Capitolo 190. Strumenti per il controllo e l'analisi del traffico IP

L'analisi del traffico della rete, sia per mezzo dell'intercettazione di tutti i pacchetti che attraversano una rete fisica, sia per mezzo del controllo di ciò che riguarda esclusivamente una singola interfaccia di rete del nodo locale, è molto importante per comprendere i problemi legati alla sicurezza e per scoprire inconvenienti di vario genere.

L'uso produttivo degli strumenti che vengono descritti in questo capitolo richiederebbe una preparazione adeguata sulla composizione dei pacchetti dei protocolli TCP/IP, diversamente si riesce solo a sfiorare la comprensione di quello che accade. Tuttavia, per quanto poco, un po' di pratica con questi può essere utile in ogni caso.

190.1 Netstat

Netstat ⁽¹⁾ è un programma specifico di GNU/Linux, in grado di mostrare in modo agevole alcune informazioni contenute nella directory /proc/net/. Le informazioni disponibili sono molte, anche troppe. In queste sezioni viene mostrato solo un uso limitato di Netstat, riferito ai protocolli TCP/IP.

Le informazioni disponibili riguardano esclusivamente la sfera del nodo locale, comprese le connessioni che lo riguardano.

Netstat potrebbe essere utilizzato per fornire le stesse informazioni che si possono ottenere già da route, ifconfig e in parte da iptables. In generale, comunque, questo non dovrebbe essere il suo uso normale, che qui non viene mostrato.

190.1.1 Avvio del programma

L'eseguibile netstat emette attraverso lo standard output una serie di notizie riferite a tutti i tipi di connessione disponibili, traendo le informazioni dai file virtuali della directory /proc/net/.

netstat [opzioni]

Se netstat viene usato senza opzioni, mostra la situazione di tutti i tipi di collegamento, elencando i socket aperti. Se tra le opzioni appare l'indicazione di uno o più protocolli, le informazioni che si ottengono si limitano a quanto richiesto espressamente.

Opzione	Descrizione
`-t \| --tcp`	Richiede espressamente lo stato delle connessioni TCP.
`-u \| --udp`	Richiede espressamente lo stato dei socket che utilizzano il protocollo UDP.
`--inet \| --ip`	Richiede espressamente le informazioni che riguardano l'uso dei protocolli TCP/IP.
`-e`	Richiede di aggiungere l'indicazione dell'utente proprietario del processo relativo.
`-o`	Richiede di aggiungere l'indicazione dei timer di rete.
`-a`	Elenca tutte le porte utilizzate, incluse quelle dei serventi in ascolto.
`-n`	Mostra le informazioni in forma numerica: indirizzi IP, numeri di porta, numeri UID.

Segue la descrizione di alcuni esempi.

# netstat --inet

Emette l'elenco dei socket di dominio Internet, ovvero tutte le comunicazioni aperte tra i programmi attraverso i protocolli TCP/IP.
# netstat --inet -e

Come nell'esempio precedente, aggiungendo l'indicazione degli utenti proprietari dei processi che attuano le connessioni.
# netstat --tcp -a

Mostra la situazione delle porte TCP, in particolare quelle dei servizi in ascolto.

190.1.2 Interpretazione del risultato

Gli elenchi restituiti da Netstat sono composti in forma tabellare. Di seguito appare la descrizione dei nomi delle colonne di queste.

Colonna	Stato	Descrizione
`Proto`		Rappresenta il protocollo utilizzato in ogni porta attiva. Può trattarsi di `tcp`, `udp` e `raw`.
`Recv-Q`, `Send-Q`		Rappresenta la coda di byte che sono stati ricevuti ma non ancora prelevati dal programma che utilizza la connessione, o che sono stati trasmessi ma per i quali non è stata ricevuta conferma dal nodo remoto.
`Local Address`, `Foreign Address`		Rappresenta rispettivamente l'indirizzo locale e quello remoto, completo dell'indicazione della porta relativa.
`State`		Rappresenta lo stato della porta, indicato attraverso una parola chiave tra quelle elencate di seguito. Lo stato riguarda prevalentemente le connessioni TCP, negli altri casi dovrebbe essere assente.
	`ESTABLISHED`	La porta ha una connessione in corso.
	`SYN SENT`	La porta sta tentando di instaurare una connessione.
	`SYN RECV`	È in corso l'inizializzazione della connessione.
	`FIN WAIT1`	La porta è chiusa e la connessione è in corso di conclusione.
	`FIN WAIT2`	La connessione è chiusa e la porta è in attesa della conferma dall'altra parte.
	`TIME WAIT`	La porta è in attesa della conferma della conclusione della connessione.
	`CLOSED`	La porta non è in uso.
	`CLOSE WAIT`	La porte remota conclude la connessione ed è in attesa di conferma dell'altra parte.
	`LAST ACK`	La parte remota chiude la connessione e la porta è chiusa: si è in attesa della conferma finale.
	`LISTEN`	La porta è in ascolto in attesa di connessioni in arrivo. Queste porte vengono indicate solo se si utilizza l'opzione `-a`.
	`CLOSING`	Entrambe le porte stanno chiudendo la connessione, ma i dati non sono stati inviati completamente.
	`UNKNOWN`	Lo stato della porta è sconosciuto.
`User`		Il nome o il numero UID dell'utente proprietario della porta. Si ottiene questa informazione con l'opzione `-e`.

A titolo di esempio viene mostrato come può apparire una connessione TELNET tra dinkel.brot.dg e roggen.brot.dg.

