Commit b7e628a6 authored by Niels Möller's avatar Niels Möller

(md5_init): Use memcpy for initializing the state vector.

(COMPRESS): New macro, wrapping _nettle_md5_compress.
(md5_update): Use MD_UPDATE.
(md5_digest): Inline md5_final processing. Use MD_PAD and
_nettle_write_le32.
(md5_final): Deleted.

Rev: nettle/md5.c:1.3
parent cd73b5dd
......@@ -38,110 +38,50 @@
#include "macros.h"
#include "nettle-write.h"
static void
md5_final(struct md5_ctx *ctx);
void
md5_init(struct md5_ctx *ctx)
{
ctx->digest[0] = 0x67452301;
ctx->digest[1] = 0xefcdab89;
ctx->digest[2] = 0x98badcfe;
ctx->digest[3] = 0x10325476;
ctx->count_l = ctx->count_h = 0;
const uint32_t iv[_MD5_DIGEST_LENGTH] =
{
0x67452301,
0xefcdab89,
0x98badcfe,
0x10325476,
};
memcpy(ctx->state, iv, sizeof(ctx->state));
ctx->count_low = ctx->count_high = 0;
ctx->index = 0;
}
#define MD5_INCR(ctx) ((ctx)->count_h += !++(ctx)->count_l)
#define COMPRESS(ctx, data) (_nettle_md5_compress((ctx)->state, (data)))
void
md5_update(struct md5_ctx *ctx,
unsigned length,
const uint8_t *data)
{
if (ctx->index)
{
/* Try to fill partial block */
unsigned left = MD5_DATA_SIZE - ctx->index;
if (length < left)
{
memcpy(ctx->block + ctx->index, data, length);
ctx->index += length;
return; /* Finished */
}
else
{
memcpy(ctx->block + ctx->index, data, left);
_nettle_md5_compress(ctx->digest, ctx->block);
MD5_INCR(ctx);
data += left;
length -= left;
}
}
while (length >= MD5_DATA_SIZE)
{
_nettle_md5_compress(ctx->digest, data);
MD5_INCR(ctx);
data += MD5_DATA_SIZE;
length -= MD5_DATA_SIZE;
}
if ((ctx->index = length)) /* This assignment is intended */
/* Buffer leftovers */
memcpy(ctx->block, data, length);
MD_UPDATE(ctx, length, data, COMPRESS, MD_INCR(ctx));
}
void
md5_digest(struct md5_ctx *ctx,
unsigned length,
uint8_t *digest)
{
assert(length <= MD5_DIGEST_SIZE);
md5_final(ctx);
_nettle_write_le32(length, digest, ctx->digest);
md5_init(ctx);
}
/* Final wrapup - pad to MD5_DATA_SIZE-byte boundary with the bit
* pattern 1 0* (64-bit count of bits processed, LSB-first) */
static void
md5_final(struct md5_ctx *ctx)
{
uint32_t bitcount_high;
uint32_t bitcount_low;
unsigned i;
uint32_t high, low;
i = ctx->index;
assert(length <= MD5_DIGEST_SIZE);
/* Set the first char of padding to 0x80. This is safe since there
* is always at least one byte free */
assert(i < MD5_DATA_SIZE);
ctx->block[i++] = 0x80;
MD_PAD(ctx, 8, COMPRESS);
if (i > (MD5_DATA_SIZE - 8))
{
/* No room for length in this block. Process it and
pad with another one */
memset(ctx->block + i, 0, MD5_DATA_SIZE - i);
_nettle_md5_compress(ctx->digest, ctx->block);
i = 0;
}
if (i < (MD5_DATA_SIZE - 8))
memset(ctx->block + i, 0, (MD5_DATA_SIZE - 8) - i);
/* There are 512 = 2^9 bits in one block
* Little-endian order => Least significant word first */
/* There are 512 = 2^9 bits in one block */
high = (ctx->count_high << 9) | (ctx->count_low >> 23);
low = (ctx->count_low << 9) | (ctx->index << 3);
bitcount_low = (ctx->count_l << 9) | (ctx->index << 3);
bitcount_high = (ctx->count_h << 9) | (ctx->count_l >> 23);
LE_WRITE_UINT32(ctx->block + (MD5_DATA_SIZE - 8), bitcount_low);
LE_WRITE_UINT32(ctx->block + (MD5_DATA_SIZE - 4), bitcount_high);
_nettle_md5_compress(ctx->digest, ctx->block);
LE_WRITE_UINT32(ctx->block + (MD5_DATA_SIZE - 8), low);
LE_WRITE_UINT32(ctx->block + (MD5_DATA_SIZE - 4), high);
_nettle_md5_compress(ctx->state, ctx->block);
_nettle_write_le32(length, digest, ctx->state);
md5_init(ctx);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment