====== SSH ======

===== Idle Session timeout =====
Clientseitig (wird pro SSH-Session angewendet): ''/etc/ssh/ssh_config''
<code>ServerAliveInterval XX
ServerAliveCountMax YY</code>

Serverseitig (wird Systemweit angewendet): ''/etc/ssh/ssh_config''
<code>ClientAliveInterval XX
ClientAliveCountMax YY</code>

===== SSH Ohne Password =====
Möchte man per Script einen Befehl über ssh senden, dann würde das Script immer nach dem Password fragen.
Wenn dieses Script dann aber per "cron" laufen soll, muss man hier eine andere Authentifizierungsmethode wählen: Host-Key

==== Public-Key erstellen ====
So erstellt man einen RSA Host-Key:
  ssh-keygen -t [rsa|Ed25519]
Zunächst fragt das Programm nach dem Pfad zur RSA-Datei. Diesen kann man einfach bestätigen.
Nimmt man hier aber einen anderen Dateinamen oder Pfad, muss man bei der SSH-Verbindung den Pfad explizit angeben.
  ssh -i <PFAD_ZU_RSA-FILE> <REMOTE-USER>@<REMOTE-HOST>

Danach wird nach einer Passphrase gefragt.
Wenn die Passphrase leer gelassen wird, muss man sich per SSH, an dem jew. Remotehost und dem jew. User, nicht mehr mit Password anmelden.

==== Public-Key kopieren ====
Den erstellten Public-Key kopiert man einfach auf den für den jew. User auf dem Remotehost in das Verzeichnis ".ssh".
  ssh-copy-id -i ~/.ssh/id_rsa.pub <REMOTE-USER>@<REMOTE-HOST>

Wenn ''ssh-copy-id'' nicht vorhanden ist dann kann dies auch von Hand gemacht werden.
  scp .ssh/id_rsa.pub <REMOTE-USER>@<REMOTE-HOST>:<PFAD_ZU_HOMEVERZEICHNIS>/.ssh/authorized_keys
oder
   cat .ssh/id_rsa.pub | ssh <REMOTE-USER>@<REMOTE-HOST> cat>> ~/.ssh/authorized_keys 

Nun kann man sich per SSH an den Remotehost mit dem Host-Key anmelden.

==== Public-Key verteilen ====
Man kann den Public-Key auf mehrere hosts z.B. mit diesem Script verteilen.
<code bash>#!/bin/bash

SSHUSER=root
SSHRSA=<PFAD_ZU_ID_RSA_PRIVATE_KEY>
AUTHKEYSFILE=<PFAD_ZU_AUTHORIZED_KEY_AUF_REMOTEHOST>(für gewöhnlich: /.../.ssh/authorized_keys)

echo
echo
echo "Dieses Script kopiert den öffentlichen SSH-RSA Key auf den unten angegebenen PC."
echo "Danach kann man sich mit einer Passphrase am PC anmelden."
echo

read -t 20 -p "Bitte PC-Name eingeben: " TARGETSVR

function rsaright {
  echo "Dem PC wird aktuell nicht vertraut, oder das Authenticationfile existiert nicht."
  echo "Kopiere öffentlichen RSA-Key."
  ssh-copy-id -i $SSHRSA.pub $SSHUSER@$TARGETSVR
}

if ssh -i $SSHRSA $SSHUSER@$TARGETSVR "test -e $AUTHKEYSFILE"; then
  echo "Authenticationfile: $AUTHKEYSFILE existiert."

  ssh -i $SSHRSA $SSHUSER@$TARGETSVR "cat $AUTHKEYSFILE |grep root@ng1" > /dev/null 2>&1
  if [ $? -eq 0 ]; then
    echo "Dem Zielserver wird vertraut, man kann sich nun per Passphrase authentifizieren."
  else
    rsaright
  fi
else
  rsaright
fi</code>

===== Reverse SSH =====
Reverse SSH Tunnel können genutzt werden um Zugriff auf ein Remote SSH-Server/CLient zu erhalten, welcher hinter einer Firewall ist und diese keine Portfreigaben konfiguriert hat.

Remote-Ziel-Server <-----> FIREWALL <-----> SSH-Gateway-Server <-----> SSH-Client

==== Vorbereitungen auf dem Gateway ====
Folgende Vorbereitungen auf dem SSH-Gateway-Server treffen.
<code bash>vi /etc/ssh/sshd_config</code>
Einträge andern/hinzufügen:
<code>ClientAliveInterval 30
ClientAliveCountMax 99999
GatewayPorts yes
AllowTcpForwarding yes</code>

