Return-Path: Delivered-To: apmail-apr-dev-archive@www.apache.org Received: (qmail 87154 invoked from network); 9 Oct 2006 20:18:17 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 9 Oct 2006 20:18:17 -0000 Received: (qmail 51523 invoked by uid 500); 9 Oct 2006 20:18:10 -0000 Delivered-To: apmail-apr-dev-archive@apr.apache.org Received: (qmail 51434 invoked by uid 500); 9 Oct 2006 20:18:09 -0000 Mailing-List: contact dev-help@apr.apache.org; run by ezmlm Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Id: Delivered-To: mailing list dev@apr.apache.org Received: (qmail 51402 invoked by uid 99); 9 Oct 2006 20:18:09 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 09 Oct 2006 13:18:09 -0700 X-ASF-Spam-Status: No, hits=0.0 required=10.0 tests= X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [85.19.200.177] (HELO vawad.err.no) (85.19.200.177) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 09 Oct 2006 13:18:06 -0700 Received: from 205.80-202-169.nextgentel.com ([80.202.169.205] helo=thosu.err.no) by vawad.err.no with esmtps (TLS-1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.60) (envelope-from ) id 1GX1ZC-0005ZO-UE; Mon, 09 Oct 2006 22:17:40 +0200 Received: by thosu.err.no (Postfix, from userid 1000) id AA8355798A; Mon, 9 Oct 2006 22:17:00 +0200 (CEST) From: Tollef Fog Heen To: dev@apr.apache.org Subject: MD4/MD5 implementation is non-free Mail-Copies-To: never Mail-Followup-To: dev@apr.apache.org Date: Mon, 09 Oct 2006 22:17:00 +0200 Message-ID: <87y7rpw8g3.fsf@thosu.err.no> User-Agent: Gnus/5.110006 (No Gnus v0.6) Emacs/21.4 (gnu/linux) MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" X-Virus-Checked: Checked by ClamAV on apache.org X-Old-Spam-Status: (score 3.7): Status=No hits=3.7 required=5.0 tests=RCVD_IN_NJABL_DUL,RCVD_IN_SORBS_DUL version=3.1.0 X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N --=-=-= Hi, For those who don't know me, I'm one of the Debian Apache (and APR) maintainers. Some time ago, we received a bug report ( http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=340538 , but bugs.d.o is down right now, mirror at http://url.err.no/hxnxhq ) about the MD4 and MD5 implementations in apr-util being non-free and possibly distributable. I took the liberty of replacing the MD4 and MD5 implementations in apr-util with the ones from dovecot (written originally by Solar Designer and put in the public domain). They took a bit of adaption to not break the ABI or change the API. The diff is attached and also available at http://err.no/patches/apr-util-md4-md5-licence-fix.diff As I have seen earlier that public domain in some cases if problematic due to not being recognised in all jurisdictions, I have sent Solar Designer a mail asking him to licence it under the ASL or a BSD licence as well as public domain. I'll follow up as soon as I have his answer. -- Tollef Fog Heen ,''`. UNIX is user friendly, it's just picky about who its friends are : :' : `. `' `- --=-=-= Content-Type: text/x-patch Content-Disposition: attachment; filename=apr-util-md4-md5-licence-fix.diff Content-Description: Patch for licence problems in the md4 and md5 implementations in apr-util Index: crypto/apr_md4.c =================================================================== --- crypto/apr_md4.c (revisjon 454475) +++ crypto/apr_md4.c (arbeidskopi) @@ -1,3 +1,22 @@ +/* Adopted for apr-util by Tollef Fog Heen */ + +/* + * MD4 (RFC-1320) message digest. + * Modified from MD5 code by Andrey Panin + * + * Written by Solar Designer in 2001, and placed in + * the public domain. There's absolutely no warranty. + * + * This differs from Colin Plumb's older public domain implementation in + * that no 32-bit integer data type is required, there's no compile-time + * endianness configuration, and the function prototypes match OpenSSL's. + * The primary goals are portability and ease of use. + * + * This implementation is meant to be fast, but not as fast as possible. + * Some known optimizations are not included to reduce source code size + * and avoid compile-time configuration. + */ + /* Copyright 2001-2005 The Apache Software Foundation or its licensors, as * applicable. * @@ -12,30 +31,6 @@ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. - * - * This is derived from material copyright RSA Data Security, Inc. - * Their notice is reproduced below in its entirety. - * - * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All - * rights reserved. - * - * License to copy and use this software is granted provided that it - * is identified as the "RSA Data Security, Inc. MD4 Message-Digest - * Algorithm" in all material mentioning or referencing this software - * or this function. - * - * License is also granted to make and use derivative works provided - * that such works are identified as "derived from the RSA Data - * Security, Inc. MD4 Message-Digest Algorithm" in all material - * mentioning or referencing the derived work. - * - * RSA Data Security, Inc. makes no representations concerning either - * the merchantability of this software or the suitability of this - * software for any particular purpose. It is provided "as is" - * without express or implied warranty of any kind. - * - * These notices must be retained in any copies of any part of this - * documentation and/or software. */ #include "apr_strings.h" @@ -49,65 +44,53 @@ #include #endif -/* Constants for MD4Transform routine. - */ - -#define S11 3 -#define S12 7 -#define S13 11 -#define S14 19 -#define S21 3 -#define S22 5 -#define S23 9 -#define S24 13 -#define S31 3 -#define S32 9 -#define S33 11 -#define S34 15 - -static void MD4Transform(apr_uint32_t state[4], const unsigned char block[64]); -static void Encode(unsigned char *output, const apr_uint32_t *input, - unsigned int len); -static void Decode(apr_uint32_t *output, const unsigned char *input, - unsigned int len); - -static unsigned char PADDING[64] = -{ - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - #if APR_CHARSET_EBCDIC static apr_xlate_t *xlate_ebcdic_to_ascii; /* used in apr_md4_encode() */ #endif -/* F, G and I are basic MD4 functions. +static const void *body(apr_md4_ctx_t *context, const void *data, size_t size); + +/* + * The basic MD4 functions. */ -#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) -#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) -#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) -/* ROTATE_LEFT rotates x left n bits. +/* + * The MD4 transformation for all four rounds. */ -#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) +#define STEP(f, a, b, c, d, x, s) \ + (a) += f((b), (c), (d)) + (x); \ + (a) = ((a) << (s)) | ((a) >> (32 - (s))) -/* FF, GG and HH are transformations for rounds 1, 2 and 3 */ -/* Rotation is separate from addition to prevent recomputation */ -#define FF(a, b, c, d, x, s) { \ - (a) += F ((b), (c), (d)) + (x); \ - (a) = ROTATE_LEFT ((a), (s)); \ - } -#define GG(a, b, c, d, x, s) { \ - (a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)0x5a827999; \ - (a) = ROTATE_LEFT ((a), (s)); \ - } -#define HH(a, b, c, d, x, s) { \ - (a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)0x6ed9eba1; \ - (a) = ROTATE_LEFT ((a), (s)); \ - } +/* + * SET reads 4 input bytes in little-endian byte order and stores them + * in a properly aligned word in host byte order. + * + * The check for little-endian architectures which tolerate unaligned + * memory accesses is just an optimization. Nothing will break if it + * doesn't work. + */ +/*#if defined(__i386__) || defined(__x86_64__) || defined(__vax__) +#define SET(n) \ + (*(const apr_uint32_t *)&ptr[(n) * 4]) +#define GET(n) \ + SET(n) + #else*/ +#define SET(n) \ + (block[(n)] = \ + (apr_uint32_t)ptr[(n) * 4] | \ + ((apr_uint32_t)ptr[(n) * 4 + 1] << 8) | \ + ((apr_uint32_t)ptr[(n) * 4 + 2] << 16) | \ + ((apr_uint32_t)ptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (block[(n)]) +/*#endif*/ + + /* MD4 initialization. Begins an MD4 operation, writing a new context. */ APU_DECLARE(apr_status_t) apr_md4_init(apr_md4_ctx_t *context) @@ -160,82 +143,43 @@ const unsigned char *input, apr_size_t inputLen) { - unsigned int i, idx, partLen; + apr_uint32_t saved_lo; + unsigned long used, free; #if APR_HAS_XLATE - apr_size_t inbytes_left, outbytes_left; +/* apr_size_t inbytes_left, outbytes_left;*/ #endif - /* Compute number of bytes mod 64 */ - idx = (unsigned int)((context->count[0] >> 3) & 0x3F); - /* Update number of bits */ - if ((context->count[0] += ((apr_uint32_t)inputLen << 3)) - < ((apr_uint32_t)inputLen << 3)) + saved_lo = context->count[0]; + if ((context->count[0] = (saved_lo + inputLen) & 0x1fffffff) < saved_lo) context->count[1]++; context->count[1] += (apr_uint32_t)inputLen >> 29; - partLen = 64 - idx; + /* Compute number of bytes mod 64 */ + used = saved_lo & 0x3f; /* Transform as many times as possible. */ -#if !APR_HAS_XLATE - if (inputLen >= partLen) { - memcpy(&context->buffer[idx], input, partLen); - MD4Transform(context->state, context->buffer); + if (used) { + free = 64 - used; + + if (inputLen < free) { + memcpy(&context->buffer[used], input, inputLen); + return APR_SUCCESS; + } - for (i = partLen; i + 63 < inputLen; i += 64) - MD4Transform(context->state, &input[i]); - - idx = 0; + memcpy(&context->buffer[used], input, free); + input = (const unsigned char *) input + free; + inputLen -= free; + body(context, context->buffer, 64); } - else - i = 0; - /* Buffer remaining input */ - memcpy(&context->buffer[idx], &input[i], inputLen - i); -#else /*APR_HAS_XLATE*/ - if (inputLen >= partLen) { - if (context->xlate) { - inbytes_left = outbytes_left = partLen; - apr_xlate_conv_buffer(context->xlate, (const char *)input, - &inbytes_left, - (char *)&context->buffer[idx], - &outbytes_left); - } - else { - memcpy(&context->buffer[idx], input, partLen); - } - MD4Transform(context->state, context->buffer); - - for (i = partLen; i + 63 < inputLen; i += 64) { - if (context->xlate) { - unsigned char inp_tmp[64]; - inbytes_left = outbytes_left = 64; - apr_xlate_conv_buffer(context->xlate, (const char *)&input[i], - &inbytes_left, - (char *)inp_tmp, &outbytes_left); - MD4Transform(context->state, inp_tmp); - } - else { - MD4Transform(context->state, &input[i]); - } - } - - idx = 0; + if (inputLen >= 64) { + input = body(context, input, inputLen & ~(unsigned long)0x3f); + inputLen &= 0x3f; } - else - i = 0; /* Buffer remaining input */ - if (context->xlate) { - inbytes_left = outbytes_left = inputLen - i; - apr_xlate_conv_buffer(context->xlate, (const char *)&input[i], - &inbytes_left, (char *)&context->buffer[idx], - &outbytes_left); - } - else { - memcpy(&context->buffer[idx], &input[i], inputLen - i); - } -#endif /*APR_HAS_XLATE*/ + memcpy(context->buffer, input, inputLen); return APR_SUCCESS; } @@ -246,28 +190,57 @@ unsigned char digest[APR_MD4_DIGESTSIZE], apr_md4_ctx_t *context) { - unsigned char bits[8]; - unsigned int idx, padLen; + unsigned long used, free; - /* Save number of bits */ - Encode(bits, context->count, 8); + used = context->count[0] & 0x3f; + context->buffer[used++] = 0x80; + + free = 64 - used; + #if APR_HAS_XLATE /* apr_md4_update() should not translate for this final round. */ context->xlate = NULL; #endif /*APR_HAS_XLATE*/ - /* Pad out to 56 mod 64. */ - idx = (unsigned int) ((context->count[0] >> 3) & 0x3f); - padLen = (idx < 56) ? (56 - idx) : (120 - idx); - apr_md4_update(context, PADDING, padLen); + if (free < 8) { + memset(&context->buffer[used], 0, free); + body(context, context->buffer, 64); + used = 0; + free = 64; + } - /* Append length (before padding) */ - apr_md4_update(context, bits, 8); + memset(&context->buffer[used], 0, free - 8); - /* Store state in digest */ - Encode(digest, context->state, APR_MD4_DIGESTSIZE); + context->count[0] <<= 3; + context->buffer[56] = context->count[0]; + context->buffer[57] = context->count[0] >> 8; + context->buffer[58] = context->count[0] >> 16; + context->buffer[59] = context->count[0] >> 24; + context->buffer[60] = context->count[1]; + context->buffer[61] = context->count[1] >> 8; + context->buffer[62] = context->count[1] >> 16; + context->buffer[63] = context->count[1] >> 24; + body(context, context->buffer, 64); + + digest[0] = context->state[0]; + digest[1] = context->state[0] >> 8; + digest[2] = context->state[0] >> 16; + digest[3] = context->state[0] >> 24; + digest[4] = context->state[1]; + digest[5] = context->state[1] >> 8; + digest[6] = context->state[1] >> 16; + digest[7] = context->state[1] >> 24; + digest[8] = context->state[2]; + digest[9] = context->state[2] >> 8; + digest[10] = context->state[2] >> 16; + digest[11] = context->state[2] >> 24; + digest[12] = context->state[3]; + digest[13] = context->state[3] >> 8; + digest[14] = context->state[3] >> 16; + digest[15] = context->state[3] >> 24; + /* Zeroize sensitive information. */ memset(context, 0, sizeof(*context)); @@ -291,110 +264,122 @@ return apr_md4_final(digest, &ctx); } -/* MD4 basic transformation. Transforms state based on block. */ -static void MD4Transform(apr_uint32_t state[4], const unsigned char block[64]) +/* + * This processes one or more 64-byte data blocks, but does NOT update + * the bit counters. There're no alignment requirements. + */ +static const void *body(apr_md4_ctx_t *context, const void *data, size_t size) { - apr_uint32_t a = state[0], b = state[1], c = state[2], d = state[3], - x[APR_MD4_DIGESTSIZE]; + const unsigned char *ptr, *convptr; + uint32_t a, b, c, d; + uint32_t saved_a, saved_b, saved_c, saved_d; + apr_uint32_t block[16]; + +#ifdef APR_HAS_XLATE + apr_size_t inbytes_left, outbytes_left; +#endif - Decode(x, block, 64); - - /* Round 1 */ - FF (a, b, c, d, x[ 0], S11); /* 1 */ - FF (d, a, b, c, x[ 1], S12); /* 2 */ - FF (c, d, a, b, x[ 2], S13); /* 3 */ - FF (b, c, d, a, x[ 3], S14); /* 4 */ - FF (a, b, c, d, x[ 4], S11); /* 5 */ - FF (d, a, b, c, x[ 5], S12); /* 6 */ - FF (c, d, a, b, x[ 6], S13); /* 7 */ - FF (b, c, d, a, x[ 7], S14); /* 8 */ - FF (a, b, c, d, x[ 8], S11); /* 9 */ - FF (d, a, b, c, x[ 9], S12); /* 10 */ - FF (c, d, a, b, x[10], S13); /* 11 */ - FF (b, c, d, a, x[11], S14); /* 12 */ - FF (a, b, c, d, x[12], S11); /* 13 */ - FF (d, a, b, c, x[13], S12); /* 14 */ - FF (c, d, a, b, x[14], S13); /* 15 */ - FF (b, c, d, a, x[15], S14); /* 16 */ - - /* Round 2 */ - GG (a, b, c, d, x[ 0], S21); /* 17 */ - GG (d, a, b, c, x[ 4], S22); /* 18 */ - GG (c, d, a, b, x[ 8], S23); /* 19 */ - GG (b, c, d, a, x[12], S24); /* 20 */ - GG (a, b, c, d, x[ 1], S21); /* 21 */ - GG (d, a, b, c, x[ 5], S22); /* 22 */ - GG (c, d, a, b, x[ 9], S23); /* 23 */ - GG (b, c, d, a, x[13], S24); /* 24 */ - GG (a, b, c, d, x[ 2], S21); /* 25 */ - GG (d, a, b, c, x[ 6], S22); /* 26 */ - GG (c, d, a, b, x[10], S23); /* 27 */ - GG (b, c, d, a, x[14], S24); /* 28 */ - GG (a, b, c, d, x[ 3], S21); /* 29 */ - GG (d, a, b, c, x[ 7], S22); /* 30 */ - GG (c, d, a, b, x[11], S23); /* 31 */ - GG (b, c, d, a, x[15], S24); /* 32 */ - - /* Round 3 */ - HH (a, b, c, d, x[ 0], S31); /* 33 */ - HH (d, a, b, c, x[ 8], S32); /* 34 */ - HH (c, d, a, b, x[ 4], S33); /* 35 */ - HH (b, c, d, a, x[12], S34); /* 36 */ - HH (a, b, c, d, x[ 2], S31); /* 37 */ - HH (d, a, b, c, x[10], S32); /* 38 */ - HH (c, d, a, b, x[ 6], S33); /* 39 */ - HH (b, c, d, a, x[14], S34); /* 40 */ - HH (a, b, c, d, x[ 1], S31); /* 41 */ - HH (d, a, b, c, x[ 9], S32); /* 42 */ - HH (c, d, a, b, x[ 5], S33); /* 43 */ - HH (b, c, d, a, x[13], S34); /* 44 */ - HH (a, b, c, d, x[ 3], S31); /* 45 */ - HH (d, a, b, c, x[11], S32); /* 46 */ - HH (c, d, a, b, x[ 7], S33); /* 47 */ - HH (b, c, d, a, x[15], S34); /* 48 */ - - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; + ptr = data; - /* Zeroize sensitive information. */ - memset(x, 0, sizeof(x)); + a = context->state[0]; + b = context->state[1]; + c = context->state[2]; + d = context->state[3]; + + do { + saved_a = a; + saved_b = b; + saved_c = c; + saved_d = d; + + convptr = ptr; +#ifdef APR_HAS_XLATE + if (context->xlate) { + inbytes_left = outbytes_left = 64; + unsigned char inp_tmp[64]; + apr_xlate_conv_buffer(context->xlate, ptr, &inbytes_left, + inp_tmp, &outbytes_left); + convptr = inp_tmp; + } +#endif + /* Round 1 */ + STEP(F, a, b, c, d, SET( 0), 3); + STEP(F, d, a, b, c, SET( 1), 7); + STEP(F, c, d, a, b, SET( 2), 11); + STEP(F, b, c, d, a, SET( 3), 19); + + STEP(F, a, b, c, d, SET( 4), 3); + STEP(F, d, a, b, c, SET( 5), 7); + STEP(F, c, d, a, b, SET( 6), 11); + STEP(F, b, c, d, a, SET( 7), 19); + + STEP(F, a, b, c, d, SET( 8), 3); + STEP(F, d, a, b, c, SET( 9), 7); + STEP(F, c, d, a, b, SET(10), 11); + STEP(F, b, c, d, a, SET(11), 19); + + STEP(F, a, b, c, d, SET(12), 3); + STEP(F, d, a, b, c, SET(13), 7); + STEP(F, c, d, a, b, SET(14), 11); + STEP(F, b, c, d, a, SET(15), 19); + /* Round 2 */ + STEP(G, a, b, c, d, GET( 0) + 0x5A827999, 3); + STEP(G, d, a, b, c, GET( 4) + 0x5A827999, 5); + STEP(G, c, d, a, b, GET( 8) + 0x5A827999, 9); + STEP(G, b, c, d, a, GET(12) + 0x5A827999, 13); + + STEP(G, a, b, c, d, GET( 1) + 0x5A827999, 3); + STEP(G, d, a, b, c, GET( 5) + 0x5A827999, 5); + STEP(G, c, d, a, b, GET( 9) + 0x5A827999, 9); + STEP(G, b, c, d, a, GET(13) + 0x5A827999, 13); + + STEP(G, a, b, c, d, GET( 2) + 0x5A827999, 3); + STEP(G, d, a, b, c, GET( 6) + 0x5A827999, 5); + STEP(G, c, d, a, b, GET(10) + 0x5A827999, 9); + STEP(G, b, c, d, a, GET(14) + 0x5A827999, 13); + + STEP(G, a, b, c, d, GET( 3) + 0x5A827999, 3); + STEP(G, d, a, b, c, GET( 7) + 0x5A827999, 5); + STEP(G, c, d, a, b, GET(11) + 0x5A827999, 9); + STEP(G, b, c, d, a, GET(15) + 0x5A827999, 13); + /* Round 3 */ + STEP(H, a, b, c, d, GET( 0) + 0x6ED9EBA1, 3); + STEP(H, d, a, b, c, GET( 8) + 0x6ED9EBA1, 9); + STEP(H, c, d, a, b, GET( 4) + 0x6ED9EBA1, 11); + STEP(H, b, c, d, a, GET(12) + 0x6ED9EBA1, 15); + + STEP(H, a, b, c, d, GET( 2) + 0x6ED9EBA1, 3); + STEP(H, d, a, b, c, GET(10) + 0x6ED9EBA1, 9); + STEP(H, c, d, a, b, GET( 6) + 0x6ED9EBA1, 11); + STEP(H, b, c, d, a, GET(14) + 0x6ED9EBA1, 15); + + STEP(H, a, b, c, d, GET( 1) + 0x6ED9EBA1, 3); + STEP(H, d, a, b, c, GET( 9) + 0x6ED9EBA1, 9); + STEP(H, c, d, a, b, GET( 5) + 0x6ED9EBA1, 11); + STEP(H, b, c, d, a, GET(13) + 0x6ED9EBA1, 15); + + STEP(H, a, b, c, d, GET( 3) + 0x6ED9EBA1, 3); + STEP(H, d, a, b, c, GET(11) + 0x6ED9EBA1, 9); + STEP(H, c, d, a, b, GET( 7) + 0x6ED9EBA1, 11); + STEP(H, b, c, d, a, GET(15) + 0x6ED9EBA1, 15); + + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; + + ptr += 64; + } while (size -= 64); + + context->state[0] = a; + context->state[1] = b; + context->state[2] = c; + context->state[3] = d; + + return ptr; } -/* Encodes input (apr_uint32_t) into output (unsigned char). Assumes len is - * a multiple of 4. - */ -static void Encode(unsigned char *output, const apr_uint32_t *input, - unsigned int len) -{ - unsigned int i, j; - apr_uint32_t k; - for (i = 0, j = 0; j < len; i++, j += 4) { - k = input[i]; - output[j] = (unsigned char)(k & 0xff); - output[j + 1] = (unsigned char)((k >> 8) & 0xff); - output[j + 2] = (unsigned char)((k >> 16) & 0xff); - output[j + 3] = (unsigned char)((k >> 24) & 0xff); - } -} - -/* Decodes input (unsigned char) into output (apr_uint32_t). Assumes len is - * a multiple of 4. - */ -static void Decode(apr_uint32_t *output, const unsigned char *input, - unsigned int len) -{ - unsigned int i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) - output[i] = ((apr_uint32_t)input[j]) | - (((apr_uint32_t)input[j + 1]) << 8) | - (((apr_uint32_t)input[j + 2]) << 16) | - (((apr_uint32_t)input[j + 3]) << 24); -} - #if APR_CHARSET_EBCDIC APU_DECLARE(apr_status_t) apr_MD4InitEBCDIC(apr_xlate_t *xlate) { Index: crypto/apr_md5.c =================================================================== --- crypto/apr_md5.c (revisjon 454475) +++ crypto/apr_md5.c (arbeidskopi) @@ -1,36 +1,17 @@ +/* FIXME: body must handle xlate */ + /* - * This is work is derived from material Copyright RSA Data Security, Inc. - * - * The RSA copyright statement and Licence for that original material is - * included below. This is followed by the Apache copyright statement and - * licence for the modifications made to that material. + * Adopted for apr-util by Tollef Fog Heen */ -/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, + * Inc. MD5 Message-Digest Algorithm. + * + * Written by Solar Designer in 2001, and placed in + * the public domain. See md5.c for more information. */ -/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All - rights reserved. - - License to copy and use this software is granted provided that it - is identified as the "RSA Data Security, Inc. MD5 Message-Digest - Algorithm" in all material mentioning or referencing this software - or this function. - - License is also granted to make and use derivative works provided - that such works are identified as "derived from the RSA Data - Security, Inc. MD5 Message-Digest Algorithm" in all material - mentioning or referencing the derived work. - - RSA Data Security, Inc. makes no representations concerning either - the merchantability of this software or the suitability of this - software for any particular purpose. It is provided "as is" - without express or implied warranty of any kind. - - These notices must be retained in any copies of any part of this - documentation and/or software. - */ - /* Copyright 2000-2005 The Apache Software Foundation or its licensors, as * applicable. * @@ -76,77 +57,54 @@ #include #endif -/* Constants for MD5Transform routine. - */ +static const void *body(apr_md5_ctx_t *context, const void *data, apr_size_t size); -#define S11 7 -#define S12 12 -#define S13 17 -#define S14 22 -#define S21 5 -#define S22 9 -#define S23 14 -#define S24 20 -#define S31 4 -#define S32 11 -#define S33 16 -#define S34 23 -#define S41 6 -#define S42 10 -#define S43 15 -#define S44 21 - -static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64]); -static void Encode(unsigned char *output, const apr_uint32_t *input, - unsigned int len); -static void Decode(apr_uint32_t *output, const unsigned char *input, - unsigned int len); - -static unsigned char PADDING[64] = -{ - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - #if APR_CHARSET_EBCDIC static apr_xlate_t *xlate_ebcdic_to_ascii; /* used in apr_md5_encode() */ #endif -/* F, G, H and I are basic MD5 functions. +/* + * The basic MD5 functions. + * + * F is optimized compared to its RFC 1321 definition just like in Colin + * Plumb's implementation. */ -#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) -#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) -#define H(x, y, z) ((x) ^ (y) ^ (z)) -#define I(x, y, z) ((y) ^ ((x) | (~z))) +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | ~(z))) -/* ROTATE_LEFT rotates x left n bits. +/* + * The MD5 transformation for all four rounds. */ -#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) +#define STEP(f, a, b, c, d, x, t, s) \ + (a) += f((b), (c), (d)) + (x) + (t); \ + (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ + (a) += (b); -/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. - * Rotation is separate from addition to prevent recomputation. +/* + * SET reads 4 input bytes in little-endian byte order and stores them + * in a properly aligned word in host byte order. + * + * The check for little-endian architectures which tolerate unaligned + * memory accesses is just an optimization. Nothing will break if it + * doesn't work. */ -#define FF(a, b, c, d, x, s, ac) { \ - (a) += F ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define GG(a, b, c, d, x, s, ac) { \ - (a) += G ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define HH(a, b, c, d, x, s, ac) { \ - (a) += H ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define II(a, b, c, d, x, s, ac) { \ - (a) += I ((b), (c), (d)) + (x) + (apr_uint32_t)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } +#if defined(__i386__) || defined(__x86_64__) || defined(__vax__) +#define SET(n) \ + (*(const apr_uint32_t *)&convptr[(n) * 4]) +#define GET(n) \ + SET(n) +#else +#define SET(n) \ + (block[(n)] = \ + (apr_uint32_t)convptr[(n) * 4] | \ + ((apr_uint32_t)convptr[(n) * 4 + 1] << 8) | \ + ((apr_uint32_t)convptr[(n) * 4 + 2] << 16) | \ + ((apr_uint32_t)convptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (block[(n)]) +#endif /* MD5 initialization. Begins an MD5 operation, writing a new context. */ @@ -199,83 +157,43 @@ const void *_input, apr_size_t inputLen) { - const unsigned char *input = _input; - unsigned int i, idx, partLen; + apr_uint32_t saved_lo; + unsigned long used, free; #if APR_HAS_XLATE - apr_size_t inbytes_left, outbytes_left; +/* apr_size_t inbytes_left, outbytes_left;*/ #endif - /* Compute number of bytes mod 64 */ - idx = (unsigned int)((context->count[0] >> 3) & 0x3F); - /* Update number of bits */ - if ((context->count[0] += ((apr_uint32_t)inputLen << 3)) - < ((apr_uint32_t)inputLen << 3)) + saved_lo = context->count[0]; + if ((context->count[0] = (saved_lo + inputLen) & 0x1fffffff) < saved_lo) context->count[1]++; context->count[1] += (apr_uint32_t)inputLen >> 29; - partLen = 64 - idx; + /* Compute number of bytes mod 64 */ + used = saved_lo & 0x3f; /* Transform as many times as possible. */ -#if !APR_HAS_XLATE - if (inputLen >= partLen) { - memcpy(&context->buffer[idx], input, partLen); - MD5Transform(context->state, context->buffer); + if (used) { + free = 64 - used; + + if (inputLen < free) { + memcpy(&context->buffer[used], _input, inputLen); + return APR_SUCCESS; + } - for (i = partLen; i + 63 < inputLen; i += 64) - MD5Transform(context->state, &input[i]); - - idx = 0; + memcpy(&context->buffer[used], _input, free); + _input = (const unsigned char *) _input + free; + inputLen -= free; + body(context, context->buffer, 64); } - else - i = 0; - /* Buffer remaining input */ - memcpy(&context->buffer[idx], &input[i], inputLen - i); -#else /*APR_HAS_XLATE*/ - if (inputLen >= partLen) { - if (context->xlate) { - inbytes_left = outbytes_left = partLen; - apr_xlate_conv_buffer(context->xlate, (const char *)input, - &inbytes_left, - (char *)&context->buffer[idx], - &outbytes_left); - } - else { - memcpy(&context->buffer[idx], input, partLen); - } - MD5Transform(context->state, context->buffer); - - for (i = partLen; i + 63 < inputLen; i += 64) { - if (context->xlate) { - unsigned char inp_tmp[64]; - inbytes_left = outbytes_left = 64; - apr_xlate_conv_buffer(context->xlate, (const char *)&input[i], - &inbytes_left, (char *)inp_tmp, - &outbytes_left); - MD5Transform(context->state, inp_tmp); - } - else { - MD5Transform(context->state, &input[i]); - } - } - - idx = 0; + if (inputLen >= 64) { + _input = body(context, _input, inputLen & ~(unsigned long)0x3f); + inputLen &= 0x3f; } - else - i = 0; /* Buffer remaining input */ - if (context->xlate) { - inbytes_left = outbytes_left = inputLen - i; - apr_xlate_conv_buffer(context->xlate, (const char *)&input[i], - &inbytes_left, (char *)&context->buffer[idx], - &outbytes_left); - } - else { - memcpy(&context->buffer[idx], &input[i], inputLen - i); - } -#endif /*APR_HAS_XLATE*/ + memcpy(context->buffer, _input, inputLen); return APR_SUCCESS; } @@ -285,28 +203,57 @@ APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE], apr_md5_ctx_t *context) { - unsigned char bits[8]; - unsigned int idx, padLen; + unsigned long used, free; - /* Save number of bits */ - Encode(bits, context->count, 8); + used = context->count[0] & 0x3f; + context->buffer[used++] = 0x80; + + free = 64 - used; + #if APR_HAS_XLATE /* apr_md5_update() should not translate for this final round. */ context->xlate = NULL; #endif /*APR_HAS_XLATE*/ - /* Pad out to 56 mod 64. */ - idx = (unsigned int)((context->count[0] >> 3) & 0x3f); - padLen = (idx < 56) ? (56 - idx) : (120 - idx); - apr_md5_update(context, PADDING, padLen); + if (free < 8) { + memset(&context->buffer[used], 0, free); + body(context, context->buffer, 64); + used = 0; + free = 64; + } - /* Append length (before padding) */ - apr_md5_update(context, bits, 8); + memset(&context->buffer[used], 0, free - 8); - /* Store state in digest */ - Encode(digest, context->state, APR_MD5_DIGESTSIZE); + context->count[0] <<= 3; + context->buffer[56] = context->count[0]; + context->buffer[57] = context->count[0] >> 8; + context->buffer[58] = context->count[0] >> 16; + context->buffer[59] = context->count[0] >> 24; + context->buffer[60] = context->count[1]; + context->buffer[61] = context->count[1] >> 8; + context->buffer[62] = context->count[1] >> 16; + context->buffer[63] = context->count[1] >> 24; + body(context, context->buffer, 64); + + digest[0] = context->state[0]; + digest[1] = context->state[0] >> 8; + digest[2] = context->state[0] >> 16; + digest[3] = context->state[0] >> 24; + digest[4] = context->state[1]; + digest[5] = context->state[1] >> 8; + digest[6] = context->state[1] >> 16; + digest[7] = context->state[1] >> 24; + digest[8] = context->state[2]; + digest[9] = context->state[2] >> 8; + digest[10] = context->state[2] >> 16; + digest[11] = context->state[2] >> 24; + digest[12] = context->state[3]; + digest[13] = context->state[3] >> 8; + digest[14] = context->state[3] >> 16; + digest[15] = context->state[3] >> 24; + /* Zeroize sensitive information. */ memset(context, 0, sizeof(*context)); @@ -331,126 +278,132 @@ return apr_md5_final(digest, &ctx); } -/* MD5 basic transformation. Transforms state based on block. */ -static void MD5Transform(apr_uint32_t state[4], const unsigned char block[64]) +/* + * This processes one or more 64-byte data blocks, but does NOT update + * the bit counters. There're no alignment requirements. + */ +static const void *body(apr_md5_ctx_t *context, const void *data, apr_size_t size) { - apr_uint32_t a = state[0], b = state[1], c = state[2], d = state[3], - x[APR_MD5_DIGESTSIZE]; + const unsigned char *ptr, *convptr; + uint_fast32_t a, b, c, d; + uint_fast32_t saved_a, saved_b, saved_c, saved_d; + apr_uint32_t block[16]; + +#ifdef APR_HAS_XLATE + apr_size_t inbytes_left, outbytes_left; +#endif - Decode(x, block, 64); + ptr = data; - /* Round 1 */ - FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */ - FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */ - FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */ - FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */ - FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */ - FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */ - FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */ - FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */ - FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */ - FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */ - FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ - FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ - FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ - FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ - FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ - FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + a = context->state[0]; + b = context->state[1]; + c = context->state[2]; + d = context->state[3]; + + do { + saved_a = a; + saved_b = b; + saved_c = c; + saved_d = d; - /* Round 2 */ - GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */ - GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */ - GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ - GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */ - GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */ - GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */ - GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ - GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */ - GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */ - GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ - GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */ - GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */ - GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ - GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */ - GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */ - GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + convptr = ptr; +#ifdef APR_HAS_XLATE + if (context->xlate) { + inbytes_left = outbytes_left = 64; + unsigned char inp_tmp[64]; + apr_xlate_conv_buffer(context->xlate, ptr, &inbytes_left, + inp_tmp, &outbytes_left); + convptr = inp_tmp; + } +#endif - /* Round 3 */ - HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */ - HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */ - HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ - HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ - HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */ - HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */ - HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */ - HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ - HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ - HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */ - HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */ - HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */ - HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */ - HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ - HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ - HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */ - /* Round 4 */ - II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */ - II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */ - II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ - II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */ - II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ - II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */ - II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ - II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */ - II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */ - II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ - II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */ - II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ - II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */ - II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ - II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */ - II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */ +/* Round 1 */ + STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) + STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) + STEP(F, c, d, a, b, SET(2), 0x242070db, 17) + STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) + STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) + STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) + STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) + STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) + STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) + STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) + STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) + STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) + STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) + STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) + STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) + STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; +/* Round 2 */ + STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) + STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) + STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) + STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) + STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) + STEP(G, d, a, b, c, GET(10), 0x02441453, 9) + STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) + STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) + STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) + STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) + STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) + STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) + STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) + STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) + STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) + STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) - /* Zeroize sensitive information. */ - memset(x, 0, sizeof(x)); -} +/* Round 3 */ + STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) + STEP(H, d, a, b, c, GET(8), 0x8771f681, 11) + STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) + STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23) + STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) + STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11) + STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) + STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23) + STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) + STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11) + STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) + STEP(H, b, c, d, a, GET(6), 0x04881d05, 23) + STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) + STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11) + STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) + STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23) -/* Encodes input (apr_uint32_t) into output (unsigned char). Assumes len is - * a multiple of 4. - */ -static void Encode(unsigned char *output, const apr_uint32_t *input, - unsigned int len) -{ - unsigned int i, j; - apr_uint32_t k; +/* Round 4 */ + STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) + STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) + STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) + STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) + STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) + STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) + STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) + STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) + STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) + STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) + STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) + STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) + STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) + STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) + STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) + STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) - for (i = 0, j = 0; j < len; i++, j += 4) { - k = input[i]; - output[j] = (unsigned char)(k & 0xff); - output[j + 1] = (unsigned char)((k >> 8) & 0xff); - output[j + 2] = (unsigned char)((k >> 16) & 0xff); - output[j + 3] = (unsigned char)((k >> 24) & 0xff); - } -} + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; -/* Decodes input (unsigned char) into output (apr_uint32_t). Assumes len is - * a multiple of 4. - */ -static void Decode(apr_uint32_t *output, const unsigned char *input, - unsigned int len) -{ - unsigned int i, j; + ptr += 64; + } while (size -= 64); - for (i = 0, j = 0; j < len; i++, j += 4) - output[i] = ((apr_uint32_t)input[j]) | - (((apr_uint32_t)input[j + 1]) << 8) | - (((apr_uint32_t)input[j + 2]) << 16) | - (((apr_uint32_t)input[j + 3]) << 24); + context->state[0] = a; + context->state[1] = b; + context->state[2] = c; + context->state[3] = d; + + return ptr; } #if APR_CHARSET_EBCDIC Index: include/apr_md5.h =================================================================== --- include/apr_md5.h (revisjon 454475) +++ include/apr_md5.h (arbeidskopi) @@ -1,31 +1,13 @@ /* - * This is work is derived from material Copyright RSA Data Security, Inc. - * - * The RSA copyright statement and Licence for that original material is - * included below. This is followed by the Apache copyright statement and - * licence for the modifications made to that material. + * Adopted for apr-util by Tollef Fog Heen */ -/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All - rights reserved. - - License to copy and use this software is granted provided that it - is identified as the "RSA Data Security, Inc. MD5 Message-Digest - Algorithm" in all material mentioning or referencing this software - or this function. - - License is also granted to make and use derivative works provided - that such works are identified as "derived from the RSA Data - Security, Inc. MD5 Message-Digest Algorithm" in all material - mentioning or referencing the derived work. - - RSA Data Security, Inc. makes no representations concerning either - the merchantability of this software or the suitability of this - software for any particular purpose. It is provided "as is" - without express or implied warranty of any kind. - - These notices must be retained in any copies of any part of this - documentation and/or software. +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, + * Inc. MD5 Message-Digest Algorithm. + * + * Written by Solar Designer in 2001, and placed in + * the public domain. See md5.c for more information. */ /* Copyright 2000-2005 The Apache Software Foundation or its licensors, as --=-=-=--