# netstat --tcp[Invio]

Active Internet connections (w/o servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 roggen.brot.dg:1170     dinkel.brot.dg:telnet   ESTABLISHED
tcp        0      0 dinkel.brot.dg:telnet   roggen.brot.dg:1170     ESTABLISHED

190.2 Tcpdump

Tcpdump ⁽²⁾ è lo strumento fondamentale per l'analisi del traffico che avviene nella rete fisica a cui si è collegati. Permette sia di ottenere una visione sintetica dei pacchetti, sia di visualizzarne il contenuto in esadecimale. Inoltre, è possibile definire un filtro ai pacchetti da prendere in considerazione. Purtroppo, il suo utilizzo efficace richiede un'ottima conoscenza dei protocolli TCP/IP.

I pacchetti vengono analizzati solo nella prima parte, normalmente di 68 byte, perdendo le informazioni successive. Eventualmente, questa dimensione può essere aumentata, anche se in generale ciò è sconsigliabile dal momento che richiederebbe un tempo di elaborazione maggiore, portando anche alla perdita di pacchetti.

Tcpdump può generare un risultato in esadecimale, oppure può emettere i pacchetti così come sono. Per poter interpretare il contenuto dei pacchetti, è necessario conoscere la loro struttura, in base ai protocolli relativi. A titolo di esempio, viene mostrato un programma Perl elementare, per filtrare i caratteri di controllo ASCII:

#!/usr/bin/perl

while ($riga = <STDIN>)
  {
    $riga =~ tr/\x00-\x1F//;
    $riga =~ tr/\x7F//;
    $riga =~ tr/\xFF//;
    print STDOUT ("$riga");
  }

Supponendo che questo sia il programma filtro, si può spiare in modo molto banale ciò che passa per la rete con il comando seguente:

# tcpdump -l -i eth0 -s 0 -w - | filtro

La cosa diventa ancora più semplice se si vuole utilizzare il programma strings che dovrebbe essere disponibile in tutti i sistemi standard:

# tcpdump -l -i eth0 -s 0 -w - | strings

190.2.1 Avvio del programma

tcpdump emette le informazioni tratte dalla parte iniziale dei pacchetti che possono essere intercettati attraverso un'interfaccia di rete, che corrispondono a una data espressione.

tcpdump [opzioni] [espressione]

Opzione	Descrizione
`-i interfaccia`	Definisce l'interfaccia di rete attraverso cui `tcpdump` deve porsi in ascolto. Se non viene specificata, `tcpdump` sceglie la prima, ma potrebbe trattarsi anche di `lo` (loopback).
`-l`	Filtra l'output attraverso una memoria tampone, in modo da gestire meglio le pipeline.
`-n`	Fa in modo di non convertire gli indirizzi numerici e i numeri di porta nei nomi corrispondenti.
`-s n_byte`	Permette di definire esplicitamente la quantità di byte da prendere in considerazione per ogni pacchetto. In modo predefinito vengono trattati solo i primi 68 byte. Quando la lunghezza è troppo breve per dare informazioni sufficienti, se viene identificato almeno il tipo di protocollo, quello che si ottiene è una stringa nella forma `[\|protocollo]`.
`-w file`	Memorizza i pacchetti grezzi all'interno di un file, invece di analizzarli ed emetterne il risultato. Il contenuto di questo file può essere elaborato successivamente con l'opzione `-r`.
`-r file`	Legge i pacchetti da quanto accumulato precedentemente in un file attraverso l'opzione `-w`. In pratica, permette di analizzare quanto raccolto in precedenza.
`-x`	Si limita a emettere i pacchetti in forma esadecimale. Per la precisione, viene emessa solo la parte dei pacchetti che rientra nel limite fissato con l'opzione `-s`, ovvero i primi 68 byte se questa non è stata indicata.
`-F file`	Permette di fornire l'espressione di filtro dei pacchetti attraverso un file indicato con questa opzione.

Segue la descrizione di alcuni esempi.

# tcpdump -i eth0

Emette attraverso lo standard output tutto il traffico che può essere intercettato per mezzo dell'interfaccia eth0.
# tcpdump -n -i eth0

Come nell'esempio precedente, ma le informazioni sugli indirizzi e sui numeri di porta vengono indicati in forma numerica.
# tcpdump -x -i eth0

Emette attraverso lo standard output il contenuto della prima parte dei pacchetti che possono essere intercettati per mezzo dell'interfaccia eth0. Questi dati vengono espressi in forma esadecimale.

190.2.2 Espressioni

L'utilizzo di Tcpdump non è molto utile se non viene definito un filtro a ciò che si vuole analizzare. Per questo motivo, dopo le opzioni normali della riga di comando può essere indicata un'espressione, più o meno articolata: solo i pacchetti che soddisfano la condizione espressa vengono presi in considerazione.

Questa espressione contiene spesso degli spazi: può essere fornita a Tcpdump in un argomento unico utilizzando dei delimitatori, oppure può essere composta da più argomenti in sequenza. Inoltre, attraverso l'opzione -F è possibile fornire l'espressione contenuta in un file; in tal caso, l'espressione può essere scritta su più righe, senza bisogno di simboli di continuazione.

Le espressioni di Tcpdump sono composte da primitive che possono essere raggruppate per mezzo delle parentesi tonde (in modo da evitare ambiguità nell'ordine di risoluzione) e connesse attraverso operatori booleani:

`! \| not`	un punto esclamativo o la parola chiave `not` rappresenta la negazione logica;
`&& \| and`	una doppia e-commerciale (`&&`) o la parola chiave `and` rappresenta il concatenamento, ovvero un AND logico;
`\|\| \| or`	una doppia barra verticale (`\|\|`) o la parola chiave `or` rappresenta l'alternanza, ovvero un OR logico.

All'interno delle primitive possono apparire riferimenti a diversi tipi di entità, che vengono descritte brevemente.

Gli indirizzi di origine o di destinazione, riferiti al protocollo TCP/IP, possono essere indicati attraverso nomi di dominio o numeri IP. In particolare, è possibile fare riferimento a una sottorete indicando il numero IP parziale.
Le porte possono essere identificate per numero o per nome.
Per identificare i protocolli si possono usare delle parole chiave precise; in particolare: ether, fddi, ip, arp, rarp, decnet, tcp, udp.

Il protocollo identificato dalle parole chiave elencate dovrebbe essere intuitivo, almeno per i casi più comuni (IP, ARP, RARP, TCP e UDP). Le prime due parole chiave sono equivalenti: ether e fddi rappresentano semplicemente il secondo livello, collegamento dati, del modello ISO-OSI.

Primitiva	Descrizione
`dst host host` `src host host` `host host`	Se viene usata la parola chiave `dst`, si avvera se il campo della destinazione IP corrisponde al nodo indicato; se viene usata la parola chiave `src`, si avvera se il campo dell'origine IP corrisponde al nodo indicato; altrimenti, in mancanza di tali parole chiave, si avvera se il nodo corrisponde indifferentemente all'origine o alla destinazione.
`ether dst host_ethernet` `ether src host_ethernet` `ether host host_ethernet`	Definisce un indirizzo Ethernet numerico o derivato dal contenuto del file `/etc/ethers`. Come si può intuire, nel primo caso si fa riferimento a una destinazione, nel secondo a un'origine, nel terzo non si fa differenza.
`gateway host`	Si avvera nel caso i pacchetti utilizzino il nodo indicato come gateway, ovvero, quando l'indirizzo Ethernet dell'origine o della destinazione non appartiene né all'indirizzo IP dell'origine, né a quello della destinazione.
`dst net rete` `src net rete` `net rete`	Se viene usata la parola chiave `dst`, si avvera se il campo della destinazione IP appartiene alla rete indicata; se viene usata la parola chiave `src`, si avvera se il campo dell'origine IP appartiene alla rete indicata; altrimenti, in mancanza di tali parole chiave, si avvera se la rete corrisponde indifferentemente all'origine o alla destinazione. La rete può essere indicata con un numero IP incompleto, oppure attraverso l'aggiunta di una maschera di rete. Per cui, la sintassi potrebbe essere estesa nel modo seguente:
`dst net {rete` _<-' ^`->`\| indirizzo_ip mask maschera_ip` _<-' ^`->`\| indirizzo_ip/lunghezza_maschera}` `src net {rete` _<-' ^`->`\| indirizzo_ip mask maschera_ip` _<-' ^`->`\| indirizzo_ip/lunghezza_maschera}` `net {rete` _<-' ^`->`\| indirizzo_ip mask maschera_ip` _<-' ^`->`\| indirizzo_ip/lunghezza_maschera}`	In tal caso, la maschera di rete può essere indicata attraverso un numero IP corrispondente, oppure attraverso la quantità di bit a uno nella parte iniziale di tale maschera.
`dst port porta` `src port porta` `port porta`	Definisce una porta TCP o UDP, trattandosi rispettivamente di un'origine, di una destinazione, o di entrambe le cose indifferentemente.
`less lunghezza` _<-' ^`->`\| len <= lunghezza` `greather lunghezza` _<-' ^`->`\| len >= lunghezza`	Si avvera se la dimensione del pacchetto è inferiore o uguale, oppure maggiore o uguale alla quantità di byte indicata.
`ether proto protocollo`	Definisce la selezione di un protocollo Ethernet attraverso un numero oppure un nome: `ip`, `arp`, `rarp`. Dal momento che questi nomi sono anche parole chiave per Tcpdump, vanno indicati facendoli precedere da una barra obliqua inversa (`\`) (ciò tenendo conto anche del tipo di shell utilizzato; nel caso della shell Bash e di altre, occorre raddoppiare la barra obliqua inversa).
`ip proto protocollo`	Definisce la selezione di un protocollo IP attraverso un numero, oppure un nome: `icmp`, `igrp`, `udp`, `nd`, `tcp`. Tuttavia, i nomi `icmp`, `tcp` e `udp` vanno preceduti da una barra obliqua inversa (`\`) per evitare che vengano interpretati in modo speciale da Tcpdump.
`[ether] broadcast`	Si avvera se il pacchetto è di tipo Ethernet broadcast.
`ip broadcast`	Si avvera per un pacchetto IP broadcast.
`[ether] multicast`	Si avvera se il pacchetto è di tipo Ethernet multicast.
`ip multicast`	Si avvera per un pacchetto IP multicast.

Segue la descrizione di alcuni esempi.

# tcpdump host dinkel.brot.dg

Individua ed emette tutto il traffico riferito a dinkel.brot.dg.
# tcpdump host dinkel.brot.dg and host roggen.brot.dg

Individua ed emette tutto il traffico riferito simultaneamente a dinkel.brot.dg e a roggen.brot.dg. In pratica si limita a estrarre il traffico tra questi due nodi.
# tcpdump host dinkel.brot.dg and $host roggen.brot.dg _<-'
^`->or host weizen.brot.dg$

Individua esclusivamente il traffico intrattenuto tra dinkel.brot.dg e roggen.brot.dg, oppure tra dinkel.brot.dg e weizen.brot.dg. Le parentesi tonde sono state protette attraverso la barra obliqua inversa per evitare una diversa interpretazione da parte della shell.
# tcpdump host dinkel.brot.dg and not host roggen.brot.dg

Analizza tutto il traffico intrattenuto da dinkel.brot.dg e tutti gli altri nodi, a esclusione di roggen.brot.dg.
# tcpdump gateway router.brot.dg

Analizza tutto il traffico che attraversa il nodo router.brot.dg senza essere diretto, o provenire da quello.

190.2.3 Controllo del traffico PPP

Vale la pena di annotare un'idea molto semplice per controllare in modo approssimativo il traffico di una connessione PPP. In questo caso, si pensa a una connessione PPP attraverso linea commutata, intesa come la connessione di un utente che accede a un ISP per collegarsi a Internet. L'esigenza potrebbe nascere nel momento in cui si dovesse sospettare che il modem stia trasmettendo all'esterno dati che non dovrebbe, magari per opera di un software manomesso ad arte per questo scopo.

In un sistema GNU/Linux tipico ci sono diverse console virtuali inutilizzate, che potrebbero essere adibite al monitoraggio continuo del contenuto dei pacchetti che transitano attraverso l'interfaccia ppp0. Per farlo basta usare Tcpdump, con l'aiuto di un filtro come strings, come è già stato descritto. In questo caso, il tutto potrebbe essere avviato dallo script /etc/ppp/ip-up (direttamente o attraverso un altro script specifico). I comandi necessari sono quelli seguenti, supponendo di voler utilizzare la dodicesima console virtuale (/dev/tty12):

#!/bin/sh
#...
#...
/bin/chown root.tty /dev/tty12
/bin/chmod 0600 /dev/tty12
/usr/bin/nohup /usr/sbin/tcpdump -l -i ppp0 -s 0 -w - \
  | /usr/bin/strings > /dev/tty12 &

Si può osservare che si modificano i permessi di accesso al file di dispositivo /dev/tty12 per evitare che altri possano leggere il traffico attraverso il terminale stesso.

In condizioni normali, quando l'interfaccia di rete ppp0 scompare a seguito della conclusione della connessione, anche l'eseguibile tcpdump termina di funzionare.

Volendo complicare le cose, si può anche fare in modo che i dati vengano memorizzati in un registro, per poter fare una verifica successiva in modo più dettagliato:

/usr/bin/nohup /usr/sbin/tcpdump -l -i ppp0 -s 0 -w - \
  | /usr/bin/tee /var/log/ppp0.log
  | /usr/bin/strings > /dev/tty12 &

Come si vede, il file /var/log/ppp0.log viene memorizzato prima di essere ridotto da strings.

190.3 IPTraf

IPTraf ⁽³⁾ è un programma di servizio per l'analisi del traffico IPv4 (in parte anche di quello non IP), che transita attraverso la rete fisica a cui ci si trova connessi. IPTraf è specializzato nel tracciamento delle connessioni e nella produzione di statistiche, senza addentrarsi nella lettura del contenuto dei pacchetti.

IPTraf è fondamentalmente un programma interattivo, che utilizza una console virtuale o un terminale a caratteri, organizzato attraverso dei menù. La figura 190.1 mostra il menù generale di IPTraf.

Figura 190.1. Menù generale di IPTraf.

.---------------------------------------.
| IP traffic monitor                    |
| General interface statistics          |
| Detailed interface statistics         |
| TCP/UDP service monitor               |
| Ethernet station monitor              |
| TCP display filters                   |
| Other protocol filters                |
| Options                               |
| Exit                                  |
`---------------------------------------'

IPTraf può essere configurato attraverso la funzione {Options} che appare nel menù generale. Inoltre, può annotare le informazioni sul traffico all'interno di un registro. Il file di configurazione e quello delle registrazioni vengono creati all'interno della directory /var/lib/iptraf/, che deve essere presente.

Perché possa essere analizzato tutto il traffico della propria rete fisica, è necessario che sia abilitata la modalità promiscua, come descritto nella sezione dedicata alla configurazione di IPTraf.

In questa sezione vengono descritti solo alcuni aspetti di IPTraf. Per il resto si può consultare la documentazione che accompagna questo programma.

Tabella 190.6. IPTraf funziona fondamentalmente in modo interattivo, tuttavia può essere avviato con delle opzioni in modo da raggiungere immediatamente la funzione desiderata.

Sintassi di avvio	Descrizione
`iptraf`	Avviando `iptraf` senza opzioni si ottiene il menù dal quale scegliere il tipo di funzione desiderata.
`iptraf -i`	Con l'opzione `-i` si ottiene immediatamente la selezione della funzione {`IP traffic monitor`}, ovvero il monitor del traffico IP in tempo reale.
`iptraf -g`	Con l'opzione `-g` si ottiene immediatamente la selezione della funzione {`General interface statistics`}, ovvero le statistiche generali delle interfacce presenti.
`iptraf -d interfaccia`	Con l'opzione `-d` e l'aggiunta dell'indicazione di un'interfaccia di rete, si ottiene immediatamente la selezione della funzione {`Detailed interface statistics`}, ovvero le statistiche dettagliate di quell'interfaccia.
`iptraf -s interfaccia`	Con l'opzione `-s` e l'aggiunta dell'indicazione di un'interfaccia di rete, si ottiene immediatamente la selezione della funzione {`TCP/UDP service monitor`}, ovvero il monitor dei servizi TCP e UDP di quell'interfaccia.
`iptraf -e`	Con l'opzione `-e` si ottiene immediatamente la selezione della funzione {`Ethernet station monitor`}, ovvero il monitor delle stazioni Ethernet (riguarda solo le interfacce Ethernet).

La configurazione di IPTraf può essere definita a livelli differenti: la configurazione generale e quella che riguarda i filtri di selezione dei pacchetti da elaborare. La configurazione generale è definibile attraverso la funzione {Options} del menù generale, da cui si accede a quanto si vede nella figura 190.2, che rappresenta anche l'impostazione predefinita.

Figura 190.2. Definizione delle opzioni generali di IPTraf.

.-----------------------.. Enabled Options -----------.
| Reverse DNS lookups   ||                            |
| Promiscuous operation ||                            |
| Color                 || Color                      |
| Logging               ||                            |
| TCP timeout...        ||                            |
| Logging interval...   || TCP timeout:       15 mins |
| Additional port...    || Log interval:      60 mins |
| Delete port...        |`----------------------------'
| Exit menu             |
`-----------------------'

Le opzioni si attivano e si disattivano premendo il tasto [Invio]; quando una voce è terminata da tre punti di sospensione (...), selezionandola si ottiene una finestra a scomparsa attraverso la quale fornire altre indicazioni. Lo stato delle opzioni è indicato dalla finestra destra: {Enabled Options}.

Opzione di configurazione	Descrizione
`Reverse DNS lookups`	Se attivata, fa in modo di risolvere gli indirizzi IP in nomi di dominio corrispondenti. L'attivazione di questa modalità può provocare dei ritardi nel funzionamento di IPTraf, per cui è consigliabile limitarne l'uso. Questa opzione è disattivata in modo predefinito.
`Promiscuous operation`	La modalità promiscua consente a IPTraf si analizzare tutto il traffico della rete fisica, non solo quello che interferisce con il nodo in cui si utilizza. Questa opzione è disattivata in modo predefinito.
`Color`	IPTraf è in grado di determinare automaticamente se il tipo di terminale utilizzato consente la visualizzazione dei colori o meno. Tuttavia, è possibile disabilitare la visualizzazione dei colori attraverso questa opzione.
`Logging`	IPTraf può annotare le informazioni sul traffico all'interno di un file di registrazioni, precisamente `/var/lib/iptraf/iptraf.log`. Questa opzione è disabilitata in modo predefinito dal momento che il registro può diventare rapidamente molto grande.

La funzionalità di controllo del traffico IP rappresenta l'utilizzo più comune di IPTraf. Selezionando la voce corrispondente dal menù generale, oppure avviando iptraf con l'opzione -i, si ottiene qualcosa di simile a quanto mostrato nella figura 190.3, dove in particolare appare anche lo stato di una connessione TELNET tra 192.168.1.1 e 192.168.1.2.

Figura 190.3. Monitor di traffico IP con una connessione TELNET attiva.

. Source -------------- Destination ----------- Packets --- Bytes Flags  Iface .
|/192.168.1.2:1050      192.168.1.1:23               40      1701 --A-   eth0  |
|\192.168.1.1:23        192.168.1.2:1050             31      1435 -PA-   eth0  |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
` TCP: 1 entries --------------------------------------------------- Active ---'
.------------------------------------------------------------------------------.
| ARP from 0000b46507cb to ffffffffffff on eth0                                |
| ARP from 0080adc8a981 to 0000b46507cb on eth0                                |
|                                                                              |
|                                                                              |
|                                                                              |
` Top --------- Elapsed time:   0:01 ------------------------------------------'
 IP:       6150 TCP:      3136 UDP:      3014 ICMP:         0 Non-IP:        2
 Up/Dn/PgUp/PgDn-scrl actv win  W-chg actv win  M-more TCP info  X/Ctrl+X-Exit

Il monitor di traffico IP si compone di due finestre: una superiore per le connessioni TCP e una inferiore per gli altri tipi. Una delle due finestre è quella attiva, che si distingue perché appare la parola Active sul bordo nella parte bassa, al lato destro. All'interno della finestra attiva è possibile fare scorrere le informazioni con i tasti [freccia su] e [freccia giù]; per cambiare la finestra attiva basta utilizzare il tasto [w], come suggerisce il promemoria che appare nell'ultima riga dello schermo. Per uscire da questa funzionalità basta il tasto [x], oppure la combinazione [Ctrl+x].

Non è possibile conoscere quale sia la parte che ha originato la connessione TCP, salvo intuirlo dalle convenzioni sull'uso delle porte; nella finestra relativa, le connessioni TCP vengono sempre mostrate con una coppia di voci: una per ogni direzione della connessione TCP.

Il significato delle varie colonne di informazione che appaiono nella finestra delle connessioni TCP dovrebbe essere abbastanza intuitivo, a parte la colonna Flags, all'interno della quale possono essere annotate lettere e parole chiave differenti. Il significato di queste viene descritto di seguito.

Simbolo	Descrizione
`S`	L'ultimo pacchetto individuato è stato di tipo SYN, sincronizzazione, che si usa in preparazione di una connessione.
`A`	L'ultimo pacchetto individuato è stato di tipo ACK, che si usa per confermare la ricezione precedente di un pacchetto.
`P`	L'ultimo pacchetto individuato è stato di tipo PSH, push, che si usa per richiedere lo spostamento dei dati all'inizio della coda di ricezione.
`U`	L'ultimo pacchetto individuato è stato di tipo URG, che si usa per rappresentare dati urgenti.
`RESET`	La connessione è stata azzerata dal nodo di origine della direzione a cui si riferisce.
`DONE`	La connessione ha terminato l'invio di dati nella direzione a cui si riferisce e ha inviato il pacchetto FIN, ma non è ancora stata confermata la conclusione dall'altro nodo.
`CLOSED`	L'invio precedente del pacchetto FIN è stato confermato dall'altra parte.

Se si verifica una presenza inusuale di pacchetti SYN, può trattarsi di un tentativo di attacco, definito SYN flood, che letteralmente significa: «inondazione di pacchetti SYN».

190.4 Sniffit

Sniffit ⁽⁴⁾ è un programma per l'analisi del traffico di rete, che può essere usato per individuare le connessioni TCP in corso, oppure per conservare una sorta di registro delle comunicazioni avvenute, contenente le comunicazioni stesse.

Naturalmente, la lettura del contenuto dei pacchetti può essere utile a livello didattico, oppure per individuare dei problemi nell'utilizzo della rete, mentre diventa una pratica illegale quando ciò sconfina nel diritto alla riservatezza delle persone.

La sintassi per l'avvio di Sniffit è quella seguente, tenendo conto che almeno un'opzione del primo gruppo è obbligatoria.

sniffit {-v|-s nodo|-t nodo|-i|-I|-c file_di_configurazione}... _<-'
^`->altre_opzioni

Segue la descrizione di alcune opzioni.

Opzione	Descrizione
`-v`	Mostra la versione e non fa altro.
`-s nodo` `-t nodo`	Limitano l'osservazione, rispettivamente, al nodo di origine e al nodo di destinazione indicati. Queste opzioni riguardano solo per il traffico TCP e UDP. L'indirizzo, se espresso in forma numerica, può essere parziale e completato con il simbolo `@`.
`-i` `-I`	Attiva un funzionamento interattivo, dove `-I` mostra più informazioni.
`-c file`	Consente di indicare un file contenente una serie di direttive, attraverso le quali si stabilisce il comportamento di Sniffit.
`-F interfaccia`	Consente di specificare il nome dell'interfaccia di rete a cui fare riferimento.
`-d` `-a`	Mostra i pacchetti sullo schermo, rispettivamente in esadecimale e in ASCII
`-P {IP\|TCP\|UDP\|ICMP}`	Consente di selezionare un tipo di protocollo, tra quelli indicati. Questa opzione è incompatibile con `-i` o `-I`.
`-p n_porta`	Per quanto riguarda i protocolli TCP e UDP, consente di limitare l'attenzione ai pacchetti riferiti alla porta indicata.
`-l n_byte`	Definisce la quantità massima di byte da accumulare per ogni pacchetto. Il valore zero serve a non porre limiti.

Qui viene mostrato soltanto il funzionamento interattivo, con l'opzione -I, all'interno del quale è possibile anche inserirsi in uno dei flussi TCP per leggerne i dati:

# sniffit -I -F eth0

In questo modo si ottiene il funzionamento interattivo, specificando espressamente l'interfaccia (in questo caso si tratta di eth0. Quello che si vede nella figura seguente è soltanto il traffico TCP attivo:

Figura 190.4. Sniffit durante il funzionamento interattivo con l'opzione -I.

.--Sniffit 0.3.7 Beta----------------------------------------------------------.
|        192.168.1.1  32796  ->      192.168.1.2     23  :  TELNET             |
|        192.168.1.2     23  ->      192.168.1.1  32796  :  TELNET             |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
`------------------------------------------------------------------------------'
.--Sniffit 0.3.7 Beta----------------------------------------------------------.
| Source IP     : All               Source PORT     : All                      |
| Destination IP: All               Destination PORT: All                      |
`------------------------------------------------------------------------------'
  Masks: F1-Source IP  F2-Dest. IP  F3-Source Port  F4-Dest. Port

Nel riquadro delle connessioni TCP, appare un cursore, con cui è possibile selezionare, all'interno di una connessione, uno dei due flussi (andata o ritorno). Una volta collocato il cursore sopra un flusso di interesse, basta premere [Invio] per ottenere una finestra in cui appare il contenuto di quella comunicazione:

Figura 190.5. Intercettazione di una copia del flusso di dati.

.--Sniffit 0.3.7 Beta----------------------------------------------------------.
|        192.168.1.1  32796  ->      192.168.1.2     23  :  TELNET             |
|        192.168.1.2     23  ->      192.168.1.1  32796  :  TELNET             |
|                            .-----------------------------------------------. |
|                            |tizio..baci47..                                | |
|                            |                                               | |
|                            |                                               | |
|                            |                                               | |
|                            |                                               | |
|                            |                                               | |
|                            |                                               | |
|                            |                                               | |
|                            |-----------------------------------------------| |
|                            | 192.168.1.1  32796  ->      192.168.1.2     23| |
|                            `-----------------------------------------------' |
|                                                                              |
|                                                                              |
|                                                                              |
|                                                                              |
`------------------------------------------------------------------------------'
.--Sniffit 0.3.7 Beta----------------------------------------------------------.
| Source IP     : All               Source PORT     : All                      |
| Destination IP: All               Destination PORT: All                      |
`------------------------------------------------------------------------------'
  Masks: F1-Source IP  F2-Dest. IP  F3-Source Port  F4-Dest. Port

Come si può intuire dalla figura, in questo caso si intercetta il flusso dei dati trasmessi da un cliente TELNET, proprio nella fase dell'autenticazione: l'utente tizio, con la parola d'ordine baci47.⁽⁵⁾

190.5 Ethereal

Ethereal ⁽⁶⁾ è un programma per l'analisi del traffico di rete, fino al livello due del modello ISO-OSI (collegamento dati), riuscendo a riconoscere all'interno di questo una serie di protocolli al livello tre e quattro del modello ISO-OSI (rete). In particolare, individua correttamente molti protocolli collegati a IPv4 e IPv6.

Ethereal è pensato principalmente per accumulare il traffico intercettato, allo scopo di consentire un'analisi dettagliata di questo in un momento successivo; nello stesso modo è predisposto per accedere a informazioni di questo genere accumulate da programmi diversi, così come è in grado di esportare i propri dati in formati alternativi.

Ethereal consente anche una visualizzazione in tempo reale del traffico in corso, in modo analogo a quanto fa IPTraf, con la differenza che le informazioni fornite sono molto più chiare. In questo senso, Ethereal è un ottimo strumento didattico per lo studio delle reti.

Ethereal viene usato normalmente attraverso il sistema grafico X e deve funzionare con i privilegi dell'utente root, per poter accedere direttamente all'interfaccia di rete da sondare. L'eseguibile da avviare è ethereal:

ethereal [opzioni]

Qui si intende mostrare il funzionamento di Ethereal in modo interattivo, senza l'uso di opzioni nella riga di comando. Eventualmente si può consultare la pagina di manuale ethereal(1).

Figura 190.6. Ethereal avviato senza opzioni, rimane in attesa prima di iniziare la sua analisi.

figure/a2-ethereal-avvio

Una volta avviato l'eseguibile ethereal, per ottenere un'analisi del traffico in tempo reale può essere necessario controllare la configurazione. Si trova la voce {Preferences} nel menù {Edit}:

Figura 190.7. La finestra di configurazione di Ethereal per quanto riguarda la selezione dei pacchetti catturati.

figure/a2-ethereal-configurazione

La figura mostra in particolare la selezione della modalità promiscua, con cui si intercettano tutti i pacchetti che l'interfaccia di rete selezionata è in grado di osservare.

Una volta definita la configurazione e selezionata l'interfaccia di rete di interesse, si può passare alla cattura dei pacchetti, selezionando la voce {Start} dal menù {Capture}. Si ottiene una finestra da cui è possibile aggiustare le opzioni relative alla cattura:

Figura 190.8. La finestra che appare quando si chiede di iniziare la cattura dei pacchetti.

figure/a2-ethereal-cattura-avvio

Durante la cattura dei pacchetti viene visualizzata una statistica sull'avanzamento di questo lavoro, dove appare un pulsante grafico che consente di fermare l'accumulo dei dati. Se era stata richiesta la visualizzazione in tempo reale delle informazioni relative alla cattura, anche il contenuto dei pacchetti viene visualizzato nella finestra principale di Ethereal.

Figura 190.9. Statistiche visualizzate durante la cattura dei pacchetti.

figure/a2-ethereal-cattura-statistica

La finestra principale di Ethereal si divide in tre parti: in quella superiore appare l'elenco di pacchetti intercettati con una descrizione essenziale del loro contenuto; selezionando un pacchetto nella parte superiore, in quella centrale appare un elenco ad albero di componenti del pacchetto stesso; selezionando una voce nell'elenco del riquadro centrale, appare in quello inferiore l'evidenziamento della porzione di pacchetto che lo riguarda. La figura seguente mostra la porzione IP di un pacchetto relativo a una comunicazione TELNET:

Figura 190.10. Porzione IP di un pacchetto relativo a una comunicazione TELNET.

figure/a2-ethereal-cattura-telnet-ip

Nella figura successiva, si analizzano i dati TCP dello stesso pacchetto, mostrando in particolare dove si colloca l'informazione sulla porta di destinazione:

Figura 190.11. Porta di destinazione TCP di un pacchetto relativo a una comunicazione TELNET.

figure/a2-ethereal-cattura-telnet-tcp

190.6 IPlogger

IPlogger ⁽⁷⁾ è un pacchetto di programmi contenente alcuni demoni che si occupano di annotare le connessioni all'interno del registro del sistema. Allo stato attuale si tratta solo di tcplog e di icmplog, in grado rispettivamente di annotare le connessioni TCP e l'utilizzo del protocollo ICMP. Non è niente di eccezionale, ma qualcosa di utile nel caso non si abbiano strumenti migliori.

Non c'è molto da aggiungere sull'utilizzo di questi due demoni: basta fare in modo che la procedura di inizializzazione del sistema provveda ad avviarli e loro si arrangiano. Non occorre alcuna configurazione.

È probabile che questo pacchetto abbia uno sviluppo futuro, aggiungendo varie forme di identificazione di attacchi noti.

190.7 Netcat6

Netcat6 ⁽⁸⁾ è un programma creato allo scopo di leggere e scrivere dati attraverso delle connessioni di rete TCP o UDP. Si tratta di uno strumento generico, vagamente simile a un cliente TELNET, con la differenza che può funzionare anche con il protocollo UDP. Le potenzialità di questo programma sono notevoli, ma qui verranno mostrate solo alcune delle sue caratteristiche; per il resto si può leggere la sua documentazione, che per essere compresa richiede comunque un po' di esperienza nella gestione delle reti TCP/IP.

Netcat6 può funzionare, quasi indifferentemente, come cliente o servente di una connessione; per questo è uno strumento ottimale per la verifica del funzionamento delle connessioni di rete e non solo. In un certo senso, l'eseguibile nc6, ovvero ciò che costituisce Netcat6, è paragonabile idealmente al programma dd, con la differenza che invece di fare riferimento a dei dispositivi, si lavora con la rete a livello di trasporto TCP e UDP: il quarto nel modello ISO-OSI.

L'eseguibile nc6 è tutto ciò che compone Netcat6. Questo programma instaura una connessione, in qualità di cliente o di servente, utilizzando il protocollo TCP oppure UDP, trasmettendo ciò che ottiene dallo standard input e restituendo attraverso lo standard output ciò che riceve dall'altro capo.

nc6 [opzioni] host porta

nc6 -l -p porta [host [porta]]

L'uso di Netcat6 differisce fondamentalmente a seconda del fatto che si voglia raggiungere un servizio in ascolto presso un nodo, a una porta determinata, oppure che si intenda avviarlo per restare in ascolto in attesa di una richiesta di connessione. Nel secondo caso si usa l'opzione -l (Listen).

Il funzionamento di questo programma si comprende meglio attraverso degli esempi, ma per il momento viene mostrato il significato di alcune opzioni.

Opzione	Descrizione
`-4`	Forza l'utilizzo di IPv4.
`-6`	Forza l'utilizzo di IPv6.
`-l`	Fa in modo che Netcat6 venga avviato per restare in ascolto di una certa porta (specificata attraverso l'opzione `-p`).
`-p porta`	Permette di specificare la porta a cui Netcat6 deve prestare ascolto. Si usa assieme all'opzione `-l`.
`-n`	Fa in modo che si eviti di tentare di risolvere gli indirizzi IP in nomi di dominio.
`-s indirizzo_ip_locale`	Definisce esplicitamente l'indirizzo IP locale. Perché ciò possa essere fatto, occorre che questo indirizzo sia abbinato effettivamente a un'interfaccia di rete, eventualmente anche solo come alias.
`-u`	Utilizza il protocollo UDP. Senza questa opzione, viene usato il protocollo TCP in modo predefinito.

L'esempio seguente, serve a instaurare una connessione TCP con il servente SMTP dinkel.brot.dg:

$ nc6 dinkel.brot.dg smtp

Un uso interessante di Netcat6 è quello con il quale si ottiene un trasferimento dati senza bisogno di una shell remota (rsh per esempio). Per questo, da una parte occorre avviare l'eseguibile nc6 in ascolto di una certa porta TCP, mentre dall'altra si utilizza sempre nc6 in modo che cerchi di contattare quella porta di quel nodo. Il canale che si crea può essere sfruttato per questo scopo.

$ nc6 -l -p 1234 | tar xzpvf -

In questo modo, Netcat6 viene avviato in ascolto della porta 1 234, che si presume sia libera. Il suo standard output viene passato a tar che deve occuparsi di estrarne il contenuto nella directory corrente. In pratica, si presume che Netcat6 debba ricevere dalla porta 1 234 un file corrispondente a un archivio tar+gzip e che questo debba essere riprodotto localmente.
$ tar czf - /home/tizio | nc6 dinkel.brot.dg 1234

Questo comando è la controparte dell'esempio mostrato prima: viene archiviata la directory /home/tizio/ e passata all'eseguibile nc6 attraverso una pipeline. Evidentemente, dinkel.brot.dg è il nodo all'interno del quale deve essere riprodotta tale directory.

Netcat6 può essere usato per ridirigere una connessione TCP, per esempio attraverso un firewall. Gli esempi seguenti si riferiscono a Inetd, pertanto si tratta di direttive del file /etc/inetd.conf.

www stream tcp nowait nobody /usr/sbin/tcpd /usr/bin/nc6 roggen.brot.dg 80

In questo caso, le richieste TCP per la porta www (ovvero 80), sono ridirette attraverso Netcat6 verso il nodo roggen.brot.dg alla stessa porta.

www stream tcp nowait nobody /usr/sbin/tcpd /usr/bin/nc6 roggen.brot.dg 1234

Questa è solo una piccola variante dell'esempio precedente, in cui si presume che il vero servente HTTP si trovi sempre nel nodo roggen.brot.dg, ma sia in ascolto della porta 1 234.

1) net-tools GNU GPL

2) Tcpdump software libero con licenza speciale

3) IPTraf GNU GPL

4) Sniffit software libero con licenza speciale

5) Questo esempio viene mostrato proprio per far comprendere quanto vulnerabile sia un terminale remoto che non utilizzi una comunicazione cifrata.

6) Ethereal GNU GPL

7) IPlogger GNU GPL

8) Netcat6 GNU GPL

`! \| not`	un punto esclamativo o la parola chiave `not` rappresenta la negazione logica;
`&& \| and`	una doppia e-commerciale (`&&`) o la parola chiave `and` rappresenta il concatenamento, ovvero un AND logico;
`\|\| \| or`	una doppia barra verticale (`\|\|`) o la parola chiave `or` rappresenta l'alternanza, ovvero un OR logico.