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

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

วัดประสิทธิภาพของโค้ดอย่างไร เนื่องจากฉันเป็นคนแรกที่พูดถึงเรื่องนี้ ฉันจะวัดมันด้วยมาตราส่วน RTT ทางด้านขวาของผู้ค้นพบ;)

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

นักเรียนจะตอบ - หนึ่ง ครูของเขาจะคิดและพูดว่า สี่ มืออาชีพ - มีเพียงสิบสองการดำเนินการเท่านั้น

ดังนั้น โค้ดโปรแกรมที่โหลดอุปกรณ์ผู้บริหารของโปรเซสเซอร์ทั้งหมดพร้อมกันตลอดระยะเวลาการดำเนินการโค้ดทั้งหมดจะมีประสิทธิภาพ 12 RTT NIS ขีดสุด! พูดตามตรงฉันไม่เคยเขียนโค้ดแบบนี้มาก่อนเลย แต่ในบทความนี้ฉันจะพยายามพยายามด้วยตัวเอง

ฉันจะพิสูจน์ว่ารหัสที่มีการประมวลผลแบบ 32 บิตสิบสองรายการพร้อมกันนั้นเป็นไปได้

รหัสโปรแกรมที่ใช้หนึ่งหน่วยดำเนินการในแกนประมวลผลจะมีประสิทธิภาพ 1 RTT โดยธรรมชาติ โปรแกรมที่สร้างโดยคอมไพเลอร์ภาษาระดับสูงและล่ามเครื่องเสมือนสามารถ "โอ้อวด" ประสิทธิภาพของโค้ดดังกล่าวได้ ไม่ควรสันนิษฐานว่าตัวบ่งชี้การใช้งาน CPU ซึ่งสามารถเห็นได้ในตัวจัดการงาน OS สามารถทำหน้าที่เป็นเกณฑ์วัตถุประสงค์สำหรับประสิทธิภาพของรหัส โหลดคอร์โปรเซสเซอร์สามารถเป็น 100% ได้ แต่โค้ดโปรแกรมจะใช้อุปกรณ์ดำเนินการหนึ่งเครื่องในนั้น (ประสิทธิภาพ 1 RTT) ในกรณีนี้ เมื่อโหลด 100% แกนประมวลผลจะทำงานที่ 1/12 ของประสิทธิภาพสูงสุด กล่าวอีกนัยหนึ่ง เมื่อ Windows Task Manager แสดงการใช้งาน CPU สูงสุด ประสิทธิภาพจริงอาจแตกต่างกันไปตั้งแต่ 1 ถึง 12 RTT เมื่อดูในหน้าต่างประสิทธิภาพโหลด 100% บนคอร์โปรเซสเซอร์ใด ๆ มันผิดที่จะถือว่าอุปกรณ์ผู้บริหารทั้งหมดทำงานในคอร์นี้โดยไม่ได้ตั้งใจ!

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

การใช้งานแบบดั้งเดิมของ GOST 28147-89

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

การแปลงการเข้ารหัสตาม GOST 28147-89 ใช้สำหรับการสตรีมการเข้ารหัสข้อมูลในช่องสื่อสารและบนดิสก์ไดรฟ์

ปัจจุบันมีการใช้ซอฟต์แวร์ของ GOST นี้บน RON ของโปรเซสเซอร์กลางกันอย่างแพร่หลาย ในวิธีการที่รู้จักกันดีในการใช้ GOST ข้อมูลลับทั้งหมด (คีย์การเข้ารหัส บล็อกทดแทน) จะอยู่ใน RAM สิ่งนี้จะลดความน่าเชื่อถือของการเข้ารหัส เนื่องจากการดัมพ์ RAM ทำให้สามารถเปิดเผยองค์ประกอบลับทั้งหมดของการแปลงรหัสลับได้อย่างสมบูรณ์ นอกจากนี้ วิธีนี้ยังมีข้อจำกัดด้านความเร็วเนื่องจากตำแหน่งของวัตถุหลักของการแปลงการเข้ารหัสลับใน OP และการโหลดอุปกรณ์ผู้บริหาร ALU ที่ไม่สมบูรณ์ โปรเซสเซอร์สมัยใหม่ที่ใช้ cryptoprocedure โดยใช้วิธีที่รู้จักกันดีสามารถให้ความเร็วการเข้ารหัส 40–60 เมกะไบต์ต่อวินาที และถ้าคุณเข้าใจมันจนจบจริงๆ สาเหตุของประสิทธิภาพต่ำและความปลอดภัยที่อ่อนแอของการแปลง crypto คือการใช้ซอฟต์แวร์ของบล็อกการทดแทน ดูคำอธิบายใน GOST ในรูป 1.

ตามข้อ 1.2 ของ GOST บล็อกนี้ใช้การเรียงสับเปลี่ยน tetrad (สี่บิต) ในคำ 32 บิต แต่สถาปัตยกรรมตัวประมวลผล x86 / 64 และชุดคำสั่งไม่สามารถจัดการ tetrad ได้อย่างมีประสิทธิภาพ

สำหรับการใช้งานซอฟต์แวร์ของบล็อกการแทนที่จะใช้ตารางพิเศษใน RAM ซึ่งเตรียมไว้ในขั้นตอนของการเริ่มต้นของฟังก์ชันการเข้ารหัสลับ ตารางเหล่านี้รวมโหนดแทนที่ของ tetrads ที่อยู่ติดกันเป็นตารางไบต์ขนาด 8 × 8 บิต ดังนั้นจึงมีตารางขนาด 256 ไบต์สี่ตารางใน RAM

ในการใช้งานขั้นสูง ตารางเหล่านี้มีขนาด 1024 ไบต์ (256 คำ 4 ไบต์) สิ่งนี้ทำขึ้นเพื่อใช้ในตารางการเปลี่ยนแปลงแบบวนรอบเพิ่มเติมโดย 11 ตำแหน่งของคำ 32 บิตที่ได้รับจากการแทนที่ (การดำเนินการถัดไปของอัลกอริทึมการแปลงตาม GOST) ตัวอย่างของการใช้ GOST ตามวิธีนี้แสดงในภาคผนวก 1 (บนดิสก์)

ข้อมูลของบล็อกการแทนที่เป็นองค์ประกอบลับของฟังก์ชันการเข้ารหัสลับ (ตามที่กำหนดใน GOST ดูรูปที่ 2)

การวางตารางเหล่านี้ด้วยคีย์ของบล็อกการแทนที่ใน OP ขัดแย้งกับข้อกำหนดของ GOST (ข้อ 1.7) เนื่องจากข้อมูลลับจะพร้อมใช้งานสำหรับโปรแกรมของบุคคลที่สามที่ทำงานบนการติดตั้งคอมพิวเตอร์ FSB ซึ่งรับรองการใช้งานซอฟต์แวร์ของการเข้ารหัสตาม GOST พิจารณาการละเมิดนี้โดยกล่าวอย่างสุภาพและถ่อมตน หากต้องการวางคีย์ใน OP FSB ยังคงต้องใช้ "fig leaf" - ปิดบังคีย์ด้วยการดำเนินการ XOR ดังนั้นจึงไม่จำเป็นต้องเปลี่ยนบล็อกใน OP พวกเขาจะถูกเก็บไว้ในข้อความที่ชัดเจน

ในระยะสั้น FSB ข้ามการใช้งานซอฟต์แวร์ดังกล่าวของ cryptoprocedure แม้ว่าความแข็งแกร่งของโซลูชันดังกล่าวจะลดลงอย่างชัดเจนและละเมิดข้อกำหนดโดยตรงตาม GOST (ข้อ 1.7) และนี่คือแม้จะมีวิธีการที่รู้จักกันดีในการทำลายรหัสผ่านการลบการถ่ายโอนข้อมูลหน่วยความจำ ...

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

แต่พอเนื้อเพลงเป็นสิ่งสำคัญภายใต้กรอบของหัวข้อภายใต้การพิจารณาว่ารหัสโปรแกรมนี้มีประสิทธิภาพ 1 RTT-shku ตอนนี้มาเขียนโค้ดที่มีประสิทธิภาพ 2 RTT

การใช้งานแบบมัลติเธรดของ GOST 28147-89

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

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

อย่างไรก็ตาม มีอีกรูปแบบหนึ่งของการประมวลผลข้อมูลแบบขนานบนแกนประมวลผลเดียว ให้ฉันอธิบายความคิดที่ไม่ชัดเจนนี้

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

การโหลดงานของ ALU ทั้งหมดถูกควบคุมโดยบล็อกฮาร์ดแวร์พิเศษภายในแกนประมวลผล - ตัวกำหนดตารางเวลาซึ่งมองผ่านรหัสปฏิบัติการไปข้างหน้าจนถึงความลึก 32–64 ไบต์ หากตัวกำหนดตารางเวลาพบคำสั่งที่สามารถรันบน ALU ได้โดยไม่มีข้อขัดแย้ง ก็จะรันพร้อมกันในหน่วยดำเนินการที่แตกต่างกัน ในกรณีนี้ตัวนับของคำสั่งที่ดำเนินการจะชี้ไปที่คำสั่งที่เรียกใช้งานได้ (มีหลายคำสั่งในรูปแบบดังกล่าว) หลังจากนั้นคำสั่งทั้งหมดได้ถูกดำเนินการแล้ว

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

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

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

แต่คุณสามารถทำได้อย่างอื่น: คำสั่งทางเลือกที่เกี่ยวข้องกับการประมวลผลข้อมูลกลุ่มต่างๆ กราฟิก ตัวเลือกเหล่านี้แสดงในรูปที่ 3.

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

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

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

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

วิธีการเข้ารหัสแบบขนานถูกนำมาใช้อย่างมีประสิทธิภาพสำหรับโหมดการทำงานของโปรเซสเซอร์ 64 บิตเท่านั้น เนื่องจากในโหมดนี้มี RON เพียงพอ (มากถึง 16 ชิ้น!) ตัวอย่างของการใช้ GOST ตามวิธีนี้แสดงในภาคผนวก 2 (บนดิสก์)

เป็นที่ชัดเจนว่าการใช้ GOST นี้มีประสิทธิภาพรหัส 2 RTT ทีนี้มาดูกันว่าสิ่งนี้ส่งผลต่อเวลาดำเนินการอย่างไร

รอบการเข้ารหัสสำหรับหนึ่งสตรีม (ภาคผนวก 1) คือ 352 รอบและในช่วงเวลานี้จะมีการคำนวณข้อมูล 8 ไบต์สำหรับการใช้งาน GOST แบบสองสตรีม (ภาคผนวก 2) จำเป็นต้องมีรอบตัวประมวลผล 416 รอบ แต่คำนวณ 16 ไบต์ ดังนั้น ความเร็วในการแปลงที่ได้จึงเพิ่มขึ้นจาก 80 เป็น 144 เมกะไบต์สำหรับโปรเซสเซอร์ 3.6 GHz

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

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

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

การใช้ SSE-registers และคำสั่ง AVX ของโปรเซสเซอร์สมัยใหม่สำหรับการใช้งาน GOST 28147-89

โปรเซสเซอร์สถาปัตยกรรม x86/64 สมัยใหม่ประกอบด้วยชุดของรีจิสเตอร์ SSE ขนาด 16 ไบต์และ FPU พิเศษ (อย่างน้อยสองตัว) เพื่อดำเนินการต่างๆ กับรีจิสเตอร์เหล่านี้ เป็นไปได้ที่จะใช้ GOST บนอุปกรณ์นี้และในกรณีนี้โหนดทดแทนไม่สามารถวางได้ในรูปแบบของตารางใน RAM แต่โดยตรงในการลงทะเบียน SSE เฉพาะ

ในการลงทะเบียน SSE หนึ่งรายการ คุณสามารถวางตาราง 16 แถวได้สองตารางพร้อมกัน ดังนั้นการลงทะเบียน SSE สี่รายการจะรองรับตารางทดแทนทั้งหมดอย่างสมบูรณ์ เงื่อนไขเดียวสำหรับการจัดวางดังกล่าวคือข้อกำหนดการแทรกสลับ ซึ่งตามที่ tetrad ของไบต์เดียวกันจะต้องวางในรีจิสเตอร์ SSE ที่แตกต่างกัน นอกจากนี้ ขอแนะนำให้วาง tetrads ต่ำและสูงของอินพุตไบต์ตามลำดับใน tetrads ต่ำและสูงของการลงทะเบียน SSE

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

ไดอะแกรมของหนึ่งในตำแหน่งที่เป็นไปได้ของโหนดทดแทนในการลงทะเบียน SSE จะแสดงในรูปที่ 4.

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

• แกนประมวลผลถูกใส่เข้าไปในโหมดโฮสต์ไฮเปอร์ไวเซอร์ และบล็อกขัดจังหวะ (APIC) ถูกปิดใช้งานโดยบังคับ ในกรณีนี้ แกนประมวลผลจะถูกแยกออกจากระบบปฏิบัติการและแอปพลิเคชันที่ทำงานบนการติดตั้งคอมพิวเตอร์อย่างสมบูรณ์
• การโหลดการลงทะเบียน SSE และการแยกแกนประมวลผลจะดำเนินการก่อนเริ่มระบบปฏิบัติการ เป็นการดีที่สุดที่จะปฏิบัติตามขั้นตอนเหล่านี้จากโมดูลการบูตที่เชื่อถือได้ (TDM)
• โปรแกรมของ cryptoprocedures ตาม GOST จะอยู่ในพื้นที่หน่วยความจำที่ไม่สามารถแก้ไขได้ของหน่วยประมวลผล (ทั้ง BIOS หรือหน่วยความจำแฟลช MDZ)

การปฏิบัติตามข้อกำหนดเหล่านี้จะรับประกันการแยกอย่างสมบูรณ์และไม่สามารถเปลี่ยนแปลงได้ของรหัสโปรแกรมของ cryptoprocedures และข้อมูลลับที่ใช้ในนั้น

สำหรับการสุ่มตัวอย่างที่มีประสิทธิภาพจากการลงทะเบียน SSE ของ tetrads จะใช้สวิตช์แบบหลายอินพุตที่มีอยู่ใน FPU สวิตช์เหล่านี้อนุญาตให้ถ่ายโอนจากไบต์ใดๆ ของต้นทางไปยังไบต์ใดๆ ของปลายทาง โดยดัชนีที่อยู่ในการลงทะเบียนดัชนี SSE พิเศษ นอกจากนี้ การถ่ายโอนจะดำเนินการแบบขนานสำหรับทั้ง 16 ไบต์ของ SSE-register-receiver

การมีโหนดหน่วยเก็บข้อมูลทดแทนบนรีจิสเตอร์ SSE และสวิตช์หลายอินพุตในหน่วย FPU จึงเป็นไปได้ที่จะจัดระเบียบการแปลงต่อไปนี้ในหน่วยทดแทน (รูปที่ 5)

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

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

สวิตช์ถูกควบคุมโดยคำสั่งที่อยู่สามรายการพิเศษ AVX VPSHUFB ตัวถูกดำเนินการตัวแรกคือตัวรับข้อมูลจากสวิตช์ตัวที่สองคือแหล่งที่มาที่อินพุตของสวิตช์เชื่อมต่ออยู่ ตัวดำเนินการที่สามคือรีจิสเตอร์ควบคุมสำหรับสวิตช์ ซึ่งแต่ละไบต์จะเชื่อมโยงกับสวิตช์ที่เกี่ยวข้อง ค่าในนั้นระบุจำนวนทิศทางที่สวิตช์อ่านข้อมูล สำหรับคำอธิบายของคำสั่งนี้จากเอกสารอย่างเป็นทางการของ Intel โปรดดูรูปที่ 5. ในรูป รูปที่ 6 แสดงการทำงานของคำสั่งนี้ - แสดงการลงทะเบียน SSE เพียงครึ่งเดียวเท่านั้นสำหรับครึ่งหลังทุกอย่างจะคล้ายกัน

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

มีการเขียนโปรแกรมที่มีโน้ตบุ๊กให้เลือกผ่านสวิตช์ FPU แต่ฉันไม่ได้ใส่ลงในแอปพลิเคชันด้วยซ้ำ - มันยากเกินไป การลงทะเบียน 128 บิตและใช้เพียง 32 บิตนั้นไม่เป็นมืออาชีพ

อย่างที่เขาว่า “ปลายทางของเราคือเส้นขอบฟ้า” บีบมันออกมาอย่างนั้น… เราจะอัดมันใส่ถุง!

นี่ไม่ใช่การเล่นคำ แต่เป็นความเป็นจริงของ FPU ที่รุนแรง - การลงทะเบียน SSE สามารถแบ่งออกเป็นส่วนเท่าๆ กัน และการแปลงแบบเดียวกันสามารถทำได้ในส่วนเหล่านี้ด้วยคำสั่งเดียว เพื่อให้โปรเซสเซอร์เข้าใจสิ่งนี้มีตัวอักษรเวทย์มนตร์ "P" - แพ็คเกจที่วางไว้หน้าคำสั่งช่วยในการจำและไม่น้อยไปกว่าตัวอักษรเวทย์มนตร์ "Q", "D", "W", "B" ซึ่ง วางไว้ที่ส่วนท้ายและประกาศว่าส่วนใดของการลงทะเบียน SSE แบ่งออกเป็นคำสั่งนี้

เราสนใจโหมดถ่ายภาพต่อเนื่องด้วยการลงทะเบียน SSE ที่แบ่งออกเป็นบล็อก 32 บิตสี่บล็อก; ดังนั้น คำสั่งทั้งหมดจะนำหน้าด้วย "P" และสิ้นสุดด้วยสัญลักษณ์ "D" สิ่งนี้ทำให้สามารถประมวลผลสี่บล็อก 32 บิตพร้อมกันด้วยคำสั่งโปรเซสเซอร์หนึ่งคำสั่ง นั่นคือ คำนวณข้อมูลสี่บล็อกพร้อมกัน

โปรแกรมที่ใช้วิธีนี้มีอยู่ในภาคผนวก 3 มีคำอธิบายทั้งหมด

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

ออกราคา

การใช้การลงทะเบียน SSE เพื่อจัดเก็บโหนดทดแทนนั้นเป็นสิ่งที่เข้าใจได้ - มันให้การรับประกันการแยกข้อมูลลับบางอย่าง แต่ความหมายของการคำนวณ cryptofunction บน FPU นั้นไม่ชัดเจน ดังนั้นการวัดเวลาดำเนินการของขั้นตอนมาตรฐานโดยใช้วิธีการแทนที่โดยตรงตาม GOST สำหรับสี่และแปดสตรีม

สำหรับสี่เธรด จะได้ความเร็วในการประมวลผล 472 รอบของโปรเซสเซอร์ ดังนั้นสำหรับโปรเซสเซอร์ที่มีความถี่ 3.6 GHz จะพิจารณาหนึ่งเธรดที่ความเร็ว 59 เมกะไบต์ต่อวินาทีและสี่เธรดตามลำดับที่ความเร็ว 236 เมกะไบต์ต่อวินาที

สำหรับแปดเธรด จะได้ความเร็วในการประมวลผล 580 รอบของโปรเซสเซอร์ ดังนั้นสำหรับโปรเซสเซอร์ 3.6 GHz จะพิจารณาหนึ่งเธรดที่ความเร็ว 49 เมกะไบต์ต่อวินาทีและแปดเธรดที่ความเร็ว 392 เมกะไบต์ต่อวินาที

ดังที่ผู้อ่านอาจสังเกตเห็นว่า โค้ดในตัวอย่าง #3 มีทรูพุตเท่ากับ 4 RTT ในขณะที่โค้ดในตัวอย่าง #4 มีทรูพุตเท่ากับ 8 RTT ในตัวอย่างเหล่านี้ ในการลงทะเบียน SSE รูปแบบจะเหมือนกับเมื่อใช้ RON มีเพียงตัวกำหนดตารางเวลาเท่านั้นที่ลดประสิทธิภาพลง ตอนนี้ให้ระยะเวลาเพิ่มขึ้น 20% สำหรับความยาวโค้ดที่เพิ่มขึ้น 2 เท่า

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

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

หากเรากำลังพูดถึงการเพิ่มประสิทธิภาพเพิ่มเติม การจดจำการลงทะเบียนแบบ 256 บิต (YMM-register) เป็นสิ่งที่ควรค่าแก่การจดจำ ซึ่งคุณสามารถใช้ความเร็วในการคำนวณเป็นสองเท่าในทางทฤษฎีได้ แต่สำหรับตอนนี้ นี่เป็นเพียงโอกาสเท่านั้น ในขณะนี้ โปรเซสเซอร์ทำงานช้าลงมากเมื่อรันคำสั่ง 256 บิต (FPU มีความกว้างพาธ 128 บิต) การทดลองแสดงให้เห็นว่าในโปรเซสเซอร์สมัยใหม่ การนับ 16 เธรดบนรีจิสเตอร์ YMM ไม่ได้ให้ประโยชน์ใดๆ แต่สำหรับตอนนี้ สำหรับโปรเซสเซอร์รุ่นใหม่ ความเร็วของคำสั่ง 256 บิตจะเพิ่มขึ้นอย่างไม่ต้องสงสัย จากนั้นการใช้ 16 เธรดแบบขนานจะเป็นประโยชน์ และจะนำไปสู่การเพิ่มความเร็วของกระบวนการเข้ารหัสลับ

ในทางทฤษฎี คุณสามารถนับความเร็วได้ 600-700 เมกะไบต์ต่อวินาที หากโปรเซสเซอร์มี FPU สองตัวที่มีความกว้างของเส้นทางการทำงานที่ 256 บิตต่อวินาที ในกรณีนี้ เราสามารถพูดคุยเกี่ยวกับการเขียนโค้ดที่มีประสิทธิภาพ 16 RTT และนี่ไม่ใช่จินตนาการ แต่เป็นอนาคตอันใกล้

โหมดผสม

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

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

โฟกัสนี้ทำได้เฉพาะกับโปรเซสเซอร์ Intel เท่านั้น AMD มีเพียงสอง FPU ต่อสองโมดูลโปรเซสเซอร์ (คล้ายกับโหมดไฮเปอร์เทรด) แต่มี ALU อีกสี่ตัวซึ่งเป็นบาปที่ไม่ควรใช้งาน

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

ใครต้องการมัน?

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

ยิ่งไปกว่านั้น การเข้ารหัสอัลกอริทึม AES ที่สร้างขึ้นในโปรเซสเซอร์นั้นช้ากว่ามาก การทดสอบแสดงความเร็ว 100-150 เมกะไบต์ต่อวินาที และนี่คือการใช้ฮาร์ดแวร์ของอัลกอริทึม! ปัญหาอยู่ที่การนับแบบเธรดเดียวและบล็อกการแทนที่ซึ่งทำงานเป็นไบต์ (ตาราง 256 แถว) ดังนั้น GOST จึงมีประสิทธิภาพมากขึ้นในการใช้งานสถาปัตยกรรม x86 / 64 ใครจะคิดว่า ...

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

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

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

Nicolas Courtois - "ยิ่งใหญ่และน่ากลัว"

เริ่มจากเรื่องราวเกี่ยวกับกิจกรรมของ Nicolas Courtois ซึ่งเป็นผู้เขียนผลงานทั้งหมดเกี่ยวกับมาตรฐานการเข้ารหัสบล็อกของรัสเซีย ()

ในเดือนตุลาคม 2010 กระบวนการพิจารณาการรวมอัลกอริทึม GOST 28147-89 เข้ากับมาตรฐานสากล ISO/IEC 18033-3 ได้เริ่มต้นขึ้น ในเดือนพฤษภาคม 2554 บทความของ Nicolas Courtois นักเข้ารหัสลับชื่อดังได้ปรากฏในเอกสารอิเล็กทรอนิกส์ ePrint โดยมีทัศนคติที่ไม่ชัดเจนต่อเขาจากชุมชนการเข้ารหัสทั่วโลก สิ่งพิมพ์ของ Courtois เป็นตัวอย่างที่น่าเศร้าของการบิดเบือนแนวคิด ซึ่งไม่ได้เปิดเผยคุณสมบัติใหม่ๆ ของวัตถุที่เป็นปัญหา แต่การอ้างความรู้สึกกระตุ้นการแพร่กระจายของความคิดเห็นที่ผิดพลาดเกี่ยวกับคุณสมบัติที่แท้จริงของวัตถุในสภาพแวดล้อมที่ไร้ความสามารถ

วิธีพีชคณิต

การให้เหตุผลของ Courtois สร้างขึ้นโดยใช้วิธีการเข้ารหัสสองประเภท: วิธีพีชคณิตและวิธีเชิงอนุพันธ์ พิจารณาวิธีการชั้นหนึ่ง

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

วิธีพีชคณิตที่คูร์ตัวส์ใช้สามารถอธิบายสั้นๆ ได้ดังต่อไปนี้ ในขั้นตอนแรกคุณสมบัติดังกล่าวของ GOST 28147-89 จะใช้เป็นจุดคงที่สำหรับส่วนหนึ่งของการแปลงการเข้ารหัสรวมถึงจุดสะท้อนที่เรียกว่า ด้วยคุณสมบัติเหล่านี้ คู่หลายคู่จึงถูกเลือกจากคู่ open-ciphertext จำนวนมากพอ ซึ่งช่วยให้เราพิจารณาการแปลงที่ไม่ได้อยู่ใน 32 แต่เฉพาะใน 8 รอบเท่านั้น ขั้นตอนที่สองประกอบด้วยความจริงที่ว่า จากผลลัพธ์ของการแปลง 8 รอบที่ได้รับในขั้นตอนแรก ระบบสมการไม่เชิงเส้นจะถูกสร้างขึ้น ซึ่งค่าที่ไม่ทราบเป็นบิตสำคัญ จากนั้นระบบนี้จะได้รับการแก้ไข (ฟังดูง่าย แต่จริง ๆ แล้วเป็นส่วนที่ใช้เวลานานที่สุดของวิธีการ เนื่องจากระบบประกอบด้วยสมการที่ไม่ใช่เชิงเส้น)

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

วิธีที่แตกต่าง

พิจารณาวิธีที่สองของ Courtois ซึ่งอิงตามการเข้ารหัสแบบดิฟเฟอเรนเชียล

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

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

Courtois ใช้วิธีการที่แตกต่างกันเล็กน้อย เราทราบทันทีว่า Courtois ดำเนินการวิเคราะห์ S-box ที่แตกต่างจากปัจจุบันและจากที่เสนอใน ISO กระดาษนำเสนอลักษณะที่แตกต่างกัน (จำนวนที่บล็อกควรแตกต่างกัน) สำหรับจำนวนรอบเล็กน้อย เหตุผลในการขยายสถิติสำหรับรอบอื่นๆ เป็นไปตาม "ข้อเท็จจริง" ตามปกติ Courtois แสดงอีกครั้งโดยไม่มีสิ่งใดนอกจากอำนาจของเขา ข้อสันนิษฐานที่ไม่มีเงื่อนไขว่าการเปลี่ยน S-box จะไม่ส่งผลกระทบต่อการต่อต้านของ GOST 28147-89 ต่อการโจมตี (ในเวลาเดียวกันด้วยเหตุผลที่ไม่ทราบสาเหตุ S-box จากการทำงานครั้งแรก ร่างส่วนเสริมของมาตรฐาน ISO/IEC 18033-3 ยังไม่ได้รับการพิจารณา) การวิเคราะห์ที่ดำเนินการโดยผู้เขียนบทความแสดงให้เห็นว่าแม้ว่าเราจะใช้ "ข้อเท็จจริง" ที่ไม่มีมูลความจริงของ Courtois เกี่ยวกับความเชื่อและวิเคราะห์ GOST 28147-89 กับ S-box อื่น ๆ การโจมตีอีกครั้งก็ไม่ดีไปกว่าการแจงนับทั้งหมด

การวิเคราะห์โดยละเอียดเกี่ยวกับผลงานของ Courtois พร้อมเหตุผลโดยละเอียดสำหรับความไร้เหตุผลของข้อความทั้งหมดเกี่ยวกับการลดลงของความเสถียรของมาตรฐานรัสเซียได้ดำเนินการใน [ , ]

ในเวลาเดียวกันแม้แต่ Courtois เองก็รับรู้ถึงการขาดความแม่นยำในการคำนวณ! สไลด์ต่อไปนี้นำมาจากการนำเสนอของ Courtois ในส่วนประกาศสั้น ๆ ของ FSE 2012

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

• "ฉันคิดว่าผู้ชมของ Asiacrypt จะไม่รู้สึกว่ามันน่าสนใจ" ผู้ตรวจสอบ Asiacrypt 2011
• “… มีปัญหาใหญ่ ใหญ่ และใหญ่: การโจมตีครั้งนี้ซึ่งเป็นผลงานหลักของเอกสารนี้ได้รับการตีพิมพ์แล้วที่ FSE’11 (มันเป็นเอกสารที่ดีที่สุดด้วยซ้ำ)…” ผู้ตรวจสอบ Crypto 2011

ดังนั้น ผู้เชี่ยวชาญของชุมชนการเข้ารหัสระดับนานาชาติจึงปฏิบัติต่อคุณภาพของงานของ Courtois อย่างไม่ต้องสงสัย เช่น คำกล่าวของผู้เชี่ยวชาญชาวรัสเซียบางคนเกี่ยวกับความสามารถในการถอดรหัส AES ในราคา 2,100 หรือ "การพิสูจน์" ถัดไปสำหรับสองหน้าของ สมมติฐานซึ่งไม่ได้รับการยืนยันจากการคำนวณที่สอดคล้องกันเกี่ยวกับอสมการของคลาสความซับซ้อน P และ NP

การโจมตีของ Isobe และ Dinur-Dunkelman-Shamir

แนวคิดทั่วไปของการโจมตี Isobe () และ Dinur-Dankelman-Shamir (ต่อไปนี้: การโจมตี DDSH) () คือการสร้างชุดข้อความธรรมดาแคบ ๆ (ขึ้นอยู่กับคีย์) ชุดหนึ่งซึ่งเทียบเท่ากับการแปลงในชุดนี้ซึ่งมี โครงสร้างที่ง่ายกว่าการแปลงการเข้ารหัสเอง . ในกรณีของเมธอด Isobe นี่คือชุดของบล็อก 64 บิต x โดยที่ F 8 -1 (Swap(F 8 (z))) = z โดยที่ z = F 16 (x) ถึง F 8 ( x) และ F 16 ( x) เป็น 8 รอบแรกและ 16 รอบแรกของการเข้ารหัส GOST 28147-89 ตามลำดับผ่าน Swap - การดำเนินการสลับครึ่งของคำ 64 ไบต์ เมื่อข้อความธรรมดาเข้ามาในชุดนี้ ผลลัพธ์ของการแปลง GOST 28147-89 ครบ 32 รอบจะตรงกับผลลัพธ์ของรอบ 16 ซึ่งผู้เขียนโจมตีใช้ประโยชน์ ในกรณีของวิธี DDS นี่คือเซตของ x โดยที่ F 8 (x) = x (จุดคงที่ของการแปลง F 8) สำหรับข้อความธรรมดาใดๆ จากชุดนี้ การแปลง GOST 28147-89 ทำงานเหมือนกับ 8 รอบล่าสุดทุกประการ ซึ่งทำให้การวิเคราะห์ง่ายขึ้น

ความซับซ้อนของการโจมตี Isobe คือการดำเนินการเข้ารหัส 2224 การโจมตี LDS คือ 2192 อย่างไรก็ตาม คำถามทั้งหมดเกี่ยวกับว่าการโจมตีด้วย Isobe และ DDSH ทำให้เกิดข้อจำกัดใหม่เกี่ยวกับเงื่อนไขสำหรับการใช้อัลกอริทึมของเราหรือไม่นั้นจะถูกลบออกโดยการประเมินข้อกำหนดสำหรับปริมาณของวัสดุที่จำเป็นในการดำเนินการโจมตีแต่ละครั้ง: วิธีการ Isobe จำเป็นต้องใช้ 2 32 คู่ของข้อความธรรมดาและข้อความเข้ารหัส และสำหรับวิธี DDSH - 2 64 . การประมวลผลปริมาณของวัสดุดังกล่าวโดยไม่เปลี่ยนคีย์เป็นสิ่งที่ยอมรับไม่ได้สำหรับรหัสบล็อกใดๆ ที่มีความยาวบล็อก 64: บนวัสดุที่มีปริมาณ 2 32 โดยคำนึงถึงปัญหาวันเกิด (ดูตัวอย่าง สำหรับผู้บุกรุก ความสามารถในการสรุปบางอย่างเกี่ยวกับข้อความธรรมดาจากข้อความไซเฟอร์โดยไม่ต้องกำหนดคีย์ การมีข้อความเปิดและข้อความเข้ารหัส 264 คู่ที่ได้รับบนคีย์เดียวกันทำให้ฝ่ายตรงข้ามสามารถดำเนินการเข้ารหัสและถอดรหัสได้โดยไม่ต้องรู้คีย์นี้เลย นี่เป็นเพราะคุณสมบัติ combinatorial ล้วนๆ: ฝ่ายตรงข้ามในกรณีนี้มีตารางการแปลงการเข้ารหัสทั้งหมด สถานการณ์นี้ไม่สามารถยอมรับได้อย่างแน่นอนภายใต้ข้อกำหนดการปฏิบัติงานที่สมเหตุสมผล ตัวอย่างเช่น ใน CryptoPro CSP มีข้อจำกัดทางเทคนิคเกี่ยวกับจำนวนของเนื้อหาที่เข้ารหัส (โดยไม่มีการแปลงคีย์) ที่ 4 MB (ดู) ดังนั้นข้อห้ามอย่างเข้มงวดในการใช้คีย์บนเนื้อหาของไดรฟ์ข้อมูลดังกล่าวจึงมีอยู่ในรหัสบล็อกใด ๆ ที่มีความยาวบล็อก 64 บิต ดังนั้น Isobe และ DDSH จึงโจมตีโดยไม่ทำให้พื้นที่ใช้งานแคบลง ของอัลกอริทึม GOST 28147-89 ในขณะที่รักษาความปลอดภัยสูงสุดที่เป็นไปได้ 2256 .

แน่นอนว่าควรสังเกตว่านักวิจัย (Isobe และ Dinur-Dankelman-Shamir) แสดงให้เห็นว่าคุณสมบัติบางอย่างของอัลกอริทึม GOST 28147-89 ทำให้สามารถค้นหาเส้นทางการวิเคราะห์ที่ผู้สร้างอัลกอริทึมไม่ได้นำมาพิจารณา รูปแบบง่ายๆ ของกำหนดการคีย์ ซึ่งลดความซับซ้อนของงานในการสร้างการนำไปใช้อย่างมีประสิทธิภาพอย่างมาก ยังช่วยให้สามารถสร้างคำอธิบายที่ง่ายขึ้นของการแปลงที่ดำเนินการโดยอัลกอริทึมสำหรับบางกรณีของคีย์และข้อความธรรมดาที่หายาก

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

เราทราบว่างานของ Dinur, Dankelman และ Shamir มีความประมาทเลินเล่อบางประการในการประมาณค่าแรงงานเฉลี่ย ดังนั้น เมื่อสร้างการโจมตี จะไม่ให้ความสนใจกับประเด็นต่อไปนี้: สำหรับสัดส่วนที่สำคัญของคีย์ ชุดของข้อความธรรมดา x ซึ่ง F 8 (x) = x ว่างเปล่า: การแปลง 8 รอบอาจไม่ใช่เพียงแค่ มีจุดคงที่ การมีอยู่ของจุดคงที่ขึ้นอยู่กับทางเลือกของโหนดทดแทน ดังนั้น การโจมตีจึงใช้ได้เฉพาะกับโหนดและคีย์ทดแทนบางรายการเท่านั้น

นอกจากนี้ยังควรกล่าวถึงอีกหนึ่งผลงานด้วยการโจมตี GOST 28147-89 ในเดือนกุมภาพันธ์ 2555 บทความฉบับปรับปรุง (ลงวันที่พฤศจิกายน 2554) ปรากฏในไฟล์เก็บถาวรอิเล็กทรอนิกส์ ePrint ของสมาคมเข้ารหัสระหว่างประเทศซึ่งมีการโจมตี GOST 28147-89 ใหม่ ลักษณะของการโจมตีที่นำเสนอมีดังนี้: ปริมาตรของวัสดุคือ 232 (เช่นเดียวกับ Isobe) และความเข้มของแรงงานคือ 2192 (เช่นเดียวกับ DDSh) ดังนั้น การโจมตีนี้จึงปรับปรุงการโจมตี LDS ที่ทำลายสถิติในแง่ของปริมาณวัสดุจาก 2 64 เป็น 2 32 เราทราบแยกต่างหากว่าผู้เขียนนำเสนอการคำนวณทั้งหมดโดยสุจริตโดยมีเหตุผลของความซับซ้อนและปริมาณของเนื้อหา หลังจากผ่านไป 9 เดือน พบข้อผิดพลาดพื้นฐานในการคำนวณข้างต้น และตั้งแต่เดือนพฤศจิกายน 2012 บทความเวอร์ชันอัปเดตในไฟล์เก็บถาวรอิเล็กทรอนิกส์จะไม่มีผลลัพธ์ใดๆ เกี่ยวกับอัลกอริทึมภายในประเทศอีกต่อไป

การโจมตีโดยสันนิษฐานว่าผู้โจมตีรู้ "บางอย่าง" เกี่ยวกับกุญแจ

สุดท้ายนี้ เราทราบว่ายังมีผลงานอีกหลายชิ้นในวรรณกรรม (ดูตัวอย่าง และ ) ที่อุทิศให้กับการโจมตี GOST 28147-89 ในรูปแบบที่เรียกว่าด้วยกุญแจเชื่อมโยง แบบจำลองนี้ประกอบด้วยสมมติฐานเกี่ยวกับความเป็นไปได้ของผู้บุกรุกที่จะเข้าถึงการวิเคราะห์ ไม่เพียงแต่กับคู่ของข้อความเปิดและเข้ารหัสโดยใช้คีย์ที่ต้องการเท่านั้น แต่ยังรวมถึงคู่ของข้อความเปิดและข้อความเข้ารหัสที่ได้รับโดยใช้คีย์ (ไม่ทราบเช่นกัน) ที่แตกต่างจาก วิธีปกติที่รู้จักที่ต้องการ (เช่น ในตำแหน่งบิตคงที่) ในแบบจำลองนี้เป็นไปได้ที่จะได้รับผลลัพธ์ที่น่าสนใจเกี่ยวกับ GOST 28147-89 อย่างไรก็ตามในแบบจำลองนี้ไม่สามารถรับผลลัพธ์ที่ชัดเจนได้เช่นมาตรฐาน AES ซึ่งแพร่หลายมากที่สุดในเครือข่ายสาธารณะสมัยใหม่ (ดู , ตัวอย่างเช่น,). โปรดทราบว่าเงื่อนไขสำหรับการโจมตีดังกล่าวเกิดขึ้นเมื่อมีการใช้รหัสในโปรโตคอลบางอย่าง ควรสังเกตว่าผลลัพธ์ประเภทนี้แม้ว่าจะเป็นที่สนใจทางวิชาการอย่างไม่ต้องสงสัยจากมุมมองของการศึกษาคุณสมบัติของการแปลงรหัสลับ แต่จริง ๆ แล้วใช้ไม่ได้กับการปฏิบัติ ตัวอย่างเช่น เครื่องมือป้องกันข้อมูลเข้ารหัสทั้งหมดที่ได้รับการรับรองโดย FSB ของรัสเซีย เป็นไปตามข้อกำหนดที่เข้มงวดที่สุดสำหรับโครงร่างการสร้างคีย์การเข้ารหัส (ดูตัวอย่าง) ตามที่ระบุไว้ในผลการวิเคราะห์ เมื่อมีคีย์ที่เชื่อมโยง 18 คีย์และบล็อกข้อความแบบเปิดและแบบเข้ารหัส 2 10 คู่ ความซับซ้อนของการเปิดคีย์ส่วนตัวโดยสมบูรณ์ด้วยความน่าจะเป็นที่จะสำเร็จ 1-10 -4 นั้นแน่นอน 2 26 . อย่างไรก็ตาม หากตรงตามข้อกำหนดข้างต้นสำหรับการพัฒนาเนื้อหาหลัก ความน่าจะเป็นในการค้นหารหัสดังกล่าวคือ 2 -4352 ซึ่งน้อยกว่าการลองเดารหัสลับในครั้งแรกถึง 24,096 เท่า

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

กากแห้ง: ความต้านทานในทางปฏิบัติคืออะไร?

โดยสรุป เรานำเสนอตารางที่มีข้อมูลเกี่ยวกับผลลัพธ์ทั้งหมดของการโจมตีที่อธิบายไว้อย่างเคร่งครัดและเป็นธรรมใน GOST 28147-89 ซึ่งเป็นที่รู้จักในชุมชนการเข้ารหัสระหว่างประเทศ โปรดทราบว่าความซับซ้อนนั้นกำหนดไว้ในการดำเนินการเข้ารหัสของอัลกอริทึม GOST 28147-89 และมีการระบุหน่วยความจำและวัสดุในบล็อกของอัลกอริทึม (64 บิต = 8 ไบต์)

จู่โจม	ความเข้มของแรงงาน	หน่วยความจำ	วัสดุที่จำเป็น
อิโซเบะ	2 224	2 64	2 32
Dinur-Dunkelman-Shamir, FP, 2DMitM	2 192	2 36	2 64
Dinur-Dunkelman-Shamir, FP, หน่วยความจำต่ำ	2 204	2 19	2 64
	2 224	2 36	2 32
Dinur-Dunkelman-Shamir, ภาพสะท้อน, 2DMitM	2 236	2 19	2 32
กำลังดุร้าย	2 256	1	4
จำนวนนาโนวินาทีตั้งแต่กำเนิดเอกภพ	2 89

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

ในประเทศของเรา อัลกอริทึมแบบครบวงจรสำหรับการแสดงข้อมูลเข้ารหัสสำหรับระบบประมวลผลข้อมูลในเครือข่ายคอมพิวเตอร์ ระบบคอมพิวเตอร์ส่วนบุคคล และคอมพิวเตอร์ ซึ่งกำหนดโดย GOST 28147-89.

อัลกอริธึมการแปลงข้อมูลเข้ารหัสนี้เป็นอัลกอริทึมบล็อก 64 บิตที่มีคีย์ 256 บิต ออกแบบมาสำหรับการใช้งานฮาร์ดแวร์และซอฟต์แวร์ ตรงตามข้อกำหนดการเข้ารหัสและไม่กำหนดข้อจำกัดในระดับความลับของข้อมูลที่ได้รับการปกป้อง

เมื่ออธิบายอัลกอริทึม จะใช้สัญกรณ์ต่อไปนี้:

L และ R เป็นลำดับบิต
LR คือการต่อลำดับ L และ R โดยที่บิตของลำดับ R ตามหลังบิตของลำดับ L
(+) - โมดูโลเพิ่มเติมระดับบิต 2 (การดำเนินการ "พิเศษหรือ");
[+] - การเพิ่มโมดูโลตัวเลข 32 บิต 2 32 ;
(+) - การเพิ่มโมดูโลตัวเลข 32 บิต 2 32 -1

สรุปตัวเลขตามกฎต่อไปนี้:

A[+]B=A+B ถ้า A+B< 2 32 ,
A [+] B = A + B - 2 32 ถ้า A + B >= 2 32 . A (+) B = A + B ถ้า A + B< 2^32 - 1, A {+} B = A + B - (2^32 - 1), если A + B >= 2^32 - 1.

อัลกอริทึมมีสี่โหมดการทำงาน:

ไม่ว่าในกรณีใด คีย์ K 256 บิตจะใช้ในการเข้ารหัสข้อมูล ซึ่งแสดงเป็นคีย์ย่อย 32 บิต 8 คีย์ K i:

K = K 7 K 6 K 5 K 4 K 3 K 2 K 1 K 0 .

การถอดรหัสดำเนินการด้วยคีย์เดียวกับการเข้ารหัส แต่กระบวนการนี้ตรงกันข้ามกับกระบวนการเข้ารหัสข้อมูล

โหมดสลับง่าย

โหมดแรกและง่ายที่สุด - เปลี่ยน. ข้อมูลที่จะเข้ารหัสแบ่งออกเป็นบล็อก 64 บิต ขั้นตอนการเข้ารหัสสำหรับบล็อกข้อมูลเปิด T 0 รวม 32 รอบ (j=1...32)

บล็อก T 0 แบ่งออกเป็นสองลำดับ 32 บิต: B(0)A(0) โดยที่ B(0) เป็นบิตซ้ายหรือบิตที่มีนัยสำคัญมากที่สุด A(0) เป็นบิตขวาหรือบิตที่มีนัยสำคัญน้อยที่สุด

ลำดับเหล่านี้ถูกป้อนลงในไดรฟ์ N 1 และ N 2 ก่อนเริ่มรอบการเข้ารหัสแรก

รอบแรก (j=1) ของขั้นตอนการเข้ารหัสสำหรับบล็อกข้อมูล 64 บิตอธิบายด้วยสูตรต่อไปนี้:

ที่นี่ฉันหมายถึงหมายเลขการวนซ้ำ (i = 1, 2,..., 32)

ฟังก์ชัน f เรียกว่าฟังก์ชันเข้ารหัส อาร์กิวเมนต์คือผลรวมของโมดูโล 2 32 ของจำนวน A(i) ที่ได้จากขั้นตอนการวนซ้ำก่อนหน้าและจำนวน X(j) ของคีย์ (มิติของแต่ละตัวเลขคือ 32 หลัก)

ฟังก์ชันการเข้ารหัสประกอบด้วยสองการดำเนินการกับผลรวม 32 บิตที่เป็นผลลัพธ์ การดำเนินการแรกเรียกว่าการแทนที่ K บล็อกการแทนที่ K ประกอบด้วยโหนดการแทนที่ 8 โหนด K(1) ... K(8) โดยมีหน่วยความจำ 64 บิตในแต่ละโหนด เวกเตอร์ 32 บิตที่มาถึงบล็อกการแทนที่นั้นแบ่งออกเป็นเวกเตอร์ 4 บิตต่อเนื่องกัน 8 ตัว ซึ่งแต่ละตัวจะถูกแปลงเป็นเวกเตอร์ 4 บิตโดยโหนดการแทนที่ที่เกี่ยวข้อง ซึ่งเป็นตารางของจำนวนเต็ม 16 ตัวในช่วง 0.. .15.

เวกเตอร์อินพุตระบุที่อยู่ของแถวในตารางที่มีตัวเลขเป็นเวกเตอร์เอาต์พุต เวกเตอร์เอาต์พุต 4 บิตจะรวมกันเป็นเวกเตอร์ 32 บิตตามลำดับ ตารางบล็อกการแทนที่ K มีองค์ประกอบหลักทั่วไปในเครือข่ายคอมพิวเตอร์และแทบไม่มีการเปลี่ยนแปลง

การดำเนินการที่สองเป็นการเลื่อนวนซ้ายของเวกเตอร์ 32 บิตที่ได้จากการแทนที่ K บล็อกข้อมูลที่เข้ารหัส 64 บิต T w แสดงเป็น T w =A(32)B(32)

บล็อคข้อมูลเปิดที่เหลือในโหมดการแทนที่อย่างง่ายจะถูกเข้ารหัสด้วยวิธีเดียวกัน

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

โหมดแกมมา

ข้อมูลเปิดซึ่งแบ่งออกเป็นบล็อก 64 บิต T(i) (i=1, 2,..., m โดยที่ m ถูกกำหนดโดยจำนวนข้อมูลที่เข้ารหัส) จะถูกเข้ารหัสในโหมดแกมมาโดยการเพิ่มโมดูโล 2 ในระดับบิตด้วย รหัสแกมมา Гw ซึ่งผลิตในบล็อกขนาด 64 บิต เช่น Гw = (Г(1),Г(2),...,Г(i),...,Г(m))

สมการการเข้ารหัสข้อมูลในโหมดแกมมาสามารถแสดงได้ดังนี้:

W(i) = A (Y(i-1) [+] C2, Z(i-1) (+) C1) (+) T(i) = G(i) (+) T(i) .
ที่นี่ W(i) เป็นบล็อกข้อความเข้ารหัส 64 บิต
A - ฟังก์ชันการเข้ารหัสในโหมดการแทนที่อย่างง่าย (อาร์กิวเมนต์ของฟังก์ชันนี้คือตัวเลข 32 บิตสองตัว)
C1 และ C2 - ค่าคงที่ที่ระบุใน GOST 28147-89
Y(i) และ Z(i) เป็นปริมาณที่กำหนดขึ้นซ้ำๆ เมื่อเกิดแกมมาดังนี้:
(Y(0), Z(0)) = A(S) โดยที่ S คือลำดับเลขฐานสอง 64 บิต (ข้อความซิงค์);
(Y(i), Z(i)) = (Y(i-1) [+] C2, Z(i-1) (+) C1) สำหรับ i = 1, 2,...,m

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

โหมดแกมม่าข้อเสนอแนะ

โหมด ปรับขนาดพร้อมข้อเสนอแนะคล้ายกับโหมดแกมมา เช่นเดียวกับในโหมดแกมมา ข้อมูลเปิดที่แบ่งออกเป็นบล็อก 64 บิต T(i) (i=1, 2,..., m , โดยที่ m ถูกกำหนดโดยจำนวนข้อมูลที่เข้ารหัส) จะถูกเข้ารหัสโดยโมดูลการเติมบิต 2 ด้วยรหัสตัวเลขแกมมา G sh ซึ่งผลิตในบล็อก 64 บิต:

Гw = (Г(1),Г(2),...,Г(i),...,Г(m)).

จำนวนบิตในบล็อก T(m) อาจน้อยกว่า 64 ในขณะที่ส่วนของรหัสตัวเลขจากบล็อก G(m) ที่ไม่ได้ใช้สำหรับการเข้ารหัสจะถูกยกเลิก

สมการการเข้ารหัสข้อมูลในโหมดแกมมาพร้อมข้อมูลป้อนกลับสามารถแสดงได้ดังนี้:

ที่นี่ W(i) เป็นบล็อกข้อความเข้ารหัส 64 บิต
A - ฟังก์ชันการเข้ารหัสในโหมดการแทนที่อย่างง่าย อาร์กิวเมนต์ของฟังก์ชันในขั้นตอนแรกของอัลกอริทึมวนซ้ำคือข้อความซิงค์ 64 บิต และในขั้นตอนต่อมาทั้งหมด - บล็อกก่อนหน้าของข้อมูลที่เข้ารหัส W(i-1)

แทรกเลียนแบบ

กระบวนการพัฒนา กองเลียนแบบเป็นรูปแบบเดียวกันสำหรับโหมดการเข้ารหัสข้อมูลใดๆ

การแทรกเลียนแบบเป็นบล็อกของ p บิต (การแทรกเลียนแบบ Ip) ซึ่งเกิดขึ้นก่อนการเข้ารหัสข้อความทั้งหมด หรือควบคู่ไปกับการเข้ารหัสแบบบล็อกต่อบล็อก บล็อกแรกของข้อมูลเปิดที่เกี่ยวข้องกับการพัฒนาการจำลองการแทรกอาจมีข้อมูลการบริการ (เช่น ส่วนที่อยู่ เวลา ข้อความที่ซิงค์) และไม่ถูกเข้ารหัส ค่าของพารามิเตอร์ p (จำนวนของเลขฐานสองในการแทรกจำลอง) ถูกกำหนดโดยข้อกำหนดการเข้ารหัส โดยคำนึงถึงข้อเท็จจริงที่ว่าความน่าจะเป็นของการรบกวนที่ผิดพลาดคือ 1/2^p

ในการรับการเลียนแบบการแทรก ข้อมูลเปิดจะแสดงเป็นบล็อก 64 บิต T(i) (i = 1, 2,..., m โดยที่ m ถูกกำหนดโดยจำนวนข้อมูลที่เข้ารหัส) บล็อกแรกของข้อมูลเปิด T(1) อยู่ภายใต้การเปลี่ยนแปลงที่สอดคล้องกับ 16 รอบแรกของอัลกอริทึมการเข้ารหัสในโหมดการแทนที่อย่างง่าย นอกจากนี้ คีย์ที่ใช้ในการเข้ารหัสข้อมูลยังถูกใช้เป็นคีย์สำหรับสร้างการแทรกเลียนแบบ

จำนวน 64 บิตที่ได้รับหลังจากการทำงาน 16 รอบจะรวมโมดูโล 2 กับบล็อกข้อมูลเปิดที่สอง T(2) ผลรวมจะขึ้นอยู่กับการเปลี่ยนแปลงที่สอดคล้องกับ 16 รอบแรกของอัลกอริทึมการเข้ารหัสในโหมดการแทนที่อย่างง่าย จำนวน 64 บิตที่เป็นผลลัพธ์จะถูกเพิ่มโมดูโล 2 ลงในบล็อกข้อมูลเปิดที่สาม T(3) และต่อไปเรื่อยๆ บล็อกสุดท้าย T(m) หากจำเป็น เสริมบล็อก 64 บิตเต็มด้วยศูนย์ จะถูกรวมเป็นโมดูโล 2 ด้วยผลลัพธ์ของการทำงานในขั้นตอน m-1 หลังจากนั้นจะถูกเข้ารหัสในโหมดการแทนที่อย่างง่ายเหนือบล็อกแรก อัลกอริทึม 16 รอบ จากหมายเลข 64 บิตที่ได้รับ เลือกส่วน Ip ของความยาว p บิต

Ip แทรกเลียนแบบจะถูกส่งผ่านช่องทางการสื่อสารหรือในหน่วยความจำของคอมพิวเตอร์หลังจากข้อมูลที่เข้ารหัส ข้อมูลที่เข้ารหัสขาเข้าจะถูกถอดรหัสและจากบล็อกที่ได้รับของข้อมูลเปิด T(i) จะมีการสร้าง Ip แทรกเลียนแบบ ซึ่งจะถูกเปรียบเทียบกับ IR แทรกเลียนแบบที่ได้รับจากช่องทางการสื่อสารหรือจากหน่วยความจำคอมพิวเตอร์ หากการแทรก เลียนแบบ ไม่ตรงกัน ข้อมูลที่ถอดรหัสทั้งหมดถือเป็นเท็จ

อัลกอริทึมการเข้ารหัส GOST 28147-89 การใช้งานและการใช้งานซอฟต์แวร์สำหรับคอมพิวเตอร์ของแพลตฟอร์ม Intel x86

อันเดรย์ วิโนคูรอฟ

คำอธิบายของอัลกอริทึม

ข้อกำหนดและการกำหนด

คำอธิบายของมาตรฐานการเข้ารหัสของสหพันธรัฐรัสเซียมีอยู่ในเอกสารที่น่าสนใจมากเรื่อง "GOST 28147-89 Cryptographic Transformation Algorithm" ความจริงที่ว่าในชื่อของมัน แทนที่จะเป็นคำว่า "การเข้ารหัส" ซึ่งเป็นแนวคิดทั่วไปมากกว่า " การแปลงรหัสลับ 'ไม่ใช่เรื่องบังเอิญ นอกเหนือจากขั้นตอนการเข้ารหัสที่เกี่ยวข้องอย่างใกล้ชิดหลายขั้นตอน เอกสารยังอธิบายอัลกอริทึมหนึ่งสำหรับการสร้าง แทรกเลียนแบบ . ส่วนหลังไม่มีอะไรมากไปกว่าชุดค่าผสมการควบคุมการเข้ารหัส นั่นคือรหัสที่สร้างจากข้อมูลต้นฉบับโดยใช้รหัสลับเพื่อ ป้องกันการเลียนแบบ หรือปกป้องข้อมูลจากการเปลี่ยนแปลงที่ไม่ได้รับอนุญาต

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

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

หากองค์ประกอบข้อมูลประกอบด้วยหลายองค์ประกอบที่มีขนาดเล็กกว่า ข้อเท็จจริงนี้จะถูกระบุดังนี้: เอ็กซ์=(เอ็กซ์ 0 ,เอ็กซ์ 1 ,…,เอ็กซ์ เอ็น –1)=เอ็กซ์ 0 ||เอ็กซ์ 1 ||…||เอ็กซ์ เอ็น-1 . ขั้นตอนสำหรับการรวมองค์ประกอบข้อมูลหลายรายการเข้าด้วยกันเรียกว่า การต่อข้อมูล ข้อมูลและแสดงด้วยสัญลักษณ์ "||" โดยปกติแล้ว ความสัมพันธ์ต่อไปนี้จะต้องมีขนาดองค์ประกอบข้อมูล: | เอ็กซ์|=|เอ็กซ์ 0 |+|เอ็กซ์ 1 |+…+|เอ็กซ์ เอ็น-1 |. เมื่อระบุองค์ประกอบข้อมูลที่ซับซ้อนและการดำเนินการต่อข้อมูล องค์ประกอบข้อมูลที่เป็นส่วนประกอบจะแสดงรายการตามลำดับความสำคัญจากน้อยไปหามาก กล่าวอีกนัยหนึ่ง หากเราตีความองค์ประกอบแบบผสมและองค์ประกอบข้อมูลทั้งหมดที่รวมอยู่ในนั้นเป็นจำนวนเต็มที่ไม่มีเครื่องหมาย เราก็สามารถเขียนความเท่าเทียมกันได้ดังต่อไปนี้:

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

เอ็กซ์=(x 0 ,x 1 ,…,x n –1)=x 0 +2 1 x 1 +…+2 น-1 · x n –1 .

ดังนั้นหากคุณให้ความสนใจสิ่งที่เรียกว่า "little-endian" จำนวนหลักเช่น ภายในคำข้อมูลหลายบิต เลขฐานสองแต่ละหลักและกลุ่มของเลขฐานสองที่มีจำนวนน้อยกว่าจะมีนัยสำคัญน้อยกว่า สิ่งนี้ระบุไว้อย่างชัดเจนในย่อหน้าที่ 1.3 ของมาตรฐาน: "เมื่อเพิ่มและเปลี่ยนไบนารี่เวกเตอร์เป็นวงกลม บิตสูงสุดคือบิตของตัวสะสมที่มีจำนวนมาก" นอกจากนี้ย่อหน้าของมาตรฐาน 1.4, 2.1.1 และอื่น ๆ กำหนดให้เริ่มกรอกการลงทะเบียนที่เก็บข้อมูลของอุปกรณ์เข้ารหัสเสมือนด้วยข้อมูลจากรายการที่ต่ำกว่าเช่น อันดับที่มีความสำคัญน้อยกว่า มีการใช้ลำดับหมายเลขเดียวกันทุกประการในสถาปัตยกรรมไมโครโปรเซสเซอร์ Intel x86 ซึ่งเป็นสาเหตุที่การใช้ซอฟต์แวร์ของการเข้ารหัสบนสถาปัตยกรรมนี้ไม่จำเป็นต้องมีการเรียงสับเปลี่ยนบิตเพิ่มเติมภายในคำข้อมูล

หากมีการดำเนินการบางอย่างกับองค์ประกอบข้อมูลที่มีความหมายเชิงตรรกะ ก็จะถือว่าการดำเนินการนี้ดำเนินการกับบิตที่สอดคล้องกันขององค์ประกอบ กล่าวอีกนัยหนึ่ง ก ข=(ก 0 ข 0 ,ก 1 ข 1 ,…,หนึ่ง –1 ข n–1) โดยที่ น=|ก|=|ข| และสัญลักษณ์ " " หมายถึงการดำเนินการทางตรรกะแบบไบนารีตามอำเภอใจ มักจะหมายถึงการดำเนินการ แต่เพียงผู้เดียวหรือ ซึ่งเป็นการทำงานของผลรวมโมดูโล 2 ด้วย:

ตรรกะของการสร้างรหัสและโครงสร้างของข้อมูลสำคัญของ GOST

หากคุณศึกษา GOST 28147–89 ต้นฉบับอย่างละเอียด คุณจะสังเกตเห็นว่ามีคำอธิบายของอัลกอริทึมหลายระดับ ที่ด้านบนสุดคืออัลกอริทึมเชิงปฏิบัติที่ออกแบบมาเพื่อเข้ารหัสอาร์เรย์ข้อมูลและพัฒนาส่วนแทรกปลอมสำหรับพวกมัน ทั้งหมดนี้ใช้อัลกอริธึมระดับล่าง 3 รายการที่เรียกว่า GOST ในข้อความ รอบ . อัลกอริทึมพื้นฐานเหล่านี้ถูกอ้างถึงในบทความนี้ว่า รอบพื้นฐาน เพื่อแยกความแตกต่างจากลูปอื่นๆ ทั้งหมด พวกมันมีชื่อและตำแหน่งดังต่อไปนี้ ส่วนหลังจะอยู่ในวงเล็บ และความหมายจะอธิบายในภายหลัง:

• รอบการเข้ารหัส (32-3);
• รอบการถอดรหัส (32-P);
• รอบการสร้างเม็ดมีดเลียนแบบ (16-Z)

ในทางกลับกัน แต่ละรอบพื้นฐานเป็นการทำซ้ำหลายๆ รอบของขั้นตอนเดียว ซึ่งเรียกว่าเพื่อความชัดเจนยิ่งขึ้นในงานนี้ ขั้นตอนหลักของการเปลี่ยนแปลง crypto .

ดังนั้น เพื่อให้เข้าใจ GOST คุณต้องเข้าใจสามสิ่งต่อไปนี้:

• เกิดอะไรขึ้น ขั้นตอนพื้นฐาน การแปลงรหัสลับ
• วงจรพื้นฐานเกิดจากขั้นตอนหลักอย่างไร
• เหมือนออกสาม รอบพื้นฐาน รวมอัลกอริทึมเชิงปฏิบัติทั้งหมดของ GOST

ก่อนที่จะดำเนินการศึกษาประเด็นเหล่านี้ เราควรพูดคุยเกี่ยวกับข้อมูลสำคัญที่อัลกอริทึม GOST ใช้ ตามหลักการของ Kirchhoff ซึ่งเป็นที่พอใจของนักเข้ารหัสสมัยใหม่ทุกคนที่รู้จักกันทั่วไป มันเป็นความลับที่รับประกันความลับของข้อความที่เข้ารหัส ใน GOST ข้อมูลสำคัญประกอบด้วยสองโครงสร้างข้อมูล นอกจาก สำคัญ จำเป็นสำหรับรหัสทั้งหมดนอกจากนี้ยังมี ตารางการเปลี่ยนตัว . ด้านล่างนี้เป็นลักษณะสำคัญของโครงสร้างหลักของ GOST

ขั้นตอนหลักของการเปลี่ยนแปลง crypto

ขั้นตอนการแปลงรหัสลับหลักคือตัวดำเนินการที่กำหนดการแปลงบล็อกข้อมูล 64 บิต พารามิเตอร์เพิ่มเติมของตัวดำเนินการนี้คือบล็อก 32 บิตซึ่งใช้เป็นองค์ประกอบใด ๆ ของคีย์ แผนผังของอัลกอริทึมขั้นตอนหลักแสดงในรูปที่ 1

รูปที่ 1 แผนผังของขั้นตอนหลักของการแปลงรหัสลับของอัลกอริทึม GOST 28147-89

ด้านล่างนี้คือคำอธิบายของอัลกอริทึมขั้นตอนหลัก:

ขั้นตอนที่ 0

• เอ็น– บล็อกข้อมูล 64 บิตที่จะแปลง ในระหว่างการดำเนินการขั้นตอนนั้นมีความสำคัญน้อยที่สุด ( เอ็น 1) และเก่ากว่า ( เอ็น 2) ส่วนต่าง ๆ จะถือว่าเป็นจำนวนเต็ม 32 บิตที่ไม่ได้ลงนามแยกต่างหาก ดังนั้นจึงสามารถเขียน ยังไม่มีข้อความ=(เอ็น 1 ,เอ็น 2).
• เอ็กซ์- องค์ประกอบคีย์ 32 บิต;

ขั้นตอนที่ 1

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

ขั้นตอนที่ 2

การเปลี่ยนบล็อก ค่า 32 บิตที่ได้รับในขั้นตอนก่อนหน้านี้ถูกตีความเป็นอาร์เรย์ของบล็อกโค้ด 4 บิตแปดบล็อก: ส=(ส 0 , ส 1 , ส 2 , ส 3 , ส 4 , ส 5 , ส 6 , ส 7) และ ส 0 ประกอบด้วยตัวที่เล็กที่สุด 4 ตัว และ ส 7 - 4 บิตที่สำคัญที่สุด ส.

ถัดไป ค่าของแต่ละบล็อกจากแปดบล็อกจะถูกแทนที่ด้วยค่าใหม่ซึ่งเลือกจากตารางการแทนที่ดังนี้: ค่าของบล็อก ศรีเปลี่ยนเป็น ศรีองค์ประกอบลำดับที่ -th (หมายเลขจากศูนย์) ฉัน- ของโหนดแทนที่นั้น (เช่น ฉันบรรทัดที่ -th ของตารางการแทนที่ เลขจากศูนย์เช่นกัน) กล่าวอีกนัยหนึ่ง ในการแทนที่ค่าบล็อก องค์ประกอบจะถูกเลือกจากตารางแทนที่ด้วยหมายเลขแถวเท่ากับหมายเลขบล็อกแทนที่และหมายเลขคอลัมน์เท่ากับค่าบล็อกแทนที่เป็นจำนวนเต็ม 4 บิตที่ไม่เป็นลบ จากนี้ ขนาดของตารางการแทนที่จะชัดเจน: จำนวนแถวในนั้นเท่ากับจำนวนองค์ประกอบ 4 บิตในบล็อกข้อมูล 32 บิต นั่นคือแปด และจำนวนคอลัมน์เท่ากับ จำนวนค่าต่าง ๆ ของบล็อกข้อมูล 4 บิตซึ่งทราบกันดีว่าเป็น 2 4, 16

ขั้นตอนที่ 3

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

ขั้นตอนที่ 4

การเพิ่มบิต: ค่าที่ได้รับในขั้นตอนที่ 3 จะถูกเพิ่มโมดูโล 2 ทีละบิตไปยังครึ่งสูงของบล็อกที่กำลังแปลง

ขั้นตอนที่ 5

เลื่อนไปตามห่วงโซ่: ส่วนล่างของบล็อกที่แปลงแล้วจะถูกเลื่อนไปยังตำแหน่งของบล็อกที่เก่ากว่าและผลลัพธ์ของขั้นตอนก่อนหน้าจะถูกแทนที่

ขั้นตอนที่ 6

ค่าผลลัพธ์ของบล็อกที่จะแปลงจะถูกส่งคืนตามผลการดำเนินการของอัลกอริทึมของขั้นตอนการแปลงรหัสลับหลัก

รอบพื้นฐานของการแปลงรหัสลับ

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

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

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

รอบการเข้ารหัส 32-Z:

เค 0 ,เค 1 ,เค 2 ,เค 3 ,เค 4 ,เค 5 ,เค 6 ,เค 7 ,เค 0 ,เค 1 ,เค 2 ,เค 3 ,เค 4 ,เค 5 ,เค 6 ,เค 7 ,เค 0 ,เค 1 ,เค 2 ,เค 3 ,เค 4 ,เค 5 ,เค 6 ,เค 7 ,เค 7 ,เค 6 ,เค 5 ,เค 4 ,เค 3 ,เค 2 ,เค 1 ,เค 0 .

รูปที่ 2a วงจรการเข้ารหัส 32-3

รอบการถอดรหัส 32-P:

เค 0 ,เค 1 ,เค 2 ,เค 3 ,เค 4 ,เค 5 ,เค 6 ,เค 7 ,เค 7 ,เค 6 ,เค 5 ,เค 4 ,เค 3 ,เค 2 ,เค 1 ,เค 0 ,เค 7 ,เค 6 ,เค 5 ,เค 4 ,เค 3 ,เค 2 ,เค 1 ,เค 0 ,เค 7 ,เค 6 ,เค 5 ,เค 4 ,เค 3 ,เค 2 ,เค 1 ,เค 0 .

รูปที่ 2b แผนภาพวงจรถอดรหัส 32-P

วัฏจักรสำหรับการผลิตเม็ดมีดเลียนแบบ 16-З:

เค 0 ,เค 1 ,เค 2 ,เค 3 ,เค 4 ,เค 5 ,เค 6 ,เค 7 ,เค 0 ,เค 1 ,เค 2 ,เค 3 ,เค 4 ,เค 5 ,เค 6 ,เค 7 .

รูปที่ 2c วงจรการผลิตเม็ดมีดเลียนแบบ 16-З

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

วงจรการถอดรหัสควรเป็นการย้อนกลับของวงจรการเข้ารหัส นั่นคือ การใช้ลำดับของสองวงจรนี้กับบล็อกโดยพลการควรส่งผลให้เกิดบล็อกดั้งเดิม ซึ่งสะท้อนให้เห็นโดยความสัมพันธ์ต่อไปนี้: ค 32-R ( ค 32-З ( ต))= ที, ที่ไหน ต– บล็อกข้อมูล 64 บิตตามอำเภอใจ คเอ็กซ์( ต) เป็นผลลัพธ์ของลูป เอ็กซ์เหนือบล็อกข้อมูล ต. เพื่อให้เป็นไปตามเงื่อนไขนี้สำหรับอัลกอริทึมที่คล้ายกับ GOST มีความจำเป็นและเพียงพอที่ลำดับที่องค์ประกอบหลักจะถูกใช้โดยวัฏจักรที่สอดคล้องกันนั้นจะกลับกัน ง่ายต่อการตรวจสอบความถูกต้องของเงื่อนไขที่เป็นลายลักษณ์อักษรสำหรับกรณีที่อยู่ระหว่างการพิจารณาโดยการเปรียบเทียบลำดับข้างต้นสำหรับรอบ 32-3 และ 32-P ผลลัพธ์ที่น่าสนใจประการหนึ่งตามมาจากที่กล่าวมาแล้ว: คุณสมบัติของวัฏจักรที่จะตรงกันข้ามกับวัฏจักรอื่นนั้นมีผลร่วมกัน กล่าวคือ วัฏจักร 32-3 จะผกผันกับวัฏจักร 32-P กล่าวอีกนัยหนึ่ง การเข้ารหัสบล็อกข้อมูลในทางทฤษฎีสามารถทำได้ด้วยลูปการถอดรหัส ซึ่งในกรณีนี้การถอดรหัสบล็อกข้อมูลจะต้องทำด้วยลูปการเข้ารหัส จากสองวงจรที่ผกผันร่วมกัน วงจรหนึ่งสามารถใช้สำหรับการเข้ารหัส จากนั้นต้องใช้วงจรที่สองเพื่อถอดรหัสข้อมูล อย่างไรก็ตาม มาตรฐาน GOST28147-89 กำหนดบทบาทให้กับวงจรและไม่ให้สิทธิ์แก่ผู้ใช้ในการเลือกในเรื่องนี้ .

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

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

โหมดการเข้ารหัสพื้นฐาน

GOST 28147-89 มีโหมดการเข้ารหัสข้อมูลสามโหมดต่อไปนี้:

• เปลี่ยนง่าย
• การเล่นเกม,
• แกมมาข้อเสนอแนะ

และอีกหนึ่งโหมดในการสร้างการแทรกเลียนแบบ

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

ก่อนดำเนินการพิจารณาอัลกอริทึมเฉพาะสำหรับการแปลงการเข้ารหัส จำเป็นต้องชี้แจงสัญกรณ์ที่ใช้ในไดอะแกรมในส่วนต่อไปนี้:

ตโอ ต w เป็นอาร์เรย์ของข้อมูลเปิดและเข้ารหัสตามลำดับ

, – ฉัน- บล็อกข้อมูลเปิดและเข้ารหัส 64 บิตตามลำดับ: , บล็อกสุดท้ายอาจไม่สมบูรณ์: ;

น– จำนวนบล็อก 64 บิตในอาร์เรย์ข้อมูล

ค X เป็นฟังก์ชันของการแปลงบล็อกข้อมูล 64 บิตตามอัลกอริทึมของวงจรพื้นฐาน "X"

ตอนนี้เรามาอธิบายโหมดการเข้ารหัสหลัก:

เปลี่ยนง่าย

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

การวาดภาพ. 3ก. อัลกอริทึมการเข้ารหัสข้อมูลในโหมดการแทนที่อย่างง่าย

การวาดภาพ. 3ข. อัลกอริธึมการถอดรหัสข้อมูลในโหมดการแทนที่อย่างง่าย

ขนาดของอาร์เรย์ของข้อมูลแบบเปิดหรือแบบเข้ารหัส ซึ่งอยู่ภายใต้การเข้ารหัสหรือถอดรหัสตามลำดับ จะต้องเป็นจำนวนทวีคูณของ 64 บิต: | ต o |=| ต ว |=64 น หลังจากดำเนินการแล้ว ขนาดของอาร์เรย์ข้อมูลที่ได้รับจะไม่เปลี่ยนแปลง

โหมดการเข้ารหัสแบบแทนที่อย่างง่ายมีคุณสมบัติดังต่อไปนี้:

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

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

การพนัน.

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

ตอนนี้ไปที่คำอธิบายของโหมดแกมม่าโดยตรง แกมมาสำหรับโหมดนี้ได้รับดังต่อไปนี้: การใช้ตัวสร้างลำดับเลขซ้ำแบบอัลกอริทึม (RGCH) บล็อกข้อมูล 64 บิตจะถูกสร้างขึ้น ซึ่งจากนั้นจะถูกแปลงเป็น 32-3 นั่นคือการเข้ารหัสในโหมดการแทนที่อย่างง่าย ส่งผลให้ ในบล็อกแกมมา เนื่องจากการซ้อนทับและการลบแกมมานั้นดำเนินการโดยใช้การดำเนินการ XOR บิตเดียวกัน อัลกอริทึมการเข้ารหัสและถอดรหัสในโหมดแกมมาจึงเหมือนกัน โครงร่างทั่วไปจะแสดงในรูปที่ 4

RGHR ที่ใช้สร้างสเกลเป็นฟังก์ชันที่เกิดซ้ำ: – องค์ประกอบของลำดับที่เกิดซ้ำ ฉเป็นฟังก์ชันการแปลง ดังนั้น คำถามเกี่ยวกับการเริ่มต้นจึงเกิดขึ้นอย่างหลีกเลี่ยงไม่ได้ นั่นคือ เกี่ยวกับองค์ประกอบ อันที่จริง องค์ประกอบข้อมูลนี้เป็นพารามิเตอร์อัลกอริทึมสำหรับโหมดแกมมา สและถูกเรียกในการเข้ารหัส ซิงค์ข้อความ และใน GOST ของเรา - การเติมเริ่มต้น หนึ่งในการลงทะเบียนเข้ารหัส ด้วยเหตุผลบางประการ ผู้พัฒนา GOST จึงตัดสินใจใช้ RGHR ไม่ใช่ข้อความซิงค์โดยตรง แต่เป็นผลมาจากการเปลี่ยนแปลงตามรอบ 32-3: . ลำดับขององค์ประกอบที่สร้างโดย RGHR ขึ้นอยู่กับการเติมเริ่มต้นทั้งหมด นั่นคือ องค์ประกอบของลำดับนี้เป็นฟังก์ชันของจำนวนและการเติมเริ่มต้นของ RGHR: โดยที่ ไฟ(เอ็กซ์)=ฉ(ไฟ –1 (เอ็กซ์)), ฉ 0 (เอ็กซ์)=เอ็กซ์. โดยคำนึงถึงการเปลี่ยนแปลงตามอัลกอริทึมการแทนที่อย่างง่าย การพึ่งพาคีย์จะถูกเพิ่มเข้าไปด้วย:

ที่ไหน จี ไอ– ฉัน-th องค์ประกอบของมาตราส่วน เค- สำคัญ.

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

ทีนี้มาดูรายละเอียดเกี่ยวกับ RGHR ที่ใช้ใน GOST เพื่อสร้างองค์ประกอบแกมมา ประการแรก ควรสังเกตว่าไม่จำเป็นต้องระบุลักษณะทางสถิติใดๆ ของลำดับตัวเลขที่สร้างขึ้น RGHR ได้รับการออกแบบโดยนักพัฒนา GOST ตามความต้องการในการปฏิบัติตามเงื่อนไขต่อไปนี้:

• ระยะเวลาการทำซ้ำของลำดับตัวเลขที่สร้างโดย RGHR ไม่ควรแตกต่างกันมาก (ในรูปเปอร์เซ็นต์) จากค่าที่เป็นไปได้สูงสุดที่ 2 64 สำหรับขนาดบล็อกที่กำหนด
• ค่าใกล้เคียงที่ผลิตโดย RGHR จะต้องแตกต่างกันในแต่ละไบต์ มิฉะนั้นงานของ cryptanalyst จะง่ายขึ้น
• RGHR ควรใช้งานได้ค่อนข้างง่ายทั้งในฮาร์ดแวร์และซอฟต์แวร์บนโปรเซสเซอร์ทั่วไป ซึ่งส่วนใหญ่อย่างที่คุณทราบมีความจุ 32 บิต

ตามหลักการเหล่านี้ ผู้สร้าง GOST ได้ออกแบบ RGHR ที่ประสบความสำเร็จอย่างมาก ซึ่งมีลักษณะดังต่อไปนี้:

ที่ไหน ค 0 =1010101 16 ;

ที่ไหน ค 1 =1010104 16 ;

ตัวห้อยในสัญกรณ์ของตัวเลขหมายถึงระบบตัวเลข ดังนั้นค่าคงที่ที่ใช้ในขั้นตอนนี้จึงเขียนในระบบเลขฐานสิบหก

นิพจน์ที่สองต้องการความคิดเห็น เนื่องจากมีการกำหนดอย่างอื่นในข้อความ GOST: โดยมีค่าคงที่เท่ากัน ค 1 . แต่เพิ่มเติมในข้อความของมาตรฐานมีการแสดงความคิดเห็นว่าภายใต้การดำเนินการของโมดูโลที่เหลือ 2 32 -1 ที่นั่นมีความเข้าใจไม่เหมือนกับในวิชาคณิตศาสตร์ ความแตกต่างอยู่ในความจริงที่ว่าตาม GOST (2 32 -1) ม็อด(2 32 –1)=(2 32 –1) ไม่ใช่ 0 อันที่จริง สิ่งนี้ทำให้การนำสูตรไปใช้ง่ายขึ้น และนิพจน์ที่ถูกต้องทางคณิตศาสตร์สำหรับสูตรนั้นแสดงไว้ข้างต้น

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

แผนผังของอัลกอริทึมการเข้ารหัสในโหมดแกมมาแสดงอยู่ในรูปที่ 4 ด้านล่างนี้เป็นคำอธิบายสำหรับโครงร่าง:

รูปที่ 4 อัลกอริทึมการเข้ารหัสข้อมูล (ถอดรหัส) ในโหมดแกมมา

ขั้นตอนที่ 0

กำหนดข้อมูลเริ่มต้นสำหรับขั้นตอนการแปลงรหัสลับหลัก:

• ต o(w) - อาร์เรย์ของข้อมูลเปิด (เข้ารหัส) ที่มีขนาดตามอำเภอใจภายใต้ขั้นตอนการเข้ารหัส (ถอดรหัส) ในระหว่างขั้นตอน อาร์เรย์จะถูกแปลงเป็นส่วน 64 บิต
• ส – ซิงค์ข้อความ องค์ประกอบข้อมูล 64 บิตที่จำเป็นในการเริ่มต้นเครื่องกำเนิดแกมมา

ขั้นตอนที่ 1

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

ขั้นตอนที่ 2

ขั้นตอนหนึ่งของการทำงานของ RGHR ซึ่งใช้อัลกอริทึมที่เกิดซ้ำ ในระหว่างขั้นตอนนี้ ยิ่งเก่ากว่า ( ส 1) และอายุน้อยกว่า ( ส 0) ส่วนของลำดับข้อมูลถูกสร้างขึ้นโดยอิสระจากกัน;

ขั้นตอนที่ 3

การพนัน. องค์ประกอบ 64 บิตถัดไปที่ผลิตโดย RGHR จะต้องผ่านขั้นตอนการเข้ารหัสในรอบ 32-3 ผลลัพธ์จะถูกใช้เป็นองค์ประกอบแกมมาเพื่อเข้ารหัส (ถอดรหัส) บล็อกถัดไปของข้อมูลเปิด (เข้ารหัส) ที่มีขนาดเท่ากัน

ขั้นตอนที่ 4

ผลลัพธ์ของอัลกอริทึมคืออาร์เรย์ข้อมูลที่เข้ารหัส (ถอดรหัส)

ต่อไปนี้คือคุณสมบัติของแกมมาเป็นโหมดการเข้ารหัส:

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

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

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

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

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

ซึ่งหมายถึงฤๅษีด้วยความเคารพ ทีค่าบิต ()

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

การพนันกับข้อเสนอแนะ

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

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

รูปที่ 5 อัลกอริทึมสำหรับการเข้ารหัสข้อมูล (ถอดรหัส) ในโหมดแกมม่าพร้อมข้อเสนอแนะ

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

การเล่นเกม;

การเล่นเกมพร้อมข้อเสนอแนะ

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

การพัฒนาการจำลองการแทรกข้อมูลในอาร์เรย์

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

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

• การคำนวณการจำลองการแทรกสำหรับอาร์เรย์เปิดของข้อมูลที่กำหนด
• การเลือกข้อมูลเปิดสำหรับการแทรกการจำลองที่กำหนด

แผนผังของอัลกอริทึมสำหรับการสร้างเม็ดมีดจำลองแสดงในรูปที่ 6

รูปที่ 6 อัลกอริทึมสำหรับสร้างส่วนแทรกจำลองสำหรับอาร์เรย์ข้อมูล

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

การอภิปรายเกี่ยวกับอัลกอริธึมการเข้ารหัส GOST

ความแข็งแกร่งในการเข้ารหัสของ GOST

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

• เป็นไปได้ไหมที่จะเปิดรหัสนี้เลย
• ถ้าเป็นเช่นนั้นในทางปฏิบัติจะยากเพียงใด

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

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

GOST ใช้คีย์ 256 บิตและขนาดของพื้นที่คีย์คือ 2256 ไม่มีอุปกรณ์อิเล็กทรอนิกส์ใดที่มีอยู่ในปัจจุบันหรือคาดว่าจะถูกนำมาใช้ในอนาคตอันใกล้นี้ที่สามารถรับกุญแจได้ในเวลาน้อยกว่าหลายร้อยปี ค่านี้ได้กลายเป็นมาตรฐานขนาดคีย์โดยพฤตินัยสำหรับอัลกอริทึมการเข้ารหัสแบบสมมาตรในปัจจุบัน และมาตรฐานการเข้ารหัสใหม่ของสหรัฐอเมริกาก็รองรับเช่นกัน มาตรฐานเดิมของอเมริกา DES ที่มีขนาดคีย์จริง 56 บิตและขนาดพื้นที่คีย์เพียง 256 ไม่แข็งแรงพอในแง่ของความสามารถของเครื่องมือคอมพิวเตอร์สมัยใหม่ สิ่งนี้แสดงให้เห็นในช่วงปลายทศวรรษ 1990 โดยการโจมตี DES แบบเดรัจฉานหลายครั้งที่ประสบความสำเร็จ นอกจากนี้ DES ยังใช้วิธีการเข้ารหัสแบบพิเศษ เช่น ดิฟเฟอเรนเชียลและลิเนียร์ ในเรื่องนี้ DES อาจมีความสนใจในการวิจัยหรือวิทยาศาสตร์มากกว่าความสนใจในทางปฏิบัติ ในปี 1998 จุดอ่อนในการเข้ารหัสได้รับการยอมรับอย่างเป็นทางการ - สถาบันมาตรฐานแห่งชาติของสหรัฐอเมริกาแนะนำให้ใช้การเข้ารหัสสาม DES และในตอนท้ายของปี 2544 มาตรฐานการเข้ารหัสใหม่ของสหรัฐอเมริกา AES ก็ได้รับการอนุมัติอย่างเป็นทางการ สร้างขึ้นบนหลักการที่แตกต่างกันและปราศจากข้อบกพร่องของรุ่นก่อนหน้า

หมายเหตุเกี่ยวกับสถาปัตยกรรมของ GOST

เป็นที่ทราบกันดีว่ามาตรฐานการเข้ารหัสภายในประเทศนั้นเป็นตัวแทนของรหัสลับทั้งตระกูลที่สร้างขึ้นบนหลักการเดียวกัน "ญาติ" ที่มีชื่อเสียงที่สุดของมันคือมาตรฐานการเข้ารหัสของอเมริกาในอดีต อัลกอริทึม DES รหัสเหล่านี้ทั้งหมด เช่น GOST มีอัลกอริทึมสามระดับ พื้นฐานคือ "ขั้นตอนพื้นฐาน" ที่แน่นอนเสมอ โดยพื้นฐานแล้ว "วงจรพื้นฐาน" ถูกสร้างขึ้นในลักษณะเดียวกัน และขั้นตอนการปฏิบัติสำหรับการเข้ารหัสและการพัฒนาของการแทรกเลียนแบบนั้นถูกสร้างขึ้นบนพื้นฐานแล้ว ดังนั้นความเฉพาะเจาะจงของรหัสแต่ละตัวของตระกูลนี้จึงอยู่ในขั้นตอนหลักอย่างแม่นยำหรือแม้กระทั่งในส่วนของมัน แม้ว่าสถาปัตยกรรมของบล็อกรหัสแบบคลาสสิกซึ่งเป็นของ GOST นั้นอยู่นอกเหนือขอบเขตของบทความนี้ แต่ก็ยังคุ้มค่าที่จะพูดสองสามคำเกี่ยวกับเรื่องนี้

อัลกอริทึมสำหรับ "ขั้นตอนพื้นฐานของการแปลงรหัสลับ" สำหรับรหัสเช่น GOST นั้นถูกสร้างขึ้นในลักษณะเดียวกัน และสถาปัตยกรรมนี้เรียกว่า เครือข่าย Feistel ที่สมดุล (เครือข่าย Feistel ที่สมดุล) ตั้งชื่อตามบุคคลที่เสนอครั้งแรก รูปแบบการแปลงข้อมูลในหนึ่งรอบหรือที่เรียกกันทั่วไปว่า กลม แสดงในรูปที่ 7

รูปที่ 7 เนื้อหาของขั้นตอนการแปลงรหัสลับหลักสำหรับรหัสบล็อกที่คล้ายกับ GOST

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

หากเราใช้ข้างต้นกับโครงร่างของขั้นตอนหลักของอัลกอริทึม GOST จะเห็นได้ชัดว่าบล็อก 1,2,3 ของอัลกอริทึม (ดูรูปที่ 1) กำหนดการคำนวณฟังก์ชันการเข้ารหัสและบล็อก 4 และ 5 ตั้ง การก่อตัวของบล็อกเอาต์พุตของขั้นตอนหลักตามเนื้อหาของบล็อกอินพุตและค่าของฟังก์ชันการเข้ารหัส รายละเอียดเพิ่มเติมเกี่ยวกับสถาปัตยกรรมของบล็อกรหัสสมัยใหม่ที่มีรหัสลับสามารถพบได้ในผลงานคลาสสิก หรือในรูปแบบดัดแปลงในงานของฉัน

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

ไม่มีการใช้งาน DES ใดที่ผู้เขียนพิจารณาสำหรับแพลตฟอร์ม Intel x86 บรรลุประสิทธิภาพแม้แต่ครึ่งหนึ่งของการใช้งาน GOST ที่เสนอให้คุณทราบในบทความนี้ แม้ว่ารอบการทำงานจะสั้นกว่าสองเท่าก็ตาม ทั้งหมดข้างต้นบ่งชี้ว่านักพัฒนา GOST คำนึงถึงทั้งด้านบวกและด้านลบของ DES และยังประเมินความเป็นไปได้ในปัจจุบันและอนาคตของการเข้ารหัสอย่างสมจริงยิ่งขึ้น อย่างไรก็ตาม การใช้ DES เป็นพื้นฐานเมื่อเปรียบเทียบประสิทธิภาพของการใช้งานรหัสนั้นไม่เกี่ยวข้องอีกต่อไป มาตรฐานการเข้ารหัสใหม่ของสหรัฐอเมริกามีประสิทธิภาพดีขึ้นมาก ด้วยขนาดคีย์เดียวกับ GOST ที่ 256 บิต AES ทำงานได้เร็วกว่ามาตรฐานนี้ประมาณ 14% ซึ่งเมื่อเทียบตามจำนวนของ "การดำเนินการเบื้องต้น" นอกจากนี้ GOST แทบจะเป็นไปไม่ได้ที่จะขนานกันในขณะที่ AES มีโอกาสมากขึ้นในเรื่องนี้ ในบางสถาปัตยกรรม ประโยชน์ของ AES อาจน้อยกว่านี้ สำหรับบางสถาปัตยกรรมอาจมากกว่านั้น ดังนั้นในโปรเซสเซอร์ Intel Pentium จึงสูงถึง 28% สามารถดูรายละเอียดได้ใน

ข้อกำหนดด้านคุณภาพของข้อมูลที่สำคัญและแหล่งที่มาที่สำคัญ

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

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

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

สำคัญ

คีย์ต้องเป็นอาร์เรย์ของบิตอิสระทางสถิติที่ใช้ค่า 0 และ 1 ด้วยความน่าจะเป็นเท่าๆ กัน ไม่สามารถตัดออกได้อย่างสมบูรณ์ว่าค่าคีย์เฉพาะบางค่าอาจกลายเป็น "อ่อน" นั่นคือ การเข้ารหัสอาจไม่ให้ความปลอดภัยในระดับที่กำหนดหากมีการใช้งาน อย่างไรก็ตามส่วนแบ่งของค่าดังกล่าวในมวลรวมของคีย์ที่เป็นไปได้ทั้งหมดนั้นเล็กน้อย อย่างน้อยที่สุด การวิจัยการเข้ารหัสอย่างเข้มข้นยังไม่ได้เปิดเผยคีย์ใด ๆ สำหรับตารางการแทนที่ใด ๆ ที่รู้จัก (เช่น เสนอโดย FAPSI) ดังนั้นคีย์ที่สร้างขึ้นด้วยความช่วยเหลือของตัวสร้างตัวเลขสุ่มอย่างแท้จริงจะมีคุณภาพสูงโดยมีความน่าจะเป็นที่แตกต่างจากความสามัคคีด้วยจำนวนเล็กน้อยเล็กน้อย หากคีย์ถูกสร้างขึ้นโดยใช้ตัวสร้างตัวเลขสุ่มหลอก ตัวสร้างที่ใช้จะต้องมีลักษณะทางสถิติข้างต้น และนอกจากนี้ยังมีความแข็งแกร่งในการเข้ารหัสสูง ไม่น้อยไปกว่า GOST เอง กล่าวอีกนัยหนึ่ง ภารกิจในการพิจารณาสมาชิกที่ขาดหายไปของลำดับองค์ประกอบที่สร้างโดยเครื่องกำเนิดไฟฟ้าไม่ควรจะง่ายกว่างานในการทำลายรหัส นอกจากนี้ยังสามารถใช้เกณฑ์ทางสถิติต่างๆ เพื่อปฏิเสธคีย์ที่มีประสิทธิภาพทางสถิติต่ำ ในทางปฏิบัติ เกณฑ์สองเกณฑ์มักจะเพียงพอ - เพื่อตรวจสอบการกระจายที่เท่าเทียมกันของคีย์บิตระหว่างค่า 0 และ 1 โดยปกติจะใช้เกณฑ์ของเพียร์สัน ("ไคสแควร์") และเพื่อตรวจสอบความเป็นอิสระของคีย์บิต เกณฑ์อนุกรมคือ ใช้แล้ว. คุณสามารถอ่านเกี่ยวกับเกณฑ์ดังกล่าวได้ในตำราเรียนหรือหนังสืออ้างอิงเกี่ยวกับสถิติทางคณิตศาสตร์

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

ในกรณีที่จำเป็นต้องพัฒนาข้อมูลสำคัญจำนวนมาก เป็นไปได้และแพร่หลายมากที่จะใช้เซ็นเซอร์ซอฟต์แวร์ต่างๆ ของตัวเลขสุ่มหลอก เนื่องจากเซ็นเซอร์ดังกล่าวต้องการความแข็งแกร่งในการเข้ารหัสสูง จึงเป็นเรื่องธรรมดาที่จะใช้เครื่องกำเนิดแกมมาเข้ารหัสเอง - เราเพียงแค่ "ตัด" แกมมาที่สร้างโดยการเข้ารหัสออกเป็น "ชิ้นส่วน" ตามขนาดที่ต้องการ สำหรับ GOST - 32 ไบต์ต่ออัน แน่นอน สำหรับแนวทางนี้ เราจำเป็นต้องมี “มาสเตอร์คีย์” ซึ่งเราสามารถหาได้โดยใช้วิธีการรูเล็ตอิเล็กทรอนิกส์ที่อธิบายไว้ข้างต้น และด้วยความช่วยเหลือของมัน โดยใช้รหัสลับในโหมดตัวสร้างแกมมา เราได้รับอาร์เรย์ของข้อมูลสำคัญของ ปริมาณที่เราต้องการ ดังนั้นวิธีสร้างคีย์ทั้งสองนี้ - "แบบแมนนวล" และ "อัลกอริทึม" จึงทำงานควบคู่กันและเสริมซึ่งกันและกัน รูปแบบการสร้างคีย์ในระบบป้องกันการเข้ารหัสข้อมูล "งบประมาณต่ำ" มักจะสร้างขึ้นตามหลักการนี้

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

ตารางแทนที่เป็นองค์ประกอบหลักระยะยาว กล่าวคือ ใช้ได้นานกว่าคีย์เดียว สันนิษฐานว่าเป็นเรื่องปกติสำหรับโหนดการเข้ารหัสทั้งหมดภายในระบบป้องกันการเข้ารหัสเดียว แม้ว่าความลับของตารางการแทนที่จะถูกละเมิด ความแข็งแกร่งของรหัสยังคงสูงมากและไม่ต่ำกว่าขีดจำกัดที่อนุญาต ดังนั้นจึงไม่จำเป็นต้องเก็บตารางเป็นความลับเป็นพิเศษ และในแอปพลิเคชันเชิงพาณิชย์ส่วนใหญ่ของ GOST นี่คือวิธีการดำเนินการ ในทางกลับกัน ตารางการแทนที่เป็นองค์ประกอบที่สำคัญเพื่อให้แน่ใจว่ามีความแข็งแกร่งของรหัสทั้งหมด การเลือกตารางที่ไม่ถูกต้องอาจส่งผลให้รหัสถูกทำลายได้ง่ายด้วยวิธีการเข้ารหัสที่รู้จัก เกณฑ์สำหรับการพัฒนาโหนดทดแทนนั้นเป็นความลับที่มีตราประทับเจ็ดดวง และ FAPSI ไม่น่าจะเปิดเผยต่อสาธารณะในอนาคตอันใกล้นี้ ท้ายที่สุดแล้ว การจะบอกว่าตารางทดแทนนี้ดีหรือไม่ดีนั้น คุณต้องใช้แรงงานจำนวนมหาศาล - ชั่วโมงการทำงานของคนและเครื่องจักรหลายพันชั่วโมง เมื่อเลือกและใช้งานแล้ว ตารางจะถูกแทนที่ก็ต่อเมื่อรหัสที่ใช้งานมีความเสี่ยงต่อการเข้ารหัสประเภทใดประเภทหนึ่ง ดังนั้นตัวเลือกที่ดีที่สุดสำหรับผู้ใช้รหัสทั่วไปคือการใช้หนึ่งในหลาย ๆ ตารางที่เป็นสาธารณะ ตัวอย่างเช่น จากมาตรฐานฟังก์ชันแฮช ก็เป็น "ธนาคารกลาง" เช่นกัน ข้อมูลเกี่ยวกับตารางเหล่านี้สามารถพบได้ในสื่อเปิดและแม้แต่บนอินเทอร์เน็ตหากคุณค้นหาอย่างดี

สำหรับผู้ที่ไม่คุ้นเคยกับวิธีง่าย ๆ ด้านล่างนี้เป็นรูปแบบทั่วไปสำหรับการรับตารางคุณภาพ:

1. ใช้วิธีการใดวิธีการหนึ่ง คุณจะพัฒนาชุดของโหนดทดแทนแปดโหนดที่มีคุณสมบัติที่ไม่เป็นเชิงเส้นที่รับประกันได้ มีหลายวิธี หนึ่งในนั้นคือการใช้ฟังก์ชันงอที่เรียกว่า
2. คุณตรวจสอบการใช้งาน "เกณฑ์คุณภาพ" ที่ง่ายที่สุด ตัวอย่างเช่น เกณฑ์ที่เผยแพร่สำหรับโหนดแทนที่ DES ต่อไปนี้คือข้อควรพิจารณาโดยทั่วไปเกี่ยวกับคะแนนนี้: โหนดการแทนที่แต่ละโหนดสามารถอธิบายได้ด้วยฟังก์ชันเชิงตรรกะสี่ฟังก์ชันจากอาร์กิวเมนต์เชิงตรรกะสี่ข้อ ถ้าฟังก์ชันเหล่านี้เขียนใน รูปแบบขั้นต่ำ(เช่น ด้วยความยาวนิพจน์ขั้นต่ำที่เป็นไปได้) ไม่ซับซ้อนเพียงพอ โหนดแทนที่ดังกล่าวจะถูกปฏิเสธ นอกจากนี้ แต่ละฟังก์ชันภายในตารางการแทนที่ทั้งหมดจะต้องแตกต่างกันในระดับที่เพียงพอ ในขั้นตอนนี้ ตารางคุณภาพต่ำโดยเจตนาจำนวนมากจะถูกตัดออก
3. สำหรับการเข้ารหัสที่มีตารางที่คุณเลือก ให้สร้างแบบจำลองรอบต่างๆ ที่สอดคล้องกับการเข้ารหัสประเภทต่างๆ และวัดลักษณะ "โปรไฟล์" ที่สอดคล้องกัน ดังนั้น สำหรับการวิเคราะห์การเข้ารหัสเชิงเส้น ให้สร้างอะนาล็อกทางสถิติเชิงเส้นของรอบการเข้ารหัส และคำนวณคุณลักษณะ "โปรไฟล์" ซึ่งเป็นดัชนีที่ไม่ใช่เชิงเส้น หากปรากฎว่าไม่เพียงพอ ตารางการแทนที่จะถูกปฏิเสธ
4. สุดท้าย ใช้ผลลัพธ์ของย่อหน้าก่อนหน้า กำหนดรหัสด้วยตารางที่คุณเลือกเพื่อการวิจัยอย่างเข้มข้น - ความพยายามในการเข้ารหัสด้วยวิธีการที่รู้จักทั้งหมด ขั้นตอนนี้ยากและใช้เวลานานที่สุด แต่ถ้าทำด้วยคุณภาพสูง มีความเป็นไปได้สูงที่จะกล่าวได้ว่ารหัสของตารางที่คุณเลือกจะไม่ถูกเปิดโดยมนุษย์ธรรมดา และเป็นไปได้ว่ามันจะยากเกินไปสำหรับ บริการพิเศษ.

อย่างไรก็ตาม เป็นไปได้ที่จะทำง่ายกว่ามาก สิ่งสำคัญคือยิ่งมีรอบในรหัสมากเท่าใด ผลกระทบต่อความปลอดภัยของรหัสทั้งหมดก็จะน้อยลงเท่านั้น นั่นคือลักษณะความปลอดภัยของหนึ่งรอบ ใน GOST มีมากถึง 32 รอบ - มากกว่ารหัสเกือบทั้งหมดที่มีสถาปัตยกรรมคล้ายกัน ดังนั้น สำหรับการใช้งานในประเทศและเชิงพาณิชย์ส่วนใหญ่ ก็เพียงพอแล้วที่จะได้รับโหนดการแทนที่เป็นการเปลี่ยนลำดับแบบสุ่มอิสระของตัวเลขตั้งแต่ 0 ถึง 15 ซึ่งสามารถนำไปใช้ได้จริง เช่น โดยการสับสำรับไพ่สิบหกใบ โดยแต่ละสำรับจะได้รับหนึ่งใบ ของค่าของช่วงที่ระบุ

เกี่ยวกับตารางการเปลี่ยนจำเป็นต้องทราบข้อเท็จจริงที่น่าสนใจอีกข้อหนึ่ง ความสามารถในการย้อนกลับของวงจรการเข้ารหัสแบบ 32-3 และ 32-R ไม่จำเป็นต้องให้โหนดแทนที่ต้องมีการเรียงสับเปลี่ยนตัวเลขตั้งแต่ 0 ถึง 15 ทุกอย่างทำงานได้แม้ว่าจะมีองค์ประกอบที่ซ้ำกันในโหนดแทนที่ และการแทนที่ที่กำหนดโดยโหนดดังกล่าว กลับไม่ได้ - อย่างไรก็ตาม ในกรณีนี้ ความแรงของรหัสจะลดลง ทำไมสิ่งนี้จึงไม่ได้รับการพิจารณาในบทความนี้ แต่ก็ไม่ยากที่จะตรวจสอบข้อเท็จจริง ในการทำเช่นนี้ก็เพียงพอที่จะพยายามเข้ารหัสก่อนแล้วจึงถอดรหัสบล็อกข้อมูลโดยใช้ตารางการแทนที่ "ด้อยกว่า" ซึ่งเป็นโหนดที่มีค่าซ้ำกัน

การเปลี่ยนแปลงในรูปแบบของ GOST

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

วิธีดำเนินการในกรณีนี้และกรณีที่คล้ายกันเพื่อเพิ่มความเร็วของการเข้ารหัส? คำตอบอยู่บนพื้นผิว - ใช้การปรับเปลี่ยนรหัสโดยมีขั้นตอนพื้นฐานน้อยลง (รอบ) ในรอบพื้นฐาน เราลดจำนวนรอบการเข้ารหัสลงกี่ครั้งประสิทธิภาพก็เพิ่มขึ้นเท่าเดิม การเปลี่ยนแปลงนี้สามารถทำได้สองวิธี - โดยการลดความยาวของคีย์ และลดจำนวนของ "รอบการค้นหา" ของคีย์ จำได้ว่าจำนวนขั้นตอนพื้นฐานในรอบการเข้ารหัสพื้นฐานคือ เอ็น=n ม, ที่ไหน นคือจำนวนองค์ประกอบ 32 บิตในคีย์ ม- จำนวนรอบของการใช้องค์ประกอบหลักในมาตรฐาน น=8, ม=4. คุณสามารถลดจำนวนเหล่านี้ได้ แต่ตัวเลือกที่ง่ายที่สุดคือการลดความยาวของคีย์โดยไม่กระทบกับรูปแบบการใช้งาน

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

สำหรับความต้านทานของการเข้ารหัสต่อการถอดรหัสโดยวิธี "กว้างขวาง" นั่นคือการโจมตี "กำลังดุร้าย" ทุกอย่างมีความชัดเจนไม่มากก็น้อยที่นี่: คีย์ 64 บิตอยู่ที่ไหนสักแห่งที่ใกล้จะเข้าถึงได้สำหรับประเภทนี้ ของการโจมตี การเข้ารหัสที่มีคีย์ตั้งแต่ 96 บิตขึ้นไป (โปรดจำไว้ว่าคีย์นั้นต้องประกอบด้วยจำนวนเต็มขององค์ประกอบ 32 บิต) ค่อนข้างแข็งแกร่งเมื่อเทียบกับมัน อันที่จริง เมื่อไม่กี่ปีที่ผ่านมา DES ซึ่งเป็นมาตรฐานการเข้ารหัสของสหรัฐฯ เดิมถูกแฮ็กซ้ำแล้วซ้ำอีกโดยกำลังดุร้าย ครั้งแรกถูกแฮ็กโดยเครือข่ายคอมพิวเตอร์ที่จัดตั้งขึ้นบนพื้นฐานของอินเทอร์เน็ตทั่วโลก จากนั้นโดยเครือข่ายเฉพาะทาง เช่น คอมพิวเตอร์ที่ออกแบบมาเพื่อการนี้โดยเฉพาะ สมมติว่า GOST เวอร์ชันมาตรฐานเมื่อใช้งานในซอฟต์แวร์บนโปรเซสเซอร์สมัยใหม่ จะทำงานเร็วกว่า DES ถึงสี่เท่า จากนั้น "GOST ที่ลดลง" 8 รอบจะทำงานเร็วกว่า DES 16 เท่า สมมติว่าในช่วงเวลาตั้งแต่การแฮ็ก DES ประสิทธิภาพของเทคโนโลยีคอมพิวเตอร์ตามกฎหมายของมัวร์ได้เพิ่มขึ้นสี่เท่า เป็นผลให้เราได้รับว่าตอนนี้การตรวจสอบคีย์ 64 บิตหนึ่งคีย์สำหรับ "ลด GOST" ด้วยแปดรอบนั้นเร็วกว่าการตรวจสอบคีย์ DES เดียวถึง 64 เท่า ดังนั้นข้อได้เปรียบของ GOST เวอร์ชันนี้เหนือ DES ในแง่ของความซับซ้อนของการโจมตีด้วยกำลังดุร้ายจึงลดลงจาก 2 64–56 = 2 8 = 256 เป็น 256 / 64 = 4 ครั้ง เห็นด้วยนี่เป็นความแตกต่างที่ลวงตามากแทบจะไม่มีอะไรเลย

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

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

ในทางกลับกัน GOST ได้รับการออกแบบให้มีความปลอดภัยสูง และในปัจจุบันสามารถทนต่อการเข้ารหัสทุกประเภทที่รู้จัก รวมถึงดิฟเฟอเรนเชียลและลิเนียร์ สำหรับ LCA นั้นหมายความว่าสำหรับการติดตั้งใช้งานที่ประสบความสำเร็จนั้น จำเป็นต้องมีคู่ "open block - encrypted block" มากกว่า "มีอยู่จริง" นั่นคือมากกว่า 2 64 จากมุมมองข้างต้น หมายความว่าสำหรับ LCA ที่ประสบความสำเร็จของ GOST 16 รอบ จะต้องมีบล็อกอย่างน้อยหรือ 2 35 ไบต์หรือ 32 GB ของข้อมูล และสำหรับ GOST 8 รอบ อย่างน้อยบล็อกหรือ 2 19 ไบต์หรือ 0.5 MB

ข้อสรุปจากทั้งหมดที่กล่าวมาข้างต้นแสดงไว้ในตารางต่อไปนี้ซึ่งสรุปลักษณะของ GOST เวอร์ชันที่ลดลง

จำนวนรอบ	ขนาดกุญแจบิต	ดัชนีการดำเนินการด่วน	ลักษณะน่าจะเป็นของรหัส (ประมาณการคร่าวๆ)
24	192	1,33	ทนต่อ KA ประเภทที่รู้จักมากที่สุดหรือเกือบจะต่อต้าน การใช้งานจริงของ CA นั้นเป็นไปไม่ได้เนื่องจากความต้องการสูงสำหรับข้อมูลเริ่มต้นและความเข้มของแรงงาน
16	128	2	ในทางทฤษฎี การวิเคราะห์การเข้ารหัสบางประเภทไม่เสถียร แต่การนำไปใช้จริงในกรณีส่วนใหญ่นั้นทำได้ยาก เนื่องจากมีความต้องการสูงสำหรับข้อมูลเริ่มต้นและความเข้มข้นของแรงงาน
12	95	2,67	ไม่ทนต่อการเข้ารหัสลับบางประเภทที่รู้จัก อย่างไรก็ตาม เหมาะสำหรับการรักษาความลับของข้อมูลจำนวนเล็กน้อย (สูงสุดสิบหรือหลายร้อย KB) ในช่วงเวลาสั้นๆ
8	64	4	ไม่ทนทานต่อการเข้ารหัสบางประเภทที่รู้จัก แต่เหมาะสำหรับการรักษาความลับของข้อมูลจำนวนเล็กน้อย (ไม่เกินสิบ Kbytes) ในช่วงเวลาสั้นๆ

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

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

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

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

การใช้มาตรฐานที่ไม่ได้มาตรฐาน

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

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

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

2. ไม่เพียง แต่แกมมาการเข้ารหัสเท่านั้น แต่ยังรวมถึงการแปลงการเข้ารหัสด้วย สามารถนำมาใช้สำหรับความต้องการที่ไม่เกี่ยวข้องโดยตรงกับการเข้ารหัส:

• เราทราบดีว่าหนึ่งในตัวเลือกดังกล่าวสำหรับการใช้ GOST คือการพัฒนาส่วนแทรกจำลองสำหรับอาร์เรย์ข้อมูล อย่างไรก็ตาม บนพื้นฐานของการเข้ารหัสแบบบล็อกใด ๆ รวมถึง GOST มันค่อนข้างง่ายที่จะสร้างโครงร่างสำหรับการคำนวณฟังก์ชันแฮชทางเดียวหรือที่เรียกว่า MDC ในเอกสาร ซึ่งในแหล่งต่าง ๆ หมายถึง เปลี่ยนรหัสตรวจจับ / การจัดการ (มดัดแปลง/ มการเคลื่อนไหว งการตั้งค่า คบทกวี) หรือ สรุปข้อความ (มเรียงความ งดีที่สุด คบทกวี). การถอดรหัสครั้งแรกปรากฏในวรรณกรรมเร็วกว่ามากฉันคิดว่าอันที่สองสั้นกว่าถูกคิดค้นโดยผู้ที่จำอันแรกไม่ได้ :) - มันเป็นเรื่องตลก MDC สามารถใช้โดยตรงในระบบป้องกันการเลียนแบบเป็นอะนาล็อกของการแทรกของเลียนแบบ ซึ่งไม่ได้ขึ้นอยู่กับรหัสลับ นอกจากนี้ MDC ยังถูกใช้อย่างแพร่หลายในโครงร่างลายเซ็นดิจิทัลอิเล็กทรอนิกส์ (EDS) เนื่องจากโครงร่างเหล่านี้ส่วนใหญ่ได้รับการออกแบบในลักษณะที่สะดวกในการเซ็นบล็อกข้อมูลที่มีขนาดคงที่ ดังที่คุณทราบตามมาตรฐาน GOST 28147-89 ที่กล่าวถึงมาตรฐานของสหพันธรัฐรัสเซียสำหรับการคำนวณฟังก์ชันแฮชทางเดียว GOST R34.11-94 ถูกสร้างขึ้น
• ไม่เป็นที่ทราบกันดีว่าบนพื้นฐานของการเข้ารหัสบล็อกใด ๆ รวมถึง GOST สามารถสร้างโครงร่าง EDS ที่ทำงานได้อย่างสมบูรณ์ด้วยรหัสลายเซ็นลับและชุดค่าผสมการตรวจสอบแบบเปิด ด้วยเหตุผลหลายประการ โครงร่างนี้ไม่ได้รับการเผยแพร่ในวงกว้าง แต่ในบางกรณีก็ยังถือได้ว่าเป็นทางเลือกที่น่าสนใจมากสำหรับโครงร่าง EDS "ทางคณิตศาสตร์" ที่กำลังโดดเด่นในโลก

วรรณกรรม

ระบบประมวลผลข้อมูล การป้องกันการเข้ารหัส อัลกอริทึมการแปลงการเข้ารหัส GOST 28147-89 สถานะ. คอม สหภาพโซเวียตตามมาตรฐาน M. , 1989 ftp://ftp.wtc-ural.ru/pub/ru.crypt/GOST-28147
แชนนอน โคล้ด. ทฤษฎีทางคณิตศาสตร์ของระบบความลับ ในคอลเลกชั่น "Works on information theory and cybernetics", M., IL, 1963, p. 333-369. http://www.enlight.ru/crypto/articles/shannon/shann__i.htm
ประกาศการอนุมัติมาตรฐานการประมวลผลข้อมูลของรัฐบาลกลาง (FIPS) 197, มาตรฐานการเข้ารหัสขั้นสูง (AES), Federal Register Vol. 66 ไม่ 235 / วันพฤหัสบดีที่ 6 ธันวาคม 2544 / ประกาศ หน้า 63369–63371 http://csrc.nist.gov/encryption/aes/
ไฟสเตล ฮอร์สท์ การเข้ารหัสและความปลอดภัยของคอมพิวเตอร์ แปลโดย A. Vinokurov จัดพิมพ์โดย Horst Feistel การเข้ารหัสและความเป็นส่วนตัวของคอมพิวเตอร์ Scientific American พฤษภาคม 1973 ฉบับที่ 228 เลขที่ 5 หน้า 15-23. http://www.enlight.ru/crypto/articles/feistel/feist_i.htm
ชไนเออร์ บรูซ. การเข้ารหัสประยุกต์ แก้ไขครั้งที่ 2 โปรโตคอล อัลกอริทึม และข้อความต้นฉบับในภาษา C., M., "Triumph", 2002 http://www.ssl.stu.neva.ru/psw/crypto/appl_rus/appl_cryp.htm
เมเนเซส อัลเฟรด, ฟาน ออร์ชอต พอล, แวนสโตน สก็อตต์ คู่มือการเข้ารหัสประยุกต์ http://www.cacr.math.uwaterloo.ca/hac/
Vinokurov อันเดรย์ Block Cipher มีโครงสร้างอย่างไร? ต้นฉบับ http://www.enlight.ru/crypto/articles/vinokurov/blcyph_i.htm
Vinokurov อันเดรย์ ปัญหาเกี่ยวกับการเข้ารหัสสำหรับวารสารอิเล็กทรอนิกส์ inNFUSED BYTES ออนไลน์ http://www.enlight.ru/crypto/articles/ib/ib.htm
Vinokurov Andrey, Primenko Eduard ข้อความของรายงาน "ในการใช้ซอฟต์แวร์ของมาตรฐานการเข้ารหัสของสหพันธรัฐรัสเซียและสหรัฐอเมริกา", การประชุมเกี่ยวกับการให้ข้อมูล, มอสโก, MEPhI, 28-29 มกราคม 2544 เผยแพร่ในการดำเนินการประชุม
เทคโนโลยีสารสนเทศ. การป้องกันข้อมูลด้วยการเข้ารหัส ฟังก์ชันแฮช GOST R34.11-94, Gosstandart RF, M. , 1994

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

