minor variable rename LENGTH -> LEN, STRING_LENGTH -> STR_LEN

diff --git a/client/fwknop.c b/client/fwknop.c
index f71b6fb..2f12bbc 100644 (file)
--- a/client/fwknop.c
+++ b/client/fwknop.c
@@ -874,7 +874,7 @@ get_keys(fko_ctx_t ctx, fko_cli_options_t *options,
     {
         *hmac_key_len = fko_base64_decode(options->hmac_key_base64,
             (unsigned char *) options->hmac_key);
-        memcpy(hmac_key, options->hmac_key, SHA256_BLOCK_LENGTH);
+        memcpy(hmac_key, options->hmac_key, SHA256_BLOCK_LEN);
         use_hmac = 1;
     }
     else if (options->use_hmac)

diff --git a/lib/digest.c b/lib/digest.c
index e16b58b..5eaaf85 100644 (file)
--- a/lib/digest.c
+++ b/lib/digest.c
@@ -62,10 +62,10 @@ md5(unsigned char *out, unsigned char *in, size_t size)
 void
 md5_hex(char *out, unsigned char *in, size_t size)
 {
-    uint8_t      md[MD5_DIGEST_LENGTH];
+    uint8_t      md[MD5_DIGEST_LEN];
 
     md5(md, in, size);
-    digest_to_hex(out, md, MD5_DIGEST_LENGTH);
+    digest_to_hex(out, md, MD5_DIGEST_LEN);
 }
 
 /* Compute MD5 hash on in and store the base64 string result in out.
@@ -73,10 +73,10 @@ md5_hex(char *out, unsigned char *in, size_t size)
 void
 md5_base64(char *out, unsigned char *in, size_t size)
 {
-    uint8_t      md[MD5_DIGEST_LENGTH];
+    uint8_t      md[MD5_DIGEST_LEN];
 
     md5(md, in, size);
-    b64_encode(md, out, MD5_DIGEST_LENGTH);
+    b64_encode(md, out, MD5_DIGEST_LEN);
 
     strip_b64_eq(out);
 }
@@ -98,10 +98,10 @@ sha1(unsigned char *out, unsigned char *in, size_t size)
 void
 sha1_hex(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA1_DIGEST_LENGTH];
+    uint8_t       md[SHA1_DIGEST_LEN];
 
     sha1(md, in, size);
-    digest_to_hex(out, md, SHA1_DIGEST_LENGTH);
+    digest_to_hex(out, md, SHA1_DIGEST_LEN);
 }
 
 /* Compute SHA1 hash on in and store the base64 string result in out.
@@ -109,10 +109,10 @@ sha1_hex(char *out, unsigned char *in, size_t size)
 void
 sha1_base64(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA1_DIGEST_LENGTH];
+    uint8_t       md[SHA1_DIGEST_LEN];
 
     sha1(md, in, size);
-    b64_encode(md, out, SHA1_DIGEST_LENGTH);
+    b64_encode(md, out, SHA1_DIGEST_LEN);
 
     strip_b64_eq(out);
 }
@@ -134,10 +134,10 @@ sha256(unsigned char *out, unsigned char *in, size_t size)
 void
 sha256_hex(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA256_DIGEST_LENGTH];
+    uint8_t       md[SHA256_DIGEST_LEN];
 
     sha256(md, in, size);
-    digest_to_hex(out, md, SHA256_DIGEST_LENGTH);
+    digest_to_hex(out, md, SHA256_DIGEST_LEN);
 }
 
 /* Compute SHA256 hash on in and store the base64 string result in out.
@@ -145,10 +145,10 @@ sha256_hex(char *out, unsigned char *in, size_t size)
 void
 sha256_base64(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA256_DIGEST_LENGTH];
+    uint8_t       md[SHA256_DIGEST_LEN];
 
     sha256(md, in, size);
-    b64_encode(md, out, SHA256_DIGEST_LENGTH);
+    b64_encode(md, out, SHA256_DIGEST_LEN);
 
     strip_b64_eq(out);
 }
@@ -170,10 +170,10 @@ sha384(unsigned char *out, unsigned char *in, size_t size)
 void
 sha384_hex(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA384_DIGEST_LENGTH];
+    uint8_t       md[SHA384_DIGEST_LEN];
 
     sha384(md, in, size);
-    digest_to_hex(out, md, SHA384_DIGEST_LENGTH);
+    digest_to_hex(out, md, SHA384_DIGEST_LEN);
 }
 
 /* Compute SHA384 hash on in and store the base64 string result in out.
@@ -181,10 +181,10 @@ sha384_hex(char *out, unsigned char *in, size_t size)
 void
 sha384_base64(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA384_DIGEST_LENGTH];
+    uint8_t       md[SHA384_DIGEST_LEN];
 
     sha384(md, in, size);
-    b64_encode(md, out, SHA384_DIGEST_LENGTH);
+    b64_encode(md, out, SHA384_DIGEST_LEN);
 
     strip_b64_eq(out);
 }
@@ -206,10 +206,10 @@ sha512(unsigned char *out, unsigned char *in, size_t size)
 void
 sha512_hex(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA512_DIGEST_LENGTH];
+    uint8_t       md[SHA512_DIGEST_LEN];
 
     sha512(md, in, size);
-    digest_to_hex(out, md, SHA512_DIGEST_LENGTH);
+    digest_to_hex(out, md, SHA512_DIGEST_LEN);
 }
 
 /* Compute SHA512 hash on in and store the base64 string result in out.
@@ -217,10 +217,10 @@ sha512_hex(char *out, unsigned char *in, size_t size)
 void
 sha512_base64(char *out, unsigned char *in, size_t size)
 {
-    uint8_t       md[SHA512_DIGEST_LENGTH];
+    uint8_t       md[SHA512_DIGEST_LEN];
 
     sha512(md, in, size);
-    b64_encode(md, out, SHA512_DIGEST_LENGTH);
+    b64_encode(md, out, SHA512_DIGEST_LEN);
 
     strip_b64_eq(out);
 }

diff --git a/lib/digest.h b/lib/digest.h
index 91c9471..4716209 100644 (file)
--- a/lib/digest.h
+++ b/lib/digest.h
@@ -43,11 +43,11 @@
 
 /* Predefined base64 encoded digest sizes.
 */
-#define MD5_B64_LENGTH      22
-#define SHA1_B64_LENGTH     27
-#define SHA256_B64_LENGTH   43
-#define SHA384_B64_LENGTH   64
-#define SHA512_B64_LENGTH   86
+#define MD5_B64_LEN      22
+#define SHA1_B64_LEN     27
+#define SHA256_B64_LEN   43
+#define SHA384_B64_LEN   64
+#define SHA512_B64_LEN   86
 
 void md5(unsigned char* out, unsigned char* in, size_t size);
 void md5_hex(char* out, unsigned char* in, size_t size);

diff --git a/lib/fko_decode.c b/lib/fko_decode.c
index 56cf1da..dec34d6 100644 (file)
--- a/lib/fko_decode.c
+++ b/lib/fko_decode.c
@@ -61,27 +61,27 @@ fko_decode_spa_data(fko_ctx_t ctx)
     if (i < MIN_SPA_FIELDS)
         return(FKO_ERROR_INVALID_DATA);
 
-    t_size = strnlen(ndx, SHA512_B64_LENGTH+1);
+    t_size = strnlen(ndx, SHA512_B64_LEN+1);
 
     switch(t_size)
     {
-        case MD5_B64_LENGTH:
+        case MD5_B64_LEN:
             ctx->digest_type = FKO_DIGEST_MD5;
             break;
 
-        case SHA1_B64_LENGTH:
+        case SHA1_B64_LEN:
             ctx->digest_type = FKO_DIGEST_SHA1;
             break;
 
-        case SHA256_B64_LENGTH:
+        case SHA256_B64_LEN:
             ctx->digest_type = FKO_DIGEST_SHA256;
             break;
 
-        case SHA384_B64_LENGTH:
+        case SHA384_B64_LEN:
             ctx->digest_type = FKO_DIGEST_SHA384;
             break;
 
-        case SHA512_B64_LENGTH:
+        case SHA512_B64_LEN:
             ctx->digest_type = FKO_DIGEST_SHA512;
             break;
 

diff --git a/lib/fko_digest.c b/lib/fko_digest.c
index 0654c39..9669cee 100644 (file)
--- a/lib/fko_digest.c
+++ b/lib/fko_digest.c
@@ -111,53 +111,53 @@ set_digest(char *data, char **digest, short digest_type, int *digest_len)
     switch(digest_type)
     {
         case FKO_DIGEST_MD5:
-            md = malloc(MD_HEX_SIZE(MD5_DIGEST_LENGTH)+1);
+            md = malloc(MD_HEX_SIZE(MD5_DIGEST_LEN)+1);
             if(md == NULL)
                 return(FKO_ERROR_MEMORY_ALLOCATION);
 
             md5_base64(md,
                 (unsigned char*)data, data_len);
-            *digest_len = MD5_B64_LENGTH;
+            *digest_len = MD5_B64_LEN;
             break;
 
         case FKO_DIGEST_SHA1:
-            md = malloc(MD_HEX_SIZE(SHA1_DIGEST_LENGTH)+1);
+            md = malloc(MD_HEX_SIZE(SHA1_DIGEST_LEN)+1);
             if(md == NULL)
                 return(FKO_ERROR_MEMORY_ALLOCATION);
 
             sha1_base64(md,
                 (unsigned char*)data, data_len);
-            *digest_len = SHA1_B64_LENGTH;
+            *digest_len = SHA1_B64_LEN;
             break;
 
         case FKO_DIGEST_SHA256:
-            md = malloc(MD_HEX_SIZE(SHA256_DIGEST_LENGTH)+1);
+            md = malloc(MD_HEX_SIZE(SHA256_DIGEST_LEN)+1);
             if(md == NULL)
                 return(FKO_ERROR_MEMORY_ALLOCATION);
 
             sha256_base64(md,
                 (unsigned char*)data, data_len);
-            *digest_len = SHA256_B64_LENGTH;
+            *digest_len = SHA256_B64_LEN;
             break;
 
         case FKO_DIGEST_SHA384:
-            md = malloc(MD_HEX_SIZE(SHA384_DIGEST_LENGTH)+1);
+            md = malloc(MD_HEX_SIZE(SHA384_DIGEST_LEN)+1);
             if(md == NULL)
                 return(FKO_ERROR_MEMORY_ALLOCATION);
 
             sha384_base64(md,
                 (unsigned char*)data, data_len);
-            *digest_len = SHA384_B64_LENGTH;
+            *digest_len = SHA384_B64_LEN;
             break;
 
         case FKO_DIGEST_SHA512:
-            md = malloc(MD_HEX_SIZE(SHA512_DIGEST_LENGTH)+1);
+            md = malloc(MD_HEX_SIZE(SHA512_DIGEST_LEN)+1);
             if(md == NULL)
                 return(FKO_ERROR_MEMORY_ALLOCATION);
 
             sha512_base64(md,
                 (unsigned char*)data, data_len);
-            *digest_len = SHA512_B64_LENGTH;
+            *digest_len = SHA512_B64_LEN;
             break;
 
         default:

diff --git a/lib/fko_funcs.c b/lib/fko_funcs.c
index 73c0658..f6a352a 100644 (file)
--- a/lib/fko_funcs.c
+++ b/lib/fko_funcs.c
@@ -353,13 +353,13 @@ int
 fko_key_gen(char *key_base64, char *hmac_key_base64)
 {
     unsigned char key[RIJNDAEL_MAX_KEYSIZE];
-    unsigned char hmac_key[SHA256_BLOCK_LENGTH];
+    unsigned char hmac_key[SHA256_BLOCK_LEN];
 
     get_random_data(key, RIJNDAEL_MAX_KEYSIZE);
-    get_random_data(hmac_key, SHA256_BLOCK_LENGTH);
+    get_random_data(hmac_key, SHA256_BLOCK_LEN);
 
     b64_encode(key, key_base64, RIJNDAEL_MAX_KEYSIZE);
-    b64_encode(hmac_key, hmac_key_base64, SHA256_BLOCK_LENGTH);
+    b64_encode(hmac_key, hmac_key_base64, SHA256_BLOCK_LEN);
 
     return(FKO_SUCCESS);
 }

diff --git a/lib/fko_hmac.c b/lib/fko_hmac.c
index 85e18a9..6800292 100644 (file)
--- a/lib/fko_hmac.c
+++ b/lib/fko_hmac.c
@@ -52,21 +52,21 @@ int fko_verify_hmac(fko_ctx_t ctx,
     /* Get digest value
     */
     hmac_digest_from_data = strndup((ctx->encrypted_msg
-            + ctx->encrypted_msg_len - SHA256_B64_LENGTH), SHA256_B64_LENGTH);
+            + ctx->encrypted_msg_len - SHA256_B64_LEN), SHA256_B64_LEN);
 
     if(hmac_digest_from_data == NULL)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
     /* Now we chop the HMAC digest off of the encrypted msg
     */
-    tbuf = strndup(ctx->encrypted_msg, ctx->encrypted_msg_len - SHA256_B64_LENGTH);
+    tbuf = strndup(ctx->encrypted_msg, ctx->encrypted_msg_len - SHA256_B64_LEN);
     if(tbuf == NULL)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
     free(ctx->encrypted_msg);
 
     ctx->encrypted_msg      = tbuf;
-    ctx->encrypted_msg_len -= SHA256_B64_LENGTH;
+    ctx->encrypted_msg_len -= SHA256_B64_LEN;
 
     /* See if we need to add the "Salted__" string to the front of the
      * encrypted data.
@@ -88,7 +88,7 @@ int fko_verify_hmac(fko_ctx_t ctx,
         if(res == FKO_SUCCESS)
         {
             if(strncmp(hmac_digest_from_data,
-                    ctx->msg_hmac, SHA256_B64_LENGTH) != 0)
+                    ctx->msg_hmac, SHA256_B64_LEN) != 0)
             {
                 res = FKO_ERROR_INVALID_DATA;
             }
@@ -136,7 +136,7 @@ fko_set_hmac_mode(fko_ctx_t ctx, const short hmac_mode)
 int fko_calculate_hmac(fko_ctx_t ctx,
     const char *hmac_key, const int hmac_key_len)
 {
-    unsigned char hmac[SHA256_DIGEST_STRING_LENGTH] = {0};
+    unsigned char hmac[SHA256_DIGEST_STR_LEN] = {0};
     char *hmac_base64 = NULL;
 
     /* Must be initialized
@@ -149,18 +149,18 @@ int fko_calculate_hmac(fko_ctx_t ctx,
     if(ctx->hmac_mode != FKO_HMAC_SHA256)
         return(FKO_ERROR_UNSUPPORTED_HMAC_MODE);
 
-    hmac_base64 = calloc(1, MD_HEX_SIZE(SHA256_DIGEST_LENGTH)+1);
+    hmac_base64 = calloc(1, MD_HEX_SIZE(SHA256_DIGEST_LEN)+1);
     if (hmac_base64 == NULL)
         return(FKO_ERROR_MEMORY_ALLOCATION);
 
     hmac_sha256(ctx->encrypted_msg,
         ctx->encrypted_msg_len, hmac, hmac_key);
 
-    b64_encode(hmac, hmac_base64, SHA256_DIGEST_LENGTH);
+    b64_encode(hmac, hmac_base64, SHA256_DIGEST_LEN);
     strip_b64_eq(hmac_base64);
 
     ctx->msg_hmac     = strdup(hmac_base64);
-    ctx->msg_hmac_len = strnlen(ctx->msg_hmac, SHA512_DIGEST_STRING_LENGTH);
+    ctx->msg_hmac_len = strnlen(ctx->msg_hmac, SHA512_DIGEST_STR_LEN);
 
     free(hmac_base64);
 

diff --git a/lib/fko_util.c b/lib/fko_util.c
index 23cb3da..638b6e8 100644 (file)
--- a/lib/fko_util.c
+++ b/lib/fko_util.c
@@ -60,15 +60,15 @@ is_valid_digest_len(const int len)
 {
     switch(len)
     {
-        case MD5_B64_LENGTH:
+        case MD5_B64_LEN:
             break;
-        case SHA1_B64_LENGTH:
+        case SHA1_B64_LEN:
             break;
-        case SHA256_B64_LENGTH:
+        case SHA256_B64_LEN:
             break;
-        case SHA384_B64_LENGTH:
+        case SHA384_B64_LEN:
             break;
-        case SHA512_B64_LENGTH:
+        case SHA512_B64_LEN:
             break;
         default:
             return(0);

diff --git a/lib/hmac.c b/lib/hmac.c
index f098c66..edb4f90 100644 (file)
--- a/lib/hmac.c
+++ b/lib/hmac.c
@@ -47,16 +47,16 @@ void hmac_sha256_init(hmac_sha256_ctx *ctx, const char *key)
 {
     int i = 0;
 
-    for (i=0; i < (int) SHA256_BLOCK_LENGTH; i++) {
+    for (i=0; i < (int) SHA256_BLOCK_LEN; i++) {
         ctx->block_inner_pad[i] = key[i] ^ 0x36;
         ctx->block_outer_pad[i] = key[i] ^ 0x5c;
     }
 
     SHA256_Init(&ctx->ctx_inside);
-    SHA256_Update(&ctx->ctx_inside, ctx->block_inner_pad, SHA256_BLOCK_LENGTH);
+    SHA256_Update(&ctx->ctx_inside, ctx->block_inner_pad, SHA256_BLOCK_LEN);
 
     SHA256_Init(&ctx->ctx_outside);
-    SHA256_Update(&ctx->ctx_outside, ctx->block_outer_pad, SHA256_BLOCK_LENGTH);
+    SHA256_Update(&ctx->ctx_outside, ctx->block_outer_pad, SHA256_BLOCK_LEN);
 
     return;
 }
@@ -70,10 +70,10 @@ void hmac_sha256_update(hmac_sha256_ctx *ctx, const char *msg,
 
 void hmac_sha256_final(hmac_sha256_ctx *ctx, unsigned char *hmac)
 {
-    unsigned char digest_inside[SHA256_DIGEST_LENGTH];
+    unsigned char digest_inside[SHA256_DIGEST_LEN];
 
     SHA256_Final(digest_inside, &ctx->ctx_inside);
-    SHA256_Update(&ctx->ctx_outside, digest_inside, SHA256_DIGEST_LENGTH);
+    SHA256_Update(&ctx->ctx_outside, digest_inside, SHA256_DIGEST_LEN);
     SHA256_Final(hmac, &ctx->ctx_outside);
 
     return;

diff --git a/lib/hmac.h b/lib/hmac.h
index d7bff23..44d3060 100644 (file)
--- a/lib/hmac.h
+++ b/lib/hmac.h
@@ -37,8 +37,8 @@ typedef struct {
     SHA256_CTX ctx_inside;
     SHA256_CTX ctx_outside;
 
-    unsigned char block_inner_pad[SHA256_BLOCK_LENGTH];
-    unsigned char block_outer_pad[SHA256_BLOCK_LENGTH];
+    unsigned char block_inner_pad[SHA256_BLOCK_LEN];
+    unsigned char block_outer_pad[SHA256_BLOCK_LEN];
 } hmac_sha256_ctx;
 
 void hmac_sha256(const char *msg, const unsigned int msg_len,

diff --git a/lib/md5.h b/lib/md5.h
index 838915a..e9113e8 100644 (file)
--- a/lib/md5.h
+++ b/lib/md5.h
@@ -37,7 +37,7 @@
 
 #include "fko_common.h"
 
-#define MD5_DIGEST_LENGTH 16
+#define MD5_DIGEST_LEN 16
 
 typedef struct _MD5Context {
         uint32_t buf[4];

diff --git a/lib/sha1.h b/lib/sha1.h
index 4ba9c4f..85e5bbc 100644 (file)
--- a/lib/sha1.h
+++ b/lib/sha1.h
@@ -45,7 +45,7 @@
 #endif
 
 #define SHA1_BLOCKSIZE      64
-#define SHA1_DIGEST_LENGTH  20
+#define SHA1_DIGEST_LEN     20
 
 typedef struct {
     uint32_t    digest[8];
@@ -58,6 +58,6 @@ typedef struct {
 */
 void sha1_init(SHA1_INFO *sha1_info);
 void sha1_update(SHA1_INFO *sha1_info, uint8_t *buffer, int count);
-void sha1_final(uint8_t digest[SHA1_DIGEST_LENGTH], SHA1_INFO *sha1_info);
+void sha1_final(uint8_t digest[SHA1_DIGEST_LEN], SHA1_INFO *sha1_info);
 
 #endif /* SHA1_H */

diff --git a/lib/sha2.c b/lib/sha2.c
index 442e9d9..6c07934 100644 (file)
--- a/lib/sha2.c
+++ b/lib/sha2.c
@@ -140,9 +140,9 @@ typedef u_int64_t sha2_word64;      /* Exactly 8 bytes */
 
 /*** SHA-256/384/512 Various Length Definitions ***********************/
 /* NOTE: Most of these are in sha2.h */
-#define SHA256_SHORT_BLOCK_LENGTH      (SHA256_BLOCK_LENGTH - 8)
-#define SHA384_SHORT_BLOCK_LENGTH      (SHA384_BLOCK_LENGTH - 16)
-#define SHA512_SHORT_BLOCK_LENGTH      (SHA512_BLOCK_LENGTH - 16)
+#define SHA256_SHORT_BLOCK_LEN (SHA256_BLOCK_LEN - 8)
+#define SHA384_SHORT_BLOCK_LEN (SHA384_BLOCK_LEN - 16)
+#define SHA512_SHORT_BLOCK_LEN (SHA512_BLOCK_LEN - 16)
 
 
 /*** ENDIAN REVERSAL MACROS *******************************************/
@@ -357,8 +357,8 @@ void SHA256_Init(SHA256_CTX* context) {
        if (context == (SHA256_CTX*)0) {
                return;
        }
-       MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
-       MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
+       MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LEN);
+       MEMSET_BZERO(context->buffer, SHA256_BLOCK_LEN);
        context->bitcount = 0;
 }
 
@@ -548,10 +548,10 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
        /* Sanity check: */
        assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0);
 
-       usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+       usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LEN;
        if (usedspace > 0) {
                /* Calculate how much free space is available in the buffer */
-               freespace = SHA256_BLOCK_LENGTH - usedspace;
+               freespace = SHA256_BLOCK_LEN - usedspace;
 
                if (len >= freespace) {
                        /* Fill the buffer completely and process it */
@@ -569,12 +569,12 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
                        return;
                }
        }
-       while (len >= SHA256_BLOCK_LENGTH) {
+       while (len >= SHA256_BLOCK_LEN) {
                /* Process as many complete blocks as we can */
                SHA256_Transform(context, (sha2_word32*)data);
-               context->bitcount += SHA256_BLOCK_LENGTH << 3;
-               len -= SHA256_BLOCK_LENGTH;
-               data += SHA256_BLOCK_LENGTH;
+               context->bitcount += SHA256_BLOCK_LEN << 3;
+               len -= SHA256_BLOCK_LEN;
+               data += SHA256_BLOCK_LEN;
        }
        if (len > 0) {
                /* There's left-overs, so save 'em */
@@ -594,7 +594,7 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
 
        /* If no digest buffer is passed, we don't bother doing this: */
        if (digest != (sha2_byte*)0) {
-               usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+               usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LEN;
 #if BYTE_ORDER == LITTLE_ENDIAN
                /* Convert FROM host byte order */
                REVERSE64(context->bitcount,context->bitcount);
@@ -603,28 +603,28 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
                        /* Begin padding with a 1 bit: */
                        context->buffer[usedspace++] = 0x80;
 
-                       if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
+                       if (usedspace <= SHA256_SHORT_BLOCK_LEN) {
                                /* Set-up for the last transform: */
-                               MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
+                               MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LEN - usedspace);
                        } else {
-                               if (usedspace < SHA256_BLOCK_LENGTH) {
-                                       MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
+                               if (usedspace < SHA256_BLOCK_LEN) {
+                                       MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LEN - usedspace);
                                }
                                /* Do second-to-last transform: */
                                SHA256_Transform(context, (sha2_word32*)context->buffer);
 
                                /* And set-up for the last transform: */
-                               MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+                               MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LEN);
                        }
                } else {
                        /* Set-up for the last transform: */
-                       MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+                       MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LEN);
 
                        /* Begin padding with a 1 bit: */
                        *context->buffer = 0x80;
                }
                /* Set the bit count: */
