void hmac_sha224_init(hmac_sha224_ctx *ctx, unsigned char *key,
unsigned int key_size)
{
unsigned int fill;
unsigned int num;
unsigned char *key_used;
unsigned char key_temp[SHA224_DIGEST_SIZE];
int i;
if (key_size == SHA224_BLOCK_SIZE) {
key_used = key;
num = SHA224_BLOCK_SIZE;
} else {
if (key_size > SHA224_BLOCK_SIZE){
key_used = key_temp;
num = SHA224_DIGEST_SIZE;
sha224(key, key_size, key_used);
} else { /* key_size > SHA224_BLOCK_SIZE */
key_used = key;
num = key_size;
}
fill = SHA224_BLOCK_SIZE - num;
memset(ctx->block_ipad + num, 0x36, fill);
memset(ctx->block_opad + num, 0x5c, fill);
}
for (i = 0; i < num; i++) {
ctx->block_ipad[i] = key_used[i] ^ 0x36;
ctx->block_opad[i] = key_used[i] ^ 0x5c;
}
sha224_init(&ctx->ctx_inside);
sha224_update(&ctx->ctx_inside, ctx->block_ipad, SHA224_BLOCK_SIZE);
sha224_init(&ctx->ctx_outside);
sha224_update(&ctx->ctx_outside, ctx->block_opad,
SHA224_BLOCK_SIZE);
/* for hmac_reinit */
memcpy(&ctx->ctx_inside_reinit, &ctx->ctx_inside,
sizeof(sha224_ctx));
memcpy(&ctx->ctx_outside_reinit, &ctx->ctx_outside,
sizeof(sha224_ctx));
}
void sha224(const unsigned char *message, unsigned int len,
unsigned char *digest)
{
sha224_ctx ctx;
sha224_init(&ctx);
sha224_update(&ctx, message, len);
sha224_final(&ctx, digest);
}
/*
* length in bits!
*/
void sha224(void *dest, const void *msg, uint32_t length_b){ /* length could be choosen longer but this is for µC */
sha224_ctx_t s;
sha224_init(&s);
while(length_b >= SHA224_BLOCK_BITS){
sha224_nextBlock(&s, msg);
msg = (uint8_t*)msg + SHA224_BLOCK_BITS/8;
length_b -= SHA224_BLOCK_BITS;
}
sha224_lastBlock(&s, msg, length_b);
sha224_ctx2hash(dest,&s);
}
/**
Self-test the hash
@return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
*/
int sha224_test(void)
{
#ifndef LTC_TEST
return CRYPT_NOP;
#else
static const struct {
const char *msg;
unsigned char hash[28];
} tests[] = {
{ "abc",
{ 0x23, 0x09, 0x7d, 0x22, 0x34, 0x05, 0xd8,
0x22, 0x86, 0x42, 0xa4, 0x77, 0xbd, 0xa2,
0x55, 0xb3, 0x2a, 0xad, 0xbc, 0xe4, 0xbd,
0xa0, 0xb3, 0xf7, 0xe3, 0x6c, 0x9d, 0xa7 }
},
{ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
{ 0x75, 0x38, 0x8b, 0x16, 0x51, 0x27, 0x76,
0xcc, 0x5d, 0xba, 0x5d, 0xa1, 0xfd, 0x89,
0x01, 0x50, 0xb0, 0xc6, 0x45, 0x5c, 0xb4,
0xf5, 0x8b, 0x19, 0x52, 0x52, 0x25, 0x25 }
},
};
int i;
unsigned char tmp[28];
hash_state md;
for (i = 0; i < (int)(sizeof(tests) / sizeof(tests[0])); i++) {
sha224_init(&md);
sha224_process(&md, (unsigned char*)tests[i].msg, (unsigned long)strlen(tests[i].msg));
sha224_done(&md, tmp);
if (XMEMCMP(tmp, tests[i].hash, 28) != 0) {
return CRYPT_FAIL_TESTVECTOR;
}
}
return CRYPT_OK;
#endif
}
void libmaus2::digest::SHA2_224::init() {
sha224_init(reinterpret_cast<sha224_ctx *>(ctx));
}
static int
wrap_nettle_hash_init (gnutls_mac_algorithm_t algo, void **_ctx)
{
struct nettle_hash_ctx *ctx;
ctx = gnutls_malloc (sizeof (struct nettle_hash_ctx));
if (ctx == NULL)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
ctx->algo = algo;
switch (algo)
{
case GNUTLS_DIG_MD5:
md5_init (&ctx->ctx.md5);
ctx->update = (update_func) md5_update;
ctx->digest = (digest_func) md5_digest;
ctx->ctx_ptr = &ctx->ctx.md5;
ctx->length = MD5_DIGEST_SIZE;
break;
case GNUTLS_DIG_SHA1:
sha1_init (&ctx->ctx.sha1);
ctx->update = (update_func) sha1_update;
ctx->digest = (digest_func) sha1_digest;
ctx->ctx_ptr = &ctx->ctx.sha1;
ctx->length = SHA1_DIGEST_SIZE;
break;
case GNUTLS_DIG_MD2:
md2_init (&ctx->ctx.md2);
ctx->update = (update_func) md2_update;
ctx->digest = (digest_func) md2_digest;
ctx->ctx_ptr = &ctx->ctx.md2;
ctx->length = MD2_DIGEST_SIZE;
break;
case GNUTLS_DIG_SHA224:
sha224_init (&ctx->ctx.sha224);
ctx->update = (update_func) sha224_update;
ctx->digest = (digest_func) sha224_digest;
ctx->ctx_ptr = &ctx->ctx.sha224;
ctx->length = SHA224_DIGEST_SIZE;
break;
case GNUTLS_DIG_SHA256:
sha256_init (&ctx->ctx.sha256);
ctx->update = (update_func) sha256_update;
ctx->digest = (digest_func) sha256_digest;
ctx->ctx_ptr = &ctx->ctx.sha256;
ctx->length = SHA256_DIGEST_SIZE;
break;
case GNUTLS_DIG_SHA384:
sha384_init (&ctx->ctx.sha384);
ctx->update = (update_func) sha384_update;
ctx->digest = (digest_func) sha384_digest;
ctx->ctx_ptr = &ctx->ctx.sha384;
ctx->length = SHA384_DIGEST_SIZE;
break;
case GNUTLS_DIG_SHA512:
sha512_init (&ctx->ctx.sha512);
ctx->update = (update_func) sha512_update;
ctx->digest = (digest_func) sha512_digest;
ctx->ctx_ptr = &ctx->ctx.sha512;
ctx->length = SHA512_DIGEST_SIZE;
break;
default:
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
*_ctx = ctx;
return 0;
}
void mySHA224_Init(void *c) { sha224_init((sha224_ctx *)c); }
