SHA3-384 Hash Generator

Compute SHA3-384 cryptographic hashes locally in your browser.

Result

Input

Your input never leaves your device; hashing is done locally in your browser.

What is SHA3-384 Hash?

SHA3-384 is a higher-security variant of the NIST SHA-3 family based on the Keccak sponge construction. It produces a 384-bit (96-character hex) digest, equivalent to the security level of SHA-384 in the SHA-2 family.

Sponge construction — SHA-3 uses a fundamentally different internal structure (sponge construction) from SHA-2 (Merkle-Damgård), providing inherent resistance to length extension attacks.

192-bit security — provides 192-bit security against collision attacks, making it suitable for high-security applications.

Deterministic — the same input always produces the same hash.

Avalanche effect — changing a single bit of input flips roughly half the output bits.

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.

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

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 based on the Keccak sponge construction. It produces a fixed 384-bit (96-character hex) digest and provides 192-bit security against collision attacks, making it suitable for high-security applications.

SHA3-384 is based on the Keccak sponge construction (NIST FIPS 202), while SHA-384 is based on the Merkle-Damgård construction (NIST FIPS 180-4). SHA3-384 has inherent resistance to length extension attacks and offers better post-quantum security margins.

Yes, SHA3-384 is considered cryptographically secure and is approved by NIST under FIPS 202. It provides 192-bit security and is part of the SHA-3 family, which was designed as a backup in case vulnerabilities were found in SHA-2.

No. SHA3-384 is a one-way function. You cannot recover the original input from its hash. This preimage resistance is a fundamental property of cryptographic hash functions.

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