2023面试高手

这个屌丝很懒，什么也没留下！

热门标签

DES算法

作者：2023面试高手 | 2024-04-23 01:45:13

踩

des算法

密码学以及应用：几本重要的参考教材

1、现代密码学及应用（理查德E布拉胡特）

2、密码学基础中文版

3、密码学原理与实践

4、深入浅出密码学常用加密技术原理与应用

5、现代密码学

6、应用密码学实验

7、图解密码技术

代码参考：https://www.cnblogs.com/jikexianfeng/p/10192024.html；同时非常感谢这位博主

1、概述

（1）des是一种将64位（8字节）明文加密成64比特密文的对称加密算法，实际密钥的长度是56比特，但是从规格上来说，des的密钥长度是64比特（8字节），每隔7比特设置一个校验比特（也就是第8，16，24，32，40，48，56，64位）；

（2）des是一种分组加密，分组加密也是大部分加密算法和基本操作，没有什么好说的，就是每次8个字节明文进去，8个字节密文出来；

（3）分组加密的迭代称为加密模式，几乎大部分加密方式通用

（4）des的基本结构是有Feistel设计的，因此也称为feistel结构或者feistel密码；feistel加密的各个步骤称为轮，整个加密过程就是进行若干次轮的循环，des是一种16轮循环的feistel网络；

2、feistel处理（后续加密的主体）

把64比特数据分为两组，右边32位不做处理，作为下一轮的右边，左边的需要进行异或，异或的对象是：右边32位经过轮函数处理之后的数据（还是32位）；异或后放在下一轮左侧；

中间的子密钥是本轮加密所使用的密钥，也就是说每一轮所需要的子密钥不同，这些子密钥都是原始密钥生成的；

一轮计算的几个步骤：

①将输入数据（64位）分成左右两部分

②右侧直接发送到输出的右侧

③将输入的右侧发送到轮函数

④轮函数根据右侧的数据和子密钥，计算一组值

⑤左侧数据异或发送到左侧的输出

此时我们发现右侧数据没有发生变化，所以需要继续轮计算；

如上图所示就是进行了3轮的示意图；第一轮加密的左侧变成了右侧，原来明文的右侧放到了左侧；也就说奇数轮对左侧加密，偶数轮对右侧加密；

3、DES的加密过程

（1）明文初始置换----》（2）密钥初始置换---》（3）生成16个48位的子密钥----》（4）明文拓展置换---》（5）S盒替换---》（6）P盒替换---》（7）末置换

（1）明文初始置换（char plainstring[8]---------->根据置换表得到新的new_plainstring）


static bool Message_bit[64]={0};//把8字节换成64位处理
char My_mesesage[8]={a,b,c,d,e,f,g,h,i};//假设输入消息
ByteToBit(Message_bit,My_message,64);
TableReplace(Message_bit,Message_bit,IP_Table,64);
 
/*****************************************************************
*IP_Table是给出的固定的置换表
*
*
********************************************************************/
 
void ByteToBit( bool * Data_out,char * Data_in,int Num) //字节转位//这一步可做可不做
{
     int i,j;
     for(i=0;i<Num;i++)
     {
      Data_out[i]=(Data_in[i/8]>>(i%8))&0x01;
     }
} 
 
void TableReplace( bool *Data_out, bool * Data_in,const char *Table ,int Num) // 置换算法
{
 int i=0;
 static bool Temp[256]={0};
 for(i=0;i<Num;i++)
 {
  Temp[i]=Data_in[Table[i]-1];
 }
 Bitcopy(Data_out,Temp,Num);
}

IP初始置换是固定好的，置换表也是固定的，这个过程其实不用过多的在意，就是根据表格改变明文的顺序；是由IBM公司给出的表固定好的；

（2）密钥初始置换+生成16个48位的子密钥---------->得到一个subkey[16][48]的表

密钥置换也是固定的

（3）生成16个48位的子密钥（为什么是48位呢？？？不应该是32位吗？）

56位的密钥经过置换选择2后为什么变成48位呢？？？


char My_key[8]={1,2,3,4,5,6,7,8};  //记录加密密钥；
SetKey(My_key);  //生成16轮的加密子密钥；
 
 
// 十六轮子密钥
static bool SubKey[16][48]={0};//生成的16组子密钥放在这里
//  移位表
static char Move_Table[16]={
  1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
void SetKey(char My_key[8])
{
 int i,j;
 static bool Key_bit[64]={0}; //Key的二进制缓存；
 static bool *Key_bit_L,*Key_bit_R;
 Key_bit_L=&Key_bit[0]; //key的左边28位；
 Key_bit_R=&Key_bit[28]; //key的右边28位；
 ByteToBit(Key_bit,My_key,64);
 
 TableReplace(Key_bit,Key_bit,PC1_Table,56);//pc-1 置换,pc1是给定的表
 for(i=0;i<16;i++)
 {
  Loop_bit(Key_bit_L,Move_Table[i],28);//move_table也是给定的
  Loop_bit(Key_bit_R,Move_Table[i],28);
  TableReplace(SubKey[i],Key_bit,PC2_Table,48);//pc-2置换
 }
}
 
void Loop_bit(bool * Data_out,int movstep,int len)
{
 static bool Temp[256]={0};
 Bitcopy(Temp,Data_out,movstep);
 Bitcopy(Data_out,Data_out+movstep,len-movstep);
 Bitcopy(Data_out+len-movstep,Temp,movstep);
 /*Temp=Data_out;
 Temp[movstep]='\0';
 Data_out=Data_out+movstep;
 Data_out+(len-movstep)=Temp;*/
}

（4）明文拓展置换

拓展置换，s盒，p盒可以统一在f函数实现；

明文置换之后，分为L和R；L=f（R）^ L;

我们要做的就是实现f（R），传入32位的数组，传出32位数组；

void S_change(bool * Data_out, bool * Data_in) //S盒变换
{
int i;
int r=0,c=0;//S盒的行和列；
for(i=0;i<8;i++,Data_in=Data_in+6,Data_out=Data_out+4)
{
r=Data_in[0]*2+Data_in[5]*1;
c=Data_in[1]*8+Data_in[2]*4+Data_in[3]*2+Data_in[4]*1;
ByteToBit(Data_out,&S_Box[i][r][c],4);
}
}

void Xor(bool * Message_out,bool * Message_in,int Num)//执行异或
{
int i;
for(i=0;i<Num;i++)
{
Message_out[i]=Message_out[i]^Message_in[i];
}
}

void F_change(bool Data_out[32],bool Data_in[48]) // f函数；
{
int i;
static bool Message_E[48]={0}; //存放E置换的结果；
TableReplace(Message_E,Data_out,E_Table,48);//E表置换
Xor(Message_E,Data_in,48);
S_change(Data_out,Message_E); // S盒变换
TableReplace(Data_out,Data_out,P_Table,32); //P置换
}


char HexMssage[16] ;
TableReplace(Message_bit,Message_bit,IP_Table,64);明文置换
 for(i=0;i<16;i++)接下来进行16轮的处理
 {
  Bitcopy(Temp,Message_bit_R,32);
  F_change(Message_bit_R,SubKey[i]);
  Xor(Message_bit_R,Message_bit_L,32);右边的和左边的取异或
  Bitcopy(Message_bit_L,Temp,32);
 }最后处理需要再次置换得到密文
 TableReplace(Message_bit,Message_bit,IPR_Table,64);IP_table和IPR_table
 
/***************************************************************
*最后得到的message_bit[64]会存在不可打印字符，如何转换成16进制打印呢？
*
*************************************************************/
 BitToHex(HexMssage,Message_bit,64);//二进制转换成十六进制；

拓展置换如何拓展到48位呢？？因为子密钥是48位的；

拓展置换E，变成8个S盒，每个S盒有6个比特；每个S盒最后变成4位，再经过P运算变成32位

（5）S盒替换

（6）P盒替换

（7）末置换

（8）DES解密

解析密码同样处理；首先输入密钥char you_key[8]和密文my_message[8];

SetKey(You_key); //生成16轮的解密子密钥；---->subkey[16][48]结果放在全局变量
Run_desDes(My_message,Message_hex);//解密;

void Run_desDes(char My_message[8],char HexMessage[16])// DES轮解密算法；
{
int i=0;
static bool Message_bit[64]={0};
static bool * Message_bit_L=&Message_bit[0], * Message_bit_R=&Message_bit[32];
static bool Temp[32]={0};
HexToBit(Message_bit,HexMessage,64);传参不一样char HexMessage[16]
TableReplace(Message_bit,Message_bit,IP_Table,64);-----------------------------------------------------------------------------①初始置换
for(i=15;i>=0;i--)
{
Bitcopy(Temp,Message_bit_L,32);
F_change(Message_bit_L,SubKey[i]);--------------------------------------------------------------------------------------------------②循环处理
Xor(Message_bit_L,Message_bit_R,32);
Bitcopy(Message_bit_R,Temp,32);
}
TableReplace(Message_bit,Message_bit,IPR_Table,64);---------------------------------------------------------------------------③逆置换
BitToByte(My_message,Message_bit,64);
}

和加密函数对比一下有什么区别？？

void Run_Des(char My_message[8],char HexMssage[16])//des轮加密算法；
{
int i;
static bool Message_bit[64]={0};
static bool *Message_bit_L=&Message_bit[0],*Message_bit_R=&Message_bit[32];
static bool Temp[32]={0};
ByteToBit(Message_bit,My_message,64);
TableReplace(Message_bit,Message_bit,IP_Table,64);
for(i=0;i<16;i++)
{
Bitcopy(Temp,Message_bit_R,32);
F_change(Message_bit_R,SubKey[i]);
Xor(Message_bit_R,Message_bit_L,32);
Bitcopy(Message_bit_L,Temp,32);
}
TableReplace(Message_bit,Message_bit,IPR_Table,64);
BitToHex(HexMssage,Message_bit,64);//二进制转换成十六进制；
}

最后附上完整代码：来自https://www.cnblogs.com/jikexianfeng/p/10192024.html


#include<stdio.h>
#include<string.h>
#include<stdlib.h>
/*------------------------
     定义枚举型全局变量
------------------------*/
typedef enum
  {
    false = 0,
    true  = 1
  } bool;
 
  // 十六轮子密钥
static bool SubKey[16][48]={0};
 
 /*---------------------*/
/*-------------------------------------------------------------
     各种置换表
-------------------------------------------------------------*/
// IP置换表
const char IP_Table[64]={
 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-1置换表
const char IPR_Table[64]={
 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
};
 
// E扩展表
static char E_Table[48]={
 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
};
// PC1置换表
static char PC1_Table[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
};
 
// pc2表
static char PC2_Table[48]={
 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,34,33,48,
 44,49,39,56,34,53,46,42,50,36,29,32
};
//  移位表
static char Move_Table[16]={
  1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
 // S盒
static char S_Box[8][4][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, 0, 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, 0, 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
};
 //P置换表
static char P_Table[32]={
 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
};
/*-------------------------------------------------------------------*/
 
/*-----------------------------自定义函数-----------------------------*/
void SetKey(char My_key[8]); //生成16轮的子密钥；
void ByteToBit(bool * Data_out,char * Data_in,int Num); //字节转换成位；
void Change_bit(bool * Data_out,int Num);//二进制的位置进行转换；
void BitToByte(char My_message[8],bool * Message_in,int Num); //位转换成字节；
void TableReplace(bool *Data_out,bool *Data_in,const char *Table,int Num);  //各种表的置换算法；
void Bitcopy(bool * Data_out,bool * Data_in,int Num);  //二进制数组的拷贝
void Loop_bit(bool * Data_out,int movstep,int len);  //左移位；
void Run_Des(char My_message[8],char HexMssage[16]);//des的轮加密算法
void Xor(bool * Message_out, bool * Message_in,int Num); //执行异或
void S_change(bool * Data_out, bool * Data_in);  // S盒变换；
void HexToBit(bool * Data_out,char * Data_in,int Num); // 十六进制转二进制
void BitToHex(char * Data_out,bool * Data_in,int Num); //二进制转换成十六进制；
void Run_desDes(char My_message[8],char HexMessage[16]);// DES轮解密算法；
 
/*--------------------------*/
 
/*--------------------------主函数----------------------------------*/
int main()
{
 int i=0,j;
 char My_key[8]={0};  //记录加密密钥；
 char You_key[8]={0}; //解密密钥
 char My_message[8]={0}; //明文
 char Message_hex[16]={0};//16进制的密文
 printf("请输入你要加密的内容(8 Byte):\n");
 gets(My_message);
 printf("请输入你的加密密钥:\n");
 gets(My_key);
 i=strlen(My_key);
 while(i!=8)
 {
  printf("请输入加密密钥(8 Byte)\n");
  gets(My_key);
  i=0;
  i=strlen(My_key);
 }
 SetKey(My_key);  //生成16轮的加密子密钥；
 Run_Des(My_message,Message_hex); //des的轮加密过程
 
 
 
 
 
 
 
 
 printf("经过加密的密文为:\n");
 for(i=0;i<16;i++)
 {
  printf("%c ",Message_hex[i]);
 }
 printf("\n");
 
 
 
 
 
 
 
 
 printf("请输入你的解密密钥(8 Byte):\n");
 gets(You_key);
 i=strlen(You_key);
 while(i!=8)
 {
  printf("请输入解密密钥(8 Byte)\n");
  gets(You_key);
  i=0;
  i=strlen(You_key);
 }
 SetKey(You_key);  //生成16轮的解密子密钥；
 Run_desDes(My_message,Message_hex);//解密;
 printf("解密结果为:\n");
 for(i=0;i<8;i++)
 {
  printf("%c ",My_message[i]);
 }
 printf("\n");
 return 0;
}
 
/*--------------------具体函数定义----------------------*/
void Bitcopy(bool * Data_out, bool * Data_in,int Num) //二进制数组拷贝
{
 int i=0;
 for(i=0;i<Num;i++)
 {
  Data_out[i]=Data_in[i];
 }
 
}
void Change_bit(bool * Data_out,int Num) //二进制的位置进行转换；
{
 int i,j;
 static bool Temp[8]={0};
 for(i=0;i<Num/8;i++)
 {
  Bitcopy(Temp,Data_out,Num/8);
  for(j=0;j<Num/8;j++)
  {
   Data_out[j]=Temp[Num/8-1-j];
  }
  Data_out+=Num/8;
 }
}
void ByteToBit( bool * Data_out,char * Data_in,int Num) //字节转位
{
 int i,j;
 for(i=0;i<Num;i++)
 {
  Data_out[i]=(Data_in[i/8]>>(i%8))&0x01;
 }
 //Change_bit(Data_out,Num);
}
void BitToHex(char * Data_out, bool * Data_in,int Num) //二进制转十六进制
{
 int i;
 for(i=0;i<Num/4;i++)
 {
  Data_out[i]=0;
 }
 for(i=0;i<Num/4;i++)
 {
  Data_out[i]=Data_in[4*i]+Data_in[4*i+1]*2+Data_in[4*i+2]*4+Data_in[4*i+3]*8;
  if(Data_out[i]%16>9)
  {
   Data_out[i]=Data_out[i]%16+'7';
  }
  else
  Data_out[i]=Data_out[i]%16+'0';
 }
}
void HexToBit(bool * Data_out,char * Data_in,int Num) //十六进制转二进制
{
 int i;
 for(i=0;i<Num;i++)
 {
  if(Data_in[i/4]<='9')
  {
   Data_out[i]=((Data_in[i/4]-'0')>>(i%4))&0x01;
  }
  else
  {
   Data_out[i]=((Data_in[i/4]-'7')>>(i%4))&0x01;
  }
 }
}
void BitToByte(char My_message[8],bool * Message_in,int Num) //位转换成字节
{
 int i=0;
 for(i=0;i<(Num/8);i++)
 {
  My_message[i]=0;
 }
 for(i=0;i<Num;i++)
 {
  My_message[i/8]|=Message_in[i]<<(i%8);
 }
}
void TableReplace( bool *Data_out, bool * Data_in,const char *Table ,int Num) // 置换算法
{
 int i=0;
 static bool Temp[256]={0};
 for(i=0;i<Num;i++)
 {
  Temp[i]=Data_in[Table[i]-1];
 }
 Bitcopy(Data_out,Temp,Num);
}
 
void Loop_bit(bool * Data_out,int movstep,int len)
{
 static bool Temp[256]={0};
 Bitcopy(Temp,Data_out,movstep);
 Bitcopy(Data_out,Data_out+movstep,len-movstep);
 Bitcopy(Data_out+len-movstep,Temp,movstep);
 /*Temp=Data_out;
 Temp[movstep]='\0';
 Data_out=Data_out+movstep;
 Data_out+(len-movstep)=Temp;*/
}
 
void Xor(bool * Message_out,bool * Message_in,int Num)//执行异或
{
 int i;
 for(i=0;i<Num;i++)
 {
  Message_out[i]=Message_out[i]^Message_in[i];
 }
}
 
 
void SetKey(char My_key[8])
{
 int i,j;
 static bool Key_bit[64]={0}; //Key的二进制缓存；
 static bool *Key_bit_L,*Key_bit_R;
 Key_bit_L=&Key_bit[0]; //key的左边28位；
 Key_bit_R=&Key_bit[28]; //key的右边28位；
 ByteToBit(Key_bit,My_key,64);
/* Change_bit(Key_bit,64) ;//二进制的位置进行转换；
 for(i=0;i<64;i++)
 {
  printf("%d ",Key_bit[i]);
 }
 printf("\n");
 printf("\n");*/
 TableReplace(Key_bit,Key_bit,PC1_Table,56);//pc-1 置换
 for(i=0;i<16;i++)
 {
  Loop_bit(Key_bit_L,Move_Table[i],28);
  Loop_bit(Key_bit_R,Move_Table[i],28);
  TableReplace(SubKey[i],Key_bit,PC2_Table,48);//pc-2置换
 }
}
void S_change(bool * Data_out, bool * Data_in) //S盒变换
{
 int i;
 int r=0,c=0;//S盒的行和列；
 for(i=0;i<8;i++,Data_in=Data_in+6,Data_out=Data_out+4)
 {
  r=Data_in[0]*2+Data_in[5]*1;
  c=Data_in[1]*8+Data_in[2]*4+Data_in[3]*2+Data_in[4]*1;
  ByteToBit(Data_out,&S_Box[i][r][c],4);
 }
}
void F_change(bool Data_out[32],bool Data_in[48])   // f函数；
{
 int i;
 static bool Message_E[48]={0};  //存放E置换的结果；
 TableReplace(Message_E,Data_out,E_Table,48);//E表置换
 Xor(Message_E,Data_in,48);
 S_change(Data_out,Message_E);                 // S盒变换
 TableReplace(Data_out,Data_out,P_Table,32);  //P置换
}
void Run_Des(char My_message[8],char HexMssage[16])//des轮加密算法；
{
 int i;
 static bool Message_bit[64]={0};
 static bool *Message_bit_L=&Message_bit[0],*Message_bit_R=&Message_bit[32];
 static bool Temp[32]={0};
 ByteToBit(Message_bit,My_message,64);
 /*Change_bit(Message_bit,64) ;//二进制的位置进行转换；
 for(i=0;i<64;i++)
 {
  printf("%d ",Message_bit[i]);
 }
 printf("\n");
 printf("\n");*/
 TableReplace(Message_bit,Message_bit,IP_Table,64);
 for(i=0;i<16;i++)
 {
  Bitcopy(Temp,Message_bit_R,32);
  F_change(Message_bit_R,SubKey[i]);
  Xor(Message_bit_R,Message_bit_L,32);
  Bitcopy(Message_bit_L,Temp,32);
 }
 TableReplace(Message_bit,Message_bit,IPR_Table,64);
 BitToHex(HexMssage,Message_bit,64);//二进制转换成十六进制；
}
void Run_desDes(char My_message[8],char HexMessage[16])// DES轮解密算法；
{
 int i=0;
 static bool Message_bit[64]={0};
 static bool * Message_bit_L=&Message_bit[0], * Message_bit_R=&Message_bit[32];
 static bool Temp[32]={0};
 HexToBit(Message_bit,HexMessage,64);
 TableReplace(Message_bit,Message_bit,IP_Table,64);
 for(i=15;i>=0;i--)
 {
  Bitcopy(Temp,Message_bit_L,32);
  F_change(Message_bit_L,SubKey[i]);
  Xor(Message_bit_L,Message_bit_R,32);
  Bitcopy(Message_bit_R,Temp,32);
 }
 TableReplace(Message_bit,Message_bit,IPR_Table,64);
 BitToByte(My_message,Message_bit,64);
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/471526