What are SHA3-384's FIPS 202 use cases?

Under NIST FIPS 202 , SHA3-384 targets applications that want a high security margin without stepping up to the full 512-bit output: Government and military systems — its 192-bit collision resistance satisfies the most demanding classified-data requirements (NIST generally requires a minimum of 112-128 bits; 192 adds comfortable headroom). High-security digital signatures — FIPS 186-5 approves SHA3-384 with DSA, ECDSA, and RSA, making it suitable for certificate authorities and trust chains. Financial and regulated systems — regulations that mandate a NIST-approved hash with a strong margin often specify 384-bit outputs. Long-term archival — 96-character digests keep decades-old data verifiable while resisting advances in cryptanalysis. Choose SHA3-384 when your standard calls for a 384-bit digest and you want the SHA-3 family's sponge-based security.

How do I generate a SHA3-384 checksum from the command line?

Most Linux and macOS systems have no native sha3sum binary, so OpenSSL is the reliable cross-platform option: Linux / Windows / any OS — openssl dgst -sha3-384 filename Python (any OS) — cat filename | python3 -c "import hashlib,sys;print(hashlib.sha3_384(sys.stdin.buffer.read()).hexdigest())" Compare the output to the hash on this page, or paste it into the Verify tab — openssl-style ALG(file)= hash output is parsed automatically.

SHA3-384 Hash Generator — Keccak-based SHA-3 Hashing

A 96-character hash for high-security workloads — 192-bit collision protection for government and financial systems.

Result

Input

Iterations

Hash chaining feeds each digest back in as the next input: H(H(…H(input))). Bitcoin uses double SHA-256 (2). This is not a password KDF — use PBKDF2, bcrypt, or scrypt for passwords.

What is SHA3-384 Hash?

SHA3-384 produces a 96-character hash with 192-bit security — the SHA-3 sibling of SHA-384 for high-security certificates, government systems, and long-lived data.

Sponge at 192-bit — SHA3-384 draws on Keccak's sponge construction, producing a 384-bit output for 192-bit collision security — matching SHA-384's level but with inherent length-extension resistance.

NIST standard — defined in FIPS 202, approved for government and military grade security.

Zero-Server Tool Data Guarantee

All hashing happens locally in your browser using the @noble/hashes library. Your input is never sent to any server.

How to Use

Enter Your Text

Type or paste the text you want to hash into the input area.

View the Hash

The SHA3-384 hash is computed instantly as you type. It is displayed as a 96-character hex string.

Verify a Checksum

Switch to the Verify tab and paste a published checksum — raw hex or openssl dgst -sha3-384 output works — to confirm it matches the hash of your input.

Copy the Result

Use the copy button to save the hash to your clipboard.

Common Use Cases

High-Security Digital Signatures

Use SHA3-384 for digital signatures requiring 192-bit security in certificate authorities and trust chains.

Government & Military Applications

Meets NIST FIPS 202 requirements for classified and sensitive government information protection.

Financial Systems

Secure financial transaction verification where high-security hash functions are mandated by regulation.

Long-Term Data Protection

Archive integrity verification for data that must remain secure for decades against advancing threats.

Implementation Examples

JavaScriptBrowser (@noble/hashes)

import { sha3_384 } from '@noble/hashes/sha3.js';

const hashBytes = sha3_384(new TextEncoder().encode('hello world'));
const hashHex = Array.from(new Uint8Array(hashBytes))
    .map(b => b.toString(16).padStart(2, '0')).join('');

console.log(hashHex);
// "83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b"

SHA3-384 vs SHA-384 vs SHA3-512

Property	SHA3-384	SHA-384	SHA3-512
Output size	384-bit (96 hex)	384-bit (96 hex)	512-bit (128 hex)
Security level	192-bit (unbroken)	192-bit (unbroken)	256-bit (unbroken)
Standard	NIST FIPS 202	NIST FIPS 180-4	NIST FIPS 202
Construction	Sponge (Keccak)	Merkle-Damgård	Sponge (Keccak)
Length extension resistant	Yes (inherent)	No	Yes (inherent)
Quantum resistance	Better (sponge)	Weaker	Better (sponge)
Recommended use	High-security apps	Legacy compatibility	Maximum SHA-3 security

Which SHA-3 Size?

SHA-3 size	Output	Collision resistance	Best for
SHA3-224	56 hex	112-bit	Embedded / constrained devices, compact checksums
SHA3-256	64 hex	128-bit	General-purpose SHA-3, NIST FIPS 202 compliance
SHA3-384You're here	96 hex	192-bit	Government / high-security systems, long-term archival
SHA3-512	128 hex	256-bit	Maximum security margin, classified data, post-quantum planning

All four sizes use the same Keccak sponge construction from NIST FIPS 202 — they differ only in output length and security margin.

Production Best Practices & Security

