如何在Python IDEA加密代码中让crypt函数遍历使用52个密钥？

核心问题分析 #

你的代码存在以下关键问题，导致无法正确遍历52个子密钥并得到预期结果：

1. 密钥索引未递增：crypt函数的8轮循环中始终使用固定的keys[0]至keys[5]，未随轮次推进使用后续子密钥。每轮需用6个连续子密钥，8轮共48个，最后还有4个用于输出变换。
2. 循环变量冲突：外层循环用i作为轮次变量，内层又用i遍历数组，导致外层循环的i被覆盖，轮次无法正常推进。
3. 错误数值转换：将"10000"（对应65536，IDEA中代表-1 mod 65537）强制转为"0000"，破坏了算法的数学逻辑。
4. 缺失输出变换步骤：IDEA在8轮迭代后需执行输出变换，使用最后4个子密钥，你的代码直接返回最后一轮结果，缺少这一步。

修正后的代码 #

import random

def bit_number(bit):
    return hex(random.randint(2 ** (bit - 1), 2 ** bit - 1))[2:].zfill(bit // 4)

def separate(mas):
    return [mas[i:i + 4].zfill(4) for i in range(0, len(mas), 4)]

def hex_mod(val, mod):
    result = hex(val % mod)[2:].zfill(4)
    # IDEA中0对应65536（mod 65537），直接返回"10000"即可
    return result if result != "0000" else "10000"

def shift(num):
    bin_number = bin(int(num, 16))[2:].zfill(128)
    shifted_left_bin = bin_number[25:] + bin_number[:25]
    shifted_left_hex = hex(int(shifted_left_bin, 2))[2:].zfill(32)
    return shifted_left_hex

def key_gen(key):
    keys = []
    key_shift = key
    for _ in range(8):
        keys.extend(separate(key_shift))
        key_shift = shift(key_shift)
    return keys[:52]

def crypt(message, keys):
    current_msg = message.copy()
    key_idx = 0
    
    # 8轮迭代，每轮使用6个子密钥
    for _ in range(8):
        # 第一轮变换
        a0 = hex_mod(int(current_msg[0], 16) * int(keys[key_idx], 16), 65537)
        a1 = hex_mod(int(current_msg[1], 16) + int(keys[key_idx+1], 16), 65536)
        a2 = hex_mod(int(current_msg[2], 16) + int(keys[key_idx+2], 16), 65536)
        a3 = hex_mod(int(current_msg[3], 16) * int(keys[key_idx+3], 16), 65537)
        
        # 第二轮变换
        a4 = hex_mod(int(a0, 16) ^ int(a2, 16), 65536)
        a5 = hex_mod(int(a1, 16) ^ int(a3, 16), 65536)
        
        # 第三轮变换
        a6 = hex_mod(int(a4, 16) * int(keys[key_idx+4], 16), 65537)
        a7 = hex_mod(int(a5, 16) + int(a6, 16), 65536)
        a8 = hex_mod(int(a7, 16) * int(keys[key_idx+5], 16), 65537)
        a9 = hex_mod(int(a6, 16) + int(a8, 16), 65536)
        
        # 第四轮变换（生成下一轮输入）
        current_msg[0] = hex_mod(int(a0, 16) ^ int(a8, 16), 65536)
        current_msg[1] = hex_mod(int(a2, 16) ^ int(a8, 16), 65536)
        current_msg[2] = hex_mod(int(a1, 16) ^ int(a9, 16), 65536)
        current_msg[3] = hex_mod(int(a3, 16) ^ int(a9, 16), 65536)
        
        # 更新密钥索引
        key_idx += 6
    
    # 输出变换，使用最后4个子密钥
    output = [
        hex_mod(int(current_msg[0], 16) * int(keys[48], 16), 65537),
        hex_mod(int(current_msg[1], 16) + int(keys[49], 16), 65536),
        hex_mod(int(current_msg[2], 16) + int(keys[50], 16), 65536),
        hex_mod(int(current_msg[3], 16) * int(keys[51], 16), 65537)
    ]
    
    return output

# 测试代码
x = bit_number(64)
z = bit_number(128)
keys = key_gen(z)
print("原始密钥（128位）:", z)
message = separate(x)
print("原始消息（分块后）:", message)
ciphertext = crypt(message, keys)
print("加密结果:", ciphertext)

关键修复点说明 #

• 密钥索引管理：新增key_idx变量，每轮后递增6，确保每轮使用正确的连续子密钥。
• 循环变量修正：外层循环改用_作为变量，避免与内层循环冲突。
• 移除错误转换：删除将"10000"转为"0000"的代码，保留IDEA算法对模65537的正确数值表示。
• 添加输出变换：8轮迭代后，使用最后4个子密钥执行输出变换，完成完整加密流程。

内容的提问来源于stack exchange，提问作者Esta ODonnell