3DES เป็นรหัสเข้ารหัสที่มาจากมาตรฐานการเข้ารหัสข้อมูลดั้งเดิม (DES) มันกลายเป็นที่โดดเด่นในช่วงปลายยุคเก้า แต่ได้หลุดพ้นจากความโปรดปรานเนื่องจากการเพิ่มขึ้นของอัลกอริทึมที่ปลอดภัยมากขึ้น.
แม้ว่าจะถูกยกเลิกในปี 2566 แต่ก็ยังคงมีการใช้งานในบางสถานการณ์ เนื่องจากขึ้นอยู่กับหนึ่งในอัลกอริทึมที่ได้รับการตีพิมพ์และศึกษาเป็นครั้งแรก DES ยังคงเป็นสิ่งสำคัญที่จะต้องเรียนรู้เกี่ยวกับ 3DES คืออะไรและทำงานอย่างไร.
คำแนะนำนี้จะนำคุณผ่านแต่ละขั้นตอนของกระบวนการ DES อย่างละเอียดจากนั้นครอบคลุมถึงการปรับเปลี่ยน DES ใน 3DES เพื่อให้ปลอดภัยมากขึ้น นอกจากนี้ยังสัมผัสกับปัญหาด้านความปลอดภัยต่าง ๆ และคุณควรใช้อัลกอริทึมหรือไม่.
3DES คืออะไร?
แม้ว่าจะเป็นที่รู้จักกันอย่างเป็นทางการว่าอัลกอริทึมการเข้ารหัสข้อมูลสามมิติ (3DEA) แต่โดยทั่วไปจะเรียกว่า 3DES นี่เป็นเพราะอัลกอริทึม 3DES ใช้การเข้ารหัสข้อมูลมาตรฐานการเข้ารหัส (DES) สามครั้งเพื่อเข้ารหัสข้อมูล.
DES เป็นอัลกอริทึมแบบ symmetric-key ที่ใช้เครือข่าย Feistel ในฐานะที่เป็นรหัสคีย์สมมาตรจะใช้คีย์เดียวกันสำหรับทั้งกระบวนการเข้ารหัสและถอดรหัส เครือข่าย Feistel ทำให้กระบวนการทั้งสองเกือบเหมือนกันซึ่งส่งผลให้เกิดอัลกอริทึมที่มีประสิทธิภาพในการใช้งานมากขึ้น.
DES มีทั้งบล็อก 64- บิตและขนาดของคีย์ แต่ในทางปฏิบัติกุญแจมีความปลอดภัย 56 บิตเท่านั้น 3DES ได้รับการพัฒนาให้เป็นทางเลือกที่ปลอดภัยยิ่งขึ้นเนื่องจาก DES มีความยาวคีย์น้อย ใน 3DES อัลกอริทึม DES จะทำงานถึงสามครั้งด้วยสามปุ่มอย่างไรก็ตามมันจะถือว่าปลอดภัยเมื่อใช้สามคีย์แยกเท่านั้น.
การใช้งานของ 3DES
เมื่อจุดอ่อนของ DES ปกติชัดเจนขึ้น 3DES ถูกนำไปใช้ในการใช้งานที่หลากหลาย มันเป็นหนึ่งในรูปแบบการเข้ารหัสที่ใช้กันมากขึ้นก่อนที่จะเพิ่มขึ้นของ AES.
ตัวอย่างของการใช้งานรวมถึง Microsoft Office, Firefox และระบบการชำระเงิน EMV หลายแพลตฟอร์มเหล่านี้ไม่ได้ใช้ 3DES อีกต่อไปเนื่องจากมีทางเลือกที่ดีกว่า.
สถาบันมาตรฐานและเทคโนโลยีแห่งชาติ (NIST) ได้ออกร่างข้อเสนอที่บอกว่า 3DES ทุกรูปแบบจะถูกคัดค้านจนถึงปี 2566 และไม่อนุญาตตั้งแต่ปี 2567 เป็นต้นไป แม้ว่ามันจะเป็นแค่ร่างข้อเสนอหมายถึงจุดสิ้นสุดของยุคและเป็นเวลาที่ผ่านไปแล้วที่จะก้าวไปสู่อัลกอริทึมที่ปลอดภัยกว่า.
ประวัติความเป็นมาของการเข้ารหัส 3DES
เนื่องจาก 3DES ได้มาจาก DES จึงเป็นการดีที่สุดที่จะแนะนำมาตรฐานก่อนหน้านี้ก่อน ในยุคที่เจ็ดสำนักมาตรฐานแห่งชาติ (NBS – มันได้ถูกเปลี่ยนชื่อเป็น NIST) กำลังค้นหาอัลกอริทึมที่สามารถใช้เป็นมาตรฐานสำหรับการเข้ารหัสข้อมูลรัฐบาลที่ละเอียดอ่อน แต่ยังไม่ได้รับการจำแนกประเภท.
NBS ยอมรับข้อเสนอสำหรับมาตรฐานที่เหมาะสมกับข้อกำหนด แต่ไม่มีผู้สมัครจากรอบแรกที่เหมาะสม มันเชิญการส่งมากขึ้นและคราวนี้ไอบีเอ็มส่งอัลกอริทึมที่ทีมพัฒนาขึ้นมา การส่งมาจากตัวเลข Lucifer ที่ Horst Feistel ออกแบบ.
ในปี 1975 อัลกอริทึมของ IBM ได้รับการเผยแพร่โดย NBS ในฐานะมาตรฐานการเข้ารหัสข้อมูลที่เสนอ ประชาชนได้รับเชิญให้แสดงความคิดเห็นในการออกแบบซึ่งดึงดูดการวิจารณ์.
cryptographers ที่มีชื่อเสียงเช่น Whitfield Diffie และ Martin Hellman ผู้ออกแบบการแลกเปลี่ยนคีย์ Diffie-Hellman อ้างว่าความยาวของคีย์สั้นเกินไปและเปลี่ยน S-box จากการออกแบบเบื้องต้น.
ในขณะนั้นหลายคนในชุมชนการเข้ารหัสลับคิดว่า NSA ได้ก่อวินาศกรรมโครงการและลดขั้นตอนวิธีเพื่อที่จะเป็นหน่วยงานเดียวที่สามารถทำลาย DES.
เมื่อสิ่งนี้ถูกตรวจสอบโดยคณะกรรมการคัดเลือกข่าวกรองของวุฒิสภาสหรัฐอเมริกาพบว่า“ NSA เชื่อว่า IBM มีขนาดคีย์ที่ลดลงเพียงพอ ช่วยทางอ้อมในการพัฒนาโครงสร้าง S-box; และรับรองว่าอัลกอริธึม DES สุดท้ายคือเพื่อความรู้ที่ดีที่สุดโดยปราศจากจุดอ่อนทางสถิติหรือทางคณิตศาสตร์ใด ๆ ”
รายงานเดียวกันกล่าวต่อไปว่า“ NSA ไม่ได้ยุ่งเกี่ยวกับการออกแบบในทางใดทางหนึ่ง” สิ่งนี้ได้รับการสำรองข้อมูลโดยเจ้าหน้าที่ของ IBM อดีตผู้อ้างว่าอัลกอริทึม DES ได้รับการออกแบบโดยทีมงาน IBM ทั้งหมด.
เอกสารที่ไม่เป็นความลับอีกต่อไปของ NSA อ้างว่าเอเจนซี่“ ทำงานอย่างใกล้ชิดกับ IBM เพื่อเสริมสร้างอัลกอริทึมให้กับทุกคนยกเว้นการโจมตีที่โหดเหี้ยม
ความสงสัยของการแก้ไขดัดแปลง NSA ถูกปลดเปลื้องในเก้าสิบครั้งเมื่อการเข้ารหัสที่แตกต่างกันถูกค้นพบในที่สาธารณะ เมื่อ S-box ที่มีความร้ายกาจมากถูกทดสอบด้วยเทคนิคใหม่พวกเขาจะพบว่ามีความต้านทานต่อการโจมตีได้ดีกว่าถ้าพวกเขาถูกสุ่มเลือก.
สิ่งนี้บ่งชี้ว่าทีม IBM ได้ทราบแล้วเกี่ยวกับการเข้ารหัสที่แตกต่างกันในช่วงอายุเจ็ดสิบโดยสตีเวนเลวี่อ้างว่า NSA ขอให้พวกเขาเก็บความลับของเทคนิคเพื่อปกป้องความมั่นคงของชาติ.
ผู้เขียนรหัสที่มีชื่อเสียง Bruce Schneier เคยกล่าวขานว่า“ มันต้องใช้เวลาสองทศวรรษในวงการวิชาการเพื่อค้นหาว่า NSA ‘tweaks’ ได้ปรับปรุงความปลอดภัยของ DES จริงๆ “
แม้จะมีคำถามเบื้องต้นเกี่ยวกับความปลอดภัยของอัลกอริทึมและการมีส่วนร่วมของ NSA แต่อัลกอริทึมของ IBM ยังได้รับการอนุมัติให้เป็นมาตรฐานการเข้ารหัสข้อมูลในปี 1976 มันถูกเผยแพร่ในปี 1977 และยืนยันอีกครั้งว่าเป็นมาตรฐานในปี 1983, 1988 และ 1993.
เมื่อการเข้ารหัสเชิงเส้นถูกเผยแพร่ครั้งแรกในปี 1994 มันเริ่มตั้งคำถามเกี่ยวกับความปลอดภัยของอัลกอริทึม ในปี 1997 NIST ประกาศว่ากำลังมองหาอัลกอริทึมเพื่อแทนที่ DES ความต้องการอัลกอริทึมใหม่นั้นทวีความรุนแรงมากขึ้นเมื่อเทคโนโลยีพัฒนาขึ้นและการโจมตีที่อาจเกิดขึ้นก็เริ่มแข็งแกร่งขึ้น.
ความพยายามในการแคร็กหลายครั้งแสดงให้เห็นว่าเป็นการยากที่จะทำลายอัลกอริทึมน้อยกว่าที่คิดไว้ก่อนหน้านี้ ในปี 1998 distribution.net สามารถถอดรหัส DES ได้ 39 วัน.
เมื่อต้นปี 1999 Deep Crack Foundation ของ Electronic Frontier Foundation ได้ใช้เวลาลดลงเหลือน้อยกว่า 22 ชั่วโมง นี่เป็นสัญญาณบ่งบอกถึงจุดจบของ DES เนื่องจากการโจมตีของลักษณะนี้ตอนนี้อยู่ในอุ้งมือของฝ่ายตรงข้ามที่มีทรัพยากรสูง.
ปัญหาหลักคือพื้นที่คีย์ขนาดเล็กและอัลกอริทึมใหม่จำเป็นอย่างมาก นี่เป็นปัญหาเนื่องจากใช้เวลาหลายปีกว่าที่ NIST จะชำระราคาอัลกอริทึมซึ่งกลายเป็นมาตรฐานการแทนที่มาตรฐานการเข้ารหัสขั้นสูง (AES).
ในขณะที่การตัดสินใจเลือกรหัสสำหรับ AES นั้น 3DES ได้รับการเสนอให้เป็นมาตรการชั่วคราว มันเกี่ยวข้องกับการเรียกใช้อัลกอริทึม DES สามครั้งโดยมีสามปุ่มแยกกัน ในปี 1999 DES ได้รับการยืนยันอีกครั้ง แต่ด้วย 3DES เป็นอัลกอริทึมในอุดมคติ DES ปกติได้รับอนุญาตเฉพาะในแอปพลิเคชันดั้งเดิมเท่านั้น.
3DES กลายเป็นอัลกอริธึมการเข้ารหัสอย่างกว้างขวางถึงแม้ว่าการใช้ทรัพยากรและข้อ จำกัด ด้านความปลอดภัยจำนวนมากทำให้ AES ถูกแทนที่ด้วย AES ในกรณีการใช้งานส่วนใหญ่.
ทำความเข้าใจเกี่ยวกับอัลกอริทึม DES
ก่อนที่เราจะพูดคุยเกี่ยวกับรายละเอียดของ 3DES สิ่งสำคัญคือต้องเข้าใจอัลกอริทึม DES ที่ได้มาจาก ดังนั้นเริ่มต้นได้ตั้งแต่ต้น.
เราใช้การเข้ารหัสเพื่อเปลี่ยนข้อมูลธรรมดาของเราให้เป็นไซเฟอร์เท็กซ์ซึ่งเป็นข้อมูลที่ผู้โจมตีไม่สามารถเข้าถึงได้ (ตราบใดที่เราใช้อัลกอริทึมที่เหมาะสม).
อัลกอริทึมการเข้ารหัสเป็นสูตรทางคณิตศาสตร์ที่ซับซ้อนเป็นหลัก เมื่อพูดถึงการเข้ารหัสบางอย่างเช่น “ไปที่ชายหาด” หลายคนสับสน ท้ายที่สุดคุณสามารถใช้คณิตศาสตร์กับสิ่งต่าง ๆ เช่นตัวอักษรและอักขระได้อย่างไร?
การเข้ารหัสข้อความ
ความจริงคือคอมพิวเตอร์ไม่ได้ใช้ตัวอักษรและตัวอักษร พวกมันทำงานบนระบบ 1s และ 0s ที่รู้จักกันในชื่อ binary 1 หรือ 0 แต่ละตัวรู้จักกันในชื่อบิตและมีแปดกลุ่มที่รู้จักกันในชื่อไบต์.
คุณสามารถค้นหาด้วยตนเองหรือใช้เครื่องมือแปลงออนไลน์เพื่อดูว่าในรูปแบบไบนารี“ มาที่ชายหาด” จะกลายเป็น:
01001100 01100101 01110100 00100111 01110011 00100000 01100111 01101111 00100000 01110100 01101111 00100000 01110100 01101000 01100101 011000101 0110001 01100011 0110001 0110001 0110001
บล็อก
เมื่อข้อมูลถูกเข้ารหัสมันจะถูกแบ่งออกเป็นบล็อกย่อยเพื่อการประมวลผล DES มีขนาดบล็อก 64- บิตซึ่งหมายความว่าแต่ละบล็อกมีการรวมกันของ 64 และศูนย์ บล็อกแรกของเรา (ตัวเลข 64 ตัวแรกของไบนารีที่แสดงด้านบน) จะเป็น:
01001100 01100101 01110100 00100111 01110011 00100000 01100111 01101111
ที่สองของเราจะเป็น:
00100000 01110100 01101111 00100000 01110100 01101000 01100101 00100000
และบล็อกสุดท้ายของเราก็คือ:
01100010 01100101 01100001 01100011 01101000
การขยายความ
คุณอาจสังเกตเห็นว่าบล็อกที่สามของเรามีความยาวเพียง 40 บิต ก่อนที่จะสามารถเข้ารหัสได้จะต้องสร้างขนาดบล็อก 64 บิต สิ่งนี้ทำได้ด้วย การขยายความ, ซึ่งเกี่ยวข้องกับการเพิ่มข้อมูลพิเศษลงในบล็อกเพื่อทำให้เสร็จสมบูรณ์ สิ่งนี้สามารถทำได้ด้วยรูปแบบที่แตกต่างกันจำนวนมากและยังสามารถให้บริการในการเข้ารหัสข้อมูลที่ยากต่อการถอดรหัส แต่เราจะไม่เข้าใจในบทความนี้.
กำหนดการคีย์ DES
อัลกอริทึมการเข้ารหัสใช้คีย์เพื่อเพิ่มข้อมูลที่จะเปลี่ยนผลลัพธ์สุดท้ายของกระบวนการ หาก DES เกี่ยวข้องกับขั้นตอนเช่นการเปลี่ยนรูปและ S-box เท่านั้น (อธิบายการเปลี่ยนรูปด้านล่างในขณะที่ S-boxes ครอบคลุมใน การแทน ส่วน) สิ่งที่ผู้โจมตีต้องทำคือเปิดเผยรายละเอียดของอัลกอริทึมจากนั้นทำแต่ละขั้นตอนในสิ่งที่ตรงกันข้ามเพื่อเปิดเผยข้อความเริ่มต้น.
เนื่องจากอัลกอริธึมส่วนใหญ่ของเราเป็นที่รู้จักอย่างกว้างขวางสิ่งนี้จะไม่เพิ่มความปลอดภัยมากนัก แต่จะมีการเพิ่มรหัสลับเพื่อเปลี่ยนเอาต์พุตในวิธีที่ไม่สามารถคาดการณ์ได้เพียงแค่รู้อัลกอริทึม (ตราบเท่าที่ใช้อัลกอริทึมที่ซับซ้อนเพียงพอ).
DES เริ่มต้นด้วยคีย์เดียวซึ่งใช้เพื่อสร้างคีย์ย่อยที่ใช้ในแต่ละรอบ นี่คือคีย์ 64 บิตซึ่งมีขนาดเท่ากับบล็อกของเรา สมมติว่ากุญแจของเราคือ:
01001010 10101101 11101000 10100101 01110001 01010100 10101001 11111010
ตอนนี้คีย์นี้เป็นเลขฐานสองซึ่งเป็นวิธีการแสดงข้อมูลเมื่อคอมพิวเตอร์ประมวลผล เมื่อมนุษย์จัดการกับกุญแจพวกเขาจะปรากฏเป็นตัวละครผสมกันดังนี้:
kj329nf982bc9wn1
ใน DES ขั้นตอนแรกของการรับคีย์กลมของเราคือการเปลี่ยนคีย์ (เลื่อนไปรอบ ๆ ) ตามตารางต่อไปนี้:
ในการเรียงสับเปลี่ยนคีย์ดั้งเดิมของเราแต่ละบิตจะถูกสับเปลี่ยนไปยังตำแหน่งใหม่ตามที่ระบุไว้ในตาราง เนื่องจากเซลล์ที่มุมบนซ้าย (ของ C) พูดว่า 57, หมายเลขแรกของคีย์ที่อนุญาตของเราจะเป็นหมายเลขที่อยู่ในตำแหน่งที่ 57 ของบล็อกเก่าของเรา:
01001010 10101101 11101000 10100101 01110001 01010100 10101001 11111010
เซลล์ที่สองพูดว่า 49, ซึ่งหมายความว่าตัวเลขที่สองของคีย์ใหม่ของเราจะเป็นตัวเลขที่อยู่ในตำแหน่งที่ 49 ของบล็อกเก่าของเรา:
01001010 10101101 11101000 10100101 01110001 01010100 10101001 1111010
เซลล์ที่สามพูดว่า 41, ดังนั้นเราจึงมองหาตัวเลขที่ตำแหน่งที่ 41:
01001010 10101101 11101000 10100101 01110001 01010100 10101001 1111010
จนถึงตอนนี้กุญแจของเราประกอบด้วย“110”.
ส่วนที่เหลือของคีย์จะถูกจัดเรียงในลักษณะเดียวกันตามค่าของตาราง เราย้ายจากซ้ายไปขวาและเมื่อเราไปถึงจุดสิ้นสุดของแถวเรากระโดดลงไปที่ถัดไปเหมือนปกติ ครั้งหนึ่ง ตาราง C เสร็จสิ้นแล้วเราข้ามไปที่ ตาราง D เพื่อทำให้ช่วงครึ่งหลังของคีย์เสร็จสมบูรณ์.
ไม่มีวิธีง่ายๆในการแปลงบล็อกทั้งหมดของเราตามตารางการเปลี่ยนแปลงเริ่มต้น คุณสามารถทำสิ่งทั้งหมดด้วยตนเองหรือเขียนสคริปต์ให้มัน (หรือแม้กระทั่งโชคดีและค้นหาหนึ่งในส่วนลึกของอินเทอร์เน็ต) แต่เราจะโกงและสร้างมันขึ้นมา:
1100010 1010010 1010101 0101010 1010000 1111001 0001011 1,000111
คุณอาจกังวลว่าเรากำลังสร้างตัวเลขบางส่วนในคู่มือนี้ แต่ความจริงก็คือมันไม่สำคัญ ไม่มีใครเข้ารหัสข้อมูลด้วยตนเองอีกต่อไปทุกอย่างทำผ่านโปรแกรม สิ่งที่สำคัญที่สุดของบทช่วยสอนนี้คือคุณได้รับแนวคิดที่ชัดเจนเกี่ยวกับแนวคิดที่เรากำลังเผชิญอยู่ ตัวเลขเหล่านั้นใช้เพื่อช่วยให้คุณเห็นภาพว่าเกิดอะไรขึ้น.
ผู้อ่านบางคนอาจสังเกตเห็นว่าตาราง (และตอนนี้กุญแจของเรา) มีเพียง 56 บิตมากกว่า 64 นี่เป็นเพราะทุก ๆ 8 บิตถูกข้ามไป นี่เป็นสิ่งประดิษฐ์จากเทคโนโลยีที่เก่ากว่าเมื่อจำเป็นต้องมีบิตตรวจสอบพาริตี้ซึ่งตรวจสอบว่าได้รับคีย์อย่างถูกต้องหรือไม่ บิตการตรวจสอบพาริตีเหล่านี้หมายความว่าในทางปฏิบัติ DES มีความปลอดภัยของคีย์ 56 บิตเท่านั้น.
ตาราง C และ D ให้รหัสที่มีครึ่ง 28- บิตสองส่วน บางครั้งแบ่งเท่า ๆ กันเรียกว่า C และ D แต่ในบทความนี้เราจะเรียกพวกเขาว่า L และ R สำหรับซ้ายและขวา ด้านซ้ายของเราคือ:
1100010 1010010 1010101 0101010
ในขณะที่สิทธิของเราคือ:
1010000 1111001 0001011 1,000111
ขั้นตอนต่อไปคือการเลื่อนคีย์โดยเว้นวรรคหนึ่งหรือสองช่องทางซ้ายขึ้นอยู่กับรอบ จำนวนช่องว่างที่แน่นอนจะตัดสินใจตามตารางที่กำหนดไว้ต่อไปนี้:
| 1 | 1 |
| 2 | 1 |
| 3 | 2 |
| 4 | 2 |
| 5 | 2 |
| 6 | 2 |
| 7 | 2 |
| 8 | 2 |
| 9 | 1 |
| 10 | 2 |
| 11 | 2 |
| 12 | 2 |
| 13 | 2 |
| 14 | 2 |
| 15 | 2 |
| 16 | 1 |
ดังนั้นขอแบ่งครึ่งซ้ายและขวาของเรา:
L 1010010 1010010 1010101 0101010
R 1010000 1111001 0001011 1000111
และเลื่อนทั้งสองตำแหน่งหนึ่งไปทางซ้ายเนื่องจากรอบแรกมีการเปลี่ยนแปลง 1 ตามตาราง (หมายเลขทางด้านซ้ายจะถูกย้ายไปทางด้านขวา).
คีย์ย่อยรอบแรก:
L 0100101 0100101 0101010 1010101
R 0100001 1110010 0010111 0001111
ในรอบที่สองโต๊ะก็พูดเช่นกัน 1, ดังนั้นผลลัพธ์นี้จะถูกเปลี่ยนแปลงอีกครั้งโดยเลื่อนตำแหน่งหมายเลขหนึ่งไปทางซ้ายแต่ละตำแหน่ง.
รอบที่สอง คีย์ย่อย:
L 1001010 1001010 1010101 0101010
R 1000011 1100100 0101110 0011110
ในรอบที่สามตัวเลขจะถูกย้ายไปสองที่ทางซ้ายเนื่องจากตารางตอนนี้พูดว่า 2.
คีย์ย่อยของรอบที่สาม:
L 0101010 0101010 1010101 0101010
R 0001111 0010001 0111000 1111010
ในรอบต่อมาตัวเลขจะถูกย้ายไปทางซ้ายตามระยะทางที่ระบุในตารางโดยการเลื่อนแต่ละครั้งจะถูกนำไปใช้กับผลลัพธ์ของรอบก่อนหน้า ในท้ายที่สุดสิ่งนี้ทำให้เรามีคีย์ย่อยที่แตกต่างกันสิบหกอันหนึ่งอันสำหรับแต่ละรอบของกระบวนการ DES.
ขั้นตอนต่อไปคือการเปลี่ยนรูปแบบอื่นตามตาราง PC2 ที่แสดงด้านล่าง:
ถึงตอนนี้คุณควรคุ้นเคยกับวิธีเรียงสับเปลี่ยนดังนั้นเราจะไม่เข้าสู่กระบวนการเชิงลึก หากคุณต้องการดูรายละเอียดการทำงานให้ดูคำอธิบายที่อยู่ใกล้กับส่วนเริ่มต้นของส่วนนี้ แม้ว่าตำแหน่งการย้ายจะแตกต่างกัน แต่กระบวนการก็เหมือนกัน.
แต่ละคีย์ 16 อันที่ได้จากกระบวนการเปลี่ยนจะถูกสับตามตารางโดยที่หมายเลขจากตำแหน่งที่ 14 ถูกย้ายไปยังตำแหน่งแรกอันดับที่ 17 ถึงที่สองที่ 11 ถึงที่สาม ฯลฯ..
หากคุณดูตารางอย่างใกล้ชิดคุณจะสังเกตเห็นว่ามีเพียง 48 บิตแทนที่จะเป็น 56 บิตที่เราเคยมีก่อนหน้านี้ กระบวนการนี้เรียกว่าการเปลี่ยนแปลงการบีบอัด.
คุณจะเห็นได้ว่าครึ่งบนของตารางแสดงตัวเลขระหว่างหนึ่งถึง 28 ในขณะที่ครึ่งล่างมีตัวเลขจาก 29 ถึง 56 สิ่งนี้จะทำให้ครึ่งซ้ายและครึ่งขวาของคีย์ย่อยของเราแยกจากกัน ตรงกลางของกุญแจ.
อีกครั้งเราจะโกงและคิดเลข สมมติว่ากระบวนการทั้งหมดนี้ทำให้เรามีคีย์ย่อยดังต่อไปนี้:
รอบที่หนึ่ง: 010101 010101 101010 110100 101001 100101 101010 101010
รอบสอง: 011010 110101 101110 110010 010100 110010 111101 101101
รอบสาม: 010100 100110 110110 101010 100110 011000 101011 011001
รอบสี่: 011001 110101 011001 110101 000011 001011 010101 010101
รอบที่ห้า: 110101 001101 010101 010101 010011 001011 010111 100101
รอบที่หก: 010111 110101 011001 111001 101001 100101 101010 101010
รอบเจ็ด: 110101 111010 101110 101010 100110 010110 111011 001110
รอบแปด: 011001 110101 010101 001001 010011 001011 010100 101010
รอบเก้า: 111011 011010 011110 100010 100010 010110 110011 110010
รอบ 10: 011010 010101 101110 101001 010010 010110 111000 101010
รอบ 11: 110101 001101 101110 101010 100101 100101 101010 001010
รอบ 12: 101001 100100 101001 101010 100110 011000 101011 011001
รอบที่ 13: 010010 010010 010101 010101 010110 110001 100101 101010
รอบที่ 14: 101001 100110 010101 011101 010001 001010 110010 111110
รอบ 15: 011001 011010 011001 110101 001001 011001 100101 101101
รอบ 16: 010010 100110 010101 010101 010001 101000 110010 111010
กระบวนการขยับนี้ส่งผลให้แต่ละบิตจากคีย์เริ่มต้นที่ใช้ในคีย์ย่อยประมาณ 14 จาก 16 คีย์แม้ว่าบางบิตจะใช้มากกว่าคนอื่นเล็กน้อย.
การเปลี่ยนแปลงครั้งแรก
เมื่อข้อมูลถูกแบ่งออกเป็นบล็อกและเบาะถ้าจำเป็นก็ถึงเวลาที่จะเริ่มกระบวนการเข้ารหัส DES เราจะกลับไปที่คีย์ย่อยที่เราเพิ่งสร้างในภายหลัง ขั้นตอนแรกเรียกว่าการเปลี่ยนแปลงเริ่มต้นโดยที่ข้อมูลจะถูกจัดเรียงใหม่ตามตารางต่อไปนี้:
กระบวนการเปลี่ยนรูปเริ่มต้นนี้จะไม่ทำให้อัลกอริทึมปลอดภัยยิ่งขึ้น นี่เป็นเพราะมันไม่ได้เกี่ยวข้องกับการป้อนข้อมูลของคีย์ใด ๆ และสามารถย้อนกลับได้ง่าย เดิมอัลกอริทึมได้รับการออกแบบด้วยวิธีนี้เพราะทำให้การใช้งานง่ายขึ้นในบางบริบท.
เนื่องจากเราครอบคลุมการเรียงสับเปลี่ยนสองสามครั้งเราจะข้ามคำอธิบายที่สำคัญที่นี่ มุ่งหน้ากลับไปที่ กำหนดการคีย์ DES หากคุณต้องการข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงาน.
มาลองบล็อกแรกจากข้อความ“ ไปที่ชายหาด” ซึ่งเราได้มาใน บล็อก ภายใต้ ทำความเข้าใจเกี่ยวกับอัลกอริทึม DES:
01001100 01100101 01110100 00100111 01110011 00100000 01100111 01101111
ตั้งแต่เซลล์แรกบอกว่า 58, เราจะเลือกหมายเลขจากตำแหน่งที่ 58:
01001100 01100101 01110100 00100111 01110011 00100000 01100111 01101111
จากนั้นเราจะนำหมายเลขจากตำแหน่งที่ 50:
01001100 01100101 01110100 00100111 01110011 00100000 01100111 01101111
และจำนวนจากตำแหน่งที่ 42:
01001100 01100101 01110100 00100111 01110011 00100000 01100111 01101111
สิ่งนี้ทำให้เรา“110จนถึงตอนนี้ เราจะทำส่วนที่เหลือให้:
11010111 01001010 10101000 10011101 01001011 10110101 10000111 10101001
เมื่อการเปลี่ยนแปลงเริ่มต้นเสร็จสมบูรณ์ข้อมูลจะถูกย้ายไปยังขั้นตอนถัดไป.
แยกบล็อก
เมื่อข้อมูลได้รับการเปลี่ยนแปลงครั้งแรกข้อมูลจะถูกแบ่งออกเป็นสองส่วน เรานำบล็อกของเราที่เพิ่งได้รับการเปลี่ยนแปลงครั้งแรก:
11010111 01001010 10101000 10011101 01001011 10110101 10000111 10101001
และเราจะแยกมันออกเป็นสองบล็อกคือบล็อกซ้าย (ประกอบด้วยตัวเลข 32 หลักแรก) หรือที่เรียกว่า L0:
L0 11010111 01001010 10101000 10011101
และบล็อกขวา (ประกอบด้วย 32 หลักที่สอง) รู้จักกันในชื่อ R0:
R0 01001011 10110101 10,000111 10101001
ฟังก์ชั่น F
เมื่อบล็อกถูกแบ่งแล้วก็ถึงเวลาที่ฟังก์ชั่น F จะเกิดขึ้น ในรอบแรกมันจะถูกนำไปใช้กับครึ่งขวาของบล็อกในขณะที่ครึ่งซ้ายจะถูกเก็บไว้จนกว่าจะถึงในภายหลัง ด้านขวาผ่านสี่ขั้นตอนต่อไปนี้ซึ่งเป็นส่วนหนึ่งของฟังก์ชัน F:
- การเปลี่ยนแปลงการขยายตัว (E ในแผนภาพ)
- การผสมคีย์ (⊕ในแผนภาพ)
- การทดแทน (แต่ละ S1, S2 ฯลฯ ในแผนภาพ)
- การเปลี่ยนแปลง (P ในแผนภาพ)
การเปลี่ยนแปลงการขยายตัว
การเปลี่ยนแปลงการขยายตัวทำได้สามสิ่ง ที่สำคัญที่สุดคืออนุญาตให้บิตข้อมูลอินพุตเดี่ยวมีผลต่อเอาต์พุตของอีกสองบิตทำให้เกิดปรากฏการณ์หิมะถล่ม นอกจากนี้ยังสร้างครึ่งขวา 48 บิตเพื่อให้มีขนาดเดียวกับคีย์ย่อยสำหรับขั้นตอนถัดไป ผลกระทบอื่น ๆ ของการเปลี่ยนแปลงการขยายตัวคือมันทำให้เอาต์พุตยาวกว่าอินพุต สิ่งนี้ทำให้มันถูกบีบอัดในการดำเนินการทดแทน.
บิตถูกจัดเรียงใหม่ตามตารางต่อไปนี้ บิตแต่ละบิตบางตัวอยู่ในตารางสองครั้งซึ่งเป็นวิธีที่บล็อกขยายจาก 32 ถึง 48 บิต:
ตั้งแต่เซลล์แรกบอกว่า 32 เราใช้บล็อกขวาของเราและเลือกหมายเลขจากตำแหน่งที่ 32 เหมือนกับที่เราทำในตัวอย่างการเปลี่ยนแปลงอื่น ๆ ที่กล่าวข้างต้น:
R0 01001011 10110101 10,000111 10101001
จากนั้นเราจะนำตัวเลขจากตำแหน่งแรกตำแหน่งที่สองและต่อไปเรื่อย ๆ จนกระทั่งเราไปถึงมุมล่างขวาของบล็อก เนื่องจากมี 1 ในเซลล์นี้ตัวเลขสุดท้ายจะเป็นตัวเลขที่ปรากฏในตำแหน่งแรกของบล็อกของเรา.
สมมติว่าการเปลี่ยนแปลงการขยายตัวทำให้เรามีบล็อก 48- บิตใหม่ของ:
101110 100110 100100 000000 001100 001110 101101 011110
การผสมที่สำคัญ
เมื่อบล็อกถูกขยายเป็น 48 บิตถึงเวลาที่จะใช้คีย์ย่อยของรอบแรกซึ่งเราได้รับมาใน DES กำหนดเวลาที่สำคัญ ส่วนด้านบน บล็อกถูกปรับเปลี่ยนโดยคีย์ย่อยโดยใช้รหัส XOR.
รหัส XOR เป็นรหัสเพิ่มเติมที่ตามกระบวนการง่าย ๆ โดยเฉพาะเมื่อเปรียบเทียบกับองค์ประกอบอื่น ๆ ที่เราได้กล่าวถึงไปแล้ว.
ในศูนย์ XOR:
0 + 0 = 0
1 + 0 = 1
1 + 1 = 0
ดังนั้นสมมุติว่าคุณต้อง XOR ตัวเลขสองตัวต่อไปนี้เป็นเลขฐานสอง:
1101
0101
แต่ละหลักจะถูกเพิ่มเข้าไปในตัวเลขที่อยู่ด้านล่าง ตามกฎทั้งสามข้อที่แสดงด้านบนสิ่งนี้ให้ผลลัพธ์ของ:
1000
เพื่อให้ขั้นตอนการผสมกุญแจเสร็จสมบูรณ์เราจะใช้ด้านขวาของบล็อกที่เราเพิ่งขยายเป็น 48 บิตและแป้นกลมแรก จากนั้นเราจะทำการเพิ่ม XOR:
บล็อก: 101110 100110 100100 000000 001100 001110 101101 011110
รอบหนึ่งที่สำคัญ: 010101 010101 101010 110100 101001 100101 101010 101010
ผลลัพธ์ XOR: 111011 110011 001110 110100 100101 101011 000111 110100
ผลลัพธ์ของการดำเนินการ XOR จะถูกส่งต่อไปยังรอบถัดไป.
การแทน
การทดแทนเพิ่มความสับสนให้กับข้อมูล โดยปกติแล้วจะทำกับตารางการค้นหาซึ่งรู้จักกันในชื่อกล่องทดแทนหรือกล่องเอส DES ใช้แปดตารางที่แยกจากกันหรือ S-box ซึ่งเป็นตารางที่แตกต่างกันสำหรับแต่ละ 6 บิตของข้อมูล ตารางต่อไปนี้แสดงแปด S-boxes ของ DES:
S-box แปดตัวที่แยกออกมานั้นใช้เพื่อแปลอินพุต 6 บิตแต่ละรายการเป็นเอาต์พุต 4 บิต ขั้นตอนแรกในกระบวนการคือการใช้ตัวเลขที่จุดเริ่มต้นและจุดสิ้นสุดของส่วน 6 บิตจากนั้นแปลงค่าไบนารีนั้นเป็นทศนิยม.
มาดูข้อมูลที่เราเพิ่งทำ XORing ในขั้นตอนก่อนหน้านี้:
111011 110011 001110 110100 100101 101011 000111 110100
เราจะดูส่วน 6 บิตแรกเพื่อแสดงให้คุณเห็นว่ากระบวนการทดแทนทำงานอย่างไร:
111011
ตั้งแต่หมายเลขแรกและหมายเลขสุดท้ายมีทั้ง 1, สิ่งนี้ให้คุณค่าแก่เรา 11. จากนั้นเราจะแปลง 11 จากไบนารีเป็นทศนิยมซึ่งให้เรา 3. เหล่านี้เป็นเพียงค่าที่เทียบเท่าเขียนในรูปแบบที่แตกต่างกัน คิดว่าเป็นการแปลงภาษาคอมพิวเตอร์เป็นภาษามนุษย์ คุณสามารถตรวจสอบการแปลงด้วยตัวคุณเองด้วยเครื่องคิดเลขออนไลน์หากคุณต้องการ.
จากนั้นเราจะนำตัวเลขกลางสี่ตัวของส่วน 6 บิตแรก:
111011
และแปลงจากเลขฐานสองเป็นทศนิยม. 1101 แปลเป็นหมายเลข 13.
ตอนนี้เราเอาตัวเลขสองตัวนี้แล้วค้นหาใน S1 โต๊ะ:
หมายเลขแรกของเรา, 3, บอกให้เราดูในแถวที่สามในขณะที่หมายเลขที่สองของเรา, 13 บอกให้เราดูในคอลัมน์ที่ 13 ค่าในแถวที่สามของคอลัมน์ที่ 13 คือ 0.
ตอนนี้เราได้ค้นหาหมายเลขของเราในตารางแล้วเราแปลงกลับเป็นเลขฐานสองสี่หลัก โดยปกติแล้ว Zero จะเขียนเป็น 0 ในไบนารี แต่ 0000 เหมือนกันและนี่คือรูปแบบที่เหมาะสมที่สุดสำหรับวัตถุประสงค์ของเรา.
ทำตามกระบวนการนี้ S-box จะแปลงข้อมูล 6 บิตแรกของเรา (111011) เป็นค่า 4 บิตอื่น (0000) ดูเหมือนว่าซับซ้อน แต่เทคนิคนี้ช่วยในการปิดบังความสัมพันธ์ระหว่างไซเฟอร์เท็กซ์และข้อความธรรมดาที่เชื่อมโยงกับ.
ส่วนข้อมูล 6 บิตถัดไปจะผ่านกระบวนการเดียวกัน แต่จะใช้ช่อง S2 ที่แสดงด้านบนแทน ส่วนที่สามใช้ตาราง S3 และต่อ ๆ ไปจนกระทั่งส่วนสุดท้ายผ่านการทดแทนผ่านตาราง S8.
อีกครั้งเราจะโกงค่าที่เหลือ สมมติว่ากล่องทดแทนให้ผลดังนี้:
0000 1010 1100 1001 0100 1001 0111 0001
เมื่อแต่ละส่วนของข้อมูลผ่าน S-box แล้วมันจะไปสู่ขั้นตอนต่อไป.
การเปลี่ยนแปลง
ขั้นตอนสุดท้ายของฟังก์ชัน F คือการเปลี่ยนรูปแบบอื่นโดยใช้ตารางต่อไปนี้:
ถึงตอนนี้คุณควรมีความเข้าใจที่ดีว่าการเรียงสับเปลี่ยนเปลี่ยนจากบล็อกเก่าไปยังตำแหน่งที่แตกต่างในบล็อกใหม่ดังนั้นเราจะไม่เข้าไปอีก.
สมมติว่าการเปลี่ยนรูปนี้ใช้ผลลัพธ์ก่อนหน้าของเรา:
0000 1010 1100 1001 0100 1001 0111 0001
และให้ผลลัพธ์ของ:
0101 0110 1001 0101 0010 0100 0101 0010
เมื่อการเปลี่ยนแปลงเสร็จสมบูรณ์เราได้เสร็จสิ้นด้วยสี่ขั้นตอนของฟังก์ชัน F ในรอบนี้ ในสัญกรณ์ทางคณิตศาสตร์ค่านี้เรียกว่า f (R0, K1). ซึ่งหมายความว่าผลลัพธ์คือฟังก์ชัน (ฉ) ทางด้านขวาเริ่มต้นของบล็อก (R0) และคีย์ย่อยของรอบแรก (K1).
แฮคเกอร์พร้อมบล็อคซ้าย
จำได้ไหมว่าเราแบ่งบล็อกออกเป็นครึ่งก่อนที่เราจะเริ่มขั้นตอนของฟังก์ชั่น F เราตั้งค่าด้านซ้ายของบล็อก (L0) ในขณะที่ด้านขวาเปลี่ยนไปแต่ละกระบวนการเหล่านี้ ทีนี้ถึงเวลาแล้วที่ L0 จะกลับมาดำเนินการอีกครั้ง.
เราใช้ด้านขวาที่เราเพิ่งดำเนินการ f (R0, K1) และเพิ่มลงในด้านซ้ายเก่า (L0) ใช้รหัสศูนย์ XOR สิ่งนี้ทำให้เรา R1, ผลการแข่งขันรอบแรก:
f (R0, K1): 0101 0110 1001 0101 0010 0100 0101 0010
L0: 1101 0111 0100 1010 1010 1,000 1001 1101
ผลลัพธ์ XOR (R1): 1,000 0001 1101 1111 1,000 1100 1100 1111
อ้างถึง การผสมที่สำคัญ ส่วนด้านบนหากคุณต้องการเตือนว่าการเข้ารหัสของแฮคเกอร์ทำงานอย่างไร.
อีก 15 รอบ …
หากคุณได้มาถึงตอนนี้แล้ว DES อาจดูเหมือนว่าเป็นกระบวนการที่ลำบาก แต่ยังไม่ใกล้ที่จะเสร็จสมบูรณ์ ข้อมูลไปถึงสี่ขั้นตอนของฟังก์ชั่น F แล้วตามด้วย XOR อีก 15 ครั้งรวมเป็น 16 รอบ.
ในรอบที่สองเราใช้เวอร์ชั่นดั้งเดิมที่ไม่มีการแตะต้องของด้านขวาของบล็อก (R0) และทำให้มันเป็นด้านซ้ายใหม่ (L1) ในขณะเดียวกันเรารับผลรอบแรกและส่งผ่านฟังก์ชั่น F ทุกอย่างเกิดขึ้นเหมือนกับครั้งที่แล้วอย่างไรก็ตามครั้งนี้ใช้คีย์ย่อยสำหรับรอบสองแทน สมมติว่ากระบวนการนี้ให้ผลลัพธ์แก่เราดังนี้:
f (R1, K2): 1011 0111 1,000 1011 1001 1101 1001 1110
จากนั้นเราก็ XOR ผลลัพธ์ด้วย L1 ซึ่งจริงๆแล้ว R0 (เราได้มาใน แยกบล็อก มาตรา). สิ่งนี้ทำให้เราได้ผลลัพธ์ของรอบที่สอง R2:
f (R1, K2): 1011 0111 1,000 1011 1001 1101 1001 1110
L1: 0100 1011 1011 0101 1,000 0111 1010 1001
R2: 1111 1100 0011 1110 0001 1010 0011 0111
ขั้นตอนนี้อาจดูสับสนเล็กน้อย แต่ภายใต้โครงการ Feistel ด้านขวาเก่าจะกลายเป็นซ้ายใหม่ในขณะที่ผลลัพธ์ของการดำเนินการกลายเป็นด้านขวาใหม่.
แผนภาพต่อไปนี้แสดงภาพสิ่งที่เกิดขึ้นให้คุณเห็น IP แสดงให้เห็นถึงการเปลี่ยนแปลงเริ่มต้น F คือการเข้าสู่ฟังก์ชั่น F ทั้งหมด, ⊕เป็นสัญลักษณ์ของฟังก์ชั่น XOR และลูกศรแสดงถึงแต่ละด้านของบล็อกที่เคลื่อนไหวระหว่างซ้ายและขวา:
สูตรที่แน่นอนสำหรับแต่ละขั้นตอนคือ:
Ln = Rn-1
Rn = Ln-1 + ฉ(Rn-1,Kn)
ที่ไหน:
L = ครึ่งซ้ายของบล็อก (เริ่มต้นด้วย L0 เมื่อเริ่มแบ่งบล็อก)
R = ครึ่งขวาของบล็อก (เริ่มต้นด้วย R0 เมื่อบล็อกถูกแบ่งเริ่มแรก)
n = จำนวนรอบ (เริ่มต้นด้วย 0 เมื่อบล็อกถูกแบ่งเริ่มแรก)
f = ฟังก์ชั่น F
Kn = คีย์ย่อยสำหรับรอบ n
ตามสูตรและแผนภาพในรอบที่สาม R1 จะกลายเป็นครึ่งซ้ายใหม่ (L2) ในขณะที่ R2 ถูกประมวลผลผ่านฟังก์ชัน F สมมุติว่ามันให้ผลลัพธ์กับเรา:
f (R2, K3) 1001 0111 0000 1011 1101 0111 1011 1011
จากนั้นเราคำนวณผลลัพธ์ของรอบที่สามของเรา (R3) โดยใช้รหัส XOR เหมือนเมื่อก่อน:
f (R2, K3): 1011 0111 1,000 1011 1001 1101 1001 1110
L2: 0100 1011 1011 0101 1,000 0111 1010 1001
R3: 1111 1100 0011 1110 0001 1010 0011 0111
กระบวนการเดียวกันดำเนินต่อไปจนถึงรอบที่สิบห้าโดยมีการสลับบล็อกและคีย์ย่อยถัดไปที่ใช้ในแต่ละรอบ ในรอบที่ 16 และรอบสุดท้ายบล็อกจะไม่ถูกสลับ แต่จะรวมกันเป็นบล็อก 64 บิต การงดเว้นจากการสลับบล็อกในขั้นตอนสุดท้ายนี้อนุญาตให้ใช้อัลกอริทึมสำหรับการเข้ารหัสและถอดรหัส.
สมมติว่ารอบสุดท้ายให้ผลลัพธ์ดังนี้:
1010 0101 0100 1011 1001 0001 0100 1,000 0101 1010 1101 0001 1101 1001 1001 1101
การเปลี่ยนแปลงครั้งสุดท้าย
การเปลี่ยนแปลงนี้เป็นสิ่งที่ตรงกันข้ามกับการเปลี่ยนแปลงครั้งแรกและจะเพิ่มมูลค่าความปลอดภัยไม่เพิ่มเติม จัดเรียงข้อมูลตามตารางต่อไปนี้:
ตารางการเรียงสับเปลี่ยนนี้ทำงานเหมือนกับที่ผ่านมา เนื่องจากเป็นขั้นตอนสุดท้ายของกระบวนการเข้ารหัสผลลัพธ์จะเป็นรหัสลับสำหรับบล็อกแรกของ“ไปกันเถอะ ไปที่ชายหาด”. สมมติว่าบล็อกที่เข้ารหัสคือ:
0100 1001 0011 0010 1001 0101 0111 0100 1011 1010 0111 0101 0111 1010 0101 0101
ตอนนี้ถ้าคุณต้องการไซเฟอร์เท็กซ์ข้อความจริงสำหรับ“ ลองไปที่ชายหาด” คุณสามารถข้ามกระบวนการเรียนรู้ทั้งหมดและไปที่เครื่องมือเข้ารหัส DES ออนไลน์ หากเราป้อนประโยคของเราพร้อมกับกุญแจ (สมมุติว่า kj329nf982bc9wn1) เครื่องมือจะให้ข้อความที่เข้ารหัสของเรา:
U2FsdGVkX19Pienyu3w3q4zCd2IPKEPUWBzu3AeyVu2H3FeimZe6hA
หากคุณต้องการคุณสามารถแปลงคีย์และไซเฟอร์เท็กซ์เป็นไบนารี่แล้วเปรียบเทียบวิธี ciphertext ของบล็อกแรก เรียงกันตามกระบวนการทั้งหมดที่ระบุไว้.
ถอดรหัสถอดรหัส DES
ใน DES กระบวนการถอดรหัสนั้นง่ายอย่างไม่น่าเชื่อ โครงสร้าง Feistel ของอัลกอริทึมช่วยให้สามารถย้อนกลับได้ง่าย กระบวนการนี้เกือบจะเหมือนกันในการถอดรหัสข้อมูล ข้อแตกต่างเพียงอย่างเดียวคือมีการใช้คีย์ย่อยในสิ่งที่ตรงกันข้าม นี่เป็นการตั้งค่าที่มีประสิทธิภาพเพราะมันหมายความว่าสามารถใช้ซอฟต์แวร์และฮาร์ดแวร์เดียวกันได้ทั้งในกระบวนการเข้ารหัสและถอดรหัส.
ในการถอดรหัสข้อมูลมันจะผ่านการเปลี่ยนแปลงครั้งแรกจากนั้นบล็อกจะถูกแยกและครึ่งที่ถูกต้องจะผ่านฟังก์ชั่น F ความแตกต่างคือในรอบแรกของการถอดรหัสคีย์ย่อยที่ 16 ถูกนำไปใช้ ทุกอย่างอื่นดำเนินการตามปกติ เมื่อฟังก์ชั่น F เสร็จสมบูรณ์จะมี XORed ที่ด้านซ้ายของบล็อก.
บล็อกจะถูกสลับไปและผลลัพธ์จะผ่านกระบวนการเดียวกันสำหรับรอบที่สองโดยมีข้อยกเว้นเพียงอย่างเดียวว่าจะใช้คีย์ย่อย 15 กระบวนการนี้จะดำเนินต่อไปจนถึงรอบที่ 16 เมื่อมีการใช้คีย์ย่อย 1.
เช่นเดียวกับในกระบวนการเข้ารหัสบล็อกจะไม่สลับในขั้นตอนสุดท้ายจากนั้นข้อมูลจะได้รับการเปลี่ยนแปลงขั้นสุดท้าย ขั้นตอนนี้จะเสร็จสิ้นกระบวนการถอดรหัสลับทำให้ข้อความธรรมดาของข้อความ.
3DES
เมื่อจุดอ่อนด้านความปลอดภัยของ DES ชัดเจนขึ้น 3DES จึงถูกเสนอเป็นวิธีการขยายขนาดคีย์โดยไม่ต้องสร้างอัลกอริทึมใหม่ทั้งหมด แทนที่จะใช้ปุ่มเดียวเหมือนใน DES 3DES จะรันอัลกอริทึม DES สามครั้งโดยใช้ปุ่ม 56 บิตสามตัว:
- คีย์หนึ่งถูกใช้เพื่อ เข้ารหัส ข้อความธรรมดา.
- คีย์สองถูกใช้เพื่อ ถอดรหัส ข้อความที่ถูกเข้ารหัสโดยรหัสสำคัญ.
- คีย์สามถูกใช้เพื่อ เข้ารหัส ข้อความที่ถูกถอดรหัสโดยคีย์สาม.
ในแต่ละขั้นตอนกระบวนการ DES ที่สมบูรณ์จะถูกปฏิบัติตามที่อธิบายไว้ข้างต้น.
ตอนนี้คุณอาจสงสัยว่า“ การใช้การถอดรหัสในขั้นตอนที่สองช่วยเพิ่มความปลอดภัยได้อย่างไร”
คำตอบคือใช้รหัสแยกต่างหาก หากใช้คีย์แรกในการถอดรหัสข้อมูลในขั้นตอนที่สองข้อมูลจะถูกย้อนกลับทันทีที่เริ่มทำงาน.
อย่างไรก็ตามเนื่องจากใช้คีย์ที่แตกต่างกันกระบวนการถอดรหัสจึงไม่ได้ให้บริการเพื่อถอดรหัสข้อมูล มันอาจดูผิดปกติอย่างมีเหตุมีผล แต่การถอดรหัสด้วยคีย์แยกต่างหากจะทำหน้าที่ในการทำให้ข้อมูลสับสนยิ่งขึ้นไปอีก.
เมื่อคีย์ที่สองได้“ ถอดรหัส” ข้อมูลแล้วคีย์ที่สามจะถูกใช้เพื่อเข้ารหัสอีกครั้ง ผลลัพธ์คือ ciphertext 3DES.
3DES มีโครงสร้างแบบนี้เพราะมันช่วยให้การใช้งานเข้ากันได้กับคีย์เดียว DES, สองคีย์ DES และสามคีย์ DES (เหล่านี้จะครอบคลุมในส่วนต่อไปนี้) สิ่งนี้จะไม่ทำงานหากใช้การเข้ารหัสในทั้งสามขั้นตอน.
ตัวเลือกการคีย์ 3DES
ในทางเทคนิค 3DES สามารถนำไปใช้กับการกำหนดค่าคีย์ที่แตกต่างกันสามแบบ ตัวเลือกที่สองและสามนั้นไม่ปลอดภัยและไม่ควรนำมาใช้.
- ตัวเลือกคีย์หนึ่ง – ตัวเลือกนี้ใช้คีย์อิสระสามปุ่มและปลอดภัยที่สุด.
- ตัวเลือกคีย์สอง – ในการกำหนดค่านี้ปุ่มแรกและปุ่มที่สามเหมือนกัน.
- ตัวเลือกคีย์สาม – ใช้ปุ่มสามปุ่มเหมือนกัน เมื่อใช้คีย์เหมือนกันกระบวนการถอดรหัสในขั้นตอนที่สองจะยกเลิกการเข้ารหัสครั้งแรกโดยเหลือเพียงการเข้ารหัสขั้นสุดท้ายเพื่อเปลี่ยนข้อมูล สิ่งนี้ทำให้ผลลัพธ์ เหมือนกับ DES ทั่วไป.
กระบวนการ 3DES: ตัวเลือกการคีย์หนึ่ง
ขอบอกเลยว่ากระบวนการ 3DES ทั้งหมดสามารถทำให้หัวของคุณหมุนโดยเฉพาะถ้าคุณยังใหม่กับการเข้ารหัส เพื่อช่วยให้จมลงต่อไปนี้เป็นบทสรุปโดยย่อของรูปแบบการเข้ารหัสทั้งหมดของอัลกอริทึม 3DES:
ข้อความธรรมดาเข้าสู่อัลกอริทึม 3DES และเป็นครั้งแรก เข้ารหัสด้วยคีย์หนึ่ง ในขั้นตอนต่อไปนี้:
-
-
Key schedule – คีย์ย่อย 16 ตัวได้มาจาก key ตัวหนึ่ง
-
การเปลี่ยนแปลงครั้งแรก
-
บล็อกถูกแบ่งออกเป็นครึ่งซ้ายและครึ่งขวา
-
-
-
-
ครึ่งขวาจะถูกส่งผ่านฟังก์ชั่น F
-
การเปลี่ยนแปลงการขยายตัว
-
แฮคเกอร์พร้อมคีย์ย่อยสำหรับรอบ
-
การแทน
-
การเปลี่ยนแปลง
-
-
XOR ผลลัพธ์ของฟังก์ชัน F ทางด้านซ้าย
-
ทำให้ด้านขวาเก่าเป็นด้านซ้ายใหม่และให้ผลลัพธ์ด้านขวาใหม่
ทำซ้ำขั้นตอนข้างต้น 14 ครั้ง
-
-
-
-
-
ครึ่งขวาจะถูกส่งผ่านฟังก์ชั่น F
-
การเปลี่ยนแปลงการขยายตัว
-
แฮคเกอร์พร้อมคีย์ย่อยสำหรับรอบที่ 16
-
การแทน
-
การเปลี่ยนแปลง
-
-
XOR ผลลัพธ์ของฟังก์ชัน F ทางด้านซ้าย
-
รวมด้านซ้ายและด้านขวาของบล็อกเข้าด้วยกัน
-
-
-
-
การเปลี่ยนแปลงครั้งสุดท้าย
-
นำข้อความที่เข้ารหัสด้วยคีย์หนึ่งแล้วส่งผ่านทาง “ ถอดรหัส” กระบวนการด้วย สำคัญ สอง:
-
-
Key schedule – คีย์ย่อย 16 ตัวมาจากคีย์สอง
-
การเปลี่ยนแปลงครั้งแรก
-
บล็อกถูกแบ่งออกเป็นครึ่งซ้ายและครึ่งขวา
-
-
-
-
ครึ่งขวาจะถูกส่งผ่านฟังก์ชั่น F
-
การเปลี่ยนแปลงการขยายตัว
-
แฮคเกอร์ที่มีคีย์ย่อยสำหรับรอบ (เริ่มจากคีย์ย่อยที่ 16 สำหรับการถอดรหัส)
-
การแทน
-
การเปลี่ยนแปลง
-
-
XOR ผลลัพธ์ของฟังก์ชัน F ทางด้านซ้าย
-
ทำให้ด้านขวาเก่าเป็นด้านซ้ายใหม่และให้ผลลัพธ์ด้านขวาใหม่
ทำซ้ำขั้นตอนข้างต้น 14 ครั้ง
-
-
-
-
-
ครึ่งขวาจะถูกส่งผ่านฟังก์ชั่น F
-
การเปลี่ยนแปลงการขยายตัว
-
แฮคเกอร์พร้อมคีย์ย่อยสำหรับรอบแรก
-
การแทน
-
การเปลี่ยนแปลง
-
-
XOR ผลลัพธ์ของฟังก์ชัน F ทางด้านซ้าย
- รวมด้านซ้ายและด้านขวาของบล็อกเข้าด้วยกัน
-
- การเปลี่ยนแปลงครั้งสุดท้าย
-
ใช้ข้อมูลที่ได้รับ“ ถอดรหัส” โดยคีย์ที่สองจากนั้นส่งผ่าน enกระบวนการเข้ารหัสด้วย สำคัญ สาม:
-
-
Key schedule – คีย์ย่อย 16 ตัวมาจากคีย์สาม
-
การเปลี่ยนแปลงครั้งแรก
-
บล็อกถูกแบ่งออกเป็นครึ่งซ้ายและครึ่งขวา
-
-
-
-
ครึ่งขวาจะถูกส่งผ่านฟังก์ชั่น F
-
การเปลี่ยนแปลงการขยายตัว
-
แฮคเกอร์พร้อมคีย์ย่อยสำหรับรอบ
-
การแทน
-
การเปลี่ยนแปลง
-
-
XOR ผลลัพธ์ของฟังก์ชัน F ทางด้านซ้าย
-
ทำให้ด้านขวาเก่าเป็นด้านซ้ายใหม่และให้ผลลัพธ์ด้านขวาใหม่
ทำซ้ำขั้นตอนข้างต้น 14 ครั้ง
-
-
-
-
-
ครึ่งขวาจะถูกส่งผ่านฟังก์ชั่น F
-
การเปลี่ยนแปลงการขยายตัว
-
แฮคเกอร์พร้อมคีย์ย่อยสำหรับรอบที่ 16
-
การแทน
-
การเปลี่ยนแปลง
-
-
XOR ผลลัพธ์ของฟังก์ชัน F ทางด้านซ้าย
-
รวมด้านซ้ายและด้านขวาของบล็อกเข้าด้วยกัน
-
-
-
-
การเปลี่ยนแปลงครั้งสุดท้าย
-
ผลลัพธ์คือ ciphertext 3DES.
ความปลอดภัยของ 3DES
ความปลอดภัยของ 3DES ขึ้นอยู่กับตัวเลือกการใช้คีย์ ตัวเลือกการคีย์หนึ่งเกี่ยวข้องกับคีย์ 56 บิตที่แตกต่างกันสามตัวซึ่งให้ความยาวคีย์ทั้งหมด 168 บิต ความยาวที่มีประสิทธิภาพจะลดลงอย่างมากจากการโจมตีแบบตรงกลางซึ่งทำให้ความปลอดภัยในโลกแห่งความจริงลดลงเหลือ 112 บิต.
การโจมตีแบบตรงกลางตรงกลางมีประโยชน์สำหรับแผนการเข้ารหัสที่ทำซ้ำอัลกอริทึมเดียวกันหลายครั้ง เทคนิคนี้เก็บค่าทันทีจากการเข้ารหัสแต่ละขั้นตอนจากนั้นใช้ข้อมูลนี้เพื่อปรับปรุงเวลาที่รุนแรงเพื่อบังคับใช้อัลกอริทึม.
ตัวเลือกที่สองและสามมีคีย์ขนาดเล็กลงอย่างมากและมีความเสี่ยงต่อการโจมตีแบบข้อความธรรมดาและการโจมตีแบบข้อความธรรมดาและอื่น ๆ.
การโจมตีที่เป็นที่รู้กันทั่วไปเป็นไปได้เมื่อฝ่ายตรงข้ามมีการเข้าถึงทั้งข้อความธรรมดาและการเข้ารหัสของข้อความ หากอัลกอริทึมไวต่อการโจมตีเหล่านี้ผู้โจมตีสามารถใช้ข้อมูลนี้เพื่ออนุมานคีย์ซึ่งทำให้พวกเขาสามารถถอดรหัสข้อมูลอื่น ๆ ทั้งหมดที่เข้ารหัสด้วยคีย์เดียวกัน.
การโจมตีแบบเพลนเท็กซ์นั้นคล้ายกัน แต่มันเกี่ยวข้องกับผู้โจมตีที่เปิดเผยกุญแจโดยการเปรียบเทียบ ciphertexts กับ plaintexts โดยพลการ.
เนื่องจากช่องโหว่เหล่านี้และขนาดคีย์โดยรวมที่เกี่ยวข้องขนาดเล็กตัวเลือกการคีย์สองและสามจึงไม่ปลอดภัยและไม่ควรนำมาใช้.
3DES ปลอดภัยหรือไม่?
เนื่องจาก 3DES จะเลิกใช้ในอีกไม่กี่ปีข้างหน้าจึงเป็นการดีที่สุดที่จะใช้อัลกอริทึมอื่น ในขณะที่ตัวเลือกการคีย์หนึ่งยังถือว่าปลอดภัยสำหรับแอปพลิเคชันจำนวนมาก แต่ก็ไม่มีเหตุผลที่ดีมากมายสำหรับเหตุผลที่ควรใช้แทนตัวเลือกอื่นเช่น AES.
แม้ว่า 3DES ถือเป็นสถานที่สำคัญในการเข้ารหัสเมื่อติดตามผลของ DES แต่ปีแห่งความรุ่งโรจน์ก็สิ้นสุดลงและถึงเวลาที่ต้องเดินหน้าต่อไป หากคุณต้องการรักษาระบบของคุณให้ปลอดภัยในอนาคตคุณควรใช้อัลกอริทึมที่ทันสมัยแทน.
ที่เกี่ยวข้อง: อธิบายประเภทการเข้ารหัสทั่วไป
แผน X โดยกระทรวงอนุญาตภายใต้ มอนส์ CC0
