uint32_t
ntru_mgf1(
uint8_t *state, /* in/out - pointer to the state */
NTRU_CRYPTO_HASH_ALGID algid, /* in - hash algorithm ID */
uint8_t md_len, /* in - no. of octets in digest */
uint8_t num_calls, /* in - no. of hash calls */
uint16_t seed_len, /* in - no. of octets in seed */
uint8_t const *seed, /* in - pointer to seed */
uint8_t *out) /* out - address for output */
{
uint8_t *ctr = state + md_len;
uint32_t retcode;
ASSERT(state);
ASSERT(out);
/* if seed present, init state */
if (seed)
{
if ((retcode = ntru_crypto_hash_digest(algid, seed, seed_len, state)) !=
NTRU_CRYPTO_HASH_OK)
{
return retcode;
}
memset(ctr, 0, 4);
}
/* generate output */
while (num_calls-- > 0)
{
if ((retcode = ntru_crypto_hash_digest(algid, state, md_len + 4,
out)) != NTRU_CRYPTO_HASH_OK)
{
return retcode;
}
out += md_len;
/* increment counter */
if (++ctr[3] == 0)
{
if (++ctr[2] == 0)
{
if (++ctr[1] == 0)
{
++ctr[0];
}
}
}
}
NTRU_RET(NTRU_OK);
}
uint32_t
ntru_crypto_hmac_create_ctx(
NTRU_CRYPTO_HASH_ALGID algid, /* in - the hash algorithm to be used */
uint8_t const *key, /* in - pointer to the HMAC key */
uint32_t key_len, /* in - number of bytes in HMAC key */
NTRU_CRYPTO_HMAC_CTX **c) /* out - address for pointer to HMAC
context */
{
NTRU_CRYPTO_HMAC_CTX *ctx = NULL;
uint32_t result;
/* check parameters */
if (!c || !key) {
HMAC_RET(NTRU_CRYPTO_HMAC_BAD_PARAMETER);
}
*c = NULL;
/* allocate memory for an HMAC context */
if (NULL == (ctx = (NTRU_CRYPTO_HMAC_CTX *) MALLOC(sizeof(NTRU_CRYPTO_HMAC_CTX)))) {
HMAC_RET(NTRU_CRYPTO_HMAC_OUT_OF_MEMORY);
}
/* set the algorithm */
if ((result = ntru_crypto_hash_set_alg(algid, &ctx->hash_ctx))) {
FREE(ctx);
HMAC_RET(NTRU_CRYPTO_HMAC_BAD_ALG);
}
/* set block length and digest length */
if ((result = ntru_crypto_hash_block_length(&ctx->hash_ctx,
&ctx->blk_len)) ||
(result = ntru_crypto_hash_digest_length(&ctx->hash_ctx,
&ctx->md_len))) {
FREE(ctx);
return result;
}
/* allocate memory for K0 */
if ((ctx->k0 = (uint8_t *) MALLOC(ctx->blk_len)) == NULL) {
FREE(ctx);
HMAC_RET(NTRU_CRYPTO_HMAC_OUT_OF_MEMORY);
}
/* calculate K0 and store in HMAC context */
memset(ctx->k0, 0, ctx->blk_len);
/* check if key is too large */
if (key_len > ctx->blk_len) {
if ((result = ntru_crypto_hash_digest(algid, key, key_len, ctx->k0))) {
memset(ctx->k0, 0, ctx->blk_len);
FREE(ctx->k0);
FREE(ctx);
return result;
}
} else {
memcpy(ctx->k0, key, key_len);
}
/* return pointer to HMAC context */
*c = ctx;
HMAC_RET(NTRU_CRYPTO_HMAC_OK);
}
