ssh — Verschlüsselte Verbindungen und Tunneling auf der Kommandozeile

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.

Verbinden

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

ssh deploy@server.example.com

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

ssh server.example.com

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

ssh -p 2222 deploy@server.example.com

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

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.

ssh -v deploy@server.example.com

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

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).

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

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

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.

ssh deploy@server.example.com uptime

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

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.

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.

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.

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).

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.

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.

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

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

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

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

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).

ssh-keygen -R server.example.com

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

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.

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

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

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.

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.

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.

eval "$(ssh-agent -s)"

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

ssh-add ~/.ssh/id_ed25519

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

ssh-add

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

ssh-add -l

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

ssh-add -L

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

ssh-add -d ~/.ssh/deploy_key

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

ssh-add -D

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

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.

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).

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.

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.

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).

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).

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.

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.

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.

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

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

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.

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.

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.

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).

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.

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).

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.

sftp deploy@server.example.com

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

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).

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).

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

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

sftp> ls -la

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

sftp> lcd ~/Downloads

Konfigurationsdatei (~/.ssh/config)

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

Host production
  HostName server.example.com
  User deploy

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

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.

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.

Host *
  ServerAliveInterval 60
  ServerAliveCountMax 3
  AddKeysToAgent yes

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

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.

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.

ssh -O check deploy@server.example.com

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

ssh -O exit deploy@server.example.com

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

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

Escape-Sequenzen

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

~.

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

~^Z

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

~#

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

~?

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

~C then: -L 3306:localhost:3306

Sicherheit & Fehlerbehebung

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

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

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

ssh-keyscan -t ed25519 server.example.com

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

ssh -Q key

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

ssh -Q cipher

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

ssh -Q mac

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

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).

chmod 600 ~/.ssh/id_ed25519

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

chmod 644 ~/.ssh/authorized_keys

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 – Dokumentation und Changelog (englisch)
ssh(1) – Manpage – alle Optionen im Überblick (englisch)
Secure Shell – Wikipedia – Hintergrund und Geschichte