# ssh — Verschlüsselte Verbindungen und Tunneling auf der Kommandozeile

> Praxis-Guide zu SSH — Verbindungen aufbauen, Schlüssel verwalten, Port-Forwarding einrichten und Dateien sicher übertragen.

Source: https://www.jpkc.com/db/cheatsheets/networking/ssh/

<!-- PROSE:intro -->
SSH (Secure Shell) ist das Standardwerkzeug, mit dem du dich verschlüsselt auf entfernte Systeme einloggst, Befehle fernausführst und Dateien sicher überträgst – alles über eine einzige, kryptografisch gesicherte Verbindung. Ob Einzelserver oder komplexes Netz mit Jump-Hosts und SOCKS-Proxys: SSH deckt es ab. Dieser Guide zeigt dir die wichtigsten Befehle und Optionen, von der ersten Verbindung über Schlüsselverwaltung bis hin zu Port-Forwarding und Multiplexing.
<!-- PROSE:intro:end -->

## Verbinden

`ssh <user>@<host>` — Verbindet dich mit einem Remote-Host als bestimmter Benutzer.

```bash
ssh deploy@server.example.com
```

`ssh <host>` — Verbindet dich mit dem aktuellen lokalen Benutzernamen.

```bash
ssh server.example.com
```

`ssh -p <port> <user>@<host>` — Verbindet dich über einen nicht standardmäßigen SSH-Port.

```bash
ssh -p 2222 deploy@server.example.com
```

`ssh -i <keyfile> <user>@<host>` — Verbindet dich mit einer bestimmten privaten Schlüsseldatei.

```bash
ssh -i ~/.ssh/deploy_key deploy@server.example.com
```

`ssh -v <user>@<host>` — Ausführlicher Modus: Zeigt Debug-Informationen während der Verbindung zur Fehlerbehebung.

```bash
ssh -v deploy@server.example.com
```

`ssh -vvv <user>@<host>` — Maximale Ausführlichkeit: Zeigt alle Debug-Ebenen für tiefgehende Fehlerbehebung.

```bash
ssh -vvv deploy@server.example.com
```

`ssh -o StrictHostKeyChecking=no <user>@<host>` — Überspringt die Überprüfung des Host-Schlüssels (unsicher, nützlich für Skripte und kurzlebige Hosts).

```bash
ssh -o StrictHostKeyChecking=no deploy@staging.example.com
```

`ssh -o ConnectTimeout=<seconds> <user>@<host>` — Setzt einen Verbindungs-Timeout in Sekunden.

```bash
ssh -o ConnectTimeout=5 deploy@server.example.com
```

## Fernbefehle ausführen

`ssh <user>@<host> <command>` — Führt einen einzelnen Befehl auf dem Remote-Host aus und kehrt zurück.

```bash
ssh deploy@server.example.com uptime
```

`ssh <user>@<host> '<command1> && <command2>'` — Führt mehrere verkettete Befehle remote aus.

```bash
ssh deploy@server.example.com 'cd /var/www && git pull'
```

`ssh <user>@<host> 'bash -s' < <script>` — Führt ein lokales Skript über stdin auf dem Remote-Host aus.

```bash
ssh deploy@server.example.com 'bash -s' < deploy.sh
```

`ssh -t <user>@<host> <command>` — Erzwingt die Pseudo-Terminal-Zuweisung. Erforderlich für interaktive Befehle wie sudo oder top.

```bash
ssh -t deploy@server.example.com sudo apt update
```

`ssh <user>@<host> 'cat > <remote_file>' < <local_file>` — Überträgt eine Datei über stdin-Umleitung auf einen Remote-Host.

```bash
ssh deploy@server.example.com 'cat > /tmp/config.json' < config.json
```

## Schlüsselverwaltung

`ssh-keygen -t ed25519 -C "<comment>"` — Erstellt ein neues Ed25519-Schlüsselpaar (empfohlen, sicherste und schnellste Methode).

```bash
ssh-keygen -t ed25519 -C "deploy@server.example.com"
```

`ssh-keygen -t rsa -b 4096 -C "<comment>"` — Erstellt ein neues RSA-Schlüsselpaar mit 4096 Bit.

```bash
ssh-keygen -t rsa -b 4096 -C "user@example.com"
```

`ssh-keygen -t ed25519 -f <path>` — Erstellt ein Schlüsselpaar und speichert es unter einem bestimmten Dateipfad.

```bash
ssh-keygen -t ed25519 -f ~/.ssh/deploy_key
```

`ssh-keygen -p -f <keyfile>` — Ändert die Passphrase eines vorhandenen privaten Schlüssels.

```bash
ssh-keygen -p -f ~/.ssh/id_ed25519
```

`ssh-keygen -l -f <keyfile>` — Zeigt den Fingerabdruck einer Schlüsseldatei an.

```bash
ssh-keygen -l -f ~/.ssh/id_ed25519.pub
```

`ssh-keygen -R <host>` — Entfernt einen Host-Eintrag aus known_hosts (behebt Warnungen bei geändertem Host-Schlüssel).

```bash
ssh-keygen -R server.example.com
```

`ssh-keygen -y -f <private_key>` — Extrahiert den öffentlichen Schlüssel aus einer privaten Schlüsseldatei.

```bash
ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub
```

## Schlüsselverteilung

`ssh-copy-id <user>@<host>` — Kopiert deinen öffentlichen Schlüssel in die authorized_keys-Datei eines Remote-Hosts.

```bash
ssh-copy-id deploy@server.example.com
```

`ssh-copy-id -i <keyfile> <user>@<host>` — Kopiert einen bestimmten öffentlichen Schlüssel auf den Remote-Host.

```bash
ssh-copy-id -i ~/.ssh/deploy_key.pub deploy@server.example.com
```

`ssh-copy-id -p <port> <user>@<host>` — Kopiert den öffentlichen Schlüssel über einen nicht standardmäßigen Port auf den Remote-Host.

```bash
ssh-copy-id -p 2222 deploy@server.example.com
```

`cat <keyfile> | ssh <user>@<host> 'mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys'` — Manuelle Alternative zu ssh-copy-id, wenn es nicht verfügbar ist.

```bash
cat ~/.ssh/id_ed25519.pub | ssh deploy@server.example.com 'mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys'
```

## SSH-Agent

`eval "$(ssh-agent -s)"` — Startet den SSH-Agent und setzt Umgebungsvariablen in der aktuellen Shell.

```bash
eval "$(ssh-agent -s)"
```

`ssh-add <keyfile>` — Fügt einen privaten Schlüssel zum SSH-Agent hinzu.

```bash
ssh-add ~/.ssh/id_ed25519
```

`ssh-add` — Fügt den Standard-Schlüssel (~/.ssh/id_rsa, id_ed25519 usw.) zum Agent hinzu.

```bash
ssh-add
```

`ssh-add -l` — Listet die Fingerabdrücke aller aktuell im Agent geladenen Schlüssel auf.

```bash
ssh-add -l
```

`ssh-add -L` — Listet die vollständigen öffentlichen Schlüssel auf, die derzeit im Agent geladen sind.

```bash
ssh-add -L
```

`ssh-add -d <keyfile>` — Entfernt einen bestimmten Schlüssel aus dem Agent.

```bash
ssh-add -d ~/.ssh/deploy_key
```

`ssh-add -D` — Entfernt alle Schlüssel aus dem Agent.

```bash
ssh-add -D
```

`ssh -A <user>@<host>` — Aktiviert die Agent-Weiterleitung. Ermöglicht dem Remote-Host die Nutzung deiner lokalen SSH-Schlüssel.

```bash
ssh -A deploy@bastion.example.com
```

## Port-Forwarding (Tunneling)

`ssh -L <local_port>:<target_host>:<target_port> <user>@<host>` — Lokales Port-Forwarding: Greife auf einen Remote-Dienst über einen lokalen Port zu.

```bash
ssh -L 3306:localhost:3306 deploy@server.example.com
```

`ssh -L <local_port>:<remote_host>:<remote_port> <user>@<host>` — Leitet an einen Host weiter, der vom SSH-Server aus erreichbar ist (nicht nur localhost).

```bash
ssh -L 5432:db.internal:5432 deploy@bastion.example.com
```

`ssh -R <remote_port>:<local_host>:<local_port> <user>@<host>` — Remote-(Reverse-)Port-Forwarding: Macht einen lokalen Dienst auf dem Remote-Host verfügbar.

```bash
ssh -R 8080:localhost:3000 deploy@server.example.com
```

`ssh -D <port> <user>@<host>` — Dynamisches Port-Forwarding: Erstellt einen SOCKS5-Proxy auf dem lokalen Port.

```bash
ssh -D 1080 deploy@server.example.com
```

`ssh -L <local_port>:<target>:<target_port> -N <user>@<host>` — Leitet einen Port weiter, ohne eine Remote-Shell zu öffnen (-N = kein Befehl).

```bash
ssh -L 3306:localhost:3306 -N deploy@server.example.com
```

`ssh -L <local_port>:<target>:<target_port> -N -f <user>@<host>` — Leitet einen Port im Hintergrund weiter (-f = in den Hintergrund wechseln).

```bash
ssh -L 3306:localhost:3306 -N -f deploy@server.example.com
```

## Jump-Hosts (Bastion/ProxyJump)

`ssh -J <jump_host> <user>@<target_host>` — Verbindet dich über einen Jump-Host (Bastion) mit einem Ziel-Host.

```bash
ssh -J bastion.example.com deploy@internal-server
```

`ssh -J <user1>@<jump1>,<user2>@<jump2> <user>@<target>` — Verkettet mehrere Jump-Hosts, um das Ziel zu erreichen.

```bash
ssh -J admin@bastion1,admin@bastion2 deploy@internal-server
```

`ssh -J <jump_host>:<port> <user>@<target_host>` — Verwendet einen Jump-Host, der SSH auf einem nicht standardmäßigen Port betreibt.

```bash
ssh -J bastion.example.com:2222 deploy@internal-server
```

`ssh -o ProxyJump=<jump_host> <user>@<target_host>` — Alternative Syntax mit der ProxyJump-Option.

```bash
ssh -o ProxyJump=bastion.example.com deploy@internal-server
```

## SCP (Secure Copy)

`scp <local_file> <user>@<host>:<remote_path>` — Kopiert eine lokale Datei auf einen Remote-Host.

```bash
scp ./config.json deploy@server.example.com:/etc/app/
```

`scp <user>@<host>:<remote_file> <local_path>` — Kopiert eine Datei von einem Remote-Host auf den lokalen Rechner.

```bash
scp deploy@server.example.com:/var/log/app.log ./logs/
```

`scp -r <local_dir> <user>@<host>:<remote_path>` — Kopiert ein Verzeichnis rekursiv auf einen Remote-Host.

```bash
scp -r ./dist/ deploy@server.example.com:/var/www/html/
```

`scp -P <port> <local_file> <user>@<host>:<remote_path>` — Kopiert über einen nicht standardmäßigen SSH-Port (Hinweis: Großbuchstabe -P für scp).

```bash
scp -P 2222 ./config.json deploy@server.example.com:/etc/app/
```

`scp -i <keyfile> <local_file> <user>@<host>:<remote_path>` — Kopiert mit einer bestimmten privaten Schlüsseldatei.

```bash
scp -i ~/.ssh/deploy_key ./app.tar.gz deploy@server.example.com:/tmp/
```

`scp <user>@<host1>:<file> <user>@<host2>:<path>` — Kopiert eine Datei zwischen zwei Remote-Hosts (Daten fließen durch den lokalen Rechner).

```bash
scp deploy@server1.example.com:/backup.sql deploy@server2.example.com:/import/
```

## SFTP (Secure File Transfer)

`sftp <user>@<host>` — Startet eine interaktive SFTP-Sitzung mit einem Remote-Host.

```bash
sftp deploy@server.example.com
```

`sftp -P <port> <user>@<host>` — Verbindet sich über SFTP auf einem nicht standardmäßigen SSH-Port.

```bash
sftp -P 2222 deploy@server.example.com
```

`sftp> get <remote_file> <local_path>` — Lädt eine Datei vom Remote-Host herunter (innerhalb der SFTP-Sitzung).

```bash
sftp> get /var/log/app.log ./logs/
```

`sftp> put <local_file> <remote_path>` — Lädt eine Datei auf den Remote-Host hoch (innerhalb der SFTP-Sitzung).

```bash
sftp> put ./config.json /etc/app/
```

`sftp> ls` — Listet Dateien im aktuellen Remote-Verzeichnis auf.

```bash
sftp> ls -la
```

`sftp> lcd <path>` — Wechselt das lokale Arbeitsverzeichnis.

```bash
sftp> lcd ~/Downloads
```

## Konfigurationsdatei (~/.ssh/config)

`Host <alias>` mit `HostName`, `User` — Definiert einen Host-Alias mit Standard-Benutzer. Verbinden mit: ssh <alias>

```bash
Host production
  HostName server.example.com
  User deploy
```

`Host <alias>` mit `HostName`, `Port`, `IdentityFile` — Definiert einen Host mit benutzerdefiniertem Port und Schlüsseldatei.

```bash
Host staging
  HostName staging.example.com
  Port 2222
  IdentityFile ~/.ssh/staging_key
```

`Host <alias>` mit `HostName`, `ProxyJump` — Definiert einen Host, der über einen Jump-Host (Bastion) verbindet.

```bash
Host internal-db
  HostName db.internal
  ProxyJump bastion.example.com
```

`Host *` mit `ServerAliveInterval`, `ServerAliveCountMax` — Globale Einstellungen für alle Hosts: Verbindungen mit regelmäßigen Pings aufrechterhalten.

```bash
Host *
  ServerAliveInterval 60
  ServerAliveCountMax 3
  AddKeysToAgent yes
```

`Host <pattern>*` mit `User`, `IdentityFile` — Verwendet Wildcards, um Einstellungen auf mehrere Hosts anzuwenden.

```bash
Host aws-*
  User ec2-user
  IdentityFile ~/.ssh/aws_key
```

## Multiplexing & Keep-Alive

`ssh -o ControlMaster=auto -o ControlPath=/tmp/ssh-%r@%h:%p -o ControlPersist=10m <user>@<host>` — Aktiviert Connection-Multiplexing: Nachfolgende SSH-Sitzungen verwenden die Verbindung wieder.

```bash
ssh -o ControlMaster=auto -o ControlPath=/tmp/ssh-%r@%h:%p -o ControlPersist=10m deploy@server.example.com
```

`ssh -O check <user>@<host>` — Prüft, ob eine gemultiplexte Master-Verbindung läuft.

```bash
ssh -O check deploy@server.example.com
```

`ssh -O exit <user>@<host>` — Beendet eine gemultiplexte Master-Verbindung.

```bash
ssh -O exit deploy@server.example.com
```

`ssh -o ServerAliveInterval=<seconds> <user>@<host>` — Sendet Keep-Alive-Pakete, um Verbindungs-Timeouts zu verhindern.

```bash
ssh -o ServerAliveInterval=60 deploy@server.example.com
```

## Escape-Sequenzen

`~.` — Beendet eine feststeckende SSH-Sitzung. Zuerst Enter drücken, dann ~. (Tilde Punkt) eingeben.

```bash
~.
```

`~^Z` — Hält die SSH-Sitzung an und kehrt zur lokalen Shell zurück. Mit fg fortsetzen.

```bash
~^Z
```

`~#` — Listet alle weitergeleiteten Verbindungen in der aktuellen Sitzung auf.

```bash
~#
```

`~?` — Zeigt eine Liste aller verfügbaren Escape-Sequenzen an.

```bash
~?
```

`~C` — Öffnet die SSH-Befehlszeile, um Port-Weiterleitungen während einer laufenden Sitzung hinzuzufügen.

```bash
~C then: -L 3306:localhost:3306
```

## Sicherheit & Fehlerbehebung

`ssh-keyscan <host>` — Ruft die öffentlichen Host-Schlüssel von einem Remote-Server ab.

```bash
ssh-keyscan server.example.com >> ~/.ssh/known_hosts
```

`ssh-keyscan -t ed25519 <host>` — Ruft nur einen bestimmten Schlüsseltyp vom Remote-Server ab.

```bash
ssh-keyscan -t ed25519 server.example.com
```

`ssh -Q key` — Listet alle vom lokalen SSH-Client unterstützten Schlüsseltypen auf.

```bash
ssh -Q key
```

`ssh -Q cipher` — Listet alle vom lokalen SSH-Client unterstützten Verschlüsselungsalgorithmen auf.

```bash
ssh -Q cipher
```

`ssh -Q mac` — Listet alle unterstützten MAC-Algorithmen auf.

```bash
ssh -Q mac
```

`chmod 700 ~/.ssh` — Setzt die korrekten Berechtigungen für das .ssh-Verzeichnis (erforderlich, damit SSH funktioniert).

```bash
chmod 700 ~/.ssh
```

`chmod 600 ~/.ssh/id_ed25519` — Setzt die korrekten Berechtigungen für eine private Schlüsseldatei (darf für andere nicht zugänglich sein).

```bash
chmod 600 ~/.ssh/id_ed25519
```

`chmod 644 ~/.ssh/authorized_keys` — Setzt die korrekten Berechtigungen für authorized_keys.

```bash
chmod 644 ~/.ssh/authorized_keys
```

<!-- PROSE:outro -->
## Fazit

SSH ist weit mehr als ein Terminal-Ersatz: Schlüssel statt Passwörter, Agent-Forwarding für Bastion-Hosts, Port-Tunnel für gesperrte Dienste und Multiplexing für schnelle Wiederverbindungen machen es zum zentralen Werkzeug jeder Infrastruktur. Wer die Config-Datei pflegt und Schlüssel konsequent mit Passphrasen schützt, arbeitet schneller und sicherer zugleich.

## Weiterführende Links

- [OpenSSH – offizielle Website](https://www.openssh.com/) – Dokumentation und Changelog (englisch)
- [ssh(1) – Manpage](https://man.openbsd.org/ssh) – alle Optionen im Überblick (englisch)
- [Secure Shell – Wikipedia](https://de.wikipedia.org/wiki/Secure_Shell) – Hintergrund und Geschichte
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [scp](https://www.jpkc.com/db/cheatsheets/networking/scp/) – Dateien sicher auf Remote-Hosts kopieren
- [ssh-keygen](https://www.jpkc.com/db/cheatsheets/networking/ssh-keygen/) – SSH-Schlüsselpaare erstellen und verwalten
- [mosh](https://www.jpkc.com/db/cheatsheets/networking/mosh/) – SSH-Alternative für instabile oder hochlatente Verbindungen