Linux Workshop

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

# SSH-Server installieren
sudo dnf install openssh-server

# SSH-Client installieren
sudo dnf install openssh-clients

# Status prüfen
sudo systemctl status sshd

# SSH-Server installieren
sudo zypper install openssh

# Status prüfen
sudo systemctl status sshd

# SSH-Server installieren
sudo pacman -S openssh

# Status prüfen
sudo systemctl status sshd

# 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

/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

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

/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

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

# 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

# ~/.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

# 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 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 mit 521 Bit
ssh-keygen -t ecdsa -b 521 -C "user@email.com"

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

# 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 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 eines bestehenden Schlüssels ändern
ssh-keygen -p -f ~/.ssh/id_ed25519

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

# Ö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

# 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

# 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

# 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

# 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

# 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"

# 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-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-Tunnel im Hintergrund
ssh -fN -L 3306:localhost:3306 user@server

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

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

# 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

# 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

# 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

# "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

# SSH-Config-Syntax testen
sudo sshd -t

# Extended Test mit Konfigurationsausgabe
sudo sshd -T

# SSH-Client-Konfiguration testen
ssh -G hostname

• 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

• SCP - Secure Copy
• SFTP - SSH File Transfer Protocol
• Rsync über SSH
• sshd_config
• ssh-keygen
• ~/.ssh
• SSH-Tunnel
• Systemd-Dienste

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