Generieren Sie eine zufällige Kennwortzeichenfolge mit Anforderungen in Javascript

Ich möchte eine zufällige Zeichenfolge generieren, die 5 Buchstaben aus az und 3 Zahlen enthalten muss.

Wie kann ich das mit JavaScript machen?

Ich habe das folgende Skript, aber es entspricht nicht meinen Anforderungen.

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

Das Erzwingen einer festen Anzahl von Zeichen ist eine schlechte Idee. Die Qualität des Passworts wird dadurch nicht verbessert. Schlimmer noch, es reduziert die Anzahl möglicher Passwörter, so dass das Hacken durch Bruteforcing einfacher wird.

Verwenden Sie Folgendes, um ein zufälliges Wort zu generieren, das aus alphanumerischen Zeichen besteht:

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

Wie funktioniert es?

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

Dokumentation für die Number.prototype.toStringund string.prototype.sliceMethoden.

Ein wenig wartbarer und sicherer Ansatz.

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

Viele Antworten (einschließlich des Originals dieser Antwort) entsprechen nicht den Anforderungen des OP an die Anzahl der Buchstaben und Zahlen. Nachfolgend sind zwei Lösungen aufgeführt: Allgemein (keine minimalen Buchstaben / Zahlen) und mit Regeln.

Allgemeines:

Ich glaube, dies ist eine bessere allgemeine Lösung als die oben genannte, weil:

• Es ist sicherer als akzeptierte / am höchsten bewertete Antworten und auch vielseitiger, da es alle Zeichensätze unterstützt, bei denen zwischen Groß- und Kleinschreibung unterschieden wird
• Es ist prägnanter als andere Antworten (für die allgemeine Lösung maximal 3 Zeilen; kann einzeilig sein)
• Es wird nur natives Javascript verwendet - keine Installation oder andere Bibliotheken erforderlich

Beachten Sie, dass

• hierfür auf IE zu arbeiten, muss der Array.fill () Prototyp wird polyfilled
• falls verfügbar, verwenden Sie besser window.crypto.getRandomValues ​​() anstelle von Math.random () (danke @BenjaminH für den Hinweis)

Dreiliner:

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

Oder als Einzeiler:

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

Mit Buchstaben- / Zahlenregeln

Nun eine Variation des oben genannten. Dadurch werden drei zufällige Zeichenfolgen aus den angegebenen Zeichensätzen (Buchstaben oder Zahlen) generiert und das Ergebnis verschlüsselt.

Bitte beachten Sie, dass im Folgenden sort () nur zur Veranschaulichung verwendet wird. Für den produktiven Einsatz, ersetzen Sie die unten sort () Funktion mit einem Shuffle - Funktion wie Durstenfeld .

Erstens als Funktion:

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

Das Gleiche gilt für einen 2-Liner (zugegebenermaßen sehr lange und hässliche Linien - und wird kein 1-Liner sein, wenn Sie eine ordnungsgemäße Shuffle-Funktion verwenden. Nicht empfohlen, aber manchmal macht es trotzdem Spaß):

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

Für jemanden, der nach einem einfachsten Skript sucht. Neinwhile (true) , nein if/else, keine Erklärung.

Basiert auf der Antwort von mwag, aber diese verwendet crypto.getRandomValueseinen stärkeren Zufall alsMath.random .

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

Sehen dies für 0xffffffff.

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

Alternative 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())

Dies ist nicht genau optimiert, sollte aber funktionieren.

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

Wenn Sie

Hier ist eine jsfiddle, auf der Sie testen können: http://jsfiddle.net/sJGW4/3/

Falls Sie ein Passwort benötigen, das mit mindestens 1 Nummer, 1 Großbuchstaben und 1 Kleinbuchstaben generiert wurde:

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

Hier ist die Geige, wenn Sie spielen / testen möchten: http://jsfiddle.net/sJGW4/155/

Props an @mwag für den Start, um dies zu erstellen.

Wie @RobW feststellt, ist es eine schlechte Idee , das Kennwort auf eine feste Anzahl von Zeichen zu beschränken, wie im OP-Schema vorgeschlagen . Aber schlimmer noch, Antworten, die Code basierend auf vorschlagen Math.random, sind eine wirklich schlechte Idee .

Beginnen wir mit der schlechten Idee . Der OP-Code wählt zufällig eine Zeichenfolge mit 8 Zeichen aus einem Satz von 62 Zeichen aus. Wenn die zufällige Zeichenfolge auf 5 Buchstaben und 3 Zahlen beschränkt wird, haben die resultierenden Kennwörter bestenfalls 28,5 Bit Entropie (im Gegensatz zu einem Potenzial von 47,6 Bit) wenn die Verteilungsbeschränkung von 5 Buchstaben und 3 Zahlen aufgehoben wurde). Das ist nicht sehr gut In Wirklichkeit ist die Situation jedoch noch schlimmer. Der beste Aspekt des Codes wird durch die Verwendung Math.randomals Mittel zur Erzeugung von Entropie für die Passwörter zerstört. Math.randomist ein Pseudozufallszahlengenerator . Aufgrund der deterministischen Natur von Pseudozufallszahlengeneratoren ist die Entropie der resultierenden Passwörter wirklich schlechtDies macht eine solche vorgeschlagene Lösung zu einer wirklich schlechten Idee . Angenommen, diese Passwörter werden an Endbenutzer verteilt (o / w, worum geht es), hat ein aktiver Gegner, der ein solches Passwort erhält, sehr gute Chancen, zukünftige Passwörter vorherzusagen, die an andere Benutzer verteilt werden, und das ist wahrscheinlich keine gute Sache.

Aber zurück zu der einfach schlechten Idee . Angenommen, stattdessen wird ein kryptografisch starker Pseudozufallszahlengenerator verwendet Math.random. Warum sollten Sie die Passwörter auf 28,5 Bit beschränken? Wie gesagt, das ist nicht sehr gut. Vermutlich soll das Schema mit 5 Buchstaben und 3 Zahlen den Benutzern bei der Verwaltung zufällig verteilter Passwörter helfen. Aber seien wir ehrlich, haben Sie balancieren einfache Bedienung gegen Nutzwertes abwägen, und 28,5 Bit Entropie sind für die Verteidigung gegen einen aktiven Gegner nicht sehr wertvoll.

Aber genug von dem Bösen. Lassen Sie uns einen Weg vorwärts vorschlagen. Ich werde die JavaScript EntropyString- Bibliothek verwenden, die "effizient kryptografisch starke Zufallszeichenfolgen mit bestimmter Entropie aus verschiedenen Zeichensätzen generiert". Anstelle der OP 62-Zeichen verwende ich einen Zeichensatz mit 32 Zeichen, um die Verwendung von leicht verwirrbaren Zeichen oder die Bildung von englischen Wörtern zu reduzieren. Und anstatt des 5-Buchstaben-3-Zahlen-Schemas (das zu wenig Entropie aufweist) werde ich verkünden, dass das Passwort 60 Bit Entropie enthält (dies ist das Gleichgewicht zwischen Leichtigkeit und Wert).

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

"Q7LfR8Jn7RDp"

Beachten Sie, dass das Argument für random.stringdie gewünschten Entropiebits ist, im Gegensatz zu häufigeren Lösungen für die Erzeugung zufälliger Zeichenfolgen, bei denen die Übergabe in einer Zeichenfolgenlänge angegeben wird (die sowohl falsch als auch normalerweise nicht spezifiziert ist, aber das ist eine andere Geschichte).

Ich habe eine kleine geschrieben, die von Ihrer Antwort inspiriert ist:

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

Diese Funktion gibt das Passwort zurück und kann im Lesezeichen verwendet werden wie:

javascript:alert(TheCodeOfTheFunction);

Ich würde nicht empfehlen, ein erzwungenes Passwort zu verwenden, da dies die Sicherheit des Benutzers einschränkt. Es gibt jedoch einige Möglichkeiten, dies zu tun:

Traditionelle JavaScript-Methode -

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

Zufällige Zeichenfolge verwenden

Zufällige Zeichenfolge installieren:

npm install randomstring

Verwenden Sie es in App.js -

var randStr = require('randomstring');

var yourString = randStr.generate(8);

Der Wert Ihres Passworts wird in der Variablen gespeichert yourString.

Verwenden Sie kein erzwungenes Passwort!

Erzwungenes Passwort kann Ihre Sicherheit beeinträchtigen, da sich alle Passwörter unter demselben Zeichensatz befinden, der leicht verletzt werden kann!

Ok, wenn ich gut verstehe, dass Sie versuchen, ein zufälliges Zeichenfolgenkennwort zu erhalten, das 5 Buchstaben und 3 Zahlen enthält, die zufällig positioniert sind und eine Länge von 8 Zeichen haben und Sie Maj- und Min-Buchstaben akzeptieren, können Sie dies mit der folgenden Funktion tun ::

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

Und schließlich ohne Gleitkomma-Hacks:

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

Sicheres Passwort mit einem Zeichen für Großbuchstaben.

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)

Meine Crypto-basierte Version übernimmt das Problem. Verwenden von ES6 und Weglassen von Überprüfungen der Browserfunktionen. Kommentare zur Sicherheit oder Leistung?

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

Versuchen Sie dies, es funktioniert. Laden Sie das Skript in Ihre Javascript-Anwendung herunter und rufen Sie die Funktion randomPassword () https://gist.github.com/enishant/4ba920c71f338e83c7089dc5d6f33a64 auf

Erstellen Sie einen Kennwortgeneratordienst mit dem Namen 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('');
  }
}

Vergessen Sie nicht, den Dienst auf dem von Ihnen verwendeten Modul hinzuzufügen

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

Fügen Sie auf Ihrem Controller eine Methode hinzu, die die Methode zum Generieren des Kennworts innerhalb des Dienstes aufruft, und legen Sie das Ergebnis im Kennwortfeld fest

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

Es gibt einen Generator für zufällige Kennwortzeichenfolgen mit ausgewählter Länge

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>

Nun, Sie können immer das window.crypto-Objekt verwenden, das in der neuesten Version des Browsers verfügbar ist.

Benötigen Sie nur eine Codezeile, um eine Zufallszahl zu erhalten:

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

Es hilft auch, Daten zu verschlüsseln und zu entschlüsseln. Weitere Informationen finden Sie unter MDN-Webdokumente - window.crypto .