दिलचस्प पोस्ट
किसी भी गहराई पर नाम के तत्वों के लिए XDocument क्वेरी करें क्या मुझे JPA संस्थाओं में बराबर () लिखना चाहिए? उद्धरण चिह्नों के साथ उद्धृत स्ट्रिंग के लिए रेगेक्स एडीबी – एंड्रॉइड – वर्तमान गतिविधि का नाम लेना दिनों में दिन में जावा में कैसे जोड़ सकते हैं आईओएस 8 पर वॉल्यूम अप / डाउन बटन प्रेस कैप्चर करने का सबसे सुरक्षित तरीका मैं डीआईवी को कीबोर्ड फोकस कैसे दे सकता हूं और इसमें कीबोर्ड इवेंट हैंडलर्स को अटैच कर सकता हूं? PHP में मशीन का आईपी पता है :: 1 लेकिन क्यों? HTML <base> टैग और इंटरनेट एक्सप्लोरर के साथ स्थानीय फ़ोल्डर पथ सभी 4 दिशाओं में कड़ी चोट की पहचान कैसे करें यूआरएल फिर से लिखना के लिए फिर से लिखना-कोड MultipleActiveResultSets = सच या एकाधिक कनेक्शन? जावा वर्ग को तुलनीय क्यों लागू करना चाहिए? कचरा संग्रहण सी ++ में – क्यों? बिगडीकैम बराबर () बनाम तुलना करें ()

Java.util.Random और java.security.SecureRandom के बीच का अंतर

मेरी टीम ने कुछ सर्वर साइड कोड (जावा में) को सौंप दिया जो कि यादृच्छिक टोकन उत्पन्न करता है और मेरे पास एक ही सवाल है –

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

कोड इन टोकनों को उत्पन्न करने के लिए वर्तमान में java.util.Random वर्ग का उपयोग करता है। दस्तावेज ([ http://docs.oracle.com/javase/7/docs/api/java/util/Random.html][1] ) java.util.Random स्पष्ट रूप से निम्न बताता है:

Java.util.Random के उदाहरण क्रिप्टोग्राफ़िक रूप से सुरक्षित नहीं हैं। सुरक्षा-संवेदनशील अनुप्रयोगों द्वारा उपयोग के लिए क्रिप्टोग्राफ़िक रूप से सुरक्षित छद्म यादृच्छिक संख्या जनरेटर प्राप्त करने के लिए सिक्योररेन्डम का उपयोग करने के बजाय पर गौर करें।

हालांकि, जिस तरह से कोड वर्तमान में java.util.Random का उपयोग कर रहा है यह है – यह java.util.RandomSecureRandom.nextLong() . SecureRandom.nextLong() वर्ग को तत्काल प्रदान करता है और फिर java.util.Random SecureRandom.nextLong() को तत्काल उपयोग करने के लिए उपयोग किए जाने वाले बीज को प्राप्त करने के लिए SecureRandom.nextLong() java.util.Random वर्ग तो यह टोकन उत्पन्न करने के लिए java.util.Random.nextLong() विधि का उपयोग करता है।

तो मेरा सवाल अब – क्या यह अभी भी असुरक्षित है कि java.security.SecureRandomjava.security.SecureRandomjava.security.SecureRandom का उपयोग करके बीजगणित किया जा रहा है? क्या मुझे कोड को संशोधित करने की आवश्यकता है ताकि वह टोकन उत्पन्न करने के लिए केवल java.security.SecureRandom का उपयोग कर सके?

वर्तमान में कोड बीज के स्टार्टअप पर एक बार Random

Solutions Collecting From Web of "Java.util.Random और java.security.SecureRandom के बीच का अंतर"

मानक ओरेकल जेडीके 7 के कार्यान्वयन का उपयोग करता है जो लावायर बधाई जेनरेटर को यादृच्छिक मूल्यों को java.util.Randomjava.util.Random में उत्पन्न करता है। यादृच्छिक।

Java.util.Random स्रोत कोड (जेडीके 7u2) से लिया गया, विधि से protected int next(int bits) पर एक टिप्पणी से, जो कि यादृच्छिक मूल्यों को उत्पन्न करता है:

यह एक रैखिक congraential छद्म यादृच्छिक संख्या जनरेटर है, जैसा डीएच लेहमर द्वारा परिभाषित किया गया है और कंप्यूटर प्रोग्रामिंग की कला में डोनाल्ड ई। नुत द्वारा वर्णित है , वॉल्यूम 3: सेमिनिमिकल एल्गोरिदम , खंड 3.2.1।

रैखिक बधाई जनरेटर की भविष्यवाणी

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

कैसे एक रैखिक बधाई जेनरेटर तोड़ने के लिए

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

सुरक्षा "बेहतर" बीज के साथ सुधार नहीं करता है यह बस कोई फर्क नहीं पड़ता अगर आप SecureRandom द्वारा उत्पन्न बेतरतीब मान के साथ बीज या कई बार मरने से भी मूल्य का उत्पादन करते हैं

एक हमलावर बस मनाया गया उत्पादन मूल्यों से बीज की गणना करेगा। यह java.util.Random के मामले में 2 ^ 48 से काफी कम समय लेता है। अविश्वासी इस प्रयोग का प्रयास कर सकते हैं, जहां यह दिखाया जाता है कि आप अनुमान लगा सकते हैं कि भविष्य में केवल दो (!) आउटपुट मानों का अनुमान लगाया जा सकता है, जबकि लगभग 2 ^ 16 यह अभी एक आधुनिक कंप्यूटर पर दूसरा भी नहीं लेता है ताकि आपके यादृच्छिक संख्याओं के उत्पादन का अनुमान लगाया जा सके।

निष्कर्ष

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

एक यादृच्छिक में केवल 48 बिट्स हैं, जहां से सुरक्षितरेन्डम 128 बिट तक हो सकता है। इसलिए सुरक्षित पुनरारंभ में दोहराए जाने की संभावना बहुत छोटी है

रैंडम system clock को बीज के रूप में उपयोग करता है / या बीज उत्पन्न करने के लिए। इसलिए उन्हें आसानी से पुन: प्रस्तुत किया जा सकता है यदि हमलावर उस समय को जानता है जिस पर बीज उत्पन्न हुआ था। लेकिन सिक्योररेन्डम अपने os से Random Data लेता है (वे कीस्ट्रोक्स आदि के बीच अंतराल हो सकते हैं – सबसे अधिक ओएस इन डेटा को संग्रहीत करता है – /dev/random and /dev/urandom in case of linux/solaris ) और इसका उपयोग बीज के रूप में करता है।
इसलिए अगर छोटे टोकन का आकार ठीक है (रैंडम के मामले में), तो आप अपने कोड का उपयोग बिना किसी बदलाव के जारी रख सकते हैं, क्योंकि आप बीज उत्पन्न करने के लिए सुरक्षितरेन्डम का उपयोग कर रहे हैं। लेकिन अगर आप बड़े टोकन चाहते हैं (जो brute force attacks अधीन नहीं हो सकता है) सुरक्षितरेन्डम के साथ जाना –
यादृच्छिक के मामले में सिर्फ 2^48 प्रयास आवश्यक हैं, आज के उन्नत सीपीयू के साथ व्यावहारिक समय में इसे तोड़ना संभव है। लेकिन सुरक्षित के लिए 2^128 प्रयासों की आवश्यकता होगी, जो आज की उन्नत मशीनों के साथ भी तोड़ने के लिए साल और साल लगेंगे।

अधिक जानकारी के लिए इस लिंक को देखें।
संपादित करें
@ एंबॉस द्वारा प्रदान किए गए लिंक को पढ़ने के बाद, यह स्पष्ट है कि बीज, हालांकि इसे यादृच्छिक रूप से याद किया जाता है, इसे जावा के साथ नहीं किया जाना चाहिए। उत्पादन को देख कर बीजों की गणना करना बहुत आसान है

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

नोट – यदि आप nextBytes() को कॉल कर रहे हैं, तो आपके ओएस की तुलना में अधिक तेजी से /dev/random में यादृच्छिक बाइट्स (एन्ट्रापी) लिखने में सक्षम है, तो आप nextBytes() का प्रयोग करते समय परेशानी में पड़ सकते हैं। उस मामले में सुरक्षित रैंडम के SHA1 PRNG उदाहरण का उपयोग करें और हर कुछ मिनट (या कुछ अंतराल), इस उदाहरण को nextBytes() के नेटिव पीआरएनजी उदाहरण के अगले nextBytes() से मूल्य के साथ बीज दें इन दोनों को समान रूप से चलाना यह सुनिश्चित करेगा कि आप नियमित रूप से सच्चे यादृच्छिक मूल्यों के साथ सीडिंग कर रहे हैं, जबकि ऑपरेटिंग सिस्टम द्वारा प्राप्त एंटरपीपी को भी थका नहीं।

यदि आप दो बार java.util.Random.nextLong() को उसी बीज के साथ चलाते हैं, तो यह उसी नंबर का उत्पादन करेगा। सुरक्षा कारणों से आप java.security.SecureRandom साथ रहना चाहते हैं क्योंकि यह बहुत कम उम्मीद के मुताबिक है।

2 क्लासेस समान हैं, मुझे लगता है कि आपको एक SecureRandom टूल के साथ Random में SecureRandom को बदलने की जरूरत है और आपका मौजूदा कोड काम करेगा।

यदि आपका मौजूदा कोड बदलना एक सस्ती कार्य है, तो मेरा सुझाव है कि आप जवाडॉक में सुझाए गए सिक्योररेन्डम कक्षा का उपयोग करें।

यहां तक ​​कि अगर आपको पता चलता है कि रैंडम क्लास कार्यान्वयन आंतरिक रूप से सिक्योररेन्डम वर्ग का उपयोग करता है आपको यह स्वीकार नहीं करना चाहिए कि:

  1. अन्य वीएम क्रियान्वयन एक ही काम करते हैं
  2. जेडडीके के भविष्य के संस्करणों में यादृच्छिक वर्ग के कार्यान्वयन अभी भी सिक्योररेन्डम कक्षा का उपयोग करते हैं

इसलिए यह दस्तावेज़ीकरण सुझाव का पालन करने और सिक्योररेन्डम के साथ सीधे जाने के लिए बेहतर विकल्प है।

बीज व्यर्थ है एक अच्छा यादृच्छिक जनरेटर चुना primenumber में अलग है प्रत्येक यादृच्छिक जनरेटर एक संख्या से शुरू होता है और 'अंगूठी' के माध्यम से पुनरावृत्त करता है इसका अर्थ है, आप पुराने नंबर के साथ, एक नंबर से दूसरे पर आते हैं। लेकिन कुछ समय बाद आप फिर से शुरुआत करते हैं और फिर से शुरू करते हैं। तो आप साइकिल चलाते हैं (एक यादृच्छिक जनरेटर से वापसी मूल्य आंतरिक मूल्य नहीं है)

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

पहले तत्व को फिर से लौटने से पहले, उच्च प्राथमिक संख्याओं का अर्थ है, लंबे चक्र, फिर से। इसलिए, सुरक्षित यादृच्छिक जनरेटर के पास सिर्फ एक चक्र है, शुरुआत से पहले पहुंचने से पहले, इसलिए यह सुरक्षित क्यों है आप छोटी पीढ़ी के साथ जितना आसान हो उतनी संख्या का अनुमान नहीं लगा सकते।

दूसरे शब्दों के साथ: आपको सभी को बदलना होगा।

वर्तमान संदर्भ का कार्यान्वयन java.util.Random.nextLong() next(int) कॉल java.util.Random.nextLong() दो कॉल करता है जो सीधे वर्तमान बीड के 32 बिट को उजागर करता है:

 protected int next(int bits) { long nextseed; // calculate next seed: ... // and store it in the private "seed" field. return (int)(nextseed >>> (48 - bits)); } public long nextLong() { // it's okay that the bottom word remains signed. return ((long)(next(32)) << 32) + next(32); } 

अगले nextLong() के परिणाम के ऊपरी 32 बिट समय में बीजों का nextLong() । चूंकि बीज की चौड़ाई 48 बिट है (जवाडोक कहती है), यह शेष * 16 बिट (जो कि केवल 65.536 की कोशिश करता है) पर पुनरावृति करने के लिए * पर्याप्त होता है, जो कि दूसरे 32 बिट का उत्पादन करने वाला बीज निर्धारित करता है

एक बार बीज ज्ञात हो जाने पर, सभी निम्नलिखित टोकन को आसानी से गणना की जा सकती है।

nextLong() के उत्पादन का उपयोग सीधे, एक अंश में पीएनजी का रहस्य, जो पूरे रहस्य को बहुत कम efford के साथ गिना जा सकता है। खतरनाक!

* यदि कुछ 32 सेंटीग्रेड नकारात्मक हैं तो कुछ प्रयास किए जा सकते हैं, लेकिन कोई उसे ढूंढ सकता है।