générateur de mot de passe en javascript

Question

Quelle serait la meilleure approche pour créer un mot de passe aléatoire de 8 caractères contenant a-z , A-Z y 0-9 ?

Il n'y a absolument aucun problème de sécurité, il s'agit simplement d'un prototypage, je veux juste des données qui semblent réalistes.

Je pensais à un for (0 to 7) Math.random pour produire des codes ASCII et les convertir en caractères. Avez-vous d'autres suggestions ?

Answer 1

J'utiliserais probablement quelque chose comme ça :

function generatePassword() {
    var length = 8,
        charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
        retVal = "";
    for (var i = 0, n = charset.length; i < length; ++i) {
        retVal += charset.charAt(Math.floor(Math.random() * n));
    }
    return retVal;
}

Il est possible de l'étendre pour que la longueur et le jeu de caractères soient transmis par un paramètre.

Answer 2

Real Quick-n-dirty™

Math.random().toString(36).slice(2, 10)

Voilà ! 8 caractères alphanumériques aléatoires.

L'idée est de convertir un nombre aléatoire (compris entre 0 et 1) en une chaîne de caractères en base 36 (minuscules de a à z et 0 à 9), puis de récupérer les 8 premiers caractères après le zéro initial et la virgule.

Cependant, veuillez noter que les différents navigateurs et implémentations javascript donnent des résultats différents en matière de profondeur de bits pour les éléments suivants Math.random() . Si vous utilisez un ancien navigateur, ou Safari, cette pourrait signifie (dans le pire des cas) que vous obtenez un mot de passe plus court que 8 caractères. Cependant, vous pourriez résoudre ce problème en concaténant simplement deux chaînes de caractères, puis en les réduisant à nouveau à 8 caractères.

S'il vous plaît sachez que Math.random() était n'ont jamais été conçus ou destinés à être cryptographiquement sûrs. . Comme vous ne voulez que des mots de passe de 8 caractères, je suppose que cela ne vous intéresse pas. Cependant, pour référence, je vais montrer une solution basée sur un CSPRNG réel. L'idée est la même, nous utilisons juste window.crypto à la place.

window.crypto.getRandomValues(new BigUint64Array(1))[0].toString(36)

Ici, nous générons un mot avec 64 bits de données aléatoires, et nous le convertissons en une chaîne de caractères en base 36 (0-9 et a-z). Vous devriez obtenir une chaîne véritablement aléatoire d'environ 10 à 13 caractères. Cependant, pour la rendre plus sûre, nous voulons qu'elle soit plus longue et qu'elle comporte un mélange de majuscules et de minuscules.

Nous pourrions le faire soit en répétant simplement le processus deux fois :

console.log(window.crypto.getRandomValues(new BigUint64Array(1))[0].toString(36).toUpperCase() + window.crypto.getRandomValues(new BigUint64Array(1))[0].toString(36));

Ou nous pourrions faire un générateur générique fantaisiste qui utilise Array.reduce pour concaténer plusieurs mots aléatoires de 64 bits, en alternant entre les majuscules et les minuscules de chaque strophe :

window.crypto.getRandomValues(new BigUint64Array(length)).reduce(
    (prev, curr, index) => (
        !index ? prev : prev.toString(36)
    ) + (
        index % 2 ? curr.toString(36).toUpperCase() : curr.toString(36)
    )
);

length est le nombre de mots de 64 bits à joindre. J'utilise généralement 4, ce qui me donne environ 48-52 caractères alphanumériques aléatoires, majuscules et minuscules.

Vous pouvez aussi éventuellement mélanger l'ordre final, ce qui est facilement réalisable avec ce chaînage "oneliner".

password.split('').sort(
    () => 128 - window.crypto.getRandomValues(new Uint8Array(1))[0]
).join('')

L'idée ici est de diviser la chaîne générée en un tableau de caractères, puis de trier ce tableau de caractères avec un caractère aléatoire cryptographique, et enfin de le réunir à nouveau en une chaîne.

Personnellement, j'ai ce petit bookmarklet enregistré dans la barre de signets de mon navigateur, pour un accès rapide et facile chaque fois que j'ai besoin de générer un nom d'utilisateur spécifique à un site :

javascript:(
  function(){
    prompt('Here is your shiny new random string:', 
      window.crypto.getRandomValues(new BigUint64Array(4)).reduce(
        (prev, curr, index) => (
          !index ? prev : prev.toString(36)
        ) + (
          index % 2 ? curr.toString(36).toUpperCase() : curr.toString(36)
        )
      ).split('').sort(() => 128 -
        window.crypto.getRandomValues(new Uint8Array(1))[0]
      ).join('')
    );
  }
)();

Answer 3

function password_generator( len ) {
    var length = (len)?(len):(10);
    var string = "abcdefghijklmnopqrstuvwxyz"; //to upper 
    var numeric = '0123456789';
    var punctuation = '!@#$%^&*()_+~`|}{[]\:;?><,./-=';
    var password = "";
    var character = "";
    var crunch = true;
    while( password.length<length ) {
        entity1 = Math.ceil(string.length * Math.random()*Math.random());
        entity2 = Math.ceil(numeric.length * Math.random()*Math.random());
        entity3 = Math.ceil(punctuation.length * Math.random()*Math.random());
        hold = string.charAt( entity1 );
        hold = (password.length%2==0)?(hold.toUpperCase()):(hold);
        character += hold;
        character += numeric.charAt( entity2 );
        character += punctuation.charAt( entity3 );
        password = character;
    }
    password=password.split('').sort(function(){return 0.5-Math.random()}).join('');
    return password.substr(0,len);
}

console.log( password_generator() );

Cela génère un mot de passe un peu plus robuste qui devrait passer n'importe quel test de force de mot de passe. ex : f1&d2?I4(h1& , C1^y1)j1@G2# , j2{h6%b5@R2)

Answer 4

function generatePass(pLength){

    var keyListAlpha="abcdefghijklmnopqrstuvwxyz",
        keyListInt="123456789",
        keyListSpec="!@#_",
        password='';
    var len = Math.ceil(pLength/2);
    len = len - 1;
    var lenSpec = pLength-2*len;

    for (i=0;i<len;i++) {
        password+=keyListAlpha.charAt(Math.floor(Math.random()*keyListAlpha.length));
        password+=keyListInt.charAt(Math.floor(Math.random()*keyListInt.length));
    }

    for (i=0;i<lenSpec;i++)
        password+=keyListSpec.charAt(Math.floor(Math.random()*keyListSpec.length));

    password=password.split('').sort(function(){return 0.5-Math.random()}).join('');

    return password;
}

Answer 5

C'est ma fonction pour générer un mot de passe crypto-aléatoire de 8 caractères :

function generatePassword() {
    var buf = new Uint8Array(6);
    window.crypto.getRandomValues(buf);
    return btoa(String.fromCharCode.apply(null, buf));
}

Ce qu'il fait : Récupère 6 entiers 8 bits crypto-aléatoires et les encode en Base64.

Comme le résultat est dans le jeu de caractères Base64, le mot de passe généré peut être composé de A - Z , a - z , 0 - 9 , + y / .