md4.c File Reference

#include "md4.h"
#include "util.h"

Include dependency graph for md4.c:

Go to the source code of this file.

Macros
#define	rotl32(x, n)   (((x) << ((unsigned int)(n))) | ((x) >> (32 - (unsigned int)(n))))
#define	F(x, y, z)   (((x) & (y)) | ((~x) & (z)))
#define	G(x, y, z)   (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define	H(x, y, z)   ((x) ^ (y) ^ (z))
#define	FF(a, b, c, d, x, s)
#define	GG(a, b, c, d, x, s)
#define	HH(a, b, c, d, x, s)

Functions
static void	MD4Transform (unsigned int buf[4], unsigned int const in[16])
VOID NTAPI	MD4Init (MD4_CTX *ctx)
VOID NTAPI	MD4Update (MD4_CTX *ctx, const unsigned char *buf, unsigned int len)
VOID NTAPI	MD4Final (MD4_CTX *ctx)

Macro Definition Documentation

F

#define F	(		x,
			y,
			z
	)		(((x) & (y)) | ((~x) & (z)))

Definition at line 162 of file md4.c.

FF

#define FF	(		a,
			b,
			c,
			d,
			x,
			s
	)

Value:

    { \
    (a) += F( (b), (c), (d) ) + (x); \
    (a) = rotl32( (a), (s) ); \
  }

Definition at line 166 of file md4.c.

G

#define G	(		x,
			y,
			z
	)		(((x) & (y)) | ((x) & (z)) | ((y) & (z)))

Definition at line 163 of file md4.c.

GG

#define GG	(		a,
			b,
			c,
			d,
			x,
			s
	)

Value:

    { \
    (a) += G( (b), (c), (d) ) + (x) + (unsigned int)0x5a827999; \
    (a) = rotl32( (a), (s) ); \
  }

Definition at line 170 of file md4.c.

H

#define H	(		x,
			y,
			z
	)		((x) ^ (y) ^ (z))

Definition at line 164 of file md4.c.

HH

#define HH	(		a,
			b,
			c,
			d,
			x,
			s
	)

Value:

    { \
    (a) += H( (b), (c), (d) ) + (x) + (unsigned int)0x6ed9eba1; \
    (a) = rotl32( (a), (s) ); \
  }

Definition at line 174 of file md4.c.

rotl32

#define rotl32	(		x,
			n
	)		(((x) << ((unsigned int)(n))) | ((x) >> (32 - (unsigned int)(n))))

Definition at line 160 of file md4.c.

Function Documentation

MD4Final()

VOID NTAPI MD4Final

(

MD4_CTX *

ctx

)

Definition at line 113 of file md4.c.

{
    unsigned int count;
    unsigned char *p;
 
    /* Compute number of bytes mod 64 */
    count = (ctx->i[0] >> 3) & 0x3F;
 
    /* Set the first char of padding to 0x80.  This is safe since there is
       always at least one byte free */
    p = ctx->in + count;
    *p++ = 0x80;
 
    /* Bytes of padding needed to make 64 bytes */
    count = 64 - 1 - count;
 
    /* Pad out to 56 mod 64 */
    if (count < 8)
    {
        /* Two lots of padding:  Pad the first block to 64 bytes */
        memset( p, 0, count );
        byteReverse( ctx->in, 16 );
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        /* Now fill the next block with 56 bytes */
        memset( ctx->in, 0, 56 );
    }
    else
    {
        /* Pad block to 56 bytes */
        memset( p, 0, count - 8 );
    }
 
    byteReverse( ctx->in, 14 );
 
    /* Append length in bits and transform */
    ((unsigned int *)ctx->in)[14] = ctx->i[0];
    ((unsigned int *)ctx->in)[15] = ctx->i[1];
 
    MD4Transform( ctx->buf, (unsigned int *)ctx->in );
    byteReverse( (unsigned char *)ctx->buf, 4 );
    memcpy( ctx->digest, ctx->buf, 16 );
    memset(ctx->in, 0, sizeof(ctx->in));
}

Referenced by finalize_hash_impl(), KsecGatherEntropyData(), SECUR32_CreateNTLM1SessionKey(), SystemFunction007(), and SystemFunction010().

MD4Init()

VOID NTAPI MD4Init

(

MD4_CTX *

ctx

)

Definition at line 45 of file md4.c.

{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;
 
    ctx->i[0] = ctx->i[1] = 0;
}

Referenced by init_hash_impl(), KsecGatherEntropyData(), SECUR32_CreateNTLM1SessionKey(), SystemFunction007(), and SystemFunction010().

MD4Transform()

static void MD4Transform ( unsigned int  buf[4], unsigned int const  in[16]  )

static

Definition at line 182 of file md4.c.

{
    register unsigned int a, b, c, d;
 
    a = buf[0];
    b = buf[1];
    c = buf[2];
    d = buf[3];
 
    FF( a, b, c, d, in[0], 3 );
    FF( d, a, b, c, in[1], 7 );
    FF( c, d, a, b, in[2], 11 );
    FF( b, c, d, a, in[3], 19 );
    FF( a, b, c, d, in[4], 3 );
    FF( d, a, b, c, in[5], 7 );
    FF( c, d, a, b, in[6], 11 );
    FF( b, c, d, a, in[7], 19 );
    FF( a, b, c, d, in[8], 3 );
    FF( d, a, b, c, in[9], 7 );
    FF( c, d, a, b, in[10], 11 );
    FF( b, c, d, a, in[11], 19 );
    FF( a, b, c, d, in[12], 3 );
    FF( d, a, b, c, in[13], 7 );
    FF( c, d, a, b, in[14], 11 );
    FF( b, c, d, a, in[15], 19 );
 
    GG( a, b, c, d, in[0], 3 );
    GG( d, a, b, c, in[4], 5 );
    GG( c, d, a, b, in[8], 9 );
    GG( b, c, d, a, in[12], 13 );
    GG( a, b, c, d, in[1], 3 );
    GG( d, a, b, c, in[5], 5 );
    GG( c, d, a, b, in[9], 9 );
    GG( b, c, d, a, in[13], 13 );
    GG( a, b, c, d, in[2], 3 );
    GG( d, a, b, c, in[6], 5 );
    GG( c, d, a, b, in[10], 9 );
    GG( b, c, d, a, in[14], 13 );
    GG( a, b, c, d, in[3], 3 );
    GG( d, a, b, c, in[7], 5 );
    GG( c, d, a, b, in[11], 9 );
    GG( b, c, d, a, in[15], 13 );
 
    HH( a, b, c, d, in[0], 3 );
    HH( d, a, b, c, in[8], 9 );
    HH( c, d, a, b, in[4], 11 );
    HH( b, c, d, a, in[12], 15 );
    HH( a, b, c, d, in[2], 3 );
    HH( d, a, b, c, in[10], 9 );
    HH( c, d, a, b, in[6], 11 );
    HH( b, c, d, a, in[14], 15 );
    HH( a, b, c, d, in[1], 3 );
    HH( d, a, b, c, in[9], 9 );
    HH( c, d, a, b, in[5], 11 );
    HH( b, c, d, a, in[13], 15 );
    HH( a, b, c, d, in[3], 3 );
    HH( d, a, b, c, in[11], 9 );
    HH( c, d, a, b, in[7], 11 );
    HH( b, c, d, a, in[15], 15 );
 
    buf[0] += a;
    buf[1] += b;
    buf[2] += c;
    buf[3] += d;
}

Referenced by MD4Final(), and MD4Update().

MD4Update()

VOID NTAPI MD4Update	(	MD4_CTX *	ctx,
		const unsigned char *	buf,
		unsigned int	len
	)

Definition at line 59 of file md4.c.

{
    register unsigned int t;
 
    /* Update bitcount */
    t = ctx->i[0];
 
    if ((ctx->i[0] = t + (len << 3)) < t)
        ctx->i[1]++;        /* Carry from low to high */
 
    ctx->i[1] += len >> 29;
    t = (t >> 3) & 0x3f;
 
    /* Handle any leading odd-sized chunks */
    if (t)
    {
        unsigned char *p = (unsigned char *)ctx->in + t;
        t = 64 - t;
 
        if (len < t)
        {
            memcpy( p, buf, len );
            return;
        }
 
        memcpy( p, buf, t );
        byteReverse( ctx->in, 16 );
 
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += t;
        len -= t;
    }
 
    /* Process data in 64-byte chunks */
    while (len >= 64)
    {
        memcpy( ctx->in, buf, 64 );
        byteReverse( ctx->in, 16 );
 
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += 64;
        len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
    memcpy( ctx->in, buf, len );
}

Referenced by KsecGatherEntropyData(), SECUR32_CreateNTLM1SessionKey(), SystemFunction007(), SystemFunction010(), and update_hash_impl().