यूयूआईडी कितना अनोखा है?


451

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


11
"पर्याप्त समय" के एक बड़े पर्याप्त मूल्य के लिए :)

91
"यूयूआईडी कितना अनूठा है?" मैं अद्वितीय रूप से अद्वितीय हूं। ;)
माइल्स

29
और जब तक आप शुक्र पर विकसित होने की योजना नहीं बनाते हैं, एक GUID को पर्याप्त होना चाहिए।
स्केफमैन

1
यहाँ अधिक जानकारी और जनरेटर: ऑनलाइन uuid जनरेटर
डेव

2
"अद्वितीय" का अर्थ है कभी टकराओ नहीं । यदि इसमें टकराने की कोई क्षमता है, तो यह अद्वितीय नहीं है । इसलिए परिभाषा के अनुसार, यूयूआईडी अद्वितीय और सुरक्षित नहीं है, यदि आप टकराव की संभावना के बावजूद संभावित टक्करों के लिए तैयार हैं। अन्यथा, आपका प्रोग्राम केवल गलत है। आप यूयूआईडी को "लगभग अद्वितीय" कह सकते हैं लेकिन इसका मतलब यह नहीं है कि यह "अद्वितीय" है।
Eonil

जवाबों:


446

बहुत सुरक्षित:

किसी उल्कापिंड की चपेट में आने वाले किसी व्यक्ति का वार्षिक जोखिम 17 बिलियन में एक मौका होने का अनुमान है, जिसका अर्थ है कि संभाव्यता लगभग 0.00000000006 (6 × 10 ) 11 ) है, जो यूयूआईडी के कुछ दसियों खरबों के निर्माण की बाधाओं के बराबर है। एक साल में और एक डुप्लिकेट होने से। दूसरे शब्दों में, अगले 100 वर्षों के लिए हर सेकंड 1 बिलियन यूयूआईडी बनाने के बाद, केवल एक डुप्लिकेट बनाने की संभावना लगभग 50% होगी।

चेतावनी:

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

स्रोत: विश्वविद्यालय के अद्वितीय पहचानकर्ताओं पर विकिपीडिया लेख के अनुभाग के डुप्लिकेट की यूएआईडी संभावना (लिंक खंड को फिर से संपादित करने से पहले दिसंबर 2016 से संशोधन की ओर जाता है)।

एक ही विषय पर एक ही विषय पर वर्तमान अनुभाग भी देखें विशिष्ट पहचानकर्ता लेख, टकराव


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

6
दरअसल, बहुत से काम उतने ही अटपटे ("असली यादृच्छिकता" के रूप में पेश करने के तरीकों को खोजने में चले गए हैं, मुझे लगता है कि आप इसे यादृच्छिक संख्या एपीआई में संभव के रूप में कहेंगे)। En.wikipedia.org/wiki/Entropy_%28computing%29
broOF

4
यह वास्तव में टकराव की एक उच्च संभावना है जिसकी मैंने कल्पना की थी। जन्मदिन का विरोधाभास, मुझे लगता है।
कैमरून

क्या आप इस बात की पुष्टि कर सकते हैं कि किसी एप्लिकेशन के निष्पादन के बीच UUID का उपयोग करना सुरक्षित होगा? (उदाहरण के लिए एक अजगर लिपि)
जॉर्ज एसपी

महान उदाहरण ...: D
NuttLoose

151

यदि "पर्याप्त समय दिया गया" से आपका मतलब 100 साल है और आप उन्हें एक बिलियन सेकंड की दर से बना रहे हैं, तो हाँ, आपके पास 100 साल बाद टक्कर होने का 50% मौका है।


185
लेकिन केवल उन आईडी के लिए 256 एक्साबाइट स्टोरेज का उपयोग करने के बाद।
बॉब अमन

16
मजेदार बात यह है कि, आप एक पंक्ति में 2 उत्पन्न कर सकते हैं, जो समान थे, निश्चित रूप से संयोग, भाग्य और दिव्य हस्तक्षेप के दिमाग के स्तर पर, फिर भी अथाह बाधाओं के बावजूद, यह अभी भी संभव है! : D हाँ, ऐसा नहीं होगा। सिर्फ उस पल के बारे में सोचने के लिए जब आप एक डुप्लिकेट बनाया! स्क्रीनशॉट वीडियो!
स्केलबेल 3

