Compago

...free knowledge

 
  • Increase font size
  • Default font size
  • Decrease font size
Home Manuali Utilità Guida a Netcat

Guida a Netcat

E-mail Stampa PDF

Introduzione

Per chiunque si sia addentrato nel mondo del networking, è impossibile non essersi imbattuto in netcat.

Questo piccolo programmino permette di fare veramente tante cose, ma se proprio volessimo darne una definizione, si può dire che è una utility che legge e scrive dati utilizzando connessioni tcp/ip. Può facilmente essere usato da programmi esterni o scripts, e allo stesso tempo essere uno strumento di debbuging e controllo per le connessioni.

Con esso è possibile :

  • Aprire o leggere connessioni sia tcp o udp su o da qualsiasi porta.
  • Effettuare delle connessione in "tunnel mode".
  • Effettuare delle scansioni sulle porte, anche in modalità random.
  • Uso avanzato con l'invio in modalità buffer (per esempio inviare una riga ogni N secondi conservando i dati da inviare in un buffer) e un hexdump dei dati trasmessi o ricevuti da reindirizzare eventualmente su un file.

Queste sono in breve alcune delle caratteristiche di questo programma, ma vediamo magari con qualche esempio cosa veramente potremo fare.

Guida di base a netcat

Lanciando il comando "nc -[opzioni]" è possibile eseguire una molteplicità di azioni.

Esistono tre modalità fondamentali per netcat: "Connection mode","Listen mode" e "Tunnel mode".

Connect Mode

In modalità connect, netcat si connette ad un host in remoto e semplicemente collega il suo stdin e stdout al flusso dati spedito o ricevuto da remoto. Netcat quindi agirà in modalità client, connettendosi ad un server remoto ed inviandogli dei dati e leggendo i dati ricevuti dal server.

Come esempio immaginatevi il programma telnet, una volta connessi al server tramite telnet, tutto quello che scrivete con la tastiera nella shell verrà inviato in remoto, il risultato cioè quello che da remoto arriva a sua volta verrà sempre visualizzato nella vostra shell. Questo in modo semplificato significa "collegare stdin e stdout locale al flusso dati spedito o ricevuto da remoto".

L'uso comune è:

  netcat [opzioni] hostname porte ... 

