DES加解密算法 — python和C++实现

Mipiace

已于 2024-06-19 16:37:19 修改

阅读量2.6k

点赞数 1

分类专栏：密码学作业文章标签：密码学 python

于 2021-03-19 11:22:19 首次发布

本文链接：https://blog.csdn.net/qq_52196579/article/details/114981651

版权

密码学作业专栏收录该内容

5 篇文章 7 订阅

订阅专栏

密码学引论作业——DES

DES实现

1 算法描述

1.1 DES简介

DES(Data Encryption Standard) 是分组对称密码算法。DES采用了64位的分组长度和56位的密钥长度，它将64位的输入经过一系列变换得到64位的输出。解密则使用了相同的步骤和相同的密钥。DES的密钥长度为64位，由于第n*8(n=1,2,…8)是校验位，因此实际参与加密的长度为56位，密钥空间含有2^56个密钥。

DES算法利用多次组合替代算法和换位算法，分散和错乱的相互作用，把明文编制成密码强度很高的密文，它的加密和解密用的是同一算法。

DES算法，是一种乘积密码，其在算法结构上主要采用了 $F es i t e l$ 结构，通过轮函数迭代的方式来进行计算和工作。

算法也会使用到数据置换技术，主要有初始置换IP和逆初始置换IP^-1两种类型。DES算法使用置换运算的目的是将原始明文的所有格式及所有数据全部打乱重排。而在轮加密函数中，即将数据全部打乱重排，同时在数据格式方面，将原有的32位数据格式，扩展成为48位数据格式，目的是为了满足S盒组对数据长度和数据格式规范的要求。

1.2 Fesitel结构

加密过程中，先把待加密文本分为左右两部分 $L 和 R$ ，然后经过一定轮数加密，每一轮加密过程都如下所示,

$\begin{cases} L_{n+1}=R_n\\R_{n+1}=L_n\oplus F(K_n,R_n)\end{cases}$
每次的 $R_{n+1}$ 都是输入的 $L_n$ 和 $F$ 函数结果的异或， $F$ 函数的输入是本轮密钥 $K_n$ 和本轮输入 $R n$ 。
Fesitel结构示意图
经过若干轮加密后，在最后一轮得到的 $R_n和L_n$ ，交换后拼接成为输出，即 $Out=R_n+L_n$ 。

2 具体实现

2.1 步骤

输入处理：

输入任意长的字符串，或16进制串。分组处理，先把每个字符转换成16进制的ASCii码，用 ‘0x0’ 补足长度，令其长度是16的整数倍。然后每位16进制ascii值转化为四位二进制码。并分成64bit的组。对每组都使用DES加密。

密钥准备

我们的密钥是16位长的16进制串，也就是64位长的二进制串，密钥要先经过一个 $PC\_1$ 置换，得到56bit去掉校验位并打乱顺序的bit串 $K 56$ ，然后 $K 56$ 左右等分成 $C_0$ 和 $D_0$ ， $C_0$ 左移 $i_1$ 位生成 $C_1$ ， $C_1$ 左移 $i_2$ 位生成 $C_2$ …，同理生成 $D_1$ 到 $D_{16}$ ，其中 $i_k$ 是由左移表 $Key\_left\_shift$ 决定的。

PC_1 = [								# 64->56置换表
		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,
]
 Kleft_shift = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1] #左移表

得到 $C_i$ 和 $D_i$ （共16组）后，拼接得到 $K_i'$ ，然后 $K_i'$ 通过 $PC\_2$ 置换矩阵得到轮密钥 $K_i$ ，注意： $PC\_2$ 置换矩阵是把56位的 $K_i'$ 置换成了48位的 $K_i$ 。

16轮加密

我们现在有分好组的明文二进制串，加密过程是对一个64bit串进行加密运算。DES中明文加密的流程图如下，64bit的明文先通过 $I P$ 置换矩阵，然后分为 $L_0$ 和 $R_0$ 两部分，经过16轮的 $F es i t e l$ 加密，最后拼接后经过 $IP\_1$ 置换矩阵得到密文。关键在于其中的 $F$ 函数的实现。

在这里插入图片描述

#E拓展，唯一能记住的盒子
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,
     ]
#IP置换
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逆置换
IP_1=[
        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
]

