DES算法及其在VC上的实现.docx
《DES算法及其在VC上的实现.docx》由会员分享，可在线阅读，更多相关《DES算法及其在VC上的实现.docx（12页珍藏版）》请在冰豆网上搜索。
DES算法及其在VC上的实现
DES算法及其在VC++6.0下的实现
摘要：
本文介绍了一种国际上通用的加密算法—DES算法的原理，并给出了在VC++6.0语言环境下实现的源代码。
最后给出一个例如，以供参考。
关键字：
DES算法、明文、密文、密钥、VC；本文程序运行效果图如下：
正文：
当今社会是信息化的社会。
为了适应社会对计算机数据平安XX越来越高的要求，美国国家标准局（NBS）于1997年公布了一个由IBM公司研制的一种加密算法，并且确定为非机要部门使用的数据加密标准，简称DES（DataEncryptonStandard）。
自公布之日起，DES算法作为国际上商用XX通信和计算机通信的最常用算法，一直活泼在国际XX通信的舞台上，扮演了十分突出的角色。
现将DES算法简单介绍一下，并给出实现DES算法的VC源代码。
DES算法由加密、解密和子密钥的生成三局部组成。
一．加密DES算法处理的数据对象是一组64比特的明文串。
设该明文串为m=m1m2…m64（mi=0或1）。
明文串经过64比特的密钥K来加密，最后生成长度为64比特的密文E。
其加密过程图示如下：
DES算法加密过程对DES算法加密过程图示的说明如下：
待加密的64比特明文串m，经过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
该比特串被分为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
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
经过置换IP-1后生成的比特串就是密文e.。
下面再讲一下变换f（Ri-1,Ki）。
它的功能是将32比特的输入再转化为32比特的输出。
其过程如下列图：
对f变换说明如下：
输入Ri-1（32比特）经过变换E后，膨胀为48比特。
膨胀后的比特串的下标列表如下：
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
31
膨胀后的比特串分为8组，每组6比特。
各组经过各自的S盒后，又变为4比特（具体过程见后），合并后又成为32比特。
该32比特经过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
经过P变换后输出的比特串才是32比特的f（Ri-1,Ki）。
下面再讲一下S盒的变换过程。
任取一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盒的输出。
〔S表如下列图〕
至此，DES算法加密原理讲完了。
在VC++6.0下的程序源代码为：
for（i=1;i<=64;i++）
m1[i]=m[ip[i-1]];//64位明文串输入，经过IP置换。
下面进展迭代。
由于各次迭代的方法一样只是输入输出不同，因此只给出其中一次。
以第八次为例：
//进展第八次迭代。
首先进展S盒的运算，输入32位比特串。
for（i=1;i<=48;i++）//经过E变换扩大，由32位变为48位
RE1[i]=R7[E[i-1]];
for（i=1;i<=48;i++）//与K8按位作不进位加法运算
RE1[i]=RE1[i]+K8[i];
for（i=1;i<=48;i++）
{
if（RE1[i]==2）
RE1[i]=0;
}
for（i=1;i<7;i++）//48位分成8组
{
s11[i]=RE1[i];
s21[i]=RE1[i+6];
s31[i]=RE1[i+12];
s41[i]=RE1[i+18];
s51[i]=RE1[i+24];
s61[i]=RE1[i+30];
s71[i]=RE1[i+36];
s81[i]=RE1[i+42];
}//下面经过S盒，得到8个数。
S1,s2,s3,s4,s5,s6,s7,s8分别为S表
s[1]=s1[s11[6]+s11[1]*2][s11[5]+s11[4]*2+s11[3]*4+s11[2]*8];
s[2]=s2[s21[6]+s21[1]*2][s21[5]+s21[4]*2+s21[3]*4+s21[2]*8];
s[3]=s3[s31[6]+s31[1]*2][s31[5]+s31[4]*2+s31[3]*4+s31[2]*8];
s[4]=s4[s41[6]+s41[1]*2][s41[5]+s41[4]*2+s41[3]*4+s41[2]*8];
s[5]=s5[s51[6]+s51[1]*2][s51[5]+s51[4]*2+s51[3]*4+s51[2]*8];
s[6]=s6[s61[6]+s61[1]*2][s61[5]+s61[4]*2+s61[3]*4+s61[2]*8];
s[7]=s7[s71[6]+s71[1]*2][s71[5]+s71[4]*2+s71[3]*4+s71[2]*8];
s[8]=s8[s81[6]+s81[1]*2][s81[5]+s81[4]*2+s81[3]*4+s81[2]*8];
for（i=0;i<8;i++）//8个数变换输出二进制
{
for（j=1;j<5;j++）
{
temp[j]=s[i+1]%2;
s[i+1]=s[i+1]/2;
}
for（j=1;j<5;j++）
f[4*i+j]=temp[5-j];
}
for（i=1;i<33;i++）//经过P变换
frk[i]=f[P[i-1]];//S盒运算完成
for（i=1;i<33;i++）//左右交换
L8[i]=R7[i];
for（i=1;i<33;i++）//R8为L7与f（R,K）进展不进位二进制加法运算结果
{
R8[i]=L7[i]+frk[i];
if（R8[i]==2）
R8[i]=0;
}
其它各次迭代类似，可以依此类推。
二．子密钥的生成64比特的密钥生成16个48比特的子密钥。
其生成过程见图：
子密钥生成过程具体解释如下：
64比特的密钥K，经过PC-1后，生成56比特的串。
其下标如表所示：
PC-1
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
该比特串分为长度相等的比特串C0和D0。
然后C0和D0分别循环左移1位，得到C1和D1。
C1和D1合并起来生成C1D1。
C1D1经过PC-2变换后即生成48比特的K1。
K1的下标列表为：
PC-2
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
C1、D1分别循环左移LS2位，再合并，经过PC-2，生成子密钥K2……依次类推直至生成子密钥K16。
注意：
Lsi（I=1,2,….16）的数值是不同的。
具体见下表：
迭代顺序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
左移位数
1
1
2
2
2
2
2
2
1
2
2
2
2
2
2
1
生成子密钥的VC程序源代码如下：
for（i=1;i<57;i++）//输入64位K，经过PC-1变为56位k0[i]=k[PC_1[i-1]];
56位的K0，均分为28位的C0，D0。
C0，D0生成K1和C1，D1。
以下几次迭代方法一样，仅以生成K8为例。
for（i=1;i<27;i++）//循环左移两位
{
C8[i]=C7[i+2];
D8[i]=D7[i+2];
}
C8[27]=C7[1];
D8[27]=D7[1];
C8[28]=C7[2];
D8[28]=D7[2];
for（i=1;i<=28;i++）
{
C[i]=C8[i];
C[i+28]=D8[i];
}
for（i=1;i<=48;i++）
K8[i]=C[PC_2[i-1]];//生成子密钥k8
注意：
生成的子密钥不同，所需循环左移的位数也不同。
源程序中以生成子密钥K8为例，所以循环左移了两位。
但在编程中，生成不同的子密钥应以Lsi表为准。
三．解密DES的解密过程和DES的加密过程完全类似，只不过将16圈的子密钥序列K1，K2……K16的顺序倒过来。
即第一圈用第16个子密钥K16，第二圈用K15，其余类推。
第一圈：
加密后的结果
L=R15,R=L15⊕f（R15,K16）⊕f（R15,K16）=L15同理R15=L14⊕f（R14,K15）,L15=R14。
同理类推：
得L=R0,R=L0。
其程序源代码与加密一样。
在此就不重写。
四．例如例如：
明文m=learning,密钥k=computer。
明文m的ASCII二进制表示：
m=01101100011001010110000101110010
01101110011010010110111001100111
密钥k的ASCII二进制表示：
k=01100011011011110110110101110000
01110101011101000110010101110010
明文m经过IP置换后，得：
1111111100001000110100111010011000000000111111110111000111011000
等分为左右两段：
L0=11111111000010001101001110100110R0=00000000111111110111000111011000
经过16次迭代后，所得结果为：
其中，f函数的结果为：
16个子密钥为：
S盒中，16次运算时，每次的8个结果为：
第一次：
5，11，4，1，0，3，13，9；第二次：
7，13，15，8，12，12，13，1；第三次：
8，0，0，4，8，1，9，12；第四次：
0，7，4，1，7，6，12，4；第五次：
8，1，0，11，5，0，14，14；第六次：
14，12，13，2，7，15，14，10；第七次：
12，15，15，1，9，14，0，4；第八次：
15，8，8，3，2，3，14，5；第九次：
8，14，5，2，1，15，5，12；第十次：
2，8，13，1，9，2，10，2；第十一次：
10，15，8，2，1，12，12，3；第十二次：
5，4，4，0，14，10，7，4；第十三次：
2，13，10，9，2，4，3，13；第十四次：
13，7，14，9，15，0，1，3；第十五次：
3，1，15，5，11，9，11，4；第十六次：
12，3，4，6，9，3，3，0；子密钥生成过程中，生成的数值为：
解密过程与加密过程相反，所得的数据的顺序恰好相反。
在此就不赘述。
参考书目：
?
计算机系统平安?
XX卢开澄等编著?
计算XX码应用根底?
科学朱文余等编著?
VisualC++6.0编程实例与技巧?
机械工业王华等编著
能不能重新把子密钥写一下,原来的写错了吧,应该是48.
我在拿您的例子调试程序,拜托了!
!
:
字密钥应该是48位
升级会员 