SHA-384 Generator
Generate a 384-bit SHA-384 digest — 96 hexadecimal characters. A truncated SHA-512 with different starting values, and the usual choice for subresource integrity.
{{ 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-384
SHA-384 produces 384 bits, written as 96 hexadecimal characters. It is SHA-512 with different initial values, truncated to 384 bits — not a separate design.
The truncation is the interesting part
Because the output is shorter than the internal state, a SHA-384 digest does not reveal enough of that state to continue hashing from it. That makes SHA-384 resistant to length-extension attacks, which plain SHA-256 and SHA-512 are not. If you ever needed a bare hash of a secret plus a message — and you should use HMAC instead — SHA-384 would be the safer primitive.
Where you will meet it
Most often in HTML subresource integrity attributes, where a
sha384- prefixed Base64 digest pins the exact contents of a script or stylesheet
served from a CDN. Also in TLS cipher suites, usually paired with a 384-bit elliptic curve so the
hash and the key agreement offer comparable strength.
Getting a value you can paste into an integrity attribute
Subresource integrity takes Base64, not hex. Switch Format to Base64 and prefix
the result with sha384-. Note that SRI hashes the exact bytes served, so a CDN that
recompresses or rewrites the file will break the check.
See also the SHA-512 generator.
Frequently asked questions
What does SHA-384 produce?
384 bits, written as 96 hexadecimal characters.
How does SHA-384 relate to SHA-512?
It is the same algorithm with different initial values, truncated to 384 bits. That truncation is not cosmetic: it is what makes SHA-384 resistant to length-extension attacks, which plain SHA-512 is not.
Where would I see it?
In HTML subresource integrity attributes, where sha384- prefixed Base64 digests are conventional, and in TLS cipher suites. Also anywhere a 384-bit digest is specified to pair with a 384-bit elliptic curve.
Why is the Base64 form useful here?
Subresource integrity attributes take Base64, not hex, so switching the output format gives you the value you can paste straight into an integrity attribute.