Mostly indendation changes. Completed the Manifest.
authorWerner Koch <wk@gnupg.org>
Thu, 11 Dec 2003 15:46:12 +0000 (15:46 +0000)
committerWerner Koch <wk@gnupg.org>
Thu, 11 Dec 2003 15:46:12 +0000 (15:46 +0000)
17 files changed:
cipher/ChangeLog
cipher/Manifest
cipher/md4.c
cipher/md5.c
cipher/rijndael.c
cipher/rmd160.c
cipher/rndegd.c
cipher/rndlinux.c
cipher/rndunix.c
cipher/rndw32.c
cipher/rsa.c
cipher/serpent.c
cipher/sha1.c
cipher/sha256.c
cipher/sha512.c
cipher/tiger.c
cipher/twofish.c

index 72e951e..9785bdf 100644 (file)
@@ -1,3 +1,27 @@
+2003-12-11  Werner Koch  <wk@gnupg.org>
+
+       * rndunix.c (slow_poll): Don't use #warning but #error.
+
+       * rndegd.c: Changed indentation.
+       (my_make_filename): Removd the var_arg cruft becuase we
+       don't need it here.  Changed caller.  
+
+       * rndlinux.c: Changed indentation.
+       (open_device): Remove the superfluous stat call and clarify
+       comment.
+
+       * rsa.c: Changed indentation.
+       (secret): Use the standard algorithm if p, q and u are not
+       available.
+       (rsa_blind, rsa_unblind): Renamed from _gcry_rsa_blind,
+       _gcry_rsa_unblind and moved more to the top.
+
+       * md4.c: Changed indentation.  Removed unnecessary casts.
+       * md5.c, rmd160.c, sha1.c, tiger.c: Ditto.
+       * rijndael.c, twofish.c: Ditto.
+       * serpent.c: Removed unnecessary casts.
+       * sha256.c, sha512.c: Ditto.
+
 2003-12-09  Werner Koch  <wk@gnupg.org>
 
        * dsa.c: Unified indentation style.
index 7d8da6b..e7ca7d2 100644 (file)
@@ -39,26 +39,26 @@ crc.c iQCVAwUAP7ouejEAnp832S/7AQIgwQQApg5Nm63tH5DQkbN+zPzMO9Ygoj3ukxfFTyTBPYSXYK
 des.c iQCVAwUAP9XWVDEAnp832S/7AQLjYgP8DTVwIS1L/eODK2HOCuJgIqAg1MS9Jpb1w56pKM4pOQ24mH/pMWUgksntW1PqGXRzqt66k+AFw200/AujbEcEmB4kTmMRVYIDUrextWXsg8AQUaUqxPD6pP0mq2Y6afhCgaRm0rAYDz2kI2RRRxHPyRhwi/j+TNke01AdnnK1k2A==xGcy
 dsa.c iQCVAwUAP9XZHDEAnp832S/7AQLBRgP/XrBzTEYx5ccMj1MMb6sg37liEHdIyyy49zjvt6jUqxj4RuwVEN8S6v3u4q/QyJkHAi1E0EkREgENlyHW6PKWhYbcrd0vPIAN15yjnl2yqtrCrJImexUCoqJJewK0E4JOicGbabTil8MZjk+mbhEPnjJBqOkyP1w0i31pEDgE/8M==pC8s
 elgamal.c iQCVAwUAP9XbYzEAnp832S/7AQLXagQA3HrvspZfbTGgmUH0IqLQTJ0exUPxJv5DET2TvoIy62trDmMN6lTAj5P+a7jQ8udcu0w+mR2vXUHcxUpNA2PxLaMwGzNSY4zRDNe9r3SFTDrFm6m4y9Ko2e8XtEA+WF6P/XLpck4Jn7vMEDmVGPwkNd22kXFFE8dBGwG6i5Hk1Mk==oBUs
-md4.c
-md5.c
-rijndael.c
-rmd160.c
-rsa.c
-serpent.c
-sha1.c
-sha256.c
-sha512.c
-tiger.c
-twofish.c
+md4.c iQCVAwUAP9h50DEAnp832S/7AQJhHgQAzNA/B6MWFDlCtPkIVaW8RpP1Eg0ZNMsy0s7SJkopOCBlu6CwXUOKe+8ppcSxhjYKh4i4uQr/QtfipYlBjzKJGnrafoF/NugXNCOHSTGT11TvK7mCiBuUMVgvZGAlOJImk6eTTfUjRrMfaXM/SWl8bdJ4ZpzdjEyVh89r7I5JrGk==x2UD
+md5.c iQCVAwUAP9h7LzEAnp832S/7AQJUGQP/c0cbf6WZXCzmjufHxiE9FAQBzTsA0WtaNqdFcHl7fhmikGtknlaED8n5a7eYd/C481UQW6Wgq/oZdsvgoPWPhG3fOCy2CFP9cZVXITuMSf0ucyZTFUJNO15fnZ+nDfsUv+JPdv1aSeRinAUtfAcSKfkSyR9BCPZvkx+tgU6cphU==Zv+h
+rijndael.c iQCVAwUAP9h9cTEAnp832S/7AQKF1AP+P2L/tPqDJRDg+/fwbOk8Ts0MNxnvvYEm3gE73TKuLt1S+B2+jkrZcKNvM5VGPnVMJbnS0lmIK04nmedHCOftGTOwhGulZAHHIaKGystT3Jql4iPws/JMgAjE7Fyxh5WZMtB9yEljKBpJ5XNqhrMvvxcHpnyP3+YzIXNwzk34V+c==dJ5k
+rmd160.c iQCVAwUAP9h+bTEAnp832S/7AQK1OgP+PNKF6Nzi6X93easVlksdLqKEsArCAw2QjGWDGyxTnbiJM55qAl9JxR1mn3V+oOL7izLLwTt6EYK9evhzfcxY5N5Mni85RAcsLPsuAfQDEzjI6GUWHtQUKPbM+BaorzfhQjYFSZyvum/dZYJ/WfiwwwhqqIKyVU2ZFSqA38YGC/c==9jdA
+rsa.c iQCVAwUAP9iHIzEAnp832S/7AQKAYwQAuWtnMte54QHN+Hij9t4sGuypXogajOb1vQQwGgS0fKsaBZsuSP2amze4o5diIvsQTsFQ4CzjvqoCVuBDoHM3xkSD8wGDizgvtCamAxkdbF7wmzldKFn8SpJqlVwWQMP6kk1IjXHEuYb4IDWGTbVMhfEu+eOlU8+PSK4IhZqNvt4==/3hp
+serpent.c iQCVAwUAP9h/VzEAnp832S/7AQLyCwP/d1zbmb7l/PriZNa9/Z7mo01XFe5MnAqCfIwhl9GjeaMszcoS37jECNq5nLvrTTFIIJpm3rvBePwiCG4Wwx1I18HCxaP198pcSaR+BLOJ3Aj52EZPrxtqlDKuFr38ZOP5giyUqUYVYGVdrz4kRMNWAZQK53GeJnGhXCnhxojLEgA==ck46
+sha1.c iQCVAwUAP9iATTEAnp832S/7AQKcSwQAwAs/HnNqho3lU1ZUgCPNt5P2/Brm6W21+wWWGKJkSrra/c4NYVKJGDDwlsFE0b9ln1uZt7bHReFkKXK3JnrKTmNVcx/Cy64iCMRNMhaM72Mqy7wWx5yHBAmMBxzFGnNQKbmeY52zeGih5HsNLSibc2pPuOViWo2JPJ5Ci/wIwl8==/wtO
+sha256.c iQCVAwUAP9iAtzEAnp832S/7AQJD2QP/UqvL0hhjG1wEFbGrdkV9tba1sMDXdnnK6X7HdLuRpVAgNiQiFf8JDmntd/dZ2Q71p4Uae2ctqve4WoEijPUZPjACnpuZfx0SEQL0lQBkwxzJp7lz9ujVtwQ2cM/aYexJkXcWgGcloJNLM3JbWPGIJnuYbr/IwJ6RQF9vgj0357o==UWO1
+sha512.c iQCVAwUAP9iBTDEAnp832S/7AQIPBAQA28CJSUQLiW0s2x9u8/OH2eKnxPjA4sZmb50WP7920Lem66P31C3BrOqwfBot4RLhjL+zh/+Uc4s3HPwApZuj9E4BxNMlqLv+Tqk++DAbdaOeYT4jeUt+mlhQQ6mH/RDsy32rZsNsGQ2bUGxazZmfG++PL3JyhawqCy00SUDr/o0==H+0X
+tiger.c iQCVAwUAP9iCfjEAnp832S/7AQKufwP/fryv3MqSOYY+90325DH7X3/CtekxeooN0scGsHX0fxBakWSMecTNrj33KPddLS46gU/S89zIc2N/Bw/7EVIAXVFA3/3Ip+OrFOuIMO4Py1sCdB8o2Y+5ygv8iXLcsXIq1O0av79i9g774V3uaXa2qN9ZnXe0AEhcy8FHJ2i/wro==5XVB
+twofish.c iQCVAwUAP9iD6TEAnp832S/7AQKUnQP/Rq8FaYeHTG7HbZuqAs9pbPitzjDbkdZddmInWR7NmevBkKvhsJALjVooc0KGQfo2lAAmy3Xi/4QQN8VPn51DVjDIgf7x+DQh/9TFJHMccxI9asUgi4+TNnmMqLU1k3N8S2PjyZ1sjeC8B79fKPpwCzj72WkqPkzZw3l2jArr+dU==NdJT
 
 # Random number related
 random.c iQCVAwUAP7nsITEAnp832S/7AQK4SAQAtvfUgrtGOQ2PlxGMla0qJLPHjJacMwgq0ecusiI79elPdDsFfCCk6dK1Ug2kFbNm22nCGHNcUquqbX7noi7ZVQnmPBQXzyLNZd7GmrawRZfdlRerTUDBpSnR8V8ui/5+YYp627E7kKGC0hPSgqXFql6oBMIfno0LZwFJTjIevRY==L419
 random.h iQCVAwUAP7ovKDEAnp832S/7AQJ3bQQAjnPebnyTC7sphAv2I7uIz+yPgw1ZfbVhLv+OiWDlO9ish+fRyyMpy+HELBOgZjJdgRegqhlZC6qyns5arM/VglYi+PzvdLO3hIqHE/YFfpIFPz8wBrcmlqrYyd3CsGqcYsfjocXNttCBLeSWmoJ09ltKQH8yzJf3oAgN6X1yuc4==eNoU
 rand-internal.h iQCVAwUAP7ouvDEAnp832S/7AQLYnAQAhdI7ERoJVCkV8GiV7MjaUxv1WIL7iZ+jIOvVhv4fNyhCGCGoEtTjkyput/lj7Nsh3FXEqRhypGGrCLf47x/gua5n+BwffogxVyUDqiOyyGhNTPpe3fQcNBvbPCtco8yMK4GJO5G3BqzlPyN+BMeogLymyV6Sm1mvh5LZDyAFbfQ==tZSE
-rndlinux.c
-rndegd.c
-rndunix.c
-rndw32.c
+rndlinux.c iQCVAwUAP9iPYTEAnp832S/7AQL6/AP/ZDrbOkVuB9qJ7sKeX1MImZEsz3mi0xPovJzaBtBU7a0idcUKrWYOvQFWRlLUeq0iCT6+h2l5bniP7q7hepzlKa+VPY9VWaQthqeJm2l5LN6QQ5PyMfBq04QuBncw9BJnCGmEyTLt3RxIXBAPdxmiVxtcRIFUqCBtQvoUXGLvemw==t37k
+rndegd.c iQCVAwUAP9iPRDEAnp832S/7AQImBQP/WHKg+hKXcm1pQvilzML0jZpwK5PAMM4uBnnPJNIXWOYBO6I/Xg9d/tPLg8NlmmtyQCo2Eu0ybDSt+8mu+dWveAys+0LTi0MIqeP9BMzCKz8dnWH6+S8huLXwTF3m0IrqM0JLb6b71GK9SOq6sWQ22yW5vf61hXP8kH9dhIaoMZs==FaHV
+rndunix.c iQCVAwUAP9iQlzEAnp832S/7AQL/KgQA29GnvcD4Xb5qjDMBgW9THEE4+4lfex/6k+Fh0IT61OLJsWVLJ7bJpRntburw4uQm4Tf7CO8vaiDFDYhKKrzXeOF1fmdpcL8hA+fNp9I/MUOc4e9kN9+YJ9wikVa0SZj1OBfhzgcFLd1xOtulkr3ii52HLF9vhrxzkgVwvD10Bi8==2cML
+rndw32.c iQCVAwUAP9iRKDEAnp832S/7AQIuaAQA3AJr3WqnxNDsWCIdvehf8Suotthj+laX8nJsvDfFhXPKcXDpsg0wTTXSnnKgyED53+uYiMDnVRsxeWAyhKwvx1MjjlaSMMjzbH6isWTH8FaWpLgrxEkXoPeNqYf5FXpdUkcUxGX2RkQeuX/cIfiHLNE9CV0usaF2jysjBX2iERY==EEnO
 
 # Helper
 bithelp.h iQCVAwUAP7ouPTEAnp832S/7AQKXggQAqjcgvihIF3WclOgw1JV2rbARw4ISIDRMFqdaNCqBRx6BwEz3UGsEIlz6+iR1sS/reqN61WvtjLb+D0+tujAkGrgQJhFLG85WtG2tB5UVoI3am1fpkwiRm+bR4rv0rGk0BYk81bC7+l4KrK9o5lVp4lCsrorlUKsd48lNmBHyAXM==mDDN
