Vanlig e-post skickas i klartext. Varje mejl passerar din e-postleverantör, mottagarens leverantör och ett okänt antal mellanliggande servrar, och på vägen kan innehållet läsas, kopieras och lagras. PGP-kryptering löser det problemet genom att kryptera meddelandet så att bara mottagaren med rätt privat nyckel kan läsa det. Samma teknik signerar dina filer så att andra kan bevisa att de kommer från dig och inte har manipulerats.
Den här handledningen bygger ett komplett, fungerande krypteringsupplägg från grunden med GnuPG (GPG), den fria implementationen av OpenPGP-standarden. Du genererar ett nyckelpar, skapar ett återkallelsecertifikat, krypterar och signerar filer, ställer in krypterad e-post i Thunderbird, säkerhetskopierar dina nycklar och flyttar den privata nyckeln till en hårdvarunyckel. Allt görs i 12 steg och tar ungefär 40 minuter.
Guiden är skriven för GnuPG 2.4-serien (testad med 2.4.4 på Linux, macOS och Windows). Alla kommandon, utdataexempel och felsökningstips kommer från den versionen. Du behöver inga förkunskaper om kryptografi, men det hjälper att vara bekväm med en terminal. Vill du förstå matematiken bakom signaturerna kan du läsa vår genomgång av digitala signaturer parallellt.
Vad PGP och OpenPGP egentligen är
PGP står för Pretty Good Privacy och skapades av Phil Zimmermann 1991. Programmet i sig är gammalt, men begreppet lever vidare genom OpenPGP, det öppna meddelandeformat som beskriver hur krypterade och signerade meddelanden ska byggas. OpenPGP definierades först i RFC 4880 (2007) och uppdaterades i RFC 9580 (publicerad juli 2024), som moderniserar de tillåtna algoritmerna och inför en ny nyckelversion. När du i dag pratar om PGP-kryptering menar du nästan alltid OpenPGP i praktiken.
GnuPG, oftast förkortat GPG, är den mest använda implementationen av OpenPGP och är gratis och öppen källkod. Den finns på i stort sett alla Linux-distributioner, på macOS via GPG Suite och på Windows via Gpg4win. GnuPG sköter all kryptografi: nyckelhantering, kryptering, dekryptering, signering och verifiering. Den grafiska klienten Kleopatra (som följer med Gpg4win) är bara ett skal ovanpå samma motor.
PGP bygger på asymmetrisk kryptografi. Du har ett nyckelpar: en publik nyckel som du delar fritt, och en privat nyckel som aldrig lämnar din dator. Den som vill skicka något krypterat till dig använder din publika nyckel, och bara din privata nyckel kan låsa upp resultatet. När du signerar något använder du tvärtom din privata nyckel, och vem som helst kan verifiera signaturen med din publika nyckel. Samma asymmetri som driver HTTPS och TLS driver alltså PGP, men här styr du nycklarna helt själv.
I praktiken krypteras inte hela meddelandet med din publika nyckel. PGP genererar en slumpmässig symmetrisk sessionsnyckel (vanligen AES-256), krypterar meddelandet med den och krypterar sedan bara sessionsnyckeln med mottagarens publika nyckel. Det kallas hybridkryptering och är skälet till att PGP klarar stora filer snabbt. Signaturer bygger i sin tur på kryptografiska hashfunktioner: meddelandet hashas, och hashen signeras.
Förutsättningar och versioner
Innan du börjar behöver du rätt programvara installerad. Tabellen nedan listar exakt vad guiden använder och vilka versioner som testats. Håll dig till 2.4-serien av GnuPG eller senare. Äldre 1.4-versioner finns kvar på vissa system men saknar moderna algoritmer och bör inte användas för nya nycklar.
| Komponent | Version (testad) | Plattform | Syfte |
|---|---|---|---|
| GnuPG | 2.4.4 (2.4-serien) | Linux, macOS, Windows | Kärnan: nycklar, kryptering, signaturer |
| libgcrypt | 1.10.3 | Alla | Kryptografiskt bibliotek under GnuPG |
| Gpg4win | Senaste 4-serien | Windows | GnuPG + Kleopatra GUI |
| GPG Suite | Senaste versionen | macOS | GnuPG + nyckelhanterare |
| Thunderbird | 128 ESR eller senare | Alla | Inbyggt OpenPGP-stöd för e-post |
| YubiKey (valfritt) | 5-serien, firmware 5.2.3+ | USB/NFC | Hårdvarulagring av privat nyckel |
Du behöver också administratörsrättigheter för att installera programvara, en e-postadress som du kontrollerar och cirka 40 minuter ostörd tid. Skriv ner ett starkt lösenord för din privata nyckel innan du börjar, gärna med hjälp av en lösenordshanterare. Lösenordet skyddar nyckeln om filen hamnar i fel händer, så behandla det som vilket viktigt lösenord som helst. Vår guide om lösenordssäkerhet går igenom hur du väljer ett som håller.
Slutligen: gör det här på en dator du litar på och som är fri från skadlig kod. PGP skyddar meddelanden i transit och i vila, men om angriparen redan sitter på din maskin med en keylogger spelar krypteringen mindre roll. Håll operativsystemet uppdaterat och full diskkryptering påslagen.
Steg 1: Installera GnuPG på Linux, macOS och Windows
Installationen skiljer sig mellan plattformarna men slutar på samma ställe: ett fungerande gpg-kommando i terminalen. Välj raden för ditt system.
# Debian / Ubuntu
sudo apt update && sudo apt install gnupg
# Fedora
sudo dnf install gnupg2
# Arch Linux
sudo pacman -S gnupg
# macOS (Homebrew, eller ladda ner GPG Suite fran gpgtools.org)
brew install gnupg
# Windows: ladda ner och installera Gpg4win fran gpg4win.org
# Gpg4win innehaller GnuPG och Kleopatra (grafiskt granssnitt)Verifiera installationen direkt. Kommandot nedan ska skriva ut versionen och en lista över vilka algoritmer din GnuPG stöder. Får du fram 2.4.x är du redo. Visar systemet 1.4.x har du en gammal binär i sökvägen, och då bör du installera 2.4-serien och peka gpg mot den.
$ gpg --version
gpg (GnuPG) 2.4.4
libgcrypt 1.10.3
Copyright (C) 2024 g10 Code GmbH
...
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, ...
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2På Windows öppnar du Kleopatra efter installationen och bekräftar att programmet startar utan fel. De flesta steg i guiden går att klicka sig igenom i Kleopatra, men kommandoraden är identisk på alla plattformar och lättare att dokumentera, så vi håller oss till gpg i terminalen och pekar ut GUI-motsvarigheten där det är relevant.
Steg 2: Härda gpg.conf med säkra standardval
GnuPG fungerar direkt efter installation, men standardinställningarna är konservativa av kompatibilitetsskäl. Innan du skapar nycklar bör du sätta säkrare standardvärden i konfigurationsfilen. Den ligger i ~/.gnupg/gpg.conf på Linux och macOS, och i %APPDATA%\gnupg\gpg.conf på Windows. Skapa filen om den saknas.
# ~/.gnupg/gpg.conf
# Visa langa nyckel-ID och fullstandiga fingeravtryck
keyid-format 0xlong
with-fingerprint
# Foredra starka algoritmer nar nya nycklar skapas
personal-cipher-preferences AES256 AES192 AES
personal-digest-preferences SHA512 SHA384 SHA256
personal-compress-preferences ZLIB BZIP2 ZIP Uncompressed
default-preference-list SHA512 SHA384 SHA256 AES256 AES192 AES ZLIB BZIP2 ZIP Uncompressed
# Anvand SHA-512 for certifieringar i stallet for aldre SHA-1
cert-digest-algo SHA512
# Visa inte versionsstrang i utdata
no-emit-version
no-commentsRaden cert-digest-algo SHA512 är viktig. Äldre GnuPG kunde signera nyckelcertifieringar med SHA-1, och SHA-1 anses brutet sedan den första praktiska kollisionen demonstrerades. Vi har skrivit utförligt om varför i artikeln om SHAttered-kollisionen. Med raden ovan tvingar du fram SHA-512 i stället.
Starta om gpg-agenten så att ändringarna läses in, och bekräfta att konfigurationen tolkas utan fel:
$ gpgconf --kill gpg-agent
$ gpg --gpgconf-test && echo "gpg.conf OK"
gpg.conf OKFallgrop: en stavfel eller okänt direktiv i gpg.conf gör att GnuPG vägrar köra. Får du felet “invalid option” pekar meddelandet ut den rad som är fel. Kommentera ut raden med # och testa igen i stället för att gissa.
Steg 3: Generera ditt nyckelpar (RSA 4096 eller Ed25519)
Nu skapar du nyckelparet, hjärtat i hela uppsättningen. Du har två bra val av algoritm: RSA 4096 för maximal kompatibilitet med äldre mottagare, eller elliptisk kurva (Ed25519 för signering och Curve25519 för kryptering) för mindre, snabbare och lika säkra nycklar. För nya nycklar 2026 rekommenderar vi ECC om du vet att dina mottagare har moderna klienter, annars RSA 4096.
| Algoritm | Nyckelstorlek | Hastighet | Kompatibilitet | Rekommendation |
|---|---|---|---|---|
| RSA 2048 | 2048 bit | Snabb | Mycket bred | Undvik för nya nycklar |
| RSA 3072 | 3072 bit | Medel | Bred | Acceptabel miniminivå |
| RSA 4096 | 4096 bit | Långsammare | Bred | Bra om kompatibilitet krävs |
| Ed25519 / Cv25519 | 256 bit | Mycket snabb | Moderna klienter | Bäst för nya nycklar |
Använd det styrda läget med --full-generate-key så att du ser alla val. För ECC väljer du alternativet “ECC (sign and encrypt)” och kurvan Curve 25519. För RSA väljer du “RSA and RSA” och anger 4096 bitar. Sätt en utgångstid på ett till två år. Ett utgångsdatum är inte ett hot, eftersom du alltid kan förlänga det, men det skyddar dig om du tappar bort nyckeln utan att ha ett återkallelsecertifikat.
$ gpg --full-generate-key
Please select what kind of key you want:
(1) RSA and RSA
(9) ECC (sign and encrypt) *default*
...
Your selection? 9
Please select which elliptic curve you want:
(1) Curve 25519 *default*
Your selection? 1
Please specify how long the key should be valid.
Key is valid for? (0) 2y
Real name: Anna Andersson
Email address: [email protected]
Comment:
You selected this USER-ID:
"Anna Andersson <[email protected]>"
# Ange ett starkt losenord nar du blir tillfragad.
# GnuPG genererar nyckeln och skriver ut fingeravtrycket.När nyckeln är klar skriver GnuPG ut ett 40 tecken långt fingeravtryck. Det är den unika identiteten för din nyckel. Notera det. Du kommer att använda det varje gång någon ska verifiera att de har rätt nyckel från dig. Lista dina nycklar för att se resultatet:
$ gpg --list-secret-keys --keyid-format 0xlong
sec ed25519/0x9A7B3C2D1E4F5A6B 2026-06-13 [SC] [expires: 2028-06-12]
AB12CD34EF56AB78CD90EF12AB34CD56EF78AB90
uid [ultimate] Anna Andersson <[email protected]>
ssb cv25519/0x1122334455667788 2026-06-13 [E] [expires: 2028-06-12]Lägg märke till markeringarna [SC] och [E]. Huvudnyckeln kan signera och certifiera (S och C), medan undernyckeln (ssb) sköter kryptering (E). Den uppdelningen är medveten och blir viktig i steg 11 när vi flyttar undernycklar till en hårdvarunyckel.
Steg 4: Skapa ett återkallelsecertifikat direkt
Ett återkallelsecertifikat är din nödbroms. Om din privata nyckel läcker, om du glömmer lösenordet eller om du tappar bort nyckeln helt, är återkallelsecertifikatet det enda sättet att tala om för omvärlden att nyckeln inte längre ska litas på. Skapa det nu, medan du har tillgång till nyckeln, inte den dag det redan är för sent.
$ gpg --output anna-revoke.asc --gen-revoke 0x9A7B3C2D1E4F5A6B
Create a revocation certificate for this key? (y/N) y
Please select the reason for the revocation:
0 = No reason specified
1 = Key has been compromised
3 = Key is no longer used
Your decision? 0
Enter an optional description; end it with an empty line:
>
Reason for revocation: No reason specified
Is this okay? (y/N) y
# GnuPG skriver ut ett ASCII-armerat certifikat till anna-revoke.ascFallgrop: återkallelsecertifikatet är lika kraftfullt som det är farligt. Vem som helst som får tag i filen kan göra din nyckel oanvändbar. Spara den inte tillsammans med själva nyckeln. Lägg den på ett USB-minne i ett kassaskåp eller skriv ut den på papper. Behandla den som en reservnyckel till huset.
Flytta omedelbart certifikatet från din arbetskatalog till ett säkert ställe och ta bort den lokala kopian. På Linux och macOS sätter du dessutom strikta rättigheter på filen så att bara du kan läsa den:
$ chmod 600 anna-revoke.asc
$ mv anna-revoke.asc /media/usb-backup/
# Verifiera att den flyttats och inte ligger kvar lokalt
$ ls -l anna-revoke.asc
ls: cannot access 'anna-revoke.asc': No such file or directorySteg 5: Exportera och dela din publika nyckel
För att någon ska kunna skicka krypterad post till dig behöver de din publika nyckel. Den är gjord för att delas öppet, så det finns ingen risk i att sprida den. Exportera den i ASCII-armerat format (ändelsen .asc), som är ren text och går att klistra in i ett mejl eller lägga på en webbsida.
$ gpg --armor --export [email protected] > anna-public.asc
$ head -3 anna-public.asc
-----BEGIN PGP PUBLIC KEY BLOCK-----
mDMEZ...Det finns tre vanliga sätt att distribuera nyckeln. Det första är att skicka .asc-filen direkt. Det andra är att ladda upp den till en nyckelserver. Den moderna, rekommenderade servern är keys.openpgp.org, som till skillnad från de gamla SKS-servrarna verifierar e-postadressen innan den publicerar nyckeln knuten till adressen, vilket stoppar att vem som helst laddar upp en nyckel i ditt namn.
# Ladda upp till den verifierande nyckelservern
$ gpg --keyserver keys.openpgp.org --send-keys 0x9A7B3C2D1E4F5A6B
gpg: sending key 0x9A7B3C2D1E4F5A6B to hkps://keys.openpgp.org
# Du far ett bekraftelsemejl. Klicka pa lanken for att publicera
# kopplingen mellan din e-postadress och nyckeln.Det tredje sättet är Web Key Directory (WKD), där du publicerar nyckeln på din egen domän. Klienter som stöder WKD hittar då nyckeln automatiskt utifrån din e-postadress. WKD kräver kontroll över domänens webbserver och ligger utanför den här guidens grundflöde, men det är det renaste sättet för en organisation att dela ut nycklar i stor skala.
Steg 6: Importera och verifiera andras nycklar
Att importera en nyckel är trivialt. Det svåra, och det viktiga, är att verifiera att nyckeln verkligen tillhör den person du tror. Annars kan en angripare skicka dig sin egen nyckel och låtsas vara mottagaren, en klassisk man-in-the-middle-attack. Importera först:
$ gpg --import bjorn-public.asc
gpg: key 0xF1E2D3C4B5A69788: public key "Bjorn Berg <[email protected]>" imported
gpg: Total number processed: 1
gpg: imported: 1
# Eller hamta direkt fran nyckelservern via e-postadress
$ gpg --keyserver keys.openpgp.org --search-keys [email protected]Verifiera nyckeln genom att jämföra dess fullständiga fingeravtryck med mottagaren via en annan kanal, helst i person, via telefon eller via en signerad chatt. Läs upp fingeravtrycket och bekräfta varje tecken. Detta är hela grunden för PGP:s tillitsmodell.
$ gpg --fingerprint [email protected]
pub rsa4096/0xF1E2D3C4B5A69788 2025-03-01 [SC]
Key fingerprint = F1E2 D3C4 B5A6 9788 1234 5678 9ABC DEF0 1122 3344
uid [ unknown] Bjorn Berg <[email protected]>När fingeravtrycket stämmer signerar du nyckeln lokalt för att markera den som betrodd. Det är så det decentraliserade förtroendenätet (web of trust) byggs upp: du intygar med din signatur att den här nyckeln tillhör rätt person.
$ gpg --lsign-key 0xF1E2D3C4B5A69788
# Bekrafta att du har verifierat fingeravtrycket, ange ditt losenord.
# Nyckeln visas nu som [ full ] i stallet for [ unknown ].Fallgrop: hoppa aldrig över verifieringen för att det är obekvämt. En importerad men overifierad nyckel ger en falsk känsla av säkerhet. GnuPG varnar dig med “There is no assurance this key belongs to the named user” när du krypterar till en overifierad nyckel, och den varningen ska du ta på allvar.
Steg 7: Kryptera och dekryptera filer
Nu kommer den praktiska nyttan. För att kryptera en fil till en mottagare anger du deras e-postadress eller nyckel-ID med flaggan --recipient. Lägg gärna till --sign så att filen samtidigt signeras, vilket bevisar att den kommer från dig.
# Kryptera och signera en fil till Bjorn
$ gpg --encrypt --sign --armor --recipient [email protected] rapport.pdf
# Resultat: rapport.pdf.asc (ASCII) eller rapport.pdf.gpg (binar utan --armor)
# Kryptera till flera mottagare samtidigt
$ gpg --encrypt --recipient [email protected] --recipient [email protected] rapport.pdfMottagaren dekrypterar med ett enda kommando. GnuPG ser automatiskt vilken privat nyckel som behövs, ber om lösenordet och skriver ut originalfilen. Om filen även var signerad verifieras signaturen i samma steg.
$ gpg --decrypt rapport.pdf.asc > rapport.pdf
gpg: encrypted with cv25519 key, ID 0x1122334455667788
gpg: Good signature from "Anna Andersson <[email protected]>" [full]Vill du bara kryptera något åt dig själv, till exempel en lösenordsfil eller en säkerhetskopia, krypterar du till din egen adress. För ren symmetrisk kryptering med bara ett lösenord och ingen nyckel använder du --symmetric. Det är smidigt för en fil du vill skydda med en delad fras, men saknar fördelarna med asymmetrisk nyckelhantering.
# Symmetrisk kryptering med enbart losenord (AES-256)
$ gpg --symmetric --cipher-algo AES256 hemlig.txt
# Skapar hemlig.txt.gpg, last upp med samma losenord vid dekrypteringTekniken bakom --cipher-algo AES256 är samma AES-256 som driver hårddiskkryptering och säkra protokoll i övrigt. Skillnaden mot PGP:s vanliga läge är att här finns ingen publik nyckel inblandad, bara ett lösenord som måste delas på ett säkert sätt.
Steg 8: Signera filer och verifiera signaturer
Signering handlar inte om sekretess utan om äkthet och integritet. En signatur bevisar att en fil kommer från en viss nyckel och inte har ändrats sedan den signerades. Det är grunden för hur till exempel programvarudistributioner och säkerhetsuppdateringar verifieras. Det finns tre signaturtyper.
| Kommando | Flagga | Resultat | Användning |
|---|---|---|---|
| Inbäddad signatur | –sign | Komprimerad fil med signatur i | Filer som ska skickas vidare |
| Klartextsignatur | –clearsign | Läsbar text med signaturblock | E-post och meddelanden |
| Fristående signatur | –detach-sign | Separat .sig-fil | Stora filer, mjukvarureleaser |
Den fristående signaturen är vanligast för filer som distribueras publikt, eftersom originalet förblir orört och signaturen ligger i en egen liten fil bredvid. Så här skapar och verifierar du en sådan:
# Skapa en fristaende signatur
$ gpg --armor --detach-sign installer.tar.gz
# Skapar installer.tar.gz.asc
# Mottagaren verifierar mot originalet
$ gpg --verify installer.tar.gz.asc installer.tar.gz
gpg: Signature made tor 13 jun 2026 14:22:10 CEST
gpg: using EDDSA key AB12CD34EF56AB78CD90EF12AB34CD56EF78AB90
gpg: Good signature from "Anna Andersson <[email protected]>" [ultimate]Raden “Good signature” är det du vill se. Får du i stället “BAD signature” har filen ändrats eller signaturen hör inte ihop med filen, och då ska du inte lita på innehållet. En varning om “no assurance” betyder att signaturen är giltig men att du inte har verifierat avsändarens nyckel, vilket tar oss tillbaka till steg 6.
Klartextsignaturen med --clearsign är praktisk för meddelanden som ska kunna läsas av människor även utan PGP-stöd. Texten ligger kvar i klartext med ett signaturblock runt om, så mottagaren ser både innehållet och kan verifiera det. Det är samma princip som beskrivs i vår genomgång av digitala signaturer, fast applicerad på fritext.
Steg 9: Kryptera e-post i Thunderbird
Filkryptering är användbart, men för de flesta är själva poängen att kryptera e-post. Thunderbird har inbyggt OpenPGP-stöd sedan version 78, så du behöver inget tillägg längre. Inställningarna ligger under kontots egenskaper, fliken “End-to-End-kryptering”.
Koppla din nyckel till kontot
Du kan antingen låta Thunderbird generera en ny nyckel åt sig, eller importera den nyckel du redan skapat i terminalen. För att återanvända din befintliga nyckel exporterar du både den publika och den privata delen och importerar dem i Thunderbird via “Lägg till nyckel” och “Importera en befintlig OpenPGP-nyckel”.
# Exportera den privata nyckeln for import i Thunderbird
$ gpg --export-secret-keys --armor [email protected] > anna-private.asc
# VARNING: denna fil innehaller din privata nyckel. Radera den
# direkt efter import och behall den aldrig okrypterad pa disk.
$ shred -u anna-private.asc # saker radering pa LinuxNär nyckeln är kopplad väljer du per meddelande om det ska krypteras och signeras genom knapparna i skrivfönstret. Thunderbird hämtar mottagarens publika nyckel automatiskt om den finns på en nyckelserver eller i WKD, annars måste du importera den först som i steg 6.
Vad PGP inte döljer
En sak är avgörande att förstå: PGP krypterar meddelandets innehåll och eventuella bilagor, men inte metadata. Ämnesraden, avsändare, mottagare och tidsstämpel skickas i klartext. En angripare som avlyssnar trafiken ser alltså att du och Bjorn mejlar, när och hur ofta, men inte vad. Skriv därför aldrig något känsligt i ämnesraden, och var medveten om att kommunikationsmönstret i sig kan avslöja mycket.
PGP skyddar inte heller mot riktade nätfiskeförsök där angriparen lurar dig att kryptera till fel nyckel. Det är därför nyckelverifieringen i steg 6 inte går att hoppa över. Krypteringen är bara så stark som ditt förtroende för mottagarens nyckel.
Steg 10: Säkerhetskopiera nycklar och hantera utgång
Förlorar du din privata nyckel förlorar du tillgången till allt som krypterats till den. Det går inte att återskapa. Därför är säkerhetskopian inte valfri. Exportera hela nyckelringen, både publika och privata nycklar plus tillitsdatabasen, och lägg den på ett offline-medium.
# Komplett sakerhetskopia av nycklar och tillitsdatabas
$ gpg --export --armor > backup-public.asc
$ gpg --export-secret-keys --armor > backup-private.asc
$ gpg --export-ownertrust > backup-ownertrust.txt
# Packa och kryptera sjalva backupen symmetriskt
$ tar czf gpg-backup.tar.gz backup-*.asc backup-ownertrust.txt
$ gpg --symmetric --cipher-algo AES256 gpg-backup.tar.gz
$ shred -u backup-private.asc gpg-backup.tar.gzDen krypterade gpg-backup.tar.gz.gpg kan du lägga på flera USB-minnen på olika fysiska platser. Eftersom den är skyddad med AES-256 och ett starkt lösenord är den säker även om ett minne kommer bort. För återställning gör du tvärtom: dekryptera, packa upp och importera med gpg --import backup-private.asc följt av gpg --import-ownertrust backup-ownertrust.txt.
När nyckeln närmar sig sitt utgångsdatum förlänger du den i stället för att skapa en ny. Det bevarar alla signaturer och allt förtroende du byggt upp. Redigera nyckeln, välj giltighetstiden och spara:
$ gpg --edit-key [email protected]
gpg> expire
Key is valid for? (0) 2y
gpg> key 1 # valj undernyckeln
gpg> expire # forlang aven den
gpg> saveGlöm inte att ladda upp den uppdaterade publika nyckeln till nyckelservern efteråt, annars ser omvärlden fortfarande den gamla utgångstiden. Kör samma --send-keys som i steg 5.
Steg 11: Flytta nyckeln till en hårdvarunyckel (YubiKey)
Det säkraste du kan göra med din privata nyckel är att flytta den till en hårdvarunyckel, så att den aldrig finns på datorns disk. En YubiKey i 5-serien fungerar som ett OpenPGP-smartkort och stöder både RSA 4096 och Curve25519 från firmware 5.2.3 och senare. Den privata nyckeln lämnar då aldrig hårdvaran, och all kryptografi sker på kortet.
Förbered kortet genom att sätta egna PIN-koder. Standardvärdena är 123456 för användar-PIN och 12345678 för admin-PIN, och de måste bytas direkt.
$ gpg --card-edit
gpg/card> admin
gpg/card> passwd
# Byt bade PIN (1) och Admin PIN (3) till egna varden.
gpg/card> quitFlytta sedan dina undernycklar till kortet med keytocard. Detta flyttar nyckeln, det vill säga den raderas från disken och hamnar bara på kortet, så se till att du har en fungerande säkerhetskopia från steg 10 först.
$ gpg --edit-key [email protected]
gpg> key 1 # valj krypteringsundernyckeln
gpg> keytocard
Please select where to store the key:
(2) Encryption key
Your selection? 2
gpg> saveFallgrop: många blir överraskade av att keytocard tar bort den privata nyckeln från datorn. Utan en testad backup kan du låsa ut dig själv permanent om kortet går sönder eller tappas bort. Verifiera alltid att backupen går att importera på en separat maskin innan du flyttar nycklar till hårdvara.
Steg 12: Komplett arbetsflöde, ett körbart projekt
För att knyta ihop allt följer här ett komplett, körbart skript som krypterar och signerar en fil till en mottagare, verifierar resultatet och loggar utfallet. Det visar hur kommandona i guiden hänger ihop i ett verkligt flöde, till exempel i en backuprutin eller en filöverföring. Spara det som krypto-skicka.sh och gör det körbart med chmod +x.
#!/usr/bin/env bash
# krypto-skicka.sh - kryptera, signera och verifiera en fil med GPG
set -euo pipefail
MOTTAGARE="$1" # t.ex. [email protected]
FIL="$2" # filen som ska skickas
UT="${FIL}.asc"
# 1. Kontrollera att mottagarens nyckel finns
if ! gpg --list-keys "$MOTTAGARE" >/dev/null 2>&1; then
echo "FEL: ingen nyckel hittad for $MOTTAGARE" >&2
echo "Importera och verifiera nyckeln forst (se steg 6)." >&2
exit 1
fi
# 2. Kryptera och signera
echo "Krypterar $FIL till $MOTTAGARE ..."
gpg --batch --yes --armor --sign --encrypt \
--recipient "$MOTTAGARE" --output "$UT" "$FIL"
# 3. Verifiera att utdatafilen ar ett giltigt PGP-meddelande
if head -1 "$UT" | grep -q "BEGIN PGP MESSAGE"; then
echo "OK: $UT skapad ($(wc -c < "$UT") byte)"
else
echo "FEL: utdata ser inte ut som ett PGP-meddelande" >&2
exit 1
fi
# 4. Logga utfallet
echo "$(date -Iseconds) krypterade $FIL till $MOTTAGARE" >> krypto.log
echo "Klart. Skicka $UT till mottagaren."Kör skriptet med mottagare och fil som argument. Utdatat visar varje steg, och ett misslyckande avbryter direkt tack vare set -euo pipefail, så du aldrig av misstag skickar en okrypterad fil.
$ ./krypto-skicka.sh [email protected] kvartalsrapport.pdf
Krypterar kvartalsrapport.pdf till [email protected] ...
OK: kvartalsrapport.pdf.asc skapad (4821 byte)
Klart. Skicka kvartalsrapport.pdf.asc till mottagaren.Mottagaren behöver bara köra gpg --decrypt kvartalsrapport.pdf.asc > rapport.pdf, ange sitt lösenord och får både filen och en bekräftelse på att signaturen är giltig. Du har nu ett fungerande PGP-upplägg från nyckelgenerering till automatiserad, verifierad filöverföring.
Snabbreferens: de vanligaste GPG-kommandona
När grunden sitter behöver du sällan slå upp mer än den här tabellen. Den samlar de kommandon du använder oftast i daglig drift av PGP-kryptering.
| Uppgift | Kommando |
|---|---|
| Lista publika nycklar | gpg --list-keys |
| Lista privata nycklar | gpg --list-secret-keys |
| Generera nyckelpar | gpg --full-generate-key |
| Exportera publik nyckel | gpg --armor --export ADRESS |
| Importera nyckel | gpg --import fil.asc |
| Visa fingeravtryck | gpg --fingerprint ADRESS |
| Kryptera och signera | gpg -se -r ADRESS fil |
| Dekryptera | gpg --decrypt fil.asc |
| Verifiera signatur | gpg --verify fil.asc |
| Redigera nyckel | gpg --edit-key ADRESS |
Sex vanliga fallgropar med PGP-kryptering
De flesta problem med PGP beror inte på krypteringen i sig utan på hur människor hanterar nycklarna. Här är de misstag vi ser oftast, och hur du undviker dem.
- Ingen säkerhetskopia av privat nyckel. Tappar du nyckeln är allt krypterat material förlorat för alltid. Gör backupen i steg 10 innan du krypterar något viktigt.
- Återkallelsecertifikat skapas aldrig. Utan det kan du inte dra tillbaka en komprometterad nyckel. Skapa det i steg 4, samma dag som nyckeln.
- Overifierade nycklar. Att importera en nyckel betyder inte att den är äkta. Jämför alltid fingeravtrycket via en separat kanal.
- Känslig information i ämnesraden. PGP krypterar inte ämne, avsändare eller mottagare. Håll ämnesraden intetsägande.
- Svagt lösenord på nyckeln. Om nyckelfilen läcker är lösenordet sista försvaret. Använd en lång, unik fras.
- Privat nyckel kvar i klartext på disk. När du exporterat den privata nyckeln för import någon annanstans, radera filen säkert med
shred -u.
Felsökning: åtta vanliga problem och lösningar
Stöter du på fel är chansen stor att det redan finns i tabellen nedan. Den täcker de åtta vanligaste felmeddelandena och vad de beror på.
| Problem / meddelande | Orsak | Lösning |
|---|---|---|
| “No secret key” | Du saknar den privata nyckeln för att dekryptera | Importera din privata nyckel, eller be avsändaren kryptera till rätt publik nyckel |
| “There is no assurance this key belongs to…” | Mottagarens nyckel är overifierad | Verifiera fingeravtrycket och signera nyckeln (steg 6) |
| “Inappropriate ioctl for device” | gpg-agent kan inte visa lösenordsdialogen | Sätt export GPG_TTY=$(tty) i din shell-profil |
| “signing failed: Inappropriate ioctl” | Pinentry hittar ingen terminal | Installera pinentry och starta om gpg-agent |
| “BAD signature” | Filen ändrad eller fel signaturfil | Hämta originalfilen på nytt, lita inte på innehållet |
| “invalid option” vid start | Felaktig rad i gpg.conf | Kommentera ut den utpekade raden |
| “key expired” | Nyckelns giltighetstid har gått ut | Förläng med --edit-key och expire (steg 10) |
| Hänger vid lösenordsfråga över SSH | Ingen grafisk pinentry tillgänglig | Använd pinentry-curses i gpg-agent.conf |
Det överlägset vanligaste felet på servrar och i SSH-sessioner är Inappropriate ioctl for device. Det löses nästan alltid med en enda rad. Lägg den i ~/.bashrc eller ~/.zshrc så slipper du problemet permanent:
$ echo 'export GPG_TTY=$(tty)' >> ~/.bashrc
$ source ~/.bashrc
$ gpgconf --kill gpg-agent # tvinga omstart av agentenAvancerade tips för proffsanvändning
När grunderna sitter finns det flera sätt att höja säkerheten och bekvämligheten ytterligare. Det starkaste mönstret är att hålla huvudnyckeln helt offline och bara använda undernycklar i vardagen. Du genererar huvudnyckeln på en dator som aldrig kopplas till nätet, skapar undernycklar för signering, kryptering och autentisering, och tar bara med dig undernycklarna på din arbetsdator. Blir arbetsdatorn komprometterad kan du återkalla en undernyckel utan att förlora hela identiteten.
En autentiseringsundernyckel ([A]) kan dessutom ersätta vanliga SSH-nycklar. Då loggar du in på servrar med samma hårdvarunyckel som krypterar din e-post, och din privata SSH-nyckel finns aldrig på disk. Det görs genom att aktivera enable-ssh-support i gpg-agent.conf och exportera nyckeln i SSH-format.
För organisationer är Web Key Directory värt att ställa in ordentligt. När nycklarna publiceras under https://exempel.se/.well-known/openpgpkey/ hittar moderna klienter dem automatiskt utifrån e-postadressen, utan att användarna behöver leta på nyckelservrar. Det sänker tröskeln för krypterad e-post i hela organisationen.
Slutligen, håll ett öga på den kvantsäkra utvecklingen. Dagens RSA- och ECC-nycklar är säkra mot klassiska datorer men sårbara på lång sikt mot tillräckligt kraftfulla kvantdatorer. OpenPGP-världen arbetar med stöd för de algoritmer som NIST standardiserat, och vi följer den utvecklingen i vår bevakning av kryptografi. Material som krypteras i dag och måste vara hemligt om tjugo år bör du planera att kryptera om när kvantsäkra OpenPGP-nycklar blir allmänt tillgängliga.
Vanliga frågor om PGP-kryptering
Är PGP och GPG samma sak?
Inte riktigt. PGP är det ursprungliga programmet och i dag mest ett samlingsbegrepp. OpenPGP är den öppna standarden (RFC 4880 och RFC 9580). GPG, eller GnuPG, är den fria implementationen av OpenPGP som de allra flesta använder. När någon säger PGP-kryptering i praktiken menar de oftast OpenPGP via GnuPG.
Kan PGP-kryptering knäckas?
Inte genom att angripa själva krypteringen. RSA 4096 och Curve25519 är säkra mot all känd klassisk beräkningskraft. Det som knäcks i praktiken är nyckelhanteringen: svaga lösenord, stulna privata nycklar eller att man krypterar till fel, overifierad nyckel. Säkerheten ligger i rutinerna runt nyckeln, inte i matematiken.
Vad händer om jag glömmer mitt lösenord?
Då kommer du inte åt din privata nyckel, och det finns ingen återställningsfunktion. Allt som krypterats till nyckeln blir oläsbart för dig. Det är hela poängen med stark kryptering. Använd ditt återkallelsecertifikat för att markera nyckeln som ogiltig, och skapa ett nytt nyckelpar. Förvara därför lösenordet i en pålitlig lösenordshanterare.
Måste mottagaren också använda PGP?
Ja, för krypterad e-post och filer behöver båda parter PGP och varandras publika nycklar. För enbart signering räcker det att mottagaren kan verifiera, vilket de kan göra med vilken OpenPGP-klient som helst utan egen nyckel. För symmetrisk kryptering med --symmetric behövs bara ett delat lösenord.
RSA 4096 eller Ed25519, vilket ska jag välja?
Ed25519 med Curve25519 är förstahandsvalet för nya nycklar 2026. De är mindre, snabbare och minst lika säkra som RSA. Välj RSA 4096 bara om du vet att du måste kommunicera med gamla system eller klienter som inte stöder elliptiska kurvor. Båda ger fullgod säkerhet i dag.
Skyddar PGP mot massövervakning?
Innehållet, ja. Metadata, nej. PGP döljer vad du skriver men inte vem du mejlar, när eller hur ofta. Den som vill skydda även mönstret behöver komplettera med andra verktyg, till exempel anonymiserande nätverk. PGP är ett starkt skydd för innehåll, inte en heltäckande anonymitetslösning.
Hur ofta bör jag byta nyckel?
Du behöver inte byta nyckel regelbundet om den inte komprometterats. Sätt i stället en utgångstid på ett till två år och förläng den löpande, så bevarar du allt förtroende du byggt upp. Byt bara nyckel helt om den privata delen kan ha läckt, och använd då återkallelsecertifikatet på den gamla.
Relaterat innehåll
- Digitala signaturer: hashfunktioner och asymmetriska nycklar
- Kryptografiska hashfunktioner: egenskaper och användning
- HTTPS och TLS: hänglåset, certifikat och vad de skyddar
- Lösenordssäkerhet: längd, hashning och lösenordshanterare
- Nätfiske: hur bedrägeriförsök fungerar och hur du känner igen dem
- Kryptografi: hashfunktioner, SHA och digitalt förtroende
Vill du gå till källorna finns OpenPGP-standarden i sin helhet i RFC 9580, GnuPG dokumenteras på gnupg.org, och Windows-användare hittar Gpg4win och Kleopatra på gpg4win.org. För en pedagogisk genomgång av PGP på Linux har EFF:s Surveillance Self-Defense en bra modul, och projektets officiella hemsida finns på openpgp.org.
