SHA-1 Hash Generator
Compute 160-bit SHA-1 checksums for Git commit comparisons, legacy signature verification, and file integrity checks.
Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.
What is SHA-1?
SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function designed by the United States National Security Agency (NSA) and published as a Federal Information Processing Standard by the National Institute of Standards and Technology (NIST) in 1995 under FIPS PUB 180-1.
SHA-1 ingests an arbitrary-length message stream (up to $2^{64}-1$ bits) and processes it through an iterative compression structure to produce a deterministic, fixed-size 160-bit (20-byte) message digest, typically rendered as a 40-character hexadecimal string:
$$\text{SHA-1}("Hello\ World") = \texttt{0a4d55a8d778e5022fab701977c5d840bbc486d0}$$
For nearly two decades, SHA-1 served as the foundational cryptographic primitive securing the global internet: anchoring Transport Layer Security (TLS/SSL) certificates, authenticating SSH sessions, signing PGP/GPG software releases, verifying file integrity in peer-to-peer BitTorrent networks, and uniquely identifying commits in the Git version control system.
Today, however, SHA-1 is cryptographically broken. Practical collision attacks demonstrate that malicious adversaries can generate two different files that yield the identical SHA-1 hash digest, allowing digital signature forgery and supply chain compromises.
The Internal Mechanics of the SHA-1 Algorithm
SHA-1 is built upon the classic Merkle-Damgård construction, processing inputs in discrete 512-bit blocks through 80 sequential processing rounds:
flowchart TD
Input["Input Message (Arbitrary Length)"] --> Pad["Message Padding: Append '1' Bit + Zeros + 64-bit Length"]
Pad --> Blocks["Divide into 512-bit Chunks (M_1, M_2, ... M_n)"]
InitState["Initialize 160-bit State Register: H_0 to H_4 (A, B, C, D, E)"] --> RoundProc["80 Processing Rounds per Block"]
Blocks --> RoundProc
subgraph Rounds [80 Round Compression Function]
RoundProc --> R1["Rounds 0-19: Ch(B,C,D) + K_0"]
R1 --> R2["Rounds 20-39: Parity(B,C,D) + K_1"]
R2 --> R3["Rounds 40-59: Maj(B,C,D) + K_2"]
R3 --> R4["Rounds 60-79: Parity(B,C,D) + K_3"]
end
Rounds --> StateAdd["Davies-Meyer Feed-Forward: Add Input State to Output State"]
StateAdd --> FinalDigest["160-bit Hex Digest Output (40 Characters)"]
1. Message Padding & Block Alignment
- A single
1bit is appended to the message payload (0x80). - Zero bits (
0x00) are padded until the message length is congruent to 448 modulo 512 (leaving exactly 64 bits free). - The original message length is serialized as a 64-bit big-endian integer, filling the final block to exactly 512 bits.
2. The 80 Round Functions & Logic Stages
The 80 rounds operate across five 32-bit state registers ($A, B, C, D, E$), initialized with fixed magic constants:
- $H_0 = \texttt{0x67452301}$
- $H_1 = \texttt{0xEFCDAB89}$
- $H_2 = \texttt{0x98BADCFE}$
- $H_3 = \texttt{0x10325476}$
- $H_4 = \texttt{0xC3D2E1F0}$
Across four distinct 20-round intervals, the algorithm alternates non-linear Boolean functions:
- Rounds 0–19: $\text{Ch}(B, C, D) = (B \land C) \lor (\neg B \land D)$
- Rounds 20–39: $\text{Parity}(B, C, D) = B \oplus C \oplus D$
- Rounds 40–59: $\text{Maj}(B, C, D) = (B \land C) \lor (B \land D) \lor (C \land D)$
- Rounds 60–79: $\text{Parity}(B, C, D) = B \oplus C \oplus D$
In each round $t$, a temporary register updates the state using circular left shifts ($S^k$):
$$T = S^5(A) + f_t(B, C, D) + E + W_t + K_t$$
$$E = D; \quad D = C; \quad C = S^{30}(B); \quad B = A; \quad A = T$$
Cryptographic Status & Timeline of Collision Attacks
A secure cryptographic hash function must satisfy three fundamental criteria: Pre-image Resistance (one-way), Second Pre-image Resistance (weak collision resistance), and Collision Resistance (strong collision resistance). SHA-1 completely failed the third:
timeline
title The Cryptanalytic Fall of SHA-1
1995 : NIST Publishes FIPS 180-1 (SHA-1)
2005 : Wang et al. Prove Theoretical Collision in 2^69 operations
2011 : NIST SP 800-131A formally restricts SHA-1 for federal signatures
2017 : CWI & Google Announce "SHAttered" (First Practical PDF Collision)
2017 : Chrome, Firefox, and Safari block SHA-1 TLS certificates
2020 : Leurent & Peyrin publish "Shambles" (Chosen-Prefix Collision Attack)
2030 : NIST Mandates complete federal phase-out of all remaining SHA-1 usage
1. The SHAttered Attack (2017)
In February 2017, researchers from CWI Amsterdam and Google announced SHAttered, generating the world's first real-world collision. They created two distinct PDF documents with different content (one showing a blue contract, the other a red contract) that produced the exact same SHA-1 hash. The attack required $9 \times 10^{18}$ SHA-1 evaluations—roughly 6,500 years of single-CPU computation, accomplished in months using 110 high-end GPUs.
2. The Shambles Chosen-Prefix Attack (2020)
In 2020, researchers Gaëtan Leurent and Thomas Peyrin demonstrated a chosen-prefix collision. Unlike identical-prefix collisions, a chosen-prefix collision allows an attacker to take two completely arbitrary payloads (such as two different PGP public keys or two conflicting software binaries) and append calculated junk bytes to force identical SHA-1 hashes. The attack cost less than $45,000 in cloud GPU rentals, rendering SHA-1 unusable for digital signatures.
Modern Cryptographic Hash Algorithm Comparison Matrix
| Algorithm | Digest Size | Internal Block Size | Collision Resistance | Practical Collision Demonstrated? | Typical Throughput (MB/s) | NIST Recommendation Status |
|---|---|---|---|---|---|---|
| MD5 | 128 bits | 512 bits | 0 bits (Trivially Broken) | Yes (Instant on smartphone) | 750 MB/s | Prohibited for security |
| SHA-1 | 160 bits | 512 bits | 0 bits (Broken) | Yes (SHAttered & Shambles) | 620 MB/s | Deprecated; phase out by 2030 |
| SHA-256 | 256 bits | 512 bits | 128 bits (Full Security) | No (Mathematically secure) | 480 MB/s | Recommended Standard |
| SHA-512 | 512 bits | 1024 bits | 256 bits (Full Security) | No (Mathematically secure) | 710 MB/s (64-bit native) | Recommended Standard |
| SHA-3 (Keccak) | 256 / 512 bits | Sponge state | Full Security Margin | No (Sponge construction) | 420 MB/s | Recommended Alternative |
| BLAKE3 | 256 bits | 512 bits (Tree) | Full Security Margin | No (Bao tree structure) | 3,200 MB/s (SIMD Vectorized) | High-Performance Integrity |
Practical Implementation Examples
Python: High-Speed Streaming Hashing & SHA-256 Upgrade
import hashlib
from typing import Dict
def generate_checksums(file_path: str) -> Dict[str, str]:
"""
Computes both legacy SHA-1 and modern SHA-256 digests in a single
memory-efficient streaming pass (handles multi-gigabyte files).
"""
sha1_hasher = hashlib.sha1()
sha256_hasher = hashlib.sha256()
BUFFER_SIZE = 64 * 1024 # 64 KB chunks
with open(file_path, "rb") as f:
while True:
data = f.read(BUFFER_SIZE)
if not data:
break
sha1_hasher.update(data)
sha256_hasher.update(data)
return {
"file": file_path,
"legacy_sha1": sha1_hasher.hexdigest(),
"secure_sha256": sha256_hasher.hexdigest(),
"warning": "SHA-1 is cryptographically broken; use SHA-256 for integrity verification."
}
# String hashing demo
sample_text = b"AffiChain Security Specification"
print("SHA-1: ", hashlib.sha1(sample_text).hexdigest())
print("SHA-256:", hashlib.sha256(sample_text).hexdigest())
Node.js / TypeScript Cryptographic Pipeline
import * as crypto from 'crypto';
import * as fs from 'fs';
export function computeSha1(data: string | Buffer): string {
return crypto.createHash('sha1').update(data).digest('hex');
}
export function computeSecureSha256(data: string | Buffer): string {
return crypto.createHash('sha256').update(data).digest('hex');
}
// HMAC-SHA1: Where SHA-1 remains secure due to PRF envelope
export function computeHmacSha1(key: string, message: string): string {
return crypto.createHmac('sha1', key).update(message).digest('hex');
}
Critical Edge Cases & Where SHA-1 Persists Safely
1. Why HMAC-SHA1 Remains Mathematically Secure
While raw SHA-1 is completely broken for digital signatures, HMAC-SHA1 (Hash-based Message Authentication Code, RFC 2104)—used extensively in TOTP Two-Factor Authentication (RFC 6238) and IPsec—remains secure against collision attacks. HMAC relies on the pseudorandom function (PRF) properties of the hash algorithm, not collision resistance. Because an attacker cannot manipulate the secret key embedded within both the inner and outer hash passes, collision vulnerabilities cannot be weaponized against HMAC-SHA1.
2. Git Version Control & "Hardened SHA-1" (sha1dc)
Git historically identified every commit, tree, and blob using raw SHA-1 hashes. Following the 2017 SHAttered attack, Linus Torvalds and the Git core team integrated sha1dc (SHA-1 Collision Detection). When Git hashes an incoming object, sha1dc actively analyzes the message words to detect the specific mathematical vectors used in collision attacks, aborting if collision manipulation is detected. Git is currently transitioning to SHA-256 object identifiers under the extensions.objectFormat repository standard.
3. Password Hashing Anti-Pattern
SHA-1 must never be used for password storage. Even before collision attacks, SHA-1 is a general-purpose message digest designed for maximum CPU throughput. Modern GPU rigs compute over 15 billion SHA-1 hashes per second, allowing offline brute-force cracking of 8-character complex passwords in minutes. Password storage mandates memory-hard, computationally expensive key derivation functions: Argon2id, bcrypt, or PBKDF2.