Void dec2bin(unsigned dec, unsigned bin[])

{

unsigned B[128]; // вспомогательный массив

int j, i = 0;

do {

B[i] = dec % 2;

++i;

dec /= 2;

} while (dec != 0 );

// i - здесь разрядность двоичного числа

// Запись числа в обратном порядке

j = 0;

for ( --i; i >= 0; --i )

{

bin[j++] = B[i];

}

}

// Раундовая функция расширения (Е) с 32 бит до 48 бит

Void e48 ( unsigned r32[], unsigned t48[] )

{

T48[0 ] = R32[32 - 1];

T48[1 ] = R32[1 - 1];

T48[2 ] = R32[2 - 1];

T48[3 ] = R32[3 - 1];

T48[4 ] = R32[4 - 1];

T48[5 ] = R32[5 - 1];

T48[6 ] = R32[4 - 1];

T48[7 ] = R32[5 - 1];

T48[8 ] = R32[6 - 1];

T48[9 ] = R32[7 - 1];

T48[10] = R32[8 - 1];

T48[11] = R32[9 - 1];

T48[12] = R32[8 - 1];

T48[13] = R32[9 - 1];

T48[14] = R32[10 - 1];

T48[15] = R32[11 - 1];

T48[16] = R32[12 - 1];

T48[17] = R32[13 - 1];

T48[18] = R32[12 - 1];

T48[19] = R32[13 - 1];

T48[20] = R32[14 - 1];

T48[21] = R32[15 - 1];

T48[22] = R32[16 - 1];

T48[23] = R32[17 - 1];

T48[24] = R32[16 - 1];

T48[25] = R32[17 - 1];

T48[26] = R32[18 - 1];

T48[27] = R32[19 - 1];

T48[28] = R32[20 - 1];

T48[29] = R32[21 - 1];

T48[30] = R32[20 - 1];

T48[31] = R32[21 - 1];

T48[32] = R32[22 - 1];

T48[33] = R32[23 - 1];

T48[34] = R32[24 - 1];

T48[35] = R32[25 - 1];

T48[36] = R32[24 - 1];

T48[37] = R32[25 - 1];

T48[38] = R32[26 - 1];

T48[39] = R32[27 - 1];

T48[40] = R32[28 - 1];

T48[41] = R32[29 - 1];

T48[42] = R32[28 - 1];

T48[43] = R32[29 - 1];

T48[44] = R32[30 - 1];

T48[45] = R32[31 - 1];

T48[46] = R32[32 - 1];

T48[47] = R32[1 - 1];

}

// Функция создания 16 раундовых ключей

Void key1648(unsigned k64[64], unsigned roundKey[16][48])

{

unsigned kbit[64] = {0};

unsigned T[56] = {0};

unsigned C28[28] = {0},

D28[28] = {0},

cc28[28] = {0},

dd28[28] = {0};

int i, j, r;

// Обнуление массивов

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

{

C28 [i] = 0;

D28 [i] = 0;

cc28[i] = 0;

dd28[i] = 0;

}

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

T[i] = 0;

// Копирование битового представления исходного ключа шифрования

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

kbit[i] = k64[i];

// Начальное формирование ключей раундов для DES (C0, D0)

// Верхняя перестановка PC1 (таблица)

C28[0] = kbit[57 - 1];

C28[1] = kbit[49 - 1];

C28[2] = kbit[41 - 1];

C28[3] = kbit[33 - 1];

C28[4] = kbit[25 - 1];

C28[5] = kbit[17 - 1];

C28[6] = kbit[9 - 1];

C28[7] = kbit[1 - 1];

C28[8] = kbit[58 - 1];

C28[9] = kbit[50 - 1];

C28[10] = kbit[42 - 1];

C28[11] = kbit[34 - 1];

C28[12] = kbit[26 - 1];

C28[13] = kbit[18 - 1];

C28[14] = kbit[10 - 1];

C28[15] = kbit[2 - 1];

C28[16] = kbit[59 - 1];

C28[17] = kbit[51 - 1];

C28[18] = kbit[43 - 1];

C28[19] = kbit[35 - 1];

C28[20] = kbit[27 - 1];

C28[21] = kbit[19 - 1];

C28[22] = kbit[11 - 1];

C28[23] = kbit[3 - 1];

C28[24] = kbit[60 - 1];

C28[25] = kbit[52 - 1];

C28[26] = kbit[44 - 1];

C28[27] = kbit[36 - 1];

// Нижняя перестановка PC1 (таблица)

D28[0 ] = kbit[63 - 1];

D28[1 ] = kbit[55 - 1];

D28[2 ] = kbit[47 - 1];

D28[3 ] = kbit[39 - 1];

D28[4 ] = kbit[31 - 1];

D28[5 ] = kbit[23 - 1];

D28[6 ] = kbit[15 - 1];

D28[7 ] = kbit[7 - 1];

D28[8 ] = kbit[62 - 1];

D28[9] = kbit[54 - 1];

D28[10] = kbit[46 - 1];

D28[11] = kbit[38 - 1];

D28[12] = kbit[30 - 1];

D28[13] = kbit[22 - 1];

D28[14] = kbit[14 - 1];

D28[15] = kbit[6 - 1];

D28[16] = kbit[61 - 1];

D28[17] = kbit[53 - 1];

D28[18] = kbit[45 - 1];

C28[19] = kbit[37 - 1];

D28[20] = kbit[29 - 1];

D28[21] = kbit[21 - 1];

D28[22] = kbit[13 - 1];

D28[23] = kbit[5 - 1];

D28[24] = kbit[28 - 1];

D28[25] = kbit[20 - 1];

D28[26] = kbit[12 - 1];

D28[27] = kbit[4 - 1];

// Вращение битовых массивов

for ( r = 0; r < 16; ++r )

{

if ( r == 0 || r == 1 || r == 8|| r == 15 )

// Вращение одного бита влево

{

for ( i = 1; i < 28; ++i )

{

cc28[i-1] = C28[i];

}

cc28[27] = C28[0];

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

C28[i] = cc28[i];

for ( i = 1; i < 28; ++i )

{

dd28[i-1] = D28[i];

}

dd28[27] = D28[0];

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

D28[i] = dd28[i];

}

else // вращение двух битов влево

{

for ( i = 2; i < 28; ++i )

{

cc28[i-2] = C28[i];

}

cc28[26] = C28[0];

cc28[27] = C28[1];

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

C28[i] = cc28[i];

for ( i = 2; i < 28; ++i )

{

dd28[i-2] = D28[i];

}

dd28[26] = D28[0];

dd28[27] = D28[1];

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

D28[i] = dd28[i];

}

// i-й этап разворачивания раундовых ключей: T = PC1(K);

j = 0;

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

if ( i < 28 )

T[i] = C28[i];

else if ( i >= 28 )

{

T[i] = D28[j++];

}

// Создание раундовых ключей - массива ключей

roundKEY[r][0 ] = T[14 - 1];

roundKEY[r][1 ] = T[17 - 1];

roundKEY[r][2 ] = T[11 - 1];

roundKEY[r][3 ] = T[24 - 1];

roundKEY[r][4 ] = T[1 - 1];

roundKEY[r][5 ] = T[5 - 1];

roundKEY[r][6 ] = T[3 - 1];

roundKEY[r][7 ] = T[28 - 1];

roundKEY[r][8 ] = T[15 - 1];

roundKEY[r][9 ] = T[6 - 1];

roundKEY[r][10] = T[21 - 1];

roundKEY[r][11] = T[10 - 1];

roundKEY[r][12] = T[23 - 1];

roundKEY[r][13] = T[19 - 1];

roundKEY[r][14] = T[12 - 1];

roundKEY[r][15] = T[4 - 1];

roundKEY[r][16] = T[26 - 1];

roundKEY[r][17] = T[8 - 1];

roundKEY[r][18] = T[16 - 1];

roundKEY[r][19] = T[7 - 1];

roundKEY[r][20] = T[27 - 1];

roundKEY[r][21] = T[20 - 1];

roundKEY[r][22] = T[13 - 1];

roundKEY[r][23] = T[2 - 1];

roundKEY[r][24] = T[41 - 1];

roundKEY[r][25] = T[52 - 1];

roundKEY[r][26] = T[31 - 1];

roundKEY[r][27] = T[37 - 1];

roundKEY[r][28] = T[47 - 1];

roundKEY[r][29] = T[55 - 1];

roundKEY[r][30] = T[30 - 1];

roundKEY[r][31] = T[40 - 1];

roundKEY[r][32] = T[51 - 1];

roundKEY[r][33] = T[45 - 1];

roundKEY[r][34] = T[33 - 1];

roundKEY[r][35] = T[48 - 1];

roundKEY[r][36] = T[44 - 1];

roundKEY[r][37] = T[49 - 1];

roundKEY[r][38] = T[39 - 1];

roundKEY[r][39] = T[56 - 1];

roundKEY[r][40] = T[34 - 1];

roundKEY[r][41] = T[53 - 1];

roundKEY[r][42] = T[46 - 1];

roundKEY[r][43] = T[42 - 1];

roundKEY[r][44] = T[50 - 1];

roundKEY[r][45] = T[36 - 1];

roundKEY[r][46] = T[29 - 1];

roundKEY[r][47] = T[32 - 1];

}

}

// Функция Р сжимающей перестановки