🧒🏽 👩🏿 👧🏼 हम इस तथ्य की यादृच्छिकता को बढ़ाते हैं कि [शायद] [लगभग] दुर्घटना से 🤱🏾 🥤 🙇🏻

एक छोटी सी मिर्च अगर यादृच्छिक संख्या स्वादिष्ट

हम सिद्धांत को अभ्यास के साथ जोड़ देंगे - हम दिखाएंगे कि यादृच्छिक अनुक्रमों की एन्ट्रापी में सुधार संभव है, जिसके बाद हम ऐसा करने वाले स्रोत कोड को देखेंगे।

मैं वास्तव में इस तथ्य के बारे में लिखना चाहता था कि उच्च-गुणवत्ता, यानी अत्यधिक एन्ट्रोपिक, यादृच्छिक संख्या पीढ़ी समस्याओं की एक बड़ी संख्या को हल करने में महत्वपूर्ण है, लेकिन यह शायद अतिश्योक्तिपूर्ण है। मुझे उम्मीद है कि सभी को यह अच्छी तरह से पता होगा।

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

सिद्धांत की एक बिट

शुरू करने के लिए, हम दिखाते हैं कि सही दृष्टिकोण के साथ, मौजूदा आरएनजी की गुणवत्ता को नीचा नहीं किया जा सकता है। सबसे सरल सही दृष्टिकोण मुख्य अनुक्रम पर XOR ऑपरेशन के माध्यम से किसी अन्य अनुक्रम को ओवरले करना है। मुख्य अनुक्रम हो सकता है, उदाहरण के लिए, एक प्रणालीगत आरएनजी, जिसे हम पहले से ही अच्छा मानते हैं, लेकिन अभी भी कुछ संदेह हैं, और हमें इसे सुरक्षित खेलने की इच्छा थी। एक अतिरिक्त अनुक्रम हो सकता है, उदाहरण के लिए, एक छद्म यादृच्छिक संख्या जनरेटर, जिसका उत्पादन अच्छा दिखता है, लेकिन हम जानते हैं कि इसकी वास्तविक एन्ट्रापी बहुत कम है। परिणामी अनुक्रम प्राथमिक और माध्यमिक अनुक्रमों के बिट्स को XOR ऑपरेशन को लागू करने का परिणाम होगा। एक महत्वपूर्ण बारीकियों: प्राथमिक और माध्यमिक क्रम एक दूसरे से स्वतंत्र होना चाहिए। यही है, उनकी एन्ट्रापी को मूलभूत रूप से विभिन्न स्रोतों से लिया जाना चाहिए, जिनकी अन्योन्याश्रयता की गणना नहीं की जा सकती है।

एक्स द्वारा मुख्य अनुक्रम के अगले बिट को निरूपित करें, और y - अतिरिक्त एक के संबंधित बिट। परिणामी अनुक्रम का बिट r द्वारा निरूपित किया जाता है:
r = x⊕y

साबित करने का पहला प्रयास। आइए x , y और r के सूचनात्मक एन्ट्रापी के माध्यम से जाने का प्रयास करें। हम शून्य x की संभावना को p _{x0 के} रूप में दर्शाते हैं, और p _{y0 के} रूप में शून्य y की संभावना को। सूचना एन्ट्रापीज़ x और y की गणना शैनन सूत्र के अनुसार की जाती है:

H _x = - (p _x0 log ₂ p _x0 + (1 - p _x0 ) लॉग ₂ (1 - p _x0 ))
H _y = - (p _y0 log ₂ p _y0 + (1 - p _y0 ) log ₂ (1 - p _y0 ))

परिणामी अनुक्रम में शून्य तब दिखाई देता है जब इनपुट पर दो शून्य या दो इकाइयाँ होती हैं। शून्य आर की संभावना:

p _r0 = p _x0 p _y0 + (1 - p _x0 ) (1 - p _y0 )
H _r = - (p _r0 log ₂ p _r0 + (1 - p _r0 ) लॉग ₂ (1 - p _r0 ))

मुख्य अनुक्रम की अपरिहार्यता साबित करने के लिए, यह साबित करना आवश्यक है
Hr - Hx for 0 p _x0 और p _{y0 के} किसी भी मान के लिए। मैं इसे विश्लेषणात्मक रूप से सिद्ध नहीं कर सकता, लेकिन दृश्य गणना से पता चलता है कि एन्ट्रापी में वृद्धि एक चिकनी सतह बनाती है, जो कहीं भी शून्य से नहीं जा रही है:

उदाहरण के लिए, यदि हम तिरछे मुख्य सिग्नल c p _x0 = 0.3 (एंट्रॉपी 0.881) के साथ p _y0 = 0.1 के साथ अत्यधिक तिरछा अतिरिक्त सिग्नल जोड़ते हैं, तो हम एन्ट्रॉपी 0.925 के साथ परिणाम p _r0 = 0.66 प्राप्त करते हैं।

तो, एन्ट्रापी को खराब नहीं किया जा सकता है, लेकिन यह अभी तक सटीक नहीं है। इसलिए, एक दूसरे प्रयास की आवश्यकता है। हालांकि, एन्ट्रापी के माध्यम से भी साबित हो सकता है। योजना (सभी चरण काफी सरल हैं, आप इसे स्वयं कर सकते हैं):

हम साबित करते हैं कि एन्ट्रापी में बिंदु p ₀ = 1/2 पर अधिकतम होता है।
हम यह साबित करते हैं कि किसी भी _{x x0} और p _{y0 के लिए,} p _r0 _का मान 1/2 _x p से आगे नहीं हो सकता है।

साबित करने का दूसरा प्रयास। अनुमान लगाने की क्षमता के माध्यम से। मान लीजिए कि एक हमलावर की प्राथमिकताओं में प्राथमिक और माध्यमिक अनुक्रमों के बारे में कुछ जानकारी है। जानकारी के कब्जे को एक्स , वाई और, के परिणामस्वरूप अग्रिम रूप से अनुमान लगाने के लिए कुछ संभावना के साथ क्षमता में व्यक्त किया गया है, आर । क्रमशः x और y का अनुमान लगाने की संभावनाओं को g _x और g y द्वारा निरूपित किया जाता है, क्रमशः (शब्द अनुमान से)। परिणामी अनुक्रम का बिट या तो अनुमान लगाया जाता है जब दोनों मानों का सही अनुमान लगाया जाता है, या जब दोनों गलत होते हैं, इसलिए अनुमान लगाने की संभावना यह है:
g _r = g _x g _y + (1 - g _x ) (1 - g _y ) = 2 g _x g _y - g _x - g _y + 1

जब हमारे पास सही अनुमानक होता है, तो हमारे पास जी = 1 होता है। अगर हमें कुछ भी पता नहीं है, तो जी ... शून्य नहीं, बल्कि 1/2 है। यह अनुमान लगाने की बिल्कुल संभावना है कि अगर हम सिक्का उछालकर कोई निर्णय लेते हैं तो यह पता चल जाता है। एक बहुत ही दिलचस्प मामला है जब जी <1/2। एक तरफ, इस तरह के एक अनुमानक ने खुद के अंदर कहीं भी अनुमानित मूल्य पर डेटा दिया है, लेकिन किसी कारण से इसके उत्पादन में बदलाव होता है, और इस तरह सिक्का खराब हो जाता है। कृपया "एक सिक्का से भी बदतर" वाक्यांश को याद रखें, यह हमारे लिए उपयोगी होगा। संचार के गणितीय सिद्धांत के दृष्टिकोण से (और, परिणामस्वरूप, सूचना का मात्रात्मक सिद्धांत जो हमारे लिए परिचित है), यह स्थिति बेतुका है, क्योंकि यह सूचना का सिद्धांत नहीं होगा, बल्कि विघटन का सिद्धांत होगा, लेकिन जीवन में हमारे पास इस स्थिति की तुलना में बहुत अधिक है। ।

सीमित मामलों पर विचार करें:

जी _x = 1 , अर्थात, अनुक्रम x पूरी तरह से अनुमानित है:
g _r = g _x g _y + (1 - g _x ) (1 - g _y ) = 1 g _y + (1 11) (1 - g _y ) = g _y
अर्थात्, परिणाम का अनुमान लगाने की संभावना अतिरिक्त अनुक्रम का अनुमान लगाने की संभावना के बराबर है।
g _y = 1 : पिछले वाले के समान। परिणाम का अनुमान लगाने की संभावना मुख्य अनुक्रम का अनुमान लगाने की संभावना के बराबर है।
g _x = 1/2 , यानी अनुक्रम x पूरी तरह से अप्रत्याशित है:
g _r = 2 g _x g _y - g _x - g _y + 1 = 2/2 g _y - 1/2 - g _y +1 = g _y - g _y + 1/2 = 1/2
यही है, किसी भी अतिरिक्त अनुक्रम का जोड़ मुख्य के पूर्ण अप्रत्याशितता को ख़राब नहीं करता है।
g _y = 1/2 : पिछले वाले के समान। पूरी तरह से अप्रत्याशित अतिरिक्त अनुक्रम जोड़ने से परिणाम पूरी तरह से अप्रत्याशित हो जाता है।

