Х-Лаба: реализация криптографического алгоритма AES

Задание: разработать библиотеку классов, реализующих криптографический алгоритм
AES (Advanced Encryption Standard). Предусмотреть следующие варианты шифровки/дешифровки:

а) шифрация данных из файла в файл;
б) дешифрация данных из файла в файл;
в) дешифрация данных из файла в память.

Ключ шифрования должен задаваться строкой, содержащей последовательность шестнадцатеричных цифр. Длина ключа - 128, 192 или 256 бит.

Введение в проблему

Advanced Encryption Standard (AES), также известный как
RIJNDAEL, — это симметричный алгоритм блочного шифрования (размер блока - 128 бит, ключ - 128/192/256 бит), выбранный в ходе конкурса и принятый в качестве американского стандарта шифрования правительством США. Выбор был сделан с расчетом на повсеместное использование и активный анализ алгоритма, как это было с его предшественником
DES. Государственный институт стандартов и технологий США (National Institute of Standards and Technology, NIST), после пятилетней подготовки, 26 ноября 2001 года опубликовал предварительную
спецификацию AES, а 26 мая 2002 года AES был объявлен стандартом. По состоянию на 2006 год
AES является одним из самых распространенных алгоритмов симметричного шифрования в мире.

История AES

В далеком 1998 году NIST объявил конкурс на создание алгоритма, удовлетворяющего выдвинутым институтом требованиям. Он опубликовал все несекретные данные о тестировании кандидатов на роль
AES и потребовал от авторов алгоритмов сообщить о базовых принципах построения используемых в них констант. В отличие от ситуации с DES, NIST при выборе
AES не стал опираться на секретные и, как следствие, запрещенные к публикации данные об исследовании алгоритмов-кандидатов.

Чтобы быть утвержденным в качестве стандарта, алгоритм должен был:

1. реализовать шифрование частным ключом;
2. представлять собой блочный шифр;
3. работать со 128-разрядными блоками данных и ключами трех размеров (128, 192 и 256 разрядов).

Дополнительно кандидатам рекомендовалось:

1. использовать операции, легко реализуемые как аппаратно (в микрочипах), так и программно (на персональных компьютерах и серверах);
2. ориентироваться на 32-разрядные процессоры;
3. не усложнять без необходимости структуру шифра для того, чтобы все заинтересованные стороны были в состоянии самостоятельно провести независимый криптоанализ алгоритма и убедиться, что в нем не заложено каких-либо недокументированных возможностей.

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

Перед первым туром конкурса в NIST поступило 21 предложение, 15 из которых соответствовали выдвинутым критериям. Затем были проведены исследования этих решений, в том числе связанные с дешифровкой и проверкой производительности, и получены экспертные оценки специалистов по криптографии. В августе 1999 года NIST объявил пять финалистов, которые получили право на участие во втором этапе обсуждений.
2 октября 2000 года NIST сообщил о своем выборе – победителем конкурса стал алгоритм
RIJNDAEL (произносится как «райндол») бельгийских криптографов
Винсента Раймана и Йоана Дамана, который зарегистрирован в качестве официального федерального стандарта как
FIPS 197 (Federal Information Processing Standard).

Для меня остается загадкой, зачем в российском вузе преподают стандарты иностранных государств. Видимо, исходят из принципа, что врага надо знать в лицо :). Ладно, в общем-то, это не наше дело. Нам надо просто программно реализовать основу национальной безопасности США.

Начало работы

Итак, приступим. Так как по заданию нам надо было разработать библиотеку классов, то начнем с описания этих классов, то есть с заголовочных файлов. Наш класс будет иметь три метода, которые реализуют основные операции, перечисленные в задании: encryptFile - шифрация данных из файла в файл, DecryptToFile - дешифрация данных из файла в файл, DecryptToMemory - дешифрация данных из файла в память. Собственно, в заголовочном файле нет ничего особенного, поэтому просто приведу его листинг с комментариями (смотри листинг 1).

<br /> #pragma once<br /> #include <string></p> <p>#define BLOCK_LEN 16</p> <p>class CAes<br /> {<br /> public:<br /> CAes(void);<br /> ~CAes(void);</p> <p> /*! \brief Расшифровывает файл в память<br /> * Определяет размер файла и выделяет память в buffer<br /> * \return Число расшифрованных байт или число <= 0, в случае ошибки<br /> */<br /> static int DecryptToMemory(std::string fileName, std::string key, unsigned char* &buffer);</p> <p> /* \brief Создает файл outFileName и записывает в него зашифрованное содержимое inFileName<br /> * \return Число зашифрованных байт<br /> */<br /> static int encryptFile(std::string inFileName, std::string outFileName, std::string key);</p> <p> /* \brief Расшифровывает из файла в файл<br /> * \return Число расшифрованных байт<br /> */<br /> static int DecryptToFile(std::string inFileName, std::string outFileName, std::string key);<br /> };<br />

Как видно из листинга, мы определяем всего три вышеперечисленных метода и конструктор с деструктором. Теперь займемся реализацией этих методов.

Вспомогательный код

Прежде чем приступить непосредственно к выполнению трех основных пунктов задания, надо подготовиться, то есть написать пару вспомогательных функций и подключить несколько заголовочных файлов. Эти файлы мы нашли в интернете, ведь ты не думал, что мы будем с нуля реализовывать криптографический госстандарт США. В этих файлах содержится куча полезных структур и алгоритмов, которые позволяют заниматься разработкой непосредственно класса, а не вникать в сложную
математику AES. В большинстве случаев преподаватели сами предоставляют подобные куски кода, чтобы облегчить и без того тяжелую жизнь студента. Все эти файлы ты найдешь (а при желании и детально ознакомишься с их содержанием) на нашем
DVD.

Взглянем на листинг. Там как раз описаны две наши вспомогательные функции и один макрос.

<br /> // Для шифрования<br /> void cycles(volatile unsigned __int64 *rtn)<br /> {<br /> #if defined(_MSC_VER)<br /> __asm // считываем Pentium Time Stamp Counter<br /> { cpuid<br /> rdtsc<br /> mov ecx,rtn<br /> mov [ecx],eax<br /> mov [ecx+4],edx<br /> cpuid<br /> }<br /> #else<br /> #include <time.h><br /> time_t tt;<br /> tt = time(NULL);<br /> ((unsigned long*)rtn)[0] = tt;<br /> ((unsigned long*)rtn)[1] = tt & -36969l;<br /> return;<br /> #endif<br /> }<br /> #define RAND(a,b) (((a = 36969 * (a & 65535) + (a >> 16)) << 16) + \<br /> (b = 18000 * (b & 65535) + (b >> 16)))</p> <p>void FillRand(char *buf, const int len)<br /> {<br /> static unsigned long a[2], mt = 1, count = 4;<br /> static char r[4];<br /> int i;</p> <p> if(mt) { mt = 0; cycles((unsigned __int64 *)a); }</p> <p> for(i = 0; i < len; ++i)<br /> {<br /> if(count == 4)<br /> {<br /> *(unsigned long*)r = RAND(a[0], a[1]);<br /> count = 0;<br /> }</p> <p> buf[i] = r[count++];<br /> }<br /> }<br />

Все это хозяйство служит для заполнения массива псевдослучайных чисел. Непосредственно же заполнением занимается эта функция:

void FillRand(char *buf, const int len)

Как ее использовать, ты узнаешь чуть позже. Макрос RAND(a,b) вычисляет псевдослучайное число, а функция cycles считывает число из таймера процессора. Все это войдет в cpp-файл с реализацией класса. Также нам надо включить еще три заголовочных файла:

#include "caes.h"
#include "aes.h"
#include <stdio.h>

Здесь, caes.h описывает наш класс; aes.h – один из тех файлов, что мы нашли в интернете; stdio.h - говорить стыдно, все и так должны знать, что это стандартный ввод/вывод в
C.

Шифрование файла

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

int encryptFile(std::string inFileName, std::string outFileName, std::string
secretKey)

Содержимое из файла inFileName будет шифроваться ключом secretKey и записываться в файл outFileName. Код этой функции частично представлен в листинге.

