Newsgroup: it.comp.os.linux.sys
Titolo: E' possibile fare cio' con la NAT di linux ??

Ho (meglio dire abbiamo) un problema al lavoro.
La rete interna 192.168.x.y accede ad altre reti private (non interne)
passando da un firewall (per win) che opera l'ip masquering.
Pero' abbiamo un' applicazione (sulle altre reti, quelle non interne)
che identifica le macchine in base alla coppia IP pc client:Porta
sorgente.
Tale applicazione server deve necessariamente essere in grado di
riconoscere quante volte la stessa macchina client si è collegata.
Dato che con il NAT operato dal firewall l'IP è sempre costante,
mentre la porta cambia sempre, cio' non è possibile e quando la stessa
macchina client si collega + volte (nell'arco della giornata) viene
sempre conteggiata come nuova macchina.
In pratica la soluzione che ci servirebbe è la seguente (è solo un
esempio):
Se l'ip 192.168.x.z :porta 1000 si collega al server (sull'altra rete)
la NAT deve tradurlo in IP firewall : porta 30000
Se è 192.168.x.y: porta 1000 allora deve diventare IP FW: porta 31000.
........
E queste mappature devono essere sempre uguali, ossia tutte le
richieste che arrivano dalla porta 1000 di una macchina devono essere
mascherate sempre tramite la stessa porta del firewall (assegnata a
quella macchina).
Con il ns firewall è possibile creare delle Nat+Pat statiche MA solo
sulla destinazione e non sulla sorgente.
Ossia possiamo dirgli che tutte le richieste verso IP Pippo: Porta
Pluto vanno dirottate verso IP Paperino: Porta QuiQuoQua MA NON fargli
fare: Cio' che parte da IP Topolino: Porta EtaBeta va mascherato in IP
GambaDiLegno: Porta BandaBassotti
Quindi la domanda di questo post è:
E' possibile implementarla con il firewall (ipchains+ altro) di linux?
E se si, è possibile creare una regola di traduzione parametrizzata?
Mi spiego meglio, invece di scrivere una regola di mascheramento per
ogni macchina della rete (e porta sorgente), scrivere una regola unica
che calcola in automatico (ma fornendo, nel tempo, sempre gli stessi
risultati). Un qualcosa che in un ipotetico linguaggio di
programmazione ad alto livello sarebbe esprimibile in:
SE 192.168.X.Y è l' IP sorgente e Z è la porta sorgente
ALLORA la connessione viene mascherata come proveniente da
200.200.200.200 porta W, con W=Base+Y+Z
Dove 200.000.200.200 è l'ipotetico indirizzo ip del firewall linux e
base è un offset che indica da che valore partono le porte riservate
per il NAT (esempio Base= 40000).
Ciao
Fabrizio

 Se è 192.168.x.y: porta 1000 allora deve diventare IP FW: porta 31000.
Giusto per capire meglio il problema, quel "porta 1000" si riferisce
alla porta sorgente o a quella di destinazione?
Ciao,
-- 
Andrea Glorioso		sama(at)aglorioso(dot)com
			Padua, Italy


SORGENTE.
Faccio un esempio (valori inventati):
Sorgenti:
Client 192.168.2.10 porta 1000
Client 192.168.2.15 porta 1000
Client 192.168.2.20 porta 1000
La porta sorgente del sw client è sempre constante, a meno che non si
lancino + esecuzioni  contemporanee (cosa possibile) del sw.
In questo caso diviene porta 1000 (prima istanza), porta 1001
(seconda), ....
Destinazione:
Server 192.168.45.10 porta 3500
Senza la NAT del firewall (che pero' non si puo' eliminare per altri
motivi) la connessione funziona perfettamente ed il sw sul server è in
grado di fare le statistiche di connessione (ossia quante volte la
stessa macchina si è collegata nella giornata)
Con la NAT abilitata la connessione funziona lo stesso (e ci
mancherebbe), ma vanno a pallino tutte le statistiche, perchè il
server vede qualcosa tipo:
200.200.200.199 porta 23400 al posto di 192.168.2.10 porta 1000
200.200.200.199 porta 23450 al posto di 192.168.2.15 porta 1000
200.200.200.199 porta 23500 al posto di 192.168.2.20 porta 1000
E la cosa sarebbe accettabilissima se la traduzione fosse sempre
costante, ma invece al successivo collegamento il server vedrà:
200.200.200.199 porta 23430 al posto di 192.168.2.10 porta 1000
200.200.200.199 porta 23440 al posto di 192.168.2.15 porta 1000
200.200.200.199 porta 23590 al posto di 192.168.2.20 porta 1000
Con il risultato che invece di catalogare l'accesso avvenuto 2 volte
di 3 Client, verrà registrato l'accesso singolo di 6 client (Cosa non
vera).
Ci servirebbe quindi un firewall che permetta di mappare sempre nello
stesso modo il mascheramento delle richieste provenienti dallo stesso
sw client (ossia porta sorgente).
Ciao.
Fabrizio

 >alla porta sorgente o a quella di destinazione?
Non ho capito bene quello che vuoi fare ma ti posso dire cosa si puo' fare
con ipmasqadm e ipchains (fantastici! n.d.r.):
#---------------------------------------------
# indipendentemente dal firewal che ho
# impostato (tutto chiuso, tutto aperto, misto),
#      apro per l'IP MyExtIp la porta 80
ipchains -I input -p tcp -y -d $MyExtIP/32 80 -j ACCEPT
#Permetto ai pacchetti provenienti dal mio IP interno
# di transitare vs esterno
ipchains -I forward -p tcp -s $MyIntIP/32 80 -d 0/0 -j MASQ
# Indico che i pacchetti in arrivo sulla porta 80 per MyExtIp
#       vengano inviati a MyIntIp sulla porta 1080
ipmasqadm portfw -a -P tcp -L $MyExtIP 80 -R $MyIntIP 80 -p 10
#---------------------------------------------
Questo in poche parole, vedi tu come adattarlo (se possibile) alle tue
esigenze, in alternativa il tutto si potrebbe anche fare con :
#---------------------------------------------
#Apro e marko (-m 1)
ipchains -I input -p tcp -y -d $MyExtIP/32 80 -m 1
#forwardo IPa/porta interna vs esterno
ipchains -I forward -p tcp -s $MyIntIPa/32 80 -d 0/0 -j MASQ
#forwardo da fuori (-m 1) a dentro IPa/altraporta con priorita 10
ipmasqadm mfw -A -m 1 -r $MyIntIPa 1080 -p 10
#forwardo IPa/porta interna vs esterno
ipchains -I forward -p tcp -s $MyIntIPb/32 80 -d 0/0 -j MASQ
#forwardo da fuori (-m 1) a dentro IPb/altraporta con priorita 20
ipmasqadm mfw -A -m 1 -r $MyIntIPb 1081 -p 20
#---------------------------------------------
Notare il marker -m 1 e il flag di priorita' -p 10 (-p 20)
Se pensi che tutto questo possa servirti, allora possiamo poi approfondire
il tutto, tieni conto che non e' da molto che mastico ste' cose e potrebbero
esserci delle imperfezioni, si accettano critiche / consigli / suggerimenti.
Facci sapere.
Ciao
Dario Lesca

Dario Lesca


 


Scusa il ritardo ma il tuo post non mi è mai 
arrivato sul server 
news.tin.it
.


 


Me ne sono accorto solo per caso leggendo il gruppo 
tramite 
mailgate.org
.
Ho anche postato una prima risposta (DA NON TENERE + IN 
CONSIDERAZIONE) tramite dejanews ieri 
ma questa non sembra essere mai 
arrivata (meglio visto che ora ne cambio il contenuto).


 


Allora riprendendo il thread:


 


Io avrei bisogno di una NAT a livello di ip 
sorgente (quella che nel kernel 2.4 chiamano SNAT).


 


La soluzione che chiedevo nel post originale penso 
sia fattibile nel seguente modo:


 


Dati iniziali (inventati, ma in linea con la 
realtà):


 


210.210.210.210 ip esterno macchina 
linux
192.168.0.100 ip interno macchina linux


 


192.168.x.y indirizzi dei server (con x <> 
0)


 


192.168.0.20 - 192.168.0.35 ip delle macchine su 
cui gira il sw client
2040-2045 porte usate dal sw client (2040 se un solo 
client per macchina, 2040-2041 se 2,....)


 


La mia soluzione consiste in:


 


1) Dirottare verso la macchina linux 
(192.168.0.100) tutto il traffico che ha per destinazione il
servizio server 
richiesto.


 


2) Far forwardare verso il server da quest'ultima 
mascherando i pacchetti e mappando ogni singola
combinazione di IP 
interno/porta su una porta del suo IP esterno.
Ossia un portforward del 
tipo:


 


192.168.0.20:2040
 su 

210.210.210.210:40000
192.168.0.20:2041
 su 

210.210.210.210:40001
192.168.0.20:2042
 su 

210.210.210.210:40002
192.168.0.20:2043
 su 

210.210.210.210:40003
192.168.0.20:2044
 su 

210.210.210.210:40004
192.168.0.20:2045
 su 
210.210.210.210:40005


 


192.168.0.21:2040
 su 

210.210.210.210:40006
192.168.0.21:2041
 su 

210.210.210.210:40007
192.168.0.21:2042
 su 

210.210.210.210:40008
192.168.0.21:2043
 su 

210.210.210.210:40009
192.168.0.21:2044
 su 

210.210.210.210:40010
192.168.0.21:2045
 su 
210.210.210.210:40011


 


192.168.0.22:2040
 su 

210.210.210.210:40012
..........


 


Cosi' ogni richiesta fatta dal primo client sulla 
macchina 192.168.0.21 sarà sempre visto arrivare dal server come
proveniente 
da 
210.210.210.210:40006
.


 


Ora rimane il problema di implementare il punto 2) 
con linux (il primo lo facciamo fare ad una rules del firewall x 
Win).


 


Con la tavola di routing dico alla macchina linux 
che per raggiungere tutto quello che non sta nella
sottorete 192.168.0.x ma 
che è pure sempre nella classe C (192.168.y.x) deve usare l'altra scheda di rete 

(e quindi l'ip esterno). E fin qui sono a posto.


 


Poi devo fare le regole di forward. Prendendo il 
tuo codice penso che siano del tipo :


 


#Chiudo tutto
ipchains -P forward 
DENY


 


#Apro e marko ogni singola porta che mi 
serve
ipchains -I input -p tcp -y -d 
210.210.210.210/32
 40000 -m 
1
ipchains -I input -p tcp -y -d 
210.210.210.210/32
 40001 -m 2
ipchains -I 
input -p tcp -y -d 
210.210.210.210/32
 40002 -m 3
ipchains -I input -p tcp -y 
-d 
210.210.210.210/32
 40003 -m 4
ipchains -I input -p tcp -y -d 

210.210.210.210/32
 40004 -m 5
ipchains -I input -p tcp -y -d 

210.210.210.210/32
 40005 -m 6
ipchains -I input -p tcp -y -d 

210.210.210.210/32
 40006 -m 7
ipchains -I input -p tcp -y -d 

210.210.210.210/32
 40007 -m 
8
......................................


 


#forwardo IPa/porta interna vs esterno
ipchains 
-I forward -p tcp -s 
192.168.0.20/32
 2040 -d 0/0 -j MASQ
ipchains -I forward 
-p tcp -s 
192.168.0.20/32
 2041 -d 0/0 -j MASQ
ipchains -I forward -p tcp -s 

192.168.0.20/32
 2042 -d 0/0 -j MASQ
ipchains -I forward -p tcp -s 

192.168.0.20/32
 2043 -d 0/0 -j MASQ
ipchains -I forward -p tcp -s 

192.168.0.20/32
 2044 -d 0/0 -j MASQ
ipchains -I forward -p tcp -s 

192.168.0.20/32
 2045 -d 0/0 -j MASQ
ipchains -I forward -p tcp -s 

192.168.0.21/32
 2040 -d 0/0 -j MASQ
ipchains -I forward -p tcp -s 

192.168.0.22/32
 2041 -d 0/0 -j 
MASQ
......................................


 


#forwardo da fuori a dentro IPa/altraporta con 
priorita 10
ipmasqadm mfw -A -m 1 -r 192.168.0.20 2040 -p 10
ipmasqadm mfw 
-A -m 2 -r 192.168.0.20 2041 -p 10
ipmasqadm mfw -A -m 3 -r 192.168.0.20 2042 
-p 10
ipmasqadm mfw -A -m 4 -r 192.168.0.20 2043 -p 10
ipmasqadm mfw -A -m 
5 -r 192.168.0.20 2044 -p 10
ipmasqadm mfw -A -m 6 -r 192.168.0.20 2045 -p 
10
ipmasqadm mfw -A -m 7 -r 192.168.0.21 2040 -p 10
ipmasqadm mfw -A -m 8 
-r 192.168.0.21 2041 -p 
10
......................................


 


IO non conosco ipchains + ipmasqadm e le regole 
le ho scritte solo per logica partendo dalle tue, quindi
è probabile che 
abbia scritto vaccate.
Inoltre cosi' scritte non sono sicuro che facciano 
cio' che voglio io.


 


Riassumo cio' che mi serve:


 


a) Dato che è il client che chiama il server, a me 
ovviamente serve il collegamento da interno a esterno.
Quando 

192.168.0.20:2043
 vuole uscire (con destinazione il server) DEVE uscire come 

210.210.210.210:40003
.
Sempre E SOLO cosi'. O esce cosi' o NON DEVE 
uscire.
Non posso accettare che 
192.168.0.20:2043
 venga forwardato con l'IP 
masquarading standard, ossia usando una 
porta, presa a caso, tra quelle 
libere riservate (che se non sbaglio sotto linux sono 61000-64999).


 


b) Sarebbe bello se le porte che voglio usare per 
la mappatura rimangono chiuse finchè non servono.
Ed in quel caso, aperte, 
usate e dopo un timeout di inutilizzo richiuse.
Vorrei evitare di tenere 
sempre aperte circa 600 porte (nell'ipotesi che mappi 6 client per macchina e 
100 macchine).


 


Ciao.
Fabrizio