Start typing to search this publication.
I fixed PGP
Open menu

Subscribe to I fixed PGP

Get new posts delivered straight to your inbox.

PGP Is 35 Years Old.

I Finally Fixed the UX.

0x3Ed69C55EC582c64f6f368Be81F8f5791CF365dB
4 min read
Cover image for PGP Is 35 Years Old.

PGP has existed since 1991. Thirty-five years. It's still the gold standard for encrypted email, and almost nobody uses it.

Not because the cryptography is weak. Not because the threat model is wrong. Because the user experience has been broken for three decades in two specific ways that nobody managed to solve. Until now.


What Killed PGP

Problem 1: Key discovery.

How do you find someone's public key? For years, the answer was keyserver, the SKS network, MIT's server, pgp.mit.edu. Those collapsed. The replacements (Web Key Directory, WKD) are technically sound but obscure. The fallback was always the same: DM the person. "Hey, what's your public key?" Exchange fingerprints. Verify out-of-band. And hope.

Most people never got past that step. They opened their email client, realised they needed someone else's public key to send an encrypted message, and closed the window forever.

Problem 2: Key management.

Even if you found the key, you had to manage your own. Generate a key pair. Choose a passphrase. Store the private key somewhere safe. Back it up. Pray your hard drive doesn't die. Try to remember the passphrase six months later. Hope nobody steals the file.

This is not how normal people interact with software. This is how sysadmins interact with SSH keys. Normal people don't have sysadmin skills. So normal people didn't use PGP.

Thirty years of the best cryptographic protocol for email privacy, defeated by two UX problems.


What Changed

I've been building encrypted communications infrastructure on bare metal for the better part of a year. The core protocol nftmail.box, routes encrypted messages through a relay that physically cannot read the payload. No SMTP. No DNS for identity resolution. Your NFT is your address.

PGP interop was always on the roadmap, but it wasn't the priority. The native protocol uses ECIES encryption, which is more modern and doesn't carry PGP's key-management baggage. But the world runs on email, and a lot of email runs on PGP. If encrypted comms are going to reach normal people, PGP has to work.

So I fixed the two problems.


Solution 1: On-Chain Identity as Keyserver

Your public PGP key is stored on-chain as metadata on your ERC-8004 agent identity. Anyone can resolve alice@nftmail.box to a public key by reading the identity registry.

No keyserver. No fingerprint verification dance. No DMs asking "hey what's your key." The key is bound to an identity you can prove you control — your wallet, your NFT, your on-chain record. If you control the identity, you control the key. If you transfer the identity, the key follows.

This is a decentralised PGP keyserver keyed to human-readable identity. It doesn't require trusting a third party to serve the correct key. It doesn't require manual fingerprint verification. The binding is on-chain, verifiable, and self-sovereign.


Solution 2: Wallet as Key Custody

The private key is derived from a wallet signature. You don't generate it. You don't store it. You don't back it up.

Here's the flow:

  1. You click "Enable PGP Encryption" in your dashboard.

  2. Your wallet prompts you to sign a message.

  3. The signature deterministically derives your PGP keypair.

  4. The private key is wrapped with that same signature and stored encrypted on the relay.

  5. To decrypt a message, you sign again. The key unlocks client-side, in your browser.

  6. The server never sees the private key. Ever.

If you lose your device, you recover by signing with the same wallet on a new device. If you change wallets, you provision a new key. There is no key file to lose. No passphrase to forget. No backup to maintain. Your wallet (the same one you already use) is your key custody.

Inbound PGP email is auto-detected. The message list shows a 🔒 badge. One click. "Decrypt with Wallet." The plaintext appears. That's it.


Why This Matters

This isn't a whitepaper. It's running code on bare metal at nftmail.box.

The private key never touches the server. The relay stores the wrapped key, encrypted noise without the wallet signature. The operator physically cannot decrypt your mail, even with root access to the machine.

This is the same operator-blind architecture that powers the native ECIES protocol. Applied to a thirty-year-old standard that everyone wanted to use and nobody could.

ProtonMail made PGP usable inside a walled garden. Yes, Proton-to-Proton encryption works great, but the moment you email someone outside Proton, the message is plaintext. This is different. This is interoperable PGP with key discovery and key management solved at the protocol level. Anyone with a PGP client can encrypt to an @nftmail.box address. Anyone with an @nftmail.box address can decrypt with their wallet.


What's Next

The PGP interop is phase one. The native ECIES protocol, where the encryption is built into the relay from the ground up, with no legacy compatibility constraints, is running in parallel. PGP today. ECIES-native tomorrow.

The broader vision is Pipes: encrypted coordination infrastructure for Gnosis Safe signers. DAOs with nine-figure treasuries coordinate transactions over Telegram and Discord — channels that leak metadata, aren't cryptographically bound to signer identity, and require manual offboarding when signers rotate. Pipes replaces that with the same operator-blind, NFT-gated architecture that powers nftmail.box. Quorum tracking. Automatic signer rotation. Gnosis VPN-compatible transport for network-level metadata protection.

I'm drafting a GIP (Gnosis Improvement Proposal) to fund the Safe module integration, security audit, and open-source release. The PGP interop and the ECIES relay are the proof that the encryption stack works. Pipes is the enterprise layer that inherits it.


The 35-Year Lesson

PGP failed because cryptography is necessary but not sufficient. You can have the strongest encryption in the world, and if normal people can't find keys or manage their own, they won't use it. The protocol was right. The UX was wrong.

Key discovery belongs on-chain. Key custody belongs in the wallet. The server should never touch the private key.

It took thirty-five years. It's running now.


nftmail.box — encrypted comms where the server can't read your messages. PGP today. ECIES-native tomorrow. Pipes for Safe signers incoming

Subscribe to I fixed PGP