Il parametro "porte" indica tutte le porte alle quali connettersi. Durante il funzionamento netcat si collegherà alle porte in modo sequenziale ( o volendo anche casuale specificando l'opzione -r) ma non sarà possibile utilizzare più di una porta alla volta.

 

Listen Mode

In modalità "listen" netcat rimane in ascolto su di una porta, specificata con l'opzione '-p' fino a che qualche client da remoto ci si connette (il client potrebbe essere anche in locale). A questo punto il suo comportamento è identico a quello in modalità "connect", cioè ci sarà un collegamento tra client e server.

Il comando si usa così:

netcat -l -p porta [nome_pc_remoto] [Porte_sul_pc_remoto] ... 

L'opzione fondamentale è "-l" che impone il comportamento di ascolto. Le altre opzioni , [nome_pc_remoto] [Porte_sul_pc_remoto], indicano quale nome deve avere il pc remoto dal quale accettare al connessione e su quali porte sorgenti deve usare per avere il permesso di connettersi. Solitamente questi parametri non vengono specificati, ma se voleste selezionare i clients con queste opzioni potrete farlo.

Attenzione che a differenza di telnet o ssh o simili.. netcat non ha metodi di autorizzazione, cioè niente user o password, quindi attenzione a come viene usato, perché una volta in ascolto su di una porta chiunque potrebbe eventualmente connettersi.

Tunnel mode

Nelle modalità descritte fino ad ora è chiaro che i dati passeranno in chiaro attraverso la rete. Questo è accettabile in una rete locale, mentre risulta un problema per la sicurezza se questi dati passato tramite internet senza alcuna criptazione. Sarebbe quindi saggio usare un tunnel SSH in modo da criptare i dati trasmessi.

Usando un tunnel SSH si hanno due vantaggi:

  1. I dati sono trasferiti dentro un tunnel criptato, in questo modo saranno ben protetti.
  2. Non si avrà il bisogno di mantenere nessuna porta aperta nel firewall della macchina che agisce da server, dato che tutte le connessioni passeranno nel tunnel SSH.

Per fare questo riverseremo il file in una connessione in ascolto sul server con le stesse modalità viste fino ad ora. E' scontato dire che sulla macchina che agisce da server sia presente un processo server SSH. Eseguiremo il seguente comando:

$ cat backup.iso | nc -l 3333

Sulla macchina client che andrà a connettersi alla connessione in "listening" sulla macchina server attraverso un tunnel SSH :

$ ssh -f -L 23333:127.0.0.1:3333 me@192.168.0.1 sleep 10; nc 127.0.0.1 23333 | pv -b > backup.iso

Questo modo di creare ed usare un tunnel SSH ha il vantaggio che questo tunnel si chiuderà automaticamente dopo la fine del trasferimento del file.

Il comando descritto qui sopra è per linux, ma, tranne il comando "pv" che serve solo a mostrare graficamente il trasferimento del file, è possibile usare una versione di ssh per windows (openSSH) che fa le stesse cose.

Per maggiori chiarimenti leggere l'articolo sui tunnel SSH.

Opzioni

Opzioni di base

'-V' o '--version'
Mostrala versione di netcat e termina il programma.
'-h' o '--help'
Stampa un messaggio di aiuto con le più comuni comandi di netcat
'-v' o '--verbose' Stampa dei messaggi di controllo. Solitamente vengono inviati nello stderr. Con '-vv' si avranno ancora più informazioni

Opzioni di protocollo e inferfaccia

'-t' o `--tcp'
Imposta l'uso del protocollo TCP, che è anche quello predefinito. Questa opzione potrebbe ritornare molto utile ( vedi TunnelMode) da usare dopo, ad esempio, aver impostato l'opzione UDP, in modo da permettere un "crass protocol bridge" tra UDP e TCP.

'-u' o`--udp'
Imposta il protocollo UDP.(vedi opzione TCP)
'-p NUM' o `--local-port=NUM' Imposta la porta locale da utilizzare nella connessione. In modalità "listen" (cioè ascolto, ricezione, cioè quando il programma farà da server) e in Tunnel Mode, questa opzione serve a specificare su quale porta la connessione server si metterà in ascolto. Mentre in "connect mode" cioè quando netcat agirà come un client, imposterà la porta dalla quale verrà originata la connessione, se questa porta non verrà specificata il sistema operativo gliene assegnerà una a caso.

'-s ADDRESS' o`--source=ADDRESS'
Serve ad impostare l'indirizzo sorgente utilizzato nella creazione della connessione. In modalità "listen" e in modalità "Tunnel" questa imposterà l'indirizzo ip sul quale netcat rimarrà in ascolto. In modalità di connessione, imposterà questo indirizzo come quello da cui parte la connessione. Se non viene specificata questa opzione, allora l'indirizzo sarà impostato secondo le impostazioni della rete presente nel computer.
'-P NUM' o`--tunnel-port=NUM' E' come l'opzione "-p" ma ha effetto solo nella fase di connessione e non in modalità "listen", questo è molto utile in"Tunnel Mode" per specificare la porta sorgente della connessione.
'-S ADDRESS' o `--tunnel-source=ADDRESS' Ha la stessa funzione dell'opzione "-s" ma ha effetto solo nella fase di connessione e non in modalità "listen", questo è molto utile in"Tunnel Mode" per specificare la porta sorgente della connessione.

Opzioni avanzate

'-i SECS' o '--interval SECS'
Imposta il tempo di ritardo sul buffer in uscita. Questo ha effetto sulle connessioni presenti e fa in modo di impostarne il buffer per i dati in uscita. Questo significa che in "tunnel mode" tutto quello che viene ricevuto dalla connessione in ascolto sarà bufferizzato quindi conservato per poi essere usato nella connessione in uscita.
'-n' o '--dont-resolve' Impone di non usare il controllo DNS su di uno specificato indirizzo o hostname, oppure di in nome di una porta ( solitamente questi vengono specificati nel file /etc/services), quindi solo ip numerici
'-r' o '--randomize' Rende casuali le porte sul destinatario della connessione, Se è specificato più di un range, questo sarà reso random come se fosse un unico range globale.
'-w' o '--wait=SECS' Imposta il tempo di inattività dopo il quale netcat sarà terminato inviando nello stderr un messaggio di errore. In modalità connessione o tunnel, questo va a coincidere con il timeout cioè col tempo massimo che netcat proverà a connettersi, mentre in modalità listen questo specifica il tempo che il server aspetterà per una connessione valida.
'-T' o `--telnet' Risposte e domande sulla codifica telnet possono essere trovate nel documento RFC0854. Comunque sia questa opzione permette a netcat di utilizzare sessioni telnet. I dati in arrivo da una connessione telnet sono analizzati nella coda in ingresso e fatti uscire da essa prima di essere inviati, come se non fossero mai stati ricevuti, così che l'applicazione non debba analizzare per conto suo i codici (questo comportamento può essere disabilitato in fase di compilazione del programma utilizzando l'opzione "-enable-oldtelnet" o con "-enable-compat").
'-z' o '--zero' Imposta a zero il flag di I/O. In modalità connessione significa che non appena la porta si sarà aperta sarà immediatamente spenta e chiusa. Questo può tornare utile per testare o effettuare uno scan. Naturalmente esistono portscanners molto più veloci, ma in una logica di script, è utile avere uno strumento come netcat in grado di fare questo. In modalità listen, fa in modo che netcat rifiuti tutte le connessioni in ingresso mandandole in timeout (se impostato) or mettendole in attesa per sempre. In entrambi i casi nessun dato verrà trasferito. Questa opzione non è compatibile con il Tunnel Mod.

Altre opzioni

'-c'

Con questa opzione si dice a netcat di eseguire un comando in remoto subito dopo la connessione ed inviarne l'output indietro al client. Esempio "netcat -c '/bin/command' hostname port" in cui dico di eseguire lo script chiamato "command" dopo essermi connesso al server chiamato "hostname" sulla porta "port".Se lo usassi invece in modalità listen, esempio : " netcat -l -p 1234 -c '/bin/command' ", allora il comando voluto verrà eseguito appena il primo client si collegherà alla porta 1234 dopo di che verrà inviato a quest'ultimo l'output e infine chiusa la connessione.

'-l'
L'opzione "-l" impone a netcat di rimanere in ascolto su una porta specificata in seguito con l'opzione "-p".
'-q NUM'
In questo modo la connessione creata con netcat terminerà un numero di secondi(NUM) dopo la fine della trasmissione dei dati(EOF). Esempio "cat filename | netcat hostname 1234 -q 10"il testo del file chiamato "filename" viene spedito tramite netcat in remoto e dopo 10 secondi la fine della trasmissione del file la connessione terminerà.
'-e'
Esegue un programma dopo essersi connesso vedi l'opzione "-c" (alcune differenze sono dovute alla versione windows o linux)
'-b' Permette il traffico broadcast
'-g gateway' Source-routing gateway
'-G num' Source-routing pointer: 4, 8, 12, ...
'-r' Fa diventare casuale porte locali o remote
'-d'
Stealth mode, non viene più visualizzato dalla console (windows)
'-o file' Imposta il file ini cui verrà riversato l'output

 

Esempi

Il più semplice e primitivo uso di netcat è quello di un semplicissima situazione server-client.

Creo sul pc1 (che ha come indirizzo ip 192.168.0.1) un server in ascolto sulla porta 3333 digitando il comando:

nc -l 3333

Nel pc2 invece eseguo il seguente comando:

nc 192.168.0.1 3333

con il quale mi connetto tramite netcat al pc1 sulla sua porta 3333.

A questo punto tutto quello che scrivo nella console del pc1 verrà trasferito al pc2 e viceversa, dato che stdin e sdtout,cioè lo standard input di uno è connesso allo standard output dell'altro.

 

Terminale remoto
Per attivare un terminale remoto senza utilizzare telnet o ssh è sufficiente lanciare lato server netcat in modalità LISTEN:

nc -l -p 4000 -e /bin/sh

Per connettervi dal client invece è sufficiente invece il comando:

nc <host> 4000

Dove <host> è l’indirizzo IP del server.

Sotto windows un classico esempio di backdoor potrebbe essere:

nc -l -p 23 -t -e cmd.exe

cioè avvio un server nel pc remoto che rimane in ascolto sulla porta 23 e appena io dal mio pc mi ci collego la prima cosa che fa è avviare una shell o meglio una console DOS dalla quale poter eseguire i vari comandi sul server remoto.

Port Scanning

Per effettuare un port scan con netcat al fine di verificare le porte aperte di un certo server remoto è sufficiente lanciare il comando:

#test di due porte specifiche (80 e 21)
nc -v -z www.kernel.org 80 21
#test di un range di porte (dalla 21 alla 23)
nc -v -z www.kernel.org 21-23

File transfer

Netcat si presta benissimo anche al trasferimento files via rete: la configurazione da utilizzare è simile a quella utilizzata per il terminale remoto. Supponendo che il nome del file da trasferire sia “miofile.txt“, posizionatevi nella directory in cui si trova e lanciate netcat come segue:

cat miofile.txt| nc -l -p 4000

Il netcat server appena creato si metterà all'ascolto sulla porta 4000 in attesa di un client.

Per avviare il download lato client invece lanciate il comando:

nc <host>  4000 > miofile.txt

Dove <host> è l’indirizzo IP del server su cui si trova il file da scaricare, appena connesso infatti il server incomincerà a traferire i dati al client, dopo di che terminerà la connessione.

Se volessimo trasferire un file un po più grande, come ad esempio una immagine iso e volessimo sapere lo stato di avanzamento potremo usare l'utility "pv", che ci terrebbe informati dei byte inviati e ricevuti fino alla fine del trasferimento:

cat backup.iso | pv -b | nc -l 3333

per inviare il file

nc 192.168.0.1 3333 | pv -b > backup.iso

per ricevere il file.

HTTP Server
Ecco come attivare un semplice HTTP Server in ascolto sulla porta 8080. L’opzione “-l ” avvia netcat in modalità LISTEN e l’opzione “-c” specifica il comando da lanciare ogni volta che viene stabilita una connessione. Creo un piccolo script che con pochi comandi crea il mio piccolo http server:

#!/bin/bash
handle_req()
{
read req file proto
echo -e "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
echo -e "<html><h1>Hello World</h1></html>"
}
typeset -fx handle_req
nc -l -p 8080 -c handle_req

HTTP Client
L’esempio che segue vi permetterà di visualizzare l’ultima versione del kernel di linux presa direttamente dal sito kernel.org:

echo -e "GET /kdist/finger_banner HTTP/1.0\r\n" | nc www.kernel.org 80 | grep latest

Anonimizzare Netcat

Installando anche il pacchetto “tor” avrete a disposizione il comando “torify” che vi consentirà di anonimizzare tutto il traffico generato con Netcat (funzione sicuramente gradita agli appassionati di hacking ;-) ). Di seguito un esempio di utilizzo:

echo -e "GET /iponly/ HTTP/1.0\r\n" | torify nc ipid.shat.net 80

Questo comando visualizzerà l’IP address del server anonimo verso cui vi avrà dirottato il comando “torify”.

Catturare una pagina web

Se volessimo catturare l'output di una pagina web di un determinato sito:

 nc -v www.website.com 80

e scrivere nella console il comando "GET / HTTP/1.0" e mandando qualche "invio" come risposta il webserver ci trasmetterà la pagina che abbiamo richiesto.

Per eseguire la cosa in automatico scrivere in un file di testo "GET / HTTP/1.0" poi darlo in pasto a netcat:

nc -v www.website.com 80 < get.txt

Dove trovare questo programma

Netcat esiste sia per linux o unix che per windows, completo di sorgenti.

Per la versione linux potete controllare la revisione più aggiornata qui: Linux netcat oppure scaricarla dall'allegato qua sotto come anche la versione per windows.

Delle varianti del programma sono"socat" e "SslNetcat", e sia per linux che per windows anche "Cryptcat" dove il programma funziona esattamente come netcat ma con la quale potremo inviare i dati criptati.

Attachments:
Download this file (nc111nt.zip)Netcat per windows[ ]104 Kb
Ultimo aggiornamento ( Sabato 20 Agosto 2011 19:31 )  
Loading

Login




Chiudi