nettle: use the correct type for hash and MAC functions

diff --git a/lib/accelerated/x86/hmac-padlock.c b/lib/accelerated/x86/hmac-padlock.c
index 1d1a1bd1e608f2661f249beeede0068b095fe330..94f58f5f4a003c9d30eb25e2b62c997d7983a1bd 100644 (file)
--- a/lib/accelerated/x86/hmac-padlock.c
+++ b/lib/accelerated/x86/hmac-padlock.c
@@ -41,9 +41,9 @@
 #define OPAD 0x5c
 #define MAX_SHA_DIGEST_SIZE (512/8)
 
-typedef void (*update_func) (void *, unsigned, const uint8_t *);
-typedef void (*digest_func) (void *, unsigned, uint8_t *);
-typedef void (*set_key_func) (void *, unsigned, const uint8_t *);
+typedef void (*update_func) (void *, size_t, const uint8_t *);
+typedef void (*digest_func) (void *, size_t, uint8_t *);
+typedef void (*set_key_func) (void *, size_t, const uint8_t *);
 
 struct padlock_hmac_ctx {
        union {
@@ -64,91 +64,91 @@ struct padlock_hmac_ctx {
 
 static void
 padlock_hmac_sha1_set_key(struct hmac_sha1_ctx *ctx,
-                         unsigned key_length, const uint8_t * key)
+                         size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &padlock_sha1, key_length, key);
 }
 
 static void
 padlock_hmac_sha1_update(struct hmac_sha1_ctx *ctx,
-                        unsigned length, const uint8_t * data)
+                        size_t length, const uint8_t * data)
 {
        padlock_sha1_update(&ctx->state, length, data);
 }
 
 static void
 padlock_hmac_sha1_digest(struct hmac_sha1_ctx *ctx,
-                        unsigned length, uint8_t * digest)
+                        size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &padlock_sha1, length, digest);
 }
 
 static void
 padlock_hmac_sha256_set_key(struct hmac_sha256_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &padlock_sha256, key_length, key);
 }
 
 static void
 padlock_hmac_sha256_update(struct hmac_sha256_ctx *ctx,
-                          unsigned length, const uint8_t * data)
+                          size_t length, const uint8_t * data)
 {
        padlock_sha256_update(&ctx->state, length, data);
 }
 
 static void
 padlock_hmac_sha256_digest(struct hmac_sha256_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &padlock_sha256, length, digest);
 }
 
 static void
 padlock_hmac_sha224_set_key(struct hmac_sha224_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &padlock_sha224, key_length, key);
 }
 
 static void
 padlock_hmac_sha224_digest(struct hmac_sha224_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &padlock_sha224, length, digest);
 }
 
 static void
 padlock_hmac_sha384_set_key(struct hmac_sha384_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &padlock_sha384, key_length, key);
 }
 
 static void
 padlock_hmac_sha384_digest(struct hmac_sha384_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &padlock_sha384, length, digest);
 }
 
 static void
 padlock_hmac_sha512_set_key(struct hmac_sha512_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &padlock_sha512, key_length, key);
 }
 
 static void
 padlock_hmac_sha512_update(struct hmac_sha512_ctx *ctx,
-                          unsigned length, const uint8_t * data)
+                          size_t length, const uint8_t * data)
 {
        padlock_sha512_update(&ctx->state, length, data);
 }
 
 static void
 padlock_hmac_sha512_digest(struct hmac_sha512_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &padlock_sha512, length, digest);
 }

diff --git a/lib/accelerated/x86/hmac-x86-ssse3.c b/lib/accelerated/x86/hmac-x86-ssse3.c
index 54a81140c4b7faf809cf60eb24344aef632196d2..dd641aa52832d40c23d8d1ea94e6174c84ba9f59 100644 (file)
--- a/lib/accelerated/x86/hmac-x86-ssse3.c
+++ b/lib/accelerated/x86/hmac-x86-ssse3.c
@@ -36,9 +36,9 @@
 
 #ifdef HAVE_LIBNETTLE
 
