Amankan token acak di Node.js

Dalam pertanyaan ini Erik perlu membuat token acak aman di Node.js. Ada metode crypto.randomBytesyang menghasilkan Buffer acak. Namun, pengkodean base64 dalam node tidak aman-url, itu termasuk /dan +bukannya -dan _. Karena itu, cara termudah untuk menghasilkan token semacam itu yang saya temukan adalah

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

Apakah ada cara yang lebih elegan?

Coba crypto.randomBytes () :

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

Pengkodean 'hex' bekerja di node v0.6.x atau lebih baru.

Opsi sinkron kalau-kalau Anda bukan ahli JS seperti saya. Harus meluangkan waktu untuk mengakses variabel fungsi inline

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

0. Menggunakan perpustakaan pihak ketiga nanoid [BARU!]

Generator ID string kecil, aman, ramah URL, unik untuk JavaScript

https://github.com/ai/nanoid

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

1. Basis 64 Pengkodean dengan URL dan Nama File Alfabet Aman

Halaman 7 dari RCF 4648 menjelaskan cara menyandikan di pangkalan 64 dengan keamanan URL. Anda dapat menggunakan perpustakaan yang ada seperti base64url untuk melakukan pekerjaan itu.

Fungsinya adalah:

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

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

Contoh penggunaan:

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

Perhatikan bahwa panjang string yang dikembalikan tidak akan cocok dengan argumen ukuran (ukuran! = Panjang akhir).

2. Nilai acak Crypto dari kumpulan karakter terbatas

Waspadalah bahwa dengan solusi ini string acak yang dihasilkan tidak terdistribusi secara merata.

Anda juga dapat membuat string acak yang kuat dari serangkaian karakter terbatas seperti itu:

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

Contoh penggunaan:

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

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

Cara tepat terkini untuk melakukan hal ini secara tidak sinkron menggunakan standar ES 2016 untuk async dan menunggu (mulai dari Node 7) adalah sebagai berikut:

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

Ini berfungsi di luar kotak di Node 7 tanpa transformasi Babel

URL acak dan string nama file aman (1 liner)

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

Periksa:

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

Dengan async / menunggu dan promisifikasi .

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

Menghasilkan sesuatu yang mirip VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM

Lihatlah real_atescara ES2016, itu lebih benar.

import crypto from 'crypto';

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

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

Generator / Cara Menghasilkan

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 memiliki metode untuk itu :)

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

Modul npm anyid menyediakan API fleksibel untuk menghasilkan berbagai jenis string ID / kode.

Untuk menghasilkan string acak di A-Za-z0-9 menggunakan 48 byte acak:

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

Untuk menghasilkan alfabet panjang tetap, hanya string yang diisi oleh byte acak:

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

Secara internal itu digunakan crypto.randomBytes()untuk menghasilkan acak.

Ini adalah versi async yang diambil secara verbatim dari jawaban @Yves M. di atas

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

Fungsi sederhana yang memberi Anda token yang aman URL dan memiliki encoding base64! Ini kombinasi dari 2 jawaban dari atas.

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