การระบุ 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 | ไบต์ | หมายเหตุ |
|---|---|---|---|---|
| MD5 | 128 | 32 | 16 | Broken — collisions trivial since 2004 |
| SHA-1 | 160 | 40 | 20 | Deprecated — SHAttered attack (2017) |
| SHA-224 | 224 | 56 | 28 | Truncated SHA-256; rarely used standalone |
| SHA-256 | 256 | 64 | 32 | Current standard; TLS, Git, Bitcoin |
| SHA-384 | 384 | 96 | 48 | Truncated SHA-512; CNSA Suite approved |
| SHA-512 | 512 | 128 | 64 | Maximum SHA-2 output; large-data hashing |
| SHA3-256 | 256 | 64 | 32 | Keccak-based; NIST alternative to SHA-2 |
| SHA3-512 | 512 | 128 | 64 | Keccak-based; highest SHA-3 strength |
| RIPEMD-160 | 160 | 40 | 20 | Used in Bitcoin address derivation |
| BLAKE2s | 256 | 64 | 32 | Faster 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 แม้ว่ายังไม่มีการพิสูจน์จุดอ่อนดังกล่าว