你怎么能扭转这个伪“PRNG”来取回原来的号码？

Question

我有this function 来生成感觉从序列中的随机数：

const fetch = (x, o) => {
  if (x >= o) {
    return x
  } else {
    const v = (x * x) % o
    return (x <= o / 2) ? v : o - v
  }
}

const fetch16 = (x) => fetch(x, 65519)
const fetch8 = (x) => fetch(x, 251)

// the last number can be anything.
const build16 = (x, o) => fetch16((fetch16(x) + o) % 65536 ^ 42703)
const build8 = (x, o) => fetch8((fetch8(x) + o) % 256 ^ 101)

const j = 115; // If you don't want duplicates, either i or j should stay fixed
let i = 0
let invalid = [];
let valid = new Set;
while (i <= 255) { // <-- small fix here!
    let x = build8(i, j); // To test, you can swap i and j here, and run again.
    if (x > 255) {
        invalid.push([ i, j, x ]);
    } else {
        valid.add(x);
    }
    i++;
}

console.log("invalid:", JSON.stringify(invalid));
console.log("count of valid:", valid.size);

这不是真正的 PRNG，请查看 linked post 了解理论。这需要一个递增序列并从递增序列生成感觉像随机整数。也就是说，它将递增序列映射到看似随机的输出，但它遵循一个模式！从输出中很难看出该模式，但它都在理论。 “随机”输出从不重复序列长度（build8 的 8 位整数序列从 0 到 255 的 256 个值）。

鉴于此，您如何获取该函数的输出并取回原始输入？假设我们知道 j 最初插入以生成原始输出。假设你知道j 并且有输出号码，你如何取回原始号码？也就是如何反转这个build8或build16函数？

我一开始就卡住了，我不知道如何反转这样的函数实现的理论。如果你知道这个理论并且可以解释一下，也许这会帮助我自己尝试一下，但现在我会在黑暗中拍摄，想知道如果你已经知道这个理论是否很简单。

我们可以通过说我们知道build8 函数中的o 是什么来简化问题，这在正向和反向/反向版本中始终是固定和已知的。所以我们可以摆脱o，离开x。

const build8b = (x) => fetch8((fetch8(x) + 123) % 256 ^ 101)

问题是，你如何找到x 的输出来自build8b？

console.log(build8b(100)) // => 92
// then this is what we need to figure out how to implement:
console.log(reverse8b(92)) // => 100

如果无法找到逆运算，那么这也是一个很好的答案（以及为什么），那么我可以停止寻找解决方案。

Answer 1

粗略地说，这里的平方是可逆的，因为compute square roots modulo a prime 是可能的。如果你得到的输入值x不是二次余数，那么p - x就是。

因此，您可以反转大多数这些操作，除了在顶部完成的对折。我在下面包含了一些不太有效的代码来演示基本概念。

请注意，这不是一个好的 CSPRNG，因为我们假设攻击者知道我们用来生成它的算法。对于非加密目的它可能已经足够好，但通常对于这些目的，ChaCha8 更快并且产生更好的输出，因为 ChaCha8 目前被认为是加密安全的（但几乎不安全），而对于加密目的，ChaCha12 或 ChaCha20 更好。如果您想要一小组对象的排列，请使用其中一个带有 Fisher-Yates shuffle 的 PRNG。

这是代码。 test8 和 testinv8 显示了没有最终平方和折叠操作的操作，这说明了为什么它不是完全可逆的。

const fetch = (x, o) => {
  if (x >= o) {
    return x
  } else {
    const v = (x * x) % o
    return (x <= o / 2) ? v : o - v
  }
}

const powmod = (a, k, p) => {
    let t = a
    let x = 1
    while (k != 0) {
        if (k & 1) {
            x *= t
            x %= p
        }
        t = (t * t) % p
        k >>= 1
    }
    return x
}

const euler = (a, p) => powmod(a, (p - 1) / 2, p)

const sqrt = (z, p) => {
    if (z >= p) {
        return z
    }

    const e = euler(z, p)
    if (e != 1) {
        z = p - z
    }

    const k = (p - 3) / 4
    const v = powmod(z, k + 1, p)
    return (v <= p / 2) ? v : p - v
}

const sqrt8 = (x) => sqrt(x, 251)

const fetch16 = (x) => fetch(x, 65519)
const fetch8 = (x) => fetch(x, 251)

// the last number can be anything.
const build16 = (x, o) => fetch16((fetch16(x) + o) % 65536 ^ 42703)
const build8 = (x, o) => fetch8((fetch8(x) + o) % 256 ^ 101)
const test8 = (x, o) => ((fetch8(x) + o) % 256)
const testinv8 = (x, o) => sqrt8((256 + x - o) % 256)

const inv8 = (x, o) => sqrt8(((sqrt8(x) ^ 101) + (256 - o)) % 256)

const j = 115; // If you don't want duplicates, either i or j should stay fixed
let i = 0
let invalid = [];
let valid = new Set;
while (i <= 255) { // <-- small fix here!
    let x = build8(i, j); // To test, you can swap i and j here, and run again.
    let y = inv8(x, j)
    let z = test8(i, j)
    let a = testinv8(z, j)
    if (x > 255) {
        invalid.push([ i, j, x ]);
    } else {
        valid.add(x);
        console.log("item ", i, ", ", x, ", ", y, ", ", z, ", ", a)
    }
    i++;
}

console.log("invalid:", JSON.stringify(invalid));
console.log("count of valid:", valid.size);