Identificador de Hash

O que é Identificação de Hash?

A identificação de hash é o processo de determinar qual algoritmo hash criptográfico produziu um digest específico. Funções hash criptográficas como MD5, SHA-1 e SHA-256 produzem saídas de comprimento fixo, e o comprimento da saída é o sinal principal para identificar um hash desconhecido. Quando você encontra uma string hexadecimal em um dump de banco de dados, arquivo de configuração ou resposta de API, uma ferramenta identificadora de hash informa qual algoritmo provavelmente o gerou.

Cada algoritmo hash mapeia dados de entrada arbitrários para uma saída de tamanho fixo chamada digest. MD5 sempre produz 128 bits (32 caracteres hex), SHA-1 sempre produz 160 bits (40 caracteres hex) e SHA-256 sempre produz 256 bits (64 caracteres hex). Este comprimento de saída determinístico é o que torna a identificação algorítmica possível sem acesso aos dados de entrada originais ou ao código de hash.

A identificação apenas por comprimento nem sempre é definitiva. Vários algoritmos compartilham o mesmo tamanho de saída — por exemplo, SHA-256 e SHA3-256 produzem digests hexadecimais de 64 caracteres. Nestes casos, um identificador de hash fornece uma lista de algoritmos candidatos classificados por prevalência. Pistas contextuais como o sistema de origem, formato de codificação (hex vs. Base64) e a presença de prefixos de algoritmo (como '$2b$' para bcrypt) reduzem ainda mais as possibilidades.

Por que Usar um Identificador de Hash?

Hashes desconhecidos aparecem regularmente durante auditorias de segurança, migrações de banco de dados e análise forense. Um identificador de hash elimina adivinhação e aponta o algoritmo correto em segundos.

Casos de Uso do Identificador de Hash

Tabela de Referência de Comprimento de Algoritmo Hash

A tabela abaixo mapeia cada algoritmo hash comum para seu tamanho de saída em bits, caracteres hexadecimais e bytes crus. Esta é a tabela de busca principal usada por ferramentas de identificação de hash. Quando vários algoritmos compartilham o mesmo comprimento hex, você precisa de contexto adicional para distingui-los.

Desambiguando Comprimentos de Hash

Alguns comprimentos hex correspondem a múltiplos algoritmos. As duas ambigüidades mais comuns são hashes de 64 caracteres (SHA-256 vs. SHA3-256) e hashes de 40 caracteres (SHA-1 vs. RIPEMD-160). Aqui está como diferenciá-los quando apenas o comprimento é insuficiente.

Exemplos de Código

Abaixo estão implementações funcionais de identificação de hash por comprimento hex em quatro idiomas. Cada função valida codificação hex, busca a contagem de caracteres e retorna todos os algoritmos correspondentes.

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)

Perguntas Frequentes