एन्क्रिप्शन और एन्क्रिप्शन? हैश मान क्या है, हैश एन्क्रिप्शन क्या है, और हैश डिक्रिप्शन क्या है?

हैश बनाम एन्क्रिप्शन

एक आम गलत धारणा है कि हैश और एन्क्रिप्शन एक ही चीज हैं । वे नहीं हैं । हैश अपरिवर्तनीय है । उदाहरण के तौर पर निम्नलिखित उदाहरण लें:

$ इको -n पासवर्ड123 | md5sum
42f749ade7f9e195bf475f37a44cafcb -

हम स्ट्रिंग "पासवर्ड123" को पास करते हैं MD5 एल्गोरिदम (एल्गो), जो गणितीय संचालन करता है और उत्पन्न हेक्साडेसिमल एन्कोडेड हैश लौटाता है । एक ही हैश आउटपुट मान प्राप्त करने का एकमात्र तरीका एल्गो मूल इनपुट है । संघर्ष है, लेकिन हम बाद में चर्चा कर सकते हैं ।

अधिकांश हैश एल्गोरिदम का आउटपुट हेक्साडेसिमल एन्कोडेड फिक्स्ड-लेंथ बाइनरी स्ट्रिंग है । अन्य, इस उदाहरण की तरह, आउटपुट के रूप में base64-एन्कोडेड स्ट्रिंग का उपयोग करते हैं । ध्यान दें कि लंबाई हमेशा समान होती है:

{SHA} uNF8eZRJ8jmr8WTjyocRJPVpe7w=
{SHA}lqdu/Zr6o2dgIER8Up1/7lcUtgw=
{SHA}qYUOwLMlDEuukA5HCT4LR1kQzco=
{SHA}MXZBCpyWJ7TTs1w2kgGJslwNwTg=
{SHA}2sAPLaUh9Mz0bI+XxKEg7qyABe8=

TL; पीएच.डी.

एन्क्रिप्शन प्रतिवर्ती है, हैश नहीं है

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

foobar             | U2FsdGVkX19G+KtytNHdj6yH2AVvX26pEmtunS/PRnU= 
foobarfoobar       | U2FsdGVkX18sPpIvN6nVh68lOUCcb3gR2fKbCCnBxog= 
foobarfoobarfoobar | U2FsdGVkX1/EOnUt57TCW4Rh0EdNnWX+lDatuQv2xEXXeAeowW0XG/EXJUe9aSUz 

$ cat एन्क्रिप्टेड_पासवर्ड 
U2FsdGVkX19G+KtytNHdj6yH2AVvX26pEmtunS/PRnU= 
U2FsdGVkX18sPpIvN6nVh68lOUCcb3gR2fKbCCnBxog= 
U2FsdGVkX1/EOnUt57TCW4Rh0EdNnWX+lDatuQv2xEXXeAeowW0XG/EXJUe9aSUz 

$ for i in `cat encrypted_passwords`;  do echo $i | openssl enc -base64 -d -aes-256-cbc -पास पास: एएसडीएफ;  गूंज;  हो गया 
फ़ूबार 
foobarfoobar 
अब आप सोच सकते हैं: आप सही हो सकते हैं । हालाँकि, महत्वपूर्ण सामग्री को सिस्टम एक्सेस के लिए सुलभ होना चाहिए जिसका अर्थ है कि अनिवार्य रूप से एक सादा पाठ मास्टर पासवर्ड कहीं स्थित है - चाहे वह आरएसए कुंजी या पासवर्ड के रूप में हो या फ़ाइल में, डेटाबेस में एम्बेडेड, एप्लिकेशन में हार्ड-कोडेड या मेमोरी में कहीं स्थान पर पासवर्ड । pfft, कोई भी अपने उपयोगकर्ताओं को एन्क्रिप्ट करने के लिए कुंजी के रूप में asdf का उपयोग नहीं करेगा ' पासवर्ड 
 
 MD5 के लिए एक ही स्ट्रिंग का उपयोग करें: 
foobar             | 3858f62230ac3c915f300c664312c63f 
foobarfoobar       | 59faa421729e846dd800dce59943bfc0 
foobarfoobarfoobar | 1352aadab322d1a033c27964be0965db
हैश पासवर्ड पूर्णता से बहुत दूर है, वास्तव में यह थोड़ा बुरा है, लेकिन यह एन्क्रिप्शन से भी बदतर है क्योंकि यह क्या प्राप्त करने की कोशिश करता है । उपयोगकर्ता not की तुलना में अधिक बार पूर्ण न्यूनतम आवश्यकताओं का चयन करते हैं, और इसे कई साइटों पर भी उपयोग किया जा सकता है । कई "हैक" वास्तव में क्रेडेंशियल पुन: उपयोग हमलों से ज्यादा कुछ नहीं हैं । यदि प्रारंभिक समझौता एन्क्रिप्शन का उपयोग करना है, तो हमलावर को केवल एक ही प्रयास करना होगा जो सभी पासवर्ड को डिक्रिप्ट करने वाली कुंजी ढूंढना है । हैश के लिए, उन्हें कम से कम प्रयास करने की आवश्यकता है उन्हें क्रैक करने के लिए । जब आधुनिक एल्गोरिदम जैसे sha512crypt, bcrypt, scrypt या argon2 के साथ उपयोग किया जाता है, तो हैश को क्रैक करने के लिए बहुत प्रयास की आवश्यकता हो सकती है । 
 
 
 
 
 
 नमक 
 
 हैश करने से पहले पासवर्ड में एक स्ट्रिंग जोड़ना है । प्रत्येक हैश का नमक अद्वितीय होना चाहिए, आमतौर पर बेतरतीब ढंग से चुना जाता है, क्योंकि ध्यान एक ही सादा पाठ बनाने के लिए है "पासवर्ड" हैश मान हर बार अलग-अलग मान होते हैं । यह पासवर्ड क्रैकरों के लिए जीवन को कठिन बना देता है, क्योंकि के लिए 1,000 उपयोगकर्ताओं में से प्रत्येक के लिए "पासवर्ड" शब्द की जांच करें, प्रत्येक उपयोगकर्ता के पास एक अद्वितीय नमक है, और उन्हें ऐसा करना होगा 1,000 बार काम करें - प्रति उपयोगकर्ता / नमक एक बार । इसका मतलब यह भी है कि वे पूर्व-संकलित शब्दकोशों या इंद्रधनुष तालिकाओं (आमतौर पर ...) का प्रभावी ढंग से उपयोग नहीं कर सकते हैं क्योंकि उन्हें प्रति नमक एक कस्टम की आवश्यकता होती है । 
वेबसाइट कभी-कभी इसे गड़बड़ करती है और सभी उपयोगकर्ताओं के लिए सार्वभौमिक नमक का उपयोग करती है; यह उद्देश्य के खिलाफ है । 
निम्नलिखित नमकीन SHA1 हैश मान हैं: 

b353977827f67a4ae0318f3a9447fae1c13d9d90:b8d18ca 
|___________________________________________| 
                  हैश                  |  नमक 
                                        | 
                                    विभाजक
 इस हैश का सादा पाठ "पासवर्ड" है । इसका नमक मान "b8d18ca" है और SHA1 ($salt.$pass) के एपीआई का उपयोग करता है । इसका मतलब है कि एल्गोरिदम पासवर्ड का सादा पाठ प्राप्त करता है, नमक उत्पन्न करता है, और इसे सादा पाठ के सामने जोड़ता है । जब कोई वेबसाइट या एप्लिकेशन आपके पासवर्ड को सत्यापित करने का प्रयास करता है, तो भविष्य में, यह आपके प्लेनटेक्स्ट पासवर्ड को इनपुट के रूप में लेगा, संग्रहीत हैश में नमक मान को पढ़ेगा, इसे आपके द्वारा चुने गए पासवर्ड के सामने जोड़ेगा, और परिणामी हैश मान की तुलना संग्रहीत हैश मान के साथ करेगा । क्रैकिंग यदि आप नहीं जानते कि इसका एक हिस्सा नमक है, तो हैश निम्नलिखित सादा पाठ उत्पन्न करेगा: 
b8d18capassword

 चूंकि एल्गोरिदम सादा पाठ इनपुट बनाता है, नमक और उत्पन्न हैश मान उपयोगकर्ता के लिए पारदर्शी रह सकते हैं । क्रैकिंग के दौरान, यदि एल्गोरिथ्म नमक है, तो हमें नमक को जानने की आवश्यकता है ताकि हम इसे प्रदान कर सकें जब उम्मीदवार प्लेनटेक्स्ट उत्पन्न होता है । यदि ठीक से लागू किया जाता है, तो नमकीनता क्रैकिंग को अधिक समय लेने वाला बना सकती है । यादृच्छिक नमक के साथ, आप क्रैकर को नमक के बेमेल हैश को क्रैक करने की कोशिश में समय बर्बाद करने के लिए मजबूर करते हैं । यह मोटे तौर पर device_speed / number_of_salts के लिए आवश्यक प्रयास को पूरा करता है क्योंकि हमें एक उम्मीदवार उत्पन्न करने की आवश्यकता है प्रत्येक नमक के लिए । यदि नमक स्थिर है, तो गणितीय संचालन समान है...स्पीड_ऑफ_डिवाइस / 1. इसे देखने का एक और तरीका यह: 
हमारा GTX 980 दरारें SHA1($salt.$pass) at 3576.8 MH/s or 3.5 बिलियन उम्मीदवार प्रति सेकंड 
हमारी  हैशलिस्ट   में   1000   अद्वितीय   लवण शामिल हैं 

3,500,000,000 / 1000 = 3,500,000 उम्मीदवार प्रति सेकंड
यह परिमाण के तीन क्रम धीमा है, 99.9% का नुकसान । स्थिर नमक का उपयोग करते समय, यह इस तरह दिखता है: 
हमारे GTX 980 दरारें SHA1($salt.$pass) पर 3576.8 एमएच/एस या 3.5 अरब उम्मीदवार प्रति सेकंड 
हमारी  हैशलिस्ट   में  1  अद्वितीय  नमक शामिल है 
               
3,500,000,000 / 1 = 3,500,000,000 उम्मीदवार प्रति सेकंड
यदि इसका कोई मतलब नहीं है, तो पढ़ें और हमारे पास एक सुंदर चार्ट होगा बाद में... 

 पुनरावृत्ति 
 बस "इस सादे पाठ को हैश करें" की तुलना में एक और सामान्य सुधार यह है कि "इस सादे पाठ को हैश करें, फिर उस परिणाम को हैश करें, फिर उस परिणाम को हैश करें" हजारों बार दोहराया जाता है । यह एक ही उम्मीदवार पासवर्ड की कोशिश करते समय पासवर्ड क्रैकर को हजारों बार करना पड़ता है । इसे पुनरावृत्ति, लूप या परिवर्तनीय लागत कहा जाता है । कुछ पासवर्ड हैशिंग एल्गोरिदम हार्ड-कोडेड पुनरावृत्ति राउंड का उपयोग करते हैं; अन्य Git. इसे हैश के एक हिस्से में ही कॉन्फ़िगर करने योग्य बनाता है । उदाहरण के लिए, md5crypt() MD5 का उपयोग करता है, जिसमें salt भी शामिल है, और ठीक 1000 बार लूप करता है । sha512crypt() sha512 का उपयोग करता है, जिसमें एक नमक शामिल है, और कॉन्फ़िगर करने योग्य बार (डिफ़ॉल्ट 5,000) लूप करता है । 
 पुनरावृत्ति मुख्य रूप से हैश एल्गोरिदम की कम्प्यूटेशनल चक्र लागत को प्रभावित करती है, न कि इसकी मेमोरी उपयोग या अन्य कारकों को । ये भी महत्वपूर्ण हैं जब कुछ प्रकार के हैश प्रकारों का विरोध करने के लिए अनुकूलित डिज़ाइन किए जाते हैं, लेकिन यह यहां चर्चा करने के लिए बहुत खरपतवार है । 

क्रैकिंग गति पर हैश प्रकार का प्रभाव
आइए हैश एल्गोरिदम चयन के प्रभाव को प्रदर्शित करने के लिए कुछ उदाहरण देखें, चाहे वह नमकीन हो, कई पुनरावृत्तियों का उपयोग करें, आदि । मान लीजिए कि हमलावर 1,000 उपयोगकर्ताओं के हैश मान एकत्र करता है कुछ संक्रमित वेबसाइट से, वे केवल एक साधारण हमला करना चाहते हैं, प्रत्येक पासवर्ड का परीक्षण करते हैं हैश - 143 मिलियन उम्मीदवार पासवर्ड । 
 
 संक्रमित वेबसाइट द्वारा उपयोग किए जाने वाले हैश के प्रकार का उस हमले के माध्यम से हमलावर को लगने वाले समय पर भारी प्रभाव पड़ेगा । यह एक चार्ट है कि कितने (सापेक्ष, मोटे तौर पर) हमले को पूरा करने में सेकंड लगते हैं, उपयोग किए गए हैश के प्रकार के आधार पर, जहां मानक ग्राफिक्स: 
 ठीक है, यह काम नहीं करेगा! सबसे मजबूत हैश प्रकार बहुत धीमे होते हैं, लेकिन तेज़ होते हैं । प्रकार केवल कुछ भी नहीं होने तक कुचल दिए जाते हैं । आइए लघुगणकीय एक्स-अक्ष समय का उपयोग करके फिर से उसी डेटा आकार का प्रयास करें । जब बार बाएं से दाएं चलते हैं, तो वे 10 की शक्ति में वृद्धि करेंगे: 
 तो कुछ महत्वपूर्ण बिंदु हैं: जब आप कुछ पासवर्ड हैश को क्रैक करना चाहते हैं, तो एकल दौर मल्टी-राउंड की तुलना में आसान है और नमक जोड़ने की तुलना में कोई नमक नहीं है । इसके विपरीत, जब कुछ कंपनियां या वेबसाइटें उपयोगकर्ता डेटा युक्त डेटा उल्लंघन की घोषणा करती हैं, ए) पासवर्ड को अधिमानतः हैश किया गया है, न कि केवल सादा पाठ; बी) वे सबसे अच्छा नमकीन हैं, न कि सिर्फ हैश; सी) उनके पास बेहतर है हमेशा एक शक्तिशाली बहु-दौर नमकीन हैश का उपयोग कर रहा है, न कि केवल एक दौर । 

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

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