SSH Cheatsheet
🇬🇧 Read in English~10 min read
DevOpssshsecuritynetworkingkeystunnelingsysadmin
Back openDesk Edu for a sovereign, open-source education — every vote counts.
Vote nowSave products you love by clicking the heart icon.
Ein unverzichtbares Referenzwerk für socat — das bidirektionale Daten-Relay-Schweizer Taschenmesser für TCP, UDP, UNIX-Sockets, SSL/TLS, PTY, Dateien und Proxy-Verbindungen.
Ein praktischer Quick-Reference-Guide für Secure Shell-Operationen. Die Befehle sind nach Kategorien organisiert, inklusive gängiger Flags und realistischer Beispiele zu Schlüsselmanagement, Konfiguration, Tunneling, Dateiübertragung und Server-Hardening.
SSH-Keys bieten eine kryptografische Authentifizierung. Ed25519 ist der moderne Standard; RSA wird verwendet, wenn Abwärtskompatibilität erforderlich ist.
# Default ed25519 key
ssh-keygen -t ed25519 -C "user@host"
# Specify output file
ssh-keygen -t ed25519 -f ~/.ssh/mykey -C "user@host"
# Ed25519 with custom key derivation rounds
ssh-keygen -t ed25519 -a 100 -f ~/.ssh/mykey
# 4096-bit RSA (minimum recommended size)
ssh-keygen -t rsa -b 4096 -C "user@host"
# 4096-bit RSA with specific file path
ssh-keygen -t rsa -b 4096 -f ~/.ssh/mykey_rsa -C "user@host"
# Change passphrase on existing key
ssh-keygen -p -f ~/.ssh/id_ed25519
# Change key type comment
ssh-keygen -c -f ~/.ssh/id_ed25519 -C "new-comment@example.com"
# Generate public key from private key
ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub
# Generate fingerprint of a key
ssh-keygen -l -f ~/.ssh/id_ed25519
# Generate visual (randomart) fingerprint
ssh-keygen -lv -f ~/.ssh/id_ed25519
# View public key in RFC 4716 format (for some appliances)
ssh-keygen -e -f ~/.ssh/id_ed25519.pub
# Convert OpenSSH to PEM format (for older systems)
ssh-keygen -p -f ~/.ssh/id_rsa -m pem
# Convert PEM to OpenSSH format
ssh-keygen -p -f ~/.ssh/id_rsa -m RFC4716
# Generate host keys for a server
ssh-keygen -A
# Generate CDP/PKCS#11-compatible key
ssh-keygen -t ecdsa -b 521 -f ~/.ssh/id_ecdsa
# Fingerprint of remote server (verify on first connect)
ssh-keyscan -t ed25519 github.com | ssh-keygen -lf -
# Check all known_hosts fingerprints
ssh-keygen -l -f ~/.ssh/known_hosts
# Search known_hosts for a specific host
ssh-keygen -F github.com
# Remove a specific host from known_hosts
ssh-keygen -R github.com
Der SSH-Agent hält entschlüsselte private Schlüssel im Arbeitsspeicher, sodass Sie sich nur einmal pro Sitzung authentifizieren müssen.
# Start ssh-agent (macOS usually auto-starts it)
eval "$(ssh-agent -s)"
# Start with a specific socket
eval "$(ssh-agent -a /tmp/ssh-agent.sock)"
# Kill the agent
ssh-agent -k
# Standard-Key hinzufügen (~/.ssh/id_ed25519, ~/.ssh/id_rsa)
ssh-add
# Spezifischen Key hinzufügen
ssh-add ~/.ssh/mykey
# Key mit einer Lebensdauer hinzufügen (in Sekunden)
ssh-add -t 3600 ~/.ssh/mykey
# Key hinzufügen und Passphrase via stdin abfragen
cat passphrase.txt | ssh-add ~/.ssh/mykey
# Aktuell im Agenten befindliche Keys auflisten
ssh-add -l
# Keys mit vollständigen Fingerprints auflisten
ssh-add -L
# Spezifischen Key aus dem Agenten entfernen
ssh-add -d ~/.ssh/mykey.pub
ssh-add -D
ssh-add -x
ssh-add -X
### Auto-Loading Keys with Config
```bash
# In ~/.ssh/config hinzufügen, um Schlüssel automatisch zu laden
Host *
AddKeysToAgent yes
IdentityFile ~/.ssh/id_ed25519
IdentityFile ~/.ssh/id_rsa_work
The ~/.ssh/authorized_keys file on the server lists public keys permitted to authenticate.
Each line is one key with optional options:
[options] key-type base64-encoded-key [comment]
# Öffentlichen Schlüssel an einen Remote-Server anhängen (One-Liner)
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server
# Anhängen mit benutzerdefiniertem Port
ssh-copy-id -i ~/.ssh/id_ed25519.pub -p 2222 user@server
# Manuell anhängen (falls ssh-copy-id nicht verfügbar ist)
cat ~/.ssh/id_ed25519.pub | ssh user@server 'mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys && chmod 700 ~/.ssh'
# Schlüssel auf einen bestimmten Befehl beschränken
command="echo 'No shell access allowed'",no-port-forwarding,no-X11-forwarding,no-agent-forwarding ssh-ed25519 AAAA... user@host
# Schlüssel auf bestimmte Quell-IPs beschränken
from="10.0.0.0/8,192.168.1.*" ssh-ed25519 AAAA... user@host
# Schlüssel auf bestimmte Ports beschränken
permitopen="10.0.0.1:3306",permitopen="10.0.0.1:6379" ssh-ed25519 AAAA... user@host
# Keine PTY-Zuweisung erlauben
no-pty ssh-ed25519 AAAA... user@host
# Mehrere Beschränkungen kombinieren
command="/usr/bin/backup.sh",from="10.0.0.100",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-ed25519 AAAA... backup-key
# Ablaufdatum (OpenSSH 6.5+)
expiry="2026-12-31" ssh-ed25519 AAAA... temporary-key
The SSH client config file simplifies connections with aliases and default options.
# ~/.ssh/config
# Persönlicher Server
Host myserver
HostName 192.168.1.50
User admin
Port 2222
IdentityFile ~/.ssh/id_ed25519
# GitHub
Host github.com
HostName github.com
User git
IdentityFile ~/.ssh/id_ed25519_github
# Work Bastion
Host bastion
HostName bastion.company.com
User jumpuser
ForwardAgent yes
# Interner Server via Bastion
Host web-internal
HostName 10.0.1.50
User deploy
ProxyJump bastion
IdentityFile ~/.ssh/id_ed25519_work
# Einstellungen auf alle Hosts in einer Domain anwenden
Host *.company.com
User admin
IdentityFile ~/.ssh/id_ed25519_work
# Alle Hosts matchen (Standardwerte)
Host *
ServerAliveInterval 60
ServerAliveCountMax 3
AddKeysToAgent yes
Compression yes
ForwardX11 no
# Match nach Bedingung (unterstützt ab OpenSSH 7.6)
Host bastion
HostName bastion.company.com
User jumpuser
ForwardAgent yes
# Einstellungen nur für einen bestimmten Host anwenden (Herkunftsprüfung)
Match host 10.0.0.0/8
User admin
IdentityFile ~/.ssh/id_ed25519_internal
# Match basierend auf lokalem Benutzer
Match host gitlab.internal User git
IdentityFile ~/.ssh/id_ed25519_gitlab
# ~/.ssh/config Beispiele
Host myhost
HostName example.com
User deploy
Port 22
IdentityFile ~/.ssh/id_ed25519
# Verbindungseinstellungen
ConnectTimeout 10
ConnectionAttempts 3
ServerAliveInterval 60
ServerAliveCountMax 3
TCPKeepAlive yes
# Sicherheitseinstellungen
StrictHostKeyChecking accept-new
UserKnownHostsFile ~/.ssh/known_hosts
IdentitiesOnly yes
# Forwarding-Einstellungen
ForwardAgent yes
ForwardX11 no
ForwardX11Trusted no
# Logging
LogLevel INFO
# Ciphers und Algorithmen (nur verwenden, wenn für Legacy-Kompatibilität nötig)
# Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
# MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com
# ~/.ssh/config
# Gemeinsame Konfiguration inkludieren
Include ~/.ssh/config.d/*
# Spezifische Dateien inkludieren
Include ~/.ssh/config.d/work
Include ~/.ssh/config.d/personal
# Verbindung mit Standard-Key
ssh user@host
# Verbindung über einen spezifischen Port
ssh -p 2222 user@host
# Verbindung mit einer spezifischen Identity-Datei
ssh -i ~/.ssh/mykey user@host
# Verbindung mit verbose Output (zur Fehlersuche)
ssh -vvv user@host
# Verbindung über Config-Alias
ssh myserver
# Strict Host Key Checking deaktivieren (unsicher, sparsam einsetzen)
ssh -o StrictHostKeyChecking=no user@host
# Einzelnen Befehl auf Remote-Host ausführen
ssh user@host "uptime && df -h"
# Skript auf Remote-Host ausführen
ssh user@host "bash -s" < local_script.sh
# Pseudo-Terminal Zuweisung erzwingen
ssh -t user@host
# SSH-Verbindung im Hintergrund (für Port-Forwarding)
ssh -fN -L 8080:localhost:80 user@host
# Verbindung mit einer spezifischen Cipher
ssh -c aes256-gcm@openssh.com user@host
# Escape-Sequenzen: Enter drücken, dann ~ und dann ? für Hilfe
# ~. - Verbindung beenden
# ~C - Kommandozeile öffnen
# ~# - weitergeleitete Verbindungen auflisten
# ~& - ssh in den Hintergrund schieben
# ~? - Escape-Sequenzen auflisten
Zugriff auf Server hinter Bastion-Hosts oder Jump-Servern.
# One hop via bastion
ssh -J bastion user@internal-server
# Multiple hops
ssh -J bastion1,bastion2 user@internal-server
# Via config file
Host internal-server
HostName 10.0.1.50
User admin
ProxyJump bastion
# With specific port on bastion
ssh -J user@bastion:2222 user@internal-server
# Via netcat
ssh -o ProxyCommand="nc -x bastion:1080 %h %p" user@internal-server
# Via another SSH connection
ssh -o ProxyCommand="ssh -W %h:%p bastion" user@internal-server
# Via HTTP CONNECT proxy
ssh -o ProxyCommand="socat - PROXY:proxy.example.com:%h:%p,proxyport=8080" user@internal-server
# Via config file
Host internal-server
HostName 10.0.1.50
User admin
ProxyCommand ssh -W %h:%p bastion
# Via SOCKS5 proxy using nc (OpenBSD netcat)
Host internal-server
ProxyCommand nc -X 5 -x proxy.example.com:1080 %h %p
# ~/.ssh/config
Host bastion
HostName bastion.company.com
User jumpuser
IdentityFile ~/.ssh/id_ed25519_bastion
Host staging-db
HostName 10.10.0.50
User postgres
ProxyJump bastion
IdentityFile ~/.ssh/id_ed25519_db
Host prod-app
HostName 10.20.0.10
User deploy
ProxyJump bastion
ForwardAgent yes
IdentityFile ~/.ssh/id_ed25519_prod
# Two-hop jump: local -> bastion -> jumphost -> target
Host final-target
HostName 10.30.0.5
User admin
ProxyJump staging-db
IdentityFile ~/.ssh/id_ed25519_final
SSH kann Traffic über verschlüsselte Kanäle tunneln, um auf Remote-Dienste zuzugreifen.
Leitet einen Port auf Ihrer lokalen Maschine an einen Port auf dem Remote-Server (oder an einen von dort erreichbaren Host) weiter.
# Forward local port 8080 to remote host's port 80
ssh -L 8080:localhost:80 user@remote
# Forward local port 3306 to a remote database server
# (access MySQL on 10.0.0.5:3306 via localhost:3306)
ssh -L 3306:10.0.0.5:3306 user@bastion
# Forward local port 5432 to PostgreSQL on a private server
ssh -L 5432:db.internal:5432 user@bastion
# Bind to all interfaces (0.0.0.0) instead of localhost
ssh -L 0.0.0.0:8080:localhost:80 user@remote
# Background tunnel
ssh -fN -L 8080:localhost:80 user@remote
Leitet einen Port auf dem Remote-Server zurück an Ihre lokale Maschine weiter.
# Allow remote server to access your local port 3000
ssh -R 3000:localhost:3000 user@remote
# Make the remote listen on all interfaces (GatewayPorts)
ssh -R 0.0.0.0:8080:localhost:80 user@remote
# Persistent remote tunnel (keep alive)
ssh -o ServerAliveInterval=60 -fN -R 2222:localhost:22 user@remote
Erstellt einen SOCKS-Proxy, der den gesamten Traffic über die SSH-Verbindung routet.
# SOCKS5 proxy on local port 1080
ssh -D 1080 user@remote
# SOCKS5-Proxy an alle Schnittstellen gebunden
ssh -D 0.0.0.0:1080 user@remote
# SOCKS-Proxy im Hintergrund
ssh -fN -D 1080 user@remote
# Verwendung mit curl
curl --socks5 localhost:1080 http://internal-service:8080
# Verwendung mit Umgebungsvariable
export ALL_PROXY=socks5://localhost:1080
curl http://internal-service:8080
# Verwendung mit Firefox: Einstellungen > Netzwerk > Manueller Proxy > SOCKS-Host: localhost, Port: 1080
# ~/.ssh/config
Host tunnel-db
HostName bastion.company.com
User jumpuser
LocalForward 3306 db.internal:3306
LocalForward 5432 db.internal:5432
LocalForward 6379 redis.internal:6379
ServerAliveInterval 60
ServerAliveCountMax 3
# Verbinden und alle Tunnel aufbauen
ssh -fN tunnel-db
Run graphical applications on a remote server and display them locally.
# X11-Forwarding aktivieren
ssh -X user@remote
# Vertrauenswürdiges X11-Forwarding (weniger sicher, aber von einigen Apps benötigt)
ssh -Y user@remote
# Über Config
Host gui-server
HostName server.example.com
ForwardX11 yes
ForwardX11Trusted no
# Lokale Datei auf Remote-Server kopieren
scp file.txt user@remote:/path/to/destination/
# Remote-Datei lokal kopieren
scp user@remote:/path/to/file.txt ./
# Verzeichnis rekursiv kopieren
scp -r ./local_dir/ user@remote:/path/to/destination/
# Kopieren über einen spezifischen Port
scp -P 2222 file.txt user@remote:/path/
# Kopieren mit spezifischer Identity
scp -i ~/.ssh/mykey file.txt user@remote:/path/
# Berechtigungen und Zeitstempel beibehalten
scp -p file.txt user@remote:/path/
# Während der Übertragung komprimieren
scp -C largefile.tar.gz user@remote:/path/
# Kopieren zwischen zwei Remote-Servern (von der lokalen Maschine aus)
scp user@remote1:/path/file.txt user@remote2:/path/
# Bandbreite begrenzen (Kbit/s)
scp -l 1024 largefile.iso user@remote:/path/
# Interaktive SFTP-Sitzung
sftp user@remote
# SFTP mit spezifischem Port
sftp -P 2222 user@remote
# SFTP mit Config-Alias
sftp myserver
# Batch-Modus (aus einer Datei mit Befehlen)
sftp -b batch_commands.txt user@remote
# Innerhalb des sftp-Prompts:
# Remote-Dateisystem navigieren
ls # Remote-Dateien auflisten
cd /path # Remote-Verzeichnis wechseln
pwd # Aktuelles Remote-Arbeitsverzeichnis anzeigen
# Lokales Dateisystem navigieren
lls # Lokale Dateien auflisten
lcd /path # Lokales Verzeichnis wechseln
lpwd # Aktuelles lokales Arbeitsverzeichnis anzeigen
# Dateien übertragen
put localfile.txt # Datei hochladen
put -r localdir/ # Verzeichnis rekursiv hochladen
get remotefile.txt # Datei herunterladen
get -r remotedir/ # Verzeichnis rekursiv herunterladen
# Dateioperationen
mkdir remote_dir # Remote-Verzeichnis erstellen
rm remotefile.txt # Remote-Datei entfernen
rmdir remote_dir # Remote-Verzeichnis entfernen
chmod 644 remotefile # Remote-Berechtigungen ändern
chown user remotefile # Remote-Besitzverhältnisse ändern
# Sonstiges
rename oldname newname # Remote-Datei umbenennen
symlink src target # Symbolischen Link erstellen
exit # Verbindung schließen
# Lokales Verzeichnis mit Remote synchronisieren
rsync -avz -e ssh ./local_dir/ user@remote:/path/to/destination/
# Remote mit lokal synchronisieren
rsync -avz -e ssh user@remote:/path/to/source/ ./local_dir/
# Synchronisierung mit Fortschrittsanzeige und Unterstützung für partielle Übertragungen
rsync -avzP -e ssh ./local_dir/ user@remote:/path/
# Dry run (anzeigen, was übertragen würde)
rsync -avzn -e ssh ./local_dir/ user@remote:/path/
# Dateien auf dem Ziel löschen, die lokal nicht existieren
rsync -avz --delete -e ssh ./local_dir/ user@remote:/path/
# Verwendung mit benutzerdefiniertem Port und Key
rsync -avz -e "ssh -p 2222 -i ~/.ssh/mykey" ./dir/ user@remote:/path/
# Ausschlussmuster
rsync -avz --exclude='*.log' --exclude='node_modules/' -e ssh ./dir/ user@remote:/path/
Secure the SSH server by editing /etc/ssh/sshd_config.
# /etc/ssh/sshd_config
# === Authentifizierung ===
# Root-Login deaktivieren
PermitRootLogin no
# Passwort-Authentifizierung deaktivieren (nur Keys)
PasswordAuthentication no
# Leere Passwörter deaktivieren
PermitEmptyPasswords no
# Tastatur-interaktive Authentifizierung deaktivieren
KbdInteractiveAuthentication no
# PAM verwenden (auf no setzen, falls nicht benötigt)
UsePAM no
# === Key- und Algorithmus-Einstellungen ===
# Nur starke Key-Typen akzeptieren
PubkeyAcceptedAlgorithms ssh-ed25519,sk-ssh-ed25519@openssh.com,ecdsa-sha2-nistp256,rsa-sha2-512,rsa-sha2-256
# Starke Host-Key-Algorithmen
HostKeyAlgorithms ssh-ed25519,ecdsa-sha2-nistp256,rsa-sha2-512
# Starke Ciphers
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com
# Starke MACs
MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com
# Starke KEX-Algorithmen
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
# === Zugriffskontrolle ===
# Nur spezifische Benutzer zulassen
AllowUsers deploy admin
# Nur spezifische Gruppen zulassen
AllowGroups ssh-users
# Spezifische Benutzer ablehnen
DenyUsers guest
# === Netzwerkeinstellungen ===
# Standard-Port ändern
Port 2222
# Nur auf spezifischer Adresse lauschen
ListenAddress 0.0.0.0
ListenAddress ::
# === Session-Einstellungen ===
# Idle-Timeout festlegen (Sekunden)
ClientAliveInterval 300
ClientAliveCountMax 2
# Maximale Authentifizierungsversuche begrenzen
MaxAuthTries 3
# Maximale Sessions pro Verbindung begrenzen
MaxSessions 5
# Maximale nicht authentifizierte Verbindungen begrenzen
MaxStartups 3:50:10
# .rhosts-Datei deaktivieren
IgnoreRhosts yes
# Host-basierte Authentifizierung deaktivieren
HostbasedAuthentication no
# X11-Forwarding deaktivieren, falls nicht benötigt
X11Forwarding no
# Tunneling deaktivieren, falls nicht benötigt
PermitTunnel no
# Agent-Forwarding deaktivieren, falls nicht benötigt
AllowAgentForwarding no
# Port-Forwarding deaktivieren, falls nicht benötigt
AllowTcpForwarding no
PermitOpen none
# Reverse-Shell-Zugriff deaktivieren
PermitUserEnvironment no
# === Logging ===
SyslogFacility AUTH
LogLevel VERBOSE
# === Banner ===
Banner /etc/ssh/banner
# Konfigurationssyntax vor dem Neuladen prüfen
sudo sshd -t
# sshd neu starten (systemd)
sudo systemctl restart sshd
# sshd neu laden (bestehende Verbindungen bleiben erhalten)
sudo systemctl reload sshd
# sshd-Status prüfen
sudo systemctl status sshd
# Prüfen, ob sshd auf dem erwarteten Port lauscht
ss -tlnp | grep sshd
# Ausführliche Verbindung (Handshake, Authentifizierung und Schlüsselaustausch anzeigen)
ssh -vvv user@host
# Nur Authentifizierungs-Debugging anzeigen
ssh -vv user@host
# Verbindung testen, ohne einen Befehl auszuführen
ssh -o BatchMode=yes -o ConnectTimeout=5 user@host echo "OK"
# Prüfen, welcher Schlüssel angeboten wird
ssh -v user@host 2>&1 | grep "Offering"
# Unterstützte Algorithmen auf dem Remote-Server prüfen
ssh -Q key
ssh -Q cipher
ssh -Q mac
ssh -Q kex
# "Permission denied (publickey)"
# -> Schlüsselberechtigungen prüfen
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub
chmod 600 ~/.ssh/authorized_keys
# Prüfen, ob der Schlüssel im Agent geladen ist
ssh-add -l
# "Connection refused"
# -> Überprüfen, ob SSH läuft und auf dem erwarteten Port aktiv ist
systemctl status sshd
ss -tlnp | grep sshd
# "Connection timed out"
# -> Firewall, Security Groups oder Netzwerk-Routing prüfen
telnet host 22
nc -zv host 22
nmap -p 22 host
# "Host key verification failed"
# -> Server neu installiert oder IP geändert; alten Schlüssel entfernen
ssh-keygen -R hostname
ssh-keygen -R 192.168.1.50
# "WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED"
# -> Möglicher MITM-Angriff oder Server-Neuinstallation
# -> Wenn die Änderung vertrauenswürdig ist:
ssh-keygen -R hostname
# "Too many authentication failures"
# -> Server lehnt nach MaxAuthTries ab
# -> Den korrekten Schlüssel explizit angeben
ssh -i ~/.ssh/correct_key user@host
# Agent wird nicht über Jump-Host weitergeleitet
# -> Prüfen, ob ForwardAgent yes in der Konfiguration gesetzt ist
# -> Prüfen, ob der Agent lokal läuft
echo $SSH_AUTH_SOCK
ssh-add -l
# Effektive Konfiguration für einen bestimmten Host anzeigen
ssh -G myserver
# Effektive Konfiguration für einen bestimmten Host anzeigen (verbose)
ssh -Gv myserver
# Verbindung mit einer spezifischen Konfigurationsdatei testen
ssh -F /path/to/custom_config user@host
# Prüfen, welche Konfigurationsdatei verwendet wird
ssh -V
SSH certificates provide centralized key management, avoiding the need to distribute individual public keys.
# CA-Key generieren (einmalig ausführen, sicher aufbewahren)
ssh-keygen -t ed25519 -f ca_key -C "SSH Certificate Authority"
# Der öffentliche Schlüssel (ca_key.pub) ist der Teil, den Sie verteilen
# Den öffentlichen Schlüssel eines Benutzers signieren, gültig für 52 Wochen
ssh-keygen -s ca_key \
-I user_john_2026 \
-n john,deploy \
-V +52w \
~/.ssh/id_ed25519.pub
# Signieren mit einem spezifischen Gültigkeitszeitraum
ssh-keygen -s ca_key \
-I user_john_2026 \
-n john \
-V 20260101:20261231 \
-O no-port-forwarding \
~/.ssh/id_ed25519.pub
# Zertifikatsdetails anzeigen
ssh-keygen -L -f ~/.ssh/id_ed25519-cert.pub
# Den öffentlichen Schlüssel eines Hosts signieren
ssh-keygen -s ca_key \
-I host_webserver_2026 \
-h \
-n webserver.example.com,10.0.0.50 \
-V +52w \
/etc/ssh/ssh_host_ed25519_key.pub
# Host-Zertifikatsdetails anzeigen
ssh-keygen -L -f /etc/ssh/ssh_host_ed25519_key-cert.pub
# /etc/ssh/sshd_config — diese Zeile hinzufügen
TrustedUserCAKeys /etc/ssh/ca_user.pub
# sshd neu starten
sudo systemctl restart sshd
# ~/.ssh/config — Host-Zertifikate vertrauen, die von der CA signiert wurden
Host *.example.com
@cert-authority *.example.com ssh-ed25519 AAAA...CA_PUBLIC_KEY_HERE
# Oder in ~/.ssh/known_hosts:
@cert-authority *.example.com ssh-ed25519 AAAA...CA_PUBLIC_KEY_HERE
# ed25519 für alle neuen Schlüssel verwenden (kleiner, schneller, sicherer)
ssh-keygen -t ed25519 -C "purpose-identifier"
# Einzigartige Schlüssel pro Dienst verwenden (unabhängig rotieren)
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_github -C "github"
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_work -C "work"
# Immer eine Passphrase für private Schlüssel festlegen
# Private Schlüssel niemals teilen oder committen
# Schlüssel periodisch rotieren (mindestens jährlich)
# Alte Schlüssel nach der Rotation aus authorized_keys entfernen
# Hardware-Sicherheitsschlüssel (FIDO2/U2F) für kritische Zugriffe verwenden
ssh-keygen -t ed25519-sk -C "hardware-key@example.com"
# Passwort-Authentifizierung vollständig deaktivieren
PasswordAuthentication no
# Root-Login deaktivieren
PermitRootLogin no
# fail2ban verwenden, um Brute-Force-Angriffe zu blockieren
sudo apt install fail2ban
sudo systemctl enable fail2ban
# Einschränkung nach Benutzer oder Gruppe
AllowUsers deploy admin
AllowGroups ssh-users
# Standard-Port ändern, um Rauschen durch Scanner zu reduzieren
Port 2222
# OpenSSH aktuell halten
sudo apt update && sudo apt upgrade openssh-server
# Firewall verwenden, um den SSH-Zugriff einzuschränken
sudo ufw allow 2222/tcp from 10.0.0.0/8
# SSH-Konfiguration nutzen, um Verbindungen im Team zu standardisieren
# Team-Konfigurationen in der Versionsverwaltung speichern (ausgenommen private Keys)
# ProxyJump anstelle von verketteten SSH-Befehlen verwenden
# Gut: ssh -J bastion target
# Vermeiden: ssh bastion "ssh target"
# Connection Keepalive setzen, um Verbindungsabbrüche bei Inaktivität zu verhindern
Host *
ServerAliveInterval 60
ServerAliveCountMax 3
# In Skripten -o BatchMode=yes verwenden, um interaktive Abfragen zu verhindern
ssh -o BatchMode=yes user@host "command"
# authorized_keys regelmäßig prüfen
# Veraltete oder ungenutzte Einträge entfernen
# -V Ablaufdaten bei zertifikatsbasierter Authentifizierung verwenden
# Auth-Logs überwachen
sudo journalctl -u sshd -f
sudo tail -f /var/log/auth.log
# Eine Key Revocation List (KRL) erstellen
ssh-keygen -k -f revoked_keys.krl revoked_key1.pub revoked_key2.pub
# Eine bestehende KRL aktualisieren
ssh-keygen -k -u -f revoked_keys.krl new_revoked_key.pub
# Server so konfigurieren, dass die KRL geprüft wird
# /etc/ssh/sshd_config
RevokedKeys /etc/ssh/revoked_keys.krl
# Prüfen, ob ein Zertifikat widerrufen wurde
ssh-keygen -Q -f revoked_keys.krl ~/.ssh/id_ed25519-cert.pub