用window.crypto.getRandomValues在JavaScript中洗牌

Question

一副扑克牌有52张牌，因此52!或大致2^226可能的排列。

现在，我想完美地洗牌这样一副牌，具有真正的随机结果和均匀分布，这样你就可以到达这些可能的排列中的每一个，并且每个排列都同样可能出现。

为什么这实际上是必要的

对于游戏来说，也许你真的不需要完美的随机性，除非有钱可以赢。除此之外，人类可能甚至不会察觉到随机性的"差异"。

但如果我没有错的话，如果你使用常用编程语言中的洗牌函数和RNG组件，你通常会得到不超过32位的熵和2^32状态。因此，当洗牌时，你永远无法达到牌组的所有52!可能排列，但只能达到。。。

0.00000000000000000000000000000000000000005324900157%

可能的排列。这意味着在理论上可以玩或模拟的许多可能的游戏在实践中永远不会出现。

顺便说一句，如果你不在每次洗牌前都重置为默认顺序，而是从上次洗牌的顺序开始，或者在游戏结束后保持"混乱"，然后再洗牌，你可以进一步提高结果。

要求：

因此，为了完成上述内容，就我所知，需要以下三个组件：

1. 一个很好的混洗算法，可以确保均匀分布
2. 具有至少226个内部状态位的适当RNG。由于我们在确定性机器上，我们将得到一个PRNG，也许这应该是一个CSPRNG
3. 具有至少226比特熵的随机种子

解决方案：

现在这是可以实现的吗？我们有什么？

据我所见，费雪-耶茨的洗牌会很好

xorshift7 RNG具有超过所需226位的内部状态，并且应该足够了

使用window.crypto.getRandomValues，我们可以生成所需的226位熵，用作我们的种子。如果这还不够，我们可以从其他来源添加更多的熵

问题：

上述解决方案(以及要求)是否正确？那么，在实践中如何在JavaScript中使用这些解决方案来实现shuffling呢？如何将这三个组件组合成一个有效的解决方案？

我想我必须用对xorshift7的调用来替换Fisher Yates shuffle示例中Math.random的用法。但是RNG输出的值在[0, 1)浮点范围内，而我需要[1, n]整数范围。当缩放这个范围时，我不想失去均匀分布。此外，我想要大约226比特的随机性。如果我的RNG只输出一个Number，那么这种随机性是否有效地减少到2^53(或2^64)位，因为输出没有更多的可能性？

为了生成RNG的种子，我想做这样的事情：

var randomBytes = generateRandomBytes(226);
function generateRandomBytes(n) {
var data = new Uint8Array(
Math.ceil(n / 8)
);
window.crypto.getRandomValues(data);
return data;
}

这是正确的吗？我不知道如何以任何方式将randomBytes作为种子传递给RNG，也不知道如何修改它以接受它。

Answer 1

下面是我编写的一个函数，它使用基于window.crypto的随机字节的Fisher Yates混洗。由于Fisher Yates要求在不同的范围内生成随机数，因此它从6位掩码(mask=0x3f)开始，但随着所需范围变小(即，每当i是2的幂时)，逐渐减少该掩码中的位数。

function shuffledeck() {
var cards = Array("A♣️","2♣️","3♣️","4♣️","5♣️","6♣️","7♣️","8♣️","9♣️","10♣️","J♣️","Q♣️","K♣️",
"A♦️","2♦️","3♦️","4♦️","5♦️","6♦️","7♦️","8♦️","9♦️","10♦️","J♦️","Q♦️","K♦️",
"A♥️","2♥️","3♥️","4♥️","5♥️","6♥️","7♥️","8♥️","9♥️","10♥️","J♥️","Q♥️","K♥️",
"A♠️","2♠️","3♠️","4♠️","5♠️","6♠️","7♠️","8♠️","9♠️","10♠️","J♠️","Q♠️","K♠️");
var rndbytes = new Uint8Array(100);
var i, j, r=100, tmp, mask=0x3f;
/* Fisher-Yates shuffle, using uniform random values from window.crypto */
for (i=51; i>0; i--) {
if ((i & (i+1)) == 0) mask >>= 1;
do {
/* Fetch random values in 100-byte blocks. (We probably only need to do */
/* this once.) The `mask` variable extracts the required number of bits */
/* for efficient discarding of random numbers that are too large. */
if (r == 100) {
window.crypto.getRandomValues(rndbytes);
r = 0;
}
j = rndbytes[r++] & mask;
} while (j > i);
/* Swap cards[i] and cards[j] */
tmp = cards[i];
cards[i] = cards[j];
cards[j] = tmp;
}
return cards;
}

---

对window.crypto图书馆的评估确实值得提出自己的问题，但无论如何。。。

window.crypto.getRandomValues()提供的伪随机流对于任何目的都应该是足够随机的，但在不同的浏览器中由不同的机制生成。根据2013年的一项调查：

• Firefox(v.21+)使用带440位种子的NIST SP 800-90。注：本标准于2015年更新，删除了(可能是后门)Dual_EC_DRBG椭圆曲线PRNG算法。

• Internet Explorer(v.11+)使用BCryptGenRandom支持的算法之一(种子长度=？)

• Safari、Chrome和Opera使用带有1024位种子的ARC4流密码。

---

编辑：

一个更干净的解决方案是在Javascript的数组原型中添加一个通用的shuffle()方法

// Add Fisher-Yates shuffle method to Javascript's Array type, using
// window.crypto.getRandomValues as a source of randomness.
if (Uint8Array && window.crypto && window.crypto.getRandomValues) {
Array.prototype.shuffle = function() {
var n = this.length;

// If array has <2 items, there is nothing to do
if (n < 2) return this;
// Reject arrays with >= 2**31 items
if (n > 0x7fffffff) throw "ArrayTooLong";

var i, j, r=n*2, tmp, mask;
// Fetch (2*length) random values
var rnd_words = new Uint32Array(r);
// Create a mask to filter these values
for (i=n, mask=0; i; i>>=1) mask = (mask << 1) | 1;

// Perform Fisher-Yates shuffle
for (i=n-1; i>0; i--) {
if ((i & (i+1)) == 0) mask >>= 1;
do {
if (r == n*2) {
// Refresh random values if all used up
window.crypto.getRandomValues(rnd_words);
r = 0;
}
j = rnd_words[r++] & mask;
} while (j > i);
tmp = this[i];
this[i] = this[j];
this[j] = tmp;
}
return this;
}
} else throw "Unsupported";
// Example:
deck = [ "A♣️","2♣️","3♣️","4♣️","5♣️","6♣️","7♣️","8♣️","9♣️","10♣️","J♣️","Q♣️","K♣️",
"A♦️","2♦️","3♦️","4♦️","5♦️","6♦️","7♦️","8♦️","9♦️","10♦️","J♦️","Q♦️","K♦️",
"A♥️","2♥️","3♥️","4♥️","5♥️","6♥️","7♥️","8♥️","9♥️","10♥️","J♥️","Q♥️","K♥️",
"A♠️","2♠️","3♠️","4♠️","5♠️","6♠️","7♠️","8♠️","9♠️","10♠️","J♠️","Q♠️","K♠️"];
deck.shuffle();

Answer 2

将这里的答案与另一个问题的答案相结合，以下版本可能是一个更通用、更模块化(尽管优化程度较低)的版本：

// Fisher-Yates
function shuffle(array) {
var i, j;
for (i = array.length - 1; i > 0; i--) {
j = randomInt(0, i + 1);
swap(array, i, j);
}
}
// replacement for:
//     Math.floor(Math.random() * (max - min)) + min
function randomInt(min, max) {
var range = max - min;
var bytesNeeded = Math.ceil(Math.log2(range) / 8);
var randomBytes = new Uint8Array(bytesNeeded);
var maximumRange = Math.pow(Math.pow(2, 8), bytesNeeded);
var extendedRange = Math.floor(maximumRange / range) * range;
var i, randomInteger;
while (true) {
window.crypto.getRandomValues(randomBytes);
randomInteger = 0;
for (i = 0; i < bytesNeeded; i++) {
randomInteger <<= 8;
randomInteger += randomBytes[i];
}
if (randomInteger < extendedRange) {
randomInteger %= range;
return min + randomInteger;
}
}
}
function swap(array, first, second) {
var temp;
temp = array[first];
array[first] = array[second];
array[second] = temp;
}

Answer 3

我个人认为你可以稍微跳出框框。如果你担心随机性，你可以从random.org(https://api.random.org/json-rpc/1/)，或者从这样的链接中解析它：https://www.random.org/integer-sets/?sets=1&num＝52&min=1&max＝52&seqnos=on&逗号=在&order=索引&format=html&rnd=新。

当然，你的数据集可能会被拦截，但如果你得到几十万个数据集，然后打乱这些数据集，你就可以了。