2.2.2 Процедура расшифрования модифицированного RC6
Расшифрование выполняется следующим образом (изменения помечены жирным шрифтом):
Вход:
Исходный текст, записанный в 6-и w-битовых регистрах A,B,C,D,E,F
Число раундов шифрования (перемешивания) регистров r
Ключевая таблица S[0.. 3r + 3] w-битовых слов
Выход:
Шифрованный текст в регистрах A,B,C,D,E,F
Процедура:
A = A — S[2*r +1]
C = C — S[2*r +2]
E = E – S[2*r +3]
for i = r downto 1 do
begin
(A,B,C,D,E,F) = (F,A,B,C,D,E)
v = (D * (2 * D + 1))<< log2w
u = (B * (2 * B + 1))<< log2w
x = (F * (2 * F + 1))<< log2w
A = (A — S[2*i])>> x) xor t
C = (C — S[2*i+1]>> t) xor u
E = (E – S[2*i+2]>> u) xor x
end
D = D — S[1]
B = B — S[0]
F = F – S[2]
Программная реализация алгоритма расшифрования:
//Расшифрование регистров в блоке по алгоритму RC6:
procedure DeCryption;
var
Temp, A, B, C, D, E, F, t, v, w: Dword;
i: Byte;
begin
//Расшифрование производится для блока в 6-и 32-x битовых регистрах Buf:
A := Buf[1];
B := Buf[2];
C := Buf[3];
D := Buf[4];
E := Buf[5];
F := Buf[6];
A := A — S[2*r+1];
C := C — S[2*r+2];
E := E — S[2*r+3];
for i:=r downto 1 do
begin
Temp := F;
F := E;
E := D;
D := C;
C := B;
B := A;
A := Temp;
t := LRot32(B*(2*B+1), 5);
v := LRot32(D*(2*D+1), 5);
w := LRot32(F*(2*F+1), 5);
A := RRot32(A-S[2*i], w) xor t;
C := RRot32(C-S[2*i+1], t) xor v;
E := RRot32(E-S[2*i+2], v) xor w;
end;
B := B — S[0];
D := D — S[1];
F := F — S[2];
PreBuf := Buf;
Buf[1] := A;
Buf[2] := B;
Buf[3] := C;
Buf[4] := D;
Buf[5] := E;
Buf[6] := F;
end;
Расшифрование аналогично шифрованию.
2.2.3 Процедура генерации ключа модифицированного RC6
Алгоритм вычисления ключей для RC6 (изменения помечены жирным шрифтом):
Вход:
Определенный пользователем b-байтовый ключ, предварительно загруженный в массив L[0..e-1]
Число раундов шифрования (перемешивания) регистров r
Выход:
Ключевая таблица S[0.. 2r + 3] w-битовых слов
Процедура:
S[0] = P32
for i = 1 to 2*r+3 do
S[i] = S[i-1] +Q32
v = 3 * max{e,2*r + 4}
A = B = i = j
C = D = i1 = j1
for i = 1 to v do
begin
A = S[i] = (S[i] + A + B) << 3
B = L[j] = (L[j] + A + B) <<(AA + BB)
C = S[i1] = (S[i1] + C + D) >>3
D = L[j1] = (L[j1) + C + D) >>(CC + DD)
i = (i+1) mod (2*r+4)
j = (j+1) mod e
i1 = (i1+1) mod (2*r+4)
j1 = (j1+1) mod e
end
Программная реализация генерации ключа:
//Генерация ключа шифрования:
procedure Tfmmain.MakeEnKey;
var
L: array [0..63] of Dword;
e, k, v, i, j, i1, j1: Byte;
A, B, C, D: Dword;
begin
Key := fmEncrypt.EdKey.Text;
Len := Length(Key);
//Записываем байты в массив из C слов, начиная с младшего, дописываем в конце нули:
FillChar(L, Sizeof(L), 0);
Move(Key, L, Len+1);
e := Len div 4;
if Len mod 4 <> 0 then Inc(e);
//Формирование ключевой таблицы S[0;2r+4] 32-битовых слов
S[0] := $B7E15163;
for i:=1 to 2*r+3 do
S[i] := S[i-1] + $9E3779B9;
i := 0; j := 0; i1 := 0; j1 := 0;
A := 0; B := 0; C := 0; D := 0;
if e>2*r+4 then v := 3*e else v := 3*(2*r+4);
for k:=1 to v do
begin
A := LRot32((S[i]+A+B), 3);
S[i] := A;
B := LRot32((L[j]+A+B), (A+B));
L[j] := B;
i := (i+1) mod (2*r+4);
j := (j+1) mod e;
C := RRot32((S[i1]+C+D), 3);
S[i1] := C;
D := RRot32((L[j1]+C+D), (C+D));
L[j1] := D;
i1 := (i1+1) mod (2*r+4);
j1 := (j1+1) mod e;
end;
end;
Алгоритм вычисления ключей для RC6-w/r/b выглядит следующим образом.
Пользователь задает ключ длиной b байтов. Достаточное число ненулевых байтов дописывается в конец, чтобы получилось целое число слов. Затем эти байты записываются, начиная с младшего в массив из слов, т.е. первый байт ключа записывается в L[0], и т.д., а L[e-1] при необходимости дополняется со стороны старших разрядов нулевыми байтами. В результате работы алгоритма генерации ключей будет вычислено 2r + 4 слов, которые будут записаны в массиве ключевой таблицы S[0.. 2r + 3].
Константы P32 = b7e15163 и Q32 = 9e3779b9 – это константы, получаемые из двоичного представления е – 2, где е – основание натурального логарифма, и ф – 1, где ф – золотое сечение соответственно.
После того, как пользователь задает исходный ключ, который записывается в исходный массив L, начинает формироваться ключевая таблица S. Первый элемент S = b7e15163. Далее, в цикле для всех 2*r+3 элементов таблицы S ее элементы задаются следующим образом: каждый следующий элемент равен предыдущему плюс константа 9e3779b9. Далее, определяется, что больше, число ненулевых элементов массива L или 2*r+4. Это значение, помноженное на 3, используется далее в качестве предела итераций для цикла.
В новом цикле снова преобразуются элементы таблицы S. Каждый элемент S[i] равен сумме самого себя, предыдущего элемента S[i-1] и предыдущего элемента L[j-1]. К этому значению применяется циклический сдвиг влево на 3 бит. Таким же образом в этом же цикле рассчитывается j-й элемент массива L, за исключение того, что сдвиг влево производится на число бит, равное сумме L[j] и S[i]. Каждые следующие индексы массивов i и j равны самим себе, взятым с увеличением на 1 по модулю (2*r+4) или e соответственно.
Аналогичным образом происходят преобразования для элементов i1 и j1. Каждый элемент S[i1] равен сумме самого себя, предыдущего элемента S[i1-1] и предыдущего элемента L[j1-1]. К этому значению применяется циклический сдвиг вправо на 3 бит. Таким же образом в этом же цикле рассчитывается j1-й элемент массива L, за исключение того, что сдвиг вправо производится на число бит, равное сумме L[j1] и S[i1]. Каждые следующие индексы массивов i1 и j1 равны самим себе, взятым с увеличением на 1 по модулю (2*r+4) или e соответственно.
В итоге, модифицированный алгоритм RC6 заметно изменился, дополнился новыми преобразованиями: в процедуре шифрования/расшифрования – добавлением 2-х новых регистров E и F, в процедуре генерации ключа – расширением цикла генерации ключа новыми элементами i1 и j1. В связи с этим модифицированный алгоритм стал заметно более криптостойким к криптоанализу, т.к. с добавлением новых элементов его внутренняя структура усложнилась, в ущерб скорости генерации ключа. Однако уменьшилась скорость шифрования и расшифрования, т.к. при добавлении 2-х новых регистров общее количество блоков в шифруемом файле стало на порядок меньше, чем в стандартном алгоритме RC6, размер которых 24 байт и 16 байт соответственно. А для микропроцессорных систем на шифрование одного блока, состоящего из 6-и регистров тратится на пару тактов больше, чем для 4-х регистров. В итоге, общее суммарное количество блоков по 6 регистров в шифруемом файле примерно в 1,5 раза меньше, чем у блоков, размер которых 4 регистра, что можно наблюдать в заметном уменьшении скорости шифрования данных.
Следует отметить, что необходимо различать понятия: количество циклов шифрования (перемешивания) регистров в блоке и количество циклов шифрования блоков в файле. Количество циклов шифрования (перемешивания) регистров в блоке позволяет оперировать только с регистрами (четыре или шесть) в одном блоке, меняет местами четные и нечетные регистры, добавляет к ним генерацию ключа. А количество циклов шифрования блоков в файле позволяет брать отдельный блок (16 или 24 байт) и зашифровывает его опять указанное количество раз. Таких блоков в файле может быть бесчисленное множество, о чем говорит размер шифруемого файла.
Таким образом, была сделана попытка к усовершенствованию существующего алгоритма RC6 до версии RC6.1.
3. Практическая реализация и исследование криптостойкости модифицированного RC6
Чтобы понять, каким же образом ведется шифрование/расшифрование файлов, а также подбор пароля, необходимо сначала подробно изучить соответствующие блок-схемы по каждому процессу. К каждой блок-схеме приложено описание. Все блок-схемы справедливы для любого алгоритма RC6, будь-то стандартный или модифицированный. При описании блок-схем в расчет брался модифицированный RC6, где размер блока равен 24 байта, хотя имеет место и стандартный RC6, где размер блока – 16 байт.
В виду того, что RC6 – блочный алгоритм, где происходит шифрование/расшифрование файлов по блокам, то возможно множество вариантов технологии процесса шифрования/расшифрования. В данной работе приведены 2 варианта блок-схем. В программе реализован первый вариант технологии процесса шифрования/расшифрования.
3.1 Блок-схемы процессов шифрующей программы FileCoder на основе RC6
Прежде чем переходить к рассмотрению блок-схем, необходимо, для начала, определиться в их условных обозначениях (Табл. 2)
Табл. 1. Условные обозначения блок-схем
3.1.1 Блок-схемы процесса шифрования файла
Блок-схемы процесса шифрования файла представлены в двух вариантах, каждый из которых имеет свои особенности.
3.1.1.1 Первый вариант блок-схемы процесса шифрования файла
Описание блок-схемы шифрования для первого варианта:
Сначала в конечном файле записываем переменную, содержащую размер исходного незашифрованного файла. Далее, записываем переменную, содержащую количество циклов шифрования исходного файла. В цикле считываем первые 24 байта из исходного файла. Проверяем, если это первые 24 байта, тогда в цикле зашифровываем их указанное количество раз и записываем в конечный файл. Потом еще раз зашифровываем первые 24 байта и записываем в конечный файл. Считываем следующие 24 байта. Проверяем, если это не первые 24 байта, то в цикле зашифровываем их указанное количество раз и записываем в конечный файл. И так далее пока не считаем все блоки в исходном файле. При считывании последнего блока дописываем в его конец нули, если блок окажется менее 24 байт, и также в цикле зашифровываем его указанное количество раз и записываем в конечный файл.
Тем самым итоговый конечный зашифрованный файл содержит в начале 2 4-х байтовых блока. В первый блок входит переменная, содержащая размер исходного незашифрованного файла. Во второй – количество циклов шифрования исходного файла. Третий блок, размер которого 24 байта, зашифрован указанное количество раз, а четвертый зашифрован столько же раз, сколько и третий + еще одно шифрование. Третий и четвертый блоки служат для проверки правильности пароля, введенного при расшифровании, а также они используются в процессе подбора пароля. Все последующие блоки зашифрованы указанное количество раз.
Итого, размер конечного зашифрованного файла на 32 байта больше, чем исходный незашифрованный файл.
Программная реализация процесса шифрования для первого варианта:
//Шифрование блоков по алгоритму RC6:
procedure Tfmmain.Coding;
var
SizeFile, CurrentProgress: integer;
count, n: integer;
begin
AssignFile(f1, FileBegin);
AssignFile(f2, FileEnd);
Reset(f1, 1);
Rewrite(f2, 1);
SizeFile := Filesize(f1);
count:=strtoint(fmEncrypt.Edit3.Text);
i := 0;
BlockWrite(f2, SizeFile, SizeOf(SizeFile), NumWritten);
BlockWrite(f2, count, SizeOf(count), NumWritten);
//Пока не конец файла
repeat
Inc(i);
//Если блок <24 байт, то в конец записываются пробелы
FillChar(Buf, Sizeof(Buf), ord(‘ ‘));
//Считать 24 байта
BlockRead(f1, Buf, SizeOf(Buf), NumRead);
if i=1 then
begin
for n:=1 to Count do EnCryption;
BlockWrite(f2, Buf, SizeOf(Buf), NumWritten);
EnCryption;
BlockWrite(f2, Buf, SizeOf(Buf), NumWritten);
end
else
begin
for n:=1 to Count do EnCryption;
if NumRead <> 0 then BlockWrite(f2,Buf,SizeOf(Buf),
NumWritten);
end;
until (NumRead = 0) Or (SizeOf(Buf) <> NumRead);
CloseFile(f1);
CloseFile(f2);
end;
3.1.1.2 Второй вариант блок-схемы процесса шифрования файла
Описание блок-схемы шифрования для второго варианта:
Сначала в цикле считываем первые 24 байта из исходного файла. Проверяем, если это первые 24 байта, тогда записываем их в первую временную переменную. Зашифровываем первые 24 байта и записываем в конечный файл. Потом еще раз зашифровываем первые 24 байта и также записываем в конечный файл. Из первой временной переменной считываем первые 24 байта, в цикле зашифровываем их указанное количество раз и также записываем в конечный файл. Далее, записываем переменную, содержащую размер исходного незашифрованного файла. Считываем следующие 24 байта. Проверяем, если это не первые 24 байта, то в цикле зашифровываем их указанное количество раз и записываем в конечный файл. И так далее пока не считаем все блоки в исходном файле. При считывании последнего блока дописываем в его конец нули, если блок окажется менее 24 байт, и также в цикле зашифровываем его указанное количество раз и записываем в конечный файл.
Тем самым в итоговом конечном зашифрованном файле первый блок зашифрован 1 раз, второй – 2 раза. Эти два блока служат для проверки правильности пароля, введенного при расшифровании, а также используются в процессе подбора пароля. Третий блок зашифрован указанное количество раз. Четвертый блок, размер которого 4 байта, содержит размер исходного незашифрованного файла. Все последующие блоки зашифрованы указанное количество раз.
Итого, размер конечного зашифрованного файла на 52 байта больше, чем исходный незашифрованный файл.
Программная реализация процесса шифрования для второго варианта:
//Шифрование блоков по алгоритму RC6:
procedure Tfmmain.Coding;
var
SizeFile, CurrentProgress: integer;
count, n: integer;
begin
AssignFile(f1, FileBegin);
AssignFile(f2, FileEnd);
Reset(f1, 1);
Rewrite(f2, 1);
SizeFile := Filesize(f1);
count:=strtoint(fmEncrypt.Edit3.Text);
i := 0;
//Пока не конец файла
repeat
Inc(i);
//Если блок <24 байт, то в конец записываются пробелы
FillChar(Buf, Sizeof(Buf), ord(‘ ‘));
//Считать 24 байта
BlockRead(f1, Buf, SizeOf(Buf), NumRead);
if i=1 then
begin
Temp_Buff:=Buf;
EnCryption;
BlockWrite(f2, Buf, SizeOf(Buf), NumWritten);
EnCryption;
BlockWrite(f2, Buf, SizeOf(Buf), NumWritten);
Buf:=Temp_Buff;
for n:=1 to Count do EnCryption;
BlockWrite(f2, Buf, SizeOf(Buf), NumWritten);
//Записать в файл SizeFile
BlockWrite(f2, SizeFile, SizeOf(SizeFile));
end
else
begin
for n:=1 to Count do EnCryption;
if NumRead <> 0 then BlockWrite(f2, Buf, SizeOf(Buf),
NumWritten);
end;
until (NumRead = 0) Or (SizeOf(Buf) <> NumRead);
CloseFile(f1);
CloseFile(f2);
end;
Исходя из представленных двух вариантах шифрования файла можно сделать вывод, что второй вариант более устойчив к взлому, т.к. не содержит в своем файле переменную, указывающую сколько раз данный файл был зашифрован. Скорость шифрования файлов одинакового размера примерно равны у обоих вариантов процесса шифрования файла. При использовании первого варианта конечный файл на 32 байта больше исходного, а при использовании второго – на 52 байта.
3.1.2 Блок-схемы процесса расшифрования файла
Блок-схемы процесса расшифрования файла представлены в двух вариантах, каждый из которых имеет свои особенности.
3.1.2.1 Первый вариант блок-схемы процесса расшифрования файла
Описание блок-схемы расшифрования для первого варианта:
Сначала считываем и запоминаем в переменной первые 4 байта в исходном зашифрованном файле, которые содержат размер исходного незашифрованного файла. Далее, считываем и запоминаем в переменной следующие 4 байта, содержащие количество циклов шифрования исходного незашифрованного файла. На следующем этапе в цикле считываем 24 байта из исходного файла. Проверяем, если это первые 24 байта, тогда сразу записываем их в первую временную переменную. В цикле расшифровываем первые 24 байта указанное количество раз при шифровании исходного незашифрованного файла и записываем в конечный файл. Считываем следующие 24 байта. Проверяем, если это вторые 24 байта, то расшифровываем их и записываем во вторую временную переменную. Сравниваем равны ли первые 24 байта из первой временной переменной со вторыми 24 байтами из второй временной переменной. Если не равны, то выводим на экран сообщение о неверно набранном пароле. Считываем следующие 24 байта. Проверяем, если это не первые и не вторые 24 байта, то в цикле расшифровываем их указанное количество раз при шифровании исходного незашифрованного файла и записываем в конечный файл. На последнем этапе расшифрования удаляем лишние пробелы из конечного расшифрованного файла, тем самым его размер стал равен исходному незашифрованному файлу.
Тем самым итоговый конечный расшифрованный файл стал на 32 байт меньше, которые содержали контрольные блоки для размера и количества циклов шифрования исходного незашифрованного файла, а также контрольный блок проверки для информирования пользователя о том, правильно ли он ввел пароль при расшифровании файла или нет.
Программная реализация процесса расшифрования для первого варианта:
//Расшифрование блоков по алгоритму RC6:
procedure Tfmmain.DeCoding;
var
SizeFile, CurrentProgress: integer;
n, count: integer;
//Усекает лишние символы в конце файла
lishnie: integer;
begin
AssignFile(f1, FileBegin);
AssignFile(f2, FileEnd);
Reset(f1, 1);
Rewrite(f2, 1);
SizeFile := Filesize(f1);
i:=0;
count:=0;
BlockRead(f1, SizeFile, SizeOf(SizeFile), NumRead);
BlockRead(f1, count, SizeOf(count), NumRead);
//Пока не конец файла
repeat
Inc(i);
//Считать 24 байта
BlockRead(f1, Buf, SizeOf(Buf), NumRead);
//Записываем в Temp_Buff первые НЕРАСШИФРОВАННЫЕ 24 байта,
//расшифровываем n-раз и записываем в конечный файл
if i=1 then
begin
Temp_Buff:= Buf;
for n:=1 to count do DeCryption;
BlockWrite(f2, Buf, SizeOf(Buf), NumWritten);
end
else
//Расшифровываем и записываем в Temp_Buff2 вторые 24 байта
if i=2 then
begin
DeCryption;
Temp_Buff2:= Buf;
//Сравниваем Temp_Buff1 и Temp_Buff2, если не равны, то
//выводим сообщение
if not ((Temp_Buff[1] = Temp_Buff2[1]) and (Temp_Buff[2] =
Temp_Buff2[2]) and (Temp_Buff[3] = Temp_Buff2[3]) and
(Temp_Buff[4] = Temp_Buff2[4]) and (Temp_Buff[5] =
Temp_Buff2[5]) and (Temp_Buff[6] = Temp_Buff2[6])) then
DecodeOK := true else DecodeOK := false;
if not(BStop) then
if DecodeOK then
begin
Application.MessageBox(‘Неверное ключевое слово!’, ‘FileCoder Modified’,
MB_ICONERROR);
break;
end
end
else
begin
for n:=1 to count do DeCryption;
if NumRead <> 0 then BlockWrite(f2, Buf, SizeOf(Buf),
NumWritten);
end;
until (NumRead = 0) Or (SizeOf(Buf) <> NumRead);
lishnie := Filesize(f2) — SizeFile;
Seek(f2, Filesize(f2) — lishnie);
Truncate(f2);
CloseFile(f1);
CloseFile(f2);
end;