📄 desmain.c
字号:
lor14 = des_SPtrans2[5][t13];
#else
lor14 = des_SPtrans[5][t13];
#endif
lor13 ^= des_SPtrans[3][t12];
#ifdef DUAL_BANK
lor14 ^= des_SPtrans2[7][t14];
#else
lor14 ^= des_SPtrans[7][t14];
#endif
lor11 ^= lor12;
lor13 ^= lor14;
lor11 ^= lor13;
temp = l1 ^ lor11;
l1 = r1;
r1 = temp;
u2=r2^s2[i ];
t2=r2^s2[i+1];
t2=ROTATE(t2,4);
u21 = EXTRACT(u2, 24, 26);
u22 = EXTRACT(u2, 16, 26);
u23 = EXTRACT(u2, 8, 26);
u24 = EXTRACT(u2, 0, 26);
lor21 = des_SPtrans[0][u21];
#ifdef DUAL_BANK
lor22 = des_SPtrans2[4][u23];
#else
lor22 = des_SPtrans[4][u23];
#endif
lor21 ^= des_SPtrans[2][u22];
#ifdef DUAL_BANK
lor22 ^= des_SPtrans2[6][u24];
#else
lor22 ^= des_SPtrans[6][u24];
#endif
t21 = EXTRACT(t2, 24, 26);
t22 = EXTRACT(t2, 16, 26);
t23 = EXTRACT(t2, 8, 26);
t24 = EXTRACT(t2, 0, 26);
lor23 = des_SPtrans[1][t21];
#ifdef DUAL_BANK
lor24 = des_SPtrans2[5][t23];
#else
lor24 = des_SPtrans[5][t23];
#endif
lor23 ^= des_SPtrans[3][t22];
#ifdef DUAL_BANK
lor24 ^= des_SPtrans2[7][t24];
#else
lor24 ^= des_SPtrans[7][t24];
#endif
lor21 ^= lor22;
lor23 ^= lor24;
lor21 ^= lor23;
temp = l2 ^ lor21;
l2 = r2;
r2 = temp;
u3=r3^s3[i ];
t3=r3^s3[i+1];
t3=ROTATE(t3,4);
u31 = EXTRACT(u3, 24, 26);
u32 = EXTRACT(u3, 16, 26);
u33 = EXTRACT(u3, 8, 26);
u34 = EXTRACT(u3, 0, 26);
lor31 = des_SPtrans[0][u31];
#ifdef DUAL_BANK
lor32 = des_SPtrans2[4][u33];
#else
lor32 = des_SPtrans[4][u33];
#endif
lor31 ^= des_SPtrans[2][u32];
#ifdef DUAL_BANK
lor32 ^= des_SPtrans2[6][u34];
#else
lor32 ^= des_SPtrans[6][u34];
#endif
t31 = EXTRACT(t3, 24, 26);
t32 = EXTRACT(t3, 16, 26);
t33 = EXTRACT(t3, 8, 26);
t34 = EXTRACT(t3, 0, 26);
lor33 = des_SPtrans[1][t31];
#ifdef DUAL_BANK
lor34 = des_SPtrans2[5][t33];
#else
lor34 = des_SPtrans[5][t33];
#endif
lor33 ^= des_SPtrans[3][t32];
#ifdef DUAL_BANK
lor34 ^= des_SPtrans2[7][t34];
#else
lor34 ^= des_SPtrans[7][t34];
#endif
lor31 ^= lor32;
lor33 ^= lor34;
lor31 ^= lor33;
temp = l3 ^ lor31;
l3 = r3;
r3 = temp;
}
data1[0] = l1;
data1[1] = r1;
data2[0] = l2;
data2[1] = r2;
data3[0] = l3;
data3[1] = r3;
}
*/
void des3_encrypt_block(data, ks)
DES_LONG *data;
des_key_schedule ks[3];
{
register DES_LONG l,r,temp;
l=data[0];
r=data[1];
IP(l,r);
data[0]=ROTATE(l,29);
data[1]=ROTATE(r,29);
des_encrypt_core(data, ks[0]);
des_encrypt_core(data, ks[1]);
des_encrypt_core(data, ks[2]);
temp=data[0];
l=ROTATE(temp,3);
temp=data[1];
r=ROTATE(temp,3);
FP(r,l);
data[0]=l;
data[1]=r;
}
void des3_encrypt_block_3ch(data1, ks1, data2, ks2, data3, ks3)
DES_LONG *data1;
DES_LONG *data2;
DES_LONG *data3;
des_key_schedule ks1[3];
des_key_schedule ks2[3];
des_key_schedule ks3[3];
{
register DES_LONG l1,r1,l2,r2,l3,r3, temp;
l1=data1[0];
r1=data1[1];
IP(l1,r1);
l2=data2[0];
r2=data2[1];
IP(l2,r2);
l3=data3[0];
r3=data3[1];
IP(l3,r3);
data1[0]=ROTATE(l1,29);
data1[1]=ROTATE(r1,29);
data2[0]=ROTATE(l2,29);
data2[1]=ROTATE(r2,29);
data3[0]=ROTATE(l3,29);
data3[1]=ROTATE(r3,29);
des_encrypt_core_3ch(data1, ks1[0], data2, ks2[0], data3, ks3[0]);
des_encrypt_core_3ch(data1, ks1[1], data2, ks2[1], data3, ks3[1]);
des_encrypt_core_3ch(data1, ks1[2], data2, ks2[2], data3, ks3[2]);
temp=data1[0];
l1=ROTATE(temp,3);
temp=data1[1];
r1=ROTATE(temp,3);
temp=data2[0];
l2=ROTATE(temp,3);
temp=data2[1];
r2=ROTATE(temp,3);
temp=data3[0];
l3=ROTATE(temp,3);
temp=data3[1];
r3=ROTATE(temp,3);
FP(r1,l1);
data1[0]=l1;
data1[1]=r1;
FP(r2,l2);
data2[0]=l2;
data2[1]=r2;
FP(r3,l3);
data3[0]=l3;
data3[1]=r3;
}
/******************************************************************************/
/* des3_ecb_encrypt */
/* This is the triple Data Encryption Standard (3DES) routine which */
/* encrypts a data array of arbitrary length in the Electronic Code */
/* Book mode (ECB). It assumes that the input array has a length */
/* divisible by 24 bytes. If this data array does not have a length */
/* divisible by 24 bytes, it should be zero padded to prevent */
/* overflow. The output array should be similarly padded. The */
/* variable "length" does not need to be divisible by 24 as long as */
/* the input and output arrays are properly padded. */
/* */
/* This routine is similar to des_ecb_encrypt in the file "DESmode.c"*/
/* however, while that ECB DES encrypts using a single 56-bit key */
/* (the key is passed as a 64 bit number, but every 8th bit is */
/* ignored,) triple DES encrypts using three 56-bit keys. */
/******************************************************************************/
void des3_ecb_encrypt(input1, ks, output1, length)
des_cblock (*input1);
des_key_schedule ks[3];
des_cblock (*output1);
int length;
{
register DES_LONG *inint1, *outint1;
register int l=length;
register int i;
des_key_schedule ks_encrypt[3];
inint1 = (DES_LONG *)input1;
outint1 = (DES_LONG *)output1;
/* Generate key schedule to encrypt using DES_encrypt */
for(i=0;i<32;i+=2){
*(((DES_LONG *) ks_encrypt[0])+i ) = *(((DES_LONG *) ks[0])+i );
*(((DES_LONG *) ks_encrypt[0])+i+1) = *(((DES_LONG *) ks[0])+i+1);
*(((DES_LONG *) ks_encrypt[1])+i ) = *(((DES_LONG *) ks[1])+30-i);
*(((DES_LONG *) ks_encrypt[1])+i+1) = *(((DES_LONG *) ks[1])+31-i);
*(((DES_LONG *) ks_encrypt[2])+i ) = *(((DES_LONG *) ks[2])+i );
*(((DES_LONG *) ks_encrypt[2])+i+1) = *(((DES_LONG *) ks[2])+i+1);
}
for (; l>0; l-=24)
{
*outint1++ = (*inint1++);
*outint1++ = (*inint1++);
*outint1++ = (*inint1++);
*outint1++ = (*inint1++);
*outint1++ = (*inint1++);
*outint1++ = (*inint1++);
des3_encrypt_block_3ch((DES_LONG *)(outint1 - 6),ks_encrypt, (DES_LONG *)(outint1 - 4),ks_encrypt, (DES_LONG *)(outint1 - 2),ks_encrypt);
}
}
/******************************************************************************/
/* des3_ecb_decrypt */
/* This is the triple Data Encryption Standard (3DES) routine which */
/* decrypts a data array of arbitrary length in the Electronic Code */
/* Book mode (ECB). It assumes that the input array has a length */
/* divisible by 24 bytes. If this data array does not have a length */
/* divisible by 24 bytes, it should be zero padded to prevent */
/* overflow. The output array should be similarly padded. The */
/* variable "length" does not need to be divisible by 24 as long as */
/* the input and output arrays are properly padded. */
/* */
/* This routine is similar to des_ecb_decrypt in the file "DESmode.c"*/
/* however, while that ECB DES (en/de)crypts using a single 56-bit */
/* key (the key is passed as a 64 bit number, but every 8th bit is */
/* ignored,) triple DES (en/de)crypts using three 56-bit keys. */
/* */
/* The key schedules provided to this function should be the same key*/
/* schedules that are provided to des3_ecb_encrypt. The function */
/* reorganizes the key schedules to decrypt using the block */
/* encryption function. (It is a property of the DES algorithm that */
/* the core encryption routine is also used to decrypt, but with a */
/* modification to the key schedule.) */
/******************************************************************************/
void des3_ecb_decrypt(input, ks, output, length)
des_cblock (*input);
des_key_schedule ks[3];
des_cblock (*output);
int length;
{
register DES_LONG *inint, *outint;
register int l=length;
des_key_schedule ks_decrypt[3];
register int i;
inint=(DES_LONG *)input;
outint=(DES_LONG *)output;
/* Generate key schedule to decrypt using DES_encrypt */
for(i=0;i<32;i+=2){
*(((DES_LONG *) ks_decrypt[2])+i ) = *(((DES_LONG *) ks[0])+30-i);
*(((DES_LONG *) ks_decrypt[2])+i+1) = *(((DES_LONG *) ks[0])+31-i);
*(((DES_LONG *) ks_decrypt[1])+i ) = *(((DES_LONG *) ks[1])+i );
*(((DES_LONG *) ks_decrypt[1])+i+1) = *(((DES_LONG *) ks[1])+i+1);
*(((DES_LONG *) ks_decrypt[0])+i ) = *(((DES_LONG *) ks[2])+30-i);
*(((DES_LONG *) ks_decrypt[0])+i+1) = *(((DES_LONG *) ks[2])+31-i);
}
for (; l>0; l-=24)
{
*outint++ = (*inint++);
*outint++ = (*inint++);
*outint++ = (*inint++);
*outint++ = (*inint++);
*outint++ = (*inint++);
*outint++ = (*inint++);
des3_encrypt_block_3ch((DES_LONG *)(outint-6),ks_decrypt, (DES_LONG *)(outint - 4),ks_decrypt, (DES_LONG *)(outint - 2),ks_decrypt);
}
}
void des3_cbc_encrypt(input, ivec, ks, output, length)
des_cblock (*input);
des_cblock (*ivec);
des_key_schedule ks[3];
des_cblock (*output);
int length;
{
register DES_LONG tout0,tout1;
register DES_LONG *inint, *outint;
DES_LONG *iv;
register int l=length, i;
des_key_schedule ks_encrypt[3];
/* Generate key schedule to decrypt using DES_encrypt */
for(i=0;i<32;i+=2){
*(((DES_LONG *) ks_encrypt[0])+i ) = *(((DES_LONG *) ks[0])+i );
*(((DES_LONG *) ks_encrypt[0])+i+1) = *(((DES_LONG *) ks[0])+i+1);
*(((DES_LONG *) ks_encrypt[1])+i ) = *(((DES_LONG *) ks[1])+30-i);
*(((DES_LONG *) ks_encrypt[1])+i+1) = *(((DES_LONG *) ks[1])+31-i);
*(((DES_LONG *) ks_encrypt[2])+i ) = *(((DES_LONG *) ks[2])+i );
*(((DES_LONG *) ks_encrypt[2])+i+1) = *(((DES_LONG *) ks[2])+i+1);
}
inint = (DES_LONG *)input;
outint = (DES_LONG *)output;
iv=(DES_LONG *)ivec;
tout0 = *iv++;
tout1 = *iv++;
for (; l>=0; l-=8)
{
*(outint ) = (*inint++) ^ tout0;
*(outint +1) = (*inint++) ^ tout1;
des3_encrypt_block((DES_LONG *)outint,ks_encrypt);
tout0=*outint++;
tout1=*outint++;
}
iv=(DES_LONG *)ivec;
*iv++ = tout0;
*iv++ = tout1;
}
void des3_cbc_decrypt(input, ivec, ks, output, length)
des_cblock (*input);
des_cblock (*ivec);
des_key_schedule ks[3];
des_cblock (*output);
int length;
{
register DES_LONG xor0,xor1;
register DES_LONG t0,t1;
register DES_LONG *inint, *outint;
DES_LONG *iv;
register int l=length,i;
des_key_schedule ks_decrypt[3];
/* Generate key schedule to decrypt using DES_encrypt */
for(i=0;i<32;i+=2){
*(((DES_LONG *) ks_decrypt[2])+i ) = *(((DES_LONG *) ks[0])+30-i);
*(((DES_LONG *) ks_decrypt[2])+i+1) = *(((DES_LONG *) ks[0])+31-i);
*(((DES_LONG *) ks_decrypt[1])+i ) = *(((DES_LONG *) ks[1])+i );
*(((DES_LONG *) ks_decrypt[1])+i+1) = *(((DES_LONG *) ks[1])+i+1);
*(((DES_LONG *) ks_decrypt[0])+i ) = *(((DES_LONG *) ks[2])+30-i);
*(((DES_LONG *) ks_decrypt[0])+i+1) = *(((DES_LONG *) ks[2])+31-i);
}
inint=(DES_LONG *)input;
outint=(DES_LONG *)output;
iv=(DES_LONG *)ivec;
xor0 = *iv++;
xor1 = *iv++;
for (; l>0; l-=8)
{
*(outint ) = t0 = (*inint++);
*(outint +1) = t1 = (*inint++);
des3_encrypt_block((DES_LONG *)outint,ks_decrypt);
*outint++ ^= xor0;
*outint++ ^= xor1;
xor0 = t0;
xor1 = t1;
}
iv=(DES_LONG *)ivec;
*iv++ = t0;
*iv++ = t1;
}
void main()
{
int i;
char plaintext[64] = { 0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68};
char output[64] = { 0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,
0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78};
//des_cblock ivec;
des_cblock enc_key1={0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0};
des_cblock enc_key2={0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12};
des_cblock enc_key3={0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12,0x34};
des_cblock dec_key1={0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0};
des_cblock dec_key2={0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12};
des_cblock dec_key3={0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12,0x34};
des_key_schedule sch[3];
des_key_schedule dec_sch[3];
des_set_key((des_cblock *)enc_key1,sch[0]);
des_set_key((des_cblock *)enc_key2,sch[1]);
des_set_key((des_cblock *)enc_key3,sch[2]);
des_set_key((des_cblock *)dec_key1,dec_sch[0]);
des_set_key((des_cblock *)dec_key2,dec_sch[1]);
des_set_key((des_cblock *)dec_key3,dec_sch[2]);
for(i=0;i<16384*100;i++)
{
des3_ecb_encrypt((des_cblock *)plaintext,sch,(des_cblock *)plaintext,64);
des3_ecb_decrypt((des_cblock *)plaintext,dec_sch,(des_cblock *)plaintext,64);
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -