RSA on kenji.blog

क्या क्वांटम कंप्यूटर वास्तव में RSA एन्क्रिप्शन को नष्ट कर देगा? ~ शोर का एल्गोरिदम और वर्तमान स्थिति ~

Sat, 05 Sep 2026 22:09:21 +0900

परिचय: क्रिप्टोग्राफी और क्वांटम कंप्यूटर का प्रतिच्छेदन

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

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

इस लेख में, हम GNFS (जनरल नंबर फील्ड सीव), एक क्लासिकल डिक्रिप्शन विधि, और “शोर का एल्गोरिदम” (Shor’s Algorithm) के तंत्र में गहराई से उतरेंगे, जो क्वांटम कंप्यूटर का उपयोग करके एक निश्चित डिक्रिप्शन एल्गोरिदम है। हम क्वांटम फूरियर ट्रांसफॉर्म और अवधि खोज जैसी उन्नत अवधारणाओं को आसानी से समझने वाले तरीके से समझाएंगे, और वर्तमान NISQ (Noisy Intermediate-Scale Quantum) युग में क्वांटम हार्डवेयर की वर्तमान स्थिति और RSA-2048 को क्रैक करने के लिए आवश्यक बाधाओं की विस्तार से जांच करेंगे।

RSA एन्क्रिप्शन का आधार: अभाज्य गुणनखंडन की कठिनाई

RSA एन्क्रिप्शन की सुरक्षा गणित में एक अत्यंत सरल विषमता (asymmetry) पर निर्भर करती है। तथ्य यह है कि “दो विशाल अभाज्य संख्याओं (prime numbers) को गुणा करना आसान है, लेकिन परिणाम (समग्र संख्या) से मूल दो अभाज्य संख्याओं को खोजना (अभाज्य गुणनखंडन) बेहद मुश्किल है।”

उदाहरण के लिए, मान लीजिए कि हमारे पास दो अभाज्य संख्याएं हैं $ p = 61 $ और $ q = 53 $। इस गुणा $ N = p \times q = 3233 $ की गणना करना तात्कालिक है। हालाँकि, यदि आपको केवल संख्या “3233” दी गई है और पूछा गया है “यह किन अभाज्य संख्याओं का गुणनफल है?”, तो संख्या के बड़े होने पर गणना की मात्रा विस्फोटक रूप से बढ़ जाती है।

वर्तमान मुख्यधारा RSA-2048 में, 2048 बिट्स की कुंजी लंबाई का उपयोग किया जाता है, जो दशमलव में लगभग 617 अंकों की एक विशाल समग्र संख्या $ N $ है। यदि इस $ N $ का अभाज्य गुणनखंडन किया जा सकता है, तो एन्क्रिप्शन लगभग टूट गया है।

क्लासिकल कंप्यूटरों द्वारा चुनौती: GNFS (सामान्य संख्या क्षेत्र चलनी)

गणितज्ञों और क्रिप्टोग्राफरों ने अभाज्य गुणनखंडन समस्या को हल करने के लिए वर्षों से विभिन्न एल्गोरिदम विकसित किए हैं। उनमें से, वर्तमान में क्लासिकल कंप्यूटरों पर सबसे तेज़ सामान्य संख्या क्षेत्र चलनी (GNFS: General Number Field Sieve) माना जाता है।

GNFS एक बड़ी संख्या $ N $ का गुणनखंडन करने के लिए पूर्णांक वलय में गणना को अधिक अमूर्त बीजगणितीय संख्या क्षेत्र (Number Field) में विस्तारित करके विश्लेषण करने की एक विधि है। मोटे तौर पर प्रक्रिया इस प्रकार है:

बहुपद का चयन : उचित घात और गुणांक वाला एक बहुपद $ f(x) $ खोजें जिसका मूल $ N $ हो।
डेटा संग्रह (छानना) : परिमेय और बीजगणितीय संख्या क्षेत्रों पर बड़ी संख्या में ऐसे जोड़े खोजें जिन्हें छोटे अभाज्य (smooth numbers) में तोड़ा जा सके। इस प्रक्रिया को “छानना” (sieving) कहा जाता है और इसमें सबसे अधिक समय लगता है।
मैट्रिक्स जनरेशन और रिडक्शन : एकत्रित संबंधों के आधार पर एक विशाल विरल मैट्रिक्स (Sparse matrix) उत्पन्न करें, और रैखिक बीजगणित विधियों (जैसे ब्लॉक लैंज़ोस विधि) का उपयोग करके समाधान खोजें।
वर्गमूल की गणना : अंत में, बीजगणितीय संख्या क्षेत्र पर वर्गमूल की गणना करें और $ N $ के गुणनखंड (अभाज्य गुणनखंड) प्राप्त करें।

GNFS की जटिलता का मूल्यांकन एसिम्प्टोटिक रूप से $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $ के रूप में किया जाता है। इसे “उप-घातीय” (Sub-exponential) समय जटिलता कहा जाता है। यद्यपि यह घातीय समय (Exponential time) से तेज़ है, यह बहुपद समय (Polynomial time) से बहुत धीमा है।

वास्तव में, 2020 में, शोधकर्ताओं की एक अंतरराष्ट्रीय टीम ने GNFS का उपयोग करके RSA-250 (एक 829-बिट, 250-अंकीय समग्र संख्या) का सफलतापूर्वक गुणनखंडन किया। इस गणना में दुनिया भर के कंप्यूटिंग संसाधनों का उपयोग करते हुए लगभग 2700 CPU कोर-वर्ष का खगोलीय गणना समय लगा। हालाँकि, जब बात 2048 बिट्स की आती है, तो यह कहा जाता है कि आवश्यक गणना ब्रह्मांड के जीवनकाल के खरबों गुना तक बढ़ जाएगी, जिससे वर्तमान सुपरकंप्यूटरों को कितना भी समानांतर चलाया जाए, शास्त्रीय तरीकों से यथार्थवादी समय के भीतर इसे क्रैक करना असंभव हो जाता है।

क्वांटम कंप्यूटर का ट्रम्प कार्ड: शोर का एल्गोरिदम

यहीं पर “शोर का एल्गोरिदम” (Shor’s Algorithm), जिसे 1994 में पीटर शोर द्वारा प्रस्तुत किया गया था, सामने आता है। यह एल्गोरिदम क्रांतिकारी था क्योंकि यह क्वांटम कंप्यूटर पर बहुपद समय ( $ O((\log N)^3) $ ) में अभाज्य गुणनखंडन समस्या को हल कर सकता था। उप-घातीय समय और बहुपद समय के बीच का अंतर निर्णायक है, जिसका अर्थ है कि सिद्धांत रूप में, यदि हम क्वांटम कंप्यूटर का उपयोग करते हैं, तो RSA एन्क्रिप्शन पूरी तरह से नष्ट हो जाएगा।

शोर के एल्गोरिदम का समग्र प्रवाह

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[उस संख्या N को इनपुट करें जिसका आप गुणनखंड करना चाहते हैं] --> B[एक यादृच्छिक पूर्णांक a चुनें]
 B --> C{a और N का<br>महतम समापवर्तक (GCD)}
 C -->|1 से बड़ा| D[सौभाग्य से एक अभाज्य गुणनखंड मिला!]
 C -->|1 सह-अभाज्य| E[क्वांटम कंप्यूटर की बारी]
 E --> F[फलन f_x = a^x mod N की<br>अवधि r को क्वांटम फूरियर ट्रांसफॉर्म से खोजें]
 F --> G{अवधि r सम है और<br>a^r/2 ≢ -1 mod N}
 G -->|हाँ| H[महतम समापवर्तक gcd_a^r/2 ± 1, N की गणना करें]
 H --> I((अभाज्य गुणनखंडन सफल!))
 G -->|नहीं| B

सीधे अभाज्य गुणनखंडन समस्या को हल करने के बजाय, शोर का एल्गोरिदम इसे संख्या सिद्धांत प्रमेयों का उपयोग करके “अवधि खोज समस्या” (Period Finding Problem) नामक एक अन्य समस्या में परिवर्तित करता है, और इसे उच्च गति से हल करने के लिए क्वांटम कंप्यूटर की विशेषताओं का उपयोग करता है।

चरण 1: अभाज्य गुणनखंडन से अवधि खोज समस्या में कमी (शास्त्रीय प्रसंस्करण)

एल्गोरिदम का पहला चरण क्लासिकल कंप्यूटर पर किया जाता है। उस संख्या $ N $ के लिए जिसका आप गुणनखंड करना चाहते हैं, एक यादृच्छिक पूर्णांक $ a $ ( $ 1 < a < N $ ) चुनें जो $ N $ (जिसका सबसे बड़ा सामान्य भाजक 1 है) का सह-अभाज्य (coprime) है। यदि, संयोग से, सबसे बड़ा सामान्य भाजक 1 नहीं है, तो उस समय पाया गया सामान्य भाजक $ N $ का एक अभाज्य गुणनखंड है, इसलिए डिक्रिप्शन पूरा हो गया है, लेकिन इसकी संभावना बहुत कम है।

इसके बाद, निम्नलिखित मॉड्यूलर समीकरणों के अनुक्रम पर विचार करें। $ f(x) = a^x \pmod N $

यदि आप इस फ़ंक्शन $ f(x) $ में $ x = 1, 2, 3, \dots $ डालते हैं, तो मान यादृच्छिक लग सकते हैं, लेकिन चूंकि गणना एक सीमित सीमा के भीतर की जाती है, यह हमेशा किसी बिंदु पर अपने मूल मान पर वापस आ जाएगी और उसी अनुक्रम को दोहराएगी। इस पुनरावृत्ति की अवधि को $ r $ कहा जाता है। दूसरे शब्दों में, न्यूनतम धनात्मक पूर्णांक $ r $ खोजना ताकि $ a^r \equiv 1 \pmod N $ हो, यही “अवधि खोज समस्या” है।

यदि यह अवधि $ r $ मिल जाती है, और $ r $ सम है, तो $ a^r - 1 \equiv 0 \pmod N $, और गुणनखंडन सूत्र का उपयोग करके इसे $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $ में बदला जा सकता है। यहाँ से, यूक्लिडियन एल्गोरिथ्म (Euclidean algorithm) का उपयोग करके $ N $ और $ a^{r/2} \pm 1 $ के सबसे बड़े सामान्य भाजक की गणना करके, $ N $ के अभाज्य गुणनखंडों को बहुत अधिक संभावना के साथ प्राप्त किया जा सकता है।

क्लासिक कंप्यूटर के साथ अवधि $ r $ खोजने के लिए, अंततः घातीय चरणों की आवश्यकता होती है और इसे तेज नहीं किया जा सकता है। हालाँकि, क्वांटम कंप्यूटर के साथ, यह अवधि $ r $ तुरंत (बहुपद समय में) पाई जा सकती है।

चरण 2: क्वांटम स्थिति की तैयारी और सुपरपोजिशन

यहीं से क्वांटम कंप्यूटर काम आते हैं। क्वांटम कंप्यूटर “क्यूबिट्स” (Qubits) का उपयोग करते हैं जिनमें एक ही समय में “0” और “1” दोनों की स्थिति हो सकती है। शोर के एल्गोरिदम में, दो रजिस्टर तैयार किए जाते हैं: इनपुट को स्टोर करने के लिए एक रजिस्टर (पहला रजिस्टर) और गणना परिणाम को स्टोर करने के लिए एक रजिस्टर (दूसरा रजिस्टर)।

सबसे पहले, एक क्वांटम गेट ऑपरेशन जिसे हैडमार्ड गेट (Hadamard gate) कहा जाता है, पहले रजिस्टर में सभी क्यूबिट्स पर लागू किया जाता है। यह पहले रजिस्टर को सभी संभावित $ x $ मानों ( $ 0 $ से $ 2^n-1 $ तक, जहाँ $ n $ पर्याप्त रूप से बड़ी संख्या में बिट्स है) के समान सुपरपोजिशन (uniform superposition) स्थिति में लाता है।

दूसरे शब्दों में, अनगिनत इनपुट मान जैसे $ x=0, 1, 2, 3, \dots $ क्वांटम कंप्यूटर के अंदर एक ही समय में समानांतर में मौजूद होते हैं।

चरण 3: क्वांटम मॉड्यूलर एक्सपोनेंशिएशन (Quantum Modular Exponentiation)

इसके बाद, पहले रजिस्टर की सुपरपोजिशन स्थिति को इनपुट के रूप में उपयोग करते हुए, $ f(x) = a^x \pmod N $ की गणना की जाती है और परिणाम दूसरे रजिस्टर में संग्रहीत किया जाता है। चूँकि यह गणना क्वांटम सर्किट पर एकात्मक परिवर्तन (unitary transformation) के रूप में की जाती है, सभी $ x $ के लिए $ f(x) $ की गणना “एक साथ और समानांतर में (क्वांटम समानता)” की जाती है, जबकि सुपरपोजिशन को बनाए रखा जाता है।

इस बिंदु पर संपूर्ण क्वांटम प्रणाली का स्थान राज्य के एक विशाल सुपरपोजिशन में है: $ |x, a^x \bmod N\rangle $

हालाँकि, यदि हम केवल यहाँ दूसरे रजिस्टर को मापते (निरीक्षण करते) हैं, तो केवल एक यादृच्छिक $ a^x \bmod N $ मान संभाव्य रूप से चुना जाएगा, और पहले रजिस्टर का $ x $ भी इसके संयोजन में निर्धारित किया जाएगा। यह शास्त्रीय कंप्यूटर पर एक बार गणना करने के समान है, और अवधि $ r $ नहीं पाई जा सकती है।

क्वांटम यांत्रिकी के नियमों के तहत, सुपरपोज़्ड अवस्था के अंदर सीधे देखना संभव नहीं है। तो हम पूरी “अवधि” के बारे में वैश्विक जानकारी कैसे निकाल सकते हैं?

चरण 4: क्वांटम फूरियर ट्रांसफॉर्म (QFT: Quantum Fourier Transform)

इस दीवार को तोड़ने वाले शोर के एल्गोरिदम का वास्तविक मूल्य पहले रजिस्टर में क्वांटम फूरियर ट्रांसफॉर्म (QFT) का अनुप्रयोग है।

मापने से पहले, फलन $ f(x) $ की तरंग प्रकृति का विश्लेषण करें। मान लीजिए कि हम दूसरे रजिस्टर का निरीक्षण करते हैं। मान लीजिए कि एक निश्चित मान $ y $ प्राप्त होता है। तब, पहले रजिस्टर की स्थिति “सभी $ x $ के सुपरपोजिशन में ढह जाती है जैसे कि $ a^x \pmod N = y $ “। इस $ x $ के मान $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $ होंगे, जो अवधि $ r $ (एक प्रकार का कंघी जैसा संभाव्यता आयाम वितरण) के अंतराल पर अलग-अलग व्यवस्थित होते हैं।

इस अवस्था में क्वांटम फूरियर ट्रांसफॉर्म (QFT) लागू करें। जिस तरह एक क्लासिकल असतत (discrete) फूरियर ट्रांसफॉर्म समय-डोमेन सिग्नल को आवृत्ति डोमेन में परिवर्तित करता है, QFT क्वांटम अवस्थाओं के संभाव्यता आयामों में हस्तक्षेप (interference) का कारण बनता है।

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

चरण 5: मापन और निरंतर अंश विस्तार (शास्त्रीय पोस्ट-प्रोसेसिंग)

QFT को लागू करने के बाद पहले रजिस्टर को मापने से एक पूर्णांक $ c $ प्राप्त करने की बहुत अधिक संभावना होती है जो $ c \approx \frac{j \cdot 2^n}{r} $ के करीब है (जहाँ $ j $ एक अज्ञात पूर्णांक है और $ 2^n $ रजिस्टर का आकार है)।

यह माप परिणाम $ c $ एक क्लासिकल कंप्यूटर पर लौटाया जाता है, और भिन्न $ \frac{c}{2^n} \approx \frac{j}{r} $ बनाया जाता है। फिर, गणितीय विधि “निरंतर अंश विस्तार” (Continued fraction expansion) का उपयोग करके अनुमानित मूल्य की गणना करके, हर (denominator) में अवधि $ r $ को शानदार ढंग से सामने लाया जा सकता है।

एक बार $ r $ ज्ञात हो जाने के बाद, हम चरण 1 के सूत्र का उपयोग करके $ N $ के अभाज्य गुणनखंडों की गणना कर सकते हैं, और RSA एन्क्रिप्शन पूरी तरह से डिक्रिप्ट हो जाएगा।

वर्तमान क्वांटम कंप्यूटरों (NISQ) की क्षमताएं और चुनौतियाँ

सैद्धांतिक रूप से, शोर का एल्गोरिदम सही है, लेकिन अगर पूछा जाए, “क्या कल RSA एन्क्रिप्शन टूट जाएगा?” तो उत्तर स्पष्ट रूप से “नहीं” है। इसका कारण वर्तमान क्वांटम कंप्यूटर हार्डवेयर तकनीक की सीमाएं हैं।

NISQ (Noisy Intermediate-Scale Quantum) युग

हम वर्तमान में “NISQ” नामक युग में हैं। NISQ उपकरणों में दसियों से सैकड़ों भौतिक क्यूबिट्स होते हैं, लेकिन शोर (noise) के प्रति बेहद संवेदनशील होते हैं।

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

भौतिक क्यूबिट्स और तार्किक क्यूबिट्स

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

क्वांटम त्रुटि सुधार में, “सतह कोड” (Surface Code) जैसी तकनीकों का उपयोग बड़ी संख्या में शोर वाले “भौतिक क्यूबिट्स” को संयोजित करने के लिए किया जाता है ताकि त्रुटियों के बिना एक आदर्श “तार्किक क्यूबिट” (Logical qubit) बनाया जा सके।

वर्तमान त्रुटि दरों को देखते हुए, यह अनुमान लगाया गया है कि एक तार्किक क्यूबिट बनाने के लिए लगभग 1,000 से 10,000 भौतिक क्यूबिट्स की आवश्यकता होगी। इसे “त्रुटि सुधार ओवरहेड” कहा जाता है।

RSA-2048 को नष्ट करने के लिए किन संसाधनों की आवश्यकता है?

तो RSA-2048 को क्रैक करने के लिए शोर के एल्गोरिदम को चलाने के लिए वास्तव में कितने संसाधनों की आवश्यकता है?

क्रेग गिडनी (Google) और मार्टिन एकेरा द्वारा 2021 के एक पेपर में ग्राउंडब्रेकिंग संसाधन अनुमान के अनुसार, अनुकूलित शोर के एल्गोरिदम का उपयोग करके और सतह कोड का उपयोग करके त्रुटि सुधार करने के लिए निम्नलिखित संसाधनों की आवश्यकता होगी:

तार्किक क्यूबिट्स की संख्या : लगभग 4,096
भौतिक क्यूबिट्स की संख्या : लगभग 20 मिलियन (त्रुटि दर $10^{-3}$ मानकर)
गणना का समय : लगभग 8 घंटे (लाखों से अरबों भौतिक गेट संचालन की आवश्यकता है)

इसकी तुलना में, वर्तमान क्वांटम हार्डवेयर की क्या स्थिति है? सुपरकंडक्टिंग क्वांटम प्रोसेसर “कोंडोर”, जिसकी घोषणा 2023 के अंत में IBM द्वारा की गई थी, में 1,121 क्यूबिट्स हैं। इसके अलावा, तार्किक क्यूबिट्स के निर्माण पर ग्राउंडब्रेकिंग शोध (जैसे हार्वर्ड यूनिवर्सिटी और QuEra द्वारा तटस्थ परमाणु क्वांटम कंप्यूटर का उपयोग करके 48 तार्किक क्यूबिट्स का निर्माण) भी सामने आया है, लेकिन हम अभी तक उस स्तर पर नहीं हैं जहाँ “बिना शोर के सही गणना” लंबी अवधि के लिए लगातार निष्पादित की जा सके।

हजारों भौतिक क्यूबिट्स से 20 मिलियन व्यावहारिक भौतिक क्यूबिट्स (जो परस्पर जुड़े हुए हैं, क्रायोजेनिक तापमान पर स्थिर रूप से काम करते हैं, और अति-उच्च गति पर नियंत्रण संकेतों को संसाधित कर सकते हैं) तक स्केल करने के लिए, इंजीनियरिंग में भारी बाधाएं (वायरिंग की समस्याएं, शीतलन क्षमता की सीमाएं, और नियंत्रण इलेक्ट्रॉनिक्स का विस्तार) मौजूद हैं। कई विशेषज्ञों का अनुमान है कि “दोष-सहिष्णु (Fault-tolerant) क्वांटम कंप्यूटर (FTQC)” को साकार करने में कम से कम 10 से 30 वर्ष या उससे अधिक का समय लगेगा जो RSA-2048 को डिक्रिप्ट कर सकता है।

“Store Now, Decrypt Later” का बढ़ता खतरा और PQC की शुरुआत

यह सोचना जल्दबाजी होगी कि “हम सुरक्षित हैं क्योंकि इसमें अभी 10 से अधिक साल लगेंगे।” वर्तमान में, ऐसा डेटा है जिसे राष्ट्रीय रहस्य, चिकित्सा डेटा और दीर्घकालिक बुनियादी ढांचे के डिजाइन जैसे दशकों तक गुप्त रखा जाना चाहिए।

यहाँ जो चिंता का विषय है वह “अभी स्टोर करें, बाद में डिक्रिप्ट करें” (Store Now, Decrypt Later) नामक हमला विधि है। दुर्भावनापूर्ण राष्ट्र और संगठन वर्तमान RSA या ECC (एलिप्टिक कर्व क्रिप्टोग्राफी) के साथ एन्क्रिप्ट किए गए सभी संचार डेटा को इंटरसेप्ट करते हैं और इसे स्टोरेज में सहेजते हैं। फिर, 10 या 20 साल बाद, जिस क्षण एक शक्तिशाली क्वांटम कंप्यूटर पूरा हो जाता है, वे शोर के एल्गोरिदम का उपयोग करके सभी पिछले डेटा को डिक्रिप्ट करते हैं और रहस्यों को उजागर करते हैं।

इस समय अंतराल के खतरे का मुकाबला करने के लिए, NIST (राष्ट्रीय मानक और प्रौद्योगिकी संस्थान) के नेतृत्व में, “पोस्ट-क्वांटम क्रिप्टोग्राफी” (PQC: Post-Quantum Cryptography) के मानकीकरण की प्रक्रिया तेज गति से आगे बढ़ रही है।

PQC एक नया एन्क्रिप्शन एल्गोरिदम है जो गणितीय समस्याओं पर आधारित है जिन्हें क्वांटम कंप्यूटर का उपयोग करके हल करना मुश्किल है (यानी, शोर का एल्गोरिदम लागू नहीं किया जा सकता है)। मुख्य दृष्टिकोण इस प्रकार हैं:

लैटिस-आधारित क्रिप्टोग्राफी (Lattice-based cryptography) : LWE (Learning with Errors) समस्या पर आधारित है। NIST के मानकीकरण में मुख्यधारा (Kyber, Dilithium, आदि)।
कोड-आधारित क्रिप्टोग्राफी (Code-based cryptography) : त्रुटि-सुधार कोड को डिकोड करने की कठिनाई पर निर्भर करता है।
बहुभिन्नरूपी बहुपद क्रिप्टोग्राफी (Multivariate cryptography) : कई चरों के एक साथ द्विघात समीकरणों को हल करने की कठिनाई पर निर्भर करता है।
हैश-आधारित हस्ताक्षर (Hash-based signatures) : डिजिटल हस्ताक्षर जो पूरी तरह से हैश फ़ंक्शंस की सुरक्षा पर निर्भर करते हैं।

Google Chrome और Apple के iMessage जैसे प्रमुख सॉफ़्टवेयर और प्लेटफ़ॉर्म ने पहले ही PQC का कार्यान्वयन परीक्षण और हाइब्रिड कार्यान्वयन शुरू कर दिया है।

निष्कर्ष

क्वांटम कंप्यूटर विज्ञान कथा की काल्पनिक दुनिया से वास्तविक इंजीनियरिंग चुनौतियों की ओर बढ़ रहे हैं। शोर का एल्गोरिदम मानवता की एक महान बौद्धिक उपलब्धि है जो गणित और क्वांटम यांत्रिकी को जोड़ती है, लेकिन साथ ही, इसमें हमारे डिजिटल समाज की नींव को हिला देने वाली “विनाशकारी शक्ति” है।

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

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम "GNFS" को समझना

Sat, 05 Sep 2026 13:04:59 +0900

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम “GNFS” को समझना

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

हालाँकि, मानवता ने कभी हार नहीं मानी है। वर्तमान में, क्लासिकल कंप्यूटरों (सामान्य कंप्यूटर, न कि क्वांटम कंप्यूटर) पर विशाल अभाज्य गुणनखंडन करने के लिए ** मानवता का सबसे शक्तिशाली और उन्नत एल्गोरिदम ** मौजूद है। वह है ** “सामान्य संख्या क्षेत्र चलनी (GNFS: General Number Field Sieve)” ** ।

इस लेख में, हम इस GNFS के अत्याधुनिक संगणना लॉजिक को C++ (Boost लाइब्रेरी के मल्टीपल-प्रिसीजन इंटीजर boost::multiprecision का उपयोग करके) में सख्ती से मॉडल किए गए कार्यान्वयन कोड को पूरी तरह से प्रकाशित करेंगे, और इसके पीछे “बीजीय संख्या सिद्धांत (Algebraic Number Theory)” की गहराइयों को विस्तार से समझाएंगे।

कृपया स्रोत कोड के साथ गणित के रहस्य और कंप्यूटर विज्ञान की उस शक्ति का आनंद लें जो इसे मात देती है।

1. GNFS अत्याधुनिक लॉजिक फ्रेमवर्क (संपूर्ण स्रोत कोड)

सबसे पहले, हम इस बार समझाए जाने वाले GNFS के C++ कार्यान्वयन का पूरा दृश्य प्रस्तुत करेंगे। वास्तविक संख्या क्षेत्र चलनी (जैसे CADO-NFS) लाखों पंक्तियों वाला एक विशाल वितरित सिस्टम है, लेकिन यह कोड GNFS को बनाने वाले ** “5 आवश्यक पाइपलाइनों (चरणों)” ** को निकालता है, उन्हें क्लास के रूप में डिज़ाइन करता है, और गणितीय अर्थ खोए बिना न्यूनतम कॉन्फ़िगरेशन के साथ मॉडल करता है।

 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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Boost.Multiprecision के मल्टीपल-प्रिसीजन इंटीजर का उपयोग
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (सामान्य संख्या क्षेत्र चलनी) अत्याधुनिक लॉजिक फ्रेमवर्क
//
// यह कोड CADO-NFS आदि में उपयोग किए जाने वाले अत्याधुनिक GNFS के 5 पाइपलाइनों को
// C++ (Boost) क्लास डिज़ाइन के रूप में सख्ती से मॉडल करता है।
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung का एल्गोरिदम)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // बीजीय पक्ष बहुपद f(x)
 std::vector<cpp_int> g; // परिमेय पक्ष बहुपद g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // base-m विस्तार के आधार पर प्रारंभिक बहुपद का निर्माण (वास्तव में अधिक उन्नत जालक आधार न्यूनीकरण LLL का उपयोग किया जाता है)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // सरल base-m विस्तार (d घात)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // सरल m का अनुमान (Boost फ़ंक्शन के बिना अनुमान)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (जालक चलनी)
// ============================================================================
// हाल के वर्षों में GNFS में Line Sieve (सरल रेखा चलनी) के बजाय Franke-Kleinjung आदि द्वारा
// Special-q Lattice Sieving (विशेष-q जालक चलनी) का उपयोग करना डिफ़ॉल्ट मानक है।
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (छोड़ा गया) वास्तव में अभाज्य संख्या निर्माण और लेजेंड्रे प्रतीक आदि से फ़िल्टरिंग की जाती है
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // मॉक कार्यान्वयन: वास्तविक जालक चलनी सैकड़ों GB मेमोरी स्पेस को ब्लॉक द्वारा स्कैन करती है
 // (a, b) युग्मों को विशेष अभाज्य q के जालक (a = i*q + j*...) में मैप करती है,
 // और कैश दक्षता को अधिकतम करने वाली चलनी (sieve) चलाती है।

 // डेमो के लिए एक डमी रिलेशन जोड़ा गया
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (सिंगलटन रिमूवल और क्लीक मर्जिंग)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (केवल 1 बार आने वाले अभाज्य संख्या वाले रिलेशन को हटाना)
 // 2. Clique merging (विरल मैट्रिक्स को सघन बनाने के लिए रिलेशन को मिलाना)
 // वास्तव में यूनियन-फाइंड एल्गोरिदम आदि द्वारा करोड़ों पंक्तियों वाले मैट्रिक्स को लाखों पंक्तियों में संकुचित किया जाता है।
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann विधि)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // हाल के सुपरकंप्यूटर वातावरण में Block Lanczos विधि की तुलना में, वितरित कंप्यूटिंग के लिए
 // अधिक उपयुक्त Block Wiedemann विधि (Coppersmith कार्यान्वयन) को अत्याधुनिक माना जाता है।
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // विरल मैट्रिक्स (sparse matrix) और वेक्टर के गुणन की पुनरावृत्ति करके,
 // M * x = 0 mod 2 को संतुष्ट करने वाले कई हल वेक्टर (कर्नेल) खोजना।

 std::vector<std::vector<int>> dependencies; // निर्भरता की सूची
 // डमी डेटा
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root (बीजीय वर्गमूल)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. परिमेय पक्ष का वर्गमूल V की गणना (सरल पूर्णांक गणना)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. बीजीय पक्ष का वर्गमूल gamma की गणना (Montgomery's method आदि)
 // विशाल बीजीय क्षेत्र O_K का तत्व gamma ज्ञात करना, और समरूपता (homomorphism) phi द्वारा वास्तविक दुनिया में मैप करना
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // आदर्श वर्ग समूह (Ideal Class Group) और इकाई समूह (Unit Group) की बाधाओं (Obstruction) से बचने के लिए,
 // यह मानकर चलते हैं कि Phase 2 और 4 में द्विघाती वर्णों (Quadratic Characters) की पंक्तियाँ जोड़ी गई हैं।

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // RSA-270 आदि, विशाल भाज्य संख्या N जिसका गुणनखंडन करना है
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // बहुपद की घात (130 अंकों से अधिक होने पर आमतौर पर 5 या 6 चुनी जाती है)
 int degree = 6;

 // पाइपलाइन इनिशियलाइज़ेशन
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // वास्तविक सीमाएँ करोड़ों में होती हैं
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. बहुपद चयन
 poly_select.select(N);

 // 2. चलनी (sieve) प्रसंस्करण
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. फ़िल्टरिंग (मैट्रिक्स संपीड़न)
 filter.reduce_matrix(relations);

 // 4. रेखीय बीजगणित (GF(2) पर शून्यस्थान खोज)
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. बीजीय वर्गमूल की गणना और GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

तो यह कोड क्रिप्टोग्राफी की दीवारों को कैसे तोड़ता है? आइए इन 5 चरणों में से प्रत्येक के पीछे के सटीक एल्गोरिदम और उन्नत गणित को विस्तार से समझें।

2. GNFS का अंतिम लक्ष्य: $X^2 \equiv Y^2 \pmod N$

GNFS ही नहीं, बल्कि लगभग सभी आधुनिक विशाल अभाज्य गुणनखंडन एल्गोरिदम का लक्ष्य एक ऐसा गैर-तुच्छ (non-trivial) युग्म $(X, Y)$ खोजना है जो निम्नलिखित सर्वांगसमता (congruence) को संतुष्ट करता हो:

$$X^2 \equiv Y^2 \pmod N$$

इस समीकरण का अर्थ है कि “$X^2$ और $Y^2$ को $N$ से विभाजित करने पर शेषफल समान होता है”। यदि हम इसे रूपांतरित करें, तो: $X^2 - Y^2 \equiv 0 \pmod N$ अर्थात, $(X-Y)(X+Y)$, $N$ का गुणज है।

यदि $X \not\equiv \pm Y \pmod N$ (गैर-तुच्छ हल) है, तो $(X-Y)$ और $N$ के बीच “1 से बड़ा और $N$ से छोटा एक सार्व भाजक (common divisor)” मौजूद होगा। यहाँ, यदि हम यूक्लिड के एल्गोरिदम का उपयोग करके ** $\gcd(X-Y, N)$ ** की गणना करते हैं, तो $N$ का अभाज्य गुणनखंड आसानी से मिल जाएगा।

हालाँकि, इस $X$ और $Y$ को खोजना रेगिस्तान में सुई खोजने जैसा है। इसलिए, GNFS “वास्तविक पूर्णांकों की दुनिया” और “बहुपदों की बीजीय दुनिया” नामक ** 2 दुनियाएँ ** बनाने और संगणना को वितरित करने का एक प्रतिभाशाली दृष्टिकोण अपनाता है।

3. Phase 1: बहुपद चयन (Polynomial Selection)

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // m = N^(1/d) की गणना और base-m विस्तार
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

GNFS का पहला कदम दोनों दुनियाओं को जोड़ने के लिए एक “जादुई बहुपद” बनाना है। एक विशाल संख्या $N$ के लिए, हम एक पूर्णांक $m$ चुनते हैं। आमतौर पर, हम इसे इस तरह चुनते हैं कि $m \approx N^{1/d}$ हो (कोड में $d=6$ घात के बहुपद की कल्पना की गई है)।

फिर, हम $N$ का $m$-आधार विस्तार करते हैं, और इसके गुणांकों का उपयोग करके बहुपद $f(x)$ का निर्माण करते हैं।

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

इस बहुपद $f(x)$ में एक अत्यंत महत्वपूर्ण गुण है कि ** “चर $x$ में $m$ रखने पर, यह ठीक $N$ बन जाता है ($f(m) = N$)” ** । दूसरे शब्दों में, $f(m) \equiv 0 \pmod N$। परिमेय पक्ष के बहुपद को $g(x) = x - m$ के रूप में परिभाषित किया जाता है।

इसके कारण, $f(x)=0$ के मूल $\alpha$ द्वारा शासित ** “बीजीय क्षेत्र की दुनिया $\mathbb{Z}[\alpha]$” ** और सामान्य ** “परिमेय (पूर्णांक) संख्याओं की दुनिया $\mathbb{Z}$” ** को $x \to m$ नामक “रिंग होमोमोर्फिज्म (Ring Homomorphism)” द्वारा दृढ़ता से जोड़ा जाता है।

अत्याधुनिक CADO-NFS आदि में, KleinJung एल्गोरिदम या LLL जालक आधार न्यूनीकरण एल्गोरिदम का उपयोग महीनों तक ऐसे “सबसे सुविधाजनक बहुपद $f(x)$” की खोज के लिए किया जाता है जिसके गुणांक बहुत बड़े नहीं होते हैं और बाद के चरणों में अभाज्य संख्याएँ उत्पन्न होने की अधिक संभावना होती है (अर्थात स्मूथ होने की संभावना अधिक होती है)।

4. Phase 2: विशेष $q$ जालक चलनी (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // (a, b) युग्मों को विशेष अभाज्य q के जालक में मैप करता है,
 // और कैश दक्षता को अधिकतम करने वाली चलनी (sieve) चलाता है।
 // ...
 }
};

एक बार जब दोनों दुनियाएँ तैयार हो जाती हैं, तो अगला कदम उन दोनों दुनियाओं में “स्मूथ संख्याएँ (केवल छोटी अभाज्य संख्याओं से बनी संख्याएँ)” खोजना है। पूर्णांक युग्मों $(a, b)$ की अनगिनत संख्या उत्पन्न की जाती है, और निम्नलिखित दो मानों की गणना की जाती है:

** परिमेय पक्ष का मान ** : $a - bm$
** बीजीय पक्ष का नॉर्म ** : $b^d f(a/b)$

GNFS का लक्ष्य ऐसे ** “युग्मों (Relation: संबंध) को करोड़ों की संख्या में इकट्ठा करना है जहाँ परिमेय और बीजीय दोनों मानों को पूरी तरह से केवल छोटे अभाज्य कारकों में विभाजित किया जा सकता है” ** ।

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

इसलिए, वर्तमान अत्याधुनिक कोड में ** “विशेष $q$ जालक चलनी (Special-q Lattice Sieve)” ** नामक तकनीक का उपयोग किया जाता है। एक उपयुक्त रूप से बड़ी अभाज्य संख्या $q$ तय की जाती है, और केवल उन $(a, b)$ युग्मों की गणना की जाती है जहाँ “बीजीय पक्ष का मान निश्चित रूप से $q$ द्वारा विभाज्य है”। इस शर्त को पूरा करने वाले $(a, b)$ तल पर एक “जालक (Lattice)” बनाते हैं, इसलिए गणना करने के लिए पतों की जंप की चौड़ाई स्थिर हो जाती है, जो CPU के L1/L2 कैश में पूरी तरह से फिट बैठती है। इस जालक चलनी की शुरुआत के साथ, GNFS की गणना गति में नाटकीय रूप से सुधार हुआ।

5. Phase 3: फ़िल्टरिंग (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (केवल 1 बार आने वाले अभाज्य संख्या वाले रिलेशन को हटाना)
 // 2. Clique merging (विरल मैट्रिक्स को सघन बनाने के लिए रिलेशन को मिलाना)
 }
};

Phase 2 में दुनिया भर के कंप्यूटरों द्वारा महीनों तक एकत्र किए गए करोड़ों रिलेशन। हालाँकि, अगर हम इसे ऐसे ही अगले “युगपत समीकरणों को हल करने वाले चरण (मैट्रिक्स गणना)” में डाल देते हैं, तो सुपरकंप्यूटर की मेमोरी भर जाएगी।

इसलिए, ** फ़िल्टरिंग (Filtering) ** नामक एक अति-संपीड़न प्रक्रिया की जाती है।

