tris/recoll
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replaced RSA md5 code with public domain OpenBSD/debian dpkg version

Browse Source
This commit is contained in:
Jean-Francois Dockes 2015-03-01 14:28:01 +01:00
parent bb3e6586fb
commit 9ba0b3e8bc
16 changed files with 428 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/internfile/mh_exec.cpp
View File

@ -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,

2
src/internfile/mh_execm.cpp
View File

@ -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"

2
src/internfile/mh_html.cpp
View File

@ -25,7 +25,7 @@
#include "indextext.h"
#include "mh_html.h"
#include "smallut.h"
#include "md5.h"
#include "md5ut.h"
#include <iostream>

2
src/internfile/mh_mail.cpp
View File

@ -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"

2
src/internfile/mh_mbox.cpp
View File

@ -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"

2
src/internfile/mh_text.cpp
View File

@ -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"

2
src/internfile/mimehandler.cpp
View File

@ -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"

1
src/lib/mkMake.in
View File

@ -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 \

2
src/rcldb/rcldb.cpp
View File

@ -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"

2
src/rcldb/rcldups.cpp
View File

@ -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"

6
src/utils/Makefile
View File

@ -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)

604
src/utils/md5.cpp
View File

@ -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 <stdio.h>
//#include <config.h>
//#include <compat.h>
#include <sys/types.h>
#include <string.h>
#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<<s | 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 <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#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

65
src/utils/md5.h
View File

@ -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 <string>
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_ */

151
src/utils/md5ut.cpp Normal file
View File

@ -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 <stdio.h>
#include <string.h>
#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 <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#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

33
src/utils/md5ut.h Normal file
View File

@ -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 <sys/types.h>
#include "md5.h"
/** md5 utility wrappers */
#include <string>
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_ */

2
src/utils/pathut.cpp
View File

@ -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)
{