unit Unit1;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, Math;

type

TForm1 = class(TForm)

Button1: TButton;

Memo1: TMemo;

Button2: TButton;

Button3: TButton;

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure LOG(str: string);

function NOD(num1, num2 : cardinal):cardinal ;

function Evklid(A, N : integer):integer;

procedure Button3Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.DFM}

//******************************************************************************

function TForm1.Evklid(A, N : integer):integer;

// Возвращает остаток от деления 1/К0 на Y

var

//i: Cardinal;

U1, U2, V1, V2, t1, t2: integer;

q: integer;

begin

U1:=0; U2:=N;

V1:=1; V2:=A;

while (U2<>1) do begin

// showmessage('U1='+inttostr(U1)+' U2='+inttostr(U2)+' V1='+inttostr(V1)+' V2='+inttostr(V2));

q:=(U2 div V2);

t1:=U1-V1*q;

// while t1<0 do t1:=t1+N;

// t1:=t1 mod N;

t2:=U2-V2*q;

// while t2<0 do t2:=t2+N;

// t2:=t2 mod N;

// showmessage('q='+inttostr(q)+' t1='+inttostr(t1)+' t2='+inttostr(t2));

U1:=V1; U2:=V2;

V1:=t1; V2:=t2;

end;

while U1<0 do U1:=U1+N;

Evklid:=U1;

end;

//******************************************************************************

function TForm1.NOD(num1, num2 : cardinal):cardinal ;

// Возвращает наибольший ОБЩИЙ делитель

var

i: Cardinal;

begin

for i:=num1-1 downto 1 do

if ((num1 mod i)=0) and ((num2 mod i) = 0) then break;

NOD:=i;

end;

//********************************************************************************

procedure TForm1.LOG(str: string);

begin

memo1.Lines.Add(str);

end;

procedure TForm1.Button1Click(Sender: TObject);

type

T32bit=array[0..31] of byte;

T16bit=array[0..15] of byte;

//********************************************************************************

procedure LOGArray(arr: T32bit);

var i: byte;

str: string;

temp: string;

begin

str:='';

for i:=0 to 31 do

begin

temp:=inttostr(arr[i]);

if length(temp)=1 then temp:=' '+temp;

if length(temp)=2 then temp:=' '+temp;

str:=str+temp;

end;

memo1.Lines.Add(str);

end;

//********************************************************************************

// Вывод 16 битного массива в лог

procedure LOGSmallArray(arr: T16bit; title: string);

var i: byte;

str: string;

temp: string;

begin

str:='';

for i:=0 to 15 do

begin

temp:=inttostr(arr[i]);

if length(temp)=1 then temp:=' '+temp;

if length(temp)=2 then temp:=' '+temp;

str:=str+temp;

end;

memo1.Lines.Add(title+str);

end;

//********************************************************************************

// Перестановка элементов массива в обратном порядке

function ReverseArray(arr: T32bit):T32bit;

var

temp: T32bit;

i: byte;

begin

for i:=0 to 31 do temp[31-i]:=arr[i];

ReverseArray:=temp;

end;

//********************************************************************************

// Возвращает массив из старших эелементов массива

function HiPart(arr: T32bit):T16bit;

var

temp: T16bit;

i: byte;

begin

for i:=0 to 15 do temp[i]:=arr[i];

HiPart:=temp;

end;

//********************************************************************************

// Возвращает массив из младших эелементов массива

function LowPart(arr: T32bit):T16bit;

var

temp: T16bit;

i: byte;

begin

for i:=0 to 15 do temp[i]:=arr[i+16];

LowPart:=temp;

end;

//********************************************************************************

// Производит сложение по модулю 2 для элементов массива

function XorArray(arr1, arr2: T16bit):T16bit;

var

temp: T16bit;

i: byte;

begin

for i:=0 to 15 do temp[i]:=arr1[i] xor arr2[i];

XorArray:=temp;

end;

//********************************************************************************

// Объединяет два 16 битных массива в один 32 битный

function MergeArray(arrhi, arrlow: T16bit):T32bit;

var

temp: T32bit;

i: byte;

begin

for i:=0 to 31 do begin

if i<16 then temp[i]:=arrHi[i]

else temp[i]:=arrLow[i-16];

end;

MergeArray:=temp;

end;

//********************************************************************************

// Представляет целое 32 битное чилсо в виде массима, элементы которого двоичные числа

function NumToArray(num:cardinal):T32bit;

var

temp: T32bit;

i: byte;

begin

for i:=31 downto 0 do

begin

temp[i]:= num mod 2;

num:=num div 2;

end;

NumToArray:=temp;

end;

//********************************************************************************

var

M: T32bit; // Массив шифруемой информации

origM: T32bit; // Массив шифруемой информации

C: T32bit; // Шифротекст

K: T32bit; // Ключ шифрования

K11: T32bit; // K'

K22: T32bit; // K''

temp32: T32bit;

IP: T32bit; // Матрица прямой перестановки

invIP: T32bit; // Матрица обратной перестановки

K1, K2, K3, K4: T16bit; // Ключи фишрования

L0, L1, L2, L3, L4 : T16bit; // Промежуточные результаты шифрования

R0, R1, R2, R3, R4 : T16bit; // Промежуточные результаты шифрования

temp16: T16bit;

M1, M2, M3, M4: byte;

i: byte;

begin

IP[0]:=31; IP[1]:=27; IP[2]:=23; IP[3]:=19; IP[4]:=15; IP[5]:=11; IP[6]:=7; IP[7]:=3;

IP[8]:=29; IP[9]:=25; IP[10]:=21; IP[11]:=17; IP[12]:=13; IP[13]:=9; IP[14]:=5; IP[15]:=1;

IP[16]:=30; IP[17]:=26; IP[18]:=22; IP[19]:=18; IP[20]:=14; IP[21]:=10; IP[22]:=6; IP[23]:=2;

IP[24]:=28; IP[25]:=24; IP[26]:=20; IP[27]:=16; IP[28]:=12; IP[29]:=8; IP[30]:=4; IP[31]:=0;

for i:=0 to 31 do invIP[31-i]:=IP[i];

//M1:= (strtoint(Edit1.text)*32+strtoint(Edit2.text)) mod 256;

M1:=3*32+8;

LOG('M1=№гр*8+№п.п');

LOG('M1='+inttostr(M1));

M2:=(M1+133) mod 256;

LOG('M2=(M1+133) mod 256');

LOG('M2='+inttostr(M2));

M3:=(M2+69) mod 256;

LOG('M3=(M2+69) mod 256');

LOG('M3='+inttostr(M3));

M4:=(M3-177) mod 256;

LOG('M4=(M3-177) mod 256');

LOG('M4='+inttostr(M4));

// Формирование открытого текста

M:=NumToArray(round(power(2,24)*M1+power(2,16)*M2+256*M3+M4));

LOG('Сообщение, которое будем шифровать M=(M1,M2,M3,M4)');

LOGarray(M);

// Вычисление ключей

K:=NumToArray((M2 xor M4)+round(power(2,24)*M1+power(2,16)*M2+256*M3+M4));

LOG('Секртеный ключ K=((M2 xor M4)+M) mod 2^32');

LOGarray(K);

// K', K''

K11:=NumToArray((M2 xor M4)+round(power(2,24)*M1+power(2,16)*M2+256*M3+M4)+4*M1);

LOG('32-битное число K`=(K+4*M1) mod 2^32');

LOGarray(K11);

//LOG('K`='+inttostr(Ktemp1));

K22:=NumToArray(8*((M2 xor M4)+round(power(2,24)*M1+power(2,16)*M2+256*M3+M4)+4*M1));

LOG('временное 32-битное число temp=(8*K`) mod 2^32');

LOGarray(K22);

K22:=NumToArray(not (8*((M2 xor M4)+round(power(2,24)*M1+power(2,16)*M2+256*M3+M4)+4*M1)));;

LOG('32-битное число K``=not(temp)');

LOGarray(K22);

LOG('');

LOG('Формирование ключей');

// Получаю ключ К1

K1:=LowPart(K11);

LOGSmallArray(K1,'Ключ K1:');

// Получаю ключ К2

K2:=HiPart(K11);

LOGSmallArray(K2,'Ключ K2:');

// Получаю ключ К3

K3:=LowPart(K22);

LOGSmallArray(K3,'Ключ K3:');

// Получаю ключ К4

K4:=HiPart(K22);

LOGSmallArray(K4,'Ключ K4:');

//******************************************************************************

// НАЧАЛО ШИФРОВАНИЯ

//******************************************************************************

// Начальная перестановка

LOG('');

LOG('Прямая перестановка задается вектором IP=');

LOGArray(IP);

for i:=0 to 31 do temp32[IP[i]]:=M[i];

LOG('Результат прямой перестановки IP:');

LOGarray(temp32);

// первый цикл шифрования

L0:=HiPart(temp32);

R0:=LowPart(temp32);

LOG('Цикл шифрования 1');

LOGSmallArray(L0,'L0=');

LOGSmallArray(R0,'R0=');

LOGSmallArray(K1,'K0=');

temp16:=XorArray(R0,K1); // f(R0,K1)

LOG('f(K1,R0):');

LOGSmallArray(temp16,' ');

LOG('');

R1:=XorArray(L0,temp16);

L1:=R0;

// Второй цикл

LOG('Цикл шифрования 2');

LOGSmallArray(L1,'L1=');

LOGSmallArray(R1,'R1=');

LOGSmallArray(K2,'K2=');

temp16:=XorArray(R1,K2); // f(R1,K2)

LOG('f(K2,R1):');

LOGSmallArray(temp16,' ');

LOG('');

R2:=XorArray(L1,temp16);

L2:=R1;

// Третий цикл

LOG('Цикл шифрования 3');

LOGSmallArray(L2,'L2=');

LOGSmallArray(R2,'R2=');

LOGSmallArray(K3,'K3=');

temp16:=XorArray(R2,K3); // f(R2,K3)

LOG('f(K3,R2):');

LOGSmallArray(temp16,' ');

LOG('');

R3:=XorArray(L2,temp16);

L3:=R2;

// Четвертый цикл

LOG('Цикл шифрования 4');

LOGSmallArray(L3,'L3=');

LOGSmallArray(R3,'R3=');

LOGSmallArray(K4,'L4=');

temp16:=XorArray(R3,K4); // f(R2,K3)

LOG('f(K4,R3):');

LOGSmallArray(temp16,' ');

LOG('');

R4:=XorArray(L3,temp16);

L4:=R3;

LOGSmallArray(L4,'L4=');

LOGSmallArray(R4,'R4=');

// Объединяю два 16 числа в 32 битные

temp32:=MergeArray(L4,R4);

LOG('Результат перед обратной перестановкой temp32:');

LogArray(temp32);

// Делаю обратную перестановку

LOG('');

LOG('Обратная перестановка задается вектором invIP=');

LOGArray(invIP);

for i:=0 to 31 do C[invIP[i]]:=temp32[i];

LOG('Результат обратной перестановки C[invIP[i]]:=temp32[i]');

LOGarray(C);

LOG('');

LOG('');

LOG('НАЧАЛО ДЕШИФРОВАНИЯ');

//******************************************************************************

// НАЧАЛО ДЕШИФРОВАНИЯ!

//******************************************************************************

// Начальная перестановка

origM:=M; // Запинаю массив исходной информации

//M:=C;

for i:=0 to 31 do temp32[IP[i]]:=M[i];

LOG('Результат обратной перестановки temp32[invIP[i]]:=M[i]:');

LOGarray(temp32);

// первый цикл дешифрования

L4:=HiPart(temp32);

R4:=LowPart(temp32);

LOG('Цикл дешифрования 1');

LOGSmallArray(L4,'L4=');

LOGSmallArray(R4,'R4=');

LOGSmallArray(K4,'K4=');

temp16:=XorArray(L4,K4); // f(R0,K1)

LOG('f(K4,L4):');

LOGSmallArray(temp16,' ');

LOG('');

L3:=XorArray(R4,temp16);

R3:=L4;

//******************************************************************************

// Второй цикл дешифрования

LOG('Цикл дешифрования 2');

LOGSmallArray(L3,'L3=');

LOGSmallArray(R3,'R3=');

LOGSmallArray(K3,'K3=');

temp16:=XorArray(L3,K3); // f(R0,K1)

LOG('f(K3,L3):');

LOGSmallArray(temp16,' ');

LOG('');

L2:=XorArray(R3,temp16);

R2:=L3;

//******************************************************************************

// Третий цикл дешифрования

LOG('Цикл дешифрования 3');

LOGSmallArray(L2,'L2=');

LOGSmallArray(R2,'R2=');

LOGSmallArray(K2,'K2=');

temp16:=XorArray(L2,K2); // f(R0,K1)

LOG('f(K2,L2):');

LOGSmallArray(temp16,' ');

LOG('');

L1:=XorArray(R2,temp16);

R1:=L2;

//******************************************************************************

// Четвертый цикл дешифрования

LOG('Цикл дешифрования 4');

LOGSmallArray(L1,'L1=');

LOGSmallArray(R1,'R1=');

LOGSmallArray(K1,'K1=');

temp16:=XorArray(L1,K1); // f(R0,K1)

LOG('f(K1,L1):');

LOGSmallArray(temp16,' ');

LOG('');

L0:=XorArray(R1,temp16);

R0:=L1;

LOGSmallArray(L0,'L0=');

LOGSmallArray(R0,'R0=');

// Объединяю два 16 числа в 32 битные

temp32:=MergeArray(L0,R0);

LOG('Результат перед обратной перестановкой:');

LogArray(temp32);

// Делаю обратную перестановку

for i:=0 to 31 do C[IP[i]]:=temp32[i];

LOG('Результат обратной перестановки M:');

LOGarray(M);

LOG('Исходное значение M:');

LOGarray(origM);

LOGarray(IP);

LOGarray(invIP);

end;

procedure TForm1.Button2Click(Sender: TObject);

var

M, M1, M2, L, P, Q, P1, Q1, N, Y, Ko :Cardinal;

i: byte;

//******************************************************************************

function is_prost(num : cardinal):cardinal ;

// Возвращает наибольший делительж

var

i: Cardinal;

begin

for i:=num-1 downto 1 do begin

if (num mod i) = 0 then break;

end;

is_prost:=i;

end;

//******************************************************************************

begin

L:=3*32+8;

LOG('L='+inttostr(L));

P1:=((L+256)*(L+256)) mod 1000;

Q1:=((L*5+129)*(L*5+129)) mod 1000;

//LOG('Исходные значения P"='+inttostr(P1));

//LOG('Исходные значения Q"='+inttostr(Q1));

//if (P1 mod 100) < 10 then P1:=P1 div round(power(10,length(inttostr(P1))-2));

//if (Q1 mod 100) < 10 then Q1:=Q1 div round(power(10,length(inttostr(Q1))-2));

LOG('Исходные значения P"=((L+256)*(L+256)) mod 1000 = '+inttostr(P1));

LOG('Исходные значения Q"=((L*5+129)*(L*5+129)) mod 1000 = '+inttostr(Q1));

LOG('Ищем ближайшие большие простые числа для P и Q:');

while is_prost(P1)<>1 do inc(P1); // Ищем ближайшее большее простое число P

while is_prost(Q1)<>1 do inc(Q1); // Ищем ближайшее большее простое число Q

P:=P1;

Q:=Q1;

LOG('P='+inttostr(P));

LOG('Q='+inttostr(Q));

N:=P*Q;

LOG('N=P*Q='+inttostr(N));

Y:=(P-1)*(Q-1);

LOG('Y=(P-1)*(Q-1)='+inttostr(Y));

LOG('Генерируем случайное Ko, пока не выполнятся условия RSA');

i:=0;

repeat

Ko:=Random(Y);

//LOG(inttostr(Ko)+' НОД='+inttostr(NOD(Ko,Y)));

inc(i);

// Повторяю генерацию случайного Ko до тех пор пока не выполнятся все условия RSA

until (Ko<>P)and(Ko<>Q)and(Ko>1)and(Ko<Y)and(NOD(Ko,Y)=1);

LOG(inttostr(i)+') Ko='+inttostr(Ko));

LOG('Вычисляем Kc по алгоритму Эвклида');

LOG('Kc='+inttostr(evklid(Ko,Y)));

//LOG('(1/Ko) mod Y = '+inttostr(Evklid(5,23)));

// Формируем блоки исходной информации

LOG('');

LOG('');

LOG('Формирование блоков исходной информации');

M:=(L*3+127)*233;

LOG('M=(L*3+127)*233 = '+inttostr(M));

M1:=M mod 10000;

LOG('M1=M mod 10000 = '+inttostr(M1));

M2:=M div 10000;

LOG('M2=M div 10000 = '+inttostr(M2));

LOG('+++++++++++++++++++++++++++++++++++++++++++++++++');

LOG('');

end;

procedure TForm1.Button3Click(Sender: TObject);

var

P, M, M1, M2, Kc, Ko, Q: cardinal;

akcmodp, a, b, S1, S2, i: cardinal;

begin

P:=601; // Из RSA

LOG('P = '+inttostr(P));

Q:=Random(P-1);

LOG('Q=random(P-1) = '+inttostr(Q));

Kc:=Random(P-1);

LOG('Kc=random(P-1) = '+inttostr(Kc));

// Выбираю S1

i:=0;

repeat

inc(i);

S1:=Random(P-1);

until NOD(S1,P-1)=1;

LOG('Выбираю S1');

LOG(inttostr(i)+') S1='+inttostr(S1));

// Выбираю S2

i:=0;

repeat

inc(i);

S2:=Random(P-1);

until NOD(S2,P-1)=1;

LOG('Выбираю S2');

LOG(inttostr(i)+') S2='+inttostr(S2));

//******************************************************************************

//******************************************************************************

// Декодирование

//******************************************************************************

//******************************************************************************

Kc:=191;

P:=601;

LOG('');

LOG('');

LOG('');

LOG('P='+inttostr(P));

a:=564;

LOG('a='+inttostr(a));

b:=217;

LOG('b='+inttostr(b));

akcmodp:=324;

LOG('L='+inttostr(akcmodp));

LOG('Evklid='+inttostr(Evklid(akcmodp,P)));

M:=((b mod P)*(Evklid(akcmodp,P) mod P)) mod P;

LOG('M = '+inttostr(Evklid(akcmodp,P)));

LOG('+++++++++++++++++++++++++++++++++++++++++++++++++');

LOG('');

end;

end.