SHA-512 Hash Generator (512-bit SHA-2)

What Is SHA-512?

// Hash text using Web Crypto API (SHA-512)
async function sha512(text) {
  const data = new TextEncoder().encode(text);
  const hash = await crypto.subtle.digest('SHA-512', data);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

await sha512('Hello, World!');
// → '374d794a95cdcfd8b35993185fef9ba368f160d8daf432d08ba9f1ed1e5abe6cc69291e0fa2fe0006a52570ef18c19def4e617c33ce52ef0a6e5fbe318cb0387'

SHA-512 Examples

PBKDF2-SHA-512 passphrase for disk encryption

Apple HFS+ catalog node data

NIST SP 800-57 Part 1 Rev 5 — Recommendation for Key Management

POST /api/v3/ledger
Content-Type: application/json
{"amount":500000,"from":"acct-A","to":"acct-B"}

How to Generate SHA-512 Hashes

1. 1

   Paste text or drop a file

   Select the Text tab and paste any string into the input area — the 128-character SHA-512 hash updates as you type. For files, switch to the File tab and drag any file into the dropzone; the browser hashes it locally using the Web Crypto API with no upload. A progress indicator appears for large files (>10 MB). The algorithm picker is already set to SHA-512.

2. 2

   Copy the 128-character hash

   Click the Copy button next to the hash output. The full 128-character lowercase hex string goes to your clipboard — ready to paste into a configuration file, manifest, or API call. Use the Uppercase toggle if your target system requires uppercase hex (e.g., some Windows tools or certificate utilities).

3. 3

   Verify with the Compare tab

   Switch to the Compare tab and paste two SHA-512 hashes side by side. The tool reports match or mismatch using constant-time comparison, which does not leak timing information. Useful for verifying LUKS key derivation outputs across systems, checking HMAC-SHA-512 digests, or confirming long-term archive fingerprints against a stored manifest.

Technical Details

Algorithm: 1024-bit blocks, 80 rounds, 64-bit words

SHA-512 processes input in 1024-bit (128-byte) blocks, applying 80 rounds of bitwise operations (Ch, Maj, Σ0, Σ1 functions using 64-bit rotations and shifts) with constants derived from the cube roots of the first 80 primes. The internal state consists of eight 64-bit words (512 bits total). This is the same structure as SHA-384 — the only differences between SHA-384 and SHA-512 are the initialization vector and the fact that SHA-512 retains all 512 bits of output. Implementation: FIPS 180-4 sections 4.2.3 and 6.4.

Output: 512 bits, 128 hex characters

Always exactly 128 characters in the range [0-9a-f] (lowercase) or [0-9A-F] (uppercase). The output is fixed-length regardless of input size. At 512 bits, this is the longest output in the SHA-2 family, providing 256 bits of collision resistance — the standard recommendation for data that must remain tamper-evident beyond 2050.

Performance: faster than SHA-256 on 64-bit hardware

On x86-64 and ARM64 CPUs, SHA-512 processes 1024-bit blocks with 64-bit native operations, delivering approximately 600–1,000 MB/s in a browser (Web Crypto API) and 1–4 GB/s in native tools with hardware SHA extensions. SHA-256 processes 512-bit blocks with 32-bit operations, yielding roughly 400–700 MB/s — slower despite the smaller output size. On 32-bit hardware the relationship reverses: 64-bit arithmetic requires emulation and SHA-256 is faster.

Standards: FIPS 180-4, NIST SP 800-107, RFC 6234

Standardized in FIPS 180-2 (2001), current version FIPS 180-4 (2015). Approved by NIST for all security strength levels through 2030 and beyond under NIST SP 800-131A Rev 2. Referenced in RFC 6234 (SHA algorithms in IETF protocols), RFC 5869 (HKDF), and RFC 2898 (PBKDF2). Retained in the CNSA Suite for long-term security; NIST IR 8105 recommends SHA-512 for applications requiring post-quantum security margins.

Best Practices

Prefer SHA-512 when collision resistance beyond 128 bits is required

For most everyday uses — file checksums, Git objects, JWT signatures, TLS certificate fingerprints — SHA-256 is the standard. Upgrade to SHA-512 when: (1) data must remain tamper-evident for 20+ years, (2) a protocol specifies 256-bit security strength, or (3) you are on 64-bit hardware and SHA-512's performance advantage removes any barrier to using the stronger option. On modern servers and browsers the performance difference favors SHA-512, so there is rarely a reason not to use it for new 64-bit applications.

Use HMAC-SHA-512 for keyed message authentication

When you need a keyed MAC — authenticating API requests, signing tokens, or verifying message integrity with a shared secret — use HMAC-SHA-512 rather than a custom construction. HMAC wraps SHA-512 in a proven construction (RFC 2104) that is secure even against length-extension attacks and related-key weaknesses. Avoid concatenating a key directly with the message (HASH(key || message)) — this is vulnerable to length-extension attacks on raw SHA-512. Use a well-tested HMAC library: Node.js crypto.createHmac('sha512', key), Python hmac.new(key, msg, 'sha512'), or libsodium's crypto_auth_hmacsha512().

SHA-512/256 for length-extension immunity with SHA-2 speed

If your use case requires length-extension immunity and SHA-2 library compatibility (not SHA-3), consider SHA-512/256 (FIPS 180-4 section 5.3.6) instead of raw SHA-256. SHA-512/256 uses SHA-512's fast 64-bit arithmetic but truncates output to 256 bits with a distinct IV, making it length-extension resistant. It is faster than SHA-256 on 64-bit hardware and provides the same 128-bit collision resistance as SHA-256 with better architectural safety. The caveat: library support is less universal than SHA-256 or SHA-512 — verify your target runtime implements it before designing around it.

Use constant-time comparison when verifying SHA-512 hashes in code

When comparing two SHA-512 hashes in code, use a constant-time equality function: Node.js crypto.timingSafeEqual(), Python hmac.compare_digest(), Go subtle.ConstantTimeCompare(). Naive string equality (=== or ==) leaks timing information — an attacker making many requests can reconstruct the expected hash byte-by-byte in about 1,024 comparisons (128 chars × 8 bits). This is critical defense-in-depth for any authentication or MAC verification system. This tool's Compare tab already uses constant-time comparison.

SHA-512 FAQ