static size_t _dstuRecoverPoint_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(2 * n) +
utilMax(2,
gf2QSolve_deep(n, f_deep),
gf2Tr_deep(n, f_deep));
}
static size_t _dstuSign_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(6 * n) +
utilMax(2,
ecMulA_deep(n, ec_d, ec_deep, n),
zzMulMod_deep(n));
}
static size_t _dstuValPoint_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(2 * n) +
utilMax(2,
ec2IsOnA_deep(n, f_deep),
ecHasOrderA_deep(n, ec_d, ec_deep, n));
}
static size_t _dstuGenPoint_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return O_OF_W(3 * n) +
utilMax(2,
gf2QSolve_deep(n, f_deep),
ecHasOrderA_deep(n, ec_d, ec_deep, n));
}
static size_t g12sValParams_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
return utilMax(4,
ecpIsValid_deep(n, f_deep),
ecpSeemsValidGroup_deep(n, f_deep),
ecpIsSafeGroup_deep(n),
ecHasOrderA_deep(n, ec_d, ec_deep, n));
}
static size_t g12sSign_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
const size_t m = n;
return O_OF_W(3 * m + 2 * n) +
utilMax(3,
zzMod_deep(m, m),
ecMulA_deep(n, ec_d, ec_deep, n),
zzMulMod_deep(m));
}
static size_t g12sVerify_deep(size_t n, size_t f_deep, size_t ec_d,
size_t ec_deep)
{
const size_t m = n;
return O_OF_W(5 * m + 2 * n) +
utilMax(4,
zzMod_deep(m, m),
zzMulMod_deep(m),
zzInvMod_deep(m),
ecAddMulA_deep(n, ec_d, ec_deep, 2, m, m));
}
bool_t utilTest()
{
printf("utilVersion: %s\n", utilVersion());
if (utilMin(5, SIZE_1, (size_t)2, (size_t)3, SIZE_1, SIZE_0) != 0 ||
utilMax(5, SIZE_1, (size_t)2, (size_t)3, SIZE_1, SIZE_0) != 3)
return FALSE;
if (utilCRC32("123456789", 9, 0) != 0xCBF43926)
return FALSE;
if (utilFNV32("3pjNqM", 6, 0x811C9DC5) != 0)
return FALSE;
// все нормально
return TRUE;
}
bool posIsDraw(const Pos *pos, unsigned int ply) {
// False positives are bad, false negatives are OK.
// Repetition (2-fold).
PosData *ptr, *endPtr=utilMax(pos->dataStart, pos->data-posGetHalfMoveNumber(pos));
for(ptr=pos->data-2;ptr>=endPtr;ptr-=2)
if (ptr->key==pos->data->key)
return true;
// 50-move rule.
if (posGetHalfMoveNumber(pos)>=100)
return true;
// Insufficient material.
if (evalGetMatType(pos)==EvalMatTypeDraw)
return true;
return false;
}
static err_t g12sCreateEc(
ec_o** pec, /* [out] описание эллиптической кривой */
const g12s_params* params, /* [in] долговременные параметры */
g12s_deep_i deep /* [in] потребности в стековой памяти */
)
{
// размерности
size_t n, no, nb;
size_t f_keep;
size_t f_deep;
size_t ec_d;
size_t ec_keep;
size_t ec_deep;
// состояние
void* state;
qr_o* f; /* базовое поле */
ec_o* ec; /* кривая */
void* stack;
// pre
ASSERT(memIsValid(pec, sizeof(*pec)));
// минимальная проверка входных данных
if (!memIsValid(params, sizeof(g12s_params)) ||
params->l != 256 && params->l != 512)
return ERR_BAD_PARAMS;
// определить размерности
no = memNonZeroSize(params->p, sizeof(params->p) * params->l / 512);
n = W_OF_O(no);
f_keep = gfpCreate_keep(no);
f_deep = gfpCreate_deep(no);
ec_d = 3;
ec_keep = ecpCreateJ_keep(no);
ec_deep = ecpCreateJ_deep(no, f_deep);
// создать состояние
state = blobCreate(
f_keep + ec_keep +
utilMax(3,
ec_deep,
ecCreateGroup_deep(f_deep),
deep(n, f_deep, ec_d, ec_deep)));
if (state == 0)
return ERR_NOT_ENOUGH_MEMORY;
// создать поле
f = (qr_o*)((octet*)state + ec_keep);
stack = (octet*)f + f_keep;
if (!gfpCreate(f, params->p, no, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// проверить длину p
nb = wwBitSize(f->mod, n);
if (params->l == 256 && nb <= 253 ||
params->l == 512 && nb <= 507)
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// создать кривую и группу
ec = (ec_o*)state;
if (!ecpCreateJ(ec, f, params->a, params->b, stack) ||
!ecCreateGroup(ec, params->xP, params->yP, params->q,
params->l / 8, params->n, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// проверить q
n = W_OF_B(params->l);
nb = wwBitSize(ec->order, n);
if (params->l == 256 && nb <= 254 ||
params->l == 512 && nb <= 508 ||
zzIsEven(ec->order, n))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// присоединить f к ec
objAppend(ec, f, 0);
// все нормально
*pec = ec;
return ERR_OK;
}
static err_t _dstuCreateEc(
ec_o** pec, /* [out] описание эллиптической кривой */
const dstu_params* params, /* [in] долговременные параметры */
_dstu_deep_i deep /* [in] потребности в стековой памяти */
)
{
// размерности
size_t m;
size_t n;
size_t f_keep;
size_t f_deep;
size_t ec_d;
size_t ec_keep;
size_t ec_deep;
// состояние
void* state;
size_t* p; /* описание многочлена */
qr_o* f; /* поле */
octet* A; /* коэффициент A */
ec_o* ec; /* кривая */
void* stack;
// pre
ASSERT(memIsValid(pec, sizeof(*pec)));
// минимальная проверка входных данных
if (!memIsValid(params, sizeof(dstu_params)) ||
(m = params->p[0]) < 160 || m > 509 ||
params->A > 1)
return ERR_BAD_PARAMS;
// определить размерности
n = W_OF_B(m);
f_keep = gf2Create_keep(m);
f_deep = gf2Create_deep(m);
ec_d = 3;
ec_keep = ec2CreateLD_keep(n);
ec_deep = ec2CreateLD_deep(n, f_deep);
// создать состояние
state = blobCreate(
f_keep + ec_keep +
utilMax(4,
4 * sizeof(size_t) + f_deep,
O_OF_B(m) + ec_deep,
ecCreateGroup_deep(f_deep),
deep(n, f_deep, ec_d, ec_deep)));
if (state == 0)
return ERR_NOT_ENOUGH_MEMORY;
// создать поле
f = (qr_o*)((octet*)state + ec_keep);
p = (size_t*)((octet*)f + f_keep);
p[0] = params->p[0];
p[1] = params->p[1];
p[2] = params->p[2];
p[3] = params->p[3];
stack = p + 4;
if (!gf2Create(f, p, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// создать кривую и группу
ec = (ec_o*)state;
A = (octet*)p;
A[0] = params->A;
memSetZero(A + 1, f->no - 1);
stack = A + f->no;
if (!ec2CreateLD(ec, f, A, params->B, stack) ||
!ecCreateGroup(ec, params->P, params->P + ec->f->no, params->n,
ec->f->no, params->c, stack))
{
blobClose(state);
return ERR_BAD_PARAMS;
}
// присоединить f к ec
objAppend(ec, f, 0);
// все нормально
*pec = ec;
return ERR_OK;
}
