Is SHA-1 still safe to use?

Not for security. Practical collision attacks have existed since 2017 (SHAttered). It's deprecated for signatures and certificates. SHA-1 is still acceptable for non-security uses like Git object IDs or HMAC-SHA1 (which remains unbroken).

What should I use instead of SHA-1 for new code?

SHA-256 or SHA-512 for general hashing, BLAKE3 for high throughput, and Argon2id or bcrypt for password hashing. Never use any plain hash for password storage.

Where is the SHA-1 hash computed?

In your browser, using the Web Crypto API. The input string never leaves your device.

sha-1 · 40 hex chars · web crypto · live

Generate SHA-1 digests

Compute the SHA-1 hash of any UTF-8 text. 160-bit, 40 hex characters. Hashing uses Web Crypto and runs entirely in your browser.

SHA-1 Hash Generator

Input

43 B

43 chars

Algorithm

SHA-1

160-bit

Digest

—

lower

Status

…

web crypto

input · text

output · sha-1 hex

—

Quick Start

How to compute SHA-1

Hashes UTF-8 bytes with the Web Crypto SubtleCrypto.digest API. Output is a 40-character lowercase hex string (or uppercase if toggled).

01
Type or paste text
Any UTF-8 input — emoji and accents are hashed faithfully.
Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.
inputUTF-8TextEncoderlosslesslive
input · raw bytestext · UTF-8
```
hello
```
loaded · UTF-8MIME · ready
02
Pick the case
Toggle between lowercase and uppercase hex output.
Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.
formatWeb Cryptosubtledeterministiclive
case · optionslower · live
```
aaf4c61d…
```
options applied · livelive
03
Live hash
Output updates as you type. 160 bits → 40 hex chars.
Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.
livememoisedoptionsinstantreactive
out · encoded40 hex · ready
```
aaf4c61ddcc5e8a2dab…
```
encoded · livelossless
04
Copy or download
One click to clipboard. Download as .txt.
Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.
exportclipboardblobMIME-correctclient-side
ok · copiedready · done
```
Copied
```
shipped · ready to shipsuccess

Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Use Cases

When SHA-1 is appropriate

Git, legacy systems, and non-adversarial integrity.

Git object IDs

Inspect or simulate Git's content-addressed hashes. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

Legacy APIs

Match SHA-1 signatures used by older services. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Pre-image checks

Verify a file matches a published SHA-1 sum. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

Cache keys

Derive deterministic IDs from inputs. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Migration

Compare hashes during a SHA-1 → SHA-256 rollout. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Test fixtures

Snapshot the SHA-1 of known data. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready

FAQ

Frequently asked questions

Is SHA-1 still safe?

Not for adversarial use. Collisions have been demonstrated (SHAttered). Use SHA-256 or BLAKE3 instead.

Why is the hash always 40 characters?

SHA-1 produces 160 bits = 20 bytes, two hex characters per byte = 40 characters.

Does encoding affect the hash?

Yes. We encode input as UTF-8 before hashing — different encodings produce different hashes.

Can I hash a file?

For files use the File Checksum Verifier — it streams large files efficiently.

Is anything sent to a server?

No. SHA-1 is computed in your browser via Web Crypto and runs locally.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!