Collected changes. See ChnageLogs.

1 files changed, 312 insertions, 154 deletions

diff --git a/cipher/sha1.c b/cipher/sha1.c
index 9c81f680..fe80aba8 100644
--- a/cipher/sha1.c
+++ b/cipher/sha1.c
@@ -1,5 +1,5 @@
 /* sha1.c - SHA1 hash function
- *	Copyright (C) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 2001, 2002, 2003, 2008 Free Software Foundation, Inc.
  *
  * This file is part of Libgcrypt.
  *
@@ -14,8 +14,7 @@
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 
@@ -33,20 +32,47 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef HAVE_STDINT_H 
+# include <stdint.h>
+#endif
 
 #include "g10lib.h"
 #include "memory.h"
 #include "bithelp.h"
 #include "cipher.h"
 
-typedef struct {
-    u32  h0,h1,h2,h3,h4;
-    u32  nblocks;
-    byte buf[64];
-    int  count;
+
+/* A macro to test whether P is properly aligned for an u32 type.
+   Note that config.h provides a suitable replacement for uintptr_t if
+   it does not exist in stdint.h.  */
+#if __GNUC__ >= 2
+# define U32_ALIGNED_P(p) (!(((uintptr_t)p) % __alignof__ (u32)))
+#else
+# define U32_ALIGNED_P(p) (!(((uintptr_t)p) % sizeof (u32)))
+#endif
+
+#if WORDS_BIGENDIAN
+#define TRANSFORM(x,d,n) do { if (U32_ALIGNED_P ((x)))             \
+                                transform_aligned ((x), (d), (n)); \
+                              else                                 \
+                                transform ((x), (d), (n));         \
+                            } while (0)
+#else
+#define TRANSFORM(x,d,n) transform ((x), (d), (n))
+#endif
+
+
+
+typedef struct 
+{
+  u32           h0,h1,h2,h3,h4;
+  u32           nblocks;
+  unsigned char buf[64];
+  int           count;
 } SHA1_CONTEXT;
 
 
+
 static void
 sha1_init (void *context)
 {
@@ -62,39 +88,7 @@ sha1_init (void *context)
 }
 
 
-/****************
- * Transform the message X which consists of 16 32-bit-words
- */
-static void
-transform ( SHA1_CONTEXT *hd, const unsigned char *data )
-{
-  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;
-
-#ifdef WORDS_BIGENDIAN
-  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++;
-      }
-  }
-#endif
-
-
+/* Round function macros. */
 #define K1  0x5A827999L
 #define K2  0x6ED9EBA1L
 #define K3  0x8F1BBCDCL
@@ -103,108 +97,268 @@ transform ( SHA1_CONTEXT *hd, const unsigned char *data )
 #define F2(x,y,z)   ( x ^ y ^ z )
 #define F3(x,y,z)   ( ( x & y ) | ( z & ( x | y ) ) )
 #define F4(x,y,z)   ( x ^ y ^ z )
-
-
-#define M(i) ( tm =   x[i&0x0f] ^ x[(i-14)&0x0f] \
-		    ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f] \
-	       , (x[i&0x0f] = rol(tm, 1)) )
-
+#define M(i) ( tm =    x[ i    &0x0f]  \
+                     ^ x[(i-14)&0x0f]  \
+	 	     ^ x[(i-8) &0x0f]  \
+                     ^ x[(i-3) &0x0f], \
+                     (x[i&0x0f] = rol(tm, 1)))
 #define R(a,b,c,d,e,f,k,m)  do { e += rol( a, 5 )     \
-				      + f( b, c, d )  \
-				      + k	      \
-				      + m;	      \
+	                              + f( b, c, d )  \
+		 		      + k	      \
+			 	      + 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 chaining vars. */
-  hd->h0 += a;
-  hd->h1 += b;
-  hd->h2 += c;
-  hd->h3 += d;
-  hd->h4 += e;
+
+
+/*
+ * Transform NBLOCKS of each 64 bytes (16 32-bit words) at DATA.
+ * Unaligned version.
+ */
+static void
+transform (SHA1_CONTEXT *hd, const unsigned char *data, size_t nblocks)
+{
+  register u32 a, b, c, d, e; /* Local copies of the chaining variables.  */
+  register u32 tm;            /* Helper.  */
+  u32 x[16];                  /* The array we work on. */
+  
+  /* Loop over all blocks.  */
+  for ( ;nblocks; nblocks--)
+    {
+#ifdef WORDS_BIGENDIAN
+      memcpy (x, data, 64);
+      data += 64;
+#else
+      {
+        int i;
+        unsigned char *p;
+
+        for(i=0, p=(unsigned char*)x; i < 16; i++, p += 4 )
+          {
+            p[3] = *data++;
+            p[2] = *data++;
+            p[1] = *data++;
+            p[0] = *data++;
+          }
+      }
+#endif
+      /* Get the values of the chaining variables. */
+      a = hd->h0;
+      b = hd->h1;
+      c = hd->h2;
+      d = hd->h3;
+      e = hd->h4;
+
+      /* Transform. */
+      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 the chaining variables. */
+      hd->h0 += a;
+      hd->h1 += b;
+      hd->h2 += c;
+      hd->h3 += d;
+      hd->h4 += e;
+    }
 }
 
 
