共计 2730 个字符，预计需要花费 7 分钟才能阅读完成。
DES(Data Encryption Standard) 采用 64 位的分组长度和 56 位的密钥长度。它将 64 位的输入经过一系列变换得到 64 为的输出。解密使用相同的步骤和相同的密钥，唯一不同的是密钥顺序与加密过程相反。
DES 加密：
该算法的输入有需要加密的明文和加密使用的密钥，二者长度都为 64 位。其中密钥的第 8,16,24,32,40,48,56,64 位为奇偶校验位。
1、明文的处理
将明文读入程序并将其化为二进制串
def inputText(filename):
with open(filename,’r’)as f:
text = f.read()
text = text.split(‘\n’)
text = [eval(x) for x in text]
text = [‘{:08b}’.format(x) for x in text]
text = ”.join(text)
return text
对明文进行 IP 置换，并划分为左右两个子串
def IP_Transposition(plaintext):
LR = []
for i in IP:
LR.append(int(plaintext[i-1]))
L = LR[:32]
R = LR[32:]
return L,R
2、对密钥的处理
将密钥读入程序并以二进制串的形式存储
对密钥进行 PC- 1 置换，并划分为两个子串
#密钥置换
def Key_Transposition(key):
CD = []
for i in PC_1:
CD.append(int(key[i-1]))
C = CD[:28]
D = CD[28:]
return C,D
在生成迭代所需要的密钥之前需要对密钥进行置换压缩
#密钥压缩
def Key_Compress(C,D):
key = C+D
new_key = []
for i in PC_2:
new_key.append(key[i-1])
return new_key
生成 DES 每轮迭代所需要的子密钥，以便加密解密时直接使用
def generateKset(key):
key = inputKey(key)
C,D = Key_Transposition(key)
K = []
for i in LeftRotate:
C = Key_LeftRotate(C,i)
C = Key_LeftRotate(D,i)
K.append(Key_Compress(C,D))
return K
3、F 函数
在每轮变换中，整个过程可以用以下公式表示：
$$
L_i = R_{i-1}
$$
$$
R_i = L_{i-1}\bigoplus F(R_{i-1},K_i)
$$
其中轮密钥 Ki 长 48 位,R 长 32 位，首先将 R 置换扩展为 48 位, 这 48 位与 Ki 异或，得到的结果用替代函数作用产生 32 位的输出。这 32 位的输出经 P 置换后与 L 异或得到新的 R
代替函数由 8 个 S 盒来组成，每个 S 盒都有 6 位的输入和 4 位的输出。对每个 S 盒，输入的第一位和最后一位组成一个 2 位的二进制数，用来选择 S 盒 4 行替代值中的一行，中间 4 位用来选择 16 列中的某一列。
#明文 R 扩展为 48 位
def R_expand(R):
new_R = []
for i in E:
new_R.append(R[i-1])
return new_R
# 将两列表元素异或
def xor(input1,input2):
xor_result = []
for i in range(0,len(input1)):
xor_result.append(int(input1[i])^int(input2[i]))
return xor_result
# 将异或的结果进行 S 盒代替
def S_Substitution(xor_result):
s_result = []
for i in range(0,8):
tmp = xor_result[i*6:i*6+5]
row = tmp[0]*2+tmp[-1]
col = tmp[1]*8+tmp[2]*4+tmp[3]*2+tmp[4]
s_result.append(‘{:04b}’.format(S[i][row][col]))
s_result = ”.join(s_result)
return s_result
#F 函数
def F(R,K):
new_R = R_expand(R)
R_Kxor= xor(new_R,K)
s_result = S_Substitution(R_Kxor)
p_result = P_Transposition(s_result)
return p_result
# 将 S 盒代替的结果进行 P 置换
def P_Transposition(s_result):
p_result = []
for i in P:
p_result.append(int(s_result[i-1]))
return p_result
4、加密过程
DES 加密需要经过 16 轮迭代，前 15 轮迭代每次结束需要交换 L 和 R，第 16 次不交换
def DES_encrypt(filename,key,outputFile):
#从文件中读取明文
plaintext = inputText(filename)
#将明文进行置换分离
L,R = IP_Transposition(plaintext)
#生成 Kset
K = generateKset(key)
for i in range(0,15):
oldR = R
#F 函数
p_result = F(R,K[i])
R = xor(L,p_result)
L = oldR
p_result = F(R,K[15])
L = xor(L,p_result)
#IP 逆置换
reversedP = IP_reverseTransp(L+R)
#生成 16 进制表示的密文
Cipher = generateHex(reversedP)
#将密文写入 outputFile 文件
writeFile(outputFile,Cipher)
return Cipher
DES 解密：
def DES_decrypt(filename,key,outputFile):
#文件中读取密文
Ciphertext = inputText(filename)
#将密文进行置换分离
L,R = IP_Transposition(Ciphertext)
#生成 Kset
K = generateKset(key)
for i in range(15,0,-1):
oldR = R
#F 函数
p_result = F(R,K[i])
R = xor(L,p_result)
L = oldR
p_result = F(R,K[0])
L = xor(L,p_result)
reversedP = IP_reverseTransp(L+R)
plaintext = generateHex(reversedP)
writeFile(outputFile,plaintext)
return plaintext
源码地址 https://github.com/SuQinghang…