Php में एक यादृच्छिक पासवर्ड जनरेट करना

190

मैं php में एक यादृच्छिक पासवर्ड उत्पन्न करने की कोशिश कर रहा हूँ।

हालाँकि मुझे सब मिल रहा है और वापसी प्रकार प्रकार की है और मैं चाहूंगा कि यह एक स्ट्रिंग हो। कोड को सही करने के बारे में कोई विचार?

धन्यवाद।

function randomPassword() {
    $alphabet = "abcdefghijklmnopqrstuwxyzABCDEFGHIJKLMNOPQRSTUWXYZ0123456789";
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, count($alphabet)-1);
        $pass[$i] = $alphabet[$n];
    }
    return $pass;
}

— nunos
स्रोत

9

कोई भी उत्तर सुरक्षित रैंडम नंबर जनरेटर का उपयोग नहीं करता है , जिसे आप पासवर्ड के लिए चाहते हैं।

— स्कॉट आर्किस्ज़वेस्की

4

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

— जेरेमी बैंक्स

6

@JeremyBanks कहीं भी यह सवाल नहीं है कि क्रिप्टोग्राफिक रूप से सुरक्षित पासवर्ड की आवश्यकता है। कुछ लोगों के लिए, उपयोग करने वाले उत्तर /dev/randomपर्याप्त हैं क्योंकि प्रश्न " सुरक्षित " पासवर्ड के लिए नहीं पूछता है (और इसमें इसे संपादित नहीं किया जाना चाहिए क्योंकि यह मूल प्रश्न का अर्थ बदल देगा)। हालांकि मैं सुरक्षा के लिए हूं, लेकिन मुझे लगता है कि यह कालीन बम पूरी तरह से नहीं सोचा गया था। उपयोग की तरह mysql_*, उत्तर अभी भी मान्य हैं, लेकिन असुरक्षित के रूप में चिह्नित किया जाना चाहिए। शायद यह कुछ ऐसा है जो एसओ को अतिरिक्त सॉफ़्टवेयर के रूप में शामिल करने की आवश्यकता है - असुरक्षित कोड की चेतावनी देने की क्षमता ?

— जिम्बो

6

@JeremyBanks क्या आप इस प्रश्न के उत्तर को पुनः स्थापित कर सकते हैं? सिर्फ इसलिए कि यह एक डुप्लिकेट है इसका मतलब यह नहीं है कि उत्तर गलत हैं (मैं गलती से फिर से खोलने के लिए मतदान करता हूं, मैं मानता हूं कि यह एक डुप्लिकेट है)। इसका उत्तर हटाने का कोई मतलब नहीं है, इस प्रश्न को हटाने के बजाय विचार करें और दूसरे प्रश्न के उत्तर को माइग्रेट करें (मैंने इसे पहले किया है)।

— नफतली उर्फ नील

7

@JeremyBanks यदि आप चाहते हैं कि कुछ फिर से खोला नहीं जाए, तो उसे लॉक करें। अन्यथा 99% लोग इसे फिर से खोलेंगे और एक पूरी गड़बड़ पैदा करेंगे। व्यक्तिगत रूप से मैं उस तरह से अत्यधिक स्कोर वाले उत्तरों को हटाने से पूरी तरह असहमत हूं, लेकिन आप इस पर नहीं लड़ सकते

— शैडो विजार्ड इयर फॉर यू

258

सुरक्षा चेतावनी : rand()क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी संख्या जनरेटर नहीं है। PHP में क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी स्ट्रिंग पैदा करने के लिए कहीं और देखें ।

इसे आज़माएं ( strlenइसके बजाय उपयोग करें count, क्योंकि countएक स्ट्रिंग हमेशा होती है 1):

function randomPassword() {
    $alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
    $pass = array(); //remember to declare $pass as an array
    $alphaLength = strlen($alphabet) - 1; //put the length -1 in cache
    for ($i = 0; $i < 8; $i++) {
        $n = rand(0, $alphaLength);
        $pass[] = $alphabet[$n];
    }
    return implode($pass); //turn the array into a string
}

डेमो: http://codepad.org/UL8k4aYK

— नील
स्रोत

24

उपयोग करने के लिए अधिक सीधा लगता है $pass .= $alphabet[$n]।

— मैथ्यू

33

रैंड का उपयोग करके पासवर्ड उत्पन्न करना वास्तव में एक बुरा विचार है। यह एक सुरक्षित PRNG नहीं है। (और कोई भी बेहतर नहीं है)mt_rand

— कोडइन्चोस

19

सवाल पासवर्ड जनरेट करने का है । एक पासवर्ड उत्पन्न करने के लिए कोड को स्पष्ट रूप से सुरक्षित यादृच्छिक संख्याओं का उपयोग करने की आवश्यकता होती है।

— कोडइन्चोस

10

एक ही कारण के रूप में है के लिए नहीं एक नकली सवाल है, इस जवाब के बाद से सवाल के बारे में है, वह सही नहीं है एक पासवर्ड पैदा करने और नहीं एक यादृच्छिक स्ट्रिंग । यह उत्तर पासवर्ड उत्पन्न करने के लिए बहुत असुरक्षित दृष्टिकोण प्रदान करता है। कृपया नीचे दिए गए @ user3260409 के उत्तर का उपयोग करें, जहां openssl_random_pseudo_bytes()इसका उपयोग किया गया हैrand()

— क्षमा

35

मैंने उत्पादन में आपका असुरक्षित कोड देखा है और इसे स्रोत पर रोकना चाहता हूं। आपने पासवर्ड के लिए क्रिप्टोग्राफिक रूप से सुरक्षित यादृच्छिकता की आवश्यकता की ।

— स्कॉट आर्किज़ेव्स्की

121

टी एल; डॉ:

नीचे random_int()दिए random_str()गए का उपयोग करें और ।
यदि आपके पास नहीं है random_int(), random_compat का उपयोग करें ।

स्पष्टीकरण:

चूंकि आप एक पासवर्ड उत्पन्न कर रहे हैं , आपको यह सुनिश्चित करने की आवश्यकता है कि आपके द्वारा उत्पन्न पासवर्ड अप्रत्याशित है, और यह सुनिश्चित करने का एकमात्र तरीका है कि यह संपत्ति आपके कार्यान्वयन में मौजूद है, एक क्रिप्टोग्राफिक रूप से सुरक्षित छद्म आयामी संख्या जनरेटर (CSPRNG) का उपयोग करना है।

CSPRNG के लिए आवश्यकता को रैंडम स्ट्रिंग्स के सामान्य मामले के लिए आराम दिया जा सकता है, लेकिन सुरक्षा से जुड़े होने पर नहीं।

PHP में पासवर्ड जेनरेशन का सरल, सुरक्षित और सही उत्तर है, RandomLib का उपयोग करना और पहिया को फिर से जोड़ना नहीं। इस पुस्तकालय का ऑडिट उद्योग सुरक्षा विशेषज्ञों द्वारा किया गया है, साथ ही स्वयं भी।

उन डेवलपर्स के लिए जो आपके स्वयं के समाधान का आविष्कार करना पसंद करते हैं, PHP 7.0.0 random_int()इस उद्देश्य के लिए प्रदान करेगा । यदि आप अभी भी PHP 5.x पर हैं, तो हमने PHP 5 पॉलीफ़िलrandom_int() लिखा था, ताकि आप PHP 7 रिलीज़ होने से पहले नए API का उपयोग कर सकें। हमारे random_int()पॉलीफ़िल का उपयोग करना शायद अपने स्वयं के कार्यान्वयन को लिखने से अधिक सुरक्षित है।

हाथ पर एक सुरक्षित यादृच्छिक पूर्णांक जनरेटर के साथ, एक सुरक्षित यादृच्छिक स्ट्रिंग उत्पन्न करना पाई की तुलना में आसान है:

<?php
/**
 * Generate a random string, using a cryptographically secure 
 * pseudorandom number generator (random_int)
 * 
 * For PHP 7, random_int is a PHP core function
 * For PHP 5.x, depends on https://github.com/paragonie/random_compat
 * 
 * @param int $length      How many characters do we want?
 * @param string $keyspace A string of all possible characters
 *                         to select from
 * @return string
 */
function random_str(
    $length,
    $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
) {
    $str = '';
    $max = mb_strlen($keyspace, '8bit') - 1;
    if ($max < 1) {
        throw new Exception('$keyspace must be at least two characters long');
    }
    for ($i = 0; $i < $length; ++$i) {
        $str .= $keyspace[random_int(0, $max)];
    }
    return $str;
}

— स्कॉट आर्किसेवस्की
स्रोत

2

रैंडमलीब को अभी दो साल से अपडेट नहीं किया गया है। हाल ही के PHP बिल्ड (मेरे मामले में 7.1.25) पर इसका उपयोग करने से विभिन्न mcrypt_*कार्यों के लिए पदावनति की चेतावनी दी जाती है। मैं एक मुद्दे के थ्रेड पर देख सकता हूं कि आपने @ircmaxell की पकड़ में नहीं आने के कारण लाइब्रेरी को कांटा है, लेकिन आपका कांटा ट्रैविस पर 'बिल्ड फेलिंग' कहता है। क्या आप इस उत्तर को अपडेट करने की परवाह करेंगे (जो अभी भी Google पर काफी अधिक दिखता है)?

— Janus Bahs जेकेट

1

अच्छी पकड़! इसे हटाने की जरूरत है।

— स्कॉट आर्किस्ज़वेस्की

113

मुझे पता है कि आप एक विशिष्ट तरीके से अपना पासवर्ड बनाने की कोशिश कर रहे हैं, लेकिन आप इस तरीके को भी देखना चाहते हैं ...

$bytes = openssl_random_pseudo_bytes(2);

$pwd = bin2hex($bytes);

यह php.net साइट से लिया गया है और यह एक स्ट्रिंग बनाता है जो आपके द्वारा Opensl_random_pseudo_bytes फ़ंक्शन में डाली गई संख्या की लंबाई से दोगुनी है। तो ऊपर एक पासवर्ड 4 वर्ण लंबा बनाएगा।

संक्षेप में...

$pwd = bin2hex(openssl_random_pseudo_bytes(4));

एक पासवर्ड बनाना होगा 8 वर्ण लंबा।

ध्यान दें कि पासवर्ड में केवल 0-9 नंबर और छोटे कैप अक्षर होते हैं!

— user3260409
स्रोत

13

यदि आप एक पासवर्ड चाहते हैं जो अपरकेस, लोअरकेस और संख्याएँ हैं, तो यह आज़माएँ

— willbradley

@ زياد कौन कहता है? यदि जनरेटर 7-बिट बाइट्स का उपयोग कर रहा है तो मैं आपके साथ सहमत होगा, लेकिन openssl_random_pseudo_bytes()एक शक्तिशाली पूर्ण द्विआधारी बाइट यादृच्छिकता जनरेटर है और इसके लिए किसी और फेरबदल की आवश्यकता नहीं है। इसके अलावा, मैं यह इंगित करने का मौका लूंगा कि कई एन्क्रिप्शन विधियों को स्टैक करना खतरनाक है, कुछ भी अधिक यादृच्छिक बना देगा, कुछ मामलों में यह वास्तव में हैशिंग टकराव के संचय के कारण विपरीत हो सकता है।

— हेवनार्ड

56

2 लाइन के साथ टिनी कोड ।

डेमो: http://codepad.org/5rHMHwnH

function rand_string( $length ) {

    $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    return substr(str_shuffle($chars),0,$length);

}

echo rand_string(8);

rand_string से आप यह परिभाषित कर सकते हैं कि कितना चरित्र बनाया जाएगा।

— BSQ
स्रोत

21

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

— होबो

11

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

— प्रोग्रामर

इस बारे में @Programster और @Hobo क्या है? substr(str_shuffle(str_repeat($chars,$length)),0,$length);

— चार्ल्स-

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

— प्रोग्रामर

मैं सहमत हूँ। इसकी पंक्तियों की संख्या पर एक एल्गोरिथ्म चुनना संभव नहीं है। वैसे, अगर मुख्य लक्ष्य सिर्फ वेबसाइट पर एक नया उपयोगकर्ता बनाते समय एक अस्थायी पासवर्ड उत्पन्न करना है, तो यह जरूरतों को पूरा करेगा, मुझे लगता है।

— चार्ल्स-

40

यदि आप PHP7 पर हैं, तो आप random_int()फ़ंक्शन का उपयोग कर सकते हैं :

function generate_password($length = 20){
  $chars =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
            '0123456789`-=~!@#$%^&*()_+,./<>?;:[]{}\|';

  $str = '';
  $max = strlen($chars) - 1;

  for ($i=0; $i < $length; $i++)
    $str .= $chars[random_int(0, $max)];

  return $str;
}

नीचे पुराना उत्तर:

function generate_password($length = 20){
  $chars =  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
            '0123456789`-=~!@#$%^&*()_+,./<>?;:[]{}\|';

  $str = '';
  $max = strlen($chars) - 1;

  for ($i=0; $i < $length; $i++)
    $str .= $chars[mt_rand(0, $max)];

  return $str;
}

— PeeHaa
स्रोत

12

mt_randपासवर्ड बनाने के लिए उपयोग न करें ।

— कोडइन्चोएस

2

@CodesInChaos यह रैंड () से बेहतर है जो उपरोक्त उदाहरण का उपयोग करता है। PHPs मैनुअल के अनुसार खुलता है .lrrrandom_pseudo_bytes ()।

— अक्टूबर को

4

@willbradley बीज की गुणवत्ता के लिए बस के रूप में बुरा है mt_rand, इसलिए यह अभी भी किसी भी सुरक्षा उपयोग के लिए अनुपयुक्त है।

— कोडइन्चोस

2

आप यह देखते हैं कि मुझे + ChaosInCodes क्या कहते हैं। आपने इस प्रश्न पर गौर नहीं किया है, आपने कुछ सामान्य बयानों को खराब आयोजित मान्यताओं के भार को दोहराया है। संक्षेप में: पूरी तरह से अलग प्रश्न के लिए सलाह का सही टुकड़ा। रैंडम पासवर्ड ठीक हैं। वे शायद "एक्स" केवल उपयोग कर रहे हैं। बहुत ईमानदारी से अगर आप अपने सिस्टम को बिना टाइमआउट लॉकआउट और DOS डिटेक्शन के डिजाइन कर रहे हैं और "x try then -> लॉक" कर रहे हैं तो आप गलत कर रहे हैं। आईटी जगह में इस तरह के उपायों के साथ एक mt_rand पासवर्ड का अनुमान लगाने के लिए महत्वपूर्ण है। इसके विपरीत mt_rand का उपयोग करना आसान नहीं होगा क्योंकि पासवर्ड को बल देना आसान हो जाएगा। यह सिर्फ नहीं होगा।

— श्री हीलिस

1

मैं में \ प्रयोग नहीं करेंगे$chars

— CONvid19

36

एक पंक्ति में:

substr(str_shuffle('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') , 0 , 10 )

— सैंड्रा
स्रोत

11

यह उन्हीं अक्षरों को फिर से उपयोग करने से रोकता है, क्योंकि वे केवल घूमते हैं, लेकिन एक से अधिक बार नहीं होते हैं।

— निकडंक

8

कहने की जरूरत नहीं है कि, किसी को भी लाइन काउंट के आधार पर अपने पासवर्ड निर्माण कार्य का अनुकूलन नहीं करना चाहिए। यहां तक कि अगर यह इस्तेमाल किया गया RNG सुरक्षित था (यह नहीं है), 10-वर्ण पासवर्ड बनाते समय बार-बार पात्रों से बचने से आपको ~ 52 बिट्स एन्ट्रॉपी से ~ 50 बिट्स एन्ट्रॉपी (~ 4x तेजी से क्रैक करने के लिए) से नीचे लाया जाता है। यदि आपने इसे 20 वर्णों तक बढ़ाया है, तो गैर-पुनरावृत्ति आपको ~ 103 बिट्स से ~ 94 बिट्स (~ 512x क्रैक करने के लिए तेज़) से नीचे लाएगी।

— जेरेमी बैंक्स

1

इस विधि ने मुझे Enigma कोड Lol

— hatef

4

substr(str_shuffle(str_repeat($chars,$length)),0,$length); एन्ट्रॉपी बहाल

— चार्ल्स-एउडार्ड कोस्टे

27

आपका सबसे अच्छा शर्त ircmaxell द्वारा randomLib लाइब्रेरी है ।

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

$factory = new RandomLib\Factory;
$generator = $factory->getGenerator(new SecurityLib\Strength(SecurityLib\Strength::MEDIUM));

$passwordLength = 8; // Or more
$randomPassword = $generator->generateString($passwordLength);

यह उन स्ट्रिंग्स का उत्पादन करता है जो सामान्य यादृच्छिकता कार्यों की तुलना में अधिक दृढ़ता से यादृच्छिक होते हैं shuffle()और rand()( जैसे कि आप आमतौर पर पासवर्ड, लवण और कुंजियों जैसी संवेदनशील जानकारी चाहते हैं)।

— मदारा का भूत
स्रोत

4

यह सही जवाब है। का उपयोग न करें rand()या mt_rand()।

— स्कॉट आर्किज़ेव्स्की

1

यह सबसे सुरक्षित उत्तर हो सकता है (यह सुनिश्चित नहीं है कि यह कैसे तुलना करता है random_bytes), लेकिन यह randउत्तर गलत नहीं करता है।

— सेरेब्रस

6

randपासवर्ड के लिए एक अच्छा विकल्प नहीं है

— स्कॉट आर्किस्ज़वेस्की

8

@Cerbrus: निश्चित रूप से यह उत्तर rand()गलत का उपयोग करके उत्तर नहीं देता है। वे अपने दम पर सभी गलत हैं!

— डिडुप्लिकेटर

14

आप चाहते हैं strlen($alphabet), न countकि स्थिर alphabet(के बराबर 'alphabet')।

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

इसके बजाय, /dev/urandomक्रिप्टोग्राफिक रूप से यादृच्छिक डेटा प्राप्त करने के लिए पढ़ें ।

— phihag
स्रोत

14

मैं एक उत्तर पोस्ट करने जा रहा हूं क्योंकि कुछ मौजूदा उत्तर पास हैं लेकिन उनमें से एक है:

एक छोटा वर्ण स्थान जो आप चाहते थे ताकि या तो ब्रूट-फोर्सिंग आसान हो या पासवर्ड उसी एन्ट्रापी के लिए लंबा होना चाहिए
एक RNG जिसे क्रिप्टोग्राफिक रूप से सुरक्षित नहीं माना जाता है
कुछ तीसरे पक्ष के पुस्तकालय के लिए एक आवश्यकता और मुझे लगा कि यह दिखाना दिलचस्प हो सकता है कि इसे स्वयं करने के लिए क्या हो सकता है

यह उत्तर count/strlenजनरेट किए गए पासवर्ड की सुरक्षा के रूप में समस्या को कम करेगा, कम से कम IMHO, आपको वहां कैसे पहुंचता है, यह बताता है। मैं PHP> 5.3.0 भी ग्रहण करने जा रहा हूँ।

आइए समस्या को नीचे दिए गए घटक भागों में विभाजित करें:

यादृच्छिक डेटा प्राप्त करने के लिए यादृच्छिकता के कुछ सुरक्षित स्रोत का उपयोग करें
उस डेटा का उपयोग करें और इसे कुछ मुद्रण योग्य स्ट्रिंग के रूप में दर्शाएं

पहले भाग के लिए, PHP> 5.3.0 फ़ंक्शन प्रदान करता है openssl_random_pseudo_bytes। ध्यान दें कि अधिकांश सिस्टम क्रिप्टोग्राफिक रूप से मजबूत एल्गोरिथ्म का उपयोग करते हैं, आपको जांचना होगा कि हम एक आवरण का उपयोग करेंगे:

/**
 * @param int $length
 */
function strong_random_bytes($length)
{
    $strong = false; // Flag for whether a strong algorithm was used
    $bytes = openssl_random_pseudo_bytes($length, $strong);

    if ( ! $strong)
    {
        // System did not use a cryptographically strong algorithm 
        throw new Exception('Strong algorithm not available for PRNG.');
    }        

    return $bytes;
}

दूसरे भाग के लिए, हम उपयोग करेंगे base64_encodeक्योंकि यह एक बाइट स्ट्रिंग लेता है और वर्णों की एक श्रृंखला का उत्पादन करेगा जिसमें मूल प्रश्न में निर्दिष्ट वर्णमाला के बहुत करीब है। यदि हमारे पास बुरा नहीं है +, /और =वर्ण अंतिम स्ट्रिंग में दिखाई देते हैं और हम कम से कम $nवर्णों का परिणाम चाहते हैं , तो हम बस उपयोग कर सकते हैं:

base64_encode(strong_random_bytes(intval(ceil($n * 3 / 4))));

3/4कारक तथ्य यह है कि एक स्ट्रिंग लंबाई कम से कम एक तिहाई बाइट स्ट्रिंग से भी बड़ा है कि में परिणाम एन्कोडिंग base64 के कारण है। परिणाम $n4 के एकाधिक होने और 3 वर्णों तक लंबे समय तक अन्यथा रहने के लिए सटीक होगा । चूँकि अतिरिक्त वर्ण मुख्य रूप से गद्दी वर्ण होते हैं =, अगर हम किसी कारण से अड़चन रखते थे कि पासवर्ड एक सटीक लंबाई है, तो हम इसे उस लंबाई तक काट सकते हैं, जिसे हम चाहते हैं। यह विशेष रूप से है क्योंकि किसी दिए गए के लिए $n, सभी पासवर्ड इन की समान संख्या के साथ समाप्त हो जाएंगे, ताकि एक हमलावर जिसके पास परिणाम पासवर्ड तक पहुंच हो, अनुमान लगाने के लिए 2 से कम वर्ण तक होंगे।

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

परिणाम में अतिरिक्त वर्णों के लिए, हम उन्हें परिणामी स्ट्रिंग से हटा सकते हैं। यदि हम अपने बाइट-स्ट्रिंग में 8 बाइट्स के साथ शुरू करते हैं, तो लगभग 25% बेस 64 अक्षर ये "अवांछनीय" वर्ण होंगे, ताकि इन वर्णों को त्यागने से परिणाम स्ट्रिंग में ओपी से कम नहीं हो। फिर हम इसे सटीक लंबाई तक ले जाने के लिए काट सकते हैं:

