Разработка программной реализации криптографического алгоритма ГОСТ 28147-89 в режиме гаммирования с обратной связью

Размещено на http://allbest.ru/

Тема: «Разработка программной реализации криптографического алгоритма ГОСТ 28147-89 в режиме гаммирования с обратной связью»

Оглавление

1. Постановка задачи на проектирование

2. Описание компонентов сети конфиденциальной связи

2.1 Система распределения ключей на основе линейных преобразований (основная)

2.2 Система распределения ключей на основе алгоритма Диффи и Хелмана (резервная)

2.3 Отечественный алгоритм шифрования данных (ГОСТ 28147-89). Режим гаммирования с обратной связью

3. Данные по скоростным качествам алгоритма шифрования

4. Результаты расчетов криптостойкости алгоритма шифрования

Заключение

Приложение

1. Постановка задачи на проектирование

В соответствии с исходными данными необходимо разработать систему засекреченной связи на основе использования симметричного блочного алгоритма ГОСТ 28147-89 в режиме с обратной связью при этом обеспечить распределение основных сеансовых ключей на основе линейных преобразований, а распределение резервных - с применением алгоритма Диффи и Хелмана.

Исходные данные (вариант №6)

ГОСТ 28147 - 89 гаммирование с обратной связью;

Число выдерживаемых компрометаций - 6;

Простое число Р - 61;

(ADC69D1E91EE65C6712E0764E9F2F4C69A80B8EE9D5AFB36DA023A881BAE256F)

4. Количество пользователей конфиденциальной сети -50000;

2. Описание компонентов сети конфиденциальной связи

2.1 Система распределения ключей на основе линейных преобразований. (основная)

1. ЦРК генерирует и рассылает пользователям их открытые ключи:

Р_i = (Р_{i 1}, Р_{i 2},….,Р_{i L}),

где i=1,2,…,V (количество пользователей);

Адрес пользователя представляет собой некоторый вектор, элементы которого должны быть линейно независимыми. Для чего в курсовом проекте реализован следующий способ формирования адреса пользователя:

- выбирается случайное число а (16 битовое основание);

- вектор адресов рассчитывается следующим образом:

Р_i = (aⁱ, a^i*2 ,…., a^i*L),

где i=1,2,…,V , а L - количество компрометаций;

- размер Рⁱ_j составляет 16 бит (максимальное значение 65535), что определяет количество пользователей (в задании 50000);

2. ЦРК генерирует L*L симметричную случайную матрицу Т=(m*n), где элементы матрицы t_mn выбираются равновероятными и взаимонезависимыми, и имеют размерность равную длине ключа (256 бит).

3. ЦРК генерирует и рассылает по конфиденциальным каналам связи каждому пользователю его секретный ключ:

S_i = T*P_i^T;

4. Формирование парного ключа между i и j пользователем происходит следующим образом:

- i пользователь извлекает из запоминающего устройства открытый адрес пользователя j и формирует парный ключ на основе своего секретного ключа S_i:

К_ij = S_i*P_j^T;

- j пользователь извлекает из запоминающего устройства открытый адрес пользователя i и формирует парный ключ на основе своего секретного ключа S_j:

К_ji = S_j*P_i^T;

В виду симметричности матрицы Т ключи К_ij и K_ji будут равными. Далее ключ поступает в ключевое устройство блока шифрации алгоритма ГОСТ 28147-89.

2.2 Система распределения ключей на основе алгоритма Диффи и Хелмана (резервная)

1. Пользователи сети заранее уславливаются о модуле Р (большом простом числе размерности 256 бит) и примитивном элементе gZ_p (в курсовом проекте g выбирается как корень из единицы степени N по модулю P и имеет размерность 128 бит).

2. Для установления связи между i и j пользователем они заранее выбирают собственные секретные ключи X и Y (256 бит).

3. Далее пользователь i вычисляет открытый ключ:

К_i = g^X(mod P),

а пользователь j - открытый ключ:

К_j = g^Y(mod P).

4. Обменявшись открытыми ключами, пользователи вычисляют общий секретный ключ:

пользователь i: К_ij = (g^X)^Y(mod P);

пользователь j: К_ji = (g^Y)^X(mod P);

Очевидно, ключи К_ij и K_ji будут равными. Далее ключ поступает в ключевое устройство блока шифрации алгоритма ГОСТ 28147-89.

2.3 Отечественный алгоритм шифрования данных (ГОСТ 28147-89). Режим гаммирования с обратной связью

Зашифрование открытых данных в режиме гаммирования с обратной связью.

Криптосхема, реализующая алгоритм зашифрования в режиме гаммирования с обратной связью, имеет вид, указанный на рис. 1.1.

Открытые данные, разбитые на 64-разрядные блоки зашифровываются в режиме гаммирования с обратной связью путем поразрядного суммирования по модулю 2 в сумматоре СМ₅ с гаммой шифра Г_ш, которая вырабатывается блоками по 64 бита, т.е. где М определяется объемом открытых данных,^_ i-й 64-разрядный блок, Число двоичных разрядов в блоке может быть меньше 64.

В КЗУ вводятся 256 бит ключа. Синхропосылка S = (S₁, S₂,..., S₆₄) из 64 бит вводится в N₁ и N₂. Исходное заполнение N₁ и N₂ зашифровывается в режиме простой замены. Полученное в результате зашифрования заполнение N₁ и N₂ образует первый 64-разрядный блок гаммы шифра который суммируется поразрядно по модулю 2 в сумматоре СМ₅ с первым 64-разрядным блоком открытых данных

В результате получается 64-разрядный блок зашифрованных данных

Блок зашифрованных данных одновременно является также исходным состоянием N₁, N₂ для выработки второго блока гаммы шифра и по обратной связи записывается в указанные накопители. При этом значение вводится в 1-й разряд N₁, значение вводится во 2-й разряд N₁ и т.д. значение вводится в 32-й разряд N₁; значение вводится в 1-й разряд N₂, значение вводится во 2-й разряд N₂ и т.д., значение вводится в 32-й разряд N₂.

