Hash Identifier

Was ist Hash-Identifikation?

Hash-Identifikation bezeichnet den Prozess, bei dem ermittelt wird, welcher kryptografische Hash-Algorithmus einen bestimmten Digest erzeugt hat. Kryptografische Hash-Funktionen wie MD5, SHA-1 und SHA-256 produzieren jeweils Ausgaben fester Länge, und genau diese Ausgabelänge ist das primäre Erkennungsmerkmal eines unbekannten Hashes. Wenn du in einem Datenbankdump, einer Konfigurationsdatei oder einer API-Antwort auf eine hexadezimale Zeichenkette stößt, verrät dir ein Hash-Identifier-Tool, welcher Algorithmus sie wahrscheinlich erzeugt hat.

Jeder Hash-Algorithmus bildet beliebige Eingabedaten auf eine Ausgabe fester Größe ab, den sogenannten Digest. MD5 erzeugt stets 128 Bit (32 Hex-Zeichen), SHA-1 stets 160 Bit (40 Hex-Zeichen) und SHA-256 stets 256 Bit (64 Hex-Zeichen). Diese deterministische Ausgabelänge ermöglicht die algorithmische Identifikation, ohne dass Zugriff auf die ursprüngliche Eingabe oder den Hashing-Code erforderlich ist.

Die Identifikation allein anhand der Länge ist nicht immer eindeutig. Mehrere Algorithmen teilen dieselbe Ausgabegröße — SHA-256 und SHA3-256 erzeugen beide 64-stellige Hex-Digests. In solchen Fällen liefert ein Hash-Identifier eine nach Häufigkeit geordnete Liste von Kandidaten-Algorithmen. Kontexthinweise wie das Quellsystem, das Kodierungsformat (Hex vs. Base64) und vorhandene Algorithmus-Präfixe (z. B. '$2b$' bei bcrypt) grenzen die Möglichkeiten weiter ein.

Warum einen Hash Identifier verwenden?

Unbekannte Hashes begegnen einem regelmäßig bei Sicherheitsaudits, Datenbankmigrationen und forensischen Analysen. Ein Hash Identifier beseitigt das Rätselraten und liefert innerhalb von Sekunden den korrekten Algorithmus.

Anwendungsfälle für den Hash Identifier

Referenztabelle: Hash-Algorithmus-Längen

Die folgende Tabelle ordnet jeden gängigen Hash-Algorithmus seiner Ausgabegröße in Bits, Hex-Zeichen und rohen Bytes zu. Dies ist die primäre Nachschlagetabelle, die von Hash-Identifikations-Tools verwendet wird. Wenn mehrere Algorithmen dieselbe Hex-Länge teilen, wird zusätzlicher Kontext benötigt, um sie zu unterscheiden.

Mehrdeutige Hash-Längen auflösen

Manche Hex-Längen passen zu mehreren Algorithmen. Die zwei häufigsten Mehrdeutigkeiten sind 64-stellige Hashes (SHA-256 vs. SHA3-256) und 40-stellige Hashes (SHA-1 vs. RIPEMD-160). So lassen sie sich unterscheiden, wenn die Länge allein nicht ausreicht.

Code-Beispiele

Nachfolgend sind funktionierende Implementierungen der Hash-Identifikation anhand der Hex-Länge in vier Sprachen aufgeführt. Jede Funktion validiert die Hex-Kodierung, schlägt die Zeichenanzahl nach und gibt alle passenden Algorithmen zurück.

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"]

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']

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]
}

#!/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)

Häufig gestellte Fragen