2 * MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
4 * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
7 * License to copy and use this software is granted provided that it
8 * is identified as the "RSA Data Security, Inc. MD5 Message-Digest
9 * Algorithm" in all material mentioning or referencing this software
12 * License is also granted to make and use derivative works provided
13 * that such works are identified as "derived from the RSA Data
14 * Security, Inc. MD5 Message-Digest Algorithm" in all material
15 * mentioning or referencing the derived work.
17 * RSA Data Security, Inc. makes no representations concerning either
18 * the merchantability of this software or the suitability of this
19 * software for any particular purpose. It is provided "as is"
20 * without express or implied warranty of any kind.
22 * These notices must be retained in any copies of any part of this
23 * documentation and/or software.
25 * $FreeBSD: src/lib/libmd/md5c.c,v 1.9.2.1 1999/08/29 14:57:12 peter Exp $
27 * This code is the same as the code published by RSA Inc. It has been
28 * edited for clarity and style only.
30 * ----------------------------------------------------------------------------
31 * The md5_crypt() function was taken from freeBSD's libcrypt and contains
33 * "THE BEER-WARE LICENSE" (Revision 42):
34 * <phk@login.dknet.dk> wrote this file. As long as you retain this notice you
35 * can do whatever you want with this stuff. If we meet some day, and you think
36 * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
38 * $FreeBSD: src/lib/libcrypt/crypt.c,v 1.7.2.1 1999/08/29 14:56:33 peter Exp $
40 * ----------------------------------------------------------------------------
41 * On April 19th, 2001 md5_crypt() was modified to make it reentrant
42 * by Erik Andersen <andersen@uclibc.org>
45 * June 28, 2001 Manuel Novoa III
47 * "Un-inlined" code using loops and static const tables in order to
48 * reduce generated code size (on i386 from approx 4k to approx 2.5k).
50 * June 29, 2001 Manuel Novoa III
52 * Completely removed static PADDING array.
54 * Reintroduced the loop unrolling in MD5_Transform and added the
55 * MD5_SIZE_OVER_SPEED option for configurability. Define below as:
56 * 0 fully unrolled loops
57 * 1 partially unrolled (4 ops per loop)
58 * 2 no unrolling -- introduces the need to swap 4 variables (slow)
59 * 3 no unrolling and all 4 loops merged into one with switch
60 * in each loop (glacial)
61 * On i386, sizes are roughly (-Os -fno-builtin):
62 * 0: 3k 1: 2.5k 2: 2.2k 3: 2k
65 * Since SuSv3 does not require crypt_r, modified again August 7, 2002
66 * by Erik Andersen to remove reentrance stuff...
69 static const uint8_t ascii64
[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
72 * Valid values are 1 (fastest/largest) to 3 (smallest/slowest).
74 #define MD5_SIZE_OVER_SPEED 3
76 /**********************************************************************/
80 uint32_t state
[4]; /* state (ABCD) */
81 uint32_t count
[2]; /* number of bits, modulo 2^64 (lsb first) */
82 unsigned char buffer
[64]; /* input buffer */
85 static void __md5_Init(struct MD5Context
*);
86 static void __md5_Update(struct MD5Context
*, const unsigned char *, unsigned int);
87 static void __md5_Pad(struct MD5Context
*);
88 static void __md5_Final(unsigned char [16], struct MD5Context
*);
89 static void __md5_Transform(uint32_t [4], const unsigned char [64]);
92 #define MD5_MAGIC_STR "$1$"
93 #define MD5_MAGIC_LEN (sizeof(MD5_MAGIC_STR) - 1)
94 static const unsigned char __md5__magic
[] = MD5_MAGIC_STR
;
98 #define __md5_Encode memcpy
99 #define __md5_Decode memcpy
103 * __md5_Encodes input (uint32_t) into output (unsigned char). Assumes len is
107 __md5_Encode(unsigned char *output
, uint32_t *input
, unsigned int len
)
111 for (i
= 0, j
= 0; j
< len
; i
++, j
+= 4) {
112 output
[j
] = input
[i
];
113 output
[j
+1] = (input
[i
] >> 8);
114 output
[j
+2] = (input
[i
] >> 16);
115 output
[j
+3] = (input
[i
] >> 24);
120 * __md5_Decodes input (unsigned char) into output (uint32_t). Assumes len is
124 __md5_Decode(uint32_t *output
, const unsigned char *input
, unsigned int len
)
128 for (i
= 0, j
= 0; j
< len
; i
++, j
+= 4)
129 output
[i
] = ((uint32_t)input
[j
]) | (((uint32_t)input
[j
+1]) << 8) |
130 (((uint32_t)input
[j
+2]) << 16) | (((uint32_t)input
[j
+3]) << 24);
134 /* F, G, H and I are basic MD5 functions. */
135 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
136 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
137 #define H(x, y, z) ((x) ^ (y) ^ (z))
138 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
140 /* ROTATE_LEFT rotates x left n bits. */
141 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
144 * FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
145 * Rotation is separate from addition to prevent recomputation.
147 #define FF(a, b, c, d, x, s, ac) { \
148 (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
149 (a) = ROTATE_LEFT((a), (s)); \
152 #define GG(a, b, c, d, x, s, ac) { \
153 (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
154 (a) = ROTATE_LEFT((a), (s)); \
157 #define HH(a, b, c, d, x, s, ac) { \
158 (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
159 (a) = ROTATE_LEFT((a), (s)); \
162 #define II(a, b, c, d, x, s, ac) { \
163 (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
164 (a) = ROTATE_LEFT((a), (s)); \
168 /* MD5 initialization. Begins an MD5 operation, writing a new context. */
169 static void __md5_Init(struct MD5Context
*context
)
171 context
->count
[0] = context
->count
[1] = 0;
173 /* Load magic initialization constants. */
174 context
->state
[0] = 0x67452301;
175 context
->state
[1] = 0xefcdab89;
176 context
->state
[2] = 0x98badcfe;
177 context
->state
[3] = 0x10325476;
181 * MD5 block update operation. Continues an MD5 message-digest
182 * operation, processing another message block, and updating the
185 static void __md5_Update(struct MD5Context
*context
, const unsigned char *input
, unsigned int inputLen
)
187 unsigned int i
, idx
, partLen
;
189 /* Compute number of bytes mod 64 */
190 idx
= (context
->count
[0] >> 3) & 0x3F;
192 /* Update number of bits */
193 context
->count
[0] += (inputLen
<< 3);
194 if (context
->count
[0] < (inputLen
<< 3))
196 context
->count
[1] += (inputLen
>> 29);
200 /* Transform as many times as possible. */
201 if (inputLen
>= partLen
) {
202 memcpy(&context
->buffer
[idx
], input
, partLen
);
203 __md5_Transform(context
->state
, context
->buffer
);
205 for (i
= partLen
; i
+ 63 < inputLen
; i
+= 64)
206 __md5_Transform(context
->state
, &input
[i
]);
212 /* Buffer remaining input */
213 memcpy(&context
->buffer
[idx
], &input
[i
], inputLen
- i
);
217 * MD5 padding. Adds padding followed by original length.
219 static void __md5_Pad(struct MD5Context
*context
)
221 unsigned char bits
[8];
222 unsigned int idx
, padLen
;
223 unsigned char PADDING
[64];
225 memset(PADDING
, 0, sizeof(PADDING
));
228 /* Save number of bits */
229 __md5_Encode(bits
, context
->count
, 8);
231 /* Pad out to 56 mod 64. */
232 idx
= (context
->count
[0] >> 3) & 0x3f;
233 padLen
= (idx
< 56) ? (56 - idx
) : (120 - idx
);
234 __md5_Update(context
, PADDING
, padLen
);
236 /* Append length (before padding) */
237 __md5_Update(context
, bits
, 8);
241 * MD5 finalization. Ends an MD5 message-digest operation, writing the
242 * the message digest and zeroizing the context.
244 static void __md5_Final(unsigned char digest
[16], struct MD5Context
*context
)
249 /* Store state in digest */
250 __md5_Encode(digest
, context
->state
, 16);
252 /* Zeroize sensitive information. */
253 memset(context
, 0, sizeof(*context
));
256 /* MD5 basic transformation. Transforms state based on block. */
257 static void __md5_Transform(uint32_t state
[4], const unsigned char block
[64])
259 uint32_t a
, b
, c
, d
, x
[16];
260 #if MD5_SIZE_OVER_SPEED > 1
262 const unsigned char *ps
;
264 static const unsigned char S
[] = {
270 #endif /* MD5_SIZE_OVER_SPEED > 1 */
272 #if MD5_SIZE_OVER_SPEED > 0
274 const unsigned char *pp
;
277 static const uint32_t C
[] = {
279 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
280 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
281 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
282 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
284 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
285 0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
286 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
287 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
289 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
290 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
291 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
292 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
294 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
295 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
296 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
297 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
300 static const unsigned char P
[] = {
301 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 1 */
302 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, /* 2 */
303 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2, /* 3 */
304 0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9 /* 4 */
307 #endif /* MD5_SIZE_OVER_SPEED > 0 */
309 __md5_Decode(x
, block
, 64);
311 a
= state
[0]; b
= state
[1]; c
= state
[2]; d
= state
[3];
313 #if MD5_SIZE_OVER_SPEED > 2
314 pc
= C
; pp
= P
; ps
= S
- 4;
316 for (i
= 0; i
< 64; i
++) {
317 if ((i
& 0x0f) == 0) ps
+= 4;
333 temp
+= x
[*pp
++] + *pc
++;
334 temp
= ROTATE_LEFT(temp
, ps
[i
& 3]);
336 a
= d
; d
= c
; c
= b
; b
= temp
;
338 #elif MD5_SIZE_OVER_SPEED > 1
339 pc
= C
; pp
= P
; ps
= S
;
342 for (i
= 0; i
< 16; i
++) {
343 FF(a
, b
, c
, d
, x
[*pp
], ps
[i
& 0x3], *pc
); pp
++; pc
++;
344 temp
= d
; d
= c
; c
= b
; b
= a
; a
= temp
;
349 for (; i
< 32; i
++) {
350 GG(a
, b
, c
, d
, x
[*pp
], ps
[i
& 0x3], *pc
); pp
++; pc
++;
351 temp
= d
; d
= c
; c
= b
; b
= a
; a
= temp
;
355 for (; i
< 48; i
++) {
356 HH(a
, b
, c
, d
, x
[*pp
], ps
[i
& 0x3], *pc
); pp
++; pc
++;
357 temp
= d
; d
= c
; c
= b
; b
= a
; a
= temp
;
362 for (; i
< 64; i
++) {
363 II(a
, b
, c
, d
, x
[*pp
], ps
[i
& 0x3], *pc
); pp
++; pc
++;
364 temp
= d
; d
= c
; c
= b
; b
= a
; a
= temp
;
366 #elif MD5_SIZE_OVER_SPEED > 0
370 for (i
= 0; i
< 4; i
++) {
371 FF(a
, b
, c
, d
, x
[*pp
], 7, *pc
); pp
++; pc
++;
372 FF(d
, a
, b
, c
, x
[*pp
], 12, *pc
); pp
++; pc
++;
373 FF(c
, d
, a
, b
, x
[*pp
], 17, *pc
); pp
++; pc
++;
374 FF(b
, c
, d
, a
, x
[*pp
], 22, *pc
); pp
++; pc
++;
378 for (i
= 0; i
< 4; i
++) {
379 GG(a
, b
, c
, d
, x
[*pp
], 5, *pc
); pp
++; pc
++;
380 GG(d
, a
, b
, c
, x
[*pp
], 9, *pc
); pp
++; pc
++;
381 GG(c
, d
, a
, b
, x
[*pp
], 14, *pc
); pp
++; pc
++;
382 GG(b
, c
, d
, a
, x
[*pp
], 20, *pc
); pp
++; pc
++;
385 for (i
= 0; i
< 4; i
++) {
386 HH(a
, b
, c
, d
, x
[*pp
], 4, *pc
); pp
++; pc
++;
387 HH(d
, a
, b
, c
, x
[*pp
], 11, *pc
); pp
++; pc
++;
388 HH(c
, d
, a
, b
, x
[*pp
], 16, *pc
); pp
++; pc
++;
389 HH(b
, c
, d
, a
, x
[*pp
], 23, *pc
); pp
++; pc
++;
393 for (i
= 0; i
< 4; i
++) {
394 II(a
, b
, c
, d
, x
[*pp
], 6, *pc
); pp
++; pc
++;
395 II(d
, a
, b
, c
, x
[*pp
], 10, *pc
); pp
++; pc
++;
396 II(c
, d
, a
, b
, x
[*pp
], 15, *pc
); pp
++; pc
++;
397 II(b
, c
, d
, a
, x
[*pp
], 21, *pc
); pp
++; pc
++;
405 FF(a
, b
, c
, d
, x
[ 0], S11
, 0xd76aa478); /* 1 */
406 FF(d
, a
, b
, c
, x
[ 1], S12
, 0xe8c7b756); /* 2 */
407 FF(c
, d
, a
, b
, x
[ 2], S13
, 0x242070db); /* 3 */
408 FF(b
, c
, d
, a
, x
[ 3], S14
, 0xc1bdceee); /* 4 */
409 FF(a
, b
, c
, d
, x
[ 4], S11
, 0xf57c0faf); /* 5 */
410 FF(d
, a
, b
, c
, x
[ 5], S12
, 0x4787c62a); /* 6 */
411 FF(c
, d
, a
, b
, x
[ 6], S13
, 0xa8304613); /* 7 */
412 FF(b
, c
, d
, a
, x
[ 7], S14
, 0xfd469501); /* 8 */
413 FF(a
, b
, c
, d
, x
[ 8], S11
, 0x698098d8); /* 9 */
414 FF(d
, a
, b
, c
, x
[ 9], S12
, 0x8b44f7af); /* 10 */
415 FF(c
, d
, a
, b
, x
[10], S13
, 0xffff5bb1); /* 11 */
416 FF(b
, c
, d
, a
, x
[11], S14
, 0x895cd7be); /* 12 */
417 FF(a
, b
, c
, d
, x
[12], S11
, 0x6b901122); /* 13 */
418 FF(d
, a
, b
, c
, x
[13], S12
, 0xfd987193); /* 14 */
419 FF(c
, d
, a
, b
, x
[14], S13
, 0xa679438e); /* 15 */
420 FF(b
, c
, d
, a
, x
[15], S14
, 0x49b40821); /* 16 */
427 GG(a
, b
, c
, d
, x
[ 1], S21
, 0xf61e2562); /* 17 */
428 GG(d
, a
, b
, c
, x
[ 6], S22
, 0xc040b340); /* 18 */
429 GG(c
, d
, a
, b
, x
[11], S23
, 0x265e5a51); /* 19 */
430 GG(b
, c
, d
, a
, x
[ 0], S24
, 0xe9b6c7aa); /* 20 */
431 GG(a
, b
, c
, d
, x
[ 5], S21
, 0xd62f105d); /* 21 */
432 GG(d
, a
, b
, c
, x
[10], S22
, 0x2441453); /* 22 */
433 GG(c
, d
, a
, b
, x
[15], S23
, 0xd8a1e681); /* 23 */
434 GG(b
, c
, d
, a
, x
[ 4], S24
, 0xe7d3fbc8); /* 24 */
435 GG(a
, b
, c
, d
, x
[ 9], S21
, 0x21e1cde6); /* 25 */
436 GG(d
, a
, b
, c
, x
[14], S22
, 0xc33707d6); /* 26 */
437 GG(c
, d
, a
, b
, x
[ 3], S23
, 0xf4d50d87); /* 27 */
438 GG(b
, c
, d
, a
, x
[ 8], S24
, 0x455a14ed); /* 28 */
439 GG(a
, b
, c
, d
, x
[13], S21
, 0xa9e3e905); /* 29 */
440 GG(d
, a
, b
, c
, x
[ 2], S22
, 0xfcefa3f8); /* 30 */
441 GG(c
, d
, a
, b
, x
[ 7], S23
, 0x676f02d9); /* 31 */
442 GG(b
, c
, d
, a
, x
[12], S24
, 0x8d2a4c8a); /* 32 */
449 HH(a
, b
, c
, d
, x
[ 5], S31
, 0xfffa3942); /* 33 */
450 HH(d
, a
, b
, c
, x
[ 8], S32
, 0x8771f681); /* 34 */
451 HH(c
, d
, a
, b
, x
[11], S33
, 0x6d9d6122); /* 35 */
452 HH(b
, c
, d
, a
, x
[14], S34
, 0xfde5380c); /* 36 */
453 HH(a
, b
, c
, d
, x
[ 1], S31
, 0xa4beea44); /* 37 */
454 HH(d
, a
, b
, c
, x
[ 4], S32
, 0x4bdecfa9); /* 38 */
455 HH(c
, d
, a
, b
, x
[ 7], S33
, 0xf6bb4b60); /* 39 */
456 HH(b
, c
, d
, a
, x
[10], S34
, 0xbebfbc70); /* 40 */
457 HH(a
, b
, c
, d
, x
[13], S31
, 0x289b7ec6); /* 41 */
458 HH(d
, a
, b
, c
, x
[ 0], S32
, 0xeaa127fa); /* 42 */
459 HH(c
, d
, a
, b
, x
[ 3], S33
, 0xd4ef3085); /* 43 */
460 HH(b
, c
, d
, a
, x
[ 6], S34
, 0x4881d05); /* 44 */
461 HH(a
, b
, c
, d
, x
[ 9], S31
, 0xd9d4d039); /* 45 */
462 HH(d
, a
, b
, c
, x
[12], S32
, 0xe6db99e5); /* 46 */
463 HH(c
, d
, a
, b
, x
[15], S33
, 0x1fa27cf8); /* 47 */
464 HH(b
, c
, d
, a
, x
[ 2], S34
, 0xc4ac5665); /* 48 */
471 II(a
, b
, c
, d
, x
[ 0], S41
, 0xf4292244); /* 49 */
472 II(d
, a
, b
, c
, x
[ 7], S42
, 0x432aff97); /* 50 */
473 II(c
, d
, a
, b
, x
[14], S43
, 0xab9423a7); /* 51 */
474 II(b
, c
, d
, a
, x
[ 5], S44
, 0xfc93a039); /* 52 */
475 II(a
, b
, c
, d
, x
[12], S41
, 0x655b59c3); /* 53 */
476 II(d
, a
, b
, c
, x
[ 3], S42
, 0x8f0ccc92); /* 54 */
477 II(c
, d
, a
, b
, x
[10], S43
, 0xffeff47d); /* 55 */
478 II(b
, c
, d
, a
, x
[ 1], S44
, 0x85845dd1); /* 56 */
479 II(a
, b
, c
, d
, x
[ 8], S41
, 0x6fa87e4f); /* 57 */
480 II(d
, a
, b
, c
, x
[15], S42
, 0xfe2ce6e0); /* 58 */
481 II(c
, d
, a
, b
, x
[ 6], S43
, 0xa3014314); /* 59 */
482 II(b
, c
, d
, a
, x
[13], S44
, 0x4e0811a1); /* 60 */
483 II(a
, b
, c
, d
, x
[ 4], S41
, 0xf7537e82); /* 61 */
484 II(d
, a
, b
, c
, x
[11], S42
, 0xbd3af235); /* 62 */
485 II(c
, d
, a
, b
, x
[ 2], S43
, 0x2ad7d2bb); /* 63 */
486 II(b
, c
, d
, a
, x
[ 9], S44
, 0xeb86d391); /* 64 */
494 /* Zeroize sensitive information. */
495 memset(x
, 0, sizeof(x
));
500 __md5_to64(char *s
, unsigned v
, int n
)
503 *s
++ = ascii64
[v
& 0x3f];
512 * Use MD5 for what it is best at...
514 #define MD5_OUT_BUFSIZE 36
516 md5_crypt(char passwd
[MD5_OUT_BUFSIZE
], const unsigned char *pw
, const unsigned char *salt
)
518 const unsigned char *sp
, *ep
;
520 unsigned char final
[17]; /* final[16] exists only to aid in looping */
521 int sl
, pl
, i
, pw_len
;
522 struct MD5Context ctx
, ctx1
;
524 /* Refine the Salt first */
529 /* It stops at the first '$', max 8 chars */
530 for (ep
= sp
; *ep
&& *ep
!= '$' && ep
< (sp
+8); ep
++)
533 /* get the length of the true salt */
538 /* The password first, since that is what is most unknown */
539 pw_len
= strlen((char*)pw
);
540 __md5_Update(&ctx
, pw
, pw_len
);
542 /* Then our magic string */
543 __md5_Update(&ctx
, __md5__magic
, MD5_MAGIC_LEN
);
545 /* Then the raw salt */
546 __md5_Update(&ctx
, sp
, sl
);
548 /* Then just as many characters of the MD5(pw, salt, pw) */
550 __md5_Update(&ctx1
, pw
, pw_len
);
551 __md5_Update(&ctx1
, sp
, sl
);
552 __md5_Update(&ctx1
, pw
, pw_len
);
553 __md5_Final(final
, &ctx1
);
554 for (pl
= pw_len
; pl
> 0; pl
-= 16)
555 __md5_Update(&ctx
, final
, pl
> 16 ? 16 : pl
);
557 /* Don't leave anything around in vm they could use. */
558 //TODO: the above comment seems to be wrong. final is used later.
559 memset(final
, 0, sizeof(final
));
561 /* Then something really weird... */
562 for (i
= pw_len
; i
; i
>>= 1) {
563 __md5_Update(&ctx
, ((i
& 1) ? final
: (const unsigned char *) pw
), 1);
566 /* Now make the output string */
570 strncpy(passwd
+ 3, (char*)sp
, sl
);
571 passwd
[sl
+ 3] = '$';
573 __md5_Final(final
, &ctx
);
576 * and now, just to make sure things don't run too fast
577 * On a 60 Mhz Pentium this takes 34 msec, so you would
578 * need 30 seconds to build a 1000 entry dictionary...
580 for (i
= 0; i
< 1000; i
++) {
583 __md5_Update(&ctx1
, pw
, pw_len
);
585 __md5_Update(&ctx1
, final
, 16);
588 __md5_Update(&ctx1
, sp
, sl
);
591 __md5_Update(&ctx1
, pw
, pw_len
);
594 __md5_Update(&ctx1
, final
, 16);
596 __md5_Update(&ctx1
, pw
, pw_len
);
597 __md5_Final(final
, &ctx1
);
600 p
= passwd
+ sl
+ 4; /* 12 bytes max (sl is up to 8 bytes) */
602 /* Add 5*4+2 = 22 bytes of hash, + NUL byte. */
603 final
[16] = final
[5];
604 for (i
= 0; i
< 5; i
++) {
605 unsigned l
= (final
[i
] << 16) | (final
[i
+6] << 8) | final
[i
+12];
606 p
= __md5_to64(p
, l
, 4);
608 p
= __md5_to64(p
, final
[11], 2);
611 /* Don't leave anything around in vm they could use. */
612 memset(final
, 0, sizeof(final
));
617 #undef MD5_SIZE_OVER_SPEED
This page took 0.108729 seconds and 5 git commands to generate.