xref: /PHP-5.4/ext/standard/crypt_sha256.c (revision 6e246ad0)
1 /* SHA256-based Unix crypt implementation.
2    Released into the Public Domain by Ulrich Drepper <drepper@redhat.com>.  */
3 /* Windows VC++ port by Pierre Joye <pierre@php.net> */
4 
5 #include "php.h"
6 #include "php_main.h"
7 
8 #include <errno.h>
9 #include <limits.h>
10 
11 #ifdef PHP_WIN32
12 # include "win32/php_stdint.h"
13 # define __alignof__ __alignof
14 # define alloca _alloca
15 #else
16 # if HAVE_INTTYPES_H
17 #  include <inttypes.h>
18 # elif HAVE_STDINT_H
19 #  include <stdint.h>
20 # endif
21 # ifndef HAVE_ALIGNOF
22 #  include <stddef.h>
23 #  define __alignof__(type) offsetof (struct { char c; type member;}, member)
24 # endif
25 # if HAVE_ATTRIBUTE_ALIGNED
26 #  define ALIGNED(size) __attribute__ ((__aligned__ (size)))
27 # else
28 #  define ALIGNED(size)
29 # endif
30 #endif
31 
32 #include <stdio.h>
33 #include <stdlib.h>
34 
35 #ifdef PHP_WIN32
36 # include <string.h>
37 #else
38 # include <sys/param.h>
39 # include <sys/types.h>
40 # if HAVE_STRING_H
41 #  include <string.h>
42 # else
43 #  include <strings.h>
44 # endif
45 #endif
46 
__php_stpncpy(char * dst,const char * src,size_t len)47 char * __php_stpncpy(char *dst, const char *src, size_t len)
48 {
49 	size_t n = strlen(src);
50 	if (n > len) {
51 		n = len;
52 	}
53 	return strncpy(dst, src, len) + n;
54 }
55 
__php_mempcpy(void * dst,const void * src,size_t len)56 void * __php_mempcpy(void * dst, const void * src, size_t len)
57 {
58 	return (((char *)memcpy(dst, src, len)) + len);
59 }
60 
61 #ifndef MIN
62 # define MIN(a, b) (((a) < (b)) ? (a) : (b))
63 #endif
64 #ifndef MAX
65 # define MAX(a, b) (((a) > (b)) ? (a) : (b))
66 #endif
67 
68 /* Structure to save state of computation between the single steps.  */
69 struct sha256_ctx {
70 	uint32_t H[8];
71 
72 	uint32_t total[2];
73 	uint32_t buflen;
74 	char buffer[128]; /* NB: always correctly aligned for uint32_t.  */
75 };
76 
77 #if PHP_WIN32 || (!defined(WORDS_BIGENDIAN))
78 # define SWAP(n) \
79     (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
80 #else
81 # define SWAP(n) (n)
82 #endif
83 
84 /* This array contains the bytes used to pad the buffer to the next
85    64-byte boundary.  (FIPS 180-2:5.1.1)  */
86 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
87 
88 
89 /* Constants for SHA256 from FIPS 180-2:4.2.2.  */
90 static const uint32_t K[64] = {
91 	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
92 	0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
93 	0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
94 	0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
95 	0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
96 	0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
97 	0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
98 	0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
99 	0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
100 	0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
101 	0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
102 	0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
103 	0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
104 	0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
105 	0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
106 	0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
107 };
108 
109 
110 /* Process LEN bytes of BUFFER, accumulating context into CTX.
111    It is assumed that LEN % 64 == 0.  */
sha256_process_block(const void * buffer,size_t len,struct sha256_ctx * ctx)112 static void sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx) {
113 	const uint32_t *words = buffer;
114 	size_t nwords = len / sizeof (uint32_t);
115 	unsigned int t;
116 
117 	uint32_t a = ctx->H[0];
118 	uint32_t b = ctx->H[1];
119 	uint32_t c = ctx->H[2];
120 	uint32_t d = ctx->H[3];
121 	uint32_t e = ctx->H[4];
122 	uint32_t f = ctx->H[5];
123 	uint32_t g = ctx->H[6];
124 	uint32_t h = ctx->H[7];
125 
126 	/* First increment the byte count.  FIPS 180-2 specifies the possible
127 	 length of the file up to 2^64 bits.  Here we only compute the
128 	 number of bytes.  Do a double word increment.  */
129 	ctx->total[0] += len;
130 	if (ctx->total[0] < len) {
131 		++ctx->total[1];
132 	}
133 
134 	/* Process all bytes in the buffer with 64 bytes in each round of
135 	 the loop.  */
136 	while (nwords > 0) {
137 		uint32_t W[64];
138 		uint32_t a_save = a;
139 		uint32_t b_save = b;
140 		uint32_t c_save = c;
141 		uint32_t d_save = d;
142 		uint32_t e_save = e;
143 		uint32_t f_save = f;
144 		uint32_t g_save = g;
145 		uint32_t h_save = h;
146 
147 	/* Operators defined in FIPS 180-2:4.1.2.  */
148 #define Ch(x, y, z) ((x & y) ^ (~x & z))
149 #define Maj(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
150 #define S0(x) (CYCLIC (x, 2) ^ CYCLIC (x, 13) ^ CYCLIC (x, 22))
151 #define S1(x) (CYCLIC (x, 6) ^ CYCLIC (x, 11) ^ CYCLIC (x, 25))
152 #define R0(x) (CYCLIC (x, 7) ^ CYCLIC (x, 18) ^ (x >> 3))
153 #define R1(x) (CYCLIC (x, 17) ^ CYCLIC (x, 19) ^ (x >> 10))
154 
155 	/* It is unfortunate that C does not provide an operator for
156 	cyclic rotation.  Hope the C compiler is smart enough.  */
157 #define CYCLIC(w, s) ((w >> s) | (w << (32 - s)))
158 
159 		/* Compute the message schedule according to FIPS 180-2:6.2.2 step 2.  */
160 		for (t = 0; t < 16; ++t) {
161 			W[t] = SWAP (*words);
162 			++words;
163 		}
164 		for (t = 16; t < 64; ++t)
165 			W[t] = R1 (W[t - 2]) + W[t - 7] + R0 (W[t - 15]) + W[t - 16];
166 
167 		/* The actual computation according to FIPS 180-2:6.2.2 step 3.  */
168 		for (t = 0; t < 64; ++t) {
169 			uint32_t T1 = h + S1 (e) + Ch (e, f, g) + K[t] + W[t];
170 			uint32_t T2 = S0 (a) + Maj (a, b, c);
171 			h = g;
172 			g = f;
173 			f = e;
174 			e = d + T1;
175 			d = c;
176 			c = b;
177 			b = a;
178 			a = T1 + T2;
179 		}
180 
181 		/* Add the starting values of the context according to FIPS 180-2:6.2.2
182 		step 4.  */
183 		a += a_save;
184 		b += b_save;
185 		c += c_save;
186 		d += d_save;
187 		e += e_save;
188 		f += f_save;
189 		g += g_save;
190 		h += h_save;
191 
192 		/* Prepare for the next round.  */
193 		nwords -= 16;
194 	}
195 
196 	/* Put checksum in context given as argument.  */
197 	ctx->H[0] = a;
198 	ctx->H[1] = b;
199 	ctx->H[2] = c;
200 	ctx->H[3] = d;
201 	ctx->H[4] = e;
202 	ctx->H[5] = f;
203 	ctx->H[6] = g;
204 	ctx->H[7] = h;
205 }
206 
207 
208 /* Initialize structure containing state of computation.
209    (FIPS 180-2:5.3.2)  */
sha256_init_ctx(struct sha256_ctx * ctx)210 static void sha256_init_ctx(struct sha256_ctx *ctx) {
211 	ctx->H[0] = 0x6a09e667;
212 	ctx->H[1] = 0xbb67ae85;
213 	ctx->H[2] = 0x3c6ef372;
214 	ctx->H[3] = 0xa54ff53a;
215 	ctx->H[4] = 0x510e527f;
216 	ctx->H[5] = 0x9b05688c;
217 	ctx->H[6] = 0x1f83d9ab;
218 	ctx->H[7] = 0x5be0cd19;
219 
220 	ctx->total[0] = ctx->total[1] = 0;
221 	ctx->buflen = 0;
222 }
223 
224 
225 /* Process the remaining bytes in the internal buffer and the usual
226    prolog according to the standard and write the result to RESBUF.
227 
228    IMPORTANT: On some systems it is required that RESBUF is correctly
229    aligned for a 32 bits value.  */
sha256_finish_ctx(struct sha256_ctx * ctx,void * resbuf)230 static void * sha256_finish_ctx(struct sha256_ctx *ctx, void *resbuf) {
231 	/* Take yet unprocessed bytes into account.  */
232 	uint32_t bytes = ctx->buflen;
233 	size_t pad;
234 	unsigned int i;
235 
236 	/* Now count remaining bytes.  */
237 	ctx->total[0] += bytes;
238 	if (ctx->total[0] < bytes) {
239 		++ctx->total[1];
240 	}
241 
242 	pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
243 	memcpy(&ctx->buffer[bytes], fillbuf, pad);
244 
245 	/* Put the 64-bit file length in *bits* at the end of the buffer.  */
246 	*(uint32_t *) &ctx->buffer[bytes + pad + 4] = SWAP (ctx->total[0] << 3);
247 	*(uint32_t *) &ctx->buffer[bytes + pad] = SWAP ((ctx->total[1] << 3) |
248 						  (ctx->total[0] >> 29));
249 
250 	/* Process last bytes.  */
251 	sha256_process_block(ctx->buffer, bytes + pad + 8, ctx);
252 
253 	/* Put result from CTX in first 32 bytes following RESBUF.  */
254 	for (i = 0; i < 8; ++i) {
255 		((uint32_t *) resbuf)[i] = SWAP(ctx->H[i]);
256 	}
257 
258 	return resbuf;
259 }
260 
261 
sha256_process_bytes(const void * buffer,size_t len,struct sha256_ctx * ctx)262 static void sha256_process_bytes(const void *buffer, size_t len, struct sha256_ctx *ctx) {
263 	/* When we already have some bits in our internal buffer concatenate
264 	 both inputs first.  */
265 	if (ctx->buflen != 0) {
266 		size_t left_over = ctx->buflen;
267 		size_t add = 128 - left_over > len ? len : 128 - left_over;
268 
269 		  memcpy(&ctx->buffer[left_over], buffer, add);
270 		  ctx->buflen += add;
271 
272 		if (ctx->buflen > 64) {
273 			sha256_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
274 			ctx->buflen &= 63;
275 			/* The regions in the following copy operation cannot overlap.  */
276 			memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63], ctx->buflen);
277 		}
278 
279 		buffer = (const char *) buffer + add;
280 		len -= add;
281 	}
282 
283 	/* Process available complete blocks.  */
284 	if (len >= 64) {
285 /* To check alignment gcc has an appropriate operator.  Other
286 compilers don't.  */
287 #if __GNUC__ >= 2
288 # define UNALIGNED_P(p) (((uintptr_t) p) % __alignof__ (uint32_t) != 0)
289 #else
290 # define UNALIGNED_P(p) (((uintptr_t) p) % sizeof (uint32_t) != 0)
291 #endif
292 		if (UNALIGNED_P (buffer))
293 			while (len > 64) {
294 				sha256_process_block(memcpy(ctx->buffer, buffer, 64), 64, ctx);
295 				buffer = (const char *) buffer + 64;
296 				len -= 64;
297 			} else {
298 				sha256_process_block(buffer, len & ~63, ctx);
299 				buffer = (const char *) buffer + (len & ~63);
300 				len &= 63;
301 			}
302 	}
303 
304 	/* Move remaining bytes into internal buffer.  */
305 	if (len > 0) {
306 		size_t left_over = ctx->buflen;
307 
308 		memcpy(&ctx->buffer[left_over], buffer, len);
309 		left_over += len;
310 		if (left_over >= 64) {
311 			sha256_process_block(ctx->buffer, 64, ctx);
312 			left_over -= 64;
313 			memcpy(ctx->buffer, &ctx->buffer[64], left_over);
314 		}
315 		ctx->buflen = left_over;
316 	}
317 }
318 
319 
320 /* Define our magic string to mark salt for SHA256 "encryption"
321    replacement.  */
322 static const char sha256_salt_prefix[] = "$5$";
323 
324 /* Prefix for optional rounds specification.  */
325 static const char sha256_rounds_prefix[] = "rounds=";
326 
327 /* Maximum salt string length.  */
328 #define SALT_LEN_MAX 16
329 /* Default number of rounds if not explicitly specified.  */
330 #define ROUNDS_DEFAULT 5000
331 /* Minimum number of rounds.  */
332 #define ROUNDS_MIN 1000
333 /* Maximum number of rounds.  */
334 #define ROUNDS_MAX 999999999
335 
336 /* Table with characters for base64 transformation.  */
337 static const char b64t[64] =
338 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
339 
php_sha256_crypt_r(const char * key,const char * salt,char * buffer,int buflen)340 char * php_sha256_crypt_r(const char *key, const char *salt, char *buffer, int buflen)
341 {
342 #ifdef PHP_WIN32
343 # if _MSC <= 1300
344 #  pragma pack(push, 16)
345 	unsigned char alt_result[32];
346 	unsigned char temp_result[32];
347 #  pragma pack(pop)
348 # else
349 	__declspec(align(32)) unsigned char alt_result[32];
350 	__declspec(align(32)) unsigned char temp_result[32];
351 # endif
352 #else
353 	unsigned char alt_result[32] ALIGNED(__alignof__ (uint32_t));
354 	unsigned char temp_result[32] ALIGNED(__alignof__ (uint32_t));
355 #endif
356 
357 	struct sha256_ctx ctx;
358 	struct sha256_ctx alt_ctx;
359 	size_t salt_len;
360 	size_t key_len;
361 	size_t cnt;
362 	char *cp;
363 	char *copied_key = NULL;
364 	char *copied_salt = NULL;
365 	char *p_bytes;
366 	char *s_bytes;
367 	/* Default number of rounds.  */
368 	size_t rounds = ROUNDS_DEFAULT;
369 	zend_bool rounds_custom = 0;
370 
371 	/* Find beginning of salt string.  The prefix should normally always
372 	be present.  Just in case it is not.  */
373 	if (strncmp(sha256_salt_prefix, salt, sizeof(sha256_salt_prefix) - 1) == 0) {
374 		/* Skip salt prefix.  */
375 		salt += sizeof(sha256_salt_prefix) - 1;
376 	}
377 
378 	if (strncmp(salt, sha256_rounds_prefix, sizeof(sha256_rounds_prefix) - 1) == 0) {
379 		const char *num = salt + sizeof(sha256_rounds_prefix) - 1;
380 		char *endp;
381 		unsigned long int srounds = strtoul(num, &endp, 10);
382 		if (*endp == '$') {
383 			salt = endp + 1;
384 			rounds = MAX(ROUNDS_MIN, MIN(srounds, ROUNDS_MAX));
385 			rounds_custom = 1;
386 		}
387 	}
388 
389 	salt_len = MIN(strcspn(salt, "$"), SALT_LEN_MAX);
390 	key_len = strlen(key);
391 
392 	if ((key - (char *) 0) % __alignof__ (uint32_t) != 0) {
393 		char *tmp = (char *) alloca(key_len + __alignof__(uint32_t));
394 		key = copied_key = memcpy(tmp + __alignof__(uint32_t) - (tmp - (char *) 0) % __alignof__(uint32_t), key, key_len);
395 	}
396 
397 	if ((salt - (char *) 0) % __alignof__(uint32_t) != 0) {
398 		char *tmp = (char *) alloca(salt_len + 1 + __alignof__(uint32_t));
399 		salt = copied_salt =
400 		memcpy(tmp + __alignof__(uint32_t) - (tmp - (char *) 0) % __alignof__ (uint32_t), salt, salt_len);
401 		copied_salt[salt_len] = 0;
402 	}
403 
404 	/* Prepare for the real work.  */
405 	sha256_init_ctx(&ctx);
406 
407 	/* Add the key string.  */
408 	sha256_process_bytes(key, key_len, &ctx);
409 
410 	/* The last part is the salt string.  This must be at most 16
411 	 characters and it ends at the first `$' character (for
412 	 compatibility with existing implementations).  */
413 	sha256_process_bytes(salt, salt_len, &ctx);
414 
415 
416 	/* Compute alternate SHA256 sum with input KEY, SALT, and KEY.  The
417 	 final result will be added to the first context.  */
418 	sha256_init_ctx(&alt_ctx);
419 
420 	/* Add key.  */
421 	sha256_process_bytes(key, key_len, &alt_ctx);
422 
423 	/* Add salt.  */
424 	sha256_process_bytes(salt, salt_len, &alt_ctx);
425 
426 	/* Add key again.  */
427 	sha256_process_bytes(key, key_len, &alt_ctx);
428 
429 	/* Now get result of this (32 bytes) and add it to the other
430 	 context.  */
431 	sha256_finish_ctx(&alt_ctx, alt_result);
432 
433 	/* Add for any character in the key one byte of the alternate sum.  */
434 	for (cnt = key_len; cnt > 32; cnt -= 32) {
435 		sha256_process_bytes(alt_result, 32, &ctx);
436 	}
437 	sha256_process_bytes(alt_result, cnt, &ctx);
438 
439 	/* Take the binary representation of the length of the key and for every
440 	1 add the alternate sum, for every 0 the key.  */
441 	for (cnt = key_len; cnt > 0; cnt >>= 1) {
442 		if ((cnt & 1) != 0) {
443 			sha256_process_bytes(alt_result, 32, &ctx);
444 		} else {
445 			sha256_process_bytes(key, key_len, &ctx);
446 		}
447 	}
448 
449 	/* Create intermediate result.  */
450 	sha256_finish_ctx(&ctx, alt_result);
451 
452 	/* Start computation of P byte sequence.  */
453 	sha256_init_ctx(&alt_ctx);
454 
455 	/* For every character in the password add the entire password.  */
456 	for (cnt = 0; cnt < key_len; ++cnt) {
457 		sha256_process_bytes(key, key_len, &alt_ctx);
458 	}
459 
460 	/* Finish the digest.  */
461 	sha256_finish_ctx(&alt_ctx, temp_result);
462 
463 	/* Create byte sequence P.  */
464 	cp = p_bytes = alloca(key_len);
465 	for (cnt = key_len; cnt >= 32; cnt -= 32) {
466 		cp = __php_mempcpy((void *)cp, (const void *)temp_result, 32);
467 	}
468 	memcpy(cp, temp_result, cnt);
469 
470 	/* Start computation of S byte sequence.  */
471 	sha256_init_ctx(&alt_ctx);
472 
473 	/* For every character in the password add the entire password.  */
474 	for (cnt = 0; cnt < (size_t) (16 + alt_result[0]); ++cnt) {
475 		sha256_process_bytes(salt, salt_len, &alt_ctx);
476 	}
477 
478 	/* Finish the digest.  */
479 	sha256_finish_ctx(&alt_ctx, temp_result);
480 
481 	/* Create byte sequence S.  */
482 	cp = s_bytes = alloca(salt_len);
483 	for (cnt = salt_len; cnt >= 32; cnt -= 32) {
484 		cp = __php_mempcpy(cp, temp_result, 32);
485 	}
486 	memcpy(cp, temp_result, cnt);
487 
488 	/* Repeatedly run the collected hash value through SHA256 to burn
489 	CPU cycles.  */
490 	for (cnt = 0; cnt < rounds; ++cnt) {
491 		/* New context.  */
492 		sha256_init_ctx(&ctx);
493 
494 		/* Add key or last result.  */
495 		if ((cnt & 1) != 0) {
496 			sha256_process_bytes(p_bytes, key_len, &ctx);
497 		} else {
498 			sha256_process_bytes(alt_result, 32, &ctx);
499 		}
500 
501 		/* Add salt for numbers not divisible by 3.  */
502 		if (cnt % 3 != 0) {
503 			sha256_process_bytes(s_bytes, salt_len, &ctx);
504 		}
505 
506 		/* Add key for numbers not divisible by 7.  */
507 		if (cnt % 7 != 0) {
508 			sha256_process_bytes(p_bytes, key_len, &ctx);
509 		}
510 
511 		/* Add key or last result.  */
512 		if ((cnt & 1) != 0) {
513 			sha256_process_bytes(alt_result, 32, &ctx);
514 		} else {
515 			sha256_process_bytes(p_bytes, key_len, &ctx);
516 		}
517 
518 		/* Create intermediate result.  */
519 		sha256_finish_ctx(&ctx, alt_result);
520 	}
521 
522 	/* Now we can construct the result string.  It consists of three
523 	parts.  */
524 	cp = __php_stpncpy(buffer, sha256_salt_prefix, MAX(0, buflen));
525 	buflen -= sizeof(sha256_salt_prefix) - 1;
526 
527 	if (rounds_custom) {
528 #ifdef PHP_WIN32
529 		int n = _snprintf(cp, MAX(0, buflen), "%s%u$", sha256_rounds_prefix, rounds);
530 #else
531 		int n = snprintf(cp, MAX(0, buflen), "%s%zu$", sha256_rounds_prefix, rounds);
532 #endif
533 		cp += n;
534 		buflen -= n;
535 	}
536 
537 	cp = __php_stpncpy(cp, salt, MIN ((size_t) MAX (0, buflen), salt_len));
538 	buflen -= MIN((size_t) MAX (0, buflen), salt_len);
539 
540 	if (buflen > 0) {
541 		*cp++ = '$';
542 		--buflen;
543 	}
544 
545 #define b64_from_24bit(B2, B1, B0, N)					      \
546   do {									      \
547     unsigned int w = ((B2) << 16) | ((B1) << 8) | (B0);			      \
548     int n = (N);							      \
549     while (n-- > 0 && buflen > 0)					      \
550       {									      \
551 	*cp++ = b64t[w & 0x3f];						      \
552 	--buflen;							      \
553 	w >>= 6;							      \
554       }									      \
555   } while (0)
556 
557 	b64_from_24bit(alt_result[0], alt_result[10], alt_result[20], 4);
558 	b64_from_24bit(alt_result[21], alt_result[1], alt_result[11], 4);
559 	b64_from_24bit(alt_result[12], alt_result[22], alt_result[2], 4);
560 	b64_from_24bit(alt_result[3], alt_result[13], alt_result[23], 4);
561 	b64_from_24bit(alt_result[24], alt_result[4], alt_result[14], 4);
562 	b64_from_24bit(alt_result[15], alt_result[25], alt_result[5], 4);
563 	b64_from_24bit(alt_result[6], alt_result[16], alt_result[26], 4);
564 	b64_from_24bit(alt_result[27], alt_result[7], alt_result[17], 4);
565 	b64_from_24bit(alt_result[18], alt_result[28], alt_result[8], 4);
566 	b64_from_24bit(alt_result[9], alt_result[19], alt_result[29], 4);
567 	b64_from_24bit(0, alt_result[31], alt_result[30], 3);
568 	if (buflen <= 0) {
569 		errno = ERANGE;
570 		buffer = NULL;
571 	} else
572 		*cp = '\0';		/* Terminate the string.  */
573 
574 	/* Clear the buffer for the intermediate result so that people
575      attaching to processes or reading core dumps cannot get any
576      information.  We do it in this way to clear correct_words[]
577      inside the SHA256 implementation as well.  */
578 	sha256_init_ctx(&ctx);
579 	sha256_finish_ctx(&ctx, alt_result);
580 	memset(temp_result, '\0', sizeof(temp_result));
581 	memset(p_bytes, '\0', key_len);
582 	memset(s_bytes, '\0', salt_len);
583 	memset(&ctx, '\0', sizeof(ctx));
584 	memset(&alt_ctx, '\0', sizeof(alt_ctx));
585 
586 	if (copied_key != NULL) {
587 		memset(copied_key, '\0', key_len);
588 
589 	}
590 	if (copied_salt != NULL) {
591 		memset(copied_salt, '\0', salt_len);
592 	}
593 
594 	return buffer;
595 }
596 
597 
598 /* This entry point is equivalent to the `crypt' function in Unix
599    libcs.  */
php_sha256_crypt(const char * key,const char * salt)600 char * php_sha256_crypt(const char *key, const char *salt)
601 {
602 	/* We don't want to have an arbitrary limit in the size of the
603 	password.  We can compute an upper bound for the size of the
604 	result in advance and so we can prepare the buffer we pass to
605 	`sha256_crypt_r'.  */
606 	static char *buffer;
607 	static int buflen;
608 	int needed = (sizeof(sha256_salt_prefix) - 1
609 			+ sizeof(sha256_rounds_prefix) + 9 + 1
610 			+ strlen(salt) + 1 + 43 + 1);
611 
612 	if (buflen < needed) {
613 		char *new_buffer = (char *) realloc(buffer, needed);
614 		if (new_buffer == NULL) {
615 			return NULL;
616 		}
617 
618 		buffer = new_buffer;
619 		buflen = needed;
620 	}
621 
622 	return php_sha256_crypt_r(key, salt, buffer, buflen);
623 }
624 
625 
626 #ifdef TEST
627 static const struct
628 {
629 	const char *input;
630 	const char result[32];
631 } tests[] =
632 	{
633 	/* Test vectors from FIPS 180-2: appendix B.1.  */
634 	{ "abc",
635 	"\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
636 	"\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad" },
637 	/* Test vectors from FIPS 180-2: appendix B.2.  */
638 	{ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
639 	"\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
640 	"\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
641 	/* Test vectors from the NESSIE project.  */
642 	{ "",
643 	"\xe3\xb0\xc4\x42\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24"
644 	"\x27\xae\x41\xe4\x64\x9b\x93\x4c\xa4\x95\x99\x1b\x78\x52\xb8\x55" },
645 	{ "a",
646 	"\xca\x97\x81\x12\xca\x1b\xbd\xca\xfa\xc2\x31\xb3\x9a\x23\xdc\x4d"
647 	"\xa7\x86\xef\xf8\x14\x7c\x4e\x72\xb9\x80\x77\x85\xaf\xee\x48\xbb" },
648 	{ "message digest",
649 	"\xf7\x84\x6f\x55\xcf\x23\xe1\x4e\xeb\xea\xb5\xb4\xe1\x55\x0c\xad"
650 	"\x5b\x50\x9e\x33\x48\xfb\xc4\xef\xa3\xa1\x41\x3d\x39\x3c\xb6\x50" },
651 	{ "abcdefghijklmnopqrstuvwxyz",
652 	"\x71\xc4\x80\xdf\x93\xd6\xae\x2f\x1e\xfa\xd1\x44\x7c\x66\xc9\x52"
653 	"\x5e\x31\x62\x18\xcf\x51\xfc\x8d\x9e\xd8\x32\xf2\xda\xf1\x8b\x73" },
654 	{ "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
655 	"\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
656 	"\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1" },
657 	{ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
658 	"\xdb\x4b\xfc\xbd\x4d\xa0\xcd\x85\xa6\x0c\x3c\x37\xd3\xfb\xd8\x80"
659 	"\x5c\x77\xf1\x5f\xc6\xb1\xfd\xfe\x61\x4e\xe0\xa7\xc8\xfd\xb4\xc0" },
660 	{ "123456789012345678901234567890123456789012345678901234567890"
661 	"12345678901234567890",
662 	"\xf3\x71\xbc\x4a\x31\x1f\x2b\x00\x9e\xef\x95\x2d\xd8\x3c\xa8\x0e"
663 	"\x2b\x60\x02\x6c\x8e\x93\x55\x92\xd0\xf9\xc3\x08\x45\x3c\x81\x3e" }
664   };
665 #define ntests (sizeof (tests) / sizeof (tests[0]))
666 
667 
668 static const struct
669 {
670 	const char *salt;
671 	const char *input;
672 	const char *expected;
673 } tests2[] =
674 {
675 	{ "$5$saltstring", "Hello world!",
676 	"$5$saltstring$5B8vYYiY.CVt1RlTTf8KbXBH3hsxY/GNooZaBBGWEc5" },
677 	{ "$5$rounds=10000$saltstringsaltstring", "Hello world!",
678 	"$5$rounds=10000$saltstringsaltst$3xv.VbSHBb41AL9AvLeujZkZRBAwqFMz2."
679 	"opqey6IcA" },
680 	{ "$5$rounds=5000$toolongsaltstring", "This is just a test",
681 	"$5$rounds=5000$toolongsaltstrin$Un/5jzAHMgOGZ5.mWJpuVolil07guHPvOW8"
682 	"mGRcvxa5" },
683 	{ "$5$rounds=1400$anotherlongsaltstring",
684 	"a very much longer text to encrypt.  This one even stretches over more"
685 	"than one line.",
686 	"$5$rounds=1400$anotherlongsalts$Rx.j8H.h8HjEDGomFU8bDkXm3XIUnzyxf12"
687 	"oP84Bnq1" },
688 	{ "$5$rounds=77777$short",
689 	"we have a short salt string but not a short password",
690 	"$5$rounds=77777$short$JiO1O3ZpDAxGJeaDIuqCoEFysAe1mZNJRs3pw0KQRd/" },
691 	{ "$5$rounds=123456$asaltof16chars..", "a short string",
692 	"$5$rounds=123456$asaltof16chars..$gP3VQ/6X7UUEW3HkBn2w1/Ptq2jxPyzV/"
693 	"cZKmF/wJvD" },
694 	{ "$5$rounds=10$roundstoolow", "the minimum number is still observed",
695 	"$5$rounds=1000$roundstoolow$yfvwcWrQ8l/K0DAWyuPMDNHpIVlTQebY9l/gL97"
696 	"2bIC" },
697 };
698 #define ntests2 (sizeof (tests2) / sizeof (tests2[0]))
699 
700 
main(void)701 int main(void) {
702 	struct sha256_ctx ctx;
703 	char sum[32];
704 	int result = 0;
705 	int cnt, i;
706 	char buf[1000];
707 	static const char expected[32] =
708 	"\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
709 	"\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0";
710 
711 	for (cnt = 0; cnt < (int) ntests; ++cnt) {
712 		sha256_init_ctx(&ctx);
713 		sha256_process_bytes(tests[cnt].input, strlen(tests[cnt].input), &ctx);
714 		sha256_finish_ctx(&ctx, sum);
715 		if (memcmp(tests[cnt].result, sum, 32) != 0) {
716 			printf("test %d run %d failed\n", cnt, 1);
717 			result = 1;
718 		}
719 
720 		sha256_init_ctx(&ctx);
721 		for (i = 0; tests[cnt].input[i] != '\0'; ++i) {
722 			sha256_process_bytes(&tests[cnt].input[i], 1, &ctx);
723 		}
724 		sha256_finish_ctx(&ctx, sum);
725 		if (memcmp(tests[cnt].result, sum, 32) != 0) {
726 			printf("test %d run %d failed\n", cnt, 2);
727 			result = 1;
728 		}
729 	}
730 
731 	/* Test vector from FIPS 180-2: appendix B.3.  */
732 
733 	memset(buf, 'a', sizeof(buf));
734 	sha256_init_ctx(&ctx);
735 	for (i = 0; i < 1000; ++i) {
736 		sha256_process_bytes (buf, sizeof (buf), &ctx);
737 	}
738 
739 	sha256_finish_ctx(&ctx, sum);
740 
741 	if (memcmp(expected, sum, 32) != 0) {
742 		printf("test %d failed\n", cnt);
743 		result = 1;
744 	}
745 
746 	for (cnt = 0; cnt < ntests2; ++cnt) {
747 		char *cp = php_sha256_crypt(tests2[cnt].input, tests2[cnt].salt);
748 		if (strcmp(cp, tests2[cnt].expected) != 0) {
749 			printf("test %d: expected \"%s\", got \"%s\"\n", cnt, tests2[cnt].expected, cp);
750 			result = 1;
751 		}
752 	}
753 
754 	if (result == 0)
755 	puts("all tests OK");
756 
757 	return result;
758 }
759 #endif
760