MOV BP, AX

PC2_FOR_C

MOV [DI], BX ; Записываем первую часть Ki

MOV [DI+2], AX

MOV CX, ES ; CX:DX = Di

MOV DX, BP

PC2_FOR_D

MOV [DI+4], BX ; Записываем вторую часть Ki

MOV [DI+6], AX

MOV BX, ES ; AX:BX = Di

MOV AX, BP

POP DX ; CX:DX = Ci

POP CX

SUB DI, 8 ; Следующий ключ Ki

OR SI, SI

JZ decryption_key_L20

JMP decryption_key_L10

decryption_key_L20: POP DS

POP DI

POP SI

RET

decryption_key ENDP

END

Пр 2.1. Исходные тексты программы шифрования RSA

Файл RSA.h

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <alloc.h>

#include <string.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <io.h>

#include <mem.h>

const int SIZE=512;

class chislo

{

//private:

public:

char data[SIZE+1];

void set_from_char(char* inp);

void Show();

void Show(int last);

void Show(char* description);

void Show_dec();

void Show_deta();

void To_dop();

void Add_with_offset(const chislo& inp,int offset);

void Zero();

void Set_one();

void Set_one (int offset);

void Set_minus_one();

int Is_not_null();

int Is_null();

int Is_one();

int Is_simple();

int Get_data(int i)

{ return data[i]; }

void Inc();

void Dec();

void Shl();

void Shr();

void Shr (int offset);

void Shl (int offset);

void Generate(int razrad);

chislo operator+(const chislo& inp);

chislo operator*(const chislo& inp);

chislo operator%(const chislo& inp);

chislo operator/(const chislo& inp);

chislo operator-(const chislo& inp);

void Add (const chislo& inp);

void Sub (const chislo& inp);

int operator>(const chislo& inp);

int operator<(const chislo& inp);

int operator==(const chislo& inp);

int Save(char* path_file);

int Load(char* path_file);

friend chislo ExtEuclid (chislo d, chislo f);

friend int witness(const chislo &a, const chislo& n);

friend chislo multi_and_get_mod (chislo mul_1, chislo mul_2, chislo mod);

};

Файл RSA.cpp

#include "RSA.H"

const BLOCK_SIZE = 10;

const BLOCK_SIZE2 = 64;

//Функция, получает буфер из 64 байт и конвертит ее в двоичный СТРОКОВЫЙ формат

void bin_to_bin_str(char * src, char* res)

{

int i,j, b, o;

for( i = 0; i < BLOCK_SIZE; i++ ){

b = (unsigned char)(src[i]);

for( j = 0; j < 8; ++j ){

o = b % 2;

b = b / 2;

res[8*BLOCK_SIZE-1-(i*8+j)] = 48 + o;

}

}

res[BLOCK_SIZE*8] = 0;

};

void bin_to_bin_str2(char * src, char* res)

{

int i,j, b, o;

for( i = 0; i < BLOCK_SIZE2; i++ ){

b = (unsigned char)(src[i]);

for( j = 0; j < 8; ++j ){

o = b % 2;

b = b / 2;

res[8*BLOCK_SIZE2-1-(i+1)*8+1+j] = 48 + o;

}

}

res[BLOCK_SIZE2*8] = 0;

};

void bin_str_to_bin( char* src, char* res ){

int i,j, b, o;

for( i = 0; i < BLOCK_SIZE2; i++ ){

b = 0;

o = 1;

for( j = 0; j < 8; ++j ){

b = b + o*src[(i+1)*8-1 - j];

o = o * 2;

}

res[i] = b;

}

};

void bin_str_to_bin2( char* src, char* res ){

int i,j, b, o;

for( i = 0; i < BLOCK_SIZE2; i++ ){

b = 0;

o = 1;

for( j = 0; j < 8; ++j ){

b = b + o*src[i*8+ j];

o = o * 2;

}

res[i] = b;

}

};

void stop()

{

if (getch()==27)

exit(0);

}

int chislo::Load(char* path_file)

{

printf("Load data from %s .\n",path_file);

int file_in=open(path_file,O_RDONLY);

if (file_in == -1)

{

printf("falied to load from %s !\nPress any key.\n",path_file);

return 1;

}

int flag=0;

char symbol;

for (int i=0;i<SIZE;i++)

{

flag+=read(file_in,&symbol,1);

data[i]=symbol-48;

}

if (flag!=SIZE)

{

printf("load is incorrect!\nPress any key.\n");

return 2;

}

return 0;

}

int chislo::Save(char* path_file)

{

printf("\nSave data in %s .\n",path_file);

FILE* file_out;

if ((file_out=fopen(path_file,"wt"))==NULL)

{

perror("Error:");

printf("failed to save in %s !\nPress any key.\n",path_file);

return 1;

}

for (int i=0;i<SIZE;i++)

fprintf(file_out,"%d",data[i]);

fclose(file_out);

return 0;

}

void chislo::Show(char* description)

{

printf("%s",description);

for (int i=SIZE-1;i>=0;i--)

{

printf("%d",data[i]);

if ((i%4)==0)

printf(".");

}

printf("\n");

}

void chislo::Dec()

{

for (int i=0;i<SIZE;i++)

{

data[i]++;

if (data[i]>1)

{

data[i]-=2;

data[i+1]++;

}

}

}

int chislo::Is_simple()

{

int razrad=SIZE-1;

while ( (razrad>=0) && (data[razrad]==0) )

razrad--;

if (razrad<2)

return 1;

chislo temp;

if (data[0]==0)

return 0;

printf("Mod % 2 <> 0!\n");

int temp_1=0;

for (int j=0;j<SIZE;j+=2)

temp_1+=data[j]+2*data[j+1];

if ( (temp_1%3)==0)

return 0;

printf("Mod % 3 <> 0!\n");

printf("Check other:");

int flag=0;

while ( (flag!=-1) && (flag<8) )

{

flag++;

printf ("%d",flag);

temp.Generate(razrad-1);

printf(" --* ");

if (witness(temp,(*this)))

flag=-1;

printf(" *-- ");

}

if (flag==-1)

return 0;

printf("THIS IS SIMPLE!\n");

return 1;

}

void chislo::Set_minus_one()

{

for (int i=0;i<SIZE;i++)

data[i]=1;

}

int witness (const chislo& a, const chislo& n)

{

chislo d,x,n_1;

d.Set_one();

n_1=n;

n_1.Dec();

int i=SIZE-1;

while (n_1.data[i]==0)

i--;

for (;i>=0;i--)

{

printf("%d.",i);

x=d;

d=(d*d)%n;

if ( (d.Is_one()) && (!(x.Is_one())) && (!(x==n_1)) )

{

printf("FAIL!");

return 1;

}

if (n_1.data[i])

{

d=(d*a)%n;

}

}

if (!(d.Is_one()))

{

printf("fail!\n");

return 1;

}

printf("Strage...\n");

return 0;

}

void chislo::Generate(int razrad)

{

for (int i=SIZE;i>razrad;i--)

data[i]=0;

for (i=1;i<razrad;i++)

data[i]=rand()%2;

data[razrad]=1;

data[0]=1;

}

int chislo::operator==(const chislo& inp)

{

for (int i=0;i<SIZE;i++)

if (data[i]!=inp.data[i])

return 0;

return 1;

}

void chislo::Inc()

{

int i=0;

data[0]++;

while ( (data[i]>1) && (i<SIZE) )

{

data[i]-=2;

data[i+1]++;

i++;

}

}

void chislo::Set_one(int offset)

{

for (int i=0;i<=SIZE;i++)

data[i]=0;

data[offset]=1;

}

chislo chislo::operator/(const chislo& inp)

{

chislo result,temp,temp_umen;

result.Zero();

int i,j;

for (i=0;i<SIZE;i++)

temp_umen.data[i]=data[i];

if (temp_umen<inp)

return result;

temp_umen.data[SIZE]=0;

while ( !(temp_umen<inp) && (!temp_umen.data[SIZE]) && (!temp_umen.data[SIZE-1]) )

{

for (j=0;j<SIZE;j++)

temp.data[j]=inp.data[j];

j=0;

temp.data[SIZE]=0;

while ( !(temp>temp_umen) && (!temp.data[SIZE]) && (!temp.data[SIZE-1]) )

{

temp.Shl();

j++;

}

temp.Shr();

j--;

temp_umen=temp_umen-temp;

temp.Set_one(j);

result=result+temp;

}

return result;

}

chislo ExtEuclid (chislo d, chislo f)

{

int i;

chislo X1,X2,X3,Y1,Y2,Y3,Q,T1,T2,T3;

X1.Set_one();

X2.Zero();

Y1.Zero();

Y2.Set_one();

for (i=0;i<SIZE;i++)

{

Y3.data[i]=d.data[i];

X3.data[i]=f.data[i];

}

X3.data[SIZE]=0;

Y3.data[SIZE]=0;

Y3.data[SIZE-1]=0;

i=0;

do

{

i++;

printf(".");

Q=X3/Y3;

T1=X1-(Q*Y1);

T2=X2-(Q*Y2);

T3=X3-(Q*Y3);

X1=Y1;

X2=Y2;

X3=Y3;

Y1=T1;

Y2=T2;

Y3=T3;

}while ( (!Y3.Is_null()) && (!Y3.Is_one()) );

if (Y3.Is_null())

return Y3;

if (f<Y2)

Y2=Y2+f;

return Y2;

}

void chislo::Set_one()

{

for (int i=1;i<=SIZE;i++)

data[i]=0;

data[0]=1;

}

void chislo::Show_dec()

{

int result=data[0],shag=1;

for (int i=1;i<SIZE;i++)

{

shag*=2;

if (data[i])

result+=shag;

}

printf("CHISLO:%d\n",result);

}

void chislo::Shl()

{

for (int i=SIZE-1;i>0;i--)

data[i]=data[i-1];

data[0]=0;

}

void chislo::Shl (int offset)

{

for (int i=SIZE-offset;i>=offset;i--)

data[i]=data[i-offset];

for (i=0;i<offset;i++)

data[i]=0;

}

void chislo::Shr()

{

for (int i=0;i<(SIZE-1);i++)

data[i]=data[i+1];

data[SIZE-1]=0;

data[SIZE]=0;

}

void chislo::Shr(int offset)

{

for (int i=offset;i<(SIZE-offset);i++)

data[i]=data[i+offset];

for (i=SIZE;i>=(SIZE-offset);i++)

data[i]=0;

}

chislo chislo::operator%(const chislo& inp)

{

chislo result,temp;

result.Zero();

if ((*this)==inp)

return result;

for (int i=0;i<SIZE;i++)

result.data[i]=data[i];

while (!(result<inp) && !(result.data[SIZE]) && !(result.data[SIZE-1]))

{

for (i=0;i<SIZE;i++)

temp.data[i]=inp.data[i];

while ((temp<result) && !(temp.data[SIZE-1]))

temp.Shl();

temp.Shr();

result=result-temp;

}

return result;

}

chislo chislo::operator*(const chislo& inp)

{

chislo result;

result.Zero();

for (int i=0;i<SIZE;i++)

if (data[i])

result.Add_with_offset(inp,i);

return result;

}

chislo chislo::operator+(const chislo& inp)

{

chislo result;

result.Zero();

for (int i=0;i<SIZE;i++)

{

result.data[i]+=data[i]+inp.data[i];

if (result.data[i]>1)

{

result.data[i]-=2;

result.data[i+1]++;

}

}

return result;

}

chislo chislo::operator-(const chislo& inp)

{

chislo result;

result.Zero();

for (int i=0;i<SIZE;i++)

{

result.data[i]=data[i]-inp.data[i]-result.data[i];

if (result.data[i]<0)

{

result.data[i]+=2;

result.data[i+1]++;

}

}

return result;

}

int chislo::Is_one()

{

for (int i=1;i<SIZE;i++)

if (data[i])

return 0;

if (data[0]==1)

return 1;

return 0;

}

int chislo::Is_null()

{

for (int i=0;i<SIZE;i++)

if (data[i])

return 0;

return 1;

}

int chislo::Is_not_null()

{

for(int i=0;i<SIZE;i++)

if (data[i])

return 1;

return 0;

}

void chislo::Zero()

{

for (int i=0;i<=SIZE;i++)

data[i]=0;

}

void chislo::Add_with_offset(const chislo& inp,int offset)

{

if (offset>=SIZE)

return;

for (int i=offset;i<SIZE;i++)

{

data[i]+=inp.data[i-offset];

if (data[i]>1)

{

data[i]-=2;

data[i+1]++;

}

}

}

void chislo::To_dop()

{

for (int i=0;i<SIZE;i++)

if (data[i])

{

data[i]=0;

}

else

{

data[i]=1;

}

i=0;

data[0]++;

while ( (data[i]>1) && (i<SIZE) )

{

data[i]-=2;

data[i+1]++;

i++;

}

}

void chislo::Show()

{

for (int i=SIZE-1;i>=0;i--)

printf("%d",data[i]);

}

void chislo::Show(int last)

{

if (last>(SIZE-1))

last=SIZE-1;

for (int i=last;i>=0;i--)

printf("%d",data[i]);

}

void chislo::set_from_char (char* inp)

{

Zero();

int size=strlen(inp);

if (size>SIZE)

size=SIZE;

for (int i=0;i<size;i++)

data[size-i-1]=inp[i]-48;

}

void chislo::Show_deta()

{

for (int i=SIZE-1;i>=0;i--)

printf("%d:",data[i]);

}

chislo up_to_exp_and_get_mod (chislo osn, chislo pokaz, chislo mod)

{

chislo result;

result.set_from_char("1");

int i=SIZE-1;

while(pokaz.data[i]==0)

i--;

for (i;i>=0;i--)

{

printf(".");

result=(result*result)%mod;

if (pokaz.data[i])

result=(result*osn)%mod;

}

return result;

}

int chislo::operator> (const chislo& inp)

{

for (int i=SIZE-1;i>=0;i--)

{

if (data[i]<inp.data[i])

return 0;

if (data[i]>inp.data[i])

return 1;

}

return 0;

}

int chislo::operator< (const chislo& inp)

{

for (int i=SIZE-1;i>=0;i--)

{

if (data[i]>inp.data[i])

return 0;

if (data[i]<inp.data[i])

return 1;

}

return 0;

}

void chislo::Add(const chislo& inp)

{

for (int i=0;i<SIZE;i++)

{

data[i]+=inp.data[i];

if (data[i]>1)

{

data[i]-=2;

data[i+1]++;

}

}

}

void chislo::Sub(const chislo& inp)

{

for (int i=0;i<SIZE;i++)

{

data[i]-=inp.data[i];

if (data[i]<0)

{

data[i]+=2;

data[i+1]--;

}

}

}

Файл my_rsa.cpp

#include "rsa.cpp"

extern unsigned _stklen = 54210U;

const int SIZE_GEN=(SIZE/2)-2;

void main ()

{

clrscr();

randomize();

chislo p,q,n,e,d,f,text;

int flag=1,razrad;

while ((flag!=0)&&(flag<100))

{

flag++;

razrad=(rand()%(SIZE_GEN/4))+20;

printf("\nTry to create P N %d with %d razrad.\n",flag-1,razrad);

p.Generate(razrad);

if(p.Is_simple())

flag=0;

}

if (flag)

{

printf("\n*** Create 'P' is failed! ***\n");

stop();

exit(0);

}

printf("Create 'P' is complite!\n");

stop();

flag=1;

razrad=(SIZE_GEN/2)-razrad-1;

while ((flag!=0)&&(flag<100))

{

flag++;

printf("\nTry to create Q N %d with %d razrad.\n",flag-1,razrad);

q.Generate(razrad);

if(q.Is_simple())

flag=0;

}

if (flag)

{

printf("\n*** Create 'Q' is failed! ***\n");

stop();

exit(0);

}

printf("Create 'Q' is complite!\n");

stop();

n=p*q;

d=p;

d.Dec();

e=q;

e.Dec();

f=e*d;

flag=1;

while (flag)

{

printf("Try to create e & d N %d",flag);

flag++;

razrad=rand()%(SIZE_GEN/4)+2;

d.Generate(razrad);

if ((d.Is_not_null()) && (!d.Is_one()) )

{

e=ExtEuclid(d,f);

if (e.Is_not_null())

flag=0;

}

}

if (e.Save("open.key") || n.Save("mod.key") || d.Save("close.key") )

return;

printf("\nGenerate is complite!\n");

getch();

}

Файл code.cpp

#include "RSA.CPP"

extern unsigned _stklen = 54210U;

const int SIZE_GEN=(SIZE/2)-2;

int main( int argc, char *argv[] )

{

printf("CODE DATA BY RSA: \n");

if( argc < 3 ){

printf("CODE <crypt_file> <decrypt_file> \n");

return 0;

}

chislo open_key,mod_key,text;

if (open_key.Load("open.key") || mod_key.Load("mod.key") )

return 0;

int flag=1,i,len, cur_len;

char buff[1000];

char fbuff[255];

//Открываем файл для чтения

FILE* fin, *fout;

int in_size, out_size;

fin = fopen( argv[1], "rb+" );

//Открываем файл для записи

fout = fopen( argv[2], "wb+" );

fseek( fin, 0L, SEEK_END );

in_size = ftell( fin );

fseek( fin, 0L, SEEK_SET );

//Записываем размер в файл

fprintf( fout, "%d\n", in_size );

while( !feof( fin ) ){

//Читаем строку

len = fread( fbuff, 1, BLOCK_SIZE, fin );

if( !len ) break;

//Если надо - дополняем строку

if( len < BLOCK_SIZE ){

for( i = len; i < BLOCK_SIZE; ++i )

fbuff[i] = 0;

}

//Переводим строку в двоичный формат

bin_to_bin_str(fbuff, buff);

printf("%s \n", buff);

//Шифруем

text.set_from_char(buff);

text.Show("\nYou input TEXT:");

text=up_to_exp_and_get_mod(text,open_key,mod_key);

//Записываем результат

bin_str_to_bin( text.data, fbuff );

fwrite( fbuff, 1, BLOCK_SIZE2, fout );

}

fclose( fin );

fclose( fout );

return 0;

}

Файл uncode.cpp

#include "rsa.cpp"

extern unsigned _stklen = 54210U;

int main( int argc, char *argv[] )

{

printf("UNCODE DATA:\n");

chislo close_key,mod_key,text;

if (close_key.Load("close.key")

|| mod_key.Load("mod.key") )

return 0;

char* buff=(char*)malloc(SIZE+5);

char fbuff[255];

//Открываем файл для чтения

FILE* fin, *fout;

int in_size, out_size, cur_size = 0, len, i;

fin = fopen( argv[1], "rb+" );

//Открываем файл для записи

fout = fopen( argv[2], "wb+" );

//Записываем размер в файл

fscanf( fin, "%d\n", &in_size );

while( !feof( fin ) ){

//Читаем строку

len = fread( fbuff, 1, BLOCK_SIZE2, fin );

if( !len ) break;

//Если надо - дополняем строку

if( len < BLOCK_SIZE2 ){

for( i = len; i < BLOCK_SIZE2; ++i )

fbuff[i] = 0;

}

//Переводим строку в двоичный формат

bin_to_bin_str2(fbuff, buff);

//Шифруем

text.set_from_char(buff);

text.Show("\nYou input TEXT:");

text=up_to_exp_and_get_mod(text,close_key,mod_key);

//Записываем результат

bin_str_to_bin2( text.data, fbuff );

if( in_size - cur_size >= BLOCK_SIZE ){

fwrite( fbuff, 1, BLOCK_SIZE, fout );

cur_size += BLOCK_SIZE;

}else{

fwrite( fbuff, in_size - cur_size, 1, fout );

cur_size += in_size - cur_size;

}

}

fclose( fin );

fclose( fout );

printf("\nUncode is complite!\n");

return 0;

}

Размещено на Allbest.ru