sha-3 · keccak · 224/256/384/512 · live

Generate SHA-3 / Keccak digests

Compute SHA-3 (Keccak) hashes in any of the four standard sizes. Used by Ethereum (keccak256), TLS 1.3 and modern protocols. Runs entirely in your browser.

SHA-3 / Keccak Generator
Input
43 B
43 chars
Algorithm
SHA3-256
256-bit
Digest
—
lower
Status
loading
noble
input · text
output · sha3-256 hex
—
Quick Start

How to compute SHA-3

Hashes UTF-8 bytes with the Keccak permutation via @noble/hashes. Output is lowercase hex.

  1. 01

    Type or paste text

    Any UTF-8 input — emoji and accents are hashed faithfully.

    Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.

    inputUTF-8TextEncoderlosslesslive
    input · raw bytestext · UTF-8
    hello
    loaded · UTF-8MIME · ready
  2. 02

    Pick the output size

    224, 256, 384, or 512 bits — depends on the protocol you're matching.

    Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.

    sizeWeb Cryptosubtledeterministiclive
    size · options256 · live
    64 hex chars
    options applied · livelive
  3. 03

    Live hash

    Output updates as you type. Uses the sponge construction, not Merkle-Damgård.

    Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.

    livememoisedoptionsinstantreactive
    out · encodedready · ready
    69070dda…
    encoded · livelossless
  4. 04

    Copy or download

    One click to clipboard. Download as .txt.

    Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.

    exportclipboardblobMIME-correctclient-side
    ok · copiedready · done
    Copied
    shipped · ready to shipsuccess
Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Use Cases

When to use SHA-3

Modern protocols that want a non-Merkle-Damgård hash.

Ethereum keccak256

Compute address and contract-call hashes. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

web3

TLS 1.3

Pair SHA3 with HKDF in modern protocols. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Digital signatures

Sign a SHA3 digest with EdDSA or ECDSA. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

Post-quantum readiness

Some PQ schemes specify SHA-3 internally. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Sponge primitives

Build MACs, KDFs, or PRFs on top of Keccak. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Test fixtures

Match NIST test vectors exactly. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready
FAQ

Frequently asked questions

Almost. SHA-3 has a different padding rule than the original Keccak submission. Ethereum uses original Keccak; NIST SHA-3 differs in the suffix byte.
Match the protocol. Ethereum uses 256-bit; signatures often use 256 or 512.
On most general-purpose CPUs SHA-2 is faster. SHA-3 shines on hardware where Keccak can be implemented efficiently.
For files use the File Checksum Verifier — it streams large files efficiently.
No. SHA-3 is computed in your browser via @noble/hashes and runs locally.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!