使用node.js生成10的幂模的cryptographc随机数

Question

Using the crypto library I can require the library to give me a number of random bytes. The thing is that this bytes are numbers from 0 to 255 each (inclusive) and thus it is not that simple to create a uniformly distributed results.

What I mean is the following:

The function receives a number N, which is 10, 100, ... 10^b, where b is a number between 1 and 8 (could be bigger, but I don't need anything larger) and returns a number between 0 and the given number (not inclusive to the given number), so say if N is 100, the results of the function are from 0 to 99, and if N is 10 the results are from 0 to 9.

You can create a random number by using Math.random and just multiplying by N and then using floor. However, Math.random is not cryptographically safe, so it must be done by using randomly generated number that are of 2^8m, where m is just whatever number of bytes is given to crypto.randomBytes.

I created a simple function which is working, apparently. However, I am aware that it is fairly easy to induce some bias into random numbers and I would just like to have it validated, since it is somewhat important for the project.

genera_aleatorio_residuo_potencia10 : function (n, cb) {
  var digitos = Math.log(n) / Math.LN10;
  var extra_base2 = digitos > 8 ? digitos - 8 : 0;
  if (Math.floor(digitos + .4) - digitos > 0.00000001) {
    return cb("Numero no es potencia de 10 (10, 100, 1000...)", null);
  }
  digitos = Math.round(digitos);
  async.parallel({
    r1 : crypto_helper.generador_random_bytes(1),
    r2 : crypto_helper.generador_random_bytes(1)
  }, function (err, res) {
    if (err) {
      return cb(err, null);
    }
    var r1 = res.r1[0] + 1;
    var r2 = res.r2[0] + 1;
    var aleatorio = (Math.pow(5, digitos) - 1) * Math.pow(2, extra_base2) * r1 + r2;
    cb(null, aleatorio % n);
  });
}

Needless to say: crypto_helper.generador_random_bytes is a wrapper of node.js' crypto.randomBytes that I frequently use to make it friendlier with the async library.

My reasoning for using Math.pow(5, digitos) and the Math.pow(2, extra_base2) is for the least common multiple between N and 256. In practice, n will never be larger than 100000000, so the Math.pow(2, extra_base2) shouldn't be used in our product, but I would still like to be sure it makes sense to other people.

Answer 1

I found a great solution by simply mimicking what Java's SecureRandom.nextInt(int) is doing at here: SecureRandom.nextInt(int) Will post code as soon as I can get to code it (I'm busy at the moment). I plan to use the code I develop from it, since I confirmed the proposed solution has a bias (it is not acceptable at all).

Here is the adaptation of the JDK code. Notice the limitations on 31 bit numbers, since I realized JS does all its bitwise operations on two's complement with 32 bits. I did not implement the special case for power of 2 numbers since I won't be using it. The solution is for numbers in general and not only powers of 10... I'm sure there must be a better solution for numbers with base 10, but whatever. I rewrote the code to not use my libraries and to make it in English, so that others can use it more easily.

var crypto_random_number_range = function (n, cb) {
  //result is a number from 0 a n-1
  //Javascript works with 32 bits for bitwise operations but these are signed (2-complement), so it is good to limit the size of n
  if (n <= 0 || n > 2147483647) {
    return cb("n must be larger than 0 and smaller than 2147483647", null);
  }
  var bits, val;
  async.doWhilst(
    function (cb2) {
      crypto.randomBytes(4, function (err, rbytes) {
        if (err) {
          return cb2(err);
        }
        bits = ((rbytes[3] & 0x7f) << 24) + 
          (rbytes[2] << 16) + (rbytes[1] << 8) + rbytes[0];
        val = bits % n;
        cb2();
      });
    }, function () {
      return (bits - val + (n-1)) < 0;
    }, function (err) {
      if (err) {
        return cb(err, null);
      }
      return cb(null, val);
    }
  );
}

Did several tests, it seems to be working just fine.

Answer 2

var kazutsukuru = function kazutsukuru(kaketeiruno, kotae) {
  crypto.randomBytes(4, function(mondai, baito) {
    if (mondai) {
      return kotae(mondai);
    }

    kotae(null, Math.floor(baito.readUInt32BE(0) / 4294967296 * kaketeiruno));
  });
};

This should do what you want. I decided to make my answer hard to read because your question is hard to read.