SHA-1 Hash Generator

Vad är SHA-1-hashning?

SHA-1 (Secure Hash Algorithm 1) är en kryptografisk hashfunktion som producerar ett fast 160-bitars (20-byte) sammandrag från valfri indata. Publicerad av NSA och standardiserad av NIST 1995 som FIPS PUB 180-1, och senare dokumenterad i RFC 3174, utformades SHA-1 som en starkare efterföljare till SHA-0 och MD5. Algoritmen bearbetar indata i 512-bitarsblock genom 80 omgångar av bitvisa operationer och producerar ett hexadecimalt fingeravtryck på 40 tecken som utgjorde ryggraden i SSL/TLS, PGP, SSH och IPsec i över ett decennium.

Liksom alla kryptografiska hashfunktioner är SHA-1 en envägstransformation: att beräkna hashvärdet från indata är snabbt, men att återskapa indata enbart från hashvärdet är beräkningsmässigt ogörligt. En enstaka bitsförändring i indatan ger ett helt annat 160-bitarssammandrag — en egenskap som kallas lavineffekten. SHA-1 avbildar ett godtyckligt stort indatautrymme på en fast 160-bitarsutgång, vilket innebär att kollisioner (två olika indata som ger samma hash) matematiskt måste existera. Säkerhetskravet för en hashfunktion är att hitta sådana kollisioner ska kräva ungefär 2^80 operationer — hälften av utdatans bitlängd.

År 2017 publicerade Google och CWI Amsterdam SHAttered-attacken, som demonstrerade den första praktiska SHA-1-kollisionen genom att producera två olika PDF-filer med samma sammandrag. Attacken krävde ungefär 2^63,1 SHA-1-beräkningar — långt under den teoretiska gränsen på 2^80. År 2020 sänkte Gaetan Leurent och Thomas Peyrin kostnaden ytterligare med en vald-prefixkollisionsattack som krävde ungefär 2^63,4 operationer. Till följd av detta har alla större webbläsare, certifikatutfärdare och standardiseringsorgan fasats ut SHA-1 för digitala signaturer och TLS-certifikat. SHA-1 används dock fortfarande aktivt för icke-säkerhetsrelaterade ändamål: Git-objekt-ID:n (även om Git migrerar till SHA-256), äldre HMAC-konstruktioner och kontrollsummor för filintegritet där motståndarmässig kollisionsresistens inte krävs.

Varför använda den här SHA-1-generatorn?

Generera SHA-1-hashar direkt utan att installera något eller skriva kod. Klistra in din text och få det 40-tecken långa hex-sammandraget i realtid — användbart för att verifiera äldre kontrollsummor, felsöka Git-internals eller testa hashbaserade arbetsflöden.

Användningsområden för SHA-1

SHA-1 jämfört med andra hashalgoritmer

SHA-1 producerar ett 160-bitarssammandrag — längre än MD5 (128 bitar) men betydligt kortare än SHA-2-familjen. Tabellen nedan jämför sammandragsstorlekar, standarder och lämpliga användningsfall för varje algoritm.

Hur SHA-1 fungerar

SHA-1 följer Merkle-Damgard-konstruktionen: meddelandet fylls ut, delas upp i 512-bitarsblock, och varje block bearbetas genom 80 omgångar bitvisa operationer som blandar indatan med ett meddelandeschema härlett från blocket. Fem 32-bitars tillståndsord (H0 till H4) bär det löpande hashtillståndet, och den slutliga sammansättningen av dessa ord producerar det 160-bitars sammandraget.

Den viktigaste skillnaden mellan SHA-1 och MD5 är antalet tillståndsord (5 mot 4), antalet omgångar per block (80 mot 64) och användningen av ett meddelandeschema med vänsterrotationsfeedback. Dessa skillnader ger SHA-1 en större utdata (160 mot 128 bitar) och gav ursprungligen en högre säkerhetsmarginal, även om båda algoritmerna nu anses brutna för kollisionsresistens.

Kodexempel

Hur man genererar SHA-1-hashar i populära språk och miljöer. Till skillnad från MD5 är SHA-1 tillgänglig i webbläsarens Web Crypto API, vilket gör den användbar utan externa bibliotek i både webbläsar- och Node.js-miljöer.

// 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

Vanliga frågor