-typedef void (*update_func) (void *, unsigned, const uint8_t *);
-typedef void (*digest_func) (void *, unsigned, uint8_t *);
-typedef void (*set_key_func) (void *, unsigned, const uint8_t *);
+typedef void (*update_func) (void *, size_t, const uint8_t *);
+typedef void (*digest_func) (void *, size_t, uint8_t *);
+typedef void (*set_key_func) (void *, size_t, const uint8_t *);
 
 struct x86_hmac_ctx {
        union {
@@ -61,56 +61,56 @@ struct x86_hmac_ctx {
 
 static void
 x86_hmac_sha1_set_key(struct hmac_sha1_ctx *ctx,
-                         unsigned key_length, const uint8_t * key)
+                         size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &x86_sha1, key_length, key);
 }
 
 static void
 x86_hmac_sha1_update(struct hmac_sha1_ctx *ctx,
-                        unsigned length, const uint8_t * data)
+                        size_t length, const uint8_t * data)
 {
        x86_sha1_update(&ctx->state, length, data);
 }
 
 static void
 x86_hmac_sha1_digest(struct hmac_sha1_ctx *ctx,
-                        unsigned length, uint8_t * digest)
+                        size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &x86_sha1, length, digest);
 }
 
 static void
 x86_hmac_sha256_set_key(struct hmac_sha256_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &x86_sha256, key_length, key);
 }
 
 static void
 x86_hmac_sha256_update(struct hmac_sha256_ctx *ctx,
-                          unsigned length, const uint8_t * data)
+                          size_t length, const uint8_t * data)
 {
        x86_sha256_update(&ctx->state, length, data);
 }
 
 static void
 x86_hmac_sha256_digest(struct hmac_sha256_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &x86_sha256, length, digest);
 }
 
 static void
 x86_hmac_sha224_set_key(struct hmac_sha224_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &x86_sha224, key_length, key);
 }
 
 static void
 x86_hmac_sha224_digest(struct hmac_sha224_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &x86_sha224, length, digest);
 }
@@ -118,35 +118,35 @@ x86_hmac_sha224_digest(struct hmac_sha224_ctx *ctx,
 #ifdef ENABLE_SHA512
 static void
 x86_hmac_sha384_set_key(struct hmac_sha384_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &x86_sha384, key_length, key);
 }
 
 static void
 x86_hmac_sha384_digest(struct hmac_sha384_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &x86_sha384, length, digest);
 }
 
 static void
 x86_hmac_sha512_set_key(struct hmac_sha512_ctx *ctx,
-                           unsigned key_length, const uint8_t * key)
+                           size_t key_length, const uint8_t * key)
 {
        HMAC_SET_KEY(ctx, &x86_sha512, key_length, key);
 }
 
 static void
 x86_hmac_sha512_update(struct hmac_sha512_ctx *ctx,
-                          unsigned length, const uint8_t * data)
+                          size_t length, const uint8_t * data)
 {
        x86_sha512_update(&ctx->state, length, data);
 }
 
 static void
 x86_hmac_sha512_digest(struct hmac_sha512_ctx *ctx,
-                          unsigned length, uint8_t * digest)
+                          size_t length, uint8_t * digest)
 {
        HMAC_DIGEST(ctx, &x86_sha512, length, digest);
 }

diff --git a/lib/accelerated/x86/sha-padlock.c b/lib/accelerated/x86/sha-padlock.c
index dc74a50f5396f2cc8471dabb5943eaf5373759a5..41602832a09f417357960e4dd4b06e98fba61790 100644 (file)
--- a/lib/accelerated/x86/sha-padlock.c
+++ b/lib/accelerated/x86/sha-padlock.c
@@ -34,9 +34,9 @@
 
 #ifdef HAVE_LIBNETTLE
 
-typedef void (*update_func) (void *, unsigned, const uint8_t *);
-typedef void (*digest_func) (void *, unsigned, uint8_t *);
-typedef void (*set_key_func) (void *, unsigned, const uint8_t *);
+typedef void (*update_func) (void *, size_t, const uint8_t *);
+typedef void (*digest_func) (void *, size_t, uint8_t *);
+typedef void (*set_key_func) (void *, size_t, const uint8_t *);
 typedef void (*init_func) (void *);
 
 struct padlock_hash_ctx {
@@ -77,21 +77,21 @@ static void wrap_padlock_hash_deinit(void *hd)
 
 void
 padlock_sha1_update(struct sha1_ctx *ctx,
-                   unsigned length, const uint8_t * data)
+                   size_t length, const uint8_t * data)
 {
        MD_UPDATE(ctx, length, data, SHA1_COMPRESS, MD1_INCR(ctx));
 }
 
 void
 padlock_sha256_update(struct sha256_ctx *ctx,
-                     unsigned length, const uint8_t * data)
+                     size_t length, const uint8_t * data)
 {
        MD_UPDATE(ctx, length, data, SHA256_COMPRESS, MD1_INCR(ctx));
 }
 
 void
 padlock_sha512_update(struct sha512_ctx *ctx,
-                     unsigned length, const uint8_t * data)
+                     size_t length, const uint8_t * data)
 {
        MD_UPDATE(ctx, length, data, SHA512_COMPRESS, MD_INCR(ctx));
 }
@@ -132,7 +132,7 @@ _nettle_write_be32(unsigned length, uint8_t * dst, uint32_t * src)
 
 static void
 padlock_sha1_digest(struct sha1_ctx *ctx,
-                   unsigned length, uint8_t * digest)
+                   size_t length, uint8_t * digest)
 {
        uint64_t bit_count;
 
@@ -152,7 +152,7 @@ padlock_sha1_digest(struct sha1_ctx *ctx,
 
 static void
 padlock_sha256_digest(struct sha256_ctx *ctx,
-                     unsigned length, uint8_t * digest)
+                     size_t length, uint8_t * digest)
 {
        uint64_t bit_count;
 
@@ -174,7 +174,7 @@ padlock_sha256_digest(struct sha256_ctx *ctx,
 
 static void
 padlock_sha512_digest(struct sha512_ctx *ctx,
-                     unsigned length, uint8_t * digest)
+                     size_t length, uint8_t * digest)
 {
        uint64_t high, low;
 

diff --git a/lib/accelerated/x86/sha-padlock.h b/lib/accelerated/x86/sha-padlock.h
index 5cbe1d13b003ceb558c2f93f43dcb97c872847f7..e489582b65efb0802f30c8c33beaab79af5cd27a 100644 (file)
--- a/lib/accelerated/x86/sha-padlock.h
+++ b/lib/accelerated/x86/sha-padlock.h
@@ -18,11 +18,11 @@ int wrap_padlock_hash_fast(gnutls_digest_algorithm_t algo,
                           void *digest);
 
 void padlock_sha1_update(struct sha1_ctx *ctx,
-                        unsigned length, const uint8_t * data);
+                        size_t length, const uint8_t * data);
 void padlock_sha256_update(struct sha256_ctx *ctx,
-                          unsigned length, const uint8_t * data);
+                          size_t length, const uint8_t * data);
 void padlock_sha512_update(struct sha512_ctx *ctx,
-                          unsigned length, const uint8_t * data);
+                          size_t length, const uint8_t * data);
 
 extern const struct nettle_hash padlock_sha1;
 extern const struct nettle_hash padlock_sha224;

diff --git a/lib/accelerated/x86/sha-x86-ssse3.c b/lib/accelerated/x86/sha-x86-ssse3.c
index e99885bcf2d490655900d3c118a03264007f1041..d73039ed00ce8e292eadf00414d19af93e5d183e 100644 (file)
--- a/lib/accelerated/x86/sha-x86-ssse3.c
+++ b/lib/accelerated/x86/sha-x86-ssse3.c
@@ -35,9 +35,9 @@ void sha1_block_data_order(void *c, const void *p, size_t len);
 void sha256_block_data_order(void *c, const void *p, size_t len);
 void sha512_block_data_order(void *c, const void *p, size_t len);
 
-typedef void (*update_func) (void *, unsigned, const uint8_t *);
-typedef void (*digest_func) (void *, unsigned, uint8_t *);
-typedef void (*set_key_func) (void *, unsigned, const uint8_t *);
+typedef void (*update_func) (void *, size_t, const uint8_t *);
+typedef void (*digest_func) (void *, size_t, uint8_t *);
+typedef void (*set_key_func) (void *, size_t, const uint8_t *);
 typedef void (*init_func) (void *);
 
 struct x86_hash_ctx {

diff --git a/lib/nettle/mac.c b/lib/nettle/mac.c
index 39e53793c501165da5ec9f4d414bbdbc93338aa2..311bd404a9a4c44ff664d75df5cf3c62ded2a3a2 100644 (file)
--- a/lib/nettle/mac.c
+++ b/lib/nettle/mac.c
@@ -34,10 +34,10 @@
 #include <nettle/umac.h>
 #include <fips.h>
 
-typedef void (*update_func) (void *, unsigned, const uint8_t *);
-typedef void (*digest_func) (void *, unsigned, uint8_t *);
-typedef void (*set_key_func) (void *, unsigned, const uint8_t *);
-typedef void (*set_nonce_func) (void *, unsigned, const uint8_t *);
+typedef void (*update_func) (void *, size_t, const uint8_t *);
+typedef void (*digest_func) (void *, size_t, uint8_t *);
+typedef void (*set_key_func) (void *, size_t, const uint8_t *);
+typedef void (*set_nonce_func) (void *, size_t, const uint8_t *);
 
 static int wrap_nettle_hash_init(gnutls_digest_algorithm_t algo,
                                 void **_ctx);
@@ -85,7 +85,7 @@ struct nettle_mac_ctx {
 };
 
 static void
-_wrap_umac96_set_key(void *ctx, unsigned len, const uint8_t * key)
+_wrap_umac96_set_key(void *ctx, size_t len, const uint8_t * key)
 {
        if (unlikely(len != 16))
                abort();
@@ -93,7 +93,7 @@ _wrap_umac96_set_key(void *ctx, unsigned len, const uint8_t * key)
 }
 
 static void
-_wrap_umac128_set_key(void *ctx, unsigned len, const uint8_t * key)
+_wrap_umac128_set_key(void *ctx, size_t len, const uint8_t * key)
 {
        if (unlikely(len != 16))
                abort();