Merge pull request #142 from libtom/fix/85-part1

Fix/85 part1

src/ciphers/aes/aes.c

@@ -675,11 +675,11 @@ int ECB_TEST(void)
     }
  };
 
- symmetric_key key;
+  symmetric_key key;
- unsigned char tmp[2][16];
+  unsigned char tmp[2][16];
- int i, y;
+  int i, y;
 
- for (i = 0; i < (int)(sizeof(tests)/sizeof(tests[0])); i++) {
+  for (i = 0; i < (int)(sizeof(tests)/sizeof(tests[0])); i++) {
     zeromem(&key, sizeof(key));
     if ((err = rijndael_setup(tests[i].key, tests[i].keylen, 0, &key)) != CRYPT_OK) {
        return err;
@@ -707,13 +707,13 @@ int ECB_TEST(void)
         return CRYPT_FAIL_TESTVECTOR;
     }
 
-      /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
+    /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
-      for (y = 0; y < 16; y++) tmp[0][y] = 0;
+    for (y = 0; y < 16; y++) tmp[0][y] = 0;
-      for (y = 0; y < 1000; y++) rijndael_ecb_encrypt(tmp[0], tmp[0], &key);
+    for (y = 0; y < 1000; y++) rijndael_ecb_encrypt(tmp[0], tmp[0], &key);
-      for (y = 0; y < 1000; y++) rijndael_ecb_decrypt(tmp[0], tmp[0], &key);
+    for (y = 0; y < 1000; y++) rijndael_ecb_decrypt(tmp[0], tmp[0], &key);
-      for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
+    for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
- }
+  }
- return CRYPT_OK;
+  return CRYPT_OK;
  #endif
 }
 

src/ciphers/anubis.c

@@ -926,16 +926,16 @@ int  anubis_setup(const unsigned char *key, int keylen, int num_rounds, symmetri
       return CRYPT_INVALID_ROUNDS;
    }
 
-    /*
+   /*
-    * map cipher key to initial key state (mu):
+   * map cipher key to initial key state (mu):
-    */
+   */
-    for (i = 0, pos = 0; i < N; i++, pos += 4) {
+   for (i = 0, pos = 0; i < N; i++, pos += 4) {
       kappa[i] =
          (((ulong32)key[pos    ]) << 24) ^
          (((ulong32)key[pos + 1]) << 16) ^
          (((ulong32)key[pos + 2]) <<  8) ^
          (((ulong32)key[pos + 3])      );
-    }
+   }
 
    /*
     * generate R + 1 round keys:

src/ciphers/camellia.c

@@ -171,7 +171,7 @@ static const ulong32 SP4404[] = {
 0x28280028, 0x7b7b007b, 0xc9c900c9, 0xc1c100c1, 0xe3e300e3, 0xf4f400f4, 0xc7c700c7, 0x9e9e009e,
 };
 
-static ulong64 key_sigma[] = {
+static const ulong64 key_sigma[] = {
    CONST64(0xA09E667F3BCC908B),
    CONST64(0xB67AE8584CAA73B2),
    CONST64(0xC6EF372FE94F82BE),
@@ -686,8 +686,8 @@ int camellia_test(void)
    unsigned int x;
 
    for (x = 0; x < sizeof(tests)/sizeof(tests[0]); x++) {
-     zeromem(&skey, sizeof(skey));
+      zeromem(&skey, sizeof(skey));
-     if ((err = camellia_setup(tests[x].key, tests[x].keylen, 0, &skey)) != CRYPT_OK) {
+      if ((err = camellia_setup(tests[x].key, tests[x].keylen, 0, &skey)) != CRYPT_OK) {
          return err;
       }
       if ((err = camellia_ecb_encrypt(tests[x].pt, buf[0], &skey)) != CRYPT_OK) {

src/ciphers/des.c

@@ -1983,12 +1983,12 @@ int des_test(void)
            return CRYPT_FAIL_TESTVECTOR;
         }
 
-      /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
+        /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
-      for (y = 0; y < 8; y++) tmp[y] = 0;
+        for (y = 0; y < 8; y++) tmp[y] = 0;
-      for (y = 0; y < 1000; y++) des_ecb_encrypt(tmp, tmp, &des);
+        for (y = 0; y < 1000; y++) des_ecb_encrypt(tmp, tmp, &des);
-      for (y = 0; y < 1000; y++) des_ecb_decrypt(tmp, tmp, &des);
+        for (y = 0; y < 1000; y++) des_ecb_decrypt(tmp, tmp, &des);
-      for (y = 0; y < 8; y++) if (tmp[y] != 0) return CRYPT_FAIL_TESTVECTOR;
+        for (y = 0; y < 8; y++) if (tmp[y] != 0) return CRYPT_FAIL_TESTVECTOR;
-}
+    }
 
     return CRYPT_OK;
   #endif

src/ciphers/kseed.c

@@ -201,41 +201,41 @@ static const ulong32 KCi[16] = {
  */
 int kseed_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey)
 {
-    int     i;
+   int     i;
-    ulong32 tmp, k1, k2, k3, k4;
+   ulong32 tmp, k1, k2, k3, k4;
 
-    if (keylen != 16) {
+   if (keylen != 16) {
-       return CRYPT_INVALID_KEYSIZE;
+      return CRYPT_INVALID_KEYSIZE;
-    }
+   }
 
-    if (num_rounds != 16 && num_rounds != 0) {
+   if (num_rounds != 16 && num_rounds != 0) {
-       return CRYPT_INVALID_ROUNDS;
+      return CRYPT_INVALID_ROUNDS;
-    }
+   }
 
-    /* load key */
+   /* load key */
-    LOAD32H(k1, key);
+   LOAD32H(k1, key);
-    LOAD32H(k2, key+4);
+   LOAD32H(k2, key+4);
-    LOAD32H(k3, key+8);
+   LOAD32H(k3, key+8);
-    LOAD32H(k4, key+12);
+   LOAD32H(k4, key+12);
 
-    for (i = 0; i < 16; i++) {
+   for (i = 0; i < 16; i++) {
-       skey->kseed.K[2*i+0] = G(k1 + k3 - KCi[i]);
+      skey->kseed.K[2*i+0] = G(k1 + k3 - KCi[i]);
-       skey->kseed.K[2*i+1] = G(k2 - k4 + KCi[i]);
+      skey->kseed.K[2*i+1] = G(k2 - k4 + KCi[i]);
-       if (i&1) {
+      if (i&1) {
-          tmp = k3;
+         tmp = k3;
-          k3 = ((k3 << 8) | (k4 >> 24)) & 0xFFFFFFFF;
+         k3 = ((k3 << 8) | (k4 >> 24)) & 0xFFFFFFFF;
-          k4 = ((k4 << 8) | (tmp >> 24)) & 0xFFFFFFFF;
+         k4 = ((k4 << 8) | (tmp >> 24)) & 0xFFFFFFFF;
-       } else {
+      } else {
-          tmp = k1;
+         tmp = k1;
-          k1 = ((k1 >> 8) | (k2 << 24)) & 0xFFFFFFFF;
+         k1 = ((k1 >> 8) | (k2 << 24)) & 0xFFFFFFFF;
-          k2 = ((k2 >> 8) | (tmp << 24)) & 0xFFFFFFFF;
+         k2 = ((k2 >> 8) | (tmp << 24)) & 0xFFFFFFFF;
       }
       /* reverse keys for decrypt */
       skey->kseed.dK[2*(15-i)+0] = skey->kseed.K[2*i+0];
       skey->kseed.dK[2*(15-i)+1] = skey->kseed.K[2*i+1];
-    }
+   }
 
-    return CRYPT_OK;
+   return CRYPT_OK;
 }
 
 static void rounds(ulong32 *P, ulong32 *K)

src/ciphers/multi2.c

@@ -96,9 +96,9 @@ static void decrypt(ulong32 *p, int N, ulong32 *uk)
    int n, t;
    for (t = 4*(((N-1)>>2)&1), n = N; ;  ) {
       switch (n<=4 ? n : ((n-1)%4)+1) {
-         case 4: pi4(p, uk+t); --n;
+         case 4: pi4(p, uk+t); --n; /* FALLTHROUGH */
-         case 3: pi3(p, uk+t); --n;
+         case 3: pi3(p, uk+t); --n; /* FALLTHROUGH */
-         case 2: pi2(p, uk+t); --n;
+         case 2: pi2(p, uk+t); --n; /* FALLTHROUGH */
          case 1: pi1(p); --n; break;
          case 0: return;
       }

src/ciphers/noekeon.c

@@ -303,11 +303,11 @@ int noekeon_test(void)
         return CRYPT_FAIL_TESTVECTOR;
     }
 
-      /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
+    /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
-      for (y = 0; y < 16; y++) tmp[0][y] = 0;
+    for (y = 0; y < 16; y++) tmp[0][y] = 0;
-      for (y = 0; y < 1000; y++) noekeon_ecb_encrypt(tmp[0], tmp[0], &key);
+    for (y = 0; y < 1000; y++) noekeon_ecb_encrypt(tmp[0], tmp[0], &key);
-      for (y = 0; y < 1000; y++) noekeon_ecb_decrypt(tmp[0], tmp[0], &key);
+    for (y = 0; y < 1000; y++) noekeon_ecb_decrypt(tmp[0], tmp[0], &key);
-      for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
+    for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
  }
  return CRYPT_OK;
  #endif

src/ciphers/rc2.c

@@ -86,35 +86,35 @@ int rc2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_ke
    }
 
    for (i = 0; i < keylen; i++) {
-       tmp[i] = key[i] & 255;
+      tmp[i] = key[i] & 255;
    }
 
-    /* Phase 1: Expand input key to 128 bytes */
+   /* Phase 1: Expand input key to 128 bytes */
-    if (keylen < 128) {
+   if (keylen < 128) {
-        for (i = keylen; i < 128; i++) {
+      for (i = keylen; i < 128; i++) {
-            tmp[i] = permute[(tmp[i - 1] + tmp[i - keylen]) & 255];
+         tmp[i] = permute[(tmp[i - 1] + tmp[i - keylen]) & 255];
-        }
+      }
-    }
+   }
 
-    /* Phase 2 - reduce effective key size to "bits" */
+   /* Phase 2 - reduce effective key size to "bits" */
-    bits = keylen<<3;
+   bits = keylen<<3;
-    T8   = (unsigned)(bits+7)>>3;
+   T8   = (unsigned)(bits+7)>>3;
-    TM   = (255 >> (unsigned)(7 & -bits));
+   TM   = (255 >> (unsigned)(7 & -bits));
-    tmp[128 - T8] = permute[tmp[128 - T8] & TM];
+   tmp[128 - T8] = permute[tmp[128 - T8] & TM];
-    for (i = 127 - T8; i >= 0; i--) {
+   for (i = 127 - T8; i >= 0; i--) {
-        tmp[i] = permute[tmp[i + 1] ^ tmp[i + T8]];
+      tmp[i] = permute[tmp[i + 1] ^ tmp[i + T8]];
-    }
+   }
 
-    /* Phase 3 - copy to xkey in little-endian order */
+   /* Phase 3 - copy to xkey in little-endian order */
-    for (i = 0; i < 64; i++) {
+   for (i = 0; i < 64; i++) {
-        xkey[i] =  (unsigned)tmp[2*i] + ((unsigned)tmp[2*i+1] << 8);
+      xkey[i] =  (unsigned)tmp[2*i] + ((unsigned)tmp[2*i+1] << 8);
-    }
+   }
 
 #ifdef LTC_CLEAN_STACK
-    zeromem(tmp, sizeof(tmp));
+   zeromem(tmp, sizeof(tmp));
 #endif
 
-    return CRYPT_OK;
+   return CRYPT_OK;
 }
 
 /**********************************************************************\

src/ciphers/safer/safer.c

@@ -432,11 +432,11 @@ int safer_sk64_test(void)
       return CRYPT_FAIL_TESTVECTOR;
    }
 
-      /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
+   /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
-      for (y = 0; y < 8; y++) buf[0][y] = 0;
+   for (y = 0; y < 8; y++) buf[0][y] = 0;
-      for (y = 0; y < 1000; y++) safer_ecb_encrypt(buf[0], buf[0], &skey);
+   for (y = 0; y < 1000; y++) safer_ecb_encrypt(buf[0], buf[0], &skey);
-      for (y = 0; y < 1000; y++) safer_ecb_decrypt(buf[0], buf[0], &skey);
+   for (y = 0; y < 1000; y++) safer_ecb_decrypt(buf[0], buf[0], &skey);
-      for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
+   for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
 
    return CRYPT_OK;
   #endif
@@ -475,12 +475,13 @@ int safer_sk128_test(void)
       return CRYPT_FAIL_TESTVECTOR;
    }
 
-      /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
+   /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
-      for (y = 0; y < 8; y++) buf[0][y] = 0;
+   for (y = 0; y < 8; y++) buf[0][y] = 0;
-      for (y = 0; y < 1000; y++) safer_ecb_encrypt(buf[0], buf[0], &skey);
+   for (y = 0; y < 1000; y++) safer_ecb_encrypt(buf[0], buf[0], &skey);
-      for (y = 0; y < 1000; y++) safer_ecb_decrypt(buf[0], buf[0], &skey);
+   for (y = 0; y < 1000; y++) safer_ecb_decrypt(buf[0], buf[0], &skey);
-      for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
+   for (y = 0; y < 8; y++) if (buf[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
-  return CRYPT_OK;
+
+   return CRYPT_OK;
  #endif
 }
 

src/ciphers/twofish/twofish.c

@@ -245,23 +245,26 @@ static void h_func(const unsigned char *in, unsigned char *out, unsigned char *M
   unsigned char y[4];
   for (x = 0; x < 4; x++) {
       y[x] = in[x];
- }
+  }
   switch (k) {
      case 4:
             y[0] = (unsigned char)(sbox(1, (ulong32)y[0]) ^ M[4 * (6 + offset) + 0]);
             y[1] = (unsigned char)(sbox(0, (ulong32)y[1]) ^ M[4 * (6 + offset) + 1]);
             y[2] = (unsigned char)(sbox(0, (ulong32)y[2]) ^ M[4 * (6 + offset) + 2]);
             y[3] = (unsigned char)(sbox(1, (ulong32)y[3]) ^ M[4 * (6 + offset) + 3]);
+            /* FALLTHROUGH */
      case 3:
             y[0] = (unsigned char)(sbox(1, (ulong32)y[0]) ^ M[4 * (4 + offset) + 0]);
             y[1] = (unsigned char)(sbox(1, (ulong32)y[1]) ^ M[4 * (4 + offset) + 1]);
             y[2] = (unsigned char)(sbox(0, (ulong32)y[2]) ^ M[4 * (4 + offset) + 2]);
             y[3] = (unsigned char)(sbox(0, (ulong32)y[3]) ^ M[4 * (4 + offset) + 3]);
+            /* FALLTHROUGH */
      case 2:
             y[0] = (unsigned char)(sbox(1, sbox(0, sbox(0, (ulong32)y[0]) ^ M[4 * (2 + offset) + 0]) ^ M[4 * (0 + offset) + 0]));
             y[1] = (unsigned char)(sbox(0, sbox(0, sbox(1, (ulong32)y[1]) ^ M[4 * (2 + offset) + 1]) ^ M[4 * (0 + offset) + 1]));
             y[2] = (unsigned char)(sbox(1, sbox(1, sbox(0, (ulong32)y[2]) ^ M[4 * (2 + offset) + 2]) ^ M[4 * (0 + offset) + 2]));
             y[3] = (unsigned char)(sbox(0, sbox(1, sbox(1, (ulong32)y[3]) ^ M[4 * (2 + offset) + 3]) ^ M[4 * (0 + offset) + 3]));
+            /* FALLTHROUGH */
   }
   mds_mult(y, out);
 }
@@ -504,7 +507,7 @@ int twofish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_ke
         a  = RORc(a ^ (t1 + k[2]), 1);
         b  = ROLc(b, 1) ^ (t2 + t1 + k[3]);
         k += 4;
-   }
+    }
 
     /* output with "undo last swap" */
     ta = c ^ skey->twofish.K[4];
@@ -646,11 +649,11 @@ int twofish_test(void)
 };
 
 
- symmetric_key key;
+  symmetric_key key;
- unsigned char tmp[2][16];
+  unsigned char tmp[2][16];
- int err, i, y;
+  int err, i, y;
 
- for (i = 0; i < (int)(sizeof(tests)/sizeof(tests[0])); i++) {
+  for (i = 0; i < (int)(sizeof(tests)/sizeof(tests[0])); i++) {
     if ((err = twofish_setup(tests[i].key, tests[i].keylen, 0, &key)) != CRYPT_OK) {
        return err;
     }
@@ -662,13 +665,13 @@ int twofish_test(void)
 #endif
        return CRYPT_FAIL_TESTVECTOR;
     }
-      /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
+    /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */
-      for (y = 0; y < 16; y++) tmp[0][y] = 0;
+    for (y = 0; y < 16; y++) tmp[0][y] = 0;
-      for (y = 0; y < 1000; y++) twofish_ecb_encrypt(tmp[0], tmp[0], &key);
+    for (y = 0; y < 1000; y++) twofish_ecb_encrypt(tmp[0], tmp[0], &key);
-      for (y = 0; y < 1000; y++) twofish_ecb_decrypt(tmp[0], tmp[0], &key);
+    for (y = 0; y < 1000; y++) twofish_ecb_decrypt(tmp[0], tmp[0], &key);
-      for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
+    for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR;
- }
+  }
- return CRYPT_OK;
+  return CRYPT_OK;
 #endif
 }
 

src/encauth/ccm/ccm_add_nonce.c

@@ -42,8 +42,8 @@ int ccm_add_nonce(ccm_state *ccm,
    /* form B_0 == flags | Nonce N | l(m) */
    x = 0;
    ccm->PAD[x++] = (unsigned char)(((ccm->aadlen > 0) ? (1<<6) : 0) |
-		   (((ccm->taglen - 2)>>1)<<3)        |
+                   (((ccm->taglen - 2)>>1)<<3)        |
-		   (ccm->L-1));
+                   (ccm->L-1));
 
    /* nonce */
    for (y = 0; y < (16 - (ccm->L + 1)); y++) {

src/encauth/ccm/ccm_memory.c

@@ -283,8 +283,8 @@ int ccm_memory(int cipher,
                    goto error;
                 }
              }