Заполнение N₁, N₂ зашифровывается в режиме простой замены в соответствии с требованиями ГОСТ 28147-89. Полученное в результате зашифрования заполнение N₁, N₂ образует второй 64-разрядный блок гаммы шифра , который суммируется поразрядно по модулю 2 в сумматоре СМ₅ со вторым блоком открытых данных

Выработка последующих блоков гаммы шифра и зашифрование соответствующих блоков открытых данных производится аналогично. Если длина последнего М-го блока открытых данных меньше 64 разрядов, то из используется только соответствующее число разрядов гаммы шифра, остальные разряды отбрасываются.

Уравнения зашифрования в режиме гаммирования с обратной связью имеет вид:



В канал связи или память ЭВМ передаются синхропосылка S и блоки зашифрованных данных

Расшифрование зашифрованных данных в режиме гаммирования с обратной связью.

При расшифровании криптосхема имеет тот же вид (см. рис. 1.1), что и при зашифровании. В КЗУ вводятся 256 бит того же ключа, на котором осуществлялось зашифрование . Синхропосылка S вводится в N₁ и N₂.

Исходное заполнение N₁, N₂ (синхропосылка S) зашифровывается в режиме простой замены. Полученное в результате зашифрования N₁, N₂ образует первый блок гаммы шифра который суммируется поразрядно по модулю 2 в сумматоре СМ₅ с блоком зашифрованных. В результате получается первый блок данных открытых данных

Блок зашифрованных данных является исходным заполнением N₁, N₂ для выработки второго блока гаммы шифра . Блок записывается в N₁, N₂. Полученное заполнение N₁, N₂ зашифровывается в режиме простой замены, в результате блок суммируется поразрядно по модулю 2 в сумматоре СМ₅ со вторым блоком зашифрованных данных . В результате получается блок открытых данных

Аналогично в N₁, N₂ последовательно записываются блоки зашифрованных данных , из которых в режиме простой замены вырабатываются блоки гаммы шифра . Блоки гаммы шифра суммируются поразрядно по модулю 2 в сумматоре СМ₅ с блоками зашифрования данных , в результате получаются блоки открытых данных , при этом длина последнего блока открытых данных может содержать меньше 64 разрядов.

Уравнения расшифрования в режиме гаммирования с обратной связью имеет вид:

Рис. 1.1

Правила суммирования по модулю 2³² и по модулю (2³²-1)

1. Два целых числа a, b, где , представленные в двоичном виде

a = (a₃₂, a₃₁, ... , a₂, a₁), b = (b₃₂, b₃₁, ... , b₂, b₁),

т.е. a = a₃₂2³¹ + a₃₁2³⁰ + ... + a₂2 + a₁, b = b₃₂2³¹ + b₃₁2³⁰ + ... + b₂2 + b₁,

суммируются по модулю 2³²(операция ) по следующему правилу:

a b = a + b, если a + b < 2³²,

a b = a + b - 2³², если a + b 2³²

где операция +(-) есть арифметическая сумма(разность) двух целых чисел.

2. Два целых числа a,b, где 0 a, b 2³²-1, представленные в двоичном виде a = (a₃₂, a₃₁, ... ,a₂, a₁), b = (b₃₂, b₃₁, ... ,b₂, b₁),

суммируются по модулю (2³² - 1) (операция ) по следующему правилу:

a b = a + b, если a + b < 2³²,

a b = a + b - 2³² +1 , если a + b 2³².

3. Данные по скоростным качествам алгоритма шифрования

Листинг программной реализации криптографической системы представлен в приложении 1.

Работа программы осуществляется из командной строки:

> 28147_3.exe FileName.*,

где FileName.* - любой файл содержащий шифруемые данные.

Выходными данными работы программы являются:

- FileName.crp - файл с зашифрованным сообщением;

- FileName.dcr - файл с расшифрованным сообщением;

- FileName.key - файл-отчет, содержащий ключевую информацию (резервную и основную), а также некоторые характеристики процесса шифрования;

Вариант содержания файла-отчета FileName.key

== Исходные данные для шифрации == 1. Основные: Адрес первого абонента (№ 31945): ADRESS1 = 9FB2 FB62 44F5 485E E080 250C Адрес второго абонента (№ 25334): ADRESS2 = D15F EC7D 90CD 8F80 35DD 9610 Сеансовые ключи абонентов: К12 = C38D498F9E8DF8A9D077AD4E5606AE8600260E7189E60907011BC088E61C6411 К21 = C38D498F9E8DF8A9D077AD4E5606AE8600260E7189E60907011BC088E61C6411 Cинхропосылка : SYN = 04E21970 10C943E8 2. Резервные: P = 9D1EADC665C691EE0764712EF4C6E9F2B8EE9A80FB369D5A3A88DA02256F1BAE GEN = 76F8746A46E440E32F4E28D91CA73F3D X = 69F143C92C9F64516D4B43560E7C75FD Y = 203F1D35344D054C23D20AFE4FFB2630 Сеансовый ключ: KEY = 6FBC94F893EEE6EFD32B8CBD7F4BF87B9DE7D369FCC1A1BC7F900869C045EA95 Cинхропосылка : SYN = 04E21970 10C943E8 == Характеристики процесса шифрации == Размер сообщения (кбайт) - 9862.410 Время шифрации (в секундах) - 19.670 Скорость шифрации (кбайт/с) - 501.385 Обработка велась в резервном режиме.

При расчете скорости шифрования учитывалось общее время криптографического преобразования исходного сообщения и запись полученной шифрограммы в файл. Программа реализована в среде алгоритмического программирования Borland C++ 5.02, и применение программного языка Assembler позволит увеличить скорость шифрования приблизительно до 1,5 Мб/с. Аппаратная реализация данной системы конфиденциальной связи увеличит скорость до 10 Мб/с и более, что делает предпочтительным применение оптоволоконных линий связи, но повысит расходы на построение сети.

