Створити випадковий рядок пароля з вимогами у 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методи.

Трохи більш підтримуваний та безпечний підхід.

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 () на функцію перетасовки, таку як 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);

Те саме, що і 2-лайнер (правда, дуже довгі та потворні рядки - і не буде 1-лайнером, якщо ви використовуєте належну функцію перетасування. Не рекомендується, але іноді це все одно цікаво):

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

U

Ось jsfiddle для тестування: http://jsfiddle.net/sJGW4/3/

Якщо вам потрібен пароль, згенерований щонайменше з 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 за те, що я почав це створювати.

Як зазначає @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 біт ентропії НЕ так багато значення в захисті проти активного противника.

Але досить поганого. Давайте запропонуємо шлях вперед. Я буду використовувати бібліотеку JavaScript EntropyString, яка "ефективно генерує криптографічно сильні випадкові рядки зазначеної ентропії з різних наборів символів". Замість символів OP 62 я буду використовувати набір символів із 32 символів, вибраних для зменшення використання легко плутаних символів або утворення англійських слів. І замість схеми з 5 літер, 3 цифри (яка має занадто мало ентропії), я проголошую, що пароль матиме 60 біт ентропії (це баланс простоти та вартості).

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

"Q7LfR8Jn7RDp"

Зверніть увагу, що аргументом random.stringє бажані біти ентропії, на відміну від найбільш часто зустрічаються рішень для випадкової генерації рядків, які вказують передачу довжини рядка (що є помилковим та, як правило, невизначеним, але це вже інша історія).

Я написав невеличку, натхненну Вашою відповіддю:

(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 символів, і ви приймаєте великі та мінімальні літери, ви можете зробити це за допомогою наступної функції :

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)

Мій 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 .