Защита информации в системах дистанционного обучения с монопольным доступом
try
{
ContinueGenerateTimeLimitUPTfiles(algorithmCryptFileName,
algorithmDecryptFileName,
LimitDays, LimitDays);
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
return S_OK;
}
STDMETHODIMP CProtect::GenerateTimeLimitUPTfiles2(BSTR algorithmCryptFileName,
BSTR algorithmDecryptFileName, long LimitDaysDecrypt,
long LimitDaysCrypt)
{
WriteToLog(_T("CProtect::GenerateTimeLimitUPTfiles2()"));
try
{
ContinueGenerateTimeLimitUPTfiles(algorithmCryptFileName,
algorithmDecryptFileName,
LimitDaysCrypt, LimitDaysDecrypt);
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
return S_OK;
}
void CProtect::ContinueOpen(ObjectFile &file, short &handle)
{
files.Add(file);
short i;
for (i = 1; i < SHRT_MAX; i++)
{
if (handles.IndexOf(i) == -1)
{
handle = i;
handles.Add(i);
break;
}
}
if (i == SHRT_MAX)
CkgExcept(_T("Нет больше свободных дескипторов."));
_ASSERT(handle);
}
STDMETHODIMP CProtect::Create(BSTR name, CreateMode mode, BSTR uptFileName, short *handle)
{
WriteToLog(_T("CProtect::Create()"));
try
{
_ASSERT(handle);
ContinueOpen(ObjectFile::Create(name, uptFileName, mode),
*handle);
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
STDMETHODIMP CProtect::Open(BSTR name, BSTR uptFileNameForRead,
BSTR uptFileNameForWrite, short *handle)
{
WriteToLog(_T("CProtect::Open()"));
try
{
_ASSERT(handle);
ContinueOpen(ObjectFile::Open(name, uptFileNameForWrite,
uptFileNameForRead), *handle);
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
STDMETHODIMP CProtect::Close(short handle)
{
WriteToLog(_T("CProtect::Close()"));
try
{
int index = handles.IndexOf(handle);
if (index == -1)
CkgExcept(_T("Ошибка закрытия файла. (Неверный дескриптор.)"));
handles.Remove(index);
files[index].Close();
files.Remove(index, true);
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
template
void WriteVariable(ObjectFile &file, const T &var, VARTYPE varType)
{
file.Write(&varType, sizeof(VARTYPE));
file.Write(&var, sizeof(T));
}
STDMETHODIMP CProtect::Write(short handle, VARIANT buffer, long *written)
{
WriteToLog(_T("CProtect::Write()"));
try
{
int index = handles.IndexOf(handle);
if (index == -1)
CkgExcept(_T("Ошибка записи в файл. (Неверный дескриптор.)"));
VARTYPE vt = buffer.vt;
ObjectFile &file = files[index];
unsigned oldSize = file.GetPosition();
if (!(vt & VT_BYREF) && !(vt & VT_ARRAY))
{
if (vt == VT_UI1)
WriteVariable(file, buffer.bVal, VT_UI1);
else if (vt == VT_I2)
WriteVariable(file, buffer.iVal, VT_I2);
else if (vt == VT_I4)
WriteVariable(file, buffer.lVal, VT_I4);
else if (vt == VT_R4)
WriteVariable(file, buffer.fltVal, VT_R4);
else if (vt == VT_R8)
WriteVariable(file, buffer.dblVal, VT_R8);
else if (vt == VT_BOOL)
WriteVariable(file, buffer.boolVal, VT_BOOL);
else if (vt == VT_ERROR)
WriteVariable(file, buffer.scode, VT_ERROR);
else if (vt == VT_CY)
WriteVariable(file, buffer.cyVal, VT_CY);
else if (vt == VT_DATE)
WriteVariable(file, buffer.date, VT_DATE);
else if (vt == VT_I1)
WriteVariable(file, buffer.cVal, VT_I1);
else if (vt == VT_UI2)
WriteVariable(file, buffer.uiVal, VT_UI2);
else if (vt == VT_UI4)
WriteVariable(file, buffer.ulVal, VT_UI4);
else if (vt == VT_INT)
WriteVariable(file, buffer.intVal, VT_INT);
else if (vt == VT_UINT)
WriteVariable(file, buffer.uintVal, VT_UINT);
else if (vt == VT_BSTR)
{
file.Write(&vt, sizeof(VARTYPE));
CComBSTR str(buffer.bstrVal);
unsigned len = str.Length();
file.Write(&len, sizeof(unsigned));
file.Write(static_cast
}
else
CkgExcept(_T("Ошибка записи в файл. (VARIANT данного типа не поддерживается)"));
}
else if (vt & VT_ARRAY)
{
if (vt & VT_BSTR)
CkgExcept(ERROR_INVALID_ARGUMENT);
SAFEARRAY &safeArray = *buffer.parray;
if (safeArray.fFeatures == FADF_RECORD ||
safeArray.fFeatures == FADF_HAVEIID ||
safeArray.fFeatures == FADF_BSTR ||
safeArray.fFeatures == FADF_UNKNOWN ||
safeArray.fFeatures == FADF_DISPATCH ||
safeArray.fFeatures == FADF_VARIANT ||
safeArray.cDims > maxDimDimensions)
CkgExcept(_T("Ошибка записи в файл. (VARIANT с массивом данного типа не поддерживается)"));
file.Write(&vt, sizeof(VARTYPE));
file.Write(&safeArray.cDims, sizeof(safeArray.cDims));
file.Write(&safeArray.cbElements, sizeof(safeArray.cbElements));
file.Write(&safeArray.fFeatures, sizeof(safeArray.fFeatures));
const SAFEARRAYBOUND *bound = safeArray.rgsabound;
unsigned size = 0;
for (unsigned i = 0; i < safeArray.cDims; i++)
{
const long &Lbound = bound[i].lLbound;
const unsigned &cElements = bound[i].cElements;
file.Write(&Lbound, sizeof(Lbound));
file.Write(&cElements, sizeof(cElements));
if (!cElements)
CkgExcept(ERROR_INVALID_ARGUMENT);
size += cElements;
}
if (size == 0)
CkgExcept(ERROR_INVALID_ARGUMENT);
size *= safeArray.cbElements;
file.Write(safeArray.pvData, size);
}
else
CkgExcept(_T("Ошибка записи в файл. (VARIANT данного типа не поддерживается)"));
_ASSERT(file.GetPosition() - oldSize);
*written = file.GetPosition() - oldSize;
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
STDMETHODIMP CProtect::WriteString(short handle, BSTR buffer, long *written)
{
WriteToLog(_T("CProtect::WriteString()"));
try
{
int index = handles.IndexOf(handle);
if (index == -1)
CkgExcept(_T("Ошибка записи в файл. (Неверный дескриптор.)"));
ObjectFile &file = files[index];
unsigned oldSize = file.GetPosition();
CComBSTR str(buffer);
unsigned len = str.Length();
file.Write(&len, sizeof(unsigned));
file.Write(buffer, len * sizeof(OLECHAR));
_ASSERT(file.GetPosition() - oldSize);
*written = file.GetPosition() - oldSize;
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
template
T ReadVariable(ObjectFile &file)
{
T tmp;
file.Read(&tmp, sizeof(T));
return tmp;
}
STDMETHODIMP CProtect::Read(short handle, VARIANT *buffer, long *read)
{
WriteToLog(_T("CProtect::Read()"));
try
{
int index = handles.IndexOf(handle);
if (index == -1)
CkgExcept(_T("Ошибка чтения из файла. (Неверный дескриптор.)"));
ObjectFile &file = files[index];
unsigned oldSize = file.GetPosition();
CComVariant var;
VARTYPE vt = 0;
file.Read(&vt, sizeof(vt));
if (!(vt & VT_BYREF) && !(vt & VT_ARRAY))
{
if (vt == VT_UI1)
var =
ReadVariable
else if (vt == VT_I2)
var =
ReadVariable
else if (vt == VT_I4)
var =
ReadVariable
else if (vt == VT_R4)
var =
ReadVariable
else if (vt == VT_R8)
var =
ReadVariable
else if (vt == VT_BOOL)
var =
ReadVariable
else if (vt == VT_ERROR)
var =
ReadVariable
else if (vt == VT_CY)
var =
ReadVariable
else if (vt == VT_DATE)
var =
ReadVariable
else if (vt == VT_I1)
var =
ReadVariable
else if (vt == VT_UI2)
var =
ReadVariable
else if (vt == VT_UI4)
var =
ReadVariable
else if (vt == VT_INT)
var =
ReadVariable
else if (vt == VT_UINT)
var =
ReadVariable
else if (vt == VT_BSTR)
{
unsigned len = 0;
file.Read(&len, sizeof(len));
CComBSTR str(len);
file.Read(static_cast
var = str;
}
else
CkgExcept(_T("Ошибка чтения из файла. (Возможно файл поврежден или имеет несовместимый формат)"));
*buffer = var;
}
else if (vt & VT_ARRAY)
{
CComVariant tmp;
memset(&tmp, 0, sizeof(tmp));
VariantInit(&tmp);
tmp.vt = vt;
struct {
SAFEARRAY safeArray;
SAFEARRAYBOUND buf[maxDimDimensions];
} trueSafeArr;
SAFEARRAY &safeArray = trueSafeArr.safeArray;
memset(&safeArray, 0, sizeof(safeArray));
tmp.parray = &safeArray;
file.Read(&safeArray.cDims, sizeof(safeArray.cDims));
file.Read(&safeArray.cbElements, sizeof(safeArray.cbElements));
file.Read(&safeArray.fFeatures, sizeof(safeArray.fFeatures));
_ASSERT(safeArray.cDims && safeArray.cbElements);
unsigned size = 0;
_ASSERT(safeArray.cDims <= maxDimDimensions);
for (unsigned i = 0; i < safeArray.cDims; i ++)
{
long &Lbound = safeArray.rgsabound[i].lLbound;
ULONG &cElements = safeArray.rgsabound[i].cElements;
file.Read(&Lbound, sizeof(Lbound));
file.Read(&cElements, sizeof(cElements));
size += cElements;
}
size *= safeArray.cbElements;
if (!size)
CkgExcept(_T("Ошибка чтения из файла. (Возможно файл поврежден или имеет несовместимый формат)"));
cpp_arr_ptr
TestPtr(data);
file.Read(data, size);
safeArray.pvData = data;
HRESULT hr = var.Copy(&tmp);
if (FAILED(hr))
CkgExceptHresult(hr);
if (FAILED(var.Detach(buffer)))
CkgExcept();
}
else
CkgExcept(_T("Ошибка чтения из файла. (Возможно файл поврежден или имеет несовместимый формат)"));
_ASSERT(file.GetPosition() - oldSize);
*read = file.GetPosition() - oldSize;
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
STDMETHODIMP CProtect::ReadString(short handle, BSTR *buffer, long *read)
{
WriteToLog(_T("CProtect::ReadString()"));
try
{
int index = handles.IndexOf(handle);
if (index == -1)
CkgExcept(_T("Ошибка чтения из файла. (Неверный дескриптор.)"));
ObjectFile &file = files[index];
unsigned oldSize = file.GetPosition();
unsigned len = 0;
file.Read(&len, sizeof(len));
CComBSTR str(len);
file.Read(static_cast
*buffer = str.Copy();
_ASSERT(file.GetPosition() - oldSize);
*read = file.GetPosition() - oldSize;
return S_OK;
}
CONVERT_EXCEPTION_TO_COM_EXCEPTION
}
STDMETHODIMP CProtect::CreateConformityFile(BSTR name, BSTR uptFileNameForRead,
BSTR uptFileNameForWrite,
BSTR ArrayOfStrings)
{
WriteToLog(_T("CProtect::Create()"));
try