Linux: Firewall con IPTABLES

IPTABLES

Introduzione
IPTABLES e' un potentissimo tool di amministrazione usato dai system administrator per il filtraggio, il nat(Network Address Traslation) e l'alterazione dei pacchetti IP.

Esso si serve di apposite tabelle di filtraggio controllate dal framework Netfilter, per ispezionare nel kernel i pacchetti IP durante il transito e decidere quale politica di filtraggio applicare sul pacchetto.

IPTABLES utilizza tre tipologie di tabelle, una per il filtraggio detta filter, una per la network address traslation detta nat e l'ultima per le alterazioni specializzate dei pacchetti detta mangle.

Le regole vengono definite all'interno delle catene(chains) che vengono poi utilizzate dal kernel per il filtraggio. Una regola definisce il criterio per il quale un pacchetto puo' essere gestito(detto match), quindi se il pacchetto matcha, il relativo target viene applicato, altrimenti, la regola successiva della catena verra' esaminata, nel caso in cui nessun matching si verifica, la default Policy verra' applicata sul pacchetto.

In questo articolo approfondiremo solamente le tabelle filter e nat illustrando alcuni esempi per facilitare la compresione di tali concetti, che apparentemente possono sembrare chiari ma se compresi meglio, possono aiutarci a non commettere eventuali errori di configurazione che potrebbero costarci caro.

Tabella di Filter

La tabella filter di default e' composta da tre catene predefinite:

• INPUT - tale catena gestisce i pacchetti destinati ai servizi del firewall. In figura uno, riportiamo una tipica configurazione di un firewall con tre schede di rete collegate a tre segmenti di rete, rispettivamente Eth0 alla rete internet, Eth1 alla rete lan ed Eth2 alla rete dmz. In questo caso la nostra catena di INPUT dovra' processare i pacchetti in ingresso provenienti dalle reti precedentemente menzionate. Un esempio di pacchetto elaborato dalla catena di INPUT potrebbe essere un client che dalla rete internet esegue un ping(icmp) all'indirizzo IP dell'interfaccia Eth0 del firewall, o ancora un client che dalla rete lan tenta una sessione ssh per accedere al servizio del firewall.

fig.1

• OUTPUT - tale catena gestisce i pacchetti originati dallo stesso firewall. Riferendoci alla figura due, un esempio di pacchetto che attraversa la catena di OUTPUT potrebbe essere il tentativo di pingare dal firewall un client interno della rete lan.

fig.2

• FORWARD - tale catena gestisce i pacchetti che transitano dal sistema, rispettivamente da un'interfaccia di rete all'altra e che non sono ne originati ne destinati allo stesso firewall. Se osserviamo la figura tre, un esempio di pacchetto elaborato dalla suddetta catena, potrebbe essere la richiesta effettuata da un client della rete lan, che desidera scaricare un messaggio di posta elettronica dalla rete internet. Le frecce blu indicano il flusso dei pacchetti in uscita, mentre le frecce rosse indicano il flusso dei pacchetti in ingresso sulla catena di FORWARD del flusso da LAN verso WAN.

fig.3

ll comando IPTABLES

Il comando iptables e' il tool di configurazione per le regole di filtraggio del netfilter. Il Netfilter e' responsabile delle attivita' di filtering, natting e manipolazione dei pacchetti IP nel kernel di Linux. Di seguito elenchiamo le opzioni principali del comando e i relativi esempi pratici per imparare a utilizzarlo.

Comandi:

• -A aggiunge nuove regole in append alla catena,

esempio: iptables -t filter -A INPUT -p icmp -j ACCEPT

• -I inserisce una regola nella catena nella posizione indicata da numero,

esempio: iptables -t filter -I INPUT 1 -p udp --dport 22 -j ACCEPT

• -R sostituisce una regola con un'altra indicata da numero,

esempio: iptables -t filter -R INPUT 1 -p udp --dport 22 -j DROP

• -D cancella le regole di una catena,

esempio: iptables -t filter -D INPUT -p icmp -j ACCEPT

