आर्गन2

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

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

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

एल्गोरिथम
 समारोह Argon2  इनपुट्स: पासवर्ड (पी): बाइट्स (0..232-1) पासवर्ड (या संदेश) को हैश किया जाना है नमक (एस): बाइट्स (8..232-1) नमक (पासवर्ड हैशिंग के लिए अनुशंसित 16 बाइट्स) समांतरता (पी): संख्या (1..224-1) समानता की डिग्री (अर्थात थ्रेड्स की संख्या) टैगलेंथ (टी): संख्या (4..232-1) लौटाए गए बाइट्स की वांछित संख्या मेमोरीसाइजकेबी (एम): संख्या (8p..232-1) उपयोग की जाने वाली मेमोरी की मात्रा (किबिबाइट में) पुनरावृत्तियों (टी): संख्या (1..232-1) प्रदर्शन करने के लिए पुनरावृत्तियों की संख्या संस्करण (वी): संख्या (0x13)undefined वर्तमान संस्करण 0x13 (19 दशमलव) है कुंजी (के): बाइट्स (0..232-1) वैकल्पिक कुंजी (इरेटा: पीडीएफ 0..32 बाइट्स कहता है, आरएफसी 0..2 कहता है32 बाइट्स) संबद्ध डेटा (एक्स): बाइट्स (0..232-1) वैकल्पिक स्वैच्छिक अतिरिक्त डेटा हैशटाइप (वाई): संख्या (0=Argon2d, 1=Argon2i, 2=Argon2id) आउटपुट: टैग: बाइट्स (टैग लंबाई)undefined परिणामस्वरूप उत्पन्न बाइट, टैगलम्बाई बाइट लंबा  प्रारंभिक 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)undefined परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी <अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक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

बाहरी संबंध

 * Argon2 source code repository on Github
 * Argon2 specification
 * Password Hashing Competition
 * Uni.Lu Argon2 Page
 * Balloon Hashing: A Memory-Hard Function Providing Provable Protection Against Sequential Attacks
 * Argon2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications