NV ToolkitFormat · Validate · Convert

Developer Tools

SHA-256 Hash Generator

Just SHA-256, done properly: hex or Base64 output, HMAC-SHA256 for webhook signatures, and file checksums — nothing leaves your browser.

Updated

  • SHA-256 only — no algorithm picking
  • Hex ⇄ Base64 output toggle
  • HMAC-SHA256 with a secret key

Runs entirely in your browser — nothing you paste or open here is uploaded, logged, or stored.How we handle data →

Why a dedicated SHA-256 page

One algorithm, the two encodings you actually need

Most SHA-256 use cases today don't need MD5 or SHA-512 in the way — they need SHA-256 in hex for a release checksum, or in Base64 for a signature header. This page gives you both, plus HMAC, without scrolling past four other algorithms.

Hex or Base64, one click

SHA-256 digests are the same 32 bytes whichever way you read them — this page lets you flip between the hex string most checksums use and the Base64 string most signature headers use.

Files never leave your device

Drop a release archive or backup and it's digested locally via WebCrypto — no upload, no server round-trip, verifiable by disconnecting your network after the page loads.

Verified against FIPS 180-4

The known-answer vectors below (the empty string and "abc") are the standard test inputs used to confirm a SHA-256 implementation is correct — check this page's output against them yourself.

HMAC for signature verification

Toggle HMAC mode, paste the shared secret, and compute the keyed digest webhook providers expect you to compare against their signature header.

Learn more

SHA-256 known-answer test vectors (FIPS 180-4)

A known-answer test checks a hash implementation against inputs whose correct output is published and fixed, so a bug shows up as a mismatch rather than a silent wrong answer. The two vectors below — the empty string and the three-byte message "abc" — are the standard first checks for any SHA-256 implementation; paste either input above with HMAC off and hex output selected, and the digest should match exactly.

SHA-256 known-answer vectors
InputSHA-256 (hex)SHA-256 (Base64)
"" (empty string, 0 bytes)e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85547DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=
"abc" (3 bytes)ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015adungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

Verifying webhook signatures with HMAC-SHA256

HMAC-SHA256 is how most webhook providers prove a request actually came from them: they compute a keyed digest of the exact request body using a secret only the two of you know, and send it in a header for you to recompute and compare. Two well-documented conventions show the encoding split this page exists for — GitHub sends its signature as hex, prefixed with the algorithm name (a header shaped like sha256=<hex-digest>), while Shopify sends its HMAC as Base64 with no prefix. Both are the same underlying operation; only the header format and text encoding differ.

To verify one yourself: capture the exact raw request body (not a re-serialized or pretty-printed copy — re-formatting changes the bytes and breaks the match), turn on HMAC mode here, paste the body as the input and the provider's webhook secret as the key, switch the output encoding to match what the header uses, and compare. A mismatch almost always means the body was altered in transit (by a proxy, a logging tool, or your own code) rather than a wrong secret.

Computing SHA-256 from the command line

Every platform ships a way to compute SHA-256 without a browser, and cross-checking this page against one of them is the fastest way to confirm a file's digest before you trust it.

SHA-256 on the command line, by platform
PlatformCommand
Linuxsha256sum file.txt
macOSshasum -a 256 file.txt
Windows (PowerShell)Get-FileHash file.txt -Algorithm SHA256
Any platform with OpenSSLopenssl dgst -sha256 file.txt
Python 3python3 -c "import hashlib;print(hashlib.sha256(open('file.txt','rb').read()).hexdigest())"

Help

Frequently asked questions

Everything you need to know about the SHA-256 Hash Generator.

01How is this different from the general Hash Generator?

The general Hash Generator computes five algorithms at once (MD5, SHA-1, SHA-256, SHA-384, SHA-512) in hex only — built for 'I don't know which algorithm the checksum uses, show me all of them.' This page does one thing: SHA-256 (and HMAC-SHA256) in either hex or Base64, for the common case where you already know you need SHA-256 and want the right text encoding without scrolling past four other digests. Need MD5 or SHA-512 too? The Hash Generator computes all of them side by side.

02Why would I want Base64 instead of hex?

They're the same 32 bytes written two different ways — hex uses 64 characters (0-9, a-f), Base64 uses about 44. Release checksums and git/Docker content hashes almost always use hex; some HTTP signature and content-integrity conventions (and several webhook providers) use Base64 instead, because it's shorter. If a header or field you're matching against looks like a mix of upper and lower case letters, digits, +, / and possibly a trailing =, it's Base64, not hex — switch the toggle before pasting it into the compare field.

03Why did my Base64 checksum fail to match even though the data is identical?

Base64 is case-sensitive — unlike hex, 'A' and 'a' are different characters in a Base64 string, so this page never uppercases or lowercases Base64 output or your pasted comparison value (the A–F case toggle only applies in Hex mode). Paste the Base64 value exactly as published, including a trailing = padding character if it has one.

04How do I verify a webhook's HMAC-SHA256 signature?

Turn on HMAC mode, paste the exact raw request body the provider signed (whitespace and all — a single re-formatted space breaks the match), enter the shared secret, and compare the result to the signature header. The encoding varies by provider: some send the signature as hex (often prefixed, e.g. sha256=<hex>), others as Base64 — pick the matching output mode here before comparing. If nothing matches, the most common cause is comparing against a re-serialized copy of the payload rather than the exact bytes that were signed.

05Is SHA-256 still considered secure?

Yes — unlike MD5 and SHA-1, SHA-256 has no known practical collision or preimage attack and is the digest NIST and virtually every security standard currently recommends. It's the algorithm behind Bitcoin's proof-of-work, TLS certificate fingerprints, and most modern release-checksum and webhook-signature schemes precisely because it has held up.

Keep working

Related tools