Gere uma string de senha aleatória com requisitos em javascript

Quero gerar uma string aleatória que deve ter 5 letras de az e 3 números.

Como posso fazer isso com JavaScript?

Eu tenho o seguinte script, mas não atende aos meus requisitos.

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

Forçar um número fixo de caracteres é uma má ideia. Isso não melhora a qualidade da senha. Pior, ele reduz o número de senhas possíveis, de forma que hackear por força bruta se torna mais fácil.

Para gerar uma palavra aleatória consistindo em caracteres alfanuméricos, use:

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

Como funciona?

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

Documentação para os métodos Number.prototype.toStringe string.prototype.slice.

Uma abordagem um pouco mais segura e sustentável.

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

Muitas respostas (incluindo a original desta) não atendem aos requisitos de contagem de letras e números do OP. Abaixo estão duas soluções: geral (sem letras / números mínimos) e com regras.

Geral:

Eu acredito que esta é uma solução geral melhor do que a acima, porque:

• é mais seguro do que a resposta aceita / mais votada, e também mais versátil, porque suporta qualquer conjunto de caracteres diferenciando maiúsculas de minúsculas
• é mais conciso do que outras respostas (para solução geral, 3 linhas no máximo; pode ser de uma linha)
• ele usa apenas Javascript nativo - nenhuma instalação ou outras bibliotecas necessárias

Observe que

• para que isso funcione no IE, o protótipo Array.fill () deve ser polyfilled
• se disponível, melhor usar window.crypto.getRandomValues ​​() em vez de Math.random () (obrigado @BenjaminH por apontar)

Três linhas:

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

Ou, como uma linha:

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

Com regras de letras / números

Agora, uma variação do anterior. Isso irá gerar três strings aleatórias dos conjuntos de caracteres fornecidos (letra, número, qualquer um) e, em seguida, embaralhar o resultado.

Observe que o seguinte usa sort () apenas para fins ilustrativos. Para uso em produção, substitua a função sort () abaixo por uma função shuffle , como Durstenfeld .

Primeiro, como uma função:

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

A mesma coisa, que um 2-liner (reconhecidamente, linhas muito longas e feias - e não será um 1-liner se você usar uma função shuffle adequada. Não recomendado, mas às vezes é divertido de qualquer maneira):

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

Para quem procura um guião simples. Não while (true), não if/else, nenhuma declaração.

Baseie-se na resposta de mwag, mas esta usa crypto.getRandomValuesum aleatório mais forte do que Math.random.

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

Veja isso para 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())

Isso não é exatamente otimizado, mas deve funcionar.

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

​ ​ ​

Aqui está um jsfiddle para você testar em: http://jsfiddle.net/sJGW4/3/

Caso você precise de uma senha gerada com pelo menos 1 número, 1 caractere maiúsculo e 1 caractere minúsculo:

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

Aqui está o violino se você quiser jogar / testar: http://jsfiddle.net/sJGW4/155/

Apoio a @mwag por me dar o começo para criar isso.

Como @RobW observa, restringir a senha a um número fixo de caracteres como proposto no esquema OP é uma má ideia . Pior ainda, respostas que propõem código baseado em Math.randomsão, bem, uma péssima ideia .

Vamos começar com a má ideia . O código OP está selecionando aleatoriamente uma sequência de 8 caracteres de um conjunto de 62. Restringir a sequência aleatória a 5 letras e 3 números significa que as senhas resultantes terão, na melhor das hipóteses , 28,5 bits de entropia (em oposição a um potencial de 47,6 bits se a restrição de distribuição de 5 letras e 3 números fosse removida). Isso não é muito bom. Mas, na realidade, a situação é ainda pior. O melhor aspecto do código é destruído pelo uso de Math.randomcomo meio de gerar entropia para as senhas. Math.randomé um gerador de números pseudo-aleatórios . Devido à natureza determinística dos geradores de números pseudo-aleatórios, a entropia das senhas resultantes é muito ruim , tornando qualquer solução proposta uma péssima ideia. Supondo que essas senhas estejam sendo distribuídas para os usuários finais (e / ou qual é o ponto), um adversário ativo que recebe essa senha tem uma boa chance de prever futuras senhas distribuídas para outros usuários, e isso provavelmente não é uma coisa boa.

Mas voltando à má ideia . Suponha que um gerador de números pseudoaleatórios criptograficamente forte seja usado em vez de Math.random. Por que você restringiria as senhas a 28,5 bits? Conforme observado, isso não é muito bom. Presumivelmente, o esquema de 5 letras e 3 números visa auxiliar os usuários no gerenciamento de senhas distribuídas aleatoriamente. Mas, vamos enfrentá-lo, você deve equilibrar facilidade de uso e valor de uso , e 28,5 bits de entropia não tem muito valor na defesa contra um adversário ativo.

Mas chega de ruim. Vamos propor um caminho a seguir. Usarei a biblioteca JavaScript EntropyString , que "gera sequências aleatórias criptograficamente fortes de entropia especificada de vários conjuntos de caracteres". Em vez dos caracteres OP 62, usarei um conjunto de caracteres com 32 caracteres escolhidos para reduzir o uso de caracteres facilmente confusos ou a formação de palavras em inglês. E em vez do esquema de 5 letras e 3 números (que tem pouca entropia), proclamarei que a senha terá 60 bits de entropia (esse é o equilíbrio entre facilidade e valor).

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

"Q7LfR8Jn7RDp"

Observe que o argumento para random.stringé os bits desejados de entropia, em oposição às soluções mais comumente vistas para a geração de string aleatória que especifica a passagem de um comprimento de string (que é mal orientado e normalmente não especificado, mas isso é outra história).

Escrevi um pequeno inspirado em sua resposta:

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

Esta função retorna a senha e pode ser usada em bookmarklet como:

javascript:alert(TheCodeOfTheFunction);

Eu não recomendaria usar uma senha forçada, pois restringe a segurança do usuário, mas de qualquer forma, existem algumas maneiras de fazer isso -

Método tradicional de JavaScript -

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

Usando Random String

Instale sequência aleatória:

npm install randomstring

Usando-o no App.js -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

O valor da sua senha está retido na variável yourString.

Não use uma senha forçada!

A senha forçada pode prejudicar a sua segurança, pois todas as senhas estariam no mesmo conjunto de caracteres, o que pode ser facilmente violado!

Ok, então se eu entendi bem que você está tentando obter uma senha de string aleatória que contém 5 letras e 3 números posicionados aleatoriamente e que tem um comprimento de 8 caracteres e você aceita letras maiúsculas e minúsculas, você pode fazer isso com a seguinte função :

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, finalmente, sem usar hacks de ponto flutuante:

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

Senha segura com um caractere maiúsculo.

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)

Minha criptografia baseada no problema. Usando ES6 e omitindo quaisquer verificações de recursos do navegador. Algum comentário sobre segurança ou desempenho?

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

Experimente, funciona. Baixe o script para o seu aplicativo javascript e chame a função randomPassword () https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64

Crie um serviço gerador de senha chamado 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('');
  }
}

não se esqueça de adicionar o serviço no módulo que você está usando

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

No seu controlador, adicione um método que chama o método de geração de senha dentro do serviço e defina o resultado no campo de senha

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

Existe um gerador de string de senha aleatória com comprimento selecionado

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>

Bem, você sempre pode usar o objeto window.crypto disponível na versão recente do navegador.

Só precisa de uma linha de código para obter um número aleatório:

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

Também ajuda a criptografar e descriptografar dados. Mais informações em MDN Web docs - window.crypto .