Литература

1. Модели технических разведок и угроз безопасности информации. Коллективная монография / Под ред. Е.М. Сухарева. Кн. 3. – М.:Радиотехника, 2003 г.;

2. Лидл Р., Пильц Г. Прикладная абстрактная алгебра: Учебное пособие/пер. с англ. – Екатеринбург: Изд-во Урал. Ун-та, 1996 г.;

3. Шеннон К. Теория связи в цифровых системах // Шеннон К., Работы по теории информации и кибернетике, М.: ИИЛ, 1963 – с.333-402;

4. Молдовян А.А., Молдовян Н.А., Гуц Н.Д., Изотов Б.В. «Криптография: скоростные шифры.» – СПб.: БХВ-Петербург, 2002;

5. Иванов М.А., Чугунков И.В. Теория, применение и оценка качества генераторов псевдослучайных последовательностей. – М.:КУДРИЦ-ОБРАЗ, 2003;

6. Б. Шнаер «Прикладная криптография. Протоколы, алгоритмы, исходные тексты на языке Си.» – М.: Издательство ТРИУМФ, 2003;

7. А.Л. Чмора, “Современная прикладная криптография”. Москва “Гелиос АРВ” 2001;

8. G. Marsaglia, Пакет статистических тестов DIEHARD, 1997, geo@stat.fsu.edu;

9. Материалы сайта http://cs-www.ncsl.nist.gov/rng/rng2.html;

10. Моисеева Н.К., Павлова А.М., Проскуряков А.В., Методика выполнения организационно-экономической части дипломного проекта. – М.: МИЭТ, 1987;

11. Каракеян В.И., Константинова Л.А., Писеев В.М., Лабораторный практикум по курсу “Производственная и экологическая безопасность в микроэлектронике”.-М.: МИЭТ,1990;

12. S. Mister and C. Adams, “Practical s-box Design", Workshop Record of the Work-shop on Selected Areas in Cryptography (SAC '96), Queen's University, Kingston, Ontario, 1996;

13. Biham E., Shamir A. “Differential cryptanalysis of DES-like cryptosystems //

Advances in Cryptology” — CRYPTO ′90. LNCS, v. 537, Springer-Verlag, 1991;

13. Дж. Диксон, “Проектирование систем: изобретательство, анализ и принятие решений”, Москва, “Мир”, 1969г..

Приложение 1

Комплекс программ, реализующий алгоритмы маскирования (операция Xor) и (операция Mult) , и набор тестов для частотного анализа выходных последовательностей алгоритмов маскирования в вычислительной среде MatLab 6.0 и Borland С++ Builder 6 состоит из 20 модулей. Ниже я приведу листинг некоторых функций и процедур.

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

#include <vcl.h>

#pragma hdrstop

#include <stdlib.h>

#include <stdio.h>

#include <io.h>

#include <sys\stat.h>

#include <fcntl.h>

#include <fstream>

typedef unsigned long u4;

#include "Unit1.h"

#include "Unit2.h"

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

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

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

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

randomize();

StatusBar1->Panels->Items[0]->Text = "Произведите действие:";

}

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

//функция индикации выбора алгорима маскирования (операция Xor)

void __fastcall TForm1::Xor1Click(TObject *Sender)

{

Mult->Checked = 0;

Xor1->Checked = !Xor1->Checked;

if (Xor1->Checked)

{

StatusBar1->Panels->Items[0]->Text = "Маскирование данных будет производиться используя алгорим (операция Xor)";

}else

{

StatusBar1->Panels->Items[0]->Text = "Выберете алгоритм маскирования";

}

}

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

//функция индикации выбора алгорима маскирования (операция Mult)

void __fastcall TForm1::MultClick(TObject *Sender)

{

Xor1->Checked = 0;

Mult->Checked = !Mult->Checked;

if (Mult->Checked)

{

StatusBar1->Panels->Items[0]->Text = "Маскирование данных будет производиться используя алгорим (операция Mult)";

}else

{

StatusBar1->Panels->Items[0]->Text = "Выберете алгоритм маскирования";

}

}

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

//функция реализующая загрузку данных для маскирования/демаскирования

void __fastcall TForm1::N5Click(TObject *Sender)

{

MyFName = "";

OpenDialog1->Title = "Загрузить файл";

if (OpenDialog1->Execute()){

MyFName = OpenDialog1->Files->Text;

StatusBar1->Panels->Items[0]->Text = "Данные для маскирования успешно загружены:";

}else{

StatusBar1->Panels->Items[0]->Text = "Загрузите данные для маскирования:";

}

}

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

//функция реализации выхода из программы

void __fastcall TForm1::N6Click(TObject *Sender)

{

Free();

exit(1);

Form1->Close();

}

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

//функция проверки ввода всех параметров алгоритма и данных

void __fastcall TForm1::Button1Click(TObject *Sender)

{

if (Xor1->Checked == 1){

if (MyFName != ""){

algoritm = 1;

if (StrToInt(Form2->Edit1->Text) != 0){

read_file(StrToInt(Form2->Edit1->Text),algoritm);

n = StrToInt(Form2->Edit1->Text);

StatusBar1->Panels->Items[0]->Text = "маскирование (демаскирование) данных прошло успешно:";

}

else ShowMessage("Задайте параметры алгоритма:");

}else{

ShowMessage("Данные для маскирования/демаскирования не загружены:");

StatusBar1->Panels->Items[0]->Text = "Загрузите данные";

}

}else {

if (Mult->Checked == 1){

if (MyFName != ""){

algoritm = 2;

if (StrToInt(Form2->Edit1->Text) != 0){

read_file(StrToInt(Form2->Edit1->Text),algoritm);

n = StrToInt(Form2->Edit1->Text);

StatusBar1->Panels->Items[0]->Text = "Маскирование/Демаскирование данных прошло успешно:";

}

else ShowMessage("Задайте параметры алгоритма:");

}else{

ShowMessage("Данные для маскирования/демаскирования не загружены:");

StatusBar1->Panels->Items[0]->Text = "Загрузите данные";

}

}

else{

ShowMessage("Не выбран алгоритм маскирования/демаскирования");

StatusBar1->Panels->Items[0]->Text = "Выберете алгоритм маскирования/демаскирования";

}

}

}

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

//Функция считывания входных данных и записи резельтируещих данных

unsigned long TForm1::read_file(int n,int algoritm)

{

get_rand_matr(n); //заполняем ключевую матрицу A и ключевой вектор B

get_c(n);

unsigned long *x;

x = new unsigned long[n];

//Создаем поток и загружаем в него файл

MyFName = MyFName.SubString(1,MyFName.Length()-2);

TFileStream *tfile=new TFileStream(MyFName,fmOpenReadWrite);

//Можно не применять - при открытии указатель и так на нуле

tfile->Seek(0,0);

//Буфер для информации

unsigned long *virgBuf;

//Выделяем память для буфера информации

virgBuf=(unsigned long *)malloc(tfile->Size);

int len =tfile->Size;

len = len/sizeof(unsigned long);

int k = len/n;

//нужно реализовать создание и открытие с последущей записью У

//реализация вывода в файл

int handle;

FILE *in;

handle = creat("result.txt", S_IREAD |S_IWRITE);

if ((in = fopen("result.txt", "r+")) == NULL)

{

ShowMessage("Error opening file.");

return 0;

}

u4 *res;

int file;

res = new u4[n];

for (int j=0;j<k;j++){

for (int i=0;i<n;i++){

//Читаем информацию в буфер

tfile->Read(virgBuf,sizeof(unsigned long));

x[i] = *virgBuf;

tfile->Seek(soFromCurrent,4);

}

if (algoritm == 1){

res = form_shifrX(&x[0],n);

}

if (algoritm == 2){

res = form_shifrM(&x[0],n);

}

for (int m=0;m<n;m++){

file = write(handle, &res[m], 4);

}

}

close(handle);

fclose(in);

delete x;

//Освобождаем память

free(virgBuf);

//Освобождают поток и переносим в память

tfile->Free();

return 0;

}

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

//Функции реализующие алгоритм маскирования/демаскирования данных

u4* TForm1::form_shifrM(unsigned long* x,int n)

