Защита информации в системах дистанционного обучения с монопольным доступом
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
pure_c_ptr
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
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;