4
क्या विशिष्टता यादृच्छिकता के कारण विशुद्ध रूप से है? या अन्य कारक हैं? (उदा। समय टिकट, आईपी, आदि)
वीशी ज़ेंग

15
@ TheThaan यह यादृच्छिक अर्थ नहीं है। इसका मतलब यह नहीं है कि "पूरी तरह से अप्रत्याशित" - आमतौर पर वे किसी प्रकार के वितरण का पालन करते हैं। यदि आप 10 सिक्कों को पलटाते हैं, तो 2 सिर होने की संभावना, 3 पूंछ, उसके बाद 5 सिर, बहुत कम (2 ^ -10, लगभग 0.001) है। यह वास्तव में यादृच्छिक है, लेकिन हम पूरी तरह से एक विशेष परिणाम प्राप्त करने का मौका जान सकते हैं । हम सिर्फ पहले से यह नहीं कह सकते कि क्या यह होगा होता है।
रिचर्ड रास्ट

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

103

यूयूआईडी के एक से अधिक प्रकार हैं, इसलिए "कितना सुरक्षित" इस बात पर निर्भर करता है कि आप किस प्रकार (जिसे यूयूआईडी विनिर्देशन "संस्करण" कहते हैं) का उपयोग कर रहे हैं।

  • संस्करण 1 समय आधारित मैक पता UUID है। 128-बिट में नेटवर्क कार्ड के मैक पते (जो निर्माता द्वारा विशिष्ट रूप से असाइन किया गया है) के लिए 48-बिट और 100 नैनोसेकंड के संकल्प के साथ 60-बिट घड़ी है। 3603 ईस्वी में वह घड़ी लपेटती है ताकि ये UUID तब तक कम से कम सुरक्षित रहें (जब तक कि आपको 10 मिलियन से अधिक नए UUIDs प्रति सेकंड या किसी को आपके नेटवर्क कार्ड को क्लोन करने की आवश्यकता न हो)। मैं कहता हूं "कम से कम" क्योंकि घड़ी 15 अक्टूबर 1582 से शुरू होती है, इसलिए आपके पास घड़ी लपेटने से पहले लगभग 400 साल बाद भी नकल की एक छोटी संभावना है।

  • संस्करण 4 यादृच्छिक संख्या UUID है। वहाँ छह तय बिट्स और UUID के बाकी यादृच्छिकता के 122-बिट्स है। विकिपीडिया या अन्य विश्लेषण देखें जो बताता है कि नकल की संभावना कितनी कम है।

  • संस्करण 3 MD5 का उपयोग करता है और संस्करण 5 उन 122-बिट्स को बनाने के लिए SHA-1 का उपयोग करता है, बजाय एक यादृच्छिक या छद्म-यादृच्छिक उपकरण जनरेटर। तो सुरक्षा के लिहाज से यह संस्करण 4 की तरह एक सांख्यिकीय मुद्दा है (जब तक आप यह सुनिश्चित करते हैं कि डाइजेस्ट एल्गोरिथ्म क्या है प्रसंस्करण हमेशा अद्वितीय होता है)।

  • संस्करण 2 संस्करण 1 के समान है, लेकिन एक छोटी घड़ी के साथ इसलिए यह बहुत जल्दी चारों ओर लपेटने वाला है। लेकिन चूंकि संस्करण 2 UUIDs DCE के लिए हैं, इसलिए आपको इनका उपयोग नहीं करना चाहिए।

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

तो क्यों हर कोई केवल संस्करण 1 यूयूआईडी का उपयोग नहीं करता है? ऐसा इसलिए है क्योंकि संस्करण 1 UUIDs उस पर बनाए गए मशीन के मैक पते को प्रकट करते हैं और वे पूर्वानुमानित हो सकते हैं - दो चीजें जो उन यूयूआईडी का उपयोग करके आवेदन के लिए सुरक्षा निहितार्थ हो सकती हैं।


1
एक संस्करण में डिफ़ॉल्ट 1 UUID में गंभीर समस्याएं होती हैं जब वे कई लोगों के लिए एक ही सर्वर द्वारा उत्पन्न होती हैं। संस्करण 4 यूयूआईडी मेरा डिफ़ॉल्ट है क्योंकि आप किसी भी भाषा या प्लेटफ़ॉर्म (जावास्क्रिप्ट सहित) में एक उत्पन्न करने के लिए जल्दी से कुछ लिख सकते हैं।
जस्टिन बोजोनियर

1
@Hoylen अच्छी तरह से समझाया! लेकिन क्या यह अतिशयोक्ति है?
डिनोप पालोली

1
सैद्धांतिक रूप से , यह विशिष्ट रूप से निर्माता द्वारा सौंपा गया है।
ऑरेंजडॉग

4
एक डुप्लिकेट का सामना करने के लिए एक सेकंड में 10 मिलियन संस्करण 1 यूयूआईडी उत्पन्न करने की आवश्यकता नहीं है; अनुक्रम संख्या को ओवरफ्लो करने के लिए एक "टिक" की अवधि के भीतर केवल 16,384 यूयूआईडी का एक बैच उत्पन्न करना चाहिए। मैंने इसे एक ऐसे कार्यान्वयन के साथ देखा है जो एक घड़ी स्रोत पर निर्भर करता है, भोलेपन से, जिसमें (1) में μs-स्तरीय ग्रैन्युलैरिटी थी, और (2) को मोनोटोनिक होने की गारंटी नहीं थी (सिस्टम घड़ियों नहीं हैं)। सावधान रहें कि आप किस यूयूआईडी पीढ़ी के कोड का उपयोग करते हैं, और विशेष रूप से समय-आधारित यूयूआईडी जनरेटर के साथ सावधान रहें । उन्हें सही प्राप्त करना मुश्किल है, इसलिए उन्हें उपयोग करने से पहले परीक्षण लोड करने के लिए विषय करें।
माइक स्ट्रोबेल

क्या उत्पन्न v4 UUID के बीच का समय स्पैन अधिक टकराव की संभावनाओं को जन्म दे सकता है? मेरा मतलब है कि एक भारी ट्रैफ़िक एप्लिकेशन में, मान लीजिए कि एक ही समय में हज़ारों uuids उत्पन्न होते हैं, तो क्या इससे टकराव की संभावना अधिक होती है, यदि उयिड्स की समान मात्रा अपेक्षाकृत अधिक समय तक उत्पन्न हुई हो?
जोनाथन

18

इसका उत्तर काफी हद तक यूयूआईडी संस्करण पर निर्भर हो सकता है।

कई यूयूआईडी जनरेटर संस्करण 4 यादृच्छिक संख्या का उपयोग करते हैं। हालांकि, इनमें से कई उन्हें उत्पन्न करने के लिए एक छद्म संख्या जनरेटर का उपयोग करते हैं।

यदि एक छोटी सी अवधि के साथ खराब बीज वाले PRNG का उपयोग UUID उत्पन्न करने के लिए किया जाता है, तो मैं कहूंगा कि यह बिल्कुल सुरक्षित नहीं है।

इसलिए, यह केवल उतना ही सुरक्षित है जितना कि इसे उत्पन्न करने के लिए उपयोग किए जाने वाले एल्गोरिदम।

दूसरी तरफ, यदि आप इन सवालों का जवाब जानते हैं तो मुझे लगता है कि एक संस्करण 4 यूआईडी का उपयोग करने के लिए बहुत सुरक्षित होना चाहिए। वास्तव में मैं इसका उपयोग नेटवर्क ब्लॉक फाइल सिस्टम पर ब्लॉक की पहचान करने के लिए कर रहा हूं और अब तक कोई टकराव नहीं हुआ है।

मेरे मामले में, मैं जिस PRNG का उपयोग कर रहा हूं वह एक mersenne ट्विस्टर है और मैं इस तरह से बोए जाने के तरीके से सावधान रह रहा हूं जो कई स्रोतों से है / dev / urandom सहित। Mersenne ट्विस्टर की अवधि 2 ^ 19937 है - 1. यह एक बहुत लंबा समय होने जा रहा है इससे पहले कि मैं एक दोहराव देखता हूं।


14

विकिपीडिया से उद्धरण :

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

यह वास्तव में कितना सुरक्षित है, इस पर बहुत अच्छे तरीके से व्याख्या करता है। तो आपके प्रश्न का उत्तर देने के लिए: हाँ, यह पर्याप्त सुरक्षित है।


9

मैं अन्य उत्तरों के साथ सहमत हूं। UUIDs लगभग सभी व्यावहारिक उद्देश्यों के लिए सुरक्षित पर्याप्त हैं 1 , और निश्चित रूप से तुम्हारा के लिए।

लेकिन मान लीजिए (काल्पनिक रूप से) वे नहीं हैं।

क्या इस मुद्दे को कम करने के लिए एक बेहतर प्रणाली या किसी प्रकार का एक पैटर्न है?

यहाँ कुछ दृष्टिकोण हैं:

  1. एक बड़े UUID का उपयोग करें। उदाहरण के लिए, 128 यादृच्छिक बिट्स के बजाय, 256 या 512 का उपयोग करें या ... प्रत्येक प्रकार जिसे आप टाइप -4 शैली में जोड़ते हैं, UUID आधे से टकराव की संभावना को कम करेगा, यह मानते हुए कि आपके पास एंट्रोपी 2 का एक विश्वसनीय स्रोत है ।

  2. एक केंद्रीकृत या वितरित सेवा का निर्माण करें जो यूयूआईडी बनाता है और हर एक को रिकॉर्ड करता है जिसे उसने कभी जारी किया है। हर बार यह एक नया निर्माण करता है, यह जाँचता है कि यूयूआईडी पहले कभी जारी नहीं किया गया है। इस तरह की सेवा को लागू करने के लिए तकनीकी रूप से सीधे-आगे होगा (मुझे लगता है) यदि हम मानते हैं कि सेवा चलाने वाले लोग बिल्कुल भरोसेमंद, अस्थिर, वगैरह थे। दुर्भाग्य से, वे नहीं हैं ... खासकर जब सरकारों के सुरक्षा संगठनों के हस्तक्षेप की संभावना होती है। तो, यह दृष्टिकोण संभवतः अव्यवहारिक है, और वास्तविक दुनिया में 3 असंभव हो सकता है।


1 - यदि यूयूआईडी की विशिष्टता यह निर्धारित करती है कि क्या परमाणु मिसाइलें आपके देश की राजधानी शहर में लॉन्च की गई हैं, तो आपके बहुत से साथी नागरिकों को "संभावना बेहद कम है" से आश्वस्त नहीं किया जाएगा। इसलिए मेरी "लगभग सभी" योग्यता।

2 - और यहाँ आपके लिए एक दार्शनिक प्रश्न है। क्या वास्तव में कुछ भी यादृच्छिक है? अगर यह नहीं होता तो हम कैसे जानते होंगे? क्या ब्रह्मांड जैसा कि हम जानते हैं कि यह एक अनुकरण है? क्या कोई ईश्वर है जो एक परिणाम को बदलने के लिए भौतिकी के नियमों को "ट्विक" कर सकता है?

3 - यदि किसी को इस समस्या के बारे में कोई शोध पत्र पता है, तो कृपया टिप्पणी करें।


मैं केवल यह बताना चाहता हूं कि विधि संख्या 2 मूल रूप से UUID का उपयोग करने के मुख्य उद्देश्य को हरा देती है और आप उस बिंदु पर सिर्फ एक क्लासिक क्रमांकित आईडी का उपयोग कर सकते हैं।
पेट्र वेनक

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

8

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

UUID का उपयोग करने का पूरा बिंदु यह है कि आप इस पर भरोसा करते हैं कि एक विशिष्ट आईडी प्रदान करने का बेहतर काम आप स्वयं कर पाएंगे। अपने स्वयं के रोल करने के बजाय एक 3 पार्टी क्रिप्टोग्राफी लाइब्रेरी का उपयोग करने के पीछे यह एक ही तर्क है। इसे स्वयं करना अधिक मज़ेदार हो सकता है, लेकिन ऐसा करने के लिए आमतौर पर यह कम जिम्मेदार होता है।


6

वर्षों से कर रहे हैं। कभी किसी समस्या में न दौड़ें।

मैं आमतौर पर अपने डीबी को एक टेबल के लिए सेट करता हूं जिसमें सभी कुंजी और संशोधित तिथियां होती हैं और ऐसे। कभी डुप्लिकेट कुंजियों की समस्या में नहीं चले।

एकमात्र दोष यह है कि यह तब होता है जब आप कुछ प्रश्नों को लिखने के लिए जल्दी से कुछ जानकारी प्राप्त करने के लिए लिख रहे हैं और आप कुंजी की नकल और पेस्ट कर रहे हैं। आपके पास अब आईडी को याद रखने के लिए कम आसान नहीं है।


5

यहाँ आप के लिए एक परीक्षण स्निपेट है जो कि इसका परीक्षण करने के लिए अद्वितीय है। @ scalabl3 की टिप्पणी से प्रेरित है

मजेदार बात यह है कि, आप एक पंक्ति में 2 उत्पन्न कर सकते हैं, जो समान थे, निश्चित रूप से संयोग, भाग्य और दिव्य हस्तक्षेप के दिमाग के स्तर पर, फिर भी अथाह बाधाओं के बावजूद, यह अभी भी संभव है! : D हाँ, ऐसा नहीं होगा। सिर्फ उस पल के बारे में सोचने के लिए जब आप एक डुप्लिकेट बनाया! स्क्रीनशॉट वीडियो! - स्केलबेल 3 अक्टूबर 20 '15 को 19:11 बजे

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

Math.log2 = Math.log2 || function(n){ return Math.log(n) / Math.log(2); }
  Math.trueRandom = (function() {
  var crypt = window.crypto || window.msCrypto;

  if (crypt && crypt.getRandomValues) {
      // if we have a crypto library, use it
      var random = function(min, max) {
          var rval = 0;
          var range = max - min;
          if (range < 2) {
              return min;
          }

          var bits_needed = Math.ceil(Math.log2(range));
          if (bits_needed > 53) {
            throw new Exception("We cannot generate numbers larger than 53 bits.");
          }
          var bytes_needed = Math.ceil(bits_needed / 8);
          var mask = Math.pow(2, bits_needed) - 1;
          // 7776 -> (2^13 = 8192) -1 == 8191 or 0x00001111 11111111

          // Create byte array and fill with N random numbers
          var byteArray = new Uint8Array(bytes_needed);
          crypt.getRandomValues(byteArray);

          var p = (bytes_needed - 1) * 8;
          for(var i = 0; i < bytes_needed; i++ ) {
              rval += byteArray[i] * Math.pow(2, p);
              p -= 8;
          }

          // Use & to apply the mask and reduce the number of recursive lookups
          rval = rval & mask;

          if (rval >= range) {
              // Integer out of acceptable range
              return random(min, max);
          }
          // Return an integer that falls within the range
          return min + rval;
      }
      return function() {
          var r = random(0, 1000000000) / 1000000000;
          return r;
      };
  } else {
      // From http://baagoe.com/en/RandomMusings/javascript/
      // Johannes Baagøe <baagoe@baagoe.com>, 2010
      function Mash() {
          var n = 0xefc8249d;

          var mash = function(data) {
              data = data.toString();
              for (var i = 0; i < data.length; i++) {
                  n += data.charCodeAt(i);
                  var h = 0.02519603282416938 * n;
                  n = h >>> 0;
                  h -= n;
                  h *= n;
                  n = h >>> 0;
                  h -= n;
                  n += h * 0x100000000; // 2^32
              }
              return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
          };

          mash.version = 'Mash 0.9';
          return mash;
      }

      // From http://baagoe.com/en/RandomMusings/javascript/
      function Alea() {
          return (function(args) {
              // Johannes Baagøe <baagoe@baagoe.com>, 2010
              var s0 = 0;
              var s1 = 0;
              var s2 = 0;
              var c = 1;

              if (args.length == 0) {
                  args = [+new Date()];
              }
              var mash = Mash();
              s0 = mash(' ');
              s1 = mash(' ');
              s2 = mash(' ');

              for (var i = 0; i < args.length; i++) {
                  s0 -= mash(args[i]);
                  if (s0 < 0) {
                      s0 += 1;
                  }
                  s1 -= mash(args[i]);
                  if (s1 < 0) {
                      s1 += 1;
                  }
                  s2 -= mash(args[i]);
                  if (s2 < 0) {
                      s2 += 1;
                  }
              }
              mash = null;

              var random = function() {
                  var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
                  s0 = s1;
                  s1 = s2;
                  return s2 = t - (c = t | 0);
              };
              random.uint32 = function() {
                  return random() * 0x100000000; // 2^32
              };
              random.fract53 = function() {
                  return random() +
                      (random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
              };
              random.version = 'Alea 0.9';
              random.args = args;
              return random;

          }(Array.prototype.slice.call(arguments)));
      };
      return Alea();
  }
}());

Math.guid = function() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c)    {
      var r = Math.trueRandom() * 16 | 0,
          v = c == 'x' ? r : (r & 0x3 | 0x8);
      return v.toString(16);
  });
};
function logit(item1, item2) {
    console.log("Do "+item1+" and "+item2+" equal? "+(item1 == item2 ? "OMG! take a screenshot and you'll be epic on the world of cryptography, buy a lottery ticket now!":"No they do not. shame. no fame")+ ", runs: "+window.numberofRuns);
}
numberofRuns = 0;
function test() {
   window.numberofRuns++;
   var x = Math.guid();
   var y = Math.guid();
   var test = x == y || historyTest(x,y);

   logit(x,y);
   return test;

}
historyArr = [];
historyCount = 0;
function historyTest(item1, item2) {
    if(window.luckyDog) {
       return false;
    }
    for(var i = historyCount; i > -1; i--) {
        logit(item1,window.historyArr[i]);
        if(item1 == history[i]) {
            
            return true;
        }
        logit(item2,window.historyArr[i]);
        if(item2 == history[i]) {
            
            return true;
        }

    }
    window.historyArr.push(item1);
    window.historyArr.push(item2);
    window.historyCount+=2;
    return false;
}
luckyDog = false;
document.body.onload = function() {
document.getElementById('runit').onclick  = function() {
window.luckyDog = document.getElementById('lucky').checked;
var val = document.getElementById('input').value
if(val.trim() == '0') {
    var intervaltimer = window.setInterval(function() {
         var test = window.test();
         if(test) {
            window.clearInterval(intervaltimer);
         }
    },0);
}
else {
   var num = parseInt(val);
   if(num > 0) {
        var intervaltimer = window.setInterval(function() {
         var test = window.test();
         num--;
         if(num < 0 || test) {
    
         window.clearInterval(intervaltimer);
         }
    },0);
   }
}
};
};
Please input how often the calulation should run. set to 0 for forever. Check the checkbox if you feel lucky.<BR/>
<input type="text" value="0" id="input"><input type="checkbox" id="lucky"><button id="runit">Run</button><BR/>


RFC 4122 संस्करण 1 (दिनांक-समय और मैक पते) UUID के साथ प्रयास करें।
zaph

हाल ही में क्रोम अपडेट होने तक यह तेजी से धधक रहा था। मैंने 4 हफ्ते पहले भी ऐसा ही देखा था।

3

मुझे नहीं पता कि यह आपके लिए मायने रखता है, लेकिन ध्यान रखें कि GUIDs विश्व स्तर पर अद्वितीय हैं, लेकिन GUID के सबस्ट्रिंग नहीं हैं


1
ध्यान रखें कि यहां से जुड़ा संदर्भ संस्करण 1 यूयूआईडी (जो आईडी में जनरेटिंग कंप्यूटर आदि के बारे में जानकारी लेता है) के बारे में बात करता है। अधिकांश अन्य उत्तर संस्करण 4 के बारे में बात करते हैं (जो पूरी तरह से यादृच्छिक हैं)। उपरोक्त लिंक विकिपीडिया लेख en.wikipedia.org/wiki/Universally_unique_identifier यूयूआईडी के विभिन्न प्रकारों की व्याख्या करता है।
क्रेटेंको

3

UUID4 के लिए मैं इसे बनाता हूं कि लगभग आईडी के रूप में कई आईडी हैं, जो घन-आकार वाले बॉक्स में रेत के दाने हैं, जिनकी लंबाई 360,000 किमी है। यह बृहस्पति के व्यास की तुलना में पक्षों के साथ एक बॉक्स है ~ 2 1/2 बार।

काम करना तो कोई मुझे बता सकता है कि क्या मैंने इकाइयों को गड़बड़ कर दिया है:

  • रेत के दाने की मात्रा 0.00947 मिमी ^ 3 ( अभिभावक )
  • UUID4 में 122 यादृच्छिक बिट्स हैं -> 5.3e36 संभावित मान ( विकिपीडिया )
  • रेत के कई दानों की मात्रा = 5.0191e34 mm ^ 3 या 5.0191e + 25m ^ 3
  • उस वॉल्यूम के साथ क्यूबिक बॉक्स की साइड लंबाई = 3.69E8m या 369,000 किमी
  • बृहस्पति का व्यास: 139,820 किमी (गूगल)

वास्तव में मुझे लगता है कि यह 100% पैकिंग मानता है इसलिए शायद मुझे इसके लिए एक कारक जोड़ना चाहिए!
खो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.