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); }