ส่วนของเว็บไซต์
ตัวเลือกของบรรณาธิการ:
- แท็บเล็ต Android หรือ iPad - จะเลือกอะไรดี?
- วิธีจัดรูปแบบความต่อเนื่องของตารางใน Word อย่างถูกต้อง
- จะทำอย่างไรถ้าคุณพัฒนาแบบออฟไลน์
- การทดสอบโปรเซสเซอร์ว่ามีความร้อนสูงเกินไป
- บริการสาธารณะของ Yesia คืออะไร
- ตำแหน่งของหัวบนเสาอากาศ
- วิธีดาวน์โหลดและกำหนดค่าผู้ช่วยอัจฉริยะสำหรับอุปกรณ์ Android
- ตัวเลือก "ทุกที่ที่บ้าน" และ "ทุกที่ที่บ้านในรัสเซีย" MTS - คำอธิบายต้นทุนวิธีเชื่อมต่อ
- วิธีการกู้คืนหรือรีเซ็ตรหัสผ่านผู้ใช้ Windows
- วิธีลบโปรแกรม Avast อย่างสมบูรณ์เพื่อลบ Avast
การโฆษณา
| สตรีมยันต์ การดำเนินการ XOR และการเข้ารหัสไฟล์อย่างง่าย ตัวอย่างวิธีการทำงานของ XOR |
|
แนวคิดพื้นฐานการเข้ารหัส การเข้ารหัส- วิธีการแปลง เปิดข้อมูลเพื่อปิดและกลับ ใช้สำหรับจัดเก็บ ข้อมูลสำคัญในแหล่งที่ไม่น่าเชื่อถือหรือส่งผ่านช่องทางการสื่อสารที่ไม่ปลอดภัย ตาม GOST 28147-89 การเข้ารหัสแบ่งออกเป็นขั้นตอนการเข้ารหัสและถอดรหัส รหัส, รหัส- ชุดอัลกอริธึมการแปลงการเข้ารหัส (การเข้ารหัส) ที่แมปชุดข้อมูลเปิดที่เป็นไปได้กับชุดข้อมูลที่เข้ารหัสที่เป็นไปได้ และการแปลงแบบผกผัน Ciphers ถูกแบ่งออกเป็นที่ไม่สามารถถอดรหัสได้ในทางทฤษฎีและไม่สามารถถอดรหัสได้ในทางปฏิบัติ และตามโครงสร้างของคีย์เป็นแบบสมมาตรและไม่สมมาตร ขึ้นอยู่กับว่าคีย์เข้ารหัสเกิดขึ้นพร้อมกับคีย์ถอดรหัสหรือไม่ ในทางกลับกัน รหัสแบบสมมาตรจะถูกแบ่งออกเป็นรหัสแบบบล็อกและแบบสตรีม การเข้ารหัส- ศาสตร์แห่งวิธีการในการรับรองความลับ (ความเป็นไปไม่ได้ในการอ่านข้อมูลโดยบุคคลภายนอก) และความถูกต้อง (ความสมบูรณ์และความถูกต้องของการประพันธ์ตลอดจนความเป็นไปไม่ได้ที่จะปฏิเสธการประพันธ์) ข้อมูล ในขั้นต้น การเข้ารหัสศึกษาวิธีการเข้ารหัสข้อมูล - การแปลงข้อความธรรมดา (ต้นฉบับ) แบบย้อนกลับได้โดยใช้อัลกอริธึมลับและ/หรือคีย์เป็นไซเฟอร์เท็กซ์ (ไซเฟอร์เท็กซ์) การเข้ารหัสแบบดั้งเดิมเป็นสาขาหนึ่งของระบบการเข้ารหัสแบบสมมาตร ซึ่งการเข้ารหัสและถอดรหัสจะดำเนินการโดยใช้รหัสลับเดียวกัน วิทยาการเข้ารหัสลับเป็นหนึ่งในวิทยาศาสตร์ที่เก่าแก่ที่สุดซึ่งมีประวัติย้อนกลับไปหลายพันปี เปิดข้อความ (ต้นฉบับ)- ข้อมูล (ไม่จำเป็นต้องเป็นข้อความ) ส่งโดยไม่ต้องใช้การเข้ารหัส ข้อความที่เข้ารหัส (ปิด)- ข้อมูลที่ได้รับหลังจากใช้งาน cryptosystem ด้วยคีย์ที่ระบุ ระบบเข้ารหัส- ตระกูลของการแปลงข้อความธรรมดาเป็นไซเฟอร์เท็กซ์แบบพลิกกลับได้ สำคัญ- พารามิเตอร์ตัวเลขที่กำหนดตัวเลือกการเปลี่ยนแปลงเฉพาะของข้อความที่กำหนด ในยันต์สมัยใหม่ อัลกอริธึมการเข้ารหัสเป็นที่ทราบกันดีอยู่แล้ว และความแข็งแกร่งของการเข้ารหัสของการเข้ารหัสนั้นถูกกำหนดโดยความลับของคีย์ทั้งหมด (หลักการ Kerkhoffs) การเข้ารหัส- กระบวนการของการใช้การแปลงการเข้ารหัสของข้อความธรรมดาตามปกติโดยใช้อัลกอริธึมและคีย์ ส่งผลให้เกิดไซเฟอร์เท็กซ์ การถอดรหัส- กระบวนการประยุกต์การแปลงการเข้ารหัสข้อความไซเฟอร์เป็นข้อความธรรมดาตามปกติ การถอดรหัส (ถอดรหัส)- กระบวนการแยกข้อความธรรมดาโดยไม่ทราบคีย์การเข้ารหัสตามคีย์เข้ารหัสที่รู้จัก คำว่าถอดรหัสมักจะใช้สัมพันธ์กับกระบวนการวิเคราะห์การเข้ารหัสของไซเฟอร์เท็กซ์ (โดยทั่วไปแล้วการเข้ารหัสลับนั้นอาจเกี่ยวข้องกับการวิเคราะห์ระบบการเข้ารหัสด้วย และไม่ใช่แค่ข้อความเปิดที่เข้ารหัสโดยระบบ) การเข้ารหัสลับ- ศาสตร์ที่เรียนอยู่ วิธีการทางคณิตศาสตร์การละเมิดการรักษาความลับและความสมบูรณ์ของข้อมูล การโจมตีแบบเข้ารหัส- ความพยายามของนักวิเคราะห์การเข้ารหัสในการทำให้เกิดการเบี่ยงเบนในระบบแลกเปลี่ยนข้อมูลที่ปลอดภัยที่ถูกโจมตี เรียกว่าการโจมตีด้วยการเข้ารหัสที่ประสบความสำเร็จ การแฮ็กหรือ เปิด. ความแรงของการเข้ารหัส- ความสามารถของอัลกอริธึมการเข้ารหัสในการต้านทานการเข้ารหัส อัลกอริธึมการเข้ารหัส XOR บางทีอัลกอริธึมการเข้ารหัสที่ง่ายที่สุดและดั้งเดิมที่สุดคือการเข้ารหัส XOR อัลกอริธึมการเข้ารหัส XOR อาจมีความซับซ้อนในบางวิธี ซึ่งสามารถให้ผลลัพธ์ที่ดีมาก แต่ในการใช้งานขั้นพื้นฐาน อัลกอริธึมนั้นไม่เสถียรอย่างยิ่ง อัลกอริธึมการเข้ารหัส XOR ขึ้นอยู่กับการใช้การดำเนินการทางตรรกะแบบไบนารีพิเศษหรือ ในมุมมองตาราง ฟังก์ชันจะมีลักษณะดังนี้:
ข้อมูลป้อนเข้าสู่อัลกอริทึมคือข้อความต้นฉบับ (โดยทั่วไปคือชุดไบต์ใดๆ เช่น ไฟล์ที่กำหนดเอง) และสตริงรหัสผ่าน แนวคิดของอัลกอริทึมคือการดำเนินการ XOR แบบลอจิคัลระดับบิตจะถูกนำไปใช้กับอักขระแต่ละตัวของข้อความต้นฉบับและอักขระถัดไปของสตริงรหัสผ่าน ผลลัพธ์จะถูกเขียนลงในไฟล์ การดำเนินการ XOR นั้นสมมาตร ซึ่งหมายความว่าหากคุณเข้ารหัสไฟล์เดียวกัน 2 ครั้งด้วยรหัสผ่านเดียวกัน ผลลัพธ์จะเป็นไฟล์นี้เองโดยไม่มีการเปลี่ยนแปลง จากข้อเท็จจริงนี้เห็นได้ชัดว่าจะใช้ฟังก์ชันเดียวกันในการเข้ารหัสและถอดรหัส ซึ่งช่วยให้การนำอัลกอริทึมไปใช้ง่ายขึ้นอย่างมาก ยิ่งไปกว่านั้น หากใช้รหัสผ่านเดียวกันระหว่างการถอดรหัสเช่นเดียวกับระหว่างการเข้ารหัส ผลลัพธ์ที่ได้จะเป็น ไฟล์ต้นฉบับ- หากรหัสผ่านแตกต่างกัน ผลลัพธ์จะเป็นไฟล์ที่มีข้อมูลที่ไม่ถูกต้อง ลองดูอัลกอริธึมการเข้ารหัส XOR โดยละเอียด:
หากรหัสผ่านสั้นกว่าไฟล์ต้นฉบับ (และในกรณีส่วนใหญ่จะเป็นเช่นนี้) รหัสผ่านจะถูกใช้แบบวนรอบ เช่น หลังจากอักขระตัวสุดท้ายของรหัสผ่านเราจะกลับไปที่รหัสผ่านตัวแรก มีความจำเป็นต้องดำเนินการตามขั้นตอน: ขั้นตอน XOR_CoDec (const SourceFile, DestFile, รหัสผ่าน: string); โดยที่ต่อไปนี้ถูกส่งเป็นพารามิเตอร์: SourceFile – ชื่อของไฟล์ต้นฉบับ DestFile – ชื่อของไฟล์ผลลัพธ์ การดำเนินการไบนารี XOR (ย่อมาจาก eXCLUSIVE OR) เป็นตัวถูกดำเนินการไบนารี (เช่นเดียวกับ AND, OR ฯลฯ) จากพีชคณิตแบบบูล ตัวถูกดำเนินการนี้จะเปรียบเทียบสองบิตและจะสร้างหนึ่งบิตเป็นการตอบแทน บิตนั้นจะเท่ากับ 1 หากบิตที่เปรียบเทียบทั้งสองแตกต่างกัน และ 0 หากเท่ากัน โดยทั่วไปการเข้ารหัส Xor จะใช้ในการเข้ารหัสแบบสมมาตรหลายตัว (โดยเฉพาะ AES) การเข้ารหัสแบบสมมาตรเป็นเพียงการเข้ารหัสที่ใช้คีย์สำหรับกระบวนการเข้ารหัสและถอดรหัส ตัวถูกดำเนินการ XOR จะถูกนำไปใช้กับแต่ละบิตระหว่างข้อความที่คุณต้องการเข้ารหัสและคีย์ที่คุณจะเลือก ตัวอย่างดีกว่าคำพูด ลองใช้คำว่า "xor" กัน เราต้องการเข้ารหัสด้วยคีย์ "cle" ก่อนอื่นเราต้องแปลง อินพุตและกุญแจสำคัญในการเป็นตัวแทนไบนารี่:จากนั้นเราจะเปรียบเทียบแต่ละบิตกับตัวถูกดำเนินการ XOR ซึ่งจะให้สิ่งนี้แก่คุณ: เซอร์: 01111000 01101111 01110010 หากเราต้องการกลับไปยังอินพุตดั้งเดิม ("xor") เราก็จะต้องใช้ XOR อีกครั้งระหว่างเอาต์พุตและคีย์ คุณจะสังเกตได้ว่า XOR เป็นฟังก์ชันสับเปลี่ยนซึ่งเป็นการคูณ ทีนี้เราจะทำอย่างไรถ้าคีย์มีขนาดเล็กกว่าอินพุต? เป็นกรณีนี้ในสถานการณ์ส่วนใหญ่ หากคีย์มีความยาวเท่ากันกับอินพุต มันจะไม่น่าสนใจเพราะคุณจะต้องสื่อสารคีย์กับบุคคลที่คุณต้องการอ่านอินพุตด้วย ในทางตรงกันข้าม เมื่อคีย์และอินพุตมีความยาวเท่ากัน เป็นไปไม่ได้ที่ใครจะถอดรหัสรหัสได้ ดังนั้น เมื่อคีย์มีขนาดเล็กกว่าอินพุต คุณก็แค่ใช้มันใหม่จนกว่าจะถึงจุดสิ้นสุดของอินพุต หากฉันต้องการเข้ารหัสคำว่า "bonjour" ด้วยคีย์ "cle" ของฉัน ฉันจะทำเช่นนี้: สวัสดี: 01100010 01101111 01101110 01101010 01101111 01110101 01110010 คุณจะเห็นว่าเราเพียงแค่ทำซ้ำคีย์ ยิ่งคีย์เล็กเท่าไร การถอดรหัสรหัสของคุณก็จะง่ายที่สุด (แน่นอน) การแคร็ก XOR มักขึ้นอยู่กับการวิเคราะห์ความถี่ แต่สำหรับเรื่องนั้น ฉันขอแนะนำให้คุณทำการวิจัย รหัสสตรีมดำเนินการกับบิตหรืออักขระ (เช่น 8-, 16- หรือ 32-บิต) รหัสสตรีมจะแปลงอักขระข้อความธรรมดาเดียวกันให้เป็นอักขระไซเฟอร์เท็กซ์ที่แตกต่างกัน เช่น ขึ้นอยู่กับจำนวนอักขระและอักขระใดที่ได้รับการประมวลผลก่อนหน้านี้ การเข้ารหัสเอ็กซ์ออร์ในการเข้ารหัสสตรีมจำนวนมาก การเข้ารหัสจะดำเนินการดังนี้ เครื่องกำเนิดตัวเลขสุ่มเทียมจะสร้างลำดับของบิต (แกมมา) แกมมานี้ใช้กับข้อความธรรมดาโดยใช้การดำเนินการ XOR ระดับบิต ผลลัพธ์ที่ได้คือไซเฟอร์เท็กซ์ ในการถอดรหัส คุณต้องทำตามขั้นตอนเดียวกันทุกประการ ใช้เฉพาะแกมมาที่ได้รับโดยใช้ตัวสร้างที่เหมือนกันซึ่งมีสถานะเริ่มต้นเหมือนกันทุกประการกับไซเฟอร์เท็กซ์ พิจารณาแนวคิดเรื่องนี้ วิธีที่ง่ายที่สุด- ดังที่ได้ทราบมาจาก พีชคณิตแบบบูลการดำเนินการของการบวกเชิงตรรกะ “⊕” โมดูโล 2 (หรือตรรกะเอกสิทธิ์เฉพาะบุคคล OR – XOR, eX Exclusive OR) มีความหมายดังต่อไปนี้: |
ตารางความจริงสำหรับ XOR:
|
|
นั่นก็คือ การดำเนินการ z= x⊕ ยโดยพื้นฐานแล้วจะเป็นระดับบิต (ระดับบิต - ผลลัพธ์ไม่ได้ขึ้นอยู่กับบิตที่อยู่ติดกัน) ถ้าบิตที่สอดคล้องกันเพียงตัวเดียวคือ 1 ผลลัพธ์ก็คือ 1 และถ้าทั้งคู่เป็น 0 หรือทั้งสองเป็น 1 ผลลัพธ์ก็คือ 0 หากคุณดูผลลัพธ์ของการใช้อย่างใกล้ชิด แฮคเกอร์ให้เป็นเลขฐานสองสองตัว คุณจะเห็นว่าเราสามารถกู้คืนเงื่อนไขใดเงื่อนไขหนึ่งได้โดยใช้ตัวที่สอง: x= z⊕ ยหรือ ย= z⊕ x.
จากนี้เราสามารถสรุปได้ดังต่อไปนี้: การรู้จำนวน ยและการสมัคร แฮคเกอร์ถึง xเราจะได้ z- จากนั้นเราก็ใช้อีกครั้ง ยเราได้รับจาก zหมายเลขหลัง x- ด้วยวิธีนี้เราสามารถแปลงลำดับของตัวเลข ( x) ฉันตามลำดับ ( z) ฉัน- ตอนนี้เราสามารถตั้งชื่อหมายเลขได้แล้ว ยคีย์การเข้ารหัส (หรือการเข้ารหัส) หากบุคคลไม่ทราบรหัสเขาจะไม่สามารถเรียกคืนลำดับตัวเลขดั้งเดิมได้ ( x) ฉัน- แต่ถ้า ( x) ฉันเป็นการแทนไบต์ของตัวอักษรของข้อความ จากนั้นผู้ใช้ที่มีประสบการณ์จะสามารถถอดรหัสข้อความที่เข้ารหัสได้ เนื่องจากตัวอักษรแต่ละตัวจะถูกแสดงในไซเฟอร์เท็กซ์ด้วยรหัสเดียวกัน zจากนั้นใช้พจนานุกรมความถี่ ผู้โจมตีจะสามารถคำนวณคีย์เข้ารหัสได้ ยหากเขามีข้อความไซเฟอร์เท็กซ์ที่ยาวเพียงพอ
จากการพิจารณาล่าสุด เราได้ข้อสรุปว่าเป็นไปไม่ได้ที่จะเข้ารหัสข้อความธรรมดาโดยตรง ประการแรก ตัวเลขที่แสดงถึงช่องว่างจะยังคงแยกคำในไซเฟอร์เท็กซ์ ด้วยการเน้นหมายเลขเดียวกันที่เกิดขึ้นบ่อยครั้งนี้ ผู้ใช้จะคาดเดาว่าเป็นพื้นที่ที่เข้ารหัส ประการที่สอง คำบุพบทและคำสันธานสั้น ๆ ที่เกิดขึ้นบ่อย ๆ จะช่วยแครกเกอร์ในการระบุคีย์ด้วย ดังนั้น วิธีที่มีประสิทธิภาพมากที่สุดคือการใช้คีย์ยาวที่ครอบคลุมตัวอักษรหลายตัว หรือดีกว่านั้นคือมีความยาวเท่ากับข้อความ ดังนั้น หากเราเข้ารหัสข้อความที่ยาวเพียงพอ (อย่างน้อย 5-10 ประโยค) โดยใช้คีย์สุ่มที่มีความยาวเท่ากัน ข้อความดังกล่าวก็จะถอดรหัสได้ยากมาก ผลลัพธ์ความน่าเชื่อถือที่สูงขึ้นสามารถทำได้ ตัวอย่างเช่น ข้อความถูกบีบอัดด้วยโปรแกรมเก็บถาวรบางประเภทก่อนการเข้ารหัส นอกจากนี้ หากข้อความสั้น คุณสามารถเพิ่มลำดับอักขระแบบสุ่มที่จุดเริ่มต้นและจุดสิ้นสุดของข้อความได้
ดังนั้นความทนทานของอัลกอริธึมจึงขึ้นอยู่กับลักษณะของแกมมาที่สร้างโดยเครื่องกำเนิดเท่านั้น หากแกมม่าประกอบด้วยเลขศูนย์เท่านั้น (ตัวพิมพ์เสื่อม) ข้อมูลจะไม่เปลี่ยนแปลงเลยในระหว่างการเข้ารหัส หากแกมมามีช่วงเวลาสั้น (เช่น 32 บิต) การเข้ารหัสจะลดลงเป็นการดำเนินการ XOR ที่มีค่าคงที่ 32 บิต หากแกมม่าเป็นชุดบิตแบบสุ่มที่ไม่เป็นไปตามรูปแบบใดๆ ผลลัพธ์ที่ได้คืออะนาล็อกของแผ่นเข้ารหัสแบบครั้งเดียวที่ให้การป้องกันที่สมบูรณ์ แน่นอนว่า อัลกอริธึมเชิงกำหนดที่ใช้ในเครื่องกำเนิดแกมมาไม่สามารถสร้างลำดับแบบสุ่มอย่างแท้จริงได้ หากไม่สามารถทำซ้ำลำดับได้ ข้อความจะไม่ถูกถอดรหัส
หากข้อความสองข้อความถูกเข้ารหัสโดยใช้แกมมาเดียวกัน และข้อความหนึ่ง (ข้อความที่ยาวกว่า) สามารถรับข้อความธรรมดาได้ ก็จะเป็นการง่ายที่จะรับข้อความธรรมดาสำหรับข้อความอื่น เมื่อใช้การดำเนินการ XOR กับข้อความธรรมดาและข้อความไซเฟอร์เท็กซ์ของข้อความแรก เราได้รับส่วนของแกมมา และโดยการใช้แกมม่ากับไซเฟอร์เท็กซ์ของข้อความที่สอง เราจะได้ข้อความธรรมดา นี่คือสาเหตุที่ไม่ควรอนุญาตให้ใช้แกมม่าเดียวกันเมื่อเข้ารหัสสตรีมหรือข้อความที่แตกต่างกันสองรายการ
หากแกมมาถูกสร้างขึ้นโดยไม่ขึ้นอยู่กับเนื้อหาข้อความ อัลกอริธึมการสตรีมดังกล่าวจะเรียกว่าซิงโครนัส โดยทั่วไปแล้ว ในการเข้ารหัสสตรีมแบบซิงโครนัส คีย์การเข้ารหัสจะใช้เพื่อตั้งค่าสถานะภายในเริ่มต้นของเครื่องกำเนิดแกมมา
ตามคำจำกัดความ การดำเนินการหรือการดำเนินการแบบเอกสิทธิ์เฉพาะบุคคลหนึ่งบิตสองครั้งจะดำเนินการตามที่แสดงในตาราง 19.1.
ตารางที่ 19.1 เอกสิทธิ์หรือ(XOY)
|
อินพุต 1 |
อินพุต 2 |
ออก |
นอกจากนี้ยังสามารถเรียกว่า "การดำเนินการที่ไม่ตรงกัน" - เอาต์พุตเป็นตรรกะเมื่อค่าที่อินพุตไม่ตรงกัน จากคำจำกัดความนี้ มันง่ายที่จะอนุมานคุณสมบัติหลักของการดำเนินการนี้: หากใช้สองครั้งกับตัวถูกดำเนินการเดียวกัน มันจะไม่เปลี่ยนแปลงอะไรเลย โดยไม่คำนึงถึงค่าของตัวถูกดำเนินการที่สอง ตราบใดที่มันไม่เปลี่ยนแปลง โดยเฉพาะอย่างยิ่งมีการใช้กันอย่างแพร่หลายใน คอมพิวเตอร์กราฟิก: หากคุณใช้มาสก์ที่ประกอบด้วยหน่วยทั้งหมด (สีขาวบริสุทธิ์) กับพื้นหลังผ่านการดำเนินการ XOR รูปภาพ ณ สถานที่นี้จะกลับเป็นสี เมื่อทำการกระทำเดียวกันซ้ำทุกอย่างจะถูกกู้คืนไม่เปลี่ยนแปลง (โดยเฉพาะ สะดวกสำหรับการเลือกดูบทที่ 10)
คุณสมบัตินี้เป็นพื้นฐานสำหรับอัลกอริทึมการเข้ารหัสเกือบทั้งหมด ซึ่งบางครั้งอาจซับซ้อนมาก แต่เราจะไม่เจาะลึกปัญหานี้ แต่จะพยายามใช้วิธีการนี้ในรูปแบบดั้งเดิม หากต้องการตรวจสอบ คุณสามารถใช้ขั้นตอนง่ายๆ นี้ สมมติว่าเราต้องการเข้ารหัสบางอย่าง ไฟล์ข้อความ- เนื่องจากเราไม่ได้ซ่อนความลับทางการทูต ความยาวคีย์ปกติในกรณีเช่นนี้คือ 8 ตัวอักษร (64 บิต) ก็เพียงพอแล้วสำหรับเรา - ซึ่งเพียงพอแล้วในการถอดรหัสรหัสด้วยกำลังดุร้ายโดยใช้รหัสปกติ คอมพิวเตอร์ส่วนบุคคลงานที่แก้ไม่ได้ "ทันที" เช่น คีย์จะเป็นคำว่า "yvre-vich" ในทางปฏิบัติ ไม่สามารถสร้างคีย์ดังกล่าวจากนามสกุลของคุณได้ นอกจากนี้ คุณยังไม่สามารถใช้คำในพจนานุกรม วันที่ และหมายเลขโทรศัพท์ได้ Vernam ยังแสดงให้เห็นว่าเพื่อให้การเข้ารหัสมีประสิทธิภาพ คีย์จะต้องดำเนินการแบบสุ่มอย่างเคร่งครัดเท่านั้น เป็นตัวอย่าง (เราจะพูดถึงวิธีการตั้งค่าคีย์สุ่มในภายหลัง)
มาสร้างโปรเจ็กต์ใหม่ (ในโฟลเดอร์ Glaval9\l) ชื่อ ProbaCrypt และวางไฟล์ไว้ในโฟลเดอร์เดียวกันเพื่อทำการทดสอบ ฉันเอาข้อความของเพลง "วันหนึ่งโลกจะโค้งงอภายใต้เรา" จากละครของ A. Makarevich (ในรูปแบบข้อความเดียวกันไฟล์ mashinavremeni.txt) พร้อมคอร์ดเพราะการจัดรูปแบบที่ค่อนข้างซับซ้อนของข้อความนี้จะทำให้ ตัวอย่างที่ชัดเจนยิ่งขึ้น 3
มาวางองค์ประกอบ Memo กล่องโต้ตอบ OpenDialog และปุ่มอีเมล Butt สองปุ่มลงในแบบฟอร์ม ในส่วนหัวของ Buttoni เราจะเขียน Encrypt ในส่วนหัวของ Buttoni - Decrypt มาประกาศตัวแปรดังต่อไปนี้:
รูปแบบ: TForml; fname, คีย์: สตริง; fi, fo: ไฟล์ไบต์; ฉัน:จำนวนเต็ม; xb:ไบต์;
เมื่อสร้างแบบฟอร์ม เราจะเริ่มต้นคีย์และกล่องโต้ตอบ:
ขั้นตอน TForml.FormCreate (ผู้ส่ง: TObject); ปุ่มเริ่มต้น:='yvrevich";
OpenDialogl.InitialDir:=ExtractFiieDir (Application.ExeName); จบ;
ในตัวจัดการการคลิกปุ่ม Buttonl เราจะเขียนโค้ดที่ค่อนข้างยาวต่อไปนี้:
ขั้นตอน TForml.ButtonlClick (ผู้ส่ง: TObject); เริ่ม /เข้ารหัส/ OpenDialogl. ชื่อไฟล์:?= 11 ;(ทำความสะอาด) OpenDialogl.Filter:=”; ถ้า OpenDialogl.Execute แล้ว fname:=OpenDialogl.FileName อื่นออก; มอบหมายไฟล์ (fi, fname);(ไฟล์ต้นฉบับที่ระบุI พยายาม
รีเซ็ต (FI); (เปิดอันเดิม)ยกเว้น
ออก; (ถ้าไม่ เปิด-ออก)จบ;
มอบหมายไฟล์(สำหรับ,ChangeFileExt(fname, 1 .sec’)) ; เขียนใหม่ (สำหรับ);
อ่าน(fi,xb); (อ่านไบต์แรก)
Forml.Caption:=’ProbaCrypt: ‘+ExtractFileName(fname);
/ชื่อไฟล์ - วีชื่อ) Memol.Lines.ชัดเจน; Memol.Lines.Add('รอสักครู่...');
แอปพลิเคชัน กระบวนการข้อความ; Memol.Lines.ชัดเจน; ในขณะที่ไม่ใช่ eof(fi) จะเริ่มต้น
xb:=xb xor ord(คีย์[i]);(เราเข้ารหัส)
Memol.Text:=Kemol.Text+ไค(xb);(ส่งออกไปยังบันทึก)
เขียน (สำหรับ xb); (เขียนลงไฟล์)
อ่าน(fi,xb); (หากไฟล์อยู่ท้ายสุดให้ออก)ยกเว้นการแตกหัก; จบ; จบ; จบ;
ไฟล์ปิด(fi) ;
ลบ(FI); (ทำลายต้นตอ)
closefile(สำหรับ);
(เข้ารหัส)จบ;
ที่นี่เราเพิ่มแต่ละไบต์ของไฟล์ต้นฉบับด้วยไบต์คีย์ตามลำดับผ่านการดำเนินการ XOR เมื่อคีย์จบลงเราจะเริ่มต้นใหม่อีกครั้งด้วยอักขระตัวแรก เราเขียนผลลัพธ์ลงในไฟล์ที่มีนามสกุล sec (จาก "ความปลอดภัย") และส่งออกไปยัง Memoi เราดำเนินการแบบเดียวกันทุกประการเมื่อทำการถอดรหัส เฉพาะกับไฟล์ที่เข้ารหัสเท่านั้น ซึ่งส่งผลให้ไฟล์ต้นฉบับได้รับการกู้คืนอย่างสมบูรณ์:
ขั้นตอน TForml.Buttor.2Click (ผู้ส่ง: TObject); เริ่ม(พ่อแปลงเป็นดิจิทัลเจ OpenDialogl.FileName:=”;(ทำความสะอาด/ OpenDialogl.Filter: = ‘หมายเลข 4>ไฟล์ poBaHHbie| *.วินาที' ; ถ้า OpenDialogl.Execute แล้ว fname:OpenDialogl.FileName มิฉะนั้นจะออก มอบหมายไฟล์ (fi, fname);(เปิดแบบเข้ารหัส) พยายาม
รีเซ็ต (FI); ยกเว้นทางออก; จบ;
มอบหมายไฟล์ (สำหรับ ChangeFileExt (fname, '.txt')); เขียนใหม่ (สำหรับ);(เขียนทับอันเก่า) อ่าน(fi,xb);
Forml.Caption:='ProbaCrypt: '+ExtractFileNajne (fname) ;
!ชื่อไฟล์ – ใน headerj
Memol.Lines.ชัดเจน;
Memol.Lines.Add(1 รอ...');
แอปพลิเคชัน กระบวนการข้อความ;(เพื่อดูคำเตือน) Memol.Lines.ชัดเจน; ในขณะที่ไม่ใช่ eof(fi) จะเริ่มต้นเปลี่ยนแปลงตามข้างต้น) สำหรับ i:=l ถึง length(key) จะเริ่มต้น
xb:=xb xor ord(keyU));
Memol.Text:=Memol.Text+chr(xb);
เขียน (สำหรับ xb);
อ่าน(fi,xb); ยกเว้นการแตกหัก; จบ; จบ; จบ;
ไฟล์ปิด(fi); closefile(สำหรับ);(เข้ารหัสแล้ว) จบ;
โปรดทราบว่าฉันไม่ได้ทำลายไฟล์ที่เข้ารหัส - โดยหลักการแล้ว การดำเนินการเข้ารหัสสามารถทำได้หลายครั้งตามที่คุณต้องการบนข้อความที่เข้ารหัสแล้ว ในการถอดรหัสคุณจะต้องทำซ้ำในจำนวนเท่าเดิมและเทคนิคนี้ มักใช้ในอัลกอริธึมการเข้ารหัส "อย่างเป็นทางการ" (เฉพาะในกรณีนี้คุณจะต้องเปลี่ยนชื่อไฟล์ที่เข้ารหัสด้วยตนเองหรือแก้ไขโปรแกรมเล็กน้อยในรูปแบบปัจจุบันจะไม่อนุญาตให้คุณเปิดไฟล์เดียวกันสำหรับการถอดรหัสทั้งสอง และการเข้ารหัส) โดยปกติแล้ว ขั้นตอนการเข้ารหัสสามารถนำไปใช้กับไฟล์ใดๆ ก็ได้ ไม่ใช่แค่ไฟล์ข้อความเท่านั้น
มีจุดละเอียดอ่อนที่เกี่ยวข้องกับการทำลายต้นฉบับ - อย่างที่คุณทราบเมื่อทำลายไฟล์ดิสก์จะไม่ถูกลบเหมือนกับการบันทึกเพลงบนเทปแม่เหล็ก แต่เพียงในโครงสร้างส่วนหัวของ FAT พื้นที่นั้นจะถูกทำเครื่องหมายไว้ ฟรี (สิ่งนี้เกิดขึ้นใน NTFS เช่นกัน) ด้วยคุณสมบัตินี้เองที่เชื่อมต่อการทำงานของโปรแกรม DOS Unerase (ถ้าใครจำได้ว่ามันคืออะไร) ดังนั้นแม้ว่าคุณจะลบไฟล์ออกจากถังรีไซเคิล (อย่างไรก็ตามไฟล์ที่ถูกลบออกจากโปรแกรมของเราไม่ได้ไปอยู่ในถังรีไซเคิล) เนื้อหาของไฟล์จะยังคงอยู่ในดิสก์จนกว่าจะมีการเขียนอย่างอื่นที่นั่น ดังนั้น สำหรับบุคคลที่หวาดระแวงเป็นพิเศษ โปรแกรมเข้ารหัสขั้นสูงจึงเสนอตัวเลือกที่รับประกันว่าไฟล์จะถูกทำลายหลังจากการลบ ในกรณีของเรา โดยหลักการแล้ว ในการทำเช่นนี้ก็เพียงพอแล้วโดยไม่ต้องปิดไฟล์เพื่อเติมไบต์ด้วยค่าศูนย์ (หรืออื่น ๆ แต่ไม่เพิ่มหรือลดขนาดไฟล์) ให้เขียนสิ่งนี้ลงดิสก์ (ปิด ไฟล์) แล้วทำลายมัน จริงอยู่ที่ใน Windows ฉันไม่สามารถรับประกันได้ 100% ว่าจะถูกเขียนไปยังที่เดียวกันทุกประการ ดังนั้นในกรณีเช่นนี้ จะดีกว่าถ้าใช้โปรแกรม "อย่างเป็นทางการ" ซึ่งในทางกลับกันจะทำลายร่องรอยของแหล่งที่มาไม่เพียง แต่ใน พื้นที่ของดิสก์ที่เก็บไว้ แต่ยังอยู่ในไฟล์ Windows SWAP ด้วยหากยังคงอยู่ตรงนั้น
สำหรับการสร้างคีย์แบบสุ่ม นี่เป็นวิธีหนึ่ง ฉัน ฉันจะไม่ระบุการดำเนินการทั้งหมดเนื่องจากเป็นเรื่องง่าย ตัวสร้างตัวเลขสุ่มหลอกใน Delphi (และไม่เพียงแต่ใน Delphi) ได้รับการออกแบบดังนี้: หมายเลขเริ่มต้นของตัวสร้างถูกตั้งค่าผ่านตัวแปร RandSeea (แต่โดยค่าเริ่มต้นคือ 0) จากนั้นฟังก์ชัน Random เมื่อเข้าถึงตามลำดับจะส่งคืนชุดตัวเลขเดิมเสมอไม่ว่าเราจะใช้งานโปรแกรมใดและเมื่อใด ดังนั้นวิธีการ - คุณติดตั้งตัวสร้างดังกล่าวในโปรแกรมและสร้างคีย์ตามนั้น นี่คือวิธีที่คุณสามารถสร้างชุดอักขระแบบสุ่ม 16 ไบต์ (128 บิต) ซึ่งจะขึ้นอยู่กับค่าของออฟเซ็ตเริ่มต้นของตัวสร้าง init เท่านั้น:
:
เริ่มต้น: จำนวนเต็ม; เซนต์:สตริง;
เซนต์:=”;
RandSeed:=init;(ออฟเซ็ตเริ่มต้น) ในขณะที่ความยาว(st)<16 do begin xb:=Random(255); if xb>31 จากนั้น st:=st+chr(xb); จบ;
ในกรณีนี้ คุณถ่ายโอนไปยังผู้ติดต่อของคุณ ไม่ใช่คีย์ แต่เป็นค่า ir.j .. เขาจะมีคีย์เดียวกันที่สร้างขึ้นโดยใช้ขั้นตอนที่เหมือนกันทุกประการ แน่นอนว่าคุณสามารถสร้างกลไกที่ชาญฉลาดมากขึ้นในการนำวิธีนี้ไปใช้
ฉันต้องการทราบเพื่อไม่ให้ปิดบังสาระสำคัญของเรื่องก่อนหน้านี้ในโปรแกรมฉันใช้การอ่านแบบไบต์ต่อไบต์แบบดั้งเดิมจากไฟล์ดิสก์ คุณสามารถเร่งกระบวนการได้อย่างมากโดยใช้กลไกอย่างใดอย่างหนึ่งในการอ่านไฟล์เบื้องต้นลงในหน่วยความจำ - การแมปไฟล์ ดังในบทที่ 14 การอ่านแบบสตรีมมิ่ง หรือวิธีอื่นใดในการจัดระเบียบอาร์เรย์แบบไดนามิกในหน่วยความจำ (ดูบทที่ 21) ในตัวอย่างที่ใช้สุริยคติ ซึ่งเราจะดำเนินการต่อไป สถานการณ์นี้จะได้รับการแก้ไขบางส่วน
| อ่าน: |
|---|
เป็นที่นิยม:
วิธียกเลิกการสมัครสมาชิก Megogo บนทีวี: คำแนะนำโดยละเอียด วิธียกเลิกการสมัครสมาชิก Megogo
|
ใหม่
- วิธีจัดรูปแบบความต่อเนื่องของตารางใน Word อย่างถูกต้อง
- จะทำอย่างไรถ้าคุณพัฒนาแบบออฟไลน์
- การทดสอบโปรเซสเซอร์ว่ามีความร้อนสูงเกินไป
- บริการสาธารณะของ Yesia คืออะไร
- ตำแหน่งของหัวบนเสาอากาศ
- วิธีดาวน์โหลดและกำหนดค่าผู้ช่วยอัจฉริยะสำหรับอุปกรณ์ Android
- ตัวเลือก "ทุกที่ที่บ้าน" และ "ทุกที่ที่บ้านในรัสเซีย" MTS - คำอธิบายต้นทุนวิธีเชื่อมต่อ
- วิธีการกู้คืนหรือรีเซ็ตรหัสผ่านผู้ใช้ Windows
- วิธีลบโปรแกรม Avast อย่างสมบูรณ์เพื่อลบ Avast
- แอปพลิเคชั่นมือถือ Aliexpress
