Install VPN and Proxy

Instalare Wireguard si Squid cu Adguard

=====================

In cadrul acestui tutorial vom seta un server VPN Wireguard, un server PROXY Squid si un server DNS Adguard.
La aceste servere va veti conecta de pe PC-ul cu windows sau linux sau direct pe telefonul cu android, f posibil sa mearga si pe iphone, nu am, nu am cum sa testez.
Ce este important de retinut este faptul ca toate serviciile sunt criptate cu certificat SSL! Serverul adguard va avea niste filtre care vor bloca reclamele de pe orice site, mai putin youtube, pt youtube avem alta solutie aici
Deci indiferent de cum va conectati veti avea totul secure si filtrat prin intermediul Adguard.

In locatia unde instalezi ce se va explica aici (cu docker) trebuie sa ai ip public si un DNS. Ex: example.com
Se forwardeaza din router (sau security group daca e vps in cloud) porturile catre linuxul unde vor rula serviciile:

- 443/tcp (pt nginx)
- 51820/udp (pt wireguard)
- 853/tcp (pt DNS-over-TLS)
- 19504/tcp (pt squid, folosim un port non standard)

De asemeni pt configurare adguard de la zero veti avea nevoie si de 3000. Voi explica mai jos ca puteti folosi adguard-ul meu gata configurat si nu mai este nevoie.
Ca sa functioneze acest setup, va trebui ca pe VPS-ul unde puneti aceste servicii sa schimbati DNS-ul linuxului cu adguard si ca sa fie functional veti avea nevoie de asemeni si de dnsmasq, este obligatoriu.
Eu am pus aceasta solutie pe un server free de la oracle cloud care din pacate este cu arm64 dar e testat si functional. Evident ca merge si pe orice linux x86_64
Pe ubuntu trebuie oprit systemd-resolved.service si dezactivat insa nu de la inceput si cam pe orice linux procedura este similara:

$ systemctl stop systemd-resolved
$ systemctl mask systemd-resolved

Eu am pus totul cu root, recomandat este sa se foloseasca totusi un user separat.
Se da allow din firewall pe masina la aceste porturi (iptables, ufw, depinde ce ai).
Exemplu basic iptables pt custom ports exista aici

In /root creati urmatoarele 5 foldere:

$ cd /root
$ mkdir dnsmasq adguard squid wg-easy nginx

In fiecare folder va exista un fisier start.sh cu drepturi execute si fisierele si subfoldere aditionale.
Se instaleaza docker pe linuxul respectiv, e mai simplu asa, ce este de explicat aici va fi integral docker:

$ apt install docker.io -y

(deci daca ai ubuntu/debian pachetul este docker.io, daca ai fedora/centos exista repo special pt docker-ce)

O sa luam cele 5 foldere pe rand:

DNSmasq

Va duceti in folder prima data si ramaneti acolo.
In acest folder veti avea nevoie de dnsmasq.conf care se creeaza automat ruland acest fisier:
il puteti crea cu numele generare_conf.sh:

$nano generare_conf.sh

#!/bin/bash

# Output file
output_file="dnsmasq.conf"

echo "" > "$output_file"
echo -e "no-resolv\nserver=127.0.0.1#5353" > "$output_file"

# Get network interfaces
interfaces=$(ip link show | grep -E 'eth[0-9]+|ens[0-9]+|enp[0-9]+|docker[0-9]+|br-'| grep -v veth|awk -F ': ' '{print $2}')

for interface in $interfaces; do
echo "interface=$interface" >> "$output_file"
done
ipuri=$(ip a | grep -E 'eth[0-9]+|ens[0-9]+|enp[0-9]+|docker[0-9]+|br-'| grep -v veth|grep inet|awk '{print $2}'|cut -d/ -f1|tr "\n" ","|sed 's/.$//')
echo "listen-address="$ipuri >> "$output_file"

Il faceti executabil ca dealtfel toate fisierele .sh ce vor urma cu chmod +x generare_conf.sh si il rulati din folderul respectiv adica /root/dnsmasq cu ./generare_conf.sh
Imediat dupa ce l-ati rulat o sa vedeti ca s-a creat fisierul dnsmasq.conf care la mine ca exemplu arata asa:

no-resolv
server=127.0.0.1#5353
interface=enp0s3
interface=docker0
interface=br-f1945aa7d16f
listen-address=10.0.0.112,172.17.0.1,192.168.11.1

Ce face generare_conf.sh, pai citeste numele interfetelor pe care le aveti cu niste conditii si IP-urile care trebuie si le aranjeaza in asa fel in fisierul dnsmasq.conf astfel incat serverul dnsmasq sa il citeasca corect.

Dupa ce ati oprit serviciul systemd-resolved (am scris mai sus), trebuie sa puneti o singura data in /etc/resolv.conf:

$ cat /etc/resolv.conf
nameserver 127.0.0.1

Fisierul start.sh care apeleaza si generarea dnsmasq.conf de mai sus:

$ nano start.sh

#! /bin/bash
/root/dnsmasq/generare_conf.sh
sleep 5

if test -f /root/dnsmasq/dnsmasq.conf; then

docker run -d --name dnsmasq \
--restart unless-stopped \
--network=host \
--cap-add=NET_ADMIN \
-v /root/dnsmasq/dnsmasq.conf:/config/dnsmasq.conf \
dpvduncan/dnsmasq

fi

Din folderul /root/dnsmasq porniti containerul cu ./start.sh si ulterior verificati daca a pornit containerul, loguri samd.

Adguard

Va duceti in folder prima data si ramaneti acolo.
Creati 2 subfoldere confdir si workdir si apoi start.sh

$ nano start.sh

docker run -d \
--name adguard --dns 1.1.1.1 \
--restart unless-stopped \
-v /root/adguard/workdir:/opt/adguardhome/work \
-v /root/adguard/confdir:/opt/adguardhome/conf \
-v /opt:/etc/ssl \
-p 5353:53/tcp -p 5353:53/udp -p 8080:80/tcp -p 3000:3000/tcp -p 3001:3001/tcp -p 8531:853/tcp \
adguard/adguardhome

Ca sa instalati si sa configurati adguard trebuie sa accesati prima data serverul pe portul 3000 dupa care pe 8080 pt toate setarile care nu sunt putine insa trebuie sa acceptati din firewall portul 3000, sa accesati si sa configurati manual mai intai.
Pt a evita treaba asta o sa pun o arhiva cu toate folderele inclusiv adguard cu tot ce contine, cu ce upstream DNS folosesc eu, setari, filtre, DNS custom samd si administrarea se va face pe 8080, ma rog, prin intermediul nginx care se va explica mai jos.
Daca vreti sa folositi cum am setat eu va logati cu user: adguard si parola1234.
Din folderul /root/adguard porniti containerul cu ./start.sh si ulterior verificati daca a pornit containerul, loguri samd.

Inainte de a trece mai departe, avand in vedere ca deja dnsmasq si adguard ruleaza si este configurat indiferent de metoda, ar trebui sa va rezolve DNS-ul pe host, verificati orice site cu nslookup, ping etc.

Adguard stie si conexiuni DNS securizate, DoT si DoH, DoT trece prin HAProxy iar DoH prin nginx. Se va explica mai jos la fiecare, care cum si in ce fel.
DoQ nu folosesc, nici nu stiu cum poate fi folosit, am citit teorie ca merge de udp insa practic cum poti beneficia de el nu am inteles...

DNS-over-TLS. Se poate activa si pe telefonul mobil puneti privateDNS si va conectati permanent prin DoT la serverul adguard.
Pur si simplu scrieti FQDN si telefonul se conecteaza by default la server dot prin tcp 853. Exista pe net servere de genul asta la liber de ex one.one.one.one dar nu aveti filtre. Ca sa activati, nu mai merge cu certificat wildcard ci trebuie generat certificat LetsEncrypt wildcard pt dot plus wildcard pt subdomeniu. securedns.xxx-yyy-zzz.example.com sa zicem.
Generati cu certbot, am mai explicat prin mai multe locuri pe aici, mai spun o data pe scurt si in pagina asta:

certbot certonly --preferred-chain "ISRG Root X1" --manual --preferred-challenges dns --expand \
-d "securedns.xxx-yyy-zzz.example.com" \
-d "*.securedns.xxx-yyy-zzz.example.com"

Va pune sa faceti in zona DNS o inregistrare TXT record. O faceti, va asigurati ca s-a updatat si dati Enter, aia e tot, se genereaza cetificatul pe care il puneti pe host in /opt (deci cele 2 fisiere generate fullchain si privkey).
Va duceti in Adguard la Encryption Settings si completati exact asa:
- Enable Encryption (bifat)
- Enable plain DNS (bifat) trebuie sa ramana bifat pt DNS normal pe udp 53
- Server name: dot.example.com
- Redirect to HTTPS automatically (debifat pt ca se ocupa nginx)
- la porturi DoT si quick trebuie sa ramana 853 tcp insa pt DoH (vezi mai jos) la HTTPS schimbati 443 cu 3001
- Certificates -file path si puneti calea /etc/ssl/fulldot.pem
- Private key -file path si puneti calea /etc/ssl/privdot.pem
Save configuration

La Setings/DNS settings trebuie declarate IP-urile interne de unde dati acces la clienti pe udp 53 si tot acolo trebuie sa declarati clientii care vor folosi pe telefoane dot pe tcp 853.
Eu am pus cam toate clasele de telefonie mobila RO, daca nimereste cineva FQDN nu are ce sa va fure. Recomand la 3 luni cand expira certificatele sa folositi alt FQDN, apropo subdomeniu se poate face cu 63 de caractere: litere, cifre si caracterul minus. dot.example.com era un exemplu, in realitate am FQDN absolut imposibil de retinut de 63 de caractere.
Evident ca va trebui sa declarati si IP-ul public de acasa, vecini, rude samd ca sa va mearga wifi. Pt acasa am un mic script bash care imi schimba IP-ul direct in fisierul de configurare Adguard si da restart automat la container, la altii mai complicat....oricum solutia este foarte solida, eu ma conectez la wifi numai la mine acasa, la altii nu, raman pe netul meu.

Nota: Este mult mai eficient sa declarati clasele de IP-uri acceptate direct din firewall, iar in adguard lasati allow all.
Iata cum am eu pe iptables clasic, pe distributiile moderne este cu nftables sau direct ufw, pt acest tutorial va arat cum se face cu iptables-legacy:

# Reguli DoT (lista ACL)
#  Local
iptables -A INPUT -p tcp --dport 853 -s 172.17.0.0/26 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 172.19.10.0/24 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 192.168.11.0/28 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 192.168.0.0/24 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 192.168.5.0/24 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 192.168.7.0/29 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 10.6.0.0/24 -j MARK --set-mark 1
# Telekom
iptables -A INPUT -p tcp --dport 853 -s 178.138.0.0/16 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 89.33.32.0/21 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 89.33.48.0/21 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 193.104.247.0/24 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 193.186.4.0/24 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 85.120.83.0/24 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 85.121.35.0/24 -j MARK --set-mark 1
# Vodafone
iptables -A INPUT -p tcp --dport 853 -s 213.233.64.0/18 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 46.97.0.0/16 -j MARK --set-mark 1
# Orange
iptables -A INPUT -p tcp --dport 853 -s 109.166.128.0/17 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 92.180.0.0/17 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 93.122.128.0/17 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 37.251.208.0/20 -j MARK --set-mark 1
# Digi
iptables -A INPUT -p tcp --dport 853 -s 86.120.0.0/13 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 5.12.0.0/14 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 188.24.0.0/15 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 82.76.0.0/14 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 84.232.128.0/17 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 82.137.0.0/18 -j MARK --set-mark 1
# IP-uri fixe rude/vecini
iptables -A INPUT -p tcp --dport 853 -s 11.22.33.44/32 -j MARK --set-mark 1
iptables -A INPUT -p tcp --dport 853 -s 55.66.77.88/32 -j MARK --set-mark 1

# 2. BLACK-LIST (REJECT) - Cine NU e in ACL, REJECT!
iptables -A INPUT -p tcp --dport 853 -m mark ! --mark 1 -j REJECT --reject-with icmp-port-unreachable

# 3. LIMITARI (Se aplica DOAR celor din ACL)
iptables -A INPUT -p tcp --dport 853 -m connlimit --connlimit-above 20 --connlimit-mask 32 -j REJECT
iptables -A INPUT -p tcp --dport 853 -m state --state NEW -m hashlimit --hashlimit 150/min --hashlimit-burst 20 --hashlimit-mode srcip --hashlimit-name dot853rl -j ACCEPT

# 4. ACCEPT FINAL (Pentru pachetele legitime si conexiunile stabilite)
iptables -A INPUT -p tcp --dport 853 -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -p tcp --dport 853 -m state --state NEW -j REJECT

Nota* Pt ca DoT sa functioneze, este nevoie si de HAProxy, explic imediat mai jos ce trebuie facut.

Se poate activa si DNS-over-HTTPS. Certificatul generat pt DoT merge si pt DoH, este acelasi certificat.
Utilitatea este ca se poate folosi pe windows in browsere, eu folosesc firefox insa se poate folosi si in brave/chrome.
In primul rand veti avea nevoie de un nginx vhost pt treaba asta, spre deosebire de DoT care pur si simplu trece prin haproxy doar cu tcp redirect, nu rupe SSL acolo, DoH merge prin nginx si tot aici face si SSL Termination.
Mai jos la sectiunea nginx se explica mai multe, includeti si acest fisier doh.conf pe langa ce este explicat acolo
Ca sa va feriti de scanere, puneti alt port in loc de 443 si in URL recomand ceva random dupa /dns-query:

server {
    listen 8443 ssl http2;
    server_name securedns.xxx-yyy-zzz.example.com;

    ssl_certificate     /etc/ssl/fulldot.pem;
    ssl_certificate_key /etc/ssl/privdot.pem;

    # DoH
    location /dns-query/b6sk0w1rx7sl5azg2 { #randomizare url anti scanere
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Connection "";
        proxy_pass https://127.0.0.1:3001/dns-query;   # <- HTTP intern (port 3000)

        proxy_ssl_server_name on;
        proxy_ssl_name securedns.xxx-yyy-zzz.example.com;
    }

    # Respinge calea veche, fara sufix
    location = /dns-query {
        return 403;
    }

    # Respinge orice alt sufix (/dns-query/aaa, /dns-query/orice)
    location /dns-query {
        return 403;
    }

    location = / {
        return 404;
    }
}

Daca cumva folositi un nume f lung cum am scris mai sus, nginx va da eroare si pt a remedia trebuie in nginx.conf (configul global) urmatoarea directiva:

