/* --------------------------------------------------------------------------
* EcdsaSignerClose
* -------------------------------------------------------------------------- */
VLT_STS EcdsaSignerClose( void )
{
VLT_STS status = VLT_OK;
/* zeroise key storage */
mpSetZero(sPublicKeyQx, sizeof(sPublicKeyQx) / sizeof(DIGIT_T));
mpSetZero(sPublicKeyQy, sizeof(sPublicKeyQx) / sizeof(DIGIT_T));
mpSetZero(sPrivateKey, sizeof(sPublicKeyQx) / sizeof(DIGIT_T));
/* clear curve definition */
host_memset((VLT_PU8)&E, 0, sizeof(E));
signerState = ST_UNKNOWN;
return status;
}
int bdSetZero(T a)
/* Sets a = 0 */
{
assert(a);
mpSetZero(a->digits, a->ndigits);
a->ndigits = 0;
return 0;
}
void bdFree(T *p)
/* Zeroise and free memory. Set ptr to NULL. */
{
T bd = *p;
if (*p)
{
/* Zeroise them all, just in case */
if (bd->digits)
{
mpSetZero(bd->digits, bd->maxdigits);
free(bd->digits);
}
bd->maxdigits = 0;
bd->ndigits = 0;
free(*p);
}
*p = NULL;
}
static int bd_resize(T b, size_t newsize)
{
/*
Internal fn to re-size a BIGD structure before a calc.
Use carefully!
1. If growing, it allocs more digits and increases maxdigits
2. If shrinking, it decreases ndigits and zeroises the excess.
3. It does not increase b->ndigits; that's up to you later.
4. It does not release excess digits; use bdFree.
In other words, it's like middle-aged spread:
you go from a 32" waist to a 38 but can never go backwards.
Be careful doing the following:-
n = new_size_we_expect;
bd_resize(b, n);
mpFunctionOfSorts(b->digits, n);
b->ndigits = mpSizeof(b->digits, b->ndigits); // NO!
b->ndigits may be set too short
Better:
n = new_size_we_expect;
bd_resize(b, n);
mpFunctionOfSorts(b->digits, n);
b->ndigits = mpSizeof(b->digits, n); // Yes.
*/
size_t i;
/* Check just in case NULL */
assert(b);
assert(b->digits);
/* If we are shrinking, clear high digits */
if (newsize < b->ndigits)
{
for (i = newsize; i < b->ndigits; i++)
b->digits[i] = 0;
b->ndigits = newsize;
return 0;
}
/* We need more room */
if (b->maxdigits < newsize)
{
DIGIT_T *newp, *oldp;
size_t oldsize = b->maxdigits;
/* Increase size of digit array */
//b->digits = (DIGIT_T *)realloc(b->digits, newsize * sizeof(DIGIT_T));
/* -- [v2.2] changed [2008-03-30] to avoid realloc */
newp = (DIGIT_T *)malloc(newsize * sizeof(DIGIT_T));
oldp = b->digits;
/* Check for failure */
if (!newp)
{
mpSetZero(oldp, oldsize);
free(oldp);
mpFail("bd_resize: Failed to realloc memory.");
}
memcpy(newp, oldp, oldsize * sizeof(DIGIT_T));
mpSetZero(oldp, oldsize);
free(oldp);
b->digits = newp;
b->maxdigits = newsize; /* Remember new allocated size */
}
/* Make sure new digits are zero */
for (i = b->ndigits; i < newsize; i++)
b->digits[i] = 0;
return 0;
}