Скорость шифрования данных достигает 100 кбайт в секунду.

 

ПРИЛОЖЕНИЕ 4

 

Программное обеспечение ЦРК.

Генератор случайной матрицы.

// generate matrix T[N][N][8];

#include "lin.cpp"

#include <stdio.h>main()

{

FILE *file_T;

unsigned T[N][N] = {0,};

file_T = fopen ( "matrix.lin" , "wb");

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

{

GenerateT(T);

fwrite(&T, sizeof(unsigned), N*N, file_T);

}

fclose(file_T);

}

Результатом выполнения приложения является файл matrix.lin.

Генератор парного ключа.

#include “lin.cpp”

#include “ext128.cpp”

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <iostream.h>

//-------------------------------------------------------main (int argc, char **argv)

{

if (argc < 4)

{

cout << endl

<< “ crk.exe U1_number U2_number U1.x U2.y file.t”

<< endl;

return 1;

}

//====================initialization data=================

FILE *osnkey;

FILE *rezkey;

FILE *stat;

FILE *X_file;

FILE *Y_file;

FILE *T_file;

unsigned Num1 = atoi(argv[1]), ©;

unsigned Num2 = atoi(argv[2]);

char dest1[9];

char dest2[9];

char dest3[9];

char *n1 = “u”, *ext1 = “.lin”, *ext2 = “.d_h”;

strcpy(dest1, n1);

strcat(dest1, argv[1]);

strcat(dest1, ext1);

if ((osnkey = fopen ( dest1 , “wb”)) == NULL)

{

cout << “ KeyFile not open.”;

return 1;

}

strcpy(dest2, n1);

strcat(dest2, argv[1]);

strcat(dest2, ext2);

if ((rezkey = fopen ( dest2 , “wb”)) == NULL)

{

cout << “ KeyFile not open.”;

return 1;

}

if ((stat = fopen ( “stat.txt” , “wt”)) == NULL)

{

cout << “ stat.txt not open.”;

return 1;

}

if ((X_file = fopen ( argv[3] , “rb”)) == NULL)

{

cout << argv[2] << “ not open.”;

return 1;

}

if ((Y_file = fopen ( argv[4] , “rb”)) == NULL)

{

cout << argv[3] << “ not open.”;

return 1;

}

if ((T_file = fopen ( argv[5] , “rb”)) == NULL)

{

cout << argv[4] << “ not open.”;

return 1;

}

unsigned key1[8] = {0,};

unsigned key2[8] = {0,};

unsigned X[17] = {0,};

unsigned Y[17] = {0,};

//=====================================================

unsigned R1[N] = {0,};

unsigned R2[N] = {0,};

unsigned T[N][N] = {0,};

GenerateR(R1,Num1);

GenerateR(R2,Num2);

for (©=0; ©<8; ©++)

{

fread(T, sizeof(unsigned), N*N, T_file);

key1[©] = FormDubleKey(T,R1,R2);

}

fclose (T_file);

fwrite(&key1, sizeof(unsigned), 8, osnkey);

fclose (osnkey);

//=====================================================

// X - secret key

// Y - public key

unsigned P[17] = {0xbcd3,0xfa20,0xc188,0x51ea,0x89ae,0xc0f2,0xf780,0xce2a};

// unsigned a[8] = {0x89e,0xc55,0x8fb,0x5b42,0,0,0,0};

fread(X, sizeof(unsigned), 8, X_file);

fclose (X_file);

fread(Y, sizeof(unsigned), 8, Y_file);

fclose (Y_file);

Pow_N(Y,X,P,key2);

fwrite(&key2, sizeof(unsigned), 8, rezkey);

fclose (rezkey);

//=====================================================

int j;

fprintf(stat, «\t\tФайл статистики для ЦРК.\n»);

fprintf(stat, “\tПользователь 1: %d. \tадрес: “, Num1);

for ( j = 5; j >= 0; j--) fprintf(stat, “%.4X”, R1[j]);

fprintf(stat, “\n\tПользователь 2: %d. \tадрес: “, Num2);

for ( j = 5; j >= 0; j--) fprintf(stat, “%.4X”, R2[j]);

fprintf(stat, “\n\t1) Основной ключ:\n\t\t”);

for ( j = 7; j >= 0; j--) fprintf(stat, “%.4X”, key1[j]);

fprintf(stat, “\n\t2) Резервный ключ:\n\t\t”);

for ( j = 7; j >= 0; j--) fprintf(stat, “%.4X”, key2[j]);

fprintf(stat, “\n\n\t ©2001 A. Bashmakov”);

//=====================================================

return 0;

}

Управление осуществляется из командной строки):

crk.exe U1_number U2_number U1.x U2.y matrix.lin.

То есть указывается номера абонентов, которые хотят установить связь, секретный ключ первого абонента, открытый ключ второго и файл содержащий случайную матрицу.

Результатом являются два файла с основным (*.lin) и резервным (*.d_h) ключами, а также файл-отчёта stat.txt.

Пример отчёта:

Файл статистики для ЦРК.

Пользователь 1: 10. адрес: 4F570112060A6AF33436B67A

Пользователь 2: 20. адрес: E827254578884F57060A3436

1) Основной ключ:

4FA0F597B4F49770365581D7ACB2F3BF

2) Резервный ключ:

5FA91077838BDEFB20DD14BAE77A8B19

(c)2001 A. Bashmakov

 

ПРИЛОЖЕНИЕ 5

 

Вспомогательные функции.

1. lin.cpp

//===================(c) Bashmakov A.V. Orel,2001===========

//= started 23.10 03.05.01 =

//= finished 21.14 24.05.01 =

//=====================================================

#include <stdlib.h>

//---------------------------------------------------------------------------

#define N 6

//---------------------------------------------------------------------------GenerateT (unsigned T[N][N]);GenerateR (unsigned R[N], unsigned);FormDubleKey(unsigned T[N][N], unsigned R1[N], unsigned R2[N]);long Pow_N (unsigned long, unsigned long, unsigned long);

//------------------------------------------------------------------------GenerateT(unsigned T[N][N])

{

unsigned temp = 0;

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

{

for (int j = temp; j < N ; j++)

{

if( i == j ) T[i][j] = rand()%0xffffU;

else T[i][j] = T[j][i] = rand()%0xffffU;

}

temp ++;

}

}

//-------------------------------------------------------------------------GenerateR(unsigned R[N], unsigned number)

{

for (int i=0; i<N; i++) R[i] = Pow_N(23, (number*(i+1)), 0xffffU);

}

//-------------------------------------------------------------------------FormDubleKey (unsigned T[N][N], unsigned R1[N], unsigned R2[N])

{

unsigned long temp1 = 0U;

unsigned long temp2 = 0U;

unsigned S[N] = {0U,};

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

{

temp2 = 0;

for (int j=0; j<N; j++)

{

temp1 = ((unsigned long)T[i][j] * R1[j]);

temp2 = ((temp1%0xffffU) + temp2)%0xffffU;

}

S[i] = (unsigned)temp2;

}

temp2 = 0;

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

{

temp1 = (unsigned long)S[i] * R2[i];

temp2 = ((temp1%0xffffU) + temp2)%0xffffU ;

}

return temp2;

}

//-------------------------------------------------------------------------long Pow_N(unsigned long a, unsigned long k, unsigned long n)

{

unsigned long A,B,K,q,r;

K=k;

B=1;

A=a;: q=K/2;

r=K-2*q;

K=q;

if (r==0) goto s5;

B=(A*B)%n;

if (K==0) return B;: A=(A*A)%n;

goto s2;

}

2. ext128.cpp

//====================128 bits ariphmetics==================

//=====================23.05.01====20.42==================

//===================(c) 2001 by A.Bashmakov==============Data

{a[2];long b;

}point;

