Pengidentifikasi Hash

Apa Itu Identifikasi Hash?

Identifikasi hash adalah proses menentukan algoritma hash kriptografis mana yang menghasilkan suatu digest tertentu. Fungsi hash kriptografis seperti MD5, SHA-1, dan SHA-256 masing-masing menghasilkan keluaran berukuran tetap, dan panjang keluaran tersebut merupakan sinyal utama yang digunakan untuk mengidentifikasi hash yang tidak dikenal. Ketika Anda menemukan string heksadesimal dalam dump basis data, berkas konfigurasi, atau respons API, alat pengidentifikasi hash memberi tahu Anda algoritma mana yang kemungkinan besar menghasilkannya.

Setiap algoritma hash memetakan data masukan sembarang ke keluaran berukuran tetap yang disebut digest. MD5 selalu menghasilkan 128 bit (32 karakter hex), SHA-1 selalu menghasilkan 160 bit (40 karakter hex), dan SHA-256 selalu menghasilkan 256 bit (64 karakter hex). Panjang keluaran yang deterministik inilah yang memungkinkan identifikasi algoritma tanpa akses ke masukan asli maupun kode hashing.

Identifikasi berdasarkan panjang saja tidak selalu definitif. Beberapa algoritma berbagi ukuran keluaran yang sama — misalnya, SHA-256 dan SHA3-256 keduanya menghasilkan digest hex 64 karakter. Dalam kasus seperti ini, pengidentifikasi hash memberikan daftar kandidat algoritma yang diurutkan berdasarkan prevalensinya. Petunjuk konteks seperti sistem sumber, format pengkodean (hex vs. Base64), dan keberadaan prefiks algoritma (seperti '$2b$' untuk bcrypt) mempersempit kemungkinan lebih lanjut.

Mengapa Menggunakan Pengidentifikasi Hash?

Hash yang tidak dikenal sering muncul selama audit keamanan, migrasi basis data, dan analisis forensik. Pengidentifikasi hash menghilangkan tebak-tebakan dan mengarahkan Anda ke algoritma yang tepat dalam hitungan detik.

Kasus Penggunaan Hash Identifier

Referensi Panjang Algoritma Hash

Tabel di bawah memetakan setiap algoritma hash umum ke ukuran keluarannya dalam bit, karakter hex, dan byte mentah. Ini adalah tabel pencarian utama yang digunakan oleh alat identifikasi hash. Ketika beberapa algoritma berbagi panjang hex yang sama, Anda memerlukan konteks tambahan untuk membedakannya.

Membedakan Panjang Hash yang Ambigu

Beberapa panjang hex cocok dengan beberapa algoritma. Dua ambiguitas paling umum adalah hash 64 karakter (SHA-256 vs. SHA3-256) dan hash 40 karakter (SHA-1 vs. RIPEMD-160). Berikut cara membedakannya ketika panjang saja tidak mencukupi.

Contoh Kode

Di bawah ini adalah implementasi kerja identifikasi hash berdasarkan panjang hex dalam empat bahasa pemrograman. Setiap fungsi memvalidasi pengkodean hex, mencari jumlah karakter, dan mengembalikan semua algoritma yang cocok.

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)

Pertanyaan yang Sering Diajukan