Python 3.7 - hashlib

हैशलीब - सुरक्षित हैश और संदेश पचा




python

हैशलीब - सुरक्षित हैश और संदेश पचा

स्रोत कोड: Lib/hashlib.py

यह मॉड्यूल कई अलग-अलग सुरक्षित हैश और संदेश डाइजेस्ट एल्गोरिदम के लिए एक सामान्य इंटरफ़ेस लागू करता है। शामिल हैं सुरक्षित सेकेंड हैश एल्गोरिदम SHA1, SHA224, SHA256, SHA384, और SHA512 (FIPS 180-2 में परिभाषित) साथ ही RSA का MD5 एल्गोरिथ्म (इंटरनेट RFC 1321 में परिभाषित)। शब्द "सुरक्षित हैश" और "संदेश पचाने" विनिमेय हैं। पुराने एल्गोरिदम को संदेश डाइजेस्ट कहा जाता था। आधुनिक शब्द सुरक्षित हैश है।

ध्यान दें

यदि आप adler32 या crc32 हैश फ़ंक्शन चाहते हैं, तो वे zlib मॉड्यूल में उपलब्ध हैं।

चेतावनी

कुछ एल्गोरिदम ने हैश टक्कर की कमजोरियों को जाना है, अंत में "देखें" अनुभाग देखें।

हैश एल्गोरिदम

प्रत्येक प्रकार के हैश के लिए नामित एक निर्माण विधि है। सभी एक ही साधारण इंटरफ़ेस के साथ हैश ऑब्जेक्ट लौटाते हैं। उदाहरण के लिए: SHA-256 हैश ऑब्जेक्ट बनाने के लिए sha256() का उपयोग करें। अब आप इस ऑब्जेक्ट को update() विधि का उपयोग करके bytes जैसी वस्तुओं (सामान्य रूप से bytes ) के साथ फ़ीड कर सकते हैं। किसी भी बिंदु पर आप इसे पचाने के लिए प्राप्त डेटा के पाचन के लिए पूछ सकते हैं जो अब तक digest() या hexdigest() विधियों का उपयोग कर रहा है।

ध्यान दें

बेहतर मल्टीथ्रेडिंग प्रदर्शन के लिए, पायथन GIL ऑब्जेक्ट निर्माण या अपडेट पर 2047 बाइट्स से बड़े डेटा के लिए जारी किया जाता है।

ध्यान दें

स्ट्रिंग ऑब्जेक्ट्स को update() में update() समर्थित नहीं है, क्योंकि हैश बाइट्स पर काम करते हैं, वर्णों पर नहीं।

इस मॉड्यूल में हमेशा मौजूद हैश एल्गोरिदम के लिए निर्माता sha1() , sha224() sha256() , sha384() , sha384() , sha512() , blake2b() और blake2s() md5() आम तौर पर उपलब्ध है, हालांकि यह गायब हो सकता है यदि आप पाइरॉन के एक दुर्लभ "FIPS अनुपालन" निर्माण का उपयोग कर रहे हैं। अतिरिक्त एल्गोरिदम ओपनएसएसएल लाइब्रेरी के आधार पर भी उपलब्ध हो सकता है जो पायथन आपके प्लेटफॉर्म पर उपयोग करता है। अधिकांश प्लेटफार्मों पर sha3_224() , sha3_256() , sha3_384() , sha3_512() , shake_128() , shake_256() भी उपलब्ध हैं।

संस्करण 3.6 में नया: SHA3 ​​(केकेक) और SHAKE कंस्ट्रक्टर sha3_224() , sha3_256() , sha3_384() , sha3_512() , shake_128() , shake_256()

संस्करण 3.6 में नया: blake2b() और blake2s() जोड़ा गया।

उदाहरण के लिए, बाइट स्ट्रिंग के पाचन को प्राप्त करने के लिए कोई भी b'Nobody inspects the spammish repetition' : b'Nobody inspects the spammish repetition'

>>> import hashlib
>>> m = hashlib.sha256()
>>> m.update(b"Nobody inspects")
>>> m.update(b" the spammish repetition")
>>> m.digest()
b'\x03\x1e\xdd}Ae\x15\x93\xc5\xfe\\\x00o\xa5u+7\xfd\xdf\xf7\xbcN\x84:\xa6\xaf\x0c\x95\x0fK\x94\x06'
>>> m.digest_size
32
>>> m.block_size
64

अधिक संघनित:

>>> hashlib.sha224(b"Nobody inspects the spammish repetition").hexdigest()
'a4337bc45a8fc544c03f52dc550cd6e1e87021bc896588bd79e901e2'
hashlib.new(name[, data])

