Создать случайную строку пароля с требованиями в javascript

Я хочу сгенерировать случайную строку, которая должна содержать 5 букв от az и 3 числа.

Как я могу это сделать с помощью JavaScript?

У меня есть следующий сценарий, но он не соответствует моим требованиям.

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

Использование фиксированного количества символов - плохая идея. Это не улучшает качество пароля. Что еще хуже, это уменьшает количество возможных паролей, так что взлом с помощью брутфорса становится проще.

Чтобы сгенерировать случайное слово, состоящее из буквенно-цифровых символов, используйте:

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

Как это работает?

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

Документация для Number.prototype.toStringи string.prototype.sliceметодов.

Чуть более удобный и безопасный подход.

Обновление, чтобы расширить то, что я имел в виду и как это работает.

1. Надежно . MDN довольно четко описывает использование Math.random для всего, что связано с безопасностью :

   Math.random() не предоставляет криптографически безопасные случайные числа. Не используйте их ни для чего, связанного с безопасностью. Вместо этого используйте Web Crypto API, а точнее window.crypto.getRandomValues()метод.

   Глядя на can-i-usegetRandomValues в 2020 году, вам, вероятно, больше не понадобится msCryptoи Math.randomзапасной вариант, если вы не заботитесь о старых браузерах.

2. Поддерживаемый - это в основном RegExp _patternпростой способ определить, какие классы символов вы разрешаете в пароле. Но также о трех вещах, каждая из которых выполняет свою работу: определяет шаблон, получает случайный байт настолько безопасно, насколько это возможно, предоставляет общедоступный API для их объединения.

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

Многие ответы (включая оригинал этого) не соответствуют требованиям OP к количеству букв и цифр. Ниже приведены два решения: общее (без минимальных букв / цифр) и с правилами.

Генеральная:

Я считаю, что это лучшее общее решение, чем приведенное выше, потому что:

• он более безопасен, чем принятый / получивший наибольшее количество голосов, а также более универсален, потому что он поддерживает любой набор символов с учетом регистра
• это более кратко, чем другие ответы (для общего решения не более 3 строк; может быть однострочным)
• он использует только собственный Javascript - установка или другие библиотеки не требуются

Обратите внимание, что

• чтобы это работало в IE, прототип Array.fill () должен быть полифиллирован
• если доступно, лучше использовать window.crypto.getRandomValues ​​() вместо Math.random () (спасибо @BenjaminH за указание)

Трехстрочный:

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

Или, как однострочный:

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

С правилами букв / цифр

А теперь вариант вышеизложенного. Это сгенерирует три случайные строки из заданных кодировок (буква, цифра, любая), а затем зашифрует результат.

Обратите внимание, что ниже sort () используется только в иллюстративных целях. Для производственного использования замените приведенную ниже функцию sort () функцией перемешивания, такой как Durstenfeld .

Во-первых, как функция:

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

То же самое, что и двухстрочный (правда, очень длинные и некрасивые строки - и не будет однострочным, если вы используете правильную функцию перемешивания. Не рекомендуется, но иногда это все равно весело):

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

Для тех, кто ищет самый простой сценарий. Нет while (true), нет if/else, без декларации.

Основываясь на ответе mwag, но этот использует crypto.getRandomValuesболее сильный случайный, чем Math.random.

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

См. Это для 0xffffffff.

Альтернатива 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());

Альтернатива 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())

Это не совсем оптимизировано, но должно работать.

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

Взаимодействие с другими людьми

Вот jsfiddle, на котором вы можете протестировать: http://jsfiddle.net/sJGW4/3/

Как отмечает @RobW, ограничение пароля фиксированным числом символов, как предлагается в схеме OP, - плохая идея . Но что еще хуже, ответы, предлагающие код, основанный на коде Math.random, - это действительно плохая идея .

Начнем с плохой идеи . Код OP случайным образом выбирает строку из 8 символов из набора из 62. Ограничение случайной строки до 5 букв и 3 цифр означает, что полученные пароли будут иметь в лучшем случае 28,5 бит энтропии (в отличие от потенциальных 47,6 битов. если было снято ограничение раздачи в 5 букв и 3 цифры). Это не очень хорошо. Но на самом деле ситуация еще хуже. В лучшем случае код разрушается при использовании в Math.randomкачестве средства генерации энтропии для паролей. Math.randomявляется генератором псевдослучайных чисел . Из-за детерминированной природы генераторов псевдослучайных чисел энтропия получаемых паролей действительно плохая., что делает любое такое предлагаемое решение действительно плохой идеей . Предполагая, что эти пароли раздаются конечным пользователям (в чем суть), активный противник, получивший такой пароль, имеет очень хорошие шансы предсказать будущие пароли, выданные другим пользователям, и это, вероятно, не очень хорошо.

Но вернемся к просто плохой идее . Предположим, что вместо него используется криптографически стойкий генератор псевдослучайных чисел Math.random. Почему вы ограничиваете пароли до 28,5 бит? Как уже отмечалось, это не очень хорошо. Предположительно, схема из 5 букв и 3 цифр предназначена для помощи пользователям в управлении случайно распределенными паролями. Но давайте посмотрим правде в глаза, вам нужно сбалансировать простоту использования с ценностью использования , а 28,5 бит энтропии не имеют большого значения для защиты от активного противника.

Но хватит плохого. Предложим путь вперед. Я буду использовать библиотеку EntropyString JavaScript, которая «эффективно генерирует криптографически стойкие случайные строки с заданной энтропией из различных наборов символов». Вместо символов OP 62 я буду использовать набор из 32 символов, выбранных для уменьшения использования легко запутываемых символов или образования английских слов. И вместо схемы из 5 букв и 3 цифр (у которой слишком мало энтропии) я заявляю, что пароль будет иметь 60 бит энтропии (это баланс легкости и ценности).

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

"Q7LfR8Jn7RDp"

Обратите внимание на аргументы для Entropyуказания желаемых бит энтропии, в отличие от более часто встречающихся решений для генерации случайных строк, которые определяют передачу длины строки (которая является ошибочной и обычно недооцененной, но это уже другая история).

Если вам нужен пароль, содержащий как минимум 1 цифру, 1 символ верхнего регистра и 1 символ нижнего регистра:

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

Вот скрипка, если вы хотите поиграть / протестировать: http://jsfiddle.net/sJGW4/155/

Благодарим @mwag за то, что он дал мне начало его созданию.

Я написал небольшой, вдохновленный вашим ответом:

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

Эта функция возвращает пароль и может использоваться в букмарклете, например:

javascript:alert(TheCodeOfTheFunction);

Я бы не рекомендовал использовать принудительный пароль, поскольку он ограничивает безопасность пользователя, но в любом случае есть несколько способов сделать это:

Традиционный метод JavaScript -

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

Использование случайной строки

Установить случайную строку:

npm install randomstring

Используя его в App.js -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

Значение вашего пароля хранится в переменной yourString.

Не используйте принудительный пароль!

Принудительный пароль может нанести ущерб вашей безопасности, поскольку все пароли будут иметь один и тот же набор символов, что может быть легко взломано!

Хорошо, если я хорошо понимаю, что вы пытаетесь получить случайный строковый пароль, который содержит 5 букв и 3 числа, расположенных в случайном порядке и, следовательно, имеющий длину 8 символов, и вы принимаете буквы maj и min, вы можете сделать это с помощью следующей функции :

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

И, наконец, без использования хаков с плавающей запятой:

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

Надежный пароль с помощью одного символа в верхнем регистре.

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)

My Crypto, основанный на решении проблемы. Использование ES6 и пропуск любых проверок функций браузера. Есть комментарии по безопасности или производительности?

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

Попробуйте, это работает. Загрузите скрипт в свое приложение javascript и вызовите функцию randomPassword () https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64

Создайте службу генератора паролей под названием 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('');
  }
}

не забудьте добавить службу в модуль, который вы используете

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

На вашем контроллере добавьте метод, который вызывает метод создания пароля внутри службы и устанавливает результат в поле пароля.

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

Есть генератор случайных строк паролей выбранной длины

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>

Что ж, вы всегда можете использовать объект window.crypto, доступный в последней версии браузера.

Достаточно одной строчки кода, чтобы получить случайное число:

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

Это также помогает зашифровать и расшифровать данные. Дополнительная информация в веб-документации MDN - window.crypto .

Любой пароль, созданный с помощью Math.random (), ОЧЕНЬ ПЛОХО .

Эта функция использует системное время в качестве начального числа для генератора случайных чисел. Любой, кто знает время создания пароля, может легко подобрать пароль.

Почти во всех случаях эти данные легко доступны - просто возьмите столбец registration_time во взломанной базе данных и проверьте все значения, сгенерированные алгоритмом Math.random (), используя времена от 15 до 0 минут до этого.

Пароль, созданный с помощью Math.random (), совершенно бесполезен, потому что времени, когда пароль был впервые использован, достаточно для его взлома.