对称加密算法——DES算法（python实现）

最新推荐文章于 2021-11-24 11:01:36 发布

夏木呀

最新推荐文章于 2021-11-24 11:01:36 发布

阅读量3.5w

点赞数 38

分类专栏：网络安全文章标签：加密对称加密

网络安全专栏收录该内容

4 篇文章 1 订阅

订阅专栏

对称加密算法——DES算法（python实现）

感谢深信服技术详解～

一、DES算法描述

DES算法总的说来可以两部分组成：

1、对密钥的处理。这一部分是把我们用的64位密钥（实际用的56位，去掉了8个奇偶校验位）分散成16个48位的子密钥。

2、对数据的加密。通过第一步生成的子密钥来加密我们所要加密的数据，最终生成密文。

下面就通过这两部分分别介绍DES算法的实现原理。

1．密钥分散——子密钥的生成

64比特的密钥生成16个48比特的子密钥。其生成过程见图：

64比特的密钥K，经过PC-1后，生成56比特的串。其下标如表所示：

该比特串分为长度相等的比特串C0和D0（分别为28比特）。然后C0和D0分别循环左移1位，得到C1和D1。C1和D1合并起来生成C1D1。C1D1经过PC-2变换后即生成48比特的K1。K1的下标列表为：

C1、D1分别循环左移LS2位，再合并，经过PC-2，生成子密钥K2……依次类推直至生成子密钥K16。

注意：Lsi (I =1,2,….16)的数值是不同的。具体见下表：

注：PC-1 和 PC-2是密钥的指定为置换。

至此，我们已成功的生成了16个48位的子密钥。

2．加密流程图

DES算法处理的数据对象是一组64比特的明文串。设该明文串为m=m1m2…m64(mi=0或1)。明文串经过64比特的密钥K来加密，最后生成长度为64比特的密文E。其加密过程图示如下：

3． DES算法加密过程

对DES算法加密过程图示的说明如下：待加密的64比特明文串m，经过IP置换后，得到的比特串的下标列表如下：

该比特串被分为32位的L0和32位的R0两部分。R0子密钥K1经过变换f(R0,K1)（f变换算法见下）输出32位的比特串f1,f1与L0做异或运算。

f1 与L0做异或运算后的结果赋给R1，R0则原封不动的赋给L1。L1与R0又做与以上完全相同的运算，生成L2，R2…… 一共经过16次运算。最后生成R16和L16。其中R16为L15与f(R15,K16)做不进位二进制加法运算的结果，L16是R15的直接赋值。

R16与L16合并成64位的比特串。值得注意的是R16一定要排在L16前面。R16与L16合并后成的比特串，经过置换IP-1后所得比特串的下标列表如下：

经过置换IP-1后生成的比特串就是密文e.。

f 算法

变换f(Ri-1,Ki)的功能是将32比特的输入再转化为32比特的输出。其过程如图所示：

首先、输入Ri-1(32比特)经过变换E后，膨胀为48比特。膨胀后的比特串的下标列表如下：

其次、膨胀后的E和Ki异或的结果分为8组，每组6比特。各组经过各自的S盒后，变为4比特，

S盒的算法为：输入b1,b2,b3,b4,b5,b6，计算x=b1*2+b6,y=b5+b4*2+b3*4+b2*8，再从Si表（见下表）中查出x 行，y 列的值Sxy。将Sxy化为二进制，即得Si盒的输出。

最后、合并8组S盒输出成为32比特。该32比特经过P变换后，其下标列表如下：

经过P变换后输出的比特串才是32比特的f (Ri-1,Ki)。

以上介绍了DES算法的加密过程。DES算法的解密过程是一样的，区别仅仅在于第一次迭代时用子密钥K16，第二次K15、......，最后一次用K1，算法本身并没有任何变化。

二、目前使用的DES算法

对于服务端apache，里面描述的DES加解密，只是最基本、最原始的加解密，而现在很多地方使用的DES都会有一些扩展。

接来说下我们目前使用的DES的加解密的使用。

函数des3_set_3keys设置key，如果是3DES，则需要设置3个key，这里说的key其实就是8字节的数组类型的密钥；

而函数des3_encrypt是处理的加密，void des3_encrypt( des3_context *ctx, uint8 input[8], uint8output[8] )，其中的input和output分别表示需要加密的和加密后的数据。这里提供的是8个字节的数据，如果要加密的数据比8个字节要长，则需要循环使用这个加密函数；而输出output，每次调用des3_encrypt，输出都是8位。比如说，需要加密的数据是个10字节长的数，那么加完密之后则是16 位。

三、DES算法的两种模式

上面描述的只是是最基本的DES加密，而通常外界使用的DES很多都有模式以及填充方式的设置，如果设置不一样，将会导致一些接口信息不一致，加解密的数据就对不上。

比较常用的模式有：cbc和ecb。

这里主要介绍DES算法的数据补位问题、DES算法的两种模式ECB和CBC问题，以及更加安全的算法3DES。

1、数据补位

DES数据加解密就是将数据按照8个字节一段进行DES加密或解密得到一段8个字节的密文或者明文，最后一段不足8个字节，按照需求补足8个字节（通常补00或者FF，根据实际要求不同）进行计算，之后按照顺序将计算所得的数据连在一起即可。

很多地方默认的补位方式是以PKCS7补位的，如果C#默认的就是PKCS7补位：补位补到8位的整数倍，差几位补几。

这里有个问题就是为什么要进行数据补位？主要原因是DES算法加解密时要求数据必须为8个字节。

2、ECB模式

DES ECB（电子密本方式）其实非常简单，就是将数据按照8个字节一段进行DES加密或解密得到一段8个字节的密文或者明文，最后一段不足8个字节，按照需求补足8个字节进行计算，之后按照顺序将计算所得的数据连在一起即可，各段数据之间互不影响。

3、CBC模式

DES CBC（密文分组链接方式）有点麻烦，它的实现机制使加密的各段数据之间有了联系。其实现的机理如下：

加密步骤如下：

1）首先将数据按照8个字节一组进行分组得到D1D2......Dn（若数据不是8的整数倍，用指定的PADDING数据补位）

2）第一组数据D1与初始化向量I异或后的结果进行DES加密得到第一组密文C1（初始化向量I为全零）

3）第二组数据D2与第一组的加密结果C1异或以后的结果进行DES加密，得到第二组密文C2

4）之后的数据以此类推，得到Cn

5）按顺序连为C1C2C3......Cn即为加密结果。

解密是加密的逆过程，步骤如下：

1）首先将数据按照8个字节一组进行分组得到C1C2C3......Cn

2）将第一组数据进行解密后与初始化向量I进行异或得到第一组明文D1（注意：一定是先解密再异或）

3）将第二组数据C2进行解密后与第一组密文数据进行异或得到第二组数据D2

4）之后依此类推，得到Dn

5）按顺序连为D1D2D3......Dn即为解密结果。

python实现：

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# 2014/10/16  wrote by yangyongzhen
# QQ:534117529
# global definition
# base = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F]

__author__ = 'YangYongZhen'

base = [str(x) for x in range(10)] + [ chr(x) for x in range(ord('A'),ord('A')+6)]
# bin2dec
# 二进制 to 十进制: int(str,n=10)
def bin2dec(string_num):
	return str(int(string_num, 2))

# hex2dec
# 十六进制 to 十进制
def hex2dec(string_num):
	return str(int(string_num.upper(), 16))

# dec2bin
# 十进制 to 二进制: bin()
def dec2bin(string_num):
	num = int(string_num)
	mid = []
	while True:
		if num == 0: break
		num,rem = divmod(num, 2)
		mid.append(base[rem])

	return ''.join([str(x) for x in mid[::-1]])

