Einführung
In diesem Lab erlernen Sie die grundlegenden Fähigkeiten, um Dateien in einer Linux-Umgebung mit GPG (GNU Privacy Guard) zu verschlüsseln und zu entschlüsseln. Sie beginnen mit der Erstellung Ihres eigenen Paares aus öffentlichem und privatem Schlüssel, das die Basis des GPG-Sicherheitsmodells bildet. Nach der Schlüsselerstellung üben Sie die Kernoperationen: das Verschlüsseln einer Datei für sich selbst und das anschließende Entschlüsseln mithilfe Ihres geheimen Schlüssels und Ihrer Passphrase.
Auf diesen Grundlagen aufbauend erfahren Sie, wie Sie Informationen sicher mit anderen austauschen können. Dies umfasst den Export Ihres öffentlichen Schlüssels zur Weitergabe sowie den Import des öffentlichen Schlüssels eines anderen Benutzers. Sie lernen zudem, wie Sie einen öffentlichen Schlüssel signieren, um dessen Authentizität zu verifizieren, und führen wichtige Wartungsaufgaben durch, wie etwa das Sichern Ihres geheimen Schlüssels und das Erstellen eines Widerrufszertifikats für den Fall, dass Ihr Schlüssel kompromittiert wird.
GPG-Schlüsselpaar mit gpg --gen-key erstellen
In diesem Schritt erstellen Sie Ihr persönliches GPG-Schlüsselpaar (GNU Privacy Guard). Ein GPG-Schlüsselpaar besteht aus zwei unterschiedlichen, aber zusammengehörigen Schlüsseln: einem öffentlichen und einem privaten Schlüssel. 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 geheim halten, da nur dieser Dateien entschlüsseln kann, 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
Nun sind Sie bereit, Ihr Schlüsselpaar zu erstellen. 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 einen Hinweis, dass dieser Befehl eine vereinfachte Schlüsselerstellung verwendet. Für fortgeschrittene Optionen können Sie gpg --full-generate-key nutzen, aber die Standardeinstellungen sind für dieses Lab ausreichend.
Sie werden nach folgenden Informationen gefragt:
- Real name: Geben Sie
labexein. - Email address: Geben Sie
labex@example.comein. - Confirm User ID: Überprüfen Sie Ihre Angaben. Wenn Sie zur Eingabe
Change (N)ame, (E)mail, or (O)kay/(Q)uit?aufgefordert werden, geben SieOein und drücken SieEnter.
Das System verwendet automatisch sichere Standardwerte:
- Key type: RSA and RSA (Standard)
- Key size: 3072 bits (sicherer Standard)
- Key validity: 2 Jahre (automatische Ablaufzeit aus Sicherheitsgründen)
Hinweis: Im Gegensatz zu älteren Versionen fragt modernes GPG bei der Erstellung mit --gen-key möglicherweise nicht 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 wie folgt tun:
gpg --edit-key labex
Geben Sie dann am GPG-Prompt passwd ein, um eine Passphrase festzulegen, und anschließend save, um das Programm 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, die in etwa so aussieht:
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 erstellt 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 gerade 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):
/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 verifiziert.
Lokale Datei mit gpg -e und gpg --decrypt verschlüsseln und entschlüsseln
In diesem Schritt verwenden Sie das erstellte GPG-Schlüsselpaar, um eine Datei zu verschlüsseln und anschließend wieder zu entschlüsseln. Dies ist ein grundlegender Anwendungsfall für GPG, mit dem Sie die Vertraulichkeit Ihrer Daten schützen können. Die Verschlüsselung wandelt Ihre lesbaren Daten in ein unlesbares Format um, und nur jemand mit dem korrekten privaten Schlüssel kann sie wieder in ihre ursprüngliche Form zurückversetzen.
Erstellen Sie 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 zudem den Empfänger der verschlüsselten Nachricht mit dem Flag -r angeben, was dem Namen Ihres GPG-Schlüssels (labex) entsprechen sollte.
gpg -e -r labex mytestfile.txt
GPG verwendet Ihren öffentlichen Schlüssel zur Verschlüsselung der Datei. 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 zu sehen.
ls
Sie sollten mytestfile.txt.gpg neben der Originaldatei in der Ausgabe sehen.
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.
Lassen Sie uns die Datei nun entschlüsseln. Hierfür 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
Falls Ihr Schlüssel eine Passphrase hat, werden Sie aufgefordert, diese einzugeben. Wenn bei der Schlüsselerstellung keine Passphrase festgelegt wurde, erfolgt die Entschlüsselung automatisch. Sie sollten eine Ausgabe ähnlich dieser 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 diese mit Ihrem GPG-Schlüsselpaar wieder entschlüsselt.
Öffentliche Schlüssel mit gpg --export und gpg --import austauschen
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ötigt jemand, der Ihnen eine verschlüsselte Datei senden möchte, Ihren öffentlichen Schlüssel. Dieser Prozess beinhaltet den Export Ihres öffentlichen Schlüssels in eine Datei und den Import öffentlicher Schlüssel, die Sie von anderen erhalten, in Ihren GPG-Schlüsselbund.
Exportieren Sie zunächst Ihren eigenen öffentlichen Schlüssel. Sie verwenden dazu den Befehl gpg --export. Es ist bewährte Praxis, die Option --armor zu verwenden, die eine textbasierte (ASCII) Version des Schlüssels erstellt, was das Kopieren und Einfügen in E-Mails oder andere textbasierte Kommunikationskanäle erleichtert. 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üsselerstellung 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 an andere weitergeben 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 Lab erstellen wir ein temporäres Alice-Schlüsselpaar und exportieren dann Alices öffentlichen Schlüssel, um diesen Prozess zu simulieren.
Erstellen 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: alice@example.com
Expire-Date: 2y
%no-protection
%commit
EOF
Generieren Sie nun Alices Schlüsselpaar mithilfe der Parameterdatei:
gpg --batch --generate-key alice-key-params
Sie sollten eine Ausgabe sehen, die die Schlüsselerstellung 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 alice@example.com
Für diese Lab-Demonstration 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 alice@example.com
Bestätigen Sie das Löschen bei Aufforderung mit y und drücken Sie Enter.
gpg --delete-keys alice@example.com
Bestätigen Sie auch hier das Löschen mit y und drücken Sie Enter.
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üsselerstellung:
rm alice-key-params
Nachdem 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 <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 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).
/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 [ unknown] (unbekannt) als Vertrauenswürdigkeit markiert ist. Wie Sie das Vertrauen in Schlüssel 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 erhaltenen öffentlichen Schlüssel aufbauen und diesen dann verwenden, um eine Datei für dessen Besitzer zu verschlüsseln. Wenn Sie einen öffentlichen Schlüssel importieren, hat GPG keine Möglichkeit zu wissen, ob er authentisch ist. Indem Sie den Schlüssel mit Ihrem eigenen privaten Schlüssel "signieren", erstellen Sie eine kryptografische Bestätigung und sagen Ihrem GPG-System im Wesentlichen: "Ich vertraue darauf, dass dieser Schlüssel 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. Verwenden Sie dazu den Befehl gpg --sign-key und identifizieren Sie den Schlüssel über seine E-Mail-Adresse (alice@example.com).
gpg --sign-key alice@example.com
GPG zeigt die Details von Alices Schlüssel an und bittet Sie zu bestätigen, dass 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 <alice@example.com>
Really sign? (y/N)
Geben Sie y ein und drücken Sie Enter. Falls 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, falls Sie dazu aufgefordert werden, und drücken Sie Enter.
Sobald dies erledigt ist, können Sie die Signatur durch erneutes Auflisten der Schlüssel verifizieren.
gpg --list-keys
Beachten Sie die Änderung beim Eintrag für Alices Schlüssel. Nachdem Sie den importierten Schlüssel signiert haben, zeigt GPG ihn nicht mehr als [unknown] an. Abhängig vom Status Ihres lokalen Schlüsselbunds kann der Schlüssel nun mit einem stärkeren Gültigkeitsmarker wie [full] oder [ultimate] erscheinen.
/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 [full] Alice <alice@example.com>
sub rsa2048 2025-07-01 [E] [expires: 2027-07-01]
Wenn Sie die Signatur direkt bestätigen möchten, führen Sie aus:
gpg --list-sigs alice@example.com
Sie sollten eine Signaturzeile für labex <labex@example.com> sehen, die bestätigt, dass Ihr Schlüssel Alices importierten öffentlichen Schlüssel signiert hat.
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 anschließend mit dem Befehl gpg -e. Geben Sie dieses Mal Alice als Empfänger mit dem Flag -r an.
gpg -e -r alice@example.com message-for-alice.txt
GPG verwendet Alices öffentlichen Schlüssel für die Verschlüsselung. Verwenden Sie ls, um das Ergebnis zu sehen.
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: das Erstellen eines sicheren Backups Ihres geheimen Schlüssels und das Generieren eines Widerrufszertifikats. 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 Widerrufszertifikat ist Ihr Sicherheitsnetz, mit dem Sie Ihren öffentlichen Schlüssel für ungültig erklären können, falls Ihr geheimer Schlüssel jemals verloren geht oder kompromittiert wird.
Erstellen Sie 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 für diesen Zweck verwendet. Wir nutzen das Flag --armor, um eine ASCII-armierte Textdatei zu erstellen, die einfach zu speichern und zu transportieren ist. Sie müssen angeben, welcher Schlüssel exportiert werden soll (über die Benutzer-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 gelegenen Ort aufbewahren, wie etwa auf einem verschlüsselten USB-Stick oder in einem sicheren Tresor.
Als Nächstes erstellen Sie ein Widerrufszertifikat. Dies sollte unmittelbar nach der Schlüsselerstellung erfolgen und sicher aufbewahrt werden, getrennt von Ihrem Backup des geheimen Schlüssels. Falls 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 als vertrauenswürdig eingestuft 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:
- Wenn Sie gefragt werden
Create a revocation certificate for this key? (y/N), geben Sieyein und drücken SieEnter. - Sie werden aufgefordert, einen Grund für den Widerruf auszuwählen. Drücken Sie für dieses Lab einfach
Enter, um den Standard0 = No reason specifiedzu akzeptieren. - Sie können eine optionale Beschreibung hinzufügen. Drücken Sie vorerst einfach
Enter, um sie leer zu lassen. - Bestätigen Sie abschließend die Details mit
yund drücken SieEnter, wenn Sie gefragt werdenIs this okay? (y/N). - Falls Ihr Schlüssel eine Passphrase hat, wird GPG Sie zur Autorisierung der Erstellung dieses Zertifikats danach fragen. Geben Sie Ihre Passphrase ein, falls Sie dazu aufgefordert werden, und drücken Sie
Enter.
Sie sehen 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 den Befehl ls, um zu überprüfen, ob beide neuen Dateien in Ihrem ~/project-Verzeichnis erstellt wurden.
ls
Sie sollten nun gpgkey.asc und revoke.asc in der Dateiliste sehen. Sie haben erfolgreich wichtige Wartungsaufgaben für Ihre Schlüssel durchgeführt.
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, mithilfe des Befehls gpg --gen-key. Dieser Prozess umfasste die Auswahl von Schlüsselspezifikationen und die Erstellung einer Benutzer-ID, die durch eine sichere Passphrase geschützt ist. Nach der Schlüsselerstellung übten Sie die Kernfunktion von GPG, indem Sie eine lokale Datei mit gpg -e für sich selbst verschlüsselten und diese anschließend mit Ihrem privaten Schlüssel und dem Befehl gpg --decrypt wieder entschlüsselten, was die Grundprinzipien der asymmetrischen Verschlüsselung demonstriert.
Auf diesen Grundlagen aufbauend erkundeten Sie, wie Sie sicher mit anderen kommunizieren können. Sie lernten, öffentliche Schlüssel mit gpg --export auszutauschen, um Ihren Schlüssel weiterzugeben, und mit gpg --import den Schlüssel eines anderen Benutzers zu empfangen. Das Lab behandelte zudem 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. Abschließend führten Sie wichtige Wartungsaufgaben durch, einschließlich der Sicherung Ihres geheimen Schlüssels mit gpg --export-secret-keys und der Erstellung eines Widerrufszertifikats mit gpg --gen-revoke, um Ihr Schlüsselpaar im Falle einer Kompromittierung für ungültig zu erklären.
