Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
This commit is contained in:
DRC
328
md5/md5.c
328
md5/md5.c
@@ -1,8 +1,8 @@
|
||||
/*
|
||||
* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
|
||||
*
|
||||
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||||
* rights reserved.
|
||||
* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991.
|
||||
* 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
|
||||
@@ -61,14 +61,14 @@ static void MD5Transform(unsigned int [4], const unsigned char [64]);
|
||||
* a multiple of 4.
|
||||
*/
|
||||
|
||||
static void
|
||||
Encode (unsigned char *output, unsigned int *input, unsigned int len)
|
||||
static void Encode(unsigned char *output, unsigned int *input,
|
||||
unsigned int len)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned int *op = (unsigned int *)output;
|
||||
unsigned int i;
|
||||
unsigned int *op = (unsigned int *)output;
|
||||
|
||||
for (i = 0; i < len / 4; i++)
|
||||
op[i] = htole32(input[i]);
|
||||
for (i = 0; i < len / 4; i++)
|
||||
op[i] = htole32(input[i]);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -76,14 +76,14 @@ Encode (unsigned char *output, unsigned int *input, unsigned int len)
|
||||
* a multiple of 4.
|
||||
*/
|
||||
|
||||
static void
|
||||
Decode (unsigned int *output, const unsigned char *input, unsigned int len)
|
||||
static void Decode(unsigned int *output, const unsigned char *input,
|
||||
unsigned int len)
|
||||
{
|
||||
unsigned int i;
|
||||
const unsigned int *ip = (const unsigned int *)input;
|
||||
unsigned int i;
|
||||
const unsigned int *ip = (const unsigned int *)input;
|
||||
|
||||
for (i = 0; i < len / 4; i++)
|
||||
output[i] = le32toh(ip[i]);
|
||||
for (i = 0; i < len / 4; i++)
|
||||
output[i] = le32toh(ip[i]);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -100,47 +100,44 @@ static unsigned char PADDING[64] = {
|
||||
#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))))
|
||||
#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.
|
||||
*/
|
||||
#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); \
|
||||
}
|
||||
(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); \
|
||||
}
|
||||
(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); \
|
||||
}
|
||||
(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); \
|
||||
}
|
||||
(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. */
|
||||
|
||||
void
|
||||
MD5Init (context)
|
||||
MD5_CTX *context;
|
||||
void MD5Init(MD5_CTX *context)
|
||||
{
|
||||
context->count[0] = context->count[1] = 0;
|
||||
|
||||
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;
|
||||
/* Load magic initialization constants. */
|
||||
context->state[0] = 0x67452301;
|
||||
context->state[1] = 0xefcdab89;
|
||||
context->state[2] = 0x98badcfe;
|
||||
context->state[3] = 0x10325476;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -149,66 +146,57 @@ MD5Init (context)
|
||||
* context.
|
||||
*/
|
||||
|
||||
void
|
||||
MD5Update (context, in, inputLen)
|
||||
MD5_CTX *context;
|
||||
const void *in;
|
||||
unsigned int inputLen;
|
||||
void MD5Update(MD5_CTX *context, const void *in, unsigned int inputLen)
|
||||
{
|
||||
unsigned int i, idx, partLen;
|
||||
const unsigned char *input = in;
|
||||
unsigned int i, idx, partLen;
|
||||
const unsigned char *input = in;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
|
||||
/* Compute number of bytes mod 64 */
|
||||
idx = (unsigned int)((context->count[0] >> 3) & 0x3F);
|
||||
|
||||
/* Update number of bits */
|
||||
if ((context->count[0] += ((unsigned int)inputLen << 3))
|
||||
< ((unsigned int)inputLen << 3))
|
||||
context->count[1]++;
|
||||
context->count[1] += ((unsigned int)inputLen >> 29);
|
||||
/* Update number of bits */
|
||||
if ((context->count[0] += ((unsigned int)inputLen << 3)) <
|
||||
((unsigned int)inputLen << 3))
|
||||
context->count[1]++;
|
||||
context->count[1] += ((unsigned int)inputLen >> 29);
|
||||
|
||||
partLen = 64 - idx;
|
||||
partLen = 64 - idx;
|
||||
|
||||
/* Transform as many times as possible. */
|
||||
if (inputLen >= partLen) {
|
||||
memcpy((void *)&context->buffer[idx], (const void *)input,
|
||||
partLen);
|
||||
MD5Transform (context->state, context->buffer);
|
||||
/* Transform as many times as possible. */
|
||||
if (inputLen >= partLen) {
|
||||
memcpy((void *)&context->buffer[idx], (const void *)input, partLen);
|
||||
MD5Transform(context->state, context->buffer);
|
||||
|
||||
for (i = partLen; i + 63 < inputLen; i += 64)
|
||||
MD5Transform (context->state, &input[i]);
|
||||
for (i = partLen; i + 63 < inputLen; i += 64)
|
||||
MD5Transform(context->state, &input[i]);
|
||||
|
||||
idx = 0;
|
||||
}
|
||||
else
|
||||
i = 0;
|
||||
idx = 0;
|
||||
} else
|
||||
i = 0;
|
||||
|
||||
/* Buffer remaining input */
|
||||
memcpy ((void *)&context->buffer[idx], (const void *)&input[i],
|
||||
inputLen-i);
|
||||
/* Buffer remaining input */
|
||||
memcpy((void *)&context->buffer[idx], (const void *)&input[i], inputLen - i);
|
||||
}
|
||||
|
||||
/*
|
||||
* MD5 padding. Adds padding followed by original length.
|
||||
*/
|
||||
|
||||
void
|
||||
MD5Pad (context)
|
||||
MD5_CTX *context;
|
||||
void MD5Pad(MD5_CTX *context)
|
||||
{
|
||||
unsigned char bits[8];
|
||||
unsigned int idx, padLen;
|
||||
unsigned char bits[8];
|
||||
unsigned int idx, padLen;
|
||||
|
||||
/* Save number of bits */
|
||||
Encode (bits, context->count, 8);
|
||||
/* Save number of bits */
|
||||
Encode(bits, context->count, 8);
|
||||
|
||||
/* Pad out to 56 mod 64. */
|
||||
idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
|
||||
padLen = (idx < 56) ? (56 - idx) : (120 - idx);
|
||||
MD5Update (context, PADDING, padLen);
|
||||
/* Pad out to 56 mod 64. */
|
||||
idx = (unsigned int)((context->count[0] >> 3) & 0x3f);
|
||||
padLen = (idx < 56) ? (56 - idx) : (120 - idx);
|
||||
MD5Update(context, PADDING, padLen);
|
||||
|
||||
/* Append length (before padding) */
|
||||
MD5Update (context, bits, 8);
|
||||
/* Append length (before padding) */
|
||||
MD5Update(context, bits, 8);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -216,125 +204,119 @@ MD5Pad (context)
|
||||
* the message digest and zeroizing the context.
|
||||
*/
|
||||
|
||||
void
|
||||
MD5Final (digest, context)
|
||||
unsigned char digest[16];
|
||||
MD5_CTX *context;
|
||||
void MD5Final(unsigned char digest[16], MD5_CTX *context)
|
||||
{
|
||||
/* Do padding. */
|
||||
MD5Pad (context);
|
||||
/* Do padding. */
|
||||
MD5Pad(context);
|
||||
|
||||
/* Store state in digest */
|
||||
Encode (digest, context->state, 16);
|
||||
/* Store state in digest */
|
||||
Encode(digest, context->state, 16);
|
||||
|
||||
/* Zeroize sensitive information. */
|
||||
memset ((void *)context, 0, sizeof (*context));
|
||||
/* Zeroize sensitive information. */
|
||||
memset((void *)context, 0, sizeof(*context));
|
||||
}
|
||||
|
||||
/* MD5 basic transformation. Transforms state based on block. */
|
||||
|
||||
static void
|
||||
MD5Transform (state, block)
|
||||
unsigned int state[4];
|
||||
const unsigned char block[64];
|
||||
static void MD5Transform(unsigned int state[4], const unsigned char block[64])
|
||||
{
|
||||
unsigned int a = state[0], b = state[1], c = state[2], d = state[3], x[16];
|
||||
unsigned int a = state[0], b = state[1], c = state[2], d = state[3], x[16];
|
||||
|
||||
Decode (x, block, 64);
|
||||
Decode(x, block, 64);
|
||||
|
||||
/* Round 1 */
|
||||
/* 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 */
|
||||
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 */
|
||||
|
||||
/* Round 2 */
|
||||
/* 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 */
|
||||
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 */
|
||||
/* 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 */
|
||||
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 */
|
||||
/* 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 */
|
||||
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;
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
|
||||
/* Zeroize sensitive information. */
|
||||
memset ((void *)x, 0, sizeof (x));
|
||||
/* Zeroize sensitive information. */
|
||||
memset((void *)x, 0, sizeof(x));
|
||||
}
|
||||
|
||||
30
md5/md5.h
30
md5/md5.h
@@ -3,8 +3,8 @@
|
||||
*/
|
||||
|
||||
/*-
|
||||
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||||
rights reserved.
|
||||
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991.
|
||||
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
|
||||
@@ -30,22 +30,22 @@ documentation and/or software.
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#define MD5_BLOCK_LENGTH 64
|
||||
#define MD5_DIGEST_LENGTH 16
|
||||
#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_LENGTH * 2 + 1)
|
||||
#define MD5_BLOCK_LENGTH 64
|
||||
#define MD5_DIGEST_LENGTH 16
|
||||
#define MD5_DIGEST_STRING_LENGTH (MD5_DIGEST_LENGTH * 2 + 1)
|
||||
|
||||
/* 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 */
|
||||
unsigned int state[4]; /* state (ABCD) */
|
||||
unsigned int count[2]; /* number of bits, modulo 2^64 (lsb first) */
|
||||
unsigned char buffer[64]; /* input buffer */
|
||||
} MD5_CTX;
|
||||
|
||||
void MD5Init (MD5_CTX *);
|
||||
void MD5Update (MD5_CTX *, const void *, unsigned int);
|
||||
void MD5Final (unsigned char [16], MD5_CTX *);
|
||||
char * MD5End(MD5_CTX *, char *);
|
||||
char * MD5File(const char *, char *);
|
||||
char * MD5FileChunk(const char *, char *, off_t, off_t);
|
||||
char * MD5Data(const void *, unsigned int, char *);
|
||||
void MD5Init(MD5_CTX *);
|
||||
void MD5Update(MD5_CTX *, const void *, unsigned int);
|
||||
void MD5Final(unsigned char [16], MD5_CTX *);
|
||||
char *MD5End(MD5_CTX *, char *);
|
||||
char *MD5File(const char *, char *);
|
||||
char *MD5FileChunk(const char *, char *, off_t, off_t);
|
||||
char *MD5Data(const void *, unsigned int, char *);
|
||||
#endif /* _SYS_MD5_H_ */
|
||||
|
||||
38
md5/md5cmp.c
38
md5/md5cmp.c
@@ -33,27 +33,27 @@
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
char *md5sum = NULL, buf[65];
|
||||
char *md5sum = NULL, buf[65];
|
||||
|
||||
if (argc < 3) {
|
||||
fprintf(stderr, "USAGE: %s <correct MD5 sum> <file>\n", argv[0]);
|
||||
return -1;
|
||||
}
|
||||
if (argc < 3) {
|
||||
fprintf(stderr, "USAGE: %s <correct MD5 sum> <file>\n", argv[0]);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (strlen(argv[1]) != 32)
|
||||
fprintf(stderr, "WARNING: MD5 hash size is wrong.\n");
|
||||
if (strlen(argv[1]) != 32)
|
||||
fprintf(stderr, "WARNING: MD5 hash size is wrong.\n");
|
||||
|
||||
md5sum = MD5File(argv[2], buf);
|
||||
if (!md5sum) {
|
||||
perror("Could not obtain MD5 sum");
|
||||
return -1;
|
||||
}
|
||||
md5sum = MD5File(argv[2], buf);
|
||||
if (!md5sum) {
|
||||
perror("Could not obtain MD5 sum");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!strcasecmp(md5sum, argv[1])) {
|
||||
fprintf(stderr, "%s: OK\n", argv[2]);
|
||||
return 0;
|
||||
} else {
|
||||
fprintf(stderr, "%s: FAILED. Checksum is %s\n", argv[2], md5sum);
|
||||
return -1;
|
||||
}
|
||||
if (!strcasecmp(md5sum, argv[1])) {
|
||||
fprintf(stderr, "%s: OK\n", argv[2]);
|
||||
return 0;
|
||||
} else {
|
||||
fprintf(stderr, "%s: FAILED. Checksum is %s\n", argv[2], md5sum);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
125
md5/md5hl.c
125
md5/md5hl.c
@@ -1,4 +1,5 @@
|
||||
/* mdXhl.c * ----------------------------------------------------------------------------
|
||||
/* mdXhl.c
|
||||
* ----------------------------------------------------------------------------
|
||||
* "THE BEER-WARE LICENSE" (Revision 42):
|
||||
* <phk@FreeBSD.org> wrote this file. As long as you retain this notice you
|
||||
* can do whatever you want with this stuff. If we meet some day, and you think
|
||||
@@ -32,83 +33,79 @@
|
||||
|
||||
#include "./md5.h"
|
||||
|
||||
char *
|
||||
MD5End(MD5_CTX *ctx, char *buf)
|
||||
char *MD5End(MD5_CTX *ctx, char *buf)
|
||||
{
|
||||
int i;
|
||||
unsigned char digest[LENGTH];
|
||||
static const char hex[]="0123456789abcdef";
|
||||
int i;
|
||||
unsigned char digest[LENGTH];
|
||||
static const char hex[] = "0123456789abcdef";
|
||||
|
||||
if (!buf)
|
||||
buf = malloc(2*LENGTH + 1);
|
||||
if (!buf)
|
||||
return 0;
|
||||
MD5Final(digest, ctx);
|
||||
for (i = 0; i < LENGTH; i++) {
|
||||
buf[i+i] = hex[digest[i] >> 4];
|
||||
buf[i+i+1] = hex[digest[i] & 0x0f];
|
||||
}
|
||||
buf[i+i] = '\0';
|
||||
return buf;
|
||||
if (!buf)
|
||||
buf = malloc(2 * LENGTH + 1);
|
||||
if (!buf)
|
||||
return 0;
|
||||
MD5Final(digest, ctx);
|
||||
for (i = 0; i < LENGTH; i++) {
|
||||
buf[i + i] = hex[digest[i] >> 4];
|
||||
buf[i + i + 1] = hex[digest[i] & 0x0f];
|
||||
}
|
||||
buf[i + i] = '\0';
|
||||
return buf;
|
||||
}
|
||||
|
||||
char *
|
||||
MD5File(const char *filename, char *buf)
|
||||
char *MD5File(const char *filename, char *buf)
|
||||
{
|
||||
return (MD5FileChunk(filename, buf, 0, 0));
|
||||
return (MD5FileChunk(filename, buf, 0, 0));
|
||||
}
|
||||
|
||||
char *
|
||||
MD5FileChunk(const char *filename, char *buf, off_t ofs, off_t len)
|
||||
char *MD5FileChunk(const char *filename, char *buf, off_t ofs, off_t len)
|
||||
{
|
||||
unsigned char buffer[BUFSIZ];
|
||||
MD5_CTX ctx;
|
||||
struct stat stbuf;
|
||||
int f, i, e;
|
||||
off_t n;
|
||||
unsigned char buffer[BUFSIZ];
|
||||
MD5_CTX ctx;
|
||||
struct stat stbuf;
|
||||
int f, i, e;
|
||||
off_t n;
|
||||
|
||||
MD5Init(&ctx);
|
||||
MD5Init(&ctx);
|
||||
#if _WIN32
|
||||
f = _open(filename, O_RDONLY|O_BINARY);
|
||||
f = _open(filename, O_RDONLY | O_BINARY);
|
||||
#else
|
||||
f = open(filename, O_RDONLY);
|
||||
f = open(filename, O_RDONLY);
|
||||
#endif
|
||||
if (f < 0)
|
||||
return 0;
|
||||
if (fstat(f, &stbuf) < 0)
|
||||
return 0;
|
||||
if (ofs > stbuf.st_size)
|
||||
ofs = stbuf.st_size;
|
||||
if ((len == 0) || (len > stbuf.st_size - ofs))
|
||||
len = stbuf.st_size - ofs;
|
||||
if (lseek(f, ofs, SEEK_SET) < 0)
|
||||
return 0;
|
||||
n = len;
|
||||
i = 0;
|
||||
while (n > 0) {
|
||||
if (n > sizeof(buffer))
|
||||
i = read(f, buffer, sizeof(buffer));
|
||||
else
|
||||
i = read(f, buffer, n);
|
||||
if (i < 0)
|
||||
break;
|
||||
MD5Update(&ctx, buffer, i);
|
||||
n -= i;
|
||||
}
|
||||
e = errno;
|
||||
close(f);
|
||||
errno = e;
|
||||
if (i < 0)
|
||||
return 0;
|
||||
return (MD5End(&ctx, buf));
|
||||
if (f < 0)
|
||||
return 0;
|
||||
if (fstat(f, &stbuf) < 0)
|
||||
return 0;
|
||||
if (ofs > stbuf.st_size)
|
||||
ofs = stbuf.st_size;
|
||||
if ((len == 0) || (len > stbuf.st_size - ofs))
|
||||
len = stbuf.st_size - ofs;
|
||||
if (lseek(f, ofs, SEEK_SET) < 0)
|
||||
return 0;
|
||||
n = len;
|
||||
i = 0;
|
||||
while (n > 0) {
|
||||
if (n > sizeof(buffer))
|
||||
i = read(f, buffer, sizeof(buffer));
|
||||
else
|
||||
i = read(f, buffer, n);
|
||||
if (i < 0)
|
||||
break;
|
||||
MD5Update(&ctx, buffer, i);
|
||||
n -= i;
|
||||
}
|
||||
e = errno;
|
||||
close(f);
|
||||
errno = e;
|
||||
if (i < 0)
|
||||
return 0;
|
||||
return (MD5End(&ctx, buf));
|
||||
}
|
||||
|
||||
char *
|
||||
MD5Data (const void *data, unsigned int len, char *buf)
|
||||
char *MD5Data(const void *data, unsigned int len, char *buf)
|
||||
{
|
||||
MD5_CTX ctx;
|
||||
MD5_CTX ctx;
|
||||
|
||||
MD5Init(&ctx);
|
||||
MD5Update(&ctx,data,len);
|
||||
return (MD5End(&ctx, buf));
|
||||
MD5Init(&ctx);
|
||||
MD5Update(&ctx, data, len);
|
||||
return (MD5End(&ctx, buf));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user