एक सामान्य रचनाकार है जो अपने पहले पैरामीटर के रूप में वांछित एल्गोरिदम का स्ट्रिंग नाम लेता है। यह ऊपर सूचीबद्ध हैश के साथ-साथ आपके ओपनएसएसएल पुस्तकालय की पेशकश करने वाले किसी भी अन्य एल्गोरिदम तक पहुंच की अनुमति देने के लिए भी मौजूद है। नामित निर्माता new() तुलना में बहुत तेज़ हैं और उन्हें प्राथमिकता दी जानी चाहिए।

OpenSSL द्वारा उपलब्ध कराए गए एल्गोरिदम के साथ new() का उपयोग करना:

>>> h = hashlib.new('ripemd160')
>>> h.update(b"Nobody inspects the spammish repetition")
>>> h.hexdigest()
'cc4a5ce1b3df48aec5d22d1f16b894a0b894eccc'

हाशिब निम्नलिखित निरंतर विशेषताएं प्रदान करता है:

hashlib.algorithms_guaranteed

सभी प्लेटफार्मों पर इस मॉड्यूल द्वारा समर्थित होने के लिए गारंटीकृत हैश एल्गोरिदम के नाम वाला एक सेट। ध्यान दें कि 'md5' इस सूची में है क्योंकि कुछ अपस्ट्रीम विक्रेताओं ने एक अजीब "FIPS शिकायतकर्ता" पायथन निर्माण की पेशकश की है जो इसे छोड़कर नहीं है।

संस्करण 3.2 में नया।

hashlib.algorithms_available

एक सेट जिसमें हैश एल्गोरिदम का नाम है जो चल रहे पायथन दुभाषिया में उपलब्ध है। new() पास होने पर इन नामों को मान्यता दी जाएगी। algorithms_guaranteed हमेशा एक सबसेट होगा। अलग-अलग नामों (ओपनएसएसएल के लिए धन्यवाद) के तहत एक ही एल्गोरिथ्म इस सेट में कई बार दिखाई दे सकता है।

संस्करण 3.2 में नया।

निर्माणकर्ताओं द्वारा लौटाए गए हैश ऑब्जेक्ट की निरंतर विशेषताओं के रूप में निम्नलिखित मान प्रदान किए जाते हैं:

hash.digest_size

बाइट्स में परिणामी हैश का आकार।

hash.block_size

बाइट्स में हैश एल्गोरिथ्म का आंतरिक ब्लॉक आकार।

एक हैश वस्तु में निम्नलिखित विशेषताएं हैं:

hash.name

इस हैश का विहित नाम, हमेशा कम और हमेशा इस प्रकार के एक और हैश बनाने के लिए new() पैरामीटर के रूप में उपयुक्त होता है।

संस्करण ४.४ में परिवर्तित: नाम विशेषता अपनी स्थापना के बाद से सीपीथॉन में मौजूद है, लेकिन जब तक अजगर ३.४ औपचारिक रूप से निर्दिष्ट नहीं किया गया था, तब तक कुछ प्लेटफार्मों पर मौजूद नहीं हो सकता है।

हैश ऑब्जेक्ट में निम्न विधियाँ हैं:

hash.update(data)

हैश ऑब्जेक्ट को बाइट्स जैसी ऑब्जेक्ट से अपडेट करें। बार-बार कॉल सभी तर्कों के m.update(a); m.update(b) साथ एक एकल कॉल के बराबर हैं: m.update(a); m.update(b) m.update(a); m.update(b) m.update(a+b) बराबर है।

संस्करण 3.1 में बदला गया: पायथन जीआईएल को अन्य थ्रेड को चलाने की अनुमति देने के लिए जारी किया गया है, जबकि OpenSSL द्वारा आपूर्ति किए गए हैश एल्गोरिदम का उपयोग करते समय 2047 बाइट से बड़े डेटा पर हैश अपडेट हो रहा है।

hash.digest()

update() विधि में अब तक दिए गए डेटा के पाचन को वापस लौटाएं। यह आकार का एक बाइट्स digest_size जिसमें 0 से 255 तक पूरी रेंज में बाइट्स हो सकते हैं।

hash.hexdigest()

digest() तरह digest() को छोड़कर डबल लेंथ की एक स्ट्रिग ऑब्जेक्ट के रूप में वापस किया जाता है, जिसमें केवल हेक्साडेसिमल अंक होते हैं। इसका उपयोग ईमेल या अन्य गैर-बाइनरी वातावरण में सुरक्षित रूप से मूल्य का आदान-प्रदान करने के लिए किया जा सकता है।

hash.copy()

हैश ऑब्जेक्ट की एक प्रति ("क्लोन") वापस करें। यह एक सामान्य प्रारंभिक विकल्प साझा करने वाले डेटा के पाचन को कुशलतापूर्वक गणना करने के लिए इस्तेमाल किया जा सकता है।

शेक चर लंबाई पचता है

shake_128() और shake_256() एल्गोरिथ्म लंबाई के साथ पचाने वाले लंबाई के साथ लंबाई प्रदान करते हैं। जैसे, उनके पाचन के तरीकों की लंबाई की आवश्यकता होती है। अधिकतम लंबाई SHAKE एल्गोरिथम द्वारा सीमित नहीं है।

shake.digest(length)

update() विधि में अब तक दिए गए डेटा के पाचन को वापस लौटाएं। यह आकार लंबाई का एक बाइट्स ऑब्जेक्ट है जिसमें 0 से 255 तक पूरी रेंज में बाइट्स हो सकते हैं।

shake.hexdigest(length)

digest() तरह digest() को छोड़कर डबल लेंथ की एक स्ट्रिग ऑब्जेक्ट के रूप में वापस किया जाता है, जिसमें केवल हेक्साडेसिमल अंक होते हैं। इसका उपयोग ईमेल या अन्य गैर-बाइनरी वातावरण में सुरक्षित रूप से मूल्य का आदान-प्रदान करने के लिए किया जा सकता है।

कुंजी व्युत्पत्ति

कुंजी व्युत्पत्ति और प्रमुख स्ट्रेचिंग एल्गोरिदम सुरक्षित पासवर्ड हैशिंग के लिए डिज़ाइन किए गए हैं। Na1 एल्गोरिदम जैसे कि sha1(password) जानवर-बल के हमलों के खिलाफ प्रतिरोधी नहीं हैं। एक अच्छा पासवर्ड हैशिंग फ़ंक्शन ट्यून करने योग्य, धीमा और salt शामिल होना चाहिए।

hashlib.pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None)

फ़ंक्शन PKCS # 5 पासवर्ड-आधारित कुंजी व्युत्पत्ति फ़ंक्शन प्रदान करता है। यह HMAC को छद्म आयामी फ़ंक्शन के रूप में उपयोग करता है।

स्ट्रिंग हैश_नाम एचएमएसी के लिए हैश डाइजेस्ट एल्गोरिथ्म का वांछित नाम है, जैसे 'sha1' या 'sha256'। पासवर्ड और नमक को बाइट्स के बफ़र के रूप में समझा जाता है। अनुप्रयोगों और पुस्तकालयों को पासवर्ड को एक समझदार लंबाई (जैसे 1024) तक सीमित करना चाहिए। नमक एक उचित स्रोत से लगभग 16 या अधिक बाइट्स होना चाहिए, जैसे os.urandom()

हैश एल्गोरिथ्म और कंप्यूटिंग शक्ति के आधार पर पुनरावृत्तियों की संख्या को चुना जाना चाहिए। 2013 तक, SHA-256 के कम से कम 100,000 पुनरावृत्तियों का सुझाव दिया गया है।

dklen व्युत्पन्न कुंजी की लंबाई है। यदि dklen None तो हैश एल्गोरिथ्म hash_name के डाइजेस्ट साइज़ का उपयोग किया जाता है, उदाहरण के लिए SHA-512 के लिए 64।

>>> import hashlib, binascii
>>> dk = hashlib.pbkdf2_hmac('sha256', b'password', b'salt', 100000)
>>> binascii.hexlify(dk)
b'0394a2ede332c9a13eb82e9b24631604c31df978b4e2f0fbd2c549944f9d79a5'

संस्करण 3.4 में नया।

ध्यान दें

Pbkdf2_hmac का तीव्र कार्यान्वयन OpenSSL के साथ उपलब्ध है। पायथन कार्यान्वयन hmac इनलाइन संस्करण का उपयोग करता है। यह लगभग तीन गुना धीमा है और GIL को जारी नहीं करता है।

hashlib.scrypt(password, *, salt, n, r, p, maxmem=0, dklen=64)

फ़ंक्शन RFC 7914 में परिभाषित के रूप में scrypt पासवर्ड-आधारित कुंजी व्युत्पत्ति फ़ंक्शन प्रदान करता है।

पासवर्ड और नमक बाइट्स जैसी वस्तुओं का होना चाहिए। अनुप्रयोगों और पुस्तकालयों को पासवर्ड को एक समझदार लंबाई (जैसे 1024) तक सीमित करना चाहिए। नमक एक उचित स्रोत से लगभग 16 या अधिक बाइट्स होना चाहिए, जैसे os.urandom()

n सीपीयू / मेमोरी कॉस्ट फैक्टर है, आर ब्लॉक आकार, पी समानांतरकरण कारक और मैक्सिमम लिमिट मेमोरी (ओपनएसएसएल 1.1.0 डिफॉल्ट से 32 एमआईबी) तक सीमित है। dklen व्युत्पन्न कुंजी की लंबाई है।

उपलब्धता: ओपनएसएसएल 1.1+

संस्करण 3.6 में नया।

BLAKE2

BLAKE2 RFC 7693 में परिभाषित एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन है जो दो फ्लेवर्स में आता है:

  • BLAKE2b , 64-बिट प्लेटफ़ॉर्म के लिए अनुकूलित है और 1 और 64 बाइट्स के बीच किसी भी आकार के डाइजेस्ट का उत्पादन करता है,
  • BLAKE2s , 8- से 32-बिट प्लेटफ़ॉर्म के लिए अनुकूलित और 1 और 32 बाइट्स के बीच किसी भी आकार के डाइजेस्ट का उत्पादन करता है।

BLAKE2 कीड मोड ( HMAC लिए एक तेज़ और सरल प्रतिस्थापन), नमकीन हैशिंग , निजीकरण और ट्री हैशिंग का समर्थन करता है

इस मॉड्यूल से हैश ऑब्जेक्ट मानक लाइब्रेरी के hashlib ऑब्जेक्ट्स के एपीआई का अनुसरण करते हैं।

हैश ऑब्जेक्ट बनाना

नई हैश वस्तुओं को निर्माण कार्यों को कॉल करके बनाया जाता है:

hashlib.blake2b(data=b'', *, digest_size=64, key=b'', salt=b'', person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, node_depth=0, inner_size=0, last_node=False)
hashlib.blake2s(data=b'', *, digest_size=32, key=b'', salt=b'', person=b'', fanout=1, depth=1, leaf_size=0, node_offset=0, node_depth=0, inner_size=0, last_node=False)

ये फ़ंक्शन BLAKE2b या BLAKE2s की गणना के लिए संबंधित हैश ऑब्जेक्ट लौटाते हैं। वे वैकल्पिक रूप से इन सामान्य मापदंडों को लेते हैं:

  • डेटा : हैश को डेटा का प्रारंभिक हिस्सा, जो बाइट्स की तरह वस्तु होना चाहिए। इसे केवल स्थितीय तर्क के रूप में पारित किया जा सकता है।
  • डाइजेस्ट_साइज : बाइट्स में आउटपुट डाइजेस्ट का आकार।
  • कुंजी : कुंजी वाले हैशिंग के लिए (BLAKE2b के लिए 64 बाइट्स तक, BLAKE2b के लिए 32 बाइट्स तक)।
  • नमक : यादृच्छिक हैशिंग के लिए नमक (BLAKE2b के लिए 16 बाइट तक, BLAKE2b के लिए 8 बाइट तक)।
  • व्यक्ति : वैयक्तिकरण स्ट्रिंग (BLAKE2b के लिए 16 बाइट्स तक, BLAKE2s के लिए 8 बाइट्स तक)।

निम्न तालिका सामान्य मापदंडों (बाइट्स में) के लिए सीमा दिखाती है:

हैश digest_size लेन (key) लेन (नमक) लेन (व्यक्ति)
BLAKE2b 64 64 16 16
BLAKE2s 32 32 8 8

ध्यान दें

BLAKE2 विनिर्देश नमक और निजीकरण मापदंडों के लिए निरंतर लंबाई को परिभाषित करता है, हालांकि, सुविधा के लिए, यह कार्यान्वयन निर्दिष्ट लंबाई तक किसी भी आकार के बाइट स्ट्रिंग्स को स्वीकार करता है। यदि पैरामीटर की लंबाई निर्दिष्ट से कम है, तो इसे शून्य से गद्देदार किया जाता है, इस प्रकार, उदाहरण के लिए, b'salt' और b'salt\x00' एक ही मूल्य है। (यह कुंजी के लिए मामला नहीं है।)

ये आकार नीचे वर्णित मॉड्यूल constants रूप में उपलब्ध हैं।

