1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
|
/* $Id$ */
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2008 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Pierre Alain Joye <pajoye@php.net |
+----------------------------------------------------------------------+
*/
/*
* License for the Unix md5crypt implementation (md5_crypt):
*
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@login.dknet.dk> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ----------------------------------------------------------------------------
*
* from FreeBSD: crypt.c,v 1.5 1996/10/14 08:34:02 phk Exp
* via OpenBSD: md5crypt.c,v 1.9 1997/07/23 20:58:27 kstailey Exp
* via NetBSD: md5crypt.c,v 1.4.2.1 2002/01/22 19:31:59 he Exp
*
*/
#include "php.h"
#include <string.h>
#if PHP_WIN32
# include <windows.h>
# include <Wincrypt.h>
#endif
#include <signal.h>
#include "php_crypt_r.h"
#include "crypt_freesec.h"
#if !PHP_WIN32
#include "ext/standard/md5.h"
#endif
#ifdef ZTS
MUTEX_T php_crypt_extended_init_lock;
#endif
/* TODO: enable it when enabling vista/2k8 mode in tsrm */
#if 0
CONDITION_VARIABLE initialized;
#endif
void php_init_crypt_r()
{
#ifdef ZTS
php_crypt_extended_init_lock = tsrm_mutex_alloc();
#endif
}
void php_shutdown_crypt_r()
{
#ifdef ZTS
tsrm_mutex_free(php_crypt_extended_init_lock);
#endif
}
void _crypt_extended_init_r(void)
{
static volatile sig_atomic_t initialized = 0;
#ifdef ZTS
tsrm_mutex_lock(php_crypt_extended_init_lock);
#endif
if (initialized) {
return;
} else {
_crypt_extended_init();
initialized = 1;
}
#ifdef ZTS
tsrm_mutex_unlock(php_crypt_extended_init_lock);
#endif
}
/* MD% crypt implementation using the windows CryptoApi */
#define MD5_MAGIC "$1$"
#define MD5_MAGIC_LEN 3
static unsigned char itoa64[] = /* 0 ... 63 => ascii - 64 */
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static void
to64(char *s, int32_t v, int n)
{
while (--n >= 0) {
*s++ = itoa64[v & 0x3f];
v >>= 6;
}
}
#if PHP_WIN32
char * php_md5_crypt_r(const char *pw, const char *salt, char *out) {
HCRYPTPROV hCryptProv;
HCRYPTHASH ctx, ctx1;
unsigned int i, pwl, sl;
const BYTE magic_md5[4] = "$1$";
const DWORD magic_md5_len = 3;
DWORD dwHashLen;
int pl;
__int32 l;
const char *sp = salt;
const char *ep = salt;
char *p = NULL;
char *passwd = out;
unsigned char final[16];
/* Acquire a cryptographic provider context handle. */
if(!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
return NULL;
}
pwl = (unsigned int) strlen(pw);
/* Refine the salt first */
sp = salt;
/* If it starts with the magic string, then skip that */
if (strncmp(sp, MD5_MAGIC, MD5_MAGIC_LEN) == 0) {
sp += MD5_MAGIC_LEN;
}
/* It stops at the first '$', max 8 chars */
for (ep = sp; *ep != '\0' && *ep != '$' && ep < (sp + 8); ep++) {
continue;
}
/* get the length of the true salt */
sl = ep - sp;
/* Create an empty hash object. */
if(!CryptCreateHash(hCryptProv, CALG_MD5, 0, 0, &ctx)) {
goto _destroyProv;
}
/* The password first, since that is what is most unknown */
if(!CryptHashData(ctx, (BYTE *)pw, pwl, 0)) {
goto _destroyCtx0;
}
/* Then our magic string */
if(!CryptHashData(ctx, magic_md5, magic_md5_len, 0)) {
goto _destroyCtx0;
}
/* Then the raw salt */
if(!CryptHashData( ctx, (BYTE *)sp, sl, 0)) {
goto _destroyCtx0;
}
/* MD5(pw,salt,pw), valid. */
/* Then just as many characters of the MD5(pw,salt,pw) */
if(!CryptCreateHash(hCryptProv, CALG_MD5, 0, 0, &ctx1)) {
goto _destroyCtx0;
}
if(!CryptHashData(ctx1, (BYTE *)pw, pwl, 0)) {
goto _destroyCtx1;
}
if(!CryptHashData(ctx1, (BYTE *)sp, sl, 0)) {
goto _destroyCtx1;
}
if(!CryptHashData(ctx1, (BYTE *)pw, pwl, 0)) {
goto _destroyCtx1;
}
dwHashLen = pwl + sl + pwl;
CryptGetHashParam(ctx1, HP_HASHVAL, final, &dwHashLen, 0);
/* MD5(pw,salt,pw). Valid. */
for (pl = pwl; pl > 0; pl -= 16) {
CryptHashData(ctx, final, (DWORD)(pl > 16 ? 16 : pl), 0);
}
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
/* Then something really weird... */
for (i = pwl; i != 0; i >>= 1) {
if ((i & 1) != 0) {
CryptHashData(ctx, (const BYTE *)final, 1, 0);
} else {
CryptHashData(ctx, (const BYTE *)pw, 1, 0);
}
}
memcpy(passwd, MD5_MAGIC, MD5_MAGIC_LEN);
#if _MSC_VER >= 1500
if (strncpy_s(passwd + MD5_MAGIC_LEN, MD5_HASH_MAX_LEN - MD5_MAGIC_LEN, sp, sl + 1) != 0) {
goto _destroyCtx1;
}
strcat_s(passwd, MD5_HASH_MAX_LEN, "$");
#else
/* VC6 version doesn't have strcat_s or strncpy_s */
if (strncpy(passwd + MD5_MAGIC_LEN, sp, sl + 1) < sl) {
goto _destroyCtx1;
}
strcat(passwd, "$");
#endif
dwHashLen = 16;
/* Fetch the ctx hash value */
CryptGetHashParam(ctx, HP_HASHVAL, final, &dwHashLen, 0);
for (i = 0; i < 1000; i++) {
if(!CryptCreateHash(hCryptProv, CALG_MD5, 0, 0, &ctx1)) {
goto _destroyCtx1;
}
if ((i & 1) != 0) {
if(!CryptHashData(ctx1, (BYTE *)pw, pwl, 0)) {
goto _destroyCtx1;
}
} else {
if(!CryptHashData(ctx1, (BYTE *)final, 16, 0)) {
goto _destroyCtx1;
}
}
if ((i % 3) != 0) {
if(!CryptHashData(ctx1, (BYTE *)sp, sl, 0)) {
goto _destroyCtx1;
}
}
if ((i % 7) != 0) {
if(!CryptHashData(ctx1, (BYTE *)pw, pwl, 0)) {
goto _destroyCtx1;
}
}
if ((i & 1) != 0) {
if(!CryptHashData(ctx1, (BYTE *)final, 16, 0)) {
goto _destroyCtx1;
}
} else {
if(!CryptHashData(ctx1, (BYTE *)pw, pwl, 0)) {
goto _destroyCtx1;
}
}
/* Fetch the ctx hash value */
dwHashLen = 16;
CryptGetHashParam(ctx1, HP_HASHVAL, final, &dwHashLen, 0);
if(!(CryptDestroyHash(ctx1))) {
goto _destroyCtx0;
}
}
ctx1 = (HCRYPTHASH) NULL;
p = passwd + sl + MD5_MAGIC_LEN + 1;
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p,l,4); p += 4;
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p,l,4); p += 4;
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p,l,4); p += 4;
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p,l,4); p += 4;
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p,l,4); p += 4;
l = final[11]; to64(p,l,2); p += 2;
*p = '\0';
memset(final, 0, sizeof(final));
_destroyCtx1:
if (ctx1) {
if (!CryptDestroyHash(ctx1)) {
}
}
_destroyCtx0:
CryptDestroyHash(ctx);
_destroyProv:
/* Release the provider handle.*/
if(hCryptProv) {
if(!(CryptReleaseContext(hCryptProv, 0))) {
return NULL;
}
}
return out;
}
#else
/*
* MD5 password encryption.
*/
char * php_md5_crypt_r(const char *pw, const char *salt, char *out)
{
static char passwd[MD5_HASH_MAX_LEN], *p;
const char *sp, *ep;
unsigned char final[16];
unsigned int i, sl, pwl;
PHP_MD5_CTX ctx, ctx1;
php_uint32 l;
int pl;
pwl = strlen(pw);
/* Refine the salt first */
sp = salt;
/* If it starts with the magic string, then skip that */
if (strncmp(sp, MD5_MAGIC, MD5_MAGIC_LEN) == 0)
sp += MD5_MAGIC_LEN;
/* It stops at the first '$', max 8 chars */
for (ep = sp; *ep != '\0' && *ep != '$' && ep < (sp + 8); ep++)
continue;
/* get the length of the true salt */
sl = ep - sp;
PHP_MD5Init(&ctx);
/* The password first, since that is what is most unknown */
PHP_MD5Update(&ctx, (const unsigned char *)pw, pwl);
/* Then our magic string */
PHP_MD5Update(&ctx, (const unsigned char *)MD5_MAGIC, MD5_MAGIC_LEN);
/* Then the raw salt */
PHP_MD5Update(&ctx, (const unsigned char *)sp, sl);
/* Then just as many characters of the MD5(pw,salt,pw) */
PHP_MD5Init(&ctx1);
PHP_MD5Update(&ctx1, (const unsigned char *)pw, pwl);
PHP_MD5Update(&ctx1, (const unsigned char *)sp, sl);
PHP_MD5Update(&ctx1, (const unsigned char *)pw, pwl);
PHP_MD5Final(final, &ctx1);
for (pl = pwl; pl > 0; pl -= 16)
PHP_MD5Update(&ctx, final, (unsigned int)(pl > 16 ? 16 : pl));
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
/* Then something really weird... */
for (i = pwl; i != 0; i >>= 1)
if ((i & 1) != 0)
PHP_MD5Update(&ctx, final, 1);
else
PHP_MD5Update(&ctx, (const unsigned char *)pw, 1);
/* Now make the output string */
memcpy(passwd, MD5_MAGIC, MD5_MAGIC_LEN);
strlcpy(passwd + MD5_MAGIC_LEN, sp, sl + 1);
strcat(passwd, "$");
PHP_MD5Final(final, &ctx);
/*
* And now, just to make sure things don't run too fast. On a 60 MHz
* Pentium this takes 34 msec, so you would need 30 seconds to build
* a 1000 entry dictionary...
*/
for (i = 0; i < 1000; i++) {
PHP_MD5Init(&ctx1);
if ((i & 1) != 0)
PHP_MD5Update(&ctx1, (const unsigned char *)pw, pwl);
else
PHP_MD5Update(&ctx1, final, 16);
if ((i % 3) != 0)
PHP_MD5Update(&ctx1, (const unsigned char *)sp, sl);
if ((i % 7) != 0)
PHP_MD5Update(&ctx1, (const unsigned char *)pw, pwl);
if ((i & 1) != 0)
PHP_MD5Update(&ctx1, final, 16);
else
PHP_MD5Update(&ctx1, (const unsigned char *)pw, pwl);
PHP_MD5Final(final, &ctx1);
}
p = passwd + sl + MD5_MAGIC_LEN + 1;
l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p,l,4); p += 4;
l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p,l,4); p += 4;
l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p,l,4); p += 4;
l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p,l,4); p += 4;
l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p,l,4); p += 4;
l = final[11] ; to64(p,l,2); p += 2;
*p = '\0';
/* Don't leave anything around in vm they could use. */
memset(final, 0, sizeof(final));
return (passwd);
}
#undef MD5_MAGIC
#undef MD5_MAGIC_LEN
#endif
|