sammlung:ssh

Inhaltsverzeichnis

SSH (Secure Shell)

SSH (Secure Shell)

SSH ist ein verschlüsseltes Netzwerkprotokoll für die sichere Fernverwaltung von Computern und die sichere Datenübertragung über unsichere Netzwerke. Es wird hauptsächlich für Remote-Login, Dateitransfer und Tunnel verwendet.

SSH installieren

Debian / Ubuntu

# SSH-Server installieren
sudo apt update
sudo apt install openssh-server

# SSH-Client installieren (meist bereits installiert)
sudo apt install openssh-client

# Status prüfen
sudo systemctl status ssh

RHEL / CentOS / Fedora

# SSH-Server installieren
sudo dnf install openssh-server

# SSH-Client installieren
sudo dnf install openssh-clients

# Status prüfen
sudo systemctl status sshd

openSUSE

# SSH-Server installieren
sudo zypper install openssh

# Status prüfen
sudo systemctl status sshd

Arch Linux

# SSH-Server installieren
sudo pacman -S openssh

# Status prüfen
sudo systemctl status sshd

SSH-Dienst verwalten

# SSH-Dienst starten
sudo systemctl start sshd    # RHEL/Fedora/openSUSE/Arch
sudo systemctl start ssh     # Debian/Ubuntu

# Automatischer Start beim Booten
sudo systemctl enable sshd   # RHEL/Fedora/openSUSE/Arch
sudo systemctl enable ssh    # Debian/Ubuntu

# SSH-Dienst neu starten (nach Konfigurationsänderungen)
sudo systemctl restart sshd
sudo systemctl restart ssh

# SSH-Dienst stoppen
sudo systemctl stop sshd
sudo systemctl stop ssh

SSH-Dateien Server

Hauptkonfigurationsdatei

/etc/ssh/sshd_config           # SSH-Server-Hauptkonfiguration

Wichtige Optionen in `/etc/ssh/sshd_config`:

Port 22                        # Standard-SSH-Port
ListenAddress 0.0.0.0          # Auf allen Interfaces lauschen
PermitRootLogin no             # Root-Login verbieten (empfohlen)
PasswordAuthentication yes     # Passwort-Login erlauben
PubkeyAuthentication yes       # Public-Key-Authentifizierung erlauben
AuthorizedKeysFile .ssh/authorized_keys  # Pfad zu autorisierten Schlüsseln
X11Forwarding yes              # X11-Forwarding erlauben
MaxAuthTries 3                 # Maximale Anmeldeversuche
ClientAliveInterval 300        # Keep-Alive in Sekunden
AllowUsers user1 user2         # Nur bestimmte Benutzer erlauben
DenyUsers baduser              # Bestimmte Benutzer verbieten

Host-Schlüssel

/etc/ssh/ssh_host_rsa_key          # RSA Host-Schlüssel (privat)
/etc/ssh/ssh_host_rsa_key.pub      # RSA Host-Schlüssel (öffentlich)
/etc/ssh/ssh_host_ecdsa_key        # ECDSA Host-Schlüssel (privat)
/etc/ssh/ssh_host_ecdsa_key.pub    # ECDSA Host-Schlüssel (öffentlich)
/etc/ssh/ssh_host_ed25519_key      # ED25519 Host-Schlüssel (privat)
/etc/ssh/ssh_host_ed25519_key.pub  # ED25519 Host-Schlüssel (öffentlich)

Weitere Konfigurationsdateien

/etc/ssh/sshd_config               # Globale Client-Konfiguration
/etc/ssh/sshd_config.d/            # Zusätzliche Server-Konfigurationen

/etc/ssh/ssh_config                # Globale Client-Konfiguration
/etc/ssh/ssh_config.d/             # Zusätzliche Client-Konfigurationen

Logs

/var/log/auth.log                  # SSH-Login-Logs (Debian/Ubuntu)
/var/log/secure                    # SSH-Login-Logs (RHEL/CentOS)

# Logs anzeigen
sudo tail -f /var/log/auth.log
sudo journalctl -u sshd -f

SSH-Dateien User

User-Verzeichnis

~/.ssh/                            # User-SSH-Verzeichnis
~/.ssh/id_rsa                      # Privater RSA-Schlüssel
~/.ssh/id_rsa.pub                  # Öffentlicher RSA-Schlüssel
~/.ssh/id_ed25519                  # Privater ED25519-Schlüssel (empfohlen)
~/.ssh/id_ed25519.pub              # Öffentlicher ED25519-Schlüssel
~/.ssh/authorized_keys             # Autorisierte öffentliche Schlüssel (Server)
~/.ssh/known_hosts                 # Bekannte Host-Schlüssel
~/.ssh/config                      # User-SSH-Client-Konfiguration

Berechtigungen setzen (wichtig!)

# Korrekte Berechtigungen für .ssh-Verzeichnis
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys
chmod 644 ~/.ssh/known_hosts
chmod 600 ~/.ssh/config

User-SSH-Config

# ~/.ssh/config
Host myserver
    HostName 192.168.1.100
    User username
    Port 22
    IdentityFile ~/.ssh/id_ed25519

Host github
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_github

Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3

SSH-Key erstellen

ED25519-Schlüssel erstellen (empfohlen)

# Neuen ED25519-Schlüssel erstellen
ssh-keygen -t ed25519 -C "user@email.com"

# Mit eigenem Dateinamen
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_custom -C "user@email.com"

# Ohne Passphrase (nicht empfohlen für produktive Systeme)
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519 -N ""

RSA-Schlüssel erstellen (4096 Bit)

# RSA mit 4096 Bit (sicherer als Standard 2048)
ssh-keygen -t rsa -b 4096 -C "user@email.com"

# Mit eigenem Dateinamen
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa_custom -C "user@email.com"

ECDSA-Schlüssel erstellen

# ECDSA mit 521 Bit
ssh-keygen -t ecdsa -b 521 -C "user@email.com"

Interaktiver Prozess

# Beim Erstellen werden Sie gefragt:
# 1. Speicherort (Enter für Standard: ~/.ssh/id_ed25519)
# 2. Passphrase (empfohlen für Sicherheit)
# 3. Passphrase wiederholen

# Beispiel-Ausgabe:
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519): 
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/user/.ssh/id_ed25519
Your public key has been saved in /home/user/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:... user@email.com

Öffentlichen Schlüssel anzeigen

# Öffentlichen Schlüssel anzeigen
cat ~/.ssh/id_ed25519.pub
cat ~/.ssh/id_rsa.pub

# Fingerprint anzeigen
ssh-keygen -lf ~/.ssh/id_ed25519.pub
ssh-keygen -lf ~/.ssh/id_rsa.pub

SSH-Key verwalten

Öffentlichen Schlüssel auf Server kopieren

# Automatisch mit ssh-copy-id (empfohlen)
ssh-copy-id user@server
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# Mit spezifischem Port
ssh-copy-id -i ~/.ssh/id_ed25519.pub -p 2222 user@server

# Manuell (wenn ssh-copy-id nicht verfügbar)
cat ~/.ssh/id_ed25519.pub | ssh user@server "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

# Oder mit scp
scp ~/.ssh/id_ed25519.pub user@server:~/.ssh/authorized_keys

# Berechtigungen auf Server prüfen
ssh user@server "chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys"

SSH-Agent verwenden

# SSH-Agent starten
eval "$(ssh-agent -s)"

# Schlüssel zum Agent hinzufügen
ssh-add ~/.ssh/id_ed25519
ssh-add ~/.ssh/id_rsa

# Schlüssel mit Timeout hinzufügen (1 Stunde)
ssh-add -t 3600 ~/.ssh/id_ed25519

# Geladene Schlüssel anzeigen
ssh-add -l

# Alle Schlüssel aus Agent entfernen
ssh-add -D

# Spezifischen Schlüssel entfernen
ssh-add -d ~/.ssh/id_ed25519

Passphrase ändern

# Passphrase eines bestehenden Schlüssels ändern
ssh-keygen -p -f ~/.ssh/id_ed25519

# Passphrase entfernen (leer lassen)
ssh-keygen -p -f ~/.ssh/id_ed25519 -N ""

Schlüssel konvertieren

# Öffentlichen Schlüssel aus privatem generieren
ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub

# PEM-Format konvertieren (für ältere Systeme)
ssh-keygen -p -f ~/.ssh/id_rsa -m pem

Autorisierte Schlüssel verwalten

# authorized_keys auf Server
cat ~/.ssh/authorized_keys        # Alle autorisierten Schlüssel anzeigen

# Schlüssel hinzufügen
echo "ssh-ed25519 AAAA..." >> ~/.ssh/authorized_keys

# Optionen für Schlüssel
# no-port-forwarding,no-X11-forwarding ssh-ed25519 AAAA...
# from="192.168.1.0/24" ssh-ed25519 AAAA...
# command="/usr/bin/backup.sh" ssh-ed25519 AAAA...

# Duplikate entfernen und sortieren
sort -u ~/.ssh/authorized_keys -o ~/.ssh/authorized_keys

Schlüssel testen

# Verbindung mit spezifischem Schlüssel testen
ssh -i ~/.ssh/id_ed25519 user@server

# Verbose-Modus für Debugging
ssh -v user@server
ssh -vv user@server       # Mehr Details
ssh -vvv user@server      # Maximum Details

# Nur Authentifizierung testen (ohne Shell)
ssh -T user@server

Bekannte Hosts verwalten

# Host aus known_hosts entfernen (bei Hostkey-Änderung)
ssh-keygen -R hostname
ssh-keygen -R 192.168.1.100

# Bekannte Hosts anzeigen
cat ~/.ssh/known_hosts

# Hostkey vorab hinzufügen
ssh-keyscan hostname >> ~/.ssh/known_hosts
ssh-keyscan -H hostname >> ~/.ssh/known_hosts  # Mit Hash

Mehrere SSH-Keys verwalten

# In ~/.ssh/config verschiedene Keys für verschiedene Hosts
Host work
    HostName work.example.com
    User workuser
    IdentityFile ~/.ssh/id_work

Host personal
    HostName personal.example.com
    User homeuser
    IdentityFile ~/.ssh/id_personal

Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_github_work

Host github-personal
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_github_personal

SSH-Verbindung herstellen

Grundlegende Verbindung

# Standard-Verbindung
ssh user@hostname
ssh user@192.168.1.100

# Mit spezifischem Port
ssh -p 2222 user@hostname

# Mit spezifischem Schlüssel
ssh -i ~/.ssh/id_custom user@hostname

# Befehl auf Remote-System ausführen
ssh user@hostname "ls -la"
ssh user@hostname "sudo systemctl status nginx"

Port-Forwarding

# Lokalen Port weiterleiten (Local Port Forwarding)
ssh -L 8080:localhost:80 user@server
# Dann http://localhost:8080 im Browser öffnen

# Remote Port Forwarding
ssh -R 8080:localhost:80 user@server

# Dynamic Port Forwarding (SOCKS-Proxy)
ssh -D 1080 user@server

X11-Forwarding

# X11-Anwendungen remote ausführen
ssh -X user@server
ssh -Y user@server    # Trusted X11 Forwarding (weniger sicher)

# Beispiel: Firefox remote starten
ssh -X user@server firefox

SSH-Tunneling

# SSH-Tunnel im Hintergrund
ssh -fN -L 3306:localhost:3306 user@server

# -f: Im Hintergrund
# -N: Keine Remote-Befehle ausführen

SSH absichern

Server-Konfiguration härten

# /etc/ssh/sshd_config bearbeiten
sudo nano /etc/ssh/sshd_config

# Empfohlene Sicherheitseinstellungen:
Port 2222                          # Nicht-Standard-Port
PermitRootLogin no                 # Root-Login verbieten
PasswordAuthentication no          # Nur Key-basierte Auth
PubkeyAuthentication yes           # Public-Key-Auth aktivieren
PermitEmptyPasswords no            # Leere Passwörter verbieten
MaxAuthTries 3                     # Max. Anmeldeversuche
LoginGraceTime 30                  # Timeout für Login
AllowUsers user1 user2             # Nur bestimmte User erlauben
Protocol 2                         # Nur SSH-2-Protokoll
X11Forwarding no                   # X11 deaktivieren (wenn nicht benötigt)
AllowTcpForwarding no              # Port-Forwarding deaktivieren (optional)

# Nach Änderungen neu starten
sudo systemctl restart sshd

Fail2Ban einrichten

# Fail2Ban installieren (automatische IP-Sperre nach Fehlversuchen)
sudo apt install fail2ban         # Debian/Ubuntu
sudo dnf install fail2ban         # Fedora/RHEL
sudo zypper install fail2ban      # openSUSE

# Konfiguration
sudo nano /etc/fail2ban/jail.local

[sshd]
enabled = true
port = 22
maxretry = 3
bantime = 3600
findtime = 600

# Fail2Ban starten
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

# Status prüfen
sudo fail2ban-client status sshd

Firewall-Regeln

# UFW (Debian/Ubuntu)
sudo ufw allow 22/tcp
sudo ufw allow from 192.168.1.0/24 to any port 22  # Nur aus lokalem Netz

# firewalld (RHEL/Fedora)
sudo firewall-cmd --permanent --add-service=ssh
sudo firewall-cmd --reload

# iptables
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

Zwei-Faktor-Authentifizierung (2FA)

# Google Authenticator installieren
sudo apt install libpam-google-authenticator

# Als User konfigurieren
google-authenticator

# PAM konfigurieren
sudo nano /etc/pam.d/sshd
# Zeile hinzufügen:
auth required pam_google_authenticator.so

# sshd_config anpassen
sudo nano /etc/ssh/sshd_config
ChallengeResponseAuthentication yes

sudo systemctl restart sshd

SSH-Troubleshooting

Verbindungsprobleme diagnostizieren

# Verbose-Modus für detaillierte Ausgabe
ssh -vvv user@server

# SSH-Dienst-Status prüfen
sudo systemctl status sshd

# Port-Verfügbarkeit testen
telnet hostname 22
nc -zv hostname 22

# Firewall prüfen
sudo ufw status
sudo firewall-cmd --list-all
sudo iptables -L

# Logs überprüfen
sudo tail -f /var/log/auth.log    # Debian/Ubuntu
sudo tail -f /var/log/secure       # RHEL/CentOS
sudo journalctl -u sshd -f

Häufige Fehler

# "Permission denied (publickey)"
# Lösung: Berechtigungen prüfen
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub
chmod 600 ~/.ssh/authorized_keys

# "Host key verification failed"
# Lösung: Host aus known_hosts entfernen
ssh-keygen -R hostname

# "Connection refused"
# Lösung: SSH-Dienst läuft nicht oder Firewall blockiert
sudo systemctl start sshd
sudo ufw allow 22

# "Too many authentication failures"
# Lösung: Weniger Schlüssel im SSH-Agent oder IdentitiesOnly verwenden
ssh -o IdentitiesOnly=yes -i ~/.ssh/id_ed25519 user@server

Konfiguration testen

# SSH-Config-Syntax testen
sudo sshd -t

# Extended Test mit Konfigurationsausgabe
sudo sshd -T

# SSH-Client-Konfiguration testen
ssh -G hostname

Best Practices

ED25519-Schlüssel verwenden - Moderner, sicherer und schneller als RSA
Passphrase für Schlüssel - Privaten Schlüssel mit Passphrase schützen
SSH-Agent nutzen - Bequemes Arbeiten mit geschützten Schlüsseln
Root-Login deaktivieren - PermitRootLogin no in sshd_config
Key-basierte Authentifizierung - Passwort-Login deaktivieren
Nicht-Standard-Port - SSH-Port ändern (z.B. 2222)
Fail2Ban installieren - Automatischer Schutz vor Brute-Force
Regelmäßige Updates - OpenSSH aktuell halten
Berechtigungen prüfen - .ssh-Verzeichnis und Dateien korrekt setzen
Firewall konfigurieren - Nur notwendige Zugriffe erlauben
Logs überwachen - Verdächtige Aktivitäten erkennen
Backup der Schlüssel - Private Schlüssel sicher aufbewahren

Siehe auch

Weitere Informationen

man ssh
man sshd
man sshd_config
man ssh-keygen
man ssh-copy-id
man ssh-agent
man ssh-add

cli, security, remote-access, protocol, basics, advanced