AES Encrypt / Decrypt
AES has been the standard symmetric cipher since NIST adopted it in 2001, and the algorithm itself is not where things go wrong — the mode, the IV, and the key handling are. This tool exposes all three so you can see exactly how each choice changes the ciphertext.
Why ECB leaks patterns
In ECB mode, every 16-byte block is encrypted independently, so identical plaintext blocks produce identical ciphertext blocks. Encrypt the 32-byte string ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP with the key "secret" at 128 bits and look at the ciphertext in hex: the first two blocks are both 78e4b365b763dab62e82ce6c1bc4033d — byte-for-byte identical. An attacker who never learns your key can still see that block 1 equals block 2, which is exactly how the famous ECB-encrypted Linux penguin image stays recognizable. Switch the same input to CBC and the second block becomes 8504648ce78c686202792f187622e794, because CBC XORs each plaintext block with the previous ciphertext block before encrypting.
One CBC caveat specific to this tool: if you leave the IV field blank, it uses an all-zero IV. With a zero IV, the first CBC block is computed on unmodified plaintext, so it comes out identical to the first ECB block (78e4b365... in the example above), and encrypting the same message twice gives the same ciphertext both times. That determinism is fine for testing round-trips, but real systems generate a fresh random IV per message and transmit it alongside the ciphertext.
What key padding does to short keys
AES-256 needs exactly 32 key bytes, but you can type a key of any length here. Short keys are right-padded with the character "0" (the digit, byte 0x30), and long keys are truncated to size. The non-obvious consequence: the keys "mykey" and "mykey0" pad to the same 32 bytes and produce identical ciphertext — a trailing literal zero in your key is indistinguishable from padding. It also means a 5-character key padded to 256 bits is still a 5-character key to anyone guessing; production systems derive keys from passphrases with a KDF like PBKDF2 or Argon2 instead. If you need ciphertext that another system can decrypt, confirm how that system turns your passphrase into key bytes, because "same password" does not mean "same key".
Reading the output and the failure cases
Output is Base64 of the raw ciphertext with PKCS#7 padding, so ciphertext length is always a multiple of 16 bytes: a 13-byte message becomes one 16-byte block (24 Base64 characters), and exactly 16 bytes becomes two blocks (44 Base64 characters), because PKCS#7 always appends at least one padding byte. On decrypt, a wrong key, mode, or IV surfaces as the single error "Decryption failed — wrong key, IV, or corrupted data" — the tool cannot tell you which of the three it was, so check the mode and key size selections first, since they silently change the key material. If the decrypted payload is a JSON object or array, the output pane switches to a collapsible JSON view automatically.
Questions people ask
Why doesn't the ciphertext change when I encrypt the same plaintext again?
It is expected with this tool's defaults: ECB is deterministic by design, and CBC with a blank IV field uses a zero IV, which is also deterministic. Real deployments use a random IV per message precisely so repeated plaintexts do not produce repeated ciphertexts. Type a different IV and the output changes completely.
Ciphertext from my Java/Python service will not decrypt here. Why?
Symmetric interop fails on any mismatch in mode, IV handling, padding, or key derivation. The most common culprit is key derivation: this tool uses your typed characters padded with "0" as the raw key, while most libraries run the passphrase through a KDF, producing entirely different key bytes from the same password. Match the raw key bytes, mode, and IV and it will round-trip.