ryan/mozjpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Build: Use Colin Plumb's public domain MD5 code

Browse Source 
... instead of the RSA code, the license for which contains an
advertising clause.  It is strongly believed that the RSA advertising
clause is innocuous, because:

- A clarification from RSA
  (http://www.ietf.org/ietf-ftp/IPR/RSA-MD-all), published in 2000,
  stated:

  "Implementations of these message-digest algorithms, including
  implementations derived from the reference C code in RFC-1319,
  RFC-1320, and RFC-1321, may be made, used, and sold without license
  from RSA for any purpose."

  Referring to the opinion from Fedora's legal team
  (https://fedoraproject.org/wiki/Licensing:FAQ?rd=Licensing/FAQ#What_about_the_RSA_license_on_their_MD5_implementation.3F_Isn.27t_that_GPL-incompatible.3F),
  this means that md5.c and md5.h, which were derived from the original
  RFC 1321 reference code (http://www.faqs.org/rfcs/rfc1321.html), can
  be used without the RSA license.

- In the context of libjpeg-turbo, RSA's MD5 code was used only in the
  build/test system.  It was not part of the libjpeg-turbo binary
  distribution, and thus the only "material mentioning or referencing"
  the MD5 code was the libjpeg-turbo source code, which-- by virtue of
  including RSA's original copyright headers-- properly attributed the
  code as required under the RSA license.

However, in light of the open source community's tendency to have
knee-jerk reactions to stuff like this, it would've been necessary to
include the above explanation in our source tree in order to head off
potential FUD, and a simple fix is always better than a complex
explanation.

This commit also assigns the 3-clause BSD license to my modifications of
the MD5 code.  This license is the same one used by md5cmp and other
parts of the build system.
This commit is contained in:
DRC
2018-03-31 10:36:06 -05:00
parent 9a12cf7ab5
commit 51f94caba1
3 changed files with 295 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

489
md5/md5.c
View File

@@ -1,322 +1,275 @@
/* /*
* 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. * Equivalent code is available from RSA Data Security, Inc.
* All rights reserved. * 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 * To compute the message digest of a chunk of bytes, declare an
* is identified as the "RSA Data Security, Inc. MD5 Message-Digest * MD5Context structure, pass it to MD5Init, call MD5Update as
* Algorithm" in all material mentioning or referencing this software * needed on buffers full of bytes, and then call MD5Final, which
* or this function. * will fill a supplied 16-byte array with the digest.
* ----------------------------------------------------------------------------
* libjpeg-turbo Modifications:
* Copyright (C)2018, D. R. Commander. All Rights Reserved.
* *
* License is also granted to make and use derivative works provided * Redistribution and use in source and binary forms, with or without
* that such works are identified as "derived from the RSA Data * modification, are permitted provided that the following conditions are met:
* Security, Inc. MD5 Message-Digest Algorithm" in all material
* mentioning or referencing the derived work.
* *
* RSA Data Security, Inc. makes no representations concerning either * - Redistributions of source code must retain the above copyright notice,
* the merchantability of this software or the suitability of this * this list of conditions and the following disclaimer.
* software for any particular purpose. It is provided "as is" * - Redistributions in binary form must reproduce the above copyright notice,
* without express or implied warranty of any kind. * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the libjpeg-turbo Project nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
* *
* These notices must be retained in any copies of any part of this * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
* documentation and/or software. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* This code is the same as the code published by RSA Inc. It has been * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* edited for clarity and style only. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* ----------------------------------------------------------------------------
*/ */
#include <sys/types.h> #include <string.h> /* for memcpy() */
#include <string.h> #include "md5.h"
#include "./md5.h"
#ifdef __amigaos4__
#include <machine/endian.h>
#define le32toh(x) (((x & 0xff) << 24) | \
((x & 0xff00) << 8) | \
((x & 0xff0000) >> 8) | \
((x & 0xff000000) >> 24))
#define htole32(x) le32toh(x)
#endif
static void MD5Transform(unsigned int [4], const unsigned char [64]);
#if (BYTE_ORDER == LITTLE_ENDIAN) #if (BYTE_ORDER == LITTLE_ENDIAN)
#define Encode memcpy #define byteReverse(buf, len) /* Nothing */
#define Decode memcpy
#else #else
/* /*
* OS X doesn't have le32toh() or htole32() * Note: this code is harmless on little-endian machines.
*/ */
#ifdef __APPLE__ static void byteReverse(unsigned char *buf, unsigned int longs)
#include <libkern/OSByteOrder.h> {
#define le32toh(x) OSSwapLittleToHostInt32(x) uint32 t;
#define htole32(x) OSSwapHostToLittleInt32(x) do {
t = (uint32) ((unsigned int)buf[3] << 8 | buf[2]) << 16 |
((unsigned int)buf[1] << 8 | buf[0]);
*(uint32 *) buf = t;
buf += 4;
} while (--longs);
}
#endif #endif
/* /*
* Encodes input (unsigned int) into output (unsigned char). Assumes len is * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* a multiple of 4. * initialization constants.
*/ */
void MD5Init(struct MD5Context *ctx)
static void Encode(unsigned char *output, unsigned int *input,
unsigned int len)
{ {
unsigned int i; ctx->buf[0] = 0x67452301;
unsigned int *op = (unsigned int *)output; ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
for (i = 0; i < len / 4; i++) ctx->bits[0] = 0;
op[i] = htole32(input[i]); ctx->bits[1] = 0;
} }
/* /*
* Decodes input (unsigned char) into output (unsigned int). Assumes len is * Update context to reflect the concatenation of another buffer full
* a multiple of 4. * of bytes.
*/ */
void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned int len)
static void Decode(unsigned int *output, const unsigned char *input,
unsigned int len)
{ {
unsigned int i; uint32 t;
const unsigned int *ip = (const unsigned int *)input;
for (i = 0; i < len / 4; i++) /* Update bitcount */
output[i] = le32toh(ip[i]);
}
#endif
static unsigned char PADDING[64] = { t = ctx->bits[0];
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ctx->bits[1]++; /* Carry from low to high */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ctx->bits[1] += len >> 29;
};
/* F, G, H and I are basic MD5 functions. */ t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
#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. */ /* Handle any leading odd-sized chunks */
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* if (t) {
* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. unsigned char *p = (unsigned char *)ctx->in + t;
* Rotation is separate from addition to prevent recomputation.
*/
#define FF(a, b, c, d, x, s, ac) { \
(a) += F((b), (c), (d)) + (x) + (unsigned int)(ac); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G((b), (c), (d)) + (x) + (unsigned int)(ac); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H((b), (c), (d)) + (x) + (unsigned int)(ac); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I((b), (c), (d)) + (x) + (unsigned int)(ac); \
(a) = ROTATE_LEFT((a), (s)); \
(a) += (b); \
}
/* MD5 initialization. Begins an MD5 operation, writing a new context. */ t = 64 - t;
if (len < t) {
memcpy(p, buf, len);
return;
}
memcpy(p, buf, t);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32 *)ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
void MD5Init(MD5_CTX *context) while (len >= 64) {
{ memcpy(ctx->in, buf, 64);
context->count[0] = context->count[1] = 0; byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32 *)ctx->in);
buf += 64;
len -= 64;
}
/* Load magic initialization constants. */ /* Handle any remaining bytes of data. */
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89; memcpy(ctx->in, buf, len);
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
} }
/* /*
* MD5 block update operation. Continues an MD5 message-digest * Final wrapup - pad to 64-byte boundary with the bit pattern
* operation, processing another message block, and updating the * 1 0* (64-bit count of bits processed, MSB-first)
* context.
*/ */
void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
void MD5Update(MD5_CTX *context, const void *in, unsigned int inputLen)
{ {
unsigned int i, idx, partLen; unsigned int count;
const unsigned char *input = in; unsigned char *p;
uint32 *in32 = (uint32 *)ctx->in;
/* Compute number of bytes mod 64 */ /* Compute number of bytes mod 64 */
idx = (unsigned int)((context->count[0] >> 3) & 0x3F); count = (ctx->bits[0] >> 3) & 0x3F;
/* Update number of bits */ /* Set the first char of padding to 0x80. This is safe since there is
if ((context->count[0] += ((unsigned int)inputLen << 3)) < always at least one byte free */
((unsigned int)inputLen << 3)) p = ctx->in + count;
context->count[1]++; *p++ = 0x80;
context->count[1] += ((unsigned int)inputLen >> 29);
partLen = 64 - idx; /* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Transform as many times as possible. */ /* Pad out to 56 mod 64 */
if (inputLen >= partLen) { if (count < 8) {
memcpy((void *)&context->buffer[idx], (const void *)input, partLen); /* Two lots of padding: Pad the first block to 64 bytes */
MD5Transform(context->state, context->buffer); memset(p, 0, count);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32 *)ctx->in);
for (i = partLen; i + 63 < inputLen; i += 64) /* Now fill the next block with 56 bytes */
MD5Transform(context->state, &input[i]); memset(ctx->in, 0, 56);
} else {
/* Pad block to 56 bytes */
memset(p, 0, count - 8);
}
byteReverse(ctx->in, 14);
idx = 0; /* Append length in bits and transform */
} else in32[14] = ctx->bits[0];
i = 0; in32[15] = ctx->bits[1];
/* Buffer remaining input */ MD5Transform(ctx->buf, (uint32 *)ctx->in);
memcpy((void *)&context->buffer[idx], (const void *)&input[i], inputLen - i); byteReverse((unsigned char *)ctx->buf, 4);
memcpy(digest, ctx->buf, 16);
memset(ctx, 0, sizeof(struct MD5Context)); /* In case it's sensitive */
} }
/* 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 )
/* /*
* MD5 padding. Adds padding followed by original length. * 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(uint32 buf[4], uint32 in[16])
void MD5Pad(MD5_CTX *context)
{ {
unsigned char bits[8]; register uint32 a, b, c, d;
unsigned int idx, padLen;
/* Save number of bits */ a = buf[0];
Encode(bits, context->count, 8); b = buf[1];
c = buf[2];
d = buf[3];
/* Pad out to 56 mod 64. */ MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
idx = (unsigned int)((context->count[0] >> 3) & 0x3f); MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
padLen = (idx < 56) ? (56 - idx) : (120 - idx); MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
MD5Update(context, PADDING, padLen); 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);
/* Append length (before padding) */ MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
MD5Update(context, bits, 8); 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);
* MD5 finalization. Ends an MD5 message-digest operation, writing the MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
* the message digest and zeroizing the context. 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);
void MD5Final(unsigned char digest[16], MD5_CTX *context) MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
{ MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
/* Do padding. */ MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
MD5Pad(context); MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
/* Store state in digest */ MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
Encode(digest, context->state, 16); MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
/* Zeroize sensitive information. */ MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
memset((void *)context, 0, sizeof(*context)); 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);
/* MD5 basic transformation. Transforms state based on block. */ MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
static void MD5Transform(unsigned int state[4], const unsigned char block[64]) MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
{ MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
unsigned int a = state[0], b = state[1], c = state[2], d = state[3], x[16]; MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
Decode(x, block, 64); MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
/* Round 1 */ MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
#define S11 7 MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
#define S12 12 MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
#define S13 17 MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
#define S14 22
FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
/* Round 2 */ buf[0] += a;
#define S21 5 buf[1] += b;
#define S22 9 buf[2] += c;
#define S23 14 buf[3] += d;
#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 */
/* 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 */
/* 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 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
/* Zeroize sensitive information. */
memset((void *)x, 0, sizeof(x));
} }

90
md5/md5.h
View File

@@ -1,51 +1,57 @@
/* MD5.H - header file for MD5C.C /*
* $FreeBSD$ * libjpeg-turbo Modifications:
* Copyright (C)2018 D. R. Commander. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the libjpeg-turbo Project nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/*- #ifndef MD5_H
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. #define MD5_H
All rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.
These notices must be retained in any copies of any part of this
documentation and/or software.
*/
#ifndef _SYS_MD5_H_
#define _SYS_MD5_H_
#include <sys/types.h> #include <sys/types.h>
#ifdef __amigaos4__
#include <machine/endian.h>
#endif
#define MD5_BLOCK_LENGTH 64 /* On machines where "long" is 64 bits, we need to declare
#define MD5_DIGEST_LENGTH 16 uint32 as something guaranteed to be 32 bits. */
#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_LENGTH * 2 + 1)
typedef unsigned int uint32;
/* MD5 context. */
typedef struct MD5Context { typedef struct MD5Context {
unsigned int state[4]; /* state (ABCD) */ uint32 buf[4];
unsigned int count[2]; /* number of bits, modulo 2^64 (lsb first) */ uint32 bits[2];
unsigned char buffer[64]; /* input buffer */ unsigned char in[64];
} MD5_CTX; } MD5_CTX;
void MD5Init(MD5_CTX *); extern void MD5Init(struct MD5Context *ctx);
void MD5Update(MD5_CTX *, const void *, unsigned int); extern void MD5Update(struct MD5Context *ctx, unsigned char *buf,
void MD5Final(unsigned char [16], MD5_CTX *); unsigned int len);
char *MD5End(MD5_CTX *, char *); extern void MD5Final(unsigned char digest[16], struct MD5Context *ctx);
char *MD5File(const char *, char *); extern void MD5Transform(uint32 buf[4], uint32 in[16]);
char *MD5FileChunk(const char *, char *, off_t, off_t); extern char *MD5File(const char *, char *);
char *MD5Data(const void *, unsigned int, char *); extern char *MD5FileChunk(const char *, char *, off_t, off_t);
#endif /* _SYS_MD5_H_ */
#endif /* !MD5_H */

29
md5/md5hl.c
View File

@@ -6,8 +6,31 @@
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
* libjpeg-turbo Modifications: * libjpeg-turbo Modifications:
* Copyright (C) 2016, D. R. Commander. * Copyright (C)2016, 2018 D. R. Commander. All Rights Reserved.
* Modifications are under the same license as the original code (see above) *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the libjpeg-turbo Project nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
@@ -106,6 +129,6 @@ char *MD5Data(const void *data, unsigned int len, char *buf)
MD5_CTX ctx; MD5_CTX ctx;
MD5Init(&ctx); MD5Init(&ctx);
MD5Update(&ctx, data, len); MD5Update(&ctx, (unsigned char *)data, len);
return (MD5End(&ctx, buf)); return (MD5End(&ctx, buf));
} }