Xreferat.com » Рефераты по информатике и программированию » Защита информации в системах дистанционного обучения с монопольным доступом

Защита информации в системах дистанционного обучения с монопольным доступом

BLOCK(01_00)

BLOCK(01_01)

BLOCK(01_02)

BLOCK(01_03)

BLOCK(01_04)

BLOCK(01_05)

BLOCKS_END(01)


BLOCKS_SIZE_START(01)

BLOCK_SIZE(01_00)

BLOCK_SIZE(01_01)

BLOCK_SIZE(01_02)

BLOCK_SIZE(01_03)

BLOCK_SIZE(01_04)

BLOCK_SIZE(01_05)

BLOCKS_SIZE_END(01)

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


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

// Блок N2. (xN)

// Служит для инициализации модификатора нужным значением.

// ES_VARIABLE_0 - ячейка которая может быть занята под значение.

// ES_REG_0 - регистр который может быть занят под значение.

// ES_VARIABLE_1 - ячейка, где может храниться модификатор

// ES_COSNT_0 - здесь может храниться модификатор

BLOCK_START(02_00)

EO_MOV, EOP_VAR, ES_VARIABLE_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(02_00)


BLOCK_START(02_01)

EO_MOV, EOP_REG, ES_REG_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(02_01)


BLOCK_START(02_02)

EO_MOV, EOP_VAR, ES_VARIABLE_0, EOP_CONST, ES_CONST_0

BLOCK_END(02_02)


BLOCK_START(02_03)

EO_MOV, EOP_REG, ES_REG_0, EOP_CONST, ES_CONST_0

BLOCK_END(02_03)


BLOCK_START(02_04)

EO_XCHG, EOP_VAR, ES_VARIABLE_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(02_04)


BLOCK_START(02_05)

EO_XCHG, EOP_REG, ES_REG_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(02_05)


BLOCK_START(02_06)

EO_PUSH, EOP_CONST, ES_CONST_0,

ES_RANDOM_NOP,

ES_RANDOM_NOP,

EO_POP, EOP_REG, ES_REG_0

BLOCK_END(02_06)


BLOCK_START(02_07)

EO_MOV, EOP_VAR, ES_VARIABLE_0, EOP_CONST, 0,

EO_ADD, EOP_VAR, ES_VARIABLE_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(02_07)


BLOCKS_START(02)

BLOCK(02_00)

BLOCK(02_01)

BLOCK(02_02)

BLOCK(02_03)

BLOCK(02_04)

BLOCK(02_05)

BLOCK(02_06)

BLOCK(02_07)

BLOCKS_END(02)


BLOCKS_SIZE_START(02)

BLOCK_SIZE(02_00)

BLOCK_SIZE(02_01)

BLOCK_SIZE(02_02)

BLOCK_SIZE(02_03)

BLOCK_SIZE(02_04)

BLOCK_SIZE(02_05)

BLOCK_SIZE(02_06)

BLOCK_SIZE(02_07)

BLOCKS_SIZE_END(02)

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


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

// Блок N3. (xN)

// Служит для преобразования одной ячейки памяти.

// ES_VARIABLE_0 - указатель на ячейку памяти

// ES_REG_0 - /

// ES_VARIABLE_1 - модификатор

// ES_REG_1 - /

// ES_VARIABLE_2 - счетчик

// ES_REG_2 - /

// ES_SPECIFIC_0 - сюда подставить операцию

//. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .


const static int block_03_operation_AB[] =

{

EO_XOR, EO_ADD, EO_SUB

};


const static int block_03_operation_BA[] =

{

EO_XOR, EO_SUB, EO_ADD

};


BLOCK_START(03_00)

ES_SPECIFIC_0, EOP_REF_REG, ES_REG_0, EOP_REG, ES_REG_1

BLOCK_END(03_00)


BLOCK_START(03_01)

ES_SPECIFIC_0, EOP_REF_VAR, ES_VARIABLE_0, EOP_REG, ES_REG_1

BLOCK_END(03_01)


BLOCK_START(03_02)

ES_SPECIFIC_0, EOP_REF_REG, ES_REG_0, EOP_REG, ES_REG_2

BLOCK_END(03_02)


BLOCK_START(03_03)

ES_SPECIFIC_0, EOP_REF_VAR, ES_VARIABLE_0, EOP_REG, ES_REG_2

BLOCK_END(03_03)


BLOCK_START(03_04)

ES_SPECIFIC_0, EOP_REF_REG, ES_REG_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(03_04)


BLOCK_START(03_05)

ES_SPECIFIC_0, EOP_REF_VAR, ES_VARIABLE_0, EOP_VAR, ES_VARIABLE_1

BLOCK_END(03_05)


BLOCK_START(03_06)

ES_SPECIFIC_0, EOP_REF_REG, ES_REG_0, EOP_VAR, ES_VARIABLE_2

BLOCK_END(03_06)


BLOCK_START(03_07)

ES_SPECIFIC_0, EOP_REF_VAR, ES_VARIABLE_0, EOP_VAR, ES_VARIABLE_2

BLOCK_END(03_07)


BLOCKS_START(03)

BLOCK(03_00)

BLOCK(03_01)

BLOCK(03_02)

BLOCK(03_03)

BLOCK(03_04)

BLOCK(03_05)

BLOCK(03_06)

BLOCK(03_07)

BLOCKS_END(03)


BLOCKS_SIZE_START(03)

BLOCK_SIZE(03_00)

BLOCK_SIZE(03_01)

BLOCK_SIZE(03_02)

BLOCK_SIZE(03_03)

BLOCK_SIZE(03_04)

BLOCK_SIZE(03_05)

BLOCK_SIZE(03_06)

BLOCK_SIZE(03_07)

BLOCKS_SIZE_END(03)

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


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

// Блок N4. (x1)

// Служит для увеличения значения указателя.

// ES_VARIABLE_0 - ячейка которая может быть занята под указатель.

// ES_REG_0 - регистр который может быть занят под указатель.

BLOCK_START(04_00)

EO_ADD, EOP_VAR, ES_VARIABLE_0, EOP_CONST, 1

BLOCK_END(04_00)


BLOCK_START(04_01)

EO_INC, EOP_VAR, ES_VARIABLE_0

BLOCK_END(04_01)


BLOCK_START(04_02)

EO_INC, EOP_REG, ES_REG_0

BLOCK_END(04_02)


BLOCK_START(04_03)

EO_SUB, EOP_VAR, ES_VARIABLE_0, EOP_CONST, -1

BLOCK_END(04_03)


BLOCK_START(04_04)

EO_SUB, EOP_REG, ES_REG_0, EOP_CONST, -1

BLOCK_END(04_04)


BLOCK_START(04_05)

EO_NEG, EOP_REG, ES_REG_0,

ES_RANDOM_NOP,

ES_RANDOM_NOP,

EO_DEC, EOP_REG, ES_REG_0,

EO_NEG, EOP_REG, ES_REG_0

BLOCK_END(04_05)


BLOCKS_START(04)

BLOCK(04_00)

BLOCK(04_01)

BLOCK(04_02)

BLOCK(04_03)

BLOCK(04_04)

BLOCK(04_05)

BLOCKS_END(04)


BLOCKS_SIZE_START(04)

BLOCK_SIZE(04_00)

BLOCK_SIZE(04_01)

BLOCK_SIZE(04_02)

BLOCK_SIZE(04_03)

BLOCK_SIZE(04_04)

BLOCK_SIZE(04_05)

BLOCKS_SIZE_END(04)

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


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

// Блок N5. (x1)

// Служит для организации цикла.

// ES_VARIABLE_0 - ячейка которая может быть занята под счетчик.

// ES_REG_0 - регистр который может быть занят под счетчик.

// ES_ADDRESS_0 - куда осуществить переход для повтора цикла.


BLOCK_START(05_00)

EO_DEC, EOP_VAR, ES_VARIABLE_0,

EO_CMP, EOP_VAR, ES_VARIABLE_0, EOP_CONST, 0,

EO_JNZ, EOP_CONST, ES_ADDRESS_0

BLOCK_END(05_00)


BLOCK_START(05_01)

EO_DEC, EOP_REG, ES_REG_0,

EO_CMP, EOP_REG, ES_REG_0, EOP_CONST, 0,

EO_JNZ, EOP_CONST, ES_ADDRESS_0

BLOCK_END(05_01)


BLOCKS_START(05)

BLOCK(05_00)

BLOCK(05_01)

BLOCKS_END(05)


BLOCKS_SIZE_START(05)

BLOCK_SIZE(05_00)

BLOCK_SIZE(05_01)

BLOCKS_SIZE_END(05)

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


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

// Блок N6. (x1)

// Служит для проверки временных ограничений. (может отсутсвовать)

// ES_CONST_0 - константа которая может содержать дату для контроля.

// ES_VARIABLE_0 - ячейка которая может содержать дату для контроля.


BLOCK_START(06_00)

EO_TEST_TIME_0, EOP_CONST, ES_CONST_0

BLOCK_END(06_00)


BLOCK_START(06_01)

EO_TEST_TIME_1, EOP_CONST, ES_CONST_0

BLOCK_END(06_01)


BLOCK_START(06_02)

EO_TEST_TIME_0, EOP_VAR, ES_VARIABLE_0

BLOCK_END(06_02)


BLOCK_START(06_03)

EO_TEST_TIME_1, EOP_VAR, ES_VARIABLE_0

BLOCK_END(06_03)


BLOCKS_START(06)

BLOCK(06_00)

BLOCK(06_01)

BLOCK(06_02)

BLOCK(06_03)

BLOCKS_END(06)


BLOCKS_SIZE_START(06)

BLOCK_SIZE(06_00)

BLOCK_SIZE(06_01)

BLOCK_SIZE(06_02)

BLOCK_SIZE(06_03)

BLOCKS_SIZE_END(06)


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

// Блок N7. (x1)

// Служит для завершения.


BLOCK_START(07_00)

EO_EXIT_0

BLOCK_END(07_00)


BLOCK_START(07_01)

EO_EXIT_1

BLOCK_END(07_01)


BLOCK_START(07_02)

EO_EXIT_2,

EO_NOP_0,

EO_JMP, EOP_CONST, 0

BLOCK_END(07_02)


BLOCKS_START(07)

BLOCK(07_00)

BLOCK(07_01)

BLOCK(07_02)

BLOCKS_END(07)


BLOCKS_SIZE_START(07)

BLOCK_SIZE(07_00)

BLOCK_SIZE(07_01)

BLOCK_SIZE(07_02)

BLOCKS_SIZE_END(07)


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

// Блок NOP.

BLOCK_START(nop_00)

EO_XCHG, EOP_REG, ES_RANDOM_REG, EOP_VAR, ES_RANDOM_VAR,

BLOCK_END(nop_00)


BLOCK_START(nop_01)

EO_ADD, EOP_REG, ES_RANDOM_REG, EOP_REG, ES_RANDOM_USE_REG,

BLOCK_END(nop_01)


BLOCK_START(nop_02)

EO_NOP_0

BLOCK_END(nop_02)


BLOCK_START(nop_03)

EO_NOP_1

BLOCK_END(nop_03)


BLOCK_START(nop_04)

EO_NOP_2

BLOCK_END(nop_04)


BLOCK_START(nop_05)

EO_NOP_3

BLOCK_END(nop_05)


BLOCK_START(nop_06)

EO_MOV, EOP_REG, ES_RANDOM_REG, EOP_RAND

BLOCK_END(nop_06)


BLOCKS_START(Nops)

BLOCK(nop_00)

BLOCK(nop_01)

BLOCK(nop_02)

BLOCK(nop_03)

BLOCK(nop_04)

BLOCK(nop_05)

BLOCK(nop_06)

BLOCKS_END(Nops)


BLOCKS_SIZE_START(Nops)

BLOCK_SIZE(nop_00)

BLOCK_SIZE(nop_01)

BLOCK_SIZE(nop_02)

BLOCK_SIZE(nop_03)

BLOCK_SIZE(nop_04)

BLOCK_SIZE(nop_05)

BLOCK_SIZE(nop_06)

BLOCKS_SIZE_END(Nops)

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


#endif // __BLOCKS_H__


Файл p_enums.h.


#ifndef __P_ENUMS_H__

#define __P_ENUMS_H__


#ifndef CALC_ARRAY_SIZE

#define CALC_ARRAY_SIZE(arr) ((int) (sizeof arr / sizeof arr[0]))

#endif


enum E_OPERATION // Инструкции

{

EO_ERROR = -1, // Недопустимая инструкция

EO_EXIT_0, EO_EXIT_1, EO_EXIT_2, // Конец рабоботы

EO_NOP_0, EO_NOP_1, EO_NOP_2, EO_NOP_3, // Пустые команды

EO_TEST_TIME_0, EO_TEST_TIME_1, // Контроль времени

EO_MOV, EO_XCHG, // Пересылка данных

EO_PUSH, EO_POP, // Работа со стеком

EO_XOR, EO_AND, EO_OR, EO_NOT, // Логические операции

EO_ADD, EO_SUB, EO_MUL, EO_DIV, EO_NEG, // Арифметические операции

EO_INC, EO_DEC,

EO_TEST, EO_CMP, // Операции сравнения

// (влияют на флаги)

EO_JMP, EO_CALL, EO_RET, // Операторы безусловного перехода

EO_JZ, EO_JNZ, EO_JA, EO_JNA, // Условные переходы

};


#define LAST_DEFINED_NOP EO_NOP_3

#define LAST_OPERATION EO_JNA


enum E_FLAGS // Флаги

{

EF_ZERO = 1, // Ноль

EF_ABOVE = 2, // Больше

};


enum E_OPERAND

{ // Операндом является:

EOP_REG = 0, // Регистр

EOP_REF_REG, // Память по адресу в регистре

EOP_VAR, // Переменная

EOP_REF_VAR, // Память по адресу в переменная

EOP_CONST, // Константное значение

EOP_RAND // Случайное число

};


enum E_SUBSTITUTION // Подстановки

{

// НЕ зАБЫВАТЬ подправить ArraySubstitution

ES_RANDOM_NOP = 0x0A0FF00, // Сюда можно подставить любой NOP-блок

ES_RANDOM_CONST = 0x0A0FF01, // Сюда можно подставит любое число

ES_RANDOM_REG = 0x0A0FF02, // Сюда можно подставить любой незанятый

// регистр

ES_RANDOM_VAR = 0x0A0FF03, // Сюда можно подставить любую незанятую

// переменную

ES_RANDOM_USE_REG = 0x0A0FF04, // Сюда можно подставить любой незанятый

// или занятый регистр

ES_RANDOM_USE_VAR = 0x0A0FF05, // Сюда можно подставить любую незанятую

// или занятую переменную

ES_VARIABLE_0 = 0x0B0FF02, // Сюда подставляются данные, актуальные

ES_VARIABLE_1 = 0x0B0FF03, // для данного блока

ES_VARIABLE_2 = 0x0B0FF04,

ES_REG_0 = 0x0C0FF05,

ES_REG_1 = 0x0C0FF06,

ES_REG_2 = 0x0C0FF07,

ES_ADDRESS_0 = 0x0D0AA08,

ES_ADDRESS_1 = 0x0D0AA09,

ES_CONST_0 = 0x0E0AA0A,

ES_CONST_1 = 0x0E0AA0B,

ES_SPECIFIC_0 = 0x0E0BB0C,

ES_SPECIFIC_1 = 0x0E0BB0D

};


static const E_SUBSTITUTION AllSubstitution[] =

{ ES_RANDOM_NOP, ES_RANDOM_CONST, ES_RANDOM_REG, ES_RANDOM_VAR,

ES_RANDOM_USE_REG, ES_RANDOM_USE_VAR,

ES_VARIABLE_0, ES_VARIABLE_1, ES_VARIABLE_2,

ES_REG_0, ES_REG_1, ES_REG_2,

ES_ADDRESS_0, ES_ADDRESS_1,

ES_CONST_0, ES_CONST_1,

ES_SPECIFIC_0, ES_SPECIFIC_1

};

unsigned AllSubstitutionSize = CALC_ARRAY_SIZE(AllSubstitution);


#endif // __P_ENUMS_H__


Файл pdebug.h.


#ifndef __PDEBUG_H__

#define __PDEBUG_H__


#ifdef _DEBUG

#define WRITE_LOG

#endif


#ifdef WRITE_LOG

void WriteToLog(LPCTSTR str, bool newLine = true);

void WriteToLog(int num, bool newLine = true);

#else

inline void WriteToLog(LPCTSTR, bool = true) { }

inline void WriteToLog(int, bool = true) { }

#endif


#endif //__PDEBUG_H__


Файл pdebug.cpp.


#include "stdafx.h"

#include

#include "pdebug.h"

#include "ckg_str.h"


#ifdef WRITE_LOG

static FILE *logFile = NULL;

void WriteToLog(LPCTSTR str, bool newLine)

{

if (!logFile)

{

logFile = _tfopen(_T("uniprot.log"), _T("wb"));

_ASSERT(logFile);

}

fwrite(str, sizeof(TCHAR), _tcslen(str), logFile);

if (newLine)

{

static LPCTSTR endStr = _T("rn");

fwrite(endStr, sizeof(TCHAR), _tcslen(endStr), logFile);

}

fflush(logFile);

}

void WriteToLog(int num, bool newLine)

{

CkgString str;

str.Format(_T("%d "), num);

WriteToLog(str, newLine);

}

#endif


Файл polymorphism.h.


#ifndef __POLYMORPHISM_H__

#define __POLYMORPHISM_H__


// Чему должны быть кранты размеры данных.

#define ROUND_SATA_SIZE 64


// Минимально допустимый год.

// (Вычитется в GetCurrentDayNum)

#define MIN_YEAR 1970 // бездумно не трогать.

// (подумать над DataToDay())


void CryptData (BYTE &dataArray, size_t size, BYTE &algorithmDataArray,

size_t algorithmDataSize);


void DecryptData(BYTE &dataArray, size_t size, BYTE &algorithmDataArray,

size_t algorithmDataSize);


void CryptData (BYTE &dataArray, size_t size, const TCHAR &fileName);


void DecryptData(BYTE &dataArray, size_t size, const TCHAR &fileName);


unsigned GetCurrentDayNum();


void GenerateAlgorithm(pure_c_ptr &algorithmCrypt, size_t &sizeCrypt,

pure_c_ptr &algorithmDecrypt, size_t &sizeDecrypt,

unsigned deltaTimeCrypt = 0,

unsigned deltaTimeDecrypt = 0);


void GenerateAlgorithm(const TCHAR &algorithmCryptFileName,

const TCHAR &algorithmDecryptFileName,

unsigned deltaTimeCrypt = 0,

unsigned deltaTimeDecrypt = 0);


int CoolRand();

int CoolRand(unsigned limit);


#endif // __POLYMORPHISM_H__


Файл polymorphism.cpp.


#include "stdafx.h"

#include

#include

#include

#include "resource.h"

#include "cpp_ptr.h"

#include "c_ptr.h"

#include "ckg_str.h"

#include "ckg_error.h"

#include "ckg_alloc.h"

#include "ckg_array.h"

#include "polymorphism.h"

#include "p_enums.h"

#include "blocks.h"

#include "pdebug.h"


// Количество переменных для виртуальной машины.

// В отличии от виртуальных регистров, переменные

// явдяются инициализированными до начала работы.

const unsigned variablesNum = 20;


// Количество виртуальных регистров

const unsigned registersNum = 10;


const BYTE idSupportAlgorithm = 1; // Идентификатор блока с алгоритмом

const BYTE idCryptAlgorithm = 0; // Алгоритм для шифрования

const BYTE idDecryptAlgorithm = 1; // Алгоритм для расшифрования


const unsigned maxUseTime = INT_MAX; // Ограничение по максимальному

// времени использования (дней).


typedef CkgSimpleContainerArray Block;


struct AlgorithmDataStruct

{

BYTE idSupportAlgorithm;

BYTE idType;

size_t sizeAll;

int variables[variablesNum];

unsigned numVarForSetSize; // В переменную с этим номером занести

// размер данных

};


const unsigned minSizeAlgorithm = 160; // Придельные размеры алгоритма.

const unsigned maxSizeAlgorithm = 200; //

const unsigned minNumTransformation = 2; // Придельное количество

const unsigned maxNumTransformation = 5; // трансформаций.

const unsigned numBlocks = 8; // Количество блоков.

const unsigned numBlocksBeforeLoop = 3; // Количество блоков до метки

// Loop.

const unsigned dataSizeSmoothing = ROUND_SATA_SIZE;

// Чему должны быть кранты

// размеры данных


struct AlgorithmParameters

{

unsigned sizeAlgorithm; // Размер алгоритма

unsigned numTransformation; // Количество блоков для преобразования

bool addressIsReg; // Адрес в регистре или переменной

unsigned addressNumber; // Номер переменной или регистра где

// будет храниться адрес.

bool modificatoryIsReg[maxNumTransformation];

// Модификатор регистр / переменная.

unsigned modificatorsNumbers[maxNumTransformation];

// Номера регистров/переменных для

// модификаторов.

unsigned counterIsReg; // Счетчик в регистре или переменной.

unsigned counterNumber;

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: