Hash Identifier

Identifiera hashtyp efter längd och format — MD5, SHA-1, SHA-256 och mer

Hash-sträng

Körs lokalt · Säkert att klistra in hemligheter

Vad är hashidentifiering?

Hashidentifiering är processen att avgöra vilket kryptografiskt hashalgoritm som producerat ett givet digest. Kryptografiska hashfunktioner som MD5, SHA-1 och SHA-256 producerar var och en utdata med fast längd, och utdatalängden är den primära signalen för att identifiera en okänd hash. När du stöter på en hexadecimal sträng i en databasdump, konfigurationsfil eller ett API-svar berättar ett hashidentifieringsverktyg vilken algoritm som troligen genererade den.

Varje hashalgoritm mappar godtyckliga indata till ett utdata med fast storlek kallat ett digest. MD5 producerar alltid 128 bitar (32 hex-tecken), SHA-1 producerar alltid 160 bitar (40 hex-tecken) och SHA-256 producerar alltid 256 bitar (64 hex-tecken). Denna deterministiska utdatalängd är det som gör algoritmisk identifiering möjlig utan tillgång till den ursprungliga inmatningen eller hashkoden.

Identifiering enbart baserat på längd är inte alltid avgörande. Flera algoritmer delar samma utdatastorlek — till exempel producerar SHA-256 och SHA3-256 båda 64-teckens hex-digest. I sådana fall tillhandahåller ett hashidentifieringsverktyg en lista med kandidatalgoritmer rangordnade efter förekomst. Ledtrådar från sammanhanget, såsom källsystemet, kodningsformat (hex vs. Base64) och förekomsten av algoritmprefix (som '$2b$' för bcrypt), begränsar möjligheterna ytterligare.

Varför använda ett hashidentifieringsverktyg?

Okända hashar dyker regelbundet upp vid säkerhetsgranskningar, databasmigreringar och kriminalteknisk analys. Ett hashidentifieringsverktyg eliminerar gissningar och pekar dig mot rätt algoritm på sekunder.

Omedelbar identifiering
Klistra in en hash och få kandidatalgoritmer direkt. Du behöver inte räkna tecken manuellt eller slå upp referenstabeller — verktyget mappar hex-längden till alla matchande algoritmer automatiskt.
🔒
Integritetsfokuserad analys
All identifiering körs helt i din webbläsare med JavaScript. Hash-värdet lämnar aldrig din enhet, vilket är viktigt vid analys av lösenordshashar, autentiseringstokens eller känslig kriminalteknisk bevisning.
📋
Fullständig algoritmtäckning
Identifierar MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 och deras SHA-3-motsvarigheter. Referenstabellen täcker hela SHA-2- och SHA-3-familjerna samt vanliga alternativ som RIPEMD-160 och BLAKE2.
🚫
Inget konto eller installation
Fungerar direkt i alla moderna webbläsare. Ingen registrering, ingen API-nyckel, inget CLI-verktyg att installera. Lägg till ett bokmärke och använd det när du stöter på en okänd hash — på vilket operativsystem och vilken enhet som helst.

Användningsområden för hashidentifiering

Säkerhetsgranskning
Vid penetrationstester avgör identifiering av lösenordshashalgoritmer i läckta databaser vilken knäckningsmetod som ska användas. MD5- och SHA-1-hashar indikerar svagt skydd och kan prioriteras för åtgärd.
Databasmigrering
Vid migrering av användarposter mellan system måste den lagrade lösenordshashalgoritmen vara känd för att konfigurera det nya autentiseringslagret korrekt. Om algoritmen identifieras fel misslyckas alla inloggningar.
DevOps och CI/CD
Byggpipelines inkluderar ofta kontrollsummor för artefaktverifiering. Att identifiera om en kontrollsumma är SHA-256 eller SHA-512 säkerställer att du använder rätt verifieringskommando i dina driftsättningsskript.
Digital kriminalteknik
Kriminaltekniska utredare stöter på hash-digest i fillintegritetloggar, blockkedjeregister och bevismetadata. Att identifiera algoritmen är en förutsättning för att verifiera beviskedjan.
API-integration
Tredjeparts-API:er returnerar ibland hash-värden utan att dokumentera algoritmen. Att identifiera hashtypen från svaret låter dig konfigurera din webhook-signaturverifiering eller kontrollsummevalidering korrekt.
Lär dig kryptografi
Studenter som arbetar igenom kryptografikurser kan klistra in hashar genererade av olika algoritmer och omedelbart se sambandet mellan algoritmval, utdatalängd och säkerhetsegenskaper.

Referenstabell för hashalgoritmlängder

Tabellen nedan mappar varje vanlig hashalgoritm till sin utdatastorlek i bitar, hex-tecken och råbytes. Detta är den primära uppslagstabellen som används av hashidentifieringsverktyg. När flera algoritmer delar samma hex-längd behöver du ytterligare sammanhang för att skilja dem åt.

