รักษาความปลอดภัยโทเค็นแบบสุ่มใน Node.js

ในคำถามนี้ Erik จำเป็นต้องสร้างโทเค็นแบบสุ่มที่ปลอดภัยใน Node.js มีวิธีcrypto.randomBytesที่สร้างบัฟเฟอร์แบบสุ่ม อย่างไรก็ตาม base64 เข้ารหัสในโหนดไม่ URL ปลอดภัยก็มี/และ+แทนและ- _ดังนั้นวิธีที่ง่ายที่สุดในการสร้างโทเค็นที่ฉันพบคือ

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

มีวิธีที่สง่างามกว่านี้ไหม?

ลองcrypto.randomBytes () :

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

การเข้ารหัส 'hex' ทำงานในโหนด v0.6.x หรือใหม่กว่า

ตัวเลือกแบบซิงโครนัสในกรณีที่คุณไม่ใช่ผู้เชี่ยวชาญ JS อย่างฉัน ต้องใช้เวลาในการเข้าถึงตัวแปรฟังก์ชั่นอินไลน์

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

0. การใช้ไลบรารีของบุคคลที่สาม nanoid [ใหม่!]

เครื่องมือสร้างสตริง ID ที่ไม่ซ้ำใครและปลอดภัยและเป็นมิตรกับ URL สำหรับ JavaScript

https://github.com/ai/nanoid

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

1. การเข้ารหัสฐาน 64 ด้วย URL และตัวอักษรที่ปลอดภัยของชื่อไฟล์

หน้า 7 ของ RCF 4648อธิบายวิธีเข้ารหัสในฐาน 64 พร้อมความปลอดภัยของ URL คุณสามารถใช้ไลบรารีที่มีอยู่เช่นbase64urlเพื่อทำงาน

ฟังก์ชั่นจะเป็น:

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

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

ตัวอย่างการใช้งาน:

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

โปรดทราบว่าความยาวสตริงที่ส่งคืนจะไม่ตรงกับอาร์กิวเมนต์ขนาด (ขนาด! = ความยาวสุดท้าย)

2. Crypto สุ่มค่าจากชุดอักขระที่ จำกัด

ระวังด้วยวิธีนี้สตริงสุ่มที่สร้างขึ้นจะไม่กระจายอย่างสม่ำเสมอ

คุณยังสามารถสร้างสตริงแบบสุ่มที่แข็งแกร่งจากชุดอักขระที่ จำกัด เช่นนั้น:

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

ตัวอย่างการใช้งาน:

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

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

วิธีที่ถูกต้องทันสมัยในการทำแบบอะซิงโครนัสโดยใช้มาตรฐาน ES 2016 ของ async และรอ (ณ โหนด 7) จะเป็นดังต่อไปนี้:

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

สิ่งนี้ได้ผลนอกกรอบในโหนด 7 โดยไม่มีการแปลง Babel

URL แบบสุ่มและสตริงชื่อไฟล์ปลอดภัย (1 ไลเนอร์)

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

เช็คเอาท์:

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

ด้วย async / รอคอยและpromisification

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

สร้างสิ่งที่คล้ายกับ VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM

ดูreal_atesวิธี ES2016 มันถูกต้องมากขึ้น

import crypto from 'crypto';

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

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

วิธีการกำเนิด / ผลผลิต

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มีวิธีการ :)

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

โมดูลnpm anyidจัดเตรียม API ที่ยืดหยุ่นเพื่อสร้าง ID สตริง / รหัสสตริงประเภทต่างๆ

ในการสร้างสตริงแบบสุ่มใน A-Za-z0-9 โดยใช้ 48 ไบต์แบบสุ่ม:

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

ในการสร้างตัวอักษรความยาวคงที่สตริงเท่านั้นที่เต็มไปด้วยไบต์สุ่ม

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

ภายในจะใช้crypto.randomBytes()ในการสร้างแบบสุ่ม

นี่คือเวอร์ชัน async ที่ใช้คำต่อคำจากคำตอบของ @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);
});

ฟังก์ชั่นง่าย ๆ ที่จะทำให้คุณได้รับโทเค็นที่ปลอดภัยและมีการเข้ารหัส base64! มันเป็นการรวมกันของ 2 คำตอบจากด้านบน

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