Jeton aléatoire sécurisé dans Node.js

Dans cette question, Erik doit générer un jeton aléatoire sécurisé dans Node.js. Il y a la méthode crypto.randomBytesqui génère un tampon aléatoire. Cependant, le codage base64 dans le nœud n'est pas sûr pour les URL, il inclut /et +au lieu de -et _. Par conséquent, le moyen le plus simple de générer un tel jeton que j'ai trouvé est

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

Existe-t-il une manière plus élégante?

Essayez crypto.randomBytes () :

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

L'encodage «hexadécimal» fonctionne dans le nœud v0.6.x ou plus récent.

Option synchrone au cas où vous n'êtes pas un expert JS comme moi. J'ai dû passer un peu de temps sur la façon d'accéder à la variable de fonction en ligne

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

0. Utilisation d'une bibliothèque tierce nanoïde [NOUVEAU!]

Un minuscule générateur d'ID de chaîne unique, sécurisé, convivial et compatible URL pour JavaScript

https://github.com/ai/nanoid

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

1. Encodage Base 64 avec URL et nom de fichier Safe Alphabet

La page 7 du RCF 4648 décrit comment coder en base 64 avec la sécurité des URL. Vous pouvez utiliser une bibliothèque existante comme base64url pour faire le travail.

La fonction sera:

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

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

Exemple d'utilisation:

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

Notez que la longueur de chaîne retournée ne correspondra pas à l'argument taille (taille! = Longueur finale).

2. Valeurs aléatoires cryptographiques d'un ensemble limité de caractères

Attention, avec cette solution, la chaîne aléatoire générée n'est pas uniformément distribuée.

Vous pouvez également créer une chaîne aléatoire forte à partir d'un ensemble limité de caractères comme celui-ci:

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

Exemple d'utilisation:

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

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

La bonne façon à jour de le faire de manière asynchrone en utilisant les normes ES 2016 d'async et d'attente (à partir du nœud 7) serait la suivante:

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

Cela fonctionne hors de la boîte dans le nœud 7 sans aucune transformation Babel

URL aléatoire et chaîne de nom de fichier sécurisée (1 doublure)

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

Check-out:

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

Avec async / wait et promisification .

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

Génère quelque chose de similaire à VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM

Regardez la real_atesmanière ES2016, c'est plus correct.

import crypto from 'crypto';

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

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

Générateur / rendement

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 a une méthode pour cela :)

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

Le module npm anyid fournit une API flexible pour générer différents types d'ID / code de chaîne.

Pour générer une chaîne aléatoire dans A-Za-z0-9 en utilisant 48 octets aléatoires:

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

Pour générer uniquement une chaîne d'alphabet de longueur fixe remplie d'octets aléatoires:

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

En interne, il utilise crypto.randomBytes()pour générer de façon aléatoire.

Voici une version asynchrone prise mot pour mot d'en haut @Yves M.'s answer

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

Fonction simple qui vous permet d'obtenir un jeton sûr pour les URL et doté d'un encodage base64! C'est une combinaison de 2 réponses d'en haut.

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