1/* 2 * This is work is derived from material Copyright RSA Data Security, Inc. 3 * 4 * The RSA copyright statement and Licence for that original material is 5 * included below. This is followed by the Apache copyright statement and 6 * licence for the modifications made to that material. 7 */ 8 9/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm 10 */ 11 12/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All 13 rights reserved. 14 15 License to copy and use this software is granted provided that it 16 is identified as the "RSA Data Security, Inc. MD5 Message-Digest 17 Algorithm" in all material mentioning or referencing this software 18 or this function. 19 20 License is also granted to make and use derivative works provided 21 that such works are identified as "derived from the RSA Data 22 Security, Inc. MD5 Message-Digest Algorithm" in all material 23 mentioning or referencing the derived work. 24 25 RSA Data Security, Inc. makes no representations concerning either 26 the merchantability of this software or the suitability of this 27 software for any particular purpose. It is provided "as is" 28 without express or implied warranty of any kind. 29 30 These notices must be retained in any copies of any part of this 31 documentation and/or software. 32 */ 33 34/* Licensed to the Apache Software Foundation (ASF) under one or more 35 * contributor license agreements. See the NOTICE file distributed with 36 * this work for additional information regarding copyright ownership. 37 * The ASF licenses this file to You under the Apache License, Version 2.0 38 * (the "License"); you may not use this file except in compliance with 39 * the License. You may obtain a copy of the License at 40 * 41 * http://www.apache.org/licenses/LICENSE-2.0 42 * 43 * Unless required by applicable law or agreed to in writing, software 44 * distributed under the License is distributed on an "AS IS" BASIS, 45 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 46 * See the License for the specific language governing permissions and 47 * limitations under the License. 48 */ 49 50/* 51 * The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0 52 * MD5 crypt() function, which is licenced as follows: 53 * ---------------------------------------------------------------------------- 54 * "THE BEER-WARE LICENSE" (Revision 42): 55 * <phk@login.dknet.dk> wrote this file. As long as you retain this notice you 56 * can do whatever you want with this stuff. If we meet some day, and you think 57 * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp 58 * ---------------------------------------------------------------------------- 59 */ 60#include "apr_strings.h" 61#include "apr_md5.h" 62#include "apr_lib.h" 63#include "apu_config.h" 64 65#if APR_HAVE_STRING_H 66#include <string.h> 67#endif 68 69/* Constants for MD5Transform routine. 70 */ 71 72#define S11 7 73#define S12 12 74#define S13 17 75#define S14 22 76#define S21 5 77#define S22 9 78#define S23 14 79#define S24 20 80#define S31 4 81#define S32 11 82#define S33 16 83#define S34 23 84#define S41 6 85#define S42 10 86#define S43 15 87#define S44 21 88 89static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64]); 90static void Encode(unsigned char *output, const apr_uint32_t *input, 91 unsigned int len); 92static void Decode(apr_uint32_t *output, const unsigned char *input, 93 unsigned int len); 94 95static const unsigned char PADDING[64] = 96{ 97 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 98 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 99 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 100}; 101 102#if APR_CHARSET_EBCDIC 103static apr_xlate_t *xlate_ebcdic_to_ascii; /* used in apr_md5_encode() */ 104#endif 105#define DO_XLATE 0 106#define SKIP_XLATE 1 107 108/* F, G, H and I are basic MD5 functions. 109 */ 110#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) 111#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) 112#define H(x, y, z) ((x) ^ (y) ^ (z)) 113#define I(x, y, z) ((y) ^ ((x) | (~z))) 114 115/* ROTATE_LEFT rotates x left n bits. 116 */ 117#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) 118 119/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. 120 * Rotation is separate from addition to prevent recomputation. 121 */ 122#define FF(a, b, c, d, x, s, ac) { \ 123 (a) += F ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ 124 (a) = ROTATE_LEFT ((a), (s)); \ 125 (a) += (b); \ 126 } 127#define GG(a, b, c, d, x, s, ac) { \ 128 (a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ 129 (a) = ROTATE_LEFT ((a), (s)); \ 130 (a) += (b); \ 131 } 132#define HH(a, b, c, d, x, s, ac) { \ 133 (a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ 134 (a) = ROTATE_LEFT ((a), (s)); \ 135 (a) += (b); \ 136 } 137#define II(a, b, c, d, x, s, ac) { \ 138 (a) += I ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ 139 (a) = ROTATE_LEFT ((a), (s)); \ 140 (a) += (b); \ 141 } 142 143/* MD5 initialization. Begins an MD5 operation, writing a new context. 144 */ 145APU_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context) 146{ 147 context->count[0] = context->count[1] = 0; 148 149 /* Load magic initialization constants. */ 150 context->state[0] = 0x67452301; 151 context->state[1] = 0xefcdab89; 152 context->state[2] = 0x98badcfe; 153 context->state[3] = 0x10325476; 154 context->xlate = NULL; 155 156 return APR_SUCCESS; 157} 158 159/* MD5 translation setup. Provides the APR translation handle 160 * to be used for translating the content before calculating the 161 * digest. 162 */ 163APU_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context, 164 apr_xlate_t *xlate) 165{ 166#if APR_HAS_XLATE 167 apr_status_t rv; 168 int is_sb; 169 170 /* TODO: remove the single-byte-only restriction from this code 171 */ 172 rv = apr_xlate_sb_get(xlate, &is_sb); 173 if (rv != APR_SUCCESS) { 174 return rv; 175 } 176 if (!is_sb) { 177 return APR_EINVAL; 178 } 179 context->xlate = xlate; 180 return APR_SUCCESS; 181#else 182 return APR_ENOTIMPL; 183#endif /* APR_HAS_XLATE */ 184} 185 186/* MD5 block update operation. Continues an MD5 message-digest 187 * operation, processing another message block, and updating the 188 * context. 189 */ 190static apr_status_t md5_update_buffer(apr_md5_ctx_t *context, 191 const void *vinput, 192 apr_size_t inputLen, 193 int xlate_buffer) 194{ 195 const unsigned char *input = vinput; 196 unsigned int i, idx, partLen; 197#if APR_HAS_XLATE 198 apr_size_t inbytes_left, outbytes_left; 199#endif 200 201 /* Compute number of bytes mod 64 */ 202 idx = (unsigned int)((context->count[0] >> 3) & 0x3F); 203 204 /* Update number of bits */ 205 if ((context->count[0] += ((apr_uint32_t)inputLen << 3)) 206 < ((apr_uint32_t)inputLen << 3)) 207 context->count[1]++; 208 context->count[1] += (apr_uint32_t)inputLen >> 29; 209 210 partLen = 64 - idx; 211 212 /* Transform as many times as possible. */ 213#if !APR_HAS_XLATE 214 if (inputLen >= partLen) { 215 memcpy(&context->buffer[idx], input, partLen); 216 MD5Transform(context->state, context->buffer); 217 218 for (i = partLen; i + 63 < inputLen; i += 64) 219 MD5Transform(context->state, &input[i]); 220 221 idx = 0; 222 } 223 else 224 i = 0; 225 226 /* Buffer remaining input */ 227 memcpy(&context->buffer[idx], &input[i], inputLen - i); 228#else /*APR_HAS_XLATE*/ 229 if (inputLen >= partLen) { 230 if (context->xlate && (xlate_buffer == DO_XLATE)) { 231 inbytes_left = outbytes_left = partLen; 232 apr_xlate_conv_buffer(context->xlate, (const char *)input, 233 &inbytes_left, 234 (char *)&context->buffer[idx], 235 &outbytes_left); 236 } 237 else { 238 memcpy(&context->buffer[idx], input, partLen); 239 } 240 MD5Transform(context->state, context->buffer); 241 242 for (i = partLen; i + 63 < inputLen; i += 64) { 243 if (context->xlate && (xlate_buffer == DO_XLATE)) { 244 unsigned char inp_tmp[64]; 245 inbytes_left = outbytes_left = 64; 246 apr_xlate_conv_buffer(context->xlate, (const char *)&input[i], 247 &inbytes_left, (char *)inp_tmp, 248 &outbytes_left); 249 MD5Transform(context->state, inp_tmp); 250 } 251 else { 252 MD5Transform(context->state, &input[i]); 253 } 254 } 255 256 idx = 0; 257 } 258 else 259 i = 0; 260 261 /* Buffer remaining input */ 262 if (context->xlate && (xlate_buffer == DO_XLATE)) { 263 inbytes_left = outbytes_left = inputLen - i; 264 apr_xlate_conv_buffer(context->xlate, (const char *)&input[i], 265 &inbytes_left, (char *)&context->buffer[idx], 266 &outbytes_left); 267 } 268 else { 269 memcpy(&context->buffer[idx], &input[i], inputLen - i); 270 } 271#endif /*APR_HAS_XLATE*/ 272 return APR_SUCCESS; 273} 274 275/* MD5 block update operation. API with the default setting 276 * for EBCDIC translations 277 */ 278APU_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context, 279 const void *input, 280 apr_size_t inputLen) 281{ 282 return md5_update_buffer(context, input, inputLen, DO_XLATE); 283} 284 285/* MD5 finalization. Ends an MD5 message-digest operation, writing the 286 * the message digest and zeroizing the context. 287 */ 288APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE], 289 apr_md5_ctx_t *context) 290{ 291 unsigned char bits[8]; 292 unsigned int idx, padLen; 293 294 /* Save number of bits */ 295 Encode(bits, context->count, 8); 296 297#if APR_HAS_XLATE 298 /* apr_md5_update() should not translate for this final round. */ 299 context->xlate = NULL; 300#endif /*APR_HAS_XLATE*/ 301 302 /* Pad out to 56 mod 64. */ 303 idx = (unsigned int)((context->count[0] >> 3) & 0x3f); 304 padLen = (idx < 56) ? (56 - idx) : (120 - idx); 305 apr_md5_update(context, PADDING, padLen); 306 307 /* Append length (before padding) */ 308 apr_md5_update(context, bits, 8); 309 310 /* Store state in digest */ 311 Encode(digest, context->state, APR_MD5_DIGESTSIZE); 312 313 /* Zeroize sensitive information. */ 314 memset(context, 0, sizeof(*context)); 315 316 return APR_SUCCESS; 317} 318 319/* MD5 in one step (init, update, final) 320 */ 321APU_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE], 322 const void *_input, 323 apr_size_t inputLen) 324{ 325 const unsigned char *input = _input; 326 apr_md5_ctx_t ctx; 327 apr_status_t rv; 328 329 apr_md5_init(&ctx); 330 331 if ((rv = apr_md5_update(&ctx, input, inputLen)) != APR_SUCCESS) 332 return rv; 333 334 return apr_md5_final(digest, &ctx); 335} 336 337/* MD5 basic transformation. Transforms state based on block. */ 338static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64]) 339{ 340 apr_uint32_t a = state[0], b = state[1], c = state[2], d = state[3], 341 tmpbuf[APR_MD5_DIGESTSIZE]; 342 const apr_uint32_t *x; 343 344#if !APR_IS_BIGENDIAN 345 if ((apr_uintptr_t)block % sizeof(apr_uint32_t) == 0) { 346 x = (apr_uint32_t *)block; 347 } else 348#endif 349 { 350 Decode(tmpbuf, block, 64); 351 x = tmpbuf; 352 } 353 354 /* Round 1 */ 355 FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */ 356 FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */ 357 FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */ 358 FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */ 359 FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */ 360 FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */ 361 FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */ 362 FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */ 363 FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */ 364 FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */ 365 FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ 366 FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ 367 FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ 368 FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ 369 FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ 370 FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ 371 372 /* Round 2 */ 373 GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */ 374 GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */ 375 GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ 376 GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */ 377 GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */ 378 GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */ 379 GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ 380 GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */ 381 GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */ 382 GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ 383 GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */ 384 GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */ 385 GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ 386 GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */ 387 GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */ 388 GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ 389 390 /* Round 3 */ 391 HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */ 392 HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */ 393 HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ 394 HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ 395 HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */ 396 HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */ 397 HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */ 398 HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ 399 HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ 400 HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */ 401 HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */ 402 HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */ 403 HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */ 404 HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ 405 HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ 406 HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */ 407 408 /* Round 4 */ 409 II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */ 410 II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */ 411 II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ 412 II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */ 413 II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ 414 II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */ 415 II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ 416 II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */ 417 II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */ 418 II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ 419 II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */ 420 II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ 421 II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */ 422 II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ 423 II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */ 424 II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */ 425 426 state[0] += a; 427 state[1] += b; 428 state[2] += c; 429 state[3] += d; 430 431#if !APR_IS_BIGENDIAN 432 if (x == tmpbuf) 433#endif 434 { 435 /* Zeroize sensitive information. */ 436 memset(tmpbuf, 0, sizeof(tmpbuf)); 437 } 438} 439 440/* Encodes input (apr_uint32_t) into output (unsigned char). Assumes len is 441 * a multiple of 4. 442 */ 443static void Encode(unsigned char *output, const apr_uint32_t *input, 444 unsigned int len) 445{ 446 unsigned int i, j; 447 apr_uint32_t k; 448 449 for (i = 0, j = 0; j < len; i++, j += 4) { 450 k = input[i]; 451 output[j] = (unsigned char)(k & 0xff); 452 output[j + 1] = (unsigned char)((k >> 8) & 0xff); 453 output[j + 2] = (unsigned char)((k >> 16) & 0xff); 454 output[j + 3] = (unsigned char)((k >> 24) & 0xff); 455 } 456} 457 458/* Decodes input (unsigned char) into output (apr_uint32_t). Assumes len is 459 * a multiple of 4. 460 */ 461static void Decode(apr_uint32_t *output, const unsigned char *input, 462 unsigned int len) 463{ 464 unsigned int i, j; 465 466 for (i = 0, j = 0; j < len; i++, j += 4) 467 output[i] = ((apr_uint32_t)input[j]) | 468 (((apr_uint32_t)input[j + 1]) << 8) | 469 (((apr_uint32_t)input[j + 2]) << 16) | 470 (((apr_uint32_t)input[j + 3]) << 24); 471} 472 473#if APR_CHARSET_EBCDIC 474APU_DECLARE(apr_status_t) apr_MD5InitEBCDIC(apr_xlate_t *xlate) 475{ 476 xlate_ebcdic_to_ascii = xlate; 477 return APR_SUCCESS; 478} 479#endif 480 481/* 482 * Define the Magic String prefix that identifies a password as being 483 * hashed using our algorithm. 484 */ 485static const char * const apr1_id = "$apr1$"; 486 487/* 488 * The following MD5 password encryption code was largely borrowed from 489 * the FreeBSD 3.0 /usr/src/lib/libcrypt/crypt.c file, which is 490 * licenced as stated at the top of this file. 491 */ 492 493static void to64(char *s, unsigned long v, int n) 494{ 495 static unsigned char itoa64[] = /* 0 ... 63 => ASCII - 64 */ 496 "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; 497 498 while (--n >= 0) { 499 *s++ = itoa64[v&0x3f]; 500 v >>= 6; 501 } 502} 503 504APU_DECLARE(apr_status_t) apr_md5_encode(const char *pw, const char *salt, 505 char *result, apr_size_t nbytes) 506{ 507 /* 508 * Minimum size is 8 bytes for salt, plus 1 for the trailing NUL, 509 * plus 4 for the '$' separators, plus the password hash itself. 510 * Let's leave a goodly amount of leeway. 511 */ 512 513 char passwd[120], *p; 514 const char *sp, *ep; 515 unsigned char final[APR_MD5_DIGESTSIZE]; 516 apr_ssize_t sl, pl, i; 517 apr_md5_ctx_t ctx, ctx1; 518 unsigned long l; 519 520 /* 521 * Refine the salt first. It's possible we were given an already-hashed 522 * string as the salt argument, so extract the actual salt value from it 523 * if so. Otherwise just use the string up to the first '$' as the salt. 524 */ 525 sp = salt; 526 527 /* 528 * If it starts with the magic string, then skip that. 529 */ 530 if (!strncmp(sp, apr1_id, strlen(apr1_id))) { 531 sp += strlen(apr1_id); 532 } 533 534 /* 535 * It stops at the first '$' or 8 chars, whichever comes first 536 */ 537 for (ep = sp; (*ep != '\0') && (*ep != '$') && (ep < (sp + 8)); ep++) { 538 continue; 539 } 540 541 /* 542 * Get the length of the true salt 543 */ 544 sl = ep - sp; 545 546 /* 547 * 'Time to make the doughnuts..' 548 */ 549 apr_md5_init(&ctx); 550#if APR_CHARSET_EBCDIC 551 apr_md5_set_xlate(&ctx, xlate_ebcdic_to_ascii); 552#endif 553 554 /* 555 * The password first, since that is what is most unknown 556 */ 557 apr_md5_update(&ctx, pw, strlen(pw)); 558 559 /* 560 * Then our magic string 561 */ 562 apr_md5_update(&ctx, apr1_id, strlen(apr1_id)); 563 564 /* 565 * Then the raw salt 566 */ 567 apr_md5_update(&ctx, sp, sl); 568 569 /* 570 * Then just as many characters of the MD5(pw, salt, pw) 571 */ 572 apr_md5_init(&ctx1); 573#if APR_CHARSET_EBCDIC 574 apr_md5_set_xlate(&ctx1, xlate_ebcdic_to_ascii); 575#endif 576 apr_md5_update(&ctx1, pw, strlen(pw)); 577 apr_md5_update(&ctx1, sp, sl); 578 apr_md5_update(&ctx1, pw, strlen(pw)); 579 apr_md5_final(final, &ctx1); 580 for (pl = strlen(pw); pl > 0; pl -= APR_MD5_DIGESTSIZE) { 581 md5_update_buffer(&ctx, final, 582 (pl > APR_MD5_DIGESTSIZE) ? APR_MD5_DIGESTSIZE : pl, SKIP_XLATE); 583 } 584 585 /* 586 * Don't leave anything around in vm they could use. 587 */ 588 memset(final, 0, sizeof(final)); 589 590 /* 591 * Then something really weird... 592 */ 593 for (i = strlen(pw); i != 0; i >>= 1) { 594 if (i & 1) { 595 md5_update_buffer(&ctx, final, 1, SKIP_XLATE); 596 } 597 else { 598 apr_md5_update(&ctx, pw, 1); 599 } 600 } 601 602 /* 603 * Now make the output string. We know our limitations, so we 604 * can use the string routines without bounds checking. 605 */ 606 strcpy(passwd, apr1_id); 607 strncat(passwd, sp, sl); 608 strcat(passwd, "$"); 609 610 apr_md5_final(final, &ctx); 611 612 /* 613 * And now, just to make sure things don't run too fast.. 614 * On a 60 Mhz Pentium this takes 34 msec, so you would 615 * need 30 seconds to build a 1000 entry dictionary... 616 */ 617 for (i = 0; i < 1000; i++) { 618 apr_md5_init(&ctx1); 619 /* 620 * apr_md5_final clears out ctx1.xlate at the end of each loop, 621 * so need to to set it each time through 622 */ 623#if APR_CHARSET_EBCDIC 624 apr_md5_set_xlate(&ctx1, xlate_ebcdic_to_ascii); 625#endif 626 if (i & 1) { 627 apr_md5_update(&ctx1, pw, strlen(pw)); 628 } 629 else { 630 md5_update_buffer(&ctx1, final, APR_MD5_DIGESTSIZE, SKIP_XLATE); 631 } 632 if (i % 3) { 633 apr_md5_update(&ctx1, sp, sl); 634 } 635 636 if (i % 7) { 637 apr_md5_update(&ctx1, pw, strlen(pw)); 638 } 639 640 if (i & 1) { 641 md5_update_buffer(&ctx1, final, APR_MD5_DIGESTSIZE, SKIP_XLATE); 642 } 643 else { 644 apr_md5_update(&ctx1, pw, strlen(pw)); 645 } 646 apr_md5_final(final,&ctx1); 647 } 648 649 p = passwd + strlen(passwd); 650 651 l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p, l, 4); p += 4; 652 l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p, l, 4); p += 4; 653 l = (final[ 2]<<16) | (final[ 8]<<8) | final[14]; to64(p, l, 4); p += 4; 654 l = (final[ 3]<<16) | (final[ 9]<<8) | final[15]; to64(p, l, 4); p += 4; 655 l = (final[ 4]<<16) | (final[10]<<8) | final[ 5]; to64(p, l, 4); p += 4; 656 l = final[11] ; to64(p, l, 2); p += 2; 657 *p = '\0'; 658 659 /* 660 * Don't leave anything around in vm they could use. 661 */ 662 memset(final, 0, sizeof(final)); 663 664 apr_cpystrn(result, passwd, nbytes - 1); 665 return APR_SUCCESS; 666} 667