जावास्क्रिप्ट में आवश्यकताओं के साथ यादृच्छिक पासवर्ड स्ट्रिंग उत्पन्न करें


94

मैं एक यादृच्छिक स्ट्रिंग उत्पन्न करना चाहता हूं जिसमें 5 अक्षर az और 3 संख्याएँ होनी चाहिए।

मैं जावास्क्रिप्ट के साथ यह कैसे कर सकता हूं?

मुझे निम्न स्क्रिप्ट मिली है, लेकिन यह मेरी आवश्यकताओं को पूरा नहीं करती है।

        var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        var string_length = 8;
        var randomstring = '';
        for (var i=0; i<string_length; i++) {
            var rnum = Math.floor(Math.random() * chars.length);
            randomstring += chars.substring(rnum,rnum+1);
        }

6
यदि यह आपकी आवश्यकता को पूरा करता है, तो सवाल क्या है? इसके अलावा, आपकी मजबूर पासवर्ड की आवश्यकता एक बुरा विचार है।
— रॉब डब्ल्यू


2
new Array(12).fill().map(() => String.fromCharCode(Math.random()*86+40)).join("") निफ्टी वन लाइनर एक विशेष रूप से ऊपरी चार नंबरों के साथ 12
— चार्

जवाबों:


309

एक निश्चित संख्या में वर्णों को मजबूर करना एक बुरा विचार है। यह पासवर्ड की गुणवत्ता में सुधार नहीं करता है। इससे भी बदतर, यह संभव पासवर्डों की संख्या को कम कर देता है, ताकि bruteforcing द्वारा हैकिंग आसान हो जाए।

अल्फ़ान्यूमेरिक वर्णों से मिलकर एक यादृच्छिक शब्द उत्पन्न करने के लिए, उपयोग करें:

var randomstring = Math.random().toString(36).slice(-8);

यह कैसे काम करता है?

Math.random()                        // Generate random number, eg: 0.123456
             .toString(36)           // Convert  to base-36 : "0.4fzyo82mvyr"
                          .slice(-8);// Cut off last 8 characters : "yo82mvyr"

Number.prototype.toStringऔर string.prototype.sliceतरीकों के लिए प्रलेखन ।


6
मैं सहमत हूं, लेकिन कभी-कभी आप तय नहीं करते हैं;)
— ffffff01

38
इस का उपयोग न करें: चूंकि संख्या को बाइनरी से दशमलव में परिवर्तित किया जाता है, और पूर्ण दशमलव स्थान को "भरने" के लिए पर्याप्त बिट्स नहीं है, अंतिम अंक केवल मूल्यों के एक निश्चित सेट से चुना जाएगा। उदाहरण के लिए, मेरे कंप्यूटर पर, अंतिम अंक केवल "i", "r" और "9" है। इसकी जगह इसका प्रयोग करें:Math.random().toString(36).substr(2, 8)
— जोएल

1
यह समझाने के लिए कि 36 क्या करता है: मोज़िला से TheString () विधि अपना पहला तर्क देती है, और निर्दिष्ट मूलांक (आधार) में एक स्ट्रिंग प्रतिनिधित्व वापस करने का प्रयास करती है। 10 से ऊपर के मूलांक के लिए, वर्णमाला के अक्षर 9. से अधिक अंक दर्शाते हैं। उदाहरण के लिए, हेक्साडेसिमल संख्या (आधार 16) के लिए, एक एफ के माध्यम से उपयोग किया जाता है। तो इसके अनुसार, मूलांक 36 का उपयोग करते हुए, हमें 0-9 के बाद az मिलता है।
— शिशिर गुप्ता

2
@ शिशिरगुप्ता .toStringकेवल 36 तक के आधार को शामिल करता है और स्वीकार करता है। इस उत्तर का अर्थ गैर-क्रिप्टोग्राफिक यादृच्छिक स्ट्रिंग के लिए एक-लाइनर के रूप में है। यदि आप राजधानियाँ चाहते हैं, तो Math.random(या crypto.getRandomValuesयदि उपलब्ध हो) का उपयोग करें और परिणाम को az, AZ, 0-9 पर मैप करें। उदाहरण के लिए नीचे साज़ के उत्तर का उपयोग करना।
— रोब डब्ल्यू

1
यह नहीं देख रहा है कि यह ओपी की आवश्यकता को "5 अक्षर az और 3 संख्याओं" से कैसे संबोधित करता है । मुझे यह मिल गया, लेखक को लगता है कि यह एक बुरा विचार है ... लेकिन फिर भी इसकी आवश्यकता है
— mwag

38

थोड़ा अधिक बनाए रखने योग्य और सुरक्षित दृष्टिकोण।

var Password = {
 
  _pattern : /[a-zA-Z0-9_\-\+\.]/,
  
  
  _getRandomByte : function()
  {
    // http://caniuse.com/#feat=getrandomvalues
    if(window.crypto && window.crypto.getRandomValues) 
    {
      var result = new Uint8Array(1);
      window.crypto.getRandomValues(result);
      return result[0];
    }
    else if(window.msCrypto && window.msCrypto.getRandomValues) 
    {
      var result = new Uint8Array(1);
      window.msCrypto.getRandomValues(result);
      return result[0];
    }
    else
    {
      return Math.floor(Math.random() * 256);
    }
  },
  
  generate : function(length)
  {
    return Array.apply(null, {'length': length})
      .map(function()
      {
        var result;
        while(true) 
        {
          result = String.fromCharCode(this._getRandomByte());
          if(this._pattern.test(result))
          {
            return result;
          }
        }        
      }, this)
      .join('');  
  }    
    
};
<input type='text' id='p'/><br/>
<input type='button' value ='generate' onclick='document.getElementById("p").value = Password.generate(16)'>


इसके अलावा यह हमेशा उत्पन्न कोड में एक संख्या नहीं जोड़ता है और ओपी न्यूनतम 3 चाहता है।
— qwertzman

मिले एक पुस्तकालय है कि समर्थन window.crypto.getRandomValues और Node.js में काम करता है और साथ ही github.com/bermi/password-generator
— यूजीन

बस कहना चाहता था कि मुझे एक चुटकी में पासवर्ड बनाने के लिए कुछ चाहिए था और यह एकदम सही था। धन्यवाद!
— काइल के

29

कई जवाब (इस एक के मूल सहित) ओपी के पत्र और संख्या-गणना आवश्यकताओं को संबोधित नहीं करते हैं। नीचे दो समाधान दिए गए हैं: सामान्य (कोई मिनट पत्र / संख्या), और नियमों के साथ।

सामान्य:

मेरा मानना ​​है कि यह उपरोक्त से बेहतर सामान्य समाधान है, क्योंकि:

  • यह स्वीकृत / उच्चतम मत वाले उत्तर की तुलना में अधिक सुरक्षित है, और अधिक बहुमुखी भी है, क्योंकि यह केस-सेंसिटिव तरीके से सेट किए गए किसी भी चार्ट का समर्थन करता है
  • यह अन्य उत्तरों की तुलना में अधिक संक्षिप्त है (सामान्य समाधान के लिए, 3 लाइन अधिकतम; एक-लाइनर हो सकता है)
  • यह केवल मूल जावास्क्रिप्ट का उपयोग करता है- कोई इंस्टालेशन या अन्य लिबास की आवश्यकता नहीं है

ध्यान दें कि

  • इस IE पर काम करने के लिए, Array.fill () प्रोटोटाइप किया जाना चाहिए polyfilled
  • यदि उपलब्ध है, तो बेहतर है। उपयोग के लिए window.crypto.getRandomValues ​​() के बजाय Math.random () (शुक्रिया @BenjaminH इंगित करने के लिए)

तीन-लाइनर:

var pwdChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var pwdLen = 10;
var randPassword = Array(pwdLen).fill(pwdChars).map(function(x) { return x[Math.floor(Math.random() * x.length)] }).join('');

या, वन-लाइनर के रूप में:

var randPassword = Array(10).fill("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz").map(function(x) { return x[Math.floor(Math.random() * x.length)] }).join('');

पत्र / संख्या नियमों के साथ

अब, उपरोक्त पर एक बदलाव। यह दिए गए वर्ण (अक्षर, संख्या, या तो) से तीन यादृच्छिक तार उत्पन्न करेगा और फिर परिणाम को स्क्रैम्बल करेगा।

कृपया नीचे दिए गए प्रकारों का उपयोग करें। उत्पादन के उपयोग के लिए, डर्स्टनफील्ड जैसे फेरबदल फ़ंक्शन के साथ निम्न प्रकार () फ़ंक्शन को बदलें ।

सबसे पहले, एक समारोह के रूप में:

function randPassword(letters, numbers, either) {
  var chars = [
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", // letters
   "0123456789", // numbers
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" // either
  ];

  return [letters, numbers, either].map(function(len, i) {
    return Array(len).fill(chars[i]).map(function(x) {
      return x[Math.floor(Math.random() * x.length)];
    }).join('');
  }).concat().join('').split('').sort(function(){
    return 0.5-Math.random();
  }).join('')
}

// invoke like so: randPassword(5,3,2);

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

var chars = ["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz","0123456789", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"];
var randPwd = [5,3,2].map(function(len, i) { return Array(len).fill(chars[i]).map(function(x) { return x[Math.floor(Math.random() * x.length)] }).join('') }).concat().join('').split('').sort(function(){return 0.5-Math.random()}).join('');

अच्छा उत्तर, लेकिन आपके द्वारा उत्पन्न किसी भी पासवर्ड में कैपिटल लेटर Y कभी नहीं दिखाई देगा।
— रयान

1
धन्यवाद। मैंने ओपी प्रश्न में चारसेट का उपयोग किया लेकिन ऐसा लगता है कि यह त्रुटिपूर्ण था। अभी अपडेट किया गया।
— mwag

आप कहते हैं कि "यह स्वीकृत / उच्चतम मत वाले उत्तर की तुलना में अधिक सुरक्षित है"। क्या आप कारण पर विस्तार से बता सकते हैं?
— बेंजामिन

इसके अलावा Math.random () का उपयोग अनुमानित किया जा सकता है। इसलिए पासवर्ड जनरेट करने के लिए window.crypto.getRandomValues ​​जैसे फ़ंक्शन का बेहतर उपयोग करें।
— बेंजामिन

2
इसका कारण अधिक सुरक्षित है क्योंकि यह समर्थन करता है उत्पादन में संभावित वर्णों की एक उच्च संख्या है जो स्ट्रींग (36) का उपयोग कर रहा है। एक निश्चित आउटपुट लंबाई (उदाहरण के लिए 8) के साथ, यदि आपके पास चुनने के लिए अधिकतम 36 वर्ण हैं, तो आपके पास 62 पार (उदाहरण के रूप में) या बेहतर अभी तक की तुलना में बहुत कम क्रमपरिवर्तन हैं, पूरे 95 मुद्रण योग्य (ascii) ) चार्ट, या यूनिकोड का उपयोग करते हुए, प्रति बाइट की संभावनाओं की एक भी अधिक संख्या।
— mwag

10

किसी के लिए जो एक सरल स्क्रिप्ट की तलाश में है। नहीं while (true), नहीं if/else, कोई घोषणा नहीं।

Mwag के जवाब के आधार पर, लेकिन यह एक का उपयोग करता है crypto.getRandomValues, की तुलना में एक मजबूत यादृच्छिक Math.random।

Array(20)
  .fill('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$')
  .map(x => x[Math.floor(crypto.getRandomValues(new Uint32Array(1))[0] / (0xffffffff + 1) * x.length)])
  .join('');

इसके लिए देखें 0xffffffff।

वैकल्पिक 1

var generatePassword = (
  length = 20,
  wishlist = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$"
) => Array(length)
      .fill('')
      .map(() => wishlist[Math.floor(crypto.getRandomValues(new Uint32Array(1))[0] / (0xffffffff + 1) * wishlist.length)])
      .join('');

console.log(generatePassword());

वैकल्पिक 2

var generatePassword = (
  length = 20,
  wishlist = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$'
) =>
  Array.from(crypto.getRandomValues(new Uint32Array(length)))
    .map((x) => wishlist[x % wishlist.length])
    .join('')

console.log(generatePassword())

Node.js

const crypto = require('crypto')

const generatePassword = (
  length = 20,
  wishlist = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@-#$'
) =>
  Array.from(crypto.randomFillSync(new Uint32Array(length)))
    .map((x) => wishlist[x % wishlist.length])
    .join('')

console.log(generatePassword())

1
अपरिभाषित ऑफसेट के कारण यह लगातार 20 लंबाई पासवर्ड नहीं दे रहा है। + 1भाग आवश्यक नहीं है और हटाया जा सकता है।
— ब्रीक जूल

अच्छा पकड़ @bryc। अपडेट किया गया। धन्यवाद।
— नौवें फाम

1
उपयोगी और आसान उपाय। किसी को भी देख NodeJS भीतर ऐसा करने के लिए बस की जगह ले सकता crypto.getRandomValuesसाथ crypto.randomFillSync ।
— रिवी पांडे

जोड़ा गया Node.js संस्करण। धन्यवाद @Rvy पांडे
— नौवें फाम

8

यह बिल्कुल अनुकूलित नहीं है, लेकिन यह काम करना चाहिए।

var chars = "ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
var string_length = 8;
var randomstring = '';
var charCount = 0;
var numCount = 0;

for (var i=0; i<string_length; i++) {
    // If random bit is 0, there are less than 3 digits already saved, and there are not already 5 characters saved, generate a numeric value. 
    if((Math.floor(Math.random() * 2) == 0) && numCount < 3 || charCount >= 5) {
        var rnum = Math.floor(Math.random() * 10);
        randomstring += rnum;
        numCount += 1;
    } else {
        // If any of the above criteria fail, go ahead and generate an alpha character from the chars string
        var rnum = Math.floor(Math.random() * chars.length);
        randomstring += chars.substring(rnum,rnum+1);
        charCount += 1;
    }
}

alert(randomstring);

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की तरफ से कोई ठोस कदम नहीं उठाया गया है।

यहाँ आप पर परीक्षण करने के लिए एक jsfiddle है: http://jsfiddle.net/sJGW4/3/


1
chars.substring(rnum, rnum+1)बिल्कुल वैसा ही हैchars.charAt(rnum)
— Mad Echet

7

यदि आपको कम से कम 1 नंबर, 1 अपर केस कैरेक्टर और 1 लोअर केस कैरेक्टर के साथ पासवर्ड की आवश्यकता होती है:

function generatePassword(passwordLength) {
  var numberChars = "0123456789";
  var upperChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  var lowerChars = "abcdefghijklmnopqrstuvwxyz";
  var allChars = numberChars + upperChars + lowerChars;
  var randPasswordArray = Array(passwordLength);
  randPasswordArray[0] = numberChars;
  randPasswordArray[1] = upperChars;
  randPasswordArray[2] = lowerChars;
  randPasswordArray = randPasswordArray.fill(allChars, 3);
  return shuffleArray(randPasswordArray.map(function(x) { return x[Math.floor(Math.random() * x.length)] })).join('');
}

function shuffleArray(array) {
  for (var i = array.length - 1; i > 0; i--) {
    var j = Math.floor(Math.random() * (i + 1));
    var temp = array[i];
    array[i] = array[j];
    array[j] = temp;
  }
  return array;
}

alert(generatePassword(12));

यदि आप खेलना / परीक्षण करना चाहते हैं तो यहां पर यह है: http://jsfiddle.net/sJGW4/155/

मुझे इसे बनाने के लिए शुरुआत देने के लिए @mwag को सहारा देता है।


1
आप लोअरकेस याद कर रहे हैं j: पी अन्यथा, यहाँ अच्छा सामान। मेरी आवश्यकताओं को पूरा करने के लिए इसे थोड़ा संशोधित किया गया है।
— इगोर याविक

7

@RobW नोटों के अनुसार, पासवर्ड को ओपी योजना में प्रस्तावित वर्णों की निश्चित संख्या तक सीमित करना एक बुरा विचार है । लेकिन इससे भी बदतर, जवाब है कि प्रस्ताव कोड आधारित Math.randomहैं, ठीक है, एक बहुत बुरा विचार है ।

बुरे विचार से शुरू करते हैं । ओपी कोड बेतरतीब ढंग से 62 के सेट से 8 वर्णों की एक स्ट्रिंग का चयन कर रहा है। यादृच्छिक स्ट्रिंग को 5 अक्षरों और 3 संख्याओं तक सीमित करने का मतलब है कि परिणामस्वरूप पासवर्ड में, सबसे अच्छा , 28.5 बिट्स एन्ट्रापी (47.6 बिट की क्षमता के विपरीत) होगा। यदि 5 अक्षरों और 3 संख्याओं का वितरण प्रतिबंध हटा दिया गया है)। यह बहुत अच्छा नहीं है। लेकिन वास्तव में, स्थिति और भी खराब है। सबसे अच्छे रूप में कोड के पहलू के उपयोग के द्वारा नष्ट हो जाता है Math.randomपासवर्ड के लिए एन्ट्रापी पैदा करने के साधन के रूप। Math.randomएक छद्म यादृच्छिक संख्या जनरेटर है । छद्म यादृच्छिक संख्या जनरेटर के निर्धारक प्रकृति के कारण परिणामी पासवर्डों की एन्ट्रॉपी वास्तव में खराब है, ऐसे किसी भी प्रस्तावित समाधान को वास्तव में बुरा विचार प्रदान करना । इन पासवर्डों को समाप्त करने वाले उपयोगकर्ताओं (ओ / डब्ल्यू क्या बात है) को माना जा रहा है, एक सक्रिय विरोधी जो इस तरह के पासवर्ड को प्राप्त करता है, भविष्य के पासवर्ड की भविष्यवाणी करने का बहुत अच्छा मौका है जो अन्य उपयोगकर्ताओं को पता चलता है, और यह शायद अच्छी बात नहीं है।

लेकिन वापस सिर्फ बुरे विचार के लिए । इसके बजाय एक क्रिप्टोग्राफिक रूप से मजबूत छद्म यादृच्छिक संख्या जनरेटर का उपयोग किया जाता है Math.random। आप पासवर्ड को 28.5 बिट्स तक सीमित क्यों रखेंगे? जैसा कि कहा गया है, यह बहुत अच्छा नहीं है। संभवतः 5 अक्षर, 3 नंबर योजना उपयोगकर्ताओं को बेतरतीब ढंग से खोदे गए पासवर्ड को प्रबंधित करने में सहायता करने के लिए है। लेकिन इसका सामना करते हैं, आपको उपयोग के मूल्य के खिलाफ उपयोग में आसानी को संतुलित करना होगा , और एक सक्रिय विरोधी के खिलाफ रक्षा में 28.5 बिट्स की एन्ट्रापी का अधिक मूल्य नहीं है।

लेकिन काफी बुरा है। आगे एक रास्ता प्रस्तावित करते हैं। मैं जावास्क्रिप्ट एन्ट्रापीस्ट्रिंग लाइब्रेरी का उपयोग करूँगा, जो "कुशलता से विभिन्न विशिष्ट सेटों से निर्दिष्ट एन्ट्रॉपी के क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक तार उत्पन्न करता है"। ओपी 62 पात्रों के बजाय, मैं आसानी से भ्रमित पात्रों के उपयोग को कम करने या अंग्रेजी शब्दों के गठन के लिए चुने गए 32 अक्षरों के साथ एक चरित्र सेट का उपयोग करूंगा। और 5 अक्षर, 3 नंबर स्कीम (जिसमें बहुत कम एन्ट्रापी है) के बजाय, मैं पासवर्ड घोषित करूंगा, इसमें 60 बिट्स ऑफ एन्ट्रॉपी होगी (यह आसानी बनाम मूल्य का संतुलन है)।

import {Random, charSet32} from 'entropy-string'
const random = new Random(charSet32)
const string = random.string(60)

"Q7LfR8Jn7RDp"

तर्क पर ध्यान दें random.stringकि किसी भी स्ट्रिंग स्ट्रिंग लंबाई (जो दोनों गुमराह है और आमतौर पर अंडरस्क्रिफ़ाइड है, लेकिन यह एक और कहानी है) में निर्दिष्ट करने के लिए अधिक सामान्यतः देखे गए समाधानों के विपरीत, एन्ट्रॉपी के वांछित बिट्स हैं।


6

मैंने आपके उत्तर से प्रेरित एक छोटा सा लिखा है:

(function(){g=function(){c='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';p='';for(i=0;i<8;i++){p+=c.charAt(Math.floor(Math.random()*62));}return p;};p=g();while(!/[A-Z]/.test(p)||!/[0-9]/.test(p)||!/[a-z]/.test(p)){p=g();}return p;})()

यह फ़ंक्शन पासवर्ड लौटाता है और बुकमार्क में उपयोग किया जा सकता है जैसे:

javascript:alert(TheCodeOfTheFunction);

3

मैं एक मजबूर पासवर्ड का उपयोग करने की अनुशंसा नहीं करूंगा क्योंकि यह उपयोगकर्ता की सुरक्षा को प्रतिबंधित करता है लेकिन किसी भी तरह से, इसे करने के कुछ तरीके हैं -

पारंपरिक जावास्क्रिप्ट विधि -

Math.random().toString(36).slice(-8);

रैंडम स्ट्रिंग का उपयोग करना

यादृच्छिक स्ट्रिंग स्थापित करें:

npm install randomstring

App.js में इसका उपयोग -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

चर में आपके पासवर्ड का मान रखा जा रहा है yourString।

एक मजबूर पासवर्ड का उपयोग न करें!

मजबूर पासवर्ड आपकी सुरक्षा को नुकसान पहुंचा सकता है क्योंकि सभी पासवर्ड समान वर्ण सेट के तहत होंगे, जो आसानी से भंग हो सकते हैं!


3

ठीक है, अगर मैं अच्छी तरह से समझता हूं कि आप एक यादृच्छिक स्ट्रिंग पासवर्ड प्राप्त करने की कोशिश कर रहे हैं जिसमें 5 अक्षर और 3 संख्याएं यादृच्छिक रूप से तैनात हैं और इसलिए जिसकी लंबाई 8 वर्णों की है और आप बड़े और न्यूनतम पत्रों को स्वीकार करते हैं, तो आप निम्न फ़ंक्शन के साथ ऐसा कर सकते हैं :

function randPass(lettersLength,numbersLength) {
    var j, x, i;
    var result           = '';
    var letters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    var numbers       = '0123456789';
    for (i = 0; i < lettersLength; i++ ) {
        result += letters.charAt(Math.floor(Math.random() * letters.length));
    }
    for (i = 0; i < numbersLength; i++ ) {
        result += numbers.charAt(Math.floor(Math.random() * numbers.length));
    }
    result = result.split("");
    for (i = result.length - 1; i > 0; i--) {
        j = Math.floor(Math.random() * (i + 1));
        x = result[i];
        result[i] = result[j];
        result[j] = x;
    }
    result = result.join("");
    return result
}

function randPass(lettersLength,numbersLength) {
    var j, x, i;
    var result           = '';
    var letters       = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    var numbers       = '0123456789';
    for (i = 0; i < lettersLength; i++ ) {
        result += letters.charAt(Math.floor(Math.random() * letters.length));
    }
    for (i = 0; i < numbersLength; i++ ) {
        result += numbers.charAt(Math.floor(Math.random() * numbers.length));
    }
    result = result.split("");
    for (i = result.length - 1; i > 0; i--) {
        j = Math.floor(Math.random() * (i + 1));
        x = result[i];
        result[i] = result[j];
        result[j] = x;
    }
    result = result.join("");
    return result
}
console.log(randPass(5,3))


2
var letters = ['a','b','c','d','e','f','g','h','i','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];
    var numbers = [0,1,2,3,4,5,6,7,8,9];
    var randomstring = '';

        for(var i=0;i<5;i++){
            var rlet = Math.floor(Math.random()*letters.length);
            randomstring += letters[rlet];
        }
        for(var i=0;i<3;i++){
            var rnum = Math.floor(Math.random()*numbers.length);
            randomstring += numbers[rnum];
        }
     alert(randomstring);

1

और अंत में, फ्लोटिंग पॉइंट हैक्स का उपयोग किए बिना:

function genpasswd(n) {
    // 36 ** 11 > Number.MAX_SAFE_INTEGER
    if (n > 10)
        throw new Error('Too big n for this function');
    var x = "0000000000" + Math.floor(Number.MAX_SAFE_INTEGER * Math.random()).toString(36);
    return x.slice(-n);
}

1

एक अपरकेस चार के साथ सुरक्षित पासवर्ड।

let once = false;

    let newPassword = Math.random().toString(36).substr(2, 8).split('').map((char) => {
                    if(!Number(char) && !once){
                        once = true;
                        return char.toUpperCase();
                    }
                    return char;
                }).join('');

    console.log(newPassword)

1

मेरी क्रिप्टोकरंसी समस्या पर आधारित है। ES6 का उपयोग करना और किसी भी ब्राउज़र सुविधा की जांच को छोड़ना। सुरक्षा या प्रदर्शन पर कोई टिप्पणी?

const generatePassword = (
  passwordLength = 12,
  passwordChars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
) =>
  [...window.crypto.getRandomValues(new Uint32Array(passwordLength))]
    .map(x => passwordChars[x % passwordChars.length])
    .join('');


1

PassswordGeneratorService नामक एक पासवर्ड जनरेटर सेवा बनाएँ

import { Injectable } from '@angular/core';

@Injectable()
export class PasswordGeneratorService {

  generatePassword(length:number,upper:boolean,numbers:boolean,symbols:boolean) {
    const passwordLength = length || 12;
    const addUpper =  upper;
    const addNumbers =  numbers;
    const addSymbols =  symbols;

    const lowerCharacters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
    const upperCharacters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
    const numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
    const symbols = ['!', '?', '@'];

    const getRandom = array => array[Math.floor(Math.random() * array.length)];

    let finalCharacters = '';

    if (addUpper) {
      finalCharacters = finalCharacters.concat(getRandom(upperCharacters));
    }

    if (addNumbers) {
      finalCharacters = finalCharacters.concat(getRandom(numbers));
    }

    if (addSymbols) {
      finalCharacters = finalCharacters.concat(getRandom(symbols));
    }

    for (let i = 1; i < passwordLength - 3; i++) {
      finalCharacters = finalCharacters.concat(getRandom(lowerCharacters));
    }

    return  finalCharacters.split('').sort(() => 0.5 - Math.random()).join('');
  }
}

अपने उपयोग के मॉड्यूल पर सेवा जोड़ना न भूलें

@NgModule({
  imports: [
    CommonModule,
    SharedModule,
    CommonModule,
    RouterModule.forChild(routes),
    FormsModule,
    ReactiveFormsModule,
    FlexLayoutModule,
    TranslateModule,
    ExistingUserDialogModule,
    UserDocumentsUploadDialogModule
  ],
  declarations: [
    UserListComponent,
    EditUserDialogComponent,
    UserEditorComponent
  ],
  entryComponents: [
    EditUserDialogComponent
  ],
  providers: [
    AuthService,
    PasswordGeneratorService
  ]
})
export class UsersModule {
}

आप नियंत्रक पर एक विधि जोड़ते हैं जो सेवा के अंदर उत्पन्न पासवर्ड विधि को कॉल करता है और परिणाम को पासवर्ड फ़ील्ड पर सेट करता है

  constructor(
     private passwordGenerator: PasswordGeneratorService,
    )
  get newPassword() {
    return this.password.get('newPassword');
  }
  generatePassword() {
    this.newPassword.setValue(this.passwordGenerator.generatePassword(8,true,true,true));
  }

मैं सिर्फ समारोह छीन लिया generatePasswordऔर इसका इस्तेमाल किया, एक पूरी कक्षा के लिए कोई ज़रूरत नहीं है। thnx
— बिस्किट मुहम्मद

0

चयनित लंबाई के साथ एक यादृच्छिक पासवर्ड स्ट्रिंग जनरेटर है

let input = document.querySelector("textarea");
let button = document.querySelector("button");
let length = document.querySelector("input");

function generatePassword(n) 
{
	let pwd = "";

  while(!pwd || pwd.length < n)
  {
  	pwd += Math.random().toString(36).slice(-22);
  }
  
  return pwd.substring(0, n);
}

button.addEventListener("click", function()
{
	input.value = generatePassword(length.value);
});
<div>password:</div>
<div><textarea cols="70" rows="10"></textarea></div>
<div>length:</div>
<div><input type="number" value="200"></div>
<br>
<button>gen</button>


0

खैर, आप हमेशा ब्राउज़र के हाल के संस्करण में उपलब्ध window.crypto ऑब्जेक्ट का उपयोग कर सकते हैं।

एक यादृच्छिक संख्या प्राप्त करने के लिए बस एक पंक्ति की आवश्यकता है:

let n = window.crypto.getRandomValues(new Uint32Array(1))[0];

यह डेटा को एन्क्रिप्ट और डिक्रिप्ट करने में भी मदद करता है। MDN वेब डॉक्स पर अधिक जानकारी - window.crypto ।

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