Crypto & Hash

Parse and explain Unix passwd and shadow file lines field by field.

Validate a US bank ABA/routing transit number using its mod-10 checksum.

Compute the Adler-32 checksum of text or a file, as used by zlib.

Encrypt and decrypt text with AES-GCM using a passphrase, producing self-contained Base64 output with embedded salt and IV.

Encrypt or decrypt text with AES-CBC using a passphrase-derived key and explicit IV.

Encrypt or decrypt a chosen file in-browser with AES-GCM using a passphrase.

Generate matched public key ID and secret pairs with prefixes and a derived checksum.

Recommend Argon2id memory, iteration, and parallelism parameters for a target environment.

Validate and parse an Australian Bank State Branch (BSB) number into bank, state, and branch.

Convert between Base64url and big-integer/byte values for hand-editing JWK fields.

Estimate bcrypt hashing time for each cost factor and recommend a target work factor.

Hash a password with bcrypt and verify a password against a hash, locally.

Generate BIP39 seed phrases of 12, 15, 18, 21, or 24 words with a valid checksum for crypto wallet backups.

Compute the CRC-32 checksum of any text, output as hex or unsigned decimal for quick integrity checks.

Generate memorable passphrases from a bundled Diceware-style 7776-word list using cryptographic randomness.

Validate or compute check digits for EAN-13, EAN-8, and UPC-A barcodes.

Generate an elliptic-curve (P-256/P-384/P-521) key pair as PEM for ECDSA signing.

Sign and verify messages with ECDSA over P-256/P-384/P-521 curves.

Hash any local file with MD5, SHA-1, SHA-256, or SHA-512 by dropping it in, with a field to compare against an expected checksum.

Compute Fletcher checksums (16, 32, and 64-bit) of input bytes.

Paste an expected checksum and your text or file hash to confirm they match with constant-time-style comparison.

Compute MD5, SHA-1, SHA-256/384/512, SHA-3, BLAKE3 and CRC32 digests of text — live, in your browser.

Expand input key material into one or more output keys using HKDF (RFC 5869).

Compute HMAC (SHA-1/256/384/512) of a message with a secret key.

Recompute an HMAC over a message and key, then compare it against an expected MAC to verify authenticity.

Validate an IBAN using the ISO 13616 mod-97 checksum and show its structure.

Validate ISBN-10 and ISBN-13 check digits and convert between the two formats.

Inspect and convert between JWK and PEM key representations and display their parameters.

Compute the canonical SHA-256 thumbprint of a JSON Web Key per RFC 7638.

Build and sign JSON Web Tokens with RSA or ECDSA keys (RS256/384/512, ES256/384/512, PS256).

Decode a JWT and check its registered claims (exp, nbf, iat, aud, iss) without verifying the signature.

Create a signed HS256/384/512 JSON Web Token from a payload and secret.

Verify an HMAC-signed JWT (HS256/384/512) against a secret and report whether the signature and expiry are valid.

Verify a JWT signature against an RSA or ECDSA public key and check standard claims.

Compute memory, time, and output sizes for PBKDF2/scrypt/Argon2 parameter sets without running them.

Compute SSH-style and certificate-style fingerprints of a public key (MD5 colon-hex and SHA-256 base64).

Validate any Luhn-based number (credit cards, IMEI, etc.) and compute its check digit.

Generate the MD5 hash of any text, with lowercase or uppercase hex output (the algorithm Web Crypto omits).

Computes and verifies Mod-10 (Luhn) and Mod-11 check digits for arbitrary numeric strings.

Computes CRC-8, CRC-16, CRC-32, Adler-32 and a simple XOR/sum checksum of text in one view.

Build otpauth:// provisioning URIs for TOTP/HOTP authenticator apps from a Base32 secret and render a scannable QR code.

Estimate the bits of entropy in a passphrase based on its character set and length.

Generate strong random passwords or diceware passphrases, locally.

Score a password using composition rules and common-pattern detection with actionable feedback.

Derive a key from a passphrase and salt using PBKDF2 with configurable iterations and hash.

Generate cryptographically secure random bytes as hex, Base64, Base64URL, or a C-style byte array of a chosen length.

Generate cryptographically random tokens in many developer formats (hex, base64url, Base32, API-key style) with prefixes and grouping.

Encode or decode text with ROT47, the printable-ASCII rotation cipher (its own inverse).

Compare RSA, ECC, and symmetric key sizes by equivalent bits of security.

Generate an RSA public/private key pair in PEM format with selectable key size (2048/3072/4096) and hash.

Sign messages with an RSA private key and verify signatures with a public key (RSASSA-PKCS1 / PSS).

Compute SHA-1, SHA-256, SHA-384, and SHA-512 digests of pasted text simultaneously.

Computes SHA3-224/256/384/512 and Keccak-256 hashes of text using a pure JS implementation.

Split a secret into N shares requiring K to reconstruct, using finite-field polynomial interpolation.

Generate time-based one-time passwords (TOTP) from a Base32 secret.

Parse any UUID to reveal its version, variant, and embedded timestamp or node data.

Compute and validate Verhoeff and Damm check digits for error-detecting numeric strings.

Encrypt or decrypt text with the classic Vigenere keyword cipher.

Encrypt or decrypt text with a repeating-key XOR, output as hex or Base64 and back.