<br /> int CAes::encryptFile(std::string inFileName, std::string outFileName, std::string secretKey)<br /> {<br /> gen_tabs();</p> <p> unsigned long i = 0;<br /> int by = 0, key_len, err = 0;<br /> const char* cKey = secretKey.c_str();<br /> char ch,key[32];</p> <p> const char* cp = &cKey[0]; // указатель на символ в key</p> <p> i = 0; // счетчик обработанных цифр</p> <p> while(i < 64 && *cp) // максимальная длина ключа - 32 байта и,<br /> { // следовательно, максимум 64 шестнадцатеричные цифры<br /> ch = toupper(*cp++);<br /> if(ch >= '0' && ch <= '9')<br /> by = (by << 4) + ch - '0';<br /> else if(ch >= 'A' && ch <= 'F')<br /> by = (by << 4) + ch - 'A' + 10;<br /> else // ошибка, если символ не шестнадцатеричная цифра<br /> return -2;</p> <p> // запоминаем байт ключа для каждой пары шестнадцатеричных цифр<br /> if(i++ & 1)<br /> key[i / 2 - 1] = by & 0xff;<br /> }</p> <p> if(*cp)<br /> return -3;<br /> else<br /> if(i < 32 || (i & 15))<br /> return -4;</p> <p> key_len = i / 2;</p> <p> int encrypted = 0;</p> <p> FILE* inFile = fopen(inFileName.c_str(), "rb");<br /> if (!inFile)<br /> return -5;</p> <p> FILE* outFile = fopen(outFileName.c_str(), "wb");</p> <p> if (!outFile)<br /> return -5;</p> <p> aes_encrypt_ctx ctx[1];</p> <p> aes_encrypt_key((unsigned char*)key, key_len, ctx);</p> <p> /* далее идет непосредственно алгоритм шифрования; в этом листинге он опускается по причине громоздкости; полную версию функции можно увидеть на диске, прилагаемом к журналу, в файле caes.cpp */</p> <p> // закрываем файлы, чтобы сохранить информацию в них<br /> fclose(inFile);<br /> fclose(outFile);<br /> return 0;<br /> }

Весь код, к сожалению, мы привести не можем, поскольку он занял бы значительный объем статьи; полностью ты найдешь его только
на нашем диске. 

Здесь первым делом мы объявляем и инициализируем несколько переменных. Затем в цикле проверяем корректность введенного ключа, а поскольку передается он в функцию в виде строки, то должен содержать лишь цифры от 0 до 9 и латинские буквы от A до F. Кроме этого, дополнительно мы проверяем длину ключа. После этого открываем входной и выходной файлы и проводим предварительную инициализацию нужных нам структур. Далее в листинге должен идти код шифрования, но, как мы уже говорили, он опущен. Вот и все, главное - после шифрации не забыть корректно закрыть файлы, чтобы сохранить все изменения.

Дешифрация из файла в память

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

int DecryptToMemory(std::string fileName, std::string secretKey, unsigned char* &buffer)

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

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

int DecryptToFile(std::string inFileName, std::string outFileName, std::string key)

Содержимое inFileName расшифровывается ключом key и записывается в файл outFileName. Полный код этой функции можно увидеть в листинге.

<br /> int CAes::DecryptToFile(std::string inFileName, std::string outFileName, std::string key)<br /> {<br /> unsigned char* buffer;<br /> int decrypted = DecryptToMemory(inFileName, key, buffer);<br /> if (decrypted > 0)<br /> {<br /> FILE* outFile = fopen(outFileName.c_str(), "wb");<br /> if (outFile)<br /> {<br /> fwrite(buffer, sizeof(unsigned char), decrypted, outFile);<br /> fclose(outFile);<br /> }<br /> delete buffer;<br /> }<br /> return decrypted;<br /> }

Для начала мы объявляем указатель на unsigned char. Затем с помощью реализованной выше функции DecryptToMemory расшифровываем содержимое файла в память. Если все прошло успешно, то записываем участок памяти, на который ссылается переменная buffer, в файл outFileName и удаляем память, выделенную функцей
DecryptToMemory.

Проверка работы

И в заключение напишем маленькую программку, которая будет шифровать/дешифровать файлы. Для этого нам понадобится консольный проект (я использовал Visual Studio 2003). Включим в проект файлы нашего недавно созданного класса и то, что мы скачали из интернета (aes.h, aeskey.c, aescrypt.c, aesopt.h, aestab.c, aestab.h). Проект мы назвали AES_demo, а потому и главный cpp-файл называется aes_demo.cpp. В нем мы подключим caes.h и определим 256-битный ключ шифрования.

#include "caes.h"

#define RESCRYPTO_KEY "1fe2daD67821f83092bbceeadf821fe0923ed923edfe98df98acD6238119faed"

Чтобы зашифровать какой-либо файл, надо запустить программу со следующими параметрами:

AES_demo.exe /encrypt not_crypt_file.txt crypt_file.txt

После такого вызова в crypt_file.txt мы увидим зашифрованное содержимое not_crypt_file.txt. Для дешифровки надо вбить в командную строку следующее:

AES_demo.exe /decrypt crypt_file.txt decrypt_file.txt

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

Вот и все. Конечно, для сдачи лабы одной программы недостаточно - надо уметь еще и объяснить, что ты написал. Но если бы мы начали здесь объяснять
алгоритм AES, на это ушел бы весь объем журнала. Советуем поискать тебе инфу в интернете, благо там ее предостаточно. Например, вот эта ссылка кратко описывает основные моменты, правда, на английском языке:
http://en.wikipedia.org/wiki/Advanced_Encryption_Standard. В общем, удачи, не прогуливай пары ;).