SSH: Sicher verbinden und effizient arbeiten – Der Einsteiger-Guide

Einleitung

Wer sich in der Welt der Linux-Server oder Heimserver bewegt, kommt früher oder später an einem Begriff nicht vorbei: SSH. Doch was steckt eigentlich dahinter, und warum ist es so wichtig?

SSH steht für Secure Shell – ein Netzwerkprotokoll, das eine verschlüsselte Verbindung zwischen zwei Computern ermöglicht. Stell dir vor, du möchtest deinen Server in der Cloud verwalten, ohne physisch davor zu sitzen. Genau hier kommt SSH ins Spiel. Es erlaubt dir, über das Terminal (auch Shell genannt) Befehle auf einem entfernten Rechner auszuführen, als wärst du direkt vor Ort.

Das Terminal ist dabei dein Werkzeug: ein textbasiertes Interface, über das du mit dem Betriebssystem kommunizierst. Klingt kompliziert? Keine Sorge – dieser Guide führt dich Schritt für Schritt durch alles, was du wissen musst.

1. Verbindung herstellen

Die grundlegende Syntax

Der einfachste SSH-Befehl sieht so aus:

ssh user@hostname

Dabei ist:

  • user → dein Benutzername auf dem Zielserver
  • hostname → die IP-Adresse oder der Domainname des Servers

Ein konkretes Beispiel:

ssh admin@192.168.1.100

oder mit einem Domainnamen:

ssh admin@mein-server.de

Port ändern

Standardmäßig läuft SSH auf Port 22. Viele Administratoren ändern diesen Port aus Sicherheitsgründen (dazu später mehr). Wenn dein Server auf einem anderen Port lauscht, gibst du diesen mit dem Flag -p an:

ssh -p 2222 user@hostname

Die erste Verbindung – Host-Key bestätigen

Wenn du dich zum ersten Mal mit einem Server verbindest, wirst du von einer Meldung begrüßt, die ungefähr so aussieht:

The authenticity of host '192.168.1.100 (192.168.1.100)' can't be established.
ED25519 key fingerprint is SHA256:abc123xyz...
Are you sure you want to continue connecting (yes/no/[fingerprint])?

Was passiert hier? SSH zeigt dir den sogenannten Host-Key des Servers – einen einzigartigen Fingerabdruck, der sicherstellt, dass du wirklich mit dem richtigen Server sprichst und nicht Opfer eines Man-in-the-Middle-Angriffs wirst.

Wenn du den Server kennst und ihm vertraust, tippst du yes und drückst Enter. Der Fingerabdruck wird dann in der Datei ~/.ssh/known_hosts auf deinem lokalen Rechner gespeichert. Bei zukünftigen Verbindungen wird dieser automatisch überprüft.

⚠️ Wichtig: Wenn du eine Warnung bekommst, dass sich der Host-Key geändert hat, obwohl du den Server nicht neu aufgesetzt hast, könnte das ein Zeichen für einen Angriff sein. Überprüfe die Situation sorgfältig, bevor du fortfährst!

Verbindung trennen

Um eine SSH-Sitzung zu beenden, tippst du einfach:

exit

oder drückst Ctrl + D.

2. SSH-Keys – Warum und wie

Passwort vs. SSH-Key: Was ist besser?

Beim ersten Login wirst du wahrscheinlich nach einem Passwort gefragt. Das funktioniert – ist aber nicht ideal. Warum?

MethodeSicherheitKomfort
PasswortAnfällig für Brute-ForceMuss jedes Mal eingegeben werden
SSH-KeySehr hoch (kryptografisch)Nach Einrichtung automatisch

SSH-Keys sind kryptografische Schlüsselpaare, die aus zwei Teilen bestehen:

  • 🔑 Private Key → bleibt immer auf deinem lokalen Rechner, wird niemals geteilt
  • 🔓 Public Key → wird auf dem Server hinterlegt

Das Prinzip: Der Server kennt deinen Public Key. Wenn du dich verbindest, beweist dein Rechner mit dem Private Key, dass er zusammengehört – ohne das Passwort jemals über das Netzwerk zu schicken.

Schlüsselpaar generieren

Öffne dein Terminal und tippe:

ssh-keygen -t ed25519 -C "mein-kommentar@system-ecke.de"
  • -t ed25519 → gibt den Algorithmus an (Ed25519 ist modern und sicher, alternativ geht auch rsa -b 4096)
  • -C → ein optionaler Kommentar, z.B. deine E-Mail-Adresse

Du wirst nach einem Speicherort gefragt:

Enter file in which to save the key (/home/user/.ssh/id_ed25519):

Drücke einfach Enter, um den Standardpfad zu verwenden. Danach wirst du nach einer Passphrase gefragt:

Enter passphrase (empty for no passphrase):

Eine Passphrase ist ein zusätzlicher Schutz für deinen Private Key. Selbst wenn jemand Zugriff auf deine Schlüsseldatei bekommt, kann er sie ohne die Passphrase nicht nutzen. Empfehlung: Setze eine Passphrase!

Nach der Generierung findest du zwei Dateien:

~/.ssh/id_ed25519       ← Private Key (NIEMALS teilen!)
~/.ssh/id_ed25519.pub   ← Public Key (dieser kommt auf den Server)

Public Key auf den Server übertragen

Der einfachste Weg ist das Tool ssh-copy-id:

ssh-copy-id user@hostname

Das Tool kopiert deinen Public Key automatisch in die Datei ~/.ssh/authorized_keys auf dem Server. Du wirst einmalig nach deinem Passwort gefragt.

Falls ssh-copy-id nicht verfügbar ist (z.B. auf macOS ohne Homebrew), geht es auch manuell:

cat ~/.ssh/id_ed25519.pub | ssh user@hostname "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

Nach der Übertragung kannst du dich ohne Passwort verbinden:

ssh user@hostname
# → Verbindung klappt direkt (ggf. Passphrase des Keys eingeben)

Public vs. Private Key – nochmal einfach erklärt

Stell dir ein Vorhängeschloss vor:

  • Der Public Key ist das offene Schloss – du kannst es jedem geben
  • Der Private Key ist der einzige Schlüssel, der dieses Schloss öffnet

Der Server „schließt“ die Verbindung mit deinem Public Key. Nur du, mit deinem Private Key, kannst sie öffnen.

~/.ssh/config – Verbindungen vereinfachen

Anstatt jedes Mal ssh admin@192.168.1.100 -p 2222 zu tippen, kannst du Aliase in der SSH-Konfigurationsdatei anlegen. Mehr dazu im Abschnitt SSH Config Datei weiter unten.

3. Wichtige SSH-Befehle

Dateien kopieren mit scp

scp (Secure Copy) funktioniert wie das normale cp, aber über SSH. Die Syntax ist:

# Lokale Datei auf Server kopieren
scp /pfad/zur/datei.txt user@hostname:/ziel/pfad/

# Datei vom Server herunterladen
scp user@hostname:/pfad/zur/datei.txt /lokaler/pfad/

# Ganzen Ordner kopieren (rekursiv mit -r)
scp -r /lokaler/ordner user@hostname:/ziel/pfad/

Ein praktisches Beispiel – Backup vom Server holen:

scp admin@mein-server.de:/var/backups/backup.tar.gz ~/Downloads/

Interaktive Dateiübertragung mit sftp

sftp (SSH File Transfer Protocol) bietet eine interaktive Sitzung, ähnlich wie FTP, aber verschlüsselt:

sftp user@hostname

Innerhalb der SFTP-Sitzung stehen dir Befehle zur Verfügung:

ls          # Dateien auf dem Server auflisten
lls         # Lokale Dateien auflisten
cd ordner   # Verzeichnis wechseln (Server)
lcd ordner  # Lokales Verzeichnis wechseln
get datei   # Datei herunterladen
put datei   # Datei hochladen
bye         # Sitzung beenden

Port-Forwarding – Lokaler Tunnel

Port-Forwarding ist eine der mächtigsten SSH-Funktionen. Damit kannst du Dienste, die nur auf dem Server erreichbar sind, auf deinen lokalen Rechner „tunneln“.

Beispiel: Du hast eine Webanwendung auf dem Server, die auf Port 8080 läuft, aber nicht öffentlich erreichbar ist:

ssh -L 8080:localhost:8080 user@hostname

Jetzt kannst du in deinem Browser http://localhost:8080 aufrufen und erreichst die Anwendung auf dem Server – sicher durch den SSH-Tunnel!

Die Syntax lautet:

ssh -L [lokaler-port]:[ziel-host]:[ziel-port] user@hostname

X11-Forwarding – GUI-Anwendungen über SSH

Hast du eine grafische Anwendung auf dem Server, die du lokal anzeigen möchtest? Mit X11-Forwarding ist das möglich:

ssh -X user@hostname

Danach kannst du grafische Programme starten, die auf deinem lokalen Bildschirm erscheinen:

# Auf dem Server (nach SSH-Verbindung mit -X)
gedit &       # Texteditor öffnen
firefox &     # Browser öffnen

💡 Hinweis: Auf macOS benötigst du zusätzlich XQuartz. Unter Windows funktioniert das mit VcXsrv oder Xming.

4. SSH Config Datei

Was ist die SSH Config?

Die Datei ~/.ssh/config ist dein persönliches Konfigurationsfile für SSH-Verbindungen. Hier kannst du Einstellungen für verschiedene Server hinterlegen und dir das Leben erheblich vereinfachen.

Falls die Datei noch nicht existiert, erstelle sie:

touch ~/.ssh/config
chmod 600 ~/.ssh/config

Host-Aliase anlegen

Statt immer ssh admin@192.168.1.100 -p 2222 zu tippen, legst du einen Alias an:

Host mein-server
    HostName 192.168.1.100
    User admin
    Port 2222

Jetzt reicht ein einfaches:

ssh mein-server

Automatischer Key-Einsatz

Du kannst für jeden Host einen spezifischen SSH-Key festlegen:

Host mein-server
    HostName 192.168.1.100
    User admin
    Port 2222
    IdentityFile ~/.ssh/id_ed25519_server

Host github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_github

Das ist besonders praktisch, wenn du mehrere Keys für verschiedene Dienste verwendest.

Keep-Alive einstellen

Manchmal trennt sich eine SSH-Verbindung nach längerer Inaktivität. Das lässt sich mit Keep-Alive-Einstellungen verhindern:

Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
  • ServerAliveInterval 60 → sendet alle 60 Sekunden ein Keep-Alive-Signal
  • ServerAliveCountMax 3 → nach 3 ausbleibenden Antworten wird die Verbindung getrennt

Eine vollständige Config als Beispiel

# Globale Einstellungen für alle Hosts
Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
    AddKeysToAgent yes

# Heimserver
Host heimserver
    HostName 192.168.1.100
    User pi
    Port 22
    IdentityFile ~/.ssh/id_ed25519_home

# VPS in der Cloud
Host vps
    HostName mein-vps.de
    User admin
    Port 2222
    IdentityFile ~/.ssh/id_ed25519_vps

# GitHub
Host github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_github

5. Security-Hardening

Ein SSH-Server, der offen im Internet steht, ist ein beliebtes Angriffsziel. Mit ein paar einfachen Maßnahmen kannst du die Sicherheit erheblich erhöhen.

Root-Login deaktivieren

Der root-Account ist auf jedem Linux-System vorhanden – Angreifer wissen das. Deaktiviere den direkten Root-Login in der SSH-Konfiguration des Servers:

sudo nano /etc/ssh/sshd_config

Suche nach der Zeile und ändere sie:

PermitRootLogin no

Passwort-Authentifizierung deaktivieren

Wenn du SSH-Keys eingerichtet hast, gibt es keinen Grund mehr, Passwort-Logins zu erlauben. Deaktiviere sie:

PasswordAuthentication no
PubkeyAuthentication yes

⚠️ Wichtig: Stelle sicher, dass dein SSH-Key funktioniert, bevor du die Passwort-Authentifizierung deaktivierst! Sonst sperrst du dich selbst aus, und musst Dich dann mit einer Konsole an dem Rechner anmelden

Nach jeder Änderung an der sshd_config musst du den SSH-Dienst neu starten:

sudo systemctl restart sshd

fail2ban – Brute-Force-Angriffe abwehren

fail2ban überwacht Log-Dateien und sperrt IP-Adressen, die zu viele fehlgeschlagene Login-Versuche haben.

Installation:

sudo apt install fail2ban    # Debian/Ubuntu
sudo dnf install fail2ban    # Fedora/RHEL

Eine einfache Konfiguration für SSH (/etc/fail2ban/jail.local):

[sshd]
enabled = true
port = ssh
maxretry = 5
bantime = 3600
findtime = 600
  • maxretry = 5 → nach 5 Fehlversuchen wird die IP gesperrt
  • bantime = 3600 → Sperre dauert 1 Stunde (3600 Sekunden)
  • findtime = 600 → Fehlversuche werden innerhalb von 10 Minuten gezählt

Dienst starten:

sudo systemctl enable fail2ban
sudo systemctl start fail2ban

Fazit

SSH ist ein unverzichtbares Werkzeug für jeden, der mit Linux-Servern arbeitet. Mit den Grundlagen aus diesem Guide bist du gut aufgestellt:

✅ Du weißt, wie du eine Verbindung aufbaust
✅ Du nutzt SSH-Keys statt unsicherer Passwörter
✅ Du überträgst Dateien sicher mit scp und sftp
✅ Du hast deine Verbindungen mit der Config-Datei organisiert
✅ Du hast deinen Server mit grundlegenden Sicherheitsmaßnahmen gehärtet

Ein letzter Tipp: Lege dir immer eine Backup-Verbindungsmöglichkeit bereit (z.B. Konsolen-Zugang beim Hoster), bevor du Änderungen an der SSH-Konfiguration vornimmst. So sperrst du dich im Notfall nicht aus.

Viel Erfolg beim Erkunden der Welt der sicheren Verbindungen – und willkommen in der System-Ecke! 🖥️

Dieser Artikel ist Teil der erschienen auf system-ecke.de

Teile deine Liebe

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert