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
 153         void MDinit(dword *MDbuf, unsigned int* key)
 154         {
 155                 if (key)
 156                 {
 157                         MDbuf[0] = key[0];
 158                         MDbuf[1] = key[1];
 159                         MDbuf[2] = key[2];
 160                         MDbuf[3] = key[3];
 161                         MDbuf[4] = key[4];
 162                 }
 163                 else
 164                 {
 165                         MDbuf[0] = 0x67452301UL;
 166                         MDbuf[1] = 0xefcdab89UL;
 167                         MDbuf[2] = 0x98badcfeUL;
 168                         MDbuf[3] = 0x10325476UL;
 169                         MDbuf[4] = 0xc3d2e1f0UL;
 170                 }
 171                 return;
 172         }
 173
 174
 175         void compress(dword *MDbuf, dword *X)
 176         {
 177                 dword aa = MDbuf[0],  bb = MDbuf[1],  cc = MDbuf[2],
 178                         dd = MDbuf[3],  ee = MDbuf[4];
 179                 dword aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2],
 180                         ddd = MDbuf[3], eee = MDbuf[4];
 181
 182                 /* round 1 */
 183                 FF(aa, bb, cc, dd, ee, X[ 0], 11);
 184                 FF(ee, aa, bb, cc, dd, X[ 1], 14);
 185                 FF(dd, ee, aa, bb, cc, X[ 2], 15);
 186                 FF(cc, dd, ee, aa, bb, X[ 3], 12);
 187                 FF(bb, cc, dd, ee, aa, X[ 4],  5);
 188                 FF(aa, bb, cc, dd, ee, X[ 5],  8);
 189                 FF(ee, aa, bb, cc, dd, X[ 6],  7);
 190                 FF(dd, ee, aa, bb, cc, X[ 7],  9);
 191                 FF(cc, dd, ee, aa, bb, X[ 8], 11);
 192                 FF(bb, cc, dd, ee, aa, X[ 9], 13);
 193                 FF(aa, bb, cc, dd, ee, X[10], 14);
 194                 FF(ee, aa, bb, cc, dd, X[11], 15);
 195                 FF(dd, ee, aa, bb, cc, X[12],  6);
 196                 FF(cc, dd, ee, aa, bb, X[13],  7);
 197                 FF(bb, cc, dd, ee, aa, X[14],  9);
 198                 FF(aa, bb, cc, dd, ee, X[15],  8);
 199
 200                 /* round 2 */
 201                 GG(ee, aa, bb, cc, dd, X[ 7],  7);
 202                 GG(dd, ee, aa, bb, cc, X[ 4],  6);
 203                 GG(cc, dd, ee, aa, bb, X[13],  8);
 204                 GG(bb, cc, dd, ee, aa, X[ 1], 13);
 205                 GG(aa, bb, cc, dd, ee, X[10], 11);
 206                 GG(ee, aa, bb, cc, dd, X[ 6],  9);
 207                 GG(dd, ee, aa, bb, cc, X[15],  7);
 208                 GG(cc, dd, ee, aa, bb, X[ 3], 15);
 209                 GG(bb, cc, dd, ee, aa, X[12],  7);
 210                 GG(aa, bb, cc, dd, ee, X[ 0], 12);
 211                 GG(ee, aa, bb, cc, dd, X[ 9], 15);
 212                 GG(dd, ee, aa, bb, cc, X[ 5],  9);
 213                 GG(cc, dd, ee, aa, bb, X[ 2], 11);
 214                 GG(bb, cc, dd, ee, aa, X[14],  7);
 215                 GG(aa, bb, cc, dd, ee, X[11], 13);
 216                 GG(ee, aa, bb, cc, dd, X[ 8], 12);
 217
 218                 /* round 3 */
 219                 HH(dd, ee, aa, bb, cc, X[ 3], 11);
 220                 HH(cc, dd, ee, aa, bb, X[10], 13);
 221                 HH(bb, cc, dd, ee, aa, X[14],  6);
 222                 HH(aa, bb, cc, dd, ee, X[ 4],  7);
 223                 HH(ee, aa, bb, cc, dd, X[ 9], 14);
 224                 HH(dd, ee, aa, bb, cc, X[15],  9);
 225                 HH(cc, dd, ee, aa, bb, X[ 8], 13);
 226                 HH(bb, cc, dd, ee, aa, X[ 1], 15);
 227                 HH(aa, bb, cc, dd, ee, X[ 2], 14);
 228                 HH(ee, aa, bb, cc, dd, X[ 7],  8);
 229                 HH(dd, ee, aa, bb, cc, X[ 0], 13);
 230                 HH(cc, dd, ee, aa, bb, X[ 6],  6);
 231                 HH(bb, cc, dd, ee, aa, X[13],  5);
 232                 HH(aa, bb, cc, dd, ee, X[11], 12);
 233                 HH(ee, aa, bb, cc, dd, X[ 5],  7);
 234                 HH(dd, ee, aa, bb, cc, X[12],  5);
 235
 236                 /* round 4 */
 237                 II(cc, dd, ee, aa, bb, X[ 1], 11);
 238                 II(bb, cc, dd, ee, aa, X[ 9], 12);
 239                 II(aa, bb, cc, dd, ee, X[11], 14);
 240                 II(ee, aa, bb, cc, dd, X[10], 15);
 241                 II(dd, ee, aa, bb, cc, X[ 0], 14);
 242                 II(cc, dd, ee, aa, bb, X[ 8], 15);
 243                 II(bb, cc, dd, ee, aa, X[12],  9);
 244                 II(aa, bb, cc, dd, ee, X[ 4],  8);
 245                 II(ee, aa, bb, cc, dd, X[13],  9);
 246                 II(dd, ee, aa, bb, cc, X[ 3], 14);
 247                 II(cc, dd, ee, aa, bb, X[ 7],  5);
 248                 II(bb, cc, dd, ee, aa, X[15],  6);
 249                 II(aa, bb, cc, dd, ee, X[14],  8);
 250                 II(ee, aa, bb, cc, dd, X[ 5],  6);
 251                 II(dd, ee, aa, bb, cc, X[ 6],  5);
 252                 II(cc, dd, ee, aa, bb, X[ 2], 12);
 253
 254                 /* round 5 */
 255                 JJ(bb, cc, dd, ee, aa, X[ 4],  9);
 256                 JJ(aa, bb, cc, dd, ee, X[ 0], 15);
 257                 JJ(ee, aa, bb, cc, dd, X[ 5],  5);
 258                 JJ(dd, ee, aa, bb, cc, X[ 9], 11);
 259                 JJ(cc, dd, ee, aa, bb, X[ 7],  6);
 260                 JJ(bb, cc, dd, ee, aa, X[12],  8);
 261                 JJ(aa, bb, cc, dd, ee, X[ 2], 13);
 262                 JJ(ee, aa, bb, cc, dd, X[10], 12);
 263                 JJ(dd, ee, aa, bb, cc, X[14],  5);
 264                 JJ(cc, dd, ee, aa, bb, X[ 1], 12);
 265                 JJ(bb, cc, dd, ee, aa, X[ 3], 13);
 266                 JJ(aa, bb, cc, dd, ee, X[ 8], 14);
 267                 JJ(ee, aa, bb, cc, dd, X[11], 11);
 268                 JJ(dd, ee, aa, bb, cc, X[ 6],  8);
 269                 JJ(cc, dd, ee, aa, bb, X[15],  5);
 270                 JJ(bb, cc, dd, ee, aa, X[13],  6);
 271
 272                 /* parallel round 1 */
 273                 JJJ(aaa, bbb, ccc, ddd, eee, X[ 5],  8);
 274                 JJJ(eee, aaa, bbb, ccc, ddd, X[14],  9);
 275                 JJJ(ddd, eee, aaa, bbb, ccc, X[ 7],  9);
 276                 JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
 277                 JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
 278                 JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
 279                 JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15);
 280                 JJJ(ddd, eee, aaa, bbb, ccc, X[ 4],  5);
 281                 JJJ(ccc, ddd, eee, aaa, bbb, X[13],  7);
 282                 JJJ(bbb, ccc, ddd, eee, aaa, X[ 6],  7);
 283                 JJJ(aaa, bbb, ccc, ddd, eee, X[15],  8);
 284                 JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
 285                 JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
 286                 JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14);
 287                 JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
 288                 JJJ(aaa, bbb, ccc, ddd, eee, X[12],  6);
 289
 290                 /* parallel round 2 */
 291                 III(eee, aaa, bbb, ccc, ddd, X[ 6],  9);
 292                 III(ddd, eee, aaa, bbb, ccc, X[11], 13);
 293                 III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
 294                 III(bbb, ccc, ddd, eee, aaa, X[ 7],  7);
 295                 III(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
 296                 III(eee, aaa, bbb, ccc, ddd, X[13],  8);
 297                 III(ddd, eee, aaa, bbb, ccc, X[ 5],  9);
 298                 III(ccc, ddd, eee, aaa, bbb, X[10], 11);
 299                 III(bbb, ccc, ddd, eee, aaa, X[14],  7);
 300                 III(aaa, bbb, ccc, ddd, eee, X[15],  7);
 301                 III(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
 302                 III(ddd, eee, aaa, bbb, ccc, X[12],  7);
 303                 III(ccc, ddd, eee, aaa, bbb, X[ 4],  6);
 304                 III(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
 305                 III(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
 306                 III(eee, aaa, bbb, ccc, ddd, X[ 2], 11);
 307
 308                 /* parallel round 3 */
 309                 HHH(ddd, eee, aaa, bbb, ccc, X[15],  9);
 310                 HHH(ccc, ddd, eee, aaa, bbb, X[ 5],  7);
 311                 HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
 312                 HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
 313                 HHH(eee, aaa, bbb, ccc, ddd, X[ 7],  8);
 314                 HHH(ddd, eee, aaa, bbb, ccc, X[14],  6);
 315                 HHH(ccc, ddd, eee, aaa, bbb, X[ 6],  6);
 316                 HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
 317                 HHH(aaa, bbb, ccc, ddd, eee, X[11], 12);
 318                 HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
 319                 HHH(ddd, eee, aaa, bbb, ccc, X[12],  5);
 320                 HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
 321                 HHH(bbb, ccc, ddd, eee, aaa, X[10], 13);
 322                 HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
 323                 HHH(eee, aaa, bbb, ccc, ddd, X[ 4],  7);
 324                 HHH(ddd, eee, aaa, bbb, ccc, X[13],  5);
 325
 326                 /* parallel round 4 */
 327                 GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
 328                 GGG(bbb, ccc, ddd, eee, aaa, X[ 6],  5);
 329                 GGG(aaa, bbb, ccc, ddd, eee, X[ 4],  8);
 330                 GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
 331                 GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
 332                 GGG(ccc, ddd, eee, aaa, bbb, X[11], 14);
 333                 GGG(bbb, ccc, ddd, eee, aaa, X[15],  6);
 334                 GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
 335                 GGG(eee, aaa, bbb, ccc, ddd, X[ 5],  6);
 336                 GGG(ddd, eee, aaa, bbb, ccc, X[12],  9);
 337                 GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
 338                 GGG(bbb, ccc, ddd, eee, aaa, X[13],  9);
 339                 GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
 340                 GGG(eee, aaa, bbb, ccc, ddd, X[ 7],  5);
 341                 GGG(ddd, eee, aaa, bbb, ccc, X[10], 15);
 342                 GGG(ccc, ddd, eee, aaa, bbb, X[14],  8);
 343
 344                 /* parallel round 5 */
 345                 FFF(bbb, ccc, ddd, eee, aaa, X[12] ,  8);
 346                 FFF(aaa, bbb, ccc, ddd, eee, X[15] ,  5);
 347                 FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12);
 348                 FFF(ddd, eee, aaa, bbb, ccc, X[ 4] ,  9);
 349                 FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
 350                 FFF(bbb, ccc, ddd, eee, aaa, X[ 5] ,  5);
 351                 FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
 352                 FFF(eee, aaa, bbb, ccc, ddd, X[ 7] ,  6);
 353                 FFF(ddd, eee, aaa, bbb, ccc, X[ 6] ,  8);
 354                 FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
 355                 FFF(bbb, ccc, ddd, eee, aaa, X[13] ,  6);
 356                 FFF(aaa, bbb, ccc, ddd, eee, X[14] ,  5);
 357                 FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
 358                 FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
 359                 FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
 360                 FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11);
 361
 362                 /* combine results */
 363                 ddd += cc + MDbuf[1];               /* final result for MDbuf[0] */
 364                 MDbuf[1] = MDbuf[2] + dd + eee;
 365                 MDbuf[2] = MDbuf[3] + ee + aaa;
 366                 MDbuf[3] = MDbuf[4] + aa + bbb;
 367                 MDbuf[4] = MDbuf[0] + bb + ccc;
 368                 MDbuf[0] = ddd;
 369
 370                 return;
 371         }
 372
 373         void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen)
 374         {
 375                 unsigned int i;                                 /* counter       */
 376                 dword        X[16];                             /* message words */
 377
 378                 memset(X, 0, sizeof(X));
 379
 380                 /* put bytes from strptr into X */
 381                 for (i=0; i<(lswlen&63); i++) {
 382                         /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
 383                         X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
 384                 }
 385
 386                 /* append the bit m_n == 1 */
 387                 X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);
 388
 389                 if ((lswlen & 63) > 55) {
 390                         /* length goes to next block */
 391                         compress(MDbuf, X);
 392                         memset(X, 0, sizeof(X));
 393                 }
 394
 395                 /* append length in bits*/
 396                 X[14] = lswlen << 3;
 397                 X[15] = (lswlen >> 29) | (mswlen << 3);
 398                 compress(MDbuf, X);
 399
 400                 return;
 401         }
 402
 403         byte *RMD(byte *message, dword length, unsigned int* key)
 404         {
 405                 dword         MDbuf[RMDsize/32];   /* contains (A, B, C, D(E))   */
 406                 static byte   hashcode[RMDsize/8]; /* for final hash-value         */
 407                 dword         X[16];               /* current 16-word chunk        */
 408                 unsigned int  i;                   /* counter                      */
 409                 dword         nbytes;              /* # of bytes not yet processed */
 410
 411                 /* initialize */
 412                 MDinit(MDbuf, key);
 413
 414                 /* process message in 16-word chunks */
 415                 for (nbytes=length; nbytes > 63; nbytes-=64) {
 416                         for (i=0; i<16; i++) {
 417                                 X[i] = BYTES_TO_DWORD(message);
 418                                 message += 4;
 419                         }
 420                         compress(MDbuf, X);
 421                 }                                    /* length mod 64 bytes left */
 422
 423                 MDfinish(MDbuf, message, length, 0);
 424
 425                 for (i=0; i<RMDsize/8; i+=4) {
 426                         hashcode[i]   =  MDbuf[i>>2];         /* implicit cast to byte  */
 427                         hashcode[i+1] = (MDbuf[i>>2] >>  8);  /*  extracts the 8 least  */
 428                         hashcode[i+2] = (MDbuf[i>>2] >> 16);  /*  significant bits.     */
 429                         hashcode[i+3] = (MDbuf[i>>2] >> 24);
 430                 }
 431
 432                 return (byte *)hashcode;
 433         }
 434 public:
 435         std::string sum(const std::string& data)
 436         {
 437                 char* rv = (char*)RMD((byte*)data.data(), data.length(), NULL);
 438                 return std::string(rv, RMDsize / 8);
 439         }
 440
 441         RIProv(Module* m) : HashProvider(m, "hash/ripemd160", 20, 64) {}
 442 };
 443
 444 class ModuleRIPEMD160 : public Module
 445 {
 446  public:
 447         RIProv mr;
 448         ModuleRIPEMD160() : mr(this)
 449         {
 450                 ServerInstance->Modules->AddService(mr);
 451         }
 452
 453         Version GetVersion() CXX11_OVERRIDE
 454         {
 455                 return Version("Provides RIPEMD-160 hashing", VF_VENDOR);
 456         }
 457 };
 458
 459 MODULE_INIT(ModuleRIPEMD160)