Void round16(const unsigned char ptext[], const unsigned char ktext[], unsigned bip[64] )

{

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

// ptext[] – открытый текст

// ktext[] - ключ

// BIP[64] - массив обратной перестановки

// Битовое представление открытого текста

unsigned Bit64[64] = {0};

// Битовое представление заданного секретного ключа

unsigned kBit64[64] = {0};

unsigned IP64[64] = {0}; // начальная перестановка

unsigned L0[32] = {0},// левая половина начальной перестановки

R0[32] = {0},// правая половина начальной перестановки

Li[32] = {0},// левая половина массива перестановки

Ri[32] = {0},// правая половина массива перестановки

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

unsigned key[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( ptext, Bit64 ); // для открытого текста

str64bit( ktext, 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, key); //// key - раундовые ключи

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

// 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) - расширение блока R0 (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) - расширение блока R0 (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];

}

// Функция битового представления строки из 8 байтов