Raspberry Pi als Residential Proxy für VPS-Server
Raspberry Pi als Residential Proxy: Deine VPS gehen per WireGuard über Deinen Heimanschluss ins Netz, ohne Portfreigabe, mit Leak-Sperre und Uptime Kuma.
Von Nathan Base
Viele Websites blockieren Anfragen aus Rechenzentren inzwischen pauschal, und Dein Scraper auf dem VPS bekommt dann nur noch Captchas oder Fehler 403. Mit einem Raspberry Pi bei Dir zuhause gehen Deine Server stattdessen über Deinen ganz normalen Internetanschluss ins Netz, also mit einer echten Residential-IP. In dieser Anleitung baust Du dafür einen Gateway, der ohne jede Portfreigabe in der FRITZ!Box auskommt, nur für Deine eigenen Server erreichbar ist und technisch verhindert, dass ein Skript versehentlich doch mit der IP des VPS beim Zielserver ankommt.
So funktioniert der Aufbau
Der Trick ist die Richtung der Verbindung. Nicht der VPS verbindet sich zu Dir nach Hause, sondern der Raspberry Pi baut von innen einen verschlüsselten WireGuard-Tunnel zu jedem Deiner VPS auf und hält ihn mit einem kleinen Lebenszeichen alle 25 Sekunden offen. Für die FRITZ!Box ist das eine ganz gewöhnliche ausgehende Verbindung, deshalb brauchst Du keine Portfreigabe. Das funktioniert auch bei DS-Lite-Anschlüssen ohne eigene öffentliche IPv4-Adresse, bei denen eine Portfreigabe gar nicht möglich wäre.
Jedes Bauteil steht dort, wo es am verlässlichsten läuft:
- WireGuard läuft auf dem Pi und auf jedem VPS direkt im System als systemd-Dienst
wg-quick@wg0. Das Kernelmodul ist in Raspberry Pi OS, Debian und Ubuntu enthalten, und der Tunnel kommt nach jedem Neustart von selbst wieder. - Der Proxy gost läuft auf dem Pi in Docker Compose, direkt aus dem offiziellen Image ohne eigenen Build. gost ist ein kleines, aktiv gepflegtes Open-Source-Programm in Go, das HTTP- und SOCKS5-Proxy auf einem Port anbietet. Er lauscht nur auf der Tunneladresse
10.66.0.1, ist also weder aus dem Internet noch aus Deinem Heimnetz erreichbar. - nftables legt auf dem Pi und auf den VPS fest, was über den Tunnel erlaubt ist. Die Dateien für den Pi liegen zusammen mit der Compose-Datei in einem privaten GitHub-Repository.
Abgesichert ist das Ganze in mehreren Schichten, die unabhängig voneinander greifen:
- WireGuard nimmt nur Pakete von Servern an, deren Schlüssel Du eingetragen hast. Auf alles andere antwortet es gar nicht, für Portscanner ist der Port unsichtbar.
- gost verlangt für jeden Server einen eigenen Benutzernamen und ein Passwort.
- nftables auf dem Pi lässt aus dem Tunnel nur den Proxy-Port durch und leitet nichts weiter. Dem Proxy selbst verbietet es alle privaten Netze, die eigene öffentliche IP Deines Anschlusses und die IPs Deiner Server. Selbst ein gekaperter VPS kommt so weder an Deine FRITZ!Box noch an andere Geräte zuhause, an Dienste auf dem Pi oder an Deine anderen Server.
- nftables auf dem VPS sperrt einem eigenen Benutzer für Deine Scraper jeden Weg ins Netz außer dem über den Gateway. Fällt der Gateway aus, schlagen die Anfragen fehl, statt still über die VPS-IP zu laufen.
Die Konfigurationen in dieser Anleitung sind mit gost 3.3.3, WireGuard und nftables in einer nachgestellten Umgebung auf arm64 geprüft, also derselben Architektur wie der Raspberry Pi. Simuliert waren der Pi, zwei VPS, das Heimnetz mit dem DNS der FRITZ!Box und ein Zielserver. Durchgespielt wurden unter anderem 200 gleichzeitige Anfragen von beiden Servern, Neustarts der Tunnel, ein Proxy-Start vor dem Tunnel, Zugriffe ins Heimnetz über IP und über manipulierte DNS-Namen, Zugriffe auf die eigene öffentliche IP und auf die anderen Server sowie Leak-Versuche auf dem VPS.
Was Du brauchst
- Einen Raspberry Pi 4 oder 5 mit Raspberry Pi OS (Trixie), am besten per LAN-Kabel an der FRITZ!Box statt im WLAN. 2 GB RAM reichen. Neu bekommst Du zum Beispiel einen Raspberry Pi 5 (Affiliate Link), ein gebrauchter Raspberry Pi 4 (Affiliate Link) erfüllt den Zweck genauso.
- Docker mit Compose auf dem Pi, nutzbar ohne
sudo. Falls das noch fehlt, hilft Dir die Anleitung Docker auf dem Raspberry Pi installieren und nutzen. - Einen oder mehrere VPS mit Ubuntu 24.04 oder Debian 13 und Root-Zugang per SSH. Wenn Du noch keinen hast, bekommst Du über diesen Link zu DigitalOcean (Affiliate Link) Startguthaben für ein Droplet.
- Ein GitHub-Konto für das private Repository mit der Konfiguration des Pi.
Die Beispiele verwenden das Tunnelnetz 10.66.0.0/24. Der Pi bekommt darin 10.66.0.1, der erste VPS 10.66.0.11, der zweite 10.66.0.12 und so weiter. Falls Du 10.66.x.x schon anderweitig nutzt, nimm ein anderes freies Netz und ersetze die Adressen überall.
Schritt 1: Das Repository anlegen
Leg auf GitHub ein neues, privates Repository mit dem Namen residential-gateway an und klone es auf Deinen Rechner. Ersetze DEIN-NAME durch Deinen GitHub-Benutzernamen.
git clone [email protected]:DEIN-NAME/residential-gateway.git
cd residential-gatewayIns Repository kommen acht kleine Dateien, aber keine Schlüssel und keine Passwörter. Die entstehen später direkt auf dem Pi und verlassen ihn nie. Dafür sorgt als Erstes die Datei .gitignore mit einer einzigen Zeile:
gost.yamlcompose.yaml
services:
proxy:
image: gogost/gost:3.3.3
container_name: residential-proxy
command: ["-C", "/etc/gost/gost.yaml"]
network_mode: host
user: "13128:13128"
read_only: true
tmpfs:
- /tmp
environment:
- HOME=/tmp
cap_drop:
- ALL
security_opt:
- no-new-privileges:true
volumes:
- ./gost.yaml:/etc/gost/gost.yaml:ro
logging:
driver: json-file
options:
max-size: "10m"
max-file: "3"
restart: unless-stoppednetwork_mode: host sorgt dafür, dass gost direkt auf der Tunneladresse des Pi lauschen kann. Der Container läuft unter der festen Benutzer-ID 13128, die es sonst nirgends auf dem Pi gibt. An genau dieser ID erkennt die Firewall später die Pakete des Proxys. Dazu kommen die üblichen Härtungen: schreibgeschütztes Dateisystem, keine Sonderrechte, keine Rechteausweitung. Die Log-Begrenzung schont die Speicherkarte.
Startet Docker beim Hochfahren schneller als WireGuard, findet gost die Adresse 10.66.0.1 noch nicht und beendet sich mit einem Fehler. restart: unless-stopped startet ihn dann so lange neu, bis der Tunnel steht, das dauert nur wenige Sekunden. Startest Du später nur den Tunnel neu, läuft gost einfach weiter.
gost.yaml.example
services:
- name: residential-proxy
addr: "10.66.0.1:8080"
resolver: fritzbox
handler:
type: auto
auther: vps-users
listener:
type: tcp
climiter: max-connections
authers:
- name: vps-users
auths:
- username: vps1
password: PASSWORT_VPS1
resolvers:
- name: fritzbox
nameservers:
- addr: udp://192.168.178.1:53
only: ipv4
climiters:
- name: max-connections
limits:
- "$ 500"
log:
level: info
format: textDer Typ auto erkennt selbst, ob ein Client HTTP oder SOCKS5 spricht. Der Resolver schickt alle DNS-Anfragen des Proxys an die FRITZ!Box, so wie es jedes andere Gerät bei Dir zuhause auch tut, und fragt nur IPv4-Adressen ab. Der Verbindungsbegrenzer lässt höchstens 500 gleichzeitige Verbindungen zu, damit ein außer Kontrolle geratener Scraper den Pi nicht lahmlegt.
wg0.conf.example
Das ist die Vorlage für den Tunnel auf dem Pi:
[Interface]
Address = 10.66.0.1/24
PrivateKey = PI_PRIVATE_KEY
MTU = 1380
FwMark = 0x5157
[Peer]
# vps1
PublicKey = VPS1_PUBLIC_KEY
Endpoint = VPS1_IP:51820
AllowedIPs = 10.66.0.11/32
PersistentKeepalive = 25PersistentKeepalive = 25 ist die Zeile, die den Tunnel ohne Portfreigabe offen hält. Die MTU von 1380 liegt etwas unter dem WireGuard-Standard, damit die Pakete auch bei DSL mit PPPoE und bei DS-Lite ohne Zerstückelung durchpassen. FwMark hängt an jedes verschlüsselte Paket, das WireGuard verschickt, die Markierung 0x5157. Daran erkennt die Firewall die Tunnelpakete zuverlässig, denn der Linux-Kernel rechnet sie sonst dem Programm zu, dessen Daten darin stecken.
residential-gateway.nft
Das ist die Firewall des Pi. Sie steht in einer eigenen Tabelle und lässt alles andere auf dem Pi unberührt, auch die Regeln, die Docker selbst anlegt.
#!/usr/sbin/nft -f
# Firewall fuer den Residential Gateway auf dem Raspberry Pi.
# 13128 ist die Benutzer-ID, unter der der Proxy-Container laeuft.
# 0x5157 ist die Markierung, die WireGuard an seine eigenen Pakete haengt.
table inet residential_gateway
delete table inet residential_gateway
table inet residential_gateway {
# Oeffentliche IPs Deiner VPS, der Proxy soll sie nicht erreichen
set own_servers {
type ipv4_addr
elements = { VPS1_IP }
}
# Aktuelle oeffentliche IP Deines Anschlusses, wird per Timer gefuellt
set wan_ip {
type ipv4_addr
}
# Aus dem Tunnel ist nur der Proxy erreichbar, nichts sonst auf dem Pi
chain input {
type filter hook input priority filter; policy accept;
iifname "wg0" ct state established,related accept
iifname "wg0" ip daddr 10.66.0.1 tcp dport 8080 accept
iifname "wg0" drop
}
# Der Pi routet nichts vom oder in den Tunnel weiter
chain forward {
type filter hook forward priority filter; policy accept;
iifname "wg0" drop
oifname "wg0" drop
}
# Der Proxy darf nur ins oeffentliche Internet und zum DNS der FRITZ!Box
chain output {
type filter hook output priority filter; policy accept;
meta skuid != 13128 accept
meta mark 0x5157 accept
oifname "wg0" ct state established,related accept
ip daddr 192.168.178.1 meta l4proto { tcp, udp } th dport 53 accept
ip daddr @wan_ip reject
ip daddr @own_servers reject
ip daddr {
0.0.0.0/8, 10.0.0.0/8, 100.64.0.0/10, 127.0.0.0/8,
169.254.0.0/16, 172.16.0.0/12, 192.0.0.0/24,
192.168.0.0/16, 198.18.0.0/15, 224.0.0.0/4, 240.0.0.0/4
} reject
meta nfproto ipv6 reject
}
}Die Sperre der privaten Netze sitzt absichtlich in der Firewall und nicht in der Proxy-Konfiguration. gost prüft Sperrlisten laut seiner Dokumentation nur gegen den Hostnamen und nicht gegen die aufgelöste IP. Ein Name, der auf 192.168.178.1 zeigt, käme dort durch, an der Firewall dagegen nicht.
Zwei Sperren sind weniger offensichtlich. Die Liste wan_ip enthält die öffentliche IP Deines Anschlusses, denn über die wäre sonst die FRITZ!Box samt aller Portfreigaben aus dem Heimnetz heraus erreichbar. Die Liste own_servers enthält die IPs Deiner VPS, damit ein gekaperter Server nicht mit Deiner Heim-IP bei den anderen anklopft, etwa an einem SSH-Zugang, den Du nur für zuhause freigegeben hast. Die Firewall blockiert außerdem 127.0.0.0/8, damit niemand über den Proxy an Dienste kommt, die auf dem Pi nur lokal lauschen. IPv6 ist für den Proxy gesperrt, so gehen alle Anfragen mit derselben IPv4-Adresse raus. Die Zeilen mit table und delete table am Anfang sorgen dafür, dass Du die Datei beliebig oft neu laden kannst.
residential-gateway-firewall.service
Dieser systemd-Dienst lädt die Firewall bei jedem Start, bevor das Netzwerk hochkommt. Er folgt demselben Muster wie der nftables-Dienst von Debian:
[Unit]
Description=Firewall fuer den Residential Gateway
DefaultDependencies=no
After=local-fs.target
Wants=network-pre.target
Before=network-pre.target shutdown.target
Conflicts=shutdown.target
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/sbin/nft -f /etc/residential-gateway.nft
ExecStop=/usr/sbin/nft delete table inet residential_gateway
[Install]
WantedBy=sysinit.targetEin eigener Dienst ist hier besser als die Standarddatei /etc/nftables.conf. Die beginnt bei Debian mit flush ruleset und würde beim Laden auch die Regeln löschen, die Docker angelegt hat.
residential-gateway-wanip
Dieses kleine Skript fragt die aktuelle öffentliche IPv4-Adresse ab und trägt sie in die Liste wan_ip ein:
#!/bin/sh
# Traegt die aktuelle oeffentliche IPv4 des Anschlusses in die Sperrliste der Firewall ein.
IP=$(curl -4 -fsS -m 10 https://api.ipify.org) || exit 0
case "$IP" in
""|*[!0-9.]*) exit 0 ;;
esac
nft -f - <<NFT
flush set inet residential_gateway wan_ip
add element inet residential_gateway wan_ip { $IP }
NFTLeeren und neu befüllen passieren in einem Schritt, die Liste ist also nie kurz leer. Liefert der Abfragedienst einmal Unsinn oder gar nichts, bleibt der alte Eintrag stehen.
residential-gateway-wanip.service und .timer
Damit das Skript alle 30 Sekunden läuft und eine neue IP nach einer Zwangstrennung schnell gesperrt ist, brauchst Du einen Dienst und einen Timer. Die Datei residential-gateway-wanip.service:
[Unit]
Description=Oeffentliche IP fuer die Gateway-Firewall aktualisieren
Requires=residential-gateway-firewall.service
After=residential-gateway-firewall.service network-online.target
Wants=network-online.target
[Service]
Type=oneshot
ExecStart=/usr/local/sbin/residential-gateway-wanipDie Datei residential-gateway-wanip.timer:
[Unit]
Description=Oeffentliche IP regelmaessig pruefen
[Timer]
OnBootSec=20s
OnUnitActiveSec=30s
AccuracySec=5s
[Install]
WantedBy=timers.targetDas Skript muss ausführbar sein, und Git merkt sich das, wenn Du es vor dem Commit setzt. Danach schickst Du alles zu GitHub:
chmod +x residential-gateway-wanip
git add .
git commit -m "Residential Gateway"
git pushSchritt 2: Pakete, Repository und Schlüssel auf dem Pi
Melde Dich per SSH auf dem Pi an und installiere Git, curl, die WireGuard-Werkzeuge und nftables:
sudo apt update
sudo apt install git curl wireguard-tools nftablesDamit der Pi Dein privates Repository lesen kann, bekommt er einen eigenen SSH-Schlüssel, den Du bei GitHub als Deploy Key einträgst. Ein Deploy Key gilt nur für dieses eine Repository und darf ohne ausdrückliche Freigabe nur lesen.
ssh-keygen -t ed25519 -f ~/.ssh/github_gateway -N "" -C "residential-gateway"
cat ~/.ssh/github_gateway.pubKopiere die ausgegebene Zeile und füge sie im Repository unter Settings > Deploy keys > Add deploy key ein. Den Haken bei Allow write access lässt Du weg. Öffne danach mit nano ~/.ssh/config die SSH-Konfiguration auf dem Pi und trage ein:
Host github.com
IdentityFile ~/.ssh/github_gateway
IdentitiesOnly yesSpeichere mit Strg + O, bestätige mit Enter und schließe den Editor mit Strg + X. Jetzt klonst Du das Repository. Beim ersten Kontakt fragt SSH, ob Du dem Schlüssel von GitHub vertraust, das bestätigst Du mit yes.
git clone [email protected]:DEIN-NAME/residential-gateway.git ~/residential-gatewayZum Schluss erzeugst Du das Schlüsselpaar des Pi und lässt Dir beide Hälften anzeigen:
sudo sh -c 'umask 077; wg genkey > /etc/wireguard/pi.key'
sudo cat /etc/wireguard/pi.key
sudo sh -c 'wg pubkey < /etc/wireguard/pi.key'Die erste ausgegebene Zeile ist der private Schlüssel des Pi, die zweite der öffentliche. Den öffentlichen brauchst Du gleich auf dem VPS.
Schritt 3: WireGuard auf dem VPS einrichten
Melde Dich per SSH am VPS an und installiere dieselben Werkzeuge:
sudo apt update
sudo apt install curl wireguard-tools nftablesErzeuge das Schlüsselpaar des VPS:
sudo sh -c 'umask 077; wg genkey > /etc/wireguard/vps.key'
sudo cat /etc/wireguard/vps.key
sudo sh -c 'wg pubkey < /etc/wireguard/vps.key'Leg mit sudo nano /etc/wireguard/wg0.conf die Tunnelkonfiguration an:
[Interface]
Address = 10.66.0.11/24
ListenPort = 51820
PrivateKey = VPS1_PRIVATE_KEY
MTU = 1380
FwMark = 0x5157
[Peer]
# Raspberry Pi zuhause
PublicKey = PI_PUBLIC_KEY
AllowedIPs = 10.66.0.1/32Ersetze VPS1_PRIVATE_KEY durch den privaten Schlüssel des VPS und PI_PUBLIC_KEY durch den öffentlichen Schlüssel des Pi. Ein Endpoint für den Pi fehlt hier absichtlich, denn der VPS kennt Deine Heim-IP nicht und muss sie auch nicht kennen. Er lernt die aktuelle Adresse aus den Paketen, die der Pi schickt, auch nach einer Zwangstrennung mit neuer IP. Speichere, schließe den Editor, schütze die Datei vor fremden Blicken und starte den Tunnel dauerhaft:
sudo chmod 600 /etc/wireguard/wg0.conf
sudo systemctl enable --now wg-quick@wg0Gib zum Schluss den UDP-Port frei. Wenn Du ufw nutzt, geht das so:
sudo ufw allow 51820/udpHat Dein Hoster zusätzlich eine Cloud-Firewall, etwa die Cloud Firewall bei DigitalOcean, musst Du dort ebenfalls eingehend UDP 51820 erlauben. Wie Du den Rest des Servers absicherst, zeigt die Anleitung Linux-Server absichern: SSH-Schlüssel, ufw, fail2ban.
Schritt 4: Tunnel, Firewall und Proxy auf dem Pi starten
Zurück auf dem Pi prüfst Du zuerst, unter welcher Adresse Deine FRITZ!Box im Heimnetz erreichbar ist:
ip route show defaultDie Ausgabe beginnt mit default via 192.168.178.1, das ist die Standardadresse der FRITZ!Box. Steht bei Dir eine andere Adresse, ersetzt Du 192.168.178.1 gleich in gost.yaml und in /etc/residential-gateway.nft durch Deine.
Tunnel einrichten
Kopiere die Vorlage an ihren Platz und öffne sie:
cd ~/residential-gateway
sudo install -m 600 wg0.conf.example /etc/wireguard/wg0.conf
sudo nano /etc/wireguard/wg0.confErsetze PI_PRIVATE_KEY durch den privaten Schlüssel des Pi, VPS1_PUBLIC_KEY durch den öffentlichen Schlüssel des VPS und VPS1_IP durch dessen öffentliche IPv4-Adresse. Nimm hier wirklich die IP und keinen Hostnamen, denn WireGuard löst Namen nur einmal beim Start auf. Dann startest Du den Tunnel dauerhaft:
sudo systemctl enable --now wg-quick@wg0Firewall aktivieren
Kopiere die Firewall, das Skript und die drei systemd-Dateien an ihren festen Platz:
sudo install -m 644 residential-gateway.nft /etc/residential-gateway.nft
sudo install -m 755 residential-gateway-wanip /usr/local/sbin/
sudo install -m 644 residential-gateway-firewall.service residential-gateway-wanip.service residential-gateway-wanip.timer /etc/systemd/system/Öffne mit sudo nano /etc/residential-gateway.nft die Firewall und ersetze VPS1_IP durch die öffentliche IP des VPS, bei abweichender FRITZ!Box-Adresse auch 192.168.178.1. Danach aktivierst Du Firewall und Timer:
sudo systemctl daemon-reload
sudo systemctl enable --now residential-gateway-firewall.service
sudo systemctl enable --now residential-gateway-wanip.timerNach etwa einer halben Minute zeigt sudo nft list set inet residential_gateway wan_ip unter elements die öffentliche IP Deines Anschlusses. Bei DS-Lite ist das die gemeinsam genutzte Adresse Deines Providers, die Sperre schadet dort nicht.
Proxy konfigurieren und starten
Für jeden VPS erzeugst Du ein langes Zufallspasswort:
openssl rand -hex 24Lege die echte Konfiguration aus der Vorlage an, trage das Passwort statt PASSWORT_VPS1 ein und gib die Datei dem Benutzer des Proxys, damit nur er sie lesen kann:
cp gost.yaml.example gost.yaml
nano gost.yaml
sudo chown 13128:13128 gost.yaml
sudo chmod 600 gost.yamlEin Passwort aus Hexadezimalzeichen hat den Vorteil, dass Du es ohne Kodierung in eine Proxy-URL schreiben kannst. Spätere Änderungen an gost.yaml machst Du mit sudo nano gost.yaml. Jetzt startest Du den Proxy:
docker compose up -d
docker compose logs --tail 5Erfolgreich ist der Start, wenn in den Logs listening on 10.66.0.1:8080/tcp steht.
Schritt 5: Prüfen, ob wirklich Deine Heim-IP ankommt
Wechsle auf den VPS und schau zuerst, ob der Tunnel steht:
sudo wg showUnter dem Peer muss eine Zeile latest handshake mit einer Zeitangabe von wenigen Sekunden oder Minuten stehen. Fehlt sie, findest Du die Ursache weiter unten bei den Fehlern. Jetzt der eigentliche Test, einmal ohne und einmal mit Proxy:
curl -4 https://api.ipify.org
curl -x http://vps1:[email protected]:8080 https://api.ipify.orgDer erste Befehl zeigt die IP des VPS, der zweite die Deines Heimanschlusses. Vergleichen kannst Du sie mit der IPv4-Adresse, die die FRITZ!Box unter Internet > Online-Monitor anzeigt. Bei einem DS-Lite-Anschluss steht dort keine eigene IPv4-Adresse, dann siehst Du die gemeinsam genutzte Adresse Deines Providers, die ebenfalls als Residential-IP gilt. Statt http:// funktioniert genauso socks5h:// als Schema. Das h ist dabei wichtig, denn nur so löst der Pi die Hostnamen auf und nicht der VPS.
Header wie X-Forwarded-For oder Via, die die ursprüngliche Adresse verraten könnten, setzt gost nicht. Bei HTTPS-Seiten sieht der Proxy ohnehin nur die verschlüsselte Verbindung. Ein Abruf Deiner FRITZ!Box über den Proxy muss dagegen scheitern, probier es aus:
curl -m 10 -x http://vps1:[email protected]:8080 http://192.168.178.1Nach zehn Sekunden bricht curl mit Operation timed out ab, die Firewall des Pi hat die Verbindung abgewiesen.
Schritt 6: Leaks auf dem VPS technisch ausschließen
Ein Proxy in einer Umgebungsvariable ist eine Bitte, keine Garantie. Ein Paket, das die Variable ignoriert, ein Kommandozeilen-Tool oder ein Headless-Browser, der per UDP und QUIC arbeitet, und schon geht eine Anfrage direkt mit der VPS-IP raus. Deshalb laufen Deine Scraper unter einem eigenen Benutzer, dem nftables jeden anderen Weg verbaut:
sudo useradd -m -s /bin/bash scraperLeg mit sudo nano /etc/gateway-client.nft die Regeln an:
#!/usr/sbin/nft -f
# Firewall auf dem VPS: Tunnel nur ausgehend nutzbar, Benutzer "scraper" nur ueber den Gateway.
# 0x5157 ist die Markierung, die WireGuard an seine eigenen Pakete haengt.
table inet gateway_client
delete table inet gateway_client
table inet gateway_client {
# Vom Pi aus ist auf dem VPS nichts erreichbar
chain input {
type filter hook input priority filter; policy accept;
iifname "wg0" ct state established,related accept
iifname "wg0" drop
}
# Der Benutzer "scraper" kommt nur ueber den Proxy ins Netz
chain output {
type filter hook output priority filter; policy accept;
meta skuid != "scraper" accept
meta mark 0x5157 accept
oifname "lo" accept
oifname "wg0" ip daddr 10.66.0.1 tcp dport 8080 accept
counter reject
}
}Alle anderen Benutzer bleiben unberührt. Für scraper ist nur noch der Proxy im Tunnel erlaubt, alles andere über IPv4 und IPv6 wird sofort abgewiesen, auch UDP. Die Zeile mit meta mark 0x5157 lässt die verschlüsselten Tunnelpakete durch, die der Kernel sonst ebenfalls scraper zurechnen würde. Setzen kann diese Markierung nur ein Prozess mit Root-Rechten, scraper also nicht. Die Eingangsregel sorgt nebenbei dafür, dass der Pi umgekehrt keine Dienste auf dem VPS erreicht.
Zwei Dinge gehören noch dazu. scraper darf nicht in der Gruppe docker sein, denn wer Docker steuert, hat praktisch Root-Rechte und könnte die Sperre umgehen. Und DNS-Abfragen über lo bleiben erlaubt, weil viele Programme lokale Dienste brauchen. Die Zielseite sieht dadurch nie die VPS-IP, höchstens der DNS-Server Deines Hosters erfährt einen Namen. Mit http:// oder socks5h:// als Proxy-Schema löst ohnehin der Pi die Namen auf.
Damit die Regeln nach jedem Neustart greifen, legst Du mit sudo nano /etc/systemd/system/gateway-client-firewall.service einen Dienst nach demselben Muster wie auf dem Pi an:
[Unit]
Description=Firewall fuer den Gateway-Client
DefaultDependencies=no
After=local-fs.target
Wants=network-pre.target
Before=network-pre.target shutdown.target
Conflicts=shutdown.target
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/sbin/nft -f /etc/gateway-client.nft
ExecStop=/usr/sbin/nft delete table inet gateway_client
[Install]
WantedBy=sysinit.targetAktiviere ihn und prüf gleich die Wirkung:
sudo systemctl daemon-reload
sudo systemctl enable --now gateway-client-firewall.service
sudo -u scraper curl -m 10 https://api.ipify.org
sudo -u scraper curl -m 10 -x http://vps1:[email protected]:8080 https://api.ipify.orgDer direkte Abruf muss scheitern, je nach DNS-Einrichtung des VPS mit Failed to connect oder Could not resolve host. Der Abruf über den Proxy liefert Deine Heim-IP. Damit ist sichergestellt: Was als scraper läuft, kommt entweder über den Gateway beim Ziel an oder gar nicht.
Schritt 7: Den Proxy in Deinen Skripten nutzen
Die meisten Werkzeuge lesen die Umgebungsvariablen HTTP_PROXY und HTTPS_PROXY. In Python mit requests gibst Du den Proxy am besten trotzdem ausdrücklich an:
import requests
proxy = "http://vps1:[email protected]:8080"
r = requests.get(
"https://api.ipify.org",
proxies={"http": proxy, "https": proxy},
timeout=20,
)
print(r.text)Für Playwright übergibst Du den Proxy beim Start des Browsers und nimmst dabei das HTTP-Schema, denn Chromium unterstützt bei SOCKS5-Proxys keine Anmeldung mit Passwort:
browser = p.chromium.launch(
proxy={"server": "http://10.66.0.1:8080", "username": "vps1", "password": "DEIN_PASSWORT"},
args=["--force-webrtc-ip-handling-policy=disable_non_proxied_udp"],
)Das zusätzliche Argument verhindert, dass WebRTC im Browser Adressen am Proxy vorbei meldet. Läuft Dein Scraper in Docker auf dem VPS, gilt die nftables-Sperre nur, wenn der Container mit network_mode: host und user: mit der Benutzer-ID von scraper startet (die zeigt Dir id -u scraper), denn sonst laufen seine Pakete nicht als dieser Benutzer.
Mehrere Server gleichzeitig sind kein Problem. Jeder bekommt seinen eigenen Tunnel und seinen eigenen Proxy-Benutzer, und gost verarbeitet die Anfragen parallel. Im Test liefen 200 Anfragen von zwei Servern mit je 50 gleichzeitigen Verbindungen ohne einen einzigen Fehler durch. Die Grenze setzt in der Praxis eher die Bandbreite Deines Anschlusses. Gute Gewohnheiten wie Wiederholversuche mit Pause beschreibt der Artikel Robuste API-Aufrufe in Python: Timeouts, Retries, Logging, und die gelten für Scraper genauso.
Schritt 8: Den Gateway mit Uptime Kuma überwachen
Ein Monitor, der nur prüft, ob der Pi erreichbar ist, hilft hier wenig. Entscheidend ist, ob eine Anfrage wirklich mit Deiner Heim-IP ankommt. Genau das kann Uptime Kuma selbst prüfen, denn jeder HTTP-Monitor darf über einen Proxy laufen. Die Menünamen unten stammen aus Version 2.5. Voraussetzung ist, dass Uptime Kuma auf einem Deiner VPS mit Tunnel läuft, gern auch in Docker. Läuft es woanders, bindest Du diesen Server einfach wie einen weiteren VPS an. Falls Du Uptime Kuma noch nicht hast, hilft Uptime Kuma einrichten: Websites und Dienste überwachen.
- Klicke in Uptime Kuma auf
Neuen Monitor hinzufügenund wähle alsMonitortypden EintragHTTP(s) - Schlüsselwort. - Trage als URL
https://api.ipify.orgein und alsSchlüsselwortdie öffentliche IP des VPS, auf dem Uptime Kuma läuft. Die zeigt Dircurl -4 https://api.ipify.orgauf diesem Server. - Setz den Haken bei
Schlüsselwort invertieren. Der Monitor gilt damit nur als erreichbar, wenn die VPS-IP in der Antwort nicht vorkommt. - Klicke im Abschnitt
ProxyaufProxy einrichten. Wähle alsProxy-Protokollden EintragHTTP, trage alsProxy-Server10.66.0.1und als Port8080ein, aktiviereProxy-Server erfordert Authentifizierungund gib Benutzernamen und Passwort des VPS ein. - Stell das
Heartbeat-Intervallauf 60 Sekunden und dieWiederholungenauf 2, dann klicke aufSpeichern.
Der Monitor schlägt jetzt Alarm, wenn der Gateway nicht antwortet oder wenn die Anfrage doch mit der IP dieses VPS ankommt. Er prüft damit den Weg von genau einem Server. Dass die Scraper auf allen anderen VPS nicht an der Sperre vorbeikommen, stellt die nftables-Regel aus Schritt 6 sicher, nicht der Monitor. Die zwei Wiederholungen verhindern Fehlalarme bei der täglichen Zwangstrennung mancher Anschlüsse. Läuft Uptime Kuma in Docker, braucht es nichts Besonderes: Docker leitet die Anfragen des Containers an 10.66.0.1 über den Tunnel des VPS weiter.
Einen weiteren Server anbinden
Für jeden zusätzlichen VPS wiederholst Du Schritt 3 mit der nächsten Adresse, also 10.66.0.12/24 in dessen wg0.conf, und richtest dort auch Schritt 6 ein. Auf dem Pi ergänzt Du mit sudo nano /etc/wireguard/wg0.conf einen weiteren Block:
[Peer]
# vps2
PublicKey = VPS2_PUBLIC_KEY
Endpoint = VPS2_IP:51820
AllowedIPs = 10.66.0.12/32
PersistentKeepalive = 25Mit diesem Befehl übernimmt WireGuard den neuen Peer, ohne die bestehenden Tunnel zu trennen:
sudo bash -c 'wg syncconf wg0 <(wg-quick strip wg0)'Trag die öffentliche IP des neuen Servers in /etc/residential-gateway.nft zusätzlich unter own_servers ein, etwa als elements = { VPS1_IP, VPS2_IP }, und lade die Firewall mit sudo systemctl restart residential-gateway-firewall.service neu. Die Liste wan_ip füllt der Timer danach innerhalb einer halben Minute wieder. In gost.yaml bekommt der neue Server unter auths einen eigenen Benutzer vps2 mit eigenem Passwort, danach startest Du den Proxy mit docker compose restart neu.
Musst Du einen Server aufgeben oder hältst ihn für kompromittiert, löschst Du einfach seinen Peer-Block und seinen Proxy-Benutzer.
Updates und laufender Betrieb
WireGuard und nftables aktualisierst Du auf Pi und VPS ganz normal mit sudo apt update und sudo apt upgrade. Für gost trägst Du eine neue Version in compose.yaml ein, sobald auf der Release-Seite von gost eine erscheint, und schickst die Änderung zu GitHub. Auf dem Pi holst Du sie dann ab:
cd ~/residential-gateway
git pull
docker compose pull
docker compose up -dÄnderst Du eine der Systemdateien im Repository, kopierst Du sie nach dem git pull wie in Schritt 4 an ihren Platz und lädst sie neu. Bei residential-gateway.nft musst Du dabei Deine eingetragenen IPs erneut einsetzen. Für einen jahrelangen Dauerbetrieb lohnen sich ein ordentliches Netzteil und eine SSD statt der Speicherkarte. Wie das geht, steht in Raspberry Pi 5 von NVMe-SSD booten statt microSD-Karte.
Bei einer Zwangstrennung der FRITZ!Box bekommt Dein Anschluss eine neue IP. Der Pi sendet weiter seine Lebenszeichen, und der VPS übernimmt die neue Adresse mit dem nächsten Paket automatisch. Startet umgekehrt ein VPS neu, baut der Pi den Tunnel von selbst wieder auf, das dauert zwei bis drei Minuten. Baue in Deine Skripte deshalb Wiederholversuche ein, statt bei einem einzelnen Fehler abzubrechen. Den Fernzugriff auf die FRITZ!Box über das Internet brauchst Du für diesen Aufbau nicht. Wenn Du ihn nicht anderweitig nutzt, schalte ihn ab, das ist eine Angriffsfläche weniger.
Wenn es nicht klappt
- Kein
latest handshakeauf dem VPS: Meist ist UDP 51820 auf dem VPS gesperrt, in ufw oder in der Cloud-Firewall des Hosters. Prüf außerdem, ob auf beiden Seiten jeweils der öffentliche Schlüssel der Gegenseite eingetragen ist und obEndpointauf dem Pi die richtige IP enthält.sudo systemctl status wg-quick@wg0zeigt Tippfehler in der Konfiguration. - Die Firewall startet nicht: Meldet
sudo systemctl status residential-gateway-firewall.serviceden FehlerCould not resolve hostname, steht in/etc/residential-gateway.nftnoch der PlatzhalterVPS1_IP. - Der Proxy startet ständig neu: Steht in
docker compose logsdie Meldungcannot assign requested address, ist der Tunnel auf dem Pi nicht aktiv. Sobaldwg-quick@wg0läuft, fängt sich gost von selbst. Beipermission deniedaufgost.yamlfehlt daschownaus Schritt 4. - Fehler 407: Benutzername oder Passwort stimmen nicht. Sonderzeichen im Passwort müssen in einer Proxy-URL kodiert werden, deshalb das Hex-Passwort.
- Jede Anfrage läuft in einen Timeout: Prüf, ob die Adresse der FRITZ!Box in
gost.yamlund in/etc/residential-gateway.nftmit der Ausgabe vonip route show defaultübereinstimmt. Sonst kann der Proxy keine Namen auflösen. - Kleine Seiten laden, große HTTPS-Seiten hängen: Das ist ein MTU-Problem. Setz die
MTUauf dem Pi und auf dem VPS auf1280und starte den Tunnel auf beiden Seiten neu.
Fazit
Mit einem Raspberry Pi, WireGuard und gost hast Du einen eigenen Residential Proxy, der nichts kostet, keine Portfreigabe braucht und für niemanden außer Deinen Servern existiert. Jedes Bauteil läuft dort, wo es hingehört: der Tunnel als Systemdienst, der Proxy als gehärteter Container aus dem offiziellen Image, die Regeln in nftables. Schlüssel, Passwort, die Sperren auf dem Pi und die nftables-Regel auf dem VPS greifen dabei unabhängig voneinander. Bedenke nur, dass alles, was Deine Skripte über diesen Weg abrufen, bei den Zielseiten unter Deinem Anschluss auftaucht. Halte Dich an die Nutzungsbedingungen und an robots.txt, bleib bei moderaten Abrufraten und gib den Zugang nicht an andere weiter. Dann bleibt Deine Heim-IP auch für Dich selbst sauber.
Weiterlesen.
-
Raspberry Pi & LinuxDocker auf dem Raspberry Pi installieren und nutzen
Docker und Docker Compose auf dem Raspberry Pi sauber aus dem offiziellen Repository installieren, ersten Stack mit Uptime Kuma starten und Fehler lösen.
Nathan Base -
Selfhosting & WebUptime Kuma einrichten: Websites und Dienste überwachen
Uptime Kuma 2 mit Docker Compose installieren, Websites und SSL-Zertifikate überwachen, per ntfy oder Telegram alarmieren und eine Statusseite anlegen.
Nathan Base -
Raspberry Pi & LinuxLinux-Server absichern: SSH-Schlüssel, ufw, fail2ban
Neuen Linux-Server absichern, ohne Dich auszusperren: SSH-Schlüssel, Passwort-Login aus, ufw, die Docker-Falle, fail2ban und automatische Updates.
Nathan Base -
Raspberry Pi & LinuxTailscale Exit Node: unterwegs über den Pi surfen
Raspberry Pi als Tailscale Exit Node: im Hotel-WLAN sicher über den eigenen Anschluss surfen und Pi-hole auch unterwegs auf dem iPhone nutzen.
Nathan Base -
Raspberry Pi & LinuxFRITZ!Box-VPN mit WireGuard: iPhone und Mac verbinden
So richtest Du an der FRITZ!Box ein WireGuard-VPN ein, verbindest iPhone, Android und Mac per QR-Code oder Datei und löst DS-Lite- und Handshake-Probleme.
Nathan Base -
Raspberry Pi & LinuxHeimnetz-Geschwindigkeit messen mit iperf3: LAN und WLAN
Mit iperf3 misst Du das Tempo zwischen zwei Geräten im Heimnetz, findest Engpässe bei LAN-Kabel, Repeater oder NAS und liest die Ausgabe richtig.
Nathan Base