-               *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
+               *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LEN] = context->bitcount;
 
                /* Final transform: */
                SHA256_Transform(context, (sha2_word32*)context->buffer);
@@ -639,7 +639,7 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
                        }
                }
 #else
-               MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH);
+               MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LEN);
 #endif
        }
 
@@ -649,7 +649,7 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
 }
 
 char *SHA256_End(SHA256_CTX* context, char buffer[]) {
-       sha2_byte       digest[SHA256_DIGEST_LENGTH], *d = digest;
+       sha2_byte       digest[SHA256_DIGEST_LEN], *d = digest;
        int             i;
 
        /* Sanity check: */
@@ -658,7 +658,7 @@ char *SHA256_End(SHA256_CTX* context, char buffer[]) {
        if (buffer != (char*)0) {
                SHA256_Final(digest, context);
 
-               for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+               for (i = 0; i < SHA256_DIGEST_LEN; i++) {
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
                        d++;
@@ -667,11 +667,11 @@ char *SHA256_End(SHA256_CTX* context, char buffer[]) {
        } else {
                MEMSET_BZERO(context, sizeof(context));
        }
-       MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
+       MEMSET_BZERO(digest, SHA256_DIGEST_LEN);
        return buffer;
 }
 
-char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
+char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STR_LEN]) {
        SHA256_CTX      context;
 
        SHA256_Init(&context);
@@ -685,8 +685,8 @@ void SHA512_Init(SHA512_CTX* context) {
        if (context == (SHA512_CTX*)0) {
                return;
        }
-       MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
-       MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
+       MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LEN);
+       MEMSET_BZERO(context->buffer, SHA512_BLOCK_LEN);
        context->bitcount[0] = context->bitcount[1] =  0;
 }
 
@@ -870,10 +870,10 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
        /* Sanity check: */
        assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0);
 
