Identifiant de Hash

Qu'est-ce que l'identification de hash ?

L'identification de hash est le processus qui consiste à déterminer quel algorithme de hachage cryptographique a produit un condensat donné. Les fonctions de hachage cryptographique comme MD5, SHA-1 et SHA-256 produisent chacune des sorties de longueur fixe, et cette longueur de sortie est le signal principal utilisé pour identifier un hash inconnu. Lorsque vous rencontrez une chaîne hexadécimale dans un dump de base de données, un fichier de configuration ou une réponse d'API, un outil d'identification de hash vous indique quel algorithme l'a probablement généré.

Chaque algorithme de hachage fait correspondre des données d'entrée arbitraires à une sortie de taille fixe appelée condensat. MD5 produit toujours 128 bits (32 caractères hex), SHA-1 produit toujours 160 bits (40 caractères hex), et SHA-256 produit toujours 256 bits (64 caractères hex). Cette longueur de sortie déterministe est ce qui rend l'identification algorithmique possible sans accès à l'entrée d'origine ni au code de hachage.

L'identification par la seule longueur n'est pas toujours définitive. Plusieurs algorithmes partagent la même taille de sortie — par exemple, SHA-256 et SHA3-256 produisent tous deux des condensats hex de 64 caractères. Dans ces cas, un identificateur de hash fournit une liste d'algorithmes candidats classés par prévalence. Des indices contextuels tels que le système source, le format d'encodage (hex vs. Base64) et la présence de préfixes d'algorithme (comme '$2b$' pour bcrypt) permettent de réduire les possibilités.

Pourquoi utiliser un identificateur de hash ?

Les hash inconnus apparaissent régulièrement lors d'audits de sécurité, de migrations de bases de données et d'analyses forensiques. Un identificateur de hash supprime les approximations et vous pointe vers le bon algorithme en quelques secondes.

Cas d'usage de l'identificateur de hash

Référence des longueurs d'algorithmes de hash

Le tableau ci-dessous associe chaque algorithme de hash courant à sa taille de sortie en bits, caractères hex et octets bruts. C'est la table de correspondance principale utilisée par les outils d'identification de hash. Lorsque plusieurs algorithmes partagent la même longueur hex, vous avez besoin de contexte supplémentaire pour les distinguer.

Lever l'ambiguïté des longueurs de hash

Certaines longueurs hex correspondent à plusieurs algorithmes. Les deux ambiguïtés les plus courantes sont les hash de 64 caractères (SHA-256 vs. SHA3-256) et les hash de 40 caractères (SHA-1 vs. RIPEMD-160). Voici comment les distinguer quand la seule longueur est insuffisante.

Exemples de code

Voici des implémentations fonctionnelles de l'identification de hash par longueur hex dans quatre langages. Chaque fonction valide l'encodage hex, recherche le nombre de caractères et retourne tous les algorithmes correspondants.

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)

Questions fréquentes