Разработка программного приложения "DES"

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

МИНОБРНАУКИ РОССИИ

РГУ нефти и газа (НИУ) имени И.М. Губкина

Курсовая работа

По дисциплине Методы программирования

На тему Разработка программного приложения «DES»

Выполнили:

Киселева А.И., Матюшин А.М.

Москва, 2022



Оглавление

Введение

Глава 1. Спецификация требований к разрабатываемому приложению

1.1 Анализ предметной области

1.2 Описание функций, методов, алгоритмов взаимодействия

Глава 2. Описание алгоритма шифрования

2.1 Обзор алгоритма DES

2.2 Логическая схема

Глава 3. Разработка программного кода приложения

Вывод



Введение

Целью данной курсовой работы является разработка программного приложения «DES».

Данный вопрос можно считать актуальным, так как при в настоящий момент алгоритм DES (Data Encryption Standard) является наиболее широко используемым алгоритмом шифрования в мире. В течение многих лет и среди многих людей "создание секретного кода" и DES были синонимами. И, несмотря на недавний успех Electronic Frontier Foundation в создании машины стоимостью 220 000 долларов для взлома сообщений, зашифрованных DES, DES еще долгие годы будет использоваться в правительстве и банковской сфере благодаря версии, продлевающей жизнь, под названием "triple-DES".

Для достижения цели необходимо решить следующие задачи:

Определить спецификацию требований к разрабатываемому приложению.

Описать алгоритм шифрования

Разработать программный код приложения и само приложение.

Разработка программного приложения «DES» позволит закрепить знания, полученные во время изучения дисциплины «Методы программирования», а также применить на практике навыки программирования на языке С++.



Глава 1. Спецификация требований к разрабатываемому приложению

1.1 Анализ предметной области

15 мая 1973 года, во время правления Ричарда Никсона, Национальное бюро стандартов (NBS) опубликовало в Федеральном реестре уведомление с запросом предложений по криптографическим алгоритмам для защиты данных во время передачи и хранения. В уведомлении объяснялось, почему шифрование является важной проблемой.

За последнее десятилетие наблюдается рост накопления и передачи цифровых данных правительством, промышленностью и другими организациями частного сектора. Содержание этих передаваемых и хранимых данных часто имеет очень значительную ценность. В настоящее время часто можно встретить передачи данных, которые представляют собой денежные переводы в размере нескольких миллионов долларов, покупку или продажу ценных бумаг, ордера на арест или записи об аресте и осуждении, передаваемые между правоохранительными органами, бронирование авиабилетов и билетов, представляющих инвестиции и ценность как для авиакомпании, так и для пассажиров, а также передаваемые записи о состоянии здоровья и уходе за пациентами среди врачей и лечебных центров.

Растущий объем, ценность и конфиденциальность этих записей, регулярно передаваемых и хранимых коммерческими и государственными учреждениями, привели к усилению признания и обеспокоенности по поводу их подверженности несанкционированному доступу и использованию. Это злоупотребление может быть в форме кражи или искажения записей данных, представляющих денежные средства, злонамеренного изменения бизнес-инвентаря или перехвата и неправильного использования конфиденциальной информации о людях. Тогда потребность в защите становится очевидной и неотложной. Признано, что шифрование представляет собой единственное средство защиты таких данных во время передачи и полезное средство защиты содержимого данных, хранящихся на различных носителях, при условии, что шифрование достаточной надежности может быть разработано и проверено. Национальное бюро стандартов запрашивает предлагаемые методы и алгоритмы шифрования компьютерных данных. Бюро также запрашивает рекомендуемые методы для реализации криптографической функции: для генерации, оценки и защиты криптографических ключей; для сохранения файлов, закодированных в соответствии с истекающими ключами; для частичного обновления зашифрованных файлов; и смешанных открытых и зашифрованных данных для обеспечения маркировки, опроса, маршрутизации и т.д. Бюро, выполняя свою роль по установлению стандартов и оказанию помощи правительству и промышленности в оценке технологий, организует оценку методов защиты с целью подготовки руководящих принципов.

NBS ждал пока поступят ответы. Она не получила ни одного до 6 августа 1974 года, за три дня до отставки Никсона, когда IBM представила кандидата, которого она разработала внутри компании под названием LUCIFER. После оценки алгоритма с помощью Агентства национальной безопасности (АНБ) 15 июля 1977 года NBS приняло модификацию алгоритма LUCIFER в качестве нового стандарта шифрования данных (DES).

DES был быстро принят для нецифровых носителей, таких как голосовые телефонные линии общего пользования. Например, в течение нескольких лет International Flavors and Fragrances использовала DES для защиты своих ценных рецептур, передаваемых по телефону.

Тем временем банковская индустрия, которая является крупнейшим пользователем шифрования за пределами правительства, приняла DES в качестве оптового банковского стандарта. Стандарты для оптовой банковской отрасли устанавливаются Американским национальным институтом стандартов (ANSI). ANSI X3.92, принятый в 1980 году, определил использование алгоритма DES.



1.2 Описание функций, методов, алгоритмов взаимодействия

Функции:

для преобразования десятичного числа в двоичное

для преобразования числа из двоичного в десятичное

для выполнения кругового сдвига влево на 1

для выполнения кругового сдвига влево на 2

для вычисления xor(исключающее или) между двумя строками

для генерации 16 ключей

функция реализации алгоритма

Атрибуты функций:

Таблица PC1

Таблица PC2

Начальная таблица перестановок

Таблица расширения

Массивы для замены

Таблица перестановок

Таблица обратных перестановок

Методы функций:

Перевод обычного текста в двоичный код

Зашифровка блока обычного текста из 64 бит с помощью ключа

Расшифровка блока обычного текста из 64 бит с помощью ключа

Введение нового блока текста и выбор что с ним сделать

Разработка структурной схемы интерфейса



Глава 2. Описание алгоритма шифрования

2.1 Обзор алгоритма DES

DES работает с битами, или двоичными числами - 0 и 1, обычными для цифровых компьютеров. Каждая группа из четырех битов составляет шестнадцатеричное, или базовое 16, число. Двоичное "0001" равно шестнадцатеричному числу "1", двоичное "1000" равно шестнадцатеричному числу "8", "1001" равно шестнадцатеричному числу "9", "1010" равно шестнадцатеричному числу "А", а "1111" равно к шестнадцатеричному числу "F".

DES работает путем шифрования групп из 64 битов сообщений, что соответствует 16 шестнадцатеричным числам. Для выполнения шифрования DES использует "ключи", которые также, по-видимому, имеют длину 16 шестнадцатеричных чисел или, по-видимому, 64 бита. Однако каждый 8-й бит ключа игнорируется в алгоритме DES, так что эффективный размер ключа составляет 56 бит. Но, в любом случае, 64 бита (16 шестнадцатеричных цифр) - это круглое число, на основе которого организован DES.

Например, если мы возьмем сообщение открытого текста "87878787878787" и зашифруем его с помощью ключа DES "0E329232EA6D0D73", мы получим зашифрованный текст "0000000000000000". Если зашифрованный текст расшифровывается с помощью того же секретного ключа DES "0E329232EA6D0D73", результатом будет исходный открытый текст "8787878787878787".

Этот пример аккуратен и упорядочен, потому что наш открытый текст был длиной ровно 64 бита. То же самое было бы верно, если бы открытый текст был кратен 64 битам. Но большинство сообщений не попадут в эту категорию. Они не будут точно кратны 64 битам (то есть точному кратному 16 шестнадцатеричным числам).

Например, возьмите сообщение "Я памятник себе воздвиг нерукотворный."(кавычки не входят в текст самого сообщения). Длина этого открытого текстового сообщения составляет 38 байт (76 шестнадцатеричных цифр). Таким образом, это сообщение должно быть дополнено несколькими дополнительными байтами в конце для шифрования. Как только зашифрованное сообщение было расшифровано, эти дополнительные байты отбрасываются. Конечно, существуют разные схемы заполнения - разные способы добавления дополнительных байтов. Здесь мы просто добавим 0 в конце, чтобы общее сообщение было кратно 8 байтам (или 16 шестнадцатеричным цифрам, или 64 битам).

Начальная перестановка (IP)

Обычный текст разделен на более мелкие фрагменты 64-битного размера. IP выполняется перед первым раундом. Этот этап описывает реализацию процесса транспозиции. Например, 58-й бит заменяет первый бит, 50-й бит заменяет второй бит и так далее. Результирующий 64-битный текст разделяется на две равные половины по 32 бита каждая, называемые левым открытым текстом (LPT) и правым открытым текстом (RPT).

Шаг 1: Ключевая трансформация

Процесс шифрования методом DES использует 56-битный ключ, который получается путем исключения всех битов, присутствующих в каждой 8-й позиции 64-битного ключа. На этом шаге генерируется 48-битный ключ. 56-битный ключ разделен на две равные половины, и в зависимости от количества раундов биты смещаются влево по кругу.

Из-за этого все биты в ключе снова переставляются. Мы можем наблюдать, что некоторые биты удаляются в процессе сдвига, создавая 48-битный ключ. Этот процесс известен как компрессионная перестановка.

Шаг 2: Перестановка расширения

Давайте рассмотрим RPT 32-битного размера, который создается на этапе IP. На этом шаге он расширяется с 32-разрядного до 48-разрядного. RPT 32-битного размера разбивается на 8 блоков по 4 бита в каждом, и к каждому блоку добавляются дополнительные два бита, позже биты переставляются между собой, что приводит к 48-битным данным. Функция XOR применяется между 48-битным ключом, полученным на шаге 1, и 48-битным расширенным RPT.

Разберем более подробно с учетом таблиц.

Процесс шифрования состоит в начальной перестановке, 16 циклах шифрования и конечной перестановке.

Начальная перестановка

Исходный текст T (блок 64 бит) преобразуется c помощью начальной перестановки IP которая определяется таблицей 1:

По таблице первые 3 бита результирующего блока IP(T) после начальной перестановки IP являются битами 58, 50, 42 входного блока Т, а его 3 последние бита являются битами 23, 15, 7 входного блока.

Получение 16 ключей по 48 бит из ключа 56 бит

Ключи kiполучаются из начального ключа k (64 бит = 8 байтов или 8 символов в ASCII) таким образом. Восемь битов, находящих в позициях 8, 16, 24, 32, 40, 48, 56, 64 добавляются в ключ k таким образом, чтобы каждый байт содержал нечетное число единиц. Это используется для обнаружения ошибок при обмене и хранении ключей. Затем делают перестановку для расширенного ключа (кроме добавляемых битов 8, 16, 24, 32, 40, 48, 56, 64). Такая перестановка определена как в таблице 1.



Эта перестановка определяется двумя блоками C0 и D0 по 28 бит каждый. Первые 3 бита C0 есть биты 57, 49, 41 расширенного ключа. А первые три бита D0 есть биты 63, 55, 47 расширенного ключа. Ci,Di i=1,2,3…получаются из Ci?1,Di?1 одним или двумя левыми циклическими сдвигами согласно таблице 2.

Ключ , i=1,…16 состоит из 48 бит, выбранных из битов вектора (56 бит) согласно таблице 3. Первый и второй биты , есть биты 14, 17 вектора .

Описание функции F

В функции F находится вся не линейная часть, осуществляется она с помощью S и P преобразований. Функция представлена на рисунке 2. На вход поступает 32 бита, затем происходит функция расширения Е, которая описана в таблице.



Описание S преобразования

48 бит делится на подблоки по 6 бит (S-box). Функция S преобразует 6 бит в 4 бита. По таблице можно увидеть? как определяется преобразование S.

Преобразования Sjопределяются таблицей 5.



Описание P преобразования.

Перестановка P задана таблицей 6:

Конечная перестановка

Конечная перестановка IP?1 действует на T16 и используется для восстановления позиции. Она является обратной к перестановке IP. Конечная перестановка определяется таблицей 7.

2.2 Логическая схема



Глава 3. Разработка программного кода приложения

Шаги для генерации ключей

В алгоритме предусмотрено 16 раундов шифрования, и для каждого раунда используется свой ключ. Как генерируются ключи, указано ниже.

- Биты помечаются от 1 до 64, начиная с самого значимого бита и переходя к наименее значимому биту.

1. Сожмите и транспонируйте данный 64-разрядный ключ в 48-разрядный ключ, используя следующую таблицу:

// Элементы массива обозначают разрядные числа

int pc1[56] = {

57,49,41,33,25,17,9,

1,58,50,42,34,26,18,

10,2,59,51,43,35,27,

19,11,3,60,52,44,36,

63,55,47,39,31,23,15,

7,62,54,46,38,30,22,

14,6,61,53,45,37,29,

21,13,5,28,20,12,4

};

2. Разделите результат на две равные части: C и D.

3. C и D сдвинуты влево по кругу. Для раундов шифрования 1, 2, 9 и 16 они сдвинуты влево по кругу на 1 бит; для всех остальных раундов они сдвинуты влево по кругу на 2.

4. Результат сжимается до 48 бит в соответствии со следующим правилом: приложение интерфейс шифрование код

int pc2[48] = {

14,17,11,24,1,5,

3,28,15,6,21,10,

23,19,12,4,26,8,

16,7,27,20,13,2,

41,52,31,37,47,55,

30,40,51,45,33,48,

44,49,39,56,34,53,

46,42,50,36,29,32

};

5. Результатом шага 3 являются входные данные для следующего раунда генерации ключа.

Шаги для шифрования

1. Транспонируйте биты в 64-м блоке в соответствии со следующим:

// 58 означает, что 58-й бит следует считать первым битом,

// 50-й бит - вторым битом и так далее.

int initial_permutation_table[64] = {

58,50,42,34,26,18,10,2,

60,52,44,36,28,20,12,4,

62,54,46,38,30,22,14,6,

64,56,48,40,32,24,16,8,

57,49,41,33,25,17,9,1,

59,51,43,35,27,19,11,3,

61,53,45,37,29,21,13,5,

63,55,47,39,31,23,15,7

};

2. Разделите результат на равные части: левый обычный текст (1-32 бита) и правый обычный текст (33-64 бита)

3. Полученные части подвергаются 16 раундам шифрования в каждом раунде.

Правый обычный текст расширяется с помощью следующей таблицы расширения:

// Элементы массива обозначают разрядные числа

int expansion_table[48] = {

32,1,2,3,4,5,4,5,

6,7,8,9,8,9,10,11,

12,13,12,13,14,15,16,17,

16,17,18,19,20,21,20,21,

22,23,24,25,24,25,26,27,

28,29,28,29,30,31,32,1

};

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

5. Результат предыдущего шага разделен на 8 блоков. Каждая коробка содержит 6 битов. После прохождения восьми блоков подстановки каждый блок уменьшается с 6 бит до 4 бит. Первый и последний бит каждого блока обеспечивают индекс строки, а остальные биты обеспечивают индекс столбца. Эти индексы используются для поиска значений в поле подстановки. Поле подстановки состоит из 4 строк, 16 столбцов и содержит числа от 0 до 15.

6. Результат транспонируется в соответствии со следующим правилом:?

// Элементы массива обозначают разрядные числа

int permutation_table[32] = {

16,7,20,21,29,12,28,17,

1,15,23,26,5,18,31,10,

2,8,24,14,32,27,3,9,

19,13,30,6,22,11,4,25

};

7. Увеличьте левую половину с результатом вышеуказанного шага. Сохраните это в правильном обычном тексте.

8. Сохраните исходный правый обычный текст в левом обычном тексте.

9. Эти половины являются входными данными для следующего раунда. Помните, что для каждого раунда существуют разные ключи.

10. После 16 раундов шифрования поменяйте местами левый обычный текст и правый обычный текст.

11. Наконец, примените обратную перестановку (обратную исходной перестановке), и зашифрованный текст будет сгенерирован.

Реализация

1. Генерация ключей.

Алгоритм включает в себя 16 раундов шифрования, причем в каждом раунде используется свой ключ. Таким образом, генерируется 16 ключей.

#include <iostream>

#include <string>

#include <cmath>

using namespace std;

// Массив для хранения 16 ключей string round_keys[16];

// Строка для хранения обычного текста string pt;

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

string convertDecimalToBinary(int decimal)

{

string binary;

while (decimal != 0) {

binary = (decimal % 2 == 0 ? "0" : "1") + binary;

decimal = decimal / 2;

}

while (binary.length() < 4) {

binary = "0" + binary;

}

return binary;

}

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

int convertBinaryToDecimal(string binary)

{

int decimal = 0;

int counter = 0;

int size = binary.length();

for (int i = size - 1; i >= 0; i--)

{

if (binary[i] == '1') {

decimal += pow(2, counter);

}

counter++;

}

return decimal;

}

// Функция для выполнения кругового сдвига влево на 1

string shift_left_once(string key_chunk) {

string shifted = "";

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

shifted += key_chunk[i];

}

shifted += key_chunk[0];

return shifted;

}

// Функция для выполнения кругового сдвига влево на 2

string shift_left_twice(string key_chunk) {

string shifted = "";

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

for (int j = 1; j < 28; j++) {

shifted += key_chunk[j];

}

shifted += key_chunk[0];

key_chunk = shifted;

shifted = "";

}

return key_chunk;

}

// Функция для вычисления xor(исключающее или) между двумя строками

string Xor(string a, string b) {

string result = "";

int size = b.size();

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

if (a[i] != b[i]) {

result += "1";

}

else {

result += "0";

}

}

return result;

}

// Функция для генерации 16 ключей.

void generate_keys(string key) {

// Таблица PC1

int pc1[56] = {

57,49,41,33,25,17,9,

1,58,50,42,34,26,18,

10,2,59,51,43,35,27,

19,11,3,60,52,44,36,

63,55,47,39,31,23,15,

7,62,54,46,38,30,22,

14,6,61,53,45,37,29,

21,13,5,28,20,12,4

};

// Таблица PC2

int pc2[48] = {

14,17,11,24,1,5,

3,28,15,6,21,10,

23,19,12,4,26,8,

16,7,27,20,13,2,

41,52,31,37,47,55,

30,40,51,45,33,48,

44,49,39,56,34,53,

46,42,50,36,29,32

};

// 1. Сжатие ключа с использованием таблицы PC1

string perm_key = "";

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

perm_key += key[pc1[i] - 1];

}

// 2. Разделяем ключ на две равные половины

string left = perm_key.substr(0, 28);

string right = perm_key.substr(28, 28);

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

// 3.1. Для 1, 2, 9, 16 круга ключевые блоки сдвигаются на единицу

if (i == 0 || i == 1 || i == 8 || i == 15) {

left = shift_left_once(left);

right = shift_left_once(right);

}

// 3.2. Для других кругов ключевые блоки сдвигаются на два

else {

left = shift_left_twice(left);

right = shift_left_twice(right);

}

// Объединение двух фрагментов

string combined_key = left + right;

string round_key = "";

// Наконец, используется таблица PC2 для транспонирования ключевых битов

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

round_key += combined_key[pc2[i] - 1];

}

round_keys[i] = round_key;

cout << "Key " << i + 1 << ": " << round_keys[i] << endl;

}

}

int main() {

string key = "10101010101110110000100100011000001001110011"

"01101100110011011101";

generate_keys(key);

2. Шифрование обычного текста для получения зашифрованного текста

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

#include <iostream>

#include <string>

#include <cmath>

using namespace std;

// Массив для хранения 16 ключей

string round_keys[16];

// Строка для хранения обычного текста

string pt;

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

string convertDecimalToBinary(int decimal)

{

string binary;

while (decimal != 0) {

binary = (decimal % 2 == 0 ? "0" : "1") + binary;

decimal = decimal / 2;

}

while (binary.length() < 4) {

binary = "0" + binary;

}

return binary;

}

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

int convertBinaryToDecimal(string binary)

{

int decimal = 0;

int counter = 0;

int size = binary.length();

for (int i = size - 1; i >= 0; i--)

{

if (binary[i] == '1') {

decimal += pow(2, counter);

}

counter++;

}

return decimal;

}

// Функция для выполнения кругового сдвига влево на 1

string shift_left_once(string key_chunk) {

string shifted = "";

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

shifted += key_chunk[i];

}

shifted += key_chunk[0];

return shifted;

}

// Функция для выполнения кругового сдвига влево на 2

string shift_left_twice(string key_chunk) {

string shifted = "";

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

for (int j = 1; j < 28; j++) {

shifted += key_chunk[j];

}

shifted += key_chunk[0];

key_chunk = shifted;

shifted = "";

}

return key_chunk;

}

// Функция для вычисления xor(исключающее или) между двумя строками

string Xor(string a, string b) {

string result = "";

int size = b.size();

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

if (a[i] != b[i]) {

result += "1";

}

else {

result += "0";

}

}

return result;

}

// Функция для генерации 16 ключей.

void generate_keys(string key) {

// Таблица PC1

int pc1[56] = {

57,49,41,33,25,17,9,

1,58,50,42,34,26,18,

10,2,59,51,43,35,27,

19,11,3,60,52,44,36,

63,55,47,39,31,23,15,

7,62,54,46,38,30,22,

14,6,61,53,45,37,29,

21,13,5,28,20,12,4

};

// Таблица PC2

int pc2[48] = {

14,17,11,24,1,5,

3,28,15,6,21,10,

23,19,12,4,26,8,

16,7,27,20,13,2,

41,52,31,37,47,55,

30,40,51,45,33,48,

44,49,39,56,34,53,

46,42,50,36,29,32

};

// 1. Сжатие ключа с использованием таблицы PC1

string perm_key = "";

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

perm_key += key[pc1[i] - 1];

}

// 2. Разделяем ключ на две равные половины

string left = perm_key.substr(0, 28);

string right = perm_key.substr(28, 28);

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

// 3.1. Для 1, 2, 9, 16 круга ключевые блоки сдвигаются на единицу

if (i == 0 || i == 1 || i == 8 || i == 15) {

left = shift_left_once(left);

right = shift_left_once(right);

}

// 3.2. Для других кругов ключевые блоки сдвигаются на два

else {

left = shift_left_twice(left);

right = shift_left_twice(right);

}

// Объединение двух фрагментов

string combined_key = left + right;

string round_key = "";

// Наконец, используется таблица PC2 для транспонирования ключевых битов

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

round_key += combined_key[pc2[i] - 1];

}

round_keys[i] = round_key;

}

}

// Реализация алгоритма

string DES() {

// Начальная таблица перестановок

int initial_permutation[64] = {

58,50,42,34,26,18,10,2,

60,52,44,36,28,20,12,4,

62,54,46,38,30,22,14,6,

64,56,48,40,32,24,16,8,

57,49,41,33,25,17,9,1,

59,51,43,35,27,19,11,3,

61,53,45,37,29,21,13,5,

63,55,47,39,31,23,15,7

};

// Таблица расширения

int expansion_table[48] = {

32,1,2,3,4,5,4,5,

6,7,8,9,8,9,10,11,

12,13,12,13,14,15,16,17,

16,17,18,19,20,21,20,21,

22,23,24,25,24,25,26,27,

28,29,28,29,30,31,32,1

};

// Массивы для замены. Он должен содержать значения от 0 до 15 в любом порядке.

int substition_boxes[8][4][16] =

{ {

14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,

0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,

4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,

15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13

},

{

15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,

3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,

0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,

13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9

},

{

10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,

13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,

13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,

1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12

},

{

7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,

13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,

10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,

3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14

},

{

2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,

14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,

4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,

11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3

},

{

12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,

10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,

9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,

4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13

},

{

4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,

13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,

1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,

6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12

},

{

13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,

1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,

7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,

2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11

} };

// Таблица перестановок

int permutation_tab[32] = {

16,7,20,21,29,12,28,17,

1,15,23,26,5,18,31,10,

2,8,24,14,32,27,3,9,

19,13,30,6,22,11,4,25

};

// Таблица обратных перестановок

int inverse_permutation[64] = {

40,8,48,16,56,24,64,32,

39,7,47,15,55,23,63,31,

38,6,46,14,54,22,62,30,

37,5,45,13,53,21,61,29,

36,4,44,12,52,20,60,28,

35,3,43,11,51,19,59,27,

34,2,42,10,50,18,58,26,

33,1,41,9,49,17,57,25

};

//1. Применение начальной перестановки

string perm = "";

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

perm += pt[initial_permutation[i] - 1];

}

// 2. Разделяем результат на две равные половины

string left = perm.substr(0, 32);

string right = perm.substr(32, 32);

// Обычный текст зашифрован 16 раз

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

string right_expanded = "";

// 3.1. Правая половина обычного текста развернута

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

right_expanded += right[expansion_table[i] - 1];

}; // 3.3. Результат фиксируется с помощью ключа

string xored = Xor(round_keys[i], right_expanded);

string res = "";

// 3.4. Результат делится на 8 равных частей

// и пропускается через 8 ячеек для замены.

// После прохождения через блок подстановки

// каждый блок уменьшается с 6 до 4 бит.

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

// Поиск индексов строк и столбцов для поиска в поле подстановки

string row1 = xored.substr(i * 6, 1) + xored.substr(i * 6 + 5, 1);

int row = convertBinaryToDecimal(row1);

string col1 = xored.substr(i * 6 + 1, 1) + xored.substr(i * 6 + 2, 1) + xored.substr(i * 6 + 3, 1) + xored.substr(i * 6 + 4, 1);;

int col = convertBinaryToDecimal(col1);

int val = substition_boxes[i][row][col];

res += convertDecimalToBinary(val);

}

// 3.5. Применяется другая перестановка

string perm2 = "";

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

perm2 += res[permutation_tab[i] - 1];

}

// 3.6. Результат фиксируется с левой половиной

xored = Xor(perm2, left);

// 3.7. Левая и правая части обычного текста меняются местами

left = xored;

if (i < 15) {

string temp = right;

right = xored;

left = temp;

}

}

// 4. Применяются половинки обычного текста

string combined_text = left + right;

string ciphertext = "";

// Применяется обратная исходной перестановке

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

ciphertext += combined_text[inverse_permutation[i] - 1];

}

// И мы, наконец, получаем зашифрованный текст

return ciphertext;

}

int main() {

// 64-битный ключ

string key = "1010101010111011000010010001100000100111001101101100110011011101";

// Блок обычного текста из 64 бит

pt = "1010101111001101111001101010101111001101000100110010010100110110";

// Вызов функции для генерации 16 ключей

generate_keys(key);

cout << "Plain text: " << pt << endl;

// Применение алгоритма

string ct = DES();

cout << "Ciphertext: " << ct << endl;

}



Вывод

Шаги для расшифровки. Порядок 16 48-битных ключей меняется на противоположный таким образом, что ключ 16 становится ключом 1, и так далее. Затем к зашифрованному тексту применяются шаги для шифрования.

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