Hoe kan ik een SSH tunnel betrouwbaar open houden?

Het lijkt erop dat je autossh nodig hebt. Dit zal een ssh tunnel monitoren en herstarten indien nodig. We gebruiken het al een paar jaar en het lijkt goed te werken.

autossh -M 20000 -f -N your_public_server -R 1234:localhost:22 -C

Meer details over de -M parameter hier

Alle stateful firewalls vergeten een verbinding nadat ze enige tijd geen pakket voor die verbinding hebben gezien (om te voorkomen dat de toestandstabellen vol komen te staan met verbindingen waarbij beide uiteinden zijn overleden zonder de verbinding te sluiten). De meeste TCP implementaties zullen een keepalive pakket sturen na een lange tijd zonder iets van de andere kant gehoord te hebben (2 uur is een gebruikelijke waarde). Als er echter een stateful firewall is die de verbinding vergeet voordat de keepalive pakketten verstuurd kunnen worden, zal een langlevende maar inactieve verbinding afsterven.

Als dat het geval is, is de oplossing om te voorkomen dat de verbinding inactief wordt. OpenSSH heeft een optie genaamd ServerAliveInterval die gebruikt kan worden om te voorkomen dat de verbinding te lang inactief blijft (als bonus zal het eerder detecteren wanneer de peer overleden is, zelfs als de verbinding inactief is).

Op je eigen mac of linux machine configureer je ssh hou de server ssh elke 3 minuten in leven. Open een terminal en ga naar je onzichtbare .ssh in je home:

cd ~/.ssh/

maak dan een 1 regel config bestand aan met:

echo "ServerAliveInterval 180" >> config

je moet ook toevoegen:

ServerAliveCountMax xxxx (high number)

de standaard is 3 dus ServerAliveInterval 180 zal stoppen met zenden na 9 minuten (3 van de 3 minuten interval opgegeven door ServerAliveInterval).

Ik heb het volgende Bash script gebruikt om steeds nieuwe ssh tunnels te spawnen wanneer de vorige sterft. Het gebruik van een script is handig als je geen extra pakketten wilt of kunt installeren of geen compiler kunt gebruiken.

while true
do
  ssh <ssh_options> [user@]hostname
  sleep 15
done

Merk op dat dit een keyfile vereist om de verbinding automatisch op te zetten, maar dat is met autossh ook het geval.

Systemd is hier bij uitstek geschikt voor.

Maak een service bestand /etc/systemd/system/sshtunnel.service met daarin:

[Unit]
Description=SSH Tunnel
After=network.target

[Service]
Restart=always
RestartSec=20
User=sshtunnel
ExecStart=/bin/ssh -NT -o ServerAliveInterval=60 -L 5900:localhost:5900 user@otherserver

[Install]
WantedBy=multi-user.target

(Pas het ssh commando aan)

• dit zal draaien als gebruiker sshtunnel dus zorg ervoor dat die gebruiker eerst bestaat
• geef systemctl enable sshtunnel om het te laten starten bij het opstarten

• geef systemctl start sshtunnel om onmiddellijk te starten

Update Jan 2018 : sommige distro’s (bv. bijv. Fedora 27) kunnen SELinux-beleid gebruiken om het gebruik van SSH vanuit systemd init te voorkomen, in welk geval een aangepast beleid moet worden gemaakt om de nodige vrijstellingen te bieden.

Het lijkt mij dat jullie allemaal de ServerAliveCountMax verkeerd interpreteren. Zoals ik de docs begrijp, is het het aantal server alive berichten dat onbeantwoord kan blijven zonder dat de verbinding wordt verbroken. Dus in gevallen zoals we hier bespreken, zal het instellen op een hoge waarde er alleen maar voor zorgen dat een vastgelopen verbinding niet wordt gedetecteerd en beëindigd!

Het instellen van ServerAliveInterval zou voldoende moeten zijn om het probleem op te lossen dat een firewall de verbinding vergeet, en als je ServerAliveCountMax laag laat, zal het oorspronkelijke eind de mislukking opmerken en de verbinding beëindigen als die toch mislukt.

Wat je wilt is, 1) dat de verbinding onder normale omstandigheden permanent open blijft, 2) dat het falen van de verbinding wordt gedetecteerd en dat de server bij het falen afsluit, en 3) dat het ssh commando iedere keer dat het afsluit opnieuw wordt gegeven (hoe je dat doet is platformafhankelijk, het “while true” script voorgesteld door Jawa is één manier, op OS X heb ik een launchd item opgezet).

Gebruik altijd de ServerAliveInterval SSH optie in het geval dat de tunnelproblemen veroorzaakt worden door verlopen NAT sessies.

Gebruik altijd een respawning methode voor het geval de connectiviteit volledig wegvalt, je hebt hier minstens drie opties:

• autossh programma
• bash script (while true do ssh ...; sleep 5; done) verwijder het sleep commando niet, ssh kan snel falen en je respawnt teveel processen

• /etc/inittab, om toegang te hebben tot een box die in een ander land verscheept en geïnstalleerd is, achter NAT, zonder port forwarding naar de box, kun je hem configureren om een ssh tunnel terug naar jou te maken:

• upstart script op Ubuntu, waar /etc/inittab niet beschikbaar is:

of gebruik altijd beide methodes.

Ik heb dit probleem hiermee opgelost:

Bewerk

~/.ssh/config

En voeg

ServerAliveInterval 15
ServerAliveCountMax 4

toe Volgens man page voor ssh_config:

ServerAliveCountMax
         Sets the number of server alive messages (see below) which may be
         sent without ssh(1) receiving any messages back from the server.
         If this threshold is reached while server alive messages are
         being sent, ssh will disconnect from the server, terminating the
         session. It is important to note that the use of server alive
         messages is very different from TCPKeepAlive (below). The server
         alive messages are sent through the encrypted channel and there‐
         fore will not be spoofable. The TCP keepalive option enabled by
         TCPKeepAlive is spoofable. The server alive mechanism is valu‐
         able when the client or server depend on knowing when a connec‐
         tion has become inactive.

         The default value is 3. If, for example, ServerAliveInterval
         (see below) is set to 15 and ServerAliveCountMax is left at the
         default, if the server becomes unresponsive, ssh will disconnect
         after approximately 45 seconds. This option applies to protocol
         version 2 only.

 ServerAliveInterval
         Sets a timeout interval in seconds after which if no data has
         been received from the server, ssh(1) will send a message through
         the encrypted channel to request a response from the server. The
         default is 0, indicating that these messages will not be sent to
         the server. This option applies to protocol version 2 only.

ExitOnForwardFailure yes is een goede aanvulling op de andere suggesties. Als het verbinding maakt maar de poort forwarding niet tot stand kan brengen is het net zo nutteloos voor je als wanneer het helemaal geen verbinding had gemaakt.

Een beetje een hack, maar ik gebruik graag scherm om dit te houden. Ik heb momenteel een remote forward die al weken loopt.

Voorbeeld, lokaal beginnen:

screen
ssh -R ......

Wanneer de remote forward is toegepast, en je hebt een shell op de remote computer:

screen
Ctrl + a + d

Je hebt nu een ononderbroken remote forward. De truc is om screen aan beide uiteinden te draaien

Onlangs had ik dit probleem zelf, omdat deze oplossingen vereisen dat je het wachtwoord elke keer opnieuw invoert als je een wachtwoord login gebruikt, gebruikte ik sshpass in een lus samen met een tekst prompt om het wachtwoord niet in het batch bestand te hebben.

Ik dacht, ik deel mijn oplossing op deze thead voor het geval iemand anders hetzelfde probleem heeft:

#!/bin/bash
read -s -p "Password: " pass
while true
do
    sshpass -p "$pass" ssh user@address -p port
    sleep 1
done

Hoewel er tools zijn zoals autossh die helpen om een ssh sessie te herstarten… wat ik echt handig vind is het uitvoeren van het ‘screen’ commando. Hiermee kun je je ssh-sessies HERHALEN, zelfs nadat je de verbinding hebt verbroken. Vooral handig als je verbinding niet zo betrouwbaar is als het zou moeten zijn.

• http://www.howtogeek.com/howto/ubuntu/keep-your-ssh-session-running-when-you-disconnect/

…vergeet niet dit als het ‘juiste’ antwoord aan te vinken als het je helpt k! ;-)

Ik had de behoefte om een SSH-tunnel op lange termijn te onderhouden. Mijn oplossing draaide vanaf een Linux server, en het is gewoon een klein C programma dat ssh opnieuw start met sleutel-gebaseerde authenticatie.

Ik ben niet zeker van het hangen, maar ik heb tunnels gehad die doodgingen door timeouts.

Ik zou graag de code voor de respawner willen geven, maar ik kan hem op dit moment niet vinden.

Aangezien autossh niet aan onze behoeften voldoet (het geeft een foutmelding als het bij de eerste poging geen verbinding met de server kan maken), hebben we een pure bash applicatie geschreven: https://github.com/aktos-io/link-with-server

Het creëert standaard een reverse tunnel voor de sshd poort (22) van de NODE op de server. Als je andere acties wilt uitvoeren (zoals extra poorten doorsturen, mails versturen op verbinding, enz…) kun je je scripts on-connect en on-disconnect mappen.

Ik heb soortgelijke problemen gehad met mijn vorige ISP. Voor mij was het hetzelfde met elke tcp verbinding, het bezoeken van websites of het verzenden van mail.

De oplossing was om een VPN verbinding over UDP te configureren (ik gebruikte OpenVPN). Deze verbinding was toleranter voor de oorzaak van de verbrekingen. Dan kun je elke service via deze verbinding laten lopen.

Er kunnen nog steeds problemen zijn met de verbinding, maar omdat de tunnel toleranter is, zal iedere ssh sessie een korte oponthoud voelen in plaats van verbroken te worden.

Om dit te doen heb je een online VPN service nodig die je op je eigen server kunt instellen.

Je zou heel eenvoudig het commando tmux kunnen gebruiken op je server op afstand. Hiermee open je een “sessie” op de machine op afstand waar je je code op afstand uitvoert.

Dan kun je de machine op afstand verlaten (of de verbinding verliezen in jouw geval) zonder je zorgen te maken, aangezien je code veilig draait in je tmux sessie.

Tenslotte, als je weer verbinding maakt op de server op afstand, hoef je alleen maar tmux attach te draaien om terug te keren naar de sessie die je eerder geopend had en dat is het.