Follow NIST FIPS 202 — SHA3-384 is a standardized algorithm; use it where NIST compliance is required for high-security applications. Why:NIST FIPS 202 compliance is mandatory for many government systems. Using a standardized algorithm ensures it has been peer-reviewed and meets rigorous security requirements.

Don't use SHA3-384 alone for passwords — it's too fast; use bcrypt, scrypt, or PBKDF2 instead. Why:SHA3-384 can process hundreds of millions of hashes per second, allowing attackers to test enormous password dictionaries in minutes without key stretching.

Use a salt for uniqueness — without a salt, identical inputs produce identical hashes, enabling rainbow table attacks. Why:A unique per-user salt means each hash must be attacked independently, making precomputed rainbow tables useless and drastically increasing the cost of mass password cracking.

Use for high-security applications — SHA3-384 provides 192-bit security, suitable for government and military grade requirements. Why:192-bit collision resistance exceeds the 128-bit minimum for top-secret classification and provides a comfortable security margin against both classical and near-term quantum attacks.

Consider post-quantum readiness — SHA-3's sponge construction offers different security properties than SHA-2. Why:SHA-3's underlying Keccak permutation has a different algebraic structure than SHA-2, meaning a quantum breakthrough against one family would not necessarily affect the other, providing cryptographic diversity.

Verify integrity end-to-end — compute the hash at the source and verify it at the destination to detect tampering. Why:If an attacker modifies data in transit, the hash will change completely due to the avalanche effect. Comparing source and destination hashes is the most reliable way to detect any alteration.

Frequently Asked Questions

SHA3-384 is a cryptographic hash function from the NIST SHA-3 family defined in FIPS 202. It uses the Keccak sponge construction with a 1600-bit state array and produces a fixed 384-bit (96-character hex) output.

SHA3-384 provides 192-bit collision resistance (two different inputs producing the same hash — a collision — is practically impossible to find), offering a substantial security margin that exceeds the requirements of most applications — including classified government systems.

It is the SHA-3 equivalent of SHA-384 but with the Keccak sponge's inherent resistance to length extension attacks.

While both produce 384-bit (96-character hex) digests, SHA3-384 uses the Keccak sponge (NIST FIPS 202) and SHA-384 uses the Merkle-Damgård construction (NIST FIPS 180-4).

SHA3-384 has inherent resistance to length extension attacks without requiring HMAC, offers algorithm diversity alongside SHA-2, and provides a higher security margin against potential quantum cryptanalysis due to its permutation-based design.

SHA-384 benefits from widespread hardware acceleration, making it faster on most platforms.

Yes. SHA3-384 is approved by NIST under FIPS 202 and provides 192 bits of collision resistance — well beyond the security level required for any current practical application.

The Keccak algorithm underwent a rigorous multi-year public competition and has been extensively analyzed by the cryptographic community since 2008.

SHA3-384 is suitable for high-security environments including government systems, long-term archival, and any scenario where the strongest possible integrity assurance is desired.

No. SHA3-384 uses the Keccak sponge construction, which is a one-way permutation. The sponge's 1600-bit state absorbs and discards input information through 24 rounds of nonlinear permutation.

This process mathematically cannot be inverted to recover the original input. This preimage resistance is fundamental to all cryptographic hash functions and is what makes SHA3-384 suitable for integrity verification, digital signatures, and other security-critical applications.

On most modern hardware, SHA-384 is faster because it shares SHA-512's efficient 64-bit word design.

SHA3-384 lacks widespread hardware acceleration as of 2026, making it 2-5x slower for bulk hashing.

However, SHA3-384 provides inherent length extension resistance and algorithm diversity. Choose SHA3-384 when post-quantum readiness, sponge construction benefits, or protocol mandates outweigh raw throughput.

Under NIST FIPS 202, SHA3-384 targets applications that want a high security margin without stepping up to the full 512-bit output:

Government and military systems — its 192-bit collision resistance satisfies the most demanding classified-data requirements (NIST generally requires a minimum of 112-128 bits; 192 adds comfortable headroom).
High-security digital signatures — FIPS 186-5 approves SHA3-384 with DSA, ECDSA, and RSA, making it suitable for certificate authorities and trust chains.
Financial and regulated systems — regulations that mandate a NIST-approved hash with a strong margin often specify 384-bit outputs.
Long-term archival — 96-character digests keep decades-old data verifiable while resisting advances in cryptanalysis.

Choose SHA3-384 when your standard calls for a 384-bit digest and you want the SHA-3 family's sponge-based security.

Most Linux and macOS systems have no native sha3sum binary, so OpenSSL is the reliable cross-platform option:

Linux / Windows / any OS — openssl dgst -sha3-384 filename
Python (any OS) — cat filename | python3 -c "import hashlib,sys;print(hashlib.sha3_384(sys.stdin.buffer.read()).hexdigest())"

Compare the output to the hash on this page, or paste it into the Verify tab — openssl-style ALG(file)= hash output is parsed automatically.