Die ersten 2 Zeilen sorgen dafür, dass die Verbindung, bei Inaktivität, nicht wieder abgebaut wird.
Die 3. Zeile aktivert den Gateway-Modus und die 4. Zeile aktiviert das Weiterleiten von TCP-Paketen.

==== Verbindung vom Remote-Ziel-Server zum Gateway ====
Die SSH-Verbindung vom Remote-Ziel-Server zum Gateway wird wie folgt aufgebaut.
<code bash>ssh -p2000 -fNC -R 10011:<IP_REMOTEZIEL_SERVER | localhost>:22 <USER>@<SSH_GATEWAY_IP></code>
^Parameter ^ Beschreibung ^
| –p2000 | (optional) anderer Port anstatt von "22" auf dem Gateway |
| -f | SSH in den Hintergrund schicken, damit die Verbindung weiterläuft, auch wenn man die eigene SSH-Verbindung trennt |
| N | keine Remote-Kommandos annemmen, nur Tunnel aufbauen |
| C | (optional) Komprimierung einschalten, evtl. dadurch Performanceeinbußen <
| -R | Reverse Tunnel aufgebauen |
| 10011 | Ausgangsport des Gateways zum Remote-Ziel-Server, darüber verbindet man sich vom Gateway zum Remote-Ziel-Server |
| localhost | Hier ist der Remote-Ziel-Server selbst gemeint, bei Verbindungen zu Geräten hinter dem Remote-Ziel-Server, sollte die IP-Adresse des Remote-Ziel-Server verwendet werden |
| 22 | SSH-Eingangsport am Remote-Ziel-Server |

==== Verbindung Gateway zum Remote-Ziel-Server ====
Hiermit verbindet man sich vom Gateway zum Remote-Ziel-Server.
<code bash>ssh -p10011 <IP_REMOTEZIEL_SERVER | localhost></code>

==== Autossh ====
Die Verbindung kann mit dem Tool ''autossh'' automatisch aufgebaut werden.
<code bash>apt install autossh</code>

Verbindungsscript zum Aufbau des Reverse SSH Tunnel anlegen.

Inhalt:
<code>#!/bin/bash
/usr/bin/autossh -p2000 -fNC -R 10011:<IP_REMOTEZIEL_SERVER | localhost>:22 <USER>@<SSH_GATEWAY_IP></code>

<code bash>chmod +x <SCRIPT>.sh</code>

Nun noch das Script per Crontab starten lassen
<code bash>crontab -e</code>
Inhalt einfügen:
<code>@reboot <PFAD_ZU_SCRIPT.sh></code>

==== SSH-Tunnel erweitern ====
Mit Reverse SSH kann man auch andere Ports, wie z.B. HTTP erreichen.
Dazu erweitert man die Verbindung um eine weitere "-R" Anweisung.
<code bash>ssh -p2000 -fNC -R 8000:<IP_REMOTEZIEL_SERVER | localhost>:80 -R 10011:<IP_REMOTEZIEL_SERVER | localhost>:22 <USER>@<SSH_GATEWAY_IP></code>
Hier wird der Port 8000 von Außen auf den Port 80 umgeleitet. Läuft der Webserver auf einem anderen Gerät, wird anstatt ''<IP_REMOTEZIEL_SERVER | localhost>'' die IP-Adresse des Gerätes angegeben.

===== Troubleshooting =====
Wenn bei einer Verbindung folgende Antwort kommt: <code>Unable to negotiate with <IP-ADRESSE> port 22: no matching key exchange method found. Their offer: diffie-hellman-group1-sha1</code>
Dann die Verbindung wie folgt aufbauen <code bash>ssh -oKexAlgorithms=+diffie-hellman-group1-sha1 <IP-ADRESSE></code>oder <code bash>ssh -oKexAlgorithms=+diffie-hellman-group1-sha1 -c aes256-cbc <IP-ADRESSE></code> oder <code bash>ssh -oHostKeyAlgorithms=+ssh-dss -oKexAlgorithms=+diffie-hellman-group1-sha1 -c aes256-cbc <IP-ADRESSE></code>

Man kann in der ''~/.ssh/config'' das auch dauerhaft für den Host definieren:
<code bash>Host <HOSTNAME> <FQDN>
  KexAlgorithms diffie-hellman-group1-sha1
  Ciphers 3des-cbc</code>

Ggf. folgendes in der ''/etc/ssh/ssh_config'' einfügen/anpassen um die Parameter automatisch bei Verbindung zu verwenden: <code>KexAlgorithms diffie-hellman-group1-sha1,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha1
Ciphers 3des-cbc,blowfish-cbc,aes128-cbc,aes128-ctr,aes256-ctr</code>