Hallo! Interessiert an der Welt des Remote-Zugriffs über SSH? In den letzten Beiträgen haben wir über SSH Keygen, die grundlegenden Befehle und das lokale Port-Forwarding (-L Option) gesprochen. Heute konzentrieren wir uns auf eine weitere mächtige Funktion von SSH, das Reverse Port Forwarding, also die -R Option.

Während die -L Option "einen Tunnel von meinem Computer nach außen zu Ressourcen aufbauen" bedeutet, ist die -R Option das Gegenteil. Sie ermöglicht es, "einen Tunnel von einem externen Computer zu meinem Computer aufzubauen", um auf interne Ressourcen zuzugreifen, vergleichbar mit dem Erstellen einer Tür in einer Wand.

Was ist Reverse Port Forwarding? (Überblick über die -R Option)

Es ist normalerweise schwierig, direkt von einem Remote-Server (Server A) auf einen lokalen Computer (Client B) zuzugreifen. Dies liegt oft daran, dass Client B eine private IP-Adresse verwendet, sich hinter einer Firewall befindet oder keine feste IP hat.

In solchen Fällen ermöglicht es das Reverse Port Forwarding (-R Option), dass Client B versucht, sich über SSH mit Server A zu verbinden, während gleichzeitig ein Tunnel zu Server A hergestellt wird, um Anfragen, die an einen bestimmten Port von Server A gerichtet sind, an einen bestimmten Port von Client B weiterzuleiten.

Einfach gesagt:

  1. Client B (mein Computer) versucht, sich mit Server A (externer Server) über SSH zu verbinden.
  2. Dabei verwendet er die -R Option und sagt: "Leite die Anfragen, die an den X-Port von Server A kommen, an den Y-Port meines Computers (Client B) weiter!"
  3. Wenn jetzt ein anderer externer Benutzer auf den X-Port von Server A zugreift, wird diese Anfrage über den SSH-Tunnel an den Y-Port von Client B weitergeleitet.

Es ist fast so, als ob Client B Server A bittet, "eine Tür zu erstellen, über die man mich erreichen kann".

SSH Reverse Port Forwarding Diagramm: Struktur, in der externe Anfragen über den Server an lokal weitergeleitet werden

-R Befehlssyntax

Die grundlegende Befehlssyntax für Reverse Port Forwarding lautet:

ssh -R [remote_port]:[target_host]:[target_port] [remote_server_user]@[remote_server_address]

Lass uns jedes Element näher betrachten:

  • ssh: Der Befehl zum Ausführen des SSH-Clients.
  • -R: Die Option für Reverse Port Forwarding.
  • [remote_port]: Die Portnummer des Remote-Servers (Server A), über die der Tunnel eingerichtet wird. Wenn ein externer Benutzer auf diesen Port zugreift, wird er mit den Ressourcen von Client B verbunden.
  • [target_host]: Der [remote_server_user]@[remote_server_address] greift zu, um die Host-Name oder IP-Adresse der Ressourcen, auf die innerhalb von Client B (mein Computer) zugegriffen wird, zu bestimmen. Meistens ist es localhost (d.h. Client B selbst).
  • [target_port]: Die Portnummer des offenen Dienstes innerhalb von Client B (mein Computer). Dies ist der finale Punkt, zu dem eingehende Anfragen gelangen.
  • [remote_server_user]@[remote_server_address]: Das Benutzerkonto und die Adresse des externen Servers (Server A), zu dem der Tunnel verbunden werden soll. Dies ist der Weg, wie Client B sich mit Server A verbindet.

Beispiel:

Wenn ich über den 8888-Port eines externen Servers (Server A) auf den port 8080 meines lokalen Computers (Client B) zugreifen möchte:

# Ausführen auf Client B (mein Computer)
ssh -R 8888:localhost:8080 user@server_a_public_ip

Wenn dieser Befehl erfolgreich ausgeführt wird, bin ich verbunden mit server_a_public_ip über SSH. Wenn man jetzt von einem anderen Computer http://server_a_public_ip:8888 aufruft, wird man tatsächlich auf den Port 8080 von Client B zugreifen.

Wann ist Reverse Port Forwarding nützlich? (Einsatz während der Entwicklungsphase)

Reverse Port Forwarding erweist sich als sehr mächtig in spezifischen Situationen, die mit einer gewöhnlichen SSH-Verbindung schwer zu lösen sind. Es kann besonders nützlich während des Entwicklungsprozesses sein.

1. Lokale Entwicklungsserver hinter NAT/Firewalls freigeben

  • Problemstellung: Sie haben eine Webanwendung (z.B. läuft unter localhost:3000), die Sie während der Entwicklung in einem internen Netzwerk oder zu Hause aufbauen. Sie möchten dieser Anwendung jedoch Teamkollegen oder Kunden von außen zeigen, doch Ihr Computer hat eine private IP-Adresse und ist nicht direkt zugänglich. Router- oder Firewall-Einstellungen können kompliziert sein und eine Genehmigung vom Administrator erfordern.
  • Lösung: Sie können Ihren lokalen Entwicklungsserver über einen externen Server mit Public IP (z.B. AWS EC2-Instanz, VPS) zugänglich machen.
