पासवर्ड धीमा हैशिंग। क्यों?

शुभ दिन, हब्बरपारनिक! आज हम सुरक्षा बढ़ाने के लिए थोड़े असामान्य तरीके के बारे में बात करेंगे, अर्थात् पासवर्ड हैशिंग को धीमा करना । ऐसा लगता है कि जब हर कोई अनुकूलन करने की कोशिश कर रहा है, तो कुछ धीमा क्यों करें?

कम से कम तब, कि सबसे सुपर-डुपर संरक्षित प्रणाली में भी, सबसे कमजोर लिंक एक व्यक्ति बना हुआ है। अर्थात्, उसका पासवर्ड।



क्या आपने कभी एन्क्रिप्टेड रार आर्काइव को क्रैक करने की कोशिश की है? और प्रति सेकंड कितने पासवर्ड से गुजरा? 50-100-200? यहां तक ​​कि एक अच्छे GPU पर, कुख्यात cRARk का उपयोग करते समय, खोज की गति केवल लगभग 2400 विकल्प / सेकंड होती है। और यह zip / md5 / SHA1 के लिए लाखों पासवर्ड / सेकेंड के दसियों (सैकड़ों) की तुलना में है।



कटौती के तहत, इस प्रक्रिया की मेरी मुक्त व्याख्या।





संपूर्ण क्रिया का अर्थ इस प्रकार है:

• एन्क्रिप्शन कुंजी पासवर्ड से नहीं, बल्कि (धीमी) हैश से महत्वपूर्ण है
• पासवर्ड कैश्ड होने पर उपयोगकर्ता को सेकंड सेकंड के लिए प्रतीक्षा करने की आवश्यकता नहीं है
• लेकिन होमो ब्रूटोर्फस को धैर्य रखना होगा

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



मैं यह नहीं कह रहा हूं कि नमक सिस्टम खराब हैं, उन्हें बस मजबूत किया जा सकता है।



और इसलिए, नमक है, एक पासवर्ड है। आगे क्या है?



और फिर सब कुछ बहुत आसान है:

1. नमक और पासवर्ड को मिलाएं
2. हैश, परिणाम याद है
3. जबकि (कई बार) {
4. गोल नमक उत्पन्न करें
5. इसे और हैश में समेटो
6. कैश, परिणाम याद रखें}

Winrar में (उसके लिए, वैसे, प्रेरणा के लिए), अगर मेरी स्मृति मेरी सेवा करती है, तो गोल नमक पुनरावृत्ति संख्या है। मैं थोड़ा आगे गया।



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



1. मैं 2 हैशिंग एल्गोरिदम (SHA-256 और SHA-512) का उपयोग करता हूं, इसलिए शुरुआत के लिए एक छोटा इंटरफ़ेस है जो हमें इस पूरी चीज़ को कम या ज्यादा सार्वभौमिक बनाने में मदद करेगा।

सार्वजनिक इंटरफ़ेस IDigest

{

सार्वजनिक बाइट [] प्रक्रिया ( बाइट [] डेटा);



सार्वजनिक int getSize ();

}

2. SHA-256 एल्गोरिथ्म के लिए इस इंटरफ़ेस के कार्यान्वयन का एक उदाहरण ( BouncyCastle लाइब्रेरी से SHA256Digest वर्ग का उपयोग करके):

सार्वजनिक वर्ग SHA256 IDigest लागू करता है

{



निजी SHA256Digest m_SHA256 = नया SHA256Digest ();



@Override

सार्वजनिक बाइट [] प्रक्रिया ( बाइट [] डेटा)

{

m_SHA256.reset ();

m_SHA256.update (डेटा, 0, data.length);

बाइट [] परिणाम = नया बाइट [m_SHA256.getDigestSize ()];

m_SHA256.doFinal (परिणाम, 0);

वापसी परिणाम;

}



@Override

सार्वजनिक int getSize ()

{

वापसी m_SHA256.getDigestSize ();

}

}

3. सबसे यम्मी। मैं इसे विस्तार से बताऊंगा।

