Bảo mật mã thông báo ngẫu nhiên trong Node.js

Trong câu hỏi này, Erik cần tạo mã thông báo ngẫu nhiên an toàn trong Node.js. Có phương pháp crypto.randomBytestạo Bộ đệm ngẫu nhiên. Tuy nhiên, mã hóa base64 trong nút không an toàn cho url, nó bao gồm /và +thay vì -và _. Do đó, cách dễ nhất để tạo mã thông báo như vậy tôi đã tìm thấy là

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

Có cách nào thanh lịch hơn?

Hãy thử crypto.randomBytes () :

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

Mã hóa 'hex' hoạt động trong nút v0.6.x hoặc mới hơn.

Tùy chọn đồng bộ trong trường hợp nếu bạn không phải là chuyên gia về JS như tôi. Phải dành một chút thời gian để làm thế nào để truy cập vào biến chức năng nội tuyến

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

0. Sử dụng thư viện bên thứ ba nanoid [MỚI!]

Trình tạo ID chuỗi duy nhất, an toàn, thân thiện với URL, dành cho JavaScript

https://github.com/ai/nanoid

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

1. Mã hóa cơ sở 64 với URL và tên tệp Bảng chữ cái an toàn

Trang 7 của RCF 4648 mô tả cách mã hóa trong cơ sở 64 với an toàn URL. Bạn có thể sử dụng một thư viện hiện có như base64url để thực hiện công việc.

Chức năng sẽ là:

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

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

Ví dụ sử dụng:

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

Lưu ý rằng độ dài chuỗi được trả về sẽ không khớp với đối số kích thước (size! = Chiều dài cuối cùng).

2. Giá trị ngẫu nhiên của tiền điện tử từ bộ ký tự giới hạn

Coi chừng với giải pháp này, chuỗi ngẫu nhiên được tạo ra không được phân phối đồng đều.

Bạn cũng có thể xây dựng một chuỗi ngẫu nhiên mạnh mẽ từ một bộ ký tự giới hạn như thế:

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

Ví dụ sử dụng:

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

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

Cách cập nhật đúng để thực hiện điều này một cách không đồng bộ bằng cách sử dụng các tiêu chuẩn không đồng bộ ES 2016 và chờ đợi (kể từ Nút 7) sẽ như sau:

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

Điều này hoạt động ra khỏi hộp trong Nút 7 mà không có bất kỳ biến đổi Babel nào

URL ngẫu nhiên và chuỗi tên tệp an toàn (1 lớp lót)

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

Thủ tục thanh toán:

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

Với async / chờ đợi và hứa hẹn .

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

Tạo ra một cái gì đó tương tự như VjocVHdFiz5vGHnlnwqJKN0NdeHcz8eM

Nhìn vào real_atescách ES2016, nó đúng hơn.

import crypto from 'crypto';

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

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

Cách tạo / năng suất

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 có một phương pháp cho nó :)

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

Mô-đun npm anyid cung cấp API linh hoạt để tạo các loại ID / mã chuỗi khác nhau.

Để tạo chuỗi ngẫu nhiên trong A-Za-z0-9 bằng 48 byte ngẫu nhiên:

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

Để tạo bảng chữ cái có độ dài cố định, chỉ có chuỗi được điền bởi các byte ngẫu nhiên:

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

Trong nội bộ, nó sử dụng crypto.randomBytes()để tạo ngẫu nhiên.

Đây là phiên bản không đồng bộ được lấy nguyên văn từ câu trả lời của @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);
});

Hàm đơn giản giúp bạn nhận được mã thông báo là URL an toàn và có mã hóa base64! Đó là sự kết hợp của 2 câu trả lời từ phía trên.

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