Configurare un proxy SOCKS5 su Linux con MicroSocks

Cos’è MicroSocks e quando usarlo

MicroSocks è un piccolo proxy SOCKS5 pensato per essere leggero, veloce e facile da mettere in piedi su Linux. È utile quando ti serve un punto di uscita controllato per browser, tool di test, applicazioni che supportano SOCKS5 o automazioni che devono passare da una VPS remota.

Non è un sistema di anonimizzazione “magico” e non sostituisce una VPN. Serve a esporre un proxy minimale, con meno complessità rispetto ad alternative più pesanti. Proprio per questo è perfetto su server piccoli, container, VPS economiche e ambienti dove vuoi tenere sotto controllo ogni parametro.

In questa guida vediamo come installarlo, configurarlo, proteggerlo e testarlo in modo pratico su Linux.

Prerequisiti

• Una VPS o un server Linux con accesso root o sudo.
• Una distribuzione comune come Ubuntu, Debian, AlmaLinux, Rocky Linux o CentOS.
• Un client che supporti SOCKS5, ad esempio browser, curl, SSH o software di test.
• Se il proxy deve essere accessibile dall’esterno, un IP pubblico e una regola firewall coerente.

Assumeremo che tu voglia un proxy SOCKS5 semplice, autenticato e limitato a una sola porta, con avvio automatico al boot.

Installazione di MicroSocks

MicroSocks non sempre è disponibile nei repository standard. Il metodo più comune è compilarlo dai sorgenti. Su molte distribuzioni bastano i pacchetti di sviluppo essenziali.

Ubuntu e Debian

sudo apt update
sudo apt install -y git build-essential

AlmaLinux, Rocky Linux, CentOS

sudo dnf install -y git gcc make

Clona il progetto e compila:

git clone https://github.com/rofl0r/microsocks.git
cd microsocks
make

Se la compilazione va a buon fine, troverai il binario `microsocks` nella directory corrente. Il controllo minimo è questo:

./microsocks -h

Esito atteso: viene mostrata la help con le opzioni disponibili. Se invece ricevi un errore di compilazione, verifica che i pacchetti di build siano installati e che il sistema abbia una toolchain aggiornata.

Avvio base del servizio

La sintassi più semplice è questa:

./microsocks -p 1080

Questo avvia un SOCKS5 in ascolto sulla porta 1080 su tutte le interfacce, senza autenticazione. È utile per un test rapido in locale, ma non va bene su un server esposto a Internet.

Per un uso reale conviene sempre limitare l’accesso e, se possibile, richiedere username e password.

Configurazione consigliata con autenticazione

MicroSocks supporta autenticazione semplice con utente e password. Una configurazione tipica è:

./microsocks -p 1080 -u proxyuser -P 'PasswordMoltoForte' -i 0.0.0.0

Significato delle opzioni principali:

• -p 1080: porta di ascolto.
• -u proxyuser: username per l’accesso.
• -P 'PasswordMoltoForte': password dell’utente.
• -i 0.0.0.0: ascolto su tutte le interfacce IPv4.

Se il proxy deve essere usato solo localmente, è più sicuro bindarlo su localhost:

./microsocks -p 1080 -u proxyuser -P 'PasswordMoltoForte' -i 127.0.0.1

In questo caso il servizio non sarà raggiungibile dall’esterno e potrai usarlo tramite tunnel SSH o applicazioni locali.

Creare un servizio systemd

Per non avviare manualmente MicroSocks a ogni reboot, conviene creare un servizio systemd. Prima copia il binario in una posizione stabile, ad esempio /usr/local/bin:

sudo install -m 0755 ./microsocks /usr/local/bin/microsocks

Poi crea un utente dedicato senza shell interattiva:

sudo useradd -r -s /usr/sbin/nologin -M microsocks

Ora prepara il file di servizio, ad esempio /etc/systemd/system/microsocks.service. Prima fai un backup se il file esiste già:

sudo cp -a /etc/systemd/system/microsocks.service /etc/systemd/system/microsocks.service.bak 2>/dev/null || true

Contenuto consigliato:

[Unit]
Description=MicroSocks SOCKS5 Proxy
After=network-online.target
Wants=network-online.target

[Service]
User=microsocks
Group=microsocks
ExecStart=/usr/local/bin/microsocks -p 1080 -u proxyuser -P PasswordMoltoForte -i 127.0.0.1
Restart=on-failure
RestartSec=2
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=true

[Install]
WantedBy=multi-user.target

Attenzione: se inserisci la password direttamente nel file di servizio, proteggi molto bene i permessi del file. È una soluzione semplice, ma non la più elegante. Per ambienti più sensibili, meglio usare un wrapper o una secret management policy esterna.

Dopo aver creato il file, ricarica systemd e avvia il servizio:

sudo systemctl daemon-reload
sudo systemctl enable --now microsocks

Verifica lo stato:

sudo systemctl status microsocks --no-pager

Esito atteso: stato active (running) e nessun errore di avvio.

Test funzionale del proxy

Il modo più semplice per testarlo è usare curl. Se il proxy è in ascolto su localhost:

curl --socks5-hostname proxyuser:PasswordMoltoForte@127.0.0.1:1080 https://ifconfig.me

Esito atteso: viene restituito l’IP pubblico della VPS o del server da cui esce il traffico, non il tuo IP locale.

Puoi fare un test più completo con DNS via proxy:

curl --socks5-hostname proxyuser:PasswordMoltoForte@127.0.0.1:1080 https://example.com -I

Se il comando fallisce, controlla nell’ordine:

• porta corretta;
• servizio attivo;
• autenticazione esatta;
• firewall o bind su interfaccia sbagliata.

Aprire la porta nel firewall

Se vuoi rendere il proxy accessibile da altre macchine, devi aprire la porta nel firewall e, idealmente, limitarla a IP fidati.

UFW

sudo ufw allow from 203.0.113.10 to any port 1080 proto tcp

Esito atteso: solo l’IP indicato può raggiungere la porta 1080.

firewalld

sudo firewall-cmd --permanent --add-rich-rule='rule family="ipv4" source address="203.0.113.10/32" port port="1080" protocol="tcp" accept'
sudo firewall-cmd --reload

Se invece apri la porta a tutto il mondo, il rischio aumenta molto. In quel caso l’autenticazione deve essere forte e il server deve essere monitorato.

Hardening minimo pratico

Un proxy SOCKS5 esposto senza protezioni è una cattiva idea. Le misure minime sensate sono queste:

• Usare una password lunga e non riutilizzata.
• Limitare l’accesso a IP specifici quando possibile.
• Bindare il servizio su 127.0.0.1 se basta un uso locale.
• Aggiornare regolarmente il sistema.
• Controllare i log e i processi attivi.

Puoi verificare chi sta ascoltando sulla porta con:

sudo ss -lntp | grep 1080

Esito atteso: il processo microsocks in ascolto solo sull’indirizzo previsto.

Se vuoi ridurre ulteriormente l’esposizione, puoi usare MicroSocks solo come backend locale e accedervi tramite tunnel SSH. In quel caso il proxy non deve essere pubblicato su Internet.

Usarlo con SSH come tunnel locale

Se MicroSocks ascolta su 127.0.0.1:1080, puoi raggiungerlo da remoto con un tunnel SSH:

ssh -L 1080:127.0.0.1:1080 utente@server

In questo modo il traffico passa cifrato nel tunnel SSH e il proxy resta non esposto pubblicamente. Sul tuo PC locale userai poi 127.0.0.1:1080 come endpoint SOCKS5.

Questo approccio è spesso il più pulito quando il proxy serve solo per test, automazioni o navigazione amministrativa temporanea.

Integrazione con browser e applicazioni

Molti browser supportano SOCKS5 direttamente nelle impostazioni di rete. Se il proxy è locale, inserisci:

• Host: 127.0.0.1
• Porta: 1080
• Tipo: SOCKS5

Se il client supporta l’autenticazione SOCKS5, inserisci username e password. Alcune applicazioni non gestiscono bene l’autenticazione via GUI, quindi conviene testare prima con curl.

Problemi comuni e soluzioni rapide

Il servizio non parte. Controlla il log di systemd:

sudo journalctl -u microsocks -e --no-pager

Esito atteso: nessun errore di sintassi o permessi. Se vedi “permission denied”, verifica utente, percorso del binario e permessi del file di servizio.

La porta risulta chiusa. Verifica il bind e il firewall con:

sudo ss -lntp | grep 1080
sudo ufw status
sudo firewall-cmd --list-all

Autenticazione fallita. Ricontrolla username e password. Attenzione agli apici nel file di servizio e ai caratteri speciali nella password.

Il proxy risponde ma non risolve i nomi. Usa --socks5-hostname nei client che lo supportano, così la risoluzione DNS avviene tramite proxy.

Rollback e disattivazione pulita

Se devi dismettere il servizio, procedi in modo ordinato:

sudo systemctl disable --now microsocks

Se vuoi rimuovere anche il servizio systemd:

sudo rm -f /etc/systemd/system/microsocks.service
sudo systemctl daemon-reload

Se hai copiato il binario in /usr/local/bin e non ti serve più, rimuovilo solo dopo aver verificato che nessun servizio lo usi più:

sudo rm -f /usr/local/bin/microsocks

Prima di fare pulizia definitiva, controlla che non ci siano processi residui:

ps aux | grep microsocks | grep -v grep

Esito atteso: nessun processo in esecuzione.

Conclusione operativa

MicroSocks è una soluzione molto pratica quando ti serve un SOCKS5 leggero, con pochi componenti e controllo diretto della configurazione. La scelta migliore, nella maggior parte dei casi, è usarlo con autenticazione, bind locale o restrizione per IP e avvio tramite systemd.

Se vuoi un ambiente più robusto, il modello da preferire è questo: servizio locale, accesso tramite tunnel SSH, firewall restrittivo e test con curl prima di affidarlo a browser o software di produzione. Così mantieni il proxy semplice, verificabile e molto più facile da gestire nel tempo.