आर्गन2

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

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

क्रिप्टैनालिसिस
अटैक जबकि आर्गन2d के लिए कोई सार्वजनिक क्रिप्ट विश्लेषण लागू नहीं है, आर्गन2i फ़ंक्शन पर दो प्रकाशित अटैक हैं। पहला अटैक केवल आर्गन2i के पुराने संस्करण पर लागू होता है, जबकि दूसरा नवीनतम संस्करण (1.3) तक बढ़ा दिया गया है।

पहले अटैक से पता चलता है कि वांछित स्थान के एक चौथाई और पांचवे हिस्से के बीच बिना किसी समय दंड के एकल-पास आर्गन2i फ़ंक्शन की गणना करना संभव है, और केवल $N$/$e$ (≈ $N$/2.72) का उपयोग करके एक बहु-पास आर्गन2i की गणना करना संभव है, स्थान और बिना किसी समय दंड (पेनाल्टी) के। आर्गन2 लेखकों के अनुसार, यह अटैक वेक्टर संस्करण 1.3 में तय किया गया था।

दूसरे अटैक से पता चलता है कि आर्गन2i की गणना एक एल्गोरिथ्म द्वारा की जा सकती है जिसमें जटिलता O($n$7/4 लॉग ($n$)) मापदंडों के सभी विकल्पों के लिए $σ$ (अंतरिक्ष लागत), $τ$ (समय की लागत), और थ्रेड-काउंट जैसे कि $n$=$σ$∗$τ$. आर्गन2 लेखकों का दावा है कि यदि आर्गन2i का उपयोग तीन या अधिक पास के साथ किया जाता है तो यह अटैक कुशल नहीं है। हालांकि, जोएल अल्वेन और यिर्मयाह ब्लॉकी ने अटैक में सुधार किया और दिखाया कि अटैक को विफल करने के लिए, आर्गन2i v1.3 को मेमोरी पर 10 से अधिक पास की जरूरत है।

एल्गोरिथम
 समारोह आर्गन2  इनपुट्स: पासवर्ड (पी): बाइट्स (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=आर्गन2d, 1=आर्गन2i, 2=आर्गन2id) आउटपुट: टैग: बाइट्स (टैग लंबाई)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' इंडेक्स निर्भर करते हैं यदि यह आर्गन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)undefined परिणामस्वरूप उत्पन्न बाइट्स, डाइजेस्टसाइज़ बाइट्स लंबी <अवधि शैली = रंग: हरा; > हैश एक चर-लंबाई वाला हैश फ़ंक्शन है, जिसे ब्लेक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

बाहरी संबंध

 * आर्गन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
 * आर्गन2 Memory-Hard Function for Password Hashing and Proof-of-Work Applications