แฮชชิ่ง — คืออะไร อัลกอริทึมการเข้ารหัส และการประยุกต์ใช้

แฮชชิ่งคืออะไร?

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

คุณสมบัติพื้นฐานของฟังก์ชันแฮช

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

ความแตกต่างจากการเข้ารหัส

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

ฟังก์ชันแฮชเชิงการเข้ารหัสและไม่เข้ารหัส

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

ฟังก์ชันแฮชเชิงการเข้ารหัส

ฟังก์ชันเหล่านี้ถูกทำให้ช้าและซับซ้อนโดยเจตนาเพื่อทำให้การโจมตีแบบเดารหัสผิดทำได้ยาก ฟังก์ชันเหล่านี้ต้องทนทานต่อการชนและการโจมตีแบบพรีอิมเมจ ตระกูล SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512) ได้รับการรับรองโดย NIST และแนะนำให้ใช้ในระบบของรัฐบาล สำหรับการแฮชรหัสผ่าน อัลกอริทึม bcrypt, scrypt และ Argon2 ถูกใช้เพิ่มเติมด้วย ความซับซ้อนที่ปรับได้

ฟังก์ชันแฮชที่ไม่เข้ารหัส

ฟังก์ชันเหล่านี้ถูกปรับให้เหมาะสมสำหรับความเร็ว ไม่ใช่ความปลอดภัย ตัวอย่าง: CityHash, MurmurHash, xxHash ใช้ในตารางแฮช การขจัดข้อมูลซ้ำซ้อน และเช็คซัมสำหรับการตรวจสอบความสมบูรณ์อย่างรวดเร็วของข้อมูลที่ไม่สำคัญ สิ่งสำคัญคือห้ามใช้ฟังก์ชันเหล่านี้ในการจัดเก็บรหัสผ่านหรือตรวจสอบลายเซ็นดิจิทัล — ความเร็วสูง ทำให้เสี่ยงต่อการโจมตีแบบเดารหัสผิด

อัลกอริทึมแฮชชิ่งยอดนิยม

มาสำรวจ อัลกอริทึมแฮชชิ่ง ที่พบได้บ่อยที่สุดที่ใช้ในการพัฒนาแอปพลิเคชันมือถือสมัยใหม่ แต่ละอัลกอริทึมมีจุดแข็งและจุดอ่อนของตัวเอง

SHA-256

SHA-256 เป็นสัญลักษณ์ของการเข้ารหัสสมัยใหม่ ได้รับการแนะนำโดย NIST ซึ่งเป็นส่วนหนึ่งของมาตรฐาน FIPS 180-4 อัลกอริทึมสร้างไดเจสต์ 256 บิตและเป็นองค์ประกอบหลักของโปรโตคอล TLS เครือข่ายบล็อกเชน และระบบควบคุมเวอร์ชัน ตามรายงานของ NCC Group (2025) SHA-256 ถูกใช้ใน 96% ของใบรับรอง TLS สำหรับการลงนามความโปร่งใสของใบรับรอง

SHA-3 — ผู้สืบทอดของ SHA-2

SHA-3 เป็นตระกูลฟังก์ชันแฮชรุ่นล่าสุด ที่ได้มาตรฐานโดย NIST ในปี 2015 ในชื่อ FIPS 202 แตกต่างจาก SHA-2 ที่สร้างบนโครงสร้าง Merkle–Damgård SHA-3 อาศัยโครงสร้าง Keccak ที่แตกต่างกับฟังก์ชันฟองน้ำ ทำให้ SHA-3 ทนทานต่อการโจมตีที่อาจเกิดขึ้นกับ SHA-2 ในอนาคต สำหรับนักพัฒนาแอปพลิเคชันมือถือ SHA-3 สามารถใช้งานได้ผ่านไลบรารีการเข้ารหัส มาตรฐาน ตั้งแต่ Android 7.0 และ iOS 13

import java.security.MessageDigest

fun hashWithSHA256(input: String): String {
    val digest = MessageDigest.getInstance("SHA-256")
    val hashBytes = digest.digest(input.toByteArray())
    return hashBytes.joinToString("") { String.format("%02x", it) }
}

bcrypt สำหรับรหัสผ่าน

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

import at.favre.lib.crypto.bcrypt.BCrypt

fun hashPassword(password: String): String {
    return BCrypt.create()
        .hashToString(BCrypt.MIN_COST, password.toCharArray())
}

fun verifyPassword(password: String, hash: String): Boolean {
    val result = BCrypt.verifyer().verify(password.toCharArray(), hash)
    return result.verified
}

Argon2 — มาตรฐานสมัยใหม่

Argon2 เป็นผู้ชนะการแข่งขัน Password Hashing Competition (2015) ซึ่ง OWASP แนะนำให้เป็นตัวเลือกที่ดีที่สุดสำหรับการแฮชรหัสผ่าน Argon2id เป็นรูปแบบที่ทนทานต่อการโจมตีช่องทางข้างเคียงและการโจมตีแบบแลกเวลากับหน่วยความจำ แตกต่างจาก bcrypt Argon2 อนุญาตให้กำหนดค่าเวลาดำเนินการ การใช้หน่วยความจำ และระดับความขนานแยกกัน ให้การป้องกันที่ยืดหยุ่นต่อการโจมตีประเภทต่างๆ

