Wie man den Befehl docker trust key generate verwendet, um Signierschlüssel zu erstellen

DockerDockerBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie mit dem Befehl gpg Signierschlüsselpaare generieren können. Dies ist ein grundlegender Schritt für sichere Kommunikation und Softwareverteilung. Sie werden ein neues RSA-Schlüsselpaar mit einer bestimmten Schlüssellänge und Gültigkeitsdauer generieren und dabei wichtige Benutzer-ID-Informationen angeben.

Nach der Schlüsselgenerierung lernen Sie, wie Sie das Passwort für Ihren neuen Schlüssel eingeben und bestätigen können, was ein entscheidendes Sicherheitsmaßnahme ist. Anschließend werden Sie die generierte öffentliche Schlüsseldatei überprüfen, um deren Korrektheit sicherzustellen. Abschließend werden Sie untersuchen, wie Sie ein Schlüsselpaar in einem bestimmten Verzeichnis generieren können, was die Flexibilität bei der Verwaltung Ihrer Schlüssel zeigt.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") subgraph Lab Skills docker/exec -.-> lab-555252{{"Wie man den Befehl docker trust key generate verwendet, um Signierschlüssel zu erstellen"}} docker/create -.-> lab-555252{{"Wie man den Befehl docker trust key generate verwendet, um Signierschlüssel zu erstellen"}} end

Generieren eines neuen Signierschlüsselpaars

In diesem Schritt lernen Sie, wie Sie mit dem Befehl gpg ein neues Signierschlüsselpaar generieren können. Ein Signierschlüsselpaar besteht aus einem privaten Schlüssel und einem öffentlichen Schlüssel. Der private Schlüssel wird zum Signieren von Daten verwendet, und der öffentliche Schlüssel wird zur Überprüfung der Signatur eingesetzt. Dies ist ein grundlegendes Konzept in der sicheren Kommunikation und Softwareverteilung.

Öffnen Sie zunächst Ihr Terminal. Sie befinden sich bereits im Verzeichnis ~/project.

Um ein neues Schlüsselpaar zu generieren, verwenden Sie den folgenden Befehl:

gpg --full-generate-key

Nachdem Sie den Befehl ausgeführt haben, werden Sie aufgefordert, die Art des Schlüssels auszuwählen, den Sie möchten. In diesem Lab verwenden wir die Standardoption, die RSA and RSA ist. Drücken Sie Enter, um die Standardeinstellung zu akzeptieren.

gpg (GnuPG) 2.2.27; Copyright (C) 2021 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
Your selection? 1

Als nächstes werden Sie nach der Schlüssellänge gefragt. Eine größere Schlüssellänge bietet mehr Sicherheit, erfordert aber länger zum Generieren und Verwenden. In diesem Lab verwenden wir die Standard-Schlüssellänge von 3072 Bits. Drücken Sie Enter, um die Standardeinstellung zu akzeptieren.

RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (3072)

Anschließend werden Sie gefragt, wie lange der Schlüssel gültig sein soll. In diesem Lab lassen wir den Schlüssel ein Jahr lang gültig sein. Geben Sie 1y ein und drücken Sie Enter.

Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 1y

Bestätigen Sie, dass der Schlüssel am angezeigten Datum abläuft, indem Sie y eingeben und Enter drücken.

Key expires at ...
Is this correct? (y/N) y

Jetzt müssen Sie Benutzer-ID-Informationen angeben. Diese Informationen werden Ihrem öffentlichen Schlüssel zugeordnet und helfen anderen, Sie zu identifizieren.

Geben Sie zunächst Ihren realen Namen ein. In diesem Lab können Sie LabEx User verwenden. Geben Sie LabEx User ein und drücken Sie Enter.

Real name: LabEx User

Als nächstes geben Sie Ihre E-Mail-Adresse ein. In diesem Lab können Sie [email protected] verwenden. Geben Sie [email protected] ein und drücken Sie Enter.

Email address: [email protected]