{

__int64 temp_x;

unsigned long temp_sum_mod2,temp_32;

unsigned long *y;

y = new unsigned long[n];

for(int j=0;j<n;j++){

temp_x = shifr_raund_modM(&x[0],&y[0],j,n);

temp_32 = To(&temp_x);

temp_sum_mod2 = sum_mod2(&temp_32,j);

y[j] = sum(&temp_sum_mod2,&x[0],j);

}

return y;

}

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

u4* TForm1::form_shifrX(unsigned long* x,int n)

{

__int64 temp_x;

unsigned long temp_sum_mod2,temp_32;

unsigned long *y;

y = new unsigned long[n];

for(int j=0;j<n;j++){

temp_x = shifr_raund_modX(&x[0],&y[0],j,n);

temp_32 = To(&temp_x);

temp_sum_mod2 = sum_mod2(&temp_32,j);

y[j] = sum(&temp_sum_mod2,&x[0],j);

}

return y;

}

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

__int64 TForm1::shifr_raund_modM(unsigned long* temp,unsigned long* y, int j,int n)

{

__int64 temp_x;

if (j==0){

temp_x = shifr_raund_sum0M(&temp[0],j,n);

}else{

if (j==(n-1)){

temp_x = shifr_raund_sumnM(&y[0],j,n);

}else{

temp_x = shifr_raund_sumM(&temp[0],&y[0],j,n);

}

}

return temp_x;

}

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

__int64 TForm1::shifr_raund_modX(unsigned long* temp,unsigned long* y, int j,int n)

{

__int64 temp_x;

if (j==0){

temp_x = shifr_raund_sum0X(&temp[0],j,n);

}else{

if (j==(n-1)){

temp_x = shifr_raund_sumnX(&y[0],j,n);

}else{

temp_x = shifr_raund_sumX(&temp[0],&y[0],j,n);

}

}

return temp_x;

}

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

//функция выборки из 2*N (где N =32 бита ) N бит

unsigned long TForm1::To(__int64* temp)

{

unsigned long peremX = *temp;

peremX = peremX >>16;

unsigned long per;

__int64 perem = *temp;

perem = perem >>8;

per = perem;

per = per^peremX;

return per;

}

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

unsigned long TForm1::sum_mod2(unsigned long* temp,int j)

{

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

unsigned long perem;

perem = (*temp)^c[j][n-1];

return perem;

}

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

unsigned long TForm1::sum(unsigned long* temp,unsigned long* x,int j)

{

//

unsigned long res;

res = x[j] ^ *temp;

return res;

}

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

__int64 TForm1::shifr_raund_sum0M(unsigned long *x,int j,int n)

{

//реализация первого такта шифрования

__int64 temp_x=0;

for(int i=0;i<n-j-1;i++){

temp_x += x[i+j+1]*c[j][i];

}

return temp_x;

}

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

__int64 TForm1::shifr_raund_sumnM(unsigned long* y,int j,int n)

{

//реализация последнего такта шифрования

__int64 temp_x2=0;

int cin = 0;

for(int i = n-1-j;i<n-1;i++){

temp_x2 += y[cin]*c[j][i];

cin++;

}

return temp_x2;

}

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

__int64 TForm1::shifr_raund_sumM(unsigned long *x,unsigned long *y,int j,int n)

{

__int64 temp_x,temp_x1=0,temp_x2=0;

for (int i=0;i<n-j-1;i++){

temp_x1 += x[i+j+1]*c[j][i];

}

int cin = 0;

for(int i = n-1-j;i<n-1;i++){

temp_x2 += y[cin]*c[j][i];

cin++;

}

//нужна функция выборки 32 бит

temp_x = temp_x1 + temp_x2;

return temp_x;

}

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

__int64 TForm1::shifr_raund_sum0X(unsigned long *x,int j,int n)

{

//реализация первого такта шифрования

__int64 temp_x=0;

for(int i=0;i<n-j-1;i++){

temp_x += x[i+j+1]^c[j][i];

}

return temp_x;

}

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

__int64 TForm1::shifr_raund_sumnX(unsigned long* y,int j,int n)

{

//реализация последнего такта шифрования

__int64 temp_x2=0;

int cin = 0;

for(int i = n-1-j;i<n-1;i++){

temp_x2 += y[cin]^c[j][i];

cin++;

}

return temp_x2;

}

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

__int64 TForm1::shifr_raund_sumX(unsigned long *x,unsigned long *y,int j,int n)

{

__int64 temp_x,temp_x1=0,temp_x2=0;

for (int i=0;i<n-j-1;i++){

temp_x1 += x[i+j+1]*c[j][i];

}

int cin = 0;

for(int i = n-1-j;i<n-1;i++){

temp_x2 += y[cin]^c[j][i];

cin++;

}

//нужна функция выборки 32 бит

temp_x = temp_x1 + temp_x2;

return temp_x;

}

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

//Функция генерации секретного ключа

void TForm1::get_rand_matr(int n)

{

//реализация простого рандома

for (int i=0;i<n;i++){

for(int j=0;j<(n-1);j++){

a[i][j] = random(429496729);

}

b[i] = random(429496729);

}

}

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

void TForm1::get_c(int n)

{

//реализация расширенной матрицы

for (int i=0;i<n;i++){

for(int j=0;j<(n-1);j++){

c[i][j] = a[i][j];

}

c[i][n-1] = b[i];

}

}

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

//функция реализующая загрузку данных для маскирования/демаскирования

void __fastcall TForm1::N4Click(TObject *Sender)

{

MyFName = "";

OpenDialog1->Title = "Загрузить файл";

if (OpenDialog1->Execute()){

MyFName = OpenDialog1->Files->Text;

StatusBar1->Panels->Items[0]->Text = "Данные для маскирования успешно загружены:";

}else{

StatusBar1->Panels->Items[0]->Text = "Загрузите данные для маскирования:";

}

}

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

% Проверка ключа на случайность по критерию k-распределенности (Кнут).

X=[1 0 0 1 1 1 1 0 0 1 0 1 1 0 0 1 1 0 0 1 1 0 1 1 0 0 1 0 1 0 0 0 1 1 1 0 0 1 1 1 1 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 0 1 1 1 0 1 0 1 1 1 0 1 0 1 0 0 1 0 1 1 1 0 0 0 0 1 1 0 0 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 1 0 0 1 0 1 0 1 1 1 0 1 0 1 0 1 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 0 1 1 0 0 0 1 1 0 0 1 1 0 0 0 1 0 0 0 1 1 1 1 1 1 0 1 1 0 1 0 1 1 1 0 0 0 1 1 1 0 0 0 0 1 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 1 1 1 0 0 1 1 0 0 1 0 0 0 0 1 0 1 0 0 1 1 1 0 1 0 1 0 0 1];

%--------1-распределение ---------

num_zero=0;

num_ones=0;

for i=1:256,

if X(i)==0,

num_zero=num_zero+1;

else

num_ones=num_ones+1;

end

end

if abs(num_zero/256-0.5)<=0.0625 & abs(num_ones/256-0.5)<=0.0625,

'1-raspredelenie=yes'

else

'1-raspredelenie=no'

end

%--------2-распределение ---------

num(1:4)=0;

for i=1:256,

num(polyval([X(i),X(mod(i,256)+1)],2)+1)=num(polyval([X(i),X(mod(i,256)+1)],2)+1)+1;

end

if abs(num(1)/256-0.25)<=0.0625 & abs(num(2)/256-0.25)<=0.0625 & abs(num(3)/256-0.25)<=0.0625 & abs(num(4)/256-0.25)<=0.0625,

'2-raspredelenie=yes'

else

'2-raspredelenie=no'

end

%--------3-распределение ---------

num(1:8)=0;

for i=1:256,

num(polyval([X(i) X(mod(i,256)+1) X(mod(i+1,256)+1)],2)+1)=num(polyval([X(i) X(mod(i,256)+1) X(mod(i,255)+1)],2)+1)+1;

end

if abs(num(1)/256-0.125)<=0.0625 & abs(num(2)/256-0.125)<=0.0625 & abs(num(3)/256-0.125)<=0.0625 & abs(num(4)/256-0.125)<=0.0625 & abs(num(5)/256-0.125)<=0.0625 & abs(num(6)/256-0.125)<=0.0625 & abs(num(7)/256-0.125)<=0.0625 & abs(num(8)/256-0.125)<=0.0625,

'3-raspredelenie=yes'

else

'3-raspredelenie=no'

end

%--------4-распределение ---------

num(1:16)=0;

for i=1:256,

num(polyval([X(i) X(mod(i,256)+1) X(mod(i+1,256)+1) X(mod(i+2,256)+1)],2)+1)=num(polyval([X(i) X(mod(i,256)+1) X(mod(i+1,256)+1) X(mod(i+2,256)+1)],2)+1)+1;

end

if abs(num(1)/256-0.0625)<=0.0625 & abs(num(2)/256-0.0625)<=0.0625 & abs(num(3)/256-0.0625)<=0.0625 & abs(num(4)/256-0.0625)<=0.0625 & abs(num(5)/256-0.0625)<=0.0625 & abs(num(6)/256-0.0625)<=0.0625 & abs(num(7)/256-0.0625)<=0.0625 & abs(num(8)/256-0.0625)<=0.0625 & abs(num(9)/256-0.0625)<=0.0625 & abs(num(10)/256-0.0625)<=0.0625 & abs(num(11)/256-0.0625)<=0.0625 & abs(num(12)/256-0.0625)<=0.0625 & abs(num(13)/256-0.0625)<=0.0625 & abs(num(14)/256-0.0625)<=0.0625 & abs(num(15)/256-0.0625)<=0.0625 & abs(num(16)/256-0.0625)<=0.0625,

'4-raspredelenie=yes'

else

'4-raspredelenie=no'

end

%--------------------------------

% Частотный тест.

fid=fopen('inputseq.txt');

S = fscanf(fid,'%d ',inf);

fclose(fid);

siz=size(S);

n=siz(1);

X=2*S-1;

Sn=sum(X);

Sobs=abs(Sn)/sqrt(n);

Pvalue=erfc(Sobs/sqrt(2));

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Тест на самую длинную серию единиц в блоке

fid=fopen('inputseq.txt');

S = fscanf(fid,'%d ',inf);

fclose(fid);

n=6272;

K=5;

M=128;

N=49;

for i=1:N,

for j=1:M,

B(i,j)=S(j+M*(i-1));

end

end

for i=1:N,

count=0;

run=0;

for j=1:M,

if B(i,j)==0,

count=0;

else

count=count+1;

end

if count>run,

run=count;

end

end

runs(i)=run;

end

for i=1:6,

v(i)=0;

end

for i=1:N,

if runs(i)<=4,

v(1)=v(1)+1;

end

if runs(i)==5,

v(2)=v(2)+1;

end

if runs(i)==6,

v(3)=v(3)+1;

end

if runs(i)==7,

v(4)==v(4)+1;

end

if runs(i)==8,

v(5)=v(5)+1;

end

if runs(i)>=9,

v(6)=v(6)+1;

end

end

p(1)=0.1174;

p(2)=0.2430;

p(3)=0.2493;

p(4)=0.1752;

p(5)=0.1027;

p(6)=0.1124;

XiSquare=0;

for i=1:(K+1),

XiSquare=XiSquare+((v(i)-N*p(i))^2)/(N*p(i));

end

Pvalue=1-gammainc(XiSquare/2,K/2)

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Тест ранга двоичных матриц

fid=fopen('inputseq.txt');

S = fscanf(fid,'%d ',inf);

fclose(fid);

n=99328;

M=32;

Q=32;

N=97;

for i=1:N*M,

for j=1:Q,

B(i,j)=S(j+Q*(i-1));

end

end

for i=1:N,

r(i)=rank(B((1+(i-1)*M):(M+(i-1)*M),1:Q));

end

MAXR=M;

for i=1:3,

F(i)=0;

end

for i=1:N,

if r(i)==MAXR,

F(1)=F(1)+1;

elseif r(i)==MAXR-1,

F(2)=F(2)+1;

else

F(3)=F(3)+1;

end

end

p(1)=0.2888;

p(2)=0.5776;

p(3)=0.1336;

XiSquare=0;

for i=1:3,

XiSquare=XiSquare+((F(i)-N*p(i))^2)/(N*p(i));

end

