diff options
author | Tor Brede Vekterli <vekterli@yahoo-inc.com> | 2017-09-15 12:22:50 +0000 |
---|---|---|
committer | Tor Brede Vekterli <vekterli@yahoo-inc.com> | 2017-09-15 13:11:29 +0000 |
commit | 66d2cf0915c2a812c87363f3bcd31fff4d0da504 (patch) | |
tree | 360240d7639c5bac3027d485cccbf91d2dd8736b | |
parent | dcdb0188e4daf6b60c43b31b391fc32bc880f879 (diff) |
Use public domain MD5 implementation in vespalib
Add basic test vectors to ensure implementation is conformant.
-rw-r--r-- | vespalib/CMakeLists.txt | 1 | ||||
-rw-r--r-- | vespalib/src/tests/util/md5/CMakeLists.txt | 8 | ||||
-rw-r--r-- | vespalib/src/tests/util/md5/md5_test.cpp | 38 | ||||
-rw-r--r-- | vespalib/src/vespa/vespalib/util/md5.c | 519 |
4 files changed, 290 insertions, 276 deletions
diff --git a/vespalib/CMakeLists.txt b/vespalib/CMakeLists.txt index b6f8775b64b..9e11562c0b0 100644 --- a/vespalib/CMakeLists.txt +++ b/vespalib/CMakeLists.txt @@ -99,6 +99,7 @@ vespa_define_module( src/tests/tutorial/threads src/tests/util/generationhandler src/tests/util/generationhandler_stress + src/tests/util/md5 src/tests/valgrind src/tests/websocket src/tests/zcurve diff --git a/vespalib/src/tests/util/md5/CMakeLists.txt b/vespalib/src/tests/util/md5/CMakeLists.txt new file mode 100644 index 00000000000..7c3d1874275 --- /dev/null +++ b/vespalib/src/tests/util/md5/CMakeLists.txt @@ -0,0 +1,8 @@ +# Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +vespa_add_executable(vespalib_md5_test_app TEST + SOURCES + md5_test.cpp + DEPENDS + vespalib +) +vespa_add_test(NAME vespalib_md5_test_app COMMAND vespalib_md5_test_app) diff --git a/vespalib/src/tests/util/md5/md5_test.cpp b/vespalib/src/tests/util/md5/md5_test.cpp new file mode 100644 index 00000000000..6061f138566 --- /dev/null +++ b/vespalib/src/tests/util/md5/md5_test.cpp @@ -0,0 +1,38 @@ +// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#include <vespa/vespalib/testkit/test_kit.h> +#include <vespa/vespalib/util/md5.h> +#include <vespa/vespalib/stllike/string.h> +#include <vespa/vespalib/stllike/asciistream.h> + +namespace vespalib { + +string md5_hash_of(stringref buffer) { + unsigned char hash_out[16]; // Always 128 bits. + fastc_md5sum(buffer.data(), buffer.size(), hash_out); + asciistream os; + for (int i = 0; i < 16; ++i) { + os << hex << setw(2) << setfill('0') << static_cast<unsigned int>(hash_out[i]); + } + return os.str(); +} + +// https://www.nist.gov/itl/ssd/software-quality-group/nsrl-test-data +// We only include the informal test vectors here. +TEST("MD5 output matches NIST test vectors") { + EXPECT_EQUAL("900150983cd24fb0d6963f7d28e17f72", md5_hash_of("abc")); + EXPECT_EQUAL("8215ef0796a20bcaaae116d3876c664a", + md5_hash_of("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")); + EXPECT_EQUAL("7707d6ae4e027c70eea2a935c2296f21", md5_hash_of(string(1'000'000, 'a'))); +} + +// https://en.wikipedia.org/wiki/MD5#MD5_hashes +TEST("MD5 output matches Wikipedia test vectors") { + EXPECT_EQUAL("d41d8cd98f00b204e9800998ecf8427e", md5_hash_of("")); + EXPECT_EQUAL("9e107d9d372bb6826bd81d3542a419d6", md5_hash_of("The quick brown fox jumps over the lazy dog")); + EXPECT_EQUAL("e4d909c290d0fb1ca068ffaddf22cbd0", md5_hash_of("The quick brown fox jumps over the lazy dog.")); +} + +} + +TEST_MAIN() { TEST_RUN_ALL(); } + diff --git a/vespalib/src/vespa/vespalib/util/md5.c b/vespalib/src/vespa/vespalib/util/md5.c index 7c23e84d271..35319ac7e59 100644 --- a/vespalib/src/vespa/vespalib/util/md5.c +++ b/vespalib/src/vespa/vespalib/util/md5.c @@ -1,323 +1,290 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. /* + * The above copyright notice applies to changes made to code derived from + * (original license follows): * - * Generic hash functions to ensure the same hash values are used everywhere. - */ - -/* - * The following copyright notice applies to the code between the - * "--- START OF MD5 CODE ---" and "--- END OF MD5 CODE ---" markers: + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). * - * MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 * - * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All - * rights reserved. + * Author: + * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> * - * 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. + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: * - * 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. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. * - * 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. + * There's ABSOLUTELY NO WARRANTY, express or implied. * - * These notices must be retained in any copies of any part of this - * documentation and/or software. + * (This is a heavily cut-down "BSD license".) * + * This differs from Colin Plumb's older public domain implementation in that + * no exactly 32-bit integer data type is required (any 32-bit or wider + * unsigned integer data type will do), there's no compile-time endianness + * configuration, and the function prototypes match OpenSSL's. No code from + * Colin Plumb's implementation has been reused; this comment merely compares + * the properties of the two independent implementations. + * + * The primary goals of this implementation are portability and ease of use. + * It 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. */ -#include "md5.h" +// Vespalib integration notice: we use static linkage on the digest processing +// functions, as their signatures intentionally alias those of OpenSSL. Once we +// start linking with OpenSSL itself, consider using its digest functions instead. + #include <string.h> -#include <inttypes.h> - -/* --- START OF MD5 CODE --- */ - -#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 - -/* MD5 context. */ -typedef struct -{ - uint32_t state[4]; /* state (ABCD) */ - uint32_t count[2]; /* number of bits, modulo 2^64 (lsb first) */ - unsigned char buffer[64]; /* input buffer */ -} MD5_CTX; +#include "md5.h" -static void MD5Init (MD5_CTX *); -static void MD5Update (MD5_CTX *, const unsigned char *, uint32_t); -static void MD5Final (unsigned char [16], MD5_CTX *); -static void MD5Transform (uint32_t [4], const unsigned char [64]); -static void Encode (unsigned char *, uint32_t *, uint32_t); -static void Decode (uint32_t *, const unsigned char *, uint32_t); +/* Any 32-bit or wider unsigned integer data type will do */ +typedef unsigned int MD5_u32plus; -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 -}; +typedef struct { + MD5_u32plus lo, hi; + MD5_u32plus a, b, c, d; + unsigned char buffer[64]; + MD5_u32plus block[16]; +} MD5_CTX; -/* F, G, H and I are basic MD5 functions. +/* + * The basic MD5 functions. + * + * F and G are optimized compared to their RFC 1321 definitions for + * architectures that lack an AND-NOT instruction, 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 H2(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. */ -#define FF(a, b, c, d, x, s, ac) { \ - (a) += F ((b), (c), (d)) + (x) + (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) + (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) + (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) + (uint32_t)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ -} +#define SET(n) \ + (ctx->block[(n)] = \ + (MD5_u32plus)ptr[(n) * 4] | \ + ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ + ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ + ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (ctx->block[(n)]) -/* MD5 initialization. Begins an MD5 operation, writing a new context. +/* + * This processes one or more 64-byte data blocks, but does NOT update the bit + * counters. There are no alignment requirements. */ -static void -MD5Init (MD5_CTX *context) -{ - context->count[0] = context->count[1] = 0; - /* Load magic initialization constants. - */ - context->state[0] = 0x67452301ul; - context->state[1] = 0xefcdab89ul; - context->state[2] = 0x98badcfeul; - context->state[3] = 0x10325476ul; +static const void *body(MD5_CTX *ctx, const void *data, unsigned long size) { + const unsigned char *ptr; + MD5_u32plus a, b, c, d; + MD5_u32plus saved_a, saved_b, saved_c, saved_d; + + ptr = (const unsigned char *) data; + + a = ctx->a; + b = ctx->b; + c = ctx->c; + d = ctx->d; + + do { + saved_a = a; + saved_b = b; + saved_c = c; + saved_d = d; + +/* 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) + +/* 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) + +/* Round 3 */ + STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) + STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11) + STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) + STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23) + STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) + STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11) + STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) + STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23) + STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) + STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11) + STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) + STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23) + STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) + STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11) + STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) + STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23) + +/* 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) + + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; + + ptr += 64; + } while (size -= 64); + + ctx->a = a; + ctx->b = b; + ctx->c = c; + ctx->d = d; + + return ptr; } -/* MD5 block update operation. Continues an MD5 message-digest - operation, processing another message block, and updating the - context. - */ -static void -MD5Update (MD5_CTX *context, const unsigned char *input, uint32_t inputLen) -{ - uint32_t i, idx, partLen; +static void MD5_Init(MD5_CTX *ctx) { + ctx->a = 0x67452301; + ctx->b = 0xefcdab89; + ctx->c = 0x98badcfe; + ctx->d = 0x10325476; - /* Compute number of bytes mod 64 */ - idx = (uint32_t)((context->count[0] >> 3) & 0x3F); + ctx->lo = 0; + ctx->hi = 0; +} - /* Update number of bits */ - if ((context->count[0] += ((uint32_t)inputLen << 3)) < ((uint32_t)inputLen << 3)) { - context->count[1]++; - } - context->count[1] += ((uint32_t)inputLen >> 29); +static void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size) { + MD5_u32plus saved_lo; + unsigned long used, available; - partLen = 64 - idx; + saved_lo = ctx->lo; + if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) + ctx->hi++; + ctx->hi += size >> 29; - /* Transform as many times as possible. - */ - if (inputLen >= partLen) { - memcpy((unsigned char *)&context->buffer[idx], (const unsigned char *)input, partLen); - MD5Transform(context->state, context->buffer); + used = saved_lo & 0x3f; - for (i = partLen; i + 63 < inputLen; i += 64) { - MD5Transform (context->state, &input[i]); + if (used) { + available = 64 - used; + + if (size < available) { + memcpy(&ctx->buffer[used], data, size); + return; } - idx = 0; - } else { - i = 0; + + memcpy(&ctx->buffer[used], data, available); + data = (const unsigned char *) data + available; + size -= available; + body(ctx, ctx->buffer, 64); } - /* Buffer remaining input */ - memcpy((unsigned char *)&context->buffer[idx], (const unsigned char *)&input[i], inputLen-i); -} + if (size >= 64) { + data = body(ctx, data, size & ~(unsigned long) 0x3f); + size &= 0x3f; + } -/* MD5 finalization. Ends an MD5 message-digest operation, writing the - the message digest and zeroizing the context. - */ -static void -MD5Final (unsigned char digest[16], MD5_CTX *context) -{ - unsigned char bits[8]; - uint32_t idx, padLen; - - /* Save number of bits */ - Encode (bits, context->count, 8); - - /* Pad out to 56 mod 64. - */ - idx = (uint32_t)((context->count[0] >> 3) & 0x3f); - padLen = (idx < 56) ? (56 - idx) : (120 - idx); - MD5Update (context, PADDING, padLen); - - /* Append length (before padding) */ - MD5Update (context, bits, 8); - /* Store state in digest */ - Encode (digest, context->state, 16); - - /* Zeroize sensitive information. - */ - memset ((unsigned char *)context, 0, sizeof (*context)); + memcpy(ctx->buffer, data, size); } -/* MD5 basic transformation. Transforms state based on block. - */ -static void -MD5Transform (uint32_t state[4], const unsigned char dblock[64]) -{ - uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16]; - - Decode (x, dblock, 64); - - /* Round 1 */ - FF (a, b, c, d, x[ 0], S11, 0xd76aa478ul); /* 1 */ - FF (d, a, b, c, x[ 1], S12, 0xe8c7b756ul); /* 2 */ - FF (c, d, a, b, x[ 2], S13, 0x242070dbul); /* 3 */ - FF (b, c, d, a, x[ 3], S14, 0xc1bdceeeul); /* 4 */ - FF (a, b, c, d, x[ 4], S11, 0xf57c0faful); /* 5 */ - FF (d, a, b, c, x[ 5], S12, 0x4787c62aul); /* 6 */ - FF (c, d, a, b, x[ 6], S13, 0xa8304613ul); /* 7 */ - FF (b, c, d, a, x[ 7], S14, 0xfd469501ul); /* 8 */ - FF (a, b, c, d, x[ 8], S11, 0x698098d8ul); /* 9 */ - FF (d, a, b, c, x[ 9], S12, 0x8b44f7aful); /* 10 */ - FF (c, d, a, b, x[10], S13, 0xffff5bb1ul); /* 11 */ - FF (b, c, d, a, x[11], S14, 0x895cd7beul); /* 12 */ - FF (a, b, c, d, x[12], S11, 0x6b901122ul); /* 13 */ - FF (d, a, b, c, x[13], S12, 0xfd987193ul); /* 14 */ - FF (c, d, a, b, x[14], S13, 0xa679438eul); /* 15 */ - FF (b, c, d, a, x[15], S14, 0x49b40821ul); /* 16 */ - - /* Round 2 */ - GG (a, b, c, d, x[ 1], S21, 0xf61e2562ul); /* 17 */ - GG (d, a, b, c, x[ 6], S22, 0xc040b340ul); /* 18 */ - GG (c, d, a, b, x[11], S23, 0x265e5a51ul); /* 19 */ - GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aaul); /* 20 */ - GG (a, b, c, d, x[ 5], S21, 0xd62f105dul); /* 21 */ - GG (d, a, b, c, x[10], S22, 0x2441453ul); /* 22 */ - GG (c, d, a, b, x[15], S23, 0xd8a1e681ul); /* 23 */ - GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8ul); /* 24 */ - GG (a, b, c, d, x[ 9], S21, 0x21e1cde6ul); /* 25 */ - GG (d, a, b, c, x[14], S22, 0xc33707d6ul); /* 26 */ - GG (c, d, a, b, x[ 3], S23, 0xf4d50d87ul); /* 27 */ - GG (b, c, d, a, x[ 8], S24, 0x455a14edul); /* 28 */ - GG (a, b, c, d, x[13], S21, 0xa9e3e905ul); /* 29 */ - GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8ul); /* 30 */ - GG (c, d, a, b, x[ 7], S23, 0x676f02d9ul); /* 31 */ - GG (b, c, d, a, x[12], S24, 0x8d2a4c8aul); /* 32 */ - - /* Round 3 */ - HH (a, b, c, d, x[ 5], S31, 0xfffa3942ul); /* 33 */ - HH (d, a, b, c, x[ 8], S32, 0x8771f681ul); /* 34 */ - HH (c, d, a, b, x[11], S33, 0x6d9d6122ul); /* 35 */ - HH (b, c, d, a, x[14], S34, 0xfde5380cul); /* 36 */ - HH (a, b, c, d, x[ 1], S31, 0xa4beea44ul); /* 37 */ - HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9ul); /* 38 */ - HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60ul); /* 39 */ - HH (b, c, d, a, x[10], S34, 0xbebfbc70ul); /* 40 */ - HH (a, b, c, d, x[13], S31, 0x289b7ec6ul); /* 41 */ - HH (d, a, b, c, x[ 0], S32, 0xeaa127faul); /* 42 */ - HH (c, d, a, b, x[ 3], S33, 0xd4ef3085ul); /* 43 */ - HH (b, c, d, a, x[ 6], S34, 0x4881d05ul); /* 44 */ - HH (a, b, c, d, x[ 9], S31, 0xd9d4d039ul); /* 45 */ - HH (d, a, b, c, x[12], S32, 0xe6db99e5ul); /* 46 */ - HH (c, d, a, b, x[15], S33, 0x1fa27cf8ul); /* 47 */ - HH (b, c, d, a, x[ 2], S34, 0xc4ac5665ul); /* 48 */ - - /* Round 4 */ - II (a, b, c, d, x[ 0], S41, 0xf4292244ul); /* 49 */ - II (d, a, b, c, x[ 7], S42, 0x432aff97ul); /* 50 */ - II (c, d, a, b, x[14], S43, 0xab9423a7ul); /* 51 */ - II (b, c, d, a, x[ 5], S44, 0xfc93a039ul); /* 52 */ - II (a, b, c, d, x[12], S41, 0x655b59c3ul); /* 53 */ - II (d, a, b, c, x[ 3], S42, 0x8f0ccc92ul); /* 54 */ - II (c, d, a, b, x[10], S43, 0xffeff47dul); /* 55 */ - II (b, c, d, a, x[ 1], S44, 0x85845dd1ul); /* 56 */ - II (a, b, c, d, x[ 8], S41, 0x6fa87e4ful); /* 57 */ - II (d, a, b, c, x[15], S42, 0xfe2ce6e0ul); /* 58 */ - II (c, d, a, b, x[ 6], S43, 0xa3014314ul); /* 59 */ - II (b, c, d, a, x[13], S44, 0x4e0811a1ul); /* 60 */ - II (a, b, c, d, x[ 4], S41, 0xf7537e82ul); /* 61 */ - II (d, a, b, c, x[11], S42, 0xbd3af235ul); /* 62 */ - II (c, d, a, b, x[ 2], S43, 0x2ad7d2bbul); /* 63 */ - II (b, c, d, a, x[ 9], S44, 0xeb86d391ul); /* 64 */ - - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - - /* Zeroize sensitive information. - */ - memset((unsigned char *)x, 0, sizeof (x)); -} +#define OUT(dst, src) \ + (dst)[0] = (unsigned char)(src); \ + (dst)[1] = (unsigned char)((src) >> 8); \ + (dst)[2] = (unsigned char)((src) >> 16); \ + (dst)[3] = (unsigned char)((src) >> 24); + +static void MD5_Final(unsigned char *result, MD5_CTX *ctx) { + unsigned long used, available; + + used = ctx->lo & 0x3f; + + ctx->buffer[used++] = 0x80; -static void -Encode (unsigned char *output, uint32_t *input, uint32_t len) -{ - uint32_t i, j; + available = 64 - used; - for (i = 0, j = 0; j < len; i++, j += 4) { - output[j] = (unsigned char)(input[i] & 0xff); - output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); - output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); - output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); + if (available < 8) { + memset(&ctx->buffer[used], 0, available); + body(ctx, ctx->buffer, 64); + used = 0; + available = 64; } -} -/* Decodes input (unsigned char) into output (uint32_t). Assumes len is - a multiple of 4. - */ + memset(&ctx->buffer[used], 0, available - 8); -static void -Decode (uint32_t *output, const unsigned char *input, uint32_t len) -{ - uint32_t i, j; + ctx->lo <<= 3; + OUT(&ctx->buffer[56], ctx->lo) + OUT(&ctx->buffer[60], ctx->hi) - for (i = 0, j = 0; j < len; i++, j += 4) - output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) | - (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24); -} + body(ctx, ctx->buffer, 64); + OUT(&result[0], ctx->a) + OUT(&result[4], ctx->b) + OUT(&result[8], ctx->c) + OUT(&result[12], ctx->d) -/* --- END OF MD5 CODE --- */ + memset(ctx, 0, sizeof(*ctx)); +} -void fastc_md5sum(const void *s, size_t len, unsigned char *key) -{ - MD5_CTX m5; - MD5Init(&m5); - MD5Update(&m5, (const unsigned char *)s, len); - MD5Final(key, &m5); +void fastc_md5sum(const void *s, size_t len, unsigned char *key) { + MD5_CTX m5; + MD5_Init(&m5); + MD5_Update(&m5, (const unsigned char *)s, len); + MD5_Final(key, &m5); } |