index fd51d03..0d0a559 100644 (file)
@@ -70,7 +70,7 @@ typedef struct {
 static void
 md4_init( void *context )
 {
-  MD4_CONTEXT *ctx = (MD4_CONTEXT *) context;
+  MD4_CONTEXT *ctx = context;
 
   ctx->A = 0x67452301;
   ctx->B = 0xefcdab89;
@@ -92,95 +92,97 @@ md4_init( void *context )
 static void
 transform( MD4_CONTEXT *ctx, byte *data )
 {
-    u32 in[16];
-    register u32 A = ctx->A;
-    register u32 B = ctx->B;
-    register u32 C = ctx->C;
-    register u32 D = ctx->D;
+  u32 in[16];
+  register u32 A = ctx->A;
+  register u32 B = ctx->B;
+  register u32 C = ctx->C;
+  register u32 D = ctx->D;
 
 #ifdef WORDS_BIGENDIAN
-    { int i;
-      byte *p2, *p1;
-      for(i=0, p1=data, p2=(byte*)in; i < 16; i++, p2 += 4 ) {
+  {
+    int i;
+    byte *p2, *p1;
+    for(i=0, p1=data, p2=(byte*)in; i < 16; i++, p2 += 4 )
+      {
        p2[3] = *p1++;
        p2[2] = *p1++;
        p2[1] = *p1++;
        p2[0] = *p1++;
       }
-    }
+  }
 #else
-    memcpy (in, data, 64);
+  memcpy (in, data, 64);
 #endif
 
-    /* Round 1.  */
+  /* Round 1.  */
 #define function(a,b,c,d,k,s) a=rol(a+F(b,c,d)+in[k],s);
-          function(A,B,C,D, 0, 3);
-          function(D,A,B,C, 1, 7);
-          function(C,D,A,B, 2,11);
-          function(B,C,D,A, 3,19);
-          function(A,B,C,D, 4, 3);
-          function(D,A,B,C, 5, 7);
-          function(C,D,A,B, 6,11);
-          function(B,C,D,A, 7,19);
-          function(A,B,C,D, 8, 3);
-          function(D,A,B,C, 9, 7);
-          function(C,D,A,B,10,11);
-          function(B,C,D,A,11,19);
-          function(A,B,C,D,12, 3);
-          function(D,A,B,C,13, 7);
-          function(C,D,A,B,14,11);
-          function(B,C,D,A,15,19);
+  function(A,B,C,D, 0, 3);
+  function(D,A,B,C, 1, 7);
+  function(C,D,A,B, 2,11);
+  function(B,C,D,A, 3,19);
+  function(A,B,C,D, 4, 3);
+  function(D,A,B,C, 5, 7);
+  function(C,D,A,B, 6,11);
+  function(B,C,D,A, 7,19);
+  function(A,B,C,D, 8, 3);
+  function(D,A,B,C, 9, 7);
+  function(C,D,A,B,10,11);
+  function(B,C,D,A,11,19);
+  function(A,B,C,D,12, 3);
+  function(D,A,B,C,13, 7);
+  function(C,D,A,B,14,11);
+  function(B,C,D,A,15,19);
 
 #undef function
 
-    /* Round 2.  */
+  /* Round 2.  */
 #define function(a,b,c,d,k,s) a=rol(a+G(b,c,d)+in[k]+0x5a827999,s);
 
-          function(A,B,C,D, 0, 3);
-          function(D,A,B,C, 4, 5);
-          function(C,D,A,B, 8, 9);
-          function(B,C,D,A,12,13);
-          function(A,B,C,D, 1, 3);
-          function(D,A,B,C, 5, 5);
-          function(C,D,A,B, 9, 9);
-          function(B,C,D,A,13,13);
-          function(A,B,C,D, 2, 3);
-          function(D,A,B,C, 6, 5);
-          function(C,D,A,B,10, 9);
-          function(B,C,D,A,14,13);
-          function(A,B,C,D, 3, 3);
-          function(D,A,B,C, 7, 5);
-          function(C,D,A,B,11, 9);
-          function(B,C,D,A,15,13);
+  function(A,B,C,D, 0, 3);
+  function(D,A,B,C, 4, 5);
+  function(C,D,A,B, 8, 9);
+  function(B,C,D,A,12,13);
+  function(A,B,C,D, 1, 3);
+  function(D,A,B,C, 5, 5);
+  function(C,D,A,B, 9, 9);
+  function(B,C,D,A,13,13);
+  function(A,B,C,D, 2, 3);
+  function(D,A,B,C, 6, 5);
+  function(C,D,A,B,10, 9);
+  function(B,C,D,A,14,13);
+  function(A,B,C,D, 3, 3);
+  function(D,A,B,C, 7, 5);
+  function(C,D,A,B,11, 9);
+  function(B,C,D,A,15,13);
 
 #undef function
 
-    /* Round 3.  */
+  /* Round 3.  */
 #define function(a,b,c,d,k,s) a=rol(a+H(b,c,d)+in[k]+0x6ed9eba1,s);
 
-          function(A,B,C,D, 0, 3);
-          function(D,A,B,C, 8, 9);
-          function(C,D,A,B, 4,11);
-          function(B,C,D,A,12,15);
-          function(A,B,C,D, 2, 3);
-          function(D,A,B,C,10, 9);
-          function(C,D,A,B, 6,11);
-          function(B,C,D,A,14,15);
-          function(A,B,C,D, 1, 3);
-          function(D,A,B,C, 9, 9);
-          function(C,D,A,B, 5,11);
-          function(B,C,D,A,13,15);
-          function(A,B,C,D, 3, 3);
-          function(D,A,B,C,11, 9);
-          function(C,D,A,B, 7,11);
-          function(B,C,D,A,15,15);
-
-
-    /* Put checksum in context given as argument.  */
-    ctx->A += A;
-    ctx->B += B;
-    ctx->C += C;
-    ctx->D += D;
+  function(A,B,C,D, 0, 3);
+  function(D,A,B,C, 8, 9);
+  function(C,D,A,B, 4,11);
+  function(B,C,D,A,12,15);
+  function(A,B,C,D, 2, 3);
+  function(D,A,B,C,10, 9);
+  function(C,D,A,B, 6,11);
+  function(B,C,D,A,14,15);
+  function(A,B,C,D, 1, 3);
+  function(D,A,B,C, 9, 9);
+  function(C,D,A,B, 5,11);
+  function(B,C,D,A,13,15);
+  function(A,B,C,D, 3, 3);
+  function(D,A,B,C,11, 9);
+  function(C,D,A,B, 7,11);
+  function(B,C,D,A,15,15);
+
+
+  /* Put checksum in context given as argument.  */
+  ctx->A += A;
+  ctx->B += B;
+  ctx->C += C;
+  ctx->D += D;
 }
 
 
@@ -192,34 +194,38 @@ transform( MD4_CONTEXT *ctx, byte *data )
 static void
 md4_write( void *context, byte *inbuf, size_t inlen)
 {
-  MD4_CONTEXT *hd = (MD4_CONTEXT *) context;
-    if( hd->count == 64 ) { /* flush the buffer */
-       transform( hd, hd->buf );
-        _gcry_burn_stack (80+6*sizeof(void*));
-       hd->count = 0;
-       hd->nblocks++;
+  MD4_CONTEXT *hd = context;
+
+  if( hd->count == 64 ) /* flush the buffer */
+    { 
+      transform( hd, hd->buf );
+      _gcry_burn_stack (80+6*sizeof(void*));
+      hd->count = 0;
+      hd->nblocks++;
     }
-    if( !inbuf )
-       return;
-    if( hd->count ) {
-       for( ; inlen && hd->count < 64; inlen-- )
-           hd->buf[hd->count++] = *inbuf++;
-       md4_write( hd, NULL, 0 );
-       if( !inlen )
-           return;
+  if( !inbuf )
+    return;
+
+  if( hd->count )
+    {
+      for( ; inlen && hd->count < 64; inlen-- )
+        hd->buf[hd->count++] = *inbuf++;
+      md4_write( hd, NULL, 0 );
+      if( !inlen )
+        return;
     }
-    _gcry_burn_stack (80+6*sizeof(void*));
-
-    while( inlen >= 64 ) {
-       transform( hd, inbuf );
-       hd->count = 0;
-       hd->nblocks++;
-       inlen -= 64;
-       inbuf += 64;
+  _gcry_burn_stack (80+6*sizeof(void*));
+
+  while( inlen >= 64 )
+    {
+      transform( hd, inbuf );
+      hd->count = 0;
+      hd->nblocks++;
+      inlen -= 64;
+      inbuf += 64;
     }
-    for( ; inlen && hd->count < 64; inlen-- )
-       hd->buf[hd->count++] = *inbuf++;
-
+  for( ; inlen && hd->count < 64; inlen-- )
+    hd->buf[hd->count++] = *inbuf++;
 }
 
 
@@ -233,61 +239,63 @@ md4_write( void *context, byte *inbuf, size_t inlen)
 static void
 md4_final( void *context )
 {
-  MD4_CONTEXT *hd = (MD4_CONTEXT *) context;
-    u32 t, msb, lsb;
-    byte *p;
-
-    md4_write(hd, NULL, 0); /* flush */;
-
-    t = hd->nblocks;
-    /* multiply by 64 to make a byte count */
-    lsb = t << 6;
-    msb = t >> 26;
-    /* add the count */
-    t = lsb;
-    if( (lsb += hd->count) < t )
-       msb++;
-    /* multiply by 8 to make a bit count */
-    t = lsb;
-    lsb <<= 3;
-    msb <<= 3;
-    msb |= t >> 29;
-
-    if( hd->count < 56 ) { /* enough room */
-       hd->buf[hd->count++] = 0x80; /* pad */
-       while( hd->count < 56 )
-           hd->buf[hd->count++] = 0;  /* pad */
+  MD4_CONTEXT *hd = context;
+  u32 t, msb, lsb;
+  byte *p;
+
+  md4_write(hd, NULL, 0); /* flush */;
+
+  t = hd->nblocks;
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = t >> 26;
+  /* add the count */
+  t = lsb;
+  if( (lsb += hd->count) < t )
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+  
+  if( hd->count < 56 )  /* enough room */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad */
+      while( hd->count < 56 )
+        hd->buf[hd->count++] = 0;  /* pad */
     }
-    else { /* need one extra block */
-       hd->buf[hd->count++] = 0x80; /* pad character */
-       while( hd->count < 64 )
-           hd->buf[hd->count++] = 0;
-       md4_write(hd, NULL, 0);  /* flush */;
-       memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+  else /* need one extra block */ 
+    { 
+      hd->buf[hd->count++] = 0x80; /* pad character */
+      while( hd->count < 64 )
+        hd->buf[hd->count++] = 0;
+      md4_write(hd, NULL, 0);  /* flush */;
+      memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     }
-    /* append the 64 bit count */
-    hd->buf[56] = lsb     ;
-    hd->buf[57] = lsb >>  8;
-    hd->buf[58] = lsb >> 16;
-    hd->buf[59] = lsb >> 24;
-    hd->buf[60] = msb     ;
-    hd->buf[61] = msb >>  8;
-    hd->buf[62] = msb >> 16;
-    hd->buf[63] = msb >> 24;
-    transform( hd, hd->buf );
-    _gcry_burn_stack (80+6*sizeof(void*));
-
-    p = hd->buf;
+  /* append the 64 bit count */
+  hd->buf[56] = lsb       ;
+  hd->buf[57] = lsb >>  8;
+  hd->buf[58] = lsb >> 16;
+  hd->buf[59] = lsb >> 24;
+  hd->buf[60] = msb       ;
+  hd->buf[61] = msb >>  8;
+  hd->buf[62] = msb >> 16;
+  hd->buf[63] = msb >> 24;
+  transform( hd, hd->buf );
+  _gcry_burn_stack (80+6*sizeof(void*));
+
+  p = hd->buf;
 #ifdef WORDS_BIGENDIAN
 #define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
-                     *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
+                 *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
 #else /* little endian */
 #define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0)
 #endif
-    X(A);
-    X(B);
-    X(C);
-    X(D);
+  X(A);
+  X(B);
+  X(C);
+  X(D);
 #undef X
 
 }
@@ -295,7 +303,7 @@ md4_final( void *context )
 static byte *
 md4_read (void *context)
 {
-  MD4_CONTEXT *hd = (MD4_CONTEXT *) context;
+  MD4_CONTEXT *hd = context;
   return hd->buf;
 }
 
@@ -317,4 +325,3 @@ gcry_md_spec_t _gcry_digest_spec_md4 =
     sizeof (MD4_CONTEXT)
   };
 
-/* end of file */
index ecbf172..ec10b4d 100644 (file)
@@ -1,5 +1,6 @@
 /* md5.c - MD5 Message-Digest Algorithm
- * Copyright (C) 1995,1996,1998,1999,2001,2002,2003 Free Software Foundation, Inc.
+ * Copyright (C) 1995,1996,1998,1999,2001,2002,
+ *               2003  Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
@@ -53,15 +54,15 @@ typedef struct {
 static void
 md5_init( void *context )
 {
-  MD5_CONTEXT *ctx = (MD5_CONTEXT *) context;
+  MD5_CONTEXT *ctx = context;
 
-    ctx->A = 0x67452301;
-    ctx->B = 0xefcdab89;
-    ctx->C = 0x98badcfe;
-    ctx->D = 0x10325476;
+  ctx->A = 0x67452301;
+  ctx->B = 0xefcdab89;
+  ctx->C = 0x98badcfe;
+  ctx->D = 0x10325476;
 
-    ctx->nblocks = 0;
-    ctx->count = 0;
+  ctx->nblocks = 0;
+  ctx->count = 0;
 }
 
 
@@ -79,63 +80,64 @@ md5_init( void *context )
  * transform n*64 bytes
  */
 static void
-/*transform( MD5_CONTEXT *ctx, const void *buffer, size_t len )*/
 transform( MD5_CONTEXT *ctx, byte *data )
 {
-    u32 correct_words[16];
-    register u32 A = ctx->A;
-    register u32 B = ctx->B;
-    register u32 C = ctx->C;
-    register u32 D = ctx->D;
-    u32 *cwp = correct_words;
-
+  u32 correct_words[16];
+  register u32 A = ctx->A;
+  register u32 B = ctx->B;
+  register u32 C = ctx->C;
+  register u32 D = ctx->D;
+  u32 *cwp = correct_words;
+    
 #ifdef WORDS_BIGENDIAN
-    { int i;
-      byte *p2, *p1;
-      for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 ) {
-       p2[3] = *p1++;
+  { 
+    int i;
+    byte *p2, *p1;
+    for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 )
+      {
+        p2[3] = *p1++;
        p2[2] = *p1++;
        p2[1] = *p1++;
        p2[0] = *p1++;
       }
-    }
+  }
 #else
-    memcpy( correct_words, data, 64 );
+  memcpy( correct_words, data, 64 );
 #endif
 
 
-#define OP(a, b, c, d, s, T)                                       \
-  do                                                               \
-    {                                                              \
-      a += FF (b, c, d) + (*cwp++) + T;            \
-      a = rol(a, s);                                               \
-      a += b;                                                      \
-    }                                                              \
+#define OP(a, b, c, d, s, T) \
+  do                                      \
+    {                                     \
+      a += FF (b, c, d) + (*cwp++) + T;    \
+      a = rol(a, s);                      \
+      a += b;                             \
+    }                                     \
   while (0)
 
-    /* Before we start, one word about the strange constants.
-       They are defined in RFC 1321 as
-
-       T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
-     */
-
-    /* Round 1.  */
-    OP (A, B, C, D,  7, 0xd76aa478);
-    OP (D, A, B, C, 12, 0xe8c7b756);
-    OP (C, D, A, B, 17, 0x242070db);
-    OP (B, C, D, A, 22, 0xc1bdceee);
-    OP (A, B, C, D,  7, 0xf57c0faf);
-    OP (D, A, B, C, 12, 0x4787c62a);
-    OP (C, D, A, B, 17, 0xa8304613);
-    OP (B, C, D, A, 22, 0xfd469501);
-    OP (A, B, C, D,  7, 0x698098d8);
-    OP (D, A, B, C, 12, 0x8b44f7af);
-    OP (C, D, A, B, 17, 0xffff5bb1);
-    OP (B, C, D, A, 22, 0x895cd7be);
-    OP (A, B, C, D,  7, 0x6b901122);
-    OP (D, A, B, C, 12, 0xfd987193);
-    OP (C, D, A, B, 17, 0xa679438e);
-    OP (B, C, D, A, 22, 0x49b40821);
+  /* Before we start, one word about the strange constants.
+     They are defined in RFC 1321 as
+
+     T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+  */
+
+  /* Round 1.  */
+  OP (A, B, C, D,  7, 0xd76aa478);
+  OP (D, A, B, C, 12, 0xe8c7b756);
+  OP (C, D, A, B, 17, 0x242070db);
+  OP (B, C, D, A, 22, 0xc1bdceee);
+  OP (A, B, C, D,  7, 0xf57c0faf);
+  OP (D, A, B, C, 12, 0x4787c62a);
+  OP (C, D, A, B, 17, 0xa8304613);
+  OP (B, C, D, A, 22, 0xfd469501);
+  OP (A, B, C, D,  7, 0x698098d8);
+  OP (D, A, B, C, 12, 0x8b44f7af);
+  OP (C, D, A, B, 17, 0xffff5bb1);
+  OP (B, C, D, A, 22, 0x895cd7be);
+  OP (A, B, C, D,  7, 0x6b901122);
+  OP (D, A, B, C, 12, 0xfd987193);
+  OP (C, D, A, B, 17, 0xa679438e);
+  OP (B, C, D, A, 22, 0x49b40821);
 
 #undef OP
 #define OP(f, a, b, c, d, k, s, T)  \
@@ -147,65 +149,65 @@ transform( MD5_CONTEXT *ctx, byte *data )
       }                                                              \
     while (0)
 
-    /* Round 2.  */
-    OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
-    OP (FG, D, A, B, C,  6,  9, 0xc040b340);
-    OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
-    OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
-    OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
-    OP (FG, D, A, B, C, 10,  9, 0x02441453);
-    OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
-    OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
-    OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
-    OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
-    OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
-    OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
-    OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
-    OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
-    OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
-    OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
-
-    /* Round 3.  */
-    OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
-    OP (FH, D, A, B, C,  8, 11, 0x8771f681);
-    OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
-    OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
-    OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
-    OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
-    OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
-    OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
-    OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
-    OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
-    OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
-    OP (FH, B, C, D, A,  6, 23, 0x04881d05);
-    OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
-    OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
-    OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
-    OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
-
-    /* Round 4.  */
-    OP (FI, A, B, C, D,  0,  6, 0xf4292244);
-    OP (FI, D, A, B, C,  7, 10, 0x432aff97);
-    OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
-    OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
-    OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
-    OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
-    OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
-    OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
-    OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
-    OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
-    OP (FI, C, D, A, B,  6, 15, 0xa3014314);
-    OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
-    OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
-    OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
-    OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
-    OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
-
-    /* Put checksum in context given as argument.  */
-    ctx->A += A;
-    ctx->B += B;
-    ctx->C += C;
-    ctx->D += D;
+  /* Round 2.  */
+  OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
+  OP (FG, D, A, B, C,  6,  9, 0xc040b340);
+  OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
+  OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
+  OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
+  OP (FG, D, A, B, C, 10,  9, 0x02441453);
+  OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
+  OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
+  OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
+  OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
+  OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
+  OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
+  OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
+  OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
+  OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
+  OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
+
+  /* Round 3.  */
+  OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
+  OP (FH, D, A, B, C,  8, 11, 0x8771f681);
+  OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
+  OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
+  OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
+  OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
+  OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
+  OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
+  OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
+  OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
+  OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
+  OP (FH, B, C, D, A,  6, 23, 0x04881d05);
+  OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
+  OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
+  OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
+  OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
+
+  /* Round 4.  */
+  OP (FI, A, B, C, D,  0,  6, 0xf4292244);
+  OP (FI, D, A, B, C,  7, 10, 0x432aff97);
+  OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
+  OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
+  OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
+  OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
+  OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
+  OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
+  OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
+  OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
+  OP (FI, C, D, A, B,  6, 15, 0xa3014314);
+  OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
+  OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
+  OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
+  OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
+  OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
+
+  /* Put checksum in context given as argument.  */
+  ctx->A += A;
+  ctx->B += B;
+  ctx->C += C;
+  ctx->D += D;
 }
 
 
@@ -217,33 +219,38 @@ transform( MD5_CONTEXT *ctx, byte *data )
 static void
 md5_write( void *context, byte *inbuf, size_t inlen)
 {
-  MD5_CONTEXT *hd = (MD5_CONTEXT *) context;
-    if( hd->count == 64 ) { /* flush the buffer */
-       transform( hd, hd->buf );
-        _gcry_burn_stack (80+6*sizeof(void*));
-       hd->count = 0;
-       hd->nblocks++;
+  MD5_CONTEXT *hd = context;
+  
+  if( hd->count == 64 )  /* flush the buffer */
+    {
+      transform( hd, hd->buf );
+      _gcry_burn_stack (80+6*sizeof(void*));
+      hd->count = 0;
+      hd->nblocks++;
     }
-    if( !inbuf )
-       return;
-    if( hd->count ) {
-       for( ; inlen && hd->count < 64; inlen-- )
-           hd->buf[hd->count++] = *inbuf++;
-       md5_write( hd, NULL, 0 );
-       if( !inlen )
-           return;
+  if( !inbuf )
+    return;
+
+  if( hd->count )
+    {
+      for( ; inlen && hd->count < 64; inlen-- )
+        hd->buf[hd->count++] = *inbuf++;
+      md5_write( hd, NULL, 0 );
+      if( !inlen )
+        return;
     }
-    _gcry_burn_stack (80+6*sizeof(void*));
-
-    while( inlen >= 64 ) {
-       transform( hd, inbuf );
-       hd->count = 0;
-       hd->nblocks++;
-       inlen -= 64;
-       inbuf += 64;
+  _gcry_burn_stack (80+6*sizeof(void*));
+
+  while( inlen >= 64 ) 
+    {
+      transform( hd, inbuf );
+      hd->count = 0;
+      hd->nblocks++;
+      inlen -= 64;
+      inbuf += 64;
     }
-    for( ; inlen && hd->count < 64; inlen-- )
-       hd->buf[hd->count++] = *inbuf++;
+  for( ; inlen && hd->count < 64; inlen-- )
+    hd->buf[hd->count++] = *inbuf++;
 
 }
 
@@ -258,61 +265,63 @@ md5_write( void *context, byte *inbuf, size_t inlen)
 static void
 md5_final( void *context)
 {
-  MD5_CONTEXT *hd = (MD5_CONTEXT *) context;
-    u32 t, msb, lsb;
-    byte *p;
-
-    md5_write(hd, NULL, 0); /* flush */;
-
-    t = hd->nblocks;
-    /* multiply by 64 to make a byte count */
-    lsb = t << 6;
-    msb = t >> 26;
-    /* add the count */
-    t = lsb;
-    if( (lsb += hd->count) < t )
-       msb++;
-    /* multiply by 8 to make a bit count */
-    t = lsb;
-    lsb <<= 3;
-    msb <<= 3;
-    msb |= t >> 29;
-
-    if( hd->count < 56 ) { /* enough room */
-       hd->buf[hd->count++] = 0x80; /* pad */
-       while( hd->count < 56 )
-           hd->buf[hd->count++] = 0;  /* pad */
+  MD5_CONTEXT *hd = context;
+  u32 t, msb, lsb;
+  byte *p;
+  
+  md5_write(hd, NULL, 0); /* flush */;
+
+  t = hd->nblocks;
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = t >> 26;
+  /* add the count */
+  t = lsb;
+  if( (lsb += hd->count) < t )
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+
+  if( hd->count < 56 )  /* enough room */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad */
+      while( hd->count < 56 )
+        hd->buf[hd->count++] = 0;  /* pad */
     }
-    else { /* need one extra block */
-       hd->buf[hd->count++] = 0x80; /* pad character */
-       while( hd->count < 64 )
-           hd->buf[hd->count++] = 0;
-       md5_write(hd, NULL, 0);  /* flush */;
-       memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+  else  /* need one extra block */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad character */
+      while( hd->count < 64 )
+        hd->buf[hd->count++] = 0;
+      md5_write(hd, NULL, 0);  /* flush */;
+      memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     }
-    /* append the 64 bit count */
-    hd->buf[56] = lsb     ;
-    hd->buf[57] = lsb >>  8;
-    hd->buf[58] = lsb >> 16;
-    hd->buf[59] = lsb >> 24;
-    hd->buf[60] = msb     ;
-    hd->buf[61] = msb >>  8;
-    hd->buf[62] = msb >> 16;
-    hd->buf[63] = msb >> 24;
-    transform( hd, hd->buf );
-    _gcry_burn_stack (80+6*sizeof(void*));
-
-    p = hd->buf;
+  /* append the 64 bit count */
+  hd->buf[56] = lsb       ;
+  hd->buf[57] = lsb >>  8;
+  hd->buf[58] = lsb >> 16;
+  hd->buf[59] = lsb >> 24;
+  hd->buf[60] = msb       ;
+  hd->buf[61] = msb >>  8;
+  hd->buf[62] = msb >> 16;
+  hd->buf[63] = msb >> 24;
+  transform( hd, hd->buf );
+  _gcry_burn_stack (80+6*sizeof(void*));
+
+  p = hd->buf;
 #ifdef WORDS_BIGENDIAN
 #define X(a) do { *p++ = hd->a      ; *p++ = hd->a >> 8;      \
-                     *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
+                 *p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
 #else /* little endian */
 #define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0)
 #endif
-    X(A);
-    X(B);
-    X(C);
-    X(D);
+  X(A);
+  X(B);
+  X(C);
+  X(D);
 #undef X
 
 }
index d9c60fd..e53880f 100644 (file)
@@ -54,7 +54,7 @@ typedef struct {
     byte  keySched[MAXROUNDS+1][4][4]; /* key schedule         */
     byte  keySched2[MAXROUNDS+1][4][4];        /* key schedule         */
 } RIJNDAEL_context;
-\f
+
 
 static const byte S[256] = {
     99, 124, 119, 123, 242, 107, 111, 197,
@@ -1713,143 +1713,166 @@ static const u32 rcon[30] = {
 static gcry_err_code_t
 do_setkey (RIJNDAEL_context *ctx, const byte *key, const unsigned keylen)
 {
-    static int initialized = 0;
-    static const char *selftest_failed=0;
-    int ROUNDS;
-    byte k[MAXKC][4];
-    int i,j, r, t, rconpointer = 0;
-    byte tk[MAXKC][4];
-    int KC;
-
-    if (!initialized) {
-        initialized = 1;
-        selftest_failed = selftest ();
-        if( selftest_failed )
-            log_error ("%s\n", selftest_failed );
+  static int initialized = 0;
+  static const char *selftest_failed=0;
+  int ROUNDS;
+  byte k[MAXKC][4];
+  int i,j, r, t, rconpointer = 0;
+  byte tk[MAXKC][4];
+  int KC;
+  
+  if (!initialized)
+    {
+      initialized = 1;
+      selftest_failed = selftest ();
+      if( selftest_failed )
+        log_error ("%s\n", selftest_failed );
     }
-    if( selftest_failed )
-        return GPG_ERR_SELFTEST_FAILED;
+  if( selftest_failed )
+    return GPG_ERR_SELFTEST_FAILED;
 
-    if( keylen == 128/8 ) {
-        ROUNDS = 10;
-        KC = 4;
+  if( keylen == 128/8 )
+    {
+      ROUNDS = 10;
+      KC = 4;
     }
-    else if ( keylen == 192/8 ) {
-        ROUNDS = 12;
-        KC = 6;
+  else if ( keylen == 192/8 )
+    {
+      ROUNDS = 12;
+      KC = 6;
     }
-    else if ( keylen == 256/8 ) {
-        ROUNDS = 14;
-        KC = 8;
+  else if ( keylen == 256/8 )
+    {
+      ROUNDS = 14;
+      KC = 8;
     }
-    else
-       return GPG_ERR_INV_KEYLEN;
+  else
+    return GPG_ERR_INV_KEYLEN;
 
-    ctx->ROUNDS = ROUNDS;
-    ctx->decryption_prepared = 0;
+  ctx->ROUNDS = ROUNDS;
+  ctx->decryption_prepared = 0;
 
-    for (i = 0; i < keylen; i++) {
-        k[i >> 2][i & 3] = key[i]; 
+  for (i = 0; i < keylen; i++) 
+    {
+      k[i >> 2][i & 3] = key[i]; 
     }
 #define W (ctx->keySched)
 
-    for (j = KC-1; j >= 0; j--) {
-        *((u32*)tk[j]) = *((u32*)k[j]);
+  for (j = KC-1; j >= 0; j--) 
+    {
+      *((u32*)tk[j]) = *((u32*)k[j]);
     }
-    r = 0;
-    t = 0;
-    /* copy values into round key array */
-    for (j = 0; (j < KC) && (r < ROUNDS + 1); ) {
-        for (; (j < KC) && (t < 4); j++, t++) {
-            *((u32*)W[r][t]) = *((u32*)tk[j]);
+  r = 0;
+  t = 0;
+  /* copy values into round key array */
+  for (j = 0; (j < KC) && (r < ROUNDS + 1); )
+    {
+      for (; (j < KC) && (t < 4); j++, t++)
+        {
+          *((u32*)W[r][t]) = *((u32*)tk[j]);
         }
-        if (t == 4) {
-            r++;
-            t = 0;
+      if (t == 4)
+        {
+          r++;
+          t = 0;
         }
     }
                
-    while (r < ROUNDS + 1) {
-        /* while not enough round key material calculated */
-        /* calculate new values */
-        tk[0][0] ^= S[tk[KC-1][1]];
-        tk[0][1] ^= S[tk[KC-1][2]];
-        tk[0][2] ^= S[tk[KC-1][3]];
-        tk[0][3] ^= S[tk[KC-1][0]];
-        tk[0][0] ^= rcon[rconpointer++];
+  while (r < ROUNDS + 1)
+    {
+      /* While not enough round key material calculated */
+      /* calculate new values. */
+      tk[0][0] ^= S[tk[KC-1][1]];
+      tk[0][1] ^= S[tk[KC-1][2]];
+      tk[0][2] ^= S[tk[KC-1][3]];
+      tk[0][3] ^= S[tk[KC-1][0]];
+      tk[0][0] ^= rcon[rconpointer++];
         
-        if (KC != 8) {
-            for (j = 1; j < KC; j++) {
-                *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
+      if (KC != 8)
+        {
+          for (j = 1; j < KC; j++) 
+            {
+              *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
             }
-        } else {
-            for (j = 1; j < KC/2; j++) {
-                *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
+        } 
+      else 
+        {
+          for (j = 1; j < KC/2; j++)
+            {
+              *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
             }
-            tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
-            tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
-            tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
-            tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
-            for (j = KC/2 + 1; j < KC; j++) {
-                *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
+          tk[KC/2][0] ^= S[tk[KC/2 - 1][0]];
+          tk[KC/2][1] ^= S[tk[KC/2 - 1][1]];
+          tk[KC/2][2] ^= S[tk[KC/2 - 1][2]];
+          tk[KC/2][3] ^= S[tk[KC/2 - 1][3]];
+          for (j = KC/2 + 1; j < KC; j++)
+            {
+              *((u32*)tk[j]) ^= *((u32*)tk[j-1]);
             }
         }
-        /* copy values into round key array */
-        for (j = 0; (j < KC) && (r < ROUNDS + 1); ) {
-            for (; (j < KC) && (t < 4); j++, t++) {
-                *((u32*)W[r][t]) = *((u32*)tk[j]);
+
+      /* Copy values into round key array. */
+      for (j = 0; (j < KC) && (r < ROUNDS + 1); )
+        {
+          for (; (j < KC) && (t < 4); j++, t++)
+            {
+              *((u32*)W[r][t]) = *((u32*)tk[j]);
             }
-            if (t == 4) {
-                r++;
-                t = 0;
+          if (t == 4)
+            {
+              r++;
+              t = 0;
             }
         }
     }          
     
 #undef W    
-    return 0;
+  return 0;
 }
 
 static gcry_err_code_t
 rijndael_setkey (void *context, const byte *key, const unsigned keylen)
 {
-  RIJNDAEL_context *ctx = (RIJNDAEL_context *) context;
+  RIJNDAEL_context *ctx = context;
+
   int rc = do_setkey (ctx, key, keylen);
   _gcry_burn_stack ( 100 + 16*sizeof(int));
   return rc;
 }
 
 
-/* make a decryption  key from an encryption key */
+/* Make a decryption key from an encryption key. */
 static void
 prepare_decryption( RIJNDAEL_context *ctx )
 {
-    int r;
-    byte *w;
-
-    for (r=0; r < MAXROUNDS+1; r++ ) {
-        *((u32*)ctx->keySched2[r][0]) = *((u32*)ctx->keySched[r][0]);
-        *((u32*)ctx->keySched2[r][1]) = *((u32*)ctx->keySched[r][1]);
-        *((u32*)ctx->keySched2[r][2]) = *((u32*)ctx->keySched[r][2]);
-        *((u32*)ctx->keySched2[r][3]) = *((u32*)ctx->keySched[r][3]);
+  int r;
+  byte *w;
+
+  for (r=0; r < MAXROUNDS+1; r++ )
+    {
+      *((u32*)ctx->keySched2[r][0]) = *((u32*)ctx->keySched[r][0]);
+      *((u32*)ctx->keySched2[r][1]) = *((u32*)ctx->keySched[r][1]);
+      *((u32*)ctx->keySched2[r][2]) = *((u32*)ctx->keySched[r][2]);
+      *((u32*)ctx->keySched2[r][3]) = *((u32*)ctx->keySched[r][3]);
     }
 #define W (ctx->keySched2)
-    for (r = 1; r < ctx->ROUNDS; r++) {
-        w = W[r][0];
-        *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
-                   ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
+  for (r = 1; r < ctx->ROUNDS; r++)
+    {
+      w = W[r][0];
+      *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
+        ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
        
-        w = W[r][1];
-        *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
-                   ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
+      w = W[r][1];
+      *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
+        ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
         
-        w = W[r][2];
-        *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
-                   ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
+      w = W[r][2];
+      *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
+        ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
         
-        w = W[r][3];
-        *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
-                   ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
+      w = W[r][3];
+      *((u32*)w) = *((u32*)U1[w[0]]) ^ *((u32*)U2[w[1]])
+        ^ *((u32*)U3[w[2]]) ^ *((u32*)U4[w[3]]);
     }
 #undef W
 }      
@@ -1863,89 +1886,93 @@ do_encrypt (const RIJNDAEL_context *ctx, byte *b, const byte *a)
   /* FIXME: Ugly code, replace by straighter implementaion and use
      optimized assembler for common CPUs. */
 
-    int r;
-    union {
-      u32  tempu32[4];  /* Force correct alignment. */
-      byte temp[4][4];
-    } u;
-    int ROUNDS = ctx->ROUNDS;
+  int r;
+  union {
+    u32  tempu32[4];  /* Force correct alignment. */
+    byte temp[4][4];
+  } u;
+  int ROUNDS = ctx->ROUNDS;
 #define rk (ctx->keySched)
 
-    *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[0][0]);
-    *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[0][1]);
-    *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[0][2]);
-    *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[0][3]);
-    *((u32*)(b    )) = *((u32*)T1[u.temp[0][0]])
-        ^ *((u32*)T2[u.temp[1][1]])
-        ^ *((u32*)T3[u.temp[2][2]]) 
-        ^ *((u32*)T4[u.temp[3][3]]);
-    *((u32*)(b + 4)) = *((u32*)T1[u.temp[1][0]])
-        ^ *((u32*)T2[u.temp[2][1]])
-        ^ *((u32*)T3[u.temp[3][2]]) 
-        ^ *((u32*)T4[u.temp[0][3]]);
-    *((u32*)(b + 8)) = *((u32*)T1[u.temp[2][0]])
-        ^ *((u32*)T2[u.temp[3][1]])
-        ^ *((u32*)T3[u.temp[0][2]]) 
-        ^ *((u32*)T4[u.temp[1][3]]);
-    *((u32*)(b +12)) = *((u32*)T1[u.temp[3][0]])
-        ^ *((u32*)T2[u.temp[0][1]])
-        ^ *((u32*)T3[u.temp[1][2]]) 
-        ^ *((u32*)T4[u.temp[2][3]]);
-    for (r = 1; r < ROUNDS-1; r++) {
-        *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
-        *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
-        *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
-        *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
-
-        *((u32*)(b    )) = *((u32*)T1[u.temp[0][0]])
-            ^ *((u32*)T2[u.temp[1][1]])
-            ^ *((u32*)T3[u.temp[2][2]]) 
-            ^ *((u32*)T4[u.temp[3][3]]);
-        *((u32*)(b + 4)) = *((u32*)T1[u.temp[1][0]])
-            ^ *((u32*)T2[u.temp[2][1]])
-            ^ *((u32*)T3[u.temp[3][2]]) 
-            ^ *((u32*)T4[u.temp[0][3]]);
-        *((u32*)(b + 8)) = *((u32*)T1[u.temp[2][0]])
-            ^ *((u32*)T2[u.temp[3][1]])
-            ^ *((u32*)T3[u.temp[0][2]]) 
-            ^ *((u32*)T4[u.temp[1][3]]);
-        *((u32*)(b +12)) = *((u32*)T1[u.temp[3][0]])
-            ^ *((u32*)T2[u.temp[0][1]])
-            ^ *((u32*)T3[u.temp[1][2]]) 
-            ^ *((u32*)T4[u.temp[2][3]]);
+  *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[0][0]);
+  *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[0][1]);
+  *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[0][2]);
+  *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[0][3]);
+  *((u32*)(b    )) = (*((u32*)T1[u.temp[0][0]])
+                      ^ *((u32*)T2[u.temp[1][1]])
+                      ^ *((u32*)T3[u.temp[2][2]]) 
+                      ^ *((u32*)T4[u.temp[3][3]]));
+  *((u32*)(b + 4)) = (*((u32*)T1[u.temp[1][0]])
+                      ^ *((u32*)T2[u.temp[2][1]])
+                      ^ *((u32*)T3[u.temp[3][2]]) 
+                      ^ *((u32*)T4[u.temp[0][3]]));
+  *((u32*)(b + 8)) = (*((u32*)T1[u.temp[2][0]])
+                      ^ *((u32*)T2[u.temp[3][1]])
+                      ^ *((u32*)T3[u.temp[0][2]]) 
+                      ^ *((u32*)T4[u.temp[1][3]]));
+  *((u32*)(b +12)) = (*((u32*)T1[u.temp[3][0]])
+                      ^ *((u32*)T2[u.temp[0][1]])
+                      ^ *((u32*)T3[u.temp[1][2]]) 
+                      ^ *((u32*)T4[u.temp[2][3]]));
+
+  for (r = 1; r < ROUNDS-1; r++)
+    {
+      *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
+      *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
+      *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
+      *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
+
+      *((u32*)(b    )) = (*((u32*)T1[u.temp[0][0]])
+                          ^ *((u32*)T2[u.temp[1][1]])
+                          ^ *((u32*)T3[u.temp[2][2]]) 
+                          ^ *((u32*)T4[u.temp[3][3]]));
+      *((u32*)(b + 4)) = (*((u32*)T1[u.temp[1][0]])
+                          ^ *((u32*)T2[u.temp[2][1]])
+                          ^ *((u32*)T3[u.temp[3][2]]) 
+                          ^ *((u32*)T4[u.temp[0][3]]));
+      *((u32*)(b + 8)) = (*((u32*)T1[u.temp[2][0]])
+                          ^ *((u32*)T2[u.temp[3][1]])
+                          ^ *((u32*)T3[u.temp[0][2]]) 
+                          ^ *((u32*)T4[u.temp[1][3]]));
+      *((u32*)(b +12)) = (*((u32*)T1[u.temp[3][0]])
+                          ^ *((u32*)T2[u.temp[0][1]])
+                          ^ *((u32*)T3[u.temp[1][2]]) 
+                          ^ *((u32*)T4[u.temp[2][3]]));
     }
-    /* last round is special */   
-    *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[ROUNDS-1][0]);
-    *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[ROUNDS-1][1]);
-    *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[ROUNDS-1][2]);
-    *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[ROUNDS-1][3]);
-    b[ 0] = T1[u.temp[0][0]][1];
-    b[ 1] = T1[u.temp[1][1]][1];
-    b[ 2] = T1[u.temp[2][2]][1];
-    b[ 3] = T1[u.temp[3][3]][1];
-    b[ 4] = T1[u.temp[1][0]][1];
-    b[ 5] = T1[u.temp[2][1]][1];
-    b[ 6] = T1[u.temp[3][2]][1];
-    b[ 7] = T1[u.temp[0][3]][1];
-    b[ 8] = T1[u.temp[2][0]][1];
-    b[ 9] = T1[u.temp[3][1]][1];
-    b[10] = T1[u.temp[0][2]][1];
-    b[11] = T1[u.temp[1][3]][1];
-    b[12] = T1[u.temp[3][0]][1];
-    b[13] = T1[u.temp[0][1]][1];
-    b[14] = T1[u.temp[1][2]][1];
-    b[15] = T1[u.temp[2][3]][1];
-    *((u32*)(b   )) ^= *((u32*)rk[ROUNDS][0]);
-    *((u32*)(b+ 4)) ^= *((u32*)rk[ROUNDS][1]);
-    *((u32*)(b+ 8)) ^= *((u32*)rk[ROUNDS][2]);
-    *((u32*)(b+12)) ^= *((u32*)rk[ROUNDS][3]);
+
+  /* Last round is special. */   
+  *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[ROUNDS-1][0]);
+  *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[ROUNDS-1][1]);
+  *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[ROUNDS-1][2]);
+  *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[ROUNDS-1][3]);
+  b[ 0] = T1[u.temp[0][0]][1];
+  b[ 1] = T1[u.temp[1][1]][1];
+  b[ 2] = T1[u.temp[2][2]][1];
+  b[ 3] = T1[u.temp[3][3]][1];
+  b[ 4] = T1[u.temp[1][0]][1];
+  b[ 5] = T1[u.temp[2][1]][1];
+  b[ 6] = T1[u.temp[3][2]][1];
+  b[ 7] = T1[u.temp[0][3]][1];
+  b[ 8] = T1[u.temp[2][0]][1];
+  b[ 9] = T1[u.temp[3][1]][1];
+  b[10] = T1[u.temp[0][2]][1];
+  b[11] = T1[u.temp[1][3]][1];
+  b[12] = T1[u.temp[3][0]][1];
+  b[13] = T1[u.temp[0][1]][1];
+  b[14] = T1[u.temp[1][2]][1];
+  b[15] = T1[u.temp[2][3]][1];
+  *((u32*)(b   )) ^= *((u32*)rk[ROUNDS][0]);
+  *((u32*)(b+ 4)) ^= *((u32*)rk[ROUNDS][1]);
+  *((u32*)(b+ 8)) ^= *((u32*)rk[ROUNDS][2]);
+  *((u32*)(b+12)) ^= *((u32*)rk[ROUNDS][3]);
 #undef rk
 }
 
 static void
 rijndael_encrypt (void *context, byte *b, const byte *a)
 {
-  RIJNDAEL_context *ctx = (RIJNDAEL_context *) context;
+  RIJNDAEL_context *ctx = context;
+
   do_encrypt (ctx, b, a);
   _gcry_burn_stack (16 + 2*sizeof(int));
 }
@@ -1957,176 +1984,181 @@ static void
 do_decrypt (RIJNDAEL_context *ctx, byte *b, const byte *a)
 {
 #define rk  (ctx->keySched2)
-    int ROUNDS = ctx->ROUNDS; 
-    int r;
-    union {
-      u32  tempu32[4];  /* Force correct alignment. */
-      byte temp[4][4];
-    } u;
-
-    if ( !ctx->decryption_prepared ) {
-        prepare_decryption ( ctx );
-        _gcry_burn_stack (64);
-        ctx->decryption_prepared = 1;
+  int ROUNDS = ctx->ROUNDS; 
+  int r;
+  union {
+    u32  tempu32[4];  /* Force correct alignment. */
+    byte temp[4][4];
+  } u;
+
+  if ( !ctx->decryption_prepared )
+    {
+      prepare_decryption ( ctx );
+      _gcry_burn_stack (64);
+      ctx->decryption_prepared = 1;
     }
     
-    *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[ROUNDS][0]);
-    *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[ROUNDS][1]);
-    *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[ROUNDS][2]);
-    *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[ROUNDS][3]);
+  *((u32*)u.temp[0]) = *((u32*)(a   )) ^ *((u32*)rk[ROUNDS][0]);
+  *((u32*)u.temp[1]) = *((u32*)(a+ 4)) ^ *((u32*)rk[ROUNDS][1]);
+  *((u32*)u.temp[2]) = *((u32*)(a+ 8)) ^ *((u32*)rk[ROUNDS][2]);
+  *((u32*)u.temp[3]) = *((u32*)(a+12)) ^ *((u32*)rk[ROUNDS][3]);
   
-    *((u32*)(b   )) = *((u32*)T5[u.temp[0][0]])
-        ^ *((u32*)T6[u.temp[3][1]])
-        ^ *((u32*)T7[u.temp[2][2]]) 
-        ^ *((u32*)T8[u.temp[1][3]]);
-    *((u32*)(b+ 4)) = *((u32*)T5[u.temp[1][0]])
-        ^ *((u32*)T6[u.temp[0][1]])
-        ^ *((u32*)T7[u.temp[3][2]]) 
-        ^ *((u32*)T8[u.temp[2][3]]);
-    *((u32*)(b+ 8)) = *((u32*)T5[u.temp[2][0]])
-        ^ *((u32*)T6[u.temp[1][1]])
-        ^ *((u32*)T7[u.temp[0][2]]) 
-        ^ *((u32*)T8[u.temp[3][3]]);
-    *((u32*)(b+12)) = *((u32*)T5[u.temp[3][0]])
-        ^ *((u32*)T6[u.temp[2][1]])
-        ^ *((u32*)T7[u.temp[1][2]]) 
-        ^ *((u32*)T8[u.temp[0][3]]);
-    for (r = ROUNDS-1; r > 1; r--) {
-               *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
-               *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
-               *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
-               *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
-               *((u32*)(b   )) = *((u32*)T5[u.temp[0][0]])
-           ^ *((u32*)T6[u.temp[3][1]])
-           ^ *((u32*)T7[u.temp[2][2]]) 
-           ^ *((u32*)T8[u.temp[1][3]]);
-               *((u32*)(b+ 4)) = *((u32*)T5[u.temp[1][0]])
-           ^ *((u32*)T6[u.temp[0][1]])
-           ^ *((u32*)T7[u.temp[3][2]]) 
-           ^ *((u32*)T8[u.temp[2][3]]);
-               *((u32*)(b+ 8)) = *((u32*)T5[u.temp[2][0]])
-           ^ *((u32*)T6[u.temp[1][1]])
-           ^ *((u32*)T7[u.temp[0][2]]) 
-           ^ *((u32*)T8[u.temp[3][3]]);
-               *((u32*)(b+12)) = *((u32*)T5[u.temp[3][0]])
-           ^ *((u32*)T6[u.temp[2][1]])
-           ^ *((u32*)T7[u.temp[1][2]]) 
-           ^ *((u32*)T8[u.temp[0][3]]);
-       }
-       /* last round is special */   
-       *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[1][0]);
-       *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[1][1]);
-       *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[1][2]);
-       *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[1][3]);
-       b[ 0] = S5[u.temp[0][0]];
-       b[ 1] = S5[u.temp[3][1]];
-       b[ 2] = S5[u.temp[2][2]];
-       b[ 3] = S5[u.temp[1][3]];
-       b[ 4] = S5[u.temp[1][0]];
-       b[ 5] = S5[u.temp[0][1]];
-       b[ 6] = S5[u.temp[3][2]];
-       b[ 7] = S5[u.temp[2][3]];
-       b[ 8] = S5[u.temp[2][0]];
-       b[ 9] = S5[u.temp[1][1]];
-       b[10] = S5[u.temp[0][2]];
-       b[11] = S5[u.temp[3][3]];
-       b[12] = S5[u.temp[3][0]];
-       b[13] = S5[u.temp[2][1]];
-       b[14] = S5[u.temp[1][2]];
-       b[15] = S5[u.temp[0][3]];
-       *((u32*)(b   )) ^= *((u32*)rk[0][0]);
-       *((u32*)(b+ 4)) ^= *((u32*)rk[0][1]);
-       *((u32*)(b+ 8)) ^= *((u32*)rk[0][2]);
-       *((u32*)(b+12)) ^= *((u32*)rk[0][3]);
+  *((u32*)(b   )) = (*((u32*)T5[u.temp[0][0]])
+                     ^ *((u32*)T6[u.temp[3][1]])
+                     ^ *((u32*)T7[u.temp[2][2]]) 
+                     ^ *((u32*)T8[u.temp[1][3]]));
+  *((u32*)(b+ 4)) = (*((u32*)T5[u.temp[1][0]])
+                     ^ *((u32*)T6[u.temp[0][1]])
+                     ^ *((u32*)T7[u.temp[3][2]]) 
+                     ^ *((u32*)T8[u.temp[2][3]]));
+  *((u32*)(b+ 8)) = (*((u32*)T5[u.temp[2][0]])
+                     ^ *((u32*)T6[u.temp[1][1]])
+                     ^ *((u32*)T7[u.temp[0][2]]) 
+                     ^ *((u32*)T8[u.temp[3][3]]));
+  *((u32*)(b+12)) = (*((u32*)T5[u.temp[3][0]])
+                     ^ *((u32*)T6[u.temp[2][1]])
+                     ^ *((u32*)T7[u.temp[1][2]]) 
+                     ^ *((u32*)T8[u.temp[0][3]]));
+
+  for (r = ROUNDS-1; r > 1; r--)
+    {
+      *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[r][0]);
+      *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[r][1]);
+      *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[r][2]);
+      *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[r][3]);
+      *((u32*)(b   )) = (*((u32*)T5[u.temp[0][0]])
+                         ^ *((u32*)T6[u.temp[3][1]])
+                         ^ *((u32*)T7[u.temp[2][2]]) 
+                         ^ *((u32*)T8[u.temp[1][3]]));
+      *((u32*)(b+ 4)) = (*((u32*)T5[u.temp[1][0]])
+                         ^ *((u32*)T6[u.temp[0][1]])
+                         ^ *((u32*)T7[u.temp[3][2]]) 
+                         ^ *((u32*)T8[u.temp[2][3]]));
+      *((u32*)(b+ 8)) = (*((u32*)T5[u.temp[2][0]])
+                         ^ *((u32*)T6[u.temp[1][1]])
+                         ^ *((u32*)T7[u.temp[0][2]]) 
+                         ^ *((u32*)T8[u.temp[3][3]]));
+      *((u32*)(b+12)) = (*((u32*)T5[u.temp[3][0]])
+                         ^ *((u32*)T6[u.temp[2][1]])
+                         ^ *((u32*)T7[u.temp[1][2]]) 
+                         ^ *((u32*)T8[u.temp[0][3]]));
+    }
+
+  /* Last round is special. */   
+  *((u32*)u.temp[0]) = *((u32*)(b   )) ^ *((u32*)rk[1][0]);
+  *((u32*)u.temp[1]) = *((u32*)(b+ 4)) ^ *((u32*)rk[1][1]);
+  *((u32*)u.temp[2]) = *((u32*)(b+ 8)) ^ *((u32*)rk[1][2]);
+  *((u32*)u.temp[3]) = *((u32*)(b+12)) ^ *((u32*)rk[1][3]);
+  b[ 0] = S5[u.temp[0][0]];
+  b[ 1] = S5[u.temp[3][1]];
+  b[ 2] = S5[u.temp[2][2]];
+  b[ 3] = S5[u.temp[1][3]];
+  b[ 4] = S5[u.temp[1][0]];
+  b[ 5] = S5[u.temp[0][1]];
+  b[ 6] = S5[u.temp[3][2]];
+  b[ 7] = S5[u.temp[2][3]];
+  b[ 8] = S5[u.temp[2][0]];
+  b[ 9] = S5[u.temp[1][1]];
+  b[10] = S5[u.temp[0][2]];
+  b[11] = S5[u.temp[3][3]];
+  b[12] = S5[u.temp[3][0]];
+  b[13] = S5[u.temp[2][1]];
+  b[14] = S5[u.temp[1][2]];
+  b[15] = S5[u.temp[0][3]];
+  *((u32*)(b   )) ^= *((u32*)rk[0][0]);
+  *((u32*)(b+ 4)) ^= *((u32*)rk[0][1]);
+  *((u32*)(b+ 8)) ^= *((u32*)rk[0][2]);
+  *((u32*)(b+12)) ^= *((u32*)rk[0][3]);
 #undef rk
 }
 
 static void
 rijndael_decrypt (void *context, byte *b, const byte *a)
 {
-  RIJNDAEL_context *ctx = (RIJNDAEL_context *) context;
+  RIJNDAEL_context *ctx = context;
+
   do_decrypt (ctx, b, a);
   _gcry_burn_stack (16+2*sizeof(int));
 }
+
 \f
 /* Test a single encryption and decryption with each key size. */
-
 static const char*
 selftest (void)
 {
-    RIJNDAEL_context ctx;
-    byte scratch[16];     
-
-    /* The test vectors are from the AES supplied ones; more or less 
-     * randomly taken from ecb_tbl.txt (I=42,81,14)
-     */
-    static byte plaintext[16] = {
-       0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
-       0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
-    };
-    static byte key[16] = {
-        0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
-        0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
-    };
-    static const byte ciphertext[16] = {
-        0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
-        0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
-    };
-
-    static byte plaintext_192[16] = {
-        0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
-        0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
-    };
-    static byte key_192[24] = {
-        0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
-        0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
-        0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
-    };
-    static const byte ciphertext_192[16] = {
-        0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
-        0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
-    };
+  RIJNDAEL_context ctx;
+  byte scratch[16];       
+
+  /* The test vectors are from the AES supplied ones; more or less 
+   * randomly taken from ecb_tbl.txt (I=42,81,14)
+   */
+  static byte plaintext[16] = {
+    0x01,0x4B,0xAF,0x22,0x78,0xA6,0x9D,0x33,
+    0x1D,0x51,0x80,0x10,0x36,0x43,0xE9,0x9A
+  };
+  static byte key[16] = {
+    0xE8,0xE9,0xEA,0xEB,0xED,0xEE,0xEF,0xF0,
+    0xF2,0xF3,0xF4,0xF5,0xF7,0xF8,0xF9,0xFA
+  };
+  static const byte ciphertext[16] = {
+    0x67,0x43,0xC3,0xD1,0x51,0x9A,0xB4,0xF2,
+    0xCD,0x9A,0x78,0xAB,0x09,0xA5,0x11,0xBD
+  };
+
+  static byte plaintext_192[16] = {
+    0x76,0x77,0x74,0x75,0xF1,0xF2,0xF3,0xF4,
+    0xF8,0xF9,0xE6,0xE7,0x77,0x70,0x71,0x72
+  };
+  static byte key_192[24] = {
+    0x04,0x05,0x06,0x07,0x09,0x0A,0x0B,0x0C,
+    0x0E,0x0F,0x10,0x11,0x13,0x14,0x15,0x16,
+    0x18,0x19,0x1A,0x1B,0x1D,0x1E,0x1F,0x20
+  };
+  static const byte ciphertext_192[16] = {
+    0x5D,0x1E,0xF2,0x0D,0xCE,0xD6,0xBC,0xBC,
+    0x12,0x13,0x1A,0xC7,0xC5,0x47,0x88,0xAA
+  };
     
-    static byte plaintext_256[16] = {
-        0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
-        0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
-    };
-    static byte key_256[32] = {
-        0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
-        0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
-        0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
-        0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
-    };
-    static const byte ciphertext_256[16] = {
-        0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
-        0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
-    };
-
-    rijndael_setkey (&ctx, key, sizeof(key));
-    rijndael_encrypt (&ctx, scratch, plaintext);
-    if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
-        return "Rijndael-128 test encryption failed.";
-    rijndael_decrypt (&ctx, scratch, scratch);
-    if (memcmp (scratch, plaintext, sizeof (plaintext)))
-        return "Rijndael-128 test decryption failed.";
-
-    rijndael_setkey (&ctx, key_192, sizeof(key_192));
-    rijndael_encrypt (&ctx, scratch, plaintext_192);
-    if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
-        return "Rijndael-192 test encryption failed.";
-    rijndael_decrypt (&ctx, scratch, scratch);
-    if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
-        return "Rijndael-192 test decryption failed.";
+  static byte plaintext_256[16] = {
+    0x06,0x9A,0x00,0x7F,0xC7,0x6A,0x45,0x9F,
+    0x98,0xBA,0xF9,0x17,0xFE,0xDF,0x95,0x21
+  };
+  static byte key_256[32] = {
+    0x08,0x09,0x0A,0x0B,0x0D,0x0E,0x0F,0x10,
+    0x12,0x13,0x14,0x15,0x17,0x18,0x19,0x1A,
+    0x1C,0x1D,0x1E,0x1F,0x21,0x22,0x23,0x24,
+    0x26,0x27,0x28,0x29,0x2B,0x2C,0x2D,0x2E
+  };
+  static const byte ciphertext_256[16] = {
+    0x08,0x0E,0x95,0x17,0xEB,0x16,0x77,0x71,
+    0x9A,0xCF,0x72,0x80,0x86,0x04,0x0A,0xE3
+  };
+
+  rijndael_setkey (&ctx, key, sizeof(key));
+  rijndael_encrypt (&ctx, scratch, plaintext);
+  if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
+    return "Rijndael-128 test encryption failed.";
+  rijndael_decrypt (&ctx, scratch, scratch);
+  if (memcmp (scratch, plaintext, sizeof (plaintext)))
+    return "Rijndael-128 test decryption failed.";
+
+  rijndael_setkey (&ctx, key_192, sizeof(key_192));
+  rijndael_encrypt (&ctx, scratch, plaintext_192);
+  if (memcmp (scratch, ciphertext_192, sizeof (ciphertext_192)))
+    return "Rijndael-192 test encryption failed.";
+  rijndael_decrypt (&ctx, scratch, scratch);
+  if (memcmp (scratch, plaintext_192, sizeof (plaintext_192)))
+    return "Rijndael-192 test decryption failed.";
     
-    rijndael_setkey (&ctx, key_256, sizeof(key_256));
-    rijndael_encrypt (&ctx, scratch, plaintext_256);
-    if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
-        return "Rijndael-256 test encryption failed.";
-    rijndael_decrypt (&ctx, scratch, scratch);
-    if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
-        return "Rijndael-256 test decryption failed.";
+  rijndael_setkey (&ctx, key_256, sizeof(key_256));
+  rijndael_encrypt (&ctx, scratch, plaintext_256);
+  if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
+    return "Rijndael-256 test encryption failed.";
+  rijndael_decrypt (&ctx, scratch, scratch);
+  if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
+    return "Rijndael-256 test decryption failed.";
     
-    return NULL;
+  return NULL;
 }
 
 \f
@@ -2190,6 +2222,7 @@ static gcry_cipher_oid_spec_t rijndael256_oids[] =
 
 gcry_cipher_spec_t _gcry_cipher_spec_aes256 =
   {
-    "AES256", rijndael256_names, rijndael256_oids, 16, 256, sizeof (RIJNDAEL_context),
+    "AES256", rijndael256_names, rijndael256_oids, 16, 256,
+    sizeof (RIJNDAEL_context),
     rijndael_setkey, rijndael_encrypt, rijndael_decrypt,
   };
index e32917f..f450f2b 100644 (file)
 void
 _gcry_rmd160_init (void *context)
 {
-  RMD160_CONTEXT *hd = (RMD160_CONTEXT *) context;
-    hd->h0 = 0x67452301;
-    hd->h1 = 0xEFCDAB89;
-    hd->h2 = 0x98BADCFE;
-    hd->h3 = 0x10325476;
-    hd->h4 = 0xC3D2E1F0;
-    hd->nblocks = 0;
-    hd->count = 0;
+  RMD160_CONTEXT *hd = context;
+
+  hd->h0 = 0x67452301;
+  hd->h1 = 0xEFCDAB89;
+  hd->h2 = 0x98BADCFE;
+  hd->h3 = 0x10325476;
+  hd->h4 = 0xC3D2E1F0;
+  hd->nblocks = 0;
+  hd->count = 0;
 }
 
 
@@ -166,17 +167,19 @@ transform( RMD160_CONTEXT *hd, byte *data )
   u32 aa,bb,cc,dd,ee,t;
 #ifdef WORDS_BIGENDIAN
   u32 x[16];
-  { int i;
-  byte *p2, *p1;
-  for(i=0, p1=data, p2=(byte*)x; i < 16; i++, p2 += 4 ) {
-    p2[3] = *p1++;
-    p2[2] = *p1++;
-    p2[1] = *p1++;
-    p2[0] = *p1++;
-  }
+  {
+    int i;
+    byte *p2, *p1;
+    for (i=0, p1=data, p2=(byte*)x; i < 16; i++, p2 += 4 )
+      {
+        p2[3] = *p1++;
+        p2[2] = *p1++;
+        p2[1] = *p1++;
+        p2[0] = *p1++;
+      }
   }
 #else
-  /* this version is better because it is always aligned;
+  /* This version is better because it is always aligned;
    * The performance penalty on a 586-100 is about 6% which
    * is acceptable - because the data is more local it might
    * also be possible that this is faster on some machines.
@@ -208,189 +211,189 @@ transform( RMD160_CONTEXT *hd, byte *data )
                                  c = rol(c,10);               \
                                } while(0)
 
-    /* left lane */
-    a = hd->h0;
-    b = hd->h1;
-    c = hd->h2;
-    d = hd->h3;
-    e = hd->h4;
-    R( a, b, c, d, e, F0, K0,  0, 11 );
-    R( e, a, b, c, d, F0, K0,  1, 14 );
-    R( d, e, a, b, c, F0, K0,  2, 15 );
-    R( c, d, e, a, b, F0, K0,  3, 12 );
-    R( b, c, d, e, a, F0, K0,  4,  5 );
-    R( a, b, c, d, e, F0, K0,  5,  8 );
-    R( e, a, b, c, d, F0, K0,  6,  7 );
-    R( d, e, a, b, c, F0, K0,  7,  9 );
-    R( c, d, e, a, b, F0, K0,  8, 11 );
-    R( b, c, d, e, a, F0, K0,  9, 13 );
-    R( a, b, c, d, e, F0, K0, 10, 14 );
-    R( e, a, b, c, d, F0, K0, 11, 15 );
-    R( d, e, a, b, c, F0, K0, 12,  6 );
-    R( c, d, e, a, b, F0, K0, 13,  7 );
-    R( b, c, d, e, a, F0, K0, 14,  9 );
-    R( a, b, c, d, e, F0, K0, 15,  8 );
-    R( e, a, b, c, d, F1, K1,  7,  7 );
-    R( d, e, a, b, c, F1, K1,  4,  6 );
-    R( c, d, e, a, b, F1, K1, 13,  8 );
-    R( b, c, d, e, a, F1, K1,  1, 13 );
-    R( a, b, c, d, e, F1, K1, 10, 11 );
-    R( e, a, b, c, d, F1, K1,  6,  9 );
-    R( d, e, a, b, c, F1, K1, 15,  7 );
-    R( c, d, e, a, b, F1, K1,  3, 15 );
-    R( b, c, d, e, a, F1, K1, 12,  7 );
-    R( a, b, c, d, e, F1, K1,  0, 12 );
-    R( e, a, b, c, d, F1, K1,  9, 15 );
-    R( d, e, a, b, c, F1, K1,  5,  9 );
-    R( c, d, e, a, b, F1, K1,  2, 11 );
-    R( b, c, d, e, a, F1, K1, 14,  7 );
-    R( a, b, c, d, e, F1, K1, 11, 13 );
-    R( e, a, b, c, d, F1, K1,  8, 12 );
-    R( d, e, a, b, c, F2, K2,  3, 11 );
-    R( c, d, e, a, b, F2, K2, 10, 13 );
-    R( b, c, d, e, a, F2, K2, 14,  6 );
-    R( a, b, c, d, e, F2, K2,  4,  7 );
-    R( e, a, b, c, d, F2, K2,  9, 14 );
-    R( d, e, a, b, c, F2, K2, 15,  9 );
-    R( c, d, e, a, b, F2, K2,  8, 13 );
-    R( b, c, d, e, a, F2, K2,  1, 15 );
-    R( a, b, c, d, e, F2, K2,  2, 14 );
-    R( e, a, b, c, d, F2, K2,  7,  8 );
-    R( d, e, a, b, c, F2, K2,  0, 13 );
-    R( c, d, e, a, b, F2, K2,  6,  6 );
-    R( b, c, d, e, a, F2, K2, 13,  5 );
-    R( a, b, c, d, e, F2, K2, 11, 12 );
-    R( e, a, b, c, d, F2, K2,  5,  7 );
-    R( d, e, a, b, c, F2, K2, 12,  5 );
-    R( c, d, e, a, b, F3, K3,  1, 11 );
-    R( b, c, d, e, a, F3, K3,  9, 12 );
-    R( a, b, c, d, e, F3, K3, 11, 14 );
-    R( e, a, b, c, d, F3, K3, 10, 15 );
-    R( d, e, a, b, c, F3, K3,  0, 14 );
-    R( c, d, e, a, b, F3, K3,  8, 15 );
-    R( b, c, d, e, a, F3, K3, 12,  9 );
-    R( a, b, c, d, e, F3, K3,  4,  8 );
-    R( e, a, b, c, d, F3, K3, 13,  9 );
-    R( d, e, a, b, c, F3, K3,  3, 14 );
-    R( c, d, e, a, b, F3, K3,  7,  5 );
-    R( b, c, d, e, a, F3, K3, 15,  6 );
-    R( a, b, c, d, e, F3, K3, 14,  8 );
-    R( e, a, b, c, d, F3, K3,  5,  6 );
-    R( d, e, a, b, c, F3, K3,  6,  5 );
-    R( c, d, e, a, b, F3, K3,  2, 12 );
-    R( b, c, d, e, a, F4, K4,  4,  9 );
-    R( a, b, c, d, e, F4, K4,  0, 15 );
-    R( e, a, b, c, d, F4, K4,  5,  5 );
-    R( d, e, a, b, c, F4, K4,  9, 11 );
-    R( c, d, e, a, b, F4, K4,  7,  6 );
-    R( b, c, d, e, a, F4, K4, 12,  8 );
-    R( a, b, c, d, e, F4, K4,  2, 13 );
-    R( e, a, b, c, d, F4, K4, 10, 12 );
-    R( d, e, a, b, c, F4, K4, 14,  5 );
-    R( c, d, e, a, b, F4, K4,  1, 12 );
-    R( b, c, d, e, a, F4, K4,  3, 13 );
-    R( a, b, c, d, e, F4, K4,  8, 14 );
-    R( e, a, b, c, d, F4, K4, 11, 11 );
-    R( d, e, a, b, c, F4, K4,  6,  8 );
-    R( c, d, e, a, b, F4, K4, 15,  5 );
-    R( b, c, d, e, a, F4, K4, 13,  6 );
-
-    aa = a; bb = b; cc = c; dd = d; ee = e;
-
-    /* right lane */
-    a = hd->h0;
-    b = hd->h1;
-    c = hd->h2;
-    d = hd->h3;
-    e = hd->h4;
-    R( a, b, c, d, e, F4, KK0, 5,  8);
-    R( e, a, b, c, d, F4, KK0, 14,  9);
-    R( d, e, a, b, c, F4, KK0, 7,  9);
-    R( c, d, e, a, b, F4, KK0, 0, 11);
-    R( b, c, d, e, a, F4, KK0, 9, 13);
-    R( a, b, c, d, e, F4, KK0, 2, 15);
-    R( e, a, b, c, d, F4, KK0, 11, 15);
-    R( d, e, a, b, c, F4, KK0, 4,  5);
-    R( c, d, e, a, b, F4, KK0, 13,  7);
-    R( b, c, d, e, a, F4, KK0, 6,  7);
-    R( a, b, c, d, e, F4, KK0, 15,  8);
-    R( e, a, b, c, d, F4, KK0, 8, 11);
-    R( d, e, a, b, c, F4, KK0, 1, 14);
-    R( c, d, e, a, b, F4, KK0, 10, 14);
-    R( b, c, d, e, a, F4, KK0, 3, 12);
-    R( a, b, c, d, e, F4, KK0, 12,  6);
-    R( e, a, b, c, d, F3, KK1, 6,  9);
-    R( d, e, a, b, c, F3, KK1, 11, 13);
-    R( c, d, e, a, b, F3, KK1, 3, 15);
-    R( b, c, d, e, a, F3, KK1, 7,  7);
-    R( a, b, c, d, e, F3, KK1, 0, 12);
-    R( e, a, b, c, d, F3, KK1, 13,  8);
-    R( d, e, a, b, c, F3, KK1, 5,  9);
-    R( c, d, e, a, b, F3, KK1, 10, 11);
-    R( b, c, d, e, a, F3, KK1, 14,  7);
-    R( a, b, c, d, e, F3, KK1, 15,  7);
-    R( e, a, b, c, d, F3, KK1, 8, 12);
-    R( d, e, a, b, c, F3, KK1, 12,  7);
-    R( c, d, e, a, b, F3, KK1, 4,  6);
-    R( b, c, d, e, a, F3, KK1, 9, 15);
-    R( a, b, c, d, e, F3, KK1, 1, 13);
-    R( e, a, b, c, d, F3, KK1, 2, 11);
-    R( d, e, a, b, c, F2, KK2, 15,  9);
-    R( c, d, e, a, b, F2, KK2, 5,  7);
-    R( b, c, d, e, a, F2, KK2, 1, 15);
-    R( a, b, c, d, e, F2, KK2, 3, 11);
-    R( e, a, b, c, d, F2, KK2, 7,  8);
-    R( d, e, a, b, c, F2, KK2, 14,  6);
-    R( c, d, e, a, b, F2, KK2, 6,  6);
-    R( b, c, d, e, a, F2, KK2, 9, 14);
-    R( a, b, c, d, e, F2, KK2, 11, 12);
-    R( e, a, b, c, d, F2, KK2, 8, 13);
-    R( d, e, a, b, c, F2, KK2, 12,  5);
-    R( c, d, e, a, b, F2, KK2, 2, 14);
-    R( b, c, d, e, a, F2, KK2, 10, 13);
-    R( a, b, c, d, e, F2, KK2, 0, 13);
-    R( e, a, b, c, d, F2, KK2, 4,  7);
-    R( d, e, a, b, c, F2, KK2, 13,  5);
-    R( c, d, e, a, b, F1, KK3, 8, 15);
-    R( b, c, d, e, a, F1, KK3, 6,  5);
-    R( a, b, c, d, e, F1, KK3, 4,  8);
-    R( e, a, b, c, d, F1, KK3, 1, 11);
-    R( d, e, a, b, c, F1, KK3, 3, 14);
-    R( c, d, e, a, b, F1, KK3, 11, 14);
-    R( b, c, d, e, a, F1, KK3, 15,  6);
-    R( a, b, c, d, e, F1, KK3, 0, 14);
-    R( e, a, b, c, d, F1, KK3, 5,  6);
-    R( d, e, a, b, c, F1, KK3, 12,  9);
-    R( c, d, e, a, b, F1, KK3, 2, 12);
-    R( b, c, d, e, a, F1, KK3, 13,  9);
-    R( a, b, c, d, e, F1, KK3, 9, 12);
-    R( e, a, b, c, d, F1, KK3, 7,  5);
-    R( d, e, a, b, c, F1, KK3, 10, 15);
-    R( c, d, e, a, b, F1, KK3, 14,  8);
-    R( b, c, d, e, a, F0, KK4, 12,  8);
-    R( a, b, c, d, e, F0, KK4, 15,  5);
-    R( e, a, b, c, d, F0, KK4, 10, 12);
-    R( d, e, a, b, c, F0, KK4, 4,  9);
-    R( c, d, e, a, b, F0, KK4, 1, 12);
-    R( b, c, d, e, a, F0, KK4, 5,  5);
-    R( a, b, c, d, e, F0, KK4, 8, 14);
-    R( e, a, b, c, d, F0, KK4, 7,  6);
-    R( d, e, a, b, c, F0, KK4, 6,  8);
-    R( c, d, e, a, b, F0, KK4, 2, 13);
-    R( b, c, d, e, a, F0, KK4, 13,  6);
-    R( a, b, c, d, e, F0, KK4, 14,  5);
-    R( e, a, b, c, d, F0, KK4, 0, 15);
-    R( d, e, a, b, c, F0, KK4, 3, 13);
-    R( c, d, e, a, b, F0, KK4, 9, 11);
-    R( b, c, d, e, a, F0, KK4, 11, 11);
-
-
-    t     = hd->h1 + d + cc;
-    hd->h1 = hd->h2 + e + dd;
-    hd->h2 = hd->h3 + a + ee;
-    hd->h3 = hd->h4 + b + aa;
-    hd->h4 = hd->h0 + c + bb;
-    hd->h0 = t;
+  /* left lane */
+  a = hd->h0;
+  b = hd->h1;
+  c = hd->h2;
+  d = hd->h3;
+  e = hd->h4;
+  R( a, b, c, d, e, F0, K0,  0, 11 );
+  R( e, a, b, c, d, F0, K0,  1, 14 );
+  R( d, e, a, b, c, F0, K0,  2, 15 );
+  R( c, d, e, a, b, F0, K0,  3, 12 );
+  R( b, c, d, e, a, F0, K0,  4,  5 );
+  R( a, b, c, d, e, F0, K0,  5,  8 );
+  R( e, a, b, c, d, F0, K0,  6,  7 );
+  R( d, e, a, b, c, F0, K0,  7,  9 );
+  R( c, d, e, a, b, F0, K0,  8, 11 );
+  R( b, c, d, e, a, F0, K0,  9, 13 );
+  R( a, b, c, d, e, F0, K0, 10, 14 );
+  R( e, a, b, c, d, F0, K0, 11, 15 );
+  R( d, e, a, b, c, F0, K0, 12,  6 );
+  R( c, d, e, a, b, F0, K0, 13,  7 );
+  R( b, c, d, e, a, F0, K0, 14,  9 );
+  R( a, b, c, d, e, F0, K0, 15,  8 );
+  R( e, a, b, c, d, F1, K1,  7,  7 );
+  R( d, e, a, b, c, F1, K1,  4,  6 );
+  R( c, d, e, a, b, F1, K1, 13,  8 );
+  R( b, c, d, e, a, F1, K1,  1, 13 );
+  R( a, b, c, d, e, F1, K1, 10, 11 );
+  R( e, a, b, c, d, F1, K1,  6,  9 );
+  R( d, e, a, b, c, F1, K1, 15,  7 );
+  R( c, d, e, a, b, F1, K1,  3, 15 );
+  R( b, c, d, e, a, F1, K1, 12,  7 );
+  R( a, b, c, d, e, F1, K1,  0, 12 );
+  R( e, a, b, c, d, F1, K1,  9, 15 );
+  R( d, e, a, b, c, F1, K1,  5,  9 );
+  R( c, d, e, a, b, F1, K1,  2, 11 );
+  R( b, c, d, e, a, F1, K1, 14,  7 );
+  R( a, b, c, d, e, F1, K1, 11, 13 );
+  R( e, a, b, c, d, F1, K1,  8, 12 );
+  R( d, e, a, b, c, F2, K2,  3, 11 );
+  R( c, d, e, a, b, F2, K2, 10, 13 );
+  R( b, c, d, e, a, F2, K2, 14,  6 );
+  R( a, b, c, d, e, F2, K2,  4,  7 );
+  R( e, a, b, c, d, F2, K2,  9, 14 );
+  R( d, e, a, b, c, F2, K2, 15,  9 );
+  R( c, d, e, a, b, F2, K2,  8, 13 );
+  R( b, c, d, e, a, F2, K2,  1, 15 );
+  R( a, b, c, d, e, F2, K2,  2, 14 );
+  R( e, a, b, c, d, F2, K2,  7,  8 );
+  R( d, e, a, b, c, F2, K2,  0, 13 );
+  R( c, d, e, a, b, F2, K2,  6,  6 );
+  R( b, c, d, e, a, F2, K2, 13,  5 );
+  R( a, b, c, d, e, F2, K2, 11, 12 );
+  R( e, a, b, c, d, F2, K2,  5,  7 );
+  R( d, e, a, b, c, F2, K2, 12,  5 );
+  R( c, d, e, a, b, F3, K3,  1, 11 );
+  R( b, c, d, e, a, F3, K3,  9, 12 );
+  R( a, b, c, d, e, F3, K3, 11, 14 );
+  R( e, a, b, c, d, F3, K3, 10, 15 );
+  R( d, e, a, b, c, F3, K3,  0, 14 );
+  R( c, d, e, a, b, F3, K3,  8, 15 );
+  R( b, c, d, e, a, F3, K3, 12,  9 );
+  R( a, b, c, d, e, F3, K3,  4,  8 );
+  R( e, a, b, c, d, F3, K3, 13,  9 );
+  R( d, e, a, b, c, F3, K3,  3, 14 );
+  R( c, d, e, a, b, F3, K3,  7,  5 );
+  R( b, c, d, e, a, F3, K3, 15,  6 );
+  R( a, b, c, d, e, F3, K3, 14,  8 );
+  R( e, a, b, c, d, F3, K3,  5,  6 );
+  R( d, e, a, b, c, F3, K3,  6,  5 );
+  R( c, d, e, a, b, F3, K3,  2, 12 );
+  R( b, c, d, e, a, F4, K4,  4,  9 );
+  R( a, b, c, d, e, F4, K4,  0, 15 );
+  R( e, a, b, c, d, F4, K4,  5,  5 );
+  R( d, e, a, b, c, F4, K4,  9, 11 );
+  R( c, d, e, a, b, F4, K4,  7,  6 );
+  R( b, c, d, e, a, F4, K4, 12,  8 );
+  R( a, b, c, d, e, F4, K4,  2, 13 );
+  R( e, a, b, c, d, F4, K4, 10, 12 );
+  R( d, e, a, b, c, F4, K4, 14,  5 );
+  R( c, d, e, a, b, F4, K4,  1, 12 );
+  R( b, c, d, e, a, F4, K4,  3, 13 );
+  R( a, b, c, d, e, F4, K4,  8, 14 );
+  R( e, a, b, c, d, F4, K4, 11, 11 );
+  R( d, e, a, b, c, F4, K4,  6,  8 );
+  R( c, d, e, a, b, F4, K4, 15,  5 );
+  R( b, c, d, e, a, F4, K4, 13,  6 );
+
+  aa = a; bb = b; cc = c; dd = d; ee = e;
+
+  /* right lane */
+  a = hd->h0;
+  b = hd->h1;
+  c = hd->h2;
+  d = hd->h3;
+  e = hd->h4;
+  R( a, b, c, d, e, F4, KK0,   5,  8);
+  R( e, a, b, c, d, F4, KK0, 14,  9);
+  R( d, e, a, b, c, F4, KK0,   7,  9);
+  R( c, d, e, a, b, F4, KK0,   0, 11);
+  R( b, c, d, e, a, F4, KK0,   9, 13);
+  R( a, b, c, d, e, F4, KK0,   2, 15);
+  R( e, a, b, c, d, F4, KK0, 11, 15);
+  R( d, e, a, b, c, F4, KK0,   4,  5);
+  R( c, d, e, a, b, F4, KK0, 13,  7);
+  R( b, c, d, e, a, F4, KK0,   6,  7);
+  R( a, b, c, d, e, F4, KK0, 15,  8);
+  R( e, a, b, c, d, F4, KK0,   8, 11);
+  R( d, e, a, b, c, F4, KK0,   1, 14);
+  R( c, d, e, a, b, F4, KK0, 10, 14);
+  R( b, c, d, e, a, F4, KK0,   3, 12);
+  R( a, b, c, d, e, F4, KK0, 12,  6);
+  R( e, a, b, c, d, F3, KK1,   6,  9);
+  R( d, e, a, b, c, F3, KK1, 11, 13);
+  R( c, d, e, a, b, F3, KK1,   3, 15);
+  R( b, c, d, e, a, F3, KK1,   7,  7);
+  R( a, b, c, d, e, F3, KK1,   0, 12);
+  R( e, a, b, c, d, F3, KK1, 13,  8);
+  R( d, e, a, b, c, F3, KK1,   5,  9);
+  R( c, d, e, a, b, F3, KK1, 10, 11);
+  R( b, c, d, e, a, F3, KK1, 14,  7);
+  R( a, b, c, d, e, F3, KK1, 15,  7);
+  R( e, a, b, c, d, F3, KK1,   8, 12);
+  R( d, e, a, b, c, F3, KK1, 12,  7);
+  R( c, d, e, a, b, F3, KK1,   4,  6);
+  R( b, c, d, e, a, F3, KK1,   9, 15);
+  R( a, b, c, d, e, F3, KK1,   1, 13);
+  R( e, a, b, c, d, F3, KK1,   2, 11);
+  R( d, e, a, b, c, F2, KK2, 15,  9);
+  R( c, d, e, a, b, F2, KK2,   5,  7);
+  R( b, c, d, e, a, F2, KK2,   1, 15);
+  R( a, b, c, d, e, F2, KK2,   3, 11);
+  R( e, a, b, c, d, F2, KK2,   7,  8);
+  R( d, e, a, b, c, F2, KK2, 14,  6);
+  R( c, d, e, a, b, F2, KK2,   6,  6);
+  R( b, c, d, e, a, F2, KK2,   9, 14);
+  R( a, b, c, d, e, F2, KK2, 11, 12);
+  R( e, a, b, c, d, F2, KK2,   8, 13);
+  R( d, e, a, b, c, F2, KK2, 12,  5);
+  R( c, d, e, a, b, F2, KK2,   2, 14);
+  R( b, c, d, e, a, F2, KK2, 10, 13);
+  R( a, b, c, d, e, F2, KK2,   0, 13);
+  R( e, a, b, c, d, F2, KK2,   4,  7);
+  R( d, e, a, b, c, F2, KK2, 13,  5);
+  R( c, d, e, a, b, F1, KK3,   8, 15);
+  R( b, c, d, e, a, F1, KK3,   6,  5);
+  R( a, b, c, d, e, F1, KK3,   4,  8);
+  R( e, a, b, c, d, F1, KK3,   1, 11);
+  R( d, e, a, b, c, F1, KK3,   3, 14);
+  R( c, d, e, a, b, F1, KK3, 11, 14);
+  R( b, c, d, e, a, F1, KK3, 15,  6);
+  R( a, b, c, d, e, F1, KK3,   0, 14);
+  R( e, a, b, c, d, F1, KK3,   5,  6);
+  R( d, e, a, b, c, F1, KK3, 12,  9);
+  R( c, d, e, a, b, F1, KK3,   2, 12);
+  R( b, c, d, e, a, F1, KK3, 13,  9);
+  R( a, b, c, d, e, F1, KK3,   9, 12);
+  R( e, a, b, c, d, F1, KK3,   7,  5);
+  R( d, e, a, b, c, F1, KK3, 10, 15);
+  R( c, d, e, a, b, F1, KK3, 14,  8);
+  R( b, c, d, e, a, F0, KK4, 12,  8);
+  R( a, b, c, d, e, F0, KK4, 15,  5);
+  R( e, a, b, c, d, F0, KK4, 10, 12);
+  R( d, e, a, b, c, F0, KK4,   4,  9);
+  R( c, d, e, a, b, F0, KK4,   1, 12);
+  R( b, c, d, e, a, F0, KK4,   5,  5);
+  R( a, b, c, d, e, F0, KK4,   8, 14);
+  R( e, a, b, c, d, F0, KK4,   7,  6);
+  R( d, e, a, b, c, F0, KK4,   6,  8);
+  R( c, d, e, a, b, F0, KK4,   2, 13);
+  R( b, c, d, e, a, F0, KK4, 13,  6);
+  R( a, b, c, d, e, F0, KK4, 14,  5);
+  R( e, a, b, c, d, F0, KK4,   0, 15);
+  R( d, e, a, b, c, F0, KK4,   3, 13);
+  R( c, d, e, a, b, F0, KK4,   9, 11);
+  R( b, c, d, e, a, F0, KK4, 11, 11);
+
+
+  t       = hd->h1 + d + cc;
+  hd->h1 = hd->h2 + e + dd;
+  hd->h2 = hd->h3 + a + ee;
+  hd->h3 = hd->h4 + b + aa;
+  hd->h4 = hd->h0 + c + bb;
+  hd->h0 = t;
 }
 
 
@@ -400,33 +403,37 @@ transform( RMD160_CONTEXT *hd, byte *data )
 static void
 rmd160_write( void *context, byte *inbuf, size_t inlen)
 {
-  RMD160_CONTEXT *hd = (RMD160_CONTEXT *) context;
-    if( hd->count == 64 ) { /* flush the buffer */
-       transform( hd, hd->buf );
-        _gcry_burn_stack (108+5*sizeof(void*));
-       hd->count = 0;
-       hd->nblocks++;
+  RMD160_CONTEXT *hd = context;
+
+  if( hd->count == 64 )  /* flush the buffer */
+    {
+      transform( hd, hd->buf );
+      _gcry_burn_stack (108+5*sizeof(void*));
+      hd->count = 0;
+      hd->nblocks++;
     }
-    if( !inbuf )
-       return;
-    if( hd->count ) {
-       for( ; inlen && hd->count < 64; inlen-- )
-           hd->buf[hd->count++] = *inbuf++;
-       rmd160_write( hd, NULL, 0 );
-       if( !inlen )
-           return;
+  if( !inbuf )
+    return;
+  if( hd->count ) 
+    {
+      for( ; inlen && hd->count < 64; inlen-- )
+        hd->buf[hd->count++] = *inbuf++;
+      rmd160_write( hd, NULL, 0 );
+      if( !inlen )
+        return;
     }
 
-    while( inlen >= 64 ) {
-       transform( hd, inbuf );
-       hd->count = 0;
-       hd->nblocks++;
-       inlen -= 64;
-       inbuf += 64;
+  while( inlen >= 64 )
+    {
+      transform( hd, inbuf );
+      hd->count = 0;
+      hd->nblocks++;
+      inlen -= 64;
+      inbuf += 64;
     }
-    _gcry_burn_stack (108+5*sizeof(void*));
-    for( ; inlen && hd->count < 64; inlen-- )
-       hd->buf[hd->count++] = *inbuf++;
+  _gcry_burn_stack (108+5*sizeof(void*));
+  for( ; inlen && hd->count < 64; inlen-- )
+    hd->buf[hd->count++] = *inbuf++;
 }
 
 /****************
@@ -438,14 +445,15 @@ rmd160_write( void *context, byte *inbuf, size_t inlen)
 void
 _gcry_rmd160_mixblock( RMD160_CONTEXT *hd, char *buffer )
 {
-    char *p = buffer;
-    transform( hd, buffer );
+  char *p = buffer;
+
+  transform( hd, buffer );
 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
-    X(0);
-    X(1);
-    X(2);
-    X(3);
-    X(4);
+  X(0);
+  X(1);
+  X(2);
+  X(3);
+  X(4);
 #undef X
 }
 
@@ -456,70 +464,73 @@ _gcry_rmd160_mixblock( RMD160_CONTEXT *hd, char *buffer )
 static void
 rmd160_final( void *context )
 {
-  RMD160_CONTEXT *hd = (RMD160_CONTEXT *) context;
-    u32 t, msb, lsb;
-    byte *p;
-
-    rmd160_write(hd, NULL, 0); /* flush */;
-
-    t = hd->nblocks;
-    /* multiply by 64 to make a byte count */
-    lsb = t << 6;
-    msb = t >> 26;
-    /* add the count */
-    t = lsb;
-    if( (lsb += hd->count) < t )
-       msb++;
-    /* multiply by 8 to make a bit count */
-    t = lsb;
-    lsb <<= 3;
-    msb <<= 3;
-    msb |= t >> 29;
-
-    if( hd->count < 56 ) { /* enough room */
-       hd->buf[hd->count++] = 0x80; /* pad */
-       while( hd->count < 56 )
-           hd->buf[hd->count++] = 0;  /* pad */
+  RMD160_CONTEXT *hd = context;
+  u32 t, msb, lsb;
+  byte *p;
+  
+  rmd160_write(hd, NULL, 0); /* flush */;
+
+  t = hd->nblocks;
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = t >> 26;
+  /* add the count */
+  t = lsb;
+  if( (lsb += hd->count) < t )
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+
+  if( hd->count < 56 )  /* enough room */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad */
+      while( hd->count < 56 )
+        hd->buf[hd->count++] = 0;  /* pad */
     }
-    else { /* need one extra block */
-       hd->buf[hd->count++] = 0x80; /* pad character */
-       while( hd->count < 64 )
-           hd->buf[hd->count++] = 0;
-       rmd160_write(hd, NULL, 0);  /* flush */;
-       memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+  else  /* need one extra block */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad character */
+      while( hd->count < 64 )
+        hd->buf[hd->count++] = 0;
+      rmd160_write(hd, NULL, 0);  /* flush */;
+      memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     }
-    /* append the 64 bit count */
-    hd->buf[56] = lsb     ;
-    hd->buf[57] = lsb >>  8;
-    hd->buf[58] = lsb >> 16;
-    hd->buf[59] = lsb >> 24;
-    hd->buf[60] = msb     ;
-    hd->buf[61] = msb >>  8;
-    hd->buf[62] = msb >> 16;
-    hd->buf[63] = msb >> 24;
-    transform( hd, hd->buf );
-    _gcry_burn_stack (108+5*sizeof(void*));
-
-    p = hd->buf;
+  /* append the 64 bit count */
+  hd->buf[56] = lsb       ;
+  hd->buf[57] = lsb >>  8;
+  hd->buf[58] = lsb >> 16;
+  hd->buf[59] = lsb >> 24;
+  hd->buf[60] = msb       ;
+  hd->buf[61] = msb >>  8;
+  hd->buf[62] = msb >> 16;
+  hd->buf[63] = msb >> 24;
+  transform( hd, hd->buf );
+  _gcry_burn_stack (108+5*sizeof(void*));
+
+  p = hd->buf;
 #ifdef WORDS_BIGENDIAN
 #define X(a) do { *p++ = hd->h##a         ; *p++ = hd->h##a >> 8;      \
-                     *p++ = hd->h##a >> 16; *p++ = hd->h##a >> 24; } while(0)
+                 *p++ = hd->h##a >> 16; *p++ = hd->h##a >> 24; } while(0)
 #else /* little endian */
 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
 #endif
-    X(0);
-    X(1);
-    X(2);
-    X(3);
-    X(4);
+  X(0);
+  X(1);
+  X(2);
+  X(3);
+  X(4);
 #undef X
 }
 
 static byte *
 rmd160_read( void *context )
 {
-  RMD160_CONTEXT *hd = (RMD160_CONTEXT *) context;
-    return hd->buf;
+  RMD160_CONTEXT *hd = context;
+
+  return hd->buf;
 }
 
 
@@ -531,12 +542,12 @@ rmd160_read( void *context )
 void
 _gcry_rmd160_hash_buffer( char *outbuf, const char *buffer, size_t length )
 {
-    RMD160_CONTEXT hd;
+  RMD160_CONTEXT hd;
 
-    _gcry_rmd160_init( &hd );
-    rmd160_write( &hd, (byte*)buffer, length );
-    rmd160_final( &hd );
-    memcpy( outbuf, hd.buf, 20 );
+  _gcry_rmd160_init( &hd );
+  rmd160_write( &hd, (byte*)buffer, length );
+  rmd160_final( &hd );
+  memcpy( outbuf, hd.buf, 20 );
 }
 
 static byte asn[15] = /* Object ID is 1.3.36.3.2.1 */
index 098ff3e..29b48e8 100644 (file)
 
 static int egd_socket = -1;
 
-/* FIXME: this is duplicated code from util/fileutil
* I don't think that this code should go into libgcrypt anyway.
+/* Allocate a new filename from FIRST_PART and SECOND_PART and to
  tilde expansion for first_part.  SECOND_PART might be NULL.
  */
-char *
-my_make_filename( const char *first_part, ... )
+static char *
+my_make_filename (const char *first_part, const char *second_part)
 {
-    va_list arg_ptr ;
-    size_t n;
-    const char *s;
-    char *name, *home, *p;
-
-    va_start( arg_ptr, first_part ) ;
-    n = strlen(first_part)+1;
-    while( (s=va_arg(arg_ptr, const char *)) )
-       n += strlen(s) + 1;
-    va_end(arg_ptr);
-
-    home = NULL;
-    if( *first_part == '~' && first_part[1] == '/'
-                          && (home = getenv("HOME")) && *home )
-       n += strlen(home);
-
-    name = gcry_malloc(n);
-    p = home ? stpcpy(stpcpy(name,home), first_part+1)
-            : stpcpy(name, first_part);
-    va_start( arg_ptr, first_part ) ;
-    while( (s=va_arg(arg_ptr, const char *)) )
-       p = stpcpy(stpcpy(p,"/"), s);
-    va_end(arg_ptr);
-
-    return name;
+  size_t n;
+  char *name, *home, *p;
+
+  n = strlen(first_part)+1;
+  if (second_part)
+    n += strlen (second_part) + 1;
+
+  home = NULL;
+  if( *first_part == '~' && first_part[1] == '/'
+      && (home = getenv("HOME")) && *home )
+    n += strlen(home);
+
+  name = gcry_xmalloc(n);
+  p = (home
+       ? stpcpy (stpcpy (name, home), first_part+1 )
+       : stpcpy (name, first_part) );
+
+  if (second_part)
+    strcpy (stpcpy(p,"/"), second_part);
+
+  return name;
 }
 
 
 static int
 do_write( int fd, void *buf, size_t nbytes )
 {
-    size_t nleft = nbytes;
-    int nwritten;
-
-    while( nleft > 0 ) {
-       nwritten = write( fd, buf, nleft);
-       if( nwritten < 0 ) {
-           if( errno == EINTR )
-               continue;
-           return -1;
+  size_t nleft = nbytes;
+  int nwritten;
+  
+  while( nleft > 0 ) 
+    {
+      nwritten = write( fd, buf, nleft);
+      if( nwritten < 0 )
+        {
+          if( errno == EINTR )
+            continue;
+          return -1;
        }
-       nleft -= nwritten;
-       buf = (char*)buf + nwritten;
+      nleft -= nwritten;
+      buf = (char*)buf + nwritten;
     }
-    return 0;
+  return 0;
 }
 
 static int
 do_read( int fd, void *buf, size_t nbytes )
 {
-    int n, nread = 0;
-
-    do {
-       do {
-           n = read(fd, (char*)buf + nread, nbytes );
-       } while( n == -1 && errno == EINTR );
-       if( n == -1)
-           return nread? nread:-1;
-       if( n == 0)
-           return -1;
-       nread += n;
-       nbytes -= n;
-    } while( nread < nbytes );
-    return nread;
+  int n, nread = 0;
+
+  do
+    {
+      do
+        {
+          n = read(fd, (char*)buf + nread, nbytes );
+        } 
+      while( n == -1 && errno == EINTR );
+      if( n == -1)
+        return nread? nread:-1;
+      if( n == 0)
+        return -1;
+      nread += n;
+      nbytes -= n;
+    } 
+  while( nread < nbytes );
+  return nread;
 }
 
 
@@ -136,7 +138,7 @@ _gcry_rndegd_connect_socket (int nofail)
   bname = EGD_SOCKET_NAME;
 #endif
   if ( !bname || !*bname )
-    name = my_make_filename ("~/.gnupg", "entropy", NULL); /* FIXME?  */
+    name = my_make_filename ("~/.gnupg", "entropy");
   else
     name = my_make_filename (bname, NULL);
 
@@ -151,12 +153,11 @@ _gcry_rndegd_connect_socket (int nofail)
   
   fd = socket(AF_UNIX, SOCK_STREAM, 0);
   if (fd == -1 && !nofail)
-    log_fatal("can't create unix domain socket: %s\n",
-             strerror(errno) );
+    log_fatal("can't create unix domain socket: %s\n", strerror(errno) );
   else if (connect (fd, (struct sockaddr*)&addr, addr_len) == -1)
     {
       if (!nofail)
-        log_fatal("can't connect to `%s': %s\n",
+        log_fatal("can't connect to EGD socket `%s': %s\n",
                  name, strerror(errno) );
       close (fd);
       fd = -1;
@@ -168,8 +169,8 @@ _gcry_rndegd_connect_socket (int nofail)
 }
 
 /****************
- * Note: we always use the highest level.
- * TO boost the performance we may want to add some
+ * Note: We always use the highest level.
+ * To boost the performance we may want to add some
  * additional code for level 1
  *
  * Using a level of 0 should never block and better add nothing
@@ -180,70 +181,76 @@ _gcry_rndegd_gather_random (void (*add)(const void*, size_t, int),
                             int requester,
                             size_t length, int level )
 {
-    int fd = egd_socket;
-    int n;
-    byte buffer[256+2];
-    int nbytes;
-    int do_restart = 0;
-
-    if( !length )
-       return 0;
-    if( !level )
-       return 0;
-
-  restart:
-    if (fd == -1 || do_restart)
-      fd = _gcry_rndegd_connect_socket (0);
-
-    do_restart = 0;
-
-    nbytes = length < 255? length : 255;
-    /* first time we do it with a non blocking request */
-    buffer[0] = 1; /* non blocking */
-    buffer[1] = nbytes;
-    if( do_write( fd, buffer, 2 ) == -1 )
-       log_fatal("can't write to the EGD: %s\n", strerror(errno) );
-    n = do_read( fd, buffer, 1 );
-    if( n == -1 ) {
-       log_error("read error on EGD: %s\n", strerror(errno));
-       do_restart = 1;
-       goto restart;
+  int fd = egd_socket;
+  int n;
+  byte buffer[256+2];
+  int nbytes;
+  int do_restart = 0;
+
+  if( !length )
+    return 0;
+  if( !level )
+    return 0;
+
+ restart:
+  if (fd == -1 || do_restart)
+    fd = _gcry_rndegd_connect_socket (0);
+
+  do_restart = 0;
+
+  nbytes = length < 255? length : 255;
+  /* First time we do it with a non blocking request */
+  buffer[0] = 1; /* non blocking */
+  buffer[1] = nbytes;
+  if( do_write( fd, buffer, 2 ) == -1 )
+    log_fatal("can't write to the EGD: %s\n", strerror(errno) );
+  n = do_read( fd, buffer, 1 );
+  if( n == -1 )
+    {
+      log_error("read error on EGD: %s\n", strerror(errno));
+      do_restart = 1;
+      goto restart;
     }
-    n = buffer[0];
-    if( n ) {
-       n = do_read( fd, buffer, n );
-       if( n == -1 ) {
-           log_error("read error on EGD: %s\n", strerror(errno));
-           do_restart = 1;
-           goto restart;
+  n = buffer[0];
+  if( n )
+    {
+      n = do_read( fd, buffer, n );
+      if( n == -1 )
+        {
+          log_error("read error on EGD: %s\n", strerror(errno));
+          do_restart = 1;
+          goto restart;
        }
-       (*add)( buffer, n, requester );
-       length -= n;
+      (*add)( buffer, n, requester );
+      length -= n;
     }
 
-    if( length ) {
-       log_info (
-        _("Please wait, entropy is being gathered. Do some work if it would\n"
-          "keep you from getting bored, because it will improve the quality\n"
-          "of the entropy.\n") );
+  if( length )
+    {
+      log_info (
+      _("Please wait, entropy is being gathered. Do some work if it would\n"
+        "keep you from getting bored, because it will improve the quality\n"
+        "of the entropy.\n") );
     }
-    while( length ) {
-       nbytes = length < 255? length : 255;
-
-       buffer[0] = 2; /* blocking */
-       buffer[1] = nbytes;
-       if( do_write( fd, buffer, 2 ) == -1 )
-           log_fatal("can't write to the EGD: %s\n", strerror(errno) );
-       n = do_read( fd, buffer, nbytes );
-       if( n == -1 ) {
-           log_error("read error on EGD: %s\n", strerror(errno));
-           do_restart = 1;
-           goto restart;
+  while( length )
+    {
+      nbytes = length < 255? length : 255;
+
+      buffer[0] = 2; /* blocking */
+      buffer[1] = nbytes;
+      if( do_write( fd, buffer, 2 ) == -1 )
+        log_fatal("can't write to the EGD: %s\n", strerror(errno) );
+      n = do_read( fd, buffer, nbytes );
+      if( n == -1 )
+        {
+          log_error("read error on EGD: %s\n", strerror(errno));
+          do_restart = 1;
+          goto restart;
        }
-       (*add)( buffer, n, requester );
-       length -= n;
+      (*add)( buffer, n, requester );
+      length -= n;
     }
-    memset(buffer, 0, sizeof(buffer) );
+  memset(buffer, 0, sizeof(buffer) );
 
-    return 0; /* success */
+  return 0; /* success */
 }
index 05a8e03..fc608bc 100644 (file)
 #include <sys/types.h>
 #include <sys/stat.h>
 #ifdef HAVE_GETTIMEOFDAY
-#include <sys/times.h>
+# include <sys/times.h>
 #endif
 #include <string.h>
 #include <unistd.h>
 #include <fcntl.h>
-#if 0
-#ifdef HAVE_LINUX_RANDOM_H
-#include <sys/ioctl.h>
-#include <asm/types.h>
-#include <linux/random.h>
-#endif
-#endif
 #include "types.h"
 #include "g10lib.h"
 #include "rand-internal.h"
@@ -49,38 +42,30 @@ int _gcry_rndlinux_gather_random (void (*add)(const void*, size_t, int),
                                   int requester,
                                   size_t length, int level );
 
-#if 0
-#ifdef HAVE_DEV_RANDOM_IOCTL
-static ulong
-get_entropy_count( int fd )
-{
-    ulong count;
-
-    if( ioctl( fd, RNDGETENTCNT, &count ) == -1 )
-       log_fatal("ioctl(RNDGETENTCNT) failed: %s\n", strerror(errno) );
-    return count;
-}
-#endif
-#endif
-
-/****************
- * Used to open the /dev/random devices (Linux, xBSD, Solaris (if it exists), ...)
+/*
+ * Used to open the /dev/random devices (Linux, xBSD, Solaris (if it exists)).
  */
 static int
 open_device( const char *name, int minor )
 {
-    int fd;
-    struct stat sb;
+  int fd;
 
-    fd = open( name, O_RDONLY );
-    if( fd == -1 )
-       log_fatal("can't open %s: %s\n", name, strerror(errno) );
-    if( fstat( fd, &sb ) )
-       log_fatal("stat() off %s failed: %s\n", name, strerror(errno) );
-    /* Don't check device type for better portability */
-    /*  if( (!S_ISCHR(sb.st_mode)) && (!S_ISFIFO(sb.st_mode)) )
-         log_fatal("invalid random device!\n" ); */
-    return fd;
+  fd = open( name, O_RDONLY );
+  if( fd == -1 )
+    log_fatal ("can't open %s: %s\n", name, strerror(errno) );
+
+  /* We used to do the follwing check, however it turned out that this
+     is not portable since more OSes provide a random device which is
+     sometimes implemented as anoteher device type. 
+     
+     struct stat sb;
+
+     if( fstat( fd, &sb ) )
+        log_fatal("stat() off %s failed: %s\n", name, strerror(errno) );
+     if( (!S_ISCHR(sb.st_mode)) && (!S_ISFIFO(sb.st_mode)) )
+        log_fatal("invalid random device!\n" );
+  */
+  return fd;
 }
 
 
@@ -89,39 +74,38 @@ _gcry_rndlinux_gather_random (void (*add)(const void*, size_t, int),
                               int requester,
                               size_t length, int level )
 {
-    static int fd_urandom = -1;
-    static int fd_random = -1;
-    int fd;
-    int n;
-    int warn=0;
-    byte buffer[768];
+  static int fd_urandom = -1;
+  static int fd_random = -1;
+  int fd;
+  int n;
+  int warn=0;
+  byte buffer[768];
 
-    if( level >= 2 ) {
-       if( fd_random == -1 )
-           fd_random = open_device( NAME_OF_DEV_RANDOM, 8 );
-       fd = fd_random;
+  if( level >= 2 )
+    {
+      if( fd_random == -1 )
+        fd_random = open_device( NAME_OF_DEV_RANDOM, 8 );
+      fd = fd_random;
     }
-    else {
-       if( fd_urandom == -1 )
-           fd_urandom = open_device( NAME_OF_DEV_URANDOM, 9 );
-       fd = fd_urandom;
+  else
+    {
+      if( fd_urandom == -1 )
+        fd_urandom = open_device( NAME_OF_DEV_URANDOM, 9 );
+      fd = fd_urandom;
     }
 
-#if 0
-#ifdef HAVE_DEV_RANDOM_IOCTL
-    log_info("entropy count of %d is %lu\n", fd, get_entropy_count(fd) );
-#endif
-#endif
-    while( length ) {
-       fd_set rfds;
-       struct timeval tv;
-       int rc;
-
-       FD_ZERO(&rfds);
-       FD_SET(fd, &rfds);
-       tv.tv_sec = 3;
-       tv.tv_usec = 0;
-       if( !(rc=select(fd+1, &rfds, NULL, NULL, &tv)) ) {
+  while (length)
+    {
+      fd_set rfds;
+      struct timeval tv;
+      int rc;
+      
+      FD_ZERO(&rfds);
+      FD_SET(fd, &rfds);
+      tv.tv_sec = 3;
+      tv.tv_usec = 0;
+      if( !(rc=select(fd+1, &rfds, NULL, NULL, &tv)) )
+        {
           if( !warn )
             {
               _gcry_random_progress ("need_entropy", 'X', 0, (int)length);
@@ -129,25 +113,29 @@ _gcry_rndlinux_gather_random (void (*add)(const void*, size_t, int),
            }
          continue;
        }
-       else if( rc == -1 ) {
+       else if( rc == -1 )
+          {
            log_error ("select() error: %s\n", strerror(errno));
            continue;
-       }
+          }
 
-       do {
+       do 
+          {
            int nbytes = length < sizeof(buffer)? length : sizeof(buffer);
            n = read(fd, buffer, nbytes );
-           if( n >= 0 && n > nbytes ) {
+           if( n >= 0 && n > nbytes ) 
+              {
                log_error("bogus read from random device (n=%d)\n", n );
                n = nbytes;
-           }
-       } while( n == -1 && errno == EINTR );
+              }
+          } 
+        while( n == -1 && errno == EINTR );
        if( n == -1 )
-           log_fatal("read error on random device: %s\n", strerror(errno));
+          log_fatal("read error on random device: %s\n", strerror(errno));
        (*add)( buffer, n, requester );
        length -= n;
     }
-    memset(buffer, 0, sizeof(buffer) );
+  memset(buffer, 0, sizeof(buffer) );
 
-    return 0; /* success */
+  return 0; /* success */
 }
index c95e207..3ebb823 100644 (file)
@@ -508,11 +508,13 @@ slow_poll(FILE *dbgfp, int dbgall, size_t *nbytes )
            dataSources[i].pipeFD = fileno(dataSources[i].pipe);
            if (dataSources[i].pipeFD > maxFD)
                maxFD = dataSources[i].pipeFD;
-         #ifdef O_NONBLOCK /* Ohhh what a hack (used for Atari) */
+
+#ifdef O_NONBLOCK /* Ohhh what a hack (used for Atari) */
            fcntl(dataSources[i].pipeFD, F_SETFL, O_NONBLOCK);
-         #else
-           #warning O_NONBLOCK is missing
-         #endif
+#else
+#error O_NONBLOCK is missing
+#endif
+
            FD_SET(dataSources[i].pipeFD, &fds);
            dataSources[i].length = 0;
 
@@ -659,15 +661,15 @@ start_gatherer( int pipefd )
     {  int nmax, n1, n2, i;
 #ifdef _SC_OPEN_MAX
        if( (nmax=sysconf( _SC_OPEN_MAX )) < 0 ) {
-         #ifdef _POSIX_OPEN_MAX
+#ifdef _POSIX_OPEN_MAX
            nmax = _POSIX_OPEN_MAX;
-         #else
+#else
            nmax = 20; /* assume a reasonable value */
-         #endif
+#endif
        }
-#else
+#else /*!_SC_OPEN_MAX*/
        nmax = 20; /* assume a reasonable value */
-#endif
+#endif /*!_SC_OPEN_MAX*/
        n1 = fileno( stderr );
        n2 = dbgfp? fileno( dbgfp ) : -1;
        for(i=0; i < nmax; i++ ) {
@@ -678,7 +680,6 @@ start_gatherer( int pipefd )
     }
 
 
-
     /* Set up the buffer */
     gather_buffer_size = GATHER_BUFSIZE;
     gather_buffer = malloc( gather_buffer_size );
@@ -837,7 +838,7 @@ _gcry_rndunix_gather_random (void (*add)(const void*, size_t, int),
            n = length;
        (*add)( msg.data, n, requester );
 
-       /* this is the trick how e cope with the goodness */
+       /* this is the trick how we cope with the goodness */
        subtract = (ulong)n * goodness / 100;
        /* subtract at least 1 byte to avoid infinite loops */
        length -= subtract ? subtract : 1;
index fa5fda9..870eec6 100644 (file)
@@ -508,7 +508,7 @@ _gcry_rndw32_gather_random( void (*add)(const void*, size_t, int),
     if( !level )
        return 0;
     /* We don't differentiate between level 1 and 2 here because
-     * there is no nternal entropy pool as a scary resource.  It may
+     * there is no internal entropy pool as a scary resource.  It may
      * all work slower, but because our entropy source will never
      * block but deliver some not easy to measure entropy, we assume level 2
      */
index a2200e3..fa26622 100644 (file)
@@ -62,26 +62,26 @@ static void secret (gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey);
 static void
 test_keys( RSA_secret_key *sk, unsigned nbits )
 {
-    RSA_public_key pk;
-    gcry_mpi_t test = gcry_mpi_new ( nbits );
-    gcry_mpi_t out1 = gcry_mpi_new ( nbits );
-    gcry_mpi_t out2 = gcry_mpi_new ( nbits );
-
-    pk.n = sk->n;
-    pk.e = sk->e;
-    gcry_mpi_randomize( test, nbits, GCRY_WEAK_RANDOM );
-
-    public( out1, test, &pk );
-    secret( out2, out1, sk );
-    if( mpi_cmp( test, out2 ) )
-       log_fatal("RSA operation: public, secret failed\n");
-    secret( out1, test, sk );
-    public( out2, out1, &pk );
-    if( mpi_cmp( test, out2 ) )
-       log_fatal("RSA operation: secret, public failed\n");
-    gcry_mpi_release ( test );
-    gcry_mpi_release ( out1 );
-    gcry_mpi_release ( out2 );
+  RSA_public_key pk;
+  gcry_mpi_t test = gcry_mpi_new ( nbits );
+  gcry_mpi_t out1 = gcry_mpi_new ( nbits );
+  gcry_mpi_t out2 = gcry_mpi_new ( nbits );
+
+  pk.n = sk->n;
+  pk.e = sk->e;
+  gcry_mpi_randomize( test, nbits, GCRY_WEAK_RANDOM );
+
+  public( out1, test, &pk );
+  secret( out2, out1, sk );
+  if( mpi_cmp( test, out2 ) )
+    log_fatal("RSA operation: public, secret failed\n");
+  secret( out1, test, sk );
+  public( out2, out1, &pk );
+  if( mpi_cmp( test, out2 ) )
+    log_fatal("RSA operation: secret, public failed\n");
+  gcry_mpi_release ( test );
+  gcry_mpi_release ( out1 );
+  gcry_mpi_release ( out2 );
 }
 
 
@@ -113,45 +113,46 @@ check_exponent (void *arg, gcry_mpi_t a)
 static void
 generate (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e)
 {
-    gcry_mpi_t p, q; /* the two primes */
-    gcry_mpi_t d;    /* the private key */
-    gcry_mpi_t u;
-    gcry_mpi_t t1, t2;
-    gcry_mpi_t n;    /* the public key */
-    gcry_mpi_t e;    /* the exponent */
-    gcry_mpi_t phi;  /* helper: (p-1)(q-1) */
-    gcry_mpi_t g;
-    gcry_mpi_t f;
-
-    /* make sure that nbits is even so that we generate p, q of equal size */
-    if ( (nbits&1) )
-      nbits++; 
-
-    if (use_e == 1)   /* Alias for a secure value. */
-      use_e = 65537;  /* as demanded by Spinx. */
-
-    /* Public exponent:
-       In general we use 41 as this is quite fast and more secure than the
-       commonly used 17.  Benchmarking the RSA verify function
-       with a 1024 bit key yields (2001-11-08): 
-         e=17    0.54 ms
-         e=41    0.75 ms
-         e=257   0.95 ms
-         e=65537 1.80 ms
-    */
-    e = mpi_alloc( (32+BITS_PER_MPI_LIMB-1)/BITS_PER_MPI_LIMB );
-    if (!use_e)
-      mpi_set_ui (e, 41);     /* This is a reasonable secure and fast value */
-    else 
-      {
-        use_e |= 1; /* make sure this is odd */
-        mpi_set_ui (e, use_e); 
-      }
+  gcry_mpi_t p, q; /* the two primes */
+  gcry_mpi_t d;    /* the private key */
+  gcry_mpi_t u;
+  gcry_mpi_t t1, t2;
+  gcry_mpi_t n;    /* the public key */
+  gcry_mpi_t e;    /* the exponent */
+  gcry_mpi_t phi;  /* helper: (p-1)(q-1) */
+  gcry_mpi_t g;
+  gcry_mpi_t f;
+
+  /* make sure that nbits is even so that we generate p, q of equal size */
+  if ( (nbits&1) )
+    nbits++; 
+
+  if (use_e == 1)   /* Alias for a secure value. */
+    use_e = 65537;  /* as demanded by Spinx. */
+
+  /* Public exponent:
+     In general we use 41 as this is quite fast and more secure than the
+     commonly used 17.  Benchmarking the RSA verify function
+     with a 1024 bit key yields (2001-11-08): 
+     e=17    0.54 ms
+     e=41    0.75 ms
+     e=257   0.95 ms
+     e=65537 1.80 ms
+  */
+  e = mpi_alloc( (32+BITS_PER_MPI_LIMB-1)/BITS_PER_MPI_LIMB );
+  if (!use_e)
+    mpi_set_ui (e, 41);     /* This is a reasonable secure and fast value */
+  else 
+    {
+      use_e |= 1; /* make sure this is odd */
+      mpi_set_ui (e, use_e); 
+    }
     
-    n = gcry_mpi_new (nbits);
+  n = gcry_mpi_new (nbits);
 
-    p = q = NULL;
-    do {
+  p = q = NULL;
+  do
+    {
       /* select two (very secret) primes */
       if (p)
         gcry_mpi_release (p);
@@ -172,62 +173,64 @@ generate (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e)
         mpi_swap(p,q);
       /* calculate the modulus */
       mpi_mul( n, p, q );
-    } while ( mpi_get_nbits(n) != nbits );
-
-    /* calculate Euler totient: phi = (p-1)(q-1) */
-    t1 = mpi_alloc_secure( mpi_get_nlimbs(p) );
-    t2 = mpi_alloc_secure( mpi_get_nlimbs(p) );
-    phi = gcry_mpi_snew ( nbits );
-    g  = gcry_mpi_snew ( nbits );
-    f  = gcry_mpi_snew ( nbits );
-    mpi_sub_ui( t1, p, 1 );
-    mpi_sub_ui( t2, q, 1 );
-    mpi_mul( phi, t1, t2 );
-    gcry_mpi_gcd(g, t1, t2);
-    mpi_fdiv_q(f, phi, g);
+    }
+  while ( mpi_get_nbits(n) != nbits );
+
+  /* calculate Euler totient: phi = (p-1)(q-1) */
+  t1 = mpi_alloc_secure( mpi_get_nlimbs(p) );
+  t2 = mpi_alloc_secure( mpi_get_nlimbs(p) );
+  phi = gcry_mpi_snew ( nbits );
+  g    = gcry_mpi_snew ( nbits );
+  f    = gcry_mpi_snew ( nbits );
+  mpi_sub_ui( t1, p, 1 );
+  mpi_sub_ui( t2, q, 1 );
+  mpi_mul( phi, t1, t2 );
+  gcry_mpi_gcd(g, t1, t2);
+  mpi_fdiv_q(f, phi, g);
+
+  while (!gcry_mpi_gcd(t1, e, phi)) /* (while gcd is not 1) */
+    {
+      if (use_e)
+        BUG (); /* The prime generator already made sure that we
+                   never can get to here. */
+      mpi_add_ui (e, e, 2);
+    }
 
-    while (!gcry_mpi_gcd(t1, e, phi)) /* (while gcd is not 1) */
-      {
-        if (use_e)
-          BUG (); /* The prime generator already made sure that we
-                     never can get to here. */
-        mpi_add_ui (e, e, 2);
-      }
+  /* calculate the secret key d = e^1 mod phi */
+  d = gcry_mpi_snew ( nbits );
+  mpi_invm(d, e, f );
+  /* calculate the inverse of p and q (used for chinese remainder theorem)*/
+  u = gcry_mpi_snew ( nbits );
+  mpi_invm(u, p, q );
 
-    /* calculate the secret key d = e^1 mod phi */
-    d = gcry_mpi_snew ( nbits );
-    mpi_invm(d, e, f );
-    /* calculate the inverse of p and q (used for chinese remainder theorem)*/
-    u = gcry_mpi_snew ( nbits );
-    mpi_invm(u, p, q );
-
-    if( DBG_CIPHER ) {
-        log_mpidump("  p= ", p );
-       log_mpidump("  q= ", q );
-       log_mpidump("phi= ", phi );
-       log_mpidump("  g= ", g );
-       log_mpidump("  f= ", f );
-       log_mpidump("  n= ", n );
-       log_mpidump("  e= ", e );
-       log_mpidump("  d= ", d );
-       log_mpidump("  u= ", u );
+  if( DBG_CIPHER )
+    {
+      log_mpidump("  p= ", p );
+      log_mpidump("  q= ", q );
+      log_mpidump("phi= ", phi );
+      log_mpidump("  g= ", g );
+      log_mpidump("  f= ", f );
+      log_mpidump("  n= ", n );
+      log_mpidump("  e= ", e );
+      log_mpidump("  d= ", d );
+      log_mpidump("  u= ", u );
     }
 
-    gcry_mpi_release (t1);
-    gcry_mpi_release (t2);
-    gcry_mpi_release (phi);
-    gcry_mpi_release (f);
-    gcry_mpi_release (g);
-
-    sk->n = n;
-    sk->e = e;
-    sk->p = p;
-    sk->q = q;
-    sk->d = d;
-    sk->u = u;
-
-    /* now we can test our keys (this should never fail!) */
-    test_keys( sk, nbits - 64 );
+  gcry_mpi_release (t1);
+  gcry_mpi_release (t2);
+  gcry_mpi_release (phi);
+  gcry_mpi_release (f);
+  gcry_mpi_release (g);
+
+  sk->n = n;
+  sk->e = e;
+  sk->p = p;
+  sk->q = q;
+  sk->d = d;
+  sk->u = u;
+
+  /* now we can test our keys (this should never fail!) */
+  test_keys( sk, nbits - 64 );
 }
 
 
@@ -238,13 +241,13 @@ generate (RSA_secret_key *sk, unsigned int nbits, unsigned long use_e)
 static int
 check_secret_key( RSA_secret_key *sk )
 {
-    int rc;
-    gcry_mpi_t temp = mpi_alloc( mpi_get_nlimbs(sk->p)*2 );
-
-    mpi_mul(temp, sk->p, sk->q );
-    rc = mpi_cmp( temp, sk->n );
-    mpi_free(temp);
-    return !rc;
+  int rc;
+  gcry_mpi_t temp = mpi_alloc( mpi_get_nlimbs(sk->p)*2 );
+  
+  mpi_mul(temp, sk->p, sk->q );
+  rc = mpi_cmp( temp, sk->n );
+  mpi_free(temp);
+  return !rc;
 }
 
 
@@ -259,14 +262,15 @@ check_secret_key( RSA_secret_key *sk )
 static void
 public(gcry_mpi_t output, gcry_mpi_t input, RSA_public_key *pkey )
 {
-    if( output == input ) { /* powm doesn't like output and input the same */
-       gcry_mpi_t x = mpi_alloc( mpi_get_nlimbs(input)*2 );
-       mpi_powm( x, input, pkey->e, pkey->n );
-       mpi_set(output, x);
-       mpi_free(x);
+  if( output == input )  /* powm doesn't like output and input the same */
+    {
+      gcry_mpi_t x = mpi_alloc( mpi_get_nlimbs(input)*2 );
+      mpi_powm( x, input, pkey->e, pkey->n );
+      mpi_set(output, x);
+      mpi_free(x);
     }
-    else
-       mpi_powm( output, input, pkey->e, pkey->n );
+  else
+    mpi_powm( output, input, pkey->e, pkey->n );
 }
 
 #if 0
@@ -351,38 +355,81 @@ stronger_key_check ( RSA_secret_key *skey )
 static void
 secret(gcry_mpi_t output, gcry_mpi_t input, RSA_secret_key *skey )
 {
-#if 0
-    mpi_powm( output, input, skey->d, skey->n );
-#else
-    gcry_mpi_t m1   = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
-    gcry_mpi_t m2   = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
-    gcry_mpi_t h    = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
-
-    /* m1 = c ^ (d mod (p-1)) mod p */
-    mpi_sub_ui( h, skey->p, 1  );
-    mpi_fdiv_r( h, skey->d, h );   
-    mpi_powm( m1, input, h, skey->p );
-    /* m2 = c ^ (d mod (q-1)) mod q */
-    mpi_sub_ui( h, skey->q, 1  );
-    mpi_fdiv_r( h, skey->d, h );
-    mpi_powm( m2, input, h, skey->q );
-    /* h = u * ( m2 - m1 ) mod q */
-    mpi_sub( h, m2, m1 );
-    if ( mpi_is_neg( h ) ) 
+  if (!skey->p && !skey->q && !skey->u)
+    {
+      mpi_powm (output, input, skey->d, skey->n);
+    }
+  else
+    {
+      gcry_mpi_t m1 = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
+      gcry_mpi_t m2 = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
+      gcry_mpi_t h  = mpi_alloc_secure( mpi_get_nlimbs(skey->n)+1 );
+      
+      /* m1 = c ^ (d mod (p-1)) mod p */
+      mpi_sub_ui( h, skey->p, 1  );
+      mpi_fdiv_r( h, skey->d, h );   
+      mpi_powm( m1, input, h, skey->p );
+      /* m2 = c ^ (d mod (q-1)) mod q */
+      mpi_sub_ui( h, skey->q, 1  );
+      mpi_fdiv_r( h, skey->d, h );
+      mpi_powm( m2, input, h, skey->q );
+      /* h = u * ( m2 - m1 ) mod q */
+      mpi_sub( h, m2, m1 );
+      if ( mpi_is_neg( h ) ) 
         mpi_add ( h, h, skey->q );
-    mpi_mulm( h, skey->u, h, skey->q ); 
-    /* m = m2 + h * p */
-    mpi_mul ( h, h, skey->p );
-    mpi_add ( output, m1, h );
-    /* ready */
+      mpi_mulm( h, skey->u, h, skey->q ); 
+      /* m = m2 + h * p */
+      mpi_mul ( h, h, skey->p );
+      mpi_add ( output, m1, h );
     
-    mpi_free ( h );
-    mpi_free ( m1 );
-    mpi_free ( m2 );
-#endif
+      mpi_free ( h );
+      mpi_free ( m1 );
+      mpi_free ( m2 );
+    }
+}
+
+
+
+/* Perform RSA blinding.  */
+static gcry_mpi_t
+rsa_blind (gcry_mpi_t x, gcry_mpi_t r, gcry_mpi_t e, gcry_mpi_t n)
+{
+  /* A helper.  */
+  gcry_mpi_t a;
+
+  /* Result.  */
+  gcry_mpi_t y;
+
+  a = gcry_mpi_snew (gcry_mpi_get_nbits (n));
+  y = gcry_mpi_snew (gcry_mpi_get_nbits (n));
+  
+  /* Now we calculate: y = (x * r^e) mod n, where r is the random
+     number, e is the public exponent, x is the non-blinded data and n
+     is the RSA modulus.  */
+  gcry_mpi_powm (a, r, e, n);
+  gcry_mpi_mulm (y, a, x, n);
+
+  gcry_mpi_release (a);
+
+  return y;
 }
 
+/* Undo RSA blinding.  */
+static gcry_mpi_t
+rsa_unblind (gcry_mpi_t x, gcry_mpi_t ri, gcry_mpi_t n)
+{
+  gcry_mpi_t y;
+
+  y = gcry_mpi_snew (gcry_mpi_get_nbits (n));
+
+  /* Here we calculate: y = (x * r^-1) mod n, where x is the blinded
+     decrypted data, ri is the modular multiplicative inverse of r and
+     n is the RSA modulus.  */
+
+  gcry_mpi_mulm (y, ri, x, n);
 
+  return y;
+}
 
 /*********************************************
  **************  interface  ******************
@@ -430,63 +477,22 @@ _gcry_rsa_check_secret_key( int algo, gcry_mpi_t *skey )
 
 
 gcry_err_code_t
-_gcry_rsa_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *pkey,
-                  int flags)
+_gcry_rsa_encrypt (int algo, gcry_mpi_t *resarr, gcry_mpi_t data,
+                   gcry_mpi_t *pkey, int flags)
 {
   RSA_public_key pk;
-
+  
   pk.n = pkey[0];
   pk.e = pkey[1];
   resarr[0] = mpi_alloc (mpi_get_nlimbs (pk.n));
   public (resarr[0], data, &pk);
-
-  return GPG_ERR_NO_ERROR;
-}
-
-/* Perform RSA blinding.  */
-static gcry_mpi_t
-_gcry_rsa_blind (gcry_mpi_t x, gcry_mpi_t r, gcry_mpi_t e, gcry_mpi_t n)
-{
-  /* A helper.  */
-  gcry_mpi_t a;
-
-  /* Result.  */
-  gcry_mpi_t y;
-
-  a = gcry_mpi_snew (gcry_mpi_get_nbits (n));
-  y = gcry_mpi_snew (gcry_mpi_get_nbits (n));
   
-  /* Now we calculate: y = (x * r^e) mod n, where r is the random
-     number, e is the public exponent, x is the non-blinded data and n
-     is the RSA modulus.  */
-  gcry_mpi_powm (a, r, e, n);
-  gcry_mpi_mulm (y, a, x, n);
-
-  gcry_mpi_release (a);
-
-  return y;
-}
-
-/* Undo RSA blinding.  */
-static gcry_mpi_t
-_gcry_rsa_unblind (gcry_mpi_t x, gcry_mpi_t ri, gcry_mpi_t n)
-{
-  gcry_mpi_t y;
-
-  y = gcry_mpi_snew (gcry_mpi_get_nbits (n));
-
-  /* Here we calculate: y = (x * r^-1) mod n, where x is the blinded
-     decrypted data, ri is the modular multiplicative inverse of r and
-     n is the RSA modulus.  */
-
-  gcry_mpi_mulm (y, ri, x, n);
-
-  return y;
+  return GPG_ERR_NO_ERROR;
 }
 
 gcry_err_code_t
-_gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *skey,
-                  int flags)
+_gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data,
+                   gcry_mpi_t *skey, int flags)
 {
   RSA_secret_key sk;
   gcry_mpi_t r = MPI_NULL;     /* Random number needed for blinding.  */
@@ -527,10 +533,8 @@ _gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *s
     }
 
   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
-    /* Do blinding.  */
-    x = _gcry_rsa_blind (data[0], r, sk.e, sk.n);
+    x = rsa_blind (data[0], r, sk.e, sk.n);
   else
-    /* Skip blinding.  */
     x = data[0];
 
   /* Do the encryption.  */
@@ -542,7 +546,7 @@ _gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data, gcry_mpi_t *s
       gcry_mpi_t a = gcry_mpi_copy (y);
       
       gcry_mpi_release (y);
-      y = _gcry_rsa_unblind (a, ri, sk.n);
+      y = rsa_unblind (a, ri, sk.n);
     }
 
   if (! (flags & PUBKEY_FLAG_NO_BLINDING))
index afb5af9..d606d9f 100644 (file)
@@ -679,7 +679,7 @@ static gcry_err_code_t
 serpent_setkey (void *ctx,
                const byte_t *key, unsigned int key_length)
 {
-  serpent_context_t *context = (serpent_context_t *) ctx;
+  serpent_context_t *context = ctx;
   static const char *serpent_test_ret;
   static int serpent_init_done;
   gcry_err_code_t ret = GPG_ERR_NO_ERROR;
@@ -842,7 +842,7 @@ serpent_decrypt_internal (serpent_context_t *context,
 static void
 serpent_encrypt (void *ctx, byte_t *buffer_out, const byte_t *buffer_in)
 {
-  serpent_context_t *context = (serpent_context_t *) ctx;
+  serpent_context_t *context = ctx;
 
   serpent_encrypt_internal (context,
                            (const u32_t *) buffer_in, (u32_t *) buffer_out);
@@ -852,7 +852,7 @@ serpent_encrypt (void *ctx, byte_t *buffer_out, const byte_t *buffer_in)
 static void
 serpent_decrypt (void *ctx, byte *buffer_out, const byte *buffer_in)
 {
-  serpent_context_t *context = (serpent_context_t *) ctx;
+  serpent_context_t *context = ctx;
 
   serpent_decrypt_internal (context,
                            (const u32_t *) buffer_in,
@@ -913,7 +913,8 @@ serpent_test (void)
 
   for (i = 0; test_data[i].key_length; i++)
     {
-      serpent_setkey_internal (&context, test_data[i].key, test_data[i].key_length);
+      serpent_setkey_internal (&context, test_data[i].key,
+                               test_data[i].key_length);
       serpent_encrypt_internal (&context,
                                (const u32_t *) test_data[i].text_plain,
                                (u32_t *) scratch);
index 85b234a..1f31443 100644 (file)
@@ -50,7 +50,8 @@ typedef struct {
 static void
 sha1_init (void *context)
 {
-  SHA1_CONTEXT *hd = (SHA1_CONTEXT *) context;
+  SHA1_CONTEXT *hd = context;
+
   hd->h0 = 0x67452301;
   hd->h1 = 0xefcdab89;
   hd->h2 = 0x98badcfe;
@@ -67,28 +68,30 @@ sha1_init (void *context)
 static void
 transform( SHA1_CONTEXT *hd, byte *data )
 {
-    register u32 a,b,c,d,e,tm;
-    u32 x[16];
+  register u32 a,b,c,d,e,tm;
+  u32 x[16];
 
-    /* get values from the chaining vars */
-    a = hd->h0;
-    b = hd->h1;
-    c = hd->h2;
-    d = hd->h3;
-    e = hd->h4;
+  /* Get values from the chaining vars. */
+  a = hd->h0;
+  b = hd->h1;
+  c = hd->h2;
+  d = hd->h3;
+  e = hd->h4;
 
 #ifdef WORDS_BIGENDIAN
-    memcpy( x, data, 64 );
+  memcpy( x, data, 64 );
 #else
-    { int i;
-      byte *p2;
-      for(i=0, p2=(byte*)x; i < 16; i++, p2 += 4 ) {
-       p2[3] = *data++;
-       p2[2] = *data++;
-       p2[1] = *data++;
-       p2[0] = *data++;
+  {
+    int i;
+    byte *p2;
+    for(i=0, p2=(byte*)x; i < 16; i++, p2 += 4 )
+      {
+        p2[3] = *data++;
+        p2[2] = *data++;
+        p2[1] = *data++;
+        p2[0] = *data++;
       }
-    }
+  }
 #endif
 
 
@@ -112,93 +115,93 @@ transform( SHA1_CONTEXT *hd, byte *data )
                                      + m;            \
                                 b = rol( b, 30 );    \
                               } while(0)
-    R( a, b, c, d, e, F1, K1, x[ 0] );
-    R( e, a, b, c, d, F1, K1, x[ 1] );
-    R( d, e, a, b, c, F1, K1, x[ 2] );
-    R( c, d, e, a, b, F1, K1, x[ 3] );
-    R( b, c, d, e, a, F1, K1, x[ 4] );
-    R( a, b, c, d, e, F1, K1, x[ 5] );
-    R( e, a, b, c, d, F1, K1, x[ 6] );
-    R( d, e, a, b, c, F1, K1, x[ 7] );
-    R( c, d, e, a, b, F1, K1, x[ 8] );
-    R( b, c, d, e, a, F1, K1, x[ 9] );
-    R( a, b, c, d, e, F1, K1, x[10] );
-    R( e, a, b, c, d, F1, K1, x[11] );
-    R( d, e, a, b, c, F1, K1, x[12] );
-    R( c, d, e, a, b, F1, K1, x[13] );
-    R( b, c, d, e, a, F1, K1, x[14] );
-    R( a, b, c, d, e, F1, K1, x[15] );
-    R( e, a, b, c, d, F1, K1, M(16) );
-    R( d, e, a, b, c, F1, K1, M(17) );
-    R( c, d, e, a, b, F1, K1, M(18) );
-    R( b, c, d, e, a, F1, K1, M(19) );
-    R( a, b, c, d, e, F2, K2, M(20) );
-    R( e, a, b, c, d, F2, K2, M(21) );
-    R( d, e, a, b, c, F2, K2, M(22) );
-    R( c, d, e, a, b, F2, K2, M(23) );
-    R( b, c, d, e, a, F2, K2, M(24) );
-    R( a, b, c, d, e, F2, K2, M(25) );
-    R( e, a, b, c, d, F2, K2, M(26) );
-    R( d, e, a, b, c, F2, K2, M(27) );
-    R( c, d, e, a, b, F2, K2, M(28) );
-    R( b, c, d, e, a, F2, K2, M(29) );
-    R( a, b, c, d, e, F2, K2, M(30) );
-    R( e, a, b, c, d, F2, K2, M(31) );
-    R( d, e, a, b, c, F2, K2, M(32) );
-    R( c, d, e, a, b, F2, K2, M(33) );
-    R( b, c, d, e, a, F2, K2, M(34) );
-    R( a, b, c, d, e, F2, K2, M(35) );
-    R( e, a, b, c, d, F2, K2, M(36) );
-    R( d, e, a, b, c, F2, K2, M(37) );
-    R( c, d, e, a, b, F2, K2, M(38) );
-    R( b, c, d, e, a, F2, K2, M(39) );
-    R( a, b, c, d, e, F3, K3, M(40) );
-    R( e, a, b, c, d, F3, K3, M(41) );
-    R( d, e, a, b, c, F3, K3, M(42) );
-    R( c, d, e, a, b, F3, K3, M(43) );
-    R( b, c, d, e, a, F3, K3, M(44) );
-    R( a, b, c, d, e, F3, K3, M(45) );
-    R( e, a, b, c, d, F3, K3, M(46) );
-    R( d, e, a, b, c, F3, K3, M(47) );
-    R( c, d, e, a, b, F3, K3, M(48) );
-    R( b, c, d, e, a, F3, K3, M(49) );
-    R( a, b, c, d, e, F3, K3, M(50) );
-    R( e, a, b, c, d, F3, K3, M(51) );
-    R( d, e, a, b, c, F3, K3, M(52) );
-    R( c, d, e, a, b, F3, K3, M(53) );
-    R( b, c, d, e, a, F3, K3, M(54) );
-    R( a, b, c, d, e, F3, K3, M(55) );
-    R( e, a, b, c, d, F3, K3, M(56) );
-    R( d, e, a, b, c, F3, K3, M(57) );
-    R( c, d, e, a, b, F3, K3, M(58) );
-    R( b, c, d, e, a, F3, K3, M(59) );
-    R( a, b, c, d, e, F4, K4, M(60) );
-    R( e, a, b, c, d, F4, K4, M(61) );
-    R( d, e, a, b, c, F4, K4, M(62) );
-    R( c, d, e, a, b, F4, K4, M(63) );
-    R( b, c, d, e, a, F4, K4, M(64) );
-    R( a, b, c, d, e, F4, K4, M(65) );
-    R( e, a, b, c, d, F4, K4, M(66) );
-    R( d, e, a, b, c, F4, K4, M(67) );
-    R( c, d, e, a, b, F4, K4, M(68) );
-    R( b, c, d, e, a, F4, K4, M(69) );
-    R( a, b, c, d, e, F4, K4, M(70) );
-    R( e, a, b, c, d, F4, K4, M(71) );
-    R( d, e, a, b, c, F4, K4, M(72) );
-    R( c, d, e, a, b, F4, K4, M(73) );
-    R( b, c, d, e, a, F4, K4, M(74) );
-    R( a, b, c, d, e, F4, K4, M(75) );
-    R( e, a, b, c, d, F4, K4, M(76) );
-    R( d, e, a, b, c, F4, K4, M(77) );
-    R( c, d, e, a, b, F4, K4, M(78) );
-    R( b, c, d, e, a, F4, K4, M(79) );
-
-    /* update chainig vars */
-    hd->h0 += a;
-    hd->h1 += b;
-    hd->h2 += c;
-    hd->h3 += d;
-    hd->h4 += e;
+  R( a, b, c, d, e, F1, K1, x[ 0] );
+  R( e, a, b, c, d, F1, K1, x[ 1] );
+  R( d, e, a, b, c, F1, K1, x[ 2] );
+  R( c, d, e, a, b, F1, K1, x[ 3] );
+  R( b, c, d, e, a, F1, K1, x[ 4] );
+  R( a, b, c, d, e, F1, K1, x[ 5] );
+  R( e, a, b, c, d, F1, K1, x[ 6] );
+  R( d, e, a, b, c, F1, K1, x[ 7] );
+  R( c, d, e, a, b, F1, K1, x[ 8] );
+  R( b, c, d, e, a, F1, K1, x[ 9] );
+  R( a, b, c, d, e, F1, K1, x[10] );
+  R( e, a, b, c, d, F1, K1, x[11] );
+  R( d, e, a, b, c, F1, K1, x[12] );
+  R( c, d, e, a, b, F1, K1, x[13] );
+  R( b, c, d, e, a, F1, K1, x[14] );
+  R( a, b, c, d, e, F1, K1, x[15] );
+  R( e, a, b, c, d, F1, K1, M(16) );
+  R( d, e, a, b, c, F1, K1, M(17) );
+  R( c, d, e, a, b, F1, K1, M(18) );
+  R( b, c, d, e, a, F1, K1, M(19) );
+  R( a, b, c, d, e, F2, K2, M(20) );
+  R( e, a, b, c, d, F2, K2, M(21) );
+  R( d, e, a, b, c, F2, K2, M(22) );
+  R( c, d, e, a, b, F2, K2, M(23) );
+  R( b, c, d, e, a, F2, K2, M(24) );
+  R( a, b, c, d, e, F2, K2, M(25) );
+  R( e, a, b, c, d, F2, K2, M(26) );
+  R( d, e, a, b, c, F2, K2, M(27) );
+  R( c, d, e, a, b, F2, K2, M(28) );
+  R( b, c, d, e, a, F2, K2, M(29) );
+  R( a, b, c, d, e, F2, K2, M(30) );
+  R( e, a, b, c, d, F2, K2, M(31) );
+  R( d, e, a, b, c, F2, K2, M(32) );
+  R( c, d, e, a, b, F2, K2, M(33) );
+  R( b, c, d, e, a, F2, K2, M(34) );
+  R( a, b, c, d, e, F2, K2, M(35) );
+  R( e, a, b, c, d, F2, K2, M(36) );
+  R( d, e, a, b, c, F2, K2, M(37) );
+  R( c, d, e, a, b, F2, K2, M(38) );
+  R( b, c, d, e, a, F2, K2, M(39) );
+  R( a, b, c, d, e, F3, K3, M(40) );
+  R( e, a, b, c, d, F3, K3, M(41) );
+  R( d, e, a, b, c, F3, K3, M(42) );
+  R( c, d, e, a, b, F3, K3, M(43) );
+  R( b, c, d, e, a, F3, K3, M(44) );
+  R( a, b, c, d, e, F3, K3, M(45) );
+  R( e, a, b, c, d, F3, K3, M(46) );
+  R( d, e, a, b, c, F3, K3, M(47) );
+  R( c, d, e, a, b, F3, K3, M(48) );
+  R( b, c, d, e, a, F3, K3, M(49) );
+  R( a, b, c, d, e, F3, K3, M(50) );
+  R( e, a, b, c, d, F3, K3, M(51) );
+  R( d, e, a, b, c, F3, K3, M(52) );
+  R( c, d, e, a, b, F3, K3, M(53) );
+  R( b, c, d, e, a, F3, K3, M(54) );
+  R( a, b, c, d, e, F3, K3, M(55) );
+  R( e, a, b, c, d, F3, K3, M(56) );
+  R( d, e, a, b, c, F3, K3, M(57) );
+  R( c, d, e, a, b, F3, K3, M(58) );
+  R( b, c, d, e, a, F3, K3, M(59) );
+  R( a, b, c, d, e, F4, K4, M(60) );
+  R( e, a, b, c, d, F4, K4, M(61) );
+  R( d, e, a, b, c, F4, K4, M(62) );
+  R( c, d, e, a, b, F4, K4, M(63) );
+  R( b, c, d, e, a, F4, K4, M(64) );
+  R( a, b, c, d, e, F4, K4, M(65) );
+  R( e, a, b, c, d, F4, K4, M(66) );
+  R( d, e, a, b, c, F4, K4, M(67) );
+  R( c, d, e, a, b, F4, K4, M(68) );
+  R( b, c, d, e, a, F4, K4, M(69) );
+  R( a, b, c, d, e, F4, K4, M(70) );
+  R( e, a, b, c, d, F4, K4, M(71) );
+  R( d, e, a, b, c, F4, K4, M(72) );
+  R( c, d, e, a, b, F4, K4, M(73) );
+  R( b, c, d, e, a, F4, K4, M(74) );
+  R( a, b, c, d, e, F4, K4, M(75) );
+  R( e, a, b, c, d, F4, K4, M(76) );
+  R( d, e, a, b, c, F4, K4, M(77) );
+  R( c, d, e, a, b, F4, K4, M(78) );
+  R( b, c, d, e, a, F4, K4, M(79) );
+
+  /* Update chaining vars. */
+  hd->h0 += a;
+  hd->h1 += b;
+  hd->h2 += c;
+  hd->h3 += d;
+  hd->h4 += e;
 }
 
 
@@ -208,33 +211,38 @@ transform( SHA1_CONTEXT *hd, byte *data )
 static void
 sha1_write( void *context, byte *inbuf, size_t inlen)
 {
-  SHA1_CONTEXT *hd = (SHA1_CONTEXT *) context;
-    if( hd->count == 64 ) { /* flush the buffer */
-       transform( hd, hd->buf );
-        _gcry_burn_stack (88+4*sizeof(void*));
-       hd->count = 0;
-       hd->nblocks++;
+  SHA1_CONTEXT *hd = context;
+
+  if( hd->count == 64 )  /* flush the buffer */
+    {
+      transform( hd, hd->buf );
+      _gcry_burn_stack (88+4*sizeof(void*));
+      hd->count = 0;
+      hd->nblocks++;
     }
-    if( !inbuf )
-       return;
-    if( hd->count ) {
-       for( ; inlen && hd->count < 64; inlen-- )
-           hd->buf[hd->count++] = *inbuf++;
-       sha1_write( hd, NULL, 0 );
-       if( !inlen )
-           return;
+  if( !inbuf )
+    return;
+
+  if( hd->count )
+    {
+      for( ; inlen && hd->count < 64; inlen-- )
+        hd->buf[hd->count++] = *inbuf++;
+      sha1_write( hd, NULL, 0 );
+      if( !inlen )
+        return;
     }
 
-    while( inlen >= 64 ) {
-       transform( hd, inbuf );
-       hd->count = 0;
-       hd->nblocks++;
-       inlen -= 64;
-       inbuf += 64;
+  while( inlen >= 64 ) 
+    {
+      transform( hd, inbuf );
+      hd->count = 0;
+      hd->nblocks++;
+      inlen -= 64;
+      inbuf += 64;
     }
-    _gcry_burn_stack (88+4*sizeof(void*));
-    for( ; inlen && hd->count < 64; inlen-- )
-       hd->buf[hd->count++] = *inbuf++;
+  _gcry_burn_stack (88+4*sizeof(void*));
+  for( ; inlen && hd->count < 64; inlen-- )
+    hd->buf[hd->count++] = *inbuf++;
 }
 
 
@@ -248,62 +256,65 @@ sha1_write( void *context, byte *inbuf, size_t inlen)
 static void
 sha1_final(void *context)
 {
-  SHA1_CONTEXT *hd = (SHA1_CONTEXT *) context;
-    u32 t, msb, lsb;
-    byte *p;
-
-    sha1_write(hd, NULL, 0); /* flush */;
-
-    t = hd->nblocks;
-    /* multiply by 64 to make a byte count */
-    lsb = t << 6;
-    msb = t >> 26;
-    /* add the count */
-    t = lsb;
-    if( (lsb += hd->count) < t )
-       msb++;
-    /* multiply by 8 to make a bit count */
-    t = lsb;
-    lsb <<= 3;
-    msb <<= 3;
-    msb |= t >> 29;
-
-    if( hd->count < 56 ) { /* enough room */
-       hd->buf[hd->count++] = 0x80; /* pad */
-       while( hd->count < 56 )
-           hd->buf[hd->count++] = 0;  /* pad */
+  SHA1_CONTEXT *hd = context;
+  
+  u32 t, msb, lsb;
+  byte *p;
+
+  sha1_write(hd, NULL, 0); /* flush */;
+
+  t = hd->nblocks;
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = t >> 26;
+  /* add the count */
+  t = lsb;
+  if( (lsb += hd->count) < t )
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+
+  if( hd->count < 56 )  /* enough room */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad */
+      while( hd->count < 56 )
+        hd->buf[hd->count++] = 0;  /* pad */
     }
-    else { /* need one extra block */
-       hd->buf[hd->count++] = 0x80; /* pad character */
-       while( hd->count < 64 )
-           hd->buf[hd->count++] = 0;
-       sha1_write(hd, NULL, 0);  /* flush */;
-       memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+  else  /* need one extra block */
+    {
+      hd->buf[hd->count++] = 0x80; /* pad character */
+      while( hd->count < 64 )
+        hd->buf[hd->count++] = 0;
+      sha1_write(hd, NULL, 0);  /* flush */;
+      memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     }
-    /* append the 64 bit count */
-    hd->buf[56] = msb >> 24;
-    hd->buf[57] = msb >> 16;
-    hd->buf[58] = msb >>  8;
-    hd->buf[59] = msb     ;
-    hd->buf[60] = lsb >> 24;
-    hd->buf[61] = lsb >> 16;
-    hd->buf[62] = lsb >>  8;
-    hd->buf[63] = lsb     ;
-    transform( hd, hd->buf );
-    _gcry_burn_stack (88+4*sizeof(void*));
-
-    p = hd->buf;
+  /* append the 64 bit count */
+  hd->buf[56] = msb >> 24;
+  hd->buf[57] = msb >> 16;
+  hd->buf[58] = msb >>  8;
+  hd->buf[59] = msb       ;
+  hd->buf[60] = lsb >> 24;
+  hd->buf[61] = lsb >> 16;
+  hd->buf[62] = lsb >>  8;
+  hd->buf[63] = lsb       ;
+  transform( hd, hd->buf );
+  _gcry_burn_stack (88+4*sizeof(void*));
+
+  p = hd->buf;
 #ifdef WORDS_BIGENDIAN
 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
 #else /* little endian */
 #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;         \
-                     *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
+                  *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
 #endif
-    X(0);
-    X(1);
-    X(2);
-    X(3);
-    X(4);
+  X(0);
+  X(1);
+  X(2);
+  X(3);
+  X(4);
 #undef X
 
 }
@@ -311,7 +322,8 @@ sha1_final(void *context)
 static byte *
 sha1_read( void *context )
 {
-  SHA1_CONTEXT *hd = (SHA1_CONTEXT *) context;
+  SHA1_CONTEXT *hd = context;
+
   return hd->buf;
 }
 
@@ -322,12 +334,12 @@ sha1_read( void *context )
 void
 _gcry_sha1_hash_buffer (char *outbuf, const char *buffer, size_t length)
 {
-    SHA1_CONTEXT hd;
+  SHA1_CONTEXT hd;
 
-    sha1_init (&hd);
-    sha1_write (&hd, (byte*)buffer, length);
-    sha1_final (&hd);
-    memcpy (outbuf, hd.buf, 20);
+  sha1_init (&hd);
+  sha1_write (&hd, (byte*)buffer, length);
+  sha1_final (&hd);
+  memcpy (outbuf, hd.buf, 20);
 }
 
 
index 657c882..712c4e0 100644 (file)
@@ -54,7 +54,7 @@ typedef struct {
 static void
 sha256_init (void *context)
 {
-  SHA256_CONTEXT *hd = (SHA256_CONTEXT *) context;
+  SHA256_CONTEXT *hd = context;
 
   hd->h0 = 0x6a09e667;
   hd->h1 = 0xbb67ae85;
@@ -176,7 +176,8 @@ transform (SHA256_CONTEXT *hd, byte *data)
 static void
 sha256_write (void *context, byte *inbuf, size_t inlen)
 {
-  SHA256_CONTEXT *hd = (SHA256_CONTEXT *) context;
+  SHA256_CONTEXT *hd = context;
+
   if (hd->count == 64)
     { /* flush the buffer */
       transform (hd, hd->buf);
@@ -217,7 +218,7 @@ sha256_write (void *context, byte *inbuf, size_t inlen)
 static void
 sha256_final(void *context)
 {
-  SHA256_CONTEXT *hd = (SHA256_CONTEXT *) context;
+  SHA256_CONTEXT *hd = context;
   u32 t, msb, lsb;
   byte *p;
   
@@ -284,7 +285,8 @@ sha256_final(void *context)
 static byte *
 sha256_read (void *context)
 {
-  SHA256_CONTEXT *hd = (SHA256_CONTEXT *) context;
+  SHA256_CONTEXT *hd = context;
+
   return hd->buf;
 }
 
index cc33b80..e2160eb 100644 (file)
@@ -66,7 +66,7 @@ typedef struct
 static void
 sha512_init (void *context)
 {
-  SHA512_CONTEXT *hd = (SHA512_CONTEXT *) context;
+  SHA512_CONTEXT *hd = context;
 
   hd->h0 = U64_C(0x6a09e667f3bcc908);
   hd->h1 = U64_C(0xbb67ae8584caa73b);
@@ -84,7 +84,7 @@ sha512_init (void *context)
 static void
 sha384_init (void *context)
 {
-  SHA512_CONTEXT *hd = (SHA512_CONTEXT *) context;
+  SHA512_CONTEXT *hd = context;
 
   hd->h0 = U64_C(0xcbbb9d5dc1059ed8);
   hd->h1 = U64_C(0x629a292a367cd507);
@@ -210,7 +210,8 @@ transform (SHA512_CONTEXT *hd, byte *data)
       b = a;
       a = t1 + t2;
 
-      /* printf("t=%d a=%016llX b=%016llX c=%016llX d=%016llX e=%016llX f=%016llX g=%016llX h=%016llX\n",t,a,b,c,d,e,f,g,h); */
+      /* printf("t=%d a=%016llX b=%016llX c=%016llX d=%016llX "
+          "e=%016llX f=%016llX g=%016llX h=%016llX\n",t,a,b,c,d,e,f,g,h); */
     }
 
   /* update chaining vars */
@@ -231,7 +232,7 @@ transform (SHA512_CONTEXT *hd, byte *data)
 static void
 sha512_write (void *context, byte *inbuf, size_t inlen)
 {
-  SHA512_CONTEXT *hd = (SHA512_CONTEXT *) context;
+  SHA512_CONTEXT *hd = context;
 
   if (hd->count == 128)
     {                          /* flush the buffer */
@@ -276,7 +277,7 @@ sha512_write (void *context, byte *inbuf, size_t inlen)
 static void
 sha512_final (void *context)
 {
-  SHA512_CONTEXT *hd = (SHA512_CONTEXT *) context;
+  SHA512_CONTEXT *hd = context;
   u64 t, msb, lsb;
   byte *p;
 
index 0488988..a92e812 100644 (file)
@@ -590,75 +590,76 @@ static u64 sbox4[256] = {
 static void
 tiger_init( void *context )
 {
-  TIGER_CONTEXT *hd = (TIGER_CONTEXT *) context;
-    hd->a = 0x0123456789abcdefLL;
-    hd->b = 0xfedcba9876543210LL;
-    hd->c = 0xf096a5b4c3b2e187LL;
-    hd->nblocks = 0;
-    hd->count = 0;
+  TIGER_CONTEXT *hd = context;
+
+  hd->a = 0x0123456789abcdefLL;
+  hd->b = 0xfedcba9876543210LL;
+  hd->c = 0xf096a5b4c3b2e187LL;
+  hd->nblocks = 0;
+  hd->count = 0;
 }
 
 static void
 round( u64 *ra, u64 *rb, u64 *rc, u64 x, int mul )
 {
-    u64 a = *ra;
-    u64 b = *rb;
-    u64 c = *rc;
-
-    c ^= x;
-    a -=   sbox1[  c       & 0xff ] ^ sbox2[ (c >> 16) & 0xff ]
-        ^ sbox3[ (c >> 32) & 0xff ] ^ sbox4[ (c >> 48) & 0xff ];
-    b +=   sbox4[ (c >>  8) & 0xff ] ^ sbox3[ (c >> 24) & 0xff ]
-        ^ sbox2[ (c >> 40) & 0xff ] ^ sbox1[ (c >> 56) & 0xff ];
-    b *= mul;
-
-    *ra = a;
-    *rb = b;
-    *rc = c;
+  u64 a = *ra;
+  u64 b = *rb;
+  u64 c = *rc;
+  
+  c ^= x;
+  a -= (  sbox1[  c        & 0xff ] ^ sbox2[ (c >> 16) & 0xff ]
+        ^ sbox3[ (c >> 32) & 0xff ] ^ sbox4[ (c >> 48) & 0xff ]);
+  b += (  sbox4[ (c >>  8) & 0xff ] ^ sbox3[ (c >> 24) & 0xff ]
+        ^ sbox2[ (c >> 40) & 0xff ] ^ sbox1[ (c >> 56) & 0xff ]);
+  b *= mul;
+  
+  *ra = a;
+  *rb = b;
+  *rc = c;
 }
 
 
 static void
 pass( u64 *ra, u64 *rb, u64 *rc, u64 *x, int mul )
 {
-    u64 a = *ra;
-    u64 b = *rb;
-    u64 c = *rc;
-
-    round( &a, &b, &c, x[0], mul );
-    round( &b, &c, &a, x[1], mul );
-    round( &c, &a, &b, x[2], mul );
-    round( &a, &b, &c, x[3], mul );
-    round( &b, &c, &a, x[4], mul );
-    round( &c, &a, &b, x[5], mul );
-    round( &a, &b, &c, x[6], mul );
-    round( &b, &c, &a, x[7], mul );
-
-    *ra = a;
-    *rb = b;
-    *rc = c;
+  u64 a = *ra;
+  u64 b = *rb;
+  u64 c = *rc;
+
+  round( &a, &b, &c, x[0], mul );
+  round( &b, &c, &a, x[1], mul );
+  round( &c, &a, &b, x[2], mul );
+  round( &a, &b, &c, x[3], mul );
+  round( &b, &c, &a, x[4], mul );
+  round( &c, &a, &b, x[5], mul );
+  round( &a, &b, &c, x[6], mul );
+  round( &b, &c, &a, x[7], mul );
+
+  *ra = a;
+  *rb = b;
+  *rc = c;
 }
 
 
 static void
 key_schedule( u64 *x )
 {
-    x[0] -= x[7] ^ 0xa5a5a5a5a5a5a5a5LL;
-    x[1] ^= x[0];
-    x[2] += x[1];
-    x[3] -= x[2] ^ ((~x[1]) << 19 );
-    x[4] ^= x[3];
-    x[5] += x[4];
-    x[6] -= x[5] ^ ((~x[4]) >> 23 );
-    x[7] ^= x[6];
-    x[0] += x[7];
-    x[1] -= x[0] ^ ((~x[7]) << 19 );
-    x[2] ^= x[1];
-    x[3] += x[2];
-    x[4] -= x[3] ^ ((~x[2]) >> 23 );
-    x[5] ^= x[4];
-    x[6] += x[5];
-    x[7] -= x[6] ^ 0x0123456789abcdefLL;
+  x[0] -= x[7] ^ 0xa5a5a5a5a5a5a5a5LL;
+  x[1] ^= x[0];
+  x[2] += x[1];
+  x[3] -= x[2] ^ ((~x[1]) << 19 );
+  x[4] ^= x[3];
+  x[5] += x[4];
+  x[6] -= x[5] ^ ((~x[4]) >> 23 );
+  x[7] ^= x[6];
+  x[0] += x[7];
+  x[1] -= x[0] ^ ((~x[7]) << 19 );
+  x[2] ^= x[1];
+  x[3] += x[2];
+  x[4] -= x[3] ^ ((~x[2]) >> 23 );
+  x[5] ^= x[4];
+  x[6] += x[5];
+  x[7] -= x[6] ^ 0x0123456789abcdefLL;
 }
 
 
@@ -668,46 +669,46 @@ key_schedule( u64 *x )
 static void
 transform( TIGER_CONTEXT *hd, byte *data )
 {
-    u64 a,b,c,aa,bb,cc;
-    u64 x[8];
+  u64 a,b,c,aa,bb,cc;
+  u64 x[8];
 #ifdef WORDS_BIGENDIAN
 #define MKWORD(d,n) \
                (  ((u64)(d)[8*(n)+7]) << 56 | ((u64)(d)[8*(n)+6]) << 48  \
                 | ((u64)(d)[8*(n)+5]) << 40 | ((u64)(d)[8*(n)+4]) << 32  \
                 | ((u64)(d)[8*(n)+3]) << 24 | ((u64)(d)[8*(n)+2]) << 16  \
                 | ((u64)(d)[8*(n)+1]) << 8  | ((u64)(d)[8*(n)  ])       )
-    x[0] = MKWORD(data, 0);
-    x[1] = MKWORD(data, 1);
-    x[2] = MKWORD(data, 2);
-    x[3] = MKWORD(data, 3);
-    x[4] = MKWORD(data, 4);
-    x[5] = MKWORD(data, 5);
-    x[6] = MKWORD(data, 6);
-    x[7] = MKWORD(data, 7);
+  x[0] = MKWORD(data, 0);
+  x[1] = MKWORD(data, 1);
+  x[2] = MKWORD(data, 2);
+  x[3] = MKWORD(data, 3);
+  x[4] = MKWORD(data, 4);
+  x[5] = MKWORD(data, 5);
+  x[6] = MKWORD(data, 6);
+  x[7] = MKWORD(data, 7);
 #undef MKWORD
 #else
-    memcpy( &x[0], data, 64 );
+  memcpy( &x[0], data, 64 );
 #endif
 
-    /* save */
-    a = aa = hd->a;
-    b = bb = hd->b;
-    c = cc = hd->c;
-
-    pass( &a, &b, &c, x, 5);
-    key_schedule( x );
-    pass( &c, &a, &b, x, 7);
-    key_schedule( x );
-    pass( &b, &c, &a, x, 9);
-
-    /* feedforward */
-    a ^= aa;
-    b -= bb;
-    c += cc;
-    /* store */
-    hd->a = a;
-    hd->b = b;
-    hd->c = c;
+  /* save */
+  a = aa = hd->a;
+  b = bb = hd->b;
+  c = cc = hd->c;
+
+  pass( &a, &b, &c, x, 5);
+  key_schedule( x );
+  pass( &c, &a, &b, x, 7);
+  key_schedule( x );
+  pass( &b, &c, &a, x, 9);
+
+  /* feedforward */
+  a ^= aa;
+  b -= bb;
+  c += cc;
+  /* store */
+  hd->a = a;
+  hd->b = b;
+  hd->c = c;
 }
 
 
@@ -718,106 +719,112 @@ transform( TIGER_CONTEXT *hd, byte *data )
 static void
 tiger_write( void *context, byte *inbuf, size_t inlen)
 {
-  TIGER_CONTEXT *hd = (TIGER_CONTEXT *) context;
-    if( hd->count == 64 ) { /* flush the buffer */
-       transform( hd, hd->buf );
-        _gcry_burn_stack (21*8+11*sizeof(void*));
-       hd->count = 0;
-       hd->nblocks++;
+  TIGER_CONTEXT *hd = context;
+
+  if( hd->count == 64 ) /* flush the buffer */
+    {
+      transform( hd, hd->buf );
+      _gcry_burn_stack (21*8+11*sizeof(void*));
+      hd->count = 0;
+      hd->nblocks++;
     }
-    if( !inbuf )
-       return;
-    if( hd->count ) {
-       for( ; inlen && hd->count < 64; inlen-- )
-           hd->buf[hd->count++] = *inbuf++;
-       tiger_write( hd, NULL, 0 );
-       if( !inlen )
-           return;
+  if( !inbuf )
+    return;
+  if( hd->count ) 
+    {
+      for( ; inlen && hd->count < 64; inlen-- )
+        hd->buf[hd->count++] = *inbuf++;
+      tiger_write( hd, NULL, 0 );
+      if( !inlen )
+        return;
     }
 
-    while( inlen >= 64 ) {
-       transform( hd, inbuf );
-       hd->count = 0;
-       hd->nblocks++;
-       inlen -= 64;
-       inbuf += 64;
+  while( inlen >= 64 )
+    {
+      transform( hd, inbuf );
+      hd->count = 0;
+      hd->nblocks++;
+      inlen -= 64;
+      inbuf += 64;
     }
-    _gcry_burn_stack (21*8+11*sizeof(void*));
-    for( ; inlen && hd->count < 64; inlen-- )
-       hd->buf[hd->count++] = *inbuf++;
+  _gcry_burn_stack (21*8+11*sizeof(void*));
+  for( ; inlen && hd->count < 64; inlen-- )
+    hd->buf[hd->count++] = *inbuf++;
 }
 
 
 
 /* The routine terminates the computation
  */
-
 static void
 tiger_final( void *context )
 {
-  TIGER_CONTEXT *hd = (TIGER_CONTEXT *) context;
-    u32 t, msb, lsb;
-    byte *p;
-
-    tiger_write(hd, NULL, 0); /* flush */;
-
-    t = hd->nblocks;
-    /* multiply by 64 to make a byte count */
-    lsb = t << 6;
-    msb = t >> 26;
-    /* add the count */
-    t = lsb;
-    if( (lsb += hd->count) < t )
-       msb++;
-    /* multiply by 8 to make a bit count */
-    t = lsb;
-    lsb <<= 3;
-    msb <<= 3;
-    msb |= t >> 29;
-
-    if( hd->count < 56 ) { /* enough room */
-       hd->buf[hd->count++] = 0x01; /* pad */
-       while( hd->count < 56 )
-           hd->buf[hd->count++] = 0;  /* pad */
+  TIGER_CONTEXT *hd = context;
+  u32 t, msb, lsb;
+  byte *p;
+
+  tiger_write(hd, NULL, 0); /* flush */;
+
+  t = hd->nblocks;
+  /* multiply by 64 to make a byte count */
+  lsb = t << 6;
+  msb = t >> 26;
+  /* add the count */
+  t = lsb;
+  if( (lsb += hd->count) < t )
+    msb++;
+  /* multiply by 8 to make a bit count */
+  t = lsb;
+  lsb <<= 3;
+  msb <<= 3;
+  msb |= t >> 29;
+
+  if( hd->count < 56 )  /* enough room */
+    {
+      hd->buf[hd->count++] = 0x01; /* pad */
+      while( hd->count < 56 )
+        hd->buf[hd->count++] = 0;  /* pad */
     }
-    else { /* need one extra block */
-       hd->buf[hd->count++] = 0x01; /* pad character */
-       while( hd->count < 64 )
-           hd->buf[hd->count++] = 0;
-       tiger_write(hd, NULL, 0);  /* flush */;
-       memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
+  else  /* need one extra block */
+    {
+      hd->buf[hd->count++] = 0x01; /* pad character */
+      while( hd->count < 64 )
+        hd->buf[hd->count++] = 0;
+      tiger_write(hd, NULL, 0);  /* flush */;
+      memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
     }
-    /* append the 64 bit count */
-    hd->buf[56] = lsb     ;
-    hd->buf[57] = lsb >>  8;
-    hd->buf[58] = lsb >> 16;
-    hd->buf[59] = lsb >> 24;
-    hd->buf[60] = msb     ;
-    hd->buf[61] = msb >>  8;
-    hd->buf[62] = msb >> 16;
-    hd->buf[63] = msb >> 24;
-    transform( hd, hd->buf );
-    _gcry_burn_stack (21*8+11*sizeof(void*));
-
-    p = hd->buf;
+  /* append the 64 bit count */
+  hd->buf[56] = lsb       ;
+  hd->buf[57] = lsb >>  8;
+  hd->buf[58] = lsb >> 16;
+  hd->buf[59] = lsb >> 24;
+  hd->buf[60] = msb       ;
+  hd->buf[61] = msb >>  8;
+  hd->buf[62] = msb >> 16;
+  hd->buf[63] = msb >> 24;
+  transform( hd, hd->buf );
+  _gcry_burn_stack (21*8+11*sizeof(void*));
+
+  p = hd->buf;
 #ifdef WORDS_BIGENDIAN
 #define X(a) do { *(u64*)p = hd->a ; p += 8; } while(0)
 #else /* little endian */
 #define X(a) do { *p++ = hd->a >> 56; *p++ = hd->a >> 48; \
-                     *p++ = hd->a >> 40; *p++ = hd->a >> 32; \
-                     *p++ = hd->a >> 24; *p++ = hd->a >> 16; \
-                     *p++ = hd->a >>  8; *p++ = hd->a; } while(0)
+                 *p++ = hd->a >> 40; *p++ = hd->a >> 32; \
+                 *p++ = hd->a >> 24; *p++ = hd->a >> 16; \
+                 *p++ = hd->a >>  8; *p++ = hd->a;       } while(0)
 #endif
-    X(a);
-    X(b);
-    X(c);
+  X(a);
+  X(b);
+  X(c);
 #undef X
 }
 
 static byte *
 tiger_read( void *context )
 {
-  TIGER_CONTEXT *hd = (TIGER_CONTEXT *) context;
+  TIGER_CONTEXT *hd = context;
+
   return hd->buf;
 }
 
index fd3651e..32589a0 100644 (file)
@@ -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. */
-\f
+
 #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;
 }
 \f
 /* 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 */