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

Question

Je veux générer une chaîne aléatoire qui doit comporter 5 lettres de a à z et 3 chiffres.

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

Answer 1

Dans le cas où 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/

Bravo à @mwag pour m'avoir donné l'idée de créer ceci.

Answer 2

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

Commençons par le mauvaise idée . Le code OP consiste à sélectionner de façon aléatoire une chaîne de 8 caractères parmi un ensemble de 62. En limitant la chaîne aléatoire à 5 lettres et 3 chiffres, les mots de passe résultants auront , au mieux L'entropie est de 28,5 bits (contre un potentiel de 47,6 bits si la restriction de distribution de 5 lettres et 3 chiffres était supprimée). Ce n'est pas très bon. Mais en réalité, la situation est encore pire. Le site au mieux de l'aspect du code est détruit par l'utilisation de Math.random comme moyen de générer de l'entropie pour les mots de passe. Math.random est 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 de vraiment mauvais ce qui fait que toute solution proposée est une très mauvaise idée . En supposant que ces mots de passe soient distribués aux utilisateurs finaux (o/w what's the point), 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 aux autres utilisateurs, et ce n'est probablement pas une bonne chose.

Mais revenons au juste mauvaise idée . Supposons qu'un générateur de nombres pseudo-aléatoires cryptographiquement fort soit utilisé au lieu de Math.random . Pourquoi limiter les mots de passe à 28,5 bits ? Comme indiqué, ce n'est pas très bon. On peut supposer que le schéma 5 lettres, 3 chiffres est destiné à aider les utilisateurs à gérer les mots de passe distribués de manière aléatoire. Mais regardons les choses en face, vous devez équilibrer la facilité d'utilisation contre valeur d'usage et 28,5 bits d'entropie n'ont pas une grande valeur pour se défendre contre un adversaire actif.

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

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

"Q7LfR8Jn7RDp"

Notez les arguments de Entropy spécifier les bits d'entropie souhaités, par opposition aux solutions les plus courantes pour la génération de chaînes aléatoires qui consistent à indiquer une longueur de chaîne (ce qui est à la fois malavisé et généralement non spécifié, mais c'est une autre histoire).

Answer 3

J'en ai écrit un petit en m'inspirant 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 un bookmarklet comme celui-ci :

javascript:alert(TheCodeOfTheFunction);

Answer 4

Ok, si je comprends bien, vous essayez d'obtenir un mot de passe de type chaîne aléatoire qui contient 5 lettres et 3 chiffres positionnés de manière aléatoire et donc qui a une longueur de 8 caractères et vous acceptez les lettres majuscules et minuscules, 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))

Answer 5

Tout mot de passe généré avec Math.random() est EXTREMELY BAD .

Cette fonction utilise l'heure du système comme graine pour le générateur de nombres aléatoires. Toute personne qui connaît l'heure à laquelle le mot de passe a été généré peut facilement forcer le mot de passe.

Dans presque tous les cas, ces données sont facilement disponibles - il suffit de prendre la colonne registration_time dans une base de données piratée, et de tester toutes les valeurs générées par l'algorithme Math.random() en utilisant les temps de 15 à 0 minutes auparavant.

Un mot de passe généré avec Math.random() n'a aucune valeur. car l'heure à laquelle le mot de passe a été utilisé pour la première fois est suffisante pour le craquer.