Dateien mit GPG unter Linux verschlüsseln und entschlüsseln

LinuxLinuxBeginner
Jetzt üben

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

Einleitung

In diesem Labor lernen Sie die wesentlichen Fähigkeiten zur Verschlüsselung und Entschlüsselung von Dateien in einer Linux-Umgebung mit GPG (GNU Privacy Guard). Sie beginnen mit der Generierung Ihres eigenen öffentlichen/privaten Schlüsselpaares, der Grundlage des Sicherheitsmodells von GPG. Nach der Schlüsselgenerierung üben Sie die Kernoperationen der Verschlüsselung einer Datei für sich selbst und deren anschließende Entschlüsselung mit Ihrem geheimen Schlüssel und Ihrer Passphrase.

Aufbauend auf diesen Grundlagen erkunden Sie, wie Sie Informationen sicher mit anderen austauschen können. Dies beinhaltet den Export Ihres öffentlichen Schlüssels zum Teilen und den Import des öffentlichen Schlüssels eines anderen Benutzers. Sie lernen auch, wie Sie einen öffentlichen Schlüssel signieren, um seine Authentizität zu überprüfen, und führen wichtige Schlüsselwartungsaufgaben durch, wie z. B. die Sicherung Ihres geheimen Schlüssels und die Erstellung eines Widerrufszertifikats für den Fall, dass Ihr Schlüssel kompromittiert wird.

Generieren Ihres GPG-Schlüsselpaares mit gpg --gen-key

In diesem Schritt generieren Sie Ihr persönliches GPG (GNU Privacy Guard) Schlüsselpaar. Ein GPG-Schlüsselpaar besteht aus zwei unterschiedlichen, aber zusammenhängenden Schlüsseln: einem öffentlichen Schlüssel und einem privaten Schlüssel. Sie können Ihren öffentlichen Schlüssel mit anderen teilen, damit diese Dateien für Sie verschlüsseln können. Ihren privaten Schlüssel müssen Sie geheim halten, da er der einzige Schlüssel ist, mit dem Dateien entschlüsselt werden können, die mit Ihrem öffentlichen Schlüssel verschlüsselt wurden.

Stellen Sie zunächst sicher, dass das Paket gnupg, das die GPG-Funktionalität bereitstellt, auf Ihrem System installiert ist.

sudo apt-get update && sudo apt-get install -y gnupg

Nun sind Sie bereit, Ihr Schlüsselpaar zu generieren. Der Befehl gpg --gen-key führt Sie durch einen interaktiven Prozess.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

gpg --gen-key

Sie sehen eine Notiz, dass dieser Befehl eine vereinfachte Schlüsselgenerierung verwendet. Für erweiterte Optionen können Sie gpg --full-generate-key verwenden, aber die Standardoptionen sind für dieses Labor geeignet.

Sie werden nach den folgenden Informationen gefragt:

  1. Real name: Geben Sie labex ein.
  2. Email address: Geben Sie [email protected] ein.
  3. Confirm User ID: Überprüfen Sie Ihre Details. Wenn Sie gefragt werden Change (N)ame, (E)mail, or (O)kay/(Q)uit?, geben Sie O ein und drücken Sie Enter.

Das System verwendet automatisch sichere Standardeinstellungen:

  • Key type: RSA und RSA (Standard)
  • Key size: 3072 Bits (sicherer Standard)
  • Key validity: 2 Jahre (automatische Ablaufdatum aus Sicherheitsgründen)

Hinweis: Im Gegensatz zu älteren Versionen fragt modernes GPG möglicherweise nicht nach einer Passphrase während der Schlüsselgenerierung mit --gen-key. Wenn Sie Ihrer Schlüssel für zusätzliche Sicherheit eine Passphrase hinzufügen möchten, können Sie dies später tun mit:

gpg --edit-key labex

Geben Sie dann passwd an der GPG-Eingabeaufforderung ein, um eine Passphrase festzulegen, gefolgt von save, um zu beenden.

Das System generiert nun Ihr Schlüsselpaar. Dieser Prozess erfordert zufällige Daten (Entropie) und kann einige Momente dauern.

Sobald der Vorgang abgeschlossen ist, sehen Sie eine Bestätigungsmeldung ähnlich dieser:

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

pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid                      labex <[email protected]>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

Nachdem Ihre Schlüssel generiert wurden, können Sie sie anzeigen. Um Ihren neuen öffentlichen Schlüssel anzuzeigen, führen Sie aus:

gpg --list-keys

Die Ausgabe listet alle öffentlichen Schlüssel in Ihrem Schlüsselbund auf, einschließlich des gerade erstellten:

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid           [ultimate] labex <[email protected]>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

Um Ihren privaten Schlüssel anzuzeigen, führen Sie aus:

gpg --list-secret-keys

Die Ausgabe ist ähnlich, aber sie zeigt einen geheimen Schlüssel (sec) anstelle eines öffentlichen Schlüssels (pub):

/home/labex/.gnupg/pubring.kbx
------------------------------
sec   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid           [ultimate] labex <[email protected]>
ssb   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

Sie haben nun erfolgreich Ihr GPG-Schlüsselpaar erstellt und verifiziert.

Verschlüsseln und Entschlüsseln einer lokalen Datei mit gpg -e und gpg --decrypt

In diesem Schritt verwenden Sie das generierte GPG-Schlüsselpaar, um eine Datei zu verschlüsseln und dann zu entschlüsseln. Dies ist ein grundlegender Anwendungsfall für GPG, der es Ihnen ermöglicht, die Vertraulichkeit Ihrer Daten zu schützen. Verschlüsselung wandelt Ihre lesbaren Daten in ein unlesbares Format um, und nur jemand mit dem richtigen privaten Schlüssel kann sie wieder in ihre ursprüngliche Form entschlüsseln.

Erstellen wir zunächst eine einfache Textdatei, mit der wir arbeiten können. Alle Operationen werden in Ihrem aktuellen Verzeichnis, ~/project, ausgeführt.

echo "This is a secret message for the lab." > mytestfile.txt

Nun können Sie diese Datei mit Ihrem öffentlichen Schlüssel verschlüsseln. Der Befehl gpg -e wird für die Verschlüsselung verwendet. Sie müssen auch den Empfänger der verschlüsselten Nachricht mit dem Flag -r angeben, was der Name sein sollte, der mit Ihrem GPG-Schlüssel (labex) verbunden ist.

gpg -e -r labex mytestfile.txt

GPG verwendet Ihren öffentlichen Schlüssel, um die Datei zu verschlüsseln. Sie werden nicht nach Ihrer Passphrase gefragt, da die Verschlüsselung mit dem öffentlichen Schlüssel erfolgt, der nicht geheim ist.

Nachdem der Befehl abgeschlossen ist, verwenden Sie den Befehl ls, um die neue verschlüsselte Datei anzuzeigen.

ls

Sie sollten mytestfile.txt.gpg in der Ausgabe sehen, neben der Originaldatei.

mytestfile.txt  mytestfile.txt.gpg

Die Datei mytestfile.txt.gpg enthält die verschlüsselten Daten. Wenn Sie versuchen, ihren Inhalt anzuzeigen, sehen Sie unlesbare Binärdaten.

Nun lassen Sie uns die Datei entschlüsseln. Dazu verwenden Sie den Befehl gpg --decrypt. Da Sie entschlüsseln, verwendet GPG Ihren privaten Schlüssel.

Wir verwenden das Flag --output, um eine neue Datei für den entschlüsselten Inhalt anzugeben, mytestfile.txt.decrypted. Dies verhindert das Überschreiben der Originaldatei und macht deutlich, welche Datei welche ist.

gpg --output mytestfile.txt.decrypted --decrypt mytestfile.txt.gpg

Wenn Ihr Schlüssel eine Passphrase hat, werden Sie aufgefordert, diese einzugeben. Wenn während der Schlüsselgenerierung keine Passphrase festgelegt wurde, wird die Entschlüsselung automatisch fortgesetzt. Sie sollten eine Ausgabe ähnlich dieser sehen:

gpg: encrypted with 3072-bit RSA key, ID <KEY_ID>, created 2025-07-01
      "labex <[email protected]>"

Nach der Entschlüsselung können Sie den Inhalt der neuen Datei anzeigen, um zu bestätigen, dass er mit der ursprünglichen Nachricht übereinstimmt.

cat mytestfile.txt.decrypted

Die Ausgabe sollte der ursprüngliche Text sein, den Sie erstellt haben:

This is a secret message for the lab.

Sie haben erfolgreich eine Datei für sich selbst verschlüsselt und sie dann mit Ihrem GPG-Schlüsselpaar entschlüsselt.

Austausch von öffentlichen Schlüsseln mit gpg --export und gpg --import

In diesem Schritt lernen Sie, wie Sie öffentliche Schlüssel mit anderen austauschen. Um eine Datei für jemand anderen zu verschlüsseln, benötigen Sie dessen öffentlichen Schlüssel. Ebenso benötigen andere Ihren öffentlichen Schlüssel, wenn sie Ihnen eine verschlüsselte Datei senden möchten. Dieser Prozess beinhaltet den Export Ihres öffentlichen Schlüssels in eine Datei und den Import von öffentlichen Schlüsseln, die Sie von anderen erhalten, in Ihren GPG-Schlüsselbund.

Exportieren wir zunächst Ihren eigenen öffentlichen Schlüssel. Sie verwenden den Befehl gpg --export. Es ist bewährte Praxis, die Option --armor zu verwenden, die eine textbasierte (ASCII) Version des Schlüssels erstellt, wodurch er sich leicht in E-Mails oder andere textbasierte Kommunikationskanäle kopieren und einfügen lässt. Wir speichern ihn in einer Datei namens labex.pub.

Führen Sie in Ihrem Terminal den folgenden Befehl aus. Ersetzen Sie labex durch die Benutzerkennung (User ID), die Sie bei der Schlüsselgenerierung verwendet haben.

gpg --export --armor -o labex.pub labex

Sie können mit ls überprüfen, ob die Datei erstellt wurde:

ls

Sie sollten labex.pub in der Dateiliste sehen. Sie können auch den Inhalt anzeigen:

cat labex.pub

Die Ausgabe ist ein Textblock, der mit -----BEGIN PGP PUBLIC KEY BLOCK----- beginnt. Dies ist Ihr öffentlicher Schlüssel, den Sie nun mit anderen teilen können.

Als Nächstes simulieren Sie den Empfang eines öffentlichen Schlüssels von einem anderen Benutzer und dessen Import in Ihren Schlüsselbund. In einem realen Szenario würden Sie den öffentlichen Schlüssel von einer anderen Person über einen sicheren Kanal erhalten. Für dieses Labor erstellen wir ein temporäres Alice-Schlüsselpaar und exportieren dann Alices öffentlichen Schlüssel, um diesen Prozess zu simulieren.

Generieren wir zunächst temporär ein Schlüsselpaar für Alice. Wir verwenden einen Batch-Modus, um diesen Prozess ohne interaktive Abfragen zu automatisieren:

cat > alice-key-params << 'EOF'
Key-Type: RSA
Key-Length: 2048
Subkey-Type: RSA
Subkey-Length: 2048
Name-Real: Alice
Name-Email: [email protected]
Expire-Date: 2y
%no-protection
%commit
EOF

Generieren Sie nun Alices Schlüsselpaar mit der Parameterdatei:

gpg --batch --generate-key alice-key-params

Sie sollten eine Ausgabe sehen, die die Schlüsselgenerierung bestätigt:

gpg: key <KEY_ID> marked as ultimately trusted
public and secret key created and signed.

Exportieren Sie nun Alices öffentlichen Schlüssel in eine Datei, um zu simulieren, wie Sie ihn von Alice erhalten würden:

gpg --export --armor -o alice.pub [email protected]

Für diese Laborvorführung entfernen wir auch Alices geheimen Schlüssel aus dem Schlüsselbund, da Sie in der Realität nur ihren öffentlichen Schlüssel hätten:

gpg --delete-secret-keys [email protected]

Bestätigen Sie die Löschung, indem Sie y eingeben und Enter drücken, wenn Sie dazu aufgefordert werden.

gpg --delete-keys [email protected]

Bestätigen Sie die Löschung erneut, indem Sie y eingeben und Enter drücken.

Nun haben Sie Alices öffentlichen Schlüssel in der Datei alice.pub, was simuliert, wie Sie ihn von einem anderen Benutzer erhalten würden.

Bereinigen Sie die temporäre Datei zur Schlüsselgenerierung:

rm alice-key-params

Da Sie nun Alices öffentlichen Schlüssel in einer Datei haben, importieren Sie ihn mit dem Befehl gpg --import in Ihren GPG-Schlüsselbund.

gpg --import alice.pub

Sie sollten eine Ausgabe sehen, die den Import des Schlüssels bestätigt:

gpg: key <KEY_ID>: public key "Alice <[email protected]>" imported
gpg: Total number processed: 1
gpg:               imported: 1

Um zu bestätigen, dass Alices Schlüssel nun in Ihrem Schlüsselbund vorhanden ist, listen Sie erneut alle Ihre öffentlichen Schlüssel auf.

gpg --list-keys

Die Ausgabe zeigt nun sowohl Ihren Schlüssel (labex) als auch den neu importierten Schlüssel (Alice) an.

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_LABEX>
uid           [ultimate] labex <[email protected]>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

pub   rsa2048 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_ALICE>
uid           [ unknown] Alice <[email protected]>
sub   rsa2048 2025-07-01 [E] [expires: 2027-07-01]

Beachten Sie, dass Alices Schlüssel mit [ unknown] Vertrauen markiert ist. Wie Sie das Schlüsselvertrauen verwalten, erfahren Sie im nächsten Schritt.

Signieren eines öffentlichen Schlüssels und Verschlüsseln einer Datei für einen anderen Benutzer

In diesem Schritt lernen Sie, wie Sie einem erhaltenen öffentlichen Schlüssel vertrauen und ihn dann verwenden, um eine Datei für dessen Besitzer zu verschlüsseln. Wenn Sie einen öffentlichen Schlüssel importieren, kann GPG nicht wissen, ob er authentisch ist. Indem Sie den Schlüssel mit Ihrem eigenen privaten Schlüssel "signieren", erstellen Sie eine kryptografische Bestätigung, die Ihrer GPG-Konfiguration im Wesentlichen sagt: "Ich vertraue darauf, dass dieser Schlüssel zu dieser Person gehört." Dies ist ein grundlegendes Konzept im "Web of Trust"-Modell von GPG.

Zuerst müssen Sie den öffentlichen Schlüssel für "Alice" signieren, den Sie im vorherigen Schritt importiert haben. Sie verwenden den Befehl gpg --sign-key und identifizieren den Schlüssel anhand ihrer E-Mail-Adresse ([email protected]).

gpg --sign-key [email protected]

GPG zeigt die Details von Alices Schlüssel an und fragt Sie, ob Sie ihn signieren möchten.

pub  rsa2048/XXXXXXXXXXXXXXXX 2025-07-01
     created: 2025-07-01  expires: 2027-07-01  usage: SC
     trust: unknown       validity: unknown
sub  rsa2048/YYYYYYYYYYYYYYYY 2025-07-01
     created: 2025-07-01  expires: 2027-07-01  usage: E
[ unknown] (1). Alice <[email protected]>

Really sign? (y/N)

Geben Sie y ein und drücken Sie Enter. Wenn Ihr Schlüssel eine Passphrase hat, werden Sie aufgefordert, diese einzugeben. Dies liegt daran, dass eine Signatur eine kryptografische Operation ist, die nur mit Ihrem geheimen Schlüssel durchgeführt werden kann. Geben Sie Ihre Passphrase ein, wenn Sie dazu aufgefordert werden, und drücken Sie Enter.

Sobald dies erledigt ist, können Sie die Signatur überprüfen, indem Sie die Schlüssel erneut auflisten.

gpg --list-keys

Beachten Sie die Änderung im Eintrag für Alices Schlüssel. Die Vertrauensstufe ist nicht mehr [unknown]. Sie zeigt nun [ultimate] an, da Sie ihr durch Signieren explizit vertraut haben.

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_LABEX>
uid           [ultimate] labex <[email protected]>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

pub   rsa2048 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_ALICE>
uid           [ultimate] Alice <[email protected]>
sub   rsa2048 2025-07-01 [E] [expires: 2027-07-01]

Da Sie nun einen vertrauenswürdigen öffentlichen Schlüssel für Alice haben, können Sie eine Datei verschlüsseln, die nur sie öffnen kann. Erstellen Sie zuerst eine neue Datei für diesen Zweck.

echo "This is a confidential message for Alice." > message-for-alice.txt

Verschlüsseln Sie diese Datei als Nächstes mit dem Befehl gpg -e. Geben Sie diesmal Alice als Empfänger mit dem Flag -r an.

gpg -e -r [email protected] message-for-alice.txt

GPG verwendet Alices öffentlichen Schlüssel, um die Verschlüsselung durchzuführen. Verwenden Sie ls, um das Ergebnis anzuzeigen.

ls

Sie sehen die neue verschlüsselte Datei message-for-alice.txt.gpg in Ihrem Verzeichnis.

labex.pub                 mytestfile.txt
alice.pub                 mytestfile.txt.decrypted
message-for-alice.txt     mytestfile.txt.gpg
message-for-alice.txt.gpg

Diese Datei ist nun sicher verschlüsselt. Nur jemand mit Zugriff auf Alices privaten Schlüssel (und dessen Passphrase) kann die Nachricht entschlüsseln und lesen.

Schlüsselwartung mit gpg --export-secret-keys und gpg --gen-revoke durchführen

In diesem letzten Schritt führen Sie zwei kritische Wartungsaufgaben für Ihren GPG-Schlüssel durch: die Erstellung eines sicheren Backups Ihres geheimen Schlüssels und die Generierung eines Sperrzertifikats. Ihr geheimer Schlüssel ist unersetzlich; wenn Sie ihn verlieren, verlieren Sie den Zugriff auf alle Daten, die mit dem entsprechenden öffentlichen Schlüssel verschlüsselt wurden. Ein Sperrzertifikat ist Ihr Sicherheitsnetz, das es Ihnen ermöglicht, Ihren öffentlichen Schlüssel zu invalidieren, falls Ihr geheimer Schlüssel jemals verloren geht oder kompromittiert wird.

Erstellen wir zunächst ein Backup Ihres geheimen Schlüssels. Dies ist einer der wichtigsten Schritte bei der Verwaltung eines GPG-Schlüssels.

Der Befehl gpg --export-secret-keys wird zu diesem Zweck verwendet. Wir verwenden das Flag --armor, um eine ASCII-gepanzerte Textdatei zu erstellen, die einfach zu speichern und zu transportieren ist. Sie müssen angeben, welcher Schlüssel exportiert werden soll, anhand seiner Benutzerkennung (User ID).

gpg --export-secret-keys --armor -o gpgkey.asc labex

Dieser Befehl exportiert den geheimen Schlüssel für den Benutzer labex in eine Datei namens gpgkey.asc. Diese Datei ist extrem sensibel. In einem realen Szenario würden Sie diese Datei an einem sehr sicheren, offline gespeicherten Ort aufbewahren, z. B. auf einem verschlüsselten USB-Laufwerk oder in einem sicheren Tresor.

Als Nächstes erstellen Sie ein Sperrzertifikat. Dies sollte unmittelbar nach der Schlüsselgenerierung erfolgen und sicher, getrennt von Ihrem geheimen Schlüssel-Backup, aufbewahrt werden. Wenn Sie Ihren geheimen Schlüssel verlieren oder er gestohlen wird, können Sie dieses Zertifikat veröffentlichen, um andere darüber zu informieren, dass der Schlüssel nicht mehr verwendet oder vertraut werden sollte.

Verwenden Sie den Befehl gpg --gen-revoke. Wir speichern das Zertifikat mit dem Flag --output in einer Datei namens revoke.asc.

gpg --output revoke.asc --gen-revoke labex

Sie werden durch einen interaktiven Prozess geführt:

  1. Wenn Sie gefragt werden Create a revocation certificate for this key? (y/N), geben Sie y ein und drücken Sie Enter.
  2. Sie werden aufgefordert, einen Grund für die Sperrung auszuwählen. Für dieses Labor drücken Sie einfach Enter, um den Standardwert 0 = No reason specified zu akzeptieren.
  3. Sie können eine optionale Beschreibung hinzufügen. Drücken Sie vorerst einfach Enter, um sie leer zu lassen.
  4. Bestätigen Sie abschließend die Details, indem Sie y eingeben und Enter drücken, wenn Sie gefragt werden Is this okay? (y/N).
  5. Wenn Ihr Schlüssel eine Passphrase hat, wird GPG Sie nach dieser fragen, um die Erstellung dieses Zertifikats zu autorisieren. Geben Sie Ihre Passphrase ein, wenn Sie dazu aufgefordert werden, und drücken Sie Enter.

Sie sehen eine Bestätigung, dass das Sperrzertifikat erstellt wurde.

Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The printout
might be scanned and reconstructed by a determined attacker.

Verwenden Sie den Befehl ls, um zu überprüfen, ob beide neuen Dateien in Ihrem Verzeichnis ~/project erstellt wurden.

ls

Sie sollten nun gpgkey.asc und revoke.asc in der Dateiliste sehen. Sie haben erfolgreich wesentliche Schlüsselwartungsaufgaben durchgeführt.

Zusammenfassung

In diesem Labor haben Sie die grundlegenden Operationen von GNU Privacy Guard (GPG) in einer Linux-Umgebung kennengelernt. Sie begannen mit der Generierung eines persönlichen GPG-Schlüsselpaares, bestehend aus einem öffentlichen und einem privaten Schlüssel, mit dem Befehl gpg --gen-key. Dieser Prozess umfasste die Auswahl von Schlüsselspezifikationen und die Erstellung einer Benutzerkennung (User ID), die durch eine sichere Passphrase geschützt ist. Nach der Schlüsselgenerierung übten Sie die Kernfunktion von GPG, indem Sie eine lokale Datei für sich selbst mit gpg -e verschlüsselten und sie anschließend mit Ihrem privaten Schlüssel und dem Befehl gpg --decrypt entschlüsselten, was die grundlegenden Prinzipien der asymmetrischen Verschlüsselung demonstrierte.

Aufbauend auf diesen Grundlagen haben Sie untersucht, wie Sie sicher mit anderen kommunizieren können. Sie lernten den Austausch öffentlicher Schlüssel mit gpg --export, um Ihren Schlüssel zu teilen, und gpg --import, um den Schlüssel eines anderen Benutzers zu empfangen. Das Labor behandelte auch die Bedeutung des Vertrauensaufbaus durch das Signieren eines importierten öffentlichen Schlüssels und dessen anschließende Verwendung zur Verschlüsselung einer Datei speziell für diesen Benutzer. Schließlich führten Sie wichtige Schlüsselwartungsaufgaben durch, einschließlich der Sicherung Ihres geheimen Schlüssels mit gpg --export-secret-keys und der Erstellung eines Sperrzertifikats mit gpg --gen-revoke, um Ihr Schlüsselpaar zu invalidieren, falls es kompromittiert wird.