http {
server_names_hash_bucket_size 128;
........

Deci la sectiunea Encryption Settings in Adguard trebuie sa va asigurati ca aveti exact asa:

Setari Firefox:

about:preferences#privacy
scroll pana la DNS over HTTPS/Max protection/choose provider custom:
https://securedns.xxx-yyy-zzz.example.com/dns-query/doh

about:networking#dns
vedeti acolo DoH URL si in coloana TRR trebuie sa scrie true in dreptul siteului vizitat.

Setari Chrome:

Settings/Privacy and Security/Security/Select DNS provider/Add custom DNS service provider si pui URL-ul:
https://securedns.xxx-yyy-zzz.example.com/dns-query/doh

Diferenta fata de squid (ZeroOmega sau foxyproxy) este ca aveti cu ambele resolver Adguard cu filtre dar cu Squid preiei si IP public de la server, cu DoH NU.

HAProxy (pt DoT)

Faceti un folder /root/haproxy ca la restul si in folder trebuie sa aveti astea:
start.sh:

$ docker run -itd --name haproxy --memory="80m" --restart=always \
--user root --privileged --network=host --dns 1.1.1.1 \
-v /root/rtmp/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg \
-v /root/rtmp/errors:/etc/haproxy/errors \
-v /opt:/etc/ssl \
haproxy:3.2

Fisierul de configurare haproxy.cfg:

global
        #log /dev/log    local0
        #log /dev/log    local1 notice
        stats timeout 30s
        daemon

defaults
        log     global
        mode    http
        #option httplog
        option  dontlognull
        #option  http-server-close
        #option  redispatch
        timeout connect 5000
        timeout client  50000
        timeout server  50000

frontend stats
        mode http
        bind 172.27.72.2:8404
        acl allowed_pc src 172.27.72.10
        http-request deny deny_status 403 unless allowed_pc
        stats enable
        stats uri /stats
        stats refresh 10s
        stats admin if allowed_pc
        #stats admin if TRUE


frontend dot-vapor
    bind *:853
    mode tcp

    # Stick-table generos
    stick-table type ip size 1k expire 10m store conn_cur
    tcp-request connection track-sc0 src
    tcp-request connection reject if { sc0_conn_cur gt 300 }

    timeout client 45s
    timeout client-fin 45s
    default_backend dot-vapor-backend

backend dot-vapor-backend
    mode tcp
    server adghome 127.0.0.1:8531
    timeout server 60s

Aveti nevoie si de un subfolder errors ca sa functioneze, valabil pt orice haproxy:

$ ls errors
400.http 403.http 408.http 500.http 502.http 503.http 504.http

HAProxy nu are treaba cu SSL termination, doar face redirect si are mici protectii suplimentare care vin peste cele declarate in firewall.

Exista totusi un minus daca folositi haproxy: Nu mai vedeti separat telefoanele care se conecteaza pt ca toate conexiunile vin de la haproxy care nu stie sa parseze headerele mai departe.
Solutia este sa folositi un subdomeniu pt fiecare telefon in parte. Deci in zona DNS trebuie sa creati aceste inregistrari care sa pointeze catre server, logic. Exemplu:
mihai-oneplus11.securedns.xxx-yyy-zzz.example.com
vlad-samsunga57.securedns.xxx-yyy-zzz.example.com
marius-samsungs26ultra.securedns.xxx-yyy-zzz.example.com
alin-oppofindx8.securedns.xxx-yyy-zzz.example.com

De asemeni in adguard la Client settings trebuie sa creati clientii cu acelasi nume: Exemplu:
New Client: Name: [dot] mihai, Tags: (nu umblati), Identifier: mihai-oneplus11
Fiecare client pe telefon va trebui sa puna numele complet la privateDNS cu tot cu prefix de ex: mihai-oneplus11.securedns.xxx-yyy-zzz.example.com, iar varianta FARA prefix securedns.xxx-yyy-zzz.example.com nu trebuie sa mai functioneze, ea ramane valabila strict numai pt DoH.

Scenariu cu mai multe backend-uri Adguard

Eu am 3 servere cu adguard configurate identic si pt redundanta folosesc o masina nanode unde de asemeni am un haproxy, acolo este ultima versiune haproxy 3.4. Este LTS, e bine sa fie cat mai noua.
Sunt diferente mari in config, mult mai complex:

global
        user root
        chroot /
        pidfile /var/run/haproxy.pid
        #log /dev/log    local0
        log stdout format raw local0 debug
        log /dev/log    local1 notice
        tune.bufsize 65536
        tune.maxrewrite 16384
        stats timeout 40s
        maxconn 20000
        daemon

resolvers mydns
    nameserver dns1 1.1.1.1:53
    nameserver dns2 9.9.9.9:53
    resolve_retries 3
    timeout retry 1s
    hold valid 10s
    hold other 30s
    hold refused 30s
    hold nx 30s
    hold timeout 30s

defaults
        log     global
        mode    http
        option tcplog
        option  dontlognull
        #option  http-server-close
        #option  redispatch
        timeout connect 5000
        timeout client  300000
        timeout server  300000

frontend stats
        bind 0.0.0.0:8404
        stats enable
        stats uri /stats
        stats refresh 10s
        stats admin if TRUE
        stats show-version

frontend dot-nanode
    bind *:853
    mode tcp

    # Stick-table generos pentru 15 utilizatori
    stick-table type ip size 100k expire 10m store conn_cur,conn_rate(10s),bytes_out_rate(10s)
    tcp-request connection track-sc0 src
    # Limite ajustate pentru 15 utilizatori
    acl too_many_conn sc0_conn_cur gt 50
    acl too_fast_conn sc0_conn_rate gt 100
    acl too_much_data sc0_bytes_out_rate gt 300000

    tcp-request connection reject if too_many_conn
    tcp-request connection reject if too_fast_conn
    tcp-request connection reject if too_much_data

    # Whitelist SNI + limitare per prefix
    tcp-request inspect-delay 5s
    tcp-request content reject unless { req.ssl_hello_type 1 } { req.ssl_sni -i -f /usr/local/etc/haproxy/dot_clients.txt }
    tcp-request content set-var(sess.cli) req.ssl_sni,lower,field(1,.)
    tcp-request content track-sc1 req.ssl_sni,lower table sni_track
    tcp-request content reject if { sc1_conn_cur gt 20 }
    tcp-request content accept

    # Timeout-uri generoase pentru DoT pe mobile
    timeout client 45s
    timeout client-fin 45s

    # Log cu prefixul clientului
    log-format "%ci:%cp [%t] %f %b/%s %Tw/%Tc/%Tt %B %ts %ac/%fc/%bc/%sc/%rc %sq/%bq cli=%[var(sess.cli)]"
    
    default_backend dot-nanode-backend

backend dot-nanode-backend
    mode tcp
    option redispatch 1
    retries 3
    timeout connect 2s
    timeout server 60s
    default-server check check-ssl verify none inter 2s fastinter 1s downinter 5s fall 2 rise 5 observe layer4 error-limit 1 on-error mark-down resolvers mydns resolve-prefer ipv4
    server alpha fqdn1.go.ro:853
    server vapor fqdn2.go.ro:853
    server xeon fqdn3.go.ro:853

backend sni_track
    stick-table type string len 80 size 1k expire 20m store conn_cur,conn_rate(60s)

Va fi nevoie si de un fisier txt incarcat de config: dot_clients.txt care trebuie sa contina toti clientii exact asa:

mihai-oneplus11.securedns.xxx-yyy-zzz.example.com
vlad-samsunga57.securedns.xxx-yyy-zzz.example.com
marius-samsungs26ultra.securedns.xxx-yyy-zzz.example.com
alin-oppofindx8.securedns.xxx-yyy-zzz.example.com

Cum vedeti in log:

11.11.22.22:38606 [21/Oct/2026:11:54:38.744] dot-nanode dot-nanode-backend/vapor 118/35/14292 1280 -- 2/2/1/0/0 0/0 cli=mihai-oneplus11
22.22.33.33:55358 [21/Oct/2026:11:54:44.343] dot-nanode dot-nanode-backend/alpha 8/24/10349 4184 -- 1/1/0/0/0 0/0 cli=vlad-samsunga57
22.22.33.33:56342 [21/Oct/2026:11:54:57.123] dot-nanode dot-nanode-backend/alpha 9/23/10918 512 -- 2/2/1/0/0 0/0 cli=vlad-samsunga57
33.33.44.44:42944 [21/Oct/2026:11:55:09.856] dot-nanode dot-nanode-backend/xeon 9/35/11485 4218 -- 4/4/3/2/0 0/0 cli=marius-samsungs26ultra
44.44.55.55:32609 [21/Oct/2026:11:55:06.763] dot-nanode dot-nanode-backend/xeon 5/34/18688 1474 -- 3/3/2/1/0 0/0 cli=alin-oppofindx8
22.22.33.33:58196 [21/Oct/2026:11:55:17.527] dot-nanode dot-nanode-backend/xeon 23/36/10989 4186 -- 2/2/1/0/0 0/0 cli=vlad-samsunga57
22.22.33.33:59266 [21/Oct/2026:11:55:28.590] dot-nanode dot-nanode-backend/vapor 9/31/10823 4186 -- 2/2/1/1/0 0/0 cli=vlad-samsunga57
44.44.55.55:60437 [21/Oct/2026:11:56:05.643] dot-nanode dot-nanode-backend/xeon 11/27/10643 816 -- 1/1/0/0/0 0/0 cli=alin-oppofindx8
33.33.44.44:42958 [21/Oct/2026:11:56:18.280] dot-nanode dot-nanode-backend/alpha 8/24/12122 4355 -- 2/2/1/0/0 0/0 cli=marius-samsungs26ultra

Deci vedeti IP-ul clientului si se vede clar despre ce client este vorba si de asemeni care dintre cele 3 backend-uri a rezolvat DNS requestul.
Pe baza logului se pot inventa statistici mult mai clare cu acest script de ex:

$ cat /root/haproxy/stats_dot.sh
#!/bin/bash
# Statistici HAProxy DoT per client
# Utilizare: ./stats_dot.sh [perioada]   ex: ./stats_dot.sh 24h   (implicit: tot logul)

if [ -n "$1" ]; then
  LOGS=$(docker logs --since "$1" haproxy 2>&1)
  PERIOADA="ultimele $1"
else
  LOGS=$(docker logs haproxy 2>&1)
  PERIOADA="tot logul"
fi

ora_curenta=$(date +"%H:%M:%S")

echo "########## Statistici DoT $ora_curenta ($PERIOADA) ##########"
echo

echo "=== 1. Numar de conexiuni per client (descrescator) ==="
echo "$LOGS" | grep -o 'cli=[^ ]*' | sort | uniq -c | sort -rn
echo

echo "=== 2. Volum de date trimis catre client, in MB (descrescator) ==="
echo "$LOGS" | awk '/cli=/ {for(i=1;i<=NF;i++) if($i ~ /^cli=/) c=$i; b[c]+=$(NF-4)} END {for(k in b) printf "%8.1f MB  %s\n", b[k]/1048576, k}' | sort -rn
echo

#echo "=== 3. Numar de IP-uri distincte folosite de fiecare client (partajare / schimbari de retea) ==="
#echo "$LOGS" | grep 'cli=' | awk '{split($1,a,":"); for(i=1;i<=NF;i++) if($i ~ /^cli=/) print $i, a[1]}' | sort -u | awk '{print $1}' | sort | uniq -c | sort -rn
#echo

echo "=== 3 IP-uri folosite de fiecare client (cei cu cele mai multe IP-uri primii, cel mai recent IP primul) ==="
echo "$LOGS" | grep 'cli=' | awk '
{
  split($1,a,":"); ip=a[1]
  t=$2; gsub(/[\[\]]/,"",t)
  for(i=1;i<=NF;i++) if($i ~ /^cli=/) c=$i
  key=c SUBSEP ip
  last[key]=t; n[key]++
  if (!(key in seen)) { seen[key]=1; nip[c]++ }
}
END {
  for (k in last) { split(k,p,SUBSEP); printf "%d\t%s\t%s\t%s\t%d\n", nip[p[1]], p[1], last[k], p[2], n[k] }
}' | sort -t$'\t' -k1,1nr -k2,2 -k3,3r | awk -F'\t' '
{
  if ($2 != prev) { printf "\n%s\n", $2; prev=$2 }
  printf "    %-16s ultima: %s  (%d conexiuni)\n", $4, $3, $5
}'
echo

echo "=== 4. Conexiuni per backend (descrescator) ==="
#echo "$LOGS" | grep -o 'dot-nanode-backend/[a-z0-9_-]*' | cut -d/ -f2 | sort | uniq -c | sort -rn
echo "$LOGS" | grep -o 'dot-nanode-backend/[^ ]*' | cut -d/ -f2 | sort | uniq -c | sort -rn
echo

echo "=== 5. Volum de date per backend, in MB (descrescator) ==="
echo "$LOGS" | awk '/dot-nanode-backend\// {split($0,m,"dot-nanode-backend/"); split(m[2],n," "); b[n[1]]+=$(NF-4)} END {for(k in b) printf "%8.1f MB  %s\n", b[k]/1048576, k}' | sort -rn
echo

echo "=== 6. Conexiuni respinse (NOSRV), per IP si prefix ==="
echo "$LOGS" | grep 'dot-nanode-backend/<NOSRV>' | awk '{split($1,a,":"); c="cli="; for(i=1;i<=NF;i++) if($i ~ /^cli=/) c=$i; print a[1], c}' | sort | uniq -c | sort -rn
echo

Il puteti pune in cron sa genereze un fisier txt o data la jumatate de ora si fisierul ala il atasati la un nginx vhost sa il cititi din browser:

1,31 * * * * /usr/bin/flock -n /var/lock/stats.lock /bin/bash /root/haproxy/stats_dot.sh > /root/rtmp/nginx/html/statsdot.log 2>&1

Si vhostul trebuie sa arate ceva de genul, numai de la un trusted IP incarca, de la oricine altcineva e protejat cu .htpasswd:

server {
    listen 443 ssl;
    server_name statistics-dot.example.com;

    ssl_certificate     /etc/ssl/fullchain.pem;
    ssl_certificate_key /etc/ssl/privkey.pem;

    # Tot traficul protejat cu IP whitelist + auth_basic
    location = /statsdot.log {
    satisfy any;

    allow 11.22.33.44;
        deny all;

        auth_basic           "Restricted";
        auth_basic_user_file /etc/nginx/parole/.htpasswd;

    root html;
    default_type text/plain;
    types { } 
    }
}

In felul asta daca VPS nanode e ok si nu pica, chiar este foarte stabil, nu vei avea nicio problema daca un nod din spate pica, ii dai restart, sau ti se schimba IP public samd, totul este deja acoperit.
Deci si daca se schimba IP public de la oricare din nodurile din backend, nu e nevoie de niciun reload la container, se face automat pe baza resolvers mydns.
Conditia pusa numai pe prefix se aplica numai pe acest LB HA, pe haproxy-urile locale nu mai este necesara.
Ce am explicat mai sus legat de firewall cu clasele permise DoT se muta pe VPS, pe noduri nu trebuie decat allow de la IP-ul VPS-ului si atat!

Squid

Va duceti in folder prima data si ramaneti acolo.
Squid se poate restrictiona sa functioneze pe baza de trusted IP insa in situatia aceasta este mai bine pe baza de htpasswd. Asa va puteti genera continutul fisierului passwords.new cu user si parola criptata:

apt install -y apache2-utils
htpasswd -B -C 12 -c /root/squid/passwords.new gogudelagaze
echo "gogudelagaze parolagenerata" | docker exec -i squid /usr/lib/squid/basic_ncsa_auth /etc/squid/passwords.new

Va sfatuiesc sa folositi o parola cu multe caractere, caractere speciale, cifre etc si cu ultima comanda verificati.

Fisierul de configurare squid.conf care nu necesita nicio modificare decat port daca il rulati cu network host (recomandat pt o performanta mult mai buna):

acl localnet src 10.0.0.0/8     # RFC1918 possible internal network
acl localnet src 172.16.0.0/12  # RFC1918 possible internal network
acl localnet src 192.168.0.0/16 # RFC1918 possible internal network
acl localnet src fc00::/7       # RFC 4193 local private network range
acl localnet src fe80::/10      # RFC 4291 link-local (directly plugged) machines

acl SSL_ports port 443
#acl SSL_ports port 1025-65535
acl SSL_ports port 5443
acl SSL_ports port 8443
acl SSL_ports port 8919
acl SSL_ports port 21222        #port ftp (pt TC)
acl SSL_ports port 2126
acl SSL_ports port 50000-50101  #port ftp pasiv (pt TC)
acl Safe_ports port 80          # http
acl Safe_ports port 21          # ftp
acl Safe_ports port 443         # https
acl Safe_ports port 70          # gopher
acl Safe_ports port 210         # wais
acl Safe_ports port 1025-65535  # unregistered ports
acl Safe_ports port 280         # http-mgmt
acl Safe_ports port 488         # gss-http
acl Safe_ports port 591         # filemaker
acl Safe_ports port 777         # multiling http
acl CONNECT method CONNECT

auth_param basic program /usr/lib/squid/basic_ncsa_auth /etc/squid/passwords.new
auth_param basic realm my-proxy-name
acl authenticated proxy_auth REQUIRED

http_access deny !Safe_ports

# Deny CONNECT to other than secure SSL ports
http_access deny CONNECT !SSL_ports

# Only allow cachemgr access from localhost
http_access allow all manager
http_access deny manager

# We strongly recommend the following be uncommented to protect innocent
# web applications running on the proxy server who think the only
# one who can access services on "localhost" is a local user
http_access deny to_localhost

#
# INSERT YOUR OWN RULE(S) HERE TO ALLOW ACCESS FROM YOUR CLIENTS
#

# And finally deny all other access to this proxy
http_access allow authenticated
#http_access allow localnet authenticated #daca activez asta in locul aleia de deasupra, trebuie sa ai ip declarat sus de tot acl localnet
#http_access deny all #pt claritate ar trebui activata dar oricum ce e deasupra blocheaza corect, deci nu e musai necesar

# Squid normally listens to port 3128
#http_port 3128
http_port 19505
https_port 19504 cert=/etc/squid/squid.pem

# Uncomment and adjust the following to add a disk cache directory.
cache_dir null /tmp

#Default:
# access_log daemon:/var/log/squid/access.log squid
access_log none

# cache_log /var/log/squid/cache.log
cache_log /dev/null

#adaugate din squid fedora
reply_header_access Via deny all
reply_header_access X-Forwarded-For deny all
icp_port 3130
forwarded_for off

# Leave coredumps in the first cache dir
coredump_dir /var/spool/squid

# store_id_bypass on
cache deny all
refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
refresh_pattern (Release|Packages(.gz)*)$      0       20%     2880
refresh_pattern .               0       20%     4320

#some protection from squid irc
request_header_access Via deny all
request_header_access X-Forwarded-For deny all
reply_header_access Via deny all
reply_header_access X-Forwarded-For deny all
icp_port 3130
forwarded_for off

Creati start.sh

$ nano start.sh

docker run -d \
--name squid --dns 127.0.0.1\
--network=host \
--memory="1g" --restart=always \
-v /root/squid/squid.conf:/etc/squid/squid.conf \
-v /root/squid/squid.pem:/etc/squid/squid.pem \
-v /root/squid/passwords.new:/etc/squid/passwords.new \
-v /root/squid/entrypoint.sh:/entrypoint.sh \
-v /root/squid/run:/run \
squid-ssl:local /entrypoint.sh

Mai trebuie sa creati subfolder run (unde va rula squid.pid) si inca un fisier entrypoint.sh care trebuie sa fie executabil:

$ cat entrypoint.sh #!/bin/bash
rm -f /run/squid.pid
exec squid -N -f /etc/squid/squid.conf

$ chmod +x /root/squid/entrypoint.sh

Fara schema asta cu entrypoint, la restart containerul squid intra intr-un restart loop si fix-ul asta rezolva.

Observati ca este folosit un certificat. Este certificat LetsEncrypt bundle generat cu lipirea celor 2 fisiere certificat:

$ cat fullchain.pem privkey.pem > /opt/squid.pem

Observati de asemeni si o imagine squid-ssl:local pe care am compilat-o, este ultimul squid 7.7 cu suport full SSL si cu tot ce trebuie.

Fisierul Dockerfile arata exact asa:

FROM ubuntu:24.04
ARG SQUID_VER=7.7
ARG SQUID_TAG=SQUID_7_7
ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    libssl-dev \
    libldap2-dev \
    libpam0g-dev \
    libdb-dev \
    libexpat1-dev \
    libcppunit-dev \
    pkg-config \
    libkrb5-dev \
    libnetfilter-conntrack-dev \
    libxml2-dev \
    libcap2-dev \
    libsystemd-dev \
    perl \
    xz-utils \
    ca-certificates \
    curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /usr/src
RUN curl -fsSL -o squid-${SQUID_VER}.tar.xz \
      https://github.com/squid-cache/squid/releases/download/${SQUID_TAG}/squid-${SQUID_VER}.tar.xz && \
    tar xf squid-${SQUID_VER}.tar.xz && \
    cd squid-${SQUID_VER} && \
    ./configure \
      --prefix=/usr \
      --localstatedir=/var \
      --libexecdir=/usr/lib/squid \
      --datadir=/usr/share/squid \
      --sysconfdir=/etc/squid \
      --with-default-user=proxy \
      --with-logdir=/var/log/squid \
      --with-pidfile=/var/run/squid.pid \
      --with-openssl \
      --enable-ssl-crtd \
      --enable-auth-basic \
      --enable-auth-digest \
      --enable-auth-negotiate \
      --enable-auth-ntlm \
      --enable-external-acl-helpers \
      --enable-cache-digests \
      --enable-follow-x-forwarded-for \
      --enable-storeio=ufs,aufs,diskd,rock \
      --enable-delay-pools \
      --enable-linux-netfilter \
      --enable-removal-policies=lru,heap && \
    make -j$(nproc) && make install && \
    cd / && rm -rf /usr/src/squid-*

RUN mkdir -p /var/log/squid /var/cache/squid /var/spool/squid && \
    chown -R proxy:proxy /var/log/squid /var/cache/squid /var/spool/squid

CMD ["squid", "-N", "-f", "/etc/squid/squid.conf"]

Dupa ce aveti fisierul Dockerfile, build-uiti imaginea:

$ docker build -t squid-ssl:local .

Din folderul /root/squid porniti containerul cu ./start.sh si ulterior verificati daca a pornit containerul, loguri samd.
Din pacate acest squid securizat se poate folosi numai in browser (zero omega sau foxyproxy), in orice alta aplicatie nu prea. Nici in TC nu merge pt ca stie doar HTTP connect, nici filezilla client si orice fel de client de orice fel stie proxy dar NU securizat. Deci in squid.conf pe langa 19504 cu certificat am lasat si 19505 http simplu ca nu se stie niciodata cand ai nevoie.

Wireguard

Din pacate wireguard cu docker merge prost, exista wg-easy f cunoscut insa in ultimii 3 ani l-am tot testat, nu e ce trebuie, pierzi viteza, nu e OK. Chiar si pornit cu network host mi se pare ca nu e la fel de light.

Pe o conexiune gigabit unde la speedtest am la download in jur de 900, 950 mbps, cu wg-easy(docker) am cam 450 mbps iar cu solutia urmatoare chiar depasesc 800 mbps la download. Cu ultima versiune pornita cu network host atingi si 650, parca nu mai e asa de mare diferenta dar TOT NU E LA FEL!

Se instaleaza wireguard pe linuxul respectiv, deci trebuie sa fie functional, initial fara niciun fisier de configurare dar sa fie instalat.

$ apt install wireguard wireguard-tools

Obligatoriu trebuie iptables, este mai sus un link catre un exemplu.

Trebuie creata o structura de foldere dupa cum urmeaza:

$ mkdir /root/wgfiles
# mkdir /root/wgtest

Se vor folosi mai multe fisiere care trebuie sa se afle in wgfiles. Arhiva cu toate fisierele aici. In principiu ca sa faceti cli fisierele sunt gen.sh, del.sh si mai exista si included.sh.
In /root/wgfiles e destul de complicat cu drepturile:
/root/wgtest/sessions chown 82:82 si chmod 700 si fisierele 82:82 600
/root/wgfiles 82:82 755 si fisierele 82:82
seqno.txt 82:82 777
wgui.lock 82:82 666
gen.sh, del.sh 82:82 755
restul fisierelor 82:82 644 (inclusiv peers.conf)
exceptii cu root: mon1,2,3.txt root 644
monitor.sh root 700
server.key root 600

Este foarte important dupa ce puneti gen.sh sa il editati (temporar) si sa editati la inceput LOCK="/usr/share/nginx/html/wgui.lock" in LOCK="/root/wgfiles/wgui.lock" ca sa rulati o data pe host.
Fisierele pe care le va genera le pastrati, nu le suprascrieti cu cele din arhiva. Fisierele sunt urmatoarele:
extnetif.txt, fwtype.txt, intnetaddress.txt, intnetdns.txt, intnetmtu.txt, seqno.txt, wgui.lock, extnetip.txt, intnetallowedips.txt, intnetmask.txt, portno.txt, sysctltype.txt
Dupa generare puneti variabila la loc.

Nota* In Adguard se trece si IP-ul 192.168.66.1 la lista de IP-uri permise.
De asemeni in dnsmasq.conf (docker) trebuie refacut dnsmasq.conf:
-se adauga interface=wghub si jos la listen-address se pune si 192.168.66.1
si apoi se restarteaza containerul dnsmasq

Pt administrarea asta va trebuie sa puneti un php custom SPECIAL pt treaba asta, daca pe serverul respectiv mai aveti alt php, trebuie sa fie separate. Daca aveti alt nginx, se poate folosi, va contine doar un chost separat.

Explic mai jos cum se pornesc aceste containere.
Pt ca modificrile sa se ia in seama, se face cu systemd watcher, aveti in arhiva subfolderul systemd-system.

Nginx

Va duceti in folderul nginx prima data si ramaneti acolo.
Aici creati subfolderul conf.d in care veti avea 2 fisiere: adguard.conf si wg.conf. Creati de asemeni si subfolder cert.
Aceste 2 vhosturi vor folosi certificate LetEncrypt care se genereaza cu mai multe metode, puteti cauta exemplu aici
Indiferent de metoda, se vor genera 2 fisiere, recomand sa fie certificat wildcard pt ca aveti nevoie de 2 inregistrari:

A wireguard.example.com 11.22.33.44 #DNS pt servicii aditionale
A adguard.example.com 11.22.33.44 #DNS pt servicii aditionale

Creati vhost-urile care arata cam asa:

$ nano /root/nginx/conf.d/adguard.conf
 server {
    listen 443 ssl;
    server_name adguard.example.com;
    ssl_certificate /etc/ssl/fullchain.pem;
    ssl_certificate_key /etc/ssl/privkey.pem;
    
#auth_basic "Private Property";
#auth_basic_user_file /etc/nginx/parole/.htpasswd;

  location / {
    proxy_pass                         http://localhost:8080;
    proxy_set_header Host              $http_host;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout                 600;
}

}

In cazul in care folositi wireguard instalat nativ pe baza solutiei prezentate mai sus, vhostul este asta:

    $ nano /root/nginx/conf.d/wg.conf
    server {
        listen 8446 ssl;
        server_name wireguard.example.com;
        
        ssl_certificate /etc/ssl/fullchain.pem;
        ssl_certificate_key /etc/ssl/privkey.pem;
        
        auth_basic "WireGuard AlphaVPS";
        auth_basic_user_file /etc/nginx/auth/.htpasswd;

        root /usr/share/nginx/html;
        index index.php;
        client_max_body_size 12m;

        location ~* (?:~|\.swp|\.swo|\.orig|\.save)$ {
            deny all;
        }

        location ~ /\. { deny all; }
        location ~* \.(conf|key|psk|sh|txt|bak)$ { deny all; }

        location / {
            try_files $uri $uri/ =404;
        }

        location ~ \.php$ {
            try_files $uri =404;
            include fastcgi_params;
            fastcgi_pass 127.0.0.1:9002;
            fastcgi_index index.php;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        }

        error_page 500 502 503 504 /50x.html;
        location = /50x.html { root /usr/share/nginx/html; }
    }

Containerul nginx ar trebui sa se porneasca in felul asta:

$ nano start.sh

docker run -itd \
--name nginx \
--restart unless-stopped \
# ce aveati deja aici adica volume samd
# si obligatoriu includeti si folderul asta:
-v /root/wgfiles:/usr/share/nginx/html/wgui:ro \
-v /opt:/etc/ssl \
--network=host \
nginx:1.25.3-alpine

Din acelasi folder /root/nginx porniti containerul cu ./start.sh si ulterior verificati daca a pornit containerul, loguri samd.

-Deschideti in browser https://adguard.example.com si revizuiti setarile, adaugati custom DNS, adaugati alte liste etc
Am specificat mai sus cum si am pus si credentialele. Vreti de la zero sa configurati, aveti mai sus explicatii.
Trebuie sa aveti mare atentie la Settings/DNS Settings la sectiunea Allowed clients unde trebuie sa adaugati ip-ul de pe VPS si clasa "retea": 192.168.11.0/28! sau 192.168.66.0/24 pt wg nativ si eventual si clasa network default 172.17.0.0/26 daca mai sunt si alte containere pe masina si vreti sa aiba resolver Adguard-ul.
-Deschideti in browser https://wireguard.example.com si creati clienti pt utilizare pe android (QR code) sau pe PC (download config file)
-Pt varianta wireguard instalata nativ veti deschide acelasi https://wireguard.example.com dar ca sa functioneze veti avea nevoie si de un container php:

PHP (pt varianta wireguard fara docker)

Se build-uieste imaginea php cu pachete aditionale, in principiu wireguard-tools si sudo nu cred ca mai sunt necesare, restul insa trebuie.

Creati folderul /root/php daca nu este creat si intrati in el:

$ docker build -t php:1 .

FROM php:8.2-fpm-alpine
WORKDIR /usr/share/nginx/html

RUN apk add --update --no-cache bash libgd libpng-dev libjpeg-turbo-dev freetype-dev icu-dev wireguard-tools sudo libqrencode libqrencode-tools

RUN docker-php-ext-install -j$(nproc) gd
RUN docker-php-ext-install -j$(nproc) opcache

RUN sed -i 's/9000/9002/' /usr/local/etc/php-fpm.d/zz-docker.conf
RUN sed -i 's/9000/9002/' /usr/local/etc/php-fpm.d/www.conf
RUN sed -i 's/9000/9002/' /usr/local/etc/php-fpm.d/www.conf.default
RUN sed -i 's/9000/9002/' /usr/local/etc/php-fpm.d/docker.conf

Ramanem in folderul /root/php si cream start.sh

$ nano start.sh

docker run -itd --name phpwg \
--restart unless-stopped \
-v /root/wgfiles:/usr/share/nginx/html \
-v /root/wgtest/php.ini:/usr/local/etc/php/php.ini:ro \
-v /root/wgtest/fpm/zz-docker.conf:/usr/local/etc/php-fpm.d/zz-docker.conf:ro \
-v /root/wgtest/sessions:/var/lib/php/sessions \
--security-opt seccomp=unconfined \
--network=host \
php:1

Fisierul index.php care se va folosi trebuie pus in /root/wgfiles unde sunt toate fisierele wireguard, php de acolo citeste:

<?php
session_set_cookie_params(['httponly' => true, 'samesite' => 'Strict']);
session_start();
if (empty($_SESSION['csrf'])) {
    $_SESSION['csrf'] = bin2hex(random_bytes(16));
}
$csrf = $_SESSION['csrf'];
error_reporting(E_ERROR | E_PARSE);

function h($s) { return htmlspecialchars((string)$s, ENT_QUOTES, 'UTF-8'); }
function valid_name($n) {
    return is_string($n) && preg_match('/^[A-Za-z0-9_-]{1,32}$/D', $n) === 1 && $n[0] !== '-';
}

// Add / Remove (doar POST + token CSRF)
if ($_SERVER['REQUEST_METHOD'] === 'POST' && in_array($_POST['action'] ?? '', ['add', 'remove'], true)) {
    if (!hash_equals($csrf, (string)($_POST['csrf'] ?? ''))) {
        http_response_code(403);
        exit('CSRF invalid');
    }
    $add  = ($_POST['action'] === 'add');
    $name = $add ? ($_POST['peerName'] ?? '') : ($_POST['peer'] ?? '');
    if (!valid_name($name)) {
        http_response_code(400);
        exit('Nume invalid (doar A-Z a-z 0-9 _ - ; max 32; fara - la inceput)');
    }
    $script = $add ? './gen.sh' : './del.sh';
    shell_exec('(cd ' . escapeshellarg(__DIR__) . ' && /bin/bash ' . $script . ' ' . escapeshellarg($name) . ') >/dev/null 2>&1 &');
    header('Refresh: 2; url=index.php');
    exit('OK, se aplica...');
}

$confContent = (string)@file_get_contents(__DIR__ . '/peers.conf');

function monitorMap() {
    static $map = null;
    if ($map !== null) return $map;
    $map = [];
    $raw = (string)@file_get_contents(__DIR__ . '/mon3.txt');
    foreach (explode("\n", $raw) as $line) {
        if (preg_match('/^Client:\s*(\S+?),\s*Endpoint:\s*(.+?),\s*Latest Handshake:\s*(.*)$/', trim($line), $m)) {
            $map[$m[1]] = ['endpoint' => trim($m[2]), 'hs' => trim($m[3])];
        }
    }
    return $map;
}

function handshakeSeconds($text) {
    $units = ['year' => 31536000, 'week' => 604800, 'day' => 86400,
              'hour' => 3600, 'minute' => 60, 'second' => 1];
    $total = 0;
    if (preg_match_all('/(\d+)\s+(year|week|day|hour|minute|second)s?/', $text, $mm, PREG_SET_ORDER)) {
        foreach ($mm as $x) $total += (int)$x[1] * $units[$x[2]];
    }
    return $total;
}

function peerStatus($name) {
    $map = monitorMap();
    if (!isset($map[$name])) {
        return '<span style="color:#888;">none</span>';
    }
    $hs = $map[$name]['hs'];
    $ep = $map[$name]['endpoint'];
    $ip = trim(preg_replace('/:\d+$/', '', $ep), '[]');

    $hsClean = trim(preg_replace('/\s*ago\s*$/', '', rtrim($hs, ', ')));
    $recent  = handshakeSeconds($hs) < 120;

    $img = $recent ? 'online.gif' : 'offline.gif';
    $alt = $recent ? 'online' : 'offline';
    $icon = '<img src="' . $img . '" alt="' . $alt . '" title="' . $alt
          . '" style="height:14px;vertical-align:middle;"> ';

    $link = '<a href="https://db-ip.com/' . rawurlencode($ip) . '" target="_blank" rel="noopener">'
          . h($ip) . '</a>';

    return $icon . h($hsClean) . ' (' . $link . ')';
}

function displayPeers($confContent, $csrf) {
    $peerID = $peerName = $peerIP = '';
    foreach (explode("\n", $confContent) as $line) {
        if (preg_match('/^# (\d+): (\S+) >/', $line, $m)) {
            $peerID = $m[1];
            $peerName = $m[2];
            $peerIP = '';
        }
        if ($peerName !== '' && strpos($line, 'AllowedIPs') !== false && preg_match('/=\s*(\S+)/', $line, $m)) {
            $peerIP = $m[1];
        }
        if ($peerName !== '' && $peerIP !== '') {
            echo '<div>ID: ' . h($peerID) . ' | Name: <b>' . h($peerName) . '</b> | IP: ' . h($peerIP) . ' | '. peerStatus($peerName) . ' ';
            echo '<form method="post" style="display:inline" onsubmit="return confirm(\'Sigur stergi acest peer?\')">'
               . '<input type="hidden" name="action" value="remove">'
               . '<input type="hidden" name="peer" value="' . h($peerName) . '">'
               . '<input type="hidden" name="csrf" value="' . h($csrf) . '">'
               . '<input type="submit" value="Remove"></form></div>';
            echo '<a href="wgclient_' . rawurlencode($peerName) . '.qrcode.png"><img width="20" src="/qrcode.png"></a>__';
            echo '<a href="download.php?file=' . rawurlencode('wgclient_' . $peerName . '.conf') . '"><img src="/download.png"></a>';
            $peerName = $peerIP = '';
        }
    }
}

?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>WireGuard Hub Management</title>
<link rel="icon" href="favicon.ico" type="image/x-icon">
<style>
body { font-family: Arial, sans-serif; background-color: #f9f9f9; margin: 0; padding: 0; min-height: 100vh; overflow-y: auto; }
.container { display: flex; flex-direction: column; justify-content: center; align-items: center; min-height: 100vh; width: 80%; padding: 20px; background-color: #fff; border-radius: 8px; box-shadow: 0 0 10px 0 rgba(0,0,0,0.1); margin: 20px auto; }
.column { width: 100%; }
h2 { color: #ff0000; }
p { margin-bottom: 10px; }
input[type="text"], input[type="submit"] { padding: 8px; margin-right: 10px; }
a { color: #ff0000; }
</style>
</head>
<body>
<div class="container"><div class="column">
<img src="/wireguard.png"><img src="vapor.png"><br>

<h2>Existing Peers:</h2>
<?php displayPeers($confContent, $csrf); ?>
<br><br>

<!--<h2>Monitoring (per minute):</h2>-->
<?php /* echo nl2br($mon); */ ?>

<h2>Add New Peer:</h2>
<form method="post" action="index.php">
<input type="hidden" name="action" value="add">
<input type="hidden" name="csrf" value="<?= h($csrf) ?>">
<label for="peerName">Peer Name:</label>
<input type="text" id="peerName" name="peerName" maxlength="32" pattern="[A-Za-z0-9_\-]{1,32}" required>
<input type="submit" value="Add New Peer">
</form>
</div></div>
</body>
</html>

Acest php apeleaza scripturile bash gen.sh si del.sh pt a crea si sterge clienti(peers) direct din pagina web.
Pt download exista si un fisier separat download.php ca sa puteti descarca peername.conf curat:

<?php
$name = basename($_GET['file'] ?? '');
if (!preg_match('/^wgclient_[A-Za-z0-9_-]{1,32}\.conf$/D', $name)) { http_response_code(404); exit('File not found.'); }
$file = __DIR__ . '/' . $name;
if (!is_file($file)) { http_response_code(404); exit('File not found.'); }
header('Content-Type: application/octet-stream');
header('Content-Disposition: attachment; filename="' . substr($name, strlen('wgclient_')) . '"');
header('Content-Length: ' . filesize($file));
header('X-Content-Type-Options: nosniff');
readfile($file);
    ?>

index.php trebuie sa aiba chown 82 sau www-data daca exista!

Se poate introduce si o pseudo monitorizare care afiseaza dedesubt ce peers sunt activi, IP de la care sunt conectati, iata un mic bash care creaza mon3.txt de asemeni apelat de index.php:

$ nano /root/wg-files/clienti.sh

#!/bin/bash

wg show wghub | \
awk ' \
/peer:/ {pid=$2} \
/endpoint:/ {endpoint=$2} \
/latest handshake:/ {handshake=$3" "$4" "$5" "$6; printf "Client: %s| Endpoint: %s| Latest Handshake: %s\n", substr(allowed, 1, length(allowed)-3), endpoint, handshake} \
/allowed ips:/ {allowed=$3}' > /root/wgfiles/mon1.txt

cat /root/wgfiles/peers.conf | egrep '.conf|AllowedIPs' | grep -v configuration | awk '{print $3}'|cut -d "/" -f1|tr "\n" " "|xargs -n 2 > /root/wgfiles/mon2.txt
#awk '/.conf|AllowedIPs/ && !/configuration/{split($3,a,"/"); printf "%s%s", a[1], (++cnt % 2 ? OFS : ORS)}' /root/wgfiles/peers.conf > /root/wgfiles/mon2.txt

while IFS="|" read -r client endpoint handshake; do
ip=$(echo $client | awk '{print $2}' | cut -d " " -f2)
name=$(grep $ip /root/wgfiles/mon2.txt | awk '{print $1}')
echo "Client: $name, $endpoint, $handshake"
done < /root/wgfiles/mon1.txt > /root/wgfiles/mon3.txt

Nici nu mai e nevoie de chown, mon3.txt poate ramane si cu root

Mai e nevoie si de scriptul asta monitor.sh care este tot in wgfiles:

#!/bin/bash
set -u

BASE="/root/wgfiles"
IFACE="wghub"

peers_file="$BASE/peers.conf"
mon1="$BASE/mon1.txt"
mon2="$BASE/mon2.txt"
mon3="$BASE/mon3.txt"

tmp1="$mon1.tmp.$$"
tmp2="$mon2.tmp.$$"
tmp3="$mon3.tmp.$$"

: > "$tmp1"
: > "$tmp2"
: > "$tmp3"

cleanup() {
    rm -f "$tmp1" "$tmp2" "$tmp3"
}
trap cleanup EXIT

# mon2: toti clientii din peers.conf, cu nume si IP
awk '
    /^# / {
        line = $0
        sub(/^# [0-9]+: /, "", line)
        sub(/ >.*/, "", line)
        name = line
        next
    }
    $1 == "AllowedIPs" {
        ip = $3
        sub(/,.*$/, "", ip)
        if (name != "" && ip != "") {
            print name " " ip
        }
        name = ""
        next
    }
' "$peers_file" > "$tmp2"

# mon1 si mon3: doar peerii care au avut handshake
wg show "$IFACE" dump | tail -n +2 | \
while IFS=$'\t' read -r pubkey psk endpoint allowed handshake rx tx keepalive; do

    name=$(awk -v key="$pubkey" '
        /^# / {
            line = $0
            sub(/^# [0-9]+: /, "", line)
            sub(/ >.*/, "", line)
            candidate = line
        }
        $1 == "PublicKey" && $3 == key {
            print candidate
            exit
        }
    ' "$peers_file")

    ip=$(printf '%s' "$allowed" | cut -d, -f1)

    if [ "$handshake" -gt 0 ]; then
        age=$(( $(date +%s) - handshake ))

        if [ "$age" -lt 60 ]; then
            human="$age seconds ago"
        elif [ "$age" -lt 3600 ]; then
            human="$((age / 60)) minutes ago"
        elif [ "$age" -lt 86400 ]; then
            human="$((age / 3600)) hours ago"
        else
            human="$((age / 86400)) days ago"
        fi

        printf 'Client: %s| Endpoint: %s| Latest Handshake: %s\n' \
            "${name:-necunoscut}" "${endpoint:-none}" "$human" >> "$tmp1"

        printf 'Client: %s,  Endpoint: %s,  Latest Handshake: %s\n' \
            "${name:-necunoscut}" "${endpoint:-none}" "$human" >> "$tmp3"
    fi
done

mv -f "$tmp1" "$mon1"
mv -f "$tmp2" "$mon2"
mv -f "$tmp3" "$mon3"

Se poate updata la 10 secunde de ex dar se complica prea mult partea de cron, la minut este suficient:

* * * * * /bin/bash /root/wgfiles/monitor.sh >/dev/null 2>&1

Pagina nu are autentificare, e simplu de facut insa nu merita efortul momentan. Securizarea consider ca este suficient facuta din nginx cu htpasswd.
Fata de varianta precedenta, wghub.conf nu mai sta in wgfiles adica folderul controlat direct de nginx si php ci sta in /etc/wireguard/wgui/wghub.php
Este nevoie de un serviciu systemd de care am amintit mai sus, este explicat in arhiva de mai sus. O sa pun totusi scriptul controlat de systemd care este responsabil cu rescrierea acestui conf chiar daca la adaugare sau stergere peer NU se opreste/porneste wireguard ci doar se face un reload dynamic. Scriptul este /usr/local/sbin/wgui-apply:

#!/bin/bash
set -euo pipefail

PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
export PATH
umask 077

IFACE="wghub"
SOURCE="/root/wgfiles/peers.conf"
BOOT="/etc/wireguard/wgui/wghub.conf"

exec 9>/root/wgfiles/wgui.lock

lock_tries=0
until flock -n -x 9; do
    lock_tries=$((lock_tries + 1))
    if (( lock_tries >= 10 )); then
        echo "Nu am putut obtine lock-ul pentru peers.conf in 10 secunde." >&2
        exit 1
    fi
    sleep 1
done

sleep 1

work=$(mktemp -d /run/wgui-apply.XXXXXX)
persist_tmp=""

cleanup() {
    rm -rf -- "$work"
    if [[ -n "$persist_tmp" ]]; then
        rm -f -- "$persist_tmp"
    fi
}
trap cleanup EXIT

cp -- "$SOURCE" "$work/source.conf"

# Sectiunea Interface provine exclusiv din configuratia root.
awk '
    /^[[:space:]]*\[Peer\][[:space:]]*$/ { exit }
    { lines[++n] = $0 }
    END {
        while (n > 0 && lines[n] ~ /^[[:space:]]*$/) n--
        for (i = 1; i <= n; i++) print lines[i]
    }
' "$BOOT" > "$work/$IFACE.conf"

# Din fisierul aplicatiei acceptam numai peeri strict validati.
awk '
function fail(message) {
    print "Configuratie refuzata: " message > "/dev/stderr"
    failed = 1
    exit 1
}

function finish_peer() {
    if (in_peer && (pub_count != 1 || psk_count != 1 || ip_count != 1)) {
        fail("peer incomplet sau campuri duplicate")
    }
}

function valid_key(value) {
    return length(value) == 44 &&
           value ~ /^[A-Za-z0-9+\/]+=$/
}

{
    line = $0
    sub(/\r$/, "", line)
    sub(/^[[:space:]]+/, "", line)
    sub(/[[:space:]]+$/, "", line)

    if (line == "" || line ~ /^#/) {
        next
    }

    if (line == "[Peer]") {
        finish_peer()
        in_peer = 1
        pub_count = psk_count = ip_count = 0
        print "\n[Peer]"
        next
    }

    # Ignoram tot ce precede primul Peer din fisierul PHP.
    if (!in_peer) {
        next
    }

    pos = index(line, "=")
    if (!pos) {
        fail("linie nepermisa intr-un peer")
    }

    field = substr(line, 1, pos - 1)
    value = substr(line, pos + 1)

    sub(/[[:space:]]+$/, "", field)
    sub(/^[[:space:]]+/, "", value)

    if (field == "PublicKey") {
        if (++pub_count != 1 || !valid_key(value)) {
            fail("PublicKey invalid sau duplicat")
        }
        if (seen_key[value]++) {
            fail("aceeasi cheie publica apare la mai multi peeri")
        }
    } else if (field == "PresharedKey") {
        if (++psk_count != 1 || !valid_key(value)) {
            fail("PresharedKey invalid sau duplicat")
        }
    } else if (field == "AllowedIPs") {
        if (++ip_count != 1) {
            fail("AllowedIPs duplicat")
        }
        if (value !~ /^192\.168\.66\.[0-9]+\/32$/) {
            fail("AllowedIPs trebuie sa fie un singur IP din 192.168.66.0/24")
        }

        split(value, parts, /[.\/]/)
        octet = parts[4] + 0

        if (octet < 2 || octet > 254 ||
            value != sprintf("192.168.66.%d/32", octet)) {
            fail("adresa client nepermisa")
        }
        if (seen_ip[value]++) {
            fail("aceeasi adresa apare la mai multi peeri")
        }
    } else {
        fail("camp nepermis: " field)
    }

    print field " = " value
}

END {
    if (!failed) {
        finish_peer()
    }
}
' "$work/source.conf" >> "$work/$IFACE.conf"

wg-quick strip "$work/$IFACE.conf" > "$work/apply.conf"

if ip link show dev "$IFACE" >/dev/null 2>&1; then
    echo "Sincronizez peer-ii validati pentru $IFACE"
    wg syncconf "$IFACE" "$work/apply.conf"
else
    echo "Pornesc $IFACE din configuratia root si peer-ii validati"
    wg-quick up "$work/$IFACE.conf"
fi

# Persistam configuratia dupa aplicarea reusita.
persist_tmp=$(mktemp /etc/wireguard/wgui/.wghub.XXXXXX)
cat "$work/$IFACE.conf" > "$persist_tmp"
chmod 600 "$persist_tmp"
chown root:root "$persist_tmp"
mv -f -- "$persist_tmp" "$BOOT"
persist_tmp=""

echo "Configuratia pentru $IFACE a fost aplicata si salvata"

Comparativ cu varianta docker wg-easy ce am facut eu aici e mai minimalist, permite generarea si stergerea clientilor din browser insa are monitorizare precara. Este destul de greu de setat insa avand in vedere sporul de performanta fata de wg-easy(docker) cu peste 50% in unele cazuri,eu cred ca a meritat tot efortul. Ca sa faci monitorizare real time nu ai cum cu php, sau nu stiu eu cum, ai nevoie de ceva syncron sa ruleze in continuu asa cum e facut wg-easy, ai nevoie de nodejs. Clar se poate face si asta insa nu acopera acest tutorial, e suficient si asa cum am facut eu, macar ai link sa verifici IP-ul clientului.

Dupa crearea unui nou client(peer) si scanarea pe telefon, aveti doua metode de restart wireguard ca sa se ia setarile in considerare, ambele functioneaza perfect.
Avand in vedere ca pt monitorizare (daca vreti sa puneti) trebuie cron-ul ala la minut, mai bine va chinuiti cu metoda2 pt restart wireguard, scapati de inca un cron, cum doriti.
Scopul proiectului este sa putem face web management cu docker pt wireguard instalat nativ.

Functionare si Mentenanta

In mod normal un setup cu 5 containere docker se pune cu docker-compose insa eu nu i-am dat de cap. Nu am reusit sa setez docker-compose.yaml sa porneasca in ordine containerele, nu inteleg ce am gresit, indiferent de ce fac nu am DNS nici in squid nici in wireguard deci nu merge nimic.
Am reusit insa in schimb sa fac un mic script bash care se asigura ca este totul in regula si indiferent de situatie porneste totul corect:

    #!/bin/bash
    upSeconds="$(cat /proc/uptime | grep -o '^[0-9]\+')"
    upMins=$((${upSeconds} / 60))
    log=/root/dockere.txt
    array=(dnsmasq adguard wg-easy squid nginx)
    
    verificare () {
    local my_array=("$@")
    echo array::::::${my_array[@]}
    if [[ $(docker inspect -f '{{.State.Running}}' ${my_array[@]}) = "false" && "${upMins}" -gt "2" ]];then
      docker start ${my_array[@]} > /dev/null 2>&1
      sleep 10
      if [[ $(docker inspect -f '{{.State.Running}}' ${my_array[@]}) = "true" ]];then
        date >> $log
        echo ${my_array[@]} "container started and RUNNING" | tee -a $log
      else
        docker stop ${my_array[@]} > /dev/null 2>&1
        sleep 2
        docker rm ${my_array[@]} > /dev/null 2>&1
        sleep 2
        date >> $log
        echo ${my_array[@]} "container stopped and removed" | tee -a $log
    
       /root/${my_array[@]}/start.sh
       date >> $log
       echo ${my_array[@]} "container started" | tee -a $log
      fi
    else
      date >> $log
      echo ${my_array[@]} "merge deci nu intervenim" | tee -a $log
    fi
    }
    
    fldr=$(docker ps -a|awk '{print $NF}'|tail -n+2|tr "\n" ","|sed 's/.$//')
    #execute
    for ((i=0; i<${#array[@]}; i++));do
    echo "===="
    
    if [[ "$fldr" == *"${array[$i]}"* ]]; then plm="ok"; else plm="ko"; fi; echo "${array[$i]} : $plm"
    
    if [[ "$plm" == "ko" ]];then
            date >> $log
            echo "container ${array[$i]} NU exista deci il pornim apeland /root/${array[$i]}/start.sh" | tee -a $log
            /root/${array[$i]}/start.sh
            sleep 5
    else
            date >> $log
            echo "container ${array[$i]} exista dar apelam verificare array[$i]" | tee -a $log
            verificare "${array[$i]}"
    fi
    
    done

Acest script se poate pune pe linux si in crontab sa ruleze singur o data la o ora sa zicem, cum e ceva in neregula se asigura ca fiecare container este up and running.
Se poate pune si la startup cand se da reboot la masina pt updates, etc. Mare atentie sa scoateti wg-easy din variabila array daca folositi wireguard instalat nativ si sa il inlocuiti cu php!

Aveti aici o arhiva cu toate folderele si fisierele pe care le-am explicat pas cu pas ce face fiecare.

Utilizare clienti

Clientul VPN wireguard se descarca de pe siteul oficial pt windows si linux iar pe telefoanele cu Android se instaleaza gratis din Google Play.
Dupa cum am explicat mai sus, pe PC se foloseste fisier de configurare iar pe Android se adauga conexiunea pe baza de QR code.

Pt cine vrea sa aiba IP schimbat si aceasta protectie doar in browser, Proxy-ul http squid se poate folosi pe baza unor extensii. Cele mai cunoscute sunt FoxyProxy (PC cam orice browser si Android doar cu firefox) iar pe PC se mai poate folosi si Switchy Omega, in opinia mea extensie ceva mai buna.
Se poate folosi in browser doar DNS-ul de tip DoH (am explicat mai sus) si diferenta este ca fata de squid, aveti aceeasi protectie Adguard dar fara sa preluati si IP-ul public.
Pt wireguard puteti folosi direct IP, nu e obligatoriu sa folositi domain (unul din cele 2 de sus), wireguard va da direct configul, insa pt squid folositi FQDN pt ca are certificat,port 19504 plus user/pass.

Avantajul folosirii acestei solutii pe PC sau pe telefon este ca aveti IP-ul de unde ruleaza serverul (in cazul meu Oracle Cloud Frankfurt Germania) si ca resolver de DNS aveti Adguard pe baza filtrelor puse de voi. In afara de youtube, nu va apare nicio reclama pe niciun site in niciun browser, deci nu veti mai fi nevoiti sa instalati adblockere in browsere.
Foarte important este faptul ca nu veti avea DNS leak, sunt o multime de servicii VPN platite prost setate care va dau IP de nush ce tara dar va da de gol DNS-ul. In cazul nostru pe langa faptul ca nu aveti leak, mai are si acele custom filters pe care le-ati setat in Adguard.
Mai mult, va puteti crea in Adguard inregistrari DNS fake care va merg numai voua, nu sunt publicate in Internet, de la Filters/DNS rewrites.
Un mic detaliu pt cine stie la ce ma refer, cu wireguard nu veti avea nici WebRTC leak, putina lume stie detaliul asta. Sunt unele siteuri care verifica deci pe partea asta squid nu poate ascunde.
Asta e asa un bonus, WebRTC se poate rezolva pe PC in firefox de la about:config media.peerconnection.enabled false iar pe orice browser based on chromium cu extensia asta si in felul asta folositi squid cu incredere, nu va da de gol. De asemeni aveti nevoie de Canvas si de inca o extensie care va protejeaza Geolocation: Vytal cu care puteti face spoof la User agent si la Location Data.
Deci pe langa IP aveti nevoie de protectie la DNS, WebRTC, Canvas fingerprint, Geolocation (timezone) si browser agent.

Pe telefoanele cu android recomand Firefox care permite instalarea de extensii. Eu folosesc uBlock Origin chiar daca oricum nu aveti reclame dar e bine sa fie, Proxy SwitchyOmega3 (ZeroOmega) si f important, Disable WebRTC (asa se numeste extensia). Pe brave din pacate va da de gol WebRTC pe telefon insa cu Firefiox, e rock solid, e ca si cum ati fi conectati la wireguard!

Happy safe browsing the internet!

Last update 2 Nov 2026.