# dec2hex
# 十进制 to 八进制: oct()
# 十进制 to 十六进制: hex()
def dec2hex(string_num):
	num = int(string_num)
	if num==0:
		return '0'
	mid = []
	while True:
		if num == 0: break
		num,rem = divmod(num, 16)
		mid.append(base[rem])

	return ''.join([str(x) for x in mid[::-1]])

# hex2tobin
# 十六进制 to 二进制: bin(int(str,16))
def hex2bin(string_num):
	return dec2bin(hex2dec(string_num.upper()))

# bin2hex
# 二进制 to 十六进制: hex(int(str,2))
def bin2hex(string_num):
	return dec2hex(bin2dec(string_num))
'''
/**
 * PBOC3DES 加密算法
 * @author Administrator
 *
 */
'''
class PBOC_DES():
	pass
'''
/** ***************************压缩替换S-Box************************************************* */
'''
subKey = [([0] * 48) for ll in range(16)]

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 ] ]

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 = [ 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 ]
# 每次密钥循环左移位数
LS = [ 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2,2, 1 ]
'''
/**
 * IP初始置换
 * @param source
 * @return
 */
'''
def changeIP(source):
	dest= [0]*64
	global ip
	for i in range(64):
		dest[i] = source[ip[i] - 1]
	return dest


def string2Binary(str):
	le = len(str)
	dest =[0]*le*4
	i = 0
	for c in str:
	   i += 4
	   j = 0
	   s = hex2bin(c)
	   l = len(s)
	   for d in s:
		dest[i-l+j]=int(d)
		j += 1
	return dest

'''
/**
 * IP-1逆置
 * @param source
 * @return
 */
'''
def changeInverseIP(source):
		dest = [0]*64
		global _ip
		for i in range(64):
			dest[i] = source[_ip[i] - 1]

		return dest
'''
/**
 *
 * 获取轮子密钥(48bit)
 *
 * @param source
 *
 * @return
 *
 */
'''
def setKey(source):
	global subKey
	# 装换4bit
	temp = string2Binary(source)
	# 6bit均分成两部分
	left =  [0]*28
	right = [0]*28
	# 经过PC-14bit转换6bit
	temp1 = [0]*56
	temp1 = keyPC_1(temp)
	# printArr(temp1);
	#将经过转换的temp1均分成两部分
	for i in range(28):
		left[i] = temp1[i]
		right[i] = temp1[i + 28]
	# 经过16次循环左移，然后PC-2置换
	for i in range(16):
		left = keyLeftMove(left, LS[i])
		right = keyLeftMove(right, LS[i])
		for j in range(28):
				temp1[j] = left[j]
				temp1[j + 28] = right[j]
		subKey[i] = keyPC_2(temp1)

'''
/**
 *
 * 6bit的密钥转换成48bit
 * @param source
 * @return
 *
 */
'''
def keyPC_2(source):
	dest = [0]*48
	temp = [ 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 ]
	for i in range(48):
		dest[i] = source[temp[i] - 1]
	return dest

'''
/**
 *
 * 将密钥循环左移i
 * @param source 二进制密钥数
 * @param i 循环左移位数
 * @return
 *
 */
'''
def keyLeftMove( source, i):
	temp = 0
	global LS
	le = len(source)
	ls = LS[i]
	for k in range(ls):
		temp = source[0]
		for j in range(le-1):
			source[j] = source[j + 1]
	source[le - 1] = temp
	return source
'''
/**
 *
 * 4bit的密钥转换成56bit
 * @param source
 * @return
 *
 */
'''
def keyPC_1(source):
	dest = [0]*56
	temp = [ 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 ]
	for i in range(56):
		dest[i] = source[temp[i] - 1]
	return dest
'''
/**
 * 两个等长的数组做异或
 * @param source1
 * @param source2
 * @return
 */
'''
def diffOr( source1, source2):
	le = len(source1)
	dest = [0]*le
	for i in range(le):
		dest[i] = source1[i] ^ source2[i]
	return dest
