ssh-keygen: SSH-Schlüssel erzeugen, öffentlichen Schlüssel hinterlegen und ssh-copy-id nutzen

ssh-keygen ist der OpenSSH-Befehl, der das Paar aus privatem und öffentlichem Schlüssel für SSH-Verbindungen erzeugt und außerdem Fingerabdrücke prüft, Passphrasen ändert und known_hosts aufräumt. Ich habe auf einem AlmaLinux-9-Server ed25519- und rsa-Schlüssel erzeugt, die Fingerabdrücke geprüft, Passphrase und Kommentar geändert und danach ssh-copy-id im Dry-Run getestet: Zum Server geht nur die eine Zeile mit dem öffentlichen Schlüssel aus der .pub-Datei.

Kontonamen und Pfade der Schlüsseldateien in der Ausgabe unten sind Beispielwerte; Fingerabdrücke, öffentliche Schlüssel und randomart stammen von Schlüsseln, die für diesen Artikel erzeugt und danach gelöscht wurden. Den Befehl, der einen öffentlichen Schlüssel wirklich auf einem Server hinterlegt, zeige ich nur, ausgeführt habe ich ihn nicht.

1️⃣ Schlüssel mit ssh-keygen erzeugen: -t ed25519 und Kommentar mit -C

Schlüssel erzeugst du in der Form ssh-keygen -t Typ -C Kommentar. -t ist der Schlüsseltyp, -C ein Kommentar am Ende des öffentlichen Schlüssels, in den du eine E-Mail-Adresse oder den Zweck schreibst. Unten siehst du die komplette Ausgabe, wenn die Datei mit -f festgelegt ist und du bei beiden Passphrase-Abfragen einfach Enter drückst.

ssh-keygen -t ed25519 -C "user@example.com" -f ~/.ssh/id_ed25519

Generating public/private ed25519 key pair.
Enter passphrase for "/home/user/.ssh/id_ed25519" (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:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com
The key's randomart image is:
+--[ED25519 256]--+
|                 |
|     .           |
|    o o          |
|     = o   .     |
|    =   Soo .    |
|     = *+*.. .   |
|    o.B.o++ .    |
|    .=o*Eo.+     |
|    o+=@OO=      |
+----[SHA256]-----+

Drückst du bei der Passphrase-Abfrage nur Enter, entsteht ein Schlüssel ohne Passphrase. Lässt du -f weg, fragt vor der Passphrase zuerst eine Zeile nach dem Speicherort. In Klammern steht der Standardpfad .ssh/id_ed25519 in deinem Home-Ordner, und auch hier speichert ein einfaches Enter den Schlüssel dort.

Das randomart am Ende der Ausgabe ist der Fingerabdruck als Bild. Beim Erzeugen und bei der erneuten Prüfung mit -lv kam dasselbe Bild heraus.

ls -l ~/.ssh/id_ed25519 ~/.ssh/id_ed25519.pub

-rw------- 1 user user 411 Oct 29 08:22 /home/user/.ssh/id_ed25519
-rw-r--r-- 1 user user  98 Oct 29 08:22 /home/user/.ssh/id_ed25519.pub

Der private Schlüssel wurde mit den Rechten 600 angelegt, der öffentliche mit 644. Den privaten Schlüssel behältst du nur auf deinem eigenen Rechner und gibst ihn nicht weiter.

cat ~/.ssh/id_ed25519.pub

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.com

Der öffentliche Schlüssel ist eine einzige Zeile aus Schlüsseltyp, Schlüsselwert und Kommentar, getrennt durch Leerzeichen. Genau diese Zeile kommt in die authorized_keys des Servers, mit dem du dich verbindest. Die Aufgaben der Dateien im Ordner sind als Baum zusammengefasst.

2️⃣ ssh-keygen-Optionen: -f, -N, -b, -q

Fragen zu beantworten ist bequem, wenn du von Hand tippst, in einem Skript müssen die Fragen aber ganz weg. Legst du die Datei mit -f und die Passphrase mit -N fest, wird der Schlüssel sofort ohne Rückfrage erzeugt.

ssh-keygen -t ed25519 -f ~/.ssh/deploy_key -N "" -C "deploy@example.com"

Generating public/private ed25519 key pair.
Your identification has been saved in /home/user/.ssh/deploy_key
Your public key has been saved in /home/user/.ssh/deploy_key.pub
The key fingerprint is:
SHA256:Rhk2/tgn59K8jtvDWJTOLiYnToM8t4gkdaMfu6TJ0oM deploy@example.com
The key's randomart image is:
+--[ED25519 256]--+
|        +        |
|       o +       |
|        +    .   |
|       . +  o    |
|    . o S ++o    |
|   . + +   B+    |
|  .oo * + .=+    |
|  E+o* Boo=++.   |
|   .=.=oo=o++.   |
+----[SHA256]-----+

Mit leeren Anführungszeichen hinter -N entsteht ein Schlüssel ohne Passphrase, und Speicherort und Fingerabdruck erschienen ohne jede Abfrage in einem Rutsch.

ssh-keygen -t ed25519 -f ~/.ssh/deploy_key -N ""

Generating public/private ed25519 key pair.
/home/user/.ssh/deploy_key already exists.
Overwrite (y/n)?

Führst du den Befehl mit demselben Namen noch einmal aus, fragt er nach already exists, ob überschrieben werden soll. Mit n blieb alles unverändert, und der Befehl endete mit Exit-Code 1. Damit du einen Schlüssel im Einsatz nicht versehentlich überschreibst, erzeugst du neue Schlüssel unter einem anderen Namen.

ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N "" -C "user@example.com"

Generating public/private rsa key pair.
Your identification has been saved in /home/user/.ssh/id_rsa
Your public key has been saved in /home/user/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:f+uwCSQjMka1BEHzXADwIWbrlbVRiP6Z4tjnwNwPVAA user@example.com
The key's randomart image is:
+---[RSA 4096]----+
|o=BE*=+.         |
|oo.Oo++          |
| .+o+. .         |
|....  .          |
| .+ o.= S        |
| .o+o= + .       |
|  ++.o  . o .    |
| . o..o  . = .   |
|    o. .  o.o    |
+----[SHA256]-----+

Bei rsa legt -b die Länge fest. Laut Handbuch ist der Standard 3072 Bit; oben wurde der Schlüssel mit 4096 Bit erzeugt, und im Kopf des randomart stand RSA 4096. ed25519 hat laut Handbuch eine feste Länge, -b wird dort ignoriert.

ssh-keygen -f ~/.ssh/default_key -N "" -C "user@example.com"

Generating public/private ed25519 key pair.
Your identification has been saved in /home/user/.ssh/default_key
Your public key has been saved in /home/user/.ssh/default_key.pub
The key fingerprint is:
SHA256:mwy02fpKxjxEVvLC2EUJeaMIiNFOVS0GwWVjN9v0j4c user@example.com
The key's randomart image is:
+--[ED25519 256]--+
|o+ o+=O=*..      |
|o + .*+B== .     |
| o ..oB+o.. .    |
|  . .+.=     +   |
|      = S   E o  |
|     + + o   .   |
|      B +        |
|     o o         |
|      ...        |
+----[SHA256]-----+

Ohne -t wurde ein ed25519-Schlüssel erzeugt.

ssh-keygen -q -t ed25519 -f ~/.ssh/backup_key -N "" -C "backup@example.com"; echo rc=$?

rc=0

Mit -q wird alles ausgeblendet, auch Fingerabdruck und randomart, nur der Exit-Code bleibt. Das nutzt du, wenn ein Skript Schlüssel für mehrere Server erzeugt.

📌 Wichtige Optionen: Ergebnisse aus diesem Artikel

📎 Weitere Optionen: laut offiziellem Handbuch

3️⃣ ssh-keygen -l für den Fingerabdruck und -y zum Auslesen des öffentlichen Schlüssels

Gibt es mehrere Schlüsseldateien, lässt sich am Dateinamen allein schwer erkennen, welcher öffentliche Schlüssel zu welchem privaten gehört. Da der Fingerabdruck für privaten und öffentlichen Schlüssel gleich ist, bestätigst du das Paar, indem du die Fingerabdrücke beider Dateien mit -l vergleichst.

ssh-keygen -l -f ~/.ssh/id_ed25519.pub

256 SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com (ED25519)

ssh-keygen -l -f ~/.ssh/id_ed25519

256 SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com (ED25519)

Öffentliche und private Schlüsseldatei lieferten denselben SHA256-Fingerabdruck. Die 256 vorne ist die Schlüssellänge, die Klammer am Ende der Schlüsseltyp.

ssh-keygen -l -E md5 -f ~/.ssh/id_ed25519.pub

256 MD5:00:7b:02:5e:b8:ba:85:0c:32:d7:15:7e:72:45:f7:bc user@example.com (ED25519)

Mit -E md5 wechselt die Ausgabe zum älteren MD5-Fingerabdruck. Das brauchst du zum Abgleich, wenn ein alter Server oder ein Verwaltungsbereich MD5-Fingerabdrücke anzeigt.

ssh-keygen -lv -f ~/.ssh/id_ed25519.pub

256 SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com (ED25519)
+--[ED25519 256]--+
|                 |
|     .           |
|    o o          |
|     = o   .     |
|    =   Soo .    |
|     = *+*.. .   |
|    o.B.o++ .    |
|    .=o*Eo.+     |
|    o+=@OO=      |
+----[SHA256]-----+

Mit -v dazu erscheint das randomart erneut. Es war dasselbe Bild wie beim Erzeugen des Schlüssels.

ssh-keygen -l -f ~/.ssh/authorized_keys

256 SHA256:Rhk2/tgn59K8jtvDWJTOLiYnToM8t4gkdaMfu6TJ0oM deploy@example.com (ED25519)

Gibst du eine Datei mit mehreren Zeilen öffentlicher Schlüssel an, etwa authorized_keys, bekommst du pro Schlüssel eine Zeile Fingerabdruck. So prüfst du, welche Schlüssel auf einem Server hinterlegt sind.

ssh-keygen -y -f ~/.ssh/id_ed25519

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.com

-y liest den öffentlichen Schlüssel erneut aus dem privaten aus. Hast du die .pub-Datei gelöscht oder nur den privaten Schlüssel auf einen anderen Rechner gebracht, speicherst du diese Ausgabe einfach in eine Datei. Die Ausgabe war Zeichen für Zeichen gleich der ursprünglichen .pub-Datei.

4️⃣ ssh-keygen -p zum Ändern der Passphrase und -c zum Ändern des Kommentars

Mit einer Passphrase auf dem privaten Schlüssel ist die Datei ohne Passphrase nicht nutzbar, selbst wenn sie in fremde Hände gerät. Dafür musst du die Passphrase bei jeder Verbindung eingeben; sie passt also zu Schlüsseln, die Menschen von Hand nutzen, nicht zu Schlüsseln für automatisch laufende Skripte wie Cronjobs.

ssh-keygen -p -f ~/.ssh/id_ed25519 -P "" -N "example-pass"

Key has comment 'user@example.com'
Your identification has been saved with the new passphrase.

-P ist die alte Passphrase, -N die neue. Der Schlüssel hatte keine Passphrase, daher bekam -P leere Anführungszeichen, und zwei Zeilen meldeten, dass mit der neuen Passphrase neu gespeichert wurde. Laut Handbuch fragt -p allein ohne Optionen nacheinander nach alter und neuer Passphrase.

ls -l ~/.ssh/id_ed25519

-rw------- 1 user user 464 Oct 29 08:22 /home/user/.ssh/id_ed25519

Nach dem Setzen der Passphrase wuchs die private Schlüsseldatei von 411 auf 464 Byte.

ssh-keygen -y -f ~/.ssh/id_ed25519 -P "example-pass"

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.com

ssh-keygen -y -f ~/.ssh/id_ed25519 -P "wrongpass"

Load key "/home/user/.ssh/id_ed25519": incorrect passphrase supplied to decrypt private key

Bei einem Schlüssel mit Passphrase braucht auch -y die Passphrase über -P. Mit der richtigen Passphrase kam derselbe öffentliche Schlüssel wie vorher, mit einer falschen endete es mit dem Fehler incorrect passphrase. Laut Handbuch lässt sich eine verlorene Passphrase nicht wiederherstellen; vergisst du sie, erzeugst du einen neuen Schlüssel und hinterlegst den öffentlichen Schlüssel erneut.

ssh-keygen -c -C "user@laptop" -f ~/.ssh/id_ed25519 -P "example-pass"

Old comment: user@example.com
Comment 'user@laptop' applied

cat ~/.ssh/id_ed25519.pub

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@laptop

-c ändert den Kommentar. Alter und neuer Kommentar erscheinen je in einer Zeile, und auch der Kommentar am Ende der öffentlichen Schlüsseldatei wurde zu user@laptop. Der Kommentar ist nur eine Markierung zur Unterscheidung, der Schlüsselwert selbst blieb gleich.

ssh-keygen -p -f ~/.ssh/id_ed25519 -P "example-pass" -N ""

Key has comment 'user@laptop'
Your identification has been saved with the new passphrase.

Um die Passphrase zu entfernen, gibst du -N leere Anführungszeichen. Es erscheinen dieselben zwei Zeilen, und danach lief -y wieder ohne -P.

5️⃣ ssh-keygen -R: Host-Schlüssel aus known_hosts löschen

In known_hosts sammeln sich die Host-Schlüssel der Server, mit denen du verbunden warst, je eine Zeile. Wird ein Server neu installiert und ändert sich sein Host-Schlüssel, verweigert ssh die Verbindung, weil der Schlüssel vom gespeicherten abweicht, und die Option, die die alte Zeile löscht, ist -R. Das known_hosts unten ist eine Datei aus drei Zeilen mit Beispieladressen, angegeben mit -f.

cat ~/.ssh/known_hosts

192.0.2.10 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk
server2.example.com,192.0.2.20 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR
[192.0.2.30]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIC0WmcBD2HIsiSn+tERrbeFIyExAodSEUhE9j5WMpkRW

Jede Zeile enthält Hostname oder Adresse, Schlüsseltyp und Schlüsselwert in dieser Reihenfolge. Die zweite Zeile mit Komma enthält Name und Adresse desselben Servers, und eckige Klammern mit Doppelpunkt in der dritten Zeile stehen für einen anderen Port als 22.

ssh-keygen -F 192.0.2.10 -f ~/.ssh/known_hosts

# Host 192.0.2.10 found: line 1
192.0.2.10 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk

-F gibt die Zeile dieses Hosts zusammen mit ihrer Zeilennummer aus. Bei einem unbekannten Host kam keine Ausgabe, und der Befehl endete mit Exit-Code 1.

ssh-keygen -R 192.0.2.10 -f ~/.ssh/known_hosts

# Host 192.0.2.10 found: line 1
/home/user/.ssh/known_hosts updated.
Original contents retained as /home/user/.ssh/known_hosts.old

cat ~/.ssh/known_hosts

server2.example.com,192.0.2.20 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR
[192.0.2.30]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIC0WmcBD2HIsiSn+tERrbeFIyExAodSEUhE9j5WMpkRW

-R löscht die Zeile dieses Hosts und behält die Originaldatei als known_hosts.old. Nach dem Löschen blieben nur zwei Zeilen übrig.

ssh-keygen -R 192.0.2.99 -f ~/.ssh/known_hosts

Host 192.0.2.99 not found in /home/user/.ssh/known_hosts

ssh-keygen -R "[192.0.2.30]:2222" -f ~/.ssh/known_hosts

# Host [192.0.2.30]:2222 found: line 2
/home/user/.ssh/known_hosts updated.
Original contents retained as /home/user/.ssh/known_hosts.old

Bei einem unbekannten Host kam nur eine Zeile not found. Für einen Server mit anderem Port musst du eckige Klammern und Port genau so angeben, wie sie in known_hosts stehen.

ssh-keygen -H -f ~/.ssh/known_hosts

WARNING: /home/user/.ssh/known_hosts.old contains unhashed entries
Delete this file to ensure privacy of hostnames
/home/user/.ssh/known_hosts updated.
Original contents retained as /home/user/.ssh/known_hosts.old

cat ~/.ssh/known_hosts

|1|JL/knNlx/BnCoOWp5rNeRo3r1rE=|OCPyeFd1rgG8P2QGzrju/V2Y8c4= ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR
|1|AG9QJQvGaQmVsEusSdND1lM9cKI=|Ue0a9suJIzN0yxoJgV7ClLBgSYw= ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR

-H hasht Hostnamen und Adressen. Die Option verhindert, dass eine geleakte Datei verrät, mit welchen Servern du verbunden warst; Name und Adresse, die per Komma verbunden waren, wurden in zwei gehashte Zeilen aufgeteilt. Dazu kam die Warnung, dass die .old-Datei noch den ungehashten Inhalt enthält.

ssh-keygen -F server2.example.com -f ~/.ssh/known_hosts

# Host server2.example.com found: line 1
|1|JL/knNlx/BnCoOWp5rNeRo3r1rE=|OCPyeFd1rgG8P2QGzrju/V2Y8c4= ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR

Auch in der gehashten Datei fand -F die Zeile über den Namen.

6️⃣ ssh-copy-id: öffentlichen Schlüssel hinterlegen und authorized_keys

Ein erzeugter Schlüssel allein reicht nicht: Solange der Server den öffentlichen Schlüssel nicht kennt, meldest du dich weiter mit Passwort an. Bekannt gemacht wird der öffentliche Schlüssel in ~/.ssh/authorized_keys des Kontos, mit dem du dich anmeldest, und ssh-copy-id ist der Befehl, der die .pub-Zeile in diese Datei schreibt. Der private Schlüssel bleibt auf deinem Rechner, nur die Zeile mit dem öffentlichen Schlüssel geht hinüber. Drück im Diagramm unten auf die Schritt-Schaltflächen, um zu sehen, wo die beiden Dateien landen.

ssh-copy-id -n -i ~/.ssh/deploy_key.pub -o ConnectTimeout=3 user@192.0.2.10

/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/deploy_key.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed

/usr/bin/ssh-copy-id: ERROR: ssh: connect to host 192.0.2.10 port 22: Connection timed out

-n ist ein Dry-Run, auf den Server wird also nichts geschrieben. Trotzdem versucht ssh-copy-id zuerst, sich mit diesem Schlüssel anzumelden, um bereits hinterlegte Schlüssel auszusortieren, und weil 192.0.2.10 eine Dokumentationsadresse ist, kam keine Verbindung zustande, und es endete mit timed out. Optionen hinter -o gehen unverändert an ssh.

ssh-copy-id -n -f -i ~/.ssh/deploy_key.pub -o ConnectTimeout=3 user@192.0.2.10

/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/deploy_key.pub"
=-=-=-=-=-=-=-=
Would have added the following key(s):

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk deploy@example.com
=-=-=-=-=-=-=-=

-f ist der Force-Modus, der diese Prüfung überspringt. Zusammen mit -n erschien unter Would have added die Zeile mit dem öffentlichen Schlüssel, die auf den Server käme. Es ist dieselbe Zeile wie der Inhalt der .pub-Datei.

ssh-copy-id -i ~/.ssh/id_ed25519.pub user@192.0.2.10

Das eigentliche Hinterlegen erledigt dieser Befehl ohne -n. Laut ssh-copy-id-Skript und Handbuch fragt er einmal nach dem Passwort des Kontos, hängt den öffentlichen Schlüssel ans Ende von ~/.ssh/authorized_keys auf dem Server und gibt dann Number of key(s) added: 1 aus. Fehlen Datei und Ordner, legt er sie an, und ist derselbe Schlüssel schon vorhanden, überspringt er ihn.

ssh-copy-id -i ~/.ssh/id_ed25519.pub -p 2222 user@192.0.2.10

Ist der Port nicht 22, gibst du ihn mit -p mit.

Wo es kein ssh-copy-id gibt, hängst du die Zeile mit dem öffentlichen Schlüssel selbst an die authorized_keys des Servers an. Melde dich mit deinem Passwort am Server an und geh in der folgenden Reihenfolge vor. Die Ausgabe wurde geprüft, indem die .pub-Datei auf demselben Server angehängt wurde; bei einem anderen Server kopierst du die Zeile aus der .pub-Datei und hängst sie mit echo an.

mkdir -p ~/.ssh

chmod 700 ~/.ssh

Fehlt der Ordner .ssh, legst du ihn an und setzt die Rechte auf 700.

cat ~/.ssh/deploy_key.pub >> ~/.ssh/authorized_keys

chmod 600 ~/.ssh/authorized_keys

cat ~/.ssh/authorized_keys

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk deploy@example.com

ls -l ~/.ssh/authorized_keys

-rw------- 1 user user 100 Oct 29 08:22 /home/user/.ssh/authorized_keys

Die Zeile mit dem öffentlichen Schlüssel steht jetzt in authorized_keys, mit den Rechten 600. Laut dem Eintrag StrictModes im sshd_config-Handbuch prüft sshd in der Standardeinstellung zuerst die Rechte der Benutzerdateien und lehnt die Anmeldung ab, wenn jeder darauf schreiben darf.

ssh -i ~/.ssh/id_ed25519 user@192.0.2.10

Nach dem Hinterlegen verbindest du dich mit dem privaten Schlüssel. Hat der Schlüssel einen Standardnamen wie id_ed25519, findet ssh ihn von selbst; hat er einen anderen Namen wie deploy_key, gibst du die Datei mit der ssh-Option -i an.

🔲 Simulator für den Befehl ssh-keygen

Im Simulator unten kannst du ssh-keygen selbst eintippen: Schlüssel erzeugen, Fingerabdruck prüfen, Passphrase ändern, known_hosts aufräumen und ssh-copy-id ausprobieren. Fingerabdrücke und öffentliche Schlüssel sind dieselben Beispielwerte wie im Artikel, und ssh-copy-id tut nur so, als würde es auf einem virtuellen Server hinterlegen.

🔢 FAQ & empfohlene Inhalte

🔗 Empfohlene Artikel

Nächster Schritt Per SFTP & SSH zu Cloudways verbinden: FileZilla einrichten, SSH-Schlüssel hinterlegen FileZilla-SFTP sowie Web-SSH-Terminal und PowerShell im Simulator nachgebaut und SSH-Schlüssel und IP-Whitelist auf dem Testserver geprüft. Artikel lesen →

Windows · Öffentlicher Schlüssel Öffentlichen Schlüssel in Xshell erzeugen So erzeugst du mit dem Schlüsselassistenten des Windows-SSH-Clients Xshell einen öffentlichen Schlüssel und hinterlegst ihn auf dem Server. SSH · Servereinstellungen SSH-Konfiguration: Funktionen und Einstellungen der Datei sshd_config Artikel über Einstellungen wie Port, Root-Anmeldung und Authentifizierung per öffentlichem Schlüssel in der sshd_config des empfangenden Servers. Linux · Grundlagen SSH unter Linux: Definition und Grundeinstellungen Was SSH ist, wie es sich von Telnet unterscheidet und wie du sshd auf einem Server startest und die Grundeinstellungen prüfst.

ℹ️ Affiliate-Hinweis
Die Inhalte dieser Website enthalten Affiliate-Links. Kauft ein Besucher über einen dieser Links ein Produkt oder eine Dienstleistung, erhält die Website vom Verkäufer eine Provision. Der Betrag, den der Käufer zahlt^{(bei Aktionsrabatten sinkt er ↓)}, steigt dadurch nicht. Angegebene Preise, Rabatte und Lagerbestände entsprechen dem Stand bei Erstellung und können abweichen; prüfe sie daher vor dem Kauf beim Verkäufer. Produkte werden nach eigenen Kriterien ausgewählt und bewertet, und Provisionen beeinflussen weder die Reihenfolge noch den Inhalt der Bewertungen.