# Auf meinem lokalen Entwicklungsrechner (Client B) ausführen
ssh -R 80:localhost:3000 your_user@your_public_server.com
# Oder den Port 80 verwenden, der Root-Rechte benötigt, und einen anderen Port verwenden (z.B. 8080)
ssh -R 8080:localhost:3000 your_user@your_public_server.com

Nun, wenn Sie `your_public_server.com:8080` aufrufen, gelangen Sie tatsächlich zu Ihrer lokal laufenden Webanwendung (`localhost:3000`). Sie können jetzt den Fortschritt Ihrer Entwicklung in Echtzeit extern verfolgen.

2. Webhook-Tests

  • Problemstellung: Sie möchten Webhook-Ereignisse von Zahlungssystemen, Git-Repositories (GitHub/GitLab), Messaging-Plattformen usw. lokal testen. Webhook können jedoch nur an eine öffentliche URL gesendet werden.
  • Lösung: Ersetzen Sie Ihren lokalen Webhook-Endpunkt (z.B. localhost:5000/webhook) durch den spezifischen URL einer öffentlichen Server-URL über Reverse Port Forwarding.
# Auf meinem lokalen Entwicklungsrechner (Client B) ausführen
ssh -R 5000:localhost:5000 your_user@your_public_server.com

Jetzt können Sie `http://your_public_server.com:5000/webhook` in den Webhook-Einstellungen eingeben, und das Webhook-Ereignis wird zu Ihrem lokalen Server weitergeleitet für Tests.

3. Direkter Zugriff auf spezifische Ports eines Remote-Servers (Umgehung von Sicherheitsnetzwerken)

  • Problemstellung: Sie wollen auf eine Datenbank oder interne Verwaltungstools (z.B. läuft auf localhost:9000) auf einem bestimmten Remote-Server (Client B) zugreifen. Der Zugriff auf diesen Server ist jedoch wegen der Firewall auf externe Ports eingeschränkt oder liegt in einem privaten Netzwerk. Aber Client B kann sich mit einem externen öffentlichen Server (Server A) über SSH verbinden.
  • Lösung: Client B stellt eine SSH-Verbindung zu Server A her und fordert via Reverse Port Forwarding: "Schaffe einen Zugang zu meinem 9000-Port".
# Ausführen auf Client B (Server hinter einer Firewall)
ssh -R 9000:localhost:9000 your_user@server_a_public_ip

Wenn Sie jetzt `server_a_public_ip:9000` von Ihrem Computer (oder einem anderen externer Computer) aufrufen, gelangen Sie zu den Diensten auf Port 9000 von Client B.

4. Temporäre Demos oder Sharing

  • Problemstellung: Sie möchten einem Kollegen zeigen, wie eine spezifische Anwendung, die lokal läuft, funktioniert oder möchten es nur kurz extern veröffentlichen, um Feedback zu erhalten.
  • Lösung: Mit einfacher Reverse Port Forwarding kann man für einen bestimmten Zeitraum lokale Services extern freigeben. Nachdem die Demo abgeschlossen ist, können Sie die SSH-Sitzung beenden und den Zugang blockieren.

Wichtige Hinweise zur Nutzung von Reverse Port Forwarding

  • GatewayPorts yes: Die über Reverse Port Forwarding geöffneten entfernten Ports sind standardmäßig nur auf der Maschine zugänglich, auf der der SSH-Server (server_a_public_ip) ausgeführt wird. Wenn Sie anderen Computern außerhalb des SSH-Servers den Zugriff auf diesen Port ermöglichen möchten, müssen Sie die GatewayPorts yes Konfiguration in der sshd_config-Datei des SSH-Servers hinzufügen und den SSH-Dienst neu starten. (Diese Einstellung kann Sicherheitsimplikationen haben, daher sollten Sie vorsichtig damit umgehen.)

  • Sicherheit: Reverse Port Forwarding stellt einen bestimmten Port des lokalen Netzwerks nach außen zur Verfügung, daher sollte es nur auf vertrauenswürdigen Servern verwendet werden. Überprüfen Sie im Voraus die Sicherheitsanfälligkeiten der exponierten Dienste.

  • SSH-Sitzung aufrechterhalten: Der Reverse Port Forwarding Tunnel ist nur während der Aufrechterhaltung der SSH-Sitzung gültig. Wenn Sie es im Hintergrund ausführen möchten, ist es üblich, ssh -fN -R ... zu verwenden, wobei die Optionen f (im Hintergrund ausführen) und N (keine Remote-Befehle ausführen) kombiniert werden.

Fazit

SSH Reverse Port Forwarding (-R Option) ist eine sehr nützliche Funktion, wenn man bestimmte Dienste in komplexen Netzwerkumgebungen oder hinter Firewalls nach außen verfügbar machen muss. Insbesondere während der Entwicklungsphase kann es ein starkes Produktivitätswerkzeug sein, um lokal Umgebungen extern zu teilen oder Webhook-Tests durchzuführen.

Falls dieses Konzept schwer zu verstehen war, ist es am besten, es tatsächlich auszuprobieren und zu lernen. Nutzen Sie SSH Reverse Port Forwarding aktiv in Ihrem Entwicklungsworkflow!

Wenn Sie Fragen haben, hinterlassen Sie gerne einen Kommentar!