Optional können Sie einen Kommentar hinzufügen. In diesem Lab lassen Sie das Kommentarfeld leer. Drücken Sie Enter, um den Kommentar zu überspringen.

Comment:

Überprüfen Sie die von Ihnen eingegebenen Informationen. Wenn sie korrekt sind, geben Sie O für Okay ein und drücken Sie Enter. Wenn Sie Änderungen vornehmen müssen, geben Sie C für Change oder Q für Quit ein.

You selected this USER-ID:
    "LabEx User <[email protected]>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O

Schließlich werden Sie aufgefordert, ein Passwort einzugeben, um Ihren privaten Schlüssel zu schützen. Dies ist ein entscheidender Sicherheits-Schritt. Wählen Sie ein starkes Passwort, das Sie sich merken können. Sie müssen dieses Passwort im nächsten Schritt erneut eingeben.

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator more entropy.

Das System wird dann das Schlüsselpaar generieren. Dies kann einen Moment dauern.

Eingabe und Bestätigung des Passworts für den neuen Schlüssel

Im vorherigen Schritt haben Sie den Prozess zur Generierung eines neuen GPG-Schlüsselpaars gestartet. Der letzte Schritt in diesem Prozess besteht darin, ein Passwort für Ihren privaten Schlüssel einzugeben und zu bestätigen. Dieses Passwort ist unerlässlich, um Ihren privaten Schlüssel vor unbefugtem Zugriff zu schützen.

Nun sollte ein Dialogfeld oder eine Eingabeaufforderung in Ihrem Terminal erscheinen, in der Sie aufgefordert werden, ein Passwort einzugeben.

┌─────────┤ Please enter the passphrase to protect your new key ├─────────┐
│                                                                         │
│ Passphrase: _________________________________________                   │
│                                                                         │
│        <OK>                                          <Cancel>           │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Geben Sie ein starkes Passwort in das Feld "Passphrase" ein. Merken Sie sich dieses Passwort, da Sie es jedes Mal benötigen werden, wenn Sie Ihren privaten Schlüssel verwenden (z.B. zum Signieren). In diesem Lab können Sie ein einfaches Passwort wie mypassphrase123 verwenden. Geben Sie mypassphrase123 ein und drücken Sie Enter oder klicken Sie auf <OK>.

Anschließend werden Sie aufgefordert, Ihr Passwort erneut einzugeben, um es zu bestätigen. Dies trägt dazu bei, sicherzustellen, dass Sie das Passwort korrekt eingegeben haben.

┌─────────┤ Please re-enter the passphrase to protect your new key ├─────────┐
│                                                                          │
│ Repeat passphrase: _________________________________________             │
│                                                                          │
│        <OK>                                           <Cancel>            │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘

Geben Sie das gleiche Passwort (mypassphrase123) erneut in das Feld "Repeat passphrase" ein und drücken Sie Enter oder klicken Sie auf <OK>.

Nach der Bestätigung des Passworts wird GPG die Generierung Ihres Schlüsselpaars abschließen. Sie sollten eine Ausgabe ähnlich der folgenden sehen, die darauf hinweist, dass die Schlüsselgenerierung abgeschlossen ist:

gpg: key ... marked as ultimately trusted
gpg: revocation certificate stored as '/home/labex/.gnupg/openpgp-revocs.d/....rev'
public and secret key created and signed.

pub   rsa3072 2023-10-27 [SC]
      ...
uid           [ultimate] LabEx User <[email protected]>
sub   rsa3072 2023-10-27 [E]

Die Ausgabe zeigt Informationen über Ihren neu generierten Schlüssel, einschließlich des Schlüsseltyps (rsa3072), des Erstellungsdatums, der Schlüssel-ID (...) und der von Ihnen angegebenen Benutzer-ID (LabEx User <[email protected]>). Die Zeile pub bezieht sich auf den öffentlichen Schlüssel, und die Zeile sub bezieht sich auf den Sub-Schlüssel (verwendet zur Verschlüsselung).

