From 9ba0b3e8bcc5413bc40e9da65a90c4b2c4ebbe3c Mon Sep 17 00:00:00 2001 From: Jean-Francois Dockes Date: Sun, 1 Mar 2015 14:28:01 +0100 Subject: [PATCH] Replaced RSA md5 code with public domain OpenBSD/debian dpkg version --- src/internfile/mh_exec.cpp | 2 +- src/internfile/mh_execm.cpp | 2 +- src/internfile/mh_html.cpp | 2 +- src/internfile/mh_mail.cpp | 2 +- src/internfile/mh_mbox.cpp | 2 +- src/internfile/mh_text.cpp | 2 +- src/internfile/mimehandler.cpp | 2 +- src/lib/mkMake.in | 1 + src/rcldb/rcldb.cpp | 2 +- src/rcldb/rcldups.cpp | 2 +- src/utils/Makefile | 6 +- src/utils/md5.cpp | 604 +++++++++++---------------------- src/utils/md5.h | 65 ++-- src/utils/md5ut.cpp | 151 +++++++++ src/utils/md5ut.h | 33 ++ src/utils/pathut.cpp | 2 +- 16 files changed, 428 insertions(+), 452 deletions(-) create mode 100644 src/utils/md5ut.cpp create mode 100644 src/utils/md5ut.h diff --git a/src/internfile/mh_exec.cpp b/src/internfile/mh_exec.cpp index f10da8f8..6bd6ee61 100644 --- a/src/internfile/mh_exec.cpp +++ b/src/internfile/mh_exec.cpp @@ -29,7 +29,7 @@ using namespace std; #include "debuglog.h" #include "cancelcheck.h" #include "smallut.h" -#include "md5.h" +#include "md5ut.h" #include "rclconfig.h" // This is called periodically by ExeCmd when it is waiting for data, diff --git a/src/internfile/mh_execm.cpp b/src/internfile/mh_execm.cpp index 51796ac2..3897bc2f 100644 --- a/src/internfile/mh_execm.cpp +++ b/src/internfile/mh_execm.cpp @@ -26,7 +26,7 @@ using namespace std; #include "debuglog.h" #include "cancelcheck.h" #include "smallut.h" -#include "md5.h" +#include "md5ut.h" #include "rclconfig.h" #include "mimetype.h" #include "idfile.h" diff --git a/src/internfile/mh_html.cpp b/src/internfile/mh_html.cpp index c16a8009..2750146d 100644 --- a/src/internfile/mh_html.cpp +++ b/src/internfile/mh_html.cpp @@ -25,7 +25,7 @@ #include "indextext.h" #include "mh_html.h" #include "smallut.h" -#include "md5.h" +#include "md5ut.h" #include diff --git a/src/internfile/mh_mail.cpp b/src/internfile/mh_mail.cpp index 85b6a58b..c2396c0e 100644 --- a/src/internfile/mh_mail.cpp +++ b/src/internfile/mh_mail.cpp @@ -36,7 +36,7 @@ #include "mh_html.h" #include "rclconfig.h" #include "mimetype.h" -#include "md5.h" +#include "md5ut.h" // binc imap mime definitions #include "mime.h" diff --git a/src/internfile/mh_mbox.cpp b/src/internfile/mh_mbox.cpp index fbdb0b52..83cf3a2a 100644 --- a/src/internfile/mh_mbox.cpp +++ b/src/internfile/mh_mbox.cpp @@ -36,7 +36,7 @@ #include "mh_mbox.h" #include "smallut.h" #include "rclconfig.h" -#include "md5.h" +#include "md5ut.h" #include "conftree.h" #include "ptmutex.h" diff --git a/src/internfile/mh_text.cpp b/src/internfile/mh_text.cpp index 7947ee3d..6aab33fa 100644 --- a/src/internfile/mh_text.cpp +++ b/src/internfile/mh_text.cpp @@ -31,7 +31,7 @@ using namespace std; #include "mh_text.h" #include "debuglog.h" #include "readfile.h" -#include "md5.h" +#include "md5ut.h" #include "rclconfig.h" #include "pxattr.h" diff --git a/src/internfile/mimehandler.cpp b/src/internfile/mimehandler.cpp index 664be028..4e72cb52 100644 --- a/src/internfile/mimehandler.cpp +++ b/src/internfile/mimehandler.cpp @@ -30,7 +30,7 @@ using namespace std; #include "debuglog.h" #include "rclconfig.h" #include "smallut.h" -#include "md5.h" +#include "md5ut.h" #include "mh_exec.h" #include "mh_execm.h" diff --git a/src/lib/mkMake.in b/src/lib/mkMake.in index f372a8ef..468eda15 100755 --- a/src/lib/mkMake.in +++ b/src/lib/mkMake.in @@ -73,6 +73,7 @@ ${depth}/utils/fstreewalk.cpp \ ${depth}/utils/idfile.cpp \ ${depth}/utils/fileudi.cpp \ ${depth}/utils/md5.cpp \ +${depth}/utils/md5ut.cpp \ ${depth}/utils/mimeparse.cpp \ ${depth}/utils/netcon.cpp \ ${depth}/utils/pathut.cpp \ diff --git a/src/rcldb/rcldb.cpp b/src/rcldb/rcldb.cpp index 8db87477..2344961a 100644 --- a/src/rcldb/rcldb.cpp +++ b/src/rcldb/rcldb.cpp @@ -46,7 +46,7 @@ using namespace std; #include "searchdata.h" #include "rclquery.h" #include "rclquery_p.h" -#include "md5.h" +#include "md5ut.h" #include "rclversion.h" #include "cancelcheck.h" #include "ptmutex.h" diff --git a/src/rcldb/rcldups.cpp b/src/rcldb/rcldups.cpp index 60913688..ddebce97 100644 --- a/src/rcldb/rcldups.cpp +++ b/src/rcldb/rcldups.cpp @@ -28,7 +28,7 @@ using namespace std; #include "rcldb.h" #include "rcldb_p.h" #include "xmacros.h" -#include "md5.h" +#include "md5ut.h" #include "searchdata.h" #include "rclquery.h" diff --git a/src/utils/Makefile b/src/utils/Makefile index 1659cfff..fa997667 100644 --- a/src/utils/Makefile +++ b/src/utils/Makefile @@ -71,11 +71,11 @@ trcopyfile.o : copyfile.cpp copyfile.h $(CXX) -o trcopyfile.o -c $(ALL_CXXFLAGS) \ -DTEST_COPYFILE copyfile.cpp -MD5_OBJS= trmd5.o +MD5_OBJS= trmd5.o md5.o trmd5 : $(MD5_OBJS) $(CXX) -o trmd5 $(MD5_OBJS) $(LIBRECOLL) $(LIBICONV) $(LIBSYS) -trmd5.o : md5.cpp md5.h - $(CXX) -o trmd5.o -c $(ALL_CXXFLAGS) -DTEST_MD5 md5.cpp +trmd5.o : md5ut.cpp md5ut.h md5.h + $(CXX) -o trmd5.o -c $(ALL_CXXFLAGS) -DTEST_MD5 md5ut.cpp PATHUT_OBJS= trpathut.o trpathut : $(PATHUT_OBJS) diff --git a/src/utils/md5.cpp b/src/utils/md5.cpp index 9d424580..7c0781a5 100644 --- a/src/utils/md5.cpp +++ b/src/utils/md5.cpp @@ -1,446 +1,252 @@ +/* $OpenBSD: md5.c,v 1.7 2004/05/28 15:10:27 millert Exp $ */ + /* - * MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + * This code implements the MD5 message-digest algorithm. + * The algorithm is due to Ron Rivest. This code was + * written by Colin Plumb in 1993, no copyright is claimed. + * This code is in the public domain; do with it what you wish. * - * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All - * rights reserved. + * Equivalent code is available from RSA Data Security, Inc. + * This code has been tested against that, and is equivalent, + * except that you don't need to include two pages of legalese + * with every copy. * - * 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. - * - * $FreeBSD: src/lib/libmd/md5c.c,v 1.11 1999/12/29 05:04:20 peter Exp $ - * - * This code is the same as the code published by RSA Inc. It has been - * edited for clarity and style only. + * To compute the message digest of a chunk of bytes, declare an + * MD5Context structure, pass it to MD5Init, call MD5Update as + * needed on buffers full of bytes, and then call MD5Final, which + * will fill a supplied 16-byte array with the digest. */ -#ifndef TEST_MD5 -#include + +//#include +//#include + +#include #include #include "md5.h" -typedef unsigned int md5uint32; +#define PUT_64BIT_LE(cp, value) do { \ + (cp)[7] = (value) >> 56; \ + (cp)[6] = (value) >> 48; \ + (cp)[5] = (value) >> 40; \ + (cp)[4] = (value) >> 32; \ + (cp)[3] = (value) >> 24; \ + (cp)[2] = (value) >> 16; \ + (cp)[1] = (value) >> 8; \ + (cp)[0] = (value); } while (0) -static void MD5Transform(md5uint32 [4], const unsigned char [64]); +#define PUT_32BIT_LE(cp, value) do { \ + (cp)[3] = (value) >> 24; \ + (cp)[2] = (value) >> 16; \ + (cp)[1] = (value) >> 8; \ + (cp)[0] = (value); } while (0) -#ifdef i386 -#define Encode memcpy -#define Decode memcpy -#else /* i386 */ - -/* - * Encodes input (md5uint32) into output (unsigned char). Assumes len is - * a multiple of 4. - */ - -static void -Encode (unsigned char *output, md5uint32 *input, unsigned int len) -{ - unsigned int i, j; - - 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); - } -} - -/* - * Decodes input (unsigned char) into output (md5uint32). Assumes len is - * a multiple of 4. - */ - -static void -Decode (md5uint32 *output, const unsigned char *input, unsigned int len) -{ - unsigned int i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) - output[i] = ((md5uint32)input[j]) | (((md5uint32)input[j+1]) << 8) | - (((md5uint32)input[j+2]) << 16) | (((md5uint32)input[j+3]) << 24); -} -#endif /* i386 */ - -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 +static u_int8_t PADDING[MD5_BLOCK_LENGTH] = { + 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 }; -/* F, G, H and I are basic MD5 functions. */ -#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))) - -/* ROTATE_LEFT rotates x left n bits. */ -#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) - /* - * FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. - * Rotation is separate from addition to prevent recomputation. + * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious + * initialization constants. */ -#define FF(a, b, c, d, x, s, ac) { \ - (a) += F ((b), (c), (d)) + (x) + (md5uint32)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define GG(a, b, c, d, x, s, ac) { \ - (a) += G ((b), (c), (d)) + (x) + (md5uint32)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define HH(a, b, c, d, x, s, ac) { \ - (a) += H ((b), (c), (d)) + (x) + (md5uint32)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } -#define II(a, b, c, d, x, s, ac) { \ - (a) += I ((b), (c), (d)) + (x) + (md5uint32)(ac); \ - (a) = ROTATE_LEFT ((a), (s)); \ - (a) += (b); \ - } - -/* MD5 initialization. Begins an MD5 operation, writing a new context. */ - void -MD5Init (MD5_CTX *context) +MD5Init(MD5_CTX *ctx) { - - context->count[0] = context->count[1] = 0; - - /* Load magic initialization constants. */ - context->state[0] = 0x67452301; - context->state[1] = 0xefcdab89; - context->state[2] = 0x98badcfe; - context->state[3] = 0x10325476; -} - -/* - * MD5 block update operation. Continues an MD5 message-digest - * operation, processing another message block, and updating the - * context. - */ - -void -MD5Update (MD5_CTX *context, const unsigned char *input, unsigned int inputLen) -{ - unsigned int i, index, partLen; - - /* Compute number of bytes mod 64 */ - index = (unsigned int)((context->count[0] >> 3) & 0x3F); - - /* Update number of bits */ - if ((context->count[0] += ((md5uint32)inputLen << 3)) - < ((md5uint32)inputLen << 3)) - context->count[1]++; - context->count[1] += ((md5uint32)inputLen >> 29); - - partLen = 64 - index; - - /* Transform as many times as possible. */ - if (inputLen >= partLen) { - memcpy((void *)&context->buffer[index], (const void *)input, - partLen); - MD5Transform (context->state, context->buffer); - - for (i = partLen; i + 63 < inputLen; i += 64) - MD5Transform (context->state, &input[i]); - - index = 0; - } - else - i = 0; - - /* Buffer remaining input */ - memcpy ((void *)&context->buffer[index], (const void *)&input[i], - inputLen-i); + ctx->count = 0; + ctx->state[0] = 0x67452301; + ctx->state[1] = 0xefcdab89; + ctx->state[2] = 0x98badcfe; + ctx->state[3] = 0x10325476; } /* - * MD5 padding. Adds padding followed by original length. + * Update context to reflect the concatenation of another buffer full + * of bytes. */ - void -MD5Pad (MD5_CTX *context) +MD5Update(MD5_CTX *ctx, const unsigned char *input, size_t len) { - unsigned char bits[8]; - unsigned int index, padLen; + size_t have, need; - /* Save number of bits */ - Encode (bits, context->count, 8); + /* Check how many bytes we already have and how many more we need. */ + have = (size_t)((ctx->count >> 3) & (MD5_BLOCK_LENGTH - 1)); + need = MD5_BLOCK_LENGTH - have; + + /* Update bitcount */ + ctx->count += (u_int64_t)len << 3; + + if (len >= need) { + if (have != 0) { + memcpy(ctx->buffer + have, input, need); + MD5Transform(ctx->state, ctx->buffer); + input += need; + len -= need; + have = 0; + } + + /* Process data in MD5_BLOCK_LENGTH-byte chunks. */ + while (len >= MD5_BLOCK_LENGTH) { + MD5Transform(ctx->state, input); + input += MD5_BLOCK_LENGTH; + len -= MD5_BLOCK_LENGTH; + } + } + + /* Handle any remaining bytes of data. */ + if (len != 0) + memcpy(ctx->buffer + have, input, len); +} + +/* + * Pad pad to 64-byte boundary with the bit pattern + * 1 0* (64-bit count of bits processed, MSB-first) + */ +void +MD5Pad(MD5_CTX *ctx) +{ + u_int8_t count[8]; + size_t padlen; + + /* Convert count to 8 bytes in little endian order. */ + PUT_64BIT_LE(count, ctx->count); /* Pad out to 56 mod 64. */ - index = (unsigned int)((context->count[0] >> 3) & 0x3f); - padLen = (index < 56) ? (56 - index) : (120 - index); - MD5Update (context, PADDING, padLen); - - /* Append length (before padding) */ - MD5Update (context, bits, 8); + padlen = MD5_BLOCK_LENGTH - + ((ctx->count >> 3) & (MD5_BLOCK_LENGTH - 1)); + if (padlen < 1 + 8) + padlen += MD5_BLOCK_LENGTH; + MD5Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */ + MD5Update(ctx, count, 8); } /* - * MD5 finalization. Ends an MD5 message-digest operation, writing the - * the message digest and zeroizing the context. + * Final wrapup--call MD5Pad, fill in digest and zero out ctx. */ - void -MD5Final (unsigned char digest[16],MD5_CTX *context) +MD5Final(unsigned char digest[MD5_DIGEST_LENGTH], MD5_CTX *ctx) { - /* Do padding. */ - MD5Pad (context); + int i; - /* Store state in digest */ - Encode (digest, context->state, 16); - - /* Zeroize sensitive information. */ - memset ((void *)context, 0, sizeof (*context)); + MD5Pad(ctx); + if (digest != NULL) { + for (i = 0; i < 4; i++) + PUT_32BIT_LE(digest + i * 4, ctx->state[i]); + memset(ctx, 0, sizeof(*ctx)); + } } -/* MD5 basic transformation. Transforms state based on block. */ -static void -MD5Transform (md5uint32 state[4], const unsigned char block[64]) +/* The four core functions - F1 is optimized somewhat */ + +/* #define F1(x, y, z) (x & y | ~x & z) */ +#define F1(x, y, z) (z ^ (x & (y ^ z))) +#define F2(x, y, z) F1(z, x, y) +#define F3(x, y, z) (x ^ y ^ z) +#define F4(x, y, z) (y ^ (x | ~z)) + +/* This is the central step in the MD5 algorithm. */ +#define MD5STEP(f, w, x, y, z, data, s) \ + ( w += f(x, y, z) + data, w = w<>(32-s), w += x ) + +/* + * The core of the MD5 algorithm, this alters an existing MD5 hash to + * reflect the addition of 16 longwords of new data. MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +void +MD5Transform(u_int32_t state[4], const u_int8_t block[MD5_BLOCK_LENGTH]) { - md5uint32 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + u_int32_t a, b, c, d, in[MD5_BLOCK_LENGTH / 4]; - Decode (x, block, 64); +#ifndef WORDS_BIGENDIAN + memcpy(in, block, sizeof(in)); +#else + for (a = 0; a < MD5_BLOCK_LENGTH / 4; a++) { + in[a] = (u_int32_t)( + (u_int32_t)(block[a * 4 + 0]) | + (u_int32_t)(block[a * 4 + 1]) << 8 | + (u_int32_t)(block[a * 4 + 2]) << 16 | + (u_int32_t)(block[a * 4 + 3]) << 24); + } +#endif - /* Round 1 */ -#define S11 7 -#define S12 12 -#define S13 17 -#define S14 22 - 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 = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; - /* Round 2 */ -#define S21 5 -#define S22 9 -#define S23 14 -#define S24 20 - 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 */ + MD5STEP(F1, a, b, c, d, in[ 0] + 0xd76aa478, 7); + MD5STEP(F1, d, a, b, c, in[ 1] + 0xe8c7b756, 12); + MD5STEP(F1, c, d, a, b, in[ 2] + 0x242070db, 17); + MD5STEP(F1, b, c, d, a, in[ 3] + 0xc1bdceee, 22); + MD5STEP(F1, a, b, c, d, in[ 4] + 0xf57c0faf, 7); + MD5STEP(F1, d, a, b, c, in[ 5] + 0x4787c62a, 12); + MD5STEP(F1, c, d, a, b, in[ 6] + 0xa8304613, 17); + MD5STEP(F1, b, c, d, a, in[ 7] + 0xfd469501, 22); + MD5STEP(F1, a, b, c, d, in[ 8] + 0x698098d8, 7); + MD5STEP(F1, d, a, b, c, in[ 9] + 0x8b44f7af, 12); + MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); + MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); + MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); + MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); + MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); + MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); - /* Round 3 */ -#define S31 4 -#define S32 11 -#define S33 16 -#define S34 23 - 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 */ + MD5STEP(F2, a, b, c, d, in[ 1] + 0xf61e2562, 5); + MD5STEP(F2, d, a, b, c, in[ 6] + 0xc040b340, 9); + MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); + MD5STEP(F2, b, c, d, a, in[ 0] + 0xe9b6c7aa, 20); + MD5STEP(F2, a, b, c, d, in[ 5] + 0xd62f105d, 5); + MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); + MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); + MD5STEP(F2, b, c, d, a, in[ 4] + 0xe7d3fbc8, 20); + MD5STEP(F2, a, b, c, d, in[ 9] + 0x21e1cde6, 5); + MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); + MD5STEP(F2, c, d, a, b, in[ 3] + 0xf4d50d87, 14); + MD5STEP(F2, b, c, d, a, in[ 8] + 0x455a14ed, 20); + MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); + MD5STEP(F2, d, a, b, c, in[ 2] + 0xfcefa3f8, 9); + MD5STEP(F2, c, d, a, b, in[ 7] + 0x676f02d9, 14); + MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); - /* Round 4 */ -#define S41 6 -#define S42 10 -#define S43 15 -#define S44 21 - 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 */ + MD5STEP(F3, a, b, c, d, in[ 5] + 0xfffa3942, 4); + MD5STEP(F3, d, a, b, c, in[ 8] + 0x8771f681, 11); + MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); + MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); + MD5STEP(F3, a, b, c, d, in[ 1] + 0xa4beea44, 4); + MD5STEP(F3, d, a, b, c, in[ 4] + 0x4bdecfa9, 11); + MD5STEP(F3, c, d, a, b, in[ 7] + 0xf6bb4b60, 16); + MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); + MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); + MD5STEP(F3, d, a, b, c, in[ 0] + 0xeaa127fa, 11); + MD5STEP(F3, c, d, a, b, in[ 3] + 0xd4ef3085, 16); + MD5STEP(F3, b, c, d, a, in[ 6] + 0x04881d05, 23); + MD5STEP(F3, a, b, c, d, in[ 9] + 0xd9d4d039, 4); + MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); + MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); + MD5STEP(F3, b, c, d, a, in[2 ] + 0xc4ac5665, 23); + + MD5STEP(F4, a, b, c, d, in[ 0] + 0xf4292244, 6); + MD5STEP(F4, d, a, b, c, in[7 ] + 0x432aff97, 10); + MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); + MD5STEP(F4, b, c, d, a, in[5 ] + 0xfc93a039, 21); + MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); + MD5STEP(F4, d, a, b, c, in[3 ] + 0x8f0ccc92, 10); + MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); + MD5STEP(F4, b, c, d, a, in[1 ] + 0x85845dd1, 21); + MD5STEP(F4, a, b, c, d, in[8 ] + 0x6fa87e4f, 6); + MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); + MD5STEP(F4, c, d, a, b, in[6 ] + 0xa3014314, 15); + MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); + MD5STEP(F4, a, b, c, d, in[4 ] + 0xf7537e82, 6); + MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); + MD5STEP(F4, c, d, a, b, in[2 ] + 0x2ad7d2bb, 15); + MD5STEP(F4, b, c, d, a, in[9 ] + 0xeb86d391, 21); state[0] += a; state[1] += b; state[2] += c; state[3] += d; - - /* Zeroize sensitive information. */ - memset ((void *)x, 0, sizeof (x)); } - -/*************** Convenience / utilities */ -void MD5Final(string &digest, MD5_CTX *context) -{ - unsigned char d[16]; - MD5Final (d, context); - digest.assign((const char *)d, 16); -} - -string& MD5String(const string& data, string& digest) -{ - MD5_CTX ctx; - MD5Init(&ctx); - MD5Update(&ctx, (const unsigned char*)data.c_str(), data.length()); - MD5Final(digest, &ctx); - return digest; -} - -string& MD5HexPrint(const string& digest, string &out) -{ - out.erase(); - out.reserve(33); - static const char hex[]="0123456789abcdef"; - const unsigned char *hash = (const unsigned char *)digest.c_str(); - for (int i = 0; i < 16; i++) { - out.append(1, hex[hash[i] >> 4]); - out.append(1, hex[hash[i] & 0x0f]); - } - return out; -} -string& MD5HexScan(const string& xdigest, string& digest) -{ - digest.erase(); - if (xdigest.length() != 32) { - return digest; - } - for (unsigned int i = 0; i < 16; i++) { - unsigned int val; - if (sscanf(xdigest.c_str() + 2*i, "%2x", &val) != 1) { - digest.erase(); - return digest; - } - digest.append(1, (unsigned char)val); - } - return digest; -} - -#include "readfile.h" -class FileScanMd5 : public FileScanDo { -public: - FileScanMd5(string& d) : digest(d) {} - virtual bool init(size_t size, string *) - { - MD5Init(&ctx); - return true; - } - virtual bool data(const char *buf, int cnt, string*) - { - MD5Update(&ctx, (const unsigned char*)buf, cnt); - return true; - } - string &digest; - MD5_CTX ctx; -}; -bool MD5File(const string& filename, string &digest, string *reason) -{ - FileScanMd5 md5er(digest); - if (!file_scan(filename, &md5er, reason)) - return false; - // We happen to know that digest and md5er.digest are the same object - MD5Final(md5er.digest, &md5er.ctx); - return true; -} -#else - -// Test driver -#include -#include - -#include -#include -#include "md5.h" - -using namespace std; - -static const char *thisprog; -static char usage [] = -"trmd5 filename\n\n" -; -static void -Usage(void) -{ - fprintf(stderr, "%s: usage:\n%s", thisprog, usage); - exit(1); -} - -int main(int argc, const char **argv) -{ - thisprog = argv[0]; - argc--; argv++; - - if (argc != 1) - Usage(); - string filename = *argv++;argc--; - - string reason, digest; - if (!MD5File(filename, digest, &reason)) { - cerr << reason << endl; - exit(1); - } else { - string hex; - cout << "MD5 (" << filename << ") = " << MD5HexPrint(digest, hex) << endl; - - string digest1; - MD5HexScan(hex, digest1); - if (digest1.compare(digest)) { - cout << "MD5HexScan Failure" << endl; - cout << MD5HexPrint(digest, hex) << " " << digest.length() << " -> " - << MD5HexPrint(digest1, hex) << " " << digest1.length() << endl; - exit(1); - } - - } - exit(0); -} - -#endif diff --git a/src/utils/md5.h b/src/utils/md5.h index ecbc85ff..f6243603 100644 --- a/src/utils/md5.h +++ b/src/utils/md5.h @@ -1,49 +1,34 @@ +/* $OpenBSD: md5.h,v 1.15 2004/05/03 17:30:14 millert Exp $ */ + +/* + * This code implements the MD5 message-digest algorithm. + * The algorithm is due to Ron Rivest. This code was + * written by Colin Plumb in 1993, no copyright is claimed. + * This code is in the public domain; do with it what you wish. + * + * Equivalent code is available from RSA Data Security, Inc. + * This code has been tested against that, and is equivalent, + * except that you don't need to include two pages of legalese + * with every copy. + */ + #ifndef _MD5_H_ #define _MD5_H_ -/* MD5.H - header file for MD5C.C - * Id: md5.h,v 1.6.2.1 1998/02/18 02:28:14 jkh Exp $ - */ -/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All -rights reserved. +#define MD5_BLOCK_LENGTH 64 +#define MD5_DIGEST_LENGTH 16 +#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_LENGTH * 2 + 1) -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. - */ - -/* Base functions from original file */ -/* MD5 context. */ typedef struct MD5Context { - unsigned int state[4]; /* state (ABCD) */ - unsigned int count[2]; /* number of bits, modulo 2^64 (lsb first) */ - unsigned char buffer[64]; /* input buffer */ + u_int32_t state[4]; /* state */ + u_int64_t count; /* number of bits, mod 2^64 */ + u_int8_t buffer[MD5_BLOCK_LENGTH]; /* input buffer */ } MD5_CTX; -extern void MD5Init (MD5_CTX *); -extern void MD5Update (MD5_CTX *, const unsigned char *, unsigned int); -extern void MD5Final (unsigned char [16], MD5_CTX *); +void MD5Init(MD5_CTX *); +void MD5Update(MD5_CTX *, const u_int8_t *, size_t); +void MD5Pad(MD5_CTX *); +void MD5Final(u_int8_t [MD5_DIGEST_LENGTH], MD5_CTX *); +void MD5Transform(u_int32_t [4], const u_int8_t [MD5_BLOCK_LENGTH]); -/* Convenience / utilities */ -#include -using std::string; -extern void MD5Final(string& digest, MD5_CTX *); -extern bool MD5File(const string& filename, string& digest, string *reason); -extern string& MD5String(const string& data, string& digest); -extern string& MD5HexPrint(const string& digest, string& xdigest); -extern string& MD5HexScan(const string& xdigest, string& digest); #endif /* _MD5_H_ */ diff --git a/src/utils/md5ut.cpp b/src/utils/md5ut.cpp new file mode 100644 index 00000000..43c990fe --- /dev/null +++ b/src/utils/md5ut.cpp @@ -0,0 +1,151 @@ +/* Copyright (C) 2015 J.F.Dockes + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef TEST_MD5 +#include +#include + +#include "md5ut.h" + +/* Convenience utilities */ + +void MD5Final(string &digest, MD5_CTX *context) +{ + unsigned char d[16]; + MD5Final (d, context); + digest.assign((const char *)d, 16); +} + +string& MD5String(const string& data, string& digest) +{ + MD5_CTX ctx; + MD5Init(&ctx); + MD5Update(&ctx, (const unsigned char*)data.c_str(), data.length()); + MD5Final(digest, &ctx); + return digest; +} + +string& MD5HexPrint(const string& digest, string &out) +{ + out.erase(); + out.reserve(33); + static const char hex[]="0123456789abcdef"; + const unsigned char *hash = (const unsigned char *)digest.c_str(); + for (int i = 0; i < 16; i++) { + out.append(1, hex[hash[i] >> 4]); + out.append(1, hex[hash[i] & 0x0f]); + } + return out; +} +string& MD5HexScan(const string& xdigest, string& digest) +{ + digest.erase(); + if (xdigest.length() != 32) { + return digest; + } + for (unsigned int i = 0; i < 16; i++) { + unsigned int val; + if (sscanf(xdigest.c_str() + 2*i, "%2x", &val) != 1) { + digest.erase(); + return digest; + } + digest.append(1, (unsigned char)val); + } + return digest; +} + +#include "readfile.h" +class FileScanMd5 : public FileScanDo { +public: + FileScanMd5(string& d) : digest(d) {} + virtual bool init(size_t size, string *) + { + MD5Init(&ctx); + return true; + } + virtual bool data(const char *buf, int cnt, string*) + { + MD5Update(&ctx, (const unsigned char*)buf, cnt); + return true; + } + string &digest; + MD5_CTX ctx; +}; +bool MD5File(const string& filename, string &digest, string *reason) +{ + FileScanMd5 md5er(digest); + if (!file_scan(filename, &md5er, reason)) + return false; + // We happen to know that digest and md5er.digest are the same object + MD5Final(md5er.digest, &md5er.ctx); + return true; +} + +#else // TEST_MD5 + +// Test driver +#include +#include + +#include +#include +#include "md5ut.h" + +using namespace std; + +static const char *thisprog; +static char usage [] = +"trmd5 filename\n\n" +; +static void +Usage(void) +{ + fprintf(stderr, "%s: usage:\n%s", thisprog, usage); + exit(1); +} + +int main(int argc, const char **argv) +{ + thisprog = argv[0]; + argc--; argv++; + + if (argc != 1) + Usage(); + string filename = *argv++;argc--; + + string reason, digest; + if (!MD5File(filename, digest, &reason)) { + cerr << reason << endl; + exit(1); + } else { + string hex; + cout << "MD5 (" << filename << ") = " << MD5HexPrint(digest, hex) << endl; + + string digest1; + MD5HexScan(hex, digest1); + if (digest1.compare(digest)) { + cout << "MD5HexScan Failure" << endl; + cout << MD5HexPrint(digest, hex) << " " << digest.length() << " -> " + << MD5HexPrint(digest1, hex) << " " << digest1.length() << endl; + exit(1); + } + + } + exit(0); +} + +#endif diff --git a/src/utils/md5ut.h b/src/utils/md5ut.h new file mode 100644 index 00000000..f1e5c81f --- /dev/null +++ b/src/utils/md5ut.h @@ -0,0 +1,33 @@ +/* Copyright (C) 2014 J.F.Dockes + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ +#ifndef _MD5UT_H_ +#define _MD5UT_H_ + +#include + +#include "md5.h" + +/** md5 utility wrappers */ +#include +using std::string; +extern void MD5Final(string& digest, MD5_CTX *); +extern bool MD5File(const string& filename, string& digest, string *reason); +extern string& MD5String(const string& data, string& digest); +extern string& MD5HexPrint(const string& digest, string& xdigest); +extern string& MD5HexScan(const string& xdigest, string& digest); + +#endif /* _MD5UT_H_ */ diff --git a/src/utils/pathut.cpp b/src/utils/pathut.cpp index 22fa3c7d..b29e11db 100644 --- a/src/utils/pathut.cpp +++ b/src/utils/pathut.cpp @@ -57,7 +57,7 @@ using namespace std; #include "pathut.h" #include "transcode.h" #include "wipedir.h" -#include "md5.h" +#include "md5ut.h" bool fsocc(const string &path, int *pc, long *blocks) {