Identyfikator Hash

Czym jest identyfikacja skrótu?

Identyfikacja skrótu to proces określania, który algorytm kryptograficzny wyprodukował dany skrót. Kryptograficzne funkcje skrótu, takie jak MD5, SHA-1 i SHA-256, generują dane wyjściowe o stałej długości, a właśnie ta długość jest podstawowym sygnałem używanym do identyfikacji nieznanego skrótu. Gdy napotkasz ciąg szesnastkowy w zrzucie bazy danych, pliku konfiguracyjnym lub odpowiedzi API, narzędzie do identyfikacji skrótów wskaże, który algorytm go najprawdopodobniej wygenerował.

Każdy algorytm skrótu odwzorowuje dowolne dane wejściowe na dane wyjściowe o stałym rozmiarze, zwane skrótem (ang. digest). MD5 zawsze generuje 128 bitów (32 znaki hex), SHA-1 zawsze generuje 160 bitów (40 znaków hex), a SHA-256 zawsze generuje 256 bitów (64 znaki hex). Ta deterministyczna długość danych wyjściowych sprawia, że identyfikacja algorytmu jest możliwa bez dostępu do oryginalnych danych wejściowych ani kodu haszującego.

Identyfikacja wyłącznie na podstawie długości nie zawsze jest jednoznaczna. Kilka algorytmów może mieć tę samą długość danych wyjściowych — na przykład SHA-256 i SHA3-256 oba generują 64-znakowe skróty hex. W takich przypadkach narzędzie do identyfikacji skrótów zwraca listę kandydatów uszeregowanych według częstości występowania. Dodatkowy kontekst, taki jak system źródłowy, format kodowania (hex lub Base64) oraz obecność prefiksów algorytmu (np. '$2b$' dla bcrypt), pozwala zawęzić możliwości.

Po co używać narzędzia do identyfikacji skrótów?

Nieznane skróty pojawiają się regularnie podczas audytów bezpieczeństwa, migracji baz danych i analizy kryminalistycznej. Narzędzie do identyfikacji skrótów eliminuje zgadywanie i wskazuje właściwy algorytm w ciągu kilku sekund.

Przypadki użycia narzędzia do identyfikacji skrótów

Tabela referencyjna długości algorytmów skrótu

Poniższa tabela mapuje każdy popularny algorytm skrótu na rozmiar danych wyjściowych w bitach, znakach hex i surowych bajtach. Jest to główna tabela przeglądowa używana przez narzędzia do identyfikacji skrótów. Gdy wiele algorytmów ma tę samą długość hex, do ich rozróżnienia potrzebny jest dodatkowy kontekst.

Rozróżnianie niejednoznacznych długości skrótów

Niektóre długości hex pasują do wielu algorytmów. Dwie najczęstsze niejednoznaczności to 64-znakowe skróty (SHA-256 a SHA3-256) i 40-znakowe skróty (SHA-1 a RIPEMD-160). Poniżej wyjaśniono, jak je odróżnić, gdy sama długość jest niewystarczająca.

Przykłady kodu

Poniżej znajdują się działające implementacje identyfikacji skrótu na podstawie długości hex w czterech językach. Każda funkcja waliduje kodowanie hex, sprawdza liczbę znaków i zwraca wszystkie pasujące algorytmy.

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)

Często zadawane pytania