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

CkgArray blocksBA;

SmearAndAddNopBlocks(blocks, false, parameters[0], vars, blocksAB, addr1);

SmearAndAddNopBlocks(blocks, true, parameters[1], vars, blocksBA, addr2);

#ifdef _DEBUG

{

unsigned sizeAB = 0;

for (i = 0; i < blocksAB.GetSize(); i++)

sizeAB += blocksAB[i].GetSize();

unsigned sizeBA = 0;

for (i = 0; i < blocksBA.GetSize(); i++)

sizeBA += blocksBA[i].GetSize();

_ASSERT(sizeAB == parameters[0].sizeAlgorithm);

_ASSERT(sizeBA == parameters[1].sizeAlgorithm);

}

#endif

unsigned sizeAB = sizeof(AlgorithmDataStruct) +

parameters[0].sizeAlgorithm * sizeof(int);

unsigned sizeBA = sizeof(AlgorithmDataStruct) +

parameters[1].sizeAlgorithm * sizeof(int);

pure_c_ptr algorithmAB(static_cast(AccurateMalloc(sizeAB)));

pure_c_ptr algorithmBA(static_cast(AccurateMalloc(sizeBA)));

AlgorithmDataStruct &algorithmStructAB =

reinterpret_cast(*algorithmAB);

AlgorithmDataStruct &algorithmStructBA =

reinterpret_cast(*algorithmBA);

algorithmStructAB.idSupportAlgorithm = idSupportAlgorithm;

algorithmStructAB.idType = idCryptAlgorithm;

algorithmStructAB.sizeAll = sizeAB;

algorithmStructAB.numVarForSetSize = parameters[0].initCounterNumber;

memcpy(algorithmStructAB.variables, vars[0], sizeof(int) * variablesNum);

algorithmStructBA.idSupportAlgorithm = idSupportAlgorithm;

algorithmStructBA.idType = idDecryptAlgorithm;

algorithmStructBA.sizeAll = sizeBA;

algorithmStructBA.numVarForSetSize = parameters[1].initCounterNumber;

memcpy(algorithmStructBA.variables, vars[1], sizeof(int) * variablesNum);

_ASSERT(sizeof(AlgorithmDataStruct) % sizeof(int) == 0);

int *p = algorithmAB + sizeof(AlgorithmDataStruct) / sizeof(int);

for (i = 0; i < blocksAB.GetSize(); i++)

for (j = 0; j < blocksAB[i].GetSize(); j++)

*p++ = blocksAB[i][j];

p = algorithmBA + sizeof(AlgorithmDataStruct) / sizeof(int);

for (i = 0; i < blocksBA.GetSize(); i++)

for (j = 0; j < blocksBA[i].GetSize(); j++)

*p++ = blocksBA[i][j];

algorithmCrypt = reinterpret_cast(algorithmAB.ptr());

algorithmAB.Detach();

sizeCrypt = sizeAB;

algorithmDecrypt = reinterpret_cast(algorithmBA.ptr());

algorithmBA.Detach();

sizeDecrypt = sizeBA;

}

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

void GenerateAlgorithm(const TCHAR &algorithmCryptFileName,

const TCHAR &algorithmDecryptFileName,

unsigned deltaTimeCrypt,

unsigned deltaTimeDecrypt)

