अजगर passlib: - इससे पहले कि उपयोगकर्ताओं को नाराज हो रही शुरू 400 मि.से क्या "दौर"

Question

passlib documentation

सबसे सार्वजनिक संपर्क वाले सेवाओं के लिए से

के लिए सबसे अच्छा मूल्य है, तो आप आम तौर पर साइन इन 250ms के ऊपर ले हो सकता है।

तो एक लॉग इन/पंजीकरण अगर हम पर विचार है कि वहाँ एक लॉगिन प्रयास के लिए डेटाबेस के लिए कॉल में rounds के लिए सबसे अच्छा मूल्य क्या है, और यह का उपयोग करता गैर अवरुद्ध साथ MongoDB पर कॉल करें। (Mongotor उपयोग कर, और _id के रूप में ईमेल का उपयोग कर, इसलिए यह डिफ़ॉल्ट अनुक्रमित द्वारा होता है, क्वेरी तेज है: .00299978256226 और पाठ्यक्रम एक डेटाबेस 3 रिकॉर्ड है कि के साथ परीक्षण के ...)

import passlib.hash 
import time 

hashh = passlib.hash.pbkdf2_sha512 
beg1 = time.time() 
password = hashh.encrypt("test", salt_size = 32, rounds = 12000) 
print time.time()- beg1 # returns 0.142999887466 
beg2 = time.time() 
hashh.verify("test", password) # returns 0.143000125885 
print time.time()- beg2 

अब अगर मैं आधा मूल्य का उपयोग करें:

password = hashh.encrypt("test", salt_size = 32, rounds = 4000) # returns 0.0720000267029 
hashh.verify("test", password) # returns 0.0709998607635 

उपयोग कर रहा हूँ विंडोज 7 डेल एक्सपीएस 15 i7 2.0 Ghz

बिट्स

एनबी: स्थापित bcrypt, और जाहिर है, यह एक असली दर्द यह सीधे का उपयोग कर अपने मूलभूत मूल्यों के रूप में (rounds = 12) है:

hashh = passlib.hash.bcrypt 
beg1 = time.time() 
password = hashh.encrypt("test", rounds = 12) # returns 0.406000137329 
print time.time()- beg1 
beg2 = time.time() 
hashh.verify("test", password) # returns 0.40499997139 
print time.time()- beg2 

आधा मूल्य:

password = hashh.encrypt("test", rounds = 12) # 0.00699996948242 wonderful? 
hashh.verify("test", password) # 0.00600004196167 

तुम मुझे एक अच्छा सुझाव दे सकते हैं pbkdf2_sha512 का उपयोग करते समय राउंड मूल्य जो उत्पादन के लिए अच्छा होगा?

Answer 1

(passlib डेवलपर यहाँ)

समय pbkdf2_sha512 लेता है की राशि दौर रेखीय समानुपाती यह है पैरामीटर (elapsed_time = rounds * native_speed)। आपके सिस्टम के लिए डेटा का उपयोग करना, native_speed = 12000/.143 = 83916 iterations/second, जिसका अर्थ है कि आपको ~ 350ms देरी प्राप्त करने के लिए लगभग 83916 * .350 = 29575 rounds की आवश्यकता होगी।

चीजें bcrypt के लिए एक छोटी सी चालक हैं, क्योंकि इसमें जितना समय लगता है वह इसके राउंड पैरामीटर (elapsed_time = (2 ** rounds) * native_speed) के लिए आनुपातिक रूप से आनुपातिक है। आपके सिस्टम के लिए डेटा का उपयोग करना, native_speed = (2 ** 12)/.405 = 10113 iterations/second, जिसका अर्थ है कि आपको ~ 350 एमएस देरी प्राप्त करने के लिए लगभग log(10113 * .350, 2) = 11.79 rounds की आवश्यकता होगी। लेकिन चूंकि बीक्रिप्ट केवल पूर्णांक राउंड पैरामीटर स्वीकार करता है, इसलिए आपको rounds=11 (~ 200ms) या rounds=12 (~ 400ms) चुनना होगा।

---

यह सब कुछ है जो मैं पासलिब की भविष्य में रिलीज में ठीक होने की उम्मीद कर रहा हूं। एक काम प्रगति पर है, पासलिब के मर्कुरियल रेपो में वर्तमान में एक साधारण छोटी स्क्रिप्ट, choose_rounds.py है, जो किसी दिए गए लक्ष्य समय के लिए सही राउंड मान चुनने का ख्याल रखती है।आप डाउनलोड करने और इसे सीधे चलाने के रूप में निम्न प्रकार कर सकते हैं (यह 20 समय लग सकता है या तो चलाने के लिए):

$ python choose_rounds.py -h 
usage: python choose_rounds.py <hash_name> [<target_in_milliseconds>] 

$ python choose_rounds.py pbkdf2_sha512 350 
hash............: pbkdf2_sha512 
speed...........: 83916 iterations/second 
target time.....: 350 ms 
target rounds...: 29575 

$ python choose_rounds.py bcrypt 350 
hash............: bcrypt 
speed...........: 10113 iterations/second 
target time.....: 350 ms 
target rounds...: 11 (200ms -- 150ms faster than requested) 
target rounds...: 12 (400ms -- 50ms slower than requested) 

---

(संपादित करें: सुरक्षित न्यूनतम दौर के बारे में जोड़ा प्रतिक्रिया ...)

अस्वीकरण: एक सुरक्षित न्यूनतम निर्धारित करना एक आश्चर्यजनक रूप से मुश्किल सवाल है - पैरामीटर को मापने के लिए बहुत कठिन हैं, बहुत कम वास्तविक विश्व डेटा, और कुछ कठोर असहनीय सिद्धांत। एक अच्छा अधिकार की कमी, मैं खुद विषय का शोध कर रहा हूं; और ऑफ-द-कफ गणनाओं के लिए, मैंने कच्चे डेटा को एक छोटे सूत्र (नीचे) तक उबाला है, जो आम तौर पर मैं उपयोग करता हूं। बस जागरूक रहें कि इसके पीछे धारणाओं और मोटे अनुमानों के कुछ पृष्ठ हैं, जो इसे Fermi Estimation से अधिक सटीक उत्तर से अधिक बनाते हैं: |

अंगूठे का मेरा नियम (मध्य 2012) PBKDF2-HMAC-SHA512 पर हमला GPUs उपयोग करने के लिए है: इससे पहले कि हमलावर अनुमान लगा की एक 50/50 मौका है

days * dollars = 2**(n-31) * rounds 

• days दिनों की संख्या है पासवर्ड।
• dollars हमलावरों के हार्डवेयर बजट ($ यूएसडी में) है।
• n आपके उपयोगकर्ता के पासवर्ड (बिट्स में) में एन्ट्रॉपी की औसत राशि है। अगर औसत पासवर्ड एन्ट्रापी की 32 बिट है, और हमलावर एक अच्छा GPU के साथ एक $ 2000 प्रणाली है, तो 30000 राउंड में वे 30 दिन की आवश्यकता होगी (2**(32-31)*30000/2000):

अपनी स्क्रिप्ट-किडी सवाल का जवाब देने दिए गए हैश को क्रैक करने का 50/50 मौका है। मैं मूल्यों के साथ खेलने के लिए अनुशंसा करता हूं जब तक आप एक राउंड/दिन ट्रेडऑफ पर पहुंच न जाएं जिससे आप सहज महसूस कर सकें।

कुछ बातें ध्यान में रखना:

• डिक्शनरी हमले की सफलता की दर रैखिक नहीं है, इसके बारे में "लंबी पूंछ" स्थिति और अधिक है, तो के अधिक के रूप में 50/50 मार्क के बारे में सोच आधा जीवन

• 31 महत्वपूर्ण कारक है, क्योंकि यह विशिष्ट तकनीक स्तर का उपयोग करके एक विशिष्ट एल्गोरिदम पर हमला करने की लागत का आकलन करता है। वास्तविक मूल्य, 2**-31, "प्रति दिन डॉलर-दिन" को मापता है, यह एक हमलावर की लागत होगी। तुलना के लिए, ASIC का उपयोग कर पीबीकेडीएफ 2-एचएमएसी-एसएचए 512 पर हमला करने के लिए 46 के करीब एक कारक है - बड़ी संख्या में हमलावर की हिरन के लिए अधिक धमाका है, और आपके लिए प्रति राउंड कम सुरक्षा है, हालांकि स्क्रिप्ट किड्स के पास आमतौर पर उस तरह का बजट नहीं होगा :)