Void p(unsigned t2[48], unsigned p[32])

{

// Стандартная P-таблица

P[0 ] = T2[16 - 1];

P[1 ] = T2[7 - 1];

P[2 ] = T2[20 - 1];

P[3 ] = T2[21 - 1];

P[4 ] = T2[29 - 1];

P[5 ] = T2[12 - 1];

P[6 ] = T2[28 - 1];

P[7 ] = T2[17 - 1];

P[8 ] = T2[1 - 1];

P[9 ] = T2[15 - 1];

P[10] = T2[23 - 1];

P[11] = T2[26 - 1];

P[12] = T2[5 - 1];

P[13] = T2[18 - 1];

P[14] = T2[31 - 1];

P[15] = T2[10 - 1];

P[16] = T2[2 - 1];

P[17] = T2[8 - 1];

P[18] = T2[24 - 1];

P[19] = T2[14 - 1];

P[20] = T2[32 - 1];

P[21] = T2[27 - 1];

P[22] = T2[3 - 1];

P[23] = T2[9 - 1];

P[24] = T2[19 - 1];

P[25] = T2[13 - 1];

P[26] = T2[30 - 1];

P[27] = T2[6 - 1];

P[28] = T2[22 - 1];

P[29] = T2[11 - 1];

P[30] = T2[4 - 1];

P[31] = T2[25 - 1];

}

// Функция раундов расшифрования

#include "hDES.h" // подключение заголовка с прототипами функций

// Определение функции раундов расшифрования

Void rback( const unsigned char keytext[], unsigned Bit64[64], unsigned bip[64] )

{

// Аргументы функции

// keytext - секретный ключ

// Bit64 - массив зашифрованных битов

// BIP - массив расшифрованных битов (двоичное представление

// расшифрованного блока данных)

// Для битового представления секретного ключа

unsigned kBit64[64] = {0};

// Для стандартной начальной перестановки

unsigned IP64[64] = {0};

unsigned L0[32] = {0}; // левый подблок

unsigned R0[32] = {0}; ///правый подблок

unsigned Li[32] = {0}; // левый подблок

unsigned Ri[32] = {0}; // правый подблок

unsigned tempL[32] = {0}; // вспомогательный массив

unsigned key[16][48] = {0}; // массив раундовых ключей

unsigned key2[16][48] = {0};

unsigned T48[48] = {0}; // блок расширения с 32 бит до 48 бит

// Блок результата операции XOR (T48 XOR Ki)

unsigned T1[48] = {0};

unsigned T2[32] = {0}; // блок сжатия с S таблицами

// Блок после Р - табличной перестановки

unsigned T3[32] = {0};

unsigned RiLi[64] = {0}; // блок слияния массивов Ri, Li

int i, j, r;

// Обращение к функции битового представления секретного ключа

str64bit( keytext, kBit64 );

// Стандартная начальная перестановка

IP64[0 ] = Bit64[58 - 1];

IP64[1 ] = Bit64[50 - 1];

IP64[2 ] = Bit64[42 - 1];

IP64[3 ] = Bit64[34 - 1];

IP64[4 ] = Bit64[26 - 1];

IP64[5 ] = Bit64[18 - 1];

IP64[6 ] = Bit64[10 - 1];

IP64[7 ] = Bit64[2 - 1];

IP64[8 ] = Bit64[60 - 1];

IP64[9 ] = Bit64[52 - 1];

IP64[10] = Bit64[44 - 1];

IP64[11] = Bit64[36 - 1];

IP64[12] = Bit64[28 - 1];

IP64[13] = Bit64[20 - 1];

IP64[14] = Bit64[12 - 1];

IP64[15] = Bit64[4 - 1];

IP64[16] = Bit64[62 - 1];

IP64[17] = Bit64[54 - 1];

IP64[18] = Bit64[46 - 1];

IP64[19] = Bit64[38 - 1];

IP64[20] = Bit64[30 - 1];

IP64[21] = Bit64[22 - 1];

IP64[22] = Bit64[14 - 1];

IP64[23] = Bit64[6 - 1];

IP64[24] = Bit64[64 - 1];

IP64[25] = Bit64[56 - 1];

IP64[26] = Bit64[48 - 1];

IP64[27] = Bit64[40 - 1];

IP64[28] = Bit64[32 - 1];

IP64[29] = Bit64[24 - 1];

IP64[30] = Bit64[16 - 1];

IP64[31] = Bit64[8 - 1];

IP64[32] = Bit64[57 - 1];

IP64[33] = Bit64[49 - 1];

IP64[34] = Bit64[41 - 1];

IP64[35] = Bit64[33 - 1];

IP64[36] = Bit64[25 - 1];

IP64[37] = Bit64[17 - 1];

IP64[38] = Bit64[9 - 1];

IP64[39] = Bit64[1 - 1];

IP64[40] = Bit64[59 - 1];

IP64[41] = Bit64[51 - 1];

IP64[42] = Bit64[43 - 1];

IP64[43] = Bit64[35 - 1];

IP64[44] = Bit64[27 - 1];

IP64[45] = Bit64[19 - 1];

IP64[46] = Bit64[11 - 1];

IP64[47] = Bit64[3 - 1];

IP64[48] = Bit64[61 - 1];

IP64[49] = Bit64[53 - 1];

IP64[50] = Bit64[45 - 1];

IP64[51] = Bit64[37 - 1];

IP64[52] = Bit64[29 - 1];

IP64[53] = Bit64[21 - 1];

IP64[54] = Bit64[13 - 1];

IP64[55] = Bit64[5 - 1];

IP64[56] = Bit64[63 - 1];

IP64[57] = Bit64[55 - 1];

IP64[58] = Bit64[47 - 1];

IP64[59] = Bit64[39 - 1];

IP64[60] = Bit64[31 - 1];

IP64[61] = Bit64[23 - 1];

IP64[62] = Bit64[15 - 1];

IP64[63] = Bit64[7 - 1];

// Разбиение битовой строки IP64 на два подблока L0, R0

j = 0;

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

if ( i < 32 )

L0[i] = IP64[i];

else

R0[j++] = IP64[i];

// Вызов функции key1648() для формирования раундовых ключей

key1648(kBit64, key2); // key - раундовые ключи

// Обращение ключей

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

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

key[i][j] = key2[15 - i][j];

// Формулы расшифрования

// Li = Ri-1, i = 1,2,…,16;

// Ri = Li-1 xor f(Ri-1,Ki), i = 1,2,…,16.

// 1-й раунд -------------------------------------------------

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

{

Li[i] = R0[i]; // обмен массивов

}

// Раундовая функция расширения (E) - расширение блока R0 (32 бит)

// до 48 бит

E48( R0, T48 ); // T48 - результат расширения

// Применение операции XOR

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

T1[i] = T48[i] ^ key[0][i];

T1T2(T1, T2); // T2 – 32-х битный блок

P(T2, T3); // Т3 - результат перестановки блока Т2

// Операция XOR

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

{

Ri[i] = L0[i] ^ T3[i];

}

// Окончание 1-го раунда ----------------------------------

// Формирование 14 раундов перестановок

for ( r = 1; r < 15; ++r )

{

// Формулы зашифрования

// Li = Ri-1, i = 1,2,…,16;

// Ri = Li-1 xor f(Ri-1,Ki), i = 1,2,…,16.

// r-й раунд -----------------------------------------------

for ( i = 0; i < 32; ++i ) //// для обмена массивов

{

tempL[i] = Li[i];

Li[i] = Ri[i];

}

// Раундовая функция расширения (E) - расширение блока Ri (32 бит)

// до 48 бит

E48( Ri, T48 ); // T48 - результат расширения

// Применение операции XOR

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

T1[i] = T48[i] ^ key[r][i];

T1T2(T1, T2); // T2 - 32 битный блок

P(T2, T3); // Т3 - результат перестановки блока Т2

// Операция XOR

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

{

Ri[i] = tempL[i] ^ T3[i];

}

// Окончание r-го раунда --------------------------------

// Результат: Li_15, Ri_15

}

// Последний 16 раунд

for ( i = 0; i < 32; ++i ) // для обмена массивов

{

tempL[i] = Li[i];

Li[i] = Ri[i];

}

// Раундовая функция расширения (E) - расширение блока Ri (32 бит)

// до 48 бит

E48( Ri, T48 ); // T48 - результат расширения

// Применение операции XOR

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

T1[i] = T48[i] ^ key[r][i];

T1T2(T1, T2); // T2 - 32 битный блок

P(T2, T3); // Т3 - результат перестановки блока Т2

// Операция XOR

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

{

Ri[i] = tempL[i] ^ T3[i];

}

// Окончание 16-го раунда ------------------------------

// Результат: Li_16, Ri_16

// Слияние массивов Ri, Li

j = 0;

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

if ( i < 32 )

RiLi[i] = Ri[i];

else

RiLi[i] = Li[j++];

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

BIP[0 ] = RiLi[40 - 1];

BIP[1 ] = RiLi[8 - 1];

BIP[2 ] = RiLi[48 - 1];

BIP[3 ] = RiLi[16 - 1];

BIP[4 ] = RiLi[56 - 1];

BIP[5 ] = RiLi[24 - 1];

BIP[6 ] = RiLi[64 - 1];

BIP[7 ] = RiLi[32 - 1];

BIP[8 ] = RiLi[39 - 1];

BIP[9 ] = RiLi[7 - 1];

BIP[10] = RiLi[47 - 1];

BIP[11] = RiLi[15 - 1];

BIP[12] = RiLi[55 - 1];

BIP[13] = RiLi[23 - 1];

BIP[14] = RiLi[63 - 1];

BIP[15] = RiLi[31 - 1];

BIP[16] = RiLi[38 - 1];

BIP[17] = RiLi[6 - 1];

BIP[18] = RiLi[46 - 1];

BIP[19] = RiLi[14 - 1];

BIP[20] = RiLi[54 - 1];

BIP[21] = RiLi[22 - 1];

BIP[22] = RiLi[62 - 1];

BIP[23] = RiLi[30 - 1];

BIP[24] = RiLi[37 - 1];

BIP[25] = RiLi[5 - 1];

BIP[26] = RiLi[45 - 1];

BIP[27] = RiLi[13 - 1];

BIP[28] = RiLi[53 - 1];

BIP[29] = RiLi[21 - 1];

BIP[30] = RiLi[61 - 1];

BIP[31] = RiLi[29 - 1];

BIP[32] = RiLi[36 - 1];

BIP[33] = RiLi[4 - 1];

BIP[34] = RiLi[44 - 1];

BIP[35] = RiLi[12 - 1];

BIP[36] = RiLi[52 - 1];

BIP[37] = RiLi[20 - 1];

BIP[38] = RiLi[60 - 1];

BIP[39] = RiLi[28 - 1];

BIP[40] = RiLi[35 - 1];

BIP[41] = RiLi[3 - 1];

BIP[42] = RiLi[43 - 1];

BIP[43] = RiLi[11 - 1];

BIP[44] = RiLi[51 - 1];

BIP[45] = RiLi[19 - 1];

BIP[46] = RiLi[59 - 1];

BIP[47] = RiLi[27 - 1];

BIP[48] = RiLi[34 - 1];

BIP[49] = RiLi[2 - 1];

BIP[50] = RiLi[42 - 1];

BIP[51] = RiLi[10 - 1];

BIP[52] = RiLi[50 - 1];

BIP[53] = RiLi[18 - 1];

BIP[54] = RiLi[58 - 1];

BIP[55] = RiLi[26 - 1];

BIP[56] = RiLi[33 - 1];

BIP[57] = RiLi[1 - 1];

BIP[58] = RiLi[41 - 1];

BIP[59] = RiLi[9 - 1];

BIP[60] = RiLi[49 - 1];

BIP[61] = RiLi[17 - 1];

BIP[62] = RiLi[57 - 1];

BIP[63] = RiLi[25 - 1];

}

// Функция раундовых перестановок

#include "hDES.h" // подключение заголовка с прототипами функций

// Определение функции раундовых перестановок