• Main Page
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

ext/digest/rmd160/rmd160.c

Go to the documentation of this file.
00001 /*      $NetBSD: rmd160.c,v 1.1.1.1 2001/03/06 11:21:05 agc Exp $       */
00002 /*      $RoughId: rmd160.c,v 1.2 2001/07/13 19:49:10 knu Exp $  */
00003 /*      $Id: rmd160.c 25189 2009-10-02 12:04:37Z akr $  */
00004 
00005 /********************************************************************\
00006  *
00007  *      FILE:     rmd160.c
00008  *
00009  *      CONTENTS: A sample C-implementation of the RIPEMD-160
00010  *                hash-function.
00011  *      TARGET:   any computer with an ANSI C compiler
00012  *
00013  *      AUTHOR:   Antoon Bosselaers, ESAT-COSIC
00014  *                (Arranged for libc by Todd C. Miller)
00015  *      DATE:     1 March 1996
00016  *      VERSION:  1.0
00017  *
00018  *      Copyright (c) Katholieke Universiteit Leuven
00019  *      1996, All Rights Reserved
00020  *
00021 \********************************************************************/
00022 
00023 #include "rmd160.h"
00024 
00025 #ifndef lint
00026 /* __RCSID("$NetBSD: rmd160.c,v 1.1.1.1 2001/03/06 11:21:05 agc Exp $"); */
00027 #endif  /* not lint */
00028 
00029 /* header files */
00030 
00031 #ifdef HAVE_SYS_ENDIAN_H_
00032 #include <sys/endian.h>
00033 #endif
00034 
00035 #ifdef HAVE_MACHINE_ENDIAN_H_
00036 #include <machine/endian.h>
00037 #endif
00038 
00039 /* #include "namespace.h" */
00040 
00041 #include <assert.h>
00042 #include <stdio.h>
00043 #include <stdlib.h>
00044 #include <string.h>
00045 
00046 #ifndef _DIAGASSERT
00047 #define _DIAGASSERT(cond)       assert(cond)
00048 #endif
00049 
00050 
00051 /********************************************************************/
00052 
00053 /* macro definitions */
00054 
00055 /* collect four bytes into one word: */
00056 #define BYTES_TO_DWORD(strptr)                  \
00057     (((uint32_t) *((strptr)+3) << 24) | \
00058     ((uint32_t) *((strptr)+2) << 16) |          \
00059     ((uint32_t) *((strptr)+1) <<  8) |          \
00060     ((uint32_t) *(strptr)))
00061 
00062 /* ROL(x, n) cyclically rotates x over n bits to the left */
00063 /* x must be of an unsigned 32 bits type and 0 <= n < 32. */
00064 #define ROL(x, n)       (((x) << (n)) | ((x) >> (32-(n))))
00065 
00066 /* the three basic functions F(), G() and H() */
00067 #define F(x, y, z)      ((x) ^ (y) ^ (z))
00068 #define G(x, y, z)      (((x) & (y)) | (~(x) & (z)))
00069 #define H(x, y, z)      (((x) | ~(y)) ^ (z))
00070 #define I(x, y, z)      (((x) & (z)) | ((y) & ~(z)))
00071 #define J(x, y, z)      ((x) ^ ((y) | ~(z)))
00072 
00073 /* the eight basic operations FF() through III() */
00074 #define FF(a, b, c, d, e, x, s) {                       \
00075       (a) += F((b), (c), (d)) + (x);                    \
00076       (a) = ROL((a), (s)) + (e);                        \
00077       (c) = ROL((c), 10);                               \
00078 }
00079 #define GG(a, b, c, d, e, x, s) {                       \
00080       (a) += G((b), (c), (d)) + (x) + 0x5a827999U;      \
00081       (a) = ROL((a), (s)) + (e);                        \
00082       (c) = ROL((c), 10);                               \
00083 }
00084 #define HH(a, b, c, d, e, x, s) {                       \
00085       (a) += H((b), (c), (d)) + (x) + 0x6ed9eba1U;      \
00086       (a) = ROL((a), (s)) + (e);                        \
00087       (c) = ROL((c), 10);                               \
00088 }
00089 #define II(a, b, c, d, e, x, s) {                       \
00090       (a) += I((b), (c), (d)) + (x) + 0x8f1bbcdcU;      \
00091       (a) = ROL((a), (s)) + (e);                        \
00092       (c) = ROL((c), 10);                               \
00093 }
00094 #define JJ(a, b, c, d, e, x, s) {                       \
00095       (a) += J((b), (c), (d)) + (x) + 0xa953fd4eU;      \
00096       (a) = ROL((a), (s)) + (e);                        \
00097       (c) = ROL((c), 10);                               \
00098 }
00099 #define FFF(a, b, c, d, e, x, s)        {               \
00100       (a) += F((b), (c), (d)) + (x);                    \
00101       (a) = ROL((a), (s)) + (e);                        \
00102       (c) = ROL((c), 10);                               \
00103 }
00104 #define GGG(a, b, c, d, e, x, s)        {               \
00105       (a) += G((b), (c), (d)) + (x) + 0x7a6d76e9U;      \
00106       (a) = ROL((a), (s)) + (e);                        \
00107       (c) = ROL((c), 10);                               \
00108 }
00109 #define HHH(a, b, c, d, e, x, s)        {               \
00110       (a) += H((b), (c), (d)) + (x) + 0x6d703ef3U;      \
00111       (a) = ROL((a), (s)) + (e);                        \
00112       (c) = ROL((c), 10);                               \
00113 }
00114 #define III(a, b, c, d, e, x, s)        {               \
00115       (a) += I((b), (c), (d)) + (x) + 0x5c4dd124U;      \
00116       (a) = ROL((a), (s)) + (e);                        \
00117       (c) = ROL((c), 10);                               \
00118 }
00119 #define JJJ(a, b, c, d, e, x, s)        {               \
00120       (a) += J((b), (c), (d)) + (x) + 0x50a28be6U;      \
00121       (a) = ROL((a), (s)) + (e);                        \
00122       (c) = ROL((c), 10);                               \
00123 }
00124 
00125 /********************************************************************/
00126 
00127 void
00128 RMD160_Init(RMD160_CTX *context)
00129 {
00130 
00131         _DIAGASSERT(context != NULL);
00132 
00133         /* ripemd-160 initialization constants */
00134         context->state[0] = 0x67452301U;
00135         context->state[1] = 0xefcdab89U;
00136         context->state[2] = 0x98badcfeU;
00137         context->state[3] = 0x10325476U;
00138         context->state[4] = 0xc3d2e1f0U;
00139         context->length[0] = context->length[1] = 0;
00140         context->buflen = 0;
00141 }
00142 
00143 /********************************************************************/
00144 
00145 void
00146 RMD160_Transform(uint32_t state[5], const uint32_t block[16])
00147 {
00148         uint32_t aa, bb, cc, dd, ee;
00149         uint32_t aaa, bbb, ccc, ddd, eee;
00150 
00151         _DIAGASSERT(state != NULL);
00152         _DIAGASSERT(block != NULL);
00153 
00154         aa = aaa = state[0];
00155         bb = bbb = state[1];
00156         cc = ccc = state[2];
00157         dd = ddd = state[3];
00158         ee = eee = state[4];
00159 
00160         /* round 1 */
00161         FF(aa, bb, cc, dd, ee, block[ 0], 11);
00162         FF(ee, aa, bb, cc, dd, block[ 1], 14);
00163         FF(dd, ee, aa, bb, cc, block[ 2], 15);
00164         FF(cc, dd, ee, aa, bb, block[ 3], 12);
00165         FF(bb, cc, dd, ee, aa, block[ 4],  5);
00166         FF(aa, bb, cc, dd, ee, block[ 5],  8);
00167         FF(ee, aa, bb, cc, dd, block[ 6],  7);
00168         FF(dd, ee, aa, bb, cc, block[ 7],  9);
00169         FF(cc, dd, ee, aa, bb, block[ 8], 11);
00170         FF(bb, cc, dd, ee, aa, block[ 9], 13);
00171         FF(aa, bb, cc, dd, ee, block[10], 14);
00172         FF(ee, aa, bb, cc, dd, block[11], 15);
00173         FF(dd, ee, aa, bb, cc, block[12],  6);
00174         FF(cc, dd, ee, aa, bb, block[13],  7);
00175         FF(bb, cc, dd, ee, aa, block[14],  9);
00176         FF(aa, bb, cc, dd, ee, block[15],  8);
00177 
00178         /* round 2 */
00179         GG(ee, aa, bb, cc, dd, block[ 7],  7);
00180         GG(dd, ee, aa, bb, cc, block[ 4],  6);
00181         GG(cc, dd, ee, aa, bb, block[13],  8);
00182         GG(bb, cc, dd, ee, aa, block[ 1], 13);
00183         GG(aa, bb, cc, dd, ee, block[10], 11);
00184         GG(ee, aa, bb, cc, dd, block[ 6],  9);
00185         GG(dd, ee, aa, bb, cc, block[15],  7);
00186         GG(cc, dd, ee, aa, bb, block[ 3], 15);
00187         GG(bb, cc, dd, ee, aa, block[12],  7);
00188         GG(aa, bb, cc, dd, ee, block[ 0], 12);
00189         GG(ee, aa, bb, cc, dd, block[ 9], 15);
00190         GG(dd, ee, aa, bb, cc, block[ 5],  9);
00191         GG(cc, dd, ee, aa, bb, block[ 2], 11);
00192         GG(bb, cc, dd, ee, aa, block[14],  7);
00193         GG(aa, bb, cc, dd, ee, block[11], 13);
00194         GG(ee, aa, bb, cc, dd, block[ 8], 12);
00195 
00196         /* round 3 */
00197         HH(dd, ee, aa, bb, cc, block[ 3], 11);
00198         HH(cc, dd, ee, aa, bb, block[10], 13);
00199         HH(bb, cc, dd, ee, aa, block[14],  6);
00200         HH(aa, bb, cc, dd, ee, block[ 4],  7);
00201         HH(ee, aa, bb, cc, dd, block[ 9], 14);
00202         HH(dd, ee, aa, bb, cc, block[15],  9);
00203         HH(cc, dd, ee, aa, bb, block[ 8], 13);
00204         HH(bb, cc, dd, ee, aa, block[ 1], 15);
00205         HH(aa, bb, cc, dd, ee, block[ 2], 14);
00206         HH(ee, aa, bb, cc, dd, block[ 7],  8);
00207         HH(dd, ee, aa, bb, cc, block[ 0], 13);
00208         HH(cc, dd, ee, aa, bb, block[ 6],  6);
00209         HH(bb, cc, dd, ee, aa, block[13],  5);
00210         HH(aa, bb, cc, dd, ee, block[11], 12);
00211         HH(ee, aa, bb, cc, dd, block[ 5],  7);
00212         HH(dd, ee, aa, bb, cc, block[12],  5);
00213 
00214         /* round 4 */
00215         II(cc, dd, ee, aa, bb, block[ 1], 11);
00216         II(bb, cc, dd, ee, aa, block[ 9], 12);
00217         II(aa, bb, cc, dd, ee, block[11], 14);
00218         II(ee, aa, bb, cc, dd, block[10], 15);
00219         II(dd, ee, aa, bb, cc, block[ 0], 14);
00220         II(cc, dd, ee, aa, bb, block[ 8], 15);
00221         II(bb, cc, dd, ee, aa, block[12],  9);
00222         II(aa, bb, cc, dd, ee, block[ 4],  8);
00223         II(ee, aa, bb, cc, dd, block[13],  9);
00224         II(dd, ee, aa, bb, cc, block[ 3], 14);
00225         II(cc, dd, ee, aa, bb, block[ 7],  5);
00226         II(bb, cc, dd, ee, aa, block[15],  6);
00227         II(aa, bb, cc, dd, ee, block[14],  8);
00228         II(ee, aa, bb, cc, dd, block[ 5],  6);
00229         II(dd, ee, aa, bb, cc, block[ 6],  5);
00230         II(cc, dd, ee, aa, bb, block[ 2], 12);
00231 
00232         /* round 5 */
00233         JJ(bb, cc, dd, ee, aa, block[ 4],  9);
00234         JJ(aa, bb, cc, dd, ee, block[ 0], 15);
00235         JJ(ee, aa, bb, cc, dd, block[ 5],  5);
00236         JJ(dd, ee, aa, bb, cc, block[ 9], 11);
00237         JJ(cc, dd, ee, aa, bb, block[ 7],  6);
00238         JJ(bb, cc, dd, ee, aa, block[12],  8);
00239         JJ(aa, bb, cc, dd, ee, block[ 2], 13);
00240         JJ(ee, aa, bb, cc, dd, block[10], 12);
00241         JJ(dd, ee, aa, bb, cc, block[14],  5);
00242         JJ(cc, dd, ee, aa, bb, block[ 1], 12);
00243         JJ(bb, cc, dd, ee, aa, block[ 3], 13);
00244         JJ(aa, bb, cc, dd, ee, block[ 8], 14);
00245         JJ(ee, aa, bb, cc, dd, block[11], 11);
00246         JJ(dd, ee, aa, bb, cc, block[ 6],  8);
00247         JJ(cc, dd, ee, aa, bb, block[15],  5);
00248         JJ(bb, cc, dd, ee, aa, block[13],  6);
00249 
00250         /* parallel round 1 */
00251         JJJ(aaa, bbb, ccc, ddd, eee, block[ 5],  8);
00252         JJJ(eee, aaa, bbb, ccc, ddd, block[14],  9);
00253         JJJ(ddd, eee, aaa, bbb, ccc, block[ 7],  9);
00254         JJJ(ccc, ddd, eee, aaa, bbb, block[ 0], 11);
00255         JJJ(bbb, ccc, ddd, eee, aaa, block[ 9], 13);
00256         JJJ(aaa, bbb, ccc, ddd, eee, block[ 2], 15);
00257         JJJ(eee, aaa, bbb, ccc, ddd, block[11], 15);
00258         JJJ(ddd, eee, aaa, bbb, ccc, block[ 4],  5);
00259         JJJ(ccc, ddd, eee, aaa, bbb, block[13],  7);
00260         JJJ(bbb, ccc, ddd, eee, aaa, block[ 6],  7);
00261         JJJ(aaa, bbb, ccc, ddd, eee, block[15],  8);
00262         JJJ(eee, aaa, bbb, ccc, ddd, block[ 8], 11);
00263         JJJ(ddd, eee, aaa, bbb, ccc, block[ 1], 14);
00264         JJJ(ccc, ddd, eee, aaa, bbb, block[10], 14);
00265         JJJ(bbb, ccc, ddd, eee, aaa, block[ 3], 12);
00266         JJJ(aaa, bbb, ccc, ddd, eee, block[12],  6);
00267 
00268         /* parallel round 2 */
00269         III(eee, aaa, bbb, ccc, ddd, block[ 6],  9);
00270         III(ddd, eee, aaa, bbb, ccc, block[11], 13);
00271         III(ccc, ddd, eee, aaa, bbb, block[ 3], 15);
00272         III(bbb, ccc, ddd, eee, aaa, block[ 7],  7);
00273         III(aaa, bbb, ccc, ddd, eee, block[ 0], 12);
00274         III(eee, aaa, bbb, ccc, ddd, block[13],  8);
00275         III(ddd, eee, aaa, bbb, ccc, block[ 5],  9);
00276         III(ccc, ddd, eee, aaa, bbb, block[10], 11);
00277         III(bbb, ccc, ddd, eee, aaa, block[14],  7);
00278         III(aaa, bbb, ccc, ddd, eee, block[15],  7);
00279         III(eee, aaa, bbb, ccc, ddd, block[ 8], 12);
00280         III(ddd, eee, aaa, bbb, ccc, block[12],  7);
00281         III(ccc, ddd, eee, aaa, bbb, block[ 4],  6);
00282         III(bbb, ccc, ddd, eee, aaa, block[ 9], 15);
00283         III(aaa, bbb, ccc, ddd, eee, block[ 1], 13);
00284         III(eee, aaa, bbb, ccc, ddd, block[ 2], 11);
00285 
00286         /* parallel round 3 */
00287         HHH(ddd, eee, aaa, bbb, ccc, block[15],  9);
00288         HHH(ccc, ddd, eee, aaa, bbb, block[ 5],  7);
00289         HHH(bbb, ccc, ddd, eee, aaa, block[ 1], 15);
00290         HHH(aaa, bbb, ccc, ddd, eee, block[ 3], 11);
00291         HHH(eee, aaa, bbb, ccc, ddd, block[ 7],  8);
00292         HHH(ddd, eee, aaa, bbb, ccc, block[14],  6);
00293         HHH(ccc, ddd, eee, aaa, bbb, block[ 6],  6);
00294         HHH(bbb, ccc, ddd, eee, aaa, block[ 9], 14);
00295         HHH(aaa, bbb, ccc, ddd, eee, block[11], 12);
00296         HHH(eee, aaa, bbb, ccc, ddd, block[ 8], 13);
00297         HHH(ddd, eee, aaa, bbb, ccc, block[12],  5);
00298         HHH(ccc, ddd, eee, aaa, bbb, block[ 2], 14);
00299         HHH(bbb, ccc, ddd, eee, aaa, block[10], 13);
00300         HHH(aaa, bbb, ccc, ddd, eee, block[ 0], 13);
00301         HHH(eee, aaa, bbb, ccc, ddd, block[ 4],  7);
00302         HHH(ddd, eee, aaa, bbb, ccc, block[13],  5);
00303 
00304         /* parallel round 4 */
00305         GGG(ccc, ddd, eee, aaa, bbb, block[ 8], 15);
00306         GGG(bbb, ccc, ddd, eee, aaa, block[ 6],  5);
00307         GGG(aaa, bbb, ccc, ddd, eee, block[ 4],  8);
00308         GGG(eee, aaa, bbb, ccc, ddd, block[ 1], 11);
00309         GGG(ddd, eee, aaa, bbb, ccc, block[ 3], 14);
00310         GGG(ccc, ddd, eee, aaa, bbb, block[11], 14);
00311         GGG(bbb, ccc, ddd, eee, aaa, block[15],  6);
00312         GGG(aaa, bbb, ccc, ddd, eee, block[ 0], 14);
00313         GGG(eee, aaa, bbb, ccc, ddd, block[ 5],  6);
00314         GGG(ddd, eee, aaa, bbb, ccc, block[12],  9);
00315         GGG(ccc, ddd, eee, aaa, bbb, block[ 2], 12);
00316         GGG(bbb, ccc, ddd, eee, aaa, block[13],  9);
00317         GGG(aaa, bbb, ccc, ddd, eee, block[ 9], 12);
00318         GGG(eee, aaa, bbb, ccc, ddd, block[ 7],  5);
00319         GGG(ddd, eee, aaa, bbb, ccc, block[10], 15);
00320         GGG(ccc, ddd, eee, aaa, bbb, block[14],  8);
00321 
00322         /* parallel round 5 */
00323         FFF(bbb, ccc, ddd, eee, aaa, block[12] ,  8);
00324         FFF(aaa, bbb, ccc, ddd, eee, block[15] ,  5);
00325         FFF(eee, aaa, bbb, ccc, ddd, block[10] , 12);
00326         FFF(ddd, eee, aaa, bbb, ccc, block[ 4] ,  9);
00327         FFF(ccc, ddd, eee, aaa, bbb, block[ 1] , 12);
00328         FFF(bbb, ccc, ddd, eee, aaa, block[ 5] ,  5);
00329         FFF(aaa, bbb, ccc, ddd, eee, block[ 8] , 14);
00330         FFF(eee, aaa, bbb, ccc, ddd, block[ 7] ,  6);
00331         FFF(ddd, eee, aaa, bbb, ccc, block[ 6] ,  8);
00332         FFF(ccc, ddd, eee, aaa, bbb, block[ 2] , 13);
00333         FFF(bbb, ccc, ddd, eee, aaa, block[13] ,  6);
00334         FFF(aaa, bbb, ccc, ddd, eee, block[14] ,  5);
00335         FFF(eee, aaa, bbb, ccc, ddd, block[ 0] , 15);
00336         FFF(ddd, eee, aaa, bbb, ccc, block[ 3] , 13);
00337         FFF(ccc, ddd, eee, aaa, bbb, block[ 9] , 11);
00338         FFF(bbb, ccc, ddd, eee, aaa, block[11] , 11);
00339 
00340         /* combine results */
00341         ddd += cc + state[1];           /* final result for state[0] */
00342         state[1] = state[2] + dd + eee;
00343         state[2] = state[3] + ee + aaa;
00344         state[3] = state[4] + aa + bbb;
00345         state[4] = state[0] + bb + ccc;
00346         state[0] = ddd;
00347 }
00348 
00349 /********************************************************************/
00350 
00351 void
00352 RMD160_Update(RMD160_CTX *context, const uint8_t *data, size_t nbytes)
00353 {
00354         uint32_t X[16];
00355         uint32_t ofs = 0;
00356         uint32_t i;
00357 #ifdef WORDS_BIGENDIAN
00358         uint32_t j;
00359 #endif
00360 
00361         _DIAGASSERT(context != NULL);
00362         _DIAGASSERT(data != NULL);
00363 
00364         /* update length[] */
00365         if (context->length[0] + nbytes < context->length[0])
00366                 context->length[1]++;           /* overflow to msb of length */
00367         context->length[0] += nbytes;
00368 
00369         (void)memset(X, 0, sizeof(X));
00370 
00371         if ( context->buflen + nbytes < 64 )
00372         {
00373                 (void)memcpy(context->bbuffer + context->buflen, data, nbytes);
00374                 context->buflen += nbytes;
00375         }
00376         else
00377         {
00378                 /* process first block */
00379                 ofs = 64 - context->buflen;
00380                 (void)memcpy(context->bbuffer + context->buflen, data, ofs);
00381 #ifndef WORDS_BIGENDIAN
00382                 (void)memcpy(X, context->bbuffer, sizeof(X));
00383 #else
00384                 for (j=0; j < 16; j++)
00385                         X[j] = BYTES_TO_DWORD(context->bbuffer + (4 * j));
00386 #endif
00387                 RMD160_Transform(context->state, X);
00388                 nbytes -= ofs;
00389 
00390                 /* process remaining complete blocks */
00391                 for (i = 0; i < (nbytes >> 6); i++) {
00392 #ifndef WORDS_BIGENDIAN
00393                         (void)memcpy(X, data + (64 * i) + ofs, sizeof(X));
00394 #else
00395                         for (j=0; j < 16; j++)
00396                                 X[j] = BYTES_TO_DWORD(data + (64 * i) + (4 * j) + ofs);
00397 #endif
00398                         RMD160_Transform(context->state, X);
00399                 }
00400 
00401                 /*
00402                  * Put last bytes from data into context's buffer
00403                  */
00404                 context->buflen = nbytes & 63;
00405                 memcpy(context->bbuffer, data + (64 * i) + ofs, context->buflen);
00406         }
00407 }
00408 
00409 /********************************************************************/
00410 
00411 void
00412 RMD160_Finish(RMD160_CTX *context, uint8_t digest[20])
00413 {
00414         uint32_t i;
00415         uint32_t X[16];
00416 #ifdef WORDS_BIGENDIAN
00417         uint32_t j;
00418 #endif
00419 
00420         _DIAGASSERT(digest != NULL);
00421         _DIAGASSERT(context != NULL);
00422 
00423         /* append the bit m_n == 1 */
00424         context->bbuffer[context->buflen] = (uint8_t)'\200';
00425 
00426         (void)memset(context->bbuffer + context->buflen + 1, 0,
00427                 63 - context->buflen);
00428 #ifndef WORDS_BIGENDIAN
00429         (void)memcpy(X, context->bbuffer, sizeof(X));
00430 #else
00431         for (j=0; j < 16; j++)
00432                 X[j] = BYTES_TO_DWORD(context->bbuffer + (4 * j));
00433 #endif
00434         if ((context->buflen) > 55) {
00435                 /* length goes to next block */
00436                 RMD160_Transform(context->state, X);
00437                 (void)memset(X, 0, sizeof(X));
00438         }
00439 
00440         /* append length in bits */
00441         X[14] = context->length[0] << 3;
00442         X[15] = (context->length[0] >> 29) |
00443             (context->length[1] << 3);
00444         RMD160_Transform(context->state, X);
00445 
00446         if (digest != NULL) {
00447                 for (i = 0; i < 20; i += 4) {
00448                         /* extracts the 8 least significant bits. */
00449                         digest[i]     =  context->state[i>>2];
00450                         digest[i + 1] = (context->state[i>>2] >>  8);
00451                         digest[i + 2] = (context->state[i>>2] >> 16);
00452                         digest[i + 3] = (context->state[i>>2] >> 24);
00453                 }
00454         }
00455 }
00456 
00457 /************************ end of file rmd160.c **********************/
00458 

Generated on Thu Sep 8 2011 03:50:29 for Ruby by  doxygen 1.7.1