/ray/src/lib/crypto/rmd160hash.cc

Go to the documentation of this file.

/*
 * lib/crypto/rmd160hash.cc
 * 
 * Implementation of class RMD160Hash, a class for 
 * computing the RMD160 mesage digest / hash algorithm (RIPE MD 160). 
 * 
 * Copyright (c) 2001--2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "rmd160hash.h"

const SecureHashBase::Parameters RMD160Hash::par=
{
    INIT_FIELD(hash_size) 20,
    INIT_FIELD(block_size) 64,
    INIT_FIELD(hash_ID) 0x2000,
    INIT_FIELD(name) "RMD160"
};

static inline uint32 rmd_func0(uint32 x,uint32 y,uint32 z)
{  return(x ^ y ^ z);  }

static inline uint32 rmd_func1(uint32 x,uint32 y,uint32 z)
//{  return((x & y) | ((~x) & z));  }  // slower 
{  return(z ^ (x & (y ^ z)));  }  // faster

static inline uint32 rmd_func2(uint32 x,uint32 y,uint32 z)
{  return((x | (~y)) ^ z);  }

static inline uint32 rmd_func3(uint32 x,uint32 y,uint32 z)
{  return((x & z) | (y & (~z)));  }

static inline uint32 rmd_func4(uint32 x,uint32 y,uint32 z)
{  return(x ^ (y | (~z)));  }

static inline uint32 rotate(uint32 x,int n)
{  return((x<<n) | (x>>(32-n)));  }


// All this magic stuff...
static const uint32 rmd_init_state[5]=
{ 0x67452301U, 0xefcdab89U, 0x98badcfeU, 0x10325476U, 0xc3d2e1f0U };

#if UNROLLED!=2
// Constants: 
static const uint32 K[5]=
    { 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E };
static const uint32 KK[5]=
    { 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000 };

// Message selection permutation:
static const unsigned short int R[80]=
    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
      7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 
      3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 
      1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 
      4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 };
static const unsigned short int RR[80]=
    { 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 
      6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 
      15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 
      8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 
      12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 };

// Bit shift value: 
static const unsigned short int S[80]=
    { 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 
      7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 
      11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 
      11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 
      9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 };
static const unsigned short int SS[80]=
    { 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 
      9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 
      9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 
      15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 
      8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 };
#endif  /* !UNROLLED */


