#include "des.h"
#include <stdint.h>
/************byte2bit(change 64byte to 64bit-8byte)（begin）********************/
void byte2bit(unsigned char byte[64] , unsigned char bit[8])
{
int i = 0 ;
/*byte1*/
for(i = 0;i < 8;i++)
{
if(byte[0] == 0x1) bit[0] = bit[0] | 0x80 ;
else bit[0] = bit[0] & 0x7f ;
if(byte[1] == 0x1) bit[0] = bit[0] | 0x40 ;
else bit[0] = bit[0] & 0xbf ;
if(byte[2] == 0x1) bit[0] = bit[0] | 0x20 ;
else bit[0] = bit[0] & 0xdf ;
if(byte[3] == 0x1) bit[0] = bit[0] | 0x10 ;
else bit[0] = bit[0] & 0xef ;
if(byte[4] == 0x1) bit[0] = bit[0] | 0x08 ;
else bit[0] = bit[0] & 0xf7 ;
if(byte[5] == 0x1) bit[0] = bit[0] | 0x04 ;
else bit[0] = bit[0] & 0xfb ;
if(byte[6] == 0x1) bit[0] = bit[0] | 0x02 ;
else bit[0] = bit[0] & 0xfd ;
if(byte[7] == 0x1) bit[0] = bit[0] | 0x01 ;
else bit[0] = bit[0] & 0xfe ;
}
/*byte2*/
for(i = 8;i < 16;i++)
{
if(byte[8] == 0x1) bit[1] = bit[1] | 0x80 ;
else bit[1] = bit[1] & 0x7f ;
if(byte[9] == 0x1) bit[1] = bit[1] | 0x40 ;
else bit[1] = bit[1] & 0xbf ;
if(byte[10] == 0x1) bit[1] = bit[1] | 0x20 ;
else bit[1] = bit[1] & 0xdf ;
if(byte[11] == 0x1) bit[1] = bit[1] | 0x10 ;
else bit[1] = bit[1] & 0xef ;
if(byte[12] == 0x1) bit[1] = bit[1] | 0x08 ;
else bit[1] = bit[1] & 0xf7 ;
if(byte[13] == 0x1) bit[1] = bit[1] | 0x04 ;
else bit[1] = bit[1] & 0xfb ;
if(byte[14] == 0x1) bit[1] = bit[1] | 0x02 ;
else bit[1] = bit[1] & 0xfd ;
if(byte[15] == 0x1) bit[1] = bit[1] | 0x01 ;
else bit[1] = bit[1] & 0xfe ;
}
/*byte3*/
for(i = 16;i < 24 ;i++)
{
if(byte[16] == 0x1) bit[2] = bit[2] | 0x80 ;
else bit[2] = bit[2] & 0x7f ;
if(byte[17] == 0x1) bit[2] = bit[2] | 0x40 ;
else bit[2] = bit[2] & 0xbf ;
if(byte[18] == 0x1) bit[2] = bit[2] | 0x20 ;
else bit[2] = bit[2] & 0xdf ;
if(byte[19] == 0x1) bit[2] = bit[2] | 0x10 ;
else bit[2] = bit[2] & 0xef ;
if(byte[20] == 0x1) bit[2] = bit[2] | 0x08 ;
else bit[2] = bit[2] & 0xf7 ;
if(byte[21] == 0x1) bit[2] = bit[2] | 0x04 ;
else bit[2] = bit[2] & 0xfb ;
if(byte[22] == 0x1) bit[2] = bit[2] | 0x02 ;
else bit[2] = bit[2] & 0xfd ;
if(byte[23] == 0x1) bit[2] = bit[2] | 0x01 ;
else bit[2] = bit[2] & 0xfe ;
}
/*byte4*/
for(i = 24;i < 32 ;i++)
{
if(byte[24] == 0x1) bit[3] = bit[3] | 0x80 ;
else bit[3] = bit[3] & 0x7f ;
if(byte[25] == 0x1) bit[3] = bit[3] | 0x40 ;
else bit[3] = bit[3] & 0xbf ;
if(byte[26] == 0x1) bit[3] = bit[3] | 0x20 ;
else bit[3] = bit[3] & 0xdf ;
if(byte[27] == 0x1) bit[3] = bit[3] | 0x10 ;
else bit[3] = bit[3] & 0xef ;
if(byte[28] == 0x1) bit[3] = bit[3] | 0x08 ;
else bit[3] = bit[3] & 0xf7 ;
if(byte[29] == 0x1) bit[3] = bit[3] | 0x04 ;
else bit[3] = bit[3] & 0xfb ;
if(byte[30] == 0x1) bit[3] = bit[3] | 0x02 ;
else bit[3] = bit[3] & 0xfd ;
if(byte[31] == 0x1) bit[3] = bit[3] | 0x01 ;
else bit[3] = bit[3] & 0xfe ;
}
/*byte5*/
for(i = 32;i < 40 ;i++)
{
if(byte[32] == 0x1) bit[4] = bit[4] | 0x80 ;
else bit[4] = bit[4] & 0x7f ;
if(byte[33] == 0x1) bit[4] = bit[4] | 0x40 ;
else bit[4] = bit[4] & 0xbf ;
if(byte[34] == 0x1) bit[4] = bit[4] | 0x20 ;
else bit[4] = bit[4] & 0xdf ;
if(byte[35] == 0x1) bit[4] = bit[4] | 0x10 ;
else bit[4] = bit[4] & 0xef ;
if(byte[36] == 0x1) bit[4] = bit[4] | 0x08 ;
else bit[4] = bit[4] & 0xf7 ;
if(byte[37] == 0x1) bit[4] = bit[4] | 0x04 ;
else bit[4] = bit[4] & 0xfb ;
if(byte[38] == 0x1) bit[4] = bit[4] | 0x02 ;
else bit[4] = bit[4] & 0xfd ;
if(byte[39] == 0x1) bit[4] = bit[4] | 0x01 ;
else bit[4] = bit[4] & 0xfe ;
}
/*byte6*/
for(i = 40;i < 48 ;i++)
{
if(byte[40] == 0x1) bit[5] = bit[5] | 0x80 ;
else bit[5] = bit[5] & 0x7f ;
if(byte[41] == 0x1) bit[5] = bit[5] | 0x40 ;
else bit[5] = bit[5] & 0xbf ;
if(byte[42] == 0x1) bit[5] = bit[5] | 0x20 ;
else bit[5] = bit[5] & 0xdf ;
if(byte[43] == 0x1) bit[5] = bit[5] | 0x10 ;
else bit[5] = bit[5] & 0xef ;
if(byte[44] == 0x1) bit[5] = bit[5] | 0x08 ;
else bit[5] = bit[5] & 0xf7 ;
if(byte[45] == 0x1) bit[5] = bit[5] | 0x04 ;
else bit[5] = bit[5] & 0xfb ;
if(byte[46] == 0x1) bit[5] = bit[5] | 0x02 ;
else bit[5] = bit[5] & 0xfd ;
if(byte[47] == 0x1) bit[5] = bit[5] | 0x01 ;
else bit[5] = bit[5] & 0xfe ;
}
/*byte7*/
for(i = 48;i < 56 ;i++)
{
if(byte[48] == 0x1) bit[6] = bit[6] | 0x80 ;
else bit[6] = bit[6] & 0x7f ;
if(byte[49] == 0x1) bit[6] = bit[6] | 0x40 ;
else bit[6] = bit[6] & 0xbf ;
if(byte[50] == 0x1) bit[6] = bit[6] | 0x20 ;
else bit[6] = bit[6] & 0xdf ;
if(byte[51] == 0x1) bit[6] = bit[6] | 0x10 ;
else bit[6] = bit[6] & 0xef ;
if(byte[52] == 0x1) bit[6] = bit[6] | 0x08 ;
else bit[6] = bit[6] & 0xf7;
if(byte[53] == 0x1) bit[6] = bit[6] | 0x04 ;
else bit[6] = bit[6] & 0xfb ;
if(byte[54] == 0x1) bit[6] = bit[6] | 0x02 ;
else bit[6] = bit[6] & 0xfd ;
if(byte[55] == 0x1) bit[6] = bit[6] | 0x01 ;
else bit[6] = bit[6] & 0xfe ;
}
/*byte8*/
for(i = 56;i < 64 ;i++)
{
if(byte[56] == 0x1) bit[7] = bit[7] | 0x80 ;
else bit[7] = bit[7] & 0x7f ;
if(byte[57] == 0x1) bit[7] = bit[7] | 0x40 ;
else bit[7] = bit[7] & 0xbf ;
if(byte[58] == 0x1) bit[7] = bit[7] | 0x20 ;
else bit[7] = bit[7] & 0xdf ;
if(byte[59] == 0x1) bit[7] = bit[7] | 0x10 ;
else bit[7] = bit[7] & 0xef ;
if(byte[60] == 0x1) bit[7] = bit[7] | 0x08 ;
else bit[7] = bit[7] & 0xf7 ;
if(byte[61] == 0x1) bit[7] = bit[7] | 0x04 ;
else bit[7] = bit[7] & 0xfb ;
if(byte[62] == 0x1) bit[7] = bit[7] | 0x02 ;
else bit[7] = bit[7] & 0xfd ;
if(byte[63] == 0x1) bit[7] = bit[7] | 0x01 ;
else bit[7] = bit[7] & 0xfe ;
}
}
/******************************byte2bit（end）**********************************/
/***********bit2byte(change 64bit-8byte to 64byte)（begin）*********************/
void bit2byte(unsigned char bit[8] , unsigned char byte[64])
{
int i=0 ;
for(i=0 ; i<=63 ; i++)
{
byte[i] = 0x0 ;
}
for(i=0 ; i<=7 ; i++)
{
if((bit[i] & 0x80) == 0x80) byte[i*8+0] = 0x01 ;
if((bit[i] & 0x40) == 0x40) byte[i*8+1] = 0x01 ;
if((bit[i] & 0x20) == 0x20) byte[i*8+2] = 0x01 ;
if((bit[i] & 0x10) == 0x10) byte[i*8+3] = 0x01 ;
if((bit[i] & 0x08) == 0x08) byte[i*8+4] = 0x01 ;
if((bit[i] & 0x04) == 0x04) byte[i*8+5] = 0x01 ;
if((bit[i] & 0x02) == 0x02) byte[i*8+6] = 0x01 ;
if((bit[i] & 0x01) == 0x01) byte[i*8+7] = 0x01 ;
}
}
/******************************bit2byte（end）**********************************/
/*********************************IP置换（begin）*******************************/
void ip_permute(unsigned char array[64])
{
int i;
unsigned char temp[64];
for(i=0;i<64;i++) temp[i]=array[ip[i]-1];
for(i=0;i<64;i++) array[i]=temp[i];
}
/*********************************IP置换（end）*********************************/
/*********************************IP逆置换（begin）*****************************/
void ip_1_permute(unsigned char array[64])
{
int i;
unsigned char temp[64];
for(i=0;i<64;i++) temp[i]=array[ip_1[i]-1];
for(i=0;i<64;i++) array[i]=temp[i];
}
/*********************************IP逆置换（end）*******************************/
/***********************E置换--32位膨胀为48位（begin）**************************/
void expand(unsigned char array[64])
{
int i;
unsigned char temp[64];
for(i=0;i<48;i++) temp[i]=array[e[i]-1];
for(i=0;i<48;i++) array[i]=temp[i];
}
/**********************E置换--32位膨胀为48位（end）*****************************/
/*******************************P置换（begin）**********************************/
void p_permute(unsigned char array[64])
{
int i;
unsigned char temp[64];
for(i=0;i<32;i++) temp[i]=array[p[i]-1];
for(i=0;i<32;i++) array[i]=temp[i];
}
/******************************P置换（end）*************************************/
/*******************************函数f（begin）**********************************/
void f(unsigned char r_byte[64],unsigned char k_bit[8])
{
int i,j;
int row, col;
unsigned char r_bit[8]={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
unsigned char temp_bit[8]={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
unsigned char temp_byte[64];
unsigned char s_out_bit[8]={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0} ;
expand(r_byte); /*now r is 48 bits */
byte2bit(r_byte,r_bit);
for(i=0;i<6;i++) r_bit[i]^=k_bit[i]; /*xor 48bit key*/
bit2byte(r_bit,r_byte);
for(i=0;i<8;i++)
{
/**********change 48bit(8bit x 6byte) to 48bit(6bit x 8byte)********/
for(j=0;j<64;j++) temp_byte[j] = 0x0 ;/*clear temp*/
temp_byte[6] = r_byte[i*6] ; /*get bit 0 in 6 bit*/
temp_byte[7] = r_byte[i*6+5] ; /*get bit 5 in 6 bit*/
byte2bit(temp_byte,temp_bit) ; /* 0000 00?? */
row = temp_bit[0] ; /*get row[i]*/
for(j=0;j<64;j++) temp_byte[j] = 0x0 ;/*clear temp*/
temp_byte[4] = r_byte[i*6+1] ; /*0000 ????*/
temp_byte[5] = r_byte[i*6+2] ;
temp_byte[6] = r_byte[i*6+3] ;
temp_byte[7] = r_byte[i*6+4] ;
byte2bit(temp_byte,temp_bit) ;
col = temp_bit[0] ; /*get column in S table*/
/**********change 48bit(8bit x 6byte) to 48bit(6bit x 8byte)********/
/*get number from S table with row and col*/
switch (i) {
case 0 :
s_out_bit[i] = s1[row][col] ;
break ;
case 1 :
s_out_bit[i] = s2[row][col] ;
break ;
case 2 :
s_out_bit[i] = s3[row][col] ;
break ;
case 3 :
s_out_bit[i] = s4[row][col] ;
break ;
case 4 :
s_out_bit[i] = s5[row][col] ;
break ;
case 5 :
s_out_bit[i] = s6[row][col] ;
break ;
case 6 :
s_out_bit[i] = s7[row][col] ;
break ;
case 7 :
s_out_bit[i] = s8[row][col] ;
break ;
} ;
} /*s_out_bit[0-7]:0000???? 0000???? 0000???? 0000????...0000???? */
/*change 64bit to 32bit : clean 0000(high 4bit)*/
r_bit[0] = (s_out_bit[0]<<4) + s_out_bit[1] ;
r_bit[1] = (s_out_bit[2]<<4) + s_out_bit[3] ;
r_bit[2] = (s_out_bit[4]<<4) + s_out_bit[5] ;
r_bit[3] = (s_out_bit[6]<<4) + s_out_bit[7] ;
/*now r_bit[0-7] = ???????? ???????? ???????? ???????? 0000..*/
bit2byte(r_bit,r_byte);
p_permute(r_byte);
}
/******************************函数f（end）*************************************/
/**************************生成子密钥（beging）*********************************/
void keychange(unsigned char oldkey[8] , unsigned char newkey[16][8])
{
int i=0,j=0,k=0 ;
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 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} ;
int ccmovebit[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1} ;
unsigned char oldkey_byte[64] ; /*64位原始密钥，不过需要从oldkey[8]中提取出64位信息*/
unsigned char oldkey_byte1[64] ; /*实际只有56个字节，存放经过pc_1置换后的56位密钥*/
unsigned char oldkey_byte2[64] ; /*存放c(i)和d(i)合并起来后的56位，然后用于PC_2置换得到48位的k(i)*/
unsigned char oldkey_c[28] ; /*28位密钥c0*/
unsigned char oldkey_d[28] ; /*28位密钥d0*/
unsigned char cc_temp ;
unsigned char newkey_byte[16][64] ; /*16个子密钥k1、k2、...、k16，每个子密钥实际存放48位*/
bit2byte(oldkey,oldkey_byte) ;/*change to byte把64位（8字节）密钥转换为64字节，每字节代表密钥的一位*/
for(i=0;i<=55;i++) oldkey_byte1[i] = oldkey_byte[pc_1[i] - 1] ;/*goto PC-1*/
for(i=0;i<=27;i++) oldkey_c[i] = oldkey_byte1[i] ;/*move 28bit -> c0*/
for(i=28;i<=55;i++) oldkey_d[i -28] = oldkey_byte1[i] ;/*move other 28bit -> d0*/
/*cc_movebit : get c1-16,d1-16*/
for(i=0;i<=15;i++)
{
for(j=1;j<=ccmovebit[i];j++) /*循环左移位，位数由ccmovebit[i]事先确定*/
{
cc_temp = oldkey_c[0] ; /*move out the first bit*/
for(k=0;k<=26;k++)
{
oldkey_c[k] = oldkey_c[k+1] ;
}
oldkey_c[27] = cc_temp ; /*move the first bit to the last bit*/
cc_temp = oldkey_d[0] ; /*move out the first bit*/
for(k=0;k<=26;k++)
{
oldkey_d[k] = oldkey_d[k+1] ;
}
oldkey_d[27] = cc_temp ; /*move the first bit to the last bit*/
} /*cc_movebit*/
/*goto pc-2 change bit*/
for(k=0;k<=27;k++) oldkey_byte2[k] = oldkey_c[k] ;
for(k=28;k<=55;k++) oldkey_byte2[k] = oldkey_d[k-28] ;
/*add c(i)+d(i) -> for pc-2 change 56bit to 48bit k(i)*/
for(k=0;k<=47;k++) newkey_byte[i][k] = oldkey_byte2[pc_2[k] - 1] ;
}/*end of one of change the 48bit key*/
/*byte to bit for 48bit newkey*/
for(i=0;i<=15;i++) byte2bit(newkey_byte[i],newkey[i]) ;
}
/****************************生成子密钥（end）**********************************/
/************************加密算法des_encryption（begin）****************************/
void endes(unsigned char m_bit[8], unsigned char k_bit[8], unsigned char e_bit[8])
{
unsigned char m_bit1[8] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0} ; /*明文经过IP置换后的存放地－－8字节64位明文*/
unsigned char m_byte[64] ; /*存放原始明文－－64字节64位明文*/
unsigned char key_n[16][8] ; /*存放子密钥*/
unsigned char l_bit[17][8] ; /*存放加密过程的每一层结果的左32位，实际每层只用4个字节表示32位结果*/
unsigned char r_bit[17][8] ; /*存放加密过程的每一层结果的右32位，实际每层只用4个字节表示32位结果*/
unsigned char e_byte[64] ; /*存放密文，64个字节表示64位密文*/
unsigned char r_byte[64] ; /*存放R(i)，实际用32个字节存放32位有用信息*/
int i = 0 , j = 0;
keychange(k_bit,key_n) ;/*get the 48bit key x 16 (16rows x 6byte in key_n)*/
bit2byte(m_bit,m_byte) ;/*change to byte*/
ip_permute(m_byte);
byte2bit(m_byte,m_bit1) ;/*re-change to bit*/
for(i=0;i<=3;i++) l_bit[0][i] = m_bit1[i] ;/*move left 32bit -> l0*/
for(i=4;i<=7;i++) r_bit[0][i - 4] = m_bit1[i] ;/*move right 32bit -> r0*/
for(i=1;i<=16;i++) /*16 layer*/
{
for(j=0;j<=3;j++) l_bit[i][j] = r_bit[i-1][j] ;/*L(n) = R(n-1)*/
/*comput f(R(n-1),k)*/
bit2byte(r_bit[i-1],r_byte) ;
f(r_byte,key_n[i-1]);
byte2bit(r_byte,r_bit[i-1]);
for(j=0;j<=3;j++)/*get next r_bit*/
{
r_bit[i][j] = l_bit[i-1][j] ^ r_bit[i-1][j] ;
}
}/*end of endes*/
for(i=0;i<=3;i++) e_bit[i] = r_bit[16][i] ;
for(i=4;i<=7;i++) e_bit[i] = l_bit[16][i - 4] ; /*r_bit + l_bit -> e_bit(64bit)*/
bit2byte(e_bit,e_byte) ;/*change to byte for swap bit IP-1*/
ip_1_permute(e_byte);
byte2bit(e_byte,e_bit) ;/*got e_bit*/
}
/*************************加密算法des_encryption（end）*****************************/
/************************解密算法uncryption（begin）****************************/
void undes(unsigned char m_bit[8], unsigned char k_bit[8], unsigned char e_bit[8])
{ /*～～～注意，这里m_bit[8]实际上是密文，而e_bit[8]则是需要的明文！～～～～*/
unsigned char m_bit1[8] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0} ; /*明文经过IP置换后的存放地－－8字节64位明文*/
unsigned char m_byte[64] ; /*存放原始明文－－64字节64位明文*/
unsigned char key_n[16][8] ; /*存放子密钥*/
unsigned char l_bit[17][8] ; /*存放加密过程的每一层结果的左32位，实际每层只用4个字节表示32位结果*/
unsigned char r_bit[17][8] ; /*存放加密过程的每一层结果的右32位，实际每层只用4个字节表示32位结果*/
unsigned char e_byte[64] ; /*存放密文，64个字节表示64位密文*/
unsigned char r_byte[64] ; /*存放R(i)，实际用32个字节存放32位有用信息*/
int i = 0 , j = 0;
keychange(k_bit,key_n) ;/*get the 48bit key x 16 (16rows x 6byte in key_n)*/
bit2byte(m_bit,m_byte) ;/*change to byte*/
ip_permute(m_byte);
byte2bit(m_byte,m_bit1) ;/*re-change to bit*/
for(i=0;i<=3;i++) l_bit[0][i] = m_bit1[i] ;/*move left 32bit -> l0*/
for(i=4;i<=7;i++) r_bit[0][i - 4] = m_bit1[i] ;/*move right 32bit -> r0*/
for(i=1;i<=16;i++) /*16 layer*/
{
for(j=0;j<=3;j++) l_bit[i][j] = r_bit[i-1][j] ;/*L(n) = R(n-1)*/
/*comput f(R(n-1),k)*/
bit2byte(r_bit[i-1],r_byte) ;
f(r_byte,key_n[16-i]);
byte2bit(r_byte,r_bit[i-1]);
for(j=0;j<=3;j++)/*get next r_bit*/
{
r_bit[i][j] = l_bit[i-1][j] ^ r_bit[i-1][j] ;
}
}/*end of endes*/
for(i=0;i<=3;i++) e_bit[i] = r_bit[16][i] ;
for(i=4;i<=7;i++) e_bit[i] = l_bit[16][i - 4] ; /*r_bit + l_bit -> e_bit(64bit)*/
bit2byte(e_bit,e_byte) ;/*change to byte for swap bit IP-1*/
ip_1_permute(e_byte);
byte2bit(e_byte,e_bit) ;/*got e_bit*/
}
/*************************加密算法*****************************/
uint8_t * des_encryption_process(uint8_t *in_data)
{
int i,j;
uint8_t out_data[8];
uint8_t * out_data_ptr = out_data;
// printf("the original des_message is: ");
// for(i=0;i<8;i++) printf("%c",*(in_data+i));
// printf("\n");
// printf("the keyword is: ");
// for(i=0;i<8;i++) printf("%c",keyword[i]);
// printf("\n\n");
endes(in_data,keyword,out_data);
// printf("the des_encryption out_data is(hex): ");
// for(i=0; i<8; i++) printf("%x ",*(out_data+i));
// printf("\n");
return(out_data_ptr);
}
uint8_t testy[20],testx[20],ptrx;
uint8_t * testx_ptr=testx;
uint8_t des_encryption_result(uint8_t * dec_ram, uint8_t dec_length)
{
uint8_t i,j;
uint8_t * ptry = dec_ram;
for(i=0;i<10;i++){
*(dec_ram+dec_length+i) = 0x30;
}
j=0;
if(dec_length%8){
j++;
}
j += dec_length/8;
ptrx=0;
for(i=0;i<j;i++){
memcpy(testy,(dec_ram+i*8),8);
memcpy(testx_ptr, des_encryption_process(testy), 8);
memcpy((ptry+i*8),testx_ptr,8);
}
dec_length =j*8;
return(dec_length);
}
void des_process(void)
{
int i;
printf("the original des_message is: ");
for(i=0;i<8;i++) printf("%c",des_message[i]);
printf("\n");
printf("the keyword is: ");
for(i=0;i<8;i++) printf("%c",keyword[i]);
printf("\n\n");
endes(des_message,keyword,des_encryption);
// printf("the des_encryption des_message is(char): ");
// for(i=0;i<8;i++) printf("%c",des_encryption[i]);
// printf("\n");
printf("the des_encryption des_message is(hex): ");
for(i=0; i<8; i++) printf("%x ",des_encryption[i]);
printf("\n");
// bit2byte(des_encryption,encryption_byte);
// printf("the des_encryption des_message is(bin):\n");
// for(i=0; i<64; i++)
// if(i%8==7) printf("%1d ",encryption_byte[i]);
// else printf("%1d",encryption_byte[i]);
// printf("\n");
printf("\n\n\n************* after uncryption *****************\n");
undes(des_encryption,keyword,des_result);
printf("the uncryption des_message is: ");
for(i=0;i<8;i++)
printf("%c",des_result[i]);
printf("\n");
}
楼主
嵌入式代码，DES加密函数
全部回复 0
暂无评论，快来抢沙发吧
举报
内容系网友发布，其中涉及到安全隐患的内容系网友个人行为，不代表面包板社区观点
关闭
站长推荐
/3 
/3
-
返回顶部
-