-       usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+       usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LEN;
        if (usedspace > 0) {
                /* Calculate how much free space is available in the buffer */
-               freespace = SHA512_BLOCK_LENGTH - usedspace;
+               freespace = SHA512_BLOCK_LEN - usedspace;
 
                if (len >= freespace) {
                        /* Fill the buffer completely and process it */
@@ -891,12 +891,12 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
                        return;
                }
        }
-       while (len >= SHA512_BLOCK_LENGTH) {
+       while (len >= SHA512_BLOCK_LEN) {
                /* Process as many complete blocks as we can */
                SHA512_Transform(context, (sha2_word64*)data);
-               ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
-               len -= SHA512_BLOCK_LENGTH;
-               data += SHA512_BLOCK_LENGTH;
+               ADDINC128(context->bitcount, SHA512_BLOCK_LEN << 3);
+               len -= SHA512_BLOCK_LEN;
+               data += SHA512_BLOCK_LEN;
        }
        if (len > 0) {
                /* There's left-overs, so save 'em */
@@ -910,7 +910,7 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
 void SHA512_Last(SHA512_CTX* context) {
        unsigned int    usedspace;
 
-       usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+       usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LEN;
 #if BYTE_ORDER == LITTLE_ENDIAN
        /* Convert FROM host byte order */
        REVERSE64(context->bitcount[0],context->bitcount[0]);
@@ -920,29 +920,29 @@ void SHA512_Last(SHA512_CTX* context) {
                /* Begin padding with a 1 bit: */
                context->buffer[usedspace++] = 0x80;
 
-               if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
+               if (usedspace <= SHA512_SHORT_BLOCK_LEN) {
                        /* Set-up for the last transform: */
-                       MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
+                       MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LEN - usedspace);
                } else {
-                       if (usedspace < SHA512_BLOCK_LENGTH) {
-                               MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
+                       if (usedspace < SHA512_BLOCK_LEN) {
+                               MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LEN - usedspace);
                        }
                        /* Do second-to-last transform: */
                        SHA512_Transform(context, (sha2_word64*)context->buffer);
 
                        /* And set-up for the last transform: */
-                       MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
+                       MEMSET_BZERO(context->buffer, SHA512_BLOCK_LEN - 2);
                }
        } else {
                /* Prepare for final transform: */
-               MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
+               MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LEN);
 
                /* Begin padding with a 1 bit: */
                *context->buffer = 0x80;
        }
        /* Store the length of input data (in bits): */
-       *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
-       *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
+       *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LEN] = context->bitcount[1];
+       *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LEN+8] = context->bitcount[0];
 
        /* Final transform: */
        SHA512_Transform(context, (sha2_word64*)context->buffer);
@@ -969,7 +969,7 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
                        }
                }
 #else
-               MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
+               MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LEN);
 #endif
        }
 
@@ -978,7 +978,7 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
 }
 
 char *SHA512_End(SHA512_CTX* context, char buffer[]) {
-       sha2_byte       digest[SHA512_DIGEST_LENGTH], *d = digest;
+       sha2_byte       digest[SHA512_DIGEST_LEN], *d = digest;
        int             i;
 
        /* Sanity check: */
@@ -987,7 +987,7 @@ char *SHA512_End(SHA512_CTX* context, char buffer[]) {
        if (buffer != (char*)0) {
                SHA512_Final(digest, context);
 
-               for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
+               for (i = 0; i < SHA512_DIGEST_LEN; i++) {
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
                        d++;
@@ -996,11 +996,11 @@ char *SHA512_End(SHA512_CTX* context, char buffer[]) {
        } else {
                MEMSET_BZERO(context, sizeof(context));
        }
-       MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
+       MEMSET_BZERO(digest, SHA512_DIGEST_LEN);
        return buffer;
 }
 
-char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
+char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STR_LEN]) {
        SHA512_CTX      context;
 
        SHA512_Init(&context);
@@ -1014,8 +1014,8 @@ void SHA384_Init(SHA384_CTX* context) {
        if (context == (SHA384_CTX*)0) {
                return;
        }
-       MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
-       MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
+       MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LEN);
+       MEMSET_BZERO(context->buffer, SHA384_BLOCK_LEN);
        context->bitcount[0] = context->bitcount[1] = 0;
 }
 
@@ -1044,7 +1044,7 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
                        }
                }
 #else
