ssh key erstellen

Als Webentwickler kam ich letztens an einen Punkt, an dem mir ein “normaler” Webserver nicht mehr ausreichte und ich mich daher nach Alternativen umschaute. Da ich als ehemaliger Mechaniker eher praktisch veranlagt bin und gerne selber Dinge ausprobiere und optimiere, weckten die root-Server sehr schnell mein Interesse. Aber: Was muss ich alles bedenken? Heute starten wir mit der Frage: Wie erstelle ich einen ssh key?

  1. Wie richte ich mir einen SSH-Key ein?
  2. RSA vs. DSA
  3. Welche Schlüssellänge ist heutzutage aktuell?
  4. Brauche ich ein Passwort für meinen Private-Key?
  5. Fingerprint, Randomart?? Warum?

Voller Vorfreude gab ich Hostnamen und Passwort hinter den SSH-Befehl in die Kommandozeile ein. Und Tadaa, mein V-Root meldete sich wie gewünscht mit

root@myserver: ~#

Jetzt hatte ich die Macht, ein eigenes System. :D Die nächste Frage ließ aber nicht lange auf sich warten. Wie richte ich den Server ein? Was ist notwendig für ein stabiles System? Wie war das nochmal mit der Sicherheit? Wie komme ich am einfachsten und schnellsten auf den Server?

Mit einem Webserver und Datenbanken hab‘ ich ja keine Probleme, mit allem anderen musste ich mich erst auseinandersetzen.

Wie richte ich mir einen SSH-Key ein?

Um mich nicht immer mit meinem Passwort auf dem Server anmelden zu müssen, bietet das ssh-Protokoll die Authentifizierung über einen öffentlichen Schlüssel (Public-Key Authentifizierung). Dafür werden ein Private Key auf dem Client und ein Public Key auf dem Server hinterlegt, mit denen eine Authentifizierung ohne Passwort möglich ist.

Für „Lesephobiker“ habe ich in einem zweiten Beitrag die Anleitung in Kurzform verfasst. ;) In diesem Artikel gehe ich noch auf einige Fragen ein, die ich mir während des Schreibens gestellt habe.

me@home: ~$ ssh-keygen -t rsa -b 4096

Mit diesem Befehl wird ein Schlüsselpaar erzeugt. Dabei gebe ich den Typ “RSA” und die Verschlüsselungstiefe in bit mit 4096 an.

Generating public/private rsa key pair
Enter file in which to save the key (/home/me/.ssh/id_rsa)

Wenn die location und der Dateiname so passt, dann könnt ihr hier einfach “Enter” drücken. Ansonsten einfach den absoluten Pfad angeben, wo die Keys gespeichert werden sollen.

Enter passphrase (empty for no passphrase):

Falls ihr die Sicherheit des private Keys erhöhen wollt, tragt da ein Passwort ein. Ihr werdet anschließend aufgefordert, das Passwort nochmal einzugeben.

Your identification has been saved in /home/me/.ssh/id_rsa
Your public key has been saved in /home/me/.ssh/id_rsa.pub
The key fingerprint is:
df:a8:fe:c2:d6:88:07:78:9e:c7:d7:69:b4:6a:02:f0 me@home
The key’s randomart image is:
+------[ RSA 4096]------+
| |
| |
| . |
| . . o . |
| S o *..o|
| E o* ++.|
| . .+..oo |
| +... o |
| ooo. o |
+-----------------------+

Und fertig ist das Schlüsselpaar. :)

Jetzt muss der öffentliche Schlüssel auf den Server kopiert werden.

me@home:~$ ssh-copy-id -i /home/me/.ssh/id_rsa me@myrootserver.de

mit “-i” gebe ich die Identifikationsdatei an und schließe mit dem „Benutzer@Host“ ab. Dann noch schnell das Passwort eingeben und schon sollte der public key auf dem Server sein. Um den Private-Key noch sicherer zu machen, wandeln wir den Private-Key in ein anderes Format um (PCKS#8).
Erstmal bennene ich die Private-Key-Datei und wandle sie anschließend in das neue Format um.

me@home: ~/.ssh$ mv id_rsa id_rsa.bak
me@home: ~/.ssh$ openssl pkcs8 -topk8 -v2 des3 \
-in id_rsa.old -out id_rsa

Dieses Format ist noch sicherer gegen Brute-Force Attacken und vor allem abwärtskompatibel, da PCKS#8 Bestandteil von openSSL und das wiederum von openSSH ist. :)

Nun könnt ihr euch mit

me@home:~$ ssh me@myrootserver.de

auf eurem Rootserver anmelden, ohne ein Passwort zu benutzen. War die Anmeldung erfolgreich, löschen wir noch das Backup des Private-Keys.

me@home: ~/.ssh$ rm id_rsa.bak

Sollte euch der SSH-Befehl immer noch zu lang sein, könnt ihr ihn mit folgenden Anpassungen kürzen (Bspw.: ssh myroot). Dazu einfach in das .ssh-Verzeichnis wechseln und da, falls nicht vorhanden, die config Datei anlegen. Ansonsten einfach mal öffnen.

me@home:~$ cd .ssh
me@home:~/.ssh$ vim config

Dort tragt ihr folgendes ein:

Host myroot
HostName myrootserver.de
User me
IdentityFile ~/.ssh/id_rsa

Ist die Datei einmal abgespeichert, könnt ihr euch einfach mit

me@home:~/.ssh$ ssh myroot

auf dem Rootserver einloggen.

Somit ist das Handwerkliche schon mal erledigt. Allerdings haben sich bei mir beim copy & paste weitere Fragen zu dem „Warum mache ich das so“ ergeben, auf die ich jetzt noch näher eingehen werde.

RSA vs. DSA

Erstmal, was ist RSA überhaupt?! Hört sich schlau und wichtig an, sagte mir aber nichts.

Die Kurzform besteht eigentlich nur aus einer Auflistung von Namen. Rivest, Shamir und Adleman. Die drei versuchten am MIT die Theorie von Diffie und Hellmann zu widerlegen, die eine Theorie zur Public-Key-Verschlüsselung aufgestellt hatten. Letztendlich kam ein Public-Key-Verschlüsselungsverfahren, welches scheinbar sicher war und anschließend zum Patent angemeldet wurde. Also ein Verschlüsselungsverfahren, das auch zur digitalen Signatur genutzt werden kann. Dazu gibt es einen privaten Schlüssel, der auf dem eigenen System liegen bleibt, und einen öffentlichen Schlüssel, der frei weitergegeben werden kann. Mit diesen beiden Schlüsseln können dann Signaturen erstellt, verschlüsselt und entschlüsselt und letztendlich auch dahingehend verifiziert werden, dass man auch der ist, der man vorgibt zu sein.

Als Alternative zur RSA Signatur gibt es noch die DSA (Digital Signature Algorithm) Variante.

Dieses Verfahren wurde von der NSA im Auftrag der US-Regierung entwickelt.

Allerdings wird DSA von vielen nicht mehr empfohlen, da diese nur auf eine Schlüssellänge von 1024 bit begrenzt ist. RSA Schlüssel sind da nicht so eingeschränkt. Ein Versuch auf meinem V-Root-Server mit 16384 bit war ohne Probleme möglich. Hat zwar etwas länger gedauert, aber es ging. Auf meinem doch etwas älteren Notebook dauerte es einfach zu lange, um das Schlüsselpaar zu erzeugen, weshalb ich den Prozess abgebrochen habe.

Welche Schlüssellänge ist heutzutage aktuell?

Wie oben schon kurz angedeutet, dauert die Erzeugung des Schlüssels länger, je größer die Schlüssellänge in Bit gewählt wird und ist damit auch rechenleistungsabhängig. Das Ver- und Entschlüsseln dauert dementsprechend auch länger. Die Standardlänge im SSH-Client ist auf 2048 bits gesetzt, wobei mittlerweile eine Schlüssellänge von 4096 bits empfohlen wird. Ein 4096 bits langer Schlüssel wird nicht so schnell geknackt wie einer mit einer Länge von 2048 oder sogar 1024. Wobei ein 1024 bit RSA Schlüssel genauso stark ist wie ein 1024 bit DSA Schlüssel.

Ich selber habe meine Schlüssel mit 8192 bit erstellt, damit ich diesen Schlüssel auch etwas länger nutzen kann, ohne mir Sorgen um die Sicherheit meines Schlüssels machen zu müssen.

Brauche ich ein Passwort für meinen Private-Key?

Für mich ein klares JA. Eine weitere Barriere, um an meinen privaten Schlüssel zu kommen, ist immer gut. Wenn jemand sich aus irgendeinem Grund Zugang zu meinem Rechner verschafft hat, kann er auch relativ schnell auf meinen v-Root-Server. Bei jeder Anmeldung müsst ihr dann aber dieses Passwort eingeben. Dafür gibt es jedoch noch kleine Helferlein wie “keepass” & Co., die einem das Eingeben des Passworts abnehmen.

In der Kurzanleitung habe ich ja schon den Private-Key in das PCKS#8 Format umgewandelt, da für Brute-Force Attacken anfälliger. Das Passwort wird nämlich nur MD5 gehasht, mit einem Salt versehen und anschließend wird der Key damit verschlüsselt. Das gehashte Passwort ist jedoch relativ leicht aus der Datei zu extrahieren und damit auch anfälliger für Brute-Force Attacken.

Fingerprint, Randomart?? Warum?

Naja, das mit dem Fingerprint konnte ich mir schon halb denken. Es soll eine Eindeutigkeit von etwas darstellen.

Der Fingerprint basiert auf dem Host-Key und soll die Identifikation von Hosts erleichtern. Außerdem wird er als Indikator für MITM-Angriffe genutzt. Bei der ersten Anmeldung muss man ja bestätigen, dass man sich wirklich mit dem Server verbinden will.

Bei diesem Schritt wird der Fingerprint des Servers angezeigt und man könnte über eine andere sichere Verbindung prüfen, ob es sich wirklich um den Fingerprint des Servers handelt. Bestätigt man die Aktion mit “yes”, wird der Host in der Datei “known_hosts” gespeichert. Bei den folgenden Anmeldungen auf dem Server wird der Fingerprint des Hosts mit dem in der Datei gespeicherten abgeglichen. Stimmen diese nicht überein, wird eine Warnung erzeugt und die Anmeldung wird abgebrochen. Meistens kommt der Fehler aber nicht von einer MITM-Attacke. Oft wurde der ssh-Server oder auch das System neu aufgesetzt. Der Eintrag muss dann einfach aus der known_hosts Datei entfernt werden, was ihr mit

me@home: ~$ ssh-keygen -R Benutzer@Host

durchführt. Beim nächsten Anmeldeversuch wird dann wieder gefragt, ob man wirklich mit dem Server verbunden werden möchte.

Das Randomart soll jetzt die “manu-visuelle” Identifikation des Servers vereinfachen, indem ein Bild aus dem Fingerprint bzw. aus dem Public-Key generiert wird. Da erkennt man auf “einen Blick”, ob es der richtige Server ist, auf den ich mich verbinden will. Damit euch die Grafik bei Verbinden auf den Server angezeigt wird, müsst ihr eure ssh_config wie folgt anpassen.

me@home: ~$ vim /etc/ssh/ssh_config

dann einfach die Zeile

#VisualHostKey no

einkommentieren und auf yes setzen.

VisualHostKey yes

Und schon seht ihr die Grafik und könnt euren Server auch identifizieren. Das soll es auch schon gewesen sein, was das Authentifizieren per Public-Key angeht. :) Wir haben nun das Schlüsselpaar erstellt, auf den Server kopiert und noch kleine Anpassungen vorgenommen. Damit kommt man erstmal schnell auf den Server ohne lästige Passworteingabe.

Kommentare

  1. Gravatar
    Philipp am
    Jetzt muss nur noch euer Jump-Server Service ssh-keys unterstützen ;-)
    Antworten
  2. Tobias Hüske am

    Hallo Herr Norcoc,

    vielen Dank für Ihren Kommentar und die Rückfrage!

    Es wird automatisch der öffentliche Schlüssel aus der *.pub-Datei kopiert. Das Tool ssh-copy-id wählt diesen immer aus, selbst wenn Sie nur den Schlüsselnamen bzw. den Verweis auf die private Datei angeben. Durch dieses Sicherheitsfeature kann also der private Schlüssel, den Sie ausschließlich auf Ihrem Rechner haben sollten, nicht auf den Server gelangen.

    Viele Grüße

    Tobias Hüske

    Antworten
  3. Gravatar
    ThiasJ am

    Nachtrag: Grade auf wiki.ubuntuusers.de/SSH nachgelesen:

    — Zitat;
    Sollte man – warum auch immer – bei der Angabe des Dateinamens des Schlüssels die Endung .pub vergessen, so wird diese automatisch durch ssh-copy-id angehängt. Man kann also nie aus Versehen seinen privaten Schlüssel Namens id_rsa (also ohne Endung .pub) übertragen.

    Sind also beide Methoden richtig :)

    Antworten
  4. Gravatar
    ThiasJ am

    Schöner Artikel, aber eine Frage:

    Zitat: „me@home:~$ ssh-copy-id -i /home/me/.ssh/id_rsa me@myrootserver.de

    Muss nicht der öffentliche Schlüssel kopiert werden? also /home/me/.ssh/id_rsa.pub oder wählt der Befehl dann automatisch den öffentlichen Schlüssel aus?

    Antworten
    1. Gravatar
      Felix Norcoc am

      Genau, dies ist auch meine Frage.

      Wird überhaupt geantwortet, da die letzte Anfrage schon sehr alt ist??

      Antworten

Kommentar hinzufügen