เครื่องมือสำหรับนักพัฒนา

เครื่องสร้างแฮชและ Checksum

รับ MD5, SHA-1, SHA-256, SHA-384 และ SHA-512 สำหรับข้อความและไฟล์พร้อมกัน ตรวจสอบไฟล์ที่ดาวน์โหลดเทียบกับ checksum อย่างเป็นทางการเพื่อให้แน่ใจว่าไม่มีการแก้ไขข้อมูล ทุกอย่างทำงานในเครื่อง ไม่มีข้อมูลออกจากเบราว์เซอร์ของคุณ

5 อัลกอริทึมในคราวเดียว Checksum ข้อความ + ไฟล์ ทำงานในเครื่อง ไม่มีการอัปโหลด ผลลัพธ์ทันที

อัลกอริทึม: MD5 · SHA-1/256/384/512
เอ็นจิ้น: Web Crypto API
ความเป็นส่วนตัว: 100% ในเครื่อง
อินพุต: ข้อความ / ไฟล์

อักขระ ไบต์ UTF-8

ผลลัพธ์แฮช

วาง checksum อย่างเป็นทางการเพื่อตรวจสอบ

ผ่าน: ไฟล์ตรงกับ checksum อย่างเป็นทางการทุกประการ ปลอดภัยที่จะใช้

ล้มเหลว: ไฟล์แตกต่างจาก checksum อย่างเป็นทางการ - อาจเสียหายหรือมีการแก้ไขอย่าเรียกใช้

Checksum สามารถมีได้เฉพาะอักขระฐานสิบหก (0-9, a-f) เท่านั้น โปรดตรวจสอบสิ่งที่คุณคัดลอก

ความควรยาว 32 (MD5), 40 (SHA-1), 64 (SHA-256), 96 (SHA-384) หรือ 128 (SHA-512) อักขระ - ตรวจสอบว่าคัดลอกค่าทั้งหมดแล้ว

คุณสมบัติ

แฮชทั้งห้าบนหน้าเดียว

จากลายนิ้วมือรวดเร็วไปจนถึงลายเซ็นที่ปลอดภัย - ทุกแฮชที่นักพัฒนา, ผู้ดูแลระบบ และการตรวจสอบการดาวน์โหลดต้องการ

ห้าอัลกอริทึม

MD5, SHA-1, SHA-256, SHA-384 และ SHA-512 แสดงพร้อมกันพร้อมความยาวบิตของเอาต์พุต - ไม่ต้องสลับระหว่างเครื่องมืออีกต่อไป

การคำนวณแบบเรียลไทม์

แฮชข้อความเมื่อคุณพิมพ์ ไม่ต้องกดปุ่ม ผลลัพธ์แบบ monospace - คลิกแถวเพื่อคัดลอก

ตรวจสอบความสมบูรณ์ของไฟล์

วางไฟล์ติดตั้ง, อิมเมจดิสก์ หรือไฟล์เก็บถาวร แล้วเปรียบเทียบกับ checksum อย่างเป็นทางการเพื่อยืนยันว่าไม่มีการแก้ไขข้อมูลจากการดาวน์โหลด

ทำงานในเครื่อง ไม่มีการอัปโหลด

ตระกูล SHA ใช้ Web Crypto API ที่สร้างมาในเบราว์เซอร์ ข้อความและไฟล์ไม่มีออกจากเครื่องของคุณ - เนื้อหาที่ละเอียดอ่อนปลอดภัย

สอดคล้องกับ UTF-8

ข้อความจะถูกแฮชเป็นไบต์ UTF-8 จึงได้ผลลัพธ์ตรงกับ md5sum, PHP md5() และ Python hashlib อย่างแม่นยำ

คัดลอกด้วยคลิกเดียว

คัดลอกแฮชแต่ละรายการ หรือทั้งหมดในรูปแบบ checksum มาตรฐาน พร้อมใช้งานในเทอร์มินัล

สิ่งที่คุณควรรู้เกี่ยวกับแฮช

แนวคิดง่าย ๆ แต่การใช้ผิดประเภทสำหรับงานที่ไม่เหมาะสมคือข้อผิดพลาดด้านความปลอดภัยที่แท้จริง

MD5 และ SHA-1 คืออะไรกันแน่?

MD5 (Message-Digest Algorithm 5) ออกแบบโดย Ronald Rivest ที่ MIT และเผยแพร่ในปี 1992 เป็น RFC 1321 โดยสร้างไดเจสต์ขนาดคงที่ 128 บิต (อักขระเลขฐานสิบหก 32 ตัว) เป็นผู้สืบทอดของ MD4 ส่วน SHA-1 ออกแบบโดย U.S. National Security Agency และเผยแพร่ในปี 1995 เป็นมาตรฐานรัฐบาล FIPS 180-1 โดยสร้างไดเจสต์ 160 บิต ทั้งสองกลายเป็นอัลกอริทึมแฮชที่ใช้กันอย่างแพร่หลายมากที่สุดในช่วงสองทศวรรษต่อมา — ใช้สำหรับ checksum ไฟล์, การจัดเก็บรหัสผ่าน, ลายดิจิทัล และ ID การคอมมิต Git โปรดทราบว่าพวกมันยังคงสร้างไดเจสต์ที่ถูกต้องในปัจจุบัน คำว่า "ไม่ปลอดภัย" หมายถึงความต้านทานการชนกัน (collision resistance) ของพวกมันล้มเหลว ไม่ใช่ว่าผลลัพธ์ของพวกมันไม่ถูกต้อง

การแฮช, การเข้ารหัส และการเข้ารหัส (encoding) เป็นสิ่งเดียวกันหรือไม่?

ไม่ — พวกมันแก้ปัญหาต่างกัน การเข้ารหัส (เช่น Base64 หรือ URL encoding) คือการแปลงรูปแบบที่ย้อนกลับได้โดยทุกคน ไม่มีความปลอดภัยเลย การเข้ารหัส (encryption) ย้อนกลับได้ด้วยคีย์: ข้อความธรรมดากลายเป็นข้อความที่เข้ารหัส และคีย์ที่ถูกต้องจะถอดรหัสได้ ส่วนการแฮชเป็นแบบทางเดียว ไม่มีคีย์ และไมสามารถกู้คืนข้อมูลต้นฉบับจากไดเจสต์ได้ — ใช้สำหรับลายนิ้วมือ, การตรวจสอบความสมบูรณ์ และลายเซ็น ความเข้าใจผิดที่พบบ่อยสองประการ: การมองว่า Base64 เป็น "การเข้ารหัส" และการกล่าวว่ารหัสผ่านถูก "เข้ารหัสด้วย MD5" — นั่นคือการแฮช และเป็นวิธีการจัดเก็บรหัสผ่านที่ไม่ปลอดภัยอีกด้วย

ทำไมแฮชจึงไมสามารถย้อนกลับไปเป็นข้อมูลต้นฉบับได้?

แฮชคือฟังก์ชันทางเดียว: อินพุตที่มีความยาวใด ๆ จะถูกบีบอัดเป็นไดเจสต์ความยาวคงที่ โดยย่อข้อมูลส่วนใหญ่ไว้ เช่นเดียวกับที่คุณไมสามารถสร้างประโยคขึ้นมาใหม่จากจำนวนคำได้ ข้อมูลต้นฉบับจึงไมสามารถนำมาจากไดเจสต์ได้ อัลกอริทึมที่ปลอดภัยได้รับการออกแบบมาโดยเฉพาะเพื่อทำให้การย้อนกลับเช่นนี้ไมสามารถทำได้ด้วยกำลังคำนวณ

MD5 และ SHA-1 ยังใช้งานได้หรือไม่?

สำหรับตรวจสอบว่าไฟล์เกิดความเสียหายโดยไม่ได้ตั้งใจขณะส่ง — ใช่ การเปลี่ยนแปลงไบต์โดยไม่ตั้งใจเกือบทุกครั้งจะเปลี่ยน MD5 แต่ไม่ควรใช้เพื่อความปลอดภัย: มีการโจมตี collision ที่ใช้งานได้จริงสำหรับทั้งสอง (นักวิจัยสามารถสร้างไฟล์สองไฟล์ที่แตกต่างกันซึ่งมี MD5 เดียวกันภายใต้การควบคุมของพวกเขา) ให้ใช้ SHA-256 หรือสูงกว่าสำหรับรหัสผ่าน, ลายเซ็น และใบรับรอง

ทำไมแฮชของฉันจึงแตกต่างจากเครื่องมืออื่นสำหรับข้อความเดียวกัน?

