SHA3-384 Generator

What is SHA3-384 and when would you use it?

SHA3-384 is the 384-bit member of the SHA-3 family defined in FIPS 202. It produces a 48-byte digest, printed here as 96 lowercase hex characters, with 192-bit collision resistance. You'd use it when a system is built around the 192-bit security level and specifies SHA-3, or when you need to match a SHA3-384 value someone else produced.

This tool encodes your text as UTF-8, hashes it exactly as entered, and shows the digest when you click Generate. Empty input produces no output.

Matching security levels

Cryptographic systems are usually designed so every part offers roughly the same strength; a 256-bit key protected by a weak hash is only as strong as the hash. NIST's key-management recommendation, SP 800-57 Part 1 Rev. 5, groups algorithms by security strength. For hashes, collision resistance is half the output length, which puts SHA3-384 in the 192-bit tier:

So SHA3-384 pairs naturally with P-384 signatures or AES-192 encryption. In practice, SHA-384 fills that slot far more often, simply because SHA-2 is everywhere. SHA3-384 is the choice when a design deliberately standardizes on SHA-3.

How SHA3-384 differs from SHA-384

Both produce 384 bits, and the comparison shows how differently they get there.

SHA-384 runs SHA-512's Merkle-Damgard engine from its own initial values and drops the last 128 bits of the 512-bit state. Those hidden bits are why SHA-384, unlike SHA-256 or SHA-512, isn't open to length-extension attacks.

SHA3-384 uses the Keccak sponge with a 768-bit capacity, double the output size, and a 832-bit rate, so it absorbs 104 bytes per permutation. The capacity is never output, which rules out length extension by construction.

The outputs for the same input have nothing in common:

SHA3-384("abc") = ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25
SHA-384("abc")  = cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7

The SHA3-384 line is NIST's published example value for this input and is exactly what this tool outputs. For SHA-384 use the hash generator, which computes it with the browser's built-in crypto.

Checking a SHA3-384 digest step by step

1. Get the exact original text. Case, spaces and line endings all change the hash.
2. Paste it into the input box and click Generate.
3. Compare your 96 characters against the expected value. Hex is case-insensitive, so EC0149... and ec0149... are the same digest.
4. If it doesn't match, rule out invisible differences by hashing the same string from a terminal:

printf '%s' 'hello world' | openssl dgst -sha3-384

Both should give 83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b. Python's hashlib.sha3_384() and PHP's hash('sha3-384', ...) agree too.

If the other party's value still differs, they may have hashed with SHA-384 instead, encoded the text differently (UTF-16 is a common culprit on Windows), or used the pre-standard Keccak padding, which gives different output from the same permutation.

Is SHA3-384 slower?

Per byte, yes, compared with SHA3-256. A larger capacity means a smaller rate: SHA3-384 absorbs 104 bytes per Keccak-f[1600] call against SHA3-256's 136, so long inputs need about 30% more permutations. For the short strings you'd paste into a web form, the difference is invisible.

What not to use it for

SHA3-384 is a general-purpose hash. It isn't encryption and can't be reversed, and on its own it isn't an appropriate way to store passwords; the OWASP Password Storage Cheat Sheet recommends slow, salted functions such as Argon2id. To prove a message came from someone holding a shared key, use an HMAC rather than a bare hash.

Other SHA-3 sizes are available too: the SHA3-256 generator for the common 128-bit tier and the SHA3-512 generator for the 256-bit tier.