> Ottimo, grazie... si potrebbe aggiungere anche qualche
> dritta e/o esempio pratico: per non rimanere sempre sul
> 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 che i client NON vanno modificati/configurati appositamente, come accade coi proxy o Socks) un SINGOLO accesso ad internet.
Il MASQ 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 con 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. Tra un po' sara' disponibile una versione HTML coi link.

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 Win2K, 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 fa altro che tradurre i nostri comandi (che sono umanamente comprensibili) 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 suppongo che gli argomenti seguenti saranno per voi scontati.

ipchains e' il programma ufficiale scritto da (mannaggia alla mia memoria!!!) colui che gestisce la parte del Kernel Linux che si occupa 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 il MASQ puro e semplice e non e' in grado di gestire il Port Forwarding.
Per configurare il Port Forwarding bisogna procurarsi il programma ipmasqadm.

Per quanto riguarda il kernel, per far funzionare il MASQUERADE dovete compilarlo con le seguenti opzioni attive:

* 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, ma sono il primo a non segnarmeli... :)
Comunque, a parte il fatto che in molte distribuzioni tali programmi  sono presenti, comunque credo che chiunque sia in grado di 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.
L'unico programma che serve per il momento e' ipchains.
ipchains si chiama cosi' perche' permette di definire delle cosiddette "catene di firewall". A dire il vero il termine non mi va proprio a genio, quindi lo usero' poco (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 predefiniti sono input, forward, output (notare l'ordine in cui sono scritti)


Per far funzionare il firewalling bisogna attivare l' ip_forwarding del kernel.
In alcune versioni dek KErnel ed in alcune distribuzioni per motivi di sicurezza il forward e' disabilitato.
per abilitarlo si deve usare il comando:
~# echo "1" > /proc/sys/net/ipv4/ip_forward


(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.

Delle regole di input stabiliscono quali pacchetti debbano essere accettati. In genere non vogliamo che accadano cose come lo spoofing e l'attacco su servizzi fruibili solo dagli utenti della rete interna.
NOTA: l'unico spoofing da cui ci si puo' difendere e' soltanto quello per cui l'attacker usa un indirizzo del nostro localnetwork come sorgente (cioe' se ci arrivano dall'esterno dei pacchetti che affermano di provenire dall'interno della rete)

NOTA IMPORTANTE! L'ordine con cui vengono inserite le regole in un gruppo e' importantissimo.
Infatti esse vengono valutate dal Kernel esattamente nell'ordine in cui sono state inserite (fatta salva la regola di default, che in quanto tale e' valutata per ultima)

innanzitutto, la regola di default e' rifiutare ogni cosa.
~# ipchains -P input REJECT
-P input indica il nome della chain cui aggiungere la regola. con REJECT stiamo imponendo di rifiutare per default tutto il traffico.

Dopo di che dobbiamo stabilire che tutto il traffico della rete interna diretto verso qualsiasi destinazione, deve essere accettato.
Col comando che segue voglio imporre che tutto 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 viene applicata 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. (Si tratta di una forma di lo spoofing)
~# ipchains -A input -i ppp0 -s 192.168.0.0/24 -d 0.0.0.0/0\ 
 -l -j REJECT


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 alla "chiusura di certe porte" fastidiose.
Come esempio vi porto la chiusura delle porte del netbios, servizio che e' decisamente meglio 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. Con i precedenti due comandi si sono chiusi sia UDP che TCP (Netbios puo' usarli tutti e due)
-l dice di loggare l'accaduto (in syslog)
i numeri 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.
NOTARE DENY al posto di REJECT: si tratta di una forma di rifiuto piu' dura, in quanto il Kernel non genera dei pacchetti di risposta ICMP per avvisare l'host remoto.

Ovviamente conviene chiudere esplicitamente TUTTE le porte dei servizzi attivi che non devono essere usati all'esterno della rete, anche se considerati sicuti, perche' NON SI SA MAI!


La regola seguente stabilisce che ogni pacchetto proveniente da Internet (ppp0) e destinato al nostro IP pubblico (quello assegnato dal provider) deve essere accettato. xxx.xxx.xxx.xxx/32 rappresenta tale indirizzo IP.
Essa va messa DOPO aver chiuso le porte tcp/udp, perche' come detto in precedenza ipchains guarda le regole nello stesso ordine in cui si sono inserite e si ferma appena trova un regola che corrisponde al pacchetto ricevuto.
~# ipchains -A input -i ppp0 -s 0.0.0.0/0 -d xxx.xxx.xxx.xxx/32\
 -j ACCEPT



(KEYWORD = FW1.2)
Passiamo ora a elencare le regole di FORWARDING (cioe' come trattare i pacchetti in transito)
Il MASQUERADE viene configurato in questa sezione.

innanzitutto si impone come regola di default della chain di non forwardare niente che non sia esplicitamente permesso.
~# ipchains -P forward DENY

Dopo di che si stabilisce che i soli pacchetti diretti all'esterno e provenienti da una nostra macchina debbano essere MASQUERATI e forwardati.
~# 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 impone il MASQUERADE.


ALLA FINE dell'articolo ho inserito tutti i listati degli 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 grado 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 del Kernel che rendono il MASQUERADE compatibile con alcuni protocolli NON "NAT Friendly". Alcuni sono stati messi nel sorgente del kernel, altri invece sono da prelevare e compilare a parte.

i moduli del masquerade li trovate in 
/lib/modules/2.2.xx/ipv4/

io posseggo:
ip_masq_cuseeme.o
ip_masq_icq.o     (scaricato a parte)
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 davvero!)
Un modulo da compilare a parte ma di sicuro interesse si chiama UDPloose (semore che la memoria non mi inganni) e serve per far funzionare alcuni giochi multiplayer NAT friendly.


(KEYWORD = PORTFW1)
ADESSO passiamo ai SERVIZZI IN INGRESSO, per i quali serve ipmasqadm.
tale programma si compone di vari moduli. quello che ci server e' portfw. Gli altri possono tornare utili per rendere compatibli alcuni protocolli "NAT friendly" (ad es.: ICQ puo' essere fatto funzionare in diversi modi, non solamente col modulo apposito)


Ritorniamo al Port Forwarding.
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 su una porta diversa.

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.



(KEYWORD = SCRIPT1.1)

Ecco a voi i miei script. Per l'occasione li ho commentati un po'.


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 mi e' molto utile.
Questo script non controlla se la connessione e' attiva: si limita a tentare di ucciderla e ripristinarla.
Nel mio caso il controllo 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

 
# 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

# 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 

# questo comando rifiuta 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 imposta il Port Forwarding.
Nella mia rete molti servizzi vengono svolti da una macchina
della rete privata.
Ricordatevi che 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
Probabilmente esiste un programma piu' intelligente di pptp,
che si accorga magari da solo che la connessione e' caduta
e la ripristini.


#!/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.
Dunque, le operazioni che seguono si devono effettuare su qualsiasi tipo di rete dotata di gateway.
Il NAT e' un sistema quasi del tutto trasparente ai client, il quali quindi non necessitano di essere configurati per L'uso di PROXY.
D'altro canto, installare dei Proxy con Cache per il WEB e FTP puo' essere una buona idea per diminuire un po' il traffico.


Il gateway si setta in maniera diversa sui vari sistemi operativi.
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.


QUALSIASI commento e' gradito.


--
Ciauz!
   midorichan (paipai_rimuovi_questo@tiscali.it)

////////////////////////////////////
     ... Erroneus Error. Nothing Wrong.