สาเหตุที่พบบ่อยที่สุดสามประการ: ① การเข้ารหัสอักขระที่แตกต่างกัน (เครื่องมือนี้ใช้ UTF-8 เสมอ ส่วนเครื่องมือเก่าอาจใช้ GBK หรือ Latin-1) ② การขึ้นบรรทัดใหม่ที่ท้าย — คำสั่ง echo เพิ่มการขึ้นบรรทัดใหม่โดยค่าเริ่มต้น (ใช้ echo -n) ③ ช่องว่างโดยไม่ตั้งใจหรืออักขระที่มองไม่เห็นขณะคัดลอก แฮชไวต่อแต่ละไบต์ ดังนั้นแม้ไบต์เดียวที่ผิดก็จะเปลี่ยนผลลัพธ์อย่างสิ้นเชิง

ทำไมไมสามารถจัดเก็บรหัสผ่านเป็น MD5/SHA-256 ธรรมดาได้?

แฮชธรรมดามีความเร็วสูง เมื่อตารางแฮชรั่วไหล ผู้โจมตีสามารถทายรหัสผ่านได้หลายพันล้านครั้งต่อวินาที และตารางเรนโบว์ (rainbow tables) จะค้นย้อนกลับรหัสผ่านทั่วไปได้ทันที รหัสผ่านต้องใช้อัลกอริทึมที่ช้าอย่างจงใจและต้องการหน่วยความจำ (bcrypt, scrypt, Argon2) พร้อม salt ที่ไม่ซ้ำกันสำหรับแต่ละรหัสผ่าน ทำให้การโจมตีด้วยกำลังดิบมีค่าใช้จ่ายสูงจนไมสามารถดำเนินการได้

ฉันจะตรวจสอบความสมบูรณ์ของไฟล์ที่ดาวน์โหลดได้อย่างไร?

ค้นหา checksum ที่เผยแพร่บนเว็บไซต์อย่างเป็นทางการ (โดยปกติคือ SHA-256) ลากไฟล์ที่ดาวน์โหลดไปไว้ในแท็บ "Checksum ของไฟล์" ที่นี่ แล้ววางค่าที่มาจากเว็บไซต์ลงในช่องด้านบนผลลัพธ์ เครื่องมือจะตรวจจับอัลกอริทึมจากความยาวของค่าและเปลี่ยนแถวที่ตรงกันเป็นสีเขียวเมื่อไบต์ของไฟล์ตรงกับที่ผู้เผยแพร่เผยแพร่ ถ้าเป็นสีแดงหมายถึงไฟล์เสียหายหรือถูกเปลี่ยนแปลงโดยผู้ไม่ประสงค์ดี — อย่าเรียกใช้ไฟล์นั้น

ควรใช้อัลกอริทึมใดในห้าตัวนี้

เลือกตามสถานการณ์ อัลกอริทึมใหม่กว่าจะสร้างไดเจสต์ที่ยาวกว่า ทนต่อการโจมตีได้ดีกว่า และใช้เวลาคำนวณนานกว่าเล็กน้อย

อัลกอริทึม	เปิดตัวปี	ความยาวของเอาต์พุต	ระดับความปลอดภัย	การใช้งานทั่วไป
MD5	1992	128 บิต (32 อักขระ)	เสียแล้ว สามารถสร้างการชนกันได้จริง	ลายนิ้วมือที่ไม่ต้องการความปลอดภัย, การคัดลอกไฟล์, ความเข้ากันได้แบบเก่า
SHA-1	1995	160 บิต (40 อักขระ)	สามารถสร้างการชนกันได้จริงตั้งแต่ปี 2017	รหัสประวัติ Git และระบบเก่าอื่น ๆ; ไม่เหมาะสำหรับการใช้งานด้านความปลอดภัยใหม่
SHA-256	2001	256 บิต (64 อักขระ)	ปลอดภัยในปัจจุบัน	Checksum ไฟล์, ลายเซ็น, ใบรับรอง TLS, บล็อกเชน — ค่าเริ่มต้นที่ใช้ทั่วไป
SHA-384	2001	384 บิต (96 อักขระ)	ปลอดภัย	SHA-512 ที่ตัดตอนสำหรับกฎเกณฑ์การปฏิบัติตามที่ต้องการ 384 บิต
SHA-512	2001	512 บิต (128 อักขระ)	ปลอดภัย	ลายเซ็นที่ต้องการความน่าเชื่อถือสูง; มักจะเร็วกว่า SHA-256 บน CPU 64 บิต

"ปลอดภัย" หมายถึง ไม่มีการโจมตีสร้างการชนกันที่เป็นไปได้ในทางปฏิบัติจนถึงปัจจุบัน สำหรับการจัดเก็บรหัสผ่าน ให้ใช้ bcrypt/Argon2 โดยไม่คำนึงถึงการเลือกแฮช

Checksum: วิธีตรวจสอบไฟล์ที่ดาวน์โหลดอย่างถูกต้อง

สตริง MD5 หรือ SHA-256 บนหน้าดาวน์โหลดมีไว้เพื่ออะไร เปรียบเทียบอย่างไร และใช้เปรียบเทียบกับอะไร — ทั้งหมดอยู่ในส่วนนี้

ทำไมต้องตรวจสอบเลย

ไฟล์บนดิสก์ของคุณไม่จำเป็นต้องตรงกับไฟล์บนเซิร์ฟเวอร์ การเปรียบเทียบ checksum เพียงสิบวินาทีช่วยป้องกันปัญหาสามประเภทดังนี้:

ไฟล์เสียหายระหว่างการส่ง

ไฟล์ขนาดใหญ่ที่ดาวน์โหลดด้วยการต่อการดาวน์โหลดและใช้เครือข่ายที่ไม่เสถียร มักจะมีไบต์ผิดปกติอย่างน่าประหลาดใจ การแก้ไขปัญหาไฟล์ติดตั้งที่เสียจะใช้เวลานานกว่าสิบวินาทีมาก

มิเรอร์ไม่ตรงกัน

การดาวน์โหลดจำนวนมากมาจากมิเรอร์หรือ CDN ซึ่งการล่าช้าในการซิงค์หรือข้อผิดพลาดของแคชสามารถให้เวอร์ชันที่ล้าสมัยแก่คุณ — หรือไฟล์เพียงครึ่งหนึ่ง

การแก้ไขโดยเจตนา

เมื่อแหล่งดาวน์โหลดถูกบุกรุกหรือเครือข่ายสาธารถูกแฮ็ก ไฟล์สามารถมีแบ็กดอร์ได้ ในปี 2016 เว็บไซต์ Linux Mint ถูกแฮ็กและเปลี่ยนลิงก์ดาวน์โหลดเป็น ISO ที่มีแบ็กดอร์ — การตอบสนองแรกของโปรเจ็กต์คือการเรียกร้องให้ทุกคนตรวจสอบ checksum

Checksum คืออะไร

ผู้จัดพิมพ์จะแฮชไฟล์บนเซิร์ฟเวอร์แล้วโพสต์ผลลัพธ์ลงในหน้าดาวน์โหลด หลังจากดาวน์โหลดเสร็จ คุณจะทำการแฮชไฟล์อีกครั้งในเครื่อง หากสตริงทั้งสองตรงกันทุกตัวอักษร แสดงว่าไบต์ทั้งหมดของไฟล์ตรงกับเวอร์ชันที่ผู้จัดพิมพ์เผยแพร่ ไม่เสียหายและไม่ถูกดัดแปลง การตรวจสอบนี้ละเอียดถี่ถ้วนทุกไบต์: แม้เปลี่ยนเพียงไบต์เดียว ค่าผลลัพธ์จะเปลี่ยนไปโดยสิ้นเชิง โดยทั่วไปแล้ว เช็คซัมยังรวมถึงรูปแบบที่ง่ายกว่า เช่น CRC32 ที่ใช้ตรวจจับการเสียหายโดยไม่ได้ตั้งใจ ในขณะที่แฮชทางคริปโตกราฟี เช่น MD5/SHA สามารถป้องกันการปลอมแปลงโดยเจตนาได้อีกด้วย

ตรวจสอบไฟล์ในสามขั้นตอน

1

รับค่าเช็คซัมอย่างเป็นทางการ

ในหน้าดาวน์โหลด ให้ค้นหาค่า MD5 หรือ SHA-256 ที่เผยแพร่ (มักระบุว่า "checksum" หรือมาพร้อมไฟล์เสริมนามสกุล .sha256) แล้วคัดลอกสตริงทั้งหมด
2

วางไฟล์และค่าเช็คซัม

สลับไปที่แท็บ "File checksum" ด้านบน วางไฟล์ที่ดาวน์โหลดไว้ แล้ววางค่าเช็คซัมลงในช่องด้านบนผลลัพธ์
3

อ่านผลการตรวจสอบจากสี

เครื่องมือจะตรวจจับอัลกอริทึมจากความยาวของค่า: สีเขียวหมายความว่าไฟล์ตรงกับเวอร์ชันอย่างเป็นทางการและปลอดภัยใช้งาน; สีแดงหมายความว่าอาจมีการเสียหายหรือการดัดแปลง — อย่าเรียกใช้ไฟล์นี้

การอ่านค่าเช็คซัมบนไซต์อย่างเป็นทางการ

หน้าดาวน์โหลดจะเขียนค่าเช็คซัมในหลายรูปแบบ แต่ทุกรูปแบบมีสององค์ประกอบเหมือนกัน คือ ค่าแฮชและชื่อไฟล์ รูปแบบสามแบบต่อไปนี้เป็นที่นิยมที่สุด — เมื่อคัดลอกมา ให้เอาเฉพาะส่วนค่าแฮชเท่านั้น (เครื่องมือนี้จะไม่สนใจช่องว่างและการขึ้นบรรทัดอัตโนมัติ):

# 1. บรรทัดเดียว: เพียงค่าแฮช
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a

# 2. รูปแบบ sha256sum: ค่า + สองช่องว่าง + ชื่อไฟล์ (ไฟล์แสดงรายการ SHA256SUMS มีบรรทัดดังกล่าวหลายบรรทัด)
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a  ubuntu-24.04.iso

# 3. รูปแบบ BSD: อัลกอริทึม (ชื่อไฟล์) = ค่า
SHA256 (ubuntu-24.04.iso) = a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a

MD5 หรือ SHA-256

ตรวจสอบตามที่ไซต์อย่างเป็นทางการแจ้ง แต่ถ้าคุณต้องเลือก: MD5 เพียงพอสำหรับตรวจสอบการเสียหายโดยไม่ได้ตั้งใจระหว่างการส่งข้อมูล (การเปลี่ยนแปลงใดๆ โดยบังเอิญจะเปลี่ยนค่า MD5 เสมอ) สำหรับการป้องกันการดัดแปลงโดยเจตนา — เช่น ซอฟต์แวร์รักษาความปลอดภัย, ใบรับรอง, แพ็กเกจที่ลงนาม — คุณต้องใช้ SHA-256 หรืออัลกอริทึมที่แข็งแกร่งกว่า เพราะการโจมตีชนิด collision แบบที่ใช้ได้จริงช่วยให้ผู้โจมตีสามารถสร้างไฟล์สองไฟล์ที่แตกต่างกันแต่มีค่า MD5 เท่ากันได้ รายละเอียดอยู่ใน "ประวัติด้านความปลอดภัย" ด้านล่าง

วิธีตรวจสอบจากบรรทัดคำสั่งแทน

บน Linux และ macOS เครื่องมือเช็คซัมจะรับตัวเลือก -c เพื่อตรวจสอบไฟล์แสดงรายการทั้งหมดโดยอัตโนมัติ — ไม่ต้องเปรียบเทียบด้วยตนเอง ส่วนคำสั่งมาตรฐานของ Windows สามารถคำนวณเพียงค่าเท่านั้น คุณจึงต้องนำไปเปรียบเทียบกับค่าอย่างเป็นทางการด้วยตนเอง

ระบบปฏิบัติการ	คำสั่งตรวจสอบ
Linux	`sha256sum -c SHA256SUMS (ตรวจสอบทุกไฟล์ที่ระบุในไฟล์แสดงรายการ)`
macOS	`shasum -a 256 -c checksum.txt`
การตรวจสอบค่าเดียวแบบรวดเร็ว	`echo "ค่า-อย่างเป็นทางการ ชื่อไฟล์" \| sha256sum -c - (จะแสดงข้อความ OK เมื่อสำเร็จ)`
Windows	`คำนวณด้วย Get-FileHash <ไฟล์> -Algorithm SHA256 แล้วนำไปเปรียบเทียบกับค่าอย่างเป็นทางการ`

ประวัติด้านความปลอดภัยโดยย่อ: วิธีที่ MD5 ถูกทำลาย

MD5 ไม่ล้มเหลวในชั่วข้ามคืน — ตั้งแต่การพัฒนาเทคนิคการโจมตีครั้งแรกในวงการวิชาการ จนถึงการปลอมแปลงใบรับรองในโลกจริง ใช้เวลานานถึงสองทศวรรษ

1992

มีการเผยแพร่ MD5

โรนัลด์ ริเวสต์เปิดตัว MD5 ใน RFC 1321 มีความรวดเร็ว ใช้งานง่าย และผลัดกฤษณ์ 128 บิตเสมอ จึงกลายเป็นมาตรฐานที่ใช้กันอย่างแพร่หลายสำหรับการตรวจสอบผลรวมของไฟล์และการจัดเก็บรหัสผ่านในเวลาไม่นาน — และถูกมองว่ามีความปลอดภัยทางการเข้ารหัส
2004

ทีมของวัง เซี่ยวหยุนเปิดเผยการชนกันเต็มรูปแบบของ MD5

ในงาน CRYPTO 2004 ทีมที่นำโดยนักคณิตศาสตร์ชาวจีน วัง เซี่ยวหยุน ได้สาธิตการโจมตีแบบชนกันเต็มรูปแบบบน MD5 — โดยสร้างไฟล์สองไฟล์ที่มีเนื้อหาต่างกันแต่มีแฮชเดียวกัน (เดิมใช้เวลาประมาณหนึ่งชั่วโมงบนซูเปอร์คอมพิวเตอร์ IBM P690; ต่อมาปรับปรุงให้ใช้เวลาเพียงไม่กี่วินาทีบนฮาร์ดแวร์ธรรมดา) ความต้านทานการชนกันที่ MD5 สัญญาไว้หายไปแล้ว; การปรบมืออย่างยาวนานที่ตามมากลายเป็นหนึ่งในช่วงเวลาที่มีชื่อเสียงที่สุดในด้านการเข้ารหัส
2008

ใบรับรองปลอมโจมตีอินเทอร์เน็ตจริง

มาร์ค สตีเวนส์ อเล็กซานเดอร์ โซติโรฟ และผู้อื่นใช้การชนกันแบบเลือกคำนำหน้าเพื่อสร้างใบรับรอง CA ระดับกลางที่เบราว์เซอร์ไว้วางใจ: ใบรับรองที่มีคำนำหน้าต่างกันมีลายเซ็นเดียวกัน ตอนนี้ผู้โจมตีสามารถออกใบรับรอง HTTPS "ถูกต้อง" สำหรับเว็บปลอมใดก็ได้ หลังจากนั้นไม่นาน หน่วยงานออกใบรับรองก็หยุดออกใบรับรอง MD5
2012

มัลแวร์ Flameโจมตี Windows ผ่าน MD5

มัลแวร์ Flameที่รัฐบาลสนับสนุนใช้การชนกันของ MD5 เพื่อให้หน่วยงานการออกใบอนุญาตเซิร์ฟเวอร์เทอร์มินัลของไมโครซอฟต์ลงนามในใบรับรองการลงนามโค้ดปลอม ทำให้มัลแวร์สามารถแพร่กระจายทั่วตะวันออกกลางโดยปลอมตัวเป็นการอัปเดตที่ลงนามโดยไมโครซอฟต์ นี่เป็นการโจมตีในโลกจริงครั้งแรกที่ใช้การชนกันของ MD5; ไมโครซอฟต์เพิกถอนใบรับรองด้วยแพทช์ฉุกเฉิน
2017

SHAttered: SHA-1 ล่มสลาย

Google และสถาบัน CWI ของเนเธอร์แลนด์ (มาร์ค สตีเวนส์ และคณะ) ได้เผยแพร่ไฟล์ PDF ที่แตกต่างกันสองไฟล์ที่มีแฮช SHA-1 เหมือนกัน — ด้วยค่าใช้จ่ายประมาณ 6,500 CPU ปี และ 110 GPU ปี หลังจากนั้นไม่นาน เบราว์เซอร์ก็ถอนความไว้วางใจในใบรับรอง SHA-1 และแพลตฟอร์ม Git ก็เร่งการย้ายออกจาก SHA-1 ยุค 160 บิตจบลงแล้ว

