आर्गन2: Difference between revisions

From Vigyanwiki
m (Deepak moved page हम वापिस आ गये to आर्गन2 without leaving a redirect)
No edit summary
Line 1: Line 1:
{{short description|Password-based key derivation function created in 2015}}
{{short description|Password-based key derivation function created in 2015}}
{{Primary sources|date=January 2016}}
आर्गन2 एक प्रमुख व्युत्पत्ति कार्य है जिसे 2015 [[पासवर्ड हैशिंग प्रतियोगिता]] के विजेता के रूप में चुना गया था।<ref>[https://password-hashing.net/ "Password Hashing Competition"]</ref><ref>{{cite arXiv |author=Jos Wetzels |date=2016-02-08 |title=Open Sesame: The Password Hashing Competition and Argon2 |class=cs.CR |eprint=1602.03097 }}</ref> यह [[लक्समबर्ग विश्वविद्यालय]] से [[ एलेक्स बिरुकोव | एलेक्स बिरुकोव]], डैनियल दीनू और [[दिमित्री खोवराटोविच]] द्वारा डिजाइन किया गया था।<ref>[https://password-hashing.net/argon2-specs.pdf Argon2: the memory-hard function for password hashing and other applications], Alex Biryukov, et al, October 1, 2015</ref> आर्गन2 का संदर्भ कार्यान्वयन [[Creative Commons CC0|क्रिएटिव  कॉमन्स CC0]] लाइसेंस (यानी पब्लिक डोमेन) या अपाचे लाइसेंस 2.0 के तहत जारी किया गया है, और तीन संबंधित संस्करण प्रदान करता है:
Argon2 एक प्रमुख व्युत्पत्ति कार्य है जिसे 2015 [[पासवर्ड हैशिंग प्रतियोगिता]] के विजेता के रूप में चुना गया था।<ref>[https://password-hashing.net/ "Password Hashing Competition"]</ref><ref>{{cite arXiv |author=Jos Wetzels |date=2016-02-08 |title=Open Sesame: The Password Hashing Competition and Argon2 |class=cs.CR |eprint=1602.03097 }}</ref> यह [[लक्समबर्ग विश्वविद्यालय]] से [[ एलेक्स बिरुकोव ]], डैनियल दीनू और [[दिमित्री खोवराटोविच]] द्वारा डिजाइन किया गया था।<ref>[https://password-hashing.net/argon2-specs.pdf Argon2: the memory-hard function for password hashing and other applications], Alex Biryukov, et al, October 1, 2015</ref> Argon2 का संदर्भ कार्यान्वयन [[Creative Commons CC0]] लाइसेंस (यानी सार्वजनिक डोमेन) या Apache लाइसेंस|Apache लाइसेंस 2.0 के तहत जारी किया गया है, और तीन संबंधित संस्करण प्रदान करता है:


*Argon2d GPU [[पासवर्ड क्रैकिंग]] के प्रतिरोध को अधिकतम करता है। यह एक पासवर्ड निर्भर क्रम में मेमोरी ऐरे को एक्सेस करता है, जो टाइम-मेमोरी ट्रेड-ऑफ (टीएमटीओ) हमलों की संभावना को कम करता है, लेकिन संभावित साइड-चैनल हमलों का परिचय देता है।
*आर्गन2d GPU [[पासवर्ड क्रैकिंग]] के प्रतिरोध को अधिकतम करता है। यह एक पासवर्ड निर्भर क्रम में मेमोरी ऐरे को एक्सेस करता है, जो टाइम-मेमोरी ट्रेड-ऑफ (टीएमटीओ) अटैक्स की संभावना को कम करता है, लेकिन संभावित साइड-चैनल अटैक का परिचय देता है।
*Argon2i को साइड-चैनल हमलों का विरोध करने के लिए अनुकूलित किया गया है। यह एक पासवर्ड स्वतंत्र क्रम में मेमोरी ऐरे को एक्सेस करता है।
*आर्गन2i को साइड-चैनल अटैक्स का विरोध करने के लिए अनुकूलित किया गया है। यह एक पासवर्ड स्वतंत्र क्रम में मेमोरी ऐरे को एक्सेस करता है।
*Argon2id एक संकर संस्करण है। यह पहली छमाही पास ओवर मेमोरी के लिए Argon2i दृष्टिकोण और बाद के पास के लिए Argon2d दृष्टिकोण का अनुसरण करता है। {{IETF RFC|9106}} Argon2id का उपयोग करने की अनुशंसा करता है यदि आप प्रकारों के बीच अंतर नहीं जानते हैं या आप साइड-चैनल हमलों को एक व्यवहार्य खतरा मानते हैं।<ref>{{cite web|url=https://www.rfc-editor.org/rfc/rfc9106.html|title=Argon2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications|access-date= September 9, 2021}}</ref>
*आर्गन2id एक संकर (हाइब्रिड) संस्करण है। यह पहली छमाही पास ओवर मेमोरी के लिए आर्गन2i दृष्टिकोण और बाद के पास के लिए आर्गन2d दृष्टिकोण का अनुसरण करता है। {{IETF RFC|9106}} आर्गन2id का उपयोग करने की अनुशंसा करता है यदि आप प्रकारों के बीच अंतर नहीं जानते हैं या आप साइड-चैनल अटैक को एक व्यवहार्य खतरा मानते हैं।<ref>{{cite web|url=https://www.rfc-editor.org/rfc/rfc9106.html|title=Argon2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications|access-date= September 9, 2021}}</ref>
सभी तीन मोड तीन मापदंडों द्वारा विनिर्देशन की अनुमति देते हैं जो नियंत्रित करते हैं:
सभी तीन मोड तीन मापदंडों द्वारा विनिर्देशन की अनुमति देते हैं जो नियंत्रित करते हैं:
*निष्पादन समय
*निष्पादन समय
*स्मृति आवश्यक है
*मेमोरी आवश्यक है
* समानता की डिग्री
* समानता की डिग्री


== क्रिप्टैनालिसिस ==
== क्रिप्टैनालिसिस ==


जबकि Argon2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, Argon2i फ़ंक्शन पर दो प्रकाशित हमले हैं। पहला हमला केवल Argon2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।<ref name="blocki"></ref>
अटैक जबकि आर्गन2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, आर्गन2i फ़ंक्शन पर दो प्रकाशित अटैक हैं। पहला अटैक केवल आर्गन2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।<ref name="blocki"></ref>
पहले हमले से पता चलता है कि वांछित स्थान के एक चौथाई और पांचवे हिस्से के बीच बिना किसी समय दंड के एकल-पास Argon2i फ़ंक्शन की गणना करना संभव है, और केवल का उपयोग करके एक बहु-पास Argon2i की गणना करना संभव है {{mvar|N}}/{{mvar|e}} (≈ {{mvar|N}}/2.72) बिना किसी समय दंड के स्थान।<ref>{{cite report |author1=Henry |author2=Corrigan-Gibbs |author3=Dan Boneh |author4=Stuart Schechter |date=2016-01-14 |title=Balloon Hashing: Provably Space-Hard Hash Functions with Data-Independent Access Patterns |url=https://eprint.iacr.org/2016/027.pdf }}</ref> Argon2 लेखकों के अनुसार, यह अटैक वेक्टर संस्करण 1.3 में तय किया गया था।<ref name=":0">{{Cite web|url=https://www.ietf.org/mail-archive/web/cfrg/current/msg07948.html|title=[Cfrg] Argon2 v.1.3|website=www.ietf.org|access-date=2016-10-30}}</ref>
दूसरे हमले से पता चलता है कि Argon2i की गणना एक एल्गोरिथ्म द्वारा की जा सकती है जिसमें जटिलता O({{mvar|n}}<sup>7/4</sup> लॉग ({{mvar|n}})) मापदंडों के सभी विकल्पों के लिए {{mvar|σ}} (अंतरिक्ष लागत), {{mvar|τ}} (समय की लागत), और थ्रेड-काउंट जैसे कि {{mvar|n}}={{mvar|σ}}∗{{mvar|τ}}.<ref>{{cite report |author1=Joël Alwen |author2=Jeremiah Blocki |date=2016-02-19 |title=कुशल रूप से डेटा-स्वतंत्र मेमोरी-हार्ड फ़ंक्शंस की गणना करना|url=https://eprint.iacr.org/2016/115.pdf }}</ref> Argon2 लेखकों का दावा है कि यदि Argon2i का उपयोग तीन या अधिक पास के साथ किया जाता है तो यह हमला कुशल नहीं है।<ref name=":0" />हालांकि, जोएल अल्वेन और यिर्मयाह ब्लॉकी ने हमले में सुधार किया और दिखाया कि हमले को विफल करने के लिए, Argon2i v1.3 को मेमोरी पर 10 से अधिक पास की जरूरत है।<ref name="blocki">{{cite report |author1=Joël Alwen |author2=Jeremiah Blocki |date=2016-08-05 |title=Towards Practical Attacks on Argon2i and Balloon Hashing |url=https://eprint.iacr.org/2016/759.pdf }}</ref>


पहले अटैक से पता चलता है कि वांछित स्थान के एक चौथाई और पांचवे हिस्से के बीच बिना किसी समय दंड के एकल-पास आर्गन2i फ़ंक्शन की गणना करना संभव है, और केवल का उपयोग करके एक बहु-पास आर्गन2i की गणना करना संभव है {{mvar|N}}/{{mvar|e}} (≈ {{mvar|N}}/2.72) बिना किसी समय दंड के स्थान।<ref>{{cite report |author1=Henry |author2=Corrigan-Gibbs |author3=Dan Boneh |author4=Stuart Schechter |date=2016-01-14 |title=Balloon Hashing: Provably Space-Hard Hash Functions with Data-Independent Access Patterns |url=https://eprint.iacr.org/2016/027.pdf }}</ref> आर्गन2 लेखकों के अनुसार, यह अटैक वेक्टर संस्करण 1.3 में तय किया गया था।<ref name=":0">{{Cite web|url=https://www.ietf.org/mail-archive/web/cfrg/current/msg07948.html|title=[Cfrg] Argon2 v.1.3|website=www.ietf.org|access-date=2016-10-30}}</ref>


दूसरे अटैक से पता चलता है कि आर्गन2i की गणना एक एल्गोरिथ्म द्वारा की जा सकती है जिसमें जटिलता O({{mvar|n}}<sup>7/4</sup> लॉग ({{mvar|n}})) मापदंडों के सभी विकल्पों के लिए {{mvar|σ}} (अंतरिक्ष लागत), {{mvar|τ}} (समय की लागत), और थ्रेड-काउंट जैसे कि {{mvar|n}}={{mvar|σ}}∗{{mvar|τ}}.<ref>{{cite report |author1=Joël Alwen |author2=Jeremiah Blocki |date=2016-02-19 |title=कुशल रूप से डेटा-स्वतंत्र मेमोरी-हार्ड फ़ंक्शंस की गणना करना|url=https://eprint.iacr.org/2016/115.pdf }}</ref> आर्गन2 लेखकों का दावा है कि यदि आर्गन2i का उपयोग तीन या अधिक पास के साथ किया जाता है तो यह अटैक कुशल नहीं है।<ref name=":0" />हालांकि, जोएल अल्वेन और यिर्मयाह ब्लॉकी ने अटैक में सुधार किया और दिखाया कि अटैक को विफल करने के लिए, आर्गन2i v1.3 को मेमोरी पर 10 से अधिक पास की जरूरत है।<ref name="blocki">{{cite report |author1=Joël Alwen |author2=Jeremiah Blocki |date=2016-08-05 |title=Towards Practical Attacks on Argon2i and Balloon Hashing |url=https://eprint.iacr.org/2016/759.pdf }}</ref>
== एल्गोरिथम ==
== एल्गोरिथम ==


  <अवधि शैली = रंग: नीला; > समारोह </span> Argon2
  <अवधि शैली = रंग: नीला; > समारोह आर्गन2
     <अवधि शैली = रंग: नीला; > इनपुट्स:</span>
     <अवधि शैली = रंग: नीला; > इनपुट्स:
       पासवर्ड (पी): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >पासवर्ड (या संदेश) को हैश किया जाना है</span>
       पासवर्ड (पी): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >पासवर्ड (या संदेश) को हैश किया जाना है</span>
       नमक (एस): बाइट्स (8..2<sup>32</sup>-1) <span style= color:green; > नमक (पासवर्ड हैशिंग के लिए अनुशंसित 16 बाइट्स)</span>
       नमक (एस): बाइट्स (8..2<sup>32</sup>-1) <span style= color:green; > नमक (पासवर्ड हैशिंग के लिए अनुशंसित 16 बाइट्स)</span>
Line 31: Line 30:
       कुंजी (के): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >वैकल्पिक कुंजी (इरेटा: पीडीएफ 0..32 बाइट्स कहता है, आरएफसी 0..2 कहता है<sup>32</sup> बाइट्स)</span>
       कुंजी (के): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >वैकल्पिक कुंजी (इरेटा: पीडीएफ 0..32 बाइट्स कहता है, आरएफसी 0..2 कहता है<sup>32</sup> बाइट्स)</span>
       संबद्ध डेटा (एक्स): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >वैकल्पिक स्वैच्छिक अतिरिक्त डेटा</span>
       संबद्ध डेटा (एक्स): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >वैकल्पिक स्वैच्छिक अतिरिक्त डेटा</span>
       हैशटाइप (वाई): संख्या (0=Argon2d, 1=Argon2i, 2=Argon2id)
       हैशटाइप (वाई): संख्या (0=आर्गन2d, 1=आर्गन2i, 2=आर्गन2id)
     <अवधि शैली = रंग: नीला; >आउटपुट:</span>
     <अवधि शैली = रंग: नीला; >आउटपुट:
       टैग: बाइट्स (टैग लंबाई)<sup>  </sup> <span style= color:green; >परिणामस्वरूप उत्पन्न बाइट, टैगलम्बाई बाइट लंबा</span>
       टैग: बाइट्स (टैग लंबाई)<sup>  </sup> <span style= color:green; >परिणामस्वरूप उत्पन्न बाइट, टैगलम्बाई बाइट लंबा</span>
   
   
Line 39: Line 38:
     इरेटा: RFC का कहना है कि H<sub>0</sub> 64-बिट्स है; पीडीएफ कहते हैं एच<sub>0</sub> 64-बाइट है।
     इरेटा: RFC का कहना है कि H<sub>0</sub> 64-बिट्स है; पीडीएफ कहते हैं एच<sub>0</sub> 64-बाइट है।
     इरेटा: आरएफसी का कहना है कि हैश एच ^ है, पीडीएफ कहता है कि यह ℋ है (लेकिन दस्तावेज नहीं है कि ℋ क्या है)। यह वास्तव में ब्लेक2बी है।
     इरेटा: आरएफसी का कहना है कि हैश एच ^ है, पीडीएफ कहता है कि यह ℋ है (लेकिन दस्तावेज नहीं है कि ℋ क्या है)। यह वास्तव में ब्लेक2बी है।
     वेरिएबल लेंथ आइटम्स को उनकी लंबाई के साथ 32-बिट लिट्ल-एंडियन इंटिजर के रूप में जोड़ा जाता है।</span>
     वेरिएबल लेंथ आइटम्स को उनकी लंबाई के साथ 32-बिट लिट्ल-एंडियन इंटिजर के रूप में जोड़ा जाता है।
     बफर ← समांतरता ∥ टैग लंबाई ∥ स्मृति आकार केबी ∥ पुनरावृत्तियों ∥ संस्करण ∥ हैशटाइप
     बफर ← समांतरता ∥ टैग लंबाई ∥ स्मृति आकार केबी ∥ पुनरावृत्तियों ∥ संस्करण ∥ हैशटाइप
           ∥ लंबाई (पासवर्ड) ∥ पासवर्ड
           ∥ लंबाई (पासवर्ड) ∥ पासवर्ड
Line 45: Line 44:
           ∥ लंबाई (कुंजी) ∥ कुंजी
           ∥ लंबाई (कुंजी) ∥ कुंजी
           ∥ लंबाई (एसोसिएटेड डेटा) ∥ संबद्ध डेटा
           ∥ लंबाई (एसोसिएटेड डेटा) ∥ संबद्ध डेटा
     एच<sub>0</sub> ← ब्लेक2बी(बफर, 64) <विस्तार शैली= रंग:हरा; > // ब्लेक2बी का डिफ़ॉल्ट हैश आकार 64-बाइट्स</span> है
     एच<sub>0</sub> ← ब्लेक2बी(बफर, 64) <विस्तार शैली= रंग:हरा; > // ब्लेक2बी का डिफ़ॉल्ट हैश आकार 64-बाइट्स है
   
   
     <अवधि शैली = रंग: हरा; > मेमोरीसाइज़केबी को 4*समानांतर किबिबाइट</span> के निकटतम गुणक में राउंड डाउन करके 1 KB ब्लॉक की संख्या की गणना करें
     <अवधि शैली = रंग: हरा; > मेमोरीसाइज़केबी को 4*समानांतर किबिबाइट के निकटतम गुणक में राउंड डाउन करके 1 KB ब्लॉक की संख्या की गणना करें
     ब्लॉककाउंट ← फ्लोर (मेमोरी साइजकेबी, 4*पैरेललिज्म)
     ब्लॉककाउंट ← फ्लोर (मेमोरी साइजकेबी, 4*पैरेललिज्म)
   
   
     <अवधि शैली = रंग: हरा; >1 KiB ब्लॉक की द्वि-आयामी सरणी आवंटित करें (समानता पंक्तियां x कॉलमकाउंट कॉलम)</span>
     <अवधि शैली = रंग: हरा; >1 KiB ब्लॉक की द्वि-आयामी सरणी आवंटित करें (समानता पंक्तियां x कॉलमकाउंट कॉलम)
     कॉलमकाउंट ← ब्लॉककाउंट / समांतरता; <अवधि शैली = रंग: हरा; >// RFC में, columnCount को 'q'</span> कहा जाता है
     कॉलमकाउंट ← ब्लॉककाउंट / समांतरता; <अवधि शैली = रंग: हरा; >// RFC में, columnCount को 'q' कहा जाता है
   
   
     <अवधि शैली = रंग: हरा; > प्रत्येक लेन (यानी पंक्ति) के पहले और दूसरे ब्लॉक (यानी कॉलम शून्य और एक) की गणना करें</span>
     <अवधि शैली = रंग: हरा; > प्रत्येक लेन (यानी पंक्ति) के पहले और दूसरे ब्लॉक (यानी कॉलम शून्य और एक) की गणना करें
     'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >प्रत्येक पंक्ति के लिए</span>
     'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >प्रत्येक पंक्ति के लिए
       बी<sub>i</sub>[0] ← हैश (एच<sub>0</sub> ∥ 0 ∥ i, 1024) <span style= color:green; >//1024-बाइट डाइजेस्ट</span> जनरेट करें
       बी<sub>i</sub>[0] ← हैश (एच<sub>0</sub> ∥ 0 ∥ i, 1024) <span style= color:green; >//1024-बाइट डाइजेस्ट</span> जनरेट करें
       बी<sub>i</sub>[1] ← हैश (एच<sub>0</sub> ∥ 1 ∥ i, 1024) <span style= color:green; >//1024-बाइट डाइजेस्ट</span> जनरेट करें
       बी<sub>i</sub>[1] ← हैश (एच<sub>0</sub> ∥ 1 ∥ i, 1024) <span style= color:green; >//1024-बाइट डाइजेस्ट</span> जनरेट करें
   
   
     <अवधि शैली = रंग: हरा; >प्रत्येक लेन के शेष स्तंभों की गणना करें</span>
     <अवधि शैली = रंग: हरा; >प्रत्येक लेन के शेष स्तंभों की गणना करें
     'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >//प्रत्येक पंक्ति के लिए</span>
     'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >//प्रत्येक पंक्ति के लिए
       'for' j ← 2 'to' columnCount-1 'do' <span style= color:green; >//बाद के हर कॉलम के लिए</span>
       'for' j ← 2 'to' columnCount-1 'do' <span style= color:green; >//बाद के हर कॉलम के लिए</span>
           <अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह Argon2i, Argon2d, या Argon2id है (अनुभाग 3.4 देखें)</span>
           <अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह आर्गन2i, आर्गन2d, या आर्गन2id है (अनुभाग 3.4 देखें)
           i′, j′ ← GetBlockIndexes(i, j) <span style= color:green; >//GetBlockIndexes फ़ंक्शन परिभाषित नहीं है</span>
           i′, j′ ← GetBlockIndexes(i, j) <span style= color:green; >//GetBlockIndexes फ़ंक्शन परिभाषित नहीं है</span>
           बी<sub>i</sub>[जे] = जी (बी<sub>i</sub>[जे-1], बी<sub>i′</sub>[जे']) <विस्तार शैली = रंग: हरा; >//G हैश फ़ंक्शन परिभाषित नहीं है</span>
           बी<sub>i</sub>[जे] = जी (बी<sub>i</sub>[जे-1], बी<sub>i′</sub>[जे']) <विस्तार शैली = रंग: हरा; >//G हैश फ़ंक्शन परिभाषित नहीं है
   
   
     <अवधि शैली = रंग: हरा; > पुनरावृति > 1</span> होने पर और पास हो जाता है
     <अवधि शैली = रंग: हरा; > पुनरावृति > 1 होने पर और पास हो जाता है
     nIteration के लिए ← 2 पुनरावृत्तियों के लिए करते हैं
     nIteration के लिए ← 2 पुनरावृत्तियों के लिए करते हैं
       for i ← 0 to Parallelism-1 do <span style= color:green; >प्रत्येक पंक्ति के लिए</span>
       for i ← 0 to Parallelism-1 do <span style= color:green; >प्रत्येक पंक्ति के लिए</span>
         j ← 0 के लिए columnCount-1 do <span style= color:green; >//बाद के हर कॉलम के लिए</span>
         j ← 0 के लिए columnCount-1 do <span style= color:green; >//बाद के हर कॉलम के लिए</span>
             <अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह Argon2i, Argon2d, या Argon2id है (अनुभाग 3.4 देखें)</span>
             <अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह आर्गन2i, आर्गन2d, या आर्गन2id है (अनुभाग 3.4 देखें)
             i′, j′ ← GetBlockIndexes(i, j)
             i′, j′ ← GetBlockIndexes(i, j)
             अगर जे == 0 तो
             अगर जे == 0 तो
Line 76: Line 75:
               बी<sub>i</sub>[जे] = बी<sub>i</sub>[जे] एक्सोर जी (बी<sub>i</sub>[जे-1], बी<sub>i′</sub>[जे'])
               बी<sub>i</sub>[जे] = बी<sub>i</sub>[जे] एक्सोर जी (बी<sub>i</sub>[जे-1], बी<sub>i′</sub>[जे'])
   
   
     <अवधि शैली = रंग: हरा; > प्रत्येक पंक्ति के अंतिम कॉलम के XOR के रूप में अंतिम ब्लॉक C की गणना करें</span>
     <अवधि शैली = रंग: हरा; > प्रत्येक पंक्ति के अंतिम कॉलम के XOR के रूप में अंतिम ब्लॉक C की गणना करें
     सी ← बी<sub>0</sub>[स्तंभ संख्या-1]
     सी ← बी<sub>0</sub>[स्तंभ संख्या-1]
     for i ← 1 to Parallelism-1 do
     for i ← 1 to Parallelism-1 do
       सी ← सी एक्सोर बी<sub>i</sub>[स्तंभ संख्या-1]
       सी ← सी एक्सोर बी<sub>i</sub>[स्तंभ संख्या-1]
   
   
     <अवधि शैली = रंग: हरा; > गणना आउटपुट टैग </span>
     <अवधि शैली = रंग: हरा; > गणना आउटपुट टैग  
     वापसी हैश (सी, टैग लम्बाई)
     वापसी हैश (सी, टैग लम्बाई)


=== चर-लंबाई हैश फ़ंक्शन ===
=== चर-लंबाई हैश फ़ंक्शन ===


Argon2 एक हैश फ़ंक्शन का उपयोग करता है जो 2 तक डाइजेस्ट उत्पन्न करने में सक्षम है<sup>32</sup> बाइट लंबा। यह हैश फ़ंक्शन आंतरिक रूप से [[ब्लेक 2]] पर बनाया गया है।
आर्गन2 एक हैश फ़ंक्शन का उपयोग करता है जो 2<sup>32</sup> तक डाइजेस्ट उत्पन्न करने में सक्षम है बाइट लंबा। यह हैश फ़ंक्शन आंतरिक रूप से [[ब्लेक 2]] पर बनाया गया है।


  <अवधि शैली = रंग: नीला; >फ़ंक्शन</span> हैश (संदेश, डाइजेस्ट आकार)
  <अवधि शैली = रंग: नीला; >फ़ंक्शन हैश (संदेश, डाइजेस्ट आकार)
     <अवधि शैली = रंग: नीला; > इनपुट्स:</span>
     <अवधि शैली = रंग: नीला; > इनपुट्स:
       संदेश: बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >संदेश हैश किया जाना है</span>
       संदेश: बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >संदेश हैश किया जाना है</span>
       डाइजेस्टसाइज: पूर्णांक (1..2<sup>32</sup>) <span style= color:green; > लौटाई जाने वाली बाइट की वांछित संख्या</span>
       डाइजेस्टसाइज: पूर्णांक (1..2<sup>32</sup>) <span style= color:green; > लौटाई जाने वाली बाइट की वांछित संख्या</span>
     <अवधि शैली = रंग: नीला; >आउटपुट:</span>
     <अवधि शैली = रंग: नीला; >आउटपुट:
       डाइजेस्ट: बाइट्स (digestSize)<sup>  </sup> <span style= color:green; >परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी</span>
       डाइजेस्ट: बाइट्स (digestSize)<sup>  </sup> <span style= color:green; >परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी</span>
   
   
     <अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक2बी का उपयोग करके बनाया गया है, जो उत्पन्न करने में सक्षम है
     <अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक2बी का उपयोग करके बनाया गया है, जो उत्पन्न करने में सक्षम है
     2 तक पचता है<sup>32</sup> बाइट।</span>
     2 तक पचता है<sup>32</sup> बाइट।
   
   
     <अवधि शैली = रंग: हरा; > यदि अनुरोधित डाइजेस्ट आकार 64-बाइट या उससे कम है, तो हम सीधे ब्लेक2बी का उपयोग करते हैं</span>
     <अवधि शैली = रंग: हरा; > यदि अनुरोधित डाइजेस्ट आकार 64-बाइट या उससे कम है, तो हम सीधे ब्लेक2बी का उपयोग करते हैं
     if (digestSize <= 64) तब
     if (digestSize <= 64) तब
       वापसी Blake2b(digestSize ∥ message, डाइजेस्टसाइज़) <span style= color:green; >//संदेश बाइट्स के साथ 32-बिट छोटे एंडियन डाइजेस्ट आकार को संयोजित करें</span>
       वापसी Blake2b(digestSize ∥ message, डाइजेस्टसाइज़) <span style= color:green; >//संदेश बाइट्स के साथ 32-बिट छोटे एंडियन डाइजेस्ट आकार को संयोजित करें</span>
   
   
     <अवधि शैली = रंग: हरा; > 64-बाइट्स से अधिक वांछित हैश के लिए (उदाहरण के लिए Argon2 ब्लॉक के लिए 1024 बाइट्स),
     <अवधि शैली = रंग: हरा; > 64-बाइट्स से अधिक वांछित हैश के लिए (उदाहरण के लिए आर्गन2 ब्लॉक के लिए 1024 बाइट्स),
     हम आवश्यक 64-बाइट ब्लॉकों की दोगुनी संख्या उत्पन्न करने के लिए ब्लेक2बी का उपयोग करते हैं,
     हम आवश्यक 64-बाइट ब्लॉकों की दोगुनी संख्या उत्पन्न करने के लिए ब्लेक2बी का उपयोग करते हैं,
     और उसके बाद प्रत्येक ब्लॉक से केवल 32-बाइट का उपयोग करें</span>
     और उसके बाद प्रत्येक ब्लॉक से केवल 32-बाइट का उपयोग करें
   
   
     <अवधि शैली = रंग: हरा; > पूरे ब्लॉक की संख्या की गणना करें (यह जानते हुए कि हम प्रत्येक से केवल 32-बाइट का उपयोग करने जा रहे हैं)</span>
     <अवधि शैली = रंग: हरा; > पूरे ब्लॉक की संख्या की गणना करें (यह जानते हुए कि हम प्रत्येक से केवल 32-बाइट का उपयोग करने जा रहे हैं)
     आर ← सील (डाइजेस्ट साइज/32)-2;
     आर ← सील (डाइजेस्ट साइज/32)-2;
   
   
     <अवधि शैली = रंग: हरा; > संपूर्ण ब्लॉक उत्पन्न करें।</span>
     <अवधि शैली = रंग: हरा; > संपूर्ण ब्लॉक उत्पन्न करें।
     <अवधि शैली = रंग: हरा; >प्रारंभिक ब्लॉक संदेश से उत्पन्न होता है</span>
     <अवधि शैली = रंग: हरा; >प्रारंभिक ब्लॉक संदेश से उत्पन्न होता है
     वी<sub>1</sub> ← ब्लेक2बी (डाइजेस्टसाइज ∥ संदेश, 64);
     वी<sub>1</sub> ← ब्लेक2बी (डाइजेस्टसाइज ∥ संदेश, 64);
     <अवधि शैली = रंग: हरा; > बाद के ब्लॉक पिछले ब्लॉकों से उत्पन्न होते हैं</span>
     <अवधि शैली = रंग: हरा; > बाद के ब्लॉक पिछले ब्लॉकों से उत्पन्न होते हैं
     मैं ← 2 से आर करने के लिए
     मैं ← 2 से आर करने के लिए
       वी<sub>i</sub> ← ब्लेक2बी (वी<sub>i-1</sub>, 64)
       वी<sub>i</sub> ← ब्लेक2बी (वी<sub>i-1</sub>, 64)
     <अवधि शैली = रंग: हरा; >अंतिम (संभवतः आंशिक) ब्लॉक</span> उत्पन्न करें
     <अवधि शैली = रंग: हरा; >अंतिम (संभवतः आंशिक) ब्लॉक उत्पन्न करें
     partialBytesNeeded ← डाइजेस्टसाइज़ - 32*r;
     partialBytesNeeded ← डाइजेस्टसाइज़ - 32*r;
     वी<sub>r+1</sub> ← ब्लेक2बी (वी<sub>r</sub>, आंशिक बाइट्स की जरूरत है)
     वी<sub>r+1</sub> ← ब्लेक2बी (वी<sub>r</sub>, आंशिक बाइट्स की जरूरत है)
Line 123: Line 122:
     <अवधि शैली = रंग: हरा; > चलो ए<sub>i</sub> ब्लॉक वी के निचले 32-बाइट्स का प्रतिनिधित्व करें<sub>i</sub></अवधि>
     <अवधि शैली = रंग: हरा; > चलो ए<sub>i</sub> ब्लॉक वी के निचले 32-बाइट्स का प्रतिनिधित्व करें<sub>i</sub></अवधि>
     वापसी ए<sub>1</sub> ∥ ए<sub>2</sub> ∥ ... ∥ ए<sub>r</sub> ∥ वी<sub>r+1</sub>
     वापसी ए<sub>1</sub> ∥ ए<sub>2</sub> ∥ ... ∥ ए<sub>r</sub> ∥ वी<sub>r+1</sub>
== संदर्भ ==
== संदर्भ ==
{{reflist}}
{{reflist}}
== बाहरी संबंध ==
== बाहरी संबंध ==
*[https://github.com/p-h-c/phc-winner-argon2 Argon2 source code repository on Github]
*[https://github.com/p-h-c/phc-winner-argon2 आर्गन2 source code repository on Github]
*[https://www.cryptolux.org/images/0/0d/Argon2.pdf Argon2 specification]
*[https://www.cryptolux.org/images/0/0d/Argon2.pdf आर्गन2 specification]
*[https://password-hashing.net/ Password Hashing Competition]
*[https://password-hashing.net/ Password Hashing Competition]
*[https://www.cryptolux.org/index.php/Argon2 Uni.Lu Argon2 Page]
*[https://www.cryptolux.org/index.php/Argon2 Uni.Lu आर्गन2 Page]
*[https://eprint.iacr.org/2016/027.pdf Balloon Hashing: A Memory-Hard Function Providing Provable Protection Against Sequential Attacks]
*[https://eprint.iacr.org/2016/027.pdf Balloon Hashing: A Memory-Hard Function Providing Provable Protection Against Sequential Attacks]
*{{IETF RFC|9106|link=no}} Argon2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications
*{{IETF RFC|9106|link=no}} आर्गन2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications


{{Cryptography navbox | hash}}
{{Cryptography navbox | hash}}

Revision as of 22:21, 29 May 2023

आर्गन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 फ़ंक्शन की गणना करना संभव है, और केवल का उपयोग करके एक बहु-पास आर्गन2i की गणना करना संभव है N/e (≈ N/2.72) बिना किसी समय दंड के स्थान।[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

संदर्भ

  1. ↑ "Password Hashing Competition"
  2. ↑ Jos Wetzels (2016-02-08). "Open Sesame: The Password Hashing Competition and Argon2". arXiv:1602.03097 [cs.CR].
  3. ↑ Argon2: the memory-hard function for password hashing and other applications, Alex Biryukov, et al, October 1, 2015
  4. ↑ "Argon2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications". Retrieved September 9, 2021.
  5. ↑ 5.0 5.1 Joël Alwen; Jeremiah Blocki (2016-08-05). Towards Practical Attacks on Argon2i and Balloon Hashing (PDF) (Report).
  6. ↑ 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. ↑ 7.0 7.1 "[Cfrg] Argon2 v.1.3". www.ietf.org. Retrieved 2016-10-30.
  8. ↑ Joël Alwen; Jeremiah Blocki (2016-02-19). कुशल रूप से डेटा-स्वतंत्र मेमोरी-हार्ड फ़ंक्शंस की गणना करना (PDF) (Report).

बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=आर्गन2&oldid=172654’