Cryptor (AES-256) — Manual

Back to overview: Cryptor (AES-256) · Open the live tool: www.jpkc.com/tools/cryptor/

This manual describes Cryptor (AES-256) in full: how the interface is laid out, which crypto parameters apply exactly, what each button does, which older formats the tool still reads, and what limits browser-based operation brings. The labels appear here exactly as they do in the tool, so you can find your way around the real interface.

Interface layout

Cryptor has two columns and a full-width card below them:

Input (left) — the password field (Password) with three buttons (show, copy, generate), the repeat field (Repeat password) below it, and a large text area (Message) for plaintext or ciphertext.
Encryption (top right) — the Encrypt and Decrypt buttons plus a status line that, after encrypting or decrypting, reports the algorithm or the detected format, the iteration count (except for the legacy format), and the duration.
Message (bottom right) — Copy, Open, Save, Undo, and Clear for the text area's content.
Format & decrypting without this tool (bottom, full width) — a description of the output format and ready-made decryption scripts for Node.js, Python, PHP, and OpenSSL.

The hint below the password field — "Used for both encryption and decryption. Without it, encrypted text cannot be recovered." — captures the core principle: there is just one password, used both to encrypt and to decrypt. Lose it, and the ciphertext is no longer readable.

The Message field does double duty: it holds either the plaintext you want to encrypt or the ciphertext you want to decrypt. The result of an action replaces the field's content — and Undo brings back what was there before.

Workflow

The typical workflow has three steps:

Set a password — type your own (then repeat it in Repeat password as a check) or have one generated via the key button.
Enter text — plaintext (to encrypt) or ciphertext (to decrypt) in the Message field, typed, loaded with Open, or dropped in from a file.
Choose an action — Encrypt or Decrypt, or simply Ctrl+Enter. The result appears in the same field and can be copied or saved.

On load, Cryptor checks whether the browser supports the Web Crypto API (crypto.subtle) and web workers. If either is missing, you see "Your browser does not support modern encryption (Web Crypto API). Please use a current browser over HTTPS." and the action buttons (Encrypt, Decrypt, Copy, Open, Save, Clear) stay disabled.

Crypto parameters in detail

Cryptor's encryption uses the browser's Web Crypto API (crypto.subtle). It runs in a dedicated web worker (a background thread), so the page stays responsive even with large texts. The parameters are hard-wired.

AES-256-GCM

The algorithm is AES with a 256-bit key in GCM mode (Galois/Counter Mode). GCM is an authenticated encryption (AEAD): alongside the ciphertext it produces a 128-bit authentication tag. During decryption the browser verifies this tag — if it doesn't match (wrong password, tampered or corrupted ciphertext), decryption fails instead of returning faulty plaintext.

On top of that, Cryptor binds the format header (e.g. cryptor:v2:600000:) to the ciphertext as additional authenticated data (AAD). The header is readable but protected: change the iteration count in it, and the tag check fails.

PBKDF2 key derivation

The actual 32-byte key is derived from your password (encoded as UTF-8) via PBKDF2-HMAC-SHA256 with 600,000 iterations. The high count is deliberate: it slows down each individual derivation attempt and thereby makes systematic password guessing expensive. Older texts in format v1 still use 100,000 or 300,000 iterations (see Format v1).

Salt and IV

Before every encryption, Cryptor generates two random values from the browser's cryptographically secure generator (crypto.getRandomValues):

a salt of 16 bytes (128 bits) — it feeds into the PBKDF2 derivation, so the same password yields a different key every time;
an IV (initialization vector) of 12 bytes (96 bits) — the usual length for GCM.

Because the salt and IV are newly random on every run, the same text with the same password produces a different ciphertext each time. That is intentional and a sign of correct cryptography.

Output format

The current format is called v2. The ciphertext consists of a readable header followed by a Base64 block:

cryptor:v2:<iterations>:Base64( salt[16] ‖ iv[12] ‖ ciphertext ‖ GCM tag[16] )

key = PBKDF2-HMAC-SHA256( password as UTF-8, salt, iterations, 32 bytes )
AES-256-GCM, additional authenticated data = header incl. last colon, e.g. "cryptor:v2:600000:"

A freshly encrypted text therefore always starts with cryptor:v2:600000:. The salt and IV travel inside the ciphertext — they need not be secret and are required for decryption. The 16-byte tag is appended by GCM.

A few rules make the format robust when decrypting:

Spaces and line breaks in the ciphertext are stripped before parsing. If a mail client wraps the block across lines, no harm done.
An iteration count in the header outside 1,000 to 10,000,000 is rejected as invalid — a crafted header can't keep your browser busy for minutes.
If the header carries a higher version number than the tool knows (say cryptor:v3:), Cryptor reports "Format version 3 is newer than this tool."
If the block is shorter than salt + IV + tag + at least one byte, you get "The encrypted text is incomplete (too short)."

The plaintext, on the other hand, is encrypted exactly as it sits in the field — leading and trailing spaces and blank lines are preserved.

The actions in detail

