Overview
Introduction
SHA-0 is the algorithm NSA published in 1993 and then quietly pulled two years later, replacing it with SHA-1 to fix a single missing rotation in the message schedule.
This tool computes that original, uncorrected SHA-0 digest for any text you provide, entirely client-side, for reproducing historical test vectors or studying exactly what the SHA-1 fix changed.
What Is SHA-0 Hash Calculator?
SHA-0 is a 160-bit cryptographic hash function published as FIPS 180 in 1993 by NIST, based on NSA's design, producing a digest shown here as 40 hexadecimal characters.
It shares its entire compression function, round structure, and constants with SHA-1; the only difference is that SHA-1's message-schedule expansion left-rotates each derived word by 1 bit, a step SHA-0 omits entirely.
How SHA-0 Hash Calculator Works
Your UTF-8 text is padded to a multiple of 512 bits (a 0x80 byte, zero bytes, then a 64-bit length field) and split into 16-word blocks, exactly like SHA-1.
Each block's 16 words are expanded to 80 by repeatedly XORing four earlier words together, without the rotate-by-1 step SHA-1 adds, then run through 80 rounds of bitwise mixing to update a running 160-bit state, hex-encoded into the final digest.
When To Use SHA-0 Hash Calculator
Use SHA-0 to reproduce a known historical test vector, study early-1990s NSA hash design, or interoperate with a genuinely legacy system from that era.
Never choose SHA-0 for anything new; it's both cryptographically broken (practical collisions are known) and essentially unused in practice, superseded by SHA-1 within two years of its own publication.
Often used alongside SHA-1 Hash Calculator, SHA-2 Hash Calculator and MD5 Hash Calculator.
Features
Advantages
- Historically significant as the direct ancestor of SHA-1, SHA-2, and (via design lineage) part of the story SHA-3 was created to diversify away from.
- Simple, well-documented structure identical to SHA-1 apart from one expansion step.
- Useful for precisely demonstrating how a single missing bit rotation weakens a hash function's diffusion.
Limitations
- Cryptographically broken: practical collision attacks are published and cheaper to mount than against SHA-1.
- Essentially unused in any real system since the mid-1990s, so compatibility need for it is rare.
- 160-bit output is short by modern standards even before considering the known weaknesses.
Examples
Best Practices & Notes
Best Practices
- Treat SHA-0 strictly as a historical/educational curiosity, never as a real integrity or security mechanism.
- If you're comparing hash families, run the same input through SHA-1 alongside this tool to see how one rotation changes every output bit (avalanche effect).
- For any real checksum or security need, use SHA-256 or newer.
Developer Notes
No published JavaScript library implements this withdrawn algorithm, so it's hand-written directly from the FIPS 180 (1993) specification, reusing SHA-1's exact compression function and round constants but omitting the rotl(...,1) step in message-schedule expansion. Verified against two independently confirmed SHA-0 test vectors for 'abc' and 'Hello, world!'.
SHA-0 Hash Calculator Use Cases
- Reproducing textbook SHA-0 test vectors while studying early NIST hash function history
- Demonstrating the practical effect of SHA-1's single-rotation fix over SHA-0
- Cryptography coursework covering the SHA family's evolution
- Interoperating with a genuinely legacy 1990s system that still references SHA-0
Common Mistakes
- Confusing SHA-0 with SHA-1; they look almost identical in spec but produce completely different digests for the same input.
- Assuming SHA-0 saw meaningful real-world adoption; it was replaced within about two years of publication.
- Using SHA-0 (or SHA-1) for any new security-relevant purpose in 2026.
Tips
- Run the same text through the SHA-1 tool to see the avalanche effect of that one added rotation.
- If you need a real family overview, the SHA-2 Hash Calculator computes all four modern SHA-2 lengths from a single input.