-         }
+          }
-     }
+      }
 #endif
 
       for (; y < ptlen; y++) {

src/encauth/ccm/ccm_test.c

@@ -118,7 +118,7 @@ int ccm_test(void)
   int           err, idx;
   symmetric_key skey;
   ccm_state ccm;
-  
+
   zeromem(zero, 64);
 
   idx = find_cipher("aes");
@@ -190,9 +190,9 @@ int ccm_test(void)
       }
 
       if (y == 0) {
-          XMEMCPY(tag3, tests[x].tag, tests[x].taglen);
+         XMEMCPY(tag3, tests[x].tag, tests[x].taglen);
-          taglen = tests[x].taglen;
+         taglen = tests[x].taglen;
-          if ((err = ccm_memory(idx,
+         if ((err = ccm_memory(idx,
                                tests[x].key, 16,
                                NULL,
                                tests[x].nonce, tests[x].noncelen,

src/encauth/eax/eax_addheader.c

@@ -8,22 +8,22 @@
  *
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
-/** 
+/**
     @file eax_addheader.c
-    EAX implementation, add meta-data, by Tom St Denis 
+    EAX implementation, add meta-data, by Tom St Denis
 */
 #include "tomcrypt.h"
 
 #ifdef LTC_EAX_MODE
 
-/** 
+/**
-    add header (metadata) to the stream 
+    add header (metadata) to the stream
     @param eax    The current EAX state
     @param header The header (meta-data) data you wish to add to the state
     @param length The length of the header data
     @return CRYPT_OK if successful
 */
-int eax_addheader(eax_state *eax, const unsigned char *header, 
+int eax_addheader(eax_state *eax, const unsigned char *header,
                   unsigned long length)
 {
    LTC_ARGCHK(eax    != NULL);

src/encauth/eax/eax_decrypt.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
     @file eax_decrypt.c
     EAX implementation, decrypt block, by Tom St Denis
 */
@@ -17,7 +17,7 @@
 
 #ifdef LTC_EAX_MODE
 
-/**  
+/**
    Decrypt data with the EAX protocol
    @param eax     The EAX state
    @param ct      The ciphertext
@@ -25,11 +25,11 @@
    @param length  The length (octets) of the ciphertext
    @return CRYPT_OK if successful
 */
-int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, 
+int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt,
                 unsigned long length)
 {
    int err;
-   
+
    LTC_ARGCHK(eax != NULL);
    LTC_ARGCHK(pt  != NULL);
    LTC_ARGCHK(ct  != NULL);

src/encauth/eax/eax_decrypt_verify_memory.c

@@ -77,7 +77,7 @@ int eax_decrypt_verify_memory(int cipher,
    if ((err = eax_decrypt(eax, ct, pt, ctlen)) != CRYPT_OK) {
       goto LBL_ERR;
    }
- 
+
    buflen = taglen;
    if ((err = eax_done(eax, buf, &buflen)) != CRYPT_OK) {
       goto LBL_ERR;
@@ -87,7 +87,7 @@ int eax_decrypt_verify_memory(int cipher,
    if (buflen >= taglen && XMEMCMP(buf, tag, taglen) == 0) {
       *stat = 1;
    }
-   
+
    err = CRYPT_OK;
 LBL_ERR:
 #ifdef LTC_CLEAN_STACK

src/encauth/eax/eax_done.c

@@ -51,7 +51,7 @@ int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen)
    /* finish ctomac */
    len = MAXBLOCKSIZE;
    if ((err = omac_done(&eax->ctomac, ctmac, &len)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* finish headeromac */
@@ -59,7 +59,7 @@ int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen)
    /* note we specifically don't reset len so the two lens are minimal */
 
    if ((err = omac_done(&eax->headeromac, headermac, &len)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* terminate the CTR chain */

src/encauth/eax/eax_encrypt.c

@@ -11,7 +11,7 @@
 
 /**
    @file eax_encrypt.c
-   EAX implementation, encrypt block by Tom St Denis 
+   EAX implementation, encrypt block by Tom St Denis
 */
 #include "tomcrypt.h"
 
@@ -25,11 +25,11 @@
    @param length     The length of the plaintext (octets)
    @return CRYPT_OK if successful
 */
-int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, 
+int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct,
                 unsigned long length)
 {
    int err;
-   
+
    LTC_ARGCHK(eax != NULL);
    LTC_ARGCHK(pt  != NULL);
    LTC_ARGCHK(ct  != NULL);

src/encauth/eax/eax_encrypt_authenticate_memory.c

@@ -53,15 +53,15 @@ int eax_encrypt_authenticate_memory(int cipher,
    eax = XMALLOC(sizeof(*eax));
 
    if ((err = eax_init(eax, cipher, key, keylen, nonce, noncelen, header, headerlen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    if ((err = eax_encrypt(eax, pt, ct, ptlen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
- 
+
    if ((err = eax_done(eax, tag, taglen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    err = CRYPT_OK;
@@ -72,7 +72,7 @@ LBL_ERR:
 
    XFREE(eax);
 
-   return err;   
+   return err;
 }
 
 #endif

src/encauth/eax/eax_init.c

@@ -9,15 +9,15 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file eax_init.c
-   EAX implementation, initialized EAX state, by Tom St Denis 
+   EAX implementation, initialized EAX state, by Tom St Denis
 */
 #include "tomcrypt.h"
 
 #ifdef LTC_EAX_MODE
 
-/** 
+/**
    Initialized an EAX state
    @param eax       [out] The EAX state to initialize
    @param cipher    The index of the desired cipher
@@ -29,7 +29,7 @@
    @param headerlen The header length (octets)
    @return CRYPT_OK if successful
 */
-int eax_init(eax_state *eax, int cipher, 
+int eax_init(eax_state *eax, int cipher,
              const unsigned char *key,    unsigned long keylen,
              const unsigned char *nonce,  unsigned long noncelen,
              const unsigned char *header, unsigned long headerlen)
@@ -69,21 +69,21 @@ int eax_init(eax_state *eax, int cipher,
    /* N = LTC_OMAC_0K(nonce) */
    zeromem(buf, MAXBLOCKSIZE);
    if ((err = omac_init(omac, cipher, key, keylen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* omac the [0]_n */
    if ((err = omac_process(omac, buf, blklen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
    /* omac the nonce */
    if ((err = omac_process(omac, nonce, noncelen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
    /* store result */
    len = sizeof(eax->N);
    if ((err = omac_done(omac, eax->N, &len)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* H = LTC_OMAC_1K(header) */
@@ -91,17 +91,17 @@ int eax_init(eax_state *eax, int cipher,
    buf[blklen - 1] = 1;
 
    if ((err = omac_init(&eax->headeromac, cipher, key, keylen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* omac the [1]_n */
    if ((err = omac_process(&eax->headeromac, buf, blklen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
    /* omac the header */
    if (headerlen != 0) {
       if ((err = omac_process(&eax->headeromac, header, headerlen)) != CRYPT_OK) {
-          goto LBL_ERR; 
+          goto LBL_ERR;
       }
    }
 
@@ -109,19 +109,19 @@ int eax_init(eax_state *eax, int cipher,
 
    /* setup the CTR mode */
    if ((err = ctr_start(cipher, eax->N, key, keylen, 0, CTR_COUNTER_BIG_ENDIAN, &eax->ctr)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* setup the LTC_OMAC for the ciphertext */
-   if ((err = omac_init(&eax->ctomac, cipher, key, keylen)) != CRYPT_OK) { 
+   if ((err = omac_init(&eax->ctomac, cipher, key, keylen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    /* omac [2]_n */
    zeromem(buf, MAXBLOCKSIZE);
    buf[blklen-1] = 2;
    if ((err = omac_process(&eax->ctomac, buf, blklen)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    err = CRYPT_OK;
@@ -137,7 +137,7 @@ LBL_ERR:
    return err;
 }
 
-#endif 
+#endif
 
 /* $Source$ */
 /* $Revision$ */

src/encauth/eax/eax_test.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
     @file eax_test.c
     EAX implementation, self-test, by Tom St Denis
 */
@@ -27,16 +27,16 @@ int eax_test(void)
    return CRYPT_NOP;
 #else
    static const struct {
-       int               keylen, 
+       int               keylen,
-                       noncelen, 
+                       noncelen,
-                      headerlen, 
+                      headerlen,
                          msglen;
 
-       unsigned char        key[MAXBLOCKSIZE], 
+       unsigned char        key[MAXBLOCKSIZE],
-                          nonce[MAXBLOCKSIZE], 
+                          nonce[MAXBLOCKSIZE],
-                         header[MAXBLOCKSIZE], 
+                         header[MAXBLOCKSIZE],
                       plaintext[MAXBLOCKSIZE],
-                     ciphertext[MAXBLOCKSIZE], 
+                     ciphertext[MAXBLOCKSIZE],
                             tag[MAXBLOCKSIZE];
    } tests[] = {
 
@@ -107,7 +107,7 @@ int eax_test(void)
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
    /* nonce */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },  
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
    /* header */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -134,7 +134,7 @@ int eax_test(void)
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
    /* nonce */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e },  
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e },
    /* header */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d },
@@ -176,7 +176,7 @@ int eax_test(void)
 
 {
    16, 16, 8, 2,
-   /* key */ 
+   /* key */
    { 0x91, 0x94, 0x5d, 0x3f, 0x4d, 0xcb, 0xee, 0x0b,
      0xf4, 0x5e, 0xf5, 0x22, 0x55, 0xf0, 0x95, 0xa4 },
    /* nonce */
@@ -210,14 +210,14 @@ int eax_test(void)
    /* Tag */
    { 0x3a, 0x59, 0xf2, 0x38, 0xa2, 0x3e, 0x39, 0x19,
      0x9d, 0xc9, 0x26, 0x66, 0x26, 0xc4, 0x0f, 0x80 }
-}   
+}
 
 };
    int err, x, idx, res;
    unsigned long len;
    unsigned char outct[MAXBLOCKSIZE], outtag[MAXBLOCKSIZE];
 
-    /* AES can be under rijndael or aes... try to find it */ 
+    /* AES can be under rijndael or aes... try to find it */
     if ((idx = find_cipher("aes")) == -1) {
        if ((idx = find_cipher("rijndael")) == -1) {
           return CRYPT_NOP;
@@ -270,8 +270,8 @@ int eax_test(void)
            return CRYPT_FAIL_TESTVECTOR;
         }
 
-     }
+    }
-     return CRYPT_OK;
+    return CRYPT_OK;
 #endif /* LTC_TEST */
 }
 

src/encauth/gcm/gcm_add_aad.c

@@ -104,9 +104,9 @@ int gcm_add_aad(gcm_state *gcm,
 
    /* start adding AAD data to the state */
    for (; x < adatalen; x++) {
-       gcm->X[gcm->buflen++] ^= *adata++;
+      gcm->X[gcm->buflen++] ^= *adata++;
 
-       if (gcm->buflen == 16) {
+      if (gcm->buflen == 16) {
          /* GF mult it */
          gcm_mult_h(gcm, gcm->X);
          gcm->buflen = 0;

src/encauth/gcm/gcm_add_iv.c

@@ -72,7 +72,7 @@ int gcm_add_iv(gcm_state *gcm,
    for (; x < IVlen; x++) {
        gcm->buf[gcm->buflen++] = *IV++;
 
-       if (gcm->buflen == 16) {
+      if (gcm->buflen == 16) {
          /* GF mult it */
          for (y = 0; y < 16; y++) {
              gcm->X[y] ^= gcm->buf[y];

src/encauth/gcm/gcm_done.c

@@ -24,7 +24,7 @@
   @param taglen  [in/out]  The length of the MAC tag
   @return CRYPT_OK on success
  */
-int gcm_done(gcm_state *gcm, 
+int gcm_done(gcm_state *gcm,
                      unsigned char *tag,    unsigned long *taglen)
 {
    unsigned long x;

src/encauth/gcm/gcm_gf_mult.c

@@ -17,7 +17,7 @@
 
 #if defined(LTC_GCM_TABLES) || defined(LTC_LRW_TABLES) || ((defined(LTC_GCM_MODE) || defined(LTC_GCM_MODE)) && defined(LTC_FAST))
 
-/* this is x*2^128 mod p(x) ... the results are 16 bytes each stored in a packed format.  Since only the 
+/* this is x*2^128 mod p(x) ... the results are 16 bytes each stored in a packed format.  Since only the
  * lower 16 bits are not zero'ed I removed the upper 14 bytes */
 const unsigned char gcm_shift_table[256*2] = {
 0x00, 0x00, 0x01, 0xc2, 0x03, 0x84, 0x02, 0x46, 0x07, 0x08, 0x06, 0xca, 0x04, 0x8c, 0x05, 0x4e,
@@ -73,13 +73,13 @@ static void gcm_rightshift(unsigned char *a)
 static const unsigned char mask[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
 static const unsigned char poly[] = { 0x00, 0xE1 };
 
-     
+
 /**
   GCM GF multiplier (internal use only)  bitserial
   @param a   First value
   @param b   Second value
   @param c   Destination for a * b
- */  
+ */
 void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *c)
 {
    unsigned char Z[16], V[16];
@@ -90,7 +90,7 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
    for (x = 0; x < 128; x++) {
        if (b[x>>3] & mask[x&7]) {
           for (y = 0; y < 16; y++) {
-              Z[y] ^= V[y]; 
+              Z[y] ^= V[y];
           }
        }
        z     = V[15] & 0x01;
@@ -113,7 +113,7 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
   @param a   First value
   @param b   Second value
   @param c   Destination for a * b
- */  
+ */
 void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *c)
 {
    int i, j, k, u;
@@ -129,7 +129,7 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
        LOAD32H(B[M(1)][i], a + (i<<2));
        LOAD32L(pB[i],      b + (i<<2));
    }
-#else 
+#else
    for (i = 0; i < 2; i++) {
        LOAD64H(B[M(1)][i], a + (i<<3));
        LOAD64L(pB[i],      b + (i<<3));
@@ -154,7 +154,7 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
       B[M(9)][i]  = B[M(1)][i] ^ B[M(8)][i];
       B[M(10)][i] = B[M(2)][i] ^ B[M(8)][i];
       B[M(12)][i] = B[M(8)][i] ^ B[M(4)][i];
-   
+
    /*  now all 3 bit values and the only 4 bit value: 7, 11, 13, 14, 15 */
       B[M(7)][i]  = B[M(3)][i] ^ B[M(4)][i];
       B[M(11)][i] = B[M(3)][i] ^ B[M(8)][i];
@@ -193,7 +193,7 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
    for (i = 0; i < 8; i++) {
        STORE32H(tmp[i], pTmp + (i<<2));
    }
-#else 
+#else
    for (i = 0; i < 4; i++) {
        STORE64H(tmp[i], pTmp + (i<<3));
    }
@@ -218,4 +218,4 @@ void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *
 /* $Source$ */
 /* $Revision$ */
 /* $Date$ */
- 
+

src/encauth/gcm/gcm_init.c

@@ -25,7 +25,7 @@
   @param keylen  The length of the secret key
   @return CRYPT_OK on success
  */
-int gcm_init(gcm_state *gcm, int cipher, 
+int gcm_init(gcm_state *gcm, int cipher,
              const unsigned char *key,  int keylen)
 {
    int           err;
@@ -92,8 +92,8 @@ int gcm_init(gcm_state *gcm, int cipher,
          }
          gcm->PC[x][y][0] = gcm_shift_table[t<<1];
          gcm->PC[x][y][1] ^= gcm_shift_table[(t<<1)+1];
-     }
+      }
-  }
+   }
 
 #endif
 

src/encauth/gcm/gcm_memory.c

@@ -22,7 +22,7 @@
   @param cipher            Index of cipher to use
   @param key               The secret key
   @param keylen            The length of the secret key
-  @param IV                The initial vector 
+  @param IV                The initial vector
   @param IVlen             The length of the initial vector
   @param adata             The additional authentication data (header)
   @param adatalen          The length of the adata
@@ -39,7 +39,7 @@ int gcm_memory(      int           cipher,
                const unsigned char *IV,     unsigned long IVlen,
                const unsigned char *adata,  unsigned long adatalen,
                      unsigned char *pt,     unsigned long ptlen,
-                     unsigned char *ct, 
+                     unsigned char *ct,
                      unsigned char *tag,    unsigned long *taglen,
                                int direction)
 {
@@ -50,9 +50,9 @@ int gcm_memory(      int           cipher,
     if ((err = cipher_is_valid(cipher)) != CRYPT_OK) {
        return err;
     }
- 
+
     if (cipher_descriptor[cipher].accel_gcm_memory != NULL) {
-       return 
+       return
          cipher_descriptor[cipher].accel_gcm_memory
                                           (key,   keylen,
                                            IV,    IVlen,

src/encauth/gcm/gcm_process.c

@@ -118,7 +118,7 @@ int gcm_process(gcm_state *gcm,
                 return err;
              }
          }
-     }
+      }
    }
 #endif
 

src/encauth/gcm/gcm_reset.c

@@ -33,7 +33,7 @@ int gcm_reset(gcm_state *gcm)
    gcm->buflen   = 0;
    gcm->totlen   = 0;
    gcm->pttotlen = 0;
-  
+
    return CRYPT_OK;
 }
 

src/encauth/gcm/gcm_test.c

@@ -17,7 +17,7 @@
 
 #ifdef LTC_GCM_MODE
 
-/** 
+/**
   Test the GCM code
   @return CRYPT_OK on success
  */
@@ -100,18 +100,18 @@ int gcm_test(void)
 /* test case #3 */
 {
    /* key */
-   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 
+   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
      0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08, },
    16,
 
    /* PT */
-   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 
+   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
-     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a, 
+     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
-     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, 
+     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
-     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 
+     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
-     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53, 
+     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
-     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, 
+     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
-     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 
+     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
      0xba, 0x63, 0x7b, 0x39, 0x1a, 0xaf, 0xd2, 0x55, },
   64,
 
@@ -120,66 +120,66 @@ int gcm_test(void)
   0,
 
   /* IV */
-  { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, 
+  { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
     0xde, 0xca, 0xf8, 0x88,  },
   12,
- 
+
   /* CT */
-  { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 
+  { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
-    0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c, 
+    0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
-    0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, 
+    0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
-    0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 
+    0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
-    0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, 
+    0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
-    0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, 
+    0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
-    0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, 
+    0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
     0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85, },
 
   /* TAG */
-  { 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6, 
+  { 0x4d, 0x5c, 0x2a, 0xf3, 0x27, 0xcd, 0x64, 0xa6,
     0x2c, 0xf3, 0x5a, 0xbd, 0x2b, 0xa6, 0xfa, 0xb4, }
 },
 
 /* test case #4 */
 {
    /* key */
-   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 
+   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
      0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08, },
    16,
 
    /* PT */
-   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 
+   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
-     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a, 
+     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
-     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, 
+     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
-     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 
+     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
-     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53, 
+     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
-     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, 
+     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
-     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 
+     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
      0xba, 0x63, 0x7b, 0x39,  },
    60,
 
    /* ADATA */
-   { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 
+   { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
-     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 
+     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
      0xab, 0xad, 0xda, 0xd2,  },
    20,
 
    /* IV */
-   { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, 
+   { 0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad,
      0xde, 0xca, 0xf8, 0x88,  },
    12,
 
    /* CT */
-   { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 
+   { 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24,
-     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c, 
+     0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c,
-     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, 
+     0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0,
-     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 
+     0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e,
-     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, 
+     0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c,
-     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, 
+     0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05,
-     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, 
+     0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97,
      0x3d, 0x58, 0xe0, 0x91,  },
 
    /* TAG */
-   { 0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb, 
+   { 0x5b, 0xc9, 0x4f, 0xbc, 0x32, 0x21, 0xa5, 0xdb,
      0x94, 0xfa, 0xe9, 0x5a, 0xe7, 0x12, 0x1a, 0x47, }
 
 },
@@ -187,24 +187,24 @@ int gcm_test(void)
 /* test case #5 */
 {
    /* key */
-   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 
+   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
      0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08, },
    16,
 
    /* PT */
-   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 
+   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
-     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a, 
+     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
-     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, 
+     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
-     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 
+     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
-     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53, 
+     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
-     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, 
+     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
-     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 
+     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
      0xba, 0x63, 0x7b, 0x39,  },
    60,
 
    /* ADATA */
-   { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 
+   { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
-     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 
+     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
      0xab, 0xad, 0xda, 0xd2,  },
    20,
 
@@ -213,112 +213,112 @@ int gcm_test(void)
    8,
 
    /* CT */
-   { 0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a, 
+   { 0x61, 0x35, 0x3b, 0x4c, 0x28, 0x06, 0x93, 0x4a,
-     0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55, 
+     0x77, 0x7f, 0xf5, 0x1f, 0xa2, 0x2a, 0x47, 0x55,
-     0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8, 
+     0x69, 0x9b, 0x2a, 0x71, 0x4f, 0xcd, 0xc6, 0xf8,
-     0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23, 
+     0x37, 0x66, 0xe5, 0xf9, 0x7b, 0x6c, 0x74, 0x23,
-     0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2, 
+     0x73, 0x80, 0x69, 0x00, 0xe4, 0x9f, 0x24, 0xb2,
-     0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42, 
+     0x2b, 0x09, 0x75, 0x44, 0xd4, 0x89, 0x6b, 0x42,
-     0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07, 
+     0x49, 0x89, 0xb5, 0xe1, 0xeb, 0xac, 0x0f, 0x07,
      0xc2, 0x3f, 0x45, 0x98,  },
 
    /* TAG */
-   { 0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85, 
+   { 0x36, 0x12, 0xd2, 0xe7, 0x9e, 0x3b, 0x07, 0x85,
      0x56, 0x1b, 0xe1, 0x4a, 0xac, 0xa2, 0xfc, 0xcb, }
 },
 
 /* test case #6 */
 {
    /* key */
-   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 
+   { 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
      0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08, },
    16,
 
    /* PT */
-   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 
+   { 0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5,
-     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a, 
+     0xa5, 0x59, 0x09, 0xc5, 0xaf, 0xf5, 0x26, 0x9a,
-     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda, 
+     0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
-     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 
+     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72,
-     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53, 
+     0x1c, 0x3c, 0x0c, 0x95, 0x95, 0x68, 0x09, 0x53,
-     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25, 
+     0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
-     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 
+     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57,
      0xba, 0x63, 0x7b, 0x39,  },
    60,
 
    /* ADATA */
-   { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 
+   { 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
-     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 
+     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef,
      0xab, 0xad, 0xda, 0xd2,  },
    20,
 
    /* IV */
-   { 0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5, 
+   { 0x93, 0x13, 0x22, 0x5d, 0xf8, 0x84, 0x06, 0xe5,
-     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa, 
+     0x55, 0x90, 0x9c, 0x5a, 0xff, 0x52, 0x69, 0xaa,
-     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1, 
+     0x6a, 0x7a, 0x95, 0x38, 0x53, 0x4f, 0x7d, 0xa1,
-     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28, 
+     0xe4, 0xc3, 0x03, 0xd2, 0xa3, 0x18, 0xa7, 0x28,
-     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39, 
+     0xc3, 0xc0, 0xc9, 0x51, 0x56, 0x80, 0x95, 0x39,
-     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54, 
+     0xfc, 0xf0, 0xe2, 0x42, 0x9a, 0x6b, 0x52, 0x54,
-     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57, 
+     0x16, 0xae, 0xdb, 0xf5, 0xa0, 0xde, 0x6a, 0x57,
      0xa6, 0x37, 0xb3, 0x9b,  },
    60,
 
    /* CT */
-   { 0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6, 
+   { 0x8c, 0xe2, 0x49, 0x98, 0x62, 0x56, 0x15, 0xb6,
-     0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94, 
+     0x03, 0xa0, 0x33, 0xac, 0xa1, 0x3f, 0xb8, 0x94,
-     0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8, 
+     0xbe, 0x91, 0x12, 0xa5, 0xc3, 0xa2, 0x11, 0xa8,
-     0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7, 
+     0xba, 0x26, 0x2a, 0x3c, 0xca, 0x7e, 0x2c, 0xa7,
-     0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90, 
+     0x01, 0xe4, 0xa9, 0xa4, 0xfb, 0xa4, 0x3c, 0x90,
-     0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f, 
+     0xcc, 0xdc, 0xb2, 0x81, 0xd4, 0x8c, 0x7c, 0x6f,
-     0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03, 
+     0xd6, 0x28, 0x75, 0xd2, 0xac, 0xa4, 0x17, 0x03,
      0x4c, 0x34, 0xae, 0xe5,  },
 
    /* TAG */
-   { 0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa, 
+   { 0x61, 0x9c, 0xc5, 0xae, 0xff, 0xfe, 0x0b, 0xfa,
      0x46, 0x2a, 0xf4, 0x3c, 0x16, 0x99, 0xd0, 0x50, }
 },
 
 /* test case #46 from BG (catches the LTC bug of v1.15) */
 {
    /* key */
-   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+   { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
    16,
 
    /* PT */
-   { 0xa2, 0xaa, 0xb3, 0xad, 0x8b, 0x17, 0xac, 0xdd, 
+   { 0xa2, 0xaa, 0xb3, 0xad, 0x8b, 0x17, 0xac, 0xdd,
-     0xa2, 0x88, 0x42, 0x6c, 0xd7, 0xc4, 0x29, 0xb7, 
+     0xa2, 0x88, 0x42, 0x6c, 0xd7, 0xc4, 0x29, 0xb7,
-     0xca, 0x86, 0xb7, 0xac, 0xa0, 0x58, 0x09, 0xc7, 
+     0xca, 0x86, 0xb7, 0xac, 0xa0, 0x58, 0x09, 0xc7,
      0x0c, 0xe8, 0x2d, 0xb2, 0x57, 0x11, 0xcb, 0x53,
-     0x02, 0xeb, 0x27, 0x43, 0xb0, 0x36, 0xf3, 0xd7, 
+     0x02, 0xeb, 0x27, 0x43, 0xb0, 0x36, 0xf3, 0xd7,
-     0x50, 0xd6, 0xcf, 0x0d, 0xc0, 0xac, 0xb9, 0x29, 
+     0x50, 0xd6, 0xcf, 0x0d, 0xc0, 0xac, 0xb9, 0x29,
-     0x50, 0xd5, 0x46, 0xdb, 0x30, 0x8f, 0x93, 0xb4, 
+     0x50, 0xd5, 0x46, 0xdb, 0x30, 0x8f, 0x93, 0xb4,
      0xff, 0x24, 0x4a, 0xfa, 0x9d, 0xc7, 0x2b, 0xcd,
      0x75, 0x8d, 0x2c },
    67,
 
    /* ADATA */
-   { 0x68, 0x8e, 0x1a, 0xa9, 0x84, 0xde, 0x92, 0x6d, 
+   { 0x68, 0x8e, 0x1a, 0xa9, 0x84, 0xde, 0x92, 0x6d,
      0xc7, 0xb4, 0xc4, 0x7f, 0x44 },
-   13,   
+   13,
 
    /* IV */
-   { 0xb7, 0x21, 0x38, 0xb5, 0xa0, 0x5f, 0xf5, 0x07, 
+   { 0xb7, 0x21, 0x38, 0xb5, 0xa0, 0x5f, 0xf5, 0x07,
      0x0e, 0x8c, 0xd9, 0x41, 0x83, 0xf7, 0x61, 0xd8 },
    16,
 
    /* CT */
-   { 0xcb, 0xc8, 0xd2, 0xf1, 0x54, 0x81, 0xa4, 0xcc, 
+   { 0xcb, 0xc8, 0xd2, 0xf1, 0x54, 0x81, 0xa4, 0xcc,
-     0x7d, 0xd1, 0xe1, 0x9a, 0xaa, 0x83, 0xde, 0x56, 
+     0x7d, 0xd1, 0xe1, 0x9a, 0xaa, 0x83, 0xde, 0x56,
-     0x78, 0x48, 0x3e, 0xc3, 0x59, 0xae, 0x7d, 0xec, 
+     0x78, 0x48, 0x3e, 0xc3, 0x59, 0xae, 0x7d, 0xec,
      0x2a, 0xb8, 0xd5, 0x34, 0xe0, 0x90, 0x6f, 0x4b,
-     0x46, 0x63, 0xfa, 0xff, 0x58, 0xa8, 0xb2, 0xd7, 
+     0x46, 0x63, 0xfa, 0xff, 0x58, 0xa8, 0xb2, 0xd7,
-     0x33, 0xb8, 0x45, 0xee, 0xf7, 0xc9, 0xb3, 0x31, 
+     0x33, 0xb8, 0x45, 0xee, 0xf7, 0xc9, 0xb3, 0x31,
-     0xe9, 0xe1, 0x0e, 0xb2, 0x61, 0x2c, 0x99, 0x5f, 
+     0xe9, 0xe1, 0x0e, 0xb2, 0x61, 0x2c, 0x99, 0x5f,
      0xeb, 0x1a, 0xc1, 0x5a, 0x62, 0x86, 0xcc, 0xe8,
      0xb2, 0x97, 0xa8 },
 
    /* TAG */
-   { 0x8d, 0x2d, 0x2a, 0x93, 0x72, 0x62, 0x6f, 0x6b, 
+   { 0x8d, 0x2d, 0x2a, 0x93, 0x72, 0x62, 0x6f, 0x6b,
      0xee, 0x85, 0x80, 0x27, 0x6a, 0x63, 0x66, 0xbf }
 }
 

src/encauth/ocb/ocb_decrypt.c

@@ -11,7 +11,7 @@
 
 /**
    @file ocb_decrypt.c
-   OCB implementation, decrypt data, by Tom St Denis 
+   OCB implementation, decrypt data, by Tom St Denis
 */
 #include "tomcrypt.h"
 
@@ -38,7 +38,7 @@ int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt)
       return err;
    }
    LTC_ARGCHK(cipher_descriptor[ocb->cipher].ecb_decrypt != NULL);
-   
+
    /* check length */
    if (ocb->block_len != cipher_descriptor[ocb->cipher].block_length) {
       return CRYPT_INVALID_ARG;

src/encauth/ocb/ocb_decrypt_verify_memory.c

@@ -9,9 +9,9 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
   @file ocb_decrypt_verify_memory.c
-  OCB implementation, helper to decrypt block of memory, by Tom St Denis 
+  OCB implementation, helper to decrypt block of memory, by Tom St Denis
 */
 #include "tomcrypt.h"
 
@@ -33,7 +33,7 @@
 */
 int ocb_decrypt_verify_memory(int cipher,
     const unsigned char *key,    unsigned long keylen,
-    const unsigned char *nonce,  
+    const unsigned char *nonce,
     const unsigned char *ct,     unsigned long ctlen,
           unsigned char *pt,
     const unsigned char *tag,    unsigned long taglen,
@@ -56,12 +56,12 @@ int ocb_decrypt_verify_memory(int cipher,
    }
 
    if ((err = ocb_init(ocb, cipher, key, keylen, nonce)) != CRYPT_OK) {
-      goto LBL_ERR; 
+      goto LBL_ERR;
    }
 
    while (ctlen > (unsigned long)ocb->block_len) {
         if ((err = ocb_decrypt(ocb, ct, pt)) != CRYPT_OK) {
-            goto LBL_ERR; 
+            goto LBL_ERR;
         }
         ctlen   -= ocb->block_len;
         pt      += ocb->block_len;
@@ -73,7 +73,7 @@ LBL_ERR:
 #ifdef LTC_CLEAN_STACK
    zeromem(ocb, sizeof(ocb_state));
 #endif
- 
+
    XFREE(ocb);
 
    return err;

src/encauth/ocb/ocb_done_decrypt.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file ocb_done_decrypt.c
    OCB implementation, terminate decryption, by Tom St Denis
 */
@@ -28,9 +28,9 @@
    @param stat    [out] The result of the tag comparison
    @return CRYPT_OK if the process was successful regardless if the tag is valid
 */
-int ocb_done_decrypt(ocb_state *ocb, 
+int ocb_done_decrypt(ocb_state *ocb,
                      const unsigned char *ct,  unsigned long ctlen,
-                           unsigned char *pt, 
+                           unsigned char *pt,
                      const unsigned char *tag, unsigned long taglen, int *stat)
 {
    int err;

src/encauth/ocb/ocb_done_encrypt.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file ocb_done_encrypt.c
    OCB implementation, terminate encryption, by Tom St Denis
 */
@@ -17,7 +17,7 @@
 
 #ifdef LTC_OCB_MODE
 
-/** 
+/**
    Terminate an encryption OCB state
    @param ocb       The OCB state
    @param pt        Remaining plaintext (if any)

src/encauth/ocb/ocb_encrypt.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file ocb_encrypt.c
    OCB implementation, encrypt data, by Tom St Denis
 */

src/encauth/ocb/ocb_encrypt_authenticate_memory.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
   @file ocb_encrypt_authenticate_memory.c
   OCB implementation, encrypt block of memory, by Tom St Denis
 */
@@ -32,7 +32,7 @@
 */
 int ocb_encrypt_authenticate_memory(int cipher,
     const unsigned char *key,    unsigned long keylen,
-    const unsigned char *nonce,  
+    const unsigned char *nonce,
     const unsigned char *pt,     unsigned long ptlen,
           unsigned char *ct,
           unsigned char *tag,    unsigned long *taglen)

src/encauth/ocb/ocb_init.c

@@ -19,7 +19,7 @@
 
 static const struct {
     int           len;
-    unsigned char poly_div[MAXBLOCKSIZE], 
+    unsigned char poly_div[MAXBLOCKSIZE],
                   poly_mul[MAXBLOCKSIZE];
 } polys[] = {
 {
@@ -27,7 +27,7 @@ static const struct {
     { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D },
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B }
 }, {
-    16, 
+    16,
     { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43 },
     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -44,7 +44,7 @@ static const struct {
   @param nonce   The session nonce (length of the block size of the cipher)
   @return CRYPT_OK if successful
 */
-int ocb_init(ocb_state *ocb, int cipher, 
+int ocb_init(ocb_state *ocb, int cipher,
              const unsigned char *key, unsigned long keylen, const unsigned char *nonce)
 {
    int poly, x, y, m, err;
@@ -62,7 +62,7 @@ int ocb_init(ocb_state *ocb, int cipher,
    ocb->block_len = cipher_descriptor[cipher].block_length;
    x = (int)(sizeof(polys)/sizeof(polys[0]));
    for (poly = 0; poly < x; poly++) {
-       if (polys[poly].len == ocb->block_len) { 
+       if (polys[poly].len == ocb->block_len) {
           break;
        }
    }
@@ -71,13 +71,13 @@ int ocb_init(ocb_state *ocb, int cipher,
    }
    if (polys[poly].len != ocb->block_len) {
       return CRYPT_INVALID_ARG;
-   }   
+   }
 
    /* schedule the key */
    if ((err = cipher_descriptor[cipher].setup(key, keylen, 0, &ocb->key)) != CRYPT_OK) {
       return err;
    }
- 
+
    /* find L = E[0] */
    zeromem(ocb->L, ocb->block_len);
    if ((err = cipher_descriptor[cipher].ecb_encrypt(ocb->L, ocb->L, &ocb->key)) != CRYPT_OK) {
@@ -106,32 +106,32 @@ int ocb_init(ocb_state *ocb, int cipher,
               ocb->Ls[x][y] ^= polys[poly].poly_mul[y];
           }
        }
-    }
+   }
 
-    /* find Lr = L / x */
+   /* find Lr = L / x */
-    m = ocb->L[ocb->block_len-1] & 1;
+   m = ocb->L[ocb->block_len-1] & 1;
 
-    /* shift right */
+   /* shift right */
-    for (x = ocb->block_len - 1; x > 0; x--) {
+   for (x = ocb->block_len - 1; x > 0; x--) {
-        ocb->Lr[x] = ((ocb->L[x] >> 1) | (ocb->L[x-1] << 7)) & 255;
+      ocb->Lr[x] = ((ocb->L[x] >> 1) | (ocb->L[x-1] << 7)) & 255;
-    }
+   }
-    ocb->Lr[0] = ocb->L[0] >> 1;
+   ocb->Lr[0] = ocb->L[0] >> 1;
 
-    if (m == 1) {
+   if (m == 1) {
-       for (x = 0; x < ocb->block_len; x++) {
+      for (x = 0; x < ocb->block_len; x++) {
-           ocb->Lr[x] ^= polys[poly].poly_div[x];
+         ocb->Lr[x] ^= polys[poly].poly_div[x];
-       }
+      }
-    }
+   }
 
-    /* set Li, checksum */
+   /* set Li, checksum */
-    zeromem(ocb->Li,       ocb->block_len);
+   zeromem(ocb->Li,       ocb->block_len);
-    zeromem(ocb->checksum, ocb->block_len);
+   zeromem(ocb->checksum, ocb->block_len);
 
-    /* set other params */
+   /* set other params */
-    ocb->block_index = 1;
+   ocb->block_index = 1;
-    ocb->cipher      = cipher;
+   ocb->cipher      = cipher;
 
-    return CRYPT_OK;
+   return CRYPT_OK;
 }
 
 #endif

src/encauth/ocb/ocb_shift_xor.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file ocb_shift_xor.c
    OCB implementation, internal function, by Tom St Denis
 */
@@ -19,7 +19,7 @@
 
 /**
    Compute the shift/xor for OCB (internal function)
-   @param ocb  The OCB state 
+   @param ocb  The OCB state
    @param Z    The destination of the shift
 */
 void ocb_shift_xor(ocb_state *ocb, unsigned char *Z)

src/encauth/ocb/ocb_test.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file ocb_test.c
    OCB implementation, self-test by Tom St Denis
 */
@@ -17,7 +17,7 @@
 
 #ifdef LTC_OCB_MODE
 
-/** 
+/**
   Test the OCB protocol
   @return   CRYPT_OK if successful
 */
@@ -52,7 +52,7 @@ int ocb_test(void)
 
    /* OCB-AES-128-3B */
 {
-   3, 
+   3,
    /* key */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -70,7 +70,7 @@ int ocb_test(void)
 
    /* OCB-AES-128-16B */
 {
-   16, 
+   16,
    /* key */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -90,7 +90,7 @@ int ocb_test(void)
 
    /* OCB-AES-128-20B  */
 {
-   20, 
+   20,
    /* key */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -99,7 +99,7 @@ int ocb_test(void)
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
    /* pt */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13 },
    /* ct */
    { 0x01, 0xa0, 0x75, 0xf0, 0xd8, 0x15, 0xb1, 0xa4,
@@ -112,7 +112,7 @@ int ocb_test(void)
 
    /* OCB-AES-128-32B  */
 {
-   32, 
+   32,
    /* key */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -121,7 +121,7 @@ int ocb_test(void)
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
    /* pt */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
    /* ct */
@@ -137,7 +137,7 @@ int ocb_test(void)
 
    /* OCB-AES-128-34B  */
 {
-   34, 
+   34,
    /* key */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
@@ -146,7 +146,7 @@ int ocb_test(void)
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
    /* pt */
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
      0x20, 0x21 },
@@ -168,7 +168,7 @@ int ocb_test(void)
    unsigned long len;
    unsigned char outct[MAXBLOCKSIZE], outtag[MAXBLOCKSIZE];
 
-    /* AES can be under rijndael or aes... try to find it */ 
+    /* AES can be under rijndael or aes... try to find it */
     if ((idx = find_cipher("aes")) == -1) {
        if ((idx = find_cipher("rijndael")) == -1) {
           return CRYPT_NOP;
@@ -181,7 +181,7 @@ int ocb_test(void)
              tests[x].nonce, tests[x].pt, tests[x].ptlen, outct, outtag, &len)) != CRYPT_OK) {
            return err;
         }
-        
+
         if (XMEMCMP(outtag, tests[x].tag, len) || XMEMCMP(outct, tests[x].ct, tests[x].ptlen)) {
 #if 0
            unsigned long y;
@@ -200,7 +200,7 @@ int ocb_test(void)
 #endif
            return CRYPT_FAIL_TESTVECTOR;
         }
-        
+
         if ((err = ocb_decrypt_verify_memory(idx, tests[x].key, 16, tests[x].nonce, outct, tests[x].ptlen,
              outct, tests[x].tag, len, &res)) != CRYPT_OK) {
            return err;

src/encauth/ocb/s_ocb_done.c

@@ -9,7 +9,7 @@
  * Tom St Denis, tomstdenis@gmail.com, http://libtom.org
  */
 
-/** 
+/**
    @file s_ocb_done.c
    OCB implementation, internal helper, by Tom St Denis
 */
@@ -22,7 +22,7 @@
  * is we XOR the final ciphertext into the checksum so we have to xor it
  * before we CTR [decrypt] or after [encrypt]
  *
- * the names pt/ptlen/ct really just mean in/inlen/out but this is the way I wrote it... 
+ * the names pt/ptlen/ct really just mean in/inlen/out but this is the way I wrote it...
  */
 
 /**
@@ -74,13 +74,13 @@ int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
    }
 
    /* compute X[m] = len(pt[m]) XOR Lr XOR Z[m] */
-   ocb_shift_xor(ocb, X); 
+   ocb_shift_xor(ocb, X);
    XMEMCPY(Z, X, ocb->block_len);
 
    X[ocb->block_len-1] ^= (ptlen*8)&255;
    X[ocb->block_len-2] ^= ((ptlen*8)>>8)&255;
    for (x = 0; x < ocb->block_len; x++) {
-       X[x] ^= ocb->Lr[x]; 
+       X[x] ^= ocb->Lr[x];
    }
 
    /* Y[m] = E(X[m])) */
@@ -93,7 +93,7 @@ int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
       /* xor C[m] into checksum */
       for (x = 0; x < (int)ptlen; x++) {
          ocb->checksum[x] ^= ct[x];
-      }  
+      }
    }
 
    /* C[m] = P[m] xor Y[m] */
@@ -102,7 +102,7 @@ int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
    }
 
    if (mode == 0) {
-      /* encrypt mode */    
+      /* encrypt mode */
       /* xor C[m] into checksum */
       for (x = 0; x < (int)ptlen; x++) {
           ocb->checksum[x] ^= ct[x];
@@ -113,7 +113,7 @@ int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
    for (x = 0; x < ocb->block_len; x++) {
        ocb->checksum[x] ^= Y[x] ^ Z[x];
    }
-   
+
    /* encrypt checksum, er... tag!! */
    if ((err = cipher_descriptor[ocb->cipher].ecb_encrypt(ocb->checksum, X, &ocb->key)) != CRYPT_OK) {
       goto error;
@@ -132,7 +132,7 @@ int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
    zeromem(Z, MAXBLOCKSIZE);
    zeromem(ocb, sizeof(*ocb));
 #endif
-error:   
+error:
    XFREE(X);
    XFREE(Y);
    XFREE(Z);

src/encauth/ocb3/ocb3_init.c

@@ -90,45 +90,45 @@ int ocb3_init(ocb3_state *ocb, int cipher,
 
    /* compute L_$, L_0, L_1, ... */
    for (x = -1; x < 32; x++) {
-       if (x == -1) {                /* gonna compute: L_$ = double(L_*) */
+      if (x == -1) {                /* gonna compute: L_$ = double(L_*) */
          current  = ocb->L_dollar;
          previous = ocb->L_star;
-       }
+      }
-       else if (x == 0) {            /* gonna compute: L_0 = double(L_$) */
+      else if (x == 0) {            /* gonna compute: L_0 = double(L_$) */
          current  = ocb->L_[0];
          previous = ocb->L_dollar;
-       }
+      }
-       else {                        /* gonna compute: L_i = double(L_{i-1}) for every integer i > 0 */
+      else {                        /* gonna compute: L_i = double(L_{i-1}) for every integer i > 0 */
          current  = ocb->L_[x];
          previous = ocb->L_[x-1];
-       }
+      }
-       m = previous[0] >> 7;
+      m = previous[0] >> 7;
-       for (y = 0; y < ocb->block_len-1; y++) {
+      for (y = 0; y < ocb->block_len-1; y++) {
-           current[y] = ((previous[y] << 1) | (previous[y+1] >> 7)) & 255;
+         current[y] = ((previous[y] << 1) | (previous[y+1] >> 7)) & 255;
-       }
+      }
-       current[ocb->block_len-1] = (previous[ocb->block_len-1] << 1) & 255;
+      current[ocb->block_len-1] = (previous[ocb->block_len-1] << 1) & 255;
-       if (m == 1) {
+      if (m == 1) {
-          /* current[] = current[] XOR polys[poly].poly_mul[]*/
+         /* current[] = current[] XOR polys[poly].poly_mul[]*/
-          ocb3_int_xor_blocks(current, current, polys[poly].poly_mul, ocb->block_len);
+         ocb3_int_xor_blocks(current, current, polys[poly].poly_mul, ocb->block_len);
-       }
+      }
-    }
+   }
 
-    /* initialize ocb->Offset_current = Offset_0 */
+   /* initialize ocb->Offset_current = Offset_0 */
-    ocb3_int_calc_offset_zero(ocb, nonce, noncelen);
+   ocb3_int_calc_offset_zero(ocb, nonce, noncelen);
 
-    /* initialize checksum to all zeros */
+   /* initialize checksum to all zeros */
-    zeromem(ocb->checksum, ocb->block_len);
+   zeromem(ocb->checksum, ocb->block_len);
 
-    /* set block index */
+   /* set block index */
-    ocb->block_index = 1;
+   ocb->block_index = 1;
 
-    /* initialize AAD related stuff */
+   /* initialize AAD related stuff */
-    ocb->ablock_index = 1;
+   ocb->ablock_index = 1;
-    ocb->adata_buffer_bytes = 0;
+   ocb->adata_buffer_bytes = 0;
-    zeromem(ocb->aOffset_current, ocb->block_len);
+   zeromem(ocb->aOffset_current, ocb->block_len);
-    zeromem(ocb->aSum_current, ocb->block_len);
+   zeromem(ocb->aSum_current, ocb->block_len);
 
-    return CRYPT_OK;
+   return CRYPT_OK;
 }
 
 #endif

src/encauth/ocb3/ocb3_test.c

@@ -35,134 +35,134 @@ int ocb3_test(void)
          unsigned char pt[64], aad[64], ct[64], tag[16];
    } tests[] = {
 
-	{ /* index:0 */
+   { /* index:0 */
-	  0, /* PLAINTEXT length */
+     0, /* PLAINTEXT length */
-	  0, /* AAD length */
+     0, /* AAD length */
-	  {  }, /* PLAINTEXT */
+     {  }, /* PLAINTEXT */
-	  {  }, /* AAD */
+     {  }, /* AAD */
-	  {  }, /* CIPHERTEXT */
+     {  }, /* CIPHERTEXT */
-	  { 0x19,0x7b,0x9c,0x3c,0x44,0x1d,0x3c,0x83,0xea,0xfb,0x2b,0xef,0x63,0x3b,0x91,0x82 }, /* TAG */
+     { 0x19,0x7b,0x9c,0x3c,0x44,0x1d,0x3c,0x83,0xea,0xfb,0x2b,0xef,0x63,0x3b,0x91,0x82 }, /* TAG */
-	},
+   },
-	{ /* index:1 */
+   { /* index:1 */
-	  8, /* PLAINTEXT length */
+     8, /* PLAINTEXT length */
-	  8, /* AAD length */
+     8, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* AAD */
-	  { 0x92,0xb6,0x57,0x13,0x0a,0x74,0xb8,0x5a }, /* CIPHERTEXT */
+     { 0x92,0xb6,0x57,0x13,0x0a,0x74,0xb8,0x5a }, /* CIPHERTEXT */
-	  { 0x16,0xdc,0x76,0xa4,0x6d,0x47,0xe1,0xea,0xd5,0x37,0x20,0x9e,0x8a,0x96,0xd1,0x4e }, /* TAG */
+     { 0x16,0xdc,0x76,0xa4,0x6d,0x47,0xe1,0xea,0xd5,0x37,0x20,0x9e,0x8a,0x96,0xd1,0x4e }, /* TAG */
-	},
+   },
-	{ /* index:2 */
+   { /* index:2 */
-	  0, /* PLAINTEXT length */
+     0, /* PLAINTEXT length */
-	  8, /* AAD length */
+     8, /* AAD length */
-	  {  }, /* PLAINTEXT */
+     {  }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* AAD */
-	  {  }, /* CIPHERTEXT */
+     {  }, /* CIPHERTEXT */
-	  { 0x98,0xb9,0x15,0x52,0xc8,0xc0,0x09,0x18,0x50,0x44,0xe3,0x0a,0x6e,0xb2,0xfe,0x21 }, /* TAG */
+     { 0x98,0xb9,0x15,0x52,0xc8,0xc0,0x09,0x18,0x50,0x44,0xe3,0x0a,0x6e,0xb2,0xfe,0x21 }, /* TAG */
-	},
+   },
-	{ /* index:3 */
+   { /* index:3 */
-	  8, /* PLAINTEXT length */
+     8, /* PLAINTEXT length */
-	  0, /* AAD length */
+     0, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, /* PLAINTEXT */
-	  {  }, /* AAD */
+     {  }, /* AAD */
-	  { 0x92,0xb6,0x57,0x13,0x0a,0x74,0xb8,0x5a }, /* CIPHERTEXT */
+     { 0x92,0xb6,0x57,0x13,0x0a,0x74,0xb8,0x5a }, /* CIPHERTEXT */
-	  { 0x97,0x1e,0xff,0xca,0xe1,0x9a,0xd4,0x71,0x6f,0x88,0xe8,0x7b,0x87,0x1f,0xbe,0xed }, /* TAG */
+     { 0x97,0x1e,0xff,0xca,0xe1,0x9a,0xd4,0x71,0x6f,0x88,0xe8,0x7b,0x87,0x1f,0xbe,0xed }, /* TAG */
-	},
+   },
-	{ /* index:4 */
+   { /* index:4 */
-	  16, /* PLAINTEXT length */
+     16, /* PLAINTEXT length */
-	  16, /* AAD length */
+     16, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22 }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22 }, /* CIPHERTEXT */
-	  { 0x77,0x6c,0x99,0x24,0xd6,0x72,0x3a,0x1f,0xc4,0x52,0x45,0x32,0xac,0x3e,0x5b,0xeb }, /* TAG */
+     { 0x77,0x6c,0x99,0x24,0xd6,0x72,0x3a,0x1f,0xc4,0x52,0x45,0x32,0xac,0x3e,0x5b,0xeb }, /* TAG */
-	},
+   },
-	{ /* index:5 */
+   { /* index:5 */
-	  0, /* PLAINTEXT length */
+     0, /* PLAINTEXT length */
-	  16, /* AAD length */
+     16, /* AAD length */
-	  {  }, /* PLAINTEXT */
+     {  }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* AAD */
-	  {  }, /* CIPHERTEXT */
+     {  }, /* CIPHERTEXT */
-	  { 0x7d,0xdb,0x8e,0x6c,0xea,0x68,0x14,0x86,0x62,0x12,0x50,0x96,0x19,0xb1,0x9c,0xc6 }, /* TAG */
+     { 0x7d,0xdb,0x8e,0x6c,0xea,0x68,0x14,0x86,0x62,0x12,0x50,0x96,0x19,0xb1,0x9c,0xc6 }, /* TAG */
-	},
+   },
-	{ /* index:6 */
+   { /* index:6 */
-	  16, /* PLAINTEXT length */
+     16, /* PLAINTEXT length */
-	  0, /* AAD length */
+     0, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }, /* PLAINTEXT */
-	  {  }, /* AAD */
+     {  }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22 }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22 }, /* CIPHERTEXT */
-	  { 0x13,0xcc,0x8b,0x74,0x78,0x07,0x12,0x1a,0x4c,0xbb,0x3e,0x4b,0xd6,0xb4,0x56,0xaf }, /* TAG */
+     { 0x13,0xcc,0x8b,0x74,0x78,0x07,0x12,0x1a,0x4c,0xbb,0x3e,0x4b,0xd6,0xb4,0x56,0xaf }, /* TAG */
-	},
+   },
-	{ /* index:7 */
+   { /* index:7 */
-	  24, /* PLAINTEXT length */
+     24, /* PLAINTEXT length */
-	  24, /* AAD length */
+     24, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xfc,0xfc,0xee,0x7a,0x2a,0x8d,0x4d,0x48 }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xfc,0xfc,0xee,0x7a,0x2a,0x8d,0x4d,0x48 }, /* CIPHERTEXT */
-	  { 0x5f,0xa9,0x4f,0xc3,0xf3,0x88,0x20,0xf1,0xdc,0x3f,0x3d,0x1f,0xd4,0xe5,0x5e,0x1c }, /* TAG */
+     { 0x5f,0xa9,0x4f,0xc3,0xf3,0x88,0x20,0xf1,0xdc,0x3f,0x3d,0x1f,0xd4,0xe5,0x5e,0x1c }, /* TAG */
-	},
+   },
-	{ /* index:8 */
+   { /* index:8 */
-	  0, /* PLAINTEXT length */
+     0, /* PLAINTEXT length */
-	  24, /* AAD length */
+     24, /* AAD length */
-	  {  }, /* PLAINTEXT */
+     {  }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* AAD */
-	  {  }, /* CIPHERTEXT */
+     {  }, /* CIPHERTEXT */
-	  { 0x28,0x20,0x26,0xda,0x30,0x68,0xbc,0x9f,0xa1,0x18,0x68,0x1d,0x55,0x9f,0x10,0xf6 }, /* TAG */
+     { 0x28,0x20,0x26,0xda,0x30,0x68,0xbc,0x9f,0xa1,0x18,0x68,0x1d,0x55,0x9f,0x10,0xf6 }, /* TAG */
-	},
+   },
-	{ /* index:9 */
+   { /* index:9 */
-	  24, /* PLAINTEXT length */
+     24, /* PLAINTEXT length */
-	  0, /* AAD length */
+     0, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17 }, /* PLAINTEXT */
-	  {  }, /* AAD */
+     {  }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xfc,0xfc,0xee,0x7a,0x2a,0x8d,0x4d,0x48 }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xfc,0xfc,0xee,0x7a,0x2a,0x8d,0x4d,0x48 }, /* CIPHERTEXT */
-	  { 0x6e,0xf2,0xf5,0x25,0x87,0xfd,0xa0,0xed,0x97,0xdc,0x7e,0xed,0xe2,0x41,0xdf,0x68 }, /* TAG */
+     { 0x6e,0xf2,0xf5,0x25,0x87,0xfd,0xa0,0xed,0x97,0xdc,0x7e,0xed,0xe2,0x41,0xdf,0x68 }, /* TAG */
-	},
+   },
-	{ /* index:10 */
+   { /* index:10 */
-	  32, /* PLAINTEXT length */
+     32, /* PLAINTEXT length */
-	  32, /* AAD length */
+     32, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb }, /* CIPHERTEXT */
-	  { 0xb2,0xa0,0x40,0xdd,0x3b,0xd5,0x16,0x43,0x72,0xd7,0x6d,0x7b,0xb6,0x82,0x42,0x40 }, /* TAG */
+     { 0xb2,0xa0,0x40,0xdd,0x3b,0xd5,0x16,0x43,0x72,0xd7,0x6d,0x7b,0xb6,0x82,0x42,0x40 }, /* TAG */
-	},
+   },
-	{ /* index:11 */
+   { /* index:11 */
-	  0, /* PLAINTEXT length */
+     0, /* PLAINTEXT length */
-	  32, /* AAD length */
+     32, /* AAD length */
-	  {  }, /* PLAINTEXT */
+     {  }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* AAD */
-	  {  }, /* CIPHERTEXT */
+     {  }, /* CIPHERTEXT */
-	  { 0xe1,0xe0,0x72,0x63,0x3b,0xad,0xe5,0x1a,0x60,0xe8,0x59,0x51,0xd9,0xc4,0x2a,0x1b }, /* TAG */
+     { 0xe1,0xe0,0x72,0x63,0x3b,0xad,0xe5,0x1a,0x60,0xe8,0x59,0x51,0xd9,0xc4,0x2a,0x1b }, /* TAG */
-	},
+   },
-	{ /* index:12 */
+   { /* index:12 */
-	  32, /* PLAINTEXT length */
+     32, /* PLAINTEXT length */
-	  0, /* AAD length */
+     0, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f }, /* PLAINTEXT */
-	  {  }, /* AAD */
+     {  }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb }, /* CIPHERTEXT */
-	  { 0x4a,0x3b,0xae,0x82,0x44,0x65,0xcf,0xda,0xf8,0xc4,0x1f,0xc5,0x0c,0x7d,0xf9,0xd9 }, /* TAG */
+     { 0x4a,0x3b,0xae,0x82,0x44,0x65,0xcf,0xda,0xf8,0xc4,0x1f,0xc5,0x0c,0x7d,0xf9,0xd9 }, /* TAG */
-	},
+   },
-	{ /* index:13 */
+   { /* index:13 */
-	  40, /* PLAINTEXT length */
+     40, /* PLAINTEXT length */
-	  40, /* AAD length */
+     40, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb,0x68,0xc6,0x57,0x78,0xb0,0x58,0xa6,0x35 }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb,0x68,0xc6,0x57,0x78,0xb0,0x58,0xa6,0x35 }, /* CIPHERTEXT */
-	  { 0x65,0x9c,0x62,0x32,0x11,0xde,0xea,0x0d,0xe3,0x0d,0x2c,0x38,0x18,0x79,0xf4,0xc8 }, /* TAG */
+     { 0x65,0x9c,0x62,0x32,0x11,0xde,0xea,0x0d,0xe3,0x0d,0x2c,0x38,0x18,0x79,0xf4,0xc8 }, /* TAG */
-	},
+   },
-	{ /* index:14 */
+   { /* index:14 */
-	  0, /* PLAINTEXT length */
+     0, /* PLAINTEXT length */
-	  40, /* AAD length */
+     40, /* AAD length */
-	  {  }, /* PLAINTEXT */
+     {  }, /* PLAINTEXT */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* AAD */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* AAD */
-	  {  }, /* CIPHERTEXT */
+     {  }, /* CIPHERTEXT */
-	  { 0x7a,0xeb,0x7a,0x69,0xa1,0x68,0x7d,0xd0,0x82,0xca,0x27,0xb0,0xd9,0xa3,0x70,0x96 }, /* TAG */
+     { 0x7a,0xeb,0x7a,0x69,0xa1,0x68,0x7d,0xd0,0x82,0xca,0x27,0xb0,0xd9,0xa3,0x70,0x96 }, /* TAG */
-	},
+   },
-	{ /* index:15 */
+   { /* index:15 */
-	  40, /* PLAINTEXT length */
+     40, /* PLAINTEXT length */
-	  0, /* AAD length */
+     0, /* AAD length */
-	  { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* PLAINTEXT */
+     { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27 }, /* PLAINTEXT */
-	  {  }, /* AAD */
+     {  }, /* AAD */
-	  { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb,0x68,0xc6,0x57,0x78,0xb0,0x58,0xa6,0x35 }, /* CIPHERTEXT */
+     { 0xbe,0xa5,0xe8,0x79,0x8d,0xbe,0x71,0x10,0x03,0x1c,0x14,0x4d,0xa0,0xb2,0x61,0x22,0xce,0xaa,0xb9,0xb0,0x5d,0xf7,0x71,0xa6,0x57,0x14,0x9d,0x53,0x77,0x34,0x63,0xcb,0x68,0xc6,0x57,0x78,0xb0,0x58,0xa6,0x35 }, /* CIPHERTEXT */
-	  { 0x06,0x0c,0x84,0x67,0xf4,0xab,0xab,0x5e,0x8b,0x3c,0x20,0x67,0xa2,0xe1,0x15,0xdc }, /* TAG */
+     { 0x06,0x0c,0x84,0x67,0xf4,0xab,0xab,0x5e,0x8b,0x3c,0x20,0x67,0xa2,0xe1,0x15,0xdc }, /* TAG */
-	},
+   },
 
 };
 

src/hashes/helper/hash_file.c

@@ -11,7 +11,7 @@
 #include "tomcrypt.h"
 
 #ifndef LTC_NO_FILE
-/** 
+/**
   @file hash_file.c
   Hash a file, Tom St Denis
 */
@@ -36,7 +36,7 @@ int hash_file(int hash, const char *fname, unsigned char *out, unsigned long *ou
     }
 
     in = fopen(fname, "rb");
-    if (in == NULL) { 
+    if (in == NULL) {
        return CRYPT_FILE_NOTFOUND;
     }
 

src/hashes/helper/hash_filehandle.c

@@ -16,13 +16,13 @@
    Hash open files, Tom St Denis
 */
 
-/** 
+/**
-  Hash data from an open file handle.  
+  Hash data from an open file handle.
   @param hash   The index of the hash you want to use
   @param in     The FILE* handle of the file you want to hash
   @param out    [out] The destination of the digest
   @param outlen [in/out] The max size and resulting size of the digest
-  @result CRYPT_OK if successful   
+  @result CRYPT_OK if successful
 */
 int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen)
 {

src/hashes/md2.c

@@ -12,7 +12,7 @@
 
 /**
    @param md2.c
-   LTC_MD2 (RFC 1319) hash function implementation by Tom St Denis 
+   LTC_MD2 (RFC 1319) hash function implementation by Tom St Denis
 */
 
 #ifdef LTC_MD2
@@ -64,7 +64,7 @@ static void md2_update_chksum(hash_state *md)
    L = md->md2.chksum[15];
    for (j = 0; j < 16; j++) {
 
-/* caution, the RFC says its "C[j] = S[M[i*16+j] xor L]" but the reference source code [and test vectors] say 
+/* caution, the RFC says its "C[j] = S[M[i*16+j] xor L]" but the reference source code [and test vectors] say
    otherwise.
 */
        L = (md->md2.chksum[j] ^= PI_SUBST[(int)(md->md2.buf[j] ^ L)] & 255);
@@ -75,7 +75,7 @@ static void md2_compress(hash_state *md)
 {
    int j, k;
    unsigned char t;
-   
+
    /* copy block */
    for (j = 0; j < 16; j++) {
        md->md2.X[16+j] = md->md2.buf[j];
@@ -122,9 +122,9 @@ int md2_process(hash_state *md, const unsigned char *in, unsigned long inlen)
     unsigned long n;
     LTC_ARGCHK(md != NULL);
     LTC_ARGCHK(in != NULL);
-    if (md-> md2 .curlen > sizeof(md-> md2 .buf)) {                            
+    if (md-> md2 .curlen > sizeof(md-> md2 .buf)) {
-       return CRYPT_INVALID_ARG;                                                           
+       return CRYPT_INVALID_ARG;
-    }                                                                                       
+    }
     while (inlen > 0) {
         n = MIN(inlen, (16 - md->md2.curlen));
         XMEMCPY(md->md2.buf + md->md2.curlen, in, (size_t)n);
@@ -186,12 +186,12 @@ int md2_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int md2_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
    static const struct {
         char *msg;
         unsigned char md[16];
@@ -239,7 +239,7 @@ int md2_test(void)
           return CRYPT_FAIL_TESTVECTOR;
        }
    }
-   return CRYPT_OK;        
+   return CRYPT_OK;
   #endif
 }
 

src/hashes/md4.c

@@ -12,7 +12,7 @@
 
 /**
    @param md4.c
-   Submitted by Dobes Vandermeer  (dobes@smartt.com) 
+   Submitted by Dobes Vandermeer  (dobes@smartt.com)
 */
 
 #ifdef LTC_MD4
@@ -23,7 +23,7 @@ const struct ltc_hash_descriptor md4_desc =
     6,
     16,
     64,
- 
+
     /* OID */
    { 1, 2, 840, 113549, 2, 4,  },
    6,
@@ -56,8 +56,8 @@ const struct ltc_hash_descriptor md4_desc =
 /* ROTATE_LEFT rotates x left n bits. */
 #define ROTATE_LEFT(x, n) ROLc(x, n)
 
-/* FF, GG and HH are transformations for rounds 1, 2 and 3 */ 
+/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
-/* Rotation is separate from addition to prevent recomputation */ 
+/* Rotation is separate from addition to prevent recomputation */
 
 #define FF(a, b, c, d, x, s) { \
     (a) += F ((b), (c), (d)) + (x); \
@@ -91,61 +91,61 @@ static int  md4_compress(hash_state *md, unsigned char *buf)
     for (i = 0; i < 16; i++) {
         LOAD32L(x[i], buf + (4*i));
     }
- 
+
-    /* Round 1 */ 
+    /* Round 1 */
-    FF (a, b, c, d, x[ 0], S11); /* 1 */ 
+    FF (a, b, c, d, x[ 0], S11); /* 1 */
-    FF (d, a, b, c, x[ 1], S12); /* 2 */ 
+    FF (d, a, b, c, x[ 1], S12); /* 2 */
-    FF (c, d, a, b, x[ 2], S13); /* 3 */ 
+    FF (c, d, a, b, x[ 2], S13); /* 3 */
-    FF (b, c, d, a, x[ 3], S14); /* 4 */ 
+    FF (b, c, d, a, x[ 3], S14); /* 4 */
-    FF (a, b, c, d, x[ 4], S11); /* 5 */ 
+    FF (a, b, c, d, x[ 4], S11); /* 5 */
-    FF (d, a, b, c, x[ 5], S12); /* 6 */ 
+    FF (d, a, b, c, x[ 5], S12); /* 6 */
-    FF (c, d, a, b, x[ 6], S13); /* 7 */ 
+    FF (c, d, a, b, x[ 6], S13); /* 7 */
-    FF (b, c, d, a, x[ 7], S14); /* 8 */ 
+    FF (b, c, d, a, x[ 7], S14); /* 8 */
-    FF (a, b, c, d, x[ 8], S11); /* 9 */ 
+    FF (a, b, c, d, x[ 8], S11); /* 9 */
     FF (d, a, b, c, x[ 9], S12); /* 10 */
-    FF (c, d, a, b, x[10], S13); /* 11 */ 
+    FF (c, d, a, b, x[10], S13); /* 11 */
     FF (b, c, d, a, x[11], S14); /* 12 */
     FF (a, b, c, d, x[12], S11); /* 13 */
-    FF (d, a, b, c, x[13], S12); /* 14 */ 
+    FF (d, a, b, c, x[13], S12); /* 14 */
-    FF (c, d, a, b, x[14], S13); /* 15 */ 
+    FF (c, d, a, b, x[14], S13); /* 15 */
-    FF (b, c, d, a, x[15], S14); /* 16 */ 
+    FF (b, c, d, a, x[15], S14); /* 16 */
-    
+
-    /* Round 2 */ 
+    /* Round 2 */
-    GG (a, b, c, d, x[ 0], S21); /* 17 */ 
+    GG (a, b, c, d, x[ 0], S21); /* 17 */
-    GG (d, a, b, c, x[ 4], S22); /* 18 */ 
+    GG (d, a, b, c, x[ 4], S22); /* 18 */
-    GG (c, d, a, b, x[ 8], S23); /* 19 */ 
+    GG (c, d, a, b, x[ 8], S23); /* 19 */
-    GG (b, c, d, a, x[12], S24); /* 20 */ 
+    GG (b, c, d, a, x[12], S24); /* 20 */
-    GG (a, b, c, d, x[ 1], S21); /* 21 */ 
+    GG (a, b, c, d, x[ 1], S21); /* 21 */
-    GG (d, a, b, c, x[ 5], S22); /* 22 */ 
+    GG (d, a, b, c, x[ 5], S22); /* 22 */
-    GG (c, d, a, b, x[ 9], S23); /* 23 */ 
+    GG (c, d, a, b, x[ 9], S23); /* 23 */
-    GG (b, c, d, a, x[13], S24); /* 24 */ 
+    GG (b, c, d, a, x[13], S24); /* 24 */
-    GG (a, b, c, d, x[ 2], S21); /* 25 */ 
+    GG (a, b, c, d, x[ 2], S21); /* 25 */
-    GG (d, a, b, c, x[ 6], S22); /* 26 */ 
+    GG (d, a, b, c, x[ 6], S22); /* 26 */
-    GG (c, d, a, b, x[10], S23); /* 27 */ 
+    GG (c, d, a, b, x[10], S23); /* 27 */
-    GG (b, c, d, a, x[14], S24); /* 28 */ 
+    GG (b, c, d, a, x[14], S24); /* 28 */
-    GG (a, b, c, d, x[ 3], S21); /* 29 */ 
+    GG (a, b, c, d, x[ 3], S21); /* 29 */
-    GG (d, a, b, c, x[ 7], S22); /* 30 */ 
+    GG (d, a, b, c, x[ 7], S22); /* 30 */
-    GG (c, d, a, b, x[11], S23); /* 31 */ 
+    GG (c, d, a, b, x[11], S23); /* 31 */
-    GG (b, c, d, a, x[15], S24); /* 32 */ 
+    GG (b, c, d, a, x[15], S24); /* 32 */
-    
+
     /* Round 3 */
-    HH (a, b, c, d, x[ 0], S31); /* 33 */ 
+    HH (a, b, c, d, x[ 0], S31); /* 33 */
-    HH (d, a, b, c, x[ 8], S32); /* 34 */ 
+    HH (d, a, b, c, x[ 8], S32); /* 34 */
-    HH (c, d, a, b, x[ 4], S33); /* 35 */ 
+    HH (c, d, a, b, x[ 4], S33); /* 35 */
-    HH (b, c, d, a, x[12], S34); /* 36 */ 
+    HH (b, c, d, a, x[12], S34); /* 36 */
-    HH (a, b, c, d, x[ 2], S31); /* 37 */ 
+    HH (a, b, c, d, x[ 2], S31); /* 37 */
-    HH (d, a, b, c, x[10], S32); /* 38 */ 
+    HH (d, a, b, c, x[10], S32); /* 38 */
-    HH (c, d, a, b, x[ 6], S33); /* 39 */ 
+    HH (c, d, a, b, x[ 6], S33); /* 39 */
-    HH (b, c, d, a, x[14], S34); /* 40 */ 
+    HH (b, c, d, a, x[14], S34); /* 40 */
-    HH (a, b, c, d, x[ 1], S31); /* 41 */ 
+    HH (a, b, c, d, x[ 1], S31); /* 41 */
-    HH (d, a, b, c, x[ 9], S32); /* 42 */ 
+    HH (d, a, b, c, x[ 9], S32); /* 42 */
-    HH (c, d, a, b, x[ 5], S33); /* 43 */ 
+    HH (c, d, a, b, x[ 5], S33); /* 43 */
-    HH (b, c, d, a, x[13], S34); /* 44 */ 
+    HH (b, c, d, a, x[13], S34); /* 44 */
-    HH (a, b, c, d, x[ 3], S31); /* 45 */ 
+    HH (a, b, c, d, x[ 3], S31); /* 45 */
-    HH (d, a, b, c, x[11], S32); /* 46 */ 
+    HH (d, a, b, c, x[11], S32); /* 46 */
-    HH (c, d, a, b, x[ 7], S33); /* 47 */ 
+    HH (c, d, a, b, x[ 7], S33); /* 47 */
-    HH (b, c, d, a, x[15], S34); /* 48 */ 
+    HH (b, c, d, a, x[15], S34); /* 48 */
-    
+
 
     /* Update our state */
     md->md4.state[0] = md->md4.state[0] + a;
@@ -242,43 +242,43 @@ int md4_done(hash_state * md, unsigned char *out)
     }
 #ifdef LTC_CLEAN_STACK
     zeromem(md, sizeof(hash_state));
-#endif 
+#endif
     return CRYPT_OK;
 }
 
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int md4_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
     static const struct md4_test_case {
         char *input;
         unsigned char digest[16];
     } cases[] = {
-        { "", 
+        { "",
           {0x31, 0xd6, 0xcf, 0xe0, 0xd1, 0x6a, 0xe9, 0x31,
            0xb7, 0x3c, 0x59, 0xd7, 0xe0, 0xc0, 0x89, 0xc0} },
         { "a",
           {0xbd, 0xe5, 0x2c, 0xb3, 0x1d, 0xe3, 0x3e, 0x46,
            0x24, 0x5e, 0x05, 0xfb, 0xdb, 0xd6, 0xfb, 0x24} },
         { "abc",
-          {0xa4, 0x48, 0x01, 0x7a, 0xaf, 0x21, 0xd8, 0x52, 
+          {0xa4, 0x48, 0x01, 0x7a, 0xaf, 0x21, 0xd8, 0x52,
            0x5f, 0xc1, 0x0a, 0xe8, 0x7a, 0xa6, 0x72, 0x9d} },
-        { "message digest", 
+        { "message digest",
-          {0xd9, 0x13, 0x0a, 0x81, 0x64, 0x54, 0x9f, 0xe8, 
+          {0xd9, 0x13, 0x0a, 0x81, 0x64, 0x54, 0x9f, 0xe8,
            0x18, 0x87, 0x48, 0x06, 0xe1, 0xc7, 0x01, 0x4b} },
-        { "abcdefghijklmnopqrstuvwxyz", 
+        { "abcdefghijklmnopqrstuvwxyz",
-          {0xd7, 0x9e, 0x1c, 0x30, 0x8a, 0xa5, 0xbb, 0xcd, 
+          {0xd7, 0x9e, 0x1c, 0x30, 0x8a, 0xa5, 0xbb, 0xcd,
            0xee, 0xa8, 0xed, 0x63, 0xdf, 0x41, 0x2d, 0xa9} },
-        { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 
+        { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-          {0x04, 0x3f, 0x85, 0x82, 0xf2, 0x41, 0xdb, 0x35, 
+          {0x04, 0x3f, 0x85, 0x82, 0xf2, 0x41, 0xdb, 0x35,
            0x1c, 0xe6, 0x27, 0xe1, 0x53, 0xe7, 0xf0, 0xe4} },
-        { "12345678901234567890123456789012345678901234567890123456789012345678901234567890", 
+        { "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
-          {0xe3, 0x3b, 0x4d, 0xdc, 0x9c, 0x38, 0xf2, 0x19, 
+          {0xe3, 0x3b, 0x4d, 0xdc, 0x9c, 0x38, 0xf2, 0x19,
            0x9c, 0x3e, 0x7b, 0x16, 0x4f, 0xcc, 0x05, 0x36} },
     };
     int i;

src/hashes/md5.c

@@ -13,7 +13,7 @@
 
 /**
   @file md5.c
-  LTC_MD5 hash function by Tom St Denis 
+  LTC_MD5 hash function by Tom St Denis
 */
 
 #ifdef LTC_MD5
@@ -95,7 +95,7 @@ static const ulong32 Korder[64] = {
     a = (a + I(b,c,d) + M + t); a = ROLc(a, s) + b;
 
 
-#endif   
+#endif
 
 #ifdef LTC_CLEAN_STACK
 static int _md5_compress(hash_state *md, unsigned char *buf)
@@ -112,7 +112,7 @@ static int  md5_compress(hash_state *md, unsigned char *buf)
     for (i = 0; i < 16; i++) {
         LOAD32L(W[i], buf + (4*i));
     }
- 
+
     /* copy state */
     a = md->md5.state[0];
     b = md->md5.state[1];
@@ -309,37 +309,37 @@ int md5_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int  md5_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
   static const struct {
       char *msg;
       unsigned char hash[16];
   } tests[] = {
     { "",
-      { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, 
+      { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04,
         0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e } },
     { "a",
-      {0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8, 
+      {0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8,
        0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 } },
     { "abc",
-      { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0, 
+      { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
         0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 } },
-    { "message digest", 
+    { "message digest",
-      { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d, 
+      { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d,
-        0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 } }, 
+        0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 } },
     { "abcdefghijklmnopqrstuvwxyz",
-      { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00, 
+      { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00,
         0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b } },
     { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-      { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5, 
+      { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5,
         0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f } },
     { "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
-      { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55, 
+      { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55,
-        0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a } }, 
+        0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a } },
     { NULL, { 0 } }
   };
 

src/hashes/rmd128.c

@@ -13,7 +13,7 @@
 /**
    @param rmd128.c
    RMD128 Hash function
-*/   
+*/
 
 /* Implementation of LTC_RIPEMD-128 based on the source by Antoon Bosselaers, ESAT-COSIC
  *
@@ -42,11 +42,11 @@ const struct ltc_hash_descriptor rmd128_desc =
 };
 
 /* the four basic functions F(), G() and H() */
-#define F(x, y, z)        ((x) ^ (y) ^ (z)) 
+#define F(x, y, z)        ((x) ^ (y) ^ (z))
-#define G(x, y, z)        (((x) & (y)) | (~(x) & (z))) 
+#define G(x, y, z)        (((x) & (y)) | (~(x) & (z)))
 #define H(x, y, z)        (((x) | ~(y)) ^ (z))
-#define I(x, y, z)        (((x) & (z)) | ((y) & ~(z))) 
+#define I(x, y, z)        (((x) & (z)) | ((y) & ~(z)))
-  
+
 /* the eight basic operations FF() through III() */
 #define FF(a, b, c, d, x, s)        \
       (a) += F((b), (c), (d)) + (x);\
@@ -88,7 +88,7 @@ static int  rmd128_compress(hash_state *md, unsigned char *buf)
 {
    ulong32 aa,bb,cc,dd,aaa,bbb,ccc,ddd,X[16];
    int i;
-   
+
    /* load words X */
    for (i = 0; i < 16; i++){
       LOAD32L(X[i], buf + (4 * i));
@@ -117,7 +117,7 @@ static int  rmd128_compress(hash_state *md, unsigned char *buf)
    FF(dd, aa, bb, cc, X[13],  7);
    FF(cc, dd, aa, bb, X[14],  9);
    FF(bb, cc, dd, aa, X[15],  8);
-                             
+
    /* round 2 */
    GG(aa, bb, cc, dd, X[ 7],  7);
    GG(dd, aa, bb, cc, X[ 4],  6);
@@ -173,7 +173,7 @@ static int  rmd128_compress(hash_state *md, unsigned char *buf)
    II(bb, cc, dd, aa, X[ 2], 12);
 
    /* parallel round 1 */
-   III(aaa, bbb, ccc, ddd, X[ 5],  8); 
+   III(aaa, bbb, ccc, ddd, X[ 5],  8);
    III(ddd, aaa, bbb, ccc, X[14],  9);
    III(ccc, ddd, aaa, bbb, X[ 7],  9);
    III(bbb, ccc, ddd, aaa, X[ 0], 11);
@@ -208,7 +208,7 @@ static int  rmd128_compress(hash_state *md, unsigned char *buf)
    HHH(ccc, ddd, aaa, bbb, X[ 1], 13);
    HHH(bbb, ccc, ddd, aaa, X[ 2], 11);
 
-   /* parallel round 3 */   
+   /* parallel round 3 */
    GGG(aaa, bbb, ccc, ddd, X[15],  9);
    GGG(ddd, aaa, bbb, ccc, X[ 5],  7);
    GGG(ccc, ddd, aaa, bbb, X[ 1], 15);
@@ -342,13 +342,13 @@ int rmd128_done(hash_state * md, unsigned char *out)
 #ifdef LTC_CLEAN_STACK
     zeromem(md, sizeof(hash_state));
 #endif
-   return CRYPT_OK;  
+   return CRYPT_OK;
 }
 
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int rmd128_test(void)
 {
 #ifndef LTC_TEST

src/hashes/rmd160.c

@@ -13,7 +13,7 @@
 /**
    @file rmd160.c
    RMD160 hash function
-*/   
+*/
 
 /* Implementation of LTC_RIPEMD-160 based on the source by Antoon Bosselaers, ESAT-COSIC
  *
@@ -42,12 +42,12 @@ const struct ltc_hash_descriptor rmd160_desc =
 };
 
 /* the five basic functions F(), G() and H() */
-#define F(x, y, z)        ((x) ^ (y) ^ (z)) 
+#define F(x, y, z)        ((x) ^ (y) ^ (z))
-#define G(x, y, z)        (((x) & (y)) | (~(x) & (z))) 
+#define G(x, y, z)        (((x) & (y)) | (~(x) & (z)))
 #define H(x, y, z)        (((x) | ~(y)) ^ (z))
-#define I(x, y, z)        (((x) & (z)) | ((y) & ~(z))) 
+#define I(x, y, z)        (((x) & (z)) | ((y) & ~(z)))
 #define J(x, y, z)        ((x) ^ ((y) | ~(z)))
-  
+
 /* the ten basic operations FF() through III() */
 #define FF(a, b, c, d, e, x, s)        \
       (a) += F((b), (c), (d)) + (x);\
@@ -138,7 +138,7 @@ static int  rmd160_compress(hash_state *md, unsigned char *buf)
    FF(cc, dd, ee, aa, bb, X[13],  7);
    FF(bb, cc, dd, ee, aa, X[14],  9);
    FF(aa, bb, cc, dd, ee, X[15],  8);
-                             
+
    /* round 2 */
    GG(ee, aa, bb, cc, dd, X[ 7],  7);
    GG(dd, ee, aa, bb, cc, X[ 4],  6);
@@ -230,7 +230,7 @@ static int  rmd160_compress(hash_state *md, unsigned char *buf)
    JJJ(aaa, bbb, ccc, ddd, eee, X[12],  6);
 
    /* parallel round 2 */
-   III(eee, aaa, bbb, ccc, ddd, X[ 6],  9); 
+   III(eee, aaa, bbb, ccc, ddd, X[ 6],  9);
    III(ddd, eee, aaa, bbb, ccc, X[11], 13);
    III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
    III(bbb, ccc, ddd, eee, aaa, X[ 7],  7);
@@ -265,7 +265,7 @@ static int  rmd160_compress(hash_state *md, unsigned char *buf)
    HHH(eee, aaa, bbb, ccc, ddd, X[ 4],  7);
    HHH(ddd, eee, aaa, bbb, ccc, X[13],  5);
 
-   /* parallel round 4 */   
+   /* parallel round 4 */
    GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
    GGG(bbb, ccc, ddd, eee, aaa, X[ 6],  5);
    GGG(aaa, bbb, ccc, ddd, eee, X[ 4],  8);
@@ -407,7 +407,7 @@ int rmd160_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int rmd160_test(void)
 {
 #ifndef LTC_TEST

src/hashes/sha1.c

@@ -12,7 +12,7 @@
 
 /**
   @file sha1.c
-  LTC_SHA1 code by Tom St Denis 
+  LTC_SHA1 code by Tom St Denis
 */
 
 
@@ -66,7 +66,7 @@ static int  sha1_compress(hash_state *md, unsigned char *buf)
 
     /* expand it */
     for (i = 16; i < 80; i++) {
-        W[i] = ROL(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1); 
+        W[i] = ROL(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
     }
 
     /* compress */
@@ -75,9 +75,9 @@ static int  sha1_compress(hash_state *md, unsigned char *buf)
     #define FF1(a,b,c,d,e,i) e = (ROLc(a, 5) + F1(b,c,d) + e + W[i] + 0x6ed9eba1UL); b = ROLc(b, 30);
     #define FF2(a,b,c,d,e,i) e = (ROLc(a, 5) + F2(b,c,d) + e + W[i] + 0x8f1bbcdcUL); b = ROLc(b, 30);
     #define FF3(a,b,c,d,e,i) e = (ROLc(a, 5) + F3(b,c,d) + e + W[i] + 0xca62c1d6UL); b = ROLc(b, 30);
- 
+
 #ifdef LTC_SMALL_CODE
- 
+
     for (i = 0; i < 20; ) {
        FF0(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t;
     }
@@ -105,7 +105,7 @@ static int  sha1_compress(hash_state *md, unsigned char *buf)
     }
 
     /* round two */
-    for (; i < 40; )  { 
+    for (; i < 40; )  {
        FF1(a,b,c,d,e,i++);
        FF1(e,a,b,c,d,i++);
        FF1(d,e,a,b,c,i++);
@@ -114,7 +114,7 @@ static int  sha1_compress(hash_state *md, unsigned char *buf)
     }
 
     /* round three */
-    for (; i < 60; )  { 
+    for (; i < 60; )  {
        FF2(a,b,c,d,e,i++);
        FF2(e,a,b,c,d,i++);
        FF2(d,e,a,b,c,i++);
@@ -123,7 +123,7 @@ static int  sha1_compress(hash_state *md, unsigned char *buf)
     }
 
     /* round four */
-    for (; i < 80; )  { 
+    for (; i < 80; )  {
        FF3(a,b,c,d,e,i++);
        FF3(e,a,b,c,d,i++);
        FF3(d,e,a,b,c,i++);
@@ -241,12 +241,12 @@ int sha1_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int  sha1_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
   static const struct {
       char *msg;
       unsigned char hash[20];

src/hashes/sha2/sha256.c

@@ -12,10 +12,10 @@
 
 /**
   @file sha256.c
-  LTC_SHA256 by Tom St Denis 
+  LTC_SHA256 by Tom St Denis
 */
 
-#ifdef LTC_SHA256 
+#ifdef LTC_SHA256
 
 const struct ltc_hash_descriptor sha256_desc =
 {
@@ -56,7 +56,7 @@ static const ulong32 K[64] = {
 
 /* Various logical functions */
 #define Ch(x,y,z)       (z ^ (x & (y ^ z)))
-#define Maj(x,y,z)      (((x | y) & z) | (x & y)) 
+#define Maj(x,y,z)      (((x | y) & z) | (x & y))
 #define S(x, n)         RORc((x),(n))
 #define R(x, n)         (((x)&0xFFFFFFFFUL)>>(n))
 #define Sigma0(x)       (S(x, 2) ^ S(x, 13) ^ S(x, 22))
@@ -90,10 +90,10 @@ static int  sha256_compress(hash_state * md, unsigned char *buf)
     /* fill W[16..63] */
     for (i = 16; i < 64; i++) {
         W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
-    }        
+    }
 
     /* Compress */
-#ifdef LTC_SMALL_CODE   
+#ifdef LTC_SMALL_CODE
 #define RND(a,b,c,d,e,f,g,h,i)                         \
      t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i];   \
      t1 = Sigma0(a) + Maj(a, b, c);                    \
@@ -102,10 +102,10 @@ static int  sha256_compress(hash_state * md, unsigned char *buf)
 
      for (i = 0; i < 64; ++i) {
          RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i);
-         t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4]; 
+         t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4];
          S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t;
-     }  
+     }
-#else 
+#else
 #define RND(a,b,c,d,e,f,g,h,i,ki)                    \
      t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i];   \
      t1 = Sigma0(a) + Maj(a, b, c);                  \
@@ -177,9 +177,9 @@ static int  sha256_compress(hash_state * md, unsigned char *buf)
     RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],62,0xbef9a3f7);
     RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],63,0xc67178f2);
 
-#undef RND     
+#undef RND
-    
+
-#endif     
+#endif
 
     /* feedback */
     for (i = 0; i < 8; i++) {
@@ -287,12 +287,12 @@ int sha256_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int  sha256_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
   static const struct {
       char *msg;
       unsigned char hash[32];
@@ -304,9 +304,9 @@ int  sha256_test(void)
         0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad }
     },
     { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
-      { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 
+      { 0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
         0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
-        0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67, 
+        0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
         0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 }
     },
   };

src/hashes/sha2/sha512.c

@@ -12,7 +12,7 @@
 
 /**
    @param sha512.c
-   LTC_SHA512 by Tom St Denis 
+   LTC_SHA512 by Tom St Denis
 */
 
 #ifdef LTC_SHA512
@@ -37,51 +37,51 @@ const struct ltc_hash_descriptor sha512_desc =
 
 /* the K array */
 static const ulong64 K[80] = {
-CONST64(0x428a2f98d728ae22), CONST64(0x7137449123ef65cd), 
+CONST64(0x428a2f98d728ae22), CONST64(0x7137449123ef65cd),
 CONST64(0xb5c0fbcfec4d3b2f), CONST64(0xe9b5dba58189dbbc),
-CONST64(0x3956c25bf348b538), CONST64(0x59f111f1b605d019), 
+CONST64(0x3956c25bf348b538), CONST64(0x59f111f1b605d019),
 CONST64(0x923f82a4af194f9b), CONST64(0xab1c5ed5da6d8118),
-CONST64(0xd807aa98a3030242), CONST64(0x12835b0145706fbe), 
+CONST64(0xd807aa98a3030242), CONST64(0x12835b0145706fbe),
 CONST64(0x243185be4ee4b28c), CONST64(0x550c7dc3d5ffb4e2),
-CONST64(0x72be5d74f27b896f), CONST64(0x80deb1fe3b1696b1), 
+CONST64(0x72be5d74f27b896f), CONST64(0x80deb1fe3b1696b1),
 CONST64(0x9bdc06a725c71235), CONST64(0xc19bf174cf692694),
-CONST64(0xe49b69c19ef14ad2), CONST64(0xefbe4786384f25e3), 
+CONST64(0xe49b69c19ef14ad2), CONST64(0xefbe4786384f25e3),
 CONST64(0x0fc19dc68b8cd5b5), CONST64(0x240ca1cc77ac9c65),
-CONST64(0x2de92c6f592b0275), CONST64(0x4a7484aa6ea6e483), 
+CONST64(0x2de92c6f592b0275), CONST64(0x4a7484aa6ea6e483),
 CONST64(0x5cb0a9dcbd41fbd4), CONST64(0x76f988da831153b5),
-CONST64(0x983e5152ee66dfab), CONST64(0xa831c66d2db43210), 
+CONST64(0x983e5152ee66dfab), CONST64(0xa831c66d2db43210),
 CONST64(0xb00327c898fb213f), CONST64(0xbf597fc7beef0ee4),
-CONST64(0xc6e00bf33da88fc2), CONST64(0xd5a79147930aa725), 
+CONST64(0xc6e00bf33da88fc2), CONST64(0xd5a79147930aa725),
 CONST64(0x06ca6351e003826f), CONST64(0x142929670a0e6e70),
-CONST64(0x27b70a8546d22ffc), CONST64(0x2e1b21385c26c926), 
+CONST64(0x27b70a8546d22ffc), CONST64(0x2e1b21385c26c926),
 CONST64(0x4d2c6dfc5ac42aed), CONST64(0x53380d139d95b3df),
-CONST64(0x650a73548baf63de), CONST64(0x766a0abb3c77b2a8), 
+CONST64(0x650a73548baf63de), CONST64(0x766a0abb3c77b2a8),
 CONST64(0x81c2c92e47edaee6), CONST64(0x92722c851482353b),
 CONST64(0xa2bfe8a14cf10364), CONST64(0xa81a664bbc423001),
 CONST64(0xc24b8b70d0f89791), CONST64(0xc76c51a30654be30),
-CONST64(0xd192e819d6ef5218), CONST64(0xd69906245565a910), 
+CONST64(0xd192e819d6ef5218), CONST64(0xd69906245565a910),
 CONST64(0xf40e35855771202a), CONST64(0x106aa07032bbd1b8),
-CONST64(0x19a4c116b8d2d0c8), CONST64(0x1e376c085141ab53), 
+CONST64(0x19a4c116b8d2d0c8), CONST64(0x1e376c085141ab53),
 CONST64(0x2748774cdf8eeb99), CONST64(0x34b0bcb5e19b48a8),
-CONST64(0x391c0cb3c5c95a63), CONST64(0x4ed8aa4ae3418acb), 
+CONST64(0x391c0cb3c5c95a63), CONST64(0x4ed8aa4ae3418acb),
 CONST64(0x5b9cca4f7763e373), CONST64(0x682e6ff3d6b2b8a3),
-CONST64(0x748f82ee5defb2fc), CONST64(0x78a5636f43172f60), 
+CONST64(0x748f82ee5defb2fc), CONST64(0x78a5636f43172f60),
 CONST64(0x84c87814a1f0ab72), CONST64(0x8cc702081a6439ec),
-CONST64(0x90befffa23631e28), CONST64(0xa4506cebde82bde9), 
+CONST64(0x90befffa23631e28), CONST64(0xa4506cebde82bde9),
 CONST64(0xbef9a3f7b2c67915), CONST64(0xc67178f2e372532b),
-CONST64(0xca273eceea26619c), CONST64(0xd186b8c721c0c207), 
+CONST64(0xca273eceea26619c), CONST64(0xd186b8c721c0c207),
 CONST64(0xeada7dd6cde0eb1e), CONST64(0xf57d4f7fee6ed178),
-CONST64(0x06f067aa72176fba), CONST64(0x0a637dc5a2c898a6), 
+CONST64(0x06f067aa72176fba), CONST64(0x0a637dc5a2c898a6),
 CONST64(0x113f9804bef90dae), CONST64(0x1b710b35131c471b),
-CONST64(0x28db77f523047d84), CONST64(0x32caab7b40c72493), 
+CONST64(0x28db77f523047d84), CONST64(0x32caab7b40c72493),
 CONST64(0x3c9ebe0a15c9bebc), CONST64(0x431d67c49c100d4c),
-CONST64(0x4cc5d4becb3e42b6), CONST64(0x597f299cfc657e2a), 
+CONST64(0x4cc5d4becb3e42b6), CONST64(0x597f299cfc657e2a),
 CONST64(0x5fcb6fab3ad6faec), CONST64(0x6c44198c4a475817)
 };
 
 /* Various logical functions */
 #define Ch(x,y,z)       (z ^ (x & (y ^ z)))
-#define Maj(x,y,z)      (((x | y) & z) | (x & y)) 
+#define Maj(x,y,z)      (((x | y) & z) | (x & y))
 #define S(x, n)         ROR64c(x, n)
 #define R(x, n)         (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)n))
 #define Sigma0(x)       (S(x, 28) ^ S(x, 34) ^ S(x, 39))
@@ -112,7 +112,7 @@ static int  sha512_compress(hash_state * md, unsigned char *buf)
     /* fill W[16..79] */
     for (i = 16; i < 80; i++) {
         W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
-    }        
+    }
 
     /* Compress */
 #ifdef LTC_SMALL_CODE
@@ -135,17 +135,17 @@ static int  sha512_compress(hash_state * md, unsigned char *buf)
      d += t0;                                        \
      h  = t0 + t1;
 
-     for (i = 0; i < 80; i += 8) {
+    for (i = 0; i < 80; i += 8) {
-         RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i+0);
+        RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i+0);
-         RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],i+1);
+        RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],i+1);
-         RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],i+2);
+        RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],i+2);
-         RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],i+3);
+        RND(S[5],S[6],S[7],S[0],S[1],S[2],S[3],S[4],i+3);
-         RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],i+4);
+        RND(S[4],S[5],S[6],S[7],S[0],S[1],S[2],S[3],i+4);
-         RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],i+5);
+        RND(S[3],S[4],S[5],S[6],S[7],S[0],S[1],S[2],i+5);
-         RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],i+6);
+        RND(S[2],S[3],S[4],S[5],S[6],S[7],S[0],S[1],i+6);
-         RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],i+7);
+        RND(S[1],S[2],S[3],S[4],S[5],S[6],S[7],S[0],i+7);
-     }
+    }
-#endif     
+#endif
 
 
     /* feedback */
@@ -232,7 +232,7 @@ int sha512_done(hash_state * md, unsigned char *out)
         md->sha512.curlen = 0;
     }
 
-    /* pad upto 120 bytes of zeroes 
+    /* pad upto 120 bytes of zeroes
      * note: that from 112 to 120 is the 64 MSB of the length.  We assume that you won't hash
      * > 2^64 bits of data... :-)
      */
@@ -257,12 +257,12 @@ int sha512_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int  sha512_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
   static const struct {
       char *msg;
       unsigned char hash[64];

src/hashes/tiger.c

@@ -558,16 +558,16 @@ static const ulong64 table[4*256] = {
 #ifdef _MSC_VER
    #define INLINE __inline
 #else
-   #define INLINE 
+   #define INLINE
-#endif   
+#endif
 
 /* one round of the hash function */
 INLINE static void tiger_round(ulong64 *a, ulong64 *b, ulong64 *c, ulong64 x, int mul)
 {
     ulong64 tmp;
-    tmp = (*c ^= x); 
+    tmp = (*c ^= x);
-           *a -= t1[byte(tmp, 0)] ^ t2[byte(tmp, 2)] ^ t3[byte(tmp, 4)] ^ t4[byte(tmp, 6)];      
+           *a -= t1[byte(tmp, 0)] ^ t2[byte(tmp, 2)] ^ t3[byte(tmp, 4)] ^ t4[byte(tmp, 6)];
-    tmp = (*b += t4[byte(tmp, 1)] ^ t3[byte(tmp, 3)] ^ t2[byte(tmp,5)] ^ t1[byte(tmp,7)]); 
+    tmp = (*b += t4[byte(tmp, 1)] ^ t3[byte(tmp, 3)] ^ t2[byte(tmp,5)] ^ t1[byte(tmp,7)]);
     switch (mul) {
         case 5:  *b = (tmp << 2) + tmp; break;
         case 7:  *b = (tmp << 3) - tmp; break;
@@ -578,36 +578,36 @@ INLINE static void tiger_round(ulong64 *a, ulong64 *b, ulong64 *c, ulong64 x, in
 /* one complete pass */
 static void pass(ulong64 *a, ulong64 *b, ulong64 *c, ulong64 *x, int mul)
 {
-   tiger_round(a,b,c,x[0],mul); 
+   tiger_round(a,b,c,x[0],mul);
-   tiger_round(b,c,a,x[1],mul); 
+   tiger_round(b,c,a,x[1],mul);
-   tiger_round(c,a,b,x[2],mul); 
+   tiger_round(c,a,b,x[2],mul);
-   tiger_round(a,b,c,x[3],mul); 
+   tiger_round(a,b,c,x[3],mul);
-   tiger_round(b,c,a,x[4],mul); 
+   tiger_round(b,c,a,x[4],mul);
-   tiger_round(c,a,b,x[5],mul); 
+   tiger_round(c,a,b,x[5],mul);
-   tiger_round(a,b,c,x[6],mul); 
+   tiger_round(a,b,c,x[6],mul);
-   tiger_round(b,c,a,x[7],mul);          
+   tiger_round(b,c,a,x[7],mul);
-}   
+}
 
 /* The key mixing schedule */
-static void key_schedule(ulong64 *x) 
+static void key_schedule(ulong64 *x)
 {
-    x[0] -= x[7] ^ CONST64(0xA5A5A5A5A5A5A5A5); 
+    x[0] -= x[7] ^ CONST64(0xA5A5A5A5A5A5A5A5);
-    x[1] ^= x[0];                               
+    x[1] ^= x[0];
-    x[2] += x[1];                               
+    x[2] += x[1];
-    x[3] -= x[2] ^ ((~x[1])<<19);               
+    x[3] -= x[2] ^ ((~x[1])<<19);
-    x[4] ^= x[3];                               
+    x[4] ^= x[3];
-    x[5] += x[4];                               
+    x[5] += x[4];
-    x[6] -= x[5] ^ ((~x[4])>>23);               
+    x[6] -= x[5] ^ ((~x[4])>>23);
-    x[7] ^= x[6];                               
+    x[7] ^= x[6];
-    x[0] += x[7];                               
+    x[0] += x[7];
-    x[1] -= x[0] ^ ((~x[7])<<19);               
+    x[1] -= x[0] ^ ((~x[7])<<19);
-    x[2] ^= x[1];                               
+    x[2] ^= x[1];
-    x[3] += x[2];                               
+    x[3] += x[2];
-    x[4] -= x[3] ^ ((~x[2])>>23);               
+    x[4] -= x[3] ^ ((~x[2])>>23);
-    x[5] ^= x[4];                               
+    x[5] ^= x[4];
-    x[6] += x[5];                               
+    x[6] += x[5];
     x[7] -= x[6] ^ CONST64(0x0123456789ABCDEF);
-}    
+}
 
 #ifdef LTC_CLEAN_STACK
 static int _tiger_compress(hash_state *md, unsigned char *buf)
@@ -709,7 +709,7 @@ int tiger_done(hash_state * md, unsigned char *out)
 
     /* pad upto 56 bytes of zeroes */
     while (md->tiger.curlen < 56) {
-        md->tiger.buf[md->tiger.curlen++] = (unsigned char)0; 
+        md->tiger.buf[md->tiger.curlen++] = (unsigned char)0;
     }
 
     /* store length */
@@ -730,12 +730,12 @@ int tiger_done(hash_state * md, unsigned char *out)
 /**
   Self-test the hash
   @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
-*/  
+*/
 int  tiger_test(void)
 {
  #ifndef LTC_TEST
     return CRYPT_NOP;
- #else    
+ #else
   static const struct {
       char *msg;
       unsigned char hash[24];

src/headers/tomcrypt_hash.h

@@ -373,7 +373,7 @@ int func_name (hash_state * md, const unsigned char *in, unsigned long inlen)
     if (md-> state_var .curlen > sizeof(md-> state_var .buf)) {                             \
        return CRYPT_INVALID_ARG;                                                            \
     }                                                                                       \
-    if ((md-> state_var .length + inlen) < md-> state_var .length) {	                    \
+    if ((md-> state_var .length + inlen) < md-> state_var .length) {                       \
       return CRYPT_HASH_OVERFLOW;                                                           \
     }                                                                                       \
     while (inlen > 0) {                                                                     \

src/headers/tomcrypt_pk.h

@@ -261,8 +261,8 @@ typedef struct {
     /** Index into the ltc_ecc_sets[] for the parameters of this curve; if -1, then this key is using user supplied curve in dp */
     int idx;
 
-	/** pointer to domain parameters; either points to NIST curves (identified by idx >= 0) or user supplied curve */
+    /** pointer to domain parameters; either points to NIST curves (identified by idx >= 0) or user supplied curve */
-	const ltc_ecc_set_type *dp;
+    const ltc_ecc_set_type *dp;
 
     /** The public key */
     ecc_point pubkey;

src/mac/f9/f9_done.c

@@ -62,7 +62,7 @@ int f9_done(f9_state *f9, unsigned char *out, unsigned long *outlen)
       out[x] = f9->ACC[x];
    }
    *outlen = x;
-  
+
 #ifdef LTC_CLEAN_STACK
    zeromem(f9, sizeof(*f9));
 #endif

src/mac/f9/f9_file.c

@@ -10,7 +10,7 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
   @file f9_file.c
   f9 support, process a file, Tom St Denis
 */
@@ -29,7 +29,7 @@
 */
 int f9_file(int cipher,
               const unsigned char *key, unsigned long keylen,
-              const char *filename, 
+              const char *filename,
                     unsigned char *out, unsigned long *outlen)
 {
 #ifdef LTC_NO_FILE

src/mac/f9/f9_init.c

@@ -45,12 +45,12 @@ int f9_init(f9_state *f9, int cipher, const unsigned char *key, unsigned long ke
    if ((err = cipher_descriptor[cipher].setup(key, keylen, 0, &f9->key)) != CRYPT_OK) {
       goto done;
    }
-   
+
    /* make the second key */
    for (x = 0; (unsigned)x < keylen; x++) {
       f9->akey[x] = key[x] ^ 0xAA;
    }
- 
+
    /* setup struct */
    zeromem(f9->IV,  cipher_descriptor[cipher].block_length);
    zeromem(f9->ACC, cipher_descriptor[cipher].block_length);

src/mac/f9/f9_memory.c

@@ -17,7 +17,7 @@
 
 #ifdef LTC_F9_MODE
 
-/** f9-MAC a block of memory 
+/** f9-MAC a block of memory
   @param cipher     Index of cipher to use
   @param key        [in]  Secret key
   @param keylen     Length of key in octets
@@ -27,7 +27,7 @@
   @param outlen     [in/out] Output size and final tag size
   Return CRYPT_OK on success.
 */
-int f9_memory(int cipher, 
+int f9_memory(int cipher,
                const unsigned char *key, unsigned long keylen,
                const unsigned char *in,  unsigned long inlen,
                      unsigned char *out, unsigned long *outlen)

src/mac/f9/f9_memory_multi.c

@@ -11,7 +11,7 @@
 #include "tomcrypt.h"
 #include <stdarg.h>
 
-/** 
+/**
   @file f9_memory_multi.c
   f9 support, process multiple blocks of memory, Tom St Denis
 */
@@ -19,7 +19,7 @@
 #ifdef LTC_F9_MODE
 
 /**
-   f9 multiple blocks of memory 
+   f9 multiple blocks of memory
    @param cipher    The index of the desired cipher
    @param key       The secret key
    @param keylen    The length of the secret key (octets)
@@ -30,7 +30,7 @@
    @param ...       tuples of (data,len) pairs to f9, terminated with a (NULL,x) (x=don't care)
    @return CRYPT_OK if successful
 */
-int f9_memory_multi(int cipher, 
+int f9_memory_multi(int cipher,
                 const unsigned char *key, unsigned long keylen,
                       unsigned char *out, unsigned long *outlen,
                 const unsigned char *in,  unsigned long inlen, ...)
@@ -57,7 +57,7 @@ int f9_memory_multi(int cipher,
       goto LBL_ERR;
    }
    va_start(args, inlen);
-   curptr = in; 
+   curptr = in;
    curlen = inlen;
    for (;;) {
       /* process buf */
@@ -80,7 +80,7 @@ LBL_ERR:
 #endif
    XFREE(f9);
    va_end(args);
-   return err;   
+   return err;
 }
 
 #endif

src/mac/f9/f9_process.c

@@ -53,21 +53,21 @@ int f9_process(f9_state *f9, const unsigned char *in, unsigned long inlen)
            in    += f9->blocksize;
            inlen -= f9->blocksize;
        }
-  }
+   }
 #endif
 
    while (inlen) {
-     if (f9->buflen == f9->blocksize) {
+      if (f9->buflen == f9->blocksize) {
          cipher_descriptor[f9->cipher].ecb_encrypt(f9->IV, f9->IV, &f9->key);
          for (x = 0; x < f9->blocksize; x++) {
             f9->ACC[x] ^= f9->IV[x];
          }
          f9->buflen = 0;
-     }
+      }
-     f9->IV[f9->buflen++] ^= *in++;
+      f9->IV[f9->buflen++] ^= *in++;
-     --inlen;
+      --inlen;
-  }
+   }
-  return CRYPT_OK;
+   return CRYPT_OK;
 }
 
 #endif

src/mac/f9/f9_test.c

@@ -12,7 +12,7 @@
 
 /**
   @file f9_test.c
-  f9 Support, Test F9 mode 
+  f9 Support, Test F9 mode
 */
 
 #ifdef LTC_F9_MODE
@@ -39,7 +39,7 @@ int f9_test(void)
 {
    105,
    { 0x83, 0xFD, 0x23, 0xA2, 0x44, 0xA7, 0x4C, 0xF3, 0x58, 0xDA, 0x30, 0x19, 0xF1, 0x72, 0x26, 0x35 },
-   { 0x36, 0xAF, 0x61, 0x44, 0x4F, 0x30, 0x2A, 0xD2, 
+   { 0x36, 0xAF, 0x61, 0x44, 0x4F, 0x30, 0x2A, 0xD2,
      0x35, 0xC6, 0x87, 0x16, 0x63, 0x3C, 0x66, 0xFB, 0x75, 0x0C, 0x26, 0x68, 0x65, 0xD5, 0x3C, 0x11, 0xEA, 0x05, 0xB1, 0xE9, 0xFA, 0x49, 0xC8, 0x39, 0x8D, 0x48, 0xE1, 0xEF, 0xA5, 0x90, 0x9D, 0x39,
      0x47, 0x90, 0x28, 0x37, 0xF5, 0xAE, 0x96, 0xD5, 0xA0, 0x5B, 0xC8, 0xD6, 0x1C, 0xA8, 0xDB, 0xEF, 0x1B, 0x13, 0xA4, 0xB4, 0xAB, 0xFE, 0x4F, 0xB1, 0x00, 0x60, 0x45, 0xB6, 0x74, 0xBB, 0x54, 0x72,
      0x93, 0x04, 0xC3, 0x82, 0xBE, 0x53, 0xA5, 0xAF, 0x05, 0x55, 0x61, 0x76, 0xF6, 0xEA, 0xA2, 0xEF, 0x1D, 0x05, 0xE4, 0xB0, 0x83, 0x18, 0x1E, 0xE6, 0x74, 0xCD, 0xA5, 0xA4, 0x85, 0xF7, 0x4D, 0x7A,

src/mac/pelican/pelican_memory.c

@@ -10,9 +10,9 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pelican_memory.c
-   Pelican MAC, MAC a block of memory, by Tom St Denis 
+   Pelican MAC, MAC a block of memory, by Tom St Denis
 */
 
 #ifdef LTC_PELICAN
@@ -23,7 +23,7 @@
   @param keylen   The length of the key (octets)
   @param in       The input to MAC
   @param inlen    The length of the input (octets)
-  @param out      [out] The output TAG 
+  @param out      [out] The output TAG
   @return CRYPT_OK on success
 */
 int pelican_memory(const unsigned char *key, unsigned long keylen,
@@ -34,7 +34,7 @@ int pelican_memory(const unsigned char *key, unsigned long keylen,
    int err;
 
    pel = XMALLOC(sizeof(*pel));
-   if (pel == NULL) { 
+   if (pel == NULL) {
       return CRYPT_MEM;
    }
 
@@ -47,7 +47,7 @@ int pelican_memory(const unsigned char *key, unsigned long keylen,
       return err;
    }
    err = pelican_done(pel, out);
-   XFREE(pel); 
+   XFREE(pel);
    return err;
 }
 

src/mac/pelican/pelican_test.c

@@ -10,9 +10,9 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pelican_test.c
-   Pelican MAC, test, by Tom St Denis 
+   Pelican MAC, test, by Tom St Denis
 */
 
 #ifdef LTC_PELICAN
@@ -31,7 +31,7 @@ int pelican_test(void)
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
    { 0 },
-   { 0xeb, 0x58, 0x37, 0x15, 0xf8, 0x34, 0xde, 0xe5, 
+   { 0xeb, 0x58, 0x37, 0x15, 0xf8, 0x34, 0xde, 0xe5,
      0xa4, 0xd1, 0x6e, 0xe4, 0xb9, 0xd7, 0x76, 0x0e, },
    16, 0
 },
@@ -41,7 +41,7 @@ int pelican_test(void)
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
    { 0x00, 0x01, 0x02 },
-   { 0x1c, 0x97, 0x40, 0x60, 0x6c, 0x58, 0x17, 0x2d, 
+   { 0x1c, 0x97, 0x40, 0x60, 0x6c, 0x58, 0x17, 0x2d,
      0x03, 0x94, 0x19, 0x70, 0x81, 0xc4, 0x38, 0x54, },
    16, 3
 },
@@ -52,7 +52,7 @@ int pelican_test(void)
      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
    { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
-   { 0x03, 0xcc, 0x46, 0xb8, 0xac, 0xa7, 0x9c, 0x36, 
+   { 0x03, 0xcc, 0x46, 0xb8, 0xac, 0xa7, 0x9c, 0x36,
      0x1e, 0x8c, 0x6e, 0xa6, 0x7b, 0x89, 0x32, 0x49, },
    16, 16
 },
@@ -65,7 +65,7 @@ int pelican_test(void)
      0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
-   { 0x89, 0xcc, 0x36, 0x58, 0x1b, 0xdd, 0x4d, 0xb5, 
+   { 0x89, 0xcc, 0x36, 0x58, 0x1b, 0xdd, 0x4d, 0xb5,
      0x78, 0xbb, 0xac, 0xf0, 0xff, 0x8b, 0x08, 0x15, },
    16, 32
 },
@@ -79,7 +79,7 @@ int pelican_test(void)
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
      0x20, 0x21, 0x23 },
-   { 0x4a, 0x7d, 0x45, 0x4d, 0xcd, 0xb5, 0xda, 0x8d, 
+   { 0x4a, 0x7d, 0x45, 0x4d, 0xcd, 0xb5, 0xda, 0x8d,
      0x48, 0x78, 0x16, 0x48, 0x5d, 0x45, 0x95, 0x99, },
    16, 35
 },
@@ -87,8 +87,8 @@ int pelican_test(void)
    int x, err;
    unsigned char out[16];
    pelican_state pel;
-   
+
-   for (x = 0; x < (int)(sizeof(tests)/sizeof(tests[0])); x++) { 
+   for (x = 0; x < (int)(sizeof(tests)/sizeof(tests[0])); x++) {
        if ((err = pelican_init(&pel, tests[x].K, tests[x].keylen)) != CRYPT_OK) {
           return err;
        }

src/mac/pmac/pmac_done.c

@@ -10,9 +10,9 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
   @file pmac_done.c
-  PMAC implementation, terminate a session, by Tom St Denis 
+  PMAC implementation, terminate a session, by Tom St Denis
 */
 
 #ifdef LTC_PMAC

src/mac/pmac/pmac_file.c

@@ -10,15 +10,15 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pmac_file.c
-   PMAC implementation, process a file, by Tom St Denis 
+   PMAC implementation, process a file, by Tom St Denis
 */
 
 #ifdef LTC_PMAC
 
 /**
-   PMAC a file 
+   PMAC a file
    @param cipher       The index of the cipher desired
    @param key          The secret key
    @param keylen       The length of the secret key (octets)
@@ -27,9 +27,9 @@
    @param outlen       [in/out] Max size and resulting size of the authentication tag
    @return CRYPT_OK if successful, CRYPT_NOP if file support has been disabled
 */
-int pmac_file(int cipher, 
+int pmac_file(int cipher,
               const unsigned char *key, unsigned long keylen,
-              const char *filename, 
+              const char *filename,
                     unsigned char *out, unsigned long *outlen)
 {
 #ifdef LTC_NO_FILE

src/mac/pmac/pmac_init.c

@@ -110,37 +110,37 @@ int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned l
        }
     }
 
-    /* find Lr = L / x */
+   /* find Lr = L / x */
-    m = L[pmac->block_len-1] & 1;
+   m = L[pmac->block_len-1] & 1;
 
-    /* shift right */
+   /* shift right */
-    for (x = pmac->block_len - 1; x > 0; x--) {
+   for (x = pmac->block_len - 1; x > 0; x--) {
-        pmac->Lr[x] = ((L[x] >> 1) | (L[x-1] << 7)) & 255;
+      pmac->Lr[x] = ((L[x] >> 1) | (L[x-1] << 7)) & 255;
-    }
+   }
-    pmac->Lr[0] = L[0] >> 1;
+   pmac->Lr[0] = L[0] >> 1;
 
-    if (m == 1) {
+   if (m == 1) {
-       for (x = 0; x < pmac->block_len; x++) {
+      for (x = 0; x < pmac->block_len; x++) {
-           pmac->Lr[x] ^= polys[poly].poly_div[x];
+         pmac->Lr[x] ^= polys[poly].poly_div[x];
-       }
+      }
-    }
+   }
 
-    /* zero buffer, counters, etc... */
+   /* zero buffer, counters, etc... */
-    pmac->block_index = 1;
+   pmac->block_index = 1;
-    pmac->cipher_idx  = cipher;
+   pmac->cipher_idx  = cipher;
-    pmac->buflen      = 0;
+   pmac->buflen      = 0;
-    zeromem(pmac->block,    sizeof(pmac->block));
+   zeromem(pmac->block,    sizeof(pmac->block));
-    zeromem(pmac->Li,       sizeof(pmac->Li));
+   zeromem(pmac->Li,       sizeof(pmac->Li));
-    zeromem(pmac->checksum, sizeof(pmac->checksum));
+   zeromem(pmac->checksum, sizeof(pmac->checksum));
-    err = CRYPT_OK;
+   err = CRYPT_OK;
 error:
 #ifdef LTC_CLEAN_STACK
-    zeromem(L, pmac->block_len);
+   zeromem(L, pmac->block_len);
 #endif
 
-    XFREE(L);
+   XFREE(L);
 
-    return err;
+   return err;
 }
 
 #endif

src/mac/pmac/pmac_memory.c

@@ -10,9 +10,9 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pmac_memory.c
-   PMAC implementation, process a block of memory, by Tom St Denis 
+   PMAC implementation, process a block of memory, by Tom St Denis
 */
 
 #ifdef LTC_PMAC
@@ -28,7 +28,7 @@
    @param outlen   [in/out] The max size and resulting size of the authentication tag
    @return CRYPT_OK if successful
 */
-int pmac_memory(int cipher, 
+int pmac_memory(int cipher,
                 const unsigned char *key, unsigned long keylen,
                 const unsigned char *in, unsigned long inlen,
                       unsigned char *out, unsigned long *outlen)
@@ -46,7 +46,7 @@ int pmac_memory(int cipher,
    if (pmac == NULL) {
       return CRYPT_MEM;
    }
-   
+
    if ((err = pmac_init(pmac, cipher, key, keylen)) != CRYPT_OK) {
       goto LBL_ERR;
    }
@@ -64,7 +64,7 @@ LBL_ERR:
 #endif
 
    XFREE(pmac);
-   return err;   
+   return err;
 }
 
 #endif

src/mac/pmac/pmac_memory_multi.c

@@ -11,9 +11,9 @@
 #include "tomcrypt.h"
 #include <stdarg.h>
 
-/** 
+/**
    @file pmac_memory_multi.c
-   PMAC implementation, process multiple blocks of memory, by Tom St Denis 
+   PMAC implementation, process multiple blocks of memory, by Tom St Denis
 */
 
 #ifdef LTC_PMAC
@@ -30,7 +30,7 @@
    @param ...      tuples of (data,len) pairs to PMAC, terminated with a (NULL,x) (x=don't care)
    @return CRYPT_OK if successful
 */
-int pmac_memory_multi(int cipher, 
+int pmac_memory_multi(int cipher,
                 const unsigned char *key, unsigned long  keylen,
                       unsigned char *out, unsigned long *outlen,
                 const unsigned char *in,  unsigned long  inlen, ...)
@@ -51,12 +51,12 @@ int pmac_memory_multi(int cipher,
    if (pmac == NULL) {
       return CRYPT_MEM;
    }
-   
+
    if ((err = pmac_init(pmac, cipher, key, keylen)) != CRYPT_OK) {
       goto LBL_ERR;
    }
    va_start(args, inlen);
-   curptr = in; 
+   curptr = in;
    curlen = inlen;
    for (;;) {
       /* process buf */
@@ -79,7 +79,7 @@ LBL_ERR:
 #endif
    XFREE(pmac);
    va_end(args);
-   return err;   
+   return err;
 }
 
 #endif

src/mac/pmac/pmac_ntz.c

@@ -10,9 +10,9 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pmac_ntz.c
-   PMAC implementation, internal function, by Tom St Denis 
+   PMAC implementation, internal function, by Tom St Denis
 */
 
 #ifdef LTC_PMAC

src/mac/pmac/pmac_shift_xor.c

@@ -10,9 +10,9 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pmac_shift_xor.c
-   PMAC implementation, internal function, by Tom St Denis 
+   PMAC implementation, internal function, by Tom St Denis
 */
 
 #ifdef LTC_PMAC

src/mac/pmac/pmac_test.c

@@ -10,15 +10,15 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
    @file pmac_test.c
-   PMAC implementation, self-test, by Tom St Denis 
+   PMAC implementation, self-test, by Tom St Denis
 */
 
 
 #ifdef LTC_PMAC
 
-/** 
+/**
    Test the LTC_OMAC implementation
    @return CRYPT_OK if successful, CRYPT_NOP if testing has been disabled
 */
@@ -27,7 +27,7 @@ int pmac_test(void)
 #if !defined(LTC_TEST)
     return CRYPT_NOP;
 #else
-    static const struct { 
+    static const struct {
         int msglen;
         unsigned char key[16], msg[34], tag[16];
     } tests[] = {
@@ -125,7 +125,7 @@ int pmac_test(void)
    unsigned long len;
    unsigned char outtag[MAXBLOCKSIZE];
 
-    /* AES can be under rijndael or aes... try to find it */ 
+    /* AES can be under rijndael or aes... try to find it */
     if ((idx = find_cipher("aes")) == -1) {
        if ((idx = find_cipher("rijndael")) == -1) {
           return CRYPT_NOP;
@@ -137,7 +137,7 @@ int pmac_test(void)
         if ((err = pmac_memory(idx, tests[x].key, 16, tests[x].msg, tests[x].msglen, outtag, &len)) != CRYPT_OK) {
            return err;
         }
-        
+
         if (XMEMCMP(outtag, tests[x].tag, len)) {
 #if 0
            unsigned long y;
@@ -150,15 +150,15 @@ int pmac_test(void)
 #endif
            return CRYPT_FAIL_TESTVECTOR;
         }
-     }
+    }
-     return CRYPT_OK;
+    return CRYPT_OK;
 #endif /* LTC_TEST */
 }
 
 #endif /* PMAC_MODE */
 
 
- 
+
 
 /* $Source$ */
 /* $Revision$ */

src/mac/xcbc/xcbc_done.c

@@ -62,7 +62,7 @@ int xcbc_done(xcbc_state *xcbc, unsigned char *out, unsigned long *outlen)
       out[x] = xcbc->IV[x];
    }
    *outlen = x;
-  
+
 #ifdef LTC_CLEAN_STACK
    zeromem(xcbc, sizeof(*xcbc));
 #endif

src/mac/xcbc/xcbc_file.c

@@ -10,7 +10,7 @@
  */
 #include "tomcrypt.h"
 
-/** 
+/**
   @file xcbc_file.c
   XCBC support, process a file, Tom St Denis
 */
@@ -27,9 +27,9 @@
    @param outlen   [in/out] The max size and resulting size of the authentication tag
    @return CRYPT_OK if successful, CRYPT_NOP if file support has been disabled
 */
-int xcbc_file(int cipher, 
+int xcbc_file(int cipher,
               const unsigned char *key, unsigned long keylen,
-              const char *filename, 
+              const char *filename,
                     unsigned char *out, unsigned long *outlen)
 {
 #ifdef LTC_NO_FILE

src/mac/xcbc/xcbc_init.c

@@ -71,7 +71,7 @@ int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned l
       if ((err = cipher_descriptor[cipher].setup(key, keylen, 0, skey)) != CRYPT_OK) {
          goto done;
       }
-   
+
       /* make the three keys */
       for (y = 0; y < 3; y++) {
         for (x = 0; x < cipher_descriptor[cipher].block_length; x++) {
@@ -80,10 +80,10 @@ int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned l
         cipher_descriptor[cipher].ecb_encrypt(xcbc->K[y], xcbc->K[y], skey);
       }
    }
-     
+
    /* setup K1 */
    err = cipher_descriptor[cipher].setup(xcbc->K[0], k1, 0, &xcbc->key);
- 
+
    /* setup struct */
    zeromem(xcbc->IV, cipher_descriptor[cipher].block_length);
    xcbc->blocksize = cipher_descriptor[cipher].block_length;
@@ -91,7 +91,7 @@ int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned l
    xcbc->buflen    = 0;
 done:
    cipher_descriptor[cipher].done(skey);
-   if (skey != NULL) { 
+   if (skey != NULL) {
 #ifdef LTC_CLEAN_STACK
       zeromem(skey, sizeof(*skey));
 #endif

src/mac/xcbc/xcbc_memory.c

@@ -17,7 +17,7 @@
 
 #ifdef LTC_XCBC
 
-/** XCBC-MAC a block of memory 
+/** XCBC-MAC a block of memory
   @param cipher     Index of cipher to use
   @param key        [in]  Secret key
   @param keylen     Length of key in octets
@@ -27,7 +27,7 @@
   @param outlen     [in/out] Output size and final tag size
   Return CRYPT_OK on success.
 */
-int xcbc_memory(int cipher, 
+int xcbc_memory(int cipher,
                const unsigned char *key, unsigned long keylen,
                const unsigned char *in,  unsigned long inlen,
                      unsigned char *out, unsigned long *outlen)

src/mac/xcbc/xcbc_memory_multi.c

@@ -11,7 +11,7 @@
 #include "tomcrypt.h"
 #include <stdarg.h>
 
-/** 
+/**
   @file xcbc_memory_multi.c
   XCBC support, process multiple blocks of memory, Tom St Denis
 */
@@ -19,7 +19,7 @@
 #ifdef LTC_XCBC
 
 /**
-   XCBC multiple blocks of memory 
+   XCBC multiple blocks of memory
    @param cipher    The index of the desired cipher
    @param key       The secret key
    @param keylen    The length of the secret key (octets)
@@ -30,7 +30,7 @@
    @param ...       tuples of (data,len) pairs to XCBC, terminated with a (NULL,x) (x=don't care)
    @return CRYPT_OK if successful
 */
-int xcbc_memory_multi(int cipher, 
+int xcbc_memory_multi(int cipher,
                 const unsigned char *key, unsigned long keylen,
                       unsigned char *out, unsigned long *outlen,
                 const unsigned char *in,  unsigned long inlen, ...)
@@ -57,7 +57,7 @@ int xcbc_memory_multi(int cipher,
       goto LBL_ERR;
    }
    va_start(args, inlen);
-   curptr = in; 
+   curptr = in;
    curlen = inlen;
    for (;;) {
       /* process buf */
@@ -80,7 +80,7 @@ LBL_ERR:
 #endif
    XFREE(xcbc);
    va_end(args);
-   return err;   
+   return err;
 }
 
 #endif

src/mac/xcbc/xcbc_process.c

@@ -53,18 +53,18 @@ int xcbc_process(xcbc_state *xcbc, const unsigned char *in, unsigned long inlen)
            in    += xcbc->blocksize;
            inlen -= xcbc->blocksize;
        }
-  }
+   }
 #endif
 
    while (inlen) {
-     if (xcbc->buflen == xcbc->blocksize) {
+      if (xcbc->buflen == xcbc->blocksize) {
          cipher_descriptor[xcbc->cipher].ecb_encrypt(xcbc->IV, xcbc->IV, &xcbc->key);
          xcbc->buflen = 0;
-     }
+      }
-     xcbc->IV[xcbc->buflen++] ^= *in++;
+      xcbc->IV[xcbc->buflen++] ^= *in++;
-     --inlen;
+      --inlen;
-  }
+   }
-  return CRYPT_OK;
+   return CRYPT_OK;
 }
 
 #endif

src/mac/xcbc/xcbc_test.c

@@ -31,64 +31,64 @@ int xcbc_test(void)
    } tests[] = {
 {
    0,
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
    { 0 },
 
-   { 0x75, 0xf0, 0x25, 0x1d, 0x52, 0x8a, 0xc0, 0x1c, 
+   { 0x75, 0xf0, 0x25, 0x1d, 0x52, 0x8a, 0xc0, 0x1c,
      0x45, 0x73, 0xdf, 0xd5, 0x84, 0xd7, 0x9f, 0x29 }
 },
 
 {
    3,
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
    { 0x00, 0x01, 0x02 },
 
-   { 0x5b, 0x37, 0x65, 0x80, 0xae, 0x2f, 0x19, 0xaf, 
+   { 0x5b, 0x37, 0x65, 0x80, 0xae, 0x2f, 0x19, 0xaf,
      0xe7, 0x21, 0x9c, 0xee, 0xf1, 0x72, 0x75, 0x6f }
 },
 
 {
    16,
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
-   { 0xd2, 0xa2, 0x46, 0xfa, 0x34, 0x9b, 0x68, 0xa7, 
+   { 0xd2, 0xa2, 0x46, 0xfa, 0x34, 0x9b, 0x68, 0xa7,
      0x99, 0x98, 0xa4, 0x39, 0x4f, 0xf7, 0xa2, 0x63 }
 },
 
 {
    32,
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
 
-   { 0xf5, 0x4f, 0x0e, 0xc8, 0xd2, 0xb9, 0xf3, 0xd3, 
+   { 0xf5, 0x4f, 0x0e, 0xc8, 0xd2, 0xb9, 0xf3, 0xd3,
      0x68, 0x07, 0x73, 0x4b, 0xd5, 0x28, 0x3f, 0xd4 }
 },
 
 {
    34,
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
      0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f },
 
-   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
+   { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
      0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
      0x20, 0x21 },
 
-   { 0xbe, 0xcb, 0xb3, 0xbc, 0xcd, 0xb5, 0x18, 0xa3, 
+   { 0xbe, 0xcb, 0xb3, 0xbc, 0xcd, 0xb5, 0x18, 0xa3,
      0x06, 0x77, 0xd5, 0x48, 0x1f, 0xb6, 0xb4, 0xd8 },
 },
 
@@ -99,7 +99,7 @@ int xcbc_test(void)
   unsigned long taglen;
   int err, x, idx;
 
-  /* AES can be under rijndael or aes... try to find it */ 
+  /* AES can be under rijndael or aes... try to find it */
   if ((idx = find_cipher("aes")) == -1) {
      if ((idx = find_cipher("rijndael")) == -1) {
         return CRYPT_NOP;

src/math/rand_prime.c

@@ -15,7 +15,7 @@
 /**
   @file rand_prime.c
   Generate a random prime, Tom St Denis
-*/  
+*/
 
 #define USE_BBS 1
 
@@ -35,13 +35,13 @@ int rand_prime(void *N, long len, prng_state *prng, int wprng)
    }
 
    /* allow sizes between 2 and 512 bytes for a prime size */
-   if (len < 2 || len > 512) { 
+   if (len < 2 || len > 512) {
       return CRYPT_INVALID_PRIME_SIZE;
    }
-   
+
    /* valid PRNG? Better be! */
    if ((err = prng_is_valid(wprng)) != CRYPT_OK) {
-      return err; 
+      return err;
    }
 
    /* allocate buffer to work with */
@@ -60,7 +60,7 @@ int rand_prime(void *N, long len, prng_state *prng, int wprng)
       /* munge bits */
       buf[0]     |= 0x80 | 0x40;
       buf[len-1] |= 0x01 | ((type & USE_BBS) ? 0x02 : 0x00);
- 
+
       /* load value */
       if ((err = mp_read_unsigned_bin(N, buf, len)) != CRYPT_OK) {
          XFREE(buf);
@@ -81,7 +81,7 @@ int rand_prime(void *N, long len, prng_state *prng, int wprng)
    XFREE(buf);
    return CRYPT_OK;
 }
-      
+
 #endif /* LTC_NO_MATH */
 
 

src/misc/adler32.c

@@ -89,16 +89,16 @@ void adler32_finish(adler32_state *ctx, void *hash, unsigned long size)
    switch (size) {
       default:
          h[3] = ctx->s[0] & 0x0ff;
-         /* no break */
+         /* FALLTHROUGH */
       case 3:
          h[2] = (ctx->s[0] >> 8) & 0x0ff;
-         /* no break */
+         /* FALLTHROUGH */
       case 2:
          h[1] = ctx->s[1] & 0x0ff;
-         /* no break */
+         /* FALLTHROUGH */
       case 1:
          h[0] = (ctx->s[1] >> 8) & 0x0ff;
-         /* no break */
+         /* FALLTHROUGH */
       case 0:
          ;
    }

src/misc/base64/base64_encode.c

@@ -20,12 +20,12 @@
 #if defined(LTC_BASE64) || defined (LTC_BASE64_URL)
 
 #if defined(LTC_BASE64)
-static const char *codes_base64 =
+static const char * const codes_base64 =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 #endif /* LTC_BASE64 */
 
 #if defined(LTC_BASE64_URL)
-static const char *codes_base64url =
+static const char * const codes_base64url =
 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 #endif /* LTC_BASE64_URL */
 

src/misc/crypt/crypt_find_cipher_any.c

@@ -16,7 +16,7 @@
 */
 
 /**
-   Find a cipher flexibly.  First by name then if not present by block and key size 
+   Find a cipher flexibly.  First by name then if not present by block and key size
    @param name        The name of the cipher desired
    @param blocklen    The minimum length of the block cipher desired (octets)
    @param keylen      The minimum length of the key size desired (octets)

src/misc/crypt/crypt_find_hash_any.c

@@ -16,7 +16,7 @@
 */
 
 /**
-   Find a hash flexibly.  First by name then if not present by digest size 
+   Find a hash flexibly.  First by name then if not present by digest size
    @param name        The name of the hash desired
    @param digestlen   The minimum length of the digest size (octets)
    @return >= 0 if found, -1 if not present

src/misc/crypt/crypt_fsa.c

@@ -14,7 +14,7 @@
 /**
   @file crypt_fsa.c
   LibTomCrypt FULL SPEED AHEAD!, Tom St Denis
-*/  
+*/
 
 /* format is ltc_mp, cipher_desc, [cipher_desc], NULL, hash_desc, [hash_desc], NULL, prng_desc, [prng_desc], NULL */
 int crypt_fsa(void *mp, ...)
@@ -26,7 +26,7 @@ int crypt_fsa(void *mp, ...)
    if (mp != NULL) {
       XMEMCPY(&ltc_mp, mp, sizeof(ltc_mp));
    }
-   
+
    while ((p = va_arg(args, void*)) != NULL) {
       if (register_cipher(p) == -1) {
          va_end(args);
@@ -49,7 +49,7 @@ int crypt_fsa(void *mp, ...)
    }
 
    va_end(args);
-   return CRYPT_OK;   
+   return CRYPT_OK;
 }
 
 

src/misc/crypt/crypt_hash_descriptor.c

@@ -12,7 +12,7 @@
 
 /**
   @file crypt_hash_descriptor.c
-  Stores the hash descriptor table, Tom St Denis  
+  Stores the hash descriptor table, Tom St Denis
 */
 
 struct ltc_hash_descriptor hash_descriptor[TAB_SIZE] = {

src/misc/crypt/crypt_hash_is_valid.c

@@ -13,7 +13,7 @@
 /**
   @file crypt_hash_is_valid.c
   Determine if hash is valid, Tom St Denis
-*/  
+*/
 
 /*
    Test if a hash index is valid

src/misc/crypt/crypt_prng_descriptor.c

@@ -13,7 +13,7 @@
 /**
   @file crypt_prng_descriptor.c
   Stores the PRNG descriptors, Tom St Denis
-*/  
+*/
 struct ltc_prng_descriptor prng_descriptor[TAB_SIZE] = {
 { NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
 };

src/misc/crypt/crypt_register_prng.c

@@ -14,7 +14,7 @@
   @file crypt_register_prng.c
   Register a PRNG, Tom St Denis
 */
-  
+
 /**
    Register a PRNG with the descriptor table
    @param prng   The PRNG you wish to register

src/misc/error_to_string.c

@@ -16,7 +16,7 @@
   Convert error codes to ASCII strings, Tom St Denis
 */
 
-static const char *err_2_str[] =
+static const char * const err_2_str[] =
 {
    "CRYPT_OK",
    "CRYPT_ERROR",
@@ -68,7 +68,7 @@ const char *error_to_string(int err)
       return "Invalid error code.";
    } else {
       return err_2_str[err];
-   }   
+   }
 }
 
 

src/modes/cbc/cbc_decrypt.c

@@ -69,17 +69,17 @@ int cbc_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, s
 
          /* xor IV against plaintext */
          #if defined(LTC_FAST)
-        for (x = 0; x < cbc->blocklen; x += sizeof(LTC_FAST_TYPE)) {
+         for (x = 0; x < cbc->blocklen; x += sizeof(LTC_FAST_TYPE)) {
             tmpy = *((LTC_FAST_TYPE*)((unsigned char *)cbc->IV + x)) ^ *((LTC_FAST_TYPE*)((unsigned char *)tmp + x));
-       *((LTC_FAST_TYPE*)((unsigned char *)cbc->IV + x)) = *((LTC_FAST_TYPE*)((unsigned char *)ct + x));
+            *((LTC_FAST_TYPE*)((unsigned char *)cbc->IV + x)) = *((LTC_FAST_TYPE*)((unsigned char *)ct + x));
-       *((LTC_FAST_TYPE*)((unsigned char *)pt + x)) = tmpy;
+            *((LTC_FAST_TYPE*)((unsigned char *)pt + x)) = tmpy;
-        }
+         }
     #else
-            for (x = 0; x < cbc->blocklen; x++) {
+         for (x = 0; x < cbc->blocklen; x++) {
-               tmpy       = tmp[x] ^ cbc->IV[x];
+            tmpy       = tmp[x] ^ cbc->IV[x];
-               cbc->IV[x] = ct[x];
+            cbc->IV[x] = ct[x];
-               pt[x]      = tmpy;
+            pt[x]      = tmpy;
-            }
+         }
     #endif
 
          ct  += cbc->blocklen;

src/modes/cbc/cbc_done.c

@@ -33,7 +33,7 @@ int cbc_done(symmetric_CBC *cbc)
    return CRYPT_OK;
 }
 
-   
+
 
 #endif
 

src/modes/cbc/cbc_encrypt.c

@@ -58,13 +58,13 @@ int cbc_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, s
       while (len) {
          /* xor IV against plaintext */
          #if defined(LTC_FAST)
-        for (x = 0; x < cbc->blocklen; x += sizeof(LTC_FAST_TYPE)) {
+         for (x = 0; x < cbc->blocklen; x += sizeof(LTC_FAST_TYPE)) {
             *((LTC_FAST_TYPE*)((unsigned char *)cbc->IV + x)) ^= *((LTC_FAST_TYPE*)((unsigned char *)pt + x));
-        }
+         }
     #else
-            for (x = 0; x < cbc->blocklen; x++) {
+         for (x = 0; x < cbc->blocklen; x++) {
-               cbc->IV[x] ^= pt[x];
+            cbc->IV[x] ^= pt[x];
-            }
+         }
     #endif
 
          /* encrypt */
@@ -72,21 +72,21 @@ int cbc_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, s
             return err;
          }
 
-        /* store IV [ciphertext] for a future block */
+         /* store IV [ciphertext] for a future block */
          #if defined(LTC_FAST)
-        for (x = 0; x < cbc->blocklen; x += sizeof(LTC_FAST_TYPE)) {
+         for (x = 0; x < cbc->blocklen; x += sizeof(LTC_FAST_TYPE)) {
             *((LTC_FAST_TYPE*)((unsigned char *)cbc->IV + x)) = *((LTC_FAST_TYPE*)((unsigned char *)ct + x));
-        }
+         }
     #else
-             for (x = 0; x < cbc->blocklen; x++) {
+         for (x = 0; x < cbc->blocklen; x++) {
-                cbc->IV[x] = ct[x];
+            cbc->IV[x] = ct[x];
-             }
+         }
     #endif
 
-        ct  += cbc->blocklen;
+         ct  += cbc->blocklen;
-        pt  += cbc->blocklen;
+         pt  += cbc->blocklen;
-        len -= cbc->blocklen;
+         len -= cbc->blocklen;
-     }
+      }
    }
    return CRYPT_OK;
 }

src/modes/cbc/cbc_setiv.c

@@ -36,7 +36,7 @@ int cbc_setiv(const unsigned char *IV, unsigned long len, symmetric_CBC *cbc)
    return CRYPT_OK;
 }
 
-#endif 
+#endif
 
 
 /* $Source$ */

src/modes/cbc/cbc_start.c

@@ -21,17 +21,17 @@
    Initialize a CBC context
    @param cipher      The index of the cipher desired
    @param IV          The initial vector
-   @param key         The secret key 
+   @param key         The secret key
    @param keylen      The length of the secret key (octets)
    @param num_rounds  Number of rounds in the cipher desired (0 for default)
    @param cbc         The CBC state to initialize
    @return CRYPT_OK if successful
 */
-int cbc_start(int cipher, const unsigned char *IV, const unsigned char *key, 
+int cbc_start(int cipher, const unsigned char *IV, const unsigned char *key,
               int keylen, int num_rounds, symmetric_CBC *cbc)
 {
    int x, err;
- 
+
    LTC_ARGCHK(IV != NULL);
    LTC_ARGCHK(key != NULL);
    LTC_ARGCHK(cbc != NULL);

src/modes/cfb/cfb_decrypt.c

@@ -52,7 +52,7 @@ int cfb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, s
        }
        cfb->pad[cfb->padlen] = *ct;
        *pt = *ct ^ cfb->IV[cfb->padlen];
-       ++pt; 
+       ++pt;
        ++ct;
        ++(cfb->padlen);
    }

src/modes/cfb/cfb_done.c

@@ -33,7 +33,7 @@ int cfb_done(symmetric_CFB *cfb)
    return CRYPT_OK;
 }
 
-   
+
 
 #endif
 

src/modes/cfb/cfb_encrypt.c

@@ -51,7 +51,7 @@ int cfb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, s
           cfb->padlen = 0;
        }
        cfb->pad[cfb->padlen] = (*ct = *pt ^ cfb->IV[cfb->padlen]);
-       ++pt; 
+       ++pt;
        ++ct;
        ++(cfb->padlen);
    }

src/modes/cfb/cfb_setiv.c

@@ -13,7 +13,7 @@
 /**
   @file cfb_setiv.c
   CFB implementation, set IV, Tom St Denis
-*/  
+*/
 
 #ifdef LTC_CFB_MODE
 
@@ -27,24 +27,24 @@
 int cfb_setiv(const unsigned char *IV, unsigned long len, symmetric_CFB *cfb)
 {
    int err;
-   
+
    LTC_ARGCHK(IV  != NULL);
    LTC_ARGCHK(cfb != NULL);
 
    if ((err = cipher_is_valid(cfb->cipher)) != CRYPT_OK) {
        return err;
    }
-   
+
    if (len != (unsigned long)cfb->blocklen) {
       return CRYPT_INVALID_ARG;
    }
-      
+
    /* force next block */
    cfb->padlen = 0;
    return cipher_descriptor[cfb->cipher].ecb_encrypt(IV, cfb->IV, &cfb->key);
 }
 
-#endif 
+#endif
 
 
 /* $Source$ */