esempio: iptables -t filter -D INPUT 1

• -F rimuove le regole di una catena se specificata o di tutte le catene,

esempio: iptables -t filter -F INPUT

esempio: iptables -t filter -F

• -L elenca in maniera dettagliata le regole di una catena se specificata o di tutte le catene,

esempio: iptables -t filter -L INPUT -vn

esempio: iptables -t filter -L -vn

• -Z azzera i contatori di una catena se specificata o di tutte le catene,

esempio: iptables -t filter -Z INPUT

esempio: iptables -t filter -Z

• -N crea una nuova catena definita dall'utente,

esempio: iptables -t filter -N LANtoWAN

• -X cancella una catena definita dall'utente,

esempio: iptables -t filter -X LANtoWAN

• -E rinomina una catena,

esempio: iptables -t filter -R LANtoWAN LAN2WAN

• -P imposta la policy implicita da applicare ai pacchetti che non matchano le regole

esempio: iptables -t filter -P INPUT DROP

Parametri:

• -i nome dell'interfaccia attraverso il quale il pacchetto viene ricevuto

• -o nome dell'interfaccia attraverso il quale il pacchetto viene inviato

• -p nome o numero del protocollo(tcp,udp,ip,etc)

• -s specifica l'indirizzo IP sorgente

• -d specifica l'indirizzo IP di destinazione

• --sport specifica la porta sorgente utilizzata dai protocolli tcp/udp

• --dport specifica la porta di destinazione utilizzata dai protocolli tcp/udp

• -m multiport specifica un insieme di porte tcp/udp per un massimo di quindici

• -m state specifica lo stato di connessione di un pacchetto. Gli stati validi sono ESTABLISHED (il pacchetto appartiene ad una connessione preesistente), NEW (il pacchetto crea una nuova connessione) , INVALID (il pacchetto non e' valido) e RELATED (il pacchetto e' correlato con una preesistente connessione, ad esempio il protocollo ftp)

• --tcp-flags specifica i flag del protocollo tcp

• --mac-source -- specifica l'indirizzo mac sorgente che ha trasmesso il pacchetto

• -j -- specifica il target della regola.

Target:

• ACCEPT - accetta il pacchetto,

• DROP - scarta il pacchetto,

• REJECT - simile al drop con la differenza che viene inviato un icmp al mittente del pacchetto,

• REDIRECT - il pacchetto viene redirezionato verso una porta locale, molto utilizzato per la configurazione di un trasparent proxy

• QUEUE - accoda il pacchetto in user space per passarlo ad esempio a un ACCEPT,

• RETURN - interrompe l'attraversamento della catena passando a quella successiva o segue la policy di default,

• MIRROR - un pacchetto speculare a quello ricevuto viene inviato al mittente,

• MARK - viene marcato il pacchetto per essere processato da programmi in user space,

• MASQUERADE - viene mascherato l'IP del pacchetto,

• LOG(viene notificato il matching del pacchetto al syslog).

Esempio pratico per la realizzazione di un firewall
Ora che abbiamo compreso meglio il funzionamento e la sintassi dei comandi di IPTABLES, siamo finalmente pronti per configurare il nostro firewall. Il file di configurazione di IPTABLES dove le regole di filtraggio vengone scritte, prende il nome di iptables e si trova in /etc/sysconfig. Piuttosto che utilizzare il file di configurazione di default, preferiamo impostare le regole di filtraggio all'interno di uno script bash, in maniera tale da poter impostare determinate variabili e impartire eventuali comandi di sistema. Prenderemo come esempio, una classica configurazione di un sistema con una qualsiasi distribuzione GNU/Linux, configurato con due schede di rete, eth0 rispettivamente collegata alla rete WAN(internet) e eth1 collegata alla rete LAN.

Creazione dello script iptables.sh

Creiamo all'interno della directory /etc il nostro file di configurazione denominato iptables.sh e procediamo con l'inserimento delle configurazioni citate nei prossimi paragrafi adeguandole alle nostre esigenze.

Carichiamo i moduli del kernel

Diversi moduli del kernel sono a disposizione del netfilter per effettuare le operazioni di filtraggio dei pacchetti.Tali moduli, possono essere compilati all'interno del kernel o caricati on fly per mezzo del comando modprobe. Nella nostra configurazione attiveremo i seguenti moduli come indicato in listing 1.

Listing 1. Locading dei moduli del kernel per il Netfilter

INIZIO /etc/iptables.sh

#!/bin/sh
# iptables.sh - Scritto da Domenico Rigattieri
#
# imposta il debug a livello script - segnala eventuali errori
set -x
#
# [ Moduli del kernel ]
# attiva la funzionalita' di connection tracking per
# la gestione delle connessioni mediante l'uso del modulo state
modprobe ip_conntrack
#
# attiva il connection tracking per il protocollo ftp
modprobe ip_conntrack_ftp

Altri moduli sono a disposizione per la gestione delle connessioni di alcuni protocolli particolari:

• ip_conntrack_pptp,

• ip_conntrack_tftp,

• ip_conntrack_h323,

• ip_conntrack_sip,

• ip_conntrack_netbios_ns,

• ip_conntrack_irc.

Tuning dei parametri del kernel
Intervendo sul sysctl(system control) e' possibile impostare alcune funzionalita' avanzate di networking che aggiungono inoltre un'ulteriore livello di sicurezza sul nostro firewall. In listing 2 sono rappresentati tali parametri.

Listing 2. Tuning dei parametri del kernel

# [ Parametri del kernel ]
# viene attivato il routing per l'inoltro dei pacchetti da una scheda di rete all'altra
echo "1" > /proc/sys/net/ipv4/ip_forward
#
# ignora gli icmp echo inviati agli indirizzi di broadcast/multicast della subnet
echo "1" > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts
# ignora finti messaggi di errore icmp
echo "1" > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses
#
# disattiva l'accettazione di pacchetti ICMP rediretti
echo "0" > /proc/sys/net/ipv4/conf/all/accept_redirects
#
# attiva un filtro antispoofing grazie al reverse filtering del percorso
# che verifica l'indirizzo sorgente con la tabella di routing
echo "1" > /proc/sys/net/ipv4/conf/all/rp_filter
# attiva la funzione che inibisce eventuali attacchi syn flood
echo "1" > /proc/sys/net/ipv4/tcp_syncookies
# attiva il logging dei pacchetti spoofati, dei pacchetti da fonte instradata
# e dei pacchetti rediretti
echo "1" > /proc/sys/net/ipv4/conf/all/log_martians

Definizione delle variabili

Le variabili sono molto comode da impiegare, in quanto ci permettono di impostare degli alias che se modificati, possono alterare in maniera globale la configurazione del nostro script evitando cosi' di dover intervenire su ciascun regola configurata. In listing 3 sono riportate le variabili principali.

Listing 3. Definizione delle variabili

# [ Variabili ]
# Path di iptables
IPT=/sbin/iptables
#
# Interfaccie di rete
# interfaccia eth0 collegata alla rete internet
IfWan=eth0
# interfaccia eth1 collegata alla rete lan
IfLan=eth1
#
# PAT - rete interna da mascherare
LanNet=192.168.1.0/24
# Gruppi di Porte TCP/UDP per il multiport sulla catena LANtoWAN
# (max 15 porte per gruppo!)
# Porte TCP
TCP_MAIL="smtp,pop3,imap,imap3,imaps,pop3s"
TCP_INTERNET="domain,http,https,ftp,ftp-data"
TCP_GROUP1="ssh,telnet,ntp,ms-wbt-server"
#
# Porte UDP
UDP_MAIL="smtp,pop3,imap,imap3,imaps,pop3s"
UDP_GROUP1="domain,ntp"

Reset delle catene, regole e contatori

Prima di impostare qualsiasi regola di filtraggio, e' mandatorio assicurarci che il sistema non abbia gia' eventuali configurazioni che potrebbero compromettere il corretto filtraggio dei pacchetti. Come indicato in Listing 4, rimuoviamo eventuali catene/regole presenti sul sistema e resettiamo i contatori.

Listing 4. Reset delle catene, regole e contatori

# [ Reset iptables ]
# Rimuove qualsiasi catena e regola dalle tabelle filter e nat
$IPT -t filter -t filter -F
$IPT -t filter -t filter -X
$IPT -t filter -t nat -F
$IPT -t filter -t nat -X
#
# Azzera tutti i contatori dei pacchetti e bytes
$IPT -t filter -t filter -Z
$IPT -t filter -t nat -Z

Le Policy di default
Le policy di default, stabiliscono in maniera implicita il target da applicare ai pacchetti che non matchano nessuna delle condizioni specificate nelle regole configurate. Per default, le policy sono configurate per accettare tutti i pacchetti, i tal caso occorre specificare, in maniera esplicita, configurando alla fine di ogni catena una regola per il blocco dei pacchetti. Nel listing 5 della nostra configurazione, le policy di default sono state impostate con target DROP per scartare i pacchetti alla fine della catena.

Listing 5. Impostazione delle policy di default

# [ Default policy ]
$IPT -t filter -P INPUT DROP
$IPT -t filter -P OUTPUT DROP
$IPT -t filter -P FORWARD DROP
$IPT -t nat -P PREROUTING DROP
$IPT -t nat -P POSTROUTING DROP
$IPT -t nat -P OUTPUT DROP

Creazione delle catene(chains)
Nel listing 6, sono state create alcune catene che fungeranno da target per i flussi di FORWARD, dei filtri antispoof e antiscan che vedremo piu' avanti.

Listing 6. Creazione delle catene

# [ Creazione delle catene ]

$IPT -t filter -N LANtoWAN
$IPT -t filter -N WANtoLAN
$IPT -t filter -N ANTISPOOF
$IPT -t filter -N ANTISCAN

Flussi di FORWARD
La definizione dei flussi sulle catene di forward, impostata come nel listing 7, semplifica la creazione delle regole di filtraggio in quanto il nome della catena usata come target, per esempio LANtoWAN, corrisponde in particolare al flusso di forwarding, che i pacchetti di una data sorgente(LAN), attraversano il firewall per arrivare verso una data destinazione(WAN). Nel listing 7, la prima regola imposta la catena LANtoWAN come target dei pacchetti che dalla rete LAN(in ingresso sull'interfaccia $IfLan) attraversano il firewall per raggiungere le reti esterne WAN(in uscita dall'interfaccia $IfWan); in figura 3 le frecce blue. La seconda regola, imposta la catena WANtoLAN come target dei pacchetti che dalle reti esterne(WAN) attraversano il firewall per arrivare alle reti internet(LAN); in figura 3 le frecce rosse.

Listing 7. Flussi di forward

# [ Impostazione dei flussi sulle catene FORWARD ]
$IPT -t filter -A FORWARD -i $IfLan -o $IfWan -j LANtoWAN
$IPT -t filter -A FORWARD -i $IfWan -o $IfLan -j WANtoLAN

Tabella NAT - Network Address Traslation

Come gia' anticipato, IPTABLES servendosi della tabella nat, e' in grado di gestire la manipolazione degli indirizzi IP e delle porte di un pacchetto quando questo viaggia sulla rete.

In genere i collegamenti che effettuano il NAT ricordano come hanno manipolato il pacchetto, dunque quando arriva un pacchetto di risposta dall'altra parte, viene effettuato su di esso la manipolazione inversa e in questo modo tutto funziona. Le ragioni per cui viene utilizzato il NAT sono le seguenti:

• connessioni di piu' client a Internet attraverso un solo IP address pubblico. Tipico delle connessioni modem o xdsl dove sia ha un solo IP pubblico,

• quando si desidera cambiare l'IP address di destinazione sui pacchetti che giungono alla nostra rete; utile quando si ha un solo IP address pubblico e si vuol far raggiungere dall'esterno uno o piu' servizi all'interno della propria rete privata,

• quando si ha la necessita' di far dialogare reti in over-lapping o duplicate aventi lo stesso indirizzamento di rete,

• quando si ha l'esigenza di implementare un Port-Forwarding e quindi di alterare le porte dei protocolli di trasporto TCP/UDP.

IPTABLES suddive il nat in due tipi:

• Source NAT(SNAT) - Il SNAT si ha quando si riscrive l'indirizzo IP sorgente del pacchetto IP ed opera in fase di post-routing, giusto dopo che il pacchetto e' stato elaborato dal processo di routing pronto per essere immesso sulla rete. Il Masquerading o Mascheramento e' anch'essa una tecnica di SNAT per mascherare un'intera rete privata con un solo IP address, solitamente implementato in connessioni dial-up PPP o xdsl dove si dispone di un unico IP publico.

• Destination NAT(DNAT) - Il DNAT si ha quando si riscrive l'indirizzo IP di destinazione del pacchetto IP ed opera in fase di pre-routing, giusto prima che il pacchetto venga indirizzato al processo di routing. Port-Forwarding, Load-Sharing e il Trasparent-Proxy sono tutte tecniche di DNAT.

La tabella nat ha tre catene native:

• POSTROUTING - tale catena opera per la modalita' SNAT,

• PREROUTING - tale catena opera per la modalita' DNAT,

• OUTPUT - tale catena opera per la modalita' DNAT e viene utilizzata per alterare l'indirizzo IP di destinazione di un pacchetto in uscita dal firewall.

Vediamo alcuni esempi di SNAT e DNAT:

- Esempi pratici con SNAT

1) traslare qualsiasi indirizzo IP sorgente della rete LAN con l'IP address 95.66.23.4 in uscita dall'interfaccia eth0

iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 95.66.23.4

2) impostare un pool di indirizzi con cui mascherare tutti i pacchetti in uscita dall'interfaccia eth0

iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 234.11.23.1-234.11.23.10

- Esempi pratici con DNAT

1) traslare l'indirizzo IP di destinazione, sui pacchetti in ingresso all'interfaccia eth0 con l'indirizzo 192.168.1.100

iptables -t nat -A PREROUTING -i eth0 -j DNAT --to-destination 192.168.1.100

2) traslare l'indirizzo IP e la porta di destinazione del traffico HTTP con l'IP 10.0.0.1 porta 8080, tipica configurazione per il Trasparent-Proxy

iptables -t nat -A PREROUTING -p tcp --dport 80 -i eth0 -j DNAT --to-destination 10.0.0.1:8080

3) redirect dei pacchetti destinati all'indirizzo 192.168.100.1 verso l'IP 172.16.20.1

iptables -t nat -A PREROUTING -d 192.168.100.1 -j DNAT -to-destination 172.16.20.1

4) pubblicare diversi server ssh utilizzando un solo IP pubblico; quindi ssh 46.98.56.100 -p 5100 per connettersi al server 10.10.10.100

iptables -t nat -A PREROUTING -d 46.98.56.100 -p tcp --dport 5100 -j DNAT -to-destination 10.10.10.100:22

iptables -t nat -A PREROUTING -d 46.98.56.100 -p tcp --dport 5200 -j DNAT -to-destination 10.10.10.101:22

Considerato che la configurazione del PAT e' comunemente usata in un firewall, In listing 8 e' stata riportata tale configurazione. Nel listing, la regola esegue un PAT traslando qualsiasi IP sorgente della rete LAN con l'indirizzo IP dell'interfaccia $IFWAN connessa a internet.

Listing 8. Network address traslation(NAT)

# [ Regole di nat ]
#esegue un PAT per le reti interne
$IPT -t nat -A POSTROUTING -o $IfWan -s $LanNet -j MASQUERADE

Regole di filtraggio

Nel listing 9, troviamo le regole di filtraggio applicate alle rispettive catene della tabella filter. Le regole specificate nel listing, permettono dalla rete LAN l'accesso ai principali servizi internet e l'accesso in ssh sul firewall. Certamente e' impensabile pretendere di adattarle a qualsiasi contesto, in quanto ogni network richiede determinate policy di filtraggio al fine di garantire l'accesso alle applicazioni e ai servizi di rete.

Listing 9. Regole di filtraggio

# [ Regole di filter ]
# Regole Antiscan e Antispoof
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN -j LOG --log-prefix " FW ANTISCAN"
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN -j DROP
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN -j LOG --log-prefix " FW ANTISCAN"
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN -j DROP
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j LOG --log-prefix " FW ANTISCAN"
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j LOG --log-prefix " FW ANTISCAN"
$IPT -t filter -A ANTISCAN -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j DROP
$IPT -t filter -A ANTISPOOF -s 127.0.0.1/32 -j LOG --log-prefix " FW ANTISPOOFING"
$IPT -t filter -A ANTISPOOF -s 127.0.0.1/32 -j DROP
$IPT -t filter -A ANTISPOOF -s 192.168.0.0/16 -j LOG --log-prefix " FW ANTISPOOF"
$IPT -t filter -A ANTISPOOF -s 192.168.0.0/16 -j DROP
$IPT -t filter -A ANTISPOOF -s 172.16.0.0/12 -j LOG --log-prefix " FW ANTISPOOF"
$IPT -t filter -A ANTISPOOF -s 172.16.0.0/12 -j DROP
$IPT -t filter -A ANTISPOOF -s 10.0.0.0/8 -j LOG --log-prefix " FW ANTISPOOF"
$IPT -t filter -A ANTISPOOF -s 10.0.0.0/8 -j DROP
$IPT -t filter -A ANTISPOOF -s 224.0.0.0/4 -j LOG --log-prefix " FW ANTISPOOF"
$IPT -t filter -A ANTISPOOF -s 224.0.0.0/4 -j DROP
$IPT -t filter -A ANTISPOOF -s 240.0.0.0/5 -j LOG --log-prefix " FW ANTISPOOF"
$IPT -t filter -A ANTISPOOF -s 240.0.0.0/5 -j DROP
#
#======================> INTERFACCIA LOOPBACK
# [ regole in INPUT sull'interfaccia Loopback ]
$IPT -t filter -A INPUT -i lo -s 127.0.0.1 -d 127.0.0.1 -j ACCEPT
#
# [ regole in OUTPUT sull'interfaccia Loopback ]
$IPT -t filter -A OUTPUT -o lo -s 127.0.0.1 -d 127.0.0.1 -j ACCEPT
#
#======================> INTERFACCIA ETH0 IfWan (INTERNET)
# [ Regole FW->INTERNET ]
$IPT -t filter -A OUTPUT -o $IfWan -p tcp --sport 1024: -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPT -t filter -A OUTPUT -o $IfWan -p tcp -m multiport --dport 53,80,443,20,21 -j ACCEPT
$IPT -t filter -A OUTPUT -o $IfWan -m pkttype --pkt-type unicast -j LOG --log-prefix " [FW]->[INTERNET] "
#
# [ Regole INTERNET->FW ]
$IPT -t filter -A INPUT -i $IfWan -j ANTISPOOF
$IPT -t filter -A INPUT -i $IfWan -j ANTISCAN
$IPT -t filter -A INPUT -i $IfWan -p tcp --dport 1024: -m state --state ESTABLISHED -j ACCEPT
$IPT -t filter -A INPUT -i $IfWan -p udp --dport 1024: -m state --state ESTABLISHED -j ACCEPT
$IPT -t filter -A INPUT -i $IfWan -m pkttype --pkt-type unicast -j LOG --log-prefix " [INTERNET]->[FW] "
#
#======================> INTERFACCIA ETH1 IfLan (LAN)
# [ Regole FW->LAN ]
$IPT -t filter -A OUTPUT -o $IfLan -p tcp -m state --state ESTABLISHED,RELATED -j ACCEPT
$IPT -t filter -A OUTPUT -o $IfLan -p icmp -j ACCEPT
$IPT -t filter -A OUTPUT -o $IfLan -m pkttype --pkt-type unicast -j LOG --log-prefix " [FW]->[LAN] "
# [LAN]->[FW]
$IPT -t filter -A INPUT -i $IfLan -p tcp --dport 22 -j ACCEPT
$IPT -t filter -A INPUT -i $IfLan -p icmp -j ACCEPT
$IPT -t filter -A INPUT -i $IfLan -m pkttype --pkt-type unicast -j LOG --log-prefix " [LAN]->[FW] "
#
#======================> FORWARDING da IfLan(LAN) verso IfWan(INTERNET)
# [Regole flusso LAN->INTERNET ]
$IPT -t filter -A LANtoWAN -p tcp --sport 1024: --dport 1024: -m state -state ESTABLISHED,RELATED -j ACCEPT
$IPT -t filter -A LANtoWAN -p udp --sport 1024: --dport 1024: -m state -state ESTABLISHED,RELATED -j ACCEPT
$IPT -t filter -A LANtoWAN -p tcp -m multiport --dport $TCP_INTERNET -j ACCEPT
$IPT -t filter -A LANtoWAN -p tcp -m multiport --dport $TCP_MAIL -j ACCEPT
$IPT -t filter -A LANtoWAN -p tcp -m multiport --dport $TCP_GROUP1 -j ACCEPT
$IPT -t filter -A LANtoWAN -p udp -m multiport --dport $UDP_MAIL -j ACCEPT
$IPT -t filter -A LANtoWAN -p udp -m multiport --dport $UDP_GROUP1 -j ACCEPT
$IPT -t filter -A LANtoWAN -p icmp -j ACCEPT
$IPT -t filter -A LANtoWAN -m pkttype --pkt-type unicast -j LOG --log-prefix " [LAN]->[INTERNET] "
#
#======================> FORWARDING da IfWan(INTERNET) verso IfLan(LAN)
# [ Regole flusso INTERNET->LAN ]
$IPT -t filter -A WANtoLAN -j ANTISPOOF
$IPT -t filter -A WANtoLAN -j ANTISCAN
$IPT -t filter -A WANtoLAN -p tcp --dport 1024: -m state --state ESTABLISHED -j ACCEPT
$IPT -t filter -A WANtoLAN -p udp --dport 1024: -m state --state ESTABLISHED -j ACCEPT
$IPT -t filter -A WANtoLAN -m pkttype --pkt-type unicast -j LOG --log-prefix " [INTERNET]->[LAN] "
#
# FINE /etc/iptables.sh

Bootscript
Adesso che abbiamo concluso la configurazione del nostro firewall, dobbiamo far si che il sistema attivi le regole di iptables al boot della macchina. Per far questo dobbiamo sostituire l'originale bootscript di iptables, che si trova in /etc/rc.d, rinominandolo da iptables a iptables.def e creare il nuovo bootscript con la configurazione riportata nel listing 10.

Listing 10. Bootscript

#!/bin/sh
# written by Domenico Rigattieri
# chkconfig: 2345 08 92
# description: Starts, stops and status iptables firewall
#
# config: /etc/iptables.sh
case "$1" in
start)
echo "Starting IPTABLES..."
/bin/sh /etc/iptables.sh
;;
stop)
echo "Stopping IPTABLES..."
/sbin/iptables -t filter -t filter -F
/sbin/iptables -t filter -t filter -X
/sbin/iptables -t filter -t nat -F
/sbin/iptables -t filter -t nat -X
/sbin/iptables -t filter -P INPUT ACCEPT
/sbin/iptables -t filter -P OUTPUT ACCEPT
/sbin/iptables -t filter -P FORWARD ACCEPT
/sbin/iptables -t nat -P PREROUTING ACCEPT
/sbin/iptables -t nat -P POSTROUTING ACCEPT
/sbin/iptables -t nat -P OUTPUT ACCEPT
;;
restart)
$0 stop
sleep 1
$0 start
;;
status)
/sbin/iptables -L -nv
;;
*)
echo "Usage: $0 {start|stop|restart|status}"
exit 1
;;
esac