GPG is een van die tools die iedereen “ooit moet leren” maar waar niemand zin in heeft. De documentatie is overweldigend, de terminologie verwarrend, en de error messages cryptisch (pun intended).

Maar GPG is ook onmisbaar. Het is de basis voor pass, voor signed git commits, voor versleutelde email, en voor het verifiëren van software downloads. Als je serieus bent over security, ontkom je er niet aan.

Dit is de gids die ik zelf had willen hebben toen ik begon.

Wat is GPG eigenlijk?

GPG (GNU Privacy Guard) is een implementatie van het OpenPGP protocol. Het doet twee dingen:

  1. Encryptie: Bestanden versleutelen zodat alleen de bedoelde ontvanger ze kan lezen
  2. Signing: Digitaal ondertekenen zodat anderen kunnen verifiëren dat iets van jou komt

Dit werkt met asymmetrische cryptografie: je hebt een public key (die je deelt) en een private key (die je geheim houdt).

  • Iemand wil jou een geheim sturen → versleutelt met jouw public key → alleen jij kunt ontsleutelen met je private key
  • Jij wilt bewijzen dat iets van jou komt → onderteken met je private key → anderen verifiëren met je public key

Dat is het. De rest is implementatiedetails.

In 5 minuten je eerste keypair

Installatie

# macOS
brew install gnupg

# Debian/Ubuntu
sudo apt install gnupg

# Arch
sudo pacman -S gnupg

Keypair genereren

gpg --full-generate-key

Je krijgt een paar vragen:

Please select what kind of key you want:
   (1) RSA and RSA
   (9) ECC (sign and encrypt)

Kies (1) RSA and RSA voor maximale compatibiliteit, of (9) ECC voor moderne, kortere keys.

What keysize do you want? (3072)

Kies 4096 voor RSA. Meer is beter (binnen redelijke grenzen).

Key is valid for? (0)

Kies 2y (2 jaar). Je kunt later verlengen. Een key zonder expiry is riskant — als je ’m verliest, is hij voor altijd geldig.

Real name: Tom Meurs
Email address: tom@example.com
Comment:

Vul je naam en email in. Comment mag leeg.

Enter passphrase:

Kies een sterke passphrase. Dit is de laatste verdedigingslinie als iemand je private key steelt.

Klaar. Je hebt nu een GPG keypair.

Keys bekijken

# Lijst je public keys
gpg --list-keys

# Lijst je private keys
gpg --list-secret-keys

Output ziet er zo uit:

pub   rsa4096 2026-01-26 [SC] [expires: 2028-01-26]
      ABC123DEF456GHI789JKL012MNO345PQR678STU9
uid           [ultimate] Tom Meurs <tom@example.com>
sub   rsa4096 2026-01-26 [E] [expires: 2028-01-26]

Die lange string is je key ID (fingerprint). De korte versie (laatste 16 karakters) wordt vaak gebruikt: MNO345PQR678STU9.

Direct bruikbaar: bestanden versleutelen

Versleutelen voor jezelf

# Versleutel een bestand
gpg --encrypt --recipient tom@example.com secret.txt
# Maakt secret.txt.gpg

# Ontsleutel
gpg --decrypt secret.txt.gpg > secret.txt

Versleutelen voor iemand anders

Eerst heb je hun public key nodig:

# Importeer een public key
gpg --import colleague-key.asc

# Of haal op van een keyserver
gpg --keyserver keyserver.ubuntu.com --recv-keys THEIR_KEY_ID

Dan versleutelen:

gpg --encrypt --recipient colleague@example.com secret.txt

Alleen zij kunnen het nu ontsleutelen.

Symmetrische encryptie (wachtwoord)

Geen keys nodig, gewoon een wachtwoord:

gpg --symmetric secret.txt
# Vraagt om wachtwoord, maakt secret.txt.gpg

Handig voor quick-and-dirty encryptie, maar minder veilig dan asymmetrisch.

Signing: bewijzen dat iets van jou komt

Een bestand ondertekenen

# Maak een losse signature
gpg --detach-sign document.pdf
# Maakt document.pdf.sig

# Of embed de signature
gpg --sign document.pdf
# Maakt document.pdf.gpg (signed + compressed)

# Of clearsign (leesbaar met signature erin)
gpg --clearsign message.txt
# Maakt message.txt.asc

Signature verifiëren

gpg --verify document.pdf.sig document.pdf

Output:

gpg: Signature made Mon Jan 26 12:00:00 2026 CET
gpg: using RSA key ABC123...
gpg: Good signature from "Tom Meurs <tom@example.com>"

