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：

暂停并稍微考虑算法之后，我理解了问题并且比我想象的更容易：

output[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]]

基本上将索引加入到＃34;加密＆＃34;并以26块的方式排列它的单词。

你可以认为它只是基于＆＃34;键＆＃34;来拼写单词，它会告诉你它是如何被扰乱的。

e.g，

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

表示第一个单词（位置0）放在位置16，位置16的单词放在位置9。

另一个术语是将其称为shuffle密码。它以一种非常可预测的方式改变了所有的词语。

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

要制作反向密码，您必须创建相反的密钥。如果位置0变为16，那么这意味着位置16必须转到0.对阵列中的每个数字执行此操作并形成一个名为＆＃39; encrypt_key＆＃39;然后你就可以用你给出的代码加密可以正确解密的单词了。

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]

Answer 2

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

该算法看起来是对称的，所以一旦你理解了它们的键是什么（看起来它只是根据键将字符串中的字符混乱），那么你就可以派生出加密函数。

反转DECRYPT算法

2 个答案: