Générer une chaîne de mot de passe aléatoire avec des exigences en javascript

Je veux générer une chaîne aléatoire qui doit avoir 5 lettres de az et 3 nombres.

Comment puis-je faire cela avec JavaScript?

J'ai le script suivant, mais il ne répond pas à mes exigences.

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

Forcer un nombre fixe de caractères est une mauvaise idée. Cela n'améliore pas la qualité du mot de passe. Pire, cela réduit le nombre de mots de passe possibles, de sorte que le piratage par bruteforcing devient plus facile.

Pour générer un mot aléatoire composé de caractères alphanumériques, utilisez:

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

Comment ça marche?

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

Documentation des méthodes Number.prototype.toStringet string.prototype.slice.

Une approche un peu plus maintenable et sécurisée.

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

De nombreuses réponses (y compris l'original de celle-ci) ne répondent pas aux exigences de nombre de lettres et de nombres du PO. Voici deux solutions: générale (pas de lettres / chiffres min) et avec des règles.

Général:

Je pense que c'est une meilleure solution générale que la précédente, car:

• elle est plus sûre que la réponse acceptée / la plus votée, et également plus polyvalente, car elle prend en charge tous les jeux de caractères en respectant la casse
• c'est plus concis que les autres réponses (pour une solution générale, 3 lignes maximum; peut être une ligne)
• il utilise uniquement du Javascript natif - aucune installation ou autre bibliothèque requise

Notez que

• pour que cela fonctionne sur IE, le prototype Array.fill () doit être polyfilled
• si disponible, il vaut mieux utiliser window.crypto.getRandomValues ​​() au lieu de Math.random () (merci @BenjaminH pour l'avoir signalé)

Trois lignes:

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, en one-liner:

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

Avec des règles de lettres / nombres

Maintenant, une variation sur ce qui précède. Cela générera trois chaînes aléatoires à partir des jeux de caractères donnés (lettre, nombre, soit), puis brouillera le résultat.

Veuillez noter que ci-dessous utilise sort () à des fins d'illustration uniquement. Pour une utilisation en production, remplacez la fonction sort () ci-dessous par une fonction de lecture aléatoire telle que Durstenfeld .

Tout d'abord, en fonction:

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

Même chose, comme un 2 lignes (certes, des lignes très longues et laides - et ne sera pas un 1-ligne si vous utilisez une fonction de lecture aléatoire appropriée. Non recommandé mais parfois c'est amusant quand même):

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

Pour quelqu'un qui recherche un script le plus simple. Non while (true), non if/else, pas de déclaration.

Basé sur la réponse de mwag, mais celui-ci utilise crypto.getRandomValues, un aléatoire plus fort que Math.random.

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

Voir ceci pour 0xffffffff.

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

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

Ce n'est pas exactement optimisé, mais cela devrait fonctionner.

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

​ ​ ​

Voici un jsfiddle à tester sur: http://jsfiddle.net/sJGW4/3/

Si vous avez besoin d'un mot de passe généré avec au moins 1 chiffre, 1 caractère majuscule et 1 caractère minuscule:

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

Voici le violon si vous voulez jouer / tester: http://jsfiddle.net/sJGW4/155/

Props à @mwag pour m'avoir donné le départ pour créer ceci.

Comme le note @RobW, restreindre le mot de passe à un nombre fixe de caractères comme proposé dans le schéma OP est une mauvaise idée . Mais pire, les réponses qui proposent du code basé sur Math.randomsont, eh bien, une très mauvaise idée .

Commençons par la mauvaise idée . Le code OP sélectionne au hasard une chaîne de 8 caractères parmi un ensemble de 62. Restreindre la chaîne aléatoire à 5 lettres et 3 chiffres signifie que les mots de passe résultants auront, au mieux , 28,5 bits d'entropie (par opposition à un potentiel de 47,6 bits si la restriction de distribution de 5 lettres et 3 chiffres a été supprimée). Ce n'est pas très bon. Mais en réalité, la situation est encore pire. Au mieux, l' aspect du code est détruit par l'utilisation de Math.randomcomme moyen de générer une entropie pour les mots de passe. Math.randomest un générateur de nombres pseudo aléatoires . En raison de la nature déterministe des générateurs de nombres pseudo aléatoires, l'entropie des mots de passe résultants est vraiment mauvaise, rendant une telle solution proposée une très mauvaise idée . En supposant que ces mots de passe sont distribués aux utilisateurs finaux (o / w à quoi ça sert), un adversaire actif qui reçoit un tel mot de passe a de très bonnes chances de prédire les futurs mots de passe distribués à d'autres utilisateurs, et ce n'est probablement pas une bonne chose.

Mais revenons à la mauvaise idée . Supposons qu'un générateur de nombres pseudo aléatoires cryptographiquement fort soit utilisé à la place de Math.random. Pourquoi limiteriez-vous les mots de passe à 28,5 bits? Comme indiqué, ce n'est pas très bon. Vraisemblablement, le schéma à 5 lettres et 3 chiffres est d'aider les utilisateurs à gérer les mots de passe distribués au hasard. Mais avouons - le, vous devez équilibrer la facilité d'utilisation contre la valeur d'utilisation et 28,5 bits d'entropie est pas beaucoup de valeur dans la défense contre un adversaire actif.

Mais assez de mauvais. Proposons une voie à suivre. J'utiliserai la bibliothèque JavaScript EntropyString qui "génère efficacement des chaînes aléatoires cryptographiquement fortes d'entropie spécifiée à partir de divers jeux de caractères". Plutôt que les caractères OP 62, j'utiliserai un jeu de caractères avec 32 caractères choisis pour réduire l'utilisation de caractères facilement confondus ou la formation de mots anglais. Et plutôt que le schéma à 5 lettres et 3 chiffres (qui a trop peu d'entropie), je proclamerai que le mot de passe aura 60 bits d'entropie (c'est l'équilibre entre facilité et valeur).

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

«Q7LfR8Jn7RDp»

Notez que l'argument random.stringest les bits d'entropie souhaités, par opposition aux solutions les plus courantes de génération de chaînes aléatoires qui spécifient le passage d'une longueur de chaîne (ce qui est à la fois mal orienté et généralement sous-spécifié, mais c'est une autre histoire).

J'en ai écrit un petit inspiré de votre réponse:

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

Cette fonction renvoie le mot de passe et peut être utilisée dans le bookmarklet comme:

javascript:alert(TheCodeOfTheFunction);

Je ne recommanderais pas d'utiliser un mot de passe forcé car il restreint la sécurité de l'utilisateur, mais de toute façon, il existe plusieurs façons de le faire -

Méthode JavaScript traditionnelle -

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

Utilisation d'une chaîne aléatoire

Installez une chaîne aléatoire:

npm install randomstring

Utilisation dans App.js -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

La valeur de votre mot de passe est conservée dans la variable yourString.

N'utilisez pas de mot de passe forcé!

Le mot de passe forcé peut nuire à votre sécurité car tous les mots de passe seraient sous le même jeu de caractères, ce qui pourrait facilement être violé!

Ok donc si je comprends bien que vous essayez d'obtenir un mot de passe de chaîne aléatoire qui contient 5 lettres et 3 chiffres positionnés au hasard et qui a donc une longueur de 8 caractères et que vous acceptez les lettres maj et min, vous pouvez le faire avec la fonction suivante :

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

Et enfin, sans utiliser de hacks en virgule flottante:

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

Mot de passe sécurisé avec un caractère majuscule.

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)

Mon Crypto basé sur le problème. Utiliser ES6 et omettre toute vérification des fonctionnalités du navigateur. Des commentaires sur la sécurité ou les performances?

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

Essayez ceci, cela fonctionne. Téléchargez le script sur votre application javascript et appelez la fonction randomPassword () https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64

Créez un service de générateur de mot de passe appelé 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'oubliez pas d'ajouter le service sur le module que vous utilisez

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

Sur votre contrôleur, ajoutez une méthode qui appelle la méthode de génération de mot de passe dans le service et définissez le résultat dans le champ de mot de passe

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

Il existe un générateur de chaîne de mot de passe aléatoire avec une longueur sélectionnée

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>

Eh bien, vous pouvez toujours utiliser l'objet window.crypto disponible dans la version récente du navigateur.

Il suffit d'une ligne de code pour obtenir un nombre aléatoire:

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

Il aide également à crypter et décrypter les données. Plus d'informations sur la documentation Web MDN - window.crypto .