Newsgroup: it.comp.os.linux.sys
Titolo: come funziona il NAT

Siccome mi e' stato richiesto, posto un piccolo articolo sul
funzionamento del NAT e della sua implementazione in linux come
MASQUERADE.
Introduciamo innanzitutto dei termini che ricorreranno nell'articolo:
Per IP address _Privato_ si intende un indirizzo appartenente ad uno dei
gruppi di indirizzi designati ad essere usati nelle LAN basate su IP e
non interconnesse con Internet (in maniera diretta, perlomeno).
Tali indirizzi sono stati scelti da IANA (Internet Assigned Numbers
Authority) e sono i seguenti:
 10.0.0.0        -   10.255.255.255
 172.16.0.0      -   172.31.255.255
 192.168.0.0     -   192.168.255.255
Tutti questi indirizzi non vengono assegnati a nessuna macchina connessa
ad Internet.
Innanzitutto diciamo che NAT sta per Network Address Translation. E'
chiamato cosi' perche' il suo compito fondamentale e' tradurre indirizzi
IP privati in indirizzi IP pubblici, e viceversa.
Originariamente il NAT fu sviluppato per permettere l'accesso alla rete
da parte di piu' client di quanti IP address si possedessero. L'idea e'
simile ai centralini dei grandi uffici o enti, in cui le linee per
connettersi con l'esterno sono molte meno del numero effettivo degli
utenti (che d'altro canto si suppone non passino tutta la giornata al
telefono).
In questo scenario ogni volta che una macchina vuole connettersi
all'esterno della Intranet, gli viene "prestato" un IP pubblico dal
router NAT. Questo IP viene liberato in genere dopo un certo timeout di
inutilizzo, fino allo scadere del quale la macchina che lo possiede ne
ha un uso esclusivo.
Il sistema tuttavia puo' essere applicato anche se si possiede UN SOLO
IP address pubblico.
Per spiegare come questo sia possibile bisogna  esporre come funziona il
NAT.
Un router NAT fa qualcosa di piu' di un semplice router.
Quando riceve dalla LAN un pacchetto IP destinato ad una macchina
esterna alla LAN:
- memorizza IP:porta di sorgente e di destinazione in una tabella.
Chiamiamo Entry1 la prima coppia ed Entry2 la seconda.
- cambia l'IP e la porta sorgente con un IP pubblico ed una porta
disponibile presa da un opportuno pool (in genere da 50000 in su).
- infine come un normale router instrada il pacchetto opportunamente
all'esterno della LAN (verso Internet).
Quando il router NAT riceve un pacchetto proveniente dall'esterno della
LAN (da Internet):
- cerca nella tabella sopra citata nel campo Entry2 se esiste una voce
corrispondente all'indirizzo SORGENTE del pacchetto ricevuto.
- Se esiste, il router sostituisce l'indirizzo di destinazione del
pacchetto con il campo Entry1. Altrimenti il pacchetto viene trattato in
maniera diversa (gettato, respinto o altro)
adesso cerchero' di viasualizzare la cosa attraverso un esempio e dei
disegni:
In tale esempio il client Worley (192.168.1.10) invia un pacchetto al
server web 
www.tiscalinet.it
 (porta di destinazione 80) e riceve una
risposta.
Lo schema che segue rivolge l'attenzione ad i soli pacchetti:
Pacchetto in uscita:
     SORG: 
192.168.1.10:2250
     NAT     SORG: 
151.12.10.187:61251
     DEST: 
195.130.224.57:80
   ------->  DEST: 
195.130.224.57:80
Pacchetto in ingresso:
     SORG: 
195.130.224.57:80
      NAT    SORG: 
195.130.224.57:80
     DEST: 
192.168.1.10:2250
   <-------  DEST: 
151.12.10.187:61251
Questo invece rappresenta lo schema completo:
Vediamo cosa succede quando il client Worley invia una richiesra al
server Web 
www.tiscalinet.it
.
(i disegni sono sviluppati in verticale perche' quasi tutti i client di
posta fanno il word wrap. E' probabile che con il vostro client non
vengano rispettati spazi e tabulazioni. Per vedere meglio i disegni
potere copiarli ed incollarli in un editor di testi che abbia dimensione
del carattere fissa, come Textpad)
-------------------------
client (Worley)
IP privato: 192.168.1.10
-------------------------
     |
     |
     |
     |   ------------------------
     |->  Pacchetto Originale
          SORG: 
192.168.1.10:2250
          DEST: 
195.130.224.57:80
         ------------------------
                                 |
                                 |
                                 |
                                 |
---------------------------      |
IP privato: 192.168.1.1    <-----|
Router NAT
IP pubblico: 151.12.10.187
---------------------------
     |
     |
     |
     |
     |   --------------------------
     |--> Pacchetto Modificato
          SORG: 
151.12.10.187:61251
          DEST: 
195.130.224.57:80
         --------------------------
                                 |
                                 |
                                 |
                                 |
---------------------------      |
Server Web                 <-----|
IP pubblico: 195.130.224.57
---------------------------
Vediamo cosa succede quando lo stesso server web  invia una risposta
relativa alla precedente richiesta del client Worley.
---------------------------
Server  Web
IP pubblico: 195.130.224.57
---------------------------
     |
     |
     |
     |   --------------------------
     |->  Pacchetto Originale
          SORG: 
