TL;DR GPG versleutelt bestanden en ondertekent dingen, en het zit onder pass, onder signed git commits en onder de checksums die maintainers publiceren. Eén commando en je hebt in vijf minuten een werkend keypair. Subkeys en een YubiKey komen later, of nooit, en de UX is slecht genoeg dat ik er hieronder uitgebreid over klaag.
GPG is een tool die ik jarenlang wilde leren en niet deed. De docs zijn een muur van tekst, de terminologie is een dialect op zich, en de foutmeldingen zijn cryptisch in beide betekenissen van het woord.
Je loopt er toch tegenaan. GPG zit onder pass, onder signed git commits, onder versleutelde email, onder de check of de binary die je net downloadde wel de binary is die de maintainer heeft uitgebracht. Wil je je eigen security in eigen hand houden in plaats van ’m bij een vendor neerleggen, dan kom je hier vroeg of laat uit.
Dus dit is de gids die ik zelf had willen krijgen. Hij begint met het minste dat iets doet, en je mag stoppen met lezen zodra je genoeg hebt.
Wat GPG doet
GPG (GNU Privacy Guard) is een implementatie van het OpenPGP-protocol, en onder het jargon heeft het twee klussen. Het versleutelt een bestand zodat alleen de bedoelde ontvanger het kan lezen, en het ondertekent iets zodat anderen kunnen nagaan dat het van jou komt.
Allebei draaien ze op asymmetrische cryptografie. Je hebt een public key die je vrij uitdeelt en een private key die nooit uit je handen komt. Wil iemand jou een geheim sturen, dan versleutelt die het met jouw public key, en alleen jouw private key krijgt het weer open. Wil je bewijzen dat iets van jou is, dan onderteken je het met je private key en kan iedereen het nalopen met de public key.
Alles hieronder is flags en bestandsformaten bovenop die twee ideeën. Raak je de draad kwijt, kom dan even terug naar deze alinea.
In 5 minuten je eerste keypair
Eén commando, een handvol vragen, en je hebt werkende crypto. Geen subkeys, geen hardware, geen theorie. Krijg dit eerst werkend; alles daarna is optioneel.
Installatie
# macOS
brew install gnupg
# Debian/Ubuntu
sudo apt install gnupg
# Arch
sudo pacman -S gnupg
Keypair genereren
gpg --full-generate-key
Hij stelt je 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 de breedste compatibiliteit, of (9) ECC voor moderne, kortere keys. Bij twijfel RSA. Alles snapt het.
What keysize do you want? (3072)
4096 voor RSA. Groter mag hier best, binnen de rede.
Key is valid for? (0)
2y, dus 2 jaar. Verlengen kan later altijd. Een key zonder expiry voelt handig, tot de dag dat hij lekt, want dan blijft hij voor altijd geldig en beperkt niks de schade. Een expiry-datum is een failsafe die je één keer instelt.
Real name: Tom Meurs
Email address: tom@example.com
Comment:
Je naam en email. De comment laat je leeg.
Enter passphrase:
Kies hier een sterke passphrase. Krijgt iemand ooit je private-key-bestand te pakken, dan is deze passphrase het enige wat nog tussen die persoon en jouw identiteit staat.
Klaar. Je hebt een werkend GPG-keypair, en dat was het lastige deel van beginnen.
Keys bekijken
# Lijst je public keys
gpg --list-keys
# Lijst je private keys
gpg --list-secret-keys
De 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, de fingerprint. Mensen gebruiken vaak de korte versie, de laatste 16 tekens: MNO345PQR678STU9.
Een bestand versleutelen
Je hebt een key, dus laten we ’m gebruiken. Encryptie is het deel dat je het eerst voelt, dus dat komt eerst.
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 diens 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
Nu krijgt alleen die ander het open. Je hoefde nergens via een zijkanaal een gedeeld wachtwoord af te spreken, en daar is public key crypto nou precies voor bedacht.
Symmetrische encryptie met een wachtwoord
Soms wil je helemaal geen keys, alleen een wachtwoord:
gpg --symmetric secret.txt
# Vraagt om wachtwoord, maakt secret.txt.gpg
Handig voor een snelle eenmalige klus. Het is zwakker dan de asymmetrische route, want alles hangt aan één wachtwoord dat je moet onthouden en op de een of andere manier moet delen, dus ik pak het alleen als keys overdreven zouden zijn.
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>"
Zie je ooit “BAD signature”, dan is het bestand na het ondertekenen veranderd of hoort de signature bij een andere key. Hoe dan ook niet vertrouwen.
Git commits signen
Gebruik je GPG maar voor één ding, laat het dan dit zijn. Het is het stukje GPG dat ik elke dag aanraak zonder het te merken.
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 en GitLab zetten een “Verified”-badge naast signed commits. Die badge vertelt een reviewer dat de commit van jou kwam en niet vervalst is door iemand die user.email op jouw adres zette, wat iedereen kan.
Je public key aan GitHub toevoegen
# Exporteer je public key
gpg --armor --export tom@example.com
Kopieer de output, inclusief de regel -----BEGIN PGP PUBLIC KEY BLOCK-----, en plak ’m in GitHub onder Settings, dan SSH and GPG keys, dan New GPG key.
Je public key delen
Een signature heeft niemand iets aan zonder je public key, dus die moet de wereld in. Dat kan op een paar manieren, van “mail ’m” tot “zet ’m op een keyserver”.
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 vindt iedereen je key met:
gpg --keyserver keyserver.ubuntu.com --search-keys tom@example.com
Op je eigen website zetten
Veel mensen hosten hun public key op example.com/.well-known/openpgpkey/ of gewoon op example.com/pgp.asc. Zelf hosten betekent dat mensen ’m ophalen van infrastructuur die jij draait, en niet van een keyserver die iemand anders draait.
Subkeys, zodat de master key offline kan
Alles tot hier werkt met het ene keypair dat je aan het begin genereerde, en om te beginnen is dat prima. Ga je jaren op GPG leunen, dan zijn subkeys wat dat draaglijk maakt, dus lees dit ook als je het pas later opzet.
GPG ondersteunt subkeys, aparte keys die onder je master key hangen.
Waarom subkeys
Je master key is je identiteit. Raak je die kwijt aan een ander, dan ben je het ding kwijt dat bewijst dat jij jij bent, en een nette weg terug is er niet. Subkeys houden die key uit de vuurlinie. De master key staat offline, in cold storage. Subkeys doen het dagelijkse werk. Lekt een subkey, dan trek je die ene subkey in en ga je door, en de master key, je identiteit, blijft onaangeroerd.
Hetzelfde principe als backups offline houden of de rechten van een service account inperken. Maak de blast radius kleiner, dan neemt één misstap niet alles mee.
Subkey-structuur
Een typische opzet:
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
De master key offline halen
Deze stap vraagt wat lef, want je gaat bewust secret-key-materiaal van je dagelijkse machine verwijderen:
# 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
Je dagelijkse machine draagt nu alleen nog subkeys. De master key zit op een USB-stick in een la, of waar je ’m ook vertrouwt. Wordt de laptop gestolen of overgenomen, dan krijgt de aanvaller subkeys die je kunt intrekken, niet de key die jou definieert.
gpg --list-secret-keys
# sec# rsa4096 ... ← die # betekent dat de master key niet aanwezig is
De subkeys naar een YubiKey verhuizen
De meeste mensen hebben dit nooit nodig, en ik ga je er niet heen duwen. Maar wil je dat je private keys fysiek weigeren het apparaat te verlaten waar ze op staan, dan is een hardwaretoken de manier.
Wat de hardware je oplevert
De keys verlaten de hardware nooit, punt. Malware op je laptop kan niet kopiëren wat het niet kan lezen. En een aanvaller heeft de fysieke YubiKey in handen nodig, niet alleen een shell op je machine.
Keys naar de 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
Vanaf dan betekent signen of ontsleutelen dat je de YubiKey insteekt en aantikt. Een kleine pauze, elke keer, in ruil voor keys die niemand van je schijf kan kopiëren.
GPG + SSH met YubiKey
Er zit een bonus aan. Je GPG-authentication-subkey doet ook dienst als SSH-key.
# 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 authenticeert ssh via de YubiKey. Eén hardwaretoken voor GPG én SSH, precies het soort consolidatie waar ik blij van word.
De nadelen
Ik zou je iets aansmeren als ik hier stopte en deed alsof GPG een feest is om te gebruiken. Dat is het niet. Het is een krachtige tool met bekende problemen, en die hoor je te kennen voor je instapt.
De UX is slecht
GPG is ontworpen in de jaren ‘90 en dat zie je. De command-line interface is inconsistent, de foutmeldingen zijn cryptisch, en routineklussen zitten verstopt achter flags die je elke keer opnieuw opzoekt.
gpg: decryption failed: No secret key
# Wat betekent dit? Key verlopen? Verkeerde key? Geen idee.
Er zijn GUI’s zoals Kleopatra en GPG Keychain. Ze helpen een beetje. De onderliggende rariteit lossen ze niet op.
Keymanagement is complex
Hoe backup je keys veilig? Hoe roteer je ze zonder alles te breken? Hoe trek je een gecompromitteerde key in zodat iedereen het hoort? Hoe deel je keys met mensen die GPG niet snappen? Op alles is een antwoord, geen ervan ligt voor de hand, en je gaat zoeken op het slechtst denkbare moment, bijvoorbeeld als een key bijna verloopt.
Web of Trust is effectief dood
Het oorspronkelijke PGP-idee was dat mensen elkaars keys ondertekenen en zo een netwerk van vertrouwen bouwen dat je kunt nalopen. Bijna niemand doet dat nog. De meeste mensen importeren een key en vertrouwen ’m omdat de fingerprint er ongeveer goed uitzag, en dat is geen trust-model te noemen.
Keyservers zijn een rommeltje
De klassieke keyservers zijn vaak traag of offline, kunnen niet nagaan of een upload wel hoort bij wie het claimt, en hebben een geschiedenis van spam en misbruik. Het oude SKS-keyservernetwerk is inmiddels grotendeels kapot.
De betere optie is keys.openpgp.org, dat in elk geval controleert of jij het emailadres op de key beheert voordat het ’m uitserveert.
Metadata lekt
GPG versleutelt de inhoud en verder niks. De versleutelde blob verraadt nog steeds wie de ontvanger is, de oorspronkelijke bestandsnaam en grootte, en wanneer het versleuteld is. Is het bestaan van een gesprek net zo gevoelig als de inhoud, dan weegt dat gat zwaar.
Emailencryptie kwam nooit van de grond
PGP-email, via tools als Enigmail, heeft normale mensen nooit bereikt. De setup is te priegelig, de UX te ruw, en Signal loste hetzelfde probleem op met een fractie van de moeite. Ik versleutel m’n email niet dagelijks, en ik ga niet doen alsof.
Alternatieven bestaan, en dat is prima
age doet moderne, doodsimpele bestandsencryptie zonder keymanagement-ceremonie. Signal doet messaging met een UX die in een andere divisie speelt. Keybase was een serieuze poging om PGP vriendelijk te maken, en is nu van Zoom.
Wanneer GPG wél het juiste gereedschap is
Met dat alles op tafel blijft GPG voor een handvol klussen de beste optie. Git commit signing heeft geen serieuze concurrent. pass is op GPG gebouwd, dus een password manager in de terminal betekent GPG. Package managers verwachten GPG-signatures op software, dus je komt ze tegemoet. Voor versleutelde backups is het oud, saai en overal ondersteund, precies wat je van een backup wilt. En iedereen met GPG kan lezen wat je stuurt, zonder account of app.
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
M’n master key staat op een air-gapped machine en de subkeys zitten op een YubiKey. Dag in dag uit gebruik ik GPG voor drie dingen. Git commits signen, pass, en af en toe een bestand. Signal voor chatten, en age als ik wegwerp-encryptie wil. GPG hoeft niet alles te doen om de moeite van het bewaren waard te zijn.
Praktische tips
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 versleutelde USB-stick, ergens veilig, en doe het nu. Raak je de enige kopie van een private key kwijt, dan is er geen helpdesk om te bellen.
Zet een agendaherinnering voor de expiry
Keys verlopen, en dat is met opzet. Vergeet je op tijd te verlengen, dan sluit je jezelf buiten je eigen versleutelde bestanden.
gpg --edit-key tom@example.com
gpg> expire
# Kies nieuwe datum
gpg> save
Gebruik een goede passphrase
Je passphrase is het slot op je private key. Maak ’m lang en onvoorspelbaar, en laat een password manager ’m onthouden, zodat je niet in de verleiding komt iets te kiezen wat je uit je hoofd kunt typen.
Verifieer fingerprints out-of-band
Importeer je iemands public key, bevestig de fingerprint dan via een apart kanaal, een telefoontje of in persoon. Keyservers kunnen gecompromitteerd zijn. Een fingerprint die je zelf hebt gecheckt is meer waard dan een die een server je aanreikt.
Waar je mag stoppen
Eén commando, één keypair, werkende crypto in vijf minuten. Dat is nog steeds het fundament. Subkeys, hardwaretokens en keyservers zijn diepte die je toevoegt als je ze nodig hebt, en niet eerder.
Is GPG de moeite waard om te leren? Ja, als je git commits wilt signen, pass wilt gebruiken, bestanden netjes wilt versleutelen of software wilt verifiëren die je downloadt. Sla het over als je alleen veilig wilt chatten, want daar wint Signal, of triviale bestandsencryptie wilt, want daar is age vriendelijker. En verpesten CLI-papercuts je dag, stap dan met open ogen in.
Begin in het ondiepe. Genereer een key, zet signed git commits aan, en leef daar een tijdje mee. Subkeys en een YubiKey kunnen wachten tot de dag dat je ze wilt. Ik onderteken elke commit met een subkey op een YubiKey, en de flag voor een losse signature zoek ik nog steeds elke keer op.
Verder lezen:
- GnuPG documentatie
- OpenPGP Best Practices
- keys.openpgp.org - moderne keyserver met email verificatie
- age - simpel alternatief voor file encryptie