यह साबित करने के लिए कि मुख्य में एक अतिरिक्त अनुक्रम जोड़ने से हमलावर को मदद नहीं मिलेगी, हमें यह पता लगाने की जरूरत है कि जी _एक्स से अधिक क्या स्थिति हो सकती है, यानी।

2 जी _एक्स जी _वाई - जी _एक्स - जी _वाई + 1> जी _एक्स

जी _x को दाईं ओर से बाईं ओर ले जाएँ, और g _y और 1 को दाईं ओर ले जाएँ:

2 जी _एक्स जी _वाई - जी _एक्स - जी _एक्स > जी _वाई - 1
2 g _x g _y - 2 g _x > g _y - 1
हम कोष्ठक से बाईं ओर 2g _x निकालते हैं:
2 g _x (g _y - 1)> g _y - १
चूँकि हमारे पास g _y एक से कम है (लिमिशन केस जब g _y = 1, हम पहले ही विचार कर चुके हैं), हम g _y g1 को 1 - g _{y में} बदल देते हैं, "कम" करने के लिए "अधिक" बदलने की भूल किए बिना:
2 जी _एक्स (1 - जी _वाई ) <1 - जी _वाई

"1 - g _y " कम करें और उस स्थिति को प्राप्त करें जिसके तहत एक अतिरिक्त अनुक्रम जोड़ने से हमलावर के लिए अनुमान लगाने के लिए स्थिति में सुधार होगा:

२ ग्राम _x <१
g _x <१/२

यही है, जी _r केवल g _x से अधिक हो सकता है जब मुख्य अनुक्रम का अनुमान एक सिक्के से भी बदतर है । तब, जब हमारे भविष्यवक्ता सचेत तोड़फोड़ में लगे हुए हैं।

एन्ट्रापी के बारे में कुछ अतिरिक्त विचार।