ประเด็นสำคัญ: การโจมตีแบบชนกันไม่ได้ "ทุบทำลาย" แฮชของไฟล์ที่มีอยู่แล้ว — มันสร้างไฟล์เฉพาะสองไฟล์ที่แฮชเป็นค่าเดียวกัน แต่สำหรับลายเซ็นและใบรับรอง นั่นก็เพียงพอสำหรับการปลอมแปลงร้ายแรง

การแฮชจากบรรทัดคำสั่ง

เมื่อเบราว์เซอร์ไม่สะดวก แต่ละระบบปฏิบัติการมีคำสั่งในตัว (แสดง SHA-256)

สภาพแวดล้อม	คำสั่ง
Linux / macOS	`sha256sum ชื่อไฟล์ (บน macOS: shasum -a 256 ชื่อไฟล์)`
Windows PowerShell	`Get-FileHash ชื่อไฟล์ -Algorithm SHA256`
Windows CMD	`certutil -hashfile ชื่อไฟล์ SHA256`

การแฮชในโค้ด

ตัวอย่างพื้นฐานในภาษาทั่วไปสี่ภาษาเมื่อคุณเขียนสคริปต์หรือรวม API

JavaScript

async function sha256Hex(data) {
  const bytes = typeof data === "string"
    ? new TextEncoder().encode(data)
    : new Uint8Array(data);
  const digest = await crypto.subtle.digest("SHA-256", bytes);
  return [...new Uint8Array(digest)]
    .map((b) => b.toString(16).padStart(2, "0"))
    .join("");
}

// Text
console.log(await sha256Hex("hello"));

// Files: digest accepts an ArrayBuffer directly
const buf = await file.arrayBuffer();
console.log(await sha256Hex(buf));

Web Crypto ในตัวของเบราว์เซอร์รองรับเฉพาะตระกูล SHA และต้องใช้ HTTPS หรือ localhost; MD5 ต้องใช้ไลบรารีของบุคคลที่สาม

PHP

echo hash('sha256', 'hello');        // 64 hex characters
echo md5('hello');                   // same as hash('md5', 'hello')

// Streamed: hashes the file without loading it into memory
echo hash_file('sha256', 'setup.exe');

hash() และ hash_file() รองรับ md5, sha1, sha256, sha512 และอื่น ๆ; การแฮชไฟล์จะใช้สตรีม จึงใช้หน่วยความจำน้อย

Python

import hashlib

print(hashlib.sha256(b"hello").hexdigest())
print(hashlib.md5(b"hello").hexdigest())

# Large files: streamed, low memory (Python 3.11+)
with open("setup.exe", "rb") as f:
    print(hashlib.file_digest(f, "sha256").hexdigest())

ไลบรารีมาตรฐาน hashlib ไม่ต้องติดตั้ง; ใช้ file_digest() สำหรับการแฮชสตรีมของไฟล์ขนาดใหญ่ (Python 3.11 ขึ้นไป)

Rust

use sha2::{Digest, Sha256};
use md5::Md5;

// Text
println!("{:x}", Sha256::digest(b"hello"));
println!("{:x}", Md5::digest(b"hello"));

// Large files: streamed, low memory
let mut file = std::fs::File::open("setup.exe")?;
let mut hasher = Sha256::new();
std::io::copy(&mut file, &mut hasher)?;
println!("{:x}", hasher.finalize());

การแฮชไม่อยู่ในไลบรารีมาตรฐาน; เพิ่มแพ็กเกจ RustCrypto sha2 และ md-5 ใน Cargo.toml เมื่อเปิดใช้คุณสมบัติ std, io::copy จะสตรีมไฟล์เข้าไปใน hasher

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

ข้อความและไฟล์ของฉันอัปโหลดหรือไม่

ไม่ ทุกอย่างจะถูกคำนวณภายในเบราว์เซอร์ของคุณ: การเรียกใช้ครอบครัว SHA จะใช้ Web Crypto API ที่มีอยู่ในตัว และ MD5 จะทำงานใน JavaScript ของหน้า เว็บนี้ยังใช้งานได้เมื่อไม่มีเครือข่าย - ลองใช้กับไฟล์ที่ละเอียดอ่อนได้เลย

ทำไมข้อความว่างจึงยังมีแฮชอยู่?

