Разработка криптографического программного обеспечения
Федеральное
агентство связи
Федеральное
государственное образовательное учреждение
высшего
профессионального образования
«Сибирский
государственный университет
телекоммуникаций
и информатики»
(ФГОБУ ВПО
«СибГУТИ»)
Кафедра
Прикладной математики и кибернетики
.65
Информационная безопасность телекоммуникационных систем (очная форма обучения)
Курсовой
проект
по дисциплине
«Криптографические методы защиты информации»
Разработка
криптографического программного обеспечения
Новосибирск
2015
Оглавление
Введение
. Разработка программного обеспечения,
которое выполняет шифрование по алгоритму RC6
1.1 Алгоритм RC6
.2 Исходный код программы
.3 Вывод
2. Разработка программного обеспечения,
которое выполняет электронную подпись на базе шифра Эль-Гамаля
2.1 Электронная подпись на базе шифра Эль-Гамаля
.2 Исходный код программы
.3 Вывод
3. Задача о нахождении гамильтонова цикла
в графе
3.1 Алгоритм реализации гамильтонова цикла
.2 Исходный код программы
.3 Вывод
Заключение
Библиография
Введение
Целью данной курсовой работы является создание
криптографического программного обеспечения, которое выполняет следующие
задачи:
. шифрование по алгоритму RC6;
. электронная подпись на основе шифра
Эль-Гамаля;
. задача гамильтонов цикл.
В качестве языка программирования был выбран C++.
1. Разработка программного
обеспечения, которое выполняет шифрование по алгоритму RC6
1.1 Алгоритм RC6
Это один из новейших шифров, предложенный Ривертом (Ronald Rivest) в 1998 году. Это шифр принимал участие в конкурсе на
новый стандарт блокового шифра США, проводимом в 1999-2001 годах, прошел в
финал, но по совокупности таких показателей, как быстродействие, удобство
использования и т.п., уступил первое место другому шифру (Rijdael). Тем не менее, активные
исследования RC6 в ходе проведения конкурса не
выявили в нем каких-либо слабых мест, и данный шифр высоко оценивается многими
специалистами.
В RC6
пользователь задаёт размер слова (w) 16, 32 или 64 бита, количество раундов (r), длину ключа (l) от 0 до 255 байт. Размер блока всегда составляет четыре слова.
Конкретный вариант шифра обозначается по схеме RC6-32/20/16 - размер блока 128 бит, длина ключа 128 бит, 20
раундов (такой шифр исследовался в качестве кандидата на стандарт США).
В шифре используются следующие операции:
+, -сложение и вычитание слов по модулю 2w;
*умножение по модулю 2w;
побитовое сложение по модулю 2 или,
что то же самое, «исключающее или» двух слов;
циклические сдвиги слова влево и
вправо на указанное число бит (заметим, что при длине слова w бит величина циклического сдвига
фактически приводится по модулю w,
причем, как правило, это приведение выполняется автоматически на машинном
уровне, т.е. не требует дополнительных вычислений - процесс просто использует
младшие log w бит числа, задающего величину сдвига).
Шифрование и дешифрование блока данных приводится с
использованием одного и того же раундового ключа W длиной 2r+4
слова (нумерация слов с нуля), получаемого из секретного ключа K.
RC6: шифрование блока данных.
Вход: блок из четырех слов (a, b, c, d), раундовый ключ.
Выход: зашифрованный блок (a, b, c, d).
1. 
, 
;
. FOR i = 1, 2, …, r DO
. 
,
. 
,
. 
,
. 
,
. (a, b, c, d) = (b, c, d, a);
. 
, 
;
. RETURN (a, b, c, d).
Для дешифрования просто «прокручиваем» процесс в
обратном порядке.
RC6: дешифрование блока данных.
Вход: блок из четырех слов (a, b, c, d), раундовый ключ W.
Выход: дешифрованный блок (a, b, c, d).
1. 
, 
;
. FOR i = r, r-1, …, 1 DO
. (a, b, c, d) = (d, a, b, c),
. ,
. ,
. 
,
. 
;
. 
, 
;
. RETURN (a, b, c, d).
Расписание раундового ключа в RC6 более сложно, чем в ГОСТ 28147-89, что характерно для
большинства современных шифров. По сути дела речь идет о развертывании
секретного ключа K в более длинную
псевдослучайную последовательность W с целью затруднить криптоанализ шифра.
Обозначим через c число слов в ключе 
. Посредством нижеприведенного алгоритма
секретный ключ K разворачивается
в раундовый ключ W: 
.
В алгоритме используется «магические» числа: Pw - первые w бит служат двоичного разложения числа e-1, где e - число Эйлера, служащее основанием натурального алгоритма,
и Qw - первые w бит двоичного разложения числа f, где 
- «золотое сечение». При w = 32 Pw = b7e15163, Qw = 9e3779b9.
RC6: формирование раундового ключа.
Выход: раундовый ключ W.
1. 
;
. FOR i = 1, 2, …, 2r+3 DO 
;
. a = 0, b = 0, i = 0, j = 0;
. 
;
. DO k раз
. 
, 
,
. 
, 
b = K[j],
. 
, 
;
. RETURN W.
Рассмотрим кратко основные идеи построения алгоритма
шифрования RC6. Заметим, прежде всего, что, как и
в шифрах DES и ГОСТ 28147-89, в каждом раунде RC6 одна половина блока используется
для шифрования другой. Действительно, значение переменных t и u (строки 3-4) определяется только словами b и d соответственно. Затем эти переменные используются для
модификации слов a и c перед сложением с элементами ключа
(строки 5-6). Таким образом, в a и c вносится зависимость от b и d. В следующем раунде пары a, c и b, d меняются ролями, причем b и d
переставляются между собой (строка 7). Вследствие такой структуры шифра
количество раундов должно быть четным.
Рекомендуемое количество раундов r = 20 связанно с результатами
исследования стойкости шифра по отношению к дифференциальному и линейному
криптоанализу.
В ходе исследований шифра слабых ключей не обнаружено,
т.е. любой ключ, даже нулевой, обеспечивает заявляемую высокую стойкость шифра.
Предполагается, что для RC6 не
существует алгоритма взлома, лучшего, чем перебор ключей.
1.2 Исходный код программы
#include <iostream>
#include <fstream>
#include <windows.h>
#include <math.h>
#include <cmath>
#include <time.h>
#include <string>
#include <map>
#include <ctime>
#include <stdlib.h>
#include <functional>
unsigned int RightShift2(unsigned int
z_value, int z_shift, int w) {((z_value >> z_shift) | (z_value <<
(w - z_shift)));
}int LeftShift2(unsigned int z_value,
int z_shift, int w) {((z_value << z_shift) | (z_value >> (w -
z_shift)));
}main() {i, j, w = 32;int r = 20, a =
0, b = 0, c = 0, d = 0, t, u, pw, qw, k, ksb = 4, buf;int *W = new unsigned
int[2 * r + 4];int *K = new unsigned int[ksb];long long buf2 = 1;double f =
1.6180339887498948482045868343656381177203;double e =
2.7182818284590452353602874713526624977572;<<= w;= (unsigned int)((f -
1)*buf2);(qw % 2 == 0)++;= (unsigned int)((e - 2)*buf2);(pw % 2 ==
0)++;<< "w = " << w << " pw = " <<
pw << " " << hex << pw << " qw = "
<< dec << qw << hex << " " << qw
<< dec << endl;<< "Ключ пользователя" <<
endl;(int f = 0; f<ksb; f++){[f] = rand();<< "K[" << f
<< "] = " << K[f] << endl;
}
// Формирование раундового ключа
W[0] = pw;
for (int i = 1; i <= 2 * r + 3;
i++)[i] = W[i - 1] + qw;= 0; b = 0; i = 0; j = 0;= 3 * max(ksb, 2 * r + 4);(k)
{[i] = LeftShift2(W[i] + a + b, 3, w);= W[i];[j] = LeftShift2(K[j] + a + b, a +
b, w);= K[j];= (i + 1) % (2 * r + 4);= (j + 1) % ksb;-;
}<< "Раундовый ключ "
<< endl;(int i = 1; i <= 2 * r + 4; i++)<< "W["
<< i << "] = " << W[i] <<endl;
//Шифрование блока данных
a = 4;
b = 8;
c = 15;=
16;<< "a = " << a << " b = " << b
<< " c = " << c << " d = " << d
<< endl;= b + W[0];= d + W[1];(int i = 1; i <= r; i++)
{= LeftShift2(b *
(2 * b + 1), (int)log2(w), w);= LeftShift2(d * (2 * d + 1), (int)log2(w), w);=
LeftShift2(a^t, u, w) + W[2*i];= LeftShift2(c^u, t, w) + W[2 * i + 1];= a;= b;=
c;= d;= buf;
}= a + W[2 * r +
2];= c + W[2 * r + 3]; <<
"Шифрованный блок данных" << endl;
cout <<
"a = " << a << " b = " << b <<
" c = " << c << " d = " << d <<
endl;
//Дешифрование блока данных
c = c - W[2 * r + 3];
a = a - W[2 * r +
2];(int i = r; i >= 1; i--) {= d;= c;= b;= a;= buf;= LeftShift2(b * (2 * b +
1), (int)log2(w), w);= LeftShift2(d * (2 * d + 1), (int)log2(w), w);=
RightShift2(a - W[2 * i], u, w) ^ t;= RightShift2(c - W[2 * i + 1], t, w) ^ u;
}
d = d - W[1];
b = b - W[0];
cout << "Расшифрованный блок данных"
<< endl;
cout <<
"a = " << a << " b = " << b <<
" c = " << c << " d = " << d <<
endl;
}
1.3 Вывод
В результате выполнения программы, слова, содержащиеся
в блоке данных, зашифровывались по алгоритму RC6, затем расшифровывались и результат расшифровки выводится
на экран. Результат работы программы представлен на рисунке 1.1.
Рисунок 1.1 - Результат выполнения программы
шифрования блока данных алгоритмом RC6
2. Разработка программного
обеспечения, которое выполняет электронную подпись на базе шифра Эль-Гамаля
.1 Электронная подпись на базе шифра Эль-Гамаля
программный криптографический шифрование
гамильтонов
Описание варианта подписи, основанный на задаче
дискретного логарифмирования.
Алиса собирается подписывать документы. Алиса выбирает
большое просто число p и
число g, такие, что различные степени g суть различные числа по модулю p. Эти числа передаются или хранятся в
открытом виде и могут быть общими для целой группы пользователей. Алиса
выбирает случайное число x, 1
< x < p-1, которое она держит в секрете. Это ее секретный ключ.
Затем она вычисляет 
.
Это число y Алиса публикует в качестве своего открытого ключа. Заметим, что при
больших p, зная y, невозможно найти x (это задача дискретного логарифмирования).
Теперь Алиса может подписывать сообщения. Допустим,
она хочет подписать сообщение 
. Опишем последовательность действий для построения записи.
Вначале Алиса вычисляет значение хэш-функции 
, которое должно удовлетворять
неравенству 1 < h < p. Затем Алиса выбирает случайно число
k (1 < k < p-1),
взаимно простое с p-1, и вычисляет
число 
. Далее Алиса вычисляет числа 
, 
.
Под k-1 подразумевается число,
удовлетворяющее уравнению 
.
Такое 
существует, так как k и p-1
взаимно просты, и может быть найдено по обобщенному алгоритму Евклида. Наконец,
Алиса формирует подписанное сообщение {
, r, s}. Получатель
подписанного сообщения, прежде всего, заново вычисляет хеш-функции . Затем он проверяет подпись,
используя равенство 
.
2.2 Исходный код программы
#include <iostream>
#include <fstream>
#include <windows.h>
#include <math.h>
#include <cmath>
#include <time.h>
#include <string>
#include <map>
#include <ctime>
#include
<functional>simpleChecker(long long p){(long long i = 2; i * i <= p;
i++){(p%i == 0)false;
}true;
};long codeMod(long long a, long long
x, long long p){ //быстрое возведение в степеньlong rez = 1;(long long aCurr =
a%p; x>0; x >>= 1, aCurr = aCurr*aCurr%p)(x & 1)= rez*aCurr%p;rez;
}Evklid(long long a, long long b,
long long &nod, long long &x, long long &y) //обощенный алгоритм
Евклида
{long c, q;i;long u[3];long v[3];long
t[3];(a<b) { c = a; a = b; b = c; }[0] = a; u[1] = 1; u[2] = 0;[0] = b; v[1]
= 0; v[2] = 1;(v[0] != 0)
{= u[0] / v[0];(i = 0; i <= 2;
i++)
{[i] = u[i] - q*v[i];
}(u, v, sizeof(v)); memcpy(v, t, sizeof(t));
}= u[0]; x = u[1]; y = u[2];
}main() {long m, p, q, g, x, y, k,
nod, b, v, r, u, s, ko;A;//объявление потока.open("message.txt",
ios::in);>> m;{= rand();= (p - 1) / 2;
} while (simpleChecker(p) != 1 ||
simpleChecker(q) != 1);<< "p = " << p << endl;<<
"q = " << q << endl;{= rand();
} while (g > (p - 1) || codeMod(g,
q, p) == 1);<< "g = " << g << endl;= rand() % (p -
1); //секретный ключ Алисы << "Секретный ключ Алисы x = " << x << endl;
y = codeMod(g, x, p);//открытый ключ
Алисы
cout << "Открытый ключ Алисы y = " << y << endl;
long long h = m;::hash<long
long> e;_t h_hash = e(m);<< "Хэш w = " << h_hash
<< endl;{= rand();(k, (p - 1), nod, b, v);
} while
(k >= (p - 1) || nod !=
1);
cout << "Алиса выбрала случайно число k, взаимно простое с p-1 = " << k << endl;
r = codeMod(g, k, p);= (h - (x * r) %
(p - 1) + p - 1) % (p - 1);{= rand();
} while (ko*k%(p-1) != 1);<<
"k^-1 = " << ko << endl; = (ko * u) % (p - 1);
cout << "подписанное сообщение:" << endl;
cout << m << ";
" << r << ", " << s << endl;
//как бы отправляем подписанное сообщение другому
пользователю
long long rez = codeMod(y, r, p);// y
^ rlong rez1 = codeMod(r, s, p);// r ^ slong rezult = rez * rez1 % p;// y ^ r *
r ^ s(rezult == codeMod(g, h, p))//если (y ^ r * r ^ s) = G ^ h mod P<<
rezult << " = " << codeMod(g, h, p) << endl
<< "Подпись подлинная" << endl << endl <<
endl;
cout << "Подпись неподлинная" << endl;
}
.3 Вывод
В результате содержимое файла message.txt
было зашифровано при помощи электронной подписи на база Эль-Гамаля. Результат
выполнения программы представлен на рисунке 2.1.
Рисунок 2.1 -Результат выполнения программы
3. Задача о нахождении гамильтонова
цикла в графе
.1 Алгоритм реализации гамильтонова цикла
Блюм (Manuel Blum) показал,
что, выражаясь неформально, любое математическое утверждение может быть
представлено в виде графа, причем доказательство этого утверждения
соответствует гамильтонову циклу в этом графе. Поэтому наличие протокола
доказательства с нулевым значением для гамильтонова цикла означает, что
доказательство любого математического утверждения может быть представлено в
форме доказательства с нулевым значением.
Гамильтоновым циклом в графе называется непрерывный
путь, проходящие через все вершины графа ровно по одному разу.
Допустим, что Алиса знает гамильтонов цикл в графе G. Теперь она может это доказать Бобу
и всем, кто имел граф G, с
помощью описываемого ниже протокола. Алиса может использовать это
доказательство, например, для идентификации своей личности. Но прежде чем мы
перейдем к описанию протокола, договоримся о некоторых обозначениях.
Мы будем обозначать графы буквами G, H, F, понимая под
этим одновременно соответствующие матрицы смежности. Элемент матрицы 
, если в графе есть ребро,
соединяющее вершины i и j; 
- в противном случае. Символом ||
будем обозначать конкатенацию (сцепление) двух чисел, точнее двоичных слов, им
соответствующих. Нам понадобится шифр с открытым ключом. Вообще говоря, это
может быть любой шифр, но для определенности будем использовать шифр RSA. Будем считать, что Алиса
сформировала систему RSA с открытыми параметрами N и d. Важно, что
зашифрованные в этой системе сообщения может расшифровать только Алиса и больше
никто.
Протокол доказательства состоит из следующих четырех
шагов.
Шаг 1. Алиса получает граф Н, являющийся копией
исходного графа G, где у всех вершин новые, случайно выбранные номера. На языке
теории графов говорят, что граф Н изоморфен графу G. Иными словами, граф Н
получается путем некоторой перестановки номеров вершин в графе G. Алиса
кодирует матрицу Н, приписывая к первоначально содержащимся в ней нулям и
единицам случайные числа rij по схеме 
. Затем она шифрует элементы матрицы
, получая зашифрованную матрицу F, 
. Матрицу F Алиса передает Бобу.
Шаг 2. Боб, получив зашифрованный граф F, задает Алисе
один из двух вопросов.
. Каков гамильтонов цикл для графа H?
. Действительно ли граф H изоморфен G?
Шаг 3. Алиса отвечает на соответствующий вопрос Боба.
. Она расшифровывает в F ребра, образующие гамильтонов цикл.
. Она расшифровывает F полностью (фактически передает Бобу граф ) и предъявляет перестановки, с
помощью которых граф H был
получен из графа G.
Шаг4. Получив ответ, Боб проверяет правильность
расшифровки путем повторного шифрования и сравнения с F и убеждается либо в том, что показанные ребра действительно
образуют гамильтонов цикл, либо в том, что предъявленные перестановки
действительно переводят граф G в
граф H.
Весь протокол повторяется t раз.
3.2 Исходный код программы
#include <iostream>
#include <fstream>
#include <windows.h>
#include <math.h>
#include <cmath>
#include <time.h>
#include <string>
#include <map>
#include <ctime>
#include <stdlib.h>
#include <functional>namespace
std;prov(long long lim, long long mas[], long long digit)
{i;(i = 0; i<lim; i++)(mas[i] ==
digit)1;0;
}long concatenate(long long first,
long long second) {(!second) {first * 10;
}long temp = second;(temp) {*= 10;/=
10;
}first + second;
}int n = 8;c[n]; // номер хода, на котором посещается
вершинаpath[n];// номера посещаемых вершинv0 = 2; // начальная вершина
//Матрица смежности G
int G[n][n] =
{
, 0, 1, 0, 0, 1, 1, 1,
, 0, 1, 1, 0, 0, 0, 1,
, 1, 0, 0, 1, 1, 1, 0,
, 1, 0, 0, 0, 1, 0, 0,
, 0, 1, 0, 0, 0, 1, 1,
, 0, 1, 1, 0, 0, 0, 0,
, 1, 0, 0, 1, 0, 0, 0,
};gamilton(int k)
{v, q1 = 0;(v = 0; v<n &&
!q1; v++)
{(G[v][path[k - 1]] || G[path[k -
1]][v])
{(k == n && v == v0) q1 =
1;if (c[v] == -1)
{[v] = k; path[k] = v;= gamilton(k +
1);(!q1) c[v] = -1;
}continue;
}
} return q1;
}main() {long P, Q, N = 0, D = 0, C =
0, s = 0, w = 0, f = 0, m, nod;int n = 8;long i, j, SP1[8], buf, buf1, buf2,
buf3, buf4, buf5, buf6, buf7, VB;H[n][n], H2[n][n], F[n][n], MB1[n][n],
MB2[n][n], MB3[n][n]; //MB - матрица Боба{= rand();
} while (simpleChecker(P) != 1);{=
rand();
} while (simpleChecker(Q) != 1);=
Q*P;= (P - 1)*(Q - 1);<< "P = " << P << " Q =
" << Q << endl << "Открытый ключ N = " << N
<< endl;= f + 1;(D >= f || nod != 1) {= (rand() % 100000) * 10000 +
(rand() % 10000);(D, f, nod, m, C);
}(C < 0) C = C + f;<< "Открытый ключ D = " << D << endl;
//Матрица смежности GG[n][n] =
{
, 0, 1, 0, 0, 1, 1, 1,
, 0, 1, 1, 0, 0, 0, 1,
, 1, 0, 0, 1, 1, 1, 0,
, 1, 0, 0, 0, 1, 0, 0,
, 0, 1, 0, 0, 0, 1, 1,
, 0, 1, 1, 0, 0, 0, 0,
, 0, 1, 0, 1, 0, 0, 0,
, 1, 0, 0, 1, 0, 0, 0,
};<< endl << "Матрица смежности G
" << endl;
for (i = 0; i < 8; i++) {(int j =
0; j < 8; j++)<< G[i][j] << " ";<< endl;
}<< endl;<< "Гамильтонов цикл графа G" << endl;(j = 0;
j<n; j++) c[j] = -1;[0] = v0;[v0] = v0;(gamilton(1)) {p;(p = 0; p<n;
p++)<< path[p] << " ";<< path[0];<< endl
<< endl;
}cout << "У данного графа нет гамильтонова цикла" << endl;G0[n] = {
G[path[0]][path[1]], G[path[1]][path[2]], G[path[2]][path[3]],
G[path[3]][path[4]], G[path[4]][path[5]], G[path[5]][path[6]],
G[path[6]][path[7]], G[path[7]][path[0]] };gcg0[3] = { path[0], path[1], G0[0]
};gcg1[3] = { path[1], path[2], G0[1] };gcg2[3] = { path[2], path[3], G0[2]
};gcg3[3] = { path[3], path[4], G0[3] };gcg4[3] = { path[4], path[5], G0[4]
};gcg5[3] = { path[5], path[6], G0[5] };gcg6[3] = { path[6], path[7], G0[6]
};gcg7[3] = { path[7], path[0], G0[7] };<< "gcg0 = ";for (i =
0; i < 3; i++)cout << gcg0[i] << " ";cout <<
endl;<< "gcg1 = ";for (i = 0; i < 3; i++)cout <<
gcg1[i] << " ";cout << endl;<< "gcg2 =
";for (i = 0; i < 3; i++)cout << gcg2[i] << "
";cout << endl;<< "gcg3 = ";for (i = 0; i < 3;
i++)cout << gcg3[i] << " ";cout << endl;<<
"gcg4 = ";for (i = 0; i < 3; i++)cout << gcg4[i] <<
" ";cout << endl;<< "gcg5 = ";for (i = 0; i
< 3; i++)cout << gcg5[i] << " ";cout <<
endl;<< "gcg6 = ";for (i = 0; i < 3; i++)cout <<
gcg6[i] << " ";cout << endl;<< "gcg7 =
";for (i = 0; i < 3; i++)cout << gcg7[i] << "
";cout << endl;
cout << endl << "Случайная
последовательность из 8-ми вершин" << endl;
for (int f = 0; f < 8; f++) {{[f]
= rand() % 8;
} while (prov(f, SP1,
SP1[f]));<< SP1[f] << " ";
}<< endl << endl;=
SP1[0]; buf1 = SP1[1]; buf2 = SP1[2]; buf3 = SP1[3]; buf4 = SP1[4]; buf5 =
SP1[5]; buf6 = SP1[6]; buf7 = SP1[7];= 6; buf1 = 3; buf2 = 4; buf3 = 2; buf4 =
0; buf5 = 1; buf6 = 7; buf7 = 5;bufgl[n] = {buf, buf1, buf2, buf3, buf4, buf5,
buf6, buf7};(i = 0; i < 8; i++) {(j = 0; j < 8; j++) {[i][j] =
G[bufgl[i]][bufgl[j]];
}
}
cout << "Матрица смежности H" << endl;
for (i = 0; i < 8; i++) {(int j =
0; j < 8; j++)<< H[i][j] << " ";<< endl;
}<< endl;h0[n] = {
H[buf1][buf2], H[buf2][buf6], H[buf6][buf5], H[buf5][buf7], H[buf7][buf],
H[buf][buf3], H[buf3][buf4], H[buf4][buf1] };gch0[3] = { buf1, buf2, h0[0]
};gch1[3] = { buf2, buf6, h0[1] };gch2[3] = { buf6, buf5, h0[2] };gch3[3] = {
buf5, buf7, h0[3] };gch4[3] = { buf7, buf, h0[4] };gch5[3] = { buf, buf3, h0[5]
};gch6[3] = { buf3, buf4, h0[6] };gch7[3] = { buf4, buf1, h0[7] }; << "Гамильтон цикл для
матрицы H" << endl;
cout << "gch0 = ";for
(i = 0; i < 3; i++)cout << gch0[i] << " ";cout
<< endl;<< "gch1 = ";for (i = 0; i < 3; i++)cout
<< gch1[i] << " ";cout << endl;<< "gch2
= ";for (i = 0; i < 3; i++)cout << gch2[i] << "
";cout << endl;<< "gch3 = ";for (i = 0; i < 3;
i++)cout << gch3[i] << " ";cout << endl;<<
"gch4 = ";for (i = 0; i < 3; i++)cout << gch4[i] <<
" ";cout << endl;<< "gch5 = ";for (i = 0; i
< 3; i++)cout << gch5[i] << " ";cout <<
endl;<< "gch6 = ";for (i = 0; i < 3; i++)cout <<
gch6[i] << " ";cout << endl;<< "gch7 =
";for (i = 0; i < 3; i++)cout << gch7[i] << "
";cout << endl;(i = 0; i < 8; i++) {(int j = 0; j < 8;
j++)[i][j] = concatenate(rand() % 5 + 1, H[i][j]);
}<< endl << "Матрица
смежности H2" << endl;(i = 0; i < 8; i++) {(int j = 0; j < 8;
j++)<< H2[i][j] << " ";<< endl;
}h20[n] = { H2[buf1][buf2],
H2[buf2][buf6], H2[buf6][buf5], H2[buf5][buf7], H2[buf7][buf], H2[buf][buf3],
H2[buf3][buf4], H2[buf4][buf1] };gch20[3] = { buf1, buf2, h20[0] };gch21[3] = {
buf2, buf6, h20[1] };gch22[3] = { buf6, buf5, h20[2] };gch23[3] = { buf5, buf7,
h20[3] };gch24[3] = { buf7, buf, h20[4] };gch25[3] = { buf, buf3, h20[5]
};gch26[3] = { buf3, buf4, h20[6] };gch27[3] = { buf4, buf1, h20[7] };<<
endl << "Гамильтон цикл для матрицы H2" << endl;<<
"gch20 = ";for (i = 0; i < 3; i++)cout << gch20[i] <<
" "; cout << endl;<< "gch21 = ";for (i = 0; i
< 3; i++)cout << gch21[i] << " "; cout <<
endl;<< "gch22 = ";for (i = 0; i < 3; i++)cout <<
gch22[i] << " "; cout << endl;<< "gch23 =
";for (i = 0; i < 3; i++)cout << gch23[i] << " ";
cout << endl;<< "gch24 = ";for (i = 0; i < 3; i++)cout
<< gch24[i] << " "; cout << endl;<<
"gch25 = ";for (i = 0; i < 3; i++) cout << gch25[i] <<
" "; cout << endl;<< "gch26 = ";for (i = 0; i
< 3; i++)cout << gch26[i] << " "; cout <<
endl;<< "gch27 = ";for (i = 0; i < 3; i++)cout <<
gch27[i] << " "; cout << endl;<< endl <<
"N = " << N << " D = " << D <<
endl;(i = 0; i < 8; i++) {(int j = 0; j < 8; j++)[i][j] =
codeMod(H2[i][j], D, N);
}<< endl;<< "Матрица
смежности F" << endl;(i = 0; i < 8; i++) {(int j = 0; j < 8;
j++)<< F[i][j] << " ";<< endl;
}fp[n] = { F[buf1][buf2],
F[buf2][buf6], F[buf6][buf5], F[buf5][buf7], F[buf7][buf], F[buf][buf3],
F[buf3][buf4], F[buf4][buf1] };gcf0[3] = { buf1, buf2, fp[0] };gcf1[3] = {
buf2, buf6, fp[1] };gcf2[3] = { buf6, buf5, fp[2] };gcf3[3] = { buf5, buf7,
fp[3] };gcf4[3] = { buf7, buf, fp[4] };gcf5[3] = { buf, buf3, fp[5] };gcf6[3] =
{ buf3, buf4, fp[6] };gcf7[3] = { buf4, buf1, fp[7] };<< endl <<
"Гамильтон цикл для матрицы F" << endl;<< "gcf0 =
";for (i = 0; i < 3; i++)cout << gcf0[i] << "
";cout << endl;<< "gcf1 = ";for (i = 0; i < 3;
i++)cout << gcf1[i] << " ";cout << endl;<<
"gcf2 = ";for (i = 0; i < 3; i++)cout << gcf2[i] <<
" ";cout << endl;<< "gcf3 = ";for (i = 0; i
< 3; i++)cout << gcf3[i] << " ";cout <<
endl;<< "gcf4 = ";for (i = 0; i < 3; i++)cout <<
gcf4[i] << " ";cout << endl;<< "gcf5 =
";for (i = 0; i < 3; i++)cout << gcf5[i] << "
";cout << endl;<< "gcf6 = ";for (i = 0; i < 3;
i++)cout << gcf6[i] << " ";cout << endl;<<
"gcf7 = ";for (i = 0; i < 3; i++)cout << gcf7[i] <<
" ";cout << endl; = rand()
% 2 + 1;
cout << endl << "Какой из двух вопросов будет задавать Боб VB = " << VB << endl;
if (VB == 1) {
cout << endl << "Боб выбрал первый вопрос:\nДействительно ли граф H изоморфен G?\n\nТогда Алиса отправляет Бобу матрицу H2 и\nиспользованную
последовательность bufgl[n]" << endl;
for (i = 0; i < 8; i++) {(int j =
0; j < 8; j++)[i][j] = codeMod(H2[i][j], D, N);
}= 0;(MB1[i][j] == F[i][j]) { << endl << "Полученная матрица Бобом MB1 после проверки равна матрице F - правильно" << endl;
}
else {
cout << endl << "Полученная матрица Бобом MB1 после проверки не равна матрице F - неправильно" << endl;
}(i = 0; i < 8; i++) {(int j = 0;
j < 8; j++)[i][j] = H2[i][j] % 10;
}(MB2[i][j] == H[i][j]) { << endl << "Полученная матрица Бобом MB2 после отброса старшей десятичной
цифры\nравна матрице H - правильно" << endl;
}
else {
cout << endl << "Полученная матрица Бобом MB2 после отброса старшей десятичной цифры\nне равна матрице H - неправильно" << endl;
}(i = 0; i < 8; i++) {(j = 0; j
< 8; j++) {[i][j] = MB2[bufgl[i]][bufgl[j]];
}
}(MB3[i][j] == G[i][j]) {<<
endl << "Полученная матрица
Бобом MB3 после перестановки вершин\nравна матрице G - правильно" << endl;
}
else {
cout << endl << "Полученная матрица Бобом MB3 после перестановки вершин\nне равна матрице G - неправильно" << endl;
}
cout << endl << "На этом реализация первого вопроса заканчивается"
<< endl;
}
if (VB == 2) {
cout << endl << "Боб выбрал второй вопрос:\nКаков гамильтонов цикл для графа H?\n\nТогда Алиса отправляет Бобу\nсоответствующий список
(закодированных) ребер графа H2"
<< endl << endl;
cout << "Проверка соответствия Бобом ребер
матрицы H2 матрице F" << endl;
int PB[n];(i = 0; i < 8; i++) {[i]
= codeMod(h20[i], D, N);
}
if (PB[i] == fp[i]) {
cout << endl << "Полученные результаты соответвствуют кодам ребер матрицы F - правильно" << endl;
else {
cout << endl << "Полученные результаты не соответвствуют кодам ребер
матрицы F - неправильно" << endl;
}
cout << endl << "На этом реализация второго вопроса заканчивается"
<< endl;
}
}
.3 Вывод
В ходе выполнения программы была решена задача.
Результат выполнения программы представлен на рисунке 3.1.
Рисунок 3 -результат выполнения программы «Шаг
младенца шаг великана»
Заключение
В результате выполнения данного проекта было
разработано криптографическое программное обеспечение, решающее следующие
задачи:
. шифрование по алгоритму RC6;
. электронная подпись на основе шифра
Эль-Гамаля;
. задача гамильтонов цикл.
Библиография
1 Рябко, Б.Я. Криптографические методы защиты информации / Б.Я.
Рябко, А.Н. Фионов. - Москва: Горячая линия - телеком, 2005. - 229с.
Конспект лекций по предмету криптографические методы защиты
информации