ความแตกต่างพื้นฐานระหว่างอัลกอริทึม Hashing และการเข้ารหัส

ฉันเห็นความสับสนมากมายระหว่างแฮชและอัลกอริธึมการเข้ารหัสและฉันต้องการฟังคำแนะนำจากผู้เชี่ยวชาญเพิ่มเติมเกี่ยวกับ:

1. ควรใช้แฮชเมื่อใดเทียบกับการเข้ารหัส

2. สิ่งที่ทำให้แฮชหรืออัลกอริธึมการเข้ารหัสแตกต่างกัน (จากระดับทฤษฎี / คณิตศาสตร์) คือสิ่งที่ทำให้แฮชไม่สามารถย้อนกลับได้ (โดยไม่ต้องอาศัยต้นรุ้ง)

นี่คือคำถาม SO ที่คล้ายกันที่ไม่ได้ลงรายละเอียดมากที่สุดเท่าที่ฉันกำลังมองหา:

ความแตกต่างระหว่าง Obfuscation, Hashing และ Encryption คืออะไร
ความแตกต่างระหว่างการเข้ารหัสและการแฮช

คุณสามารถค้นหาในWikipedia ... แต่เนื่องจากคุณต้องการคำอธิบายฉันจะทำให้ดีที่สุดที่นี่:

ฟังก์ชันแฮช

จัดเตรียมการแม็พระหว่างอินพุตความยาวตามอำเภอใจและเอาต์พุต (ปกติ) ความยาวคงที่ (หรือความยาวน้อยกว่า) มันสามารถเป็นอะไรก็ได้ตั้งแต่ crc32 ธรรมดาไปจนถึงฟังก์ชั่นแฮชเข้ารหัสเต็มรูปแบบเช่น MD5 หรือ SHA1 / 2/256/512 ประเด็นคือมีการทำแผนที่ทางเดียวที่เกิดขึ้น มีการแมปจำนวนมากเสมอ: 1 (หมายถึงจะมีการชนกันอยู่เสมอ) เนื่องจากทุกฟังก์ชั่นให้ผลผลิตที่น้อยกว่าความสามารถในการป้อนข้อมูล (หากคุณป้อนไฟล์ 1mb ที่เป็นไปได้ทั้งหมดลงใน MD5 คุณจะได้รับการชนจำนวนมาก)

เหตุผลที่พวกเขายาก (หรือเป็นไปไม่ได้ในการปฏิบัติจริง) เพื่อย้อนกลับเป็นเพราะพวกเขาทำงานภายใน ฟังก์ชันแฮชการเข้ารหัสลับส่วนใหญ่วนซ้ำไปตามอินพุตที่ตั้งไว้หลายครั้งเพื่อสร้างเอาต์พุต ดังนั้นถ้าเราดูแต่ละอันของความยาวคงที่ (ซึ่งขึ้นอยู่กับอัลกอริทึม) ฟังก์ชันแฮชจะเรียกสถานะปัจจุบันว่า จากนั้นจะวนซ้ำสถานะและเปลี่ยนเป็นสถานะใหม่และใช้เป็นข้อเสนอแนะในตัวเอง (MD5 ทำเช่นนี้ 64 ครั้งสำหรับแต่ละบิตข้อมูล 512 บิต) จากนั้นจะรวมสถานะผลลัพธ์จากการวนซ้ำทั้งหมดเหล่านี้กลับเข้าด้วยกันเพื่อสร้างแฮชผลลัพธ์

ตอนนี้ถ้าคุณต้องการถอดรหัสแฮชก่อนอื่นคุณต้องหาวิธีแยกแฮชที่ให้ออกไปเป็นสถานะที่มีการวนซ้ำ (1 ความเป็นไปได้สำหรับอินพุตที่เล็กกว่าขนาดของก้อนข้อมูล จากนั้นคุณจะต้องย้อนกลับการวนซ้ำสำหรับแต่ละรัฐ ตอนนี้จะอธิบายว่าทำไมนี้เป็นเรื่องยากมากคิดพยายามที่จะอนุมานaและจากสูตรดังต่อไปนี้:b 10 = a + bมีชุดค่าผสม 10 ค่าบวกaและbสามารถใช้งานได้ ทีนี้วนซ้ำหลาย ๆ ครั้ง:tmp = a + b; a = b; b = tmp. สำหรับการทำซ้ำ 64 ครั้งคุณจะมีความเป็นไปได้มากกว่า 10 ^ 64 ที่จะลอง และนั่นเป็นเพียงการเพิ่มที่เรียบง่ายซึ่งบางรัฐถูกสงวนไว้จากการทำซ้ำไปยังการทำซ้ำ ฟังก์ชันแฮชจริงทำมากกว่า 1 การดำเนินการ (MD5 ทำงานได้ประมาณ 15 การดำเนินการกับตัวแปรสถานะ 4 ตัว) และเนื่องจากการวนซ้ำครั้งต่อไปขึ้นอยู่กับสถานะของก่อนหน้านี้และก่อนหน้านี้ถูกทำลายในการสร้างสถานะปัจจุบันมันเป็นไปไม่ได้เลยที่จะกำหนดสถานะอินพุตที่นำไปสู่สถานะเอาต์พุตที่กำหนด (สำหรับแต่ละการวนซ้ำไม่น้อย) รวมกับความเป็นไปได้จำนวนมากที่เกี่ยวข้องและการถอดรหัสแม้ MD5 จะใช้ทรัพยากรจำนวนใกล้เคียง (แต่ไม่ จำกัด ไม่) ทรัพยากรมากมายที่มัน '

ฟังก์ชั่นการเข้ารหัส

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

ใช้เคส

ใช้ฟังก์ชันแฮชเมื่อคุณต้องการเปรียบเทียบค่า แต่ไม่สามารถเก็บการแทนค่าธรรมดา (ด้วยเหตุผลใด ๆ ก็ได้) รหัสผ่านควรเหมาะกับกรณีการใช้งานนี้เป็นอย่างดีเนื่องจากคุณไม่ต้องการเก็บข้อความธรรมดาไว้ด้วยเหตุผลด้านความปลอดภัย (และไม่ควร) แต่ถ้าคุณต้องการตรวจสอบระบบไฟล์สำหรับไฟล์เพลงที่ละเมิดลิขสิทธิ์ล่ะ จะไม่สามารถจัดเก็บไฟล์ 3 MB ต่อไฟล์เพลง ดังนั้นให้ใช้แฮชของไฟล์แทนและเก็บไว้ (md5 จะเก็บ 16 ไบต์แทน 3mb) ด้วยวิธีนี้คุณเพียงแค่แฮชไฟล์แต่ละไฟล์และเปรียบเทียบกับฐานข้อมูลแฮชที่เก็บไว้ (วิธีนี้ไม่ได้ผลเช่นกันเนื่องจากการเข้ารหัสใหม่การเปลี่ยนส่วนหัวของไฟล์ ฯลฯ แต่เป็นตัวอย่างการใช้งาน)

ใช้ฟังก์ชันแฮชเมื่อคุณกำลังตรวจสอบความถูกต้องของข้อมูลอินพุต นั่นคือสิ่งที่พวกเขาออกแบบมา หากคุณมีอินพุต 2 ชิ้นและต้องการตรวจสอบว่าเหมือนกันหรือไม่ให้รันทั้งสองผ่านฟังก์ชั่นแฮช ความน่าจะเป็นของการชนนั้นต่ำมากสำหรับขนาดอินพุตที่เล็ก (สมมติว่าเป็นฟังก์ชันแฮชที่ดี) นี่คือเหตุผลที่แนะนำให้ใช้รหัสผ่าน สำหรับรหัสผ่านสูงสุด 32 ตัวอักษร md5 มีพื้นที่เอาต์พุต 4 เท่า SHA1 มีพื้นที่เอาต์พุต 6 เท่า (โดยประมาณ) SHA512 มีพื้นที่เอาต์พุตประมาณ 16 เท่า คุณไม่สนใจจริงๆว่ารหัสผ่านคืออะไรคุณสนใจหรือไม่ว่าเป็นรหัสเดียวกับที่จัดเก็บไว้ นั่นเป็นเหตุผลที่คุณควรใช้แฮชสำหรับรหัสผ่าน

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

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

หมายเหตุเกี่ยวกับแฮชสำหรับรหัสผ่าน:

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

การเพิ่มเกลือช่วยเรื่องสำคัญเพราะมันจะเพิ่มข้อมูลที่ไม่รู้จักเล็กน้อยลงในแฮช ดังนั้นแทนที่จะค้นหาสิ่งที่ตรงกันmd5(foo)พวกเขาต้องค้นหาสิ่งที่เมื่อเพิ่มเข้าไปในเกลือที่รู้จักก่อให้เกิดmd5(foo.salt)(ซึ่งยากมากที่จะทำ) แต่ก็ยังไม่สามารถแก้ปัญหาความเร็วได้เพราะถ้าพวกเขารู้ว่าเกลือมันเป็นเพียงเรื่องของการเรียกใช้พจนานุกรมผ่าน

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

var hash = password + salt;
for (var i = 0; i < 5000; i++) {
    hash = sha512(hash + password + salt);
}

อื่น ๆ ที่มีการใช้งานมาตรฐานมากขึ้นเช่นPBKDF2 , bcrypt แต่เทคนิคนี้ใช้โดยระบบที่เกี่ยวข้องกับความปลอดภัยค่อนข้างน้อย (เช่น PGP, WPA, Apache และ OpenSSL)

บรรทัดล่างhash(password)ไม่ดีพอ hash(password + salt)ดีกว่า แต่ก็ยังไม่ดีพอ ... ใช้กลไกแฮชที่ยืดออกเพื่อสร้างรหัสผ่านแฮชของคุณ ...

หมายเหตุเกี่ยวกับการยืดเล็กน้อย

ไม่ว่าในกรณีใด ๆ ให้ป้อนเอาต์พุตของแฮ็ชหนึ่งอันกลับไปยังฟังก์ชันแฮชโดยตรง :

hash = sha512(password + salt); 
for (i = 0; i < 1000; i++) {
    hash = sha512(hash); // <-- Do NOT do this!
}

เหตุผลนี้เกี่ยวข้องกับการชน โปรดจำไว้ว่าฟังก์ชันแฮชทั้งหมดมีการชนกันเนื่องจากพื้นที่เอาต์พุตที่เป็นไปได้ (จำนวนเอาต์พุตที่เป็นไปได้) มีขนาดเล็กกว่าพื้นที่อินพุตนั้น เพื่อดูว่าทำไมเรามาดูสิ่งที่เกิดขึ้น เพื่อบทนี้ขอให้สมมติฐานที่ว่ามีโอกาสที่ 0.001% ของการชนจากsha1()(มันมากต่ำกว่าในความเป็นจริง แต่สำหรับวัตถุประสงค์ในการสาธิต)

hash1 = sha1(password + salt);

ตอนนี้hash1มีความน่าจะเป็นของการชนที่ 0.001% แต่เมื่อเราทำต่อไปhash2 = sha1(hash1);, การชนกันทั้งหมดของhash1hash2ชนกลายเป็นโดยอัตโนมัติ ดังนั้นตอนนี้เรามีอัตราแฮช 1 ที่ 0.001% และการsha1()โทรครั้งที่สองเพิ่มเข้าไป ดังนั้นตอนนี้hash2มีความน่าจะเป็นของการชนกันของ 0.002% นั่นเป็นโอกาสที่สองเท่า! การวนซ้ำแต่ละครั้งจะเพิ่ม0.001%โอกาสการชนอีกครั้งกับผลลัพธ์ ดังนั้นด้วยการวนซ้ำ 1,000 ครั้งโอกาสในการปะทะกันเพิ่มขึ้นจาก 0.001% เป็น 1% ตอนนี้การย่อยสลายเป็นเส้นตรงและความน่าจะเป็นจริงไกลขนาดเล็ก แต่ผลที่ได้คือเดียวกัน (การประเมินของโอกาสของการปะทะกันครั้งเดียวที่มีmd5ประมาณ 1 / (2 ¹²⁸ ) หรือ 1 / (3x10 ³⁸) แม้ว่าจะดูเล็ก แต่ต้องขอบคุณการโจมตีวันเกิดแต่ก็ไม่เล็กเท่าที่ควร)

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

hash = sha512(password + salt);
for (i = 0; i < 1000; i++) {
    hash = sha512(hash + password + salt);
}

มีโอกาสชนกันกับsha512ฟังก์ชันเนทิฟ สิ่งที่คุณต้องการ ใช้สิ่งนั้นแทน

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

การไปทางอื่นนั้นเป็นเรื่องยากเป็นพิเศษ - คุณไม่สามารถแยกขนมปังกลับเป็นแป้งน้ำยีสต์ - บางส่วนก็หายไปในระหว่างกระบวนการอบและคุณไม่สามารถบอกได้ว่าปริมาณน้ำหรือแป้งหรือยีสต์เท่าไร ก้อนหนึ่งโดยเฉพาะเพราะข้อมูลนั้นถูกทำลายโดยฟังก์ชันการแปลงแป้นพิมพ์ (aka เตาอบ)

ในหลาย ๆ ทางทฤษฎีของปัจจัยการผลิตจะผลิตก้อนที่เหมือนกัน (เช่นน้ำ 2 ถ้วยและยีสต์ 1 ช้อนโต๊ะผลิตก้อนเดียวกับ 2.1 ถ้วยน้ำและ 0.9tsbp ของยีสต์) แต่ถ้าเป็นหนึ่งก้อนคุณไม่สามารถบอกได้ สิ่งที่คำสั่งผสมของอินพุตผลิตออกมา

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

ใช้แฮชเมื่อคุณไม่ต้องการรับอินพุทดั้งเดิมกลับมาใช้การเข้ารหัสเมื่อคุณทำ

HASH รับอินพุตและเปลี่ยนเป็นบิต (โดยปกติจะคิดว่าเป็นตัวเลขเช่นจำนวนเต็ม 32 บิต, จำนวนเต็ม 64 บิตเป็นต้น) อินพุตเดียวกันจะสร้างแฮชเดียวกันเสมอ แต่คุณสูญเสียข้อมูลในกระบวนการดังนั้นคุณจึงไม่สามารถสร้างอินพุตดั้งเดิมได้อย่างน่าเชื่อถือ (มีข้อแม้อยู่สองสามข้อ)

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

ตัวอย่างง่ายๆของการแปลงแป้นพิมพ์

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

ตัวอย่าง:

Input    Hash
0010     0
0011     1
0110     1
1000     0

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

โดยวิธีการนี้ 1 บิตกัญชาไม่ได้วางแผนไว้ว่า ... มีลักษณะที่บิตพาริตี

ตัวอย่างง่ายๆของการเข้ารหัส

คุณอาจเข้ารหัสข้อความโดยใช้การเปลี่ยนตัวอักษรแบบง่ายพูดว่าอินพุตคือ A คุณเขียน B ถ้าอินพุตคือ B คุณเขียน C ไปจนสุดตัวอักษรโดยที่ถ้าอินพุตคือ Z คุณ เขียน A อีกครั้ง

Input   Encrypted
CAT     DBU
ZOO     APP

เช่นเดียวกับตัวอย่างเช่นกัญชาง่ายประเภทของการเข้ารหัสนี้ได้ถูกนำมาใช้ในอดีต

ภาพรวมพื้นฐานของเทคนิคการแฮชและการเข้ารหัส / ถอดรหัสคือ

hashing:

หากคุณสับใด ๆข้อความธรรมดาอีกครั้งคุณไม่สามารถได้รับข้อความธรรมดาเดียวกันจากข้อความแฮช มันเป็นกระบวนการทางเดียว

---

การเข้ารหัสและถอดรหัส:

หากคุณเข้ารหัสใด ๆข้อความธรรมดาที่มีคีย์อีกครั้งคุณจะได้รับข้อความธรรมดาเดียวกันโดยการทำถอดรหัสข้อความที่เข้ารหัสด้วยเหมือนกัน (symetric) / ที่แตกต่างกัน (asymentric) ที่สำคัญ

ปรับปรุง: เพื่อที่อยู่จุดที่กล่าวถึงในคำถามที่แก้ไข

1. เมื่อใดควรใช้แฮ็ชกับการเข้ารหัส

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

การเข้ารหัสเป็นสิ่งที่ดีถ้าคุณบอกว่ามีข้อความที่จะส่งถึงใครบางคน คุณเข้ารหัสข้อความด้วยคีย์และผู้รับถอดรหัสด้วยคีย์เดียวกัน (หรืออาจจะแตกต่างกัน) เพื่อรับข้อความเดิม เครดิต

---

2. อะไรที่ทำให้แฮชหรืออัลกอริธึมการเข้ารหัสแตกต่างกัน (จากระดับทฤษฎี / คณิตศาสตร์) คือสิ่งที่ทำให้แฮชไม่สามารถย้อนกลับได้

โดยทั่วไปคร่ำเครียดคือการดำเนินการที่สูญเสียข้อมูล แต่ไม่เข้ารหัส มาดูความแตกต่างในวิธีการทางคณิตศาสตร์อย่างง่ายเพื่อความเข้าใจที่ง่ายของเราแน่นอนว่าทั้งคู่มีการดำเนินการทางคณิตศาสตร์ที่ซับซ้อนมากขึ้นด้วยการทำซ้ำที่เกี่ยวข้องกับมัน

การเข้ารหัส / ถอดรหัส (ย้อนกลับ):

นอกจากนี้ :

4 + 3 = 7  

สิ่งนี้สามารถย้อนกลับได้โดยการหาผลรวมและลบหนึ่งในส่วนเพิ่มเติม

7 - 3 = 4     

การคูณ :

4 * 5 = 20  

สิ่งนี้สามารถย้อนกลับได้โดยการนำผลิตภัณฑ์มาหารด้วยหนึ่งในปัจจัย

20 / 4 = 5    

ดังนั้นที่นี่เราอาจสันนิษฐานว่าหนึ่งในการเพิ่ม / ปัจจัยคือคีย์ decrpytion และผล (7,20) เป็นข้อความที่เข้ารหัสลับ

---

Hashing (ไม่สามารถย้อนกลับได้):

แผนก Modulo :

22 % 7 = 1   

สิ่งนี้ไม่สามารถยกเลิกได้เนื่องจากไม่มีการดำเนินการที่คุณสามารถทำกับผลหารและเงินปันผลเพื่อสร้างตัวหารใหม่ (หรือกลับกัน)

คุณสามารถหาการดำเนินการเพื่อเติมในที่ '?' คือ?

1  ?  7 = 22  
1  ?  22 = 7

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

เครดิต

หนึ่งซับของฉัน ... โดยทั่วไปผู้สัมภาษณ์ต้องการคำตอบด้านล่าง

การแฮ็ชเป็นวิธีหนึ่ง คุณไม่สามารถแปลงข้อมูล / สตริงของคุณจากรหัสแฮช

การเข้ารหัสนั้นมี 2 วิธี - คุณสามารถถอดรหัสสตริงที่เข้ารหัสได้อีกครั้งหากคุณมีกุญแจติดตัว

ฟังก์ชั่นแฮเปลี่ยนจำนวนตัวแปรขนาดของข้อความเป็นตัวอักษรขนาดคงที่-A

ที่มา: https://en.wikipedia.org/wiki/Hash_function

ฟังก์ชันแฮชใน PHP

แฮชเปลี่ยนสตริงเป็นสตริงที่แฮช ดูด้านล่าง

กัญชา:

$str = 'My age is 29';
$hash = hash('sha1', $str);
echo $hash; // OUTPUT: 4d675d9fbefc74a38c89e005f9d776c75d92623e

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

DEHASH:

SHA1 เป็นแฮชทางเดียว ซึ่งหมายความว่าคุณไม่สามารถแฮชแฮช

อย่างไรก็ตามคุณสามารถบังคับให้แฮชดุร้ายได้ โปรดดูที่: https://hashkiller.co.uk/sha1-decrypter.aspx

MD5 เป็นแฮชอีกอัน MD5 dehasher สามารถพบได้บนเว็บไซต์นี้: https://www.md5online.org/

เพื่อขัดขวางการโจมตีที่ดุร้ายกับแฮชจะได้รับเกลือ ใน php คุณสามารถใช้password_hash()สำหรับการสร้างรหัสผ่านแฮช ฟังก์ชั่นpassword_hash()สร้างเกลือโดยอัตโนมัติ ยืนยันรหัสผ่านบนกัญชารหัสผ่าน (เกลือ) password_verify()การใช้งาน

// Invoke this little script 3 times, and it will give you everytime a new hash
$password = '1234';  
$hash = password_hash($password, PASSWORD_DEFAULT);  

echo $hash; 
// OUTPUT 

$2y$10$ADxKiJW/Jn2DZNwpigWZ1ePwQ4il7V0ZB4iPeKj11n.iaDtLrC8bu 

$2y$10$H8jRnHDOMsHFMEZdT4Mk4uI4DCW7/YRKjfdcmV3MiA/WdzEvou71u 

$2y$10$qhyfIT25jpR63vCGvRbEoewACQZXQJ5glttlb01DmR4ota4L25jaW

รหัสผ่านหนึ่งรหัสสามารถแทนด้วยแฮชมากกว่าหนึ่งรหัส เมื่อคุณยืนยันรหัสผ่านที่มีการแฮชรหัสผ่านที่แตกต่างกันโดยใช้password_verify()รหัสผ่านนั้นจะถูกยอมรับว่าเป็นรหัสผ่านที่ถูกต้อง

$password = '1234';  

$hash = '$2y$10$ADxKiJW/Jn2DZNwpigWZ1ePwQ4il7V0ZB4iPeKj11n.iaDtLrC8bu';  
var_dump( password_verify($password, $hash) );  

$hash = '$2y$10$H8jRnHDOMsHFMEZdT4Mk4uI4DCW7/YRKjfdcmV3MiA/WdzEvou71u';  
var_dump( password_verify($password, $hash) );  

$hash = '$2y$10$qhyfIT25jpR63vCGvRbEoewACQZXQJ5glttlb01DmR4ota4L25jaW';  
var_dump( password_verify($password, $hash) );

// OUTPUT 

boolean true 

boolean true 

boolean true

ฟังก์ชั่นการเข้ารหัส แปลงข้อความเป็น ciphertext ไร้สาระโดยใช้คีย์การเข้ารหัสและในทางกลับกัน

ที่มา: https://en.wikipedia.org/wiki/Encryption

การเข้ารหัสใน PHP

ลองดำดิ่งเข้าไปในโค้ด PHP ที่จัดการการเข้ารหัส

--- นามสกุล Mcrypt ---

เข้ารหัส:

$cipher = MCRYPT_RIJNDAEL_128;
$key = 'A_KEY';
$data = 'My age is 29';
$mode = MCRYPT_MODE_ECB;

$encryptedData = mcrypt_encrypt($cipher, $key , $data , $mode);
var_dump($encryptedData);

//OUTPUT:
string '„Ùòyªq³¿ì¼üÀpå' (length=16)

ถอดรหัส:

$decryptedData = mcrypt_decrypt($cipher, $key , $encryptedData, $mode);
$decryptedData = rtrim($decryptedData, "\0\4"); // Remove the nulls and EOTs at the END
var_dump($decryptedData);

//OUTPUT:
string 'My age is 29' (length=12)

--- การขยาย OpenSSL ---

การขยายของ Mcrypt นั้นเลิกใช้ใน 7.1 และลบออกใน php 7.2 ส่วนขยาย OpenSSL ควรใช้ใน php 7 ดูตัวอย่างโค้ดด้านล่าง:

$key = 'A_KEY';
$data = 'My age is 29';

// ENCRYPT
$encryptedData = openssl_encrypt($data , 'AES-128-CBC', $key, 0, 'IV_init_vector01');
var_dump($encryptedData);

// DECRYPT    
$decryptedData = openssl_decrypt($encryptedData, 'AES-128-CBC', $key, 0, 'IV_init_vector01');
var_dump($decryptedData);

//OUTPUT
string '4RJ8+18YkEd7Xk+tAMLz5Q==' (length=24)
string 'My age is 29' (length=12)

การเข้ารหัสแบบสมมาตร:

การเข้ารหัสแบบสมมาตรอาจเรียกว่ารหัสที่ใช้ร่วมกันหรือการเข้ารหัสลับที่ใช้ร่วมกัน ในการเข้ารหัสแบบสมมาตรจะใช้ปุ่มเดียวเพื่อเข้ารหัสและถอดรหัสทราฟฟิก

การเข้ารหัสแบบอสมมาตร:

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

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

hashing:

ในที่สุด hashing เป็นรูปแบบของการรักษาความปลอดภัยการเข้ารหัสซึ่งแตกต่างจากการเข้ารหัส ในขณะที่การเข้ารหัสเป็นกระบวนการสองขั้นตอนที่ใช้ในการเข้ารหัสก่อนแล้วจึงถอดรหัสข้อความการบีบอัดข้อความจะทำให้ข้อความที่มีค่าความยาวคงที่ไม่สามารถย้อนกลับได้หรือแฮช สองในที่สุดขั้นตอนวิธี hashing ทั่วไปเห็นในเครือข่ายที่มีและMD5SHA-1

อ่านเพิ่มเติมได้ที่นี่: http://packetlife.net/blog/2010/nov/23/symmetric-asymmetric-encrypt-hashing/

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

2. อัลกอริทึมการแฮชและอัลกอริทึมการเข้ารหัสเป็นเพียงอัลกอริทึมทางคณิตศาสตร์ ดังนั้นในแง่ที่พวกเขาไม่แตกต่าง - มันเป็นเพียงสูตรทางคณิตศาสตร์ อย่างไรก็ตามความหมายของความหมายนั้นมีความแตกต่างอย่างมากระหว่างการแปลงแป้นพิมพ์ (ทางเดียว) และการเข้ารหัส (แบบสองทาง) ทำไมแฮชจึงไม่สามารถกลับคืนสภาพเดิมได้? เพราะมันถูกออกแบบมาให้เป็นแบบนั้นเพราะบางครั้งคุณต้องการการทำงานแบบทางเดียว

อัลกอริทึมการเข้ารหัสและแฮชทำงานในลักษณะเดียวกัน ในแต่ละกรณีมีความจำเป็นที่จะต้องสร้างความสับสนและความแตกต่างระหว่างบิต ต้มลงความสับสนคือการสร้างความสัมพันธ์ที่ซับซ้อนระหว่างที่สำคัญและ ciphertext และแพร่มีการแพร่กระจายข้อมูลของแต่ละรอบบิต

ฟังก์ชั่นกัญชาหลายจริงใช้วิธีการเข้ารหัสลับ (หรือพื้นฐานของขั้นตอนวิธีการเข้ารหัส. ยกตัวอย่างเช่น SHA-3 ผู้สมัครเข็ดใช้ Threefish เป็นวิธีการพื้นฐานในการประมวลผลแต่ละบล็อก. แตกต่างคือแทนที่จะรักษาบล็อก ciphertext แต่ละพวกเขาจะทำลาย, ผสานกันอย่างถาวรกับความยาวคงที่

เมื่อพูดถึงเรื่องความปลอดภัยสำหรับการส่งข้อมูลนั่นคือการสื่อสารสองทางที่คุณใช้การเข้ารหัสการเข้ารหัสทั้งหมดต้องใช้กุญแจ

เมื่อพูดถึงการอนุญาตที่คุณใช้การแฮชไม่มีคีย์ในการแฮช

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

ทำไมการแฮ็กถึงไม่สามารถกลับคืนสภาพเดิมได้:

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

การเข้ารหัสเกี่ยวข้องกับตัวเลขและสตริง โดยพื้นฐานแล้วทุกสิ่งในโลกดิจิตอลล้วนเป็นตัวเลข เมื่อฉันพูดตัวเลขมันคือ 0 & 1 คุณรู้ว่ามันคืออะไรไบนารี ภาพที่คุณเห็นบนหน้าจอเพลงที่คุณฟังผ่านหูฟังของคุณทุกอย่างเป็นไบนารี แต่หูและตาของเราจะไม่เข้าใจไบนารีใช่มั้ย มีเพียงสมองเท่านั้นที่เข้าใจสิ่งนั้นและแม้ว่ามันจะสามารถเข้าใจไบนารีได้ แต่ก็ไม่สามารถเพลิดเพลินกับไบนารีได้ ดังนั้นเราจึงแปลงไบนารีให้เป็นรูปแบบที่มนุษย์เข้าใจได้เช่น mp3, jpg เป็นต้น Let 's ระยะการดำเนินการตามการเข้ารหัส มันเป็นกระบวนการแบบสองทางและสามารถถอดรหัสกลับสู่รูปแบบดั้งเดิมได้อย่างง่ายดาย

คร่ำเครียด

การแฮชเป็นเทคนิคการเข้ารหัสลับอีกรูปแบบหนึ่งซึ่งข้อมูลที่เคยถูกแปลงเป็นรูปแบบอื่นจะไม่สามารถกู้คืนได้ ในระยะของคนธรรมดา, ไม่มีกระบวนการใดที่เรียกว่าเดอคร่ำเครียด มีฟังก์ชันแฮชจำนวนมากเพื่อทำงานเช่น sha-512, md5 และอื่น ๆ

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

เครดิต: วิกิมีเดียโดยใช้แฮชกับรหัสผ่านเราสามารถมั่นใจได้ว่าผู้โจมตีจะไม่ได้รับรหัสผ่านของเราแม้ว่าเขาจะขโมยไฟล์รหัสผ่านที่เก็บไว้ ผู้โจมตีจะมีแฮชของรหัสผ่าน เขาอาจจะสามารถค้นหารายการรหัสผ่านที่ใช้บ่อยที่สุดและใช้sha-512กับแต่ละรหัสและเปรียบเทียบกับค่าในมือของเขา มันถูกเรียกว่าโจมตีพจนานุกรม แต่เขาจะทำสิ่งนี้นานแค่ไหน? หากรหัสผ่านของคุณสุ่มพอคุณคิดว่าวิธีการถอดรหัสนี้จะใช้งานได้หรือไม่ รหัสผ่านทั้งหมดในฐานข้อมูลของ Facebook, Google และ Amazon ถูกแฮชหรืออย่างน้อยพวกเขาก็ควรจะแฮช

จากนั้นก็มีการเข้ารหัส

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

การเข้ารหัสคีย์แบบสมมาตร

ฉันพยายามทำให้สิ่งต่าง ๆ เรียบง่ายที่สุดเท่าที่จะทำได้ ดังนั้นเรามาทำความเข้าใจการเข้ารหัสแบบสมมาตรด้วยอัลกอริทึมแบบกะ อัลกอริทึมนี้ใช้ในการเข้ารหัสตัวอักษรโดยการเลื่อนตัวอักษรไปทางซ้ายหรือขวา ลองรับสตริง CRYPTO แล้วพิจารณาตัวเลข +3 จากนั้นรูปแบบที่เข้ารหัสของ CRYPTO จะเป็น FUBSWR นั่นหมายความว่าจดหมายแต่ละฉบับจะถูกเลื่อนไปทางขวา 3 ตำแหน่ง ที่นี่คำว่า CRYPTO เรียกว่าPlaintextผลลัพธ์ของ FUBSWR เรียกว่าCiphertextค่า +3 เรียกว่าEncryption key (symmetric key) และกระบวนการทั้งหมดเป็นตัวเลข. นี่เป็นหนึ่งในอัลกอริทึมการเข้ารหัสคีย์สมมาตรขั้นพื้นฐานที่เก่าแก่ที่สุดและมีการรายงานการใช้งานครั้งแรกในช่วงเวลาที่ Julius Caesar ดังนั้นจึงได้รับการตั้งชื่อตามเขาและมันเป็นที่มีชื่อเสียงรหัสซีซาร์ ใครก็ตามที่รู้คีย์การเข้ารหัสและสามารถนำอัลกอริทึมกลับมาของ Caesar และดึง Plaintext ดั้งเดิมได้ ดังนั้นมันจะเรียกว่าการเข้ารหัสแบบสมมาตร

การเข้ารหัสคีย์แบบอสมมาตร

เรารู้ว่าในการเข้ารหัสแบบสมมาตรคีย์เดียวกันใช้สำหรับการเข้ารหัสและถอดรหัส เมื่อคีย์นั้นถูกขโมยข้อมูลทั้งหมดจะหายไป นั่นเป็นความเสี่ยงครั้งใหญ่และเราต้องการเทคนิคที่ซับซ้อนกว่านี้ ในปี 1976 Whitfield Diffie และมาร์ตินเฮลแมนตีพิมพ์ครั้งแรกแนวคิดของการเข้ารหัสแบบอสมมาตรและขั้นตอนวิธีการที่เป็นที่รู้จักในฐานะแลกเปลี่ยนคีย์ Diffie-Hellman จากนั้นในปี 1978 Ron Rivest, Adi Shamir และ Leonard Adleman จาก MIT ได้เผยแพร่อัลกอริทึมRSA สิ่งเหล่านี้ถือเป็นรากฐานของการเข้ารหัสแบบอสมมาตร

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

ที่มา: SSL / TLS สำหรับหุ่นตอนที่ 1: Ciphersuite, Hashing, Encryption | WST ( https://www.wst.space/ssl-part1-ciphersuite-hashing-encrypt/ )

การเข้ารหัสวัตถุประสงค์ของการเข้ารหัสคือการแปลงข้อมูลเพื่อเก็บเป็นความลับเช่น (ส่งข้อความลับเฉพาะบุคคลที่สามารถอ่านได้เท่านั้นโดยส่งรหัสผ่านทางอินเทอร์เน็ต)

แทนที่จะมุ่งเน้นไปที่การใช้งานเป้าหมายคือเพื่อให้แน่ใจว่าการส่งข้อมูลสามารถส่งอย่างลับ ๆ และสามารถเห็นได้โดยผู้ใช้ที่คุณส่งเท่านั้น

มันเข้ารหัสข้อมูลในรูปแบบอื่นของการแปลงเป็นรูปแบบที่ไม่ซ้ำกันซึ่งสามารถเข้ารหัสด้วยรหัสลับและผู้ใช้ที่มีรหัสลับสามารถดูข้อความโดยย้อนกลับกระบวนการ เช่น (AES ปักเป้า RSA)

การเข้ารหัสอาจดูเหมือนFhQp6U4N28GITVGjdt37hZNนี้

Hashingในทางเทคนิคเราสามารถพูดได้ว่ามันเป็นยิงใส่พลและผลิตสตริงความยาวคงที่

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

หากแฮชผิดและไม่ตรงกับแฮชเราจะไม่เห็นข้อมูลใด ๆ เช่น (MD5, SHA ..... )