A 192.168.8.17 10.0.0.33 RETE p-p: 10.0.0.

32
B 192.168.8.18 10.0.0.34
C 192.168.8.3 10.0.0.5 RETE p-p: 10.0.0.4
D 192.168.8.4 10.0.0.6

ESERCITAZIONE 1

Parte 1: IP FORWARDING
C
A si stacca dalla rete 192.168.8.0:
A: sudo ifconfig eth1 down A B

B deve abilitare l’IP forwarding

B: sudo sysctl –w net.ipv4.ip_forward=1

B deve diventare il default gateway di A in modo da reindirizzare i pacchetti verso C. A tal fine,
l’host A imposta una nuova entry nella propria tabella.
A: sudo route add –net 192.168.8.0 netmask 255.255.255.0 gw 10.0.0.34
dev eth0
–net 192.168.8.0
vogliamo raggiungere la rete (net) 192.168.8.0
gw 10.0.0.34
il gateway (B) dev’essere raggiunto con la rete punto-punto
dev eth0
la rete punto-punto è appannaggio dell’interfaccia eth0

C vuole rispondere a 10.0.0.33 ma non sa come trovarlo, quindi dovrà trovare il modo di spedirlo
a B per potervi accedere.
C: sudo route add –host 10.0.0.33 gw 192.168.8.18 dev eth1
–host 10.0.0.33
vogliamo raggiungere l’host 10.0.0.33
gw 192.168.8.18
il gateway è B
dev eth1
questa volta dobbiamo affidarci alla eth1

Parte 2: IP forwarding fra 2 (intere) reti IP

A B C D

C abilita il forwarding perché dovrà comunicare con D e instradargli i pacchetti verso A e B.

C: sudo sysctl –w net.ipv4.ip_forward=1

D manda giù eth1 (è isolato rispetto alla rete “grande”) e aggiunge due entry nella route table,
l’una per poter pingare B e l’altra per raggiungere A.
D: sudo ifconfig eth1 down
D: sudo route add –net 192.168.8.0 netmask 255.255.255.0 gw 10.0.0.5 dev
eth0
–net 192.168.8.0
per raggiungere un qualsiasi PC della rete grande (ad esempio B)
gw 10.0.0.5
D vuole usare C
dev eth0
e per farlo usa l’interfaccia eth0 (collegamento p-p)
D: sudo route add –net 10.0.0.32 netmask 255.255.255.252 gw 10.0.0.5 dev
eth0
–net 10.0.0.32
per raggiungere un qualsiasi PC della rete piccola (B, oppure A)
gw 10.0.0.5
D vuole usare C
dev eth0
e per farlo usa l’interfaccia eth0 (collegamento p-p)

B trova il modo di collegarsi a D (o, meglio, alla rete di D) utilizzando C come gateway
B: sudo route add –net 10.0.0.4 gw 192.168.8.3 dev eth1
–net 10.0.0.4
per raggiungere un qualsiasi PC della rete piccola (C, oppure D)
gw 192.168.8.3
B vuole usare C
dev eth0
e per farlo usa l’interfaccia eth0 (collegamento p-p)

Ora D può essere potenzialmente in connessione con qualsiasi PC, tramite C.

A mantiene il collegamento verso la rete globale (e quindi può contattare C)

(A: sudo route add –net 192.168.8.0 netmask 255.255.255.0 gw 10.0.0.34
dev eth0)
ma in più deve poter contattare D:
A: sudo route add –net 10.0.0.4 netmask 255.255.255.252 gw 10.0.0.34 dev
eth0
–net 10.0.0.4
A vuole raggiungere la rete (net) 10.0.0.4
gw 10.0.0.34
il gateway (B) dev’essere raggiunto con la rete punto-punto
dev eth0
che è appannaggio dell’interfaccia eth0

Ora la connettività è completa.

Parte 3: proxy-ARP

C vuole sapere il MAC di A con l’illusione che quest’ultimo faccia parte della sua rete (altrimenti
non si potrebbe fare l’ARP). In realtà è B, punto di riferimento per l’instradamento, che darà il
MAC a C cosicché, se quest’ultimo vuole parlare con A, passerà attraverso B!

A B

B deve abilitare l’IP forwarding

B: sudo sysctl –w net.ipv4.ip_forward=1
B deve sostituire fare aliasing perché si richiede di contattarlo presso le 192.168.8.x/30 (reti
piccoline di 2 PC sulle 192.168.8.x).
B: sudo ifconfig eth0 192.168.8.201 netmask 255.255.255.252 broadcast
192.168.8.203
eth0
il nuovo indirizzo fa riferimento all’interfaccia eth0
192.168.8.201
ecco il nuovo indirizzo di B
broadcast 192.168.8.203
ecco qual è l’indirizzo di broadcast della nuova rete inventata
apposta per B

