src/modules/m_ripemd160.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2008 Pippijn van Steenhoven <pip88nl@gmail.com>
   6  *   Copyright (C) 2008 Craig Edwards <craigedwards@brainbox.cc>
   7  *   Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net>
   8  *
   9  * This file is part of InspIRCd.  InspIRCd is free software: you can
  10  * redistribute it and/or modify it under the terms of the GNU General Public
  11  * License as published by the Free Software Foundation, version 2.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22
  23 /*
  24  *
  25  *      AUTHOR:   Antoon Bosselaers, ESAT-COSIC
  26  *      DATE:     1 March 1996
  27  *      VERSION:  1.0
  28  *
  29  *      Copyright (c) Katholieke Universiteit Leuven
  30  *      1996, All Rights Reserved
  31  *
  32  *  Conditions for use of the RIPEMD-160 Software
  33  *
  34  *  The RIPEMD-160 software is freely available for use under the terms and
  35  *  conditions described hereunder, which shall be deemed to be accepted by
  36  *  any user of the software and applicable on any use of the software:
  37  *
  38  *  1. K.U.Leuven Department of Electrical Engineering-ESAT/COSIC shall for
  39  *     all purposes be considered the owner of the RIPEMD-160 software and of
  40  *     all copyright, trade secret, patent or other intellectual property
  41  *     rights therein.
  42  *  2. The RIPEMD-160 software is provided on an "as is" basis without
  43  *     warranty of any sort, express or implied. K.U.Leuven makes no
  44  *     representation that the use of the software will not infringe any
  45  *     patent or proprietary right of third parties. User will indemnify
  46  *     K.U.Leuven and hold K.U.Leuven harmless from any claims or liabilities
  47  *     which may arise as a result of its use of the software. In no
  48  *     circumstances K.U.Leuven R&D will be held liable for any deficiency,
  49  *     fault or other mishappening with regard to the use or performance of
  50  *     the software.
  51  *  3. User agrees to give due credit to K.U.Leuven in scientific publications
  52  *     or communications in relation with the use of the RIPEMD-160 software
  53  *     as follows: RIPEMD-160 software written by Antoon Bosselaers,
  54  *     available at http://www.esat.kuleuven.be/~cosicart/ps/AB-9601/.
  55  *
  56  */
  57
  58
  59 /* macro definitions */
  60
  61 #include "inspircd.h"
  62 #include "modules/hash.h"
  63
  64 #define RMDsize 160
  65
  66 typedef uint8_t byte;
  67 typedef uint32_t dword;
  68
  69 /* collect four bytes into one word: */
  70 #define BYTES_TO_DWORD(strptr)                    \
  71             (((dword) *((strptr)+3) << 24) | \
  72              ((dword) *((strptr)+2) << 16) | \
  73              ((dword) *((strptr)+1) <<  8) | \
  74              ((dword) *(strptr)))
  75
  76 /* ROL(x, n) cyclically rotates x over n bits to the left */
  77 /* x must be of an unsigned 32 bits type and 0 <= n < 32. */
  78 #define ROL(x, n)        (((x) << (n)) | ((x) >> (32-(n))))
  79
  80 /* the five basic functions F(), G() and H() */
  81 #define F(x, y, z)        ((x) ^ (y) ^ (z))
  82 #define G(x, y, z)        (((x) & (y)) | (~(x) & (z)))
  83 #define H(x, y, z)        (((x) | ~(y)) ^ (z))
  84 #define I(x, y, z)        (((x) & (z)) | ((y) & ~(z)))
  85 #define J(x, y, z)        ((x) ^ ((y) | ~(z)))
  86
  87 /* the ten basic operations FF() through III() */
  88
  89 #define FF(a, b, c, d, e, x, s)        {\
  90       (a) += F((b), (c), (d)) + (x);\
  91       (a) = ROL((a), (s)) + (e);\
  92       (c) = ROL((c), 10);\
  93    }
  94
  95 #define GG(a, b, c, d, e, x, s)        {\
  96       (a) += G((b), (c), (d)) + (x) + 0x5a827999UL;\
  97       (a) = ROL((a), (s)) + (e);\
  98       (c) = ROL((c), 10);\
  99    }
 100
 101 #define HH(a, b, c, d, e, x, s)        {\
 102       (a) += H((b), (c), (d)) + (x) + 0x6ed9eba1UL;\
 103       (a) = ROL((a), (s)) + (e);\
 104       (c) = ROL((c), 10);\
 105    }
 106
 107 #define II(a, b, c, d, e, x, s)        {\
 108       (a) += I((b), (c), (d)) + (x) + 0x8f1bbcdcUL;\
 109       (a) = ROL((a), (s)) + (e);\
 110       (c) = ROL((c), 10);\
 111    }
 112
 113 #define JJ(a, b, c, d, e, x, s)        {\
 114       (a) += J((b), (c), (d)) + (x) + 0xa953fd4eUL;\
 115       (a) = ROL((a), (s)) + (e);\
 116       (c) = ROL((c), 10);\
 117    }
 118
 119 #define FFF(a, b, c, d, e, x, s)        {\
 120       (a) += F((b), (c), (d)) + (x);\
 121       (a) = ROL((a), (s)) + (e);\
 122       (c) = ROL((c), 10);\
 123    }
 124
 125 #define GGG(a, b, c, d, e, x, s)        {\
 126       (a) += G((b), (c), (d)) + (x) + 0x7a6d76e9UL;\
 127       (a) = ROL((a), (s)) + (e);\
 128       (c) = ROL((c), 10);\
 129    }
 130
 131 #define HHH(a, b, c, d, e, x, s)        {\
 132       (a) += H((b), (c), (d)) + (x) + 0x6d703ef3UL;\
 133       (a) = ROL((a), (s)) + (e);\
 134       (c) = ROL((c), 10);\
 135    }
 136
 137 #define III(a, b, c, d, e, x, s)        {\
 138       (a) += I((b), (c), (d)) + (x) + 0x5c4dd124UL;\
 139       (a) = ROL((a), (s)) + (e);\
 140       (c) = ROL((c), 10);\
 141    }
 142
 143 #define JJJ(a, b, c, d, e, x, s)        {\
 144       (a) += J((b), (c), (d)) + (x) + 0x50a28be6UL;\
 145       (a) = ROL((a), (s)) + (e);\
 146       (c) = ROL((c), 10);\
 147    }
 148
 149
 150 class RIProv : public HashProvider
 151 {
 152         /** Final hash value
 153          */
 154         byte hashcode[RMDsize/8];
 155
 156         void MDinit(dword *MDbuf, unsigned int* key)
 157         {
 158                 if (key)
 159                 {
 160                         MDbuf[0] = key[0];
 161                         MDbuf[1] = key[1];
 162                         MDbuf[2] = key[2];
 163                         MDbuf[3] = key[3];
 164                         MDbuf[4] = key[4];
 165                 }
 166                 else
 167                 {
 168                         MDbuf[0] = 0x67452301UL;
 169                         MDbuf[1] = 0xefcdab89UL;
 170                         MDbuf[2] = 0x98badcfeUL;
 171                         MDbuf[3] = 0x10325476UL;
 172                         MDbuf[4] = 0xc3d2e1f0UL;
 173                 }
 174                 return;
 175         }
 176
 177
 178         void compress(dword *MDbuf, dword *X)
 179         {
 180                 dword aa = MDbuf[0],  bb = MDbuf[1],  cc = MDbuf[2],
 181                         dd = MDbuf[3],  ee = MDbuf[4];
 182                 dword aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2],
 183                         ddd = MDbuf[3], eee = MDbuf[4];
 184
 185                 /* round 1 */
 186                 FF(aa, bb, cc, dd, ee, X[ 0], 11);
 187                 FF(ee, aa, bb, cc, dd, X[ 1], 14);
 188                 FF(dd, ee, aa, bb, cc, X[ 2], 15);
 189                 FF(cc, dd, ee, aa, bb, X[ 3], 12);
 190                 FF(bb, cc, dd, ee, aa, X[ 4],  5);
 191                 FF(aa, bb, cc, dd, ee, X[ 5],  8);
 192                 FF(ee, aa, bb, cc, dd, X[ 6],  7);
 193                 FF(dd, ee, aa, bb, cc, X[ 7],  9);
 194                 FF(cc, dd, ee, aa, bb, X[ 8], 11);
 195                 FF(bb, cc, dd, ee, aa, X[ 9], 13);
 196                 FF(aa, bb, cc, dd, ee, X[10], 14);
 197                 FF(ee, aa, bb, cc, dd, X[11], 15);
 198                 FF(dd, ee, aa, bb, cc, X[12],  6);
 199                 FF(cc, dd, ee, aa, bb, X[13],  7);
 200                 FF(bb, cc, dd, ee, aa, X[14],  9);
 201                 FF(aa, bb, cc, dd, ee, X[15],  8);
 202
 203                 /* round 2 */
 204                 GG(ee, aa, bb, cc, dd, X[ 7],  7);
 205                 GG(dd, ee, aa, bb, cc, X[ 4],  6);
 206                 GG(cc, dd, ee, aa, bb, X[13],  8);
 207                 GG(bb, cc, dd, ee, aa, X[ 1], 13);
 208                 GG(aa, bb, cc, dd, ee, X[10], 11);
 209                 GG(ee, aa, bb, cc, dd, X[ 6],  9);
 210                 GG(dd, ee, aa, bb, cc, X[15],  7);
 211                 GG(cc, dd, ee, aa, bb, X[ 3], 15);
 212                 GG(bb, cc, dd, ee, aa, X[12],  7);
 213                 GG(aa, bb, cc, dd, ee, X[ 0], 12);
 214                 GG(ee, aa, bb, cc, dd, X[ 9], 15);
 215                 GG(dd, ee, aa, bb, cc, X[ 5],  9);
 216                 GG(cc, dd, ee, aa, bb, X[ 2], 11);
 217                 GG(bb, cc, dd, ee, aa, X[14],  7);
 218                 GG(aa, bb, cc, dd, ee, X[11], 13);
 219                 GG(ee, aa, bb, cc, dd, X[ 8], 12);
 220
 221                 /* round 3 */
 222                 HH(dd, ee, aa, bb, cc, X[ 3], 11);
 223                 HH(cc, dd, ee, aa, bb, X[10], 13);
 224                 HH(bb, cc, dd, ee, aa, X[14],  6);
 225                 HH(aa, bb, cc, dd, ee, X[ 4],  7);
 226                 HH(ee, aa, bb, cc, dd, X[ 9], 14);
 227                 HH(dd, ee, aa, bb, cc, X[15],  9);
 228                 HH(cc, dd, ee, aa, bb, X[ 8], 13);
 229                 HH(bb, cc, dd, ee, aa, X[ 1], 15);
 230                 HH(aa, bb, cc, dd, ee, X[ 2], 14);
 231                 HH(ee, aa, bb, cc, dd, X[ 7],  8);
 232                 HH(dd, ee, aa, bb, cc, X[ 0], 13);
 233                 HH(cc, dd, ee, aa, bb, X[ 6],  6);
 234                 HH(bb, cc, dd, ee, aa, X[13],  5);
 235                 HH(aa, bb, cc, dd, ee, X[11], 12);
 236                 HH(ee, aa, bb, cc, dd, X[ 5],  7);
 237                 HH(dd, ee, aa, bb, cc, X[12],  5);
 238
 239                 /* round 4 */
 240                 II(cc, dd, ee, aa, bb, X[ 1], 11);
 241                 II(bb, cc, dd, ee, aa, X[ 9], 12);
 242                 II(aa, bb, cc, dd, ee, X[11], 14);
 243                 II(ee, aa, bb, cc, dd, X[10], 15);
 244                 II(dd, ee, aa, bb, cc, X[ 0], 14);
 245                 II(cc, dd, ee, aa, bb, X[ 8], 15);
 246                 II(bb, cc, dd, ee, aa, X[12],  9);
 247                 II(aa, bb, cc, dd, ee, X[ 4],  8);
 248                 II(ee, aa, bb, cc, dd, X[13],  9);
 249                 II(dd, ee, aa, bb, cc, X[ 3], 14);
 250                 II(cc, dd, ee, aa, bb, X[ 7],  5);
 251                 II(bb, cc, dd, ee, aa, X[15],  6);
 252                 II(aa, bb, cc, dd, ee, X[14],  8);
 253                 II(ee, aa, bb, cc, dd, X[ 5],  6);
 254                 II(dd, ee, aa, bb, cc, X[ 6],  5);
 255                 II(cc, dd, ee, aa, bb, X[ 2], 12);
 256
 257                 /* round 5 */
 258                 JJ(bb, cc, dd, ee, aa, X[ 4],  9);
 259                 JJ(aa, bb, cc, dd, ee, X[ 0], 15);
 260                 JJ(ee, aa, bb, cc, dd, X[ 5],  5);
 261                 JJ(dd, ee, aa, bb, cc, X[ 9], 11);
 262                 JJ(cc, dd, ee, aa, bb, X[ 7],  6);
 263                 JJ(bb, cc, dd, ee, aa, X[12],  8);
 264                 JJ(aa, bb, cc, dd, ee, X[ 2], 13);
 265                 JJ(ee, aa, bb, cc, dd, X[10], 12);
 266                 JJ(dd, ee, aa, bb, cc, X[14],  5);
 267                 JJ(cc, dd, ee, aa, bb, X[ 1], 12);
 268                 JJ(bb, cc, dd, ee, aa, X[ 3], 13);
 269                 JJ(aa, bb, cc, dd, ee, X[ 8], 14);
 270                 JJ(ee, aa, bb, cc, dd, X[11], 11);
 271                 JJ(dd, ee, aa, bb, cc, X[ 6],  8);
 272                 JJ(cc, dd, ee, aa, bb, X[15],  5);
 273                 JJ(bb, cc, dd, ee, aa, X[13],  6);
 274
 275                 /* parallel round 1 */
 276                 JJJ(aaa, bbb, ccc, ddd, eee, X[ 5],  8);
 277                 JJJ(eee, aaa, bbb, ccc, ddd, X[14],  9);
 278                 JJJ(ddd, eee, aaa, bbb, ccc, X[ 7],  9);
 279                 JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
 280                 JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
 281                 JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
 282                 JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15);
 283                 JJJ(ddd, eee, aaa, bbb, ccc, X[ 4],  5);
 284                 JJJ(ccc, ddd, eee, aaa, bbb, X[13],  7);
 285                 JJJ(bbb, ccc, ddd, eee, aaa, X[ 6],  7);
 286                 JJJ(aaa, bbb, ccc, ddd, eee, X[15],  8);
 287                 JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
 288                 JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
 289                 JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14);
 290                 JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
 291                 JJJ(aaa, bbb, ccc, ddd, eee, X[12],  6);
 292
 293                 /* parallel round 2 */
 294                 III(eee, aaa, bbb, ccc, ddd, X[ 6],  9);
 295                 III(ddd, eee, aaa, bbb, ccc, X[11], 13);
 296                 III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
 297                 III(bbb, ccc, ddd, eee, aaa, X[ 7],  7);
 298                 III(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
 299                 III(eee, aaa, bbb, ccc, ddd, X[13],  8);
 300                 III(ddd, eee, aaa, bbb, ccc, X[ 5],  9);
 301                 III(ccc, ddd, eee, aaa, bbb, X[10], 11);
 302                 III(bbb, ccc, ddd, eee, aaa, X[14],  7);
 303                 III(aaa, bbb, ccc, ddd, eee, X[15],  7);
 304                 III(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
 305                 III(ddd, eee, aaa, bbb, ccc, X[12],  7);
 306                 III(ccc, ddd, eee, aaa, bbb, X[ 4],  6);
 307                 III(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
 308                 III(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
 309                 III(eee, aaa, bbb, ccc, ddd, X[ 2], 11);
 310
 311                 /* parallel round 3 */
 312                 HHH(ddd, eee, aaa, bbb, ccc, X[15],  9);
 313                 HHH(ccc, ddd, eee, aaa, bbb, X[ 5],  7);
 314                 HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
 315                 HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
 316                 HHH(eee, aaa, bbb, ccc, ddd, X[ 7],  8);
 317                 HHH(ddd, eee, aaa, bbb, ccc, X[14],  6);
 318                 HHH(ccc, ddd, eee, aaa, bbb, X[ 6],  6);
 319                 HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
 320                 HHH(aaa, bbb, ccc, ddd, eee, X[11], 12);
 321                 HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
 322                 HHH(ddd, eee, aaa, bbb, ccc, X[12],  5);
 323                 HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
 324                 HHH(bbb, ccc, ddd, eee, aaa, X[10], 13);
 325                 HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
 326                 HHH(eee, aaa, bbb, ccc, ddd, X[ 4],  7);
 327                 HHH(ddd, eee, aaa, bbb, ccc, X[13],  5);
 328
 329                 /* parallel round 4 */
 330                 GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
 331                 GGG(bbb, ccc, ddd, eee, aaa, X[ 6],  5);
 332                 GGG(aaa, bbb, ccc, ddd, eee, X[ 4],  8);
 333                 GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
 334                 GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
 335                 GGG(ccc, ddd, eee, aaa, bbb, X[11], 14);
 336                 GGG(bbb, ccc, ddd, eee, aaa, X[15],  6);
 337                 GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
 338                 GGG(eee, aaa, bbb, ccc, ddd, X[ 5],  6);
 339                 GGG(ddd, eee, aaa, bbb, ccc, X[12],  9);
 340                 GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
 341                 GGG(bbb, ccc, ddd, eee, aaa, X[13],  9);
 342                 GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
 343                 GGG(eee, aaa, bbb, ccc, ddd, X[ 7],  5);
 344                 GGG(ddd, eee, aaa, bbb, ccc, X[10], 15);
 345                 GGG(ccc, ddd, eee, aaa, bbb, X[14],  8);
 346
 347                 /* parallel round 5 */
 348                 FFF(bbb, ccc, ddd, eee, aaa, X[12] ,  8);
 349                 FFF(aaa, bbb, ccc, ddd, eee, X[15] ,  5);
 350                 FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12);
 351                 FFF(ddd, eee, aaa, bbb, ccc, X[ 4] ,  9);
 352                 FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
 353                 FFF(bbb, ccc, ddd, eee, aaa, X[ 5] ,  5);
 354                 FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
 355                 FFF(eee, aaa, bbb, ccc, ddd, X[ 7] ,  6);
 356                 FFF(ddd, eee, aaa, bbb, ccc, X[ 6] ,  8);
 357                 FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
 358                 FFF(bbb, ccc, ddd, eee, aaa, X[13] ,  6);
 359                 FFF(aaa, bbb, ccc, ddd, eee, X[14] ,  5);
 360                 FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
 361                 FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
 362                 FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
 363                 FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11);
 364
 365                 /* combine results */
 366                 ddd += cc + MDbuf[1];               /* final result for MDbuf[0] */
 367                 MDbuf[1] = MDbuf[2] + dd + eee;
 368                 MDbuf[2] = MDbuf[3] + ee + aaa;
 369                 MDbuf[3] = MDbuf[4] + aa + bbb;
 370                 MDbuf[4] = MDbuf[0] + bb + ccc;
 371                 MDbuf[0] = ddd;
 372
 373                 return;
 374         }
 375
 376         void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen)
 377         {
 378                 unsigned int i;                                 /* counter       */
 379                 dword        X[16];                             /* message words */
 380
 381                 memset(X, 0, sizeof(X));
 382
 383                 /* put bytes from strptr into X */
 384                 for (i=0; i<(lswlen&63); i++) {
 385                         /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
 386                         X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
 387                 }
 388
 389                 /* append the bit m_n == 1 */
 390                 X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);
 391
 392                 if ((lswlen & 63) > 55) {
 393                         /* length goes to next block */
 394                         compress(MDbuf, X);
 395                         memset(X, 0, sizeof(X));
 396                 }
 397
 398                 /* append length in bits*/
 399                 X[14] = lswlen << 3;
 400                 X[15] = (lswlen >> 29) | (mswlen << 3);
 401                 compress(MDbuf, X);
 402
 403                 return;
 404         }
 405
 406         byte *RMD(byte *message, dword length, unsigned int* key)
 407         {
 408                 dword         MDbuf[RMDsize/32];   /* contains (A, B, C, D(E))   */
 409                 dword         X[16];               /* current 16-word chunk        */
 410                 unsigned int  i;                   /* counter                      */
 411                 dword         nbytes;              /* # of bytes not yet processed */
 412
 413                 /* initialize */
 414                 MDinit(MDbuf, key);
 415
 416                 /* process message in 16-word chunks */
 417                 for (nbytes=length; nbytes > 63; nbytes-=64) {
 418                         for (i=0; i<16; i++) {
 419                                 X[i] = BYTES_TO_DWORD(message);
 420                                 message += 4;
 421                         }
 422                         compress(MDbuf, X);
 423                 }                                    /* length mod 64 bytes left */
 424
 425                 MDfinish(MDbuf, message, length, 0);
 426
 427                 for (i=0; i<RMDsize/8; i+=4) {
 428                         hashcode[i]   =  MDbuf[i>>2];         /* implicit cast to byte  */
 429                         hashcode[i+1] = (MDbuf[i>>2] >>  8);  /*  extracts the 8 least  */
 430                         hashcode[i+2] = (MDbuf[i>>2] >> 16);  /*  significant bits.     */
 431                         hashcode[i+3] = (MDbuf[i>>2] >> 24);
 432                 }
 433
 434                 return (byte *)hashcode;
 435         }
 436 public:
 437         std::string GenerateRaw(const std::string& data) CXX11_OVERRIDE
 438         {
 439                 char* rv = (char*)RMD((byte*)data.data(), data.length(), NULL);
 440                 return std::string(rv, RMDsize / 8);
 441         }
 442
 443         RIProv(Module* m) : HashProvider(m, "ripemd160", 20, 64) {}
 444 };
 445
 446 class ModuleRIPEMD160 : public Module
 447 {
 448  public:
 449         RIProv mr;
 450         ModuleRIPEMD160() : mr(this)
 451         {
 452         }
 453
 454         Version GetVersion() CXX11_OVERRIDE
 455         {
 456                 return Version("Provides RIPEMD-160 hashing", VF_VENDOR);
 457         }
 458 };
 459
 460 MODULE_INIT(ModuleRIPEMD160)