aboutsummaryrefslogtreecommitdiff
path: root/libbb/pw_encrypt_md5.c
diff options
context:
space:
mode:
authorDenis Vlasenko <vda.linux@googlemail.com>2008-11-11 01:38:04 +0000
committerDenis Vlasenko <vda.linux@googlemail.com>2008-11-11 01:38:04 +0000
commite9b9a19ad30e004b3532105af417e43575ce7779 (patch)
tree149fe884916ee0be75e384fbcbb908695499c8d7 /libbb/pw_encrypt_md5.c
parent6f05874b9dc4623512878566d144b0905700525d (diff)
downloadbusybox-w32-e9b9a19ad30e004b3532105af417e43575ce7779.tar.gz
busybox-w32-e9b9a19ad30e004b3532105af417e43575ce7779.tar.bz2
busybox-w32-e9b9a19ad30e004b3532105af417e43575ce7779.zip
libbb: disable a second md5 implementation which managed to creep in :)
function old new delta sha512_end 239 237 -2 sha256_end 162 160 -2 sha1_end 191 189 -2 md5_end 168 166 -2 __md5__magic 4 - -4 md5_crypt 627 621 -6 static.S 16 - -16 __md5_Init 42 - -42 static.P 64 - -64 __md5_Final 131 - -131 __md5_Update 153 - -153 static.C 268 12 -256 __md5_Transform 293 - -293 ------------------------------------------------------------------------------ (add/remove: 0/7 grow/shrink: 0/6 up/down: 0/-973) Total: -973 bytes
Diffstat (limited to 'libbb/pw_encrypt_md5.c')
-rw-r--r--libbb/pw_encrypt_md5.c549
1 files changed, 39 insertions, 510 deletions
diff --git a/libbb/pw_encrypt_md5.c b/libbb/pw_encrypt_md5.c
index b7478aa9d..b02cbecfa 100644
--- a/libbb/pw_encrypt_md5.c
+++ b/libbb/pw_encrypt_md5.c
@@ -61,439 +61,14 @@
61 * On i386, sizes are roughly (-Os -fno-builtin): 61 * On i386, sizes are roughly (-Os -fno-builtin):
62 * 0: 3k 1: 2.5k 2: 2.2k 3: 2k 62 * 0: 3k 1: 2.5k 2: 2.2k 3: 2k
63 * 63 *
64 *
65 * Since SuSv3 does not require crypt_r, modified again August 7, 2002 64 * Since SuSv3 does not require crypt_r, modified again August 7, 2002
66 * by Erik Andersen to remove reentrance stuff... 65 * by Erik Andersen to remove reentrance stuff...
67 */ 66 */
68 67
69/*
70 * Valid values are 1 (fastest/largest) to 3 (smallest/slowest).
71 */
72#define MD5_SIZE_OVER_SPEED 3
73
74/**********************************************************************/
75
76/* MD5 context. */
77struct MD5Context {
78 uint32_t state[4]; /* state (ABCD) */
79 uint32_t count[2]; /* number of bits, modulo 2^64 (lsb first) */
80 unsigned char buffer[64]; /* input buffer */
81};
82
83static void __md5_Init(struct MD5Context *);
84static void __md5_Update(struct MD5Context *, const unsigned char *, unsigned int);
85static void __md5_Pad(struct MD5Context *);
86static void __md5_Final(unsigned char [16], struct MD5Context *);
87static void __md5_Transform(uint32_t [4], const unsigned char [64]);
88
89
90#define MD5_MAGIC_STR "$1$" 68#define MD5_MAGIC_STR "$1$"
91#define MD5_MAGIC_LEN (sizeof(MD5_MAGIC_STR) - 1) 69#define MD5_MAGIC_LEN (sizeof(MD5_MAGIC_STR) - 1)
92static const unsigned char __md5__magic[] = MD5_MAGIC_STR; 70static const unsigned char __md5__magic[] = MD5_MAGIC_STR;
93 71
94
95#ifdef i386
96#define __md5_Encode memcpy
97#define __md5_Decode memcpy
98#else /* i386 */
99
100/*
101 * __md5_Encodes input (uint32_t) into output (unsigned char). Assumes len is
102 * a multiple of 4.
103 */
104static void
105__md5_Encode(unsigned char *output, uint32_t *input, unsigned int len)
106{
107 unsigned int i, j;
108
109 for (i = 0, j = 0; j < len; i++, j += 4) {
110 output[j] = input[i];
111 output[j+1] = (input[i] >> 8);
112 output[j+2] = (input[i] >> 16);
113 output[j+3] = (input[i] >> 24);
114 }
115}
116
117/*
118 * __md5_Decodes input (unsigned char) into output (uint32_t). Assumes len is
119 * a multiple of 4.
120 */
121static void
122__md5_Decode(uint32_t *output, const unsigned char *input, unsigned int len)
123{
124 unsigned int i, j;
125
126 for (i = 0, j = 0; j < len; i++, j += 4)
127 output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) |
128 (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
129}
130#endif /* i386 */
131
132/* F, G, H and I are basic MD5 functions. */
133#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
134#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
135#define H(x, y, z) ((x) ^ (y) ^ (z))
136#define I(x, y, z) ((y) ^ ((x) | ~(z)))
137
138/* ROTATE_LEFT rotates x left n bits. */
139#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
140
141/*
142 * FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
143 * Rotation is separate from addition to prevent recomputation.
144 */
145#define FF(a, b, c, d, x, s, ac) { \
146 (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
147 (a) = ROTATE_LEFT((a), (s)); \
148 (a) += (b); \
149 }
150#define GG(a, b, c, d, x, s, ac) { \
151 (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
152 (a) = ROTATE_LEFT((a), (s)); \
153 (a) += (b); \
154 }
155#define HH(a, b, c, d, x, s, ac) { \
156 (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
157 (a) = ROTATE_LEFT((a), (s)); \
158 (a) += (b); \
159 }
160#define II(a, b, c, d, x, s, ac) { \
161 (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
162 (a) = ROTATE_LEFT((a), (s)); \
163 (a) += (b); \
164 }
165
166/* MD5 initialization. Begins an MD5 operation, writing a new context. */
167static void __md5_Init(struct MD5Context *context)
168{
169 context->count[0] = context->count[1] = 0;
170
171 /* Load magic initialization constants. */
172 context->state[0] = 0x67452301;
173 context->state[1] = 0xefcdab89;
174 context->state[2] = 0x98badcfe;
175 context->state[3] = 0x10325476;
176}
177
178/*
179 * MD5 block update operation. Continues an MD5 message-digest
180 * operation, processing another message block, and updating the
181 * context.
182 */
183static void __md5_Update(struct MD5Context *context, const unsigned char *input, unsigned int inputLen)
184{
185 unsigned int i, idx, partLen;
186
187 /* Compute number of bytes mod 64 */
188 idx = (context->count[0] >> 3) & 0x3F;
189
190 /* Update number of bits */
191 context->count[0] += (inputLen << 3);
192 if (context->count[0] < (inputLen << 3))
193 context->count[1]++;
194 context->count[1] += (inputLen >> 29);
195
196 partLen = 64 - idx;
197
198 /* Transform as many times as possible. */
199 if (inputLen >= partLen) {
200 memcpy(&context->buffer[idx], input, partLen);
201 __md5_Transform(context->state, context->buffer);
202
203 for (i = partLen; i + 63 < inputLen; i += 64)
204 __md5_Transform(context->state, &input[i]);
205
206 idx = 0;
207 } else
208 i = 0;
209
210 /* Buffer remaining input */
211 memcpy(&context->buffer[idx], &input[i], inputLen - i);
212}
213
214/*
215 * MD5 padding. Adds padding followed by original length.
216 */
217static void __md5_Pad(struct MD5Context *context)
218{
219 unsigned char bits[8];
220 unsigned int idx, padLen;
221 unsigned char PADDING[64];
222
223 memset(PADDING, 0, sizeof(PADDING));
224 PADDING[0] = 0x80;
225
226 /* Save number of bits */
227 __md5_Encode(bits, context->count, 8);
228
229 /* Pad out to 56 mod 64. */
230 idx = (context->count[0] >> 3) & 0x3f;
231 padLen = (idx < 56) ? (56 - idx) : (120 - idx);
232 __md5_Update(context, PADDING, padLen);
233
234 /* Append length (before padding) */
235 __md5_Update(context, bits, 8);
236}
237
238/*
239 * MD5 finalization. Ends an MD5 message-digest operation, writing the
240 * the message digest and zeroizing the context.
241 */
242static void __md5_Final(unsigned char digest[16], struct MD5Context *context)
243{
244 /* Do padding. */
245 __md5_Pad(context);
246
247 /* Store state in digest */
248 __md5_Encode(digest, context->state, 16);
249
250 /* Zeroize sensitive information. */
251 memset(context, 0, sizeof(*context));
252}
253
254/* MD5 basic transformation. Transforms state based on block. */
255static void __md5_Transform(uint32_t state[4], const unsigned char block[64])
256{
257 uint32_t a, b, c, d, x[16];
258#if MD5_SIZE_OVER_SPEED > 1
259 uint32_t temp;
260 const unsigned char *ps;
261
262 static const unsigned char S[] = {
263 7, 12, 17, 22,
264 5, 9, 14, 20,
265 4, 11, 16, 23,
266 6, 10, 15, 21
267 };
268#endif /* MD5_SIZE_OVER_SPEED > 1 */
269
270#if MD5_SIZE_OVER_SPEED > 0
271 const uint32_t *pc;
272 const unsigned char *pp;
273 int i;
274
275 static const uint32_t C[] = {
276 /* round 1 */
277 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
278 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
279 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
280 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
281 /* round 2 */
282 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
283 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
284 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
285 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
286 /* round 3 */
287 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
288 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
289 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
290 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
291 /* round 4 */
292 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
293 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
294 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
295 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
296 };
297
298 static const unsigned char P[] = {
299 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
300 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
301 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
302 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */
303 };
304
305#endif /* MD5_SIZE_OVER_SPEED > 0 */
306
307 __md5_Decode(x, block, 64);
308
309 a = state[0]; b = state[1]; c = state[2]; d = state[3];
310
311#if MD5_SIZE_OVER_SPEED > 2
312 pc = C; pp = P; ps = S - 4;
313
314 for (i = 0; i < 64; i++) {
315 if ((i & 0x0f) == 0) ps += 4;
316 temp = a;
317 switch (i>>4) {
318 case 0:
319 temp += F(b, c, d);
320 break;
321 case 1:
322 temp += G(b, c, d);
323 break;
324 case 2:
325 temp += H(b, c, d);
326 break;
327 case 3:
328 temp += I(b, c, d);
329 break;
330 }
331 temp += x[*pp++] + *pc++;
332 temp = ROTATE_LEFT(temp, ps[i & 3]);
333 temp += b;
334 a = d; d = c; c = b; b = temp;
335 }
336#elif MD5_SIZE_OVER_SPEED > 1
337 pc = C; pp = P; ps = S;
338
339 /* Round 1 */
340 for (i = 0; i < 16; i++) {
341 FF(a, b, c, d, x[*pp], ps[i & 0x3], *pc); pp++; pc++;
342 temp = d; d = c; c = b; b = a; a = temp;
343 }
344
345 /* Round 2 */
346 ps += 4;
347 for (; i < 32; i++) {
348 GG(a, b, c, d, x[*pp], ps[i & 0x3], *pc); pp++; pc++;
349 temp = d; d = c; c = b; b = a; a = temp;
350 }
351 /* Round 3 */
352 ps += 4;
353 for (; i < 48; i++) {
354 HH(a, b, c, d, x[*pp], ps[i & 0x3], *pc); pp++; pc++;
355 temp = d; d = c; c = b; b = a; a = temp;
356 }
357
358 /* Round 4 */
359 ps += 4;
360 for (; i < 64; i++) {
361 II(a, b, c, d, x[*pp], ps[i & 0x3], *pc); pp++; pc++;
362 temp = d; d = c; c = b; b = a; a = temp;
363 }
364#elif MD5_SIZE_OVER_SPEED > 0
365 pc = C; pp = P;
366
367 /* Round 1 */
368 for (i = 0; i < 4; i++) {
369 FF(a, b, c, d, x[*pp], 7, *pc); pp++; pc++;
370 FF(d, a, b, c, x[*pp], 12, *pc); pp++; pc++;
371 FF(c, d, a, b, x[*pp], 17, *pc); pp++; pc++;
372 FF(b, c, d, a, x[*pp], 22, *pc); pp++; pc++;
373 }
374
375 /* Round 2 */
376 for (i = 0; i < 4; i++) {
377 GG(a, b, c, d, x[*pp], 5, *pc); pp++; pc++;
378 GG(d, a, b, c, x[*pp], 9, *pc); pp++; pc++;
379 GG(c, d, a, b, x[*pp], 14, *pc); pp++; pc++;
380 GG(b, c, d, a, x[*pp], 20, *pc); pp++; pc++;
381 }
382 /* Round 3 */
383 for (i = 0; i < 4; i++) {
384 HH(a, b, c, d, x[*pp], 4, *pc); pp++; pc++;
385 HH(d, a, b, c, x[*pp], 11, *pc); pp++; pc++;
386 HH(c, d, a, b, x[*pp], 16, *pc); pp++; pc++;
387 HH(b, c, d, a, x[*pp], 23, *pc); pp++; pc++;
388 }
389
390 /* Round 4 */
391 for (i = 0; i < 4; i++) {
392 II(a, b, c, d, x[*pp], 6, *pc); pp++; pc++;
393 II(d, a, b, c, x[*pp], 10, *pc); pp++; pc++;
394 II(c, d, a, b, x[*pp], 15, *pc); pp++; pc++;
395 II(b, c, d, a, x[*pp], 21, *pc); pp++; pc++;
396 }
397#else
398 /* Round 1 */
399#define S11 7
400#define S12 12
401#define S13 17
402#define S14 22
403 FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
404 FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
405 FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
406 FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
407 FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
408 FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
409 FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
410 FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
411 FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
412 FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
413 FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
414 FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
415 FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
416 FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
417 FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
418 FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
419
420 /* Round 2 */
421#define S21 5
422#define S22 9
423#define S23 14
424#define S24 20
425 GG(a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
426 GG(d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
427 GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
428 GG(b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
429 GG(a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
430 GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
431 GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
432 GG(b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
433 GG(a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
434 GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
435 GG(c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
436 GG(b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
437 GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
438 GG(d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
439 GG(c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
440 GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
441
442 /* Round 3 */
443#define S31 4
444#define S32 11
445#define S33 16
446#define S34 23
447 HH(a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
448 HH(d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
449 HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
450 HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
451 HH(a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
452 HH(d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
453 HH(c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
454 HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
455 HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
456 HH(d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
457 HH(c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
458 HH(b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
459 HH(a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
460 HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
461 HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
462 HH(b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
463
464 /* Round 4 */
465#define S41 6
466#define S42 10
467#define S43 15
468#define S44 21
469 II(a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
470 II(d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
471 II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
472 II(b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
473 II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
474 II(d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
475 II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
476 II(b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
477 II(a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
478 II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
479 II(c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
480 II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
481 II(a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
482 II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
483 II(c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
484 II(b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
485#endif
486
487 state[0] += a;
488 state[1] += b;
489 state[2] += c;
490 state[3] += d;
491
492 /* Zeroize sensitive information. */
493 memset(x, 0, sizeof(x));
494}
495
496
497/* 72/*
498 * UNIX password 73 * UNIX password
499 * 74 *
@@ -502,94 +77,77 @@ static void __md5_Transform(uint32_t state[4], const unsigned char block[64])
502#define MD5_OUT_BUFSIZE 36 77#define MD5_OUT_BUFSIZE 36
503static char * 78static char *
504NOINLINE 79NOINLINE
505md5_crypt(char passwd[MD5_OUT_BUFSIZE], const unsigned char *pw, const unsigned char *salt) 80md5_crypt(char result[MD5_OUT_BUFSIZE], const unsigned char *pw, const unsigned char *salt)
506{ 81{
507 const unsigned char *sp, *ep;
508 char *p; 82 char *p;
509 unsigned char final[17]; /* final[16] exists only to aid in looping */ 83 unsigned char final[17]; /* final[16] exists only to aid in looping */
510 int sl, pl, i, pw_len; 84 int sl, pl, i, pw_len;
511 struct MD5Context ctx, ctx1; 85 md5_ctx_t ctx, ctx1;
512
513 /* Refine the Salt first */
514 sp = salt;
515 86
516// always true for bbox 87 /* NB: in busybox, "$1$" in salt is always present */
517// /* If it starts with the magic string, then skip that */
518// if (!strncmp(sp, __md5__magic, MD5_MAGIC_LEN))
519 sp += MD5_MAGIC_LEN;
520 88
521 /* It stops at the first '$', max 8 chars */ 89 /* Refine the Salt first */
522 for (ep = sp; *ep && *ep != '$' && ep < (sp+8); ep++)
523 continue;
524
525 /* get the length of the true salt */
526 sl = ep - sp;
527 90
528 __md5_Init(&ctx); 91 /* Get the length of the salt including "$1$" */
92 sl = 3;
93 while (salt[sl] && salt[sl] != '$' && sl < (3 + 8))
94 sl++;
529 95
530 /* The password first, since that is what is most unknown */ 96 /* Hash. the password first, since that is what is most unknown */
97 md5_begin(&ctx);
531 pw_len = strlen((char*)pw); 98 pw_len = strlen((char*)pw);
532 __md5_Update(&ctx, pw, pw_len); 99 md5_hash(pw, pw_len, &ctx);
533 100
534 /* Then our magic string */ 101 /* Then the salt including "$1$" */
535 __md5_Update(&ctx, __md5__magic, MD5_MAGIC_LEN); 102 md5_hash(salt, sl, &ctx);
536 103
537 /* Then the raw salt */ 104 /* Copy salt to result; skip "$1$" */
538 __md5_Update(&ctx, sp, sl); 105 memcpy(result, salt, sl);
106 result[sl] = '$';
107 salt += 3;
108 sl -= 3;
539 109
540 /* Then just as many characters of the MD5(pw, salt, pw) */ 110 /* Then just as many characters of the MD5(pw, salt, pw) */
541 __md5_Init(&ctx1); 111 md5_begin(&ctx1);
542 __md5_Update(&ctx1, pw, pw_len); 112 md5_hash(pw, pw_len, &ctx1);
543 __md5_Update(&ctx1, sp, sl); 113 md5_hash(salt, sl, &ctx1);
544 __md5_Update(&ctx1, pw, pw_len); 114 md5_hash(pw, pw_len, &ctx1);
545 __md5_Final(final, &ctx1); 115 md5_end(final, &ctx1);
546 for (pl = pw_len; pl > 0; pl -= 16) 116 for (pl = pw_len; pl > 0; pl -= 16)
547 __md5_Update(&ctx, final, pl > 16 ? 16 : pl); 117 md5_hash(final, pl > 16 ? 16 : pl, &ctx);
548
549 /* Don't leave anything around in vm they could use. */
550//TODO: the above comment seems to be wrong. final is used later.
551 memset(final, 0, sizeof(final));
552 118
553 /* Then something really weird... */ 119 /* Then something really weird... */
120 memset(final, 0, sizeof(final));
554 for (i = pw_len; i; i >>= 1) { 121 for (i = pw_len; i; i >>= 1) {
555 __md5_Update(&ctx, ((i & 1) ? final : (const unsigned char *) pw), 1); 122 md5_hash(((i & 1) ? final : (const unsigned char *) pw), 1, &ctx);
556 } 123 }
124 md5_end(final, &ctx);
557 125
558 /* Now make the output string */ 126 /* And now, just to make sure things don't run too fast.
559 passwd[0] = '$';
560 passwd[1] = '1';
561 passwd[2] = '$';
562 strncpy(passwd + 3, (char*)sp, sl);
563 passwd[sl + 3] = '$';
564
565 __md5_Final(final, &ctx);
566
567 /*
568 * and now, just to make sure things don't run too fast
569 * On a 60 Mhz Pentium this takes 34 msec, so you would 127 * On a 60 Mhz Pentium this takes 34 msec, so you would
570 * need 30 seconds to build a 1000 entry dictionary... 128 * need 30 seconds to build a 1000 entry dictionary...
571 */ 129 */
572 for (i = 0; i < 1000; i++) { 130 for (i = 0; i < 1000; i++) {
573 __md5_Init(&ctx1); 131 md5_begin(&ctx1);
574 if (i & 1) 132 if (i & 1)
575 __md5_Update(&ctx1, pw, pw_len); 133 md5_hash(pw, pw_len, &ctx1);
576 else 134 else
577 __md5_Update(&ctx1, final, 16); 135 md5_hash(final, 16, &ctx1);
578 136
579 if (i % 3) 137 if (i % 3)
580 __md5_Update(&ctx1, sp, sl); 138 md5_hash(salt, sl, &ctx1);
581 139
582 if (i % 7) 140 if (i % 7)
583 __md5_Update(&ctx1, pw, pw_len); 141 md5_hash(pw, pw_len, &ctx1);
584 142
585 if (i & 1) 143 if (i & 1)
586 __md5_Update(&ctx1, final, 16); 144 md5_hash(final, 16, &ctx1);
587 else 145 else
588 __md5_Update(&ctx1, pw, pw_len); 146 md5_hash(pw, pw_len, &ctx1);
589 __md5_Final(final, &ctx1); 147 md5_end(final, &ctx1);
590 } 148 }
591 149
592 p = passwd + sl + 4; /* 12 bytes max (sl is up to 8 bytes) */ 150 p = result + sl + 4; /* 12 bytes max (sl is up to 8 bytes) */
593 151
594 /* Add 5*4+2 = 22 bytes of hash, + NUL byte. */ 152 /* Add 5*4+2 = 22 bytes of hash, + NUL byte. */
595 final[16] = final[5]; 153 final[16] = final[5];
@@ -603,36 +161,7 @@ md5_crypt(char passwd[MD5_OUT_BUFSIZE], const unsigned char *pw, const unsigned
603 /* Don't leave anything around in vm they could use. */ 161 /* Don't leave anything around in vm they could use. */
604 memset(final, 0, sizeof(final)); 162 memset(final, 0, sizeof(final));
605 163
606 return passwd; 164 return result;
607} 165}
608
609#undef MD5_SIZE_OVER_SPEED
610#undef MD5_MAGIC_STR 166#undef MD5_MAGIC_STR
611#undef MD5_MAGIC_LEN 167#undef MD5_MAGIC_LEN
612#undef __md5_Encode
613#undef __md5_Decode
614#undef F
615#undef G
616#undef H
617#undef I
618#undef ROTATE_LEFT
619#undef FF
620#undef GG
621#undef HH
622#undef II
623#undef S11
624#undef S12
625#undef S13
626#undef S14
627#undef S21
628#undef S22
629#undef S23
630#undef S24
631#undef S31
632#undef S32
633#undef S33
634#undef S34
635#undef S41
636#undef S42
637#undef S43
638#undef S44
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-17 20:39:25 +0000