In diesem Artikel möchte ich euch zeigen, wie man seinen OpenSSH Server abhärten bzw. absichern kann. Ich habe für diese Anleitung eine virtuelle Maschine auf meinem Unraid Server erstellt und Ubuntu 20.04 darauf installiert, funktioniert aber auch mit Ubuntu 22.04 oder einer anderen Linux-Distribution.

Grundlegende Anpassungen vornehmen

Nachdem wir uns auf unseren Server eingeloggt haben, geben wir folgenden Befehl ein, um unser System auf den aktuellsten Stand zu bringen.

# Bringt das System auf den aktuellsten Stand.
sudo apt update && sudo apt upgrade -y

Optional: Idealerweise erstellen wir einen neuen User und weisen ihm Root-Rechte zu. Das machen wir wie folgt.

# Erstellt neuen Benutzer – Bitte Benutzernamen anpassen!
adduser Benutzername

# Gibt dem neuen Benutzer Root-Rechte - Bitte Benutzernamen anpassen!
usermod -aG sudo Benutzername

Mit folgendem Befehl erstellen wir eine Kopie der Original-Konfiguration des OpenSSH-Servers

# Erstellt eine Sicherheitskopie der SSH-Serverkonfiguration.
sudo cp /etc/ssh/{sshd_config,sshd_config.orig}

Jetzt deaktivieren wir den Zugang für den Root-Benutzer, da wir uns ab sofort mit dem neu erstellte Benutzer anmelden können.

# Setzt in der "/etc/ssh/sshd_config" das "PermitRootLogin" von "yes" auf "no".
sudo sed -ri 's/#?PermitRootLogin\s.*$/PermitRootLogin no/' /etc/ssh/sshd_config

# Startet den OpenSSH-Server neu.
sudo service ssh restart

So, nun sind wir mit der Grundeinstellung fertig und können uns mit dem neu erstellten Benutzer einloggen.

SSH-Verbindung mit ssh-audit testen

Bevor wir uns mit der Sicherheit unseres Servers befassen, müssen wir den IST-Zustand herausfinden.
Dazu installieren wir ssh-audit und führen gleich mal einen Scan durch.

ssh-audit ist ein kleines Programm, das die Version und Einstellungen unseres OpenSSH-Servers ausließt und zudem noch im Ampelformat anzeigt, welche Algorithmen und Ciphers wir am besten abschalten sollten, damit unser System ein Stück sicherer wird.

# Installiert pip für Python 3.
sudo apt install python3-pip -y

# Installiert die aktuellste ssh-audit version.
sudo pip3 install ssh-audit

# Mit diesem Befehl führt ssh-audit einen SSH-Security-Scan auf den SSH-Server durch.
ssh-audit localhost:22

Das Ergebnis sollte in etwas so aussehen. Wie wir sehen, müssen wir ein paar Dinge verbessern, damit alles „im grünen“ Bereich ist.

ssh audit ergbniss bevor Hardening
ssh-audit Scan-Ergebnis von einem unsicheren OpenSSH Server

Alte Verschlüsselung entfernen und System sicherer machen

Für Ubuntu 20.04 müssen wir folgende Befehle als Root-Benutzer eingeben. Wenn du ein anderes Betriebssystem verwendest, dann schau bitte dieser Seite nach.

# Wechselt zum root-User.
sudo su

# entfernt veraltete RSA und ED25519-Schlüssel und generiert neue.
rm /etc/ssh/ssh_host_*
ssh-keygen -t rsa -b 4096 -f /etc/ssh/ssh_host_rsa_key -N ""
ssh-keygen -t ed25519 -f /etc/ssh/ssh_host_ed25519_key -N "" 

# entfernt kleine Diffie-Hellman-Module.
awk '$5 >= 3071' /etc/ssh/moduli > /etc/ssh/moduli.safe
mv /etc/ssh/moduli.safe /etc/ssh/moduli

# deaktiviert DSA und ECDSA HostKey-Direktiven in der Datei /etc/ssh/sshd_config.
sed -i 's/^\#HostKey \/etc\/ssh\/ssh_host_\(rsa\|ed25519\)_key$/HostKey \/etc\/ssh\/ssh_host_\1_key/g' /etc/ssh/sshd_config

