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

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

== परिभाषा ==

एक '''मास्क जेनरेशन फ़ंक्शन''' चर लंबाई की एक ऑक्टेट स्ट्रिंग और इनपुट के रूप में एक वांछित आउटपुट लंबाई लेता है और वांछित लंबाई के एक ऑक्टेट स्ट्रिंग को आउटपुट करता है। इनपुट और आउटपुट ऑक्टेट स्ट्रिंग्स की लंबाई पर प्रतिबंध हो सकते हैं, किन्तु ऐसी सीमाएं सामान्यतः बहुत बड़ी होती हैं। इस प्रकार मुखौटा निर्माण कार्य नियतिवादी हैं; ऑक्टेट स्ट्रिंग आउटपुट पूरी तरह से इनपुट ऑक्टेट स्ट्रिंग द्वारा निर्धारित किया जाता है। मास्क जनरेशन फ़ंक्शन का आउटपुट छद्म यादृच्छिक होना चाहिए, अर्थात, यदि फ़ंक्शन के बीज अज्ञात हैं, तो आउटपुट को वास्तव में यादृच्छिक स्ट्रिंग से अलग करना असंभव होना चाहिए।<ref name="rsa">{{cite web |url=https://www.ietf.org/rfc/rfc2437.txt |title=RFC 2437 PKCS #1 |author=RSA Laboratories}}</ref>

== अनुप्रयोग ==

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

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

मास्क जनरेशन फ़ंक्शंस को पहली बार आरएसए-ओएईपी एल्गोरिदम में पैडिंग के विनिर्देश के हिस्से के रूप में प्रस्तावित किया गया था। इस प्रकार ओएईपी एल्गोरिदम को एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन की आवश्यकता होती है जो '''"डेटा ब्लॉक"''' के आकार के बराबर आउटपुट उत्पन्न कर सकता है जिसकी लंबाई मनमाने ढंग से आकार के इनपुट संदेश के समानुपाती होती है।<ref name="rsa"/>
=== यादृच्छिक संख्या जनरेटर ===

इस प्रकार एनआईएसटी विशेष प्रकाशन 800-90ए <ref>{{cite journal |url=http://csrc.nist.gov/publications/nistpubs/800-90A/SP800-90A.pdf |title=नियतात्मक रैंडम बिट जेनरेटर का उपयोग करके रैंडम नंबर जनरेशन के लिए सिफारिश|author=National Institute of Standards and Technology|year=2012 |doi=10.6028/NIST.SP.800-90A }}</ref> क्रिप्टोग्राफ़िक रूप से सुरक्षित रैंडम नंबर जेनरेटर के एक वर्ग को परिभाषित करता है, जिनमें से एक '''"हैश डीआरबीजी"''' है, जो रैंडम बिट्स की अनुरोधित संख्या के आकार के बराबर रैंडम बिट्स के अनुरोधित अनुक्रम का उत्पादन करने के लिए काउंटर के साथ हैश फ़ंक्शन का उपयोग करता है।

== उदाहरण ==

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

=== एमजीएफ1 ===

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

==== विकल्प ====
<math>\mathsf{Hash}</math>
:   हैश फंकशन (<math>\mathsf{hLen}</math> हैश फ़ंक्शन आउटपुट के ऑक्टेट में लंबाई दर्शाता है)

==== इनपुट ====
<math>Z</math>
: बीज जिससे मुखौटा उत्पन्न होता है, एक ऑक्टेट स्ट्रिंग
<math>l</math>
:मास्क के ऑक्टेट में अभीष्ट लंबाई, अधिक से अधिक <math>2^{32}(\mathsf{hLen})</math>

'''आउटपुट'''

<math>\mathsf{mask}</math>
:मास्क, लंबाई का एक ऑक्टेट स्ट्रिंग <math>l</math>; या बहुत लंबा मुखौटा

==== कदम ====
{{Ordered list | list_style_type=decimal
|   If <math>l > 2^{32}(\mathsf{hLen})</math>, output "mask too long" and stop.
|   Let <math>T</math>  be the empty octet string.
|   For <math>\mathsf{counter}</math> from <math>0</math> to <math>\left\lceil{\tfrac{l}{\mathsf{hLen}}}\right\rceil-1</math>, do the following:
    {{Ordered list | list_style_type=lower-alpha
    |   Convert <math>\mathsf{counter}</math> to an octet string <math>C</math> of length <math>4</math> with the primitive <math>\mathsf{I2OSP}</math>:
:   <math>C = \mathsf{I2OSP} (\mathsf{counter}, 4)</math>
    |   Concatenate the hash of the seed <math>Z</math> and <math>C</math> to the octet string <math>T</math>:
:   <math>T =   T \shortparallel \mathsf{Hash} (Z \shortparallel C)</math>
}}
|  Output the leading <math>l</math> octets of <math>T</math> as the octet string mask.
}}
</ब्लॉककोट>

=== उदाहरण कोड ===

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

<syntaxhighlight lang="python">
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]
</syntaxhighlight>
एमजीएफ1 का उदाहरण आउटपुट:

<syntaxhighlight lang="pycon">
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'
</syntaxhighlight>
== संदर्भ ==
{{reflist}}
[[Category: क्रिप्टोग्राफिक आदिम]] [[Category: क्रिप्टोग्राफ़िक हैश फ़ंक्शन]] [[Category: क्रिप्टोग्राफी का सिद्धांत]] 



[[Category: Machine Translated Page]]
[[Category:Created On 19/06/2023]]
[[Category:Vigyan Ready]]