我们可以注意到 $I P$ 和 $IP\_1$ 两个矩阵是有关系的，比如 $IP\_1$ 的第一位是40，而 $1$ 就是 $I P$ 的第40位，于是有如下关系式： $IP\_1[i] = IP.index(i)$ 。

F函数

$F$ 函数的输入是 $32 bi t$ 的 $R$ 和 $48 bi t$ 的 $K_i$ ，首先要先对 $R$ 做一个 $E$ 拓展，变成 $48 bi t$ ，然后与 $K_i$ 进行异或，异或得到的 $48 bi$ t串，分成 $8$ 组，每组是连续的 $6 bi t$ 。我们利用这 $6 bi t$ ，来获得一个 $S\_box$ 的坐标。 $S\_box$ 共有8个矩阵，分别对应 $8$ 个 $6 bi t$ 的分组。
每个分组的 $6 bi t$ ，首位两个bit拼接作为矩阵行坐标，中间四个bit拼接作为列坐标。例如第一个分组是"100101"，行坐标就是 $0 b 11$ ，就是3，列坐标就是"0010"就是2，这样行坐标有4种情况，列坐标有16种情况，所以 $S\_box$ 的矩阵是4行16列的。

S_box = [[
                0xe, 0x4, 0xd, 0x1, 0x2, 0xf, 0xb, 0x8, 0x3, 0xa, 0x6, 0xc, 0x5, 0x9, 0x0, 0x7,
                0x0, 0xf, 0x7, 0x4, 0xe, 0x2, 0xd, 0x1, 0xa, 0x6, 0xc, 0xb, 0x9, 0x5, 0x3, 0x8,
                0x4, 0x1, 0xe, 0x8, 0xd, 0x6, 0x2, 0xb, 0xf, 0xc, 0x9, 0x7, 0x3, 0xa, 0x5, 0x0,
                0xf, 0xc, 0x8, 0x2, 0x4, 0x9, 0x1, 0x7, 0x5, 0xb, 0x3, 0xe, 0xa, 0x0, 0x6, 0xd,
        ],
        [
                0xf, 0x1, 0x8, 0xe, 0x6, 0xb, 0x3, 0x4, 0x9, 0x7, 0x2, 0xd, 0xc, 0x0, 0x5, 0xa,
                0x3, 0xd, 0x4, 0x7, 0xf, 0x2, 0x8, 0xe, 0xc, 0x0, 0x1, 0xa, 0x6, 0x9, 0xb, 0x5,
                0x0, 0xe, 0x7, 0xb, 0xa, 0x4, 0xd, 0x1, 0x5, 0x8, 0xc, 0x6, 0x9, 0x3, 0x2, 0xf,
                0xd, 0x8, 0xa, 0x1, 0x3, 0xf, 0x4, 0x2, 0xb, 0x6, 0x7, 0xc, 0x0, 0x5, 0xe, 0x9,
        ],
        [
                0xa, 0x0, 0x9, 0xe, 0x6, 0x3, 0xf, 0x5, 0x1, 0xd, 0xc, 0x7, 0xb, 0x4, 0x2, 0x8,
                0xd, 0x7, 0x0, 0x9, 0x3, 0x4, 0x6, 0xa, 0x2, 0x8, 0x5, 0xe, 0xc, 0xb, 0xf, 0x1,
                0xd, 0x6, 0x4, 0x9, 0x8, 0xf, 0x3, 0x0, 0xb, 0x1, 0x2, 0xc, 0x5, 0xa, 0xe, 0x7,
                0x1, 0xa, 0xd, 0x0, 0x6, 0x9, 0x8, 0x7, 0x4, 0xf, 0xe, 0x3, 0xb, 0x5, 0x2, 0xc,
        ],
        [
                0x7, 0xd, 0xe, 0x3, 0x0, 0x6, 0x9, 0xa, 0x1, 0x2, 0x8, 0x5, 0xb, 0xc, 0x4, 0xf,
                0xd, 0x8, 0xb, 0x5, 0x6, 0xf, 0x0, 0x3, 0x4, 0x7, 0x2, 0xc, 0x1, 0xa, 0xe, 0x9,
                0xa, 0x6, 0x9, 0x0, 0xc, 0xb, 0x7, 0xd, 0xf, 0x1, 0x3, 0xe, 0x5, 0x2, 0x8, 0x4,
                0x3, 0xf, 0x0, 0x6, 0xa, 0x1, 0xd, 0x8, 0x9, 0x4, 0x5, 0xb, 0xc, 0x7, 0x2, 0xe,
        ],
        [
                0x2, 0xc, 0x4, 0x1, 0x7, 0xa, 0xb, 0x6, 0x8, 0x5, 0x3, 0xf, 0xd, 0x0, 0xe, 0x9,
                0xe, 0xb, 0x2, 0xc, 0x4, 0x7, 0xd, 0x1, 0x5, 0x0, 0xf, 0xa, 0x3, 0x9, 0x8, 0x6,
                0x4, 0x2, 0x1, 0xb, 0xa, 0xd, 0x7, 0x8, 0xf, 0x9, 0xc, 0x5, 0x6, 0x3, 0x0, 0xe,
                0xb, 0x8, 0xc, 0x7, 0x1, 0xe, 0x2, 0xd, 0x6, 0xf, 0x0, 0x9, 0xa, 0x4, 0x5, 0x3,
        ],
        [
                0xc, 0x1, 0xa, 0xf, 0x9, 0x2, 0x6, 0x8, 0x0, 0xd, 0x3, 0x4, 0xe, 0x7, 0x5, 0xb,
                0xa, 0xf, 0x4, 0x2, 0x7, 0xc, 0x9, 0x5, 0x6, 0x1, 0xd, 0xe, 0x0, 0xb, 0x3, 0x8,
                0x9, 0xe, 0xf, 0x5, 0x2, 0x8, 0xc, 0x3, 0x7, 0x0, 0x4, 0xa, 0x1, 0xd, 0xb, 0x6,
                0x4, 0x3, 0x2, 0xc, 0x9, 0x5, 0xf, 0xa, 0xb, 0xe, 0x1, 0x7, 0x6, 0x0, 0x8, 0xd,
        ],
        [
                0x4, 0xb, 0x2, 0xe, 0xf, 0x0, 0x8, 0xd, 0x3, 0xc, 0x9, 0x7, 0x5, 0xa, 0x6, 0x1,
                0xd, 0x0, 0xb, 0x7, 0x4, 0x9, 0x1, 0xa, 0xe, 0x3, 0x5, 0xc, 0x2, 0xf, 0x8, 0x6,
                0x1, 0x4, 0xb, 0xd, 0xc, 0x3, 0x7, 0xe, 0xa, 0xf, 0x6, 0x8, 0x0, 0x5, 0x9, 0x2,
                0x6, 0xb, 0xd, 0x8, 0x1, 0x4, 0xa, 0x7, 0x9, 0x5, 0x0, 0xf, 0xe, 0x2, 0x3, 0xc,
        ],
        [
                0xd, 0x2, 0x8, 0x4, 0x6, 0xf, 0xb, 0x1, 0xa, 0x9, 0x3, 0xe, 0x5, 0x0, 0xc, 0x7,
                0x1, 0xf, 0xd, 0x8, 0xa, 0x3, 0x7, 0x4, 0xc, 0x5, 0x6, 0xb, 0x0, 0xe, 0x9, 0x2,
                0x7, 0xb, 0x4, 0x1, 0x9, 0xc, 0xe, 0x2, 0x0, 0x6, 0xa, 0xd, 0xf, 0x3, 0x5, 0x8,
                0x2, 0x1, 0xe, 0x7, 0x4, 0xa, 0x8, 0xd, 0xf, 0xc, 0x9, 0x0, 0x3, 0x5, 0x6, 0xb,
        ],
]
# P盒
P_box = [
        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,
]

