ad_user
/
f2b
2
2
Fork 0
Code Issues Pull Requests Releases Activity
Browse Source

* replace md5 implementation with public-domain licensed

master
Alex 'AdUser' Z 4 years ago
parent
2ab12c4fd5
commit
8e0d93aa71
3 changed files with 324 additions and 341 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 11
      src/csocket.c
  2. 517
      src/md5.c
  3. 77
      src/md5.h

11
src/csocket.c
Unescape View File

@ -77,12 +77,11 @@ void
f2b_conn_update_challenge(f2b_conn_t *conn) { f2b_conn_update_challenge(f2b_conn_t *conn) {
char buf[64] = ""; char buf[64] = "";
MD5_CTX md5; MD5_CTX md5;
memset(&md5, 0x0, sizeof(md5));
snprintf(buf, sizeof(buf), "%08lx+%ld", random(), time(NULL)); snprintf(buf, sizeof(buf), "%08lx+%ld", random(), time(NULL));
MD5Init(&md5); MD5Init(&md5);
MD5Update(&md5, buf, strlen(buf)); MD5Update(&md5, (unsigned char *) buf, strlen(buf));
MD5Final(&md5); MD5Final(&md5);
strlcpy(conn->challenge, md5.string, sizeof(conn->challenge)); strlcpy(conn->challenge, md5.hexdigest, sizeof(conn->challenge));
} }
void void
@ -113,10 +112,10 @@ f2b_conn_check_auth(f2b_conn_t *conn, f2b_cmd_t *cmd) {
f2b_log_msg(log_error, "csocket auth failure from %s: password mismatch", conn->peer); f2b_log_msg(log_error, "csocket auth failure from %s: password mismatch", conn->peer);
} else if (strcmp(cmd->args[1], "challenge") == 0) { } else if (strcmp(cmd->args[1], "challenge") == 0) {
MD5Init(&md5); MD5Init(&md5);
MD5Update(&md5, conn->challenge, strlen(conn->challenge)); MD5Update(&md5, (unsigned char *) conn->challenge, strlen(conn->challenge));
MD5Update(&md5, conn->password, strlen(conn->password)); MD5Update(&md5, (unsigned char *) conn->password, strlen(conn->password));
MD5Final(&md5); MD5Final(&md5);
if (strcmp(cmd->args[2], md5.string) == 0) { if (strcmp(cmd->args[2], md5.hexdigest) == 0) {
conn->flags |= CSOCKET_CONN_AUTH_OK; conn->flags |= CSOCKET_CONN_AUTH_OK;
f2b_buf_append(&conn->send, "+ok\n", 0); f2b_buf_append(&conn->send, "+ok\n", 0);
return true; return true;

517
src/md5.c
Unescape View File

@ -1,282 +1,295 @@
/* /*
********************************************************************** * This code implements the MD5 message-digest algorithm.
** md5.c ** * The algorithm is due to Ron Rivest. This code was
** RSA Data Security, Inc. MD5 Message Digest Algorithm ** * written by Colin Plumb in 1993, no copyright is claimed.
** Created: 2/17/90 RLR ** * This code is in the public domain; do with it what you wish.
** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version ** *
********************************************************************** * 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.
*/ */
/* /* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
********************************************************************** not require an integer type which is exactly 32 bits. This work
** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. ** draws on the changes for the same purpose by Tatu Ylonen
** ** <ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
** License to copy and use this software is granted provided that ** that code, there is no copyright issue. I hereby disclaim
** it is identified as the "RSA Data Security, Inc. MD5 Message ** copyright in any changes I have made; this code remains in the
** Digest Algorithm" in all material mentioning or referencing this ** public domain. */
** 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. **
**********************************************************************
*/
/* -- include the following line if the md5.h header file is separate -- */
#include "md5.h"
#include <stdio.h> /* sprintf */ #include <stdio.h> /* sprintf */
#include <string.h> /* for memcpy() */
/* forward declaration */ /* Add prototype support. */
static void Transform (); #ifndef PROTO
#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
static unsigned char PADDING[64] = { #define PROTO(ARGS) ARGS
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, #else
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, #define PROTO(ARGS) ()
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, #endif
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, #endif
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* F, G and H are basic MD5 functions: selection, majority, parity */
#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 */
#define FF(a, b, c, d, x, s, ac) \
{(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) \
{(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) \
{(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) \
{(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
void MD5Init (mdContext) #include "md5.h"
MD5_CTX *mdContext;
/* Little-endian byte-swapping routines. Note that these do not
depend on the size of datatypes such as uint32, nor do they require
us to detect the endianness of the machine we are running on. It
is possible they should be macros for speed, but I would be
surprised if they were a performance bottleneck for MD5. */
static uint32
getu32 (addr)
const unsigned char *addr;
{ {
mdContext->i[0] = mdContext->i[1] = (UINT4)0; return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
| addr[1]) << 8 | addr[0];
}
static void
putu32 (data, addr)
uint32 data;
unsigned char *addr;
{
addr[0] = (unsigned char)data;
addr[1] = (unsigned char)(data >> 8);
addr[2] = (unsigned char)(data >> 16);
addr[3] = (unsigned char)(data >> 24);
}
/* Load magic initialization constants. /*
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* initialization constants.
*/ */
mdContext->buf[0] = (UINT4)0x67452301; void
mdContext->buf[1] = (UINT4)0xefcdab89; MD5Init(ctx)
mdContext->buf[2] = (UINT4)0x98badcfe; struct MD5Context *ctx;
mdContext->buf[3] = (UINT4)0x10325476; {
memset(ctx, 0, sizeof(struct MD5Context)); /* In case it's sensitive */
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
ctx->bits[0] = 0;
ctx->bits[1] = 0;
} }
void MD5Update (mdContext, inBuf, inLen) /*
MD5_CTX *mdContext; * Update context to reflect the concatenation of another buffer full
unsigned char *inBuf; * of bytes.
unsigned int inLen; */
void
MD5Update(ctx, buf, len)
struct MD5Context *ctx;
unsigned char const *buf;
unsigned len;
{ {
UINT4 in[16]; uint32 t;
int mdi;
unsigned int i, ii; /* Update bitcount */
/* compute number of bytes mod 64 */ t = ctx->bits[0];
mdi = (int)((mdContext->i[0] >> 3) & 0x3F); if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t)
ctx->bits[1]++; /* Carry from low to high */
/* update number of bits */ ctx->bits[1] += len >> 29;
if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
mdContext->i[1]++; t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
mdContext->i[0] += ((UINT4)inLen << 3);
mdContext->i[1] += ((UINT4)inLen >> 29); /* Handle any leading odd-sized chunks */
while (inLen--) { if ( t ) {
/* add new character to buffer, increment mdi */ unsigned char *p = ctx->in + t;
mdContext->in[mdi++] = *inBuf++;
t = 64-t;
/* transform if necessary */ if (len < t) {
if (mdi == 0x40) { memcpy(p, buf, len);
for (i = 0, ii = 0; i < 16; i++, ii += 4) return;
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | }
(((UINT4)mdContext->in[ii+2]) << 16) | memcpy(p, buf, t);
(((UINT4)mdContext->in[ii+1]) << 8) | MD5Transform(ctx->buf, ctx->in);
((UINT4)mdContext->in[ii]); buf += t;
Transform (mdContext->buf, in); len -= t;
mdi = 0;
} }
/* Process data in 64-byte chunks */
while (len >= 64) {
memcpy(ctx->in, buf, 64);
MD5Transform(ctx->buf, ctx->in);
buf += 64;
len -= 64;
} }
/* Handle any remaining bytes of data. */
memcpy(ctx->in, buf, len);
} }
void MD5Final (mdContext) /*
MD5_CTX *mdContext; * Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
void
MD5Final(ctx)
struct MD5Context *ctx;
{ {
UINT4 in[16]; unsigned count;
int mdi; unsigned char *p;
unsigned int i, ii;
unsigned int padLen; /* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
/* save number of bits */
in[14] = mdContext->i[0]; /* Set the first char of padding to 0x80. This is safe since there is
in[15] = mdContext->i[1]; always at least one byte free */
p = ctx->in + count;
/* compute number of bytes mod 64 */ *p++ = 0x80;
mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
/* Bytes of padding needed to make 64 bytes */
/* pad out to 56 mod 64 */ count = 64 - 1 - count;
padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
MD5Update (mdContext, PADDING, padLen); /* Pad out to 56 mod 64 */
if (count < 8) {
/* append length in bits and transform */ /* Two lots of padding: Pad the first block to 64 bytes */
for (i = 0, ii = 0; i < 14; i++, ii += 4) memset(p, 0, count);
in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | MD5Transform(ctx->buf, ctx->in);
(((UINT4)mdContext->in[ii+2]) << 16) |
(((UINT4)mdContext->in[ii+1]) << 8) | /* Now fill the next block with 56 bytes */
((UINT4)mdContext->in[ii]); memset(ctx->in, 0, 56);
Transform (mdContext->buf, in); } else {
/* Pad block to 56 bytes */
/* store buffer in digest */ memset(p, 0, count-8);
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF);
mdContext->digest[ii+1] =
(unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
mdContext->digest[ii+2] =
(unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
mdContext->digest[ii+3] =
(unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
} }
/* added: generate hex-string */ /* Append length in bits and transform */
for (i = 0; i < 16; i++) putu32(ctx->bits[0], ctx->in + 56);
sprintf(&mdContext->string[i * 2], "%02x", mdContext->digest[i]); putu32(ctx->bits[1], ctx->in + 60);
mdContext->string[32] = '\0';
MD5Transform(ctx->buf, ctx->in);
/* calculate digest */
putu32(ctx->buf[0], ctx->digest);
putu32(ctx->buf[1], ctx->digest + 4);
putu32(ctx->buf[2], ctx->digest + 8);
putu32(ctx->buf[3], ctx->digest + 12);
/* calculate hexdigest */
for (short int i = 0; i < 16; i++) {
sprintf(&ctx->hexdigest[i * 2], "%02x", ctx->digest[i]);
}
} }
/* Basic MD5 step. Transform buf based on in. #ifndef ASM_MD5
/* 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 &= 0xffffffff, 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.
*/ */
static void Transform (buf, in) void
UINT4 *buf; MD5Transform(buf, inraw)
UINT4 *in; uint32 buf[4];
const unsigned char inraw[64];
{ {
UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3]; register uint32 a, b, c, d;
uint32 in[16];
/* Round 1 */ int i;
#define S11 7
#define S12 12 for (i = 0; i < 16; ++i)
#define S13 17 in[i] = getu32 (inraw + 4 * i);
#define S14 22
FF ( a, b, c, d, in[ 0], S11, 3614090360); /* 1 */ a = buf[0];
FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */ b = buf[1];
FF ( c, d, a, b, in[ 2], S13, 606105819); /* 3 */ c = buf[2];
FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */ d = buf[3];
FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */
FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */ MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);
FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */ MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */ MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */ MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */ MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);
FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */ MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */ MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */ MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */ MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);
FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */ MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */ MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
/* Round 2 */ MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);
#define S21 5 MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
#define S22 9 MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
#define S23 14 MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
#define S24 20
GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */ MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);
GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */ MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);
GG ( c, d, a, b, in[11], S23, 643717713); /* 19 */ MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */ MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */ MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);
GG ( d, a, b, c, in[10], S22, 38016083); /* 22 */ MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);
GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */ MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */ MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
GG ( a, b, c, d, in[ 9], S21, 568446438); /* 25 */ MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);
GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */ MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);
GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */ MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */ MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */ MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);
GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */ MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);
GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */ MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */ MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
/* Round 3 */ MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);
#define S31 4 MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
#define S32 11 MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
#define S33 16 MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
#define S34 23 MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);
HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */ MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */ MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */ MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */ MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);
HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */ MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */ MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */ MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */ MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);
HH ( a, b, c, d, in[13], S31, 681279174); /* 41 */ MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */ MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */ MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
HH ( b, c, d, a, in[ 6], S34, 76029189); /* 44 */
HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */ MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);
HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */ MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
HH ( c, d, a, b, in[15], S33, 530742520); /* 47 */ MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */ MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);
/* Round 4 */ MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
#define S41 6 MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
#define S42 10 MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
#define S43 15 MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);
#define S44 21 MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */ MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */ MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */ MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);
II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */ MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */ MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */ MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */
II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */
II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */
II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */
II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */
II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */
II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */
II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */
II ( c, d, a, b, in[ 2], S43, 718787259); /* 63 */
II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */
buf[0] += a; buf[0] += a;
buf[1] += b; buf[1] += b;
buf[2] += c; buf[2] += c;
buf[3] += d; buf[3] += d;
} }
#endif
/*
**********************************************************************
** End of md5.c **
******************************* (cut) ********************************
*/

