Реализация криптографического алгоритма (AES) Rijndael
Реализация
криптографического алгоритма (AES) Rijndael
Введение
Шифрование - способ преобразования открытой информации в
закрытую и обратно. Применяется для хранения важной информации в ненадёжных
источниках или передачи её по незащищённым каналам связи. Согласно ГОСТ
28147-89, шифрование подразделяется на процесс зашифровывания и
расшифровывания.
В зависимости от алгоритма преобразования данных, методы
шифрования подразделяются на гарантированной или временной криптостойкости.
В зависимости от структуры используемых ключей методы
шифрования подразделяются на
· симметричное шифрование: посторонним лицам
может быть известен алгоритм шифрования, но неизвестна небольшая порция
секретной информации - ключа, одинакового для отправителя и получателя
сообщения;
· асимметричное шифрование: посторонним
лицам может быть известен алгоритм шифрования, и, возможно, открытый ключ, но
неизвестен закрытый ключ, известный только получателю.
История AES
В далеком 1998 году NIST объявил конкурс на создание алгоритма,
удовлетворяющего выдвинутым институтом требованиям. Он опубликовал все
несекретные данные о тестировании кандидатов на роль AES и потребовал от
авторов алгоритмов сообщить о базовых принципах построения используемых в них
констант. В отличие от ситуации с DES, NIST при выборе AES не стал опираться на
секретные и, как следствие, запрещенные к публикации данные об исследовании
алгоритмов-кандидатов.
Чтобы быть утвержденным в качестве стандарта, алгоритм должен
был:
реализовать шифрование частным ключом;
представлять собой блочный шифр;
работать со 128-разрядными блоками данных и ключами трех
размеров (128, 192 и 256 разрядов).
Дополнительно кандидатам рекомендовалось:
использовать операции, легко реализуемые как аппаратно (в
микрочипах), так и программно (на персональных компьютерах и серверах);
ориентироваться на 32-разрядные процессоры;
не усложнять без необходимости структуру шифра для того,
чтобы все заинтересованные стороны были в состоянии самостоятельно провести
независимый криптоанализ алгоритма и убедиться, что в нем не заложено
каких-либо недокументированных возможностей.
Кроме того, алгоритм, претендующий на роль стандарта, должен
распространяться по всему миру на неэксклюзивных условиях и без платы за
пользование патентом.
Перед первым туром конкурса в NIST поступило 21 предложение,
15 из которых соответствовали выдвинутым критериям. Затем были проведены
исследования этих решений, в том числе связанные с дешифровкой и проверкой
производительности, и получены экспертные оценки специалистов по криптографии.
В августе 1999 года NIST объявил пять финалистов, которые получили право на
участие во втором этапе обсуждений. 2 октября 2000 года NIST сообщил о своем
выборе - победителем конкурса стал алгоритм RIJNDAEL (произносится как
«райндол») бельгийских криптографов Винсента Раймана и Йоана Дамана, который
зарегистрирован в качестве официального федерального стандарта как FIPS 197
(Federal Information Processing Standard).
Для меня остается загадкой, зачем в российском вузе преподают
стандарты иностранных государств. Видимо, исходят из принципа, что врага надо
знать в лицо:). Ладно, в общем-то, это не наше дело. Нам надо просто программно
реализовать основу национальной безопасности США.
Описание
AES
Определения и вспомогательные процедуры
Block - последовательность бит, из которых состоит
input, output, State и Round Key. Также под Block можно понимать
последовательность байт
Cipher Key - секретный, криптографический ключ,
который используется Key Expansion процедурой, чтобы произвести набор ключей
для раундов (Round Keys); может быть представлен как прямоугольный массив
байтов, имеющий четыре строки и Nk колонок.
Ciphertext - выходные данные алгоритма шифрования
Key Expansion - процедура используемая для генерации
Round Keys из Cipher Key
Round Key - Round Keys получаютсяиз Cipher Key используяпроцедуру Key
Expansion. Они
применяются к State при шифровании и расшифровании
State - промежуточный результат шифрования, который
может быть представлен как прямоугольный массив байтов имеющий 4 строки и Nb колонок
S-box - нелинейная таблица замен, использующаяся в
нескольких трансформациях замены байт и в процедуре Key Expansion для
взаимнооднозначной замены значения байта. Предварительно рассчитанныйS-box -
можно увидеть ниже.
Nb - число столбцов (32-ух битных слов),
составляющих State.
Для, AES Nb = 4
Nk - число 32-ух битных слов, составляющих
шифроключ.
Для AES, Nk = 4,6, или 8
Nr - число раундов, которое является функцией Nk и
Nb. Для AES, Nr = 10, 12, 14
Rcon[] - массив, который состоит из битов 32-х разрядного
слова и является постоянным для данного раунда. Предварительно рассчитанный
Rcon[] можно увидеть ниже.
S-box
Sbox = array (
0x63,0x7c, 0x77,0x7b, 0xf2,0x6b, 0x6f,
0xc5,0x30,0x01,0x67,0x2b, 0xfe, 0xd7,0xab, 0x76,
xca, 0x82,0xc9,0x7d, 0xfa, 0x59,0x47,0xf0,0xad,
0xd4,0xa2,0xaf, 0x9c, 0xa4,0x72,0xc0,
xb7,0xfd, 0x93,0x26,0x36,0x3f, 0xf7,0xcc,
0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,
0x07,0x12,0x80,0xe2,0xeb, 0x27,0xb2,0x75,
x09,0x83,0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,0x52,0x3b,
0xd6,0xb3,0x29,0xe3,0x2f, 0x84,
x53,0xd1,0x00,0xed, 0x20,0xfc, 0xb1,0x5b, 0x6a,
0xcb, 0xbe, 0x39,0x4a, 0x4c, 0x58,0xcf,
xd0,0xef, 0xaa, 0xfb, 0x43,0x4d,
0x33,0x85,0x45,0xf9,0x02,0x7f, 0x50,0x3c, 0x9f, 0xa8,
x51,0xa3,0x40,0x8f, 0x92,0x9d, 0x38,0xf5,0xbc,
0xb6,0xda, 0x21,0x10,0xff, 0xf3,0xd2,
xcd, 0x0c, 0x13,0xec, 0x5f,
0x97,0x44,0x17,0xc4,0xa7,0x7e, 0x3d, 0x64,0x5d, 0x19,0x73,
x60,0x81,0x4f, 0xdc, 0x22,0x2a,
0x90,0x88,0x46,0xee, 0xb8,0x14,0xde, 0x5e, 0x0b, 0xdb,
xe0,0x32,0x3a, 0x0a, 0x49,0x06,0x24,0x5c,
0xc2,0xd3,0xac, 0x62,0x91,0x95,0xe4,0x79,
xe7,0xc8,0x37,0x6d, 0x8d, 0xd5,0x4e, 0xa9,0x6c,
0x56,0xf4,0xea, 0x65,0x7a, 0xae, 0x08,
xba, 0x78,0x25,0x2e, 0x1c,
0xa6,0xb4,0xc6,0xe8,0xdd, 0x74,0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
x70,0x3e, 0xb5,0x66,0x48,0x03,0xf6,0x0e,
0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d, 0x9e,
xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e, 0x94,0x9b,
0x1e, 0x87,0xe9,0xce, 0x55,0x28,0xdf,
x8c, 0xa1,0x89,0x0d, 0xbf,
0xe6,0x42,0x68,0x41,0x99,0x2d, 0x0f, 0xb0,0x54,0xbb, 0x16,
);
Rcon[]
Rcon = array ((0x00, 0x00, 0x00, 0x00),(0x01,
0x00, 0x00, 0x00),(0x02, 0x00, 0x00, 0x00),(0x04, 0x00, 0x00, 0x00),(0x08,
0x00, 0x00, 0x00),(0x10, 0x00, 0x00, 0x00),(0x20, 0x00, 0x00, 0x00),(0x40,
0x00, 0x00, 0x00),(0x80, 0x00, 0x00, 0x00),(0x1b, 0x00, 0x00, 0x00),
array (0x36, 0x00, 0x00, 0x00),
);
Вспомогательные процедуры
() - трансформация при шифровании и обратном
шифровании, при которой Round Key XOR’ится c State. Длина RoundKey равна
размеру State (те, если Nb = 4, то длина RoundKey равна 128 бит или 16 байт)
InvMixColumns() - трансформация при расшифровании которая
является обратной по отношению к MixColumns()
InvShiftRows() - трансформация при расшифровании которая
является обратной по отношению к ShiftRows()
InvSubBytes() - трансформация при расшифровании которая
является обратной по отношению к SubBytes()
MixColumns() - трансформация при шифровании которая
берет все столбцы State и смешивает их данные (независимо друг от друга), чтобы
получить новые столбцы
RotWord() - функция, использующаяся в процедуре Key
Expansion, которая берет 4-х байтное слово и производит над ним циклическую
перестановку
ShiftRows() - трансформации при шифровании,
которые обрабатывают State, циклически смещая последние три строки State на
разные величины
SubBytes() - трансформации при шифровании которые
обрабатывают State используя нелинейную таблицу замещения байтов (S-box),
применяя её независимо к каждому байту State
SubWord() - функция, используемая в процедуре Key
Expansion, которая берет на входе четырёх-байтное слово и применяя S-box к каждому
из четырёх байтов выдаёт выходное слово
Шифрование
AES является стандартом, основанным на алгоритме Rijndael.
Для AES длина input (блока входных данных) и State(состояния) постоянна и равна
128 бит, а длина шифроключа K составляет 128, 192, или 256 бит. При этом,
исходный алгоритм Rijndael допускает длину ключа и размер блока от 128 до 256
бит с шагом в 32 бита. Для обозначения выбранных длин input, State и Cipher Key
в байтах используется нотация Nb = 4 для input и State, Nk = 4, 6, 8 для Cipher
Key соответственно для разных длин ключей.
В начале шифрования input копируется в массив State по
правилу s [r, c] = in [r + 4c], для и. После этого к State применяется
процедура AddRoundKey() и затем State проходит через процедуру трансформации
(раунд) 10, 12, или 14 раз (в зависимости от длины ключа), при этом надо
учесть, что последний раунд несколько отличается от предыдущих. В итоге, после
завершения последнего раунда трансформации, State копируется в output по
правилу out [r + 4c] = s [r, c], для и.
(byte in [4*Nb], byte out [4*Nb], word w
[Nb*(Nr+1)])state [4, Nb]= in(state, w [0, Nb-1])round = 1 step 1 to
Nr-1(state)(state)(state)(state, w [round*Nb,
(round+1)*Nb-1])for(state)(state)(state, w [Nr*Nb, (Nr+1)*Nb-1]) = state
end
SubBytes()
В процедуре SubBytes, каждый байт в state заменяется
соответствующим элементом в фиксированной 8-битной таблице поиска, S; bij =
S(aij).
Процедура SubBytes() обрабатывает каждый байт состояния,
независимо производя нелинейную замену байтов используя таблицу замен (S-box).
Такая операция обеспечивает нелинейность алгоритма шифрования. Построение S-box
состоит из двух шагов. Во-первых, производится взятие обратного числа в поле
Галуа. Во-вторых, к каждому байту b из которых состоит S-box применяется
следующая операция:
где, и где bi есть i-ый бит b, а ci - i-ый бит константы c =
6316 = 9910 = 011000112. Таким образом, обеспечивается защита от атак,
основанных на простых алгебраических свойствах.
()
В процедуре ShiftRows, байты в каждой строке state циклически
сдвигаются влево. Размер смещения байтов каждой строки зависит от её
номераработает со строками State. При этой трансформации строки состояния
циклически сдвигаются на r байт по горизонтали, в зависимости от номера строки.
Для нулевой строки r = 0, для первой строки r = 1 Б и т.д. Таким образом каждая
колонка выходного состояния после применения процедуры ShiftRows состоит из
байтов из каждой колонки начального состояния. Для алгоритма Rijndael паттерн
смещения строк для 128- и 192-битных строк одинаков. Однако для блока размером
256 бит отличается от предыдущих тем, что 2, 3, и 4-е строки смещаются на 1, 3,
и 4 байта, соответственно.
()
В процедуре MixColumns, каждая колонка состояния
перемножается с фиксированным многочленом c(x).
В процедуре MixColumns, четыре байта каждой колонки State
смешиваются, используя для этого обратимую линейную трансформацию. MixColumns
обрабатывает состояния по колонкам, трактуя каждую из них как полином четвёртой
степени. Над этими полиномами производится умножение в GF(28) по модулю x4 + 1
на фиксированный многочлен c(x) = 3x3 + x2 + x + 2. Вместе с ShiftRows,
MixColumns вносит диффузию в шифр
()
В процедуре AddRoundKey, каждый байт состояния объединяется с
RoundKey используя XOR operation (⊕).
В процедуре AddRoundKey, RoundKey каждого раунда объединяется
со State. Для каждого раунда Roundkey получается из CipherKey используя
процедуру KeyExpansion; каждый RoundKey такого же размера, что и State.
Процедура производит побитовый XOR каждого байта State с каждым байтом
RoundKey.
Алгоритм обработки ключа
Алгоритм обработки ключа состоит из двух процедур:
· Алгоритм расширения ключа
· Алгоритм выбора раундового ключа (ключа
итерации)
Алгоритм расширения ключа
AES алгоритм, используя процедуру KeyExpansion() и подавая в
неё Cipher Key, K, получает ключи для всех раундов. Всего она получает Nb*(Nr +
1) слов: изначально для алгоритма требуется набор из Nb слов, и каждому из Nr
раундов требуется Nb ключевых набора данных. Полученный массив ключей для
раундов обозначается как,
. Алгоритм KeyExpansion() показан в псевдо коде
ниже.
Функция SubWord() берет четырёхбайтовое входное слово и
применяет S-box к каждому из четырёх байтов то, что получилось подается на
выход. На вход RotWord() подается слово [a0, a1, a2, a3] которое она циклически
переставляет и возвращает [a1, a2, a3, a0]. Массив слов, слов постоянный для
данного раунда,
, содержит значения [xi − 1,00,00,00], где
x = {02}, а xi − 1 является степенью x в 
(i начинается с 1).
Из рисунка можно увидеть, что первые Nk слов расширенного
ключа заполненны Cipher Key. В каждое последующее слово, w[i], кладётся
значение полученное при операции XOR w [i − 1] и 
, те XOR’а предыдущего и
на Nk позиций раньше слов. Для слов, позиция которых кратна Nk, перед XOR’ом к
w [i-1] применяется трасформация, за которой следует XOR с константой раунда
Rcon[i]. Указанная выше трансформация состоит из циклического сдвига байтов в
слове (RotWord()), за которой следует процедура SubWord() - то же самое, что и
SubBytes(), только входные и выходные данные будут размером в слово.
Важно заметить, что процедура KeyExpansion() для 256 битного
Cipher Key немного отличается от тех, которые применяются для 128 и 192 битных
шифроключей. Если Nk = 8 и i − 4 кратно Nk, то SubWord() применяется к w
[i − 1] до XOR’а.
KeyExpansion (byte key [4*Nk], word w
[Nb*(Nr+1)], Nk)
Псевдокод для Key Expansion
begintemp= 0;(i < Nk)[i] = word (key[4*i], key
[4*i+1], key [4*i+2], key [4*i+3])= i+1while= Nk(i < Nb * (Nr+1))= w [i-1](i
mod Nk = 0)= SubWord (RotWord(temp)) xor Rcon [i/Nk]if (Nk > 6 and i mod Nk
= 4)= SubWord(temp)if[i] = w [i-Nk] xor temp= i + 1while
Псевдокод для Key Expansion
Расшифрование
Псевдокоддля Inverse Cipher
InvCipher (byte in [4*Nb], byte out [4*Nb], word
w [Nb*(Nr+1)])state [4, Nb]= in(state, w [Nr*Nb, (Nr+1)*Nb-1])round = Nr-1 step
-1 downto 1(state)(state)(state, w [round*Nb,
(round+1)*Nb-1])(state)for(state)(state)(state, w [Nr*Nb, (Nr+1)*Nb-1]) = state
end
Алгоритм выбора раундового ключа
На каждой итерации i раундовый ключ для операции AddRoundKey
выбирается из массива 
начиная с элемента
до
.
Варианты алгоритма
На базе алгоритма Rijndael, лежащего в основе AES,
реализованы альтернативные криптоалгоритмы. Среди наиболее известных -
участники конкурса Nessie: Anubis на инволюциях, автором которого является
Винсент Рэймен и усиленный вариант шифра - Grand Cru Йохана Борста.
Криптостойкость
В июне 2003 года Агентство национальной безопасности США
постановило, что шифр AES является достаточно надёжным, чтобы использовать его
для защиты сведений, составляющих государственную тайну (англ. classified
information). Вплоть до уровня SECRET было разрешено использовать ключи длиной
128 бит, для уровня TOP SECRET требовались ключи длиной 192 и 256 бит.
Программная
реализация алгоритма AES
Пример 1
Выберем действие «Шифрование», затем выберем файл с
расширением.txt, нажимаем на кнопку «Шифровать» (также можно выбрать параметры
шифрования слева в поле «Выполнение процесса»). Программа создает файл EncodedFile.txtрядом с исходным файлом.
Рисунок 1. Шифрование
Пример 2
Выполним обратное действие. В поле исходный файл выберем
созданный ранее программой файл EncodedFile.txt, выберем действие «Дешифровать».Программа
создает файл DecodedFile.txtрядом с исходным файлом.
шифрование программный алгоритм
криптографический
Рисунок 2. Дешифрование
Листинг
программы
unit Main;
interface, Messages, SysUtils, Classes, Graphics,
Controls, Forms, Dialogs,, Math, Buttons, ExtCtrls, Menus, jpeg, pngimage;=
class(Exception);= ^Integer;= array [0..15] of byte;= array [0..15] of byte;=
array [0..43] of longword;=^TAESBuffer;=^TAESKey128;=^TAESExpandedKey128;=
class(TForm): TLabel;: TEdit;: TOpenDialog;: TButton;: TButton;: TLabel;:
TLabel;: TLabel;: TLabel;: TEdit;_Time: TLabel;: TLabel;_Status: TLabel;:
TMemo;: TButton;: TPanel;: TMemo;: TEdit;: TRadioGroup;: TComboBox;: TLabel;:
TLabel;: TLabel;: TLabel;: TMainMenu;: TMenuItem;: TMenuItem;: TMenuItem;:
TMenuItem;: TMenuItem;: TLabel;: TLabel;: TImage;: TLabel;Button1Click (Sender:
TObject);Button2Click (Sender: TObject);ButtonStopClick (Sender:
TObject);CBOptChange (Sender: TObject);FormActivate (Sender:
TObject);RadioGroup1Click (Sender: TObject);MFExitClick (Sender:
TObject);MFChooseClick (Sender: TObject);FormCreate (Sender: TObject);MHHelpClick
(Sender: TObject);
{Private declarations}
{Public declarations};: TForm1;, Fpath: string;
flag: boolean;
// Расширение ключа для шифрования
procedure ExpandAESKeyForEncryption (const Key:
TAESKey128;ExpandedKey: TAESExpandedKey128); overload;
// БлочноешифрованиеEncryptAES (const InBuf:
TAESBuffer; const Key: TAESExpandedKey128;OutBuf: TAESBuffer);
// Шифрованиепотока (ECB
mode)EncryptAESStreamECB (Source: TStream; Count: cardinal;Key: TAESKey128;
Dest: TStream); overload;EncryptAESStreamECB (Source: TStream; Count:
cardinal;ExpandedKey: TAESExpandedKey128; Dest: TStream); overload;
// РасширениеключадлядешифрованияExpandAESKeyForDecryption
(var ExpandedKey: TAESExpandedKey128); overload;ExpandAESKeyForDecryption
(const Key: TAESKey128;ExpandedKey: TAESExpandedKey128); overload;
// ДешифрованиетекущегоблокаDecryptAES (const InBuf:
TAESBuffer; const Key: TAESExpandedKey128;
var OutBuf: TAESBuffer);
// Дешифрование потока (считывание поблочно из потока и
применение к каждому из блоков процедуры DecryptAES)
procedure DecryptAESStreamECB (Source: TStream;
Count: cardinal;Key: TAESKey128; Dest: TStream); overload;DecryptAESStreamECB
(Source: TStream; Count: cardinal;ExpandedKey: TAESExpandedKey128; Dest:
TStream); overload;= 'Неверныйразмербуферадлядешифрования';= 'Ошибка чтения из потока';
SWriteError = 'Ошибка записи в поток';
implementationUnStop;
{$R *.DFM}= ^LongWord;
Min (A, B: integer): integer; // НахождениеминимальногоиздвухчиселA < B
then:= A:= B;;: array [1..30] of longword = (
$00000040, $00000080, $0000001B, $00000036,
$0000006C, $000000D8,
$000000AB, $0000004D, $0000009A, $0000002F,
$0000005E, $000000BC,
$00000063, $000000C6, $00000097, $00000035,
$0000006A, $000000D4,
$000000B3, $0000007D, $000000FA, $000000EF,
$000000C5, $00000091
);
// Прямаятаблица: array [0..255] of
longword = (
$A56363C6, $847C7CF8, $997777EE, $8D7B7BF6,
$0DF2F2FF, $BD6B6BD6, $B16F6FDE, $54C5C591,
$50303060, $03010102, $A96767CE, $7D2B2B56,
$19FEFEE7, $62D7D7B5, $E6ABAB4D, $9A7676EC,
$45CACA8F, $9D82821F, $40C9C989, $877D7DFA,
$15FAFAEF, $EB5959B2, $C947478E, $0BF0F0FB,
$ECADAD41, $67D4D4B3, $FDA2A25F, $EAAFAF45,
$BF9C9C23, $F7A4A453, $967272E4, $5BC0C09B,
$C2B7B775, $1CFDFDE1, $AE93933D, $6A26264C,
$5A36366C, $413F3F7E, $02F7F7F5, $4FCCCC83,
$5C343468, $F4A5A551, $34E5E5D1, $08F1F1F9,
$937171E2, $73D8D8AB, $53313162, $3F15152A,
$0C040408, $52C7C795, $65232346, $5EC3C39D,
$28181830, $A1969637, $0F05050A, $B59A9A2F,
$0907070E, $36121224, $9B80801B, $3DE2E2DF,
$26EBEBCD, $6927274E, $CDB2B27F, $9F7575EA,
$1B090912, $9E83831D, $742C2C58, $2E1A1A34,
$2D1B1B36, $B26E6EDC, $EE5A5AB4, $FBA0A05B,
$F65252A4, $4D3B3B76, $61D6D6B7, $CEB3B37D,
$7B292952, $3EE3E3DD, $712F2F5E, $97848413,
$F55353A6, $68D1D1B9, $00000000, $2CEDEDC1,
$60202040, $1FFCFCE3, $C8B1B179, $ED5B5BB6,
$BE6A6AD4, $46CBCB8D, $D9BEBE67, $4B393972,
$DE4A4A94, $D44C4C98, $E85858B0, $4ACFCF85,
$6BD0D0BB, $2AEFEFC5, $E5AAAA4F, $16FBFBED,
$C5434386, $D74D4D9A, $55333366, $94858511,
$CF45458A, $10F9F9E9, $06020204, $817F7FFE,
$F05050A0, $443C3C78, $BA9F9F25, $E3A8A84B,
$F35151A2, $FEA3A35D, $C0404080, $8A8F8F05,
$AD92923F, $BC9D9D21, $48383870, $04F5F5F1,
$DFBCBC63, $C1B6B677, $75DADAAF, $63212142,
$30101020, $1AFFFFE5, $0EF3F3FD, $6DD2D2BF,
$4CCDCD81, $140C0C18, $35131326, $2FECECC3,
$E15F5FBE, $A2979735, $CC444488, $3917172E,
$57C4C493, $F2A7A755, $827E7EFC, $473D3D7A,
$AC6464C8, $E75D5DBA, $2B191932, $957373E6,
$A06060C0, $98818119, $D14F4F9E, $7FDCDCA3, $66222244,
$7E2A2A54, $AB90903B, $8388880B,
$CA46468C, $29EEEEC7, $D3B8B86B, $3C141428,
$79DEDEA7, $E25E5EBC, $1D0B0B16, $76DBDBAD,
$3BE0E0DB, $56323264, $4E3A3A74, $1E0A0A14,
$DB494992, $0A06060C, $6C242448, $E45C5CB8,
$5DC2C29F, $6ED3D3BD, $EFACAC43, $A66262C4,
$A8919139, $A4959531, $37E4E4D3, $8B7979F2,
$32E7E7D5, $43C8C88B, $5937376E, $B76D6DDA,
$8C8D8D01, $64D5D5B1, $D24E4E9C, $E0A9A949,
$B46C6CD8, $FA5656AC, $07F4F4F3, $25EAEACF,
$AF6565CA, $8E7A7AF4, $E9AEAE47, $18080810,
$D5BABA6F, $887878F0, $6F25254A, $722E2E5C,
$241C1C38, $F1A6A657, $C7B4B473, $51C6C697,
$23E8E8CB, $7CDDDDA1, $9C7474E8, $211F1F3E,
$DD4B4B96, $DCBDBD61, $868B8B0D, $858A8A0F,
$907070E0, $423E3E7C, $C4B5B571, $AA6666CC,
$D8484890, $05030306, $01F6F6F7, $120E0E1C,
$A36161C2, $5F35356A, $F95757AE, $D0B9B969,
$91868617, $58C1C199, $271D1D3A, $B99E9E27,
$38E1E1D9, $13F8F8EB, $B398982B, $33111122,
$BB6969D2, $70D9D9A9, $898E8E07, $A7949433,
$B69B9B2D, $221E1E3C, $92878715, $20E9E9C9,
$49CECE87, $FF5555AA, $78282850, $7ADFDFA5,
$8F8C8C03, $F8A1A159, $80898909, $170D0D1A,
$DABFBF65, $31E6E6D7, $C6424284, $B86868D0,
$C3414182, $B0999929, $772D2D5A, $110F0F1E,
$CBB0B07B, $FC5454A8, $D6BBBB6D, $3A16162C
);
// Последняяпрямаятаблица: array [0..255] of
longword = (
$00000063, $0000007C, $00000077, $0000007B,
$000000F2, $0000006B, $0000006F, $000000C5,
$00000030, $00000001, $00000067, $0000002B,
$000000FE, $000000D7, $000000AB, $00000076,
$000000CA, $00000082, $000000C9, $0000007D,
$000000FA, $00000059, $00000047, $000000F0,
$000000AD, $000000D4, $000000A2, $000000AF,
$0000009C, $000000A4, $00000072, $000000C0,
$000000B7, $000000FD, $00000093, $00000026,
$00000036, $0000003F, $000000F7, $000000CC,
$00000034, $000000A5, $000000E5, $000000F1,
$00000071, $000000D8, $00000031, $00000015,
$00000004, $000000C7, $00000023, $000000C3,
$00000018, $00000096, $00000005, $0000009A,
$00000007, $00000012, $00000080, $000000E2,
$000000EB, $00000027, $000000B2, $00000075,
$00000009, $00000083, $0000002C, $0000001A,
$0000001B, $0000006E, $0000005A, $000000A0,
$00000052, $0000003B, $000000D6, $000000B3,
$00000029, $000000E3, $0000002F, $00000084,
$00000053, $000000D1, $00000000, $000000ED,
$00000020, $000000FC, $000000B1, $0000005B,
$0000006A, $000000CB, $000000BE, $00000039,
$0000004A, $0000004C, $00000058, $000000CF,
$000000D0, $000000EF, $000000AA, $000000FB,
$00000043, $0000004D, $00000033, $00000085,
$00000045, $000000F9, $00000002, $0000007F,
$00000050, $0000003C, $0000009F, $000000A8,
$00000051, $000000A3, $00000040, $0000008F, $00000092,
$0000009D, $00000038, $000000F5,
$000000BC, $000000B6, $000000DA, $00000021,
$00000010, $000000FF, $000000F3, $000000D2,
$000000CD, $0000000C, $00000013, $000000EC,
$0000005F, $00000097, $00000044, $00000017,
$000000C4, $000000A7, $0000007E, $0000003D,
$00000064, $0000005D, $00000019, $00000073,
$00000060, $00000081, $0000004F, $000000DC,
$00000022, $0000002A, $00000090, $00000088,
$00000046, $000000EE, $000000B8, $00000014,
$000000DE, $0000005E, $0000000B, $000000DB,
$000000E0, $00000032, $0000003A, $0000000A,
$00000049, $00000006, $00000024, $0000005C,
$000000C2, $000000D3, $000000AC, $00000062,
$00000091, $00000095, $000000E4, $00000079,
$000000E7, $000000C8, $00000037, $0000006D,
$0000008D, $000000D5, $0000004E, $000000A9,
$0000006C, $00000056, $000000F4, $000000EA,
$00000065, $0000007A, $000000AE, $00000008,
$000000BA, $00000078, $00000025, $0000002E,
$0000001C, $000000A6, $000000B4, $000000C6,
$000000E8, $000000DD, $00000074, $0000001F,
$0000004B, $000000BD, $0000008B, $0000008A,
$00000070, $0000003E, $000000B5, $00000066,
$00000048, $00000003, $000000F6, $0000000E,
$00000061, $00000035, $00000057, $000000B9,
$00000086, $000000C1, $0000001D, $0000009E,
$000000E1, $000000F8, $00000098, $00000011,
$00000069, $000000D9, $0000008E, $00000094,
$0000009B, $0000001E, $00000087, $000000E9,
$000000CE, $00000055, $00000028, $000000DF,
$00000041, $00000099, $0000002D, $0000000F,
$000000B0, $00000054, $000000BB, $00000016
);
// Инверснаятаблица: array [0..255] of
longword = (
$50A7F451, $5365417E, $C3A4171A, $965E273A,
$CB6BAB3B, $F1459D1F, $AB58FAAC, $9303E34B,
$55FA3020, $F66D76AD, $9176CC88, $254C02F5,
$FCD7E54F, $D7CB2AC5, $80443526, $8FA362B5,
$495AB1DE, $671BBA25, $980EEA45, $E1C0FE5D,
$02752FC3, $12F04C81, $A397468D, $C6F9D36B,
$E75F8F03, $959C9215, $EB7A6DBF, $DA595295,
$2D83BED4, $D3217458, $2969E049, $44C8C98E,
$6A89C275, $78798EF4, $6B3E5899, $DD71B927,
$B64FE1BE, $17AD88F0, $66AC20C9, $B43ACE7D,
$184ADF63, $82311AE5, $60335197, $457F5362,
$E07764B1, $84AE6BBB, $1CA081FE, $942B08F9,
$58684870, $19FD458F, $876CDE94, $B7F87B52,
$23D373AB, $E2024B72, $578F1FE3, $2AAB5566,
$0728EBB2, $03C2B52F, $9A7BC586, $A50837D3,
$F2872830, $B2A5BF23, $BA6A0302, $5C8216ED,
$2B1CCF8A, $92B479A7, $F0F207F3, $A1E2694E,
$CDF4DA65, $D5BE0506, $1F6234D1, $8AFEA6C4,
$9D532E34, $A055F3A2, $32E18A05, $75EBF6A4,
$39EC830B, $AAEF6040, $069F715E, $51106EBD,
$F98A213E, $3D06DD96, $AE053EDD, $46BDE64D,
$B58D5491, $055DC471, $6FD40604, $FF155060,
$24FB9819, $97E9BDD6, $CC434089, $779ED967,
$BD42E8B0, $888B8907, $385B19E7, $DBEEC879,
$470A7CA1, $E90F427C, $C91E84F8, $00000000,
$83868009, $48ED2B32, $AC70111E, $4E725A6C,
$FBFF0EFD, $5638850F, $1ED5AE3D, $27392D36,
$64D90F0A, $21A65C68, $D1545B9B, $3A2E3624,
$B1670A0C, $0FE75793, $D296EEB4, $9E919B1B,
$4FC5C080, $A220DC61, $694B775A, $161A121C,
$0ABA93E2, $E52AA0C0, $43E0223C, $1D171B12,
$0B0D090E, $ADC78BF2, $B9A8B62D, $C8A91E14,
$8519F157, $4C0775AF, $BBDD99EE, $FD607FA3,
$9F2601F7, $BCF5725C, $C53B6644, $347EFB5B,
$7629438B, $DCC623CB, $68FCEDB6, $63F1E4B8,
$CADC31D7, $10856342, $40229713, $2011C684,
$7D244A85, $F83DBBD2, $1132F9AE, $6DA129C7,
$4B2F9E1D, $F330B2DC, $EC52860D, $D0E3C177,
$6C16B32B, $99B970A9, $FA489411, $2264E947,
$C48CFCA8, $1A3FF0A0, $D82C7D56, $EF903322,
$C74E4987, $C1D138D9, $FEA2CA8C, $360BD498,
$CF81F5A6, $28DE7AA5, $268EB7DA, $A4BFAD3F,
$E49D3A2C, $0D927850, $9BCC5F6A, $62467E54,
$C2138DF6, $E8B8D890, $5EF7392E, $F5AFC382,
$BE805D9F, $7C93D069, $A92DD56F, $B31225CF,
$3B99ACC8, $A77D1810, $6E639CE8, $7BBB3BDB,
$097826CD, $F418596E, $01B79AEC, $A89A4F83,
$656E95E6, $7EE6FFAA, $08CFBC21, $E6E815EF,
$D99BE7BA, $CE366F4A, $D4099FEA, $D67CB029,
$AFB2A431, $31233F2A, $3094A5C6, $C066A235,
$37BC4E74, $A6CA82FC, $B0D090E0, $15D8A733,
$4A9804F1, $F7DAEC41, $0E50CD7F, $2FF69117,
$8DD64D76, $4DB0EF43, $544DAACC, $DF0496E4,
$E3B5D19E, $1B886A4C, $B81F2CC1, $7F516546,
$04EA5E9D, $5D358C01, $737487FA, $2E410BFB,
$5A1D67B3, $52D2DB92, $335610E9, $1347D66D,
$8C61D79A, $7A0CA137, $8E14F859, $893C13EB,
$EE27A9CE, $35C961B7, $EDE51CE1, $3CB1477A,
$59DFD29C, $3F73F255, $79CE1418, $BF37C773,
$EACDF753, $5BAAFD5F, $146F3DDF, $86DB4478,
$81F3AFCA, $3EC468B9, $2C342438, $5F40A3C2,
$72C31D16, $0C25E2BC, $8B493C28, $41950DFF,
$7101A839, $DEB30C08, $9CE4B4D8, $90C15664,
$6184CB7B, $70B632D5, $745C6C48, $4257B8D0
);
// Последняяинверснаятаблица: array [0..255] of
longword = (
$00000052, $00000009, $0000006A, $000000D5,
$00000030, $00000036, $000000A5, $00000038,
$000000BF, $00000040, $000000A3, $0000009E,
$00000081, $000000F3, $000000D7, $000000FB,
$0000007C, $000000E3, $00000039, $00000082,
$0000009B, $0000002F, $000000FF, $00000087,
$00000034, $0000008E, $00000043, $00000044,
$000000C4, $000000DE, $000000E9, $000000CB,
$00000054, $0000007B, $00000094, $00000032,
$000000A6, $000000C2, $00000023, $0000003D,
$000000EE, $0000004C, $00000095, $0000000B,
$00000042, $000000FA, $000000C3, $0000004E,
$00000008, $0000002E, $000000A1, $00000066,
$00000028, $000000D9, $00000024, $000000B2,
$00000076, $0000005B, $000000A2, $00000049,
$0000006D, $0000008B, $000000D1, $00000025,
$00000072, $000000F8, $000000F6, $00000064,
$00000086, $00000068, $00000098, $00000016,
$000000D4, $000000A4, $0000005C, $000000CC, $0000005D,
$00000065, $000000B6, $00000092,
$0000006C, $00000070, $00000048, $00000050,
$000000FD, $000000ED, $000000B9, $000000DA,
$0000005E, $00000015, $00000046, $00000057,
$000000A7, $0000008D, $0000009D, $00000084,
$00000090, $000000D8, $000000AB, $00000000,
$0000008C, $000000BC, $000000D3, $0000000A,
$000000F7, $000000E4, $00000058, $00000005,
$000000B8, $000000B3, $00000045, $00000006,
$000000D0, $0000002C, $0000001E, $0000008F,
$000000CA, $0000003F, $0000000F, $00000002,
$000000C1, $000000AF, $000000BD, $00000003,
$00000001, $00000013, $0000008A, $0000006B,
$0000003A, $00000091, $00000011, $00000041,
$0000004F, $00000067, $000000DC, $000000EA,
$00000097, $000000F2, $000000CF, $000000CE,
$000000F0, $000000B4, $000000E6, $00000073,
$00000096, $000000AC, $00000074, $00000022,
$000000E7, $000000AD, $00000035, $00000085,
$000000E2, $000000F9, $00000037, $000000E8,
$0000001C, $00000075, $000000DF, $0000006E,
$00000047, $000000F1, $0000001A, $00000071,
$0000001D, $00000029, $000000C5, $00000089,
$0000006F, $000000B7, $00000062, $0000000E,
$000000AA, $00000018, $000000BE, $0000001B,
$000000FC, $00000056, $0000003E, $0000004B,
$000000C6, $000000D2, $00000079, $00000020,
$0000009A, $000000DB, $000000C0, $000000FE,
$00000078, $000000CD, $0000005A, $000000F4,
$0000001F, $000000DD, $000000A8, $00000033,
$00000088, $00000007, $000000C7, $00000031,
$000000B1, $00000012, $00000010, $00000059,
$00000027, $00000080, $000000EC, $0000005F,
$00000060, $00000051, $0000007F, $000000A9,
$00000019, $000000B5, $0000004A, $0000000D,
$0000002D, $000000E5, $0000007A, $0000009F,
$00000093, $000000C9, $0000009C, $000000EF,
$000000A0, $000000E0, $0000003B, $0000004D,
$000000AE, $0000002A, $000000F5, $000000B0,
$000000C8, $000000EB, $000000BB, $0000003C, $00000083,
$00000053, $00000099, $00000061,
$00000017, $0000002B, $00000004, $0000007E,
$000000BA, $00000077, $000000D6, $00000026,
$000000E1, $00000069, $00000014, $00000063, $00000055,
$00000021, $0000000C, $0000007D
);
procedure ExpandAESKeyForEncryption (const Key:
TAESKey128; var ExpandedKey: TAESExpandedKey128);, J: integer;: longword;, W1,
W2, W3: longword;[0]:= PLongWord (@Key[0])^;[1]:= PLongWord (@Key[4])^;[2]:=
PLongWord (@Key[8])^;[3]:= PLongWord (@Key[12])^;:= 0; J:= 1;:= (ExpandedKey [I
+ 3] shl 24) or (ExpandedKey [I + 3] shr 8);:= LastForwardTable [Byte(T)]; W1:=
LastForwardTable [Byte(T shr 8)];:= LastForwardTable [Byte(T shr 16)]; W3:=
LastForwardTable [Byte(T shr 24)];[I + 4]:= ExpandedKey[I] xor
(W0 xor ((W1 shl 8) or (W1 shr 24)) xor
((W2 shl 16) or (W2 shr 16)) xor ((W3 shl 24) or
(W3 shr 8))) xor Rcon[J];(J);[I + 5]:= ExpandedKey [I + 1] xor ExpandedKey [I +
4];[I + 6]:= ExpandedKey [I + 2] xor ExpandedKey [I + 5];[I + 7]:= ExpandedKey
[I + 3] xor ExpandedKey [I + 6];(I, 4);I >= 40;;EncryptAES (const InBuf:
TAESBuffer; const Key: TAESExpandedKey128;OutBuf: TAESBuffer);, T1: array
[0..3] of longword;, W1, W2, W3: longword;
// Инициализация[0]:= PLongWord
(@InBuf[0])^ xor Key[0];[1]:= PLongWord (@InBuf[4])^ xor Key[1];[2]:= PLongWord
(@InBuf[8])^ xor Key[2];[3]:= PLongWord (@InBuf[12])^ xor Key[3];
// преобразования выполняются 10 раз
// раунд 1:= ForwardTable [Byte(T0 [0])]; W1:=
ForwardTable [Byte(T0 [1] shr 8)];:= ForwardTable [Byte(T0 [2] shr 16)]; W3:=
ForwardTable [Byte(T0 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[4];:=
ForwardTable [Byte(T0 [1])]; W1:= ForwardTable [Byte(T0 [2] shr 8)];:=
ForwardTable [Byte(T0 [3] shr 16)]; W3:= ForwardTable [Byte(T0 [0] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[5];:= ForwardTable [Byte(T0 [2])];
W1:= ForwardTable [Byte(T0 [3] shr 8)];:= ForwardTable [Byte(T0 [0] shr 16)];
W3:= ForwardTable [Byte(T0 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[6];:=
ForwardTable [Byte(T0 [3])]; W1:= ForwardTable [Byte(T0 [0] shr 8)];:=
ForwardTable [Byte(T0 [1] shr 16)]; W3:= ForwardTable [Byte(T0 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[7];
// раунд 2:= ForwardTable [Byte(T1 [0])]; W1:=
ForwardTable [Byte(T1 [1] shr 8)];:= ForwardTable [Byte(T1 [2] shr 16)]; W3:=
ForwardTable [Byte(T1 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[8];:=
ForwardTable [Byte(T1 [1])]; W1:= ForwardTable [Byte(T1 [2] shr 8)];:=
ForwardTable [Byte(T1 [3] shr 16)]; W3:= ForwardTable [Byte(T1 [0] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[9];:= ForwardTable [Byte(T1 [2])];
W1:= ForwardTable [Byte(T1 [3] shr 8)];:= ForwardTable [Byte(T1 [0] shr 16)];
W3:= ForwardTable [Byte(T1 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[10];:= ForwardTable [Byte(T1 [3])]; W1:= ForwardTable [Byte(T1 [0] shr
8)];:= ForwardTable [Byte(T1 [1] shr 16)]; W3:= ForwardTable [Byte(T1 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[11];
// раунд 3:= ForwardTable [Byte(T0 [0])]; W1:=
ForwardTable [Byte(T0 [1] shr 8)];:= ForwardTable [Byte(T0 [2] shr 16)]; W3:=
ForwardTable [Byte(T0 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[12];:=
ForwardTable [Byte(T0 [1])]; W1:= ForwardTable [Byte(T0 [2] shr 8)];:=
ForwardTable [Byte(T0 [3] shr 16)]; W3:= ForwardTable [Byte(T0 [0] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[13];:= ForwardTable [Byte(T0 [2])];
W1:= ForwardTable [Byte(T0 [3] shr 8)];:= ForwardTable [Byte(T0 [0] shr 16)];
W3:= ForwardTable [Byte(T0 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[14];:= ForwardTable [Byte(T0 [3])]; W1:= ForwardTable [Byte(T0 [0] shr
8)];:= ForwardTable [Byte(T0 [1] shr 16)]; W3:= ForwardTable [Byte(T0 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[15];
// раунд 4:= ForwardTable [Byte(T1 [0])]; W1:=
ForwardTable [Byte(T1 [1] shr 8)];:= ForwardTable [Byte(T1 [2] shr 16)]; W3:=
ForwardTable [Byte(T1 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[16];:=
ForwardTable [Byte(T1 [1])]; W1:= ForwardTable [Byte(T1 [2] shr 8)];:=
ForwardTable [Byte(T1 [3] shr 16)]; W3:= ForwardTable [Byte(T1 [0] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[17];:= ForwardTable [Byte(T1 [2])];
W1:= ForwardTable [Byte(T1 [3] shr 8)];:= ForwardTable [Byte(T1 [0] shr 16)];
W3:= ForwardTable [Byte(T1 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[18];:=
ForwardTable [Byte(T1 [3])]; W1:= ForwardTable [Byte(T1 [0] shr 8)];:=
ForwardTable [Byte(T1 [1] shr 16)]; W3:= ForwardTable [Byte(T1 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[19];
// раунд 5:= ForwardTable [Byte(T0 [0])]; W1:=
ForwardTable [Byte(T0 [1] shr 8)];:= ForwardTable [Byte(T0 [2] shr 16)]; W3:=
ForwardTable [Byte(T0 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[20];:=
ForwardTable [Byte(T0 [1])]; W1:= ForwardTable [Byte(T0 [2] shr 8)];:=
ForwardTable [Byte(T0 [3] shr 16)]; W3:= ForwardTable [Byte(T0 [0] shr 24)];[1]:=
(W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl
24) or (W3 shr 8))) xor Key[21];:= ForwardTable [Byte(T0 [2])]; W1:=
ForwardTable [Byte(T0 [3] shr 8)];:= ForwardTable [Byte(T0 [0] shr 16)]; W3:=
ForwardTable [Byte(T0 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[22];:=
ForwardTable [Byte(T0 [3])]; W1:= ForwardTable [Byte(T0 [0] shr 8)];:=
ForwardTable [Byte(T0 [1] shr 16)]; W3:= ForwardTable [Byte(T0 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[23];
// раунд 6:= ForwardTable [Byte(T1 [0])]; W1:=
ForwardTable [Byte(T1 [1] shr 8)];:= ForwardTable [Byte(T1 [2] shr 16)]; W3:= ForwardTable
[Byte(T1 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl
16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[24];:= ForwardTable
[Byte(T1 [1])]; W1:= ForwardTable [Byte(T1 [2] shr 8)];:= ForwardTable [Byte(T1
[3] shr 16)]; W3:= ForwardTable [Byte(T1 [0] shr 24)];[1]:= (W0 xor ((W1 shl 8)
or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8)))
xor Key[25];:= ForwardTable [Byte(T1 [2])]; W1:= ForwardTable [Byte(T1 [3] shr
8)];:= ForwardTable [Byte(T1 [0] shr 16)]; W3:= ForwardTable [Byte(T1 [1] shr
24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[26];:= ForwardTable [Byte(T1 [3])];
W1:= ForwardTable [Byte(T1 [0] shr 8)];:= ForwardTable [Byte(T1 [1] shr 16)];
W3:= ForwardTable [Byte(T1 [2] shr 24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[27];
// раунд 7:= ForwardTable [Byte(T0 [0])]; W1:=
ForwardTable [Byte(T0 [1] shr 8)];:= ForwardTable [Byte(T0 [2] shr 16)]; W3:=
ForwardTable [Byte(T0 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[28];:=
ForwardTable [Byte(T0 [1])]; W1:= ForwardTable [Byte(T0 [2] shr 8)];:=
ForwardTable [Byte(T0 [3] shr 16)]; W3:= ForwardTable [Byte(T0 [0] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[29];:= ForwardTable [Byte(T0 [2])];
W1:= ForwardTable [Byte(T0 [3] shr 8)];:= ForwardTable [Byte(T0 [0] shr 16)];
W3:= ForwardTable [Byte(T0 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[30];:= ForwardTable [Byte(T0 [3])]; W1:= ForwardTable [Byte(T0 [0] shr
8)];:= ForwardTable [Byte(T0 [1] shr 16)]; W3:= ForwardTable [Byte(T0 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[31];
// раунд 8:= ForwardTable [Byte(T1 [0])]; W1:=
ForwardTable [Byte(T1 [1] shr 8)];:= ForwardTable [Byte(T1 [2] shr 16)]; W3:=
ForwardTable [Byte(T1 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[32];:=
ForwardTable [Byte(T1 [1])]; W1:= ForwardTable [Byte(T1 [2] shr 8)];:=
ForwardTable [Byte(T1 [3] shr 16)]; W3:= ForwardTable [Byte(T1 [0] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[33];:= ForwardTable [Byte(T1 [2])];
W1:= ForwardTable [Byte(T1 [3] shr 8)];:= ForwardTable [Byte(T1 [0] shr 16)];
W3:= ForwardTable [Byte(T1 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[34];:=
ForwardTable [Byte(T1 [3])]; W1:= ForwardTable [Byte(T1 [0] shr 8)];:=
ForwardTable [Byte(T1 [1] shr 16)]; W3:= ForwardTable [Byte(T1 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[35];
// раунд 9:= ForwardTable [Byte(T0 [0])]; W1:=
ForwardTable [Byte(T0 [1] shr 8)];:= ForwardTable [Byte(T0 [2] shr 16)]; W3:=
ForwardTable [Byte(T0 [3] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[36];:=
ForwardTable [Byte(T0 [1])]; W1:= ForwardTable [Byte(T0 [2] shr 8)];:=
ForwardTable [Byte(T0 [3] shr 16)]; W3:= ForwardTable [Byte(T0 [0] shr 24)];[1]:=
(W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl
24) or (W3 shr 8))) xor Key[37];:= ForwardTable [Byte(T0 [2])]; W1:=
ForwardTable [Byte(T0 [3] shr 8)];:= ForwardTable [Byte(T0 [0] shr 16)]; W3:=
ForwardTable [Byte(T0 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[38];:=
ForwardTable [Byte(T0 [3])]; W1:= ForwardTable [Byte(T0 [0] shr 8)];:=
ForwardTable [Byte(T0 [1] shr 16)]; W3:= ForwardTable [Byte(T0 [2] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[39];
// Последнийраундпреобраобразований:=
LastForwardTable [Byte(T1 [0])]; W1:= LastForwardTable [Byte(T1 [1] shr 8)];:=
LastForwardTable [Byte(T1 [2] shr 16)]; W3:= LastForwardTable [Byte(T1 [3] shr
24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[40];:= LastForwardTable [Byte(T1
[1])]; W1:= LastForwardTable [Byte(T1 [2] shr 8)];:= LastForwardTable [Byte(T1
[3] shr 16)]; W3:= LastForwardTable [Byte(T1 [0] shr 24)];[1]:= (W0 xor ((W1
shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr
8))) xor Key[41];:= LastForwardTable [Byte(T1 [2])]; W1:= LastForwardTable
[Byte(T1 [3] shr 8)];:= LastForwardTable [Byte(T1 [0] shr 16)]; W3:=
LastForwardTable [Byte(T1 [1] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[42];:= LastForwardTable [Byte(T1 [3])]; W1:= LastForwardTable [Byte(T1 [0]
shr 8)];:= LastForwardTable [Byte(T1 [1] shr 16)]; W3:= LastForwardTable
[Byte(T1 [2] shr 24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl
16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[43];
// Завершение(@OutBuf[0])^:= T0 [0];
PLongWord (@OutBuf[4])^:= T0 [1];(@OutBuf[8])^:= T0 [2]; PLongWord
(@OutBuf[12])^:= T0 [3];;ExpandAESKeyForDecryption (var ExpandedKey:
TAESExpandedKey128);: integer;, F2, F4, F8, F9: longword;I:= 1 to 9 do
// Процедура расширения ключа:= ExpandedKey [I * 4];
U:= F9 and $80808080;:= ((F9 and $7F7F7F7F) shl
1) xor ((U - (U shr 7)) and $1B1B1B1B);:= F2 and $80808080;:= ((F2 and
$7F7F7F7F) shl 1) xor ((U - (U shr 7)) and $1B1B1B1B);:= F4 and $80808080;:=
((F4 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and $1B1B1B1B);:= F9 xor F8;[I
* 4]:= F2 xor F4 xor F8 xor
(((F2 xor F9) shl 24) or ((F2 xor F9) shr 8)) xor
(((F4 xor F9) shl 16) or ((F4 xor F9) shr 16))
xor ((F9 shl 8) or (F9 shr 24));:= ExpandedKey [I * 4 + 1];:= F9 and
$80808080;:= ((F9 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and $1B1B1B1B);:=
F2 and $80808080;:= ((F2 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and
$1B1B1B1B);:= F4 and $80808080;:= ((F4 and $7F7F7F7F) shl 1) xor ((U - (U shr
7)) and $1B1B1B1B);:= F9 xor F8;[I * 4 + 1]:= F2 xor F4 xor F8 xor
(((F2 xor F9) shl 24) or ((F2 xor F9) shr 8)) xor
(((F4 xor F9) shl 16) or ((F4 xor F9) shr 16))
xor ((F9 shl 8) or (F9 shr 24));:= ExpandedKey [I * 4 + 2];:= F9 and
$80808080;:= ((F9 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and $1B1B1B1B);:=
F2 and $80808080;:= ((F2 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and
$1B1B1B1B);:= F4 and $80808080;:= ((F4 and $7F7F7F7F) shl 1) xor ((U - (U shr
7)) and $1B1B1B1B);:= F9 xor F8;[I * 4 + 2]:= F2 xor F4 xor F8 xor
(((F2 xor F9) shl 24) or ((F2 xor F9) shr 8)) xor
(((F4 xor F9) shl 16) or ((F4 xor F9) shr 16))
xor ((F9 shl 8) or (F9 shr 24));:= ExpandedKey [I * 4 + 3];:= F9 and
$80808080;:= ((F9 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and $1B1B1B1B);:=
F2 and $80808080;:= ((F2 and $7F7F7F7F) shl 1) xor ((U - (U shr 7)) and
$1B1B1B1B);:= F4 and $80808080;:= ((F4 and $7F7F7F7F) shl 1) xor ((U - (U shr
7)) and $1B1B1B1B);:= F9 xor F8;[I * 4 + 3]:= F2 xor F4 xor F8 xor
(((F2 xor F9) shl 24) or ((F2 xor F9) shr 8)) xor
(((F4 xor F9) shl 16) or ((F4 xor F9) shr 16))
xor ((F9 shl 8) or (F9 shr 24));;;ExpandAESKeyForDecryption (const Key:
TAESKey128; var ExpandedKey: TAESExpandedKey128);(Key, ExpandedKey);
// Подготовка ключа (расширение)(ExpandedKey);
// Расширение ключа для дешифрования;DecryptAES
(const InBuf: TAESBuffer; const Key: TAESExpandedKey128;OutBuf: TAESBuffer);,
T1: array [0..3] of longword;, W1, W2, W3: longword;
// Инициализация[0]:= PLongWord
(@InBuf[0])^ xor Key[40];[1]:= PLongWord (@InBuf[4])^ xor Key[41];[2]:=
PLongWord (@InBuf[8])^ xor Key[42];[3]:= PLongWord (@InBuf[12])^ xor Key[43];
// Преобразованиявыполняются 10 раз
// раунд 1:= InverseTable [Byte(T0 [0])]; W1:=
InverseTable [Byte(T0 [3] shr 8)];:= InverseTable [Byte(T0 [2] shr 16)]; W3:=
InverseTable [Byte(T0 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[36];:=
InverseTable [Byte(T0 [1])]; W1:= InverseTable [Byte(T0 [0] shr 8)];:=
InverseTable [Byte(T0 [3] shr 16)]; W3:= InverseTable [Byte(T0 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[37];:= InverseTable [Byte(T0 [2])];
W1:= InverseTable [Byte(T0 [1] shr 8)];:= InverseTable [Byte(T0 [0] shr 16)];
W3:= InverseTable [Byte(T0 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[38];:= InverseTable [Byte(T0 [3])]; W1:= InverseTable [Byte(T0 [2] shr
8)];:= InverseTable [Byte(T0 [1] shr 16)]; W3:= InverseTable [Byte(T0 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[39];
// раунд 2:= InverseTable [Byte(T1 [0])]; W1:=
InverseTable [Byte(T1 [3] shr 8)];:= InverseTable [Byte(T1 [2] shr 16)]; W3:=
InverseTable [Byte(T1 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[32];:=
InverseTable [Byte(T1 [1])]; W1:= InverseTable [Byte(T1 [0] shr 8)];:=
InverseTable [Byte(T1 [3] shr 16)]; W3:= InverseTable [Byte(T1 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[33];:= InverseTable [Byte(T1 [2])];
W1:= InverseTable [Byte(T1 [1] shr 8)];:= InverseTable [Byte(T1 [0] shr 16)];
W3:= InverseTable [Byte(T1 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[34];:= InverseTable [Byte(T1 [3])]; W1:= InverseTable [Byte(T1 [2] shr
8)];:= InverseTable [Byte(T1 [1] shr 16)]; W3:= InverseTable [Byte(T1 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[35];
// раунд 3:= InverseTable [Byte(T0 [0])]; W1:=
InverseTable [Byte(T0 [3] shr 8)];:= InverseTable [Byte(T0 [2] shr 16)]; W3:=
InverseTable [Byte(T0 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[28];:=
InverseTable [Byte(T0 [1])]; W1:= InverseTable [Byte(T0 [0] shr 8)];:=
InverseTable [Byte(T0 [3] shr 16)]; W3:= InverseTable [Byte(T0 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[29];:= InverseTable [Byte(T0 [2])];
W1:= InverseTable [Byte(T0 [1] shr 8)];:= InverseTable [Byte(T0 [0] shr 16)];
W3:= InverseTable [Byte(T0 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[30];:= InverseTable [Byte(T0 [3])]; W1:= InverseTable [Byte(T0 [2] shr
8)];:= InverseTable [Byte(T0 [1] shr 16)]; W3:= InverseTable [Byte(T0 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[31];
// раунд 4:= InverseTable [Byte(T1 [0])]; W1:=
InverseTable [Byte(T1 [3] shr 8)];:= InverseTable [Byte(T1 [2] shr 16)]; W3:=
InverseTable [Byte(T1 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[24];:=
InverseTable [Byte(T1 [1])]; W1:= InverseTable [Byte(T1 [0] shr 8)];:=
InverseTable [Byte(T1 [3] shr 16)]; W3:= InverseTable [Byte(T1 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[25];:= InverseTable [Byte(T1 [2])];
W1:= InverseTable [Byte(T1 [1] shr 8)];:= InverseTable [Byte(T1 [0] shr 16)];
W3:= InverseTable [Byte(T1 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[26];:= InverseTable [Byte(T1 [3])]; W1:= InverseTable [Byte(T1 [2] shr
8)];:= InverseTable [Byte(T1 [1] shr 16)]; W3:= InverseTable [Byte(T1 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[27];
// раунд 5:= InverseTable [Byte(T0 [0])]; W1:=
InverseTable [Byte(T0 [3] shr 8)];:= InverseTable [Byte(T0 [2] shr 16)]; W3:=
InverseTable [Byte(T0 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[20];:=
InverseTable [Byte(T0 [1])]; W1:= InverseTable [Byte(T0 [0] shr 8)];:=
InverseTable [Byte(T0 [3] shr 16)]; W3:= InverseTable [Byte(T0 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[21];:= InverseTable [Byte(T0 [2])];
W1:= InverseTable [Byte(T0 [1] shr 8)];:= InverseTable [Byte(T0 [0] shr 16)];
W3:= InverseTable [Byte(T0 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[22];:= InverseTable [Byte(T0 [3])]; W1:= InverseTable [Byte(T0 [2] shr
8)];:= InverseTable [Byte(T0 [1] shr 16)]; W3:= InverseTable [Byte(T0 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[23];
// раунд 6:= InverseTable [Byte(T1 [0])]; W1:=
InverseTable [Byte(T1 [3] shr 8)];:= InverseTable [Byte(T1 [2] shr 16)]; W3:=
InverseTable [Byte(T1 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[16];:=
InverseTable [Byte(T1 [1])]; W1:= InverseTable [Byte(T1 [0] shr 8)];:=
InverseTable [Byte(T1 [3] shr 16)]; W3:= InverseTable [Byte(T1 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[17];:= InverseTable [Byte(T1 [2])];
W1:= InverseTable [Byte(T1 [1] shr 8)];:= InverseTable [Byte(T1 [0] shr 16)];
W3:= InverseTable [Byte(T1 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[18];:= InverseTable [Byte(T1 [3])]; W1:= InverseTable [Byte(T1 [2] shr
8)];:= InverseTable [Byte(T1 [1] shr 16)]; W3:= InverseTable [Byte(T1 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[19];
// раунд 7:= InverseTable [Byte(T0 [0])]; W1:=
InverseTable [Byte(T0 [3] shr 8)];:= InverseTable [Byte(T0 [2] shr 16)]; W3:=
InverseTable [Byte(T0 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[12];:=
InverseTable [Byte(T0 [1])]; W1:= InverseTable [Byte(T0 [0] shr 8)];:=
InverseTable [Byte(T0 [3] shr 16)]; W3:= InverseTable [Byte(T0 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[13];:= InverseTable [Byte(T0 [2])];
W1:= InverseTable [Byte(T0 [1] shr 8)];:= InverseTable [Byte(T0 [0] shr 16)];
W3:= InverseTable [Byte(T0 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[14];:=
InverseTable [Byte(T0 [3])]; W1:= InverseTable [Byte(T0 [2] shr 8)];:=
InverseTable [Byte(T0 [1] shr 16)]; W3:= InverseTable [Byte(T0 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[15];
// раунд 8:= InverseTable [Byte(T1 [0])]; W1:=
InverseTable [Byte(T1 [3] shr 8)];:= InverseTable [Byte(T1 [2] shr 16)]; W3:=
InverseTable [Byte(T1 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[8];:=
InverseTable [Byte(T1 [1])]; W1:= InverseTable [Byte(T1 [0] shr 8)];:=
InverseTable [Byte(T1 [3] shr 16)]; W3:= InverseTable [Byte(T1 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3
shl 24) or (W3 shr 8))) xor Key[9];:= InverseTable [Byte(T1 [2])]; W1:=
InverseTable [Byte(T1 [1] shr 8)];:= InverseTable [Byte(T1 [0] shr 16)]; W3:=
InverseTable [Byte(T1 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[10];:=
InverseTable [Byte(T1 [3])]; W1:= InverseTable [Byte(T1 [2] shr 8)];:=
InverseTable [Byte(T1 [1] shr 16)]; W3:= InverseTable [Byte(T1 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[11];
// раунд 9:= InverseTable [Byte(T0 [0])]; W1:=
InverseTable [Byte(T0 [3] shr 8)];:= InverseTable [Byte(T0 [2] shr 16)]; W3:=
InverseTable [Byte(T0 [1] shr 24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24))
xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[4];:=
InverseTable [Byte(T0 [1])]; W1:= InverseTable [Byte(T0 [0] shr 8)];:=
InverseTable [Byte(T0 [3] shr 16)]; W3:= InverseTable [Byte(T0 [2] shr
24)];[1]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[5];:= InverseTable [Byte(T0 [2])];
W1:= InverseTable [Byte(T0 [1] shr 8)];:= InverseTable [Byte(T0 [0] shr 16)];
W3:= InverseTable [Byte(T0 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr
24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[6];:=
InverseTable [Byte(T0 [3])]; W1:= InverseTable [Byte(T0 [2] shr 8)];:=
InverseTable [Byte(T0 [1] shr 16)]; W3:= InverseTable [Byte(T0 [0] shr
24)];[3]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[7];
// Последнийраундпреобразований:=
LastInverseTable [Byte(T1 [0])]; W1:= LastInverseTable [Byte(T1 [3] shr 8)];:=
LastInverseTable [Byte(T1 [2] shr 16)]; W3:= LastInverseTable [Byte(T1 [1] shr
24)];[0]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr
16))((W3 shl 24) or (W3 shr 8))) xor Key[0];:= LastInverseTable [Byte(T1 [1])];
W1:= LastInverseTable [Byte(T1 [0] shr 8)];:= LastInverseTable [Byte(T1 [3] shr
16)]; W3:= LastInverseTable [Byte(T1 [2] shr 24)];[1]:= (W0 xor ((W1 shl 8) or
(W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor
Key[1];:= LastInverseTable [Byte(T1 [2])]; W1:= LastInverseTable [Byte(T1 [1]
shr 8)];:= LastInverseTable [Byte(T1 [0] shr 16)]; W3:= LastInverseTable
[Byte(T1 [3] shr 24)];[2]:= (W0 xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl
16) or (W2 shr 16))((W3 shl 24) or (W3 shr 8))) xor Key[2];:= LastInverseTable
[Byte(T1 [3])]; W1:= LastInverseTable [Byte(T1 [2] shr 8)];:= LastInverseTable
[Byte(T1 [1] shr 16)]; W3:= LastInverseTable [Byte(T1 [0] shr 24)];[3]:= (W0
xor ((W1 shl 8) or (W1 shr 24)) xor ((W2 shl 16) or (W2 shr 16))((W3 shl 24) or
(W3 shr 8))) xor Key[3];
// Конечное преобразование(@OutBuf[0])^:= T0 [0]; PLongWord
(@OutBuf[4])^:= T0 [1];
PLongWord (@OutBuf[8])^:= T0 [2]; PLongWord
(@OutBuf[12])^:= T0 [3];
end;
// Сначала ключ переводится к расширенному
procedure EncryptAESStreamECB (Source: TStream;
Count: cardinal;Key: TAESKey128; Dest: TStream);: TAESExpandedKey128;(Key,
ExpandedKey);
// Вызов из этой процедуры процедуры шифорования с
расширенным ключом
EncryptAESStreamECB (Source, Count, ExpandedKey,
Dest);;
// ШифрованиепотокаEncryptAESStreamECB
(Source: TStream; Count: cardinal;ExpandedKey: TAESExpandedKey128; Dest:
TStream);
var, TempOut: TAESBuffer; // Размер буферов считывания и
записи
Done: cardinal;: TStringStream;: integer;:=
TStringStream. Create('');Count = 0 then. Position:= 0; //
Указательвначалопотока:= Source. Size; // Определение текущего размера потока
endCount:= Min (Count, Source. Size - Source.
Position);Count = 0 then exit;Count >= SizeOf(TAESBuffer) do:= Source. Read
(TempIn, SizeOf(TempIn)); // СчитываемданныеизпотокаDone < SizeOf(TempIn)
thenEStreamError. Create(SReadError);(TempIn, ExpandedKey, TempOut); flag = false then
// Вывод входного и выходного блоков
FmStop. EditIn. Text:= IntToHex (TempIn[0],
2)+IntToHex (TempIn[1], 2)+(TempIn[2], 2)+IntToHex (TempIn[3], 2)+IntToHex
(TempIn[4], 2)+(TempIn[5], 2)+IntToHex (TempIn[6], 2)+IntToHex (TempIn[7],
2)+(TempIn[8], 2)+IntToHex (TempIn[9], 2)+IntToHex (TempIn[10], 2)+(TempIn[11],
2)+IntToHex (TempIn[12], 2)+IntToHex (TempIn[13], 2)+(TempIn[14], 2)+IntToHex
(TempIn[15], 2);
. EditOut. Text:= IntToHex (TempOut[0], 2)+IntToHex
(TempOut[1], 2)+(TempOut[2], 2)+IntToHex (TempOut[3], 2)+IntToHex (TempOut[4],
2)+(TempOut[5], 2)+IntToHex (TempOut[6], 2)+IntToHex (TempOut[7],
2)+(TempOut[8], 2)+IntToHex (TempOut[9], 2)+IntToHex (TempOut[10],
2)+(TempOut[11], 2)+IntToHex (TempOut[12], 2)+IntToHex (TempOut[13],
2)+(TempOut[14], 2)+IntToHex (TempOut[15], 2);
//FmStop;:= Dest. Write (TempOut,
SizeOf(TempOut));. Write (TempOut, SizeOf(TempOut));
. MemoOut. Text:= st. DataString;Form1.
RadioGroup1. ItemIndex = 1 then:= GetTickCount;.
ProcessMessages;(GetTickCount-tick)>StrToInt (Form1.editDelay. Text);;Done
< SizeOf(TempOut) thenEStreamError. Create(SWriteError);(Count,
SizeOf(TAESBuffer));; //whileCount > 0 then:= Source. Read (TempIn,
Count);Done < Count thenEStreamError. Create(SReadError);(TempIn[Count],
SizeOf(TempIn) - Count, 0);(TempIn, ExpandedKey, TempOut);flag = false then
begin
// Вывод входного и выходного блоков
FmStop. EditIn. Text:= IntToHex (TempIn[0],
2)+IntToHex (TempIn[1], 2)+(TempIn[2], 2)+IntToHex (TempIn[3], 2)+IntToHex
(TempIn[4], 2)+(TempIn[5], 2)+IntToHex (TempIn[6], 2)+IntToHex (TempIn[7],
2)+(TempIn[8], 2)+IntToHex (TempIn[9], 2)+IntToHex (TempIn[10], 2)+(TempIn[11],
2)+IntToHex (TempIn[12], 2)+IntToHex (TempIn[13], 2)+(TempIn[14], 2)+IntToHex
(TempIn[15], 2);
. EditOut. Text:= IntToHex (TempOut[0],
2)+IntToHex (TempOut[1], 2)+(TempOut[2], 2)+IntToHex (TempOut[3], 2)+IntToHex
(TempOut[4], 2)+(TempOut[5], 2)+IntToHex (TempOut[6], 2)+IntToHex (TempOut[7],
2)+(TempOut[8], 2)+IntToHex (TempOut[9], 2)+IntToHex (TempOut[10],
2)+(TempOut[11], 2)+IntToHex (TempOut[12], 2)+IntToHex (TempOut[13],
2)+(TempOut[14], 2)+IntToHex (TempOut[15], 2);
//FmStop;:= Dest. Write (TempOut,
SizeOf(TempOut));. Write (TempOut, SizeOf(TempOut));. MemoOut. Text:= st.
DataString;Form1. RadioGroup1. ItemIndex = 0 then:= GetTickCount;.
ProcessMessages;(GetTickCount-tick)>StrToInt (Form1.editDelay. Text);;Done
< SizeOf(TempOut) thenEStreamError. Create(SWriteError);;. Free;.
Label_Status. Caption:= 'Шифрованиезавершено';;
// ДешифрованиеDecryptAESStreamECB
(Source: TStream; Count: cardinal;Key: TAESKey128; Dest: TStream);:
TAESExpandedKey128;(Key, ExpandedKey);
// Расширениеключадлядешифрования(Source,
Count, ExpandedKey, Dest);
// Дешифрование;DecryptAESStreamECB
(Source: TStream; Count: cardinal;ExpandedKey: TAESExpandedKey128; Dest:
TStream);: integer;, TempOut: TAESBuffer;: cardinal;: TStringStream;:=
TStringStream. Create('');Count = 0 then. Position:= 0;:= Source. Size;Count:=
Min (Count, Source. Size - Source. Position);Count = 0 then exit;(Count mod
SizeOf(TAESBuffer)) > 0 thenEAESError. Create(SInvalidInBufSize);Count >=
SizeOf(TAESBuffer) do:= Source. Read (TempIn, SizeOf(TempIn));Done <
SizeOf(TempIn) thenEStreamError. Create(SReadError);(TempIn, ExpandedKey,
TempOut); flag = false then
// Вывод входного и выходного блоков
FmStop. EditIn. Text:= IntToHex (TempIn[0],
2)+IntToHex (TempIn[1], 2)+(TempIn[2], 2)+IntToHex (TempIn[3], 2)+IntToHex
(TempIn[4], 2)+(TempIn[5], 2)+IntToHex (TempIn[6], 2)+IntToHex (TempIn[7],
2)+(TempIn[8], 2)+IntToHex (TempIn[9], 2)+IntToHex (TempIn[10], 2)+(TempIn[11],
2)+IntToHex (TempIn[12], 2)+IntToHex (TempIn[13], 2)+(TempIn[14], 2)+IntToHex
(TempIn[15], 2);. EditOut. Text:= IntToHex (TempOut[0], 2)+IntToHex
(TempOut[1], 2)+(TempOut[2], 2)+IntToHex (TempOut[3], 2)+IntToHex (TempOut[4],
2)+(TempOut[5], 2)+IntToHex (TempOut[6], 2)+IntToHex (TempOut[7],
2)+(TempOut[8], 2)+IntToHex (TempOut[9], 2)+IntToHex (TempOut[10], 2)+(TempOut[11],
2)+IntToHex (TempOut[12], 2)+IntToHex (TempOut[13], 2)+(TempOut[14],
2)+IntToHex (TempOut[15], 2);
//FmStop;. Write (TempOut, SizeOf(TempOut));
. MemoOut. Text:= stt. DataString;Form1.
RadioGroup1. ItemIndex = 1 then:= GetTickCount;. ProcessMessages;(GetTickCount-tick)>StrToInt
(Form1.editDelay. Text);;:= Dest. Write (TempOut, SizeOf(TempOut));Done <
SizeOf(TempOut) thenEStreamError. Create(SWriteError);(Count,
SizeOf(TAESBuffer));;. Free;. Label_Status. Caption:= 'Дешифрованиезавершено';;TForm1.
Button1Click (Sender: TObject);stpath, stext: string;OpenDialog1. Execute =
True then. Text:= OpenDialog1. FileName;. Lines. LoadFromFile (Edit1.text);:=
Edit1. Text;:= ExtractFileDir(Fpath);:= ExtractFileExt(FPath);CBOpt. Text = «Шифрование» then.
Caption:= 'Имязашифрованогофайла:';:= stpath +
'\EncodedFile'+stExt;. Caption:= FPath;. Caption:= 'Имядешифрованогофайла:';
:= stpath + '\DecodedFile'+stExt;. Caption:=
FPath;;;;TForm1. Button2Click (Sender: TObject);, Dest: TFileStream;, DestFile:
string;, Stop: cardinal;: integer;
Key: TAESKey128; // Длина ключа и блока 128 бит
// ШифрованиеCBOpt. Text = «Шифрование» then_Status.
Caption:= 'Шифрование…';;:=
TFileStream. Create (Edit1. Text, fmOpenRead); // Открываемфайлдлячтения. Caption:=
IntToStr (Source. Size div 1024) + ' KB'; // Выводразмерафайла;:= Fpath; // Файлназначения:=
TFileStream. Create (DestFile, fmCreate); // Создаемновыйфайлилипереписываемужеимеющийся:= Source. Size; // Определение
размера источника. WriteBuffer (Size, SizeOf(Size)); // Задаем размер буфера
назначения
FillChar (Key, SizeOf(Key), 0); // Заполняемключнулями(PChar(Edit2.
Text)^, Key, Min (SizeOf(Key), Length (Edit2. Text))); // Вначалоключазаписываемпароль:=
GetTickCount;(Source, 0, Key, Dest);:= GetTickCount;_Time. Caption:= IntToStr
(Stop - Start) + ' ms';;. Free;;. Free;;;CBOpt. Text = «Дешифрование» then
// Дешифрование_Status. Caption:= 'Дешифрование…';;:=
TFileStream. Create (Edit1. Text, fmOpenRead); // Источник - зашифрованныйфайл. ReadBuffer
(Size, SizeOf(Size)); // Считывание Size данныхизпотока:= fpath;(Key,
SizeOf(Key), 0); // Заполняемключнулями(PChar(Edit2. Text)^, Key, Min (SizeOf(Key),
Length (Edit2. Text))); // Вначалоключазаписываемпароль:= Fpath;:= TFileStream.
Create (DestFile, fmCreate); // Назначение:= GetTickCount;(Source,
Source. Size - Source. Position, Key, Dest);. Size:= Size;:=
GetTickCount;_Time. Caption:= IntToStr (Stop - Start) + ' ms';;. Free;;.
Free;;;;TForm1. ButtonStopClick (Sender: TObject);:= true;. ShowModal;.
ProcessMessages;not Flag;;TForm1.CBOptChange (Sender: TObject);CBOpt. Text = «Шифрование» then.
Caption:= 'Шифровать';. Caption:=
'Имязашифрованногофайла';. Caption:=
'Дешифровать';. Caption:=
'Имя Дешифрованного файла';;;TForm1.
FormActivate (Sender: TObject);:= false;;TForm1. RadioGroup1Click (Sender:
TObject);RadioGroup1. ItemIndex = 0 then EditDelay. Enabled:= false else.
Enabled:= true;;TForm1.MFExitClick (Sender: TObject);;;TForm1.MFChooseClick
(Sender: TObject);. Click;;TForm1. FormCreate (Sender: TObject);. HelpFile:=
GetCurrentDir +'\AES.hlp';;TForm1.MHHelpClick (Sender: TObject);. HelpCommand
(HELP_CONTENTS, 1);
end;.
Заключение
Среди способов защиты информации наиболее важным считается
криптографический. Он предусматривает такое преобразование информации, при
котором она становится доступной для прочтения лишь обладателю некоторого
секретного параметра (ключа). В последние годы область применения криптографии
значительно расширилась. Ее стали повседневно использовать многие организации,
коммерческие фирмы, частные лица, СМИ.
В данной курсовой работе изучается алгоритм шифрования
данных AES: его история создания, описание и программная реализация.
Список использованной литературы
1. Религии
мира. Справочник. - Пер. с англ.: М.: Белфаксиздатгрупп, 1994.
2. Панасенко
С.П. Алгоритмы шифрования. Специальный справочник. - СПб.: БХВ-Петербург, 2009.
. Технические
средства и методы защиты информации. Учебное пособие для вузов /А.П. Зайцев,
А.А. Шелупанов, Р.В. Мещеряков и др.; под ред. А.П. Зайцева и А.А. Шелупанова.
- 4-е изд., испр. И доп. - М., 2009.
. Прикладная
криптография. Брюс Шнайер, 2-е издание