Защита информации в системах дистанционного обучения с монопольным доступом
case ES_VARIABLE_0: _ASSERT(!parameters.counterIsReg);
newValue = parameters.counterNumber;
break;
case ES_VARIABLE_1: newValue =
parameters.initCounterNumber;
break;
default: CkgExcept();
}
block.GetRef(position) = newValue;
}
DEBUG_TEST_BLOCK(block.Get(position));
position++;
}
}
//-----------------------------------------------------------------------------
void CreateBlock1(Block block[], AlgorithmParameters parameters[],
cpp_arr_ptr
{
CreateBlock1_(block[0], parameters[0], vars[0]);
CreateBlock1_(block[1], parameters[1], vars[1]);
}
//-----------------------------------------------------------------------------
void CreateBlock2_(Block &block, AlgorithmParameters ¶meters,
cpp_arr_ptr
{
_ASSERT(n < maxNumTransformation);
SAppropriate appropriate;
appropriate.testContain = true;
appropriate.numShouldContain = 1;
int whatSearch = parameters.modificatoryIsReg[n] ? ES_REG_0 : ES_VARIABLE_0;
appropriate.shouldContain = &whatSearch;
unsigned index;
if (!SearchRandomAppropriateBlock(sizeBlocksArray_02, *sizeBlocks_02,
*blocks_02, appropriate, index))
CkgExcept();
for (unsigned i = 0; i < sizeBlocks_02[index]; i++)
block.Add(blocks_02[index][i]);
unsigned position = 0;
while (SearchSubstitution(block, position))
{
if (!ReplacemenRandomEntity(block.GetRef(position), parameters))
{
int newValue = EO_ERROR;
int b = block[position];
switch (b)
{
case ES_REG_0: _ASSERT(parameters.modificatoryIsReg[n]);
newValue = parameters.modificatorsNumbers[n];
break;
case ES_VARIABLE_0: _ASSERT(!parameters.modificatoryIsReg[n]);
newValue = parameters.modificatorsNumbers[n];
break;
case ES_VARIABLE_1: {
unsigned varNum =
ReserveRandomNonUsedVariables(parameters);
vars[varNum] = randValue;
newValue
= static_cast
break;
}
case ES_CONST_0: newValue = randValue;
break;
default: CkgExcept();
}
block.GetRef(position) = newValue;
}
DEBUG_TEST_BLOCK(block.Get(position));
position++;
}
}
//-----------------------------------------------------------------------------
void CreateBlock2(Block block[], AlgorithmParameters parameters[],
cpp_arr_ptr
{
int randValue = CoolRand();
CreateBlock2_(block[0], parameters[0], vars[0], n, randValue);
CreateBlock2_(block[1], parameters[1], vars[1], n, randValue);
}
//-----------------------------------------------------------------------------
void CalcBlocksSize(Block (*blocks)[2], unsigned num, unsigned &size1, unsigned &size2)
{
_ASSERT(num);
unsigned i;
size1 = 0;
for (i = 0; i < num; i++)
size1 += blocks[i][0].GetSize();
size2 = 0;
for (i = 0; i < num; i++)
size2 += blocks[i][1].GetSize();
}
//-----------------------------------------------------------------------------
void CreateLoopAddres_(unsigned num, const AlgorithmParameters ¶meters,
unsigned sizeBeforeLoop,
unsigned &addr)
{
const double dispersion = 0.1;
const double k =
(static_cast
_ASSERT(fabs(k) <= dispersion);
const double allSize = parameters.sizeAlgorithm;
const double sizeInBlocks = num;
const double allSizeInBlocks = parameters.totalNumTrueBlocks;
double randAddr = sizeInBlocks * allSize / allSizeInBlocks;
_ASSERT(static_cast
randAddr += randAddr * k;
addr =
static_cast
_ASSERT(addr >= sizeBeforeLoop);
if (addr < sizeBeforeLoop)
CkgExcept();
}
//-----------------------------------------------------------------------------
void CreateLoopAddres(unsigned num, const AlgorithmParameters parameters[],
unsigned sizeBeforeLoop1,
unsigned sizeBeforeLoop2,
unsigned &addr1, unsigned &addr2)
{
_ASSERT(sizeBeforeLoop1 && sizeBeforeLoop2);
CreateLoopAddres_(num, parameters[0], sizeBeforeLoop1, addr1);
CreateLoopAddres_(num, parameters[1], sizeBeforeLoop2, addr2);
}
//-----------------------------------------------------------------------------
void CreateBlock3_(Block &block, AlgorithmParameters ¶meters,
cpp_arr_ptr
bool useCounterForModify)
{
_ASSERT(CALC_ARRAY_SIZE(block_03_operation_AB) ==
CALC_ARRAY_SIZE(block_03_operation_BA));
bool isBA = numSelectedBlock != -1;
if (!isBA)
{
numSelectedBlock = CALC_ARRAY_SIZE(block_03_operation_AB) > 1 ?
CoolRand(CALC_ARRAY_SIZE(block_03_operation_AB)) : 0;
}
SAppropriate appropriate;
appropriate.testContain = true;
appropriate.numShouldContain = 1 + useCounterForModify;
unsigned index;
int whatSearch[2];
whatSearch[0] = parameters.addressIsReg ? ES_REG_0 : ES_VARIABLE_0;
whatSearch[1] = parameters.counterIsReg ? ES_REG_2 : ES_VARIABLE_2;
appropriate.shouldContain = whatSearch;
appropriate.testNotContain = true;
appropriate.numNotShouldContain = 2 + (!useCounterForModify) * 2;
int whatNotContain[4];
appropriate.notShouldContain = whatNotContain;
whatNotContain[0] = !parameters.modificatoryIsReg[n] ?
ES_REG_1 : ES_VARIABLE_1;
whatNotContain[1] = !parameters.counterIsReg ?
ES_REG_2 : ES_VARIABLE_2;
whatNotContain[2] = ES_VARIABLE_2;
whatNotContain[3] = ES_REG_2;
if (!SearchRandomAppropriateBlock(sizeBlocksArray_03, *sizeBlocks_03,
*blocks_03, appropriate, index))
CkgExcept();
index;
for (unsigned i = 0; i < sizeBlocks_03[index]; i++)
block.Add(blocks_03[index][i]);
unsigned position = 0;
int checkCountUse = useCounterForModify;
while (SearchSubstitution(block, position))
{
if (!ReplacemenRandomEntity(block.GetRef(position), parameters))
{
int newValue = EO_ERROR;
int b = block[position];
switch (b)
{
case ES_REG_0: _ASSERT(parameters.addressIsReg);
newValue = parameters.addressNumber;
break;
case ES_REG_1: _ASSERT(parameters.modificatoryIsReg[n]);
newValue = parameters.modificatorsNumbers[n];
break;
case ES_REG_2: _ASSERT(parameters.counterIsReg);
newValue = parameters.counterNumber;
checkCountUse--;
_ASSERT(checkCountUse == 0);
break;
case ES_VARIABLE_0: _ASSERT(!parameters.addressIsReg);
newValue = parameters.addressNumber;
break;
case ES_VARIABLE_1: _ASSERT(!parameters.modificatoryIsReg[n]);
newValue = parameters.modificatorsNumbers[n];
break;
case ES_VARIABLE_2: _ASSERT(!parameters.counterIsReg);
newValue = parameters.counterNumber;
checkCountUse--;
_ASSERT(checkCountUse == 0);
break;
case ES_SPECIFIC_0: if (isBA)
newValue = block_03_operation_BA[numSelectedBlock];
else
newValue = block_03_operation_AB[numSelectedBlock];
break;
default: CkgExcept();
}
block.GetRef(position) = newValue;
}
DEBUG_TEST_BLOCK(block.Get(position));
position++;
}
if (checkCountUse != 0)
CkgExcept(_T("Ошибка в алгоритме генерации UPT-файлов (function CreateBlock3_). Обратитесь к разработчику."));
}
//-----------------------------------------------------------------------------
void CreateBlock3AB(Block block[], AlgorithmParameters parameters[],
cpp_arr_ptr
int &numSelectedBlock, bool useCounterForModify)
{
_ASSERT(vars && n < maxNumTransformation);
numSelectedBlock = -1;
CreateBlock3_(block[0], parameters[0], vars[0], n, numSelectedBlock,
useCounterForModify);
_ASSERT(numSelectedBlock >= 0);
}
//-----------------------------------------------------------------------------
void CreateBlock3BA(Block block[], AlgorithmParameters parameters[],
cpp_arr_ptr
int numSelectedBlock, bool useCounterForModify)
{
_ASSERT(vars && n < maxNumTransformation);
_ASSERT(numSelectedBlock >= 0);
CreateBlock3_(block[1], parameters[1], vars[1], n, numSelectedBlock,
useCounterForModify);
}
//-----------------------------------------------------------------------------
void
CreateBlock4_(Block &block, AlgorithmParameters ¶meters,
cpp_arr_ptr
{
_ASSERT(block.IsEmpty());
SAppropriate appropriate;
appropriate.testContain = true;
appropriate.numShouldContain = 1;
int whatSearch = parameters.addressIsReg ? ES_REG_0 : ES_VARIABLE_0;
appropriate.shouldContain = &whatSearch;
unsigned index;
if (!SearchRandomAppropriateBlock(sizeBlocksArray_04, *sizeBlocks_04,
*blocks_04, appropriate, index))
CkgExcept();
for (unsigned i = 0; i < sizeBlocks_04[index]; i++)
block.Add(blocks_04[index][i]);
unsigned position = 0;
while (SearchSubstitution(block, position))
{
if (!ReplacemenRandomEntity(block.GetRef(position), parameters))
{
int newValue = EO_ERROR;
int b = block[position];
switch (b)
{
case ES_REG_0: _ASSERT(parameters.addressIsReg);
newValue = parameters.addressNumber;
break;