// msg: size 64 bytes
// w: temporary buffer where AtomicHash stores (expanded) input data (msg). 
void RMD160Hash::AtomicHash(const unsigned char *msg,uint32 *w)
{
    register uint32 *p;
    uint32 *we=&w[16];
    
    // Fill message into w-buffer. 
    msg+=3;
    for(p=w; p<we; p++)
    {
        // We want LSB first...
        *p= uint32(*(msg--));   *p<<=8;
        *p|=uint32(*(msg--));   *p<<=8;
        *p|=uint32(*(msg--));   *p<<=8;
        *p|=uint32(*(msg  ));
        msg+=7;
    }
    
    #if UNROLLED==0
    
    uint32 a,b,c,d,e;
    uint32 aa,bb,cc,dd,ee;
    
    // Assign current hash state: 
    a=aa=state[0];
    b=bb=state[1];
    c=cc=state[2];
    d=dd=state[3];
    e=ee=state[4];
    
    // Now, compute the rounds: 
    const uint32 *Kp=K,*KKp=KK;
    int j=0;
    uint32 tmp;
    for(; j<16; j++)
    {
        tmp = rotate(a + rmd_func0(b,c,d) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + e;
        a=e; e=d; d=rotate(c,10); c=b; b=tmp;
        tmp = rotate(aa + rmd_func4(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        aa=ee; ee=dd; dd=rotate(cc,10); cc=bb; bb=tmp;
    }
    for(++Kp,++KKp; j<32; j++)
    {
        tmp = rotate(a + rmd_func1(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        a=e; e=d; d=rotate(c,10); c=b; b=tmp;
        tmp = rotate(aa + rmd_func3(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        aa=ee; ee=dd; dd=rotate(cc,10); cc=bb; bb=tmp;
    }
    for(++Kp,++KKp; j<48; j++)
    {
        tmp = rotate(a + rmd_func2(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        a=e; e=d; d=rotate(c,10); c=b; b=tmp;
        tmp = rotate(aa + rmd_func2(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        aa=ee; ee=dd; dd=rotate(cc,10); cc=bb; bb=tmp;
    }
    for(++Kp,++KKp; j<64; j++)
    {
        tmp = rotate(a + rmd_func3(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        a=e; e=d; d=rotate(c,10); c=b; b=tmp;
        tmp = rotate(aa + rmd_func1(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        aa=ee; ee=dd; dd=rotate(cc,10); cc=bb; bb=tmp;
    }
    for(++Kp,++KKp; j<80; j++)
    {
        tmp = rotate(a + rmd_func4(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        a=e; e=d; d=rotate(c,10); c=b; b=tmp;
        tmp = rotate(aa + rmd_func0(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        aa=ee; ee=dd; dd=rotate(cc,10); cc=bb; bb=tmp;
    }
    
    // Add result to state: 
    tmp =      state[1] + c + dd;
    state[1] = state[2] + d + ee;
    state[2] = state[3] + e + aa;
    state[3] = state[4] + a + bb;
    state[4] = state[0] + b + cc;
    state[0] = tmp;
    
    #elif UNROLLED==1
    
    uint32 a,b,c,d,e;
    uint32 aa,bb,cc,dd,ee;
    
    // Assign current hash state: 
    a=aa=state[0];
    b=bb=state[1];
    c=cc=state[2];
    d=dd=state[3];
    e=ee=state[4];
    
    // Now, compute the rounds: 
    const uint32 *Kp=K,*KKp=KK;
    int j=0;
    for(; j<15; )
    {
        a = rotate(a + rmd_func0(b,c,d) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + e;
        c=rotate(c,10);
        aa = rotate(aa + rmd_func4(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        cc=rotate(cc,10);  ++j;
        
        e = rotate(e + rmd_func0(a,b,c) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + d;
        b=rotate(b,10);
        ee = rotate(ee + rmd_func4(aa,bb,cc) + w[RR[j]] + *KKp, SS[j]) + dd;
        bb=rotate(bb,10);  ++j;
        
        d = rotate(d + rmd_func0(e,a,b) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + c;
        a=rotate(a,10);
        dd = rotate(dd + rmd_func4(ee,aa,bb) + w[RR[j]] + *KKp, SS[j]) + cc;
        aa=rotate(aa,10);  ++j;
        
        c = rotate(c + rmd_func0(d,e,a) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + b;
        e=rotate(e,10);
        cc = rotate(cc + rmd_func4(dd,ee,aa) + w[RR[j]] + *KKp, SS[j]) + bb;
        ee=rotate(ee,10);  ++j;
        
        b = rotate(b + rmd_func0(c,d,e) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + a;
        d=rotate(d,10);
        bb = rotate(bb + rmd_func4(cc,dd,ee) + w[RR[j]] + *KKp, SS[j]) + aa;
        dd=rotate(dd,10);  ++j;
    }
    a = rotate(a + rmd_func0(b,c,d) + w[ /*R[*/ j /*]*/] + *Kp, S[j]) + e;
    c=rotate(c,10);
    aa = rotate(aa + rmd_func4(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
    cc=rotate(cc,10);  ++j;
    
    for(++Kp,++KKp; j<31; )
    {
        e = rotate(e + rmd_func1(a,b,c) + w[R[j]] + *Kp, S[j]) + d;
        b=rotate(b,10);
        ee = rotate(ee + rmd_func3(aa,bb,cc) + w[RR[j]] + *KKp, SS[j]) + dd;
        bb=rotate(bb,10);  ++j;
        
        d = rotate(d + rmd_func1(e,a,b) + w[R[j]] + *Kp, S[j]) + c;
        a=rotate(a,10);
        dd = rotate(dd + rmd_func3(ee,aa,bb) + w[RR[j]] + *KKp, SS[j]) + cc;
        aa=rotate(aa,10);  ++j;
        
        c = rotate(c + rmd_func1(d,e,a) + w[R[j]] + *Kp, S[j]) + b;
        e=rotate(e,10);
        cc = rotate(cc + rmd_func3(dd,ee,aa) + w[RR[j]] + *KKp, SS[j]) + bb;
        ee=rotate(ee,10);  ++j;
        
        b = rotate(b + rmd_func1(c,d,e) + w[R[j]] + *Kp, S[j]) + a;
        d=rotate(d,10);
        bb = rotate(bb + rmd_func3(cc,dd,ee) + w[RR[j]] + *KKp, SS[j]) + aa;
        dd=rotate(dd,10);  ++j;
        
        a = rotate(a + rmd_func1(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        c=rotate(c,10);
        aa = rotate(aa + rmd_func3(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        cc=rotate(cc,10);  ++j;
    }
    e = rotate(e + rmd_func1(a,b,c) + w[R[j]] + *Kp, S[j]) + d;
    b=rotate(b,10);
    ee = rotate(ee + rmd_func3(aa,bb,cc) + w[RR[j]] + *KKp, SS[j]) + dd;
    bb=rotate(bb,10);  ++j;
    
    for(++Kp,++KKp; j<47; )
    {
        d = rotate(d + rmd_func2(e,a,b) + w[R[j]] + *Kp, S[j]) + c;
        a=rotate(a,10);
        dd = rotate(dd + rmd_func2(ee,aa,bb) + w[RR[j]] + *KKp, SS[j]) + cc;
        aa=rotate(aa,10);  ++j;
        
        c = rotate(c + rmd_func2(d,e,a) + w[R[j]] + *Kp, S[j]) + b;
        e=rotate(e,10);
        cc = rotate(cc + rmd_func2(dd,ee,aa) + w[RR[j]] + *KKp, SS[j]) + bb;
        ee=rotate(ee,10);  ++j;
        
        b = rotate(b + rmd_func2(c,d,e) + w[R[j]] + *Kp, S[j]) + a;
        d=rotate(d,10);
        bb = rotate(bb + rmd_func2(cc,dd,ee) + w[RR[j]] + *KKp, SS[j]) + aa;
        dd=rotate(dd,10);  ++j;
        
        a = rotate(a + rmd_func2(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        c=rotate(c,10);
        aa = rotate(aa + rmd_func2(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        cc=rotate(cc,10);  ++j;
        
        e = rotate(e + rmd_func2(a,b,c) + w[R[j]] + *Kp, S[j]) + d;
        b=rotate(b,10);
        ee = rotate(ee + rmd_func2(aa,bb,cc) + w[RR[j]] + *KKp, SS[j]) + dd;
        bb=rotate(bb,10);  ++j;
    }
    d = rotate(d + rmd_func2(e,a,b) + w[R[j]] + *Kp, S[j]) + c;
    a=rotate(a,10);
    dd = rotate(dd + rmd_func2(ee,aa,bb) + w[RR[j]] + *KKp, SS[j]) + cc;
    aa=rotate(aa,10);  ++j;

    for(++Kp,++KKp; j<63; )
    {
        c = rotate(c + rmd_func3(d,e,a) + w[R[j]] + *Kp, S[j]) + b;
        e=rotate(e,10);
        cc = rotate(cc + rmd_func1(dd,ee,aa) + w[RR[j]] + *KKp, SS[j]) + bb;
        ee=rotate(ee,10);  ++j;
        
        b = rotate(b + rmd_func3(c,d,e) + w[R[j]] + *Kp, S[j]) + a;
        d=rotate(d,10);
        bb = rotate(bb + rmd_func1(cc,dd,ee) + w[RR[j]] + *KKp, SS[j]) + aa;
        dd=rotate(dd,10);  ++j;
        
        a = rotate(a + rmd_func3(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        c=rotate(c,10);
        aa = rotate(aa + rmd_func1(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        cc=rotate(cc,10);  ++j;
        
        e = rotate(e + rmd_func3(a,b,c) + w[R[j]] + *Kp, S[j]) + d;
        b=rotate(b,10);
        ee = rotate(ee + rmd_func1(aa,bb,cc) + w[RR[j]] + *KKp, SS[j]) + dd;
        bb=rotate(bb,10);  ++j;
        
        d = rotate(d + rmd_func3(e,a,b) + w[R[j]] + *Kp, S[j]) + c;
        a=rotate(a,10);
        dd = rotate(dd + rmd_func1(ee,aa,bb) + w[RR[j]] + *KKp, SS[j]) + cc;
        aa=rotate(aa,10);  ++j;
    }
    c = rotate(c + rmd_func3(d,e,a) + w[R[j]] + *Kp, S[j]) + b;
    e=rotate(e,10);
    cc = rotate(cc + rmd_func1(dd,ee,aa) + w[RR[j]] + *KKp, SS[j]) + bb;
    ee=rotate(ee,10);  ++j;
    
    for(++Kp,++KKp; j<79; )
    {
        b = rotate(b + rmd_func4(c,d,e) + w[R[j]] + *Kp, S[j]) + a;
        d=rotate(d,10);
        bb = rotate(bb + rmd_func0(cc,dd,ee) + w[RR[j]] + *KKp, SS[j]) + aa;
        dd=rotate(dd,10);  ++j;
        
        a = rotate(a + rmd_func4(b,c,d) + w[R[j]] + *Kp, S[j]) + e;
        c=rotate(c,10);
        aa = rotate(aa + rmd_func0(bb,cc,dd) + w[RR[j]] + *KKp, SS[j]) + ee;
        cc=rotate(cc,10);  ++j;
        
        e = rotate(e + rmd_func4(a,b,c) + w[R[j]] + *Kp, S[j]) + d;
        b=rotate(b,10);
        ee = rotate(ee + rmd_func0(aa,bb,cc) + w[RR[j]] + *KKp, SS[j]) + dd;
        bb=rotate(bb,10);  ++j;
        
        d = rotate(d + rmd_func4(e,a,b) + w[R[j]] + *Kp, S[j]) + c;
        a=rotate(a,10);
        dd = rotate(dd + rmd_func0(ee,aa,bb) + w[RR[j]] + *KKp, SS[j]) + cc;
        aa=rotate(aa,10);  ++j;
        
        c = rotate(c + rmd_func4(d,e,a) + w[R[j]] + *Kp, S[j]) + b;
        e=rotate(e,10);
        cc = rotate(cc + rmd_func0(dd,ee,aa) + w[RR[j]] + *KKp, SS[j]) + bb;
        ee=rotate(ee,10);  ++j;
    }
    b = rotate(b + rmd_func4(c,d,e) + w[R[j]] + *Kp, S[j]) + a;
    d=rotate(d,10);
    bb = rotate(bb + rmd_func0(cc,dd,ee) + w[RR[j]] + *KKp, SS[j]) + aa;
    dd=rotate(dd,10);  ++j;
    
    // Add result to state: 
    uint32 tmp;
    tmp =      state[1] + c + dd;
    state[1] = state[2] + d + ee;
    state[2] = state[3] + e + aa;
    state[3] = state[4] + a + bb;
    state[4] = state[0] + b + cc;
    state[0] = tmp;
    
    #elif UNROLLED==2
    
    uint32 x0,x1,x2,x3,x4;
    uint32 y0,y1,y2,y3,y4;
    
    // Assign (current) hash state to x and y: 
    x0 = y0 = state[0];
    x1 = y1 = state[1];
    x2 = y2 = state[2];
    x3 = y3 = state[3];
    x4 = y4 = state[4];
    
//-----------------------------------------------------------------------------
// Define the ten transforms.
//-----------------------------------------------------------------------------
#define T1(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func0((b),(c),(d)) + (x);            \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define T2(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func1((b),(c),(d)) + (x) + 0x5a827999UL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define T3(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func2((b),(c),(d)) + (x) + 0x6ed9eba1UL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define T4(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func3((b),(c),(d)) + (x) + 0x8f1bbcdcUL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define T5(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func4((b),(c),(d)) + (x) + 0xa953fd4eUL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}

#define S1(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func0((b),(c),(d)) + (x);            \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define S2(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func1((b),(c),(d)) + (x) + 0x7a6d76e9UL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define S3(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func2((b),(c),(d)) + (x) + 0x6d703ef3UL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define S4(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func3((b),(c),(d)) + (x) + 0x5c4dd124UL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}
#define S5(a,b,c,d,e,x,s) {                     \
            (a) += rmd_func4((b),(c),(d)) + (x) + 0x50a28be6UL; \
            (a) = rotate((a),(s)) + (e);            \
            (c) = rotate((c),10);}

    //------------------------------------
    // Perform the ten calculation rounds.
    //------------------------------------
    T1( x0 , x1 , x2 , x3 , x4 , w[ 0] , 11 );
    T1( x4 , x0 , x1 , x2 , x3 , w[ 1] , 14 );
    T1( x3 , x4 , x0 , x1 , x2 , w[ 2] , 15 );
    T1( x2 , x3 , x4 , x0 , x1 , w[ 3] , 12 );
    T1( x1 , x2 , x3 , x4 , x0 , w[ 4] ,  5 );
    T1( x0 , x1 , x2 , x3 , x4 , w[ 5] ,  8 );
    T1( x4 , x0 , x1 , x2 , x3 , w[ 6] ,  7 );
    T1( x3 , x4 , x0 , x1 , x2 , w[ 7] ,  9 );
    T1( x2 , x3 , x4 , x0 , x1 , w[ 8] , 11 );
    T1( x1 , x2 , x3 , x4 , x0 , w[ 9] , 13 );
    T1( x0 , x1 , x2 , x3 , x4 , w[10] , 14 );
    T1( x4 , x0 , x1 , x2 , x3 , w[11] , 15 );
    T1( x3 , x4 , x0 , x1 , x2 , w[12] ,  6 );
    T1( x2 , x3 , x4 , x0 , x1 , w[13] ,  7 );
    T1( x1 , x2 , x3 , x4 , x0 , w[14] ,  9 );
    T1( x0 , x1 , x2 , x3 , x4 , w[15] ,  8 );

    T2( x4 , x0 , x1 , x2 , x3 , w[ 7] ,  7 );
    T2( x3 , x4 , x0 , x1 , x2 , w[ 4] ,  6 );
    T2( x2 , x3 , x4 , x0 , x1 , w[13] ,  8 );
    T2( x1 , x2 , x3 , x4 , x0 , w[ 1] , 13 );
    T2( x0 , x1 , x2 , x3 , x4 , w[10] , 11 );
    T2( x4 , x0 , x1 , x2 , x3 , w[ 6] ,  9 );
    T2( x3 , x4 , x0 , x1 , x2 , w[15] ,  7 );
    T2( x2 , x3 , x4 , x0 , x1 , w[ 3] , 15 );
    T2( x1 , x2 , x3 , x4 , x0 , w[12] ,  7 );
    T2( x0 , x1 , x2 , x3 , x4 , w[ 0] , 12 );
    T2( x4 , x0 , x1 , x2 , x3 , w[ 9] , 15 );
    T2( x3 , x4 , x0 , x1 , x2 , w[ 5] ,  9 );
    T2( x2 , x3 , x4 , x0 , x1 , w[ 2] , 11 );
    T2( x1 , x2 , x3 , x4 , x0 , w[14] ,  7 );
    T2( x0 , x1 , x2 , x3 , x4 , w[11] , 13 );
    T2( x4 , x0 , x1 , x2 , x3 , w[ 8] , 12 );

    T3( x3 , x4 , x0 , x1 , x2 , w[ 3] , 11 );
    T3( x2 , x3 , x4 , x0 , x1 , w[10] , 13 );
    T3( x1 , x2 , x3 , x4 , x0 , w[14] ,  6 );
    T3( x0 , x1 , x2 , x3 , x4 , w[ 4] ,  7 );
    T3( x4 , x0 , x1 , x2 , x3 , w[ 9] , 14 );
    T3( x3 , x4 , x0 , x1 , x2 , w[15] ,  9 );
    T3( x2 , x3 , x4 , x0 , x1 , w[ 8] , 13 );
    T3( x1 , x2 , x3 , x4 , x0 , w[ 1] , 15 );
    T3( x0 , x1 , x2 , x3 , x4 , w[ 2] , 14 );
    T3( x4 , x0 , x1 , x2 , x3 , w[ 7] ,  8 );
    T3( x3 , x4 , x0 , x1 , x2 , w[ 0] , 13 );
    T3( x2 , x3 , x4 , x0 , x1 , w[ 6] ,  6 );
    T3( x1 , x2 , x3 , x4 , x0 , w[13] ,  5 );
    T3( x0 , x1 , x2 , x3 , x4 , w[11] , 12 );
    T3( x4 , x0 , x1 , x2 , x3 , w[ 5] ,  7 );
    T3( x3 , x4 , x0 , x1 , x2 , w[12] ,  5 );

    T4( x2 , x3 , x4 , x0 , x1 , w[ 1] , 11 );
    T4( x1 , x2 , x3 , x4 , x0 , w[ 9] , 12 );
    T4( x0 , x1 , x2 , x3 , x4 , w[11] , 14 );
    T4( x4 , x0 , x1 , x2 , x3 , w[10] , 15 );
    T4( x3 , x4 , x0 , x1 , x2 , w[ 0] , 14 );
    T4( x2 , x3 , x4 , x0 , x1 , w[ 8] , 15 );
    T4( x1 , x2 , x3 , x4 , x0 , w[12] ,  9 );
    T4( x0 , x1 , x2 , x3 , x4 , w[ 4] ,  8 );
    T4( x4 , x0 , x1 , x2 , x3 , w[13] ,  9 );
    T4( x3 , x4 , x0 , x1 , x2 , w[ 3] , 14 );
    T4( x2 , x3 , x4 , x0 , x1 , w[ 7] ,  5 );
    T4( x1 , x2 , x3 , x4 , x0 , w[15] ,  6 );
    T4( x0 , x1 , x2 , x3 , x4 , w[14] ,  8 );
    T4( x4 , x0 , x1 , x2 , x3 , w[ 5] ,  6 );
    T4( x3 , x4 , x0 , x1 , x2 , w[ 6] ,  5 );
    T4( x2 , x3 , x4 , x0 , x1 , w[ 2] , 12 );

    T5( x1 , x2 , x3 , x4 , x0 , w[ 4] ,  9 );
    T5( x0 , x1 , x2 , x3 , x4 , w[ 0] , 15 );
    T5( x4 , x0 , x1 , x2 , x3 , w[ 5] ,  5 );
    T5( x3 , x4 , x0 , x1 , x2 , w[ 9] , 11 );
    T5( x2 , x3 , x4 , x0 , x1 , w[ 7] ,  6 );
    T5( x1 , x2 , x3 , x4 , x0 , w[12] ,  8 );
    T5( x0 , x1 , x2 , x3 , x4 , w[ 2] , 13 );
    T5( x4 , x0 , x1 , x2 , x3 , w[10] , 12 );
    T5( x3 , x4 , x0 , x1 , x2 , w[14] ,  5 );
    T5( x2 , x3 , x4 , x0 , x1 , w[ 1] , 12 );
    T5( x1 , x2 , x3 , x4 , x0 , w[ 3] , 13 );
    T5( x0 , x1 , x2 , x3 , x4 , w[ 8] , 14 );
    T5( x4 , x0 , x1 , x2 , x3 , w[11] , 11 );
    T5( x3 , x4 , x0 , x1 , x2 , w[ 6] ,  8 );
    T5( x2 , x3 , x4 , x0 , x1 , w[15] ,  5 );
    T5( x1 , x2 , x3 , x4 , x0 , w[13] ,  6 );

    S5( y0 , y1 , y2 , y3 , y4 , w[ 5] ,  8 );
    S5( y4 , y0 , y1 , y2 , y3 , w[14] ,  9 );
    S5( y3 , y4 , y0 , y1 , y2 , w[ 7] ,  9 );
    S5( y2 , y3 , y4 , y0 , y1 , w[ 0] , 11 );
    S5( y1 , y2 , y3 , y4 , y0 , w[ 9] , 13 );
    S5( y0 , y1 , y2 , y3 , y4 , w[ 2] , 15 );
    S5( y4 , y0 , y1 , y2 , y3 , w[11] , 15 );
    S5( y3 , y4 , y0 , y1 , y2 , w[ 4] ,  5 );
    S5( y2 , y3 , y4 , y0 , y1 , w[13] ,  7 );
    S5( y1 , y2 , y3 , y4 , y0 , w[ 6] ,  7 );
    S5( y0 , y1 , y2 , y3 , y4 , w[15] ,  8 );
    S5( y4 , y0 , y1 , y2 , y3 , w[ 8] , 11 );
    S5( y3 , y4 , y0 , y1 , y2 , w[ 1] , 14 );
    S5( y2 , y3 , y4 , y0 , y1 , w[10] , 14 );
    S5( y1 , y2 , y3 , y4 , y0 , w[ 3] , 12 );
    S5( y0 , y1 , y2 , y3 , y4 , w[12] ,  6 );

    S4( y4 , y0 , y1 , y2 , y3 , w[ 6] ,  9 );
    S4( y3 , y4 , y0 , y1 , y2 , w[11] , 13 );
    S4( y2 , y3 , y4 , y0 , y1 , w[ 3] , 15 );
    S4( y1 , y2 , y3 , y4 , y0 , w[ 7] ,  7 );
    S4( y0 , y1 , y2 , y3 , y4 , w[ 0] , 12 );
    S4( y4 , y0 , y1 , y2 , y3 , w[13] ,  8 );
    S4( y3 , y4 , y0 , y1 , y2 , w[ 5] ,  9 );
    S4( y2 , y3 , y4 , y0 , y1 , w[10] , 11 );
    S4( y1 , y2 , y3 , y4 , y0 , w[14] ,  7 );
    S4( y0 , y1 , y2 , y3 , y4 , w[15] ,  7 );
    S4( y4 , y0 , y1 , y2 , y3 , w[ 8] , 12 );
    S4( y3 , y4 , y0 , y1 , y2 , w[12] ,  7 );
    S4( y2 , y3 , y4 , y0 , y1 , w[ 4] ,  6 );
    S4( y1 , y2 , y3 , y4 , y0 , w[ 9] , 15 );
    S4( y0 , y1 , y2 , y3 , y4 , w[ 1] , 13 );
    S4( y4 , y0 , y1 , y2 , y3 , w[ 2] , 11 );
    
    S3( y3 , y4 , y0 , y1 , y2 , w[15] ,  9 );
    S3( y2 , y3 , y4 , y0 , y1 , w[ 5] ,  7 );
    S3( y1 , y2 , y3 , y4 , y0 , w[ 1] , 15 );
    S3( y0 , y1 , y2 , y3 , y4 , w[ 3] , 11 );
    S3( y4 , y0 , y1 , y2 , y3 , w[ 7] ,  8 );
    S3( y3 , y4 , y0 , y1 , y2 , w[14] ,  6 );
    S3( y2 , y3 , y4 , y0 , y1 , w[ 6] ,  6 );
    S3( y1 , y2 , y3 , y4 , y0 , w[ 9] , 14 );
    S3( y0 , y1 , y2 , y3 , y4 , w[11] , 12 );
    S3( y4 , y0 , y1 , y2 , y3 , w[ 8] , 13 );
    S3( y3 , y4 , y0 , y1 , y2 , w[12] ,  5 );
    S3( y2 , y3 , y4 , y0 , y1 , w[ 2] , 14 );
    S3( y1 , y2 , y3 , y4 , y0 , w[10] , 13 );
    S3( y0 , y1 , y2 , y3 , y4 , w[ 0] , 13 );
    S3( y4 , y0 , y1 , y2 , y3 , w[ 4] ,  7 );
    S3( y3 , y4 , y0 , y1 , y2 , w[13] ,  5 );
    
    S2( y2 , y3 , y4 , y0 , y1 , w[ 8] , 15 );
    S2( y1 , y2 , y3 , y4 , y0 , w[ 6] ,  5 );
    S2( y0 , y1 , y2 , y3 , y4 , w[ 4] ,  8 );
    S2( y4 , y0 , y1 , y2 , y3 , w[ 1] , 11 );
    S2( y3 , y4 , y0 , y1 , y2 , w[ 3] , 14 );
    S2( y2 , y3 , y4 , y0 , y1 , w[11] , 14 );
    S2( y1 , y2 , y3 , y4 , y0 , w[15] ,  6 );
    S2( y0 , y1 , y2 , y3 , y4 , w[ 0] , 14 );
    S2( y4 , y0 , y1 , y2 , y3 , w[ 5] ,  6 );
    S2( y3 , y4 , y0 , y1 , y2 , w[12] ,  9 );
    S2( y2 , y3 , y4 , y0 , y1 , w[ 2] , 12 );
    S2( y1 , y2 , y3 , y4 , y0 , w[13] ,  9 );
    S2( y0 , y1 , y2 , y3 , y4 , w[ 9] , 12 );
    S2( y4 , y0 , y1 , y2 , y3 , w[ 7] ,  5 );
    S2( y3 , y4 , y0 , y1 , y2 , w[10] , 15 );
    S2( y2 , y3 , y4 , y0 , y1 , w[14] ,  8 );
    
    S1( y1 , y2 , y3 , y4 , y0 , w[12] ,  8 );
    S1( y0 , y1 , y2 , y3 , y4 , w[15] ,  5 );
    S1( y4 , y0 , y1 , y2 , y3 , w[10] , 12 );
    S1( y3 , y4 , y0 , y1 , y2 , w[ 4] ,  9 );
    S1( y2 , y3 , y4 , y0 , y1 , w[ 1] , 12 );
    S1( y1 , y2 , y3 , y4 , y0 , w[ 5] ,  5 );
    S1( y0 , y1 , y2 , y3 , y4 , w[ 8] , 14 );
    S1( y4 , y0 , y1 , y2 , y3 , w[ 7] ,  6 );
    S1( y3 , y4 , y0 , y1 , y2 , w[ 6] ,  8 );
    S1( y2 , y3 , y4 , y0 , y1 , w[ 2] , 13 );
    S1( y1 , y2 , y3 , y4 , y0 , w[13] ,  6 );
    S1( y0 , y1 , y2 , y3 , y4 , w[14] ,  5 );
    S1( y4 , y0 , y1 , y2 , y3 , w[ 0] , 15 );
    S1( y3 , y4 , y0 , y1 , y2 , w[ 3] , 13 );
    S1( y2 , y3 , y4 , y0 , y1 , w[ 9] , 11 );
    S1( y1 , y2 , y3 , y4 , y0 , w[11] , 11 );
    
    // Add result to state: 
    y3 += x2 + state[1];
    state[1] = state[2] + x3 + y4;
    state[2] = state[3] + x4 + y0;
    state[3] = state[4] + x0 + y1;
    state[4] = state[0] + x1 + y2;
    state[0] = y3;
    #else
    #error Illegal value for UNROLLED macro. 
    #endif  /* UNROLLED */
}


void RMD160Hash::GetHash(char *buf) const
{
    register unsigned char *hsh=(unsigned char*)buf;
    for(register const uint32 *i=state,*ie=&state[5]; i<ie; i++)
    {
        uint32 j=*i;
        *(hsh++)=(unsigned char)(j & 0xffU);  j>>=8;
        *(hsh++)=(unsigned char)(j & 0xffU);  j>>=8;
        *(hsh++)=(unsigned char)(j & 0xffU);  j>>=8;
        *(hsh++)=(unsigned char)(j & 0xffU);
    }
}


void RMD160Hash::reset()
{
    length=0LLU;
    
    state[0]=rmd_init_state[0];
    state[1]=rmd_init_state[1];
    state[2]=rmd_init_state[2];
    state[3]=rmd_init_state[3];
    state[4]=rmd_init_state[4];
    
    tmp_size=0;
    for(unsigned char *d=tmpbuf,*de=d+64; d<de; d++)
    {  *d=(unsigned char)0;  }
}


void RMD160Hash::feed(const char *_buf,size_t len)
{
    if(!len)
    {  return;  }
    
    const unsigned char *buf=(const unsigned char*)_buf;
    uint32 w[16];
    
    if(tmp_size)  // There is some data left from last time. 
    {
        size_t needed=64-tmp_size;
        if(len>=needed)
        {
            for(unsigned char *d=&tmpbuf[tmp_size],*de=&tmpbuf[64]; d<de; d++)
            {  *d=*(buf++);  }
            AtomicHash(tmpbuf,w);
            len-=needed;
            tmp_size=0;
            length+=64LLU;
            if(!len)
            {  return;  }
        }
        else
        {
            unsigned char *d=&tmpbuf[tmp_size];
            tmp_size+=int(len);
            for(unsigned char *de=&tmpbuf[tmp_size]; d<de; d++)
            {  *d=*(buf++);  }
            return;
        }
    }
    
    size_t l=len;
    for(;;)
    {
        if(l<64)
        {  break;  }
        AtomicHash((const unsigned char*)buf,w);
        buf+=64;
        l-=64;
    }
    length+=uint64(len-l);
    if(l)  // Some bytes left; store them for later. 
    {
        for(unsigned char *d=tmpbuf,*de=d+l; d<de; d++)
        {  *d=*(buf++);  }
        tmp_size=int(l);
    }
}


void RMD160Hash::final()
{
    uint32 w[16];
    int pad80=0;
    
    // Now, let's see if we need padding. 
    // We must check for >=56 as we always have to add one 0x80 padding. 
    // Padding does not count for the length, of course.
    length+=uint64(tmp_size);
    if(tmp_size>=56)  // We need to pad the tmpbuf with zeros and hash it. 
    {
        unsigned char *d=&tmpbuf[tmp_size];
        *(d++)=(unsigned char)0x80;   // append binary 10000000. 
        for(unsigned char *de=&tmpbuf[64]; d<de; d++)
        {  *d=(unsigned char)0;  }
        AtomicHash(tmpbuf,w);
        tmp_size=0;
        ++pad80;
    }
    
    // The length was counted in bytes, but we need the number of bits here: 
    uint64 len=length*8LLU;
    
    // Now, we have to fill up tmpbuf with zeros and add the length in bits 
    // as the last 8 bytes. 
    unsigned char *d=&tmpbuf[tmp_size];
    if(!pad80)
    {  *(d++)=(unsigned char)0x80;  }  // append binary 10000000. 
    for(unsigned char *de=&tmpbuf[56]; d<de; d++)
    {  *d=(unsigned char)0;  }
    
    // Add less significant word: 
    uint32 word = uint32(len & 0xffffffffLLU);
    *(d++)=(unsigned char)(word & 0xffU);  word>>=8;
    *(d++)=(unsigned char)(word & 0xffU);  word>>=8;
    *(d++)=(unsigned char)(word & 0xffU);  word>>=8;
    *(d++)=(unsigned char)(word & 0xffU);
    
    // Add more significant word: 
    word = uint32(len >> 32);
    *(d++)=(unsigned char)(word & 0xffU);  word>>=8;
    *(d++)=(unsigned char)(word & 0xffU);  word>>=8;
    *(d++)=(unsigned char)(word & 0xffU);  word>>=8;
    *(d  )=(unsigned char)(word & 0xffU);
    
    AtomicHash(tmpbuf,w);
    tmp_size=0;
}

---