Navigation
Home
Artikel Kategorien
Vulnerabilities
Blog Kategorien
Blogroll
morpheus
Hexblog
SEppl's Blog
Rabenhorst
The Daily WTF
Otrn Blog
Userfriendly
Schneier on Security
Planet SELinux & News
Heise
SecurityFocus
Open4Free Blog
xkcd
RSS Feeds
Browser Sicherheitslücken
Blog
Partner
Online-tutorials
|_|0|_|
|_|_|0|
|0|0|0|

Be-Paranoid.net

Iptables Tutorial

Orginal Version | Artikel editieren | Versionen anzeigen | Bottom
Letzte Änderung: 11.11.2007, 21:55

Inhaltsverzeichnis



Einführung Top



Iptables ist ein mächtiges Werkzeug, mit dem man den kernelinternen Paketfilter konfigurieren kann.

Dinge wie z.B. NAT, Quality of Service, Port forwarding, ... sind damit sehr leicht umzusetzen.

Dieses Tutorial soll das Schreiben eines iptables-Scripts erleichtern. Es wird ziemlich viele überflüssige Funktionen haben, aber ich denke, damit sollte man auch viel umsetzen können.

Dieses Tutorial erklärt nicht jeden Befehl, hier werden viele Beispiele gezeigt, die möglichst viele Situationen abdecken. Die Befehle sollten selbsterklärend sein, man iptables sollte in den meisten Fällen helfen.

Die Befehle iptables -L -v und iptables -L -t nat geben die Regeln aus, das sollte beim debuggen helfen.

Dieses Tutorial erfordert Hintergrundwissen im Bereich Netzwerktechnik, wenn irgendetwas unklar ist -> Forum.

Iptables sind so aufgebaut, das sie die Regeln nach und nach hinzufügen, das das als erstes hinzugefügt wird, wirkt zuerst.

Das Grundgerüst Top



Als erstes fangen wir mit dem üblichen Standard an:

Code:


#!/bin/sh
#
# iptables firewall script v1.0
#
# http://www.online-tutorials.net/
# 

case $1 in
        start)
                $0 stop

                #Defines the INPUT rules

                #Defines the OUTPUT rules

                #Defines the NAT rules

                echo "Firewall & Routing activated"

        ;;

        stop)
                $IPTABLES -t filter -F INPUT
                $IPTABLES -t filter -F OUTPUT
                $IPTABLES -t filter -F FORWARD
                $IPTABLES -t nat -F POSTROUTING
        ;;

        restart)
                $0 start
        ;;

        *)
                echo "Usage: $0 {startwd|stop|restart}"
        ;;

esac



Das ist das Grundgerüst, wir speichern es mit dem Dateinamen routing-firewall ab. Mit ./routing-firewall start starten wir es, ./routing-firewall stop stoppt es.

Jetzt definieren wir die globalen Variablen, die wir später brauchen vor case $1 in:

Code:


# Siehe: ifconfig oder ip addr
# Die Devices in meinem Fall:
# - läuft das VPN zum Internet Provider über eth1
# - heißt das VPN devices ppp0
# - interne Netzwerk in das ich routen will eth0
EXT_NET_DEV=eth1
EXT_DEV=ppp0
INT_DEV=eth0

#Das interne Netzwerk allgemein
INT_NET=192.168.0.0/16

#Der sichere Bereich, mit den sicheren Clients
INT_NET_SECURE=192.168.100.0/24

#Das Netz in das unsichere Clients aus dem internen Netzwerk kommen
INT_NET_TESTING=192.168.0.0/24

# Das VPN für die VPN-Clients vom Internet, die in's interne Netz wollen
VPN_NET=10.0.100.0/24
VPN_DEV=tap0

#Der Pfad zur iptables
IPTABLES=/sbin/iptables

#Wollen wir die Verbindung zurückweisen, oder droppen? (DROP/REJECT)
NEGATIV=DROP



Alles ist erlaubt, was nicht verboten ist, oder alles ist verboten was nicht erlaubt ist Top



Sie können die iptables Regeln auf zwei Zustände setzen:





Die erste Methode ist vor allem für Leute die ein kleines Heimnetzwerk betreiben und viele verschiedene Programme auf verschiedenen Ports benutzen wollen.

Die zweite Methode ist die sichere Methode, die allerdings etwas umständlich zu konfigurieren ist, vor allem wenn es keine genaue Protokollbeschreibung gibt.

Wir wählen für unser Tutorial die zweite Methode, die erste sollte aber leicht zu implentieren sein.

Der Code dafür kommt nach der folgenden Stelle in das Script:

Code:

        start)
                $0 stop



Hier ist der Code:

Code:


#Deny everything except what we want
$IPTABLES -t filter -P INPUT DROP
$IPTABLES -t filter -P OUTPUT DROP
$IPTABLES -t filter -P FORWARD DROP



Erklärung:


Diese Parameter sagen iptables, das es die Policies INPUT, OUTPUT, und FORWARD mit der Standardeinstellung DROP starten sollen.



Code:


#Wenn wir NAT forwarding machen wollen, müssen wir es hier aktivieren
echo 1 > /proc/sys/net/ipv4/ip_forward



Sicherheitseinstellungen Top



Jetzt können wir noch den folgenden Code zum letzen hinzufügen, wenn Sie etwas nicht wollen können Sie es natürlich weglassen:

Code:


#Verlangsamt ICMP bei zu vielen Paketen
echo "5" >/proc/sys/net/ipv4/icmp_ratelimit

#Killt Packete mit der source route option
echo "0">/proc/sys/net/ipv4/conf/$EXT_DEV/accept_source_route

#Killt ICMP weiterleitung
echo "0">/proc/sys/net/ipv4/conf/$EXT_DEV/accept_redirects

#Defragmentiert  IP-Packete immer
echo "1">/proc/sys/net/ipv4/conf/$EXT_DEV/ip_always_defrag

#Killt gespoofte Pakete
echo "1" > /proc/sys/net/ipv4/conf/$EXT_DEV/rp_filter

#Killt Pakete aus dem Adressraum 0.X.X.X
echo "0" > /proc/sys/net/ipv4/conf/eth0/bootp_relay

# TCP-FIN-Timeout zum Schutz vor DoS-Attacken setzen
echo 30 > /proc/sys/net/ipv4/tcp_fin_timeout

#Maximal 3 Antworten auf ein TCP-SYN 
echo 3 > /proc/sys/net/ipv4/tcp_retries1

#TCP-Pakete maximal 15x wiederholen
echo 15 > /proc/sys/net/ipv4/tcp_retries2

#Dropt defekte Pakete, wer das Modul dazu hat kann es auskommentieren
#$IPTABLES -A FORWARD -m unclean -j DROP
#$IPTABLES -A INPUT   -m unclean -j DROP

#Als nächstes droppen wir Pakete aus dem externen Netzwerk, die eine interne Adresse haben
$IPTABLES -t nat -A PREROUTING -i $EXT_DEV -s 192.168.0.0/16 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_DEV -s 10.0.0.0/8 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_DEV -s 172.16.0.0/12 -j DROP
$IPTABLES -t nat -A PREROUTING -i $EXT_DEV -s 127.0.0.0/8 -j DROP



Erklärung:


Diese Befehle sagen iptables, das es alle Pakete 
die von einer externen Adresse in das interne Netzwerk geroutet werden sollen gedroppt werden sollen.



ICMP wird nicht geblockt Top



Ich werde in diesem Tutorial ICMP eingeschaltet lassen, hier die Gründe: Click me!

ICMP abzuschalten macht absolut keinen Sinn.

Ports definieren Top



Als nächtes definieren wir die Ports, die wir forwarden wollen, ich liste hier ein paar auf, die wir brauchen werden:

#TCP
21 FTP
25 SMTP (Emails verschicken)
80 HTTP
110 POP3 (Email per POP3)
143 IMAP (Email per IMAP)
993 IMAP SSL (Email per IMAP verschlüsselt)
443 HTTPS
1863 MSN
5190 ICQ
5222 Jabber
6667 IRC
6668 IRC

Diese Ports werden dann vom internen Netzwerk in das Internet geroutet.

Jeder kann diese Liste natürlich vergrößern, einfach auf editieren klicken. laugh

Diese Ports schreiben wir jetzt in eine Variable, zu den anderen Variablen dazu ganz am Anfang unseres Skripts:

Code:


NAT_FORWARDING_TCP_PORT="21,25,80,110,143,443,993,5190,5222,6667,6668,1863"



Als nächstes definieren wir die Ports, die vom Internet auf den Rechner zugreifen dürfen:

Code:


#Diese Ports werden von mir für SSH (22), und OpenVPN (443, Standard für HTTPS) verwendet
INPUT_INTERNET_TCP_PORT="443,22"



Input Regeln definieren Top



Diese Regeln werden nach #Defines the INPUT rules definiert.

Code:


#vpn
$IPTABLES -t filter -A INPUT -i $EXT_NET_DEV -j ACCEPT



Hier lassen wir alle Verbindungen die zur Netzwerkkarte die mit dem Provider verbunden ist durch.

Code:


#Accept each lo connection
$IPTABLES -t filter -A INPUT  -i lo -j ACCEPT                                         



Wir akzeptieren jede lokale Verbindung auf das loop device (127.0.0.1).

Code:


#icmp
$IPTABLES -t filter -A INPUT -p icmp -j ACCEPT

ICMP wird akzeptiert



Code:


$IPTABLES -t filter -A INPUT -s 0.0.0.0/0 -p tcp -m multiport --dport $INPUT_INTERNET_TCP_PORT -j ACCEPT



Wir akzeptieren Verbindungen die vom Internet auf uns zugreifen. (wenn nur 1 Port-> -m mulitport weg)

-s ist die Adresse/Adressraum im Internet, von der die Verbindung stammt.

Als nächstes fügen wir folgendes hinzu:

Code:


$IPTABLES -t filter -A INPUT -p tcp ! --syn -j ACCEPT #syn packages



Code:


#Intern
#$IPTABLES -t filter -A INPUT -i $INT_DEV -s $INT_NET -p udp -m multiport  --dport $INPUT_INTERN_UDP_PORT -j ACCEPT



Falls $INPUT_INTERN_UDP_PORT gesetzt ist, können sie das auskommentieren, dadurch werden die UDP Ports hereingelassen. (wenn nur 1 Port-> -m mulitport weg)

Jetzt müssen wir noch den Zugriff zum Nameserver (51) gewähren:

Code:


#Internet
$IPTABLES -t filter -A INPUT -i $EXT_DEV -s 195.58.160.0/16 -p udp -j ACCEPT          #Nameserver
$IPTABLES -t filter -A INPUT -i $EXT_DEV -s 195.58.161.0/16 -p udp -j ACCEPT          #Nameserver
$IPTABLES -t filter -A INPUT -i $EXT_DEV -p udp --dport 53 -j ACCEPT



Damit hätten wir alle Zugriffe die von außen auf unseren Rechner zugreifen wollen geregelt.

Output Regeln definieren Top



Falls nötig öffnen wir hier wieder die Verbindung über die Netzwerkkarte zum Provider, außerdem die Verbindungen vom loopback device, und die ICMP Verbindungen.

Code:


#vpn
$IPTABLES -t filter -A OUTPUT -o $EXT_NET_DEV -j ACCEPT

#icmp
$IPTABLES -t filter -A OUTPUT -p icmp  -j ACCEPT

#Accept each lo connection
$IPTABLES -t filter -A OUTPUT -o lo -j ACCEPT                                        



Falls $OUTPUT_INTERN_TCP_PORT oben gesetzt wurde, können wir das Folgende wieder auskommentieren (wenn nur 1 Port-> -m mulitport weg):

Code:


#intern
#$IPTABLES -t filter -A OUTPUT -o $INT_DEV -d $INT_NET -m multiport  -p tcp --dport $OUTPUT_INTERN_TCP_PORT -j ACCEPT



Als nächstes erlauben wir geforwardete Pakete den Weg nach draußen. (wird noch nicht weitergeleitet)

Code:


#internet
$IPTABLES -t filter -A OUTPUT -o $EXT_DEV -d 0.0.0.0/0 -p tcp -m multiport --dport $NAT_FORWARDING_TCP_PORT -j ACCEPT #Outgoing ftp


$IPTABLES -t filter -A OUTPUT -p tcp ! --syn -j ACCEPT #syn packages



NAT Top



Jetzt können wir uns mit dem Interessantesten beschäftigten: NAT.

Als erstes aktivieren wir die Weiterleitung:

Code:




$IPTABLES -A POSTROUTING -t nat -p tcp -o $EXT_DEV -s $INT_NET -j MASQUERADE

//Wenn UDP weitergeleitet werden soll
#$IPTABLES -A POSTROUTING -t nat -p udp -o $EXT_DEV -s $INT_NET -j MASQUERADE

$IPTABLES -A POSTROUTING -t nat -p icmp -o $EXT_DEV -s $INT_NET -j MASQUERADE



Jetzt forwarden wir alle syn Pakete, und blocken eine Domain:

Code:


$IPTABLES -A FORWARD -p tcp ! --syn -j ACCEPT

#Wollen wir nicht, schlechte Erfahrung
#Wir machen REJECT, damit der Browser nicht lange für die Antwort braucht
$IPTABLES -t filter -A FORWARD -p tcp -d hausaufgaben.de -j REJECT



Mit dem folgenden Code können wir alle Pakete die ins Internet wollen, und einen Port von $NAT_FORWARDING_TCP_PORT ansprechen wollen weiterleiten, außerdem lassen wird den Port 442 bei example.com zu:

Code:


#tcp
$IPTABLES -A FORWARD -i $INT_DEV -o $EXT_DEV -s $INT_NET -p tcp -m multiport --dport $NAT_FORWARDING_TCP_PORT -j ACCEPT

$IPTABLES -A FORWARD -i $INT_DEV -o $EXT_DEV -s $INT_NET -d www.example.com -p tcp --dport 442 -j ACCEPT



So werden ICMP Nachrichten weitergeleitet:

Code:


#icmp
$IPTABLES -A FORWARD -m state --state NEW -p icmp -j ACCEPT
$IPTABLES -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT



Optional können wir auch diesen Code an das ende der NAT regeln stellen, nachdem alle Regeln durchgegangen sind, und nichts gefunden wude, loggen diese Befehle dann den Rest, der noch keine Regel entsprochen hat:

Code:


#Log other outgoing connections (internet)
$IPTABLES -A FORWARD -i $INT_DEV -o $EXT_DEV -s $INT_NET -p tcp -j LOG --log-prefix "~~FILTER~~ FORWARD TCP! " --log-ip-options

$IPTABLES -A FORWARD -i $INT_DEV -o $EXT_DEV -s $INT_NET -p udp -j LOG --log-prefix "~~FILTER~~ FORWARD UDP! " --log-ip-options



Da ich ein VPN verwende, will ich das in mein Internes Netz routen:

Code:


#VPN
$IPTABLES -A FORWARD -i $VPN_DEV -o $INT_DEV -s $VPN_NET -j ACCEPT
$IPTABLES -A FORWARD -i $INT_DEV -o $VPN_DEV -s $INT_NET -j ACCEPT



Zum mitloggen, forwarde ich alle Verbindungen die auf die Ports 6667 und 6668 zugreifen wollen, und ins Internet wollen auf localhost, dort werden sie abgefangen, und weitergeleitet:

Code:


$IPTABLES -t nat -A PREROUTING -p tcp --dport 6667 -j REDIRECT --to-ports 13

$IPTABLES -t nat -A PREROUTING -p tcp --dport 6668 -j REDIRECT --to-ports 14



Auf 192.168.0.2:80 läuft ein Webserver, ich forwarde alle Verbindungen die vom Internet auf den Port 80 zugreifen wollen, auf den Webserver:


Code:


#Forwarden
$IPTABLES -t nat -A PREROUTING -i $EXT_DEV -p tcp --dport 80 -j DNAT --to 192.168.0.1

#Verbindung die geforwardet wird erlauben
$IPTABLES -A FORWARD -i $EXT_DEV -o $INT_DEV -p tcp --dport 80 -j ACCEPT



Forwardet alle Verbindungen die das Testnetz als Ziel haben, aber nicht umgekehrt:

Code:


$IPTABLES -A FORWARD -i $INT_DEV -o $EXT_DEV -d $INT_NET_TESTING -p tcp -j ACCEPT
$IPTABLES -A FORWARD -i $INT_DEV -o $EXT_DEV -d $INT_NET_TESTING -p udp -j ACCEPT



Schlusswort Top



Ich hoffe dieses Tutorial hat einen kleinen Einblick in das Thema iptables geschaffen, natürlich richtet es sich an eine Zielgruppe die auch selbst was nachschlägt laugh

Orginal Version | Artikel editieren | Versionen anzeigen | Top
Letzte Änderung: 11.11.2007, 21:55