आर्गन2: Difference between revisions

From Vigyanwiki
(Created page with "{{short description|Password-based key derivation function created in 2015}} {{Primary sources|date=January 2016}} Argon2 एक प्रमुख व्युत्पत्...")
 
m (Deepak moved page हम वापिस आ गये to आर्गन2 without leaving a redirect)
(No difference)

Revision as of 10:02, 19 May 2023

Argon2 एक प्रमुख व्युत्पत्ति कार्य है जिसे 2015 पासवर्ड हैशिंग प्रतियोगिता के विजेता के रूप में चुना गया था।[1][2] यह लक्समबर्ग विश्वविद्यालय से एलेक्स बिरुकोव , डैनियल दीनू और दिमित्री खोवराटोविच द्वारा डिजाइन किया गया था।[3] Argon2 का संदर्भ कार्यान्वयन Creative Commons CC0 लाइसेंस (यानी सार्वजनिक डोमेन) या Apache लाइसेंस|Apache लाइसेंस 2.0 के तहत जारी किया गया है, और तीन संबंधित संस्करण प्रदान करता है:

  • Argon2d GPU पासवर्ड क्रैकिंग के प्रतिरोध को अधिकतम करता है। यह एक पासवर्ड निर्भर क्रम में मेमोरी ऐरे को एक्सेस करता है, जो टाइम-मेमोरी ट्रेड-ऑफ (टीएमटीओ) हमलों की संभावना को कम करता है, लेकिन संभावित साइड-चैनल हमलों का परिचय देता है।
  • Argon2i को साइड-चैनल हमलों का विरोध करने के लिए अनुकूलित किया गया है। यह एक पासवर्ड स्वतंत्र क्रम में मेमोरी ऐरे को एक्सेस करता है।
  • Argon2id एक संकर संस्करण है। यह पहली छमाही पास ओवर मेमोरी के लिए Argon2i दृष्टिकोण और बाद के पास के लिए Argon2d दृष्टिकोण का अनुसरण करता है। RFC 9106 Argon2id का उपयोग करने की अनुशंसा करता है यदि आप प्रकारों के बीच अंतर नहीं जानते हैं या आप साइड-चैनल हमलों को एक व्यवहार्य खतरा मानते हैं।[4]

सभी तीन मोड तीन मापदंडों द्वारा विनिर्देशन की अनुमति देते हैं जो नियंत्रित करते हैं:

  • निष्पादन समय
  • स्मृति आवश्यक है
  • समानता की डिग्री

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

जबकि Argon2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, Argon2i फ़ंक्शन पर दो प्रकाशित हमले हैं। पहला हमला केवल Argon2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।[5] पहले हमले से पता चलता है कि वांछित स्थान के एक चौथाई और पांचवे हिस्से के बीच बिना किसी समय दंड के एकल-पास Argon2i फ़ंक्शन की गणना करना संभव है, और केवल का उपयोग करके एक बहु-पास Argon2i की गणना करना संभव है N/e (≈ N/2.72) बिना किसी समय दंड के स्थान।[6] Argon2 लेखकों के अनुसार, यह अटैक वेक्टर संस्करण 1.3 में तय किया गया था।[7] दूसरे हमले से पता चलता है कि Argon2i की गणना एक एल्गोरिथ्म द्वारा की जा सकती है जिसमें जटिलता O(n7/4 लॉग (n)) मापदंडों के सभी विकल्पों के लिए σ (अंतरिक्ष लागत), τ (समय की लागत), और थ्रेड-काउंट जैसे कि n=σ∗τ.[8] Argon2 लेखकों का दावा है कि यदि Argon2i का उपयोग तीन या अधिक पास के साथ किया जाता है तो यह हमला कुशल नहीं है।[7]हालांकि, जोएल अल्वेन और यिर्मयाह ब्लॉकी ने हमले में सुधार किया और दिखाया कि हमले को विफल करने के लिए, Argon2i v1.3 को मेमोरी पर 10 से अधिक पास की जरूरत है।[5]


एल्गोरिथम

<अवधि शैली = रंग: नीला; > समारोह  Argon2
   <अवधि शैली = रंग: नीला; > इनपुट्स:
      पासवर्ड (पी): बाइट्स (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=Argon2d, 1=Argon2i, 2=Argon2id)
   <अवधि शैली = रंग: नीला; >आउटपुट:
      टैग: बाइट्स (टैग लंबाई)   परिणामस्वरूप उत्पन्न बाइट, टैगलम्बाई बाइट लंबा

   <अवधि शैली = रंग: हरा; > प्रारंभिक 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' इंडेक्स निर्भर करते हैं यदि यह Argon2i, Argon2d, या Argon2id है (अनुभाग 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' इंडेक्स निर्भर करते हैं यदि यह Argon2i, Argon2d, या Argon2id है (अनुभाग 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]

   <अवधि शैली = रंग: हरा; > गणना आउटपुट टैग 
   वापसी हैश (सी, टैग लम्बाई)

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

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

<अवधि शैली = रंग: नीला; >फ़ंक्शन हैश (संदेश, डाइजेस्ट आकार)
   <अवधि शैली = रंग: नीला; > इनपुट्स:
      संदेश: बाइट्स (0..232-1) संदेश हैश किया जाना है
      डाइजेस्टसाइज: पूर्णांक (1..232)  लौटाई जाने वाली बाइट की वांछित संख्या
   <अवधि शैली = रंग: नीला; >आउटपुट:
      डाइजेस्ट: बाइट्स (digestSize)   परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी

   <अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक2बी का उपयोग करके बनाया गया है, जो उत्पन्न करने में सक्षम है
   2 तक पचता है32 बाइट।

   <अवधि शैली = रंग: हरा; > यदि अनुरोधित डाइजेस्ट आकार 64-बाइट या उससे कम है, तो हम सीधे ब्लेक2बी का उपयोग करते हैं
   if (digestSize <= 64) तब
      वापसी Blake2b(digestSize ∥ message, डाइजेस्टसाइज़) //संदेश बाइट्स के साथ 32-बिट छोटे एंडियन डाइजेस्ट आकार को संयोजित करें

   <अवधि शैली = रंग: हरा; > 64-बाइट्स से अधिक वांछित हैश के लिए (उदाहरण के लिए Argon2 ब्लॉक के लिए 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=172653’