In questo breve articolo parleremo di netcat, un vero e proprio Coltellino Svizzero in ambito networking che ogni professionista dovrebbe conoscere. Netcat (abbreviato “nc”) è una utility da CLI disponibile per Linux, Windows, macOS, BSD e numerosi altri sistemi, permette di effettuare testi di connessione molto articolati, scansioni di rete ed altri task estremamente utili.
Come le tipiche utility da CLI netcat possiede il comune schema sintattico, con il lancio del comando seguito dalle varie opzioni e dai target oggetto delle operazioni che andiamo ad effettuare, come IP e porte. La sintassi sarà quindi:
$ nc [optioni] host porta
Supponiamo di voler verificare su un host target (es. 192.168.1.100) l’eventualità che una specifica porta sia aperta ed in ascolto, lanciamo il comando:
$ nc -zv 192.168.1.100 22
Che verifica l'apertura della porta SSH (22) sul target specificato rispondendo:
Connection to 192.168.1.100 22 port [tcp/ssh] succeeded!
O in caso di chiusura della stessa con:
nc: connect to 192.168.1.100 port 23 (tcp) failed: Connection refused
Supponiamo ora di voler scansionare sempre sullo stesso host un range di porte per evitare di lanciare singoli comandi in sequenza magari trascurando per dimenticanza alcune importanti porte, lanciamo il comando seguente che scansionerà tutte le porte tra la 20 e la 200:
$ nc -zv 192.168.1.100 20-200
Otterremo ancora una lunga serie di informazioni su quali porte sono aperte per cui nc è riuscito a stabilire una connessione:
nc: connect to 192.168.1.100 port 20 (tcp) failed: Connection refused nc: connect to 192.168.1.100 port 21 (tcp) failed: Connection refused Connection to 192.168.1.100 22 port [tcp/ssh] succeeded! nc: connect to 192.168.1.100 port 23 (tcp) failed: Connection refused …
Per una versione sintetica dell’output con l’elenco delle sole porte aperte possiamo aggiungere un piccolo grep che evidenzia solo le info di nostro interesse:
$ nc -zv 192.168.1.100 20-80 2>&1 | grep succeeded
o se ci interessano i tentativi in cui la connessione non è andata a buon fine:
$ nc -zv 192.168.1.100 20-80 2>&1 | grep failed
Come si può notare dagli output ottenuti nc ha effettuato tentativi di connessione in TCP (tramite il classico SYN / SYN/ACK / ACK)
Fin’ora abbiamo indicato a nc il target da analizzare tramite indirizzo IP, lo stesso possiamo fare con uno specifico dominio, ad esempio example.com:
$ nc -zv example.com 20-200
Così come potremmo indicare testualemnte le porte da scansionare a netcat sostituendo le porte numeriche con quelle di nostro interesse specifico, ad esempio ssh, http, https, ecc.
Possiamo raffinare i nostri criteri di ricerca indicando a nc quale tempo di timeout utilizzare per i sistemi scansionati con l’opzione -w 1 (dove 1 è il tempo di timeout settato in secondi) e quale formato indirizzo usare, ad esempio se IPv4 o IPv6, rispettivamente con -4 (solo IPv4) e -6 (solo IPv6).
Creiamo ora a scopi didattici e di test un piccolo server sul nostro PC in ascolto su una specifica porta, sul nostro PC lanciamo 2 finestre terminale distinte, nella prima lanciamo il comando:
$ nc -l 4000
Con cui diciamo a netcat di mettersi in ascolto con -l (cioè listen) su una porta scelta a caso, in questo per esempio abbiamo scelto la 4000. Una volta lanciato il comando netcat rimarrà in ascolto sulla porta senza produrre nulla, il terminale risulterà infatti impegnato.
Sul secondo terminale procediamo con netcat a stabilire una connessione su questa porta per vedere cosa succede sul nostro piccolo server. Dal secondo terminale lanciamo quindi il comando:
$ nc -zv localhost 4000
Che (come visto sopra) tanta di instaurare sulla nostra macchina (localhost) una connessione sulla porta 4000. Appena lanciato il comando otterremo:
Connection to localhost (127.0.0.1) 4000 port [tcp/*] succeeded!
Mentre il primo terminale tornerà in stato attivo, ossia dopo la creazione della connessione sulla porta 4000 il nostro piccolo server creato con netcat si chiude. Questo il caso relativo all’uso del protocollo TCP, avremmo potuto fare lo stesso attraverso UDP lanciando (rispettivamente):
$ nc -u -l 4000
e
$ nc -zv -u localhost 4000
Ottenendo:
Connection to localhost (127.0.0.1) 4000 port [udp/*] succeeded!
E sul primo terminale diverse “X”, 5 nel caso, che stanno a testimoniare 5 pacchetti di test (UDP) inviati dal secondo terminale che stabilisce la connessione e ricevuti in sequenza (come da protocollo UDP, cioè come stream) dal primo:
$ nc -u -l 4000
XXXXX
Netcat possiede potenzialità ben più grandi delle poche elencate, possiamo per esempio inviare un file, creare una piccola chat per fini didattici o misurare le prestazioni di rete. Vediamo un ultimo esempio dimostrativo per l’invio di un file tramite nc.
Supponiamo di voler rendere disponibile atrtaverso il nostro piccolo server un file di test, che creeremo per l'occasione con:
echo “File per netcat!” > test.txt
Lanciamo dal nostro primo terminale un server in ascolto con il file in input:
$ nc -vl 127.0.0.1 4000 < test.txt
Il server creato da netcat rimane in attesa, dal secondo terminale stabiliamo la connessione al server lanciando:
$ nc localhost 4000
ottenendo sul primo:
Listening on localhost 4000 Connection received on localhost *****
E sul secondo:
File per netcat!
Sempre sul secondo terminale stoppiamo l’esecuzione con CTRL+C e rilanciamo sul primo terminale il nostro server con il file di input (stesso comando), dal secondo terminale questa volta lanciamo:
$ wget -qO- http://localhost:4000/
Otterremo:
Listening on localhost 4000 Connection received on localhost ***** GET / HTTP/1.1 Host: localhost:4000 User-Agent: Wget/1.21.2 Accept: */* Accept-Encoding: identity Connection: Keep-Alive
E sul secondo sempre:
File per netcat!
Abbiamo visto nei due casi come avviene lo scambio di un file concentrandoci prima sulla trasmissione con netcat e successivamente tramite wget anche sull’header della stessa (richiesta GET, versione protocollo, ecc.).
Ovviamente uno scambio file effettuato in questo modo serve solo per scopi didattici e di test, non potendo quindi rappresentare una opzione nel mondo reale. Probabilmente ci siamo già accorti di ttute le controindicazioni, prima fra tutte il fatto che il file venga inviato su una connessione in chiaro, cioè non cifrata, facilmente intercettabile (insieme al file allegato) analizzando il traffico di rete.
Netcat rimane comunque uno strumento fondamentale, per la sua versatilità risulta indispensabile per gli specialisti dell’ambito networking, potendo all’occorrenza funzionare anche come strumento offensivo durante il pentesting, potendo quindi aprire connessioni e microserver attraverso cui eseguire istruzioni proprio attraverso una remote shell.
Come sempre, per tutti gli approfondimenti del caso rimandiamo al manuale di netcat consultabile da terminale lanciando:
$ man nc
Qualsivoglia richiesta può essere inviata a NAOSDATA che offre servizi di consulenza, implementazione e managment specifico sulle infrastrutture ICT.
Ci auguriamo che questo articolo vi sia piaciuto e vi possa essere d'aiuto nell'utilizzo di netcat. Se apprezzate il nostro lavoro seguite i nostri profili su Facebook e LinkedIn.
Questo lavoro è offerto tramite licenza Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
Risorse e Link: