===== 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 ===
<code>
# 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
</code>

=== RHEL / CentOS / Fedora ===
<code>
# SSH-Server installieren
sudo dnf install openssh-server

# SSH-Client installieren
sudo dnf install openssh-clients

# Status prüfen
sudo systemctl status sshd
</code>

=== openSUSE ===
<code>
# SSH-Server installieren
sudo zypper install openssh

# Status prüfen
sudo systemctl status sshd
</code>

=== Arch Linux ===
<code>
# SSH-Server installieren
sudo pacman -S openssh

# Status prüfen
sudo systemctl status sshd
</code>

=== SSH-Dienst verwalten ===
<code>
# 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
</code>

==== SSH-Dateien Server ====

=== Hauptkonfigurationsdatei ===
<code>
/etc/ssh/sshd_config           # SSH-Server-Hauptkonfiguration     
</code>

Wichtige Optionen in `/etc/ssh/sshd_config`:
<code>
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
</code>

=== Host-Schlüssel ===
<code>
/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)
</code>

=== Weitere Konfigurationsdateien ===
<code>
/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
</code>

=== Logs ===
<code>
/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
</code>

==== SSH-Dateien User ====

=== User-Verzeichnis ===
<code>
~/.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
</code>

=== Berechtigungen setzen (wichtig!) ===
<code>
# 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
</code>

=== User-SSH-Config ===
<code>
# ~/.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
</code>

==== SSH-Key erstellen ====

=== ED25519-Schlüssel erstellen (empfohlen) ===
<code>
# 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 ""
</code>

=== RSA-Schlüssel erstellen (4096 Bit) ===
<code>
# 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"
</code>

=== ECDSA-Schlüssel erstellen ===
<code>
# ECDSA mit 521 Bit
ssh-keygen -t ecdsa -b 521 -C "user@email.com"
</code>

=== Interaktiver Prozess ===
<code>
# 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
</code>

=== Öffentlichen Schlüssel anzeigen ===
<code>
# Ö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
</code>

==== SSH-Key verwalten ====

=== Öffentlichen Schlüssel auf Server kopieren ===
<code>
# 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"
</code>

=== SSH-Agent verwenden ===
<code>
# 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
</code>

=== Passphrase ändern ===
<code>
# 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 ""
</code>

=== Schlüssel konvertieren ===
<code>
# Ö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
</code>

=== Autorisierte Schlüssel verwalten ===
<code>
# 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
</code>

=== Schlüssel testen ===
<code>
# 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
</code>

=== Bekannte Hosts verwalten ===
<code>
# 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
</code>

=== Mehrere SSH-Keys verwalten ===
<code>
# 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
</code>

==== SSH-Verbindung herstellen ====

=== Grundlegende Verbindung ===
<code>
# 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"
</code>

=== Port-Forwarding ===
<code>
# 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
</code>

=== X11-Forwarding ===
<code>
# 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
</code>

=== SSH-Tunneling ===
<code>
# SSH-Tunnel im Hintergrund
ssh -fN -L 3306:localhost:3306 user@server

# -f: Im Hintergrund
# -N: Keine Remote-Befehle ausführen
</code>

==== SSH absichern ====

=== Server-Konfiguration härten ===
<code>
# /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
</code>

=== Fail2Ban einrichten ===
<code>
# 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
</code>

=== Firewall-Regeln ===
<code>
# 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
</code>

=== Zwei-Faktor-Authentifizierung (2FA) ===
<code>
# 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
</code>

==== SSH-Troubleshooting ====

=== Verbindungsprobleme diagnostizieren ===
<code>
# 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
</code>

=== Häufige Fehler ===
<code>
# "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
</code>

=== Konfiguration testen ===
<code>
# SSH-Config-Syntax testen
sudo sshd -t

# Extended Test mit Konfigurationsausgabe
sudo sshd -T

# SSH-Client-Konfiguration testen
ssh -G hostname
</code>

==== 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 ====

  * [[sammlung:scp|SCP - Secure Copy]]
  * [[sammlung:sftp|SFTP - SSH File Transfer Protocol]]
  * [[sammlung:rsync|Rsync über SSH]]
  * [[sammlung:sshd_config|sshd_config]]
  * [[sammlung:ssh-keygen|ssh-keygen]]
  * [[sammlung:dot_ssh|~/.ssh]]
  * [[sammlung:ssh_tunnel|SSH-Tunnel]]
  * [[sammlung:systemd|Systemd-Dienste]]

==== Weitere Informationen ====

<code>
man ssh
man sshd
man sshd_config
man ssh-keygen
man ssh-copy-id
man ssh-agent
man ssh-add
</code>

----

{{tag>cli security remote-access protocol basics advanced}}

----