अपडेट: कृपया ध्यान दें कि मैं यह नहीं पूछ रहा हूं कि नमक क्या है, इंद्रधनुष तालिका क्या है, शब्दकोश हमला क्या है, या नमक का उद्देश्य क्या है। मैं प्रश्न कर रहा हूं: यदि आप उपयोगकर्ताओं को नमक और हैश के बारे में जानते हैं, तो क्या उनके पासवर्ड की गणना करना काफी आसान नहीं है?
मैं इस प्रक्रिया को समझता हूं, और इसे अपनी कुछ परियोजनाओं में स्वयं लागू करता हूं।
s = random salt
storedPassword = sha1(password + s)
आपके द्वारा संग्रहीत डेटाबेस में:
username | hashed_password | salt
नमस्कार के हर कार्यान्वयन को मैंने देखा है कि पासवर्ड के अंत में या तो शुरुआत में नमक जोड़ता है:
hashed_Password = sha1(s + password )
hashed_Password = sha1(password + s)
इसके बाद, एक हैकर का शब्दकोष जो उसके नमक (हा हा) के लायक है, ऊपर सूचीबद्ध आम संयोजनों में संग्रहित लवणों के विरुद्ध प्रत्येक कीवर्ड को चलाएगा।
निश्चित रूप से ऊपर वर्णित कार्यान्वयन वास्तव में अंतर्निहित मुद्दे को हल किए बिना, हैकर के लिए एक और कदम जोड़ता है? इस समस्या के समाधान के लिए क्या विकल्प हैं, या क्या मैं समस्या को गलत समझ रहा हूं?
केवल एक चीज जो मैं सोच सकता हूं कि एक गुप्त सम्मिश्रण एल्गोरिथ्म है जो नमक और पासवर्ड को एक यादृच्छिक पैटर्न में एक साथ रखता है, या हैशिंग प्रक्रिया में अन्य उपयोगकर्ता फ़ील्ड्स को जोड़ता है जिसका अर्थ हैकर को डेटाबेस तक पहुंचना होगा और फीता पर कोड करना होगा। उन्हें एक शब्दकोश हमले के लिए उपयोगी साबित करने के लिए। (अपडेट, जैसा कि टिप्पणियों में बताया गया है कि यह मान लेना सबसे अच्छा है कि हैकर को आपकी सभी जानकारी तक पहुंच प्राप्त है, इसलिए यह संभवतः सर्वोत्तम नहीं है)।
मैं एक उदाहरण देता हूं कि मैं कैसे प्रस्तावित करता हूं कि एक हैकर पासवर्ड और हैश की सूची के साथ एक उपयोगकर्ता डेटाबेस को हैक करेगा:
हमारे हैक किए गए डेटाबेस से डेटा:
RawPassword (not stored) | Hashed | Salt
--------------------------------------------------------
letmein WEFLS... WEFOJFOFO...
आम पासवर्ड शब्दकोश:
Common Password
--------------
letmein
12345
...
प्रत्येक उपयोगकर्ता रिकॉर्ड के लिए, सामान्य पासवर्ड को लूप करें और उन्हें हैश करें:
for each user in hacked_DB
salt = users_salt
hashed_pw = users_hashed_password
for each common_password
testhash = sha1(common_password + salt)
if testhash = hashed_pw then
//Match! Users password = common_password
//Lets visit the webpage and login now.
end if
next
next
मुझे उम्मीद है कि यह मेरी बात को बहुत बेहतर दिखाता है।
10,000 सामान्य पासवर्ड और 10,000 उपयोगकर्ता रिकॉर्ड को देखते हुए, हमें यथासंभव अधिक से अधिक उपयोगकर्ता पासवर्ड खोजने के लिए 100,000,000 हैश की गणना करने की आवश्यकता होगी। इसमें कुछ घंटे लग सकते हैं, लेकिन यह वास्तव में एक मुद्दा नहीं है।
क्रैकिंग थ्योरी पर अपडेट
हम मान लेंगे कि हम एक भ्रष्ट वेबहोस्ट हैं, जिसमें SHA1 हैश और लवण के डेटाबेस तक पहुंच है, साथ ही उन्हें मिश्रण करने के लिए आपके एल्गोरिथ्म के साथ। डेटाबेस में 10,000 उपयोगकर्ता रिकॉर्ड हैं।
यह साइट GPU का उपयोग करके प्रति सेकंड 2,300,000,000 SHA1 हैश की गणना करने में सक्षम होने का दावा करती है। (वास्तविक दुनिया में स्थिति शायद धीमी होगी, लेकिन अब हम उस उद्धृत आंकड़े का उपयोग करेंगे)।
(((95 ^ 4) / 2300000000) / 2) * 10000 = 177 सेकंड
95 प्रिंट करने योग्य ASCII वर्णों की एक पूरी श्रृंखला को देखते हुए, 4 वर्णों की अधिकतम लंबाई के साथ, गणना की दर (चर) से विभाजित, 2 से विभाजित (पासवर्ड की खोज करने के लिए औसत समय मानने पर 10,000 के लिए औसतन 50% क्रमपरिवर्तन की आवश्यकता होगी)। उन उपयोगकर्ताओं को सभी उपयोगकर्ताओं के पासवर्ड काम करने में 177 सेकंड का समय लगेगा जहां लंबाई <= 4 है।
आइए इसे यथार्थवाद के लिए थोड़ा समायोजित करें।
((36 ^ 7) / 1000000000) / 2) * 10000 = 2 दिन
पासवर्ड की लंबाई <= 7 के साथ गैर-मामले की संवेदनशीलता को मानते हुए, केवल अल्फ़ान्यूमेरिक वर्ण, 10,000 उपयोगकर्ता रिकॉर्ड को हल करने में 4 दिन लगेंगे, और मैंने ओवरहेड और गैर आदर्श परिस्थिति को प्रतिबिंबित करने के लिए एल्गोरिथ्म की गति को आधा कर दिया है।
यह पहचानना महत्वपूर्ण है कि यह एक लीनियर ब्रूट फोर्स अटैक है, सभी गणना एक दूसरे से स्वतंत्र हैं, इसके अलावा कई सिस्टमों को हल करने के लिए यह एक आदर्श कार्य है। (IE अलग-अलग छोरों से हमले चलाने वाले 2 कंप्यूटरों को स्थापित करना आसान है जो कि एक्सपेक्टेशन टाइम को आधा कर देगा)।
इस कार्य को अधिक कम्प्यूटेशनल रूप से महंगा बनाने के लिए एक पासवर्ड को 1,000 गुना करने के लिए हैशिंग के मामले को देखते हुए:
((36 ^ 7) / 1 000 000 000) / 2) * 1000 सेकंड = 10.8839117 घंटे
यह 7 अल्फा-न्यूमेरिक वर्णों की अधिकतम लंबाई का प्रतिनिधित्व करता है, एक उपयोगकर्ता के लिए उद्धृत आंकड़े से आधे से भी कम गति निष्पादन ।
एक बार फिर से हैशिंग ने 1,000 बार प्रभावी रूप से एक कंबल हमले को अवरुद्ध किया है, लेकिन उपयोगकर्ता डेटा पर लक्षित हमले अभी भी असुरक्षित हैं।