DES加密算法的实现

合集下载

DES算法原理完整版

DES算法原理完整版

DES算法原理完整版1.所需参数key:8个字节共64位的⼯作密钥data:8个字节共64位的需要被加密或被解密的数据 mode:DES⼯作⽅式,加密或者解密2.初始置换DES算法使⽤64位的密钥key将64位的明⽂输⼊块变为64位的密⽂输出块,并把输出块分为L0、R0两部分,每部分均为32位。

初始置换规则如下:注意:这⾥的数字表⽰的是原数据的位置,不是数据158,50,42,34,26,18,10,2,260,52,44,36,28,20,12,4,362,54,46,38,30,22,14,6,464,56,48,40,32,24,16,8,557,49,41,33,25,17, 9,1,659,51,43,35,27,19,11,3,761,53,45,37,29,21,13,5,863,55,47,39,31,23,15,7,即将输⼊的64位明⽂的第1位置换到第40位,第2位置换到第8位,第3位置换到第48位。

以此类推,最后⼀位是原来的第7位。

置换规则是规定的。

L0(Left)是置换后的数据的前32位,R0(Right)是置换后的数据的后32位。

例如:64位输⼊块是D1~D64,则经过初始置换后是D58,D50...D7。

则L0=D58,D50,D12...D8;R0=D57,D49,D41 (7)该置换过程是在64位秘钥的控制下。

3.加密处理--迭代过程经过初始置换后,进⾏16轮完全相同的运算,在运算过程中数据与秘钥结合。

函数f的输出经过⼀个异或运算,和左半部分结合形成新的右半部分,原来的右半部分成为新的左半部分。

每轮迭代的过程可以表⽰如下:Ln = R(n - 1);Rn = L(n - 1)⊕f(Rn-1,kn-1)⊕:异或运算Kn是向第N层输⼊的48位的秘钥,f是以Rn-1和Kn为变量的输出32位的函数3.1函数f函数f由四步运算构成:秘钥置换(Kn的⽣成,n=0~16);扩展置换;S-盒代替;P-盒置换。

DES算法及其程序实现

DES算法及其程序实现

DES算法及其程序实现一.D ES算法概述①DES算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。

明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位,使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

②DES算法的特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。

③DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位,整个算法的主流程图如下:二.D ES算法的编程实现#include <iostream>#include <fstream>using namespace std;const static char 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};const static char fp[] = { //最终置换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};const static char sbox[8][64] = { //s_box/* 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 };const static char rar[] = { //压缩置换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};const static char ei[] = { //扩展置换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, 1const static char Pzh[]={ //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};const static char Keyrar[]={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};bool key[16][48]={0},/*rekey[16][48],*/char key_in[8];void ByteToBit(bool *Out,char *In,int bits) //字节到位的转换{int i;for(i=0;i<bits;i++)Out[i]=(In[i/8]>>(i%8))&1;}void BitToByte(char *Out,bool *In,int bits) //位到字节转换{for(int i=0;i<bits/8;i++)Out[i]=0;for(i=0;i<bits;i++)Out[i/8]|=In[i]<<(i%8); //"|="组合了位操作符和赋值操作符的功能}void Xor(bool *InA,const bool *InB,int len) //按位异或{for(int i=0;i<len;i++)InA[i]^=InB[i];}void keyfc(char *In) //获取密钥函数{int i,j=0,mov,k;bool key0[56],temp,keyin[64];ByteToBit(keyin,In,64); //字节到位的转换for(i=0;i<56;i++) //密钥压缩为56位key0[i]=keyin[Keyrar[i]-1];for(i=0;i<16;i++) //16轮密钥产生{if(i==0||i==1||i==8||i==15)mov=1;elsemov=2;for(k=0;k<mov;k++) //分左右两块循环左移{for(int m=0;m<8;m++){temp=key0[m*7];for(j=m*7;j<m*7+7;j++)key0[j]=key0[j+1];key0[m*7+6]=temp;}temp=key0[0];for(m=0;m<27;m++)key0[m]=key0[m+1];key0[27]=temp;temp=key0[28];for(m=28;m<55;m++)key0[m]=key0[m+1];key0[55]=temp;}for(j=0;j<48;j++) //压缩置换并储存key[i][j]=key0[rar[j]-1];}}void DES(char Out[8],char In[8],bool MS)//加密核心程序,ms=0时加密,反之解密{bool MW[64],tmp[32],PMW[64]; //注意指针bool kzmw[48],keytem[48],ss[32];int hang,lie;ByteToBit(PMW,In,64);for(int j=0;j<64;j++){MW[j]=PMW[ip[j]-1]; //初始置换}bool *Li=&MW[0],*Ri=&MW[32];for(int i=0;i<48;i++) //右明文扩展置换kzmw[i]=Ri[ei[i]-1]; //注意指针if(MS==0) //DES加密过程{for(int lun=0;lun<16;lun++){for(i=0;i<32;i++)ss[i]=Ri[i];for(i=0;i<48;i++) //右明文扩展置换kzmw[i]=Ri[ei[i]-1]; //注意指针for(i=0;i<48;i++)keytem[i]=key[lun][i]; //轮密钥Xor(kzmw,keytem,48);/*S盒置换*/for(i=0;i<8;i++){hang=kzmw[i*6]*2+kzmw[i*6+5];lie =kzmw[i*6+1]*8+kzmw[i*6+2]*4+kzmw[i*6+3]*2+kzmw[i*6+4];tmp[i*4+3]=sbox[i][(hang+1)*16+lie]%2;tmp[i*4+2]=(sbox[i][(hang+1)*16+lie]/2)%2;tmp[i*4+1]=(sbox[i][(hang+1)*16+lie]/4)%2;tmp[i*4]=(sbox[i][(hang+1)*16+lie]/8)%2;}for(int i=0;i<32;i++) //P置换Ri[i]=tmp[Pzh[i]-1];Xor(Ri,Li,32); //异或for(i=0;i<32;i++) //交换左右明文{Li[i]=ss[i];}}for(i=0;i<32;i++){tmp[i]=Li[i];Li[i]=Ri[i];Ri[i]=tmp[i];}for(i=0;i<64;i++)PMW[i]=MW[fp[i]-1];BitToByte(Out,PMW,64); //位到字节的转换}else //DES解密过程{for(int lun=15;lun>=0;lun--){for(i=0;i<32;i++)ss[i]=Ri[i];for(int i=0;i<48;i++) //右明文扩展置换kzmw[i]=Ri[ei[i]-1]; //注意指针for(i=0;i<48;i++)keytem[i]=key[lun][i]; //轮密钥Xor(kzmw,keytem,48);/*S盒置换*/for(i=0;i<8;i++){hang=kzmw[i*6]*2+kzmw[i*6+5];lie =kzmw[i*6+1]*8+kzmw[i*6+2]*4+kzmw[i*6+3]*2+kzmw[i*6+4];tmp[i*4+3]=sbox[i][(hang+1)*16+lie]%2;tmp[i*4+2]=(sbox[i][(hang+1)*16+lie]/2)%2;tmp[i*4+1]=(sbox[i][(hang+1)*16+lie]/4)%2;tmp[i*4]=(sbox[i][(hang+1)*16+lie]/8)%2;}for(i=0;i<32;i++) //P置换Ri[i]=tmp[Pzh[i]-1];Xor(Ri,Li,32); //异或for(i=0;i<32;i++) //交换左右明文{Li[i]=ss[i];}}for(i=0;i<32;i++){tmp[i]=Li[i];Li[i]=Ri[i];Ri[i]=tmp[i];}for(i=0;i<64;i++)PMW[i]=MW[fp[i]-1];BitToByte(Out,PMW,64); //位到字节的转换}}void main(){char Ki[8],jm[8],final[8];int i0;cout<<"请输入密钥(8字节):"<<endl;for(i0=0;i0<8;i0++)cin>>Ki[i0];keyfc(Ki);cout<<"请输入明文:"<<endl;for(i0=0;i0<8;i0++)cin>>jm[i0];DES(final,jm,0);cout<<"加密后:"<<endl;//加密for(i0=0;i0<8;i0++)cout<<final[i0];cout<<endl;cout<<"解密后:"<<endl;DES(jm,final,1); //解密for(i0=0;i0<8;i0++)cout<<jm[i0];cout<<endl;}三.实例描述1.加密字母,运行结果如下:2.加密汉字,运行结果如下:。

des算法原理

des算法原理

des算法原理DES 算法就像是一个神秘的密码宝箱,它有着自己独特的开锁方式。

DES 算法呢,其实就是一种加密算法,用来把咱们的重要信息藏得严严实实的,不让那些不怀好意的家伙轻易看到。

想象一下,我们有一堆明文,就是那些没有经过处理的、能直接看懂的信息。

DES 算法就像是一个魔法师,它把这些明文变来变去,最后变成了一堆让人摸不着头脑的密文。

那它是怎么做到的呢?这就得好好说道说道啦。

DES 算法首先有一个很关键的东西,叫做密钥。

这个密钥就像是一把特别的钥匙,只有拥有了正确的钥匙,才能打开加密后的信息。

而且这个密钥可不是随随便便生成的哦,它得经过一系列复杂的计算和处理。

在加密的过程中,DES 算法会把明文分成一块一块的,就好像把一个大蛋糕切成了好多小块。

然后对每一小块进行处理。

处理的时候,它会进行好多轮的操作,每一轮都像是在给这些小块信息做一次特别的“加工”。

比如说,进行一些替换啦,移位啦之类的操作。

这些操作可不是乱来的,都是按照事先设定好的规则来的。

而且哦,DES 算法还特别聪明。

它在加密的时候,会考虑到很多因素,保证加密后的信息足够安全,让那些想破解的人头疼得不行。

比如说,如果有人想通过尝试不同的密钥来破解,那可就太难啦。

因为可能的密钥数量多得吓人,就像天上的星星一样数都数不过来。

再想想,如果有人想通过分析密文的规律来破解,DES 算法也早就想到了这一点。

它的加密过程设计得非常巧妙,让密文看起来几乎没有什么明显的规律可循。

不过呢,DES 算法也不是完美无缺的啦。

随着技术的不断发展,它也面临着一些挑战。

但是在它诞生的那个时候,可是为信息安全立下了汗马功劳呢!DES 算法就像是一个守护信息的小卫士,虽然它可能不像现在的一些新算法那么强大,但在密码学的历史上,它可是有着重要的地位哟!怎么样,朋友,我给你讲的 DES 算法原理有没有让你稍微明白一点呀?。

DES加密算法原理

DES加密算法原理

DES加密算法原理DES(Data Encryption Standard)是一种对称加密算法,它使用相同的密钥进行加密和解密。

DES算法的原理可以分为以下几个方面。

1.初始置换(IP):DES加密过程的第一步是对明文进行初始置换,通过将明文中的每个位按照事先规定的顺序重新排列,得到一个初始排列的明文块。

2. 轮函数(Feistel function):DES算法采用了Feistel网络结构。

在每一轮中,明文块被分成左右两部分,右半部分经过扩展运算(Expansion),将其扩展为一个48位的数据块。

然后将扩展后的数据块与轮密钥进行异或运算,得到一个48位的结果。

3. S-盒变换(S-Box substitution):接下来,经过48位结果的S-盒变换。

S-盒是DES算法的核心部分,它将6位输入映射为4位输出。

DES算法使用了8个不同的S-盒,每个S-盒都有一个4x16表格,用于将输入映射为输出。

4. P-盒置换(P-Box permutation):经过S-盒变换后,输出结果通过一个固定的P-盒进行置换运算。

P-盒操作将32位输出重新排列,得到一个新的32位结果。

5. 轮密钥生成(Key schedule):DES算法使用了16轮的加密迭代过程。

每一轮使用一个不同的48位轮密钥。

轮密钥生成过程根据初始密钥生成所有的轮密钥。

轮密钥生成包括密钥置换选择1、密钥循环移位、密钥置换选择2等步骤。

6. 最后交换(Inverse Initial Permutation):经过16轮迭代后,得到最终的加密结果。

在最后交换步骤中,将加密结果的左右两部分进行互换,得到最终的加密结果。

DES算法依靠这些步骤进行加密和解密过程。

加密过程中,明文块经过初始置换后,进入16轮的迭代过程,每一轮中使用不同的轮密钥对明文进行加密。

最后得到加密结果。

解密过程与加密过程相反,使用相同的轮密钥对密文进行解密,最终得到明文。

DES算法的安全性主要依赖于密钥的长度和轮数。

DES加密算法详解

DES加密算法详解

DES加密算法详解DES(Data Encryption Standard)是一种对称加密算法,是最早被广泛使用的加密算法之一、它于1977年被美国国家标准局(NIST)作为联邦信息处理标准(FIPS)发布,并在接下来的几十年内被广泛应用于数据加密领域。

下面将对DES加密算法进行详细解释。

DES算法使用一个56位的密钥来加密64位的数据块。

密钥经过一系列的处理后生成16个48位的子密钥,然后对数据块进行16轮的加密处理。

每轮加密又包括初始置换、扩展置换、与子密钥异或、S盒置换、P置换等步骤。

初始置换(IP)是DES算法的第一步,通过将输入的64位数据块按照特定的规则重新排列来改变其位的位置。

这样可以提高后续处理的随机性和复杂性。

扩展置换(E)是DES算法的第二步,将32位的数据块扩展成48位,并重新排列其位的位置。

这样可以增加密钥和数据的混淆度。

与子密钥异或(XOR)是DES算法的第三步,将扩展后的数据块与生成的子密钥进行异或操作。

这样可以将密钥的信息混合到数据中。

S盒置换是DES算法的核心部分,利用8个不同的4x16位置换表(S 盒)进行16次S盒置换。

S盒将6位输入映射为4位输出,通过混淆和代替的方式增加了加密的随机性。

P置换是DES算法的最后一步,在经过S盒置换后,对输出的32位数据块进行一次最终的置换。

这样可以使得密文在传输过程中更难以破解。

DES算法的解密过程与加密过程相似,只是在16轮中使用的子密钥的顺序是相反的。

解密过程中同样包括初始置换、扩展置换、与子密钥异或、S盒置换、P置换等步骤,最后经过逆初始置换得到明文。

虽然DES算法曾经是数据安全领域的标准算法,但是随着计算机计算能力的提高,DES算法的密钥长度过短(56位)容易被暴力破解,安全性逐渐变弱。

因此,在2001年,DES被高级加密标准(AES)取代,并成为新的数据加密标准。

总结来说,DES加密算法采用对称密钥体制,使用相同的密钥进行加密和解密。

DES算法的简介及编程实现

DES算法的简介及编程实现

实验一DES算法实验目的:1.深入了解DES算法的原理、特点、密钥及输入输出2.通过编程来模拟DES算法的加密及解密过程实验内容:一.D ES算法概述①DES算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。

明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位,使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

②DES算法的特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。

③DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位,整个算法的主流程图如下:二.D ES算法的编程实现#include <iostream>#include <fstream>using namespace std;const static char 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};const static char fp[] = { //最终置换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};const static char sbox[8][64] = { //s_box/* 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 };const static char rar[] = { //压缩置换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};const static char ei[] = { //扩展置换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};const static char Pzh[]={ //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};const static char Keyrar[]={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};bool key[16][48]={0},/*rekey[16][48],*/char key_in[8];void ByteToBit(bool *Out,char *In,int bits) //字节到位的转换{int i;for(i=0;i<bits;i++)Out[i]=(In[i/8]>>(i%8))&1;}void BitToByte(char *Out,bool *In,int bits) //位到字节转换{for(int i=0;i<bits/8;i++)Out[i]=0;for(i=0;i<bits;i++)Out[i/8]|=In[i]<<(i%8); //"|="组合了位操作符和赋值操作符的功能}void Xor(bool *InA,const bool *InB,int len) //按位异或{for(int i=0;i<len;i++)InA[i]^=InB[i];}void keyfc(char *In) //获取密钥函数{int i,j=0,mov,k;bool key0[56],temp,keyin[64];ByteToBit(keyin,In,64); //字节到位的转换for(i=0;i<56;i++) //密钥压缩为56位key0[i]=keyin[Keyrar[i]-1];for(i=0;i<16;i++) //16轮密钥产生{if(i==0||i==1||i==8||i==15)mov=1;elsemov=2;for(k=0;k<mov;k++) //分左右两块循环左移{for(int m=0;m<8;m++){temp=key0[m*7];for(j=m*7;j<m*7+7;j++)key0[j]=key0[j+1];key0[m*7+6]=temp;}temp=key0[0];for(m=0;m<27;m++)key0[m]=key0[m+1];key0[27]=temp;temp=key0[28];for(m=28;m<55;m++)key0[m]=key0[m+1];key0[55]=temp;}for(j=0;j<48;j++) //压缩置换并储存key[i][j]=key0[rar[j]-1];}}void DES(char Out[8],char In[8],bool MS)//加密核心程序,ms=0时加密,反之解密{bool MW[64],tmp[32],PMW[64]; //注意指针bool kzmw[48],keytem[48],ss[32];int hang,lie;ByteToBit(PMW,In,64);for(int j=0;j<64;j++){MW[j]=PMW[ip[j]-1]; //初始置换}bool *Li=&MW[0],*Ri=&MW[32];for(int i=0;i<48;i++) //右明文扩展置换kzmw[i]=Ri[ei[i]-1]; //注意指针if(MS==0) //DES加密过程{for(int lun=0;lun<16;lun++){for(i=0;i<32;i++)ss[i]=Ri[i];for(i=0;i<48;i++) //右明文扩展置换kzmw[i]=Ri[ei[i]-1]; //注意指针for(i=0;i<48;i++)keytem[i]=key[lun][i]; //轮密钥Xor(kzmw,keytem,48);/*S盒置换*/for(i=0;i<8;i++){hang=kzmw[i*6]*2+kzmw[i*6+5];lie =kzmw[i*6+1]*8+kzmw[i*6+2]*4+kzmw[i*6+3]*2+kzmw[i*6+4];tmp[i*4+3]=sbox[i][(hang+1)*16+lie]%2;tmp[i*4+2]=(sbox[i][(hang+1)*16+lie]/2)%2;tmp[i*4+1]=(sbox[i][(hang+1)*16+lie]/4)%2;tmp[i*4]=(sbox[i][(hang+1)*16+lie]/8)%2;}for(int i=0;i<32;i++) //P置换Ri[i]=tmp[Pzh[i]-1];Xor(Ri,Li,32); //异或for(i=0;i<32;i++) //交换左右明文{Li[i]=ss[i];}}for(i=0;i<32;i++){tmp[i]=Li[i];Li[i]=Ri[i];Ri[i]=tmp[i];}for(i=0;i<64;i++)PMW[i]=MW[fp[i]-1];BitToByte(Out,PMW,64); //位到字节的转换}else //DES解密过程{for(int lun=15;lun>=0;lun--){for(i=0;i<32;i++)ss[i]=Ri[i];for(int i=0;i<48;i++) //右明文扩展置换kzmw[i]=Ri[ei[i]-1]; //注意指针for(i=0;i<48;i++)keytem[i]=key[lun][i]; //轮密钥Xor(kzmw,keytem,48);/*S盒置换*/for(i=0;i<8;i++){hang=kzmw[i*6]*2+kzmw[i*6+5];lie =kzmw[i*6+1]*8+kzmw[i*6+2]*4+kzmw[i*6+3]*2+kzmw[i*6+4];tmp[i*4+3]=sbox[i][(hang+1)*16+lie]%2;tmp[i*4+2]=(sbox[i][(hang+1)*16+lie]/2)%2;tmp[i*4+1]=(sbox[i][(hang+1)*16+lie]/4)%2;tmp[i*4]=(sbox[i][(hang+1)*16+lie]/8)%2;}for(i=0;i<32;i++) //P置换Ri[i]=tmp[Pzh[i]-1];Xor(Ri,Li,32); //异或for(i=0;i<32;i++) //交换左右明文{Li[i]=ss[i];}}for(i=0;i<32;i++){tmp[i]=Li[i];Li[i]=Ri[i];Ri[i]=tmp[i];}for(i=0;i<64;i++)PMW[i]=MW[fp[i]-1];BitToByte(Out,PMW,64); //位到字节的转换}}void main(){char Ki[8],jm[8],final[8];int i0;cout<<"请输入密钥(8字节):"<<endl;for(i0=0;i0<8;i0++)cin>>Ki[i0];keyfc(Ki);cout<<"请输入明文:"<<endl;for(i0=0;i0<8;i0++)cin>>jm[i0];DES(final,jm,0);cout<<"加密后:"<<endl;//加密for(i0=0;i0<8;i0++)cout<<final[i0];cout<<endl;cout<<"解密后:"<<endl;DES(jm,final,1); //解密for(i0=0;i0<8;i0++)cout<<jm[i0];cout<<endl;}三.实例描述1.加密字母,运行结果如下:2.加密汉字,运行结果如下:四.D ES算法的安全性DES算法为密码体制中的对称密码体制。

DES加密的算法

DES加密的算法

信息安全概论·课程设计DES加密的C语言实现目录摘要....................................................... 错误!未定义书签。

Abstract ................................................... 错误!未定义书签。

关键词..................................................... 错误!未定义书签。

1.算法描述................................................ 错误!未定义书签。

1.1加/解密算法的一般原理............................... 错误!未定义书签。

1.2加/解密机制的应用................................... 错误!未定义书签。

2.S盒设计................................................ 错误!未定义书签。

3.DES程序实例与分析...................................... 错误!未定义书签。

4.DES实例运行结果........................................ 错误!未定义书签。

5.结语.................................................... 错误!未定义书签。

6.参考文献................................................. 错误!未定义书签。

信息安全概论·课程设计DES加密的C语言实现C language achieve DES algorithm摘要DES算法是一种数据加密算法,自从1977年公布以来,一直是国际上的商用保密通信和计算机通信的最常用的加密标准。

des密码算法程序c语言

des密码算法程序c语言

des密码算法程序c语言一、概述DES(数据加密标准)是一种常用的对称加密算法,它采用64位的密钥,对数据进行加密和解密。

本程序使用C语言实现DES算法,包括密钥生成、数据加密和解密等操作。

二、算法实现1.密钥生成:使用初始置换算法IP(56位)将明文转化为56位的分组,再将该分组经过一系列的逻辑函数F进行6轮处理,最终生成一个56位的密文。

其中密钥包括56位数据位和8位奇偶校验位。

2.数据加密:将需要加密的数据转化为56位的分组,再经过DES 算法处理,得到密文。

3.数据解密:将密文经过DES算法处理,还原成原始明文。

三、程序代码```c#include<stdio.h>#include<string.h>#include<stdlib.h>#include<time.h>//DES算法参数定义#defineITERATIONS6//加密轮数#defineKEY_LENGTH8//密钥长度,单位为字节#defineBLOCK_SIZE8//数据分组长度,单位为字节#definePADDINGPKCS7Padding//填充方式#defineMAX_INPUT_LENGTH(BLOCK_SIZE*2)//数据输入的最大长度//初始置换函数voidinit_permutation(unsignedcharinput[BLOCK_SIZE]){inti;for(i=0;i<BLOCK_SIZE;i++){input[i]=i;}}//逻辑函数F的定义voidlogic_function(unsignedcharinput[BLOCK_SIZE],unsigned charoutput[BLOCK_SIZE]){inti;for(i=0;i<BLOCK_SIZE;i++){output[i]=input[(i+1)%BLOCK_SIZE]^input[i]^(i+1)/BLOCK_SI ZE;}}//DES算法主函数voiddes_encrypt(unsignedchar*input,unsignedchar*output){ unsignedcharkey[KEY_LENGTH];//密钥数组unsignedchariv[BLOCK_SIZE];//初始置换的输入数组unsignedcharciphertext[MAX_INPUT_LENGTH];//密文数组unsignedcharpadding[BLOCK_SIZE];//填充数组unsignedintlength=strlen((char*)input);//数据长度(以字节为单位)unsignedintpadding_length=(length+BLOCK_SIZE-1)%BLOCK_SIZE;//需要填充的字节数unsignedintround=0;//加密轮数计数器unsignedintj=0;//数据指针,用于循环读取数据和填充数据intkey_offset=((1<<(32-KEY_LENGTH))-1)<<(32-(ITERATIONS*BLOCK_SIZE));//密钥索引值,用于生成密钥数组和填充数组的初始值unsignedintk=0;//DES算法中每个轮次的密钥索引值,用于生成每个轮次的密钥数组和填充数组的值unsignedintkplus1=(k+1)%((1<<(32-BLOCK_SIZE))-1);//DES算法中每个轮次的密钥索引值加一后的值,用于下一个轮次的密钥生成charseed[32];//使用MD5作为初始种子值生成随机数序列chartmp[MAX_INPUT_LENGTH];//临时变量数组,用于数据交换和中间计算结果存储等操作time_tt;//时间戳变量,用于生成随机数序列的种子值srand((unsignedint)time(&t));//设置随机数种子值,确保每次运行生成的随机数序列不同init_permutation(iv);//初始置换操作,将输入数据转化为56位分组(需要重复填充时)或一个随机的分组(不需要重复填充时)memcpy(key,key_offset,sizeof(key));//将初始化的密钥数组复制到相应的位置上,以便于接下来的轮次生成不同的密钥值memcpy(padding,seed,sizeof(seed));//将种子值复制到填充数组中,以便于接下来的轮次生成不同的随机数序列值for(round=0;round<ITERATIONS;round++){//进行加密轮次操作,每轮包括。

DES算法的实现及安全性分析

DES算法的实现及安全性分析

DES算法的实现及安全性分析DES(Data Encryption Standard)是一种对称加密算法,用于加密和解密数据。

DES是一种块加密算法,将输入数据分成64位的块进行加密,输出64位的密文。

DES算法使用一个64位的密钥来加密和解密数据,这个密钥包含56位的有效位和8位的奇偶校验位。

在DES算法中,加密和解密使用相同的密钥。

1.原始数据处理:如果数据长度不是64位的倍数,需要进行填充操作,通常使用0填充。

2.密钥生成:根据输入密钥,生成加密和解密使用的子密钥。

DES算法使用56位的原始密钥生成16个48位的子密钥,每个子密钥用于单个加密轮次。

3.初始置换:将64位输入数据按照DES算法的规则进行初始置换。

4.16轮加密:将初始置换后的数据分为左右两部分,每一轮使用一轮加密函数对左半部分进行处理,并将结果与右半部分异或,然后将左右部分交换。

5.逆初始置换:经过16轮加密后的数据进行逆初始置换,得到加密后的64位密文。

6.解密:将加密后的密文按照相反的顺序使用16轮解密函数进行解密处理,得到解密后的原始数据。

DES算法的安全性主要基于密钥长度和算法结构。

DES密钥长度较短,只有56位有效位,因此在今天的计算能力下,使用穷举法破解DES密码是可行的。

此外,DES算法的结构已经被一些攻击方法所破解,例如差分攻击和线性攻击。

为了解决DES算法的安全性问题,目前使用更加安全和强大的替代算法,例如AES(Advanced Encryption Standard)算法。

AES算法使用128位、192位或256位的密钥长度,提供了更高的安全性。

AES已经成为目前最广泛使用的对称加密算法之一总的来说,DES算法在当今的环境中已经不够安全,因为其密钥长度较短,结构容易受到攻击。

建议在实际应用中使用更加安全的替代算法,如AES算法。

如果有特殊需求要使用DES算法,可以考虑使用3DES (Triple DES)算法,即对数据进行三次DES加密。

DES加密算法的JAVA实现

DES加密算法的JAVA实现

DES加密算法的JAVA实现DES是一种对称加密算法,它将明文划分为64位的数据块,并对每个数据块进行一系列的转换和替代操作,最终生成密文。

在Java中,可以使用javax.crypto包提供的API来实现DES加密算法。

首先,需要导入javax.crypto包和java.security包。

```javaimport javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import java.security.Key;``````javapublic class DESUtilprivate static final String ALGORITHM = "DES";public static Key generateKey(byte[] keyData) throws Exceptionreturn new SecretKeySpec(keyData, ALGORITHM);}```接下来,我们需要编写加密和解密的方法。

```javapublic class DESUtil//...public static byte[] encrypt(byte[] data, Key key) throws ExceptionCipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, key);return cipher.doFinal(data);}public static byte[] decrypt(byte[] encryptedData, Key key) throws ExceptionCipher cipher = Cipher.getInstance(ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, key);return cipher.doFinal(encryptedData);}```在上述代码中,encrypt方法用于将明文数据加密成密文,decrypt 方法用于将密文数据解密成明文。

des密码算法的设计和实现

des密码算法的设计和实现

des密码算法的设计和实现
DES密码算法的设计和实现可以归纳为以下几个主要步骤:
1. 建立总体结构:DES算法以64位为分组长度,64位一组的明文作为算法的输入,通过一系列复杂的操作,输出同样64位长度的密文。

DES使用加密密钥定义变换过程,因此算法认为只有持有加密所用的密钥的用户才能解密密文。

DES的采用64位密钥,但由于每8位中的最后1位用于奇偶校验,实际有效密钥长度为56位。

2. 数据填充:为了使DES算法的输入数据长度达到64位,需要对输入数据进行数据填充。

数据填充过程是在每个输入的64位数据块中添加56位零,然后将输入数据块分成两个32位块。

3. 初始置换:输入的64位数据块经过初始置换后,生成56位输出。

置换规则是将输入数据块的第8、16、24、32、40、48、56、64位置换为第7、9、11、13、27、29、31、33位。

4. 生成子密钥:子密钥是通过一系列的置换和代换操作生成的。

首先对56位密钥进行置换,然后进行16轮相同的运算,每一轮都涉及置换、代换、S盒置换、P盒置换和异或等操作。

5. 加密运算:加密运算包括16轮相同的运算,每一轮都涉及置换、代换、S盒置换、P盒置换和异或等操作。

6. 逆置换:最后一轮加密运算后,再进行一次逆置换,置换规则与初始置换相反。

以上是DES密码算法的设计和实现的主要步骤。

需要注意的是,在实现过程中需要遵循相应的安全性和正确性原则,例如在加密和解密过
程中使用相同的秘钥,以及在数据填充和逆置换过程中保持数据的完整性等。

如需更多关于DES密码算法的细节,建议查阅密码学相关书籍或咨询专业人士。

des加密算法python代码

des加密算法python代码

序号1:什么是DES加密算法?DES(Data Encryption Standard)是一种对称密钥加密算法,由IBM研制并于1977年被美国国家标准局(NBS)确定为联邦数据处理标准(FIPS)的一部分。

DES算法使用56位的密钥对64位的数据进行加密,经过多轮的置换、替换和移位运算后,得到密文。

DES算法已经被AES算法所代替,但在一些旧系统中仍然在使用。

序号2:DES加密算法的Python实现下面是一个简单的使用Python实现DES加密算法的例子:```pythonfrom Crypto.Cipher import DESfrom Crypto.Random import get_random_bytesdef des_encrypt(key, data):cipher = DES.new(key, DES.MODE_ECB)padded_data = data + b'\0' * (8 - len(data) % 8)encrypted_data = cipher.encrypt(padded_data)return encrypted_datadef des_decrypt(key, encrypted_data):cipher = DES.new(key, DES.MODE_ECB)decrypted_data = cipher.decrypt(encrypted_data).rstrip(b'\0') return decrypted_datakey = get_random_bytes(8)data = b'This is a test'encrypted_data = des_encrypt(key, data)decrypted_data = des_decrypt(key, encrypted_data)print('Original data:', data)print('Encrypted data:', encrypted_data)print('Decrypted data:', decrypted_data)```序号3:代码解读3.1 导入必要的模块```pythonfrom Crypto.Cipher import DESfrom Crypto.Random import get_random_bytes```在这行代码中,我们使用了`Crypto.Cipher`模块中的DES类和`Crypto.Random`模块的`get_random_bytes`函数。

DES算法的原理与实现

DES算法的原理与实现

实验项目与实验报告( 2 )即将输入的第58位换到第一位,第50位换到第2位,...,依此类推,最后一位是原来的第7位。

L0、R0则是换位输出后的两部分,L0是输出的左32位,R0 是右32位,例:设置换前的输入值为D1D2D3......D64,则经过初始置换后的结果为:L0=D58D50...D8;R0=D57D49 (7)经过16次迭代运算后。

得到L16、R16,将此作为输入,进行逆置换,即得到密文输出。

逆置换正好是初始置换的逆运算。

例如,第1位经过初始置换后,处于第40位,而通过逆置换,又将第40位换回到第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,(2)放大换位表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,(3)单纯换位表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,(4)功能表在f(Ri,Ki)算法描述图中,S1,S2...S8为选择函数,其功能是把48bit数据变为32bit数据。

下面给出选择函数Si(i=1,2......8)的功能表:选择函数SiS1: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,在此以S1为例说明其功能,我们可以看到:在S1中,共有4行数据,命名为0,1、2、3行;每行有16列,命名为0、1、2、3,......,14、15列。

数据加密算法--详解DES加密算法原理与实现

数据加密算法--详解DES加密算法原理与实现

数据加密算法--详解DES加密算法原理与实现DES算法简介DES(Data Encryption Standard)是⽬前最为流⾏的加密算法之⼀。

DES是对称的,也就是说它使⽤同⼀个密钥来加密和解密数据。

DES还是⼀种分组加密算法,该算法每次处理固定长度的数据段,称之为分组。

DES分组的⼤⼩是64位,如果加密的数据长度不是64位的倍数,可以按照某种具体的规则来填充位。

从本质上来说,DES的安全性依赖于虚假表象,从密码学的术语来讲就是依赖于“混乱和扩散”的原则。

混乱的⽬的是为隐藏任何明⽂同密⽂、或者密钥之间的关系,⽽扩散的⽬的是使明⽂中的有效位和密钥⼀起组成尽可能多的密⽂。

两者结合到⼀起就使得安全性变得相对较⾼。

DES算法具体通过对明⽂进⾏⼀系列的排列和替换操作来将其加密。

过程的关键就是从给定的初始密钥中得到16个⼦密钥的函数。

要加密⼀组明⽂,每个⼦密钥按照顺序(1-16)以⼀系列的位操作施加于数据上,每个⼦密钥⼀次,⼀共重复16次。

每⼀次迭代称之为⼀轮。

要对密⽂进⾏解密可以采⽤同样的步骤,只是⼦密钥是按照逆向的顺序(16-1)对密⽂进⾏处理。

计算16个⼦密钥上⾯提到DES算法的第⼀步就是从初始密钥中计算得出16个⼦密钥。

图⽰1展⽰了这个过程。

DES使⽤⼀个56位的初始密钥,但是这⾥提供的是⼀个64位的值,这是因为在硬件实现中每8位可以⽤于奇偶校验,在软件实现中多出的位只是简单的忽略掉。

要获得⼀个56位的密钥,可以执照表1的⽅式执⾏密钥转换。

解释⼀下表1,按照从左往右从上往下的⽅式看,表格中每个位置P包含初始密钥中位在转换后的密钥中所占的位置。

⽐如,初始密钥中的第57位就是转换后的密钥中的第1位,⽽初始密钥中的第49位则变成转换后的密钥中的第2位,以此类推...。

(数据位的计数顺序按照从左到右从1开始的)表1:DES中密钥的转换表(DesTransform[56])将密钥转换为56位后,接下来计算⼦密钥。

DES算法实现课程设计

DES算法实现课程设计
因此,DES算法已经被更安全的加密算法所取代,如AES算法等
增加密钥长度:提高密钥长度可以增加破解难度,提高安全性
采用多轮加密:多轮加密可以提高安全性,防止攻击者破解
采用随机数生成器:随机数生成器可以提高安全性,防止攻击者预测密钥
采用分组密码:分组密码可以减少密钥长度,提高安全性
C语言具有高效的执行效率,适合实现高性能的加密算法
添加标题
添加标题
添加标题
添加标题
初始置换:将明文进行初始置换,得到初始置换后的明文
输入明文:将明文转换为二进制数据
16轮迭代:对初始置换后的明文进行16轮迭代,每轮迭代包括选择、扩展、置换和异或操作
输出密文:将迭代后的明文进行输出置换,得到密文
安全性高:采用分组密码体制,密钥长度可变,加密速度快
初始置换使用56个置换盒,每个置换盒有4行和16列
每个置换盒中的元素按照一定的规则进行排列,形成初始置换表
初始置换的目的是为了增加明文的复杂度,提高加密的安全性
初始化密钥:生成64位密钥
初始置换:将64位密钥转换为56位密钥
16轮迭代:每轮进行一轮加密操作
逆初始置换:将56位密钥转换为64位密钥
输出加密结果:得到加密后的数据
扩展:将输入数据扩展为48位
安全性改进:3DES算法通过增加密钥长度提高安全性
加密强度:56位密钥,理论上可以抵抗暴力破解
安全性分析:存在弱密钥和半弱密钥问题,可能导致破解
安全性评估:在现代计算能力下,DES算法的安全性已经降低
数据加密:DES算法广泛应用于数据加密,如电子邮件、文件传输等。
身份验证:DES算法可以用于身份验证,如登录密码、数字签名等。
Python的语法简洁明了,易于理解和实现

DES加密解密算法的实现

DES加密解密算法的实现

DES加密解密算法的实现DES(Data Encryption Standard)是一种对称加密算法,用于加密和解密数据。

其基本原理是通过使用密钥将明文数据转换为密文数据,并使用相同的密钥将密文数据还原为明文数据。

DES算法采用了分组加密的方式,将明文数据分为固定大小的数据块,并对每个数据块进行加密。

DES算法的实现包括了三个主要步骤:初始置换、16轮迭代加密和最终置换。

下面将详细介绍DES加密解密算法的实现步骤。

1. 初始置换(Initial Permutation):初始置换是将明文数据进行重排,以增加加密的随机性。

它通过将明文数据按照规定的顺序排列成新的数据,作为加密的初始输入。

2. 16轮迭代加密(16 Rounds of Iterative Encryption):DES算法将明文数据进行16轮的迭代加密。

每一轮加密包括了四个主要步骤:逐位扩展(Expansion Permutation)、密钥混淆(Key Mixing)、S盒替代和P盒置换。

- 逐位扩展(Expansion Permutation):逐位扩展将32位的数据扩展为48位的数据,以提供更高的密钥强度,并增加加密的随机性。

- 密钥混淆(Key Mixing):密钥混淆是将48位的数据与密钥进行异或运算,以增加加密的复杂性。

- S盒替代(S-Box Substitution):S盒替代是将48位的数据分成8个6位的数据块,并根据S盒中预先定义的替代规则进行替代。

S盒替代是DES算法的核心步骤,它对密文数据进行非线性转换,增加了加密的强度。

- P盒置换(P-Box Permutation):P盒置换是将32位的数据按照规定的顺序进行重排,以增加加密的随机性。

3. 最终置换(Final Permutation):最终置换是将经过16轮迭代加密后的数据进行一个最终的变换,以得到加密的最终输出。

最终置换和初始置换相反,将经过加密处理的数据重新排列成最终输出。

des子密钥生成算法实现

des子密钥生成算法实现

des子密钥生成算法实现
DES算法,英文全称为Data Encryption Standard,即为“数据加密标准”。

该算法的加密和解密过程都是基于密钥进行的,因此密钥的安全性至关重要。

为了确保加密过程的安全性,DES算法对密钥进行了复杂的生成方式。

DES算法的密钥长度为64位,虽然DES算法被认为是一种强加密算法,但由于密钥长度较短,因此仍具有一定的被破解的可能性。

为了增强密码强度,可以采用“三重DES”或“高级加密标准(AES)”等更为安全的加密算法。

DES算法中的密钥生成算法是为了生成子密钥,该过程一般分为三个步骤:
1. 使用密钥置换表进行密钥置换:将64位的密钥按照密钥置换表进行置换,得到56位的密钥。

2. 对56位的密钥进行分组操作:将56位的密钥分成两个28位的半密钥,分别称为左半密钥和右半密钥。

3. 对左、右半密钥进行移位和置换操作:经过16轮迭代操作,将左、右半密钥进行不同方式的移位、置换和替换操作,最终生成16个48位的子密钥。

在DES算法中,密钥生成算法的实现是非常重要的,它决定了加密效果的好坏和安全性的高低。

在进行DES算法加密过程之前,密钥的生成和保护工作必须得到充分的重视。

总之,密钥生成算法是DES算法中的重要一环,它能够保证加密过程的安全性并增强密钥的复杂度。

在实际应用中,可根据需求采用更为安全的加密算法,确保数据的安全。

des算法的基本原理和步骤

des算法的基本原理和步骤

des算法的基本原理和步骤DES 算法呀,就像是一个神秘的密码盒子。

它的基本原理呢,就是通过一系列复杂的操作来对信息进行加密和解密。

想象一下,我们有一串明文,就好像是一件宝贝,我们要把它藏起来不让别人轻易发现。

DES 算法就像是一个神奇的魔法师,通过一系列独特的步骤来给这件宝贝披上一层神秘的外衣。

第一步呢,就像是给宝贝穿上一件特制的衣服。

它会对明文进行初始置换,让明文的排列发生变化。

这就好像是把宝贝打乱了顺序,让别人一下子摸不着头脑。

接下来呀,进入到了一轮又一轮的复杂运算中。

这就好比是在给宝贝设置层层关卡,每一轮都有独特的操作和变换。

就像走迷宫一样,让试图破解的人晕头转向。

然后呢,还有密钥的参与。

这密钥就像是打开密码盒子的钥匙,只有拥有正确的密钥,才能顺利地解开加密后的信息。

要是没有这把钥匙,那可就像是在黑暗中摸索,怎么也找不到出路。

在加密的过程中,DES 算法会不断地变换、计算,把明文变得面目全非。

这可真是神奇啊!等需要解密的时候呢,再按照相反的步骤,用正确的密钥一步步还原出原来的明文。

你说这是不是很厉害?它就像是一个保护我们信息安全的卫士,默默地守护着我们的秘密。

在当今这个信息时代,DES 算法可发挥了大作用呢!它让我们在网络世界里能够放心地交流和传递信息,不用担心被别人轻易窃取。

你看,银行转账、网上购物等等这些涉及到我们重要信息的地方,都有 DES 算法的身影。

它就像是一个隐形的保镖,时刻保护着我们的财产安全和隐私。

所以啊,了解 DES 算法的基本原理和步骤可真是太重要啦!这不仅能让我们更好地理解信息安全的重要性,还能让我们对现代科技的神奇之处有更深刻的认识。

我们可不能小瞧了这个小小的算法,它背后蕴含的智慧和力量可不容小觑呢!难道不是吗?。

DES算法的实现步骤

DES算法的实现步骤

DES算法的实现步骤DES(Data Encryption Standard)是一种对称加密算法,也是目前应用最广泛的加密算法之一、它采用分组密码的方式,将明文划分为64位的块,通过一系列的置换、代替和置换运算,将明文转换为密文。

下面是DES算法的实现步骤:1. 明文处理(Initial Permutation):将明文进行初始置换,将每一位按照指定的映射表进行重新排列,得到初始置换后的明文。

2.分组:将初始置换后的明文按照64位一组进行分组,若明文长度不是64位的倍数,则需要进行填充。

3. 密钥生成(Key Generation):从初始密钥生成16个48位的子密钥,每个子密钥应用到轮函数时进行异或操作。

4. 轮函数(Round Function):每个分组进行16轮的加密,每轮将待加密分组的左右两半部分进行交换,并通过扩展、代替、置换等操作生成新的右半部分。

5. 扩展置换(Expansion Permutation):将32位的右半部分扩展为48位,使用扩展置换表将每一位重排。

6. 轮密钥加(Round Key Addition):将扩展置换后的32位结果与当前轮使用的子密钥进行异或操作。

7. S-盒代替(S-Box Substitution):将异或后的48位输入分为8组6位,通过8个S-盒进行代替,每个S-盒都将6位输入映射为4位输出。

8. P-盒置换(Permutation):将S-盒代替后的32位输出通过P-盒进行置换,重排其位置。

9.循环:将经过P-盒置换后的32位输出与初始分组的左半部分进行异或操作,得到新的左半部分。

10.左右交换:将经过循环处理后的左右半部分进行交换,左半部分变为新的右半部分,右半部分变为新的左半部分。

11. 密文处理(Inverse Initial Permutation):将总共经过16轮迭代处理后的左右半部分进行交换,并进行逆初始置换,得到最终的密文。

12.密文输出:将逆初始置换后的结果作为最终的密文输出。

DES加密算法实验原理

DES加密算法实验原理

DES加密算法实验原理DES(Data Encryption Standard)是一种对称加密算法,它的原理是通过将明文划分为64位的数据块,并对每个数据块进行一系列的置换和替换操作,最后输出密文。

DES算法的实验原理可以分为以下几个步骤:1. 初始置换(IP):初始置换是将明文按照固定的顺序进行置换,目的是打乱明文的次序,增加加密的难度。

初始置换表(IP Table)定义了置换的顺序和位置。

2. 生成子密钥:DES算法使用了16个48位的子密钥。

这些子密钥是通过一个称为密钥调度算法(Key Schedule)的过程生成的。

密钥调度算法将输入的64位密钥进行置换和压缩,生成48位的子密钥。

3. 轮函数(Feistel Function):DES算法使用了16轮的轮函数加密过程。

每轮的输入由上一轮的输出和相应的轮子密钥产生。

轮函数包括以下几个步骤:a. 将32位的输入数据进行扩展置换(Expansion Permutation),得到48位的输出。

b.将扩展置换的输出与轮子密钥进行异或运算。

c.将异或结果分为8个6位的块,通过8个S盒进行替换操作。

每个S盒都是一个4x16的置换表,根据输入的6位数据得到4位的输出。

d. 将替换操作后的结果进行置换置换(Permutation),得到32位的输出。

4. 最终置换(IP-1):最终置换是对最后一轮轮函数的输出进行逆操作,得到最终的密文。

最终置换使用的是与初始置换相反的置换表(IP-1 Table)。

DES算法最终输出的密文是通过16轮轮函数的加密过程得到的。

每一轮轮函数的输入是上一轮轮函数的输出和相应的轮子密钥的异或结果。

每次轮函数的加密过程都会增加密文的复杂度,提高加密算法的安全性。

DES算法的安全性主要依赖于密钥的保密性和密钥长度。

由于DES算法使用的是56位的密钥,随着计算机计算能力的提高,DES算法的安全性逐渐变得不足。

因此,现在更常用的加密算法是AES(Advanced Encryption Standard),它使用128位、192位或256位的密钥,具有更高的加密强度。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

常州工学院计算机信息工程学院《数据结构》课程设计报告题目DES加密算法的实现班级 14软一学号姓名王磊(组长)学号姓名王凯旋学号姓名陶伟2016年01 月06日一,实验名称:DES加密算法的实现二,实验内容:a)熟悉DES算法的基本原理;b)依据所算则的算法,编程实现该该算法;c)执行程序并分析结果;三,实验原理1,概述DES是一种分组加密算法,他以64位为分组对数据加密。

64位一组的明文从算法的一端输入,64位的密文从另一端输出。

DES是一个对称算法:加密和解密用的是同一个算法(除密钥编排不同以外)。

密钥的长度为56位(密钥通常表示为64位的数,但每个第8位都用作奇偶检验,可以忽略)。

密钥可以是任意的56位数,且可以在任意的时候改变。

DES算法的入口参数有3个:Key,Data,Mode。

其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或解密的数据:Mode为DES的工作方式,有两种:加密或解密。

DES算法的工作过程:若Mode为加密,则用Key对数据Data进行加密,生成Data的密码形式(64位)作为DES的输出结果;若Mode 为解密,则用Key对密码形式的数据Data解密,还原为Data的明码形式(64位)作为DES的输出结果。

2,DES算法详述DES算法把64位的明文输入块变为64位的密文输出块,他所使用的密钥也是64位,DES对64 位的明文分组进行操作。

通过一个初始置换,将明文分组分成左半部分和右半部分,各32位长。

然后进行16轮相同的运算,这些相同的运算被称为函数f,在运算过程中数据和密钥相结合。

经过16轮运算后左、右部分在一起经过一个置换(初始置换的逆置换),这样算法就完成了。

(1)初始置换其功能是把输入的64位数据块按位重新组合,并把输出分为L0,R0两部分,每部分各长32位,即将输入的第58位换到第1位,第50位换到第2位,…,依次类推,最后一位是原来的第7位,L0,R0则是换位输出后的两部分,L0是输出的左32位,R0是右32位。

(2)逆置换经过16次迭代运算后,得到L16,R16,将此作为输入进行逆置换,即得到密文输出。

逆置换正好是初始置换的逆运算。

例如,第1位经过初始置换后,处于第40位,而通过逆置换,又将第40位换回到第1位。

(3)函数f(Ri,Ki)的计算“扩展置换”是将32位放大成48位,“P盒置换”是32位到32位换位,在(Ri,Ki)算法描述图中,选择函数功能是把6 b数据变为4 b数据。

(4)子密钥Ki(48 b)的生成算法开始,由于不考虑每个字节的第8位,DES的密钥从64位变为48位,如表6所示,首先56位密钥被分成两个部分,每部分28位,然后根据轮数,两部分分别循环左移l或2位。

DES算法规定,其中第8,16,…,64位是奇偶校验位,不参与DES 运算。

故Key实际可用位数只有56位。

即:经过密钥置换表的变换后,Key的位数由64位变成了56位,此56位分为C 0,D0两部分,各28位,然后分别进行第一次循环左移,得到C1,D1,将C1(28位),D1(28位 )合并得到56位,再经过压缩置换,从而便得到了密钥K0(48位)。

依次类推,便可得到K1,K 2,…,K15。

需要注意的是,16次循环左移对应的左移位数要依据表7所示的规则进行。

以上介绍了DES算法的加密过程。

DES算法的解密过程是一样的,区别仅在于第一次迭代时用子密钥K15,第二次是K14,…,最后一次用K0,算法本身并没有任何变化。

四,实验步骤:a)选择并熟悉一种密码算法。

b)编写概要设计,详细设计报告c)使用visual c++工具,编码.d)调试及测试五,主要程序#include<stdio.h>#include<stdlib.h>#include<string.h>void show1() //主界面{printf("\n\n\n\t\t*************** DES加密解密系统******************\n\n");printf("\t\t--------------------------------------------------\n");//printf("\t\t--------------------------------------------------\n");printf("\t\t**************************************************\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t\t1.加密\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t\t2.解密\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t\t3.退出\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t--------------------------------------------------\n");}void show2()//加密界面{printf("\n\n\n\t\t****************** DES加密**********************\n\n");printf("\t\t--------------------------------------------------\n");printf("\t\t**************************************************\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t请选择明文和密钥的输入方式:\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t1.直接输入\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t2.从文件读取\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t**\t\t3.退出\t\t\t\t**\n");printf("\t\t**\t\t\t\t\t\t**\n");printf("\t\t--------------------------------------------------\n");printf("\t\t\t选择:");}void reader(char str[30],char s[8]) //读取明文和密钥{FILE *fp;fp=fopen(str,"r");if(fp==NULL){printf("明文读取失败!\n");}else{fscanf(fp,"%s",s);}fclose(fp);}void To2Bin(char p[8],int b[64]) //将字节转换成二进制流{int i,k=0;for(i=0;i<8;i++){int j=0x80;for(;j;j>>=1){if(j&p[i]){b[k++]=1;}else{b[k++]=0;}}}}int IP_Table[64] = //初始置换(IP){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,56, 48, 40, 32, 24, 16, 8, 0,58, 50, 42, 34, 26, 18, 10, 2,60, 52, 44, 36, 28, 20, 12, 4,62, 54, 46, 38, 30, 22, 14, 6};int E_Table[] = {//扩展变换E31, 0, 1, 2, 3, 4,3, 4, 5, 6, 7, 8,7, 8, 9, 10, 11, 12,11, 12, 13, 14, 15, 16,15, 16, 17, 18, 19, 20,19, 20, 21, 22, 23, 24,23, 24, 25, 26, 27, 28,27, 28, 29, 30, 31, 0};int S_Box[8][4][16] = {//8个s盒{{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}},{{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}},{{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}},{{ 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}},{{ 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}},{{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}},{{ 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}},{{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}}};int IP_1_Table[64] =//逆初始置换IP^-1 {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,32, 0, 40, 8, 48, 16, 56, 24};int P_Table[32] =//置换运算P{15,6,19,20,28,11,27,16,0,14,22,25,4,17,30,9,1,7,23,13,31,26,2,8,18,12,29,5,21,10,3,24};int PC_1[56] ={56,48,40,32,24,16,8, //密钥置换PC_10,57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,60,52,44,36,28,20,12,4,27,19,11,3};int PC_2[48] =//密钥置换PC_2{13,16,10,23,0,4,2,27,14,5,20,9,22,18,11,3,25,7,15,6,26,19,12,1,40,51,30,36,46,54,29,39,50,44,32,47,43,48,38,55,33,52,45,41,49,35,28,31};void Replacement(int arry1[],int arry2[],int arry3[],int num)//置换函数(初始IP,逆初始IP,{int i,tmp;for(i=0;i<num;i++){tmp=arry2[i];arry3[i]=arry1[tmp];}}int move_times[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1}; //对左移位的规定void lif_move(int arry1[],int arry2[],int n) //左移位实现函数{int i;for(i=0;i<28;i++){arry2[i]=arry1[(n+i)%28];}}int K[16][48];//存放16轮子密钥int c[64];//存放明文或密文int L[17][32],R[17][32]; //存放加密过程中左右部分void SubKey(int K0[64])//子密钥产生函数{int i;int K1[56],K2[56];int C[17][28],D[17][28];Replacement(K0,PC_1,K1,56);//密钥置换PC_1for(i=0;i<28;i++)//将PC_1输出的56比特分为左右两部分{C[0][i]=K1[i];D[0][i]=K1[i+28];}i=0;while(i<16){int j;lif_move(C[i],C[i+1],move_times[i]);lif_move(D[i],D[i+1],move_times[i]);for(j=0;j<28;j++){K2[j]=C[i+1][j];K2[j+28]=D[i+1][j];}Replacement(K2,PC_2,K[i],48);//密钥置换PC_2i++;}/*printf("\n子密钥生成过程中,左边生成的值:");for(i=0;i<17;i++){int j;printf("\nC[%d]:",i);for(j=0;j<28;j++){if(j%7==0){printf(" ");}printf("%d",C[i][j]);}}printf("\n子密钥生成过程中,右边生成的值:");for(i=0;i<17;i++){int j;printf("\nD[%d]:",i);for(j=0;j<28;j++){if(j%7==0){printf(" ");}printf("%d",D[i][j]);}}*/}void S_compress(int arry[],int shc[])//S盒压缩变换,其中数组shc存放经过s盒的结果{int h,l;//行,列int sha[8]; //存放经过s盒的十进制结果int i,j;int temp[4];for(i=0;i<8;i++) //s盒压缩变换{h=arry[(1+(i*6))-1]*2 + arry[(6+(i*6))-1];l =arry[(2+(i*6))-1]*8 + arry[(3+(i*6))-1]*4 + arry[(4+(i*6))-1]*2 + arry[(5+(i*6))-1];sha[i]=S_Box[i][h][l];}for(i=0;i<8;i++){for(j=3;j>=0;j--){temp[j]=sha[i]%2;sha[i]=sha[i]/2;}for(j=0;j<4;j++){shc[4*i+j]=temp[j];}}/*printf("\n第%d次s盒的输出:",m++);for(i=0;i<32;i++){if(i%8==0){printf(" ");}printf("%d",shc[i]);}*/}void To10(int a[], int b[],int n)//二进制转十进制{int i,j;int temp;int arry[16][4];for(i=0;i<n/4;i++){for(j=0;j<4;j++){arry[i][j]=a[4*i+j];}}for (i=0;i<n/4;i++){temp=arry[i][0]*8+arry[i][1]*4+arry[i][2]*2+arry[i][3]*1;/*for(j=3;j>=0;j--){if(arry[i][j]==1){t=1;for(k=0;k<3-j;k++){t=t*2;}temp+=t;}}*/b[i]=temp;}}void To102(int a[], int b[],int n)//二进制转十进制{int i,j;int temp;int arry[8][8];int t=1,k;for(i=0;i<n/8;i++){for(j=0;j<8;j++){arry[i][j]=a[8*i+j];}}for (i=0;i<n/8;i++){temp=0;for(j=7;j>=0;j--){if(arry[i][j]==1){t=1;for(k=0;k<7-j;k++){t=t*2;}temp+=t;}}b[i]=temp;}}void F_Function(int a[32],int b[32],int n)//F函数{int i;int tmp[48];int tep[32];Replacement(a,E_Table,tmp,48);//扩展变换E /*printf("\n第%d轮E盒扩展结果:",n);for(i=0;i<48;i++){if(i%8==0)printf(" ");printf("%d",tmp[i]);}*/for(i=0;i<48;i++)//与子密钥异或{tmp[i] ^= K[n][i];}/*printf("\n进入S盒的48比特:");for(i=0;i<48;i++){if(i%6==0){printf(" ");}printf("%d",tmp[i]);}*/S_compress(tmp,tep); //压缩变换SReplacement(tep,P_Table,b,32); //置换运算P/*printf("\n第%d次P置盒输出:",l++);for(i=0;i<32;i++){if(i%8==0)printf(" ");printf("%d",b[i]);}*//*printf("\nf[%d]的输出结果:",n);for(i=0;i<32;i++){if(i%8==0){printf(" ");}printf("%d",b[i]);}*/}void Encryption(int m0[64],int c1[64]){int i,k;int arry[32];int c0[64],m1[64];Replacement(m0,IP_Table,m1,64); //初始置换IP/*printf("\n初始置换:");for(i=0;i<64;i++){if(i%8==0)printf(" ");printf("%d",m1[i]);}*/for(i=0;i<32;i++){L[0][i]=m1[i];R[0][i]=m1[i+32];}k=1;while(k<17){F_Function(R[k-1],arry,k-1);for(i=0;i<32;i++){L[k][i]=R[k-1][i];R[k][i]=L[k-1][i]^arry[i];}k++;}for(i=0;i<32;i++){c0[i]=R[16][i];c0[i+32]=L[16][i];}Replacement(c0,IP_1_Table,c1,64); //逆初始置换}void changeKey(int a[16][48]){int i,j;int tmp[16][48];for(i=0;i<16;i++){for(j=0;j<48;j++){tmp[i][j]=a[i][j];}}for(i=0;i<16;i++){for(j=0;j<48;j++){K[i][j]=tmp[15-i][j];}}}void Decryption(int c1[],int m[]){int c0[64],t[64];int i,k;int arry[32];changeKey(K);/*printf("\n交换后的密钥:\n");for(i=0;i<16;i++){printf("\n");for(j=0;j<48;j++){if(j%8==0){printf(" ");}printf("%d",K[i][j]);}}*/Replacement(c1,IP_Table,c0,64);//初始IP for(i=0;i<32;i++){L[0][i]=c0[i];R[0][i]=c0[i+32];}k=1;while(k<17){F_Function(R[k-1],arry,k-1);for(i=0;i<32;i++){L[k][i]=R[k-1][i];R[k][i]=L[k-1][i]^arry[i];}k++;}for(i=0;i<32;i++){t[i]=R[16][i];t[i+32]=L[16][i];}Replacement(t,IP_1_Table,m,64); //逆初始置换}void print() //输出函数{int i;int a[12],b[12],d[3][16];int p[64],q[64];for(i=0;i<32;i++){p[i]=L[15][i];p[32+i]=R[15][i];q[i]=R[16][i];q[i+32]=L[16][i];}To10(K[14],a,48);To10(K[15],b,48);To10(c,d[0],64);To10(p,d[1],64);To10(q,d[2],64);printf("\n\t\t15轮密钥:");for(i=0;i<12;i++){printf("%x",a[i]);}printf("\t15轮结果:");for(i=0;i<16;i++){printf("%X",d[1][i]);}printf("\n\t\t16轮密钥:");for(i=0;i<12;i++){printf("%X",b[i]);}printf("\t16轮结果:");for(i=0;i<16;i++){printf("%X",d[2][i]);}printf("\n\t\t最后结果:");for(i=0;i<16;i++){printf("%X",d[0][i]);}/*printf("\n最后结果二进制:");for(i=0;i<64;i++){printf("%d",c[i]);}*/}int main(){int num,i,t;char s1[8],s2[8];int m[64]; //m存放二进制明文/密文int d[64]; //存放二进制密钥int s[8];show1();printf("\t\tinput you choice:");while(1){scanf("%d",&num);switch(num){case 1:system("cls");//调用清屏函数show2();{scanf("%d",&num);if(num==1){while(strlen(s1)!=8){printf("\t\t请输入明文(8):");scanf("%s",s1);}To2Bin(s1,m);//将明文转换成二进制流while(strlen(s2)!=8){printf("\t\t请输入密钥(8):");scanf("%s",s2);}To2Bin(s2,d);//将密钥转换成二进制/*printf("\n初始二进制明文:");for(i=0;i<64;i++){printf("%d",m[i]);}*//*printf("\n初始二进制密钥:");for(i=0;i<64;i++){printf("%d",d[i]);}*/SubKey(d);/*printf("\n16轮子密钥如下:");for(i=0;i<16;i++){printf("\nK[%d]:",i+1);for(j=0;j<48;j++){if(j%8==0)printf(" ");printf("%d",K[i][j]);}}*/Encryption(m,c);/*printf("\n16次迭代左结果:");for(i=0;i<17;i++){printf("\nL[%d]:",i);for(j=0;j<32;j++){if(j%8==0){printf(" ");}printf("%d",L[i][j]);}}printf("\n16次迭代右结果:");for(i=0;i<17;i++){printf("\nR[%d]:",i);for(j=0;j<32;j++){if(j%8==0){printf(" ");}printf("%d",R[i][j]);}}*/print();/*printf("\n二进制密文:");for(i=0;i<64;i++){printf("%d",c[i]);}*/printf("\n\t\t按0将此密文解密,1返回上一层,2返回主界面,其他键退出.....");scanf("%d",&t);if(t==0){int s[8];int a[64];Decryption(c,a);/*printf("\n解密后的二进制:");for(i=0;i<64;i++){printf("%d",a[i]);}*/To102(a,s,64);printf("\n\t\t解密结果:");for(i=0;i<8;i++){printf("%c",s[i]);printf("\n\t\t按1加密,2解密,3退出");}else if(t==1){system("cls");show2();}else if(t==2){system("cls");show1();}else{exit(0);}}else if(num==2){char str1[20],str2[20];printf("\t\t请输入明文文件名:");scanf("%s",str1);reader(str1,s1);To2Bin(s1,m);printf("\t\t请输入密钥文件名:");scanf("%s",str2);reader(str2,s2);To2Bin(s2,d);SubKey(d);Encryption(m,c);print();printf("\n\t\t按0将此密文解密,1将密文存入文件,2返回主界面,其他键退出.....");scanf("%d",&t);if(t==0){int a[64];Decryption(c,a);/*printf("\n解密后的二进制:");for(i=0;i<64;i++){printf("%d",a[i]);To102(a,s,64);printf("\n\t\t解密结果:");for(i=0;i<8;i++){printf("%c",s[i]);}printf("\n\t\t按1加密,2解密,3退出");}else if(t==1){int a[16];char str[30];FILE *fw;printf("\n\t\t请输入文件名:");scanf("%s",str);fw=fopen(str,"w");if(fw==NULL){printf("\n\t\t文件打开失败!\n");}else{To10(c,a,64);for(i=0;i<16;i++){fprintf(fw,"%X",a[i]);}}fclose(fw);printf("\n\t\t密文保存成功!按1加密,2解密,3退出");}else if(t==2){system("cls");show1();}else{exit(0);}}else if(num==3){system("cls");exit(0);}else{printf("\n\t\t输入不正确,请重新输入:");}}break;case 2:{system("cls");printf("\n\n\t\t------------------DES解密----------------");while(strlen(s1)!=8){printf("\n\n\n\t\t请输入密文(8):");scanf("%s",s1);}To2Bin(s1,m);while(strlen(s2)!=8){printf("\t\t请输入密钥(8):");scanf("%s",s2);}To2Bin(s2,d);SubKey(d);Decryption(m,c);print();printf("\n\t\t按1返回上一层,2返回主界面,其他键退出.....");scanf("%d",&t);if(t==1){system("cls");printf("\n\n\t\t---------------DES解密-------------");while(strlen(s1)!=8){printf("\n\n\t\t请输入密文(8):");scanf("%s",s1);}To2Bin(s1,m);while(strlen(s2)!=8){printf("\t\t请输入密钥(8):");scanf("%s",s);}To2Bin(s2,d);SubKey(d);Decryption(m,c);print();}else if(t==2){system("cls");show1();}else{exit(0);}}break;case 3:system("cls");exit(0);default:printf("输入不正确,请重新输入:");}}return 0;}说明:程序中有大部分的注释代码,去掉注释可查看各部分中间结果,如:十六轮子密钥,十六轮结果等。

相关文档
最新文档