77
src/md5.h
Unescape View File

@ -1,60 +1,31 @@
/* /* See md5.c for explanation and copyright information. */
**********************************************************************
** md5.h -- Header file for implementation of MD5 **
** RSA Data Security, Inc. MD5 Message Digest Algorithm **
** Created: 2/17/90 RLR **
** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version **
** Revised (for MD5): RLR 4/27/91 **
** -- G modified to have y&~z instead of y&z **
** -- FF, GG, HH modified to add in last register done **
** -- Access pattern: round 2 works mod 5, round 3 works mod 3 **
** -- distinct additive constant for each step **
** -- round 4 added, working mod 7 **
**********************************************************************
*/
/* #ifndef MD5_H
********************************************************************** #define MD5_H
** Copyright (C) 1990, RSA Data Security, Inc. 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. **
**********************************************************************
*/
/* typedef a 32 bit type */ /* Unlike previous versions of this code, uint32 need not be exactly
typedef unsigned long int UINT4; 32 bits, merely 32 bits or more. Choosing a data type which is 32
bits instead of 64 is not important; speed is considerably more
important. ANSI guarantees that "unsigned long" will be big enough,
and always using it seems to have few disadvantages. */
typedef unsigned long uint32;
/* Data structure for MD5 (Message Digest) computation */ struct MD5Context {
typedef struct { uint32 buf[4];
UINT4 i[2]; /* number of _bits_ handled mod 2^64 */ uint32 bits[2];
UINT4 buf[4]; /* scratch buffer */ unsigned char in[64];
unsigned char in[64]; /* input buffer */ unsigned char digest[16]; /*< added for usability */
unsigned char digest[16]; /* actual digest after MD5Final call */ char hexdigest[33]; /*< added for usability */
char string[34]; /* same as above but in hex-form */ };
} MD5_CTX;
void MD5Init (); void MD5Init (struct MD5Context *context); /* modified: zortes context before use */
void MD5Update (); void MD5Update (struct MD5Context *context, unsigned char const *buf, unsigned len);
void MD5Final (); void MD5Final (struct MD5Context *context); /* modified: dropped outparam 'digest', fills 'digest' and 'hexdigest' fields in context */
void MD5Transform (uint32 buf[4], const unsigned char in[64]);
/* /*
********************************************************************** * This is needed to make RSAREF happy on some MS-DOS compilers.
** End of md5.h **
******************************* (cut) ********************************
*/ */
typedef struct MD5Context MD5_CTX;
#endif /* !MD5_H */

Write Preview
Loading…
Cancel
Save