Als je “BAD signature” ziet, is het bestand gewijzigd of de signature fake.

Git commits signen

Dit is misschien wel de meest praktische use case voor GPG.

Git configureren

# Vertel git welke key te gebruiken
git config --global user.signingkey YOUR_KEY_ID

# Automatisch alle commits signen
git config --global commit.gpgsign true

# Automatisch alle tags signen
git config --global tag.gpgsign true

Signed commit maken

git commit -S -m "This commit is signed"

GitHub/GitLab tonen een “Verified” badge bij signed commits.

Je public key aan GitHub toevoegen

# Exporteer je public key
gpg --armor --export tom@example.com

Kopieer de output (inclusief -----BEGIN PGP PUBLIC KEY BLOCK-----) en plak in GitHub → Settings → SSH and GPG keys → New GPG key.

Je public key delen

Exporteren

# Als ASCII (voor email, websites)
gpg --armor --export tom@example.com > tom-public.asc

# Als binary
gpg --export tom@example.com > tom-public.gpg

Naar een keyserver uploaden

gpg --keyserver keyserver.ubuntu.com --send-keys YOUR_KEY_ID

Nu kan iedereen je key vinden met:

gpg --keyserver keyserver.ubuntu.com --search-keys tom@example.com

Op je website zetten

Veel mensen zetten hun public key op example.com/.well-known/openpgpkey/ of gewoon example.com/pgp.asc.

Deep dive: subkeys

Tot nu toe heb je één keypair. Maar GPG ondersteunt subkeys: aparte keys die onder je master key hangen.

Waarom subkeys?

Je master key is heilig. Als die gecompromitteerd raakt, is alles verloren. Met subkeys:

  • Je master key blijft offline (cold storage)
  • Subkeys gebruik je dagelijks
  • Als een subkey lekt, revoke je alleen die subkey
  • Je identiteit (master key) blijft intact

Subkey structuur

Typische setup:

Master key [C] (certify) - offline bewaren
├── Subkey [S] (signing) - dagelijks gebruik
├── Subkey [E] (encryption) - dagelijks gebruik
└── Subkey [A] (authentication) - SSH login

Subkeys aanmaken

gpg --edit-key tom@example.com

In de GPG prompt:

gpg> addkey
Please select what kind of key you want:
   (4) RSA (sign only)
   (6) RSA (encrypt only)

# Maak een sign-only subkey
# Maak een encrypt-only subkey

gpg> save

Master key offline halen

Dit is waar het serieus wordt:

# Exporteer alles (backup!)
gpg --armor --export-secret-keys tom@example.com > master-backup.asc

# Exporteer alleen subkeys
gpg --armor --export-secret-subkeys tom@example.com > subkeys.asc

# Verwijder secret keys van je machine
gpg --delete-secret-keys tom@example.com

# Importeer alleen de subkeys
gpg --import subkeys.asc

Nu heb je alleen subkeys op je machine. De master key zit veilig op een USB stick in een kluis.

gpg --list-secret-keys
# sec#  rsa4096 ...  ← de # betekent: master key niet aanwezig

Hardware keys: YubiKey

De ultieme setup: je private keys op een hardware token.

Waarom?

  • Keys verlaten nooit de hardware
  • Malware kan je keys niet stelen
  • Fysieke beveiliging (je moet de YubiKey hebben)

Keys naar YubiKey verplaatsen

gpg --edit-key tom@example.com

gpg> key 1  # selecteer subkey
gpg> keytocard
Please select where to store the key:
   (1) Signature key
   (3) Authentication key

gpg> key 2  # selecteer volgende subkey
gpg> keytocard

gpg> save

Nu moet je de YubiKey aansluiten om te kunnen signen of decrypten.

GPG + SSH met YubiKey

Je kunt GPG authentication keys gebruiken voor SSH:

# In ~/.bashrc of ~/.zshrc
export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket)

# Enable SSH support in gpg-agent
echo "enable-ssh-support" >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent

Nu werkt ssh via je YubiKey. Eén hardware token voor GPG én SSH.

De nadelen van GPG

En hier wordt het eerlijk. GPG heeft serieuze problemen.

De UX is verschrikkelijk

GPG is ontworpen in de jaren ‘90 en het voelt zo. De command-line interface is inconsistent, de error messages zijn cryptisch, en simpele taken vereisen obscure flags.

gpg: decryption failed: No secret key
# Wat betekent dit? Key verlopen? Verkeerde key? Geen idee.

Er zijn GUI’s (Kleopatra, GPG Keychain), maar die zijn ook niet geweldig.

Key management is complex

  • Hoe backup je keys veilig?
  • Hoe roteer je keys zonder alles te breken?
  • Hoe revoke je een gecompromitteerde key zodat iedereen het weet?
  • Hoe deel je keys met mensen die GPG niet snappen?

Dit zijn opgeloste problemen, maar de oplossingen zijn niet intuïtief.

Web of Trust is effectief dood

Het originele PGP model was: mensen signen elkaars keys om vertrouwen op te bouwen. In de praktijk doet bijna niemand dit. De meeste mensen vertrouwen keys op basis van… hopen dat het klopt.

Keyservers zijn problematisch

Keyservers zijn:

  • Vaak traag of offline
  • Kunnen niet verifiëren of uploads legitiem zijn
  • Hebben in het verleden spam/abuse gehad
  • SKS keyserver network is grotendeels kapot

Alternatief: keys.openpgp.org verifieert email adressen.

Metadata lekt

GPG versleutelt de inhoud, maar niet:

  • Wie de ontvanger is (zichtbaar in encrypted blob)
  • Bestandsnaam en grootte
  • Wanneer het versleuteld is

Voor hoogrisico situaties is dit een probleem.

Email encryptie is grotendeels gefaald

PGP email (via Enigmail, etc.) heeft nooit mainstream adoptie bereikt. De setup is te complex, de UX te slecht, en alternatieven (Signal, encrypted messaging) zijn veel gebruiksvriendelijker.

Alternatieven bestaan

  • age: Moderne, simpele encryptie tool. Geen key management gedoe.
  • Signal: Voor messaging, veel betere UX.
  • Keybase: Was een poging om PGP gebruiksvriendelijk te maken (nu onderdeel van Zoom).

Wanneer GPG wél de juiste keuze is

Ondanks de nadelen is GPG nog steeds de beste optie voor:

  • Git commit signing: Geen goed alternatief
  • Password managers (pass): GPG is de standaard
  • Software signing: Package managers verwachten GPG signatures
  • Encrypted backups: Battle-tested, breed ondersteund
  • Interoperabiliteit: Iedereen met GPG kan je berichten lezen

Mijn setup

# ~/.gnupg/gpg.conf
default-key ABC123...
keyserver hkps://keys.openpgp.org
auto-key-retrieve

# Moderne crypto voorkeuren
personal-cipher-preferences AES256 AES192 AES
personal-digest-preferences SHA512 SHA384 SHA256
personal-compress-preferences ZLIB BZIP2 ZIP Uncompressed

Mijn master key zit op een air-gapped machine. Subkeys zitten op een YubiKey. Ik gebruik GPG primair voor:

  • Git commit signing
  • Pass (password manager)
  • Incidenteel bestanden versleutelen

Voor messaging gebruik ik Signal. Voor ad-hoc encryptie soms age.

Praktische tips

1. Backup je keys

# Nu. Voordat je het vergeet.
gpg --armor --export-secret-keys > ~/backup/gpg-secret-keys.asc
gpg --armor --export > ~/backup/gpg-public-keys.asc
gpg --export-ownertrust > ~/backup/gpg-ownertrust.txt

Zet dit op een encrypted USB stick. In een kluis. Serieus.

2. Zet een calendar reminder voor expiry

Keys verlopen. Als je niet op tijd verlengt, kun je je eigen bestanden niet meer ontsleutelen.

gpg --edit-key tom@example.com
gpg> expire
# Kies nieuwe datum
gpg> save

3. Gebruik een goede passphrase

Je passphrase beschermt je private key. Maak het lang, onvoorspelbaar, en gebruik een password manager om het op te slaan.

4. Verifieer fingerprints out-of-band

Als je iemands public key importeert, verifieer de fingerprint via een ander kanaal (telefoon, in persoon). Keyservers kunnen gehackt zijn.

Conclusie

GPG is krachtig maar complex. Het is de de-facto standaard voor asymmetrische cryptografie op de command line, maar de UX is een constante bron van frustratie.

Is het de moeite waard om te leren? Ja, als je:

  • Git commits wilt signen
  • Pass wilt gebruiken
  • Bestanden veilig wilt versleutelen
  • Software wilt verifiëren

Nee, als je:

  • Alleen veilig wilt chatten (gebruik Signal)
  • Eenvoudige file encryptie wilt (overweeg age)
  • Niet tegen CLI-frustratie kunt

Start simpel: genereer een key, sign je git commits, en bouw van daaruit op. Je hoeft niet meteen subkeys en YubiKeys te begrijpen. Dat komt later, als je er klaar voor bent.

GPG is als vim: een steile leercurve, maar als je eenmaal over de heuvel bent, wil je niet meer terug.

Resources: