1 | /* |
2 | +----------------------------------------------------------------------+ |
3 | | PHP Version 5 | |
4 | +----------------------------------------------------------------------+ |
5 | | Copyright (c) 1997-2015 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: Stefan Esser <sesser@php.net> | |
16 | +----------------------------------------------------------------------+ |
17 | */ |
18 | |
19 | /* $Id$ */ |
20 | |
21 | #include "php.h" |
22 | |
23 | /* This code is heavily based on the PHP md5 implementation */ |
24 | |
25 | #include "sha1.h" |
26 | #include "md5.h" |
27 | |
28 | PHPAPI void make_sha1_digest(char *sha1str, unsigned char *digest) |
29 | { |
30 | make_digest_ex(sha1str, digest, 20); |
31 | } |
32 | |
33 | /* {{{ proto string sha1(string str [, bool raw_output]) |
34 | Calculate the sha1 hash of a string */ |
35 | PHP_FUNCTION(sha1) |
36 | { |
37 | char *arg; |
38 | int arg_len; |
39 | zend_bool raw_output = 0; |
40 | char sha1str[41]; |
41 | PHP_SHA1_CTX context; |
42 | unsigned char digest[20]; |
43 | |
44 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b" , &arg, &arg_len, &raw_output) == FAILURE) { |
45 | return; |
46 | } |
47 | |
48 | sha1str[0] = '\0'; |
49 | PHP_SHA1Init(&context); |
50 | PHP_SHA1Update(&context, arg, arg_len); |
51 | PHP_SHA1Final(digest, &context); |
52 | if (raw_output) { |
53 | RETURN_STRINGL(digest, 20, 1); |
54 | } else { |
55 | make_digest_ex(sha1str, digest, 20); |
56 | RETVAL_STRING(sha1str, 1); |
57 | } |
58 | |
59 | } |
60 | |
61 | /* }}} */ |
62 | |
63 | |
64 | /* {{{ proto string sha1_file(string filename [, bool raw_output]) |
65 | Calculate the sha1 hash of given filename */ |
66 | PHP_FUNCTION(sha1_file) |
67 | { |
68 | char *arg; |
69 | int arg_len; |
70 | zend_bool raw_output = 0; |
71 | char sha1str[41]; |
72 | unsigned char buf[1024]; |
73 | unsigned char digest[20]; |
74 | PHP_SHA1_CTX context; |
75 | int n; |
76 | php_stream *stream; |
77 | |
78 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|b" , &arg, &arg_len, &raw_output) == FAILURE) { |
79 | return; |
80 | } |
81 | |
82 | stream = php_stream_open_wrapper(arg, "rb" , REPORT_ERRORS, NULL); |
83 | if (!stream) { |
84 | RETURN_FALSE; |
85 | } |
86 | |
87 | PHP_SHA1Init(&context); |
88 | |
89 | while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) { |
90 | PHP_SHA1Update(&context, buf, n); |
91 | } |
92 | |
93 | PHP_SHA1Final(digest, &context); |
94 | |
95 | php_stream_close(stream); |
96 | |
97 | if (n<0) { |
98 | RETURN_FALSE; |
99 | } |
100 | |
101 | if (raw_output) { |
102 | RETURN_STRINGL(digest, 20, 1); |
103 | } else { |
104 | make_digest_ex(sha1str, digest, 20); |
105 | RETVAL_STRING(sha1str, 1); |
106 | } |
107 | } |
108 | /* }}} */ |
109 | |
110 | |
111 | static void SHA1Transform(php_uint32[5], const unsigned char[64]); |
112 | static void SHA1Encode(unsigned char *, php_uint32 *, unsigned int); |
113 | static void SHA1Decode(php_uint32 *, const unsigned char *, unsigned int); |
114 | |
115 | static unsigned char PADDING[64] = |
116 | { |
117 | 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
118 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
119 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
120 | }; |
121 | |
122 | /* F, G, H and I are basic SHA1 functions. |
123 | */ |
124 | #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) |
125 | #define G(x, y, z) ((x) ^ (y) ^ (z)) |
126 | #define H(x, y, z) (((x) & (y)) | ((z) & ((x) | (y)))) |
127 | #define I(x, y, z) ((x) ^ (y) ^ (z)) |
128 | |
129 | /* ROTATE_LEFT rotates x left n bits. |
130 | */ |
131 | #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) |
132 | |
133 | /* W[i] |
134 | */ |
135 | #define W(i) ( tmp=x[(i-3)&15]^x[(i-8)&15]^x[(i-14)&15]^x[i&15], \ |
136 | (x[i&15]=ROTATE_LEFT(tmp, 1)) ) |
137 | |
138 | /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. |
139 | */ |
140 | #define FF(a, b, c, d, e, w) { \ |
141 | (e) += F ((b), (c), (d)) + (w) + (php_uint32)(0x5A827999); \ |
142 | (e) += ROTATE_LEFT ((a), 5); \ |
143 | (b) = ROTATE_LEFT((b), 30); \ |
144 | } |
145 | #define GG(a, b, c, d, e, w) { \ |
146 | (e) += G ((b), (c), (d)) + (w) + (php_uint32)(0x6ED9EBA1); \ |
147 | (e) += ROTATE_LEFT ((a), 5); \ |
148 | (b) = ROTATE_LEFT((b), 30); \ |
149 | } |
150 | #define HH(a, b, c, d, e, w) { \ |
151 | (e) += H ((b), (c), (d)) + (w) + (php_uint32)(0x8F1BBCDC); \ |
152 | (e) += ROTATE_LEFT ((a), 5); \ |
153 | (b) = ROTATE_LEFT((b), 30); \ |
154 | } |
155 | #define II(a, b, c, d, e, w) { \ |
156 | (e) += I ((b), (c), (d)) + (w) + (php_uint32)(0xCA62C1D6); \ |
157 | (e) += ROTATE_LEFT ((a), 5); \ |
158 | (b) = ROTATE_LEFT((b), 30); \ |
159 | } |
160 | |
161 | |
162 | /* {{{ PHP_SHA1Init |
163 | * SHA1 initialization. Begins an SHA1 operation, writing a new context. |
164 | */ |
165 | PHPAPI void PHP_SHA1Init(PHP_SHA1_CTX * context) |
166 | { |
167 | context->count[0] = context->count[1] = 0; |
168 | /* Load magic initialization constants. |
169 | */ |
170 | context->state[0] = 0x67452301; |
171 | context->state[1] = 0xefcdab89; |
172 | context->state[2] = 0x98badcfe; |
173 | context->state[3] = 0x10325476; |
174 | context->state[4] = 0xc3d2e1f0; |
175 | } |
176 | /* }}} */ |
177 | |
178 | /* {{{ PHP_SHA1Update |
179 | SHA1 block update operation. Continues an SHA1 message-digest |
180 | operation, processing another message block, and updating the |
181 | context. |
182 | */ |
183 | PHPAPI void PHP_SHA1Update(PHP_SHA1_CTX * context, const unsigned char *input, |
184 | unsigned int inputLen) |
185 | { |
186 | unsigned int i, index, partLen; |
187 | |
188 | /* Compute number of bytes mod 64 */ |
189 | index = (unsigned int) ((context->count[0] >> 3) & 0x3F); |
190 | |
191 | /* Update number of bits */ |
192 | if ((context->count[0] += ((php_uint32) inputLen << 3)) |
193 | < ((php_uint32) inputLen << 3)) |
194 | context->count[1]++; |
195 | context->count[1] += ((php_uint32) inputLen >> 29); |
196 | |
197 | partLen = 64 - index; |
198 | |
199 | /* Transform as many times as possible. |
200 | */ |
201 | if (inputLen >= partLen) { |
202 | memcpy |
203 | ((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen); |
204 | SHA1Transform(context->state, context->buffer); |
205 | |
206 | for (i = partLen; i + 63 < inputLen; i += 64) |
207 | SHA1Transform(context->state, &input[i]); |
208 | |
209 | index = 0; |
210 | } else |
211 | i = 0; |
212 | |
213 | /* Buffer remaining input */ |
214 | memcpy |
215 | ((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], |
216 | inputLen - i); |
217 | } |
218 | /* }}} */ |
219 | |
220 | /* {{{ PHP_SHA1Final |
221 | SHA1 finalization. Ends an SHA1 message-digest operation, writing the |
222 | the message digest and zeroizing the context. |
223 | */ |
224 | PHPAPI void PHP_SHA1Final(unsigned char digest[20], PHP_SHA1_CTX * context) |
225 | { |
226 | unsigned char bits[8]; |
227 | unsigned int index, padLen; |
228 | |
229 | /* Save number of bits */ |
230 | bits[7] = context->count[0] & 0xFF; |
231 | bits[6] = (context->count[0] >> 8) & 0xFF; |
232 | bits[5] = (context->count[0] >> 16) & 0xFF; |
233 | bits[4] = (context->count[0] >> 24) & 0xFF; |
234 | bits[3] = context->count[1] & 0xFF; |
235 | bits[2] = (context->count[1] >> 8) & 0xFF; |
236 | bits[1] = (context->count[1] >> 16) & 0xFF; |
237 | bits[0] = (context->count[1] >> 24) & 0xFF; |
238 | |
239 | /* Pad out to 56 mod 64. |
240 | */ |
241 | index = (unsigned int) ((context->count[0] >> 3) & 0x3f); |
242 | padLen = (index < 56) ? (56 - index) : (120 - index); |
243 | PHP_SHA1Update(context, PADDING, padLen); |
244 | |
245 | /* Append length (before padding) */ |
246 | PHP_SHA1Update(context, bits, 8); |
247 | |
248 | /* Store state in digest */ |
249 | SHA1Encode(digest, context->state, 20); |
250 | |
251 | /* Zeroize sensitive information. |
252 | */ |
253 | memset((unsigned char*) context, 0, sizeof(*context)); |
254 | } |
255 | /* }}} */ |
256 | |
257 | /* {{{ SHA1Transform |
258 | * SHA1 basic transformation. Transforms state based on block. |
259 | */ |
260 | static void SHA1Transform(state, block) |
261 | php_uint32 state[5]; |
262 | const unsigned char block[64]; |
263 | { |
264 | php_uint32 a = state[0], b = state[1], c = state[2]; |
265 | php_uint32 d = state[3], e = state[4], x[16], tmp; |
266 | |
267 | SHA1Decode(x, block, 64); |
268 | |
269 | /* Round 1 */ |
270 | FF(a, b, c, d, e, x[0]); /* 1 */ |
271 | FF(e, a, b, c, d, x[1]); /* 2 */ |
272 | FF(d, e, a, b, c, x[2]); /* 3 */ |
273 | FF(c, d, e, a, b, x[3]); /* 4 */ |
274 | FF(b, c, d, e, a, x[4]); /* 5 */ |
275 | FF(a, b, c, d, e, x[5]); /* 6 */ |
276 | FF(e, a, b, c, d, x[6]); /* 7 */ |
277 | FF(d, e, a, b, c, x[7]); /* 8 */ |
278 | FF(c, d, e, a, b, x[8]); /* 9 */ |
279 | FF(b, c, d, e, a, x[9]); /* 10 */ |
280 | FF(a, b, c, d, e, x[10]); /* 11 */ |
281 | FF(e, a, b, c, d, x[11]); /* 12 */ |
282 | FF(d, e, a, b, c, x[12]); /* 13 */ |
283 | FF(c, d, e, a, b, x[13]); /* 14 */ |
284 | FF(b, c, d, e, a, x[14]); /* 15 */ |
285 | FF(a, b, c, d, e, x[15]); /* 16 */ |
286 | FF(e, a, b, c, d, W(16)); /* 17 */ |
287 | FF(d, e, a, b, c, W(17)); /* 18 */ |
288 | FF(c, d, e, a, b, W(18)); /* 19 */ |
289 | FF(b, c, d, e, a, W(19)); /* 20 */ |
290 | |
291 | /* Round 2 */ |
292 | GG(a, b, c, d, e, W(20)); /* 21 */ |
293 | GG(e, a, b, c, d, W(21)); /* 22 */ |
294 | GG(d, e, a, b, c, W(22)); /* 23 */ |
295 | GG(c, d, e, a, b, W(23)); /* 24 */ |
296 | GG(b, c, d, e, a, W(24)); /* 25 */ |
297 | GG(a, b, c, d, e, W(25)); /* 26 */ |
298 | GG(e, a, b, c, d, W(26)); /* 27 */ |
299 | GG(d, e, a, b, c, W(27)); /* 28 */ |
300 | GG(c, d, e, a, b, W(28)); /* 29 */ |
301 | GG(b, c, d, e, a, W(29)); /* 30 */ |
302 | GG(a, b, c, d, e, W(30)); /* 31 */ |
303 | GG(e, a, b, c, d, W(31)); /* 32 */ |
304 | GG(d, e, a, b, c, W(32)); /* 33 */ |
305 | GG(c, d, e, a, b, W(33)); /* 34 */ |
306 | GG(b, c, d, e, a, W(34)); /* 35 */ |
307 | GG(a, b, c, d, e, W(35)); /* 36 */ |
308 | GG(e, a, b, c, d, W(36)); /* 37 */ |
309 | GG(d, e, a, b, c, W(37)); /* 38 */ |
310 | GG(c, d, e, a, b, W(38)); /* 39 */ |
311 | GG(b, c, d, e, a, W(39)); /* 40 */ |
312 | |
313 | /* Round 3 */ |
314 | HH(a, b, c, d, e, W(40)); /* 41 */ |
315 | HH(e, a, b, c, d, W(41)); /* 42 */ |
316 | HH(d, e, a, b, c, W(42)); /* 43 */ |
317 | HH(c, d, e, a, b, W(43)); /* 44 */ |
318 | HH(b, c, d, e, a, W(44)); /* 45 */ |
319 | HH(a, b, c, d, e, W(45)); /* 46 */ |
320 | HH(e, a, b, c, d, W(46)); /* 47 */ |
321 | HH(d, e, a, b, c, W(47)); /* 48 */ |
322 | HH(c, d, e, a, b, W(48)); /* 49 */ |
323 | HH(b, c, d, e, a, W(49)); /* 50 */ |
324 | HH(a, b, c, d, e, W(50)); /* 51 */ |
325 | HH(e, a, b, c, d, W(51)); /* 52 */ |
326 | HH(d, e, a, b, c, W(52)); /* 53 */ |
327 | HH(c, d, e, a, b, W(53)); /* 54 */ |
328 | HH(b, c, d, e, a, W(54)); /* 55 */ |
329 | HH(a, b, c, d, e, W(55)); /* 56 */ |
330 | HH(e, a, b, c, d, W(56)); /* 57 */ |
331 | HH(d, e, a, b, c, W(57)); /* 58 */ |
332 | HH(c, d, e, a, b, W(58)); /* 59 */ |
333 | HH(b, c, d, e, a, W(59)); /* 60 */ |
334 | |
335 | /* Round 4 */ |
336 | II(a, b, c, d, e, W(60)); /* 61 */ |
337 | II(e, a, b, c, d, W(61)); /* 62 */ |
338 | II(d, e, a, b, c, W(62)); /* 63 */ |
339 | II(c, d, e, a, b, W(63)); /* 64 */ |
340 | II(b, c, d, e, a, W(64)); /* 65 */ |
341 | II(a, b, c, d, e, W(65)); /* 66 */ |
342 | II(e, a, b, c, d, W(66)); /* 67 */ |
343 | II(d, e, a, b, c, W(67)); /* 68 */ |
344 | II(c, d, e, a, b, W(68)); /* 69 */ |
345 | II(b, c, d, e, a, W(69)); /* 70 */ |
346 | II(a, b, c, d, e, W(70)); /* 71 */ |
347 | II(e, a, b, c, d, W(71)); /* 72 */ |
348 | II(d, e, a, b, c, W(72)); /* 73 */ |
349 | II(c, d, e, a, b, W(73)); /* 74 */ |
350 | II(b, c, d, e, a, W(74)); /* 75 */ |
351 | II(a, b, c, d, e, W(75)); /* 76 */ |
352 | II(e, a, b, c, d, W(76)); /* 77 */ |
353 | II(d, e, a, b, c, W(77)); /* 78 */ |
354 | II(c, d, e, a, b, W(78)); /* 79 */ |
355 | II(b, c, d, e, a, W(79)); /* 80 */ |
356 | |
357 | state[0] += a; |
358 | state[1] += b; |
359 | state[2] += c; |
360 | state[3] += d; |
361 | state[4] += e; |
362 | |
363 | /* Zeroize sensitive information. */ |
364 | memset((unsigned char*) x, 0, sizeof(x)); |
365 | } |
366 | /* }}} */ |
367 | |
368 | /* {{{ SHA1Encode |
369 | Encodes input (php_uint32) into output (unsigned char). Assumes len is |
370 | a multiple of 4. |
371 | */ |
372 | static void SHA1Encode(output, input, len) |
373 | unsigned char *output; |
374 | php_uint32 *input; |
375 | unsigned int len; |
376 | { |
377 | unsigned int i, j; |
378 | |
379 | for (i = 0, j = 0; j < len; i++, j += 4) { |
380 | output[j] = (unsigned char) ((input[i] >> 24) & 0xff); |
381 | output[j + 1] = (unsigned char) ((input[i] >> 16) & 0xff); |
382 | output[j + 2] = (unsigned char) ((input[i] >> 8) & 0xff); |
383 | output[j + 3] = (unsigned char) (input[i] & 0xff); |
384 | } |
385 | } |
386 | /* }}} */ |
387 | |
388 | /* {{{ SHA1Decode |
389 | Decodes input (unsigned char) into output (php_uint32). Assumes len is |
390 | a multiple of 4. |
391 | */ |
392 | static void SHA1Decode(output, input, len) |
393 | php_uint32 *output; |
394 | const unsigned char *input; |
395 | unsigned int len; |
396 | { |
397 | unsigned int i, j; |
398 | |
399 | for (i = 0, j = 0; j < len; i++, j += 4) |
400 | output[i] = ((php_uint32) input[j + 3]) | (((php_uint32) input[j + 2]) << 8) | |
401 | (((php_uint32) input[j + 1]) << 16) | (((php_uint32) input[j]) << 24); |
402 | } |
403 | /* }}} */ |
404 | |
405 | /* |
406 | * Local variables: |
407 | * tab-width: 4 |
408 | * c-basic-offset: 4 |
409 | * End: |
410 | * vim600: sw=4 ts=4 fdm=marker |
411 | * vim<600: sw=4 ts=4 |
412 | */ |
413 | |