Hash Generator & Checksum Verifier

Compute and verify MD5, SHA-1, SHA-256, SHA-384, SHA-512, and CRC-32 digests or HMAC signatures for strings and local files.

Input Text / String

Input Format:

Samples:

Length: 13 chars•Bytes: 13 B

Calculated Hashes6 Algorithms

MD5(128-bit)

Broken (Checksums only)

...

SHA-1(160-bit)

Deprecated (Legacy only)

...

SHA-256(256-bit)

Highly Secure (Standard)

...

SHA-384(384-bit)

Highly Secure

...

SHA-512(512-bit)

Maximum Security

...

CRC-32(32-bit)

Checksum Only (Non-Crypto)

...

How to Generate and Verify Checksums

Select Hashing Mode: Use Text Hash to compute digests for strings and payloads; File Checksum for binary files and packages; Checksum Verifier to compare against an expected release digest; or HMAC Generator for keyed message authentication.
Provide Input: Type or paste text (supports UTF-8, raw Hex strings, or Base64 byte sequences), or drag and drop any local file into the file hashing interface.
Configure Output Encoding: Switch between lowercase hexadecimal (abc), uppercase hexadecimal (ABC), or Base64 encoding via the toolbar controls.
Export Digests: Click the copy button next to an individual digest, or use Copy All to copy all computed algorithm digests simultaneously to your clipboard in a formatted manifest.
Validate Upstream Hashes: Under the Checksum Verifier tab, paste an expected digest from an official package repository or security advisory to automatically verify integrity.

Cryptographic Hash Function Comparison Matrix

Architectural parameters, block dimensions, and practical deployment recommendations across standardized hashing algorithms.

Algorithm	Specification	Digest Size	Block Size	Word Size	Security Status	Practical Use Case
MD5	RFC 1321 (1992)	128 bits (16 B)	512 bits (64 B)	32-bit	Broken (Collisions proven)	S3 ETag verification, non-adversarial deduplication, legacy cache keys
SHA-1	FIPS 180-4 (1995)	160 bits (20 B)	512 bits (64 B)	32-bit	Deprecated (SHAttered collision)	Legacy Git commit hashing, historical TLS cert validation, torrent infohashes
SHA-256	FIPS 180-4 / SHA-2	256 bits (32 B)	512 bits (64 B)	32-bit	Standard (NIST Approved)	TLS 1.3 certificates, Bitcoin PoW, Docker image digests, package signing
SHA-384	FIPS 180-4 / SHA-2	384 bits (48 B)	1024 bits (128 B)	64-bit	High Security (Truncated SHA-512)	NSA Suite B cryptography, enterprise VPNs, high-assurance TLS handshakes
SHA-512	FIPS 180-4 / SHA-2	512 bits (64 B)	1024 bits (128 B)	64-bit	Maximum (NIST Approved)	Digital signatures (Ed25519), shadow password salts, 64-bit server pipelines
CRC-32	IEEE 802.3 (1975)	32 bits (4 B)	Bitwise streaming	32-bit	Non-Crypto (Error detection only)	ZIP/GZIP container headers, Ethernet frame check sequence, PNG chunk validation

Internal Mechanics: Merkle–Damgård Construction & Length Extension

Block Processing & Compression

Algorithms in the MD5 and SHA families operate on the Merkle–Damgård construction. Before processing, the input message is padded with a single 1 bit, followed by necessary 0 bits, and terminated by a 64-bit (or 128-bit in SHA-512) integer encoding the original message length. This ensures the padded stream divides evenly into fixed blocks:

512-bit blocks (64 bytes): MD5, SHA-1, SHA-256.
1024-bit blocks (128 bytes): SHA-384, SHA-512.

Each block passes through a one-way compression function along with the intermediate state from the previous block (initialized with fixed standard Initial Vectors, or IVs).

The Length Extension Flaw & HMAC Solution

