Mathematics on kenji.blog

फर्मेट के छोटे प्रमेय का उपयोग करते हुए क्रिप्टोग्राफी के मूल सिद्धांत और कार्यान्वयन

Fri, 11 Sep 2026 22:00:00 +0900

1. परिचय: आधुनिक क्रिप्टोग्राफी का समर्थन करने वाले गणित का रहस्य

आधुनिक डिजिटल समाज में, विशेष रूप से इंटरनेट के माध्यम से संचार में, ‘क्रिप्टोग्राफी’ (एन्क्रिप्शन) एक अपरिहार्य आधारभूत तकनीक बन गई है। हम वेब ब्राउज़र में HTTPS के माध्यम से सुरक्षित रूप से वेबसाइट ब्राउज़ कर सकते हैं, ऑनलाइन बैंकिंग में वित्तीय लेनदेन कर सकते हैं, और मैसेजिंग ऐप्स पर निजी बातचीत कर सकते हैं, यह सब उन्नत गणितीय सिद्धांतों द्वारा समर्थित क्रिप्टोग्राफ़िक प्रोटोकॉल के बैकग्राउंड में काम करने के कारण संभव है। इनमें से ‘पब्लिक-की क्रिप्टोग्राफी’ (सार्वजनिक-कुंजी क्रिप्टोग्राफी) एक बहुत ही महत्वपूर्ण भूमिका निभाती है, और इसका सबसे प्रमुख उदाहरण RSA क्रिप्टोग्राफी है।

RSA सहित कई क्रिप्टोग्राफिक एल्गोरिदम की सुरक्षा और वैधता 17वीं सदी के फ्रांसीसी गणितज्ञ पियरे डी फर्मेट (Pierre de Fermat) द्वारा खोजे गए एक अत्यंत सुंदर और शक्तिशाली प्रमेय पर काफी हद तक निर्भर करती है। यह फर्मेट का छोटा प्रमेय (Fermat’s Little Theorem) है। इसके अलावा, लियोनहार्ड यूलर (Leonhard Euler) का प्रमेय, जो कि इसका सामान्यीकरण है, भी क्रिप्टोग्राफिक सिद्धांत में एक निर्णायक भूमिका निभाता है।

इस लेख में, हम शुरुआत से गहराई से बताएंगे कि कैसे फर्मेट के छोटे प्रमेय, जो कि शुद्ध गणित की एक खोज है, को आधुनिक व्यावहारिक क्रिप्टोग्राफिक तकनीकों, विशेष रूप से ‘अभाज्य संख्या परीक्षण’ (Primality Test) और ‘RSA क्रिप्टोग्राफी’ में लागू किया जाता है। यह एक बहुत विस्तृत तकनीकी मार्गदर्शिका होगी, जिसमें गणितीय प्रमाण, एन्क्रिप्शन और डिक्रिप्शन के तंत्र, और C++ और Python का उपयोग करके विशिष्ट एल्गोरिदम के कार्यान्वयन को शामिल किया गया है।

2. सर्वांगसमता (Congruence) और मॉड्यूलर अंकगणित के मूल सिद्धांत

फर्मेट के छोटे प्रमेय को समझने के लिए, सबसे पहले ‘मॉड्यूलर अंकगणित (सर्वांगसमता)’ की गणितीय अवधारणा से परिचित होना आवश्यक है। मॉड्यूलर अंकगणित गणना की एक प्रणाली है जो किसी निश्चित संख्या (जिसे मॉड्यूलस कहा जाता है) से विभाजित करने पर प्राप्त ‘शेषफल’ (remainder) पर केंद्रित होती है। चूंकि यह घड़ी के डायल (जो 12 घंटे में एक चक्कर पूरा करता है) की तरह एक गणना है, इसे अक्सर ‘घड़ी का गणित’ भी कहा जाता है।

जब पूर्णांक $a$ और $b$ को धनात्मक पूर्णांक $n$ से विभाजित करने पर शेषफल समान होता है, तो गणितीय रूप से इसे इस प्रकार लिखा जाता है:

$$ a \equiv b \pmod n $$

इसे इस प्रकार पढ़ा जाता है: “$a$ और $b$ मॉड्यूलो $n$ सर्वांगसम (congruent) हैं”। उदाहरण के लिए, 17 को 5 से भाग देने पर शेषफल 2 आता है, और 12 को 5 से भाग देने पर भी शेषफल 2 आता है। इसलिए, इसे इस प्रकार लिखा जा सकता है:

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

मॉड्यूलर अंकगणित में, सामान्य बुनियादी अंकगणितीय संक्रियाएँ (जोड़, घटाव, गुणा) वैसे ही लागू होती हैं:

जोड़ (Addition): यदि $a \equiv b \pmod n$ और $c \equiv d \pmod n$, तो $a + c \equiv b + d \pmod n$
घटाव (Subtraction): यदि $a \equiv b \pmod n$ और $c \equiv d \pmod n$, तो $a - c \equiv b - d \pmod n$
गुणा (Multiplication): यदि $a \equiv b \pmod n$ और $c \equiv d \pmod n$, तो $a \times c \equiv b \times d \pmod n$
घातांक (Exponentiation): यदि $a \equiv b \pmod n$, तो किसी भी प्राकृतिक संख्या $k$ के लिए $a^k \equiv b^k \pmod n$

हालाँकि, भाग (Division) के संबंध में सावधानी बरतने की आवश्यकता है। सामान्य तौर पर, यदि $a \times c \equiv b \times c \pmod n$ है, तो इसका मतलब यह नहीं है कि हम दोनों पक्षों को $c$ से भाग देकर $a \equiv b \pmod n$ कर सकते हैं। यह केवल तभी सत्य होता है जब $c$ और $n$ सह-अभाज्य (coprime) हों (यानी, उनका महत्तम समापवर्तक 1 हो)। ‘मॉड्यूलर व्युत्क्रम (Modular inverse)’ की यह अवधारणा RSA क्रिप्टोग्राफी में कुंजी निर्माण (key generation) के लिए अत्यंत महत्वपूर्ण है, जिस पर हम बाद में चर्चा करेंगे।

3. फर्मेट के छोटे प्रमेय की गणितीय पृष्ठभूमि और प्रमाण

मॉड्यूलर अंकगणित के मूल सिद्धांतों को समझने के बाद, आइए हमारे मुख्य विषय, फर्मेट के छोटे प्रमेय (Fermat’s Little Theorem) पर नज़र डालते हैं।

3.1 प्रमेय की परिभाषा

फर्मेट के छोटे प्रमेय को इस प्रकार तैयार किया गया है:

फर्मेट का छोटा प्रमेय (Fermat’s Little Theorem) मान लीजिए कि $p$ एक अभाज्य संख्या (prime number) है, और $a$ कोई ऐसा पूर्णांक है जो $p$ का गुणज नहीं है (अर्थात $a$ और $p$ सह-अभाज्य हैं)। इस स्थिति में, निम्नलिखित सर्वांगसमता (congruence) सत्य होगी:
$$ a^{p-1} \equiv 1 \pmod p $$

इसके अलावा, “$a$, $p$ का गुणज नहीं है” की शर्त को हटाकर इसे एक ऐसे रूप में व्यक्त करना भी आम है जो सभी पूर्णांकों $a$ के लिए सही है। उस स्थिति में, दोनों पक्षों को $a$ से गुणा करने पर निम्नलिखित प्राप्त होता है:

$$ a^p \equiv a \pmod p $$

3.2 विशिष्ट उदाहरणों के साथ सत्यापन

आइए विशिष्ट संख्याओं का उपयोग करके जांचें कि क्या यह प्रमेय वास्तव में काम करता है। मान लें कि अभाज्य संख्या $p = 5$ है। तो $p-1 = 4$ होगा। हम $a$ के रूप में एक पूर्णांक चुनते हैं जो $p$ का गुणज नहीं है।

यदि $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ शेषफल $1$. अतः $16 \equiv 1 \pmod 5$. (सत्यापित)
यदि $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ शेषफल $1$. अतः $81 \equiv 1 \pmod 5$. (सत्यापित)
यदि $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ शेषफल $1$. अतः $256 \equiv 1 \pmod 5$. (सत्यापित)

इस प्रकार, हम जो भी $a$ चुनते हैं (जब तक कि वह 5 का गुणज न हो), उसे घात 4 तक बढ़ाने और 5 से भाग देने पर शेषफल हमेशा 1 होगा। यह जादू जैसा लग सकता है, लेकिन यह अभाज्य संख्याओं के सुंदर गुणों से उत्पन्न होता है।

3.3 प्रमेय का गणितीय प्रमाण

ऐसा क्यों होता है? यहाँ हम अवशिष्ट वर्गों (residue classes) के सेट का उपयोग करते हुए एक सुरुचिपूर्ण प्रमाण प्रस्तुत करते हैं।

मान लीजिए एक सेट $S = \{1, 2, 3, \dots, p-1\}$ है। ये उन पूर्णांकों के प्रतिनिधि हैं जिन्हें $p$ से विभाजित करने पर शेषफल $1$ से $p-1$ तक आते हैं। अब, एक नए सेट $T$ पर विचार करें जहाँ $S$ के प्रत्येक तत्व को $p$ के साथ सह-अभाज्य पूर्णांक $a$ से गुणा किया गया है:

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

इस सेट $T$ के प्रत्येक तत्व को $p$ से विभाजित करने पर प्राप्त शेषफलों पर विचार करें। आश्चर्यजनक रूप से, ये शेषफल, भले ही उनका क्रम बदल गया हो, मूल सेट $S$ के तत्वों से पूरी तरह मेल खाएंगे। ऐसा इसलिए है क्योंकि:

$T$ का कोई भी तत्व $p$ का गुणज नहीं हो सकता (क्योंकि न तो $a$ और न ही मूल तत्व $p$ के गुणज हैं)।
$T$ में ऐसे कोई दो भिन्न तत्व नहीं हैं जो मॉड्यूलो $p$ सर्वांगसम हों। यदि $ia \equiv ja \pmod p$ (जहाँ $i \neq j$) है, तो चूंकि $a$ और $p$ सह-अभाज्य हैं, हम $a$ से भाग दे सकते हैं और $i \equiv j \pmod p$ प्राप्त कर सकते हैं, जो एक विरोधाभास है।

इसलिए, $S$ के सभी तत्वों का गुणनफल और $T$ के सभी तत्वों का गुणनफल मॉड्यूलो $p$ सर्वांगसम होंगे।

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

बायें पक्ष को व्यवस्थित करने पर, चूंकि $a$, $p-1$ बार है:

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

चूंकि $(p-1)!$ और $p$ सह-अभाज्य हैं, हम दोनों पक्षों को $(p-1)!$ से भाग दे सकते हैं, जिससे अंततः निम्नलिखित प्रमेय प्राप्त होता है:

$$ a^{p-1} \equiv 1 \pmod p $$

यह फर्मेट के छोटे प्रमेय का प्रमाण है।

4. यूलर का टोटिएंट फलन (Euler’s Totient Function) और यूलर का प्रमेय

फर्मेट का छोटा प्रमेय ‘अभाज्य संख्या $p$’ के बारे बारे में है, लेकिन लियोनहार्ड यूलर ने इसे ‘किसी भी धनात्मक पूर्णांक $n$’ के लिए सामान्यीकृत किया। RSA क्रिप्टोग्राफी को समझने के लिए यह विस्तार आवश्यक है।

4.1 यूलर का टोटिएंट फलन $\phi(n)$

यूलर का टोटिएंट फलन (या यूलर का $\phi$ फलन) $\phi(n)$ एक ऐसा फलन है जो “$1$ से $n$ तक के उन पूर्णांकों की संख्या को दर्शाता है जो $n$ के साथ सह-अभाज्य हैं”।

किसी अभाज्य संख्या $p$ के लिए, $1$ से $p-1$ तक के सभी पूर्णांक $p$ के साथ सह-अभाज्य होते हैं, इसलिए $\phi(p) = p - 1$ होगा।
दो भिन्न अभाज्य संख्याओं $p, q$ के लिए, यदि उनका गुणनफल $n = p \times q$ है, तो $\phi(n)$ को एक बहुत ही सरल सूत्र द्वारा निकाला जा सकता है: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

यह गुण RSA क्रिप्टोग्राफी में कुंजी निर्माण का मूल तर्क (logic) बन जाता है।

4.2 यूलर का प्रमेय

यूलर ने फर्मेट के छोटे प्रमेय को इस प्रकार सामान्यीकृत किया:

यूलर का प्रमेय (Euler’s Theorem) एक धनात्मक पूर्णांक $n$ और उसके साथ सह-अभाज्य पूर्णांक $a$ के लिए, निम्नलिखित सत्य है:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

यदि $n$ एक अभाज्य संख्या $p$ है, तो $\phi(p) = p - 1$, जिसका अर्थ है कि यह स्वयं फर्मेट का छोटा प्रमेय ($a^{p-1} \equiv 1 \pmod p$) बन जाता है। दूसरे शब्दों में, फर्मेट का छोटा प्रमेय यूलर के प्रमेय का ही एक विशेष मामला है।

5. विशाल अभाज्य संख्याएँ ढूँढना: फर्मेट का अभाज्य परीक्षण (Primality Test)

क्रिप्टोग्राफी (जैसे RSA क्रिप्टोग्राफी और डिफी-हेलमैन (Diffie-Hellman) कुंजी विनिमय) में, सैकड़ों अंकों की ‘विशाल अभाज्य संख्याएँ’ तेज़ी से खोजना आवश्यक है। हालाँकि, यह निर्धारित करने के लिए कि क्या एक विशाल संख्या $N$ अभाज्य है, ‘परीक्षण विभाजन विधि’ (Trial division), जिसमें $2$ से $\sqrt{N}$ तक की सभी संख्याओं से भाग देकर जाँचा जाता है, में ब्रह्मांड के जीवनकाल जितना समय लग सकता है।

यहीं पर फर्मेट के छोटे प्रमेय का उपयोग करने वाला ‘प्रायिकतात्मक अभाज्य परीक्षण’ (Probabilistic primality test), जिसे फर्मेट टेस्ट (Fermat Primality Test) कहा जाता है, सामने आता है।

5.1 प्रायिकतात्मक अभाज्य परीक्षण क्या है?

फर्मेट के छोटे प्रमेय के अनुसार, यदि $p$ अभाज्य है, तो किसी भी $a$ ($1 < a < p$) के लिए, $a^{p-1} \equiv 1 \pmod p$ हमेशा सत्य होगा। इसका प्रतिलोम (contrapositive) लेने पर हम कह सकते हैं, “यदि किसी $a$ के लिए $a^{p-1} \not\equiv 1 \pmod p$ है, तो $p$ निश्चित रूप से अभाज्य नहीं है (यह एक भाज्य संख्या (composite number) है)"।

इसलिए, यदि हम परीक्षण करना चाहते हैं कि क्या $N$ अभाज्य है, तो हम यादृच्छिक रूप से कुछ $a$ चुनते हैं, $a^{N-1} \pmod N$ की गणना करते हैं, और जांचते हैं कि क्या यह $1$ है। यदि उत्तर एक बार भी $1$ के अलावा कुछ और आता है, तो $N$ निश्चित रूप से एक भाज्य संख्या है। यदि कई बार परीक्षण करने के बाद भी यह $1$ आता है, तो हम उच्च संभावना के साथ कह सकते हैं कि $N$ “संभवतः अभाज्य (probably prime)” है।

5.2 एल्गोरिदम का विवरण और फ़्लोचार्ट

फर्मेट टेस्ट का एल्गोरिदम इस प्रकार है:

flowchart TD Start["प्रारंभ"] --> Input["परीक्षण की जाने वाली संख्या p और परीक्षणों की संख्या k इनपुट करें"] Input --> LoopStart["i = 0 से k-1 तक लूप"] LoopStart --> Condition{"i < k ?"} Condition -- "हाँ" --> RandomA["1 < a < p-1 के बीच एक यादृच्छिक पूर्णांक a चुनें"] RandomA --> Calc["मॉड्यूलर घातांक a^(p-1) mod p की गणना करें"] Calc --> CheckPrime{"क्या परिणाम 1 है?"} CheckPrime -- "नहीं" --> ReturnComposite["p एक भाज्य संख्या है (निश्चित)"] CheckPrime -- "हाँ" --> Increment["i को बढ़ाएँ (increment)"] Increment --> Condition Condition -- "नहीं" --> ReturnPrime["p संभवतः अभाज्य है (प्रायिकतात्मक)"] ReturnComposite --> End["समाप्त"] ReturnPrime --> End

5.3 कारमाइकल संख्याएँ (Pseudoprimes) का जाल

फर्मेट टेस्ट बहुत तेज़ है, लेकिन इसमें एक गंभीर दोष है। कुछ ऐसी दुष्ट संख्याएँ होती हैं जो भाज्य (composite) होने के बावजूद, सभी $a$ के लिए $a^{N-1} \equiv 1 \pmod N$ को संतुष्ट करती हैं। इन्हें कारमाइकल संख्याएँ (Carmichael numbers) कहा जाता है। सबसे छोटी कारमाइकल संख्या $561$ ($3 \times 11 \times 17$) है।

कारमाइकल संख्याओं के अस्तित्व के कारण, केवल शुद्ध फर्मेट टेस्ट से पूर्ण अभाज्य परीक्षण नहीं किया जा सकता है। इसलिए, वास्तविक एन्क्रिप्शन सिस्टम (जैसे OpenSSL) मानक के रूप में मिलर-राबिन (Miller-Rabin) अभाज्य परीक्षण का उपयोग करते हैं, जो फर्मेट टेस्ट का एक उन्नत संस्करण है। मिलर-राबिन परीक्षण कारमाइकल संख्याओं का पता लगा सकता है, जिससे गलत निर्णय की संभावना लगभग शून्य हो जाती है।

5.4 तेज़ मॉड्यूलर घातांक (Exponentiation by Squaring)

अभाज्य परीक्षण एल्गोरिदम में, $a^{N-1} \pmod N$ की गणना करना आवश्यक है, लेकिन यदि $N$ बहुत बड़ा है, तो $a^{N-1}$ खगोलीय अंकों में होगा और कंप्यूटर की मेमोरी में फिट नहीं होगा। इसका समाधान निरंतर वर्ग विधि (Exponentiation by Squaring) या मॉड्यूलर घातांक (modular exponentiation) है। गणना के प्रत्येक चरण में मॉड्यूलो (mod N) लेने से, मान हमेशा $N$ से छोटा रखा जाता है, जिससे गणना बहुत तेज़ी से (समय जटिलता $O(\log N)$ में) की जा सकती है।

6. अभाज्य परीक्षण और मॉड्यूलर घातांक का कार्यान्वयन

तो चलिए C++ और Python में फर्मेट अभाज्य परीक्षण और निरंतर वर्ग विधि (exponentiation by squaring) को लागू करते हैं।

6.1 C++ में कार्यान्वयन

C++ में, मानक पूर्णांक प्रकार (standard integer types) आसानी से ओवरफ़्लो हो जाते हैं, इसलिए बड़ी संख्याओं को संभालने के लिए मल्टी-प्रिसिजन इंटीजर लाइब्रेरी (जैसे GMP) की आवश्यकता होती है, लेकिन यहाँ हम एल्गोरिदम को समझने के लिए 64-बिट पूर्णांक (unsigned long long) की सीमा के भीतर एक कार्यान्वयन दिखाएंगे।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <iostream>
#include <random>

using namespace std;

// तेज़ मॉड्यूलर घातांक (a^b mod m) - निरंतर वर्ग विधि (Exponentiation by squaring)
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // यदि b का सबसे निचला बिट 1 है, तो परिणाम को a से गुणा करें
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // ओवरफ़्लो रोकने के लिए 128-बिट विस्तार
 }
 // a का वर्ग करें
 a = (__int128)a * a % m;
 // b को राइट शिफ्ट करें (आधा करें)
 b /= 2;
 }
 return result;
}

// फर्मेट का अभाज्य परीक्षण
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // यदि a^(p-1) mod p, 1 नहीं है, तो यह भाज्य संख्या है
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // संभवतः अभाज्य
}

int main() {
 unsigned long long num = 1000000007; // ज्ञात अभाज्य
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Python में कार्यान्वयन

Python का मानक पूर्णांक प्रकार (standard integer type) मनमाने आकार की संख्याओं (arbitrary-precision integers) का समर्थन करता है, इसलिए ओवरफ्लो के बारे में चिंता करने की कोई आवश्यकता नहीं है। इसके अलावा, Python का अंतर्निहित फ़ंक्शन pow(a, b, m) आंतरिक रूप से निरंतर वर्ग विधि का उपयोग करता है, इसलिए यह बहुत तेज़ है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import random

def fermat_is_prime(p, iterations=5):
 """
 फर्मेट के अभाज्य परीक्षण का उपयोग करके प्रायिकतात्मक अभाज्य परीक्षण
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # 2 से p-2 के बीच एक यादृच्छिक संख्या a चुनें
 a = random.randint(2, p - 2)
 # a^(p-1) mod p की गणना करें। अंतर्निहित pow बहुत तेज़ है।
 if pow(a, p - 1, p) != 1:
 return False # निश्चित भाज्य

 return True # संभवतः अभाज्य

# परीक्षण
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} संभवतः अभाज्य है।")
else:
 print(f"{number_to_test} एक भाज्य संख्या है।")

7. RSA क्रिप्टोग्राफी में अनुप्रयोग: जहाँ फर्मेट और यूलर फलीभूत होते हैं

फर्मेट के छोटे प्रमेय (और यूलर के प्रमेय) का सबसे बड़ा अनुप्रयोग 1977 में रिवेस्ट, शमीर और एडलमैन द्वारा विकसित RSA क्रिप्टोग्राफी है। RSA क्रिप्टोग्राफी एक क्रांतिकारी प्रणाली है जिसे ‘पब्लिक-की क्रिप्टोग्राफी’ (public-key cryptography) कहा जाता है। यह एक ऐसा तंत्र प्रदान करता है जहाँ एन्क्रिप्ट करने के लिए कुंजी (पब्लिक की/सार्वजनिक कुंजी) दुनिया के सामने सार्वजनिक की जा सकती है, जबकि डिक्रिप्ट करने वाली कुंजी (प्राइवेट की/निजी कुंजी) केवल प्राप्तकर्ता को ही पता होती है।

यह विषमता (asymmetry) इस कम्प्यूटेशनल सुरक्षा पर आधारित है कि “विशाल भाज्य संख्याओं का अभाज्य गुणनखंडन (prime factorization) अत्यंत कठिन है”।

7.1 RSA क्रिप्टोग्राफी तंत्र (कुंजी निर्माण, एन्क्रिप्शन, डिक्रिप्शन)

आइए मर्मेड (Mermaid) अनुक्रम आरेख (sequence diagram) के माध्यम से RSA क्रिप्टोग्राफी के समग्र संचार प्रवाह की जांच करें।

sequenceDiagram participant Alice["ऐलिस (प्राप्तकर्ता)"] participant Bob["बॉब (प्रेषक)"] Alice->>Alice: "विशाल अभाज्य संख्याएँ p, q जनरेट करें" Alice->>Alice: "N = p * q, φ(N) = (p-1)(q-1) की गणना करें" Alice->>Alice: "पब्लिक की e और प्राइवेट की d की गणना करें (e*d ≡ 1 mod φ(N))" Alice->>Bob: "पब्लिक की (N, e) भेजें" Note over Bob: "सादा पाठ (Plaintext) M तैयार करें (M < N)" Bob->>Bob: "सिफरटेक्स्ट (Ciphertext) C = M^e mod N की गणना करें" Bob->>Alice: "सिफरटेक्स्ट C भेजें" Alice->>Alice: "सादा पाठ M = C^d mod N की गणना करके डिक्रिप्ट करें"

नीचे गणितीय चरणों का विस्तृत विवरण दिया गया है।

चरण 1: कुंजी निर्माण (प्राप्तकर्ता ऐलिस का कार्य)

दो विशाल अभाज्य संख्याएँ $p$ और $q$ यादृच्छिक रूप से जनरेट करें (यहाँ पहले उल्लिखित अभाज्य परीक्षण विधि का उपयोग किया जाता है)।
उनके गुणनफल $N = p \times q$ की गणना करें। यह $N$ सार्वजनिक किया जाता है।
यूलर के टोटिएंट फलन का उपयोग करते हुए, $\phi(N) = (p-1)(q-1)$ की गणना करें।
$\phi(N)$ के साथ सह-अभाज्य एक पूर्णांक $e$ (सार्वजनिक घातांक/public exponent) चुनें (अक्सर $e = 65537$ का उपयोग किया जाता है)।
$e$ के मॉड्यूलर व्युत्क्रम (modular inverse) $d$ (निजी घातांक/private exponent) की गणना करें। अर्थात, ऐसा $d$ खोजें जो निम्नलिखित को संतुष्ट करे: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ इस गणना के लिए विस्तारित यूक्लिडियन एल्गोरिदम (Extended Euclidean Algorithm) का उपयोग किया जाता है।

इसके साथ, पब्लिक की (सार्वजनिक कुंजी) $(N, e)$ और प्राइवेट की (निजी कुंजी) $(N, d)$ हो जाती है। ($p, q,$ और $\phi(N)$ को तुरंत नष्ट कर दिया जाना चाहिए या सख्ती से छिपाकर रखा जाना चाहिए)।

चरण 2: एन्क्रिप्शन (प्रेषक बॉब का कार्य)

मान लें कि बॉब ऐलिस को एक संदेश $M$ भेजना चाहता है ($M$ वर्णों (characters) का एक संख्यात्मक प्रतिनिधित्व है, जहाँ $0 \le M < N$ है)। बॉब ऐलिस की पब्लिक की $(N, e)$ का उपयोग करता है और सिफरटेक्स्ट (Ciphertext) $C$ बनाने के लिए निम्नलिखित गणना करता है:

$$ C \equiv M^e \pmod N $$

वह इस $C$ को नेटवर्क के माध्यम से ऐलिस को भेजता है।

चरण 3: डिक्रिप्शन (प्राप्तकर्ता ऐलिस का कार्य)

सिफरटेक्स्ट $C$ प्राप्त करने के बाद, ऐलिस अपनी गुप्त प्राइवेट की $d$ का उपयोग करके निम्नलिखित गणना करती है:

$$ M' \equiv C^d \pmod N $$

आश्चर्यजनक रूप से, यह गणना परिणाम $M'$ मूल संदेश $M$ से पूरी तरह मेल खाता है।

7.2 इसे डिक्रिप्ट क्यों किया जा सकता है? (गणितीय प्रमाण)

यहीं पर फर्मेट का छोटा प्रमेय (यूलर का प्रमेय) अपनी वास्तविक शक्ति दिखाता है। $C^d \pmod N$, $M$ में वापस क्यों बदल जाता है?

आइए डिक्रिप्शन समीकरण का विस्तार करें: चूंकि $C \equiv M^e \pmod N$ है,

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

कुंजी निर्माण चरण में, हमने $d$ को इस प्रकार चुना था कि $e \cdot d \equiv 1 \pmod{\phi(N)}$ हो। इसका मतलब है कि एक ऐसा पूर्णांक $k$ मौजूद है जिसे इस प्रकार लिखा जा सकता है:

$$ e \cdot d = 1 + k \cdot \phi(N) $$

इसे उपरोक्त समीकरण में प्रतिस्थापित (substitute) करने पर:

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

यहीं पर यूलर का प्रमेय ($M^{\phi(N)} \equiv 1 \pmod N$) लागू होता है। (※कड़ाई से कहें तो, $M$ और $N$ का सह-अभाज्य होना आवश्यक है, लेकिन RSA में, $M$ और $N$ के सह-अभाज्य न होने की संभावना खगोलीय रूप से कम है, और यह सिद्ध किया जा सकता है कि चाइनीज़ रिमाइंडर थ्योरम (Chinese Remainder Theorem) का उपयोग करके यह सह-अभाज्य न होने पर भी काम करता है)।

यूलर के प्रमेय को लागू करने पर, चूंकि $M^{\phi(N)} \equiv 1$ है:

$$ M \cdot (1)^k \equiv M \pmod N $$

सफलतापूर्वक $M$ को बहाल कर लिया गया है! संख्याओं के वे गुण, जिन्हें फर्मेट और यूलर ने सैकड़ों साल पहले खोजा था, आज आधुनिक डिजिटल संचार की गोपनीयता की पूरी तरह से गारंटी देते हैं।

8. RSA क्रिप्टोग्राफी का टॉय इम्प्लीमेंटेशन (Python)

केवल सिद्धांत के साथ इसे महसूस करना मुश्किल हो सकता है, तो चलिए Python का उपयोग करके वास्तविक RSA कुंजी जनरेशन, एन्क्रिप्शन और डिक्रिप्शन प्रक्रिया को लागू करते हैं। यह एक शैक्षिक “टॉय इम्प्लीमेंटेशन (toy implementation)” है, लेकिन इसमें प्रयुक्त गणित बिल्कुल वास्तविक के समान है।

हम मॉड्यूलर व्युत्क्रम (modular inverse) $d$ खोजने के लिए “विस्तारित यूक्लिडियन एल्गोरिदम (Extended Euclidean Algorithm)” को भी कार्यान्वयन में शामिल करेंगे।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


import random

# महत्तम समापवर्तक (GCD) खोजें
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# विस्तारित यूक्लिडियन एल्गोरिदम (ax + by = gcd(a,b) के x, y खोजें)
# e*d ≡ 1 (mod φ(N)) के लिए d खोजने के लिए उपयोग किया जाता है
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('व्युत्क्रम मौजूद नहीं है')
 else:
 return x % phi

# अभाज्य जनरेशन फ़ंक्शन (सरलीकृत संस्करण: छोटी अभाज्य संख्याएँ जनरेट करें)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # पहले बताए गए फर्मेट टेस्ट के बजाय सरल परीक्षण
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# RSA कुंजी जनरेशन
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # सुनिश्चित करें कि p और q समान न हों
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # e के लिए अक्सर 65537 जैसी अभाज्य संख्या का उपयोग किया जाता है, लेकिन यहाँ इसे यादृच्छिक रूप से चुना गया है
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # प्राइवेट की d की गणना
 d = mod_inverse(e, phi)

 # पब्लिक की (e, n), प्राइवेट की (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # plaintext^e mod n की गणना करें
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # cipher^d mod n की गणना करें, और वापस वर्णों में बदलें
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# निष्पादन उदाहरण
if __name__ == '__main__':
 print("--- RSA क्रिप्टोग्राफी टॉय इम्प्लीमेंटेशन ---")
 public_key, private_key = generate_keypair(bits=12) # 12-बिट अभाज्य संख्याओं का उपयोग

 print(f"पब्लिक की (e, n): {public_key}")
 print(f"प्राइवेट की (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nमूल संदेश: {message}")

 # एन्क्रिप्शन
 encrypted_msg = encrypt(public_key, message)
 print(f"सिफरटेक्स्ट: {encrypted_msg}")

 # डिक्रिप्शन
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"डिक्रिप्ट किया गया संदेश: {decrypted_msg}")

जब आप यह कोड चलाते हैं, तो आप देख सकते हैं कि वर्णों की एक सरणी अज्ञात संख्याओं की एक सरणी (सिफरटेक्स्ट) में परिवर्तित हो जाती है, जिसे बाद में प्राइवेट की का उपयोग करके सफलतापूर्वक मूल स्ट्रिंग में बहाल कर लिया जाता है।

9. निष्कर्ष: गणित की सुंदरता और व्यावहारिकता का प्रतिच्छेदन (Intersection)

17वीं शताब्दी में जब पियरे डी फर्मेट ने इस ‘छोटे प्रमेय’ की खोज की थी, तब किसी ने नहीं सोचा था कि यह किसी काम आएगा। खुद फर्मेट ने शुद्ध गणितीय जिज्ञासा से संख्या सिद्धांत (number theory) पर शोध किया था।

हालाँकि, लगभग 300 साल बाद 1970 के दशक में, कंप्यूटर नेटवर्क के शुरुआती दिनों में, सुरक्षित संचार प्रोटोकॉल स्थापित करने के लिए आवश्यक क्रिप्टोग्राफिक तकनीक के रूप में फर्मेट के प्रमेय का नाटकीय रूप से पुनरुत्थान हुआ। फर्मेट के छोटे प्रमेय पर आधारित अभाज्य परीक्षण तकनीक और यूलर के प्रमेय पर आधारित RSA क्रिप्टोग्राफी आज के इंटरनेट बुनियादी ढांचे को सचमुच में सहारा देती है।

हमारे द्वारा प्रतिदिन भेजे जाने वाले LINE या WhatsApp संदेश, या Amazon पर हमारी खरीदारी, यह सब इसी सरल और सुंदर सूत्र $a^{p-1} \equiv 1 \pmod p$ के इर्द-गिर्द घूमती है। फर्मेट का छोटा प्रमेय हमें सिखाता है कि गणित चाहे कितना भी अमूर्त क्यों न हो, एक समय ऐसा ज़रूर आएगा जब यह मानवता के काम आएगा।

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

जाली-आधारित क्रिप्टोग्राफी (Lattice-based cryptography) का गणितीय अंतर्ज्ञान

Fri, 11 Sep 2026 21:00:00 +0900

1. परिचय: पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC) की शुरुआत और जाली-आधारित क्रिप्टोग्राफी (Lattice-based cryptography) का उदय

आधुनिक समाज के डिजिटल बुनियादी ढांचे का आधार RSA और एलिप्टिक कर्व क्रिप्टोग्राफी (ECC) जैसी पब्लिक-की क्रिप्टोग्राफी (Public-key cryptography) तकनीकें हैं। इन क्रिप्टोग्राफी विधियों की सुरक्षा “प्राइम फैक्टराइजेशन प्रॉब्लम (Prime Factorization Problem)” और “डिस्क्रीट लॉगरिथम प्रॉब्लम (Discrete Logarithm Problem)” जैसी गणितीय कठिनाइयों पर निर्भर करती है, जिनके बारे में माना जाता है कि पारंपरिक क्लासिकल कंप्यूटरों द्वारा उन्हें कुशलतापूर्वक हल नहीं किया जा सकता है (इसमें एक्सपोनेंशियल समय लगता है)।

हालाँकि, 1994 में पीटर शोर (Peter Shor) द्वारा प्रस्तुत “शोर का एल्गोरिदम (Shor’s Algorithm)” ने क्रिप्टोग्राफी की दुनिया में तहलका मचा दिया। इस एल्गोरिदम ने गणितीय रूप से यह साबित कर दिया कि जब बड़े पैमाने पर क्वांटम कंप्यूटर वास्तविकता बन जाएंगे, तो वे प्राइम फैक्टराइजेशन और डिस्क्रीट लॉगरिथम समस्याओं को पॉलीनोमियल समय (Polynomial time) में हल कर देंगे। इसका अर्थ है कि वर्तमान में व्यापक रूप से उपयोग की जाने वाली पब्लिक-की क्रिप्टोग्राफी भविष्य में पूरी तरह से डिक्रिप्ट (decrypt) की जा सकेगी।

इस तरह के “क्वांटम खतरे (Quantum Threat)” का मुकाबला करने के लिए, नई क्रिप्टोग्राफिक विधियों पर शोध करना एक तत्काल आवश्यकता बन गई, जिन्हें क्वांटम कंप्यूटरों का उपयोग करके भी तोड़ना मुश्किल हो। इस क्षेत्र को “पोस्ट-क्वांटम क्रिप्टोग्राफी (Post-Quantum Cryptography: PQC)” या “क्वांटम-प्रतिरोधी क्रिप्टोग्राफी” कहा जाता है।

PQC के लिए कई मजबूत उम्मीदवार मौजूद हैं। इनमें हैश-आधारित क्रिप्टोग्राफी, कोड-आधारित क्रिप्टोग्राफी, मल्टीवेरिएट पॉलीनोमियल क्रिप्टोग्राफी, और आइसोजेनी-आधारित क्रिप्टोग्राफी शामिल हैं। लेकिन इनमें से जिसने वर्तमान में सबसे अधिक ध्यान आकर्षित किया है और जो NIST (नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड्स एंड टेक्नोलॉजी, USA) की PQC मानकीकरण प्रक्रिया के केंद्र में है, वह “जाली-आधारित क्रिप्टोग्राफी (Lattice-based cryptography)” है। अन्य विधियों की तुलना में, जाली-आधारित क्रिप्टोग्राफी में एन्क्रिप्शन और डिक्रिप्शन की गति बहुत तेज है। इसके अलावा, इसकी एक उत्कृष्ट विशेषता यह है कि इसमें “सबसे खराब स्थिति की जटिलता (Worst-case complexity)” से “औसत स्थिति की जटिलता (Average-case complexity)” में कमी (reduction) का गुण है, जो क्रिप्टोग्राफिक सिद्धांत में सुरक्षा का एक अत्यंत शक्तिशाली प्रमाण प्रदान करता है।

इस लेख में, हम जाली-आधारित क्रिप्टोग्राफी की नींव, “जाली (Lattice)” की गणितीय परिभाषा से शुरू करेंगे, और फिर जाली पर कठिन समस्याओं जैसे कि SVP (सबसे छोटा वेक्टर समस्या / Shortest Vector Problem) और CVP (सबसे करीबी वेक्टर समस्या / Closest Vector Problem) पर चर्चा करेंगे। अंत में, हम “LWE समस्या (Learning With Errors)” के बारे में विस्तार से जानेंगे, जिसे आधुनिक जाली-आधारित क्रिप्टोग्राफी का हृदय कहा जा सकता है। हम गणितीय सूत्रों, ज्यामितीय अंतर्ज्ञान और ठोस संख्यात्मक उदाहरणों के साथ इसका गहराई से विश्लेषण करेंगे।

2. जाली (Lattice) की गणितीय परिभाषा और ज्यामितीय अंतर्ज्ञान

2.1 वेक्टर स्पेस और जाली

गणित में, “जाली (Lattice)” $n$-आयामी वास्तविक वेक्टर स्पेस $\mathbb{R}^n$ के भीतर नियमित रूप से व्यवस्थित असतत (discrete) बिंदुओं का एक सेट है। यह लीनियर अलजेब्रा में सीखे गए वेक्टर स्पेस (Vector Space) के समान है, लेकिन इनमें एक महत्वपूर्ण अंतर है। जबकि एक वेक्टर स्पेस एक सतत (continuous) स्थान है जिसे बेसिस (आधार) वेक्टरों के “वास्तविक संख्या (real number) गुणांक” वाले रैखिक संयोजन (linear combination) द्वारा दर्शाया जाता है, एक जाली एक असतत स्थान है जिसे बेसिस वेक्टरों के “पूर्णांक (integer) गुणांक” वाले रैखिक संयोजन द्वारा दर्शाया जाता है।

आइए एक सख्त गणितीय परिभाषा दें। $m$-आयामी वास्तविक वेक्टर स्पेस $\mathbb{R}^m$ में $n$ ($n \le m$) रैखिक रूप से स्वतंत्र (linearly independent) वेक्टरों $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ पर विचार करें। मान लें कि एक मैट्रिक्स $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$ है, जिसके कॉलम में ये वेक्टर हैं। इस $B$ को जाली का “बेसिस (Basis)” कहा जाता है।

इस बेसिस $B$ द्वारा उत्पन्न जाली $\mathcal{L}(B)$ को इस प्रकार परिभाषित किया गया है:

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

यहाँ महत्वपूर्ण बात यह है कि गुणांक $x_i$ वास्तविक संख्याओं $\mathbb{R}$ तक सीमित नहीं हैं, बल्कि पूर्णांकों $\mathbb{Z}$ तक सीमित हैं। इसके परिणामस्वरूप, अंतरिक्ष में मौजूद अनगिनत सतत बिंदुओं के बजाय, समान दूरी पर स्थित चौराहों की तरह “असतत बिंदुओं का एक सेट” बनता है।

2.2 ज्यामितीय छवि

आइए 2-आयामी तल $\mathbb{R}^2$ के एक उदाहरण पर विचार करें। यदि हम बेसिस वेक्टर के रूप में $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ और $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ चुनते हैं, तो उनके द्वारा उत्पन्न जाली, निर्देशांक तल पर सभी पूर्णांक निर्देशांकों $(x, y) \in \mathbb{Z}^2$ का सेट होगी। यह सबसे सरल “वर्गाकार जाली (square lattice)” है।

हालाँकि, जालियाँ हमेशा ऑर्थोगोनल (समकोण पर) नहीं होती हैं। उदाहरण के लिए, यदि हम बेसिस $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ और $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$ पर विचार करें, तो उत्पन्न बिंदु एक तिरछे (skewed) जाल के चौराहों की तरह दिखेंगे।

2.3 बेसिस की गैर-अद्वितीयता (Non-uniqueness) और यूनिमॉड्युलर ट्रांसफॉर्मेशन

जाली-आधारित क्रिप्टोग्राफी की सुरक्षा के मूल में एक महत्वपूर्ण गुण निहित है: “एक ही जाली उत्पन्न करने वाले अनगिनत बेसिस मौजूद होते हैं।”

उदाहरण के लिए, ऊपर बताई गई बेसिस $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ द्वारा उत्पन्न $\mathbb{Z}^2$ जाली, बिल्कुल उसी $\mathbb{Z}^2$ जाली को उत्पन्न करती है जिसे बेसिस $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$ का उपयोग करके भी उत्पन्न किया जा सकता है।

एक बेसिस $B$ और दूसरे बेसिस $B'$ द्वारा समान जाली उत्पन्न करने के लिए आवश्यक और पर्याप्त शर्त (necessary and sufficient condition) यह है कि एक पूर्णांक घटकों वाला मैट्रिक्स $U \in \mathbb{Z}^{n \times n}$ मौजूद हो, जिसका डिटरमिनेंट $\det(U) = \pm 1$ हो, और जिसे इस प्रकार व्यक्त किया जा सके:

$$ B' = B U $$

इस प्रकार के मैट्रिक्स $U$ को “यूनिमॉड्युलर मैट्रिक्स (Unimodular matrix)” कहा जाता है।

क्रिप्टोग्राफी में इसके अनुप्रयोग का मूल विचार एक “अच्छे बेसिस” (जो लगभग ऑर्थोगोनल हो और छोटे वेक्टरों से बना हो) को सीक्रेट की (गुप्त कुंजी) के रूप में उपयोग करना है, और एक “बुरे बेसिस” (जो अत्यधिक तिरछा हो और बहुत लंबे वेक्टरों से बना हो) को पब्लिक की (सार्वजनिक कुंजी) के रूप में उपयोग करना है। उच्च आयामों में एक बुरे बेसिस से एक अच्छे बेसिस की गणना करना बहुत मुश्किल हो जाता है। यही जाली-आधारित क्रिप्टोग्राफी का मूलभूत अंतर्ज्ञान है।

3. जाली में गणना संबंधी कठिन समस्याएं

जाली-आधारित क्रिप्टोग्राफी की सुरक्षा जाली पर कुछ गणितीय समस्याओं को हल करने की कठिनाई पर निर्भर करती है। यहाँ हम दो सबसे बुनियादी और प्रसिद्ध समस्याओं का परिचय देंगे।

3.1 सबसे छोटा वेक्टर समस्या (Shortest Vector Problem: SVP)

SVP जाली सिद्धांत में सबसे शास्त्रीय और प्रसिद्ध समस्या है।

परिभाषा (SVP): मान लें कि कोई भी जाली बेसिस $B$ दिया गया है, तो उस जाली $\mathcal{L}(B)$ से संबंधित सभी गैर-शून्य वेक्टरों में से, उस वेक्टर $\mathbf{v}$ का पता लगाएं जिसका यूक्लिडियन नॉर्म (लंबाई) सबसे कम हो।

सूत्र रूप में, यह वह $\mathbf{v}$ खोजने की समस्या है जो $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$ को संतुष्ट करता हो। इस न्यूनतम लंबाई को $\lambda_1(\mathcal{L})$ के रूप में लिखा जाता है और इसे “जाली का पहला क्रमिक न्यूनतम मान (First successive minimum)” कहा जाता है।

2D या 3D जैसे निचले आयामों में, आप एक चित्र बनाकर सबसे छोटे वेक्टर को अपनी आँखों से देख सकते हैं। या आप इसे गॉस (Gauss) के जाली रिडक्शन एल्गोरिदम का उपयोग करके कुशलतापूर्वक हल कर सकते हैं। हालाँकि, जब आयाम $n$ सैकड़ों से हजारों जैसे उच्च आयामों तक पहुँचता है, तो SVP को सटीक रूप से हल करना NP-हार्ड माना जाता है।

वास्तविक क्रिप्टोग्राफी में, सटीक सबसे छोटे वेक्टर के बजाय, “लगभग सबसे छोटे वेक्टर” को खोजने वाली समस्या, एप्रोक्सिमेट SVP ($\gamma$-SVP) का उपयोग किया जाता है। यदि एप्रोक्सिमेशन फैक्टर (सन्निकटन कारक) $\gamma$ पॉलीनोमियल आकार का है, तो इस समस्या को अभी भी बहुत कठिन माना जाता है।

3.2 सबसे करीबी वेक्टर समस्या (Closest Vector Problem: CVP)

CVP भी जाली-आधारित क्रिप्टोग्राफी में एक अत्यंत महत्वपूर्ण समस्या है।

परिभाषा (CVP): मान लें कि कोई भी जाली बेसिस $B$ और अंतरिक्ष में कोई लक्ष्य वेक्टर $\mathbf{t} \in \mathbb{R}^m$ (जो जरूरी नहीं कि जाली बिंदु हो) दिया गया है, तो जाली के बिंदुओं में से वह जाली बिंदु $\mathbf{v} \in \mathcal{L}(B)$ खोजें जो $\mathbf{t}$ के सबसे करीब हो।

सूत्र रूप में, यह वह जाली बिंदु $\mathbf{v}$ खोजने की समस्या है जो $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$ को संतुष्ट करता हो।

SVP की तरह, उच्च आयामों में CVP भी NP-हार्ड है। क्रिप्टोग्राफिक अनुप्रयोगों के दृष्टिकोण से, LWE समस्या (जिसकी चर्चा बाद में की जाएगी) CVP के एक विशेष संस्करण (Bounded Distance Decoding: BDD) से निकटता से संबंधित है।

3.3 उच्च आयामों में इन्हें हल करना असंभव क्यों है? (LLL और BKZ की सीमाएँ)

उच्च-आयामी जाली समस्याओं को हल करने के लिए एक प्रसिद्ध एल्गोरिदम LLL एल्गोरिदम (Lenstra-Lenstra-Lovász algorithm) है। LLL एल्गोरिदम पॉलीनोमियल समय में काम करता है और जाली बेसिस को कुछ हद तक “अच्छे बेसिस” में घटा (रिड्यूस) सकता है। हालाँकि, LLL एल्गोरिदम द्वारा खोजा जाने वाला सबसे छोटा वेक्टर, वास्तविक सबसे छोटे वेक्टर की लंबाई के सापेक्ष एक एक्सपोनेंशियल ($2^{\mathcal{O}(n)}$) एप्रोक्सिमेशन फैक्टर (सन्निकटन कारक) रखता है, इसलिए यह क्रिप्टोग्राफी की सुरक्षा को तोड़ने के लिए पर्याप्त नहीं है।

यदि LLL का उन्नत संस्करण BKZ (Block Korkine-Zolotarev) एल्गोरिदम जैसे अधिक शक्तिशाली बेसिस रिडक्शन एल्गोरिदम का उपयोग किया जाए, तो छोटे वेक्टर पाए जा सकते हैं, लेकिन इसकी कम्प्यूटेशनल जटिलता (computational complexity) ब्लॉक आकार के संबंध में एक्सपोनेंशियल रूप से बढ़ जाती है। जाली-आधारित क्रिप्टोग्राफी में, सुरक्षित पैरामीटर (जैसे आयाम $n$ का आकार) इस BKZ एल्गोरिदम के निष्पादन समय का अनुमान लगाकर निर्धारित किए जाते हैं। वर्तमान PQC मानक मापदंडों में, आयाम $n$ को 500 से 1000 या उससे अधिक के मानों के लिए चुना जाता है, और यह माना जाता है कि भविष्य के सुपर कंप्यूटरों या क्वांटम कंप्यूटरों का उपयोग करके भी इसे डिक्रिप्ट करने में ब्रह्मांड की आयु से अधिक समय लगेगा।

4. LWE समस्या (Learning With Errors) का गणितीय निरूपण

आधुनिक जाली-आधारित क्रिप्टोग्राफी का अधिकांश हिस्सा “LWE समस्या (Learning With Errors)” पर आधारित है, जिसे 2005 में ओडेड रेगेव (Oded Regev) द्वारा प्रस्तावित किया गया था। LWE समस्या की सुंदरता इसके निर्माण की सरलता और इसके शक्तिशाली गणितीय प्रमाण में निहित है, जिसे “सबसे खराब स्थिति की जटिलता से औसत स्थिति की जटिलता में कमी” कहा जाता है।

4.1 बिना शोर के रेखीय समीकरणों की प्रणाली

LWE समस्या को समझने के लिए, आइए पहले बिना शोर वाले रेखीय समीकरणों की एक सरल प्रणाली पर विचार करें। मान लें कि हमारे पास एक अज्ञात गुप्त वेक्टर $\mathbf{s} \in \mathbb{Z}_q^n$ (प्रत्येक घटक $0$ से $q-1$ तक का एक पूर्णांक है) है। यहाँ, मान लें कि $q$ एक अभाज्य संख्या है।

हम यादृच्छिक (random) गुणांक वेक्टर $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$ चुनते हैं, और गुप्त वेक्टर $\mathbf{s}$ के साथ इसके डॉट प्रोडक्ट की गणना मॉड्युलो $q$ पर करते हैं। $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

यदि हमें पर्याप्त संख्या में (कम से कम $n$) $(\mathbf{a}_i, b_i)$ के जोड़े दिए जाते हैं, तो हम लीनियर अलजेब्रा में “गौसियन एलिमिनेशन (Gaussian elimination)” का उपयोग करके गुप्त वेक्टर $\mathbf{s}$ को आसानी से पुनर्प्राप्त कर सकते हैं। यह एक ऐसी समस्या है जिसे पॉलीनोमियल समय में आसानी से हल किया जा सकता है।

4.2 LWE समस्या की परिभाषा: शोर जोड़ना

तो, यदि हम इस समस्या में थोड़ा सा “शोर (त्रुटि / error)” जोड़ दें तो क्या होगा? यही LWE समस्या का सार है।

अज्ञात गुप्त वेक्टर $\mathbf{s} \in \mathbb{Z}_q^n$ के लिए, हम प्रत्येक समीकरण के परिणाम में एक छोटी सी त्रुटि $e_i \in \mathbb{Z}_q$ जोड़ते हैं। $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

यहाँ, $e_i$ एक छोटा पूर्णांक मान है जिसका औसत 0 है और जिसका मानक विचलन (standard deviation) अपेक्षाकृत छोटा है (उदाहरण के लिए, सामान्य वितरण की तरह एक डिस्क्रीट गॉसियन वितरण (discrete Gaussian distribution) से चुना गया)। प्रदान की गई जानकारी यादृच्छिक वेक्टर $\mathbf{a}_i$ और त्रुटि जोड़ने के बाद गणना किए गए $b_i$ के जोड़े की एक सूची है। $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

इसे मैट्रिक्स का उपयोग करके बहुत स्पष्ट रूप से दर्शाया जा सकता है। यादृच्छिक मैट्रिक्स $A \in \mathbb{Z}_q^{m \times n}$, गुप्त वेक्टर $\mathbf{s} \in \mathbb{Z}_q^n$, और त्रुटि वेक्टर $\mathbf{e} \in \mathbb{Z}_q^m$ का उपयोग करके, हम इसे इस प्रकार लिख सकते हैं:

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

हमें केवल $A$ और $\mathbf{b}$ दिए जाते हैं। यहाँ से $\mathbf{s}$ ज्ञात करना “सर्च LWE समस्या (Search LWE problem)” कहलाता है।

चूंकि इसमें त्रुटि $e_i$ शामिल है, इसलिए यदि हम गौसियन एलिमिनेशन का उपयोग करने का प्रयास करते हैं, तो समीकरणों को जोड़ने और घटाने की प्रक्रिया में त्रुटि एक्सपोनेंशियल रूप से बढ़ जाती है, जिससे सही उत्तर तक पहुँचना असंभव हो जाता है। पहली नज़र में, यह रेखीय समीकरणों की एक सरल प्रणाली की तरह लगता है, लेकिन इस छोटे से शोर के जुड़ने से ही समस्या की कठिनाई NP-हार्ड स्तर तक पहुँच जाती है।

4.3 डिसीजन LWE समस्या (Decision LWE)

क्रिप्टोग्राफिक सिद्धांत के प्रमाणों में अक्सर जिसका उपयोग किया जाता है, वह सर्च LWE समस्या का एक संस्करण है, जिसे “डिसीजन LWE समस्या (Decision LWE problem)” कहा जाता है।

डिसीजन LWE समस्या यह निर्धारित करने की समस्या है कि नीचे दिए गए दो वितरणों (distributions) में से प्राप्त नमूनों की सूची किस वितरण से आई है:

LWE वितरण: जानबूझकर गणना की गई $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
यूनिफ़ॉर्म रैंडम वितरण: पूरी तरह से यादृच्छिक रूप से चुने गए मैट्रिक्स $A$ और वेक्टर $\mathbf{u}$ से मिलकर बना $(A, \mathbf{u})$

आश्चर्यजनक रूप से, यदि LWE समस्या के मापदंडों को ठीक से चुना जाता है, तो LWE वितरण से प्राप्त जोड़े पूरी तरह से यादृच्छिक डेटा के जोड़े से “कम्प्यूटेशनल रूप से अप्रभेद्य (Computationally Indistinguishable)” हो जाते हैं। यही गुण LWE-आधारित क्रिप्टोग्राफी का आधार है, जो ऐसे “सिफरटेक्स्ट (ciphertext) उत्पन्न करता है जिन्हें यादृच्छिक संख्याओं (random numbers) से अलग नहीं किया जा सकता है।”

4.4 सबसे खराब स्थिति से औसत स्थिति की जटिलता में कमी (Regev’s Theorem)

ओडेड रेगेव (Oded Regev) की सबसे बड़ी उपलब्धि इस LWE समस्या की कठिनाई को ऊपर बताई गई जाली समस्याओं (SVP और CVP) की कठिनाई से गणितीय रूप से जोड़ना था।

क्वांटम रिडक्शन (Quantum reduction) का उपयोग करते हुए, उन्होंने साबित किया कि “यदि कोई पॉलीनोमियल-टाइम एल्गोरिदम मौजूद है जो औसत रूप से LWE समस्या को हल कर सकता है (यादृच्छिक रूप से चुने गए $A$ और $\mathbf{e}$ के लिए), तो एक पॉलीनोमियल-टाइम क्वांटम एल्गोरिदम भी मौजूद होगा जो किसी भी जाली के सबसे खराब स्थिति (सबसे कठिन मामले) में Gap-SVP को हल कर सकता है।” (बाद में, Peikert और अन्य लोगों द्वारा क्लासिकल रिडक्शन भी दिखाया गया है)।

यह क्रिप्टोग्राफिक सिद्धांत में एक सपने जैसी विशेषता है। ऐसा इसलिए है क्योंकि यह इस चिंता को दूर करता है कि “हो सकता है कि क्रिप्टोग्राफी टूट गई हो क्योंकि हमने संयोग से एक कमजोर कुंजी (औसत मामलों में से एक) चुन ली हो,” और यह एक शक्तिशाली गारंटी प्रदान करता है कि “यदि औसत LWE को हल किया जा सकता है, तो जाली की सभी कठिन समस्याओं को हल किया जा सकता है (इसलिए LWE निश्चित रूप से कठिन है)।”

graph TD A["सबसे खराब स्थिति वाली जाली समस्याएं (Gap-SVP, SIVP)"] -->|Quantum/Classical Reduction| B["औसत स्थिति वाली LWE समस्या"] B -->|Cryptographic Construction| C["LWE-आधारित क्रिप्टोसिस्टम (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. LWE का उपयोग करके पब्लिक-की क्रिप्टोग्राफी (रेगेव क्रिप्टोग्राफी - Regev Cryptosystem) का निर्माण

अब जब हम LWE समस्या की कठिनाई को समझ चुके हैं, तो आइए ओडेड रेगेव द्वारा प्रस्तावित बुनियादी पब्लिक-की क्रिप्टोग्राफी प्रणाली (Public-key cryptosystem) को देखें कि यह एन्क्रिप्शन और डिक्रिप्शन करने के लिए इसका उपयोग कैसे करती है। यहाँ हम 1-बिट संदेश $M \in \{0, 1\}$ को एन्क्रिप्ट करने के सबसे बुनियादी तंत्र की व्याख्या करेंगे।

5.1 कुंजी निर्माण (Key Generation)

सिस्टम पैरामीटर के रूप में, एक अभाज्य संख्या $q$ (मॉड्यूलस), एक आयाम $n$, और समीकरणों की संख्या $m$ ($m > n \log q$) निर्धारित करें।
गुप्त कुंजी (Secret Key) के रूप में एक वेक्टर $\mathbf{s} \in \mathbb{Z}_q^n$ को यादृच्छिक रूप से चुनें।
एक यादृच्छिक मैट्रिक्स $A \in \mathbb{Z}_q^{m \times n}$ उत्पन्न करें।
एक छोटा त्रुटि वेक्टर $\mathbf{e} \in \mathbb{Z}_q^m$ एक त्रुटि वितरण जैसे कि डिस्क्रीट गॉसियन वितरण से चुनें।
वेक्टर $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$ की गणना करें।
पब्लिक की (Public Key) $(A, \mathbf{b})$ होगी।
सीक्रेट की (Secret Key) $\mathbf{s}$ होगी।

पब्लिक की वस्तुतः “LWE समस्या का एक इंस्टेंस (instance)” है। चूँकि पब्लिक की $(A, \mathbf{b})$ से सीक्रेट की $\mathbf{s}$ ज्ञात करना सर्च LWE समस्या को हल करने के बराबर है, इसलिए सुरक्षा की गारंटी है।

5.2 एन्क्रिप्शन (Encryption)

ऐलिस, बॉब की पब्लिक की $(A, \mathbf{b})$ का उपयोग करके 1-बिट संदेश $M \in \{0, 1\}$ को एन्क्रिप्ट करती है।

एक यादृच्छिक बाइनरी वेक्टर (जिसके घटक 0 या 1 हैं) $\mathbf{r} \in \{0, 1\}^m$ चुनें।
सिफरटेक्स्ट (ciphertext) के पहले भाग के रूप में, वेक्टर $\mathbf{u} = A^T \mathbf{r} \pmod q$ की गणना करें। ($A^T$, $A$ का ट्रांसपोज़ मैट्रिक्स (transpose matrix) है। अर्थात्, हम $A$ की उन पंक्तियों को जोड़ रहे हैं जहाँ $\mathbf{r}$ का घटक 1 है)।
सिफरटेक्स्ट के दूसरे भाग के रूप में, स्केलर $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$ की गणना करें। (यदि संदेश $M$ 0 है तो कुछ भी नहीं जोड़ा जाता है, और यदि $1$ है तो हम $q$ का ठीक आधा मान $\lfloor \frac{q}{2} \rfloor$ जोड़ते हैं)।
सिफरटेक्स्ट (Ciphertext) $(\mathbf{u}, v)$ होगा।

एन्क्रिप्शन का सहज अर्थ पब्लिक की के मैट्रिक्स $A$ और वेक्टर $\mathbf{b}$ के लिए “यादृच्छिक उपसमूह का योग (sum of a random subset)” लेना है। डिसीजन LWE समस्या की कठिनाई के कारण, यह सिफरटेक्स्ट $(\mathbf{u}, v)$ एक पूरी तरह से यादृच्छिक वेक्टर और एक समान यादृच्छिक संख्या (uniform random number) से अप्रभेद्य (indistinguishable) प्रतीत होता है (सिमेंटिक सिक्योरिटी: Semantic Security)।

flowchart LR M["संदेश M {0,1} में"] --> Enc PK["पब्लिक की (A, b)"] --> Enc r["यादृच्छिक बाइनरी वेक्टर r"] --> Enc subgraph Enc ["एन्क्रिप्शन प्रक्रिया"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["सिफरटेक्स्ट (u, v)"]

5.3 डिक्रिप्शन (Decryption)

बॉब अपनी गुप्त कुंजी $\mathbf{s}$ का उपयोग करके सिफरटेक्स्ट $(\mathbf{u}, v)$ को डिक्रिप्ट करता है।

निम्नलिखित मान की गणना करें: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
यदि गणना किया गया परिणाम $0$ के करीब है, तो $M=0$ आउटपुट करें, और यदि यह $\lfloor \frac{q}{2} \rfloor$ के करीब है, तो $M=1$ आउटपुट करें।

आइए गणितीय रूप से इसका विस्तार करें कि इसे इस प्रकार डिक्रिप्ट क्यों किया जा सकता है। याद रखें कि $\mathbf{b} = A \mathbf{s} + \mathbf{e}$ था।

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

यहाँ, सूत्र में से $\mathbf{s}^T A^T \mathbf{r}$ पूरी तरह से कट कर (cancel out) समाप्त हो गया! बचा हुआ हिस्सा $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$ है।

$\mathbf{e}$ एक शोर वेक्टर है जिसके घटक बहुत छोटे हैं, और $\mathbf{r}$ एक बाइनरी वेक्टर है जिसके घटक 0 या 1 हैं। इसलिए, उनका डॉट प्रोडक्ट $\mathbf{e}^T \mathbf{r}$ भी अपेक्षाकृत छोटा मान (यदि पैरामीटर ठीक से चुने गए हैं) ही रहेगा।

यदि $M=0$ है, तो परिणाम $\mathbf{e}^T \mathbf{r}$ होगा, जो $0$ के करीब एक छोटा मान होगा।
यदि $M=1$ है, तो परिणाम $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$ होगा, जो $q$ के आधे मान $\lfloor \frac{q}{2} \rfloor$ के आसपास स्थित होगा।

यदि मापदंडों को इस तरह से डिज़ाइन किया गया है कि त्रुटि $\mathbf{e}^T \mathbf{r}$ का निरपेक्ष मान (absolute value) $\frac{q}{4}$ से कम रहे, तो बॉब केवल यह देखकर संदेश $M$ को सटीक रूप से निर्धारित (डिक्रिप्ट) कर सकता है कि गणना का परिणाम $0$ के अधिक करीब है या $\lfloor \frac{q}{2} \rfloor$ के। यही वह सुंदर तंत्र है जिसके द्वारा LWE-आधारित क्रिप्टोग्राफी काम करती है।

flowchart LR CT["सिफरटेक्स्ट (u, v)"] --> Dec SK["गुप्त कुंजी s"] --> Dec subgraph Dec ["डिक्रिप्शन प्रक्रिया"] direction TB calc["गणना करें D = v - s^T * u mod q"] check["जांचें कि क्या D, 0 या q/2 के करीब है"] end calc --> check Dec --> M_out["पुनर्प्राप्त संदेश M"]

6. विशिष्ट संख्यात्मक मानों का उपयोग करते हुए LWE क्रिप्टोग्राफी का एक टॉय उदाहरण (Toy Example)

सूत्रों की एक श्रृंखला के साथ इसे समझना मुश्किल हो सकता है, इसलिए आइए वास्तव में बहुत छोटे संख्यात्मक मापदंडों को सेट करके एन्क्रिप्शन से डिक्रिप्शन तक की गणनाओं का पालन करें। (※ वास्तविक क्रिप्टोग्राफ़िक प्रणालियों में, सुरक्षा सुनिश्चित करने के लिए $n$ के लिए 500 या उससे अधिक और $q$ के लिए हजारों या उससे अधिक मान का उपयोग किया जाता है)

【पैरामीटर सेटिंग्स】

मॉड्यूलस $q = 17$ (अभाज्य संख्या। इसलिए मान $0$ से $16$ तक की सीमा में होंगे)
आयाम $n = 2$
समीकरणों की संख्या $m = 4$
मान लें कि हम संदेश $M = 1$ को एन्क्रिप्ट कर रहे हैं।
संदेश का शिफ्ट मान: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

【1. कुंजी निर्माण चरण (Key Generation Phase)】 बॉब गुप्त कुंजी $\mathbf{s}$, मैट्रिक्स $A$, और त्रुटि वेक्टर $\mathbf{e}$ को यादृच्छिक रूप से चुनता है।

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

इसके बाद, पब्लिक की $\mathbf{b}$ की गणना करें।

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

इसकी गणना मॉड्युलो 17 में करें। (जैसे $66 = 17 \times 3 + 15$)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

त्रुटि वेक्टर $\mathbf{e}$ जोड़ें।

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

पब्लिक की $A$ और $\mathbf{b} = (16, 0, 11, 1)^T$ होगी।

【2. एन्क्रिप्शन चरण (Encryption Phase)】 ऐलिस संदेश $M = 1$ को एन्क्रिप्ट करती है। वह एक यादृच्छिक वेक्टर $\mathbf{r}$ चुनती है। यहाँ मान लें कि $\mathbf{r} = (1, 0, 1, 0)^T$ है।

$\mathbf{u}$ की गणना करें।

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

$v$ की गणना करें।

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

संदेश $M=1$ के अनुरूप मान $\lfloor 17/2 \rfloor = 8$ जोड़ें।

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

ऐलिस सिफरटेक्स्ट के रूप में $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ बॉब को भेजती है।

【3. डिक्रिप्शन चरण (Decryption Phase)】 सिफरटेक्स्ट प्राप्त करने के बाद, बॉब गुप्त कुंजी $\mathbf{s} = (3, 4)^T$ का उपयोग करके इसे डिक्रिप्ट करता है। डिक्रिप्शन प्रक्रिया सूत्र: $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$ की गणना करें।

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

यहाँ, मॉड्युलो 17 की दुनिया में, $-8$, $9$ के बराबर है ($-8 + 17 = 9$)। प्राप्त मान $D = 9$ का मूल्यांकन यह निर्धारित करने के लिए करें कि यह $0$ के अधिक करीब है या $8$ ($\lfloor 17/2 \rfloor$) के। चूँकि $9$ स्पष्ट रूप से $0$ की तुलना में $8$ के अधिक करीब है, बॉब ने $M = 1$ को सफलतापूर्वक और सही ढंग से पुनर्प्राप्त कर लिया!

यह $9$ क्यों हुआ? आइए पहले के प्रमाण को याद करें। त्रुटि भाग $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$ है। इसलिए, गणना का परिणाम $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$ है, और यह पुष्टि हो गई है कि सैद्धांतिक रूप से सही मान की गणना की गई है।

7. व्यावहारिक अनुप्रयोग की दिशा में विकास: Ring-LWE और Module-LWE

अब तक समझाई गई मानक LWE समस्या (Standard LWE) में बहुत मजबूत सुरक्षा प्रमाण है, लेकिन व्यावहारिक अनुप्रयोग में इसकी एक घातक कमजोरी है: “कुंजी का आकार विशाल हो जाता है” और “कम्प्यूटेशनल लागत अधिक होती है।”

Standard LWE में, पब्लिक की में एक विशाल मैट्रिक्स $A \in \mathbb{Z}_q^{m \times n}$ शामिल होता है। जब पैरामीटर $n$ सैकड़ों से हजारों तक पहुँच जाता है, तो इस मैट्रिक्स का आकार कई मेगाबाइट तक पहुँच जाता है, जो इंटरनेट संचार प्रोटोकॉल (जैसे TLS) में हर बार प्रसारित और प्राप्त करने के लिए बहुत भारी होता है। इसके अलावा, मैट्रिक्स और वेक्टर के गुणन के लिए $\mathcal{O}(n^2)$ कम्प्यूटेशनल जटिलता की आवश्यकता होती है।

इस समस्या को हल करने के लिए, “Ring-LWE (RLWE)” और “Module-LWE (MLWE)” को पेश किया गया, जो जाली में पॉलीनोमियल रिंग्स (Polynomial rings) नामक बीजीय संरचनाओं (algebraic structures) को शामिल करते हैं।

7.1 Ring-LWE का अंतर्ज्ञान

Ring-LWE में, वेक्टर और मैट्रिक्स को पॉलीनोमियल रिंग $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$ पर तत्वों (बहुपदों / polynomials) से बदल दिया जाता है। (जहाँ $n$ को 2 की घात के रूप में चुना जाता है)।

Standard LWE में जहाँ पब्लिक की एक मैट्रिक्स $A$ थी, वहीं Ring-LWE में एकल बहुपद $a(x)$ का उपयोग किया जाता है। गुप्त कुंजी $s(x)$ और त्रुटि $e(x)$ भी बहुपद बन जाते हैं। समीकरण इस प्रकार है:

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

चूँकि यह बहुपदों का गुणन है, फास्ट फूरियर ट्रांसफॉर्म (FFT) के समान “नंबर थियोरेटिक ट्रांसफॉर्म (Number Theoretic Transform: NTT)” का उपयोग करके कम्प्यूटेशनल जटिलता को नाटकीय रूप से $\mathcal{O}(n \log n)$ तक कम किया जा सकता है। इसके अलावा, चूंकि पब्लिक की का आकार एक मैट्रिक्स से एकल बहुपद तक छोटा हो जाता है, इसलिए डेटा का आकार $\mathcal{O}(n)$ तक कम हो जाता है। यह संचार बैंडविड्थ के मामले में एक बड़ा लाभ प्रदान करता है।

गणितीय दृष्टिकोण से, Ring-LWE एक सामान्य जाली नहीं है, बल्कि यह एक विशेष समरूपता (symmetry) वाली जाली की समस्या में बदल जाती है, जिसे “आइडियल लैटिस (Ideal Lattice)” कहा जाता है।

7.2 Module-LWE और NIST का मानकीकरण (Kyber / ML-KEM)

हालाँकि Ring-LWE कुशल है, लेकिन यह चिंता थी कि आइडियल लैटिस की विशेष बीजीय संरचना भविष्य में हमलों का एक प्रारंभिक बिंदु बन सकती है। इसलिए, “Module-LWE (MLWE)” को पेश किया गया, जो Standard LWE की रूढ़िवादी (conservative) सुरक्षा और Ring-LWE की दक्षता का “सर्वश्रेष्ठ संयोजन (best of both worlds)” है।

Module-LWE में, हम बहुपदों वाले छोटे मैट्रिक्स और वेक्टरों पर विचार करते हैं। दूसरे शब्दों में, हम एक रिंग पर मॉड्यूल से निपटते हैं। वर्तमान में, NIST द्वारा PQC कुंजी-विनिमय एल्गोरिदम (KEM) के मानक के रूप में चुना गया “CRYSTALS-Kyber” (मानकीकृत नाम: ML-KEM), पूरी तरह से इस Module-LWE समस्या की कठिनाई पर आधारित है।

8. यह क्वांटम कंप्यूटरों के खिलाफ सुरक्षित क्यों है?

अंत में, आइए इस मुख्य प्रश्न को छूते हैं: “ऐसा क्यों माना जाता है कि क्वांटम कंप्यूटरों का उपयोग करके भी जाली-आधारित क्रिप्टोग्राफी को नहीं तोड़ा जा सकता है?”

Shor का एल्गोरिदम, जो क्वांटम कंप्यूटरों को RSA और एलिप्टिक कर्व क्रिप्टोग्राफी को तोड़ने की अनुमति देता है, अनिवार्य रूप से “हिडन सबग्रुप प्रॉब्लम (Hidden Subgroup Problem: HSP)” को हल करने के लिए एक एल्गोरिदम है। RSA और ECC (परिमित एबेलियन समूह / finite Abelian groups) के पीछे की गणितीय संरचना में आवधिकता (periodicity) होती है, और क्वांटम फूरियर ट्रांसफॉर्म (QFT) नामक क्वांटम एल्गोरिदम के लिए विशिष्ट ऑपरेशन का उपयोग करके इस अवधि (छिपे हुए उपसमूह) को एक बार में निकाला जा सकता है।

हालाँकि, जाली की समस्याएं मौलिक रूप से भिन्न हैं। हालांकि जालियों में भी आवधिकता होती है, SVP और CVP के लिए “सबसे कम दूरी” और “शोर हटाने” जैसे ज्यामितीय, गैर-रेखीय (non-linear) गुणों की आवश्यकता होती है। Shor के एल्गोरिदम की तरह “एबेलियन समूह पर क्वांटम फूरियर ट्रांसफॉर्म” को सीधे लागू करने से जाली समस्याओं को हल करने के लिए उपयोगी जानकारी को कुशलतापूर्वक नहीं निकाला जा सकता है। आज तक, SVP या LWE को पॉलीनोमियल समय में हल करने वाला कोई क्वांटम एल्गोरिदम नहीं खोजा गया है। यह व्यापक रूप से माना जाता है कि क्वांटम कंप्यूटरों की समानांतर कंप्यूटिंग क्षमता के साथ भी, ब्रूट-फोर्स सर्च (Brute-force search) के करीब का तरीका (ग्रोवर के एल्गोरिदम का उपयोग करके वर्गमूल गति वृद्धि / square root speedup तक ही) एकमात्र प्रभावी साधन है।

9. निष्कर्ष

इस लेख में, हमने जाली-आधारित क्रिप्टोग्राफी के गणितीय अंतर्ज्ञान के बारे में विस्तार से बताया है, जिसकी शुरुआत जाली की ज्यामितीय परिभाषा से हुई, उसके बाद LWE समस्या का निरूपण किया गया, और अंततः पब्लिक-की क्रिप्टोग्राफी के निर्माण को समझाया गया।

जाली (Lattice) एक असतत स्थान (discrete space) है जिसे बेसिस वेक्टरों के पूर्णांक गुणांकों वाले रैखिक संयोजन द्वारा दर्शाया जाता है। उच्च आयामों में एक “अच्छा बेसिस” खोजना (जो लगभग ऑर्थोगोनल हो) मुश्किल हो जाता है (SVP)।
LWE समस्या (Learning With Errors) शोर (noise) के साथ रेखीय समीकरणों की प्रणाली को हल करने की समस्या है। चूँकि यह जाली की सबसे खराब स्थिति (worst-case) वाली समस्याओं की कठिनाई से जुड़ी है, इसलिए यह सुरक्षा का एक मजबूत आधार प्रदान करती है।
LWE समस्या का उपयोग करते हुए, जानबूझकर शोर जोड़ने या हटाने के एक सरल तंत्र के माध्यम से एन्क्रिप्शन और डिक्रिप्शन (रेगेव क्रिप्टोग्राफी - Regev Cryptosystem) प्राप्त किया जाता है।
वास्तविक प्रोटोकॉल में, संचार दक्षता और कम्प्यूटेशनल गति में सुधार करने के लिए पॉलीनोमियल रिंग्स का उपयोग करने वाले Ring-LWE और Module-LWE को अपनाया गया है। ये NIST के मानक ML-KEM की नींव बनाते हैं।

जैसे-जैसे क्वांटम कंप्यूटर के रूप में अभूतपूर्व कंप्यूटिंग प्रतिमान बदलाव (paradigm shift) आ रहा है, यह बहुत ही रोमांचक है कि क्लासिकल लीनियर अलजेब्रा और नंबर थ्योरी (number theory) की गहराइयों से जन्मी “जाली-आधारित क्रिप्टोग्राफी” भविष्य की इंटरनेट सुरक्षा की नींव रखेगी। जाली-आधारित क्रिप्टोग्राफी की आधारभूत गणित बहुत अधिक जटिल नहीं है; लीनियर अलजेब्रा और प्रोबेबिलिटी (probability) के बुनियादी ज्ञान के साथ, इसकी सुंदर संरचना को पूरी तरह से समझा जा सकता है। हमें उम्मीद है कि यह लेख PQC के मूल में स्थित जाली-आधारित क्रिप्टोग्राफी को समझने में आपकी मदद करेगा।

रीमैन परिकल्पना और अभाज्य संख्याओं का वितरण: आधुनिक क्रिप्टोग्राफी के साथ गहरा संबंध

Fri, 11 Sep 2026 16:00:00 +0900

1. परिचय: अभाज्य संख्याओं का लौकिक रहस्य और रीमैन परिकल्पना

“अभाज्य संख्याएँ (Prime Numbers)” प्राकृतिक संख्याएँ हैं जो केवल 1 और स्वयं से विभाज्य होती हैं, और उन्हें गणित की दुनिया का “परमाणु” भी कहा जाता है। अनुक्रम 2, 3, 5, 7, 11, 13… पहली नज़र में अव्यवस्थित और यादृच्छिक प्रतीत होता है। प्राचीन यूनानी गणितज्ञ यूक्लिड ने यह साबित किया था कि “अभाज्य संख्याएँ अनंत हैं,” तब से अनगिनत गणितज्ञों ने अभाज्य संख्याओं के इस क्रम में छिपी नियमितता को उजागर करने का प्रयास किया है।

इस अभाज्य संख्या के रहस्य के सबसे करीब 1859 में जर्मन गणितज्ञ बर्नहार्ड रीमैन (Bernhard Riemann) द्वारा प्रस्तावित “रीमैन परिकल्पना (Riemann Hypothesis)” है। रीमैन परिकल्पना आधुनिक गणित में सबसे महत्वपूर्ण और अनसुलझी समस्याओं में से एक है, और यह क्ले मैथमेटिक्स इंस्टीट्यूट द्वारा निर्धारित मिलेनियम प्राइज समस्याओं में से एक है, जिस पर 1 मिलियन डॉलर का इनाम है।

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

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

2. अभाज्य संख्या प्रमेय और अभाज्य संख्याओं का वितरण: गॉस की खोज

अभाज्य संख्याएँ कैसे वितरित होती हैं, यह समझने के लिए, गणितज्ञों ने अभाज्य-गणना फलन (Prime-counting function) $\pi(x)$ पर विचार किया, जो दर्शाता है कि “किसी संख्या $x$ के बराबर या उससे कम कितनी अभाज्य संख्याएँ हैं।”

उदाहरण के लिए:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

15 वर्षीय प्रतिभाशाली गणितज्ञ कार्ल फ्रेडरिक गॉस (Carl Friedrich Gauss) ने अभाज्य संख्याओं की विशाल तालिकाओं की गणना की और पाया कि अभाज्य संख्याओं की आवृत्ति प्राकृतिक लघुगणक (natural logarithm) $\ln x$ के व्युत्क्रमानुपाती होकर कम हो जाती है। अर्थात्, उन्होंने अनुमान लगाया कि किसी संख्या $x$ के आसपास अभाज्य संख्या मिलने की प्रायिकता लगभग $\frac{1}{\ln x}$ है।

इसे समाकलन (integration) का उपयोग करके व्यक्त किया गया है, जिसे लघुगणकीय समाकलन (Logarithmic integral) $\text{Li}(x)$ कहा जाता है।

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

गॉस के अनुमान को बाद में 1896 में जैक्स हैडमार्ड और चार्ल्स जीन डे ला वैली-पूसिन द्वारा स्वतंत्र रूप से सिद्ध किया गया था, और इसे अभाज्य संख्या प्रमेय (Prime Number Theorem, PNT) के रूप में स्थापित किया गया।

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

या अनुमानित रूप से इसे इस प्रकार व्यक्त किया जाता है:

$$ \pi(x) \sim \frac{x}{\ln x} $$

इस प्रमेय से, यह पता चला कि यदि स्थूल रूप से देखा जाए, तो अभाज्य संख्याओं का वितरण बहुत सहज और अनुमानित होता है। हालाँकि, यदि सूक्ष्म रूप से देखा जाए, तो $\pi(x)$ और $\text{Li}(x)$ के बीच हमेशा “त्रुटि” अर्थात् “उतार-चढ़ाव” होता है। इस उतार-चढ़ाव का वास्तविक स्वरूप ही वह सबसे बड़ा रहस्य है जिसे रीमैन परिकल्पना सुलझाने का प्रयास कर रही है।

3. रीमैन ज़ेटा फ़ंक्शन और यूलर उत्पाद

अभाज्य संख्याओं के वितरण का विश्लेषण करने के लिए सबसे शक्तिशाली हथियार रीमैन ज़ेटा फ़ंक्शन (Riemann Zeta Function) है। यह मूल रूप से लियोनहार्ड यूलर (Leonhard Euler) द्वारा वास्तविक संख्याओं $s > 1$ के लिए परिभाषित एक अनंत श्रृंखला थी।

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

यूलर की सबसे बड़ी उपलब्धियों में से एक यह साबित करना था कि इस अनंत श्रृंखला को सभी अभाज्य संख्याओं $p$ पर एक अनंत उत्पाद के रूप में व्यक्त किया जा सकता है। यह यूलर उत्पाद सूत्र (Euler Product Formula) है।

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

प्रमाण की सहज समझ यह है कि दाईं ओर के प्रत्येक पद को एक गुणोत्तर श्रेणी के रूप में विस्तारित करके और उन्हें गुणा करके, अंकगणित के मूलभूत प्रमेय (सभी प्राकृतिक संख्याओं को अभाज्य संख्याओं के उत्पाद के रूप में विशिष्ट रूप से दर्शाया जाता है) के कारण, बाईं ओर की प्राकृतिक संख्याओं के व्युत्क्रमों का योग पूरी तरह से पुनर्गठित हो जाता है।

यह एक ही सूत्र विश्लेषण (अनंत श्रृंखला और निरंतर कार्य) और संख्या सिद्धांत (अभाज्य संख्या और असतत संख्या) को जोड़ने वाला सेतु बन गया। ज़ेटा फ़ंक्शन की जांच करना अभाज्य संख्याओं के वितरण की जांच करने के समान है।

4. विश्लेषणात्मक निरंतरता और सम्मिश्र तल में विस्तार

रीमैन की प्रतिभा इस बात में निहित है कि उन्होंने चर $s$ को, जिसे यूलर ने केवल वास्तविक संख्याओं के लिए $\zeta(s)$ में माना था, सम्मिश्र संख्या $s = \sigma + it$ ($\sigma$ वास्तविक भाग है, $t$ काल्पनिक भाग है) में विस्तारित किया।

मूल अनंत श्रृंखला केवल $\sigma > 1$ के लिए अभिसरण करती है, लेकिन रीमैन ने “विश्लेषणात्मक निरंतरता (Analytic Continuation)” नामक तकनीक का उपयोग करके परिभाषा का विस्तार किया ताकि $\zeta(s)$ का अर्थ पूरे सम्मिश्र तल पर हो, सिवाय $s = 1$ के पोल के।

उन्होंने ज़ेटा फ़ंक्शन द्वारा संतुष्ट एक सुंदर कार्यात्मक समीकरण (Functional equation) भी प्राप्त किया।

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

यहाँ $\Gamma(x)$ गामा फ़ंक्शन है। इस समीकरण के साथ, हम दाहिने आधे तल के गुणों से बाएं आधे तल के गुणों को जान सकते हैं।

शून्य (Zeros of the Zeta Function)

सम्मिश्र संख्या $s$ जहाँ ज़ेटा फ़ंक्शन का मान 0 हो जाता है, उसे “शून्य” कहा जाता है। कार्यात्मक समीकरण से, जब $s$ एक ऋणात्मक सम संख्या ($-2, -4, -6, \dots$) होती है, $\sin(\pi s / 2)$ 0 हो जाता है, इसलिए $\zeta(s) = 0$ होता है। इन्हें तुच्छ शून्य (Trivial zeros) कहा जाता है।

हालाँकि, अभाज्य संख्याओं के वितरण में जो महत्वपूर्ण है वह अन्य शून्य हैं, अर्थात् गैर-तुच्छ शून्य (Non-trivial zeros) जो $0 \le \sigma \le 1$ के “महत्वपूर्ण क्षेत्र (Critical strip)” में मौजूद हैं।

5. रीमैन परिकल्पना का मूल और स्पष्ट सूत्र

रीमैन ने कुछ शून्यों की गणना की और एक आश्चर्यजनक परिकल्पना प्रस्तुत की। यह रीमैन परिकल्पना है।

रीमैन परिकल्पना (Riemann Hypothesis) रीमैन ज़ेटा फ़ंक्शन $\zeta(s)$ के सभी गैर-तुच्छ शून्य उस रेखा पर स्थित होते हैं जिसका वास्तविक भाग $1/2$ है ($\text{Re}(s) = 1/2$)।

इस वास्तविक भाग $1/2$ वाली रेखा को “महत्वपूर्ण रेखा (Critical line)” कहा जाता है।

graph TD A["रीमैन ज़ेटा फ़ंक्शन ζ(s)"] --> B["विश्लेषणात्मक निरंतरता द्वारा सम्मिश्र तल में विस्तार"] B --> C["तुच्छ शून्य (s = -2, -4, -6 ...)"] B --> D["गैर-तुच्छ शून्य (0 <= Re(s) <= 1)"] D --> E["रीमैन परिकल्पना"] E --> F["सभी गैर-तुच्छ शून्य Re(s) = 1/2 पर स्थित हैं"] F --> G["अभाज्य वितरण की त्रुटि अवधि की सीमा के प्रमाण की ओर"]

रीमैन परिकल्पना इतनी महत्वपूर्ण क्यों है? ऐसा इसलिए है क्योंकि ज़ेटा फ़ंक्शन के शून्य अभाज्य संख्याओं के वितरण को पूरी तरह से निर्धारित करते हैं।

रीमैन और बाद के गणितज्ञ वॉन मैंगोल्ड्ट ने अभाज्य संख्याओं के वितरण का सटीक वर्णन करने के लिए एक “स्पष्ट सूत्र (Explicit formula)” प्राप्त किया। चेबीशेव फ़ंक्शन $\psi(x)$ का उपयोग करते हुए, इसे इस प्रकार व्यक्त किया जाता है:

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

यहाँ $\rho$ ज़ेटा फ़ंक्शन के सभी गैर-तुच्छ शून्यों पर योग है। मुख्य पद $x$ है (जो अभाज्य संख्या प्रमेय से मेल खाता है), और वहां से, शून्य $\rho$ पर निर्भर तरंग जैसे पदों को जोड़ने और घटाने से, अभाज्य संख्याओं का सटीक सीढ़ी जैसा वितरण बहाल हो जाता है। यह कहा जा सकता है कि गैर-तुच्छ शून्य अभाज्य संख्याओं के वितरण की “आवृत्ति (तरंग)” का प्रतिनिधित्व करते हैं।

यदि रीमैन परिकल्पना सही है और सभी गैर-तुच्छ शून्यों $\rho$ का वास्तविक भाग ठीक $1/2$ है, तो अभाज्य संख्या प्रमेय का त्रुटि पद सैद्धांतिक रूप से संभव न्यूनतम सीमा के भीतर होगा।

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

दूसरे शब्दों में, यदि रीमैन परिकल्पना सत्य है, तो यह सिद्ध हो जाएगा कि अभाज्य संख्याएँ सबसे “नियमित और सुंदर” तरीके से वितरित हैं जिसकी हम कल्पना कर सकते हैं।

6. आधुनिक क्रिप्टोग्राफी और अभाज्य संख्याओं के बीच अविभाज्य संबंध

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

इंटरनेट पर क्रेडिट कार्ड भुगतान, पासवर्ड का प्रसारण और ब्लॉकचेन के डिजिटल हस्ताक्षर जैसे सभी संचारों की सुरक्षा “अभाज्य संख्याओं” पर निर्भर करती है।

RSA क्रिप्टोग्राफी कैसे काम करती है

RSA क्रिप्टोग्राफी की सुरक्षा इस गणितीय तथ्य (पूर्णांक गुणनखंड समस्या) पर आधारित है कि “कई अंकों वाली एक समग्र संख्या का गुणनखंड करना बेहद मुश्किल है।”

कुंजी निर्माण: विशाल अभाज्य संख्याएँ $p$ और $q$ (उदाहरण के लिए, प्रत्येक 2048 बिट) यादृच्छिक रूप से चुनी जाती हैं। उन्हें गुणा करके $N = p \times q$ की गणना की जाती है। यह $N$ सार्वजनिक कुंजी का हिस्सा बन जाता है। यूलर के टॉटिएंट फ़ंक्शन $\phi(N) = (p-1)(q-1)$ का उपयोग करके, एक गुप्त कुंजी $d$ उत्पन्न की जाती है।
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
एन्क्रिप्शन और डिक्रिप्शन: सादा पाठ $M$ को सार्वजनिक कुंजी $e, N$ का उपयोग करके सिफरटेक्स्ट $C$ में परिवर्तित किया जाता है।
$$ C \equiv M^e \pmod{N} $$
केवल गुप्त कुंजी $d$ वाला व्यक्ति ही इसे डिक्रिप्ट कर सकता है।
$$ M \equiv C^d \pmod{N} $$

graph LR A["सादा पाठ (Plaintext)"] --> B["सार्वजनिक कुंजी (e, N) के साथ एन्क्रिप्ट करें"] B --> C["सिफरटेक्स्ट (Ciphertext)"] C --> D["गुप्त कुंजी (d) के साथ डिक्रिप्ट करें"] D --> E["मूल सादा पाठ"] F["हमलावर (Attacker)"] -- "N का गुणनखंड करने का प्रयास करता है" --> C F -.-> G["p और q के बिना d की गणना नहीं की जा सकती"]

RSA क्रिप्टोग्राफी को तोड़ने के लिए, विशाल $N$ से मूल अभाज्य संख्याओं $p$ और $q$ को खोजना (गुणनखंड करना) आवश्यक है। यहां तक कि वर्तमान मुख्यधारा के एल्गोरिदम (जैसे जनरल नंबर फील्ड सीव: GNFS) का उपयोग करके, सुपर कंप्यूटर का उपयोग करके सैकड़ों अंकों की संख्या का गुणनखंड करने में ब्रह्मांड की आयु से बहुत अधिक समय लगने की उम्मीद है।

7. क्रिप्टोग्राफी पर रीमैन परिकल्पना का प्रभाव

तो, “रीमैन परिकल्पना” (शुद्ध गणित का शिखर) और “क्रिप्टोग्राफी” एक दूसरे को कैसे पार करते हैं?

7.1. अभाज्य संख्या जनरेशन एल्गोरिदम (प्राइमलिटी टेस्टिंग) और जनरलाइज्ड रीमैन परिकल्पना (GRH)

RSA क्रिप्टोग्राफी को संचालित करने के लिए, पहले विशाल अभाज्य संख्याएँ $p$ और $q$ उत्पन्न करनी होंगी। हालाँकि, यह निश्चित रूप से और तेज़ी से निर्धारित करना आसान नहीं है कि “क्या कोई संख्या अभाज्य है।”

वर्तमान में, व्यावहारिक उपयोग में आने वाला मिलर-राबिन प्राइमलिटी टेस्ट (Miller-Rabin primality test) एक संभाव्य एल्गोरिथ्म है। यह एल्गोरिथ्म तेज़ है, लेकिन एक “छद्म-अभाज्य” जोखिम है जहाँ यह एक समग्र संख्या को बहुत कम संभावना के साथ अभाज्य संख्या के रूप में गलत रूप से आंक सकता है।

हालाँकि, यदि हम मान लें कि डिरिचलेट के L-फ़ंक्शंस तक रीमैन परिकल्पना का विस्तार “जनरलाइज्ड रीमैन परिकल्पना (Generalized Riemann Hypothesis, GRH)” सत्य है, तो कहानी नाटकीय रूप से बदल जाती है। यदि GRH सत्य है, तो मिलर-राबिन परीक्षण में परीक्षणों की अधिकतम संख्या की गणितीय रूप से गारंटी होती है, और यह एक संभाव्य एल्गोरिथ्म से “नियतात्मक बहुपद-समय एल्गोरिथ्म” में परिवर्तित हो जाता है (यह AKS प्राइमलिटी परीक्षण की खोज से पहले भी ज्ञात एक महत्वपूर्ण तथ्य था)।

दूसरे शब्दों में, रीमैन परिकल्पना (और इसका विस्तार) सीधे तौर पर इस बात की गारंटी देता है कि “क्या हम पूर्ण विश्वास के साथ और उच्च गति पर विशाल अभाज्य संख्याएँ उत्पन्न कर सकते हैं”, जो क्रिप्टोग्राफी की नींव उत्पन्न करने के लिए आवश्यक है।

7.2. गुणनखंड एल्गोरिदम के साथ संबंध

क्रिप्टोग्राफी को क्रैक करने वाले एल्गोरिदम (जैसे कि जनरल नंबर फील्ड सीव) की कम्प्यूटेशनल जटिलता का मूल्यांकन करते समय, अभाज्य संख्याओं के वितरण का ज्ञान अपरिहार्य है। कई गुणनखंड एल्गोरिदम “सहज संख्याओं (Smooth numbers: वे संख्याएँ जिनमें केवल छोटे अभाज्य गुणनखंड होते हैं)” के वितरण पर निर्भर करते हैं।

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

8. यदि रीमैन परिकल्पना सिद्ध हो जाए, तो क्या क्रिप्टोग्राफी टूट जाएगी?

एक शहरी किंवदंती की तरह, यह कभी-कभी कहा जाता है कि “यदि रीमैन परिकल्पना हल हो जाती है, तो RSA क्रिप्टोग्राफी तुरंत ढह जाएगी”, लेकिन यह गणितीय रूप से गलत है।

रीमैन परिकल्पना का प्रमाण अपने आप में कोई जादुई एल्गोरिथ्म नहीं बना देगा जो तुरंत गुणनखंड को नाटकीय रूप से तेज कर दे। ऐसा इसलिए है क्योंकि रीमैन परिकल्पना केवल अभाज्य संख्याओं के “स्थूल वितरण की नियमितता” के बारे में एक प्रमेय है, और यह हमें सीधे यह नहीं बताती है कि एक व्यक्तिगत संख्या $N$ को किस अभाज्य संख्या से विभाजित किया जा सकता है (स्थानीय गुण)।

हालाँकि, इसका प्रभाव शून्य नहीं है। ऐसा इसलिए है क्योंकि यह अत्यधिक संभव है कि रीमैन परिकल्पना को सिद्ध करने की प्रक्रिया में “नए गणितीय उपकरण” और “अज्ञात विश्लेषणात्मक तरीके” खोजे जाएंगे। इतिहास को देखते हुए, जब फर्मेट का अंतिम प्रमेय और पोइंकारे अनुमान सिद्ध हुए थे, तो इस प्रक्रिया में विकसित नए सिद्धांतों ने पूरे गणित को एक बड़ी छलांग दी थी।

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

क्वांटम कंप्यूटर और शोर का एल्गोरिथ्म

क्रिप्टोग्राफी के लिए एक अधिक प्रत्यक्ष और यथार्थवादी खतरा रीमैन परिकल्पना का प्रमाण नहीं है बल्कि क्वांटम कंप्यूटर है। 1994 में पीटर शोर (Peter Shor) द्वारा प्रकाशित “शोर का एल्गोरिथ्म” ने साबित कर दिया कि यदि पर्याप्त प्रदर्शन वाला क्वांटम कंप्यूटर है, तो गुणनखंडन को बहुपद समय में हल किया जा सकता है। इससे RSA क्रिप्टोग्राफी और एलिप्टिक कर्व क्रिप्टोग्राफी मौलिक रूप से टूट जाएगी।

वर्तमान में, दुनिया भर में “पोस्ट-क्वांटम क्रिप्टोग्राफी (Post-Quantum Cryptography, PQC)” (जैसे लैटिस-आधारित क्रिप्टोग्राफी) का संक्रमण चल रहा है जिसे क्वांटम कंप्यूटर भी डिक्रिप्ट नहीं कर सकते हैं। अभाज्य संख्याओं पर निर्भर क्रिप्टोग्राफ़िक तकनीकें एक मायने में अपने स्वर्ण युग को समाप्त कर रही हैं, लेकिन स्वयं अभाज्य संख्याओं का गणितीय मूल्य कभी नष्ट नहीं होगा।

9. निष्कर्ष: गणित के अमूर्तीकरण और वास्तविक समाज का चौराहा

graph TD A["शुद्ध गणित की खोज"] --> B["रीमैन परिकल्पना का स्पष्टीकरण"] B --> C["अभाज्य वितरण की पूर्ण समझ"] C --> D["संख्या सिद्धांत और बीजीय ज्यामिति में तेजी से विकास"] D -.-> E["नए गुणनखंडन एल्गोरिदम की संभावना"] E -.-> F["क्रिप्टोग्राफी के सुरक्षा मूल्यांकन का अद्यतन"] A --> G["अनुप्रयुक्त गणित और कंप्यूटर विज्ञान"] G --> H["प्राइमलिटी टेस्टिंग और कुंजी जनरेशन की दक्षता"] H --> F

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

रीमैन परिकल्पना एक ही समय में गणित की “अमूर्त सुंदरता” और “भौतिक दुनिया और वास्तविक समाज के लिए इसकी आश्चर्यजनक प्रयोज्यता” का प्रतीक है।

जब गणित के इस विशाल पर्वत पर अंततः विजय प्राप्त कर ली जाएगी, जिस पर अभी तक कोई नहीं पहुंच पाया है, तो हम अभाज्य संख्याओं की लौकिक सच्चाई को पूरी तरह से समझ लेंगे, और साथ ही सूचना समाज की नींव पर एक नया दृष्टिकोण प्राप्त करेंगे। क्रिप्टोग्राफी सीखना स्वयं मानवता के ज्ञान के इतिहास का पता लगाने की यात्रा है।

C++ में लागू तेज़ अभाज्य संख्या परीक्षण एल्गोरिदम (मिलर-राबिन आदि)

Fri, 11 Sep 2026 14:00:00 +0900

परिचय: हमें तेज़ अभाज्य संख्या परीक्षण की आवश्यकता क्यों है?

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

इसके अलावा, प्रतिस्पर्धात्मक प्रोग्रामिंग (जैसे AtCoder और Codeforces) में अभाज्य संख्या परीक्षण एक लगातार आने वाला विषय है। ऐसे परिदृश्यों में जहाँ आपको 1 सेकंड के भीतर $N \le 10^{18}$ जैसे विशाल इनपुट बाधाओं के लिए हज़ारों बार अभाज्य परीक्षण करने होते हैं, पारंपरिक और सरल एल्गोरिदम पूरी तरह से विफल हो जाएंगे और समय सीमा पार (Time Limit Exceeded: TLE) हो जाएगी।

इस लेख में, हम एक सरल अभाज्य परीक्षण एल्गोरिदम से शुरुआत करेंगे, संभाव्य अभाज्य परीक्षण पद्धति “फर्मेंट टेस्ट (Fermat Primality Test)” पर जाएंगे, और फिर “मिलर-राबिन (Miller-Rabin) अभाज्य परीक्षण पद्धति” को कवर करेंगे, जो एक व्यावहारिक रूप से शक्तिशाली और तेज़ एल्गोरिदम है जिसने फर्मेंट टेस्ट की कमजोरियों को दूर किया है। हम गणितीय पृष्ठभूमि से लेकर C++ में अत्यधिक अनुकूलित कार्यान्वयन तक सब कुछ विस्तार से समझाएंगे। विशेष रूप से, 64-बिट पूर्णांकों ($N < 2^{64}$) के लिए, हम न केवल संभाव्य परीक्षण की व्याख्या करेंगे, बल्कि एक “नियतात्मक परीक्षण (Deterministic Test)” की भी व्याख्या करेंगे जो 100% निश्चितता के साथ अभाज्य परीक्षण कर सकता है, और अभ्यास में उपयोग के लिए तैयार C++ सोर्स कोड प्रदान करेंगे।

1. अभाज्य परीक्षण की मूल बातें और परीक्षण विभाजन विधि (Trial Division)

अभाज्य संख्या (Prime number) 2 या उससे बड़ी वह प्राकृत संख्या है जिसके 1 और स्वयं के अलावा कोई धनात्मक भाजक नहीं होते हैं। अभाज्य संख्या की परिभाषा का कड़ाई से पालन करते हुए, यह निर्धारित करने के लिए कि कोई पूर्णांक $N$ अभाज्य है या नहीं, हम $N$ को $2$ से $N-1$ तक के सभी पूर्णांकों से विभाजित करने का प्रयास कर सकते हैं। यदि यह किसी से भी विभाज्य नहीं है, तो यह एक अभाज्य संख्या है; यदि यह एक बार भी विभाज्य हो जाता है, तो इसे एक भाज्य संख्या (अभाज्य नहीं) माना जा सकता है।

हालाँकि, इस पद्धति की समय जटिलता $O(N)$ है, और जब $N$ $10^{18}$ जैसी विशाल संख्या होती है, तो आधुनिक कंप्यूटरों को भी इसकी गणना करने में बहुत अधिक समय लगेगा।

परीक्षण विभाजन का अनुकूलन: $\sqrt{N}$ तक खोजना

जब एक भाज्य संख्या $N$ को $a \times b = N$ ($a \le b$) के रूप में व्यक्त किया जाता है, तो यह हमेशा सत्य होता है कि $a \le \sqrt{N}$। इसलिए, अभाज्य परीक्षण लूप को $N-1$ तक चलाने की कोई आवश्यकता नहीं है; $\sqrt{N}$ तक जाँचना पर्याप्त है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>

// परीक्षण विभाजन विधि द्वारा अभाज्य परीक्षण (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // केवल 3 या उससे बड़ी विषम संख्याओं की जाँच करें
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

इस एल्गोरिदम की समय जटिलता $O(\sqrt{N})$ है। यदि $N \le 10^{12}$ है, तो इसकी गणना तुरंत की जा सकती है। हालाँकि, जब $N \approx 10^{18}$ होता है, तो लूप पुनरावृत्तियों की संख्या लगभग $10^9$ हो जाती है। यहाँ तक कि C++ के साथ भी, इसमें सैकड़ों मिलीसेकंड से लेकर कुछ सेकंड तक का समय लगता है, जो इसे कई परीक्षणों के लिए अनुपयुक्त बनाता है।

2. फर्मेंट टेस्ट: संभाव्य अभाज्य परीक्षण की शुरुआत

परीक्षण विभाजन विधि की सीमाओं को पार करने के लिए, संख्या सिद्धांत के प्रमेयों का उपयोग करके “संभाव्य एल्गोरिदम (Probabilistic Algorithm)” तैयार किए गए थे। इसका एक प्रमुख उदाहरण “फर्मेंट टेस्ट (Fermat Primality Test)” है, जो फर्मेंट के छोटे प्रमेय (Fermat’s Little Theorem) का उपयोग करता है।

फर्मेंट का छोटा प्रमेय (Fermat’s Little Theorem)

पियरे डी फर्मेंट (Pierre de Fermat) द्वारा खोजा गया यह प्रमेय निम्नलिखित बताता है:

किसी भी अभाज्य संख्या $p$ और किसी भी पूर्णांक $a$ जो कि $p$ का गुणज नहीं है (अर्थात् $a$ और $p$ सह-अभाज्य हैं), के लिए निम्नलिखित सर्वांगसमता (congruence) लागू होती है:
$$ a^{p-1} \equiv 1 \pmod p $$

इस प्रमेय का प्रतिधनात्मक (contrapositive) लेने पर, हम कह सकते हैं कि “यदि कोई पूर्णांक $N$ और एक पूर्णांक $a$ जो $N$ के साथ सह-अभाज्य है, ऐसा है कि $a^{N-1} \not\equiv 1 \pmod N$, तो $N$ निश्चित रूप से एक भाज्य संख्या है।” इस गुण का उपयोग करते हुए, फर्मेंट टेस्ट परीक्षण की जाने वाली संख्या $N$ के लिए एक यादृच्छिक आधार (base) $a$ चुनता है, $a^{N-1} \pmod N$ की गणना करता है, और जाँचता है कि क्या यह $1$ के बराबर है।

तेज़ मॉड्यूलर एक्सपोनेंशिएशन (बाइनरी एक्सपोनेंशिएशन)

फर्मेंट टेस्ट करने के लिए, हमें $a^{N-1} \pmod N$ की विशाल घात की तेज़ी से गणना करने की आवश्यकता है। इसके लिए, हम “बाइनरी एक्सपोनेंशिएशन (Modular Exponentiation / Binary Exponentiation)” का उपयोग करते हैं। इसकी समय जटिलता $O(\log N)$ है, जो बहुत तेज़ है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// बाइनरी एक्सपोनेंशिएशन का उपयोग करके a^b mod m की गणना
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

※ यहाँ, अतिप्रवाह (overflow) को रोकने के लिए, हम मध्यवर्ती गुणनफलों को बनाए रखने के लिए GCC/Clang एक्सटेंशन __int128_t (128-बिट पूर्णांक) का उपयोग करते हैं।

छद्म अभाज्य (Pseudoprimes) और कार्माइकल संख्याएँ (Carmichael Numbers)

फर्मेंट टेस्ट बहुत शक्तिशाली है, लेकिन इसकी एक बड़ी कमजोरी है। ऐसी संख्याएँ मौजूद हैं जहाँ $N$ एक भाज्य संख्या है, फिर भी सभी $a$ ($N$ के साथ सह-अभाज्य) के लिए $a^{N-1} \equiv 1 \pmod N$ सत्य होता है।

ऐसी संख्याओं को “निरपेक्ष छद्म अभाज्य (Absolute Pseudoprimes)” या “कार्माइकल संख्याएँ (Carmichael Numbers)” कहा जाता है। सबसे छोटी कार्माइकल संख्या $561 = 3 \times 11 \times 17$ है। कार्माइकल संख्याओं के अस्तित्व के कारण, अकेले फर्मेंट टेस्ट “100% संभाव्यता” के साथ नियतात्मक परीक्षण नहीं कर सकता है। आप कितने भी अलग-अलग $a$ आज़मा लें, $561$ जैसी संख्या हमेशा अभाज्य संख्या होने का नाटक करके आपको धोखा देगी।

3. मिलर-राबिन अभाज्य परीक्षण (Miller-Rabin Primality Test)

“मिलर-राबिन अभाज्य परीक्षण”, जिसे गैरी एल. मिलर (Gary L. Miller) और माइकल ओ. राबिन (Michael O. Rabin) द्वारा तैयार किया गया था, फर्मेंट टेस्ट की कमजोरी (कार्माइकल संख्याओं का अस्तित्व) को शानदार ढंग से पार करता है। वर्तमान में, यह विभिन्न प्रोग्रामिंग भाषाओं की आंतरिक लाइब्रेरीज़ और क्रिप्टोग्राफ़िक प्रणालियों में कुंजी निर्माण के लिए एक व्यावहारिक, तेज़ अभाज्य परीक्षण एल्गोरिदम के रूप में सबसे व्यापक रूप से उपयोग किया जाता है।

गणितीय सिद्धांत

मिलर-राबिन एल्गोरिदम फर्मेंट के छोटे प्रमेय का उपयोग करता है, साथ ही इस गुण का भी कि “एक अभाज्य संख्या पर आधारित परिमित क्षेत्र ($\mathbb{Z}/p\mathbb{Z}$) में, $x^2 \equiv 1 \pmod p$ के समाधान केवल $x \equiv 1$ या $x \equiv -1$ तक ही सीमित हैं” (जब मापांक एक भाज्य संख्या है, तो अन्य गैर-तुच्छ वर्गमूल मौजूद हो सकते हैं)।

जिस विषम संख्या $N$ का हम परीक्षण करना चाहते हैं, उसमें से $1$ घटाने पर $N-1$ हमेशा एक सम संख्या होगी। इसलिए, हम $N-1$ को $2$ से तब तक विभाजित करते हैं जब तक संभव हो, और इसे निम्न रूप में व्यक्त करते हैं:

$$ N-1 = d \cdot 2^s $$

(जहाँ $d$ एक विषम संख्या है, और $s \ge 1$)

किसी भी आधार $a$ ($1 < a < N-1$) के लिए, हम फर्मेंट के छोटे प्रमेय के अनुसार जाँचते हैं कि क्या $a^{N-1} \equiv 1 \pmod N$ है, लेकिन हम इस गणना को चरणों में करते हैं। विशेष रूप से, हम बार-बार वर्ग करते हैं: $a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$ क्रम में।

मिलर-राबिन परीक्षण $N$ को “एक अभाज्य” (या “प्रबल संभावना के साथ एक अभाज्य”) मानता है यदि निम्न स्थितियों में से कोई भी सत्य है:

$a^d \equiv 1 \pmod N$
एक ऐसा $r$ ($0 \le r < s$) मौजूद है जिसके लिए $a^{d \cdot 2^r} \equiv -1 \pmod N$ लागू होता है। ※ C++ में मॉड्यूलर अंकगणित में, $-1 \pmod N$, $N-1$ के बराबर होता है।

यदि $N$ एक अभाज्य संख्या है, तो यह स्थिति निश्चित रूप से किसी भी $a$ के लिए पूरी होगी। इसके विपरीत, यदि $N$ एक भाज्य संख्या है, तो गणितीय रूप से यह सिद्ध हो चुका है कि जब यादृच्छिक रूप से $a$ चुना जाता है, तो इस स्थिति के पूरा होने (धोखा खाने) की संभावना $\frac{1}{4}$ या उससे कम होती है। यदि आप $k$ स्वतंत्र परीक्षण करते हैं, तो गलत सकारात्मक (false positive) की संभावना $\left(\frac{1}{4}\right)^k$ या उससे कम हो जाती है, जिसे व्यावहारिक रूप से शून्य माना जा सकता है। कार्माइकल संख्याओं जैसी कोई “ऐसी संख्याएँ नहीं हैं जो हमेशा धोखा दे सकें”।

मिलर-राबिन एल्गोरिदम का प्रवाह (मर्मेड फ़्लोचार्ट)

नीचे दिया गया आरेख मिलर-राबिन अभाज्य परीक्षण में एक एकल परीक्षण (एक आधार $a$ के लिए परीक्षण) के तार्किक प्रवाह को दर्शाता है।

graph TD Start["परीक्षण प्रारंभ (इनपुट: N, a)"] --> CalcDS["d (विषम) और s की गणना करें ताकि N-1 = d * 2^s हो"] CalcDS --> CalcX["x = a^d mod N की गणना करें"] CalcX --> CheckX1{"क्या x == 1 या x == N-1 ?"} CheckX1 -- "हाँ" --> ReturnTrue["संभवतः अभाज्य (Probably Prime)"] CheckX1 -- "नहीं" --> LoopStart["r = 1 से s-1 तक लूप प्रारंभ करें"] LoopStart --> LoopCondition{"क्या r < s ?"} LoopCondition -- "नहीं" --> ReturnFalse["निश्चित रूप से भाज्य (Composite)"] LoopCondition -- "हाँ" --> SquareX["x = (x * x) mod N की गणना करें"] SquareX --> CheckXMinus1{"क्या x == N - 1 ?"} CheckXMinus1 -- "हाँ" --> ReturnTrue CheckXMinus1 -- "नहीं" --> CheckXOne{"क्या x == 1 ?"} CheckXOne -- "हाँ" --> ReturnFalse CheckXOne -- "नहीं" --> LoopNext["r को 1 बढ़ाएं और आगे बढ़ें"] LoopNext --> LoopCondition

4. 64-बिट पूर्णांकों के लिए नियतात्मक परीक्षण (Deterministic Testing)

मिलर-राबिन अभाज्य परीक्षण मूल रूप से एक “संभाव्य” एल्गोरिदम है, लेकिन यदि $N$ की ऊपरी सीमा तय है, तो आप विशिष्ट $a$ (आधार) के सेट का परीक्षण करके “100% निश्चितता” के साथ अभाज्य परीक्षण कर सकते हैं। इसे नियतात्मक मिलर-राबिन परीक्षण (Deterministic Miller-Rabin Test) कहा जाता है।

जिम सिंक्लेयर (Jim Sinclair) और अन्य लोगों के शोध से पता चला है कि $N < 2^{64}$ (लगभग $1.8 \times 10^{19}$) के सभी पूर्णांकों के लिए, आधार $a$ के रूप में निम्नलिखित $7$ अभाज्य संख्याओं का परीक्षण करना एक पूर्ण और पूरी तरह से नियतात्मक निर्णय लेने के लिए पर्याप्त है।

परीक्षण किए जाने वाले आधार $a$ की सूची: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

वैकल्पिक रूप से, एक अन्य प्रसिद्ध सेट के रूप में, निम्नलिखित $12$ अभाज्य संख्याओं का उपयोग करना भी $N < 2^{64}$ से नीचे के परीक्षणों के लिए पूरी तरह से काम करता है। {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

इस बार, एल्गोरिदम की सादगी और विश्वसनीयता में सुधार करने के लिए, हम एक ऐसा दृष्टिकोण अपनाएंगे जो आधार के रूप में बाद की $12$ अभाज्य संख्याओं (या अधिक अनुकूलित $7$ आधारों) का उपयोग करता है। C++ कार्यान्वयन में, हम सशर्त शाखाओं के साथ श्रेणियों को विभाजित करके परीक्षणों की संख्या को कम करने के लिए इसे अनुकूलित करेंगे।

5. C++ के साथ अत्यधिक अनुकूलित कार्यान्वयन (Highly Optimized C++ Implementation)

अब, चलिए अब तक के गणितीय सिद्धांत और एल्गोरिदम डिज़ाइन को संकलित करते हैं, और आधुनिक C++ में उच्चतम स्तर के मिलर-राबिन अभाज्य परीक्षण फ़ंक्शन के कार्यान्वयन कोड को प्रस्तुत करते हैं।

कार्यान्वयन के मुख्य बिंदु

64-बिट पूर्णांक गुणन में अतिप्रवाह से बचना: जब $N \approx 10^{18}$, मॉड्यूलर गुणन में $x \times x$ अधिकतम $10^{36}$ तक पहुँच सकता है, जो सामान्य 64-बिट पूर्णांकों (uint64_t या long long) के अधिकतम मान $1.8 \times 10^{19}$ को आसानी से पार कर जाएगा। इस समस्या को हल करने के लिए, हम GCC और Clang एक्सटेंशन प्रकार __int128_t (या unsigned __int128) का उपयोग करते हैं ताकि 128-बिट सटीकता के साथ गणना की जा सके और फिर मॉड्यूलो लिया जा सके। यह बिना जटिल एल्गोरिदम के तेज़ मॉड्यूलर गुणन को संभव बनाता है।
नियतात्मक आधारों का चयन: जब $N$ का मान छोटा होता है, तो हम इसे अनुकूलित करते हैं ताकि हमें केवल कुछ आधारों का परीक्षण करना पड़े।

संपूर्ण C++ सोर्स कोड

नीचे उत्पादन के लिए तैयार संपूर्ण सोर्स कोड दिया गया है। आप इस कोड को सीधे कॉपी करके प्रतिस्पर्धात्मक प्रोग्रामिंग जैसे वातावरण में उपयोग कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


#include <iostream>
#include <vector>
#include <cstdint>
#include <initializer_list>

using namespace std;

// 128-बिट पूर्णांक का उपयोग करके तेज़ (a * b) mod m
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// बाइनरी एक्सपोनेंशिएशन द्वारा (base^exp) mod m की गणना
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// मिलर-राबिन अभाज्य परीक्षण द्वारा 64-बिट पूर्णांकों का नियतात्मक परीक्षण
bool is_prime_miller_rabin(uint64_t n) {
 // सीमा मानों और छोटी अभाज्य संख्याओं की पूर्व-जाँच
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // n-1 को d * 2^s के रूप में विघटित करें
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // परीक्षण के लिए उपयोग किए जाने वाले आधारों (bases) की सूची
 // N के आकार के अनुसार परीक्षण किए जाने वाले आधारों की संख्या को कम करने के लिए अनुकूलन
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // N < 2^64 की सभी संख्याओं के लिए नियतात्मक होने वाले 7 आधार
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // प्रत्येक आधार के लिए परीक्षण चलाएँ
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // यदि a, n का गुणज है, तो परीक्षण अनिश्चित है, लेकिन यह अभाज्य नहीं है

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // पहली शर्त पूरी हो गई, अगले आधार पर जाएँ

 bool composite = true;
 // s-1 बार लूप करें (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // दूसरी शर्त पूरी हो गई, अभाज्य होने की संभावना है
 break;
 }
 }

 // यदि कोई भी शर्त पूरी नहीं होती है, तो यह निश्चित रूप से भाज्य है
 if (composite) return false;
 }

 // यदि सभी आधारों के लिए शर्तें पूरी हो जाती हैं, तो यह निश्चित रूप से अभाज्य है
 return true;
}

int main() {
 // परीक्षण के लिए नमूने
 vector<uint64_t> test_cases = {
 1000000007, // प्रसिद्ध अभाज्य संख्या
 998244353, // प्रसिद्ध अभाज्य संख्या
 1000000000000000003, // 10^18 के आसपास अभाज्य संख्या
 1000000000000000007, // भाज्य संख्या (10^18 + 7)
 561, // कार्माइकल संख्या (भाज्य)
 18446744073709551557ULL // 2^64 के आसपास की सबसे बड़ी अभाज्य संख्याओं में से एक
 };

 for (uint64_t n : test_cases) {
 cout << n << " is "
 << (is_prime_miller_rabin(n) ? "Prime" : "Composite")
 << endl;
 }

 return 0;
}

6. एल्गोरिदम समय जटिलता और प्रदर्शन मूल्यांकन

आइए हमारे द्वारा कार्यान्वित किए गए एल्गोरिदम के प्रदर्शन पर विचार करें।

समय जटिलता (Time Complexity)

परीक्षण विभाजन विधि: $O(\sqrt{N})$
फर्मेंट टेस्ट: घातांक की गणना $O(\log N) \times k$ ($k$ परीक्षणों की संख्या है)
मिलर-राबिन विधि: घातांक और लूप की गणना $O(\log N) \times k$

64-बिट वातावरण ($N \le 2^{64}$) में, ऊपर दी गई नियतात्मक मिलर-राबिन विधि अधिकतम केवल $7$ आधारों की पुष्टि करती है। इसलिए, $k \le 7$ को एक स्थिरांक माना जा सकता है, और समग्र समय जटिलता सख्ती से $O(\log N)$ बन जाती है। यहाँ तक कि अधिकतम मामले ($N \approx 10^{19}$) में भी, निष्पादन के चरणों की संख्या अधिकतम $7 \times 64 = 448$ बुनियादी परिचालनों के भीतर रहती है, और निष्पादन का समय कुछ माइक्रोसेकंड ($10^{-6}$ सेकंड) या उससे कम है। परीक्षण विभाजन विधि की $O(\sqrt{N})$ (लूप पुनरावृत्तियाँ $\approx 4 \times 10^9$ बार) की तुलना में, लाखों गुना की गति में वृद्धि प्राप्त की गई है।

आगे का अनुकूलन: मोंटगोमरी गुणन (Montgomery Multiplication)

इस लेख के कार्यान्वयन में, हम विभाजन (मॉड्यूलो ऑपरेशन %) करने के लिए 128-बिट पूर्णांक एक्सटेंशन प्रकार __int128_t का उपयोग कर रहे हैं। यहाँ तक कि आधुनिक CPU में भी, पूर्णांक विभाजन (DIV निर्देश) एक महँगा निर्देश है जिसमें जोड़ या गुणा की तुलना में दर्जनों चक्र लगते हैं।

लाइब्रेरी निर्माता और प्रतिस्पर्धी प्रोग्रामर जो और भी अधिक चरम अनुकूलन चाहते हैं, वे कभी-कभी मोंटगोमरी गुणन (Montgomery Multiplication) नामक एक तकनीक अपनाते हैं। मोंटगोमरी गुणन एक अद्भुत एल्गोरिदम है जो संख्याओं को एक विशेष “मोंटगोमरी स्पेस” में मैप करके महँगे मॉड्यूलर ऑपरेशन्स (विभाजन) को “केवल बिट शिफ्ट्स और गुणन” से बदल देता है। इसे मिलर-राबिन परीक्षण के मॉड्यूलर गुणन में शामिल करके, निष्पादन की गति को 2 से 3 गुना और बढ़ाया जा सकता है। चूँकि यह बहुत ही गहरा विषय है, मैं इसे किसी अन्य लेख में विस्तार से समझाना चाहूँगा।

7. निष्कर्ष

इस लेख में, हमने एक ही बार में अभाज्य परीक्षण की मूल बातों से लेकर उन्नत विषयों तक सब कुछ समझाया है। आइए मुख्य बिंदुओं को दोहराते हैं:

परीक्षण विभाजन विधि (Trial Division) निश्चित है, लेकिन इसकी समय जटिलता $O(\sqrt{N})$ है, जो $N$ के $10^{12}$ से अधिक होने पर इसे अव्यावहारिक बना देती है।
फर्मेंट टेस्ट बहुत तेज़ है, $O(\log N)$, लेकिन इसकी एक बड़ी कमजोरी है कि यह कार्माइकल संख्याओं जैसे निरपेक्ष छद्म अभाज्यों से धोखा खा जाता है।
मिलर-राबिन अभाज्य परीक्षण एक व्यावहारिक और बहुत शक्तिशाली एल्गोरिदम है जो फर्मेंट टेस्ट की कमजोरी को दूर करता है।
C++ कार्यान्वयन में, __int128_t का उपयोग 64-बिट पूर्णांक गुणन अतिप्रवाह को सुरक्षित रूप से संभालने की अनुमति देता है।
64-बिट पूर्णांक सीमा ($N < 2^{64}$) के भीतर, आधार के रूप में $7$ या $12$ विशिष्ट अभाज्य संख्याओं का चयन करके, संभाव्य के बजाय नियतात्मक रूप से (100% सटीक) अभाज्य परीक्षण करना संभव है।

बड़ी संख्याओं से जुड़ी गणनाओं में तेज़ अभाज्य परीक्षण एक अपरिहार्य तकनीक है। इस लेख में दिया गया C++ मिलर-राबिन सोर्स कोड मज़बूत है और इसे अभ्यास में उसी तरह उपयोग किया जा सकता है। कृपया बेझिझक इसे अपनी स्वयं की परियोजनाओं या एल्गोरिदम प्रतियोगिताओं में उपयोग करें।

graph LR TrialDivision["परीक्षण विभाजन विधि (O(√N))"] --> Fermat["फर्मेंट टेस्ट (O(log N), कमजोरियाँ हैं)"] Fermat --> MillerRabin["मिलर-राबिन विधि (O(log N), नियतात्मक बनाया जा सकता है)"] MillerRabin --> Montgomery["+ मोंटगोमरी गुणन (स्थिरांक-गुणक गति वृद्धि)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

एल्गोरिदम की दुनिया, जहाँ प्रोग्रामिंग और गणित प्रतिच्छेद करते हैं, बहुत सुंदर और गहरी है। मुझे आशा है कि यह लेख आपके भविष्य के अध्ययन में मदद करेगा।

Reference:

Pomerance, C., Selfridge, J. L., & Wagstaff, S. S. (1980). The pseudoprimes to 25.10^9. Mathematics of Computation.
Sinclair, J. (2011). Deterministic Miller-Rabin primality testing.

【गणित व्याख्या】 हाई स्कूल के छात्रों के लिए RSA एन्क्रिप्शन तंत्र की सरल व्याख्या

Fri, 11 Sep 2026 13:00:00 +0900

इंटरनेट समाज की सुरक्षा को बुनियादी रूप से समर्थन देने वाली तकनीकों में से एक “RSA एन्क्रिप्शन” है। ऑनलाइन शॉपिंग में क्रेडिट कार्ड से भुगतान, दोस्तों के साथ सोशल मीडिया पर बातचीत, कंपनी की गोपनीय जानकारी का आदान-प्रदान, आदि—जिन संचारों का हम प्रतिदिन जाने-अनजाने उपयोग करते हैं, उनमें से अधिकांश इस RSA एन्क्रिप्शन या इसकी उत्तराधिकारी तकनीकों द्वारा सुरक्षित होते हैं।

हालाँकि, “एन्क्रिप्शन” शब्द सुनकर आप शायद जासूसी फिल्मों में दिखने वाली जटिल एन्क्रिप्शन मशीनों या अति-उन्नत गणित की कल्पना करें जिसे केवल कुछ प्रतिभाशाली लोग ही समझ सकते हैं। यह सच है कि आधुनिक एन्क्रिप्शन सिद्धांत उन्नत गणित पर आधारित है, लेकिन RSA एन्क्रिप्शन का मूल तंत्र इतना सरल है कि यदि आपको हाई स्कूल के गणित (पूर्णांकों के गुण, अभाज्य संख्याएँ, सर्वांगसमता आदि) का ज्ञान है, तो आप इसे पूरी तरह से समझ सकते हैं।

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

1. सममित कुंजी एन्क्रिप्शन और सार्वजनिक कुंजी एन्क्रिप्शन

RSA एन्क्रिप्शन के गणितीय तंत्र में जाने से पहले, आइए एन्क्रिप्शन की बुनियादी अवधारणाओं को समझ लें। एन्क्रिप्शन विधियों को मोटे तौर पर दो प्रकारों में बांटा जा सकता है: “सममित कुंजी एन्क्रिप्शन” और “सार्वजनिक कुंजी एन्क्रिप्शन”।

1.1 सममित कुंजी एन्क्रिप्शन प्रणाली की सीमाएँ

प्राचीन काल से उपयोग की जाने वाली अधिकांश एन्क्रिप्शन प्रणालियाँ “सममित कुंजी एन्क्रिप्शन प्रणाली” कहलाती हैं। यह एक ऐसी प्रणाली है जिसमें “एन्क्रिप्शन (संदेश को गुप्त सिफरटेक्स्ट में बदलना)” और “डिक्रिप्शन (सिफरटेक्स्ट को मूल संदेश में वापस लाना)” के लिए एक ही कुंजी का उपयोग किया जाता है।

उदाहरण के लिए, मान लें कि ऐलिस, बॉब को एक गुप्त पत्र भेजना चाहती है। ऐलिस एक पैडलॉक (सममित कुंजी) का उपयोग करके पत्र को एक बक्से में बंद कर देती है। बॉब को उस बक्से को खोलने के लिए उसी कुंजी की आवश्यकता होगी जिसका ऐलिस ने उपयोग किया था।

इस प्रणाली में एक बड़ी समस्या है: “कुंजी वितरण समस्या”। जब दूर बैठे ऐलिस और बॉब पहली बार संवाद करते हैं, तो वे बिना किसी के द्वारा सुने गए कुंजी को कैसे साझा कर सकते हैं? यदि मेल द्वारा भेजे जाते समय किसी तीसरे पक्ष द्वारा कुंजी चुरा ली जाती है, तो उसके बाद के सभी एन्क्रिप्टेड संचार लीक हो जाएंगे।

1.2 एक क्रांतिकारी आविष्कार: “सार्वजनिक कुंजी एन्क्रिप्शन प्रणाली”

कुंजी वितरण की इस समस्या को हल करने के लिए “सार्वजनिक कुंजी एन्क्रिप्शन प्रणाली” का आविष्कार किया गया था। RSA एन्क्रिप्शन भी इसी का एक प्रकार है।

सार्वजनिक कुंजी एन्क्रिप्शन प्रणाली में, “एन्क्रिप्ट करने के लिए कुंजी (सार्वजनिक कुंजी)” और “डिक्रिप्ट करने के लिए कुंजी (निजी कुंजी)” नामक दो अलग-अलग कुंजियों का उपयोग किया जाता है।

प्राप्तकर्ता बॉब “सार्वजनिक कुंजी” और “निजी कुंजी” का एक जोड़ा बनाता है।
बॉब “सार्वजनिक कुंजी” को दुनिया भर में प्रकाशित करता है (कोई भी इसे प्राप्त कर सकता है)।
प्रेषक ऐलिस, बॉब की “सार्वजनिक कुंजी” का उपयोग करके संदेश को एन्क्रिप्ट करती है और उसे भेज देती है।
एन्क्रिप्टेड संदेश को केवल “निजी कुंजी” से ही डिक्रिप्ट किया जा सकता है जो केवल बॉब के पास है।

यदि इसे पैडलॉक से समझा जाए, तो बॉब बहुत सारे “खुले हुए पैडलॉक (सार्वजनिक कुंजी)” बनाता है और उन्हें दुनिया भर में बाँट देता है। ऐलिस बॉब के लिए संदेश को बक्से में डालती है, और बॉब का जो पैडलॉक उसे मिला है, उससे बक्से को बंद कर देती है। एक बार ताला बंद हो जाने के बाद, इसे केवल “मास्टर कुंजी (निजी कुंजी)” से ही खोला जा सकता है जो बॉब के पास है। भले ही कोई बीच में बक्सा चुरा ले, वह उसे नहीं खोल सकता क्योंकि उसके पास मास्टर कुंजी नहीं है।

graph TD A["ऐलिस (प्रेषक)"] --> B["प्लेनटेक्स्ट (संदेश)"] B --> C["एन्क्रिप्शन प्रक्रिया"] D["बॉब की सार्वजनिक कुंजी (कोई भी प्राप्त कर सकता है)"] --> C C --> E["इंटरनेट के माध्यम से भेजा गया: सिफरटेक्स्ट (एन्क्रिप्टेड)"] E --> F["डिक्रिप्शन प्रक्रिया"] G["बॉब की निजी कुंजी (केवल बॉब के पास)"] --> F F --> H["पुनर्प्राप्त प्लेनटेक्स्ट (संदेश)"] H --> I["बॉब (प्राप्तकर्ता)"]

इस क्रांतिकारी प्रणाली को साकार करने के लिए, किसी प्रकार के “एक-तरफ़ा फ़ंक्शन (वन-वे गणितीय पहेली)” की आवश्यकता होती है, जिसका अर्थ है कि सार्वजनिक कुंजी के साथ एन्क्रिप्ट करना आसान है, लेकिन निजी कुंजी के बिना इसे डिक्रिप्ट करना बिल्कुल असंभव है। उस पहेली के हिस्से के रूप में जिस चीज़ पर ध्यान दिया गया, वह हमारी परिचित “अभाज्य संख्याएँ” थीं।

2. RSA एन्क्रिप्शन का समर्थन करने वाला गणितीय आधार 1: अभाज्य संख्याएँ और अभाज्य गुणनखंडन

RSA एन्क्रिप्शन की सुरक्षा इस गणितीय तथ्य पर आधारित है कि “विशाल संख्याओं का अभाज्य गुणनखंडन करना बहुत कठिन है।”

2.1 अभाज्य संख्याएँ क्या हैं?

अभाज्य संख्याएँ वे “1 से बड़ी प्राकृत संख्याएँ हैं जो केवल 1 और स्वयं से विभाज्य हैं।” उदाहरण: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

अभाज्य संख्याएँ सभी पूर्णांकों के “परमाणुओं” की तरह हैं। किसी भी प्राकृत संख्या को अभाज्य संख्याओं के गुणा के रूप में तोड़ा जा सकता है। इसे अभाज्य गुणनखंडन कहा जाता है। उदाहरण के लिए, $60 = 2^2 \times 3 \times 5$, यह सर्वविदित है कि यदि हम क्रम को अनदेखा करें तो गुणनखंडन केवल एक ही अद्वितीय तरीके से किया जा सकता है (अंकगणित का मूलभूत प्रमेय)।

2.2 अभाज्य गुणनखंडन की कठिनाई (एक-तरफ़ा फ़ंक्शन)

यहाँ जो बात महत्वपूर्ण है वह है विषमता: “गुणा करना आसान है, लेकिन अभाज्य गुणनखंडन करना कठिन है।”

उदाहरण के लिए, निम्नलिखित दो अभाज्य संख्याओं के गुणनफल की गणना अपने दिमाग में करने का प्रयास करें। $11 \times 13 = ?$ यह आसान है। उत्तर $143$ है।

तो, इस संख्या के बारे में क्या खयाल है? $323$ का अभाज्य गुणनखंडन करें। कैसा लगा? इसमें थोड़ा समय लगना चाहिए। (उत्तर $17 \times 19$ है)।

यदि संख्याएँ छोटी हैं, तो मनुष्य भी किसी तरह गणना कर सकते हैं, लेकिन जब संख्याएँ बड़ी हो जाती हैं, Math तो कंप्यूटर का उपयोग करने पर भी गणना अत्यधिक कठिन हो जाती है। वर्तमान में मुख्यधारा के RSA एन्क्रिप्शन में, हम एक संख्या $N = p \times q$ का उपयोग करते हैं, जो दो अविश्वसनीय रूप से विशाल अभाज्य संख्याओं $p$ और $q$ को गुणा करके बनती है, जो 2048 बिट्स (दशमलव में लगभग 600 अंक) की होती हैं।

दिए गए दो विशाल अभाज्य संख्याओं $p$ और $q$ के लिए, $N$ की गणना करना कंप्यूटर के लिए पल भर (मिलीसेकंड से भी कम) का काम है। हालाँकि, यदि केवल $N$ दिया गया हो, तो मूल $p$ और $q$ को वापस खोजना इतना समय लेने वाला है कि इसे वर्तमान के सबसे तेज़ सुपरकंप्यूटरों का उपयोग करके भी खरबों वर्षों में हल नहीं किया जा सकता।

यही “कम्प्यूटेशनल विषमता (एक तरफा आसान, दूसरी तरफा कठिन)” सार्वजनिक कुंजी और निजी कुंजी के बीच संबंध बनाने की नींव बनाती है।

3. RSA एन्क्रिप्शन का समर्थन करने वाला गणितीय आधार 2: सर्वांगसमता (मॉड्यूलर अंकगणित)

RSA एन्क्रिप्शन में गणना साधारण जोड़ या गुणा की तरह नहीं होती जहाँ संख्याएँ अनंत रूप से बड़ी हो जाती हैं, बल्कि यह किसी संख्या से विभाजित करने पर बचे “शेषफल” की दुनिया में होती है। इसे सर्वांगसमता (मॉड्यूलर अंकगणित) कहा जाता है।

3.1 घड़ी का गणित

मॉड्यूलर अंकगणित की तुलना अक्सर “घड़ी के गणित” से की जाती है। मान लें कि अभी 10 बज रहे हैं, तो 5 घंटे बाद क्या समय होगा? $10 + 5 = 15$ बजे, लेकिन एक सामान्य 12-घंटे की घड़ी में हम उत्तर देते हैं “3 बजे”। ऐसा इसलिए है क्योंकि 15 को 12 से भाग देने पर शेषफल 3 आता है।

गणित की दुनिया में, इसे इस प्रकार लिखा जाता है:

$$ 15 \equiv 3 \pmod{12} $$

इसे ऐसे पढ़ा जाता है: “15 और 3, मॉड्युलो 12 के सर्वांगसम हैं (यानी 12 से भाग देने पर शेषफल समान है)।”

3.2 सर्वांगसमता के मूल गुण

सर्वांगसमता में कुछ बहुत ही उपयोगी गुण होते हैं जो समीकरणों ($=$) के समान होते हैं। मान लीजिए कि भाजक $N$ है। जब $a \equiv b \pmod N$ और $c \equiv d \pmod N$ हो, तो निम्नलिखित सत्य है:

जोड़: $a + c \equiv b + d \pmod N$
घटाव: $a - c \equiv b - d \pmod N$
गुणा: $a \times c \equiv b \times d \pmod N$
घातांक: $a^k \equiv b^k \pmod N$ ($k$ एक प्राकृत संख्या है)

“घातांक” का गुण विशेष रूप से महत्वपूर्ण है। इसका मतलब है कि “शेषफल का घातांक, घातांक के शेषफल के बराबर है।” उदाहरण के लिए, मान लें कि हम $7^{100}$ को $5$ से विभाजित करने पर शेषफल ज्ञात करना चाहते हैं। 7 को 100 बार गुणा करना और फिर उसे 5 से भाग देना बहुत मुश्किल काम है, लेकिन सर्वांगसमता के गुणों का उपयोग करके, चूँकि $7 \equiv 2 \pmod 5$ है, यह $7^{100} \equiv 2^{100} \pmod 5$ हो जाता है, जिससे गणना को काफी आसान किया जा सकता है। एन्क्रिप्शन की दुनिया में, यह गुण अपरिहार्य है क्योंकि हम बहुत बड़ी संख्याओं के घातांक से निपटते हैं।

4. RSA एन्क्रिप्शन का समर्थन करने वाला गणितीय आधार 3: यूलर का टॉशेंट फ़ंक्शन और यूलर का प्रमेय

यहाँ से जादुई गणित शुरू होता है जो RSA एन्क्रिप्शन का मूल है। “यूलर का प्रमेय” सामने आता है, जो “फर्मेट के छोटे प्रमेय” का एक सामान्यीकरण है।

4.1 यूलर का टॉशेंट फ़ंक्शन $\phi(N)$

यूलर का टॉशेंट फ़ंक्शन ($\phi$ फ़ंक्शन) एक ऐसा फ़ंक्शन है जो किसी भी प्राकृत संख्या $N$ के लिए, “1 से $N$ तक की उन प्राकृत संख्याओं की गिनती देता है, जो $N$ के साथ सह-अभाज्य (जिनका महत्तम समापवर्तक 1 है) हैं।”

आइए कुछ उदाहरण देखें:

$\phi(5)$: 1, 2, 3, 4, 5 में से, 5 के साथ सह-अभाज्य 1, 2, 3, 4 हैं, जो कुल 4 हैं। इसलिए $\phi(5) = 4$।
$\phi(6)$: 1, 2, 3, 4, 5, 6 में से, 6 के साथ सह-अभाज्य केवल 1, 5 हैं, जो कुल 2 हैं। इसलिए $\phi(6) = 2$।

【अभाज्य संख्याओं के लिए विशेष गुण】 जब $p$ एक अभाज्य संख्या है, तो 1 से $p-1$ तक की सभी संख्याएँ $p$ के साथ सह-अभाज्य होती हैं। इसलिए,

$$ \phi(p) = p - 1 $$

होता है।

【अभाज्य संख्याओं के गुणनफल के लिए विशेष गुण】 दो अलग-अलग अभाज्य संख्याओं $p$ और $q$ के लिए, यदि हम $N = p \times q$ मान लें, तो $\phi(N)$ को निम्नलिखित गणना द्वारा आसानी से निकाला जा सकता है:

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

यह गुण RSA एन्क्रिप्शन के “गुप्त पिछले दरवाजे (ट्रैपडोर)” के रूप में कार्य करता है। एक व्यक्ति जो $p$ और $q$ (कुंजी का निर्माता) जानता है, वह पल भर में $\phi(N)$ की गणना कर सकता है, लेकिन कोई तीसरा पक्ष जो केवल $N$ जानता है, वह $\phi(N)$ नहीं खोज सकता, जब तक कि वह $N$ का अभाज्य गुणनखंडन न कर ले।

4.2 यूलर का प्रमेय

लियोनहार्ड यूलर ने इस $\phi(N)$ का उपयोग करके निम्नलिखित सुंदर प्रमेय सिद्ध किया:

यूलर का प्रमेय: जब पूर्णांक $a$ और $N$ सह-अभाज्य होते हैं, तो निम्नलिखित सर्वांगसमता सत्य होती है:

$$ a^{\phi(N)} \equiv 1 \pmod N $$

यह एक आश्चर्यजनक गुण है कि “यदि हम किसी संख्या $a$ को $\phi(N)$ बार गुणा करते हैं और $N$ से विभाजित करते हैं, तो शेषफल हमेशा $1$ होगा।” (जब $N$ एक अभाज्य संख्या $p$ है, तो यह $a^{p-1} \equiv 1 \pmod p$ बन जाता है, जिसे फर्मेट का छोटा प्रमेय कहा जाता है)।

आइए इस यूलर के प्रमेय को थोड़ा संशोधित करें। दोनों पक्षों को फिर से $a$ से गुणा करें:

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

इसके अलावा, किसी भी पूर्णांक $k$ के लिए, $a^{k \cdot \phi(N)}$ भी $1^k = 1$ होगा, इसलिए निम्नलिखित समीकरण सत्य है:

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

यह समीकरण ही वह मूल सिद्धांत है जो RSA एन्क्रिप्शन के इस जादू को काम करने देता है: “जब आप इसे एन्क्रिप्ट करते हैं और फिर डिक्रिप्ट करते हैं, तो यह अपनी मूल अवस्था में वापस आ जाता है।”

5. RSA एन्क्रिप्शन एल्गोरिथम: कुंजी निर्माण, एन्क्रिप्शन और डिक्रिप्शन के चरण

अब जब हमारे पास बुनियादी ज्ञान है, तो आइए अंततः RSA एन्क्रिप्शन के विशिष्ट चरणों को देखें। RSA एन्क्रिप्शन मोटे तौर पर तीन चरणों में बंटा हुआ है: “1. कुंजी निर्माण”, “2. एन्क्रिप्शन”, और “3. डिक्रिप्शन”।

flowchart TD A1["1. अभाज्य संख्याएँ p, q चुनें"] --> A2["N = p × q की गणना करें"] A1 --> A3["φ(N) = (p-1)(q-1) की गणना करें"] A3 --> A4["φ(N) के साथ सह-अभाज्य e चुनें"] A3 --> A5["ऐसे d की गणना करें कि e × d ≡ 1 (mod φ(N)) हो"] A2 --> A6["सार्वजनिक कुंजी (N, e)"] A4 --> A6 A5 --> A7["निजी कुंजी d"] B1["2. प्लेनटेक्स्ट संदेश M"] --> B2["C ≡ M^e (mod N) की गणना करें"] A6 -.-> B2 B2 --> B3["सिफरटेक्स्ट C भेजें"] B3 --> C1["3. प्राप्त सिफरटेक्स्ट C"] C1 --> C2["M ≡ C^d (mod N) की गणना करें"] A7 -.-> C2 C2 --> C3["मूल प्लेनटेक्स्ट संदेश M प्राप्त करें"]

5.1 कुंजी निर्माण (Key Generation)

प्राप्तकर्ता बॉब, अपने लिए एक “सार्वजनिक कुंजी” और एक “निजी कुंजी” बनाता है।

अभाज्य संख्याओं का चयन: दो बड़ी अभाज्य संख्याएँ $p$ और $q$ यादृच्छिक रूप से चुनें।
$N$ की गणना: $N = p \times q$ की गणना करें। यह $N$ सार्वजनिक किया जाएगा।
$\phi(N)$ की गणना: यूलर फ़ंक्शन $\phi(N) = (p - 1)(q - 1)$ की गणना करें। यह बॉब का गुप्त नंबर है।
सार्वजनिक कुंजी $e$ का चयन: एक ऐसा पूर्णांक $e$ चुनें जो $1 < e < \phi(N)$ हो और $\phi(N)$ के साथ सह-अभाज्य हो।
निजी कुंजी $d$ की गणना: एक ऐसा पूर्णांक $d$ खोजें जो निम्नलिखित शर्त को पूरा करता हो: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ दूसरे शब्दों में, यह एक ऐसी संख्या $d$ है जहाँ “$e \times d$ को $\phi(N)$ से भाग देने पर शेषफल $1$ होता है।”

इसके साथ ही कुंजियों की तैयारी पूरी हो जाती है।

सार्वजनिक कुंजी: $(N, e)$ का जोड़ा। इसे पूरी दुनिया के लिए सार्वजनिक किया जाता है।
निजी कुंजी: $d$। इसे किसी को भी नहीं बताया जाता।

5.2 एन्क्रिप्शन (Encryption)

मान लें कि ऐलिस, बॉब को एक गुप्त संदेश $M$ भेजना चाहती है। ($M$ पाठ को संख्यात्मक रूप में परिवर्तित करने से बनता है, और हम मान कर चलते हैं कि $0 \le M < N$ है)। ऐलिस बॉब की सार्वजनिक कुंजी $(N, e)$ का उपयोग करके निम्नानुसार गणना करती है:

$$ C \equiv M^e \pmod N $$

“संदेश $M$ को $e$ की घात तक उठाएँ, और $N$ से भाग देने पर शेषफल $C$ प्राप्त करें।” यह $C$ एन्क्रिप्टेड संदेश (सिफरटेक्स्ट) है।

5.3 डिक्रिप्शन (Decryption)

बॉब को सिफरटेक्स्ट $C$ प्राप्त होता है। बॉब अपनी निजी कुंजी $d$ का उपयोग करके निम्नानुसार गणना करता है:

$$ M \equiv C^d \pmod N $$

यदि आप “सिफरटेक्स्ट $C$ को $d$ की घात तक बढ़ाते हैं, और $N$ से भाग देने पर शेषफल” की गणना करते हैं, तो आश्चर्यजनक रूप से मूल संदेश $M$ पुनर्प्राप्त हो जाता है!

6. डिक्रिप्शन इसे मूल अवस्था में वापस क्यों लाता है? (गणितीय प्रमाण)

आप सोच रहे होंगे, “$C$ की घात $d$ करने से, यह मूल $M$ में कैसे वापस आ जाता है?” यहीं पर पहले वर्णित “यूलर का प्रमेय” अपनी शक्ति दिखाता है।

आइए डिक्रिप्शन के सूत्र $C^d \pmod N$ में एन्क्रिप्शन के सूत्र $C = M^e$ को प्रतिस्थापित करें:

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

यहाँ, कुंजी निर्माण के चरण 5 को याद करें। जब बॉब ने $d$ बनाया, तो उसने इसे इस तरह चुना कि $e \times d \equiv 1 \pmod{\phi(N)}$ हो। इसका मतलब है कि “$ed$, $\phi(N)$ के गुणज में $1$ जोड़ने से बनी संख्या है।” एक पूर्णांक $k$ का उपयोग करके, इसे इस प्रकार लिखा जा सकता है:

$$ ed = k \cdot \phi(N) + 1 $$

इसे घातांक वाले भाग में रखें और घातांक के नियमों का उपयोग करके इसे हल करें:

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

यहाँ, यदि हम मान लें कि संदेश $M$ और $N$ सह-अभाज्य हैं, तो यूलर के प्रमेय से, $M^{\phi(N)} \equiv 1 \pmod N$ होता है।

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

इसलिए, निम्नलिखित समीकरण पूरी तरह से सत्य होता है:

$$ C^d \equiv M \pmod N $$

ऐलिस $d$ को नहीं जानती, और छिपकर बातें सुनने वाला भी $d$ को नहीं जानता, इसलिए केवल बॉब, जिसके पास $d$ है, $C$ से $M$ को निकाल सकता है।

7. एक ठोस उदाहरण: आइए छोटी अभाज्य संख्याओं का उपयोग करके हाथ से RSA की गणना करें

आइए वास्तव में छोटी संख्याओं (अभाज्य संख्याओं) का उपयोग करके ऐलिस से बॉब तक एन्क्रिप्टेड संचार का प्रयास करें।

【बॉब का कुंजी निर्माण चरण】

दो अभाज्य संख्याएँ चुनें, $p=11$ और $q=13$।
$N = 11 \times 13 = 143$ की गणना करें।
$\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$ की गणना करें।
एक सार्वजनिक कुंजी $e$ चुनें जो $\phi(N)=120$ के साथ सह-अभाज्य हो। यहाँ हम $e=7$ का उपयोग करेंगे।
निजी कुंजी $d$ ज्ञात करें। ऐसा $d$ खोजें कि $7 \times d \equiv 1 \pmod{120}$ हो। समीकरण $7d = 120k + 1$ में, जब $k=6$ होता है, तो मान $721$ हो जाता है, और $721 \div 7 = 103$ होता है। इसलिए, $d = 103$ हो जाता है।

सार्वजनिक कुंजी: $(N=143, e=7)$
निजी कुंजी: $d=103$

【ऐलिस का एन्क्रिप्शन चरण】 मान लीजिए कि ऐलिस संदेश $M = 9$ भेजना चाहती है। सूत्र: $C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$। जब इसे 143 से भाग दिया जाता है, तो भागफल 33447 और शेषफल 48 होता है। तो एन्क्रिप्टेड संदेश $C = 48$ हो गया।

【बॉब का डिक्रिप्शन चरण】 बॉब को एन्क्रिप्टेड संदेश $C = 48$ मिलता है और वह इसे डिक्रिप्ट करने के लिए अपनी निजी कुंजी $d = 103$ का उपयोग करता है। सूत्र: $M \equiv 48^{103} \pmod{143}$ यदि आप कैलकुलेटर पर (48 ** 103) % 143 चलाते हैं, तो परिणाम आश्चर्यजनक रूप से “9” आएगा! बॉब सफलतापूर्वक मूल संदेश प्राप्त करने में सक्षम हो गया।

8. निजी कुंजी $d$ कैसे ज्ञात करें: विस्तारित यूक्लिडियन एल्गोरिथम

मैन्युअल गणना के उदाहरण में, हमने अनुमान लगाकर $k$ का मान खोजा और $d=103$ प्राप्त किया, लेकिन जब संख्याएँ सैकड़ों अंकों की हो जाती हैं, तो यह विधि असंभव है। वास्तविक प्रोग्रामों में, “विस्तारित यूक्लिडियन एल्गोरिथम” नामक एल्गोरिथम का उपयोग किया जाता है।

$7d \equiv 1 \pmod{120}$ को हल करने का मतलब ऐसे पूर्णांक $d, y$ ज्ञात करना है जो $7d + 120y = 1$ को संतुष्ट करते हों। यूक्लिडियन एल्गोरिथम को उल्टे क्रम में लागू करके, इसकी गणना व्यवस्थित तरीके से की जा सकती है।

$120 \div 7 = 17$ शेषफल $1$
इसे पुनः व्यवस्थित करने पर, $1 = 120 - 17 \times 7$
यानी, $-17 \times 7 \equiv 1 \pmod{120}$

मॉड्युलो 120 की दुनिया में $-17$ का अर्थ $120 - 17 = 103$ के समान ही है। इसलिए, $d = 103$ पल भर में मिल जाता है। यह विधि बहुत तेज़ी से गणना कर सकती है, चाहे संख्या कितनी भी विशाल क्यों न हो।

9. RSA एन्क्रिप्शन का एक और चेहरा: डिजिटल हस्ताक्षर

RSA एन्क्रिप्शन के बारे में सबसे अच्छी बात यह है कि सार्वजनिक और निजी कुंजियों की भूमिकाओं को उलट कर इसे “डिजिटल हस्ताक्षर” के रूप में भी इस्तेमाल किया जा सकता है।

एन्क्रिप्शन में, प्रक्रिया थी “सार्वजनिक कुंजी के साथ एन्क्रिप्ट करें $\Rightarrow$ निजी कुंजी के साथ डिक्रिप्ट करें”। डिजिटल हस्ताक्षर में, प्रक्रिया है “निजी कुंजी के साथ एन्क्रिप्ट करें $\Rightarrow$ सार्वजनिक कुंजी के साथ डिक्रिप्ट करें”।

flowchart TD A1["1. ऐलिस अपनी निजी कुंजी से हस्ताक्षर बनाती है"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["संदेश M और हस्ताक्षर S भेजें"] A3 --> B1["2. बॉब सार्वजनिक कुंजी के साथ हस्ताक्षर सत्यापित करता है"] B1 --> B2["M' ≡ S^e (mod N) की गणना करें"] B2 --> B3["जांचें कि क्या M' और M मेल खाते हैं"]

ऐलिस अपनी निजी कुंजी $d$ का उपयोग करके संदेश को बदलती है (यह हस्ताक्षर $S$ है) और इसे बॉब को भेजती है। बॉब सत्यापन गणना करने के लिए ऐलिस की सार्वजनिक कुंजी $e$ का उपयोग करता है। यदि गणना का परिणाम मूल संदेश से मेल खाता है, तो यह एक साथ साबित करता है कि “यह डेटा केवल ऐलिस की निजी कुंजी से ही बनाया जा सकता था” और “संदेश से रास्ते में छेड़छाड़ नहीं की गई है।”

10. एक प्रोग्राम के साथ RSA एन्क्रिप्शन का अनुभव करना

हाथ से घातांक की गणना करना कठिन है, लेकिन यदि आप Python का उपयोग करते हैं, तो इसे लागू करना बहुत आसान है। नीचे दिया गया Python कोड आपको RSA एन्क्रिप्शन के मुख्य तर्क का अनुभव करने की अनुमति देता है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


def gcd(a, b):
 """महत्तम समापवर्तक ज्ञात करें"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """निजी कुंजी d ज्ञात करें (Python 3.8+ के बिल्ट-इन फ़ंक्शन का उपयोग करके)"""
 return pow(e, -1, phi)

# 1. कुंजी निर्माण
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"सार्वजनिक कुंजी: (N={N}, e={e}), निजी कुंजी: d={d}")

# 2. एन्क्रिप्शन
message = 9
ciphertext = pow(message, e, N)
print(f"एन्क्रिप्टेड संदेश: {ciphertext}")

# 3. डिक्रिप्शन
decrypted_message = pow(ciphertext, d, N)
print(f"डिक्रिप्टेड संदेश: {decrypted_message}")

चूँकि Python का pow(base, exp, mod) फ़ंक्शन आंतरिक रूप से एक तेज़ एल्गोरिथम का उपयोग करता है जिसे “पुनरावृत्त वर्ग विधि (Exponentiation by squaring)” कहा जाता है, यह एक पल में गणना पूरी कर लेता है, भले ही संख्याएँ सैकड़ों अंकों की हों।

11. निष्कर्ष और भविष्य की एन्क्रिप्शन तकनीक

हमने हाई स्कूल के गणितीय ज्ञान के आधार पर RSA एन्क्रिप्शन के तंत्र का खुलासा किया है।

अभाज्य गुणनखंडन की कठिनाई: $p \times q = N$ खोजना आसान है, लेकिन $N$ से $p, q$ खोजना बहुत मुश्किल है।
सर्वांगसमता और यूलर का प्रमेय: $a^{\phi(N)} \equiv 1 \pmod N$ नियम के माध्यम से, “एक निश्चित संख्या की घात तक बढ़ाने पर मूल अवस्था में वापस आने” का जादुई ट्रैपडोर पूरा हो जाता है।
सार्वजनिक और निजी कुंजियाँ: कोई भी एन्क्रिप्ट कर सकता है, लेकिन केवल वैध प्राप्तकर्ता ही इसे डिक्रिप्ट कर सकता है।

वर्तमान में उपयोग किए जाने वाले RSA एन्क्रिप्शन में 600 से अधिक अंकों का $N$ होता है, और दुनिया के सभी सुपर कंप्यूटरों को एक साथ काम में लगा दिया जाए, तो भी इसके अभाज्य गुणनखंडन में ब्रह्मांड की आयु से अधिक समय लगेगा। हालाँकि, यदि हाल ही में शोध किए जा रहे “क्वांटम कंप्यूटर” भविष्य में व्यावहारिक उपयोग में आते हैं, तो ऐसी संभावना है कि यह अभाज्य गुणनखंडन “शोर के एल्गोरिथम” द्वारा पल भर में हल हो जाएगा। इस कारण से, दुनिया भर में “क्वांटम-प्रतिरोधी एन्क्रिप्शन” विकसित करने के लिए तेज़ गति से काम चल रहा है, जिसे क्वांटम कंप्यूटर भी डिक्रिप्ट नहीं कर सकते।

उन्नत गणित जिसे अक्सर “बेकार” माना जाता है, वास्तव में हमारे दैनिक जीवन को उसकी जड़ों से सुरक्षित रखता है। RSA एन्क्रिप्शन इस तरह के गणित की गहराई और सुंदरता सिखाने वाली सबसे बेहतरीन शिक्षण सामग्री है। हमें उम्मीद है कि इस लेख के माध्यम से आप एन्क्रिप्शन और गणित के आकर्षण को थोड़ा भी महसूस कर पाए होंगे।

पूर्ण समरूप एन्क्रिप्शन (FHE) क्या है? अगली पीढ़ी की सुरक्षा के मूल तत्व की व्याख्या

Fri, 11 Sep 2026 11:00:00 +0900

चूंकि क्लाउड कंप्यूटिंग और एआई तकनीक समाज की नींव के रूप में स्थापित हो रही है, “डेटा गोपनीयता (Data Privacy)” और “डेटा उपयोग (Data Utilization)” के बीच का ट्रेड-ऑफ सबसे महत्वपूर्ण चुनौतियों में से एक बन गया है। अत्यधिक गोपनीय डेटा, जैसे मेडिकल डेटा, वित्तीय जानकारी, और व्यक्तिगत बायोमेट्रिक जानकारी का क्लाउड पर एआई द्वारा विश्लेषण कराने की मांग बढ़ रही है, लेकिन सुरक्षा चिंताओं के कारण कई कंपनियां डेटा को बाहर भेजने में संकोच करती हैं।

पारंपरिक एन्क्रिप्शन तकनीकें (जैसे AES और RSA) स्टोरेज में सहेजे गए डेटा (Data at Rest) और नेटवर्क पर प्रवाहित होने वाले डेटा (Data in Transit) की सुरक्षा करने में उत्कृष्ट हैं। हालाँकि, जब सर्वर डेटा पर खोज या मशीन लर्निंग जैसी प्रक्रियाएँ (गणनाएँ) करता है (Data in Use), तो एन्क्रिप्शन को डिक्रिप्ट करके उसे वापस प्लेनटेक्स्ट में बदलना आवश्यक होता है। यदि इस डिक्रिप्शन के समय सर्वर हैक हो जाता है, या कोई दुर्भावनापूर्ण आंतरिक प्रशासक डेटा देख लेता है, तो यह सीधे सूचना रिसाव का कारण बन सकता है।

इस “प्रोसेसिंग के दौरान डिक्रिप्शन” की मूलभूत कमजोरी को दूर करने वाली सपनों की तकनीक पूर्ण समरूप एन्क्रिप्शन (Fully Homomorphic Encryption: FHE) है। FHE का उपयोग करके, डेटा को डिक्रिप्ट किए बिना एन्क्रिप्टेड अवस्था में ही गणना प्रक्रियाएं करना संभव है, और केवल परिणामी सिफरटेक्स्ट (ciphertext) को क्लाइंट को वापस किया जाता है।

इस लेख में, हम FHE की अवधारणा से लेकर इसके इतिहास, क्रेग जेंट्री (Craig Gentry) की ऐतिहासिक सफलता, गणितीय आधार (जैसे Ring-LWE), सबसे बड़ी चुनौती “शोर (Noise)” और इसके समाधान (बूटस्ट्रैपिंग), और नवीनतम कार्यान्वयन पुस्तकालयों (implementation libraries) तक सब कुछ कवर करेंगे, जो अगली पीढ़ी की सुरक्षा के प्रमुख तत्व FHE की गहराई से व्याख्या करता है।

1. समरूप एन्क्रिप्शन क्या है? बुनियादी अवधारणा

“समरूप (Homomorphic)” एक बीजगणितीय शब्द है, जो किसी संरचना वाले सेट के बीच एक मैपिंग को संदर्भित करता है जो ऑपरेशनों की संरचना को बरकरार रखता है। क्रिप्टोग्राफी में “समरूपता (Homomorphism)” का अर्थ यह गुण है कि प्लेनटेक्स्ट स्पेस में ऑपरेशन्स सिफरटेक्स्ट स्पेस में ऑपरेशन्स के अनुरूप होते हैं।

सरल गणितीय शब्दों में, मान लें कि प्लेनटेक्स्ट $m_1$ और $m_2$ के लिए एन्क्रिप्शन फ़ंक्शन $E(\cdot)$ है, और डिक्रिप्शन फ़ंक्शन $D(\cdot)$ है। प्लेनटेक्स्ट पर होने वाले ऑपरेशन (जैसे जोड़ या गुणा) को $\circ$ के रूप में, और सिफरटेक्स्ट पर होने वाले ऑपरेशन को $\diamond$ के रूप में दर्शाया गया है, तो निम्नलिखित संबंध लागू होता है:

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

दूसरे शब्दों में, यदि आप सिफरटेक्स्ट $E(m_1)$ और $E(m_2)$ पर कोई ऑपरेशन $\diamond$ लागू करते हैं और परिणाम को डिक्रिप्ट करते हैं, तो यह मूल प्लेनटेक्स्ट के बीच ऑपरेशन $\circ$ लागू करने के परिणाम से मेल खाएगा।

क्लाउड कंप्यूटिंग में डेटा प्रवाह (Data Flow in Cloud Computing)

FHE का उपयोग करने वाली क्लाउड प्रोसेसिंग का आर्किटेक्चर पारंपरिक वाले से बिल्कुल अलग है। नीचे दिया गया चित्र FHE का उपयोग करते हुए सुरक्षित डेटा प्रोसेसिंग प्रवाह को दर्शाता है।

सर्वर एन्क्रिप्टेड डेटा $E(x)$ प्राप्त करता है, लेकिन चूंकि उसके पास निजी कुंजी (private key) नहीं है, इसलिए वह कभी भी डेटा की सामग्री नहीं जान सकता। हालांकि, FHE के गुणों का उपयोग करके, यह सिफरटेक्स्ट पर एक फ़ंक्शन $f$ (उदाहरण के लिए, मशीन लर्निंग अनुमान मॉडल) लागू कर सकता है और $E(f(x))$ उत्पन्न कर सकता है। क्लाइंट इसे प्राप्त करता है और वांछित परिणाम $y = f(x)$ प्राप्त करने के लिए इसे अपनी निजी कुंजी के साथ डिक्रिप्ट करता है।

2. समरूप एन्क्रिप्शन के विकास का इतिहास: PHE, SHE, FHE

समरूप एन्क्रिप्शन एक ही बार में अपने वर्तमान “पूर्ण” रूप में विकसित नहीं हुआ था। इसे सक्षम किए जा सकने वाले ऑपरेशनों के प्रकार और संख्या के आधार पर मोटे तौर पर तीन चरणों में वर्गीकृत किया जाता है।

आंशिक रूप से समरूप एन्क्रिप्शन (Partially Homomorphic Encryption - PHE)

PHE एक एन्क्रिप्शन पद्धति है जो बिना किसी सीमा के जोड़ या गुणा में से केवल एक को करने की अनुमति देती है। वास्तव में, इस गुण वाले एन्क्रिप्शन लंबे समय से मौजूद हैं।

RSA एन्क्रिप्शन (गुणा के लिए समरूपता) RSA एन्क्रिप्शन में अनजाने में गुणात्मक समरूपता थी। मान लें कि प्लेनटेक्स्ट $m_1, m_2$ है, और सार्वजनिक कुंजी $(e, N)$ है: $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ यदि हम इन्हें गुणा करते हैं: $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ इस प्रकार, सिफरटेक्स्ट का गुणा प्लेनटेक्स्ट के गुणा के अनुरूप होता है।
Paillier एन्क्रिप्शन (जोड़ के लिए समरूपता) 1999 में तैयार किए गए पैलिएर (Paillier) एन्क्रिप्शन में योगात्मक समरूपता (additive homomorphism) होती है। इसे इलेक्ट्रॉनिक वोटिंग (जहां एन्क्रिप्टेड वोटों को जोड़ा जाता है, और केवल अंतिम परिणाम को डिक्रिप्ट किया जाता है) जैसी चीजों में व्यावहारिक रूप से उपयोग किया गया है।

कुछ हद तक समरूप एन्क्रिप्शन (Somewhat Homomorphic Encryption - SHE)

यह एक ऐसी विधि है जो जोड़ और गुणा दोनों को निष्पादित कर सकती है, लेकिन किए जा सकने वाले ऑपरेशनों की संख्या (सर्किट की गहराई) पर एक सीमा होती है। “शोर (noise)” के संचय के कारण (जिसकी चर्चा बाद में की गई है), यदि किसी निश्चित संख्या से अधिक गुणा किया जाता है, तो डिक्रिप्शन असंभव हो जाता है। 2005 का BGN (Boneh-Goh-Nissim) एन्क्रिप्शन इस श्रेणी में आता है, लेकिन व्यावहारिक और जटिल गणनाएं (जैसे डीप लर्निंग) करने में इसकी सीमाएं थीं।

पूर्ण समरूप एन्क्रिप्शन (Fully Homomorphic Encryption - FHE)

यह एक एन्क्रिप्शन विधि है जहां जोड़ और गुणा दोनों को असीमित बार निष्पादित किया जा सकता है। सूचना सिद्धांत में ट्यूरिंग-पूर्णता के समान, यदि जोड़ (XOR के समतुल्य) और गुणा (AND के समतुल्य) को अनिश्चित काल तक जोड़ा जा सकता है, तो इसका अर्थ है कि सिद्धांत रूप में कोई भी गणना योग्य फ़ंक्शन या एल्गोरिदम एन्क्रिप्टेड अवस्था में निष्पादित किया जा सकता है।

लंबे समय तक, FHE को “क्रिप्टोग्राफी का पवित्र कंठ (Holy Grail of Cryptography)” कहा जाता था, और यहां तक कहा जाता था कि इसे साकार करना असंभव हो सकता है। हालाँकि, 2009 में, स्टैनफोर्ड विश्वविद्यालय के एक तत्कालीन पीएचडी छात्र क्रेग जेंट्री (Craig Gentry) ने आदर्श जालक (Ideal Lattices) का उपयोग करते हुए पहली FHE योजना प्रस्तावित की और दुनिया को चौंका दिया।

3. FHE का गणितीय आधार: LWE समस्या और Ring-LWE

कई मुख्यधारा की FHE योजनाएँ आज LWE (Learning With Errors) समस्या पर आधारित हैं, जो “लैटिस-आधारित क्रिप्टोग्राफी (Lattice-based Cryptography)” में एक कठिन गणितीय समस्या है, जिसे पोस्ट-क्वांटम क्रिप्टोग्राफी के रूप में भी जाना जाता है।

LWE समस्या की सहज समझ

गॉसियन उन्मूलन (Gaussian elimination) जैसी विधियों का उपयोग करके रैखिक समीकरणों की प्रणालियों को हल करना आसान है।

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

हालाँकि, क्या होगा यदि हम इस समीकरण के परिणाम में थोड़ी सी “यादृच्छिक त्रुटि (शोर)” $e$ जोड़ दें?

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

केवल इस त्रुटि $e$ को जोड़ने से, गुप्त चर सदिश (secret variable vector) $\vec{s}$ को खोजने की समस्या एक NP-hard समस्या में बदल जाती है जिसे वर्तमान सुपर कंप्यूटर या क्वांटम कंप्यूटर का उपयोग करके भी डिक्रिप्ट करना मुश्किल है। यह LWE समस्या है।

Ring-LWE समस्या (RLWE)

चूंकि मानक LWE समस्या में मैट्रिक्स संचालन शामिल होता है, इसलिए इसमें ऐसी समस्याएं थीं कि कुंजी का आकार बहुत बड़ा (कभी-कभी गीगाबाइट में) था और कम्प्यूटेशनल दक्षता खराब थी। इसे हल करने के लिए, Ring-LWE (RLWE) समस्या, जो बहुपद वलय (polynomial rings) पर संचालन का उपयोग करती है, पेश की गई थी।

RLWE में, तत्व बहुपद वलय $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ से संबंधित होते हैं (जहाँ $N$ 2 की घात है, और $q$ एक अभाज्य मापांक (prime modulus) है)। मान लें कि गुप्त कुंजी एक बहुपद $s(x)$ है, $a(x)$ एक यादृच्छिक बहुपद है, और $e(x)$ एक छोटा शोर बहुपद है, तो सार्वजनिक कुंजी (public key) निम्न जोड़ी बन जाती है:

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

एन्क्रिप्शन के दौरान, इस बहुपद के गुणों का उपयोग प्लेनटेक्स्ट $m(x)$ को एनकोड करने और सिफरटेक्स्ट उत्पन्न करने के लिए किया जाता है।

4. सबसे बड़ी बाधा “शोर (Noise)” और जेंट्री की बूटस्ट्रैपिंग

FHE को समझने में सबसे महत्वपूर्ण अवधारणा “शोर प्रबंधन (Noise Management)” है।

LWE/RLWE-आधारित एन्क्रिप्शन में, सुरक्षा सुनिश्चित करने के लिए जानबूझकर एक छोटा “शोर (त्रुटि)” शामिल किया जाता है। मोटे तौर पर कहें সমগ্র, प्लेनटेक्स्ट $m$ के सिफरटेक्स्ट $c$ को डिक्रिप्ट करने की प्रक्रिया को निम्नलिखित सूत्र द्वारा व्यक्त किया जा सकता है:

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

डिक्रिप्शन के दौरान, सही प्लेनटेक्स्ट $m$ प्राप्त करने के लिए इस noise को राउंडिंग जैसी प्रक्रियाओं द्वारा हटा दिया जाता है। हालाँकि, जब सिफरटेक्स्ट के बीच समरूप संचालन (विशेष रूप से गुणा) किया जाता है, तो यह शोर नाटकीय रूप से बढ़ जाता है।

समरूप जोड़ (Homomorphic Addition): शोर संयोजी रूप से बढ़ता है ($e_1 + e_2$)। यह अपेक्षाकृत क्रमिक वृद्धि है।
समरूप जोड़ द्वारा समरूपता की गणितीय अभिव्यक्ति: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
समरूप गुणा (Homomorphic Multiplication): शोर गुणात्मक रूप से विस्फोटित होता है (क्योंकि इसमें $e_1 \times e_2$ आदि शामिल हैं)। केवल कुछ गुणा के बाद, शोर $q/2$ की सीमा से अधिक हो जाता है, जिससे उचित राउंडिंग प्रक्रिया विफल हो जाती है और डिक्रिप्शन असंभव हो जाता है।
समरूप गुणा द्वारा समरूपता की गणितीय अभिव्यक्ति: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

यही कारण है कि FHE को लंबे समय तक महसूस नहीं किया जा सका, और यह SHE (सीमित संख्या में संचालन के साथ) तक ही सीमित रहा।

बूटस्ट्रैपिंग (Bootstrapping) का जादू

क्रेग जेंट्री का सबसे प्रतिभाशाली योगदान “बूटस्ट्रैपिंग” नामक शोर कम करने वाली तकनीक का आविष्कार था। यह क्रिप्टोग्राफी में एक प्रतिमान बदलाव (paradigm shift) था।

सहज रूप से, यह एक ऐसा ऑपरेशन है जो “सिफरटेक्स्ट के शोर से भर जाने और टूटने से पहले, इसे एन्क्रिप्टेड अवस्था में ही ‘डिक्रिप्ट’ करके साफ करता है, और इसे एक नए सिफरटेक्स्ट में डालता है।”

मान लें कि हमारे पास एक उच्च-शोर वाला सिफरटेक्स्ट $C_{noisy}$ है।
क्लाइंट पहले से ही सर्वर को निजी कुंजी $sk$ का “सार्वजनिक कुंजी द्वारा एन्क्रिप्टेड संस्करण” $E_{pk}(sk)$ (जिसे बूटस्ट्रैपिंग कुंजी कहा जाता है) प्रदान करता है।
सर्वर $C_{noisy}$ पर समरूप रूप से डिक्रिप्शन सर्किट (Decryption Circuit) को निष्पादित करता है।
विशेष रूप से, यह $E_{pk}(sk)$ का उपयोग करके $E_{pk}(C_{noisy})$ पर “एन्क्रिप्टेड स्पेस के भीतर डिक्रिप्शन” करता है।
चूंकि यह डिक्रिप्शन सर्किट स्वयं एक समरूप संचालन है, यह नया शोर पैदा करता है, लेकिन आउटपुट के रूप में उत्पन्न नए सिफरटेक्स्ट $C_{fresh}$ का शोर एक निश्चित “निश्चित स्तर (fixed level)” पर रीसेट हो जाता है।

graph LR A["उच्च-शोर सिफरटेक्स्ट C_noisy"] --> B["समरूप डिक्रिप्शन सर्किट (Eval_Dec)"] C["एन्क्रिप्टेड निजी कुंजी E(sk)"] --> B B --> D["निम्न-शोर सिफरटेक्स्ट C_fresh"] style B fill:#ffeeba,stroke:#ffc107

गणना के दौरान समय-समय पर इस बूटस्ट्रैपिंग को निष्पादित करके, सिद्धांत रूप में अनंत गहराई के सर्किट की गणना करना संभव हो गया (FHE की उपलब्धि)। हालाँकि, जेंट्री की शुरुआती पद्धति निराशाजनक रूप से महंगी थी, जिसमें बूटस्ट्रैपिंग प्रक्रिया में हर बार कई मिनटों से लेकर कई घंटों तक का समय लगता था।

5. FHE की पीढ़ियाँ और प्रमुख योजनाओं का विकास

FHE के व्यावहारिक अनुप्रयोग के लिए, दुनिया भर के क्रिप्टोग्राफर इसके एल्गोरिदम को बेहतर बनाने के लिए प्रतिस्पर्धा कर रहे हैं। वर्तमान में, FHE को मुख्य रूप से 4 पीढ़ियों/श्रेणियों में वर्गीकृत किया गया है।

दूसरी पीढ़ी: पूर्णांकों पर सटीक संचालन (BGV, BFV)

BGV (Brakerski-Gentry-Vaikuntanathan) और BFV (Brakerski/Fan-Vercauteren) योजनाएँ 2011 से 2012 के बीच उभरीं। ये RLWE पर आधारित हैं और पूर्णांकों (सटीक गणना) के मॉड्यूलर अंकगणित के लिए उपयुक्त हैं। वे SIMD (Single Instruction, Multiple Data) जैसी बैचिंग तकनीक का समर्थन करते हैं, जो एक ही विशाल बहुपद सिफरटेक्स्ट में हजारों डेटा स्लॉट पैक करने और एक ही समय में समानांतर गणना करने की अनुमति देता है।

तीसरी पीढ़ी: बूटस्ट्रैपिंग का त्वरण (GSW, FHEW, TFHE)

2013 की GSW (Gentry-Sahai-Waters) योजना ने FHE संरचना को बहुत सरल बना दिया। इससे विकसित होकर वर्तमान मुख्यधारा की योजनाओं में से एक TFHE (Fast Fully Homomorphic Encryption over the Torus) बनी। TFHE की विशेषता इसकी बहुत तेज़ बूटस्ट्रैपिंग (मिलीसेकंड में) है। यह गेट स्तर (तार्किक सर्किट जैसे AND, XOR) पर संचालन में बहुत प्रभावी है, और सिफरटेक्स्ट का आकार भी अपेक्षाकृत छोटा है, जिससे यह किसी भी तार्किक सर्किट का तेज़ी से मूल्यांकन करने के लिए उपयुक्त हो जाता है।

चौथी पीढ़ी: अनुमानित गणना और मशीन लर्निंग पर ध्यान केंद्रित (CKKS)

2017 में चेओन एट अल. द्वारा प्रस्तावित CKKS (Cheon-Kim-Kim-Song) योजना को वर्तमान AI और मशीन लर्निंग गोपनीयता सुरक्षा में निश्चित तकनीक माना जा सकता है। जबकि पिछली FHE योजनाओं ने “सटीक पूर्णांक गणना” पर ध्यान केंद्रित किया, CKKS एन्क्रिप्टेड अवस्था में “फ़्लोटिंग-पॉइंट संख्याओं की अनुमानित गणना” का समर्थन करता है। यह वास्तविक संख्या गणनाओं में भारी प्रदर्शन प्रदान करता है जहां छोटी त्रुटियां स्वीकार्य हैं, जैसे तंत्रिका नेटवर्क (neural networks) का प्रशिक्षण और अनुमान।

नीचे दी गई तालिका उद्देश्य के अनुसार योजनाओं को चुनने का सारांश देती है:

योजना का नाम	डेटा प्रकार	अनुशंसित उपयोग के मामले	विशेषताएँ
BFV / BGV	पूर्णांक (Integer)	सटीक सांख्यिकीय गणना, वित्तीय डेटा एकत्रीकरण, DB खोज	SIMD बैचिंग के माध्यम से उच्च थ्रूपुट
CKKS	वास्तविक संख्या (Real/Complex)	मशीन लर्निंग (DNN, लॉजिस्टिक रिग्रेशन), सिग्नल प्रोसेसिंग	अनुमानित गणना के माध्यम से त्वरण, रीस्केलिंग
TFHE	बूलियन (Boolean)	मनमाना तार्किक सर्किट, स्ट्रिंग खोज, गैर-रेखीय फ़ंक्शन मूल्यांकन	अल्ट्रा-फास्ट बूटस्ट्रैपिंग (मिलीसेकंड स्तर)

6. व्यवहार में: FHE लाइब्रेरी और वैचारिक कोड

आजकल, कई ओपन-सोर्स लाइब्रेरी उपलब्ध हैं जो आपको क्रिप्टोग्राफी के गहरे ज्ञान के बिना FHE का उपयोग करने की अनुमति देती हैं।

Microsoft SEAL (Simple Encrypted Arithmetic Library): BFV, BGV और CKKS का समर्थन करने वाली एक C++ लाइब्रेरी। उद्योग के मानकों में से एक। इसका पायथन बाइंडिंग, TenSEAL, AI इंजीनियरों के बीच बहुत लोकप्रिय है।
Zama (Concrete): TFHE पर आधारित एक फ्रेमवर्क। इसे रस्ट/पायथन (Rust/Python) में लिखा जा सकता है और यह मौजूदा PyTorch मॉडल को संकलित (compile) करने और उन्हें FHE (Concrete ML) पर चलाने की सुविधा प्रदान करता है।
OpenFHE: PALISADE का उत्तराधिकारी, एक व्यापक C++ लाइब्रेरी जो सभी प्रमुख योजनाओं का समर्थन करती है।

पायथन (TenSEAL) का उपयोग करते हुए FHE प्रोग्रामिंग का उदाहरण

यहां एक वैचारिक पायथन कोड का उदाहरण दिया गया है जो CKKS योजना का उपयोग करके वास्तविक संख्या वैक्टरों को एन्क्रिप्टेड अवस्था में जोड़ने और गुणा करने को दर्शाता है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import tenseal as ts

# 1. संदर्भ सेटअप (कुंजी पीढ़ी सहित)
# CKKS योजना का उपयोग करें, और बहुपद की डिग्री को 8192 पर सेट करें
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # वास्तविक संख्याओं के लिए स्केलिंग कारक

# 2. क्लाइंट पक्ष: डेटा एन्क्रिप्शन
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# प्लेनटेक्स्ट वेक्टर को सिफरटेक्स्ट में बदलें (मूल रूप से क्लाइंट साइड पर निष्पादित)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. सर्वर पक्ष: एन्क्रिप्टेड अवस्था में गणना (Data in Use की सुरक्षा)
# सर्वर प्लेनटेक्स्ट को नहीं जानता है, लेकिन जोड़ और गुणा कर सकता है
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. क्लाइंट पक्ष: परिणाम डिक्रिप्शन
# केवल निजी कुंजी वाला क्लाइंट ही परिणाम देख सकता है
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"डिक्रिप्टेड जोड़ परिणाम: {res_add}")
# आउटपुट उदाहरण: [3.5000001, 5.5000001, 7.5000002] (अनुमानित गणना के कारण छोटी त्रुटियां शामिल हैं)

print(f"डिक्रिप्टेड गुणा परिणाम: {res_mul}")
# आउटपुट उदाहरण: [3.0000002, 7.5000005, 14.0000003]

जैसा कि आप उपरोक्त कोड से देख सकते हैं, आप enc_v1 + enc_v2 जैसे नियमित पायथन ऑपरेटरों को ओवरलोड कर सकते हैं, जिससे आप सहज रूप से सिफरटेक्स्ट के बीच गणना लिख सकते हैं। सर्वर पक्ष पर, वेक्टर गणना वेक्टर की सामग्री को जाने बिना पूरी हो जाती है।

7. FHE की चुनौतियाँ: प्रदर्शन और हार्डवेयर त्वरण (Hardware Acceleration)

यद्यपि FHE सैद्धांतिक रूप से पूर्ण सुरक्षा प्रदान करता है, व्यावहारिक अनुप्रयोग में सबसे बड़ी चुनौती “प्रदर्शन ओवरहेड (Performance Overhead)” है।

कम्प्यूटेशनल ओवरहेड: प्लेनटेक्स्ट में गणना की तुलना में, सीपीयू पर सिफरटेक्स्ट में गणना हजारों से दसियों हजार गुना धीमी होती है। बहुपद गुणा और बूटस्ट्रैपिंग के लिए भारी मात्रा में FFT (फास्ट फूरियर ट्रांसफॉर्म) और NTT (नंबर थ्योरेटिक ट्रांसफॉर्म) गणनाओं की आवश्यकता होती है।
डेटा आकार का विस्तार (Ciphertext Expansion): कुछ बाइट्स का प्लेनटेक्स्ट एन्क्रिप्ट होने पर कई मेगाबाइट का हो सकता है। यह मेमोरी बैंडविड्थ और नेटवर्क बैंडविड्थ पर बहुत अधिक दबाव डालता है।

हार्डवेयर-आधारित समाधान का दृष्टिकोण

इस ओवरहेड को दूर करने के लिए, दुनिया भर में FHE-विशिष्ट हार्डवेयर त्वरक (ASIC, FPGA, GPU समर्थन) विकसित किए जा रहे हैं।

GPU त्वरण (GPU Acceleration): NVIDIA जैसे शक्तिशाली GPU का उपयोग करके NTT गणनाओं और बूटस्ट्रैपिंग को समानांतर करने के प्रयास चल रहे हैं, जिसमें सॉफ्टवेयर कार्यान्वयन की तुलना में दसियों गुना गति में वृद्धि की सूचना है (उदाहरण: 100x.ai, Zama का TFHE-rs CUDA बैकएंड)।
DARPA DPRIVE प्रोजेक्ट: US डिफेंस एडवांस्ड रिसर्च प्रोजेक्ट्स एजेंसी (DARPA) “DPRIVE (Data Protection in Virtual Environments)” नामक एक समर्पित हार्डवेयर विकास परियोजना चला रही है, जिसका उद्देश्य FHE की गणना गति को प्लेनटेक्स्ट प्रोसेसिंग गति (10 गुना के ओवरहेड के भीतर) के बराबर स्तर तक बढ़ाना है, जिसमें इंटेल (Intel), माइक्रोसॉफ्ट (Microsoft), और इंटेलेक्चुअल वेंचर्स (Intellectual Ventures) भाग ले रहे हैं।
FPU (FHE Processing Unit) का आगमन: कॉर्नमी (Cornami) और ऑप्टालिसिस (Optalysys) जैसे स्टार्टअप ऑप्टिकल कंप्यूटिंग और विशेष सिलिकॉन आर्किटेक्चर का उपयोग करके समर्पित FHE चिप्स विकसित कर रहे हैं।

निकट भविष्य में, ऐसा समय आ सकता है जब AI में NPU (Neural Processing Unit) की तरह सर्वर और क्लाउड इन्फ्रास्ट्रक्चर में “FPU” मानक उपकरण के रूप में स्थापित हो जाएंगे।

8. अपेक्षित उपयोग के मामले (Expected Use Cases)

अब जब FHE व्यावहारिक गति तक पहुँच रहा है, तो निम्नलिखित क्षेत्रों में विनाशकारी नवाचारों (disruptive innovations) की उम्मीद है:

चिकित्सा और जीनोमिक विश्लेषण में गोपनीयता संरक्षण: विभिन्न अस्पतालों से रोगियों के मेडिकल रिकॉर्ड और डीएनए डेटा को FHE का उपयोग करके एन्क्रिप्टेड अवस्था में क्लाउड AI द्वारा प्रशिक्षित किया जा सकता है, जो गोपनीयता कानूनों (जैसे HIPAA और GDPR) का उल्लंघन किए बिना अत्यधिक सटीक कैंसर निदान मॉडल और नई दवा के विकास को सक्षम करता है।
वित्तीय संस्थानों में धोखाधड़ी का पता लगाना और एंटी-मनी लॉन्ड्रिंग (AML): प्रतिस्पर्धी बैंक ग्राहकों के खाते की जानकारी और लेन-देन के इतिहास को प्रकट किए बिना, एन्क्रिप्टेड अवस्था में एक-दूसरे के डेटा को क्रॉस-चेक कर सकते हैं, जिससे विशाल धन शोधन नेटवर्क का पता लगाने के लिए क्रॉस-बैंक विश्लेषण संभव हो जाता है।
सुरक्षित AI अनुमान API (MaaS: Model as a Service): उपयोगकर्ता अपनी आवाज़, चेहरे की छवियों और संकेतों (prompts) को एन्क्रिप्ट कर सकते हैं और उन्हें AI सेवाओं (जैसे कि ChatGPT जैसे LLM) में भेज सकते हैं। AI प्रदाता उपयोगकर्ता के इनपुट को जाने बिना उत्तर उत्पन्न करते हैं और इसे सिफरटेक्स्ट के रूप में वापस करते हैं। यह “AI द्वारा व्यक्तिगत जानकारी सीखने या झाँकने” की चिंताओं को पूरी तरह से दूर करता है।

9. निष्कर्ष: क्रिप्टोग्राफी का भविष्य “अदृश्य गणना (Invisible Computing)” की ओर

जिस तरह 1970 के दशक में सार्वजनिक कुंजी एन्क्रिप्शन (RSA) के आविष्कार ने इंटरनेट पर सुरक्षित संचार (जैसे HTTPS) को संभव बनाया, उसी तरह क्रेग जेंट्री द्वारा FHE का आविष्कार क्रिप्टोग्राफी के इतिहास में सबसे महत्वपूर्ण मील के पत्थरों में से एक है।

वर्तमान में, पूर्ण समरूप एन्क्रिप्शन (FHE) प्रयोगशाला के सिद्धांत से बाहर आ गया है और ऐसे चरण में प्रवेश कर गया है जहां Microsoft, IBM, Intel, Google और कई स्टार्टअप इसे व्यावहारिक बनाने के लिए प्रतिस्पर्धा कर रहे हैं। हालांकि कम्प्यूटेशनल लागत और डेटा आकार की चुनौतियां अभी भी मौजूद हैं, एल्गोरिदम के शोधन और हार्डवेयर त्वरक के विकास के कारण, मूर के नियम (Moore’s Law) से अधिक गति से प्रदर्शन में सुधार जारी है।

कुछ ही वर्षों में, “एन्क्रिप्टेड रहने के दौरान डेटा की गणना करना” कोई विशेष बात नहीं होगी, बल्कि यह क्लाउड सेवाओं में एक मानक डेटा सुरक्षा सर्वोत्तम अभ्यास बन जाएगा। FHE अगली पीढ़ी की सुरक्षा का प्रमुख तत्व है, जो डेटा-संचालित समाज में परम गोपनीयता और डेटा उपयोग के बीच संतुलन को साकार करता है।

एलिप्टिक कर्व क्रिप्टोग्राफी (ECC) का गणितीय आधार और C++ में इसका कार्यान्वयन

Fri, 11 Sep 2026 10:00:00 +0900

एलिप्टिक कर्व क्रिप्टोग्राफी (ECC) का गणितीय आधार और C++ में इसका कार्यान्वयन

आधुनिक क्रिप्टोग्राफी में, एलिप्टिक कर्व क्रिप्टोग्राफी (Elliptic Curve Cryptography: ECC) अत्यंत महत्वपूर्ण भूमिका निभाती है। हमारे दैनिक इंटरनेट संचार (HTTPS/TLS) से लेकर, स्मार्टफोन के सुरक्षित एन्क्लेव, SSH के माध्यम से सर्वर प्रमाणीकरण, FIDO जैसे पासवर्ड रहित प्रमाणीकरण, और यहाँ तक कि बिटकॉइन और एथेरियम जैसी क्रिप्टो संपत्तियों तक, यह कहना अतिशयोक्ति नहीं होगी कि आधुनिक डिजिटल समाज का विश्वास आधार ECC द्वारा समर्थित है।

इस लेख में, हम विस्तार से समझाएंगे कि एलिप्टिक कर्व क्रिप्टोग्राफी कैसे काम करती है, इसके पीछे के सुंदर लेकिन जटिल गणितीय सिद्धांत (परिमित क्षेत्र पर बीजगणितीय ज्यामिति) से शुरू करते हुए, वास्तविक C++ का उपयोग करके कार्यान्वयन विधि, और यहां तक कि साइड-चैनल हमलों (टाइमिंग हमलों) को रोकने के लिए सुरक्षित कोडिंग तकनीक तक।

1. एलिप्टिक कर्व क्रिप्टोग्राफी क्यों? (RSA के साथ तुलना)

पब्लिक-की क्रिप्टोग्राफी का पर्याय लंबे समय से RSA एन्क्रिप्शन रहा है। RSA एन्क्रिप्शन अपनी सुरक्षा के आधार के रूप में “बड़े समग्र संख्याओं के अभाज्य गुणनखंडन की कठिनाई” पर निर्भर करता है। हालांकि, कंप्यूटर की गणना क्षमता में सुधार के साथ, सुरक्षा बनाए रखने के लिए RSA की कुंजी की लंबाई (मोडुलस के बिट्स की संख्या) को लगातार बढ़ाने की आवश्यकता उत्पन्न हुई है। वर्तमान में, कम से कम 2048 बिट्स, और अधिक सुरक्षित होने के लिए 3072 बिट्स या 4096 बिट्स की कुंजी की लंबाई की सिफारिश की जाती है।

इसके विपरीत, एलिप्टिक कर्व क्रिप्टोग्राफी (ECC) अपनी सुरक्षा के लिए “एलिप्टिक कर्व पर असतत लघुगणक समस्या (Discrete Logarithm Problem on Elliptic Curves - ECDLP)” नामक एक अलग गणितीय कठिनाई पर निर्भर करता है। ECDLP को हल करने के लिए आज तक कोई कुशल एल्गोरिदम (जैसे सब-एक्सपोनेंशियल टाइम एल्गोरिदम) नहीं खोजा जा सका है, और यहां तक कि ज्ञात सबसे कुशल हमले के तरीके भी घातांकीय (exponential) समय लेते हैं।

इस गुण के कारण, ECC का यह निर्णायक लाभ है कि यह बहुत छोटी कुंजी की लंबाई के साथ RSA के समान सुरक्षा शक्ति प्राप्त कर सकता है।

सुरक्षा शक्ति (बिट्स)	RSA एन्क्रिप्शन कुंजी की लंबाई (बिट्स)	एलिप्टिक कर्व क्रिप्टोग्राफी कुंजी की लंबाई (बिट्स)	कुंजी की लंबाई का अनुपात
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

जैसा कि ऊपर दी गई तालिका दिखाती है, 128-बिट सुरक्षा शक्ति (वर्तमान मानक शक्ति) प्राप्त करने के लिए, RSA को 3072-बिट कुंजी की आवश्यकता होती है, लेकिन ECC के साथ केवल 256 बिट्स की आवश्यकता होती है। इससे गणना को कम करना, मेमोरी के उपयोग को कम करना और नेटवर्क बैंडविड्थ को सहेजना संभव हो जाता है, जिससे यह विशेष रूप से सीमित संसाधनों वाले IoT उपकरणों और स्मार्ट कार्ड वातावरण में अत्यधिक फायदेमंद हो जाता है।

2. गणितीय तैयारी: समूह सिद्धांत (Group Theory) और परिमित क्षेत्र (Finite Fields) की दुनिया

एलिप्टिक कर्व क्रिप्टोग्राफी को वास्तव में समझने के लिए, सार बीजगणित (समूह सिद्धांत और क्षेत्र सिद्धांत) की बुनियादी अवधारणाओं को समझना आवश्यक है। यहाँ हम ECC के निर्माण के लिए आवश्यक पूर्वज्ञान का संक्षेप में सारांश दे रहे हैं।

2.1. समूह (Group) और एबेलियन समूह (Abelian Group)

समूह (Group) एक सेट $G$ और उस सेट पर एक बाइनरी ऑपरेशन (यहाँ हम जोड़ $+$ मानेंगे) का संयोजन $(G, +)$ है, जो निम्नलिखित 4 स्वयंसिद्धों (axioms) को पूरा करता है।

संवृतता (Closure): किन्हीं $a, b \in G$ के लिए, $a + b \in G$ होता है।
साहचर्य (Associativity): किन्हीं $a, b, c \in G$ के लिए, $(a + b) + c = a + (b + c)$ लागू होता है।
तत्समक अवयव का अस्तित्व (Identity element): किसी भी $a \in G$ के लिए, एक ऐसा अवयव $e \in G$ मौजूद होता है कि $a + e = e + a = a$। एक योगात्मक समूह (additive group) के मामले में, इस तत्समक अवयव को आमतौर पर $0$ या $\mathcal{O}$ के रूप में दर्शाया जाता है।
प्रतिलोम अवयव का अस्तित्व (Inverse element): किसी भी $a \in G$ के लिए, एक ऐसा अवयव $b \in G$ मौजूद होता है कि $a + b = b + a = e$। इस $b$ को $-a$ के रूप में दर्शाया जाता है।

इसके अलावा, एक समूह जिसमें संक्रियाओं के क्रम को बदलने से परिणाम नहीं बदलता है, अर्थात जो निम्नलिखित शर्त को पूरा करता है, उसे एबेलियन समूह (Abelian group या क्रमविनिमेय समूह) कहा जाता है।

क्रमविनिमेयता (Commutativity): किन्हीं $a, b \in G$ के लिए, $a + b = b + a$ लागू होता है।

एलिप्टिक कर्व पर बिंदुओं का सेट, एक विशिष्ट जोड़ नियम को परिभाषित करके, इस एबेलियन समूह का निर्माण करता है।

2.2. परिमित क्षेत्र (Finite Field)

क्रिप्टोग्राफी में, हम वास्तविक या सम्मिश्र संख्याओं जैसे निरंतर और असीम अवयवों वाले क्षेत्रों के बजाय परिमित क्षेत्र (Finite Field) या गैलवा क्षेत्र (Galois Field) का उपयोग करते हैं, जिनमें अवयवों की संख्या परिमित होती है।

सबसे बुनियादी परिमित क्षेत्र अभाज्य संख्या $p$ का उपयोग करने वाला अभाज्य क्षेत्र (Prime Field) $\mathbb{F}_p$ है। यह पूर्णांकों के सेट $\{0, 1, 2, \dots, p-1\}$ पर मॉड्यूलो $p$ (अर्थात $p$ से विभाजित करने पर शेषफल) के अंतर्गत चार बुनियादी अंकगणितीय संक्रियाओं (जोड़, घटाव, गुणा, भाग) को परिभाषित करता है।

जोड़: $(a + b) \pmod p$
घटाव: $(a - b) \pmod p$
गुणा: $(a \times b) \pmod p$
भाग: $a \times b^{-1} \pmod p$ (जहाँ $b^{-1}$ मॉड्यूलो $p$ के तहत $b$ का गुणनात्मक प्रतिलोम है)

गुणनात्मक प्रतिलोम (Modular Multiplicative Inverse) की गणना क्रिप्टोग्राफ़िक कार्यान्वयन में बहुत महत्वपूर्ण है। $b \times b^{-1} \equiv 1 \pmod p$ को संतुष्ट करने वाले $b^{-1}$ को खोजने के लिए मुख्य रूप से निम्नलिखित दो एल्गोरिदम का उपयोग किया जाता है।

विस्तारित यूक्लिडियन एल्गोरिदम (Extended Euclidean Algorithm): यह तेज़ है, लेकिन कार्यान्वयन के आधार पर, प्रसंस्करण समय इनपुट मान पर निर्भर कर सकता है, जिससे टाइमिंग हमलों का जोखिम होता है।
फ़र्मेट का छोटा प्रमेय (Fermat’s Little Theorem): जब $p$ एक अभाज्य संख्या है और $b \neq 0$ है, तो $b^{p-1} \equiv 1 \pmod p$ लागू होता है। दोनों पक्षों को $b$ से विभाजित करने पर, हमें $b^{p-2} \equiv b^{-1} \pmod p$ मिलता है। दूसरे शब्दों में, $b$ की घात $p-2$ की गणना करके प्रतिलोम पाया जा सकता है। चूंकि घातांकीकरण (exponentiation) को निरंतर समय (constant time) में लागू करना आसान होता है, इसलिए क्रिप्टोग्राफ़िक कार्यान्वयन में इसे प्राथमिकता दी जाती है।

3. एलिप्टिक कर्व के समीकरण और ज्यामिति

3.1. वियरस्ट्रास का सामान्य रूप (Weierstrass Normal Form)

एलिप्टिक कर्व (Elliptic Curve) आम तौर पर एक समतलीय वक्र (plane curve) होता है जिसे निम्नलिखित वियरस्ट्रास के सामान्य रूप (Weierstrass normal form) नामक समीकरण द्वारा परिभाषित किया जाता है।

$$ y^2 = x^3 + ax + b $$

यहाँ, $a$ और $b$ स्थिरांक हैं, और इस शर्त के रूप में कि वक्र में कोई एकवचन बिंदु (singular points जैसे स्व-प्रतिच्छेदन या कस्प) न हो (अर्थात यह एक चिकना वक्र हो), यह आवश्यक है कि निम्नलिखित विविक्तकर (Discriminant) $\Delta$ शून्य न हो।

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

चूंकि एकवचन बिंदुओं वाले वक्र क्रिप्टोग्राफ़िक सुरक्षा से समझौता करते हैं, इसलिए गुणांक $a, b$ को हमेशा इस शर्त को पूरा करने के लिए चुना जाता है।

3.2. अनंत पर बिंदु (Point at Infinity)

एलिप्टिक कर्व को गणितीय रूप से पूर्ण समूह बनाने के लिए, हम समतल के बिंदुओं के अलावा “अनंत पर बिंदु (Point at Infinity)” नामक एक आभासी बिंदु पेश करते हैं। इसे $\mathcal{O}$ (ओ) के रूप में दर्शाया जाता है।

अनंत पर बिंदु $\mathcal{O}$ को उस बिंदु के रूप में परिभाषित किया गया है जहाँ सभी ऊर्ध्वाधर रेखाएँ अनंत में प्रतिच्छेद करती हैं। समूह सिद्धांत में, यह अनंत पर बिंदु $\mathcal{O}$ जोड़ के तहत तत्समक अवयव (शून्य) के रूप में कार्य करता है।

अर्थात, वक्र पर किसी भी बिंदु $P$ के लिए, निम्नलिखित लागू होता है।

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

इसके अलावा, बिंदु $P = (x, y)$ का प्रतिलोम $-P$, x-अक्ष के सममित बिंदु $(x, -y)$ के रूप में परिभाषित किया गया है। इसलिए:

$$ P + (-P) = \mathcal{O} $$

होता है।

4. एलिप्टिक कर्व पर समूह संचालन (बिंदु जोड़ और दोहरीकरण)

एलिप्टिक कर्व क्रिप्टोग्राफी का मूल वक्र पर बिंदुओं के बीच “जोड़ (Addition)” का संचालन है। यह सामान्य पूर्णांकों के जोड़ से अलग है और ज्यामितीय संचालन के आधार पर परिभाषित किया गया है।

4.1. ज्यामितीय जोड़ (Tangent and Chord Method)

वक्र पर दो अलग-अलग बिंदुओं $P$ और $Q$ को जोड़कर एक नया बिंदु $R$ ($R = P + Q$) खोजने की प्रक्रिया इस प्रकार है।

बिंदु $P$ और बिंदु $Q$ से गुजरने वाली एक रेखा (जीवा/chord) खींचें।
यह रेखा हमेशा एलिप्टिक कर्व को एक और बिंदु पर प्रतिच्छेद करेगी (आइए इसे $-R$ कहें)। (*बीजगणितीय ज्यामिति के एक प्रमेय के अनुसार)
प्रतिच्छेदन बिंदु $-R$ को x-अक्ष पर प्रतिबिंबित करने (y-निर्देशांक के चिह्न को उलटने) से प्राप्त बिंदु, वांछित बिंदु $R$ है।

graph TD Step1["P(x1, y1) और Q(x2, y2) को जोड़ने वाली एक रेखा खींचें"] --> Step2["वक्र के साथ तीसरे प्रतिच्छेदन बिंदु -R को खोजें"] Step2 --> Step3["-R को x-अक्ष पर प्रतिबिंबित करें और R(x3, y3) प्राप्त करें"] Step3 -.-> Result["यह R = P + Q है"]

4.2. बिंदु का दोहरीकरण (Point Doubling)

जब एक ही बिंदु $P$ को बिंदु $P$ में जोड़ा जाता है ($P + P = 2P$), तो दो बिंदुओं से गुजरने वाली रेखा खींचना संभव नहीं है। इस मामले में, हम बिंदु $P$ पर वक्र की स्पर्शरेखा (Tangent) खींचते हैं।

बिंदु $P$ पर वक्र की स्पर्शरेखा खींचें।
यह स्पर्शरेखा वक्र को एक अन्य बिंदु $-R$ पर प्रतिच्छेद करती है।
प्रतिच्छेदन बिंदु को x-अक्ष पर प्रतिबिंबित करने से प्राप्त बिंदु वांछित बिंदु $R = 2P$ है।

4.3. बीजगणितीय गणना सूत्र

ज्यामितीय संक्रियाओं को बीजगणितीय सूत्रों में बदला जाता है ताकि कंप्यूटर द्वारा उनकी गणना की जा सके। सभी गणनाएँ परिमित क्षेत्र $\mathbb{F}_p$ (मॉड्यूलो $p$) पर की जाती हैं।

मान लें कि बिंदु $P = (x_1, y_1)$ और बिंदु $Q = (x_2, y_2)$ हैं। यह भी मान लें कि गणना के परिणाम का बिंदु $R = P + Q = (x_3, y_3)$ है।

मान लें कि रेखा का ढलान $\lambda$ (लैम्ब्डा) है।

【स्थिति 1: $P \neq Q$ होने पर (बिंदु जोड़)】 ढलान $\lambda$ दो बिंदुओं के बीच परिवर्तन की दर है।

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

इस $\lambda$ का उपयोग करके, $x_3, y_3$ निम्न प्रकार से ज्ञात किए जा सकते हैं।

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

【स्थिति 2: $P = Q$ होने पर (बिंदु का दोहरीकरण)】 ढलान $\lambda$ स्पर्शरेखा का ढलान है जिसे अवकलन (differentiation) द्वारा पाया जाता है। (हम $y^2 = x^3 + ax + b$ का अंतर्निहित अवकलन करते हैं)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

इसलिए,

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

$x_3, y_3$ के समीकरण जोड़ के समान रूप में हैं, लेकिन चूँकि $x_2 = x_1$ है, इसलिए वे निम्न प्रकार हो जाते हैं।

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] इन सूत्रों में $(x_2 - x_1)^{-1}$ और $(2y_1)^{-1}$ जैसे विभाजन (मॉड्यूलर प्रतिलोम की गणना) शामिल हैं। मॉड्यूलर प्रतिलोम की गणना की कम्प्यूटेशनल लागत बहुत अधिक होती है, इसलिए वास्तविक कार्यान्वयन में, “जैकोबियन कोऑर्डिनेट्स (Jacobian Coordinates)” जैसी प्रक्षेपीय समन्वय प्रणालियों (projective coordinate systems) का आमतौर पर उपयोग किया जाता है जो विभाजन को विलंबित करते हैं।

5. अदिश गुणन (Scalar Multiplication) और एलिप्टिक कर्व असतत लघुगणक समस्या (ECDLP)

एलिप्टिक कर्व क्रिप्टोग्राफी में, वह संक्रिया जिसमें सबसे अधिक गणना की आवश्यकता होती है और जो सुरक्षा का मूल है, वह अदिश गुणन (Scalar Multiplication) है।

5.1. अदिश गुणन क्या है?

किसी बिंदु $P$ को $k$ बार जोड़ने की क्रिया को अदिश गुणन कहा जाता है, और इसे $kP$ के रूप में दर्शाया जाता है।

$$ kP = \underbrace{P + P + \dots + P}_{k\text{ बार}} $$

यहाँ, $k$ एक बहुत बड़ा पूर्णांक है (उदाहरण के लिए, 256-बिट पूर्णांक)।

5.2. एलिप्टिक कर्व असतत लघुगणक समस्या (ECDLP)

एलिप्टिक कर्व क्रिप्टोग्राफी की सुरक्षा निम्नलिखित समस्या की कठिनाई पर निर्भर करती है।

एलिप्टिक कर्व असतत लघुगणक समस्या (Elliptic Curve Discrete Logarithm Problem: ECDLP) एक ज्ञात बिंदु $P$ (आधार बिंदु) और एक गणना किए गए परिणामी बिंदु $Q$ को देखते हुए, अदिश (scalar) $k$ खोजें जो $Q = kP$ को संतुष्ट करता हो।

$k$ और $P$ से $Q$ की गणना करना (आगे की दिशा) बाद में वर्णित एल्गोरिदम का उपयोग करके आसान (बहुपद समय) है, लेकिन $P$ और $Q$ से $k$ की उल्टी गणना (विपरीत दिशा) करना लगभग असंभव है (यह एक वन-वे फ़ंक्शन है), सिवाय ब्रूट-फोर्स खोज के इसके लिए कोई कुशल समाधान नहीं है। क्रिप्टोग्राफ़िक प्रोटोकॉल में, $k$ “निजी कुंजी (Private Key)” से मेल खाता है, और $Q$ “सार्वजनिक कुंजी (Public Key)” से मेल खाता है।

5.3. डबल-एंड-ऐड (Double-and-Add) एल्गोरिदम

यदि $k$ एक विशाल संख्या है (उदा: $2^{256}$), तो $P$ को सीधे $k$ बार जोड़ना ब्रह्मांड के जीवनकाल में भी पूरा नहीं होगा। इसलिए, अदिश गुणन को तेज़ी से करने के लिए डबल-एंड-ऐड विधि (Double-and-Add method या बाइनरी विधि) का उपयोग किया जाता है।

यह पूर्णांकों के घातांकीकरण को तेज़ी से गणना करने के लिए “स्क्वेयर-एंड-मल्टीप्लाई (square-and-multiply)” विधि का एलिप्टिक कर्व संस्करण है। यह अदिश $k$ को बाइनरी में दर्शाता है और सबसे महत्वपूर्ण बिट (MSB) से शुरू करके क्रमिक रूप से संसाधित करता है।

परिणाम को संग्रहीत करने के लिए बिंदु $R$ को $\mathcal{O}$ से प्रारंभ करें।
$k$ के सबसे महत्वपूर्ण बिट (MSB) से सबसे कम महत्वपूर्ण बिट (LSB) तक निम्न को दोहराएं:
- $R$ को दोगुना करें (Point Doubling: $R = 2R$)
- यदि वर्तमान बिट 1 है, तो $R$ में $P$ जोड़ें (Point Addition: $R = R + P$)

इस एल्गोरिदम के माध्यम से, कम्प्यूटेशनल जटिलता $O(k)$ से $O(\log_2 k)$ तक नाटकीय रूप से कम हो जाती है, जिससे यथार्थवादी समय (मिलीसेकंड में) में गणना संभव हो जाती है।

6. एलिप्टिक कर्व डिफी-हेलमैन (ECDH) कुंजी विनिमय (Key Exchange)

यहाँ हम ECDH (Elliptic Curve Diffie-Hellman) कुंजी विनिमय प्रोटोकॉल के तंत्र की व्याख्या करेंगे, जो ECC का सबसे विशिष्ट अनुप्रयोग है। ECDH ऐलिस और बॉब को एक असुरक्षित संचार चैनल पर सुरक्षित रूप से एक सामान्य गुप्त कुंजी (सत्र कुंजी/session key) उत्पन्न करने और साझा करने की अनुमति देता है (यह TLS हैंडशेक का मूल है)।

【पूर्वापेक्षित पैरामीटर (डोमेन पैरामीटर)】 दोनों पक्ष पहले से उपयोग किए जाने वाले एलिप्टिक कर्व $E$, अभाज्य संख्या $p$, और आधार बिंदु $G$ को साझा करते हैं। (उदाहरण के लिए NIST P-256 या secp256k1 आदि)

sequenceDiagram participant Alice as "Alice (ऐलिस)" participant Bob as "Bob (बॉब)" Note over Alice,Bob: "सार्वजनिक पैरामीटर: वक्र E, आधार बिंदु G, अभाज्य संख्या p" Alice->>Alice: "निजी कुंजी d_A (एक यादृच्छिक पूर्णांक) उत्पन्न करें" Alice->>Alice: "सार्वजनिक कुंजी Q_A = d_A * G की गणना करें" Bob->>Bob: "निजी कुंजी d_B (एक यादृच्छिक पूर्णांक) उत्पन्न करें" Bob->>Bob: "सार्वजनिक कुंजी Q_B = d_B * G की गणना करें" Alice->>Bob: "सार्वजनिक कुंजी Q_A भेजें (प्लेनटेक्स्ट में)" Bob->>Alice: "सार्वजनिक कुंजी Q_B भेजें (प्लेनटेक्स्ट में)" Alice->>Alice: "साझा रहस्य S = d_A * Q_B की गणना करें" Bob->>Bob: "साझा रहस्य S = d_B * Q_A की गणना करें" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "दोनों पक्षों द्वारा गणना किया गया परिणाम S पूरी तरह से मेल खाता है!"

एक छिपकर बातें सुनने वाला (ईव) संचार चैनल पर प्रवाहित होने वाले $G$, $Q_A$, $Q_B$ को रोक सकता है, लेकिन ECDLP की कठिनाई के कारण, वह $Q_A = d_A \cdot G$ से ऐलिस की निजी कुंजी $d_A$ का पता नहीं लगा सकता है। इसके अलावा, $Q_A$ और $Q_B$ को गुणा करने से साझा कुंजी $S$ नहीं मिलती है, इसलिए छिपकर बातें सुनने वाला $S$ की गणना नहीं कर सकता।

7. कार्यान्वयन की कमियां: साइड-चैनल हमले और उपाय

भले ही एक क्रिप्टोग्राफ़िक एल्गोरिदम सैद्धांतिक रूप से परिपूर्ण हो, लेकिन इसे एक प्रोग्राम के रूप में लागू करने की प्रक्रिया में कमियां उत्पन्न हो सकती हैं। इसे “साइड-चैनल अटैक (Side-Channel Attack)” कहा जाता है।

7.1. टाइमिंग अटैक (Timing Attack)

आइए पहले बताए गए डबल-एंड-ऐड (Double-and-Add) एल्गोरिदम को फिर से देखें।

1
2
3
4
5
6
7
8


// असुरक्षित डबल-एंड-ऐड का छद्म कोड (pseudocode)
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // हमेशा निष्पादित होता है
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // केवल तभी निष्पादित होता है जब बिट 1 हो!
 }
}

इस कार्यान्वयन में एक घातक खामी है। जब बिट 1 होता है, तो पॉइंट एडिशन निष्पादित होता है, इसलिए गणना का समय थोड़ा लंबा हो जाता है तुलना में जब बिट 0 होता है। इसके अतिरिक्त, प्रोसेसर की शाखा भविष्यवाणी (branch prediction) और कैश मेमोरी व्यवहार भी बदल जाते हैं। हमलावर इस गणना समय (या बिजली की खपत) में मिनट के अंतर को हजारों बार सांख्यिकीय रूप से देखकर निजी कुंजी $k$ के बिट अनुक्रम को बिट दर बिट पूरी तरह से पुनर्प्राप्त कर सकता है। यही टाइमिंग अटैक है।

7.2. निरंतर-समय (Constant-Time) कार्यान्वयन: मोंटगोमेरी लैडर (Montgomery Ladder)

टाइमिंग हमलों को रोकने के लिए, ऐसे एल्गोरिदम को अपनाना आवश्यक है जहाँ निष्पादित निर्देशों का अनुक्रम और गणना का समय हमेशा स्थिर (Constant-Time) होता है, चाहे निजी कुंजी का बिट मान कुछ भी हो।

इसका एक प्रमुख उदाहरण मोंटगोमेरी लैडर (Montgomery Ladder) है।

graph TD Start["आरंभीकरण: R0 = O, R1 = P"] --> LoopStart["प्रत्येक बिट i के लिए (MSB से)"] LoopStart --> Cond{"k_i का मान क्या है?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["अगले बिट पर जाएं"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"सभी बिट्स पूरे हुए"| End["अंत: R0 परिणाम (kP) है"]

मोंटगोमेरी लैडर की सुंदरता इस बात में है कि चाहे बिट 0 हो या 1, “हमेशा एक पॉइंट एडिशन और एक पॉइंट डबलिंग” निष्पादित की जाती है। यह गणना समय की डेटा निर्भरता को पूरी तरह से समाप्त कर देता है।

हालाँकि, यदि कोई शाखा (branch) (if (k_i == 0)) स्वयं मौजूद है, तो यह जोखिम रहता है कि निष्पादन समय कंपाइलर अनुकूलन और CPU की शाखा भविष्यवाणी के कारण भिन्न हो सकता है। इसलिए, वास्तविक निरंतर-समय के कार्यान्वयन में, सशर्त शाखाओं (if कथन) को समाप्त कर दिया जाता है और बिटवाइज़ संचालन (bitwise operations) का उपयोग करके एक सशर्त स्वैप (Conditional Swap) का उपयोग किया जाता है।

8. C++ का उपयोग करके एलिप्टिक कर्व क्रिप्टोग्राफी का कार्यान्वयन

यहाँ से, हम सिद्धांत को C++ कोड में बदलेंगे। व्यावहारिक क्रिप्टोग्राफ़िक लाइब्रेरी (जैसे OpenSSL या libsodium) उन्नत असेंबली अनुकूलन और जैकोबियन निर्देशांक का उपयोग करती हैं, लेकिन यहाँ, गणितीय समझ को गहरा करने के लिए, हम एफाइन निर्देशांक (Affine Coordinates) का उपयोग करके आसानी से समझे जाने वाले निरंतर-समय कार्यान्वयन की रूपरेखा दिखाएंगे।

हम यह मानेंगे कि बड़े पूर्णांक संचालन के लिए boost::multiprecision::cpp_int का उपयोग किया जाता है।

8.1. मॉड्यूलर अंकगणित और प्रतिलोम

सबसे पहले, हम परिमित क्षेत्र पर संचालन के लिए सहायक कार्यों को परिभाषित करते हैं। हम फ़र्मेट के छोटे प्रमेय (Fermat’s Little Theorem) का उपयोग करके प्रतिलोम गणना को लागू करेंगे।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// उदाहरण के रूप में secp256k1 की अभाज्य संख्या p और पैरामीटर
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// धनात्मक शेषफल लौटाने वाला मॉड्यूलो ऑपरेशन
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// मॉड्यूलर घातांकीकरण (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// फ़र्मेट के छोटे प्रमेय का उपयोग करके मॉड्यूलर प्रतिलोम
cpp_int modInverse(cpp_int n, cpp_int m) {
 // यह मानकर कि m एक अभाज्य संख्या है: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. बिंदु प्रतिनिधित्व और समूह संचालन (जोड़ / दोहरीकरण)

हम अनंत पर बिंदु को प्रबंधित करने के लिए एक ध्वज (flag) के साथ एक Point संरचना, और जोड़ सूत्र को लागू करेंगे।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // अनंत पर बिंदु का निर्माण
 Point() : x(0), y(0), isInfinity(true) {}

 // सामान्य बिंदु का निर्माण
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// एलिप्टिक कर्व पर बिंदु जोड़ (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = अनंत पर बिंदु
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (P = Q होने पर)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (P != Q होने पर)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. निरंतर-समय (Constant-Time) सशर्त स्वैप (Conditional Swap) का कार्यान्वयन

निजी कुंजी के बिट मान के आधार पर चर (variables) की सामग्री की अदला-बदली करते समय, हम if कथन का उपयोग किए बिना केवल बिटवाइज़ संचालन (मास्क) का उपयोग करके स्वैप करते हैं। यह सुनिश्चित करता है कि निष्पादन पथ (execution path) पूरी तरह से स्थिर रहे।

[!TIP] वास्तविक कार्यान्वयन में, cpp_int जैसे गतिशील रूप से आवंटित बहु-सटीक (multi-precision) पूर्णांक वर्ग निरंतर-समय प्रसंस्करण के लिए उपयुक्त नहीं हैं। ऐसा इसलिए है क्योंकि मेमोरी आवंटन और सरणी आकार में भिन्नता के कारण टाइमिंग जानकारी लीक होती है। व्यावहारिक पुस्तकालयों में, उन्हें एक निश्चित लंबाई (उदाहरण के लिए, uint64_t का 4-तत्व सरणी) के साथ दर्शाया जाता है, और बिट-स्तरीय मास्किंग लागू की जाती है। निम्नलिखित एक वैचारिक उदाहरण है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// वैचारिक निरंतर-समय स्वैप (निश्चित लंबाई के पूर्णांक मानकर)
// यदि bit 1 है, तो P1 और P2 को स्वैप करें; यदि 0 है, तो स्वैप न करें
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit 0 या 1 है। यदि bit=1 है तो मास्क सभी 1 (0xFF..) है, और यदि 0 है तो सभी 0 है।
 // (स्पष्टीकरण के लिए, मान लें कि एक निश्चित लंबाई वाले BigInt वर्ग का प्रत्येक शब्द w है)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // y-निर्देशांक और isInfinity ध्वज को भी इसी तरह संसाधित करें
 }
 */

 // * boost::multiprecision के साथ पूर्ण निरंतर-समय स्वैप मुश्किल है,
 // इसलिए यहाँ तर्क को समझने के लिए हम केवल शाखाओं (branches) द्वारा इसका अनुकरण करते हैं।
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. मोंटगोमेरी लैडर (Montgomery Ladder) का उपयोग करके अदिश गुणन

सुरक्षित अदिश गुणन को लागू करने के लिए हम पहले बताए गए pointAdd और cswap को जोड़ते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// अदिश गुणन k * P (मोंटगोमेरी लैडर विधि)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // अनंत पर बिंदु
 Point R1 = P;

 // k की बिट लंबाई प्राप्त करें (secp256k1 के लिए 256 बिट्स)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // i-वें बिट का मान प्राप्त करें (0 या 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // यदि bit == 1, तो R0 और R1 को स्वैप करें
 cswap(R0, R1, bit);

 // हमेशा समान संक्रिया निष्पादित करें (पॉइंट एडिशन और पॉइंट डबलिंग)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // यदि bit == 1 था, तो स्थिति को पुनर्स्थापित करने के लिए फिर से स्वैप करें
 cswap(R0, R1, bit);
 }

 return R0;
}

इस कार्यान्वयन तर्क के साथ, चाहे अदिश $k$ का प्रत्येक बिट 0 हो या 1, प्रत्येक लूप पुनरावृत्ति (iteration) के भीतर निष्पादित संक्रियाएँ (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap) बिल्कुल एक ही प्रवाह का पालन करती हैं, जो समय या कैश एक्सेस पैटर्न में अंतर के माध्यम से गुप्त जानकारी के रिसाव को दृढ़ता से रोकता है।

9. निष्कर्ष

एलिप्टिक कर्व क्रिप्टोग्राफी (ECC), पहली नज़र में अजीब लग सकती है कि “क्यों रेखाएँ खींचने और प्रतिच्छेदनों को प्रतिबिंबित करने जैसी ज्यामितीय संक्रियाएँ एन्क्रिप्शन बन जाती हैं?"। हालाँकि, यह गणित और क्रिप्टोग्राफी के एक चमत्कारी संलयन का परिणाम है जो इसे परिमित क्षेत्र के असतत (discrete) दुनिया में मैप करके एक शानदार वन-वे फ़ंक्शन (असतत लघुगणक समस्या) बनाने की अनुमति देता है।

इस लेख में हमने निम्नलिखित महत्वपूर्ण बिंदुओं की व्याख्या की है:

RSA पर लाभ: बहुत छोटी कुंजी की लंबाई के साथ मजबूत सुरक्षा प्रदान करता है, जो इसे आधुनिक मोबाइल और IoT युग के लिए आदर्श बनाता है।
समूह सिद्धांत और परिमित क्षेत्रों की मूल बातें: गणितीय संरचना जो ECC की नींव बनाती है।
जोड़ और दोहरीकरण सूत्र: वियरस्ट्रास समीकरण का उपयोग करके बीजगणितीय समूह संचालन को लागू करने के तरीके।
साइड-चैनल हमलों का खतरा: कैसे निजी कुंजी के बिट्स पर निर्भर सशर्त शाखाएं (conditional branches) घातक कमियां पैदा करती हैं।
निरंतर-समय (Constant-Time) कार्यान्वयन: मोंटगोमेरी लैडर और सशर्त स्वैप (Conditional Swap) का उपयोग करके हार्डवेयर-स्तरीय व्यवहार को सुसंगत बनाने और हमलों को रोकने के लिए C++ कोडिंग तकनीक।

उत्पादन वातावरण (production environment) में काम करने वाली अपनी खुद की क्रिप्टोग्राफ़िक लाइब्रेरी बनाने को सुरक्षा जोखिमों के कारण अत्यधिक हतोत्साहित किया जाता है (“अपना खुद का क्रिप्टो न बनाएं”)। हालाँकि, हुड के नीचे काम करने वाले एल्गोरिदम और गणितीय पृष्ठभूमि की गहरी समझ होना, अधिक सुरक्षित और उच्च-प्रदर्शन प्रणाली को डिजाइन और संचालित करने वाले इंजीनियरों के लिए एक अमूल्य और शक्तिशाली हथियार होगा।

अगले लेख में, हम इस एलिप्टिक कर्व का उपयोग करने वाले डिजिटल हस्ताक्षर एल्गोरिदम ECDSA (Elliptic Curve Digital Signature Algorithm) के तंत्र, और बिटकॉइन में प्रयुक्त स्क्नोर (Schnorr) हस्ताक्षर के बारे में और गहराई से जानेंगे।

क्या GNFS (जनरल नंबर फील्ड सीव) से परे कोई एल्गोरिदम मौजूद है?

Fri, 11 Sep 2026 09:00:00 +0900

1. परिचय: पूर्णांक गुणनखंडन और आधुनिक क्रिप्टोग्राफी का आधार

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

वर्तमान में, क्लासिकल कंप्यूटर का उपयोग करके बड़े पूर्णांकों के गुणनखंडन के लिए सबसे तेज़ और सबसे शक्तिशाली एल्गोरिदम जनरल नंबर फील्ड सीव (GNFS: General Number Field Sieve) है। GNFS का जन्म 1980 के दशक के अंत में प्रस्तावित स्पेशल नंबर फील्ड सीव (SNFS) के विस्तार के रूप में हुआ था, और आज तक इसने RSA-768 और RSA-250 जैसी विशाल भाज्य संख्याओं के गुणनखंडन के रिकॉर्ड बनाए हैं।

हालाँकि, क्रिप्टोग्राफ़र और गणितज्ञ हमेशा निम्नलिखित प्रश्न पूछते हैं: “क्या GNFS से परे कोई क्लासिकल एल्गोरिदम मौजूद है?”, “क्लासिकल कंप्यूटर की सीमाएँ कहाँ हैं?”, और “क्वांटम कंप्यूटर इस स्थिति को कैसे तोड़ेंगे?”

इस लेख में, हम GNFS के पीछे की गहरी गणितीय संरचना का पूरी तरह से विश्लेषण करेंगे और बहुपद चयन (polynomial selection), सीविंग प्रक्रिया (sieving processing), और ब्लॉक वीडमैन (Block Wiedemann) विधि का उपयोग करके रैखिक बीजगणित (linear algebra) चरणों जैसे विस्तृत तकनीकी विश्लेषण करेंगे। इसके अलावा, हम कॉपरस्मिथ (Coppersmith) के सुधारों के माध्यम से GNFS की विस्तार विधियों पर विचार करेंगे, और गणितीय दृष्टिकोण से क्लासिकल सब-एक्सपोनेंशियल टाइम (Sub-exponential time) एल्गोरिदम और क्वांटम पॉलीनोमियल टाइम (Polynomial time) एल्गोरिदम के बीच महत्वपूर्ण अंतर की तुलना और व्याख्या करेंगे।

2. एसिम्प्टोटिक कॉम्प्लेक्सिटी और L-नोटेशन (L-notation)

गुणनखंडन एल्गोरिदम की जटिलता का मूल्यांकन करते समय, मानक पॉलीनोमियल टाइम नोटेशन ($O(n^k)$ आदि) के बजाय इनपुट $n$ के अंकों की संख्या के सापेक्ष सब-एक्सपोनेंशियल समय को व्यक्त करने के लिए L-नोटेशन (L-notation) का उपयोग किया जाता है। L-नोटेशन को इस प्रकार परिभाषित किया गया है:

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

जहाँ, $n$ वह पूर्णांक है जिसका गुणनखंड किया जाना है, और $\ln n$ प्राकृतिक लघुगणक (natural logarithm) है जो $n$ की बिट लंबाई के आनुपातिक है।

$\alpha = 0$ के मामले में: $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$ होता है, जो बिट लंबाई के सापेक्ष पॉलीनोमियल टाइम (Polynomial time) को दर्शाता है।
$\alpha = 1$ के मामले में: $L_n[1, c] = \exp(c \ln n) = n^c$ होता है, जो बिट लंबाई के सापेक्ष एक्सपोनेंशियल टाइम (Exponential time) को दर्शाता है।
$0 < \alpha < 1$ के मामले में: यह पॉलीनोमियल टाइम और एक्सपोनेंशियल टाइम के बीच स्थित सब-एक्सपोनेंशियल टाइम (Sub-exponential time) है।

अतीत में गुणनखंडन एल्गोरिदम का विकास धीरे-धीरे इस $\alpha$ के मान को कम करने का इतिहास रहा है।

कंटीन्यूड फ्रैक्शन मेथड (CFRAC) और मल्टीपल पॉलीनोमियल क्वाड्रेटिक सीव (MPQS): ये $\alpha = 1/2$ वर्ग से संबंधित हैं, और जटिलता लगभग $L_n[1/2, 1]$ है।
जनरल नंबर फील्ड सीव (GNFS): इसने $\alpha = 1/3$ हासिल किया, और वर्तमान में ज्ञात क्लासिकल एल्गोरिदम में सबसे तेज़ $L_n[1/3, (64/9)^{1/3}]$ की जटिलता का दावा करता है।

3. GNFS (जनरल नंबर फील्ड सीव) का संपूर्ण एल्गोरिदम और गणितीय संरचना

GNFS का गणितीय आधार बहुत ही जटिल और उन्नत है। मूल विचार फर्मेट के लिटिल थ्योरम (Fermat’s Little Theorem) और क्वाड्रेटिक सीव (QS) का विस्तार है, और सर्वांगसमता (congruence) $X^2 \equiv Y^2 \pmod n$ को संतुष्ट करने वाले और $X \not\equiv \pm Y \pmod n$ होने वाले गैर-तुच्छ (non-trivial) जोड़े $(X, Y)$ को खोजकर $n$ का गुणनखंड $\gcd(X-Y, n)$ प्राप्त करना है।

हालाँकि, GNFS का सार यह है कि यह केवल परिमेय संख्या क्षेत्र (rational number field) $\mathbb{Q}$ में ऐसा नहीं करता है, बल्कि एक साथ परिमेय संख्या क्षेत्र और बीजगणितीय संख्या क्षेत्र (Algebraic Number Field) नामक विस्तार क्षेत्र $\mathbb{Q}(\alpha)$ दोनों में “स्मूद नंबर्स (Smooth numbers)” की खोज करता है, और होमोमोर्फिज्म (homomorphism) के माध्यम से सर्वांगसम संबंध बनाता है।

GNFS की प्रक्रिया मोटे तौर पर 5 चरणों में विभाजित है।

graph TD A["गुणनखंडन समस्या (इनपुट n)"] --> B["1. बहुपद चयन (Polynomial Selection)"] B --> C["2. सीविंग प्रक्रिया (Sieving Phase)"] C --> D["3. फ़िल्टरिंग (Filtering Phase)"] D --> E["4. रैखिक बीजगणित (Linear Algebra Phase)"] E --> F["5. वर्गमूल (Square Root Phase)"] F --> G["अभाज्य गुणनखंड p, q का आउटपुट"]

3.1 चरण 1: बहुपद चयन (Polynomial Selection)

GNFS की सफलता बहुत हद तक उपयुक्त बहुपदों के चयन पर निर्भर करती है। लक्ष्य दो इरेड्यूसिबल बहुपदों (irreducible polynomials) $f_1(x)$ (परिमेय पक्ष) और $f_2(x)$ (बीजगणितीय पक्ष) को खोजना है जिनका एक उभयनिष्ठ मूल $m$ हो। अर्थात, $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$ को संतुष्ट करता हो।

आमतौर पर, परिमेय पक्ष के बहुपद के लिए 1-डिग्री व्यंजक $f_1(x) = x - m$ चुना जाता है, और बीजगणितीय पक्ष के बहुपद $f_2(x)$ के लिए डिग्री $d$ (आमतौर কাহিনী 5 या 6) का एक मोनिक बहुपद चुना जाता है। सबसे क्लासिकल दृष्टिकोण Base-$m$ विधि है। $n$ की घात $1/(d+1)$ के करीब एक पूर्णांक $m = \lfloor n^{1/(d+1)} \rfloor$ चुना जाता है, और $n$ का बेस-$m$ विस्तार किया जाता है। $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ इससे, हमें बहुपद $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$ प्राप्त होता है। स्पष्ट रूप से $f_2(m) = n \equiv 0 \pmod n$ होता है।

हालाँकि, आधुनिक कार्यान्वयन में Kleinjung का एल्गोरिदम उपयोग किया जाता है। यह बहुपदों के गुणांकों (coefficients) को अत्यधिक बड़ा होने से रोकता है (Skewness का अनुकूलन), बीजगणितीय गुणों (Murphy’s $E$ value और $\alpha$-value) को अनुकूलित करता है, और ऐसे बहुपदों की खोज करता है जो सीविंग प्रक्रिया में आसानी से स्मूद नंबर उत्पन्न करते हैं। अकेले इस चरण में बहुत सारे कम्प्यूटेशनल संसाधन लगाए जाते हैं।

3.2 चरण 2: सीविंग प्रक्रिया (Sieving Phase)

बहुपद निर्धारित होने के बाद, यह एल्गोरिदम के सबसे अधिक कम्प्यूटेशनल रूप से भारी “सीव (Sieving)” चरण में प्रवेश करता है। यहाँ, युग्म $(a, b)$ खोजा जाता है। यह युग्म को-प्राइम (coprime) होना चाहिए, और निम्नलिखित दो मानों का एक साथ “स्मूद (Smooth)” होना आवश्यक है:

परिमेय पक्ष का मानदंड (Norm on rational side): $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
बीजगणितीय पक्ष का मानदंड (Norm on algebraic side): $F_2(a, b) = b^d \cdot f_2(a/b)$

“स्मूद” होने का अर्थ है कि इसे केवल एक निर्दिष्ट ऊपरी सीमा (Sieve bound) या उससे छोटे अभाज्य संख्याओं द्वारा ही गुणनखंडित किया जा सकता है। परिमेय पक्ष के लिए एक फैक्टर बेस (Factor base) और बीजगणितीय पक्ष के लिए एक फैक्टर बेस तैयार किया जाता है, और इरेटोस्थनीज की छलनी (Sieve of Eratosthenes) की तरह एक विशाल खोज स्थान पर कुशलता से स्मूद नंबर खोजे जाते हैं। वर्तमान में, लैटिस सीविंग (Lattice Sieving) नामक तकनीक मुख्यधारा है, जहाँ एक विशिष्ट अभाज्य संख्या $q$ को तय किया जाता है, और केवल उस सब-लैटिस (sub-lattice) पर $(a, b)$ युग्मों को सीव किया जाता है जहाँ परिमेय और बीजगणितीय दोनों पक्ष $q$ के गुणज हों, जिससे अत्यधिक उच्च दक्षता प्राप्त होती है।

3.3 चरण 3: फ़िल्टरिंग (Filtering Phase)

सीविंग प्रक्रिया में पाए गए स्मूद संबंधों (रिलेशन) की संख्या करोड़ों या अरबों में होती है। हालाँकि, इनमें बहुत सारी बेकार जानकारी भी शामिल होती है। फ़िल्टरिंग का उद्देश्य एक विशाल विरल मैट्रिक्स (Sparse Matrix) का निर्माण करना है और साथ ही इसके आयाम (dimension) को जितना संभव हो उतना छोटा करना है।

विशेष रूप से, निम्नलिखित ऑपरेशन किए जाते हैं:

Singleton removal: उन रिलेशन को हटा दें जिनमें केवल एक बार आने वाला अभाज्य गुणनखंड शामिल हो।
Clique removal / Merging: दो या अधिक बार आने वाले अभाज्य गुणनखंडों वाले रिलेशन को एक साथ गुणा करें, चरों (variables) को समाप्त करें, और उन्हें एक उच्च घनत्व वाले लेकिन छोटे आयाम के समीकरण प्रणाली में कम करें।

इसके परिणामस्वरूप, अरबों पंक्तियों का मैट्रिक्स कुछ करोड़ पंक्तियों के एक विशाल विरल मैट्रिक्स $\mathbf{A}$ (जिसके तत्व फील्ड $\mathbb{F}_2$ पर 0 और 1 हैं) में संकुचित हो जाता है।

3.4 चरण 4: रैखिक बीजगणित (Linear Algebra Phase)

यहाँ, हम समीकरण $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$ का एक गैर-तुच्छ (non-trivial) समाधान वेक्टर $\mathbf{x}$ खोजते हैं। दूसरे शब्दों में, यह विशाल विरल मैट्रिक्स के लेफ्ट नलस्पेस (Left Nullspace) को खोजने की समस्या है।

चूँकि मैट्रिक्स का आकार अत्यंत बड़ा है, सामान्य गाऊसीयन एलिमिनेशन (Gaussian elimination) ($O(N^3)$) के साथ इसकी गणना करना असंभव है। इसलिए, क्रिलोव सबस्पेस विधि (Krylov subspace method) का एक प्रकार, पुनरावृत्तीय विधि (iterative method) का उपयोग किया जाता है। ऐतिहासिक रूप से, ब्लॉक लैंक्ज़ोस विधि (Block Lanczos) का उपयोग किया गया है, लेकिन वर्तमान वितरित कंप्यूटिंग (distributed computing) वातावरण में, ब्लॉक वीडमैन विधि (Block Wiedemann Algorithm) मुख्यधारा है, जो संचार ओवरहेड को नाटकीय रूप से कम कर सकती है।

ब्लॉक वीडमैन विधि मैट्रिक्स $\mathbf{A}$ और वेक्टर अनुक्रम से न्यूनतम बहुपद की गणना करती है, और नलस्पेस के आधार (basis) के निर्माण के लिए बर्लेकैम्प-मैसी (Berlekamp-Massey) एल्गोरिदम का उपयोग करती है। इस चरण को समानांतर (parallelize) करना बहुत मुश्किल है, और यह GNFS की सबसे बड़ी अड़चनों (bottlenecks) में से एक है, जिसके लिए सुपर कंप्यूटर या बड़े क्लस्टर के कसकर युग्मित (tightly coupled) संचार नेटवर्क की आवश्यकता होती है।

3.5 चरण 5: वर्गमूल (Square Root Phase)

रैखिक बीजगणित के समाधान से, परिमेय पक्ष और बीजगणितीय पक्ष दोनों पर “पूर्ण वर्ग (perfect square)” बनने वाले गुणनफल (products) का निर्माण किया जाता है। परिमेय पक्ष पर, $\prod (a-bm)$ एक पूर्णांक $X$ का वर्ग $X^2$ बन जाता है, और बीजगणितीय पक्ष पर, संबंधित आदर्शों (ideals) का गुणनफल बीजगणितीय क्षेत्र (algebraic field) पर पूर्ण वर्ग $\gamma^2$ बन जाता है। बीजगणितीय क्षेत्र पर इस $\gamma$ की गणना करके और परिमेय पूर्णांक वलय (rational integer ring) में होमोमोर्फिज्म $\phi: \alpha \mapsto m \pmod n$ को लागू करके, सर्वांगसमता: $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$ प्राप्त होती है।

बीजगणितीय क्षेत्र पर वर्गमूल की गणना करने के लिए मोंटगोमरी की विधि (Montgomery’s Method) जैसे जटिल एल्गोरिदम का उपयोग किया जाता है, जिसके लिए बीजगणितीय संख्या सिद्धांत (algebraic number theory) के गहन ज्ञान की आवश्यकता होती है। अंत में, $\gcd(X-Y, n)$ की गणना की जाती है, और यदि एक गैर-तुच्छ गुणनखंड प्राप्त होता है, तो गुणनखंडन पूरा हो जाता है।

4. क्या GNFS से परे कोई क्लासिकल एल्गोरिदम मौजूद है?

अब तक, सामान्य पूर्णांकों के गुणनखंडन के लिए कोई ऐसा क्लासिकल एल्गोरिदम नहीं खोजा गया है जिसकी एसिम्प्टोटिक कॉम्प्लेक्सिटी $L_n[1/3, c]$ से कम हो। हालाँकि, सैद्धांतिक और व्यावहारिक सीमाओं को तोड़ने के लिए कई प्रयास और व्युत्पन्न (derivative) एल्गोरिदम मौजूद हैं।

4.1 मल्टीपल नंबर फील्ड सीव (MNFS: Multiple Number Field Sieve)

GNFS का विस्तार करने वाले एक दृष्टिकोण के रूप में, D. Coppersmith द्वारा मल्टीपल नंबर फील्ड सीव (MNFS) है। जबकि GNFS दो बहुपदों (परिमेय पक्ष और बीजगणितीय पक्ष) का उपयोग करता है, MNFS एक परिमेय पक्ष बहुपद के विरुद्ध एक साथ कई अलग-अलग बीजगणितीय पक्ष बहुपदों का उपयोग करता है।

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

कई बीजगणितीय क्षेत्रों का उपयोग करके, प्रत्येक सीविंग चरण में “किसी भी बीजगणितीय क्षेत्र में स्मूद होने” की संभावना को नाटकीय रूप से बढ़ाया जा सकता है। Coppersmith ने इस दृष्टिकोण के साथ जटिलता $L_n[1/3, c]$ के स्थिरांक (constant) $c$ को थोड़ा कम करने में सफलता प्राप्त की। विशेष रूप से, जबकि GNFS के लिए स्थिरांक $c = (64/9)^{1/3} \approx 1.923$ है, यह सैद्धांतिक रूप से दिखाया गया है कि MNFS को अनुकूलित करके जटिलता को $c \approx 1.902$ तक कम किया जा सकता है। हालाँकि, व्यवहार में, कई क्षेत्रों के प्रबंधन के कारण ओवरहेड बड़ा है, और व्यावहारिक पैमाने पर RSA मॉड्यूलस के लिए कोई निर्णायक सफलता नहीं मिली है।

4.2 क्या $L_n[1/4]$ वर्ग का एल्गोरिदम संभव है?

गणितज्ञों के बीच गुणनखंडन के क्लासिकल एल्गोरिदम की सीमा के बारे में लंबे समय से बहस का विषय रहा है: “क्या घातांक $\alpha = 1/4$ वाला कोई एल्गोरिदम मौजूद है?” वर्तमान GNFS और इसके डेरिवेटिव्स सीविंग के माध्यम से “स्मूदनेस की खोज” के ढांचे से मजबूती से बंधे हैं, और व्यापक रूप से यह माना जाता है कि इस प्रतिमान (paradigm) के भीतर $\alpha = 1/3$ ही सीमा है। डिकमैन फ़ंक्शन (Dickman function) का उपयोग करके स्मूद पूर्णांकों की वितरण संभावना के विश्लेषण से भी यह माना जाता है कि वर्तमान बीजगणितीय क्षेत्र निर्माण विधियों और सीविंग के संयोजन को चाहे जितना भी अनुकूलित किया जाए, $O(L_n[1/3])$ की बाधा को पार नहीं किया जा सकता है।

यदि $L_n[1/4]$, या कोई क्लासिकल पॉलीनोमियल टाइम एल्गोरिदम मौजूद है, तो इसे GNFS जैसे “स्मूदनेस-आधारित” दृष्टिकोण से पूरी तरह से अलग होना चाहिए, और ऐसी नई गणितीय संरचनाओं पर निर्भर होना चाहिए जिनकी मानवता वर्तमान में कल्पना नहीं कर सकती (उदाहरण के लिए, अण्डाकार वक्र क्रिप्टोग्राफी (Elliptic Curve Cryptography) के लिए Schoof के एल्गोरिदम की तरह अधिक उन्नत बीजगणितीय ज्यामितीय दृष्टिकोण)। हालाँकि, वर्तमान में ऐसे कोई संकेत नहीं हैं।

5. क्वांटम कंप्यूटर के साथ सफलता: शोर का एल्गोरिदम (Shor’s Algorithm)

जबकि क्लासिकल कंप्यूटर $L_n[1/3]$ की बाधा का सामना कर रहे हैं, कंप्यूटिंग मॉडल को मूल रूप से बदलकर इस बाधा को तोड़ने वाला एल्गोरिदम 1994 में पीटर शोर (Peter Shor) द्वारा प्रकाशित शोर का एल्गोरिदम (Shor’s Algorithm) था।

5.1 क्वांटम पॉलीनोमियल टाइम का प्रभाव

शोर का एल्गोरिदम गुणनखंडन समस्या को “ऑर्डर फाइंडिंग प्रॉब्लम (Order Finding Problem)” में बदल देता है। यह किसी पूर्णांक $a$ के लिए फ़ंक्शन $f(x) = a^x \pmod n$ की अवधि (period) $r$ खोजने की समस्या है। क्लासिकल कंप्यूटर पर इस अवधि को खोजने में घातीय (exponential) समय लगता है, लेकिन क्वांटम कंप्यूटर पर क्वांटम फेज़ एस्टिमेशन (QPE: Quantum Phase Estimation) और क्वांटम फूरियर ट्रांसफॉर्म (QFT: Quantum Fourier Transform) का उपयोग करके, सभी अवस्थाओं के सुपरपोज़िशन (Superposition) का समानांतर मूल्यांकन किया जा सकता है और उच्च संभावना के साथ अवधि $r$ को निकाला जा सकता है।

कम्प्यूटेशनल जटिलता के दृष्टिकोण से, शोर के एल्गोरिदम का निष्पादन समय क्वांटम पॉलीनोमियल टाइम है, विशेष रूप से यह इस प्रकार है:

$$ O((\log n)^3) $$

हाल के वर्षों में अनुकूलित सर्किट कार्यान्वयन पर विचार ঘনত্ব करते हुए, इसे $O((\log n)^2 \log \log n)$ तक कम किया जा सकता है।

graph LR A["क्लासिकल एल्गोरिदम (GNFS)"] -->|सीमा| B["सब-एक्सपोनेंशियल टाइम L_n[1/3]"] C["क्वांटम एल्गोरिदम (Shor)"] -->|सफलता| D["पॉलीनोमियल टाइम O((log n)^3)"] B --> E["RSA क्रिप्टोग्राफी का निरंतर उपयोग (कुंजी की लंबाई बढ़ाना)"] D --> F["RSA क्रिप्टोग्राफी का पूर्ण पतन"]

5.2 क्लासिकल सब-एक्सपोनेंशियल टाइम बनाम क्वांटम पॉलीनोमियल टाइम

इन दो जटिलता वर्गों के बीच का अंतर वास्तविक दुनिया की क्रिप्टोग्राफ़िक सुरक्षा में निर्णायक अर्थ रखता है।

उदाहरण के लिए, RSA-2048 (2048-बिट भाज्य संख्या) के गुणनखंडन के मामले पर विचार करें।

GNFS (क्लासिकल): $n \approx 2^{2048}$ को $L_n[1/3, 1.923]$ में प्रतिस्थापित करने पर, लगभग $2^{112}$ ऑपरेशनों की आवश्यकता होगी। यह एक खगोलीय गणना राशि है जिसे ब्रह्मांड के जीवनकाल से अधिक समय लगेगा, भले ही वर्तमान में पृथ्वी पर सभी कम्प्यूटेशनल संसाधनों को जोड़ दिया जाए।
Shor’s Algorithm (क्वांटम): $O((\log n)^3)$ एल्गोरिदम के साथ, केवल लगभग $2048^3 \approx 8.5 \times 10^9$ लॉजिक गेट ऑपरेशनों की आवश्यकता होगी। इसका मतलब यह है कि यदि उचित हार्डवेयर (लाखों भौतिक क्विबिट और त्रुटि सुधार क्षमताओं के साथ एक यूनिवर्सल क्वांटम कंप्यूटर) मौजूद है, तो गणना केवल कुछ घंटों से लेकर कुछ दिनों में पूरी की जा सकती है।

“घातांक $\alpha=1/3$” सब-एक्सपोनेंशियल से “पॉलीनोमियल टाइम” में प्रतिमान बदलाव (paradigm shift) पारंपरिक क्रिप्टोग्राफी की उस रणनीति को शक्तिहीन कर देता है जो कुंजी की लंबाई बढ़ाकर सुरक्षा सुनिश्चित करती है।

6. निष्कर्ष: अगली पीढ़ी के लिए दृष्टिकोण

“क्या GNFS से परे कोई क्लासिकल एल्गोरिदम मौजूद है?” प्रश्न के लिए वैज्ञानिक समुदाय की वर्तमान आम सहमति इस प्रकार है:

व्यावहारिक सुधार जारी रहेंगे, लेकिन एसिम्प्टोटिक छलांग नहीं लगेगी: MNFS, बहुपद चयन का अनुकूलन, ब्लॉक वीडमैन विधि का समानांतरकरण आदि जैसे GNFS के स्थिरांक पद $c$ को सुधारने के प्रयास जारी हैं। हालाँकि, इसकी बहुत कम संभावना है कि $\alpha = 1/3$ से कम वाला कोई क्लासिकल एल्गोरिदम खोजा जाएगा।
क्लासिकल कंप्यूटरों पर RSA की सुरक्षा मजबूत बनी हुई है: GNFS की कम्प्यूटेशनल जटिलता अभी भी बहुत बड़ी है, और RSA-2048 और RSA-4096 क्लासिकल कंप्यूटरों के हमलों के खिलाफ आने वाले कई दशकों तक सुरक्षित रहेंगे।
असली खतरा क्वांटम एल्गोरिदम है: क्वांटम यांत्रिकी के सिद्धांतों पर आधारित शोर का एल्गोरिदम कम्प्यूटेशनल जटिलता की बाधा को तोड़ता है। इसके कारण, दुनिया को पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC: Post-Quantum Cryptography) में स्थानांतरित होने के लिए मजबूर होना पड़ रहा है। क्वांटम कंप्यूटरों (जो पॉलीनोमियल टाइम में हल नहीं किए जा सकते) के लिए भी कठिन मानी जाने वाली नई गणितीय समस्याओं, जैसे लैटिस-आधारित क्रिप्टोग्राफी और हैश-आधारित क्रिप्टोग्राफी में संक्रमण, वर्तमान क्रिप्टोग्राफी में सबसे आगे है।

जनरल नंबर फील्ड सीव (GNFS) “सर्वोच्च उपलब्धियों” में से एक है जिसे मानवता क्लासिकल गणित और एल्गोरिदम डिजाइन की सीमा तक पहुंचकर हासिल कर पाई है। GNFS की गहरी गणितीय संरचना को समझना न केवल क्रिप्टैनालिसिस (cryptanalysis) का इतिहास सीखना है, बल्कि यह कम्प्यूटेशनल कॉम्प्लेक्सिटी थ्योरी और बीजीय संख्या सिद्धांत (algebraic number theory) की सुंदरता का अनुभव करने के लिए एक बौद्धिक खोज की यात्रा भी है। उस दिन तक जब क्वांटम कंप्यूटर व्यावहारिक हो जाएंगे, GNFS संभवतः सबसे शक्तिशाली गुणनखंडन एल्गोरिदम के रूप में अपना सिंहासन बनाए रखेगा।

पायथन में शोर के एल्गोरिथ्म का सिमुलेशन

Fri, 11 Sep 2026 08:00:00 +0900

1. परिचय: क्वांटम कंप्यूटर द्वारा लाया गया क्रिप्टोग्राफी का संकट

आधुनिक इंटरनेट समाज में सुरक्षा का अधिकांश हिस्सा सार्वजनिक कुंजी क्रिप्टोग्राफी (Public Key Cryptography) (विशेष रूप से RSA एन्क्रिप्शन) पर निर्भर करता है। जब हम ऑनलाइन शॉपिंग के दौरान क्रेडिट कार्ड की जानकारी भेजते हैं या अत्यधिक गोपनीय डेटा का आदान-प्रदान करते हैं, तो उस संचार की सामग्री को RSA एन्क्रिप्शन द्वारा दृढ़ता से सुरक्षित किया जाता है।

RSA एन्क्रिप्शन की सुरक्षा का आधार इस गणितीय तथ्य पर निर्भर करता है कि “एक बहुत बड़े पूर्णांक का अभाज्य गुणनखंडन शास्त्रीय कंप्यूटरों (जैसे पीसी या सुपरकंप्यूटर) के लिए अत्यंत कठिन है।” हालाँकि, 1994 में पीटर शोर (Peter Shor) द्वारा प्रकाशित “शोर का एल्गोरिथ्म (Shor’s Algorithm)” इस आधार को पूरी तरह से पलट देता है। यह गणितीय रूप से सिद्ध हो चुका है कि यदि शोर के एल्गोरिथ्म को बड़े पैमाने के क्वांटम कंप्यूटर पर निष्पादित किया जाए, तो अभाज्य गुणनखंडन, जिसे शास्त्रीय कंप्यूटर पर हल करने में ब्रह्मांड की आयु से अधिक समय लग सकता है, उसे केवल कुछ मिनटों से लेकर कुछ घंटों में हल किया जा सकता है।

इस लेख में, हम विस्तार से बताएंगे कि कैसे शोर का एल्गोरिथ्म अभाज्य गुणनखंडन को इतनी तेज़ी से करता है, इसके गणितीय तंत्र से लेकर, क्वांटम कंप्यूटिंग फ्रेमवर्क Qiskit और Python का उपयोग करके इसके विशिष्ट सिमुलेशन कार्यान्वयन तक।

2. कम्प्यूटेशनल जटिलता में नाटकीय बदलाव: घातांकीय से बहुपद समय तक

अभाज्य गुणनखंडन इतना कठिन क्यों है? भले ही हम “सामान्य संख्या क्षेत्र चलनी (General Number Field Sieve, GNFS)” का उपयोग करें, जिसे शास्त्रीय कंप्यूटरों के लिए सबसे अच्छा अभाज्य गुणनखंडन एल्गोरिथ्म माना जाता है, इसकी कम्प्यूटेशनल जटिलता उप-घातांकीय (sub-exponential) है।

$N$ अंकों की एक समग्र संख्या (composite number) का अभाज्य गुणनखंडन करने के लिए आवश्यक समय जटिलता (time complexity) शास्त्रीय तरीकों से इस प्रकार है:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

इस वजह से, केवल कुंजी की लंबाई बढ़ाने (उदाहरण के लिए, इसे 2048 बिट्स या 4096 बिट्स करने) से शास्त्रीय कंप्यूटरों के लिए डिक्रिप्शन में हजारों या लाखों साल लग सकते हैं, जो कि अव्यावहारिक है।

हालाँकि, जब क्वांटम कंप्यूटर पर शोर के एल्गोरिथ्म का उपयोग किया जाता है, तो इनपुट बिट्स $\log N$ की संख्या के सापेक्ष कम्प्यूटेशनल जटिलता नाटकीय रूप से कम होकर बहुपद समय (polynomial time) में आ जाती है।

$$ O((\log N)^3) $$

इसका मतलब यह है कि यदि बिट्स की संख्या दोगुनी कर दी जाए, तो शास्त्रीय कंप्यूटरों के लिए गणना का समय खगोलीय रूप से बढ़ जाता है, जबकि क्वांटम कंप्यूटरों के लिए गणना का समय केवल लगभग 8 गुना बढ़ जाता है। घातांकीय समय से बहुपद समय तक जटिलता वर्ग में यह कमी (BQP वर्ग में शामिल होना) ही शोर के एल्गोरिथ्म की सच्ची महानता है।

graph TD A["इनपुट आकार (बिट्स की संख्या) N में वृद्धि"] --> B{"एल्गोरिथ्म का चयन"} B -->|शास्त्रीय: सामान्य संख्या क्षेत्र चलनी| C["उप-घातांकीय वृद्धि O(exp(...))"] B -->|क्वांटम: शोर का एल्गोरिथ्म| D["बहुपद समय O((log N)^3)"] C --> E["हजारों से अरबों साल (डिक्रिप्ट करने में असमर्थ)"] D --> F["कुछ मिनट से कुछ घंटे (व्यावहारिक समय में डिक्रिप्ट)"]

3. एल्गोरिथ्म का अवलोकन और गणितीय पृष्ठभूमि

असल में, शोर के एल्गोरिथ्म में सब कुछ क्वांटम कंप्यूटर पर नहीं किया जाता है। यह शास्त्रीय कंप्यूटर द्वारा प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग, और क्वांटम कंप्यूटर द्वारा मुख्य भाग (अवधि खोजने का एल्गोरिथ्म - Period Finding Algorithm) के बीच सहयोग पर निर्भर करता है।

एल्गोरिथ्म का समग्र प्रवाह इस प्रकार है:

graph TD A["इनपुट: वह समग्र संख्या N जिसका अभाज्य गुणनखंडन करना है"] --> B["यादृच्छिक संख्या a चुनें जहाँ a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["तुच्छ गुणनखंड gcd(a, N) आउटपुट करें और समाप्त करें"] C -- "No" --> E["क्वांटम एल्गोरिथ्म के साथ f(x) = a^x mod N की अवधि r खोजें"] E --> F{"क्या r सम है और a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["गुणनखंड p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N) की गणना करें"] G --> H["आउटपुट: p, q"]

अभाज्य गुणनखंडन को अवधि खोजने की समस्या (Period Finding Problem) में बदलना

शोर का प्रतिभाशाली विचार “अभाज्य गुणनखंडन समस्या” को “अवधि खोजने की समस्या (Order Finding Problem)” में परिवर्तित करना था।

मान लीजिए कि एक पूर्णांक $N$ (वह संख्या जिसका अभाज्य गुणनखंडन किया जाना है) और एक सह-अभाज्य (coprime) पूर्णांक $a$ ($1 < a < N$) है। हम निम्नलिखित मॉड्यूलर एक्सपोनेंशियल फ़ंक्शन को परिभाषित करते हैं:

$$ f(x) = a^x \bmod N $$

इस फ़ंक्शन की एक निश्चित अवधि $r$ होती है। अर्थात, किसी भी $x$ के लिए, $f(x+r) = f(x)$ सत्य होता है। विशेष रूप से, जब $x=0$ होता है,

$$ a^r \equiv 1 \pmod N $$

सबसे छोटा धनात्मक पूर्णांक $r$ जो इसे संतुष्ट करता है, उसे “$N$ के मापांक में $a$ का क्रम (Order)” कहा जाता है। यदि हम इस अवधि $r$ को पा सकते हैं, तो हम अभाज्य गुणनखंडों को निम्न प्रकार से निकाल सकते हैं:

समीकरण को बदलने पर,

$$ a^r - 1 \equiv 0 \pmod N $$

यदि $r$ सम है, तो हम इसे वर्गों के अंतर के सूत्र का उपयोग करके गुणनखंडित कर सकते हैं:

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

यह इंगित करता है कि $N$ का $(a^{r/2} - 1)$ या $(a^{r/2} + 1)$ के साथ कोई सार्व भाजक (common divisor) है (बशर्ते कि शर्त $a^{r/2} \not\equiv -1 \pmod N$ संतुष्ट हो)। इसलिए, यूक्लिडियन एल्गोरिथ्म (Euclidean algorithm) का उपयोग करके,

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

की गणना करके, हम $N$ के गैर-तुच्छ अभाज्य गुणनखंड (non-trivial prime factors) $p, q$ खोज सकते हैं। यह गणना (महत्तम समापवर्तक की गणना और यादृच्छिक संख्या का निर्माण) शास्त्रीय कंप्यूटरों पर बहुत तेजी से की जा सकती है। समस्या केवल इस बात पर केंद्रित हो जाती है कि हम अवधि $r$ को तेजी से कैसे खोज सकते हैं। शास्त्रीय कंप्यूटरों के लिए, केवल इस अवधि $r$ को खोजने में ही घातांकीय समय लगता है। यहीं क्वांटम कंप्यूटर काम में आते हैं।

4. क्वांटम एल्गोरिथ्म भाग: अवधि खोजने का तंत्र

क्वांटम कंप्यूटर का उपयोग करके अवधि $r$ खोजने के लिए सबरूटीन में निम्नलिखित 4 चरण शामिल हैं:

graph LR subgraph "क्वांटम अवस्था का संक्रमण" S1["|0⟩|0⟩ (आरंभीकरण)"] --> S2["H गेट: सुपरपोजिशन Σ|x⟩|0⟩"] S2 --> S3["ओरेकल U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: हस्तक्षेप द्वारा अवधि निष्कर्षण"] S4 --> S5["माप: अनुमानित मान y प्राप्त करना"] end

चरण 1: क्वांटम रजिस्टर का आरंभीकरण और सुपरपोजिशन

सबसे पहले, हम दो क्वांटम रजिस्टर तैयार करते हैं। पहला रजिस्टर अवस्था इनपुट करने के लिए है, और दूसरा रजिस्टर फ़ंक्शन के गणना परिणामों को संग्रहीत करने के लिए है। प्रारंभिक अवस्था पूरी तरह से $|0\rangle$ है।

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

हम पहले रजिस्टर के सभी क्विबिट्स पर हैडमार्ड गेट (Hadamard Gate) लागू करते हैं ताकि सभी संभावित इनपुट्स $x$ ($0$ से $Q-1$ तक, $Q=2^n$) की समान संभावना वाली सुपरपोजिशन अवस्था (superposition state) बनाई जा सके।

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

इसके साथ, क्वांटम कंप्यूटर एक ही ऑपरेशन में एक साथ सभी $Q$ इनपुट्स के लिए अवस्था को बनाए रखता है। यही क्वांटम समानांतरता (quantum parallelism) का शक्तिशाली स्रोत है।

चरण 2: ओरेकल फ़ंक्शन (मॉड्यूलर एक्सपोनेंटिएशन) लागू करना

इसके बाद, हम फ़ंक्शन $f(x) = a^x \bmod N$ की गणना करने के लिए क्वांटम ऑपरेशन सर्किट $U_f$ का उपयोग करते हैं और परिणाम को दूसरे रजिस्टर में संग्रहीत करते हैं।

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

इस बिंदु पर, पहला रजिस्टर और दूसरा रजिस्टर क्वांटम एंटैंगलमेंट (quantum entanglement) की अवस्था में होते हैं। यदि हम (काल्पनिक रूप से) दूसरे रजिस्टर का अवलोकन करते हैं और एक विशिष्ट मान $k = a^{x_0} \bmod N$ प्राप्त करते हैं, तो पहले रजिस्टर की अवस्था उस $x$ की सुपरपोजिशन अवस्था में ढह जाएगी जो वह मान $k$ देता है। चूंकि फ़ंक्शन की अवधि $r$ है, शेष अवस्थाएं $x_0, x_0+r, x_0+2r, \dots$ जैसे मानों के $r$ छलांग पर होंगी।

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

हालाँकि, हम $x_0$ नहीं जानना चाहते हैं, बल्कि हम स्वयं अवधि $r$ जानना चाहते हैं। इस अवस्था से $r$ को सीधे मापना असंभव है। इसलिए, हम क्वांटम फूरियर ट्रांसफॉर्म (Quantum Fourier Transform) का उपयोग करते हैं।

चरण 3: क्वांटम फूरियर ट्रांसफॉर्म (QFT) के माध्यम से चरण हस्तक्षेप

हम पहले रजिस्टर पर क्वांटम फूरियर ट्रांसफॉर्म (QFT) लागू करते हैं। QFT शास्त्रीय असतत फूरियर ट्रांसफॉर्म (discrete Fourier transform) का क्वांटम संस्करण है, जो अवस्था वेक्टर के आयाम (amplitude) को परिवर्तित करता है। आधार अवस्था (basis state) $|x\rangle$ पर QFT की क्रिया को इस प्रकार परिभाषित किया गया है:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

यहाँ, $\omega = e^{2\pi i / Q}$ है।

जब QFT लागू किया जाता है, तो अवस्थाओं के आयाम में हस्तक्षेप (interference) होता है। गणितीय विवरण को छोड़ते हुए, जब अवधि $r$ वाली अवस्था पर QFT लागू किया जाता है, तो तरंगों में रचनात्मक हस्तक्षेप (Constructive Interference) केवल तभी होता है जब $y$ का मान $Q/r$ के पूर्णांक गुणज के बहुत करीब होता है। अन्य अवस्थाओं के लिए, संभावना आयाम (probability amplitude) विनाशकारी हस्तक्षेप (Destructive Interference) द्वारा रद्द हो जाते हैं और शून्य के करीब पहुंच जाते हैं।

चरण 4: मापन और निरंतर भिन्न विस्तार

अंत में, हम पहले रजिस्टर को मापते हैं। माप से प्राप्त मान $y$ उच्च संभावना के साथ निम्नलिखित शर्त को पूरा करता है:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ एक अज्ञात पूर्णांक है जहाँ $0 \le c < r$ है)

प्राप्त परिमेय संख्या $y/Q$ पर शास्त्रीय एल्गोरिथ्म निरंतर भिन्न विस्तार (Continued Fraction Expansion) लागू करके, हम सन्निकट भिन्न (approximate fraction) $c/r$ की गणना करते हैं और हर (denominator) से अवधि $r$ निकालते हैं।

5. Python और Qiskit का उपयोग करके सिमुलेशन कार्यान्वयन

चूंकि केवल सिद्धांत से इसे समझना मुश्किल है, आइए वास्तव में Python और IBM के क्वांटम कंप्यूटिंग फ्रेमवर्क Qiskit का उपयोग करके शोर के एल्गोरिथ्म का सिमुलेशन करें।

यहाँ, हम सबसे क्लासिक और प्रसिद्ध परिदृश्य को लागू करेंगे: "$a=7$ का उपयोग करके $N=15$ का अभाज्य गुणनखंडन करना।"

निष्पादन वातावरण तैयार करना

कृपया सुनिश्चित करें कि आपने पहले ही Qiskit स्थापित कर लिया है।

1

pip install qiskit qiskit-aer numpy

Python कार्यान्वयन कोड का अवलोकन

नीचे दिया गया कोड $N=15, a=7$ के लिए विशेषीकृत शोर के एल्गोरिथ्म कार्यान्वयन का एक उदाहरण है। चूंकि वर्तमान सिमुलेटर में सामान्य प्रयोजन के मॉड्यूलर घातांक सर्किट का निर्माण करना कम्प्यूटेशनल रूप से बहुत महंगा है, हम विशेष रूप से $a=7$ के मामले में गेट ऑपरेशंस को हार्डकोड कर रहे हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. व्युत्क्रम क्वांटम फूरियर ट्रांसफॉर्म (QFT†) बनाने का फलन
def qft_dagger(n):
 """n क्विबिट्स का इनवर्स क्वांटम फूरियर ट्रांसफॉर्म सर्किट बनाता है"""
 qc = QuantumCircuit(n)
 # क्रम को उलटने के लिए SWAP गेट
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # नियंत्रित फेज़ गेट और H गेट को लागू करना
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. 7^x mod 15 के लिए नियंत्रित मॉड्यूलर एक्सपोनेंटिएशन ऑपरेशन बनाने का फलन
def c_amod15(a, power):
 """विशिष्ट 'a' और 'power' के लिए नियंत्रित U गेट बनाता है (केवल N=15 के लिए)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # a=7 होने पर 7^x mod 15 के लिए हार्डकोडेड लॉजिक
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. मुख्य क्वांटम सर्किट विन्यास
def shor_circuit(a, n_count):
 # n_count: नियंत्रण रजिस्टर में बिट्स की संख्या
 # लक्ष्य रजिस्टर 0 से 15 तक दर्शाने के लिए 4 बिट्स का उपयोग करता है
 qc = QuantumCircuit(n_count + 4, n_count)

 # पहले रजिस्टर (नियंत्रण रजिस्टर) का आरंभीकरण (सुपरपोजिशन उत्पन्न करना)
 for q in range(n_count):
 qc.h(q)

 # दूसरे रजिस्टर (लक्ष्य रजिस्टर) को |1> (0001) पर आरंभ करना
 qc.x(3 + n_count)

 # नियंत्रित मॉड्यूलर एक्सपोनेंटिएशन (ओरेकल) को लागू करना
 for q in range(n_count):
 # 2^q घातांक ऑपरेशन लागू करना
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # पहले रजिस्टर पर इनवर्स क्वांटम फूरियर ट्रांसफॉर्म लागू करना
 qc.append(qft_dagger(n_count), range(n_count))

 # पहले रजिस्टर को मापना
 qc.measure(range(n_count), range(n_count))
 return qc

# --- निष्पादन अनुभाग ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # नियंत्रण रजिस्टर में 8 क्विबिट्स का उपयोग करें (Q=256)

 print(f"खोज सेटिंग्स: N={N}, a={a}, नियंत्रण क्विबिट्स की संख्या={n_count}")

 # सर्किट का निर्माण
 qc = shor_circuit(a, n_count)

 # सिमुलेटर पर निष्पादन
 sim = AerSimulator()
 # नवीनतम Qiskit में transpile की अनुशंसा की जाती है
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nमाप परिणाम (बिट स्ट्रिंग: प्रेक्षणों की संख्या):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} बार")

 # शास्त्रीय पोस्ट-प्रोसेसिंग: निरंतर भिन्न विस्तार (Continued fractions) का उपयोग करके अवधि r खोजना
 print("\n--- अवधि की गणना और अभाज्य गुणनखंडन ---")
 phases = []
 for output in counts:
 # बिट स्ट्रिंग को दशमलव में परिवर्तित करना
 decimal = int(output, 2)
 # फेज़ (Phase) = मापा गया मान / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # निरंतर भिन्न विस्तार के माध्यम से सन्निकट भिन्न प्राप्त करें। हर (denominator) की ऊपरी सीमा N=15 है
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"प्रेक्षित मान: {decimal:3d} | फेज़: {phase:.4f} | भिन्न: {frac} | अनुमानित अवधि r = {r}")

 # जांचें कि क्या अवधि r सम है और वैध परिणाम देती है
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => सफलता! {N} के अभाज्य गुणनखंड {guess1} और {guess2} हैं।")
 else:
 print(f" => केवल तुच्छ गुणनखंड। पुनः प्रयास करें।")
 else:
 print(f" => विफलता क्योंकि अवधि विषम है।")

कोड की व्याख्या और निष्पादन परिणामों का विश्लेषण

जब आप उपरोक्त कोड निष्पादित करते हैं, तो आपको उच्च संभावना के साथ नियंत्रण रजिस्टर के मापन परिणामों के रूप में विशिष्ट चोटियाँ (प्रेक्षित मान) प्राप्त होंगी। n_count=8 ($Q=256$) के मामले में, एक आदर्श क्वांटम कंप्यूटर (या सिमुलेटर) पर, भारी संभावना के साथ प्रेक्षित मानों के रूप में 0, 64, 128, और 192 जैसी संख्याएं दिखाई देंगी।

जब इन्हें $Q=256$ से विभाजित किया जाता है, तो चरण (phase) $y/Q$ क्रमशः $0.0$, $0.25$, $0.5$, और $0.75$ हो जाते हैं। जब इन चरणों को निरंतर भिन्न (continued fraction) के रूप में विस्तारित किया जाता है:

$0.25 \to 1/4$ (अनुमानित अवधि $r=4$)
$0.50 \to 1/2$ (अनुमानित अवधि $r=2$)
$0.75 \to 3/4$ (अनुमानित अवधि $r=4$)

यहां प्राप्त अवधि $r=4$ का उपयोग करके, हम अभाज्य गुणनखंडों की गणना करते हैं। चूंकि $a=7, r=4$ है, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

शानदार ढंग से, हम सफलतापूर्वक $15 = 3 \times 5$ का अभाज्य गुणनखंडन कर चुके हैं।

[!TIP] यदि प्रेक्षित मान $y=128$ (चरण $0.5$) प्राप्त होता है, तो हर (denominator) $2$ होगा, और हमें सही अवधि $r=4$ के बजाय इसका एक विभाजक मिलेगा। ऐसे मामलों में, एल्गोरिथ्म को कई बार निष्पादित करके या प्राप्त $r$ के गुणकों की जाँच करके, सही अवधि तक पहुँचा जा सकता है।

6. व्यावहारिक अनुप्रयोग के लिए चुनौतियाँ और NISQ युग की सीमाएँ

हालाँकि एक सिमुलेटर पर $N=15$ का अभाज्य गुणनखंडन करना आसान था, वास्तविक दुनिया में उपयोग किए जा रहे RSA-2048 (617 अंकों की दशमलव संख्या) का अभाज्य गुणनखंडन करने के लिए वास्तविक क्वांटम कंप्यूटरों को अभी भी कई बाधाओं का सामना करना पड़ता है।

जिस युग में हम वर्तमान में रह रहे हैं उसे NISQ (Noisy Intermediate-Scale Quantum: शोरगुल वाले मध्यवर्ती-स्तरीय क्वांटम) युग कहा जाता है। क्वांटम बिट्स बाहरी वातावरण के शोर के प्रति बेहद संवेदनशील होते हैं, और गणना के बीच में “डिकोहेरेंस (decoherence)” के कारण उनकी अवस्था नष्ट हो जाती है।

शोर के एल्गोरिथ्म जैसे गहरे (बड़ी संख्या में गेट्स वाले) सर्किट को सटीक रूप से निष्पादित करने के लिए, क्वांटम त्रुटि सुधार (Quantum Error Correction) आवश्यक है जो शोर को ठीक करता है। एक शोर-मुक्त “लॉजिकल क्विबिट (logical qubit)” बनाने के लिए, सरफेस कोड (Surface Code) आदि के माध्यम से हजारों “फिजिकल क्विबिट्स (physical qubits)” को एन्कोड करना आवश्यक है।

अनुमान है कि 2048-बिट RSA एन्क्रिप्शन को तोड़ने के लिए हजारों पूर्ण लॉजिकल क्विबिट्स की आवश्यकता होगी, और इसे प्राप्त करने के लिए लाखों से करोड़ों फिजिकल क्विबिट्स से सुसज्जित एक फॉल्ट-टॉलरेंट (दोष-सहिष्णु) क्वांटम कंप्यूटर की आवश्यकता होगी। यहाँ तक कि आज के सबसे उन्नत क्वांटम प्रोसेसर में भी केवल कुछ सौ से कुछ हज़ार फिजिकल क्विबिट्स हैं, इसलिए दुनिया की एन्क्रिप्शन व्यवस्था तुरंत नहीं टूटेगी।

[!WARNING] हालाँकि, “Store Now, Decrypt Later (अभी सहेजें, बाद में डिक्रिप्ट करें)” नामक एक खतरे का मॉडल (threat model) मौजूद है। हमलावर वर्तमान में एन्क्रिप्टेड गोपनीय संचार डेटा को बड़ी मात्रा में सहेज सकते हैं, और 10 से 20 साल बाद एक शक्तिशाली क्वांटम कंप्यूटर पूरा होने के तुरंत बाद उन सभी को डिक्रिप्ट करने की रणनीति अपना सकते हैं।

7. पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC) में स्थानांतरण

ऐसे “Q-Day (वह दिन जब क्वांटम कंप्यूटर एन्क्रिप्शन को तोड़ेंगे)” के आगमन की तैयारी में, अमेरिका के नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड्स एंड टेक्नोलॉजी (NIST) के नेतृत्व में, दुनिया भर के क्रिप्टोग्राफर पोस्ट-क्वांटम क्रिप्टोग्राफी (Post-Quantum Cryptography, PQC) के लिए मानक विकसित कर रहे हैं।

PQC नई गणितीय समस्याओं (जैसे कि जालक समस्याएँ (lattice problems), बहुभिन्नरूपी बहुपद समस्याएँ (multivariate polynomial problems), हैश फ़ंक्शन-आधारित आदि) पर आधारित है, जिनके बारे में गणितीय रूप से माना जाता है कि उन्हें शोर के एल्गोरिथ्म (या ग्रोवर के एल्गोरिथ्म) का उपयोग करके भी कुशलता से हल नहीं किया जा सकता है। “CRYSTALS-Kyber” और “CRYSTALS-Dilithium” जैसे एल्गोरिथ्म को पहले ही मानक विनिर्देशों के रूप में चुना जा चुका है, और इन्हें धीरे-धीरे Apple के iMessage और विभिन्न वेब ब्राउज़र के संचार प्रोटोकॉल में पेश किया जा रहा है।

IT इन्फ्रास्ट्रक्चर का प्रबंधन करने वाले इंजीनियरों के लिए, मौजूदा RSA और इलिप्टिक कर्व क्रिप्टोग्राफी (elliptic curve cryptography) से PQC में सिस्टमिक बदलाव करना, अर्थात् “क्रिप्टो-एजिलिटी (Crypto-agility: एन्क्रिप्शन विधियों को तेज़ी से बदलने की क्षमता)” को सिस्टम में शामिल करना, भविष्य का एक बड़ा मिशन होगा।

8. निष्कर्ष

इस लेख में, हमने शोर के एल्गोरिथ्म की सैद्धांतिक गणितीय पृष्ठभूमि से शुरुआत करके, क्वांटम फूरियर ट्रांसफॉर्म का उपयोग करके अवधि निष्कर्षण तंत्र, और अंततः Python और Qiskit का उपयोग करके विशिष्ट सिमुलेशन कोड तक, 10,000 वर्णों के पैमाने पर एक विस्तृत व्याख्या प्रदान की है।

यह तथ्य कि क्वांटम यांत्रिकी के सूक्ष्म विश्व के भौतिक नियम, मैक्रोस्कोपिक सूचना विज्ञान के मूल (जैसे कम्प्यूटेशनल जटिलता सिद्धांत और क्रिप्टोग्राफी सिद्धांत) को पूरी तरह से पलट सकते हैं, विज्ञान के इतिहास में सबसे रोमांचक प्रतिमान बदलावों (paradigm shifts) में से एक है। हमें क्वांटम कंप्यूटिंग तकनीक के चल ক্রিম विकास और इसके खिलाफ बचाव करने वाली नई एन्क्रिप्शन तकनीकों के बीच लड़ाई पर नज़र रखनी चाहिए।

हम आपको इस लेख में प्रस्तुत Python कोड को अपने स्वयं के वातावरण में निष्पादित करने के लिए प्रोत्साहित करते हैं, और क्वांटम अवस्था सुपरपोजिशन (superposition) और हस्तक्षेप (interference) द्वारा बनाए गए “कम्प्यूटेशनल जादू (magic of computation)” का अनुभव करते हैं।

संदर्भ (References)

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【चित्रित PQC】 क्वांटम-प्रतिरोधी क्रिप्टोग्राफी के प्रमुख एल्गोरिदम की तुलना

Fri, 11 Sep 2026 07:00:00 +0900

1. परिचय: क्वांटम कंप्यूटर द्वारा लाया गया ‘क्रिप्टोग्राफी संकट’

आधुनिक इंटरनेट समाज में, संचार की गोपनीयता और डेटा की अखंडता की रक्षा के लिए पब्लिक-की क्रिप्टोग्राफी तकनीक बुनियादी ढांचे के रूप में अपरिहार्य है। वर्तमान में व्यापक रूप से उपयोग की जाने वाली RSA क्रिप्टोग्राफी और एलिप्टिक कर्व क्रिप्टोग्राफी (ECC), क्रमशः ‘विशाल समग्र संख्याओं के अभाज्य गुणनखंड (prime factorization) की कठिनाई’ और ‘एलिप्टिक कर्व पर असतत लघुगणक समस्या (discrete logarithm problem) की कठिनाई’ जैसी गणितीय बाधाओं पर निर्भर करके सुरक्षा सुनिश्चित करती हैं। शास्त्रीय कंप्यूटरों (सुपर कंप्यूटर सहित वर्तमान में हम जिन कंप्यूटरों का उपयोग कर रहे हैं) के साथ, यह सिद्ध हो चुका है कि इन गणितीय समस्याओं को हल करने में ब्रह्मांड की आयु से भी अधिक समय लगेगा, और यही उनकी सुरक्षा का आधार रहा है।

हालाँकि, यह मजबूत आधार क्वांटम कंप्यूटर के सिद्धांत और व्यावसायीकरण की प्रगति से पूरी तरह से पलटने वाला है। 1994 में क्रिप्टोग्राफर पीटर शोर (Peter Shor) द्वारा प्रकाशित ‘शोर का एल्गोरिदम (Shor's Algorithm)’ सैद्धांतिक रूप से साबित करता है कि यदि इसे पर्याप्त प्रदर्शन वाले फॉल्ट-टॉलरेंट जनरल-परपज क्वांटम कंप्यूटर (CRQC: Cryptographically Relevant Quantum Computer) पर निष्पादित किया जाए, तो अभाज्य गुणनखंड समस्या और असतत लघुगणक समस्या को ‘बहुपद समय (polynomial time)’ में डिक्रिप्ट किया जा सकता है। इसका मतलब है कि वर्तमान में उपयोग की जाने वाली सभी पब्लिक-की क्रिप्टोग्राफी बेकार हो जाएंगी।

graph TD A["बड़े पैमाने का क्वांटम कंप्यूटर (CRQC)"] -->|निष्पादन| B["शोर का एल्गोरिदम (Shor's Algorithm)"] B -->|बहुपद समय में डिक्रिप्शन| C["अभाज्य गुणनखंड समस्या (RSA)"] B -->|बहुपद समय में डिक्रिप्शन| D["असतत लघुगणक समस्या (ECC / ECDSA)"] C --> E["क्रिप्टोग्राफ़िक संचार की छिपकर बातें सुनना, डेटा से छेड़छाड़, स्पूफिंग"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

यह सोचना कि ‘कोई समस्या नहीं है क्योंकि पूर्ण विकसित क्वांटम कंप्यूटर के पूरा होने में अभी दशकों बाकी हैं’ बहुत खतरनाक है। क्योंकि, Store Now, Decrypt Later (SNDL: अभी स्टोर करें, बाद में डिक्रिप्ट करें) नामक हमले का तरीका पहले ही एक वास्तविक खतरा बन चुका है। यह एक ऐसा हमला है जहाँ दुर्भावनापूर्ण राष्ट्र या हैकर संगठन वर्तमान एन्क्रिप्टेड संचार डेटा (जैसे TLS ट्रैफ़िक) को बड़ी मात्रा में स्टोरेज में सहेज कर रखते हैं, और भविष्य में जैसे ही शक्तिशाली क्वांटम कंप्यूटर उपलब्ध होंगे, वे उन सभी को डिक्रिप्ट कर देंगे। राष्ट्रीय रहस्य, बुनियादी ढांचे की जानकारी, और चिकित्सा डेटा जिन्हें लंबे समय तक संरक्षित किया जाना चाहिए, पहले से ही इस खतरे के संपर्क में हैं।

इसके अलावा, सममित-कुंजी क्रिप्टोग्राफी (Symmetric-key cryptography जैसे AES) और हैश फ़ंक्शंस (जैसे SHA-256) के खिलाफ 1996 में खोजा गया ग्रोवर का एल्गोरिदम (Grover’s Algorithm) मौजूद है। यह ब्रूट-फोर्स हमले (brute-force attack) की कम्प्यूटेशनल जटिलता को वर्गमूल (square root) तक कम कर देता है। दूसरे शब्दों में, AES-128 का सुरक्षा स्तर प्रभावी रूप से 2^64 तक आधा हो जाता है, इसलिए क्वांटम युग में AES-256 या SHA-384 जैसी लंबी कुंजियों या हैश लंबाई का उपयोग करने की सिफारिश की जाती है।

इस अभूतपूर्व क्रिप्टोग्राफ़िक संकट का मुकाबला करने के लिए, पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC) का जन्म हुआ, जो नई गणितीय समस्याओं पर आधारित है जिन्हें क्वांटम कंप्यूटर का उपयोग करके भी हल करना मुश्किल है। इस लेख में, हम यू.एस. नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड एंड टेक्नोलॉजी (NIST) के नेतृत्व में PQC मानकीकरण प्रक्रिया के परिणामों के आधार पर प्रमुख PQC एल्गोरिदम के गणितीय पृष्ठभूमि, तंत्र और वास्तुकला की तुलना के बारे में विस्तार से बताएंगे।

2. NIST PQC मानकीकरण परियोजना का पूरा अवलोकन और इतिहास

क्रिप्टोग्राफ़िक तकनीक के संक्रमण में, प्रोटोकॉल के पुन: डिज़ाइन, सिस्टम अपडेट और हार्डवेयर प्रतिस्थापन आदि सहित कई वर्षों से लेकर दशकों तक का समय लगता है। इसलिए, दुनिया भर के क्रिप्टोग्राफ़रों ने बहुत पहले से PQC पर शोध करना शुरू कर दिया था। संयुक्त राज्य अमेरिका का NIST (नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड एंड टेक्नोलॉजी) इसमें केंद्रीय भूमिका निभा रहा है। NIST ने 2016 में PQC मानकीकरण प्रक्रिया के लिए आवेदन आमंत्रित किए और दुनिया भर के क्रिप्टोग्राफ़िक समुदाय से पूरी तरह से नए क्रिप्टोग्राफ़िक एल्गोरिदम के प्रस्ताव स्वीकार किए।

मानकीकरण के लक्ष्य निम्नलिखित 2 मुख्य श्रेणियां थीं:

पब्लिक-की क्रिप्टोग्राफी / की एनकैप्सुलेशन मैकेनिज्म (KEM: Key Encapsulation Mechanism): TLS कनेक्शन आदि में संचार पथ को एन्क्रिप्ट करने के लिए सुरक्षित रूप से एक साझा कुंजी (common key) साझा (वितरित) करने का तंत्र।
डिजिटल हस्ताक्षर (Digital Signatures): सॉफ़्टवेयर अपडेट और डिजिटल प्रमाणपत्रों में यह साबित करने का तंत्र कि डेटा के साथ कोई छेड़छाड़ नहीं की गई है और प्रेषक की पहचान सही है (प्रामाणिकता)।

लगभग 6 वर्षों के गहन मूल्यांकन, विश्लेषण और डिक्रिप्शन प्रतियोगिता (राउंड 1 से राउंड 3) के बाद, कुछ एल्गोरिदम के लिए राउंड 4 का अतिरिक्त मूल्यांकन किया गया। परिणामस्वरूप, 2024 में निम्नलिखित एल्गोरिदम औपचारिक संघीय सूचना प्रसंस्करण मानक (FIPS) के रूप में जारी किए गए और भविष्य के वैश्विक मानकों के रूप में स्थापित किए गए।

FIPS 203 (ML-KEM): CRYSTALS-Kyber पर आधारित KEM
FIPS 204 (ML-DSA): CRYSTALS-Dilithium पर आधारित डिजिटल हस्ताक्षर
FIPS 205 (SLH-DSA): SPHINCS+ पर आधारित स्टेटलेस हैश-आधारित हस्ताक्षर
(भविष्य की योजना) FN-DSA: FALCON पर आधारित डिजिटल हस्ताक्षर

ये चयनित एल्गोरिदम विभिन्न गणितीय ‘कठिनाई समस्याओं’ पर निर्भर करते हैं, ताकि यदि भविष्य में किसी एक एल्गोरिदम में कोई गंभीर भेद्यता पाई जाती है, तो संपूर्ण सिस्टम ध्वस्त न हो और विविधता (Crypto Agility) सुनिश्चित की जा सके। मानकीकरण प्रक्रिया में, लैटिस-आधारित क्रिप्टोग्राफी (Lattice-based cryptography) ने मुख्य रूप से प्रदर्शन के मामले में प्रमुख भूमिका निभाई, लेकिन हैश-आधारित क्रिप्टोग्राफी और कोड-आधारित क्रिप्टोग्राफी को शक्तिशाली बैकअप के रूप में अपनाया गया है।

3. PQC के प्रमुख गणितीय दृष्टिकोणों का वर्गीकरण

PQC एल्गोरिदम को मुख्य रूप से 5 श्रेणियों में विभाजित किया गया है, जो उनकी सुरक्षा के आधार पर गणितीय समस्याओं पर निर्भर करते हैं। इस लेख में, हम विशेष रूप से शीर्ष 3 के बारे में विस्तार से जानेंगे।

लैटिस-आधारित क्रिप्टोग्राफी (Lattice-based Cryptography): यह बहुआयामी लैटिस स्पेस में शॉर्टेस्ट वेक्टर प्रॉब्लम (SVP) और क्लोजेस्ट वेक्टर प्रॉब्लम (CVP), और उनसे प्राप्त LWE समस्या पर आधारित है। यह NIST मानकीकरण का केंद्र है, और इसमें Kyber, Dilithium और FALCON शामिल हैं। यह प्रसंस्करण गति, पब्लिक कुंजी आकार और सिफरटेक्स्ट (ciphertext) आकार का सबसे अच्छा संतुलन प्रदान करता है, और सामान्य उद्देश्य के उपयोग के लिए उपयुक्त है।
हैश-आधारित क्रिप्टोग्राफी (Hash-based Cryptography): यह अपनी सुरक्षा को पूरी तरह से क्रिप्टोग्राफ़िक हैश फ़ंक्शंस (जैसे SHA-2 और SHAKE) के ‘कोलिजन रेजिस्टेंस (Collision Resistance)’ और ‘वन-वेनेस (One-wayness)’ पर आधारित करता है। यह केवल डिजिटल हस्ताक्षर (जैसे SPHINCS+) पर लागू होता है, लेकिन इसकी सुरक्षा का प्रमाण सबसे मजबूत है और यह अज्ञात गणितीय हमलों के प्रति अत्यधिक प्रतिरोधी है।
कोड-आधारित क्रिप्टोग्राफी (Code-based Cryptography): त्रुटि-सुधार कोड के सिद्धांत पर आधारित, यह सिंड्रोम डिकोडिंग समस्या (Syndrome Decoding Problem) की कठिनाई पर निर्भर करता है। 1970 के दशक में प्रस्तावित Classic McEliece इसका प्रतिनिधि है, जिसका इतिहास बहुत लंबा है और सुरक्षा का ट्रैक रिकॉर्ड सिद्ध है, लेकिन दूसरी ओर, पब्लिक-की का आकार बहुत बड़ा (मेगाबाइट में) होता है।
मल्टीवेरिएट पॉलीनोमियल क्रिप्टोग्राफी (Multivariate Polynomial Cryptography): परिमित क्षेत्र (finite field) पर मल्टीवेरिएट क्वाड्रैटिक समीकरणों की प्रणाली को हल करने की कठिनाई (MQ समस्या) पर आधारित है। इसे मुख्य रूप से डिजिटल हस्ताक्षर (जैसे Rainbow) के रूप में प्रस्तावित किया गया था, लेकिन NIST के अंतिम दौर के दौरान एक शक्तिशाली हमले की विधि खोजी गई जिसने इसे एक साधारण पीसी पर कुछ दिनों में क्रैक कर दिया, जिसके कारण कई एल्गोरिदम मानकीकरण से बाहर हो गए।
आइसोजेनी-आधारित क्रिप्टोग्राफी (Isogeny-based Cryptography): एलिप्टिक कर्व्स के आइसोजेनी ग्राफ पर पथ-खोज समस्या (Path-finding problem) पर आधारित है। कुंजी का आकार बहुत छोटा है, और इसे ECC का सही उत्तराधिकारी माना जा रहा था, लेकिन अंतिम उम्मीदवार ‘SIKE’ को 2022 में क्लासिकल गणित (Castryck-Decru हमले आदि) का उपयोग करके एक साधारण पीसी पर कुछ ही घंटों में पूरी तरह से डिक्रिप्ट कर दिया गया, जो PQC डिजाइन की कठिनाई और खतरे का प्रतीक एक नाटकीय अंत था।

4. लैटिस क्रिप्टोग्राफी की गहराई: LWE समस्या और Module-LWE की गणितीय नींव

वर्तमान में सबसे आशाजनक माना जाने वाला और मानकीकरण का केंद्र लैटिस क्रिप्टोग्राफी (Lattice-based cryptography) है। इसकी सुरक्षा का आधार LWE समस्या (Learning with Errors) है। इसे 2005 में ओडेड रेगेव (Oded Regev) द्वारा प्रस्तावित किया गया था, और इस ऐतिहासिक उपलब्धि के लिए उन्हें गोडेल पुरस्कार (Gödel Prize) से सम्मानित किया गया। LWE समस्या को समझे बिना आधुनिक PQC के बारे में बात करना असंभव है।

4.1. LWE समस्या (Learning with Errors) क्या है?

सबसे पहले, आइए एक सरल रैखिक समीकरण प्रणाली (linear equation system) पर विचार करें। मान लीजिए कि किसी मॉड्यूलस $q$ (मॉड्यूलो $q$) के तहत एक ज्ञात यादृच्छिक (random) मैट्रिक्स $A$ है, एक अज्ञात गुप्त वेक्टर $\vec{s}$ है, और उनका गुणनफल $\vec{b}$ दिया गया है।

$$ \vec{b} = A\vec{s} \pmod q $$

इस समय, सार्वजनिक जानकारी $A$ और $\vec{b}$ से अज्ञात $\vec{s}$ को खोजना आसान है। यदि हम ‘गौसियन एलिमिनेशन (Gaussian elimination)’ जैसे शास्त्रीय एल्गोरिदम का उपयोग करते हैं, तो हम आसानी से बहुपद समय में $\vec{s}$ की गणना कर सकते हैं।

हालाँकि, यदि हम इस समीकरण में ‘छोटी जानबूझकर की गई त्रुटि (शोर/noise)’ जोड़ते हैं, तो समस्या की कठिनाई नाटकीय रूप से बढ़ जाती है। यही LWE समस्या है।

एक अज्ञात गुप्त वेक्टर $\vec{s} \in \mathbb{Z}_q^n$ और एक बेतरतीब ढंग से चुना गया मैट्रिक्स $A \in \mathbb{Z}_q^{m \times n}$ तैयार करें। इसके अलावा, एक त्रुटि वेक्टर $\vec{e} \in \mathbb{Z}_q^m$ तैयार करें जिसे सामान्य वितरण (normal distribution) या द्विपद वितरण (binomial distribution) के अनुसार चुना गया हो और जिसके ‘तत्वों का मान पर्याप्त रूप से छोटा’ हो, और $\vec{b}$ की गणना निम्नानुसार करें:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Search LWE समस्या वह समस्या है जिसमें ‘सार्वजनिक जानकारी $(A, \vec{b})$ से गुप्त जानकारी $\vec{s}$ को खोजना’ होता है। इस त्रुटि $\vec{e}$ की उपस्थिति के कारण, यदि हम गौसियन एलिमिनेशन जैसे बीजगणितीय समाधान (algebraic solution) करने का प्रयास करते हैं, तो समीकरणों को जोड़ने और घटाने की प्रक्रिया में त्रुटि $\vec{e}$ बहुत अधिक बढ़ जाती है, और अंततः यह यादृच्छिक मूल्यों से अप्रभेद्य हो जाती है और विफल हो जाती है।

LWE समस्या की महानता इस तथ्य में निहित है कि एक मजबूत सैद्धांतिक प्रमाण (reduction) मौजूद है कि जब तक कोई ऐसा क्वांटम एल्गोरिदम नहीं है जो लैटिस पर ‘वर्स्ट-केस हार्डनेस (Worst-case hardness)’ समस्याओं जैसे कि GapSVP (Decision Shortest Vector Problem) या SIVP (Shortest Independent Vector Problem) को हल कर सके, LWE समस्या को भी औसत मामले (Average-case) में हल नहीं किया जा सकता है। दूसरे शब्दों में, भले ही क्रिप्टोग्राफ़िक कुंजी बेतरतीब ढंग से उत्पन्न हो, यह गारंटी दी जाती है कि इसमें सैद्धांतिक ऊपरी सीमा द्वारा समर्थित मजबूत सुरक्षा है।

4.2. Ring-LWE और Module-LWE द्वारा नाटकीय दक्षता सुधार

सामान्य LWE समस्या (Standard LWE) में सुरक्षा का बहुत स्पष्ट आधार होता है, लेकिन मैट्रिक्स $A$ का आकार बहुत बड़ा हो जाता है, और कुंजी का आकार मेगाबाइट-श्रेणी का हो जाता है, जो व्यावहारिक नहीं है। इसलिए, पॉलीनोमियल रिंग्स (Polynomial Rings) का उपयोग करके एक बीजगणितीय संरचना बनाने का दृष्टिकोण प्रस्तावित किया गया था।

Ring-LWE समस्या में, साधारण वैक्टर या मैट्रिक्स के बजाय, हम एक निश्चित बहुपद वलय (polynomial ring) $R_q$ के तत्वों (बहुपद) का उपयोग करते हैं। NIST मानक आमतौर पर निम्नलिखित जैसे साइक्लोटोमिक बहुपद वलय (cyclotomic polynomial ring) का उपयोग करता है:

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

यहाँ, $n$ 2 की घात (power of 2) (जैसे: 256) है, और $q$ एक उपयुक्त अभाज्य संख्या (prime number) है। इस रिंग पर, हम $b = a \cdot s + e \pmod q$ की गणना करने के लिए तत्वों $a, s, e \in R_q$ का उपयोग करते हैं। चूंकि एक बहुपद $a$ में $n$ गुणांक (coefficients) होते हैं, डेटा को काफी संपीड़ित (compressed) किया जा सकता है। इसके अलावा, NTT (Number Theoretic Transform) का उपयोग करके, जो कि फास्ट फूरियर ट्रांसफॉर्म (FFT) का एक परिमित क्षेत्र (finite field) संस्करण है, बहुपदों का गुणन $O(n \log n)$ की कम्प्यूटेशनल जटिलता के साथ बहुत तेज गति से संभव हो जाता है।

हालाँकि, Ring-LWE के साथ यह चिंता थी कि ‘रिंग की विशेष बीजगणितीय संरचना के कारण अज्ञात कमजोरियाँ मौजूद हो सकती हैं’। इसके अलावा, जब सुरक्षा स्तर (जैसे AES-128, 192, 256 समतुल्य) बदलते हैं, तो बहुपद की डिग्री $n$ को ही बदलना पड़ता था, और इसके साथ NTT एल्गोरिदम आदि जैसे संपूर्ण कार्यान्वयन को फिर से लिखना पड़ता था, जो एक इंजीनियरिंग चुनौती थी।

इसलिए, मानकीकृत एल्गोरिदम Kyber और Dilithium ने Module-LWE (M-LWE) समस्या को अपनाया। Module-LWE संरचनाहीन Standard LWE और अत्यधिक संरचित Ring-LWE के बीच एक समझौता है, और बहुपद वलय $R_q$ के तत्वों से बने $k \times k$ मैट्रिक्स (मॉड्यूल) का उपयोग करता है।

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Module-LWE का सबसे बड़ा लाभ यह है कि बहुपद की डिग्री $n$ (NIST मानक में $n=256$) को स्थिर रखते हुए, मैट्रिक्स के आयाम (dimension) $k$ को बदलकर सुरक्षा स्तर को आसानी से बढ़ाया या घटाया जा सकता है। उदाहरण के लिए, Kyber के मामले में, आयाम $k$ को निम्नानुसार समायोजित किया गया है:

Kyber512 (Level 1): $k = 2$ (AES-128 समतुल्य)
Kyber768 (Level 3): $k = 3$ (AES-192 समतुल्य)
Kyber1024 (Level 5): $k = 4$ (AES-256 समतुल्य)

इससे सभी सुरक्षा स्तरों पर बुनियादी NTT कोड और बहुपद गणना हार्डवेयर सर्किट का 100% पुन: उपयोग करना संभव हो गया, जिससे कार्यान्वयन की सुरक्षा और दक्षता में नाटकीय रूप से सुधार हुआ।

5. CRYSTALS-Kyber (ML-KEM): अगली पीढ़ी का की एनकैप्सुलेशन मैकेनिज्म (Key Encapsulation Mechanism)

FIPS 203 (ML-KEM) के रूप में औपचारिक रूप से मानकीकृत CRYSTALS-Kyber, उपर्युक्त Module-LWE समस्या पर आधारित एक की एनकैप्सुलेशन मैकेनिज्म (KEM) है। यह भविष्य में TLS 1.3 और SSH आदि में सत्र कुंजियों (session keys) को सुरक्षित रूप से साझा करने के लिए वास्तविक वैश्विक मानक बन जाएगा।

5.1. KEM (Key Encapsulation Mechanism) वास्तुकला (Architecture)

PQC युग में, RSA की तरह ‘क्लाइंट एक साझा कुंजी बनाता है और इसे सर्वर की सार्वजनिक कुंजी के साथ एन्क्रिप्ट करके भेजता है’ के सीधे दृष्टिकोण के बजाय, KEM का एनकैप्सुलेशन ढांचा मानक होगा।

sequenceDiagram participant Client as "क्लाइंट (Alice)" participant Server as "सर्वर (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "गुप्त कुंजी (sk) और सार्वजनिक कुंजी (pk) उत्पन्न करें" Client->>Server: "सार्वजनिक कुंजी (pk) भेजें" Note over Server: "ML-KEM Encaps()" Server->>Server: "एक यादृच्छिक साझा कुंजी (K) उत्पन्न करें" Server->>Server: "K को pk के साथ एनकैप्सुलेट करें और सिफरटेक्स्ट (c) बनाएं" Server->>Client: "सिफरटेक्स्ट (c) भेजें" Note over Client: "ML-KEM Decaps()" Client->>Client: "गुप्त कुंजी (sk) का उपयोग करके सिफरटेक्स्ट (c) को डिक्रिप्ट करें" Client->>Client: "एनकैप्सुलेशन हटाएं और साझा कुंजी (K) निकालें" Note over Client, Server: "साझा की गई साझा कुंजी (K) का उपयोग करके AES आदि के साथ एन्क्रिप्टेड संचार शुरू करें"

5.2. Kyber के आंतरिक एल्गोरिदम का तंत्र और फुजिसाकी-ओकामोटो (Fujisaki-Okamoto) ट्रांसफॉर्म

Kyber का डिज़ाइन बहुत ही परिष्कृत है। सबसे पहले, यह एक पब्लिक-की क्रिप्टोग्राफी सिस्टम (Kyber.CPAPKE) बनाता है जो केवल CPA (Chosen Plaintext Attack) के खिलाफ सुरक्षित है, और फिर उस पर फुजिसाकी-ओकामोटो ट्रांसफॉर्म (Fujisaki-Okamoto Transform) नामक क्रिप्टोग्राफ़िक रूप से बहुत शक्तिशाली तकनीक को लागू करके, इसे एक पूर्ण KEM में अपग्रेड करने के लिए डिज़ाइन किया गया है जो CCA (Adaptive Chosen Ciphertext Attack) के खिलाफ भी सुरक्षित है।

CPAPKE के मूल एन्क्रिप्शन और डिक्रिप्शन तंत्र इस प्रकार हैं:

कुंजी निर्माण (Key Generation):
- एक यादृच्छिक बीज (random seed) मान से, NTT डोमेन पर मैट्रिक्स $A \in R_q^{k \times k}$ उत्पन्न करें। मॉड्यूलस $q$ का उपयोग $3329$ किया जाता है।
- सेंटर्ड बाइनोमियल डिस्ट्रीब्यूशन (CBD) से, छोटे गुणांक वाले गुप्त वेक्टर $\vec{s}$ और त्रुटि वेक्टर $\vec{e}$ का नमूना लें।
- $\vec{t} = A\vec{s} + \vec{e}$ की गणना करें। सार्वजनिक कुंजी $(A, \vec{t})$ है, गुप्त कुंजी $\vec{s}$ है। (व्यवहार में $A$ को एक बीज मान के रूप में प्रकाशित किया जाता है ताकि बैंडविड्थ बचाई जा सके)।
एन्क्रिप्शन (Encryption):
- 32-बाइट संदेश ($m$) (साझा कुंजी की सामग्री) जिसे आप साझा करना चाहते हैं, उसे एक बहुपद में एनकोड करें।
- एक नया यादृच्छिक वेक्टर $\vec{r}$ और छोटी त्रुटियां $\vec{e_1}, e_2$ उत्पन्न करें।
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- सिफरटेक्स्ट $(\vec{u}, v)$ बन जाता है।
डिक्रिप्शन (Decryption):
- प्राप्तकर्ता $v - \vec{s}^T\vec{u}$ की गणना करता है।
- इस समीकरण का विस्तार करने पर यह निम्न प्रकार से बन जाता है: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- यहाँ $\vec{t} = A\vec{s} + \vec{e}$ को प्रतिस्थापित करने पर, मुख्य पद $\vec{s}^TA^T\vec{r}$ रद्द हो जाता है।
- जो बचता है वह है $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$।
- चूँकि कोष्ठक में दिए गए पद ‘छोटी त्रुटियों के उत्पाद और योग’ हैं, इसलिए वे समग्र रूप से पर्याप्त छोटे मान (शोर) तक सीमित रहते हैं। इसलिए, प्रत्येक गुणांक $0$ के करीब है या $q/2$ के करीब है, इसकी थ्रेशोल्ड निर्णय (threshold judgment) करके, मूल संदेश $m$ के बिट्स (0 या 1) को बिना किसी त्रुटि के पूरी तरह से बहाल किया जा सकता है।

Kyber की सबसे बड़ी ताकत इसकी असाधारण प्रसंस्करण गति और मध्यम कुंजी का आकार है। Kyber768 के मामले में, सार्वजनिक कुंजी का आकार 1,184 बाइट्स है, और सिफरटेक्स्ट आकार 1,088 बाइट्स है, जो RSA-3072 (लगभग 384 बाइट्स के कुंजी आकार) की तुलना में बड़ा है, लेकिन यह आधुनिक इंटरनेट संचार के MTU (Maximum Transmission Unit) के भीतर पैकेट विखंडन (packet fragmentation) के बिना फिट हो सकता है, और इसका नेटवर्क लेटेंसी पर लगभग कोई प्रतिकूल प्रभाव नहीं पड़ता है।

6. CRYSTALS-Dilithium (ML-DSA): लैटिस-आधारित सामान्य-उद्देश्य डिजिटल हस्ताक्षर

डिजिटल हस्ताक्षरों के मानकीकरण में, समान लैटिस क्रिप्टोग्राफी दृष्टिकोण के भीतर भी विभिन्न डिजाइन दर्शन वाले एल्गोरिदम ने प्रतिस्पर्धा की। उनमें से, CRYSTALS-Dilithium को एक सामान्य-उद्देश्य डिजिटल हस्ताक्षर के रूप में FIPS 204 (ML-DSA) के लिए चुना गया था।

6.1. Fiat-Shamir with Aborts पैराडाइम

Kyber की तरह ही, Dilithium भी Module-LWE (और Module-SIS समस्या) पर आधारित एक डिजिटल हस्ताक्षर योजना है। डिज़ाइन का आधार एक अत्यंत महत्वपूर्ण पैराडाइम का उपयोग करता है जिसे ‘Fiat-Shamir with Aborts (रद्द करने के साथ फिएट-शमीर ट्रांसफॉर्म)’ कहा जाता है।

फिएट-शमीर ट्रांसफॉर्म अपने आप में एक इंटरेक्टिव ज़ीरो-नॉलेज प्रूफ़ (interactive zero-knowledge proof) प्रोटोकॉल को गैर-इंटरेक्टिव डिजिटल हस्ताक्षर में बदलने की एक मानक विधि है। प्रूवर (हस्ताक्षरकर्ता) एक कमिटमेंट $y$ उत्पन्न करता है, $w = Ay$ की गणना करता है और इसे एक हैश फ़ंक्शन के माध्यम से गुजार कर एक यादृच्छिक चुनौती (random challenge) $c$ प्राप्त करता है, और प्रतिक्रिया $z = y + cs$ की गणना करता है।

हालाँकि, यदि इसे लैटिस क्रिप्टोग्राफी में सरलता से लागू किया जाता है, तो प्रतिक्रिया $z$ का वितरण गुप्त कुंजी $s$ के मान के आधार पर विकृत हो जाता है, और एक घातक समस्या (साइड-चैनल जैसी गणितीय जानकारी लीक होना) थी कि कई हस्ताक्षरों को देखने वाला हमलावर धीरे-धीरे गुप्त कुंजी $s$ की जानकारी लीक होते हुए प्राप्त कर लेगा।

Dilithium की डिज़ाइन टीम (Lyubashevsky और अन्य) ने एक तकनीक पेश की जिसे ‘रिजेक्शन सैंपलिंग (Rejection Sampling)’ कहा जाता है, जिसमें यदि हस्ताक्षर की गणना के परिणाम $z$ के गुणांक पूर्व-निर्धारित सुरक्षित थ्रेशोल्ड सीमा के भीतर नहीं आते हैं, तो संपूर्ण हस्ताक्षर प्रक्रिया को छोड़ दिया जाता है (Abort) और एक नए यादृच्छिक संख्या $y$ का उपयोग करके खरोंच से गणना फिर से की जाती है।

नतीजतन, अंतिम रूप से आउटपुट होने वाला हस्ताक्षर $z$ गुप्त कुंजी पर बिल्कुल निर्भर नहीं करता है और यह पूरी तरह से एक समान वितरण (uniform distribution) बन जाता है, जो गणितीय रूप से सूचना रिसाव को पूरी तरह से रोकने में सफल रहा।

6.2. Dilithium के लाभ और कार्यान्वयन में आसानी

Dilithium के डिजाइन का एक बड़ा फायदा यह है कि यह हस्ताक्षर निर्माण प्रक्रिया में जटिल ‘गाऊसी वितरण (Gaussian distribution) से सैंपलिंग’ या ‘फ्लोटिंग-पॉइंट गणना’ का बिल्कुल उपयोग नहीं करता है। इसे केवल एक समान वितरण (uniform distribution) से सैंपलिंग, सरल पूर्णांक मॉड्यूलो अंकगणित, NTT और हैश फ़ंक्शंस (SHAKE) के साथ लागू किया जा सकता है, जिससे एम्बेडेड माइक्रोकंट्रोलर्स से लेकर क्लाउड सर्वर तक विभिन्न प्रकार के वातावरण में इसे सुरक्षित रूप से और निरंतर समय (constant-time) में लागू करना आसान हो जाता है। इसके कारण, यह टाइमिंग हमलों (timing attacks) जैसे भौतिक साइड-चैनल हमलों (side-channel attacks) के खिलाफ भी मजबूत प्रतिरोध रखता है।

7. FALCON (FN-DSA): अत्यधिक कॉम्पैक्ट लैटिस हस्ताक्षर

NIST ने Dilithium से भिन्न विशेषताओं वाले एक अन्य लैटिस-आधारित हस्ताक्षर के रूप में FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) को मानकीकरण उम्मीदवार के रूप में चुना (वर्तमान में FN-DSA के रूप में मसौदा तैयार किया जा रहा है)।

7.1. NTRU लैटिस और गाऊसी सैंपलिंग (Gaussian Sampling)

FALCON की सबसे बड़ी विशेषता यह है कि यह LWE समस्या के बजाय NTRU (N-th degree Truncated polynomial Ring Units) लैटिस का उपयोग करता है, जिसका इतिहास 1996 से काफी पुराना है। इसके अलावा, यह GPV (Gentry-Peikert-Vaikuntanathan) ढांचे पर आधारित ‘हैश-एंड-साइन (Hash-and-Sign)’ पैराडाइम को अपनाता है।

Hash-and-Sign में, संदेश का हैश मान अंतरिक्ष में एक लक्ष्य बिंदु के रूप में सेट किया जाता है, और उस बिंदु के सबसे करीब लैटिस पर बिंदु (क्लोजेस्ट वेक्टर प्रॉब्लम का अनुमानित समाधान) खोजना हस्ताक्षर बन जाता है। इसके लिए, गुप्त कुंजी ‘अच्छी गुणवत्ता के छोटे आधार (good short basis)’ का उपयोग करके असतत गाऊसी वितरण (discrete Gaussian distribution) के अनुसार बिंदुओं का नमूना लेना आवश्यक है।

FALCON ने ‘फास्ट फूरियर ऑर्थोगोनलाइज़ेशन (Fast Fourier Orthogonalization: FFO)’ नामक तकनीक का उपयोग करके इस भारी गणना को नाटकीय रूप से तेज कर दिया।

7.2. FALCON के फायदे और नुकसान

FALCON का जबरदस्त फायदा यह है कि इसका हस्ताक्षर आकार और सार्वजनिक कुंजी का आकार बहुत छोटा (कॉम्पैक्ट) है। Dilithium3 का हस्ताक्षर आकार लगभग 3,309 बाइट्स है, जबकि FALCON-512 का हस्ताक्षर आकार केवल लगभग 666 बाइट्स है। सार्वजनिक कुंजी भी 897 बाइट्स पर बहुत छोटी है, जो इसे ऐसे वातावरणों में एक तारणहार बनाती है जहाँ संचार बैंडविड्थ बेहद सीमित है, या IoT उपकरणों और विशिष्ट नेटवर्क प्रोटोकॉल के लिए।

हालाँकि, एक महत्वपूर्ण नुकसान भी है। चूँकि हस्ताक्षर उत्पन्न करते समय जटिल फ्लोटिंग-पॉइंट गणना (64-बिट IEEE 754) के साथ असतत गाऊसी सैंपलिंग आवश्यक है, इसलिए समय रिसाव को रोकने के लिए निरंतर-समय कार्यान्वयन (Constant-time implementation) अत्यंत कठिन है, और कोड भी बड़ा हो जाता है। इस कारण से, FALCON को सामान्य-उद्देश्य के उपयोग (Dilithium) के विपरीत एक विशिष्ट अनुप्रयोग-केंद्रित शक्तिशाली विशेष एल्गोरिदम के रूप में रखा गया है।

graph LR A["डिजिटल हस्ताक्षर की आवश्यकताएं"] --> B{"सबसे महत्वपूर्ण बाधा क्या है?"} B -->|"कार्यान्वयन की सरलता, बहुमुखी प्रतिभा, निरंतर-समय कार्यान्वयन में आसानी"| C["Dilithium (ML-DSA)"] B -->|"संचार बैंडविड्थ का न्यूनीकरण, डेटा आकार की सघनता"| D["FALCON (FN-DSA)"] C --> E["सामान्य-उद्देश्य TLS प्रमाणपत्र, सॉफ़्टवेयर इलेक्ट्रॉनिक हस्ताक्षर"] D --> F["सख्त पैकेट आकार सीमा वाले प्रोटोकॉल, विशेष वातावरण"]

8. SPHINCS+ (SLH-DSA): सबसे मजबूत सुरक्षा का दावा करने वाला हैश-आधारित हस्ताक्षर

उस सबसे खराब स्थिति (एक दुर्लभ घटना) की तैयारी में कि भविष्य में एक प्रतिभाशाली गणितज्ञ की सफलता से लैटिस क्रिप्टोग्राफी की सुरक्षा टूट सकती है, NIST ने लैटिस क्रिप्टोग्राफी से बिल्कुल अलग दृष्टिकोण के साथ एक मानक के रूप में FIPS 205 (SLH-DSA), यानी SPHINCS+ तैयार किया।

SPHINCS+ को हैश-आधारित हस्ताक्षर के रूप में वर्गीकृत किया गया है। इसकी सुरक्षा का आधार केवल एक बात पर निर्भर करता है: ‘उपयोग किए जा रहे क्रिप्टोग्राफिक हैश फ़ंक्शंस (जैसे SHA-2 और SHAKE256) में कोलिजन रेजिस्टेंस (collision resistance) और वन-वेनेस (one-wayness) है’। चूँकि यह LWE या अभाज्य गुणनखंड जैसी किसी विशिष्ट बीजगणितीय संरचना वाली गणितीय समस्याओं पर निर्भर नहीं करता है, इसलिए यह अत्यंत मजबूत सुरक्षा (सबसे रूढ़िवादी सुरक्षा) का दावा करता है जिसका भविष्य में कोई भी शक्तिशाली क्वांटम एल्गोरिदम आने पर केवल हैश फ़ंक्शन की आउटपुट लंबाई बढ़ाकर मुकाबला किया जा सकता है।

8.1. WOTS+ और FORS द्वारा स्टेटलेस वास्तुकला (Stateless Architecture)

हैश-आधारित हस्ताक्षरों का एक लंबा इतिहास है, जो 1970 के दशक में लैम्पोर्ट सिग्नेचर (Lamport signatures) और विंटरनिट्ज़ वन-टाइम सिग्नेचर (WOTS) तक जाता है। ये डिस्पोजेबल कुंजियां (disposable keys) थीं जिन्हें ‘केवल एक बार सुरक्षित रूप से हस्ताक्षर’ किया जा सकता था। इन्हें कई बार उपयोग करने योग्य बनाने के लिए, XMSS (eXtended Merkle Signature Scheme) और LMS जैसे एल्गोरिदम विकसित किए गए, जो अनगिनत वन-टाइम कुंजियों को एकल रूट हैश के साथ प्रबंधित करने के लिए मर्कल ट्री (Merkle Tree) को मिलाते हैं।

हालाँकि, XMSS और LMS में एक बड़ी खामी थी कि वे ‘स्टेटफुल (Stateful)’ थे। हर बार हस्ताक्षर किए जाने पर गैर-वाष्पशील मेमोरी (non-volatile memory) में इंडेक्स स्टेट को कड़ाई से रिकॉर्ड करना आवश्यक था कि ‘कौन सी वन-टाइम कुंजी का उपयोग किया गया था’, और यदि वर्चुअल मशीन के स्नैपशॉट को पुनर्स्थापित करने के कारण स्टेट वापस आ जाता है और उसी वन-टाइम कुंजी का दो बार उपयोग किया जाता है, तो गुप्त कुंजी तुरंत लीक हो जाएगी और सिस्टम ढह जाएगा।

SPHINCS+ एक ‘स्टेटलेस (Stateless)’ हैश-आधारित हस्ताक्षर है जिसने इस राज्य प्रबंधन (state management) की परेशानी को हल किया। इसकी मुख्य तकनीक निम्नलिखित का संयोजन है:

WOTS+ (Winternitz One-Time Signature Plus): एक बुनियादी वन-टाइम हस्ताक्षर।
FORS (Forest of Random Subsets): फ्यू-टाइम सिग्नेचर (Few-Time Signature) तकनीक। एक ही कुंजी को कुछ बार पुन: उपयोग करने पर भी सुरक्षा बनाए रखता है।
Hyper-Tree (विशाल वृक्ष संरचना): एक विशाल संरचना जिसमें मर्कल ट्री को कई परतों में एक के ऊपर পুনরায় रखा गया है।

SPHINCS+ में, हस्ताक्षर करते समय स्टेट को प्रबंधित करने के बजाय, यह हाइपर-ट्री (Hyper-Tree) के आधार पर बड़ी संख्या में FORS कुंजियों में से एक को बेतरतीब ढंग से चुनने के लिए छद्म यादृच्छिक संख्याओं (pseudo-random numbers) का उपयोग करके हस्ताक्षर करता है। चूँकि पेड़ के पत्तों की संख्या खगोलीय रूप से बड़ी होती है, इसलिए संयोग से एक ही कुंजी को दो बार चुनने की संभावना (टकराव/collision) नगण्य रूप से छोटी हो जाती है, जिसके परिणामस्वरूप स्टेटलेस प्राप्त होता है।

SPHINCS+ की एकमात्र और सबसे बड़ी कमजोरी यह है कि इसका हस्ताक्षर आकार बहुत बड़ा है। मापदंडों के आधार पर, हस्ताक्षर का आकार 17 किलोबाइट से 49 किलोबाइट तक पहुँच सकता है, और हस्ताक्षर बनाने की गति लैटिस क्रिप्टोग्राफी की तुलना में बहुत धीमी है। इसलिए, यह रोजमर्रा के वेब ब्राउज़िंग में उपयोग किए जाने के बजाय, सॉफ़्टवेयर अपडेट सिग्नेचर या रूट सर्टिफ़िकेट अथॉरिटी (CA) सर्टिफ़िकेट जैसे अनुप्रयोगों में उपयोग किए जाने की उम्मीद है, जहाँ हस्ताक्षर अक्सर नहीं किए जाते हैं और लंबी अवधि के लिए पूर्ण सुरक्षा की दृढ़ता से आवश्यकता होती है।

9. कोड-आधारित क्रिप्टोग्राफी: Classic McEliece नामक एक पुराना अच्छा विशालकाय (Giant)

NIST की मानकीकरण प्रक्रिया में, राउंड 4 के अंतिम उम्मीदवार के रूप में अभी भी मूल्यांकन किए जा रहे महत्वपूर्ण दृष्टिकोणों में से एक कोड-आधारित क्रिप्टोग्राफी का Classic McEliece है।

1978 में रॉबर्ट मैकएलीस (Robert McEliece) द्वारा प्रस्तावित यह एल्गोरिदम पब्लिक-की क्रिप्टोग्राफी के इतिहास में RSA के साथ सबसे पुराने एल्गोरिदम में से एक है। यह ‘गोप्पा कोड (Goppa code)’ नामक एक बीजगणितीय ज्यामिति कोड (algebraic geometry code) का उपयोग करता है, और संदेश में जानबूझकर त्रुटियों (शोर वेक्टर) को जोड़कर इसे एन्क्रिप्ट करता है। यह ‘सिंड्रोम डिकोडिंग समस्या (Syndrome Decoding Problem)’ पर आधारित है जहाँ केवल वह व्यक्ति जिसके पास गुप्त कुंजी के रूप में गोप्पा कोड का पैरिटी-चेक मैट्रिक्स (parity-check matrix) है, वह शक्तिशाली त्रुटि-सुधार (error-correction) क्षमता का उपयोग करके त्रुटि को दूर कर सकता है और मूल संदेश को डिक्रिप्ट कर सकता है।

$$ \vec{c} = \vec{m} G + \vec{e} $$

(यहाँ $G$ एक स्क्रैम्बल्ड जनरेटर मैट्रिक्स है जो सार्वजनिक कुंजी है, $\vec{e}$ वजन $t$ का त्रुटि वेक्टर है)

Classic McEliece की आश्चर्यजनक बात इसका प्रभावशाली ट्रैक रिकॉर्ड है: प्रस्तावित किए जाने के 40 से अधिक वर्षों के बाद, और दुनिया भर के क्रिप्टोग्राफ़रों द्वारा तीव्र डिक्रिप्शन अनुसंधान के अधीन होने के बावजूद, इसकी कोई भी मौलिक भेद्यता कभी नहीं खोजी गई है। यह PQC के बीच सबसे अधिक ‘समय-परीक्षणित मजबूत सुरक्षा’ रखता है।

इसके अलावा, इसका यह लाभ है कि सिफरटेक्स्ट का आकार बहुत छोटा (केवल 100 से 200 बाइट्स) होता है। हालाँकि, एक घातक खामी है कि सार्वजनिक कुंजी का आकार मेगाबाइट (MB) में होता है। सबसे निचले सुरक्षा स्तर (AES-128 समतुल्य) पर भी, सार्वजनिक कुंजी लगभग 250KB है, और उच्च स्तरों पर यह 1MB से अधिक हो जाती है।

इस कारण से, यह उन अनुप्रयोगों के लिए बिल्कुल लागू नहीं है जो TLS हैंडशेक की तरह संचार के हर बार नेटवर्क पर सार्वजनिक कुंजी भेजते हैं। हालाँकि, विशेष उपयोग के मामलों में जहाँ सार्वजनिक कुंजी को पहले से सिस्टम में रखा जा सकता है, जैसे कि VPN प्री-शेयर्ड कुंजियों का आदान-प्रदान, फ़र्मवेयर में सार्वजनिक कुंजियों को हार्डकोडिंग करना, या उपग्रह संचार, इसकी मजबूत सुरक्षा के कारण इसे एक अत्यंत आशाजनक विकल्प के रूप में माना जाना जारी है।

10. प्रत्येक PQC एल्गोरिदम के प्रदर्शन की तुलना और ट्रेड-ऑफ़ (Trade-offs)

अब तक बताए गए प्रमुख एल्गोरिदम के संबंध में, सामान्य सुरक्षा स्तरों (NIST Level 2 से 3 समतुल्य, AES-128 से 192 स्तर) पर प्रदर्शन विशेषताओं को निम्न तालिका में संक्षेपित किया गया है।

एल्गोरिदम (मानक नाम)	श्रेणी	गणितीय आधार	सार्वजनिक कुंजी का आकार	गुप्त कुंजी का आकार	सिफरटेक्स्ट/हस्ताक्षर का आकार	प्रसंस्करण गति की प्रवृत्ति	मुख्य विशेषताएं और अनुप्रयोग
Kyber768 (ML-KEM)	KEM	Module-LWE	1,184 Bytes	2,400 Bytes	1,088 Bytes	बहुत तेज़	कुंजी के आकार और गति का सबसे अच्छा संतुलन। TLS 1.3 आदि के लिए सामान्य KEM मानक।
Dilithium3 (ML-DSA)	हस्ताक्षर	Module-LWE	1,952 Bytes	4,032 Bytes	3,309 Bytes	निर्माण और सत्यापन दोनों में तेज़	सरल कार्यान्वयन। सामान्य-उद्देश्य डिजिटल हस्ताक्षर मानक।
FALCON-512 (FN-DSA)	हस्ताक्षर	NTRU लैटिस	897 Bytes	1,281 Bytes	666 Bytes	हस्ताक्षर निर्माण धीमा है, सत्यापन बहुत तेज़	अत्यंत छोटा हस्ताक्षर आकार। हालाँकि फ्लोटिंग-पॉइंट गणना आवश्यक है। एम्बेडेड/IoT के लिए।
SPHINCS+ (SLH-DSA)	हस्ताक्षर	हैश फ़ंक्शन	32 Bytes	64 Bytes	लगभग 17,000 Bytes	निर्माण बहुत धीमा है	गणितीय विफलता का जोखिम लगभग शून्य है। रूट प्रमाणपत्र आदि जैसे उच्च-सुरक्षा अनुप्रयोग।
Classic McEliece	KEM	Goppa कोड	लगभग 1.04 MB	13,568 Bytes	188 Bytes	एनकैप्सुलेशन तेज़ है	40 वर्षों का सुरक्षा ट्रैक रिकॉर्ड। सार्वजनिक कुंजी विशाल है। उन वातावरणों के लिए जहाँ हार्डकोडिंग संभव है।

ट्रेड-ऑफ़ (Trade-offs) को समझना

PQC की दुनिया में, कोई एकल जादुई एल्गोरिदम नहीं है जो ‘आकार में छोटा, गति में तेज़, और गणितीय गारंटी में परिपूर्ण’ हो।

इंटरनेट मानक (Kyber / Dilithium): इनके प्रदर्शन का संतुलन सबसे अच्छा है और ये वर्तमान RSA/ECC से ड्रॉप-इन रिप्लेसमेंट (सीधे प्रतिस्थापित करने) के लिए सबसे उपयुक्त हैं।
अत्यधिक रूढ़िवादिता (SPHINCS+): यदि आप भविष्य की गणितीय सफलताओं के खिलाफ पूर्ण बीमा चाहते हैं, भले ही इसके लिए डेटा आकार और प्रसंस्करण गति का बलिदान देना पड़े, तो इसे चुना जाता है।
विशेष वातावरण के लिए (FALCON / Classic McEliece): ये विशेष हथियार हैं जिन्हें पर्यावरणीय बाधाओं के अनुसार चुना जाता है, जैसे कि जब संचार बैंडविड्थ बेहद संकीर्ण होती है, या पूर्व-वितरण संभव होता है।

11. व्यावसायीकरण की चुनौतियाँ और ‘हाइब्रिड क्रिप्टोग्राफी (Hybrid Cryptography)’ का व्यावहारिक समाधान

NIST के मानकीकरण के पूरा होने और FIPS मानकों के आधिकारिक तौर पर जारी होने के साथ, दुनिया भर में IT बुनियादी ढांचे का PQC संक्रमण (PQC माइग्रेशन) पूरी लगन से शुरू हो गया है। Google का क्रोम ब्राउज़र, Apple का iMessage (PQ3 प्रोटोकॉल), और Cloudflare जैसे नेटवर्क प्रदाताओं ने पहले ही अपने प्रोटोकॉल में PQC समर्थन लागू कर दिया है और वास्तविक संचालन शुरू कर दिया है।

हालाँकि, अचानक पूरी तरह से नए क्रिप्टोग्राफ़िक एल्गोरिदम में स्विच करने में बहुत अधिक जोखिम शामिल है। यदि कुछ वर्षों में कोई प्रतिभाशाली गणितज्ञ Kyber जैसे लैटिस क्रिप्टोग्राफी के खिलाफ एक घातक हमले का तरीका (एक गणितीय दोष जिसे शास्त्रीय कंप्यूटर से भी हल किया जा सकता है) खोज लेता है, तो उस पर निर्भर संपूर्ण सिस्टम एक पल में पूरी तरह से कमजोर हो जाएगा।

इस अनिश्चितता के जोखिम को कम करने के लिए एक व्यावहारिक और अनुशंसित दृष्टिकोण ‘हाइब्रिड क्रिप्टोग्राफी (Hybrid Cryptography)’ है।

हाइब्रिड क्रिप्टोग्राफी में, कुंजियों का आदान-प्रदान वर्तमान क्लासिकल क्रिप्टोग्राफी के लंबे ट्रैक रिकॉर्ड (उदा: X25519 जैसी एलिप्टिक कर्व क्रिप्टोग्राफी) और नए PQC (उदा: Kyber768) दोनों का एक साथ उपयोग करके किया जाता है। प्रत्येक एल्गोरिदम अलग-अलग साझा कुंजी घटकों को उत्पन्न करता है, और अंततः दोनों घटकों को मिश्रित करने और अंतिम मास्टर सीक्रेट उत्पन्न करने के लिए एक सुरक्षित की डेरिवेशन फ़ंक्शन (Key Derivation Function: KDF) का उपयोग किया जाता है।

graph TD A["क्लाइंट"] -->|① X25519 सार्वजनिक कुंजी + Kyber सार्वजनिक कुंजी भेजें| B["सर्वर"] B -->|② X25519 साझा कुंजी + Kyber एनकैप्सुलेटेड सिफरटेक्स्ट वापस भेजें| A A --> C{"मास्टर सीक्रेट व्युत्पत्ति (KDF)"} B --> C C -->|इनपुट: (X25519 साझा कुंजी) || (Kyber साझा कुंजी)| D["सुरक्षित संचार कुंजी (AES-256 / ChaCha20)"] D -->|"क्वांटम खतरों और क्लासिकल कमजोरियों दोनों के प्रति प्रतिरोधी"| E["सुरक्षित हाइब्रिड क्रिप्टोग्राफ़िक संचार (TLS 1.3)"]

यह एक मजबूत टू-टियर सुरक्षा सुनिश्चित करता है, जहाँ ‘यदि क्वांटम कंप्यूटर एक वास्तविकता बन जाते हैं और ECC टूट जाता है, तो Kyber संचार की रक्षा करेगा’, और इसके विपरीत, ‘यदि Kyber में कोई अज्ञात गणितीय दोष पाया जाता है, तो ECC संचार की रक्षा करेगा’। एक विशिष्ट उदाहरण के रूप में, IETF द्वारा मानकीकृत किया जा रहा X25519MLKEM768 (पूर्व में X25519Kyber768) मसौदा है, और वर्तमान में वेब ब्राउज़र और अत्याधुनिक सर्वरों के बीच संचार इस हाइब्रिड पद्धति का उपयोग करके किया जाता है।

इसके अलावा, सिस्टम डिज़ाइन में, क्रिप्टो एजिलिटी (Crypto Agility) की अवधारणा, जिसका अर्थ है ‘विशिष्ट क्रिप्टोग्राफ़िक एल्गोरिदम पर अत्यधिक निर्भर न होना, और यदि कोई एल्गोरिदम विफल हो जाता है तो जल्दी से किसी अन्य एल्गोरिदम (उदा: Kyber से McEliece, Dilithium से SPHINCS+) में स्विच करने में सक्षम वास्तुकला बनाना’, भविष्य के सिस्टम विकास के लिए एक आवश्यक आवश्यकता बन जाएगी।

12. निष्कर्ष: क्रिप्टोग्राफ़िक तकनीक का एक नया क्षितिज

क्वांटम कंप्यूटर, मानवता की स्वप्निल तकनीक, विडंबना यह है कि उन ‘अभाज्य गुणनखंड’ और ‘असतत लघुगणक समस्या’ की गणितीय बाधाओं को तोड़ने का सबसे बड़ा खतरा बन गई है जिन पर हमने कई वर्षों से भरोसा किया था। हालाँकि, इसके आगे झुकने के बजाय, दुनिया भर के क्रिप्टोग्राफ़रों ने लैटिस थ्योरी (lattice theory), हैश फ़ंक्शन ट्री और एरर-करेक्शन कोड जैसे अधिक जटिल और गहन बहुआयामी गणितीय क्षेत्रों का बीड़ा उठाया है, और पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC) नामक एक नई बाधा बनाई है।

NIST द्वारा FIPS 203 (ML-KEM), FIPS 204 (ML-DSA), और FIPS 205 (SLH-DSA) का मानकीकरण पूरा होना कोई लक्ष्य नहीं है। यह PQC माइग्रेशन नामक महाकाव्य यात्रा का पहला कदम है जो आने वाले दशकों तक जारी रहेगा। सॉफ्टवेयर इंजीनियरों और सिस्टम आर्किटेक्ट्स के लिए, नेटवर्क प्रोटोकॉल और सिस्टम के लिए इन नए एल्गोरिदम द्वारा लाए गए ‘कुंजी के आकार में वृद्धि’ और ‘कम्प्यूटेशनल लागत में परिवर्तन’ को कैसे अनुकूल रूप से ढालना है, यह आगे चलकर एक बड़ी तकनीकी चुनौती होगी।

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

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

क्वांटम कंप्यूटर के व्यावहारिक उपयोग का दिन: 2026 में वर्तमान स्थिति

Fri, 11 Sep 2026 06:00:00 +0900

1. प्रस्तावना: 2026 में, क्वांटम कंप्यूटर कहाँ तक पहुँच चुका है?

वर्तमान 2026 में, क्वांटम कंप्यूटिंग ने अतीत के “सैद्धांतिक सपने” से “इंजीनियरिंग वास्तविकता” की ओर एक निर्णायक छलांग लगाई है। कुछ वर्षों पहले तक मुख्यधारा रहे NISQ (Noisy Intermediate-Scale Quantum) उपकरणों की सीमाएँ स्पष्ट होने के साथ, दुनिया भर के अनुसंधान संस्थानों और टेक दिग्गजों ने “फॉल्ट-टॉलरेंट क्वांटम कंप्यूटिंग (FTQC: Fault-Tolerant Quantum Computing)” को साकार करने की दिशा में कदम बढ़ाया है।

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

2. क्वांटम अवस्था की मूल बातें और फिडेलिटी (विश्वसनीयता)

क्वांटम कंप्यूटर की मूल इकाई क्वांटम बिट (Qubit), शास्त्रीय बिट (0 या 1) के विपरीत, 0 और 1 की सुपरपोजिशन (Superposition) अवस्था ले सकती है। एकल क्वांटम बिट की अवस्था को हिल्बर्ट स्पेस (Hilbert space) पर एक वेक्टर के रूप में इस प्रकार दर्शाया जाता है:

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

यहाँ, $\alpha$ और $\beta$ सम्मिश्र संभाव्यता आयाम (probability amplitudes) हैं, जो निम्नलिखित सामान्यीकरण शर्त को पूरा करते हैं:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

क्वांटम गणना के प्रदर्शन को मापने के लिए सबसे महत्वपूर्ण मीट्रिक फिडेलिटी (Fidelity) है। आदर्श क्वांटम अवस्था $|\psi\rangle$ और शोर (noise) के कारण विकृत होकर मिश्रित अवस्था में बदल चुके वास्तविक घनत्व मैट्रिक्स (density matrix) $\rho$ के बीच फिडेलिटी $F$ को इस प्रकार परिभाषित किया जाता है:

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

वर्तमान 2026 में, 2-क्यूबिट गेट (जैसे: CNOT गेट या CZ गेट) की फिडेलिटी सुपरकंडक्टिंग पद्धति में 99.99% की बाधा (तथाकथित “4 नाइन”) को लगातार पार करने लगी है। यह सरफेस कोड द्वारा त्रुटि सुधार की सीमा (लगभग 99%) से काफी अधिक है, और यह व्यावहारिक उपयोग की दिशा में सबसे बड़ी सफलताओं में से एक है।

3. NISQ युग की सीमाएँ और FTQC की ओर प्रतिमान बदलाव (Paradigm Shift)

2010 के दशक के उत्तरार्ध से 2020 के दशक के पूर्वार्ध तक का समय बिना त्रुटि सुधार वाले दसियों से लेकर सैकड़ों क्वांटम बिट वाले उपकरणों, अर्थात NISQ (Noisy Intermediate-Scale Quantum) का युग था। हालाँकि, NISQ की स्पष्ट सीमाएँ थीं।

जैसे-जैसे सर्किट की गहराई (Depth) बढ़ती है, त्रुटियाँ घातांकीय रूप से (exponentially) जमा होती जाती हैं, जिससे सार्थक गणना परिणाम प्राप्त करना असंभव हो जाता है। सर्किट की गहराई $D$ पर समग्र सफलता की संभावना $P_{success}$, एकल गेट की फिडेलिटी $f$ और गेट्स की संख्या $N$ के सापेक्ष इस प्रकार घटती है:

$$ P_{success} \approx f^N $$

यदि $f = 0.99$ के साथ 1000 गेट्स लागू किए जाएं, तो परिणाम $0.99^{1000} \approx 4.3 \times 10^{-5}$ होगा, जो लगभग यादृच्छिक शोर (random noise) में दब जाता है। इस कारण से, 2026 में, NISQ एल्गोरिदम (जैसे VQE या QAOA) को सीधे स्केल अप करने के बजाय, तार्किक क्वांटम बिट (Logical Qubit) उत्पन्न करने पर संसाधनों को केंद्रित किया जा रहा है।

4. क्वांटम त्रुटि सुधार और तार्किक क्वांटम बिट: सरफेस कोड का उन्नत मोर्चा

क्वांटम त्रुटि सुधार (QEC: Quantum Error Correction) एक ऐसी तकनीक है जो कई “भौतिक क्वांटम बिट्स” को एन्कोड करके एक “तार्किक क्वांटम बिट” बनाती है और त्रुटियों का पता लगाकर उन्हें सुधारती है। वर्तमान में सबसे आशाजनक तरीका सरफेस कोड (Surface Code) माना जा रहा है।

4.1 सरफेस कोड (Surface Code) की संरचना

सरफेस कोड में, क्वांटम बिट्स को द्वि-आयामी (2D) ग्रिड में व्यवस्थित किया जाता है। डेटा क्वांटम बिट (जो वास्तविक जानकारी रखते हैं) और मापन क्वांटम बिट (सिंड्रोम मापन के लिए) चेकरबोर्ड पैटर्न (checkerboard pattern) में व्यवस्थित होते हैं।

graph TD A["डेटा क्यूबिट (D1)"] --- B["मापन क्यूबिट (M1)"] B --- C["डेटा क्यूबिट (D2)"] C --- D["मापन क्यूबिट (M2)"] D --- E["डेटा क्यूबिट (D3)"] B --- F["डेटा क्यूबिट (D4)"] D --- G["डेटा क्यूबिट (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

स्टेबलाइजर ऑपरेटर $S_x$ और $S_z$ का उपयोग करके, बिट फ्लिप (X त्रुटि) और फेज फ्लिप (Z त्रुटि) की लगातार निगरानी की जाती है।

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

2026 की महत्वपूर्ण प्रगति यह है कि “ब्रेक-ईवन पॉइंट (Break-even point)” को पूरी तरह से पार कर लिया गया है। इसका मतलब है कि त्रुटि सुधार के लिए आवश्यक अतिरिक्त सर्किट द्वारा उत्पन्न शोर की तुलना में, त्रुटि सुधार द्वारा हटाए गए शोर की मात्रा अधिक हो गई है, और तार्किक क्वांटम बिट का जीवनकाल भौतिक क्वांटम बिट के जीवनकाल से कई गुना अधिक हो गया है।

4.2 क्वांटम त्रुटि सुधार चक्र

त्रुटि सुधार एक निरंतर फीडबैक लूप के रूप में कार्य करता है।

sequenceDiagram participant D as "डेटा क्यूबिट्स" participant M as "एंसिला/मापन क्यूबिट्स" participant C as "शास्त्रीय नियंत्रक" loop "सिंड्रोम निष्कर्षण चक्र (लगभग 1 माइक्रोसेकंड)" D->>M: "एंटैंगल (CNOT/CZ)" M->>C: "स्थिति मापन (सिंड्रोम)" C->>C: "सिंड्रोम डिकोड करें (जैसे: मिनिमम वेट परफेक्ट मैचिंग)" C-->>D: "पाउली सुधार लागू करें (यदि आवश्यक हो)" end

वर्तमान में, इस शास्त्रीय डिकोडिंग प्रक्रिया (सिंड्रोम विश्लेषण) को नैनोसेकंड स्केल पर निष्पादित करने के लिए FPGA और समर्पित ASIC तकनीकें स्थापित हो चुकी हैं, और वास्तविक समय (real-time) में त्रुटि सुधार व्यावहारिक चरण में प्रवेश कर चुका है।

5. हार्डवेयर आर्किटेक्चर का विकास (2026 संस्करण)

2026 में क्वांटम हार्डवेयर मुख्य रूप से तीन दिशाओं में विकसित हो रहा है: “सुपरकंडक्टिंग विधि,” “आयन ट्रैप विधि,” और “टोपोलॉजिकल विधि।”

5.1 सुपरकंडक्टिंग क्वांटम बिट का एकीकरण (Integration)

सुपरकंडक्टिंग विधि एक ऐसा क्षेत्र है जिसका नेतृत्व IBM और Google कर रहे हैं, और जोसेफसन जंक्शन (Josephson junction) का उपयोग करने वाले ट्रांसमोन (Transmon) क्वांटम बिट मुख्यधारा में हैं। 2026 में, एक ही चिप पर हजारों से लेकर दस हजार भौतिक क्वांटम बिट्स को एकीकृत करने वाले मेगाचिप साकार हो चुके हैं।

विशेष रूप से उल्लेखनीय मॉड्यूल के बीच क्वांटम संचार (Quantum Interconnects) की स्थापना है। माइक्रोवेव फोटॉन का उपयोग करते हुए चिप्स के बीच क्वांटम टेलीपोर्टेशन को व्यावसायिक स्तर पर लागू किया गया জ্ঞिा गया है, जिससे एकल डाइल्यूशन रेफ्रिजरेटर (dilution refrigerator) के आकार की सीमा से बचना संभव हो गया है।

5.2 आयन ट्रैप की 2D स्केलिंग और ऑप्टिकल इंटरकनेक्ट

आयन ट्रैप विधि (जिसका नेतृत्व Quantinuum और IonQ कर रहे हैं) में वैक्यूम में तैरते आयनों की आंतरिक ऊर्जा अवस्थाओं को क्वांटम बिट के रूप में उपयोग किया जाता है। सुपरकंडक्टिंग विधि की तुलना में, इसका T1/T2 कोहेरेंस (coherence) समय अत्यधिक लंबा होता है, और ऑल-टू-ऑल कनेक्टिविटी (All-to-All Connectivity) संभव है।

2026 की सफलता QCCD (क्वांटम चार्ज कपल्ड डिवाइस) आर्किटेक्चर का द्वि-आयामी (2D) निर्माण और फोटोनिक इंटरकनेक्ट का उपयोग करके मल्टी-ट्रैप्स के बीच उच्च गति वाले एंटैंगलमेंट का निर्माण है। इससे आयन ट्रैप की कमजोरियां “धीमी गेट गति” और “स्केलेबिलिटी (scalability)” में नाटकीय रूप से सुधार हुआ है।

5.3 टोपोलॉजिकल क्वांटम गणना: एनीऑन का नियंत्रण

टोपोलॉजिकल क्वांटम गणना, जिसे लंबे समय से केवल सैद्धांतिक माना जाता था, 2026 में अंततः प्रायोगिक प्रदर्शन के चरण में प्रवेश कर चुकी है। Microsoft और अन्य द्वारा संचालित यह विधि “मेजरना जीरो मोड्स (Majorana Zero Modes)” नामक गैर-अबेलियन एनीऑन्स (Non-Abelian Anyons) का उपयोग करती है।

एनीऑन कणों की स्थिति बदलने के लिए “ब्रेडिंग (Braiding)” नामक ऑपरेशन का उपयोग करके क्वांटम गेट्स निष्पादित किए जाते हैं।

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

यहाँ $B_{ij}$ ब्रेडिंग ऑपरेटर है। टोपोलॉजिकल विधि में, सूचना का संरक्षण कणों की स्थानीय अवस्था पर निर्भर नहीं करता, बल्कि पूरी “गांठ” की टोपोलॉजी पर निर्भर करता है, इसलिए यह पर्यावरणीय शोर के प्रति स्वाभाविक रूप से प्रतिरोधी (हार्डवेयर-स्तर की त्रुटि सहनशीलता) है। 2026 में, दुनिया में पहली बार उच्च-फिडेलिटी वाले टोपोलॉजिकल तार्किक क्वांटम बिट के निर्माण की पुष्टि की गई थी, और यह FTQC के लिए एक शक्तिशाली शॉर्टकट के रूप में ध्यान आकर्षित कर रहा है।

6. व्यावहारिक उपयोग की दिशा में रोडमैप और भविष्य की संभावनाएं

ताकि क्वांटम कंप्यूटर वास्तव में क्वांटम सर्वोच्चता (Quantum Advantage) प्रदर्शित कर सके, जो “रासायनिक गणना,” “पदार्थ विज्ञान,” और “वित्तीय मॉडलिंग” जैसे क्षेत्रों में शास्त्रीय कंप्यूटर (सुपरकंप्यूटर) को मात दे, इसके लिए हजारों तार्किक क्वांटम बिट्स की आवश्यकता है।

gantt title "क्वांटम कंप्यूटिंग रोडमैप (संशोधित 2026)" dateFormat YYYY axisFormat %Y section "NISQ युग" "शोर वाले क्यूबिट्स (<1000)" :done, 2018, 2024 section "प्रारंभिक FTQC" "ब्रेक-ईवन पॉइंट प्रदर्शन" :done, 2024, 2026 "सैकड़ों तार्किक क्यूबिट्स" :active, 2026, 2028 section "पूर्ण-पैमाने पर FTQC" "1000+ तार्किक क्यूबिट्स (व्यावसायिक ऐप)" : 2028, 2030 "यूनिवर्सल फॉल्ट-टॉलरेंट क्वांटम कंप्यूटर" : 2030, 2035

6.1 वर्तमान में सामना की जा रही चुनौतियां और भविष्य

2026 तक की सबसे बड़ी चुनौती क्रायोस्टेट (डाइल्यूशन रेफ्रिजरेटर) की शीतलन क्षमता है, जो अत्यंत कम तापमान बनाए रखने के लिए आवश्यक है, और कमरे के तापमान नियंत्रण उपकरण को क्रायोजेनिक क्वांटम चिप से जोड़ने वाली वायरिंग (I/O बॉटलनेक) है। इसके जवाब में, क्रायोजेनिक वातावरण में काम करने में सक्षम CMOS (Cryo-CMOS) कंट्रोलर चिप्स का विकास तेजी से आगे बढ़ रहा है।

निष्कर्ष

2026 को क्वांटम कंप्यूटर के इतिहास में “तार्किक क्वांटम बिट स्केल-अप के प्रथम वर्ष” के रूप में दर्ज किया जाएगा। त्रुटि सुधार एल्गोरिदम के प्रदर्शन, हार्डवेयर के मॉडर्नाइजेशन और टोपोलॉजिकल दृष्टिकोण में तेजी से प्रगति के साथ, “व्यावहारिक उपयोग का दिन” अब दूर के भविष्य की बात नहीं है, बल्कि एक विशिष्ट मील का पत्थर है जिसे अगले कुछ वर्षों में देखा जा सकता है। क्वांटम एल्गोरिदम के डेवलपर्स और कंपनियों के लिए, यह क्वांटम-नेटिव समस्या-समाधान में गंभीरता से निवेश करने का सही समय है।

यह लेख 2026 के नवीनतम क्वांटम कंप्यूटिंग शोध पत्रों और उद्योग के रुझानों के आधार पर लिखा गया है।