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

Code pour générer un mot de passe dont la longueur sera donnée (par défaut 8) et qui aura Au moins une majuscule, une minuscule, un chiffre et un symbole.

(2 fonctions et une variable const appelée 'allowed')

const allowed = {
    uppers: "QWERTYUIOPASDFGHJKLZXCVBNM",
    lowers: "qwertyuiopasdfghjklzxcvbnm",
    numbers: "1234567890",
    symbols: "!@#$%^&*"
}

const getRandomCharFromString = (str) => str.charAt(Math.floor(Math.random() * str.length))
const generatePassword = (length = 8) => { // password will be @Param-length, default to 8, and have at least one upper, one lower, one number and one symbol
    let pwd = "";
    pwd += getRandomCharFromString(allowed.uppers); //pwd will have at least one upper
    pwd += getRandomCharFromString(allowed.lowers); //pwd will have at least one lower
    pwd += getRandomCharFromString(allowed.numbers); //pwd will have at least one number
    pwd += getRandomCharFromString(allowed.symbols);//pwd will have at least one symbolo
    for (let i = pwd.length; i < length; i++)
        pwd += getRandomCharFromString(Object.values(allowed).join('')); //fill the rest of the pwd with random characters
    return pwd
}

Answer 2

Voici mon point de vue (avec Typescript) sur ce sujet en utilisant l'API cryptographique du navigateur et en imposant un mot de passe qui a au moins.. :

• 1 lettre minuscule
• 1 lettre majuscule

• 1 symbole

  const LOWER_CASE_CHARS = 'abcdefghijklmnopqrstuvwxyz'.split(''); const UPPER_CASE_CHARS = LOWER_CASECHARS.map((x) => x.toUpperCase()); const SYMBOLS = '!£$%^&*()@~:;,./?{}=-'.split(''); const LETTERS_MIX = [...LOWER_CASE_CHARS, ...UPPER_CASE_CHARS, ...SYMBOLS]; const CHARS_LENGTH = LETTERS_MIX.length;

  function containsLowerCase(str: string): boolean { return LOWER_CASE_CHARS.some((x) => str.includes(x)); }

  function containsUpperCase(str: string): boolean { return UPPER_CASE_CHARS.some((x) => str.includes(x)); }

  function containsSymbol(str: string): boolean { return SYMBOLS.some((x) => str.includes(x)); }

  function isValidPassword(password: string) { return containsLowerCase(password) && containsUpperCase(password) && containsSymbol(password); }

  export function generateStrongPassword(length: number = 16): string { const buff = new Uint8Array(length);

  let generatedPassword = '';

  do { window.crypto.getRandomValues(buff); generatedPassword = [...buff].map((x) => LETTERS_MIX[x % CHARS_LENGTH]).join(''); } while (!isValidPassword(generatedPassword));

  return generatedPassword; }

Answer 3

Voici un code tout simplement intelligent :

function generate(l) {
    if (typeof l==='undefined'){var l=8;}
    /* c : alphanumeric character string */
    var c='abcdefghijknopqrstuvwxyzACDEFGHJKLMNPQRSTUVWXYZ12345679',
    n=c.length,
    /* p : special character string */
    p='!@#$+-*&_',
    o=p.length,
    r='',
    n=c.length,
    /* s : determinate the position of the special character */
    s=Math.floor(Math.random() * (p.length-1));

    for(var i=0; i<l; ++i){
        if(s == i){
            /* special charact insertion (random position s) */
            r += p.charAt(Math.floor(Math.random() * o));
        }else{
            /* alphanumeric insertion */
            r += c.charAt(Math.floor(Math.random() * n));
        }
    }
    return r;
}

Il suffit d'appeler generate(), et il fait la clé contenant un caractère spécial (!@#$+-*&_) pour la sécurité.

Résultats possibles : WJGUk$Ey, gaV7#fF7, ty_T55DD, YtrQMWveZqYyYKo_

Vous trouverez plus de détails et d'exemples sur mon site web : https://www.bxnxg.com/minituto-01-generer-mots-de-passes-secures-facilements-en-javascript/

Answer 4

Attribue de manière aléatoire des caractères alpha, numériques, majuscules et spéciaux par caractère puis valide le mot de passe. S'il ne contient pas chacun des éléments ci-dessus, il attribue aléatoirement un nouveau caractère de l'élément manquant à un caractère existant aléatoire puis valide récursivement jusqu'à ce qu'un mot de passe soit formé :

function createPassword(length) {
    var alpha = "abcdefghijklmnopqrstuvwxyz";
    var caps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    var numeric = "0123456789";
    var special = "!$^&*-=+_?";

    var options = [alpha, caps, numeric, special];

    var password = "";
    var passwordArray = Array(length);

    for (i = 0; i < length; i++) {
        var currentOption = options[Math.floor(Math.random() * options.length)];
        var randomChar = currentOption.charAt(Math.floor(Math.random() * currentOption.length));
        password += randomChar;
        passwordArray.push(randomChar);
    }

    checkPassword();

    function checkPassword() {
        var missingValueArray = [];
        var containsAll = true;

        options.forEach(function (e, i, a) {
            var hasValue = false;
            passwordArray.forEach(function (e1, i1, a1) {
                if (e.indexOf(e1) > -1) {
                    hasValue = true;
                }
            });

            if (!hasValue) {
                missingValueArray = a;
                containsAll = false;
            }
        });

        if (!containsAll) {
            passwordArray[Math.floor(Math.random() * passwordArray.length)] = missingValueArray.charAt(Math.floor(Math.random() * missingValueArray.length));
            password = "";
            passwordArray.forEach(function (e, i, a) {
                password += e;
            });
            checkPassword();
        }
    }

    return password;
}

Answer 5

Arrêtez la folie !

Mon point faible est que chaque outil d'inscription autorise un ensemble différent de caractères spéciaux. Certains peuvent n'autoriser que les caractères suivants @#$%&* alors que d'autres n'autorisent peut-être pas * mais autorisent d'autres choses. Tous les générateurs de mots de passe que j'ai rencontrés sont binaires en ce qui concerne les caractères spéciaux. Ils vous permettent de les inclure ou non. Je dois donc passer en revue des tonnes d'options et rechercher les caractères aberrants qui ne répondent pas aux exigences jusqu'à ce que je trouve un mot de passe qui fonctionne. Plus le mot de passe est long, plus cela devient fastidieux. Enfin, j'ai remarqué que, parfois, les outils d'inscription ne permettent pas de répéter le même caractère deux fois de suite, mais les générateurs de mots de passe ne semblent pas en tenir compte. C'est de la folie !

Je l'ai créé pour moi-même afin de pouvoir coller l'ensemble exact des caractères spéciaux autorisés. Je ne prétends pas que c'est un code élégant. Je l'ai juste assemblé pour répondre à mes besoins.

De plus, je n'ai jamais pensé qu'un outil d'inscription n'autorisait pas les chiffres ou n'était pas sensible à la casse. Mes mots de passe comportent donc toujours au moins un chiffre, une lettre majuscule, une lettre minuscule et un caractère spécial. La longueur minimale est donc de 4. Techniquement, je peux contourner l'exigence relative aux caractères spéciaux en saisissant simplement une lettre si nécessaire.

const getPassword = (length, arg) => {
  length = document.getElementById("lengthInput").value || 16;
  arg = document.getElementById("specialInput").value || "~!@#$%^&*()_+-=[]{}|;:.,?><";
  if (length < 4) {
    updateView("passwordValue", "passwordValue", "", "P", "Length must be at least 4");
    return console.error("Length must be at least 4")
  } else if (length > 99) {
    updateView("passwordValue", "passwordValue", "", "P", "Length must be less then 100");
    return console.error("Length must be less then 100")
  }
  const lowercase = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
  const uppercase = lowercase.join("").toUpperCase().split("");
  const specialChars = arg.split("").filter(item => item.trim().length);
  const numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  let hasNumber = false;
  let hasUpper = false;
  let hasLower = false;
  let hasSpecial = false;

  if (Number(length)) {
    length = Number(length)
  } else {
    return console.error("Enter a valid length for the first argument.")
  }

  let password = [];
  let lastChar;
  for (let i = 0; i < length; i++) {
    let char = newChar(lowercase, uppercase, numbers, specialChars);
    if (char !== lastChar) {
      password.push(char);
      lastChar = char
      if (Number(char)) {
        hasNumber = true
      }
      if (lowercase.indexOf(char) > -1) {
        hasLower = true
      }
      if (uppercase.indexOf(char) > -1) {
        hasUpper = true
      }
      if (specialChars.indexOf(char) > -1) {
        hasSpecial = true
      }
    } else {
      i--
    }
    if (i === length - 1 && (!hasNumber || !hasUpper || !hasLower || !hasSpecial)) {
      hasNumber = false;
      hasUpper = false;
      hasLower = false;
      hasSpecial = false;
      password = [];
      i = -1;
    }
  }

  function newChar(lower, upper, nums, specials) {
    let set = [lower, upper, nums, specials];
    let pick = set[Math.floor(Math.random() * set.length)];
    return pick[Math.floor(Math.random() * pick.length)]
  }
  updateView("passwordValue", "passwordValue", "", "P", password.join(""));
  updateView("copyPassword", "copyPassword", "", "button", "copy text");
  document.getElementById("copyPassword").addEventListener("click", copyPassword);
}

const copyPassword = () => {
  let text = document.getElementById("passwordValue").textContent;
  navigator.clipboard.writeText(text);
};

const updateView = (targetId, newId, label, element, method = '') => {
  let newElement = document.createElement(element);
  newElement.id = newId;
  let content = document.createTextNode(label + method);
  newElement.appendChild(content);

  let currentElement = document.getElementById(targetId);
  let parentElement = currentElement.parentNode;
  parentElement.replaceChild(newElement, currentElement);
}

document.getElementById("getPassword").addEventListener("click", getPassword);

<!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8">
</head>

<body>
  <div>
    <button id="getPassword">Generate Password</button>
    <input type="number" id="lengthInput" placeholder="Length">
    <input type="text" id="specialInput" placeholder="Special Characters">
    <p id="passwordValue"></p>
    <p id="copyPassword"></p>
  </div>

</body>

</html>