mirror of
https://github.com/amadvance/snapraid.git
synced 2026-10-26 10:51:54 -04:00
Removes MD5 support.
This commit is contained in:
Andrea Mazzoleni
parent
eb2f45072e
commit
9e1ea619c5
11 changed files with 6 additions and 362 deletions
1
HISTORY
1
HISTORY
|
|
@ -31,6 +31,7 @@ SnapRAID HISTORY
|
|||
* Exclude rules are now also applied to directories.
|
||||
This allows to excludes some file/directory without the need to call
|
||||
the stat() function on them.
|
||||
* Removed MD5 support.
|
||||
|
||||
1.13 2012/11
|
||||
============
|
||||
|
|
|
|||
|
|
@ -29,8 +29,6 @@ noinst_HEADERS = \
|
|||
state.h \
|
||||
parity.h \
|
||||
handle.h \
|
||||
md5.h \
|
||||
md5.c \
|
||||
murmurhash3.c \
|
||||
tommyarray.h \
|
||||
tommychain.h \
|
||||
|
|
|
|||
2
TODO
2
TODO
|
|
@ -32,8 +32,6 @@ is too complex.
|
|||
|
||||
- v2.x
|
||||
|
||||
* Remove the old MD5 support.
|
||||
|
||||
* A new 'init' command to differentiate the first 'sync' operation.
|
||||
This 'init' will work also without a content file, and parity files.
|
||||
Instead 'sync' will require all of them.
|
||||
|
|
|
|||
14
configure.ac
14
configure.ac
|
|
@ -64,20 +64,6 @@ AS_CASE([$host],
|
|||
[]
|
||||
)
|
||||
|
||||
dnl Checks for options
|
||||
AC_ARG_WITH([crypto],
|
||||
[AS_HELP_STRING([--with-crypto],
|
||||
[enable the use of the MD5 fast implementation of the OpenSSL crypto library])],
|
||||
[],
|
||||
[with_crypto=check])
|
||||
AS_IF([test "x$with_crypto" != xno], [
|
||||
AC_CHECK_LIB([crypto], [MD5], [],
|
||||
[if test "x$with_crypto" != xcheck; then
|
||||
AC_MSG_FAILURE([--with-crypto was given, but test for OpenSSL crypto library failed])
|
||||
fi
|
||||
])
|
||||
])
|
||||
|
||||
AC_ARG_ENABLE([profiler],
|
||||
[AS_HELP_STRING([--enable-profiler],[enable the use of gprof for code coverage])],
|
||||
[
|
||||
|
|
|
|||
246
md5.c
246
md5.c
|
|
@ -1,246 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Changed so as no longer to depend on Colin Plumb's `usual.h' header
|
||||
* definitions; now uses stuff from dpkg's config.h.
|
||||
* - Ian Jackson <ijackson@nyx.cs.du.edu>.
|
||||
* Still in the public domain.
|
||||
*
|
||||
* Added convenience MD5(buffer,length,digest) function.
|
||||
* - Gordon Mohr <gojomo@bitzi.com>
|
||||
* Still in the public domain.
|
||||
*/
|
||||
|
||||
#include "portable.h"
|
||||
|
||||
#include "md5.h"
|
||||
|
||||
#if WORDS_BIGENDIAN
|
||||
void byteSwap(uint32_t *buf, unsigned words)
|
||||
{
|
||||
md5byte *p = (md5byte *)buf;
|
||||
|
||||
do {
|
||||
*buf++ = (uint32_t)((unsigned)p[3] << 8 | p[2]) << 16 |
|
||||
((unsigned)p[1] << 8 | p[0]);
|
||||
p += 4;
|
||||
} while (--words);
|
||||
}
|
||||
#else
|
||||
#define byteSwap(buf,words)
|
||||
#endif
|
||||
|
||||
/* 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,in,s) \
|
||||
(w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
|
||||
|
||||
/*
|
||||
* The core of the MD5 algorithm, this alters an existing MD5 hash to
|
||||
* reflect the addition of 16 longwords of new data. md5_update blocks
|
||||
* the data and converts bytes into longwords for this routine.
|
||||
*/
|
||||
static void
|
||||
md5_transform(uint32_t buf[4], uint32_t const in[16])
|
||||
{
|
||||
uint32_t a, b, c, d;
|
||||
|
||||
a = buf[0];
|
||||
b = buf[1];
|
||||
c = buf[2];
|
||||
d = buf[3];
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
buf[0] += a;
|
||||
buf[1] += b;
|
||||
buf[2] += c;
|
||||
buf[3] += d;
|
||||
}
|
||||
|
||||
/*
|
||||
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
|
||||
* initialization constants.
|
||||
*/
|
||||
void md5_init(struct md5_t *ctx)
|
||||
{
|
||||
ctx->buf[0] = 0x67452301;
|
||||
ctx->buf[1] = 0xefcdab89;
|
||||
ctx->buf[2] = 0x98badcfe;
|
||||
ctx->buf[3] = 0x10325476;
|
||||
|
||||
ctx->bytes[0] = 0;
|
||||
ctx->bytes[1] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Update context to reflect the concatenation of another buffer full
|
||||
* of bytes.
|
||||
*/
|
||||
void md5_update(struct md5_t* ctx, const unsigned char* buf, unsigned len)
|
||||
{
|
||||
uint32_t t;
|
||||
|
||||
/* Update byte count */
|
||||
|
||||
t = ctx->bytes[0];
|
||||
if ((ctx->bytes[0] = t + len) < t)
|
||||
ctx->bytes[1]++; /* Carry from low to high */
|
||||
|
||||
t = 64 - (t & 0x3f); /* Space available in ctx->in (at least 1) */
|
||||
if (t > len) {
|
||||
memcpy((uint8_t *)ctx->in + 64 - t, buf, len);
|
||||
return;
|
||||
}
|
||||
/* First chunk is an odd size */
|
||||
memcpy((uint8_t *)ctx->in + 64 - t, buf, t);
|
||||
byteSwap(ctx->in, 16);
|
||||
md5_transform(ctx->buf, ctx->in);
|
||||
buf += t;
|
||||
len -= t;
|
||||
|
||||
/* Process data in 64-byte chunks */
|
||||
while (len >= 64) {
|
||||
memcpy(ctx->in, buf, 64);
|
||||
byteSwap(ctx->in, 16);
|
||||
md5_transform(ctx->buf, ctx->in);
|
||||
buf += 64;
|
||||
len -= 64;
|
||||
}
|
||||
|
||||
/* Handle any remaining bytes of data. */
|
||||
memcpy(ctx->in, buf, len);
|
||||
}
|
||||
|
||||
/*
|
||||
* Final wrapup - pad to 64-byte boundary with the bit pattern
|
||||
* 1 0* (64-bit count of bits processed, MSB-first)
|
||||
*/
|
||||
void md5_final(struct md5_t* ctx, unsigned char* digest)
|
||||
{
|
||||
int count = ctx->bytes[0] & 0x3f; /* Number of bytes in ctx->in */
|
||||
uint8_t *p = (uint8_t *)ctx->in + count;
|
||||
|
||||
/* Set the first char of padding to 0x80. There is always room. */
|
||||
*p++ = 0x80;
|
||||
|
||||
/* Bytes of padding needed to make 56 bytes (-8..55) */
|
||||
count = 56 - 1 - count;
|
||||
|
||||
if (count < 0) { /* Padding forces an extra block */
|
||||
memset(p, 0, count + 8);
|
||||
byteSwap(ctx->in, 16);
|
||||
md5_transform(ctx->buf, ctx->in);
|
||||
p = (uint8_t *)ctx->in;
|
||||
count = 56;
|
||||
}
|
||||
memset(p, 0, count);
|
||||
byteSwap(ctx->in, 14);
|
||||
|
||||
/* Append length in bits and transform */
|
||||
ctx->in[14] = ctx->bytes[0] << 3;
|
||||
ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
|
||||
md5_transform(ctx->buf, ctx->in);
|
||||
|
||||
byteSwap(ctx->buf, 4);
|
||||
memcpy(digest, ctx->buf, 16);
|
||||
}
|
||||
|
||||
/*
|
||||
* Convenience function for when what you need to MD5 is
|
||||
* in a single contiguous buffer.
|
||||
*/
|
||||
void MD5(uint8_t *buffer, unsigned int length, uint8_t *digest)
|
||||
{
|
||||
struct md5_t md5ctx;
|
||||
md5_init(&md5ctx);
|
||||
md5_update(&md5ctx,buffer,length);
|
||||
md5_final(&md5ctx,digest);
|
||||
}
|
||||
|
||||
38
md5.h
38
md5.h
|
|
@ -1,38 +0,0 @@
|
|||
/*
|
||||
* This is the header file for 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.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Changed so as no longer to depend on Colin Plumb's `usual.h'
|
||||
* header definitions; now uses stuff from dpkg's config.h
|
||||
* - Ian Jackson <ijackson@nyx.cs.du.edu>.
|
||||
* Still in the public domain.
|
||||
*/
|
||||
|
||||
#ifndef __MD5_H
|
||||
#define __MD5_H
|
||||
|
||||
#define MD5_SIZE 16
|
||||
|
||||
struct md5_t {
|
||||
uint32_t buf[4];
|
||||
uint32_t bytes[2];
|
||||
uint32_t in[16];
|
||||
};
|
||||
|
||||
void md5_init(struct md5_t* context);
|
||||
void md5_update(struct md5_t* context, const unsigned char* buf, unsigned len);
|
||||
void md5_final(struct md5_t* context, unsigned char* digest);
|
||||
|
||||
#endif
|
||||
31
selftest.c
31
selftest.c
|
|
@ -26,28 +26,6 @@ struct test_vector {
|
|||
unsigned char digest[HASH_SIZE];
|
||||
};
|
||||
|
||||
/**
|
||||
* Test vectors for MD5 from RFC1321.
|
||||
*
|
||||
* MD5("") = d41d8cd98f00b204e9800998ecf8427e
|
||||
* MD5("a") = 0cc175b9c0f1b6a831c399e269772661
|
||||
* MD5("abc") = 900150983cd24fb0d6963f7d28e17f72
|
||||
* MD5("message digest") = f96b697d7cb7938d525a2f31aaf161d0
|
||||
* MD5("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
|
||||
* MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f
|
||||
* MD5("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a
|
||||
*/
|
||||
struct test_vector TEST_MD5[] = {
|
||||
{ "", { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e } },
|
||||
{ "a", { 0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8, 0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 } },
|
||||
{ "abc", { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0, 0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 } },
|
||||
{ "message digest", { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d, 0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 } },
|
||||
{ "abcdefghijklmnopqrstuvwxyz", { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00, 0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b } },
|
||||
{ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5, 0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f } },
|
||||
{ "12345678901234567890123456789012345678901234567890123456789012345678901234567890", { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55, 0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a, } },
|
||||
{ 0, { 0 } }
|
||||
};
|
||||
|
||||
/**
|
||||
* Test vectors for MurmorHash3_x86_128
|
||||
*/
|
||||
|
|
@ -211,15 +189,6 @@ static void hashtest(void)
|
|||
{
|
||||
unsigned i;
|
||||
|
||||
for(i=0;TEST_MD5[i].data;++i) {
|
||||
unsigned char digest[HASH_SIZE];
|
||||
memhash(HASH_MD5, digest, TEST_MD5[i].data, strlen(TEST_MD5[i].data));
|
||||
if (memcmp(digest, TEST_MD5[i].digest, HASH_SIZE) != 0) {
|
||||
fprintf(stderr, "Failed MD5 test vector\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
for(i=0;TEST_MURMUR3[i].data;++i) {
|
||||
unsigned char digest[HASH_SIZE];
|
||||
memhash(HASH_MURMUR3, digest, TEST_MURMUR3[i].data, strlen(TEST_MURMUR3[i].data));
|
||||
|
|
|
|||
8
speed.c
8
speed.c
|
|
@ -87,14 +87,6 @@ void speed(void)
|
|||
|
||||
printf("memset %"PRIu64" [MB/s]\n", ds / dt);
|
||||
|
||||
SPEED_START {
|
||||
for(j=0;j<diskmax;++j) {
|
||||
memhash(HASH_MD5, digest, buffer[j], block_size);
|
||||
}
|
||||
} SPEED_STOP
|
||||
|
||||
printf("MD5 %"PRIu64" [MB/s]\n", ds / dt);
|
||||
|
||||
SPEED_START {
|
||||
for(j=0;j<diskmax;++j) {
|
||||
memhash(HASH_MURMUR3, digest, buffer[j], block_size);
|
||||
|
|
|
|||
5
state.c
5
state.c
|
|
@ -1198,6 +1198,11 @@ void state_read(struct snapraid_state* state)
|
|||
|
||||
sclose(f);
|
||||
|
||||
if (state->hash == HASH_MD5) {
|
||||
fprintf(stderr, "MD5 is not supported anymore.\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
state->loaded_blockmax = blockmax;
|
||||
|
||||
/* update the mapping */
|
||||
|
|
|
|||
3
state.h
3
state.h
|
|
@ -26,9 +26,6 @@
|
|||
*/
|
||||
extern volatile int global_interrupt;
|
||||
|
||||
#define HASH_MURMUR3 0
|
||||
#define HASH_MD5 1
|
||||
|
||||
struct snapraid_state {
|
||||
int verbose; /**< Verbose output. */
|
||||
int gui; /**< Gui output. */
|
||||
|
|
|
|||
18
util.c
18
util.c
|
|
@ -705,12 +705,6 @@ void* malloc_nofail_align(size_t size, void** freeptr)
|
|||
return ptr;
|
||||
}
|
||||
|
||||
#if HAVE_LIBCRYPTO
|
||||
#include <openssl/md5.h>
|
||||
#else
|
||||
#include "md5.c"
|
||||
#endif
|
||||
|
||||
#include "murmurhash3.c"
|
||||
|
||||
void memhash(unsigned kind, void* digest, const void* src, unsigned size)
|
||||
|
|
@ -719,17 +713,5 @@ void memhash(unsigned kind, void* digest, const void* src, unsigned size)
|
|||
MurmurHash3_x86_128(src, size, 0, digest);
|
||||
return;
|
||||
}
|
||||
|
||||
if (kind == HASH_MD5) {
|
||||
#if HAVE_LIBCRYPTO
|
||||
MD5((void*)src, size, digest);
|
||||
#else
|
||||
struct md5_t md5;
|
||||
md5_init(&md5);
|
||||
md5_update(&md5, src, size);
|
||||
md5_final(&md5, digest);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue