मास्क जनरेशन फंक्शन

मास्क जेनरेशन फ़ंक्शन (एमजीएफ) क्रिप्टोग्राफ़िक हैश फ़ंक्शन के समान एक क्रिप्टोग्राफ़िक आदिम है, सिवाय इसके कि हैश फ़ंक्शन के आउटपुट का एक निश्चित आकार होता है, एमजीएफ एक चर लंबाई के आउटपुट का समर्थन करता है। इस संबंध में, एक एमजीएफ को एक विस्तार योग्य-आउटपुट फ़ंक्शन (एक्सओएफ) के रूप में देखा जा सकता है: यह किसी भी लम्बाई के इनपुट को स्वीकार कर सकता है और इसे किसी भी लम्बाई के आउटपुट का उत्पादन करने के लिए संसाधित कर सकता है। मास्क जनरेशन फ़ंक्शंस पूरी तरह से नियतात्मक हैं: किसी दिए गए इनपुट और वांछित आउटपुट लंबाई के लिए आउटपुट हमेशा समान होता है।

परिभाषा

एक मास्क जेनरेशन फ़ंक्शन चर लंबाई की एक ऑक्टेट स्ट्रिंग और इनपुट के रूप में एक वांछित आउटपुट लंबाई लेता है और वांछित लंबाई के एक ऑक्टेट स्ट्रिंग को आउटपुट करता है। इनपुट और आउटपुट ऑक्टेट स्ट्रिंग्स की लंबाई पर प्रतिबंध हो सकते हैं, किन्तु ऐसी सीमाएं सामान्यतः बहुत बड़ी होती हैं। मुखौटा निर्माण कार्य नियतिवादी हैं; ऑक्टेट स्ट्रिंग आउटपुट पूरी तरह से इनपुट ऑक्टेट स्ट्रिंग द्वारा निर्धारित किया जाता है। मास्क जनरेशन फ़ंक्शन का आउटपुट छद्म यादृच्छिक होना चाहिए, अर्थात, यदि फ़ंक्शन के बीज अज्ञात हैं, तो आउटपुट को वास्तव में यादृच्छिक स्ट्रिंग से अलग करना असंभव होना चाहिए।

अनुप्रयोग

हैश फ़ंक्शंस के सामान्यीकरण के रूप में मास्क जनरेशन फ़ंक्शंस, जहाँ भी हैश फ़ंक्शंस होते हैं, उपयोगी होते हैं। चूंकि, एमजीएफ का उपयोग उन स्थितियों में वांछनीय है जहां एक निश्चित आकार का हैश अपर्याप्त होगा। उदाहरणों में पैडिंग (क्रिप्टोग्राफी) उत्पन्न करना, सिमेट्रिक-की_एल्गोरिदम|सिमेट्रिक-की एन्क्रिप्शन में एक बार के पैड या कीस्ट्रीम का उत्पादन करना, और छद्म यादृच्छिक संख्या जनरेटर के लिए आउटपुट देना सम्मिलित है।

पैडिंग योजनाएँ

मास्क जनरेशन फ़ंक्शंस को पहली बार आरएसए-ओएईपी एल्गोरिदम में पैडिंग के विनिर्देश के हिस्से के रूप में प्रस्तावित किया गया था। ओएईपी एल्गोरिदम को एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन की आवश्यकता होती है जो "डेटा ब्लॉक" के आकार के बराबर आउटपुट उत्पन्न कर सकता है जिसकी लंबाई मनमाने ढंग से आकार के इनपुट संदेश के समानुपाती होती है।

यादृच्छिक संख्या जनरेटर

एनआईएसटी विशेष प्रकाशन 800-90ए क्रिप्टोग्राफ़िक रूप से सुरक्षित रैंडम नंबर जेनरेटर के एक वर्ग को परिभाषित करता है, जिनमें से एक "हैश डीआरबीजी" है, जो रैंडम बिट्स की अनुरोधित संख्या के आकार के बराबर रैंडम बिट्स के अनुरोधित अनुक्रम का उत्पादन करने के लिए काउंटर के साथ हैश फ़ंक्शन का उपयोग करता है।

उदाहरण

एमजीएफ बनाने के लिए संभवतः सबसे आम और सीधा तंत्र एक हैश फ़ंक्शन को एक बढ़ते हुए काउंटर वैल्यू के साथ एक साथ लागू करना है। पर्याप्त मात्रा में आउटपुट एकत्र होने तक नए आउटपुट ब्लॉक प्राप्त करने के लिए काउंटर को अनिश्चित काल तक बढ़ाया जा सकता है। यह एमजीएफ1 में प्रयुक्त दृष्टिकोण है।

एमजीएफ1

एमजीएफ1 आरएसए प्रयोगशालाओं द्वारा प्रकाशित सार्वजनिक कुंजी क्रिप्टोग्राफी मानक #1 में परिभाषित एक मुखौटा निर्माण कार्य है:<ब्लॉककोट>

विकल्प

${\mathsf {Hash}}$

हैश फंकशन (${\mathsf {hLen}}$ हैश फ़ंक्शन आउटपुट के ऑक्टेट में लंबाई दर्शाता है)

इनपुट

$Z$

बीज जिससे मुखौटा उत्पन्न होता है, एक ऑक्टेट स्ट्रिंग

$l$

मास्क के ऑक्टेट में अभीष्ट लंबाई, अधिक से अधिक $2^{32}({\mathsf {hLen}})$

आउटपुट

${\mathsf {mask}}$

मास्क, लंबाई का एक ऑक्टेट स्ट्रिंग $l$; या बहुत लंबा मुखौटा

कदम

1. If $l>2^{32}({\mathsf {hLen}})$, output "mask too long" and stop.
2. Let $T$ be the empty octet string.
3. For ${\mathsf {counter}}$ from $0$ to $\left\lceil {\tfrac {l}{\mathsf {hLen}}}\right\rceil -1$, do the following:
   1. Convert ${\mathsf {counter}}$ to an octet string $C$ of length $4$ with the primitive ${\mathsf {I2OSP}}$:

      $C={\mathsf {I2OSP}}({\mathsf {counter}},4)$

   2. Concatenate the hash of the seed $Z$ and $C$ to the octet string $T$:
      $T=T\shortparallel {\mathsf {Hash}}(Z\shortparallel C)$
4. Output the leading $l$ octets of $T$ as the octet string mask.

</ब्लॉककोट>

उदाहरण कोड

नीचे एमजीएफ1 को लागू करने वाला पायथन कोड है:

import hashlib

def mgf1(seed: bytes, length: int, hash_func=hashlib.sha1) -> bytes:
    """Mask generation function."""
    hLen = hash_func().digest_size
    # https://www.ietf.org/rfc/rfc2437.txt
    # 1.If l > 2^32(hLen), output "mask too long" and stop.
    if length > (hLen << 32):
        raise ValueError("mask too long")
    # 2.Let T  be the empty octet string.
    T = b""
    # 3.For counter from 0 to \lceil{l / hLen}\rceil-1, do the following:
    # Note: \lceil{l / hLen}\rceil-1 is the number of iterations needed,
    #       but it's easier to check if we have reached the desired length.
    counter = 0
    while len(T) < length:
        # a.Convert counter to an octet string C of length 4 with the primitive I2OSP: C = I2OSP (counter, 4)
        C = int.to_bytes(counter, 4, 'big')
        # b.Concatenate the hash of the seed Z and C to the octet string T: T = T || Hash (Z || C)
        T += hash_func(seed + C).digest()
        counter += 1
    # 4.Output the leading l octets of T as the octet string mask.
    return T[:length]

एमजीएफ1 का उदाहरण आउटपुट:

Python 3.10.4 (main, Apr 16 2022, 16:28:41) [GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from mgf1 import mgf1
>>> from hashlib import sha256
>>> mgf1(b"foo", 3).hex()
'1ac907'
>>> mgf1(b"foo", 5).hex()
'1ac9075cd4'
>>> mgf1(b"bar", 5).hex()
'bc0c655e01'
>>> mgf1(b"bar", 50).hex()
'bc0c655e016bc2931d85a2e675181adcef7f581f76df2739da74faac41627be2f7f415c89e983fd0ce80ced9878641cb4876'
>>> mgf1(b"bar", 50, sha256).hex()
'382576a7841021cc28fc4c0948753fb8312090cea942ea4c4e735d10dc724b155f9f6069f289d61daca0cb814502ef04eae1'