# Beschränkt den Schlüsselaustausch auf (key exchange), Chiffrier- (cipher) und MAC-Algorithmen.
echo -e "\n# Restrict key exchange, cipher, and MAC algorithms, as per sshaudit.com\n# hardening guide.\nKexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group-exchange-sha256\nCiphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com,aes256-ctr,aes192-ctr,aes128-ctr\nMACs hmac-sha2-256-etm@openssh.com,hmac-sha2-512-etm@openssh.com,umac-128-etm@openssh.com\nHostKeyAlgorithms ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-512,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512-cert-v01@openssh.com" > /etc/ssh/sshd_config.d/ssh-audit_hardening.conf

# startet den SSH neu.
service ssh restart

# wechselt zum normalen Benutzer zurück.
exit

Jetzt führen wir einen erneuten Scan mit ssh-audit durch, um zu schauen, ob unser Server nun sicherer ist. Das machen wir mit diesem Befehl.

# Zeigt das Scan-Ergebnis von ssh-audit an.
ssh-audit localhost:22

Das Ergebnis sollte jetzt wie folgt aussehen.

ssh audit ergbniss nach Hardening
ssh-audit Scan nach Hardening

Wenn das Ergebnis bei Euch auch so aussieht, dann habt ihr das bisher alles richtig gemacht.

Auflisten der unterstützten OpenSSH-Server Cipher-Methoden

Wir haben zwei Methoden, um die unterstützen Cipher-Methoden anzuzeigen. Die zeige ich euch hier.

# Erste und schnelle Methode
ssh -Q cipher
ssh -Q cipher-auth
ssh -Q mac
ssh -Q kex
ssh -Q key

# zweite methode mit nmp
# wir brauchen das tool nmap das installieren wir wie folgt
sudo apt install nmap -y

# Jetzt können wir mit diesem Befehl die unterstützen Cipher-Methoden anzeigen lassen
nmap -p22 -n -sV --script ssh2-enum-algos localhost

Die Secure Shell (SSH) bekommt ein SSH-Schlüsselpaar

Aktuell kann man sich mit User und Passwort anmelden, das ist nicht sonderlich sicher. Wir wollen das man sich nur mit einem Privat-Key einloggen kann, alles andere wird blockiert. Das ist um einiges sicherer.

Wir fangen mit dem Erstellen eines SSH-Schlüsselpaars für den eingeloggten Benutzer an. Das machen wir wie folgt.

# Generiert einen sicheren SSH-Key (ed25519) - mit y Bestätigen.
sudo ssh-keygen -o -a 100 -t ed25519 -N "" -f /etc/ssh/ssh_host_ed25519_key -C "$(hostname)-$(date -I)"

Erklärung der Parameter:

-o: Speichert das SSH-Schlüsselpaar im neuen SSH-Format ab, das robuster gegen Brute-Force-Angriffe ist.
-a: Gibt an, wie viele Schlüsselableitungsfunktionen (KDFs) beim Erstellen des Keys verwendet werden sollen. Je höher der Wert, desto langsamer, aber dafür sicherer.
-t: Gibt den Typ des zu erstellenden Schlüssels an. Die möglichen Werte sind »dsa«, »ecdsa«, »ecdsa-sk«, »ed25519«, »ed25519-sk« und »rsa«. Wir nehmen natürlich den sichersten (Ed25519).
-N: Stellt eine neue Passphrase bereit. Das lassen wir leer, da wir kein Passwort benötigen, wer möchte, kann hier ein Passwort eintragen.
-f: Mit diesem Parameter wird der SSH-Schlüsselpaar-Name festgelegt und der Speicherort mitgegeben.
-C: Fügt am Ende des Public Keys einen Kommentar hinzu. Das dient der besseren „Zuordnung“. In unserem Fall wird der Hostnamen und das Datum automatisch eingetragen.

.ssh Ordner und authorized_keys erstellen

Mit folgenden Befehlen erstellen wir einen .ssh Ordner sowie eine authorized_keys Datei.

mkdir /home/$USER/.ssh
touch /home/$USER/.ssh/authorized_keys

Public-Key dem Benutzer zuordnen

Jetzt weisen wir dem Benutzer sein Public-Key zu. Das machen wir mit diesem Befehl.

# Verschiebt den ssh_host_ed25519_key.pub nach authorized_keys.
sudo cat /etc/ssh/ssh_host_ed25519_key.pub >> /home/$USER/.ssh/authorized_keys

Rechte der SSH-Schlüsselpaare anpassen

# Das .ssh-Verzeichnis für andere Benutzer und Gruppen das leserecht entziehen.
chmod 700 /home/$USER/.ssh

# Legt fest, dass die SSH-Schlüsselpaare nur gelesen werden können.
sudo chmod 400 /etc/ssh/ssh_host_ed25519_key*

# Setzt den lokalen Benutzer als Besitzer des Public-Keys.
chown $USER:$USER /home/$USER/.ssh/authorized_keys

SSH-Schlüsselpaare für Putty mittels puttygen konvertieren

Wer sich aus einem Windows-PC auf den Server verbinden möchte, braucht den puttygen. Das können wir hier herunterladen. Lad entsprechend deiner Windows-Bit-Architektur herunter.

Windows 64-bit x86

Windows 32-bit x86

Windows 64-bit Arm

Das brauchen wir gleich. Erstmal machen wir auf den Server weiter.
Mit diesem Befehl lassen wir uns den zuvor erstellen ssh_host_ed25519_key anzeigen.

# zeigt den ssh_host_ed25519_key an.
sudo cat  /etc/ssh/ssh_host_ed25519_key

Das sollte in etwa so aussehen.

openssh key 2
Private-Key

Wie im Bild zu sehen ist, markieren und kopieren wir den Privat-Key, öffnen unseren Windows Editor (oder irgendein Texteditor deiner Wahl) und speichern es unter einen beliebigen Namen ein.

sshkey
Privat-Key im Windows-Editor

Nun gehen wir zurück zu puttygen und klicken oben auf Conversions dann auf Import Key und wählen den zuvor mit Windows Editor erstellte Datei aus. Den generierten Privat-key können jetzt mit einem Klick auf Save private key speichern. Wählt dazu einen passenden Namen und speichert es auf euren Windows Rechner.

puttygen konvertiert auf Ed25519
puttygen – Privat-Key erstellen und speichern

Putty bekommt einen Privat-Key

Jetzt öffnen wir Putty und klicken im linken Menü auf das kleine + neben SSH dann auf Auth und zuletzt auf Browse. Als Nächstes wählen wir die .ppk Datei aus, die wir zuvor auf unseren Windows-PC gespeichert haben. Jetzt klicken wir im linken Menü oben auf Session und geben die IP unseres Servers ein. Nun tragen wir unter Saved Sessions einen Namen ein und speichern das ganze mit einem Klick auf Save.

putty einstellen
Putty – Privat-Key zuweisen und speichern

Erweiterte Härtung des OpenSSH-Servers

In diesem Teil werden wir das Anmelden mittels Benutzer und Passwort unterbinden und erlauben nur das Anmelden mit einem gültigen Privat-Key. Das machen wir mit folgenden Befehlen.

# Verhindert das anmelden mittels Passwort.
sudo sed -ri 's/#?PasswordAuthentication\s.*$/PasswordAuthentication no/' /etc/ssh/sshd_config

# Erlaubt das anmelden mittels SSH-Schlüsselpaare.
sudo sed -ri 's/#?PubkeyAuthentication\s.*$/PubkeyAuthentication yes/' /etc/ssh/sshd_config

# Begrenzt die Authentifizierungsversuche !der Wert hier ist 3, kann angepasst werden.
sudo sed -ri 's/#?MaxAuthTries\s.*$/MaxAuthTries 3/' /etc/ssh/sshd_config

# Einstellungen übernehmen.
sudo systemctl reload sshd

In diesem Abschnitt werden wir die sshd_config ein wenig anpassen, um die Sicherheit unseres Servers zu erhöhen und abzuhärten.

# Wir ändern den Port auf 4935 - ! Kann angepasst werden.
sudo sed -ri 's/#?Port\s.*$/Port 4935/' /etc/ssh/sshd_config

# aktiviert das sicherer Protocol 2.
sudo sed -i '/^.*Port.*/a Protocol 2' /etc/ssh/sshd_config

