About

SHA-1 produces a 160-bit (40 hexadecimal character) message digest from arbitrary input. Although deprecated for certificate signing since 2017 due to collision vulnerabilities demonstrated by the SHAttered attack, SHA-1 remains widely used in Git object addressing, content-addressable storage, cache key generation, and non-security deduplication scenarios. This generator feeds cryptographically random bytes from crypto.getRandomValues into the native Web Crypto SHA-1 digest function. Each output is a genuine hash, not a random hex string. The distinction matters: a random hex string has uniform character distribution, while a true SHA-1 digest carries the internal avalanche properties of the Merkle - Damgård construction. Limitation: outputs are random hashes of random data. They do not correspond to any meaningful input message.

Formulas

The SHA-1 algorithm processes an input message M through a Merkle - Damgård construction with a Davies - Meyer compression function. The message is padded, split into 512-bit blocks, and processed through 80 rounds of bitwise operations.

H_out = SHA-1(M) = h₀ ‖ h₁ ‖ h₂ ‖ h₃ ‖ h₄

Each h_i is a 32-bit word. Concatenated, they form the 160-bit digest, represented as 40 hexadecimal characters. The digest length in hex is derived from:

L_hex = 1604 = 40 characters

Where each hexadecimal character encodes exactly 4 bits. This generator creates random input by sampling 32 bytes from the CSPRNG via crypto.getRandomValues, then computes the real SHA-1 digest via crypto.subtle.digest.

Where H_out = final hash output, M = input message (random bytes), h_0..4 = five 32-bit state words after all rounds, L_hex = output length in hex characters, ‖ = concatenation operator.

Reference Data

Hash Algorithm	Digest Length (bits)	Hex Characters	Collision Resistance	Status	Common Use
MD5	128	32	2⁶⁴	Broken	Legacy checksums
SHA-1	160	40	2⁶³ (theoretical)	Deprecated for security	Git, HMAC, dedup
SHA-224	224	56	2¹¹²	Active	TLS, certificates
SHA-256	256	64	2¹²⁸	Active (standard)	Bitcoin, TLS, JWT
SHA-384	384	96	2¹⁹²	Active	TLS 1.3
SHA-512	512	128	2²⁵⁶	Active	SSH, PGP
SHA-3-256	256	64	2¹²⁸	Active (newest)	Post-quantum prep
BLAKE2b	256	64	2¹²⁸	Active	Argon2, WireGuard
BLAKE3	256	64	2¹²⁸	Active	File integrity
RIPEMD-160	160	40	2⁸⁰	Legacy	Bitcoin addresses
Whirlpool	512	128	2²⁵⁶	Active	ISO/IEC 10118-3
CRC-32	32	8	None (checksum)	Active	ZIP, Ethernet
Adler-32	32	8	None (checksum)	Active	zlib
xxHash	64	16	None (non-crypto)	Active	Database hashing
MurmurHash3	128	32	None (non-crypto)	Active	Hash tables

Frequently Asked Questions

Genuine SHA-1 digests. The generator feeds 32 cryptographically random bytes into the Web Crypto API's SHA-1 digest function. The output carries the avalanche and diffusion properties of the real SHA-1 compression function, not uniform random hex distribution.

In 2017, the SHAttered attack demonstrated a practical collision: two distinct PDF files producing the same SHA-1 hash. The attack required approximately 2⁶³ computations, far below the ideal 2⁸⁰ collision resistance. For digital signatures and certificates, this means an attacker can forge documents. For non-security uses like Git object IDs or cache keys, SHA-1 remains functional.

No. SHA-1 is a one-way function. The random bytes used as input are not stored or recoverable from the digest. Even with unlimited computation, preimage resistance of SHA-1 remains at approximately 2¹⁶⁰ operations. The input data is discarded after hashing.

By the birthday paradox, collision probability reaches 50% after approximately 2⁸⁰ (≈ 1.2 × 10²⁴) hashes. Generating 10,000 hashes yields a collision probability of roughly 10^-40. Practically zero.

No. SHA-1 operates on binary data. The hex representation is a display convention. Lowercase (a-f) and uppercase (A-F) encode identical bit patterns. Prefixes like 0x are purely notational. Most standards (RFC 3174) use lowercase, Git uses lowercase, but the cryptographic content is identical.

The Web Crypto API delegates to the browser's native cryptographic module (often OpenSSL or BoringSSL compiled to native code). It runs at near-C speed and is constant-time to resist side-channel attacks. A pure JavaScript SHA-1 implementation is roughly 10 - 100× slower and may leak timing information. This tool uses the native API exclusively.