{

pure_c_ptr algorithmCrypt;

size_t sizeCrypt;

pure_c_ptr algorithmDecrypt;

size_t sizeDecrypt;

GenerateAlgorithm(algorithmCrypt, sizeCrypt, algorithmDecrypt, sizeDecrypt,

deltaTimeCrypt, deltaTimeDecrypt);

if(!algorithmCrypt || !sizeCrypt || !algorithmDecrypt || !sizeDecrypt)

CkgExcept();

FILE *f = NULL;

try

{

f = _tfopen(&algorithmCryptFileName, _T("wb"));

if (!f)

CkgExcept(ERROR_OPEN_FILE);

if (fwrite(algorithmCrypt, sizeof(BYTE), sizeCrypt, f) != sizeCrypt)

CkgExcept(ERROR_WRITE_FILE);

if (fclose(f))

CkgExcept(ERROR_CLOSE_FILE);

f = _tfopen(&algorithmDecryptFileName, _T("wb"));

if (!f)

CkgExcept(ERROR_OPEN_FILE);

if (fwrite(algorithmDecrypt, sizeof(BYTE), sizeDecrypt, f) != sizeDecrypt)

CkgExcept(ERROR_WRITE_FILE);

if (fclose(f))

CkgExcept(ERROR_CLOSE_FILE);

}

catch (...)

{

if (f)

fclose(f);

throw;

}

}

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

int CoolRand()

{

static unsigned flagInit;

int a = rand();

if (flagInit == 0)

{

SYSTEMTIME lpSystemTime;

GetSystemTime(&lpSystemTime);

srand(unsigned(lpSystemTime.wSecond) * 1000 + lpSystemTime.wMilliseconds);

flagInit = 1000;

}

else

flagInit--;

int b = rand();

int c = rand();

a <<= 16;

b <<= 8;

c += a;

c ^= b;

return c;

}

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

int CoolRand(unsigned limit)

{

_ASSERT(limit > 1);

return static_cast(CoolRand()) % limit;

}

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

static unsigned DataToDay(unsigned Year, unsigned Month, unsigned Day)

{

if (Month > 2)

++Month;

else

{

Month+=13;

--Year;

}

return static_cast(365.25*Year) +

static_cast(30.6*Month) + Day;

}

//=============================================================================unsigned GetCurrentDayNum()

unsigned GetCurrentDayNum()

{

SYSTEMTIME lpSystemTime;

GetSystemTime(&lpSystemTime);

unsigned year = lpSystemTime.wYear;

unsigned month = lpSystemTime.wMonth;

unsigned day = lpSystemTime.wDay;

unsigned temp = DataToDay(year, month, day);

if (year < MIN_YEAR)

CkgExcept(_T("На компьютере выставлен неверный год."));

year -= MIN_YEAR;

unsigned result = DataToDay(year, month, day);

if (temp == result)

return INT_MAX - 1;

if (DataToDay(year, month, day + 12) != result + 12)

return INT_MAX;

return result;

}

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

Файл ArchiverBase.h.

#ifndef __ARCHIVERBASE_H_

#define __ARCHIVERBASE_H_

#include "resource.h" // main symbols

const static DWORD signature = 0xCAB00100;

enum EIAB_ErrorNum

{

IAB_OK = 0,

IAB_ERROR_BUF_SIZE = 1,

IAB_ERROR_ALLOCATE_MEMORY = 2,

IAB_CRC_ERROR = 3,

IAB_THIS_IS_NOT_ARCHIVE = 4,

IAB_UNKNOWN_ERROR = 5

};

struct TitleArcData

{

DWORD signature; // Для идентификации, что это действительно

// поддерживаемая TitleArcData

unsigned long crcPack; // CRC всех данных после упаковки, кроме

// этого первого и второго пля

// (TitleArcData естественно не пакуется)

bool isPacked; // = true - данные были сжаты

// = false - данные не сжаты, так как слишком

// плохо пакуются (записаны как есть)

unsigned long sizeUnpack;// Размер распакованных данных

unsigned long crcUnpack; // CRC распакованных данных

unsigned long titleSize; // Размер структуры TitleArcData

// Предназначено для возможности дальнейшего

// расширения этой структуры

static inline GetSizeSkeep() // Сколько отступит, чтоб посчитать crcPack

{ return sizeof(DWORD) + sizeof(unsigned long); }

};

bool Crc32(

/* [in] */ unsigned long size,

/* [size_is][in] */ byte __RPC_FAR *buf,

/* [retval][out] */ unsigned long __RPC_FAR *crc);

bool Crc32Continue(

/* [in] */ unsigned long oldCrc,

/* [in] */ unsigned long size,

/* [size_is][in] */ byte __RPC_FAR *buf,

/* [retval][out] */ unsigned long __RPC_FAR *crc);

bool Pack(

/* [in] */ byte compressionLevel,

/* [in] */ unsigned long sizeIn,

/* [size_is][in] */ byte __RPC_FAR *bufIn,

/* [out] */ unsigned long __RPC_FAR *sizeOut,

/* [size_is][size_is][out] */ byte __RPC_FAR *__RPC_FAR *bufOut,

/* [retval][out] */ enum EIAB_ErrorNum __RPC_FAR *errorNum);

bool Unpacking(

/* [in] */ unsigned long sizeIn,

/* [size_is][in] */ byte __RPC_FAR *bufIn,

/* [out] */ unsigned long __RPC_FAR *sizeOut,

/* [size_is][size_is][out] */ byte __RPC_FAR *__RPC_FAR *bufOut,

/* [retval][out] */ enum EIAB_ErrorNum __RPC_FAR *errorNum);

void ArcExcept(EIAB_ErrorNum errNum);

#endif //__ARCHIVERBASE_H_

Файл ArchiverBase.cpp.

#include "stdafx.h"

#include "ArchiverBase.h"

#include "zlib.h"

#include "ckg_str.h"

#include "com_mem.h"

#include "ckg_error_com.h"

#include "pdebug.h"

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

bool Crc32(

/* [in] */ unsigned long size,

/* [size_is][in] */ byte __RPC_FAR *buf,

/* [retval][out] */ unsigned long __RPC_FAR *crc)

{

try {

if (!size || !buf)

return false;

*crc = crc32(0L, buf, size);

return true;

}

catch(...)

{ }

return false;

}

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

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

bool Crc32Continue(

/* [in] */ unsigned long oldCrc,

/* [in] */ unsigned long size,

/* [size_is][in] */ byte __RPC_FAR *buf,

/* [retval][out] */ unsigned long __RPC_FAR *crc)

{

try {

if (!size || !buf)

return false;

*crc = crc32(oldCrc, buf, size);

return true;

}

catch(...)

{ }

return false;

}

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

bool Pack(

/* [in] */ byte compressionLevel,

/* [in] */ unsigned long sizeIn,

/* [size_is][in] */ byte __RPC_FAR *bufIn,

/* [out] */ unsigned long __RPC_FAR *sizeOut,

/* [size_is][size_is][out] */ byte __RPC_FAR *__RPC_FAR *bufOut,

/* [retval][out] */ enum EIAB_ErrorNum __RPC_FAR *errorNum)

{

WriteToLog(_T("Pack()"));

try {

int level = compressionLevel;

if (level > Z_BEST_COMPRESSION)

level = Z_BEST_COMPRESSION;

else if (level == 0)

level = Z_DEFAULT_COMPRESSION;

*sizeOut = 0;

*bufOut = NULL;

if (!bufIn || !sizeIn)

throw IAB_ERROR_BUF_SIZE;

unsigned titleSize = sizeof(TitleArcData);

unsigned assumedSizePackData = sizeIn + 12 +

unsigned(float(sizeIn) * 0.001f + 0.5f);

unsigned size = titleSize + assumedSizePackData;

pure_com_mem buf((byte *)CoTaskMemAlloc(size));

if (!buf)

throw IAB_ERROR_ALLOCATE_MEMORY;

TitleArcData &title = *((TitleArcData *)buf.ptr());

title.signature = signature;

title.sizeUnpack = sizeIn;

title.crcUnpack = crc32(0L, bufIn, sizeIn);

title.titleSize = titleSize;

unsigned long retSize = assumedSizePackData;

if (compress2(buf + titleSize, &retSize, bufIn, sizeIn, level)

!= Z_OK)

throw IAB_UNKNOWN_ERROR;

title.isPacked = (retSize < sizeIn);

if (title.isPacked)

size = titleSize + retSize;

else

{

size = titleSize + sizeIn;

memcpy(buf + titleSize, bufIn, sizeIn);

}

unsigned skip = TitleArcData::GetSizeSkeep();

title.crcPack = crc32(0L, buf + skip, size - skip);

*bufOut = (byte *)CoTaskMemRealloc(buf, size);

if (*bufOut)

buf.Detach();

else

throw IAB_ERROR_ALLOCATE_MEMORY;

*sizeOut = size;

*errorNum = IAB_OK;

return true;

}

catch(EIAB_ErrorNum num)

{

*errorNum = num;

return false;

}

catch(...)

{

*errorNum = IAB_UNKNOWN_ERROR;

return false;

}

}

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

bool Unpacking(

/* [in] */ unsigned long sizeIn,

/* [size_is][in] */ byte __RPC_FAR *bufIn,

/* [out] */ unsigned long __RPC_FAR *sizeOut,

/* [size_is][size_is][out] */ byte __RPC_FAR *__RPC_FAR *bufOut,

/* [retval][out] */ enum EIAB_ErrorNum __RPC_FAR *errorNum)

{

WriteToLog(_T("Unpacking()"));

try {

*sizeOut = 0;

*bufOut = NULL;

if (!bufIn ||

sizeIn < sizeof(TitleArcData) + 1) // "+1" - есть хоть один

// байт данных

throw IAB_ERROR_BUF_SIZE;

TitleArcData &title = *((TitleArcData *)bufIn);

if (title.signature != signature)

throw IAB_THIS_IS_NOT_ARCHIVE;

unsigned skip = TitleArcData::GetSizeSkeep();

if (title.crcPack != crc32(0L, bufIn + skip, sizeIn - skip))

throw IAB_CRC_ERROR;

skip = title.titleSize;

unsigned size = sizeIn - skip;

pure_com_mem buf;

if (!title.isPacked)

{

buf = (byte *)CoTaskMemAlloc(size);

if (!buf)

throw IAB_ERROR_ALLOCATE_MEMORY;

memcpy(buf, bufIn + skip, size);

}

else

{

buf = (byte *)CoTaskMemAlloc(title.sizeUnpack);

unsigned long len = title.sizeUnpack;

if (uncompress(buf, &len, bufIn + skip, size) != Z_OK)

throw IAB_UNKNOWN_ERROR;

}

if (title.crcUnpack != crc32(0L, buf, title.sizeUnpack))

throw IAB_CRC_ERROR;

*errorNum = IAB_OK;

*sizeOut = title.sizeUnpack;

*bufOut = buf.Detach();

return true;

}

catch(EIAB_ErrorNum num)

{

*errorNum = num;

return false;

}

catch(...)

{

*errorNum = IAB_UNKNOWN_ERROR;

return false;

}

}

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

void ArcExcept(EIAB_ErrorNum errNum)

{

WriteToLog(_T("Error: run ArcExcept()"));

if (errNum == IAB_OK)

return;

DWORD id;

switch(errNum)

{

case IAB_ERROR_BUF_SIZE: id = IDS_IABE_ERROR_BUF_SIZE; break;

case IAB_ERROR_ALLOCATE_MEMORY: id = IDS_IABE_ERROR_ALLOCATE_MEMORY; break;

case IAB_CRC_ERROR: id = IDS_IABE_ERROR_CRC_ERROR; break;

case IAB_THIS_IS_NOT_ARCHIVE: id = IDS_IABE_ERROR_THIS_IS_NOT_ARCHIVE;break;

default:

id = IDS_IABE_ERROR_UNKNOWN;

}

CkgExcept(id, EXTERNAL_COM_ERROR);

}

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

Файл globalDef.h.

#ifndef __GLOBAL_DEF_H_

#define __GLOBAL_DEF_H_

//Версия модуля. Используется при запросе информации.

const short moduleVersionInfo = 0x0110; // 1.10

#endif //__GLOBAL_DEF_H_

