ठीक है, आप इसे विकिपीडिया में देख सकते हैं ... लेकिन जब से आप एक स्पष्टीकरण चाहते हैं, मैं यहाँ अपना सर्वश्रेष्ठ प्रदर्शन करूँगा:
हैश फंक्शंस
वे एक मनमाना लंबाई इनपुट और (आमतौर पर) निश्चित लंबाई (या छोटी लंबाई) आउटपुट के बीच एक मानचित्रण प्रदान करते हैं। यह एक साधारण crc32, एमडी 5 या SHA1 / 2/256/512 जैसे पूर्ण विकसित क्रिप्टोग्राफिक हैश फ़ंक्शन से कुछ भी हो सकता है। मुद्दा यह है कि वहाँ एक तरह से मानचित्रण चल रहा है। यह हमेशा एक बहुत है: 1 मानचित्रण (मतलब हमेशा टकराव होगा) चूंकि प्रत्येक फ़ंक्शन इनपुट करने में सक्षम होने की तुलना में एक छोटा आउटपुट पैदा करता है (यदि आप एमडी 5 में हर संभव 1mb फ़ाइल फ़ीड करते हैं, तो आपको एक टन टकराव मिलेगा)।
इसका कारण यह है कि वे व्यावहारिक रूप से कठिन (या व्यावहारिकता में असंभव) हैं क्योंकि वे आंतरिक रूप से कैसे काम करते हैं। अधिकांश क्रिप्टोग्राफ़िक हैश आउटपुट के उत्पादन के लिए इनपुट सेट पर कई बार कार्य करता है। इसलिए यदि हम इनपुट की प्रत्येक निश्चित लंबाई के टुकड़े (जो एल्गोरिथ्म पर निर्भर है) को देखते हैं, हैश फ़ंक्शन वर्तमान स्थिति को कॉल करेगा। फिर यह राज्य पर पुनरावृत्ति करेगा और इसे एक नए में बदल देगा और उस फीडबैक को स्वयं के रूप में उपयोग कर सकता है (MD5 प्रत्येक 512bit डेटा के लिए 64 बार करता है)। फिर यह किसी भी तरह परिणामी अवस्थाओं को जोड़कर इन सभी पुनरावृत्तियों को एक साथ परिणामी हैश बनाता है।
अब, यदि आप हैश को डीकोड करना चाहते हैं, तो आपको पहले यह पता लगाना होगा कि दिए गए हैश को इसकी पुनरावृत्त अवस्थाओं में कैसे विभाजित किया जाए (1 इनपुट के आकार की तुलना में छोटे डेटा के आकार की संभावना, बड़े इनपुट के लिए कई)। फिर आपको प्रत्येक राज्य के लिए पुनरावृत्ति को उलटने की आवश्यकता होगी। अब, यह समझाने के लिए कि यह बहुत कठिन है, कल्पना करने की कोशिश करें a
और b
निम्नलिखित सूत्र से कटौती करने की कोशिश करें 10 = a + b
:। के 10 सकारात्मक संयोजन हैं a
और b
यह काम कर सकते हैं। अब उस पर एक बार लूप करें:tmp = a + b; a = b; b = tmp
। 64 पुनरावृत्तियों के लिए, आपके पास प्रयास करने के लिए 10 ^ 64 से अधिक संभावनाएँ होंगी। और यह सिर्फ एक साधारण जोड़ है जहां कुछ राज्य को पुनरावृत्ति से संरक्षित किया जाता है। वास्तविक हैश फ़ंक्शंस 1 से अधिक ऑपरेशन करते हैं (एमडी 5 4 राज्य चर पर लगभग 15 ऑपरेशन करता है)। और चूंकि अगली पुनरावृत्ति पूर्व की स्थिति पर निर्भर करती है और पिछली स्थिति को वर्तमान स्थिति बनाने में नष्ट हो जाती है, यह इनपुट स्थिति को निर्धारित करने के लिए सभी असंभव है, जो एक दिए गए आउटपुट राज्य (प्रत्येक पुनरावृत्ति के लिए कोई कम नहीं) का नेतृत्व करता है। बड़ी संख्या में शामिल होने की संभावनाओं के साथ, और एमडी 5 को भी डीकोड करने से संसाधनों के पास अनंत (लेकिन अनंत नहीं) राशि प्राप्त होगी। इतने संसाधन कि यह '
एन्क्रिप्शन कार्य
वे एक मनमाना लंबाई इनपुट और आउटपुट के बीच 1: 1 मैपिंग प्रदान करते हैं। और वे हमेशा प्रतिवर्ती हैं। ध्यान देने योग्य बात यह है कि यह किसी विधि का उपयोग करके प्रतिवर्ती है। और यह हमेशा दी गई कुंजी के लिए 1: 1 है। अब, कई इनपुट हैं: प्रमुख जोड़े जो समान आउटपुट उत्पन्न कर सकते हैं (वास्तव में एन्क्रिप्शन फ़ंक्शन के आधार पर, आमतौर पर वहां होते हैं)। अच्छा एन्क्रिप्टेड डेटा यादृच्छिक शोर से अप्रभेद्य है। यह एक अच्छे हैश आउटपुट से अलग है जो हमेशा एक सुसंगत प्रारूप का होता है।
बक्सों का इस्तेमाल करें
जब आप किसी मान की तुलना करना चाहते हैं, तो हैश फ़ंक्शन का उपयोग करें, लेकिन सादे प्रतिनिधित्व को संग्रहीत नहीं कर सकता (किसी भी कारण से)। पासवर्ड को इस उपयोग के मामले में बहुत अच्छी तरह से फिट होना चाहिए क्योंकि आप उन्हें सुरक्षा कारणों से सादे-पाठ को संग्रहीत नहीं करना चाहते (और नहीं करना चाहिए)। लेकिन क्या होगा अगर आप पायरेटेड म्यूजिक फाइल्स के लिए फाइलसिस्टम जांचना चाहते हैं? यह 3 एमबी प्रति संगीत फ़ाइल संग्रहीत करने के लिए अव्यावहारिक होगा। इसलिए इसके बजाय, फ़ाइल का हैश लें, और स्टोर करें (md5 3mb के बजाय 16 बाइट्स स्टोर करेगा)। इस तरह, आप बस प्रत्येक फ़ाइल को हैश करते हैं और हैश के संग्रहीत डेटाबेस से तुलना करते हैं (यह री-एन्कोडिंग, फ़ाइल हेडर बदलने आदि के कारण अभ्यास में भी काम नहीं करता है, लेकिन यह एक उदाहरण उपयोग-मामला है)।
जब आप इनपुट डेटा की वैधता की जाँच कर रहे हों तो हैश फ़ंक्शन का उपयोग करें। यही उनके लिए डिज़ाइन किया गया है। यदि आपके पास इनपुट के 2 टुकड़े हैं, और यह देखने के लिए जांचना चाहते हैं कि क्या वे समान हैं, तो हैश फ़ंक्शन के माध्यम से दोनों चलाएं। टक्कर की संभावना छोटे इनपुट आकार (एक अच्छा हैश फ़ंक्शन मानकर) के लिए खगोलीय रूप से कम है। इसलिए यह पासवर्ड के लिए अनुशंसित है। 32 अक्षरों तक के पासवर्ड के लिए, md5 में 4 गुना आउटपुट स्पेस है। SHA1 में 6 गुना आउटपुट स्पेस (लगभग) है। SHA512 में लगभग 16 गुना आउटपुट स्पेस है। आपको वास्तव में परवाह नहीं है कि पासवर्ड क्या था , आप परवाह करते हैं कि यह वही है जो संग्रहीत किया गया था। इसलिए आपको पासवर्ड के लिए हैश का उपयोग करना चाहिए।
जब भी आपको इनपुट डेटा वापस पाने की आवश्यकता हो, एन्क्रिप्शन का उपयोग करें। शब्द की जरूरत पर ध्यान दें । यदि आप क्रेडिट कार्ड नंबर जमा कर रहे हैं, तो आपको उन्हें किसी बिंदु पर वापस लाने की आवश्यकता है, लेकिन उन्हें सादे पाठ को संग्रहीत करने की आवश्यकता नहीं है। इसलिए इसके बजाय, एन्क्रिप्ट किए गए संस्करण को स्टोर करें और कुंजी को यथासंभव सुरक्षित रखें।
डेटा पर हस्ताक्षर करने के लिए हैश फ़ंक्शन भी महान हैं। उदाहरण के लिए, यदि आप HMAC का उपयोग कर रहे हैं, तो आप एक ज्ञात लेकिन प्रेषित मूल्य (एक गुप्त मूल्य) के साथ समाप्त डेटा का एक हैश लेकर डेटा के एक टुकड़े पर हस्ताक्षर करते हैं। तो, आप सादा-पाठ और HMAC हैश भेजें। फिर, रिसीवर केवल प्रस्तुत किए गए डेटा को ज्ञात मूल्य के साथ धोता है और यह देखने के लिए जांचता है कि क्या यह प्रेषित एचएमएसी से मेल खाता है। यदि यह समान है, तो आप जानते हैं कि यह एक पार्टी द्वारा गुप्त मूल्य के बिना छेड़छाड़ नहीं की गई थी। यह आमतौर पर HTTP फ्रेमवर्क द्वारा सुरक्षित कुकी सिस्टम में उपयोग किया जाता है, साथ ही साथ HTTP पर डेटा के संदेश संचरण में जहां आप डेटा में अखंडता का कुछ आश्वासन चाहते हैं।
पासवर्ड के लिए हैश पर एक नोट:
क्रिप्टोग्राफ़िक हैश फ़ंक्शंस की एक प्रमुख विशेषता यह है कि उन्हें बनाने के लिए बहुत तेज़ होना चाहिए, और रिवर्स करने के लिए बहुत मुश्किल / धीमा (इतना है कि यह व्यावहारिक रूप से असंभव है)। इससे पासवर्ड की समस्या हो जाती है। यदि आप स्टोर करते हैं sha512(password)
, तो आप इंद्रधनुष तालिकाओं या जानवर बल के हमलों के खिलाफ रक्षा करने के लिए एक चीज़ नहीं कर रहे हैं। याद रखें, हैश फ़ंक्शन गति के लिए डिज़ाइन किया गया था। तो यह एक हमलावर के लिए केवल हैश फ़ंक्शन के माध्यम से एक शब्दकोश चलाने और प्रत्येक परिणाम का परीक्षण करने के लिए तुच्छ है।
नमक जोड़ने से मामलों में मदद मिलती है क्योंकि यह हैश में कुछ अज्ञात डेटा जोड़ता है। इसलिए जो कुछ भी मेल खाता है md5(foo)
, उसे खोजने के बजाय , उन्हें कुछ ऐसा खोजने की आवश्यकता होती है, जब ज्ञात नमक में मिलाया जाता है md5(foo.salt)
(जो करने के लिए बहुत कठिन है)। लेकिन यह अभी भी गति की समस्या को हल नहीं करता है क्योंकि अगर वे नमक जानते हैं तो यह केवल शब्दकोश चलाने की बात है।
तो, इससे निपटने के तरीके हैं। एक लोकप्रिय विधि को कुंजी को मजबूत करना (या कुंजी खींचना) कहा जाता है । मूल रूप से, आप हैश पर कई बार पुनरावृत्त होते हैं (आमतौर पर हजारों)। यह दो काम करता है। सबसे पहले, यह हैशिंग एल्गोरिथ्म के रनटाइम को काफी धीमा कर देता है। दूसरा, अगर सही लागू किया जाता है (प्रत्येक पुनरावृत्ति पर इनपुट और नमक वापस पारित करना) वास्तव में आउटपुट के लिए एन्ट्रॉपी (उपलब्ध स्थान) को बढ़ाता है, जिससे टकराव की संभावना कम हो जाती है। एक तुच्छ कार्यान्वयन है:
var hash = password + salt;
for (var i = 0; i < 5000; i++) {
hash = sha512(hash + password + salt);
}
पीबीकेडीएफ 2 , बीसीक्रिप्ट जैसे अन्य मानक कार्यान्वयन हैं । लेकिन इस तकनीक का उपयोग सुरक्षा संबंधी कुछ प्रणालियों (जैसे पीजीपी, डब्ल्यूपीए, अपाचे और ओपनएसएसएल) द्वारा किया जाता है।
नीचे की रेखा, hash(password)
पर्याप्त अच्छी नहीं है। hash(password + salt)
बेहतर है, लेकिन अभी भी पर्याप्त नहीं है ... अपने पासवर्ड हैश का उत्पादन करने के लिए एक विस्तारित हैश तंत्र का उपयोग करें ...
तुच्छ खींच पर एक और नोट
किसी भी परिस्थिति में एक हैश के उत्पादन को सीधे हैश फ़ंक्शन में वापस न करें :
hash = sha512(password + salt);
for (i = 0; i < 1000; i++) {
hash = sha512(hash); // <-- Do NOT do this!
}
इसका कारण टक्करों के साथ करना है। याद रखें कि सभी हैश फ़ंक्शंस में टक्कर होती है क्योंकि संभावित आउटपुट स्पेस (संभावित आउटपुट की संख्या) इनपुट स्पेस से छोटा होता है। क्यों देखना है, आइए देखें कि क्या होता है। इसे प्रस्तुत करने के लिए, मान लें कि वहाँ से टकराव की 0.001% संभावना है sha1()
(यह वास्तविकता में बहुत कम है, लेकिन प्रदर्शन उद्देश्यों के लिए)।
hash1 = sha1(password + salt);
अब, hash1
0.001% की टक्कर की संभावना है। लेकिन जब हम अगला करते हैं hash2 = sha1(hash1);
, तो स्वचालित रूप से सभी टकराव की hash1
टक्कर बन जाते हैंhash2
। तो अब, हमारे पास हैश की दर 0.001% है, और दूसरा sha1()
कॉल उसी को जोड़ता है। तो अब, hash2
0.002% के टकराने की संभावना है। कि दो बार के रूप में कई संभावना है! प्रत्येक पुनरावृत्ति 0.001%
परिणाम को टकराने का एक और मौका जोड़ देगा । तो, 1000 पुनरावृत्तियों के साथ, टक्कर का मौका एक मामूली 0.001% से 1% तक उछल गया। अब, गिरावट रैखिक है, और वास्तविक संभावनाएं बहुत छोटी हैं, लेकिन प्रभाव समान है (एकल टकराव की संभावना का एक अनुमान md5
लगभग 1 / (2 128 ) या 1 / (3x10 38) है)। जबकि यह छोटा लगता है, जन्मदिन के हमले के लिए धन्यवाद यह वास्तव में उतना छोटा नहीं है जितना लगता है)।
इसके बजाय, हर बार नमक और पासवर्ड को फिर से जोड़कर, आप डेटा को हैश फ़ंक्शन में वापस ला रहे हैं। इसलिए किसी भी विशेष दौर की कोई भी टक्कर अब अगले दौर की टक्कर नहीं है। इसलिए:
hash = sha512(password + salt);
for (i = 0; i < 1000; i++) {
hash = sha512(hash + password + salt);
}
देशी sha512
समारोह के रूप में टकराव का एक ही मौका है । जो आप चाहते हैं। इसकी जगह इस्तेमाल करें।