//----------------------------------------------------------------Mult16 (unsigned *, unsigned *, unsigned *);Div16 (unsigned *, unsigned *, unsigned *, unsigned *);Sum16 (unsigned *, unsigned *, unsigned *);Razn16 (unsigned *, unsigned *, unsigned *);Pow_N (unsigned *, unsigned *, unsigned *, unsigned *);ModN (unsigned *, unsigned *);

//----------------------------------------------------------------Mult16(unsigned a[9], unsigned b[9], unsigned rez[18])

{ // a * b = rez; a & b max 128 bit, rez - 256 bit

unsigned st16 = 0U;

unsigned ml16 = 0U;

unsigned long temp = 0L;

for(int j=0; j<16; j++) rez[j] = 0U;

a[8] = 0;

b[8] = 0;

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

{

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

{

if(i == 0)

{

rez[9 + j] = st16;

st16 = 0;

}

point.b = (unsigned long)a[i] * (unsigned long)b[j];

ml16 = point.a[0];

temp = (unsigned long)rez[i+j] + (unsigned long)ml16 + st16;

rez[i+j] += ml16 + st16;

st16 = point.a[1] + (unsigned)(temp>>16);

if((j == 8)&&(i == 8)) rez[i+j+1] = st16;

}

}

}

//----------------------------------------------------------------Sum16(unsigned a[16], unsigned b[16], unsigned rez[16])

{ // a + b = rez;

unsigned perepS = 0;

unsigned j = 0;

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

{

point.b = (unsigned long)b[i] + (unsigned long)a[i] + perepS;

rez[j] = point.a[0];

perepS = point.a[1];

j++;

}

rez[j] = perepS;

}

//----------------------------------------------------------------ModN(unsigned a[16], unsigned m[8])

{ // a(mod m);

int i = 16;

do {i--;} while (a[i]==0);

int j = 8;

do {j--;} while (m[j]==0);

unsigned *temp1 = new unsigned [16];

unsigned *temp2 = new unsigned [16];

if ((i>j)||((i==j)&&(a[i]>m[j])))

{

do

{

for (int g=0; g<16; g++) temp1[g] = 0;

if (a[i] >= m[j])

{

point.b = (a[i] / m[j]);

temp1[i - j] = (point.a[0] == 0)?1:point.a[0];

}

else

{

i--;

point.a[0] = a[i];

point.a[1] = a[i+1];

point.b = (point.b / m[j]) - 1;

temp1[i - j] = (point.a[0] == 0)?1:point.a[0];

temp1[i - j + 1]= point.a[1];

}

Mult16(m, temp1, temp2);

Razn16(a, temp2, temp1);

for (g=0; g<16; g++) a[g] = temp1[g];

i = 16;

do

{ i--;

if(i == -1) {i=0; break;}

}while (a[i]==0);

}while(i!=j);

for (int g=8; g<16; g++) temp2[g] = 0;

for ( g=0; g<8 ; g++) temp2[g] = m[g];

while (a[i]>=m[j])

{

Razn16(a, temp2, temp1);

for (g=0; g<16; g++) a[g] = temp1[g];

};

};

delete temp1;

delete temp2;

}

//----------------------------------------------------------------Razn16(unsigned a[16], unsigned b[16], unsigned rez[16])

{ // a - b = rez;

for(int i=0; i<16; i++) rez[i] = 0;

unsigned *temp = new unsigned [17];

for(i=0; i<16; i++) temp[i] = a[i];

temp[17] = 0;

unsigned p = 17;

do {p--;} while (a[p]==0);

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

{

point.a[0] = temp[i];

point.a[1] = temp[i+1];

point.b -= b[i];

rez[i] = point.a[0];

temp[i+1] = point.a[1];

}

rez[i] = temp[i];

delete temp;

}

//----------------------------------------------------------------Pow_N(unsigned a[8], unsigned b[8], unsigned mod[8], unsigned rez[8])

{

unsigned *temp = new unsigned [9];

unsigned *temp1 = new unsigned [16];

int f;

for (int i = 0; i<8; i++) temp[i] = a[i];

temp[8] = 0;

for ( i = 0; i<16; i++) temp1[i] = 0;

unsigned p = 8;

do {p--;} while (b[p]==0);

unsigned g = 16;

do {g--;} while ( ((b[p] >> g)&0x1) == 0);

g--;

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

{

Mult16(temp, temp, temp1);

ModN (temp1, mod);

for (f = 8; f>=0; f--) temp[f] = temp1[f];

if (((b[p] >> i)&0x1) == 1)

{

Mult16(temp, a, temp1);

ModN (temp1, mod);

for (f = 8; f>=0; f--) temp[f] = temp1[f];

}

}

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

{

for (int j=15; j>=0; j--)

{

Mult16(temp, temp, temp1);

ModN (temp1, mod);

for (f = 8; f>=0; f--) temp[f] = temp1[f];

if (((b[i] >> j)&0x1) == 1)

{

Mult16(a, temp, temp1);

ModN (temp1, mod);

for (f = 8; f>=0; f--) temp[f] = temp1[f];

}

}

}

for (i=7; i>=0; i--) rez[i] = temp[i];

delete temp;

delete temp1;

}

//----------------------------------------------------------------Div16(unsigned a[8], unsigned b[8], unsigned rez[8], unsigned ost[8])

{

int i = 8;

do {i--;} while (a[i]==0);

int j = 8;

do {j--;} while (b[j]==0);

unsigned RaznPoz, del;

unsigned ostT [16] = {0,};

for (int g=0; g<8; g++) ostT[g] = a[g];

unsigned *temp1 = new unsigned [17];

unsigned *temp2 = new unsigned [17];

if ((i>j)||((i==j)&&(ostT[i]>b[j])))

{

do

{

for (int g=0; g<17; g++) temp1[g] = 0;

if (ostT[i] > b[j]) del = (ost[i] / b[j]);

else

{

i--;

point.a[0] = ostT[i];

point.a[1] = ostT[i+1];

del = point.b / b[j] - 1;

del = (del == 0)?1:del;

}

RaznPoz = i - j;

temp1[RaznPoz] = del;

rez [RaznPoz] = (rez[RaznPoz]==0)?del:(rez[RaznPoz] + del);

Mult16(b, temp1, temp2);

Razn16(ostT, temp2, temp1);

for(int u=15;u>=0;u--) ostT[u] = temp1[u];

i = 8;

do

{

i--;

if (i==-1) {i = 0; break;}

}while (ostT[i]==0);

}while(i>j);

int pointer = 0;

for (g = 0; g < 8; g++) temp2[g] = b[g];

for (g = 8; g < 16; g++) temp2[g] = 0;

while (ostT[i]>=b[j])

{

Razn16(ostT, temp2, temp1);

for(g=7;g>=0;g--) ostT[g] = temp1[g];

pointer++;

};

rez[0] += pointer;

};

delete temp1;

delete temp2;

}

 

3. idea.cpp

//==================idea.cpp============================

//-------International Data Encription Algorithm--------unsigned long type32;unsigned type16;unsigned char type8;

//------------------------------------------------------EncriptionStep (unsigned *, unsigned *);IDEA (unsigned *, unsigned *);SdvigMas1_4 (unsigned *);GenerateKey (type16 *, type16 *);sdvig25 (type16 *);IDEA_OFB (unsigned *, unsigned *, unsigned *, int);mul (unsigned, unsigned);

//------------------------------------------------------EncriptionStep(unsigned *key, unsigned *mes)

{

unsigned long a,b,c,d,e,f,g,h;

a = mul(mes[0], key[0]); // 1

b = ((unsigned long)mes[1] + key[1])%65536; // 2

c = ((unsigned long)mes[2] + key[2])%65536; // 3

d = mul(mes[3], key[3]); // 4

e = a ^ c; // 5

f = b ^ d; // 6

e = mul(e, key[4]); // 7

f = ((unsigned long)f + e)%65336; // 8

f = mul(f, key[5]); // 9

e = ((unsigned long)e + f)%65336; // 10

mes[0] = a ^ f; // 11

mes[1] = c ^ f; // 12

mes[2] = b ^ e; // 13

mes[3] = d ^ e; // 14

}IDEA(unsigned *key, unsigned *mes)

{

EncriptionStep(key,mes);

EncriptionStep(key + 6 ,mes);

EncriptionStep(key + 12,mes);

EncriptionStep(key + 18,mes);

EncriptionStep(key + 24,mes);

EncriptionStep(key + 30,mes);

EncriptionStep(key + 36,mes);

EncriptionStep(key + 42,mes);

mes[0] = ((unsigned long)mes[0] * key[48])%65337L;

mes[1] = ((unsigned long)mes[1] + key[49])%65336;

mes[2] = ((unsigned long)mes[2] + key[50])%65336;

mes[3] = ((unsigned long)mes[3] * key[51])%65337L;

}SdvigMas1_4(unsigned *mas)

{

unsigned temp = mas[0];

mas[0] = mas[1];

mas[1] = mas[2];

mas[2] = mas[3];

mas[3] = temp;

return (temp);

}GenerateKey(type16 *A, type16 *B)

{

for (int i=0;i<8;i++) B[i] = A[i];

sdvig25(A);

for (i=0;i<8;i++) B[i+8] = A[i];

sdvig25(A);

for (i=0;i<8;i++) B[i+16] = A[i];

sdvig25(A);

for (i=0;i<8;i++) B[i+24] = A[i];

sdvig25(A);

for (i=0;i<8;i++) B[i+32] = A[i];

sdvig25(A);

for (i=0;i<8;i++) B[i+40] = A[i];

sdvig25(A);

for (i=0;i<4;i++) B[i+48] = A[i];

return 1;

}sdvig25(type16 *A)

{

type32 *massiv = new type32 [4];

type32 *out = new type32 [4];

type32 *bit7 = new type32 [4];

type32 *bit25 = new type32 [4];

*massiv = *(type32*)A;

*(massiv + 1) = *(type32*)(A + 2);

*(massiv + 2) = *(type32*)(A + 4);

*(massiv + 3) = *(type32*)(A + 6);

bit7 [0] = ((massiv[0]&0x7f)<<25)&0xfe000000;

bit25[0] = ((massiv[0]&0xffffff80)>>7)&0x1ffffff;

bit7 [1] = ((massiv[1]&0x7f)<<25)&0xfe000000;

bit25[1] = ((massiv[1]&0xffffff80)>>7)&0x1ffffff;

bit7 [2] = ((massiv[2]&0x7f)<<25)&0xfe000000;

bit25[2] = ((massiv[2]&0xffffff80)>>7)&0x1ffffff;

bit7 [3] = ((massiv[3]&0x7f)<<25)&0xfe000000;

bit25[3] = ((massiv[3]&0xffffff80)>>7)&0x1ffffff;

out[0] = bit7[0]|bit25[3];

out[1] = bit7[1]|bit25[0];

out[2] = bit7[2]|bit25[1];

out[3] = bit7[3]|bit25[2];

*(type32*)A = out[0];

*(type32*)(A + 2) = out[1];

*(type32*)(A + 4) = out[2];

*(type32*)(A + 6) = out[3];

delete massiv;

delete bit7;

delete bit25;

delete out;

return 1;

}IDEA_OFB(unsigned *mes,unsigned *key,unsigned *NZ, int n)

{ // mes - n * 16bit

IDEA(key,NZ);

for (int i = 0; i<n; i++) mes[i] ^= NZ[3-i];

SdvigMas1_4(NZ);

}mul(unsigned a, unsigned b)

{

unsigned long p;

if (a)

{ if (b)

{ p = (unsigned long)a * b;

b = p&0xffffU;

a = p>>16;

return b - a + (b < a);

}

else return 1-a;

}

else return 1-b;

}