0

我很难扭转这个算法：

decrypt_algorithm = function (text) {
  var parser = new TextParser(text);
  var decrypt_key = [16, 19, 17, 7, 20, 23, 13, 1, 24, 15, 6, 12, 0, 18, 21, 2, 9, 14, 3, 10, 5, 25, 8, 4, 22, 11];
  var text_size = parser.getSize();
  var text_size_without_last_part = text_size - 26;
  var output = [];
  if (text_size_without_last_part > 0) {
      for (var m = 0; m < text_size_without_last_part; m += 26) {
          var word_to_decrypt = [];
          for (var k = 0; k < 26; k++) {
              word_to_decrypt[k] = parser.readNextChar()
          }
          for (var k = 0; k < 26; k++) {
              output[m + k] = word_to_decrypt[decrypt_key[k]]
          }
      }
      var parser_position = parser.getPosition();
      var last_part_size = text_size - text_size_without_last_part - 1;
      if (last_part_text > 0) {
          for (var k = 0; k < last_part_size; k++) {
              output[text_size_without_last_part + k] = parser.readNextChar()
          }
      }
  }
  return output;
};

我没有任何逆向工程知识，所以如果你能指出一些解释如何“逆向”函数的资源，那将非常有帮助。

我不需要确切的代码作为答案，但是我非常感谢一些关于如何自己逆向工程的指南。

编辑1：

稍作停顿，稍微思考了一下算法后，我明白了这个问题，而且比我想象的要容易：

output[decrypt_key[k]] = word_to_decrypt[m + k]

改变这将恢复算法，解决问题。

4

2 回答 2

4

这是一个简单的置换密码。本质上decrypt_key是用于重新排列输出

output[m + k] = word_to_decrypt[decrypt_key[k]]


decrypt_key = [16, 19, 17, 7, 20, 23, 13, 1, 24, 15, 6, 12, 0, 18, 21, 2, 9, 14, 3, 10, 5, 25, 8, 4, 22, 11];

或者，重新排列：

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16 16 17 18 19 20 21 22 23 24 25

编码

word_to_decrypt[decrypt_key[k]]

本质上将索引放入被“加密”的代码中，并将其单词排列成 26 个块。

你可以把它想象成只是根据“key”来打乱单词，它告诉你它是如何被打乱的。

例如，

decrypt_key[0] -> 16
decrypt_key[16] -> 9

这意味着第一个单词（位置 0）被放在位置 16，位置 16 的单词被放在位置 9。

另一个术语是称它为洗牌密码。它打乱了所有的单词，但是以一种非常可预测的方式。

只要你知道decypher_key密码的类型和类型，你就可以很容易地恢复数据，就像你知道一副纸牌是如何洗牌的一样（因为它不是真正随机的）。

要制作逆密码，您必须创建相反的密钥。如果位置 0 变为 16，则意味着位置 16 必须变为 0。对数组中的每个数字执行此操作并形成一个名为“encrypt_key”的新数组，然后您就可以加密可以正确解密的单词你给的代码。

卢阿代码：

function printarray(arr) local s = '[' for k,v in pairs(arr) do s = s..tostring(v)..', '  end s = s:sub(1,-3)..']' return s end
function permute(arr, key) local newarr = {}; for i = 1, #key do newarr[i] = arr[key[i]] end return newarr end

letters = {'a','b','c','d','e'};
key = {5, 1, 3, 4, 2};
invkey = {}
newletters = permute(letters, key)
print('input:  '..printarray(letters))
print('key:    '..printarray(key))
print('output: '..printarray(newletters))


for i = 1, #key do
    for j = 1, #key do
        if i == key[j] then
            invkey[i] = j;
            break;
        end
    end
end;

newletters2 = permute(newletters, invkey)
print('\nInverse Permutation')
print('input:  '..printarray(newletters))
print('key:    '..printarray(invkey))
print('output: '..printarray(newletters2))

输出：

input:  [a, b, c, d, e]
key:    [5, 1, 3, 4, 2]
output: [e, a, c, d, b]

Inverse Permutation
input:  [e, a, c, d, b]
key:    [2, 5, 3, 4, 1]
output: [a, b, c, d, e]
于 2012-11-14T01:48:15.130 回答
2

您无需对其进行逆向工程：您已经拥有 JavaScript 源代码。该算法看起来很简单（只有两个嵌套循环） - 只需使用调试器单步执行它就可以揭示“关键”与任何给定输入的关系。

该算法看起来是对称的，所以一旦你了解了它们的密钥的作用（看起来它只是根据密钥在字符串中随机排列字符），那么你就可以推导出加密函数。

于 2012-11-14T01:37:13.657 回答