ext/hash/hash_ripemd.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
PHP_RIPEMD128Init
PHP_RIPEMD256Init
PHP_RIPEMD160Init
PHP_RIPEMD320Init
RIPEMDDecode
RIPEMD128Transform
PHP_RIPEMD128Update
RIPEMD256Transform
PHP_RIPEMD256Update
RIPEMD160Transform
PHP_RIPEMD160Update
RIPEMD320Transform
PHP_RIPEMD320Update
RIPEMDEncode
PHP_RIPEMD128Final
PHP_RIPEMD256Final
PHP_RIPEMD160Final
PHP_RIPEMD320Final
   1 /*
   2   +----------------------------------------------------------------------+
   3   | PHP Version 7                                                        |
   4   +----------------------------------------------------------------------+
   5   | Copyright (c) 1997-2016 The PHP Group                                |
   6   +----------------------------------------------------------------------+
   7   | This source file is subject to version 3.01 of the PHP license,      |
   8   | that is bundled with this package in the file LICENSE, and is        |
   9   | available through the world-wide-web at the following url:           |
  10   | http://www.php.net/license/3_01.txt                                  |
  11   | If you did not receive a copy of the PHP license and are unable to   |
  12   | obtain it through the world-wide-web, please send a note to          |
  13   | license@php.net so we can mail you a copy immediately.               |
  14   +----------------------------------------------------------------------+
  15   | Author: Sara Golemon <pollita@php.net>                               |
  16   +----------------------------------------------------------------------+
  17 */
  18 
  19 /* $Id$ */
  20 
  21 /* Heavily borrowed from md5.c & sha1.c of PHP archival fame
  22    Note that ripemd laughs in the face of logic and uses
  23    little endian byte ordering */
  24 
  25 #include "php_hash.h"
  26 #include "php_hash_ripemd.h"
  27 
  28 const php_hash_ops php_hash_ripemd128_ops = {
  29         (php_hash_init_func_t) PHP_RIPEMD128Init,
  30         (php_hash_update_func_t) PHP_RIPEMD128Update,
  31         (php_hash_final_func_t) PHP_RIPEMD128Final,
  32         (php_hash_copy_func_t) php_hash_copy,
  33         16,
  34         64,
  35         sizeof(PHP_RIPEMD128_CTX)
  36 };
  37 
  38 const php_hash_ops php_hash_ripemd160_ops = {
  39         (php_hash_init_func_t) PHP_RIPEMD160Init,
  40         (php_hash_update_func_t) PHP_RIPEMD160Update,
  41         (php_hash_final_func_t) PHP_RIPEMD160Final,
  42         (php_hash_copy_func_t) php_hash_copy,
  43         20,
  44         64,
  45         sizeof(PHP_RIPEMD160_CTX)
  46 };
  47 
  48 const php_hash_ops php_hash_ripemd256_ops = {
  49         (php_hash_init_func_t) PHP_RIPEMD256Init,
  50         (php_hash_update_func_t) PHP_RIPEMD256Update,
  51         (php_hash_final_func_t) PHP_RIPEMD256Final,
  52         (php_hash_copy_func_t) php_hash_copy,
  53         32,
  54         64,
  55         sizeof(PHP_RIPEMD256_CTX)
  56 };
  57 
  58 const php_hash_ops php_hash_ripemd320_ops = {
  59         (php_hash_init_func_t) PHP_RIPEMD320Init,
  60         (php_hash_update_func_t) PHP_RIPEMD320Update,
  61         (php_hash_final_func_t) PHP_RIPEMD320Final,
  62         (php_hash_copy_func_t) php_hash_copy,
  63         40,
  64         64,
  65         sizeof(PHP_RIPEMD320_CTX)
  66 };
  67 
  68 /* {{{ PHP_RIPEMD128Init
  69  * ripemd128 initialization. Begins a ripemd128 operation, writing a new context.
  70  */
  71 PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX * context)
  72 {
  73         context->count[0] = context->count[1] = 0;
  74         /* Load magic initialization constants.
  75          */
  76         context->state[0] = 0x67452301;
  77         context->state[1] = 0xEFCDAB89;
  78         context->state[2] = 0x98BADCFE;
  79         context->state[3] = 0x10325476;
  80 }
  81 /* }}} */
  82 
  83 /* {{{ PHP_RIPEMD256Init
  84  * ripemd256 initialization. Begins a ripemd256 operation, writing a new context.
  85  */
  86 PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX * context)
  87 {
  88         context->count[0] = context->count[1] = 0;
  89         /* Load magic initialization constants.
  90          */
  91         context->state[0] = 0x67452301;
  92         context->state[1] = 0xEFCDAB89;
  93         context->state[2] = 0x98BADCFE;
  94         context->state[3] = 0x10325476;
  95         context->state[4] = 0x76543210;
  96         context->state[5] = 0xFEDCBA98;
  97         context->state[6] = 0x89ABCDEF;
  98         context->state[7] = 0x01234567;
  99 }
 100 /* }}} */
 101 
 102 /* {{{ PHP_RIPEMD160Init
 103  * ripemd160 initialization. Begins a ripemd160 operation, writing a new context.
 104  */
 105 PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX * context)
 106 {
 107         context->count[0] = context->count[1] = 0;
 108         /* Load magic initialization constants.
 109          */
 110         context->state[0] = 0x67452301;
 111         context->state[1] = 0xEFCDAB89;
 112         context->state[2] = 0x98BADCFE;
 113         context->state[3] = 0x10325476;
 114         context->state[4] = 0xC3D2E1F0;
 115 }
 116 /* }}} */
 117 
 118 /* {{{ PHP_RIPEMD320Init
 119  * ripemd320 initialization. Begins a ripemd320 operation, writing a new context.
 120  */
 121 PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX * context)
 122 {
 123         context->count[0] = context->count[1] = 0;
 124         /* Load magic initialization constants.
 125          */
 126         context->state[0] = 0x67452301;
 127         context->state[1] = 0xEFCDAB89;
 128         context->state[2] = 0x98BADCFE;
 129         context->state[3] = 0x10325476;
 130         context->state[4] = 0xC3D2E1F0;
 131         context->state[5] = 0x76543210;
 132         context->state[6] = 0xFEDCBA98;
 133         context->state[7] = 0x89ABCDEF;
 134         context->state[8] = 0x01234567;
 135         context->state[9] = 0x3C2D1E0F;
 136 }
 137 /* }}} */
 138 
 139 /* Basic ripemd function */
 140 #define F0(x,y,z)               ((x) ^ (y) ^ (z))
 141 #define F1(x,y,z)               (((x) & (y)) | ((~(x)) & (z)))
 142 #define F2(x,y,z)               (((x) | (~(y))) ^ (z))
 143 #define F3(x,y,z)               (((x) & (z)) | ((y) & (~(z))))
 144 #define F4(x,y,z)               ((x) ^ ((y) | (~(z))))
 145 
 146 static const php_hash_uint32 K_values[5]  = { 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E };    /* 128, 256, 160, 320 */
 147 static const php_hash_uint32 KK_values[4] = { 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x00000000 };                /* 128 & 256 */
 148 static const php_hash_uint32 KK160_values[5] = { 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000 }; /* 160 & 320 */
 149 
 150 #define K(n)  K_values[ (n) >> 4]
 151 #define KK(n) KK_values[(n) >> 4]
 152 #define KK160(n) KK160_values[(n) >> 4]
 153 
 154 static const unsigned char R[80] = {
 155          0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 156          7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
 157          3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
 158          1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
 159          4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13 };
 160 
 161 static const unsigned char RR[80] = {
 162          5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
 163          6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
 164         15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
 165          8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
 166         12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11 };
 167 
 168 static const unsigned char S[80] = {
 169         11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
 170          7,  6,  8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
 171         11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
 172         11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
 173          9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6 };
 174 
 175 static const unsigned char SS[80] = {
 176          8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
 177          9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
 178          9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
 179         15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
 180          8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11 };
 181 
 182 #define ROLS(j, x)      (((x) << S[j])  | ((x) >> (32 - S[j])))
 183 #define ROLSS(j, x)     (((x) << SS[j]) | ((x) >> (32 - SS[j])))
 184 #define ROL(n, x)       (((x) << n) | ((x) >> (32 - n)))
 185 
 186 /* {{{ RIPEMDDecode
 187    Decodes input (unsigned char) into output (php_hash_uint32). Assumes len is
 188    a multiple of 4.
 189  */
 190 static void RIPEMDDecode(php_hash_uint32 *output, const unsigned char *input, unsigned int len)
 191 {
 192         unsigned int i, j;
 193 
 194         for (i = 0, j = 0; j < len; i++, j += 4)
 195                 output[i] = ((php_hash_uint32) input[j + 0]) | (((php_hash_uint32) input[j + 1]) << 8) |
 196                         (((php_hash_uint32) input[j + 2]) << 16) | (((php_hash_uint32) input[j + 3]) << 24);
 197 }
 198 /* }}} */
 199 
 200 /* {{{ RIPEMD128Transform
 201  * ripemd128 basic transformation. Transforms state based on block.
 202  */
 203 static void RIPEMD128Transform(php_hash_uint32 state[4], const unsigned char block[64])
 204 {
 205         php_hash_uint32 a  = state[0], b  = state[1], c  = state[2], d  = state[3];
 206         php_hash_uint32 aa = state[0], bb = state[1], cc = state[2], dd = state[3];
 207         php_hash_uint32 tmp, x[16];
 208         int j;
 209 
 210         RIPEMDDecode(x, block, 64);
 211 
 212         for(j = 0; j < 16; j++) {
 213                 tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j));
 214                 a = d; d = c; c = b; b = tmp;
 215                 tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK(j));
 216                 aa = dd; dd = cc; cc = bb; bb = tmp;
 217         }
 218 
 219         for(j = 16; j < 32; j++) {
 220                 tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j));
 221                 a = d; d = c; c = b; b = tmp;
 222                 tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK(j));
 223                 aa = dd; dd = cc; cc = bb; bb = tmp;
 224         }
 225 
 226         for(j = 32; j < 48; j++) {
 227                 tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j));
 228                 a = d; d = c; c = b; b = tmp;
 229                 tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK(j));
 230                 aa = dd; dd = cc; cc = bb; bb = tmp;
 231         }
 232 
 233         for(j = 48; j < 64; j++) {
 234                 tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j));
 235                 a = d; d = c; c = b; b = tmp;
 236                 tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK(j));
 237                 aa = dd; dd = cc; cc = bb; bb = tmp;
 238         }
 239 
 240         tmp = state[1] + c + dd;
 241         state[1] = state[2] + d + aa;
 242         state[2] = state[3] + a + bb;
 243         state[3] = state[0] + b + cc;
 244         state[0] = tmp;
 245 
 246         tmp = 0;
 247         ZEND_SECURE_ZERO(x, sizeof(x));
 248 }
 249 /* }}} */
 250 
 251 /* {{{ PHP_RIPEMD128Update
 252    ripemd128 block update operation. Continues a ripemd128 message-digest
 253    operation, processing another message block, and updating the
 254    context.
 255  */
 256 PHP_HASH_API void PHP_RIPEMD128Update(PHP_RIPEMD128_CTX * context, const unsigned char *input, unsigned int inputLen)
 257 {
 258         unsigned int i, index, partLen;
 259 
 260         /* Compute number of bytes mod 64 */
 261         index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
 262 
 263         /* Update number of bits */
 264         if ((context->count[0] += ((php_hash_uint32) inputLen << 3)) < ((php_hash_uint32) inputLen << 3)) {
 265                 context->count[1]++;
 266         }
 267         context->count[1] += ((php_hash_uint32) inputLen >> 29);
 268 
 269         partLen = 64 - index;
 270 
 271         /* Transform as many times as possible.
 272          */
 273         if (inputLen >= partLen) {
 274                 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
 275                 RIPEMD128Transform(context->state, context->buffer);
 276 
 277                 for (i = partLen; i + 63 < inputLen; i += 64) {
 278                         RIPEMD128Transform(context->state, &input[i]);
 279                 }
 280 
 281                 index = 0;
 282         } else {
 283                 i = 0;
 284         }
 285 
 286         /* Buffer remaining input */
 287         memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
 288 }
 289 /* }}} */
 290 
 291 /* {{{ RIPEMD256Transform
 292  * ripemd256 basic transformation. Transforms state based on block.
 293  */
 294 static void RIPEMD256Transform(php_hash_uint32 state[8], const unsigned char block[64])
 295 {
 296         php_hash_uint32 a  = state[0], b  = state[1], c  = state[2], d  = state[3];
 297         php_hash_uint32 aa = state[4], bb = state[5], cc = state[6], dd = state[7];
 298         php_hash_uint32 tmp, x[16];
 299         int j;
 300 
 301         RIPEMDDecode(x, block, 64);
 302 
 303         for(j = 0; j < 16; j++) {
 304                 tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j));
 305                 a = d; d = c; c = b; b = tmp;
 306                 tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK(j));
 307                 aa = dd; dd = cc; cc = bb; bb = tmp;
 308         }
 309         tmp = a; a = aa; aa = tmp;
 310 
 311         for(j = 16; j < 32; j++) {
 312                 tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j));
 313                 a = d; d = c; c = b; b = tmp;
 314                 tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK(j));
 315                 aa = dd; dd = cc; cc = bb; bb = tmp;
 316         }
 317         tmp = b; b = bb; bb = tmp;
 318 
 319         for(j = 32; j < 48; j++) {
 320                 tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j));
 321                 a = d; d = c; c = b; b = tmp;
 322                 tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK(j));
 323                 aa = dd; dd = cc; cc = bb; bb = tmp;
 324         }
 325         tmp = c; c = cc; cc = tmp;
 326 
 327         for(j = 48; j < 64; j++) {
 328                 tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j));
 329                 a = d; d = c; c = b; b = tmp;
 330                 tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK(j));
 331                 aa = dd; dd = cc; cc = bb; bb = tmp;
 332         }
 333         tmp = d; d = dd; dd = tmp;
 334 
 335         state[0] += a;
 336         state[1] += b;
 337         state[2] += c;
 338         state[3] += d;
 339         state[4] += aa;
 340         state[5] += bb;
 341         state[6] += cc;
 342         state[7] += dd;
 343 
 344         tmp = 0;
 345         ZEND_SECURE_ZERO(x, sizeof(x));
 346 }
 347 /* }}} */
 348 
 349 /* {{{ PHP_RIPEMD256Update
 350    ripemd256 block update operation. Continues a ripemd256 message-digest
 351    operation, processing another message block, and updating the
 352    context.
 353  */
 354 PHP_HASH_API void PHP_RIPEMD256Update(PHP_RIPEMD256_CTX * context, const unsigned char *input, unsigned int inputLen)
 355 {
 356         unsigned int i, index, partLen;
 357 
 358         /* Compute number of bytes mod 64 */
 359         index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
 360 
 361         /* Update number of bits */
 362         if ((context->count[0] += ((php_hash_uint32) inputLen << 3)) < ((php_hash_uint32) inputLen << 3)) {
 363                 context->count[1]++;
 364         }
 365         context->count[1] += ((php_hash_uint32) inputLen >> 29);
 366 
 367         partLen = 64 - index;
 368 
 369         /* Transform as many times as possible.
 370          */
 371         if (inputLen >= partLen) {
 372                 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
 373                 RIPEMD256Transform(context->state, context->buffer);
 374 
 375                 for (i = partLen; i + 63 < inputLen; i += 64) {
 376                         RIPEMD256Transform(context->state, &input[i]);
 377                 }
 378 
 379                 index = 0;
 380         } else {
 381                 i = 0;
 382         }
 383 
 384         /* Buffer remaining input */
 385         memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
 386 }
 387 /* }}} */
 388 
 389 /* {{{ RIPEMD160Transform
 390  * ripemd160 basic transformation. Transforms state based on block.
 391  */
 392 static void RIPEMD160Transform(php_hash_uint32 state[5], const unsigned char block[64])
 393 {
 394         php_hash_uint32 a  = state[0], b  = state[1], c  = state[2], d  = state[3], e  = state[4];
 395         php_hash_uint32 aa = state[0], bb = state[1], cc = state[2], dd = state[3], ee = state[4];
 396         php_hash_uint32 tmp, x[16];
 397         int j;
 398 
 399         RIPEMDDecode(x, block, 64);
 400 
 401         for(j = 0; j < 16; j++) {
 402                 tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 403                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 404                 tmp = ROLSS(j, aa + F4(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 405                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 406         }
 407 
 408         for(j = 16; j < 32; j++) {
 409                 tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 410                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 411                 tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 412                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 413         }
 414 
 415         for(j = 32; j < 48; j++) {
 416                 tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 417                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 418                 tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 419                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 420         }
 421 
 422         for(j = 48; j < 64; j++) {
 423                 tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 424                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 425                 tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 426                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 427         }
 428 
 429         for(j = 64; j < 80; j++) {
 430                 tmp = ROLS( j, a  + F4(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 431                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 432                 tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 433                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 434         }
 435 
 436         tmp = state[1] + c + dd;
 437         state[1] = state[2] + d + ee;
 438         state[2] = state[3] + e + aa;
 439         state[3] = state[4] + a + bb;
 440         state[4] = state[0] + b + cc;
 441         state[0] = tmp;
 442 
 443         tmp = 0;
 444         ZEND_SECURE_ZERO(x, sizeof(x));
 445 }
 446 /* }}} */
 447 
 448 /* {{{ PHP_RIPEMD160Update
 449    ripemd160 block update operation. Continues a ripemd160 message-digest
 450    operation, processing another message block, and updating the
 451    context.
 452  */
 453 PHP_HASH_API void PHP_RIPEMD160Update(PHP_RIPEMD160_CTX * context, const unsigned char *input, unsigned int inputLen)
 454 {
 455         unsigned int i, index, partLen;
 456 
 457         /* Compute number of bytes mod 64 */
 458         index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
 459 
 460         /* Update number of bits */
 461         if ((context->count[0] += ((php_hash_uint32) inputLen << 3)) < ((php_hash_uint32) inputLen << 3)) {
 462                 context->count[1]++;
 463         }
 464         context->count[1] += ((php_hash_uint32) inputLen >> 29);
 465 
 466         partLen = 64 - index;
 467 
 468         /* Transform as many times as possible.
 469          */
 470         if (inputLen >= partLen) {
 471                 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
 472                 RIPEMD160Transform(context->state, context->buffer);
 473 
 474                 for (i = partLen; i + 63 < inputLen; i += 64) {
 475                         RIPEMD160Transform(context->state, &input[i]);
 476                 }
 477 
 478                 index = 0;
 479         } else {
 480                 i = 0;
 481         }
 482 
 483         /* Buffer remaining input */
 484         memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
 485 }
 486 /* }}} */
 487 
 488 /* {{{ RIPEMD320Transform
 489  * ripemd320 basic transformation. Transforms state based on block.
 490  */
 491 static void RIPEMD320Transform(php_hash_uint32 state[10], const unsigned char block[64])
 492 {
 493         php_hash_uint32 a  = state[0], b  = state[1], c  = state[2], d  = state[3], e  = state[4];
 494         php_hash_uint32 aa = state[5], bb = state[6], cc = state[7], dd = state[8], ee = state[9];
 495         php_hash_uint32 tmp, x[16];
 496         int j;
 497 
 498         RIPEMDDecode(x, block, 64);
 499 
 500         for(j = 0; j < 16; j++) {
 501                 tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 502                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 503                 tmp = ROLSS(j, aa + F4(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 504                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 505         }
 506         tmp = b; b = bb; bb = tmp;
 507 
 508         for(j = 16; j < 32; j++) {
 509                 tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 510                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 511                 tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 512                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 513         }
 514         tmp = d; d = dd; dd = tmp;
 515 
 516         for(j = 32; j < 48; j++) {
 517                 tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 518                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 519                 tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 520                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 521         }
 522         tmp = a; a = aa; aa = tmp;
 523 
 524         for(j = 48; j < 64; j++) {
 525                 tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 526                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 527                 tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 528                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 529         }
 530         tmp = c; c = cc; cc = tmp;
 531 
 532         for(j = 64; j < 80; j++) {
 533                 tmp = ROLS( j, a  + F4(b,  c,  d)  + x[R[j]]  + K(j)) + e;
 534                 a = e; e = d; d = ROL(10, c); c = b; b = tmp;
 535                 tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
 536                 aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
 537         }
 538         tmp = e; e = ee; ee = tmp;
 539 
 540         state[0] += a;
 541         state[1] += b;
 542         state[2] += c;
 543         state[3] += d;
 544         state[4] += e;
 545         state[5] += aa;
 546         state[6] += bb;
 547         state[7] += cc;
 548         state[8] += dd;
 549         state[9] += ee;
 550 
 551         tmp = 0;
 552         ZEND_SECURE_ZERO(x, sizeof(x));
 553 }
 554 /* }}} */
 555 
 556 /* {{{ PHP_RIPEMD320Update
 557    ripemd320 block update operation. Continues a ripemd320 message-digest
 558    operation, processing another message block, and updating the
 559    context.
 560  */
 561 PHP_HASH_API void PHP_RIPEMD320Update(PHP_RIPEMD320_CTX * context, const unsigned char *input, unsigned int inputLen)
 562 {
 563         unsigned int i, index, partLen;
 564 
 565         /* Compute number of bytes mod 64 */
 566         index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
 567 
 568         /* Update number of bits */
 569         if ((context->count[0] += ((php_hash_uint32) inputLen << 3)) < ((php_hash_uint32) inputLen << 3)) {
 570                 context->count[1]++;
 571         }
 572         context->count[1] += ((php_hash_uint32) inputLen >> 29);
 573 
 574         partLen = 64 - index;
 575 
 576         /* Transform as many times as possible.
 577          */
 578         if (inputLen >= partLen) {
 579                 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
 580                 RIPEMD320Transform(context->state, context->buffer);
 581 
 582                 for (i = partLen; i + 63 < inputLen; i += 64) {
 583                         RIPEMD320Transform(context->state, &input[i]);
 584                 }
 585 
 586                 index = 0;
 587         } else {
 588                 i = 0;
 589         }
 590 
 591         /* Buffer remaining input */
 592         memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
 593 }
 594 /* }}} */
 595 
 596 static const unsigned char PADDING[64] =
 597 {
 598         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 599         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 600         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 601 };
 602 
 603 /* {{{ RIPEMDEncode
 604    Encodes input (php_hash_uint32) into output (unsigned char). Assumes len is
 605    a multiple of 4.
 606  */
 607 static void RIPEMDEncode(unsigned char *output, php_hash_uint32 *input, unsigned int len)
 608 {
 609         unsigned int i, j;
 610 
 611         for (i = 0, j = 0; j < len; i++, j += 4) {
 612                 output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
 613                 output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
 614                 output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
 615                 output[j + 0] = (unsigned char) (input[i] & 0xff);
 616         }
 617 }
 618 /* }}} */
 619 
 620 /* {{{ PHP_RIPEMD128Final
 621    ripemd128 finalization. Ends a ripemd128 message-digest operation, writing the
 622    the message digest and zeroizing the context.
 623  */
 624 PHP_HASH_API void PHP_RIPEMD128Final(unsigned char digest[16], PHP_RIPEMD128_CTX * context)
 625 {
 626         unsigned char bits[8];
 627         unsigned int index, padLen;
 628 
 629         /* Save number of bits */
 630         bits[0] = (unsigned char) (context->count[0] & 0xFF);
 631         bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
 632         bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
 633         bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
 634         bits[4] = (unsigned char) (context->count[1] & 0xFF);
 635         bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
 636         bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
 637         bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
 638 
 639         /* Pad out to 56 mod 64.
 640          */
 641         index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
 642         padLen = (index < 56) ? (56 - index) : (120 - index);
 643         PHP_RIPEMD128Update(context, PADDING, padLen);
 644 
 645         /* Append length (before padding) */
 646         PHP_RIPEMD128Update(context, bits, 8);
 647 
 648         /* Store state in digest */
 649         RIPEMDEncode(digest, context->state, 16);
 650 
 651         /* Zeroize sensitive information.
 652          */
 653         ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
 654 }
 655 /* }}} */
 656 
 657 /* {{{ PHP_RIPEMD256Final
 658    ripemd256 finalization. Ends a ripemd256 message-digest operation, writing the
 659    the message digest and zeroizing the context.
 660  */
 661 PHP_HASH_API void PHP_RIPEMD256Final(unsigned char digest[32], PHP_RIPEMD256_CTX * context)
 662 {
 663         unsigned char bits[8];
 664         unsigned int index, padLen;
 665 
 666         /* Save number of bits */
 667         bits[0] = (unsigned char) (context->count[0] & 0xFF);
 668         bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
 669         bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
 670         bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
 671         bits[4] = (unsigned char) (context->count[1] & 0xFF);
 672         bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
 673         bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
 674         bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
 675 
 676         /* Pad out to 56 mod 64.
 677          */
 678         index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
 679         padLen = (index < 56) ? (56 - index) : (120 - index);
 680         PHP_RIPEMD256Update(context, PADDING, padLen);
 681 
 682         /* Append length (before padding) */
 683         PHP_RIPEMD256Update(context, bits, 8);
 684 
 685         /* Store state in digest */
 686         RIPEMDEncode(digest, context->state, 32);
 687 
 688         /* Zeroize sensitive information.
 689          */
 690         ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
 691 }
 692 /* }}} */
 693 
 694 /* {{{ PHP_RIPEMD160Final
 695    ripemd160 finalization. Ends a ripemd160 message-digest operation, writing the
 696    the message digest and zeroizing the context.
 697  */
 698 PHP_HASH_API void PHP_RIPEMD160Final(unsigned char digest[20], PHP_RIPEMD160_CTX * context)
 699 {
 700         unsigned char bits[8];
 701         unsigned int index, padLen;
 702 
 703         /* Save number of bits */
 704         bits[0] = (unsigned char) (context->count[0] & 0xFF);
 705         bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
 706         bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
 707         bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
 708         bits[4] = (unsigned char) (context->count[1] & 0xFF);
 709         bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
 710         bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
 711         bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
 712 
 713         /* Pad out to 56 mod 64.
 714          */
 715         index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
 716         padLen = (index < 56) ? (56 - index) : (120 - index);
 717         PHP_RIPEMD160Update(context, PADDING, padLen);
 718 
 719         /* Append length (before padding) */
 720         PHP_RIPEMD160Update(context, bits, 8);
 721 
 722         /* Store state in digest */
 723         RIPEMDEncode(digest, context->state, 20);
 724 
 725         /* Zeroize sensitive information.
 726          */
 727         ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
 728 }
 729 /* }}} */
 730 
 731 /* {{{ PHP_RIPEMD320Final
 732    ripemd320 finalization. Ends a ripemd320 message-digest operation, writing the
 733    the message digest and zeroizing the context.
 734  */
 735 PHP_HASH_API void PHP_RIPEMD320Final(unsigned char digest[40], PHP_RIPEMD320_CTX * context)
 736 {
 737         unsigned char bits[8];
 738         unsigned int index, padLen;
 739 
 740         /* Save number of bits */
 741         bits[0] = (unsigned char) (context->count[0] & 0xFF);
 742         bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
 743         bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
 744         bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
 745         bits[4] = (unsigned char) (context->count[1] & 0xFF);
 746         bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
 747         bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
 748         bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
 749 
 750         /* Pad out to 56 mod 64.
 751          */
 752         index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
 753         padLen = (index < 56) ? (56 - index) : (120 - index);
 754         PHP_RIPEMD320Update(context, PADDING, padLen);
 755 
 756         /* Append length (before padding) */
 757         PHP_RIPEMD320Update(context, bits, 8);
 758 
 759         /* Store state in digest */
 760         RIPEMDEncode(digest, context->state, 40);
 761 
 762         /* Zeroize sensitive information.
 763          */
 764         ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
 765 }
 766 /* }}} */
 767 
 768 /*
 769  * Local variables:
 770  * tab-width: 4
 771  * c-basic-offset: 4
 772  * End:
 773  * vim600: sw=4 ts=4 fdm=marker
 774  * vim<600: sw=4 ts=4
 775  */
/* [<][>][^][v][top][bottom][index][help] */
root/ext/hash/hash_ripemd.c

DEFINITIONS
