static int
__archive_nettle_ripemd160update(archive_rmd160_ctx *ctx, const void *indata,
size_t insize)
{
ripemd160_update(ctx, insize, indata);
return (ARCHIVE_OK);
}
static bool do_test(const struct test *t, bool single)
{
struct ripemd160 h;
if (single) {
if (t->repetitions != 1)
return true;
ripemd160(&h, t->test, strlen(t->test));
} else {
struct ripemd160_ctx ctx = RIPEMD160_INIT;
size_t i;
for (i = 0; i < t->repetitions; i++)
ripemd160_update(&ctx, t->test, strlen(t->test));
ripemd160_done(&ctx, &h);
}
return memcmp(&h.u, t->result, sizeof(t->result)) == 0;
}
static void ripemd160_update_wrap( void *ctx, const unsigned char *input,
size_t ilen )
{
ripemd160_update( (ripemd160_context *) ctx, input, ilen );
}
void
hmac_ripemd160(const uint8 *key, int32 keyLength, const uint8 *input,
int32 length, uint8 *digest)
{
ripemd160_context context;
uint8 keyInnerPad[65]; /* inner padding - key XORd with ipad */
uint8 keyOuterPad[65]; /* outer padding - key XORd with opad */
uint8 tk[RIPEMD160_DIGESTSIZE];
int i;
/* If the key is longer than the hash algorithm block size,
let key = ripemd160(key), as per HMAC specifications. */
if (keyLength > RIPEMD160_BLOCKSIZE) {
ripemd160_context tctx;
ripemd160_init(&tctx);
ripemd160_update(&tctx, key, keyLength);
ripemd160_final(tk, &tctx);
key = tk;
keyLength = RIPEMD160_DIGESTSIZE;
memset(&tctx, 0, sizeof(tctx)); // Prevent leaks
}
/*
RMD160(K XOR opad, RMD160(K XOR ipad, text))
where K is an n byte key
ipad is the byte 0x36 repeated RIPEMD160_BLOCKSIZE times
opad is the byte 0x5c repeated RIPEMD160_BLOCKSIZE times
and text is the data being protected */
/* start out by storing key in pads */
memset(keyInnerPad, 0x36, sizeof(keyInnerPad));
memset(keyOuterPad, 0x5c, sizeof(keyOuterPad));
/* XOR key with ipad and opad values */
for (i = 0; i < keyLength; i++) {
keyInnerPad[i] ^= key[i];
keyOuterPad[i] ^= key[i];
}
/* perform inner RIPEMD-160 */
ripemd160_init(&context); /* init context for 1st pass */
ripemd160_update(&context, keyInnerPad, RIPEMD160_BLOCKSIZE);
ripemd160_update(&context, input, length); /* then text of datagram */
ripemd160_final(digest, &context); /* finish up 1st pass */
/* perform outer RIPEMD-160 */
ripemd160_init(&context); /* init context for 2nd pass */
ripemd160_update(&context, keyOuterPad, RIPEMD160_BLOCKSIZE);
/* results of 1st hash */
ripemd160_update(&context, digest, RIPEMD160_DIGESTSIZE);
ripemd160_final(digest, &context); /* finish up 2nd pass */
/* Prevent possible leaks. */
memset(keyInnerPad, 0, sizeof(keyInnerPad));
memset(keyOuterPad, 0, sizeof(keyOuterPad));
memset(tk, 0, sizeof(tk));
memset(&context, 0, sizeof(context));
}
void
hmac_ripemd160_update(struct hmac_ripemd160_ctx *ctx,
unsigned length, const uint8_t *data)
{
ripemd160_update(&ctx->state, length, data);
}
