Genere una cadena de contraseña aleatoria con requisitos en javascript

Quiero generar una cadena aleatoria que debe tener 5 letras de az y 3 números.

¿Cómo puedo hacer esto con JavaScript?

Tengo el siguiente script, pero no cumple con mis 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);
        }

Forzar un número fijo de caracteres es una mala idea. No mejora la calidad de la contraseña. Peor aún, reduce la cantidad de contraseñas posibles, por lo que la piratería por fuerza bruta se vuelve más fácil.

Para generar una palabra aleatoria que consta de caracteres alfanuméricos, utilice:

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"

Documentación de los métodos Number.prototype.toStringy string.prototype.slice.

Un enfoque un poco más fácil de mantener y seguro.

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

Muchas respuestas (incluida la original de esta) no abordan los requisitos de recuento de letras y números del OP. A continuación se presentan dos soluciones: general (sin letras / números mínimos) y con reglas.

General:

Creo que esta es una mejor solución general que la anterior, porque:

• es más seguro que la respuesta aceptada / más votada, y también más versátil, ya que admite cualquier conjunto de caracteres que distingue entre mayúsculas y minúsculas
• es más conciso que otras respuestas (para una solución general, 3 líneas como máximo; puede ser de una sola línea)
• utiliza solo Javascript nativo, no se requiere instalación ni otras bibliotecas

Tenga en cuenta que

• para que esto funcione en IE, el prototipo Array.fill () debe estar polyrelleno
• si está disponible, es mejor usar window.crypto.getRandomValues ​​() en lugar de Math.random () (gracias @BenjaminH por señalar)

Tres líneas:

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

O, como una sola línea:

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

Con reglas de letras / números

Ahora, una variación de lo anterior. Esto generará tres cadenas aleatorias de los conjuntos de caracteres dados (letra, número, cualquiera) y luego codificará el resultado.

Tenga en cuenta que a continuación se utiliza sort () solo con fines ilustrativos. Para uso de producción, reemplace la función sort () a continuación con una función de reproducción aleatoria como Durstenfeld .

Primero, en función:

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

Lo mismo, como una línea de 2 líneas (es cierto, líneas muy largas y feas, y no será una línea de 1 línea si usa una función de reproducción aleatoria adecuada. No se recomienda, pero a veces es divertido de todos modos):

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 alguien que busca un guión más simple. No while (true), no if/else, ninguna declaración.

Basado en la respuesta de mwag, pero este usa crypto.getRandomValues, un aleatorio más fuerte que Math.random.

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

Vea esto 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())

Esto no está optimizado exactamente, pero debería 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);

​ ​ ​

Aquí hay un jsfiddle para que lo pruebes: http://jsfiddle.net/sJGW4/3/

En caso de que necesite una contraseña generada con al menos 1 número, 1 carácter en mayúscula y 1 carácter en minúscula:

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

Aquí está el violín si quieres jugar / probar: http://jsfiddle.net/sJGW4/155/

Felicitaciones a @mwag por darme el comienzo para crear esto.

Como señala @RobW, restringir la contraseña a un número fijo de caracteres como se propone en el esquema OP es una mala idea . Pero lo que es peor, las respuestas que proponen código basado en Math.randomson, bueno, una muy mala idea .

Empecemos por la mala idea . El código OP selecciona aleatoriamente una cadena de 8 caracteres de un conjunto de 62. Restringir la cadena aleatoria a 5 letras y 3 números significa que las contraseñas resultantes tendrán, en el mejor de los casos , 28,5 bits de entropía (a diferencia de un potencial de 47,6 bits). si se eliminó la restricción de distribución de 5 letras y 3 números). Eso no es muy bueno. Pero en realidad, la situación es aún peor. El mejor aspecto del código se destruye mediante el uso de Math.randomcomo medio de generar entropía para las contraseñas. Math.randomes un generador de números pseudoaleatorios . Debido a la naturaleza determinista de los generadores de números pseudoaleatorios, la entropía de las contraseñas resultantes es realmente mala, lo que hace que cualquier solución propuesta sea una muy mala idea . Suponiendo que estas contraseñas se distribuyen a los usuarios finales (o / w cuál es el punto), un adversario activo que recibe dicha contraseña tiene muy buenas posibilidades de predecir las contraseñas futuras distribuidas a otros usuarios, y eso probablemente no sea algo bueno.

Pero volvamos a la mala idea . Suponga que se utiliza un generador de números pseudoaleatorios criptográficamente fuerte en lugar de Math.random. ¿Por qué restringiría las contraseñas a 28,5 bits? Como se señaló, eso no es muy bueno. Presumiblemente, el esquema de 5 letras y 3 números es para ayudar a los usuarios a administrar contraseñas distribuidas al azar. Pero seamos sinceros, tienes que equilibrar la facilidad de uso con el valor de uso , y 28,5 bits de entropía no tienen mucho valor en la defensa contra un adversario activo.

Pero basta de lo malo. Propongamos un camino a seguir. Usaré la biblioteca JavaScript EntropyString que "genera de manera eficiente cadenas aleatorias criptográficamente fuertes de entropía especificada a partir de varios conjuntos de caracteres". En lugar de los caracteres OP 62, usaré un conjunto de caracteres con 32 caracteres elegidos para reducir el uso de caracteres fácilmente confundidos o la formación de palabras en inglés. Y en lugar del esquema de 5 letras y 3 números (que tiene muy poca entropía), proclamaré que la contraseña tendrá 60 bits de entropía (este es el equilibrio entre facilidad y valor).

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

"Q7LfR8Jn7RDp"

Tenga en cuenta que el argumento random.stringes los bits de entropía deseados en lugar de las soluciones más comunes para la generación de cadenas aleatorias que especifican el paso de una longitud de cadena (que es errónea y, por lo general, no está especificada, pero esa es otra historia).

He escrito una pequeña inspirada en tu respuesta:

(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 función devuelve la contraseña y se puede utilizar en bookmarklet como:

javascript:alert(TheCodeOfTheFunction);

No recomendaría usar una contraseña forzada ya que restringe la seguridad del usuario, pero de todos modos, hay algunas formas de hacerlo:

Método tradicional de JavaScript -

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

Usando cadena aleatoria

Instalar cadena aleatoria:

npm install randomstring

Usándolo en App.js -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

El valor de su contraseña se mantiene en la variable yourString.

¡No use una contraseña forzada!

La contraseña forzada puede dañar su seguridad, ya que todas las contraseñas estarían bajo el mismo conjunto de caracteres, lo que podría romperse fácilmente.

Ok, entonces si entiendo bien que está tratando de obtener una contraseña de cadena aleatoria que contiene 5 letras y 3 números colocados al azar y que tiene una longitud de 8 caracteres y acepta letras mayúsculas y minúsculas, puede hacerlo con la siguiente función :

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

Y finalmente, sin usar trucos de punto flotante:

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

Contraseña segura con un carácter de mayúscula.

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)

Mi versión basada en Crypto resuelve el problema. Usar ES6 y omitir cualquier verificación de funciones del navegador. ¿Algún comentario sobre seguridad o rendimiento?

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

Prueba esto, funciona. Descargue el script a su aplicación javascript y llame a la función randomPassword () https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64

Cree un servicio generador de contraseñas llamado 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('');
  }
}

no olvide agregar el servicio en el módulo que 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 {
}

En su controlador, agregue un método que llame al método de generación de contraseña dentro del servicio y establezca el resultado en el campo de contraseña

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

Hay un generador de cadena de contraseña aleatoria con la longitud seleccionada

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>

Bueno, siempre puede usar el objeto window.crypto disponible en la versión reciente del navegador.

Solo necesita una línea de código para obtener un número aleatorio:

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

También ayuda a cifrar y descifrar datos. Más información en MDN Web docs: window.crypto .