/****************************************************************************
* *
* HPACK Multi-System Archiver *
* =========================== *
* *
* MD5 Message Digest Code *
* MD5.C Updated 02/10/91 *
* *
* This program is protected by copyright and as such any use or copying of *
* this code for your own purposes directly or indirectly is highly uncool *
* and if you do so there will be....trubble. *
* And remember: We know where your kids go to school. *
* *
* Copyright 1991 Peter C.Gutmann. All rights reserved *
* *
****************************************************************************/
#include <stdlib.h>
#include <string.h>
#include "md5.h"
/****************************************************************************
* *
* Implementation RSA Data Security, Inc. MD5 Message-Digest Algorithm *
* Created 2/17/90 RLR, revised 1/91 SRD,AJ,BSK,JT Reference C Version *
* Copyright (C) 1990, RSA Data Security, Inc. All rights reserved *
* *
****************************************************************************/
/* Define the following to use the assembly-language version of MDTransform().
This is desirable since MDTransform() uses many rotates which cannot be
easily represented in C and must be done inefficiently via shifts */
#ifdef __MSDOS__
#define ASM_MD5
#endif /* __MSDOS__ */
#ifdef ASM_MD5
void MD5Transform( LONG *buf, LONG *in );
#endif /* ASM_MD5 */
/* To form the message digest for a message M, initialize a context buffer
mdContext using MD5Init(); call MD5Update() on mdContext and M; and call
MD5Final() on mdContext. The message digest is now in
mdContext->digest[ 0 ... 15 ] */
/****************************************************************************
* *
* The MD5 Transformation *
* *
****************************************************************************/
/* The Mysterious Constants used in the MD5 transformation */
static LONG md5const[] = { 3614090360L, 3905402710L, 606105819L, 3250441966L,
4118548399L, 1200080426L, 2821735955L, 4249261313L,
1770035416L, 2336552879L, 4294925233L, 2304563134L,
1804603682L, 4254626195L, 2792965006L, 1236535329L,
4129170786L, 3225465664L, 643717713L, 3921069994L,
3593408605L, 38016083L, 3634488961L, 3889429448L,
568446438L, 3275163606L, 4107603335L, 1163531501L,
2850285829L, 4243563512L, 1735328473L, 2368359562L,
4294588738L, 2272392833L, 1839030562L, 4259657740L,
2763975236L, 1272893353L, 4139469664L, 3200236656L,
681279174L, 3936430074L, 3572445317L, 76029189L,
3654602809L, 3873151461L, 530742520L, 3299628645L,
4096336452L, 1126891415L, 2878612391L, 4237533241L,
1700485571L, 2399980690L, 4293915773L, 2240044497L,
1873313359L, 4264355552L, 2734768916L, 1309151649L,
4149444226L, 3174756917L, 718787259L, 3951481745L };
/* Storage for the Mysterious Constants (either md5const or user-defined) */
LONG mConst[ MD5_ROUNDS ];
#ifndef ASM_MD5
/* F, G, H and I are basic MD5 functions */
#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,shiftAmt,magicConst) \
{ \
A += F( B, C, D ) + X + magicConst; \
A = ROTATE_LEFT( A, shiftAmt ); \
A += B; \
}
#define GG(A,B,C,D,X,shiftAmt,magicConst) \
{ \
A += G( B, C, D ) + X + magicConst; \
A = ROTATE_LEFT( A, shiftAmt ); \
A += B; \
}
#define HH(A,B,C,D,X,shiftAmt,magicConst) \
{ \
A += H( B, C, D ) + X + magicConst; \
A = ROTATE_LEFT( A, shiftAmt ); \
A += B; \
}
#define II(A,B,C,D,X,shiftAmt,magicConst) \
{ \
A += I( B, C, D ) + X + magicConst; \
A = ROTATE_LEFT( A, shiftAmt ); \
A += B; \
}
/* Round 1 shift amounts */
#define S11 7
#define S12 12
#define S13 17
#define S14 22
/* Round 2 shift amounts */
#define S21 5
#define S22 9
#define S23 14
#define S24 20
/* Round 3 shift amounts */
#define S31 4
#define S32 11
#define S33 16
#define S34 23
/* Round 4 shift amounts */
#define S41 6
#define S42 10
#define S43 15
#define S44 21
/* Basic MD5 step. Transforms buf based on in. Note that if the Mysterious
Constants are arranged backwards in little-endian order and decrypted with
the DES they produce OCCULT MESSAGES! */
#if defined( __ARC__ ) || defined( IRIX ) || defined( __TSC__ )
/* MD5Transform is split into its component rounds since many optimizers
choke on the grand unified version */
static void MD5TransformRound1( LONG *A, LONG *B, LONG *C, LONG *D, LONG *in )
{
/* Round 1 */
FF( *A, *B, *C, *D, in[ 0 ], S11, mConst[ 0 ] ); /* 1 */
FF( *D, *A, *B, *C, in[ 1 ], S12, mConst[ 1 ] ); /* 2 */
FF( *C, *D, *A, *B, in[ 2 ], S13, mConst[ 2 ] ); /* 3 */
FF( *B, *C, *D, *A, in[ 3 ], S14, mConst[ 3 ] ); /* 4 */
FF( *A, *B, *C, *D, in[ 4 ], S11, mConst[ 4 ] ); /* 5 */
FF( *D, *A, *B, *C, in[ 5 ], S12, mConst[ 5 ] ); /* 6 */
FF( *C, *D, *A, *B, in[ 6 ], S13, mConst[ 6 ] ); /* 7 */
FF( *B, *C, *D, *A, in[ 7 ], S14, mConst[ 7 ] ); /* 8 */
FF( *A, *B, *C, *D, in[ 8 ], S11, mConst[ 8 ] ); /* 9 */
FF( *D, *A, *B, *C, in[ 9 ], S12, mConst[ 9 ] ); /* 10 */
FF( *C, *D, *A, *B, in[ 10 ], S13, mConst[ 10 ] ); /* 11 */
FF( *B, *C, *D, *A, in[ 11 ], S14, mConst[ 11 ] ); /* 12 */
FF( *A, *B, *C, *D, in[ 12 ], S11, mConst[ 12 ] ); /* 13 */
FF( *D, *A, *B, *C, in[ 13 ], S12, mConst[ 13 ] ); /* 14 */
FF( *C, *D, *A, *B, in[ 14 ], S13, mConst[ 14 ] ); /* 15 */
FF( *B, *C, *D, *A, in[ 15 ], S14, mConst[ 15 ] ); /* 16 */
}
static void MD5TransformRound2( LONG *A, LONG *B, LONG *C, LONG *D, LONG *in )
{
/* Round 2 */
GG( *A, *B, *C, *D, in[ 1 ], S21, mConst[ 16 ] ); /* 17 */
GG( *D, *A, *B, *C, in[ 6 ], S22, mConst[ 17 ] ); /* 18 */
GG( *C, *D, *A, *B, in[ 11 ], S23, mConst[ 18 ] ); /* 19 */
GG( *B, *C, *D, *A, in[ 0 ], S24, mConst[ 19 ] ); /* 20 */
GG( *A, *B, *C, *D, in[ 5 ], S21, mConst[ 20 ] ); /* 21 */
GG( *D, *A, *B, *C, in[ 10 ], S22, mConst[ 21 ] ); /* 22 */
GG( *C, *D, *A, *B, in[ 15 ], S23, mConst[ 22 ] ); /* 23 */
GG( *B, *C, *D, *A, in[ 4 ], S24, mConst[ 23 ] ); /* 24 */
GG( *A, *B, *C, *D, in[ 9 ], S21, mConst[ 24 ] ); /* 25 */
GG( *D, *A, *B, *C, in[ 14 ], S22, mConst[ 25 ] ); /* 26 */
GG( *C, *D, *A, *B, in[ 3 ], S23, mConst[ 26 ] ); /* 27 */
GG( *B, *C, *D, *A, in[ 8 ], S24, mConst[ 27 ] ); /* 28 */
GG( *A, *B, *C, *D, in[ 13 ], S21, mConst[ 28 ] ); /* 29 */
GG( *D, *A, *B, *C, in[ 2 ], S22, mConst[ 29 ] ); /* 30 */
GG( *C, *D, *A, *B, in[ 7 ], S23, mConst[ 30 ] ); /* 31 */
GG( *B, *C, *D, *A, in[ 12 ], S24, mConst[ 31 ] ); /* 32 */
}
static void MD5TransformRound3( LONG *A, LONG *B, LONG *C, LONG *D, LONG *in )
{
/* Round 3 */
HH( *A, *B, *C, *D, in[ 5 ], S31, mConst[ 32 ] ); /* 33 */
HH( *D, *A, *B, *C, in[ 8 ], S32, mConst[ 33 ] ); /* 34 */
HH( *C, *D, *A, *B, in[ 11 ], S33, mConst[ 34 ] ); /* 35 */
HH( *B, *C, *D, *A, in[ 14 ], S34, mConst[ 35 ] ); /* 36 */
HH( *A, *B, *C, *D, in[ 1 ], S31, mConst[ 36 ] ); /* 37 */
HH( *D, *A, *B, *C, in[ 4 ], S32, mConst[ 37 ] ); /* 38 */
HH( *C, *D, *A, *B, in[ 7 ], S33, mConst[ 38 ] ); /* 39 */
HH( *B, *C, *D, *A, in[ 10 ], S34, mConst[ 39 ] ); /* 40 */
HH( *A, *B, *C, *D, in[ 13 ], S31, mConst[ 40 ] ); /* 41 */
HH( *D, *A, *B, *C, in[ 0 ], S32, mConst[ 41 ] ); /* 42
评论0