Encrypt

Encrypts the Message field's content with the password. Preconditions the tool checks:

There must be text (otherwise "Please enter a message to encrypt.").
There must be a password (otherwise "Please enter a password or generate one.").
The password must be at least 8 characters long (otherwise "The password should be at least 8 characters long.").
If the password is hidden, it must be repeated identically in Repeat password (otherwise "The two passwords do not match." or, if the repeat field is empty, "Please repeat the password (or show it to check it)."). With the password shown, this check is skipped.
If the content already looks like ciphertext, Cryptor asks first: "This already looks encrypted. Encrypt it again?"

While computing, the button reads "Encrypting…" with a spinner, and the other action buttons are locked. Afterwards the ciphertext sits in the Message field, the status line reports something like "Encrypted · AES-256-GCM · 600,000 iterations · 0.42 s", and a notice confirms "Message encrypted.".

Decrypt

Decrypts the Message field's content with the password. Preconditions:

There must be text (otherwise "Please paste the encrypted text first.").
The text must be recognizable as Cryptor ciphertext (otherwise "This is not encrypted text from Cryptor (or it was damaged while copying).").
There must be a password (otherwise "Please enter the password."). Decrypting needs neither the minimum length nor the repeat field.

Cryptor detects the format automatically:

the text starts with cryptor: → format v2 (current);
it starts with U2FsdGVkX1 (Base64 for Salted__) → legacy format;
it's bare Base64 without a header (at least 60 characters) → format v1.

On success the plaintext replaces the field content, and the status line names the detected format, the iteration count (except for the legacy format), and the duration, e.g. "Decrypted · format v2 · 600,000 iterations · 0.40 s". For v2 you see "Message decrypted."; for an older format, the hint "Decrypted an older format. Encrypt it again to upgrade it to the current, stronger format."

If decryption fails, "Wrong password — or the encrypted text was changed or is incomplete." appears and the field content stays unchanged. A wrong password and a damaged text are technically indistinguishable — for v2 and v1, the authentication tag doesn't match in either case. Legacy texts have no such tag: a wrong password shows up there through the padding and UTF-8 checks, but Cryptor can't reliably detect changes to the text.

Generate a password

The key-icon button (tooltip "Generate a password") opens a menu headed "Generated in your browser" with four entries:

Entry	Result	Strength
Password · 32 characters	32 random characters	≈ 202 bits
Password · 64 characters	64 random characters	≈ 403 bits
Passphrase · 6 words	6 words joined with `-`	≈ 78 bits
Passphrase · 8 words	8 words joined with `-`	≈ 103 bits

Everything is generated in the browser with crypto.getRandomValues and uniform selection (no modulo bias) — no request goes to the server. Character passwords draw from a set of 79 printable ASCII characters: lower- and uppercase letters, digits, and , . - ; _ # + * ! $ % & / ( ) = ?. The set is deliberately ASCII-only so the password can be typed on any keyboard. Passphrases come from the EFF word list (7,776 English words), which the tool loads only the first time you need it — for example crumb-velvet-unfold-stucco-lagoon-ripple.

After generating, the password is shown, the repeat field is emptied and hidden, and a notice reminds you to store the password safely. Generating can be reverted with Undo, too.

Show, repeat, and copy the password

Show password / Hide password (eye button) — toggles the password field between hidden (dots) and plain text. It's hidden by default.
Repeat password — appears only while the password is hidden. It guards against a typo you can't see, which would make the text unrecoverable. When encrypting it must match; with the password shown, it's not needed.
Copy password — copies the password to the clipboard ("Password copied."), even while it's hidden. If the field is empty, you get "There is no password to copy.".

Autocomplete and spell checking are switched off on the password and text fields; the password fields also carry attributes that keep 1Password and LastPass from offering stored credentials there.

Password strength

Above the password field, on the right, Cryptor shows a strength badge with a bit value. The levels:

Bits	Badge
below 40	weak
40 to below 60	fair
60 to below 80	strong
80 and up	very strong

For generated passwords the figure is exact (length × information per character or word). For typed passwords it's followed by "(estimate)": Cryptor estimates from the character classes used and the length, caps repeated characters, and rates common base words such as password, qwerty, or summer — even with digits or symbols tacked on — at just 15 bits. Strings of only digits or symbols shorter than 12 characters top out at 20 bits. Self-invented word passphrases tend to be overrated by the character-based estimate; treat the badge as a guide, not a guarantee.

Copy

Copies the current Message field content to the clipboard. If the field is empty, "Nothing to copy." appears.

Open, Save, Clear

The Message card bundles file handling:

Open opens a file dialog (suggesting .txt, .enc, .aes, and text files) and loads the content as UTF-8 into the Message field ("Loaded: filename"). Files over 20 MB are refused. If the first 8 KB of the file contain null bytes or the file isn't valid UTF-8, you get "… is not a text file. Cryptor encrypts text only." — reading a binary file as text would otherwise destroy it. A byte order mark at the start of the file is removed.
Save downloads the field content as a UTF-8 text file. If Cryptor recognizes ciphertext, the file is named encrypted.txt, otherwise plaintext.txt. If the field is empty, you get "Nothing to save.".
Clear asks first ("Clear message and password? Undo restores them.") and then wipes the Message field, the password, and the repeat field. If everything is already empty, Cryptor says "Everything is already empty.".

