Sign something, or check who signed it
Produce a detached signature over text or a file with a private key, or verify one against a public key. A signature proves the holder of a particular private key approved these exact bytes — it does not hide them.
Processed locally in your browserNothing you enter here is uploaded, logged or sent to any server.
Think carefully before pasting a private key into any web page
Including this one. Everything here happens in your browser and nothing is transmitted — you can confirm that in the network tab — but the general habit is a bad one, because the next page that asks will look identical and may not be honest.
For a key that matters, use a tool on your own machine: openssl dgst -sha256 -sign key.pem, ssh-keygen -Y sign, gpg --detach-sign, or your language's standard library. This page is for keys generated here, for learning how signatures work, and for verification — which only ever needs the public key and is entirely safe.
What a valid signature does and does not establish
It establishes that whoever holds the private key matching this public key produced a signature over exactly these bytes, and that nothing has changed since. One flipped bit anywhere and it fails.
It does not establish who that person is. A signature ties content to a key, not to a name. Deciding that a particular key belongs to a particular person is a separate problem, and it is the hard one — solved by certificate authorities, key servers, fingerprint comparison in person, or trust decisions you make yourself. This page verifies the arithmetic; it cannot tell you whose key you pasted.
It does not encrypt anything. The content is exactly as readable after signing as before. Signing and encrypting are different operations that people routinely conflate — a signature is a claim about content, not a wrapper around it.
It says nothing about when. Signatures carry no time. If it matters that something was signed before a particular date, that requires a timestamp from somebody you trust, signed separately.
Detached signatures, and why the bytes must match exactly
The signature produced here is detached — a separate value that travels alongside the content rather than being wrapped around it. That keeps the original file usable by everything that could use it before.
The cost is that verification needs the content back byte for byte. A text editor that converts line endings, a mail client that rewraps paragraphs, or an editor that adds a trailing newline will all break a signature that was perfectly valid, and the failure looks exactly like tampering. When verification fails on something you believe is genuine, this is nearly always why.
What this tool does not claim
No tool on this site is described as unbreakable, military grade, or completely secure, because none of those phrases means anything a person could check. What is written down instead is which standard is used, which library implements it, and what the tool has been tested against.
Everything here runs in your browser using its built-in Web Crypto implementation. Nothing is uploaded, and there is no server that could receive it. That is a real and checkable property — open your browser's network tab and use the tool.
Signature or HMAC?
Use a signature when the two sides should not share a secret — when you publish something many people verify, or when it matters that only one party could have produced it. Only the private key holder can sign; anyone with the public key can check.
Use an HMAC when both sides already share a key and you only need to know the message is authentic between you. It is far faster and the tags are shorter, but either party could have produced any tag, so it establishes nothing about which.
Which algorithm
ECDSA P-256 unless something else is required. Small keys, 64-byte signatures, fast, and supported everywhere.
Ed25519 is the better modern design — deterministic, so the same key and message always produce the same signature, which removes a whole class of implementation failure. Browser support is recent, so it is offered only where available.
RSA is here because so much existing software expects it. Signatures are four to eight times larger and generation is far slower, with no security advantage at comparable strength.
Related
The key pair generator makes a key to use here, the key inspector reads one somebody sent you, and HMAC covers the shared-secret case.
Questions people actually ask
Should I paste my private key here?
Think about it first. Everything happens in your browser and nothing is transmitted — you can confirm that in the network tab — but the habit is a bad one, because the next site that asks will look identical and may not be honest. For a key that matters, use openssl, ssh-keygen -Y sign, gpg, or your language's standard library on your own machine. Verification only ever needs the public key and is entirely safe.
Does a valid signature tell me who signed it?
No. It tells you that whoever holds the private key matching the public key you supplied signed exactly those bytes. Connecting that key to a person is a separate problem — and the harder one. Certificate authorities, key servers and comparing fingerprints in person all exist to address it; arithmetic cannot.
Does signing encrypt my file?
No. The content is exactly as readable afterwards as before. A signature is a claim about content, not a wrapper around it. If you want something unreadable, use file encryption; if you want both, sign and then encrypt.
Verification fails but I am sure the file is genuine.
Almost always the bytes have changed. A text editor converting line endings, a mail client rewrapping paragraphs, an editor adding a trailing newline, or an archive being repacked will all break a valid signature, and the failure is indistinguishable from tampering. Check the file size against the original first.
Which algorithm should I choose?
ECDSA P-256 unless something else is required — small keys, 64-byte signatures, universally supported. Ed25519 is the better modern design and is offered where the browser supports it. RSA is included because so much software expects it, at four to eight times the signature size and much slower generation.
Does the signature say when it was made?
No. Signatures carry no time at all. If it matters that something was signed before a particular date, you need a timestamp from a party you trust, signed separately.