DES加密算法
一、 概述
DES加密算法属于对称密码算法中的分组加密算法
密钥长64位，56位参与运算，8位为检验位(8,16,24..)
DES加密将明文分为固定的字节块，对字节块进行加密，最后串在一起便是密文
二、加密流程与加密步骤
流程图
步骤(全程L1只是通过R0来填充)
三、加密步骤之IP置换
左边是初始置换表，置换后将64位明文分为两组32位数据
四、加密步骤之16轮迭代(相当于流程图中的f()函数)
F轮函数
1、 E扩展
扩展表
中间白色的是原来的数据，两边灰色的是扩展的数据
扩展规律：
每组数据的中间四个数据就是原来未扩展时的数据，扩展后第二组数据的第一个位与扩展
前，第一组数据的最后一位相等，扩展后第二组的最后一位等于扩展前数据的第一个位…以
此类推
2、异或
E扩展完成后与对应的轮密钥进行异或(密钥的生成下文会说)
3、S盒压缩处理
主要步骤就是将48位输入分为8块6位数据，经过8个S盒进行压缩，处理得到8个4位
数据，合到一起即为32位数据
主要压缩方法是将6位数据的头尾与中间分开，分别作为行数与列数，直接取对应的S盒中
查找对应的数据(四位)替换成原来的6位数据即可
下面是S盒表
4、P盒置换
将32位的数据进行置换
至此，一次轮函数完成
最终结果与L0进行异或(就是流程图中的异或)，并把值赋给R1，L1 = R0
再把L1，R1带入进行循环
反复直至得到L16与R16
五、加密步骤之逆置换
将L16与R16的值拼接到一起经过逆置换，即得到DES密文
六、密钥生成
密钥是64位的，我们通过PC-1置换表(上图)变成56位
然后把56位数据的高28位与低28位分别给C0，D0
C0，D0是第1次迭代，两个数据都需要循环左移位1次，得到C1,D1
再把C1，D1拼接起来，经过PC2表置换，得到K1，K1即为第一个轮密钥
再把C1,D1经过第2次迭代，两个数据都需要循环左移1次，得到C2,D2，再次拼接，PC-2置换，得到K2，K2即为第二个轮密钥
再把C2,D2经过第三次迭代，左移2次…
…
如此反复共16次，一共会得到16个轮密钥
参考
https://www.bilibili.com/video/BV1KQ4y127AT?spm_id_from=333.999.0.0
土豆姐姐yyds
七、第一种代码实现方案
目前网上流传两种加密DES的加密方法，感觉这种方法DES加密用的多，第二种，3DES加密用的多
代码如下:
#include <stdio.h> #include <stdlib.h> #include <string.h> //密钥 //64位变56位密钥置换表 int pc_1[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 }; //循环左移表 int left_list[16]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1}; //56位变48位密钥置换表 int pc_2[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,45,33,48, 44,49,39,56,34,53, 46,42,50,36,29,32 }; //明文 //IP置换表 int IP[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 }; //r数组拓展置换表 int E[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 }; //l数组s盒置换表 int s_box[8][4][16]={ 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 }; //P盒置换 int p[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}; //IP逆置换表 int IP_[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 }; //循环左移,arr为初始数组，start为数组的初始位置,end为数组的末尾位置 void Reverse(char *arr,int start,int end){ for(;start<end;start++,end--){ int s=arr[end]; arr[end]=arr[start]; arr[start]=s; } } //arr初始数组,n数组长度,k左移位数 1234567 void LeftShift(char *arr,int n,int k){ k=k%n; Reverse(arr,0,k-1);//将前面k位逆置1234->4321 Reverse(arr,k,n-1);//将后面几位逆置 567->765 Reverse(arr,0,n-1);//整个数组逆置4321765->5671234 } //置换表，a为初始数组,change置换表,result结果数组,len想要置换的长度 void change_table(char *a,int *change,char *result,int len){ int i; for(i=0;i<len;i++){ result[i]=a[change[i]-1]; } } //合并数组 void merge(char *dest, char *src1, char *src2) { while(*src1) *dest++ = *src1++; while(*src2) *dest++ = *src2++; } //子密钥生成函数，key为初始64位密钥,key_48为子密钥生成后的48位密钥 void get_16_key(char *key_64,char key_48[][49]){ char key_56[57]="\0";//第一次置换后保存的56位密钥 char c[17][28]; char d[17][28];//需要用到c0-c16，每个28位 memset(c,0,sizeof(c)); memset(d,0,sizeof(d)); change_table(key_64,pc_1,key_56,56);//第一次置换，64位密钥 //c0d0初始化 for(int i=0;i<56;i++){ if(i<28){ c[0][i]=key_56[i];//前面28位密钥赋值给c0 //printf("%c",c[0][i]); } else{ d[0][i-28]=key_56[i];//前面28位密钥赋值给c0 // printf("%c",d[0][i-28]); } } //生成后面的16个子密钥 printf("16个子密钥为: \n"); for(int i=1,j=0;i<17;i++,j++){ for(int s=0;s<28;s++){ c[i][s]=c[i-1][s]; d[i][s]=d[i-1][s]; } LeftShift(d[i],sizeof(d[i]),left_list[j]); LeftShift(c[i],sizeof(c[i]),left_list[j]); //每次左移完成后，将c和d拼接起来并进行第二次置换为48位子密钥 memset(key_56,0,strlen(key_56)); for(int k=0;k<56;k++){ if(k<28) key_56[k]=c[i][k]; else key_56[k]=d[i][k-28]; } change_table(key_56,pc_2,key_48[i-1],48);//得到最终的子密钥 printf("k%d=",i); puts(key_48[i-1]); } } //加密算法 void des(char *mingwen_64,char *key_64,char *result,int type){ int i,j,k; char key_48[16][49];//16个子密钥48位 char mingwen_IP[65]="\0";//IP 置换后的64位明文 char r_48[49]="\0";//拓展置换后 char l[17][33]; char r[17][33];//需要用到l0-l16,每个32位 char bit6[8][6];//s盒置换中用到的8个6位的块 char r_32[33]="\0";//p盒置换后的32位 memset(key_48,0,sizeof(key_48)); memset(l,0,sizeof(l)); memset(r,0,sizeof(r)); memset(bit6,0,sizeof(bit6)); get_16_key(key_64,key_48);//获取16个子密钥保存在key_48中 change_table(mingwen_64,IP,mingwen_IP,64);//对明文进行IP置换 //初始化l0r0 for(i=0;i<64;i++){ if(i<32){ l[0][i]=mingwen_IP[i]; }else{ r[0][i-32]=mingwen_IP[i]; } } //16次递推运算 for(i=1;i<17;i++){ //Rn=L(n-1)异或P( S ( ( E ( R(n-1) ) 异或 Kn ) ) ) //获取ln for(j=0;j<32;j++){ l[i][j]=r[i-1][j]; } //获取rn //拓展置换，将r从32位拓展到48位 change_table(r[i-1],E,r_48,48); //与k子密钥进行异或 int ch; if(type==1){ //加密 for(j=0;j<48;j++){ ch=r_48[j]^key_48[i-1][j]; r_48[j]=ch+'0'; } } else{ for(j=0;j<48;j++){ ch=r_48[j]^key_48[16-i][j]; // 加密和解密不一样的地方就在这里 // r_48[j]=ch+'0'; } } //s盒转换为32位 int a=0; int b=0;//控制s盒置换后的位置 for(j=0;j<8;j++){ //48位数据分为8个6位的块,0-7 for(k=0;k<6;k++){ bit6[j][k]=r_48[a]; a++; } int x,y,re;//x行数 y列数 re结果 x=(bit6[j][0]-'0')*2+(bit6[j][5]-'0');//取出这一块当中第一位和第六位形成十进制数x作为行数 y=(bit6[j][1]-'0')*8+(bit6[j][2]-'0')*4+(bit6[j][3]-'0')*2+(bit6[j][4]-'0');//取出中间的4位形成十进制数作为列数 //每一块都有一个对应的s盒 re=s_box[j][x][y];//去这一块对应的s盒中的x行y列找到结果 //结果转成二进制 char str[4]={'0','0','0','0'}; int q=0;//余数 int c=3; while(re!=0){ q=re%2; str[c]=q+48; c--; re=re/2; } for(int d=0;d<4;d++){ r[i][b]=str[d]; b++; } } //p盒置换后与l数组进行异或 change_table(r[i],p,r_32,32); for(j=0;j<32;j++){ r[i][j]=(l[i-1][j]^r_32[j])+'0'; } printf("N=%d\n",i); printf("L%d=",i); puts(l[i]); printf("R%d=",i); puts(r[i]); } //由r16l16和一次IP逆置换获得最终的密文 for(i=0;i<64;i++){ if(i<32){ mingwen_64[i]=r[16][i]; } else{ mingwen_64[i]=l[16][i-32]; } } change_table(mingwen_64,IP_,result,64);//IP逆置换最后的密文 } int main(){ // char mingwen_64[65];//明文0011000000110001001100100011001100110100001101010011011000110111 // char result1[65]="\0";//由明文加密得到的密文 // char ming_key_64[65];//64位加密密钥 0011000100110010001100110011010000110101001101100011011100111000 // char miwen_64[65];//密文 // char mi_key_64[65];//64位解密密钥 // char result2[65]="\0";//由密文解密得到的明文 // printf("请输入要加密的明文："); // gets(mingwen_64); // printf("请输入加密密钥："); // gets(ming_key_64); char mingwen_64[65] = "0011000000110001001100100011001100110100001101010011011000110111"; char ming_key_64[65] = "0011000100110010001100110011010000110101001101100011011100111000"; char result1[65]={0}; //加密 // printf("加密过程：\n"); des(mingwen_64,ming_key_64,result1,1);//1代表加密 printf("加密后的密文为：\n"); puts(result1); getchar(); // printf("请输入要解密的密文："); // gets(miwen_64); // printf("请输入解密密钥："); // gets(mi_key_64); //解密 // printf("解密过程：\n"); char miwen_64[65] = "1000101110110100011110100000110011110000101010010110001001101101"; char mi_key_64[65] = "0011000100110010001100110011010000110101001101100011011100111000"; char result2[65]={0}; des(miwen_64,mi_key_64,result2,2);//2代表解密 printf("解密后的明文为：\n"); puts(result2); getchar(); return 0; }
八、第二种代码实现方案
代码如下:
#include <stdio.h> #include <stddef.h> #include <stdint.h> #define DES_ENCRYPT 1 #define DES_DECRYPT 0 #define ERR_DES_INVALID_INPUT_LENGTH -0x0002 /**< The data input has an invalid length. */ #define MBEDTLS_DES_KEY_SIZE 8 #define DES_KEY_SIZE (8) #define DES3_KEY2_SIZE (16) #define DES3_KEY3_SIZE (24) typedef struct { uint32_t sk[32]; /*!< DES subkeys */ }des_context; /** * \brief Triple-DES context structure */ typedef struct { uint32_t sk[96]; /*!< 3DES subkeys */ }des3_context; #define DES_C #if defined(DES_C) #include <string.h> #include <stdlib.h> #if !defined(DES_ALT) /* Implementation that should never be optimized out by the compiler */ static void zeroize( void *v, size_t n ) { volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0; } /* * 32-bit integer manipulation macros (big endian) */ #ifndef GET_UINT32_BE #define GET_UINT32_BE(n,b,i) \ { \ (n) = ( (uint32_t) (b)[(i) ] << 24 ) \ | ( (uint32_t) (b)[(i) + 1] << 16 ) \ | ( (uint32_t) (b)[(i) + 2] << 8 ) \ | ( (uint32_t) (b)[(i) + 3] ); \ } #endif #ifndef PUT_UINT32_BE #define PUT_UINT32_BE(n,b,i) \ { \ (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ (b)[(i) + 3] = (unsigned char) ( (n) ); \ } #endif /* * Expanded DES S-boxes */ static const uint32_t SB1[64] = { 0x01010400, 0x00000000, 0x00010000, 0x01010404, 0x01010004, 0x00010404, 0x00000004, 0x00010000, 0x00000400, 0x01010400, 0x01010404, 0x00000400, 0x01000404, 0x01010004, 0x01000000, 0x00000004, 0x00000404, 0x01000400, 0x01000400, 0x00010400, 0x00010400, 0x01010000, 0x01010000, 0x01000404, 0x00010004, 0x01000004, 0x01000004, 0x00010004, 0x00000000, 0x00000404, 0x00010404, 0x01000000, 0x00010000, 0x01010404, 0x00000004, 0x01010000, 0x01010400, 0x01000000, 0x01000000, 0x00000400, 0x01010004, 0x00010000, 0x00010400, 0x01000004, 0x00000400, 0x00000004, 0x01000404, 0x00010404, 0x01010404, 0x00010004, 0x01010000, 0x01000404, 0x01000004, 0x00000404, 0x00010404, 0x01010400, 0x00000404, 0x01000400, 0x01000400, 0x00000000, 0x00010004, 0x00010400, 0x00000000, 0x01010004 }; static const uint32_t SB2[64] = { 0x80108020, 0x80008000, 0x00008000, 0x00108020, 0x00100000, 0x00000020, 0x80100020, 0x80008020, 0x80000020, 0x80108020, 0x80108000, 0x80000000, 0x80008000, 0x00100000, 0x00000020, 0x80100020, 0x00108000, 0x00100020, 0x80008020, 0x00000000, 0x80000000, 0x00008000, 0x00108020, 0x80100000, 0x00100020, 0x80000020, 0x00000000, 0x00108000, 0x00008020, 0x80108000, 0x80100000, 0x00008020, 0x00000000, 0x00108020, 0x80100020, 0x00100000, 0x80008020, 0x80100000, 0x80108000, 0x00008000, 0x80100000, 0x80008000, 0x00000020, 0x80108020, 0x00108020, 0x00000020, 0x00008000, 0x80000000, 0x00008020, 0x80108000, 0x00100000, 0x80000020, 0x00100020, 0x80008020, 0x80000020, 0x00100020, 0x00108000, 0x00000000, 0x80008000, 0x00008020, 0x80000000, 0x80100020, 0x80108020, 0x00108000 }; static const uint32_t SB3[64] = { 0x00000208, 0x08020200, 0x00000000, 0x08020008, 0x08000200, 0x00000000, 0x00020208, 0x08000200, 0x00020008, 0x08000008, 0x08000008, 0x00020000, 0x08020208, 0x00020008, 0x08020000, 0x00000208, 0x08000000, 0x00000008, 0x08020200, 0x00000200, 0x00020200, 0x08020000, 0x08020008, 0x00020208, 0x08000208, 0x00020200, 0x00020000, 0x08000208, 0x00000008, 0x08020208, 0x00000200, 0x08000000, 0x08020200, 0x08000000, 0x00020008, 0x00000208, 0x00020000, 0x08020200, 0x08000200, 0x00000000, 0x00000200, 0x00020008, 0x08020208, 0x08000200, 0x08000008, 0x00000200, 0x00000000, 0x08020008, 0x08000208, 0x00020000, 0x08000000, 0x08020208, 0x00000008, 0x00020208, 0x00020200, 0x08000008, 0x08020000, 0x08000208, 0x00000208, 0x08020000, 0x00020208, 0x00000008, 0x08020008, 0x00020200 }; static const uint32_t SB4[64] = { 0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802080, 0x00800081, 0x00800001, 0x00002001, 0x00000000, 0x00802000, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00800080, 0x00800001, 0x00000001, 0x00002000, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002001, 0x00002080, 0x00800081, 0x00000001, 0x00002080, 0x00800080, 0x00002000, 0x00802080, 0x00802081, 0x00000081, 0x00800080, 0x00800001, 0x00802000, 0x00802081, 0x00000081, 0x00000000, 0x00000000, 0x00802000, 0x00002080, 0x00800080, 0x00800081, 0x00000001, 0x00802001, 0x00002081, 0x00002081, 0x00000080, 0x00802081, 0x00000081, 0x00000001, 0x00002000, 0x00800001, 0x00002001, 0x00802080, 0x00800081, 0x00002001, 0x00002080, 0x00800000, 0x00802001, 0x00000080, 0x00800000, 0x00002000, 0x00802080 }; static const uint32_t SB5[64] = { 0x00000100, 0x02080100, 0x02080000, 0x42000100, 0x00080000, 0x00000100, 0x40000000, 0x02080000, 0x40080100, 0x00080000, 0x02000100, 0x40080100, 0x42000100, 0x42080000, 0x00080100, 0x40000000, 0x02000000, 0x40080000, 0x40080000, 0x00000000, 0x40000100, 0x42080100, 0x42080100, 0x02000100, 0x42080000, 0x40000100, 0x00000000, 0x42000000, 0x02080100, 0x02000000, 0x42000000, 0x00080100, 0x00080000, 0x42000100, 0x00000100, 0x02000000, 0x40000000, 0x02080000, 0x42000100, 0x40080100, 0x02000100, 0x40000000, 0x42080000, 0x02080100, 0x40080100, 0x00000100, 0x02000000, 0x42080000, 0x42080100, 0x00080100, 0x42000000, 0x42080100, 0x02080000, 0x00000000, 0x40080000, 0x42000000, 0x00080100, 0x02000100, 0x40000100, 0x00080000, 0x00000000, 0x40080000, 0x02080100, 0x40000100 }; static const uint32_t SB6[64] = { 0x20000010, 0x20400000, 0x00004000, 0x20404010, 0x20400000, 0x00000010, 0x20404010, 0x00400000, 0x20004000, 0x00404010, 0x00400000, 0x20000010, 0x00400010, 0x20004000, 0x20000000, 0x00004010, 0x00000000, 0x00400010, 0x20004010, 0x00004000, 0x00404000, 0x20004010, 0x00000010, 0x20400010, 0x20400010, 0x00000000, 0x00404010, 0x20404000, 0x00004010, 0x00404000, 0x20404000, 0x20000000, 0x20004000, 0x00000010, 0x20400010, 0x00404000, 0x20404010, 0x00400000, 0x00004010, 0x20000010, 0x00400000, 0x20004000, 0x20000000, 0x00004010, 0x20000010, 0x20404010, 0x00404000, 0x20400000, 0x00404010, 0x20404000, 0x00000000, 0x20400010, 0x00000010, 0x00004000, 0x20400000, 0x00404010, 0x00004000, 0x00400010, 0x20004010, 0x00000000, 0x20404000, 0x20000000, 0x00400010, 0x20004010 }; static const uint32_t SB7[64] = { 0x00200000, 0x04200002, 0x04000802, 0x00000000, 0x00000800, 0x04000802, 0x00200802, 0x04200800, 0x04200802, 0x00200000, 0x00000000, 0x04000002, 0x00000002, 0x04000000, 0x04200002, 0x00000802, 0x04000800, 0x00200802, 0x00200002, 0x04000800, 0x04000002, 0x04200000, 0x04200800, 0x00200002, 0x04200000, 0x00000800, 0x00000802, 0x04200802, 0x00200800, 0x00000002, 0x04000000, 0x00200800, 0x04000000, 0x00200800, 0x00200000, 0x04000802, 0x04000802, 0x04200002, 0x04200002, 0x00000002, 0x00200002, 0x04000000, 0x04000800, 0x00200000, 0x04200800, 0x00000802, 0x00200802, 0x04200800, 0x00000802, 0x04000002, 0x04200802, 0x04200000, 0x00200800, 0x00000000, 0x00000002, 0x04200802, 0x00000000, 0x00200802, 0x04200000, 0x00000800, 0x04000002, 0x04000800, 0x00000800, 0x00200002 }; static const uint32_t SB8[64] = { 0x10001040, 0x00001000, 0x00040000, 0x10041040, 0x10000000, 0x10001040, 0x00000040, 0x10000000, 0x00040040, 0x10040000, 0x10041040, 0x00041000, 0x10041000, 0x00041040, 0x00001000, 0x00000040, 0x10040000, 0x10000040, 0x10001000, 0x00001040, 0x00041000, 0x00040040, 0x10040040, 0x10041000, 0x00001040, 0x00000000, 0x00000000, 0x10040040, 0x10000040, 0x10001000, 0x00041040, 0x00040000, 0x00041040, 0x00040000, 0x10041000, 0x00001000, 0x00000040, 0x10040040, 0x00001000, 0x00041040, 0x10001000, 0x00000040, 0x10000040, 0x10040000, 0x10040040, 0x10000000, 0x00040000, 0x10001040, 0x00000000, 0x10041040, 0x00040040, 0x10000040, 0x10040000, 0x10001000, 0x10001040, 0x00000000, 0x10041040, 0x00041000, 0x00041000, 0x00001040, 0x00001040, 0x00040040, 0x10000000, 0x10041000 }; /* * PC1: left and right halves bit-swap */ static const uint32_t LHs[16] = { 0x00000000, 0x00000001, 0x00000100, 0x00000101, 0x00010000, 0x00010001, 0x00010100, 0x00010101, 0x01000000, 0x01000001, 0x01000100, 0x01000101, 0x01010000, 0x01010001, 0x01010100, 0x01010101 }; static const uint32_t RHs[16] = { 0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100, 0x01000100, 0x00010100, 0x01010100, 0x00000001, 0x01000001, 0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101, 0x01010101, }; /* * Initial Permutation macro */ #define DES_IP(X,Y) \ { \ T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \ T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \ T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \ T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \ Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \ T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \ X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \ } /* * Final Permutation macro */ #define DES_FP(X,Y) \ { \ X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \ T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \ Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \ T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \ T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \ T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \ T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \ } /* * DES round macro */ #define DES_ROUND(X,Y) \ { \ T = *SK++ ^ X; \ Y ^= SB8[ (T ) & 0x3F ] ^ \ SB6[ (T >> 8) & 0x3F ] ^ \ SB4[ (T >> 16) & 0x3F ] ^ \ SB2[ (T >> 24) & 0x3F ]; \ \ T = *SK++ ^ ((X << 28) | (X >> 4)); \ Y ^= SB7[ (T ) & 0x3F ] ^ \ SB5[ (T >> 8) & 0x3F ] ^ \ SB3[ (T >> 16) & 0x3F ] ^ \ SB1[ (T >> 24) & 0x3F ]; \ } #define SWAP(a,b) { uint32_t t = a; a = b; b = t; t = 0; } void des_init( des_context *ctx ) { memset( ctx, 0, sizeof( des_context ) ); } void des_free( des_context *ctx ) { if( ctx == NULL ) return; zeroize( ctx, sizeof( des_context ) ); } void des3_init( des3_context *ctx ) { memset( ctx, 0, sizeof( des3_context ) ); } void des3_free( des3_context *ctx ) { if( ctx == NULL ) return; zeroize( ctx, sizeof( des3_context ) ); } static const unsigned char odd_parity_table[128] = { 1, 2, 4, 7, 8, 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44, 47, 49, 50, 52, 55, 56, 59, 61, 62, 64, 67, 69, 70, 73, 74, 76, 79, 81, 82, 84, 87, 88, 91, 93, 94, 97, 98, 100, 103, 104, 107, 109, 110, 112, 115, 117, 118, 121, 122, 124, 127, 128, 131, 133, 134, 137, 138, 140, 143, 145, 146, 148, 151, 152, 155, 157, 158, 161, 162, 164, 167, 168, 171, 173, 174, 176, 179, 181, 182, 185, 186, 188, 191, 193, 194, 196, 199, 200, 203, 205, 206, 208, 211, 213, 214, 217, 218, 220, 223, 224, 227, 229, 230, 233, 234, 236, 239, 241, 242, 244, 247, 248, 251, 253, 254 }; void des_key_set_parity( unsigned char key[DES_KEY_SIZE] ) { int i; for( i = 0; i < DES_KEY_SIZE; i++ ) key[i] = odd_parity_table[key[i] / 2]; } /* * Check the given key's parity, returns 1 on failure, 0 on SUCCESS */ int des_key_check_key_parity( const unsigned char key[DES_KEY_SIZE] ) { int i; for( i = 0; i < DES_KEY_SIZE; i++ ) if( key[i] != odd_parity_table[key[i] / 2] ) return( 1 ); return( 0 ); } /* * Table of weak and semi-weak keys * * Source: http://en.wikipedia.org/wiki/Weak_key * * Weak: * Alternating ones + zeros (0x0101010101010101) * Alternating 'F' + 'E' (0xFEFEFEFEFEFEFEFE) * '0xE0E0E0E0F1F1F1F1' * '0x1F1F1F1F0E0E0E0E' * * Semi-weak: * 0x011F011F010E010E and 0x1F011F010E010E01 * 0x01E001E001F101F1 and 0xE001E001F101F101 * 0x01FE01FE01FE01FE and 0xFE01FE01FE01FE01 * 0x1FE01FE00EF10EF1 and 0xE01FE01FF10EF10E * 0x1FFE1FFE0EFE0EFE and 0xFE1FFE1FFE0EFE0E * 0xE0FEE0FEF1FEF1FE and 0xFEE0FEE0FEF1FEF1 * */ #define WEAK_KEY_COUNT 16 static const unsigned char weak_key_table[WEAK_KEY_COUNT][DES_KEY_SIZE] = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE }, { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E }, { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 }, { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E }, { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 }, { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 }, { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 }, { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE }, { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 }, { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 }, { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E }, { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE }, { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E }, { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE }, { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 } }; int des_key_check_weak( const unsigned char key[DES_KEY_SIZE] ) { int i; for( i = 0; i < WEAK_KEY_COUNT; i++ ) if( memcmp( weak_key_table[i], key, DES_KEY_SIZE) == 0 ) return( 1 ); return( 0 ); } void des_setkey( uint32_t SK[32], const unsigned char key[DES_KEY_SIZE] ) { int i; uint32_t X, Y, T; GET_UINT32_BE( X, key, 0 ); GET_UINT32_BE( Y, key, 4 ); /* * Permuted Choice 1 */ T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4); T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T ); X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2) | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] ) | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6) | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4); Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2) | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] ) | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6) | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4); X &= 0x0FFFFFFF; Y &= 0x0FFFFFFF; /* * calculate subkeys */ for( i = 0; i < 16; i++ ) { if( i < 2 || i == 8 || i == 15 ) { X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF; Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF; } else { X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF; Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF; } *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000) | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000) | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000) | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000) | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000) | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000) | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400) | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100) | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010) | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004) | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001); *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000) | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000) | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000) | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000) | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000) | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000) | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000) | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400) | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100) | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011) | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002); } } /* * DES key schedule (56-bit, encryption) */ int des_setkey_enc( des_context *ctx, const unsigned char key[DES_KEY_SIZE] ) { des_setkey( ctx->sk, key ); return( 0 ); } /* * DES key schedule (56-bit, decryption) */ int des_setkey_dec( des_context *ctx, const unsigned char key[DES_KEY_SIZE] ) { int i; des_setkey( ctx->sk, key ); for( i = 0; i < 16; i += 2 ) { SWAP( ctx->sk[i ], ctx->sk[30 - i] ); SWAP( ctx->sk[i + 1], ctx->sk[31 - i] ); } return( 0 ); } static void des3_set2key( uint32_t esk[96], uint32_t dsk[96], const unsigned char key[DES_KEY_SIZE*2] ) { int i; des_setkey( esk, key ); des_setkey( dsk + 32, key + 8 ); for( i = 0; i < 32; i += 2 ) { dsk[i ] = esk[30 - i]; dsk[i + 1] = esk[31 - i]; esk[i + 32] = dsk[62 - i]; esk[i + 33] = dsk[63 - i]; esk[i + 64] = esk[i ]; esk[i + 65] = esk[i + 1]; dsk[i + 64] = dsk[i ]; dsk[i + 65] = dsk[i + 1]; } } /* * Triple-DES key schedule (112-bit, encryption) */ int des3_set2key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] ) { uint32_t sk[96]; des3_set2key( ctx->sk, sk, key ); zeroize( sk, sizeof( sk ) ); return( 0 ); } /* * Triple-DES key schedule (112-bit, decryption) */ int des3_set2key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 2] ) { uint32_t sk[96]; des3_set2key( sk, ctx->sk, key ); zeroize( sk, sizeof( sk ) ); return( 0 ); } static void des3_set3key( uint32_t esk[96], uint32_t dsk[96], const unsigned char key[24] ) { int i; des_setkey( esk, key ); des_setkey( dsk + 32, key + 8 ); des_setkey( esk + 64, key + 16 ); for( i = 0; i < 32; i += 2 ) { dsk[i ] = esk[94 - i]; dsk[i + 1] = esk[95 - i]; esk[i + 32] = dsk[62 - i]; esk[i + 33] = dsk[63 - i]; dsk[i + 64] = esk[30 - i]; dsk[i + 65] = esk[31 - i]; } } /* * Triple-DES key schedule (168-bit, encryption) */ int des3_set3key_enc( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] ) { uint32_t sk[96]; des3_set3key( ctx->sk, sk, key ); zeroize( sk, sizeof( sk ) ); return( 0 ); } /* * Triple-DES key schedule (168-bit, decryption) */ int des3_set3key_dec( des3_context *ctx, const unsigned char key[DES_KEY_SIZE * 3] ) { uint32_t sk[96]; des3_set3key( sk, ctx->sk, key ); zeroize( sk, sizeof( sk ) ); return( 0 ); } /* * DES-ECB block encryption/decryption */ int des_crypt_ecb( des_context *ctx, const unsigned char input[8], unsigned char output[8] ) { int i; uint32_t X, Y, T, *SK; SK = ctx->sk; GET_UINT32_BE( X, input, 0 ); GET_UINT32_BE( Y, input, 4 ); DES_IP( X, Y ); for( i = 0; i < 8; i++ ) { DES_ROUND( Y, X ); DES_ROUND( X, Y ); } DES_FP( Y, X ); PUT_UINT32_BE( Y, output, 0 ); PUT_UINT32_BE( X, output, 4 ); return( 0 ); } /* * DES-CBC buffer encryption/decryption */ int des_crypt_cbc( des_context *ctx, int mode, size_t length, unsigned char iv[8], const unsigned char *input, unsigned char *output ) { int i; unsigned char temp[8]; if( length % 8 ) return( ERR_DES_INVALID_INPUT_LENGTH ); if( mode == DES_ENCRYPT ) { while( length > 0 ) { for( i = 0; i < 8; i++ ) output[i] = (unsigned char)( input[i] ^ iv[i] ); des_crypt_ecb( ctx, output, output ); memcpy( iv, output, 8 ); input += 8; output += 8; length -= 8; } } else /* DES_DECRYPT */ { while( length > 0 ) { memcpy( temp, input, 8 ); des_crypt_ecb( ctx, input, output ); for( i = 0; i < 8; i++ ) output[i] = (unsigned char)( output[i] ^ iv[i] ); memcpy( iv, temp, 8 ); input += 8; output += 8; length -= 8; } } return( 0 ); } /* * 3DES-ECB block encryption/decryption */ int des3_crypt_ecb( des3_context *ctx, const unsigned char input[8], unsigned char output[8] ) { int i; uint32_t X, Y, T, *SK; SK = ctx->sk; GET_UINT32_BE( X, input, 0 ); GET_UINT32_BE( Y, input, 4 ); DES_IP( X, Y ); for( i = 0; i < 8; i++ ) { DES_ROUND( Y, X ); DES_ROUND( X, Y ); } for( i = 0; i < 8; i++ ) { DES_ROUND( X, Y ); DES_ROUND( Y, X ); } for( i = 0; i < 8; i++ ) { DES_ROUND( Y, X ); DES_ROUND( X, Y ); } DES_FP( Y, X ); PUT_UINT32_BE( Y, output, 0 ); PUT_UINT32_BE( X, output, 4 ); return( 0 ); } /* * 3DES-CBC buffer encryption/decryption */ int des3_crypt_cbc( des3_context *ctx, int mode, size_t length, unsigned char iv[8], const unsigned char *input, unsigned char *output ) { int i; unsigned char temp[8]; if( length % 8 ) return( ERR_DES_INVALID_INPUT_LENGTH ); if( mode == DES_ENCRYPT ) { while( length > 0 ) { for( i = 0; i < 8; i++ ) output[i] = (unsigned char)( input[i] ^ iv[i] ); des3_crypt_ecb( ctx, output, output ); memcpy( iv, output, 8 ); input += 8; output += 8; length -= 8; } } else /* DES_DECRYPT */ { while( length > 0 ) { memcpy( temp, input, 8 ); des3_crypt_ecb( ctx, input, output ); for( i = 0; i < 8; i++ ) output[i] = (unsigned char)( output[i] ^ iv[i] ); memcpy( iv, temp, 8 ); input += 8; output += 8; length -= 8; } } return( 0 ); } #endif /* !DES_ALT */ #endif /* DES_C */ /* * DES-ECB buffer encryption API */ unsigned int des_ecb_encrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey) { unsigned char *tmp; unsigned int len,i; unsigned char ch = '\0'; des_context ctx; des_setkey_enc( &ctx, pkey ); len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8; //ch = 8 - nlen % 8; for(i = 0;i < nlen;i += 8) { des_crypt_ecb( &ctx, (pdata + i), (pout + i) ); } if(len > nlen) { tmp = (unsigned char *)malloc(len); i -= 8; memcpy(tmp,pdata + i,nlen - i); memset(tmp + nlen % 8, ch, (8 - nlen % 8) % 8); des_crypt_ecb( &ctx, tmp, (pout + i)); free(tmp); } des_free( &ctx ); return len; } /* * DES-ECB buffer decryption API */ unsigned int des_ecb_decrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey) { unsigned int i; des_context ctx; if(nlen % 8) return 1; des_setkey_dec( &ctx, pkey ); for(i = 0;i < nlen;i += 8) { des_crypt_ecb(&ctx, (pdata + i), (pout + i)); } des_free( &ctx ); return 0; } /* * DES-CBC buffer encryption API */ unsigned int des_cbc_encrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey, unsigned char *piv) { des_context ctx; unsigned char iv[8] = {0}; unsigned char *pivb; if(piv == NULL) pivb = iv; else pivb = piv; des_setkey_enc( &ctx, pkey ); des_crypt_cbc( &ctx, 1, nlen, pivb, pdata, (pout)); des_free( &ctx ); return nlen; } /* * DES-CBC buffer decryption API */ unsigned int des_cbc_decrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey, unsigned char *piv) { des_context ctx; unsigned char iv[8] = {0}; unsigned char *pivb; if(piv == NULL) pivb = iv; else pivb = piv; des_setkey_dec( &ctx, pkey ); des_crypt_cbc( &ctx, 0, nlen, pivb, pdata, (pout)); des_free( &ctx ); return 0; } /* * 3DES-ECB buffer encryption API */ unsigned int des3_ecb_encrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey, unsigned int klen) { unsigned char *tmp; unsigned int len,i; unsigned char ch = '\0'; des3_context ctx3; if(klen == DES3_KEY2_SIZE)//16字节 des3_set2key_enc( &ctx3, pkey );//根据长度设置key else if(klen == DES3_KEY3_SIZE)//24字节 des3_set3key_enc( &ctx3, pkey ); len = (nlen / 8 + (nlen % 8 ? 1: 0)) * 8; //ch = 8 - nlen % 8;//可以设置补齐内容，常用0或0xFF for(i = 0;i < nlen;i += 8) { des3_crypt_ecb( &ctx3, (pdata + i), (pout + i) ); } if(len > nlen)//不足8字节补齐 { tmp = (unsigned char *)malloc(len); i -= 8; memcpy(tmp,pdata + i,nlen - i); memset(tmp + nlen % 8, ch, (8 - nlen % 8) % 8); des3_crypt_ecb( &ctx3, tmp, (pout + i)); free(tmp); } des3_free( &ctx3 ); return len; } /* * 3DES-ECB buffer decryption API */ unsigned int des3_ecb_decrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey, unsigned int klen) { unsigned int i; des3_context ctx3; if(nlen % 8) return 1; if(klen == DES3_KEY2_SIZE) des3_set2key_dec( &ctx3, pkey ); else if(klen == DES3_KEY3_SIZE) des3_set3key_dec( &ctx3, pkey ); for(i = 0;i < nlen;i += 8) { des3_crypt_ecb(&ctx3, (pdata + i), (pout + i)); } des3_free( &ctx3 ); return 0; } /* * 3DES-CBC buffer encryption API */ unsigned int des3_cbc_encrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey, unsigned int klen, unsigned char *piv) { des3_context ctx; unsigned char iv[8] = {0}; unsigned char *pivb; unsigned int len; unsigned char * tmp; if(piv == NULL) pivb = iv; else pivb = piv; if(klen == DES3_KEY2_SIZE) des3_set2key_enc( &ctx, pkey ); else if(klen == DES3_KEY3_SIZE) des3_set3key_enc( &ctx, pkey ); if(nlen % 8) { len = nlen + 8 - nlen % 8; tmp = (unsigned char *)calloc(1, len); memcpy(tmp, pdata, nlen); des3_crypt_cbc( &ctx, 1, len, pivb, tmp, (pout)); free(tmp); } else { des3_crypt_cbc( &ctx, 1, nlen, pivb, pdata, (pout)); } des3_free( &ctx ); return nlen; } /* * 3DES-CBC buffer decryption API */ unsigned int des3_cbc_decrypt(unsigned char *pout, unsigned char *pdata, unsigned int nlen, unsigned char *pkey, unsigned int klen, unsigned char *piv) { des3_context ctx; unsigned char iv[8] = {0}; unsigned char *pivb; if(nlen % 8) return 1; if(piv == NULL) pivb = iv; else pivb = piv; if(klen == DES3_KEY2_SIZE) des3_set2key_dec( &ctx, pkey ); else if(klen == DES3_KEY3_SIZE) des3_set3key_dec( &ctx, pkey ); des3_crypt_cbc( &ctx, 0, nlen, pivb, pdata, (pout)); des3_free( &ctx ); return 0; } //main函数测试 int des_test_self() { unsigned char buff[1024] = {0}; unsigned char data[1024] = {0x3F,0x12,0xE7,0xC0,0x2D,0x66,0x5A,0xB0,0xC4,0x2E,0x58,0xF1}; int ret,len,i; // len = MyStrToHex("3F12E7C02D665AB0C42E58F1", data);//不满8字节 len = strlen((char*)data); for(i = 0;i < len;i++) { printf("%02X",data[i]); } printf("\r\n"); unsigned char key[16] = {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0x00,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF}; //DES ECB 加密 printf("DES ECB ENC::\r\n"); ret = des_ecb_encrypt(buff,data,len,key); for(i = 0;i < ret;i++) { printf("%02X",buff[i]); } printf("\r\n"); //DES ECB 解密 printf("DES ECB DEC::\r\n"); memset(data,0,sizeof(data)); des_ecb_decrypt(data,buff,ret,key); for(i = 0;i < ret;i++) { printf("%02X",data[i]); } printf("\r\n"); //DES CBC 加密 printf("DES CBC ENC::\r\n"); memset(buff,0,sizeof(buff)); des_cbc_encrypt(buff,data,ret,key,NULL); for(i = 0;i < ret;i++) { printf("%02X",buff[i]); } printf("\r\n"); //DES CBC 解密 printf("DES CBC DEC::\r\n"); memset(data,0,sizeof(data)); des_cbc_decrypt(data,buff,ret,key,NULL); for(i = 0;i < ret;i++) { printf("%02X",data[i]); } printf("\r\n"); printf("\r\n"); //3DES ECB 加密 printf("3DES ECB ENC::\r\n"); ret = des3_ecb_encrypt(buff,data,len,key,16); for(i = 0;i < ret;i++) { printf("%02X",buff[i]); } printf("\r\n"); //3DES ECB 解密 printf("3DES ECB DEC::\r\n"); memset(data,0,sizeof(data)); des3_ecb_decrypt(data,buff,ret,key,16); for(i = 0;i < ret;i++) { printf("%02X",data[i]); } printf("\r\n"); //3DES CBC 加密 printf("3DES CBC ENC::\r\n"); memset(buff,0,sizeof(buff)); des3_cbc_encrypt(buff,data,ret,key,16,NULL); for(i = 0;i < ret;i++) { printf("%02X",buff[i]); } printf("\r\n"); //3DES CBC 解密 printf("3DES CBC DEC::\r\n"); memset(data,0,sizeof(data)); des3_cbc_decrypt(data,buff,ret,key,16,NULL); for(i = 0;i < ret;i++) { printf("%02X",data[i]); } printf("\r\n"); return 0; } int main(){ des_test_self(); return 0; }
九、DES解密方法
des:
参考 https://developer.aliyun.com/article/173633
就是异或的 17 轮轮密钥的顺序颠倒一下