DES 加密算法实现：Python 代码详解

DES 加密算法实现
from typing import List

# 初始置换表
IP = [58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7]

# 逆置换表
IP_INV = [40, 8, 48, 16, 56, 24, 64, 32,
39, 7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25]

# 扩展置换表
E = [32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1]

# S 盒
SBOX = [
# S1
[
[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
[0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
[4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
[15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]
],
# S2
[
[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
[3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
[0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
[13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]
],
# S3
[
[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
[13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
[13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
[1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]
],
# S4
[
[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
[13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
[10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
[3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]
],
# S5
[
[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
[14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
[4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
[11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]
],
# S6
[
[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
[10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
[9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
[4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]
],
# S7
[
[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
[13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
[1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
[6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]
],
# S8
[
[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
[1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
[7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
[2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]
]
]

# 置换函数 P
P = [16, 7, 20, 21, 29, 12, 28, 17,
1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9,
19, 13, 30, 6, 22, 11, 4, 25]

# 密钥置换 1
PC1 = [57, 49, 41, 33, 25, 17, 9,
1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27,
19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15,
7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29,
21, 13, 5, 28, 20, 12, 4]

# 密钥置换 2
PC2 = [14, 17, 11, 24, 1, 5, 3, 28,
15, 6, 21, 10, 23, 19, 12, 4,
26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40,
51, 45, 33, 48, 44, 49, 39, 56,
34, 53, 46, 42, 50, 36, 29, 32]

# 左移位数表
SHIFT_TABLE = [1, 1, 2, 2, 2, 2, 2, 2,
1, 2, 2, 2, 2, 2, 2, 1]

# 将 64 位的二进制字符串转换为列表形式
def binary_str_to_list(s: str) -> List[int]:
return [int(c) for c in s]

# 将列表形式的二进制字符串转换为字符串形式
def binary_list_to_str(lst: List[int]) -> str:
return ''.join(str(c) for c in lst)

# 将 16 进制字符串转换为列表形式
def hex_str_to_list(s: str) -> List[int]:
return [int(c, 16) for c in s]

# 将列表形式的 16 进制字符串转换为字符串形式
def hex_list_to_str(lst: List[int]) -> str:
return ''.join(hex(c)[2:].zfill(2) for c in lst)

# 将一个字符串转换为二进制字符串（不足 8 位的在前面补 0）
def str_to_binary_str(s: str) -> str:
return ''.join(bin(ord(c))[2:].zfill(8) for c in s)

# 将一个二进制字符串转换为字符串
def binary_str_to_str(s: str) -> str:
return ''.join(chr(int(s[i:i+8], 2)) for i in range(0, len(s), 8))

# 将一个二进制字符串进行异或
def xor(a: str, b: str) -> str:
return ''.join(str(int(x) ^ int(y)) for x, y in zip(a, b))

# 将列表左移 n 位
def left_shift(lst: List[int], n: int) -> List[int]:
return lst[n:] + lst[:n]

# 对数据进行初始置换
def initial_permutation(data: List[int]) -> List[int]:
return [data[i-1] for i in IP]

# 对数据进行逆置换
def inverse_permutation(data: List[int]) -> List[int]:
return [data[i-1] for i in IP_INV]

# 将 64 位密钥进行 PC1 置换
def permuted_choice_1(key: List[int]) -> List[int]:
return [key[i-1] for i in PC1]

# 将 56 位密钥进行 PC2 置换
def permuted_choice_2(key: List[int]) -> List[int]:
return [key[i-1] for i in PC2]

# 对密钥进行循环左移
def key_left_shift(key: List[int], n: int) -> List[int]:
left = key[:28]
right = key[28:]
left = left_shift(left, n)
right = left_shift(right, n)
return left + right

# 将 48 位数据进行扩展置换
def expansion(data: List[int]) -> List[int]:
return [data[i-1] for i in E]

# 将 6 位数据进行 S 盒置换
def sbox(data: List[int], sbox_idx: int) -> List[int]:
row = (data[0] << 1) | data[5]
col = (data[1] << 3) | (data[2] << 2) | (data[3] << 1) | data[4]
val = SBOX[sbox_idx][row][col]
return [int(c) for c in bin(val)[2:].zfill(4)]

# 将 32 位数据进行置换 P
def permutation(data: List[int]) -> List[int]:
return [data[i-1] for i in P]

# 生成子密钥
def generate_subkeys(key: List[int]) -> List[List[int]]:
# 将 64 位密钥进行 PC1 置换
key = permuted_choice_1(key)
# 生成 16 个子密钥
subkeys = []
for i in range(16):
# 将 56 位密钥进行循环左移
key = key_left_shift(key, SHIFT_TABLE[i])
# 将 56 位密钥进行 PC2 置换
subkey = permuted_choice_2(key)
subkeys.append(subkey)
return subkeys

# 加密一个 64 位的数据块
def encrypt_block(data: List[int], subkeys: List[List[int]]) -> List[int]:
# 将 64 位数据进行初始置换
data = initial_permutation(data)
left = data[:32]
right = data[32:]
for i in range(16):
# 将右半部分进行扩展置换，得到 48 位数据
right_expanded = expansion(right)
# 将 48 位数据与子密钥进行异或
subkey = subkeys[i]
right_xor = xor(binary_list_to_str(right_expanded), binary_list_to_str(subkey))
right_xor = binary_str_to_list(right_xor)
# 将 48 位数据进行 S 盒置换，得到 32 位数据
right_sbox = []
for j in range(8):
sbox_data = right_xor[j*6:(j+1)*6]
sbox_result = sbox(sbox_data, j)
right_sbox += sbox_result
# 将 32 位数据进行置换 P
right_permuted = permutation(right_sbox)
# 将左半部分与置换后的右半部分进行异或
left_xor = xor(binary_list_to_str(left), binary_list_to_str(right_permuted))
left_xor = binary_str_to_list(left_xor)
# 更新左右半部分
left = right
right = left_xor
# 将左右半部分交换
left, right = right, left
# 将左右半部分合并
data = left + right
# 将数据进行逆置换
data = inverse_permutation(data)
return data

# 加密一个字符串
def encrypt(s: str, key: str) -> str:
# 将字符串转换为二进制字符串
s_binary = str_to_binary_str(s)
# 将密钥转换为二进制字符串
key_binary = str_to_binary_str(key)
# 将二进制字符串转换为列表形式
s_list = binary_str_to_list(s_binary)
key_list = binary_str_to_list(key_binary)
# 生成子密钥
subkeys = generate_subkeys(key_list)
# 对数据进行分块，每块 64 位
blocks = [s_list[i:i+64] for i in range(0, len(s_list), 64)]
# 对每个块进行加密
encrypted_blocks = [encrypt_block(block, subkeys) for block in blocks]
# 将加密后的块合并为一个列表
encrypted_list = [c for block in encrypted_blocks for c in block]
# 将加密后的列表转换为二进制字符串
encrypted_binary = binary_list_to_str(encrypted_list)
# 将二进制字符串转换为 16 进制字符串
encrypted_hex = hex(int(encrypted_binary, 2))[2:].zfill(len(encrypted_binary) // 4)
return encrypted_hex

# 解密一个字符串
def decrypt(s: str, key: str) -> str:
# 将 16 进制字符串转换为二进制字符串
s_binary = bin(int(s, 16))[2:].zfill(len(s) * 4)
# 将密钥转换为二进制字符串
key_binary = str_to_binary_str(key)
# 将二进制字符串转换为列表形式
s_list = binary_str_to_list(s_binary)
key_list = binary_str_to_list(key_binary)
# 生成子密钥
subkeys = generate_subkeys(key_list)
# 对数据进行分块，每块 64 位
blocks = [s_list[i:i+64] for i in range(0, len(s_list), 64)]
# 对每个块进行解密
decrypted_blocks = [encrypt_block(block, subkeys[::-1]) for block in blocks]
# 将解密后的块合并为一个列表
decrypted_list = [c for block in decrypted_blocks for c in block]
# 将解密后的列表转换为二进制字符串
decrypted_binary = binary_list_to_str(decrypted_list)
# 将二进制字符串转换为字符串
decrypted_str = binary_str_to_str(decrypted_binary)
return decrypted_str

# 测试
key = '1234567890ABCDEF'
s = 'Hello world!'
encrypted_hex = encrypt(s, key)
print(f'加密后的字符串：{encrypted_hex}')
decrypted_str = decrypt(encrypted_hex, key)
print(f'解密后的字符串：{decrypted_str}')

代码说明

1. 基础函数

• binary_str_to_list(s: str) -> List[int]：将 64 位的二进制字符串转换为列表形式。
• binary_list_to_str(lst: List[int]) -> str：将列表形式的二进制字符串转换为字符串形式。
• hex_str_to_list(s: str) -> List[int]：将 16 进制字符串转换为列表形式。
• hex_list_to_str(lst: List[int]) -> str：将列表形式的 16 进制字符串转换为字符串形式。
• str_to_binary_str(s: str) -> str：将一个字符串转换为二进制字符串（不足 8 位的在前面补 0）。
• binary_str_to_str(s: str) -> str：将一个二进制字符串转换为字符串。
• xor(a: str, b: str) -> str：将一个二进制字符串进行异或。
• left_shift(lst: List[int], n: int) -> List[int]：将列表左移 n 位。

2. DES 算法核心函数

• initial_permutation(data: List[int]) -> List[int]：对数据进行初始置换。
• inverse_permutation(data: List[int]) -> List[int]：对数据进行逆置换。
• permuted_choice_1(key: List[int]) -> List[int]：将 64 位密钥进行 PC1 置换。
• permuted_choice_2(key: List[int]) -> List[int]：将 56 位密钥进行 PC2 置换。
• key_left_shift(key: List[int], n: int) -> List[int]：对密钥进行循环左移。
• expansion(data: List[int]) -> List[int]：将 48 位数据进行扩展置换。
• sbox(data: List[int], sbox_idx: int) -> List[int]：将 6 位数据进行 S 盒置换。
• permutation(data: List[int]) -> List[int]：将 32 位数据进行置换 P。
• generate_subkeys(key: List[int]) -> List[List[int]]：生成子密钥。
• encrypt_block(data: List[int], subkeys: List[List[int]]) -> List[int]：加密一个 64 位的数据块。

3. 加密和解密函数

• encrypt(s: str, key: str) -> str：加密一个字符串。
• decrypt(s: str, key: str) -> str：解密一个字符串。

测试

代码最后部分是测试代码，展示了如何使用 encrypt 函数加密字符串，以及使用 decrypt 函数解密字符串。

总结

本文详细介绍了 DES 加密算法的 Python 代码实现，并对每个函数的功能进行了说明。希望能够帮助你更好地理解 DES 算法，并将其应用于实际的项目中。