SHA-1 Hash Generator

Wat is SHA-1-hashing?

SHA-1 (Secure Hash Algorithm 1) is een cryptografische hashfunctie die uit elke invoer een vaste samenvatting van 160 bits (20 bytes) produceert. Gepubliceerd door de NSA en in 1995 gestandaardiseerd door NIST als FIPS PUB 180-1 en later gedocumenteerd in RFC 3174, werd SHA-1 ontworpen als een sterkere opvolger van SHA-0 en MD5. Het algoritme verwerkt invoer in blokken van 512 bits via 80 rondes van bitsgewijze bewerkingen, en produceert een hexadecimale vingerafdruk van 40 tekens die meer dan een decennium lang de basis vormde voor SSL/TLS, PGP, SSH en IPsec.

Net als alle cryptografische hashfuncties is SHA-1 een eenrichtingstransformatie: het berekenen van de hash uit een invoer gaat snel, maar het terughalen van de invoer uit alleen de hash is rekenkundig onuitvoerbaar. Een verandering van één bit in de invoer levert een volledig andere samenvatting van 160 bits op — een eigenschap die het lawine-effect wordt genoemd. SHA-1 beeldt een willekeurig grote invoerruimte af op een vaste uitvoer van 160 bits, wat betekent dat botsingen (twee verschillende invoerwaarden die dezelfde hash opleveren) wiskundig onvermijdelijk zijn. De beveiligingsclaim van een hashfunctie is dat het vinden van zulke botsingen ongeveer 2^80 bewerkingen moet vereisen — de helft van de uitvoerlengte in bits.

In 2017 publiceerden Google en CWI Amsterdam de SHAttered-aanval, waarbij de eerste praktische SHA-1-botsing werd aangetoond door twee verschillende PDF-bestanden met dezelfde samenvatting te produceren. De aanval vergde ongeveer 2^63,1 SHA-1-berekeningen — ruim onder de theoretische grens van 2^80. In 2020 verlaagden Gaetan Leurent en Thomas Peyrin de kosten verder met een chosen-prefix collision-aanval van circa 2^63,4 bewerkingen. Als gevolg hiervan hebben alle grote browsers, certificaatautoriteiten en normalisatie-instanties SHA-1 afgeschaft voor digitale handtekeningen en TLS-certificaten. SHA-1 wordt echter nog steeds actief gebruikt voor niet-beveiligingsdoeleinden: Git-object-ID's (hoewel Git migreert naar SHA-256), verouderde HMAC-constructies en bestandsintegriteitscontrolesommen waarbij botsingsbestendigheid tegen aanvallers niet vereist is.

Waarom deze SHA-1 Generator gebruiken?

Genereer SHA-1-hashes onmiddellijk, zonder iets te installeren of code te schrijven. Plak uw tekst en ontvang de hexadecimale samenvatting van 40 tekens in realtime — handig voor het verifiëren van verouderde controlesommen, het debuggen van Git-internals of het testen van op hash gebaseerde workflows.

Toepassingen van SHA-1

SHA-1 versus andere hashalgoritmen

SHA-1 produceert een samenvatting van 160 bits — langer dan MD5 (128 bits) maar aanzienlijk korter dan de SHA-2-familie. De onderstaande tabel vergelijkt samenvattingsgroottes, standaarden en geschikte toepassingen voor elk algoritme.

Hoe werkt SHA-1?

SHA-1 volgt de Merkle-Damgard-constructie: het bericht wordt opgevuld, opgesplitst in blokken van 512 bits en elk blok wordt verwerkt via 80 rondes bitsgewijze bewerkingen die de invoer vermengen met een berichtplanning afgeleid van het blok. Vijf toestandswoorden van 32 bits (H0 tot en met H4) bevatten de lopende hashstatus, en de uiteindelijke aaneenschakeling van deze woorden levert de samenvatting van 160 bits op.

Het belangrijkste verschil tussen SHA-1 en MD5 is het aantal toestandswoorden (5 versus 4), het aantal rondes per blok (80 versus 64) en het gebruik van een berichtplanning met terugkoppeling via links-roteren. Deze verschillen geven SHA-1 een grotere uitvoer (160 versus 128 bits) en boden oorspronkelijk een hogere beveiligingsmarge, hoewel beide algoritmen nu als gebroken worden beschouwd voor botsingsbestendigheid.

Codevoorbeelden

Hoe u SHA-1-hashes genereert in populaire talen en omgevingen. Anders dan MD5 is SHA-1 beschikbaar in de Web Crypto API van de browser, waardoor het zonder externe bibliotheken bruikbaar is in zowel browser- als Node.js-omgevingen.

// SHA-1 is available in the Web Crypto API
async function sha1(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-1', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha1('hello world')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha1').update('hello world').digest('hex')
// → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

import hashlib

# Basic SHA-1 hash
result = hashlib.sha1(b'hello world').hexdigest()
print(result)  # → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a string (encode to bytes first)
text = 'hello world'
hashlib.sha1(text.encode('utf-8')).hexdigest()
# → "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"

# Hash a file in chunks
with open('file.bin', 'rb') as f:
    sha1 = hashlib.sha1()
    for chunk in iter(lambda: f.read(8192), b''):
        sha1.update(chunk)
    print(sha1.hexdigest())

package main

import (
    "crypto/sha1"
    "fmt"
)

func main() {
    data := []byte("hello world")
    hash := sha1.Sum(data)
    fmt.Printf("%x\n", hash)
    // → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed
}

# Using sha1sum (Linux) or shasum (macOS)
echo -n "hello world" | sha1sum
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# macOS
echo -n "hello world" | shasum -a 1
# → 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed  -

# Hash a file
sha1sum package.json
# → a1b2c3d4e5f6...  package.json

# Using openssl (cross-platform)
echo -n "hello world" | openssl sha1
# → SHA1(stdin)= 2aae6c35c94fcfb415dbe95f408b9ce91ee846ed

Veelgestelde vragen