कंस्ट्रक्टर फ़ंक्शन निम्नलिखित पेड़ हैशिंग मापदंडों को भी स्वीकार करते हैं:

  • फैनआउट : फैनआउट (0 से 255, 0 यदि असीमित, क्रमिक मोड में 1)।
  • गहराई : पेड़ की अधिकतम गहराई (1 से 255, 255 अगर असीमित, अनुक्रमिक मोड में 1)।
  • पत्ती_साइज : पत्ती की अधिकतम बाइट लंबाई (0 से 2 ** 32-1, 0 अगर असीमित या अनुक्रमिक मोड में हो)।
  • नोड_ऑफसेट : नोड ऑफसेट (0 से 2 ** 64-1 के लिए BLAKE2b, 0 से 2 ** 48-1 के लिए BLAKE2s, 0 के लिए पहले, सबसे बाईं ओर, पत्ती, या अनुक्रमिक मोड में)।
  • नोड_डेप : नोड गहराई (0 से 255, पत्तियों के लिए, या अनुक्रमिक मोड में)।
  • इनर_साइज़ : इनर डाइजेस्ट साइज़ (BLAKE2b के लिए 0 से 64, BLAKE2s के लिए 0 से 32, क्रमिक मोड में 0)।
  • last_node : बूलियन यह दर्शाता है कि संसाधित नोड अंतिम है (अनुक्रमिक मोड के लिए False )।
ट्री मोड मापदंडों की व्याख्या।

पेड़ हैशिंग की व्यापक समीक्षा के लिए BLAKE2 विनिर्देश में अनुभाग 2.10 देखें।

स्थिरांक

blake2b.SALT_SIZE
blake2s.SALT_SIZE

नमक की लंबाई (निर्माणकर्ताओं द्वारा स्वीकृत अधिकतम लंबाई)।

blake2b.PERSON_SIZE
blake2s.PERSON_SIZE

वैयक्तिकरण स्ट्रिंग की लंबाई (निर्माणकर्ताओं द्वारा स्वीकृत अधिकतम लंबाई)।

blake2b.MAX_KEY_SIZE
blake2s.MAX_KEY_SIZE

अधिकतम कुंजी आकार।

blake2b.MAX_DIGEST_SIZE
blake2s.MAX_DIGEST_SIZE

अधिकतम पाचन आकार जो हैश फ़ंक्शन आउटपुट कर सकता है।

उदाहरण

सरल हैशिंग

कुछ डेटा के हैश की गणना करने के लिए, आपको पहले उचित कंस्ट्रक्टर फ़ंक्शन ( blake2b() या blake2s() ) को कॉल करके एक हैश ऑब्जेक्ट का निर्माण करना चाहिए, फिर ऑब्जेक्ट पर update() कॉल करके डेटा के साथ update() , और, अंत में, प्राप्त करें digest() या hexdigest() हेक्स-एन्कोडेड स्ट्रिंग के लिए कॉल करके ऑब्जेक्ट को hexdigest()

>>> from hashlib import blake2b
>>> h = blake2b()
>>> h.update(b'Hello world')
>>> h.hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'

शॉर्टकट के रूप में, आप स्थिति संबंधी तर्क के रूप में सीधे निर्माता को अपडेट करने के लिए डेटा का पहला हिस्सा पास कर सकते हैं:

>>> from hashlib import blake2b
>>> blake2b(b'Hello world').hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'

आप update() को कई बार कॉल कर सकते हैं update() बार आपको हैश को अपडेट करने की आवश्यकता होती है:

>>> from hashlib import blake2b
>>> items = [b'Hello', b' ', b'world']
>>> h = blake2b()
>>> for item in items:
...     h.update(item)
>>> h.hexdigest()
'6ff843ba685842aa82031d3f53c48b66326df7639a63d128974c5c14f31a0f33343a8c65551134ed1ae0f2b0dd2bb495dc81039e3eeb0aa1bb0388bbeac29183'

विभिन्न पाचन आकारों का उपयोग करना

BLAKE2 के पास 64 बाइट्स के लिए BLAKE2b के लिए 64 बाइट्स तक और BLAKE2s के लिए 32 बाइट्स तक कॉन्फ़िगर करने योग्य आकार है। उदाहरण के लिए, SHA-1 को BLAKE2b के साथ बदलने के लिए आउटपुट के आकार को बदले बिना, हम BLAKE2b को 20-बाइट डाइजेस्ट बनाने के लिए कह सकते हैं:

>>> from hashlib import blake2b
>>> h = blake2b(digest_size=20)
>>> h.update(b'Replacing SHA1 with the more secure function')
>>> h.hexdigest()
'd24f26cf8de66472d58d4e1b1774b4c9158b1f4c'
>>> h.digest_size
20
>>> len(h.digest())
20

अलग-अलग डाइजेस्ट साइज़ वाली हैश ऑब्जेक्ट्स में पूरी तरह से अलग-अलग आउटपुट होते हैं (छोटी हैश अधिक लंबी हैश के उपसर्ग नहीं हैं); BLAKE2b और BLAKE2s अलग-अलग आउटपुट का उत्पादन करते हैं, भले ही आउटपुट लंबाई समान हो:

