这种逆向工程算法是如何工作的？

Question

实际的算法函数是：

output[i] = ( (129 * input[i]) XOR input[i-1]) % 256 //input[-1] = 0

对此有多种解决方案。通常这样做的方式是：

var output = [0, 129, 3, 129, 7, 129, 3, 129, 15, 129, 3, 129, 7, 129, 3, 129];
var outputToInputArray = function(array) {
  var input = [];
  var outputToInput = function(dig, lastInput) {
    var current = dig;

    while(true) {
      if (!((current ^ lastInput) % 129)) {
        return (current ^ lastInput)/129;
      }
      current += 256;
    }
  }

  for(var i = 0; i < output.length; i++) {
    input.push(outputToInput(output[i], i>0 ? input[i-1] : 0));
  }

  return input;
}

console.log(outputToInputArray(output));

但是，我刚刚来了：

output = [0, 129, 3, 129, 7, 129, 3, 129, 15, 129, 3, 129, 7, 129, 3, 129]
var input = [];
for(var i =0; i < output.length; i++) {
    lastInput = input.length < 1 ? 0 : input[i-1];
    input.push(((output[i] ^ lastInput) * 129) % 256);
}
console.log(input);

当被要求反转函数时要遵循的想法是代数反转函数。但是，第二种解决方案似乎以一种在数学上不应该有效的方式简化了反转函数！但它有效！请帮忙！

附：预期输出为 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

Answer 1

注意：写完这个答案后，我通过qxz重新阅读了答案，并且 意识到这里涵盖的所有内容也都包含在 qxz 的答案中。 但我还是决定发布这个，因为略有不同 格式可能对某些人有帮助。

要了解为什么会这样，您所要做的就是计算

y = (129 * x) % 256;  

对于 0 到 255 之间的每个 x。从偶数开始

for ( x = 0; x < 256; x += 2 ) {
    y = (129 * x) % 256; 
    console.log(y);
}

输出是

  0   0
  2   2
  4   4
  6   6
  8   8
 10  10
 12  12
 14  14
... ...

换句话说，当你以 256 为模乘以 129 时，偶数不会改变。

奇数的输出是

  1 129
  3 131
  5 133
  7 135
  9 137
 11 139
... ...
125 253
127 255
129   1
131   3
133   5
... ...

换句话说，乘以 129 模 256 与将 128 加到模 256 的数字相同。因此，当您执行两次时，您会得到原始数字：(x + 128 + 128) % 256 = x

公式的其余部分确实对此没有任何影响。模 256 丢弃第 7 位以上的所有位，保留低 8 位。 XOR 对第 7 位以上的位没有影响，它只是反转一些低 8 位。因此异或和模256之间没有相互作用。异或只影响低8位，模只影响高位。

这意味着在反转计算时，您可以先进行 XOR 以取回低 8 位。然后乘以 129 模 256 或者什么都不做（如果数字是偶数）或者它添加 128 模 256（如果数字是奇数）。无论哪种方式，您都可以取回原始号码。

Answer 2

首先，您的“散列函数”并不是传统意义上的散列函数。散列函数通常接受一个输入（可以是可变大小，例如字符串）并将其转换为固定位数的单个值。这类函数不能真正反转，因为在转换过程中会丢失很多位数据；你不能从 4 位重构 100 位。

您的函数将一个字节列表转换为另一个等长的字节列表。看起来它接受当前输入，通过函数 x => (x*129)%256 运行它，然后 xors 它与之前的输入一起运行。

函数f(x) = (x*129) % 256 是有趣的部分。如果输入是偶数，则输出是相同的数字。如果输入为奇数，则输出为第 7 位（第 127 位）反转的输入。 （尝试自己插入一些值。）因此，f(x) 是它自己的倒数； f(f(x)) == x.

因此，整个“哈希函数”可以这样反转：

• xor 当前哈希值与前一个输入值，或者0 如果是第一个输入值
• 通过f(x) 函数运行结果以在计算值时反转f(x)
• 对每个值重复

... 这就是你最后一个 sn-p 所做的。我不确定第一个。