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

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

परिभाषा

<ब्लॉककोट>

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

</ब्लॉककोट>

अनुप्रयोग

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

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

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

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

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

उदाहरण

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

MGF1

MGF1 RSA प्रयोगशालाओं द्वारा प्रकाशित सार्वजनिक कुंजी क्रिप्टोग्राफी मानक #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.

</ब्लॉककोट>

उदाहरण कोड

नीचे MGF1 को लागू करने वाला पायथन कोड है:

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]

MGF1 का उदाहरण आउटपुट:

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'