%Pvalue=1-gammainc(XiSquare/2,1)

Pvalue=exp(-XiSquare/2);

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Спектральный тест

fid=fopen('inputseq.txt');

e = fscanf(fid,'%u ',inf);

fclose(fid);

num=size(e); n=num(1);

for i=1:n,

x(i)=2*e(i)-1;

end

s=fft(x);

M=abs(s(1:n/2));

plot(M);grid

T=sqrt(3*n);

N0=0.95*n/2

N1=0;

for i=1:n/2,

if M(i)<T,

N1=N1+1;

end

end

N1

d=(N1-N0)/(sqrt(n*0.95*0.05/2))

Pvalue=erfc(abs(d)/sqrt(2))

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Универсальный статистический тест Маурэра.

fid=fopen('inputseq.txt');

S = fscanf(fid,'%d ',inf);

fclose(fid);

n=470016;

L=6;

Q=640;

K=77696;

for i=1:(Q+K),

for j=1:L,

QK(i,j)=S(j+L*(i-1));

end

end

for i=1:2^L,

T(i)=0;

end

for i=1:Q,

j=polyval(QK(i,:),2);

T(j+1)=i;

end

sum=0;

for i=(Q+1):(Q+K),

j=polyval(QK(i,:),2);

sum=sum+log2(i-T(j+1));

T(j+1)=i;

end

fn=sum/K;

c=0.7-(0.8/L)+((4+32/L)*(K^(-3/L))/15);

sigma=c*sqrt(2.954/K);

Pvalue=erfc(abs(fn-5.2177052)/(sqrt(2)*sigma));

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Сжатие при помощи алгоритма Лемпела-Зива.

fid=fopen('inputseq.txt');

s = fscanf(fid,'%d ',inf);

fclose(fid);

sizeofS=size(s);

%n=sizeofS(1);

n=100000;

slovar=num2str(s(1));

i=2;

while i<=n,

str=num2str(s(i));

r=1;

k=0;

while r==1,

r=0;

siz=size(slovar);

sizeofstr=size(str);

for j=1:siz(1),

if sizeofstr==size(deblank(slovar(j,:))),

if str==deblank(slovar(j,:)),

r=1;

end

end

end

if r==1,

str=strcat(str,num2str(s(i+k+1)));

k=k+1;

else

slovar=strvcat(slovar,str);

end

end

i=i+k+1;

end

W=size(slovar);

Wobs=W(1);

Pvalue=0.5*erfc(abs(69586.25-Wobs)/sqrt(2*70.448718))

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Тест линейной сложности.

fid=fopen('output.txt');

L = fscanf(fid,'%u ',inf);

fclose(fid);

n=1000000;

M=1000;

N=1000;

K=6;

miuTeor=M/2+(9+(-1)^(M+1))/36-(M/3+2/9)/2^M;

for i=1:N,

T(i)=((-1)^M)*(L(i)-miuTeor)+2/9;

end

for i=1:7,

v(i)=0;

end

for i=1:N,

if (T(i)<=-2.5),

v(1)=v(1)+1;

end

if (T(i)>-2.5)&(T(i)<=-1.5),

v(2)=v(2)+1;

end

if (T(i)>-1.5)&(T(i)<=-0.5),

v(3)=v(3)+1;

end

if (T(i)>-0.5)&(T(i)<=0.5),

v(4)=v(4)+1;

end

if (T(i)>0.5)&(T(i)<=1.5),

v(5)=v(5)+1;

end

if (T(i)>1.5)&(T(i)<=2.5),

v(6)=v(6)+1;

end

if (T(i)>2.5),

v(7)=v(7)+1;

end

end

p(1)=0.01047;

p(2)=0.03125;

p(3)=0.12500;

p(4)=0.50000;

p(5)=0.25000;

p(6)=0.06250;

p(7)=0.020833;

XiSquare=0;

for i=1:(K+1),

XiSquare=XiSquare+((v(i)-N*p(i))^2)/(N*p(i));

end

Pvalue=1-gammainc(XiSquare/2,K/2)

if Pvalue>0.01,

result='test +'

else

result='test -'

end

% Вычисление линейной сложности с помощью алгоритма “Берлекампа-Месси”.

#include <stdio.h>

#include <stdlib.h>

#include <dos.h>

long BerlekampMassey(char *s, long n, long *C)

{

long L = 0, N = 0, d, e, i, m = - 1, n1 = n + 1, sum;

long dB = 0, dC = 0, dT;

long *B = malloc(n1 * sizeof(long));

long *D = malloc(n1 * sizeof(long));

long *T = malloc(n1 * sizeof(long));

for (i = 1; i < n1; i++) B[i] = C[i] = T[i] = 0;

T[0] = 0;

C[0] = B[0] = 1;

while (N < n) {

sum = 0;

for (i = 1; i <= L; i++) sum += C[i] * s[N - i];

d = (s[N] + sum) & 1l;

if (d == 1) {

dT = dC;

for (i = 0; i <= dT; i++) T[i] = C[i];

e = N - m;

for (i = 0; i < e; i++) D[i] = 0;

for (i = 0; i <= dB; i++) D[i + e] = B[i];

D[e] = 1;

for (i = 0; i <= dB + e; i++)

C[i] = (C[i] + D[i]) & 1l;

if (dB + e > dC) dC = dB + e;

if (L <= N / 2) {

dB = dT;

for (i = 0; i <= dB; i++) B[i] = T[i];

L = N + 1 - L, m = N;

}

}

N++;

}

free(B);

free(D);

free(T);

return L;

}

void main(void)

{

char sb[1000], s[1000000];

long i, j, n = 1000000, M = 1000, N = 1000, C[1000], L[1000];

FILE *stream1;

stream1 = fopen("inputseq.txt", "r");

for (i = 0; i < n; i++) fscanf(stream1, "%d", &s[i]);

fclose(stream1);

FILE *stream2;

stream2 = fopen("output.txt", "w+");

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

{

for (j = 0; j < M; j++) sb[j] = s[j+M*i];

L[i] = BerlekampMassey(sb, M, C);

}

for (i = 0; i < N; i++) fprintf(stream2, "%d ", L[i]);

fclose(stream2);

}

% Построение профиля линейной сложности.

#include <stdio.h>

#include <stdlib.h>

#include <dos.h>

long BerlekampMassey(char *s, long n, long *C)

{

long L = 0, N = 0, d, e, i, m = - 1, n1 = n + 1, sum;

long dB = 0, dC = 0, dT;

long *B = malloc(n1 * sizeof(long));

long *D = malloc(n1 * sizeof(long));

long *T = malloc(n1 * sizeof(long));

for (i = 1; i < n1; i++) B[i] = C[i] = T[i] = 0;

T[0] = 0;

C[0] = B[0] = 1;

while (N < n) {

sum = 0;

for (i = 1; i <= L; i++) sum += C[i] * s[N - i];

d = (s[N] + sum) & 1l;

if (d == 1) {

dT = dC;

for (i = 0; i <= dT; i++) T[i] = C[i];

e = N - m;

for (i = 0; i < e; i++) D[i] = 0;

for (i = 0; i <= dB; i++) D[i + e] = B[i];

D[e] = 1;

for (i = 0; i <= dB + e; i++)

C[i] = (C[i] + D[i]) & 1l;

if (dB + e > dC) dC = dB + e;

if (L <= N / 2) {

dB = dT;

for (i = 0; i <= dB; i++) B[i] = T[i];

L = N + 1 - L, m = N;

}

}

N++;

}

free(B);

free(D);

free(T);

return L;

}

void main(void)

{

char s[10000];

long i, j, n = 10000, L[10000], n1=n+1;

long *sb = malloc(n1 * sizeof(long));

long *C = malloc(n1 * sizeof(long));

FILE *stream1;

stream1 = fopen("inputseq.txt", "r");

for (i = 0; i < n; i++) fscanf(stream1, "%d", &s[i]);

fclose(stream1);

FILE *stream2;

stream2 = fopen("outputprofil.txt", "w+");

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

{

for (j = 0; j < i+1; j++) sb[j] = s[j];

L[i] = BerlekampMassey(sb, (i+1), C);

}

for (i = 0; i < n; i++) fprintf(stream2, "%d ", L[i]);

fclose(stream2);

}