益友软件工作室

加密金刚锁相关技术 → 加密类技术文章 → DES算法详述

DES算法详述

文章作者:佚名

DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位,整个算法的主流程图如下:

其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长32位,其置换规则见下表:

58,50,12,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,

即将输入的第58位换到第一位,第50位换到第2位,...,依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分,L0是输出的左32位,R0 是右32位,例:设置换前的输入值为D1D2D3......D64,则经过初始置换后的结果为:L0=D58D50...D8;R0=D57D49...D7。

经过16次迭代运算后。得到L16、R16,将此作为输入,进行逆置换,即得到密文输出。逆置换正好是初始置的逆运算,例如,第1位经过初始置换后,处于第40位,而通过逆置换,又将第40位换回到第1位,其逆置换规则如下表所示:

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,

放大换位表

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,

单纯换位表

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,

在f(Ri,Ki)算法描述图中,S1,S2...S8为选择函数,其功能是把6bit数据变为4bit数据。下面给出选择函数Si(i=1,2......8)的功能表:

选择函数Si

S1:

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,

S2:

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,

S3:

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,

S4:

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,

S5:

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,

S6:

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,

S7:

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,

S8:

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,

在此以S1为例说明其功能,我们可以看到:在S1中,共有4行数据,命名为0,1、2、3行;每行有16列,命名为0、1、2、3,......,14、15列。

现设输入为: D=D1D2D3D4D5D6

令:列=D2D3D4D5

行=D1D6

然后在S1表中查得对应的数,以4位二进制表示,此即为选择函数S1的输出。下面给出子密钥Ki(48bit)的生成算法

从子密钥Ki的生成算法描述图中我们可以看到:初始Key值为64位,但DES算法规定,其中第8、16、......64位是奇偶校验位,不参与DES运算。故Key 实际可用位数便只有56位。即:经过缩小选择换位表1的变换后,Key 的位数由64 位变成了56位,此56位分为C0、D0两部分,各28位,然后分别进行第1次循环左移,得到C1、D1,将C1(28位)、D1(28位)合并得到56位,再经过缩小选择换位2,从而便得到了密钥K0(48位)。依此类推,便可得到K1、K2、......、K15,不过需要注意的是,16次循环左移对应的左移位数要依据下述规则进行:

循环左移位数

1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1

以上介绍了DES算法的加密过程。DES算法的解密过程是一样的,区别仅仅在于第一次迭代时用子密钥K15,第二次K14、......,最后一次用K0,算法本身并没有任何变化。

DES 算法网络上很多,给你们一个

/* ================================================================

des()

Description: DES algorithm,do encript or descript.

================================================================ */

int des(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg)

{

unsigned char bufout[64],

kwork[56], worka[48], kn[48], buffer[64], key[64],

nbrofshift, temp1, temp2;

int valindex;

register i, j, k, iter;

 

/* INITIALIZE THE TABLES */

/* Table - s1 */

static unsigned char s1[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 };

 

/* Table - s2 */

static unsigned char s2[4][16] = {

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 };

 

/* Table - s3 */

static unsigned char s3[4][16] = {

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 };

 

/* Table - s4 */

static unsigned char s4[4][16] = {

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 };

 

/* Table - s5 */

static unsigned char s5[4][16] = {

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 };

 

/* Table - s6 */

static unsigned char s6[4][16] = {

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 };

 

/* Table - s7 */

static unsigned char s7[4][16] = {

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 };

 

/* Table - s8 */

static unsigned char s8[4][16] = {

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 };

 

 

/* Table - Shift */

static unsigned char shift[16] = {

1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };

 

 

/* Table - Binary */

static unsigned char binary[64] = {

0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1,

0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1,

1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,

1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 };

 

/* MAIN PROCESS */

/* Convert from 64-bit key into 64-byte key */

for (i = 0; i < 8; i++) {

key[8*i] = ((j = *(inkey + i)) / 128) % 2;

key[8*i+1] = (j / 64) % 2;

key[8*i+2] = (j / 32) % 2;

key[8*i+3] = (j / 16) % 2;

key[8*i+4] = (j / 8) % 2;

key[8*i+5] = (j / 4) % 2;

key[8*i+6] = (j / 2) % 2;

key[8*i+7] = j % 2;

}

 

/* Convert from 64-bit data into 64-byte data */

for (i = 0; i < 8; i++) {

buffer[8*i] = ((j = *(source + i)) / 128) % 2;

buffer[8*i+1] = (j / 64) % 2;

buffer[8*i+2] = (j / 32) % 2;

buffer[8*i+3] = (j / 16) % 2;

buffer[8*i+4] = (j / 8) % 2;

buffer[8*i+5] = (j / 4) % 2;

buffer[8*i+6] = (j / 2) % 2;

buffer[8*i+7] = j % 2;

}

 

/* Initial Permutation of Data */

bufout[ 0] = buffer[57];

bufout[ 1] = buffer[49];

bufout[ 2] = buffer[41];

bufout[ 3] = buffer[33];

bufout[ 4] = buffer[25];

bufout[ 5] = buffer[17];

bufout[ 6] = buffer[ 9];

bufout[ 7] = buffer[ 1];

bufout[ 8] = buffer[59];

bufout[ 9] = buffer[51];

bufout[10] = buffer[43];

bufout[11] = buffer[35];

bufout[12] = buffer[27];

bufout[13] = buffer[19];

bufout[14] = buffer[11];

bufout[15] = buffer[ 3];

bufout[16] = buffer[61];

bufout[17] = buffer[53];

bufout[18] = buffer[45];

bufout[19] = buffer[37];

bufout[20] = buffer[29];

bufout[21] = buffer[21];

bufout[22] = buffer[13];

bufout[23] = buffer[ 5];

bufout[24] = buffer[63];

bufout[25] = buffer[55];

bufout[26] = buffer[47];

bufout[27] = buffer[39];

bufout[28] = buffer[31];

bufout[29] = buffer[23];

bufout[30] = buffer[15];

bufout[31] = buffer[ 7];

bufout[32] = buffer[56];

bufout[33] = buffer[48];

bufout[34] = buffer[40];

bufout[35] = buffer[32];

bufout[36] = buffer[24];

bufout[37] = buffer[16];

bufout[38] = buffer[ 8];

bufout[39] = buffer[ 0];

bufout[40] = buffer[58];

bufout[41] = buffer[50];

bufout[42] = buffer[42];

bufout[43] = buffer[34];

bufout[44] = buffer[26];

bufout[45] = buffer[18];

bufout[46] = buffer[10];

bufout[47] = buffer[ 2];

bufout[48] = buffer[60];

bufout[49] = buffer[52];

bufout[50] = buffer[44];

bufout[51] = buffer[36];

bufout[52] = buffer[28];

bufout[53] = buffer[20];

bufout[54] = buffer[12];

bufout[55] = buffer[ 4];

bufout[56] = buffer[62];

bufout[57] = buffer[54];

bufout[58] = buffer[46];

bufout[59] = buffer[38];

bufout[60] = buffer[30];

bufout[61] = buffer[22];

bufout[62] = buffer[14];

bufout[63] = buffer[ 6];

 

/* Initial Permutation of Key */

kwork[ 0] = key[56];

kwork[ 1] = key[48];

kwork[ 2] = key[40];

kwork[ 3] = key[32];

kwork[ 4] = key[24];

kwork[ 5] = key[16];

kwork[ 6] = key[ 8];

kwork[ 7] = key[ 0];

kwork[ 8] = key[57];

kwork[ 9] = key[49];

kwork[10] = key[41];

kwork[11] = key[33];

kwork[12] = key[25];

kwork[13] = key[17];

kwork[14] = key[ 9];

kwork[15] = key[ 1];

kwork[16] = key[58];

kwork[17] = key[50];

kwork[18] = key[42];

kwork[19] = key[34];

kwork[20] = key[26];

kwork[21] = key[18];

kwork[22] = key[10];

kwork[23] = key[ 2];

kwork[24] = key[59];

kwork[25] = key[51];

kwork[26] = key[43];

kwork[27] = key[35];

kwork[28] = key[62];

kwork[29] = key[54];

kwork[30] = key[46];

kwork[31] = key[38];

kwork[32] = key[30];

kwork[33] = key[22];

kwork[34] = key[14];

kwork[35] = key[ 6];

kwork[36] = key[61];

kwork[37] = key[53];

kwork[38] = key[45];

kwork[39] = key[37];

kwork[40] = key[29];

kwork[41] = key[21];

kwork[42] = key[13];

kwork[43] = key[ 5];

kwork[44] = key[60];

kwork[45] = key[52];

kwork[46] = key[44];

kwork[47] = key[36];

kwork[48] = key[28];

kwork[49] = key[20];

kwork[50] = key[12];

kwork[51] = key[ 4];

kwork[52] = key[27];

kwork[53] = key[19];

kwork[54] = key[11];

kwork[55] = key[ 3];

 

/* 16 Iterations */

for (iter = 1; iter < 17; iter++) {

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

buffer[i] = bufout[32+i];

 

/* Calculation of F(R, K) */

/* Permute - E */

worka[ 0] = buffer[31];

worka[ 1] = buffer[ 0];

worka[ 2] = buffer[ 1];

worka[ 3] = buffer[ 2];

worka[ 4] = buffer[ 3];

worka[ 5] = buffer[ 4];

worka[ 6] = buffer[ 3];

worka[ 7] = buffer[ 4];

worka[ 8] = buffer[ 5];

worka[ 9] = buffer[ 6];

worka[10] = buffer[ 7];

worka[11] = buffer[ 8];

worka[12] = buffer[ 7];

worka[13] = buffer[ 8];

worka[14] = buffer[ 9];

worka[15] = buffer[10];

worka[16] = buffer[11];

worka[17] = buffer[12];

worka[18] = buffer[11];

worka[19] = buffer[12];

worka[20] = buffer[13];

worka[21] = buffer[14];

worka[22] = buffer[15];

worka[23] = buffer[16];

worka[24] = buffer[15];

worka[25] = buffer[16];

worka[26] = buffer[17];

worka[27] = buffer[18];

worka[28] = buffer[19];

worka[29] = buffer[20];

worka[30] = buffer[19];

worka[31] = buffer[20];

worka[32] = buffer[21];

worka[33] = buffer[22];

worka[34] = buffer[23];

worka[35] = buffer[24];

worka[36] = buffer[23];

worka[37] = buffer[24];

worka[38] = buffer[25];

worka[39] = buffer[26];

worka[40] = buffer[27];

worka[41] = buffer[28];

worka[42] = buffer[27];

worka[43] = buffer[28];

worka[44] = buffer[29];

worka[45] = buffer[30];

worka[46] = buffer[31];

worka[47] = buffer[ 0];

 

/* KS Function Begin */

if (flg) {

nbrofshift = shift[iter-1];

for (i = 0; i < (int) nbrofshift; i++) {

temp1 = kwork[0];

temp2 = kwork[28];

for (j = 0; j < 27; j++) {

kwork[j] = kwork[j+1];

kwork[j+28] = kwork[j+29];

}

kwork[27] = temp1;

kwork[55] = temp2;

}

} else if (iter > 1) {

nbrofshift = shift[17-iter];

for (i = 0; i < (int) nbrofshift; i++) {

temp1 = kwork[27];

temp2 = kwork[55];

for (j = 27; j > 0; j--) {

kwork[j] = kwork[j-1];

kwork[j+28] = kwork[j+27];

}

kwork[0] = temp1;

kwork[28] = temp2;

}

}

 

/* Permute kwork - PC2 */

kn[ 0] = kwork[13];

kn[ 1] = kwork[16];

kn[ 2] = kwork[10];

kn[ 3] = kwork[23];

kn[ 4] = kwork[ 0];

kn[ 5] = kwork[ 4];

kn[ 6] = kwork[ 2];

kn[ 7] = kwork[27];

kn[ 8] = kwork[14];

kn[ 9] = kwork[ 5];

kn[10] = kwork[20];

kn[11] = kwork[ 9];

kn[12] = kwork[22];

kn[13] = kwork[18];

kn[14] = kwork[11];

kn[15] = kwork[ 3];

kn[16] = kwork[25];

kn[17] = kwork[ 7];

kn[18] = kwork[15];

kn[19] = kwork[ 6];

kn[20] = kwork[26];

kn[21] = kwork[19];

kn[22] = kwork[12];

kn[23] = kwork[ 1];

kn[24] = kwork[40];

kn[25] = kwork[51];

kn[26] = kwork[30];

kn[27] = kwork[36];

kn[28] = kwork[46];

kn[29] = kwork[54];

kn[30] = kwork[29];

kn[31] = kwork[39];

kn[32] = kwork[50];

kn[33] = kwork[44];

kn[34] = kwork[32];

kn[35] = kwork[47];

kn[36] = kwork[43];

kn[37] = kwork[48];

kn[38] = kwork[38];

kn[39] = kwork[55];

kn[40] = kwork[33];

kn[41] = kwork[52];

kn[42] = kwork[45];

kn[43] = kwork[41];

kn[44] = kwork[49];

kn[45] = kwork[35];

kn[46] = kwork[28];

kn[47] = kwork[31];

/* KS Function End */

 

/* worka XOR kn */

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

worka[i] = worka[i] ^ kn[i];

 

/* 8 s-functions */

valindex = s1[2*worka[ 0]+worka[ 5]]

[2*(2*(2*worka[ 1]+worka[ 2])+

worka[ 3])+worka[ 4]];

valindex = valindex * 4;

kn[ 0] = binary[0+valindex];

kn[ 1] = binary[1+valindex];

kn[ 2] = binary[2+valindex];

kn[ 3] = binary[3+valindex];

valindex = s2[2*worka[ 6]+worka[11]]

[2*(2*(2*worka[ 7]+worka[ 8])+

worka[ 9])+worka[10]];

valindex = valindex * 4;

kn[ 4] = binary[0+valindex];

kn[ 5] = binary[1+valindex];

kn[ 6] = binary[2+valindex];

kn[ 7] = binary[3+valindex];

valindex = s3[2*worka[12]+worka[17]]

[2*(2*(2*worka[13]+worka[14])+

worka[15])+worka[16]];

valindex = valindex * 4;

kn[ 8] = binary[0+valindex];

kn[ 9] = binary[1+valindex];

kn[10] = binary[2+valindex];

kn[11] = binary[3+valindex];

valindex = s4[2*worka[18]+worka[23]]

[2*(2*(2*worka[19]+worka[20])+

worka[21])+worka[22]];

valindex = valindex * 4;

kn[12] = binary[0+valindex];

kn[13] = binary[1+valindex];

kn[14] = binary[2+valindex];

kn[15] = binary[3+valindex];

valindex = s5[2*worka[24]+worka[29]]

[2*(2*(2*worka[25]+worka[26])+

worka[27])+worka[28]];

valindex = valindex * 4;

kn[16] = binary[0+valindex];

kn[17] = binary[1+valindex];

kn[18] = binary[2+valindex];

kn[19] = binary[3+valindex];

valindex = s6[2*worka[30]+worka[35]]

[2*(2*(2*worka[31]+worka[32])+

worka[33])+worka[34]];

valindex = valindex * 4;

kn[20] = binary[0+valindex];

kn[21] = binary[1+valindex];

kn[22] = binary[2+valindex];

kn[23] = binary[3+valindex];

valindex = s7[2*worka[36]+worka[41]]

[2*(2*(2*worka[37]+worka[38])+

worka[39])+worka[40]];

valindex = valindex * 4;

kn[24] = binary[0+valindex];

kn[25] = binary[1+valindex];

kn[26] = binary[2+valindex];

kn[27] = binary[3+valindex];

valindex = s8[2*worka[42]+worka[47]]

[2*(2*(2*worka[43]+worka[44])+

worka[45])+worka[46]];

valindex = valindex * 4;

kn[28] = binary[0+valindex];

kn[29] = binary[1+valindex];

kn[30] = binary[2+valindex];

kn[31] = binary[3+valindex];

 

/* Permute - P */

worka[ 0] = kn[15];

worka[ 1] = kn[ 6];

worka[ 2] = kn[19];

worka[ 3] = kn[20];

worka[ 4] = kn[28];

worka[ 5] = kn[11];

worka[ 6] = kn[27];

worka[ 7] = kn[16];

worka[ 8] = kn[ 0];

worka[ 9] = kn[14];

worka[10] = kn[22];

worka[11] = kn[25];

worka[12] = kn[ 4];

worka[13] = kn[17];

worka[14] = kn[30];

worka[15] = kn[ 9];

worka[16] = kn[ 1];

worka[17] = kn[ 7];

worka[18] = kn[23];

worka[19] = kn[13];

worka[20] = kn[31];

worka[21] = kn[26];

worka[22] = kn[ 2];

worka[23] = kn[ 8];

worka[24] = kn[18];

worka[25] = kn[12];

worka[26] = kn[29];

worka[27] = kn[ 5];

worka[28] = kn[21];

worka[29] = kn[10];

worka[30] = kn[ 3];

worka[31] = kn[24];

 

/* bufout XOR worka */

for (i = 0; i < 32; i++) {

bufout[i+32] = bufout[i] ^ worka[i];

bufout[i] = buffer[i];

}

} /* End of Iter */

 

/* Prepare Output */

for (i = 0; i < 32; i++) {

j = bufout[i];

bufout[i] = bufout[32+i];

bufout[32+i] = j;

}

 

/* Inverse Initial Permutation */

buffer[ 0] = bufout[39];

buffer[ 1] = bufout[ 7];

buffer[ 2] = bufout[47];

buffer[ 3] = bufout[15];

buffer[ 4] = bufout[55];

buffer[ 5] = bufout[23];

buffer[ 6] = bufout[63];

buffer[ 7] = bufout[31];

buffer[ 8] = bufout[38];

buffer[ 9] = bufout[ 6];

buffer[10] = bufout[46];

buffer[11] = bufout[14];

buffer[12] = bufout[54];

buffer[13] = bufout[22];

buffer[14] = bufout[62];

buffer[15] = bufout[30];

buffer[16] = bufout[37];

buffer[17] = bufout[ 5];

buffer[18] = bufout[45];

buffer[19] = bufout[13];

buffer[20] = bufout[53];

buffer[21] = bufout[21];

buffer[22] = bufout[61];

buffer[23] = bufout[29];

buffer[24] = bufout[36];

buffer[25] = bufout[ 4];

buffer[26] = bufout[44];

buffer[27] = bufout[12];

buffer[28] = bufout[52];

buffer[29] = bufout[20];

buffer[30] = bufout[60];

buffer[31] = bufout[28];

buffer[32] = bufout[35];

buffer[33] = bufout[ 3];

buffer[34] = bufout[43];

buffer[35] = bufout[11];

buffer[36] = bufout[51];

buffer[37] = bufout[19];

buffer[38] = bufout[59];

buffer[39] = bufout[27];

buffer[40] = bufout[34];

buffer[41] = bufout[ 2];

buffer[42] = bufout[42];

buffer[43] = bufout[10];

buffer[44] = bufout[50];

buffer[45] = bufout[18];

buffer[46] = bufout[58];

buffer[47] = bufout[26];

buffer[48] = bufout[33];

buffer[49] = bufout[ 1];

buffer[50] = bufout[41];

buffer[51] = bufout[ 9];

buffer[52] = bufout[49];

buffer[53] = bufout[17];

buffer[54] = bufout[57];

buffer[55] = bufout[25];

buffer[56] = bufout[32];

buffer[57] = bufout[ 0];

buffer[58] = bufout[40];

buffer[59] = bufout[ 8];

buffer[60] = bufout[48];

buffer[61] = bufout[16];

buffer[62] = bufout[56];

buffer[63] = bufout[24];

 

j = 0;

for (i = 0; i < 8; i++) {

*(dest + i) = 0x00;

for (k = 0; k < 7; k++)

*(dest + i) = ((*(dest + i)) + buffer[j+k]) * 2;

*(dest + i) = *(dest + i) + buffer[j+7];

j += 8;

}

}

上一篇:DES算法
下一篇:RSA算法

特别申明

本栏目的文章都是本人从网上搜集而来,仅供大家学习研究之用,请不要用于商业目的!其中署名“佚名”的,意思是作者不详。如果某些文章未署你的名字,请来信告知,我会补上的。如果你认为某些文章侵犯了你的正当权宜,也请来信,我会将它删除。