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. 577
      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;

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

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