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