Generate a SHA-3 Hash — Free SHA3-256/384/512 & Keccak Generator
The SHA-3 Hash Generator hashes any text you type using your choice of SHA3-224, SHA3-256, SHA3-384, SHA3-512, or the pre-standardization Keccak-256/Keccak-512 variants Ethereum still uses. Pick a variant from the dropdown and your hash appears below as you type, powered by the widely used js-sha3 library rather than the Web Crypto API, which has no native SHA-3 support. Copy the result with one click once you've got the digest you need.
Whether you need to generate a SHA3 hash for data verification, audit a software download, or validate an API response, this SHA3 hash generator gives you an instant, browser-based fixed-length fingerprint — no server contact, no data leakage, no installation required. The output you receive is a fixed-length representation of your input: if even a single character changes, the output changes completely, making SHA-3 one of the most dependable tools in modern cryptography.
How to Use This SHA3 Hash Calculator and Hash Generator
This online sha3 hash tool is designed to be as friction-free as possible — paste text, choose your variant, and instantly compute output without leaving your browser. The hash calculator works entirely client-side: your input text never leaves your device, making it suitable for sensitive data verification tasks and private workflows that respect your privacy. Web engineers, security researchers, and every programmer alike use this hash calculator as a daily utility for string processing, text processing, and data integrity checks.
Step-by-Step Hash Generation
- Enter your input: Type or paste your plain text (or hex input representing encoded bytes) into the form input field above. You can also load sample data to see an example immediately.
- Choose your variant: Select the SHA-3 instance you need — SHA3-224, SHA3-256, SHA3-384, or SHA3-512 — or choose a SHAKE variant for variable-length output. Each produces a different output length.
- Select input and output options: Choose the correct input character set (UTF-8 by default; switch to Hex if your input represents raw bytes). Then set the result representation — hex is the most common, but Base64 is available for compact representation.
- Press button to get your result: The hash calculator computes your result instantly. Many implementations support auto update so the output recalculates as you type.
- Copy the result: Click the copy button to put the output on your clipboard, or download it directly.
- Verify a value: To verify checksum integrity, paste the same input and compare the output against a known reference from a trusted source. An identical result confirms the data is unchanged.
Choosing Your Output Format
The default hex output renders your result as hexadecimal characters — lowercase letters a–f and digits 0–9. This is the layout expected by most developer tools, APIs, and communication scheme implementations. Alternatively, choosing base64 output reduces the character count by roughly one-third, which is useful for embedding results in JSON payloads or HTTP headers. When you select Hex as the input character set, the tool interprets your pasted value as raw binary rather than hashing the literal characters, so always confirm your input setting matches your data source to ensure the output is correct.
When should you use hex vs. Base64 output?
- Hex is human-readable and unambiguous — ideal for log files, configuration, and certificates.
- Base64 is more compact — useful in HTTP headers, JSON tokens, and storage-constrained contexts.
- Both encode the same underlying bits; only the text representation differs.
- Most reference test vectors (including those in FIPS 202) use lowercase hex, so hex is the safest choice when comparing against published values.
What Is SHA-3 and the Keccak Scheme? A SHA3 Hash Generator Background
SHA-3 — formally the Secure Hash Algorithm 3 — is the latest member of the Secure Hash Algorithm family of standards published by NIST. Although it carries the same family name as SHA-1 and SHA-2, it is internally an entirely different scheme built on the Keccak sponge construction rather than the Merkle–Damgård structure that underpins MD5, SHA-0, and both SHA-1 and SHA-2. Understanding this sha-3 history and sha-3 design explains why SHA-3 resists entire classes of attacks that can threaten older schemes.
Origins, SHA-3 History, and Standardization
The standards body launched a public competition in 2007 to develop a new secure hash algorithm after concerns arose around theoretical weaknesses in SHA-1 and the structural similarity between SHA-2 and SHA-1. The Keccak submission, designed by Guido Bertoni, Joan Daemen, Michaël Peeters, and Gilles Van Assche, was selected as the winner in October 2012. After a period of review and standardization, the agency formally published SHA-3 in August 2015 as NIST FIPS 202, the defining document for the sha-3 family. This sha-3 history distinguishes it from earlier schemes like the md5 hash family — which were designed in a pre-competition era with far less public scrutiny.
The Sponge Construction and Block Transformation
The core innovation in SHA-3 is the sponge construction, a hash design fundamentally different from the iterated data-reduction functions in SHA-1 and SHA-2. The sponge operates in two phases:
- Absorbing phase
- Input data is XOR-ed into a portion of the internal state — called the rate — and then the entire state is transformed by the block permutation Keccak-f. This repeats until all input has been absorbed.
- Squeezing phase
- Output bits are extracted from the rate portion of the state. For fixed-length variants, squeezing stops after one or two rounds; for extendable-output functions (XOFs), squeezing continues until the required output length is reached.
The internal state of Keccak-f[1600] is a 5×5 matrix of 64-bit lanes, totalling 1600 bits. The internal transformation applies five sub-steps — theta (θ), rho (ρ), pi (π), chi (χ), iota (ι) — across 24 rounds. This sha-3 padding-agnostic, stateful design means SHA-3 is inherently resistant to length-extension resistance attacks, a structural vulnerability that affects SHA-2 and sha1 hash when used without HMAC.
The state size can be expressed as:
$$b = r + c$$where b is the total state width (1600 bits for the standard instances), r is the rate (the portion exposed to input/output), and c is the capacity (the hidden protection buffer). A larger capacity provides stronger resistance at the cost of a smaller rate — and therefore lower throughput for a given state size.
SHA-3 Padding Rules Explained
SHA-3 uses a multi-rate padding rule known as pad10*1: a 1 bit is appended, followed by enough 0 bits to fill the block, then a final 1 bit. SHA-3 additionally prepends a type-separation suffix before the pad: 01 in binary for the SHA-3 fixed-output variants (as specified in FIPS 202), and 11 for the SHAKE XOF variants. This type-separation marker is exactly what distinguishes a sha-3 hash from a raw Keccak output — a critical implementation detail explained further in the examples section below.
Weakening Controversy and the NIST Announcement
When the agency published its draft standard, the community noticed that the proposed capacity had been reduced relative to the Keccak competition submission. Critics viewed this as weakening the protection margin without sufficient justification. Several prominent voices expressed concern:
"It's a bit of a shame for the competition that they demanded a certain security level for entrants, then went to publish a standard with a different one. But there's nothing that can be done to fix that now, except re-opening the competition."
"There is too much mistrust in the air. NIST risks publishing an algorithm that no one will trust and no one (except those forced) will use."
"I misspoke when I wrote that NIST made 'internal changes' to the algorithm. That was sloppy of me. The Keccak permutation remains unchanged. What the agency proposed was reducing the hash function's capacity in the name of performance. One of Keccak's nice features is that it's highly tunable."
Despite this weakening controversy, the final published standard retained protection strengths that match or exceed those of SHA-2 at equivalent output sizes. SHA-3 is best understood as an alternative with a different design to SHA-2 — a backup scheme that uses a structurally independent construction — rather than a direct replacement mandated for immediate migration.
Generate SHA3 Hash Variants, Instances, and Output Sizes
One of the most useful aspects of this online SHA3 hash generator is support for all standard sha-3 variants as well as the extendable-output functions. Understanding each instance helps you choose the right one for your use case — whether you need a compact 224 hash, a widely-used 256 hash, or a longer output for maximum protection margin.
Fixed-Output Instances: SHA3-224 Through SHA3-512
The FIPS 202 specification defines four fixed-length hash instances. All four use the same Keccak-f[1600] block transformation but differ in their rate/capacity split and therefore in their output size and throughput. The sha3-256 hash is the most commonly adopted, offering a fixed 256-bit result and drop-in symmetry with SHA-256 output lengths, though the two schemes are structurally unrelated. The sha3-384 and sha3-512 outputs provide progressively larger protection margins at the cost of slightly lower throughput. Below is a full comparison of all four standard variants:
| Variant | Digest Size (bits) | Rate r (bits) | Capacity c (bits) | Domain Suffix | Security Strength (bits) | Relative Speed |
|---|---|---|---|---|---|---|
SHA3-224 | 224 | 1152 | 448 | 0x06 | 112 | Fastest fixed |
SHA3-256 | 256 | 1088 | 512 | 0x06 | 128 | Fast |
SHA3-384 | 384 | 832 | 768 | 0x06 | 192 | Moderate |
SHA3-512 | 512 | 576 | 1024 | 0x06 | 256 | Slowest fixed |
SHAKE128 | Variable (XOF) | 1344 | 256 | 0x1F | min(d/2, 128) | Fastest overall |
SHAKE256 | Variable (XOF) | 1088 | 512 | 0x1F | min(d/2, 256) | Fast |
Extendable-Output Functions: SHAKE128 and SHAKE256 Variants
SHAKE128 and SHAKE256 are extendable-output functions (XOFs) — a class of secure hash where you specify how many output bits you want. Instead of a fixed 384 hash or a fixed-length output, you can request exactly 256 bits, 512 bits, or any length suited to your communication scheme. The squeezing phase continues as long as needed. SHAKE128 offers up to 128-bit resistance regardless of output length, while SHAKE256 provides up to 256-bit resistance. These XOFs are widely used in key derivation and random-beacon applications where the output length is application-defined. The different type-separation marker (0x1F vs. 0x06) ensures that SHAKE and fixed SHA-3 outputs are never accidentally confused — a critical aspect of sha-3 implementations.
Parallel and Tree-Hashing Variants: KangarooTwelve and Beyond
The later developments in the Keccak ecosystem address SHA-3's main practical weakness: raw software speed. These additional instances and parallel variants extend the original design:
- KangarooTwelve (K12): Uses a reduced 12-round version of Keccak-f (instead of 24) combined with tree hashing to enable parallel computation. On modern processors with SIMD instructions, this variant can outpace SHA-256. It is defined in a separate IETF RFC-track document.
- Farfalle construction: A generalised keyed sponge design by the Keccak team. The Farfalle construction enables even faster parallel processing and serves as the foundation for the Xoofff and Kravatte authenticated cipher schemes.
- Sakura tree hashing: A tree-hashing framework built on top of the sponge, allowing incremental and parallelisable processing of large data. Sakura provides a formal encoding for tree-structured hash computation.
- cSHAKE, TupleHash, ParallelHash: Higher-level functions standardised in NIST SP 800-185. These sha implementations add domain separation via customisation strings, enabling safe use of the same Keccak core across multiple contexts.
Speed note: SHA-3 vs. SHA-2 in software
In pure software, SHA-3 is generally 2–3× slower than SHA-256 on x86-64 processors without dedicated SHA-3 instructions. However, hardware acceleration (available in ARM processors implementing the SHA-3 extension and in dedicated accelerators) closes this gap significantly. For most developer use cases — computing a checksum over a file or a text representation of an API token — the speed difference is imperceptible.
Online SHA3 Hash vs. Other Hash Algorithms: Comparison and Structure
Choosing the right scheme for your use case requires understanding how SHA-3 compares across protection strength, structural design, and usage in communication schemes. This section covers the key dimensions of that hash comparison, including sha functions comparison across the major scheme families and post-quantum resilience considerations that matter for long-lived data.
SHA-3 vs. SHA-2: Key Structural Differences
Both SHA-2 and SHA-3 are approved by the standards body and provide strong protection, but they are built on entirely different foundations. SHA-2 (including SHA-256 and SHA-512) uses the Merkle–Damgård construction: input is divided into fixed-size blocks, and a data-reduction function iteratively updates a chaining variable. This design is susceptible to length-extension attacks — an adversary who knows \(H(m)\) and the length of \(m\) can compute \(H(m \| \text{suffix})\) without knowing \(m\). SHA-3's sponge construction eliminates this entire attack class, giving it inherent length-extension resistance without requiring HMAC wrapping.
The sha2 hash family also shares structural ancestry with SHA-1 (and distantly with MD4 and MD5), meaning a catastrophic weakness in the underlying paradigm could theoretically affect multiple schemes simultaneously. SHA-3's completely independent alternative design means it acts as a genuine backup.
Post-Quantum Resilience and SHA-3 Protection Strength
Advanced attacks using Grover's method can search an \(n\)-bit output space in \(O(2^{n/2})\) operations, effectively halving the protection level against preimage attacks. This means:
SHA3-256provides approximately 128-bit post-quantum preimage resistance (256 ÷ 2), which is widely considered sufficient for long-term integrity.SHA3-512provides approximately 256-bit post-quantum preimage resistance — the highest margin among the standard instances.- Collision resistance is reduced from \(2^{n/2}\) to roughly \(2^{n/3}\) under advanced attacks (using BHT method), making the longer variants preferable for collision-sensitive applications.
For most current cybersecurity applications, SHA3-256 strikes the right balance between output length, speed, and future-proof resilience. Standards compliance requirements (such as those in TLS 1.3 and certificate transparency logs) increasingly reference SHA-3 alongside SHA-2 for scheme agility. Verification tokens, digital signatures, and blockchain transaction outputs that need multi-decade integrity should consider SHA3-384 or SHA3-512.
Common Use Cases, Adoption, and Important Limitations
SHA-3's adoption in communication schemes continues to grow. Key deployment contexts include:
- Data verification and integrity: Computing a sha-3 checksum calculator result over a downloaded file and comparing against a published reference is the most common integrity use case. Checks like this are supported by most operating systems' native tools.
- File integrity verification: Generating a checksum over software releases ensures tampering is detectable. File verification workflows in CI/CD pipelines increasingly adopt SHA-3.
- Digital signatures and certificates: SHA-3 is approved for use with ECDSA and RSA signatures under applicable guidelines, supporting standards compliance in PKI environments.
- Blockchain and Ethereum: Note that systems in the Ethereum ecosystem predominantly use raw Keccak-256 (pre-standardisation variant), not SHA3-256. The two differ by their type-separation marker — an important distinction when building applications for that platform.
- Key derivation: SHAKE128 and SHAKE256 serve as building blocks in key derivation functions, replacing HKDF's HMAC component with a native sponge-based construction.
Important limitations — password security: SHA-3 is not a password-hashing function. An unkeyed output does not provide verification of identity. Never use plain SHA3-256 results for password storage — even salted SHA-3 is vulnerable to GPU-accelerated brute force because SHA-3 is designed to be fast. Use a deliberately expensive, memory-hard function such as Argon2, bcrypt, or scrypt for password security. Similarly, SHA-3 alone is not suitable as a keyed MAC — use HMAC-SHA3 or the standardised KMAC construction to add a secret key and gain identity-verification properties.
| Algorithm | Digest Size | First Published | Designers | NIST Certification | Preimage Resistance | Collision Resistance | Quantum Security | Security Status |
|---|---|---|---|---|---|---|---|---|
MD5 | 128 bits | 1992 | Ron Rivest | No | 2123 (weakened) | Broken (218) | None | Broken — avoid |
SHA-1 | 160 bits | 1995 | NSA | Deprecated | 2160 | Broken (SHAttered) | None | Deprecated — avoid |
SHA-256 (SHA-2) | 256 bits | 2001 | NSA | FIPS 180-4 | 2256 | 2128 | ~128 bits preimage | Secure (length-ext. risk) |
SHA-512 (SHA-2) | 512 bits | 2001 | NSA | FIPS 180-4 | 2512 | 2256 | ~256 bits preimage | Secure (length-ext. risk) |
SHA3-256 | 256 bits | 2015 | Bertoni et al. | FIPS 202 | 2256 | 2128 | ~128 bits preimage | Secure — recommended |
SHA3-512 | 512 bits | 2015 | Bertoni et al. | FIPS 202 | 2512 | 2256 | ~256 bits preimage | Secure — recommended |
SHA-3 Hash Output Examples and Expected Results
The following worked examples let you validate your implementation and understand what correct output looks like for well-known test vectors. These are the canonical test vectors used across the community to verify SHA-3 compliance. If your computed result differs from these, the most common causes are explained after each example. You can use this free online hash calculator to reproduce all three results instantly — just paste the input text, choose the output, and press button to compare.
Example 1: SHA3-256 Hash of the Empty String
Processing the empty string (zero bytes of input) is the baseline test for any hash calculator. The SHA3-256 result is a 64-character hex string — demonstrating that the output is always exactly 256-bit regardless of input length. This is what you should see when you use the tool on an empty input field:
SHA3-256("") =
a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434aExample 2: SHA3-256 Hash of 'abc' — Standard Test Vector
The string abc (three UTF-8 encoded bytes: 0x61 0x62 0x63) is the most widely used test vector for validating secure hash implementations. When you compute the output of abc using UTF-8 abc encoding, you should obtain exactly the following 64-character hex result:
SHA3-256("abc") =
3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532Example 3: SHAKE128 Variable-Length Output (XOF Demonstration)
This third example demonstrates the extendable-output nature of SHAKE. By choosing 256 bits of output from SHAKE128, you get a 64-character hex result — the same length as SHA3-256 — but computed via a completely different scheme with a different type-separation marker and rate. This is what distinguishes XOF behavior from the fixed-output instances:
SHAKE128("The quick brown fox jumps over the lazy dog", 256) =
f4202e3c5852f9182a0430fd8144f0a74b95e7417ecae17db0f8cfeed0e3e66eWhy Your Result Might Differ From Another Tool
If the string hash you compute here doesn't match another tool's output, work through this checklist:
- SHA-3 vs. Keccak: Keccak-256 (pre-standardisation) and SHA3-256 (FIPS 202) use different type-separation markers and produce different outputs for identical inputs. Ethereum uses raw Keccak, not SHA3-256.
- Input encoding: If you paste hex characters but the tool is set to text mode, it will process the literal hex string rather than the encoded bytes it represents. Confirm your input setting.
- Line endings: A trailing newline (common when copying from terminals) adds one or two extra bytes. Check for invisible line endings or trailing whitespace in your form input.
- Output representation: A Base64-encoded result looks nothing like a hex result even when both represent the same bits. Ensure the output setting is consistent between tools.
- SHA3-256 vs. SHA-256: These are entirely different schemes. SHA-256 is part of SHA-2; SHA3-256 is part of SHA-3. Their outputs are the same length (256 bits) but never equal for the same input.
Frequently Asked Questions About the SHA3 Hash Calculator
How long is a SHA-3 hash?
The output length depends on the variant. SHA3-224 produces a 56-character hex result (224 bits); SHA3-256 produces 64 characters (256 bits); SHA3-384 produces 96 characters (384 bits); and SHA3-512 produces 128 characters (512 bits). SHAKE128 and SHAKE256 produce variable-length output — you specify the exact number of output bits. In all cases the result is a fixed-length fingerprint regardless of how long or short your input is.
What is the difference between SHA-2 and SHA-3?
SHA-2 (including SHA-256 and SHA-512) uses the Merkle–Damgård construction with a data-reduction function and is susceptible to length-extension attacks. SHA-3 uses the Keccak sponge construction, which is structurally independent and inherently immune to length-extension attacks. Both are approved by the standards body and considered strong for general use. SHA-3 is an alternative with a different design — not a sign that SHA-2 is broken.
Is SHA-3 better than SHA-256?
Neither is strictly better — they serve overlapping purposes with different trade-offs. SHA-3 offers length-extension resistance natively, structural independence from SHA-2, and broader scheme agility. SHA-256 (part of SHA-2) is faster in software on most CPUs and has broader legacy support. For new systems requiring modern secure processing and standards compliance, SHA3-256 is an excellent choice. For high-throughput environments with existing SHA-2 infrastructure, there is no urgent reason to migrate.
What is the difference between SHA-3 and Keccak?
Keccak is the underlying scheme submitted to the competition. SHA-3 is the standardised version of Keccak. The key difference is the type-separation marker: the standards body appended 01 in binary to all SHA-3 inputs before padding, which Keccak-256 does not use. As a result, SHA3-256 and Keccak-256 produce different outputs for the same input. The Keccak internal transformation itself is unchanged — only the framing differs. This matters most for development targeting the Ethereum platform, where its keccak256() function is raw Keccak-256, not FIPS 202 SHA3-256.
Can I use the hash result to verify data?
Yes — data verification and integrity checks are primary use cases for SHA-3. Use this hash calculator to compute the output of a file or message, then compare it against a known-good reference published by a trusted source. If the results match, the data is unmodified. This is the basis of file verification in software distribution, verification in certificate transparency, and data integrity checks in storage systems. To process a file directly, use a dedicated tool or a command-line utility such as openssl dgst -sha3-256.
What other hash algorithms can I compare against?
Beyond SHA-3, the broader landscape includes schemes suited to different contexts. Legacy options like MD5 (md5 hash), MD2 (md2 hash), MD4 (md4 hash), and MD6 (md6 hash) are outdated or broken and should not be used for protection-sensitive tasks. The sha1 hash (SHA-1) is deprecated for most uses. The sha2 hash family (sha224 hash, sha256 hash, sha384 hash, sha512 hash) remains widely used and strong. Non-secure checksums like the crc32 hash, crc16 hash, and adler32 hash are fast but provide no protection — use them only for error detection, not integrity checks. The ripemd hash family and whirlpool hash are secure but have less ecosystem support. The ntlm hash is Windows-specific and should never be used for new systems. An all hashes calculator can generate outputs for many schemes simultaneously, which is useful for cross-referencing or migration purposes.
Is this SHA3 hash generator private and free to use?
Yes — this is a free online tool and a fully browser-based online utility. All processing happens locally in your browser using JavaScript; no input data is ever transmitted to a server. This makes it safe for private processing of sensitive strings, fully respecting your privacy. There are no ads cluttering the interface, making it a clean simple tool for web engineers, coders, and protection professionals. A programmer or developer will find related tools on this site including encoder and decoder utilities (such as a base64 encoder, base32 encoder, and url encoder), hex converter, binary converter, text converter, encryptor and decryptor tools for aes encryption, des encryption, rc4 encryption, and xor encryption, as well as a password generator. These web developer tools, web tools, and cryptography utilities complement this tool as part of a complete online toolkit — just press button and get instant results. This hash calculator, decoder, and encryptor suite serves as an all-in-one resource, and the password generator rounds out the offering for web developers and coders alike.
Pro tip for developers: When integrating SHA-3 into your application, always specify the exact scheme name including the output size (e.g., SHA3-256 not just SHA3) to avoid ambiguity between sha-3 implementations in different libraries. Confirm character-set and decoding settings — especially UTF-8 normalisation — to ensure your output matches across platforms. For identity-verification contexts, wrap SHA-3 in HMAC or use KMAC rather than relying on an unkeyed function. For data-protection needs, pair SHA-3 based key derivation with an authenticated cipher. Remember: sha-3 resilience is only as strong as the system around it — data integrity, key management, and compliance all matter equally.
Frequently Asked Questions
- What's the difference between SHA-3 and Keccak?
- SHA-3 is the NIST-standardized version of the Keccak algorithm (FIPS 202, 2015), which made small padding changes during standardization -- so plain "Keccak-256" and "SHA3-256" actually produce different hash values for the same input. Keccak-256 is specifically still used by Ethereum and some other blockchain systems that adopted it before the SHA-3 standard was finalized, which is why it's offered here separately.
- Why would I use SHA-3 instead of SHA-2 (SHA-256/512)?
- SHA-3 uses a fundamentally different internal construction (a sponge function) than SHA-2's Merkle–Damgård design, so it doesn't share any of SHA-2's theoretical structural weaknesses -- NIST standardized it specifically as a backup in case future cryptanalysis ever weakens SHA-2. In practice, SHA-256/512 remain considered secure and are far more widely deployed; SHA-3 is chosen when a project specifically wants construction diversity or is required to support it.
- Is SHA-3 safe for hashing passwords?
- No -- like every general-purpose hash function on this page, SHA-3 is designed to be fast, which is the wrong property for password storage. Use a dedicated slow hash (bcrypt, scrypt, Argon2) for that instead.
- Where is Keccak-256 actually used?
- Most notably in Ethereum and Ethereum-derived blockchains, for address derivation, transaction hashing, and Solidity's built-in keccak256() function -- a legacy of Ethereum adopting Keccak before NIST's SHA-3 standardization finalized the padding change.
- Is my text sent anywhere?
- No. The hash is computed entirely in your browser using the js-sha3 library -- nothing is transmitted to a server or stored.