मैकएलीस एंड रस्ट: एजिंग स्लोली टू ए एनआईएसटी स्टैंडर्ड फॉर पीक्यूसी

May 08 2023

हम एक ऐसी दुनिया में रहते हैं जिस पर बड़े (और फेसलेस) निगमों का प्रभुत्व है, लेकिन यह ऐसे व्यक्ति हैं जिन्होंने अक्सर हमारी सूचना दुनिया का निर्माण किया है। उनमें से एक थे रॉबर्ट जे.

अनस्प्लैश पर नेरेन ग्रोबलर द्वारा फोटो

हम एक ऐसी दुनिया में रहते हैं जिस पर बड़े (और फेसलेस) निगमों का प्रभुत्व है, लेकिन यह ऐसे व्यक्ति हैं जिन्होंने अक्सर हमारी सूचना दुनिया का निर्माण किया है। उनमें से एक रॉबर्ट जे. मैकलीस थे, जिनका मई 2019 में 76 वर्ष की आयु में निधन हो गया था। अंतरिक्ष से संबंधित कई परियोजनाओं पर काम करते हुए, उन्होंने सूचना प्रसारण और भंडारण सहित कई क्षेत्रों में योगदान दिया। रॉबर्ट को अंततः उनके काम के लिए क्लाउड ई. शैनन पुरस्कार से सम्मानित किया गया, और उन्होंने कई यादगार भाषण दिए:

और:

उनका सबसे अच्छा काम त्रुटि-सुधार कोड के आसपास है, जिसमें कनवल्शन कोड भी शामिल है, और अब उनका काम एक एन्क्रिप्शन सिस्टम बनाने में बहुत ध्यान दे रहा है जो क्वांटम कंप्यूटर के खिलाफ मजबूत होगा।

ऊनका काम

हमारी कई सार्वजनिक कुंजी विधियाँ असतत लघुगणक पर आधारित हैं और जो जॉन नेपियर द्वारा बनाए गए सिद्धांतों पर आधारित हैं। बिटकॉइन, टोर, स्मार्ट कार्ड, वाईफाई, और कई अन्य एप्लिकेशन असतत लघुगणक का उपयोग करते हैं। लेकिन इन विधियों और अन्य सार्वजनिक-कुंजी विधियों को क्वांटम कंप्यूटर से खतरा है। एक दावेदार मैकएलीस क्रिप्टोग्राफी पद्धति है।

किसी भी आधुनिक शोधकर्ता के लिए एक पाठ में, केवल दो पृष्ठों में, रॉबर्ट मैकएलिस ने 1978 में, बीजीय कोडिंग पर आधारित एक सार्वजनिक कुंजी एन्क्रिप्शन विधि की रूपरेखा तैयार की थी - जिसे अब मैकएलिस क्रिप्टोग्राफी विधि [पेपर] [1] के रूप में जाना जाता है । यह एक असममित एन्क्रिप्शन विधि है (सार्वजनिक कुंजी और निजी कुंजी के साथ), और, उस समय, एक ट्रैपडोर विधि के लिए एक गंभीर दावेदार के रूप में देखा गया। दुर्भाग्य से, RSA हिल का राजा बन गया, और McEliece पद्धति को डिजाइनरों के लिए कतार के अंत तक धकेल दिया गया।

यह मूल रूप से लगभग 40 वर्षों से बह रहा है। लेकिन, जैसे-जैसे क्वांटम कंप्यूटरों का युग शुरू हो रहा है, अब इस पर पुनर्विचार किया जा रहा है, क्योंकि इसे शोर के एल्गोरिद्म [ यहाँ ] का उपयोग करके हमलों के लिए प्रतिरक्षा के रूप में देखा जाता है।

एनआईएसटी ने अब नई क्रिप्टोग्राफी विधियों की आवश्यकता को रेखांकित करने वाले एक पेपर के साथ क्वांटम मजबूत तरीकों की ओर बढ़ना शुरू कर दिया है, क्योंकि बड़े पैमाने पर क्वांटम कंप्यूटर आरएसए और असतत लघुगणक विधियों सहित वर्तमान में उपलब्ध अधिकांश सार्वजनिक-कुंजी प्रणालियों को तोड़ देगा। समग्र सार्वजनिक कुंजी एन्क्रिप्शन का उपयोग अक्सर सममित एन्क्रिप्शन में उपयोग की जाने वाली गुप्त कुंजियों की सुरक्षा और पहचान साबित करने के लिए किया जाता है। एक सार्वजनिक कुंजी के बड़े पैमाने पर उल्लंघन से हैक की गई इकाई के लिए इंटरनेट पर विश्वास की पूर्ण कमी हो जाएगी।

क्वांटम मजबूत तरीकों के मुख्य दावेदार हैं:

लैटिस-आधारित क्रिप्टोग्राफी - यह वर्गीकरण बड़ी क्षमता दिखाता है और नई क्रिप्टोग्राफी की ओर अग्रसर होता है, जैसे कि पूरी तरह से होमोमोर्फिक एन्क्रिप्शन [ यहाँ ] और कोड अस्पष्टता के लिए। निम्नलिखित खंड में एक उदाहरण दिया गया है।
कोड-आधारित क्रिप्टोग्राफी - यह विधि 1978 में McEliece क्रिप्टोसिस्टम के साथ बनाई गई थी लेकिन वास्तविक अनुप्रयोगों में मुश्किल से इसका उपयोग किया गया है। McEliece विधि रैखिक कोड का उपयोग करती है जो त्रुटि-सुधार कोड में उपयोग की जाती है, और इसमें मैट्रिक्स-वेक्टर गुणन शामिल होता है। रैखिक कोड का एक उदाहरण हैमिंग कोड है [ यहाँ ]
बहुभिन्नरूपी बहुपद क्रिप्टोग्राफी - ये परिमित क्षेत्रों पर बहुभिन्नरूपी बहुपदों की प्रणालियों को हल करने की कठिनाई पर ध्यान केंद्रित करते हैं। दुर्भाग्य से, प्रस्तावित कई तरीके पहले ही टूट चुके हैं।
हैश-आधारित हस्ताक्षर - इसमें हैशिंग विधियों का उपयोग करके डिजिटल हस्ताक्षर बनाना शामिल होगा। दोष यह है कि एक हस्ताक्षरकर्ता को उन सभी संदेशों का ट्रैक रखने की आवश्यकता होती है जिन पर हस्ताक्षर किए गए हैं और यह कि हस्ताक्षरों की संख्या की एक सीमा होती है जो उत्पादित की जा सकती हैं।

McEliece पद्धति कोड-आधारित क्रिप्टोग्राफी का उपयोग करती है। इसकी नींव एक सामान्य रेखीय कोड को डिकोड करने में कठिनाई पर आधारित है और आमतौर पर एन्क्रिप्शन और डिक्रिप्शन के लिए RSA से तेज़ है। इसके भीतर, हमारे पास एक संभाव्य कुंजी जनरेशन विधि है, जिसका उपयोग तब सार्वजनिक और निजी कुंजी बनाने के लिए किया जाता है। चाबियाँ एन, के और टी के पैरामीटर के साथ उत्पन्न होती हैं।

कुंजी एन, के और टी के पैरामीटर के साथ उत्पन्न होती हैं। इसके साथ, हम कोड का एक [n,k] मैट्रिक्स बनाते हैं, और जो t त्रुटियों को ठीक करने में सक्षम है। अपने पेपर में, मैकएलीस n=1024, k=524, t=50 को परिभाषित करता है, और जो 524x(1024-524) = 262,000 बिट्स का सार्वजनिक कुंजी आकार देता है। उपरोक्त उदाहरण में हम k=1608, N=2048 और T=40 का उपयोग करते हैं, जो 1608x(2048–40) - 3,228,864 बिट्स का सार्वजनिक कुंजी आकार देता है। क्वांटम मजबूती के लिए यह अनुशंसा की जाती है कि एन 6960 है, के 5,412 है और टी 119 है (8,373,911 बिट्स का एक बड़ा कुंजी आकार देता है।

निम्नलिखित मुख्य विधियों में से प्रत्येक का व्युत्पन्न कुंजी आकार और सिफर टेक्स्ट (बाइट्स में) है [1]:

m    n      t   level | public key   secret key  ciphertext
--------------------------------------------------------------------------
mceliece348864  12  3,488    64	 1    |  261,120       6,492       128
mceliece460896  13  4,608    94	 3    |  524,160      13,608       188
mceliece6688128 13  6,688   128	 5    | 1,044,992     13,932       240
mceliece6960119 13  6,960   119  5    | 1,047,319     13,948       226
mceliece8192128 13  8,192   128  5    | 1,357,824     14,120       240

Type      Public key size (B)   Secret key size (B)  Ciphertext size (B)
------------------------------------------------------------------------
Kyber512              800              1,632                  768  Learning with errors (Lattice)
Kyber738            1,184              2,400                1,088  Learning with errors (Lattice)
Kyber1024           1,568              3,168                1,568  Learning with errors (Lattice)
LightSABER            672              1,568                  736  Learning with rounding (Lattice)
SABER                 992              2,304                1,088  Learning with rounding (Lattice)
FireSABER           1,312              3,040                1,472  Learning with rounding (Lattice)
McEliece348864    261,120              6,452                  128  Code based
McEliece460896    524,160             13,568                  188  Code based
McEliece6688128 1,044,992             13,892                  240  Code based
McEliece6960119 1,047,319             13,948                  226  Code based
McEliece8192128 1,357,824             14,120                  240  Code based
NTRUhps2048509        699                935                  699  Lattice
NTRUhps2048677        930              1,234                  930  Lattice
NTRUhps4096821      1,230              1,590                1,230  Lattice
SIKEp434              330                 44                  346  Isogeny
SIKEp503              378                 56                  402  Isogeny
SIKEp751              564                 80                  596  Isogeny
SIDH                  564                 48                  596  Isogeny

सबसे पहले, हम इसके साथ प्रोजेक्ट बनाते हैं:

cargo new mce

[package]
name = "mce"
version = "0.1.0"
edition = "2021"
[dependencies]
classic-mceliece-rust = "3.0"
rand = "^0.8.5"
hex="^0.4"

use classic_mceliece_rust::{keypair, encapsulate, decapsulate};
use classic_mceliece_rust::{CRYPTO_BYTES, CRYPTO_PUBLICKEYBYTES, CRYPTO_SECRETKEYBYTES};
use hex;
fn main() {
  let mut rng = rand::thread_rng();
  let mut public_key_buf = [0u8; CRYPTO_PUBLICKEYBYTES];
  let mut secret_key_buf = [0u8; CRYPTO_SECRETKEYBYTES];
  let (public_key, secret_key) = keypair(&mut public_key_buf, &mut secret_key_buf, &mut rng);
  println!("\nBob public key (showing first 32 out of {} bytes): {:.32}", CRYPTO_PUBLICKEYBYTES,hex::encode(public_key.as_array()));
  println!("\nBob secret key (showing first 32 out of {} bytes): {:.32}",CRYPTO_SECRETKEYBYTES,hex::encode(secret_key.as_array()));
 
  let mut shared_secret_bob_buf = [0u8; CRYPTO_BYTES];
  let (ciphertext, shared_secret_bob) = encapsulate(&public_key, &mut shared_secret_bob_buf, &mut rng);
  let mut shared_secret_alice_buf = [0u8; CRYPTO_BYTES];
  let shared_secret_alice = decapsulate(&ciphertext, &secret_key, &mut shared_secret_alice_buf);
  println!("\nCiphertext (Bob to Alice) (showing {} bytes): {}",ciphertext.as_array().len(),hex::encode(ciphertext.as_array()));
  println!("\nBob key:  (showing {} bytes) {}",shared_secret_bob.as_array().len(),hex::encode(shared_secret_bob.as_array()));
  println!("\nAlice key: (showing {} bytes) {}",shared_secret_alice.as_array().len(),hex::encode(shared_secret_alice.as_array()));

}

cargo build

Bob public key (showing first 32 out of 261120 bytes): 4b44ae97d30a04f2ade8334a4817b5cc
Bob secret key (showing first 32 out of 6492 bytes): 76ac75d052f030692d334d843bc29ee7

Ciphertext (Bob to Alice) (showing 96 bytes): f40bff3d7928cd70cd1cf8a04daaacbf67168585a79fc57a28fef71203771a2d572229f29079bf6fe1713e7b3444c9badaebd7a7277ef6c88db9f02a27b3ba98b6f82743b2ba4b47d781b5fc5b7657ee10ef5d30971c2f2d2a8395898e8c2fe0

Bob key:  (showing 32 bytes) bb2853e129206f1d9e2802a5e6bd93265545b0369eb91750d799b876d870ff30

Alice key: (showing 32 bytes) bb2853e129206f1d9e2802a5e6bd93265545b0369eb91750d799b876d870ff30

मैकलीस प्रदर्शन

आप पाएंगे कि कोड काफी धीमा है, और साझा कुंजी बनाने में कुछ सेकंड लग सकते हैं। इसका कारण यह है कि मुख्य पीढ़ी [ यहाँ ] के लिए किबर की तुलना में McEliece बहुत धीमी है :

जैसा कि हम देखते हैं, किबर की तुलना में मैकएलीस प्रमुख पीढ़ी के लिए 11,490 गुना धीमा है। लेकिन एनकैप्सुलेशन और डिकैप्सुलेशन प्रक्रियाएं बेहतर प्रदर्शन करती हैं, एनकैप्सुलेशन के लिए 1.9 गुना धीमा प्रदर्शन और डीकैप्सुलेशन के लिए 9.7 गुना धीमा।

निष्कर्ष

Kyber को PQC कुंजी एक्सचेंज और सार्वजनिक कुंजी एन्क्रिप्शन विधि के रूप में परिभाषित करने वाली पहली विधि के रूप में परिभाषित किया गया है। कुल मिलाकर, यह जाली विधियों पर आधारित है। ये कुंजी पीढ़ी, एन्क्रिप्शन और डिक्रिप्शन के लिए अपेक्षाकृत तेज़ हैं, और अपेक्षाकृत छोटे कुंजी आकार के साथ हैं। हालाँकि, NIST को चिंता है कि हम जाली के तरीकों पर बहुत अधिक निर्भर हो जाएंगे, और इसलिए अन्य तरीकों की तलाश कर रहे हैं। इनमें McEliece, BIKE, और HQC शामिल हैं।

आप यहां और बहुत कुछ मिल सकता है:

https://asecuritysite.com/pqc/kem

और कुछ क्रैकिंग:

McEliece कुंजी एक्सचेंज: कछुआ खोल थोड़ा टूटा हुआ है, लेकिन यह अभी भी सुरक्षित है

संदर्भ

[1] मैकएलिस, आरजे (1978)। बीजगणित पर आधारित एक सार्वजनिक कुंजी क्रिप्टो प्रणाली। कोडिंग थ्व , 4244 , 114–116।