** Singleton removal (सिंगलटन रिमूवल) ** मान लें कि करोड़ों रिलेशन में कोई विशाल अभाज्य संख्या $p$ “केवल 1 बार” आती है। हमारा लक्ष्य “सभी अभाज्य संख्याओं के घातांकों को सम (2 का गुणज) बनाना” है, इसलिए जो अभाज्य संख्या केवल 1 बार आती है उसे कभी सम नहीं किया जा सकता। इसलिए, उस अभाज्य संख्या वाले रिलेशन को तुरंत “कचरा” मानकर हटा (पर्ज) दिया जाता है। चूँकि यह एक श्रृंखला प्रतिक्रिया में होता है, करोड़ों पंक्तियों वाला डेटा तेज़ी से कम हो जाता है।
** Clique merging (क्लीक मर्जिंग) ** इसके अलावा, एक विशिष्ट अभाज्य संख्या साझा करने वाले रिलेशन को एक साथ गुणा करके (जोड़कर), पंक्तियों की संख्या कम हो जाती है, जबकि एक विरल (sparse) मैट्रिक्स को सघन स्थिति में संकुचित किया जाता है (ग्राफ सिद्धांत में क्लीक सर्च के समान एक विधि का उपयोग किया जाता है)।

इस अनुकूलन के साथ, विशाल विरल मैट्रिक्स को गणना योग्य आकार में नाटकीय रूप से संकुचित किया जाता है।

6. Phase 4: GF(2) पर रेखीय बीजगणित (Block Wiedemann विधि)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // विरल मैट्रिक्स (sparse matrix) और वेक्टर के गुणन की पुनरावृत्ति करके,
 // M * x = 0 mod 2 को संतुष्ट करने वाले कई हल वेक्टर (कर्नेल) खोजना।
 }
};

यह पहेली का मूल है। हम एकत्र किए गए रिलेशन को गुणा करते हैं ताकि ** “ऐसे संयोजन को खोज सकें जहाँ सभी अभाज्य कारकों के घातांक सम हो जाते हैं” ** ।

गणितीय रूप से, यह एक विशाल मैट्रिक्स $M$ जिसमें प्रत्येक अभाज्य संख्या के घातांक की “सम/विषम (यानी 0 या 1)” स्थिति होती है, और यह दर्शाने वाला एक वेक्टर $x$ कि किन रिलेशन का उपयोग किया जाए, का उपयोग करके: ** $M \cdot x \equiv 0 \pmod 2$ ** संतुष्ट करने वाले हल वेक्टर $x$ (शून्यस्थान / कर्नेल) को खोजने के अलावा और कुछ नहीं है।

हमें लाखों पंक्तियों × लाखों स्तंभों वाले मैट्रिक्स के युगपत समीकरणों को हल करना होगा। सामान्य गाऊसी उन्मूलन (Gaussian elimination) से गणना की जटिलता $O(N^3)$ हो जाएगी, और गणना ब्रह्मांड के अंत तक भी समाप्त नहीं होगी।

इसलिए, अत्याधुनिक कार्यान्वयन ** “Block Wiedemann (ब्लॉक विडमैन) विधि” ** को अपनाता है। यह क्रिलोव सबस्पेस विधि का एक प्रकार है जो इस तथ्य का लाभ उठाता है कि मैट्रिक्स $M$ “अत्यंत विरल (लगभग सभी 0)” है, और मैट्रिक्स और वेक्टर के गुणन को बार-बार करके हल निकालता है। पुरानी Block Lanczos विधि के विपरीत, Block Wiedemann विधि गणना प्रक्रिया को पूरी तरह से कई क्लस्टरों में विभाजित कर सकती है, इसलिए यह आधुनिक वितरित क्लाउड कंप्यूटिंग और सुपरकंप्यूटर पर समानांतर गणना में अत्यधिक शक्तिशाली है।

7. Phase 5: बीजीय वर्गमूल (Algebraic Square Root) और क्रिप्टोग्राफी का पतन

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. परिमेय पक्ष का वर्गमूल V की गणना
 cpp_int V = 1;

 // 2. बीजीय पक्ष का वर्गमूल gamma की गणना
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Phase 4 में मैट्रिक्स गणनाओं के माध्यम से, हमने “रिलेशन का एक सेट $S$ प्राप्त किया है जो, जब गुणा किया जाता है, तो सभी अभाज्य कारकों की सम घात में परिणत होता है”। यह हमें परिमेय और बीजीय दोनों दुनियाओं में “वर्ग (Squares)” बनाने की अनुमति देता है।

चूँकि परिमेय पक्ष केवल पूर्णांक गुणन है, इसलिए वर्गमूल $V$ की गणना करना आसान है।

$$V^2 = \prod_{S} (a - bm)$$

** लेकिन असली चुनौती “बीजीय पक्ष” पर है। ** बीजीय क्षेत्र $\mathbb{Z}[\alpha]$ की दुनिया में, अभाज्य गुणनखंडन की विशिष्टता (unique factorization) लागू नहीं होती है, इसलिए हमने आदर्शों (ideals) का उपयोग करके गणना की है। मैट्रिक्स गणना केवल यह गारंटी देती है कि यह “आदर्श का वर्ग” है, और ** यह गारंटी नहीं देता है कि यह “तत्व का वर्ग ($\gamma^2$)” बन जाता है ** ।

यहाँ बीजीय संख्या सिद्धांत में एक दुर्जेय दीवार है, जिसे “आदर्श वर्ग समूह (Ideal Class Group) की बाधा” और “इकाई समूह (Unit Group) की बाधा” कहा जाता है। GNFS में, इस दीवार को तोड़ने के लिए ** “द्विघाती वर्णों (Quadratic Characters)” ** नामक जादू का उपयोग किया जाता है। Phase 4 के मैट्रिक्स में, दर्जनों विशेष अभाज्य आदर्शों के लिए द्विघाती अवशेषों (लेजेंड्रे प्रतीक) की पंक्तियों को चुपके से पहले से जोड़ दिया जाता है। इस वजह से, पाया गया सेट $S$ भारी संभावना के साथ बाधाओं को बायपास करेगा, और सुरक्षित रूप से “सच्चे तत्व का वर्ग $\gamma^2$” बनाएगा।

$\gamma$ (बीजीय वर्गमूल) ज्ञात करने का कार्य Montgomery विधि जैसे अत्यंत जटिल एल्गोरिदम का उपयोग करके किया जाता है।

और अंततः, बीजीय पक्ष के वर्गमूल $\gamma$ को रिंग होमोमोर्फिज्म $\phi$ द्वारा वास्तविक दुनिया में ले जाया जाता है ($x$ के लिए $m$ प्रतिस्थापित करके), जिससे हमें $Y$ मिलता है। यदि हम परिमेय पक्ष के $V$ को वैसे ही $X$ के रूप में रखते हैं, तो वह पूर्ण समीकरण जो हम खोज रहे थे, अंततः पूरा हो जाता है।

$$X^2 \equiv Y^2 \pmod N$$

अब बस $\gcd(X-Y, N)$ की गणना करनी है। 0.001 सेकंड का प्रसंस्करण चलता है, और जैसे ही गैर-तुच्छ कारक स्क्रीन पर प्रिंट होते हैं, अभेद्य मानी जाने वाली RSA क्रिप्टोग्राफी पूरी तरह से ढह जाती है।

निष्कर्ष

GNFS सिर्फ एक प्रोग्रामिंग तकनीक नहीं है। यह मानव बुद्धि का क्रिस्टलीकरण है जिसने “शुद्ध गणित की गहराइयों” जैसे अमूर्त बीजगणित (abstract algebra), रिंग थ्योरी (ring theory), और आदर्श वर्ग समूहों (ideal class groups) को “चरम इंजीनियरिंग” जैसे सुपरकंप्यूटर वितरित आर्किटेक्चर और कैश अनुकूलन के साथ जीत लिया है।

हम जिन चैट और क्रेडिट कार्ड की जानकारी को लापरवाही से भेजते हैं, वे ऐसे खगोलीय गणितीय बचावों द्वारा संरक्षित हैं।

हमें उम्मीद है कि इस C++ फ्रेमवर्क के माध्यम से, आप अत्याधुनिक क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम के पीछे “गणित और कंप्यूटर के रोमांस” को महसूस करेंगे।

सामान्य संख्या क्षेत्र चलनी (GNFS) की सच्ची गणितीय संरचना

Sat, 05 Sep 2026 02:26:13 +0900

सामान्य संख्या क्षेत्र चलनी (GNFS) की सच्ची गणितीय संरचना

GNFS का अंतिम उद्देश्य $X, Y$ खोजना है ताकि $X^2 \equiv Y^2 \pmod N$ हो सके। इसे प्राप्त करने के लिए, गणितज्ञों ने “वास्तविक पूर्णांकों की दुनिया” और “बीजगणितीय क्षेत्रों की दुनिया” के बीच एक पुल बनाया। वह पुल “होमोमोर्फिज़्म (Homomorphism)” है।

चरण 1: दुनियाओं को जोड़ने वाला “होमोमोर्फिज़्म”

1. बहुपद का चयन और जड़ों की परिभाषा

एक विशाल भाज्य संख्या $N$ के लिए, हम एक पूर्णांक $m$ और एक बहुपद $f(x)$ चुनते हैं ताकि $f(m) \equiv 0 \pmod N$ हो। (उदाहरण: $N$ को $m$ के आधार पर विस्तारित करें और इसके गुणांकों से $f(x)$ बनाएँ। यहाँ हम मान लेते हैं कि $f(x)$ परिमेय संख्याओं के क्षेत्र $\mathbb{Q}$ पर अप्राप्य (irreducible) है (इसे और फ़ैक्टर नहीं किया जा सकता))।

अगला, हम समीकरण $f(x) = 0$ की “जटिल संख्याओं में जड़ों” में से एक को $\alpha$ के रूप में परिभाषित करते हैं। स्वाभाविक रूप से, $f(\alpha) = 0$ है। $\alpha$ एक पूर्णांक नहीं है, बल्कि एक जटिल संख्या है जिसमें वर्गमूल और काल्पनिक संख्याएँ शामिल हैं (एक बीजगणितीय संख्या)।

