Mostly indendation changes. Completed the Manifest.

1 files changed, 310 insertions, 302 deletions

diff --git a/cipher/twofish.c b/cipher/twofish.c
index fd3651e8..32589a05 100644
--- a/cipher/twofish.c
+++ b/cipher/twofish.c
@@ -35,7 +35,7 @@
  * for GNU C on a 32-bit system, but it should work almost anywhere.  Loops
  * are unrolled, precomputation tables are used, etc., for maximum speed at
  * some cost in memory consumption. */
-
+
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -566,142 +566,147 @@ static byte calc_sb_tbl[512] = {
 static gcry_err_code_t
 do_twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
 {
-    int i, j, k;
-
-    /* Temporaries for CALC_K. */
-    u32 x, y;
-
-    /* The S vector used to key the S-boxes, split up into individual bytes.
-     * 128-bit keys use only sa through sh; 256-bit use all of them. */
-    byte sa = 0, sb = 0, sc = 0, sd = 0, se = 0, sf = 0, sg = 0, sh = 0;
-    byte si = 0, sj = 0, sk = 0, sl = 0, sm = 0, sn = 0, so = 0, sp = 0;
-
-    /* Temporary for CALC_S. */
-    byte tmp;
-
-    /* Flags for self-test. */
-    static int initialized = 0;
-    static const char *selftest_failed=0;
-
-    /* Check key length. */
-    if( ( ( keylen - 16 ) | 16 ) != 16 )
-	return GPG_ERR_INV_KEYLEN;
-
-    /* Do self-test if necessary. */
-    if (!initialized) {
-       initialized = 1;
-       selftest_failed = selftest ();
-       if( selftest_failed )
-	 log_error("%s\n", selftest_failed );
+  int i, j, k;
+
+  /* Temporaries for CALC_K. */
+  u32 x, y;
+
+  /* The S vector used to key the S-boxes, split up into individual bytes.
+   * 128-bit keys use only sa through sh; 256-bit use all of them. */
+  byte sa = 0, sb = 0, sc = 0, sd = 0, se = 0, sf = 0, sg = 0, sh = 0;
+  byte si = 0, sj = 0, sk = 0, sl = 0, sm = 0, sn = 0, so = 0, sp = 0;
+  
+  /* Temporary for CALC_S. */
+  byte tmp;
+  
+  /* Flags for self-test. */
+  static int initialized = 0;
+  static const char *selftest_failed=0;
+
+  /* Check key length. */
+  if( ( ( keylen - 16 ) | 16 ) != 16 )
+    return GPG_ERR_INV_KEYLEN;
+
+  /* Do self-test if necessary. */
+  if (!initialized)
+    {
+      initialized = 1;
+      selftest_failed = selftest ();
+      if( selftest_failed )
+        log_error("%s\n", selftest_failed );
     }
-    if( selftest_failed )
-       return GPG_ERR_SELFTEST_FAILED;
-
-    /* Compute the first two words of the S vector.  The magic numbers are
-     * the entries of the RS matrix, preprocessed through poly_to_exp.	The
-     * numbers in the comments are the original (polynomial form) matrix
-     * entries. */
-    CALC_S (sa, sb, sc, sd, 0, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
-    CALC_S (sa, sb, sc, sd, 1, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
-    CALC_S (sa, sb, sc, sd, 2, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
-    CALC_S (sa, sb, sc, sd, 3, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
-    CALC_S (sa, sb, sc, sd, 4, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
-    CALC_S (sa, sb, sc, sd, 5, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
-    CALC_S (sa, sb, sc, sd, 6, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
-    CALC_S (sa, sb, sc, sd, 7, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
-    CALC_S (se, sf, sg, sh, 8, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
-    CALC_S (se, sf, sg, sh, 9, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
-    CALC_S (se, sf, sg, sh, 10, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
-    CALC_S (se, sf, sg, sh, 11, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
-    CALC_S (se, sf, sg, sh, 12, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
-    CALC_S (se, sf, sg, sh, 13, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
-    CALC_S (se, sf, sg, sh, 14, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
-    CALC_S (se, sf, sg, sh, 15, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
-
-    if (keylen == 32) { /* 256-bit key */
-	/* Calculate the remaining two words of the S vector */
-	CALC_S (si, sj, sk, sl, 16, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
-	CALC_S (si, sj, sk, sl, 17, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
-	CALC_S (si, sj, sk, sl, 18, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
-	CALC_S (si, sj, sk, sl, 19, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
-	CALC_S (si, sj, sk, sl, 20, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
-	CALC_S (si, sj, sk, sl, 21, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
-	CALC_S (si, sj, sk, sl, 22, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
-	CALC_S (si, sj, sk, sl, 23, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
-	CALC_S (sm, sn, so, sp, 24, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
-	CALC_S (sm, sn, so, sp, 25, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
-	CALC_S (sm, sn, so, sp, 26, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
-	CALC_S (sm, sn, so, sp, 27, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
-	CALC_S (sm, sn, so, sp, 28, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
-	CALC_S (sm, sn, so, sp, 29, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
-	CALC_S (sm, sn, so, sp, 30, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
-	CALC_S (sm, sn, so, sp, 31, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
-
-	/* Compute the S-boxes. */
-	for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 ) {
-	    CALC_SB256_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
+  if( selftest_failed )
+    return GPG_ERR_SELFTEST_FAILED;
+
+  /* Compute the first two words of the S vector.  The magic numbers are
+   * the entries of the RS matrix, preprocessed through poly_to_exp.	The
+   * numbers in the comments are the original (polynomial form) matrix
+   * entries. */
+  CALC_S (sa, sb, sc, sd, 0, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
+  CALC_S (sa, sb, sc, sd, 1, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
+  CALC_S (sa, sb, sc, sd, 2, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
+  CALC_S (sa, sb, sc, sd, 3, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
+  CALC_S (sa, sb, sc, sd, 4, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
+  CALC_S (sa, sb, sc, sd, 5, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
+  CALC_S (sa, sb, sc, sd, 6, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
+  CALC_S (sa, sb, sc, sd, 7, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
+  CALC_S (se, sf, sg, sh, 8, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
+  CALC_S (se, sf, sg, sh, 9, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
+  CALC_S (se, sf, sg, sh, 10, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
+  CALC_S (se, sf, sg, sh, 11, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
+  CALC_S (se, sf, sg, sh, 12, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
+  CALC_S (se, sf, sg, sh, 13, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
+  CALC_S (se, sf, sg, sh, 14, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
+  CALC_S (se, sf, sg, sh, 15, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
+
+  if (keylen == 32)  /* 256-bit key */
+    {
+      /* Calculate the remaining two words of the S vector */
+      CALC_S (si, sj, sk, sl, 16, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
+      CALC_S (si, sj, sk, sl, 17, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
+      CALC_S (si, sj, sk, sl, 18, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
+      CALC_S (si, sj, sk, sl, 19, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
+      CALC_S (si, sj, sk, sl, 20, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
+      CALC_S (si, sj, sk, sl, 21, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
+      CALC_S (si, sj, sk, sl, 22, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
+      CALC_S (si, sj, sk, sl, 23, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
+      CALC_S (sm, sn, so, sp, 24, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
+      CALC_S (sm, sn, so, sp, 25, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
+      CALC_S (sm, sn, so, sp, 26, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
+      CALC_S (sm, sn, so, sp, 27, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
+      CALC_S (sm, sn, so, sp, 28, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
+      CALC_S (sm, sn, so, sp, 29, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
+      CALC_S (sm, sn, so, sp, 30, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
+      CALC_S (sm, sn, so, sp, 31, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
+
+      /* Compute the S-boxes. */
+      for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 )
+        {
+          CALC_SB256_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
 	}
 
-	/* Calculate whitening and round subkeys.  The constants are
-	 * indices of subkeys, preprocessed through q0 and q1. */
-	CALC_K256 (w, 0, 0xA9, 0x75, 0x67, 0xF3);
-	CALC_K256 (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
-	CALC_K256 (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
-	CALC_K256 (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
-	CALC_K256 (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
-	CALC_K256 (k, 2, 0x80, 0xE6, 0x78, 0x6B);
-	CALC_K256 (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
-	CALC_K256 (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
-	CALC_K256 (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
-	CALC_K256 (k, 10, 0x35, 0xD8, 0x98, 0xFD);
-	CALC_K256 (k, 12, 0x18, 0x37, 0xF7, 0x71);
-	CALC_K256 (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
-	CALC_K256 (k, 16, 0x43, 0x30, 0x75, 0x0F);
-	CALC_K256 (k, 18, 0x37, 0xF8, 0x26, 0x1B);
-	CALC_K256 (k, 20, 0xFA, 0x87, 0x13, 0xFA);
-	CALC_K256 (k, 22, 0x94, 0x06, 0x48, 0x3F);
-	CALC_K256 (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
-	CALC_K256 (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
-	CALC_K256 (k, 28, 0x84, 0x8A, 0x54, 0x00);
-	CALC_K256 (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
+      /* Calculate whitening and round subkeys.  The constants are
+       * indices of subkeys, preprocessed through q0 and q1. */
+      CALC_K256 (w, 0, 0xA9, 0x75, 0x67, 0xF3);
+      CALC_K256 (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
+      CALC_K256 (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
+      CALC_K256 (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
+      CALC_K256 (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
+      CALC_K256 (k, 2, 0x80, 0xE6, 0x78, 0x6B);
+      CALC_K256 (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
+      CALC_K256 (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
+      CALC_K256 (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
+      CALC_K256 (k, 10, 0x35, 0xD8, 0x98, 0xFD);
+      CALC_K256 (k, 12, 0x18, 0x37, 0xF7, 0x71);
+      CALC_K256 (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
+      CALC_K256 (k, 16, 0x43, 0x30, 0x75, 0x0F);
+      CALC_K256 (k, 18, 0x37, 0xF8, 0x26, 0x1B);
+      CALC_K256 (k, 20, 0xFA, 0x87, 0x13, 0xFA);
+      CALC_K256 (k, 22, 0x94, 0x06, 0x48, 0x3F);
+      CALC_K256 (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
+      CALC_K256 (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
+      CALC_K256 (k, 28, 0x84, 0x8A, 0x54, 0x00);
+      CALC_K256 (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
     }
-    else {
-	/* Compute the S-boxes. */
-	for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 ) {
-	    CALC_SB_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
-	}
-
-	/* Calculate whitening and round subkeys.  The constants are
-	 * indices of subkeys, preprocessed through q0 and q1. */
-	CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3);
-	CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
-	CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
-	CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
-	CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
-	CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B);
-	CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
-	CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
-	CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
-	CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD);
-	CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71);
-	CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
-	CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F);
-	CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B);
-	CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA);
-	CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F);
-	CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
-	CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
-	CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00);
-	CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
+  else 
+    {
+      /* Compute the S-boxes. */
+      for(i=j=0,k=1; i < 256; i++, j += 2, k += 2 )
+        {
+          CALC_SB_2( i, calc_sb_tbl[j], calc_sb_tbl[k] );
+        }
+
+      /* Calculate whitening and round subkeys.  The constants are
+       * indices of subkeys, preprocessed through q0 and q1. */
+      CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3);
+      CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
+      CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
+      CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
+      CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
+      CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B);
+      CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
+      CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
+      CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
+      CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD);
+      CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71);
+      CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
+      CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F);
+      CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B);
+      CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA);
+      CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F);
+      CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
+      CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
+      CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00);
+      CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
     }
 
-    return 0;
+  return 0;
 }
 
 static gcry_err_code_t
 twofish_setkey (void *context, const byte *key, unsigned int keylen)
 {
-  TWOFISH_context *ctx = (TWOFISH_context *) context;
+  TWOFISH_context *ctx = context;
   int rc = do_twofish_setkey (ctx, key, keylen);
   _gcry_burn_stack (23+6*sizeof(void*));
   return rc;
@@ -772,39 +777,39 @@ twofish_setkey (void *context, const byte *key, unsigned int keylen)
 static void
 do_twofish_encrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
 {
-   /* The four 32-bit chunks of the text. */
-   u32 a, b, c, d;
-
-   /* Temporaries used by the round function. */
-   u32 x, y;
-
-   /* Input whitening and packing. */
-   INPACK (0, a, 0);
-   INPACK (1, b, 1);
-   INPACK (2, c, 2);
-   INPACK (3, d, 3);
-
-   /* Encryption Feistel cycles. */
-   ENCCYCLE (0);
-   ENCCYCLE (1);
-   ENCCYCLE (2);
-   ENCCYCLE (3);
-   ENCCYCLE (4);
-   ENCCYCLE (5);
-   ENCCYCLE (6);
-   ENCCYCLE (7);
-
-   /* Output whitening and unpacking. */
-   OUTUNPACK (0, c, 4);
-   OUTUNPACK (1, d, 5);
-   OUTUNPACK (2, a, 6);
-   OUTUNPACK (3, b, 7);
+  /* The four 32-bit chunks of the text. */
+  u32 a, b, c, d;
+
+  /* Temporaries used by the round function. */
+  u32 x, y;
+
+  /* Input whitening and packing. */
+  INPACK (0, a, 0);
+  INPACK (1, b, 1);
+  INPACK (2, c, 2);
+  INPACK (3, d, 3);
+
+  /* Encryption Feistel cycles. */
+  ENCCYCLE (0);
+  ENCCYCLE (1);
+  ENCCYCLE (2);
+  ENCCYCLE (3);
+  ENCCYCLE (4);
+  ENCCYCLE (5);
+  ENCCYCLE (6);
+  ENCCYCLE (7);
+
+  /* Output whitening and unpacking. */
+  OUTUNPACK (0, c, 4);
+  OUTUNPACK (1, d, 5);
+  OUTUNPACK (2, a, 6);
+  OUTUNPACK (3, b, 7);
 }
 
 static void
 twofish_encrypt (void *context, byte *out, const byte *in)
 {
-  TWOFISH_context *ctx = (TWOFISH_context *) context;
+  TWOFISH_context *ctx = context;
   do_twofish_encrypt (ctx, out, in);
   _gcry_burn_stack (24+3*sizeof (void*));
 }
@@ -815,39 +820,40 @@ twofish_encrypt (void *context, byte *out, const byte *in)
 static void
 do_twofish_decrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
 {
-   /* The four 32-bit chunks of the text. */
-   u32 a, b, c, d;
-
-   /* Temporaries used by the round function. */
-   u32 x, y;
-
-   /* Input whitening and packing. */
-   INPACK (0, c, 4);
-   INPACK (1, d, 5);
-   INPACK (2, a, 6);
-   INPACK (3, b, 7);
-
-   /* Encryption Feistel cycles. */
-   DECCYCLE (7);
-   DECCYCLE (6);
-   DECCYCLE (5);
-   DECCYCLE (4);
-   DECCYCLE (3);
-   DECCYCLE (2);
-   DECCYCLE (1);
-   DECCYCLE (0);
-
-   /* Output whitening and unpacking. */
-   OUTUNPACK (0, a, 0);
-   OUTUNPACK (1, b, 1);
-   OUTUNPACK (2, c, 2);
-   OUTUNPACK (3, d, 3);
+  /* The four 32-bit chunks of the text. */
+  u32 a, b, c, d;
+
+  /* Temporaries used by the round function. */
+  u32 x, y;
+
+  /* Input whitening and packing. */
+  INPACK (0, c, 4);
+  INPACK (1, d, 5);
+  INPACK (2, a, 6);
+  INPACK (3, b, 7);
+
+  /* Encryption Feistel cycles. */
+  DECCYCLE (7);
+  DECCYCLE (6);
+  DECCYCLE (5);
+  DECCYCLE (4);
+  DECCYCLE (3);
+  DECCYCLE (2);
+  DECCYCLE (1);
+  DECCYCLE (0);
+
+  /* Output whitening and unpacking. */
+  OUTUNPACK (0, a, 0);
+  OUTUNPACK (1, b, 1);
+  OUTUNPACK (2, c, 2);
+  OUTUNPACK (3, d, 3);
 }
 
 static void
 twofish_decrypt (void *context, byte *out, const byte *in)
 {
-  TWOFISH_context *ctx = (TWOFISH_context *) context;
+  TWOFISH_context *ctx = context;
+
   do_twofish_decrypt (ctx, out, in);
   _gcry_burn_stack (24+3*sizeof (void*));
 }
@@ -858,58 +864,58 @@ twofish_decrypt (void *context, byte *out, const byte *in)
 static const char*
 selftest (void)
 {
-   TWOFISH_context ctx; /* Expanded key. */
-   byte scratch[16];	/* Encryption/decryption result buffer. */
-
-   /* Test vectors for single encryption/decryption.  Note that I am using
-    * the vectors from the Twofish paper's "known answer test", I=3 for
-    * 128-bit and I=4 for 256-bit, instead of the all-0 vectors from the
-    * "intermediate value test", because an all-0 key would trigger all the
-    * special cases in the RS matrix multiply, leaving the math untested. */
-   static  byte plaintext[16] = {
-      0xD4, 0x91, 0xDB, 0x16, 0xE7, 0xB1, 0xC3, 0x9E,
-      0x86, 0xCB, 0x08, 0x6B, 0x78, 0x9F, 0x54, 0x19
-   };
-   static byte key[16] = {
-      0x9F, 0x58, 0x9F, 0x5C, 0xF6, 0x12, 0x2C, 0x32,
-      0xB6, 0xBF, 0xEC, 0x2F, 0x2A, 0xE8, 0xC3, 0x5A
-   };
-   static const byte ciphertext[16] = {
-      0x01, 0x9F, 0x98, 0x09, 0xDE, 0x17, 0x11, 0x85,
-      0x8F, 0xAA, 0xC3, 0xA3, 0xBA, 0x20, 0xFB, 0xC3
-   };
-   static byte plaintext_256[16] = {
-      0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F,
-      0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6
-   };
-   static byte key_256[32] = {
-      0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46,
-      0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
-      0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B,
-      0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F
-   };
-   static const byte ciphertext_256[16] = {
-      0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97,
-      0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
-   };
-
-   twofish_setkey (&ctx, key, sizeof(key));
-   twofish_encrypt (&ctx, scratch, plaintext);
-   if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
-     return "Twofish-128 test encryption failed.";
-   twofish_decrypt (&ctx, scratch, scratch);
-   if (memcmp (scratch, plaintext, sizeof (plaintext)))
-     return "Twofish-128 test decryption failed.";
-
-   twofish_setkey (&ctx, key_256, sizeof(key_256));
-   twofish_encrypt (&ctx, scratch, plaintext_256);
-   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
-     return "Twofish-256 test encryption failed.";
-   twofish_decrypt (&ctx, scratch, scratch);
-   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
-     return "Twofish-256 test decryption failed.";
-
-   return NULL;
+  TWOFISH_context ctx; /* Expanded key. */
+  byte scratch[16];	/* Encryption/decryption result buffer. */
+
+  /* Test vectors for single encryption/decryption.  Note that I am using
+   * the vectors from the Twofish paper's "known answer test", I=3 for
+   * 128-bit and I=4 for 256-bit, instead of the all-0 vectors from the
+   * "intermediate value test", because an all-0 key would trigger all the
+   * special cases in the RS matrix multiply, leaving the math untested. */
+  static  byte plaintext[16] = {
+    0xD4, 0x91, 0xDB, 0x16, 0xE7, 0xB1, 0xC3, 0x9E,
+    0x86, 0xCB, 0x08, 0x6B, 0x78, 0x9F, 0x54, 0x19
+  };
+  static byte key[16] = {
+    0x9F, 0x58, 0x9F, 0x5C, 0xF6, 0x12, 0x2C, 0x32,
+    0xB6, 0xBF, 0xEC, 0x2F, 0x2A, 0xE8, 0xC3, 0x5A
+  };
+  static const byte ciphertext[16] = {
+    0x01, 0x9F, 0x98, 0x09, 0xDE, 0x17, 0x11, 0x85,
+    0x8F, 0xAA, 0xC3, 0xA3, 0xBA, 0x20, 0xFB, 0xC3
+  };
+  static byte plaintext_256[16] = {
+    0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F,
+    0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6
+  };
+  static byte key_256[32] = {
+    0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46,
+    0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
+    0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B,
+    0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F
+  };
+  static const byte ciphertext_256[16] = {
+    0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97,
+    0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
+  };
+
+  twofish_setkey (&ctx, key, sizeof(key));
+  twofish_encrypt (&ctx, scratch, plaintext);
+  if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
+    return "Twofish-128 test encryption failed.";
+  twofish_decrypt (&ctx, scratch, scratch);
+  if (memcmp (scratch, plaintext, sizeof (plaintext)))
+    return "Twofish-128 test decryption failed.";
+
+  twofish_setkey (&ctx, key_256, sizeof(key_256));
+  twofish_encrypt (&ctx, scratch, plaintext_256);
+  if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
+    return "Twofish-256 test encryption failed.";
+  twofish_decrypt (&ctx, scratch, scratch);
+  if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
+    return "Twofish-256 test decryption failed.";
+
+  return NULL;
 }
 
 /* More complete test program.	This does 1000 encryptions and decryptions
@@ -928,91 +934,93 @@ selftest (void)
 int
 main()
 {
-   TWOFISH_context ctx;     /* Expanded key. */
-   int i, j;		    /* Loop counters. */
-
-   const char *encrypt_msg; /* Message to print regarding encryption test;
-			     * the printf is done outside the loop to avoid
-			     * stuffing up the timing. */
-   clock_t timer; /* For computing elapsed time. */
-
-   /* Test buffer. */
-   byte buffer[4][16] = {
-      {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-       0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
-      {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
-       0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
-      {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
-      {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
-       0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
-   };
-
-   /* Expected outputs for the million-operation test */
-   static const byte test_encrypt[4][16] = {
-      {0xC8, 0x23, 0xB8, 0xB7, 0x6B, 0xFE, 0x91, 0x13,
-       0x2F, 0xA7, 0x5E, 0xE6, 0x94, 0x77, 0x6F, 0x6B},
-      {0x90, 0x36, 0xD8, 0x29, 0xD5, 0x96, 0xC2, 0x8E,
-       0xE4, 0xFF, 0x76, 0xBC, 0xE5, 0x77, 0x88, 0x27},
-      {0xB8, 0x78, 0x69, 0xAF, 0x42, 0x8B, 0x48, 0x64,
-       0xF7, 0xE9, 0xF3, 0x9C, 0x42, 0x18, 0x7B, 0x73},
-      {0x7A, 0x88, 0xFB, 0xEB, 0x90, 0xA4, 0xB4, 0xA8,
-       0x43, 0xA3, 0x1D, 0xF1, 0x26, 0xC4, 0x53, 0x57}
-   };
-   static const byte test_decrypt[4][16] = {
-      {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
-       0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
-      {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
-       0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
-      {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
-       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
-      {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
-       0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
-   };
-
-   /* Start the timer ticking. */
-   timer = clock ();
-
-   /* Encryption test. */
-   for (i = 0; i < 125; i++) {
+  TWOFISH_context ctx;     /* Expanded key. */
+  int i, j;		    /* Loop counters. */
+
+  const char *encrypt_msg; /* Message to print regarding encryption test;
+                            * the printf is done outside the loop to avoid
+                            * stuffing up the timing. */
+  clock_t timer; /* For computing elapsed time. */
+
+  /* Test buffer. */
+  byte buffer[4][16] = {
+    {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
+    {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
+     0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
+    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
+    {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
+     0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
+  };
+
+  /* Expected outputs for the million-operation test */
+  static const byte test_encrypt[4][16] = {
+    {0xC8, 0x23, 0xB8, 0xB7, 0x6B, 0xFE, 0x91, 0x13,
+     0x2F, 0xA7, 0x5E, 0xE6, 0x94, 0x77, 0x6F, 0x6B},
+    {0x90, 0x36, 0xD8, 0x29, 0xD5, 0x96, 0xC2, 0x8E,
+     0xE4, 0xFF, 0x76, 0xBC, 0xE5, 0x77, 0x88, 0x27},
+    {0xB8, 0x78, 0x69, 0xAF, 0x42, 0x8B, 0x48, 0x64,
+     0xF7, 0xE9, 0xF3, 0x9C, 0x42, 0x18, 0x7B, 0x73},
+    {0x7A, 0x88, 0xFB, 0xEB, 0x90, 0xA4, 0xB4, 0xA8,
+     0x43, 0xA3, 0x1D, 0xF1, 0x26, 0xC4, 0x53, 0x57}
+  };
+  static const byte test_decrypt[4][16] = {
+    {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+     0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
+    {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
+     0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
+    {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+     0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
+    {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
+     0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
+  };
+
+  /* Start the timer ticking. */
+  timer = clock ();
+
+  /* Encryption test. */
+  for (i = 0; i < 125; i++) 
+    {
       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
       for (j = 0; j < 1000; j++)
-	twofish_encrypt (&ctx, buffer[2], buffer[2]);
+        twofish_encrypt (&ctx, buffer[2], buffer[2]);
       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
       for (j = 0; j < 1000; j++)
-	twofish_encrypt (&ctx, buffer[3], buffer[3]);
+        twofish_encrypt (&ctx, buffer[3], buffer[3]);
       twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
       for (j = 0; j < 1000; j++) {
-	twofish_encrypt (&ctx, buffer[0], buffer[0]);
-	twofish_encrypt (&ctx, buffer[1], buffer[1]);
+        twofish_encrypt (&ctx, buffer[0], buffer[0]);
+        twofish_encrypt (&ctx, buffer[1], buffer[1]);
       }
-   }
-   encrypt_msg = memcmp (buffer, test_encrypt, sizeof (test_encrypt)) ?
-		 "encryption failure!\n" : "encryption OK!\n";
+    }
+  encrypt_msg = memcmp (buffer, test_encrypt, sizeof (test_encrypt)) ?
+    "encryption failure!\n" : "encryption OK!\n";
 
-   /* Decryption test. */
-   for (i = 0; i < 125; i++) {
+  /* Decryption test. */
+  for (i = 0; i < 125; i++) 
+    {
       twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
       for (j = 0; j < 1000; j++) {
-	twofish_decrypt (&ctx, buffer[0], buffer[0]);
-	twofish_decrypt (&ctx, buffer[1], buffer[1]);
+        twofish_decrypt (&ctx, buffer[0], buffer[0]);
+        twofish_decrypt (&ctx, buffer[1], buffer[1]);
       }
       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
       for (j = 0; j < 1000; j++)
-	twofish_decrypt (&ctx, buffer[3], buffer[3]);
+        twofish_decrypt (&ctx, buffer[3], buffer[3]);
       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
       for (j = 0; j < 1000; j++)
-	twofish_decrypt (&ctx, buffer[2], buffer[2]);
-   }
+        twofish_decrypt (&ctx, buffer[2], buffer[2]);
+    }
 
-   /* Stop the timer, and print results. */
-   timer = clock () - timer;
-   printf (encrypt_msg);
-   printf (memcmp (buffer, test_decrypt, sizeof (test_decrypt)) ?
-	   "decryption failure!\n" : "decryption OK!\n");
-   printf ("elapsed time: %.1f s.\n", (float) timer / CLOCKS_PER_SEC);
+  /* Stop the timer, and print results. */
+  timer = clock () - timer;
+  printf (encrypt_msg);
+  printf (memcmp (buffer, test_decrypt, sizeof (test_decrypt)) ?
+          "decryption failure!\n" : "decryption OK!\n");
+  printf ("elapsed time: %.1f s.\n", (float) timer / CLOCKS_PER_SEC);
 
-   return 0;
+  return 0;
 }
 
 #endif /* TEST */