Dateien verschlüsseln und entschlüsseln mit GPG unter Linux | CompTIA Linux+

Einführung

In diesem Lab erwerben Sie die grundlegenden Fähigkeiten zum Verschlüsseln und Entschlüsseln von Dateien in einer Linux-Umgebung mittels GPG (GNU Privacy Guard). Sie beginnen mit der Erstellung Ihres eigenen öffentlichen und privaten Schlüsselpaars, dem Fundament des GPG-Sicherheitsmodells. Nach der Schlüsselgenerierung üben Sie die Kernoperationen: das Verschlüsseln einer Datei für sich selbst und das anschließende Entschlüsseln mit Ihrem geheimen Schlüssel und Ihrer Passphrase.

Auf diesen Grundlagen aufbauend erfahren Sie, wie Sie Informationen sicher mit anderen austauschen. Dies umfasst den Export Ihres öffentlichen Schlüssels zum Teilen sowie den Import öffentlicher Schlüssel anderer Benutzer. Sie lernen außerdem, wie Sie einen öffentlichen Schlüssel signieren, um dessen Authentizität zu bestätigen, und führen wichtige Wartungsaufgaben durch – etwa die Sicherung Ihres privaten Schlüssels und das Erstellen eines Widerrufszertifikats für den Fall, dass Ihr Schlüssel jemals kompromittiert wird.

GPG-Schlüsselpaar generieren mit gpg --gen-key

In diesem Schritt erstellen Sie Ihr persönliches GPG-Schlüsselpaar (GNU Privacy Guard). Ein GPG-Schlüsselpaar besteht aus zwei unterschiedlichen, aber miteinander verknüpften Schlüsseln: einem öffentlichen Schlüssel (Public Key) und einem privaten Schlüssel (Private Key). Ihren öffentlichen Schlüssel können Sie an andere weitergeben, damit diese Dateien für Sie verschlüsseln können. Ihren privaten Schlüssel müssen Sie unbedingt 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, welches die GPG-Funktionalität bereitstellt, auf Ihrem System installiert ist.

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

Jetzt können Sie Ihr Schlüsselpaar 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 erhalten den Hinweis, dass dieser Befehl eine vereinfachte Schlüsselgenerierung nutzt. Für fortgeschrittene Optionen könnten Sie gpg --full-generate-key verwenden, aber die Standardoptionen sind für dieses Lab völlig ausreichend.

Sie werden nach den folgenden Informationen gefragt:

Real name: Geben Sie labex ein.
Email address: Geben Sie labex@example.com ein.
Confirm User ID: Überprüfen Sie Ihre Angaben. Wenn die Abfrage Change (N)ame, (E)mail, or (O)kay/(Q)uit? erscheint, tippen Sie O und drücken Sie Enter.

Das System verwendet automatisch sichere Standardwerte:

Schlüsseltyp: RSA und RSA (Standard)
Schlüsselgröße: 3072 Bit (sicherer Standardwert)
Gültigkeit: 2 Jahre (automatischer Ablauf aus Sicherheitsgründen)

Hinweis: Im Gegensatz zu älteren Versionen fragt das moderne GPG bei der Verwendung von --gen-key eventuell nicht sofort nach einer Passphrase. Wenn Sie Ihrem Schlüssel für zusätzliche Sicherheit eine Passphrase hinzufügen möchten, können Sie dies später mit folgendem Befehl tun:

gpg --edit-key labex

Geben Sie dann passwd am GPG-Prompt ein, um ein Passwort festzulegen, und danach save, um den Vorgang zu beenden.

Das System generiert nun Ihr Schlüsselpaar. Dieser Prozess benötigt Zufallsdaten (Entropie) und kann einen Moment dauern.

Nach Abschluss 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 <labex@example.com>
sub   rsa3072 2025-07-01 [E] [expires: 2027-07-01]

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

gpg --list-keys

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

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT>
uid           [ultimate] labex <labex@example.com>
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, zeigt jedoch einen geheimen Schlüssel (sec) anstelle eines öffentlichen Schlüssels (pub) an:

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

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

Lokale Datei verschlüsseln und entschlüsseln mit gpg -e und gpg --decrypt

In diesem Schritt verwenden Sie das generierte GPG-Schlüsselpaar, um eine Datei zu verschlüsseln und anschließend wieder zu entschlüsseln. Dies ist ein grundlegender Anwendungsfall für GPG, um die Vertraulichkeit Ihrer Daten zu schützen. Die Verschlüsselung wandelt Ihre lesbaren Daten in ein unleserliches Format um, und nur jemand mit dem korrekten privaten Schlüssel kann sie wieder in die ursprüngliche Form zurückführen.

Erstellen wir zunächst eine einfache Textdatei, mit der wir arbeiten können. Alle Operationen werden in Ihrem aktuellen Verzeichnis ~/project durchgefü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 außerdem den Empfänger der verschlüsselten Nachricht mit dem Flag -r angeben, was in diesem Fall der Name Ihres GPG-Schlüssels (labex) ist.