2. रिंग (Ring) और होमोमोर्फिज़्म का निर्माण

यहाँ, हम दो गणितीय “रिंग” (वे दुनिया जहाँ जोड़ और गुणा परिभाषित हैं) तैयार करते हैं।

दुनिया A: $\mathbb{Z}[\alpha]$ (बीजगणितीय पूर्णांकों की रिंग जिसमें $\alpha$ शामिल है) यह $a + b\alpha + c\alpha^2 + \dots$ के रूप में व्यक्त संख्याओं की दुनिया है।
दुनिया B: $\mathbb{Z}/N\mathbb{Z}$ ($N$ से भाग देने पर शेषफल की रिंग) यह केवल $0$ से $N-1$ तक के पूर्णांकों से बनी सर्वांगसमता (modulo) की दुनिया है।

यहाँ, हम दुनिया A से दुनिया B तक निम्नलिखित मैपिंग $\phi$ को परिभाषित करते हैं। $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

यह मैपिंग $\phi$ एक जादुई ऑपरेशन है जो दुनिया A के चर $\alpha$ को दुनिया B के पूर्णांक $m$ से बदल देता है। इस $\phi$ में एक अत्यंत शक्तिशाली गुण है जिसे “रिंग होमोमोर्फिज़्म (Ring Homomorphism)” कहा जाता है। होमोमोर्फिज़्म का अर्थ है “जोड़ और गुणा की संरचना को नष्ट किए बिना किसी दूसरी दुनिया में टेलीपोर्ट करना” । दूसरे शब्दों में, निम्नलिखित समीकरण सत्य हैं:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

इसका क्या मतलब है? अगर हम “दुनिया A ($\alpha$ की दुनिया)” में किसी जटिल तत्व $\gamma$ का “वर्ग ($\gamma^2$)” बना सकते हैं, और इसे $\phi$ का उपयोग करके “दुनिया B (शेषफल की दुनिया)” में टेलीपोर्ट कर सकते हैं, तो वर्ग रूप $\phi(\gamma)^2$ पूरी तरह से संरक्षित रहता है ।

चरण 2: अभाज्य गुणनखंडन का पतन और “आदर्शों (Ideals)” का जन्म

हम दुनिया A ($\mathbb{Z}[\alpha]$) में कई उपयुक्त तत्वों $(a - b\alpha)$ को इकट्ठा करना चाहते हैं, और उन्हें गुणा करके एक “पूर्ण वर्ग (वर्ग तत्व)” बनाना चाहते हैं। आम तौर पर, हम प्रत्येक $(a - b\alpha)$ को “अभाज्य गुणनखंड (prime factorization)” करेंगे और उन्हें इस तरह जोड़ेंगे कि अभाज्य संख्याओं के घातांक सभी सम (even) हों (मैट्रिक्स के साथ हल करके) ताकि एक वर्ग बनाया जा सके।

हालाँकि, यहाँ बीजगणित की निराशाजनक दीवार खड़ी है। $\mathbb{Z}[\alpha]$ जैसी बीजगणितीय दुनिया में, मिडिल स्कूल में सिखाई गई “अभाज्य गुणनखंडन की विशिष्टता (किसी भी संख्या को विशिष्ट रूप से अभाज्य संख्याओं के उत्पाद के रूप में व्यक्त किया जा सकता है)” ढह जाती है ।

(उदाहरण: एक निश्चित बीजगणितीय क्षेत्र की दुनिया में, $6 = 2 \times 3$ है, और साथ ही $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$ है, और हम यह नहीं जानते कि कौन सा असली अभाज्य है)

यदि अभाज्य गुणनखंडन अद्वितीय नहीं है, तो “अभाज्य संख्याओं की गिनती करके उन्हें सम बनाना” की पहेली (चलनी विधि) सैद्धांतिक रूप से असंभव है।

कुमेर और डेडेकिंड का बचाव: “आदर्श (Ideal)”

इस पतन से जो बचाया गया, वह 19वीं सदी के गणितज्ञों द्वारा बनाई गई “आदर्श (Ideal: आदर्श संख्या)” की अवधारणा थी। तत्व के बजाय, तत्व द्वारा उत्पन्न “गुणकों के सेट (आदर्श)” पर विचार करके, अभाज्य गुणनखंडन फिर से संभव हो गया।

एक बीजगणितीय क्षेत्र की पूर्णांक रिंग $\mathcal{O}_K$ ($\mathbb{Z}[\alpha]$ सहित अधिक पूर्ण रिंग) में, यह सिद्ध होता है कि भले ही तत्वों को विशिष्ट रूप से गुणनखंडित नहीं किया जा सकता, “एक आदर्श को हमेशा ‘अभाज्य आदर्शों ($\mathfrak{p}$)’ के उत्पाद के रूप में विशिष्ट रूप से गुणनखंडित किया जा सकता है” ।

इसलिए GNFS में, तत्व $(a - b\alpha)$ को सीधे गुणनखंडित करने के बजाय, हम इसके द्वारा उत्पन्न प्रमुख आदर्श (principal ideal) $\langle a - b\alpha \rangle$ को अभाज्य आदर्शों में गुणनखंडित करते हैं ।

चरण 3: नॉर्म (Norm) और दो चलनियां (Sieves)

तो, हम कैसे जानेंगे कि आदर्श $\langle a - b\alpha \rangle$ किन अभाज्य आदर्शों में विघटित होगा? यहाँ हम “नॉर्म (Norm)” नामक फ़ंक्शन का उपयोग करते हैं। नॉर्म एक ऐसा फ़ंक्शन है जो बीजगणितीय क्षेत्रों के जटिल तत्वों को “सामान्य वास्तविक पूर्णांकों $\mathbb{Z}$” में परिवर्तित करता है।

तत्व $(a - b\alpha)$ का नॉर्म एक साधारण बहुपद गणना $b^d f(a/b)$ द्वारा पाया जाता है ($d$, $f(x)$ की डिग्री है)।

बीजगणितीय प्रमेयों से, हम जानते हैं कि “यदि किसी आदर्श के नॉर्म को छोटी अभाज्य संख्याओं में पूरी तरह से गुणनखंडित किया जा सकता है (चिकना है), तो मूल आदर्श को भी छोटे अभाज्य आदर्शों में पूरी तरह से गुणनखंडित किया जा सकता है” ।

इसलिए GNFS पूर्णांक युग्मों $(a, b)$ की एक बड़ी संख्या के लिए निम्नलिखित दो की एक साथ गणना करता है, और केवल उन युग्मों को एकत्र करता है जहाँ दोनों “चिकनी संख्या (smooth number)” बन जाते हैं:

परिमेय चलनी (Rational Sieve) : $a - bm$ (वास्तविक दुनिया में मान)
बीजगणितीय चलनी (Algebraic Sieve) : $b^d f(a/b)$ (बीजगणितीय दुनिया में नॉर्म)

दशकों लाख युग्मों $(a, b)$ को इकट्ठा करने के बाद, हम अभाज्य आदर्श गुणनखंडन डेटा (कितने अभाज्य आदर्श शामिल हैं) को एक विशाल मैट्रिक्स (GF(2) पर रैखिक बीजगणित) के रूप में हल करते हैं ताकि युग्मों का एक सेट $S$ मिल सके जहाँ “गुणा करने पर सभी अभाज्य आदर्शों के घातांक सम हो जाते हैं”।

चरण 4: दो “बाधाएं” और आदर्श वर्ग समूह (Ideal Class Group)

मैट्रिक्स गणना से, हमने पाया कि सेट $S$ से संबंधित सभी $(a - b\alpha)$ के आदर्शों को गुणा करने पर एक निश्चित आदर्श $I$ का वर्ग प्राप्त होता है।

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

हालाँकि, यह अभी खत्म नहीं हुआ है। GNFS में सबसे गहरी और सबसे कठिन गणितीय दीवार यहीं है।

अंत में हम “आदर्श का वर्ग” नहीं चाहते हैं, बल्कि मैपिंग $\phi$ में बदलने के लिए “तत्व का वर्ग ($\gamma^2$)” चाहते हैं। सिर्फ इसलिए कि यह एक आदर्श का वर्ग बन गया, इसका मतलब यह नहीं है कि तत्व भी एक वर्ग है। यहाँ दो मजबूत गणितीय बाधाएं (Obstructions) हैं।

बाधा ①: आदर्श वर्ग समूह (Ideal Class Group) की दीवार

आदर्श $I$ हमेशा “एक ही तत्व द्वारा उत्पन्न आदर्श (प्रमुख आदर्श)” नहीं होता है। गैर-प्रमुख आदर्शों से किसी विशिष्ट तत्व $\gamma$ को निकालना असंभव है।

यहाँ “आदर्श वर्ग समूह (Class Group, $Cl_K$)” की अवधारणा आती है। आदर्श वर्ग समूह एक ऐसा समूह है जो यह मापता है कि “उस बीजगणितीय क्षेत्र की दुनिया में कितने आदर्श हैं जो प्रमुख नहीं हैं (अभाज्य गुणनखंडन की विशिष्टता कितनी टूट गई है)"। भले ही $\prod \langle a - b\alpha \rangle$, $I^2$ बन जाए, यदि $I$ आदर्श वर्ग समूह में पहचान तत्व (प्रमुख आदर्श) नहीं है, तो इसे तत्व के वर्ग में वापस नहीं लाया जा सकता है।

बाधा ②: इकाई समूह (Unit Group) की दीवार

