การเข้ารหัส 3DES คืออะไรและ DES ทำงานอย่างไร

การเข้ารหัส 3DES คืออะไรและ DES ทำงานอย่างไร (1)

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 ขั้นตอนแรกของการรับคีย์กลมของเราคือการเปลี่ยนคีย์ (เลื่อนไปรอบ ๆ ) ตามตารางต่อไปนี้:

3DES-2a

ในการเรียงสับเปลี่ยนคีย์ดั้งเดิมของเราแต่ละบิตจะถูกสับเปลี่ยนไปยังตำแหน่งใหม่ตามที่ระบุไว้ในตาราง เนื่องจากเซลล์ที่มุมบนซ้าย (ของ 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 ที่แสดงด้านล่าง:

des-3a

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

แต่ละคีย์ 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 เราจะกลับไปที่คีย์ย่อยที่เราเพิ่งสร้างในภายหลัง ขั้นตอนแรกเรียกว่าการเปลี่ยนแปลงเริ่มต้นโดยที่ข้อมูลจะถูกจัดเรียงใหม่ตามตารางต่อไปนี้:

3DES-12

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

เนื่องจากเราครอบคลุมการเรียงสับเปลี่ยนสองสามครั้งเราจะข้ามคำอธิบายที่สำคัญที่นี่ มุ่งหน้ากลับไปที่ กำหนดการคีย์ 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 ในแผนภาพ)

des-5

การเปลี่ยนแปลงการขยายตัว

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

บิตถูกจัดเรียงใหม่ตามตารางต่อไปนี้ บิตแต่ละบิตบางตัวอยู่ในตารางสองครั้งซึ่งเป็นวิธีที่บล็อกขยายจาก 32 ถึง 48 บิต:

เด - 6a

ตั้งแต่เซลล์แรกบอกว่า 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:

ดี - 7

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 โต๊ะ:

                เด - 7a

หมายเลขแรกของเรา, 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 คือการเปลี่ยนรูปแบบอื่นโดยใช้ตารางต่อไปนี้:เด - 8a

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

สมมติว่าการเปลี่ยนรูปนี้ใช้ผลลัพธ์ก่อนหน้าของเรา:

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 และลูกศรแสดงถึงแต่ละด้านของบล็อกที่เคลื่อนไหวระหว่างซ้ายและขวา:

des-9

สูตรที่แน่นอนสำหรับแต่ละขั้นตอนคือ:

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

การเปลี่ยนแปลงครั้งสุดท้าย

การเปลี่ยนแปลงนี้เป็นสิ่งที่ตรงกันข้ามกับการเปลี่ยนแปลงครั้งแรกและจะเพิ่มมูลค่าความปลอดภัยไม่เพิ่มเติม จัดเรียงข้อมูลตามตารางต่อไปนี้:

des-10a

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

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

Brayan Jackson
Brayan Jackson Administrator
Sorry! The Author has not filled his profile.
follow me

About the author

Leave a Reply

Your email address will not be published. Required fields are marked *

− 1 = 2

Adblock
detector