Правила форума
Внимание! Действует предмодерация
Цитата
СИММЕТРИЧНЫЕ КРИПТОАЛГОРИТМЫ.
Самый популярный и широко применяемый в системах защиты алгоритм
это DES (Data Encrypted Standart), принятый в 1977г Национальным
бюро стандартов США (NBS), ныне называемым Национальным институтом
стандартов и технологий (NIST). Официальное название стандарта
Federel Information Processing Standard 46 (FIPS PUB 46).
Шифруемые данные разбиваются на 64-битные блоки и шифруются
поблочно с использованием ключа 56 бит. Многошаговый (16 раундов)
алгоритм преобразует каждый исходный блок в 64-битный шифрованный
блок. Тот же алгоритм с тем же ключом используется для обратного
преобразования шифрованного блока в исходный вид.
В силу сложности алгоритма DES рассмотрим его суть на учебном
алгоритме S-DES, который разработан в учебных целях профессором
Эдвардом Шейфером (Edward Schaefer) из университета Санта-Клара и
опубликован в 1996г. По свойствам и структуре он подобен DES, но
имеет существенно меньшую размерность и потому проще в освоении,
но практической криптостойкостью не обладает.
Учебный симметричный криптоалгоритм S-DES.
На вход поступают исходные 8-битовые блоки, для шифрования
используется 10-битовый ключ, на основе ключа генерируется 2
подключа по 8 бит и производится 2 раунда шифрования, для дешифрования
используется тот же алгоритм и тот же ключ, но подключи используются
в обратном порядке. Пусть X - исходный блок, Y - результат шифрования,
тогда процесс шифрования:
Y = IP-1( fk2( SW( fk1( IP( X ) ) ) ) )
Процесс дешифрования:
X = IP-1( fk1( SW( fk2( IP( Y ) ) ) ) )
Рассмотрим теперь модули, используемые при шифровании и дешифровании
8-битного блока. Рассмотрим их работу на примере блока: 00001011 (11)
Исходный блок X = 00001011(2) = 11(10)
1. Модуль IP. Шифрование начинается с модуля начальной перестановки
IP , в котором 8 бит исходноо блока переставляются в соотвествии
с таблицей:
IP: (1, 5, 2, 0, 3, 7, 4, 6)
Для нашего примера IP( 00001011 ) = 00011001.
Здесь же укажем таблицу, задающую последний модуль преобразования,
перестановку, обратную начальной IP-1 :
IP-1: (3, 0, 2, 4, 6, 1, 7, 5)
Легко убедиться, что эта перестановка действительно является обратной
по отношению к первой, т.е. IP-1( IP ( X ) ) = X . Примените ее
к результату модуля IP нашего примера и получите исходный 8-битный блок.
2. Модуль fk - это самый сложный компонент, в этом модуле в
преобразовании, кроме 8-битового результата модуля 1, участвует
8-битовый подключ, обозначим его SK (в первом раунде это будет
K1, во втором - K2). Обозначим L и R - левую и правую половинки
(по 4 бита) входного блока, а F() - некоторое преобразование в
пространстве 4-х битовых строк, не обязательно взаимно-однозначное,
подключ SK является параметром этого преобразования. Тогда модуль
fk описывается следующим образом:
fk( L, R ) = ( L + F( R, SK ) , R )
где + -- обозначает побитовую операцию XOR
Правая половинка R без изменения передается на выход модуля и
параллельно - на вход нелинейной функции F, зависящей также от
подключа SK. Результат функции F(R,SK) складывается по операции XOR
со входной левой полвинкой и передается на выход в качастве левой
половинки. Итого на выходе опять 8-битовый блок.
Рассмотрим теперь нелинейную функцию F(R,SK). Она состоит из следующих
модулей:
2.1. Входной блок функции ( 4-х битная правая половинка R) расширяется
с перестановкой (модуль E/P) до 8 бит согласно следующей таблице:
E/P: (3, 0, 1, 2, 1, 2, 3, 0)
В нашем примере для правой половинки R (1001) на выходе модуля
E/P будет получен результат: (11000011)
2.2 8-битовый результат модуля 2.1 складывается по операции XOR
с 8-битовым подключом SK, 8-битовый результат представим в виде
таблицы из 2-х строк (левые 4 бита -- 0-я строка, следующие 4
бита - 1-я строка):
В нашем примере подключ К1: 00100001, результат модуля E/P:
11000011, результат операции XOR: 11100010, представим результат в
виде таблицы:
1 1 1 0
0 0 1 0
2.3. Матрицы кодирования (S-матрицы). Каждая строка результата
п.2.2. подвергается преобразованию по своей S-матрице (матрица
S0 служит для сжатия 0-й строки, а матрица S1 - для сжатия 1-й
строки). В алгоритма S-DES всего 2 S-матрицы (S0 и S1). На вход
каждой S-матрицы подаются по 4 бита, на выходе получается по 2
бита.
S0:
1 0 3 2
3 2 1 0
0 2 1 3
3 1 0 2
S1:
2 3 1 0
1 0 2 3
0 1 3 2
3 0 2 1
Эти S-модули работают следующим образом. последний и предпоследний
биты входной последовательности рассматриваются как 2-битовое
число, определяющее номер строки S-матрицы, а первый и нулевой
как число, определяющее номер столбца. На пересечении соотвествующих
строки и столбца находится число, задаюшее 2-битовое выходное
значение.
В нашем примере на вход матрицы S0 поступает последовательность 1110.
последний и предпоследний биты дают число 11, т.е. номер строки -- 3.
Первый и нулевой биты дают число 10, т.е. номер столбца -- 2.
В матрице S0 на пересечении строки 3 и столбца 2 стоит число 0,
в битовом представлении это 00 . Таким образом входная 4-битовая
последовательность 1110 преобразовалась в выходную 2-битовую
последовательность 00.
На вход матрицы S1 поступает последовательность 0010. На пересечении
строки 0 и столбца 2 матрицы S1 стоит число 1 (в битовом представлении
01). Таким образом входная последовательность 0010 преобразовалась
в выходную 01.
Сцепляя (concatenation) результаты на выходе S-матриц получаем
итоговый результат модуля 2.3: 0001. Итак 8-битовая
последовательность на входе модуля S-матриц (2.3) 11100010
преобразована в 4-х битовую последовательность 0001.
2.4. Перестановка P4 задается таблицей:
P4: (0, 1, 2, 3)
Т.е. 4-му биту присваивается значение 0-го, 3-му - значение первого и т.д.
В нашем примере последовательность 0001 превращается в
последовательность 1000 . Это и есть результат функции F( R, SK ).
2.5. Полученный результат функции F( R, SK ) складывается с
помощью побитовой операции XOR с левой половинкой битовой
последовательности на входе модуля fk (п.2). Полученный результат
операции XOR cцепляется (concatenation) с правой половинкой
входной последовательности модуля fk (п.2).
В нашем примере входная последовательность модуля fk (п.2)
00011001, отделим левую и правую половинки: 0001 1001.
Результат L + F( R, SK ) = 0001 XOR 1000 = 1001.
Сцепляем этот результат с правой половинкой и получаем итоговый
результат модуля fk в первом раунде алгоритма:
1001 1001 = 10011001.
3. Модуль SW -- это перестановка левой и правой половинок входной
8-битовой последовательности.
Для нашего примера входная последовательность 10011001,
на выходе получаем 10011001. Это результат первого раунда алгоритма.
Во втором раунде входная последовательность на модуле fk:
IP-1( 00101001 ) = 10000011
шифрованный блок Y = 10000011
Дешифрование проводится по тому же самому алгоритму, что и шифрование,
но порядок подачи подключей в раунды обратный (в первом раунде - последний
подключ, а в последнем раунде - первый подключ).
Самый популярный и широко применяемый в системах защиты алгоритм
это DES (Data Encrypted Standart), принятый в 1977г Национальным
бюро стандартов США (NBS), ныне называемым Национальным институтом
стандартов и технологий (NIST). Официальное название стандарта
Federel Information Processing Standard 46 (FIPS PUB 46).
Шифруемые данные разбиваются на 64-битные блоки и шифруются
поблочно с использованием ключа 56 бит. Многошаговый (16 раундов)
алгоритм преобразует каждый исходный блок в 64-битный шифрованный
блок. Тот же алгоритм с тем же ключом используется для обратного
преобразования шифрованного блока в исходный вид.
В силу сложности алгоритма DES рассмотрим его суть на учебном
алгоритме S-DES, который разработан в учебных целях профессором
Эдвардом Шейфером (Edward Schaefer) из университета Санта-Клара и
опубликован в 1996г. По свойствам и структуре он подобен DES, но
имеет существенно меньшую размерность и потому проще в освоении,
но практической криптостойкостью не обладает.
Учебный симметричный криптоалгоритм S-DES.
На вход поступают исходные 8-битовые блоки, для шифрования
используется 10-битовый ключ, на основе ключа генерируется 2
подключа по 8 бит и производится 2 раунда шифрования, для дешифрования
используется тот же алгоритм и тот же ключ, но подключи используются
в обратном порядке. Пусть X - исходный блок, Y - результат шифрования,
тогда процесс шифрования:
Y = IP-1( fk2( SW( fk1( IP( X ) ) ) ) )
Процесс дешифрования:
X = IP-1( fk1( SW( fk2( IP( Y ) ) ) ) )
Рассмотрим теперь модули, используемые при шифровании и дешифровании
8-битного блока. Рассмотрим их работу на примере блока: 00001011 (11)
Исходный блок X = 00001011(2) = 11(10)
1. Модуль IP. Шифрование начинается с модуля начальной перестановки
IP , в котором 8 бит исходноо блока переставляются в соотвествии
с таблицей:
IP: (1, 5, 2, 0, 3, 7, 4, 6)
Для нашего примера IP( 00001011 ) = 00011001.
Здесь же укажем таблицу, задающую последний модуль преобразования,
перестановку, обратную начальной IP-1 :
IP-1: (3, 0, 2, 4, 6, 1, 7, 5)
Легко убедиться, что эта перестановка действительно является обратной
по отношению к первой, т.е. IP-1( IP ( X ) ) = X . Примените ее
к результату модуля IP нашего примера и получите исходный 8-битный блок.
2. Модуль fk - это самый сложный компонент, в этом модуле в
преобразовании, кроме 8-битового результата модуля 1, участвует
8-битовый подключ, обозначим его SK (в первом раунде это будет
K1, во втором - K2). Обозначим L и R - левую и правую половинки
(по 4 бита) входного блока, а F() - некоторое преобразование в
пространстве 4-х битовых строк, не обязательно взаимно-однозначное,
подключ SK является параметром этого преобразования. Тогда модуль
fk описывается следующим образом:
fk( L, R ) = ( L + F( R, SK ) , R )
где + -- обозначает побитовую операцию XOR
Правая половинка R без изменения передается на выход модуля и
параллельно - на вход нелинейной функции F, зависящей также от
подключа SK. Результат функции F(R,SK) складывается по операции XOR
со входной левой полвинкой и передается на выход в качастве левой
половинки. Итого на выходе опять 8-битовый блок.
Рассмотрим теперь нелинейную функцию F(R,SK). Она состоит из следующих
модулей:
2.1. Входной блок функции ( 4-х битная правая половинка R) расширяется
с перестановкой (модуль E/P) до 8 бит согласно следующей таблице:
E/P: (3, 0, 1, 2, 1, 2, 3, 0)
В нашем примере для правой половинки R (1001) на выходе модуля
E/P будет получен результат: (11000011)
2.2 8-битовый результат модуля 2.1 складывается по операции XOR
с 8-битовым подключом SK, 8-битовый результат представим в виде
таблицы из 2-х строк (левые 4 бита -- 0-я строка, следующие 4
бита - 1-я строка):
В нашем примере подключ К1: 00100001, результат модуля E/P:
11000011, результат операции XOR: 11100010, представим результат в
виде таблицы:
1 1 1 0
0 0 1 0
2.3. Матрицы кодирования (S-матрицы). Каждая строка результата
п.2.2. подвергается преобразованию по своей S-матрице (матрица
S0 служит для сжатия 0-й строки, а матрица S1 - для сжатия 1-й
строки). В алгоритма S-DES всего 2 S-матрицы (S0 и S1). На вход
каждой S-матрицы подаются по 4 бита, на выходе получается по 2
бита.
S0:
1 0 3 2
3 2 1 0
0 2 1 3
3 1 0 2
S1:
2 3 1 0
1 0 2 3
0 1 3 2
3 0 2 1
Эти S-модули работают следующим образом. последний и предпоследний
биты входной последовательности рассматриваются как 2-битовое
число, определяющее номер строки S-матрицы, а первый и нулевой
как число, определяющее номер столбца. На пересечении соотвествующих
строки и столбца находится число, задаюшее 2-битовое выходное
значение.
В нашем примере на вход матрицы S0 поступает последовательность 1110.
последний и предпоследний биты дают число 11, т.е. номер строки -- 3.
Первый и нулевой биты дают число 10, т.е. номер столбца -- 2.
В матрице S0 на пересечении строки 3 и столбца 2 стоит число 0,
в битовом представлении это 00 . Таким образом входная 4-битовая
последовательность 1110 преобразовалась в выходную 2-битовую
последовательность 00.
На вход матрицы S1 поступает последовательность 0010. На пересечении
строки 0 и столбца 2 матрицы S1 стоит число 1 (в битовом представлении
01). Таким образом входная последовательность 0010 преобразовалась
в выходную 01.
Сцепляя (concatenation) результаты на выходе S-матриц получаем
итоговый результат модуля 2.3: 0001. Итак 8-битовая
последовательность на входе модуля S-матриц (2.3) 11100010
преобразована в 4-х битовую последовательность 0001.
2.4. Перестановка P4 задается таблицей:
P4: (0, 1, 2, 3)
Т.е. 4-му биту присваивается значение 0-го, 3-му - значение первого и т.д.
В нашем примере последовательность 0001 превращается в
последовательность 1000 . Это и есть результат функции F( R, SK ).
2.5. Полученный результат функции F( R, SK ) складывается с
помощью побитовой операции XOR с левой половинкой битовой
последовательности на входе модуля fk (п.2). Полученный результат
операции XOR cцепляется (concatenation) с правой половинкой
входной последовательности модуля fk (п.2).
В нашем примере входная последовательность модуля fk (п.2)
00011001, отделим левую и правую половинки: 0001 1001.
Результат L + F( R, SK ) = 0001 XOR 1000 = 1001.
Сцепляем этот результат с правой половинкой и получаем итоговый
результат модуля fk в первом раунде алгоритма:
1001 1001 = 10011001.
3. Модуль SW -- это перестановка левой и правой половинок входной
8-битовой последовательности.
Для нашего примера входная последовательность 10011001,
на выходе получаем 10011001. Это результат первого раунда алгоритма.
Во втором раунде входная последовательность на модуле fk:
L R
1001 1001
E/P( R ) = 11000011
+ K2 00100001
= 11001001
1100 1001
1100 --> S0[ 3,0 ] = 3 --> 11
1001 --> S1[ 2,1 ] = 1 --> 01
1101
P4( 1101 ) = 1011
+ L 1001
= 0010
,R = 1001
IP-1( 00101001 ) = 10000011
шифрованный блок Y = 10000011
Дешифрование проводится по тому же самому алгоритму, что и шифрование,
но порядок подачи подключей в раунды обратный (в первом раунде - последний
подключ, а в последнем раунде - первый подключ).
генерация ключей и общая схема алгоритма:
первый раунд S-DES:
второй раунда S-DES:
Программа разбита на 3 модуля
* unit uBits -- модуль для работы с двоичным представлением числа
* unit uKeys -- модуль содержащий подпрограммы генерации подключей K1 и K2
* unit uSDES -- модуль содержащий подпрограммы кодирования данных
UNIT uBits
unit uBits;
interface
const {9, 8, 7, 6, 5, 4, 3, 2, 1, 0} { биты }
P10: array [0..9] of Byte = (2, 4, 1, 6, 3, 9, 0, 8, 7, 5); { модуль P10 }
P8: array [0..7] of Byte = (5, 2, 6, 3, 7, 4, 9, 8); { модуль P8 }
P4: array [0..3] of Byte = (0, 1, 2, 3); { модуль P4 (в этом примере просто переворот)}
{0, 1, 2, 3, 4, 5, 6, 7} { биты }
{ модуль IP }
IP: array [0..7] of Byte = (1, 5, 2, 0, 3, 7, 4, 6);
{ модуль IP_ }
IP_: array [0..7] of Byte = (3, 0, 2, 4, 6, 1, 7, 5);
{ модуль EP } {0, 1, 2, 3, 4, 5, 6, 7} { биты }
EP: array [0..7] of Byte = (3, 0, 1, 2, 1, 2, 3, 0);
{ матрица кодирования S0 }
S0: array [0..3, 0..3] of Byte = (
(1, 0, 3, 2),
(3, 2, 1, 0),
(0, 2, 1, 3),
(3, 1, 0, 2)
);
{ матрица кодирования S1 }
S1: array [0..3, 0..3] of Byte = (
(2, 3, 1, 0),
(1, 0, 2, 3),
(0, 1, 3, 2),
(3, 0, 2, 1)
);
type
TBit = 0..1;
TBit2 = array [0..1] of TBit;
TBit4 = array [0..3] of TBit;
TBit8 = array [0..7] of TBit;
TBit10 = array [0..9] of TBit;
{ ф-я вернет бит bit_num числа value }
function get_bit(const value: Integer; const bit_num: Byte): TBit;
{ пр-а установит бит bit_num числа value в значение bit_value }
procedure set_bit(var value: Integer; const bit_num: Byte; const bit_value: TBit);
{ печать массива бит, длиной bits_count }
procedure print_bits(const bits: array of TBit; const bits_count: Byte);
{ пр-а сохранит в массив bits биты числа value, нулевой бит = bits[0] }
procedure int2bits(const value: Integer; var bits: array of TBit; const bits_count: Byte);
{ ф-я вернет десятичное значение, соотв. двоичному числу, хранящемуся в bits }
function bits2int(const bits: array of TBit; const bits_count: Byte): Integer;
{ пр-а разбивает массив битов source длиной source_len
на две части part1 и part1,
пример:
(* 0,1,2,3,4,5,6,7 *) -- индексы в массиве
source = (1,1,0,0,1,0,1,0) = 01010011(2)
part1 = (1, 0, 1, 0) = 0101(2)
part2 = (1, 1, 0, 0) = 0011(2)
}
procedure cat_bits (
const source: array of TBit;
var part1, part2: array of TBit;
const source_len: Byte
);
{ пр-а "склеивает" 2 последовательности бит part1 и part2,
длины которых равны part_len в одну последовательность destination,
пример:
part1 = (1, 1, 1, 0) = 0111(2)
+
part2 = (0, 0, 0, 1) = 1000(2)
=
destination = (0, 0, 0, 1, 1, 1, 1, 0) = 01111000
}
procedure concat_bits (
const part1, part2: array of TBit;
var destination: array of TBit;
const part_len: Byte
);
implementation
function get_bit(const value: Integer; const bit_num: Byte): TBit;
var
buffer: array[0 .. 15] of TBit;
i: integer;
begin
fillchar(buffer, 16, 0);
for i := 0 to pred(sizeof(value) * 8) do begin
buffer[pred(sizeof(value) * 8) - i] := (value shr i) and $1;
end;
get_bit := buffer[pred(sizeof(value) * 8) - bit_num];
end;
procedure set_bit(var value: Integer; const bit_num: Byte;
const bit_value: TBit);
var
tmp: Integer;
begin
tmp := round(exp(bit_num * ln(2)));
if bit_value = 1 then
value := value or tmp
else if (value and tmp) = tmp then
value := value xor tmp
end;
procedure print_bits(const bits: array of TBit; const bits_count: Byte);
var
i: Byte;
begin
writeln;
for i := bits_count - 1 downto 0 do
write(bits[i]);
end;
procedure int2bits(const value: Integer; var bits: array of TBit;
const bits_count: Byte);
var
i: Byte;
begin
for i := 0 to bits_count - 1 do
bits[i] := get_bit(value, i);
end;
function bits2int(const bits: array of TBit; const bits_count: Byte): Integer;
var
i: Byte;
value: Integer;
begin
value := 0;
for i := 0 to bits_count - 1 do
set_bit(value, i, bits[i]);
bits2int := value;
end;
procedure cat_bits (
const source: array of TBit;
var part1, part2: array of TBit;
const source_len: Byte
);
var
i, middle: Byte;
begin
middle := source_len div 2 - 1;
for i := middle + 1 to source_len - 1 do
part1[i - middle - 1] := source[i];
for i := 0 to middle do
part2[i] := source[i];
end;
procedure concat_bits (
const part1, part2: array of TBit;
var destination: array of TBit;
const part_len: Byte
);
var
i: Byte;
begin
for i := 0 to part_len - 1 do
destination[i] := part2[i];
for i := part_len to 2 * part_len - 1 do
destination[i] := part1[i - part_len];
end;
end.
UNIT uKeys
unit uKeys;
interface
uses uBits;
const
KEY1: Integer = 0; { в этой переменной будет храниться первый ключ }
KEY2: Integer = 0; { в этой переменной будет храниться второй ключ }
{ пр-а генераципи 2-х 8бит ключей из 1-го 10бит ключа }
procedure generate_keys(const key: Integer);
implementation
procedure generate_keys(const key: Integer);
procedure shift(var bits: TBit10);
var
i: Byte;
tmp: TBit;
begin
tmp := bits[9];
for i := 9 downto 6 do
bits[i] := bits[i - 1];
bits[5] := tmp;
tmp := bits[4];
for i := 4 downto 1 do
bits[i] := bits[i - 1];
bits[0] := tmp
end;
procedure module_P8(var bits8: TBit8; const bits10: TBit10);
var
i: Byte;
begin
for i := 0 to 7 do
bits8[i] := bits10[ P8[7 - i] ];
end;
procedure module_P10(var bits10: TBit10);
var
i: Byte;
begin
for i := 0 to 9 do
bits10[i] := get_bit(key, P10[9 - i]);
end;
var
i: Byte;
buff8: TBit8;
buff10: TBit10;
begin
{ сохраняем в buff10 перестановку бит числа key по модулю p10 }
module_P10(buff10);
{ модуль SHIFT1 }
shift(buff10);
{ для получения ключа Key1 выполним перестановку по
модулю P8 для "buff10" }
module_P8(buff8, buff10);
KEY1 := bits2int(buff8, 8); { ------- KEY1 -------- }
{ для получения ключа Key2 выполним сдвиг SHIFT2 и
перестановку получившейся последовательности бит
по модулю P8
}
shift(buff10);
module_P8(buff8, buff10);
KEY2 := bits2int(buff8, 8); { ------- KEY2 -------- }
end;
end.
UNIT uSDES
unit uSDES;
interface
uses uBits, uKeys;
type
TCryptType = (ctCrypt, ctDecrypt);
{ шифрация текстового файла }
procedure crypt_file(const file_in, file_out: String);
procedure decrypt_file(const file_in, file_out: String);
implementation
{ перестановка массива бит bits по модулю IP }
procedure module_IP(var bits: TBit8);
var
i: Byte;
temp: TBit8;
begin
for i := 0 to 7 do
temp[i] := bits[ IP[i] ];
move(temp, bits, sizeof(temp));
end;
{ перестановка массива бит nits по модулю IP_ }
procedure module_IP_(var bits: TBit8);
var
i: Byte;
temp: TBit8;
begin
for i := 0 to 7 do
temp[i] := bits[ IP_[i] ];
move(temp, bits, sizeof(temp));
end;
{ расширение 4-х битовой последователности до 8-ми бит, с
использованием модуля EP }
procedure module_EP(const bits4: TBit4; var bits8: TBit8);
var
i: Byte;
begin
for i := 0 to 7 do
bits8[i] := bits4[ EP[7 - i] ];
end;
{ преобразование 4-битовой последователности по
матрице кодирования S0
}
procedure module_S0(const bits4: TBit4; var bits2: TBit2);
var
row, col: TBit2;
begin
move(bits4[0], col, 2 * sizeof(TBit));
move(bits4[2], row, 2 * sizeof(TBit));
int2bits(S0[ bits2int(row, 2), bits2int(col, 2) ], bits2, 2);
end;
procedure module_S1(const bits4: TBit4; var bits2: TBit2);
var
row, col: TBit2;
begin
move(bits4[0], col, 2 * sizeof(TBit));
move(bits4[2], row, 2 * sizeof(TBit));
int2bits(S1[ bits2int(row, 2), bits2int(col, 2) ], bits2, 2);
end;
procedure module_P4(const part1, part2: TBit2; var bits: TBit4);
var
i: Byte;
buff4: TBit4;
begin
concat_bits(part1, part2, bits, 2);
for i := 0 to 3 do
buff4[i] := bits[ P4[3 - i] ];
move(buff4, bits, sizeof(buff4));
end;
procedure s_des(
const left_in, right_in: TBit4;
var left_out, right_out: TBit4;
const key: Integer
);
var
buff8A: TBit8;
s0In, s1In, p4Out: TBit4;
s0Out, s1Out: TBit2;
temp: Integer;
begin
module_EP(right_in, buff8A);
temp := bits2int(buff8A, 8) xor key;
int2bits(temp, buff8A, 8);
cat_bits(buff8A, s0In, s1In, 8);
module_s0(s0In, s0Out);
module_s1(s1In, s1Out);
module_p4(s0Out, s1Out, p4Out);
int2bits(bits2int(left_in, 4) xor bits2int(p4Out, 4), left_out, 4);
move(right_in, right_out, sizeof(right_in));
end;
function crypt_byte(const _byte: Byte; const ct: TCryptType): Byte;
var
K1, K2: Integer;
left_in, right_in, left_out, right_out: TBit4;
buff8: TBit8;
begin
if ct = ctCrypt then begin
K1 := KEY1;
K2 := KEY2;
end else begin
K1 := KEY2;
K2 := KEY1;
end;
int2bits(_byte, buff8, 8);
module_IP(buff8);
cat_bits(buff8, left_in, right_in, 8);
s_des(left_in, right_in, left_out, right_out, K1);
s_des(right_out, left_out, left_in, right_in, K2);
concat_bits(left_in, left_out, buff8, 4);
module_IP_(buff8);
crypt_byte := Byte(bits2int(buff8, 8));
end;
procedure crypt_file(const file_in, file_out: String);
var
f_in, f_out: file of byte;
s: String;
i, iEnc: Byte;
begin
assign(f_in, file_in);
reset(f_in);
assign(f_out, file_out);
rewrite(f_out);
while not eof( f_in ) do begin
read(f_in, i);
iEnc := crypt_byte(i, ctCrypt);
write(f_out, iEnc);
end;
close(f_in);
close(f_out)
end;
procedure decrypt_file(const file_in, file_out: String);
var
f_in, f_out: file of byte;
s: string;
i, iDec: Byte;
begin
assign(f_in, file_in);
reset(f_in);
assign(f_out, file_out);
rewrite(f_out);
while not eof ( f_in ) do begin
read(f_in, i);
iDec := crypt_byte(i, ctDecrypt);
write(f_out, iDec);
end;
close(f_in);
close(f_out);
end;
end.
тестовая программа:
uses crt, uBits, uKeys, uSDES;
var
key: Integer;
begin
clrscr;
write('input key: '); readln(key);
if ( key < 0 ) or ( key > 1023 ) then begin
writeln('bad key');
readln;
halt(1);
end;
generate_keys(key);
writeln('encoding -- start ...');
crypt_file('c:\my_file.txt', 'c:\crypt_file.des');
decrypt_file('c:\crypt_file.des', 'c:\decrypt_file.txt');
writeln('encoding -- complete.');
readln;
end.