อัลกอริทึมแฮชจะกำหนดผลลัพธ์ที่ไม่ซ้ำและมีความยาวคงที่แม้ในกรณีของศูนย์ไบต์ MD5 ของสตริงว่างคือ d41d8cd98f00b204e9800998ecf8427e ส่วน SHA-256 ของมันเริ่มต้นด้วย e3b0c442 เครื่องมือนี้จะซ่อนผลลัพธ์เมื่ออินพุตว่างเพียงเพื่อป้องกันคุณคัดลอกโดยไม่ได้ตั้งใจ

สามารถสร้างแฮชสำหรับไฟล์ทุกขนาดได้หรือไม่?

ขึ้นอยู่กับหน่วยความจำที่มีของเบราว์เซอร์ โดยทั่วไปแล้วไฟล์ติดตั้งและอิมเมจดิสก์ที่มีขนาดหลายร้อย MB จะใช้ได้ดี ไฟล์จะถูกอ่านเข้าหน่วยความจำในครั้งเดียว ดังนั้นหากเป็นไฟล์ขนาดหลาย GB ควรใช้เครื่องมือ command-line (sha256sum, certutil) จะดีกว่า

ทำไมแฮชจึงมีความยาวต่างกัน?

ความยาวจะถูกกำหนดโดยอัลกอริทึม: MD5 มี 32 อักขระเลขฐานสิบหก, SHA-1 มี 40, SHA-256 มี 64 และ SHA-512 มี 128 แต่ละไบต์มีอักขระเลขฐานสิบหก 2 ตัว และความยาวไม่ขึ้นกับขนาดอินพุต: ทั้งไฟล์ 1 ไบต์และไฟล์หลาย GB จะให้ SHA-256 ที่มี 64 อักขระ

สามารถใช้เครื่องมือนี้ในการสร้าง API signature ได้หรือไม่?

ได้ แพลตฟอร์มเปิดจำนวนมากจะลงชื่อคำขอโดยการแฮช "พารามิเตอร์ + ความลับ" ด้วย MD5 หรือ SHA-256 เครื่องมือนี้เหมาะสำหรับการตรวจสอบค่า signature ในขณะดีบัก แต่ในสภาพแวดล้อมการผลิต ให้คำนวณแฮชด้วยไลบรารีภาษาเซิร์ฟเวอร์ของคุณ และอย่าฝังความลับไว้ในโค้ดฝั่งไคลเอ็นต์เด็ดขาด

จะเปรียบเทียบ checksum ด้วยเครื่องมือนี้ได้อย่างไร?

สลับไปที่แท็บ "File checksum" วางไฟล์ลงในนั้น แล้ววาง checksum จากเว็บไซต์อย่างเป็นทางการลงในช่องด้านบนผลลัพธ์ เครื่องมือจะตรวจจับอัลกอริทึมโดยอัตโนมัติจากความยาว (MD5 32 อักขระ, SHA-1 40, SHA-256 64, SHA-384 96, SHA-512 128): แถวที่ตรงกันจะเปลี่ยนเป็นสีเขียวพร้อมข้อความ "Passed" เมื่อตรงกัน และเปลี่ยนเป็นสีแดงเมื่อไม่ตรงกัน โดยตัวพิมพ์, ช่องว่างรอบๆ และขึ้นบรรทัดใหม่จะถูกละเว้นโดยอัตโนมัติ

เครื่องมือที่เกี่ยวข้อง

เครื่องมือเข้ารหัส, การเข้ารหิสลับ และรหัสผ่านอื่นๆ

Base64 Encode / Decode

แปลงระหว่างไบนารีและข้อความ - มีประโยชน์สำหรับ Data URIs และการดีบัก HTTP basic auth

เครื่องมือสร้างรหัสผ่าน

สร้างรหัสผ่านสุ่มที่ปลอดภัย - รหัสผ่านควรเป็นแบบสุ่มและไม่ซ้ำ ไม่ใช่ "เข้ารหัส" ด้วยแฮช

เครื่องมือตรวจสอบความแข็งแรงของรหัสผ่าน

ตรวจสอบว่ารหัสผ่านมีความยาวและสุ่มพอหรือไม่ และว่าเคยปรากฏในการรั่วไหลข้อมูลที่ทราบหรือไม่

วางไฟล์ที่นี่ หรือคลิกเพื่อเรียกดู