4. Результаты расчетов криптостойкости алгоритма шифрования

шифрование конфиденциальный связь преобразование

При использовании метода линейных преобразований для формирования общего ключа (основной режим) выбор размера используемых матриц определялся исходя из заданного количества выдерживаемых компрометаций (L=6). Таким образом, симметричная матрица Т имеет размерность Т[6,6] и длину каждого элемента матрицы равную длине ключа шифрования (256 бит), используемой в ГОСТ 28147-89. Элементы матрицы генерировались равновероятно и взаимонезависимо.

Адреса абонентов являются векторами вида Р_i=(P₁ⁱ,P₂ⁱ, …,P_Lⁱ), где L = 6. Размер каждого элемента адреса равен 16 битам, что определяется максимальным количеством абонентов конфиденциальной сети (2¹⁶ > 50000). Адрес каждого пользователя рассчитывается так, чтобы элементы вектора были линейно-независимыми.

При выполнении данных условий сформированные секретные ключи S_i каждого пользователя сети будут также равновероятными и линейно-независимыми, что является необходимым условием криптостойкости на основе заданного числа компрометаций. Если же нарушитель перехватил (или ему стали известны) более 6 секретных ключей и соответствующих им адресов абонентов, то система конфиденциальной связи считается раскрытой, так как могут быть вычислены любые оставшиеся секретные ключи.

При использовании алгоритма Диффи и Хелмана для формирования сеансового ключа (резервный режим) использовались следующие данные:

- Р - большое 256 битовое простое число (модуль);

- g - генератор поля Z_p (в КП выбран случайным образом и имеет длину 128 бит, т. е. является корнем из единицы степени N по модулю Р);

- X и Y - случайные числа размерности 128 бит;

- K_ij - сеансовый ключ, имеющий длину 256 бит;

Криптостойкость данной схемы распределения основывается на трудности решения задачи дискретного логарифмирования. Для ключа 256 бит задача практически неразрешима. Таким образом, выбор значений N и g имеет существенное влияние на безопасность этой системы. Число (N-1)/2 также должно быть большим простым числом, а число g должно быть генератором большой подгруппы мультипликативной группы по модулю N.

При обмене ключами по незащищенным каналам связи необходимо убедиться, что абонент А получил ключ именно от абонента B, и наоборот. Эта проблема решается с помощью электронной цифровой подписи.

В качестве криптосистемы в рамках курсового проекта используется криптосистема блочного шифрования с обратной связью, которой является алгоритм шифрования ГОСТ 28147-89. Используемая длина ключа равна 256 битам, и определяет криптостойкость данной системы. Достоинством данной схемы шифрования является возможность применения ее для обнаружения манипуляций сообщениями, производимых активными перехватчиками. При этом используется факт размножения ошибок. Однако размножение ошибок можно отнести и к недостаткам такого шифра. Схему шифрования с обратной связью следует применять для криптографического преобразования больших массивов данных (сообщений).

Заключение

Данная работа не преследует цели реализации реальной системы конфиденциальной связи, а предполагает лишь разработку модели ее функционирования, используя реальные алгоритмы и длины ключей.

Проведенный анализ криптостойкости алгоритмов распределения ключей и алгоритма шифрования данных подтвердил высокую стойкость применения данных схем при построении реальной системы засекреченной связи.

Приложение

#include <io.h>

#include <stdio.h>

#include <conio.h>

#include <iostream.h>

#include <fstream.h>

#include <math.h>

#include <time.h>

#include <string.h>

#include <stdlib.h>

typedef unsigned long DWord; // Двойное слово;

typedef unsigned int Word; // слово;

typedef unsigned char HWord; // Половина слова;

DWord FILESIZE (FILE *flow);

DWord a_in_P_modN (DWord a, DWord r, DWord N);

void ADDFILE (FILE *flow,short ost,DWord MES[2]);

void DICRIMENT (Word P[32],Word Q[32],Word RES[32]);

void MULTIPLE (Word Mn1[16],Word Mn2[16],Word RES[32],Word R);

void X_in_Y_modN (Word a[16],Word r[16],Word MODULE[16],Word RES[16]);

void TAKE_MODULE(Word NUMBER[32],Word OST[16],Word MOD[16]);

void SUMMA (Word P[16],Word Q[16],Word RES[16]);

union DATE {

DWord num;

HWord byte[4];

}ptr;

union Result_Long_Word{

DWord BL32;

Word BL16[2];

}W_ptr;

HWord part[8];

int main (int argc, char *argv[])

{

//--------------Программа реализации алгоритма шифрования ГОСТ 28147-89-------

//--------------в режиме обратной связи на основе алгоритма распределения-------

//--------------ключей c использованием линейных преобразований (основной)-------

//------------------------------и Диффи-Хелмана (запасной)----------------------

//----------------------------------Блок исходных данных-------------------------

clrscr();

randomize();

FILE *keystream;

FILE *datastream;

FILE *crptstream;

FILE *decrptstream;

int i=0,j=0,m=0,n=0,t=0;

clock_t start,end;

DWord GAMMA[3];

DWord MESSAGE[2],CRT_MESSAGE[2];

DWord SYN[2];

Word KEY_MAS[32];

Word Y[16]={0x0,},X[16]={0x0,},GEN[16]={0x0,},A_KEY[16],B_KEY[16];

Word P[16]={0x1BAE,0x256F,0xDA02,0x3A88,0x9D5A,0xFB36,0x9A80,0xB8EE,

0xE9F2,0xF4C6,0x712E,0x0764,0x91EE,0x65C6,0xADC6,0x9D1E};

Word T[6][6][16]={{{0x0,},},};

Word ADRESS1[6][16]={{0x0,},},RES1[16]={0x0,},S1[6][16]={{0x0,},};

Word ADRESS2[6][16]={{0x0,},},RES2[16]={0x0,},S2[6][16]={{0x0,},};

Word K12[16]={0x0,},K21[16]={0x0,};

Word L=0,a=1,user1,user2;

DWord size, file_size, length=0;

short ostatok, double prog_time;

Hword const S[1024] = {0xE4,0xEA,0xE9,0xE2,0xED,0xE8,0xE0,0xEE,0xE6,0xEB,0xE1,0xEC,0xE7,0xEF,0xE5,0xE3,

0xB4,0xBA,0xB9,0xB2,0xBD,0xB8,0xB0,0xBE,0xB6,0xBB,0xB1,0xBC,0xB7,0xBF,0xB5,0xB3,

0x44,0x4A,0x49,0x42,0x4D,0x48,0x40,0x4E,0x46,0x4B,0x41,0x4C,0x47,0x4F,0x45,0x43,

0xC4,0xCA,0xC9,0xC2,0xCD,0xC8,0xC0,0xCE,0xC6,0xCB,0xC1,0xCC,0xC7,0xCF,0xC5,0xC3,

0x64,0x6A,0x69,0x62,0x6D,0x68,0x60,0x6E,0x66,0x6B,0x61,0x6C,0x67,0x6F,0x65,0x63,

0xD4,0xDA,0xD9,0xD2,0xDD,0xD8,0xD0,0xDE,0xD6,0xDB,0xD1,0xDC,0xD7,0xDF,0xD5,0xD3,

0xF4,0xFA,0xF9,0xF2,0xFD,0xF8,0xF0,0xFE,0xF6,0xFB,0xF1,0xFC,0xF7,0xFF,0xF5,0xF3,

0xA4,0xAA,0xA9,0xA2,0xAD,0xA8,0xA0,0xAE,0xA6,0xAB,0xA1,0xAC,0xA7,0xAF,0xA5,0xA3,

0x24,0x2A,0x29,0x22,0x2D,0x28,0x20,0x2E,0x26,0x2B,0x21,0x2C,0x27,0x2F,0x25,0x23,

0x34,0x3A,0x39,0x32,0x3D,0x38,0x30,0x3E,0x36,0x3B,0x31,0x3C,0x37,0x3F,0x35,0x33,

0x84,0x8A,0x89,0x82,0x8D,0x88,0x80,0x8E,0x86,0x8B,0x81,0x8C,0x87,0x8F,0x85,0x83,

0x14,0x1A,0x19,0x12,0x1D,0x18,0x10,0x1E,0x16,0x1B,0x11,0x1C,0x17,0x1F,0x15,0x13,

0x04,0x0A,0x09,0x02,0x0D,0x08,0x00,0x0E,0x06,0x0B,0x01,0x0C,0x07,0x0F,0x05,0x03,

0x74,0x7A,0x79,0x72,0x7D,0x78,0x70,0x7E,0x76,0x7B,0x71,0x7C,0x77,0x7F,0x75,0x73,

0x54,0x5A,0x59,0x52,0x5D,0x58,0x50,0x5E,0x56,0x5B,0x51,0x5C,0x57,0x5F,0x55,0x53,

0x94,0x9A,0x99,0x92,0x9D,0x98,0x90,0x9E,0x96,0x9B,0x91,0x9C,0x97,0x9F,0x95,0x93,

0x75,0x78,0x71,0x7D,0x7A,0x73,0x74,0x72,0x7E,0x7F,0x7C,0x77,0x76,0x70,0x79,0x7B,

0xD5,0xD8,0xD1,0xDD,0xDA,0xD3,0xD4,0xD2,0xDE,0xDF,0xDC,0xD7,0xD6,0xD0,0xD9,0xDB,

0xA5,0xA8,0xA1,0xAD,0xAA,0xA3,0xA4,0xA2,0xAE,0xAF,0xAC,0xA7,0xA6,0xA0,0xA9,0xAB,

0x15,0x18,0x11,0x1D,0x1A,0x13,0x14,0x12,0x1E,0x1F,0x1C,0x17,0x16,0x10,0x19,0x1B,

0x05,0x08,0x01,0x0D,0x0A,0x03,0x04,0x02,0x0E,0x0F,0x0C,0x07,0x06,0x00,0x09,0x0B,

0x85,0x88,0x81,0x8D,0x8A,0x83,0x84,0x82,0x8E,0x8F,0x8C,0x87,0x86,0x80,0x89,0x8B,

0x95,0x98,0x91,0x9D,0x9A,0x93,0x94,0x92,0x9E,0x9F,0x9C,0x97,0x96,0x90,0x99,0x9B,

0xF5,0xF8,0xF1,0xFD,0xFA,0xF3,0xF4,0xF2,0xFE,0xFF,0xFC,0xF7,0xF6,0xF0,0xF9,0xFB,

0xE5,0xE8,0xE1,0xED,0xEA,0xE3,0xE4,0xE2,0xEE,0xEF,0xEC,0xE7,0xE6,0xE0,0xE9,0xEB,

0x45,0x48,0x41,0x4D,0x4A,0x43,0x44,0x42,0x4E,0x4F,0x4C,0x47,0x46,0x40,0x49,0x4B,

0x65,0x68,0x61,0x6D,0x6A,0x63,0x64,0x62,0x6E,0x6F,0x6C,0x67,0x66,0x60,0x69,0x6B,

0xC5,0xC8,0xC1,0xCD,0xCA,0xC3,0xC4,0xC2,0xCE,0xCF,0xCC,0xC7,0xC6,0xC0,0xC9,0xCB,

0xB5,0xB8,0xB1,0xBD,0xBA,0xB3,0xB4,0xB2,0xBE,0xBF,0xBC,0xB7,0xB6,0xB0,0xB9,0xBB,

0x25,0x28,0x21,0x2D,0x2A,0x23,0x24,0x22,0x2E,0x2F,0x2C,0x27,0x26,0x20,0x29,0x2B,

0x55,0x58,0x51,0x5D,0x5A,0x53,0x54,0x52,0x5E,0x5F,0x5C,0x57,0x56,0x50,0x59,0x5B,

0x35,0x38,0x31,0x3D,0x3A,0x33,0x34,0x32,0x3E,0x3F,0x3C,0x37,0x36,0x30,0x39,0x3B,

0x46,0x4C,0x47,0x41,0x45,0x4F,0x4D,0x48,0x44,0x4A,0x49,0x4E,0x40,0x43,0x4B,0x42,

0xB6,0xBC,0xB7,0xB1,0xB5,0xBF,0xBD,0xB8,0xB4,0xBA,0xB9,0xBE,0xB0,0xB3,0xBB,0xB2,

0xA6,0xAC,0xA7,0xA1,0xA5,0xAF,0xAD,0xA8,0xA4,0xAA,0xA9,0xAE,0xA0,0xA3,0xAB,0xA2,

0x06,0x0C,0x07,0x01,0x05,0x0F,0x0D,0x08,0x04,0x0A,0x09,0x0E,0x00,0x03,0x0B,0x02,

0x76,0x7C,0x77,0x71,0x75,0x7F,0x7D,0x78,0x74,0x7A,0x79,0x7E,0x70,0x73,0x7B,0x72,

0x26,0x2C,0x27,0x21,0x25,0x2F,0x2D,0x28,0x24,0x2A,0x29,0x2E,0x20,0x23,0x2B,0x22,

0x16,0x1C,0x17,0x11,0x15,0x1F,0x1D,0x18,0x14,0x1A,0x19,0x1E,0x10,0x13,0x1B,0x12,

0xD6,0xDC,0xD7,0xD1,0xD5,0xDF,0xDD,0xD8,0xD4,0xDA,0xD9,0xDE,0xD0,0xD3,0xDB,0xD2,

0x36,0x3C,0x37,0x31,0x35,0x3F,0x3D,0x38,0x34,0x3A,0x39,0x3E,0x30,0x33,0x3B,0x32,

0x66,0x6C,0x67,0x61,0x65,0x6F,0x6D,0x68,0x64,0x6A,0x69,0x6E,0x60,0x63,0x6B,0x62,

0x86,0x8C,0x87,0x81,0x85,0x8F,0x8D,0x88,0x84,0x8A,0x89,0x8E,0x80,0x83,0x8B,0x82,

0x56,0x5C,0x57,0x51,0x55,0x5F,0x5D,0x58,0x54,0x5A,0x59,0x5E,0x50,0x53,0x5B,0x52,

0x96,0x9C,0x97,0x91,0x95,0x9F,0x9D,0x98,0x94,0x9A,0x99,0x9E,0x90,0x93,0x9B,0x92,

0xC6,0xCC,0xC7,0xC1,0xC5,0xCF,0xCD,0xC8,0xC4,0xCA,0xC9,0xCE,0xC0,0xC3,0xCB,0xC2,

0xF6,0xFC,0xF7,0xF1,0xF5,0xFF,0xFD,0xF8,0xF4,0xFA,0xF9,0xFE,0xF0,0xF3,0xFB,0xF2,

0xE6,0xEC,0xE7,0xE1,0xE5,0xEF,0xED,0xE8,0xE4,0xEA,0xE9,0xEE,0xE0,0xE3,0xEB,0xE2,

0x1D,0x1B,0x14,0x11,0x13,0x1F,0x15,0x19,0x10,0x1A,0x1E,0x17,0x16,0x18,0x12,0x1C,

0xFD,0xFB,0xF4,0xF1,0xF3,0xFF,0xF5,0xF9,0xF0,0xFA,0xFE,0xF7,0xF6,0xF8,0xF2,0xFC,

0xDD,0xDB,0xD4,0xD1,0xD3,0xDF,0xD5,0xD9,0xD0,0xDA,0xDE,0xD7,0xD6,0xD8,0xD2,0xDC,

0x0D,0x0B,0x04,0x01,0x03,0x0F,0x05,0x09,0x00,0x0A,0x0E,0x07,0x06,0x08,0x02,0x0C,

0x5D,0x5B,0x54,0x51,0x53,0x5F,0x55,0x59,0x50,0x5A,0x5E,0x57,0x56,0x58,0x52,0x5C,

0x7D,0x7B,0x74,0x71,0x73,0x7F,0x75,0x79,0x70,0x7A,0x7E,0x77,0x76,0x78,0x72,0x7C,

0xAD,0xAB,0xA4,0xA1,0xA3,0xAF,0xA5,0xA9,0xA0,0xAA,0xAE,0xA7,0xA6,0xA8,0xA2,0xAC,

0x4D,0x4B,0x44,0x41,0x43,0x4F,0x45,0x49,0x40,0x4A,0x4E,0x47,0x46,0x48,0x42,0x4C,

0x9D,0x9B,0x94,0x91,0x93,0x9F,0x95,0x99,0x90,0x9A,0x9E,0x97,0x96,0x98,0x92,0x9C,

0x2D,0x2B,0x24,0x21,0x23,0x2F,0x25,0x29,0x20,0x2A,0x2E,0x27,0x26,0x28,0x22,0x2C,

0x3D,0x3B,0x34,0x31,0x33,0x3F,0x35,0x39,0x30,0x3A,0x3E,0x37,0x36,0x38,0x32,0x3C,

0xED,0xEB,0xE4,0xE1,0xE3,0xEF,0xE5,0xE9,0xE0,0xEA,0xEE,0xE7,0xE6,0xE8,0xE2,0xEC,

0x6D,0x6B,0x64,0x61,0x63,0x6F,0x65,0x69,0x60,0x6A,0x6E,0x67,0x66,0x68,0x62,0x6C,

0xBD,0xBB,0xB4,0xB1,0xB3,0xBF,0xB5,0xB9,0xB0,0xBA,0xBE,0xB7,0xB6,0xB8,0xB2,0xBC,

0x8D,0x8B,0x84,0x81,0x83,0x8F,0x85,0x89,0x80,0x8A,0x8E,0x87,0x86,0x88,0x82,0x8C,

0xCD,0xCB,0xC4,0xC1,0xC3,0xCF,0xC5,0xC9,0xC0,0xCA,0xCE,0xC7,0xC6,0xC8,0xC2,0xCC

};

//------------------Подготовка необходимых файлов-----------------------------------

if ((datastream = fopen( argv[1], "rb")) == NULL){

cout << " Файл " << argv[1] << " не найден .\n";

return 1;

}

char extention[4]="crp";extention[3]=NULL;

char *point = ".";

char *rout;

strcpy(rout,argv[1]);

length=strcspn(rout,point);

rout[length+1]=NULL; strcat(rout,extention);

if ((crptstream = fopen (rout,"w+b")) == NULL){

cout << " Файл "<<rout<<" не найден .\n";

return 1;

}

extention[0]='d';extention[1]='c';extention[2]='r';extention[3]=NULL;

rout[length+1]=NULL; strcat(rout,extention);

if ((decrptstream = fopen ( rout , "w+b"))==NULL)

{ cout << " Файл "<<rout<<" невозможно открыть.\n";

return 1;

}

extention[0]='k';extention[1]='e';extention[2]='y';extention[3]=NULL;

rout[length+1]=NULL; strcat(rout,extention);

if ((keystream = fopen (rout,"w+t"))==NULL){

cout << " Файл "<<rout<<" невозможно открыть.\n";

return 1;

}

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

cout<<endl;

cout<<" Идет обработка сообщения. "<<endl;

cout<<" Please, wait! ";

//--------------Блок генерации и распределения ключей на основе -----------------

//-------------------------линейных преобразований-------------------------------

//-------------------------------(основной)--------------------------------------

// 1. Генерация симетричной матрицы Т из равновероятных элементов tij:

for(t=0;t<6;t++){

for(int i=L;i<6;i++){

for(int j=0;j<16;j++){

T[t][i][j]=(DWord)rand()%0xFFFF;

T[i][t][j]=T[t][i][j];

}

}

L++;

}

// 2. Формирование открытых адресов пользователей:

while(a==1)

a=rand()%0xFFFF; // выбор основания а;

user1=rand()%0xC351; // случайный выбор двух

user2=rand()%0xC351; // из 50.000 пользователей;

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

ADRESS1[j][0]=a_in_P_modN(a,user1*(j+1),0xFFFF);

ADRESS2[j][0]=a_in_P_modN(a,user2*(j+1),0xFFFF);

}

// 3. Формирование секретных ключей пользователей:

for(t=0;t<6;t++){

f or(i=0;i<6;i++){

MULTIPLE (T[t][i],ADRESS2[i],RES2,16);

SUMMA (S2[t],RES2,S2[t]);

MULTIPLE (T[t][i],ADRESS1[i],RES1,16);

SUMMA (S1[t],RES1,S1[t]);

}

}

// 4. Формирование общего сеансового ключа К12=К21:

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

MULTIPLE (S1[i],ADRESS2[i],RES1,16);

SUMMA (K12,RES1,K12);

MULTIPLE (S2[i],ADRESS1[i],RES2,16);

SUMMA (K21,RES2,K21);

}

DWord *Key_USER1=(DWord*)(K12);

DWord *Key_USER2=(DWord*)(K21);

//--------------Блок генерации и распределения ключей на основе алгоритма--------

//--------------------------------Диффи-Хелмана----------------------------------

//---------------------------------(резервный)-----------------------------------

// 1. Выбор общего генератора поля (128 бит):

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

GEN[j]=rand()%0xFFFF;

// 2. Абонент А генерирует случайное число Х(128 бит) и выч. GEN^X(mod P):

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

X[j]=rand()%0xFFFF;

X_in_Y_modN (GEN,X,P,A_KEY);

// 3. Абонент Б генерирует случайное число Y(128 бит) и выч. GEN^Y(mod P):

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

Y[j]=rand()%0xFFFF;

X_in_Y_modN (GEN,Y,P,B_KEY);

// 4. Вычисление сеансового ключа:

MULTIPLE (A_KEY,B_KEY,KEY_MAS,32);

TAKE_MODULE(KEY_MAS,KEY_MAS,P);

DWord *KEYS=(DWord*)(KEY_MAS);

//--------------------Блок шифрации и дешифрации сообщения-----------------------

// 1. Генерация синхропосылки и установка нач.заполнения регистров N1 и N2:

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

SYN[j]=((DWord)rand()%0xFFFF)*((DWord)rand()%0xFFFF);

GAMMA[j]=SYN[j];

}

// 2. Шифрация и дешифрация сообщения:

char reserv; // резервное распределение ключей;

int FELUER=rand()%2;

if(FELUER==1)

r eserv='Y';

else

reserv='N';

char action='Ш'; // действие-шифрация;

for(int act=0;act<2;act++){

if(act==1){

action='Д'; // действие-дешифрация;

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

GAMMA[j]=SYN[j];

file_size=FILESIZE(crptstream);

}

else{

start = clock();

file_size=FILESIZE(datastream);

}

size=file_size;

ostatok=size%8;

size=size/8;

if(ostatok!=0)

++size;

for (DWord cicle=0;cicle<size;cicle++){

if(cicle==(size-1)){

if(action=='Д')

ADDFILE(crptstream,ostatok,MESSAGE);

else

ADDFILE(datastream,ostatok,MESSAGE);

}

else{

if(action=='Д'){

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

fread(part,4,1,crptstream);

MESSAGE[i]=*(DWord*)(part);

}

}

else{

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

fread(part,4,1,datastream);

MESSAGE[i]=*(DWord*)(part);

}

}

}

int step=0;

int metka=0;

for(n=0;n<4;n++){

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

if(n==3)

step=7-m;

else

step=m;

if((action=='Ш')&&(reserv=='N'))

ptr.num=GAMMA[0]+Key_USER1[step];

else if((action=='Д')&&(reserv=='N'))

ptr.num=GAMMA[0]+Key_USER2[step];

else

ptr.num=GAMMA[0]+KEYS[step];

metka=0x00;

for (t=0;t<4;t++){

ptr.byte[t]=(int)S[(int)ptr.byte[t]+metka];

metka+=0x100;

}

ptr.num=(ptr.num << 11) | (ptr.num >> 21);

if ((n==3)&&(step==0))

GAMMA[1]=(ptr.num)^GAMMA[1];

else{

GAMMA[3]=GAMMA[0];

GAMMA[0]=ptr.num^GAMMA[1];

GAMMA[1]=GAMMA[3];

}

}

}

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

if(action=='Д'){

CRT_MESSAGE[j]=MESSAGE[j];

MESSAGE[j]=GAMMA[j]^MESSAGE[j];

GAMMA[j]=CRT_MESSAGE[j];

}

else{

MESSAGE[j]=GAMMA[j]^MESSAGE[j];

GAMMA[j]=MESSAGE[j];

}

}

if(cicle==(size-1)){

HWord *uk=(HWord*)(MESSAGE);

uk[ostatok]=NULL;

if(action=='Ш')

fwrite (uk,ostatok,1,crptstream);

else

fwrite (uk,ostatok,1,decrptstream);

}

else{

if(action=='Ш')

fwrite (MESSAGE,4,2,crptstream);

else

fwrite (MESSAGE,4,2,decrptstream);

}

}

if(act==0)

end = clock();

}

prog_time=((double)(end)-(double)(start))/CLK_TCK; // Определение времени шифрования

//------------------Заполнение файла отчета--------------------------------------

fprintf(keystream," == Исходные данные для шифрации ==\r\r");

fprintf(keystream," 1. Основные: \r\r");

fprintf(keystream," Адрес первого абонента (№ %d):\r\r ",user1);

fprintf(keystream," ADRESS1 = ");

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

fprintf(keystream,"%04X",ADRESS1[i][0]);

fprintf(keystream,"\r\r Адрес второго абонента (№ %d):\r\r ",user2);

fprintf(keystream," ADRESS2 = ");

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

fprintf(keystream,"%04X",ADRESS2[i][0]);

fprintf(keystream,"\r\r Сеансовые ключи абонентов:\r\r ");

fprintf(keystream," К12 = ");

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

fprintf(keystream,"%08lX",Key_USER1[i]);

fprintf(keystream,"\r\r К21 = ");

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

fprintf(keystream,"%08lX",Key_USER2[i]);

fprintf(keystream,"\r\r Cинхропосылка :\r\r ");

fprintf(keystream," SYN = ");

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

fprintf(keystream,"%08lX ",SYN[i]);

fprintf(keystream,"\r\r 2. Резервные:\r\r ");

fprintf(keystream," P = ");

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

fprintf(keystream,"%04X",P[i]);

fprintf(keystream,"\r\r GEN = ");

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

fprintf(keystream,"%04X",GEN[i]);

fprintf(keystream,"\r\r X = ");

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

fprintf(keystream,"%04X",X[i]);

fprintf(keystream,"\r\r Y = ");

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

fprintf(keystream,"%04X",Y[i]);

fprintf(keystream,"\r\r Сеансовый ключ:\r\r ");

fprintf(keystream," KEY = ");

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

fprintf(keystream,"%08lX",KEYS[i]);

fprintf(keystream,"\r\r Cинхропосылка :\r\r ");

fprintf(keystream," SYN = ");

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

fprintf(keystream,"%08lX ",SYN[i]);

fprintf(keystream,"\r\r == Характеристикип процесса шифрации ==\r\r");

fprintf(keystream," Размер сообщения (кбайт) - %.3lf \r\r",(double)file_size/1024);

fprintf(keystream," Время шифрации (в секундах) - %.3lf \r\r",prog_time);

fprintf(keystream," Скорость шифрации (кбайт/с) - %.3lf \r\r",(double)file_size/(1024*prog_time));

fprintf(keystream," Обработка велась в ");

if(reserv=='Y')

fprintf(keystream," резервном режиме. ");

else

fprintf(keystream," основном режиме. ");

fclose(crptstream);

fclose(decrptstream);

fclose(keystream);

fclose(datastream);

clrscr();

return 0;

}

//----------Функция считывания данных из файла с дополнением --------------------

void ADDFILE (FILE *flow,short ost,DWord MES[2]){

short times;

for(int i=0;i<2;i++)

MES[i]=0x0;

times = (short)floor((double)ost/4);

if(times==1){

fread(part,4,1,flow);

M ES[0]=*(DWord*)(part);

}

if(ost%4!=0){

fread (part,ost%4,1,flow);

for(int s=ost%4;s<4;s++)

part[s]=NULL;

MES[times]=*(DWord*)(part);

}

fseek(flow,0,SEEK_SET);

}

//-------------------Функция определения длины файла --------------------

DWord FILESIZE (FILE *flow){

DWord size;

fseek(flow,0,SEEK_END);

size=ftell(flow);

fseek(flow,0,SEEK_SET);

return size;

}

//--------------------Функция разности двух 512 битовых чисел--------------

void DICRIMENT (Word P[32],Word Q[32],Word RES[32]){

Word CUR_RES[32]={0x0,};

int ZAEM=0x0;

for(int e=0;e<32;e++){

if(P[e]<Q[e]){

CUR_RES[e]=0x10000-Q[e]+P[e]-ZAEM;

ZAEM=0x1;

}

else{

CUR_RES[e]=P[e]-Q[e]-ZAEM;

ZAEM=0x0;

}

}

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

RES[e]=CUR_RES[e];

}

//-------------------Функция умножения двух 256 битовых чисел---------------

void MULTIPLE (Word Mn1[16],Word Mn2[16],Word RES[32],Word R){

W_ptr.BL32=0;

DWord BUF=0x0;

Word Previece_ST_part=0,Current_ML_part=0;

Word CUR_RES[32]={0x0,};

for(int j=0;j<16;j++){

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

if(i==0){

CUR_RES[15+j]=Previece_ST_part;

Previece_ST_part=0;

}

W_ptr.BL32=(DWord)Mn1[i]*(DWord)Mn2[j];

Current_ML_part=W_ptr.BL16[0];

BUF=(DWord)CUR_RES[i+j]+(DWord)Current_ML_part+Previece_ST_part;

CUR_RES[i+j]+=Current_ML_part+Previece_ST_part;

Previece_ST_part=W_ptr.BL16[1]+(Word)(BUF>>16);

if((j==15)&&(i==15)) CUR_RES[i+j+1]=Previece_ST_part;

}

}

for(int e=0;e<R;e++)

RES[e]=CUR_RES[e];

}

//-----------------------Функция вычисления 256 битового модуля 512 битового числа---------------

void TAKE_MODULE(Word NUMBER[32],Word OST[16],Word MOD[16]){

Word ii=31,jj=15;

Word K[16]={0x0,},CUR_MOD[32],CUR_NUM[32];

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

CUR_NUM[i]=NUMBER[i];

while(MOD[jj]==0x0)

jj--;

while((CUR_NUM[ii]==0x0)&&(ii>0))

ii--;

while (ii>=jj){

if(CUR_NUM[ii]>=MOD[jj]){

if((ii-jj)>15){

K[0]=CUR_NUM[ii]/MOD[jj];

MULTIPLE (K,MOD,CUR_MOD,32);

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

K[i]=0x0;

K[ii-jj-16]=0x1;

MULTIPLE (K,CUR_MOD,CUR_MOD,32);

for(i=ii;i>ii-16;i--){

CUR_MOD[i]=CUR_MOD[i-16];

CUR_MOD[i-16]=0x0;

}

DICRIMENT (CUR_NUM,CUR_MOD,CUR_NUM);

}

else{

K[ii-jj]=CUR_NUM[ii]/MOD[jj];

MULTIPLE (K,MOD,CUR_MOD,32);

DICRIMENT (CUR_NUM,CUR_MOD,CUR_NUM);

}

}

else{

if(ii>jj){

if((ii-jj)>15){

W_ptr.BL32=0;

W_ptr.BL16[1]=CUR_NUM[ii];

K[0]=W_ptr.BL32/(DWord)MOD[jj];

MULTIPLE (K,MOD,CUR_MOD,32);

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

K[i]=0x0;

if((ii-jj)!=16){

K[ii-jj-16]=0x1;

MULTIPLE (K,CUR_MOD,CUR_MOD,32);

}

for(i=ii;i>=ii-14;i--){

CUR_MOD[i]=CUR_MOD[i-15];

CUR_MOD[i-15]=0x0;

}

DICRIMENT (CUR_NUM,CUR_MOD,CUR_NUM);

}

else{

W_ptr.BL32=0x0;

W_ptr.BL16[1]=CUR_NUM[ii];

K[ii-jj-1]=W_ptr.BL32/(DWord)MOD[jj];

MULTIPLE (K,MOD,CUR_MOD,32);

DICRIMENT (CUR_NUM,CUR_MOD,CUR_NUM);

}

}

else

break;

}

while(CUR_NUM[ii]==0x0){

if(ii==0)

break;

ii--;

}

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

K[i]=0x0;

}

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

OST[i]=CUR_NUM[i];

}

//---------------------Функция вычисления 256 битового модуля степени 256 битового числа------------

void X_in_Y_modN (Word a[16],Word r[16],Word MODULE[16],Word RES[16]){

unsigned short bit,cicle,MASK = 0x01;

Word B[16],A[16],stepen;

Word BUFFER1[32];

Word BUFFER2[32];

int step;

for(int j=15;j>=0;j--){

A[j]=a[j];

B[j]=a[j];

}

for(int k=15;k>=0;k--){

stepen=r[k];

bit = 0;step=16;

while((bit==0)&&(step>0)){

step--;

bit = (stepen>>step)&MASK;

}

cicle = step-1;

step--;

if(step>=0){

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

bit = (stepen>>step)&MASK;

if (bit == 0){

MULTIPLE (A,A,BUFFER1,32);

TAKE_MODULE(BUFFER1,A,MODULE);

}

else{

MULTIPLE (A,A,BUFFER1,32);

TAKE_MODULE(BUFFER1,A,MODULE);

MULTIPLE (B,A,BUFFER2,32);

TAKE_MODULE(BUFFER2,A,MODULE);

}

step--;

}

}

}

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

RES[i]=A[i];

}

void SUMMA (Word P[16],Word Q[16],Word RES[16]){

Word CUR_RES[16]={0x0,};

DWord SUMMA=0x0;

Word PERENOS=0x0;

for(int e=0;e<16;e++){

SUMMA=(DWord)P[e]+(DWord)Q[e]+PERENOS;

CUR_RES[e]=(Word)SUMMA;

if(SUMMA>0xFFFF)

PERENOS=0x1;

else

PERENOS=0x0;

}

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

RES[e]=CUR_RES[e];

}

DWord a_in_P_modN (DWord a, DWord r, DWord N){

DWord B,A,stepen;

long double complit_part;

unsigned short bit,cicle;

unsigned short MASK = 0x01;

int step = 32;

stepen = r;

A=a; B=a;

bit = 0;

if (stepen==1){

A =(unsigned long)(A - floor(A/(long double)N)*(long double)N);

return A;

}

while(bit==0){

step--;

bit = (stepen>>step)&MASK;

}

cicle = step-1;

step--;

for (int j=0;j<=cicle;j++){

bit = (stepen>>step)&MASK;

if (bit == 0){

complit_part = pow((long double)A,2);

A =(unsigned long)(complit_part - floor(complit_part/(long double)N)*(long double)N);

}

else{

complit_part = pow((long double)A,2);

A =(unsigned long)(complit_part - floor(complit_part/(long double)N)*(long double)N);

complit_part = (long double)A*(long double)B;

A =(unsigned long)(complit_part - floor(complit_part/(long double)N)*(long double)N);

}

step--;

}

return A;

}

Размещено на Allbest.ru