IPCHAINS Firewall a livello rete in Linux 

Dopo aver fatto un'introduzione dei firewall come sistemi per la protezione di una certa rete , si prosegue descrivendo i tipi di firewall che un sistema Linux mette a disposizione, più precisamente si analizzera' la configurazione di un firewall packet filtering, attraverso il tools di configurazione IPCHAINS.


Configurazione e Installazione di IPCHAINS

Passiamo adesso alla configurazione del firewall presente nei sistemi Linux IPCHAINS.Il sistema Linux come molti sistemi UNIX come già detto in precedenza offre integrato nel Kernel la possibilità di gestire un firewall, e quindi di poter avere attraverso un'interfaccia con comandi UNIX una protezione sicura verso la propia rete.Se la rete non è di grosse dimensioni si può prendere un 486 installarci Linux e configurare un firewall scegliendo la politica di sicurezza più adatta alle nostre esigenze. Il kernel di linux include il supporto per il packet filtering, ovvero permette di controllare l'header di tutti i pacchetti a livello di Kernel che gli passano attraverso e di decidere come trattarli. Ipchains è il tools che permette di impostare questi filtri, in modo da poter controllare il traffico in uscita e in ingresso sulla nostra macchina e quindi impedire accessi indesiderati. Per essere sicuro che il tuo kernel includa l'IP Firewall Chains controlla l'esistenza del file `/proc/net/ip_fwchains', se c'e` allora e` tutto OK. Altrimenti siccome IPCHAINS è costituito da un modulo del kernel,bisogna settare alcune opzioni nel Kernel e ricompilarlo di conseguenza, e cioe':

Se hai un kernel 2.0.x le voci da includere nella compilazione sono:

CONFIG_EXPERIMENTAL=y
CONFIG_FIREWALL=y
CONFIG_IP_FIREWALL=y
CONFIG-IP_FIREWALL_CHAINS=y

Per i kernel 2.1.x e 2.2.x e` necessario includere:

- Network firewalls
- IP: firewalling

Oltre a queste opzione è opportuno inserire anche le funzionalità del Proxy trasparente e del mascheramento IP che verranno nel seguito spiegate, quindi bisogna settare le seguente opzioni:

- IP: always defragment
- IP: transparent proxy support
- IP: masquerading
- IP: ICMP masquerading

Come Funziona il filtraggio di un pacchetto

Il kernel parte con tre chains o catene (input, output, forward) che non possono essere eliminate. Una chains è un insieme di regole contenenti alcuni header. Quando un pacchetto, sia esso in entrata o in uscita, arriva al kernel quest'ultimo controlla la chains appropriata per verificare se ci sono rules che corrispondo all'header del dato appena ricevuto, se i dati corrispondo, il pacchetto verrà trattato come indicato nella definizione della regola, altrimenti verrà passato alla seconda regola della catena e così via; precisare l'ordine in cui vengono definite le regole è importante, e quindi il tools ipchains permette di inserire queste regole anche in determinate posizioni. Una volta consultati tutti gli anelli della catena, se non viene trovata nessuna corrispondenza, viene applicata la politica di default definita che in genere è quella di ACCEPT.

Quando il pacchetto deve essere filtrato subisce la seguente sequenza di passi:


checksum: viene controllato che il pacchetto sia integro.
Sanity: il pacchetto deve rispettare lo standard.
viene incrementato il contatore dei byte ricevuti (header + dato).
viene incrementato il numero di pacchetti ricevuti.
se richiesto dalla rule, il pacchetto viene loggato da syslog.
se richiesto, viene modificato il campo TOS (Type Of Service) dell'header IP.
se richiesto, il pacchetto viene marcato (solo con kernel superiori a 2.0).
viene esaminato il campo jump-to della rule per decidere che fare del pacchetto.
Demasquerade: se il pacchetto è in risposta a una risposta precedente, allora prima di essere inviato alla catena di output viene riconvertito (questo solo se abilitata la funzione di masquerading).
Local: se il pacchetto è creato da un processo locale, allora salta la catena di foward e passa direttamente alla catena di output.
Il campo jump-to e` definito utilizzando l'opzione -j TARGET (che puo` essere al max di 8 caratteri ed e` case sensitive), se nessun target e` specificato viene utilizzato quello di default della chains. Ci sono sei target detti "speciali":


ACCEPT, il pacchetto puo` essere elaborato.
DENY, il pacchetto viene rifiutato, come se non fosse mai arrivato.
REJECT, il pacchetto viene rifiutato, ma, se non e` di tipo ICMP, viene generato un ICMP replay all'IP sorgente dicendo che la destinazione non e` raggiungibile.
MASQ, il pacchetto viene mascherato (il kernel deve essere abilitato per l'IP Masquerading).
REDIRECT, il pacchetto viene ridiretto su un'altra porta locale (il kernel deve esser compilato attivando l'opzione CONFIG_IP TRANSPARENT_PROXY).
RETURN, salta immediatamente alla fine della chains,ulteriori target possono essere definiti dall'utente.

4.3 Usare il tool IPCHAINS

La sintassi del comando IPCHAINS e' data dalla seguente scrittura:

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

Per prima cosa vediamo quali sono le operazioni che si possono fare con una chains che corrisponde nella nostra sintassi all'opzione di comando:

-N : creazione di una nuova chains.
-X : cancellazione di una chains vuota.
-P : cambio della politica di default di una chains.
-L : elenco delle rules di una chains.
-F : cancellazione di tutte le rules di una chains.
-Z : azzeramento del contatore dei byte e dei pacchetti di una chains.
Queste invece sono le operazioni per manipolare le rules all'interno di una chains:


-A : inserimento in coda di una nuova regola.
-I : inserimento di una nuova regola in una posizione definita.
-R : rimpiazzamento di una regola in una posizione definita.
-D : cancellazione di una regola in una posizione definita.
-D : cancellazione di una regola.
-M -L : elenco delle connessioni mascherate.
-M -S : impostazione del valore di timeout per il masquerading.
Il filtro è indicato attraverso un nome: input, foward, output, naturalmente un pacchetto che attraversa un firewall attraversa questi tre filtri.Infine una regola come spiegato in precedenza e' sempre accompagnata da un obbiettivo che indica il destino del pacchetto e cioe':

Accept : consente il transito del pacchetto.
Deny : impedisce il transito del pacchetto, ignorandolo.
Reject : impedisce il transito del pacchetto notificando all'origine il rifiuto.

Scrivere le regole di filtraggio

Le tre catene input, foward e output hanno come politica di default ACCEPT. Vediamo adesso come creare delle rules generali per vedere come funziona IPCHAINS.Se voglio creare un regola che mi permette di bloccare tutti i pacchetti che arrivano da un certo indirizzo ip della rete, per esempio dal 149.132.227.0, devo aggiungere quindi la regola alla chains input; la mia regola può basarsi su questi parametri:


IP sorgente
IP destinazione
porta sorgente
porta di destinazione
tipo di protocollo
interfaccia
TCP SYN flag attivo
che rappresentano le informazioni che trovo in un pacchetto IP. Le opzioni -s e -d mi permettono di specificare il sorgente ed il destinatario.Ci sono quattro modi per specificare un indirizzo :


in modalita' stringa esmp: www.altavista.com.
indirizzo ip (ex. 149.132.227.250)
indirizzo della subnet (ex. 149.132.227.0/24) specificando la network mask attraverso la dimensione della maschera.
indirizzo della subnet (ex. 149.132.227.0/255.255.255.0) indicando la netmask mediante IP.
Quindi la riga di comando sara` del tipo:

# ipchains -A input -s -p UDP 149.132.227.0/24 -d 0/0 -j REJECT

in questo modo aggiungo alla catena di input la regola che mi permette di bloccare tutti i pacchetti con quel determinato mittente (l'opzione -d in questo caso e` inutile). Il comando -j, ovvero jump-to serve per specificare che cosa fare di quel determinato pacchetto. Se dopo aver impostato la regola proviamo a lanciare il comando:

# ipchains -L

avremo questo output:

Chain input (policy ACCEPT):
target prot opt source destination ports
REJECT udp ------ pc2.mi.it anywhere any -> any

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

nella chains input avremo la regola introdotta da noi, quindi: sotto TARGET REJECT, sotto prot protocollo UDP, sotto source pc2.mi.it, IP del pc di cui si vuole bloccare i pacchetti, sotto destination destinazione dei pacchetti a qualunque macchina e sotto port troviamo per quali porte vale la regola, se adesso proviamo ad utilizzare il protocollo udp esempio proviamo a risolvere un nome con il comando nslookup , il firewall blocca il pacchetto e noi non riceviamo risposta, naturlmente se la richiesta deve passare attraverso il Firewall.
Per riportare tutto alla situazione precedente eseguire il comando:

# ipchains -D input -p UDP -s 149.132.227.0/24 -d 0/0 -j REJECT

Abbiamo visto che con l'opzione -p si possono specificare i vari protocolli che possono essere TCP, UDP, ICMP, se si vuole specificarli tutti basta scrivere all; inoltre con i protocolli UDP e TCP possono essere specificate come parametri del filtro le porte destinazione e sorgente esempio :

# ipchains -A input -p TCP -s 149.132.227.250 21 -j REJECT

# ipchains -A input -p TCP -s 149.132.227.250 ftp -j REJECT


Nelle regole di costruzione dei filtri possono essere specificate le interfaccie sorgenti e destinazione per il filtraggio dei pacchetti attraverso l'opzione -i ; l'esempio seguente blocca i pacchetti che arrivano dall'interfaccia eth0 con IP sorgente 149.132.227.250 diretti alla porta 21, che usano il protocollo TCP:

# ipchains -A input -p TCP -s 149.132.227.250 21 -j -i eth0 REJECT


Filtraggio del protocollo ICMP

I pacchetti ICMP sono molto importanti ai fini del controllo del funzionamento della rete, quindi in generale non dovrebbero essere bloccati da un firewall, i pacchetti ICMP infatti controllano parametri importanti come ad esempio la determinazione automatica della MTU di una rete, senza i quali la comunicazione potrebbe essere seriamente compromessa, comunque si possono scrivere delle regole che discriminano il tipo di pacchetto ICMP. Per discriminare i pacchetti di tipo ICMP si puo` indicare il tipo di codice del messaggio utilizzando il numero oppure il nome (l'elenco lo si trova digitando ipchains -h icmp) per esempio:

# ipchains -A input -p ICMP -d 192.168.91.11 8 -J REJECT il codice 8 indica un echo-request.

Questa rule blocca tutti i pacchetti ICMP di tipo echo-request, che rappresenta la richiesta di un test verso un'interfaccia per controllare se è attiva. Con l'opzione -i come già detto in precedenza si puo` specificare il nome dell'interfaccia dalla quale arriva il pacchetto. Non e` necessario che al momento della creazione della rule l'interfaccia sia attiva.

I codici più importanti dei pacchetti ICMP sono:

0 echo-reply: ping.
3 destination-un reachable: traffico UDP/TCP
5 redirect: instradamento dei pacchetti.
8 echo-request: ping.
11 time-exceeded: traceroute.
Per i pacchetti di tipo TCP e` possibile attivare l'opzione "TCP SYN only" che filtra solamente i pacchetti con flag di SYN a 1 mediante l'opzione -y.

# ipchains -A input -i ppp0 -p TCP -d 196.23.34.34 23 -y -j REJECT

In questo modo vengono bloccati tutti i pacchetti provenienti dall'interfaccia ppp0 con destinazione 196.23.34.34 alla porta 23 con il flag SYN attivato.

Tutte le opzioni fino ad ora illustrare, ad eccezione del codice ICMP, possono essere precedute dall'operatore di negazione ! che viene utilizzato per indicare tutte le possibilita` ad eccezione di quella che segue il carattere ! ad esempio:

# ipchains -A input -s ! 149.132.227.0/24 -j REJECT

blocca tutti i pacchetti ad eccezione di quelli provenienti dalla rete 149.132.227.0.

Per poter loggare i pacchetti che vengono filtrati si utilizza l'opzione -l ipchains logga i pacchetti utilizzando syslog. Bisogna quindi impostare nel file /etc/syslog.conf:

kern.=info /dev/tty12

la facility e` kernel, mentre il level e` info.
kernel: Packet log: input - lo PROTO=1 127.0.0.1:8 127.0.0.1:0 L=84 S=0x00
I=33274 F=0x0000 T=64 (#1)

questo e` un esempio di log di un pacchetto filtrato.

4.6 Ulteriori caratteristiche di IPCHAINS
Quando un pacchetto attraversa una certa tipologia di rete è soggetto a seconda del mezzo di trasmissione della rete a essere frammentato, adattato cioè alla massima lunghezza consentita, per esempio per tipologia ethernet, la massima lunghezza del pacchetto o MTU è di 1500 byte.I filtraggi che vengono imposti sui vari parametri come: porta destinazione, ICMP, tcp syn, sono contenuti nel primo frammento; per indicare al kernel di controllare anche gli altri frammenti bisogna compilare il kernel attivando il riassemblaggio forzato dei frammenti, se non si applicherebbe questa regola la politica della catena viene applicata solo al primo frammento mentre sui frammenti successivi viene applicata la politica di default.

L'opzione -f (-fragment) viene utilizzata per filtare tutti i frammenti di un pacchetto. Gli header saranno presenti solamente nel primo frammento, non si potranno quindi usare parametri tipo porte, ICMP type e TCP SYN flag, ma solamente il campo destinazione e/o sorgente.

# ipchains -A input -f -s 149.132.227.250 -j DENY

E` possibile modificare il campo TOS dell'header IP, utilizzando il flag -t.

# ipchains -A output -p TCP -d 0/0 ftp -t 0x01 0x10

L'opzione -C ci permette di verificare il comportamento di ipchains all'arrivo di un particolare pacchetto. La riga di comando sara` del tipo:

# ipchains -C input -p tcp -i eth0 -s 149.132.227.1 10000 -d \ > 192.168.91.11 23

La sintassi di questo comando e` uguale a quella utilizzata per scrivere una regola, si costruisce cosi` un pacchetto sonda; otterremo un messaggio a video che ci dira` come verra` trattato il pacchetto: se accettato, ignorato, rifiutato.

L'ultima opzione e` -b (bidirectional flag); e` utilizzato per scrivere due regole con un solo comando. Se io volessi bloccare tutti i pacchetti che hanno come mittente 149.132.227.5 e come destinatario 149.132.227.10 e viceversa dovrei scrivere due rules; utilizzando il flag -b ne devo scrivere solamente una.

# ipchains -b -A input -s 149.132.227.10 -d 149.132.227.20 -j REJECT

Usare questa riga di comando equivale ad utilizzare:

# ipchains -A input -s 149.132.227.10 -d 149.132.227.20 -j REJECT

# ipchains -A input -s 149.132.227.20 -d 149.132.227.10 -j REJECT


Regole ci configurazione generale di IPCHAINS
Queste regole non corrispondono a una configurazione di rete particolare ma si possono adottare a seconda delle propie esigenze, si adattano comunque a casi generali riscontrabili nella maggior parte delle reti che vogliono adottare delle politiche di sicurezza. Una protezione fondamentale è quella di non permettere il passaggio del traffico UDP attraverso il firewall in quanto attraverso questo protocollo si possono ottenere informazioni delicate, quali possono essere NFS, NIS, la regola è:

# ipchains -A forward -p udp -j DENY

Naturalmente il protocollo UDP viene anche usato dal DNS, e quindi per poter risolvere i nomi ci si deve appoggiare a un server con il quale ci si connette via TCP, risolvendo cosi' la risoluzione dei nomi.Per questo tipo di collegamento basta cambiare nel file di configurazione del D.N.S. /etc/named.conf la seguente opzione:

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

contenente l'IP del server esterno con cui ci si collega via TCP.
Un'altra regola importante per la protezione del firewall, è data dall'esclusione dei pacchetti TCP rivolti verso il firewall con il Flag SYN abilitato che significa una possibile connessione che sul firewall deve essere esclusa a priori, la regola per escludere questi pacchetti è:

# ipchains -A input -p tcp -s 0/0 -d 192.168.200.1 -y -l -j REJECT

192.168.200.1 rappresenta l'interfaccia collegata all'esterno.

L'IP spoofing può essere evitato controllando che pacchetti provenienti dall'esterno, non abbiano indirizzi di reti interne, ponendo che l'interfaccia di comunicazione esterna sia eth0, e che gli indirizzi della rete interna siano 192.168.0.0;La regola che risolve questa situazione è:

# ipchains -A input 192.168.0.0/16 -i eth0 -l -j DENY

i tentativi vengono inoltre registrati nel file di log. Inoltre si dovrebbe disabilitare la possibilità che un pacchetto con l'indirizzo di loopback 127.0.0.0 possa transitare nella rete interna, quindi:

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

Si possono settare anche regole che permettono di escludere solo certi tipi di indirizzi per il collegamento dall'esterno verso l'interno, per esempio se si vuole escludere tutti gli indirizzi della classe E e D degli indirizzi IPv4, la regola è la seguente:

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

Il numero 3 indica i primi 3 bit tutti a 1, quindi esclude gli indirizzi di classe E e D. In generale sarebbe bene definre una regola che escluda tutti i pacchetti da tutti i tipi di indirizzi esterni alla rete, e abilitare successivamente solo gli indirizzi di reti fidate, quindi

# ipchains -A foward -s 192.168.200.0 -d 0/0 -j ACCEPT

# ipchains -A foward -s 0/0 -d 0/0 -j DENY

l'ordine di immissione della regola in questo caso è importante, infatti se le due regole andassero invertite, anche i pacchetti delle reti fidate andrebbero scartati. Tutti i protocolli che devono essere utilizzati solo dalla rete interna, devono essere disabilitati per la rete esterna esempio:

# Disabilita il protocollo NFS dall'esterno

# ipchains -A input -i eth0 -p tcp -s 0/0 -d 0/0 2049 -l -j DENY

# ipchains -A input -i eth0 -p udp -s 0/0 -d 0/0 2049 -l -j DENY

# Disabilita il NetBEUI dall'esterno.

# ipchains -A input -i eth0 -p tcp -s 0/0 -d 0/0 139 -l -j DENY

# ipchains -A input -i eth0 -p udp -s 0/0 -d 0/0 139 -l -j DENY


L'interfaccia eth0 che riceve i pacchetti dall'esterno, il protocollo a livello applicazione è individuato dalla porta.

Documentazione

Se avete bisogno di informazioni piu` dettagliate non dimenticatevi di leggere: - la man pages di ipchains - l'IPCHAINS-HOWTO (reperibile all'URL http://www.pluto.linux.it/) il sorgente da compilare di IPCHAINS si può trovare al seguente URL: www.rustcorp.com/linux/ipchains/


Script di boot di esempio per IPCHAINS

Inseriamo adesso un file di configurazione che ho trovato su internet, che corrisponde a un script di inizializzazione da inserire nella propia procedura di boot, naturalmente in base alle propie esigenze, lo script dovrà essere modificato con le propie regole.

#!/bin/sh#
#
# rc.firewall
# Script version 1.01 - November 3, 1998
#
################################################################
#
# Initialization script to set up tight rules-based firewalling and
# masquerading for private LAN/internet gateways, via ipchains.
#
# Standard usage is to put this in rc.local after loading the ip masq
# modules, but any changes can be immediately activated simply by running
# this script., as it flushes the old ones and puts in the new ruleset.
#
# Requires Linux 2.1.102 and up or a 2.0.x kernel patched for ipchains,
# as well as the ipchains program, available from the official website at:
# [http://www.adelaide.net.au/~rustcorp/ipfwchains/ipfwchains.html]
#
# All logging goes to dmesg/klogd
#
# Recommended reading:
#
# RFC 1918, 'Address allocation for private internets'
# Ethernet-HOWTO NET-3-HOWTO
# PPP-HOWTO ipchains-HOWTO
# The Jargon File Anything by Terry Pratchett
#
################################################################
# Copyright info:
#
# ipchains (C) 1998 Paul Russell [Paul.Russell@rustcorp.com.au]
#
# script (C) 1998 Ian Hall-Beyer [manuka@nerdherd.net]
#
# Contributors:
# Raymond Moyers [rmoyers@nop.org] - Original ipfwadm script
#
# You are free to distribute this script as you see fit. Any
# modified script must list the authors and contributors above.
# I would also appreciate an email letting me know what you've
# done to improve on it.
#
################################################################
#
# set the following variables to match your network
INTERNALIF="eth0"
INTERNALNET="192.168.1.0/24"
INTERNALIP="192.168.1.1"
#
EXTERNALIF="ppp0"
EXTERNALNET="0.0.0.0/0"
EXTERNALIP="0.0.0.0"
#
# This is the location of the ipchains command
IPCHAINS="/sbin/ipchains"
#
################################################################
#
## Flush everything, start from scratch
#
# Incoming packets from the outside network
$IPCHAINS -F input
# Outgoing packets from the internal networ
$IPCHAINS -F output
# Forwarding/masquerading
$IPCHAINS -F forward
#
## Allow all connections on the internal interface
#
$IPCHAINS -A input -i $INTERNALIF -s 0/0 -d 0/0 -j ACCEPT
$IPCHAINS -A output -i $INTERNALIF -s 0/0 -d 0/0 -j ACCEPT
#
#
## IP Masq
#
## dont masq internal-internal traffic
$IPCHAINS -A forward -s $INTERNALNET -d $INTERNALNET -j ACCEPT
#
## dont masq external interface direct
$IPCHAINS -A forward -s $EXTERNALIP -d 0/0 -j ACCEPT
#
## masquerade all internal IP's going outside
$IPCHAINS -A forward -s $INTERNALNET -d 0/0 -j MASQ
#
# Type of Service (TOS) bits
# This is a new feature of ipchains - check the ipchains HOWTO for

# details on what this does
#
# Set telnet, www and FTP for minimum delay
$IPCHAINS -A output -p tcp -d 0/0 www -t 0x01 0x10
$IPCHAINS -A output -p tcp -d 0/0 telnet -t 0x01 0x10
$IPCHAINS -A output -p tcp -d 0/0 ftp -t 0x01 0x10
#
# Set ftp-data for maximum throughput
$IPCHAINS -A output -p tcp -d 0/0 ftp-data -t 0x01 0x08
#
#
################################################################
# Insert trusted networks here
# (specific networks that can connect to your system)
#
#$IPCHAINS -A input -p [protocol] -s [TRUSTED NET] -d 0/0 [port range] -j ACCEPT
################################################################
# Insert banned networks here
# (specific networks that are banned from your system)
# This is good for blocking the script kiddies.
# any packets meeting these rules are logged.
#
#$IPCHAINS -A input -p [protocol] -s [BANNED NET] -d 0/0 [port range] -l -j DENY
################################################################
# Insert prohibited sites here
# (specific networks that your system is not allowed to connect to)
# any packets meeting these rules are logged.
#
#$IPCHAINS -A output [-p [protocol]] -s $INTERNALNET -d [prohibited net] [port range] -l -j REJECT

################################################################
#
#
## Specific port blocks on the external interface
## These ports have known vulnerabilities and should not be open
## to the outside world unless there is a really good reason for it.
## Since these are potentially vulnerable, packets are logged.
#
## NetBEUI
$IPCHAINS -A input -i $EXTERNALIF -p tcp -s 0/0 -d 0/0 139 -l -j DENY
NSERT $IPCHAINS -A input -i $EXTERNALIF -p udp -s 0/0 -d 0/0 139 -l -j DENY

## MS-SQL
$IPCHAINS -A input -i $EXTERNALIF -p tcp -s 0/0 -d 0/0 1433 -l -j DENY
$IPCHAINS -A input -i $EXTERNALIF -p udp -s 0/0 -d 0/0 1433 -l -j DENY
#
## NFS
#$IPCHAINS -A input -i $EXTERNALIF -p tcp -s 0/0 -d 0/0 2049 -l -j DENY
#$IPCHAINS -A input -i $EXTERNALIF -p udp -s 0/0 -d 0/0 2049 -l -j DENY
#
## postgresSQL
$IPCHAINS -A input -i $EXTERNALIF -p tcp -s 0/0 -d 0/0 5432 -l -j DENY
$IPCHAINS -A input -i $EXTERNALIF -p udp -s 0/0 -d 0/0 5432 -l -j DENY
#
## X11disp:0-:2-
$IPCHAINS -A input -i $EXTERNALIF -p tcp -s 0/0 -d 0/0 5999:6003 -l -j DENY
$IPCHAINS -A input -i $EXTERNALIF -p udp -s 0/0 -d 0/0 5999:6003 -l -j DENY
#
#
## High unpriv ports
#
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 1023:65535 -j ACCEPT
$IPCHAINS -A input -p udp -s 0/0 -d 0/0 1023:65535 -j ACCEPT
#
#
## Basic Services
# Note that unlike ipfw, ipchains cannot take more than one port per
# command, unless it is a range of ports (e.g. 20:23). You can also
# specify a service type (it must be defined in /etc/services)
# instead of a port number. Comment any of these out to block the
# service.
#
# ftp-data
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 20 -j ACCEPT
# ftp
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 21 -j ACCEPT
# ssh
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 22 -j ACCEPT
# telnet
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 23 -j ACCEPT
# smtp
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 25 -j ACCEPT
# DNS
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 53 -j ACCEPT
$IPCHAINS -A input -p udp -s 0/0 -d 0/0 53 -j ACCEPT
# http

$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 80 -j ACCEPT
# POP-3
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 110 -j ACCEPT
# indentd
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 113 -j ACCEPT
# https
$IPCHAINS -A input -p tcp -s 0/0 -d 0/0 443 -j ACCEPT
#
## ICMP
#
# Deny
# Use this to deny ICMP attacks from specific addresses
#$IPCHAINS -A input -b -i $EXTERNALIF -p icmp -s address -d 0/0 -j DENY
#
# Allow incoming ICMP
$IPCHAINS -A input -i $EXTERNALIF -p icmp -s 0/0 -d 0/0 -j ACCEPT
$IPCHAINS -A input -i $INTERNALIF -p icmp -s 0/0 -d 0/0 -j ACCEPT
# Allow outgoing ICMP
$IPCHAINS -A output -i $EXTERNALIF -p icmp -s 0/0 -d 0/0 -j ACCEPT
$IPCHAINS -A output -i $INTERNALIF -p icmp -s 0/0 -d 0/0 -j ACCEPT
#
#
## set default policies
## ipchains reverts to these if it hasn't matched any of the previous
## rules.
#
$IPCHAINS -A input -j DENY
$IPCHAINS -A output -j ACCEPT
$IPCHAINS -A forward -j DENY

Copyright (c) 2000-3000 by Ing. Eduardo Palena - Napolifirewall.com