Identificatore di Hash

Cos'è l'identificazione degli hash?

L'identificazione degli hash è il processo che determina quale algoritmo crittografico ha prodotto un dato digest. Le funzioni hash crittografiche come MD5, SHA-1 e SHA-256 producono ciascuna output di lunghezza fissa, e questa lunghezza è il segnale principale per identificare un hash sconosciuto. Quando si incontra una stringa esadecimale in un dump di database, un file di configurazione o una risposta API, uno strumento di identificazione hash indica quale algoritmo l'ha probabilmente generata.

Ogni algoritmo hash mappa dati di input arbitrari su un output di dimensione fissa chiamato digest. MD5 produce sempre 128 bit (32 caratteri hex), SHA-1 produce sempre 160 bit (40 caratteri hex) e SHA-256 produce sempre 256 bit (64 caratteri hex). Questa lunghezza di output deterministica è ciò che rende possibile l'identificazione algoritmica senza accesso all'input originale o al codice di hashing.

L'identificazione basata sulla sola lunghezza non è sempre definitiva. Diversi algoritmi condividono la stessa dimensione di output — ad esempio, SHA-256 e SHA3-256 producono entrambi digest hex di 64 caratteri. In questi casi, uno strumento di identificazione hash fornisce un elenco di algoritmi candidati ordinati per prevalenza. Indizi contestuali come il sistema sorgente, il formato di codifica (hex vs. Base64) e la presenza di prefissi algoritmici (come '$2b$' per bcrypt) restringono ulteriormente le possibilità.

Perché usare un identificatore di hash?

Gli hash sconosciuti compaiono regolarmente durante audit di sicurezza, migrazioni di database e analisi forense. Un identificatore di hash elimina le congetture e indica l'algoritmo corretto in pochi secondi.

Casi d'uso dell'identificatore di hash

Riferimento sulla lunghezza degli algoritmi hash

La tabella seguente mappa ogni comune algoritmo hash alla sua dimensione di output in bit, caratteri hex e byte grezzi. Questa è la tabella di ricerca primaria utilizzata dagli strumenti di identificazione hash. Quando più algoritmi condividono la stessa lunghezza hex, è necessario contesto aggiuntivo per distinguerli.

Disambiguare le lunghezze degli hash

Alcune lunghezze hex corrispondono a più algoritmi. Le due ambiguità più comuni sono gli hash di 64 caratteri (SHA-256 vs. SHA3-256) e quelli di 40 caratteri (SHA-1 vs. RIPEMD-160). Ecco come distinguerli quando la sola lunghezza non è sufficiente.

Esempi di codice

Di seguito sono riportate implementazioni funzionanti dell'identificazione hash tramite lunghezza hex in quattro linguaggi. Ogni funzione valida la codifica hex, ricerca il conteggio dei caratteri e restituisce tutti gli algoritmi corrispondenti.

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)

Domande frequenti