static void * ripemd160_ctx_alloc( void )
{
ripemd160_context *ctx;
ctx = (ripemd160_context *) polarssl_malloc( sizeof( ripemd160_context ) );
if( ctx == NULL )
return( NULL );
ripemd160_init( ctx );
return( ctx );
}
void
ripemd160_digest(struct ripemd160_ctx *ctx, size_t length, uint8_t *digest)
{
uint64_t bit_count;
assert(length <= RIPEMD160_DIGEST_SIZE);
MD_PAD(ctx, 8, COMPRESS);
/* There are 2^9 bits in one block */
bit_count = (ctx->count << 9) | (ctx->index << 3);
\
/* append the 64 bit count */
LE_WRITE_UINT64(ctx->block + 56, bit_count);
_nettle_ripemd160_compress(ctx->state, ctx->block);
_nettle_write_le32(length, digest, ctx->state);
ripemd160_init(ctx);
}
static int
__archive_nettle_ripemd160init(archive_rmd160_ctx *ctx)
{
ripemd160_init(ctx);
return (ARCHIVE_OK);
}
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));
}
