实验一：C语言实现DES加解密算法

计算程序执行10万次需要的时间：

总共需要175秒

加解密一次的时间小于：0.00175秒

纯计算加解密的时间会更短

去除IO操作后的时间

也就是说加解密一次的时间为0.07毫秒

 /*-------------------------------------------------------

 Data Encryption Standard  56位密钥加密64位数据

 --------------------------------------------------------*/

 #include <stdlib.h>

 #include <stdio.h>

 #include <time.h>

 #include "bool.h"   // 位处理

 #include "tables.h"

 void BitsCopy(bool *DatOut, bool *DatIn, int Len);  // 数组复制 

 void ByteToBit(bool *DatOut, char *DatIn, int Num); // 字节到位

 void BitToByte(char *DatOut, bool *DatIn, int Num); // 位到字节

 void BitToHex(char *DatOut, bool *DatIn, int Num);  // 二进制到十六进制 64位 to 4*16字符

 void HexToBit(bool *DatOut, char *DatIn, int Num);  // 十六进制到二进制 

 void TablePermute(bool *DatOut, bool *DatIn, const char *Table, int Num); // 位表置换函数

 void LoopMove(bool *DatIn, int Len, int Num);     // 循环左移 Len长度 Num移动位数

 void Xor(bool *DatA, bool *DatB, int Num);         // 异或函数 

 void S_Change(bool DatOut[], bool DatIn[]);   // S盒变换

 void F_Change(bool DatIn[], bool DatKi[]);    // F函数                                  

 void SetKey(char KeyIn[]);                         // 设置密钥

 void PlayDes(char MesOut[], char MesIn[]);       // 执行DES加密

 void KickDes(char MesOut[], char MesIn[]);             // 执行DES解密 

 int main()

 {

     clock_t aaa, bbb;

     int jjj = ;

     aaa = time(NULL);

     while (jjj <)

     {

     int i = ;

     char MesHex[] = {  };         // 16个字符数组用于存放 64位16进制的密文

     char MyKey[] = {  };           // 初始密钥 8字节*8

     char YourKey[] = {  };         // 输入的解密密钥 8字节*8

     char MyMessage[] = {  };       // 初始明文 

     /*-----------------------------------------------*/

     printf("Welcome! Please input your Message(64 bit):\n");

     //gets(MyMessage);            // 明文

     MyMessage[] = '';

     MyMessage[] = '';

     MyMessage[] = '';

     MyMessage[] = '';

     MyMessage[] = '';

     MyMessage[] = '';

     MyMessage[] = '';

     MyMessage[] = '';

     //MyMessage[0] = '\0';

     printf("Please input your Secret Key:\n");

     MyKey[] = '';                // 密钥

     MyKey[] = '';

     MyKey[] = '';

     MyKey[] = '';

     MyKey[] = '';

     MyKey[] = '';

     MyKey[] = '';

     MyKey[] = '';

     //MyKey[8] = '\0';

     while (MyKey[i] != '\0')        // 计算密钥长度

     {

         i++;

     }

     /*

     while (i != 8)                  // 不是8 提示错误

     {

     printf("Please input a correct Secret Key!\n");

     gets(MyKey);

     i = 0;

     while (MyKey[i] != '\0')    // 再次检测

     {

     i++;

     }

     }*/

     SetKey(MyKey);               // 设置密钥 得到子密钥Ki

     PlayDes(MesHex, MyMessage);   // 执行DES加密

     printf("Your Message is Encrypted!:\n");  // 信息已加密

     for (i = ; i < ; i++)

     {

         printf("%c ", MesHex[i]);

     }

     printf("\n\n");

     printf("Please input your Secret Key to Deciphering:\n");  // 请输入密钥以解密

     //gets(YourKey);                                         // 得到密钥

     YourKey[] = '';

     YourKey[] = '';

     YourKey[] = '';

     YourKey[] = '';

     YourKey[] = '';

     YourKey[] = '';

     YourKey[] = '';

     YourKey[] = '';

     //YourKey[8] = '\0';

     SetKey(YourKey);                                       // 设置密钥

     KickDes(MyMessage, MesHex);                     // 解密输出到MyMessage

     printf("Deciphering Over !!:\n");                     // 解密结束

     for (i = ; i < ; i++)

     {

         printf("%c ", MyMessage[i]);

     }

     printf("\n\n");

     jjj++;

 }

     bbb = time(NULL);

     printf("bbb-aaa= %f",(double)(bbb - aaa));

     system("pause");

     /*------------------------------------------------*/

 }

 /*-------------------------------

 把DatIn开始的长度位Len位的二进制

 复制到DatOut后

 --------------------------------*/

 void BitsCopy(bool *DatOut, bool *DatIn, int Len)     // 数组复制 OK

 {

     int i = ;

     for (i = ; i<Len; i++)

     {

         DatOut[i] = DatIn[i];

     }

 }

 /*-------------------------------

 字节转换成位函数

 每8次换一个字节 每次向右移一位

 和1与取最后一位 共64位

 --------------------------------*/

 void ByteToBit(bool *DatOut, char *DatIn, int Num)       // OK

 {

     int i = ;

     for (i = ; i<Num; i++)

     {

         DatOut[i] = (DatIn[i / ] >> (i % )) & 0x01;

     }

 }

 /*-------------------------------

 位转换成字节函数

 字节数组每8次移一位

 位每次向左移 与上一次或

 ---------------------------------*/

 void BitToByte(char *DatOut, bool *DatIn, int Num)        // OK

 {

     int i = ;

     for (i = ; i<(Num / ); i++)

     {

         DatOut[i] = ;

     }

     for (i = ; i<Num; i++)

     {

         DatOut[i / ] |= DatIn[i] << (i % );

     }

 }

 /*----------------------------------

 二进制密文转换为十六进制

 需要16个字符表示

 -----------------------------------*/

 void BitToHex(char *DatOut, bool *DatIn, int Num)

 {

     int i = ;

     for (i = ; i<Num / ; i++)

     {

         DatOut[i] = ;

     }

     for (i = ; i<Num / ; i++)

     {

         DatOut[i] = DatIn[i * ] + (DatIn[i *  + ] << )

             + (DatIn[i *  + ] << ) + (DatIn[i *  + ] << );

         if ((DatOut[i] % )>)

         {

             DatOut[i] = DatOut[i] %  + '';       //  余数大于9时处理 10-15 to A-F

         }                                     //  输出字符

         else

         {

             DatOut[i] = DatOut[i] %  + '';       //  输出字符

         }

     }

 }

 /*---------------------------------------------

 十六进制字符转二进制

 ----------------------------------------------*/

 void HexToBit(bool *DatOut, char *DatIn, int Num)

 {

     int i = ;                        // 字符型输入

     for (i = ; i<Num; i++)

     {

         if ((DatIn[i / ])>'')         //  大于9

         {

             DatOut[i] = ((DatIn[i / ] - '') >> (i % )) & 0x01;

         }

         else

         {

             DatOut[i] = ((DatIn[i / ] - '') >> (i % )) & 0x01;

         }

     }

 }

 // 表置换函数  OK

 void TablePermute(bool *DatOut, bool *DatIn, const char *Table, int Num)

 {

     int i = ;

     static bool Temp[] = {  };

     for (i = ; i<Num; i++)                // Num为置换的长度

     {

         Temp[i] = DatIn[Table[i] - ];  // 原来的数据按对应的表上的位置排列

     }

     BitsCopy(DatOut, Temp, Num);       // 把缓存Temp的值输出

 }

 // 子密钥的移位

 void LoopMove(bool *DatIn, int Len, int Num) // 循环左移 Len数据长度 Num移动位数

 {

     static bool Temp[] = {  };    // 缓存   OK

     BitsCopy(Temp, DatIn, Num);       // 将数据最左边的Num位(被移出去的)存入Temp

     BitsCopy(DatIn, DatIn + Num, Len - Num); // 将数据左边开始的第Num移入原来的空间

     BitsCopy(DatIn + Len - Num, Temp, Num);  // 将缓存中移出去的数据加到最右边

 }

 // 按位异或

 void Xor(bool *DatA, bool *DatB, int Num)           // 异或函数

 {

     int i = ;

     for (i = ; i<Num; i++)

     {

         DatA[i] = DatA[i] ^ DatB[i];                  // 异或

     }

 }

 // 输入48位 输出32位 与Ri异或

 void S_Change(bool DatOut[], bool DatIn[])     // S盒变换

 {

     int i, X, Y;                                    // i为8个S盒

     for (i = , Y = , X = ; i<; i++, DatIn += , DatOut += )   // 每执行一次,输入数据偏移6位

     {                                              // 每执行一次,输出数据偏移4位

         Y = (DatIn[] << ) + DatIn[];                          // af代表第几行

         X = (DatIn[] << ) + (DatIn[] << ) + (DatIn[] << ) + DatIn[]; // bcde代表第几列

         ByteToBit(DatOut, &S_Box[i][Y][X], );      // 把找到的点数据换为二进制

     }

 }

 // F函数

 void F_Change(bool DatIn[], bool DatKi[])       // F函数

 {

     static bool MiR[] = {  };             // 输入32位通过E选位变为48位

     TablePermute(MiR, DatIn, E_Table, );

     Xor(MiR, DatKi, );                   // 和子密钥异或

     S_Change(DatIn, MiR);                 // S盒变换

     TablePermute(DatIn, DatIn, P_Table, );   // P置换后输出

 }

 void SetKey(char KeyIn[])               // 设置密钥 获取子密钥Ki

 {

     int i = ;

     static bool KeyBit[] = {  };                // 密钥二进制存储空间

     static bool *KiL = &KeyBit[], *KiR = &KeyBit[];  // 前28,后28共56

     ByteToBit(KeyBit, KeyIn, );                    // 把密钥转为二进制存入KeyBit

     TablePermute(KeyBit, KeyBit, PC1_Table, );      // PC1表置换 56次

     for (i = ; i<; i++)

     {

         LoopMove(KiL, , Move_Table[i]);       // 前28位左移

         LoopMove(KiR, , Move_Table[i]);          // 后28位左移

         TablePermute(SubKey[i], KeyBit, PC2_Table, );

         // 二维数组 SubKey[i]为每一行起始地址

         // 每移一次位进行PC2置换得 Ki 48位

     }

 }

 void PlayDes(char MesOut[], char MesIn[])  // 执行DES加密

 {                                           // 字节输入 Bin运算 Hex输出

     int i = ;

     static bool MesBit[] = {  };        // 明文二进制存储空间 64位

     static bool Temp[] = {  };

     static bool *MiL = &MesBit[], *MiR = &MesBit[]; // 前32位 后32位

     ByteToBit(MesBit, MesIn, );                 // 把明文换成二进制存入MesBit

     TablePermute(MesBit, MesBit, IP_Table, );    // IP置换

     for (i = ; i<; i++)                       // 迭代16次

     {

         BitsCopy(Temp, MiR, );            // 临时存储

         F_Change(MiR, SubKey[i]);           // F函数变换

         Xor(MiR, MiL, );                  // 得到Ri

         BitsCopy(MiL, Temp, );            // 得到Li

     }

     TablePermute(MesBit, MesBit, IPR_Table, );

     BitToHex(MesOut, MesBit, );

 }

 void KickDes(char MesOut[], char MesIn[])       // 执行DES解密

 {                                                // Hex输入 Bin运算 字节输出

     int i = ;

     static bool MesBit[] = {  };        // 密文二进制存储空间 64位

     static bool Temp[] = {  };

     static bool *MiL = &MesBit[], *MiR = &MesBit[]; // 前32位 后32位

     HexToBit(MesBit, MesIn, );                 // 把密文换成二进制存入MesBit

     TablePermute(MesBit, MesBit, IP_Table, );    // IP置换

     for (i = ; i >= ; i--)

     {

         BitsCopy(Temp, MiL, );

         F_Change(MiL, SubKey[i]);

         Xor(MiL, MiR, );

         BitsCopy(MiR, Temp, );

     }

     TablePermute(MesBit, MesBit, IPR_Table, );

     BitToByte(MesOut, MesBit, );

 }

main2.c

验证算法的正确性和雪崩现象

明文：12345678

密钥：12345678

密文：6E15D7EC4F9D4A06

2.修改一位明文

明文：12345679

密钥：12345678

密文：48598F155CB7C5C9

3.修改一位密钥

明文：12345678

密钥：12345679

密文：02AB45B02D446190

-main.c

 /*-------------------------------------------------------

       Data Encryption Standard  56位密钥加密64位数据
 --------------------------------------------------------*/

 #include <stdlib.h>

 #include <stdio.h>

 #include "bool.h"   // 位处理

 #include "tables.h"

 void BitsCopy(bool *DatOut,bool *DatIn,int Len);  // 数组复制 

 void ByteToBit(bool *DatOut,char *DatIn,int Num); // 字节到位

 void BitToByte(char *DatOut,bool *DatIn,int Num); // 位到字节

 void BitToHex(char *DatOut,bool *DatIn,int Num);  // 二进制到十六进制 64位 to 4*16字符

 void HexToBit(bool *DatOut,char *DatIn,int Num);  // 十六进制到二进制 

 void TablePermute(bool *DatOut,bool *DatIn,const char *Table,int Num); // 位表置换函数

 void LoopMove(bool *DatIn,int Len,int Num);     // 循环左移 Len长度 Num移动位数

 void Xor(bool *DatA,bool *DatB,int Num);         // 异或函数 

 void S_Change(bool DatOut[],bool DatIn[]);   // S盒变换

 void F_Change(bool DatIn[],bool DatKi[]);    // F函数                                  

 void SetKey(char KeyIn[]);                         // 设置密钥

 void PlayDes(char MesOut[],char MesIn[]);       // 执行DES加密

 void KickDes(char MesOut[],char MesIn[]);             // 执行DES解密 

 int main()

 {

     int i=;

     char MesHex[]={};         // 16个字符数组用于存放 64位16进制的密文

      char MyKey[]={};           // 初始密钥 8字节*8

     char YourKey[]={};         // 输入的解密密钥 8字节*8

     char MyMessage[]={};       // 初始明文 

 /*-----------------------------------------------*/

     printf("Welcome! Please input your Message(64 bit):\n");

     gets(MyMessage);            // 明文

     printf("Please input your Secret Key:\n");

     gets(MyKey);                // 密钥

     while(MyKey[i]!='\0')        // 计算密钥长度

     {

         i++;

     }

     while(i!=)                  // 不是8 提示错误

     {

         printf("Please input a correct Secret Key!\n");

         gets(MyKey);

         i=;

         while(MyKey[i]!='\0')    // 再次检测

         {

             i++;

         }

     }

     SetKey(MyKey);               // 设置密钥 得到子密钥Ki

     PlayDes(MesHex,MyMessage);   // 执行DES加密

     printf("Your Message is Encrypted!:\n");  // 信息已加密

     for(i=;i<;i++)

     {

         printf("%c ",MesHex[i]);

     }

     printf("\n\n");

     printf("Please input your Secret Key to Deciphering:\n");  // 请输入密钥以解密

     gets(YourKey);                                         // 得到密钥

     SetKey(YourKey);                                       // 设置密钥

     KickDes(MyMessage,MesHex);                     // 解密输出到MyMessage

     printf("Deciphering Over !!:\n");                     // 解密结束

     for(i=;i<;i++)

     {

         printf("%c ",MyMessage[i]);

     }

     printf("\n\n");

 /*------------------------------------------------*/

 }

 /*-------------------------------

  把DatIn开始的长度位Len位的二进制

  复制到DatOut后

 --------------------------------*/

 void BitsCopy(bool *DatOut,bool *DatIn,int Len)     // 数组复制 OK

 {

     int i=;

     for(i=;i<Len;i++)

     {

         DatOut[i]=DatIn[i];

     }

 }

 /*-------------------------------

  字节转换成位函数

  每8次换一个字节 每次向右移一位

  和1与取最后一位 共64位

 --------------------------------*/

 void ByteToBit(bool *DatOut,char *DatIn,int Num)       // OK

 {

     int i=;

     for(i=;i<Num;i++)

     {

         DatOut[i]=(DatIn[i/]>>(i%))&0x01;

     }

 }

 /*-------------------------------

  位转换成字节函数

  字节数组每8次移一位

  位每次向左移 与上一次或

 ---------------------------------*/

 void BitToByte(char *DatOut,bool *DatIn,int Num)        // OK

 {

     int i=;

     for(i=;i<(Num/);i++)

     {

         DatOut[i]=;

     }

     for(i=;i<Num;i++)

     {

         DatOut[i/]|=DatIn[i]<<(i%);

     }

 }

 /*----------------------------------

  二进制密文转换为十六进制

  需要16个字符表示

 -----------------------------------*/

 void BitToHex(char *DatOut,bool *DatIn,int Num)

 {

     int i=;

     for(i=;i<Num/;i++)

     {

         DatOut[i]=;

     }

     for(i=;i<Num/;i++)

     {

         DatOut[i] = DatIn[i*]+(DatIn[i*+]<<)

                     +(DatIn[i*+]<<)+(DatIn[i*+]<<);

         if((DatOut[i]%)>)

         {

             DatOut[i]=DatOut[i]%+'';       //  余数大于9时处理 10-15 to A-F

         }                                     //  输出字符

         else

         {

             DatOut[i]=DatOut[i]%+'';       //  输出字符

         }

     }

 }

 /*---------------------------------------------

  十六进制字符转二进制

 ----------------------------------------------*/

 void HexToBit(bool *DatOut,char *DatIn,int Num)

 {

     int i=;                        // 字符型输入

     for(i=;i<Num;i++)

     {

         if((DatIn[i/])>'')         //  大于9

         {

             DatOut[i]=((DatIn[i/]-'')>>(i%))&0x01;

         }

         else

         {

             DatOut[i]=((DatIn[i/]-'')>>(i%))&0x01;

         }

     }

 }

 // 表置换函数  OK

 void TablePermute(bool *DatOut,bool *DatIn,const char *Table,int Num)

 {

     int i=;

     static bool Temp[]={};

     for(i=;i<Num;i++)                // Num为置换的长度

     {

         Temp[i]=DatIn[Table[i]-];  // 原来的数据按对应的表上的位置排列

     }

     BitsCopy(DatOut,Temp,Num);       // 把缓存Temp的值输出

 } 

 // 子密钥的移位

 void LoopMove(bool *DatIn,int Len,int Num) // 循环左移 Len数据长度 Num移动位数

 {

     static bool Temp[]={};    // 缓存   OK

     BitsCopy(Temp,DatIn,Num);       // 将数据最左边的Num位(被移出去的)存入Temp

     BitsCopy(DatIn,DatIn+Num,Len-Num); // 将数据左边开始的第Num移入原来的空间

     BitsCopy(DatIn+Len-Num,Temp,Num);  // 将缓存中移出去的数据加到最右边

 } 

 // 按位异或

 void Xor(bool *DatA,bool *DatB,int Num)           // 异或函数

 {

     int i=;

     for(i=;i<Num;i++)

     {

         DatA[i]=DatA[i]^DatB[i];                  // 异或

     }

 } 

 // 输入48位 输出32位 与Ri异或

 void S_Change(bool DatOut[],bool DatIn[])     // S盒变换

 {

     int i,X,Y;                                    // i为8个S盒

     for(i=,Y=,X=;i<;i++,DatIn+=,DatOut+=)   // 每执行一次,输入数据偏移6位

     {                                              // 每执行一次,输出数据偏移4位

         Y=(DatIn[]<<)+DatIn[];                          // af代表第几行

         X=(DatIn[]<<)+(DatIn[]<<)+(DatIn[]<<)+DatIn[]; // bcde代表第几列

         ByteToBit(DatOut,&S_Box[i][Y][X],);      // 把找到的点数据换为二进制

     }

 }

 // F函数

 void F_Change(bool DatIn[],bool DatKi[])       // F函数

 {

     static bool MiR[]={};             // 输入32位通过E选位变为48位

     TablePermute(MiR,DatIn,E_Table,);

     Xor(MiR,DatKi,);                   // 和子密钥异或

     S_Change(DatIn,MiR);                 // S盒变换

     TablePermute(DatIn,DatIn,P_Table,);   // P置换后输出

 }

 void SetKey(char KeyIn[])               // 设置密钥 获取子密钥Ki

 {

     int i=;

     static bool KeyBit[]={};                // 密钥二进制存储空间

     static bool *KiL=&KeyBit[],*KiR=&KeyBit[];  // 前28,后28共56

     ByteToBit(KeyBit,KeyIn,);                    // 把密钥转为二进制存入KeyBit

     TablePermute(KeyBit,KeyBit,PC1_Table,);      // PC1表置换 56次

     for(i=;i<;i++)

     {

         LoopMove(KiL,,Move_Table[i]);       // 前28位左移

         LoopMove(KiR,,Move_Table[i]);          // 后28位左移

          TablePermute(SubKey[i],KeyBit,PC2_Table,);

          // 二维数组 SubKey[i]为每一行起始地址

          // 每移一次位进行PC2置换得 Ki 48位

     }

 }

 void PlayDes(char MesOut[],char MesIn[])  // 执行DES加密

 {                                           // 字节输入 Bin运算 Hex输出

     int i=;

     static bool MesBit[]={};        // 明文二进制存储空间 64位

     static bool Temp[]={};

     static bool *MiL=&MesBit[],*MiR=&MesBit[]; // 前32位 后32位

     ByteToBit(MesBit,MesIn,);                 // 把明文换成二进制存入MesBit

     TablePermute(MesBit,MesBit,IP_Table,);    // IP置换

     for(i=;i<;i++)                       // 迭代16次

     {

         BitsCopy(Temp,MiR,);            // 临时存储

         F_Change(MiR,SubKey[i]);           // F函数变换

         Xor(MiR,MiL,);                  // 得到Ri

         BitsCopy(MiL,Temp,);            // 得到Li

     }

     TablePermute(MesBit,MesBit,IPR_Table,);

     BitToHex(MesOut,MesBit,);

 }

 void KickDes(char MesOut[],char MesIn[])       // 执行DES解密

 {                                                // Hex输入 Bin运算 字节输出

     int i=;

     static bool MesBit[]={};        // 密文二进制存储空间 64位

     static bool Temp[]={};

     static bool *MiL=&MesBit[],*MiR=&MesBit[]; // 前32位 后32位

     HexToBit(MesBit,MesIn,);                 // 把密文换成二进制存入MesBit

     TablePermute(MesBit,MesBit,IP_Table,);    // IP置换

     for(i=;i>=;i--)

     {

         BitsCopy(Temp,MiL,);

         F_Change(MiL,SubKey[i]);

         Xor(MiL,MiR,);

         BitsCopy(MiR,Temp,);

     }

     TablePermute(MesBit,MesBit,IPR_Table,);

     BitToByte(MesOut,MesBit,);

 }

-tables.h

 /*-------------------------------------------------------------

         置换表

 -------------------------------------------------------------*/

 #ifndef _TABLES_H_    // 防重复编译

 #define _TABLES_H_  

 // 对明文执行IP置换得到L0,R0 （L左32位,R右32位）               [明文操作]

 const char IP_Table[]={

     ,,,,,,, ,,,,,,,, ,

     ,,,,,,, ,,,,,,,, ,

     ,,,,,, , ,,,,,,,, ,

     ,,,,,,, ,,,,,,,,

 };

 // 对迭代后的L16,R16执行IP逆置换,输出密文

 const char IPR_Table[]={

     , ,,,,,,,, ,,,,,,,

     , ,,,,,,,, ,,,,,,,

     , ,,,,,,,, ,,,,,,,

     , ,,,,,,,, ,, ,,,,

 };

 /*--------------------------- 迭代法则 ----------------------------*/ 

 // F函数,32位的R0进行E变换,扩为48位输出 (R1~R16)        [备用A]  [明文操作]

 static char E_Table[]={

     , , , , , , , , , , , ,

      , ,,,,,,,,,,,

     ,,,,,,,,,,,,

     ,,,,,,,,,,,

 };

 // 子密钥K(i)的获取 密钥为K 抛弃第6,16,24,32,40,48,64位          [密钥操作]

 // 用PC1选位 分为 前28位C0,后28位D0 两部分

 static char PC1_Table[]={

     ,,,,,, , ,,,,,,,

     , ,,,,,,,, ,,,,,

     ,,,,,,, ,,,,,,,

     , ,,,,,,,, ,,,,

 };

 // 对C0,D0分别进行左移,共16次,左移位数与下面对应                 [密钥操作]

 static char Move_Table[]={

      , , , , , , , , , , , , , , ,

 };

 // C1,D1为第一次左移后得到,进行PC2选位,得到48位输出K1   [备用B]   [密钥操作]

 static char PC2_Table[]={

     ,,,, , , ,,, ,,,

     ,,, ,, ,, ,,,, ,

     ,,,,,,,,,,,,

     ,,,,,,,,,,,

 };

 /*------------- F函数 备用A和备用B 异或 得到48位输出 ---------------*/ 

 // 异或后的结果48位分为8组,每组6位,作为8个S盒的输入             [组合操作]

 // S盒以6位作为输入(8组),4位作为输出(4*(8组)=32位)

 // S工作原理 假设输入为A=abcdef ,则bcde所代表的数是0-15之间的

 // 一个数记为 X=bcde ,af代表的是0-3之间的一个数,记为 Y=af

 // 在S1的X列,Y行找到一个数Value,它在0-15之间,可以用二进制表示

 // 所以为4bit (共32位)

 static char S_Box[][][]={

     //S1

     , ,, , ,,, , ,, ,, , , , ,

      ,, , ,, ,, ,, ,,, , , , ,

      , ,, ,, , ,,,, , , ,, , ,

     ,, , , , , , , ,, ,,, , ,,

     //S2

     , , ,, ,, , , , , ,,, , ,,

      ,, , ,, , ,,, , ,, , ,, ,

      ,, ,,, ,, , , ,, , , , ,,

     , ,, , ,, , ,, , ,, , ,, ,

     //S3

     , , ,, , ,, , ,,, ,, , , ,

     , , , , , , ,, , , ,,,,, ,

     , , , , ,, , ,, , ,, ,,, ,

      ,,, , , , , , ,,, ,, , ,,

     //S4

      ,,, , , , ,, , , , ,,, ,,

     , ,, , ,, , , , , ,, ,,, ,

     , , , ,,, ,,, , ,, , , , ,

      ,, , ,, ,, , , , ,,, , ,,

     //S5

      ,, , , ,,, , , , ,,, ,, ,

     ,, ,, , ,, , , ,,, , , , ,

      , , ,,,, , ,, ,, , , , ,,

     , ,, , ,, ,, ,, , ,, , , ,

     //S6

     , ,,, , , , , ,, , ,, , ,,

     ,, , , ,, , , , ,,, ,, , ,

      ,,, , , ,, , , , ,, ,,, ,

         , , ,, , ,,,,, , , , , ,,

     //S7

      ,, ,,, , ,, ,, , , ,, , ,

     , ,, , , , ,,, , ,, ,, , ,

      , ,,,, , ,,,, , , , , , ,

      ,,, , , ,, , , , ,,, , ,,

     //S8

     , , , , ,,, ,, , ,, , ,, ,

      ,,, ,, , , ,, , ,, ,, , ,

      ,, , , ,,, , , ,,,, , , ,

      , ,, , ,, ,,,, , , , , ,

 };

 // F函数 最后第二步,对S盒输出的32进行P置换                     [组合操作]

 // 输出的值参与一次迭代:

 // L(i)=R(i-1)

 // R(i)=L(i-1)^f(R(i-1),K(i)) 异或

 static char P_Table[]={

     , ,,,,,,, ,,,, ,,,,

      , ,,,,, , ,,,, ,,, ,

 };

 // 16个子密钥K(1~16)

 static bool SubKey[][]={};

 #endif

-bool.h

 #ifndef __BOOL_H__

 #define __BOOL_H__

 typedef enum

   {

     false = ,

     true  =

   } bool;

 #endif

实验一：C语言实现DES加解密算法的更多相关文章

DES加解密算法Qt实现
算法解密qt加密table64bit [声明] (1) 本文源码大部分源码来自:DES算法代码.在此基础上,利用Qt编程进行了改写,实现了DES加解密算法,并添加了文件加解密功能.在此对署名为b ...
JavaScript与C#互通的DES加解密算法
原文地址:传送门本文提供了一个能使JavaScript与C#互通的DES加解密算法的实现,在前台页面中用JavaScript版本的DES算法将数据加密之后,传到服务器端,在服务器端可用C#版本的DE ...
DES加解密算法（C语言实现）
DES加密和解密算法的实现(C语言) 主要是做个记录,害怕以后代码丢了,先放到这里了. DES再不进行介绍了,可以看上一篇的 DES 的python实现转载请注明出处:https://www.cnb ...
实现与JS相同的Des加解密算法【转】
Java代码 import java.util.ArrayList; import java.util.List; /** * DES加密/解密 * * @Copyright Copyright (c ...
Des加解密算法
class DesHelper { /// <summary> /// DES加密方法 /// </summary> ...
JavaScript与C#互通的DES加解密算法的实现（转）
本文提供了一个能使JavaScript与C#互通的DES加解密算法的实现,在前台页面中用JavaScript版本的DES算法将数据加密之后,传到服务器端,在服务器端可用C#版本的DES解密算法将其解密 ...
C#加解密算法
先附上源码加密解密算法目前已经应用到我们生活中的各个方面加密用于达到以下目的: 保密性:帮助保护用户的标识或数据不被读取. 数据完整性:帮助保护数据不被更改. 身份验证:确保数据发自特定的一方. ...
PHP 基础篇 - PHP 中 DES 加解密详解
一.简介 DES 是对称性加密里面常见一种,全称为 Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法.密钥长度是64位(bit),超过位数密钥被忽略.所谓对 ...
Java拓展教程：文件DES加解密
Java拓展教程:文件加解密 Java中的加密解密技术加密技术根据一般可以分为对称加密技术和非对称加密技术.对称加密技术属于传统的加密技术,它的加密和解密的密钥是相同的,它的优点是:运算速度快,加密 ...

随机推荐

值得关注的 10 个 Python 英文博客
英文原文:http://pythontips.com/2013/07/31/10-python-blogs-worth-following/ 中文翻译参考: http://python.jobbole ...
hdu 1106 排序
排序 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submiss ...
Android中scrollview的scrollto方法不起作用的办法
有时候,我们在onCreate函数中调用ScrollBy函数.ScrollTo函数,会出现无效果的情况 public class ShowTraffic extends Activity Scroll ...
[Angualr 2] Using FormBuilder
There are two main functions we’ll use on FormBuilder: • control - creates a new Control• group - cr ...
Cocostudio学习笔记（1）扯扯蛋 + 环境搭建
转眼七月份就到了,2014已经过了一半,而我也最终算是有"一年工作经验"了,开心ing. 回想这一年Cocos2dx的游戏开发经历,去年下半年重心主要在游戏的逻辑上,而今年上半年重 ...
Macos Coco2d-x Android开发
1. 在装好环境 2. cocos new [-h] [-p PACKAGE_NAME] -l {cpp,lua,js} [-d DIRECTORY] [-t TEMPLATE_NAME] [--io ...
Android省电开发浅析
相信对于Android App省电的开发,一切性能优化都可以达到App的省电开发,所以一个省电的Android应用,性能优化占据很重要的位置.除此之外整理了几点关于Android应用省电的开发技巧. ...
HUD2087
#include<iostream> #include<cstdio> #include<cstring> #define maxn 1010 using name ...
C# 邮件发送注意事项
使用QQ邮箱作为smtp服务器时,遇到 "命令顺序不正确. 服务器响应为: AUTH first..",解决办法: smtpClient.UseDefaultCredentials ...
INSTALL_PARSE_FAILED_MANIFEST_MALFORMED 错误
在eclipse编译好文件之后,往AVD中安装apk,报错如下:INSTALL_PARSE_FAILED_MANIFEST_MALFORMED一般来说只需要检查AndroidManifest.xml中 ...

实验一：C语言实现DES加解密算法

实验一：C语言实现DES加解密算法的更多相关文章

随机推荐

热门专题