L’host A deve fare lo stesso e darsi il .202, ovvero l’altro indirizzo disponibile della rete piccolina:
A: sudo ifconfig eth0 192.168.8.202 netmask 255.255.255.252 broadcast
192.168.8.203
eth0
il nuovo indirizzo fa riferimento all’interfaccia eth0
192.168.8.202
ecco il nuovo indirizzo di A
broadcast 192.168.8.203
indirizzo di broadcast della nuova rete “inventata” per A e B

In più, A butta giù la eth1, perché non deve essere direttamente in collegamento con C:
A: sudo ifconfig eth1 down

Dopodiché, B aggiunge una voce di proxy-ARP:

B: sudo arp –I eth1 –s 192.168.8.202 –D eth1 pub
arp
voce di proxy-ARP
–I eth1
eth1 è l’interfaccia da cui arrivano le richieste
–s 192.168.8.202
l’indirizzo richiesto da chi vuole effettuare il proxy-arp (B risponderà
col suo MAC quando qualcuno gli chiederà di 192.168.8.202)
–D eth1
eth1 è l’interfaccia su cui rispondere alle richieste
pub
rende la cosa “pubblica”
Con questa stringa B risponde con il suo MAC a chi chiede il MAC di A.

C a questo punto fa il suo dovere:

C: arping –I eth1 192.168.8.202

E tutto funziona!
 A 192.168.8.17 10.0.0.33 RETE p-p: 10.0.0.32
B 192.168.8.18 10.0.0.34
C 192.168.8.3 10.0.0.5 RETE p-p: 10.0.0.4
D 192.168.8.4 10.0.0.6

ESERCITAZIONE 2

Punto 1: visualizzare il contenuto della tabella filter di IPTABLES

sudo iptables -L

Punto 2. Impostare IPTABLES per scartare (DROP) i pacchetti ICMP in ingresso e verificarne il
comportamento.

sudo iptables –I INPUT 1 –p icmp –j DROP

–I INPUT
inserisci (I) per la chain riguardante i pacchetti in ingresso
1
come prima regola
–p icmp
per quanto riguarda il protocollo ICMP
–j DROP
rifiuta (drop, senza notifica) tutti i pacchetti

Punto 3. Impostare IPTABLES per rifiutare (REJECT) i pacchetti ICMP in ingresso e verificarne
il comportamento

sudo iptables –I INPUT 1 –p icmp –j REJECT

–I INPUT
inserisci (I) per la chain riguardante i pacchetti in ingresso
1
come prima regola
–p icmp
per quanto riguarda il protocollo ICMP
–j REJECT
rifiuta (reject, con notifica) tutti i pacchetti

Oppure, se si vuole sostituire la politica precedente:

sudo iptables –R INPUT 1 –p icmp –j REJECT

Punto 4. Impostare a DROP la policy di default per i pacchetti in transito e abilitare l’inoltro del
traffico ssh. Verificarne il comportamento.

sudo iptables –P FORWARD DROP

–P
imposta come politica predefinita
FORWARD
per i pacchetti in transito
DROP
il drop

Eccezione per il traffico SSH (destinato alla porta 22):

sudo iptables –I FORWARD -A –p tcp –-dport 22 –j ACCEPT
–I FORWARD
inserisci una nuova regola per la chain di forward
‒A
e metti questa regola in coda
–p tcp
questa regola riguarda il protocollo TCP
--dport 22
per i pacchetti diretti alla porta 22 (SSH)
–j ACCEPT
accetta questo traffico
Per impostare regime stateful:
sudo iptables –I FORWARD –m state
–I FORWARD

–m state --state ESTABLISHED

-j ACCEPT

-–state ESTABLISHED -j ACCEPT
inserisci una nuova regola per la chain di forward
e imponi lo stateful packet filter
per i pacchetti accettati

Impostiamo l’IP forwarding per poter fare la prova:

B: sudo sysctl –w net.ipv4.ip_forward=1

Ora C può passare attraverso B per fare l’SSH su A (dopo aver modificato la tabella di routing, v.
esercitazioni precedenti):
C: ssh nomeutente@192.168.8.17

Punto 5. Impostare ad ACCEPT la policy di default per i pacchetti in transito e bloccare l’inoltro
di tutti i pacchetti TCP dalla rete 192.168.8.0/24 alla 10.0.0.x/30 tranne quelli diretti alla porta 80.
Verificarne il comportamento.