सार्वजनिक वर्ग SlowHasher

{

निजी अंतिम स्थिर int BITS_IN_BYTE = 8;



निजी स्थिर अंतिम int [] s_primeIndices = नया int [] {7, 11, 17, 23, 31, 41, 47, 53, 61};



/ **

* इस विधि में हर दौर में नमक जोड़ने के लिए 0x50000 बार हैश पासवर्ड है

*

* परम पच

* परम पासवर्ड

* वापसी

* /

पब्लिक बाइट [] कैलक्लोस्हाश (IDigest डाइजेस्ट, स्ट्रिंग पासवर्ड, बाइट [] सॉल्ट)

{

int roundSaltSize = digest.getSize () / BITS_IN_BYTE;

बाइट [] bPasswd = password.getBytes ();

बाइट [] तोश = नई बाइट [bPasswd.length + salt.length];



/ *

* बाइट्स की व्यूह रचना जो हैशेड होगी

* /

System.arraycopy (नमक, 0, toHash, 0, salt.length);

System.arraycopy (bPasswd, 0, toHash, salt.length, bPasswd.bength);



बाइट [] रेस = डाइजेस्ट।प्रोसेस (तोश);

बाइट [] अस्थायी = नई बाइट [res.length + roundSaltSize];



for ( int i = 0; मैं <0x50000; i ++)

{

System.arraycopy (res, 0, temp, 0, res.length);



/ ***

* नमक की गणना

* /

( int j = 0; j <राउंडसाल्टाइज़; j ++)

{

int btmp = res [s_primeIndices [j]] & 0xFF;

( int k = 1; k <bITS_IN_BYTE; k ++) के लिए

{

btmp = ror ((btmp + (Res [ror (btmp, k)% res.length] & 0xFF))% 256, BITS_IN_BYTE-k);

}

अस्थायी [Res.length + j] = ( बाइट ) btmp;

}

res = digest.process (अस्थायी);

}

वापसी Res;

}



/ **

* बाइट के रूप में बिट्स को सही मानते हुए रोटेट करें

* परम मूल्य 0 <= मान <= 255

* बदलाव के लिए बिट्स की संख्या

* वापसी

* /

सार्वजनिक स्थैतिक int रोर ( int value , int n)

{

वापसी (( मूल्य >> (n% BITS_IN_BYTE))) | (( मान << (8 - (n% BITS_IN_BYTE))) & 0xFF);

}

}



जो लोग जावा से परिचित नहीं हैं, वे तुरंत कहेंगे कि आपको कई आवेषण से डरना नहीं चाहिए & 0xFF



। यह केवल हस्ताक्षरित बाइट का एक रूपांतरण है जो इसे int में परिवर्तित करके और इस तरह के एक बिटमास्क को लागू करने के लिए अहस्ताक्षरित है। और सभी क्योंकि जावा में कोई अहस्ताक्षरित प्रकार नहीं हैं! बिल्कुल! खैर, ठीक है, यह घातक नहीं है।



यहां सभी सुंदरता गोल नमक का गठन है, इसलिए मुख्य ध्यान इस पर ध्यान दिया जाएगा।



चर के बारे में थोड़ा सा:

• Res SHA-256 के लिए 32 बाइट्स का एक प्रकार है और SHA-512 के लिए 64 बाइट्स है। यह हैश परिणाम संग्रहीत करता है
• roundSaltSize - गोल नमक का आकार। SHA-256 के लिए 4 बाइट और SHA-512 के लिए 8 बाइट्स
• अस्थायी - आरई सरणी आकार तत्वों के साथ साथ दौर नमक आकार गोल आकार
• s_primeIndices - Res सरणी में तत्वों के सूचकांकों की एक सरणी है, जिसमें से हम गोल नमक के संबंधित बाइट की गणना करेंगे। यही है, हम रेस [7] के साथ एसएचए -256 के लिए गोल नमक की पहली बाइट की गणना शुरू करेंगे, दूसरा रेस [11], के साथ। SHA-512 के लिए सभी सूचकांक शामिल होंगे
• btemp - एक बाइट कि मुश्किल बातचीत की एक श्रृंखला के बाद गोल नमक में जगह में गिर जाएगी

गोल नमक एल्गोरिदम के गठन की व्याख्या करने के लिए आगे बढ़ने से पहले एक और टिप्पणी। संपूर्ण एल्गोरिथ्म किसी भी वैज्ञानिक अनुसंधान और परीक्षणों का परिणाम नहीं है। यह एक मूल्य बनाने के लिए बनाया गया था जो परिणामस्वरूप हैश के कुछ बाइट्स पर निर्भर होगा और इसे धीमा और जटिल करने में मदद करेगा। खैर, अब विवरण:

1. शुरुआत में, मुख्य नमक और पासवर्ड को हाश सरणी में एकत्र किया जाता है
2. हैश सरणी हैशेड है और परिणाम रिज़ सरणी में संग्रहीत है। मूल नमक और पासवर्ड के बारे में सब कुछ भूल गया
3. हम 0x50000 पुनरावृत्तियों में एक लंबा चक्र शुरू करते हैं
4. अगला, हम अस्थायी सरणी के साथ काम करते हैं, जिसमें हम रेस सरणी की प्रतिलिपि बनाते हैं। अस्थायी सरणी के अंत में, नमक के लिए अभी भी 4 या 8 बाइट्स हैं। हमें उन्हें भरना है
5. प्रत्येक गोल नमक बाइट्स के लिए:
6. हम btmp में एक ऐसे तत्व को संग्रहीत करते हैं जो वर्तमान बाइट (j) की संख्या के आधार पर सूचकांकों (7, 11, 17 ...) में से एक पर स्थित है।
7. फिर निम्न 7 (के) बार करें:
8. हम btmp के विभाजन से शेष लेते हैं, जिनके बिट्स k पदों द्वारा दाईं ओर स्थानांतरित किए जाते हैं, Res सरणी की लंबाई से
9. हम रेस सरणी के लिए एक इंडेक्स के रूप में पिछली संख्या का उपयोग करते हैं, हम इस इंडेक्स पर संख्या को बाहर निकालते हैं
10. btmp इस नंबर को असाइन करता है, btmp modulo 256 में जोड़ा जाता है और दाईं ओर 8-k बिट्स तक स्क्रॉल किया जाता है
11. अस्थायी स्थान में हैश के बाद btmp को उसके स्थान पर रखें
12. हैश टेम्प

इस विधि के लिए कॉल इस प्रकार है:

बाइट [] नमक = नई बाइट [16];

नया सिक्योर रैंडम ()। नेक्स्टबाइट्स (नमक); // यादृच्छिक 16byte नमक उत्पन्न करते हैं

byte [] hashedPassword = new SlowHasher ()। गणनाशाला ( नया SHA256 (), पासवर्ड, नमक);

इसका परिणाम एक हैश (हैश (हैश + रेनड सॉल्ट) + राउंड सॉल्ट) है ... जिसका उपयोग उदाहरण के लिए AES-256 के लिए महत्वपूर्ण जानकारी के लिए 256-बिट एन्क्रिप्शन कुंजी के रूप में किया जा सकता है।



मेरी मशीन (C2D 2.6) पर, एक हैश उत्पन्न करने में लगभग 0.25 सेकंड लगते हैं, जिसे मैं उपयोग के लिए स्वीकार्य मानता हूं। उनकी परियोजनाओं में। आप राउंड की संख्या बढ़ा सकते हैं और फिर उसी के अनुसार समय बढ़ेगा।



यदि यह एक सम्मानित जनता के लिए दिलचस्प है, तो मैं आपको BouncyCastle पुस्तकालय के साथ काम करने के अन्य लागू पहलुओं के बारे में बता सकता हूं, जैसे कि सममित / असममित एन्क्रिप्शन, प्रमाणपत्र पीढ़ी, आदि।



युपीडी:

टिप्पणियों ने गोदी के लिए एक लिंक का संकेत दिया , जिसमें इस तरह की योजना और भी अधिक गुंजाइश है