Hallo! De wereld van externe toegang met SSH, klinkt interessant, toch? In de vorige berichten hebben we het gehad over SSH keygen, de basiscommando's voor toegang en lokale poortdoorsturing (-L optie). Dit keer richten we ons op een andere krachtige functie van SSH, namelijk Reverse Port Forwarding, oftewel de -R optie.

-L optie betekent "een tunnel van mijn computer naar buiten maken voor toegang tot externe bronnen", terwijl de -R optie het tegenovergestelde is. Het stelt ons in staat om "een tunnel van een externe computer naar mijn computer te maken voor toegang tot interne bronnen", alsof je een deur in de muur creëert.

Wat is Reverse Port Forwarding? (Overzicht van -R optie)

Over het algemeen is het moeilijk om direct toegang te krijgen vanaf een externe server (Server A) naar een lokale computer (Client B). Dit komt doordat Client B meestal een privéadres gebruikt, zich achter een firewall bevindt of geen statisch IP heeft.

In dit geval, door gebruik te maken van reverse port forwarding (-R optie), kan Client B SSH-toegang aanvragen naar Server A en tegelijkertijd een tunnel openen om verzoeken die binnenkomen op een bepaalde poort van Server A door te sturen naar een specifieke poort van Client B.

In het kort:

  1. Client B (mijn computer) probeert verbinding te maken met Server A (externe server) via SSH.
  2. Bij deze verbinding gebruiken we de -R optie en geven het commando: "Stuur verzoeken die binnenkomen op poort X van Server A naar poort Y van mijn computer (Client B)!".
  3. Nu, wanneer een andere externe gebruiker verbinding maakt met Server A op poort X, wordt dat verzoek doorgestuurd naar Client B op poort Y via de SSH-tunnel.

Het is alsof Client B aan Server A vraagt: "Maak een deur zodat ik verbonden kan worden".

SSH Reverse Port Forwarding Flowchart: structuur van externe verzoeken die via de server naar lokaal worden doorgestuurd

-R Commando-opbouw

De basisopbouw van het commando voor reverse port forwarding is als volgt.

ssh -R [remote_port]:[target_host]:[target_port] [remote_user]@[remote_server_address]
  • ssh: Commando om de SSH-client uit te voeren.
  • -R: Optie voor reverse port forwarding.
  • [remote_port]: Het poortnummer van de externe server (Server A) waar de tunnel wordt geopend. Wanneer externe gebruikers verbinding maken met deze poort, worden ze verbonden met de resources van Client B.
  • [target_host]: De [remote_user]@[remote_server_address] die verbinding maakt, is de hostnaam of het IP-adres van de resource die toegankelijk is binnen Client B (mijn computer). Meestal is dit localhost (dat wil zeggen, Client B zelf).
  • [target_port]: Het poortnummer van de service die open is binnen Client B (mijn computer). Dit is de uiteindelijke bestemming voor de verzoeken die van buiten komen.
  • [remote_user]@[remote_server_address]: Het gebruikersaccount en adres van de externe server (Server A) waarmee de tunnel wordt verbonden. Dit is het pad waarlangs Client B verbinding maakt met Server A.

Voorbeeld:

Als ik wil verbinden met mijn lokale computer (Client B) op poort 8080 via poort 8888 op de externe server (Server A):

# Voer uit op Client B (mijn computer)
ssh -R 8888:localhost:8080 user@server_a_public_ip

Als dit commando met succes wordt uitgevoerd, ben je verbonden via SSH met server_a_public_ip. Nu, wanneer iemand anders verbinding maakt met http://server_a_public_ip:8888, krijg je daadwerkelijk toegang tot poort 8080 van Client B (mijn computer).

Wanneer is reverse port forwarding nuttig? (Gebruik tijdens de ontwikkelingsfase)

Reverse port forwarding is bijzonder krachtig in situaties die moeilijk op te lossen zijn met gewone SSH-toegang. Het kan vooral nuttig zijn tijdens de ontwikkelingsfase.

1. Publicatie van lokale ontwikkelingsservers achter NAT/firewalls

  • Probleem: Je hebt een webapplicatie (bijv. draait op localhost:3000) die je ontwikkelt in je huis of het interne netwerk van je bedrijf. Je wilt deze applicatie laten zien aan teamleden of klanten van buitenaf, maar je lokale computer heeft een privéadres en kan niet extern worden benaderd. Router- of bedrijfsfirewallinstellingen zijn vaak complex en vereisen mogelijk goedkeuring van de beheerder.
  • Oplossing: Voer SSH door via een externe server met een publiek IP-adres (bijv. AWS EC2-instantie, VPS) om de lokale ontwikkelingsserver extern beschikbaar te stellen.
# Voer uit op mijn lokale ontwikkelingsmachine (Client B)
ssh -R 80:localhost:3000 your_user@your_public_server.com
# Of omdat poort 80 roottoegang nodig heeft, gebruik een andere poort (bijv. 8080)
ssh -R 8080:localhost:3000 your_user@your_public_server.com

Daarna, als je verbinding maakt met `your_public_server.com:8080`, krijg je daadwerkelijke toegang tot de webapplicatie die draait op jouw lokale machine (`localhost:3000`). Nu kunnen anderen je ontwikkelingsvoortgang in realtime volgen.

2. Webhook-test

  • Probleem: Je wilt webhook-evenementen testen van betalingssystemen, Git-repositories (GitHub/GitLab), messaging-platforms, etc., op je lokale ontwikkelingsserver. Maar webhooks kunnen alleen naar publieke URL's worden verzonden.
  • Oplossing: Met reverse port forwarding kun je lokale webhook-eindpunten (bijv. localhost:5000/webhook) mappen naar een specifieke URL op een publieke server.
# Voer uit op mijn lokale ontwikkelingsmachine (Client B)
ssh -R 5000:localhost:5000 your_user@your_public_server.com

Nu, als je `http://your_public_server.com:5000/webhook` invoert in de webhook-instellingen, worden de webhook-evenementen naar jouw lokale server gestuurd voor testen.

3. Directe toegang tot specifieke poorten op een externe server (om passeren van beveiligde netwerken mogelijk te maken)

  • Probleem: Je wilt direct toegang krijgen tot databases of interne managementtools (bijv. draait op localhost:9000) die zijn geïnstalleerd op een specifieke server (Client B) op een externe locatie, maar dit is geblokkeerd door een firewall of bevindt zich in een privénetwerk. Client B kan echter wel verbinding maken met een publieke server (Server A) via SSH.
  • Oplossing: Client B vraagt via reverse port forwarding aan Server A: "Maak een tunnel voor verbinding met mijn poort 9000".
# Voer uit op Client B (server achter de firewall)
ssh -R 9000:localhost:9000 your_user@server_a_public_ip

Nu, als je verbinding maakt met `server_a_public_ip:9000`, krijg je toegang tot de service op poort 9000 van Client B.

4. Tijdelijke demo of delen

  • Probleem: Je wilt een collega laten zien hoe een specifieke applicatie op jouw lokale machine werkt of wil het tijdelijk openbaar maken voor feedback.
  • Oplossing: Met eenvoudige reverse port forwarding kun je de lokale service tijdelijk extern beschikbaar maken. Na de demo kun je de SSH-sessie beëindigen om de toegang te blokkeren.

Belangrijke overwegingen bij het gebruik van reverse port forwarding

  • GatewayPorts yes: Externe poorten die zijn geopend met reverse port forwarding zijn standaard alleen toegankelijk vanaf de machine waarop de SSH-server (server_a_public_ip) draait. Als je wilt dat andere computers buiten de SSH-server ook deze poorten kunnen benaderen, moet je het GatewayPorts yes -instelling toevoegen aan het sshd_config bestand van de SSH-server en de SSH-service opnieuw starten. (Deze instelling kan de beveiliging beïnvloeden, dus gebruik deze met de nodige voorzichtigheid.)

  • Beveiliging: Omdat reverse port forwarding bepaalde poorten van je lokale netwerk extern openbaar maakt, moet je dit alleen gebruiken met vertrouwde servers. Je moet alle beveiligingskwetsbaarheden van de blootgestelde service van tevoren controleren.

  • Onderhouden van SSH-sessie: De reverse port forwarding-tunnel is alleen geldig zolang de SSH-sessie actief is. Om het op de achtergrond te laten draaien, is het gebruikelijk om ssh -fN -R ... te gebruiken met de opties f (op de achtergrond uitvoeren) en N (geen externe opdrachten uitvoeren).

Ter afsluiting

SSH reverse port forwarding (-R optie) is een zeer nuttige functie wanneer je specifieke services wilt blootstellen in complexe netwerkomgevingen of achter firewalls. Vooral in de ontwikkelingsfase kan het een krachtige productiviteits-tool zijn om je lokale omgeving te delen of webhook-tests uit te voeren.

Als het een moeilijk te begrijpen concept was, is het beste om het daadwerkelijk eens uit te proberen om het goed onder de knie te krijgen. Maak gebruik van SSH reverse port forwarding in jouw ontwikkelingsworkflow!

Als je vragen hebt, stel ze dan gerust in de comments!