SSH in OpenSSH sichern

Einführung

In diesem Lab werden Sie essentielle Techniken kennenlernen, um die SSH-Sicherheit in OpenSSH durch Schlüsselauthentifizierung und Konfigurationshärtung zu verbessern. Sie üben das Ersetzen der Passwortauthentifizierung durch sichere Schlüsselpaare, das Deaktivieren des Root-Logins und das Ändern der Standardports, um Brute-Force-Angriffe zu vermeiden.

Die praktischen Übungen führen Sie durch die Generierung von kryptografischen Schlüsseln, die Konfiguration geeigneter Dateiberechtigungen und das Testen Ihrer sicheren SSH-Konfiguration. Sie lernen auch die wichtigsten Befehle zum Verwalten von SSH-Diensten und zur Überprüfung Ihrer Sicherheitskonfigurationen kennen.

Skills Graph

Installieren von OpenSSH

In diesem Schritt werden Sie das OpenSSH-Serverpaket auf Ihrer LabEx-VM installieren. OpenSSH (Open Secure Shell) ist eine kostenlose und quelloffene Implementierung des SSH-Protokolls, die sichere verschlüsselte Kommunikation zwischen zwei nicht vertrauenswürdigen Hosts über ein unsicheres Netzwerk ermöglicht. Es ist das Standardtool für die Fernverwaltung von Servern und sichere Dateitransfers.

Bevor wir beginnen, ist es wichtig zu verstehen, dass SSH nach dem Client-Server-Modell arbeitet. Der Server (den wir jetzt installieren) wartet auf eingehende Verbindungen, während Clients (z. B. das Terminal auf Ihrem lokalen Rechner) sich mit ihm verbinden. Alle Kommunikation wird verschlüsselt, um Ihre Anmeldeinformationen und Daten zu schützen.

Da die LabEx-VM Docker-Container verwendet, in denen systemctl nicht verfügbar ist (Docker-Container führen normalerweise einzelne Prozesse anstelle ganzer Betriebssysteme aus), verwenden wir den service-Befehl, um den SSH-Daemon zu verwalten. Dies ist eine einfachere Alternative zu systemctl, die gut in containerisierten Umgebungen funktioniert.

Folgen Sie diesen Schritten, um OpenSSH zu installieren:

1. Aktualisieren Sie zunächst Ihre Paketliste, um sicherzustellen, dass Sie die neueste Version erhalten. Dadurch werden die neuesten Paketinformationen aus den Ubuntu-Repositories abgerufen:

   sudo apt update

2. Installieren Sie das OpenSSH-Serverpaket. Der -y-Schalter bestätigt automatisch alle Aufforderungen während der Installation:

   sudo apt install -y openssh-server

3. Überprüfen Sie nach der Installation, ob der SSH-Dienst läuft. Der status-Befehl zeigt an, ob der Dienst aktiv ist und auf Verbindungen wartet:

   service ssh status

   Sie sollten eine Ausgabe sehen, die anzeigt, dass der Dienst aktiv (läuft) ist. Wenn er nicht läuft, starten wir ihn im nächsten Schritt.

4. Wenn der Dienst nicht läuft (was in der Statusausgabe als "inaktiv" angezeigt würde), starten Sie ihn manuell:

   service ssh start

5. Überprüfen Sie, ob SSH auf dem Standardport (22) lauscht. Der netstat-Befehl zeigt Netzwerkverbindungen und lauschende Ports an, während grep nach SSH-verwandten Einträgen filtert:

   sudo netstat -tulnp | grep sshd

   Sie sollten eine Ausgabe ähnlich dieser sehen, die zeigt, dass SSH auf allen Netzwerkschnittstellen (0.0.0.0) auf Port 22 lauscht:

   tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -

Einrichten der Schlüsselauthentifizierung

In diesem Schritt konfigurieren Sie die SSH-Schlüsselbasierte Authentifizierung, die eine höhere Sicherheit bietet als die traditionelle Passwortauthentifizierung. Im Gegensatz zu Passwörtern, die erraten oder per Brute-Force-Angriff geknackt werden können, verwendet die Schlüsselauthentifizierung ein Paar kryptografischer Schlüssel - einen privaten (geheim zu halten) und einen öffentlichen (mit Servern geteilt).

Wenn Sie sich mit einem SSH-Server verbinden, verwendet dieser mathematische Algorithmen, um zu überprüfen, ob Sie den privaten Schlüssel besitzen, der dem öffentlichen Schlüssel entspricht, den er im System hat. Diese Methode ist sowohl sicherer als auch bequemer, sobald sie eingerichtet ist.

Lassen Sie uns diese Schlüssel Schritt für Schritt erstellen und konfigurieren:

1. Zunächst generieren wir ein neues SSH-Schlüsselpaar. Dieser Befehl erstellt zwei Dateien in Ihrem ~/.ssh-Verzeichnis:

   ssh-keygen -t rsa -b 4096 -f ~/.ssh/labex_key -N ""

   • -t rsa gibt den Schlüsseltyp an (RSA-Algorithmus)
   • -b 4096 erstellt einen starken 4096-Bit-Schlüssel
   • -f legt den Dateinamen für Ihr Schlüsselpaar fest
   • -N "" bedeutet kein Passwort (zur Vereinfachung im Lab)

   Sie haben jetzt:

   • Privater Schlüssel: ~/.ssh/labex_key (teilen Sie diesen niemals!)
   • Öffentlicher Schlüssel: ~/.ssh/labex_key.pub (dieser wird mit Servern geteilt)

2. Die richtigen Dateiberechtigungen sind für die SSH-Sicherheit von entscheidender Bedeutung. Diese Befehle stellen sicher, dass nur Sie auf Ihre Schlüssel zugreifen können:

   chmod 700 ~/.ssh
   chmod 600 ~/.ssh/labex_key
   chmod 644 ~/.ssh/labex_key.pub

3. Jetzt autorisieren wir Ihren Schlüssel, indem wir den öffentlichen Schlüssel in die spezielle authorized_keys-Datei einfügen, die SSH überprüft:

   cat ~/.ssh/labex_key.pub >> ~/.ssh/authorized_keys
   chmod 600 ~/.ssh/authorized_keys

4. Als Nächstes konfigurieren wir den SSH-Server selbst. Bearbeiten Sie die Hauptkonfigurationsdatei:

   sudo nano /etc/ssh/sshd_config

   Suchen Sie und ändern Sie diese wichtigen Einstellungen:

   PubkeyAuthentication yes
   PasswordAuthentication no

   Dies sagt SSH:

   • Schlüsselauthentifizierung zuzulassen (standardmäßig aktiviert, aber gut zu bestätigen)
   • Passwortanmeldungen zu deaktivieren (nur Schlüsselbasierter Zugang wird erzwungen)

5. Nach Änderungen an der Konfiguration starten Sie den SSH-Dienst immer neu:

   service ssh restart

6. Schließlich überprüfen wir, ob alles funktioniert. Versuchen Sie, sich mit Ihrem neuen Schlüssel mit Ihrem eigenen Rechner (localhost) zu verbinden:

   ssh -i ~/.ssh/labex_key localhost

   Der -i-Schalter gibt an, welchen privaten Schlüssel zu verwenden ist. Wenn der Vorgang erfolgreich ist, werden Sie sofort ohne Passwortaufforderung angemeldet - dies bestätigt, dass die Schlüsselauthentifizierung korrekt funktioniert.

Deaktivieren der Root-Anmeldung

In diesem Schritt werden wir die direkte Root-Anmeldung über SSH deaktivieren. Dies ist wichtig, da das Root-Konto volle Systemrechte hat und somit ein Hauptziel für Hacker darstellt. Indem wir die Root-Anmeldung deaktivieren, zwingen wir Angreifer, sowohl einen Benutzernamen als auch ein Passwort zu erraten, was Brute-Force-Angriffe viel schwieriger macht.

Wenn Sie nach dieser Änderung Root-Rechte benötigen, melden Sie sich zunächst mit einem normalen Benutzerkonto an und verwenden dann sudo für administrative Aufgaben. Dies schafft eine zusätzliche Sicherheitsstufe, da Angreifer zwei Konten kompromittieren müssten.

Lassen Sie uns die SSH-Konfiguration ändern:

1. Öffnen Sie zunächst die Haupt-SSH-Konfigurationsdatei mit einem Texteditor. Hier verwenden wir nano, aber Sie können jeden Editor verwenden, mit dem Sie sich wohlfühlen:

   sudo nano /etc/ssh/sshd_config

2. Suchen Sie die Zeile, die PermitRootLogin enthält (normalerweise um Zeile 32). Wenn Sie sie nicht finden können, müssen Sie sie hinzufügen. Ändern oder fügen Sie diese Zeile wie folgt hinzu:

   PermitRootLogin no

3. Während wir diese Datei bearbeiten, legen wir einige zusätzliche Sicherheitsparameter fest, die gut mit dieser Änderung zusammenarbeiten:

   StrictModes yes
   MaxAuthTries 3
   LoginGraceTime 60

   • StrictModes überprüft die Dateiberechtigungen für die Sicherheit
   • MaxAuthTries begrenzt fehlgeschlagene Anmeldeversuche
   • LoginGraceTime legt fest, wie lange eine Anmeldung dauern darf

4. Speichern Sie Ihre Änderungen in nano, indem Sie drücken:

   • Strg+O, um zu schreiben
   • Eingabe, um zu bestätigen
   • Strg+X, um zu verlassen

5. Damit die Änderungen wirksam werden, starten Sie den SSH-Dienst neu:

   service ssh restart

6. Testen wir, ob unsere Änderungen funktioniert haben, indem wir versuchen, uns als Root per SSH anzumelden (dies sollte fehlschlagen):

   ssh root@localhost

   Sie sollten eine Fehlermeldung wie "Permission denied (publickey)" sehen, was bedeutet, dass unsere Sicherheitsmaßnahme richtig funktioniert. Von nun an müssen Sie ein normales Benutzerkonto verwenden, um sich anzumelden.

Standardport ändern

In diesem Schritt ändern wir den Standard-SSH-Port von 22 auf einen benutzerdefinierten Port (in unserem Beispiel 2222). Dies ist eine wichtige Sicherheitsmaßnahme, da viele automatisierte Bots und Angreifer nach SSH-Servern auf dem Standardport 22 suchen. Indem wir auf einen nicht-standardmäßigen Port wechseln, machen wir unseren Server für diese automatisierten Scans weniger sichtbar.

Bevor wir irgendwelche Änderungen vornehmen, überprüfen wir zunächst die aktuelle SSH-Portkonfiguration. Dies hilft uns, die bestehende Einrichtung zu verstehen:

sudo grep -i port /etc/ssh/sshd_config

Normalerweise sehen Sie in der Ausgabe #Port 22. Das #-Symbol bedeutet, dass diese Zeile auskommentiert ist, sodass SSH derzeit den Standardport 22 verwendet.

Jetzt bearbeiten wir die SSH-Konfigurationsdatei. Wir verwenden den Texteditor nano, der für Anfänger benutzerfreundlich ist:

sudo nano /etc/ssh/sshd_config

Innerhalb der Datei suchen Sie die Zeile mit #Port 22. Hier müssen wir zwei Änderungen vornehmen:

1. Entfernen Sie das #, um die Zeile auszukommentieren (dies aktiviert die Einstellung).
2. Ändern Sie die Portnummer von 22 auf 2222.

Die geänderte Zeile sollte wie folgt aussehen:

Port 2222

Nach dieser Änderung speichern Sie die Datei in nano, indem Sie drücken:

1. Strg+O (um die Datei zu schreiben)
2. Eingabe (um den Dateinamen zu bestätigen)
3. Strg+X (um den Editor zu verlassen)

Damit die Änderungen wirksam werden, müssen wir den SSH-Dienst neu starten:

service ssh restart

Lassen Sie uns überprüfen, ob SSH jetzt auf unserem neuen Port (2222) anstatt auf dem Standardport lauscht:

sudo netstat -tulnp | grep ssh

Die Ausgabe sollte anzeigen, dass SSH auf Port 2222 lauscht. Wenn Sie immer noch Port 22 sehen, überprüfen Sie noch einmal die Änderungen in Ihrer Konfigurationsdatei.

Schließlich testen Sie die neue Konfiguration, indem Sie sich über den benutzerdefinierten Port mit SSH verbinden. Beachten Sie, dass wir jetzt den Port mit der -p-Option angeben müssen:

ssh -p 2222 -i ~/.ssh/labex_key localhost

Nach erfolgreicher Verbindung können Sie die SSH-Sitzung beenden, indem Sie Strg+D drücken. Denken Sie daran, dass Sie von nun an immer diesen benutzerdefinierten Port angeben müssen, wenn Sie sich mit Ihrem SSH-Server verbinden.

Getestete gehärtete Einrichtung

In diesem letzten Schritt werden wir alle von Ihnen implementierten Sicherheitsmaßnahmen zur Härtung überprüfen. Das Testen ist von entscheidender Bedeutung, um sicherzustellen, dass Ihr SSH-Server richtig konfiguriert und sicher ist. Wir werden sowohl die serverseitigen Einstellungen als auch die clientseitigen Verbindungsversuche untersuchen.

Beginnen wir damit, die aktuelle SSH-Konfiguration auf Ihrem Server zu überprüfen. Dies bestätigt, dass die von Ihnen zuvor vorgenommenen Änderungen aktiv sind:

1. Überprüfen Sie zunächst alle aktuellen SSH-Einstellungen:

   sudo sshd -T | grep -E 'port|permitrootlogin|passwordauthentication|pubkeyauthentication'

   Der Befehl sshd -T zeigt die aktuelle Laufzeitkonfiguration an. Wir filtern nach wichtigen Sicherheitsparametern. Sie sollten Folgendes sehen:

   port 2222
   permitrootlogin no
   passwordauthentication no
   pubkeyauthentication yes

   Diese Ausgabe bestätigt, dass SSH auf Port 2222 läuft, die Root-Anmeldung deaktiviert ist, die Passwortauthentifizierung ausgeschaltet ist und die Public-Key-Authentifizierung aktiviert ist.

Jetzt testen wir die Verbindungen aus der Sicht des Clients:

2. Testen Sie eine erfolgreiche Verbindung mit Schlüsselauthentifizierung:

   ssh -p 2222 -i ~/.ssh/labex_key localhost "echo 'Key auth successful'"

   Dieser Befehl versucht, sich mit Ihrem privaten Schlüssel zu verbinden (die -i-Option gibt die Schlüsseldatei an). Wenn die Verbindung erfolgreich ist, führt der Befehl einen einfachen echo-Befehl auf dem Server aus. Sie sollten Folgendes sehen:

   Key auth successful

3. Testen Sie einen fehlgeschlagenen Root-Anmeldeversuch:

   ssh -p 2222 root@localhost 2>&1 | grep -i "permission denied"

   Dieser Befehl versucht, sich als Root anzumelden, was fehlschlagen sollte, da wir die Root-Anmeldung deaktiviert haben. Der Befehl filtert nach der erwarteten Fehlermeldung.

4. Testen Sie einen fehlgeschlagenen Passwortauthentifizierungsversuch:

   ssh -p 2222 -o PreferredAuthentications=password -o PubkeyAuthentication=no localhost 2>&1 | grep -i "permission denied"

   Hier zwingen wir die Passwortauthentifizierung (in unserer Konfiguration deaktiviert), um zu überprüfen, dass sie richtig blockiert wird. Die Optionen deaktivieren explizit die Schlüsselauthentifizierung.

Schließlich überprüfen wir den Netzwerkstatus des Servers:

5. Überprüfen Sie die aktiven SSH-Verbindungen:

   sudo netstat -tulnp | grep 2222

   Dieser Befehl zeigt alle lauschenden Ports an, gefiltert nach unserem benutzerdefinierten SSH-Port (2222). Sie sollten sshd als lauschend auf diesem Port aufgeführt sehen.

6. Überprüfen Sie den Status des SSH-Dienstes:

   service ssh status

   Bestätigt, dass der SSH-Dienst ordnungsgemäß läuft. Die Ausgabe sollte anzeigen, dass der Dienst aktiv ist.

Zusammenfassung

In diesem Lab haben Sie gelernt, die SSH-Sicherheit in OpenSSH durch praktische Konfigurationen zu verbessern. Die Übungen umfassten die Installation des OpenSSH-Servers, die Überprüfung seines Status und die Implementierung der Schlüsselbasierenden Authentifizierung mit geeigneten Berechtigungseinstellungen.

Sie haben auch wichtige Sicherheitsmaßnahmen zur Härtung untersucht, darunter das Deaktivieren der Root-Anmeldung und das Ändern des Standard-SSH-Ports. Diese Maßnahmen reduzieren effektiv die Anfälligkeit für Brute-Force-Angriffe und automatisierte Scans, während die Systemfunktionalität aufrechterhalten bleibt.