Identificador de Hash

¿Qué es la Identificación de Hash?

La identificación de hash es el proceso de determinar qué algoritmo criptográfico produjo un digest específico. Las funciones hash como MD5, SHA-1 y SHA-256 producen salidas de longitud fija, y la longitud de la salida es la señal principal para identificar un hash desconocido. Cuando encuentras una cadena hexadecimal en un volcado de base de datos, archivo de configuración o respuesta de API, una herramienta identificadora te indica qué algoritmo probablemente lo generó.

Cada algoritmo hash mapea datos de entrada arbitrarios a una salida de tamaño fijo llamada digest. MD5 siempre produce 128 bits (32 caracteres hex), SHA-1 siempre produce 160 bits (40 caracteres hex) y SHA-256 siempre produce 256 bits (64 caracteres hex). Esta longitud de salida determinista es lo que hace posible la identificación algorítmica sin acceso a los datos de entrada originales o al código hash.

La identificación solo por longitud no siempre es definitiva. Varios algoritmos comparten el mismo tamaño de salida — por ejemplo, SHA-256 y SHA3-256 ambos producen digests hexadecimales de 64 caracteres. En estos casos, un identificador proporciona una lista de algoritmos candidatos clasificados por prevalencia. Las pistas contextuales como el sistema fuente, formato de codificación (hex vs. Base64) y la presencia de prefijos de algoritmo (como '$2b$' para bcrypt) reducen aún más las posibilidades.

¿Por qué Usar un Identificador de Hash?

Los hashes desconocidos aparecen regularmente durante auditorías de seguridad, migraciones de bases de datos y análisis forense. Un identificador de hash elimina la adivinanza y te señala el algoritmo correcto en segundos.

Casos de Uso del Identificador de Hash

Tabla de Referencia de Longitud de Algoritmo Hash

La tabla siguiente mapea cada algoritmo hash común a su tamaño de salida en bits, caracteres hex y bytes sin procesar. Esta es la tabla de búsqueda principal utilizada por herramientas de identificación. Cuando múltiples algoritmos comparten la misma longitud hex, necesitas contexto adicional para distinguirlos.

Desambiguación de Longitudes Hash

Algunas longitudes hex coinciden con múltiples algoritmos. Las dos ambigüedades más comunes son hashes de 64 caracteres (SHA-256 vs. SHA3-256) y hashes de 40 caracteres (SHA-1 vs. RIPEMD-160). Aquí está cómo distinguirlos cuando la longitud sola es insuficiente.

Ejemplos de Código

A continuación hay implementaciones de trabajo de identificación de hash por longitud hex en cuatro lenguajes. Cada función valida codificación hex, busca la cantidad de caracteres y devuelve todos los algoritmos coincidentes.

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)

Preguntas Frecuentes