एक क्रिप्टोग्राफिक PRCH की खोज में

हाय% उपयोगकर्ता नाम%!

आज की पोस्ट में, हम छद्म यादृच्छिक संख्या जनरेटर (PRNGs) की क्रिप्टोग्राफिक स्थिरता के बारे में बात करेंगे।
शुरू करने के लिए, हम यह निर्धारित करेंगे कि एक क्रिप्टो-प्रतिरोधी PRNG (KSGPSCH) क्या है।

HRCSSC "अगले बिट परीक्षण" को संतुष्ट करेगा। परीक्षण का अर्थ इस प्रकार है: एक बहुपद एल्गोरिथ्म नहीं होना चाहिए, जो यादृच्छिक क्रम के पहले k बिट्स को जानकर, 50% से अधिक की संभावना के साथ k + 1 बिट्स की भविष्यवाणी करने में सक्षम होगा।

विकिपीडिया

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

रैखिक प्रतिक्रिया पारी रजिस्टर

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


प्रत्येक PRNSS PRNS एक विशिष्ट बहुपद के साथ जुड़ा हुआ है जो रजिस्टर की लंबाई और प्रतिक्रिया समारोह की विशेषता है। उदाहरण के लिए, बहुपद निम्नलिखित रजिस्टर से मेल खाता है:


बहुपद की डिग्री रजिस्टर की लंबाई निर्धारित करती है; नॉनज़रो टर्म्स बताती हैं कि रजिस्टर के कौन से तत्व टैप सीक्वेंस का निर्माण करते हैं।
यदि नल अनुक्रम उत्पन्न करने वाला बहुपद irreducible modulo 2 है, तो रजिस्टर द्वारा उत्पन्न अनुक्रम की अवधि अधिकतम होगी और सूत्र द्वारा गणना की जाएगी ।

काम शुरू करने से पहले, बिट्स का एक मनमाना अनुक्रम, जिसे प्रारंभिक अवस्था कहा जाता है, रजिस्टर में दर्ज किया जाता है। उसके बाद, जनरेटर का प्रत्येक घड़ी चक्र 1 बिट लौटाता है, जो पूरी तरह से यादृच्छिक दिखता है।
RSLOS प्रति se अच्छे PRNG हैं, लेकिन चूंकि उनकी मदद से प्राप्त बिट्स में एक रैखिक संबंध है, इसलिए क्रिप्टोग्राफिक प्रयोजनों के लिए RSLOS का उपयोग करना अनुचित है।
यदि कोई हमलावर RSLOS का उपयोग करके उत्पन्न लंबाई के बिट्स का एक अनुक्रम प्राप्त करता है, तो वह इन बिट्स को रजिस्टर में लोड कर सकता है और प्रारंभिक स्थिति प्राप्त करने के लिए वापस स्क्रॉल कर सकता है। प्रारंभिक स्थिति को जानने से उसे भविष्य में पहले और उत्पन्न सभी अनुक्रमों तक पहुंच मिलेगी।

केस की जानकारी छुपाना एक अच्छा विचार हो सकता है। फिर, लंबाई n का एक क्रम प्राप्त करने के बाद भी, हमलावर प्रारंभिक स्थिति को खोलने के लिए कदम नहीं उठा पाएगा।
लेकिन बेर्लेकैंप - मैसी एल्गोरिथम का उपयोग करके इस स्थिति को आसानी से हल किया जाता है। यह एल्गोरिदम RSLOS से जुड़े बहुपद को खोलना संभव बनाता है। ऐसा करने के लिए, केवल 2n की लंबाई के साथ रजिस्टर द्वारा उत्पन्न अनुक्रम होना पर्याप्त है।
एल्गोरिथ्म लागू करने के लिए काफी सरल है:

public int[] BerlekampMassey(int[] array) { int N = array.Length; int[] b = new int[N]; int[] c = new int[N]; int[] t = new int[N]; b[0] = 1; c[0] = 1; int l = 0; int m = -1; for (int n = 0; n < N; n++) { int d = 0; for (int i = 0; i <= l; i++) { d ^= c[i] * array[n - i]; } if (d == 1) { Array.Copy(c, 0, t, 0, N); int N_M = (nm); for (int j = 0; j < N - N_M; j++) { c[N_M + j] ^= b[j]; } if (l <= n / 2) { l = n + 1 - l; m = n; Array.Copy(t, 0, b, 0, N); } } } return c; } 

इनपुट RSLOS का उपयोग करके उत्पन्न बिट्स का एक अनुक्रम प्राप्त करता है। प्रतिक्रिया योजना के रूप में एक बहुपद चरित्र का परिणाम है।

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

Mersenne बवंडर

मेरी राय में बहुत अधिक दिलचस्प PRNG है, जिसे Mersenne Whirlwind कहा जाता है। एल्गोरिथ्म के लिए कई विकल्प हैं। हम केवल सबसे अधिक इस्तेमाल किए जाने वाले MT19937 पर विचार करेंगे। हम इस एल्गोरिथम का संक्षेप में वर्णन करते हैं।
Mersenne भंवर दो भागों के होते हैं: RSLOS और शमन।

शिफ्ट रजिस्टर में 624 तत्व, प्रत्येक 32 बिट लंबे होते हैं। प्रारंभिक अवस्था का प्रारंभ समारोह द्वारा वर्णित है:

  function initialize_generator(int seed) { index := 0 MT[0] := seed for i from 1 to 623 { // loop over each other element MT[i] := last 32 bits of(1812433253 * (MT[i-1] xor (right shift by 30 bits(MT[i-1]))) + i) // 0x6c078965 } } 

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

पहले और बाद के 624 वें चरण में, रजिस्टर की आंतरिक स्थिति मिश्रित है:

  function generate_numbers() { for i from 0 to 623 { int y := (MT[i] & 0x80000000) // bit 31 (32nd bit) of MT[i] + (MT[(i+1) mod 624] & 0x7fffffff) // bits 0-30 (first 31 bits) of MT[...] MT[i] := MT[(i + 397) mod 624] xor (right shift by 1 bit(y)) if (y mod 2) != 0 { // y is odd MT[i] := MT[i] xor (2567483615) // 0x9908b0df } } } 

प्रत्येक चरण में, एल्गोरिथ्म रजिस्टर की वर्तमान स्थिति से निम्नलिखित नंबर लौटाता है और तथाकथित "हार्डनिंग" उत्पन्न करता है:

  function extract_number() { if index == 0 { generate_numbers() } int y := MT[index] // y := y xor (right shift by 11 bits(y)) y := y xor (left shift by 7 bits(y) and (2636928640)) // 0x9d2c5680 y := y xor (left shift by 15 bits(y) and (4022730752)) // 0xefc60000 y := y xor (right shift by 18 bits(y)) index := (index + 1) mod 624 return y } 

एल्गोरिथ्म की आंतरिक स्थिति तक पहुंच प्राप्त करने के लिए, एक हमलावर को केवल 624 संख्याओं का अनुक्रम प्राप्त करना होगा।
आपको केवल एल्गोरिदम द्वारा उत्पन्न संख्याओं को उस स्थिति में वापस करना होगा जिसमें वे "सख्त" चरण से पहले थे। ऐसा करने के लिए, आपको विपरीत दिशा में सख्त होने के सभी चरणों को करने की आवश्यकता है। उदाहरण के लिए, शमन के अंतिम चरण पर विचार करें:
y := y ^ (y >>> 18)
आइए देखें कि इस ऑपरेशन को करते समय बाइनरी डेटा के साथ क्या होता है:
y 101101110101111001 11111001110010
y >>> 18 00000000000000000010110111010111 100111111001110010
y ^ (y >>> 18) 101101110101111001 01001110100101
जैसा कि आप देख सकते हैं, परिणाम के पहले 18 बिट्स और मूल संख्या समान हैं। शेष 14 बिट्स को पुनर्स्थापित करने के लिए, हमें निम्नलिखित करने की आवश्यकता है:
result ^ (result >>> 18)
कठोर चरण के सभी चरणों के लिए एक समान तरीके से कार्य करते हुए, हम PRNG की प्रारंभिक अवस्था का एक तत्व प्राप्त करते हैं:

  private uint reverse(uint output) { uint tempout = output >> 18; output = output ^ tempout; tempout = output << 15; output = (uint)(output ^ (tempout & 4022730752)); uint a = output << 7; uint b = (uint)(output ^ (a & 2636928640)); uint c = b << 7; uint d = (uint)(output ^ (c & 2636928640)); uint e = d << 7; uint f = (uint)(output ^ (e & 2636928640)); uint g = f << 7; uint h = (uint)(output ^ (g & 2636928640)); uint i = h << 7; uint tempfinal = (uint)(output ^ (i & 2636928640)); uint k = tempfinal >> 11; uint l = (uint)(tempfinal ^ k); uint m = (uint)l >> 11; uint final = (uint)(tempfinal ^ m); return final;  } 

जैसा कि मैंने ऊपर उल्लेख किया है, अगर हमलावर के पास 624 नंबर हैं, जो मेरसेन भंवर का उपयोग करके उत्पन्न हुआ है, यह पूरी आंतरिक स्थिति को बहाल करने और बाद के एक में उत्पन्न सभी संख्याओं के साथ 100% संभावना के साथ भविष्यवाणी करने के लिए पर्याप्त है।

क्रिप्टोग्राफिक PRSP

एक विकल्प के रूप में, मैं दो बहुत विश्वसनीय तरीकों की पेशकश करना चाहता हूं।

ब्लम - ब्लम - शुभ एल्गोरिथम
यह जनरेटर बड़ी संख्या के कारकीकरण की समस्या को हल करने की जटिलता पर आधारित है।
एल्गोरिथ्म छद्म यादृच्छिक बिट्स का एक क्रम उत्पन्न करता है और इसमें निम्न चरण होते हैं:

• दो बड़े primes उत्पन्न करें, q ऐसा कि p = q = 3 mod 4।
• M = p * q की गणना करें।
• बड़ी संख्या में x _{0 लें} , एम से सहसंबंध।
• अनुक्रम उत्पन्न करने के प्रत्येक चरण पर, संख्या x _{i + 1} = x _i ² mod M।
• नतीजतन, संख्या x का अंतिम बिट _मैं वापस आ गया है।

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

CTR एन्क्रिप्शन मोड
एक छद्म यादृच्छिक अनुक्रम प्राप्त करने के लिए एक तेज़, लेकिन समान रूप से विश्वसनीय तरीका ब्लॉक सिफर्स के एन्क्रिप्शन का सीटीआर मोड है, दूसरे शब्दों में, काउंटर मोड। एन्क्रिप्शन फ़ंक्शन के रूप में, आप किसी भी मजबूत ब्लॉक सिफर का उपयोग कर सकते हैं, उदाहरण के लिए, एईएस।

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

निष्कर्ष

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