Raspberry Pi als Firewall & Router (nftables)

Auf eigene Gefahr: Eine fehlerhafte Regelreihenfolge sperrt dich sofort per SSH aus — alles auf eigene Gefahr. Halte während der gesamten Einrichtung Tastatur und Monitor am Pi bereit, füge die SSH-Allow-Regel IMMER vor dem default-drop ein und lade neue Rulesets nur über den im Tutorial gezeigten timed-rollback (`sleep 60 && nft flush ruleset`), damit du dich nach 60 Sekunden automatisch wieder befreist.

Überblick & Topologie

Wir bauen einen einfachen Router/Firewall auf Raspberry Pi OS (Bookworm, 64-Bit). Der onboard-Ethernet-Port eth0 wird zum WAN (Richtung deinem bestehenden Router/Internet), der USB-3-Gigabit-Adapter eth1 wird zum LAN für deine Clients. nftables übernimmt Paketfilter und NAT.

1. LAN-Interface statisch konfigurieren

Raspberry Pi OS Bookworm nutzt NetworkManager. Vergib dem LAN-Adapter eine feste IP, das WAN bleibt auf DHCP:

sudo nmcli con add type ethernet ifname eth1 con-name lan \
  ipv4.method manual ipv4.addresses 192.168.50.1/24
sudo nmcli con up lan
ip -br addr   # Kontrolle: eth1 trägt jetzt 192.168.50.1/24

2. IP-Forwarding aktivieren

Damit der Pi Pakete zwischen den Interfaces weiterleitet, schalte IPv4-Forwarding dauerhaft ein:

echo 'net.ipv4.ip_forward=1' | sudo tee /etc/sysctl.d/99-router.conf
sudo sysctl --system
sysctl net.ipv4.ip_forward   # muss "= 1" liefern

3. nftables installieren

sudo apt update
sudo apt install -y nftables
sudo systemctl enable nftables

4. Sauberes Ruleset (default-drop + NAT)

Wichtig ist die Reihenfolge: erst die SSH-Erlaubnis, dann die policy drop. Lege die Datei /etc/nftables.conf an:

#!/usr/sbin/nft -f
flush ruleset

define WAN = "eth0"
define LAN = "eth1"

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        ct state established,related accept
        iif "lo" accept
        ip protocol icmp accept

        # SSH NUR vom LAN zulassen (vor jedem drop!)
        iifname $LAN tcp dport 22 accept

        # weitere LAN-Dienste (DHCP/DNS), falls du sie auf dem Pi betreibst
        iifname $LAN udp dport { 67, 68, 53 } accept
        iifname $LAN tcp dport 53 accept
    }

    chain forward {
        type filter hook forward priority 0; policy drop;

        ct state established,related accept
        # LAN darf raus ins WAN
        iifname $LAN oifname $WAN accept
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

table inet nat {
    chain postrouting {
        type nat hook postrouting priority 100; policy accept;
        oifname $WAN masquerade
    }
}

5. Mit timed-rollback testen (Aussperr-Schutz)

Lade das Ruleset niemals blind. Starte zuerst eine Sicherung, die nach 60 Sekunden alles wieder freiräumt — bestätigst du innerhalb der Zeit, dass SSH noch geht, brichst du sie ab:

# Notbremse: setzt die Firewall nach 120 s automatisch zurück.
# Sperrst du dich aus, hast du nach spätestens 120 s wieder Zugriff.
( sleep 120 && sudo nft flush ruleset ) &
ROLLBACK=$!

# Regeln laden
sudo nft -f /etc/nftables.conf

# In einer ZWEITEN SSH-Sitzung testen, ob der Zugriff bleibt.
# Wenn ja, Notbremse stoppen (sonst Reset nach 120 s):
kill "$ROLLBACK""

Verlierst du die Verbindung, wartest du 60 Sekunden — die Firewall wird geleert und du kommst wieder rein (notfalls über die direkt angeschlossene Tastatur). Prüfe das geladene Regelwerk mit:

sudo nft list ruleset

6. Regeln persistent machen

Der nftables.service lädt beim Boot genau /etc/nftables.conf. Da unsere Regeln bereits dort liegen, reicht ein Neustart des Dienstes:

sudo systemctl restart nftables
sudo systemctl status nftables   # active (exited) = ok

Nach einem Reboot stehen die Regeln automatisch. Änderst du das Ruleset, editiere immer die Datei und teste erneut mit dem timed-rollback aus Schritt 5.

7. SSH härten — damit du den Zugang behältst

Da der Pi jetzt ein Routing-Gerät ist, ist SSH-Härtung Pflicht. Hinterlege zuerst deinen Public Key (ssh-copy-id pi@192.168.50.1), prüfe den Login per Key, und passe dann /etc/ssh/sshd_config.d/99-hardening.conf an:

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
# Optional: SSH ausschließlich auf der LAN-IP lauschen
ListenAddress 192.168.50.1

sudo sshd -t                  # Syntax prüfen, bevor du neu lädst
sudo systemctl reload ssh

Optional: DHCP/DNS fürs LAN

Damit LAN-Clients automatisch IPs bekommen, installiere dnsmasq und binde es an eth1 mit Range 192.168.50.50–150 und Gateway/DNS 192.168.50.1. Die nötigen Ports 67/68/53 sind im Ruleset oben bereits für das LAN freigegeben.