为什么这个Python代码解密不起作用？

Question

这是我的代码

from PIL import Image
import numpy as np
import json

def chaotic_encrypt_image(image_path, shuffled_x, ITERmax):
    image = Image.open(image_path).convert('L')
    image = image.resize((150, 150))
    pixels = np.array(image)

    M, N = image.size

    encrypted_pixels = np.copy(pixels)

    alpha_values = [[] for _ in range(M)]
    beta_values = [[] for _ in range(N)]

    for i in range(ITERmax):
        xor_key = shuffled_x[i % len(shuffled_x)]

        for i in range(M):
            alpha_i = np.sum(encrypted_pixels[i]) % 2
            alpha_values[i].append(int(alpha_i))

            if alpha_i == 0:
                encrypted_pixels[i] = np.roll(encrypted_pixels[i], xor_key)
            else:
                encrypted_pixels[i] = np.roll(encrypted_pixels[i], -xor_key)

        for j in range(N):
            beta_j = np.sum(encrypted_pixels[:, j]) % 2
            beta_values[j].append(int(beta_j))

            if beta_j == 0:
                encrypted_pixels[:, j] = np.roll(encrypted_pixels[:, j], xor_key)
            else:
                encrypted_pixels[:, j] = np.roll(encrypted_pixels[:, j], -xor_key)

    encrypted_image = Image.fromarray(encrypted_pixels)
    encrypted_image.save('encrypted_image_test.jpg')

    bitwise_key = {
        'alpha_values': alpha_values,
        'beta_values': beta_values
    }

    with open('bitwise_key.json', 'w') as f:
        json.dump(bitwise_key, f)

def chaotic_decrypt_image(image_path, shuffled_x, ITERmax):
    image = Image.open(image_path).convert('L')
    pixels = np.array(image)

    M, N = image.size

    decrypted_pixels = np.copy(pixels)

    with open('bitwise_key.json', 'r') as f:
        bitwise_key = json.load(f)

    alpha_values = bitwise_key['alpha_values']
    beta_values = bitwise_key['beta_values']

    shuffled_x = shuffled_x[::-1]

    for i in range(ITERmax):
        xor_key = shuffled_x[i % len(shuffled_x)]

        for j in range(N):
            beta_j = beta_values[j][i]

            if beta_j == 0:
                decrypted_pixels[:, j] = np.roll(decrypted_pixels[:, j], xor_key)
            else:
                decrypted_pixels[:, j] = np.roll(decrypted_pixels[:, j], -xor_key)

        for k in range(M):
            alpha_k = alpha_values[k][i]

            if alpha_k == 0:
                decrypted_pixels[k] = np.roll(decrypted_pixels[k], xor_key)
            else:
                decrypted_pixels[k] = np.roll(decrypted_pixels[k], -xor_key)

    decrypted_image = Image.fromarray(decrypted_pixels)
    decrypted_image.save('decrypted_image_test.jpg')

def main():
    with open('shuffled.json', 'r') as f:
        shuffled_data = json.load(f)
    shuffled_x = shuffled_data['shuffled_x']

    image_path = 'image.jpg'
    ITERmax = 150

    chaotic_encrypt_image(image_path, shuffled_x, ITERmax)
    chaotic_decrypt_image('encrypted_image_test.jpg', shuffled_x, ITERmax)

if __name__ == "__main__":
    main()

使用 150*150 lena 图像，这就是 shuffled.json 的样子：

{“洗牌_x”：[ 79、 34、 31、 32、 129、 11、 81、 3、 54、 59、 106、 7、 112、 5、 60、 78、 20、 23、 18、 21、 141、 19、 145、 119、 24、 83、 78、 102、 65、 108、 113、 135、 36、 0, 76、 39、 28、 33、 134、 131、 136、 70、 144、 22、 117、 116、 17、 95、 69、 49、 50、 28、 114、 132、 58、 105、 6、 57、 25、 107、 35、 86、 4、 13、 89、 15、 122、 48、 45、 71、 118、 42、 16、 121、 74、 104、 88、 10、 128、 133、 7、 14、 82、 75、 109、 139、 61、 12、 1、 2、 90、 143、 148、 97、 73、 68、 67、 41、 142、 99、 125、 80、 110、 11、 100, 130、 52、 107、 87、 55、 77、 103、 137、 101、 64、 140、 66、 92、 147、 46、 120、 96、 43、 44、 124、 29、 38、 127、 111、 37、 61、 56、 40、 62、 30、 27、 53、 8、 26、 85、 115、 72、 98、 91、 94、 93、 123、 47、 146、 149 ]}

它必须被完美解密，但它只是被完全错误地转移了。

加密部分工作正常，所以我尝试了一些解密部分的嫌疑

检查是否使用了相同的 XOR 计算变量

加密部分的最后一次异或计算和解密部分的第一次异或计算必须相同。
在对图像进行一些滚动之后，当for循环的i int发生变化时，它必须按照相同的原理工作。

检查代码的两部分是否使用相同的 alpha_value 和 beta_value。

必须全部颠倒过来，正如您可以在代码中了解的那样。

解密部分的算法似乎完全混乱，但正如你所看到的，它似乎可以进入正确的解密方式。找到加密方法可能很容易。

问题在于 alpha_i 和 beta_j 在解密时无法逆转。所以我采用了将alpha和beta值保存为第二个密钥的方法，并尝试将alpha和beta的值进行解密。

加密就像：

xor_key 由 shuffled_x 数组生成
使用 xor_key 逐行滚动像素 2-1.找到 alpha 值并用 alpha 值设置方向 2-2.使用 xor_key 进行随机播放
使用 xor_key 逐行滚动像素 3-1. 〜3-2。 （类似）
进行异或计算
使用for循环，执行2到3，直到循环i达到ITERmax

所以尝试反向可能会有所帮助

提前致谢。

Answer 1

这实现了我评论中的修复。我向后运行第二个外循环，然后翻转卷的方向。这有效。

请允许我发表一些哲学评论。首先，旋转 150 次是愚蠢的。做两次（甚至一次）就足够了。其次，您使用的是 JPEG，它不是无损协议。生成的 JPEG 与原始图像“不”是逐像素相同的，因为压缩过程将完全不同。一旦你扰乱像素，图像就无法轻易压缩，因此你将丢失大量信息。

from PIL import Image
import numpy as np
import json

def chaotic_encrypt_image(image_path, shuffled_x, ITERmax):
    image = Image.open(image_path).convert('L')
    image = image.resize((150, 150))
    pixels = np.array(image)

    M, N = image.size

    encrypted_pixels = np.copy(pixels)

    alpha_values = [[] for _ in range(M)]
    beta_values = [[] for _ in range(N)]

    for i in range(ITERmax):
        xor_key = shuffled_x[i % len(shuffled_x)]

        for i in range(M):
            alpha_i = np.sum(encrypted_pixels[i]) % 2
            alpha_values[i].append(int(alpha_i))

            if alpha_i == 0:
                encrypted_pixels[i] = np.roll(encrypted_pixels[i], xor_key)
            else:
                encrypted_pixels[i] = np.roll(encrypted_pixels[i], -xor_key)

        for j in range(N):
            beta_j = np.sum(encrypted_pixels[:, j]) % 2
            beta_values[j].append(int(beta_j))

            if beta_j == 0:
                encrypted_pixels[:, j] = np.roll(encrypted_pixels[:, j], xor_key)
            else:
                encrypted_pixels[:, j] = np.roll(encrypted_pixels[:, j], -xor_key)

    encrypted_image = Image.fromarray(encrypted_pixels)
    encrypted_image.save('encrypted_image_test.jpg')

    bitwise_key = {
        'alpha_values': alpha_values,
        'beta_values': beta_values
    }

    with open('bitwise_key.json', 'w') as f:
        json.dump(bitwise_key, f)

def chaotic_decrypt_image(image_path, shuffled_x, ITERmax):
    image = Image.open(image_path).convert('L')
    pixels = np.array(image)

    M, N = image.size

    decrypted_pixels = np.copy(pixels)

    with open('bitwise_key.json', 'r') as f:
        bitwise_key = json.load(f)

    alpha_values = bitwise_key['alpha_values']
    beta_values = bitwise_key['beta_values']

    for i in range(ITERmax-1,-1,-1):
        xor_key = shuffled_x[i % len(shuffled_x)]

        for j in range(N):
            beta_j = beta_values[j][i]

            if beta_j:
                decrypted_pixels[:, j] = np.roll(decrypted_pixels[:, j], xor_key)
            else:
                decrypted_pixels[:, j] = np.roll(decrypted_pixels[:, j], -xor_key)

        for k in range(M):
            alpha_k = alpha_values[k][i]

            if alpha_k:
                decrypted_pixels[k] = np.roll(decrypted_pixels[k], xor_key)
            else:
                decrypted_pixels[k] = np.roll(decrypted_pixels[k], -xor_key)

    decrypted_image = Image.fromarray(decrypted_pixels)
    decrypted_image.save('decrypted_image_test.jpg')

def main():
    with open('x.json', 'r') as f:
        shuffled_data = json.load(f)
    shuffled_x = shuffled_data['shuffled_x']

    image_path = 'image.jpg'
    ITERmax = 150

    chaotic_encrypt_image(image_path, shuffled_x, ITERmax)
    chaotic_decrypt_image('encrypted_image_test.jpg', shuffled_x, ITERmax)

if __name__ == "__main__":
    main()

跟进您可以使用以下方法稍微简化代码：

        for i in range(M):
            alpha_i = np.sum(encrypted_pixels[i]) % 2
            alpha_values[i].append(int(alpha_i))
            encrypted_pixels[i] = np.roll(encrypted_pixels[i], xor_key if not alpha_i else -xor_key)

        for j in range(N):
            beta_j = np.sum(encrypted_pixels[:, j]) % 2
            beta_values[j].append(int(beta_j))
            encrypted_pixels[:, j] = np.roll(encrypted_pixels[:, j], xor_key if not beta_j else -xor_key)
...
        for j in range(N):
            beta_j = beta_values[j][i]
            decrypted_pixels[:, j] = np.roll(decrypted_pixels[:, j], xor_key if beta_j else -xor_key)

        for k in range(M):
            alpha_k = alpha_values[k][i]
            decrypted_pixels[k] = np.roll(decrypted_pixels[k], xor_key if alpha_k else -xor_key)

基于像素总和进行左/右决策只会无缘无故地增加计算时间。您不妨选择一个 0 到 1 之间的随机数。