Signed-off-by: Dmitry Eremin-Solenikov dbaryshkov@gmail.com --- nettle-meta.h | 1 + sha1-meta.c | 3 +++ sha1.c | 56 ++++++++++++++++++++++++++++++++++++--------------- sha1.h | 29 +++++++++++++++++++++++--- 4 files changed, 70 insertions(+), 19 deletions(-)
diff --git a/nettle-meta.h b/nettle-meta.h index 79a9900cbdfa..95aaaf0fcc8c 100644 --- a/nettle-meta.h +++ b/nettle-meta.h @@ -183,6 +183,7 @@ extern const struct nettle_hash nettle_sha3_512;
extern const struct nettle_bctx_hash nettle_bctx_md5; extern const struct nettle_bctx_hash nettle_bctx_ripemd160; +extern const struct nettle_bctx_hash nettle_bctx_sha1;
struct nettle_aead { diff --git a/sha1-meta.c b/sha1-meta.c index dde990360a8f..def2704c40ee 100644 --- a/sha1-meta.c +++ b/sha1-meta.c @@ -39,3 +39,6 @@
const struct nettle_hash nettle_sha1 = _NETTLE_HASH(sha1, SHA1); + +const struct nettle_bctx_hash nettle_bctx_sha1 += _NETTLE_BLOCK_HASH(sha1, SHA1); diff --git a/sha1.c b/sha1.c index af73096c9016..7dca34b71ef7 100644 --- a/sha1.c +++ b/sha1.c @@ -47,7 +47,7 @@
/* Initialize the SHA values */ void -sha1_init(struct sha1_ctx *ctx) +sha1_block_init(struct sha1_state *state, struct block_ctx *bctx) { /* FIXME: Put the buffer last in the struct, and arrange so that we can initialize with a single memcpy. */ @@ -61,11 +61,17 @@ sha1_init(struct sha1_ctx *ctx) 0xC3D2E1F0L, };
- memcpy(ctx->state, iv, sizeof(ctx->state)); - ctx->count = 0; - + memcpy(state->state, iv, sizeof(state->state)); + state->count = 0; + /* Initialize buffer */ - ctx->index = 0; + bctx->index = 0; +} + +void +sha1_init(struct sha1_ctx *ctx) +{ + return sha1_block_init(&ctx->state, (struct block_ctx *)&ctx->block); }
#define COMPRESS(ctx, data) (nettle_sha1_compress((ctx)->state, data)) @@ -74,27 +80,45 @@ void sha1_update(struct sha1_ctx *ctx, size_t length, const uint8_t *data) { - MD_UPDATE (ctx, length, data, COMPRESS, ctx->count++); + MD_BLOCK_UPDATE(&ctx->state, &ctx->block, SHA1_BLOCK_SIZE, length, data, COMPRESS, ctx->state.count++); } - + void -sha1_digest(struct sha1_ctx *ctx, - size_t length, - uint8_t *digest) +sha1_block_update(struct sha1_state *state, + struct block_ctx *bctx, + size_t length, + const uint8_t *data) +{ + MD_BLOCK_UPDATE(state, bctx, SHA1_BLOCK_SIZE, length, data, COMPRESS, state->count++); +} + +void +sha1_block_digest(struct sha1_state *state, + struct block_ctx *bctx, + size_t length, + uint8_t *digest) { uint64_t bit_count;
assert(length <= SHA1_DIGEST_SIZE);
- MD_PAD(ctx, 8, COMPRESS); + MD_BLOCK_PAD(state, bctx, SHA1_BLOCK_SIZE, 8, COMPRESS);
/* There are 512 = 2^9 bits in one block */ - bit_count = (ctx->count << 9) | (ctx->index << 3); + bit_count = (state->count << 9) | (bctx->index << 3);
/* append the 64 bit count */ - WRITE_UINT64(ctx->block + (SHA1_BLOCK_SIZE - 8), bit_count); - nettle_sha1_compress(ctx->state, ctx->block); + WRITE_UINT64(bctx->buffer + (SHA1_BLOCK_SIZE - 8), bit_count); + nettle_sha1_compress(state->state, bctx->buffer); + + _nettle_write_be32(length, digest, state->state); + sha1_block_init(state, bctx); +}
- _nettle_write_be32(length, digest, ctx->state); - sha1_init(ctx); +void +sha1_digest(struct sha1_ctx *ctx, + size_t length, + uint8_t *digest) +{ + return sha1_block_digest(&ctx->state, (struct block_ctx *)&ctx->block, length, digest); } diff --git a/sha1.h b/sha1.h index 0f4964f8f61c..d5f336eaab04 100644 --- a/sha1.h +++ b/sha1.h @@ -44,6 +44,9 @@ extern "C" { #define sha1_init nettle_sha1_init #define sha1_update nettle_sha1_update #define sha1_digest nettle_sha1_digest +#define sha1_block_init nettle_sha1_block_init +#define sha1_block_update nettle_sha1_block_update +#define sha1_block_digest nettle_sha1_block_digest
/* SHA1 */
@@ -55,12 +58,16 @@ extern "C" { /* Digest is kept internally as 5 32-bit words. */ #define _SHA1_DIGEST_LENGTH 5
-struct sha1_ctx +struct sha1_state { uint32_t state[_SHA1_DIGEST_LENGTH]; /* State variables */ uint64_t count; /* 64-bit block count */ - unsigned int index; /* index into buffer */ - uint8_t block[SHA1_BLOCK_SIZE]; /* SHA1 data buffer */ +}; + +struct sha1_ctx +{ + struct sha1_state state; + BLOCK_CTX(SHA1_BLOCK_SIZE); };
void @@ -76,6 +83,22 @@ sha1_digest(struct sha1_ctx *ctx, size_t length, uint8_t *digest);
+void +sha1_block_init(struct sha1_state *state, + struct block_ctx *bctx); + +void +sha1_block_update(struct sha1_state *state, + struct block_ctx *bctx, + size_t length, + const uint8_t *data); + +void +sha1_block_digest(struct sha1_state *state, + struct block_ctx *bctx, + size_t length, + uint8_t *digest); + /* Internal compression function. STATE points to 5 uint32_t words, and DATA points to 64 bytes of input data, possibly unaligned. */ void