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 輪輪密鑰的順序顛倒一下