आर्गन2: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
 
(7 intermediate revisions by 5 users not shown)
Line 1: Line 1:
{{short description|Password-based key derivation function created in 2015}}
{{short description|Password-based key derivation function created in 2015}}
आर्गन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 के तहत जारी किया गया है, और तीन संबंधित संस्करण प्रदान करता है:
'''आर्गन 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 के तहत जारी किया गया है, और तीन संबंधित संस्करण प्रदान करता है:


*आर्गन2d GPU [[पासवर्ड क्रैकिंग]] के प्रतिरोध को अधिकतम करता है। यह एक पासवर्ड निर्भर क्रम में मेमोरी ऐरे को एक्सेस करता है, जो टाइम-मेमोरी ट्रेड-ऑफ (टीएमटीओ) अटैक्स की संभावना को कम करता है, लेकिन संभावित साइड-चैनल अटैक का परिचय देता है।
*आर्गन2d GPU [[पासवर्ड क्रैकिंग]] के प्रतिरोध को अधिकतम करता है। यह एक पासवर्ड निर्भर क्रम में मेमोरी ऐरे को एक्सेस करता है, जो टाइम-मेमोरी ट्रेड-ऑफ (टीएमटीओ) अटैक्स की संभावना को कम करता है, लेकिन संभावित साइड-चैनल अटैक का परिचय देता है।
Line 14: Line 14:
अटैक जबकि आर्गन2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, आर्गन2i फ़ंक्शन पर दो प्रकाशित अटैक हैं। पहला अटैक केवल आर्गन2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।<ref name="blocki"></ref>
अटैक जबकि आर्गन2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, आर्गन2i फ़ंक्शन पर दो प्रकाशित अटैक हैं। पहला अटैक केवल आर्गन2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।<ref name="blocki"></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 फ़ंक्शन की गणना करना संभव है, और केवल {{mvar|N}}/{{mvar|e}} (≈ {{mvar|N}}/2.72) का उपयोग करके एक बहु-पास आर्गन2i की गणना करना संभव है, स्थान और बिना किसी समय दंड (पेनाल्टी) के।<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>
दूसरे अटैक से पता चलता है कि आर्गन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>
== एल्गोरिथम ==
== एल्गोरिथम ==


<अवधि शैली = रंग: नीला; > समारोह  आर्गन2
<span style="color:blue;">'''Function'''</span> Argon2
     <अवधि शैली = रंग: नीला; > इनपुट्स:
     <span style="color:blue;">'''Inputs:'''</span>
       पासवर्ड (पी): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >पासवर्ड (या संदेश) को हैश किया जाना है</span>
       password ('''P'''):       Bytes (0..2<sup>32</sup>-1)   <span style="color:green;">Password (or message) to be hashed</span>
       नमक (एस): बाइट्स (8..2<sup>32</sup>-1) <span style= color:green; > नमक (पासवर्ड हैशिंग के लिए अनुशंसित 16 बाइट्स)</span>
       salt ('''S'''):           Bytes (8..2<sup>32</sup>-1)   <span style="color:green;">Salt (16 bytes recommended for password hashing)</span>
       समांतरता (पी): संख्या (1..2<sup>24</sup>-1) <span style= color:green; >समानता की डिग्री (अर्थात थ्रेड्स की संख्या)</span>
       parallelism ('''p'''):   Number (1..2<sup>24</sup>-1)   <span style="color:green;">Degree of parallelism (i.e. number of threads)</span>
       टैगलेंथ (टी): संख्या (4..2<sup>32</sup>-1) <span style= color:green; >लौटाए गए बाइट्स की वांछित संख्या</span>
       tagLength ('''T'''):     Number (4..2<sup>32</sup>-1)   <span style="color:green;">Desired number of returned bytes</span>
       मेमोरीसाइजकेबी (एम): संख्या (8p..2<sup>32</sup>-1) <span style= color:green; >उपयोग की जाने वाली मेमोरी की मात्रा ([[किबिबाइट]] में)</span>
       memorySizeKB ('''m'''):   Number (8p..2<sup>32</sup>-1) <span style="color:green;">Amount of memory (in [[Kibibyte|kibibytes]]) to use</span>
       पुनरावृत्तियों (टी): संख्या (1..2<sup>32</sup>-1) <span style= color:green; >प्रदर्शन करने के लिए पुनरावृत्तियों की संख्या</span>
       iterations ('''t'''):     Number (1..2<sup>32</sup>-1)   <span style="color:green;">Number of iterations to perform</span>
       संस्करण (वी): संख्या (0x13)<sup>  </sup> <span style= color:green; >वर्तमान संस्करण 0x13 (19 दशमलव)</span> है
       version ('''v'''):       Number (0x13)<sup>  </sup>     <span style="color:green;">The current version is 0x13 (19 decimal)</span>
       कुंजी (के): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >वैकल्पिक कुंजी (इरेटा: पीडीएफ 0..32 बाइट्स कहता है, आरएफसी 0..2 कहता है<sup>32</sup> बाइट्स)</span>
       key ('''K'''):           Bytes (0..2<sup>32</sup>-1)   <span style="color:green;">Optional key (Errata: PDF says 0..32 bytes, RFC says 0..2<sup>32</sup> bytes)</span>
       संबद्ध डेटा (एक्स): बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >वैकल्पिक स्वैच्छिक अतिरिक्त डेटा</span>
       associatedData ('''X'''): Bytes (0..2<sup>32</sup>-1)   <span style="color:green;">Optional arbitrary extra data</span>
       हैशटाइप (वाई): संख्या (0=आर्गन2d, 1=आर्गन2i, 2=आर्गन2id)
       hashType ('''y'''):       Number (0=Argon2d, 1=Argon2i, 2=Argon2id)
     <अवधि शैली = रंग: नीला; >आउटपुट:
     <span style="color:blue;">'''Output:'''</span>
       टैग: बाइट्स (टैग लंबाई)<sup>  </sup> <span style= color:green; >परिणामस्वरूप उत्पन्न बाइट, टैगलम्बाई बाइट लंबा</span>
       tag:               Bytes (tagLength)<sup>  </sup> <span style="color:green;">The resulting generated bytes, tagLength bytes long</span>
   
   
     <अवधि शैली = रंग: हरा; > प्रारंभिक 64-बाइट ब्लॉक एच उत्पन्न करें<sub>0</sub>.
     <span style="color:green;">''Generate initial 64-byte block H<sub>0</sub>.''
     सभी इनपुट मापदंडों को जोड़ा जाता है और अतिरिक्त एन्ट्रॉपी के स्रोत के रूप में इनपुट किया जाता है।
     All the input parameters are concatenated and input as a source of additional entropy.
     इरेटा: RFC का कहना है कि H<sub>0</sub> 64-बिट्स है; पीडीएफ कहते हैं एच<sub>0</sub> 64-बाइट है।
     Errata: RFC says H<sub>0</sub> is 64-bits; PDF says H<sub>0</sub> is 64-bytes.
     इरेटा: आरएफसी का कहना है कि हैश एच ^ है, पीडीएफ कहता है कि यह है (लेकिन दस्तावेज नहीं है कि क्या है)। यह वास्तव में ब्लेक2बी है।
     Errata: RFC says the Hash is H^, the PDF says it's ℋ (but doesn't document what is). It's actually Blake2b.
     वेरिएबल लेंथ आइटम्स को उनकी लंबाई के साथ 32-बिट लिट्ल-एंडियन इंटिजर के रूप में जोड़ा जाता है।
     Variable length items are prepended with their length as 32-bit little-endian integers.</span>
     बफर समांतरता टैग लंबाई स्मृति आकार केबी पुनरावृत्तियों संस्करण हैशटाइप
     buffer parallelism tagLength memorySizeKB iterations version hashType
           ∥ लंबाई (पासवर्ड) ∥ पासवर्ड
           ∥ Length(password)       Password
           ∥ लंबाई (नमक) ∥ नमक
           ∥ Length(salt)           salt
           ∥ लंबाई (कुंजी) ∥ कुंजी
           ∥ Length(key)           key
           ∥ लंबाई (एसोसिएटेड डेटा) ∥ संबद्ध डेटा
           ∥ Length(associatedData) ∥ associatedData
     एच<sub>0</sub> ← ब्लेक2बी(बफर, 64) <विस्तार शैली= रंग:हरा; > // ब्लेक2बी का डिफ़ॉल्ट हैश आकार 64-बाइट्स है
     H<sub>0</sub> ← Blake2b(buffer, 64) <span style="color:green;">''//default hash size of Blake2b is 64-bytes''</span>
   
   
     <अवधि शैली = रंग: हरा; > मेमोरीसाइज़केबी को 4*समानांतर किबिबाइट के निकटतम गुणक में राउंड डाउन करके 1 KB ब्लॉक की संख्या की गणना करें
     <span style="color:green;">Calculate number of 1&nbsp;KB blocks by rounding down memorySizeKB to the nearest multiple of 4*parallelism [[Kibibyte|kibibytes]]</span>
     ब्लॉककाउंट फ्लोर (मेमोरी साइजकेबी, 4*पैरेललिज्म)
     blockCount Floor(memorySizeKB, 4*parallelism)
   
   
     <अवधि शैली = रंग: हरा; >1 KiB ब्लॉक की द्वि-आयामी सरणी आवंटित करें (समानता पंक्तियां x कॉलमकाउंट कॉलम)
     <span style="color:green;">Allocate two-dimensional array of 1&nbsp;KiB blocks (parallelism rows x columnCount columns)</span>
     कॉलमकाउंट ब्लॉककाउंट / समांतरता; <अवधि शैली = रंग: हरा; >// RFC में, columnCount को 'q' कहा जाता है
     columnCount blockCount / parallelism;   <span style="color:green;">//In the RFC, columnCount is referred to as '''q'''</span>
   
   
     <अवधि शैली = रंग: हरा; > प्रत्येक लेन (यानी पंक्ति) के पहले और दूसरे ब्लॉक (यानी कॉलम शून्य और एक) की गणना करें
     <span style="color:green;">Compute the first and second block (i.e. column zero and one ) of each lane (i.e. row)</span>
     'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >प्रत्येक पंक्ति के लिए
     '''for''' i ← 0 '''to''' parallelism-1 '''do''' <span style="color:green;">for each row</span>
       बी<sub>i</sub>[0] ← हैश (एच<sub>0</sub> ∥ 0 ∥ i, 1024) <span style= color:green; >//1024-बाइट डाइजेस्ट</span> जनरेट करें
       B<sub>i</sub>[0] ← Hash(H<sub>0</sub> ∥ 0 ∥ i, 1024) <span style="color:green;">''//Generate a 1024-byte digest''</span>
       बी<sub>i</sub>[1] ← हैश (एच<sub>0</sub> ∥ 1 ∥ i, 1024) <span style= color:green; >//1024-बाइट डाइजेस्ट</span> जनरेट करें
       B<sub>i</sub>[1] ← Hash(H<sub>0</sub> ∥ 1 ∥ i, 1024) <span style="color:green;">''//Generate a 1024-byte digest''</span>
   
   
     <अवधि शैली = रंग: हरा; >प्रत्येक लेन के शेष स्तंभों की गणना करें
     <span style="color:green;">Compute remaining columns of each lane</span>
     'के लिए' मैं ← 0 'से' समानता -1 'करो' <विस्तार शैली = रंग: हरा; >//प्रत्येक पंक्ति के लिए
     '''for''' i ← 0 '''to''' parallelism-1 '''do''' <span style="color:green;">//for each row</span>
       'for' j ← 2 'to' columnCount-1 'do' <span style= color:green; >//बाद के हर कॉलम के लिए</span>
       '''for''' j ← 2 '''to''' columnCount-1 '''do''' <span style="color:green;">//for each subsequent column</span>
           <अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह आर्गन2i, आर्गन2d, या आर्गन2id है (अनुभाग 3.4 देखें)
           <span style="color:green;">//i' and j' indexes depend if it's Argon2i, Argon2d, or Argon2id (See section 3.4)</span>
           i′, j′ ← GetBlockIndexes(i, j) <span style= color:green; >//GetBlockIndexes फ़ंक्शन परिभाषित नहीं है</span>
           i′, j′ ← GetBlockIndexes(i, j) <span style="color:green;">//the GetBlockIndexes function is not defined</span>
           बी<sub>i</sub>[जे] = जी (बी<sub>i</sub>[जे-1], बी<sub>i′</sub>[जे']) <विस्तार शैली = रंग: हरा; >//G हैश फ़ंक्शन परिभाषित नहीं है
           B<sub>i</sub>[j] = G(B<sub>i</sub>[j-1], B<sub>i′</sub>[j′]) <span style="color:green;">//the G hash function is not defined</span>
   
   
     <अवधि शैली = रंग: हरा; > पुनरावृति > 1 होने पर और पास हो जाता है
     <span style="color:green;">Further passes when iterations > 1</span>
     nIteration के लिए ← 2 पुनरावृत्तियों के लिए करते हैं
     '''for''' nIteration ← 2 '''to''' iterations '''do'''
       for i ← 0 to Parallelism-1 do <span style= color:green; >प्रत्येक पंक्ति के लिए</span>
       '''for''' i ← 0 '''to''' parallelism-1 '''do''' <span style="color:green;">for each row</span>
         j ← 0 के लिए columnCount-1 do <span style= color:green; >//बाद के हर कॉलम के लिए</span>
         '''for''' j ← 0 '''to''' columnCount-1 '''do''' <span style="color:green;">//for each subsequent column</span>
             <अवधि शैली = रंग: हरा; >//i' और j' इंडेक्स निर्भर करते हैं यदि यह आर्गन2i, आर्गन2d, या आर्गन2id है (अनुभाग 3.4 देखें)
             <span style="color:green;">//i' and j' indexes depend if it's Argon2i, Argon2d, or Argon2id (See section 3.4)</span>
             i′, j′ ← GetBlockIndexes(i, j)
             i′, j′ ← GetBlockIndexes(i, j)
             अगर जे == 0 तो
             '''if''' j == 0 '''then'''
               बी<sub>i</sub>[0] = बी<sub>i</sub>[0] एक्सोर जी (बी<sub>i</sub>[स्तंभ संख्या-1], बी<sub>i′</sub>[जे'])
               B<sub>i</sub>[0] = B<sub>i</sub>[0] xor G(B<sub>i</sub>[columnCount-1], B<sub>i′</sub>[j′])
             अन्य
             '''else'''
               बी<sub>i</sub>[जे] = बी<sub>i</sub>[जे] एक्सोर जी (बी<sub>i</sub>[जे-1], बी<sub>i′</sub>[जे'])
               B<sub>i</sub>[j] = B<sub>i</sub>[j] xor G(B<sub>i</sub>[j-1], B<sub>i′</sub>[j′])
   
   
     <अवधि शैली = रंग: हरा; > प्रत्येक पंक्ति के अंतिम कॉलम के XOR के रूप में अंतिम ब्लॉक C की गणना करें
     <span style="color:green;">Compute final block '''C''' as the XOR of the last column of each row</span>
     सी बी<sub>0</sub>[स्तंभ संख्या-1]
     C B<sub>0</sub>[columnCount-1]
     for i ← 1 to Parallelism-1 do
     '''for''' i ← 1 '''to''' parallelism-1 '''do'''
       सी सी एक्सोर बी<sub>i</sub>[स्तंभ संख्या-1]
       C C '''xor''' B<sub>i</sub>[columnCount-1]
   
   
     <अवधि शैली = रंग: हरा; > गणना आउटपुट टैग
     <span style="color:green;">Compute output tag</span>
     वापसी हैश (सी, टैग लम्बाई)
     '''return''' Hash(C, tagLength)


=== चर-लंबाई हैश फ़ंक्शन ===
=== चर-लंबाई हैश फ़ंक्शन ===
 
Argon2 एक हैश फ़ंक्शन का उपयोग करता है जो 2 तक डाइजेस्ट उत्पन्न करने में सक्षम है<sup>32</sup> बाइट लंबा। यह हैश फ़ंक्शन आंतरिक रूप से [[ब्लेक 2]] पर बनाया गया है।
आर्गन2 एक हैश फ़ंक्शन का उपयोग करता है जो 2<sup>32</sup> तक डाइजेस्ट उत्पन्न करने में सक्षम है बाइट लंबा। यह हैश फ़ंक्शन आंतरिक रूप से [[ब्लेक 2]] पर बनाया गया है।
  <span style="color:blue;">'''Function'''</span> Hash(message, digestSize)
 
     <span style="color:blue;">'''Inputs:'''</span>
  <अवधि शैली = रंग: नीला; >फ़ंक्शन हैश (संदेश, डाइजेस्ट आकार)
       message:         Bytes (0..2<sup>32</sup>-1)     <span style="color:green;">Message to be hashed</span>
     <अवधि शैली = रंग: नीला; > इनपुट्स:
       digestSize:     Integer (1..2<sup>32</sup>)     <span style="color:green;">Desired number of bytes to be returned</span>
       संदेश: बाइट्स (0..2<sup>32</sup>-1) <span style= color:green; >संदेश हैश किया जाना है</span>
     <span style="color:blue;">Output:</span>
       डाइजेस्टसाइज: पूर्णांक (1..2<sup>32</sup>) <span style= color:green; > लौटाई जाने वाली बाइट की वांछित संख्या</span>
       digest:         Bytes (digestSize)<sup>  </sup> <span style="color:green;">The resulting generated bytes, digestSize bytes long</span>
     <अवधि शैली = रंग: नीला; >आउटपुट:
       डाइजेस्ट: बाइट्स (digestSize)<sup>  </sup> <span style= color:green; >परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी</span>
    <span style="color:green;">'''Hash''' is a variable-length hash function, built using Blake2b, capable of generating
    digests up to 2<sup>32</sup> bytes.</span>
   
   
     <अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक2बी का उपयोग करके बनाया गया है, जो उत्पन्न करने में सक्षम है
     <span style="color:green;">If the requested digestSize is 64-bytes or lower, then we use Blake2b directly</span>
     2 तक पचता है<sup>32</sup> बाइट।
     '''if''' (digestSize <= 64) '''then'''
      '''return''' Blake2b(digestSize ∥ message, digestSize) <span style="color:green;">//concatenate 32-bit little endian digestSize with the message bytes</span>
   
   
     <अवधि शैली = रंग: हरा; > यदि अनुरोधित डाइजेस्ट आकार 64-बाइट या उससे कम है, तो हम सीधे ब्लेक2बी का उपयोग करते हैं
     <span style="color:green;">For desired hashes over 64-bytes (e.g. 1024 bytes for Argon2 blocks),
    if (digestSize <= 64) तब
    we use Blake2b to generate twice the number of needed 64-byte blocks,
      वापसी Blake2b(digestSize ∥ message, डाइजेस्टसाइज़) <span style= color:green; >//संदेश बाइट्स के साथ 32-बिट छोटे एंडियन डाइजेस्ट आकार को संयोजित करें</span>
    and then only use 32-bytes from each block</span>
   
   
     <अवधि शैली = रंग: हरा; > 64-बाइट्स से अधिक वांछित हैश के लिए (उदाहरण के लिए आर्गन2 ब्लॉक के लिए 1024 बाइट्स),
     <span style="color:green;">Calculate the number of whole blocks (knowing we're only going to use 32-bytes from each)</span>
     हम आवश्यक 64-बाइट ब्लॉकों की दोगुनी संख्या उत्पन्न करने के लिए ब्लेक2बी का उपयोग करते हैं,
     r ← Ceil(digestSize/32)-2;
    और उसके बाद प्रत्येक ब्लॉक से केवल 32-बाइट का उपयोग करें
   
   
     <अवधि शैली = रंग: हरा; > पूरे ब्लॉक की संख्या की गणना करें (यह जानते हुए कि हम प्रत्येक से केवल 32-बाइट का उपयोग करने जा रहे हैं)
     <span style="color:green;">Generate r whole blocks.</span>
     आर सील (डाइजेस्ट साइज/32)-2;
    <span style="color:green;">Initial block is generated from message</span>
    V<sub>1</sub> ← Blake2b(digestSize ∥ message, 64);
    <span style="color:green;">Subsequent blocks are generated from previous blocks</span>
    '''for''' i ← 2 '''to''' r '''do'''
      V<sub>i</sub> ← Blake2b(V<sub>i-1</sub>, 64)
    <span style="color:green;">Generate the final (possibly partial) block</span>
    partialBytesNeeded ← digestSize – 32*r;
     V<sub>r+1</sub> Blake2b(V<sub>r</sub>, partialBytesNeeded)
   
   
     <अवधि शैली = रंग: हरा; > संपूर्ण ब्लॉक उत्पन्न करें।
     <span style="color:green;">Concatenate the first 32-bytes of each block V<sub>i</sub>
    <अवधि शैली = रंग: हरा; >प्रारंभिक ब्लॉक संदेश से उत्पन्न होता है
    (except the possibly partial last block, which we take the whole thing)</span>
    वी<sub>1</sub> ← ब्लेक2बी (डाइजेस्टसाइज ∥ संदेश, 64);
     <span style="color:green;">Let A<sub>i</sub> represent the lower 32-bytes of block V<sub>i</sub></span>
     <अवधि शैली = रंग: हरा; > बाद के ब्लॉक पिछले ब्लॉकों से उत्पन्न होते हैं
     '''return''' A<sub>1</sub> ∥ A<sub>2</sub> ∥ ... ∥ A<sub>r</sub> ∥ V<sub>r+1</sub>
    मैं ← 2 से आर करने के लिए
      वी<sub>i</sub> ← ब्लेक2बी (वी<sub>i-1</sub>, 64)
     <अवधि शैली = रंग: हरा; >अंतिम (संभवतः आंशिक) ब्लॉक उत्पन्न करें
    partialBytesNeeded ← डाइजेस्टसाइज़ - 32*r;
    वी<sub>r+1</sub> ← ब्लेक2बी (वी<sub>r</sub>, आंशिक बाइट्स की जरूरत है)
   
   
    <अवधि शैली = रंग: हरा; > प्रत्येक ब्लॉक V के पहले 32-बाइट्स को सम्‍मिलित करें<sub>i</sub>
 
(संभवतः आंशिक अंतिम ब्लॉक को छोड़कर, जिसे हम पूरी चीज़ लेते हैं)</span>
 
    <अवधि शैली = रंग: हरा; > चलो ए<sub>i</sub> ब्लॉक वी के निचले 32-बाइट्स का प्रतिनिधित्व करें<sub>i</sub></अवधि>
 
    वापसी ए<sub>1</sub> ∥ ए<sub>2</sub> ∥ ... ∥ ए<sub>r</sub> ∥ वी<sub>r+1</sub>
[[index.php?title=Category:Navigational boxes| ]]
 
 
 
 
 
 
== संदर्भ ==
== संदर्भ ==
{{reflist}}
{{reflist}}
Line 132: Line 141:
*{{IETF RFC|9106|link=no}} आर्गन2 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}}
[[Category:Collapse templates]]
[[Category: प्रमुख व्युत्पत्ति कार्य]] [[Category: कंप्यूटिंग में 2015]]
 
 
 
[[Category: Machine Translated Page]]
[[Category:Created On 11/05/2023]]
[[Category:Created On 11/05/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Navigational boxes without horizontal lists]]
[[Category:Pages with script errors]]
[[Category:Short description with empty Wikidata description]]
[[Category:Sidebars with styles needing conversion]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]
[[Category:कंप्यूटिंग में 2015]]
[[Category:प्रमुख व्युत्पत्ति कार्य]]

Latest revision as of 15:34, 29 August 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 फ़ंक्शन की गणना करना संभव है, और केवल 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]

एल्गोरिथम

Function Argon2

   Inputs:
      password (P):       Bytes (0..232-1)    Password (or message) to be hashed
      salt (S):           Bytes (8..232-1)    Salt (16 bytes recommended for password hashing)
      parallelism (p):    Number (1..224-1)   Degree of parallelism (i.e. number of threads)
      tagLength (T):      Number (4..232-1)   Desired number of returned bytes
      memorySizeKB (m):   Number (8p..232-1)  Amount of memory (in kibibytes) to use
      iterations (t):     Number (1..232-1)   Number of iterations to perform
      version (v):        Number (0x13)       The current version is 0x13 (19 decimal)
      key (K):            Bytes (0..232-1)    Optional key (Errata: PDF says 0..32 bytes, RFC says 0..232 bytes)
      associatedData (X): Bytes (0..232-1)    Optional arbitrary extra data
      hashType (y):       Number (0=Argon2d, 1=Argon2i, 2=Argon2id)
   Output:
      tag:                Bytes (tagLength)   The resulting generated bytes, tagLength bytes long

   Generate initial 64-byte block H0.
    All the input parameters are concatenated and input as a source of additional entropy.
    Errata: RFC says H0 is 64-bits; PDF says H0 is 64-bytes.
    Errata: RFC says the Hash is H^, the PDF says it's ℋ (but doesn't document what ℋ is). It's actually Blake2b.
    Variable length items are prepended with their length as 32-bit little-endian integers.
   buffer ← parallelism ∥ tagLength ∥ memorySizeKB ∥ iterations ∥ version ∥ hashType
         ∥ Length(password)       ∥ Password
         ∥ Length(salt)           ∥ salt
         ∥ Length(key)            ∥ key
         ∥ Length(associatedData) ∥ associatedData
   H0 ← Blake2b(buffer, 64) //default hash size of Blake2b is 64-bytes

   Calculate number of 1 KB blocks by rounding down memorySizeKB to the nearest multiple of 4*parallelism kibibytes
   blockCount ← Floor(memorySizeKB, 4*parallelism)

   Allocate two-dimensional array of 1 KiB blocks (parallelism rows x columnCount columns)
   columnCount ← blockCount / parallelism;   //In the RFC, columnCount is referred to as q

   Compute the first and second block (i.e. column zero and one ) of each lane (i.e. row)
   for i ← 0 to parallelism-1 do for each row
      Bi[0] ← Hash(H0 ∥ 0 ∥ i, 1024) //Generate a 1024-byte digest
      Bi[1] ← Hash(H0 ∥ 1 ∥ i, 1024) //Generate a 1024-byte digest

   Compute remaining columns of each lane
   for i ← 0 to parallelism-1 do //for each row
      for j ← 2 to columnCount-1 do //for each subsequent column
         //i' and j' indexes depend if it's Argon2i, Argon2d, or Argon2id (See section 3.4)
         i′, j′ ← GetBlockIndexes(i, j)  //the GetBlockIndexes function is not defined
         Bi[j] = G(Bi[j-1], Bi′[j′]) //the G hash function is not defined

   Further passes when iterations > 1
   for nIteration ← 2 to iterations do
      for i ← 0 to parallelism-1 do for each row
        for j ← 0 to columnCount-1 do //for each subsequent column
           //i' and j' indexes depend if it's Argon2i, Argon2d, or Argon2id (See section 3.4)
           i′, j′ ← GetBlockIndexes(i, j)
           if j == 0 then 
             Bi[0] = Bi[0] xor G(Bi[columnCount-1], Bi′[j′])
           else
             Bi[j] = Bi[j] xor G(Bi[j-1], Bi′[j′])

   Compute final block C as the XOR of the last column of each row
   C ← B0[columnCount-1]
   for i ← 1 to parallelism-1 do
      C ← C xor Bi[columnCount-1]

   Compute output tag
   return Hash(C, tagLength)

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

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

Function Hash(message, digestSize)
   Inputs:
      message:         Bytes (0..232-1)     Message to be hashed
      digestSize:      Integer (1..232)     Desired number of bytes to be returned
   Output:
      digest:          Bytes (digestSize)   The resulting generated bytes, digestSize bytes long

   Hash is a variable-length hash function, built using Blake2b, capable of generating
    digests up to 232 bytes.

   If the requested digestSize is 64-bytes or lower, then we use Blake2b directly
   if (digestSize <= 64) then
      return Blake2b(digestSize ∥ message, digestSize) //concatenate 32-bit little endian digestSize with the message bytes

   For desired hashes over 64-bytes (e.g. 1024 bytes for Argon2 blocks),
    we use Blake2b to generate twice the number of needed 64-byte blocks,
    and then only use 32-bytes from each block

   Calculate the number of whole blocks (knowing we're only going to use 32-bytes from each)
   r ← Ceil(digestSize/32)-2;

   Generate r whole blocks.
   Initial block is generated from message
   V1 ← Blake2b(digestSize ∥ message, 64);
   Subsequent blocks are generated from previous blocks
   for i ← 2 to r do
      Vi ← Blake2b(Vi-1, 64)
   Generate the final (possibly partial) block
   partialBytesNeeded ← digestSize – 32*r;
   Vr+1 ← Blake2b(Vr, partialBytesNeeded)

   Concatenate the first 32-bytes of each block Vi
    (except the possibly partial last block, which we take the whole thing)
   Let Ai represent the lower 32-bytes of block Vi
   return A1 ∥ A2 ∥ ... ∥ Ar ∥ Vr+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).

बाहरी संबंध