-               MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
+               MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LEN);
 #endif
        }
 
@@ -1053,7 +1053,7 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
 }
 
 char *SHA384_End(SHA384_CTX* context, char buffer[]) {
-       sha2_byte       digest[SHA384_DIGEST_LENGTH], *d = digest;
+       sha2_byte       digest[SHA384_DIGEST_LEN], *d = digest;
        int             i;
 
        /* Sanity check: */
@@ -1062,7 +1062,7 @@ char *SHA384_End(SHA384_CTX* context, char buffer[]) {
        if (buffer != (char*)0) {
                SHA384_Final(digest, context);
 
-               for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
+               for (i = 0; i < SHA384_DIGEST_LEN; i++) {
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
                        d++;
@@ -1071,11 +1071,11 @@ char *SHA384_End(SHA384_CTX* context, char buffer[]) {
        } else {
                MEMSET_BZERO(context, sizeof(context));
        }
-       MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
+       MEMSET_BZERO(digest, SHA384_DIGEST_LEN);
        return buffer;
 }
 
-char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
+char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STR_LEN]) {
        SHA384_CTX      context;
 
        SHA384_Init(&context);

diff --git a/lib/sha2.h b/lib/sha2.h
index 9dabf8d..ee4a286 100644 (file)
--- a/lib/sha2.h
+++ b/lib/sha2.h
@@ -67,15 +67,15 @@ extern "C" {
 #endif
 
 /*** SHA-256/384/512 Various Length Definitions ***********************/
-#define SHA256_BLOCK_LENGTH            64
-#define SHA256_DIGEST_LENGTH           32
-#define SHA256_DIGEST_STRING_LENGTH    (SHA256_DIGEST_LENGTH * 2 + 1)
-#define SHA384_BLOCK_LENGTH            128
-#define SHA384_DIGEST_LENGTH           48
-#define SHA384_DIGEST_STRING_LENGTH    (SHA384_DIGEST_LENGTH * 2 + 1)
-#define SHA512_BLOCK_LENGTH            128
-#define SHA512_DIGEST_LENGTH           64
-#define SHA512_DIGEST_STRING_LENGTH    (SHA512_DIGEST_LENGTH * 2 + 1)
+#define SHA256_BLOCK_LEN        64
+#define SHA256_DIGEST_LEN       32
+#define SHA256_DIGEST_STR_LEN   (SHA256_DIGEST_LEN * 2 + 1)
+#define SHA384_BLOCK_LEN        128
+#define SHA384_DIGEST_LEN       48
+#define SHA384_DIGEST_STR_LEN   (SHA384_DIGEST_LEN * 2 + 1)
+#define SHA512_BLOCK_LEN        128
+#define SHA512_DIGEST_LEN       64
+#define SHA512_DIGEST_STR_LEN   (SHA512_DIGEST_LEN * 2 + 1)
 
 
 /*** SHA-256/384/512 Context Structures *******************************/
@@ -109,12 +109,12 @@ typedef unsigned long long u_int64_t;     /* 8-bytes (64-bits) */
 typedef struct _SHA256_CTX {
        uint32_t        state[8];
        uint64_t        bitcount;
-       uint8_t buffer[SHA256_BLOCK_LENGTH];
+       uint8_t buffer[SHA256_BLOCK_LEN];
 } SHA256_CTX;
 typedef struct _SHA512_CTX {
        uint64_t        state[8];
        uint64_t        bitcount[2];
-       uint8_t buffer[SHA512_BLOCK_LENGTH];
+       uint8_t buffer[SHA512_BLOCK_LEN];
 } SHA512_CTX;
 
 #else /* SHA2_USE_INTTYPES_H */
@@ -122,12 +122,12 @@ typedef struct _SHA512_CTX {
 typedef struct _SHA256_CTX {
        u_int32_t       state[8];
        u_int64_t       bitcount;
-       u_int8_t        buffer[SHA256_BLOCK_LENGTH];
+       u_int8_t        buffer[SHA256_BLOCK_LEN];
 } SHA256_CTX;
 typedef struct _SHA512_CTX {
        u_int64_t       state[8];
        u_int64_t       bitcount[2];
-       u_int8_t        buffer[SHA512_BLOCK_LENGTH];
+       u_int8_t        buffer[SHA512_BLOCK_LEN];
 } SHA512_CTX;
 
 #endif /* SHA2_USE_INTTYPES_H */
@@ -141,41 +141,41 @@ typedef SHA512_CTX SHA384_CTX;
 
 void SHA256_Init(SHA256_CTX *);
 void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
-void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
-char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
-char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+void SHA256_Final(uint8_t[SHA256_DIGEST_LEN], SHA256_CTX*);
+char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STR_LEN]);
+char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STR_LEN]);
 
 void SHA384_Init(SHA384_CTX*);
 void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
-void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
-char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
-char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+void SHA384_Final(uint8_t[SHA384_DIGEST_LEN], SHA384_CTX*);
+char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STR_LEN]);
+char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STR_LEN]);
 
 void SHA512_Init(SHA512_CTX*);
 void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
-void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
-char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
-char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+void SHA512_Final(uint8_t[SHA512_DIGEST_LEN], SHA512_CTX*);
+char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STR_LEN]);
+char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STR_LEN]);
 
 #else /* SHA2_USE_INTTYPES_H */
 
 void SHA256_Init(SHA256_CTX *);
 void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
-void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
-char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
-char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+void SHA256_Final(u_int8_t[SHA256_DIGEST_LEN], SHA256_CTX*);
+char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STR_LEN]);
+char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STR_LEN]);
 
 void SHA384_Init(SHA384_CTX*);
 void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
-void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
-char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
-char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+void SHA384_Final(u_int8_t[SHA384_DIGEST_LEN], SHA384_CTX*);
+char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STR_LEN]);
+char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STR_LEN]);
 
 void SHA512_Init(SHA512_CTX*);
 void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
-void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
-char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
-char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+void SHA512_Final(u_int8_t[SHA512_DIGEST_LEN], SHA512_CTX*);
+char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STR_LEN]);
+char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STR_LEN]);
 
 #endif /* SHA2_USE_INTTYPES_H */