SHA-3 Generator
Generate SHA-3 digests at all four standard lengths. SHA-3 is not a patched SHA-2 — it is Keccak, a structurally different design chosen so that a break in one family would not affect the other.
{{ textCount }}
{{ textError }}
{{ r.value }}
{{ legacyNames }} {{ legacyNames.indexOf(' and ') === -1 ? 'is' : 'are' }} selected. Practical collisions are public for both, so treat the result as a checksum for spotting accidental corruption — not as evidence that a file is authentic.
Drop files here to hash them
Up to 100 files · any size · read in 4 MB chunks, never uploaded
Files are read, not uploaded. Each one is streamed through the hash function in chunks straight from disk, so a multi-gigabyte image never lands in memory and never leaves your device.
{{ f.error }}
{{ r.value }}
The key never leaves this page. It is not sent to a server, not saved to local storage, and not written into the exported files.
{{ hmacError }}
{{ hmacResult }}
HMAC is not a hash with the key glued on the front. It runs the key through the hash
twice with two different pads, which is what makes it resistant to the length-extension
attacks that break a naïve hash(key + message).
Drop the file you want to check
Hashed in your browser · never uploaded
{{ lengthProblem || vError }}
Hash matches
The {{ vResult.label }} digest of {{ vFile.name }} is identical to the hash you supplied, so this is the file that checksum describes. Letter case and surrounding whitespace were ignored.
Both {{ vResult.computed }}
Hash does not match
This file is not the one that checksum describes. Either the download is incomplete or corrupted, or the file has been altered. Downloading it again is the first thing to try.
Computed {{ vResult.cHead }}{{ vResult.cChar }}{{ vResult.cTail }}
Expected {{ vResult.eHead }}{{ vResult.eChar }}{{ vResult.eTail }}
First difference at character {{ vResult.diffAt + 1 }}.
Paste a hash into both boxes to compare them.
Hashes match
Both are the same {{ cmpResult.len }}-character value, so they identify identical content.
Ignored while comparing: letter case, spaces, line breaks, and any
sha256:-style prefix.
Both {{ cmpResult.a }}
Length {{ cmpResult.len }} — consistent with {{ cmpResult.guess }}.
Hashes are different
These are different lengths — {{ cmpResult.a.length }} and {{ cmpResult.b.length }} characters — so they are digests from two different algorithms, and comparing them tells you nothing about the content.
These two digests differ, so they describe different content.
Hash A {{ cmpResult.aHead }}{{ cmpResult.aChar }}{{ cmpResult.aTail }}
Hash B {{ cmpResult.bHead }}{{ cmpResult.bChar }}{{ cmpResult.bTail }}
First difference at character {{ cmpResult.diffAt + 1 }}.
Text, files and secret keys are hashed in your browser. Nothing you enter is ever uploaded to a server.
About SHA-3
SHA-3 is the hash standard NIST published in 2015 after a five-year open competition, based on the Keccak algorithm by Bertoni, Daemen, Peeters and Van Assche. It is available at four lengths: SHA3-224, SHA3-256, SHA3-384 and SHA3-512.
It is not a patched SHA-2
SHA-2 descends from MD5 and SHA-1 and shares their Merkle–Damgård structure. When MD5 and SHA-1 fell, that lineage became a concentration of risk: a structural break might have threatened SHA-2 too. SHA-3 was chosen precisely because it works differently — a sponge construction that absorbs input into a large permuted state and then squeezes output out of it. SHA-3 is insurance, not an upgrade.
Length extension does not apply
Because a sponge's output is only a slice of its state, a SHA-3 digest does not expose enough to
continue hashing. SHA-3 is therefore immune to the length-extension attacks that make
hash(secret + message) unsafe with SHA-256.
Should you switch?
Not without a reason. SHA-256 is more widely supported, has more hardware acceleration, and is usually faster in software. Reach for SHA-3 when a specification requires it, or when you want a digest whose security does not depend on SHA-2 holding up. Note that longer SHA-3 output is slower: a bigger digest means a smaller rate, so less data is absorbed per permutation.
SHA3-256 is not Keccak-256
NIST added a two-bit domain-separation suffix to the padding before standardising. The permutation is identical, but the digests differ for every input. Ethereum uses original Keccak-256, which is why an Ethereum hash never matches the SHA3-256 of the same data. This page implements the standard, SHA-3.
See also the SHA-256 generator.
Frequently asked questions
What is SHA-3?
The hash standard NIST published in 2015, based on the Keccak sponge construction. It was chosen through an open competition specifically because it works nothing like SHA-2 internally.
Is SHA-3 more secure than SHA-2?
Neither is broken, and SHA-3 is not a replacement. It exists as insurance: SHA-2 descends from MD5 and SHA-1, so a structural break in that lineage could threaten it. SHA-3 shares none of that structure.
Should I switch from SHA-256 to SHA3-256?
Not without a reason. SHA-256 is more widely supported and often faster in software. Choose SHA-3 when a specification requires it, or when you want a digest whose design is independent of SHA-2.
Which length should I pick?
SHA3-256 for general use. The number is the output size in bits, so SHA3-512 gives 128 hex characters. Longer output costs speed in SHA-3, because a bigger digest means absorbing less data per permutation.
Is SHA-3 the same as Keccak?
Almost. SHA-3 adds a domain-separation suffix to the padding, so SHA3-256 and original Keccak-256 give different digests for the same input. Ethereum uses the original Keccak-256, which is why its hashes differ from SHA3-256.