AlgoritmBitarHex-teckenBytesAnteckningar
MD51283216Broken — collisions trivial since 2004
SHA-11604020Deprecated — SHAttered attack (2017)
SHA-2242245628Truncated SHA-256; rarely used standalone
SHA-2562566432Current standard; TLS, Git, Bitcoin
SHA-3843849648Truncated SHA-512; CNSA Suite approved
SHA-51251212864Maximum SHA-2 output; large-data hashing
SHA3-2562566432Keccak-based; NIST alternative to SHA-2
SHA3-51251212864Keccak-based; highest SHA-3 strength
RIPEMD-1601604020Used in Bitcoin address derivation
BLAKE2s2566432Faster than SHA-256; 256-bit output

Disambiguering av hashlängder

Vissa hex-längder matchar flera algoritmer. De två vanligaste tvetydighetserna är 64-teckens hashar (SHA-256 vs. SHA3-256) och 40-teckens hashar (SHA-1 vs. RIPEMD-160). Så här skiljer du dem åt när längden ensam inte räcker.

64 hex-tecken: SHA-256 vs. SHA3-256
Båda producerar 256-bitars (64-teckens) digest. SHA-256 är överlägset vanligast i praktiken — Git-commits, TLS-certifikat, Bitcoin-block och de flesta API-signaturer använder SHA-256. SHA3-256 finns typiskt bara i system som uttryckligen kräver NIST SP 800-185-efterlevnad eller Keccak-baserade konstruktioner. Kontrollera källsystemets dokumentation för att bekräfta.
40 hex-tecken: SHA-1 vs. RIPEMD-160
SHA-1 är den vanligaste 160-bitars hashen — historiskt använd i Git (före övergången till SHA-256), TLS och kodsignering. RIPEMD-160 förekommer främst vid generering av Bitcoin-adresser (HASH160 = SHA-256 följt av RIPEMD-160). Om hashen härrör från ett kryptovalutasammanhang, överväg RIPEMD-160; annars är SHA-1 det troliga alternativet.

Kodexempel

Nedan finns fungerande implementationer av hashidentifiering via hex-längd i fyra programmeringsspråk. Varje funktion validerar hex-kodning, slår upp teckentalet och returnerar alla matchande algoritmer.

JavaScript
function identifyHash(hex) {
  const len = hex.length
  const isHex = /^[0-9a-fA-F]+$/.test(hex)
  if (!isHex) return ['Not a hex-encoded hash']

  const map = {
    32:  ['MD5'],
    40:  ['SHA-1', 'RIPEMD-160'],
    56:  ['SHA-224', 'SHA3-224'],
    64:  ['SHA-256', 'SHA3-256', 'BLAKE2s'],
    96:  ['SHA-384', 'SHA3-384'],
    128: ['SHA-512', 'SHA3-512', 'BLAKE2b'],
  }
  return map[len] || [`Unknown (${len} hex chars)`]
}

identifyHash('d41d8cd98f00b204e9800998ecf8427e')
// → ["MD5"]

identifyHash('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855')
// → ["SHA-256", "SHA3-256", "BLAKE2s"]
Python
import re

HASH_LENGTHS = {
    32:  ['MD5'],
    40:  ['SHA-1', 'RIPEMD-160'],
    56:  ['SHA-224', 'SHA3-224'],
    64:  ['SHA-256', 'SHA3-256', 'BLAKE2s'],
    96:  ['SHA-384', 'SHA3-384'],
    128: ['SHA-512', 'SHA3-512', 'BLAKE2b'],
}

def identify_hash(hex_string: str) -> list[str]:
    hex_string = hex_string.strip()
    if not re.fullmatch(r'[0-9a-fA-F]+', hex_string):
        return ['Not a hex-encoded hash']
    return HASH_LENGTHS.get(len(hex_string), [f'Unknown ({len(hex_string)} hex chars)'])

identify_hash('da39a3ee5e6b4b0d3255bfef95601890afd80709')
# → ['SHA-1', 'RIPEMD-160']

identify_hash('a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a')
# → ['SHA-256', 'SHA3-256', 'BLAKE2s']
Go
package main

import (
	"fmt"
	"regexp"
)

var hexPattern = regexp.MustCompile("^[0-9a-fA-F]+$")

var hashLengths = map[int][]string{
	32:  {"MD5"},
	40:  {"SHA-1", "RIPEMD-160"},
	56:  {"SHA-224", "SHA3-224"},
	64:  {"SHA-256", "SHA3-256", "BLAKE2s"},
	96:  {"SHA-384", "SHA3-384"},
	128: {"SHA-512", "SHA3-512", "BLAKE2b"},
}

func identifyHash(hex string) []string {
	if !hexPattern.MatchString(hex) {
		return []string{"Not a hex-encoded hash"}
	}
	if algos, ok := hashLengths[len(hex)]; ok {
		return algos
	}
	return []string{fmt.Sprintf("Unknown (%d hex chars)", len(hex))}
}

func main() {
	fmt.Println(identifyHash("d41d8cd98f00b204e9800998ecf8427e"))
	// → [MD5]
}
CLI (Bash)
#!/bin/bash
# Identify a hash from the command line by character count
hash="$1"

if [[ ! "$hash" =~ ^[0-9a-fA-F]+$ ]]; then
  echo "Not a hex-encoded hash"
  exit 1
fi

len=${#hash}
case $len in
  32)  echo "MD5 (128-bit)" ;;
  40)  echo "SHA-1 or RIPEMD-160 (160-bit)" ;;
  56)  echo "SHA-224 or SHA3-224 (224-bit)" ;;
  64)  echo "SHA-256 or SHA3-256 (256-bit)" ;;
  96)  echo "SHA-384 or SHA3-384 (384-bit)" ;;
  128) echo "SHA-512 or SHA3-512 (512-bit)" ;;
  *)   echo "Unknown hash length: $len chars" ;;
esac

# Usage: ./identify.sh d41d8cd98f00b204e9800998ecf8427e
# → MD5 (128-bit)

Vanliga frågor

Hur fungerar hashidentifiering?
Hashidentifiering bygger primärt på längden hos det hex-kodade digestet. Varje hashalgoritm producerar ett fast antal utdatabitar: MD5 ger 128 bitar (32 hex-tecken), SHA-1 ger 160 bitar (40 hex-tecken), SHA-256 ger 256 bitar (64 hex-tecken) och så vidare. Identifieraren mäter strängens längd, verifierar att den enbart innehåller hexadecimala tecken och mappar den till kända algoritmers utdatastorlekar.
Kan ett hashidentifieringsverktyg avgöra exakt algoritm med säkerhet?
Inte alltid. Flera algoritmer kan producera samma utdatalängd. SHA-256 och SHA3-256 ger båda 64 hex-tecken. SHA-1 och RIPEMD-160 ger båda 40 hex-tecken. I dessa fall returnerar verktyget alla kandidater. Du behöver sammanhang — källsystemet, dokumentation eller algoritmprefix — för att begränsa det till en enda algoritm.
Vad gör jag om min hash är Base64-kodad i stället för hex?
Base64-kodade hashar använder en annan teckenuppsättning (A–Z, a–z, 0–9, +, /) och har andra längder än sina hex-motsvarigheter. En 256-bitars hash är 44 Base64-tecken men 64 hex-tecken. Avkoda Base64-strängen till råbytes först och kontrollera sedan bytelängden: 16 bytes = MD5, 20 bytes = SHA-1, 32 bytes = SHA-256, 48 bytes = SHA-384, 64 bytes = SHA-512.
Är det säkert att klistra in lösenordshashar i ett onlineverktyg?
Det här verktyget körs helt i din webbläsare — ingen data skickas till någon server. Hash-värdet lämnar aldrig din enhet. Om du vill ha maximal driftsäkerhet under en formell granskning kan du verifiera detta genom att granska nätverksfliken i webbläsarens utvecklarverktyg, eller använda verktyget offline efter att sidan har laddats.
Varför används MD5 fortfarande om det är kryptografiskt brutet?
MD5 är brutet vad gäller kollisionsresistans — en angripare kan konstruera två olika indata som ger samma hash. MD5 används dock fortfarande i icke-säkerhetskritiska sammanhang: filkontrollsummor för nedladdningsverifiering, cachenycklar, deduplicering och ETags i HTTP. För dessa ändamål är oavsiktliga kollisioner astronomiskt osannolika och avsiktliga attacker är inte ett problem. MD5 får inte användas för lösenordshashning, digitala signaturer eller certifikatverifiering.
Hur identifierar jag bcrypt-, scrypt- eller Argon2-hashar?
Lösenordshashfunktioner som bcrypt, scrypt och Argon2 använder distinkta strängprefix i stället för råa hex-utdata. Bcrypt-hashar börjar med '$2a$', '$2b$' eller '$2y$' följt av en kostnadsfaktor. Argon2-hashar börjar med '$argon2id$' eller '$argon2i$'. Scrypt-hashar börjar typiskt med '$scrypt$'. Dessa är inte råa kryptografiska digest, så längdbaserad identifiering gäller inte — prefixet i sig identifierar algoritmen.
Vad är skillnaden mellan SHA-2 och SHA-3?
SHA-2 (som inkluderar SHA-256, SHA-384 och SHA-512) bygger på Merkle-Damgård-konstruktionen, designad av NSA och standardiserad i FIPS 180-4. SHA-3 (SHA3-256, SHA3-384, SHA3-512) bygger på Keccak-svampen, utvald genom en offentlig NIST-tävling och standardiserad i FIPS 202. De producerar samma utdatalängder vid motsvarande säkerhetsnivåer men använder fundamentalt olika interna strukturer. SHA-3 designades som en reservlösning om strukturella svagheter skulle hittas i SHA-2, men inga sådana svagheter har påvisats.