IPTables - from scratch

• iptables Allgemein
• iptables Syntax Allgemein

Positionierung der Firewall ab Ubuntu 16.04

Ab Ubuntu 16.04 wurde das übliche init durch das neue systemd ersetzt. Daher muss die Firewall in /usr/local/sbin platziert werden und wie im unteren Link angegeben der Service-File erstellt werden

• Systemd#Service_File

Der Rumpf

Zuerst wird in dem firewall-Skript ein case start - stop Block angelegt:

#!/bin/bash
case $1 in
start)
echo "starte firewall"
;;
stop)
echo "stoppe firewall"
;;
*)
echo "usage: $0 start|stop"
;;
esac

Filter Tabelle

Beginnen wir unsere Firewall mit ihrer simpelsten Funktion: dem Paketfilter.

Flushing

Bevor wir unsere eigenen Regeln entwerfen, sollten wir sichergehen das sich keine alten Regeln einschleichen und zu unerwarteten Komplikationen führen. Dieses wird durch das sogenannte "flushing" erreicht, welches mit folgender Zeile geschieht:

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -t nat -F
iptables -t mangle -F

;;
stop)
echo "stoppe firewall"
iptables -F
iptables -t nat -F
iptables -t mangle -F

;;
esac

Ohne flushing kann es auch passieren das sich unsere Regeln bei jedem Neustart der Firewall addieren.

Verwendete Syntax

Der Operand -F löst das flushing aus mit dem alle Regeln in der angegebenen Tabelle ( hier "-t filter" da keine angegeben ) entfernt werden

Wichtig

Wenn man zukünftig auch Regeln in die nat und mangle Tabellen schreiben möchte, muss man dazu sichergehen das auch diese bei jedem Start und Stop jeweils geflusht werden damit keine Komplikationen entstehen.

Default policy

Als nächstes definieren wir was passieren soll falls keine unserer Regeln zutreffen sollte, auch gennannt "default policy"

Dies geschieht mit folgenden Zeilen:

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

Wie in Syntax Allgemein angegeben muss die "default policy" auf alle 3 Anlaufstellen angewendet werden.

Nach der Anlaufstelle geben wir an was mit den Paketen zu tun ist.

Mit DROP lässt die gestartete Firewall alle Pakete fallen die nicht auf eine Regel passen.

Mit ACCEPT lässt die gestoppte Firewall alle Pakete durch.

ESTABLISHED und RELATED Pakete

Ein Vorteil von iptables zu seinen Vorgängern ist die Funktion seinen Paketfilter nur auf die ersten Pakete einer Verbindung zu begrenzen und so Ressourcen zu sparen.

Dieses wird erreicht mit folgenden Zeilen

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

Die neuen Funktionen die wir hier verwenden beinhalten:

-m state: Das Modul von iptables das erkennt ob ein Paket eine Verbindung initiiert oder zu einer bereits errichteten Verbindung gehört.

--state ESTABLISHED,RELATED: Der Status nach dem das Paket untersucht wird, wobei

ESTABLISHED: Für alle Pakete steht die nicht das erste Paket einer Verbindung ist die in beide Richtungen sendet. (TCP)

RELATED: Für alle Pakete steht die eine 2t Verbindung öffnen wollen. (FTP,ICMP)

-j ACCEPT: Benutzt die angegebene Operation auf das Paket, hier ACCEPT.

loopback device

Nun haben wir schon ein paar Regeln aber noch keine die bisher zutreffen kann. Wenn wir diese Firewall aktivieren würden wäre unser eigener Router Nichtmal mehr in der Lage mit sich selbst zu kommunizieren. Da er dies über das sogennante "loopback device" lassen wir jetzt unsere ersten Pakete durch.

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -m state --state NEW -j ACCEPT
iptables -A INPUT -i lo  -m state --state NEW -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

Hier geben wir nun zum ersten mal zur Anlaufstelle auch das jeweilige Interface das angelaufen wird mit an:

Mit -o lo beschreiben wir als output also Ausgang die Schnittstelle lo was für das loopback device steht

Genauso -i lo wobei lo hier als Eingang angegeben wird. In einem Satz:

Alle Pakete die von unserem Router aus lo Ausgehen durchlassen

Alle Pakete die an unserem Router an lo Ankommen durchlassen

Fernwartung

Angenommen unser Router mit der Firewall steht nicht im selben Netz wie unser üblicher Arbeitsrechner, ist es von Vorteil auch von außen auf ihn zugreifen zugreifen zu können. In unserem Beispiel ist das äußere Netz auch ein LAN.

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

-s: Passt auf die angegebene Quell IP-Adresse, hier 192.168.241.10

-p: Passt auf ein Protokoll, hier tcp

-dport: Passt auf Ziel Port, hier 22 (ssh)

--state NEW: Passt auf Pakete die eine Verbindung Initiieren

Adressen zusammenfassen

iptables -A INPUT -i eth0 -s 192.168.241.10,10.81.3.1 -p tcp --dport 22 -m state --state NEW -j ACCEPT

DNS-Server und HTTP

Jetzt möchten wir mit unserem Router ins Internet gehen können. Dazu müssen wir 2 Dinge tun, zuerst müssen wir erlauben das er auf DNS-Server zugreifen kann.

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

-d: Das selbe Prinzip wie auch bei -s aber auf eine Ziel Adresse

---

Dann müssen wir auch noch eine Regel für HTTP aufstellen damit wir auch Internetseiten aufrufen dürfen

 #!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

ICMP

Jetzt wollen wir testen können ob unser Router erreichbar ist. Dazu müssen wir ICMP freischalten

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

--icmp-type 8 Beschränkt erlaubte ICMP Pakete auf typ 8 ( echo )

NAT Tabelle

NAT steht für Network Address Translation, also eine Übersetzung von Netzwerk Adressen, sei es in Namen oder auch einfach nur in andere IP-Adressen. Iptables kann diesen Job übernehmen und zwar auf verschiedene Art und Weise.

Wichtig

Da wir nun beginnen NAT regeln in die firewall zu schreiben dürfen wir nicht vergessen die Zeile zum flushen eben jener hinzuzufügen

MASQUERADE

Masquerading ist wohl die simpelste Form von NAT, hiermit ersetzt der Router einfach jede Quell IP-Adresse jedes zu routenden Paketes mit seiner eigenen, sowie bei einem Antwort Paket die Ziel Adresse wieder mit der Original Quell Adresse.In iptables erreicht man diese Funktion mit folgender Zeile

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -s 172.23.242.0/24 -j MASQUERADE -o eth0 
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

-t nat: Hier sehen wir zum ersten mal wie man eine andere Tabelle außer Filter anspricht

POSTROUTING: Damit der Router weiß das er den Adressen Tausch NACH dem Routing ausführen soll

-j MASQUERADE: Eine weitere Aktion die auf ein Paket ausgeführt werden kann, hier unser NAT

-s 172.23.242.0/24: Hier wird nicht nur eine IP-Adresse, sondern ein ganzer Netzbereich als Quelle angegeben

FORWARD

Um den an die Firewall angeschlossenen Rechnern einen Netzzugang zu gestatten müssen wir deren DNS Anfragen zulassen

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -s 172.23.242.0/24 -j MASQUERADE -o eth0 
iptables -A FORWARD -i vmbr1 -o vmbr0 -p tcp --dport 53 -m state --state NEW -j ACCEPT
iptables -A FORWARD -i vmbr1 -o vmbr0 -p udp --dport 53 -m state --state NEW -j ACCEPT

;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

-i : Hier wird die Schnittstelle definiert auf der die Anfragen an die Firewall eingehen

-o: Hier wird die Schnittstelle definiert auf die Anfragen die Firewall verlassen

FORWARD: Damit die Firewall weiß, dass das Paket weitergeleitet werden soll

--dport: Hier wird der Zielport der Anfragen definiert

MULTIPORT

Ausser dem DNS müssen zum arbeiten noch andere Ports geöffnet werden. Um nicht für jeden eine einzelne Regel anlegen zu müssen bietet sich die Nutzung des Parameters Multiport an.

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -s 172.23.242.0/24 -j MASQUERADE -o eth0 
iptables -A FORWARD -i vmbr1 -o vmbr0 -p tcp --dport 53 -m state --state NEW -j ACCEPT
iptables -A FORWARD -i vmbr1 -o vmbr0 -p udp --dport 53 -m state --state NEW -j ACCEPT
iptables -A FORWARD -i vmbr1 -o vmbr0 -p tcp -m multiport --dport 22,25,80,443,143 -m state --state NEW -j ACCEPT
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

-m multiport: Hiermit weiß die Firewall, daß unter --dport mehrere Ports hinterlegt wurden

SNAT

SNAT ist Masquerading sehr ähnlich, der einzige Unterschied besteht darin das man sich bei SNAT die ersetzende IP-Adresse wählen kann. Da wir schon Masquerading eingebaut haben, hängen wir SNAT nicht auch noch mit in unsere Firewall.

Hier aber ein Beispiel:

iptables -t nat -A POSTROUTING -j SNAT -o eth0 -s 172.23.242.0/24 --to-source 192.168.242.100

Verwendete Syntax

-j SNAT: Die auszuführende Aktion, hier SNAT

--to-source 192.168.242.100: Die Angabe zu welcher IP-Adresse ersetzt wird, hier die des Routers.

NETMAP

Eine weiter Form des NAT in iptables ist NETMAP. Statt wie bei MASQUERADE oder SNAT, ersetzt NETMAP die Quell Adresse nicht nur mit einer bestimmten Adresse, sondern bildet das gesamte Quell Netz auf ein anderes ab.

SNAT-Beispiel:

iptables -t nat -A POSTROUTING -j NETMAP -o eth0 -s 172.23.242.0/24 --to 195.145.95.0/24

DNAT-Beispiel:

iptables -t nat -A PREROUTING -j NETMAP -i eth0 -d  195.145.95.0/24 --to 172.23.242.0/24

Verwendete Syntax

-j NETMAP: Aktion die auf Pakete ausgeführt wird, hier NETMAP

DNAT, port forwarding

Da das interne Netz nicht von außen angesprochen werden kann, wie es bei normalen Routern die ins Internet führen ja auch der Fall ist, bedient man sich hierfür einer Technik namens port forwarding, was bedeutet das ein Programm das über einen bestimmten Port mit dem Router kommuniziert an eine andere IP-Adresse und einen anderen Port weitergeleitet wird.

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -j MASQUERADE -o eth0 -s 172.23.242.0/24
iptables -t nat -A PREROUTING -j DNAT -i eth0 -p tcp --dport 3333 --to-dest 172.23.242.100:22
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Verwendete Syntax

PREROUTING: Die Aktion soll noch vor einer Routingentscheidung durchgeführt werden

DNAT für alle Protokolle/Ports - one IP

iptables -t nat -A PREROUTING -d $1stIP -j DNAT --to-destination $2ndIP

Alle Pakete die an die Adresse $1stIP gehen werden an die Adresse $2nIP umgeleitet

DNAT auf einen Port

iptables -t nat -A PREROUTING -p tcp -d $1stIP --dport $EINGANGSPORT -j DNAT --to-destination $2ndIP

Alle Pakete die an den Port $EINGANGSPORT der Adresse $1stIP gehen werden an die Adresse $2nIP umgeleitet

DNAT Portumleitung

iptables -t nat -A PREROUTING -p tcp -d $1stIP --dport $EINGANGSPORT -j DNAT --to-destination $2ndIP:$WUNSCHPORT

Alle Pakete die an den Port $EINGANGSPORT der Adresse $1stIP gehen werden an den Port $WUNSCHPORT der Adresse $2nIP umgeleitet

(Wenn die Destination IP der Host ist, reicht die Schnittstellenangabe!
iptables -t nat -A PREROUTING -p tcp -i $WANDEV --dport $EINGANGSPORT -j DNAT --to-destination $2ndIP:$WUNSCHPORT

FORWARD

iptables -t nat -A PREROUTING -j DNAT -i $WAN -p tcp --dport $EINGANGSPORT --to $2ndIP:$WUNSCHPORT
iptables -A FORWARD -p tcp -d $2ndIP --dport  $WUNSCHPORT -j ACCEPT -m state --state NEW

FULL NAT

iptables -t nat -A PREROUTING -d $1stIP -j DNAT --to-destination $2ndIP
iptables -t nat -A POSTROUTING -s $2ndIP -j SNAT --to-source $1stIP
     

Verwendete Syntax

PREROUTING: Paket wird nach der Routingentscheidung geändert

-j DNAT: Aktion die auf Pakete ausgeführt wird, hier DNAT

--to-dest 172.23.242.100:22: IP-Adresse und Port zu denen weitergeleitet wird

In einem Satz:

Ändere bei allen Paketen die auf eth0 ankommen und den Port 3333 ansprechen die Ziel Adresse zu 172.23.242.100 und Port zu 22

Logging

Damit wir sehen können was so alles an unserer Firewall abprallt, nicht nur um Störenfriede zu erkennen, sondern auch um zu sehen was wir vielleicht für uns freischalten müssen, können wir ein logging einrichten das automatisch alle Pakete die nicht durchgelassen wurden an den syslog deamon weitergeben der die Vorkommnisse in die syslog schreibt.

#!/bin/bash
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -s 192.168.241.10 -p tcp --dport 22 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p udp -d 192.168.240.21 --dport 53 -m state --state NEW -j ACCEPT
iptables -A OUTPUT -o eth0 -p tcp --dport 80 -m state --state NEW -j ACCEPT
iptables -A INPUT -i eth0 -p icmp --icmp-type 8 -j ACCEPT
iptables -t nat -A POSTROUTING -j MASQUERADE -o eth0 -s 172.23.242.0/24
iptables -t nat -A PREROUTING -j DNAT -i eth0 --dport 3333 --to-dest 172.23.242.100:22
iptables -A INPUT  -j LOG  --log-prefix "--iptables-in--"
iptables -A OUTPUT -j LOG  --log-prefix "--iptables-out--"
iptables -A FORWARD -j LOG --log-prefix "--iptables-for--"
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
;;
esac

Diese Zeilen sollten ganz am Ende bleiben, damit auch sichergestellt ist das nur Pakete die alle Regeln durchlaufen haben dort landen.

Verwendete Syntax

-j LOG: Aktion die auf Pakete ausgeführt wird, hier LOG

--log-prefix "--iptables-in--": Schreibt --iptables-in-- , vor jedes Paket das am INPUT verworfen wurde,

logging file ändern

• Rsyslog

netstat-nat and conntrack

• netstat-nat (vielleicht veraltet)
• conntrack

contrack table löschen

• conntrack -F

DNAT weiterleitung bis auf einen port

#!/bin/bash
SSHPORT="4567"
1stIP="WEITERLEITUNGS-IP"
2ndIP="CONNECT-IP"
case $1 in
start)
echo "starte firewall"
iptables -F
iptables -F -t nat
iptables -F -t mangle
iptables -X
iptables -X -t nat
iptables -X -t mangle
iptables -t nat -N innat
iptables -t nat -A innat -j RETURN -p tcp --dport $SSHPORT
iptables -t nat -A innat -j DNAT --to $1stIP
iptables -t nat -A PREROUTING -d $2ndIP -j innat
iptables -t nat -A POSTROUTING -j SNAT -s $1stIP --to $2ndIP
;;
stop)
echo "stoppe firewall"
iptables -F
iptables -F -t nat
iptables -F -t mangle
iptables -X
iptables -X -t nat
iptables -X -t mangle
;;
esac

Verwendete Syntax

-N innat: Hier wird eine neue Kette mit dem Namen "innat" angelegt

mark

iptables -t mangle -A PREROUTING -j MARK -p tcp --dport 25 --set-mark 9
iptables -t nat -A PREROUTING -j REDIRECT -p tcp --dport 25 --to 52525
iptables -A INPUT -j ACCEPT -m mark --mark 9

Alle ankommenden Pakete, die den angegebenen Bedingungen entsprechen (hier: TCP-Pakete mit Zielport 25) werden markiert. Es sind bis zu 32 verschiedene Markierungen möglich.

Anhand dieser Markierungen können die Pakete nun, wie in unserem Beispiel auf einen anderen Port (52525) umgeleitet werden, ohne, dass dieser Port nach aussen geöffnet werden muss.

Weiterhin werden im obigen Beispiel alle eingehenden Pakete, die den Marker 9 targen automatisch von der Firewall durchgelassen.

Mangle

MSS Reduktion

iptables -t mangle -A FORWARD -p tcp -i $LAN -o $WAN --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 1400

• https://www.zeitgeist.se/2013/11/26/mtu-woes-in-ipsec-tunnels-how-to-fix/

Markieren und Freischalten

iptables -t mangle  -A PREROUTING -j MARK -i $WAN -p tcp --dport 22 -d $TELIP --set-mark 0x8
iptables -t nat    -A PREROUTING -j DNAT -i $WAN -p tcp --dport 22 -d $TELIP --to 192.168.244.1:8472
iptables -t filter -A FORWARD -j ACCEPT -m mark --mark 0x8

backdoor hack

• iptables -t mangle -A PREROUTING -j MARK -i vmbr0 -p tcp --dport 8472 -d 192.168.100.254 ! -s 192.168.100.0/24 --set-mark 0x8
• iptables -t mangle -A PREROUTING -j CONNMARK --save-mark -i vmbr0 -p tcp --dport 8472 -d 192.168.100.254 ! -s 192.168.100.0/24
• iptables -A OUTPUT -t mangle -j CONNMARK --restore-mark
• ip rule add fwmark 8 table 230
• ip route add default via 192.168.100.253 dev vmbr0 table 230

VPN Tunnel zulassen

Über den switch policy ist es möglich alle Pakete, die zu einem bestimmten VPN-Tunnel gehören durch die Firewall zu lassen.

ACHTUNG!

Dies funktioniert nicht, wenn der Tunnel genattet wird!

Ein VPN-Tunnel

iptables -A FORWARD -i $LAN -o $WAN -s $LEFTNET -d $RIGHTNET -m policy --dir out --pol ipsec -m state --state NEW -j ACCEPT  

iptables -A FORWARD -i $WAN -o $LAN -s $RIGHTNET -d $LEFTNET -m policy --dir in  --pol ipsec -m state --state NEW -j ACCEPT 

Verwendete Syntax

$LAN: Bezeichnet die dem Netzwerk zugewandte Schnittstelle

$WAN: Bezeichnet die dem Internet zugewandte Schnittstelle

$LEFTNET: Bezeichnet das auf unserer Seite hinter der Firewall liegende Netzwerk

$RIGHTNET: Bezeichnet das auf der anderen Seite des VPN-Tunnels liegende Netzwerk

-m policy: Ruft das Modul "policy" auf

--pol ipsec: Bezeichnet die zu betrachtende policy. Hier IPSEC

--dir in/out: Legt die Richtung fest in welcher Richtung die policy betrachtet werden soll

iptables -A INPUT -i eth0 -p esp  -m state --state NEW -j ACCEPT

ESP-Protokoll zulassen

Mehrere VPN-Tunnel

Wenn wir auf unserer Firewall mehrere Tunnel haben, die wir entsprechend filtern wollen, bietet es sich an eine neue Kette zu erstellen. Das Ergebnis ist zwar in beiden Fällen das Gleiche aber durch die Kette wird unsere Firewall übersichtlicher und wir sparen uns auch einiges an Schreibarbeit.

iptables -N vpn-in-accept
iptables -A vpn-in-accept  -m policy --dir in  --pol ipsec -m state --state NEW -j ACCEPT
iptables -A vpn-in-accept -j RETURN
iptables -N vpn-out-accept
iptables -A vpn-out-accept -m policy --dir out --pol ipsec -m state --state NEW -j ACCEPT
iptables -A vpn-out-accept -j RETURN

Und nun wenden wir die neue Kette an

iptables -A FORWARD -i $LAN -o $WAN -s $LEFTNET -d $RIGHTNET -j vpn-out-accept
iptables -A FORWARD -i $WAN -o $LAN -s $RIGHTNET -d $LEFTNET -j vpn-in-accept

Alle Pakete von einem VPN-Tunnel zulassen

Hier werden alle Pakete die von dem VPN Tunnel kommen zugelassen.

iptables -A FORWARD -i $WAN  -m policy --pol ipsec --mode tunnel --dir in -j ACCEPT

limit module

modul laden

in jeder regel in der wir limits benutzen wollen müssen wir das modul laden

-m limit

optionen

• iptables -A INPUT -p icmp -m icmp -m limit --limit 4/second --limit-burst 10 -j ACCEPT

Das bedeutet folgendes:

1. Es dürfen 4 Pakete pro Sekunde durchgelassen werden.
2. Wenn mehr als 4 Pakete pro Sekunde kommen, dürfen insgesamt 10 Pakete ohne Limitierung durch.
3. Nach diesen 10 Paketen, dürfen wieder nur 4 pro Sekunde durch.
4. Wenn weniger als 4 Pakete pro Sekunde ankommen, wird die Differenz wieder frei (limit von 4-X Pakete/s) und steht wieder zum überziehen bereit.

--limit als Begrenzung optionen kann man definieren wie viele aktionen pro zeiteinheit zugelassen werden 1/second,2/minute,3/hour,4/day, oder 1/s,2m/,3/h,4/d –limit-burst definiert wie viele aktionen mehr als die limitierung zugelassen werden bevor das definierte limit einsetzt

diese regel lässt bis zu 10 Verbindungen in einer Sekunde zu wird dies überschritten setzt die Limitierung von 4 ICMP Packeten pro Sekunden ein. Für jede Sekunde in der das Limit von 4 packeten nicht erreicht wird werden die übrigen erlaubten pakete dem burst wider gut geschrieben das heißt wen der burst voll ist dauert es 2,5 sekunden (ohne das icmp packete kommen) bis der burst wider seinen Ursprungswert ereicht oder 5 sekunden in denen pro sekunden 2 packete kommen

DoS atacken

Beschränkt die Anzahl der neuen tcp Verbindungen die wir aufbauen können auf 1 pro Sekunde

• iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
• iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
• iptables -A INPUT -p icmp -m icmp -m limit --limit 1/second -j ACCEPT

ftp

Vorrausetzung

• iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT

Basically newer kernels ( >= 4.7 ) are deprecating the automatic helper module's port assignment in favor of explicit rules.

Short fix to get the old behaviour:

• echo 1 > /proc/sys/net/netfilter/nf_conntrack_helper

Sowohl aktives als auch passives FTP wird nach laden der Module über den RELATED Status gehandled. Module laden

• modprobe -v nf_conntrack_ftp
• modprobe -v nf_nat_ftp

Client auf Server im Internet

• iptables -A FORWARD -i $LAN -o $WAN -p tcp --dport 21 -m state --state NEW -j ACCEPT

FTP Server im LAN mit Inside NAT

• iptables -A FORWARD -i $WAN -o $LAN -p tcp --dport 21 -d $FTPSERVER_LAN -m state --state NEW -j ACCEPT
• iptables -t nat -A PREROUTING -j DNAT -i $WAN -p tcp --dport 21 --to-dest $FTPSERVER_LAN