ToolDeck

Hash Identifier

ระบุประเภท hash ตามความยาวและรูปแบบ — MD5, SHA-1, SHA-256 และอื่นๆ

สตริง Hash

ประมวลผลในเครื่อง · ปลอดภัยในการวางข้อมูลลับ

การระบุ Hash คืออะไร?

การระบุ hash คือกระบวนการตรวจสอบว่าอัลกอริทึม hash เชิงการเข้ารหัสใดเป็นผู้สร้างไดเจสต์ที่กำหนด ฟังก์ชัน hash เชิงการเข้ารหัส เช่น MD5, SHA-1 และ SHA-256 ต่างสร้างผลลัพธ์ที่มีความยาวคงที่ และความยาวของผลลัพธ์คือสัญญาณหลักที่ใช้ระบุ hash ที่ไม่รู้จัก เมื่อพบสตริงฐานสิบหกในไฟล์ดัมพ์ฐานข้อมูล ไฟล์คอนฟิกูเรชัน หรือการตอบสนอง API เครื่องมือระบุ hash จะบอกว่าอัลกอริทึมใดมีแนวโน้มสร้างสตริงนั้น

อัลกอริทึม hash ทุกตัวจะแปลงข้อมูลอินพุตใด ๆ ให้เป็นผลลัพธ์ขนาดคงที่ที่เรียกว่าไดเจสต์ MD5 สร้างผลลัพธ์ 128 บิตเสมอ (32 อักขระ hex) SHA-1 สร้าง 160 บิตเสมอ (40 อักขระ hex) และ SHA-256 สร้าง 256 บิตเสมอ (64 อักขระ hex) ความยาวผลลัพธ์ที่แน่นอนนี้คือสิ่งที่ทำให้การระบุอัลกอริทึมเป็นไปได้โดยไม่ต้องเข้าถึงอินพุตเดิมหรือโค้ดการแฮช

การระบุจากความยาวเพียงอย่างเดียวอาจไม่ชัดเจนเสมอไป อัลกอริทึมหลายตัวมีขนาดผลลัพธ์เท่ากัน เช่น SHA-256 และ SHA3-256 ต่างสร้างไดเจสต์ hex 64 อักขระ ในกรณีเหล่านี้ เครื่องมือระบุ hash จะแสดงรายการอัลกอริทึมที่เป็นไปได้เรียงตามความพบบ่อย ข้อมูลบริบท เช่น ระบบต้นทาง รูปแบบการเข้ารหัส (hex กับ Base64) และการมีคำนำหน้าอัลกอริทึม (เช่น '$2b$' สำหรับ bcrypt) ช่วยลดความเป็นไปได้ให้แคบลง

เหตุใดจึงควรใช้เครื่องมือระบุ Hash?

hash ที่ไม่รู้จักปรากฏขึ้นเป็นประจำระหว่างการตรวจสอบความปลอดภัย การโยกย้ายฐานข้อมูล และการวิเคราะห์นิติวิทยาศาสตร์ดิจิทัล เครื่องมือระบุ hash ขจัดการเดาสุ่มและชี้ไปยังอัลกอริทึมที่ถูกต้องภายในไม่กี่วินาที

ตรวจจับได้ทันที
วาง hash แล้วรับอัลกอริทึมที่เป็นไปได้ทันที ไม่จำเป็นต้องนับอักขระด้วยตนเองหรือค้นหาตารางอ้างอิง เครื่องมือจะแมปความยาว hex กับอัลกอริทึมที่ตรงกันทั้งหมดโดยอัตโนมัติ
🔒
วิเคราะห์โดยให้ความเป็นส่วนตัวเป็นหลัก
การระบุทั้งหมดทำงานในเบราว์เซอร์ของคุณโดยใช้ JavaScript ค่า hash จะไม่ออกจากอุปกรณ์ของคุณ ซึ่งมีความสำคัญเมื่อวิเคราะห์ hash รหัสผ่าน โทเค็นการยืนยันตัวตน หรือหลักฐานนิติวิทยาศาสตร์ที่ละเอียดอ่อน
📋
ครอบคลุมอัลกอริทึมครบถ้วน
ตรวจจับ MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512 และคู่เทียบ SHA-3 ตารางอ้างอิงครอบคลุมตระกูล SHA-2 และ SHA-3 ทั้งหมด รวมถึงทางเลือกอื่น เช่น RIPEMD-160 และ BLAKE2
🚫
ไม่ต้องสมัครบัญชีหรือติดตั้ง
ทำงานได้ทันทีในเบราว์เซอร์สมัยใหม่ทุกรุ่น ไม่ต้องลงทะเบียน ไม่ต้องใช้ API key ไม่ต้องติดตั้ง CLI ใด ๆ บุ๊กมาร์กไว้แล้วใช้เมื่อพบ hash ที่ไม่รู้จัก บนระบบปฏิบัติการและอุปกรณ์ใดก็ได้

กรณีการใช้งานเครื่องมือระบุ Hash

การตรวจสอบความปลอดภัย
ระหว่างการทดสอบเจาะระบบ การระบุอัลกอริทึม hash รหัสผ่านในฐานข้อมูลที่รั่วไหลจะกำหนดแนวทางการถอดรหัส hash ของ MD5 และ SHA-1 บ่งชี้ว่าการป้องกันอ่อนแอและสามารถจัดลำดับความสำคัญในการแก้ไขได้
การโยกย้ายฐานข้อมูล
เมื่อโยกย้ายระเบียนผู้ใช้ระหว่างระบบ จะต้องทราบอัลกอริทึม hash รหัสผ่านที่จัดเก็บไว้เพื่อกำหนดค่าชั้นการยืนยันตัวตนใหม่อย่างถูกต้อง การระบุอัลกอริทึมผิดจะทำให้การเข้าสู่ระบบทั้งหมดล้มเหลว
DevOps และ CI/CD
กระบวนการสร้างมักรวมถึงเช็กซัมสำหรับการยืนยันอาร์ติแฟกต์ การระบุว่าเช็กซัมเป็น SHA-256 หรือ SHA-512 ช่วยให้แน่ใจว่าคุณใช้คำสั่งตรวจสอบที่ถูกต้องในสคริปต์การปรับใช้งาน
นิติวิทยาศาสตร์ดิจิทัล
ผู้ตรวจสอบนิติวิทยาศาสตร์พบไดเจสต์ hash ในบันทึกความสมบูรณ์ของไฟล์ ระเบียนบล็อกเชน และข้อมูลเมตาของหลักฐาน การระบุอัลกอริทึมเป็นข้อกำหนดเบื้องต้นสำหรับการยืนยันห่วงโซ่การครอบครองหลักฐาน
การผสานรวม API
API ของบุคคลที่สามบางครั้งส่งคืนค่า hash โดยไม่ได้ระบุอัลกอริทึม การระบุประเภท hash จากการตอบสนองช่วยให้คุณกำหนดค่าการตรวจสอบลายเซ็น webhook หรือการตรวจสอบความถูกต้องของเช็กซัมได้อย่างถูกต้อง
การเรียนรู้การเข้ารหัส
นักศึกษาที่เรียนวิชาการเข้ารหัสสามารถวาง hash ที่สร้างโดยอัลกอริทึมต่าง ๆ และเห็นความสัมพันธ์ระหว่างการเลือกอัลกอริทึม ความยาวผลลัพธ์ และคุณสมบัติด้านความปลอดภัยได้ทันที

ตารางอ้างอิงความยาวอัลกอริทึม Hash

ตารางด้านล่างแมปอัลกอริทึม hash ทั่วไปแต่ละตัวกับขนาดผลลัพธ์เป็นบิต อักขระ hex และไบต์ดิบ นี่คือตารางค้นหาหลักที่เครื่องมือระบุ hash ใช้งาน เมื่ออัลกอริทึมหลายตัวมีความยาว hex เท่ากัน คุณจะต้องใช้บริบทเพิ่มเติมเพื่อแยกความแตกต่าง

อัลกอริทึมบิตอักขระ Hexไบต์หมายเหตุ
MD51283216Broken — collisions trivial since 2004
SHA-11604020Deprecated — SHAttered attack (2017)
SHA-2242245628Truncated SHA-256; rarely used standalone
SHA-2562566432Current standard; TLS, Git, Bitcoin
SHA-3843849648Truncated SHA-512; CNSA Suite approved
SHA-51251212864Maximum SHA-2 output; large-data hashing
SHA3-2562566432Keccak-based; NIST alternative to SHA-2
SHA3-51251212864Keccak-based; highest SHA-3 strength
RIPEMD-1601604020Used in Bitcoin address derivation
BLAKE2s2566432Faster than SHA-256; 256-bit output

การแก้ไขความกำกวมของความยาว Hash

ความยาว hex บางอย่างตรงกับอัลกอริทึมหลายตัว ความกำกวมที่พบบ่อยที่สุดสองกรณีคือ hash 64 อักขระ (SHA-256 กับ SHA3-256) และ hash 40 อักขระ (SHA-1 กับ RIPEMD-160) ต่อไปนี้คือวิธีแยกความแตกต่างเมื่อความยาวเพียงอย่างเดียวไม่เพียงพอ

64 อักขระ hex: SHA-256 กับ SHA3-256
ทั้งสองสร้างไดเจสต์ 256 บิต (64 อักขระ) SHA-256 พบได้บ่อยกว่ามากในทางปฏิบัติ คอมมิต Git, ใบรับรอง TLS, บล็อก Bitcoin และลายเซ็น API ส่วนใหญ่ใช้ SHA-256 SHA3-256 มักพบเฉพาะในระบบที่ต้องการการปฏิบัติตาม NIST SP 800-185 หรือโครงสร้างบนพื้นฐาน Keccak อย่างชัดเจน ตรวจสอบเอกสารประกอบของระบบต้นทางเพื่อยืนยัน
40 อักขระ hex: SHA-1 กับ RIPEMD-160
SHA-1 เป็น hash 160 บิตที่พบบ่อยกว่ามาก ใช้ในประวัติศาสตร์ใน Git (ก่อนการเปลี่ยนผ่านไปยัง SHA-256) TLS และการลงนามโค้ด RIPEMD-160 ปรากฏหลักในการสร้างที่อยู่ Bitcoin (HASH160 = SHA-256 ตามด้วย RIPEMD-160) หาก hash มาจากบริบทสกุลเงินดิจิทัล ให้พิจารณา RIPEMD-160 มิฉะนั้น SHA-1 มีแนวโน้มสูงกว่า

ตัวอย่างโค้ด

ด้านล่างคือการติดตั้งใช้งานจริงของการระบุ hash ตามความยาว hex ในสี่ภาษา แต่ละฟังก์ชันตรวจสอบการเข้ารหัส hex ค้นหาจำนวนอักขระ และส่งคืนอัลกอริทึมที่ตรงกันทั้งหมด

JavaScript
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"]
Python
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']
Go
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]
}
CLI (Bash)
#!/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)

คำถามที่พบบ่อย

การระบุ hash ทำงานอย่างไร?
การระบุ hash อาศัยความยาวของไดเจสต์ที่เข้ารหัสแบบ hex เป็นหลัก อัลกอริทึม hash แต่ละตัวสร้างจำนวนบิตผลลัพธ์คงที่ MD5 สร้าง 128 บิต (32 อักขระ hex) SHA-1 สร้าง 160 บิต (40 อักขระ hex) SHA-256 สร้าง 256 บิต (64 อักขระ hex) และอื่น ๆ เครื่องมือระบุวัดความยาวสตริง ตรวจสอบว่ามีเฉพาะอักขระฐานสิบหก และแมปกับขนาดผลลัพธ์ของอัลกอริทึมที่รู้จัก
เครื่องมือระบุ hash สามารถระบุอัลกอริทึมที่แน่นอนได้อย่างแน่ชัดหรือไม่?
ไม่เสมอไป อัลกอริทึมหลายตัวสามารถสร้างความยาวผลลัพธ์เท่ากันได้ SHA-256 และ SHA3-256 ต่างสร้าง 64 อักขระ hex SHA-1 และ RIPEMD-160 ต่างสร้าง 40 อักขระ hex ในกรณีเหล่านี้ เครื่องมือจะส่งคืนอัลกอริทึมที่เป็นไปได้ทั้งหมด คุณต้องการบริบท ได้แก่ ระบบต้นทาง เอกสารประกอบ หรือคำนำหน้าอัลกอริทึม เพื่อระบุอัลกอริทึมเดียว
จะทำอย่างไรหาก hash ถูกเข้ารหัสแบบ Base64 แทนที่จะเป็น hex?
hash ที่เข้ารหัสแบบ Base64 ใช้ชุดอักขระที่แตกต่างกัน (A-Z, a-z, 0-9, +, /) และมีความยาวต่างจากรูปแบบ hex ที่เทียบเท่า hash 256 บิตมี 44 อักขระ Base64 แต่ 64 อักขระ hex ถอดรหัสสตริง Base64 เป็นไบต์ดิบก่อน จากนั้นตรวจสอบความยาวไบต์: 16 ไบต์ = MD5, 20 ไบต์ = SHA-1, 32 ไบต์ = SHA-256, 48 ไบต์ = SHA-384, 64 ไบต์ = SHA-512
การวาง hash รหัสผ่านในเครื่องมือระบุออนไลน์ปลอดภัยหรือไม่?
เครื่องมือนี้ทำงานทั้งหมดในเบราว์เซอร์ของคุณ ไม่มีข้อมูลใดถูกส่งไปยังเซิร์ฟเวอร์ใด hash จะไม่ออกจากอุปกรณ์ของคุณ อย่างไรก็ตาม เพื่อความปลอดภัยในการปฏิบัติงานสูงสุดระหว่างการตรวจสอบอย่างเป็นทางการ คุณสามารถยืนยันได้โดยตรวจสอบแท็บเครือข่ายในเครื่องมือนักพัฒนาของเบราว์เซอร์ หรือใช้เครื่องมือแบบออฟไลน์หลังจากโหลดหน้าเว็บแล้ว
เหตุใด MD5 จึงยังใช้อยู่แม้ว่าจะเสียหายทางการเข้ารหัสแล้ว?
MD5 เสียหายในด้านการต้านทานการชน ผู้โจมตีสามารถสร้างอินพุตสองตัวที่แตกต่างกันซึ่งสร้าง hash เดียวกันได้ อย่างไรก็ตาม MD5 ยังคงใช้ในบริบทที่ไม่เกี่ยวข้องกับความปลอดภัย เช่น เช็กซัมไฟล์สำหรับการตรวจสอบการดาวน์โหลด คีย์แคช การลบข้อมูลซ้ำ และ ETags ใน HTTP สำหรับวัตถุประสงค์เหล่านี้ การชนโดยบังเอิญมีโอกาสเกิดขึ้นน้อยมากและการโจมตีโดยเจตนาไม่ใช่ข้อกังวล ห้ามใช้ MD5 สำหรับการแฮชรหัสผ่าน ลายเซ็นดิจิทัล หรือการตรวจสอบใบรับรอง
จะระบุ hash ของ bcrypt, scrypt หรือ Argon2 ได้อย่างไร?
ฟังก์ชันแฮชรหัสผ่าน เช่น bcrypt, scrypt และ Argon2 ใช้คำนำหน้าสตริงที่เป็นเอกลักษณ์แทนผลลัพธ์ hex ดิบ hash ของ bcrypt ขึ้นต้นด้วย '$2a$', '$2b$' หรือ '$2y$' ตามด้วยปัจจัยต้นทุน hash ของ Argon2 ขึ้นต้นด้วย '$argon2id$' หรือ '$argon2i$' hash ของ scrypt มักขึ้นต้นด้วย '$scrypt$' สิ่งเหล่านี้ไม่ใช่ไดเจสต์การเข้ารหัสดิบ ดังนั้นการระบุตามความยาวจึงไม่สามารถใช้ได้ คำนำหน้าเองคือตัวระบุอัลกอริทึม
SHA-2 และ SHA-3 แตกต่างกันอย่างไร?
SHA-2 (ซึ่งรวมถึง SHA-256, SHA-384 และ SHA-512) อิงตามโครงสร้าง Merkle-Damgard ที่ออกแบบโดย NSA และมาตรฐานใน FIPS 180-4 SHA-3 (SHA3-256, SHA3-384, SHA3-512) อิงตามโครงสร้าง Keccak sponge ที่คัดเลือกผ่านการแข่งขันสาธารณะของ NIST และมาตรฐานใน FIPS 202 ทั้งสองสร้างความยาวผลลัพธ์เท่ากันที่ระดับความปลอดภัยที่ตรงกัน แต่ใช้โครงสร้างภายในที่แตกต่างกันอย่างพื้นฐาน SHA-3 ถูกออกแบบมาเป็นทางเลือกสำรองในกรณีที่พบจุดอ่อนเชิงโครงสร้างใน SHA-2 แม้ว่ายังไม่มีการพิสูจน์จุดอ่อนดังกล่าว