Security Tool · Runs Offline
Generate an OpenPGP key pair, sign a message, and confirm that a signed message really came from who it claims — entirely inside this page. The cryptography library is embedded in the file itself. Save it, disconnect the network, and everything still works.
Signing proves who wrote a message and that nobody altered it in transit. It needs no connection, no account, and no third party — only a key pair and a browser.
Create a key pair. The public half is for everyone; the private half never leaves your machine. Download both, plus a revocation certificate.
Attach a signature to a message with your private key — either wrapped around the text, or as a separate detached signature block.
Given a signed message and the sender's public key, confirm the signature is valid, identify the signing key, and see when it was made.
A signature you can check without asking anyone's permission.
Nothing entered below is transmitted anywhere. Keys, passphrases, and message text stay in browser memory and are gone when the tab closes — so download anything you want to keep.
A key pair is generated locally using your browser's cryptographic random number generator. The public key is what you publish or send to people who need to check your signatures. The private key is the secret that signs — protect it with a passphrase and keep it off shared machines.
Downloaded keys land in your normal downloads folder as plain text. Move the private key somewhere you actually control — an encrypted volume, a password manager, or a hardware-backed keystore — and remove the copy in Downloads.
For keys that protect production systems, generate them on a machine that has never been on a public network.
Signing binds your identity to an exact sequence of bytes. Change one character afterwards and the signature stops verifying. Use a cleartext signature when the reader should see the message and the proof together; use a detached signature when the message or file must stay byte-for-byte unchanged.
A valid signature proves two things: the message was signed by the holder of that private key, and it has not been modified since. It does not prove the key belongs to the person named on it — that comes from how you obtained the key, which is why fingerprints are confirmed out of band.
The OpenPGP implementation is compiled into this page rather than fetched from a content delivery network. Once the HTML is on disk, the page has no runtime dependency on anything but the browser.
The only outbound requests this page makes are the Google Fonts stylesheet and font files referenced in the header. Block them and the page renders in fallback fonts with every function intact.
crypto.getRandomValues.Embedded library
library : OpenPGP.js v6.3.1 sha-256 : 2de052b91cc461387a247f66c3cd46c42fc5e826634b300d760bc86ad06c730a source : https://openpgpjs.org licence : LGPL-3.0Extract the embedded script block from this file and hash it to confirm it matches the release you expect.
Three artefacts come out of key generation. Confusing them is the most common way people lose control of an identity.
| File | What it is | Who may hold it | If it leaks |
|---|---|---|---|
| public.asc | The half that checks your signatures and encrypts to you. | Anyone — publish it freely. | No impact. Publication is the point. |
| private.asc | The half that signs and decrypts. Passphrase-encrypted if you set one. | You alone. | Anyone can sign as you. Revoke immediately and issue a new key. |
| revocation.asc | A pre-signed statement that the key is no longer valid. | You — stored apart from the private key. | Someone can retire your key. Disruptive, not catastrophic. |
A public key is only useful if the person checking your signature has the right public key. Publishing its hash in a TXT record on a domain you control gives them a second path to confirm that — one that does not depend on the mailbox, chat, or website the key arrived through. The generator produces the record for you.
pgp.example.com. 3600 IN TXT "v=pgp1; fp=<fingerprint>; sha256=<key-hash>; uid=you@example.com" # recipient checks the key they were given against the record dig +short TXT pgp.example.com gpg --dearmor < public.asc | shasum -a 256The hash covers the binary key packets — the bytes inside the ASCII armor — so it stays the same however the armor was reflowed. Dearmor the key file to reproduce it; gpg --export re-serialises the key on the way out and will produce a different hash. Publish the fingerprint alongside it: the fingerprint identifies the key, the hash pins the exact bytes, including every user ID and self-signature attached to it. Recompute and update the record whenever the key changes — extending an expiry or adding a user ID changes the packets and therefore the hash. If the zone is DNSSEC-signed, the record is authenticated end to end; if it is not, treat it as a strong corroborating signal rather than proof.
The mathematics is not the weak point. Key handling is.
Signing is the cheapest form of cryptographic identity available — no infrastructure, no certificate authority, no negotiation.
When a channel may be compromised, a signed notice tells recipients which instructions are real. Distribute the public key before the incident, not during it.
Detached signatures over build artefacts let anyone confirm what you shipped, independent of the host serving the download.
A signed change request carries its own proof of origin, so an approver can act on it without a callback to confirm the sender.
Import with gpg --import public.asc and check with gpg --verify. Nothing here is a proprietary format.
Message-level signing shares the instinct behind self-sovereign identity: authority attaches to keys you control, not to a platform account.
An automated sender can hold its own key pair, so an agent's output carries provenance that survives forwarding, quoting, and rendering.
Everything above works as loaded. But the strongest version of this is a copy on a machine that has never touched a network — then the guarantee rests on a file you hold and can hash, not on trusting this site at the moment you happen to use it.
Press Ctrl/Cmd + S and choose "Webpage, HTML Only" — in Safari, "Page Source". Everything is inline, so the single .html is the whole tool; there is no assets folder to keep beside it. Avoid Chrome's "Single File" option: it writes .mhtml, which other browsers will not open.
Downloading it that way gets the exact bytes the server sent, which makes the next step meaningful.
Record the digest of the file so you can tell later whether your copy changed. Open it in a text editor and confirm the OpenPGP.js banner comment near the end is intact.
shasum -a 256 entityos-message.htmlCopy the file to a USB stick and move it to the offline machine. That machine never needs a connection again — not to install anything, not to run this page, not to generate or use a key.
Turn off Wi-Fi, or work on a machine that has never been connected — an old laptop or a live USB session is ideal. Double-click the file. It loads over file://, the fonts fall back to system defaults, and the tag at the top of the page reads "Network off · still working". Every function behaves identically.
Do the key work there. Download the public key, private key, revocation certificate, and the DNS record document — they land in the offline machine's downloads folder, which is exactly where you want them.
Move the public key, the signatures, and the .md record to the networked world. Keep the private key on the offline machine or on encrypted removable storage. A private key generated on an air-gapped machine loses its advantage the moment it is copied onto a connected one.
Nothing about this page needs to be trusted on faith. It makes no network calls, stores nothing, and carries its own cryptography — so you can read it, hash it, keep it, and run it years from now on a machine with no internet at all.
That is the whole point: a copy you hold, producing signatures anyone can check, with no service in the middle that has to still exist.