'''
/**
 *
 * DES加密--->对称密钥
 * D = Ln(32bit)+Rn(32bit)
 * 经过16轮置
 * @param D(16byte)明文
 * @param K(16byte)轮子密钥
 * @return (16byte)密文
 */
'''
def encryption( D,  K) :
	temp = [0]*64;
	data = string2Binary(D)
	# 第一步初始置
	data = changeIP(data)
	left =  [([0] * 32) for i in range(17)]
	right = [([0] * 32) for i in range(17)]
	for j in range(32):
		left[0][j] = data[j]
		right[0][j] = data[j + 32]
	setKey(K)# sub key ok
	for i in range(1,17):
		# 获取(48bit)的轮子密
		key = subKey[i - 1]
		# L1 = R0
		left[i] = right[i - 1]
		# R1 = L0 ^ f(R0,K1)
		fTemp = f(right[i - 1], key)# 32bit
		right[i] = diffOr(left[i - 1], fTemp)
	#组合的时候，左右调换
	for i in range(32):
		temp[i] = right[16][i]
		temp[32 + i] = left[16][i]

	temp = changeInverseIP(temp)
	str = binary2ASC(intArr2Str(temp))
	return str
'''
/**
 * 8bit压缩2bit
 * @param source(48bit)
 * @return R(32bit) B=E(R)⊕K，将48 位的B 分成8 个分组，B=B1B2B3B4B5B6B7B8
 */
 '''
def press(source) :
	ret = [0]*32
	temp =  [([0] * 6) for i in range(8)]
	s =[s1,s2,s3,s4,s5,s6,s7,s8]
	st=[]
	for i in range(8):
		for j in range(6):
			temp[i][j] = source[i * 6 + j]
	for i in range(8):
		# (16)
		x = temp[i][0] * 2 + temp[i][5]
		# (2345)
		y = temp[i][1] * 8 + temp[i][2] * 4 + temp[i][3] * 2+ temp[i][4]
		val = s[i][x][y]
		ch = dec2hex(str(val))
		# System.out.println("x=" + x + ",y=" + y + "-->" + ch);
		# String ch = Integer.toBinaryString(val);
		st.append(ch)
		# System.out.println(str.toString());
	ret = string2Binary(st)
	# printArr(ret);
	# 置换P
	ret = dataP(ret)
	return ret
'''
/**
 * 置换P(32bit)
 * @param source
 * @return
 */
'''
def dataP( source):
	dest = [0]*32
	temp = [ 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 ]
	le = len(source)
	for i in range(le):
		dest[i] = source[temp[i] - 1]
	return dest
'''
/**
 * 2bit扩展8bit
 * @param source
 * @return
 */
'''
def expend(source):
	ret = [0]*48
	temp = [ 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 ]
	for i in range(48):
		ret[i] = source[temp[i] - 1]
	return ret
'''
/**
 * @param R(2bit)
 * @param K(48bit的轮子密
 * @return 32bit
 */
'''
def f( R,  K):
	dest = [0]*32
	temp = [0]*48
	# 先将输入32bit扩展8bit
	expendR = expend(R)# 48bit
	# 与轮子密钥进行异或运
	temp = diffOr(expendR, K);
	# 压缩2bit
	dest = press(temp)
	return dest
'''
/**
 * 将int类型数组拼接成字符串
 * @param arr
 * @return
 */
'''
def intArr2Str( arr) :
	sb = []
	le=len(arr)
	for i in range(le):
		sb.append(str(arr[i]))
	return ''.join(sb)
'''
/**
 * 将二进制字符串转换成十六进制字符
 * @param s
 * @return
 */
'''
def binary2ASC(s):
	st = ''
	ii = 0
	le= len(s)
	#不够4bit左补0
	if le % 4 != 0:
		while ii < (4 - len % 4):
			s = "0" + s
	le=le/4
	for i in range(le):
		st += bin2hex(s[i * 4 : i * 4 + 4])
	return st

if __name__=="__main__":

	D='1111111111111111'
	K='FFFFFFFFFFFFFFFF'
print	encryption(D,K)