用 window.crypto.getRandomValues 在 JavaScript 中洗牌

Question

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

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

为什么这实际上是必要的？

对于游戏来说，也许你真的不需要完美的随机性，除非有钱可赢。除此之外，人类可能甚至不会感知随机性中的"differences"。

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

0.000000000000000000000000000000000000000000000000000000005324900157 %

...可能的排列。这意味着理论上可以玩或模拟的所有可能的游戏在实践中将永远不会真正出现。

顺便说一句，如果您不在每次洗牌前都重置为默认顺序，而是从上次洗牌的顺序开始，或者在游戏结束后保持 "mess"，则可以进一步改善结果已播放并从那里随机播放。

要求：

因此，据我所知，要执行上述操作，需要具备以下所有三个组件：

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

解法：

现在可以实现了吗？我们有什么？

Fisher-Yates shuffle就可以了，据我所知
xorshift7 RNG 的内部状态超过所需的 226 位，应该足够了。
使用 window.crypto.getRandomValues 我们可以生成所需的 226 位熵作为我们的种子。如果这还不够，我们可以添加更多的熵 from other sources.

问题：

上述解决方案（以及要求）是否正确？那么如何在实践中使用 JavaScript 中的这些解决方案来实现洗牌呢？如何将这三个组件组合成一个可行的解决方案？

我想我必须将 Fisher-Yates 洗牌示例中 Math.random 的用法替换为对 xorshift7 的调用。但是 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 survey:

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

结合 from here with from ，似乎以下可能是一个更通用和模块化（尽管优化程度较低）的版本：

// 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 中的 API 密钥（ https://api.random.org/json-rpc/1/ ) or parse it out of a link like this: https://www.random.org/integer-sets/?sets=1&num=52&min=1&max=52&seqnos=on&commas=on&order=index&format=html&rnd=new .

当然，您的数据集可能会被拦截，但如果您获得了几十万组数据集，然后将这些数据集打乱就没问题了。

用 window.crypto.getRandomValues 在 JavaScript 中洗牌

Shuffling a poker deck in JavaScript with window.crypto.getRandomValues

javascript

random

shuffle

entropy

编辑：