javascript - 解密和加密算法很时髦

Question

我为自定义加密和解密算法做了一个小脚本，它基于凯撒密码和转录密码。
首先有一点背景来解释它应该如何工作。假设您要在发送前加密一条消息。您对其应用凯撒密码，即将字母表中的每个字母向右移动 3 个位置。然后，您获取该加密文本并按您的 key 具有的字母数将其划分为多个部分。假设您的消息有 n字母，你的 key 有m字母。那么你的消息应该被分解为n/m m 中的每一个部分(四舍五入或天花板)字母。如果消息长度不能被 key 中的字母数整除，则必须用字母 A 填充缺失的字母.然后由键给出，您根据字母表中与列号对应的特定键字母的位置转置列。因此，如果您的 key 是 LEAK ，则必须根据以下位置对列进行转置:3241 , 因为 1234对应于 AEKL (按字母顺序排序)。然后这个转置矩阵被连接回相应的字符串，然后可以发送。解密基本上是按顺序颠倒的相同过程→您收到一条消息，并且您知道 key 。您将其打包成列，然后转置列以对应于 key 中字母的字母顺序，将其连接回来，然后运行反向凯撒密码(将字母在字母表中向左移动 3 个位置)。你可能会得到一些 X最后的字母，这实际上并不重要。
现在我的问题是:我为它写了一个小的 Javascript 程序，它实际上是一个模块，我也有一个测试脚本来看看它是如何工作的。但它不能正确工作。换位错误，导致破译文本格式错误。我知道解密的文本，因为我在编写脚本之前手动完成了这个算法，并且我知道它应该有的结果。
这是模块:

module.exports = {
    decrypt: (message, key) => {
        if(message.length % key.length != 0) {
            throw new Error(`Lenght of message is not divisible by lenght of the key! ${message.length} is not divisible by ${key.length}!`);
        }
        
        let key_array_unsorted = key.split('');
        let key_array_sorted = key.split('').sort();

        let message_matrix = [];
        for(i = 0; i < message.length / key.length; ++i) {
            let quartet = [];

            for(j = 0; j < key.length; ++j) {
                quartet.push(message.charAt(i*key.length + j));
            }

            message_matrix.push(quartet);
        }

        let message_matrix_shuffled = [];
        message_matrix.forEach(quartet => {
            let quartet_shuffled = [];

            for(i = 0; i < key.length; ++i) {
                for(j = 0; j < key.length; ++j) {
                    if(key_array_unsorted[i] == key_array_sorted[j]) {
                        quartet_shuffled.push(quartet[j]);
                    }
                }
            }

            message_matrix_shuffled.push(quartet_shuffled);
        });

        let message_quartets = [];
        message_matrix_shuffled.forEach(quartet => {message_quartets.push(quartet.join(''))});

        let message_caesar = message_quartets.join('');

        let message_deciphered = "";
        for(i = 0; i < message_caesar.length; ++i) {
            let charcode = message_caesar.charCodeAt(i);
            let alphanum = charcode - 65;

            let alphanum_new = (alphanum + 23) % 26;
            let charcode_new = alphanum_new + 65;

            message_deciphered += String.fromCharCode(charcode_new);
        }

        return message_deciphered;
    },

    encrypt: (message, key) => {
        let message_caesar = "";

        for(i = 0; i < message.length; ++i) {
            let charcode = message.charCodeAt(i);
            let alphanum = charcode - 65;

            let alphanum_new = (alphanum + 3) % 26;
            let charcode_new = alphanum_new + 65;

            message_caesar += String.fromCharCode(charcode_new);
        }

        for(i = 0; i <= Math.ceil(message_caesar.length / key.length) * key.length - message_caesar.length; ++i) {
            message_caesar += "A";
        }

        let key_array_unsorted = key.split('');
        let key_array_sorted = key.split('').sort();

        let message_matrix = [];
        for(i = 0; i < message_caesar.length / key.length; ++i) {
            let quartet = [];

            for(j = 0; j < key.length; ++j) {
                quartet.push(message_caesar.charAt(i*key.length + j));
            }

            message_matrix.push(quartet);
        }

        let message_matrix_shuffled = [];
        message_matrix.forEach(quartet => {
            let quartet_shuffled = [];

            for(i = 0; i < key.length; ++i) {
                for(j = 0; j < key.length; ++j) {
                    if(key_array_sorted[i] == key_array_unsorted[j]) {
                        quartet_shuffled.push(quartet[j]);
                    }
                }
            }

            message_matrix_shuffled.push(quartet_shuffled);
        });

        let message_quartets = [];
        message_matrix_shuffled.forEach(quartet => {message_quartets.push(quartet.join(''))});

        let message_ciphered = message_quartets.join('');
        return message_ciphered;
    }
}

这是测试脚本:

const cipher = require('./cipher');

let message = "HGYRDGQCREGLDYQROXRHABAK";
let key = "OMYL";

console.log(`Received message: ${message}`);
console.log(`Known passphrase: ${key}`);

let message_deciphered = cipher.decrypt(message, key);
console.log(`Deciphered message: ${message_deciphered}`);

let message_encrypted = cipher.encrypt(message_deciphered, key);
console.log(`Control encryption: ${message_encrypted}`);

模块和测试脚本在同一个文件夹中。
输出应该是这样的:

Received message: HGYRDGQCREGLDYQROXRHABAK
Known passphrase: OMYL
Deciphered message: ODEVZDANIBODOVANEULOHYXX
Control encryption: HGYRDGQCREGLDYQROXRHABAK

这是当前输出:

Received message: HGYRDGQCREGLDYQROXRHABAK
Known passphrase: OMYL
Deciphered message: VDOENDZADBIONVOAOUELXYHX
Control encryption: HGYRDGQCREGLDYQROXRHABAK

现在，我确定 key 的字母排序正确，这不是导致错误转录的原因，我实际上查找了正确排序的 key 字母，没关系。 OMYL实际上确实正确排序到 LMOY .
问题必须在转录本身中，它与键的字母顺序不对应。问题是，由于某种原因，我无法发现错误，如果有的话。我猜 Javascript 并不是用于此类事情的真正好语言，但它相当容易并且不需要编译。我想做的就是让自己成为一个小工具或工具，为我的作业快速求解，我在星期一得到了它，我已经知道那个作业的主题，就是那个密码。
也许我做错了，也许我实际上不应该使用要比较的关键字母，而是根据关键字母的字母顺序(当然还有步骤的顺序 - 加密)为转录构建一种随机映射或解密)。不幸的是，我不知道该怎么做:(

Answer 1

根据聊天中OP给出的算法，码字排序错误
将已排序序列与未排序序列进行比较，而不是其他方式
替换 key_array_unsorted[i] == key_array_sorted[j]与 key_array_sorted[i] == key_array_unsorted[j]