javascript - 反转 DECRYPT 算法

Question

我很难逆转这个算法:

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:

暂停一下并思考一下算法后，我理解了问题，并且比我想象的要容易:

输出[decrypt_key[k]] = word_to_decrypt[m + k]

更改此设置将恢复算法，从而解决问题。

Answer 1

这是一个简单的排列密码。本质上，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 个 block 。

您可以将其视为基于“ key ”对单词进行打乱，“ key ”告诉您它是如何打乱的。

例如，

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

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

另一个术语是称其为随 secret 码。它以一种非常可预测的方式打乱所有单词。

只要您知道 decypher_key 和密码类型，您就可以很容易地恢复数据，就像您可以使用一副纸牌一样，如果您确切地知道它们是如何洗牌的(因为它不是真正随机)。

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

<小时/>

Lua代码:

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]