+#ifdef WORDS_BIGENDIAN
+/*
+ * Transform NBLOCKS of each 64 bytes (16 32-bit words) at DATA.  This
+ * version requires that DATA is aligned on a u32 boundary.  Note that
+ * we can do this only on big endian machines because we need to sawp
+ * bytes on little endian anyway.
+ */
+static void
+transform_aligned (SHA1_CONTEXT *hd, const unsigned char *data, size_t nblocks)
+{
+  register u32 a, b, c, d, e; /* Local copies of the chaining variables.  */
+  register u32 tm;            /* Helper.  */
+  const u32 *x;               /* 32 bit pointer we use for processing.  */
+  
+  x = (const u32*)data;
+
+  /* Loop over all blocks.  */
+  for ( ;nblocks; nblocks--, x += 16)
+    {
+      /* Get the values of the chaining variables. */
+      a = hd->h0;
+      b = hd->h1;
+      c = hd->h2;
+      d = hd->h3;
+      e = hd->h4;
+      
+      /* Transform.  */
+      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 the chaining variables. */
+      hd->h0 += a;
+      hd->h1 += b;
+      hd->h2 += c;
+      hd->h3 += d;
+      hd->h4 += e;
+    }
+}
+#endif /* WORDS_BIGENDIAN */
+
+
 /* Update the message digest with the contents
  * of INBUF with length INLEN.
  */
@@ -213,36 +367,40 @@ sha1_write( void *context, const void *inbuf_arg, size_t inlen)
 {
   const unsigned char *inbuf = inbuf_arg;
   SHA1_CONTEXT *hd = context;
+  size_t nblocks;
 
-  if( hd->count == 64 )  /* flush the buffer */
+  if (hd->count == 64)  /* Flush the buffer. */
     {
-      transform( hd, hd->buf );
+      TRANSFORM( hd, hd->buf, 1 );
       _gcry_burn_stack (88+4*sizeof(void*));
       hd->count = 0;
       hd->nblocks++;
     }
-  if( !inbuf )
+  if (!inbuf)
     return;
 
-  if( hd->count )
+  if (hd->count)
     {
-      for( ; inlen && hd->count < 64; inlen-- )
+      for (; inlen && hd->count < 64; inlen--)
         hd->buf[hd->count++] = *inbuf++;
-      sha1_write( hd, NULL, 0 );
-      if( !inlen )
+      sha1_write (hd, NULL, 0);
+      if (!inlen)
         return;
     }
 
-  while( inlen >= 64 ) 
+  nblocks = inlen / 64;
+  if (nblocks)
     {
-      transform( hd, inbuf );
+      TRANSFORM (hd, inbuf, nblocks);
       hd->count = 0;
-      hd->nblocks++;
-      inlen -= 64;
-      inbuf += 64;
+      hd->nblocks += nblocks;
+      inlen -= nblocks * 64;
+      inbuf += nblocks * 64;
     }
   _gcry_burn_stack (88+4*sizeof(void*));
-  for( ; inlen && hd->count < 64; inlen-- )
+
+  /* Save remaining bytes.  */
+  for (; inlen && hd->count < 64; inlen--)
     hd->buf[hd->count++] = *inbuf++;
 }
 
@@ -260,7 +418,7 @@ sha1_final(void *context)
   SHA1_CONTEXT *hd = context;
   
   u32 t, msb, lsb;
-  byte *p;
+  unsigned char *p;
 
   sha1_write(hd, NULL, 0); /* flush */;
 
@@ -301,7 +459,7 @@ sha1_final(void *context)
   hd->buf[61] = lsb >> 16;
   hd->buf[62] = lsb >>  8;
   hd->buf[63] = lsb	   ;
-  transform( hd, hd->buf );
+  TRANSFORM( hd, hd->buf, 1 );
   _gcry_burn_stack (88+4*sizeof(void*));
 
   p = hd->buf;
@@ -320,7 +478,7 @@ sha1_final(void *context)
 
 }
 
-static byte *
+static unsigned char *
 sha1_read( void *context )
 {
   SHA1_CONTEXT *hd = context;
@@ -344,7 +502,7 @@ _gcry_sha1_hash_buffer (void *outbuf, const void *buffer, size_t length)
 }
 
 
-static byte asn[15] = /* Object ID is 1.3.14.3.2.26 */
+static unsigned char asn[15] = /* Object ID is 1.3.14.3.2.26 */
   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };