/*
 *  Copyright (C) 2021 - This file is part of libecc project
 *
 *  Authors:
 *      Ryad BENADJILA <ryadbenadjila@gmail.com>
 *      Arnaud EBALARD <arnaud.ebalard@ssi.gouv.fr>
 *
 *  This software is licensed under a dual BSD and GPL v2 license.
 *  See LICENSE file at the root folder of the project.
 */
#include <libecc/lib_ecc_config.h>
#ifdef WITH_HMAC

#include <libecc/hash/hmac.h>

int hmac_init(hmac_context *ctx, const u8 *hmackey, u32 hmackey_len,
	      hash_alg_type hash_type)
{
	u8 ipad[MAX_BLOCK_SIZE];
	u8 opad[MAX_BLOCK_SIZE];
	u8 local_hmac_key[MAX_BLOCK_SIZE];
	unsigned int i, local_hmac_key_len;
	int ret;
	const hash_mapping *h;

	MUST_HAVE((ctx != NULL) && (hmackey != NULL), ret, err);

	ret = local_memset(local_hmac_key, 0, sizeof(local_hmac_key)); EG(ret, err);
	/* Set ipad and opad to appropriate values */
	ret = local_memset(ipad, 0x36, sizeof(ipad)); EG(ret, err);
	ret = local_memset(opad, 0x5c, sizeof(opad)); EG(ret, err);

	/* Get the hash mapping of the current asked hash function */
	ret = get_hash_by_type(hash_type, &(ctx->hash)); EG(ret, err);
	MUST_HAVE((ctx->hash != NULL), ret, err);

	/* Make things more readable */
	h = ctx->hash;

	if(hmackey_len <= ctx->hash->block_size){
		/* The key size is less than the hash function block size */
		ret = local_memcpy(local_hmac_key, hmackey, hmackey_len); EG(ret, err);
		local_hmac_key_len = hmackey_len;
	}
	else{
		/* The key size is greater than the hash function block size.
		 * We hash it to shorten it.
		 */
		hash_context tmp_ctx;
		/* Check our callback */
		ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);
		ret = h->hfunc_init(&tmp_ctx); EG(ret, err);
		ret = h->hfunc_update(&tmp_ctx, hmackey, hmackey_len); EG(ret, err);
		ret = h->hfunc_finalize(&tmp_ctx, local_hmac_key); EG(ret, err);
		local_hmac_key_len = h->digest_size;
	}

	/* Initialize our input and output hash contexts */
	/* Check our callback */
	ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);
	ret = h->hfunc_init(&(ctx->in_ctx)); EG(ret, err);
	/* Check our callback */
	ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);
	ret = h->hfunc_init(&(ctx->out_ctx)); EG(ret, err);

	/* Update our input context with K^ipad */
	for(i = 0; i < local_hmac_key_len; i++){
		ipad[i] ^= local_hmac_key[i];
	}
	ret = h->hfunc_update(&(ctx->in_ctx), ipad, h->block_size); EG(ret, err);
	/* Update our output context with K^opad */
	for(i = 0; i < local_hmac_key_len; i++){
		opad[i] ^= local_hmac_key[i];
	}
	ret = h->hfunc_update(&(ctx->out_ctx), opad, h->block_size); EG(ret, err);

	/* Initialize our magic */
	ctx->magic = HMAC_MAGIC;

err:
	return ret;
}

int hmac_update(hmac_context *ctx, const u8 *input, u32 ilen)
{
	int ret;
	const hash_mapping *h;

	HMAC_CHECK_INITIALIZED(ctx, ret, err);
	MUST_HAVE((input != NULL) || (ilen == 0), ret, err);

	/* Make things more readable */
	h = ctx->hash;
	/* Check our callback */
	ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);
	ret = h->hfunc_update(&(ctx->in_ctx), input, ilen); EG(ret, err);

err:
	return ret;
}

int hmac_finalize(hmac_context *ctx, u8 *output, u8 *outlen)
{
	int ret;
	u8 in_hash[MAX_DIGEST_SIZE];
	const hash_mapping *h;

	HMAC_CHECK_INITIALIZED(ctx, ret, err);
	MUST_HAVE((output != NULL) && (outlen != NULL), ret, err);

	/* Make things more readable */
	h = ctx->hash;

	MUST_HAVE(((*outlen) >= h->digest_size), ret, err);

	/* Check our callback */
	ret = hash_mapping_callbacks_sanity_check(h); EG(ret, err);
	ret = h->hfunc_finalize(&(ctx->in_ctx), in_hash); EG(ret, err);
	ret = h->hfunc_update(&(ctx->out_ctx), in_hash, h->digest_size); EG(ret, err);
	ret = h->hfunc_finalize(&(ctx->out_ctx), output); EG(ret, err);
	(*outlen) = h->digest_size;

err:
	if(ctx != NULL){
		/* Clear the hash contexts that could contain sensitive data */
		IGNORE_RET_VAL(local_memset(ctx, 0, sizeof(hmac_context)));
		/* Uninitialize the context  */
		ctx->magic = WORD(0);
	}
	if(ret && (outlen != NULL)){
		(*outlen) = 0;
	}
	return ret;
}

int hmac(const u8 *hmackey, u32 hmackey_len, hash_alg_type hash_type,
	 const u8 *input, u32 ilen, u8 *output, u8 *outlen)
{
	int ret;
	hmac_context ctx;

	ret = hmac_init(&ctx, hmackey, hmackey_len, hash_type); EG(ret, err);
	ret = hmac_update(&ctx, input, ilen); EG(ret, err);
	ret = hmac_finalize(&ctx, output, outlen);

err:
	/* Clean our context as it can contain sensitive data */
	IGNORE_RET_VAL(local_memset(&ctx, 0, sizeof(hmac_context)));

	return ret;
}

/* Scattered version */
int hmac_scattered(const u8 *hmackey, u32 hmackey_len, hash_alg_type hash_type,
	 const u8 **inputs, const u32 *ilens, u8 *output, u8 *outlen)
{
	int ret, pos = 0;
	hmac_context ctx;

	MUST_HAVE((inputs != NULL) && (ilens != NULL) && (output != NULL), ret, err);

	ret = hmac_init(&ctx, hmackey, hmackey_len, hash_type); EG(ret, err);

	while (inputs[pos] != NULL) {
		ret = hmac_update(&ctx, inputs[pos], ilens[pos]); EG(ret, err);
		pos += 1;
	}

	ret = hmac_finalize(&ctx, output, outlen);

err:
	/* Clean our context as it can contain sensitive data */
	IGNORE_RET_VAL(local_memset(&ctx, 0, sizeof(hmac_context)));

	return ret;
}


#else /* WITH_HMAC */

/*
 * Dummy definition to avoid the empty translation unit ISO C warning
 */
typedef int dummy;
#endif /* WITH_HMAC */