* options.h, g10.c (main), keylist.c (list_keyblock_print): Add
[gnupg.git] / cipher / md5.c
index a372546..631df17 100644 (file)
@@ -1,8 +1,6 @@
 /* md5.c - MD5 Message-Digest Algorithm
- *     Copyright (C) 1995, 1996, 1998, 1999 Free Software Foundation, Inc.
- *
- * according to the definition of MD5 in RFC 1321 from April 1992.
- * NOTE: This is *not* the same file as the one from glibc.
+ * Copyright (C) 1995, 1996, 1998, 1999,
+ *               2000, 2001 Free Software Foundation, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the
  * You should have received a copy of the GNU 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.
+ *
+ * According to the definition of MD5 in RFC 1321 from April 1992.
+ * NOTE: This is *not* the same file as the one from glibc.
  */
 /* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.  */
-/* heavily modified for GnuPG by <werner.koch@guug.de> */
+/* Heavily modified for GnuPG by <wk@gnupg.org> */
 
 /* Test values:
  * ""                  D4 1D 8C D9 8F 00 B2 04  E9 80 09 98 EC F8 42 7E
@@ -35,7 +36,9 @@
 #include <assert.h>
 #include "util.h"
 #include "memory.h"
-#include "dynload.h"
+#include "algorithms.h"
+
+#include "bithelp.h"
 
 
 typedef struct {
@@ -70,6 +73,18 @@ md5_init( MD5_CONTEXT *ctx )
 #define FH(b, c, d) (b ^ c ^ d)
 #define FI(b, c, d) (c ^ (b | ~d))
 
+static void
+burn_stack (int bytes)
+{
+    char buf[128];
+    
+    wipememory(buf,sizeof buf);
+    bytes -= sizeof buf;
+    if (bytes > 0)
+        burn_stack (bytes);
+}
+
+
 
 /****************
  * transform n*64 bytes
@@ -85,7 +100,7 @@ transform( MD5_CONTEXT *ctx, byte *data )
     u32 D = ctx->D;
     u32 *cwp = correct_words;
 
-  #ifdef BIG_ENDIAN_HOST
+#ifdef BIG_ENDIAN_HOST
     { int i;
       byte *p2, *p1;
       for(i=0, p1=data, p2=(byte*)correct_words; i < 16; i++, p2 += 4 ) {
@@ -95,24 +110,20 @@ transform( MD5_CONTEXT *ctx, byte *data )
        p2[0] = *p1++;
       }
     }
-  #else
+#else
     memcpy( correct_words, data, 64 );
-  #endif
+#endif
 
 
 #define OP(a, b, c, d, s, T)                                       \
   do                                                               \
     {                                                              \
       a += FF (b, c, d) + (*cwp++) + T;            \
-      CYCLIC (a, s);                                               \
+      a = rol(a, s);                                               \
       a += b;                                                      \
     }                                                              \
   while (0)
 
-  /* It is unfortunate that C does not provide an operator for
-     cyclic rotation.  Hope the C compiler is smart enough.  */
-#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
-
     /* Before we start, one word about the strange constants.
        They are defined in RFC 1321 as
 
@@ -142,7 +153,7 @@ transform( MD5_CONTEXT *ctx, byte *data )
     do                                                               \
       {                                                              \
        a += f (b, c, d) + correct_words[k] + T;                      \
-       CYCLIC (a, s);                                                \
+       a = rol(a, s);                                                \
        a += b;                                                       \
       }                                                              \
     while (0)
@@ -219,6 +230,7 @@ md5_write( MD5_CONTEXT *hd, byte *inbuf, size_t inlen)
 {
     if( hd->count == 64 ) { /* flush the buffer */
        transform( hd, hd->buf );
+        burn_stack (80+6*sizeof(void*));
        hd->count = 0;
        hd->nblocks++;
     }
@@ -239,9 +251,9 @@ md5_write( MD5_CONTEXT *hd, byte *inbuf, size_t inlen)
        inlen -= 64;
        inbuf += 64;
     }
+    burn_stack (80+6*sizeof(void*));
     for( ; inlen && hd->count < 64; inlen-- )
        hd->buf[hd->count++] = *inbuf++;
-
 }
 
 
@@ -260,18 +272,19 @@ md5_final( MD5_CONTEXT *hd )
 
     md5_write(hd, NULL, 0); /* flush */;
 
-    msb = 0;
     t = hd->nblocks;
-    if( (lsb = t << 6) < t ) /* multiply by 64 to make a byte count */
-       msb++;
-    msb += t >> 26;
+    /* multiply by 64 to make a byte count */
+    lsb = t << 6;
+    msb = t >> 26;
+    /* add the count */
     t = lsb;
-    if( (lsb = t + hd->count) < t ) /* add the count */
+    if( (lsb += hd->count) < t )
        msb++;
+    /* multiply by 8 to make a bit count */
     t = lsb;
-    if( (lsb = t << 3) < t ) /* multiply by 8 to make a bit count */
-       msb++;
-    msb += t >> 29;
+    lsb <<= 3;
+    msb <<= 3;
+    msb |= t >> 29;
 
     if( hd->count < 56 ) { /* enough room */
        hd->buf[hd->count++] = 0x80; /* pad */
@@ -295,19 +308,20 @@ md5_final( MD5_CONTEXT *hd )
     hd->buf[62] = msb >> 16;
     hd->buf[63] = msb >> 24;
     transform( hd, hd->buf );
+    burn_stack (80+6*sizeof(void*));
 
     p = hd->buf;
-  #ifdef BIG_ENDIAN_HOST
-    #define X(a) do { *p++ = hd->##a     ; *p++ = hd->##a >> 8;      \
-                     *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
+#ifdef BIG_ENDIAN_HOST
+#define X(a) do { *p++ = hd-> a      ; *p++ = hd-> a >> 8;      \
+                     *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);
-  #undef X
+#undef X
 
 }
 
@@ -323,7 +337,7 @@ md5_read( MD5_CONTEXT *hd )
  * Returns: A pointer to string describing the algorithm or NULL if
  *         the ALGO is invalid.
  */
-static const char *
+const char *
 md5_get_info( int algo, size_t *contextsize,
               byte **r_asnoid, int *r_asnlen, int *r_mdlen,
               void (**r_init)( void *c ),
@@ -343,67 +357,10 @@ md5_get_info( int algo, size_t *contextsize,
     *r_asnoid = asn;
     *r_asnlen = DIM(asn);
     *r_mdlen = 16;
-    *r_init  = (void (*)(void *))md5_init;
-    *r_write = (void (*)(void *, byte*, size_t))md5_write;
-    *r_final = (void (*)(void *))md5_final;
-    *r_read  = (byte *(*)(void *))md5_read;
+    *(void  (**)(MD5_CONTEXT *))r_init                = md5_init;
+    *(void  (**)(MD5_CONTEXT *, byte*, size_t))r_write = md5_write;
+    *(void  (**)(MD5_CONTEXT *))r_final               = md5_final;
+    *(byte *(**)(MD5_CONTEXT *))r_read                = md5_read;
 
     return "MD5";
 }
-
-
-#ifndef IS_MODULE
-static
-#endif
-const char * const gnupgext_version = "MD5 ($Revision$)";
-
-static struct {
-    int class;
-    int version;
-    int  value;
-    void (*func)(void);
-} func_table[] = {
-    { 10, 1, 0, (void(*)(void))md5_get_info },
-    { 11, 1, 1 },
-};
-
-
-#ifndef IS_MODULE
-static
-#endif
-void *
-gnupgext_enum_func( int what, int *sequence, int *class, int *vers )
-{
-    void *ret;
-    int i = *sequence;
-
-    do {
-       if( i >= DIM(func_table) || i < 0 )
-           return NULL;
-       *class = func_table[i].class;
-       *vers  = func_table[i].version;
-       switch( *class ) {
-         case 11: case 21: case 31: ret = &func_table[i].value; break;
-         default:                   ret = func_table[i].func; break;
-       }
-       i++;
-    } while( what && what != *class );
-
-    *sequence = i;
-    return ret;
-}
-
-
-
-
-#ifndef IS_MODULE
-void
-md5_constructor(void)
-{
-    register_internal_cipher_extension( gnupgext_version, gnupgext_enum_func );
-}
-#endif
-
-
-
-/* end of file */