# PGP Tool — full text > Concatenated plain-text dump of every Learn article and Compare page on https://pgptool.dev. Optimised for AI/LLM ingestion. English source-of-truth — see //learn/ for translations. --- # Articles ## How PGP works — a plain-English explainer URL: https://pgptool.dev/learn/how-pgp-works Reading time: 8 min > PGP combines asymmetric and symmetric encryption to send private messages without ever sharing a secret. Here is what actually happens under the hood. PGP — Pretty Good Privacy — is the encryption protocol that lets two people exchange private messages without first meeting to share a password. It has been the workhorse of email encryption since 1991 and underpins most of what this site does. Beneath the friendly name is a clever sandwich of two different kinds of cryptography. Each one solves a problem the other cannot, and PGP combines them into a single workflow. ## The two halves: asymmetric and symmetric Symmetric encryption (think AES) is fast and uses a single shared key — the same key locks and unlocks the message. The catch: both parties must already have the key. If you can email it, an attacker can intercept it. Asymmetric encryption (RSA, ECC) uses a key pair: a public key anyone can have, and a private key only you have. Anyone can encrypt to your public key, but only you can decrypt with the private one. The catch: it is slow and limited to small inputs. ## How PGP combines them 1. You generate a fresh, random "session key" — a one-shot AES key just for this message. 2. You encrypt the actual message body with the session key (fast, symmetric). 3. You encrypt the session key itself with the recipient's PGP public key (slow, but small payload). 4. You bundle the two ciphertexts together and send. On the other end, the recipient uses their private key to unlock the session key, then uses the session key to unlock the message. The session key is discarded. Each new message gets a new session key. ## Signing is the mirror image A signature is the same idea in reverse. You hash your message (SHA-256 or stronger) and then encrypt the hash with your private key. Anyone with your public key can decrypt the hash and check it matches — proving (a) the message has not been altered and (b) it was signed by someone holding your private key. ## Why this is hard to break Breaking PGP means either guessing the recipient's private key (computationally infeasible for RSA-3072+ or any modern ECC curve) or finding a flaw in the underlying algorithms. Decades of public scrutiny on RSA, AES, and Curve25519 have not turned up such a flaw. The realistic attacks are not on the math — they are on the user. A weak passphrase on the private key file, a compromised computer, social engineering to get you to encrypt to a wrong key. PGP makes the channel private; everything else is up to you. ## Where to start Generate a key pair on the Generate Keys tool, share the public key with anyone who wants to write to you, and keep the private key on a device only you control. That is the entire baseline. --- ## Why client-side crypto matters URL: https://pgptool.dev/learn/why-client-side-crypto-matters Reading time: 6 min > Server-side "encrypted" services still see your plaintext. Client-side crypto removes the server from the trust boundary entirely. Here is why that distinction is the whole game. A lot of services advertise "encryption". Almost all of them mean encryption-in-transit (HTTPS) and encryption-at-rest (the database is on an encrypted disk). Both are sensible practices. Neither hides your data from the people running the service. ## Where the boundary lives Encryption protects data from someone outside the trust boundary. If the boundary is "from your laptop to the server", then HTTPS keeps it private from your ISP — but the server sees plaintext. If the boundary is "your laptop only", the server only ever sees ciphertext it cannot read. Client-side crypto means the second boundary. Your data is encrypted before it leaves your machine, and the keys to decrypt it never exist on a server. Even if the server is hacked, subpoenaed, or quietly compromised, the operator has nothing useful to hand over. ## What "client-side" means in this app - Every encryption and decryption call runs in your browser using OpenPGP.js or Web Crypto. - Private keys live in your browser memory only for the duration of the operation; they are never sent anywhere. - There is no backend. The server you connect to (the static-host CDN) only delivers HTML, JS, and CSS — no API, no user accounts, no data ingestion. - You can verify this. Open devtools → Network tab. With air-gap mode on, no outbound requests fire during any operation. ## The catch Client-side crypto pushes the trust boundary onto your machine. If your browser is compromised, or you load this app from a server that has been MITM'd, you lose. That is why this site is open source, has a Content Security Policy, and is served over HTTPS with certificate pinning. You can also clone the repo and run it locally for maximum assurance. Convenience-versus-trust is the core tradeoff. Server-side services are easier — sync across devices, recovery flows, password reset — at the cost of trusting an operator. Client-side services are colder — lose your key, lose your data — but the operator cannot betray you. --- ## Argon2id vs PBKDF2: which key derivation function should you use? URL: https://pgptool.dev/learn/argon2id-vs-pbkdf2 Reading time: 7 min > Both stretch a password into an encryption key, but they cost attackers very different amounts of money. Argon2id is the modern default; PBKDF2 is the compatible fallback. When you encrypt something with a passphrase, the passphrase itself is too short and too predictable to use as an AES key directly. A key derivation function (KDF) takes the passphrase and stretches it — running thousands or millions of small operations to turn it into a 256-bit key, while making brute force expensive for an attacker. ## PBKDF2 — the old reliable PBKDF2 (Password-Based Key Derivation Function 2) was standardised in 2000 and is still everywhere — TLS, FileVault, OpenPGP, your phone's disk encryption. It iterates HMAC-SHA-256 a configurable number of times. More iterations means slower derivation, which means more cost for an attacker testing each guess. PBKDF2 has one big weakness: it is cheap on specialised hardware. A GPU or an ASIC can run thousands of PBKDF2 iterations in parallel for the cost of running one on a CPU. So an attacker with a small GPU farm can grind through guesses orders of magnitude faster than the legitimate user can verify a single one. ## Argon2id — the modern default Argon2 won the 2015 Password Hashing Competition with a deliberate design choice: be memory-hard. Each iteration requires a large block of RAM, and parallel attackers cannot share memory across guesses. So a GPU with 4 GB of memory can run 4 attacks simultaneously instead of 4000 — the cost ratio shifts back toward the defender. Argon2id is the recommended variant — it combines Argon2i (data-independent, resistant to side-channel attacks) and Argon2d (data-dependent, faster) for the best of both worlds. It is the default in libsodium, Bitwarden, 1Password, and the OpenPGP standard from 2024 onward. ## When to use which - Use Argon2id for any new encryption. The library cost is small (~250 KB WASM) and the security gain is real. - Use PBKDF2 when you need maximum compatibility — older PGP clients, archival tools, embedded devices. - This app uses Argon2id for new symmetric encryptions and falls back to PBKDF2 when decrypting legacy ciphertexts (a "magic prefix" envelope identifies which one was used). ## Practical numbers On a modern laptop, Argon2id with default parameters (m=65536 KiB, t=3, p=1) takes about 200 ms. A high-end GPU running PBKDF2-SHA256 at 200,000 iterations gets about 50 million guesses per second. The same GPU running Argon2id with 64 MB memory cost gets about 100 guesses per second. That is a six-order-of-magnitude advantage for the defender. > Caveat: KDFs cannot save a truly weak passphrase. "password123" falls in seconds regardless of iteration count. Use a passphrase generator or a multi-word phrase. --- ## How to verify a PGP signature, and why you should URL: https://pgptool.dev/learn/verifying-signatures Reading time: 5 min > A signature on a release file is only useful if you actually check it. Here is the 30-second workflow, and what each step is really proving. You downloaded a binary, the developer published a .asc signature next to it, and now what? Most people do nothing. The few who verify catch supply-chain attacks before they execute compromised code. ## What a signature actually proves A valid PGP signature proves two things: (1) the file has not been altered since it was signed, and (2) it was signed by someone holding the private key whose public counterpart you used to verify. It does not prove the signer is honest, or that the public key you are using is theirs. That second clause matters. If an attacker swaps the published file AND publishes their own public key alongside it, the signature will verify perfectly — against the wrong key. The only defence is establishing the signer's key out of band: a published fingerprint on a different domain, a transparency log, a key server lookup, or an in-person exchange. ## The verification workflow 1. Download the file and the signature (typically file.tar.gz and file.tar.gz.asc). 2. Get the signer's public key. Prefer a source unrelated to the binary — a keyserver, a printed fingerprint at a conference, or a public profile on a different domain. 3. Open the Verify tool and paste the signature, the original file, and the public key. 4. Confirm the verification result shows "Valid signature" with the expected signer. 5. Cross-check the public key fingerprint against the source you trust. ## Detached vs clearsign vs encrypted-and-signed - Detached signature — the .asc lives in a separate file. Used for binaries, archives, large blobs. - Clearsigned message — the signed text and the signature are both in the same .asc, with the original text in plain view. Used for emails and announcements. - Encrypted+signed — the message is both encrypted to the recipient and signed by the sender. Decrypt first, then verify the inner signature. ## Common mistakes - Verifying with a public key downloaded from the same place as the binary — defeats the purpose. - Ignoring "good signature, but key not certified" warnings without checking the fingerprint. - Re-saving the file before verification — line ending changes break detached signatures. --- ## Air-gap mode: what it does, and what it does not URL: https://pgptool.dev/learn/air-gap-mode-explained Reading time: 4 min > A toggle in the corner of the app blocks every outbound network request. Here is the threat model it covers and the one it does not. Air-gap mode disables every outbound network call from the running app. With it on, no DNS, no HTTPS, no keyserver lookups, no Drand fetches. (The app ships with no analytics or third-party trackers at all.) The only thing crossing the network boundary is the initial page load (which is cached by the service worker after the first visit). ## What it covers - Keyserver lookups in the Key Inspector — disabled. - Drand beacon fetches in the Time-Lock tool — disabled. - Google Analytics — never fires anyway, but explicitly blocked. - Hidden third-party scripts injected by a browser extension — would fail to fetch their payloads. ## What it does not cover - A compromised browser. If your browser itself is malicious, it can ignore air-gap mode entirely. - Browser extensions running outside the app sandbox. Extensions can read clipboard and DOM contents regardless of what the app does. - The OS layer — keyloggers, screen capture, swap files holding plaintext. ## The strong setup For maximum assurance: install the app as a PWA on a fresh, fully patched laptop, disconnect the laptop from the network, then run the app. The PWA shell is already cached locally, so it works offline. Combined with a passphrase-protected private key on encrypted disk, this is roughly the threat model that PGP was designed for. --- ## Setting up PGP for journalists: a practical 30-minute guide URL: https://pgptool.dev/learn/pgp-for-journalists Reading time: 9 min > Sources contact journalists through whatever channel feels safe. PGP is one of the few that survives a subpoena. Here is the minimum setup that actually works. A reporter's email gets subpoenaed and the prosecutor reads every message in plaintext. A reporter with PGP gets the same subpoena and the prosecutor sees ciphertext they cannot decrypt without compelling the reporter to hand over the key (which is its own legal fight, with stronger protections in most jurisdictions). PGP is not the only tool in the box — Signal, SecureDrop, encrypted email providers all have a place. But PGP is uniquely durable: it works across every email client, leaves no metadata at a third-party operator, and has a 30-year track record of resisting government attacks. Every journalist on a security or political beat should have one. ## The 30-minute setup 1. Go to /generate. Pick ECC Curve25519 (modern default). Use your real name (or a pseudonym you publish under). 2. Set a strong passphrase — 5+ random words from a wordlist, not a common phrase. Write it on paper, not in a password manager that lives on the same device. 3. Download both keys. The private key file (.asc) goes in a place only you can reach: a hardware token, an encrypted USB stick in a safe, or a passphrase-protected backup. 4. Publish the public key. Add the .asc to your bio on the news organisation's website, your social profiles, and a keyserver (keys.openpgp.org). 5. Print the fingerprint on your business card. Sources who meet you in person can verify they have the right key. ## The day-to-day workflow - A source pastes their message into /encrypt with your public key. They send the ciphertext through any channel — even Twitter DMs are fine. - You receive the ciphertext, paste into /decrypt, type your passphrase, read the message. - You reply by pasting the source's public key (which they sent you in plaintext) into /encrypt with your reply. - For attachments, use /files. For long-form documents, /vault. For self-destructing announcements, /paste with an expiry. ## Operational hygiene - Generate keys on a clean device. A compromised laptop generates a compromised key. - Use air-gap mode in this app for sensitive operations. - Set a 2-year expiry on your key. If you stop using it, it expires automatically and sources stop encrypting to it. - Maintain a revocation certificate — generated by Generate Keys and stored separately. If your key is compromised, publishing the revocation tells the world to stop trusting it. - Never share the same passphrase between PGP, your laptop login, and your password manager. ## For sources reading this Find a journalist who publishes their PGP fingerprint. Confirm the fingerprint on a second channel (their work email, a printed business card, a verified social profile). Use /encrypt with their public key. Send the ciphertext through any path that does not link your identity to theirs — a public Wi-Fi, a Tor browser, a burner email. The journalist decrypts on their end. The chain holds. > PGP is part of a defense, not the whole defense. For high-stakes leaks, also consult your news organisation's SecureDrop instance. The Freedom of the Press Foundation publishes an excellent guide that goes further than this one. --- ## How to encrypt an email with PGP — a 5-minute tutorial URL: https://pgptool.dev/learn/pgp-email-tutorial Reading time: 5 min > Sending your first encrypted email is faster than most guides make it look. Here is the minimal flow with no software install — just your browser. Most "PGP for beginners" guides spend ten paragraphs on theory before any practical step. This one does the opposite. By the end you will have sent one encrypted message and decrypted one reply. Everything happens in your browser. Nothing is sent to a server. No account is required. ## What you need - The recipient's PGP public key — a block of text starting with `-----BEGIN PGP PUBLIC KEY BLOCK-----`. - Your own key pair, if you want the recipient to write back. If you do not have one yet, generate it on the Generate Keys tool first. - Any email client. Gmail, Outlook, Proton, it doesn't matter — you paste ciphertext into the body like any other text. ## Encrypt the message 1. Open the Encrypt tool. 2. Paste the recipient's public key into the "Public Key" field. 3. Type your message into the plaintext field. 4. (Optional) Tick "Sign with my key" and paste your private key + passphrase to attach a signature. 5. Click "Encrypt". The output is a block of armored ciphertext — copy it. ## Send it Open your email client and paste the ciphertext into the body. Your subject line will be in plaintext, so do not put sensitive information there. Send. ## Decrypt the reply 1. Copy the ciphertext from the reply email. 2. Open the Decrypt tool. 3. Paste your private key and enter the passphrase. 4. Paste the ciphertext. 5. Click "Decrypt". The plaintext appears. ## Common mistakes - Pasting the wrong key. Make sure the public key you encrypt to belongs to the person you are writing. - Including an HTML signature. Some clients add a long footer that the recipient confuses with the ciphertext block. Plain text mode avoids this. - Sharing your private key. Only paste it into trusted tools and never email it to anyone. - Forgetting the subject is not encrypted. Treat it like a postcard. > For larger files, use File Encrypt instead. For self-destructing one-off messages, Secure Paste lets you generate a link with an expiry and never touches an email account. --- ## How to import and verify a public key URL: https://pgptool.dev/learn/import-verify-pgp-key Reading time: 6 min > Anyone can claim to publish a PGP public key. Verifying it before you encrypt prevents you from sending secrets to the wrong person. Here is the workflow. Importing a public key is trivial — paste it into the Key Inspector and you have it. Verifying it is where most people stop, and where most failures happen. A signed message to the wrong recipient is no better than no encryption at all. This piece walks through both halves: get the key, confirm it is the right one, then use it. ## What the public key actually is A public key is a long block of armored ASCII that anyone can have. It contains the algorithm, fingerprint, identities (names + emails), and creation/expiry timestamps. The fingerprint — a 40-character hex string — is the only piece you should treat as the canonical identifier. Names and emails can be set to anything by the key's creator. ## Step 1 — Get the key - From a keyserver: keys.openpgp.org is the modern keyserver. Search by email or fingerprint, copy the armored block. - From the recipient's website: many people publish their public key on a personal site or a `/.well-known/openpgpkey/` route. - From an email signature: some folks embed their public key in their email footer. - In person: if you meet someone, exchange fingerprints over a USB drive or QR code and avoid the network entirely. ## Step 2 — Inspect it 1. Open the Key Inspector tool. 2. Paste the armored key block. 3. Read the fingerprint, expiry date, key type, and identities. 4. Note the fingerprint — that 40-char hex string — somewhere safe. ## Step 3 — Verify the fingerprint This is the step that turns "I have a key claiming to belong to Alice" into "I have Alice's key". Compare the fingerprint you see with one you obtain from a different channel — a printed business card, a published bio, a transparency log, a phone call where Alice reads it out loud. If they match, the key is genuine. If the fingerprints do not match, do not encrypt to that key. Either the version you imported is forged, or the version on the other channel is. Investigate before sending anything sensitive. ## Step 4 — Use it Once verified, the key is safe to use in Encrypt, JSON Encryptor, File Encrypt, or any other tool that takes a public key. Save the fingerprint with the key in your notes so you do not have to repeat the verification next time. > Think of the fingerprint as the "real" name. Names and emails on the key are convenience labels, but the fingerprint is what cryptography actually compares. Always check the fingerprint, never trust just the email. --- ## OpenPGP key types explained: RSA vs Curve25519 vs P-384 URL: https://pgptool.dev/learn/pgp-key-types-explained Reading time: 7 min > Modern OpenPGP supports three key families. Each has different speed, size, and compatibility tradeoffs. Here is how to pick. When you generate a new PGP key, the tool asks "RSA-3072? RSA-4096? ECC Curve25519? ECC P-384?" The answer matters less than you might think for security — all four options are unbroken — but it matters a lot for speed, key size, and which clients can read your messages. ## RSA — the legacy default RSA-3072 and RSA-4096 are the workhorses of PGP. RSA has been in use since the 1970s and every PGP-capable client supports it. Keys are large (a 4096-bit private key is roughly 7 KB), key generation is slow (sometimes 30+ seconds in a browser), and signatures and ciphertexts are correspondingly chunky. Use RSA when you need maximum compatibility — embedded clients, very old GPG versions, regulators that explicitly mandate it. ## ECC Curve25519 — the modern default Ed25519 (signing) and X25519 (encryption) are the modern elliptic-curve replacements. Keys are tiny (a private key is around 32 bytes), key generation is essentially instant, and operations are 5–10× faster than RSA at equivalent security strength. Compatibility is good and growing — every actively maintained PGP client (GnuPG, ProtonMail, Thunderbird, this app) supports Curve25519. The only holdouts are some embedded HSMs and very old setups. Use Curve25519 for new keys unless you have a specific reason not to. It is what the OpenPGP standard recommends as of the 2024 RFC update. ## ECC P-384 — for compliance regimes NIST curves (P-256, P-384, P-521) are mathematically similar to Curve25519 but use different parameters chosen by the US National Institute of Standards. They have slightly worse performance and a more controversial provenance — the parameters were not derived in public. Use P-384 only when a compliance framework explicitly mandates a NIST curve — FIPS 140 government deployments, certain banking standards. For everything else, Curve25519 is the better engineering choice. ## A simple rule - New personal keys: ECC Curve25519. - Old systems must read your messages: RSA-3072 (the smaller of the two RSA options is fine). - Compliance audit demands NIST curves: ECC P-384. ## What about post-quantum? All three of the above are vulnerable in theory to a sufficiently large quantum computer (one that does not yet exist publicly). The OpenPGP working group is finalising post-quantum algorithms (ML-KEM and ML-DSA) but they are not yet in mainstream client support. For now, Curve25519 is your best bet — when post-quantum hybrids land, you will rotate then. > This app generates Curve25519 by default and exposes RSA-3072, RSA-4096, and P-384 as fallbacks. If you are uncertain, accept the default. --- ## Backing up PGP keys safely URL: https://pgptool.dev/learn/backing-up-pgp-keys Reading time: 7 min > Lose your private key and your encrypted history is unrecoverable. Steal a careless backup and your encrypted history is exposed. Here is how to back up without compromising either side. A PGP private key is unrecoverable. There is no "forgot password" link. If your laptop dies and you have no backup, every message ever encrypted to that key is gone forever. So you back up. But a private key sitting on a cloud drive is one breach away from ruining you. Backup hygiene is its own discipline. ## The threat model Two failure modes pull in opposite directions. (1) You lose the key — disk failure, lost laptop, accidental deletion. Backup mitigates this. (2) An attacker finds your backup — bad cloud password, stolen device, careless email attachment. Backup creates this risk. Good practice satisfies both: enough copies that loss is unlikely, but each copy is hardened against compromise. ## Strategy 1 — Encrypted offline media Burn the private key file (.asc) onto an encrypted USB stick or SD card. Use a strong, unique passphrase on the disk encryption (VeraCrypt or the OS native encryption). Store the stick somewhere physical that requires effort to reach — a home safe, a safety deposit box, a trusted relative's house. Make at least two copies in two different physical locations. A single copy plus a fire is no better than no copy at all. ## Strategy 2 — Paper backup Print the armored .asc to paper. Store in a fire-resistant safe or laminate and seal in a tamper-evident envelope. Paper does not rot, does not get hacked, and survives the death of every digital device you own. Tools like paperkey can produce QR-coded paper backups that you can scan back later. A paper backup is also passphrase-protected. The .asc is encrypted with your key passphrase, so even physical theft does not yield plaintext access. ## Strategy 3 — Shamir split For high-value keys, use the Split Key tool to break the key into N shares with K-of-N reconstruction. Distribute to trusted parties or store across geographically separated lockers. Any one share leaks nothing. Reconstruction requires K of them assembling. This trades recovery friction for catastrophic-leak resistance. Useful for keys you rarely use — a corporate signing key, an inheritance plan, an organisational master key. Less useful for your day-to-day key. ## The revocation certificate When you generate a key, also generate a revocation certificate and store it separately from the key. If your private key is ever compromised, publishing the revocation tells the world to stop encrypting to that key. Without one, you have no way to invalidate a stolen key. The Generate Keys tool emits the revocation certificate alongside the key. Save it on different media — different USB stick, different paper file, different safe. You only need it once, but when you need it you really need it. ## Hygiene checklist - At least two backup copies, in two different physical locations. - Each copy is encrypted, either by passphrase on the .asc or by full-disk encryption on the medium. - Revocation certificate stored separately from the private key. - Re-test recovery once a year — try restoring from one of your backups onto a clean device. Backups you have never tested often do not work. - Update backups whenever you add a subkey, extend the expiry, or change the passphrase. > A common mistake: emailing the .asc to yourself "as a backup". The email is then permanently in your provider's archive, encrypted only by the provider's keys. Use offline media or paper instead. --- ## Getting started with Generate Keys — your first key pair, step by step URL: https://pgptool.dev/learn/getting-started-generate-keys Reading time: 6 min > You opened the Generate Keys tool and you are staring at four fields. Here is what each one does and what to pick if you are not sure. Generating a PGP key pair is a one-time decision that you live with for years. Most guides skip the choices and tell you to "just click generate". This one explains what each field actually does, so the defaults make sense and you can deviate when you need to. Everything below happens entirely in your browser. The private key never leaves your device. ## What you are creating Two files, generated together as a pair. The public key (.asc) is the address you share — anyone in the world can encrypt to it. The private key (.asc) is the secret you keep — only it can decrypt messages sent to your public key. They are mathematically linked. Lose the private key and the messages are unreadable forever; leak it and your past correspondence is exposed. ## Field 1 — Name and email These go into the key as a "user ID" (UID), a human-readable label that travels with the public key. Pick whatever name and email you want others to see when they look up your key. The email does not need to be the address you actually use to send mail — UIDs are about identification, not delivery. You can have multiple UIDs on a single key (work email, personal email, pseudonym). For a first key, one UID is fine. Real name + the email you most want associated with the key is the conventional choice. ## Field 2 — Algorithm The default is Curve25519. Take it. It is fast, modern, has small keys, and is the algorithm every current OpenPGP client supports. RSA-3072 and RSA-4096 are still on offer for older clients (some hardware tokens, some legacy email setups) — pick RSA only if a recipient or device specifically requires it. If you are uncertain, the default is correct. There is a separate article on how the algorithms compare; this one assumes you are accepting the default. ## Field 3 — Passphrase The passphrase encrypts your private key file at rest. Without it, anyone who copies your .asc can decrypt every message you have ever received. It is the single most important security input. Make it long. Five or six unrelated words from a dictionary (an "EFF passphrase") is far stronger than a short string of mixed case and symbols, and easier to remember. The Password Generator tool can produce one. Avoid anything you have used elsewhere — passphrase reuse is the most common cause of compromise. Write it down somewhere physical the first time you set it. A passphrase you cannot recall is functionally identical to a lost private key. ## Field 4 — Expiry An expiry date does not destroy the key — it tells other clients that the key should no longer be trusted past that date. Setting one (1–2 years is conventional) gives you a graceful path to rotate keys without dramatic revocations. You can extend the expiry later if you decide to keep the key longer. "Never expires" is also acceptable for casual use. The downside is that if you lose access without a revocation certificate, the world keeps thinking the key is good forever. ## After you click Generate You will see three downloads: - Public key (.asc) — share this freely. Email it, paste it on your website, upload it to a keyserver. Anyone who wants to write to you needs this. - Private key (.asc) — store this carefully. See the "Backing up PGP keys" article. Never email it. Never paste it into untrusted tools. - Revocation certificate (.asc) — store this separately from the private key. If the private key is ever stolen or lost, publish the revocation so the world stops trusting the public key. ## First-week checklist 1. Make at least one offline backup of the private key (encrypted USB or paper). 2. Store the revocation certificate in a different location from the private key. 3. Test that you can decrypt: encrypt a sample message to your own public key, then decrypt it with the private key. 4. Share your public key with one person and ask them to send you an encrypted hello. 5. Add the key fingerprint to your email signature or website so others can verify they have the right key. > You do not have to upload your public key to a keyserver to use PGP. Direct sharing (email attachment, a download link on your site) is enough for personal use. Keyservers are convenient when you want strangers to find your key without first contacting you. --- ## Encrypt a PGP message to multiple recipients URL: https://pgptool.dev/learn/encrypt-to-multiple-recipients Reading time: 5 min > Send one encrypted message that several people can decrypt independently. Here is how OpenPGP handles multi-recipient envelopes and the practical workflow. OpenPGP makes multi-recipient encryption a single-step operation: you list every recipient, the tool encrypts the message body once with a fresh symmetric session key, then encrypts that session key separately to each recipient's public key. Every listed recipient can decrypt independently with their own private key. Anyone not on the list cannot. ## How OpenPGP handles it A PGP-encrypted message has two parts. The body is encrypted once with a random AES session key. The header carries one Public-Key Encrypted Session Key (PKESK) packet per recipient — each one is the same session key encrypted to a different public key. When Bob decrypts, his client looks for a PKESK that his private key can unwrap, recovers the session key, then decrypts the body. Alice doing the same finds her own PKESK and gets the same session key. The body is only encrypted once on the wire — the file size grows by ~1 KB per additional recipient, not by the size of the message. ## Doing it in this app 1. Open the [Encrypt tool](https://pgptool.dev/encrypt). 2. Paste the first recipient's public key. Validation will show their user ID. 3. Click "Add recipient" and paste the next one. The Encrypt tool supports up to five recipients per message. 4. Type your plaintext. 5. Click Encrypt. The output is a single ciphertext block — give the same block to every recipient. ## Practical considerations - You do NOT include yourself automatically. If you want to be able to decrypt your own sent messages, add your own public key as a recipient. - Each recipient sees who else is on the list — the PKESK packets carry key IDs in the clear (or hidden, see below). For confidential CC behavior, encrypt twice or use the hidden-recipient option. - Hidden recipients (the OpenPGP `--hidden-encrypt-to` flag) zero out the key ID in the PKESK, but the recipient count is still visible. True anonymous recipients require external metadata stripping. - Different recipients can have different key types (RSA, Curve25519, P-384) — OpenPGP picks the right algorithm per PKESK packet. ## When to encrypt to many recipients vs send N times Single multi-recipient message: smaller, faster, easier to keep in sync (everyone sees the same content). Use this for normal cases — team announcements, group secrets, shared credentials. Separate messages per recipient: required when content varies per person (e.g. each gets a different password), or when the recipient list itself is sensitive and you do not want recipients to see each other's key IDs. > There is no upper limit in the OpenPGP spec, but practical limits exist: this app caps at 5 recipients per message to keep the UI manageable; GPG on the command line will handle hundreds. For mailing-list-scale recipient counts, look at separate per-recipient messages or a dedicated key-management tool. --- ## OpenPGP subkeys explained — separate keys for signing, encryption, and authentication URL: https://pgptool.dev/learn/subkey-generation Reading time: 6 min > Modern OpenPGP keys are not one key but a primary key plus subkeys. Here is what each subkey does, why the separation matters, and how to generate them. A modern OpenPGP "key" is actually a small bundle: one primary key plus one or more subkeys. The primary signs and certifies. Subkeys do the day-to-day work of encryption and signing. Splitting them this way is one of the few unambiguously-good operational practices in PGP. ## Why subkeys exist The primary key carries your identity. Its fingerprint is what others verify, what you publish, what people sign at key-signing parties, what links to your user ID. Rotating the primary means losing all that accumulated trust — every signature on it, every published reference, every business card. You also want to use a key on devices where it might be exposed: encrypting messages on your laptop, signing emails on your phone. If those daily-use keys are the primary, a single compromised device burns the entire identity. Subkeys solve both problems. The primary stays cold (offline, air-gapped, or only used to certify). Subkeys go on the daily devices. If a subkey is compromised, you revoke just that subkey, the primary signs a new replacement, and your identity continues with no loss of accumulated trust. ## The three subkey roles - Sign (S) — produces signatures on messages, files, commits, package releases. The most-used subkey for many people. - Encrypt (E) — receives encrypted messages. When someone encrypts to you, their tool picks your encryption subkey from the public key bundle. - Authenticate (A) — used as an SSH key (via gpg-agent), for client TLS auth, or other "prove identity to a server" workflows. Optional. Each role can have multiple subkeys (e.g. one current + one for backup) and each can have a different algorithm (RSA-4096 for sign, Curve25519 for encrypt, etc.). Subkeys can also have their own expiry dates, independent of the primary. ## Default behavior When you generate a key with most modern tools — GPG, OpenPGP.js, this app — you automatically get a primary + an encryption subkey + (depending on the tool) a signing subkey. The Encrypt and Sign tools here use the primary for signing because the bundle ships a single signing-capable subkey by default; full split-role generation is more common from the command line. For a casual user, the default is fine. For long-term operational hygiene, you want the four-subkey setup: cold primary (Certify only), online sign subkey, online encrypt subkey, optional authenticate subkey. ## Practical workflow with GPG Set up once with the offline-primary pattern: ``` gpg --quick-generate-key "Alice " ed25519 cert never gpg --edit-key alice@example.com > addkey # add a sign subkey > addkey # add an encrypt subkey > addkey # add an auth subkey > save ``` Then export the primary private key to a USB stick, store it offline, and remove it from your daily keyring with `gpg --delete-secret-keys` (the subkeys stay; this is the gpg-specific "stub" pattern). Day-to-day sign/encrypt operations now run from subkeys only — the primary is only needed when you add or revoke another subkey, which should be rare. ## Rotating a subkey - Plug in the offline primary. - `gpg --edit-key alice@example.com`, run `addkey` to mint a fresh subkey of the appropriate role. - Optionally `revkey` the old subkey to rotate it out (or just let it expire). - `gpg --send-keys` to publish the updated public key. Recipients will pick up the new subkey on next refresh. Their existing encrypted-to-old-subkey messages still decrypt with the old subkey, which you keep around for archive access. New messages will use the new subkey automatically. > Subkeys are interoperable across implementations. A key generated by GPG on the command line decrypts cleanly with this app, and vice versa — they are the same OpenPGP packet format. --- ## Rotating a PGP key — when, why, and the migration workflow URL: https://pgptool.dev/learn/key-rotation Reading time: 6 min > When should you rotate a PGP key, and how do you do it without losing access to old encrypted messages? Here is the practical playbook. A PGP key is meant to last. Long-lived keys accumulate trust signatures, get cached by recipients, and form the stable identity that makes PGP useful for long-term correspondence. But there are situations where rotation is the right answer — and the migration is annoyingly hands-on if you have not thought it through. ## When to rotate - The private key was exposed (e.g. unencrypted backup leaked, lost laptop without disk encryption, malware on the device). - The passphrase is suspected to be weak or has been observed (shoulder-surfing, keylogger possibility, written down somewhere accessible). - The key uses a deprecated algorithm — RSA-1024, DSA-1024, or older. Modern guidance is RSA ≥ 3072 or Curve25519 / P-384. - The key has a hard expiry coming up that you cannot or do not want to extend. - You are reorganising identity (changing primary email, splitting personal and work). - A subkey was compromised — but here you rotate just the subkey (see "Subkey generation" article), not the primary. Rotation purely for paranoia ("it has been a long time since I rotated") is usually unnecessary if the key is sound and uncompromised. Modern keys with strong passphrases and reasonable algorithms have no expiry-by-design — they fail when something specific goes wrong. ## The two-key transition You cannot just delete the old key. Anything encrypted to it stays encrypted to it forever. The migration is overlapping, not cutover: 1. Generate the new key pair with the [Generate Keys tool](https://pgptool.dev/generate). Use Curve25519 unless you have a specific compatibility reason for RSA. 2. Sign the new public key with the old key. This produces a "rotation certificate" — a signature from the old key vouching that the new key is also you. 3. Publish the new public key (keyserver, your website, whatever channel you used for the old one). Keep the old public key published too — recipients still need it to encrypt the old archive. 4. Send a signed announcement from the old key declaring the rotation, the new fingerprint, and the date. People who already have your old key in their keyring will trust this signed message. 5. For a few weeks, accept incoming messages on either key. Slowly stop using the old key for outgoing traffic. 6. Once correspondents have updated, revoke the old key. The revocation propagates through keyservers and tells the world to stop encrypting to the old key. 7. Keep the old private key archived, encrypted offline. Do NOT delete it — old encrypted messages are unrecoverable without it. ## Decrypting old messages after rotation Anything encrypted to the old key needs the old private key. You have three options: - Archive: keep the old private key + passphrase in encrypted long-term storage. Pull it out when you need to read a 5-year-old encrypted email. - Re-encrypt: decrypt the archive with the old key once, re-encrypt with the new key, store. Convenient but a one-time operational chore. - Abandon: if you do not need the archive, delete the old private key. The old encrypted messages become unreadable forever. Most people pick the archive route — it is cheap (one encrypted file), reversible, and keeps your options open. ## If the old key was compromised The workflow above assumes a clean rotation. If the old key was actually exposed, the announcement-and-cross-sign approach is wrong — an attacker with the old key can also sign a fake "I rotated to this new key" message. Instead: - Publish the revocation certificate immediately. (You have one because you generated it when you generated the original key — see the "Backing up PGP keys" article.) - Generate a fresh key, but do NOT sign it with the compromised key — it carries no trust. - Re-establish trust out-of-band: contact correspondents directly, in person if possible, by phone otherwise, and confirm the new fingerprint. - Treat any messages encrypted to the old key after the compromise date as potentially exposed. > A compromised PGP key cannot be "patched" or re-secured. The only response is revocation + replacement. This is true of every signature-based system; PGP is not unusually fragile here, but the operational steps are entirely on you. --- # Glossary URL: https://pgptool.dev/learn/glossary ## AEAD Anchor: https://pgptool.dev/learn/glossary#aead See also: https://en.wikipedia.org/wiki/Authenticated_encryption Authenticated Encryption with Associated Data — a cipher mode that produces ciphertext + an integrity tag in one operation, so any tampering is detected at decrypt time. Modern OpenPGP and TLS use AEAD modes (AES-GCM, ChaCha20-Poly1305) by default. ## AES Anchor: https://pgptool.dev/learn/glossary#aes See also: https://en.wikipedia.org/wiki/Advanced_Encryption_Standard, https://www.wikidata.org/wiki/Q31734 Advanced Encryption Standard — the NIST-standardised symmetric block cipher (FIPS 197, 2001). Available in 128-, 192-, and 256-bit key sizes. Hardware-accelerated on every modern CPU and the default symmetric cipher in OpenPGP, TLS, and almost everything else. ## AES-CBC Anchor: https://pgptool.dev/learn/glossary#aes-cbc See also: https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_block_chaining_(CBC) AES used in Cipher Block Chaining mode. Encrypts each block XORed with the previous ciphertext block. CBC provides confidentiality but no integrity — unauthenticated CBC is the source of many real-world attacks (padding oracles). Considered legacy; AES-GCM is preferred. ## AES-GCM Anchor: https://pgptool.dev/learn/glossary#aes-gcm See also: https://en.wikipedia.org/wiki/Galois/Counter_Mode AES in Galois/Counter Mode — an AEAD construction that produces ciphertext plus a 128-bit authentication tag. Fast, parallelisable, and widely supported. Used by Web Crypto, TLS 1.3, OpenPGP's SEIPDv2 packets, and this app's Secure Paste. ## Air-gap mode Anchor: https://pgptool.dev/learn/glossary#air-gap-mode See also: https://en.wikipedia.org/wiki/Air_gap_(networking) An operational mode that disables every outbound network request from an application. In this app, air-gap mode blocks keyserver lookups, Drand fetches, and any other cross-origin call — the page can still encrypt, decrypt, and sign locally. Useful when the threat model includes a compromised network. ## Argon2 Anchor: https://pgptool.dev/learn/glossary#argon2 See also: https://en.wikipedia.org/wiki/Argon2, https://www.rfc-editor.org/rfc/rfc9106 A family of memory-hard password-hashing functions, winner of the 2015 Password Hashing Competition. Three variants: Argon2d (data-dependent, fastest), Argon2i (data-independent, side-channel-resistant), Argon2id (hybrid, recommended default). Standardised in RFC 9106. ## Argon2id Anchor: https://pgptool.dev/learn/glossary#argon2id See also: https://www.rfc-editor.org/rfc/rfc9106#section-4 The hybrid Argon2 variant — first pass uses Argon2i for side-channel resistance, subsequent passes use Argon2d for speed. The recommended default for new password-based key derivation. RFC 9106 §4. ## ASCII armor Anchor: https://pgptool.dev/learn/glossary#ascii-armor See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy#PGP_message_format OpenPGP's text encoding for binary key and message data: base64 + a checksum + ----BEGIN/END markers. Lets you paste a key or ciphertext into an email, chat, or HTML form without the binary getting mangled. The ".asc" file extension marks armored content. ## Asymmetric encryption Anchor: https://pgptool.dev/learn/glossary#asymmetric-encryption See also: https://en.wikipedia.org/wiki/Public-key_cryptography Encryption that uses two keys — one to encrypt (public), one to decrypt (private). Anyone can encrypt; only the holder of the private key can decrypt. The basis of PGP, S/MIME, TLS handshakes, and SSH host keys. Also called public-key cryptography. ## Authenticated encryption Anchor: https://pgptool.dev/learn/glossary#authenticated-encryption See also: https://en.wikipedia.org/wiki/Authenticated_encryption Encryption that also produces an integrity tag, so the receiver can detect tampering. Without authentication, an attacker can flip ciphertext bits and the receiver cannot tell. Modern protocols always use authenticated encryption (AEAD). ## Base64 Anchor: https://pgptool.dev/learn/glossary#base64 See also: https://en.wikipedia.org/wiki/Base64 A binary-to-text encoding using 64 printable characters (A–Z, a–z, 0–9, +, /). Expands data ~33% but makes it safe for email, URLs (with the URL-safe variant), and JSON. ASCII armor is base64 + framing. ## bcrypt Anchor: https://pgptool.dev/learn/glossary#bcrypt See also: https://en.wikipedia.org/wiki/Bcrypt A password hashing function from 1999 based on the Blowfish cipher. CPU-hard with a tunable work factor. Pre-dates Argon2 and lacks Argon2's memory-hardness, but still widely deployed and acceptable for password storage. Not recommended for new code over Argon2id. ## Block cipher Anchor: https://pgptool.dev/learn/glossary#block-cipher See also: https://en.wikipedia.org/wiki/Block_cipher A symmetric cipher that operates on fixed-size blocks (typically 64 or 128 bits). AES, DES, 3DES are block ciphers. To encrypt arbitrary-length data, a block cipher is used inside a mode of operation (CBC, GCM, CTR). ## Certificate Authority (CA) Anchor: https://pgptool.dev/learn/glossary#certificate-authority See also: https://en.wikipedia.org/wiki/Certificate_authority An organisation that issues digital certificates after verifying the holder's identity. CAs are the trust anchors of the X.509 / TLS / S/MIME PKI. Browsers and OS bundles ship with a list of trusted root CAs. PGP's web of trust deliberately avoids this central-authority model. ## ChaCha20 Anchor: https://pgptool.dev/learn/glossary#chacha20 See also: https://en.wikipedia.org/wiki/Salsa20#ChaCha_variant, https://www.rfc-editor.org/rfc/rfc8439 A modern stream cipher designed by Daniel J. Bernstein (2008). Faster than AES on CPUs without AES-NI, and resistant to several timing-attack classes that AES variants struggled with. Standardised in RFC 8439. ## ChaCha20-Poly1305 Anchor: https://pgptool.dev/learn/glossary#chacha20-poly1305 See also: https://en.wikipedia.org/wiki/ChaCha20-Poly1305 AEAD construction pairing the ChaCha20 stream cipher with the Poly1305 MAC. Used in TLS 1.3, OpenSSH, WireGuard, and modern OpenPGP. The default cipher of choice when AES hardware acceleration is unavailable. ## Ciphertext Anchor: https://pgptool.dev/learn/glossary#ciphertext See also: https://en.wikipedia.org/wiki/Ciphertext The encrypted form of a message. Indistinguishable from random data to anyone without the decryption key. ## Clearsign Anchor: https://pgptool.dev/learn/glossary#clearsign See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy An OpenPGP signature format that wraps the original plaintext between BEGIN/END markers and appends a detached signature. The message stays human-readable; the signature can be verified separately. Useful for signed email and signed announcements where you want the body visible without decrypting. ## Collision resistance Anchor: https://pgptool.dev/learn/glossary#collision-resistance See also: https://en.wikipedia.org/wiki/Collision_resistance A property of a hash function: it is computationally infeasible to find two distinct inputs that produce the same output. Broken collision resistance (e.g. SHA-1, MD5) means an attacker can forge documents that share a hash with a legitimate one. ## CSPRNG Anchor: https://pgptool.dev/learn/glossary#csprng See also: https://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator Cryptographically Secure Pseudo-Random Number Generator. Produces output indistinguishable from true randomness to a computationally bounded attacker. The browser's `crypto.getRandomValues()` and `crypto.subtle.generateKey()` use the OS CSPRNG. ## Curve25519 Anchor: https://pgptool.dev/learn/glossary#curve25519 See also: https://en.wikipedia.org/wiki/Curve25519, https://www.rfc-editor.org/rfc/rfc7748 An elliptic curve designed by Daniel J. Bernstein (2005) for use with X25519 ECDH. Provides ~128 bits of security with 32-byte keys. Standardised in RFC 7748. The modern default for OpenPGP encryption subkeys, alongside Ed25519 for signing. ## Detached signature Anchor: https://pgptool.dev/learn/glossary#detached-signature See also: https://en.wikipedia.org/wiki/Digital_signature A signature stored as a separate file from the data it signs (typically `.sig`). Lets you sign binaries, packages, or any file you cannot or will not modify. Verification requires both the original file and the signature. ## Diffie-Hellman Anchor: https://pgptool.dev/learn/glossary#diffie-hellman See also: https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange A 1976 key-exchange protocol that lets two parties agree on a shared secret over a public channel without ever transmitting the secret. Modern variants (ECDH, X25519) underpin TLS, Signal, OpenPGP, SSH. ## Digest Anchor: https://pgptool.dev/learn/glossary#digest See also: https://en.wikipedia.org/wiki/Cryptographic_hash_function The fixed-size output of a hash function. Sometimes called a checksum (informal) or a hash. SHA-256 produces a 256-bit (32-byte) digest. ## Digital signature Anchor: https://pgptool.dev/learn/glossary#digital-signature See also: https://en.wikipedia.org/wiki/Digital_signature A cryptographic proof that a specific message was created by the holder of a specific private key. The signature is a function of both the message and the private key, and can be verified by anyone with the matching public key. PGP, S/MIME, and code-signing all rely on digital signatures. ## ECC Anchor: https://pgptool.dev/learn/glossary#ecc See also: https://en.wikipedia.org/wiki/Elliptic-curve_cryptography Elliptic Curve Cryptography — public-key cryptography over the algebraic structure of elliptic curves. Smaller keys for the same security as RSA (256-bit ECC ≈ 3072-bit RSA). Standard curves include Curve25519, P-256, P-384, P-521. ## ECDH Anchor: https://pgptool.dev/learn/glossary#ecdh See also: https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman Elliptic Curve Diffie-Hellman — Diffie-Hellman key exchange over an elliptic curve. The asymmetric component of OpenPGP encryption when using ECC keys. X25519 is the most common variant in modern systems. ## ECDSA Anchor: https://pgptool.dev/learn/glossary#ecdsa See also: https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm Elliptic Curve Digital Signature Algorithm — the elliptic-curve variant of DSA. Used in TLS, JWT, Bitcoin, and OpenPGP signing subkeys. Requires a fresh random nonce per signature; reusing a nonce leaks the private key (the famous Sony PlayStation 3 attack). ## Ed25519 Anchor: https://pgptool.dev/learn/glossary#ed25519 See also: https://en.wikipedia.org/wiki/EdDSA#Ed25519, https://www.rfc-editor.org/rfc/rfc8032 EdDSA over Curve25519 — a deterministic signature scheme that avoids the nonce-reuse failure mode of ECDSA. Fast, small (64-byte signatures, 32-byte keys), modern. Standardised in RFC 8032 and the default signing algorithm in modern OpenPGP and SSH. ## EdDSA Anchor: https://pgptool.dev/learn/glossary#eddsa See also: https://en.wikipedia.org/wiki/EdDSA Edwards-curve Digital Signature Algorithm — a family of signature schemes over Edwards-form elliptic curves. Deterministic (no per-signature nonce), simple to implement correctly. The Ed25519 instantiation is the modern default. ## End-to-end encryption (E2EE) Anchor: https://pgptool.dev/learn/glossary#end-to-end-encryption See also: https://en.wikipedia.org/wiki/End-to-end_encryption A property of a communication system: data is encrypted on the sender's device and only decrypted on the recipient's device. Intermediate servers see only ciphertext. Signal, WhatsApp, iMessage, and PGP-encrypted email are E2EE; standard email, SMS, and most "encrypted" cloud services are not. ## Entropy Anchor: https://pgptool.dev/learn/glossary#entropy See also: https://en.wikipedia.org/wiki/Entropy_(information_theory) A measure of unpredictability, in bits. A 128-bit AES key has 128 bits of entropy if it is generated uniformly at random. A six-character lowercase password has ~28 bits of entropy. The Password Strength Tester computes entropy assuming a uniform distribution over the apparent character set. ## EXIF Anchor: https://pgptool.dev/learn/glossary#exif See also: https://en.wikipedia.org/wiki/Exif Exchangeable Image File Format — metadata embedded in JPEG, TIFF, HEIC, and other image formats. Includes camera make/model/serial, lens, exposure settings, GPS coordinates, and timestamps. The Metadata Tools page reads and strips EXIF without re-encoding the image. ## Fingerprint Anchor: https://pgptool.dev/learn/glossary#fingerprint See also: https://en.wikipedia.org/wiki/Public_key_fingerprint A short hash (usually SHA-1 or SHA-256) of a public key. Lets users compare keys by reading 40 hex characters instead of comparing 4096-bit RSA moduli. Fingerprint verification is the foundation of safe PGP key exchange. ## Forward secrecy Anchor: https://pgptool.dev/learn/glossary#forward-secrecy See also: https://en.wikipedia.org/wiki/Forward_secrecy A property where compromise of long-term keys does not compromise past sessions. Achieved by using ephemeral keys per session and discarding them after use. TLS 1.3 and Signal have forward secrecy; PGP-encrypted email does not. ## GnuPG (GPG) Anchor: https://pgptool.dev/learn/glossary#gnupg See also: https://en.wikipedia.org/wiki/GNU_Privacy_Guard, https://gnupg.org/ The Free Software implementation of OpenPGP, started in 1997. Command-line, available on Linux, macOS, Windows. The reference implementation for almost every PGP operation; this app uses OpenPGP.js but produces interoperable output. ## Hash function Anchor: https://pgptool.dev/learn/glossary#hash-function See also: https://en.wikipedia.org/wiki/Cryptographic_hash_function A function mapping arbitrary-length input to fixed-length output, designed so that the output is deterministic, fast to compute, infeasible to invert, and infeasible to find collisions for. SHA-256 is the standard general-purpose cryptographic hash. ## HKDF Anchor: https://pgptool.dev/learn/glossary#hkdf See also: https://en.wikipedia.org/wiki/HKDF, https://www.rfc-editor.org/rfc/rfc5869 HMAC-based Key Derivation Function (RFC 5869). Extracts entropy from a high-entropy input (e.g. a Diffie-Hellman shared secret) and expands it into multiple uniform output keys. Used in TLS 1.3, Signal, Noise. ## HMAC Anchor: https://pgptool.dev/learn/glossary#hmac See also: https://en.wikipedia.org/wiki/HMAC, https://www.rfc-editor.org/rfc/rfc2104 Hash-based Message Authentication Code (RFC 2104). Combines a secret key with a hash function to produce a tag that proves both authenticity and integrity. HMAC-SHA-256 is the workhorse MAC of the modern internet. ## Initialization vector (IV) Anchor: https://pgptool.dev/learn/glossary#iv See also: https://en.wikipedia.org/wiki/Initialization_vector A random value mixed into a cipher's state at the start of encryption to ensure that the same plaintext + key produce different ciphertext each time. Must be unique per encryption (and for some modes, unpredictable). IV reuse is a catastrophic failure mode in AES-GCM and CTR modes. ## Key derivation function (KDF) Anchor: https://pgptool.dev/learn/glossary#kdf See also: https://en.wikipedia.org/wiki/Key_derivation_function A function that turns a low-entropy input (a passphrase) or a high-entropy input (a Diffie-Hellman secret) into one or more uniform encryption keys. Password-stretching KDFs (PBKDF2, Argon2id) are deliberately slow; HKDF is fast and used after key agreement. ## Key ID Anchor: https://pgptool.dev/learn/glossary#key-id See also: https://en.wikipedia.org/wiki/Public_key_fingerprint The lower 64 bits of an OpenPGP key fingerprint. Convenient short reference (e.g. `0xDEADBEEF`) but collidable — short Key IDs (32 bits) have been demonstrably forged. Always verify by full fingerprint, not by Key ID. ## Key pair Anchor: https://pgptool.dev/learn/glossary#key-pair See also: https://en.wikipedia.org/wiki/Public-key_cryptography#Description A matched public + private key. Generated together; the private key cannot be derived from the public, and the public is mathematically derived from the private. The atomic unit of PGP, SSH, TLS client certs. ## Keyring Anchor: https://pgptool.dev/learn/glossary#keyring See also: https://en.wikipedia.org/wiki/GNU_Privacy_Guard A local store of PGP keys (your own + others'). GnuPG keeps a `pubring.kbx` and `secring.gpg` (or modern `private-keys-v1.d/`). Browser tools like this one usually do not have a persistent keyring — keys are pasted in per session. ## Keyserver Anchor: https://pgptool.dev/learn/glossary#keyserver See also: https://en.wikipedia.org/wiki/Key_server_(cryptographic) A server that hosts PGP public keys, indexable by email or fingerprint. The modern default is keys.openpgp.org (validated, opt-in upload, can be deleted). Older SKS servers were never validated and accumulated spam, leading to the modern split. ## MAC (Message Authentication Code) Anchor: https://pgptool.dev/learn/glossary#mac See also: https://en.wikipedia.org/wiki/Message_authentication_code A short tag computed over a message using a secret key, proving the message was produced by someone with the key and not modified. HMAC and Poly1305 are the standard MACs. ## MAC-then-encrypt Anchor: https://pgptool.dev/learn/glossary#mac-then-encrypt See also: https://en.wikipedia.org/wiki/Authenticated_encryption#Approaches_to_authenticated_encryption A flawed construction: compute a MAC over the plaintext, then encrypt plaintext + MAC together. Decryption errors leak via padding-oracle-style attacks. Modern systems use encrypt-then-MAC or AEAD instead. ## Mode of operation Anchor: https://pgptool.dev/learn/glossary#mode-of-operation See also: https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation A scheme that turns a block cipher into a way to encrypt arbitrary-length messages. ECB (insecure), CBC (legacy), CTR (parallelisable), GCM (AEAD) are the canonical examples. ## Nonce Anchor: https://pgptool.dev/learn/glossary#nonce See also: https://en.wikipedia.org/wiki/Cryptographic_nonce A "number used once" — a unique value per encryption, used by AEAD modes (AES-GCM, ChaCha20-Poly1305) to ensure ciphertexts diverge. Nonces are public and do not need to be unpredictable, only unique. Reusing a nonce with the same key in GCM is a catastrophic failure. ## OpenPGP Anchor: https://pgptool.dev/learn/glossary#openpgp See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy, https://www.rfc-editor.org/rfc/rfc9580 The IETF standard (RFC 4880, updated by RFC 9580 in 2024) defining the PGP message format and protocols. Implemented by GnuPG, OpenPGP.js, RNP, Sequoia, and others. "PGP" colloquially means OpenPGP. ## OpenPGP card Anchor: https://pgptool.dev/learn/glossary#openpgp-card See also: https://en.wikipedia.org/wiki/OpenPGP_card A smart-card specification for storing OpenPGP private keys. The card performs sign/decrypt operations internally; the keys never leave the chip. YubiKeys (in OpenPGP mode), Nitrokeys, and the FSF's Cryptostick are OpenPGP-card-compliant. ## P-256 Anchor: https://pgptool.dev/learn/glossary#p-256 See also: https://en.wikipedia.org/wiki/Elliptic-curve_cryptography#Standardized_curves A NIST-standardised elliptic curve (FIPS 186-4), also called secp256r1 or prime256v1. ~128 bits of security. The default curve for ECDSA in TLS, JWT, and many enterprise environments. Modern protocols increasingly prefer Curve25519 for the same security with simpler implementation. ## P-384 Anchor: https://pgptool.dev/learn/glossary#p-384 See also: https://en.wikipedia.org/wiki/Elliptic-curve_cryptography A NIST-standardised elliptic curve providing ~192 bits of security. Required by Suite B and several government environments. Slightly slower than P-256 and Curve25519 but with a larger security margin. ## PBKDF2 Anchor: https://pgptool.dev/learn/glossary#pbkdf2 See also: https://en.wikipedia.org/wiki/PBKDF2, https://www.rfc-editor.org/rfc/rfc2898 Password-Based Key Derivation Function 2 (RFC 2898, 2000). Stretches a passphrase into a key by iterating an HMAC many times. Modern guidance: ≥ 600,000 iterations of PBKDF2-SHA256. Only CPU-hard, not memory-hard — Argon2id is preferred for new code. ## Perfect forward secrecy (PFS) Anchor: https://pgptool.dev/learn/glossary#perfect-forward-secrecy See also: https://en.wikipedia.org/wiki/Forward_secrecy Synonymous with forward secrecy. Long-term key compromise does not retroactively expose past sessions. Achieved via ephemeral key exchange per session. ## PGP Anchor: https://pgptool.dev/learn/glossary#pgp See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy Pretty Good Privacy — Phil Zimmermann's 1991 program for encrypting and signing email and files. The OpenPGP standard (RFC 4880 / 9580) is the open spec derived from it. Today "PGP" almost always means an OpenPGP implementation, often GnuPG. ## PGP/MIME Anchor: https://pgptool.dev/learn/glossary#pgp-mime See also: https://www.rfc-editor.org/rfc/rfc3156 An IETF standard (RFC 3156) for embedding PGP-encrypted or signed payloads in MIME-formatted email. Modern mail clients prefer PGP/MIME over the older inline ASCII-armor approach because it handles attachments cleanly. ## PKI Anchor: https://pgptool.dev/learn/glossary#pki See also: https://en.wikipedia.org/wiki/Public_key_infrastructure Public Key Infrastructure — the certificate authorities, certificates, and revocation infrastructure that bind public keys to identities in TLS, S/MIME, and code signing. PGP's web of trust is an alternative trust model that avoids central CAs. ## Plaintext Anchor: https://pgptool.dev/learn/glossary#plaintext See also: https://en.wikipedia.org/wiki/Plaintext Unencrypted data. The input to encryption and the output of decryption. ## Plausible deniability Anchor: https://pgptool.dev/learn/glossary#plausible-deniability See also: https://en.wikipedia.org/wiki/Deniable_authentication A property where it is computationally or socially impossible to prove that someone did, or did not, send a particular message. Off-the-Record Messaging (OTR) and some Signal modes have this; PGP signatures explicitly do not — that is the point of a signature. ## Preimage resistance Anchor: https://pgptool.dev/learn/glossary#preimage-resistance See also: https://en.wikipedia.org/wiki/Preimage_attack A property of a hash function: given an output, it is infeasible to find an input that hashes to it. Distinct from collision resistance. SHA-256 has preimage resistance of ~2^256. ## Primary key (OpenPGP) Anchor: https://pgptool.dev/learn/glossary#primary-key See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy The top-level key in an OpenPGP key bundle. Carries the user ID, certifies subkeys, and signs revocations. Best practice is to keep the primary offline and use subkeys for daily sign/encrypt operations. ## Private key Anchor: https://pgptool.dev/learn/glossary#private-key See also: https://en.wikipedia.org/wiki/Public-key_cryptography The half of a key pair that must stay secret. Used to decrypt messages encrypted to the matching public key, and to produce signatures verifiable with the matching public key. Compromise of a private key compromises all messages encrypted to its public key. ## Public key Anchor: https://pgptool.dev/learn/glossary#public-key See also: https://en.wikipedia.org/wiki/Public-key_cryptography The half of a key pair that can be shared freely. Used to encrypt messages (only the private-key holder can decrypt) and to verify signatures (only the private-key holder could have produced them). ## Public key cryptography Anchor: https://pgptool.dev/learn/glossary#public-key-cryptography See also: https://en.wikipedia.org/wiki/Public-key_cryptography See Asymmetric encryption. ## Replay attack Anchor: https://pgptool.dev/learn/glossary#replay-attack See also: https://en.wikipedia.org/wiki/Replay_attack An attacker captures a valid encrypted or signed message and re-sends it later, hoping the receiver acts on it again. Defended against by including a fresh timestamp or nonce in every message that the receiver tracks. ## Revocation certificate Anchor: https://pgptool.dev/learn/glossary#revocation-certificate See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy A pre-signed OpenPGP statement saying "this key is no longer valid". Generated at key-creation time and stored separately, so even if you lose the private key you can still publish the revocation. Required hygiene for any PGP key meant to last. ## RSA Anchor: https://pgptool.dev/learn/glossary#rsa See also: https://en.wikipedia.org/wiki/RSA_(cryptosystem) The Rivest-Shamir-Adleman public-key algorithm (1977). Based on the difficulty of factoring large semiprimes. Modern guidance: ≥ 3072-bit keys for new use; 2048-bit for legacy compatibility only. Slower than ECC; remains universally supported. ## S/MIME Anchor: https://pgptool.dev/learn/glossary#smime See also: https://en.wikipedia.org/wiki/S/MIME Secure/Multipurpose Internet Mail Extensions — an IETF standard for email encryption and signing using X.509 certificates. Native support in Apple Mail, Outlook, and most enterprise clients. Trust comes from a CA, not from a web of trust. ## S2K Anchor: https://pgptool.dev/learn/glossary#s2k See also: https://www.rfc-editor.org/rfc/rfc9580 String-to-Key — the OpenPGP key-derivation specification used to turn a passphrase into a symmetric key. Modern S2K specifiers support PBKDF2 and Argon2id (via RFC 9580). Older S2K modes (simple, salted) are insecure for low-entropy passphrases. ## Salt Anchor: https://pgptool.dev/learn/glossary#salt See also: https://en.wikipedia.org/wiki/Salt_(cryptography) A random value mixed into password hashing to ensure that the same passphrase produces different hashes for different users. Defeats precomputed rainbow tables. Salts are public and stored alongside the hash. ## scrypt Anchor: https://pgptool.dev/learn/glossary#scrypt See also: https://en.wikipedia.org/wiki/Scrypt A memory-hard password hashing function from 2009 (Colin Percival). Pre-Argon2 standard for memory-hard KDF. Still used in some cryptocurrencies and password vaults; superseded by Argon2id for new design. ## SEIP Anchor: https://pgptool.dev/learn/glossary#seip See also: https://www.rfc-editor.org/rfc/rfc9580 Symmetrically Encrypted Integrity Protected packet — the OpenPGP packet format that pairs symmetric encryption with a SHA-1 modification-detection code (SEIPDv1) or AEAD (SEIPDv2 in RFC 9580). Replaces the older unauthenticated SE packet, which was vulnerable to active attacks. ## Session key Anchor: https://pgptool.dev/learn/glossary#session-key See also: https://en.wikipedia.org/wiki/Session_key A symmetric key generated for one specific message or session. In hybrid encryption (PGP, TLS), the session key encrypts the body and is itself encrypted to the recipient's public key. Discarded after use. ## SHA-256 Anchor: https://pgptool.dev/learn/glossary#sha-256 See also: https://en.wikipedia.org/wiki/SHA-2 A 256-bit hash from the SHA-2 family (FIPS 180-4). The default cryptographic hash for almost everything in 2026 — TLS, Bitcoin, OpenPGP, package signing. ~2^128 collision resistance. ## SHA-3 Anchor: https://pgptool.dev/learn/glossary#sha-3 See also: https://en.wikipedia.org/wiki/SHA-3 The third-generation NIST hash family (FIPS 202, 2015), based on the Keccak sponge construction. Available in 224, 256, 384, 512-bit variants. Designed as a structural alternative to SHA-2; not yet a default in most protocols. ## SHA-512 Anchor: https://pgptool.dev/learn/glossary#sha-512 See also: https://en.wikipedia.org/wiki/SHA-2 The 512-bit variant of SHA-2. Faster than SHA-256 on 64-bit CPUs, with double the collision resistance. Used where larger digests are useful (some HMAC profiles, password hashing, SHA-512/256 truncation). ## Shamir secret sharing Anchor: https://pgptool.dev/learn/glossary#shamir-secret-sharing See also: https://en.wikipedia.org/wiki/Shamir%27s_secret_sharing A 1979 scheme by Adi Shamir for splitting a secret into N shares such that any K of them can reconstruct it, and fewer than K reveal nothing. Used to back up high-value secrets without a single point of failure. The Split Key tool implements this for PGP private keys. ## Side-channel attack Anchor: https://pgptool.dev/learn/glossary#side-channel-attack See also: https://en.wikipedia.org/wiki/Side-channel_attack An attack that exploits information leaked through the implementation rather than the algorithm — timing, cache state, power consumption, electromagnetic radiation. Modern implementations of AES, ECDSA, and RSA include explicit mitigations. ## Signature Anchor: https://pgptool.dev/learn/glossary#signature See also: https://en.wikipedia.org/wiki/Digital_signature The output of a signing operation — a short binary blob that, combined with the message and the signer's public key, proves the message was signed by the corresponding private key. See Digital signature. ## Signing Anchor: https://pgptool.dev/learn/glossary#signing See also: https://en.wikipedia.org/wiki/Digital_signature Producing a digital signature over a message using a private key. The recipient verifies with the matching public key. Distinct from encryption: signing does not hide the message, only proves who produced it. ## Smart card Anchor: https://pgptool.dev/learn/glossary#smart-card See also: https://en.wikipedia.org/wiki/Smart_card A tamper-resistant chip that stores private keys and performs cryptographic operations on-chip — the keys never leave. YubiKey, Nitrokey, and government PIV / CAC cards are smart cards. The OpenPGP card spec defines a PGP-specific smart-card profile. ## Steganography Anchor: https://pgptool.dev/learn/glossary#steganography See also: https://en.wikipedia.org/wiki/Steganography Hiding data inside other data so the existence of the message is obscured (as opposed to its contents, which is encryption). Image steganography uses the least-significant bits of pixels; the Steganography tool combines this with PGP for confidentiality plus concealment. ## Stream cipher Anchor: https://pgptool.dev/learn/glossary#stream-cipher See also: https://en.wikipedia.org/wiki/Stream_cipher A symmetric cipher that produces a key-derived pseudo-random stream and XORs it with the plaintext. ChaCha20 is the modern default. Block ciphers in CTR mode behave as stream ciphers. ## Subkey (OpenPGP) Anchor: https://pgptool.dev/learn/glossary#subkey See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy A key bound to a primary key by a certification signature. Subkeys can have their own algorithms, expiry dates, and capabilities (sign / encrypt / authenticate). Best practice: use subkeys for daily operations, keep the primary offline. ## Symmetric encryption Anchor: https://pgptool.dev/learn/glossary#symmetric-encryption See also: https://en.wikipedia.org/wiki/Symmetric-key_algorithm Encryption that uses the same key to encrypt and decrypt. Fast (orders of magnitude faster than asymmetric) but requires both parties to already share the key. Modern systems combine symmetric + asymmetric: asymmetric encrypts a fresh symmetric key per message, symmetric encrypts the body. ## Threat model Anchor: https://pgptool.dev/learn/glossary#threat-model See also: https://en.wikipedia.org/wiki/Threat_model An explicit statement of who the attacker is, what they can do, and what they want. "PGP-encrypted email defends against a passive network adversary, not against malware on the recipient's laptop" is a threat-model statement. Picking the wrong tool is usually a threat-model mismatch. ## Time-lock encryption Anchor: https://pgptool.dev/learn/glossary#time-lock-encryption See also: https://en.wikipedia.org/wiki/Time-lock_puzzle Encryption that becomes decryptable only after a specified date, without trusting any single party to release a key — properly implemented with identity-based encryption over a randomness beacon such as Drand (the tlock construction). Note: the Time-Lock tool in this app is an honor-system approximation that uses Drand as a public clock but does not yet implement true tlock, so a determined holder of the envelope can open it early. ## Timing attack Anchor: https://pgptool.dev/learn/glossary#timing-attack See also: https://en.wikipedia.org/wiki/Timing_attack A side-channel attack that exploits variations in how long an operation takes, depending on secret data. Constant-time implementations mitigate this by ensuring the operation always takes the same time regardless of input. ## URL fragment Anchor: https://pgptool.dev/learn/glossary#url-fragment See also: https://en.wikipedia.org/wiki/URI_fragment The part of a URL after the `#`. Browsers do not send the fragment to the server. Secure Paste exploits this: paste content lives entirely in the fragment, so it never crosses the network even when the URL is loaded. ## User ID (OpenPGP) Anchor: https://pgptool.dev/learn/glossary#user-id See also: https://en.wikipedia.org/wiki/Pretty_Good_Privacy A string attached to an OpenPGP primary key, typically of the form `Name `. A key can have multiple user IDs (e.g. several email addresses). Each user ID is signed by the primary key and optionally by other keys (web-of-trust certifications). ## Web of Trust Anchor: https://pgptool.dev/learn/glossary#web-of-trust See also: https://en.wikipedia.org/wiki/Web_of_trust PGP's decentralised trust model: any user can sign any other user's public key, vouching that the key really belongs to them. Trust propagates transitively (you trust Alice, Alice signs Bob's key, you trust Bob's key) up to a configurable depth. Contrasts with PKI, which relies on centralised CAs. ## WebAuthn Anchor: https://pgptool.dev/learn/glossary#webauthn See also: https://en.wikipedia.org/wiki/WebAuthn A W3C standard for browser-mediated public-key authentication, often using hardware authenticators (YubiKey, Touch ID, Windows Hello). The Decrypt tool uses WebAuthn as an optional gate before revealing decrypted plaintext. ## WKD Anchor: https://pgptool.dev/learn/glossary#wkd See also: https://datatracker.ietf.org/doc/draft-koch-openpgp-webkey-service/ Web Key Directory — a discovery protocol where a domain advertises its users' OpenPGP keys at a well-known URL (`/.well-known/openpgpkey/...`). Lets recipients fetch a key by email address without trusting a separate keyserver. Supported by GnuPG and the Key Inspector tool. ## X.509 Anchor: https://pgptool.dev/learn/glossary#x509 See also: https://en.wikipedia.org/wiki/X.509 The ITU-T standard for digital certificates used in TLS, S/MIME, code signing, and PKI generally. Defines certificate fields (subject, issuer, validity, public key) and the CA-signed chain that establishes trust. Distinct from OpenPGP's certificate format. ## X25519 Anchor: https://pgptool.dev/learn/glossary#x25519 See also: https://www.rfc-editor.org/rfc/rfc7748 ECDH key agreement over Curve25519 (RFC 7748). The encryption-side counterpart to Ed25519. Used for OpenPGP encryption subkeys, TLS 1.3 key exchange, Signal, WireGuard, SSH. ## XMP Anchor: https://pgptool.dev/learn/glossary#xmp See also: https://en.wikipedia.org/wiki/Extensible_Metadata_Platform Extensible Metadata Platform — an Adobe-developed XML metadata format embedded in PDFs, JPEGs, RAW files, and Office documents. Often carries tracking IDs (xmpMM:DocumentID, xmpMM:InstanceID) that survive lazy "strip metadata" operations. The Metadata Tools page extracts and removes XMP packets. ## YubiKey Anchor: https://pgptool.dev/learn/glossary#yubikey See also: https://en.wikipedia.org/wiki/YubiKey A family of hardware security tokens from Yubico. Supports OpenPGP card mode, FIDO2/WebAuthn, U2F, OTP, and PIV. Common pairing with GnuPG for offline-primary key setups: the YubiKey holds the encryption / signing / authenticate subkeys and never reveals them. ## Zero-knowledge proof Anchor: https://pgptool.dev/learn/glossary#zero-knowledge-proof See also: https://en.wikipedia.org/wiki/Zero-knowledge_proof A cryptographic protocol that proves a statement is true without revealing anything else. Common in privacy-preserving authentication and blockchain systems. Not directly used in PGP — included here as a frequently-asked-about concept. --- # Comparisons ## PGP vs GPG — what is the difference? URL: https://pgptool.dev/vs/pgp-vs-gpg Reading time: 5 min > PGP, OpenPGP, and GPG are constantly confused. Here is exactly what each term means and which one you are actually using. People use "PGP" and "GPG" interchangeably, but they are not the same thing. One is a product, one is a standard, and one is a program that implements the standard. Untangling them clears up most of the confusion. ## The three names - PGP ("Pretty Good Privacy") — the original 1991 encryption software by Phil Zimmermann. Today it is a commercial product line (owned by Symantec/Broadcom). - OpenPGP — the open standard (RFC 4880, updated by RFC 9580) that defines the message and key formats. It is a specification, not a program. - GPG / GnuPG ("GNU Privacy Guard") — a free, open-source program that implements the OpenPGP standard. It is the tool most people actually run. So when someone says "send me your PGP key," they almost always mean an OpenPGP key — which you probably created with GPG (or a tool like this one, built on the OpenPGP.js library). All three interoperate because they speak the same OpenPGP format. ## Are they compatible? Yes. A key or message from GnuPG, from the original PGP software, or from any OpenPGP library works everywhere, because they all conform to the same standard. A message this tool encrypts can be decrypted with gpg on the command line, and vice versa. ## Which should you use? - Desktop command line and scripting: GnuPG (gpg) — free, ubiquitous, the de-facto reference implementation. - Graphical desktop app: Kleopatra (Windows) or GPG Suite (macOS), both built on GnuPG. - Quick, install-free operations: a client-side OpenPGP web tool like this one — nothing to install, everything runs locally. - The commercial "PGP" products target enterprise deployments and are rarely what an individual needs. ## The short version OpenPGP is the standard. PGP was the original program and is now a commercial product. GPG (GnuPG) is the free implementation almost everyone uses. They all interoperate, so "my PGP key" and "my GPG key" are, in practice, the same OpenPGP key. --- ## RSA vs ECC keys — which should you generate? URL: https://pgptool.dev/vs/rsa-vs-ecc Reading time: 5 min > RSA and elliptic-curve (Curve25519 / NIST) keys both secure PGP, but they trade size, speed, and compatibility differently. Here is how to choose. When you generate a PGP key you pick an algorithm family: RSA or elliptic-curve cryptography (ECC). Both are secure at recommended sizes. The real difference is efficiency versus backward compatibility. ## The core trade-off RSA security comes from the difficulty of factoring large numbers, so keys must be large — 3072 or 4096 bits — to stay strong. ECC gets equivalent security from far smaller keys: a 256-bit Curve25519 key is roughly as strong as a 3072-bit RSA key, while being much smaller and faster. ## Side by side - Key size: RSA-3072 vs Curve25519 (256-bit) for comparable security — ECC keys and signatures are dramatically smaller. - Speed: ECC key generation, signing, and decryption are faster; RSA verification is fast but signing and keygen are slow. - Compatibility: RSA works with virtually every OpenPGP implementation ever shipped. Curve25519 is supported by all modern software (recent GnuPG, Thunderbird, OpenPGP.js) but not by very old installations. - Quantum resistance: neither is quantum-safe — both will need post-quantum replacements (ML-KEM / ML-DSA) as those standards roll out. ## Which to choose - Choose ECC Curve25519 for new keys in almost all cases — smaller, faster, secure, and supported by every actively maintained OpenPGP tool. - Choose RSA-4096 only if you must interoperate with legacy systems or a policy mandates RSA. - Avoid RSA-2048 for long-lived keys — it meets today's minimum but has less margin than RSA-3072+ or Curve25519. In this tool, the Generate Keys page defaults to Curve25519 for exactly these reasons; switch to RSA only when compatibility demands it. --- ## PGP vs S/MIME — which email encryption protocol should you use? URL: https://pgptool.dev/vs/pgp-vs-smime Reading time: 6 min > PGP and S/MIME both encrypt and sign email, but they trust very different things. Here is when each one is the right answer. Both PGP and S/MIME predate the modern web. Both can encrypt and sign email. Both are still in active use. The difference is who you trust to vouch for keys — and that single distinction reshapes the rest of the choice. ## Trust model PGP uses a "web of trust" — any user can sign any other user's public key, vouching that the key really belongs to them. There is no central authority. Trust is established through direct exchange (in person, fingerprint verification) or transitively through people you already trust. S/MIME uses a centralised PKI — a Certificate Authority issues your email certificate after verifying your identity (often just by sending an email to that address and asking you to click a link). Other people trust your S/MIME signature because their email client trusts the CA, not because they trust you directly. ## Practical differences - PGP keys are free and self-issued. S/MIME certificates cost $0–$80/year and require a CA application. - PGP works with any email client (or web app like this one). S/MIME requires native support, which Apple Mail and Outlook have, but most webmail does not. - PGP keys typically last years and are rotated by the user. S/MIME certs expire annually. - PGP encrypts only the message body. S/MIME wraps the entire email including some headers, but the subject line is in plaintext for both. ## Security Both use modern algorithms (RSA / ECC + AES) and both are cryptographically sound. The interesting differences are operational. S/MIME's reliance on CAs is a single point of failure. A compromised or coerced CA can issue valid-looking certs for any email address. PGP's web of trust has no such central target — the cost of a successful attack is forging trust signatures from many independent users, which is much harder. PGP is more vulnerable to user error in key management. Without a CA stamping things, recipients have to verify fingerprints themselves. Skipped fingerprint checks are how most real-world PGP attacks succeed. ## Recommendation - Use PGP if you correspond with technical users, journalists, security researchers, or open-source maintainers — the people who already publish keys. - Use S/MIME inside a corporate environment where IT issues certs to all employees, or for regulated industries (healthcare, legal, finance) where compliance auditors expect CA-issued certificates. - You can use both. Most email clients will pick whichever the recipient supports. --- ## Argon2id vs PBKDF2 — at-a-glance comparison URL: https://pgptool.dev/vs/argon2id-vs-pbkdf2 Reading time: 4 min > Side-by-side: speed, memory cost, attack resistance, library support, and which one to pick for new code. Both are key derivation functions (KDFs). Both turn a passphrase into an encryption key. The difference is where they spend the attacker's budget. ## Side by side - Year standardised: PBKDF2 — 2000 (RFC 2898). Argon2id — 2015 (PHC winner), RFC 9106 in 2021. - Cost dimension: PBKDF2 — CPU time only. Argon2id — CPU time and RAM (memory-hard). - GPU/ASIC speedup vs CPU: PBKDF2 — 100×–1000×. Argon2id — close to 1×. - Standard library support: PBKDF2 — universal (Web Crypto, OpenSSL, every language). Argon2id — common but not universal; usually a separate library. - OpenPGP standard: PBKDF2 — yes (S2K). Argon2id — yes, since RFC 9580 in 2024. - Recommended use: PBKDF2 — legacy compatibility. Argon2id — anything new. ## Both at default settings PBKDF2-HMAC-SHA256 with 600,000 iterations: ~250 ms on a laptop CPU; ~500 ns per guess on a GPU. Argon2id with m=65536 KiB, t=3, p=1: ~250 ms on a laptop CPU; ~10 ms per guess on a GPU. Same defender cost. 5,000,000× attacker cost. That is the entire reason to switch. ## When to keep PBKDF2 anyway - Reading legacy ciphertext encrypted with PBKDF2 — you have no choice. - Targeting environments without WASM (very old browsers, hardened embedded devices). - Existing FIPS-140-3 deployments where Argon2id is not yet certified. For everything else, Argon2id wins. This app uses Argon2id by default and can read PBKDF2-encrypted legacy ciphertexts via a magic-prefix envelope. --- ## Browser PGP vs GPG on the desktop — when to use which URL: https://pgptool.dev/vs/browser-pgp-vs-gpg-desktop Reading time: 5 min > GnuPG is the gold standard for serious key management. A browser tool wins for ad-hoc encryption and on devices without root access. Here is the honest comparison. GnuPG (GPG) is the canonical PGP implementation — running on Linux, macOS, and Windows since 1997, scrutinised by every paranoid sysadmin, integrated into apt-get, package managers, mail clients, and signing infrastructure. A browser tool is something different. The two coexist for different jobs. ## GPG on the desktop Strengths: a permanent keyring under your control, hardware token integration (YubiKey, Nitrokey), command-line scripting, decades of audit history, integration with mail clients (Thunderbird), package signing (apt, dnf, brew), and SSH key management. If you encrypt or sign things daily, this is the answer. Weaknesses: requires installation, root or admin to set up, has a steep CLI learning curve. Cannot run on a borrowed laptop, a Chromebook in restricted mode, or anywhere a USB stick is not allowed. ## Browser PGP (this app) Strengths: zero install, runs anywhere with a modern browser, works offline as a PWA, no admin needed. Same crypto library quality (OpenPGP.js is widely audited and used in major mail clients). Useful as a learning tool, a backup channel, or a quick one-off encryption when you do not have your normal device. Weaknesses: no persistent keyring across browser sessions unless you save keys yourself; no hardware-token integration; trust depends on the integrity of the served HTML/JS bundle (mitigated by HTTPS, CSP, and PWA caching, but not as airtight as a static binary you compiled). ## Recommendation - Daily user with sensitive work — GPG with a hardware token. Browser tools as a fallback. - Occasional user who encrypts a message every few months — browser tool is enough, less to maintain. - Travelling on a borrowed laptop and need to read one urgent message — browser tool, in air-gap mode, then close the tab. - Source contacting a journalist for the first time — browser tool from a public Wi-Fi, ciphertext sent via any channel, journalist decrypts on their GPG setup. They are not in competition. They are different shapes for different days. --- ## PGP vs Age — when to pick the modern file encryption tool URL: https://pgptool.dev/vs/pgp-vs-age Reading time: 5 min > Age is a younger, smaller, opinionated file encryption tool. PGP has the bigger ecosystem and signing built in. Here is how the choice actually plays out. Age (pronounced "ah-gay", from the Italian for "I am") was released in 2019 by Filippo Valsorda. It tackles a small, specific problem: encrypt this file so only the recipients can read it. PGP can do that too, alongside two dozen other things. The interesting question is whether the extra surface area is helping you or hurting you. ## What each one does Age does file encryption. That is it. No signatures, no web of trust, no key servers, no expiry dates, no subkeys, no MIME, no email integration. The format is one envelope type and one cipher: X25519 + ChaCha20-Poly1305. PGP/OpenPGP does file encryption, message encryption, signatures, key certification, key revocation, multiple algorithms, multiple key types, key expiry, subkeys, smart card support, email integration, and a federated key discovery protocol. It is a kit. Age is a tool. ## Cryptography - Age — X25519 ECDH + ChaCha20-Poly1305 + HKDF. One algorithm choice, modern, no legacy modes. - PGP — RSA / ElGamal / ECDH (multiple curves) + AES-128/192/256 / IDEA / 3DES / Camellia. Decades of legacy options that recipients' implementations may or may not support. - Both are cryptographically sound at their default settings. Age has a smaller attack surface because it has fewer knobs. ## Identity and discovery Age identities are short ASCII strings: a public key looks like `age1ql3z7hjy54...` and the matching private key like `AGE-SECRET-KEY-1...`. There is no user ID, no email address, no expiry, no signature chain. Recipients exchange identities directly. PGP keys carry user IDs (name + email), creation dates, expiry, signatures from other keys, and can be looked up by email on key servers (`keys.openpgp.org`, WKD). The metadata is what enables features like "encrypt to alice@example.com without first asking Alice for her key" — but it is also what makes PGP key files large and the format complicated. ## Signing PGP signs. Age does not. Filippo's explicit position is that signing should be a separate tool (`signify`, `minisign`, `ssh-keygen -Y sign`). The argument is that mixing encryption and signing in one envelope is what made PGP's spec so big, and most users only need one of the two. If you need to verify "this file came from Alice and was not modified," PGP gives you that in one operation. With Age you encrypt with Age and sign with something else. Two tools, one each, no overlap. ## Ecosystem - PGP — every Linux distro, every mail client that supports E2E, GitHub commit signing, package signing (apt, dnf), Keybase, decades of recipients who already have a key. - Age — a single Go binary, a Rust port (`rage`), good Homebrew/apt packaging in modern distros, integration with `sops` for secrets management, growing but small. Recipients without Age installed cannot decrypt. ## Recommendation - Encrypting a file for a known technical recipient who has Age installed — Age. The format is small, the command is one line, the output is unambiguous. - Encrypting a file for someone you have not corresponded with before — PGP. Age requires an out-of-band identity exchange; PGP can use a published email-bound public key. - Email — PGP. Age has no email format and is not trying to. - Encrypting secrets in a Git-managed config repo — Age via `sops`. PGP is overkill and the metadata footprint is annoying. - Signing — neither tool covers both well. Use PGP if you want one tool for both, or pair Age with a dedicated signer (`minisign`, `ssh-keygen -Y sign`). Age is the right answer if your problem is "encrypt this for a person I already have an identity for." PGP is the right answer if your problem is "encrypt this for a person I only have an email address for, or sign this so future readers can verify provenance." The two are not in competition; they are answers to different sentences. --- ## PGP vs Signal — different threat models, not competing tools URL: https://pgptool.dev/vs/pgp-vs-signal Reading time: 6 min > Signal is for real-time chat with forward secrecy. PGP is for store-and-forward messages and files with a long-term identity. The choice is rarely either-or. Signal protects the message you sent five minutes ago even if your phone gets seized tomorrow. PGP protects the message you sent five years ago as long as your private key passphrase has not leaked. Pick the wrong tool for the wrong job and you are protecting against the wrong attacker. ## The crypto sounds similar but is not Both encrypt end-to-end. Both use modern primitives (X25519, AES-256, HMAC, HKDF). The difference is what each one rotates. PGP uses a long-term keypair. The same private key decrypts everything you have ever received, going back as far as the key has existed. If that private key is compromised — copied off your laptop, extracted from a bad backup, decrypted because the passphrase was weak — every message you have ever received is exposed. Signal uses the Double Ratchet protocol. Every message uses a fresh key derived from the previous one and from a Diffie-Hellman exchange that runs continuously in the background. Capture today's phone state and you compromise today's and tomorrow's messages — but yesterday's messages, even ones you can still read in your own chat history, are encrypted under keys that no longer exist anywhere. This is forward secrecy: yesterday's ciphertext stays unreadable even after today's keys are compromised. PGP does not have it. Signal does. ## Threat models - PGP — defends against an attacker who reads the wire (network adversary, hostile mail server) but does not control your endpoint. Loses the moment your private key + passphrase is compromised, retroactively. - Signal — defends against the same plus an attacker who eventually compromises your endpoint. They get the messages from after the compromise; the entire backlog from before is still safe. - Both — fail if your endpoint is compromised in real-time (keylogger, screen recording). No crypto helps once the attacker is reading your screen. ## Operational shape Signal is real-time. Both parties need running clients with internet. Phone-number bound (with username support being added). Designed for chat, voice, video, and small file attachments. Messages can be set to disappear. Account is tied to a device, and recovery without backup is intentionally limited. PGP is store-and-forward. Send to someone offline; they decrypt when convenient. Email-friendly, file-friendly. No real-time guarantees. Account is your private key — back it up properly and you can decrypt your archive 20 years from now. ## Long-term identity PGP is the only common end-user crypto with a stable long-term public identity. Your `0xDEADBEEF` fingerprint can appear on a website, a business card, a `humans.txt` file, in commit signatures, and on a key server, and people can verify it years later. Signal usernames and safety numbers are tied to the current Signal account; if you re-install or switch devices the safety numbers change and contacts have to re-verify. Concretely: a journalist publishes a PGP fingerprint on their newspaper bio for sources to use. A code maintainer signs releases with PGP so reproducible-build verifiers can confirm provenance years later. Neither use case maps cleanly to Signal. ## Recommendation - Day-to-day chat with someone you trust — Signal. Forward secrecy is real and matters. - Sending an encrypted file or long-form message that the recipient will read at their leisure — PGP. - Receiving a message from a stranger via a published identity (sources, bug reports, key submissions) — PGP. - Signing a software release — PGP. Signal does not sign. - Verifying a sender's identity over years — PGP fingerprints. - Most security-conscious users use both. They are different shapes for different days. The wrong question is "which is better." The right question is "which threat model am I protecting against." If forward secrecy matters and you can require both parties to use Signal, use Signal. If you need long-term identity, file encryption, or email, use PGP. They overlap on the very narrow strip of "real-time chat between two technical users" — and on that strip, Signal wins handily. ---