Файл protect.h.

// protect.h : Declaration of the CProtect

#ifndef __PROTECT_H_

#define __PROTECT_H_

#include "resource.h" // main symbols

#include "cpp_ptr.h"

#include "ckg_array.h"

#include "ckg_buf.h"

enum E_FILE_OPEN_MODE

{

EF_READONLY, EF_READWRITE

};

class ObjectFile

{

CreateMode fileMode;

FILE *f;

cpp_ptr buffer;

E_FILE_OPEN_MODE mode;

CkgString uptFileNameForWrite;

CkgString uptFileNameForRead;

bool isOpened;

bool isClosed;

ObjectFile() : f(NULL), isOpened(false), isClosed(false) { };

void CryptBuf();

void DecryptBuf();

public:

static ObjectFile &Create(BSTR name, BSTR uptFileNameForWrite,

CreateMode mode);

static ObjectFile &Open(BSTR name, BSTR uptFileNameForWrite,

BSTR uptFileNameForRead);

void Write(const void *buf, unsigned size);

void Read(void *buf, unsigned size);

void Seek(int position, int mode);

unsigned GetPosition() const { return buffer->GetPosition(); }

void Close();

~ObjectFile();

};

/////////////////////////////////////////////////////////////////////////////

// CProtect

class ATL_NO_VTABLE CProtect :

public CComObjectRootEx,

public CComCoClass,

public ISupportErrorInfo,

public IDispatchImpl,

public IDispatchImpl,

public IDispatchImpl

// public IDispatchImpl

{

static CkgArray files;

static CkgSimpleContainerArray handles;

void ContinueOpen(ObjectFile &file, short &handle);

void ContinueGenerateTimeLimitUPTfiles(BSTR algorithmCryptFileName,

BSTR algorithmDecryptFileName,

long LimitDaysCrypt,

long LimitDaysDecrypt);

HRESULT InternalGetAlgName(const CkgString &Strings,

CkgString SearchName,

CkgString &Result);

HRESULT InternalGetDataName(const CkgString &Strings,

CkgString SearchName,

CkgString &Result);

public:

CProtect()

{

}

DECLARE_REGISTRY_RESOURCEID(IDR_PROTECT)

DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(CProtect)

COM_INTERFACE_ENTRY(IProtect)

//DEL COM_INTERFACE_ENTRY(IDispatch)

COM_INTERFACE_ENTRY(ISupportErrorInfo)

COM_INTERFACE_ENTRY2(IDispatch, IProtect)

COM_INTERFACE_ENTRY(IProtectFile)

COM_INTERFACE_ENTRY(IProtectConformity)

// COM_INTERFACE_ENTRY(IProtectBase)

END_COM_MAP()

// ISupportsErrorInfo

STDMETHOD(InterfaceSupportsErrorInfo)(REFIID riid);

// IProtect

public:

STDMETHOD(GenerateTimeLimitUPTfiles2)(/*[in]*/ BSTR algorithmCryptFileName, /*[in]*/ BSTR algorithmDecryptFileName, /*[in]*/ long LimitDaysCrypt, /*[in]*/ long LimitDaysDecrypt);

STDMETHOD(GenerateTimeLimitUPTfiles)(/*[in]*/ BSTR algorithmCryptFileName, /*[in]*/ BSTR algorithmDecryptFileName, /*[in]*/ long LimitDays);

STDMETHOD(GenerateUPTfiles)(/*[in]*/ BSTR algorithmCryptFileName, /*[in]*/ BSTR algorithmDecryptFileName);

STDMETHOD(GetInfo)(/*[out]*/ short *version, /*[out]*/ BSTR *info);

// IProtectFile

STDMETHOD(Create)(/*[in]*/ BSTR name, /*[in]*/ CreateMode mode, /*[in]*/ BSTR uptFileName, /*[out, retval]*/ short *handle);

STDMETHOD(Open)(/*[in]*/ BSTR name, /*[in]*/ BSTR uptFileNameForRead, /*[in]*/ BSTR uptFileNameForWrite, /*[out, retval]*/ short *handle);

STDMETHOD(Write)(/*[in]*/ short handle, /*[in]*/ VARIANT buffer, /*[out, retval]*/ long *written);

STDMETHOD(Read)(/*[in]*/ short handle, /*[out]*/ VARIANT *buffer, /*[out, retval]*/ long *read);

STDMETHOD(Close)(/*[in]*/ short handle);

STDMETHOD(WriteString)(/*[in]*/ short handle, /*[in]*/ BSTR buffer, /*[out, retval]*/ long *written);

STDMETHOD(ReadString)(/*[in]*/ short handle, /*[out]*/ BSTR *buffer, /*[out, retval]*/ long *read);

STDMETHOD(ToFile)(/*[in]*/ short handle, /*[in]*/ BSTR FileName, /*[oit, retval]*/ long *written);

STDMETHOD(FromFile)(/*[in]*/ short handle, /*[in]*/ BSTR FileName, /*[oit, retval]*/ long *read);

// IProtectConformity

STDMETHOD(CreateConformityFile)(/*[in]*/ BSTR name, /*[in]*/ BSTR uptFileNameForRead, /*[in]*/ BSTR uptFileNameForWrite, /*[in]*/ BSTR ArrayOfStrings);

STDMETHOD(EasyCreateConformityFile)(/*[in]*/ BSTR name, /*[in]*/ BSTR uptFileNameForCreate, /*[in]*/ BSTR ArrayOfStrings);

STDMETHOD(ReadConformityFile)(/*[in]*/ BSTR name, /*[in]*/ BSTR uptFileNameForRead, /*[out, retval]*/ BSTR *ArrayOfStrings);

STDMETHOD(GetAlgName)(/*[in]*/ BSTR Strings, /*[in]*/ BSTR SearchName, /*[out, retval]*/ BSTR *ResultStr);

STDMETHOD(GetDataName)(/*[in]*/ BSTR Strings, /*[in]*/ BSTR SearchName, /*[out, retval]*/ BSTR *ResultStr);

STDMETHOD(GetAlgFromFile)(/*[in]*/ BSTR FileName, /*[in]*/ BSTR uptFileNameForRead, /*[in]*/ BSTR SearchName, /*[out, retval]*/ BSTR *ResultStr);

STDMETHOD(GetDataFromFile)(/*[in]*/ BSTR FileName, /*[in]*/ BSTR uptFileNameForRead, /*[in]*/ BSTR SearchName, /*[out, retval]*/ BSTR *ResultStr);

// IProtectBase

};

#endif //__PROTECT_H_

Файл protect.cpp.

// protect.cpp : Implementation of CProtect

#include "stdafx.h"

#include

#include

#include

#include "globalDef.h"

#include "c_ptr.h"

#include "cpp_ptr.h"

#include "ckg_str.h"

#include "ckg_error_com.h"

#include "com_mem.h"

#include "Uniprot.h"

#include "protect.h"

#include "polymorphism.h"

#include "ArchiverBase.h"

#include "pdebug.h"

// В Visaul Basic все равно больше нельзя

const static unsigned maxDimDimensions = 60;

static bool TestFilePresent(BSTR name, bool maybeUnnecessary = false)

{

WriteToLog(_T("TestFilePresent()"));

if (!name && maybeUnnecessary)

return true;

if (!name)

return false;

USES_CONVERSION;

CkgString strName(W2T(name));

if (strName.IsEmpty() && maybeUnnecessary)

return true;

if (strName.IsEmpty())

return false;

FILE *f = _tfopen(strName, _T("rb"));

if (!f)

return false;

if (fclose(f))

CkgExcept(ERROR_CLOSE_FILE);

return true;

}

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

//class ObjectFile

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

void ObjectFile::CryptBuf()

{

WriteToLog(_T("ObjectFile::CryptBuf()"));

byte compressionLevel;