$dirty_pass = base64_encode(strong_random_bytes(8)));
$pass = substr(str_replace(['/', '+', '='], ['', '', ''], $dirty_pass, 0, 8);

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

— jeteon
स्रोत

1

इस जोड़ के लिए धन्यवाद। मौजूदा उत्तरों में से कोई भी उल्लेख नहीं किया गया है कि openssl_random_pseudo_bytesकमजोर परिणाम उत्पन्न कर सकता है। मुझे एहसास नहीं था कि मामला था।

— जेरेमी बैंक्स

12

base_convert(uniqid('pass', true), 10, 36);

जैसे। e0m6ngefmj4

संपादित करें

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

हालाँकि, यदि आप एक सुरक्षित रैंडम स्ट्रिंग जनरेटर की खोज करते समय इस उत्तर पर अड़ गए हैं (जैसा कि मुझे लगता है कि कुछ लोग प्रतिक्रियाओं के आधार पर हैं), कुछ के लिए जैसे टोकन उत्पन्न करना, यहां बताया गया है कि इस तरह के कोड का एक जनरेटर कैसा दिखेगा:

function base64urlEncode($data) {
    return rtrim(strtr(base64_encode($data), '+/', '-_'), '=');
}

function secureId($length = 32) {

    if (function_exists('openssl_random_pseudo_bytes')) {
        $bytes = openssl_random_pseudo_bytes($length);
        return rtrim(strtr(base64_encode($bytes), '+/', '0a'), '=');
    }
    else { // fallback to system bytes

        error_log("Missing support for openssl_random_pseudo_bytes");

        $pr_bits = '';

        $fp = @fopen('/dev/urandom', 'rb');
        if ($fp !== false) {
            $pr_bits .= @fread($fp, $length);
            @fclose($fp);
        }

        if (strlen($pr_bits) < $length) {
            error_log('unable to read /dev/urandom');
            throw new \Exception('unable to read /dev/urandom');
        }

        return base64urlEncode($pr_bits);
    }
}

— srcspider
स्रोत

1

PS - यह PHP है - वैश्विक नाम स्थान को निरूपित करने के लिए सिर्फ \ _ का उपयोग करना।

— बॉब ग्रेगोर

सिवाय इसके कि uniqid क्रिप्टोग्राफिक रूप से सुरक्षित नहीं है। रैंड () का उपयोग करें: base_convert (रैंड (78364164096, 2821109907455), 10, 36);

— बेनुबर्ड

7

PHP मैनुअल के अनुसार @Benubird रैंड () क्रिप्टोग्राफिक रूप से सुरक्षित नहीं है। इसके बजाय मैनुअल से पता चलता है कि Opensl_random_pseudo_bytes ()।

— अक्टूबर को

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

— srcspider

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

— srcspider

9

एक और एक (केवल लिनक्स)

function randompassword()
{
    $fp = fopen ("/dev/urandom", 'r');
    if (!$fp) { die ("Can't access /dev/urandom to get random data. Aborting."); }
    $random = fread ($fp, 1024); # 1024 bytes should be enough
    fclose ($fp);
    return trim (base64_encode ( md5 ($random, true)), "=");
}

— Askarel
स्रोत

1

एन्ट्रापी के 128-बिट क्रिप्टोग्राफिक हैश में संपीड़ित करने के लिए 1024 बाइट पढ़ना थोड़ा बेकार है। इसके अलावा, fread()बफ़र डिफ़ॉल्ट रूप से 8192 बाइट्स हैं, इसलिए आप हमेशा /dev/urandomदिए गए कोड से बहुत से पढ़ने वाले हैं । यह भी विंडोज पर काम नहीं करेगा। हालांकि, एक CSPRNG का उपयोग करने के लिए यश।

— स्कॉट आर्किसेवस्की

9

थोड़ा होशियार होना:

function strand($length){
  if($length > 0)
    return chr(rand(33, 126)) . strand($length - 1);
}

इसे यहाँ देखें ।

— अमीर फ़ॉ
स्रोत

7

मेड-स्ट्रॉन्ग पासवर्ड 12 लंबाई जनरेट करने के लिए इस सरल कोड का उपयोग करें

$password_string = '!@#$%*&abcdefghijklmnpqrstuwxyzABCDEFGHJKLMNPQRSTUWXYZ23456789';
$password = substr(str_shuffle($password_string), 0, 12);

— पाब्लो मार्टिनेज
स्रोत

यह वास्तव में (बहुत) गलत है। यह वास्तव में केवल एक बार वर्णमाला से हर चार का उपयोग करता है, इस प्रकार सभी संभावित मूल्यों (क्रैकिंग के लिए प्रासंगिक) के स्थान को गंभीर रूप से सिकोड़ता है।

— राडोस्लाव बोडो

6

कैपिटल लेटर्स, स्मॉल लेटर्स, न्यूमेरिक (एस) और स्पेशल कैरेक्टर के साथ इसे ट्राई करें

function generatePassword($_len) {

    $_alphaSmall = 'abcdefghijklmnopqrstuvwxyz';            // small letters
    $_alphaCaps  = strtoupper($_alphaSmall);                // CAPITAL LETTERS
    $_numerics   = '1234567890';                            // numerics
    $_specialChars = '`~!@#$%^&*()-_=+]}[{;:,<.>/?\'"\|';   // Special Characters

    $_container = $_alphaSmall.$_alphaCaps.$_numerics.$_specialChars;   // Contains all characters
    $password = '';         // will contain the desired pass

    for($i = 0; $i < $_len; $i++) {                                 // Loop till the length mentioned
        $_rand = rand(0, strlen($_container) - 1);                  // Get Randomized Length
        $password .= substr($_container, $_rand, 1);                // returns part of the string [ high tensile strength ;) ] 
    }

    return $password;       // Returns the generated Pass
}

मान लीजिए कि हमें 10 अंकों का पास चाहिए

echo generatePassword(10);

उदाहरण आउटपुट:

, IZCQ_IV \ 7

@wlqsfhT (घ

1! 8 + 1 \ 4 @ उद

— संजीव
स्रोत

randसमारोह वास्तव में क्रिप्टोग्राफी द्वारा सुरक्षित नहीं है तो यह काफी जोखिम हो सकता है इसे का उपयोग एक पासवर्ड उत्पन्न करने के लिए

— jeteon

3

त्वरित एक। यदि आप चाहते हैं कि सरल, स्वच्छ और सुसंगत प्रारूप

$pw = chr(mt_rand(97,122)).mt_rand(0,9).chr(mt_rand(97,122)).mt_rand(10,99).chr(mt_rand(97,122)).mt_rand(100,999);

— कॉर्नेलियस पार्किन
स्रोत

3

यह इस पृष्ठ के एक अन्य उत्तर पर आधारित है, https://stackoverflow.com/a/21498316/525649

इस उत्तर के लिए, बस हेक्स वर्ण उत्पन्न करता है 0-9,a-f। कुछ ऐसा जो हेक्स की तरह नहीं दिखता है, इसके लिए प्रयास करें:

str_shuffle(
  rtrim(
    base64_encode(bin2hex(openssl_random_pseudo_bytes(5))),
    '='
  ). 
  strtoupper(bin2hex(openssl_random_pseudo_bytes(7))).
  bin2hex(openssl_random_pseudo_bytes(13))
)

base64_encode अल्फ़ान्यूमेरिक वर्णों का व्यापक प्रसार लौटाता है
rtrim=कभी-कभी अंत में निकाल देता है

उदाहरण:

32eFVfGDg891Be5e7293e54z1D23110M3ZU3FMjb30Z9a740Ej0jz4
b280R72b48eOm77a25YCj093DE5d9549Gc73Jg8TdD9Z0Nj4b98760
051b33654C0Eg201cfW0e6NA4b9614ze8D2FN49E12Y0zY557aUCb8
y67Q86ffd83G0z00M0Z152f7O2ADcY313gD7a774fc5FF069zdb5b7

यह उपयोगकर्ताओं के लिए एक इंटरफ़ेस बनाने के लिए बहुत विन्यास योग्य नहीं है, लेकिन कुछ उद्देश्यों के लिए यह ठीक है। विशेष वर्णों की कमी को ध्यान में रखते हुए वर्णों की संख्या बढ़ाएँ।

— एडम
स्रोत

3

इसमें इस कोड वाली फाइल बनाएं।

इसे कमेंट्स में लाइक करें।

<?php 

/**
* @usage  :
*       include_once($path . '/Password.php');
*       $Password = new Password;
*       $pwd = $Password->createPassword(10);
*       return $pwd;
* 
*/

class Password {

    public function createPassword($length = 15) {
        $response = [];
        $response['pwd'] = $this->generate($length);
        $response['hashPwd'] = $this->hashPwd( $response['pwd'] );
        return $response;
    }

    private function generate($length = 15) {
        $chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*(){}/?,><";
        return substr(str_shuffle($chars),0,$length);
    }

    private function hashPwd($pwd) {
        return hash('sha256', $pwd);
    }

}

?>

— waz
स्रोत

2

मैंने एक अधिक व्यापक और सुरक्षित पासवर्ड स्क्रिप्ट बनाई। यह दो अपरकेस, दो लोअरकेस, दो नंबर और दो विशेष वर्णों के संयोजन का निर्माण करेगा। कुल 8 वर्ण।

$char = [range('A','Z'),range('a','z'),range(0,9),['*','%','$','#','@','!','+','?','.']];
$pw = '';
for($a = 0; $a < count($char); $a++)
{
    $randomkeys = array_rand($char[$a], 2);
    $pw .= $char[$a][$randomkeys[0]].$char[$a][$randomkeys[1]];
}
$userPassword = str_shuffle($pw);

— monrejames
स्रोत

1

//define a function. It is only 3 lines!   
function generateRandomPassword($length = 5){
    $chars = "0123456789bcdfghjkmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";
    return substr(str_shuffle($chars),0,$length);
}

//usage
echo generateRandomPassword(5); //random password legth: 5
echo generateRandomPassword(6); //random password legth: 6
echo generateRandomPassword(7); //random password legth: 7

— hakiko
स्रोत

यह वास्तव में (बहुत) गलत है। यह वास्तव में केवल एक बार वर्णमाला से हर चार का उपयोग करता है, इस प्रकार सभी संभावित मूल्यों (क्रैकिंग के लिए प्रासंगिक) के स्थान को गंभीर रूप से सिकोड़ता है।

— राडोस्लाव बोडो

0

कम से कम एक लोअर केस लेटर, एक अपरकेस लेटर, एक अंक, और एक विशेष वर्ण वाले लंबाई 8 का एक मजबूत पासवर्ड बनाता है। आप कोड में लंबाई भी बदल सकते हैं।

function checkForCharacterCondition($string) {
    return (bool) preg_match('/(?=.*([A-Z]))(?=.*([a-z]))(?=.*([0-9]))(?=.*([~`\!@#\$%\^&\*\(\)_\{\}\[\]]))/', $string);
}

$j = 1;

function generate_pass() {
    global $j;
    $allowedCharacters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_{}[]';
    $pass = '';
    $length = 8;
    $max = mb_strlen($allowedCharacters, '8bit') - 1;
    for ($i = 0; $i < $length; ++$i) {
        $pass .= $allowedCharacters[random_int(0, $max)];
    }

    if (checkForCharacterCondition($pass)){
        return '<br><strong>Selected password: </strong>'.$pass;
    }else{
        echo 'Iteration '.$j.':  <strong>'.$pass.'</strong>  Rejected<br>';
        $j++;
        return generate_pass();
    }

}

echo generate_pass();

— जिहाद उल इस्लाम
स्रोत

0

यह फ़ंक्शन मापदंडों में नियमों के आधार पर एक पासवर्ड उत्पन्न करेगा

function random_password( $length = 8, $characters = true, $numbers = true, $case_sensitive = true, $hash = true ) {

    $password = '';

    if($characters)
    {
        $charLength = $length;
        if($numbers) $charLength-=2;
        if($case_sensitive) $charLength-=2;
        if($hash) $charLength-=2;
        $chars = "abcdefghijklmnopqrstuvwxyz";
        $password.= substr( str_shuffle( $chars ), 0, $charLength );
    }

    if($numbers)
    {
        $numbersLength = $length;
        if($characters) $numbersLength-=2;
        if($case_sensitive) $numbersLength-=2;
        if($hash) $numbersLength-=2;
        $chars = "0123456789";
        $password.= substr( str_shuffle( $chars ), 0, $numbersLength );
    }

    if($case_sensitive)
    {
        $UpperCaseLength = $length;
        if($characters) $UpperCaseLength-=2;
        if($numbers) $UpperCaseLength-=2;
        if($hash) $UpperCaseLength-=2;
        $chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        $password.= substr( str_shuffle( $chars ), 0, $UpperCaseLength );
    }

    if($hash)
    {
        $hashLength = $length;
        if($characters) $hashLength-=2;
        if($numbers) $hashLength-=2;
        if($case_sensitive) $hashLength-=2;
        $chars = "!@#$%^&*()_-=+;:,.?";
        $password.= substr( str_shuffle( $chars ), 0, $hashLength );
    }

    $password = str_shuffle( $password );
    return $password;
}

— Behiry
स्रोत

0

यहाँ मेरा यादृच्छिक सादा पासवर्ड पीढ़ी सहायक पर ले रहा है।

यह सुनिश्चित करता है कि पासवर्ड में नंबर, ऊपरी और निचले मामले के साथ-साथ न्यूनतम 3 विशेष वर्ण हैं।

पासवर्ड की लंबाई 11 से 30 के बीच होगी।

function plainPassword(): string
{
    $numbers = array_rand(range(0, 9), rand(3, 9));
    $uppercase = array_rand(array_flip(range('A', 'Z')), rand(2, 8));
    $lowercase = array_rand(array_flip(range('a', 'z')), rand(3, 8));
    $special = array_rand(array_flip(['@', '#', '$', '!', '%', '*', '?', '&']), rand(3, 5));

    $password = array_merge(
        $numbers,
        $uppercase,
        $lowercase,
        $special
    );

    shuffle($password);

    return implode($password);
}

— सेबस्टियन सुलिंस्की
स्रोत