gpg -e -r labex mytestfile.txt

GPG verwendet Ihren öffentlichen Schlüssel zur Verschlüsselung. 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 ls, um die neue verschlüsselte Datei zu sehen.

ls

Sie sollten mytestfile.txt.gpg in der Ausgabe sehen, zusammen mit 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 nur unleserliche Binärdaten.

Lassen Sie uns nun die Datei entschlüsseln. Dazu verwenden Sie den Befehl gpg --decrypt. Da Sie entschlüsseln, greift GPG auf Ihren privaten Schlüssel zu.

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

Falls Ihr Schlüssel eine Passphrase hat, werden Sie nun aufgefordert, diese einzugeben. Wenn bei der Schlüsselgenerierung kein Passwort festgelegt wurde, erfolgt die Entschlüsselung automatisch. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

gpg: encrypted with 3072-bit RSA key, ID <KEY_ID>, created 2025-07-01
      "labex <labex@example.com>"

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 anschließend mit Ihrem GPG-Schlüsselpaar wieder entschlüsselt.

Öffentliche Schlüssel austauschen 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. Umgekehrt benötigt jemand anderes Ihren öffentlichen Schlüssel, wenn er Ihnen eine verschlüsselte Datei senden möchte. Dieser Prozess beinhaltet den Export Ihres öffentlichen Schlüssels in eine Datei und den Import fremder öffentlicher Schlüssel in Ihren GPG-Schlüsselbund.

Exportieren wir zunächst Ihren eigenen öffentlichen Schlüssel. Dazu verwenden Sie den Befehl gpg --export. Es ist bewährte Praxis, die Option --armor zu verwenden. Diese erstellt eine textbasierte (ASCII) Version des Schlüssels, die sich leicht kopieren und in E-Mails oder andere Textkanäle 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 Benutzer-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 sich den Inhalt auch ansehen:

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 wir 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 Schlüssel über einen sicheren Kanal erhalten. Für dieses Lab erstellen wir ein temporäres Schlüsselpaar für "Alice" und exportieren ihren öffentlichen Schlüssel, um diesen Vorgang nachzustellen.

Zuerst generieren wir temporär ein Schlüsselpaar für Alice im Batch-Modus, um interaktive Abfragen zu vermeiden:

cat > alice-key-params << 'EOF'
Key-Type: RSA
Key-Length: 2048
Subkey-Type: RSA
Subkey-Length: 2048
Name-Real: Alice
Name-Email: alice@example.com
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 Bestätigung der Schlüsselgenerierung sehen:

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, so wie Sie ihn von ihr erhalten würden:

gpg --export --armor -o alice.pub alice@example.com

Für diese Demonstration entfernen wir Alices privaten Schlüssel wieder aus Ihrem Schlüsselbund, da Sie in der Realität nur ihren öffentlichen Schlüssel besitzen würden:

gpg --delete-secret-keys alice@example.com

Bestätigen Sie das Löschen bei Aufforderung mit y und Enter.

gpg --delete-keys alice@example.com

Bestätigen Sie auch hier das Löschen mit y und Enter.

Nun haben Sie Alices öffentlichen Schlüssel in der Datei alice.pub vorliegen.

Löschen Sie die temporäre Parameterdatei:

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 Bestätigung über den Import sehen:

gpg: key <KEY_ID>: public key "Alice <alice@example.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1

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

gpg --list-keys

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

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_LABEX>
uid           [ultimate] labex <labex@example.com>
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 <alice@example.com>
sub   rsa2048 2025-07-01 [E] [expires: 2027-07-01]

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

Einen öffentlichen Schlüssel signieren und eine Datei für einen anderen Benutzer verschlüsseln

In diesem Schritt lernen Sie, wie Sie Vertrauen in einen empfangenen öffentlichen Schlüssel etablieren und diesen 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 wirklich echt ist. Indem Sie den Schlüssel mit Ihrem eigenen privaten Schlüssel "signieren", geben Sie eine kryptografische Empfehlung ab. Sie sagen Ihrem GPG-System damit: "Ich vertraue darauf, dass dieser Schlüssel wirklich dieser Person gehört." Dies ist ein Kernkonzept des GPG "Web of Trust"-Modells.

Zuerst müssen Sie den öffentlichen Schlüssel für "Alice" signieren, den Sie im vorherigen Schritt importiert haben. Verwenden Sie dazu den Befehl gpg --sign-key und identifizieren Sie den Schlüssel über die E-Mail-Adresse (alice@example.com).

gpg --sign-key alice@example.com

GPG zeigt die Details von Alices Schlüssel an und bittet Sie um Bestätigung.

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 <alice@example.com>

Really sign? (y/N)

Tippen Sie y und drücken Sie Enter. Falls Ihr Schlüssel eine Passphrase hat, werden Sie nun zur Eingabe aufgefordert. Das liegt daran, dass eine Signatur eine kryptografische Operation ist, die nur mit Ihrem geheimen Schlüssel durchgeführt werden kann. Geben Sie Ihr Passwort ein und bestätigen Sie mit Enter.

Anschließend können Sie die Signatur überprüfen, indem Sie die Schlüssel erneut auflisten.

gpg --list-keys

Beachten Sie die Änderung bei Alices Schlüssel. Der Vertrauensstatus ist nicht mehr [unknown]. Er zeigt nun [ultimate], da Sie ihm durch das Signieren explizit vertraut haben.

/home/labex/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2025-07-01 [SC] [expires: 2027-07-01]
      <FINGERPRINT_LABEX>
uid           [ultimate] labex <labex@example.com>
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 <alice@example.com>
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 zunächst eine neue Datei für diesen Zweck.

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

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

gpg -e -r alice@example.com message-for-alice.txt

GPG verwendet Alices öffentlichen Schlüssel für die Verschlüsselung. Prüfen Sie das Ergebnis mit ls.

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 deren Passphrase) kann die Nachricht entschlüsseln und lesen.

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

In diesem letzten Schritt führen Sie zwei kritische Wartungsaufgaben für Ihren GPG-Schlüssel durch: das Erstellen eines sicheren Backups Ihres privaten Schlüssels und das Generieren eines Widerrufszertifikats. Ihr privater 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 Widerrufszertifikat ist Ihr Sicherheitsnetz, mit dem Sie Ihren öffentlichen Schlüssel für ungültig erklären können, falls Ihr privater Schlüssel jemals verloren geht oder gestohlen wird.

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

Der Befehl gpg --export-secret-keys wird hierfür verwendet. Wir nutzen das Flag --armor, um eine ASCII-Textdatei zu erstellen, die sich leicht speichern lässt. Sie müssen angeben, welcher Schlüssel exportiert werden soll.

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 der Praxis würden Sie diese Datei an einem sehr sicheren, Offline-Ort aufbewahren, etwa auf einem verschlüsselten USB-Stick oder in einem Tresor.

Als Nächstes erstellen Sie ein Widerrufszertifikat (Revocation Certificate). Dies sollte unmittelbar nach der Schlüsselgenerierung erfolgen und getrennt vom Backup des privaten Schlüssels sicher aufbewahrt werden. Falls Sie Ihren privaten Schlüssel verlieren oder er kompromittiert wird, können Sie dieses Zertifikat veröffentlichen, um anderen mitzuteilen, dass der Schlüssel nicht mehr verwendet oder vertraut werden darf.

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:

Auf die Frage Create a revocation certificate for this key? (y/N) antworten Sie mit y und Enter.
Sie werden nach einem Grund für den Widerruf gefragt. Für dieses Lab drücken Sie einfach Enter, um den Standardwert 0 = No reason specified zu akzeptieren.
Sie können eine optionale Beschreibung hinzufügen. Drücken Sie vorerst einfach Enter, um das Feld leer zu lassen.
Bestätigen Sie die Angaben schließlich mit y und Enter bei der Abfrage Is this okay? (y/N).
Falls Ihr Schlüssel eine Passphrase hat, fragt GPG danach, um die Erstellung des Zertifikats zu autorisieren. Geben Sie das Passwort ein und drücken Sie Enter.

Sie erhalten eine Bestätigung, dass das Widerrufszertifikat 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 ls, um zu prüfen, ob beide neuen Dateien in Ihrem Verzeichnis ~/project vorhanden sind.

ls

Sie sollten nun gpgkey.asc und revoke.asc in der Liste sehen. Sie haben damit die essenziellen Wartungsaufgaben für Ihre Schlüssel erfolgreich abgeschlossen.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Operationen von GNU Privacy Guard (GPG) in einer Linux-Umgebung erlernt. Sie begannen mit der Erstellung eines persönlichen GPG-Schlüsselpaars, bestehend aus einem öffentlichen und einem privaten Schlüssel, mittels des Befehls gpg --gen-key. Dieser Prozess umfasste die Festlegung von Schlüsselspezifikationen und die Erstellung einer Benutzer-ID, die durch eine sichere Passphrase geschützt ist. Nach der Schlüsselgenerierung übten Sie die Kernfunktionen 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 wieder entschlüsselten, was die Grundprinzipien der asymmetrischen Verschlüsselung verdeutlichte.

Auf diesen Grundlagen aufbauend haben Sie gelernt, wie man sicher mit anderen kommuniziert. Sie erfuhren, wie man öffentliche Schlüssel mit gpg --export teilt und mit gpg --import Schlüssel anderer Benutzer empfängt. Das Lab behandelte zudem die Wichtigkeit der Vertrauensetablierung durch das Signieren importierter Schlüssel und deren Nutzung zur gezielten Verschlüsselung für andere Empfänger. Abschließend führten Sie essenzielle Wartungsaufgaben durch, darunter das Sichern Ihres privaten Schlüssels mit gpg --export-secret-keys und das Erstellen eines Widerrufszertifikats mit gpg --gen-revoke, um Ihr Schlüsselpaar im Falle einer Kompromittierung für ungültig erklären zu können.