SHA-256 hash generator
This tool turns any text into its SHA-256 digest — a fixed 256-bit fingerprint shown as 64 hexadecimal characters. It’s used to verify that a file or message hasn’t changed, to compare values without storing the original, and as a building block in TLS, blockchains, and digital signatures. The hash updates as you type and never leaves your browser.
From text to digest in three steps
The input text is encoded to UTF-8 bytes with TextEncoder, then hashed by the
browser’s native Web Crypto API via
crypto.subtle.digest("SHA-256", data). The
resulting ArrayBuffer is converted to a lowercase hex string. SHA-256 is
deterministic (same input, same output) and one-way (you cannot derive the input
from the hash), and a single changed character flips roughly half the output bits.
The algorithm itself is defined in NIST FIPS 180-4, the Secure Hash Standard: the input is padded, split into 512-bit blocks, and each block is run through 64 rounds of mixing operations that update eight 32-bit working variables. The final state of those eight variables, concatenated, is the 256-bit digest.
Example outputs
| Input | SHA-256 (first 16 of 64 hex chars) |
|---|---|
hello | 2cf24dba5fb0a30e… |
Hello | 185f8db32271fe25… |
| (empty string) | e3b0c44298fc1c14… |
Note how hello and Hello produce entirely different digests — that
sensitivity to change is the point. An empty string still produces a full 64-character
hash; SHA-256 always outputs exactly 256 bits regardless of input length.
When and why to use SHA-256
SHA-256 belongs to the SHA-2 family, standardised by NIST, and is currently the most widely deployed cryptographic hash in the world. Common practical uses include:
- File integrity checking. Software distributors publish SHA-256 checksums alongside downloads. You hash the file you receive and compare it to the published value; any mismatch indicates corruption or tampering.
- Git object IDs. Every commit, tree, and blob in a Git repository is addressed by a hash of its content — SHA-1 by default, with an opt-in SHA-256 object format available in modern Git. This content-addressing is what makes Git tamper-evident.
- TLS certificates. Certificate authorities sign with RSA or ECDSA over a SHA-256 digest of the certificate data.
- HMAC authentication. Append a secret key to a message and hash it (HMAC-SHA-256) to produce an unforgeable authentication tag — used in AWS API signatures and JWT HS256 tokens.
- Bitcoin and blockchains. Bitcoin’s proof-of-work and block chaining both rely on double-SHA-256.
The SHA-2 family at a glance
SHA-256 is one member of the SHA-2 family defined in FIPS 180-4. The variants differ in output length and internal word size:
| Algorithm | Output bits | Hex length | Internal words | Typical use |
|---|---|---|---|---|
| SHA-224 | 224 | 56 | 32-bit | Truncated variant, rare today |
| SHA-256 | 256 | 64 | 32-bit | The general-purpose default |
| SHA-384 | 384 | 96 | 64-bit | TLS suites, higher margin |
| SHA-512 | 512 | 128 | 64-bit | Faster on 64-bit CPUs |
A useful, non-obvious fact: on modern 64-bit processors without SHA hardware extensions, SHA-512 often computes faster than SHA-256 because it processes data in 64-bit words — the choice between them is about output size and ecosystem compatibility, not speed alone.
How strong is “secure” here, in numbers
Two properties define a cryptographic hash’s strength. Preimage resistance (finding an input for a given hash) requires on the order of 2²⁵⁶ guesses for SHA-256 — a number vastly beyond any conceivable computation. Collision resistance (finding any two inputs with the same hash) is bounded by the birthday paradox at roughly 2¹²⁸ operations — still far out of reach. No practical collision or preimage attack against SHA-256 has ever been published, which is why NIST continues to approve it. Contrast MD5 (collisions computable in seconds on a laptop) and SHA-1 (public collision demonstrated in 2017): both are broken for signatures and certificates, and any system still using them for security should migrate.
What SHA-256 is not suitable for
SHA-256 is designed to be fast, which is an asset for integrity checks but a liability for password storage. A modern GPU can compute billions of SHA-256 hashes per second, making brute-force attacks practical. For storing passwords, use a purpose-built, deliberately slow algorithm: bcrypt, scrypt, or Argon2. SHA-256 can still participate as the underlying hash inside bcrypt (which does not use raw SHA-256) but should never be used as the sole layer for password hashing.
Privacy note
This tool runs the entire hash computation inside your browser using the built-in Web Crypto API. No text, hash, or metadata is ever sent to a server. It is therefore safe to hash sensitive strings — API keys, contract text, personal identifiers — directly in this tool without any upload risk.