Token aleatorio seguro en Node.js

En esta pregunta, Erik necesita generar un token aleatorio seguro en Node.js. Existe el método crypto.randomBytesque genera un búfer aleatorio. Sin embargo, la codificación base64 en el nodo no es segura para URL, incluye /y en +lugar de -y _. Por lo tanto, la forma más fácil de generar ese token que he encontrado es

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

¿Hay alguna forma más elegante?

Prueba crypto.randomBytes () :

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

La codificación 'hexadecimal' funciona en el nodo v0.6.xo posterior.

Opción síncrona en caso de que no sea un experto en JS como yo. Tuve que pasar algún tiempo sobre cómo acceder a la variable de función en línea

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

0. Uso de la biblioteca de terceros nanoid [¡NUEVO!]

Un generador de ID de cadena único, pequeño, seguro, amigable con URL para JavaScript

https://github.com/ai/nanoid

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

1. Codificación Base 64 con alfabeto seguro de URL y nombre de archivo

La página 7 de RCF 4648 describe cómo codificar en base 64 con seguridad de URL. Puede usar una biblioteca existente como base64url para hacer el trabajo.

La función será:

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

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

Ejemplo de uso:

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

Tenga en cuenta que la longitud de la cadena devuelta no coincidirá con el argumento de tamaño (tamaño! = Longitud final).

2. Valores criptográficos aleatorios de un conjunto limitado de caracteres

Tenga en cuenta que con esta solución la cadena aleatoria generada no se distribuye uniformemente.

También puede crear una cadena aleatoria fuerte a partir de un conjunto limitado de caracteres como ese:

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

Ejemplo de uso:

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

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

La forma correcta y actualizada de hacer esto de forma asíncrona utilizando los estándares ES 2016 de asíncrono y espera (a partir del Nodo 7) sería la siguiente:

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

Esto funciona de forma inmediata en el Nodo 7 sin ninguna transformación de Babel

URL aleatoria y cadena de nombre de archivo segura (1 liner)

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

Revisa:

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

Con asíncrono / espera y promisificación .

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

Genera algo similar a VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM

Mire la real_atesforma ES2016, es más correcto.

import crypto from 'crypto';

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

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

Generador / Rendimiento

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 tiene un método para ello :)

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

El módulo nid anyid proporciona una API flexible para generar varios tipos de ID / código de cadena.

Para generar una cadena aleatoria en A-Za-z0-9 usando 48 bytes aleatorios:

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

Para generar una cadena de alfabeto de longitud fija solo llena por bytes aleatorios:

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

Internamente se utiliza crypto.randomBytes()para generar al azar.

Aquí hay una versión asíncrona tomada literalmente de arriba Respuesta de @Yves M.

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

¡Función simple que le proporciona un token que es seguro para URL y tiene codificación base64! Es una combinación de 2 respuestas de arriba.

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