Decrypt Text
Decrypt AES encrypted text with your password.
About Decrypt Text Online
Paste an AES ciphertext, supply the password it was encrypted with, and read the original message. This is the reverse of the Encrypt Text page and expects the same format: Base64 in OpenSSL's Salted__ envelope, decrypted with AES-256 in CBC mode. Everything runs in this tab — the ciphertext and the password are never transmitted.
What happens when you press Decrypt
The string is Base64-decoded, and the eight bytes of salt that follow the Salted__marker are read out. Your password and that salt are then run through MD5 to reconstruct the same 256-bit key and initialisation vector that were used to encrypt, and AES runs in reverse over the remaining bytes. The salt is why the password alone is not enough to derive the key, and why it has to travel with the ciphertext rather than being kept secret.
How failure is actually detected
Worth understanding, because it is not what most people assume. This format carries no authentication tag, so there is nothing to check a key against. A wrong password does not cause an error inside the cipher — it just produces different bytes. What the page detects is that those bytes do not form valid UTF-8 text, which is true for essentially any wrong key, and reports the failure on that basis. The practical consequences are that the check is a strong hint rather than a proof, and that a successful decryption tells you the password was almost certainly right but says nothing about whether the ciphertext was modified on its way to you.
Working through a failed decryption
Check the string before you blame the password. It must begin U2FsdGVkX1; if it does not, it is not this format and no password will help. Then confirm nothing was lost in transit — long Base64 strings get wrapped, truncated or have stray spaces inserted when they pass through chat apps, email clients and spreadsheet cells, and a single missing character is fatal. Only then consider the password, watching for a trailing space picked up by a copy, a different keyboard layout, or a passphrase that was retyped rather than pasted. If the ciphertext came from another program entirely, the key derivation almost certainly differs and this page cannot read it.
Compatibility
Anything produced by the Encrypt Text page decrypts here. So does OpenSSL output, provided it was created with the legacy MD5 digest rather than the SHA-256 that modern versions default to, since a different digest derives a different key from the same password. Ciphertext from GPG, age, 7-Zip, an encrypted ZIP, a password manager export or any AES-GCM implementation uses a different construction and will not open here — use the tool that created it.
Handling the result
Once decrypted, the plaintext is on your screen and, if you use the copy button, in your clipboard — which other applications can read. Nothing is stored by this page and no request is made at any point, so the only copies are the ones you make; closing the tab discards it. Two things this page deliberately cannot do: it will not attempt to guess a forgotten password, and it cannot verify who encrypted the message. For authenticity as well as secrecy, you need a signed or authenticated format rather than plain CBC.
Reads The OpenSSL Envelope
The salt is extracted from the Salted__ header and used to re-derive the same AES-256 key, so ciphertext from this site or from the OpenSSL command line in legacy MD5 mode both open here.
Tells You When It Did Not Work
Rather than presenting whatever bytes fell out of a wrong key, output that is not valid UTF-8 is reported as a failure — so you are never handed convincing-looking garbage and left to wonder.
Password Stays On Your Machine
Key derivation and decryption both run in this tab with no network call, so pasting a ciphertext and its password does not put either on a server, and nothing survives closing the page.
Frequently Asked Questions
What kind of string does this accept?
Base64 in OpenSSL's Salted__ envelope — the format produced by the Encrypt Text page and by the OpenSSL command line in its legacy mode. In practice that means a string beginning U2FsdGVkX1, which is just Base64 for the word Salted__. If your ciphertext does not start that way it came from a different scheme and will not decrypt here.
It says decryption failed. What went wrong?
Four things produce that message and they are worth separating. The password is wrong — by far the most common. The ciphertext was truncated or had characters added when it was copied, which happens easily when a long string is pasted through a chat client that inserts line breaks. The string came from a different tool using a different key derivation. Or it is not this format at all. Check first that the whole string is present and starts with U2FsdGVkX1.
How does it know the password was wrong?
Indirectly, and this is a real limitation. There is no authentication tag to verify against, so a wrong password simply produces different bytes. What the tool actually detects is that those bytes are not valid UTF-8 text, which is overwhelmingly the case for wrong-key output — so it reports a failure. It follows that the check is a heuristic, not proof: it cannot tell you a decryption is correct, only that it plausibly is.
Why does the same ciphertext look different from a friend's, for the same message?
Because a random salt is generated at encryption time and included in the envelope. Two encryptions of identical text with an identical password produce entirely different strings, and both decrypt correctly. If you are comparing two ciphertexts to check whether they hold the same message, that comparison will not work — and preventing exactly that inference is why the salt exists.
Can this brute-force a password I have forgotten?
No. There is no guessing, no wordlist and no recovery of any kind — you supply one password and it either yields readable text or it does not. If the password is genuinely lost, the message is unrecoverable, because nothing about it is stored anywhere for anyone to look up.
Does a successful decryption prove the message is genuine?
No. This format provides confidentiality without integrity: there is no message authentication code and no signature, so nothing establishes that the ciphertext reached you unaltered or that it came from the person you expect. Someone able to modify the string in transit can change the plaintext you see. Where that matters, you need an authenticated mode such as AES-GCM or a separate signature over the message.
Can I decrypt something encrypted by another program?
Only if it used the same construction: AES-256-CBC, the OpenSSL Salted__ envelope, and MD5-based key derivation with one iteration. OpenSSL's own output qualifies when it was produced with the legacy MD5 digest — current versions default to SHA-256, which derives a different key and will fail here. Anything from GPG, age, 7-Zip, a password manager or an authenticated AES-GCM implementation will not decrypt on this page.
Is it safe to paste sensitive ciphertext and a password here?
The processing itself is local — a JavaScript crypto library running in this tab, with no request made, nothing logged and nothing stored. The residual risks are the ordinary local ones: the plaintext appears on your screen, it sits in your clipboard if you copy it, and it lives in the page until you navigate away. Close the tab when you are done, and avoid doing this on a shared or screen-shared machine.