एन्ट्रॉपी एक अत्यंत पौराणिक अवधारणा है। जानकारी - सहित। यह बहुत परेशान करने वाला है। अक्सर, सूचनात्मक एन्ट्रापी को एक प्रकार के सूक्ष्म पदार्थ के रूप में दर्शाया जाता है जो या तो डेटा में मौजूद होता है या नहीं। वास्तव में, सूचनात्मक एन्ट्रॉपी कुछ ऐसी चीज नहीं है जो सिग्नल में ही मौजूद है, बल्कि संदेश प्राप्तकर्ता के एक पूर्व जागरूकता के एक मात्रात्मक मूल्यांकन से ही संदेश के बारे में पता चलता है। यही है, यह न केवल संकेत के बारे में है, बल्कि प्राप्तकर्ता के बारे में भी है। यदि प्राप्तकर्ता को अग्रिम में संकेत के बारे में कुछ भी नहीं पता है, तो संचरित बाइनरी यूनिट की सूचना एंट्रॉपी बिल्कुल 1 बिट है, भले ही संकेत कैसे प्राप्त किया गया हो और यह क्या है।
हमारे पास एक एंट्रोपी जोड़ प्रमेय है जिसके अनुसार स्वतंत्र स्रोतों की कुल एन्ट्रोपी इन स्रोतों की एंट्रोपी के योग के बराबर है। यदि हम मुख्य अनुक्रम को संयोजन के माध्यम से अतिरिक्त के साथ जोड़ते हैं, तो हम स्रोतों की एन्ट्रोपियों को संरक्षित करेंगे, लेकिन एक बुरा परिणाम प्राप्त होगा, क्योंकि हमारे कार्य में हमें एक अलग बिट के संदर्भ में कुल एंट्रोपी नहीं, बल्कि विशिष्ट एक का मूल्यांकन करने की आवश्यकता है। स्रोतों का संघनन हमें स्रोतों की एन्ट्रापी के अंकगणितीय माध्य के बराबर परिणाम की विशिष्ट एन्ट्रापी देता है, और एन्ट्रापी कमजोर अतिरिक्त अनुक्रम स्वाभाविक रूप से परिणाम को खराब करता है। एक्सओआर ऑपरेशन के आवेदन से इस तथ्य की ओर बढ़ जाता है कि हम कुछ एन्ट्रापी खो देते हैं, लेकिन हमें गारंटी दी जाती है कि परिणामस्वरूप एन्ट्रापी शब्दों की अधिकतम एन्ट्रापी से भी बदतर नहीं होगी।
क्रिप्टोग्राफर्स में एक हठधर्मिता है: छद्म यादृच्छिक संख्या जनरेटर का उपयोग करना अक्षम्य अहंकार है। क्योंकि इन जनरेटर में एक छोटी सी विशिष्ट एन्ट्रापी होती है। लेकिन हमें अभी पता चला है कि अगर सब कुछ सही किया जाता है, तो एन्ट्रापी शहद की एक बैरल बन जाती है जिसे किसी भी मात्रा में खराब नहीं किया जा सकता है।
यदि हमारे पास वास्तविक एंट्रोपी के केवल 10 बाइट्स हैं, तो एक किलोबाइट डेटा में फैलता है, एक औपचारिक दृष्टिकोण से हमारे पास केवल 1% विशिष्ट एंट्रोपी है, जो बहुत खराब है। लेकिन अगर इन 10 बाइट्स को गुणात्मक रूप से धब्बा दिया जाता है, और जानवर बल के अलावा, इन 10 बाइट्स की गणना करने का कोई तरीका नहीं है, तो सब कुछ इतना बुरा नहीं लगता है। 10 बाइट्स 2 ^{80 है} , और अगर हमारी क्रूर शक्ति प्रति सेकंड एक ट्रिलियन विकल्पों के माध्यम से खोज करती है, तो हमें अगले चरित्र का अनुमान लगाने का तरीका जानने के लिए औसतन 19 हजार साल की आवश्यकता होगी।

जैसा कि ऊपर उल्लेख किया गया है, सूचनात्मक एन्ट्रॉपी एक सापेक्ष मूल्य है। जहां, एक विषय के लिए, विशिष्ट एंट्रॉपी 1 है, दूसरे के लिए यह अच्छी तरह से 0. हो सकता है। इसके अलावा, 1 में से किसी के पास मामलों की सही स्थिति जानने का कोई तरीका नहीं हो सकता है। प्रणाली RNG वास्तव में यादृच्छिक से हमारे लिए एक धारा अविभाज्य पैदा करती है, लेकिन हम केवल आशा कर सकते हैं कि यह वास्तव में सभी के लिए यादृच्छिक है । और विश्वास करो। यदि व्यामोह का सुझाव है कि मुख्य आरएनजी की गुणवत्ता अचानक असंतोषजनक हो सकती है, तो यह अतिरिक्त की मदद से बचाव के लिए समझ में आता है।

पायथन में एक आरएनजी को लागू करना

from random import Random, SystemRandom from random import BPF as _BPF, RECIP_BPF as _RECIP_BPF from functools import reduce as _reduce from operator import xor as _xor class CompoundRandom(SystemRandom): def __new__(cls, *sources): """Positional arguments must be descendants of Random""" if not all(isinstance(src, Random) for src in sources): raise TypeError("all the sources must be descendants of Random") return super().__new__(cls) def __init__(self, *sources): """Positional arguments must be descendants of Random""" self.sources = sources super().__init__() def getrandbits(self, k): """getrandbits(k) -> x. Generates an int with k random bits.""" ########         : return _reduce(_xor, (src.getrandbits(k) for src in self.sources), 0) def random(self): """Get the next random number in the range [0.0, 1.0).""" ########  ,   SystemRandom   .  ... return self.getrandbits(_BPF) * _RECIP_BPF

उपयोग उदाहरण:

 >>> import random_xe # <<<    >>> from random import Random, SystemRandom >>> #  : >>> myrandom1 = random_xe.CompoundRandom(SystemRandom(), Random()) >>> #    Random: >>> myrandom1.random() 0.4092251189581082 >>> myrandom1.randint(100, 200) 186 >>> myrandom1.gauss(20, 10) 19.106991205743107

SystemRandom, जिसे सही माना जाता है, को मुख्य धारा के रूप में लिया जाता है, और द्वितीयक धारा के रूप में - मानक PRSP रैंडम। इस मामले में, बहुत ज्यादा नहीं है। मानक PRNG निश्चित रूप से उस तरह का पूरक नहीं है जिसके लिए वह शुरू करने लायक था। इसके बजाय, आप एक साथ दो प्रणालीगत RNG से शादी कर सकते हैं:

 >>> myrandom2 = random_xe.CompoundRandom(SystemRandom(), SystemRandom())

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

PRSPs स्ट्रीमिंग परिपत्र हैशिंग के आधार पर

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

इस प्रक्रिया की क्रिप्टोग्राफिक ताकत दो मान्यताओं पर आधारित है:

हैश मान से मूल डेटा को पुनर्स्थापित करने का कार्य असहनीय रूप से जटिल है।
हैश मान का उपयोग करना, हैशिंग एल्गोरिथ्म की आंतरिक स्थिति को पुनर्स्थापित करना असंभव है।

एक आंतरिक विरोधाभास के साथ परामर्श करने के बाद, उन्होंने दूसरी धारणा को अनावश्यक के रूप में मान्यता दी, और इसलिए, PRNG के अंतिम कार्यान्वयन में, योजना थोड़ी जटिल है:

अब, यदि कोई हमलावर "हैश 1 आर" मान प्राप्त करने का प्रबंधन करता है, तो वह उसके बाद "हैश 2 आर" मूल्य की गणना करने में सक्षम नहीं होगा, क्योंकि उसके पास "हैश 2 एच" मूल्य नहीं है कि वह "ऊन के खिलाफ" हैश फ़ंक्शन की गणना किए बिना पहचान नहीं सकता है। इस प्रकार, इस योजना की क्रिप्टोग्राफिक ताकत प्रयुक्त हैशिंग एल्गोरिथ्म की क्रिप्टोग्राफिक ताकत से मेल खाती है।

उपयोग उदाहरण:

 >>> #  ,  HashRandom     '123': >>> myrandom3 = random_xe.CompoundRandom(SystemRandom(), random_xe.HashRandom('123')) >>> #    Random: >>> myrandom3.random() 0.8257149881148604

डिफ़ॉल्ट रूप से, SHA-256 एल्गोरिथ्म का उपयोग किया जाता है। यदि आप कुछ और चाहते हैं, तो आप दूसरे पैरामीटर के साथ वांछित प्रकार के हैशिंग एल्गोरिथ्म को कंस्ट्रक्टर को स्थानांतरित कर सकते हैं। उदाहरण के लिए, चलो एक समग्र RNG बनाते हैं, एक ढेर में निम्नलिखित को जोड़ते हैं:

1. प्रणालीगत आरएनजी (यह पवित्र है)।
2. उपयोगकर्ता इनपुट SHA3-512 एल्गोरिथ्म द्वारा संसाधित।
3. SHA-256 द्वारा संसाधित इस इनपुट पर खर्च किया गया समय।

 >>> from getpass import getpass >>> from time import perf_counter >>> from hashlib import sha3_512 #    : >>> def super_myrandom(): t_start = perf_counter() return random_xe.CompoundRandom(SystemRandom(), random_xe.HashRandom( getpass('  :'), sha3_512), random_xe.HashRandom(perf_counter() - t_start)) >>> myrandom4 = super_myrandom()   : >>> myrandom4.random() 0.35381173716740766

निष्कर्ष:

यदि हम अपने यादृच्छिक संख्या जनरेटर के बारे में निश्चित नहीं हैं, तो हम आसानी से और आश्चर्यजनक रूप से सस्ते में इस समस्या को हल कर सकते हैं।
इस समस्या का समाधान, हम बदतर नहीं कर सकते। केवल बेहतर। और यह गणितीय रूप से सिद्ध है।
हमें यह सुनिश्चित करने की कोशिश करने की भूल नहीं करनी चाहिए कि एंट्रॉपी के स्रोत स्वतंत्र हैं।

पुस्तकालय के स्रोत GitHub पर हैं।

हम इस तथ्य की यादृच्छिकता को बढ़ाते हैं कि [शायद] [लगभग] दुर्घटना से

सिद्धांत की एक बिट

पायथन में एक आरएनजी को लागू करना

PRSPs स्ट्रीमिंग परिपत्र हैशिंग के आधार पर

More articles: