Sicheres zufälliges Token in Node.js

In dieser Frage muss Erik ein sicheres zufälliges Token in Node.js generieren. Es gibt die Methode crypto.randomBytes, die einen zufälligen Puffer generiert. Die Base64-Codierung im Knoten ist jedoch nicht url-sicher, sondern enthält /und +anstelle von -und _. Daher ist der einfachste Weg, ein solches Token zu generieren, das ich gefunden habe, der

require('crypto').randomBytes(48, function(ex, buf) {
    token = buf.toString('base64').replace(/\//g,'_').replace(/\+/g,'-');
});

Gibt es einen eleganteren Weg?

Versuchen Sie crypto.randomBytes () :

require('crypto').randomBytes(48, function(err, buffer) {
  var token = buffer.toString('hex');
});

Die 'Hex'-Codierung funktioniert in Knoten v0.6.x oder neuer.

Synchrone Option für den Fall, dass Sie kein JS-Experte wie ich sind. Musste einige Zeit damit verbringen, auf die Inline-Funktionsvariable zuzugreifen

var token = crypto.randomBytes(64).toString('hex');

0. Verwenden einer Nanoid-Drittanbieter-Bibliothek [NEU!]

Ein winziger, sicherer, URL-freundlicher, eindeutiger String-ID-Generator für JavaScript

https://github.com/ai/nanoid

import { nanoid } from "nanoid";
const id = nanoid(48);

1. Base 64-Codierung mit URL und Dateiname Safe Alphabet

Seite 7 von RCF 4648 beschreibt, wie in Base 64 mit URL-Sicherheit codiert wird. Sie können eine vorhandene Bibliothek wie base64url verwenden , um die Aufgabe zu erledigen.

Die Funktion wird sein:

var crypto = require('crypto');
var base64url = require('base64url');

/** Sync */
function randomStringAsBase64Url(size) {
  return base64url(crypto.randomBytes(size));
}

Anwendungsbeispiel:

randomStringAsBase64Url(20);
// Returns 'AXSGpLVjne_f7w5Xg-fWdoBwbfs' which is 27 characters length.

Beachten Sie, dass die zurückgegebene Zeichenfolgenlänge nicht mit dem Größenargument übereinstimmt (Größe! = Endlänge).

2. Krypto-Zufallswerte aus einem begrenzten Zeichensatz

Beachten Sie, dass bei dieser Lösung die generierte Zufallszeichenfolge nicht gleichmäßig verteilt ist.

Sie können auch eine starke zufällige Zeichenfolge aus einer begrenzten Anzahl solcher Zeichen erstellen:

var crypto = require('crypto');

/** Sync */
function randomString(length, chars) {
  if (!chars) {
    throw new Error('Argument \'chars\' is undefined');
  }

  var charsLength = chars.length;
  if (charsLength > 256) {
    throw new Error('Argument \'chars\' should not have more than 256 characters'
      + ', otherwise unpredictability will be broken');
  }

  var randomBytes = crypto.randomBytes(length);
  var result = new Array(length);

  var cursor = 0;
  for (var i = 0; i < length; i++) {
    cursor += randomBytes[i];
    result[i] = chars[cursor % charsLength];
  }

  return result.join('');
}

/** Sync */
function randomAsciiString(length) {
  return randomString(length,
    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789');
}

Anwendungsbeispiel:

randomAsciiString(20);
// Returns 'rmRptK5niTSey7NlDk5y' which is 20 characters length.

randomString(20, 'ABCDEFG');
// Returns 'CCBAAGDGBBEGBDBECDCE' which is 20 characters length.

Der aktuell richtige Weg , dies asynchron unter Verwendung der ES 2016-Standards für Async und Warten (ab Knoten 7) zu tun, wäre der folgende:

const crypto = require('crypto');

function generateToken({ stringBase = 'base64', byteLength = 48 } = {}) {
  return new Promise((resolve, reject) => {
    crypto.randomBytes(byteLength, (err, buffer) => {
      if (err) {
        reject(err);
      } else {
        resolve(buffer.toString(stringBase));
      }
    });
  });
}

async function handler(req, res) {
   // default token length
   const newToken = await generateToken();
   console.log('newToken', newToken);

   // pass in parameters - adjust byte length
   const shortToken = await generateToken({byteLength: 20});
   console.log('newToken', shortToken);
}

Dies funktioniert sofort in Knoten 7 ohne Babel-Transformationen

Zufällige URL und Dateinamenzeichenfolge sicher (1 Liner)

Crypto.randomBytes(48).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/\=/g, '');

Auschecken:

var crypto = require('crypto');
crypto.randomBytes(Math.ceil(length/2)).toString('hex').slice(0,length);

Mit Async / Warten und Versprechen .

const crypto = require('crypto')
const randomBytes = Util.promisify(crypto.randomBytes)
const plain = (await randomBytes(24)).toString('base64').replace(/\W/g, '')

Erzeugt etwas Ähnliches wie VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM

Schauen Sie sich real_atesES2016 an, es ist korrekter.

import crypto from 'crypto';

function spawnTokenBuf() {
    return function(callback) {
        crypto.randomBytes(48, callback);
    };
}

async function() {
    console.log((await spawnTokenBuf()).toString('base64'));
};

Generator / Ertragsweg

var crypto = require('crypto');
var co = require('co');

function spawnTokenBuf() {
    return function(callback) {
        crypto.randomBytes(48, callback);
    };
}

co(function* () {
    console.log((yield spawnTokenBuf()).toString('base64'));
});

https://www.npmjs.com/package/crypto-extra hat eine Methode dafür :)

var value = crypto.random(/* desired length */)

Das npm-Modul anyid bietet eine flexible API zum Generieren verschiedener Arten von Zeichenfolgen-IDs / .

So generieren Sie eine zufällige Zeichenfolge in A-Za-z0-9 mit 48 zufälligen Bytes:

const id = anyid().encode('Aa0').bits(48 * 8).random().id();
// G4NtiI9OYbSgVl3EAkkoxHKyxBAWzcTI7aH13yIUNggIaNqPQoSS7SpcalIqX0qGZ

So generieren Sie nur eine Zeichenfolge mit fester Länge, die mit zufälligen Bytes gefüllt ist:

const id = anyid().encode('Aa').length(20).random().id();
// qgQBBtDwGMuFHXeoVLpt

Intern wird es verwendet crypto.randomBytes(), um zufällig zu generieren.

Hier ist eine asynchrone Version, die wörtlich aus der Antwort von @Yves M. stammt

var crypto = require('crypto');

function createCryptoString(length, chars) { // returns a promise which renders a crypto string

    if (!chars) { // provide default dictionary of chars if not supplied

        chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
    }

    return new Promise(function(resolve, reject) {

        var charsLength = chars.length;
        if (charsLength > 256) {
            reject('parm chars length greater than 256 characters' +
                        ' masks desired key unpredictability');
        }

        var randomBytes = crypto.randomBytes(length);

        var result = new Array(length);

        var cursor = 0;
        for (var i = 0; i < length; i++) {
            cursor += randomBytes[i];
            result[i] = chars[cursor % charsLength];
        }

        resolve(result.join(''));
    });
}

// --- now generate crypto string async using promise --- /

var wantStringThisLength = 64; // will generate 64 chars of crypto secure string

createCryptoString(wantStringThisLength)
.then(function(newCryptoString) {

    console.log(newCryptoString); // answer here

}).catch(function(err) {

    console.error(err);
});

Einfache Funktion, mit der Sie ein Token erhalten, das URL-sicher ist und Base64-Codierung hat! Es ist eine Kombination aus 2 Antworten von oben.

const randomToken = () => {
    crypto.randomBytes(64).toString('base64').replace(/\//g,'_').replace(/\+/g,'-');
}