# lässt nur IPv4 zu. !Kann angepasst werden - "any" (IPv4 & IPv6), "inet" (nur IPv4) oder "inet6" (nur IPv6).
sudo sed -ri 's/#?AddressFamily\s.*$/AddressFamily inet/' /etc/ssh/sshd_config

# Gibt die verfügbaren KEX (Key Exchange)-Algorithmen an.
sudo sed -i '/^.*Ciphers.*/a KexAlgorithms curve25519-sha256@libssh.org' /etc/ssh/sshd_config

# Gibt die verfügbaren MAC-Algorithmen (Message Authentication Code) an.
sudo sed -i '/^.*KexAlgorithms.*/a MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-512' /etc/ssh/sshd_config

# Gibt die zulässigen Verschlüsselungen an.
sudo sed -i '/^.*MACs.*/a Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com' /etc/ssh/sshd_config

# Gibt die vom Server angebotenen Algorithmen für die Schlüsselsignatur des Hosts an.
sudo sed -i '/^.*Ciphers chacha20.*/a HostKeyAlgorithms ssh-ed25519-cert-v01@openssh.com,ssh-ed25519' /etc/ssh/sshd_config

# stellt das LogLevel auf "INFO" und das SyslogFacility auf "AUTHPRIV".
sudo sed -ri 's/#?SyslogFacility\s.*$/SyslogFacility AUTHPRIV/' /etc/ssh/sshd_config
sudo sed -ri 's/#?LogLevel\s.*$/LogLevel INFO/' /etc/ssh/sshd_config

# Anmeldezeitraum zur Authentifizierung !Kann angepasst werden.
sudo sed -ri 's/#?LoginGraceTime\s.*$/LoginGraceTime 30/' /etc/ssh/sshd_config

# Verhindert Konfigurationsfehler.
sudo sed -ri 's/#?StrictModes\s.*$/StrictModes yes/' /etc/ssh/sshd_config

# Deaktiviert die hostbasierte Authentifizierung.
sudo sed -ri 's/#?HostbasedAuthentication\s.*$/HostbasedAuthentication no/' /etc/ssh/sshd_config

# Gibt an, dass .rhosts- und .shosts-Dateien nicht verwendet werden.
sudo sed -ri 's/#?IgnoreRhosts\s.*$/IgnoreRhosts yes/' /etc/ssh/sshd_config

# Deaktiviert das einloggen mit leeren Passwörtern.
sudo sed -ri 's/#?PermitEmptyPasswords\s.*$/PermitEmptyPasswords no/' /etc/ssh/sshd_config

# Deaktiviert die Kerberos-Authentifizierung.
sudo sed -ri 's/#?KerberosAuthentication\s.*$/KerberosAuthentication no/' /etc/ssh/sshd_config
sudo sed -ri 's/#?GSSAPIAuthentication\s.*$/GSSAPIAuthentication no/' /etc/ssh/sshd_config

# Deaktiviert die Agentenweiterleitung/-tunnelung.
sudo sed -ri 's/#?AllowAgentForwarding\s.*$/AllowAgentForwarding no/' /etc/ssh/sshd_config

# Deaktiviert die TCP-Weiterleitung/Tunneling.
sudo sed -ri 's/#?AllowTcpForwarding\s.*$/AllowTcpForwarding no/' /etc/ssh/sshd_config

# Deaktiviert das Remote-Port-Forwarding.
sudo sed -ri 's/#?GatewayPorts\s.*$/GatewayPorts no/' /etc/ssh/sshd_config

# Deaktiviert die X11-Weiterleitung/Tunneling (GUI).
sudo sed -ri 's/#?X11Forwarding\s.*$/X11Forwarding no/' /etc/ssh/sshd_config

# Deaktiviert das Motd-Banner "Message of the Day".
sudo sed -ri 's/#?PrintMotd\s.*$/PrintMotd no/' /etc/ssh/sshd_config

# Zeigt das Datum und Uhrzeit der letzten Benutzeranmeldung an.
sudo sed -ri 's/#?PrintLastLog\s.*$/PrintLastLog yes/' /etc/ssh/sshd_config

# Verhindert, dass die Verbindung zum Server unterbrochen wird.
sudo sed -ri 's/#?TCPKeepAlive\s.*$/TCPKeepAlive yes/' /etc/ssh/sshd_config

# Deaktiviert die User Environment Files.
sudo sed -ri 's/#?PermitUserEnvironment\s.*$/PermitUserEnvironment no/' /etc/ssh/sshd_config

# Deaktiviert die Komprimierung und sorgt für mehr Sicherheit.
sudo sed -ri 's/#?Compression\s.*$/Compression no/' /etc/ssh/sshd_config

# Beendet die Verbindung nach 30 Minuten Inaktivität - !Kann angepasst werden.
sudo sed -ri 's/#?ClientAliveInterval\s.*$/ClientAliveInterval 1800/' /etc/ssh/sshd_config

# Sendet 2 Mal eine ClientAlive-Nachricht bevor die Verbindung abbricht - !Kann angepasst werden.
sudo sed -ri 's/#?ClientAliveCountMax\s.*$/ClientAliveCountMax 2/' /etc/ssh/sshd_config

# Deaktiviert DSN-Lookup, dadurch wird die Verbindung schneller hergestellt.
sudo sed -ri 's/#?UseDNS\s.*$/UseDNS no/' /etc/ssh/sshd_config

# Deaktiviert die Weiterleitung von tun-Geräten bei SSH-Verbindugen.
sudo sed -ri 's/#?PermitTunnel\s.*$/PermitTunnel no/' /etc/ssh/sshd_config

# Deaktiviert das SSH-Protokollbanner.
sudo sed -ri 's/#?VersionAddendum\s.*$/VersionAddendum none/' /etc/ssh/sshd_config

Jetzt prüfen wir noch, ob alle Einstellungen richtig sind und starten das SSH neu. Das machen wir mit diesen Befehlen.

# Prüft die Konfiguration auf Fehler.
sudo sshd -t

# startet den OpenSSH-Server neu.
sudo service ssh restart

Information: Wenn ein Benutzer eine abweichende Einstellung benötigt, kann man das am Ende der sshd_config machen. Hier ein Beispiel, wie das aussehen könnte.

# Benutzer angepasste Einstellungen.
Match User Benutzername
       X11Forwarding yes
       AllowTcpForwarding yes

Nun haben wir die Konfigurationsdatei des OpenSSH-Servers erfolgreich angepasst. Als Nächstes wenden wir IP-Whitelisting an, um den Zugriff weiter einzuschränken. Mit diesem Befehl können wir festlegen, wer auf den Server zugreifen kann.

# Beschränkt den Zugang auf folgende Benutzer – !ACHTUNG bitte Namen anpassen.
sudo sed -i '/^.*AddressFamily.*/a AllowUsers sakis' /etc/ssh/sshd_config

Firewall aktivieren (UFW)

Natürlich darf eine Firewall nicht fehlen, mit der UFW (Uncomplicated Firewall) von Ubuntu geht das einrichten und einstellen recht einfach.

Als Erstes stellen wir die Standardrichtlinien fest.

# eingehende Verbindungen werden abgelehnt und ausgehende Verbindungen zugelassen.
sudo ufw default deny incoming
sudo ufw default allow outgoing

# SSH Verbindungen zulassen – !ACHTUNG: bitte Port-Nummer anpassen, falls Ihr eine andere verwendet.
sudo ufw allow 4935

# UFW aktivieren - mit y bestätigen.
sudo ufw enable

Wir haben nun die Firewall erfolgreich installiert und konfiguriert.

Fail2Ban installieren und einrichten

Fail2ban ist ein wichtiges Werkzeug, wenn es um die Abhärtung eines Servers angeht. Dieses Tool schützt dich vor Brute-Force-Attacken, indem es falsche Anmeldeversuche erkennt und für einen gewissen Zeitraum sperrt. Hier erfährst du mehr über Fail2ban.

Mit diesem Befehl bringen wir unser System auf den aktuellsten Stand, installieren die neueste Fail2ban Version und erstellen eine Kopie der Konfigurationsdatei.

# Bringt das System auf den neuesten Stand.
sudo apt update && sudo apt upgrade -y && sudo apt autoremove -y

# installiert die neueste Fail2ban Version.
sudo apt install fail2ban -y

# erstellt eine Kopie der Konfigurationsdatei.
sudo cp /etc/fail2ban/jail.{conf,local}

Fail2ban arbeitet mit dem sogenannten „Jail“-Konzept. Ein Jail beschreibt einen Dienst und beinhaltet Filter und Aktionen. Dieses Tool hat unzählige Jails, die man beliebig einstellen kann, doch uns interessiert momentan nur der [sshd] Jail.

Öffnet nun die jail.local, scrollt runter bis [sshd] und passt es wie folgt an.

# öffnet die jail.local
sudo nano /etc/fail2ban/jail.local

# Scrollt runter bis Ihr den [sshd] Jail findet und setzt da folgende Einträge. 
# !ACHTUNG passt die Portnummer, logpath etc. entsprechend an.
# Weitere Infos findest du hier https://www.fail2ban.org/wiki/index.php/MANUAL_0_8#Jail_Options

[sshd]

enabled = true
port    = 4935
logpath = %(sshd_log)s
backend = %(sshd_backend)s
maxretry  = 3
findtime  = 1d
bantime = 2h
ignoreip  = 127.0.0.1/8

# Fail2ban neu starten.
sudo service fail2ban restart

# Fail2ban nach Reboot automatisch starten
sudo systemctl enable fail2ban

So, nun sind wir mit der Installation und Konfiguration von Fail2ban fertig. Hier noch ein paar nützliche Befehle.

# Zeigt aktuellen Status zu Fail2ban an.
sudo systemctl status fail2ban

# zeigt alle aktivierten Jails.
sudo fail2ban-client status 

# Zeigt detailierten Status vom sshd-Jail.
sudo fail2ban-client status sshd

# Um eine gesperrte IP-Adresse zu entfernen, verwende folgenden Befehl.
sudo fail2ban-client set sshd unbanip diegesperrteipadresse

Du benötigst Hilfestellung oder hast einen Fehler im Blog-Beitrag entdeckt? Mit einem Klick auf den unteren Button gelangst du direkt zum passenden Supportthread, indem du deine Frage bzw. Anregung mitteilen kannst. Wir freuen uns auf dein Feedback.

sakis-tech
Folge mir!
5 3 Stimmen
Wie gefällt Ihnen der Artikel?
Abonnieren
Benachrichtige mich bei
6 Kommentare
Inline-Feedbacks
Alle Kommentare anzeigen
Simon
Gast
27.12.2022 17:26

KLeine Stolperfalle für Einsteiger bei Deinem Tutorial:
Bevor man unter ubuntu 22.04 den chown macht:

chown $USER:$USER /home/$USER/.ssh/authorized_keys

muss man erst noch das .ssh Verzeichnis und die authorized_keys im selbigen anlegen.

Simon
Gast
Antwort an  sakis-tech
07.01.2023 19:02

Gerade den zweiten Server mit ubuntu 22.04 LTS nach Deinem How-To am Abhärten: Nope, das Verzeichnis ~/.ssh ist nicht angelegt bei einem neu erzeugten User.
Daher ist bei einem über adduser angelegten User vor dem chown ein

mkdir /home/$USER/.ssh
touch /home/$USER/.ssh/authorized_keys

notwendig.

Klar, kein Problem, wenn man schon etwas mit *nix gearbeitet hat, dachte nur für die Neulinge an der Shell evtl. wichtig zu wissen.

Und fail2ban scheint unter ubuntu 22.04 nicht reboot-fest zu sein
Da muss noch ein

sudo systemctl enable fail2ban

ausgeführt werden.

Und vielen Dank für das schöne How-To.

Andreas
Gast
24.07.2022 10:34

Netter Einstiegsartikel, jedoch sollte man heutzutage keine RSA-Schlüssel mehr verwenden, sondern gleich auf EdDSA Schlüsselpaare setzen. Auch sollte in einem Artikel zum Härten von SSH auch das Einschränken auf starke Kryptographie (Kex,HostKey,Ciphers, MACs) nicht fehlen und deren Prüfung (z.B. mittels nmap –script ssh2-enum-alogs) kurz erklärt werden, vielleicht kannst du das noch ergänzen.