Because the final output digest of SHA-256 is merely the raw internal state of the last block compression, naive signatures like Hash(Secret || Message) are vulnerable to Length Extension Attacks. An adversary knowing the message length and digest can continue computing hash rounds with appended data without ever recovering the secret key.

HMAC (RFC 2104) neutralizes this attack through a dual-pass nested hashing architecture using inner and outer padding constants:

HMAC(K, M) = H((K' ⊕ 0x5c) || H((K' ⊕ 0x36) || M))

Practical Traps: Why Checksums Mismatch in Real Environments

1. CRLF vs LF Line Endings

Windows text files and Git repositories with core.autocrlf=true insert carriage returns (\r\n / 0x0D 0x0A), while Linux and macOS use line feeds (\n / 0x0A). Even if the visible text matches character-for-character, byte-level hash outputs differ completely. Always strip carriage returns when comparing cross-platform text payloads.

2. Shell Echo Trailing Newlines

Executing echo "password" | sha256sum appends a trailing newline byte (0x0A) before passing data to the pipe, computing the hash of 9 bytes instead of 8. In bash, use echo -n "password" | sha256sum or printf "%s" "password" | sha256sum.

3. Hexadecimal Case Sensitivity

Standard hash outputs are arbitrary binary byte arrays represented as hexadecimals. While e3b0c442... and E3B0C442... represent the identical byte array, naive string equality (===) evaluates to false. Normalize both strings to lowercase prior to comparison.

4. Out-of-Memory on Large Files

Attempting to read a 4 GB disk image into memory via fs.readFileSync() crashes Node.js or browser heaps. Production hash pipelines stream data in bounded chunks (typically 64 KB to 1 MB) into an incremental hasher (hasher.update(chunk)).

Security Notice: Never Use Fast Hashes (SHA-256 / MD5) for Password Storage

Cryptographic hash functions like SHA-256, SHA-512, and MD5 are deliberately optimized for high throughput. A modern graphics card or ASIC rig can compute upwards of 10 billion SHA-256 hashes per second. If an adversary accesses unsalted or plain SHA-256 password hashes, dictionary searches and brute-force attacks succeed in minutes.

For user authentication credentials, always deploy slow, memory-hard Key Derivation Functions (KDFs):

Argon2id (RFC 9106)

State-of-the-art KDF combining data-dependent and data-independent memory access. Resists GPU parallelization and cache side-channel attacks.

bcrypt (OpenBSD)

Adaptive hashing scheme based on the Blowfish cipher with an adjustable cost factor and 128-bit salt generation. Ubiquitous in production.

scrypt (RFC 7914)

Memory-hard function requiring large working memory blocks, making custom ASIC and FPGA hardware development economically unviable.

Command-Line Quick Reference: Terminal Hash Commands

Standard native shell commands for generating SHA-256 and MD5 digests across operating systems without installing external third-party binaries:

# Linux / POSIX:
sha256sum release.tar.gz
md5sum release.tar.gz
printf "%s" "raw-string" | sha256sum

# macOS (BSD coreutils):
shasum -a 256 release.dmg
md5 release.dmg
printf "%s" "raw-string" | shasum -a 256

# Windows PowerShell:
Get-FileHash -Algorithm SHA256 .\installer.msi
Get-FileHash -Algorithm MD5 .\installer.msi

# Windows Command Prompt:
certutil -hashfile .\installer.msi SHA256

# OpenSSL (cross-platform):
openssl dgst -sha256 release.tar.gz
openssl dgst -sha256 -hmac "secret-key" payload.json

Developer Implementation: Hashing Across Programming Languages

Standard code snippets for computing SHA-256 and MD5 hashes across major software development ecosystems and shell environments.

Language

Node.js•node:crypto streaming & buffer hashing

nodejs

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

// Compute SHA-256 of string
const hash = createHash('sha256').update('data').digest('hex');

// Compute HMAC-SHA256
const hmac = createHmac('sha256', 'secret-key').update('payload').digest('hex');

Web Crypto•Browser & Edge runtime standard

webcrypto

// Compute SHA-256 in browser
const encoder = new TextEncoder();
const data = encoder.encode('data');
const hashBuffer = await crypto.subtle.digest('SHA-256', data);
const hashArray = Array.from(new Uint8Array(hashBuffer));
const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');

Python•hashlib & hmac standard library

python

import hashlib
import hmac

# SHA-256 digest
data = b"data"
sha256_hex = hashlib.sha256(data).hexdigest()

# HMAC-SHA256 signature
sig = hmac.new(b"secret-key", data, hashlib.sha256).hexdigest()

Go•Standard library crypto packages

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
)

func Sha256(data []byte) string {
	sum := sha256.Sum256(data)
	return hex.EncodeToString(sum[:])
}

func HmacSha256(key, message []byte) string {
	mac := hmac.New(sha256.New, key)
	mac.Write(message)
	return hex.EncodeToString(mac.Sum(nil))
}

Rust•sha2 & hmac crates (RustCrypto)

rust

use sha2::{Sha256, Digest};
use hmac::{Hmac, Mac};

// Plain SHA-256
let mut hasher = Sha256::new();
hasher.update(b"data");
let result = hex::encode(hasher.finalize());

// Keyed HMAC-SHA256
type HmacSha256 = Hmac<Sha256>;
let mut mac = HmacSha256::new_from_slice(b"secret-key").unwrap();
mac.update(b"payload");
let hmac_hex = hex::encode(mac.finalize().into_bytes());

C# / .NET•Modern zero-allocation APIs (.NET 7+)

csharp

using System.Security.Cryptography;
using System.Text;

byte[] bytes = Encoding.UTF8.GetBytes("data");
string hashHex = Convert.ToHexStringLower(SHA256.HashData(bytes));

byte[] key = Encoding.UTF8.GetBytes("secret-key");
string hmacHex = Convert.ToHexStringLower(HMACSHA256.HashData(key, bytes));

Java•java.security.MessageDigest & Mac (Java 17+)

java

import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;
import java.util.HexFormat;

MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] digest = md.digest("data".getBytes(StandardCharsets.UTF_8));
String hashHex = HexFormat.of().formatHex(digest);

PHP•Native hash functions (PHP 8+)

php

<?php
$data = 'data';
$key = 'secret-key';

$sha256 = hash('sha256', $data);
$hmac   = hash_hmac('sha256', $data, $key);

Core Applications in Software Engineering

Binary Release Verification: Providing published SHA-256 digests alongside binaries and Linux ISOs enables package managers and users to confirm downloads were not altered in transit.
Content-Addressable Storage (CAS): Git uses SHA-1 / SHA-256 hashes as immutable object identifiers. Docker and OCI container engines identify container image layers strictly by their digest (sha256:7f3b...).
Webhook Authenticity (HMAC): Services including GitHub, Stripe, Shopify, and AWS sign outbound HTTP payloads using HMAC-SHA256 headers so receiving endpoints can verify payload origin and message integrity.
Frontend Cache Invalidation: Bundlers (Vite, Webpack, Rollup) append content-based hashes to filenames (app.[contenthash].js) to ensure client browsers only invalidate cached assets when code changes.
Subresource Integrity (SRI): Browsers verify third-party script tags using cryptographic integrity attributes (integrity="sha384-...") to block execution if a CDN is compromised.

Frequently Asked Questions

How do I verify a downloaded file checksum using SHA-256 or MD5?

Drag and drop your downloaded file into the File Checksum tab, then switch to the Checksum Verifier tab and paste the published hash from the official download site or security advisory. The verifier automatically checks against all calculated digests and displays a match confirmation. In terminal, you can verify via "sha256sum filename" (Linux), "shasum -a 256 filename" (macOS), or "Get-FileHash filename -Algorithm SHA256" (Windows PowerShell).

What is the difference between SHA-256 and MD5, and when should each be used?

MD5 produces a 128-bit (32 hex characters) digest and is cryptographically broken—demonstrated collision attacks mean it must never be used for security signatures, digital certificates, or authentication. However, MD5 remains a fast, effective non-cryptographic checksum for storage deduplication and accidental transfer error detection (such as Amazon S3 ETags). SHA-256 outputs a 256-bit (64 hex characters) digest with robust collision resistance, serving as the modern industry benchmark for software releases, TLS/SSL certificates, and blockchain systems.

Why does my text hash not match the output from the terminal or another tool?

Hash mismatches almost always stem from hidden characters or encoding discrepancies: 1) Trailing Newline: shell commands like 'echo "hello" | sha256sum' append an invisible \n byte (0x0A), hashing 6 bytes instead of 5. Use 'printf "%s" "hello" | sha256sum' or 'echo -n "hello" | sha256sum' instead. 2) Line Endings: Windows text files use CRLF (\r\n), whereas Linux uses LF (\n). 3) Character Encoding: ensure your source string is interpreted as identical binary bytes (e.g. UTF-8 vs UTF-16).

What is an HMAC and how does it differ from a standard hash?

A standard hash (like SHA-256) only guarantees data integrity—proving whether the message was altered. An HMAC (Hash-based Message Authentication Code, RFC 2104) incorporates a shared secret cryptographic key with the message using a dual-pass nested hashing algorithm. This proves both data integrity AND message authenticity (confirming the payload was signed by a party holding the secret key) while preventing length extension attacks. HMAC-SHA256 is universally used for webhook signatures (Stripe, GitHub, Shopify) and REST API authentication.

Does uppercase vs lowercase hex or Base64 encoding change the actual hash?

No. The hash digest is an immutable array of raw binary bytes (e.g., exactly 32 bytes for SHA-256). Hexadecimal is simply a human-readable text representation where lowercase ("a-f") and uppercase ("A-F") represent identical numerical values. Base64 is a more compact 64-character ASCII representation (44 characters for SHA-256 vs 64 hex characters). You can toggle between lowercase hex, uppercase hex, and Base64 in the toolbar to match your specific API format.

Can large files be hashed directly in the browser, and what are the size limits?

Yes, files are processed completely client-side in your browser using the Web Cryptography API and native typed arrays with zero server transmission, guaranteeing complete data privacy. Because in-browser hashing operates within the browser tab's local memory heap, files up to standard browser limits (typically several hundred megabytes up to ~1 GB to 2 GB depending on available system RAM and browser engine) can be hashed smoothly. For multi-gigabyte disk images or massive video archives that exceed browser tab memory allocations, native command-line utilities (such as "sha256sum", "shasum -a 256", or PowerShell "Get-FileHash") are recommended.

Can a cryptographic hash like SHA-256 or MD5 be reversed or decrypted?

No. Hashing is a one-way mathematical function, fundamentally different from encryption. Encryption is reversible using a decryption key, whereas hashing permanently compresses arbitrary-length data into a fixed-length digest, irreversibly discarding input data. Attackers cannot mathematically decrypt a hash; they can only attempt to guess inputs and look up matching outputs in pre-computed databases or rainbow tables.

Why should I never use SHA-256 or MD5 directly to store passwords in a database?

General-purpose cryptographic hash functions are deliberately engineered for high hardware throughput (hundreds of megabytes per second). Modern consumer GPUs and ASIC clusters can compute over 10 billion SHA-256 hashes per second, allowing attackers to crack password databases via brute-force or pre-computed rainbow tables within hours. Password storage requires slow, memory-hard Key Derivation Functions (KDFs) such as Argon2id (RFC 9106), bcrypt, or scrypt, which enforce computational delays and high RAM usage to defeat parallelized hardware attacks.

Hex Converter

UUID Generator

Base64 Encoder & Decoder