195.130.224.57:80
          DEST: 
151.12.10.187:61251
         --------------------------
                                 |
                                 |
                                 |
                                 |
---------------------------      |
IP pubblico: 151.12.10.187 <-----|
Router NAT
IP privato: 192.168.1.1
---------------------------
     |
     |
     |
     |
     |   --------------------------
     |--> Pacchetto Modificato
          SORG: 
195.130.224.57:80
          DEST: 
192.168.1.10:2250
         --------------------------
                                 |
                                 |
                                 |
                                 |
---------------------------      |
Client Worley              <-----|
IP privato: 192.168.1.10
---------------------------
Tornando al discorso precedente, basta osservare che una comunicazione
e' univocamente individuata da IP:porta di sorgente e destinazione per
convincersi che in realta' per un numero limitato di macchine (fino a un
centinaio) un singolo IP è sufficiente.
Infatti il numero di porte a disposizione del router NAT e' enorme
rispetto al numero di pacchetti che esso potrebbe processare (volendo
usare le sole porte da 50000 in su: sono piu' di 15000 porte
utilizzabili per instaurare altrettante comunicazioni...)
Ed ora passiamo al MASQUERATING ed a tutte le forme di router NAT che si
trrovano in commercio ultimamente.
Il NAT puro e semplice ha due problemi:
- il protocollo di comunicazione usato dalle applicazioni deve basarsi
solo ed esclusivamente sullo header IP per desumere INDIRIZZI e PORTE.
Tali informazioni nonpossono risiedere nell'area dati del pacchetto.
- Non e' possibile usare programmi di tipo server (cioe' che aspettano
una comunicazione su una certa porta)
Mentre il secondo problema e' risolvibile molto seplicemente con una
soluzione unica, il secondo va risolto protocollo per protocollo.
Prendiamo come esempio tipico FTP: in alcuni casi vengono scambiati
(nell'area dati del pacchetto TCP) informazioni su porta ed indirizzo da
usare.
La situazione tipica e' che un client invii un comando PORT specificando
il proprio indirizzo IP privato (es: 192.168.1.10) ed una porta sulla
quale si mette in attesa di una comunicazione.
I problemi citati in precendenza si verificano entrambi:
- il server FTP tentera' di rispondere ad un indirizzo privato (senza
riuscirci mai, ovviamente) che ha ricavato dal comando PORT ricevuto.
- il client si mette in attesa di una connessione (in tal caso si
comporta come un server) sulla porta specificata nel comando PORT.
Tuttavia il router NAT e' del tutto all'oscuro di questa situazione.
Il risultato e' che uno dei protocolli piu' diffusi non funziona a
dovere con il NAT.
La soluzione adottata dal MASQUERADE ddi linux per risolvere il primo
problema e' un tipo di moduli del kernel che hanno il compito di
individuare un determinato protocollo e di correggere i dai in esso
contenuti di conseguenza e di informare il modulo principale di MASQ
della situazione.
In particolare, il modulo che si occupa di far funzionare FTP intercetta
i comandi PORT (anche i PASV) e ne modifica i parametri come conviene.
Altri protocolli che non sono "NAT fiendly" sono ICQ, programmi di
conferencing, QUAKE...
Alcuni necessitano di un modulo apposito.
Altri, piu' NAT fiendly, si accontentano di un Port Forwarding.
Il Port Forwarding e' la soluzione al secondo problema del NAT.
Esso permette di inpartire ordini speciali al modulo MASQ del kernel,
che stabiliscono in maniera statica come trattare le  comunicazioni in
ingresso destineate a determinate porte.
E' ad esempio possibile stabilire che tutte le connessioni destinate
alla porta 80 siano forwardate all'IP 192.168.1.25, che e' il nostro
server Web sulla LAN.
C'e' da notare una cosa: il problema dei servizzi in ingresso viene in
realta' spacciato come cosa buona e voluta da molti vendor di software
router NAT. come dire: A feature is a bug with seniority.
Infatti tale caratteristica si comporta come un Firewall, in quanto
rende invisibile la rete dietro il router: le comunicazioni possono
essere iniziate solamente dall' interno (solo in tal caso viene creata
una entry nella tabella del NAT che permette di individuare i pacchetti
di risposta) ed i servizzi disponibili all'esterno possono essere
cotrollati attraverso il port forwarding.
Per il momento l'articolo finisce qui.
Se qualcuno ha bisogno di chiarimenti, chieda pure.
Vogliate perdonare imprecisioni ed inesattezze... :)
Il mio indirizzo e' 
pai...@paipai.net
 (e non e' uno scherzo, come
credeva qualcuno su questo NG, ma il mio indirizzo vero)
Ciauz!
   midorichan
////////////////////////////////////
     ... A feature is a bug with seniority.

 teorico ;)