Undo

Because Cryptor fills the text area by script, the browser's own undo history would be empty afterwards. So the tool keeps its own history of up to 20 steps. A snapshot is taken before every encrypt, decrypt, file open or drop, clear, and password generation — covering the message, the password, and the repeat field together.

Undo restores the previous state ("Restored the previous state."). The button is greyed out while there's nothing to undo.
Ctrl+Z (Mac: Cmd+Z) does the same when focus is outside the input fields, or when the Message field still holds the last result unchanged. Once you've typed in the field, the browser's normal undo takes over again.

The history lives only in the tab's memory — it's gone after a reload.

Keyboard shortcuts

Ctrl+Enter (Mac: Cmd+Enter) in the Message, password, or repeat field: if Cryptor recognizes ciphertext, it decrypts; otherwise it encrypts.
Ctrl+Z: undo as described above.

Drag and drop

You can drag and drop a file directly onto the Message field; it's loaded and checked just as with Open ("Dropped: filename"). While you drag a file over the field, it highlights. Drag selected text in instead of a file, and the browser's normal behavior applies.

Format & decrypting without this tool

The card at the bottom of the page makes Cryptor independent of itself: it describes the format (see Output format) and provides short scripts in four tabs that decrypt a text without this website. Each tab has a copy button.

Tab	Requirement	Usage
Node.js	Node.js 18+, no packages	save as `decrypt.mjs`, run `node decrypt.mjs message.txt`
Python	Python 3 with `pip install cryptography`	save as `decrypt.py`, run `python3 decrypt.py message.txt`
PHP	PHP 7.1+ with the OpenSSL extension	save as `decrypt.php`, run `php decrypt.php message.txt`
Older formats	OpenSSL	command for the legacy format, see below

The three scripts read the file, strip whitespace, prompt for the password, and print the plaintext. They understand format v2.

Format v1 (January to October 2026)

Texts Cryptor produced between January and October 2026 are bare Base64 without a header — same layout (salt, IV, ciphertext, tag), but without AAD. Until 15 March 2026 they were encrypted with 100,000 PBKDF2 iterations, after that with 300,000. Since the count wasn't stored in the text, Cryptor tries both values in turn when decrypting; the GCM tag rules out false matches. That makes the early v1 texts readable again, too. The flip side: with a wrong password, Cryptor works through both variants before the error message appears.

Legacy format (gibberish-aes)

Even older texts (from before 2026) start with U2FsdGVkX1 and follow OpenSSL's Salted__ format: AES-256-CBC with key and IV from EVP_BytesToKey with MD5. They were produced back then by the gibberish-aes library; today Cryptor decrypts them via the Web Crypto API (AES-CBC) and an MD5 implementation from noble-hashes — the old library is no longer on board.

In doing so, Cryptor checks the complete padding and requires valid UTF-8 as the result. A wrong password therefore reliably ends in the error message instead of a seemingly "decrypted" jumble of characters.

Without Cryptor, you decrypt such texts with OpenSSL:

openssl enc -d -aes-256-cbc -md md5 -a -in message.txt

New encryption only ever uses format v2. Cryptor can still read v1 and legacy, but no longer produce them.

API: a password via `curl`

For scripts, Cryptor offers a small endpoint that the page itself does not use:

curl https://www.jpkc.com/tools/cryptor/pw/32/

Response: a random password of the requested length as text/plain, with Cache-Control: no-store. It's generated server-side with PHP's random_int from the same 79-character set as in the browser.
Length: 1 to 64. Anything else (non-digits, 0, 65 …) gets a 404 with the hint "Usage: /tools/cryptor/pw/{length}/ with a length from 1 to 64".
Rate limit: 120 requests per 60 seconds per IP address; beyond that you get 429 with a Retry-After header.

Operating limits and privacy

Client-side: encryption, decryption, and password generation run entirely in the browser. Plaintext, password, and ciphertext never leave it. Only static files are fetched: the crypto worker and its modules on the first encryption or decryption, and the EFF word list once you generate a passphrase — without any data of yours.
Secure context required: the Web Crypto API requires HTTPS (or localhost). Without it, or without web worker support, the action buttons stay disabled.
Text only: Cryptor encrypts text. Binary files are refused, and files are capped at 20 MB.
No history: Cryptor deliberately stores nothing — no history, no local cache of content. Reloading means: empty fields, empty undo history.
Password minimum length: 8 characters to encrypt.
No key recovery: without the correct password there is no way back to the plaintext — that is the whole point, but also the biggest pitfall.

For the introduction and target audiences see the overview page. Concrete walkthroughs are in the examples, strategy and pitfalls in the tips & tricks. You can try everything directly in the tool.