/[winpt]/trunk/Gnupg/rmd160.c
ViewVC logotype

Diff of /trunk/Gnupg/rmd160.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 45 by twoaday, Mon Jan 31 11:02:21 2005 UTC revision 46 by werner, Fri Oct 28 12:57:05 2005 UTC
# Line 1  Line 1 
 /* rmd160.c  - RIPE-MD160  
  *      Copyright (C) 1998, 2001 Free Software Foundation, Inc.  
  *  
  * This file was taken from Libgcrypt cipher/rmd160.c  
  *  
  * This file is part of GPG.  
  *  
  * 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 Free Software Foundation; either version 2 of the License, or  
  * (at your option) any later version.  
  *  
  * This program is distributed in the hope that it will be useful,  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
  * GNU General Public License for more details.  
  *  
  * 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  
  */  
   
 #include <string.h>  
   
 #include "md.h"  
   
   
 /*********************************  
  * RIPEMD-160 is not patented, see (as of 25.10.97)  
  *   http://www.esat.kuleuven.ac.be/~bosselae/ripemd160.html  
  * Note that the code uses Little Endian unsigned charorder, which is good for  
  * 386 etc, but we must add some conversion when used on a big endian box.  
  *  
  *  
  * Pseudo-code for RIPEMD-160  
  *  
  * RIPEMD-160 is an iterative hash function that operates on 32-bit words.  
  * The round function takes as input a 5-word chaining variable and a 16-word  
  * message block and maps this to a new chaining variable. All operations are  
  * defined on 32-bit words. Padding is identical to that of MD4.  
  *  
  *  
  * RIPEMD-160: definitions  
  *  
  *  
  *   nonlinear functions at bit level: exor, mux, -, mux, -  
  *  
  *   f(j, x, y, z) = x XOR y XOR z                (0 <= j <= 15)  
  *   f(j, x, y, z) = (x AND y) OR (NOT(x) AND z)  (16 <= j <= 31)  
  *   f(j, x, y, z) = (x OR NOT(y)) XOR z          (32 <= j <= 47)  
  *   f(j, x, y, z) = (x AND z) OR (y AND NOT(z))  (48 <= j <= 63)  
  *   f(j, x, y, z) = x XOR (y OR NOT(z))          (64 <= j <= 79)  
  *  
  *  
  *   added constants (hexadecimal)  
  *  
  *   K(j) = 0x00000000      (0 <= j <= 15)  
  *   K(j) = 0x5A827999     (16 <= j <= 31)      int(2**30 x sqrt(2))  
  *   K(j) = 0x6ED9EBA1     (32 <= j <= 47)      int(2**30 x sqrt(3))  
  *   K(j) = 0x8F1BBCDC     (48 <= j <= 63)      int(2**30 x sqrt(5))  
  *   K(j) = 0xA953FD4E     (64 <= j <= 79)      int(2**30 x sqrt(7))  
  *   K'(j) = 0x50A28BE6     (0 <= j <= 15)      int(2**30 x cbrt(2))  
  *   K'(j) = 0x5C4DD124    (16 <= j <= 31)      int(2**30 x cbrt(3))  
  *   K'(j) = 0x6D703EF3    (32 <= j <= 47)      int(2**30 x cbrt(5))  
  *   K'(j) = 0x7A6D76E9    (48 <= j <= 63)      int(2**30 x cbrt(7))  
  *   K'(j) = 0x00000000    (64 <= j <= 79)  
  *  
  *  
  *   selection of message word  
  *  
  *   r(j)      = j                    (0 <= j <= 15)  
  *   r(16..31) = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8  
  *   r(32..47) = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12  
  *   r(48..63) = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2  
  *   r(64..79) = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13  
  *   r0(0..15) = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12  
  *   r0(16..31)= 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2  
  *   r0(32..47)= 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13  
  *   r0(48..63)= 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14  
  *   r0(64..79)= 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11  
  *  
  *  
  *   amount for rotate left (rol)  
  *  
  *   s(0..15)  = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8  
  *   s(16..31) = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12  
  *   s(32..47) = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5  
  *   s(48..63) = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12  
  *   s(64..79) = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6  
  *   s'(0..15) = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6  
  *   s'(16..31)= 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11  
  *   s'(32..47)= 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5  
  *   s'(48..63)= 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8  
  *   s'(64..79)= 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11  
  *  
  *  
  *   initial value (hexadecimal)  
  *  
  *   h0 = 0x67452301; h1 = 0xEFCDAB89; h2 = 0x98BADCFE; h3 = 0x10325476;  
  *                                                      h4 = 0xC3D2E1F0;  
  *  
  *  
  * RIPEMD-160: pseudo-code  
  *  
  *   It is assumed that the message after padding consists of t 16-word blocks  
  *   that will be denoted with X[i][j], with 0 <= i <= t-1 and 0 <= j <= 15.  
  *   The symbol [+] denotes addition modulo 2**32 and rol_s denotes cyclic left  
  *   shift (rotate) over s positions.  
  *  
  *  
  *   for i := 0 to t-1 {  
  *       A := h0; B := h1; C := h2; D = h3; E = h4;  
  *       A' := h0; B' := h1; C' := h2; D' = h3; E' = h4;  
  *       for j := 0 to 79 {  
  *           T := rol_s(j)(A [+] f(j, B, C, D) [+] X[i][r(j)] [+] K(j)) [+] E;  
  *           A := E; E := D; D := rol_10(C); C := B; B := T;  
  *           T := rol_s'(j)(A' [+] f(79-j, B', C', D') [+] X[i][r'(j)]  
                                                        [+] K'(j)) [+] E';  
  *           A' := E'; E' := D'; D' := rol_10(C'); C' := B'; B' := T;  
  *       }  
  *       T := h1 [+] C [+] D'; h1 := h2 [+] D [+] E'; h2 := h3 [+] E [+] A';  
  *       h3 := h4 [+] A [+] B'; h4 := h0 [+] B [+] C'; h0 := T;  
  *   }  
  */  
   
 /* Some examples:  
  * ""                    9c1185a5c5e9fc54612808977ee8f548b2258d31  
  * "a"                   0bdc9d2d256b3ee9daae347be6f4dc835a467ffe  
  * "abc"                 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc  
  * "message digest"      5d0689ef49d2fae572b881b123a85ffa21595f36  
  * "a...z"               f71c27109c692c1b56bbdceb5b9d2865b3708dbc  
  * "abcdbcde...nopq"     12a053384a9c0c88e405a06c27dcf49ada62eb2b  
  * "A...Za...z0...9"     b0e20b6e3116640286ed3a87a5713079b21f5189  
  * 8 times "1234567890"  9b752e45573d4b39f4dbd3323cab82bf63326bfb  
  * 1 million times "a"   52783243c1697bdbe16d37f97f68f08325dc1528  
  */  
   
 static void  
 burn_stack (int bytes)  
 {  
     char buf[150];  
       
     memset(buf, 0, sizeof buf);  
     bytes -= sizeof buf;  
     if (bytes > 0)  
         burn_stack (bytes);  
 }  
   
   
 void  
 rmd160_init( RMD160_CONTEXT *hd )  
 {  
     hd->h0 = 0x67452301;  
     hd->h1 = 0xEFCDAB89;  
     hd->h2 = 0x98BADCFE;  
     hd->h3 = 0x10325476;  
     hd->h4 = 0xC3D2E1F0;  
     hd->nblocks = 0;  
     hd->count = 0;  
 }  
   
   
 /****************  
  * Transform the message X which consists of 16 32-bit-words  
  */  
 static void  
 transform( RMD160_CONTEXT *hd, unsigned char *data )  
 {  
     unsigned long a,b,c,d,e,aa,bb,cc,dd,ee,t;  
   #ifdef BIG_ENDIAN_HOST  
     unsigned long x[16];  
     { int i;  
       unsigned char *p2, *p1;  
       for(i=0, p1=data, p2=(unsigned char*)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;  
      * 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.  
      * This function (when compiled with -02 on gcc 2.7.2)  
      * executes on a 586-100 (39.73 bogomips) at about 1900kb/sec;  
      * [measured with a 4MB data and "gpgm --print-md rmd160"] */  
     unsigned long x[16];  
     memcpy( x, data, 64 );    
   #endif  
   
   
 #define K0  0x00000000  
 #define K1  0x5A827999  
 #define K2  0x6ED9EBA1  
 #define K3  0x8F1BBCDC  
 #define K4  0xA953FD4E  
 #define KK0 0x50A28BE6  
 #define KK1 0x5C4DD124  
 #define KK2 0x6D703EF3  
 #define KK3 0x7A6D76E9  
 #define KK4 0x00000000  
 #define F0(x,y,z)   ( (x) ^ (y) ^ (z) )  
 #define F1(x,y,z)   ( ((x) & (y)) | (~(x) & (z)) )  
 #define F2(x,y,z)   ( ((x) | ~(y)) ^ (z) )  
 #define F3(x,y,z)   ( ((x) & (z)) | ((y) & ~(z)) )  
 #define F4(x,y,z)   ( (x) ^ ((y) | ~(z)) )  
 #define R(a,b,c,d,e,f,k,r,s) do { t = a + f(b,c,d) + k + x[r]; \  
                                   a = rol(t,s) + e;            \  
                                   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;  
 }  
   
   
 /* Update the message digest with the contents  
  * of INBUF with length INLEN.  
  */  
 void  
 rmd160_write( RMD160_CONTEXT *hd, unsigned char *inbuf, size_t inlen)  
 {  
     if( hd->count == 64 ) { /* flush the buffer */  
         transform( hd, hd->buf );  
         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;  
     }  
   
     while( inlen >= 64 ) {  
         transform( hd, inbuf );  
         hd->count = 0;  
         hd->nblocks++;  
         inlen -= 64;  
         inbuf += 64;  
     }  
     burn_stack (108+5*sizeof(void*));  
     for( ; inlen && hd->count < 64; inlen-- )  
         hd->buf[hd->count++] = *inbuf++;  
 }  
   
 /****************  
  * Apply the rmd160 transform function on the buffer which must have  
  * a length 64 unsigned chars. Do not use this function together with the  
  * other functions, use rmd160_init to initialize internal variables.  
  * Returns: 16 unsigned chars in buffer with the mixed contentes of buffer.  
  */  
 void  
 rmd160_mixblock( RMD160_CONTEXT *hd, char *buffer )  
 {  
     char *p = buffer;  
     transform( hd, buffer );  
   #define X(a) do { *(unsigned long*)p = hd->h##a ; p += 4; } while(0)  
     X(0);  
     X(1);  
     X(2);  
     X(3);  
     X(4);  
   #undef X  
 }  
   
   
 /* The routine terminates the computation  
  */  
   
 void  
 rmd160_final( RMD160_CONTEXT *hd )  
 {  
     unsigned long t, msb, lsb;  
     unsigned char *p;  
   
     rmd160_write(hd, NULL, 0); /* flush */;  
   
     t = hd->nblocks;  
     /* multiply by 64 to make a unsigned char 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 */  
     }  
     /* 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 );  
     burn_stack (108+5*sizeof(void*));  
   
     p = hd->buf;  
   #ifdef BIG_ENDIAN_HOST  
     #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)  
   #else /* little endian */  
     #define X(a) do { *(unsigned long*)p = hd->h##a ; p += 4; } while(0)  
   #endif  
     X(0);  
     X(1);  
     X(2);  
     X(3);  
     X(4);  
   #undef X  
 }  
   
 unsigned char *  
 rmd160_read( RMD160_CONTEXT *hd )  
 {  
     return hd->buf;  
 }  
1    /* rmd160.c  - RIPE-MD160
2     *      Copyright (C) 1998, 2001 Free Software Foundation, Inc.
3     *
4     * This file was taken from Libgcrypt cipher/rmd160.c
5     *
6     * This file is part of GPG.
7     *
8     * This program is free software; you can redistribute it and/or modify
9     * it under the terms of the GNU General Public License as published by
10     * the Free Software Foundation; either version 2 of the License, or
11     * (at your option) any later version.
12     *
13     * This program is distributed in the hope that it will be useful,
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     * GNU General Public License for more details.
17     *
18     * You should have received a copy of the GNU General Public License
19     * along with this program; if not, write to the Free Software Foundation,
20     * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21     */
22    
23    #ifdef HAVE_CONFIG_H
24    #include <config.h>
25    #endif
26    
27    #include <string.h>
28    #include <string.h>
29    
30    #include "md.h"
31    
32    
33    /*********************************
34     * RIPEMD-160 is not patented, see (as of 25.10.97)
35     *   http://www.esat.kuleuven.ac.be/~bosselae/ripemd160.html
36     * Note that the code uses Little Endian unsigned charorder, which is good for
37     * 386 etc, but we must add some conversion when used on a big endian box.
38     *
39     *
40     * Pseudo-code for RIPEMD-160
41     *
42     * RIPEMD-160 is an iterative hash function that operates on 32-bit words.
43     * The round function takes as input a 5-word chaining variable and a 16-word
44     * message block and maps this to a new chaining variable. All operations are
45     * defined on 32-bit words. Padding is identical to that of MD4.
46     *
47     *
48     * RIPEMD-160: definitions
49     *
50     *
51     *   nonlinear functions at bit level: exor, mux, -, mux, -
52     *
53     *   f(j, x, y, z) = x XOR y XOR z                (0 <= j <= 15)
54     *   f(j, x, y, z) = (x AND y) OR (NOT(x) AND z)  (16 <= j <= 31)
55     *   f(j, x, y, z) = (x OR NOT(y)) XOR z          (32 <= j <= 47)
56     *   f(j, x, y, z) = (x AND z) OR (y AND NOT(z))  (48 <= j <= 63)
57     *   f(j, x, y, z) = x XOR (y OR NOT(z))          (64 <= j <= 79)
58     *
59     *
60     *   added constants (hexadecimal)
61     *
62     *   K(j) = 0x00000000      (0 <= j <= 15)
63     *   K(j) = 0x5A827999     (16 <= j <= 31)      int(2**30 x sqrt(2))
64     *   K(j) = 0x6ED9EBA1     (32 <= j <= 47)      int(2**30 x sqrt(3))
65     *   K(j) = 0x8F1BBCDC     (48 <= j <= 63)      int(2**30 x sqrt(5))
66     *   K(j) = 0xA953FD4E     (64 <= j <= 79)      int(2**30 x sqrt(7))
67     *   K'(j) = 0x50A28BE6     (0 <= j <= 15)      int(2**30 x cbrt(2))
68     *   K'(j) = 0x5C4DD124    (16 <= j <= 31)      int(2**30 x cbrt(3))
69     *   K'(j) = 0x6D703EF3    (32 <= j <= 47)      int(2**30 x cbrt(5))
70     *   K'(j) = 0x7A6D76E9    (48 <= j <= 63)      int(2**30 x cbrt(7))
71     *   K'(j) = 0x00000000    (64 <= j <= 79)
72     *
73     *
74     *   selection of message word
75     *
76     *   r(j)      = j                    (0 <= j <= 15)
77     *   r(16..31) = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
78     *   r(32..47) = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
79     *   r(48..63) = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
80     *   r(64..79) = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
81     *   r0(0..15) = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
82     *   r0(16..31)= 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
83     *   r0(32..47)= 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
84     *   r0(48..63)= 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
85     *   r0(64..79)= 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
86     *
87     *
88     *   amount for rotate left (rol)
89     *
90     *   s(0..15)  = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
91     *   s(16..31) = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
92     *   s(32..47) = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
93     *   s(48..63) = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
94     *   s(64..79) = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
95     *   s'(0..15) = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
96     *   s'(16..31)= 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
97     *   s'(32..47)= 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
98     *   s'(48..63)= 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
99     *   s'(64..79)= 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
100     *
101     *
102     *   initial value (hexadecimal)
103     *
104     *   h0 = 0x67452301; h1 = 0xEFCDAB89; h2 = 0x98BADCFE; h3 = 0x10325476;
105     *                                                      h4 = 0xC3D2E1F0;
106     *
107     *
108     * RIPEMD-160: pseudo-code
109     *
110     *   It is assumed that the message after padding consists of t 16-word blocks
111     *   that will be denoted with X[i][j], with 0 <= i <= t-1 and 0 <= j <= 15.
112     *   The symbol [+] denotes addition modulo 2**32 and rol_s denotes cyclic left
113     *   shift (rotate) over s positions.
114     *
115     *
116     *   for i := 0 to t-1 {
117     *       A := h0; B := h1; C := h2; D = h3; E = h4;
118     *       A' := h0; B' := h1; C' := h2; D' = h3; E' = h4;
119     *       for j := 0 to 79 {
120     *           T := rol_s(j)(A [+] f(j, B, C, D) [+] X[i][r(j)] [+] K(j)) [+] E;
121     *           A := E; E := D; D := rol_10(C); C := B; B := T;
122     *           T := rol_s'(j)(A' [+] f(79-j, B', C', D') [+] X[i][r'(j)]
123                                                           [+] K'(j)) [+] E';
124     *           A' := E'; E' := D'; D' := rol_10(C'); C' := B'; B' := T;
125     *       }
126     *       T := h1 [+] C [+] D'; h1 := h2 [+] D [+] E'; h2 := h3 [+] E [+] A';
127     *       h3 := h4 [+] A [+] B'; h4 := h0 [+] B [+] C'; h0 := T;
128     *   }
129     */
130    
131    /* Some examples:
132     * ""                    9c1185a5c5e9fc54612808977ee8f548b2258d31
133     * "a"                   0bdc9d2d256b3ee9daae347be6f4dc835a467ffe
134     * "abc"                 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc
135     * "message digest"      5d0689ef49d2fae572b881b123a85ffa21595f36
136     * "a...z"               f71c27109c692c1b56bbdceb5b9d2865b3708dbc
137     * "abcdbcde...nopq"     12a053384a9c0c88e405a06c27dcf49ada62eb2b
138     * "A...Za...z0...9"     b0e20b6e3116640286ed3a87a5713079b21f5189
139     * 8 times "1234567890"  9b752e45573d4b39f4dbd3323cab82bf63326bfb
140     * 1 million times "a"   52783243c1697bdbe16d37f97f68f08325dc1528
141     */
142    
143    static void
144    burn_stack (int bytes)
145    {
146        char buf[150];
147        
148        memset(buf, 0, sizeof buf);
149        bytes -= sizeof buf;
150        if (bytes > 0)
151            burn_stack (bytes);
152    }
153    
154    
155    void
156    rmd160_init( RMD160_CONTEXT *hd )
157    {
158        hd->h0 = 0x67452301;
159        hd->h1 = 0xEFCDAB89;
160        hd->h2 = 0x98BADCFE;
161        hd->h3 = 0x10325476;
162        hd->h4 = 0xC3D2E1F0;
163        hd->nblocks = 0;
164        hd->count = 0;
165    }
166    
167    
168    /****************
169     * Transform the message X which consists of 16 32-bit-words
170     */
171    static void
172    transform( RMD160_CONTEXT *hd, unsigned char *data )
173    {
174        unsigned long a,b,c,d,e,aa,bb,cc,dd,ee,t;
175      #ifdef BIG_ENDIAN_HOST
176        unsigned long x[16];
177        { int i;
178          unsigned char *p2, *p1;
179          for(i=0, p1=data, p2=(unsigned char*)x; i < 16; i++, p2 += 4 ) {
180            p2[3] = *p1++;
181            p2[2] = *p1++;
182            p2[1] = *p1++;
183            p2[0] = *p1++;
184          }
185        }
186      #else  
187        /* this version is better because it is always aligned;
188         * The performance penalty on a 586-100 is about 6% which
189         * is acceptable - because the data is more local it might
190         * also be possible that this is faster on some machines.
191         * This function (when compiled with -02 on gcc 2.7.2)
192         * executes on a 586-100 (39.73 bogomips) at about 1900kb/sec;
193         * [measured with a 4MB data and "gpgm --print-md rmd160"] */
194        unsigned long x[16];
195        memcpy( x, data, 64 );  
196      #endif
197    
198    
199    #define K0  0x00000000
200    #define K1  0x5A827999
201    #define K2  0x6ED9EBA1
202    #define K3  0x8F1BBCDC
203    #define K4  0xA953FD4E
204    #define KK0 0x50A28BE6
205    #define KK1 0x5C4DD124
206    #define KK2 0x6D703EF3
207    #define KK3 0x7A6D76E9
208    #define KK4 0x00000000
209    #define F0(x,y,z)   ( (x) ^ (y) ^ (z) )
210    #define F1(x,y,z)   ( ((x) & (y)) | (~(x) & (z)) )
211    #define F2(x,y,z)   ( ((x) | ~(y)) ^ (z) )
212    #define F3(x,y,z)   ( ((x) & (z)) | ((y) & ~(z)) )
213    #define F4(x,y,z)   ( (x) ^ ((y) | ~(z)) )
214    #define R(a,b,c,d,e,f,k,r,s) do { t = a + f(b,c,d) + k + x[r]; \
215                                      a = rol(t,s) + e;            \
216                                      c = rol(c,10);               \
217                                    } while(0)
218    
219        /* left lane */
220        a = hd->h0;
221        b = hd->h1;
222        c = hd->h2;
223        d = hd->h3;
224        e = hd->h4;
225        R( a, b, c, d, e, F0, K0,  0, 11 );
226        R( e, a, b, c, d, F0, K0,  1, 14 );
227        R( d, e, a, b, c, F0, K0,  2, 15 );
228        R( c, d, e, a, b, F0, K0,  3, 12 );
229        R( b, c, d, e, a, F0, K0,  4,  5 );
230        R( a, b, c, d, e, F0, K0,  5,  8 );
231        R( e, a, b, c, d, F0, K0,  6,  7 );
232        R( d, e, a, b, c, F0, K0,  7,  9 );
233        R( c, d, e, a, b, F0, K0,  8, 11 );
234        R( b, c, d, e, a, F0, K0,  9, 13 );
235        R( a, b, c, d, e, F0, K0, 10, 14 );
236        R( e, a, b, c, d, F0, K0, 11, 15 );
237        R( d, e, a, b, c, F0, K0, 12,  6 );
238        R( c, d, e, a, b, F0, K0, 13,  7 );
239        R( b, c, d, e, a, F0, K0, 14,  9 );
240        R( a, b, c, d, e, F0, K0, 15,  8 );
241        R( e, a, b, c, d, F1, K1,  7,  7 );
242        R( d, e, a, b, c, F1, K1,  4,  6 );
243        R( c, d, e, a, b, F1, K1, 13,  8 );
244        R( b, c, d, e, a, F1, K1,  1, 13 );
245        R( a, b, c, d, e, F1, K1, 10, 11 );
246        R( e, a, b, c, d, F1, K1,  6,  9 );
247        R( d, e, a, b, c, F1, K1, 15,  7 );
248        R( c, d, e, a, b, F1, K1,  3, 15 );
249        R( b, c, d, e, a, F1, K1, 12,  7 );
250        R( a, b, c, d, e, F1, K1,  0, 12 );
251        R( e, a, b, c, d, F1, K1,  9, 15 );
252        R( d, e, a, b, c, F1, K1,  5,  9 );
253        R( c, d, e, a, b, F1, K1,  2, 11 );
254        R( b, c, d, e, a, F1, K1, 14,  7 );
255        R( a, b, c, d, e, F1, K1, 11, 13 );
256        R( e, a, b, c, d, F1, K1,  8, 12 );
257        R( d, e, a, b, c, F2, K2,  3, 11 );
258        R( c, d, e, a, b, F2, K2, 10, 13 );
259        R( b, c, d, e, a, F2, K2, 14,  6 );
260        R( a, b, c, d, e, F2, K2,  4,  7 );
261        R( e, a, b, c, d, F2, K2,  9, 14 );
262        R( d, e, a, b, c, F2, K2, 15,  9 );
263        R( c, d, e, a, b, F2, K2,  8, 13 );
264        R( b, c, d, e, a, F2, K2,  1, 15 );
265        R( a, b, c, d, e, F2, K2,  2, 14 );
266        R( e, a, b, c, d, F2, K2,  7,  8 );
267        R( d, e, a, b, c, F2, K2,  0, 13 );
268        R( c, d, e, a, b, F2, K2,  6,  6 );
269        R( b, c, d, e, a, F2, K2, 13,  5 );
270        R( a, b, c, d, e, F2, K2, 11, 12 );
271        R( e, a, b, c, d, F2, K2,  5,  7 );
272        R( d, e, a, b, c, F2, K2, 12,  5 );
273        R( c, d, e, a, b, F3, K3,  1, 11 );
274        R( b, c, d, e, a, F3, K3,  9, 12 );
275        R( a, b, c, d, e, F3, K3, 11, 14 );
276        R( e, a, b, c, d, F3, K3, 10, 15 );
277        R( d, e, a, b, c, F3, K3,  0, 14 );
278        R( c, d, e, a, b, F3, K3,  8, 15 );
279        R( b, c, d, e, a, F3, K3, 12,  9 );
280        R( a, b, c, d, e, F3, K3,  4,  8 );
281        R( e, a, b, c, d, F3, K3, 13,  9 );
282        R( d, e, a, b, c, F3, K3,  3, 14 );
283        R( c, d, e, a, b, F3, K3,  7,  5 );
284        R( b, c, d, e, a, F3, K3, 15,  6 );
285        R( a, b, c, d, e, F3, K3, 14,  8 );
286        R( e, a, b, c, d, F3, K3,  5,  6 );
287        R( d, e, a, b, c, F3, K3,  6,  5 );
288        R( c, d, e, a, b, F3, K3,  2, 12 );
289        R( b, c, d, e, a, F4, K4,  4,  9 );
290        R( a, b, c, d, e, F4, K4,  0, 15 );
291        R( e, a, b, c, d, F4, K4,  5,  5 );
292        R( d, e, a, b, c, F4, K4,  9, 11 );
293        R( c, d, e, a, b, F4, K4,  7,  6 );
294        R( b, c, d, e, a, F4, K4, 12,  8 );
295        R( a, b, c, d, e, F4, K4,  2, 13 );
296        R( e, a, b, c, d, F4, K4, 10, 12 );
297        R( d, e, a, b, c, F4, K4, 14,  5 );
298        R( c, d, e, a, b, F4, K4,  1, 12 );
299        R( b, c, d, e, a, F4, K4,  3, 13 );
300        R( a, b, c, d, e, F4, K4,  8, 14 );
301        R( e, a, b, c, d, F4, K4, 11, 11 );
302        R( d, e, a, b, c, F4, K4,  6,  8 );
303        R( c, d, e, a, b, F4, K4, 15,  5 );
304        R( b, c, d, e, a, F4, K4, 13,  6 );
305    
306        aa = a; bb = b; cc = c; dd = d; ee = e;
307    
308        /* right lane */
309        a = hd->h0;
310        b = hd->h1;
311        c = hd->h2;
312        d = hd->h3;
313        e = hd->h4;
314        R( a, b, c, d, e, F4, KK0,  5,  8);
315        R( e, a, b, c, d, F4, KK0, 14,  9);
316        R( d, e, a, b, c, F4, KK0,  7,  9);
317        R( c, d, e, a, b, F4, KK0,  0, 11);
318        R( b, c, d, e, a, F4, KK0,  9, 13);
319        R( a, b, c, d, e, F4, KK0,  2, 15);
320        R( e, a, b, c, d, F4, KK0, 11, 15);
321        R( d, e, a, b, c, F4, KK0,  4,  5);
322        R( c, d, e, a, b, F4, KK0, 13,  7);
323        R( b, c, d, e, a, F4, KK0,  6,  7);
324        R( a, b, c, d, e, F4, KK0, 15,  8);
325        R( e, a, b, c, d, F4, KK0,  8, 11);
326        R( d, e, a, b, c, F4, KK0,  1, 14);
327        R( c, d, e, a, b, F4, KK0, 10, 14);
328        R( b, c, d, e, a, F4, KK0,  3, 12);
329        R( a, b, c, d, e, F4, KK0, 12,  6);
330        R( e, a, b, c, d, F3, KK1,  6,  9);
331        R( d, e, a, b, c, F3, KK1, 11, 13);
332        R( c, d, e, a, b, F3, KK1,  3, 15);
333        R( b, c, d, e, a, F3, KK1,  7,  7);
334        R( a, b, c, d, e, F3, KK1,  0, 12);
335        R( e, a, b, c, d, F3, KK1, 13,  8);
336        R( d, e, a, b, c, F3, KK1,  5,  9);
337        R( c, d, e, a, b, F3, KK1, 10, 11);
338        R( b, c, d, e, a, F3, KK1, 14,  7);
339        R( a, b, c, d, e, F3, KK1, 15,  7);
340        R( e, a, b, c, d, F3, KK1,  8, 12);
341        R( d, e, a, b, c, F3, KK1, 12,  7);
342        R( c, d, e, a, b, F3, KK1,  4,  6);
343        R( b, c, d, e, a, F3, KK1,  9, 15);
344        R( a, b, c, d, e, F3, KK1,  1, 13);
345        R( e, a, b, c, d, F3, KK1,  2, 11);
346        R( d, e, a, b, c, F2, KK2, 15,  9);
347        R( c, d, e, a, b, F2, KK2,  5,  7);
348        R( b, c, d, e, a, F2, KK2,  1, 15);
349        R( a, b, c, d, e, F2, KK2,  3, 11);
350        R( e, a, b, c, d, F2, KK2,  7,  8);
351        R( d, e, a, b, c, F2, KK2, 14,  6);
352        R( c, d, e, a, b, F2, KK2,  6,  6);
353        R( b, c, d, e, a, F2, KK2,  9, 14);
354        R( a, b, c, d, e, F2, KK2, 11, 12);
355        R( e, a, b, c, d, F2, KK2,  8, 13);
356        R( d, e, a, b, c, F2, KK2, 12,  5);
357        R( c, d, e, a, b, F2, KK2,  2, 14);
358        R( b, c, d, e, a, F2, KK2, 10, 13);
359        R( a, b, c, d, e, F2, KK2,  0, 13);
360        R( e, a, b, c, d, F2, KK2,  4,  7);
361        R( d, e, a, b, c, F2, KK2, 13,  5);
362        R( c, d, e, a, b, F1, KK3,  8, 15);
363        R( b, c, d, e, a, F1, KK3,  6,  5);
364        R( a, b, c, d, e, F1, KK3,  4,  8);
365        R( e, a, b, c, d, F1, KK3,  1, 11);
366        R( d, e, a, b, c, F1, KK3,  3, 14);
367        R( c, d, e, a, b, F1, KK3, 11, 14);
368        R( b, c, d, e, a, F1, KK3, 15,  6);
369        R( a, b, c, d, e, F1, KK3,  0, 14);
370        R( e, a, b, c, d, F1, KK3,  5,  6);
371        R( d, e, a, b, c, F1, KK3, 12,  9);
372        R( c, d, e, a, b, F1, KK3,  2, 12);
373        R( b, c, d, e, a, F1, KK3, 13,  9);
374        R( a, b, c, d, e, F1, KK3,  9, 12);
375        R( e, a, b, c, d, F1, KK3,  7,  5);
376        R( d, e, a, b, c, F1, KK3, 10, 15);
377        R( c, d, e, a, b, F1, KK3, 14,  8);
378        R( b, c, d, e, a, F0, KK4, 12,  8);
379        R( a, b, c, d, e, F0, KK4, 15,  5);
380        R( e, a, b, c, d, F0, KK4, 10, 12);
381        R( d, e, a, b, c, F0, KK4,  4,  9);
382        R( c, d, e, a, b, F0, KK4,  1, 12);
383        R( b, c, d, e, a, F0, KK4,  5,  5);
384        R( a, b, c, d, e, F0, KK4,  8, 14);
385        R( e, a, b, c, d, F0, KK4,  7,  6);
386        R( d, e, a, b, c, F0, KK4,  6,  8);
387        R( c, d, e, a, b, F0, KK4,  2, 13);
388        R( b, c, d, e, a, F0, KK4, 13,  6);
389        R( a, b, c, d, e, F0, KK4, 14,  5);
390        R( e, a, b, c, d, F0, KK4,  0, 15);
391        R( d, e, a, b, c, F0, KK4,  3, 13);
392        R( c, d, e, a, b, F0, KK4,  9, 11);
393        R( b, c, d, e, a, F0, KK4, 11, 11);
394    
395    
396        t      = hd->h1 + d + cc;
397        hd->h1 = hd->h2 + e + dd;
398        hd->h2 = hd->h3 + a + ee;
399        hd->h3 = hd->h4 + b + aa;
400        hd->h4 = hd->h0 + c + bb;
401        hd->h0 = t;
402    }
403    
404    
405    /* Update the message digest with the contents
406     * of INBUF with length INLEN.
407     */
408    void
409    rmd160_write( RMD160_CONTEXT *hd, unsigned char *inbuf, size_t inlen)
410    {
411        if( hd->count == 64 ) { /* flush the buffer */
412            transform( hd, hd->buf );
413            burn_stack (108+5*sizeof(void*));
414            hd->count = 0;
415            hd->nblocks++;
416        }
417        if( !inbuf )
418            return;
419        if( hd->count ) {
420            for( ; inlen && hd->count < 64; inlen-- )
421                hd->buf[hd->count++] = *inbuf++;
422            rmd160_write( hd, NULL, 0 );
423            if( !inlen )
424                return;
425        }
426    
427        while( inlen >= 64 ) {
428            transform( hd, inbuf );
429            hd->count = 0;
430            hd->nblocks++;
431            inlen -= 64;
432            inbuf += 64;
433        }
434        burn_stack (108+5*sizeof(void*));
435        for( ; inlen && hd->count < 64; inlen-- )
436            hd->buf[hd->count++] = *inbuf++;
437    }
438    
439    /****************
440     * Apply the rmd160 transform function on the buffer which must have
441     * a length 64 unsigned chars. Do not use this function together with the
442     * other functions, use rmd160_init to initialize internal variables.
443     * Returns: 16 unsigned chars in buffer with the mixed contentes of buffer.
444     */
445    void
446    rmd160_mixblock( RMD160_CONTEXT *hd, char *buffer )
447    {
448        char *p = buffer;
449        transform( hd, buffer );
450      #define X(a) do { *(unsigned long*)p = hd->h##a ; p += 4; } while(0)
451        X(0);
452        X(1);
453        X(2);
454        X(3);
455        X(4);
456      #undef X
457    }
458    
459    
460    /* The routine terminates the computation
461     */
462    
463    void
464    rmd160_final( RMD160_CONTEXT *hd )
465    {
466        unsigned long t, msb, lsb;
467        unsigned char *p;
468    
469        rmd160_write(hd, NULL, 0); /* flush */;
470    
471        t = hd->nblocks;
472        /* multiply by 64 to make a unsigned char count */
473        lsb = t << 6;
474        msb = t >> 26;
475        /* add the count */
476        t = lsb;
477        if( (lsb += hd->count) < t )
478            msb++;
479        /* multiply by 8 to make a bit count */
480        t = lsb;
481        lsb <<= 3;
482        msb <<= 3;
483        msb |= t >> 29;
484    
485        if( hd->count < 56 ) { /* enough room */
486            hd->buf[hd->count++] = 0x80; /* pad */
487            while( hd->count < 56 )
488                hd->buf[hd->count++] = 0;  /* pad */
489        }
490        else { /* need one extra block */
491            hd->buf[hd->count++] = 0x80; /* pad character */
492            while( hd->count < 64 )
493                hd->buf[hd->count++] = 0;
494            rmd160_write(hd, NULL, 0);  /* flush */;
495            memset(hd->buf, 0, 56 ); /* fill next block with zeroes */
496        }
497        /* append the 64 bit count */
498        hd->buf[56] = lsb      ;
499        hd->buf[57] = lsb >>  8;
500        hd->buf[58] = lsb >> 16;
501        hd->buf[59] = lsb >> 24;
502        hd->buf[60] = msb      ;
503        hd->buf[61] = msb >>  8;
504        hd->buf[62] = msb >> 16;
505        hd->buf[63] = msb >> 24;
506        transform( hd, hd->buf );
507        burn_stack (108+5*sizeof(void*));
508    
509        p = hd->buf;
510      #ifdef BIG_ENDIAN_HOST
511        #define X(a) do { *p++ = hd->h##a      ; *p++ = hd->h##a >> 8;      \
512                          *p++ = hd->h##a >> 16; *p++ = hd->h##a >> 24; } while(0)
513      #else /* little endian */
514        #define X(a) do { *(unsigned long*)p = hd->h##a ; p += 4; } while(0)
515      #endif
516        X(0);
517        X(1);
518        X(2);
519        X(3);
520        X(4);
521      #undef X
522    }
523    
524    unsigned char *
525    rmd160_read( RMD160_CONTEXT *hd )
526    {
527        return hd->buf;
528    }
Legend:
Removed from v.45  
changed lines
  Added in v.46
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26