1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2014 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 | Authors: Steffan Esser <sesser@php.net> |
16 | Sara Golemon <pollita@php.net> |
17 +----------------------------------------------------------------------+
18 */
19
20 /* $Id$ */
21
22 #include "php_hash.h"
23 #include "php_hash_sha.h"
24
25 static const unsigned char PADDING[128] =
26 {
27 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
28 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
29 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
30 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
31 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
32 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
33 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
34 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
35 };
36
37 /* {{{ SHAEncode32
38 Encodes input (php_hash_uint32) into output (unsigned char). Assumes len is
39 a multiple of 4.
40 */
SHAEncode32(unsigned char * output,php_hash_uint32 * input,unsigned int len)41 static void SHAEncode32(unsigned char *output, php_hash_uint32 *input, unsigned int len)
42 {
43 unsigned int i, j;
44
45 for (i = 0, j = 0; j < len; i++, j += 4) {
46 output[j] = (unsigned char) ((input[i] >> 24) & 0xff);
47 output[j + 1] = (unsigned char) ((input[i] >> 16) & 0xff);
48 output[j + 2] = (unsigned char) ((input[i] >> 8) & 0xff);
49 output[j + 3] = (unsigned char) (input[i] & 0xff);
50 }
51 }
52 /* }}} */
53
54
55 /* {{{ SHADecode32
56 Decodes input (unsigned char) into output (php_hash_uint32). Assumes len is
57 a multiple of 4.
58 */
SHADecode32(php_hash_uint32 * output,const unsigned char * input,unsigned int len)59 static void SHADecode32(php_hash_uint32 *output, const unsigned char *input, unsigned int len)
60 {
61 unsigned int i, j;
62
63 for (i = 0, j = 0; j < len; i++, j += 4)
64 output[i] = ((php_hash_uint32) input[j + 3]) | (((php_hash_uint32) input[j + 2]) << 8) |
65 (((php_hash_uint32) input[j + 1]) << 16) | (((php_hash_uint32) input[j]) << 24);
66 }
67 /* }}} */
68
69 const php_hash_ops php_hash_sha1_ops = {
70 (php_hash_init_func_t) PHP_SHA1Init,
71 (php_hash_update_func_t) PHP_SHA1Update,
72 (php_hash_final_func_t) PHP_SHA1Final,
73 (php_hash_copy_func_t) php_hash_copy,
74 20,
75 64,
76 sizeof(PHP_SHA1_CTX)
77 };
78
79 #ifdef PHP_HASH_SHA1_NOT_IN_CORE
80
make_sha1_digest(char * sha1str,unsigned char * digest)81 PHP_HASH_API void make_sha1_digest(char *sha1str, unsigned char *digest)
82 {
83 php_hash_bin2hex(sha1str, digest, 20);
84 sha1str[40] = '\0';
85 }
86
87 /* {{{ proto string sha1(string str [, bool raw_output])
88 Calculate the sha1 hash of a string */
PHP_FUNCTION(sha1)89 PHP_FUNCTION(sha1)
90 {
91 char *arg;
92 int arg_len;
93 zend_bool raw_output = 0;
94 char sha1str[41];
95 PHP_SHA1_CTX context;
96 unsigned char digest[20];
97
98 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &arg, &arg_len, &raw_output) == FAILURE) {
99 return;
100 }
101
102 sha1str[0] = '\0';
103 PHP_SHA1Init(&context);
104 PHP_SHA1Update(&context, arg, arg_len);
105 PHP_SHA1Final(digest, &context);
106 if (raw_output) {
107 RETURN_STRINGL(digest, 20, 1);
108 } else {
109 make_sha1_digest(sha1str, digest);
110 RETVAL_STRING(sha1str, 1);
111 }
112
113 }
114
115 /* }}} */
116
117 /* {{{ proto string sha1_file(string filename [, bool raw_output])
118 Calculate the sha1 hash of given filename */
PHP_FUNCTION(sha1_file)119 PHP_FUNCTION(sha1_file)
120 {
121 char *arg;
122 int arg_len;
123 zend_bool raw_output = 0;
124 char sha1str[41];
125 unsigned char buf[1024];
126 unsigned char digest[20];
127 PHP_SHA1_CTX context;
128 int n;
129 php_stream *stream;
130
131 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|b", &arg, &arg_len, &raw_output) == FAILURE) {
132 return;
133 }
134
135 stream = php_stream_open_wrapper(arg, "rb", REPORT_ERRORS, NULL);
136 if (!stream) {
137 RETURN_FALSE;
138 }
139
140 PHP_SHA1Init(&context);
141
142 while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
143 PHP_SHA1Update(&context, buf, n);
144 }
145
146 PHP_SHA1Final(digest, &context);
147
148 php_stream_close(stream);
149
150 if (n<0) {
151 RETURN_FALSE;
152 }
153
154 if (raw_output) {
155 RETURN_STRINGL(digest, 20, 1);
156 } else {
157 make_sha1_digest(sha1str, digest);
158 RETVAL_STRING(sha1str, 1);
159 }
160 }
161 /* }}} */
162
163 /* F, G, H and I are basic SHA1 functions.
164 */
165 #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
166 #define G(x, y, z) ((x) ^ (y) ^ (z))
167 #define H(x, y, z) (((x) & (y)) | ((z) & ((x) | (y))))
168 #define I(x, y, z) ((x) ^ (y) ^ (z))
169
170 /* ROTATE_LEFT rotates x left n bits.
171 */
172 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
173
174 /* W[i]
175 */
176 #define W(i) ( tmp=x[(i-3)&15]^x[(i-8)&15]^x[(i-14)&15]^x[i&15], \
177 (x[i&15]=ROTATE_LEFT(tmp, 1)) )
178
179 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
180 */
181 #define FF(a, b, c, d, e, w) { \
182 (e) += F ((b), (c), (d)) + (w) + (php_hash_uint32)(0x5A827999); \
183 (e) += ROTATE_LEFT ((a), 5); \
184 (b) = ROTATE_LEFT((b), 30); \
185 }
186 #define GG(a, b, c, d, e, w) { \
187 (e) += G ((b), (c), (d)) + (w) + (php_hash_uint32)(0x6ED9EBA1); \
188 (e) += ROTATE_LEFT ((a), 5); \
189 (b) = ROTATE_LEFT((b), 30); \
190 }
191 #define HH(a, b, c, d, e, w) { \
192 (e) += H ((b), (c), (d)) + (w) + (php_hash_uint32)(0x8F1BBCDC); \
193 (e) += ROTATE_LEFT ((a), 5); \
194 (b) = ROTATE_LEFT((b), 30); \
195 }
196 #define II(a, b, c, d, e, w) { \
197 (e) += I ((b), (c), (d)) + (w) + (php_hash_uint32)(0xCA62C1D6); \
198 (e) += ROTATE_LEFT ((a), 5); \
199 (b) = ROTATE_LEFT((b), 30); \
200 }
201
202
203 /* {{{ PHP_SHA1Init
204 * SHA1 initialization. Begins an SHA1 operation, writing a new context.
205 */
PHP_SHA1Init(PHP_SHA1_CTX * context)206 PHP_HASH_API void PHP_SHA1Init(PHP_SHA1_CTX * context)
207 {
208 context->count[0] = context->count[1] = 0;
209 /* Load magic initialization constants.
210 */
211 context->state[0] = 0x67452301;
212 context->state[1] = 0xefcdab89;
213 context->state[2] = 0x98badcfe;
214 context->state[3] = 0x10325476;
215 context->state[4] = 0xc3d2e1f0;
216 }
217 /* }}} */
218
219 /* {{{ SHA1Transform
220 * SHA1 basic transformation. Transforms state based on block.
221 */
SHA1Transform(php_hash_uint32 state[5],const unsigned char block[64])222 static void SHA1Transform(php_hash_uint32 state[5], const unsigned char block[64])
223 {
224 php_hash_uint32 a = state[0], b = state[1], c = state[2];
225 php_hash_uint32 d = state[3], e = state[4], x[16], tmp;
226
227 SHADecode32(x, block, 64);
228
229 /* Round 1 */
230 FF(a, b, c, d, e, x[0]); /* 1 */
231 FF(e, a, b, c, d, x[1]); /* 2 */
232 FF(d, e, a, b, c, x[2]); /* 3 */
233 FF(c, d, e, a, b, x[3]); /* 4 */
234 FF(b, c, d, e, a, x[4]); /* 5 */
235 FF(a, b, c, d, e, x[5]); /* 6 */
236 FF(e, a, b, c, d, x[6]); /* 7 */
237 FF(d, e, a, b, c, x[7]); /* 8 */
238 FF(c, d, e, a, b, x[8]); /* 9 */
239 FF(b, c, d, e, a, x[9]); /* 10 */
240 FF(a, b, c, d, e, x[10]); /* 11 */
241 FF(e, a, b, c, d, x[11]); /* 12 */
242 FF(d, e, a, b, c, x[12]); /* 13 */
243 FF(c, d, e, a, b, x[13]); /* 14 */
244 FF(b, c, d, e, a, x[14]); /* 15 */
245 FF(a, b, c, d, e, x[15]); /* 16 */
246 FF(e, a, b, c, d, W(16)); /* 17 */
247 FF(d, e, a, b, c, W(17)); /* 18 */
248 FF(c, d, e, a, b, W(18)); /* 19 */
249 FF(b, c, d, e, a, W(19)); /* 20 */
250
251 /* Round 2 */
252 GG(a, b, c, d, e, W(20)); /* 21 */
253 GG(e, a, b, c, d, W(21)); /* 22 */
254 GG(d, e, a, b, c, W(22)); /* 23 */
255 GG(c, d, e, a, b, W(23)); /* 24 */
256 GG(b, c, d, e, a, W(24)); /* 25 */
257 GG(a, b, c, d, e, W(25)); /* 26 */
258 GG(e, a, b, c, d, W(26)); /* 27 */
259 GG(d, e, a, b, c, W(27)); /* 28 */
260 GG(c, d, e, a, b, W(28)); /* 29 */
261 GG(b, c, d, e, a, W(29)); /* 30 */
262 GG(a, b, c, d, e, W(30)); /* 31 */
263 GG(e, a, b, c, d, W(31)); /* 32 */
264 GG(d, e, a, b, c, W(32)); /* 33 */
265 GG(c, d, e, a, b, W(33)); /* 34 */
266 GG(b, c, d, e, a, W(34)); /* 35 */
267 GG(a, b, c, d, e, W(35)); /* 36 */
268 GG(e, a, b, c, d, W(36)); /* 37 */
269 GG(d, e, a, b, c, W(37)); /* 38 */
270 GG(c, d, e, a, b, W(38)); /* 39 */
271 GG(b, c, d, e, a, W(39)); /* 40 */
272
273 /* Round 3 */
274 HH(a, b, c, d, e, W(40)); /* 41 */
275 HH(e, a, b, c, d, W(41)); /* 42 */
276 HH(d, e, a, b, c, W(42)); /* 43 */
277 HH(c, d, e, a, b, W(43)); /* 44 */
278 HH(b, c, d, e, a, W(44)); /* 45 */
279 HH(a, b, c, d, e, W(45)); /* 46 */
280 HH(e, a, b, c, d, W(46)); /* 47 */
281 HH(d, e, a, b, c, W(47)); /* 48 */
282 HH(c, d, e, a, b, W(48)); /* 49 */
283 HH(b, c, d, e, a, W(49)); /* 50 */
284 HH(a, b, c, d, e, W(50)); /* 51 */
285 HH(e, a, b, c, d, W(51)); /* 52 */
286 HH(d, e, a, b, c, W(52)); /* 53 */
287 HH(c, d, e, a, b, W(53)); /* 54 */
288 HH(b, c, d, e, a, W(54)); /* 55 */
289 HH(a, b, c, d, e, W(55)); /* 56 */
290 HH(e, a, b, c, d, W(56)); /* 57 */
291 HH(d, e, a, b, c, W(57)); /* 58 */
292 HH(c, d, e, a, b, W(58)); /* 59 */
293 HH(b, c, d, e, a, W(59)); /* 60 */
294
295 /* Round 4 */
296 II(a, b, c, d, e, W(60)); /* 61 */
297 II(e, a, b, c, d, W(61)); /* 62 */
298 II(d, e, a, b, c, W(62)); /* 63 */
299 II(c, d, e, a, b, W(63)); /* 64 */
300 II(b, c, d, e, a, W(64)); /* 65 */
301 II(a, b, c, d, e, W(65)); /* 66 */
302 II(e, a, b, c, d, W(66)); /* 67 */
303 II(d, e, a, b, c, W(67)); /* 68 */
304 II(c, d, e, a, b, W(68)); /* 69 */
305 II(b, c, d, e, a, W(69)); /* 70 */
306 II(a, b, c, d, e, W(70)); /* 71 */
307 II(e, a, b, c, d, W(71)); /* 72 */
308 II(d, e, a, b, c, W(72)); /* 73 */
309 II(c, d, e, a, b, W(73)); /* 74 */
310 II(b, c, d, e, a, W(74)); /* 75 */
311 II(a, b, c, d, e, W(75)); /* 76 */
312 II(e, a, b, c, d, W(76)); /* 77 */
313 II(d, e, a, b, c, W(77)); /* 78 */
314 II(c, d, e, a, b, W(78)); /* 79 */
315 II(b, c, d, e, a, W(79)); /* 80 */
316
317 state[0] += a;
318 state[1] += b;
319 state[2] += c;
320 state[3] += d;
321 state[4] += e;
322
323 /* Zeroize sensitive information. */
324 memset((unsigned char*) x, 0, sizeof(x));
325 }
326 /* }}} */
327
328 /* {{{ PHP_SHA1Update
329 SHA1 block update operation. Continues an SHA1 message-digest
330 operation, processing another message block, and updating the
331 context.
332 */
PHP_SHA1Update(PHP_SHA1_CTX * context,const unsigned char * input,unsigned int inputLen)333 PHP_HASH_API void PHP_SHA1Update(PHP_SHA1_CTX * context, const unsigned char *input,
334 unsigned int inputLen)
335 {
336 unsigned int i, index, partLen;
337
338 /* Compute number of bytes mod 64 */
339 index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
340
341 /* Update number of bits */
342 if ((context->count[0] += ((php_hash_uint32) inputLen << 3))
343 < ((php_hash_uint32) inputLen << 3))
344 context->count[1]++;
345 context->count[1] += ((php_hash_uint32) inputLen >> 29);
346
347 partLen = 64 - index;
348
349 /* Transform as many times as possible.
350 */
351 if (inputLen >= partLen) {
352 memcpy
353 ((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
354 SHA1Transform(context->state, context->buffer);
355
356 for (i = partLen; i + 63 < inputLen; i += 64)
357 SHA1Transform(context->state, &input[i]);
358
359 index = 0;
360 } else
361 i = 0;
362
363 /* Buffer remaining input */
364 memcpy
365 ((unsigned char*) & context->buffer[index], (unsigned char*) & input[i],
366 inputLen - i);
367 }
368 /* }}} */
369
370 /* {{{ PHP_SHA1Final
371 SHA1 finalization. Ends an SHA1 message-digest operation, writing the
372 the message digest and zeroizing the context.
373 */
PHP_SHA1Final(unsigned char digest[20],PHP_SHA1_CTX * context)374 PHP_HASH_API void PHP_SHA1Final(unsigned char digest[20], PHP_SHA1_CTX * context)
375 {
376 unsigned char bits[8];
377 unsigned int index, padLen;
378
379 /* Save number of bits */
380 bits[7] = context->count[0] & 0xFF;
381 bits[6] = (context->count[0] >> 8) & 0xFF;
382 bits[5] = (context->count[0] >> 16) & 0xFF;
383 bits[4] = (context->count[0] >> 24) & 0xFF;
384 bits[3] = context->count[1] & 0xFF;
385 bits[2] = (context->count[1] >> 8) & 0xFF;
386 bits[1] = (context->count[1] >> 16) & 0xFF;
387 bits[0] = (context->count[1] >> 24) & 0xFF;
388
389 /* Pad out to 56 mod 64.
390 */
391 index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
392 padLen = (index < 56) ? (56 - index) : (120 - index);
393 PHP_SHA1Update(context, PADDING, padLen);
394
395 /* Append length (before padding) */
396 PHP_SHA1Update(context, bits, 8);
397
398 /* Store state in digest */
399 SHAEncode32(digest, context->state, 20);
400
401 /* Zeroize sensitive information.
402 */
403 memset((unsigned char*) context, 0, sizeof(*context));
404 }
405 /* }}} */
406
407 #endif /* PHP_HASH_SHA1_NOT_IN_CORE */
408
409 /* sha224/sha256 */
410
411 const php_hash_ops php_hash_sha256_ops = {
412 (php_hash_init_func_t) PHP_SHA256Init,
413 (php_hash_update_func_t) PHP_SHA256Update,
414 (php_hash_final_func_t) PHP_SHA256Final,
415 (php_hash_copy_func_t) php_hash_copy,
416 32,
417 64,
418 sizeof(PHP_SHA256_CTX)
419 };
420
421 const php_hash_ops php_hash_sha224_ops = {
422 (php_hash_init_func_t) PHP_SHA224Init,
423 (php_hash_update_func_t) PHP_SHA224Update,
424 (php_hash_final_func_t) PHP_SHA224Final,
425 (php_hash_copy_func_t) php_hash_copy,
426 28,
427 64,
428 sizeof(PHP_SHA224_CTX)
429 };
430
431 #define ROTR32(b,x) ((x >> b) | (x << (32 - b)))
432 #define ROTR64(b,x) ((x >> b) | (x << (64 - b)))
433 #define SHR(b, x) (x >> b)
434
435 /* Ch */
436 #define SHA256_F0(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
437 /* Maj */
438 #define SHA256_F1(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
439 /* SUM0 */
440 #define SHA256_F2(x) (ROTR32( 2,(x)) ^ ROTR32(13,(x)) ^ ROTR32(22,(x)))
441 /* SUM1 */
442 #define SHA256_F3(x) (ROTR32( 6,(x)) ^ ROTR32(11,(x)) ^ ROTR32(25,(x)))
443 /* OM0 */
444 #define SHA256_F4(x) (ROTR32( 7,(x)) ^ ROTR32(18,(x)) ^ SHR( 3,(x)))
445 /* OM1 */
446 #define SHA256_F5(x) (ROTR32(17,(x)) ^ ROTR32(19,(x)) ^ SHR(10,(x)))
447
448 static const php_hash_uint32 SHA256_K[64] = {
449 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
450 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
451 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
452 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
453 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
454 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
455 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
456 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
457
458 /* {{{ PHP_SHA256Init
459 * SHA256 initialization. Begins an SHA256 operation, writing a new context.
460 */
PHP_SHA256Init(PHP_SHA256_CTX * context)461 PHP_HASH_API void PHP_SHA256Init(PHP_SHA256_CTX * context)
462 {
463 context->count[0] = context->count[1] = 0;
464 /* Load magic initialization constants.
465 */
466 context->state[0] = 0x6a09e667;
467 context->state[1] = 0xbb67ae85;
468 context->state[2] = 0x3c6ef372;
469 context->state[3] = 0xa54ff53a;
470 context->state[4] = 0x510e527f;
471 context->state[5] = 0x9b05688c;
472 context->state[6] = 0x1f83d9ab;
473 context->state[7] = 0x5be0cd19;
474 }
475 /* }}} */
476
477 /* {{{ SHA256Transform
478 * SHA256 basic transformation. Transforms state based on block.
479 */
SHA256Transform(php_hash_uint32 state[8],const unsigned char block[64])480 static void SHA256Transform(php_hash_uint32 state[8], const unsigned char block[64])
481 {
482 php_hash_uint32 a = state[0], b = state[1], c = state[2], d = state[3];
483 php_hash_uint32 e = state[4], f = state[5], g = state[6], h = state[7];
484 php_hash_uint32 x[16], T1, T2, W[64];
485 int i;
486
487 SHADecode32(x, block, 64);
488
489 /* Schedule */
490 for(i = 0; i < 16; i++) {
491 W[i] = x[i];
492 }
493 for(i = 16; i < 64; i++) {
494 W[i] = SHA256_F5(W[i-2]) + W[i-7] + SHA256_F4(W[i-15]) + W[i-16];
495 }
496
497 for (i = 0; i < 64; i++) {
498 T1 = h + SHA256_F3(e) + SHA256_F0(e,f,g) + SHA256_K[i] + W[i];
499 T2 = SHA256_F2(a) + SHA256_F1(a,b,c);
500 h = g; g = f; f = e; e = d + T1;
501 d = c; c = b; b = a; a = T1 + T2;
502 }
503
504 state[0] += a;
505 state[1] += b;
506 state[2] += c;
507 state[3] += d;
508 state[4] += e;
509 state[5] += f;
510 state[6] += g;
511 state[7] += h;
512
513 /* Zeroize sensitive information. */
514 memset((unsigned char*) x, 0, sizeof(x));
515 }
516 /* }}} */
517
518 /* {{{ PHP_SHA224Init
519 * SHA224 initialization. Begins an SHA224 operation, writing a new context.
520 */
PHP_SHA224Init(PHP_SHA224_CTX * context)521 PHP_HASH_API void PHP_SHA224Init(PHP_SHA224_CTX * context)
522 {
523 context->count[0] = context->count[1] = 0;
524 /* Load magic initialization constants.
525 */
526 context->state[0] = 0xc1059ed8;
527 context->state[1] = 0x367cd507;
528 context->state[2] = 0x3070dd17;
529 context->state[3] = 0xf70e5939;
530 context->state[4] = 0xffc00b31;
531 context->state[5] = 0x68581511;
532 context->state[6] = 0x64f98fa7;
533 context->state[7] = 0xbefa4fa4;
534 }
535 /* }}} */
536
537 /* {{{ PHP_SHA224Update
538 SHA224 block update operation. Continues an SHA224 message-digest
539 operation, processing another message block, and updating the
540 context.
541 */
PHP_SHA224Update(PHP_SHA224_CTX * context,const unsigned char * input,unsigned int inputLen)542 PHP_HASH_API void PHP_SHA224Update(PHP_SHA224_CTX * context, const unsigned char *input, unsigned int inputLen)
543 {
544 unsigned int i, index, partLen;
545
546 /* Compute number of bytes mod 64 */
547 index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
548
549 /* Update number of bits */
550 if ((context->count[0] += ((php_hash_uint32) inputLen << 3)) < ((php_hash_uint32) inputLen << 3)) {
551 context->count[1]++;
552 }
553 context->count[1] += ((php_hash_uint32) inputLen >> 29);
554
555 partLen = 64 - index;
556
557 /* Transform as many times as possible.
558 */
559 if (inputLen >= partLen) {
560 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
561 SHA256Transform(context->state, context->buffer);
562
563 for (i = partLen; i + 63 < inputLen; i += 64) {
564 SHA256Transform(context->state, &input[i]);
565 }
566
567 index = 0;
568 } else {
569 i = 0;
570 }
571
572 /* Buffer remaining input */
573 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
574 }
575 /* }}} */
576
577 /* {{{ PHP_SHA224Final
578 SHA224 finalization. Ends an SHA224 message-digest operation, writing the
579 the message digest and zeroizing the context.
580 */
PHP_SHA224Final(unsigned char digest[28],PHP_SHA224_CTX * context)581 PHP_HASH_API void PHP_SHA224Final(unsigned char digest[28], PHP_SHA224_CTX * context)
582 {
583 unsigned char bits[8];
584 unsigned int index, padLen;
585
586 /* Save number of bits */
587 bits[7] = (unsigned char) (context->count[0] & 0xFF);
588 bits[6] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
589 bits[5] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
590 bits[4] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
591 bits[3] = (unsigned char) (context->count[1] & 0xFF);
592 bits[2] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
593 bits[1] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
594 bits[0] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
595
596 /* Pad out to 56 mod 64.
597 */
598 index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
599 padLen = (index < 56) ? (56 - index) : (120 - index);
600 PHP_SHA224Update(context, PADDING, padLen);
601
602 /* Append length (before padding) */
603 PHP_SHA224Update(context, bits, 8);
604
605 /* Store state in digest */
606 SHAEncode32(digest, context->state, 28);
607
608 /* Zeroize sensitive information.
609 */
610 memset((unsigned char*) context, 0, sizeof(*context));
611 }
612 /* }}} */
613
614 /* {{{ PHP_SHA256Update
615 SHA256 block update operation. Continues an SHA256 message-digest
616 operation, processing another message block, and updating the
617 context.
618 */
PHP_SHA256Update(PHP_SHA256_CTX * context,const unsigned char * input,unsigned int inputLen)619 PHP_HASH_API void PHP_SHA256Update(PHP_SHA256_CTX * context, const unsigned char *input, unsigned int inputLen)
620 {
621 unsigned int i, index, partLen;
622
623 /* Compute number of bytes mod 64 */
624 index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
625
626 /* Update number of bits */
627 if ((context->count[0] += ((php_hash_uint32) inputLen << 3)) < ((php_hash_uint32) inputLen << 3)) {
628 context->count[1]++;
629 }
630 context->count[1] += ((php_hash_uint32) inputLen >> 29);
631
632 partLen = 64 - index;
633
634 /* Transform as many times as possible.
635 */
636 if (inputLen >= partLen) {
637 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
638 SHA256Transform(context->state, context->buffer);
639
640 for (i = partLen; i + 63 < inputLen; i += 64) {
641 SHA256Transform(context->state, &input[i]);
642 }
643
644 index = 0;
645 } else {
646 i = 0;
647 }
648
649 /* Buffer remaining input */
650 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
651 }
652 /* }}} */
653
654 /* {{{ PHP_SHA256Final
655 SHA256 finalization. Ends an SHA256 message-digest operation, writing the
656 the message digest and zeroizing the context.
657 */
PHP_SHA256Final(unsigned char digest[32],PHP_SHA256_CTX * context)658 PHP_HASH_API void PHP_SHA256Final(unsigned char digest[32], PHP_SHA256_CTX * context)
659 {
660 unsigned char bits[8];
661 unsigned int index, padLen;
662
663 /* Save number of bits */
664 bits[7] = (unsigned char) (context->count[0] & 0xFF);
665 bits[6] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
666 bits[5] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
667 bits[4] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
668 bits[3] = (unsigned char) (context->count[1] & 0xFF);
669 bits[2] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
670 bits[1] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
671 bits[0] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
672
673 /* Pad out to 56 mod 64.
674 */
675 index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
676 padLen = (index < 56) ? (56 - index) : (120 - index);
677 PHP_SHA256Update(context, PADDING, padLen);
678
679 /* Append length (before padding) */
680 PHP_SHA256Update(context, bits, 8);
681
682 /* Store state in digest */
683 SHAEncode32(digest, context->state, 32);
684
685 /* Zeroize sensitive information.
686 */
687 memset((unsigned char*) context, 0, sizeof(*context));
688 }
689 /* }}} */
690
691 /* sha384/sha512 */
692
693 /* Ch */
694 #define SHA512_F0(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
695 /* Maj */
696 #define SHA512_F1(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
697 /* SUM0 */
698 #define SHA512_F2(x) (ROTR64(28, x) ^ ROTR64(34, x) ^ ROTR64(39, x))
699 /* SUM1 */
700 #define SHA512_F3(x) (ROTR64(14, x) ^ ROTR64(18, x) ^ ROTR64(41, x))
701 /* OM0 */
702 #define SHA512_F4(x) (ROTR64( 1, x) ^ ROTR64( 8, x) ^ SHR(7, x))
703 /* OM1 */
704 #define SHA512_F5(x) (ROTR64(19, x) ^ ROTR64(61, x) ^ SHR(6, x))
705
706 static const php_hash_uint64 SHA512_K[128] = {
707 L64(0x428a2f98d728ae22), L64(0x7137449123ef65cd), L64(0xb5c0fbcfec4d3b2f), L64(0xe9b5dba58189dbbc),
708 L64(0x3956c25bf348b538), L64(0x59f111f1b605d019), L64(0x923f82a4af194f9b), L64(0xab1c5ed5da6d8118),
709 L64(0xd807aa98a3030242), L64(0x12835b0145706fbe), L64(0x243185be4ee4b28c), L64(0x550c7dc3d5ffb4e2),
710 L64(0x72be5d74f27b896f), L64(0x80deb1fe3b1696b1), L64(0x9bdc06a725c71235), L64(0xc19bf174cf692694),
711 L64(0xe49b69c19ef14ad2), L64(0xefbe4786384f25e3), L64(0x0fc19dc68b8cd5b5), L64(0x240ca1cc77ac9c65),
712 L64(0x2de92c6f592b0275), L64(0x4a7484aa6ea6e483), L64(0x5cb0a9dcbd41fbd4), L64(0x76f988da831153b5),
713 L64(0x983e5152ee66dfab), L64(0xa831c66d2db43210), L64(0xb00327c898fb213f), L64(0xbf597fc7beef0ee4),
714 L64(0xc6e00bf33da88fc2), L64(0xd5a79147930aa725), L64(0x06ca6351e003826f), L64(0x142929670a0e6e70),
715 L64(0x27b70a8546d22ffc), L64(0x2e1b21385c26c926), L64(0x4d2c6dfc5ac42aed), L64(0x53380d139d95b3df),
716 L64(0x650a73548baf63de), L64(0x766a0abb3c77b2a8), L64(0x81c2c92e47edaee6), L64(0x92722c851482353b),
717 L64(0xa2bfe8a14cf10364), L64(0xa81a664bbc423001), L64(0xc24b8b70d0f89791), L64(0xc76c51a30654be30),
718 L64(0xd192e819d6ef5218), L64(0xd69906245565a910), L64(0xf40e35855771202a), L64(0x106aa07032bbd1b8),
719 L64(0x19a4c116b8d2d0c8), L64(0x1e376c085141ab53), L64(0x2748774cdf8eeb99), L64(0x34b0bcb5e19b48a8),
720 L64(0x391c0cb3c5c95a63), L64(0x4ed8aa4ae3418acb), L64(0x5b9cca4f7763e373), L64(0x682e6ff3d6b2b8a3),
721 L64(0x748f82ee5defb2fc), L64(0x78a5636f43172f60), L64(0x84c87814a1f0ab72), L64(0x8cc702081a6439ec),
722 L64(0x90befffa23631e28), L64(0xa4506cebde82bde9), L64(0xbef9a3f7b2c67915), L64(0xc67178f2e372532b),
723 L64(0xca273eceea26619c), L64(0xd186b8c721c0c207), L64(0xeada7dd6cde0eb1e), L64(0xf57d4f7fee6ed178),
724 L64(0x06f067aa72176fba), L64(0x0a637dc5a2c898a6), L64(0x113f9804bef90dae), L64(0x1b710b35131c471b),
725 L64(0x28db77f523047d84), L64(0x32caab7b40c72493), L64(0x3c9ebe0a15c9bebc), L64(0x431d67c49c100d4c),
726 L64(0x4cc5d4becb3e42b6), L64(0x597f299cfc657e2a), L64(0x5fcb6fab3ad6faec), L64(0x6c44198c4a475817) };
727
728 /* {{{ SHAEncode64
729 Encodes input (php_hash_uint64) into output (unsigned char). Assumes len is
730 a multiple of 8.
731 */
SHAEncode64(unsigned char * output,php_hash_uint64 * input,unsigned int len)732 static void SHAEncode64(unsigned char *output, php_hash_uint64 *input, unsigned int len)
733 {
734 unsigned int i, j;
735
736 for (i = 0, j = 0; j < len; i++, j += 8) {
737 output[j] = (unsigned char) ((input[i] >> 56) & 0xff);
738 output[j + 1] = (unsigned char) ((input[i] >> 48) & 0xff);
739 output[j + 2] = (unsigned char) ((input[i] >> 40) & 0xff);
740 output[j + 3] = (unsigned char) ((input[i] >> 32) & 0xff);
741 output[j + 4] = (unsigned char) ((input[i] >> 24) & 0xff);
742 output[j + 5] = (unsigned char) ((input[i] >> 16) & 0xff);
743 output[j + 6] = (unsigned char) ((input[i] >> 8) & 0xff);
744 output[j + 7] = (unsigned char) (input[i] & 0xff);
745 }
746 }
747 /* }}} */
748
749
750 /* {{{ SHADecode64
751 Decodes input (unsigned char) into output (php_hash_uint64). Assumes len is
752 a multiple of 8.
753 */
SHADecode64(php_hash_uint64 * output,const unsigned char * input,unsigned int len)754 static void SHADecode64(php_hash_uint64 *output, const unsigned char *input, unsigned int len)
755 {
756 unsigned int i, j;
757
758 for (i = 0, j = 0; j < len; i++, j += 8)
759 output[i] =
760 ((php_hash_uint64) input[j + 7]) | (((php_hash_uint64) input[j + 6]) << 8) |
761 (((php_hash_uint64) input[j + 5]) << 16) | (((php_hash_uint64) input[j + 4]) << 24) |
762 (((php_hash_uint64) input[j + 3]) << 32) | (((php_hash_uint64) input[j + 2]) << 40) |
763 (((php_hash_uint64) input[j + 1]) << 48) | (((php_hash_uint64) input[j]) << 56);
764 }
765 /* }}} */
766
767 /* {{{ PHP_SHA384Init
768 * SHA384 initialization. Begins an SHA384 operation, writing a new context.
769 */
PHP_SHA384Init(PHP_SHA384_CTX * context)770 PHP_HASH_API void PHP_SHA384Init(PHP_SHA384_CTX * context)
771 {
772 context->count[0] = context->count[1] = 0;
773 /* Load magic initialization constants.
774 */
775 context->state[0] = L64(0xcbbb9d5dc1059ed8);
776 context->state[1] = L64(0x629a292a367cd507);
777 context->state[2] = L64(0x9159015a3070dd17);
778 context->state[3] = L64(0x152fecd8f70e5939);
779 context->state[4] = L64(0x67332667ffc00b31);
780 context->state[5] = L64(0x8eb44a8768581511);
781 context->state[6] = L64(0xdb0c2e0d64f98fa7);
782 context->state[7] = L64(0x47b5481dbefa4fa4);
783 }
784 /* }}} */
785
786 /* {{{ SHA512Transform
787 * SHA512 basic transformation. Transforms state based on block.
788 * SHA384 uses the exact same algorithm
789 */
SHA512Transform(php_hash_uint64 state[8],const unsigned char block[128])790 static void SHA512Transform(php_hash_uint64 state[8], const unsigned char block[128])
791 {
792 php_hash_uint64 a = state[0], b = state[1], c = state[2], d = state[3];
793 php_hash_uint64 e = state[4], f = state[5], g = state[6], h = state[7];
794 php_hash_uint64 x[16], T1, T2, W[80];
795 int i;
796
797 SHADecode64(x, block, 128);
798
799 /* Schedule */
800 for(i = 0; i < 16; i++) {
801 W[i] = x[i];
802 }
803 for(i = 16; i < 80; i++) {
804 W[i] = SHA512_F5(W[i-2]) + W[i-7] + SHA512_F4(W[i-15]) + W[i-16];
805 }
806
807 for (i = 0; i < 80; i++) {
808 T1 = h + SHA512_F3(e) + SHA512_F0(e,f,g) + SHA512_K[i] + W[i];
809 T2 = SHA512_F2(a) + SHA512_F1(a,b,c);
810 h = g; g = f; f = e; e = d + T1;
811 d = c; c = b; b = a; a = T1 + T2;
812 }
813
814 state[0] += a;
815 state[1] += b;
816 state[2] += c;
817 state[3] += d;
818 state[4] += e;
819 state[5] += f;
820 state[6] += g;
821 state[7] += h;
822
823 /* Zeroize sensitive information. */
824 memset((unsigned char*) x, 0, sizeof(x));
825 }
826 /* }}} */
827
828 /* {{{ PHP_SHA384Update
829 SHA384 block update operation. Continues an SHA384 message-digest
830 operation, processing another message block, and updating the
831 context.
832 */
PHP_SHA384Update(PHP_SHA384_CTX * context,const unsigned char * input,unsigned int inputLen)833 PHP_HASH_API void PHP_SHA384Update(PHP_SHA384_CTX * context, const unsigned char *input, unsigned int inputLen)
834 {
835 unsigned int i, index, partLen;
836
837 /* Compute number of bytes mod 128 */
838 index = (unsigned int) ((context->count[0] >> 3) & 0x7F);
839
840 /* Update number of bits */
841 if ((context->count[0] += ((php_hash_uint64) inputLen << 3)) < ((php_hash_uint64) inputLen << 3)) {
842 context->count[1]++;
843 }
844 context->count[1] += ((php_hash_uint64) inputLen >> 61);
845
846 partLen = 128 - index;
847
848 /* Transform as many times as possible.
849 */
850 if (inputLen >= partLen) {
851 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
852 SHA512Transform(context->state, context->buffer);
853
854 for (i = partLen; i + 127 < inputLen; i += 128) {
855 SHA512Transform(context->state, &input[i]);
856 }
857
858 index = 0;
859 } else {
860 i = 0;
861 }
862
863 /* Buffer remaining input */
864 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
865 }
866 /* }}} */
867
868 /* {{{ PHP_SHA384Final
869 SHA384 finalization. Ends an SHA384 message-digest operation, writing the
870 the message digest and zeroizing the context.
871 */
PHP_SHA384Final(unsigned char digest[48],PHP_SHA384_CTX * context)872 PHP_HASH_API void PHP_SHA384Final(unsigned char digest[48], PHP_SHA384_CTX * context)
873 {
874 unsigned char bits[16];
875 unsigned int index, padLen;
876
877 /* Save number of bits */
878 bits[15] = (unsigned char) (context->count[0] & 0xFF);
879 bits[14] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
880 bits[13] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
881 bits[12] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
882 bits[11] = (unsigned char) ((context->count[0] >> 32) & 0xFF);
883 bits[10] = (unsigned char) ((context->count[0] >> 40) & 0xFF);
884 bits[9] = (unsigned char) ((context->count[0] >> 48) & 0xFF);
885 bits[8] = (unsigned char) ((context->count[0] >> 56) & 0xFF);
886 bits[7] = (unsigned char) (context->count[1] & 0xFF);
887 bits[6] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
888 bits[5] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
889 bits[4] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
890 bits[3] = (unsigned char) ((context->count[1] >> 32) & 0xFF);
891 bits[2] = (unsigned char) ((context->count[1] >> 40) & 0xFF);
892 bits[1] = (unsigned char) ((context->count[1] >> 48) & 0xFF);
893 bits[0] = (unsigned char) ((context->count[1] >> 56) & 0xFF);
894
895 /* Pad out to 112 mod 128.
896 */
897 index = (unsigned int) ((context->count[0] >> 3) & 0x7f);
898 padLen = (index < 112) ? (112 - index) : (240 - index);
899 PHP_SHA384Update(context, PADDING, padLen);
900
901 /* Append length (before padding) */
902 PHP_SHA384Update(context, bits, 16);
903
904 /* Store state in digest */
905 SHAEncode64(digest, context->state, 48);
906
907 /* Zeroize sensitive information.
908 */
909 memset((unsigned char*) context, 0, sizeof(*context));
910 }
911 /* }}} */
912
913 const php_hash_ops php_hash_sha384_ops = {
914 (php_hash_init_func_t) PHP_SHA384Init,
915 (php_hash_update_func_t) PHP_SHA384Update,
916 (php_hash_final_func_t) PHP_SHA384Final,
917 (php_hash_copy_func_t) php_hash_copy,
918 48,
919 128,
920 sizeof(PHP_SHA384_CTX)
921 };
922
923 /* {{{ PHP_SHA512Init
924 * SHA512 initialization. Begins an SHA512 operation, writing a new context.
925 */
PHP_SHA512Init(PHP_SHA512_CTX * context)926 PHP_HASH_API void PHP_SHA512Init(PHP_SHA512_CTX * context)
927 {
928 context->count[0] = context->count[1] = 0;
929 /* Load magic initialization constants.
930 */
931 context->state[0] = L64(0x6a09e667f3bcc908);
932 context->state[1] = L64(0xbb67ae8584caa73b);
933 context->state[2] = L64(0x3c6ef372fe94f82b);
934 context->state[3] = L64(0xa54ff53a5f1d36f1);
935 context->state[4] = L64(0x510e527fade682d1);
936 context->state[5] = L64(0x9b05688c2b3e6c1f);
937 context->state[6] = L64(0x1f83d9abfb41bd6b);
938 context->state[7] = L64(0x5be0cd19137e2179);
939 }
940 /* }}} */
941
942 /* {{{ PHP_SHA512Update
943 SHA512 block update operation. Continues an SHA512 message-digest
944 operation, processing another message block, and updating the
945 context.
946 */
PHP_SHA512Update(PHP_SHA512_CTX * context,const unsigned char * input,unsigned int inputLen)947 PHP_HASH_API void PHP_SHA512Update(PHP_SHA512_CTX * context, const unsigned char *input, unsigned int inputLen)
948 {
949 unsigned int i, index, partLen;
950
951 /* Compute number of bytes mod 128 */
952 index = (unsigned int) ((context->count[0] >> 3) & 0x7F);
953
954 /* Update number of bits */
955 if ((context->count[0] += ((php_hash_uint64) inputLen << 3)) < ((php_hash_uint64) inputLen << 3)) {
956 context->count[1]++;
957 }
958 context->count[1] += ((php_hash_uint64) inputLen >> 61);
959
960 partLen = 128 - index;
961
962 /* Transform as many times as possible.
963 */
964 if (inputLen >= partLen) {
965 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
966 SHA512Transform(context->state, context->buffer);
967
968 for (i = partLen; i + 127 < inputLen; i += 128) {
969 SHA512Transform(context->state, &input[i]);
970 }
971
972 index = 0;
973 } else {
974 i = 0;
975 }
976
977 /* Buffer remaining input */
978 memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
979 }
980 /* }}} */
981
982 /* {{{ PHP_SHA512Final
983 SHA512 finalization. Ends an SHA512 message-digest operation, writing the
984 the message digest and zeroizing the context.
985 */
PHP_SHA512Final(unsigned char digest[64],PHP_SHA512_CTX * context)986 PHP_HASH_API void PHP_SHA512Final(unsigned char digest[64], PHP_SHA512_CTX * context)
987 {
988 unsigned char bits[16];
989 unsigned int index, padLen;
990
991 /* Save number of bits */
992 bits[15] = (unsigned char) (context->count[0] & 0xFF);
993 bits[14] = (unsigned char) ((context->count[0] >> 8) & 0xFF);
994 bits[13] = (unsigned char) ((context->count[0] >> 16) & 0xFF);
995 bits[12] = (unsigned char) ((context->count[0] >> 24) & 0xFF);
996 bits[11] = (unsigned char) ((context->count[0] >> 32) & 0xFF);
997 bits[10] = (unsigned char) ((context->count[0] >> 40) & 0xFF);
998 bits[9] = (unsigned char) ((context->count[0] >> 48) & 0xFF);
999 bits[8] = (unsigned char) ((context->count[0] >> 56) & 0xFF);
1000 bits[7] = (unsigned char) (context->count[1] & 0xFF);
1001 bits[6] = (unsigned char) ((context->count[1] >> 8) & 0xFF);
1002 bits[5] = (unsigned char) ((context->count[1] >> 16) & 0xFF);
1003 bits[4] = (unsigned char) ((context->count[1] >> 24) & 0xFF);
1004 bits[3] = (unsigned char) ((context->count[1] >> 32) & 0xFF);
1005 bits[2] = (unsigned char) ((context->count[1] >> 40) & 0xFF);
1006 bits[1] = (unsigned char) ((context->count[1] >> 48) & 0xFF);
1007 bits[0] = (unsigned char) ((context->count[1] >> 56) & 0xFF);
1008
1009 /* Pad out to 112 mod 128.
1010 */
1011 index = (unsigned int) ((context->count[0] >> 3) & 0x7f);
1012 padLen = (index < 112) ? (112 - index) : (240 - index);
1013 PHP_SHA512Update(context, PADDING, padLen);
1014
1015 /* Append length (before padding) */
1016 PHP_SHA512Update(context, bits, 16);
1017
1018 /* Store state in digest */
1019 SHAEncode64(digest, context->state, 64);
1020
1021 /* Zeroize sensitive information.
1022 */
1023 memset((unsigned char*) context, 0, sizeof(*context));
1024 }
1025 /* }}} */
1026
1027 const php_hash_ops php_hash_sha512_ops = {
1028 (php_hash_init_func_t) PHP_SHA512Init,
1029 (php_hash_update_func_t) PHP_SHA512Update,
1030 (php_hash_final_func_t) PHP_SHA512Final,
1031 (php_hash_copy_func_t) php_hash_copy,
1032 64,
1033 128,
1034 sizeof(PHP_SHA512_CTX)
1035 };
1036
1037 /*
1038 * Local variables:
1039 * tab-width: 4
1040 * c-basic-offset: 4
1041 * End:
1042 * vim600: sw=4 ts=4 fdm=marker
1043 * vim<600: sw=4 ts=4
1044 */
1045
