密码学|实验二 小规模DES

实验内容

实验目的：
通过小规模 DES 的编程实现，理解 DES 的加解密过程。
实验内容：
1．实现小规模 DES 的密钥扩展过程；
2．实现单块明文的 DES 加密过程；
3．实现单块密文的 DES 解密过程。
实验步骤：
1． 对照小规模 DES 算法，编写密钥扩展函数 Key_Extesion(key, key1,key2)。
主密钥输入为 K=11001010，得到轮密钥 K1、K2。
2． 对照小规模 DES 算法，编写加密函数 Ecryption(m, key1，Key2 )。
轮函数定义为 Round_F(T, key[] )，其中两个 S 盒 S1 和 S2 由查表 2-1 和表 2-2
得到。当明文分组输入为 M=01011100，得到的密文应为 C= 11111000。
3. 根据 DES 的结构特点，编写小规模 DES 的解密函数 Decryption( )。
将轮密钥顺序颠倒，利用 Ecryption()函数，将密文分组解密。
当密文分组为 C=1111100 时，解密的明文分组应为 M=01011100。
4． 改变主密钥和明文输入，重复上述过程。
5． 改变置换和 S 盒，重复上述过程。（选做）
实验说明：
1．小规模 DES 的框图如图 2-1，其中轮函数如图 2-2 所示。

实验过程

变换

设计permute(bits,table)P置换，设计S_box(bits,sbox)S盒替代

密钥扩展

定义密钥扩展函数 Key_Extension(key, key1, key2)，输入主密钥 key (8位)，输出两个轮密钥 key1 和 key2 (6位)。
使用主密钥 K=11001010，调用 Key_Extension 函数，得到轮密钥 K1 和 K2。

加密过程

定义加密函数 Encryption(m, key1, key2)，输入明文分组 m (8位) 和两个轮密钥 key1 和 key2，输出密文分组 C。
定义轮函数 Round_F(T, key)，输入4位数据 T 和6位密钥 key，输出4位数据。

解密过程

编写解密函数 Decryption(C, key1, key2)，输入密文分组 C 和两个轮密钥 key1 和 key2，输出明文分组 M。
将轮密钥顺序颠倒，利用 Encryption 函数进行解密。

实验结果

IP = [8,6,4,2,1,3,5,7]
IP_inv = [5,4,6,3,7,2,8,1]
Q = [3,1,4,2]
R = [4,3,1,2]
P2 = [5,7,1,8,4,2]
E = [4,1,2,2,3,4]
P = [3,1,2,4]
P1 = [4,1,7,6,8,2,5,3]
        
S1 = [
    [3, 0, 1, 2],
    [1, 3, 2, 0]
    ]
S2 = [
    [2, 1, 3, 0],
    [3, 0, 2, 1]
    ]

def permute(bits:list,table):
    return [bits[i-1] for i in table]


def s_box(bits:list,sbox):
    row = int(bits[0])
    col = int(str(bits[1]) + str(bits[2]), 2)
    r = sbox[row][col]
    if r == 3:
        return [1,1]
    if r == 2:
        return [1,0]
    if r == 1:
        return [0,1]
    if r == 0:
        return [0,0]

def split_bits(bits):
    mid = len(bits) // 2
    return bits[:mid], bits[mid:]

def xor(a, b):
    return [x ^ y for x, y in zip(a, b)]

def f(t,k):
    """轮函数"""
    t = permute(t,E)
    temp = xor(t,k)
    z1,z2 = split_bits(temp)
    u1 = s_box(z1,S1)
    u2 = s_box(z2,S2)
    return permute(u1+u2,P)

def k_generate(bits):
    bits = permute(bits,P1)
    c0,d0 = split_bits(bits)
    c1 = permute(c0,Q)
    d1 = permute(d0,R)
    key1 = permute(c1 + d1,P2)
    key2 = permute(c0 + d0,P2)
    return key1,key2

def encrypt(M,key1,key2):
    t0,t1 = split_bits(permute(M,IP))
    t2 = xor(f(t1,key1),t0)
    t3 = xor(f(t2,key2),t1)
    c = permute(t3+t2,IP_inv)
    return c

def decrypt(c, key1, key2):
    s = permute(c, IP)
    t3, t2 = split_bits(s)
    t1 = xor(t3, f(t2, key2))
    t0 = xor(t2, f(t1, key1))
    m0 = t0 + t1
    m = permute(m0, IP_inv)
    return m
    
m = list(map(int,input('明文：')))
k = list(map(int,input('密钥：')))
key1,key2 = k_generate(k)
c = encrypt(m,key1,key2)
me = decrypt(c,key1,key2)
c_bits = ''.join(map(str, c))
message = ''.join(map(str, me))
print(f'密文：{c_bits}')
print(f'解密：{message}')

实验总结

优化

使用bin(r)[2:].zfill(2)，优化S盒代替

def s_box(bits, sbox):
    row = int(bits[0])
    col = int(str(bits[1]) + str(bits[2]), 2)
    r = sbox[row][col]
    return [int(bit) for bit in bin(r)[2:].zfill(2)]

总结

实验完成了小规模DES设计，加深了对分组密码Feistel结构的认识
在之前的学习中已经完成了标准DES的实现：https://www.cnblogs.com/luminescence/p/18866999
下一步可以继续从分组密码的明文的分组、加密的工作模式等方面继续优化