PageRenderTime 49ms CodeModel.GetById 15ms RepoModel.GetById 0ms app.codeStats 0ms

/ext/hash/hash_ripemd.c

http://github.com/php/php-src
C | 766 lines | 492 code | 113 blank | 161 comment | 36 complexity | ed5c760c46f8d6a9e96168a3a920ee38 MD5 | raw file
Possible License(s): BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-2.1 
    

  1. /*
    2. 

  2.   +----------------------------------------------------------------------+
    3. 

  3.   | Copyright (c) The PHP Group                                          |
    4. 

  4.   +----------------------------------------------------------------------+
    5. 

  5.   | This source file is subject to version 3.01 of the PHP license,      |
    6. 

  6.   | that is bundled with this package in the file LICENSE, and is        |
    7. 

  7.   | available through the world-wide-web at the following url:           |
    8. 

  8.   | http://www.php.net/license/3_01.txt                                  |
    9. 

  9.   | If you did not receive a copy of the PHP license and are unable to   |
    10. 

  10.   | obtain it through the world-wide-web, please send a note to          |
    11. 

  11.   | license@php.net so we can mail you a copy immediately.               |
    12. 

  12.   +----------------------------------------------------------------------+
    13. 

  13.   | Author: Sara Golemon <pollita@php.net>                               |
    14. 

  14.   +----------------------------------------------------------------------+
    15. 

  15. */
    16. 

  16. 

  17. /* Heavily borrowed from md5.c & sha1.c of PHP archival fame
    18. 

  18.    Note that ripemd laughs in the face of logic and uses
    19. 

  19.    little endian byte ordering */
    20. 

  20. 

  21. #include "php_hash.h"
    22. 

  22. #include "php_hash_ripemd.h"
    23. 

  23. 

  24. const php_hash_ops php_hash_ripemd128_ops = {
    25. 

  25. 	(php_hash_init_func_t) PHP_RIPEMD128Init,
    26. 

  26. 	(php_hash_update_func_t) PHP_RIPEMD128Update,
    27. 

  27. 	(php_hash_final_func_t) PHP_RIPEMD128Final,
    28. 

  28. 	(php_hash_copy_func_t) php_hash_copy,
    29. 

  29. 	16,
    30. 

  30. 	64,
    31. 

  31. 	sizeof(PHP_RIPEMD128_CTX),
    32. 

  32. 	1
    33. 

  33. };
    34. 

  34. 

  35. const php_hash_ops php_hash_ripemd160_ops = {
    36. 

  36. 	(php_hash_init_func_t) PHP_RIPEMD160Init,
    37. 

  37. 	(php_hash_update_func_t) PHP_RIPEMD160Update,
    38. 

  38. 	(php_hash_final_func_t) PHP_RIPEMD160Final,
    39. 

  39. 	(php_hash_copy_func_t) php_hash_copy,
    40. 

  40. 	20,
    41. 

  41. 	64,
    42. 

  42. 	sizeof(PHP_RIPEMD160_CTX),
    43. 

  43. 	1
    44. 

  44. };
    45. 

  45. 

  46. const php_hash_ops php_hash_ripemd256_ops = {
    47. 

  47. 	(php_hash_init_func_t) PHP_RIPEMD256Init,
    48. 

  48. 	(php_hash_update_func_t) PHP_RIPEMD256Update,
    49. 

  49. 	(php_hash_final_func_t) PHP_RIPEMD256Final,
    50. 

  50. 	(php_hash_copy_func_t) php_hash_copy,
    51. 

  51. 	32,
    52. 

  52. 	64,
    53. 

  53. 	sizeof(PHP_RIPEMD256_CTX),
    54. 

  54. 	1
    55. 

  55. };
    56. 

  56. 

  57. const php_hash_ops php_hash_ripemd320_ops = {
    58. 

  58. 	(php_hash_init_func_t) PHP_RIPEMD320Init,
    59. 

  59. 	(php_hash_update_func_t) PHP_RIPEMD320Update,
    60. 

  60. 	(php_hash_final_func_t) PHP_RIPEMD320Final,
    61. 

  61. 	(php_hash_copy_func_t) php_hash_copy,
    62. 

  62. 	40,
    63. 

  63. 	64,
    64. 

  64. 	sizeof(PHP_RIPEMD320_CTX),
    65. 

  65. 	1
    66. 

  66. };
    67. 

  67. 

  68. /* {{{ PHP_RIPEMD128Init
    69. 

  69.  * ripemd128 initialization. Begins a ripemd128 operation, writing a new context.
    70. 

  70.  */
    71. 

  71. PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX * context)
    72. 

  72. {
    73. 

  73. 	context->count[0] = context->count[1] = 0;
    74. 

  74. 	/* Load magic initialization constants.
    75. 

  75. 	 */
    76. 

  76. 	context->state[0] = 0x67452301;
    77. 

  77. 	context->state[1] = 0xEFCDAB89;
    78. 

  78. 	context->state[2] = 0x98BADCFE;
    79. 

  79. 	context->state[3] = 0x10325476;
    80. 

  80. }
    81. 

  81. /* }}} */
    82. 

  82. 

  83. /* {{{ PHP_RIPEMD256Init
    84. 

  84.  * ripemd256 initialization. Begins a ripemd256 operation, writing a new context.
    85. 

  85.  */
    86. 

  86. PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX * context)
    87. 

  87. {
    88. 

  88. 	context->count[0] = context->count[1] = 0;
    89. 

  89. 	/* Load magic initialization constants.
    90. 

  90. 	 */
    91. 

  91. 	context->state[0] = 0x67452301;
    92. 

  92. 	context->state[1] = 0xEFCDAB89;
    93. 

  93. 	context->state[2] = 0x98BADCFE;
    94. 

  94. 	context->state[3] = 0x10325476;
    95. 

  95. 	context->state[4] = 0x76543210;
    96. 

  96. 	context->state[5] = 0xFEDCBA98;
    97. 

  97. 	context->state[6] = 0x89ABCDEF;
    98. 

  98. 	context->state[7] = 0x01234567;
    99. 

  99. }
    100. 

  100. /* }}} */
    101. 

  101. 

  102. /* {{{ PHP_RIPEMD160Init
    103. 

  103.  * ripemd160 initialization. Begins a ripemd160 operation, writing a new context.
    104. 

  104.  */
    105. 

  105. PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX * context)
    106. 

  106. {
    107. 

  107. 	context->count[0] = context->count[1] = 0;
    108. 

  108. 	/* Load magic initialization constants.
    109. 

  109. 	 */
    110. 

  110. 	context->state[0] = 0x67452301;
    111. 

  111. 	context->state[1] = 0xEFCDAB89;
    112. 

  112. 	context->state[2] = 0x98BADCFE;
    113. 

  113. 	context->state[3] = 0x10325476;
    114. 

  114. 	context->state[4] = 0xC3D2E1F0;
    115. 

  115. }
    116. 

  116. /* }}} */
    117. 

  117. 

  118. /* {{{ PHP_RIPEMD320Init
    119. 

  119.  * ripemd320 initialization. Begins a ripemd320 operation, writing a new context.
    120. 

  120.  */
    121. 

  121. PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX * context)
    122. 

  122. {
    123. 

  123. 	context->count[0] = context->count[1] = 0;
    124. 

  124. 	/* Load magic initialization constants.
    125. 

  125. 	 */
    126. 

  126. 	context->state[0] = 0x67452301;
    127. 

  127. 	context->state[1] = 0xEFCDAB89;
    128. 

  128. 	context->state[2] = 0x98BADCFE;
    129. 

  129. 	context->state[3] = 0x10325476;
    130. 

  130. 	context->state[4] = 0xC3D2E1F0;
    131. 

  131. 	context->state[5] = 0x76543210;
    132. 

  132. 	context->state[6] = 0xFEDCBA98;
    133. 

  133. 	context->state[7] = 0x89ABCDEF;
    134. 

  134. 	context->state[8] = 0x01234567;
    135. 

  135. 	context->state[9] = 0x3C2D1E0F;
    136. 

  136. }
    137. 

  137. /* }}} */
    138. 

  138. 

  139. /* Basic ripemd function */
    140. 

  140. #define F0(x,y,z)		((x) ^ (y) ^ (z))
    141. 

  141. #define F1(x,y,z)		(((x) & (y)) | ((~(x)) & (z)))
    142. 

  142. #define F2(x,y,z)		(((x) | (~(y))) ^ (z))
    143. 

  143. #define F3(x,y,z)		(((x) & (z)) | ((y) & (~(z))))
    144. 

  144. #define F4(x,y,z)		((x) ^ ((y) | (~(z))))
    145. 

  145. 

  146. static const uint32_t K_values[5]  = { 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E };    /* 128, 256, 160, 320 */
    147. 

  147. static const uint32_t KK_values[4] = { 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x00000000 };                /* 128 & 256 */
    148. 

  148. static const uint32_t KK160_values[5] = { 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000 }; /* 160 & 320 */
    149. 

  149. 

  150. #define K(n)  K_values[ (n) >> 4]
    151. 

  151. #define KK(n) KK_values[(n) >> 4]
    152. 

  152. #define KK160(n) KK160_values[(n) >> 4]
    153. 

  153. 

  154. static const unsigned char R[80] = {
    155. 

  155. 	 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
    156. 

  156. 	 7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
    157. 

  157. 	 3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
    158. 

  158. 	 1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
    159. 

  159. 	 4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13 };
    160. 

  160. 

  161. static const unsigned char RR[80] = {
    162. 

  162. 	 5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
    163. 

  163. 	 6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
    164. 

  164. 	15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
    165. 

  165. 	 8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
    166. 

  166. 	12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11 };
    167. 

  167. 

  168. static const unsigned char S[80] = {
    169. 

  169. 	11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
    170. 

  170. 	 7,  6,  8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
    171. 

  171. 	11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
    172. 

  172. 	11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
    173. 

  173. 	 9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6 };
    174. 

  174. 

  175. static const unsigned char SS[80] = {
    176. 

  176. 	 8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
    177. 

  177. 	 9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
    178. 

  178. 	 9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
    179. 

  179. 	15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
    180. 

  180. 	 8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11 };
    181. 

  181. 

  182. #define ROLS(j, x)	(((x) << S[j])  | ((x) >> (32 - S[j])))
    183. 

  183. #define ROLSS(j, x)	(((x) << SS[j]) | ((x) >> (32 - SS[j])))
    184. 

  184. #define ROL(n, x)	(((x) << n) | ((x) >> (32 - n)))
    185. 

  185. 

  186. /* {{{ RIPEMDDecode
    187. 

  187.    Decodes input (unsigned char) into output (uint32_t). Assumes len is
    188. 

  188.    a multiple of 4.
    189. 

  189.  */
    190. 

  190. static void RIPEMDDecode(uint32_t *output, const unsigned char *input, unsigned int len)
    191. 

  191. {
    192. 

  192. 	unsigned int i, j;
    193. 

  193. 

  194. 	for (i = 0, j = 0; j < len; i++, j += 4)
    195. 

  195. 		output[i] = ((uint32_t) input[j + 0]) | (((uint32_t) input[j + 1]) << 8) |
    196. 

  196. 			(((uint32_t) input[j + 2]) << 16) | (((uint32_t) input[j + 3]) << 24);
    197. 

  197. }
    198. 

  198. /* }}} */
    199. 

  199. 

  200. /* {{{ RIPEMD128Transform
    201. 

  201.  * ripemd128 basic transformation. Transforms state based on block.
    202. 

  202.  */
    203. 

  203. static void RIPEMD128Transform(uint32_t state[4], const unsigned char block[64])
    204. 

  204. {
    205. 

  205. 	uint32_t a  = state[0], b  = state[1], c  = state[2], d  = state[3];
    206. 

  206. 	uint32_t aa = state[0], bb = state[1], cc = state[2], dd = state[3];
    207. 

  207. 	uint32_t tmp, x[16];
    208. 

  208. 	int j;
    209. 

  209. 

  210. 	RIPEMDDecode(x, block, 64);
    211. 

  211. 

  212. 	for(j = 0; j < 16; j++) {
    213. 

  213. 		tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j));
    214. 

  214. 		a = d; d = c; c = b; b = tmp;
    215. 

  215. 		tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK(j));
    216. 

  216. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    217. 

  217. 	}
    218. 

  218. 

  219. 	for(j = 16; j < 32; j++) {
    220. 

  220. 		tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j));
    221. 

  221. 		a = d; d = c; c = b; b = tmp;
    222. 

  222. 		tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK(j));
    223. 

  223. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    224. 

  224. 	}
    225. 

  225. 

  226. 	for(j = 32; j < 48; j++) {
    227. 

  227. 		tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j));
    228. 

  228. 		a = d; d = c; c = b; b = tmp;
    229. 

  229. 		tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK(j));
    230. 

  230. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    231. 

  231. 	}
    232. 

  232. 

  233. 	for(j = 48; j < 64; j++) {
    234. 

  234. 		tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j));
    235. 

  235. 		a = d; d = c; c = b; b = tmp;
    236. 

  236. 		tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK(j));
    237. 

  237. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    238. 

  238. 	}
    239. 

  239. 

  240. 	tmp = state[1] + c + dd;
    241. 

  241. 	state[1] = state[2] + d + aa;
    242. 

  242. 	state[2] = state[3] + a + bb;
    243. 

  243. 	state[3] = state[0] + b + cc;
    244. 

  244. 	state[0] = tmp;
    245. 

  245. 

  246. 	tmp = 0;
    247. 

  247. 	ZEND_SECURE_ZERO(x, sizeof(x));
    248. 

  248. }
    249. 

  249. /* }}} */
    250. 

  250. 

  251. /* {{{ PHP_RIPEMD128Update
    252. 

  252.    ripemd128 block update operation. Continues a ripemd128 message-digest
    253. 

  253.    operation, processing another message block, and updating the
    254. 

  254.    context.
    255. 

  255.  */
    256. 

  256. PHP_HASH_API void PHP_RIPEMD128Update(PHP_RIPEMD128_CTX * context, const unsigned char *input, size_t inputLen)
    257. 

  257. {
    258. 

  258. 	unsigned int i, index, partLen;
    259. 

  259. 

  260. 	/* Compute number of bytes mod 64 */
    261. 

  261. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
    262. 

  262. 

  263. 	/* Update number of bits */
    264. 

  264. 	if ((context->count[0] += ((uint32_t) inputLen << 3)) < ((uint32_t) inputLen << 3)) {
    265. 

  265. 		context->count[1]++;
    266. 

  266. 	}
    267. 

  267. 	context->count[1] += ((uint32_t) inputLen >> 29);
    268. 

  268. 

  269. 	partLen = 64 - index;
    270. 

  270. 

  271. 	/* Transform as many times as possible.
    272. 

  272. 	 */
    273. 

  273. 	if (inputLen >= partLen) {
    274. 

  274. 		memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
    275. 

  275. 		RIPEMD128Transform(context->state, context->buffer);
    276. 

  276. 

  277. 		for (i = partLen; i + 63 < inputLen; i += 64) {
    278. 

  278. 			RIPEMD128Transform(context->state, &input[i]);
    279. 

  279. 		}
    280. 

  280. 

  281. 		index = 0;
    282. 

  282. 	} else {
    283. 

  283. 		i = 0;
    284. 

  284. 	}
    285. 

  285. 

  286. 	/* Buffer remaining input */
    287. 

  287. 	memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
    288. 

  288. }
    289. 

  289. /* }}} */
    290. 

  290. 

  291. /* {{{ RIPEMD256Transform
    292. 

  292.  * ripemd256 basic transformation. Transforms state based on block.
    293. 

  293.  */
    294. 

  294. static void RIPEMD256Transform(uint32_t state[8], const unsigned char block[64])
    295. 

  295. {
    296. 

  296. 	uint32_t a  = state[0], b  = state[1], c  = state[2], d  = state[3];
    297. 

  297. 	uint32_t aa = state[4], bb = state[5], cc = state[6], dd = state[7];
    298. 

  298. 	uint32_t tmp, x[16];
    299. 

  299. 	int j;
    300. 

  300. 

  301. 	RIPEMDDecode(x, block, 64);
    302. 

  302. 

  303. 	for(j = 0; j < 16; j++) {
    304. 

  304. 		tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j));
    305. 

  305. 		a = d; d = c; c = b; b = tmp;
    306. 

  306. 		tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK(j));
    307. 

  307. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    308. 

  308. 	}
    309. 

  309. 	tmp = a; a = aa; aa = tmp;
    310. 

  310. 

  311. 	for(j = 16; j < 32; j++) {
    312. 

  312. 		tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j));
    313. 

  313. 		a = d; d = c; c = b; b = tmp;
    314. 

  314. 		tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK(j));
    315. 

  315. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    316. 

  316. 	}
    317. 

  317. 	tmp = b; b = bb; bb = tmp;
    318. 

  318. 

  319. 	for(j = 32; j < 48; j++) {
    320. 

  320. 		tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j));
    321. 

  321. 		a = d; d = c; c = b; b = tmp;
    322. 

  322. 		tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK(j));
    323. 

  323. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    324. 

  324. 	}
    325. 

  325. 	tmp = c; c = cc; cc = tmp;
    326. 

  326. 

  327. 	for(j = 48; j < 64; j++) {
    328. 

  328. 		tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j));
    329. 

  329. 		a = d; d = c; c = b; b = tmp;
    330. 

  330. 		tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK(j));
    331. 

  331. 		aa = dd; dd = cc; cc = bb; bb = tmp;
    332. 

  332. 	}
    333. 

  333. 	tmp = d; d = dd; dd = tmp;
    334. 

  334. 

  335. 	state[0] += a;
    336. 

  336. 	state[1] += b;
    337. 

  337. 	state[2] += c;
    338. 

  338. 	state[3] += d;
    339. 

  339. 	state[4] += aa;
    340. 

  340. 	state[5] += bb;
    341. 

  341. 	state[6] += cc;
    342. 

  342. 	state[7] += dd;
    343. 

  343. 

  344. 	tmp = 0;
    345. 

  345. 	ZEND_SECURE_ZERO(x, sizeof(x));
    346. 

  346. }
    347. 

  347. /* }}} */
    348. 

  348. 

  349. /* {{{ PHP_RIPEMD256Update
    350. 

  350.    ripemd256 block update operation. Continues a ripemd256 message-digest
    351. 

  351.    operation, processing another message block, and updating the
    352. 

  352.    context.
    353. 

  353.  */
    354. 

  354. PHP_HASH_API void PHP_RIPEMD256Update(PHP_RIPEMD256_CTX * context, const unsigned char *input, size_t inputLen)
    355. 

  355. {
    356. 

  356. 	unsigned int i, index, partLen;
    357. 

  357. 

  358. 	/* Compute number of bytes mod 64 */
    359. 

  359. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
    360. 

  360. 

  361. 	/* Update number of bits */
    362. 

  362. 	if ((context->count[0] += ((uint32_t) inputLen << 3)) < ((uint32_t) inputLen << 3)) {
    363. 

  363. 		context->count[1]++;
    364. 

  364. 	}
    365. 

  365. 	context->count[1] += ((uint32_t) inputLen >> 29);
    366. 

  366. 

  367. 	partLen = 64 - index;
    368. 

  368. 

  369. 	/* Transform as many times as possible.
    370. 

  370. 	 */
    371. 

  371. 	if (inputLen >= partLen) {
    372. 

  372. 		memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
    373. 

  373. 		RIPEMD256Transform(context->state, context->buffer);
    374. 

  374. 

  375. 		for (i = partLen; i + 63 < inputLen; i += 64) {
    376. 

  376. 			RIPEMD256Transform(context->state, &input[i]);
    377. 

  377. 		}
    378. 

  378. 

  379. 		index = 0;
    380. 

  380. 	} else {
    381. 

  381. 		i = 0;
    382. 

  382. 	}
    383. 

  383. 

  384. 	/* Buffer remaining input */
    385. 

  385. 	memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
    386. 

  386. }
    387. 

  387. /* }}} */
    388. 

  388. 

  389. /* {{{ RIPEMD160Transform
    390. 

  390.  * ripemd160 basic transformation. Transforms state based on block.
    391. 

  391.  */
    392. 

  392. static void RIPEMD160Transform(uint32_t state[5], const unsigned char block[64])
    393. 

  393. {
    394. 

  394. 	uint32_t a  = state[0], b  = state[1], c  = state[2], d  = state[3], e  = state[4];
    395. 

  395. 	uint32_t aa = state[0], bb = state[1], cc = state[2], dd = state[3], ee = state[4];
    396. 

  396. 	uint32_t tmp, x[16];
    397. 

  397. 	int j;
    398. 

  398. 

  399. 	RIPEMDDecode(x, block, 64);
    400. 

  400. 

  401. 	for(j = 0; j < 16; j++) {
    402. 

  402. 		tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    403. 

  403. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    404. 

  404. 		tmp = ROLSS(j, aa + F4(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    405. 

  405. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    406. 

  406. 	}
    407. 

  407. 

  408. 	for(j = 16; j < 32; j++) {
    409. 

  409. 		tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    410. 

  410. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    411. 

  411. 		tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    412. 

  412. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    413. 

  413. 	}
    414. 

  414. 

  415. 	for(j = 32; j < 48; j++) {
    416. 

  416. 		tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    417. 

  417. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    418. 

  418. 		tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    419. 

  419. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    420. 

  420. 	}
    421. 

  421. 

  422. 	for(j = 48; j < 64; j++) {
    423. 

  423. 		tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    424. 

  424. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    425. 

  425. 		tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    426. 

  426. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    427. 

  427. 	}
    428. 

  428. 

  429. 	for(j = 64; j < 80; j++) {
    430. 

  430. 		tmp = ROLS( j, a  + F4(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    431. 

  431. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    432. 

  432. 		tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    433. 

  433. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    434. 

  434. 	}
    435. 

  435. 

  436. 	tmp = state[1] + c + dd;
    437. 

  437. 	state[1] = state[2] + d + ee;
    438. 

  438. 	state[2] = state[3] + e + aa;
    439. 

  439. 	state[3] = state[4] + a + bb;
    440. 

  440. 	state[4] = state[0] + b + cc;
    441. 

  441. 	state[0] = tmp;
    442. 

  442. 

  443. 	tmp = 0;
    444. 

  444. 	ZEND_SECURE_ZERO(x, sizeof(x));
    445. 

  445. }
    446. 

  446. /* }}} */
    447. 

  447. 

  448. /* {{{ PHP_RIPEMD160Update
    449. 

  449.    ripemd160 block update operation. Continues a ripemd160 message-digest
    450. 

  450.    operation, processing another message block, and updating the
    451. 

  451.    context.
    452. 

  452.  */
    453. 

  453. PHP_HASH_API void PHP_RIPEMD160Update(PHP_RIPEMD160_CTX * context, const unsigned char *input, size_t inputLen)
    454. 

  454. {
    455. 

  455. 	unsigned int i, index, partLen;
    456. 

  456. 

  457. 	/* Compute number of bytes mod 64 */
    458. 

  458. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
    459. 

  459. 

  460. 	/* Update number of bits */
    461. 

  461. 	if ((context->count[0] += ((uint32_t) inputLen << 3)) < ((uint32_t) inputLen << 3)) {
    462. 

  462. 		context->count[1]++;
    463. 

  463. 	}
    464. 

  464. 	context->count[1] += ((uint32_t) inputLen >> 29);
    465. 

  465. 

  466. 	partLen = 64 - index;
    467. 

  467. 

  468. 	/* Transform as many times as possible.
    469. 

  469. 	 */
    470. 

  470. 	if (inputLen >= partLen) {
    471. 

  471. 		memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
    472. 

  472. 		RIPEMD160Transform(context->state, context->buffer);
    473. 

  473. 

  474. 		for (i = partLen; i + 63 < inputLen; i += 64) {
    475. 

  475. 			RIPEMD160Transform(context->state, &input[i]);
    476. 

  476. 		}
    477. 

  477. 

  478. 		index = 0;
    479. 

  479. 	} else {
    480. 

  480. 		i = 0;
    481. 

  481. 	}
    482. 

  482. 

  483. 	/* Buffer remaining input */
    484. 

  484. 	memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
    485. 

  485. }
    486. 

  486. /* }}} */
    487. 

  487. 

  488. /* {{{ RIPEMD320Transform
    489. 

  489.  * ripemd320 basic transformation. Transforms state based on block.
    490. 

  490.  */
    491. 

  491. static void RIPEMD320Transform(uint32_t state[10], const unsigned char block[64])
    492. 

  492. {
    493. 

  493. 	uint32_t a  = state[0], b  = state[1], c  = state[2], d  = state[3], e  = state[4];
    494. 

  494. 	uint32_t aa = state[5], bb = state[6], cc = state[7], dd = state[8], ee = state[9];
    495. 

  495. 	uint32_t tmp, x[16];
    496. 

  496. 	int j;
    497. 

  497. 

  498. 	RIPEMDDecode(x, block, 64);
    499. 

  499. 

  500. 	for(j = 0; j < 16; j++) {
    501. 

  501. 		tmp = ROLS( j, a  + F0(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    502. 

  502. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    503. 

  503. 		tmp = ROLSS(j, aa + F4(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    504. 

  504. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    505. 

  505. 	}
    506. 

  506. 	tmp = b; b = bb; bb = tmp;
    507. 

  507. 

  508. 	for(j = 16; j < 32; j++) {
    509. 

  509. 		tmp = ROLS( j, a  + F1(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    510. 

  510. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    511. 

  511. 		tmp = ROLSS(j, aa + F3(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    512. 

  512. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    513. 

  513. 	}
    514. 

  514. 	tmp = d; d = dd; dd = tmp;
    515. 

  515. 

  516. 	for(j = 32; j < 48; j++) {
    517. 

  517. 		tmp = ROLS( j, a  + F2(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    518. 

  518. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    519. 

  519. 		tmp = ROLSS(j, aa + F2(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    520. 

  520. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    521. 

  521. 	}
    522. 

  522. 	tmp = a; a = aa; aa = tmp;
    523. 

  523. 

  524. 	for(j = 48; j < 64; j++) {
    525. 

  525. 		tmp = ROLS( j, a  + F3(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    526. 

  526. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    527. 

  527. 		tmp = ROLSS(j, aa + F1(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    528. 

  528. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    529. 

  529. 	}
    530. 

  530. 	tmp = c; c = cc; cc = tmp;
    531. 

  531. 

  532. 	for(j = 64; j < 80; j++) {
    533. 

  533. 		tmp = ROLS( j, a  + F4(b,  c,  d)  + x[R[j]]  + K(j)) + e;
    534. 

  534. 		a = e; e = d; d = ROL(10, c); c = b; b = tmp;
    535. 

  535. 		tmp = ROLSS(j, aa + F0(bb, cc, dd) + x[RR[j]] + KK160(j)) + ee;
    536. 

  536. 		aa = ee; ee = dd; dd = ROL(10, cc); cc = bb; bb = tmp;
    537. 

  537. 	}
    538. 

  538. 	tmp = e; e = ee; ee = tmp;
    539. 

  539. 

  540. 	state[0] += a;
    541. 

  541. 	state[1] += b;
    542. 

  542. 	state[2] += c;
    543. 

  543. 	state[3] += d;
    544. 

  544. 	state[4] += e;
    545. 

  545. 	state[5] += aa;
    546. 

  546. 	state[6] += bb;
    547. 

  547. 	state[7] += cc;
    548. 

  548. 	state[8] += dd;
    549. 

  549. 	state[9] += ee;
    550. 

  550. 

  551. 	tmp = 0;
    552. 

  552. 	ZEND_SECURE_ZERO(x, sizeof(x));
    553. 

  553. }
    554. 

  554. /* }}} */
    555. 

  555. 

  556. /* {{{ PHP_RIPEMD320Update
    557. 

  557.    ripemd320 block update operation. Continues a ripemd320 message-digest
    558. 

  558.    operation, processing another message block, and updating the
    559. 

  559.    context.
    560. 

  560.  */
    561. 

  561. PHP_HASH_API void PHP_RIPEMD320Update(PHP_RIPEMD320_CTX * context, const unsigned char *input, size_t inputLen)
    562. 

  562. {
    563. 

  563. 	unsigned int i, index, partLen;
    564. 

  564. 

  565. 	/* Compute number of bytes mod 64 */
    566. 

  566. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
    567. 

  567. 

  568. 	/* Update number of bits */
    569. 

  569. 	if ((context->count[0] += ((uint32_t) inputLen << 3)) < ((uint32_t) inputLen << 3)) {
    570. 

  570. 		context->count[1]++;
    571. 

  571. 	}
    572. 

  572. 	context->count[1] += ((uint32_t) inputLen >> 29);
    573. 

  573. 

  574. 	partLen = 64 - index;
    575. 

  575. 

  576. 	/* Transform as many times as possible.
    577. 

  577. 	 */
    578. 

  578. 	if (inputLen >= partLen) {
    579. 

  579. 		memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
    580. 

  580. 		RIPEMD320Transform(context->state, context->buffer);
    581. 

  581. 

  582. 		for (i = partLen; i + 63 < inputLen; i += 64) {
    583. 

  583. 			RIPEMD320Transform(context->state, &input[i]);
    584. 

  584. 		}
    585. 

  585. 

  586. 		index = 0;
    587. 

  587. 	} else {
    588. 

  588. 		i = 0;
    589. 

  589. 	}
    590. 

  590. 

  591. 	/* Buffer remaining input */
    592. 

  592. 	memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
    593. 

  593. }
    594. 

  594. /* }}} */
    595. 

  595. 

  596. static const unsigned char PADDING[64] =
    597. 

  597. {
    598. 

  598. 	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    599. 

  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. 

  600. 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    601. 

  601. };
    602. 

  602. 

  603. /* {{{ RIPEMDEncode
    604. 

  604.    Encodes input (uint32_t) into output (unsigned char). Assumes len is
    605. 

  605.    a multiple of 4.
    606. 

  606.  */
    607. 

  607. static void RIPEMDEncode(unsigned char *output, uint32_t *input, unsigned int len)
    608. 

  608. {
    609. 

  609. 	unsigned int i, j;
    610. 

  610. 

  611. 	for (i = 0, j = 0; j < len; i++, j += 4) {
    612. 

  612. 		output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
    613. 

  613. 		output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
    614. 

  614. 		output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
    615. 

  615. 		output[j + 0] = (unsigned char) (input[i] & 0xff);
    616. 

  616. 	}
    617. 

  617. }
    618. 

  618. /* }}} */
    619. 

  619. 

  620. /* {{{ PHP_RIPEMD128Final
    621. 

  621.    ripemd128 finalization. Ends a ripemd128 message-digest operation, writing the
    622. 

  622.    the message digest and zeroizing the context.
    623. 

  623.  */
    624. 

  624. PHP_HASH_API void PHP_RIPEMD128Final(unsigned char digest[16], PHP_RIPEMD128_CTX * context)
    625. 

  625. {
    626. 

  626. 	unsigned char bits[8];
    627. 

  627. 	unsigned int index, padLen;
    628. 

  628. 

  629. 	/* Save number of bits */
    630. 

  630. 	bits[0] = (unsigned char) (context->count[0] & 0xFF);
    631. 

  631. 	bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
    632. 

  632. 	bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
    633. 

  633. 	bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
    634. 

  634. 	bits[4] = (unsigned char) (context->count[1] & 0xFF);
    635. 

  635. 	bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
    636. 

  636. 	bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
    637. 

  637. 	bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
    638. 

  638. 

  639. 	/* Pad out to 56 mod 64.
    640. 

  640. 	 */
    641. 

  641. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
    642. 

  642. 	padLen = (index < 56) ? (56 - index) : (120 - index);
    643. 

  643. 	PHP_RIPEMD128Update(context, PADDING, padLen);
    644. 

  644. 

  645. 	/* Append length (before padding) */
    646. 

  646. 	PHP_RIPEMD128Update(context, bits, 8);
    647. 

  647. 

  648. 	/* Store state in digest */
    649. 

  649. 	RIPEMDEncode(digest, context->state, 16);
    650. 

  650. 

  651. 	/* Zeroize sensitive information.
    652. 

  652. 	 */
    653. 

  653. 	ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
    654. 

  654. }
    655. 

  655. /* }}} */
    656. 

  656. 

  657. /* {{{ PHP_RIPEMD256Final
    658. 

  658.    ripemd256 finalization. Ends a ripemd256 message-digest operation, writing the
    659. 

  659.    the message digest and zeroizing the context.
    660. 

  660.  */
    661. 

  661. PHP_HASH_API void PHP_RIPEMD256Final(unsigned char digest[32], PHP_RIPEMD256_CTX * context)
    662. 

  662. {
    663. 

  663. 	unsigned char bits[8];
    664. 

  664. 	unsigned int index, padLen;
    665. 

  665. 

  666. 	/* Save number of bits */
    667. 

  667. 	bits[0] = (unsigned char) (context->count[0] & 0xFF);
    668. 

  668. 	bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
    669. 

  669. 	bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
    670. 

  670. 	bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
    671. 

  671. 	bits[4] = (unsigned char) (context->count[1] & 0xFF);
    672. 

  672. 	bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
    673. 

  673. 	bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
    674. 

  674. 	bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
    675. 

  675. 

  676. 	/* Pad out to 56 mod 64.
    677. 

  677. 	 */
    678. 

  678. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
    679. 

  679. 	padLen = (index < 56) ? (56 - index) : (120 - index);
    680. 

  680. 	PHP_RIPEMD256Update(context, PADDING, padLen);
    681. 

  681. 

  682. 	/* Append length (before padding) */
    683. 

  683. 	PHP_RIPEMD256Update(context, bits, 8);
    684. 

  684. 

  685. 	/* Store state in digest */
    686. 

  686. 	RIPEMDEncode(digest, context->state, 32);
    687. 

  687. 

  688. 	/* Zeroize sensitive information.
    689. 

  689. 	 */
    690. 

  690. 	ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
    691. 

  691. }
    692. 

  692. /* }}} */
    693. 

  693. 

  694. /* {{{ PHP_RIPEMD160Final
    695. 

  695.    ripemd160 finalization. Ends a ripemd160 message-digest operation, writing the
    696. 

  696.    the message digest and zeroizing the context.
    697. 

  697.  */
    698. 

  698. PHP_HASH_API void PHP_RIPEMD160Final(unsigned char digest[20], PHP_RIPEMD160_CTX * context)
    699. 

  699. {
    700. 

  700. 	unsigned char bits[8];
    701. 

  701. 	unsigned int index, padLen;
    702. 

  702. 

  703. 	/* Save number of bits */
    704. 

  704. 	bits[0] = (unsigned char) (context->count[0] & 0xFF);
    705. 

  705. 	bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
    706. 

  706. 	bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
    707. 

  707. 	bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
    708. 

  708. 	bits[4] = (unsigned char) (context->count[1] & 0xFF);
    709. 

  709. 	bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
    710. 

  710. 	bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
    711. 

  711. 	bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
    712. 

  712. 

  713. 	/* Pad out to 56 mod 64.
    714. 

  714. 	 */
    715. 

  715. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
    716. 

  716. 	padLen = (index < 56) ? (56 - index) : (120 - index);
    717. 

  717. 	PHP_RIPEMD160Update(context, PADDING, padLen);
    718. 

  718. 

  719. 	/* Append length (before padding) */
    720. 

  720. 	PHP_RIPEMD160Update(context, bits, 8);
    721. 

  721. 

  722. 	/* Store state in digest */
    723. 

  723. 	RIPEMDEncode(digest, context->state, 20);
    724. 

  724. 

  725. 	/* Zeroize sensitive information.
    726. 

  726. 	 */
    727. 

  727. 	ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
    728. 

  728. }
    729. 

  729. /* }}} */
    730. 

  730. 

  731. /* {{{ PHP_RIPEMD320Final
    732. 

  732.    ripemd320 finalization. Ends a ripemd320 message-digest operation, writing the
    733. 

  733.    the message digest and zeroizing the context.
    734. 

  734.  */
    735. 

  735. PHP_HASH_API void PHP_RIPEMD320Final(unsigned char digest[40], PHP_RIPEMD320_CTX * context)
    736. 

  736. {
    737. 

  737. 	unsigned char bits[8];
    738. 

  738. 	unsigned int index, padLen;
    739. 

  739. 

  740. 	/* Save number of bits */
    741. 

  741. 	bits[0] = (unsigned char) (context->count[0] & 0xFF);
    742. 

  742. 	bits[1] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
    743. 

  743. 	bits[2] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
    744. 

  744. 	bits[3] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
    745. 

  745. 	bits[4] = (unsigned char) (context->count[1] & 0xFF);
    746. 

  746. 	bits[5] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
    747. 

  747. 	bits[6] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
    748. 

  748. 	bits[7] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
    749. 

  749. 

  750. 	/* Pad out to 56 mod 64.
    751. 

  751. 	 */
    752. 

  752. 	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
    753. 

  753. 	padLen = (index < 56) ? (56 - index) : (120 - index);
    754. 

  754. 	PHP_RIPEMD320Update(context, PADDING, padLen);
    755. 

  755. 

  756. 	/* Append length (before padding) */
    757. 

  757. 	PHP_RIPEMD320Update(context, bits, 8);
    758. 

  758. 

  759. 	/* Store state in digest */
    760. 

  760. 	RIPEMDEncode(digest, context->state, 40);
    761. 

  761. 

  762. 	/* Zeroize sensitive information.
    763. 

  763. 	 */
    764. 

  764. 	ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
    765. 

  765. }
    766. 

  766. /* }}} */
    767. 

  767.