การประยุกต์ใช้แฮชชิ่งในแอปพลิเคชันมือถือ

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

การจัดเก็บรหัสผ่าน

กรณีการใช้งานหลักคือ การจัดเก็บรหัสผ่านอย่างปลอดภัย ฝั่งเซิร์ฟเวอร์ เมื่อลงทะเบียน แอปพลิเคชันส่งรหัสผ่านไปยังเซิร์ฟเวอร์ ซึ่งจะถูกแฮชด้วยเกลือโดยใช้ bcrypt หรือ Argon2 และจัดเก็บในฐานข้อมูล เมื่อเข้าสู่ระบบ เซิร์ฟเวอร์จะแฮชรหัสผ่านที่ป้อนและเปรียบเทียบกับแฮชที่จัดเก็บไว้ OWASP แนะนำให้ใช้ Argon2id ด้วยพารามิเตอร์: เวลา 2 วินาที หน่วยความจำ 64 MB ระดับความขนาน 4

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

เมื่อดาวน์โหลดไฟล์ขนาดใหญ่ เช่น แพ็คเกจ OBB หรือการอัปเดตเนื้อหา แอปพลิเคชันมือถือสามารถตรวจสอบความสมบูรณ์ผ่าน แฮชชิ่ง เซิร์ฟเวอร์เผยแพร่แฮช SHA-256 ของไฟล์ และแอปพลิเคชันคำนวณแฮชของข้อมูลที่ดาวน์โหลดและเปรียบเทียบ สิ่งนี้รับประกันว่าไฟล์ไม่เสียหายหรือถูกแก้ไขระหว่างการส่ง ตาม Google Play Console (2025) การตรวจสอบแฮช ของแอปพลิเคชันที่ผ่านการรับรองป้องกันการโจมตีการดาวน์โหลดที่เสียหายได้ถึง 99.9%

แคชและการขจัดข้อมูลซ้ำซ้อน

แฮช ถูกใช้อย่างแข็งขันสำหรับสร้างแคชที่มีประสิทธิภาพและการขจัดข้อมูลซ้ำซ้อน ที่อยู่ของรูปภาพหรือการตอบสนอง JSON ถูกแฮชและใช้เป็นคีย์แคช: เมื่อคำขอซ้ำ ระบบจะเปรียบเทียบแฮชและส่งคืนผลลัพธ์ที่จัดเก็บไว้หากข้อมูลไม่เปลี่ยนแปลง สำหรับงานนี้ ฟังก์ชันแฮช ที่ไม่เข้ารหัส เช่น MurmurHash หรือ xxHash เหมาะสม ให้ประสิทธิภาพสูงสุด

import java.security.MessageDigest

fun calculateFileHash(fileBytes: ByteArray): String {
    val digest = MessageDigest.getInstance("SHA-256")
    val hash = digest.digest(fileBytes)
    return hash.joinToString("") { String.format("%02x", it) }
}

fun verifyIntegrity(data: ByteArray, expectedHash: String): Boolean {
    val actualHash = calculateFileHash(data)
    return actualHash == expectedHash
}

ข้อผิดพลาดทั่วไปเมื่อใช้แฮช

แม้แต่นักพัฒนาที่มีประสบการณ์ก็ทำผิดพลาดเมื่อทำงานกับ แฮชชิ่ง มาสำรวจปัญหาที่พบบ่อยที่สุดที่สามารถลบล้างข้อดีทั้งหมดของการป้องกันเชิงการเข้ารหัส

การใช้ MD5 หรือ SHA-1

MD5 และ SHA-1 เป็นอัลกอริทึมที่ล้าสมัยซึ่งมีการโจมตีแบบชนได้จริง MD5 ถูกทำลายในปี 2004 โดยกลุ่มนักวิจัยชาวจีน (ชนในหนึ่งชั่วโมง) SHA-1 ถูกทำลายในปี 2017 โดยทีมจาก Google และ Centrum Wiskunde & Informatica (การโจมตี SHAttered) การใช้อัลกอริทึมเหล่านี้ในโปรเจกต์ใหม่ถือเป็น ข้อผิดพลาดด้านความปลอดภัยที่ร้ายแรง ตามการจำแนกของ OWASP

การแฮชโดยไม่มีเกลือ

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

จำนวนรอบไม่เพียงพอ

แม้เมื่อใช้ bcrypt หรือ Argon2 ก็สามารถลดการป้องกันได้โดยการเลือก พารามิเตอร์ต้นทุน ที่ต่ำเกินไป ตามข้อมูลของ OWASP (2025) จำนวนรอบ bcrypt ขั้นต่ำควรเป็น 10 (2^10 = 1024 รอบ) และสำหรับ Argon2id เวลาในการคำนวณควรอย่างน้อย 1 วินาทีบนแพลตฟอร์มเป้าหมาย พารามิเตอร์ที่ต่ำเกินไปทำให้การโจมตีแบบเดารหัสผิด สามารถทำได้จริง บนฟาร์ม GPU