SHA-256 Hash Generator

How SHA-256 works

SHA-256 is part of the SHA-2 family, designed by the NSA and published by NIST in 2001 (the current standard is FIPS 180-4). The input is padded to a multiple of 512 bits, with its length stored at the end. Each 512-bit block then goes through 64 rounds that mix eight 32-bit values with rotations, additions and fixed constants. Those eight values after the last block are the hash: 32 bytes, shown as 64 hex or 44 Base64 characters.

Finding an input for a given hash would take about 2^256 attempts, and finding any two inputs with the same hash about 2^128. You'll meet SHA-256 in TLS certificates, Bitcoin block hashes, Docker image digests (sha256:...), the SHA256SUMS files next to Linux ISO downloads, and HMAC-signed webhooks and HS256 JWTs.

MD5, SHA-1, SHA-256, SHA-384 or SHA-512?

All five are here so you can match whatever a system hands you. For anything new, choose SHA-256.

• MD5: 32 hex characters. Collisions have been easy since 2004, and one was used to forge a CA certificate in 2008. Fine for spotting accidental corruption or as a cache key, never for security.
• SHA-1: 40 hex characters. A public collision was published in 2017. Don't use it for signatures or certificates.
• SHA-256: 64 hex characters. The usual pick for checksums, signatures and HMAC. No practical attack is known.
• SHA-384: SHA-512 with different starting values, cut to 96 hex characters. Used in Subresource Integrity and TLS suites like TLS_AES_256_GCM_SHA384.
• SHA-512: 128 hex characters, built on 64-bit words and 80 rounds. On 64-bit processors without SHA-256 hardware support it's often faster than SHA-256 for long input.

Why your hash doesn't match another tool

When two tools disagree, they were given different bytes. Check these first:

• A hidden newline. echo hello | sha256sum hashes hello plus a line break and prints 5891b5b5.... Use printf '%s' hello or echo -n.
• Windows line endings. hello followed by CR and LF hashes to cd2eca35..., so the same file can hash differently on Windows and Linux.
• Unicode normalization. café written with one é character, or with e plus a combining accent, looks the same but hashes to 850f7dc4... or 81ef060b....
• Hex pasted as text. The text box hashes characters, so 48656c6c6f is hashed as 10 characters (d8e0f838...), not as the 5 bytes of Hello. To hash raw bytes, save them to a file and drop it.
• UTF-16. .NET code using Encoding.Unicode hashes different bytes than this page, which always uses UTF-8.

HMAC and webhook signatures

Anyone can hash a message, so a plain hash proves nothing about who sent it. HMAC (RFC 2104) mixes a secret key into the hash, and only someone with the key can produce the same value. Webhook providers use it with different header formats:

• GitHub: X-Hub-Signature-256: sha256=<hex> over the raw body. Paste the whole value, prefix included.
• Stripe: Stripe-Signature: t=<timestamp>,v1=<hex>. The signed text is the timestamp, a dot, then the body. Hash that joined string and paste the v1=… part; the prefix is removed for you.
• Shopify: Base64 HMAC-SHA256 in X-Shopify-Hmac-Sha256. Paste it as it is.

Checking signatures in your own code

Don't build a MAC as sha256(secret + message): SHA-256 allows length extension attacks on that construction, which is the problem HMAC solves. And compare signatures with a constant-time function such as crypto.timingSafeEqual (Node.js) or hmac.compare_digest (Python). A normal string comparison stops at the first wrong byte, and that timing can leak the right signature.

Verify a file checksum from the command line

On a server, or for files of several gigabytes, use the built-in commands:

sha256sum file.iso
# check every file listed in a checksum file:
sha256sum -c SHA256SUMS

shasum -a 256 file.iso

Get-FileHash .\file.iso -Algorithm SHA256

certutil -hashfile file.iso SHA256

SHA-256 and HMAC in code

Each snippet hashes the UTF-8 text hello, and the HMAC lines use the key secret.

const data = new TextEncoder().encode("hello");
const hash = await crypto.subtle.digest("SHA-256", data);
const hex = Array.from(new Uint8Array(hash), (b) => b.toString(16).padStart(2, "0")).join("");
// '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'

import { createHash, createHmac } from "node:crypto";

createHash("sha256").update("hello").digest("hex");
// '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'
createHmac("sha256", "secret").update("hello").digest("hex");
// '88aab3ede8d3adf94d26ab90d3bafd4a2083070c3bcce9c014ee04a443847c0b'

import hashlib, hmac

hashlib.sha256("hello".encode()).hexdigest()
hmac.new(b"secret", b"hello", hashlib.sha256).hexdigest()

sum := sha256.Sum256([]byte("hello"))
fmt.Println(hex.EncodeToString(sum[:]))

byte[] hash = MessageDigest.getInstance("SHA-256")
    .digest("hello".getBytes(StandardCharsets.UTF_8));
String hex = HexFormat.of().formatHex(hash); // Java 17+

Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes("hello"))); // .NET 5+, uppercase hex

hash("sha256", "hello");
hash_hmac("sha256", "hello", "secret");

printf '%s' 'hello' | sha256sum      # Linux
printf '%s' 'hello' | shasum -a 256   # macOS