hmac_md5.h File Reference

#include <string.h>
#include <windef.h>

Include dependency graph for hmac_md5.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MD5_CTX
struct	HMAC_MD5_CTX

Functions
void WINAPI	MD5Init (MD5_CTX *ctx)
void WINAPI	MD5Update (MD5_CTX *ctx, const unsigned char *buf, unsigned int len)
void WINAPI	MD5Final (MD5_CTX *ctx)
void	HMACMD5Init (HMAC_MD5_CTX *ctx, const unsigned char *key, unsigned int key_len) DECLSPEC_HIDDEN
void	HMACMD5Update (HMAC_MD5_CTX *ctx, const unsigned char *data, unsigned int data_len) DECLSPEC_HIDDEN
void	HMACMD5Final (HMAC_MD5_CTX *ctx, unsigned char *digest) DECLSPEC_HIDDEN

Function Documentation

HMACMD5Final()

void HMACMD5Final	(	HMAC_MD5_CTX *	ctx,
		unsigned char *	digest
	)

Definition at line 63 of file hmac_md5.c.

{
    MD5_CTX outer_ctx;
    unsigned char inner_digest[16];
 
    MD5Final(&(ctx->ctx));
    memcpy(inner_digest, ctx->ctx.digest, 16);
 
    MD5Init(&outer_ctx);
    MD5Update(&outer_ctx, ctx->outer_padding, 64);
    MD5Update(&outer_ctx, inner_digest, 16);
    MD5Final(&outer_ctx);
 
    memcpy(digest, outer_ctx.digest, 16);
}

Referenced by ntlm_CreateSignature().

HMACMD5Init()

void HMACMD5Init	(	HMAC_MD5_CTX *	ctx,
		const unsigned char *	key,
		unsigned int	key_len
	)

Definition at line 24 of file hmac_md5.c.

{
    int i;
    unsigned char inner_padding[64];
    unsigned char temp_key[16];
 
    if(key_len > 64)
    {
        MD5_CTX temp_ctx;
 
        MD5Init(&temp_ctx);
        MD5Update(&temp_ctx, key, key_len);
        MD5Final(&temp_ctx);
        memcpy(temp_key, temp_ctx.digest, 16);
 
        key = temp_key;
        key_len = 16;
    }
 
    memset(inner_padding, 0, 64);
    memset(ctx->outer_padding, 0, 64);
    memcpy(inner_padding, key, key_len);
    memcpy(ctx->outer_padding, key, key_len);
 
    for(i = 0; i < 64; ++i)
    {
        inner_padding[i] ^= 0x36;
        ctx->outer_padding[i] ^= 0x5c;
    }
 
    MD5Init(&(ctx->ctx));
    MD5Update(&(ctx->ctx), inner_padding, 64);
}

Referenced by ntlm_CreateSignature().

HMACMD5Update()

void HMACMD5Update	(	HMAC_MD5_CTX *	ctx,
		const unsigned char *	data,
		unsigned int	data_len
	)

Definition at line 58 of file hmac_md5.c.

{
    MD5Update(&(ctx->ctx), data, data_len);
}

Referenced by ntlm_CreateSignature().

MD5Final()

void WINAPI MD5Final

(

MD5_CTX *

ctx

)

Definition at line 113 of file md5.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 );
        MD5Transform( 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];
 
    MD5Transform( 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));
}

MD5Init()

void WINAPI MD5Init

(

MD5_CTX *

ctx

)

Definition at line 45 of file md5.c.

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

MD5Update()

void WINAPI MD5Update	(	MD5_CTX *	ctx,
		const unsigned char *	buf,
		unsigned int	len
	)

Definition at line 59 of file md5.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 );
 
        MD5Transform( 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 );
 
        MD5Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += 64;
        len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
    memcpy( ctx->in, buf, len );
}