[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


214. Firewall secondo la gestione del kernel Linux 2.2.*

All'interno di una rete, il firewall è un componente che serve a proteggerne una parte rispetto al resto. Di solito, si tratta di qualcosa che si interpone tra una rete interna e una rete esterna, come Internet, per evitare un accesso indiscriminato alla rete interna da parte di nodi collocati all'esterno di questa.

Il firewall, a parte il significato letterale del nome, è una sorta di filtro (passivo o attivo) che si interpone al traffico di rete, e che pertanto deve essere regolato opportunamente, in base agli obiettivi che si intendono raggiungere.

			+----------+          Rete interna da proteggere
- - - ------------------| Firewall |------------*-----------*-------- - - -
Rete esterna		+----------+		|           |
(Internet)				    +--------+	+--------+
					    |  host  |	|  host  |
					    +--------+	+--------+

Figura 214.1: Il firewall è un filtro che si interpone tra una rete interna e una rete esterna.

Generalmente, i compiti del firewall vengono svolti da un elaboratore configurato opportunamente, e munito di almeno due interfacce di rete: una per l'accesso alla rete esterna e una per la rete interna.

Questo capitolo, dopo una breve introduzione generale ai concetti legati ai firewall, affronta in dettaglio solo le funzionalità di filtro di pacchetto IP native del kernel Linux.

Per approfondire il problema si invita a leggere Linux IPCHAINS-HOWTO di Paul Russell, che spiega in modo semplice e chiaro tutti gli aspetti legati alla gestione del firewall secondo il kernel Linux.

214.1 Firewall elementare

Il firewall elementare è un elaboratore con due interfacce di rete, per le quali siano stati definiti gli instradamenti nel modo consueto, ma dove sia stato impedito il transito del traffico tra un'interfaccia e l'altra.

L'utilità di un filtro del genere è minima. Probabilmente si potrebbe utilizzare come servente SMTP e come punto di arrivo per i messaggi di posta elettronica, che gli utenti della rete interna potrebbero scaricare attraverso un protocollo come POP3, o IMAP. Inoltre, gli utenti che desiderano accedere alla rete esterna, potrebbero utilizzare Telnet per collegarsi al firewall per poi avviare da lì il programma cliente adatto all'operazione che vogliono compiere.

Evidentemente, questa non deve essere intesa come una scelta ottimale, anzi, di sicuro si tratta di un approccio sbagliato dal punto di vista della sicurezza, ma serve a rendere l'idea del significato che può avere un firewall.

Volendo, l'inserimento di una cache proxy all'interno del firewall potrebbe permettere agli utenti della rete interna che dispongono di software adatto, di accedere alle risorse della rete esterna (di solito solo con i protocolli HTTP e FTP).

All'estremo opposto, un router è un firewall che consente il transito di tutto il traffico, senza porre alcun limite, né alcun controllo.

214.2 Tipologie fondamentali

Si distinguono due tipi fondamentali di firewall: filtri di pacchetto IP e servente proxy. Il kernel Linux aggiunge alle funzionalità di filtro di pacchetto anche il mascheramento e il proxy trasparente, che comunque vengono descritte più avanti in un altro capitolo.

I filtri di pacchetto IP permettono di bloccare o abilitare selettivamente il traffico che attraversa il firewall, definendo i protocolli (o meglio, il tipo di pacchetto), gli indirizzi IP e le porte utilizzate. Questo tipo di sistema permette al massimo di controllare i tipi di servizio che possono essere utilizzati in una direzione e nell'altra, da e verso indirizzi IP determinati, ma senza la possibilità di annotare in un registro i collegamenti che sono stati effettuati (salvo eccezioni), né di poter identificare gli utenti che li utilizzano. In un certo senso, questo tipo di firewall è come un router su cui si può soltanto filtrare il tipo dei pacchetti che si vogliono lasciar transitare.

I servente proxy rappresentano una sorta di intermediario che si occupa di intrattenere le connessioni per conto di qualcun altro nella rete interna. Per tornare all'esempio del firewall elementare, è come se un utente aprisse una connessione Telnet verso il proxy, e poi da lì utilizzasse un programma cliente adatto per il tipo di collegamento che intende realizzare al di fuori della sua rete interna. Dal momento che il proxy ha un ruolo attivo nelle connessioni, può tenere un registro delle azioni compiute, ed eventualmente anche tentare di identificare l'utente che tenta di utilizzarlo.

Per completare il discorso, una cache proxy è qualcosa di simile al servente proxy a cui si sta facendo riferimento. La differenza sta essenzialmente nella specializzazione che nel primo caso è puntata alla gestione di una memoria cache, mentre nel secondo è rivolta alla protezione della rete interna.

214.3 Filtri di pacchetto IP del kernel Linux

Il kernel Linux può gestire direttamente il filtro dei pacchetti IP, cosa che quindi rappresenta la scelta più semplice per la realizzazione di un firewall con questo sistema operativo. A parte le limitazioni che può avere un tale tipo di firewall, il suo inserimento nella rete non genera effetti collaterali particolari, dal momento che poi non c'è bisogno di utilizzare software speciale per i clienti, come avviene invece nel caso di un firewall di tipo proxy.

Trattandosi di un'attività del kernel, è necessario che questo sia stato predisposto in fase di compilazione, oppure sia accompagnato dai moduli necessari.

In aggiunta, è opportuno aggiungere anche le funzionalità seguenti per il proxy trasparente e il mascheramento IP.

L'attraversamento dei pacchetti tra un'interfaccia e l'altra è controllato dalla funzionalità di forwarding/gatewaying, che in passato andava inserita esplicitamente nel kernel. In generale, il kernel non permette questo attraversamento, che deve essere abilitato attraverso un comando simile a quello seguente:

echo 1 > /proc/sys/net/ipv4/ip_forward

214.3.1 Schema generale di funzionamento del kernel

Gli elementi del kernel che si occupano delle funzionalità di filtro IP sono definite IP chain. Si distinguono tre filtri (chain): uno in ingresso, uno di inoltro e uno in uscita. A seconda delle circostanze, un pacchetto IP può essere sottoposto alla verifica di uno o più di questi filtri, che vengono programmati in base a delle regole. Quando un pacchetto sottoposto a controllo corrisponde a una regola, la sua sorte viene definita dall'obiettivo di questa (ammesso che sia stato definito).

	+-------------+		+-------------+		+-------------+
	| Ingresso    |		| Inoltro     |		| Uscita      |
	|             |         |             |         |             |
	| Regole per  |		| Regole per  |         | Regole per  |
	| l'ingresso  |         | l'attraver- |         | l'uscita    |
	| dei         |         | samento dei |         | dei         |
	| pacchetti   |         | pacchetti   |         | pacchetti   |
	|             |         |             |         |             |
	|             |         |             |         |             |
	| Politica    |         | Politica    |         | Politica    |
        | predefinita |         | predefinita |         | predefinita |
	+-------------+		+-------------+		+-------------+

Figura 214.2: Schema dei filtri della gestione del kernel Linux.

Un pacchetto proveniente da un'interfaccia qualunque, e diretto allo stesso firewall o passante per questo, è soggetto al controllo del filtro di ingresso; un pacchetto passante, dopo il controllo del filtro di ingresso viene sottoposto al controllo del filtro di inoltro; un pacchetto che deve uscire attraverso un'interfaccia del firewall è sottoposto al controllo del filtro in uscita. In pratica, i pacchetti che devono attraversare il firewall sono sottoposti a tutti questi filtri in questa sequenza.

Quando un pacchetto IP è sottoposto al vaglio di un filtro e all'interno di questo non c'è alcuna regola che lo prenda in considerazione, la sua sorte è stabilita dalla politica predefinita (policy) per quel filtro, e generalmente questa è tale per cui il pacchetto viene lasciato transitare.

214.3.2 ipchains per l'amministrazione del firewall

La gestione del filtro di pacchetto IP del kernel deve essere regolata in qualche modo, e questo avviene attraverso il programma `ipchains', ovvero l'«amministratore del firewall IP». Dal momento che le funzionalità di firewall del kernel sono piuttosto estese, la sintassi di questo programma è molto articolata, e se ne può apprendere l'utilizzo solo gradualmente.

Inoltre, è bene chiarire subito che le funzionalità di firewall del kernel non possono essere definite attraverso un file di configurazione; quindi, al massimo, tutto quello che si può fare è la realizzazione di uno script contenente una serie di comandi con `ipchains'.

`ipchains' interviene su un elenco di regole riferite alle funzionalità di firewall del kernel; un po' come avviene con la tabella degli instradamenti di un router. L'ordine in cui sono elencate tali regole è importante, quindi si deve poter distinguere tra l'inserimento di una regola all'inizio, alla fine o in un'altra posizione dell'elenco esistente.

Salvo eccezioni particolari, che verranno descritte nel contesto opportuno, la sintassi di massima per l'utilizzo di `ipchains' è quella seguente:

ipchains <opzione-di-comando> <filtro> [<regola>] [<obiettivo>]

L'opzione di comando serve a stabilire il tipo di intervento nel sistema di gestione del firewall. L'elenco seguente si riferisce alle opzioni che permettono la cancellazione o l'inserimento delle regole in un filtro:

Altre opzioni non modificano le regole; in particolare:

Altre opzioni verranno mostrate quando sarà più opportuno.

Il filtro viene indicato attraverso un nome. Si tratta di `input', `forward' e `output', che intuitivamente fanno riferimento al filtro di ingresso, quello di inoltro e quello di uscita.

Il programma `ipchains' permette di gestire delle regole all'interno di contenitori aggiuntivi a cui si fa riferimento a partire da regole inserite nei filtri normali. Nella terminologia di `ipchains' si parla sempre di chain, sia per indicare i filtri, sia per indicare questi elenchi di regole aggiuntive.

Infine, una regola comune è conclusa con l'indicazione di un obiettivo. L'obiettivo è la definizione della sorte da dare al pacchetto intercettato, e si indica attraverso una parola chiave. Le più importanti per iniziare ad apprendere la configurazione del firewall sono: `ACCEPT', `DENY' e `REJECT'.

Esempi

ipchains -A input <regola> -j DENY

Lo schema mostra l'aggiunta di una regola di ingresso, non meglio definita, per la quale viene applicato l'obiettivo `DENY'.

ipchains -R input 1 <regola> -j DENY

Lo schema mostra la sostituzione della prima regola nel filtro di ingresso con un'altra regola non meglio definita, per la quale viene applicato l'obiettivo `DENY'.

ipchains -I input 1 <regola> -j ACCEPT

Lo schema mostra l'inserimento nella prima posizione di una regola di ingresso per la quale viene consentito il transito dei pacchetti (`ACCEPT').

ipchains -D input 2

Questo comando elimina la seconda regola del filtro di ingresso.

ipchains -F input

Questo comando elimina tutte le regole del filtro di ingresso.

ipchains -F

Questo comando elimina tutte le regole di tutti i filtri.

ipchains -P input DENY

Cambia la politica predefinita del filtro di ingresso specificando che, in mancanza di regole, i pacchetti devono essere bloccati.

214.3.3 Un po' di confidenza con ipchains per la gestione del firewall

Data la complessità delle funzionalità di filtro di pacchetto del kernel, anche l'uso di `ipchains' è piuttosto articolato. Prima di iniziare a vedere come si possono definire le regole, conviene fare qualche esperimento che serva a introdurre l'uso di questo programma.

La prima cosa da sapere è in che modo si ottiene la visualizzazione della situazione dei filtri che compongono il sistema.

ipchains -L

In questo modo si ottiene la situazione di tutti i filtri (ed eventualmente anche dei raggruppamenti di regole aggiuntivi). Inizialmente si dovrebbe osservare la situazione seguente:

Chain input (policy ACCEPT):
Chain forward (policy ACCEPT):
Chain output (policy ACCEPT):

Quello che si vede è la situazione normale del sistema prima di iniziare a inserire delle regole; tutto quello che c'è sono le politiche predefinite per ogni filtro.

Se si è interessati a conoscere solo la situazione di un filtro particolare, basta aggiungere il nome di questo. Per esempio, per limitare il risultato al solo filtro di ingresso si può usare il comando seguente:

ipchains -L input

Chain input (policy ACCEPT):

Per verificare l'effetto del blocco del traffico attraverso uno dei filtri si può agire sommariamente sulla politica predefinita; per esempio si può bloccare il transito dei pacchetti in ingresso con il comando seguente:

ipchains -P input DENY

Questo tipo di blocco è totale e interviene anche nell'interfaccia virtuale che identifica il sistema locale: `lo'. Basta provare a fare un ping verso il nodo locale per accorgersi che non si ottiene più alcuna risposta.

ping localhost

Un risultato simile si poteva ottenere utilizzando l'obiettivo `REJECT'. In alternativa si può intervenire nel filtro di uscita; nell'esempio seguente si ripristina prima la politica di `ACCEPT' per i pacchetti in ingresso.

ipchains -P input ACCEPT

ipchains -P output DENY

Con il ping si ottiene in pratica lo stesso risultato, con la differenza che i pacchetti trasmessi vengono accettati, mentre la risposta a questi viene a mancare.

Se invece si interviene nel filtro di inoltro (o di transito), si avverte l'effetto solo nei pacchetti che devono attraversare il firewall da un'interfaccia a un'altra. Prima di tutto è bene ricordare che questi possono transitare solo se la cosa viene abilitata attraverso il comando:

echo 1 > /proc/sys/net/ipv4/ip_forward

Il comando seguente, per quanto inutile, impedisce il transito dei pacchetti tra le interfacce, attraverso la gestione del firewall, con la modifica della politica predefinita del filtro relativo:

ipchains -P forward DENY

Prima di proseguire è bene rimettere a posto le politiche predefinite dei tre filtri:

ipchains -P input ACCEPT

ipchains -P output ACCEPT

ipchains -P forward ACCEPT

214.3.4 Opzioni di contorno

Prima di affrontare l'analisi delle regole che possono essere inserite nei filtri del firewall, è meglio descrivere subito l'utilizzo di alcune opzioni di contorno che hanno un'importanza minore, oppure che si possono utilizzare indipendentemente dal tipo di protocollo a cui si fa riferimento con una regola.

Opzioni

-v | --verbose

Questa opzione si utilizza generalmente assieme all'opzione di comando `-L', allo scopo di rendere più dettagliata l'informazione che si ottiene.

-n | --numeric

Quando `ipchains' viene usato per ottenere delle informazioni, con questa opzione si fa in modo che gli indirizzi numerici non siano convertiti in nomi. Ciò può essere utile per evitare l'attesa di una risoluzione da parte del sistema DNS che potrebbe essere inaccessibile.

-p [!] {tcp|udp|icmp|all}

--protocol [!] {tcp|udp|icmp|all}

Stabilisce il tipo di protocollo della regola che viene definita. La parola chiave `all' rappresenta qualsiasi protocollo, ed è l'impostazione predefinita se questo non viene specificato. Le parole chiave che identificano i protocolli possono essere espresse anche attraverso lettere maiuscole. Il punto esclamativo, se utilizzato, serve a fare riferimento a tutti i protocolli fuorché quello indicato.

-l | --log

Questa è un'opzione che si utilizza nella dichiarazione di una regola e serve a richiedere l'annotazione nel registro del sistema di ogni pacchetto che corrisponda alla regola stessa. È evidente che si tratta di una possibilità da usare per compiere delle verifiche solo quando ne esiste la necessità.

-i [!] <interfaccia>

--interface [!] <interfaccia>

Questa è un'opzione che si utilizza nella dichiarazione di una regola e serve a indicare il nome dell'interfaccia di rete attraverso la quale sono ricevuti o inviati i pacchetti della regola che si sta definendo. Quando questa opzione non viene usata, si intende fare riferimento implicitamente a qualunque interfaccia di rete.

-j <obiettivo>

--jump <obiettivo>

Questa è un'opzione che si utilizza nella dichiarazione di una regola e serve a definire l'obiettivo, attraverso una parola chiave tra quelle consuete, oppure il riferimento a un gruppo di regole creato a parte.

Esempi

ipchains -L input -v

Elenca le regole di ingresso in modo dettagliato.

ipchains -L output -n

Elenca le regole di uscita senza tradurre gli indirizzi in nomi.

ipchains -A <filtro> <regola> -l -j DENY

Lo schema mostra l'indicazione di una regola non meglio definita, con la quale di vogliono intercettare dei pacchetti da bloccare (l'obiettivo è `DENY'). Questi pacchetti, anche se vengono bloccati, sono annotati nel registro del sistema.

ipchains -A <filtro> <regola> -i eth0 -j DENY

Lo schema mostra l'aggiunta in coda di una regola non meglio identificata, nella quale viene specificato in particolare che deve riferirsi al traffico entrante o uscente dall'interfaccia `eth0'. Per i pacchetti che vengono intercettati dalla regola, viene applicato l'obiettivo `DENY'.

ipchains -A <filtro> -p tcp <regola> -i eth0 -j DENY

Lo schema mostra l'aggiunta in coda di una regola non meglio identificata, nella quale viene specificato in particolare che deve riferirsi al traffico TCP entrante o uscente dall'interfaccia `eth0'. Per i pacchetti che vengono intercettati dalla regola, viene applicato l'obiettivo `DENY'.

ipchains -A <filtro> -p ! tcp <regola> -i ! eth0 -j DENY

Lo schema mostra l'aggiunta in coda di una regola non meglio identificata, nella quale viene specificato in particolare che deve riferirsi a tutto il traffico che non sia TCP, entrante o uscente da un'interfaccia qualunque purché non sia `eth0'. Per i pacchetti che vengono intercettati dalla regola, viene applicato l'obiettivo `DENY'.

214.3.5 Regole che non fanno riferimento a un protocollo

Le regole che non indicano un protocollo particolare possono servire esclusivamente a individuare il traffico riferito a un'origine e a una destinazione, con l'indicazione eventuale dell'interfaccia:

[-p all] [-s [!] <origine>] [-d [!] <destinazione>] [-i <interfaccia>]

Come si vede dallo schema, si possono utilizzare le opzioni `-s' e `-d' per indicare rispettivamente l'origine e la destinazione di un pacchetto. In aggiunta, si potrebbe inserire l'indicazione di una certa interfaccia attraverso cui i pacchetti vengono ricevuti o trasmessi; inoltre, volendo indicare espressamente che non si fa riferimento a un protocollo particolare, si può aggiungere l'opzione `-p' con l'argomento `all'.

La definizione di un gruppo di indirizzi IP può essere fatta attraverso l'indicazione di una coppia <numero-IP>/<maschera>, con una barra obliqua di separazione tra i due. La maschera può essere indicata nel modo consueto, oppure con un numero che esprime la quantità di bit iniziali da porre al valore uno. A titolo di esempio, la tabella 214.1 mostra l'equivalenza tra alcune maschere di rete tipiche e questo numero di abbreviazione.

Maschera di rete Abbreviazione Sottorete
255.0.0.0 8 Classe A
255.255.0.0 16 Classe B
255.255.255.0 24 Classe C
255.255.255.255 32 punto-punto

Tabella 214.1: Maschere di rete tipiche per IPv4.

Quando si vuole fare riferimento a indirizzi imprecisati, si utilizza solitamente l'indirizzo 0.0.0.0, che può essere indicato anche con un solo zero; questo si abbina di solito alla maschera nulla: 0.0.0.0/0 o 0/0. Tuttavia, per fare riferimento a qualunque indirizzo, è sufficiente omettere la sua indicazione, in pratica basta fare a meno di indicare l'opzione `-s' o `-d'.

L'indicazione di un indirizzo può essere fatta utilizzando direttamente il nome di dominio corrispondente, ma questo richiede la disponibilità di un servizio DNS, e di solito può essere conveniente quando si tratta di un firewall connesso stabilmente con la rete esterna, altrimenti si creerebbero delle attese inutili e fastidiose, nel tentativo di risolvere dei nomi che non sono di competenza delle zone locali. Pertanto, in generale, è preferibile indicare indirizzi in forma numerica.

Il punto esclamativo che può essere inserito facoltativamente di fronte all'indicazione di un indirizzo IP, o di un gruppo di indirizzi, rappresenta la negazione logica e serve a fare riferimento al gruppo di indirizzi complementare.

Rappresentazione dell'origine e della destinazione

-s [!] <indirizzo>[/<maschera>]

--source [!] <indirizzo>[/<maschera>]

Permette di definire l'origine dei pacchetti. L'indirizzo viene indicato generalmente in forma numerica, anche se c'è la possibilità di usare un nome di dominio. La maschera, eventuale, serve a indicare un gruppo di indirizzi.

Se questo parametro viene omesso, si intende implicitamente `-s 0.0.0.0/0', ovvero `-s 0/0', che rappresenta tutti gli indirizzi possibili.

-d [!] <indirizzo>[/<maschera>]

--destination [!] <indirizzo>[/<maschera>]

Permette di definire la destinazione dei pacchetti. L'indirizzo viene indicato generalmente in forma numerica, anche se c'è la possibilità di usare un nome di dominio. La maschera, eventuale, serve a indicare un gruppo di indirizzi.

Se questo parametro viene omesso, si intende implicitamente `-d 0.0.0.0/0', ovvero `-d 0/0', che rappresenta tutti gli indirizzi possibili.

Esempi

ipchains -A input -s 192.168.100.0/24 -j DENY

Blocca tutto il traffico in ingresso proveniente dalla rete 192.160.100.*.

ipchains -A input -s 192.168.100.0/24 -d 0/0 -j DENY

Esattamente come nell'esempio precedente.

ipchains -A input -s 192.168.100.0/24 -d 0/0 -i eth0 -j DENY

Come nell'esempio precedente, specificando però che questo traffico in ingresso deve provenire dall'interfaccia `eth0' (se provenisse da un'altra interfaccia, non verrebbe intercettato da questa regola).

ipchains -A input -d 192.168.100.0/24 -j DENY

Blocca tutto il traffico in ingresso che risulta destinato alla rete 192.160.100.*.

ipchains -A input -s 0/0 -d 192.168.100.0/24 -j DENY

Esattamente come nell'esempio precedente.

ipchains -A input -s 0/0 -d ! 192.168.100.0/24 -j DENY

Blocca tutto il traffico in ingresso che risulta destinato a indirizzi diversi dalla rete 192.160.100.*.

ipchains -A output -d 192.168.100.0/24 -j DENY

Blocca tutto il traffico in uscita che risulta destinato alla rete 192.160.100.*. Rispetto all'applicazione di questa regola nel filtro di ingresso, in questo caso si impedisce anche al firewall stesso di accedere a questi indirizzi.

214.3.6 Utilizzo pratico di regole elementari

Come negli esempi mostrati in precedenza, in cui si agiva soltanto sulla politica predefinita, con la stessa semplicità si può sperimentare l'uso delle regole. Per cominciare, quando il comando `ipchains -L' genera il risultato

Chain input (policy ACCEPT):
Chain forward (policy ACCEPT):
Chain output (policy ACCEPT):

significa che non ci sono regole per alcun filtro (e le politiche predefinite non oppongono resistenza al transito dei pacchetti). Attraverso una regola molto semplice è possibile bloccare qualunque ingresso attraverso l'interfaccia virtuale corrispondente a `localhost', cioè all'indirizzo 127.0.0.1:

ipchains -A input -s 127.0.0.1 -j DENY

Se si tenta di fare il ping verso il nodo locale, questo non genera alcuna risposta, dal momento che tutti i pacchetti in ingresso vengono eliminati. Anticipando un po' quello che verrà descritto in seguito, se lo scopo fosse stato esclusivamente quello di impedire l'ingresso dei pacchetti del protocollo ICMP (cosa che tra l'altro impedisce il ping), si poteva usare un comando più specifico:

ipchains -A input -p icmp -s 127.0.0.1 -j DENY

Se sono stati eseguiti gli esempi, il comando `ipchains -L input' dovrebbe generare il risultato seguente:

Chain input (policy ACCEPT):
target     prot opt     source                destination           ports
DENY       all  ------  localhost             anywhere              n/a
DENY       icmp ------  localhost             anywhere              any ->   any

Prima di fare altre considerazioni, conviene osservare la simbologia usata nel rapporto che è stato ottenuto: la colonna `prot' rappresenta il protocollo di riferimento; la colonna `opt' rappresenta delle specificazioni opzionali delle regole che in questo caso non sono mai state utilizzate; le colonna `source' e `destination' rappresentano l'origine e la destinazione dei pacchetti, e in particolare la parola chiave `anywhere' esprime in pratica ciò che altrimenti si indicherebbe con la notazione 0.0.0.0/0; infine, la colonna `ports' indica le porte coinvolte, dove `n/a' significa che si tratta di un'informazione non disponibile per il tipo di regola, e `any' rappresenta qualsiasi porta. Si osservi la differenza nel risultato nel caso si utilizzi l'opzione `-n', ovvero il comando `ipchains -L input -n', allo scopo di eliminare le rappresentazioni simboliche degli indirizzi.

Chain input (policy ACCEPT):
target     prot opt     source                destination           ports
DENY       all  ------  127.0.0.1             0.0.0.0/0             n/a
DENY       icmp ------  127.0.0.1             0.0.0.0/0             * ->   *

Le regole hanno una sequenza precisa, e avendo utilizzato sempre l'opzione di comando `-A', queste sono state aggiunte di seguito. Come si può intuire, la seconda regola è inutile, dal momento che i pacchetti che potrebbero riguardarla vengono già presi in considerazione da quella precedente che li blocca completamente per conto proprio.

Le regole possono essere eliminate in modo selettivo attraverso l'opzione di comando `-D', oppure in modo complessivo attraverso l'opzione `-F'. Per eliminare la prima regola, si potrebbe utilizzare uno dei due comandi seguenti:

ipchains -D input -s 127.0.0.1 -j DENY

ipchains -D input 1

Nel primo caso viene eliminata la prima regola che corrisponde al modello, cioè la prima, mentre il secondo comando fa riferimento direttamente al numero della regola. Naturalmente, dopo l'eliminazione della prima regola, quella che prima era la seconda diventa la prima:

Chain input (policy ACCEPT):
target     prot opt     source                destination           ports
DENY       icmp ------  localhost             anywhere              any ->   any

Come accennato, per eliminare tutte le regole di un filtro si può usare l'opzione di comando `-F':

ipchains -F input

L'esempio elimina tutte le regole del filtro di ingresso.

Se l'elaboratore con il quale si fanno questi esperimenti ospita un servizio si può fare qualche esperimento più interessante. Supponendo di disporre di un servente HTTP che riceve richieste attraverso la porta 80 del protocollo TCP, si potrebbe impedirne l'accesso da parte dell'utente che accede dallo stesso sistema locale attraverso il comando seguente:

ipchains -A input -p tcp -s 127.0.0.1 -d 127.0.0.1 80 -j REJECT

Quando si avvia un programma di navigazione per accedere al servizio HTTP locale, questo cerca di instaurare una connessione TCP utilizzando la porta 80 nella destinazione; se il firewall dispone della regola inserita con il comando appena mostrato, intercetta il tentativo di connessione e restituisce un messaggio di rifiuto attraverso il protocollo ICMP. La scelta di utilizzare l'obiettivo `REJECT' è motivata da questa esigenza: evitare di fare perdere tempo a chi tenta di accedere, perché diversamente l'obiettivo `DENY' renderebbe la cosa più subdola.

Per definire delle regole di filtro corrette per i fini che ci si prefigge, occorre conoscere bene il comportamento del protocollo che si utilizza. Tornando all'esempio appena fatto, in cui lo scopo era quello di impedire all'utente del sistema locale di accedere al servizio HTTP locale, si potrebbe ottenere un risultato equivalente agendo sul filtro di uscita. Per farlo occorre sapere che la connessione TCP è simmetrica, e che nel flusso di ritorno il servizio HTTP utilizza ancora la stessa porta 80, già impiegata per ricevere la richiesta di connessione.

ipchains -F input

ipchains -A output -p tcp -s 127.0.0.1 80 -d 127.0.0.1 -j REJECT

In questo caso di deve osservare comunque una cosa: il messaggio ICMP, con cui si notifica il blocco del transito del pacchetto in uscita, è diretto all'applicazione che tenta di rispondere alla richiesta del cliente, di conseguenza il cliente ne resta all'oscuro.

Dovrebbe essere intuitivo che se si vuole impedire l'accesso a un servizio, è meglio agire con delle regole di ingresso, piuttosto che rimediare con delle regole di uscita.

214.3.7 Regole per i protocolli TCP e UDP

Il modo con cui si possono definire le regole necessarie a individuare i pacchetti, dipendono dal tipo di protocollo utilizzato. Generalmente si è interessati maggiormente a controllare i protocolli TCP e UDP, che hanno in comune l'utilizzo delle porte.

Dovendo fare riferimento a un protocollo TCP o UDP si utilizza l'opzione `-p', seguita dalla parola chiave `tcp' o `udp'. Dal momento che i protocolli TCP e UDP utilizzano le porte, l'origine e la destinazione possono includere questa informazione.

Le porte possono essere indicate in modo preciso (una soltanto), oppure attraverso un intervallo. Queste porte possono essere espresse attraverso un nome, come definito nel file `/etc/services', oppure per numero, cosa che di solito si preferisce per evitare ambiguità o malintesi. Gli intervalli di porte, in particolare, vengono espressi nella forma seguente:

<porta-iniziale>:<porta-finale>

Se si indica un intervallo, e questo lo si determina per la presenza dei due punti, se manca l'indicazione della porta iniziale si intende in modo predefinito la numero zero, se invece manca quella finale si intende la porta 65535. Come nel caso degli indirizzi IP, l'indicazione della porta o dell'intervallo di porte, può essere preceduta dal punto esclamativo in qualità di negazione logica.

Opzioni per i protocolli TCP e UDP

-s [!] <indirizzo>[/<maschera>] [!] [<porta>|<intervallo-di-porte>]

--source [!] <indirizzo>[/<maschera>] [!] [<porta>|<intervallo-di-porte>]

-d [!] <indirizzo>[/<maschera>] [!] [<porta>|<intervallo-di-porte>]

--destination [!] <indirizzo>[/<maschera>] [!] [<porta>|<intervallo-di-porte>]

Con i protocolli TCP e UDP, l'origine e la destinazione possono includere l'indicazione delle porte.

[!] -y | [!] --syn

All'interno di una regola, fa in modo di identificare solo i pacchetti del protocollo TCP che hanno il bit SYN attivato, e i bit ACK e FIN azzerati. Questo serve a isolare i pacchetti che nel protocollo TCP richiedono l'inizializzazione della connessione. In pratica, si tratta di un modo alternativo per bloccare una connessione TCP in un solo verso. Se si usa il punto esclamativo di negazione si intende fare riferimento a pacchetti diversi dal tipo SYN.

Esempi

ipchains -A input -p tcp -s ! 192.168.0.0/16 -d 192.168.0.0/16 80 (segue)
  -j REJECT

Impedisce l'accesso ai servizi HTTP (protocollo TCP, porta 80) della rete 192.168.*.* a tutti gli indirizzi estranei alla rete stessa.

ipchains -A input -p tcp -s ! 192.168.0.0/16 -d 192.168.0.0/16 80 (segue)
  -y -j REJECT

Come nell'esempio precedente, limitandosi a intervenire nei pacchetti SYN.

214.3.8 Regole per il protocollo ICMP

Il protocollo ICMP è molto importante ai fini di controllo del funzionamento della rete, e in questo senso è rara la possibilità che sia il caso di bloccarne il transito attraverso il firewall. Tuttavia, dal momento che i fini del firewall non si limitano al blocco del traffico, è comunque importante poter indicare una regola che sappia selezionare un tipo particolare di pacchetto ICMP. La tabella 214.2 elenca i tipi di pacchetto ICMP e il loro utilizzo.

Numero Nome Chi lo utilizza
0 echo-reply ping
3 destination-unreachable traffico TCP/UDP
5 redirect instradamento dei pacchetti
8 echo-request ping
11 time-exceeded traceroute

Tabella 214.2: Tipi di messaggi ICMP.

Per indicare una regola che faccia riferimento a un tipo particolare di pacchetto ICMP, si sfruttano le opzioni che servono a specificare l'origine o la destinazione, aggiungendo il numero o il nome del tipo ICMP. In pratica, questa informazione va a sostituire il numero di porta nel caso dei protocolli TCP e UDP.

È estremamente importante che non vengano bloccati i messaggi ICMP di tipo 3.

Opzioni per il protocollo ICMP

-s [!] <indirizzo>[/<maschera>] [!] [<tipo>]

--source [!] <indirizzo>[/<maschera>] [!] [<tipo>]

-d [!] <indirizzo>[/<maschera>] [!] [<tipo>]

--destination [!] <indirizzo>[/<maschera>] [!] [<tipo>]

Come già accennato, con il protocollo ICMP l'origine e la destinazione possono includere l'indicazione del tipo di messaggio ICMP.

Esempi

ipchains -A input -p icmp -s ! 192.168.0.0/16 8 -d 192.168.0.0/16 -j DENY

Blocca e ignora i pacchetti ICMP che contengono un messaggio di tipo 8, cioè `echo-request', proveniente da un indirizzo estraneo alla rete 192.168.*.* e destinato alla rete stessa.

214.3.9 Pacchetti frammentati

I pacchetti frammentati costituiscono un problema per la gestione del firewall. In generale ci si limita a intervenire sul primo frammento, perché questo dovrebbe contenere le informazioni necessarie a identificarlo correttamente.

Se il firewall rappresenta un passaggio obbligato per il traffico che lo attraversa, è molto importante che sia abilitata la ricomposizione dei pacchetti frammentati. Questo risolve tanti problemi e soprattutto quello del controllo dei frammenti.

Per identificare un frammento di pacchetto successivo al primo, si utilizza l'opzione `-f' nel modo seguente:

[!] -f | [!] --fragment

Il punto esclamativo permette di ottenere l'effetto contrario, cioè di fare riferimento a tutti i pacchetti che non sono frammenti. Utilizzando questa opzione non è possibile indicare delle porte TCP o UDP, né specificare il tipo di messaggio per il protocollo ICMP.

Esempi

ipchains -A input -p icmp -s ! 192.168.0.0/16 -d 192.168.0.0/16 -f -j DENY

Blocca e ignora i frammenti dei pacchetti ICMP provenienti da un indirizzo estraneo alla rete 192.168.*.* e destinati alla rete stessa.

214.4 Strategie

In generale, quando si predispone uno script con tutte le regole di firewall che si vogliono applicare ai pacchetti in ingresso, in uscita e in transito, si inizia dall'azzeramento di quelle eventualmente esistenti, esattamente nel modo seguente:

#!/bin/sh

/sbin/ipchains -F
#...

Se la sicurezza è un punto critico, questo non è l'approccio migliore, perché dal momento che la politica predefinita è `ACCEPT', la cancellazione delle regole mette temporaneamente il firewall in balia di qualunque possibile attacco.

Dal momento che le funzionalità di filtro del kernel Linux non devono interferire con quelle di instradamento (routing), nel caso le prime non siano state definite, è necessario che la politica predefinita sia sempre `ACCEPT'. In generale, se si vuole configurare il proprio elaboratore come firewall la situazione cambia, e dovrebbe essere conveniente il contrario, in modo da poter controllare la situazione. In pratica, ancora prima dell'azzeramento delle regole delle varie categorie, è solitamente opportuno modificare le politiche predefinite, in modo da bloccare gli accessi e il transito dei pacchetti.

#...
/sbin/ipchains -P input DENY
/sbin/ipchains -P output DENY
/sbin/ipchains -P forward DENY
#...

La definizione delle regole di firewall deve tenere conto dell'ordine in cui appaiono nell'elenco gestito all'interno del kernel, quindi, la scelta tra le opzioni di comando `-A' (aggiunta in coda) e `-I' (inserimento all'inizio o in un'altra posizione) deve essere fatta in modo consapevole. A seconda della propria filosofia personale, si sceglierà probabilmente di utilizzare sempre solo un tipo, oppure l'altro.

Se si sceglie di «aggiungere» le regole, dovrebbe essere conveniente iniziare da quelle di eliminazione o rifiuto (`DENY' o `REJECT'), per finire con quelle di accettazione (`ACCEPT').

Se si preferisce lasciare che la politica predefinita sia `ACCEPT', è importante ricordare di aggiungere una regola che impedisca l'accesso in modo generalizzato alla fine di tutte le regole di un filtro, come mostrato nell'esempio seguente:

#...
# In coda a tutte le regole
/sbin/ipchains -A input -l -j DENY
/sbin/ipchains -A output -l -j DENY
/sbin/ipchains -A forward -l -j DENY

Nell'esempio, non avendo fatto riferimento ad alcun protocollo, né ad alcun indirizzo sorgente o di destinazione, si intendono implicitamente tutti i tipi di pacchetto. Come si può vedere, è stata aggiunta l'opzione `-l' in modo da annotare nel registro di sistema i tentativi di accesso o di attraversamento non autorizzati. Questo tipo di strategia è comunque applicabile con qualunque tipo di politica predefinita, dal momento che con questa regola si catturano tutti i pacchetti rimanenti.

Quando lo scopo di un firewall è solo quello di proteggere una rete interna da quella esterna, si potrebbe pensare che l'uso di regole per il solo filtro di inoltro dovrebbe bastare. In effetti, dal momento che i pacchetti devono attraversare il firewall per raggiungere la rete interna, il ragionamento è corretto; tuttavia, bisogna pensare anche a proteggere il firewall, e in tal senso si comprende l'utilità di disporre di un filtro di ingresso. Infatti, se un aggressore riesce a ottenere accesso nel firewall, da lì può entrare nella rete interna che invece si considera protetta. Il filtro di uscita è una possibilità in più per completare le cose, ed è un bene che ci siano tante possibilità.

Naturalmente, le funzionalità di filtro dei pacchetti sono utili anche per gli elaboratori che devono difendersi da soli, perché si trovano in un ambiente ostile, o perché semplicemente non ci si può fidare. È evidente in questi casi che diventa importantissima la possibilità di intervenire nelle regole del filtro di ingresso ed eventualmente anche in quelle del filtro in uscita, mentre il filtro di inoltro (o di transito) dovrebbe risultare semplicemente inutile.

214.4.1 Pacchetti ICMP

È già stato accennato al fatto che non si deve bloccare il transito dei pacchetti del protocollo ICMP. Il messaggio di tipo 3, `destination-unreachable', è indispensabile nei protocolli TCP e UDP per sapere che un certo indirizzo non è raggiungibile; bloccandolo, si attende senza sapere il perché.

Il protocollo ICMP viene usato anche nella determinazione automatica della dimensione massima dei pacchetti (MTU discovery). Mancando la possibilità di ricevere questi pacchetti ICMP, il funzionamento delle comunicazioni potrebbe essere compromesso seriamente.

214.4.2 UDP e DNS

Una delle politiche normali nella configurazione di un firewall che deve proteggere una rete interna è quella di non lasciare che i pacchetti del protocollo UDP possano attraversarlo. In linea di principio questo atteggiamento è ragionevole, dal momento che con il protocollo UDP si gestiscono spesso informazioni delicate e aggredibili con facilità (NFS e NIS sono gli esempi più importanti).

ipchains -A forward -p udp -j DENY

Quello che si vede è il comando molto semplice che permette di ottenere questo risultato, intervenendo nel filtro di inoltro.

Il sistema DNS utilizza prevalentemente il protocollo UDP, e a volte il protocollo TCP. In questo senso, un servizio DNS collocato all'interno di una rete protetta che abbia bisogno di risolvere nomi della rete esterna, deve necessariamente avvalersi di un altro servizio DNS posto nel firewall o anche al di fuori di questo.

options {
	directory "/etc/named";
	forwarders {
		123.123.123.123;
	};
};

L'esempio che si vede rappresenta una parte del file `/etc/named.conf' dove si indica l'indirizzo 123.123.123.123 da utilizzare per inoltrare le richieste che non possono essere risolte in base alla definizione delle zone locali. La comunicazione con il servizio presso 123.123.123.123 avviene con il protocollo TCP, e questo permette di superare il problema del blocco al transito dei pacchetti UDP.

Il fatto che il sistema DNS utilizzi a volte il protocollo TCP per le comunicazioni normali deve servire a capire che un blocco del protocollo TCP può creare problemi intermittenti alla risoluzione dei nomi e degli indirizzi IP.

214.4.3 Contraffazione dell'origine -- IP spoof

Uno dei riferimenti importanti su cui si basa il controllo da parte del firewall è l'indirizzo di origine dei pacchetti. Spesso, chi attacca un sistema altera i pacchetti che invia modificando l'origine, per non essere individuato. Il firewall non è in grado di sapere se l'origine è veritiera o contraffatta.

Per risolvere questo problema si utilizza la gestione dell'instradamento attraverso la procedura denominata «Source Address Verification». Per prima cosa si deve verificare che esista il file virtuale `/proc/sys/net/ipv4/conf/all/rp_filter', quindi si possono sovrascrivere tutti i file `/proc/sys/net/ipv4/conf/*/rp_filter' con il valore uno. In pratica:

if [ -e /proc/sys/net/ipv4/conf/all/rp_filter ]
then
    for f in /proc/sys/net/ipv4/conf/*/rp_filter
    do
	echo 1 > $1
    done
fi

In modo più grossolano è possibile eliminare i pacchetti che sono «evidentemente» contraffatti. Per esempio, se l'interfaccia di rete `ppp0' è quella che si rivolge verso la rete esterna, si possono bloccare tranquillamente i pacchetti che provengono da questa con l'indicazione di un'origine appartenente a uno degli indirizzi riservati per le reti private.

/sbin/ipchains -A input -s 192.168.0.0/16 -i ppp0 -l -j DENY
/sbin/ipchains -A input -s 172.16.0.0/12 -i ppp0 -l -j DENY
/sbin/ipchains -A input -s 10.0.0.0/8 -i ppp0 -l -j DENY

214.4.4 Esempi

Di seguito vengono mostrati altri esempi che dovrebbero aiutare a comprendere ancora meglio il funzionamento di un firewall realizzato con GNU/Linux.

/sbin/ipchains -A forward -s 224.0.0.0/3 -d 0/0 -l -j DENY

Questa regola impedisce il transito di tutti quei pacchetti che provengono da un'origine in cui l'indirizzo IP sia composto in modo da avere i prime tre bit a uno. Infatti, 224 si traduce nel numero binario 11100000, e questo esclude tutta la classe D e la classe E degli indirizzi IPv4. Si osservi l'aggiunta dell'opzione `-l' per ottenere l'annotazione nel registro del sistema dei tentativi di attraversamento. Segue la visualizzazione della regola attraverso `ipchains -L forward -n'; si osservi la comparsa della lettera `l' nella colonna delle opzioni.

target     prot opt     source                destination           ports
DENY       all  ----l-  224.0.0.0/3           0.0.0.0/0             n/a

---------

/sbin/ipchains -A forward -s 224.0.0.0/3 -l -j DENY

Questo esempio è esattamente identico a quello precedente, perché la destinazione predefinita è proprio quella riferita a qualunque indirizzo.

/sbin/ipchains -A forward -p tcp -s 192.168.1.0/24 -d 0/0 23 -j ACCEPT

Consente ai pacchetti TCP provenienti dalla rete 192.168.1.0/255.255.255.0 di attraversare il firewall per raggiungere qualunque indirizzo, ma solo alla porta 23. In pratica concede di raggiungere un servizio Telnet. Segue la visualizzazione della regola attraverso `ipchains -L forward -n'.

target     prot opt     source                destination          ports
ACCEPT     tcp  ------  192.168.1.0/24        0.0.0.0/0            any -> telnet

---------

/sbin/ipchains -A forward -p tcp -s 0/0 6000:6009 -d 0/0 -l -j DENY
/sbin/ipchains -A forward -p tcp -s 0/0 -d 0/0 6000:6009 -l -j DENY

Blocca il transito delle comunicazioni riferite alla gestione remota di applicazioni per X. In questo caso, si presume di poter avere a che fare con sistemi che gestiscono fino a 10 serventi grafici contemporaneamente.

/sbin/ipchains -A input  -p tcp -s 0/0 6000:6009 -d 0/0 -l -j DENY
/sbin/ipchains -A output -p tcp -s 0/0 -d 0/0 6000:6009 -l -j DENY

Blocca l'ingresso e l'uscita di comunicazioni riferite alla gestione remota di applicazioni per X. Questo potrebbe essere utile per proteggere un sistema che non si avvale di un firewall o che semplicemente non si fida della rete circostante.

214.4.4.1 Esempi raccolti da altri documenti

Nel documento Linux NET-3-HOWTO, Linux Networking di Terry Dawson (precisamente nella versione 1.2 del 1997), appare l'esempio di un firewall/router con lo scopo di proteggere una rete interna con indirizzi 172.16.37.0/255.255.255.0, come mostrato dalla figura 214.3.

-                                   -
 \                                  | 172.16.37.0
  \                                 |   /255.255.255.0
   \                 ---------      |
    |  172.16.174.30 | Linux |      |
NET =================|  f/w  |------|    ..37.19
    |    PPP         | router|      |  --------
   /                 ---------      |--| Mail |
  /                                 |  | /DNS |
 /                                  |  --------
-                                   -

Figura 214.3: Esempio tratto dal NET-3-HOWTO.

Seguono le istruzioni estratte da uno script abbinato all'immagine di questa figura. L'ordine in cui appaiono è importante.

/sbin/ipchains -F forward
/sbin/ipchains -P forward ACCEPT
/sbin/ipchains -F input
/sbin/ipchains -P input ACCEPT

Cancella le regole di inoltro e di ingresso, definendo la politica predefinita come `ACCEPT'.

/sbin/ipchains -A input -p tcp -s 0/0 -d 172.16.174.30 -y -l -j REJECT

Rifiuta l'ingresso di connessioni TCP destinate al firewall, precisamente all'interfaccia collegata all'esterno, facendo riferimento esclusivamente a pacchetti SYN, in modo da non impedire l'instaurazione di collegamenti TCP a partire dallo stesso firewall. I tentativi vengono annotati nel registro del sistema.

/sbin/ipchains -A forward -p tcp -s 224.0/3 -d 172.16.174.0/24 -l -j DENY

Impedisce il transito di pacchetti della classe D e della classe E. Anche in questo caso si annotano i tentativi nel registro del sistema.

/sbin/ipchains -A forward -s 127.0/8 -d 172.16.174.0/24 -j DENY

Nessun pacchetto appartenente alla rete di loopback può transitare nella rete, e quindi essere destinato a interfacce della rete interna.

/sbin/ipchains -A forward -p tcp -s 0/0 -d 172.16.37.19 25 -j ACCEPT

Accetta espressamente il transito di pacchetti riferiti a connessioni SMTP verso il servente della posta elettronica.

/sbin/ipchains -A forward -p tcp -s 0/0 -d 172.16.37.19 53 -j ACCEPT
/sbin/ipchains -A forward -p udp -s 0/0 -d 172.16.37.19 53 -j ACCEPT

Accetta espressamente il transito di pacchetti riferiti a connessioni DNS verso il servente relativo.

/sbin/ipchains -A forward -p udp -s 0/0 53 -d 172.16.37.0/24 2049 -l -j DENY
/sbin/ipchains -A forward -p udp -s 0/0 53 -d 172.16.37.0/24 2050 -l -j DENY

Vengono bloccate le risposte da parte del DNS che utilizzano nella destinazione delle porte delicate, come NFS.

/sbin/ipchains -A forward -p udp \
    -s 0/0 53 -d 172.16.37.0/24 1024:65535 -j ACCEPT

Dopo aver bloccato le risposte DNS destinate a porte delicate, vengono abilitate le risposte a tutte le altre porte da 1024 in su.

/sbin/ipchains -A forward -p tcp -s 0/0 -d 172.16.37.0/24 113 -l -j REJECT

Vengono respinte le richieste del protocollo IDENT provenienti dall'esterno e annotate nel registro del sistema.

/sbin/ipchains -A forward -p tcp \
    -s 192.168.64.0/23 -d 172.16.37.0/24 20:23 -j ACCEPT

Sono accettate le connessioni TCP verso le porte da 20 a 23 provenienti da reti private (192.168.64.* e 192.168.65.*).

/sbin/ipchains -A forward -p tcp -s 172.16.37.0/24 -d 0/0 -j ACCEPT

Consente il transito delle connessioni TCP che hanno origine all'interno della rete protetta.

/sbin/ipchains -A forward -p tcp -s 0/0 -d 172.16.37.0/24 -l -j DENY
/sbin/ipchains -A forward -p udp -s 0/0 -d 172.16.37.0/24 -l -j DENY

Blocca tutte le altre connessioni TCP e UDP provenienti dall'esterno.

---------

Un altro esempio interessante si trova nel Firewalling and Proxy Server HOWTO di Mark Grennan (versione 0.4 del 1996), dove appare uno script pensato per un firewall/router che ha lo scopo di proteggere una rete interna con indirizzi 196.1.2.0/255.255.255.0. Ciò che viene mostrato di seguito è modificato leggermente rispetto all'originale.

/sbin/ipchains -P forward DENY
/sbin/ipchains -F

Questo esempio si basa essenzialmente nel controllo del filtro di inoltro, per cui si modifica la politica predefinita di inoltro in modo da impedire il transito dei pacchetti, e poi si azzerano tutte le regole di tutti i filtri.

/sbin/ipchains -A forward -p tcp -s 0/0 1024:65535 -d 196.1.2.10 25   -j ACCEPT
/sbin/ipchains -A forward -p tcp -s 196.1.2.10 25  -d 0/0 1024:65535  -j ACCEPT

Permette le connessioni attraverso cui è possibile ricevere e inviare la posta elettronica.

/sbin/ipchains -A forward -p tcp -s 0/0 1024:65535 -d 196.1.2.11 80   -j ACCEPT
/sbin/ipchains -A forward -p tcp -s 196.1.2.11 80  -d 0/0 1024:65535  -j ACCEPT

Permette il transito delle connessioni con il servente HTTP.

/sbin/ipchains -A forward -p tcp -s 0/0 1024:65535  -d 196.1.2.0/24 80 -j ACCEPT
/sbin/ipchains -A forward -p tcp -s 196.1.2.0/24 80 -d 0/0 1024:65535  -j ACCEPT

Permette che dall'interno si acceda a servizi HTTP esterni.

/sbin/ipchains -A forward -p udp -s 0/0 53 -d 196.1.2.0/24 -j ACCEPT
/sbin/ipchains -A forward -p tcp -s 0/0 53 -d 196.1.2.0/24 -j ACCEPT
/sbin/ipchains -A forward -p udp -s 196.1.2.0/24 -d 0/0 53 -j ACCEPT
/sbin/ipchains -A forward -p tcp -s 196.1.2.0/24 -d 0/0 53 -j ACCEPT

Consente il traffico necessario per il servizio DNS.

---------

Per concludere è il caso di segnalare nuovamente il documento Linux IPCHAINS-HOWTO di Paul Russell, che contiene molti esempi dell'uso migliore che si può fare del programma `ipchains'.

214.5 Contabilizzazione del traffico

Con i kernel Linux 2.2.*, la contabilizzazione del traffico è implicita nel sistema di filtro del firewall: ogni regola che venga inserita in un filtro accumula i propri contatori. In questo senso possono essere opportune anche regole che non hanno l'indicazione di alcun obiettivo, in quanto utili solo per selezionare una parte del traffico ai fini contabili.

214.5.1 ipchains per la contabilità del traffico IP

Come accennato, non c'è bisogno di attivare la contabilizzazione del traffico, al massimo si tratta di studiare le regole per definire il traffico che si vuole individuare e controllare. Successivamente, con l'opzione `-v' si può osservare il valore raggiunto dai vari contatori. Per esempio, disponendo di un'unica regola che cattura tutto il traffico in ingresso,

ipchains -F input

ipchains -A input

il comando

ipchains -L input -v

potrebbe generare un rapporto simile a quello seguente:

 pkts bytes target     prot opt    tosa tosx  ifname     mark       outsize
  376 34968 -          all  ------ 0xFF 0x00  any                          

Si possono notare in particolare le colonne `pkts' e `bytes' che si riferiscono rispettivamente al numero di pacchetti IP e alla loro dimensione complessiva in byte. A fianco dei numeri che esprimono queste quantità potrebbero essere aggiunte delle lettere che rappresentano dei multipli: `K', `M' e `G'. È importante osservare che questi esprimono multipli del sistema di numerazione decimale: 1.000, 1.000.000 e 1.000.000.000.

L'azzeramento dei conteggi si ottiene con l'opzione di comando `-Z' (`--zero'), che interviene in tutte le regole dei filtri indicati. Questa può essere utilizzata anche assieme all'opzione `-L', in modo da non perdere informazioni; tuttavia, in questo caso, non è possibile indicare il nome di un filtro particolare, e si deve intervenire su tutte le regole esistenti.

Esempi

ipchains -L input -v

Mostra tutte le informazioni disponibili sulle regole del filtro di ingresso. Tra le altre cose mostra anche i contatori del traffico.

ipchains -Z input

Azzera i conteggi riferiti alle regole di ingresso.

ipchains -F -Z -v

Mostra tutte le informazioni disponibili di tutti i filtri (ed eventualmente anche di altri raggruppamenti di regole), compresi i conteggi che vengono azzerati immediatamente dopo.

214.6 Raggruppamenti di regole al di fuori dei filtri

Oltre ai filtri normali, è possibile definire delle raccolte di regole aggiuntive, a cui si può fare riferimento quasi come se fossero delle subroutine di un linguaggio di programmazione. Queste raccolte vengono identificate da un nome, al quale si può fare riferimento attraverso altre regole in qualità di obiettivo. In pratica, una regola posta in un filtro può indicare un obiettivo corrispondente al nome di un altro raggruppamento di regole, e viene così a essere incorporato idealmente in quel punto.

Per comprendere il meccanismo, si supponga di avere creato la raccolta di regole (chain) denominata `Prova', e di avere una regola all'interno del filtro di ingresso che vi faccia riferimento. Per cominciare, le regole contenute all'interno di `Prova' potrebbero essere:

target     prot opt     source                destination           ports
-          all  ------  192.168.1.0/24        0.0.0.0/0             n/a
-          all  ------  0.0.0.0/0             192.168.1.0/24        n/a
-          all  ------  0.0.0.0/0             127.0.0.1             n/a

Come si può osservare in questo caso, si tratta di regole che servono solo alla contabilizzazione il traffico, dal momento che non sono stati indicati degli obiettivi.

Le regole di ingresso potrebbero essere quelle seguenti:

target     prot opt     source                destination           ports
...
Prova      tcp  ------  0.0.0.0/0             0.0.0.0/0             * ->   *
...

Si può osservare una regola il cui scopo è quello di individuare tutto il traffico TCP. Dal momento che l'obiettivo di questa è il raggruppamento `Prova', i pacchetti che rientrano nella selezione di questa regola vengono scomposti ulteriormente attraverso le regole del raggruppamento `Prova'. I pacchetti che non vengono «catturati» da alcuna regola del raggruppamento `Prova' tornano a essere presi in considerazione dalle regole successive nel filtro di ingresso.

La creazione di un raggruppamento di regole si ottiene con l'opzione di comando `-N' (`--new-chain'), e la sua eliminazione con `-X' (`--delete-chain'). Per esempio, il comando,

ipchains -N Prova

serve a creare il raggruppamento `Prova' a cui si accennava in precedenza. L'inserimento di regole avviene nel modo normale; per continuare a seguire gli esempi fatti, i comandi dovrebbero essere i seguenti:

ipchains -A Prova -s 192.168.1.0/24

ipchains -A Prova -d 192.168.1.0/24

ipchains -A Prova -s 127.0.0.1

Così, l'inserimento della regola nel filtro di ingresso che fa riferimento a questo raggruppamento, come mostrato dagli esempi in precedenza, si indica semplicemente con il comando seguente:

ipchains -A input -p tcp -j Prova

L'eliminazione di un raggruppamento di regole è ammissibile solo quando questo è vuoto, e inoltre non esistono più riferimenti da parte di altre regole nei filtri normali.

ipchains -D input -p tcp -j Prova

ipchains -F Prova

ipchains -X Prova

I comandi mostrati sopra servono rispettivamente a eliminare la regola di ingresso che faceva riferimento al raggruppamento `Prova', a svuotare il raggruppamento e infine a eliminarlo.

214.7 Riferimenti

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]