DES对64位的明文分组进行操作。通过一个初始置换将明文分组分成左半部分和右半部分各32位长。然后进行16轮完全相同的运算这些运算被称为函数在运算过程中数据与密钥结合。经过16轮后左、右半部分合在一起经过一个末置换初始置换的逆置换这样该算法就完成了。写个Python程序

实现DES加密算法：

# 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)
        # 将左半部分与置换后的