Skip to content

Crypto & Security

Hash, encrypt and generate secure passwords locally.

Crypto & Security covers three different jobs that look similar from the outside. Hashing — MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 and HMAC — produces a fixed-length fingerprint. Encryption — AES Encrypt and AES Decrypt — is reversible with a password. Checksums — CRC32, CRC8 and Adler-32 — detect accidental corruption. Alongside them sit Password Strength, Password Entropy, Random Salt and Random Bytes for building credentials, plus classical ciphers such as Polybius Square and Autokey for puzzles. Everything executes in the page through the browser's own crypto API.

Adler-32 Checksum

Compute the Adler-32 checksum.

AES Decrypt

Decrypt AES-GCM encrypted text.

AES Encrypt

Encrypt text with AES-GCM and a password.

Autokey Cipher

Encrypt text with the autokey cipher.

CRC32 Checksum

Compute the CRC32 checksum of a string.

CRC8 Checksum

Compute the CRC8 checksum.

HMAC SHA-256

Compute an HMAC-SHA256 signature.

MD5 Hash

Compute the MD5 hash of a string.

Password Strength

Check the strength of a password.

Polybius Square

Encrypt/decrypt with the Polybius square.

Random Bytes

Generate cryptographically random bytes.

Random Salt Generator

Generate a random salt for hashing.

SHA-1 Hash

Compute the SHA-1 hash of a string.

SHA-224 Hash

Compute the SHA-224 hash of a string.

SHA-256 Hash

Compute the SHA-256 hash of a string.

SHA-384 Hash

Compute the SHA-384 hash of a string.

SHA-512 Hash

Compute the SHA-512 hash of a string.

AES-CBC Decrypt

Decrypt AES-CBC encrypted text.

AES-CBC Encrypt

Encrypt text with AES-CBC.

Affine Cipher

Encrypt text with the affine cipher.

Beaufort Cipher

Encrypt/decrypt with the Beaufort cipher.

Columnar Transposition

Encrypt/decrypt with columnar transposition.

CRC16 Checksum

Compute the CRC16-CCITT checksum.

ECDSA Key Generator

Generate an ECDSA key pair.

Fletcher-16 Checksum

Compute the Fletcher-16 checksum.

Fletcher-32 Checksum

Compute the Fletcher-32 checksum.

Gronsfeld Cipher

Encrypt text with the Gronsfeld cipher.

All Hash Generator

Compute MD5, SHA-1, SHA-256 and SHA-512 at once.

HMAC SHA-1

Compute an HMAC-SHA1 signature.

HMAC SHA-384

Compute an HMAC-SHA384 signature.

HMAC SHA-512

Compute an HMAC-SHA512 signature.

JWT Encode

Create and sign a JWT with HS256.

JWT Verify

Verify a JWT signature with HS256.

One-Time Pad

XOR encrypt text with a key (OTP).

Password Entropy

Estimate the entropy of a password in bits.

PBKDF2 Key Derivation

Derive a key using PBKDF2.

Playfair Cipher

Encrypt/decrypt with the Playfair cipher.

Porta Cipher

Encrypt text with the Porta cipher.

Random Key Generator

Generate a random encryption key.

RSA Key Generator

Generate an RSA key pair.

Scytale Cipher

Encrypt/decrypt with the Scytale cipher.

Substitution Cipher

Encrypt with a custom substitution alphabet.

TOTP Generator

Generate a time-based one-time password.

Trithemius Cipher

Encrypt text with the Trithemius cipher.

Vigenère Cipher

Encrypt/decrypt with the Vigenère cipher.

XOR Cipher

Encrypt/decrypt text with XOR and a key.

Hash, HMAC, or encrypt — pick deliberately

A hash is one-way and needs no key, which makes it right for integrity checks and wrong for anything you must read back later. MD5 and SHA-1 still appear in old checksum lists and legacy systems, but both have practical collision attacks, so anything security-related should use SHA-256 or above. When a shared secret is involved, use HMAC SHA-256 rather than hashing the message and the secret together by hand.

Encryption is the reversible option. AES Encrypt uses AES-GCM with a fresh random IV for every operation, so encrypting the same text twice with the same password produces two different ciphertexts; the IV is stored alongside the output so AES Decrypt can recover it. The key is derived by hashing the password once, which means the passphrase itself carries all of the strength — make it long. Treat this as a way to protect a note in transit, not as a replacement for a password manager or an audited library.

Checksums answer a narrower question than hashes do: did these bytes arrive unchanged? CRC32 and Adler-32 are fast and catch transmission errors, but they are not collision resistant and must never be used to detect tampering. For credentials, Password Strength scores composition while Password Entropy estimates bits of unpredictability; adding length raises entropy faster than adding symbols does.