javascript - true - rand token node js




Token aleatório seguro no Node.js (8)

0. Usando biblioteca de terceiros nanoid [NOVO!]

Um gerador de ID de cadeia de caracteres exclusivo, pequeno, seguro e compatível com URL para JavaScript

https://github.com/ai/nanoid

const nanoid = require("nanoid");
const id = nanoid(48);


1. Base 64 Codificação com URL e Alfabeto Seguro de Nome de Arquivo

Página 7 de RCF 4648 descreve como codificar na base 64 com segurança de URL. Você pode usar uma biblioteca existente como base64url para fazer o trabalho.

A função será:

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

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

Exemplo de uso:

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

Observe que o comprimento da string retornada não corresponderá ao argumento de tamanho (tamanho! = Tamanho final).


2. Valores aleatórios criptografados de um conjunto limitado de caracteres

Tenha em atenção que, com esta solução, a cadeia aleatória gerada não é uniformemente distribuída.

Você também pode criar uma string aleatória forte a partir de um conjunto limitado de caracteres como esse:

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

Exemplo de uso:

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

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

Nesta pergunta, Erik precisa gerar um token aleatório seguro no Node.js. Existe o método crypto.randomBytes que gera um Buffer aleatório. No entanto, a codificação base64 no nó não é segura para url, inclui / e + vez de - e _ . Portanto, a maneira mais fácil de gerar esse token que encontrei é

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

Existe uma maneira mais elegante?


A maneira correta e atualizada de fazer isso de forma assíncrona usando os padrões ES 2016 de async e await (como no nó 7) seria a seguinte:

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

Isso funciona fora da caixa no nó 7 sem nenhuma transformação de Babel


Com async / aguardar e promisification .

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

Gera algo semelhante ao VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM


Confira:

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

Olhe para real_ates maneira ES2016, é mais correto.

Maneira ECMAScript 2016 (ES7)

import crypto from 'crypto';

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

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

Gerador / Rendimento

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

Opção síncrona em caso de não ser um especialista em JS como eu. Tive que gastar algum tempo em como acessar a variável de função inline

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

URL aleatória e cadeia de nome de arquivo segura (1 liner)

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







securestring