SHA-3 Hash Generator (Keccak SHA3-256)

What Is SHA-3?

// SHA-3 (NIST FIPS 202 SHA3-256) using js-sha3 library
import { sha3_256 } from 'js-sha3';

const hash = sha3_256('Hello, World!');
// → '882f4b6991a775295186a4e3cc5ece9fc0b618c8c3e7a7beafdd0f56f13ae43b'

// Note: this differs from Ethereum's keccak256 for the same input:
// keccak256('Hello, World!') = 'acaf3289d7b601cbd114fb36c4d29c85bbfd5e133f14cb355c3fd8d99367964f'
// The difference is the padding byte: 0x06 (SHA-3) vs 0x01 (original Keccak)

SHA-3 Examples

abc

3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532

Hello

NIST SP 800-57 Part 1 Rev 5 — Recommendation for Key Management

POST /api/ledger
{"amount":250000,"from":"acct-A","to":"acct-B"}

How to Generate SHA-3 Hashes

1. 1

   Paste text into the input field

   Select the Text tab and type or paste any string. The SHA3-256 hash updates live as you type. On first use, the js-sha3 library (~10 KB) is fetched and cached — you may notice a brief delay on the very first hash; all subsequent hashes are instant. The algorithm is already set to SHA-3 (NIST FIPS 202 SHA3-256).

2. 2

   Copy the 64-character hex output

   Click the Copy button next to the hash result. The 64-character lowercase hex string is copied to your clipboard. Use the Uppercase toggle if your target system requires uppercase. This output matches what any FIPS 202-compliant SHA3-256 implementation produces — but note it differs from Ethereum's keccak256 for the same input.

3. 3

   Verify with the Compare tab

   Switch to the Compare tab and paste two SHA3-256 hashes side by side. The tool uses constant-time comparison to report match or mismatch without leaking timing information. Useful for verifying NIST CAVP test vectors, checking archive manifests, or confirming that two SHA3-256 implementations produce identical output.

Technical Details

Algorithm: Keccak-f[1600] sponge construction

SHA3-256 applies the Keccak-f[1600] permutation (24 rounds of theta, rho, pi, chi, iota operations on a 5×5×64 state array) in a sponge construction with rate=1088 bits and capacity=512 bits. Input is absorbed in 136-byte (1088-bit) blocks; 256 bits of output are squeezed. The FIPS 202 domain separator appends 0x06 before padding. Implementation: NIST FIPS 202 (2015) section 6.

Output: SHA3-256 by default, 64 hex characters (FIPS 202 also defines 224/384/512)

This tool outputs SHA3-256: always exactly 64 hexadecimal characters (256 bits = 32 bytes). NIST FIPS 202 also standardizes SHA3-224 (56 chars), SHA3-384 (96 chars), and SHA3-512 (128 chars) — all using the same Keccak-f[1600] permutation with different rate/capacity splits. The output length is fixed regardless of input size.

Performance: lazy-loaded js-sha3 (~10 KB); ~150–400 MB/s in browser

Unlike SHA-2 routes (which use the browser's native Web Crypto API), SHA-3 is not in the Web Crypto spec. This tool loads the js-sha3 library (~10 KB gzipped) on first use, then caches it. Typical throughput: 150–400 MB/s in JavaScript, versus 400–700 MB/s for SHA-256 via Web Crypto. For text hashing (kilobytes) the difference is imperceptible. The main bundle for other SHA routes is unaffected by this lazy load.

Standards: NIST FIPS 202 (2015), NIST SP 800-185 (KMAC), NIST IR 8105

Standardized in FIPS 202 (August 2015). NIST SP 800-185 (2016) defines KMAC128 and KMAC256 — SHA-3-based keyed MAC functions that are natively length-extension immune without the HMAC wrapper. NIST IR 8105 recommends SHA-3 variants for post-quantum security margin. Currently approved for all security strength levels through 2030 and beyond under NIST SP 800-131A Rev 2.

Best Practices

Do not confuse SHA3-256 with Ethereum's keccak256

They are different algorithms with different outputs for every input. This tool computes NIST FIPS 202 SHA3-256 (padding byte 0x06). Ethereum's keccak256 uses original Keccak padding (0x01). If you are computing Ethereum address hashes, EVM storage slots, or Solidity keccak256() results, you need a keccak256-specific tool — this tool will give you wrong answers for those use cases.

Use SHA-3 as a hedge alongside SHA-256, not as a replacement

SHA-3 and SHA-2 use structurally different designs (sponge vs. Merkle-Damgård). A dual-hash manifest (SHA-256 + SHA3-256) gives defense in depth: if a cryptanalytic break is ever found in one family's construction, the other remains secure. For long-term archival data and government records, NIST recommends considering this dual-algorithm approach. For everyday use, SHA-256 alone remains perfectly sufficient.

Prefer KMAC over HMAC-SHA3-256 for new keyed MAC designs

NIST SP 800-185 defines KMAC128 and KMAC256 — purpose-built keyed MACs based on SHA-3. Because the sponge construction is natively length-extension immune, KMAC does not need the double-hashing wrapper that HMAC requires for safety. For new protocols that have flexibility in MAC algorithm choice, KMAC128 (128-bit security) or KMAC256 (256-bit security) are cleaner and slightly more efficient than HMAC-SHA3-256.

Use constant-time comparison when verifying SHA-3 hashes in code

When comparing two SHA3-256 hashes in code, always use a constant-time equality function: Node.js crypto.timingSafeEqual(), Python hmac.compare_digest(), Go subtle.ConstantTimeCompare(). Naive string equality (=== or ==) leaks timing information that can allow an attacker to reconstruct the expected hash byte-by-byte. This applies equally to SHA-3 and all other hash functions. This tool's Compare tab already uses constant-time comparison.

SHA-3 FAQ