ความรับผิดชอบของการแลกเปลี่ยนคีย์

ฉันใช้การแลกเปลี่ยนคีย์แบบอสมมาตรเพื่อสร้างคีย์แบบสมมาตร

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

ฉันต้องการตั้งค่าตัวแปรพื้นฐานเหล่านี้:

• ไคลเอนต์มีคีย์สาธารณะของเซิร์ฟเวอร์ฮาร์ดโค้ดในหน่วยความจำ
• เซิร์ฟเวอร์มีไพรเวตคีย์ฮาร์ดโค้ดในหน่วยความจำ
• มีฮาร์ดโค้ด nonce_size
• มีฮาร์ดโค้ด public_key_size
• มีฮาร์ดโค้ด mac_size

ขั้นตอนการสื่อสารเพื่อแลกเปลี่ยนมีดังนี้

1. หลังจากการเชื่อมต่อ TCP สำเร็จ ลูกค้าจะสร้างรหัสสาธารณะใหม่ client_pubkeyเข้ารหัสรหัสสาธารณะของตัวเอง client_pubkey ใช้ nonce ใหม่ temp_nonce_1 และฮาร์ดโค้ด server_pubkeyและส่งข้อความโดยที่ไบต์แรกคือ nonce และที่เหลือคือการเข้ารหัส client_pubkey (รวมถึง mac ด้วย) นี้มีขนาดที่รู้จักของ nonce_size + public_key_size + mac_size.
2. เซิร์ฟเวอร์ได้รับข้อความ กำลังตรวจสอบขนาดพอดี nonce_size + public_key_size + mac_size. หากเป็นเช่นนั้น จะถือว่าเป็นการแลกเปลี่ยนคีย์ มันถอดรหัสลับ public_key จากนั้นเซิร์ฟเวอร์จะสร้างใหม่ สมมาตร_คีย์และส่งข้อความกลับโดยมี nonce ใหม่ tmp_nonce2และคีย์สมมาตร + mac เข้ารหัสโดยใช้ที่ได้รับ client_pubkey.
3. ลูกค้าได้รับข้อความนี้ ทราบแน่ชัดว่าควรมีขนาดเท่าใด มิฉะนั้นจะปฏิเสธ ขณะนี้ไคลเอนต์มีคีย์สมมาตรที่จะใช้
4. เซิร์ฟเวอร์และไคลเอนต์สื่อสารผ่านคีย์สมมาตร

ดังนั้นนี่คือความพยายามของฉันในการทำความเข้าใจว่าเหตุใดจึงปลอดภัย:

1. ในกรณีที่มีการส่งไบต์ขยะแบบสุ่มไปยังเซิร์ฟเวอร์ เซิร์ฟเวอร์จะสร้างคีย์ เข้ารหัสคีย์โดยใช้ขยะ สร้างขยะเพิ่ม แล้วจึงส่งข้อมูลนั้น ดังนั้นในความเป็นจริง เราได้ส่งขยะออกไปมากขึ้น และจากนั้นเราก็ไม่ได้รับข้อความที่ถูกต้องและหมดเวลาในที่สุด เป็นการปิดการเชื่อมต่อ ข้อเสียเพียงอย่างเดียวคือเสียเวลา CPU ไปสองสามวินาที
2. ไคลเอ็นต์ส่ง public_key เฉพาะค่าศูนย์ (หรือบิตเซ็ตที่ชัดเจนอื่นๆ เช่น 1 ทั้งหมด) และค่า nonce ที่ถูกต้อง (หรือศูนย์ด้วย) ในกรณีนี้ เซิร์ฟเวอร์ถือว่าศูนย์เป็นคีย์สาธารณะ และส่งคีย์สมมาตรที่เข้ารหัสผ่านคีย์สาธารณะที่เป็นศูนย์ อย่างไรก็ตาม การดำเนินการนี้ยังคงปลอดภัยเนื่องจากการมีรหัสสาธารณะเป็นเลขศูนย์ถือว่าคุณทราบรหัสส่วนตัวที่ระบุว่าได้รหัสเป็นศูนย์จาก public_key ซึ่งอาจใช้เวลาหลายพันล้านปีในการวิศวกรรมย้อนกลับ ดังนั้นจึงยังปลอดภัย
3. สมมติว่าไคลเอนต์และเซิร์ฟเวอร์สามารถรีสตาร์ทกระบวนการนี้ได้อย่างไร้ขีดจำกัด (และไม่มีขีดจำกัด x-try บนเซิร์ฟเวอร์) สมมติว่าโชคที่คำนวณไม่ได้และการสุ่มส่งไบต์แบบสุ่ม การแลกเปลี่ยนคีย์เกิดขึ้น และข้อความที่ถูกต้องของข้อมูลใดก็ตามที่เซิร์ฟเวอร์เป็น เซิร์ฟเวอร์ส่งและแยกวิเคราะห์ความคาดหวัง เราโยนแขนขึ้นไปในอากาศเพราะเข้าถึงได้ยากและโดยพื้นฐานแล้ว อึเกิดขึ้น.
   • ในกรณีนี้ เราไม่สามารถบอกว่าใครต้องรับผิดได้ ? ไม่มีอะไรที่เซิร์ฟเวอร์สามารถทำได้เกี่ยวกับการรู้ว่าเป็นแพ็กเก็ตที่เป็นอันตราย
   • แม้ว่าเราจะมีขีดจำกัด x-retry ที่ 2 ครั้ง แต่ในทางทฤษฎีแล้ว มันสามารถเกิดขึ้นได้ในการเชื่อมต่อครั้งแรกจากที่อยู่ IP และอีกครั้งที่เราทำอะไรไม่ได้

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

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