Sie haben nun erfolgreich ein GPG-Schlüsselpaar generiert und Ihren privaten Schlüssel mit einem Passwort geschützt.

Überprüfung der generierten öffentlichen Schlüsseldatei

In den vorherigen Schritten haben Sie erfolgreich ein GPG-Schlüsselpaar generiert. Jetzt überprüfen wir, ob der öffentliche Schlüssel korrekt generiert wurde und verfügbar ist. Der öffentliche Schlüssel ist derjenige, den Sie anderen Personen teilen werden, damit sie Ihre Signaturen überprüfen oder Nachrichten für Sie verschlüsseln können.

Um die öffentlichen Schlüssel in Ihrem Schlüsselbund aufzulisten, verwenden Sie den Befehl gpg --list-keys. Da Sie während der Schlüsselgenerierung "LabEx User" als Namen angegeben haben, können Sie die Ausgabe filtern, um nur Ihren Schlüssel anzuzeigen.

gpg --list-keys "LabEx User"

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die das Vorhandensein Ihres öffentlichen Schlüssels bestätigt:

pub   rsa3072 2023-10-27 [SC]
      ...
uid           [ultimate] LabEx User <[email protected]>
sub   rsa3072 2023-10-27 [E]

Diese Ausgabe zeigt die Details Ihres öffentlichen Schlüssels, einschließlich des Schlüsseltyps (pub), des Algorithmus (rsa3072), des Erstellungsdatums (2023-10-27), der Fähigkeiten ([SC] für Signieren und Zertifizieren), der Schlüssel-ID (...), der Benutzer-ID (LabEx User <[email protected]>) und Informationen über den Verschlüsselungssub-Schlüssel (sub).

Um Ihren öffentlichen Schlüssel in eine Datei zu exportieren, können Sie den Befehl gpg --output <Dateiname> --armor --export <Benutzer-ID> verwenden. Die Option --armor gibt den Schlüssel im ASCII-armor-Format aus, einem menschenlesbaren Textformat. Exportieren wir den öffentlichen Schlüssel für "LabEx User" in eine Datei namens labex_user_public.key in Ihrem aktuellen Verzeichnis (~/project).

gpg --output labex_user_public.key --armor --export "LabEx User"

Dieser Befehl erstellt eine Datei namens labex_user_public.key in Ihrem ~/project-Verzeichnis, die Ihren öffentlichen Schlüssel enthält.

Sie können den Inhalt dieser Datei mit dem cat-Befehl anzeigen:

cat labex_user_public.key

Die Ausgabe zeigt den ASCII-armor-öffentlichen Schlüsselblock, beginnend mit -----BEGIN PGP PUBLIC KEY BLOCK----- und endend mit -----END PGP PUBLIC KEY BLOCK-----.

-----BEGIN PGP PUBLIC KEY BLOCK-----

... (Ihr öffentlicher Schlüsselinhalt) ...

-----END PGP PUBLIC KEY BLOCK-----

Dies bestätigt, dass Ihr öffentlicher Schlüssel erfolgreich in eine Datei exportiert wurde. Sie können nun diese Datei mit anderen Personen teilen, die Ihre Signaturen überprüfen oder Daten für Sie verschlüsseln müssen.

Generieren eines Schlüsselpaars in einem angegebenen Verzeichnis

In den vorherigen Schritten haben Sie ein GPG-Schlüsselpaar generiert, das im Standard-GPG-Homedir (~/.gnupg) gespeichert wurde. Manchmal möchten Sie möglicherweise Schlüssel generieren und an einem anderen Ort speichern, vielleicht für bestimmte Projekte oder um sie von Ihrem Haupt-Schlüsselbund zu trennen.

In diesem Schritt erfahren Sie, wie Sie ein GPG-Schlüsselpaar generieren und ein anderes Verzeichnis angeben, in dem die Schlüsseldateien gespeichert werden sollen.

Zunächst erstellen wir ein neues Verzeichnis, in dem wir das neue Schlüsselpaar speichern werden. Wir erstellen ein Verzeichnis namens mykeys im ~/project-Verzeichnis.

mkdir ~/project/mykeys

Um nun ein Schlüsselpaar zu generieren und es im ~/project/mykeys-Verzeichnis zu speichern, müssen Sie die Option --homedir mit dem gpg-Befehl verwenden. Diese Option teilt GPG mit, dass es das angegebene Verzeichnis anstelle des Standardverzeichnisses als Homedir verwenden soll.

Verwenden Sie den folgenden Befehl, um den Schlüsselgenerierungsprozess zu starten und das ~/project/mykeys-Verzeichnis anzugeben:

gpg --homedir ~/project/mykeys --full-generate-key

Sie werden durch den gleichen Schlüsselgenerierungsprozess wie in Schritt 1 und Schritt 2 geführt.

  1. Wählen Sie die Art des Schlüssels: Wählen Sie die Standardeinstellung RSA and RSA aus, indem Sie Enter drücken.
  2. Welche Schlüssellänge möchten Sie? Wählen Sie die Standardeinstellung 3072 aus, indem Sie Enter drücken.
  3. Wie lange ist der Schlüssel gültig? Geben Sie 1y für ein Jahr ein und drücken Sie Enter.
  4. Ist das korrekt? Geben Sie y ein und drücken Sie Enter.
  5. Echter Name: Geben Sie Project User ein und drücken Sie Enter.
  6. E-Mail-Adresse: Geben Sie [email protected] ein und drücken Sie Enter.
  7. Kommentar: Lassen Sie das Feld leer, indem Sie Enter drücken.
  8. (N)amen, (C)ommentar, (E)Mail ändern oder (O)kay/(Q)uit? Geben Sie O ein und drücken Sie Enter.
  9. Passwort eingeben: Geben Sie ein Passwort ein (z.B. projectpassphrase456) und drücken Sie Enter.
  10. Passwort wiederholen: Geben Sie das gleiche Passwort (projectpassphrase456) erneut ein und drücken Sie Enter.

Nachdem Sie diese Schritte abgeschlossen haben, wird GPG das Schlüsselpaar generieren und die erforderlichen Dateien im ~/project/mykeys-Verzeichnis speichern.

Sie können überprüfen, ob der Schlüssel im angegebenen Verzeichnis generiert wurde, indem Sie die Schlüssel in diesem Homedir auflisten:

gpg --homedir ~/project/mykeys --list-keys "Project User"

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die den von Ihnen gerade generierten Schlüssel anzeigt:

gpg: directory '/home/labex/project/mykeys' created
gpg: keybox '/home/labex/project/mykeys/pubring.kbx' created
pub   rsa3072 2023-10-27 [SC]
      ...
uid           [ultimate] Project User <[email protected]>
sub   rsa3072 2023-10-27 [E]

Beachten Sie die Zeilen, die darauf hinweisen, dass das GPG-Verzeichnis und die Schlüsselbox im ~/project/mykeys-Verzeichnis erstellt wurden. Dies bestätigt, dass der Schlüssel am angegebenen Ort generiert wurde.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie ein neues Signierschlüsselpaar mit dem gpg-Befehl generieren. Dieser Prozess umfasst die Auswahl des Schlüsseltyps (Standardmäßig RSA und RSA), die Angabe der Schlüssellänge (Standardmäßig 3072 Bits) und die Festlegung der Gültigkeitsdauer des Schlüssels (in diesem Lab auf ein Jahr festgelegt). Sie haben auch gelernt, wie Sie ein Passwort für den neuen Schlüssel eingeben und bestätigen, um den privaten Schlüssel zu schützen. Schließlich haben Sie die generierte öffentliche Schlüsseldatei überprüft und das Generieren eines Schlüsselpaars in einem angegebenen Verzeichnis untersucht. Dabei haben Sie die grundlegenden Konzepte von privaten und öffentlichen Schlüsseln für sichere Kommunikation und Softwareverteilung verstanden.