आर्गन2
From Vigyanwiki
आर्गन2 एक प्रमुख व्युत्पत्ति कार्य है जिसे 2015 पासवर्ड हैशिंग प्रतियोगिता के विजेता के रूप में चुना गया था।[1][2] यह लक्समबर्ग विश्वविद्यालय से एलेक्स बिरुकोव, डैनियल दीनू और दिमित्री खोवराटोविच द्वारा डिजाइन किया गया था।[3] आर्गन2 का संदर्भ कार्यान्वयन क्रिएटिव कॉमन्स CC0 लाइसेंस (यानी पब्लिक डोमेन) या अपाचे लाइसेंस 2.0 के तहत जारी किया गया है, और तीन संबंधित संस्करण प्रदान करता है:
- आर्गन2d GPU पासवर्ड क्रैकिंग के प्रतिरोध को अधिकतम करता है। यह एक पासवर्ड निर्भर क्रम में मेमोरी ऐरे को एक्सेस करता है, जो टाइम-मेमोरी ट्रेड-ऑफ (टीएमटीओ) अटैक्स की संभावना को कम करता है, लेकिन संभावित साइड-चैनल अटैक का परिचय देता है।
- आर्गन2i को साइड-चैनल अटैक्स का विरोध करने के लिए अनुकूलित किया गया है। यह एक पासवर्ड स्वतंत्र क्रम में मेमोरी ऐरे को एक्सेस करता है।
- आर्गन2id एक संकर (हाइब्रिड) संस्करण है। यह पहली छमाही पास ओवर मेमोरी के लिए आर्गन2i दृष्टिकोण और बाद के पास के लिए आर्गन2d दृष्टिकोण का अनुसरण करता है। RFC 9106 आर्गन2id का उपयोग करने की अनुशंसा करता है यदि आप प्रकारों के बीच अंतर नहीं जानते हैं या आप साइड-चैनल अटैक को एक व्यवहार्य खतरा मानते हैं।[4]
सभी तीन मोड तीन मापदंडों द्वारा विनिर्देशन की अनुमति देते हैं जो नियंत्रित करते हैं:
- निष्पादन समय
- आवश्यक मेमोरी
- समानता की डिग्री
क्रिप्टैनालिसिस
अटैक जबकि आर्गन2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, आर्गन2i फ़ंक्शन पर दो प्रकाशित अटैक हैं। पहला अटैक केवल आर्गन2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।[5]
पहले अटैक से पता चलता है कि वांछित स्थान के एक चौथाई और पांचवे हिस्से के बीच बिना किसी समय दंड के एकल-पास आर्गन2i फ़ंक्शन की गणना करना संभव है, और केवल N/e (≈ N/2.72) का उपयोग करके एक बहु-पास आर्गन2i की गणना करना संभव है, स्थान और बिना किसी समय दंड (पेनाल्टी) के।[6] आर्गन2 लेखकों के अनुसार, यह अटैक वेक्टर संस्करण 1.3 में तय किया गया था।[7]
दूसरे अटैक से पता चलता है कि आर्गन2i की गणना एक एल्गोरिथ्म द्वारा की जा सकती है जिसमें जटिलता O(n7/4 लॉग (n)) मापदंडों के सभी विकल्पों के लिए σ (अंतरिक्ष लागत), τ (समय की लागत), और थ्रेड-काउंट जैसे कि n=σ∗τ.[8] आर्गन2 लेखकों का दावा है कि यदि आर्गन2i का उपयोग तीन या अधिक पास के साथ किया जाता है तो यह अटैक कुशल नहीं है।[7]हालांकि, जोएल अल्वेन और यिर्मयाह ब्लॉकी ने अटैक में सुधार किया और दिखाया कि अटैक को विफल करने के लिए, आर्गन2i v1.3 को मेमोरी पर 10 से अधिक पास की जरूरत है।[5]
एल्गोरिथम
<अवधि शैली = रंग: नीला; > समारोह आर्गन2
<अवधि शैली = रंग: नीला; > इनपुट्स:
पासवर्ड (पी): बाइट्स (0..232-1) पासवर्ड (या संदेश) को हैश किया जाना है
नमक (एस): बाइट्स (8..232-1) नमक (पासवर्ड हैशिंग के लिए अनुशंसित 16 बाइट्स)
समांतरता (पी): संख्या (1..224-1) समानता की डिग्री (अर्थात थ्रेड्स की संख्या)
टैगलेंथ (टी): संख्या (4..232-1) लौटाए गए बाइट्स की वांछित संख्या
मेमोरीसाइजकेबी (एम): संख्या (8p..232-1) उपयोग की जाने वाली मेमोरी की मात्रा (किबिबाइट में)
पुनरावृत्तियों (टी): संख्या (1..232-1) प्रदर्शन करने के लिए पुनरावृत्तियों की संख्या
संस्करण (वी): संख्या (0x13) वर्तमान संस्करण 0x13 (19 दशमलव) है
कुंजी (के): बाइट्स (0..232-1) वैकल्पिक कुंजी (इरेटा: पीडीएफ 0..32 बाइट्स कहता है, आरएफसी 0..2 कहता है32 बाइट्स)
संबद्ध डेटा (एक्स): बाइट्स (0..232-1) वैकल्पिक स्वैच्छिक अतिरिक्त डेटा
हैशटाइप (वाई): संख्या (0=आर्गन2d, 1=आर्गन2i, 2=आर्गन2id)
<अवधि शैली = रंग: नीला; >आउटपुट:
टैग: बाइट्स (टैग लंबाई) परिणामस्वरूप उत्पन्न बाइट, टैगलम्बाई बाइट लंबा
<अवधि शैली = रंग: हरा; > प्रारंभिक 64-बाइट ब्लॉक एच उत्पन्न करें0.
सभी इनपुट मापदंडों को जोड़ा जाता है और अतिरिक्त एन्ट्रॉपी के स्रोत के रूप में इनपुट किया जाता है।
इरेटा: RFC का कहना है कि H0 64-बिट्स है; पीडीएफ कहते हैं एच0 64-बाइट है।
इरेटा: आरएफसी का कहना है कि हैश एच ^ है, पीडीएफ कहता है कि यह ℋ है (लेकिन दस्तावेज नहीं है कि ℋ क्या है)। यह वास्तव में ब्लेक2बी है।
वेरिएबल लेंथ आइटम्स को उनकी लंबाई के साथ 32-बिट लिट्ल-एंडियन इंटिजर के रूप में जोड़ा जाता है।
बफर ← समांतरता ∥ टैग लंबाई ∥ स्मृति आकार केबी ∥ पुनरावृत्तियों ∥ संस्करण ∥ हैशटाइप
∥ लंबाई (पासवर्ड) ∥ पासवर्ड
∥ लंबाई (नमक) ∥ नमक
∥ लंबाई (कुंजी) ∥ कुंजी
∥ लंबाई (एसोसिएटेड डेटा) ∥ संबद्ध डेटा
एच0 ← ब्लेक2बी(बफर, 64) <विस्तार शैली= रंग:हरा; > // ब्लेक2बी का डिफ़ॉल्ट हैश आकार 64-बाइट्स है
<अवधि शैली = रंग: हरा; > मेमोरीसाइज़केबी को 4*समानांतर किबिबाइट के निकटतम गुणक में राउंड डाउन करके 1 KB ब्लॉक की संख्या की गणना करें
ब्लॉककाउंट ← फ्लोर (मेमोरी साइजकेबी, 4*पैरेललिज्म)
<अवधि शैली = रंग: हरा; >1 KiB ब्लॉक की द्वि-आयामी सरणी आवंटित करें (समानता पंक्तियां x कॉलमकाउंट कॉलम)
कॉलमकाउंट ← ब्लॉककाउंट / समांतरता; <अवधि शैली = रंग: हरा; >// RFC में, columnCount को 'q' कहा जाता है
<अवधि शैली = रंग: हरा; > प्रत्येक लेन (यानी पंक्ति) के पहले और दूसरे ब्लॉक (यानी कॉलम शून्य और एक) की गणना करें
'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >प्रत्येक पंक्ति के लिए
बीi[0] ← हैश (एच0 ∥ 0 ∥ i, 1024) //1024-बाइट डाइजेस्ट जनरेट करें
बीi[1] ← हैश (एच0 ∥ 1 ∥ i, 1024) //1024-बाइट डाइजेस्ट जनरेट करें
<अवधि शैली = रंग: हरा; >प्रत्येक लेन के शेष स्तंभों की गणना करें
'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >//प्रत्येक पंक्ति के लिए
'for' j ← 2 'to' columnCount-1 'do' //बाद के हर कॉलम के लिए
<अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह आर्गन2i, आर्गन2d, या आर्गन2id है (अनुभाग 3.4 देखें)
i′, j′ ← GetBlockIndexes(i, j) //GetBlockIndexes फ़ंक्शन परिभाषित नहीं है
बीi[जे] = जी (बीi[जे-1], बीi′[जे']) <विस्तार शैली = रंग: हरा; >//G हैश फ़ंक्शन परिभाषित नहीं है
<अवधि शैली = रंग: हरा; > पुनरावृति > 1 होने पर और पास हो जाता है
nIteration के लिए ← 2 पुनरावृत्तियों के लिए करते हैं
for i ← 0 to Parallelism-1 do प्रत्येक पंक्ति के लिए
j ← 0 के लिए columnCount-1 do //बाद के हर कॉलम के लिए
<अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह आर्गन2i, आर्गन2d, या आर्गन2id है (अनुभाग 3.4 देखें)
i′, j′ ← GetBlockIndexes(i, j)
अगर जे == 0 तो
बीi[0] = बीi[0] एक्सोर जी (बीi[स्तंभ संख्या-1], बीi′[जे'])
अन्य
बीi[जे] = बीi[जे] एक्सोर जी (बीi[जे-1], बीi′[जे'])
<अवधि शैली = रंग: हरा; > प्रत्येक पंक्ति के अंतिम कॉलम के XOR के रूप में अंतिम ब्लॉक C की गणना करें
सी ← बी0[स्तंभ संख्या-1]
for i ← 1 to Parallelism-1 do
सी ← सी एक्सोर बीi[स्तंभ संख्या-1]
<अवधि शैली = रंग: हरा; > गणना आउटपुट टैग
वापसी हैश (सी, टैग लम्बाई)
चर-लंबाई हैश फ़ंक्शन
आर्गन2 एक हैश फ़ंक्शन का उपयोग करता है जो 232 तक डाइजेस्ट उत्पन्न करने में सक्षम है बाइट लंबा। यह हैश फ़ंक्शन आंतरिक रूप से ब्लेक 2 पर बनाया गया है।
<अवधि शैली = रंग: नीला; >फ़ंक्शन हैश (संदेश, डाइजेस्ट आकार)
<अवधि शैली = रंग: नीला; > इनपुट्स:
संदेश: बाइट्स (0..232-1) संदेश हैश किया जाना है
डाइजेस्टसाइज: पूर्णांक (1..232) लौटाई जाने वाली बाइट की वांछित संख्या
<अवधि शैली = रंग: नीला; >आउटपुट:
डाइजेस्ट: बाइट्स (digestSize) परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी
<अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक2बी का उपयोग करके बनाया गया है, जो उत्पन्न करने में सक्षम है
2 तक पचता है32 बाइट।
<अवधि शैली = रंग: हरा; > यदि अनुरोधित डाइजेस्ट आकार 64-बाइट या उससे कम है, तो हम सीधे ब्लेक2बी का उपयोग करते हैं
if (digestSize <= 64) तब
वापसी Blake2b(digestSize ∥ message, डाइजेस्टसाइज़) //संदेश बाइट्स के साथ 32-बिट छोटे एंडियन डाइजेस्ट आकार को संयोजित करें
<अवधि शैली = रंग: हरा; > 64-बाइट्स से अधिक वांछित हैश के लिए (उदाहरण के लिए आर्गन2 ब्लॉक के लिए 1024 बाइट्स),
हम आवश्यक 64-बाइट ब्लॉकों की दोगुनी संख्या उत्पन्न करने के लिए ब्लेक2बी का उपयोग करते हैं,
और उसके बाद प्रत्येक ब्लॉक से केवल 32-बाइट का उपयोग करें
<अवधि शैली = रंग: हरा; > पूरे ब्लॉक की संख्या की गणना करें (यह जानते हुए कि हम प्रत्येक से केवल 32-बाइट का उपयोग करने जा रहे हैं)
आर ← सील (डाइजेस्ट साइज/32)-2;
<अवधि शैली = रंग: हरा; > संपूर्ण ब्लॉक उत्पन्न करें।
<अवधि शैली = रंग: हरा; >प्रारंभिक ब्लॉक संदेश से उत्पन्न होता है
वी1 ← ब्लेक2बी (डाइजेस्टसाइज ∥ संदेश, 64);
<अवधि शैली = रंग: हरा; > बाद के ब्लॉक पिछले ब्लॉकों से उत्पन्न होते हैं
मैं ← 2 से आर करने के लिए
वीi ← ब्लेक2बी (वीi-1, 64)
<अवधि शैली = रंग: हरा; >अंतिम (संभवतः आंशिक) ब्लॉक उत्पन्न करें
partialBytesNeeded ← डाइजेस्टसाइज़ - 32*r;
वीr+1 ← ब्लेक2बी (वीr, आंशिक बाइट्स की जरूरत है)
<अवधि शैली = रंग: हरा; > प्रत्येक ब्लॉक V के पहले 32-बाइट्स को सम्मिलित करेंi
(संभवतः आंशिक अंतिम ब्लॉक को छोड़कर, जिसे हम पूरी चीज़ लेते हैं)
<अवधि शैली = रंग: हरा; > चलो एi ब्लॉक वी के निचले 32-बाइट्स का प्रतिनिधित्व करेंi</अवधि> वापसी ए1 ∥ ए2 ∥ ... ∥ एr ∥ वीr+1
संदर्भ
- ↑ "Password Hashing Competition"
- ↑ Jos Wetzels (2016-02-08). "Open Sesame: The Password Hashing Competition and Argon2". arXiv:1602.03097 [cs.CR].
- ↑ Argon2: the memory-hard function for password hashing and other applications, Alex Biryukov, et al, October 1, 2015
- ↑ "Argon2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications". Retrieved September 9, 2021.
- ↑ 5.0 5.1 Joël Alwen; Jeremiah Blocki (2016-08-05). Towards Practical Attacks on Argon2i and Balloon Hashing (PDF) (Report).
- ↑ Henry; Corrigan-Gibbs; Dan Boneh; Stuart Schechter (2016-01-14). Balloon Hashing: Provably Space-Hard Hash Functions with Data-Independent Access Patterns (PDF) (Report).
- ↑ 7.0 7.1 "[Cfrg] Argon2 v.1.3". www.ietf.org. Retrieved 2016-10-30.
- ↑ Joël Alwen; Jeremiah Blocki (2016-02-19). कुशल रूप से डेटा-स्वतंत्र मेमोरी-हार्ड फ़ंक्शंस की गणना करना (PDF) (Report).
बाहरी संबंध
- आर्गन2 source code repository on Github
- आर्गन2 specification
- Password Hashing Competition
- Uni.Lu आर्गन2 Page
- Balloon Hashing: A Memory-Hard Function Providing Provable Protection Against Sequential Attacks
- RFC 9106 आर्गन2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications
