JavaScript'teki gereksinimlerle rastgele parola dizesi oluşturun

Az'dan 5 harf ve 3 sayıdan oluşan rastgele bir dize oluşturmak istiyorum.

Bunu JavaScript ile nasıl yapabilirim?

Aşağıdaki komut dosyasını aldım, ancak gereksinimlerimi karşılamıyor.

        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);
        }

Sabit sayıda karakteri zorlamak kötü bir fikirdir. Şifrenin kalitesini artırmaz. Daha da kötüsü, olası parolaların sayısını azaltır, böylece kaba kuvvet kullanarak hacklemek daha kolay hale gelir.

Alfasayısal karakterlerden oluşan rastgele bir kelime oluşturmak için şunu kullanın:

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

O nasıl çalışır?

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.toStringVe string.prototype.sliceyöntemleri için belgeler .

Biraz daha sürdürülebilir ve güvenli bir yaklaşım.

Ne demek istediğimi ve nasıl çalıştığını genişletmek için bir güncelleme.

1. Güvenli . MDN, güvenlikle ilgili herhangi bir şey için kullanımıMath.random konusunda oldukça açıktır :

   Math.random() gelmez şifreli olarak güvenli rasgele rakamlar sağlar. Bunları güvenlikle ilgili hiçbir şey için kullanmayın. Bunun yerine Web Crypto API'yi ve daha kesin olarak window.crypto.getRandomValues()yöntemi kullanın.

   Baktığımızda can-i-kullanılmak üzeregetRandomValues 2020 yılında muhtemelen yapmanız gerekmez msCryptove Math.randomantik tarayıcılar umurumda sürece bir daha özelliklerden kaçınarak.

2. Sürdürülebilirlik , çoğunlukla RegExp _patternparolada hangi karakter sınıflarına izin verdiğinizi tanımlamanın kolay bir yolu ile ilgilidir. Ama aynı zamanda her birinin işini yaptığı 3 şey hakkında: bir model tanımlar, mümkün olduğunca güvenli bir şekilde rastgele bir bayt alır, ikisini birleştirmek için genel bir API sağlar.

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)'>

Pek çok cevap (bunun orijinali dahil), OP'nin harf ve sayı sayımı gereksinimlerini karşılamıyor. Aşağıda iki çözüm bulunmaktadır: genel (minimum harf / rakam yok) ve kurallı.

Genel:

Bunun yukarıdakilerden daha iyi bir genel çözüm olduğuna inanıyorum, çünkü:

• Kabul edilen / en yüksek oy alan cevaptan daha güvenlidir ve ayrıca daha çok yönlüdür, çünkü herhangi bir karakter kümesini büyük / küçük harfe duyarlı bir şekilde destekler
• diğer cevaplardan daha özlüdür (genel çözüm için en fazla 3 satır; tek satır olabilir)
• yalnızca yerel Javascript kullanır - kurulum veya diğer kitaplıklar gerekmez

Bunu not et

• Bu IE üzerinde çalışmak için, Array.fill () prototip olmalıdır polyfilled
• varsa, Math.random () yerine window.crypto.getRandomValues ​​() kullanmak daha iyidir (işaret ettiğiniz için @BenjaminH teşekkürler)

Üç çizgili:

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

Veya tek satırlık olarak:

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

Harf / Sayı Kurallarıyla

Şimdi, yukarıdakinin bir varyasyonu. Bu, verilen karakter kümelerinden (harf, sayı, her ikisi de) üç rastgele dizge oluşturacak ve ardından sonucu karıştıracaktır.

Lütfen aşağıdaki sort () ifadesinin yalnızca açıklama amacıyla kullanıldığını unutmayın. Üretim kullanımı için, aşağıdaki sort () işlevini Durstenfeld gibi bir karıştırma işleviyle değiştirin .

İlk olarak, bir işlev olarak:

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 satırla aynı şey (kuşkusuz, çok uzun ve çirkin çizgiler - ve uygun bir karıştırma işlevi kullanırsanız 1 satırlık olmayacak. Önerilmez, ancak bazen eğlencelidir):

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('');

En basit bir senaryo arayan biri için. Hayır while (true), hayır if/else, beyan yok.

MWAG cevabı üzerine Baz, ama bu kullanımları crypto.getRandomValues, daha güçlü bir rasgele Math.random.

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

Bkz bu için 0xffffffff.

Alternatif 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());

Alternatif 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())

Bu tam olarak optimize edilmemiştir, ancak çalışmalıdır.

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);

​ ​ ​

İşte test etmeniz için bir jsfiddle: http://jsfiddle.net/sJGW4/3/

@RobW'nin belirttiği gibi, şifreyi OP şemasında önerildiği gibi sabit sayıda karakterle sınırlamak kötü bir fikirdir . Ama daha da kötüsü, temel alınan kod öneren yanıtlar, Math.randomaslında, gerçekten kötü bir fikirdir .

Kötü fikirle başlayalım . OP kodu, 62'lik bir setten rastgele olarak 8 karakterlik bir dizi seçer. Rastgele diziyi 5 harf ve 3 sayı ile sınırlamak, elde edilen şifrelerin en iyi ihtimalle 28,5 bit entropiye sahip olacağı anlamına gelir (47,6 bitlik bir potansiyelin aksine 5 harf ve 3 rakamdan oluşan dağıtım kısıtlaması kaldırılmışsa). Bu pek iyi değil. Ama gerçekte durum daha da kötü. En iyi kodu yönü kullanımı ile yok edilir Math.randomşifreler için entropi üretme aracı olarak. Math.randoma, sözde rasgele sayı üreteci . Sözde rastgele sayı üreticilerinin deterministik doğası nedeniyle, ortaya çıkan şifrelerin entropisi gerçekten kötüdür., önerilen böyle bir çözümü gerçekten kötü bir fikir haline getiriyor . Bu şifrelerin son kullanıcılara dağıtıldığını varsayarsak (ne anlamı var), böyle bir şifre alan aktif bir düşmanın, diğer kullanıcılara dağıtılacak gelecekteki şifreleri tahmin etme şansı çok yüksektir ve bu muhtemelen iyi bir şey değildir.

Ama kötü fikre geri dönelim . Bunun yerine kriptografik olarak güçlü bir sözde rastgele sayı üretecinin kullanıldığını varsayın Math.random. Parolaları neden 28,5 bit ile sınırladınız? Belirtildiği gibi, bu pek iyi değil. Muhtemelen 5 harfli, 3 rakamlı düzen, kullanıcılara rastgele dağıtılan şifreleri yönetmede yardımcı olmak içindir. Ama sen dengelemek zorunda kabul edelim kullanım kolaylığı karşı kullanımının değeri ve entropi 28.5 bit aktif bir düşmana karşı savunmada çok değer değil.

Ama yeterince kötü. İleri bir yol önerelim. "Çeşitli karakter kümelerinden belirlenen entropinin şifreleme açısından güçlü rastgele dizelerini verimli bir şekilde üreten" JavaScript EntropyString kitaplığını kullanacağım. OP 62 karakterleri yerine, kolayca karıştırılan karakterlerin kullanımını veya İngilizce kelimelerin oluşumunu azaltmak için seçilen 32 karakterli bir karakter seti kullanacağım. Ve (çok az entropiye sahip olan) 5 harfli 3 sayı şeması yerine, şifrenin 60 bitlik entropiye sahip olacağını ilan edeceğim (bu, kolaylığa karşı değer dengesidir).

import { Entropy, charSet32 } from 'entropy-string'
const random = new Entropy({ bits: 60, charset: charset32 })
const string = random.string()

"Q7LfR8Jn7RDp"

EntropyBir dizi uzunluğunda geçişi belirten (hem yanlış yönlendirilmiş hem de tipik olarak yetersiz belirtilmiştir, ancak bu başka bir hikaye) rastgele dizge oluşturmaya yönelik daha yaygın olarak görülen çözümlerin aksine istenen entropi bitlerini belirtmek için argümanlara dikkat edin.

En az 1 rakam, 1 büyük harf ve 1 küçük harf karakteriyle oluşturulmuş bir parolaya ihtiyacınız olması durumunda:

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));

Oynamak / test etmek istiyorsanız işte keman: http://jsfiddle.net/sJGW4/155/

@ Mwag'a bunu yaratmaya başlamamı sağladığın için destek.

Cevabınızdan esinlenerek küçük bir tane yazdım:

(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;})()

Bu işlev parolayı döndürür ve aşağıdaki gibi yer iminde kullanılabilir:

javascript:alert(TheCodeOfTheFunction);

Tamam, eğer rastgele yerleştirilmiş 5 harf ve 3 sayı içeren ve böylece 8 karakter uzunluğunda olan ve maj ve min harfleri kabul eden rastgele bir string şifresi almaya çalıştığınızı iyi anlarsam, bunu aşağıdaki fonksiyonla yapabilirsiniz. :

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))

Kullanıcının Güvenliğini kısıtladığı için zorunlu bir şifre kullanmanızı tavsiye etmem ama her halükarda bunu yapmanın birkaç yolu vardır -

Geleneksel JavaScript Yöntemi -

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

Rastgele Dize Kullanma

Rastgele dize yükleyin:

npm install randomstring

App.js'de kullanmak -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

Şifrenizin değeri değişkende tutuluyor yourString.

Zorunlu Parola Kullanmayın!

Zorunlu Parola güvenliğinize zarar verebilir, çünkü tüm parolalar aynı karakter setinde olduğundan kolaylıkla ihlal edilebilir!

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);

Ve son olarak, kayan noktalı saldırıları kullanmadan:

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);
}

Bir büyük harf karakteri ile parolayı güvenli hale getirin.

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)

Kripto temelli problemi ele alıyor. ES6 kullanmak ve herhangi bir tarayıcı özelliği kontrolünü atlamak. Güvenlik veya performans hakkında herhangi bir yorumunuz var mı?

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

Bunu dene, işe yarıyor. Komut dosyasını javascript uygulamanıza indirin ve randomPassword () işlevini çağırın https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64

PassswordGeneratorService adlı bir Parola oluşturucu hizmeti oluşturun

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('');
  }
}

hizmeti kullandığınız modüle eklemeyi unutmayın

@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 {
}

Denetleyicinize, hizmetin içindeki parola oluşturma yöntemini çağıran ve sonucu parola alanında ayarlayan bir yöntem ekleyin

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

Math.random () ile oluşturulan herhangi bir parola SON DERECE KÖTÜ .

Bu işlev, rasgele sayı üreteci için bir çekirdek olarak sistem zamanını kullanır. Parolanın oluşturulduğu zamanı bilen herkes, parolayı kolayca zorlayabilir.

Neredeyse tüm durumlarda, bu veriler kolayca elde edilebilir - saldırıya uğramış bir veritabanındaki kayıt_süresi sütununu alın ve Math.random () algoritması tarafından oluşturulan tüm değerleri 15 ila 0 dakika öncesindeki süreleri kullanarak test edin.

Math.random () ile oluşturulan bir parola tamamen değersizdir çünkü parolanın ilk kullanıldığı zaman onu kırmak için yeterlidir.

Seçilen uzunlukta rastgele bir şifre dizisi üreticisi var

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>

Her zaman tarayıcının son sürümünde bulunan window.crypto nesnesini kullanabilirsiniz.

Rastgele bir sayı almak için sadece bir satır koda ihtiyacınız var:

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

Ayrıca verilerin şifrelenmesine ve şifresinin çözülmesine yardımcı olur. MDN Web belgelerinde daha fazla bilgi - window.crypto .