Use size_t rather than unsigned for all cipher-related functions.

ChangeLog

+2013-04-26  Niels Möller  <nisse@lysator.liu.se>
+
+	* Many files: Use size_t rather than unsigned for data sizes.
+	* x86_64/aes-encrypt-internal.asm: Accept 64-bit length.
+	* x86_64/aes-decrypt-internal.asm: Likewise.
+
 2013-04-25  Niels Möller  <nisse@lysator.liu.se>
 
 	* configure.ac: Changed version number, to 2.8.

aes-decrypt-internal.c

@@ -35,7 +35,7 @@
 void
 _nettle_aes_decrypt(const struct aes_ctx *ctx,
 		    const struct aes_table *T,
-		    unsigned length, uint8_t *dst,
+		    size_t length, uint8_t *dst,
 		    const uint8_t *src)
 {
   FOR_BLOCKS(length, dst, src, AES_BLOCK_SIZE)

aes-decrypt.c

@@ -338,7 +338,7 @@ _aes_decrypt_table =
 
 void
 aes_decrypt(const struct aes_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src)
 {
   assert(!(length % AES_BLOCK_SIZE) );

aes-encrypt-internal.c

@@ -35,7 +35,7 @@
 void
 _nettle_aes_encrypt(const struct aes_ctx *ctx,
 		    const struct aes_table *T,
-		    unsigned length, uint8_t *dst,
+		    size_t length, uint8_t *dst,
 		    const uint8_t *src)
 {
   FOR_BLOCKS(length, dst, src, AES_BLOCK_SIZE)

aes-encrypt.c

@@ -36,7 +36,7 @@
    For PIC code, the details can be complex and system dependent. */
 void
 aes_encrypt(const struct aes_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src)
 {
   assert(!(length % AES_BLOCK_SIZE) );

aes-internal.h

@@ -53,13 +53,13 @@ struct aes_table
 void
 _aes_encrypt(const struct aes_ctx *ctx,
 	     const struct aes_table *T,
-	     unsigned length, uint8_t *dst,
+	     size_t length, uint8_t *dst,
 	     const uint8_t *src);
 
 void
 _aes_decrypt(const struct aes_ctx *ctx,
 	     const struct aes_table *T,
-	     unsigned length, uint8_t *dst,
+	     size_t length, uint8_t *dst,
 	     const uint8_t *src);
 
 /* Macros */

aes-set-decrypt-key.c

@@ -161,7 +161,7 @@ aes_invert_key(struct aes_ctx *dst,
 
 void
 aes_set_decrypt_key(struct aes_ctx *ctx,
-		    unsigned keysize, const uint8_t *key)
+		    size_t keysize, const uint8_t *key)
 {
   /* We first create subkeys for encryption,
    * then modify the subkeys for decryption. */

aes-set-encrypt-key.c

@@ -36,7 +36,7 @@
 
 void
 aes_set_encrypt_key(struct aes_ctx *ctx,
-		    unsigned keysize, const uint8_t *key)
+		    size_t keysize, const uint8_t *key)
 {
   static const uint8_t rcon[10] = {
     0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x1b,0x36,

aes.h

@@ -59,11 +59,11 @@ struct aes_ctx
 
 void
 aes_set_encrypt_key(struct aes_ctx *ctx,
-		    unsigned length, const uint8_t *key);
+		    size_t length, const uint8_t *key);
 
 void
 aes_set_decrypt_key(struct aes_ctx *ctx,
-		   unsigned length, const uint8_t *key);
+		   size_t length, const uint8_t *key);
 
 void
 aes_invert_key(struct aes_ctx *dst,
@@ -71,11 +71,11 @@ aes_invert_key(struct aes_ctx *dst,
 
 void
 aes_encrypt(const struct aes_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src);
 void
 aes_decrypt(const struct aes_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src);
 
 #ifdef __cplusplus

arcfour-crypt.c

@@ -33,7 +33,7 @@
 
 void
 arcfour_crypt(struct arcfour_ctx *ctx,
-	      unsigned length, uint8_t *dst,
+	      size_t length, uint8_t *dst,
 	      const uint8_t *src)
 {
   register uint8_t i, j;

arcfour.c

@@ -35,7 +35,7 @@
 
 void
 arcfour_set_key(struct arcfour_ctx *ctx,
-		unsigned length, const uint8_t *key)
+		size_t length, const uint8_t *key)
 {
   unsigned i, j, k;
   

arcfour.h

@@ -51,11 +51,11 @@ struct arcfour_ctx
 
 void
 arcfour_set_key(struct arcfour_ctx *ctx,
-		unsigned length, const uint8_t *key);
+		size_t length, const uint8_t *key);
 
 void
 arcfour_crypt(struct arcfour_ctx *ctx,
-	      unsigned length, uint8_t *dst,
+	      size_t length, uint8_t *dst,
 	      const uint8_t *src);
 
 #ifdef __cplusplus

arctwo.c

@@ -85,7 +85,7 @@ static const uint8_t arctwo_sbox[] = {
 
 void
 arctwo_encrypt (struct arctwo_ctx *ctx,
-		unsigned length, uint8_t *dst, const uint8_t *src)
+		size_t length, uint8_t *dst, const uint8_t *src)
 {
   FOR_BLOCKS (length, dst, src, ARCTWO_BLOCK_SIZE)
   {
@@ -130,7 +130,7 @@ arctwo_encrypt (struct arctwo_ctx *ctx,
 
 void
 arctwo_decrypt (struct arctwo_ctx *ctx,
-		unsigned length, uint8_t *dst, const uint8_t *src)
+		size_t length, uint8_t *dst, const uint8_t *src)
 {
   FOR_BLOCKS (length, dst, src, ARCTWO_BLOCK_SIZE)
   {
@@ -176,9 +176,9 @@ arctwo_decrypt (struct arctwo_ctx *ctx,
 
 void
 arctwo_set_key_ekb (struct arctwo_ctx *ctx,
-		    unsigned length, const uint8_t *key, unsigned ekb)
+		    size_t length, const uint8_t *key, unsigned ekb)
 {
-  unsigned i;
+  size_t i;
   /* Expanded key, treated as octets */
   uint8_t S[128];
   uint8_t x;
@@ -217,14 +217,14 @@ arctwo_set_key_ekb (struct arctwo_ctx *ctx,
 }
 
 void
-arctwo_set_key (struct arctwo_ctx *ctx, unsigned length, const uint8_t *key)
+arctwo_set_key (struct arctwo_ctx *ctx, size_t length, const uint8_t *key)
 {
   arctwo_set_key_ekb (ctx, length, key, 8 * length);
 }
 
 void
 arctwo_set_key_gutmann (struct arctwo_ctx *ctx,
-			unsigned length, const uint8_t *key)
+			size_t length, const uint8_t *key)
 {
   arctwo_set_key_ekb (ctx, length, key, 0);
 }

arctwo.h

@@ -57,23 +57,23 @@ struct arctwo_ctx
    as an explicit argument. 0 means maximum key bits. */
 void
 arctwo_set_key_ekb (struct arctwo_ctx *ctx,
-		    unsigned length, const uint8_t * key, unsigned ekb);
+		    size_t length, const uint8_t * key, unsigned ekb);
 
 /* Equvivalent to arctwo_set_key_ekb, with ekb = 8 * length */
 void
-arctwo_set_key (struct arctwo_ctx *ctx, unsigned length, const uint8_t *key);
+arctwo_set_key (struct arctwo_ctx *ctx, size_t length, const uint8_t *key);
 
 /* Equvivalent to arctwo_set_key_ekb, with ekb = 1024 */
 void
 arctwo_set_key_gutmann (struct arctwo_ctx *ctx,
-			unsigned length, const uint8_t *key);
+			size_t length, const uint8_t *key);
 
 void
 arctwo_encrypt (struct arctwo_ctx *ctx,
-		unsigned length, uint8_t *dst, const uint8_t *src);
+		size_t length, uint8_t *dst, const uint8_t *src);
 void
 arctwo_decrypt (struct arctwo_ctx *ctx,
-		unsigned length, uint8_t *dst, const uint8_t *src);
+		size_t length, uint8_t *dst, const uint8_t *src);
 
 #ifdef __cplusplus
 }

blowfish.c

@@ -321,7 +321,7 @@ decrypt (const struct blowfish_ctx *ctx, uint32_t * ret_xl, uint32_t * ret_xr)
 
 void
 blowfish_encrypt (const struct blowfish_ctx *ctx,
-		  unsigned length, uint8_t * dst, const uint8_t * src)
+		  size_t length, uint8_t * dst, const uint8_t * src)
 {
   FOR_BLOCKS (length, dst, src, BLOWFISH_BLOCK_SIZE)
     {
@@ -343,7 +343,7 @@ blowfish_encrypt (const struct blowfish_ctx *ctx,
 
 void
 blowfish_decrypt (const struct blowfish_ctx *ctx,
-		  unsigned length, uint8_t * dst, const uint8_t * src)
+		  size_t length, uint8_t * dst, const uint8_t * src)
 {
   FOR_BLOCKS (length, dst, src, BLOWFISH_BLOCK_SIZE)
     {
@@ -365,7 +365,7 @@ blowfish_decrypt (const struct blowfish_ctx *ctx,
 
 int
 blowfish_set_key (struct blowfish_ctx *ctx,
-		  unsigned length, const uint8_t * key)
+		  size_t length, const uint8_t * key)
 {
   int i, j;
   uint32_t data, datal, datar;

blowfish.h

@@ -58,15 +58,15 @@ struct blowfish_ctx
  * On error, returns 0 and sets ctx->status to BLOWFISH_WEAK_KEY. */
 int
 blowfish_set_key(struct blowfish_ctx *ctx,
-                 unsigned length, const uint8_t *key);
+                 size_t length, const uint8_t *key);
 
 void
 blowfish_encrypt(const struct blowfish_ctx *ctx,
-                 unsigned length, uint8_t *dst,
+                 size_t length, uint8_t *dst,
                  const uint8_t *src);
 void
 blowfish_decrypt(const struct blowfish_ctx *ctx,
-                 unsigned length, uint8_t *dst,
+                 size_t length, uint8_t *dst,
                  const uint8_t *src);
 
 #ifdef __cplusplus

camellia-crypt-internal.c

@@ -125,7 +125,7 @@
 void
 _camellia_crypt(const struct camellia_ctx *ctx,
 		const struct camellia_table *T,
-		unsigned length, uint8_t *dst,
+		size_t length, uint8_t *dst,
 		const uint8_t *src)
 {
   FOR_BLOCKS(length, dst, src, CAMELLIA_BLOCK_SIZE)

camellia-crypt.c

@@ -36,8 +36,8 @@
    For PIC code, the details can be complex and system dependent. */
 void
 camellia_crypt(const struct camellia_ctx *ctx,
-		 unsigned length, uint8_t *dst,
-	    const uint8_t *src)
+	       size_t length, uint8_t *dst,
+	       const uint8_t *src)
 {
   assert(!(length % CAMELLIA_BLOCK_SIZE) );
   _camellia_crypt(ctx, &_camellia_table,

camellia-internal.h

@@ -63,7 +63,7 @@ struct camellia_table
 void
 _camellia_crypt(const struct camellia_ctx *ctx,
 		const struct camellia_table *T,
-		unsigned length, uint8_t *dst,
+		size_t length, uint8_t *dst,
 		const uint8_t *src);
 
 extern const struct camellia_table _camellia_table;

camellia-set-decrypt-key.c

@@ -54,7 +54,7 @@ camellia_invert_key(struct camellia_ctx *dst,
 
 void
 camellia_set_decrypt_key(struct camellia_ctx *ctx,
-			 unsigned length, const uint8_t *key)
+			 size_t length, const uint8_t *key)
 {
   camellia_set_encrypt_key(ctx, length, key);
   camellia_invert_key(ctx, ctx);

camellia-set-encrypt-key.c

@@ -87,7 +87,7 @@
 
 void
 camellia_set_encrypt_key(struct camellia_ctx *ctx,
-			 unsigned length, const uint8_t *key)
+			 size_t length, const uint8_t *key)
 {
   uint64_t k0, k1;
 

camellia.h

@@ -61,11 +61,11 @@ struct camellia_ctx
 
 void
 camellia_set_encrypt_key(struct camellia_ctx *ctx,
-			 unsigned length, const uint8_t *key);
+			 size_t length, const uint8_t *key);
 
 void
 camellia_set_decrypt_key(struct camellia_ctx *ctx,
-			 unsigned length, const uint8_t *key);
+			 size_t length, const uint8_t *key);
 
 void
 camellia_invert_key(struct camellia_ctx *dst,
@@ -73,7 +73,7 @@ camellia_invert_key(struct camellia_ctx *dst,
   
 void
 camellia_crypt(const struct camellia_ctx *ctx,
-	       unsigned length, uint8_t *dst,
+	       size_t length, uint8_t *dst,
 	       const uint8_t *src);
 #ifdef  __cplusplus
 }

cast128.c

@@ -72,7 +72,7 @@
 
 void
 cast128_encrypt(const struct cast128_ctx *ctx,
-		unsigned length, uint8_t *dst,
+		size_t length, uint8_t *dst,
 		const uint8_t *src)
 {
   FOR_BLOCKS(length, dst, src, CAST128_BLOCK_SIZE)
@@ -116,7 +116,7 @@ cast128_encrypt(const struct cast128_ctx *ctx,
 
 void
 cast128_decrypt(const struct cast128_ctx *ctx,
-		unsigned length, uint8_t *dst,
+		size_t length, uint8_t *dst,
 		const uint8_t *src)
 {
   FOR_BLOCKS(length, dst, src, CAST128_BLOCK_SIZE)
@@ -161,7 +161,7 @@ cast128_decrypt(const struct cast128_ctx *ctx,
 
 void
 cast128_set_key(struct cast128_ctx *ctx,
-		unsigned keybytes, const uint8_t *rawkey)
+		size_t keybytes, const uint8_t *rawkey)
 {
   uint32_t t[4], z[4], x[4];
   unsigned i;

cast128.h

@@ -59,15 +59,15 @@ struct cast128_ctx
 
 void
 cast128_set_key(struct cast128_ctx *ctx,
-		unsigned length, const uint8_t *key);
+		size_t length, const uint8_t *key);
 
 void
 cast128_encrypt(const struct cast128_ctx *ctx,
-		unsigned length, uint8_t *dst,
+		size_t length, uint8_t *dst,
 		const uint8_t *src);
 void
 cast128_decrypt(const struct cast128_ctx *ctx,
-		unsigned length, uint8_t *dst,
+		size_t length, uint8_t *dst,
 		const uint8_t *src);
 
 #ifdef __cplusplus

cbc.c

@@ -38,8 +38,8 @@
 
 void
 cbc_encrypt(void *ctx, nettle_crypt_func *f,
-	    unsigned block_size, uint8_t *iv,
-	    unsigned length, uint8_t *dst,
+	    size_t block_size, uint8_t *iv,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src)
 {
   assert(!(length % block_size));
@@ -57,8 +57,8 @@ cbc_encrypt(void *ctx, nettle_crypt_func *f,
 
 void
 cbc_decrypt(void *ctx, nettle_crypt_func *f,
-	    unsigned block_size, uint8_t *iv,
-	    unsigned length, uint8_t *dst,
+	    size_t block_size, uint8_t *iv,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src)
 {
   assert(!(length % block_size));
@@ -90,7 +90,7 @@ cbc_decrypt(void *ctx, nettle_crypt_func *f,
       TMP_DECL(buffer, uint8_t, CBC_BUFFER_LIMIT);
       TMP_DECL(initial_iv, uint8_t, NETTLE_MAX_CIPHER_BLOCK_SIZE);
 
-      unsigned buffer_size;
+      size_t buffer_size;
 
       if (length <= CBC_BUFFER_LIMIT)
 	buffer_size = length;

cbc.h

@@ -38,14 +38,14 @@ extern "C" {
 
 void
 cbc_encrypt(void *ctx, nettle_crypt_func *f,
-	    unsigned block_size, uint8_t *iv,
-	    unsigned length, uint8_t *dst,
+	    size_t block_size, uint8_t *iv,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src);
 
 void
 cbc_decrypt(void *ctx, nettle_crypt_func *f,
-	    unsigned block_size, uint8_t *iv,
-	    unsigned length, uint8_t *dst,
+	    size_t block_size, uint8_t *iv,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src);
 
 #define CBC_CTX(type, size) \

ctr.c

@@ -41,8 +41,8 @@
 
 void
 ctr_crypt(void *ctx, nettle_crypt_func *f,
-	  unsigned block_size, uint8_t *ctr,
-	  unsigned length, uint8_t *dst,
+	  size_t block_size, uint8_t *ctr,
+	  size_t length, uint8_t *dst,
 	  const uint8_t *src)
 {
   if (src != dst)
@@ -55,7 +55,7 @@ ctr_crypt(void *ctx, nettle_crypt_func *f,
 	}
       else
 	{
-	  unsigned left;
+	  size_t left;
 	  uint8_t *p;	  
 
 	  for (p = dst, left = length;
@@ -85,7 +85,7 @@ ctr_crypt(void *ctx, nettle_crypt_func *f,
       if (length > block_size)
 	{
 	  TMP_DECL(buffer, uint8_t, NBLOCKS * NETTLE_MAX_CIPHER_BLOCK_SIZE);
-	  unsigned chunk = NBLOCKS * block_size;
+	  size_t chunk = NBLOCKS * block_size;
 
 	  TMP_ALLOC(buffer, chunk);
 

ctr.h

@@ -38,8 +38,8 @@ extern "C" {
 
 void
 ctr_crypt(void *ctx, nettle_crypt_func *f,
-	  unsigned block_size, uint8_t *ctr,
-	  unsigned length, uint8_t *dst,
+	  size_t block_size, uint8_t *ctr,
+	  size_t length, uint8_t *dst,
 	  const uint8_t *src);
 
 #define CTR_CTX(type, size) \

des.c

@@ -65,9 +65,9 @@ parity_16[16] =
 #define PARITY(x) (parity_16[(x)&0xf] ^ parity_16[((x)>>4) & 0xf])
 
 int
-des_check_parity(unsigned length, const uint8_t *key)
+des_check_parity(size_t length, const uint8_t *key)
 {
-  unsigned i;
+  size_t i;
   for (i = 0; i<length; i++)
     if (!PARITY(key[i]))
       return 0;
@@ -76,10 +76,10 @@ des_check_parity(unsigned length, const uint8_t *key)
 }
 
 void
-des_fix_parity(unsigned length, uint8_t *dst,
+des_fix_parity(size_t length, uint8_t *dst,
 	       const uint8_t *src)
 {
-  unsigned i;
+  size_t i;
   for (i = 0; i<length; i++)
     dst[i] = src[i] ^ PARITY(src[i]) ^ 1;
 }
@@ -265,7 +265,7 @@ des_set_key(struct des_ctx *ctx, const uint8_t *key)
 
 void
 des_encrypt(const struct des_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src)
 {
   assert(!(length % DES_BLOCK_SIZE));
@@ -281,7 +281,7 @@ des_encrypt(const struct des_ctx *ctx,
 
 void
 des_decrypt(const struct des_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src)
 {
   assert(!(length % DES_BLOCK_SIZE));

des.h

@@ -68,18 +68,18 @@ des_set_key(struct des_ctx *ctx, const uint8_t *key);
 
 void
 des_encrypt(const struct des_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src);
 void
 des_decrypt(const struct des_ctx *ctx,
-	    unsigned length, uint8_t *dst,
+	    size_t length, uint8_t *dst,
 	    const uint8_t *src);
 
 int
-des_check_parity(unsigned length, const uint8_t *key);
+des_check_parity(size_t length, const uint8_t *key);
 
 void
-des_fix_parity(unsigned length, uint8_t *dst,
+des_fix_parity(size_t length, uint8_t *dst,
 	       const uint8_t *src);
 
 #define DES3_KEY_SIZE 24
@@ -97,11 +97,11 @@ des3_set_key(struct des3_ctx *ctx, const uint8_t *key);
 
 void
 des3_encrypt(const struct des3_ctx *ctx,
-	     unsigned length, uint8_t *dst,
+	     size_t length, uint8_t *dst,
 	     const uint8_t *src);
 void
 des3_decrypt(const struct des3_ctx *ctx,
-	     unsigned length, uint8_t *dst,
+	     size_t length, uint8_t *dst,
 	     const uint8_t *src);
 
 #ifdef __cplusplus

des3.c

@@ -49,7 +49,7 @@ des3_set_key(struct des3_ctx *ctx, const uint8_t *key)
 
 void
 des3_encrypt(const struct des3_ctx *ctx,
-	     unsigned length, uint8_t *dst,
+	     size_t length, uint8_t *dst,
 	     const uint8_t *src)
 {
   des_encrypt(&ctx->des[0],
@@ -62,7 +62,7 @@ des3_encrypt(const struct des3_ctx *ctx,
 
 void
 des3_decrypt(const struct des3_ctx *ctx,
-	     unsigned length, uint8_t *dst,
+	     size_t length, uint8_t *dst,
 	     const uint8_t *src)
 {
   des_decrypt(&ctx->des[2],

examples/nettle-openssl.c

@@ -52,21 +52,21 @@
 /* AES */
 static nettle_set_key_func openssl_aes_set_encrypt_key;
 static void
-openssl_aes_set_encrypt_key(void *ctx, unsigned length, const uint8_t *key)
+openssl_aes_set_encrypt_key(void *ctx, size_t length, const uint8_t *key)
 {
   AES_set_encrypt_key(key, length * 8, ctx);
 }
 
 static nettle_set_key_func openssl_aes_set_decrypt_key;
 static void
-openssl_aes_set_decrypt_key(void *ctx, unsigned length, const uint8_t *key)
+openssl_aes_set_decrypt_key(void *ctx, size_t length, const uint8_t *key)
 {
   AES_set_decrypt_key(key, length * 8, ctx);
 }
 
 static nettle_crypt_func openssl_aes_encrypt;
 static void
-openssl_aes_encrypt(void *ctx, unsigned length,
+openssl_aes_encrypt(void *ctx, size_t length,
 		    uint8_t *dst, const uint8_t *src)
 {
   assert (!(length % AES_BLOCK_SIZE));
@@ -81,7 +81,7 @@ openssl_aes_encrypt(void *ctx, unsigned length,
 
 static nettle_crypt_func openssl_aes_decrypt;
 static void
-openssl_aes_decrypt(void *ctx, unsigned length,
+openssl_aes_decrypt(void *ctx, size_t length,
 		    uint8_t *dst, const uint8_t *src)
 {
   assert (!(length % AES_BLOCK_SIZE));
@@ -127,14 +127,14 @@ nettle_openssl_aes256 = {