sudo iptables –A FORWARD –s 192.168.8.0/24 –d 10.0.0.32/30 –p tcp --

dport ! 80 –j DROP
–A FORWARD
inserisci una regola in coda alla chain di forward
–s 192.168.8.0/24
per tutti i pacchetti che giungono dalla rete 192.168.8.0
–d 10.0.0.32/30
e che sono diretti alla rete 10.0.0.32
–p tcp
aventi protocollo TCP
--dport ! 80
e diretti a tutte le porte tranne l’80
–j DROP
imposta il drop

Per provare:
telnet 10.0.0.5 80

6. Visualizzare il contenuto della tabella nat di IPTABLES

sudo iptables –t nat -L

7. Impostare IPTABLES per realizzare un gateway NAT utilizzando un indirizzo aggiuntivo

rispetto a quello già assegnato all’interfaccia esterna.

B fa aliasing per poter dare un indirizzo ad A:

B: sudo ifconfig eth1: 192.168.8.202
eth1:
imposta sull’interfaccia eth1
192.168.8.202
l’indirizzo 192.168.8.202

Aggiungiamo una regola per poter dare ad A l’indirizzo:

B: sudo iptables –t nat –A postrouting -s 10.0.0.33 -j SNAT –to-source
192.168.8.202
–t nat
specifica una regola per il NAT
–A postrouting
per quanto riguarda la chain postrouting (da dentro a fuori la rete)
-s 10.0.0.33
e per i pacchetti che arrivano da 10.0.0.33
 -j SNAT--to-source
fai source-NAT (ovvero: sostituisci l’indirizzo a un PC
“mascherato” dentro una rete privata e che vuole comunicare
verso l’esterno)
192.168.8.202
e assegna l’indirizzo 192.168.8.202

A questo punto A può fare il ping verso l’esterno: con wireshark si può verificare che la eth1 di B
“comunica” fra il .202 e il .5 (cioè C) e viceversa, mentre la eth0 fa da intermediario fra la .33 (di A)
e il .5 (sempre C).

8. Impostare IPTABLES per realizzare il port forwarding verso la porta ssh di un host sulla rete
interna.

A B

B riceve qualcosa dalla rete esterna (tipo da C) sulla porta 22, e lo interpreta inoltrandolo tutto
quanto verso A (che nel frattempo ha staccato eth1).
B: sudo iptables –t nat –A PREROUTING –d 192.168.8.18 –p tcp --dport 22
–j DNAT -–to-destination 10.0.0.33
-t nat
specifica una regola per il NAT
–A PREROUTING
per quanto riguarda la chain prerouting (da fuori a dentro
la rete)
–d 192.168.8.18
e per tutti i pacchetti che vanno verso 192.168.8.18 (cioè B)
–p tcp
con protocollo TCP
--dport 22
e sono diretti alla porta 22 (sempre di B)
–j DNAT --to-destination
fai destination-NAT (ovvero, ciò che recapiti alla porta 22
va consegnato ad un PC che sta nella rete privata)
10.0.0.33
il PC al quale devi consegnare tutto è A (10.0.0.33)

Se C vuole effettuare l’SSH su A (con B che fa il NAT):

C: ssh [nome utente A]@192.168.8.18

Punto 9

A 192.168.8.17 10.0.0.33 RETE p-p: 10.0.0.32

B 192.168.8.18 10.0.0.34
C 192.168.8.3 10.0.0.5 RETE p-p: 10.0.0.4
D 192.168.8.4 10.0.0.6

Realizzare la seguente configurazione:

• B esegue NAT (considerare la rete 10.0.0.x/30 come privata)
• C è un semplice gateway provvisto di firewall che
o permette l’inoltro di traffico ICMP bidirezionale
o permette l’inoltro di traffico HTTP, HTTPS, SSH, DNS solo da client appartenenti
alla rete 10.0.0.y/30
 o scarta tutto il resto
• deve essere possibile connettersi da D e C via SSH a A e B contemporaneamente (4
connessioni contemporanee)
Per le verifiche usare, oltre a ping e SSH:
• telnet <indirizzo> <num_porta> per aprire connessioni TCP
• uplog –f –p <num_porta> <indirizzo> per generare pacchetti UDP

A modifica il default gateway e imposta B per andare ovunque.

A: sudo route add default gw 10.0.0.34
A disabilita eth1, tanto non gli serve.
A: sudo ifconfig eth1 down

D fa la stessa cosa e imposta come C default gateway.

D: sudo ifconfig eth1 down
D: sudo route add default gw 10.0.0.35

B e C abilitano il forwarding.

B aggiunge nella tabella di routing:

B: sudo route add –net 10.0.0.4 netmask 255.255.255.252 gw 192.168.8.3
dev eth1
Ovvero: B (oppure A, attraverso B) è costretto ad utilizzare C per raggiungere la rete privata di C e
D.

Facciamo la stessa cosa ma anche nel senso inverso

C: sudo route add –net 10.0.0.32 netmask 255.255.255.252 gw 192.168.8.18
dev eth1
Ovvero: C (oppure D, attraverso C) è costretto ad utilizzare B per raggiungere la rete private di A
e B.

A questo punto abbiamo risolto il problema connettività e i 4 PC possono comunicare come

indicato in figura. Concentriamoci ora sul NAT.
B deve crearsi un indirizzo nuovo con l’alias
B: sudo ifconfig eth1:0 192.168.8.100
Dopodiché si devono specificare le istruzioni per il NAT, in modo da sapere come si sostituiscono
gli indirizzi:
B: sudo iptables –t nat –A POSTROUTING –s 10.0.0.33 –j SNAT --to-source
192.168.8.100
–t nat
specifica una regola per il NAT
–A postrouting
per quanto riguarda la chain postrouting (da dentro a fuori la rete)
-s 10.0.0.33
e per i pacchetti che arrivano da 10.0.0.33
-j SNAT--to-source
fai source-NAT (ovvero: sostituisci l’indirizzo a un PC
“mascherato” dentro una rete privata e che vuole comunicare
verso l’esterno)
192.168.8.100
e assegna l’indirizzo 192.168.8. 100
B: sudo iptables –t nat –A PREROUTING –d 192.168.8.100 –j DNAT --to-
destination 10.0.0.33
-t nat
specifica una regola per il NAT
–A PREROUTING
per quanto riguarda la chain prerouting (da fuori a dentro
la rete)
–d 192.168.8.100
e per tutti i pacchetti che vengono mandati a 192.168.8.100
–j DNAT --to-destination
fai destination-NAT
10.0.0.33
il PC al quale devi consegnare tutto è A (10.0.0.33)

C è un semplice gateway provvisto di firewall. Di default imposta una policy drop:

C: sudo iptables -P FORWARD DROP
Fatto questo, C imposta le eccezioni:
• (ICMP bidirezionale)
C: sudo iptables –A FORWARD –p icmp –j ACCEPT
• (regola per HTTP provenienti dalla rete di C e D)
C: sudo iptables –A FORWARD -s 10.0.0.4/30 –p tcp --dport 80 -j ACCEPT
• (regola per l’SSH)
C: sudo iptables –A FORWARD -s 10.0.0.4/30 –p tcp --dport 22 -j ACCEPT
• (regola per l’HTTPS)
C: sudo iptables –A FORWARD -s 10.0.0.4/30 –p tcp --dport 443 -j ACCEPT
• (regola per il DNS)
C: sudo iptables –A FORWARD -s 10.0.0.4/30 –p udp --dport 53 -j ACCEPT

D ora può comunicare con l’esterno, ma non riceve risposta perché dobbiamo impostare lo stateful.
C: sudo iptables -I FORWARD 1 -m state --state ESTABLISHED -j ACCEPT

A questo punto l’esercizio è risolto!

 A 192.168.8.17 10.0.0.33 RETE p-p: 10.0.0.32
B 192.168.8.18 10.0.0.34
C 192.168.8.3 10.0.0.5 RETE p-p: 10.0.0.4
D 192.168.8.4 10.0.0.6

ESERCITAZIONE 3

Impostare il tagging 802.1Q sulle interfacce punto-punto di due host scegliendo un VLAN ID
tra 2 e 254. Assegnare alle sub-interfacce appena create un IP della rete 172.16.X.0/24, dove X =
VLAN ID:
• verificare la connettività tra i due host
• analizzare il traffico tra i due host sia sull’interfaccia principale che sulla sub-interfaccia

Anzitutto dobbiamo creare la LAN, in due passi: prima creiamo le sub-interfacce, dopodiché vi
assegniamo gli indirizzi IP.
A: sudo vconfig add eth0 200
B: sudo vconfig add eth0 200
A: sudo ifconfig eth0.200 up
B: sudo ifconfig eth0.200 up
A: sudo ifconfig eth0.200 172.16.200.2/24
B: sudo ifconfig eth0.200 172.16.200.1/24

Ora il ping funziona su tutte le interfacce!

Eliminare la sub-interfaccia da uno degli host e assegnare il suo IP ad un alias dell’interfaccia

punto-punto:
• verificare la perdita di connettività e analizzare il traffico

Eliminiamo la sub-interfaccia:
B: sudo vconfig rem eth0.200

Assegniamo l’IP ad un alias di eth0, che è l’interfaccia p-p.

B: sudo ifconfig eth0 172.16.200.1/24

A questo punto, facendo opportuni tentativi, ci accorgiamo che la perdita di connettività è totale!
 A 192.168.8.17 10.0.0.33 RETE p-p: 10.0.0.32
B 192.168.8.18 10.0.0.34
C 192.168.8.3 10.0.0.5 RETE p-p: 10.0.0.4
D 192.168.8.4 10.0.0.6

ESERCITAZIONE 4

ipsec newhostkey --bits 512 --output /home/[nometente]/Desktop/chiave512

ipsec newhostkey --bits 2048 --output /home/[nometente]/Desktop/chiave2048

La chiave a 2048 bit è chiaramente più difficile da creare, dunque il calcolatore impiega più tempo
per farlo.

A B C D

Usiamo una chiave a 512 bit (dovranno crearla B e C):

sudo ipsec newhostkey --bits 1024 --output /etc/ipsec.secrets

Per visualizzare le chiavi basta digitare:

sudo ipsec showhostkey --left (sul terminale left, B)
sudo ipsec showhostkey --right (sul terminale right, C)

A e D abbattono le interfacce eth1:

sudo ifconfig eth1 down

B e C vanno ad aprire /etc/ipsec.conf

Modifiche di B al file (come pure di C, i due file sono uguali su entrambi gli host):

conn net-to-net
left=192.168.8.18 (pubblico di B)
leftnexthop=192.168.8.3 (pubblico di C)
leftsubnet=10.0.0.32/30 (sottorete p-p di A e B)
right=192.168.8.3 (pubblico di C)
rightnexthop=192.168.8.18 (pubblico di B)
rightsubnet=10.0.0.4/30 (sottorete p-p di C e D)
 …
leftrsasigkey= [chiave di B]
rightrsasigkey= [chiave di C]

Facciamo partire la connessione su B e C

sudo /etc/init.d/ipsec start
sudo ipsec auto --up net-to-net  Questo comando solo uno dei due

B
A C D

B fa solamente il router (quindi abilità il forwarding, come C), ora il left (host) è A.

A si assegna una chiave (che poi passerà a C)

sudo ipsec newhostkey --bits 1024 --output /etc/ipsec.secrets

Modifiche di C e di A al file /etc/ipsec.conf:

conn host-to-net
left=10.0.0.33
leftnexthop=10.0.0.34
right=192.168.8.3
rightsubnet=10.0.0.4/30
rightnexthop=192.168.8.18
leftrsasigkey= [chiave di A]
rightrsasigkey= [chiave di C]

Facciamo partire la connessione su A e C

sudo /etc/init.d/ipsec start
sudo ipsec auto --up host-to-net  Questo comando solo uno dei due

A C D
B

A butta giù eth1 e imposta B come default gateway; B, a sua volta, abilita il forwarding.
A e C creano le loro chiavi:
sudo ipsec newhostkey --bits 1024 --output /etc/ipsec.secrets

Al solito, per vederle:

sudo ipsec showhostkey --left (sul terminale left, A)
sudo ipsec showhostkey --right (sul terminale right, C)

Modifiche di A sul proprio file di configurazione ipsec:

…
nat_trasversal = yes
…
conn host-to-net
left=10.0.0.33
leftnexthop=10.0.0.34
leftid=@left-peer
right=192.168.8.3
rightsubnet=10.0.0.4/30
rightnexthop=192.168.8.18
righted=@right-peer
…
leftrsasigkey= [chiave di A]
rightrsasigkey= [chiave di C]

Modifiche di C sul proprio file di configurazione ipsec (questa volta i due file sono diversi!):

…
nat_trasversal = yes
…
conn host-to-net
left=%any
leftsubnet=10.0.0.32/30
leftnexthop=10.0.0.34
leftid=@left-peer
right=192.168.8.3
rightsubnet=10.0.0.4/30
rightnexthop=192.168.8.18
righted=@right-peer
…
leftrsasigkey= [chiave di A]
rightrsasigkey= [chiave di C]

B effettua il NAT:
iptables -t NAT -A POSTROUTING -s 10.0.0.33/32 -j SNAT --to-source
192.168.8.18

Facciamo partire la connessione su A e C

sudo /etc/init.d/ipsec start
sudo ipsec auto --up host-to-net  Questo comando solo uno dei due