คำอธิบายของอัลกอริทึม

รูปแบบของอัลกอริทึมแสดงในรูปที่ 3.1. อย่างที่คุณเห็น รูปแบบของอัลกอริทึมนี้ค่อนข้างเรียบง่าย ซึ่งช่วยลดความยุ่งยากในการใช้งานซอฟต์แวร์หรือฮาร์ดแวร์ได้อย่างไม่น่าสงสัย

อัลกอริทึม GOST 28147-89 เข้ารหัสข้อมูลในบล็อก 64 บิต ซึ่งแบ่งออกเป็นสองบล็อกย่อย 32 บิต (N1 และ N2) Subblock N1 ได้รับการประมวลผลด้วยวิธีใดวิธีหนึ่ง หลังจากนั้นจึงเพิ่มค่าเข้าไป

ด้วยค่าบล็อกย่อย N2 (เพิ่มเติมจะดำเนินการโมดูโล 2) จากนั้นบล็อกย่อยจะถูกสลับ การแปลงดังกล่าวดำเนินการตามจำนวนรอบที่กำหนด: 16 หรือ 32 ขึ้นอยู่กับโหมดการทำงานของอัลกอริทึม (อธิบายด้านล่าง) ดำเนินการต่อไปนี้ในแต่ละรอบ:

1. การซ้อนทับคีย์ เนื้อหาของบล็อกย่อย /VI ถูกเพิ่มโมดูโล 2 32 ไปยังส่วน Kx ของคีย์

คีย์เข้ารหัสของอัลกอริทึม GOST 28147-89 มีขนาด 256 บิต และ Kx เป็นส่วน 32 บิต เช่น คีย์เข้ารหัส 256 บิตจะแสดงเป็นการต่อเชื่อมของคีย์ย่อย 32 บิต (รูปที่ 3.2):

SH ATI, AG2, ยู, AG4, K5, Kb, K7

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

ข้าว. 3.1. รูปแบบของอัลกอริทึม GOST 28147-

ข้าว. 3.2. คีย์การเข้ารหัสของอัลกอริทึม GOST 28147-89

2. การเปลี่ยนตาราง หลังจากการซ้อนทับคีย์แล้ว บล็อกย่อย /VI จะแบ่งออกเป็น 8 ส่วนของ 4 บิต ค่าของแต่ละส่วนจะถูกแทนที่แยกกันตามตารางการแทนที่สำหรับส่วนนี้ของบล็อกย่อย การแทนที่ตาราง (กล่องการแทนที่, S-box) มักใช้ในอัลกอริทึมการเข้ารหัสสมัยใหม่ ดังนั้นจึงควรพิจารณารายละเอียดเพิ่มเติม

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

4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1.

ให้บล็อก 4 บิต "0100" มาที่อินพุต เช่น ค่าคือ 4 ตามตาราง ค่าเอาต์พุตจะเป็น 15 เช่น "1111" (0 ถูกแทนที่ด้วย 4, 1 ถูกแทนที่ด้วย 11, ค่าของ 2 ไม่เปลี่ยนแปลง ฯลฯ)

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

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.

3. Bitwise วนซ้ายกะ 11 บิต

โหมดอัลกอริทึม

อัลกอริทึม GOST 28147-89 มี 4 โหมดการทำงาน:

□ โหมดการเปลี่ยนอย่างง่าย

□ โหมดแกมม่า;

โหมดเกม P พร้อมข้อเสนอแนะ;

□ โหมดการผลิตของสิ่งที่แนบมาเลียนแบบ

โหมดเหล่านี้ค่อนข้างแตกต่างจากโหมดที่ยอมรับโดยทั่วไป (อธิบายไว้ในหัวข้อ 1.4) ดังนั้นจึงควรพิจารณารายละเอียดเพิ่มเติม

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

โหมดสลับง่าย

ในโหมดการแทนที่อย่างง่าย การดำเนินการ 32 รอบที่อธิบายไว้ข้างต้นเป็นเพียงการดำเนินการเพื่อเข้ารหัสข้อมูล 64 บิตแต่ละบล็อก คีย์ย่อย 32 บิตใช้ในลำดับต่อไปนี้:

□ KO, Kl, K2, K3, K4, K5, Kb, AG7, KO, ATI ฯลฯ - ในรอบที่ 1 ถึง 24

□ K1, Kb, K5, K4, K3, K2, K\, KO - ในรอบ 25 ถึง 32

การถอดรหัสในโหมดการแทนที่อย่างง่ายนั้นทำในลักษณะเดียวกันทุกประการ แต่มีลำดับการใช้คีย์ย่อยที่แตกต่างกันเล็กน้อย:

□ KO, K\, K2, KZ, K4, K5, Kb, KP - ในรอบที่ 1 ถึง 8;

□ KP, Kb, K5, K4, K3, K2, K\, KO, K1, Kb ฯลฯ - ในรอบที่ 9 ถึง 32

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

โหมดแกมมา

ในโหมดแกมมา (รูปที่ 3.3) แต่ละบล็อกของข้อความธรรมดาจะถูกเพิ่มทีละบิต โมดูโล 2 ลงในบล็อกแกมมาของรหัสที่มีขนาด 64 บิต แกมมารหัสเป็นลำดับพิเศษที่สร้างขึ้นโดยใช้การแปลงที่อธิบายไว้ข้างต้นดังต่อไปนี้:

1. ในการลงทะเบียน N1 และ N2 การเติมเริ่มต้นจะถูกเขียน - ค่า 64 บิตเรียกว่า "ข้อความซิงค์" (อันที่จริงแล้วข้อความซิงค์เป็นอะนาล็อกของเวกเตอร์การเริ่มต้นในโหมด CBC, CFB และ OFB ).

2. เนื้อหาของรีจิสเตอร์ /VI และ N2 (ในกรณีนี้คือข้อความซิงค์) จะถูกเข้ารหัสในโหมดการแทนที่อย่างง่าย

3. เนื้อหาของ N1 ถูกเพิ่มเป็นโมดูโล (2 32 - 1) โดยมีค่าคงที่ CI = 2 24 + 2 16 + 2 8 + 4 ผลลัพธ์ของการเพิ่มจะถูกเขียนลงใน /VI register

4. เนื้อหาของ N2 ถูกเพิ่มโมดูโล 2 ด้วยค่าคงที่ C2 = 2 24 + 2 16 + 2 8 +1 ผลลัพธ์ของการเพิ่มจะถูกเขียนเพื่อลงทะเบียน N2

5. เนื้อหาของรีจิสเตอร์ /VI และ N2 จะถูกส่งออกเป็นบล็อกแกมมาเข้ารหัส 64 บิต (เช่น ในกรณีนี้ /VI และ N2 จะก่อตัวเป็นบล็อกแกมมาแรก)

6. หากจำเป็นต้องใช้บล็อกแกมมาถัดไป (เช่น การเข้ารหัสหรือถอดรหัสจำเป็นต้องดำเนินการต่อ) ให้กลับไปที่ขั้นตอนที่ 2

สำหรับการถอดรหัส จะมีการสร้างแกมมาในลักษณะเดียวกัน จากนั้นการดำเนินการ XOR จะถูกนำไปใช้อีกครั้งกับไซเฟอร์เท็กซ์และบิตแกมมา

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

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

โหมดแกมม่าข้อเสนอแนะ

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

ข้าว. 3.4. การสร้างแกมมาเข้ารหัสในโหมดแกมมาพร้อมข้อเสนอแนะ

โหมดสร้างเลียนแบบ

การปลอมแปลงเป็นการตรวจสอบการเข้ารหัสลับที่คำนวณโดยใช้คีย์การเข้ารหัสและออกแบบมาเพื่อตรวจสอบความสมบูรณ์ของข้อความ ในการคำนวณมีโหมดพิเศษของอัลกอริทึม GOST 28147-89

การสร้างคำนำหน้าเลียนแบบดำเนินการดังนี้:

1. บล็อกข้อมูล 64 บิตแรกซึ่งคำนวณตัวเลียนแบบจะถูกเขียนลงในรีจิสเตอร์ N1 และ N2 และเข้ารหัสในโหมดการแทนที่อย่างง่ายที่ลดลง ซึ่งดำเนินการ 16 รอบแรกจาก 32 รอบ

2. ผลลัพธ์ที่ได้คือผลรวมโมดูโล 2 กับบล็อกข้อมูลถัดไป บันทึกผลลัพธ์ใน N1 และ N2

3. M และ N2 จะถูกเข้ารหัสอีกครั้งในโหมดลดทอนของการแทนที่อย่างง่าย และต่อไปเรื่อยๆ จนถึงบล็อกสุดท้ายของข้อมูล

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

คำนำหน้าเลียนแบบใช้ดังนี้:

1. เมื่อเข้ารหัสข้อมูลใดๆ ตัวเลียนแบบข้อความธรรมดาจะถูกคำนวณและส่งพร้อมกับข้อความเข้ารหัส

2. หลังจากถอดรหัสคำนำหน้าเลียนแบบจะถูกคำนวณอีกครั้งและเปรียบเทียบกับคำนำหน้าที่ส่งไป

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

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

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

ความแข็งแกร่งของการเข้ารหัสลับของอัลกอริทึม

ในปี 1994 คำอธิบายของอัลกอริทึม GOST 28147-89 ได้รับการแปลเป็นภาษาอังกฤษและเผยแพร่ หลังจากนั้นผลการวิเคราะห์ของเขาที่ดำเนินการโดยผู้เชี่ยวชาญจากต่างประเทศก็เริ่มปรากฏขึ้น อย่างไรก็ตาม ไม่พบการโจมตีที่ใกล้จะเป็นไปได้เป็นระยะเวลานาน

□ ความยาวของคีย์ขนาดใหญ่ - 256 บิต เมื่อใช้ร่วมกับข้อความซิงค์ลับ ความยาวของคีย์ที่มีประสิทธิภาพจะเพิ่มเป็น 320 บิต

□ แปลงร่าง 32 รอบ; หลังจากผ่านไป 8 รอบแล้ว ผลทั้งหมดของการกระจายข้อมูลอินพุตจะบรรลุผลสำเร็จ: การเปลี่ยนบล็อกข้อความธรรมดาหนึ่งบิตจะส่งผลต่อบิตทั้งหมดของบล็อกข้อความไซเฟอร์ และในทางกลับกัน เช่น มีขอบความปลอดภัยหลายส่วน

พิจารณาผลลัพธ์ของการเข้ารหัสของอัลกอริทึม GOST 28147-89

การวิเคราะห์ตารางการแทนที่

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

□ การโจมตีโดยใช้การเข้ารหัสทั้งเชิงเส้นและเชิงอนุพันธ์ของอัลกอริธึม DES ใช้คุณสมบัติเฉพาะของตารางการแทนที่ เมื่อใช้ตารางอื่น การวิเคราะห์การเข้ารหัสจะต้องเริ่มต้นใหม่

□ มีการพยายามเสริมความแข็งแกร่งให้กับ DES กับการเข้ารหัสเชิงเส้นและดิฟเฟอเรนเชียลโดยใช้ตารางการแทนที่ที่แข็งแกร่งกว่า ตารางดังกล่าว ซึ่งแน่นอนมีความเสถียรมากกว่า ได้รับการเสนอ ตัวอย่างเช่น ในอัลกอริทึม s 5 DES; แต่อนิจจา มันเป็นไปไม่ได้ที่จะแทนที่ DES ด้วย s 5 DES เนื่องจากตารางแทนที่ถูกกำหนดอย่างเข้มงวดในมาตรฐาน ตามลำดับ การใช้อัลกอริทึมอาจไม่สนับสนุนความสามารถในการเปลี่ยนตารางเป็นตารางอื่น

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

1. ตั้งค่าคีย์ null และค้นหา "เวกเตอร์ว่าง" เช่น ค่า z = /(0) โดยที่ /() คือฟังก์ชันรอบของอัลกอริทึม ขั้นตอนนี้ใช้เวลาประมาณ 2 การดำเนินการเข้ารหัส

2. การใช้เวกเตอร์ศูนย์จะคำนวณค่าของตารางการแทนที่ซึ่งใช้เวลาไม่เกิน 2 11 การดำเนินการ

การปรับเปลี่ยนอัลกอริทึมและการวิเคราะห์

ในการทำงานได้ทำการเข้ารหัสการดัดแปลงอัลกอริทึม GOST 28147-89:

□ อัลกอริทึม GOST-H ซึ่งสัมพันธ์กับอัลกอริทึมดั้งเดิม ลำดับของการใช้คีย์ย่อยเปลี่ยนไป กล่าวคือในรอบตั้งแต่วันที่ 25 ถึง 32 คีย์ย่อยจะถูกใช้ตามลำดับโดยตรง เช่น ในลักษณะเดียวกับก่อนหน้านี้ รอบของอัลกอริทึม ;

□ อัลกอริธึม GOST® 20 รอบที่ใช้ XOR แทนโมดูโล 2 32 สำหรับการซ้อนทับคีย์

จากผลการวิเคราะห์สรุปได้ว่า GOST-H และ GOST© นั้นอ่อนแอกว่าอัลกอริทึม GOST 28147-89 ดั้งเดิม เนื่องจากทั้งคู่มีคลาสของคีย์ที่อ่อนแอ เป็นที่น่าสังเกตว่าในแง่ของการเข้ารหัส GOST© งานจะทำซ้ำคำต่อคำในส่วนของการเข้ารหัสของอัลกอริทึม GOST 28147-89 ซึ่งตีพิมพ์ในปี 2543 ในงานที่มีชื่อเสียง (โดยไม่มีการอ้างอิงถึงต้นฉบับ) สิ่งนี้ทำให้เกิดคำถามเกี่ยวกับความเป็นมืออาชีพของผู้เขียนผลงานและผลลัพธ์อื่นๆ

มีการเสนอการปรับเปลี่ยนอัลกอริทึมที่น่าสนใจมากในการทำงาน: ตาราง S \ ... Ss จะต้องแตกต่างกัน ในแต่ละรอบของอัลกอริทึม จะต้องเปลี่ยนรูปตามกฎที่กำหนด การเปลี่ยนรูปแบบนี้อาจขึ้นอยู่กับคีย์เข้ารหัส หรืออาจเป็นความลับ (กล่าวคือ เป็นส่วนหนึ่งของคีย์เข้ารหัสที่ใหญ่กว่าคีย์ 256 บิตดั้งเดิม) ผู้เขียนกล่าวว่าตัวเลือกทั้งสองนี้เพิ่มความต้านทานของอัลกอริทึมอย่างมีนัยสำคัญต่อการเข้ารหัสเชิงเส้นและเชิงอนุพันธ์

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

การวิเคราะห์อัลกอริทึมแบบเต็มรอบ

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

นักวิทยาศาสตร์ในประเทศ A. G. Rostovtsev และ E. B. Makhovenko ในปี 2544 ได้เสนอวิธีการเข้ารหัสแบบใหม่ที่เป็นพื้นฐาน ของคีย์และค้นหาค่าสูงสุดที่สอดคล้องกับค่าที่แท้จริงของคีย์ พวกเขายังพบคีย์อ่อนแอระดับใหญ่ของอัลกอริทึม GOST 28147-89 ซึ่งอนุญาตให้คุณเปิดอัลกอริทึมโดยใช้ข้อความธรรมดาที่เลือกเพียง 4 รายการและข้อความไซเฟอร์ที่เกี่ยวข้องซึ่งมีความซับซ้อนค่อนข้างต่ำ การเข้ารหัสของอัลกอริทึมยังคงดำเนินต่อไปในการทำงาน

ในปี พ.ศ. 2547 กลุ่มผู้เชี่ยวชาญจากเกาหลีได้เสนอการโจมตีโดยใช้การเข้ารหัสแบบดิฟเฟอเรนเชียลบนคีย์ที่เกี่ยวข้อง มีความเป็นไปได้ 91.7% 12 บิตของรหัสลับ การโจมตีต้องใช้ข้อความธรรมดาที่เลือก 235 รายการและการเข้ารหัส 236 รายการ อย่างที่คุณเห็น การโจมตีนี้แทบไม่มีประโยชน์เลยสำหรับการเปิดอัลกอริทึมจริง