当前位置：文档之家 › DES加解密过程和实现

DES加解密过程和实现

  • 格式：doc
  • 大小：202.04 KB
  • 文档页数：15

********************本科生作业********************兰州理工大学计算机与通信学院2017年春季学期信息安全课程专业：物联网工程姓名：学号：授课教师：**成绩：DES加解密过程及其实现1 DES加解密原理DES算法为密码体制中的对称密码体制，又被称为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。

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

其入口参数有三个：key、data、mode。

key为加密解密使用的密钥，data为加密解密的数据，mode为其工作模式。

当模式为加密模式时，明文按照64位进行分组，形成明文组，key 用于对数据加密，当模式为解密模式时，key用于对数据解密。

实际运用中，密钥只用到了64位中的56位，这样才具有高的安全性。

1.1 DES算法总体描述及流程图DES是一个分组加密算法，它以64位为分组对数据加密。

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

它是一个对称算法：加密和解密用的是同一个算法。

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

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

对于任意的加密方案，总有两个输入：明文和密钥。

DES的明文长为64位，密钥长为56位。

明文的处理一般经过三个阶段：首先，64位的明文经过初始置换（IP）而被重新排列。

然后经历16轮相同函数的作用，每轮作用都有置换和代替。

最后一轮迭代的输出有64位，它是输入明文和密钥的函数。

其左半部分和右半部分互换产生预输出。

最后预输出再被与初始置换（IP）互逆的置换产生64位的密文。

DES算法只不过是加密的两个基本技术——混乱和扩散的组合，即先代替后置换，它基于密钥作用于明文，这是一轮(round)，DES在明文分组上实施16轮相同的组合技术。

如下图所示：图1 DES算法总体描述DES使得用相同的函数来加密或解密每个分组成为可能，二者唯一的不同就是密钥的次序相反。

1.2 DES加解密算法原理DES对64位明文分组进行操作。

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

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

经过16轮后，左、右半部分合在一起经过一个末置换（初始置换的逆置换），算法就完成了。

在每一轮中，密钥位移位，然后再从密钥的56位中选出48位。

通过一个扩展置换将数据的右半部分扩展成48位，并通过一个异或操作与48位密钥结合，通过 8个S盒将这48位替代成新的32位数据，再将其置换一次。

这四步运算构成了函数f。

然后，通过另一个异或运算，函数f的输出与左半部分结合，其结果即成为新的左半部分。

将该操作重复16次，便实现了DES的16轮运算。

一轮DES如下图所示：图2 DES算法一轮迭代的过程假设Bi是第i次迭代的结果，Li和Ri是Bi的左半部分和右半部分，Ki是第i轮的48位密钥，且f是实现代替、置换及密钥异或等运算的函数，那么每一轮就是：L i=R i-1R i=L i-1⊕f(R i-1,K i)2 程序代码#include <iostream>#include <fstream>using namespace std;const static char 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,9, 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;else mov=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<<"请输入明文(8字节)："<<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; }2.1 初始置换初始置换在第一轮运算之前进行，对输入分组实施如下表所示的变换。

合集下载

DES算法原理及实现

DES算法原理及实现

电脑编程技巧与维护６４位的明文分组ｘ首先经过一个初始置换函数ＩＰ进行置换运算，产生一个６４位的输出ｘ０，该输出被分成两个分别为３２位的左半部分Ｌｏ和右半部分ＲＯ，用于Ｆ函数的１６轮迭代运算的首次迭代的初始输入。

初始置换函数ＩＰ实际上就是一张８ｘ８（８行８列）的迭代表，如表Ｉ所示。

明文分组中的６４位按照表中的规定重新进行排序，其排列顺序为从左到右，从上到下。

按表Ｉ所示，明文中的第５８位被放置在ｘＯ的第１位，第５０位防止在第２位，依次类推。

表ｌ初始置换函数ＩＰ５８５口４２３４２６１８１０２６０５２４４３６２８２０１２４６２５４４６３８３０２２１４６６４５６４８４０３２２４１６８５７４９４ｌ３３２５１７９ｌ５９５ｌ４３３５２７１９ｌｌ３６ｌ５３４５３７２９２ｌ１３５６３５５４７３９３ｌ２３１５７、————‘ｖ’———。

：、————’ｖ———。

ＬｏＲ。

一（２）获取子密钥Ｋｉ子密钥的获取主要通过置换和移位运算来实现。

ＤＥＳ加密算法的密钥长度为５６位，由用户提供，是ＤＥＳ算法的输入之一。

但用户输入的密钥是６４位的，按８行８列从左到右从上到下地排列，其中，每行的第８位用于奇偶校验。

在ＤＥＳ加密算法中，子密钥获取过程中，ＤＥＳ经过一系列的置换和移位运算，得到Ｋｌ到Ｋ１６共１６个子密钥，每个子密钥长４８位。

其实现过程如下：首先将输入的６４位密钥去掉最后一列的８个校验位，然后用密钥置换函数ＰＣ—ｌ对剩下的５６位密钥进行置换，如表２所示。

表２密钥置换函数ＰＣ—Ｉ５＂Ｉ４９４ｌ３３２５１７９卜ｌ５８５０４２３４２６１８１０２５９５ｌ４３３５２７１９ｌｌ３６０５２４４３６６３５５４７３９３ｌ２３ｉ５）】７６２５４４６３８３０２２１４６６１５３４５３７２９２ｌ１３５２Ｓ２０１２４由表２可知，用户输入的６４位密钥中，第８、１６、２４、３２、４０、４８、５６、６４共８个校验位被去掉。

剩余的５６位按表２所示排放：第５７位放在第１位，第４９位放在第２位，依次类推。

DES、AES算法实现

DES、AES算法实现

实验一、DES算法实验一、实验目的与意义用C++编程实现DES这一现代经典密码加解密算法，以便深入理解DES加解密算法原理，更好的理解书中介绍的相关内容，理解现代密码的精华，并且通过DES的学习实践也提高了编程的相关知识。

二、实验条件1、计算机一台；（1）、操作系统：Windows XP；（2）、实验平台：Microsoft VC++6.0三、实验原理DES算法的原理：把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，首先，DES把输入的64位数据块按位重新组合，并把输出分为shiftleft、shiftright两部分，每部分各长32位，并进行前后置换（输入的第58位换到第一位，第50位换到第2位，依此类推，最后一位是原来的第7位），最终由L0输出左32位，R0输出右32位，根据这个法则经过16次迭代运算后，得到L16、R16，将此作为输入，进行与初始置换相反的逆置换，即得到密文输出。

DES算法的入口参数有三个：Key、Data、Mode。

其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode 为DES的工作方式，有两种：加密或解密，如果Mode为加密，则用Key去把数据Data 进行加密，生成Data的密码形式作为DES的输出结果；如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式作为DES的输出结果。

在使用DES时，双方预先约定使用的”密码”即Key，然后用Key去加密数据；接收方得到密文后使用同样的Key解密得到原数据，这样便实现了安全性较高的数据传输。

1、DES加密过程DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位,其功能是把输入的64位数据块按位重新组合，并把输出分为L0 、R0两部分，每部分各长32位，其置换规则见下表：58, 50, 12, 34, 26, 18, 10, 260, 52, 44, 36, 28, 20, 12, 462, 54, 46, 38, 30, 22, 14, 664, 56, 48, 40, 32, 24, 16, 857, 49, 41, 33, 25, 17, 9, 159, 51, 43, 35, 27, 19, 11, 361, 53, 45, 37, 29, 21, 13, 563, 55, 47, 39, 31, 23, 15, 7,即将输入的第58位换到第一位，第50位换到第2位，......，依此类推，最后一位是原来的第7位。

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

数据加密标准DES1977年1月，美国政府将IBM研制的一种乘积密码宣布为国家的数据加密标准。

这个标准的确立刺激了很大一批厂商去实现加密算法的硬件化，以提高处理速度。

这种密码术的核心是乘积变换，在硬件产业中常常简称为DES（Data Encryption Standard）。

这样一来，由于可以得到便宜高速的硬件，所以反过来也鼓励了许多其他用户采纳DES。

1．DES算法描述现在我们来说明DES算法，它的过程如图9－2所示。

对明文按64位分组，每组明文经初始排列（第1步），通过子密钥K1--K16进行16次乘积变换（第2步），再通过最终排列（第3步）得到64位密文。

图9-2 DES算法过程图16次乘积变换的目的是使明文增大其混乱性和扩散性，使得输出不残存统计规律，使破译者不能从反向推算出密钥。

第1步：初始排列（IP）IP（Initial Permutation）取排数据的方法如表9-2所示，其中的数据表示明文的位标（1~64）。

例如，58指该组明文中的第58位，50指该组明文中的第50位，其他类推。

第l步初始排列的目的是将明文的顺序打乱。

表9－2 初始排列法（IP）[例12-1]明文X=0123456789ABCDEF（十六进制形式），写成二进制形式，共64位：X=0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111经过初始排列（IP）后，结果变成：1100 1100 0000 0000 1100 1100 1111 1111 1111 0000 1010 1010 1111 0000 1010 1010即写成十六进制形式是：CC00CCFFFOAAFOAA。

第2步：乘积变换把通过第1步得出的64位一分为二，用L0表示前32位，R0表示后32位，那么在上例中有：L0＝CC00CCFF R0＝FOAAFOAA其16次乘积变换的过程可以用图9－3表示。