मान लीजिए कि सौभाग्य से $I$ प्रमुख आदर्श $\langle \gamma \rangle$ है। तब, $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$ होता है। आप सोच सकते हैं, “बहुत बढ़िया, तत्व भी एक वर्ग है!”, लेकिन यह एक बड़ी गलती है।

आदर्शों (गुणकों के सेट) के समान होने का मतलब यह नहीं है कि तत्व पूरी तरह से समान हैं। हमेशा एक “इकाई (Unit: एक ऐसी संख्या जिसका व्युत्क्रम भी एक पूर्णांक है। जैसे 1 या -1)” का विचलन होगा। दूसरे शब्दों में, वास्तविक तत्व समीकरण इस प्रकार बन जाता है:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

($u$ इकाई समूह $U_K$ का एक तत्व है)

जब तक यह इकाई $u$ स्वयं किसी चीज़ का वर्ग नहीं है, तब तक बायाँ पक्ष कभी भी “सही तत्व का वर्ग” नहीं बन सकता।

चरण 5: एडलमैन का जादू “द्विघात वर्ण (Quadratic Characters)”

आदर्श वर्ग समूह की बाधा और इकाई समूह की बाधा। इन दोनों को कैसे पार करें? यहाँ क्रिप्टोग्राफर लियोनार्ड एडलमैन (RSA का “A”) और अन्य लोगों द्वारा पेश की गई शानदार विधि “द्विघात वर्ण (Quadratic Characters)” आती है।

यह निर्धारित करने के लिए कि “क्या बीजगणितीय क्षेत्र में कोई निश्चित तत्व पूर्ण वर्ग है?”, हम लीजेंड्रे प्रतीक (द्विघात अवशेष) के बीजगणितीय क्षेत्र संस्करण का उपयोग करते हैं। उस विशाल मैट्रिक्स (अभाज्य आदर्शों की संख्या को सम बनाने के लिए पहेली) में, हम चुपके से दर्जनों अतिरिक्त शर्तें (कॉलम) जोड़ते हैं, जिसमें कहा गया है कि “कुछ विशेष अभाज्य आदर्शों $\mathfrak{q}$ के लिए द्विघात वर्ण भी सभी $1$ (सम) होने चाहिए” ।

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

इसके साथ, अंततः हमें सच्चा समीकरण मिल जाता है:

$$\prod_{S} (a - b\alpha) = \gamma^2$$

अंतिम चरण: दुनियाओं का विलय और क्रिप्टोग्राफ़िक पतन

अंत में, पहेली के सभी टुकड़े अपनी जगह पर हैं।

[बीजगणितीय क्षेत्रों की दुनिया में तत्व (दुनिया A)] $\gamma^2 = \prod (a - b\alpha)$ (हम $\gamma$ खोजने के लिए वर्गमूल एल्गोरिदम का उपयोग करते हैं)

[वास्तविक दुनिया में तत्व (परिमेय संख्याओं की दुनिया)] $V^2 = \prod (a - bm)$ (चूंकि यह साधारण पूर्णांक गुणन है, हम आसानी से वर्गमूल $V$ पा सकते हैं)

अब, उस जादुई पुल का समय आ गया है जिसे हमने शुरुआत में बनाया था, होमोमोर्फिज़्म $\phi$ । हम $\phi$ ($\alpha$ को $m$ से बदलने वाला मैपिंग) का उपयोग करके दुनिया A के तत्व $\gamma$ को दुनिया B ($N$ के शेषफल की दुनिया) में टेलीपोर्ट करते हैं।

$$Y = \phi(\gamma) \pmod N$$

दूसरी ओर, हम वास्तविक दुनिया में बनाए गए $V$ को सीधे शेषफल की दुनिया में लाते हैं और इसे $X$ कहते हैं।

$$X = V \pmod N$$

होमोमोर्फिज़्म की “संरचना संरक्षण” संपत्ति के कारण, दुनिया A में वर्ग संबंध दुनिया B (मोडुलो $N$ की दुनिया) में पूरी तरह से संरक्षित है। इसके अलावा, चूंकि मूल युग्म $(a, b)$, $a - b\alpha$ और $a - bm$ के रूप में बनाए गए थे, ये $X$ और $Y$ मोडुलो $N$ की दुनिया में टकराते हैं और निम्नलिखित पूर्ण समीकरण उत्पन्न करते हैं:

$$X^2 \equiv Y^2 \pmod N$$

अब हमें बस यह प्रार्थना करनी है कि ये $X$ और $Y$ तुच्छ समाधान ($X \equiv \pm Y$) न हों, और $\gcd(X - Y, N)$ की गणना करें।

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

यह आधुनिक गणित के सार का संग्रह, “सामान्य संख्या क्षेत्र चलनी (GNFS)” की पूरी तस्वीर है।

इंटरनेट एन्क्रिप्शन को तोड़ने वाला मानवता का सबसे शक्तिशाली गणित "General Number Field Sieve (GNFS)" क्या है?

Sat, 05 Sep 2026 02:09:08 +0900

इंटरनेट एन्क्रिप्शन को तोड़ने वाला मानवता का सबसे शक्तिशाली गणित “General Number Field Sieve (GNFS)” क्या है?

जिस इंटरनेट का हम हर दिन उपयोग करते हैं। LINE संदेश, YouTube, Amazon पर खरीदारी आदि, सभी संचार “एन्क्रिप्शन” द्वारा सुरक्षित हैं। वर्तमान में, दुनिया में सबसे अधिक उपयोग किया जाने वाला एन्क्रिप्शन “RSA एन्क्रिप्शन” है।

RSA एन्क्रिप्शन की रक्षा की कुंजी बहुत सरल है। यह इस गणितीय गुण का उपयोग करता है कि ** “विशाल संख्याओं का अभाज्य गुणनखंडन कंप्यूटर द्वारा भी हल नहीं किया जा सकता है” ** । उदाहरण के लिए, “15” के लिए हम तुरंत जान जाते हैं कि यह “3 × 5” है, लेकिन जैसे ही यह “270 अंकों की संख्या” बन जाता है, भले ही हम दुनिया के सभी सुपर कंप्यूटरों को मिला दें, इसे हल करने में करोड़ों साल लगेंगे।

हालाँकि, गणितज्ञ भी चुप नहीं रहे। इस अभेद्य एन्क्रिप्शन को तोड़ने के लिए, मानवता ने एक लगभग जादुई एल्गोरिदम (गणना प्रक्रिया) बनाया है जिसे ** “General Number Field Sieve (GNFS)” ** कहा जाता है।

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

अध्याय 1: डिकोडिंग का लक्ष्य एक “8वीं कक्षा का सूत्र” है

विशाल अभाज्य गुणनखंडन का सामना करने के लिए सबसे बड़ी विशेष चाल। यह 8वीं कक्षा में सीखा गया सूत्र है:

** $X^2 - Y^2 = (X + Y)(X - Y)$ **

आप सोच सकते हैं: “सच में, क्या ऐसा बुनियादी सूत्र एन्क्रिप्शन को तोड़ सकता है?"। हालाँकि, यह वह मास्टर की है जो सब कुछ खोल देती है।

एन्क्रिप्शन को तोड़ने का सबसे बड़ा लक्ष्य, एक विशाल संख्या $N$ के लिए, ** “ऐसे संख्याएँ ($X$ और $Y$) खोजना है जहाँ $X^2$ और $Y^2$ को $N$ से विभाजित करने पर शेषफल समान हो” ** ।

“समान शेषफल” एन्क्रिप्शन को क्यों तोड़ता है?

मान लीजिए कि दो संख्याओं, $X^2$ और $Y^2$, का “$N$ से विभाजित करने पर समान शेषफल” है। समान शेषफल होने का मतलब है कि एक नियम है जहाँ ** घटाव “$X^2 - Y^2$” हमेशा $N$ से पूरी तरह से विभाज्य होगा ($N$ का गुणज होगा) ** ।

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

$X^2 - Y^2$ का गुणनखंडन करने पर, हमें ** $(X - Y)(X + Y)$ ** मिलता है। इसका $N$ का गुणज होने का अर्थ है कि इस गुणन में कहीं न कहीं गुप्त अभाज्य संख्याएँ $p$ और $q$ छिपी हैं।

यहाँ, एक चमत्कार होता है। गणितीय रूप से ** 50% (आधा) ** संभावना है कि दो अभाज्य संख्याएँ $p$ और $q$ अलग-अलग कमरों में चली जाएँगी: ** “$p$ $(X - Y)$ के कमरे में जाता है” और “$q$ $(X + Y)$ के कमरे में जाता है” ** ।

केवल अभाज्य संख्या $p$ के $(X - Y)$ कक्ष में प्रवेश करने के साथ, आइए $(X - Y)$ और $N$ के ** “महत्तम समापवर्तक (सबसे बड़ा उभयनिष्ठ भाग)” ** की गणना करें।

$(X - Y)$ की सामग्री = $p \times$ कोई संख्या
$N$ की सामग्री = $p \times q$ एकमात्र सामान्य भाग ** “$p$” ** है!

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

** 【छोटा कॉलम: वर्ग क्यों? घन या दोगुना काम क्यों नहीं करता?】 **

“$2X - 2Y$” के साथ, यह $2(X - Y)$ हो जाता है और केवल एक कमरा होता है, इसलिए आप अभाज्यों को अलग नहीं कर सकते। “$X^3 - Y^3$” के साथ, कमरे का आकार असंतुलित हो जाता है और गणना अनावश्यक रूप से भारी हो जाती है। अभाज्यों को दो में अलग करने के लिए, “वर्ग” जो पूरी तरह से दो कमरों में विभाजित होता है, सबसे अधिक लागत प्रभावी है।

अध्याय 2: X और Y कैसे खोजें? “अभाज्य संख्या कार्ड संग्रह पहेली”

लक्ष्य समझ में आ गया है। हालाँकि, भले ही हम आँख बंद करके “$X^2$ और $Y^2$ जिनके समान शेषफल हैं” की खोज करें, ब्रह्मांड का अंत उन्हें खोजने से पहले आ जाएगा। इसलिए, गणितज्ञ एक शानदार विचार लेकर आए जिसे ** “अभाज्य संख्या कार्ड संग्रह पहेली” ** कहा जाता है।

चरण 1: छलनी से केवल सोने की धूल (smooth numbers) एकत्र करें

सबसे पहले, एक उपयुक्त संख्या $Z$ तैयार करें, इसे वर्ग करें और इसे $N$ से विभाजित करके शेषफल $W$ की गणना करें। ($Z^2 = W$ की शेषफल दुनिया)

प्राप्त शेषफल $W$ का अभाज्य गुणनखंडन करें। यहाँ, केवल जब ** “2, 3, 5, 7, आदि जैसे छोटे अभाज्यों से बना $W$” ** दिखाई देता है, तो उस समीकरण को “विजेता कार्ड” के रूप में रखें, और यदि बड़े अभाज्य मिश्रित हों तो इसे फेंक दें। यह नदी में छलनी से बड़े पत्थरों को फेंकने और केवल सोने की धूल इकट्ठा करने जैसा है।

चरण 2: सबको “सम” बनाने की पहेली

उदाहरण के लिए, मान लीजिए कि निम्नलिखित 3 सोने की धूल वाले कार्ड एकत्र किए गए हैं।

कार्ड A: $Z_1^2 = 2^3 \times 3^1$
कार्ड B: $Z_2^2 = 2^1 \times 5^1$
कार्ड C: $Z_3^2 = 3^1 \times 5^1$

आइए उन सभी को गुणा करें। दाईं ओर $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$ हो जाता है, और सब कुछ एक साथ व्यवस्थित करने पर, यह ** “$2^4 \times 3^2 \times 5^2$” ** बन जाता है।

आश्चर्य की बात है, अभाज्य संख्याओं की संख्या “4, 2, 2” हो गई, ** सभी सम संख्याएँ हैं ** ! सभी सम होने का अर्थ है कि यदि आप कुल राशि को आधा कर देते हैं, तो यह “किसी चीज़ का वर्ग” होगा। दूसरे शब्दों में, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$।

बाईं ओर $(Z_1 \times Z_2 \times Z_3)^2$ है, तो अंततः, ** $X = (Z_1 \times Z_2 \times Z_3)$ ** ** $Y = 60$ ** “$X^2 = Y^2$” की बहुप्रतीक्षित जोड़ी पूरी हो गई है!

कंप्यूटर के लिए, यह गणना करने की पहेली कि अभाज्य संख्याओं की संख्या “सम है या विषम (0 या 1)” कुछ ऐसा है जिसमें वे बहुत अच्छे हैं, इसलिए इस पद्धति के साथ $X$ और $Y$ उच्च गति पर पाए जा सकते हैं।

अध्याय 3: निराशा की दीवार

अब किसी भी एन्क्रिप्शन को तोड़ा जा सकता है! …या हमने ऐसा सोचा, लेकिन एक बड़ी समस्या उत्पन्न होती है। यदि एन्क्रिप्शन संख्या $N$ “100 अंक” तक है, तो यह विधि (जिसे Quadratic Sieve कहा जाता है) इसे हल कर सकती है, लेकिन जब $N$ “200 या 300 अंक” बन जाता है, तो गणना के मध्य में आने वाला $W$ बहुत बड़ा हो जाता है।

जब संख्याएँ बहुत बड़ी हो जाती हैं, तो “केवल छोटी अभाज्य संख्याओं (सोने की धूल) से बनी संख्याएँ” आना बंद हो जाती हैं। रेगिस्तान में कॉन्टैक्ट लेंस खोजना अधिक कठिन हो जाता है, और पहेली को सुलझाने के लिए आवश्यक कार्ड बिल्कुल भी एकत्र नहीं होंगे।

यहाँ, अंततः, मानवता का अंतिम हथियार, ** “General Number Field Sieve (GNFS)” ** प्रकट होता है।

अध्याय 4: मानवता का “दो दुनिया” बनाने का सबसे शक्तिशाली विचार

GNFS का शानदार विचार है: ** “संख्याएँ विशाल हो जाती हैं क्योंकि हम केवल वास्तविक दुनिया में गणना करते हैं। तो, चलिए गणना के भार को दो भागों में विभाजित करने के लिए बहुपदों (अक्षर सूत्रों) का उपयोग करके एक ‘पर्दे के पीछे की दुनिया’ बनाते हैं।” **

अक्षर सूत्रों का जादू

GNFS आधार संख्या $m$ का उपयोग करके विशाल संख्या $N$ को अक्षर व्यंजक में परिवर्तित करता है। उदाहरण के लिए यदि $N=100$, $m=4$ के साथ, तो यह $100 = 4^3 + 2(4^2) + 4$ है। अक्षर $x$ का उपयोग करके इसे सूत्र (पर्दे के पीछे की दुनिया) में बदलते हैं: ** $f(x) = x^3 + 2x^2 + x$ ** ।

इस सूत्र की दिलचस्प बात यह है कि इसमें यह गुण है: ** “यदि आप $x$ के स्थान पर $m$ (उपरोक्त उदाहरण में 4) रखते हैं, तो आप हमेशा वास्तविक संख्या $N$ पर वापस लौट सकते हैं” ** ।

एक साथ 2 दुनियाओं में सोने की धूल की तलाश

GNFS यादृच्छिक पूर्णांक जोड़े $(a, b)$ बनाता है और एक साथ निम्नलिखित दो गणनाएं करता है:

** वास्तविक दुनिया ** : $a - b \times m$
** अक्षरों की दुनिया ** : बहुपद नियमों द्वारा गणना की गई $a - b \times x$ का मूल्य

समस्या को दो दुनियाओं में विभाजित करके, संभाली गई संख्याओं का आकार काफी कम (हल्का) हो जाता है। यह एक विशाल चट्टान को आसान से संभालने वाले पत्थरों में विभाजित करने जैसा है।

फिर, आप केवल उन चमत्कारी जोड़ियों $(a, b)$ को अलग करने और इकट्ठा करने के लिए छलनी का उपयोग करते हैं जहाँ ** “वास्तविक दुनिया और अक्षरों की दुनिया दोनों में, वे ‘केवल छोटी अभाज्य संख्याओं (सोने की धूल) से बने’ हैं” ** । यही “Number Field Sieve” नाम का मूल है।

वह क्षण जब एन्क्रिप्शन अंततः टूट जाता है

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

एक बार संयोजन मिल जाने के बाद:

वास्तविक दुनिया में वर्ग संख्या को ** $X^2$ ** होने दें
अक्षरों की दुनिया में बनाए गए वर्ग सूत्र को ** $Y(x)^2$ ** होने दें

अंततः, अक्षर सूत्र $Y(x)$ में $x$ के स्थान पर $m$ को रखें, वास्तविक दुनिया में वापस कूदें और उनसे जुड़ें। फिर, गणितीय जादू की तरह, वह स्थिति जहाँ ** “$X^2$ और $Y^2$ का शेषफल समान है” ** पूरी तरह से सिद्ध हो जाती है!

बाकी, अध्याय 1 की तरह, केवल $X - Y$ और $N$ के महत्तम समापवर्तक की गणना करना है, और अभेद्य RSA एन्क्रिप्शन ढह जाएगा, जिससे गुप्त अभाज्य संख्याएँ सामने आ जाएंगी।

निष्कर्ष: गणित कभी समाप्त नहीं होता

आप सोच रहे होंगे: “बढ़िया, GNFS के साथ किसी भी एन्क्रिप्शन को तोड़ा जा सकता है!"। हालाँकि, RSA एन्क्रिप्शन ने भी हार नहीं मानी है। आज इंटरनेट पर जो उपयोग किया जाता है वह एक राक्षसी विशाल संख्या है जिसे “RSA-2048 (लगभग 617 अंक)” कहा जाता है।

GNFS मानवता का सबसे शक्तिशाली एल्गोरिदम है, लेकिन 270 अंकों (RSA-270) को हल करने के लिए भी कहा जाता है कि दुनिया भर के कंप्यूटरों को जोड़ने पर भी हजारों या दसियों हजार साल लगेंगे। अभी के लिए, हमारे LINE और बैंक डेटा सुरक्षित हैं।

लेकिन क्या होगा यदि ** “किसी भी विशाल संख्या के लिए $X$ और $Y$ को तुरंत खोजने का जादू” ** प्रकट हो जाए? वास्तव में, इसके सबसे करीब ** “क्वांटम कंप्यूटर (Shor का एल्गोरिदम)” ** है जो वर्तमान में विकास में है। क्वांटम यांत्रिकी की तरंग प्रकृति का उपयोग करते हुए, यह गणितीय रूप से सिद्ध हो गया है कि थकाऊ कार्ड संग्रह पहेली को दरकिनार करना और एक ही बार में उत्तर तक पहुंचना संभव है।

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

जो भविष्य के सबसे मजबूत एल्गोरिदम की खोज करेगा, वह आप ही हो सकते हैं जो इस लेख को पढ़ रहे हैं!

(※यह लेख छात्रों के लिए कोड-ब्रेकिंग के गणितीय आकर्षण का एक वैचारिक रूपांतरण है। वास्तविक GNFS की गणना उच्च विश्वविद्यालय गणित, जैसे बीजीय संख्या क्षेत्रों के आदर्श वर्ग समूहों और समरूपता का उपयोग करके सख्ती से की जाती है)