मैं सार्वजनिक कुंजी एन्क्रिप्शन एल्गोरिदम में उपयोग करने के लिए सी में 2^64 के क्रम में बड़ी यादृच्छिक संख्या उत्पन्न करने के लिए एक तरीका ढूंढ रहा हूं ... (100000000 - 99 99 99 999) पी और क्यू)।बड़ी यादृच्छिक संख्याएं कैसे उत्पन्न करें सी
मैं 2^64 (यानी, 100000000 से छोटा) से छोटा संख्या उत्पन्न नहीं करना चाहता हूं।
क्या ऐसा कुछ भी है जो मुझे ऐसा करने में मदद कर सकता है?
यादृच्छिक() एक लंबे समय तक लौटाता है जो 64 बिट सिस्टम 64 बिट्स होना चाहिए।
#include <inttypes.h>
uint64_t num;
/* add code to seed random number generator */
num = rand();
num = (num << 32) | rand();
// enforce limits of value between 100000000 and 999999999
num = (num % (999999999 - 100000000)) + 100000000;
:: यदि आप एक 32bit प्रणाली पर हैं, तो आप निम्न कर सकता है
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <inttypes.h>
int fd;
uint64_t num;
if ((fd = open("/dev/random", O_RDONLY) == -1)
{
/* handle error */
};
read(fd, &num, 8);
close(fd);
// enforce limits of value between 100000000 and 999999999
num = (num % (999999999 - 100000000)) + 100000000;
एक
'rand()' 'RAND_MAX' द्वारा सीमित है जो आवश्यक नहीं है' 2^32'। और, आपको अभी भी 'srand()' पास करने के लिए कुछ चाहिए। '/ dev/random' कार्यक्षमता [अन्य प्लेटफ़ॉर्म] पर भी उपलब्ध है (http://en.wikipedia.org/wiki//dev/random)। –
यह "100000000 से छोटा नंबर उत्पन्न नहीं करना चाहता" आवश्यकता को पूरा नहीं करता है। –
पंक्ति 'num = (num% (99 99 99 999 - 100000000)) + 100000000; '100000000 की निचली सीमा की यादृच्छिक संख्या और 99 99 99 999 की ऊपरी सीमा उत्पन्न करने के लिए। –
आप एक क्रिप्टोग्राफिक शक्ति PRNG के लिए देख रहे हैं, openssl/rand की तरह: http://www.openssl.org/docs/crypto/rand.html
या [BCryptGenRandom] (http://msdn.microsoft.com/en-us/library/aa375458%28v=VS.85%29.aspx)। –
+1: इसके लिए 'रैंड()' का उपयोग करना एक सुरक्षा छेद है ('रैंड()' के आउटपुट की भविष्यवाणी करना बहुत चुनौतीपूर्ण नहीं है) –
आप छोटी संख्याओं से बाहर एक बड़ी संख्या L कर सकते हैं (उदाहरण के लिए A & B)। उदाहरण के लिए, L = (2^ n)*A + B जैसे कुछ के साथ^^ एक्सपोनेंटिएशन को इंगित करता है और n कुछ स्थिर पूर्णांक (उदा। 32) है। फिर आप 2 ऑपरेशन की शक्ति के लिए 1<<n (बिटवाई बाएं-शिफ्ट) कोड करते हैं।
तो आप बड़ी यादृच्छिक संख्याओं की एक बड़ी यादृच्छिक संख्या बना सकते हैं।
आप दो 4 बाइट यादृच्छिक पूर्णांकों गठबंधन एक 8 बाइट एक निर्माण करने के लिए कर सकते हैं:
#include <stdint.h>
...
uint64_t random =
(((uint64_t) rand() << 0) & 0x00000000FFFFFFFFull) |
(((uint64_t) rand() << 32) & 0xFFFFFFFF00000000ull);
rand के बाद रिटर्न int, और sizeof(int) >= 4 लगभग किसी भी आधुनिक मंच पर, इस कोड को काम करना चाहिए। इरादे को और स्पष्ट बनाने के लिए मैंने << 0 जोड़ा है।
0x00000000FFFFFFFF और 0xFFFFFFFF00000000 के साथ मास्किंग sizeof(int) > 4 के मामले में दो संख्याओं में बिट्स के ओवरलैपिंग को रोकने के लिए है।
संपादित
के बाद से @Banthar टिप्पणी की है कि RAND_MAX जरूरी 2^32 नहीं है, और मुझे लगता है कि यह कम से कम 2^16, आप चार 2-बाइट संख्या जोड़ सकता बस सुनिश्चित करने के होने की गारंटी है:
uint64_t random =
(((uint64_t) rand() << 0) & 0x000000000000FFFFull) |
(((uint64_t) rand() << 16) & 0x00000000FFFF0000ull) |
(((uint64_t) rand() << 32) & 0x0000FFFF00000000ull) |
(((uint64_t) rand() << 48) & 0xFFFF000000000000ull);
यदि आप '|' के बजाय संख्याओं को गठबंधन करने के लिए '^' का उपयोग करते हैं, तो आपको मास्किंग के बारे में चिंता करने की आवश्यकता नहीं है। – caf
मुझे पता है कि मुझे शायद ओली चेर्लेसवर्थ द्वारा b____slapped मिल जाएगा, लेकिन स्केल() को स्केल और ऑफ़सेट के साथ उपयोग करें। यह stdlib.h में है। पूरी श्रृंखला को कवर करने के लिए आपको मैपिंग में अंतराल को भरने के लिए इसे एक और छोटे रैंड() में जोड़ना चाहिए।
या, आप इंडेपेन्टेंट बीजों के साथ दो यादृच्छिक संख्या जेनरेटर का उपयोग कर सकते हैं और सुझाव के अनुसार अपने आउटपुट नंबर एक साथ रख सकते हैं। यह निर्भर करता है कि क्या आप 2^64 की सीमा में एक आरएनजी की 64 बिट संख्या चाहते हैं। बस उस समय पर निर्भर डिफ़ॉल्ट कॉल का उपयोग न करें, क्योंकि आपको प्रत्येक जनरेटर के लिए समान बीज मिलेंगे। सही तरीका, मुझे बस पता नहीं है ...
2^64 99 99 99 999 से काफी अधिक है।Windows Vista और उच्चतर पर –