对每个 $6 bi t$ 分组都得到一个16进制数，然后16进制数转二进制串是 $4 bi t$ ，就实现了 $48 bi t$ 压缩成 $32 bi t$ ，得到的 $32 bi t$ 二进制串再经过 $P\_box$ 得到 $F$ 函数的输出。

2.2 Python实现速度测试

核心代码

#F函数
def F(R,Ki): #R是32bits，Ki是48bits,
        R = translation(R, E)      #对R进行E拓展
        R = ''.join('0' if R[i]==Ki[i] else '1' for i in range(48))  #对R和Ki进行异或
        ij = [R[i:i+6] for i in range(0,48,6)]     # 按6bit分组
        S_box_loca = [int(ij[n][0]+ij[n][-1],2) * 16 + int(ij[n][1:-1],2) for n in range(8)] # 首尾拼接做行，中间四位做列,这里的行列不用减1，因为4行16列，已经包括0的可能性了
        R = ''.join(hex_bin[hex((S_box[n][S_box_loca[n]]))[-1]] for n in range(8))
        # 过P盒
        R = translation(R,P_box)
        return R

def festial(l,r,Ki):
        l_n = r
        r_n = F(l_n,Ki)
        r_n = ''.join('0'if l[i] ==r_n[i] else '1' for i in range(32))
        return l_n,r_n
def Enc_Dec(Input,Key,choice): #choice决定是加密还是解密
        Input_n= divide(Input)
        result=''
        Kn = get_Kn(Key)
        if choice=='2':
                Kn.reverse()
        for p in Pn:
                p = ''.join(hex_bin[i] for i in P)      #转为二进制
                #print(p)
                p = translation(p, IP)                  #IP置换
                # print(p)
                l = p[0:32]
                r = p[32:]
                for i in range(16):
                        l,r = feistel(l,r,Kn[i])       #16轮feistel
                l,r = r,l
                result = result + l+r
        result = translation(result,IP_1)               #IP_1 置换
        return result

python运行10次，求平均值运行时间如下：

测试1	测试2	测试3
0.0004034280776977539s	0.00040314197540283205s	0.0005030155181884766s

求得运行时间平均值 $0.0004365 s$

2.3 C++ 实现速度测试

核心代码：

string F(string r, string Ki)
{
	//cout << "r:\t" << r << endl;
	string r48 = "";
	string r32 = "";
	trans(r48, r, E, 48);  			//过E盒
	for (int i = 0; i < 48; i++)
	{
		r48[i] = r48[i] == Ki[i] ? '0' : '1';
	}
	//cout << "Ki^E\t" << r48 << endl;
	int p2[8] = { 0 };
	int p3[8] = { 0 };
	for (int i = 0; i < 8; i++) {
		char* str = &r48[i * 6];	//string字符串里单个字符是char类型
		p2[i] += str[0] == '1' ? 2 : 0;
		p2[i] += str[5] == '1' ? 1 : 0;
		for (int j = 1; j < 5; j++)
		{
			p3[i] += str[j] == '1' ? int(pow(2, 4 - j)) : 0;
		}
		//cout << endl;
		//cout << "p2[" << i << "]:\t" << p2[i] << "\tp3[" << i << "]:\t" << p3[i] << endl;*/
	}
	r32 = "";
	for (int i = 0; i < 8; i++)
	{
		r32 += int_bin(S_box[i][p2[i]][p3[i]]);
	}
	//cout << "S:\t" << r32 << endl;
	trans(r, r32, P_box, 32);
	//cout << "P:\t" << r << endl;
	return r;
}
void Feistel(string& l, string& r, string Ki)
{
	string r_n;
	string l_n;
	l_n = r;
	r_n = F(r, Ki);
	//r_n ^= l;
	for (int i = 0; i < 32; i++)
	{
		r_n[i] = r_n[i] == l[i] ? '0' : '1';
	}
	l = l_n;
	r = r_n;
}
string Enc_Dec(string In, string Key, int choice)
{
	string result = "";
	char* Kn_chr;
	get_Kn(Kn_chr, Key);
	string Kn_str[16];
	for (int i = 0; i < 16; i++)
	{
		int ij = i * 48;
		for (int j = 0; j < 48; j++)
		{
			Kn_str[i] += Kn_chr[ij + j];
		}
		//cout << "K" << i + 1 << ":\t" << Kn_str[i] << endl;;
	}
	delete Kn_chr;
	//Ki准备好后就要处理输入，分组进行加密，所以要得到一个Input_n[]
	int div = 0;
	string* In_n = Divide(In, div);
	string In_i = "";
	string res = "";
	string l = "";
	string r = "";
	for (int i = 0; i < div; i++)
	{
		In_i = hex_bin(In_n[i], 16);
		trans(In_i, In_i, IP, 64);  //IP置换
		l = In_i.substr(0, 32);
		r = In_i.substr(32, 64);
		for (int j = 0; j < 16; j++)
		{
			//cout << "\t\tRound:" << j + 1 << endl;
			Feistel(l, r, Kn_str[j]);
			//cout << endl;
		}
		res = r + l;
		trans(res, res, IP_1, 64);//IP逆置换
		result += res;
	}
	return result;
}