МИНОБРНАУКИ РОССИИ
Ф
едеральное
государственное бюджетное образовательное
учреждение высшего образования
НИЖЕГОРОДСКИЙ ГОСУДАРСТВЕННЫЙ ТЕХНИЧЕСКИЙ
УНИВЕРСИТЕТ им. Р.Е.АЛЕКСЕЕВА
Институт радиоэлектроники и информационных технологий
Кафедра информатики и систем управления
ОТЧЕТ по лабораторной работе №3
Алгоритм блочного шифрования, определенный в ГОСТ Р 34.12-2015: «Кузнечик».
по дисциплине
Методы и средства защиты информации
(наименование дисциплины)
РУКОВОДИТЕЛЬ:
________________ Жуков М. С.
(подпись) (фамилия, и.,о.)
СТУДЕНТ:
________________ Какушкина О.В.
(подпись) (фамилия, и.,о.)
23-ИСТ-1-1
(шифр группы)
Работа защищена «___» ____________
С оценкой ________________________
Нижний Новгород 2025
Текст задания №3:
Реализовать алгоритм блочного шифрования, определенный в ГОСТ Р 34.12-2015: «Кузнечик».
Описание алгоритма (алгоритм блочного шифрования, определенный в ГОСТ Р 34.12-2015: «Кузнечик».):
Данная программа реализует алгоритм блочного шифрования, похожий на российский стандарт ГОСТ "Кузнечик" (ГОСТ Р 34.12-2015), с использованием режима шифрования CTR (Counter Mode).
Основные компоненты алгоритма
1. Типы данных
Block - 16-байтовый массив (128 бит) для представления блоков данных
Key - 16-байтовый массив для представления ключей шифрования
2. Основные преобразования
S-преобразование (Substitution)
Замена каждого байта блока согласно таблице замен (S-блок)
Используется прямой S-блок (S_BOX) для шифрования
L-преобразование (Linear)
Линейное преобразование, выполняющее умножение в поле Галуа
Использует константный вектор L_VECTOR
Выполняет 16 раундов преобразования
R-преобразование
Обратное линейное преобразование, используется для генерации ключей
Умножение в поле Галуа
Реализует умножение байтов по модулю неприводимого многочлена 0xC3
3. Генерация раундовых ключей
Генерируются 10 констант C[i] путем S- и L-преобразований
Первый ключ получается S- и L-преобразованием мастер-ключа
Последующие ключи получаются XOR предыдущего ключа с константой C[i-1] и последующим S- и L-преобразованием
4. Процесс шифрования (10 раундов)
Первый раунд: XOR блока с первым ключом
Основные 8 раундов (2-9):
S-преобразование
L-преобразование
XOR с раундовым ключом
Последний раунд (10):
Только S-преобразование
XOR с последним ключом
5. Режим шифрования ctr (Counter Mode)
Использует счетчик (nonce + инкремент) для генерации ключевого потока
Каждый блок счетчика шифруется основным алгоритмом
Результат XOR-ится с блоком открытого текста
Счетчик увеличивается для каждого следующего блока
#include <iostream>
#include <vector>
#include <array>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
typedef array<uint8_t, 16> Block;
typedef array<uint8_t, 16> Key;
// Константы алгоритма
const uint8_t L_VECTOR[16] = {
0x94, 0x20, 0x85, 0x10, 0xC2, 0xC0, 0x01, 0xFB,
0x01, 0xC0, 0xC2, 0x10, 0x85, 0x20, 0x94, 0x01
};
// Прямая таблица замен (S-блок)
const uint8_t S_BOX[256] = {
0xFC, 0xEE, 0xDD, 0x11, 0xCF, 0x6E, 0x31, 0x16, 0xFB, 0xC4, 0xFA, 0xDA, 0x23, 0xC5, 0x04, 0x4D,
0xE9, 0x77, 0xF0, 0xDB, 0x93, 0x2E, 0x99, 0xBA, 0x17, 0x36, 0xF1, 0xBB, 0x14, 0xCD, 0x5F, 0xC1,
0xF9, 0x18, 0x65, 0x5A, 0xE2, 0x5C, 0xEF, 0x21, 0x81, 0x1C, 0x3C, 0x42, 0x8B, 0x01, 0x35, 0xE2,
0xC8, 0x82, 0xE6, 0x0E, 0x86, 0xC5, 0x71, 0xDD, 0x2E, 0x69, 0xEF, 0x12, 0x9D, 0x38, 0x25, 0x7B,
0xFD, 0xF8, 0x16, 0xB3, 0x53, 0xEC, 0x84, 0x11, 0x69, 0x50, 0x2E, 0x45, 0x4A, 0x65, 0xBD, 0xCB,
0x4C, 0x63, 0x98, 0x32, 0x29, 0xB4, 0x1A, 0x3C, 0x92, 0x6B, 0x47, 0x19, 0xCA, 0x34, 0x92, 0xAA,
0x60, 0x74, 0x4E, 0x46, 0x42, 0x27, 0x0A, 0xDC, 0xD4, 0x9A, 0x05, 0x5B, 0x7D, 0xB9, 0x07, 0x2F,
0xD3, 0xA7, 0x8B, 0x62, 0x60, 0xE9, 0x2D, 0x13, 0xCE, 0xB0, 0x6C, 0x4B, 0x61, 0x0E, 0x55, 0xE7,
0x2F, 0x8D, 0x19, 0xAC, 0x6D, 0x5B, 0x30, 0xF5, 0x89, 0xE8, 0xC3, 0x3B, 0x70, 0x6A, 0x66, 0x48,
0x97, 0x9E, 0xA1, 0x51, 0xFE, 0x20, 0xB2, 0xC6, 0xBC, 0x02, 0x79, 0xE1, 0xBE, 0x5D, 0x37, 0x08,
0x75, 0x45, 0x49, 0x68, 0xD5, 0x27, 0xF6, 0x75, 0x4F, 0x70, 0x9A, 0x27, 0xA0, 0x40, 0x59, 0x8F,
0x51, 0x5E, 0x22, 0xEA, 0xBD, 0x55, 0x2F, 0x4A, 0x1D, 0x15, 0xCC, 0x1A, 0x73, 0x6C, 0xC9, 0x57,
0x41, 0x53, 0x43, 0xC7, 0xD9, 0x49, 0x64, 0xF3, 0x28, 0xD2, 0xDF, 0x7C, 0x8D, 0xD8, 0x12, 0x80,
0xEB, 0x26, 0x52, 0x33, 0x5D, 0xDE, 0x22, 0x6F, 0x1F, 0x89, 0x7E, 0x2A, 0x0F, 0x91, 0x88, 0x3D,
0x9A, 0x08, 0x15, 0x4E, 0x07, 0x03, 0xA6, 0xE5, 0x06, 0x0B, 0xF2, 0x5E, 0x75, 0x52, 0x3A, 0xD7,
0x6A, 0xD6, 0x3B, 0xA9, 0x24, 0x7C, 0xE3, 0x09, 0xAD, 0x62, 0xAC, 0xD0, 0x7F, 0xD1, 0xC8, 0x6E
};
// Обратная таблица замен (обратный S-блок)
const uint8_t INV_S_BOX[256] = {
0xA5, 0x2D, 0x32, 0x8F, 0x0E, 0x30, 0x38, 0xC0, 0x54, 0xE6, 0x9E, 0x39, 0x55, 0x7E, 0x52, 0x91,
0x64, 0x03, 0x57, 0x5A, 0x1C, 0x60, 0x07, 0x18, 0x21, 0x72, 0xA8, 0xD1, 0x29, 0xC6, 0xA4, 0x3F,
0xE0, 0x27, 0x8D, 0x0C, 0x82, 0xEA, 0xAE, 0xB4, 0x9A, 0x63, 0x49, 0xE5, 0x42, 0xE4, 0x15, 0xB7,
0xC8, 0x06, 0x70, 0x9D, 0x41, 0x75, 0x19, 0xC9, 0xAA, 0xFC, 0x4D, 0xBF, 0x2A, 0x73, 0x84, 0xD5,
0xC3, 0xAF, 0x2B, 0x86, 0xA7, 0xB1, 0xB2, 0x5B, 0x46, 0xD3, 0x9F, 0xFD, 0xD4, 0x0F, 0x9C, 0x2F,
0x9B, 0x43, 0xEF, 0xD9, 0x79, 0xB6, 0x53, 0x7F, 0xC1, 0xF0, 0x23, 0xE7, 0x25, 0x5E, 0xB5, 0x1E,
0xA2, 0xDF, 0xA6, 0xFE, 0xAC, 0x22, 0xF9, 0xE2, 0x4A, 0xBC, 0x35, 0xCA, 0xEE, 0x78, 0x05, 0x6B,
0x51, 0xE1, 0x59, 0xA3, 0xF2, 0x71, 0x56, 0x11, 0x6A, 0x89, 0x94, 0x65, 0x8C, 0xBB, 0x77, 0x3C,
0x7B, 0x28, 0xAB, 0xD2, 0x31, 0xDE, 0xC4, 0x5F, 0xCC, 0x5D, 0x0A, 0xDC, 0x37, 0x6D, 0x34, 0xF6,
0xB9, 0x0D, 0x62, 0x87, 0x44, 0x1D, 0x4E, 0xB0, 0x16, 0xED, 0x95, 0xAD, 0xCE, 0x4C, 0xFB, 0x02,
0x7D, 0xE3, 0x10, 0x67, 0xD8, 0x47, 0x3D, 0x58, 0x2E, 0xCB, 0x6F, 0xF7, 0x88, 0x8B, 0x8E, 0x17,
0xDB, 0x66, 0x90, 0xD0, 0x7A, 0xF8, 0xEB, 0x08, 0x93, 0x3B, 0x5C, 0x13, 0x96, 0x2C, 0x33, 0x24,
0x1B, 0x20, 0x04, 0x01, 0x61, 0x99, 0x4B, 0x9D, 0x97, 0x7C, 0xCD, 0x5B, 0x26, 0x83, 0x36, 0xBE,
0x3A, 0x40, 0x68, 0xFF, 0x0B, 0x50, 0xDA, 0x1F, 0x4F, 0xBA, 0xC7, 0x45, 0x3E, 0x69, 0xEC, 0xC2,
0xE8, 0xA1, 0x85, 0xA0, 0x6E, 0x6C, 0x67, 0x92, 0x12, 0x14, 0x8A, 0x48, 0x00, 0xF3, 0xBD, 0xB3,
0xC5, 0x09, 0x3D, 0x1A, 0x98, 0xF4, 0xDD, 0xE9, 0x80, 0xA9, 0xF5, 0x76, 0xB8, 0x2C, 0x81, 0xD6
};
// Умножение в поле Галуа
uint8_t multiply_galois(uint8_t a, uint8_t b) {
uint8_t p = 0;
while (b) {
if (b & 1) p ^= a;
bool hi_bit_set = (a & 0x80);
a <<= 1;
if (hi_bit_set) a ^= 0xC3;
b >>= 1;
}
return p;
}
// S-преобразование
Block s_transform(const Block& input, const uint8_t* s_box = S_BOX) {
Block output;
for (int i = 0; i < 16; ++i) {
output[i] = s_box[input[i]];
}
return output;
}
// L-преобразование
Block l_transform(const Block& input) {
Block temp = input;
for (int round = 0; round < 16; ++round) {
uint8_t sum = 0;
for (int i = 0; i < 16; ++i) {
sum ^= multiply_galois(temp[i], L_VECTOR[i]);
}
for (int i = 15; i > 0; --i) {
temp[i] = temp[i - 1];
}
temp[0] = sum;
}
return temp;
}
Block r_transform(const Block& input) {
Block temp = input;
for (int round = 0; round < 16; ++round) {
uint8_t last = temp[15];
for (int i = 0; i < 15; ++i) {
temp[i + 1] = temp[i];
}
temp[0] = 0;
for (int i = 0; i < 16; ++i) {
temp[i] ^= multiply_galois(last, L_VECTOR[i]);
}
}
return temp;
}
Block xor_blocks(const Block& a, const Block& b) {
Block result;
for (int i = 0; i < 16; ++i) {
result[i] = a[i] ^ b[i];
}
return result;
}
vector<Key> generate_keys(const Key& master_key) {
vector<Key> round_keys(10);
Block C[10];
// Генерация констант C
for (int i = 0; i < 10; ++i) {
C[i] = { 0 };
C[i][15] = i + 1;
C[i] = l_transform(s_transform(C[i]));
}
// Первый ключ
round_keys[0] = l_transform(s_transform(master_key));
// Генерация остальных ключей
for (int i = 1; i < 10; ++i) {
round_keys[i] = xor_blocks(round_keys[i - 1], C[i - 1]);
round_keys[i] = l_transform(s_transform(round_keys[i]));
}
return round_keys;
}
// Явная реализация 10 раундов шифрования
Block encrypt_block(const Block& plaintext, const vector<Key>& round_keys) {
Block state = plaintext;
// 1-й раунд: XOR с ключом
for (int j = 0; j < 16; ++j) {
state[j] ^= round_keys[0][j]; // Первый раунд
}
// Основные 8 раунда (2-9)
for (int i = 1; i < 9; ++i) { // с 1 до 8, всего 8 раундов
state = s_transform(state); // S-преобразование
state = l_transform(state); // L-преобразование
for (int j = 0; j < 16; ++j) {
state[j] ^= round_keys[i][j]; // XOR с ключом
}
}
// 10-й раунд (последний)
state = s_transform(state); // S-преобразование
for (int j = 0; j < 16; ++j) {
state[j] ^= round_keys[9][j]; // XOR с последним ключом
}
return state;
}
// Шифрование в режиме CTR
vector<Block> encrypt_ctr(const vector<Block>& plaintext, const vector<Key>& round_keys, const Block& nonce) {
vector<Block> ciphertext;
Block counter = nonce;
for (const auto& block : plaintext) {
Block encrypted_counter = encrypt_block(counter, round_keys);
Block result;
for (int i = 0; i < 16; ++i) {
result[i] = block[i] ^ encrypted_counter[i];
}
ciphertext.push_back(result);
// Увеличиваем счетчик
for (int i = 15; i >= 0; --i) {
if (++counter[i] != 0) break;
}
}
return ciphertext;
}
// Для строки в блоки
vector<Block> string_to_blocks(const string& str) {
vector<Block> blocks;
size_t len = str.size();
size_t num_blocks = (len + 15) / 16;
for (size_t i = 0; i < num_blocks; ++i) {
Block block = { 0 };
size_t start = i * 16;
size_t end = min(start + 16, len);
for (size_t j = start; j < end; ++j) {
block[j - start] = static_cast<uint8_t>(str[j]);
}
blocks.push_back(block);
}
return blocks;
}
// Блоки в строку
string blocks_to_string(const vector<Block>& blocks) {
string str;
for (const auto& block : blocks) {
for (uint8_t byte : block) {
if (byte == 0) continue; // Пропускаем нулевые байты дополнения
str += static_cast<char>(byte);
}
}
return str;
}
// Вывод блоков в hex
void print_blocks(const vector<Block>& blocks, const string& title) {
cout << title << " (" << blocks.size() << " blocks):" << endl;
for (const auto& block : blocks) {
for (uint8_t byte : block) {
printf("%02x ", byte);
}
cout << endl;
}
cout << endl;
}
int main() {
setlocale(LC_ALL, "Russian");
// Исходные данные
string message = "Нижегородский государственный технический университет Какушкина Ольга Витальевна";
Key key = { 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
Block nonce = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
// Генерация ключей
auto round_keys = generate_keys(key);
// Преобразование строки в блоки
auto plaintext_blocks = string_to_blocks(message);
cout << "Исходное сообщение: " << message << endl << endl;
print_blocks(plaintext_blocks, "Исходные блоки");
// Шифрование в режиме CTR
auto ctr_ciphertext = encrypt_ctr(plaintext_blocks, round_keys, nonce);
print_blocks(ctr_ciphertext, "CTR - Зашифрованные блоки");
// Расшифрование CTR (то же самое что и шифрование, используя тот же ключ и nonce)
auto ctr_decrypted = encrypt_ctr(ctr_ciphertext, round_keys, nonce);
string ctr_decrypted_message = blocks_to_string(ctr_decrypted);
cout << "CTR - Расшифрованное сообщение: " << ctr_decrypted_message << endl;
return 0;
}
Вывод программы
Вывод:
В ходе лабораторной работы я работала с алгоритмом блочного шифрования, определенный в ГОСТ Р 34.12-2015: «Кузнечик». Научилась шифровать и расшифровывать текст данным методом.