>>> from hashlib import blake2b, blake2s
>>> blake2b(digest_size=10).hexdigest()
'6fa1d8fcfd719046d762'
>>> blake2b(digest_size=11).hexdigest()
'eb6ec15daf9546254f0809'
>>> blake2s(digest_size=10).hexdigest()
'1bf21a98c78a1c376ae9'
>>> blake2s(digest_size=11).hexdigest()
'567004bf96e4a25773ebf4'

कीड हैशिंग

HMAC (HMAC) के लिए तेज़ और सरल प्रतिस्थापन के रूप में प्रमाणीकरण के लिए Keyed हैशिंग का उपयोग किया जा सकता है। BLAKE2 को सुरक्षित रूप से उपसर्ग-मैक मोड में उपयोग किया जा सकता है जो BLAKE से विरासत में मिली उदासीनता संपत्ति के लिए धन्यवाद है।

इस उदाहरण से पता चलता है कि कैसे संदेश प्राप्त करने के लिए एक (हेक्स-एनकोडेड) 128-बिट प्रमाणीकरण कोड के लिए संदेश b'message data' कुंजी b'pseudorandom key' :

>>> from hashlib import blake2b
>>> h = blake2b(key=b'pseudorandom key', digest_size=16)
>>> h.update(b'message data')
>>> h.hexdigest()
'3d363ff7401e02026f4a4687d4863ced'

एक व्यावहारिक उदाहरण के रूप में, एक वेब एप्लिकेशन उपयोगकर्ताओं को भेजे गए कुकीज़ को सममित रूप से हस्ताक्षरित कर सकता है और बाद में उन्हें यह सुनिश्चित करने के लिए सत्यापित कर सकता है कि उन पर छेड़छाड़ नहीं की गई थी:

>>> from hashlib import blake2b
>>> from hmac import compare_digest
>>>
>>> SECRET_KEY = b'pseudorandomly generated server secret key'
>>> AUTH_SIZE = 16
>>>
>>> def sign(cookie):
...     h = blake2b(digest_size=AUTH_SIZE, key=SECRET_KEY)
...     h.update(cookie)
...     return h.hexdigest().encode('utf-8')
>>>
>>> def verify(cookie, sig):
...     good_sig = sign(cookie)
...     return compare_digest(good_sig, sig)
>>>
>>> cookie = b'user-alice'
>>> sig = sign(cookie)
>>> print("{0},{1}".format(cookie.decode('utf-8'), sig))
user-alice,b'43b3c982cf697e0c5ab22172d1ca7421'
>>> verify(cookie, sig)
True
>>> verify(b'user-bob', sig)
False
>>> verify(cookie, b'0102030405060708090a0b0c0d0e0f00')
False

भले ही वहाँ एक देशी बंद हैशिंग मोड, BLAKE2, निश्चित रूप से hmac साथ HMAC निर्माण में उपयोग किया जा सकता है:

>>> import hmac, hashlib
>>> m = hmac.new(b'secret key', digestmod=hashlib.blake2s)
>>> m.update(b'message')
>>> m.hexdigest()
'e3c8102868d28b5ff85fc35dda07329970d1a01e273c37481326fe0c861c8142'

यादृच्छिक हैशिंग

नमक पैरामीटर सेट करके उपयोगकर्ता हैश फ़ंक्शन के लिए यादृच्छिककरण पेश कर सकते हैं। डिजिटल हस्ताक्षर में उपयोग किए गए हैश फ़ंक्शन पर टकराव के हमलों से बचाने के लिए रैंडमाइज़्ड हैशिंग उपयोगी है।

रैंडमाइज्ड हैशिंग उन स्थितियों के लिए डिज़ाइन किया गया है जहां एक पक्ष, संदेश तैयार करने वाला, संदेश भेजने वाले या दूसरे पक्ष द्वारा हस्ताक्षर किए जाने वाले संदेश के सभी भाग या संदेश जनरेट करता है। यदि संदेश तैयार करने वाला क्रिप्टोग्राफ़िक हैश फ़ंक्शन टकरावों (यानी एक ही हैश मान का निर्माण करने वाले दो संदेश) को खोजने में सक्षम है, तो वे संदेश के सार्थक संस्करण तैयार कर सकते हैं जो एक ही हैश मान और डिजिटल हस्ताक्षर का उत्पादन करेंगे, लेकिन विभिन्न परिणामों के साथ (जैसे ($ 10 के बजाय $ 1,000,000 को एक खाते में स्थानांतरित करना)। क्रिप्टोग्राफ़िक हैश फ़ंक्शंस को टकराव प्रतिरोध के साथ एक प्रमुख लक्ष्य के रूप में तैयार किया गया है, लेकिन क्रिप्टोग्राफ़िक हैश फ़ंक्शन पर हमला करने में वर्तमान एकाग्रता एक दिए गए क्रिप्टोग्राफ़िक हैश फ़ंक्शन में अपेक्षा से कम टकराव प्रतिरोध प्रदान कर सकता है। रैंडमाइज्ड हैशिंग एक संभावित दो या दो से अधिक संदेश उत्पन्न कर सकता है जो अंततः हस्ताक्षरकर्ता को अतिरिक्त सुरक्षा प्रदान करता है जो अंततः डिजिटल हस्ताक्षर निर्माण प्रक्रिया के दौरान समान हैश मूल्य प्राप्त करते हैं - भले ही यह हैश फ़ंक्शन के लिए टकराव खोजने के लिए व्यावहारिक हो। हालाँकि, रैंडमाइज्ड हैशिंग का उपयोग डिजिटल हस्ताक्षर द्वारा प्रदान की गई सुरक्षा की मात्रा को कम कर सकता है जब हस्ताक्षरकर्ता द्वारा संदेश के सभी भाग तैयार किए जाते हैं।

( NIST SP-800-106 "डिजिटल हस्ताक्षरों के लिए यादृच्छिक बेड़ा" )

BLAKE2 में नमक को एक बार के इनपुट के रूप में संसाधित किया जाता है, जो कि प्रत्येक संपीड़न फ़ंक्शन के लिए इनपुट के रूप में, आरम्भिकरण के दौरान होता है।

चेतावनी

BLAKE2 या किसी अन्य सामान्य-उद्देश्य वाले क्रिप्टोग्राफ़िक हैश फ़ंक्शन जैसे कि SHA-256 के साथ नमकीन हैशिंग (या सिर्फ हैशिंग), हैशिंग पासवर्ड के लिए उपयुक्त नहीं है। अधिक जानकारी के लिए BLAKE2 FAQ देखें।

>>> import os
>>> from hashlib import blake2b
>>> msg = b'some message'
>>> # Calculate the first hash with a random salt.
>>> salt1 = os.urandom(blake2b.SALT_SIZE)
>>> h1 = blake2b(salt=salt1)
>>> h1.update(msg)
>>> # Calculate the second hash with a different random salt.
>>> salt2 = os.urandom(blake2b.SALT_SIZE)
>>> h2 = blake2b(salt=salt2)
>>> h2.update(msg)
>>> # The digests are different.
>>> h1.digest() != h2.digest()
True

निजीकरण

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

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

( स्केन हैश फंक्शन फ़ैमिली , पृष्ठ 21)

BLAKE2 व्यक्ति तर्क को बाइट्स पास करके व्यक्तिगत किया जा सकता है:

>>> from hashlib import blake2b
>>> FILES_HASH_PERSON = b'MyApp Files Hash'
>>> BLOCK_HASH_PERSON = b'MyApp Block Hash'
>>> h = blake2b(digest_size=32, person=FILES_HASH_PERSON)
>>> h.update(b'the same content')
>>> h.hexdigest()
'20d9cd024d4fb086aae819a1432dd2466de12947831b75c5a30cf2676095d3b4'
>>> h = blake2b(digest_size=32, person=BLOCK_HASH_PERSON)
>>> h.update(b'the same content')
>>> h.hexdigest()
'cf68fb5761b9c44e7878bfb2c4c9aea52264a80b75005e65619778de59f383a3'

कुंजीकृत मोड के साथ एक साथ निजीकरण का उपयोग एक एकल से विभिन्न कुंजी प्राप्त करने के लिए भी किया जा सकता है।

>>> from hashlib import blake2s
>>> from base64 import b64decode, b64encode
>>> orig_key = b64decode(b'Rm5EPJai72qcK3RGBpW3vPNfZy5OZothY+kHY6h21KM=')
>>> enc_key = blake2s(key=orig_key, person=b'kEncrypt').digest()
>>> mac_key = blake2s(key=orig_key, person=b'kMAC').digest()
>>> print(b64encode(enc_key).decode('utf-8'))
rbPb15S/Z9t+agffno5wuhB77VbRi6F9Iv2qIxU7WHw=
>>> print(b64encode(mac_key).decode('utf-8'))
G9GtHFE1YluXY1zWPlYk1e/nWfu0WSEb0KRcjhDeP/o=

ट्री मोड

यहाँ दो पत्ती के नोड्स के साथ एक न्यूनतम पेड़ हैशिंग का उदाहरण दिया गया है:

  10
 /  \
00  01

यह उदाहरण 64-बाइट के आंतरिक डाइजेस्ट का उपयोग करता है, और 32-बाइट के अंतिम पाचन को लौटाता है:

>>> from hashlib import blake2b
>>>
>>> FANOUT = 2
>>> DEPTH = 2
>>> LEAF_SIZE = 4096
>>> INNER_SIZE = 64
>>>
>>> buf = bytearray(6000)
>>>
>>> # Left leaf
... h00 = blake2b(buf[0:LEAF_SIZE], fanout=FANOUT, depth=DEPTH,
...               leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
...               node_offset=0, node_depth=0, last_node=False)
>>> # Right leaf
... h01 = blake2b(buf[LEAF_SIZE:], fanout=FANOUT, depth=DEPTH,
...               leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
...               node_offset=1, node_depth=0, last_node=True)
>>> # Root node
... h10 = blake2b(digest_size=32, fanout=FANOUT, depth=DEPTH,
...               leaf_size=LEAF_SIZE, inner_size=INNER_SIZE,
...               node_offset=0, node_depth=1, last_node=True)
>>> h10.update(h00.digest())
>>> h10.update(h01.digest())
>>> h10.hexdigest()
'3ad2a9b37c6070e374c7a8c508fe20ca86b6ed54e286e93a0318e95e881db5aa'

क्रेडिट

BLAKE2 को जीन-फिलिप ऑमेसन , सैमुअल नेव्स , ज़ूको विलकॉक्स-ओ'हर्न , और जीन-फिलिप एस डुमासन , लुका हेन्जेन , विली मेयर और राफेल सी.डब्ल्यू.डब्ल्यू द्वारा निर्मित SHA-3 फाइनलिस्ट BLAKE पर आधारित क्रिश्चियन विनरलेइन द्वारा डिजाइन किया गया था। फान

यह डैनियल जे। बर्नस्टीन द्वारा डिजाइन किए गए ChaCha सिफर से कोर एल्गोरिदम का उपयोग करता है।

Stdlib कार्यान्वयन pyblake2 मॉड्यूल पर आधारित है। यह शमूएल नेवेस द्वारा लिखित सी कार्यान्वयन पर आधारित दिमित्री चेस्टनिख द्वारा लिखा गया था। प्रलेखन pyblake2 से कॉपी किया गया था और दिमित्री चेस्टनिख द्वारा लिखा गया था

क्रिश्चियन हीम्स द्वारा पायथन के लिए सी कोड आंशिक रूप से फिर से लिखा गया था।

निम्न सार्वजनिक डोमेन समर्पण C हैश फ़ंक्शन कार्यान्वयन, एक्सटेंशन कोड और इस प्रलेखन दोनों के लिए लागू होता है:

कानून के तहत संभव हद तक, लेखक (ओं) ने इस सॉफ़्टवेयर के सभी कॉपीराइट और संबंधित और पड़ोसी अधिकारों को दुनिया भर में सार्वजनिक डोमेन को समर्पित किया है। यह सॉफ्टवेयर बिना किसी वारंटी के वितरित किया जाता है।

आपको इस सॉफ़्टवेयर के साथ CC0 पब्लिक डोमेन समर्पण की एक प्रति प्राप्त होनी चाहिए। यदि नहीं, तो https://creativecommons.org/publicdomain/zero/1.0/

क्रिएटिव कॉमन्स पब्लिक डोमेन समर्पण 1.0 के अनुसार निम्नलिखित लोगों ने विकास और परियोजना और सार्वजनिक डोमेन में अपने परिवर्तनों में योगदान दिया है।

  • एलेक्जेंडर सोकोलोव्स्की

यह भी देखें

Module hmac
हैश का उपयोग करके संदेश प्रमाणीकरण कोड उत्पन्न करने के लिए एक मॉड्यूल।
Module base64
गैर-बाइनरी वातावरण के लिए बाइनरी हैश को एन्कोड करने का एक और तरीका।
https://blake2.net
आधिकारिक BLAKE2 वेबसाइट।
https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2.pdf
सुरक्षित हैश एल्गोरिथ्म पर FIPS 180-2 प्रकाशन।
https://en.wikipedia.org/wiki/Cryptographic_hash_function#Cryptographic_hash_algorithms
जानकारी के साथ विकिपीडिया लेख जिस पर एल्गोरिदम ने मुद्दों को जाना है और उनके उपयोग के बारे में इसका क्या अर्थ है।
https://www.ietf.org/rfc/rfc2898.txt
PKCS # 5: पासवर्ड-आधारित क्रिप्टोग्राफी विनिर्देश संस्करण 2.0