💜 😆 😠 जीएसएम नेटवर्क सुरक्षा: डेटा एन्क्रिप्शन 🤦🏾 🥉 👺

अस्वीकरण यह लेख केवल सूचना के उद्देश्यों के लिए प्रकाशित किया गया है, इस लेख में प्रकाशित सामग्री के उपयोग के लिए, लेखक जिम्मेदार नहीं है।
मैं आपको तुरंत चेतावनी देना चाहता हूं कि यदि आप इस लेख में जीएसएम ट्रैफिक को सुनने के लिए एक कदम-दर-चरण मार्गदर्शिका खोजने की उम्मीद करते हैं या यदि आप उम्मीद कर रहे हैं, तो इस लेख को पढ़ने के लिए, अपने दोस्तों, परिचितों, ~~पालतू जानवरों~~ की टेलीफोन वार्तालापों तक पहुंच प्राप्त करें, तो इसे अनदेखा करना बेहतर है। आपको यहां कुछ भी दिलचस्प नहीं मिलेगा। वास्तव में, कट के नीचे नहीं जाना है, वहाँ ऊब है।

भाग 1: जीएसएम सुरक्षा हाइलाइट्स

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

इस आंकड़े में निम्नलिखित चरणों को योजनाबद्ध रूप से प्रस्तुत किया गया है:

ऑपरेटर का टेलीफोन नेटवर्क से जुड़ा होता है।
इसकी प्रामाणिकता की पुष्टि करने के लिए, फोन एक विशेष पहचान कोड भेजता है जिसे टीएमएसआई (अस्थायी मोबाइल सब्सक्राइबर आइडेंटिटी) कहा जाता है।
प्रमाणीकरण केंद्र (CA) एक 128-बिट यादृच्छिक संख्या RAND बनाता है और इसे मोबाइल स्टेशन (MS) पर भेजता है।
MS अपनी निजी कुंजी K _i और प्रमाणीकरण एल्गोरिथ्म A3 का उपयोग करके प्राप्त RAND नंबर को एन्क्रिप्ट करता है।
MC पिछले चरण में प्राप्त अनुक्रम से पहले 32 बिट्स लेता है (चलो उन्हें SRES (हस्ताक्षरित प्रतिक्रिया) कहते हैं) और उन्हें CA पर वापस भेजता है।
CA समान ऑपरेशन करता है और XRES (अपेक्षित प्रतिक्रिया) का 32 बिट अनुक्रम प्राप्त करता है।
तब CA SRES और XRES की तुलना करता है। यदि दोनों मान समान हैं, तो फोन को प्रमाणित माना जाता है।
MS और CA गुप्त कुंजी K _i और कुंजी पीढ़ी एल्गोरिथ्म A8 K _c = A8 _ki (रैंड) का उपयोग करके सत्र एन्क्रिप्शन कुंजी की गणना करते हैं

प्रमाणीकरण एल्गोरिदम A3 और प्रमुख पीढ़ी के एल्गोरिथ्म A8 के बारे में बोलते हुए, यह ध्यान दिया जाना चाहिए कि व्यवहार में अधिकांश मोबाइल ऑपरेटर इस उद्देश्य के लिए एक एल्गोरिथ्म का उपयोग करते हैं जिसे COMP128 कहा जाता है (इसमें कई संशोधन COMP128-1, COMP128-2, COMP128-3) हैं।
COMP128 एक साधारण हैश फ़ंक्शन है, जो इनपुट पर 128-बिट अनुक्रम लेता है और आउटपुट पर 96-बिट अनुक्रम देता है।
इसलिए, प्रमाणीकरण के लिए अलग-अलग एल्गोरिदम का उपयोग करने और सत्र कुंजी बनाने के बजाय, निम्न योजना का उपयोग किया जाता है:
SRES = COMP128 से पहले 32 बिट्स (K _i || RAND)
K _c = COMP128 के अंतिम 64 बिट्स (K _i || RAND)।
क्रिप्टोग्राफी में हमेशा की तरह, डेवलपर्स के लिए समय बचाने की कोशिश पूरी तरह से विफल रही। जीएसएम नेटवर्क की सुरक्षा शुरू में "अज्ञात के कारण सुरक्षा" के सिद्धांत पर आधारित थी। और जब 1998 में एल्गोरिथ्म को मार्क ब्रिकेनो, इयान गोल्डबर्ग और डेविड वैगनर के शोधकर्ताओं के एक समूह द्वारा खोजा गया था, तो एक दिलचस्प विशेषता सामने आई: गुप्त कुंजी के के अंतिम 10 बिट्स हमेशा शून्य _थे । इस उत्सुक संपत्ति का उपयोग करने के साथ-साथ COMP128 की भेद्यता "जन्मदिन के हमले" के लिए मार्क ब्रीनेनो, इयान गोल्डबर्ग और डेविड वैगनर सिम कार्ड से गुप्त कुंजी के _i निकालने में सक्षम थे।
इस अध्ययन का परिणाम COMP128 एल्गोरिथम की व्यापक अस्वीकृति और अधिक विश्वसनीय संशोधनों COMP128-2 और COMP128-3 के साथ इसका प्रतिस्थापन था, जिनके तकनीकी विवरण गुप्त रखे जाते हैं। हम्म ... क्या यह आपको कुछ याद दिलाता है?

भाग 2: A5 / 1 एन्क्रिप्शन एल्गोरिथ्म

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

A5 / 1 - धारा सिफर, सबसे आम आज।
A5 / 2 पिछले "खराब" एल्गोरिथ्म का एक प्रकार है। अपने "बड़े भाई" के समान, लेकिन शुरू में ए 5/1 का बहुत कमजोर संस्करण कैसे सोचा। वर्तमान में उपयोग नहीं किया गया
A5 / 3- ब्लॉक सिफर। अप्रचलित A5 / 1 को बदलने के लिए 2002 में डिज़ाइन किया गया। हालाँकि, वर्तमान में इसका उपयोग केवल 3GPP नेटवर्क में किया जाता है। एल्गोरिथ्म में कई कमजोरियां पाई गईं, लेकिन अभी तक व्यावहारिक हमलों की बात नहीं है।

आइए एल्गोरिथ्म ए 5/1 पर अधिक विस्तार से विचार करें।
तो, जैसा कि ऊपर उल्लेख किया गया है, ए 5/1 एक स्ट्रीम सिफर है। और फिर से विकिपीडिया से मदद के लिए चित्र आया:

A5 / 1 सिफर की आंतरिक स्थिति में तीन रैखिक परिवर्तन रजिस्टरों के साथ प्रतिक्रिया R1, R2, R3 होते हैं, जिनकी लंबाई 19, 22 और 23 बिट्स होती है, क्रमशः (कुल 64 बिट्स)।
आर 1, आर 2, आर 2, आर 3 में बदलाव तभी होता है जब कोई निश्चित शर्त पूरी होती है। प्रत्येक रजिस्टर में एक "घड़ी नियंत्रण बिट" होता है। आर 1 में, यह 8 वां बिट है, जबकि आर 2 और आर 3 में यह 10 वां बिट है। प्रत्येक चरण में, केवल उन रजिस्टरों को स्थानांतरित किया जाता है जिसमें सभी तीन रजिस्टरों के सिंक्रोनाइज़िंग बिट्स के मूल्यों के बराबर सिंक्रोनाइज़ेशन बिट का मूल्य होता है।

एल्गोरिथ्म चलने से पहले, रजिस्टर इनिशियलाइज़ेशन किया जाता है। यह निम्नानुसार होता है:

आर 1 = आर 2 = आर 3 = 0
I = 0 से 63 के लिए
R1 [0] = R1 [0] =Kc [i]
R2 [0] = R2 [0] 0Kc [i]
R2 [0] = R2 [0] 0Kc [i]
सिंक्रनाइज़ेशन बिट्स को अनदेखा करते हुए, सभी रजिस्टरों को एक स्थिति में शिफ्ट करें।
I = 0 से 22 के लिए
R1 [0] = R1 [0] CFrameCount [[i]
R2 [0] = R2 [0] 0FrameCount [[i]
R2 [0] = R2 [0] 0FrameCount [[i]
सिंक्रनाइज़ेशन बिट्स को अनदेखा करते हुए, सभी रजिस्टरों को एक स्थिति में शिफ्ट करें।
I = 0 से 99 के लिए
सिंक्रनाइज़ेशन बिट्स को ध्यान में रखते हुए, रजिस्टरों को एक स्थान पर शिफ्ट करें।

जहां फ्रेमवर्क वर्तमान फ्रेम की संख्या का 32-बिट रिकॉर्ड है।

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

हम उपरोक्त विवरण का उपयोग करेंगे और C5 में A5 / 1 एन्क्रिप्शन लागू करेंगे।

कक्षा A5Enc C # में

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Collections; namespace A5project { class A5Enc { private bool[] reg = new bool[19]; private bool[] reg2 = new bool[22]; private bool[] reg3 = new bool[23]; //,           public A5Enc(bool[][] startState) { reg = startState[0]; reg2 = startState[1]; reg3 = startState[2]; } public A5Enc() { for (int i = 0; i < 19; i++) reg[i] = false; for (int i = 0; i < 22; i++) reg2[i] = false; for (int i = 0; i < 23; i++) reg3[i] = false; } //  ,      A5 public void KeySetup(byte[] key, int[] frame) { for (int i = 0; i < 19; i++) reg[i] = false; for (int i = 0; i < 22; i++) reg2[i] = false; for (int i = 0; i < 23; i++) reg3[i] = false; BitArray KeyBits = new BitArray(key); BitArray FrameBits = new BitArray(frame); bool[] b = new bool[64]; for (int i = 0; i < 64; i++) { clockall(); reg[0] = reg[0] ^ KeyBits[i]; reg2[0] = reg2[0] ^ KeyBits[i]; reg3[0] = reg3[0] ^ KeyBits[i]; } for (int i = 0; i < 22; i++) { clockall(); reg[0] = reg[0] ^ FrameBits[i]; reg2[0] = reg2[0] ^ FrameBits[i]; reg3[0] = reg3[0] ^ FrameBits[i]; } for (int i = 0; i < 100; i++) { clock(); } } // ,       public void KeySetup(int[] frame) { BitArray FrameBits = new BitArray(frame); for (int i = 0; i < 22; i++) { clockall(); reg[0] = reg[0] ^ FrameBits[i]; reg2[0] = reg2[0] ^ FrameBits[i]; reg3[0] = reg3[0] ^ FrameBits[i]; } for (int i = 0; i < 100; i++) { clock(); } } private void clock() { bool majority = ((reg[8] & reg2[10]) | (reg[8] & reg3[10]) | (reg2[10] & reg3[10])); if (reg[8] == majority) clockone(reg); if (reg2[10] == majority) clocktwo(reg2); if (reg3[10] == majority) clockthree(reg3); } //     private bool[] clockone(bool[] RegOne) { bool temp = false; for (int i = RegOne.Length - 1; i > 0; i--) { if (i == RegOne.Length - 1) temp = RegOne[13] ^ RegOne[16] ^ RegOne[17] ^ RegOne[18]; RegOne[i] = RegOne[i - 1]; if (i == 1) RegOne[0] = temp; } return RegOne; } private bool[] clocktwo(bool[] RegTwo) { bool temp = false; for (int i = RegTwo.Length - 1; i > 0; i--) { if (i == RegTwo.Length - 1) temp = RegTwo[20] ^ RegTwo[21]; RegTwo[i] = RegTwo[i - 1]; if (i == 1) RegTwo[0] = temp; } return RegTwo; } private bool[] clockthree(bool[] RegThree) { bool temp = false; for (int i = RegThree.Length - 1; i > 0; i--) { if (i == RegThree.Length - 1) temp = RegThree[7] ^ RegThree[20] ^ RegThree[21] ^ RegThree[22]; RegThree[i] = RegThree[i - 1]; if (i == 1) RegThree[0] = temp; } return RegThree; } private void clockall() { reg = clockone(reg); reg2 = clocktwo(reg2); reg3 = clockthree(reg3); } //  114    public bool[] A5() { bool[] FirstPart = new bool[114]; for (int i = 0; i < 114; i++) { clock(); FirstPart[i] = (reg[18] ^ reg2[21] ^ reg3[22]); } return FirstPart; } //   228     public bool[] A5(bool AsFrame) { bool[] FirstPart = new bool[228]; for (int i = 0; i < 228; i++) { clock(); FirstPart[i] = (reg[18] ^ reg2[21] ^ reg3[22]); } return FirstPart; } public byte[] FromBoolToByte(bool[] key, bool lsb) { int bytes = key.Length / 8; if ((key.Length % 8) != 0) bytes++; byte[] arr2 = new byte[bytes]; int bitIndex = 0, byteIndex = 0; for (int i = 0; i < key.Length; i++) { if (key[i]) { if(lsb) arr2[byteIndex] |= (byte)(((byte)1) << (7 - bitIndex)); else arr2[byteIndex] |= (byte)(((byte)1) << (bitIndex)); } bitIndex++; if (bitIndex == 8) { bitIndex = 0; byteIndex++; } } return arr2; } } }

आप कुंजी {0x12, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF} और फ़्रेम नंबर 0x134 के साथ प्रोग्राम चलाकर कोड की शुद्धता को सत्यापित कर सकते हैं। प्रत्येक 114 बिट्स के दो उत्पन्न क्रम क्रमशः {0x53, 0x4E, 0xAA, 0x58, 0x2F, 0xE8, 0x15, 0x1A, 0xB6, 0xE1, 0x85, 0x5A, 0x72, 0x8C, 0x8C और {0} और {0}} और {0x24} के बराबर होने चाहिए। , 0xA3, 0x5D, 0x5F, 0xB6, 0x52, 0x6D, 0x32, 0xF9, 0x06, 0xDF, 0x1A, 0x10}।
यह ऐसा परीक्षण डेटा था जो मार्क ब्रिकेनो, इयान गोल्डबर्ग और डेविड वैगनर ने सी में लिखे एल्गोरिथम के अपने पहले कार्यान्वयन में उपयोग किया था।

इस वर्ग का उपयोग करने वाला एन्क्रिप्शन / डिक्रिप्शन फ़ंक्शन इस तरह दिखेगा:

 private byte[] A5Encyptor(byte[] msg,byte[] key) { A5Enc a5 = new A5Enc(); int[] frame = new int[1]; bool[] resbits = new bool[msg.Count]; int framesCount = msg.Length / 228; if ((msgbits.Length % 228) != 0) framesCount++; for (int i = 0; i < framesCount; i++) { frame[0] = i; a5.KeySetup(key, frame); bool[] KeyStream = a5.A5(true); for (int j = 0; j < 228; j++) { resbits[i * 228 + j] = msgbits[i * 228 + j] ^ KeyStream[j]; } } return a5.FromBoolToByte(resbits, false); }

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

भाग 3: A5 / 1 एल्गोरिथ्म पर हमला

हालांकि, हमारे पास इंद्रधनुष तालिकाओं की गणना करने के लिए आवश्यक विशाल संसाधन नहीं हैं, इसलिए हम तथाकथित से संबंधित एक आसान हमले को लागू करते हैं। "सहसंबंध हमले।"
हम जिस हमले पर विचार कर रहे हैं, उसका वर्णन पहली बार 2002 में दो शोधकर्ताओं: पैट्रिक एक्दल और थॉमस जोहानसन ने किया था।
आरंभीकरण प्रक्रिया की परिभाषा से, हम यह निष्कर्ष निकाल सकते हैं कि रजिस्टरों की प्रारंभिक स्थिति सत्र कुंजी K और फ्रेम संख्या F _n का एक रैखिक कार्य है।
यह भी जानते हुए कि जनरेटर का आउटपुट बिट सभी तीन रजिस्टरों के XOR-th आउटपुट बिट्स हैं, हम निम्नलिखित समीकरण लिख सकते हैं:

( 1 )

जहाँ _मैं कुंजी K के बिट्स को लोड करने के बाद रजिस्टरों द्वारा उत्पन्न अनुक्रम है। वे _मुझे फ्रेम संख्या के बिट्स और रजिस्टर के x-आउटपुट बिट को लोड करने के बाद अनुक्रम हैं।

इसके अलावा, आरंभीकरण की परिभाषा से, हम जानते हैं कि पहले 100 चक्रों के लिए एल्गोरिथ्म "निष्क्रिय" काम करता है, अर्थात। कोई आउटपुट बिट नहीं बनाता है, और आउटपुट अनुक्रम का पहला बिट वास्तव में 101 वां उत्पन्न बिट है। इस प्रकार, यदि हम यह ध्यान रखें कि प्रत्येक चरण में प्रत्येक रजिस्टर के लिए एक बदलाव की संभावना 3/4 है, तो हम मान सकते हैं कि 101 चरणों के बाद, प्रत्येक रजिस्टर को बिल्कुल 76 बार स्थानांतरित किया गया था। इसलिए, सूत्र (1) में परिवर्तित किया जाता है:

( २ )

(2) के दाईं ओर के रूप में चिह्नित करना

हम सूत्र को फिर से लिखते हैं:

( ३ )

क्योंकि हम (3) के दाईं ओर की अभिव्यक्ति जानते हैं, हमें कुंजी अनुक्रम एस के बारे में 1 बिट जानकारी मिलती है, अर्थात् आरंभीकरण के बाद प्रत्येक रजिस्टर की 76 वीं स्थिति के बारे में। इस तरह से कार्य करते हुए, हम मान सकते हैं कि स्थिति 102 आर 1 भी 76 की स्थिति पर है, और रजिस्टरों आर 2 और आर 3 77 की स्थिति में चले गए, इस प्रकार हमें रजिस्टर के 77 वें स्थान के बारे में जानकारी मिलती है, आदि। कुल मिलाकर, हमें प्रारंभिक अवस्था को सफलतापूर्वक बहाल करने के लिए 64 बिट्स खोलने की आवश्यकता है।

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

उस विशिष्ट स्थिति का अनुमान लगाने की आवश्यकता नहीं है जिसमें रजिस्टरों को घुमाया जाता है (सीएल ₁ , सीएल ₂ , सीएल ₃ ) बार। बस यह जानना पर्याप्त है कि उच्च स्तर की संभावना के साथ प्रत्येक रजिस्टर प्रत्येक फ्रेम के आउटपुट बिट्स के अंतराल I = [100,140] पर 76 से 102 हो जाएगा।
इस प्रकार, प्रत्येक फ्रेम के लिए, हम संभावना की गणना कर सकते हैं:

कैसे

( ४ )

जहाँ

और इस संभावना को दर्शाता है कि रजिस्टरों (cl1, cl2, cl3) के पदों के द्वारा t-th बिट उत्पन्न किया गया था।

प्रत्येक उपलब्ध फ्रेम के लिए गणना करने के बाद, हम लघुगणक का उपयोग करके प्राप्त संभावनाओं को औसत करते हैं:

(5)।

यदि (5)> 0, तो s ₁ (cl1) cls ₂ (cl2) 3s ₃ (cl3) = 0, अन्यथा s ₁ (cl1) (s ₂ (cl2) (s ₃ (cl3) - 1 ।

हम पूरी तरह से एक एल्गोरिथ्म के रूप में हमले का वर्णन करते हैं:

अंतराल सी चुनें। उदाहरण के लिए, C = [79.86]
चर सी ₁ , सीएल ₂ , सीएल ₃ को अंतराल सी से सभी मानों के माध्यम से चलाएं, प्रत्येक फ्रेम के लिए हम गणना करते हैं (4)
सभी प्राप्त मूल्यों के लिए, हम गणना करते हैं (5)
Δ के मूल्य के आधार पर, हम s ₁ (cl1) cls ₂ (cl2) )s ₃ (cl3) का चयन करते हैं

इस एल्गोरिथ्म का परिणाम फॉर्म ₁ (79) ⊕ ₂ (79) =s ₃ (79) = 0 के 8 समीकरण होंगे, जिसमें 8 अज्ञात शामिल होंगे। सरल गणन द्वारा समीकरणों की इस प्रणाली को हल करते हुए, हमें प्रत्येक रजिस्टर के प्रारंभिक मूल्य के 8 बिट मिलते हैं।
अंतराल के लिए एल्गोरिथ्म को दो बार दोहराते हुए [87, 94] और [95, 102] हम रजिस्टरों में से प्रत्येक की प्रारंभिक अवस्था के 24 बिट्स प्राप्त करते हैं। यह हमारे लिए पर्याप्त से अधिक है। 101 बार वापस रजिस्टर में से प्रत्येक को स्क्रॉल करना, हम रजिस्टर की स्थिति को ठीक से प्राप्त करते हैं जो दूसरे इनिशियलाइज़ेशन चरण के बाद था, अर्थात। रजिस्टरों में प्रमुख बिट्स को लोड करने के बाद। और अब हम संपूर्ण कुंजी अनुक्रम को एक पूरे के रूप में उत्पन्न कर सकते हैं।

C # वर्ग A5attack

 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Collections; namespace A5project { class A5attack { private double[] factorials = new double[150]; // Pr(cl1,cl2,cl3   v) private double PinVth(int cl1, int cl2, int cl3, int v) { double y=0; double x = 0; double z = 0; double w = 0; if((v - (v - cl1) - (v - cl2) - (v - cl3))>=0) y=factorials[v - (v - cl1) - (v - cl2) - (v - cl3)]; else y=1; if ((v - cl1) >= 0) x = factorials[v - cl1]; else x = 1; if ((v - cl3) >= 0) z = factorials[v - cl3]; else z = 1; if ((v - cl2) >= 0) w = factorials[v - cl2]; else w = 1; double a = factorials[v] / (x * factorials[v - (v - cl1)]); double b = factorials[v - (v - cl1)] / (w * factorials[v - (v - cl1) - (v - cl2)]); double c = factorials[v - (v - cl1) - (v - cl2)] / (z * y); double d = Math.Pow(4, v); return (a * b * c) / d; } private double factorial(int x) { double result=1; for (int i = x; i > 1; i--) result = result * i; return result; } private bool[] reg = new bool[19]; private bool[] reg2 = new bool[22]; private bool[] reg3 = new bool[23]; // ,         public void KeySetup(int[] frame) { for (int i = 0; i < 19; i++) reg[i] = false; for (int i = 0; i < 22; i++) reg2[i] = false; for (int i = 0; i < 23; i++) reg3[i] = false; BitArray FrameBits = new BitArray(frame); for (int i = 0; i < 22; i++) { clockall(); reg[0] = reg[0] ^ FrameBits[i]; reg2[0] = reg2[0] ^ FrameBits[i]; reg3[0] = reg3[0] ^ FrameBits[i]; } } //     private void clock() { bool majority = ((reg[8] & reg2[10]) | (reg[8] & reg3[10]) | (reg2[10] & reg3[10])); if (reg[8] == majority) clockone(reg); if (reg2[10] == majority) clocktwo(reg2); if (reg3[10] == majority) clockthree(reg3); } private bool[] clockone(bool[] RegOne) { bool temp = false; for (int i = RegOne.Length - 1; i > 0; i--) { if (i == RegOne.Length - 1) temp = RegOne[13] ^ RegOne[16] ^ RegOne[17] ^ RegOne[18]; RegOne[i] = RegOne[i - 1]; if (i == 1) RegOne[0] = temp; } return RegOne; } private bool[] clocktwo(bool[] RegTwo) { bool temp = false; for (int i = RegTwo.Length - 1; i > 0; i--) { if (i == RegTwo.Length - 1) temp = RegTwo[20] ^ RegTwo[21]; RegTwo[i] = RegTwo[i - 1]; if (i == 1) RegTwo[0] = temp; } return RegTwo; } private bool[] clockthree(bool[] RegThree) { bool temp = false; for (int i = RegThree.Length - 1; i > 0; i--) { if (i == RegThree.Length - 1) temp = RegThree[7] ^ RegThree[20] ^ RegThree[21] ^ RegThree[22]; RegThree[i] = RegThree[i - 1]; if (i == 1) RegThree[0] = temp; } return RegThree; } private void clockall() { reg = clockone(reg); reg2 = clocktwo(reg2); reg3 = clockthree(reg3); } //  ,      cl1, cl2  cl3 public bool Oj(int cl1,int cl2, int cl3) { for (int i = 0; i < cl1; i++) { clockone(reg); } for (int i = 0; i < cl2; i++) { clocktwo(reg2); } for (int i = 0; i < cl3; i++) { clockthree(reg3); } return (reg[18] ^ reg2[21] ^ reg3[22]); } // ,     XOR      public double Pj(int cl1, int cl2, int cl3, int j, bool[] frame) { double result = 0; double rightPart = 0; int[] framenumb=new int[1]{j}; KeySetup(framenumb); bool[] tempReg = new bool[19]; bool[] tempReg2 = new bool[22]; bool[] tempReg3 = new bool[23]; Array.Copy(reg, tempReg, 19); Array.Copy(reg2, tempReg2, 22); Array.Copy(reg3, tempReg3, 23); bool FramesBit = Oj(cl1, cl2, cl3); for (int i = 100; i < 100 + 50; i++) { Array.Copy(tempReg, reg, 19); Array.Copy(tempReg2, reg2, 22); Array.Copy(tempReg3, reg3, 23); double temp = PinVth(cl1, cl2, cl3, i); rightPart += temp; if((FramesBit^frame[i-100])==false) temp=temp*1; else temp=0; result += temp; } result = result + ((1 - rightPart) / 2); return result; } //  ,   cl1, cl2, cl3    0.  >0     0 //  ,  1 public double LikehoodRatio(int cl1, int cl2, int cl3, bool[] keystream) { double result = 0; for (int i = 0; i < keystream.Length/228; i++) { bool[] temp=new bool[228]; Array.Copy(keystream,i*228,temp,0,228); double x=Pj(cl1, cl2, cl3, i, temp); result = result + Math.Log(( x/ (1 - x))); } return result; } public bool FindKeyBit(int cl1, int cl2, int cl3, bool[] keystream) { for (int i = 0; i < 150; i++) factorials[i] = factorial(i); if (LikehoodRatio(cl1, cl2, cl3, keystream) >= 0) return false; else return true; } //         public bool[][] checkSol(byte[] first, byte[] second, byte[] third) { byte[] newFirst = new byte[3]; newFirst[0] = first[0]; newFirst[1] = second[0]; newFirst[2] = third[0]; byte[] newSecond = new byte[3]; newSecond[0] = first[1]; newSecond[1] = second[1]; newSecond[2] = third[1]; byte[] newThird = new byte[3]; newThird[0] = first[2]; newThird[1] = second[2]; newThird[2] = third[2]; bool[] firstArr1 = new BitArray(newFirst).Cast<bool>().ToArray().Reverse().ToArray(); bool[] firstArr = new bool[19]; Array.Copy(firstArr1, 5, firstArr, 0, 19); bool[] secondArr1 = new BitArray(newSecond).Cast<bool>().ToArray().Reverse().ToArray(); bool[] secondArr = new bool[22]; Array.Copy(secondArr1, 2, secondArr, 0, 22); bool[] thirdArr1 = new BitArray(newThird).Cast<bool>().ToArray().Reverse().ToArray(); bool[] thirdArr = new bool[23]; Array.Copy(thirdArr1, 1, thirdArr, 0, 23); for (int i = 0; i < 101; i++) { BackClockone(firstArr); } for (int i = 0; i < 101; i++) { BackClocktwo(secondArr); } for (int i = 0; i < 101; i++) { BackClockthree(thirdArr); } bool[][] result = new bool[3][]; result[0] = firstArr; result[1] = secondArr; result[2] = thirdArr; return result; } private void BackClockone(bool[] RegOne) { bool temp = false; for (int i = 0; i < RegOne.Length-1; i++) { if (i == 0) temp = RegOne[0]; RegOne[i] = RegOne[i+1]; if (i == (RegOne.Length-2)) RegOne[RegOne.Length - 1] = temp ^ RegOne[13] ^ RegOne[16] ^ RegOne[17]; } } private void BackClocktwo(bool[] RegTwo) { bool temp = false; for (int i = 0; i < RegTwo.Length-1; i++) { if (i == 0) temp = RegTwo[0]; RegTwo[i] = RegTwo[i + 1]; if (i == (RegTwo.Length-2)) RegTwo[RegTwo.Length - 1] = temp ^ RegTwo[20]; } } private void BackClockthree(bool[] RegThree) { bool temp = false; for (int i = 0; i < RegThree.Length-1; i++) { if (i == 0) temp = RegThree[0]; RegThree[i] = RegThree[i + 1]; if (i == (RegThree.Length-2)) RegThree[RegThree.Length - 1] = temp ^ RegThree[7] ^ RegThree[20] ^ RegThree[21]; } } } }

निम्न प्रकार से FindKeyBit फ़ंक्शन का उपयोग करना:

 private bool[] attack() { bool[] keypart=new bool[512]; int count = 0; A5attack tryattack = new A5attack(); for(int i=79; i<87;i++) for(int j=79; j<87; j++) for (int k = 79; k < 87; k++) { bool temp=tryattack.FindKeyBit(i, j, k, keystream); int time = finish - start; keypart[count] = temp; count++; } return keypart; }

हमें 512 मानों की एक सरणी मिलती है जिसमें XOR कुंजी बिट्स स्थिति 79 से स्थिति 86 तक लिखी गई है।

प्रत्येक रजिस्टर से सभी 24 बिट प्राप्त करने, और उन्हें बाइट सरणियों में अनुवाद करने के बाद, हम अपने समाधान की जांच करते हैं:

 Private void checkSolution() { A5attack LetsAttack = new A5attack(); int[] testframe = new int[1] { 0 }; bool[][] startState = LetsAttack.checkSol(first, second, third); A5Enc a5check = new A5Enc(startState); bool[] TempFrame = new bool[228]; a5check.KeySetup(testframe); TempFrame = a5check.A5(true); for (int l = 0; l < 228; l++) { find = true; if (keystream[l] != TempFrame[l]) { find = false; break; } } }

यदि प्राप्त फ्रेम ज्ञात कुंजी स्ट्रीम के पहले फ्रेम से मेल खाता है, तो हमला सफल रहा और हमने एल्गोरिदम ए 5/1 की सत्र कुंजी को खोला।

भाग 4: अंतिम

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

साहित्य और संदर्भ

मार्सिन ओलावस्की। "जीएसएम नेटवर्क में सुरक्षा।"
पैट्रिक एकडल और थॉमस जोहानसन। "A5 / 1. पर एक और हमला"
कार्स्टेन नोहल। "फोन गोपनीयता पर हमला।"
मार्क ब्रिकेनो, इयान गोल्डबर्ग और डेविड वैगनर। A5 / 1 का एक शैक्षणिक कार्यान्वयन।

पुनश्च: लेखक कृतज्ञ होगा यदि कोई बर्कान, एलाड के काम को साझा करेगा; एली बिहाम (2005)। "सशर्त अनुमानक: A5 / 1. पर एक प्रभावी हमला" यह उस हमले का वर्णन करता है जिसका मैंने अंतिम भाग में उल्लेख किया था।
UPD: उपयोगकर्ता श्वेतार्क के लिए सभी प्रश्न हटा दिए जाते हैं।

जीएसएम नेटवर्क सुरक्षा: डेटा एन्क्रिप्शन

भाग 1: जीएसएम सुरक्षा हाइलाइट्स

भाग 2: A5 / 1 एन्क्रिप्शन एल्गोरिथ्म

भाग 3: A5 / 1 एल्गोरिथ्म पर हमला

भाग 4: अंतिम

साहित्य और संदर्भ

More articles: