Genera una stringa di password casuale con requisiti in javascript

Voglio generare una stringa casuale che deve avere 5 lettere da az e 3 numeri.

Come posso farlo con JavaScript?

Ho il seguente script, ma non soddisfa i miei requisiti.

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

Forzare un numero fisso di caratteri è una cattiva idea. Non migliora la qualità della password. Peggio ancora, riduce il numero di possibili password, in modo che la pirateria informatica tramite bruteforcing diventi più facile.

Per generare una parola casuale composta da caratteri alfanumerici, utilizzare:

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

Come funziona?

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

Documentazione per i metodi Number.prototype.toStringe string.prototype.slice.

Un approccio un po 'più manutenibile e sicuro.

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

Molte risposte (inclusa l'originale di questa) non soddisfano i requisiti di conteggio di lettere e numeri dell'OP. Di seguito sono riportate due soluzioni: generale (senza lettere / numeri min) e con regole.

Generale:

Credo che questa sia una soluzione generale migliore della precedente, perché:

• è più sicuro della risposta accettata / con il voto più alto e anche più versatile, perché supporta qualsiasi set di caratteri in modo sensibile al maiuscolo / minuscolo
• è più conciso di altre risposte (per la soluzione generale, massimo 3 righe; può essere di una riga)
• utilizza solo Javascript nativo, nessuna installazione o altre librerie richieste

Nota che

• affinché funzioni su IE, il prototipo Array.fill () deve essere polyfill
• se disponibile, meglio usare window.crypto.getRandomValues ​​() invece di Math.random () (grazie @BenjaminH per averlo sottolineato)

Tre righe:

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

Oppure, come one-liner:

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

Con regole di lettere / numeri

Ora, una variazione di quanto sopra. Questo genererà tre stringhe casuali dai set di caratteri dati (lettera, numero, uno o due) e quindi rimescolerà il risultato.

Si noti che quanto segue utilizza sort () solo a scopo illustrativo. Per l'uso in produzione, sostituire la seguente funzione sort () con una funzione shuffle come Durstenfeld .

In primo luogo, come funzione:

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

Stessa cosa, come una riga a 2 righe (è vero, linee molto lunghe e brutte - e non sarà una riga a 1 riga se si utilizza una funzione di riproduzione casuale appropriata. Non consigliato ma a volte è comunque divertente):

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

Per qualcuno che sta cercando uno script più semplice. No while (true), no if/else, nessuna dichiarazione.

Si basa sulla risposta di mwag, ma questo usa crypto.getRandomValuesun casuale più forte di Math.random.

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

Vedi questo per 0xffffffff.

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

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

Non è esattamente ottimizzato, ma dovrebbe funzionare.

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

​ ​ ​

Ecco un jsfiddle su cui provare: http://jsfiddle.net/sJGW4/3/

Nel caso in cui sia necessaria una password generata con almeno 1 numero, 1 carattere maiuscolo e 1 carattere minuscolo:

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

Ecco il violino se vuoi giocare / testare: http://jsfiddle.net/sJGW4/155/

Grazie a @mwag per avermi dato l'inizio per creare questo.

Come nota @RobW, limitare la password a un numero fisso di caratteri come proposto nello schema OP è una cattiva idea . Ma peggio, le risposte che propongono un codice basato su Math.randomsono, beh, una pessima idea .

Cominciamo con la cattiva idea . Il codice OP seleziona in modo casuale una stringa di 8 caratteri da un set di 62. Limitare la stringa casuale a 5 lettere e 3 numeri significa che le password risultanti avranno, nella migliore delle ipotesi , 28,5 bit di entropia (al contrario di un potenziale di 47,6 bit se la restrizione di distribuzione di 5 lettere e 3 numeri è stata rimossa). Non va molto bene. Ma in realtà la situazione è anche peggiore. L' aspetto migliore del codice viene distrutto dall'uso di Math.randomcome mezzo per generare entropia per le password. Math.randomè un generatore di numeri pseudo casuali . A causa della natura deterministica dei generatori di numeri pseudo casuali, l'entropia delle password risultanti è davvero pessima, rendendo qualsiasi tale soluzione proposta una pessima idea . Supponendo che queste password vengano distribuite agli utenti finali (di cui qual è il punto), un avversario attivo che riceve una tale password ha ottime possibilità di prevedere le password future distribuite ad altri utenti, e probabilmente non è una buona cosa.

Ma torniamo alla cattiva idea . Si supponga di utilizzare un generatore di numeri pseudo casuali crittograficamente forte al posto di Math.random. Perché restringereste le password a 28,5 bit? Come notato, non è molto buono. Presumibilmente lo schema di 5 lettere e 3 numeri serve ad assistere gli utenti nella gestione delle password distribuite casualmente. Ma ammettiamolo, devi bilanciare la facilità d'uso con il valore d'uso e 28,5 bit di entropia non sono molto utili per difendersi da un avversario attivo.

Ma basta con il male. Proponiamo un percorso in avanti. Userò la libreria JavaScript EntropyString che "genera in modo efficiente stringhe casuali crittograficamente forti di entropia specificata da vari set di caratteri". Invece dei caratteri OP 62, userò un set di caratteri con 32 caratteri scelti per ridurre l'uso di caratteri facilmente confusi o la formazione di parole inglesi. E invece dello schema di 5 lettere e 3 numeri (che ha troppo poca entropia), proclamerò che la password avrà 60 bit di entropia (questo è l'equilibrio tra facilità e valore).

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

"Q7LfR8Jn7RDp"

Nota che l'argomento per random.stringè i bit di entropia desiderati rispetto alle soluzioni più comunemente viste per la generazione di stringhe casuali che specificano il passaggio in una lunghezza di stringa (che è sia fuorviante che tipicamente sotto specificato, ma questa è un'altra storia).

Ne ho scritto uno piccolo ispirato dalla tua risposta:

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

Questa funzione restituisce la password e può essere utilizzata nel bookmarklet come:

javascript:alert(TheCodeOfTheFunction);

Non consiglierei di utilizzare una password forzata in quanto limita la sicurezza dell'utente, ma in ogni caso, ci sono alcuni modi per farlo:

Metodo JavaScript tradizionale -

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

Utilizzo di una stringa casuale

Installa una stringa casuale:

npm install randomstring

Usandolo in App.js -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

Il valore della tua password è contenuto nella variabile yourString.

Non utilizzare una password forzata!

La password forzata può danneggiare la tua sicurezza poiché tutte le password sarebbero sotto lo stesso set di caratteri, che potrebbe essere facilmente violato!

Ok quindi se ho capito bene stai cercando di ottenere una password di stringa casuale che contiene 5 lettere e 3 numeri posizionati casualmente e quindi che ha una lunghezza di 8 caratteri e accetti lettere maiuscole e minime, puoi farlo con la seguente funzione :

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

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

E infine, senza utilizzare hack in virgola mobile:

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

Password sicura con un carattere maiuscolo.

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)

Il mio approccio basato su Crypto sul problema. Utilizzo di ES6 e omissione di qualsiasi controllo delle funzionalità del browser. Eventuali commenti sulla sicurezza o sulle prestazioni?

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

Prova questo, funziona. Scarica lo script nella tua applicazione javascript e chiama la funzione randomPassword () https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64

Crea un servizio generatore di password chiamato 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('');
  }
}

non dimenticare di aggiungere il servizio sul modulo che stai utilizzando

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

Sul controller aggiungi un metodo che chiama il metodo di generazione della password all'interno del servizio e imposta il risultato nel campo della password

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

Esiste un generatore di stringhe di password casuale con lunghezza selezionata

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>

Bene, puoi sempre utilizzare l'oggetto window.crypto disponibile nella versione recente del browser.

Basta una riga di codice per ottenere un numero casuale:

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

Aiuta anche a crittografare e decrittografare i dati. Maggiori informazioni su MDN Web docs - window.crypto .