Ed eccoci qua: vediamo come si fa a configurare in maniera semplice il MASQUERADE e le cose
correlate sui kernel 2.2.
L'articolo che segue dovrebbe tornar utile a chiunque voglia configurare il MASQUERADE sulla
propria macchina Linux, ma che per un qualsiasi motivo "non osa farlo" :)
Per chi non lo sapesse, il MASQ di linux permette di condividere in maniera quasi completamente
trasparente (vuol dire i non dovete cambiare configurazione sui clien) un SINGOLO accesso ad
internet.
Il masq semplice si adatta anche a connessioni dialup, le quali cambiano IP ad ogni
connessione.
L'articolo non tratta questo tipo di connessioni. D'altro canto, per fare in modo che il MASQ
funzioni anche con connessioni ad IP dinamico, non si deve far altro che modificare alcuni
script (alla fine dell'articolo proposti) per far in modo che ad ogni cambio di IP, la macchina
si riconfiguri automaticamente.
Ovviamente e' inutile dire che essendo stato scritto in poche ore, questo articolo puo' essere
pieno di inperfezioni ed errori.
Nel caso mi accorga in seguito di grossi strafalcioni, lo rendero' noto sul NG
it.comp.os.linux.*
L'articolo viene postato oltre che su it.comp.os.linux.sys anche su
it.comp.os.linux.iniziare
Questo documento lo si puo' trovare su:
 
http://www.paipai.net/texts/masquerade.txt
Un piccolo articolo in italiano sul funzionamento del NAT si trova su:
 
http://www.paipai.net/texts/NAT.txt
SI SUPPONE che la vostra LAN sia gia' funzionante e che sia configurata con IP privati.
 (presi tra : 10.0.0.0-10.255.255.255 ,172.16.0.0-172.31.255.255 ,
 192.168.0.0-192.168.255.255)
Un piccolo indice:
per raggiungere la sezione cercata, basta fare un search sulla keyword che gli ho associato.
Panoramica                   (KEYWORD = PAN1)
Come settare il Firewalling  (KEYWORD = FW1)
  input chain                (KEYWORD = FW1.1)
  forward chain              (KEYWORD = FW1.2)
Port Forwarding              (KEYWORD = PORTFW1)
Script Utili                 (KEYWORD = SCRIPT1)
   rc.local(startup script)  (KEYWORD = SCRIPT1.1)
   setup connessione         (KEYWORD = SCRIPT1.2)
   rc.firewall               (KEYWORD = SCRIPT1.3)
   Port Forwarding           (KEYWORD = SCRIPT1.4)
   constrollo stato della connessione    (KEYWORD = SCRIPT1.5)
Si, ma come configuro i client?          (KEYWORD = CLENT1)
(KEYWORD = PAN1)
Come esempio vi esporro' la mia configurazione.
La mia rete e composta da 4 computer: due client W2K, un server NT4.0 ed un Gateway/MASQ Linux.
Il server NT si occupa dei servizzi FTP, HTTP, SMPT, POP3, IMAP4 e fa da PDC per la rete
SMB/Microsoft.
Il Gatway Linux fa da Router/MASQ e da firewall. Inoltre funge da sever Socks, Cache, DNS, SSH,
e analizza il traffico alla
ricerca di possibili attacchi (di norma almeno uno al giorno, falsi allarmi esclusi... :) ).
Il Gateway e' connesso in PPTP tramite ADSL640K/128K.
Cominciamo col  dire che il Firewalling e parte del MASQUERADE si configurano con il
programma   ipchains  .
ipchains rappresenta un frontend per il kernel: non f altro che tradurre i nostri comandi che
hanno una dimensione umana in
istruzioni per la parte del kernel che si occupa di del Forwarding/Firewalling
Esistono anche altri programmi, ma vi sconsiglio di usarli a meno che non sappiate cosa state
facendo: in tal caso quindi credo
che le cose che seguiranno sarebbero per voi scontate.
ipchains e' il programma ufficiale scritto da (mannaggia alla mia memoria!!!) colui che
gestisce il codice del Forwarding,
Firewalling e suoi annessi e connessi.
NOTA: nella versione 2.0 del kernel il programma corrispondente a ipchains si chiamava ipfwadm
(oppure semplicemente ipfw)
Tale programma era stato preso a prestito da BSD, ed e' per questo che e' stato abbandonato per
un qualcosa di fatto apposta
per Linux.
Nei Kernel 2.4 l'autore (non) citato sopra, perso da nuovo raptus di fantasia, ha di nuovo
cambiato nome al programma (adesso
gestisce praticamente tutto!)
Tornano al discorso di prima, ho detto che il MASQUERADE si configura solo in parte con
ipchains. In effetti esso permette
solo di configurare il NAT puro e semplice e non fa nulla per il Port Forwarding.
Per configurare il Port Worwarding bisogna procurarsi il programma ipmasqadm.
Per quanto riguarda il kernel, dovete attivare:
ip_firewalling
use FWMARK value as routing key (opzionale)
transparent proxy support (opzionale, ma potrebbe tornare utile)
masquerading
ICMP masquerading
masquerading special modules support
ipautofw masq support (opzionale)
ipportfw masq support
ip fwmark masq-forwarding support (opzionale)
ip tunneling e GRE tunnels over IP (questi due non ho capito proprio se sono necessari per il
pptp. cmq, possono essere
compilati come moduli, quindi...)
NOTA: perdonatemi se non vi dico i link in cui potete trovare i programmi.
Comunque, a parte il fatto che in molte distribuzioni tali programmi  sono presenti, comunque
credo che ormai dovreste aver
imparato a fare ricerche su internet. Vi assicuro che il solo motore di ricerca che uso e'
Altavista con la ricerca booleana. Con
quello trovo davvero TUTTO. Se si tratta di programmi di cui si sa percisamente il nome, allora
ftpsearch e' inmattibile
(
ftpsearch.lycos.com
, sempre ricerca avanzata, ovviamente)
( KEYWORD = FW1 )
cominciamo dal firewalling.
E' un'ottima idea cominciare da qui, perche' non avete idea (neppure io l'avevo, credetemi) di
quanto sia pericoloso stare
connessi 24h/24h senza una valida protezione.
Impostare delle buone regole di firewalling e' la PRIMA cosa da fare.
il programma che serve per il momento e' il solo ipchains.
ipchains si chiama cosi' perche' permette di definire delle specie di "catene di firewall". A
dire il vero il termine non mi va proprio
a genio, quindi lo usero' poco (comqnque, in questo contesto gruppo o chain sono la stessa
cosa).
In poche parole, si tratta di regole per il filtraggio dei pacchetti raggruppate sotto
determinati nomi.
I gruppi di default sono input, forward, output (notare l'ordine in cui sono scritti)
NOTA: a volte viene fatta una confusione di termini: ogni chain puo' rappresentare delle regole
da applicare ai pacchetti in
INPUT, FORWARD, OUTPUT (cioe' in ingresso, transito o uscita. Notare il maiuscolo). Tali nomi
scritti in minuscolo
rappresentano le chain di default (citate piu' su), mentre scritti in maiuscolo rappresentano
il modo in cui le regole di una chain
qualsiasi devono essere applicate. Comunque, non vi fate troppi problemi: nei miei esempi non
uso nessun gruppo di regole
diverso da quelli di default.
Per far funzionare il firewalling bisogna attivare l' ipforwarding del kernel.
(KEYWORD = FW1.1)
Le regole piu' importanti sono quelle di input e di forward. Quelle di output servono a
garantire una maggiore sicurezza, ma si
potrebbero anche omettere.
Le regole di input devono stabilire quali pacchetti possono entrare nella nostra rete. In
genere non vogliamo che accadano cose
come lo spoofing e l'attacco su servizzi fruibili solo dagli utenti della rete interna.
Dunque nelle regole di input stabiliremo quanto segue:
innanzitutto, la regola di default e' rifiutare ogni cosa:
~# ipchains -P input REJECT
-P input indica il nome della chain. REJECT stabilisce che tutto cio che non permetteremo
esplicitamente andra' rifiutato.
Dopo di che dobbiamo stabilire che tutto il traffico della rete interna diretto verso qualsiasi
destinazione, deve essere accettato.
In questo scenario sto dicendo che tutti il traffico sull'interfaccia eth0 proveniente dal
network 
192.168.0.0/24
 destinato a
qualsiasi indirizzo deve essere accettato
~# ipchains -A input -i eth0 -s 
192.168.0.0/24
 -d 
0.0.0.0/0
 -j ACCEPT
l'opzione -i permette di specificare il nome dell'interfaccia a cui si deve riferire una
regola.
la riga seguente stabilisce che tutti i pacchetti che provengono dall'interfaccia ppp0 (da
Internet, insomma) e che hanno come
sorgente il nostro network interno 
192.168.0.0/24
 devono essere rifiutati. Questo evita lo
spoofing.
~# ipchains -A input -i ppp0 -s 
192.168.0.0/24
 -d 
0.0.0.0/0\
 -l -j REJECT
La regola seguente stabilisce che ogni pacchetto proveniente da Internet (ppp0) e destinato
all'indirizzo IP pubblico (quello
assegnato dal provider) deve essere accettato.
~# ipchains -A input -i ppp0 -s 
0.0.0.0/0
 -d xxx.xxx.xxx.xxx/32\
 -j ACCEPT
Il traffico sull'interfaccia di loopback (127.0.0.1) va sempre accettato:
~# ipchains -A input -i lo -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 -j ACCEPT
ed ora passiamo a "chiudere certe porte" fastidiose.
Come esempio vi porto la chiusura delle porte del netbios, servizio che vorremmo proprio
evitare di far vedere all'esterno...
~# ipchains -A input -i ppp0 -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 137:139 -l -j DENY
~# ipchains -A input -i ppp0 -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 137:139 -l -j DENY
-p xxx permette di specificare il nome di un protocollo (od il numero corrispondente... vedere
in /etc/protocols) da considerare
-l dice di loggare l'accaduto (in syslog)
137:139 messi di seguito all'indirizzo (
0.0.0.0/0
) indicano le porte da considerare.
Questa configurazione chiude tutte e tre le pericolose porte del netbios e ci permette di
satare un po' piu' tranquilli nella rete
interna.
Ovviamente conviene chiudere esplicitamente TUTTE le porte dei servizzi attivi che non devono
essere usati all'esterno della
rete, perche' NON SI SA MAI!
(KEYWORD = FW1.2)
Passiamo ora s spiegare le regole di FORWARDING (cioe' come trattare i pacchetti in transito)
In queste si stabilische anche in che casi fare il masquerade.
innanzitutto, ovviamente, si impone di non forwardare mai niente che non sia esplicitamente
permesso.
~# ipchains -P forward DENY
Dopo di che si stabilisce che i soli pacchetti che hanno come sorgente una nostra macchina e
come destinazione una macchina
diversa dalle nostre siano MASCHERATI e fowardati.
ipchains -A forward -i ppp0 -s 
192.168.0.0/24
 -d !
192.168.0.0/24
 -j MASQ
notate il parametro -d !
192.168.0.0/24
 . Davanti all'indirizzo del network c'e' un punto
esclamativo. Questo rappresenta una
negazione e significa: qualsiasi indirizzo che NON appartenga a tale network.
-j MASQ indica che questa regola riguarda il MASQUERADE.
NON vi preoccupate, dopo inseriro' anche i listati di TUTTI gli shell script che fanno il
lavoro per me. Modificando pochi parametri potrete adattarli alla vostra macchina.
Con quello che ho detto fino ad ora, sfruttando il solo ipchains, si dovrebbe essere in gradi
di far funzionare il MASQUERADE per le connessioni in uscita.
Senza caricare i moduli aggiuntivi del MASQ, la configurazione attuale effettua un NAT puro e
semplice.
Esistono vari moduli, alcuni messi nel sorgente del kernel, altri invece da prelevare e
compilare a parte.
li trovate in
/lib/modules/2.2.xx/ipv4/
io posseggo:
ip_masq_cuseeme.o
ip_masq_icq.o
ip_masq_quake.o
ip_masq_ftp.o
ip_masq_irc.o
ip_masq_raudio.o
ip_masq_vdolive.o
per far funzionare le applicazioni cui si riferiscono (in particolare FTP e ICQ) dovete
caricare tali moduli (con modprobe o insmod). Non mi pare siano moduli che si carichino
automaticamente. Cmq, a parte quello di ICQ, sono moduli talmente piccoli che li potete tenere
sempre in memoria (SOLO quelli che servono! se non ve ne frega un tubo di quake, perche'
tenerne il modulo?)
(KEYWORD = PORTFW1)
ADESSO passiamo ai SERVIZZI IN INGRESSO, per i quali server ipmasqadm.
tale programma si compone di vari moduli. quello che ci server e' portfw
il seguente comando redirige tutto il traffico che arriva sulla poprta 21 del gateway
(xx.xx.xx.xx, IP assegnato dal provider) sul server FTP della rete interna 192.168.0.12.
~# ipmasqadm portfw -a -P tcp -L xx.xx.xx.xx 21 -R 192.168.0.12 21
Notare che in questo caso la porta rimane sempre la stessa, 21. Ma nulla vieta di redirigere
una posta su un'altra.
Nel caso di servizio HTTP il comando sarebbe:
~# ipmasqadm portfw -a -P tcp -L xx.xx.xx.xx 80 -R 192.168.0.11 80
In questo esempio si suppone che la macchina che fa da server WEB sia diversa da quella che fa
FTP (192.168.0.12 per FTP, 192.168.0.11 per WWW).
(KEYWORD = SCRIPT1)
DELLE cose utili possono essere:
script che controllano lo stato della connessione PPTP e che agiscono in caso di caduta (in
caso di IP dinamico, devono fare ben altro che il solo ripristino della connessione: si devono
occupare di riconfigurare firewalling e forwarding).
Script di attivazione della connessione PPTP.
Script di inizializzazione del firewalling
Script di inizializzazione del port forwarding.
qui di seguito vi posto i miei.
C'e' un piccolo problema: molto spesso viene effettuato dai client (ma anche dai server
gentili) il wordwrap a 72 caratteri. Le righe di comando sono di certo piu' lunghe. Cerchero'
di correggere gli script, tuttavia potrebbe captare che ci siano comunque degli errori.
Ecco a voi gli script:
(KEYWORD = SCRIPT1.1)
Questo e' lo script di inizializzazione richiamato da Init
prima che venga richiesto il Login (l'ultimo script
di inizializzazione).
#!/bin/sh
##########################################################
# /etc/rc.d/rc.local:  Local system initialization script.
##########################################################
# Put any local setup commands in here:
#
# L'ordine con cui vanno caricati i vari servizzi e' questo:
#
# setup connessione
/etc/rc.d/rc.pptp-up
# impostazione firewall
/etc/rc.d/rc.firewall
# Impostazione Port Forwarding
/etc/rc.d/rc.portmap
# tutti gli altri sevizzi:
echo "Starting the Bind Daemon..."
/usr/sbin/ndc start
echo "Done!"
echo "Activating Kernel antispoofing"
echo "1" > /proc/sys/net/ipv4/conf/all/rp_filter
echo "Snorting!(grunf-grunf)"
/usr/local/bin/snort -A full -c /root/snort.rules -D -i ppp0
echo "Running Squid www-cache"
/usr/local/squid/bin/squid
# DONE!
(KEYWORD = SCRIPT1.2)
Il seguente script e' molto semplice: si occupa di resettare una connessione, sia essa attiva o
disattiva.
A volte la connessione non cade, ma comunque smette di funzionare.
Quindi uno script che elimini ogni traccia della connessione corrente prima di ripristinarne
una nuova e' molto utile.
Questo script non controlla se la connessione e' attiva. Nel mio caso viene fatto da un'altro
script, proposto piu' avanti.
#! /bin/sh
###########################################
# questo script resetta la connessione pptp
###########################################
#
# elimina ogni connessione precedente
# ed ogni possibile traccia che essa possa lasciare
/bin/killall -9 pppd
/bin/killall -9 pptp
/sbin/route del -host 1.2.3.100    # Il gateway del vostro PROVIDER
/sbin/route del -net 0.0.0.0    # elimina il defaultroute
/bin/rm -f /var/run/pptp/*
/bin/rm -f /var/run/ppp0.pid
echo "setting Up PPTP connection...   "
/usr/sbin/pptp 10.0.0.122 name IlTuoUsername defaultroute
# 
10.0.0.122
: IP del mio modem ADSL. Sostituite quello del vostro
# per motivi di sicurezza l'ho cambiato.
sleep 3
echo "Done."
(KEYWORD = SCRIPT1.3)
ECCO ora un file mooolto lungo, quello del firewalling.
Ricordate che le righe potrebbero essere stare wrappate dal vostro mailer. Fate attenzione
prima di fare copia e incolla.
#! /bin/sh
##################################
# midori's Strong Firewall rules #
#                                #
#                                #
##################################
#
echo "setting up Firewall...  "
#
# per prima cosa attiviamo l'IP_FORWARDING
echo "1" > /proc/sys/net/ipv4/ip_forward
#
#Alcune variabili DA SETTARE in base alla vostra configurazione
extip="1.2.3.4"   # sostituire il proprio IP pubblico
extint="ppp0"     # sostituire col nome della interfaccia esterna.
intint="eth1"   # Sostituire col nome della prima interfaccia interna.
intint10="eth0"   # Sostituire col nome della seconda interfaccia interna
    # se esiste. Altrimenti eliminare ogni comando in cui
    # appare la stringa $intint10.
# rappresentano rispettivamente gli indirizzi dei network della
# rete interna
# relativi alle interfacce $intint e $intint10
# nel caso la seconda interfaccia sia assente, eliminare ogni comando
# in cui appaia la stringa $intnet10
intnet="
192.168.1.0/24
"
intnet10="
10.1.1.0/24
"
# MASQ timeouts: sono i timeouts da associare ad ogni entry
#    della tabella del NAT
#
# 2 hrs timeout for TCP session timeouts
# 10 sec timeout for traffic after the TCP/IP "FIN"
#    packet is received
# 60 sec timeout for UDP traffic (MASQ'ed ICQ users must enable a
#    30sec firewall timeout in ICQ itself)
#
ipchains -M -S 7200 10 180
#############################################################################
# Incoming, flush and set default policy of reject. Actually the
# default policy
# is irrelevant because there is a catch all rule with deny and log.
#
ipchains -F input  # resetta la chain input
ipchains -P input REJECT
# local interface, local machines, going anywhere is valid
#
ipchains -A input -i $intint -s $intnet -d 
0.0.0.0/0
 -j ACCEPT
ipchains -A input -i $intint10 -s $intnet10 -d 
0.0.0.0/0
 -j ACCEPT
# remote interface, claiming to be local machines, IP spoofing,
# get lost!
#
ipchains -A input -i $extint -s $intnet -d 
0.0.0.0/0
 -l -j REJECT
ipchains -A input -i $extint -s $intnet10 -d 
0.0.0.0/0
 -l -j REJECT
# remote interface, any source, going to permanent PPP address
# is valid
#
ipchains -A input -i $extint -s 
0.0.0.0/0
 -d $extip/32 -j ACCEPT
# loopback interface is valid.
#
ipchains -A input -i lo -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 -j ACCEPT
# closing all dungerous ports:
# e' IMPORTANTISSIMO chiudere questa porta! Anzi, meglio eliminare
# proprio RPC e tutti gli "r" daemons (rexec, rlogin etc.)
#
echo "Rejecting all RPC connections on $extint (111)"
ipchains -A input -i $extint -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 111\
-l -j DENY
ipchains -A input -i $extint -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 111\
-l -j DENY
# altro servizio da chiudere ASSOLUTAMENTE.
echo "Rejecting all NETBIOS connections on $extint (135-139)"
ipchains -A input -i $extint -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 135:139\
 -l -j DENY
ipchains -A input -i $extint -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 135:139\
 -l -j DENY
echo "Rejecting all REXEC connections on $extint (512)"
ipchains -A input -i $extint -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 512:512\
 -l -j DENY
ipchains -A input -i $extint -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 512:512\
 -l -j DENY
# a che ci server far stampare qualcuno da Internet?
echo "Rejecting all LPD connections on $extint (515)"
ipchains -A input -i $extint -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 515:515\
 -l -j DENY
ipchains -A input -i $extint -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 515:515\
 -l -j DENY
# Socks rappresenta un tipico servizio da usare solo dall'interno.
echo "Rejecting all socks connections on $extint (1080)"
ipchains -A input -i $extint -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 1080\
 -l -j DENY
ipchains -A input -i $extint -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 1080\
 -l -j DENY
# per lo stesso motivo del NETBIOS, meglio chiudere NFS.
# anzi, se lo si puo' togliere e' molto meglio.
echo "Rejecting all NFS connections on $extint (2049)"
ipchains -A input -i $extint -p tcp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 2049\
 -l -j DENY
ipchains -A input -i $extint -p udp -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 2049\
 -l -j DENY
# questo comando reifiuta tutto il traffico non esplicitamente
# consentito
# la differnza con il primo comando impartito:
# ipchains -P input REJECT ?
# Qui viene imposto di effettuare il log del traffico.
ipchains -A input -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 -l -j REJECT
#######################################################################
# Forwarding, flush and set default policy of deny. Actually the
# default
# policy is irrelevant because there is a catch all rule with
# deny and log.
#
ipchains -F forward  # resetta la chain forward
ipchains -P forward DENY
# MASQUERADE attivo sui localnet per i pacchetti diretti altrove
# (al di fuori della LAN/localnet)
ipchains -A forward -i $extint -s $intnet -d ! $intnet -j MASQ
ipchains -A forward -i $extint -s $intnet -d ! $intnet10 -j MASQ
#
# catch all rule, all other forwarding is denied and logged. pity there
# is no log option on the policy but this does the job instead.
#
ipchains -A forward -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 -l -j REJECT
#######################################################################
# Come avevo detto, le regole di filtraggio in output sono OPZIONALI
# Outgoing, flush and set default policy of reject. Actually the
# default
# policy is irrelevant because there is a catch all rule with
# deny and log.
#
ipchains -F output   # resetta la chain forward
ipchains -P output REJECT
# local interface, any source going to local net is valid
#
ipchains -A output -i $intint -s 
0.0.0.0/0
 -d $intnet -j ACCEPT
ipchains -A output -i $intint10 -s 
0.0.0.0/0
 -d $intnet10 -j ACCEPT
# anything else outgoing on remote interface is valid
#
ipchains -A output -i $extint -s $extip/32 -d 
0.0.0.0/0
 -j ACCEPT
# loopback interface is valid.
#
ipchains -A output -i lo -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 -j ACCEPT
# catch all rule, all other outgoing is denied and logged. pity there
# is no log option on the policy but this does the job instead.
#
ipchains -A output -s 
0.0.0.0/0
 -d 
0.0.0.0/0
 -l -j REJECT
# abbiamo finito!
echo "Done!"
(KEYWORD = SCRIPT1.4)
Questo script Setta il port Forwarding.
Nella mia rete molti servizzi vengono serviti da una macchina
della rete privata.
Ovviamente i servizzi posti sulla macchina gateway
non necessitano del portforwarding.
#!/bin/sh
# ######################## #
# port Forwarding setup.
# ######################## #
#
echo "Setting up Port Forwarding..."
#
# Setting IPs.
extip="1.2.3.4"   # IP assegnato dal provider
ntservip="192.168.1.10"  # IP macchina 1
ntservname="paipai"  # nome macchina 1 (opzionale)
midoriip="192.168.1.12"  # IP macchina 2
songokuip="192.168.1.14" # IP macchina 3
# flushing port mapping
#
ipmasqadm portfw -f
# setting port mapping: extip port -> int ip port
#
echo -n "Port 20 -> $ntservip... ($ntservname ftp-data)...   "
ipmasqadm portfw -a -P tcp -L $extip 20 -R $ntservip 20
echo "Done!"
echo -n "Port 21 -> $ntservip... ($ntservname ftp)...  "
ipmasqadm portfw -a -P tcp -L $extip 21 -R $ntservip 21
echo "Done!"
echo -n "Port 25 -> $ntservip... ($ntservname SMTP)...  "
ipmasqadm portfw -a -P tcp -L $extip 25 -R $ntservip 25
echo "Done!"
echo -n "Port 80 -> $ntservip... ($ntservname WEB)...  "
ipmasqadm portfw -a -P tcp -L $extip 80 -R $ntservip 80
echo "Done!"
echo -n "Port 110 -> $ntservip... ($ntservname POP3)...  "
ipmasqadm portfw -a -P tcp -L $extip 113 -R $ntservip 110
echo "Done!"
echo -n "Port 143 -> $ntservip... ($ntservname IMAP4)...  "
ipmasqadm portfw -a -P tcp -L $extip 143 -R $ntservip 143
echo "Done!"
echo -n "Port 443 -> $ntservip... ($ntservname SSL)...  "
ipmasqadm portfw -a -P tcp -L $extip 443 -R $ntservip 443
echo "Done!"
echo -n "Port 444 -> $ntservip... ($ntservname SSL-2)...  "
ipmasqadm portfw -a -P tcp -L $extip 444 -R $ntservip 444
echo "Done!"
echo -n "Port 745 -> $ntservip... ($ntservname special ftp)...  "
ipmasqadm portfw -a -P tcp -L $extip 745 -R $ntservip 745
echo "Done!"
echo "Done!"
(KEYWORD = SCRIPT1.5)
ECCO ora lo script che controlla lo stato della connessione
Lo si dovrebbe lanciare periodicamente tramite crond
Probaolmente esiste un programma meno semplice di pptp
che si accorge da solo che la connessione e' caduta
e la ripristina.
#!/bin/sh
#############################################
# controlla lo stato della connessione pptp
# da usare con crond.
# ecco la riga da inserire nella crontab:
#    # Controlla che la connessione PPP sia UP (ogni 5 min)
#     */5 * * * * /root/ppp.resume >> /var/log/messages 2>&1
#
#############################################
# sostituite il vostro gateway o un host pingabile
gateway = "151.1.1.1"
case `ping -nqc 4 $gateway` in
 *"100% packet loss"*)
 echo "`date '+%b %e %T'` [ppp.resume] Connessione caduta."
 case `ps -x` in
 *"pppd"*)
  echo "`date '+%b %e %T'` [ppp.resume] !!! pppd ancora attivo: pausa di 2 minuti."
  sleep 120
  case `ping -nqc 2 $gateway` in
  *"100% packet loss"*)
    echo "`date '+%b %e %T'` [ppp.resume] !!! Connessione non piu' attiva."
    echo "`date '+%b %e %T'` [ppp.resume] La connessione pptp verra' ristabilita."
           /etc/rc.d/rc.pptp-up
           exit 0
  esac
  exit 0
 esac
 echo "`date '+%b %e %T'` worley:[ppp.resume] pppd non attivo: ripristino della connessione
pptp"
 /etc/rc.d/rc.pptp-up
 exit 0
esac
# echo "[`date +%D%t%T`] PPP connection ALIVE."
# DONE!
(KEYWORD = CLENT1)
Pochi giorni fa, un amico mi ha chiamato dicendomi:
"Mi avevi detto che il Winroute (Un NAT router per Winsuck) era semplicissimo da configurare:
ma a me non funziona una mazza! Iamm', vien ad aiutarmi"
Ovviamente si trattava di una fesseria. Ma come mi ha fatto notare il mio amico, puo' essere
una fesseria per me! Lui non ci avrebbe mai pensato alla soluzione.
La cosa e' semplice: che il vostro Router sia NAT o no, voi dovete dire a TUTTI i client
qual'e' il Gateway della rete. Perche' altrimenti i client non sapranno dove indirizzare i
pacchetti destinati all' esterno della LAN.
Il gateway si setta in maniera diversa sui vari sistemi operativo.
Cominciamo da Linux.
Si deve usare il comando route, ovviamente.
la riga di comando, da inserire nello script di inizializzazione della rete, deve essere del
tipo:
~# /sbin/route add default gw 192.168.1.1 netmask 0.0.0.0 metric 1
Mi raccomando! sostituite a 192.168.1.1 l'indirizzo di rete interna del vostro Gateway
Linux/MASQ.
In tal modo, quando digiterete il comando route senza parametri noterete che nella tabella di
routing ci sara' una nuova riga del tipo:
Dest.         Gateway       Genmask    Flags  Metric  Ref  Use  Iface
  ...            ...          ...       ...     ..     ..   ..    ..
default     192.168.1.1     0.0.0.0     UG      0      0    0    eth0
IL DNS! non vi dimenticate del DNS!
In Linux si deve editare il file resolv.conf come segue:
search 
vostro.dominio.it
nameserver 151.1.1.1
Sostituite al posto di 151.1.1.1 (che e' comunque un DNS) il DNS del vostro provider.
Passiamo a windows
A dire il vero, io W98 non ce l'ho piu', quindi vado a ammoria.
D'altro canto tra NT e W98 non c'e' poi tanta differenza.
dovete selezionare
Pannello di Controllo --> Rete.
Qui selezionate TCP/IP->(scheda ethernet)
Qui selezionate il TAB gateway. Inserite come gateway nell'apposito campo l'IP del gateway MASQ
(nell' esempio 192.168.1.1) e cliccate su Aggiungi.
Selezionare poi il tab DNS (o nameserver). Inserire nel campo apposito il nameserver del
voastro providere e cliccare su aggiungi.
In NT e' un po' diverso:
( Certo che se siete Utenti NT e non sapete settare il GW... ehehe, come sono cattivo! : ) )
Nelle proprieta' della rete selezionate il Tab Protocols (NT in inglese, ovviamente)
Scegliete TCP/IP
Nella finestra che esce, selezionate l'a scheda di rete che volete impostare (in genere ce ne
sta una sola, quindi ingorate quel che ho appena detto)
nel campo Gateway inserite il solito IP del gateway MASQ (nell' esempio 192.168.1.1)
Selezionare il TAB DNS ed inserire il DNS del proprio provider.
Windows 2000:
Le cose sono praticamente identiche a NT:
Adate in proprieta' della rete.
scegliere l'icona della connessione alla rete locale (del tipo "Connessione alla rete locale
(LAN)" )
visualizzatene le prorpieta'.
Nelle proprieta' della connessione selezionate la voce TCP/IP
nel campo Gateway inserite il solito IP del gateway MASQ (nell' esempio 192.168.1.1)
nel campo DNS inserire il DNS del vostro provider.
VOGLIO approfittare per ripetere che si suppone che la LAN vi funzioni gia' correttamente prima
di cominciare.
--
Ciauz!
   midorichan (
pai...@paipai.net
)
////////////////////////////////////
     ... Erroneus Error. Nothing Wrong.