एकाधिक हैश एन्क्रिप्शन

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

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

हैश फ़ंक्शंस के बारे में कई दिलचस्प गलतफहमियाँ हैं:

• हैश फ़ंक्शन को उल्टा करना आसान है। कथित तौर पर, एक निश्चित प्रोग्राम md5decrypt है जो md5crypt के परिणाम को पुनर्स्थापित करता है;
• एमडी 5 जैसे हैश फ़ंक्शन लंबे समय से टूट गए हैं। किसी दिए गए लाइन पर एक टक्कर प्राप्त करें - एक trifling मामला;
• हैश फ़ंक्शन एक एन्क्रिप्शन एल्गोरिथ्म हैं।

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

लेकिन कभी-कभी "बकवास" एक दिलचस्प समाधान का निर्माण करने में मदद कर सकता है, चलो एक दूसरे के लिए यह कल्पना करने की कोशिश करें कि उपरोक्त शोध सत्य हैं। ऐसा भी नहीं है, चलो एक ऑब्जेक्ट बनाते हैं जिसके लिए उन्हें निष्पादित किया जाएगा।

आर (कुंजी, संदेश) = md5 का पहला एन बिट्स (कुंजी + संदेश), जहां एन बहुत बड़ा नहीं है, चलो 40 के बराबर कहते हैं। और यहाँ मज़ा शुरू होता है!

सबसे पहले, किसी दिए गए कुंजी कुंजी के लिए, हम आसानी से बड़ी संख्या में विभिन्न संदेशों का निर्माण कर सकते हैं जो फ़ंक्शन का वांछित मूल्य देते हैं। लगभग 2 ^ 40 विभिन्न लाइनों को सॉर्ट करने के लिए एक नियमित "होम" कंप्यूटर के लिए एक व्यवहार्य कार्य है। यदि हमारे पास X का एक मान दिया गया है, जो फ़ंक्शन R को लागू करने का परिणाम है, तो हम आसानी से उलटा छवि पा सकते हैं।

यही है, X = R ('test_key', 'msg') = 5B7AF38712 चलो
हम 'संदेश' के बारे में भूल जाते हैं, हमारे पास केवल हैश मान 5B7AF38712 और स्रोत कुंजी 'test_key' है, हम खोज शुरू करते हैं, और थोड़ी देर बाद हम पूर्व-छवि के रूप में स्ट्रिंग 'संदेश' प्राप्त करते हैं!

लेकिन क्या होगा अगर हम कुंजी ('test_key') नहीं जानते हैं, लेकिन केवल हैश मान जानते हैं? तब हम अपने एक्स मान देने वाले अनंत -संदेश जोड़े का निर्माण कर सकते हैं।

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

ऐसा क्यों? सिर्फ इसलिए कि इनपुट मानों (यानी कुंजियों और संदेशों) का सेट अनंत है, और फ़ंक्शन R में संभावित मानों की एक सीमित संख्या है, जिनमें से प्रत्येक (बहुत मोटे तौर पर बोलने) में घटना होने की समान संभावना है।

अब, मुझे लगता है कि प्रक्रिया का विचार स्पष्ट है - किसी व्यक्ति को '5B7AF38712' भेजना, कुंजी ('test_key') को जानना, वह सबसे अधिक संदेश प्राप्त करेगा ('संदेश') (लेकिन इसके लिए कोई गारंटी नहीं है, यह ध्यान दिया जाना चाहिए)। और, न जाने, - कोई कचरा।

जादू

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

यही है, इनपुट पर: key1, message1 और key2, message2।
इसके अलावा, क्रिप्ट (की 1, मैसेज 1, की 2, मेसेज 2) = एक्स,
और डिक्रिप्ट (एक्स, की 1) = संदेश 1, और डिक्रिप्ट (एक्स, की 2) = संदेश 2।

यहां हमें फ़ंक्शन R को "आधुनिकीकरण" करना है, हम कार्यों का एक पूरा सेट बनाएंगे:
R _m (की, msg) = md5 के पहले N बिट्स (की + लाइन (m) + msg),
जहां स्ट्रिंग (एम) स्ट्रिंग के रूप में मीटर का कोई अनूठा प्रतिनिधित्व है (उदाहरण के लिए, दशमलव संकेतन)।

इंडेक्स एम एक विशेष "नियंत्रण मूल्य" है जो संदेशों को एन्क्रिप्ट करते समय हम अलग-अलग होंगे (अर्थात, यह हमारे एल्गोरिथ्म द्वारा चुना गया है)।

यह कैसे चुना जाता है यह बताने से पहले, मैं एक डिक्रिप्शन प्रक्रिया की पेशकश करूंगा, क्योंकि यह काफी सरल है:
डिक्रिप्ट (एक्स, की) = संदेश का मूल्य, जैसे कि आर (कुंजी, संदेश) == एक्स, सबसे छोटी मी के साथ।

पुनरावृत्त रूप में, आप इसे लिख सकते हैं (छद्मकोश):

string decrypt(X, key) { for (int m = 0; m < MAX_INT; m++) for (string msg in generate_all_strings(MAX_STRING_LENGTH) ) if (first_N_bytes( md5( key + m.ToString() + msg) ) == X) // R() return msg; } 

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

पहले 40 बिट्स के लिए टक्कर प्राप्त करना मुश्किल नहीं है, और यह फ़ंक्शन मान वापस करने के लिए गारंटी है। "एन्क्रिप्शन" फ़ंक्शन का कार्य वांछित मूल्य की वापसी सुनिश्चित करना है।

लेकिन यह भी क्रूर बल द्वारा किया जा सकता है:

 string encrypt(key, msg) { for (int m = 0; m < MAX_INT; m++) { string X = first_N_bytes( md5( key + m.ToString() + msg) ); // R() if (decrypt(X, key) == msg) return X; } } 

इस प्रकार, हम विभिन्न मापदंडों के साथ मॉडलिंग करके सही डिकोडिंग में विश्वास प्रदान करते हैं। यदि डिक्रिप्शन एल्गोरिथ्म नहीं बदलता है, तो यह शुद्धता की गारंटी है, और ध्यान दें - कोई चेकसम, सत्यापनकर्ता, अन्य चीजें जो आपको सही डिक्रिप्शन के तथ्य को "बाहर" देने की अनुमति नहीं देती हैं!

प्रारंभ में, मैंने एक बार में दो संदेशों को एन्क्रिप्ट करने की संभावना के बारे में बात की, जो वास्तव में अब एक स्व-स्पष्ट तथ्य बन रहा है:

 string encrypt(key, msg, key2, msg2) { for (int m = 0; m < MAX_INT; m++) { string X = first_N_bytes( md5( key + m.ToString() + msg) ); // R() if (decrypt(X, key) == msg && decrypt(X, key2) == msg2) return X; } } 

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

सामान्य तौर पर, प्रोटोटाइप को लागू करते समय, मैं डबल-बाइट ट्रंकेशन पर बस गया। इसके अलावा, प्रदर्शन के मुद्दे को आंशिक रूप से हल करने के लिए (मैंने जल्दी से सी # में प्रोटोटाइप को स्केच किया, और "स्थानीय" क्रिप्टोग्राफी प्रदाता बस बहुत धीमे हैं! जीपीयू पर कार्यान्वयन की तुलना में लगभग 50,000 गुना धीमा है, जिसे मैं थोड़ी देर बाद निष्पादित करने की कोशिश करूंगा) मैंने केवल अक्षरों का उपयोग करने का विकल्प छोड़ दिया! रेंज az ऐसे "उदास" रूप में, यह पहले से ही काम करता है। हम दो कुंजी-मूल्य जोड़े दर्ज करते हैं, "Encrypt2" पर क्लिक करें और थोड़ी देर बाद हैश कोड प्राप्त करें। पहली कुंजी के साथ, यह पहले संदेश में जल्दी से डिक्रिप्ट करता है:


दूसरे के साथ, क्रमशः दूसरे में:


उसी एन्क्रिप्टेड पाठ को नोट करें। ठीक है, गलत कुंजी के साथ - एक अजीब संदेश में (लेकिन गारंटी कहां है कि यह मूल नहीं था?)।


आप यहां से प्रोटोटाइप डाउनलोड कर सकते हैं: dl.dropbox.com/u/243445/md5h/HashCode.7A

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