md5.c File Reference

#include "precomp.h"
#include "hash_pattern.c"

Include dependency graph for md5.c:

Go to the source code of this file.

Macros
#define	ALG   MD5
#define	Alg   Md5
#define	F(x, y, z)   ((((z) ^ (y)) & (x)) ^ (z))
#define	G(x, y, z)   F( (z), (x), (y) )
#define	H(x, y, z)   ((x) ^ (y) ^ (z) )
#define	I(x, y, z)   ((y) ^ ((x) | ~(z)))
#define	CROUND(r, Func)
#define	IROUND(r, Func)
#define	FROUND(r, Func)

Functions
VOID SYMCRYPT_CALL	SymCryptMd5Init (_Out_ PSYMCRYPT_MD5_STATE pState)
VOID SYMCRYPT_CALL	SymCryptMd5Append (_Inout_ PSYMCRYPT_MD5_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
VOID SYMCRYPT_CALL	SymCryptMd5Result (_Inout_ PSYMCRYPT_MD5_STATE pState, _Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE pbResult)
VOID SYMCRYPT_CALL	SymCryptMd5AppendBlocks (_Inout_ SYMCRYPT_MD5_CHAINING_STATE *pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T *pcbRemaining)
VOID SYMCRYPT_CALL	SymCryptMd5StateExport (_In_ PCSYMCRYPT_MD5_STATE pState, _Out_writes_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PBYTE pbBlob)
SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptMd5StateImport (_Out_ PSYMCRYPT_MD5_STATE pState, _In_reads_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PCBYTE pbBlob)
VOID SYMCRYPT_CALL	SymCryptMd5Selftest (void)

Variables
const SYMCRYPT_HASH	SymCryptMd5Algorithm_default
const PCSYMCRYPT_HASH	SymCryptMd5Algorithm = &SymCryptMd5Algorithm_default
static const UINT32	md5Const [64]
static const int	md5Rotate [64]
static const int	md5MsgIndex [64]
static const UINT32	md5InitialState [4]
static const BYTE	md5KATAnswer [16]

Macro Definition Documentation

ALG

#define ALG   MD5

Definition at line 168 of file md5.c.

Alg

#define Alg   Md5

Definition at line 169 of file md5.c.

CROUND

#define CROUND	(		r,
			Func
	)

Value:

    { \
    ad[r%4] = ad[(r+3)%4] + ROL32( ad[r%4] + Func(ad[(r+3)%4], ad[(r+2)%4], ad[(r+1)%4]) + Wt + md5Const[r], md5Rotate[r] ); \
}

Definition at line 274 of file md5.c.

F

#define F	(		x,
			y,
			z
	)		((((z) ^ (y)) & (x)) ^ (z))

Definition at line 243 of file md5.c.

FROUND

#define FROUND	(		r,
			Func
	)

Value:

    { \
    Wt = W[md5MsgIndex[r]];\
    CROUND( r, Func ); \
}

Definition at line 288 of file md5.c.

G

#define G	(		x,
			y,
			z
	)		F( (z), (x), (y) )

Definition at line 244 of file md5.c.

H

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

Definition at line 245 of file md5.c.

I

#define I	(		x,
			y,
			z
	)		((y) ^ ((x) | ~(z)))

Definition at line 246 of file md5.c.

IROUND

#define IROUND	(		r,
			Func
	)

Value:

    { \
    Wt = SYMCRYPT_LOAD_LSBFIRST32( &pbData[ 4*md5MsgIndex[r] ] ); \
    W[r] = Wt; \
    CROUND( r, Func ); \
}

Definition at line 278 of file md5.c.

Function Documentation

SymCryptMd5Append()

VOID SYMCRYPT_CALL SymCryptMd5Append	(	_Inout_ PSYMCRYPT_MD5_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 204 of file md5.c.

{
    SymCryptHashAppendInternal( SymCryptMd5Algorithm, (PSYMCRYPT_COMMON_HASH_STATE)pState, pbData, cbData );
}

SymCryptMd5AppendBlocks()

VOID SYMCRYPT_CALL SymCryptMd5AppendBlocks	(	_Inout_ SYMCRYPT_MD5_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Definition at line 295 of file md5.c.

{
 
    UINT32 W[16];
    UINT32 ad[4];
    UINT32 Wt;
 
    ad[0] = pChain->H[0];
    ad[1] = pChain->H[3];
    ad[2] = pChain->H[2];
    ad[3] = pChain->H[1];
 
    while( cbData >= 64 )
    {
        //
        // initial rounds 1 to 16
        //
 
        IROUND(  0, F );
        IROUND(  1, F );
        IROUND(  2, F );
        IROUND(  3, F );
        IROUND(  4, F );
        IROUND(  5, F );
        IROUND(  6, F );
        IROUND(  7, F );
        IROUND(  8, F );
        IROUND(  9, F );
        IROUND( 10, F );
        IROUND( 11, F );
        IROUND( 12, F );
        IROUND( 13, F );
        IROUND( 14, F );
        IROUND( 15, F );
 
        FROUND( 16, G );
        FROUND( 17, G );
        FROUND( 18, G );
        FROUND( 19, G );
        FROUND( 20, G );
        FROUND( 21, G );
        FROUND( 22, G );
        FROUND( 23, G );
        FROUND( 24, G );
        FROUND( 25, G );
        FROUND( 26, G );
        FROUND( 27, G );
        FROUND( 28, G );
        FROUND( 29, G );
        FROUND( 30, G );
        FROUND( 31, G );
 
        FROUND( 32, H );
        FROUND( 33, H );
        FROUND( 34, H );
        FROUND( 35, H );
        FROUND( 36, H );
        FROUND( 37, H );
        FROUND( 38, H );
        FROUND( 39, H );
        FROUND( 40, H );
        FROUND( 41, H );
        FROUND( 42, H );
        FROUND( 43, H );
        FROUND( 44, H );
        FROUND( 45, H );
        FROUND( 46, H );
        FROUND( 47, H );
 
        FROUND( 48, I );
        FROUND( 49, I );
        FROUND( 50, I );
        FROUND( 51, I );
        FROUND( 52, I );
        FROUND( 53, I );
        FROUND( 54, I );
        FROUND( 55, I );
        FROUND( 56, I );
        FROUND( 57, I );
        FROUND( 58, I );
        FROUND( 59, I );
        FROUND( 60, I );
        FROUND( 61, I );
        FROUND( 62, I );
        FROUND( 63, I );
 
        pChain->H[0] = ad[0] = ad[0] + pChain->H[0];
        pChain->H[3] = ad[1] = ad[1] + pChain->H[3];
        pChain->H[2] = ad[2] = ad[2] + pChain->H[2];
        pChain->H[1] = ad[3] = ad[3] + pChain->H[1];
 
        pbData += 64;
        cbData -= 64;
    }
 
    *pcbRemaining = cbData;
 
    //
    // Wipe the variables;
    //
    SymCryptWipeKnownSize( ad, sizeof( ad ) );
    SymCryptWipeKnownSize( W, sizeof( W ) );
    SymCryptWipeKnownSize( &Wt, sizeof( Wt ) );
}

SymCryptMd5Init()

VOID SYMCRYPT_CALL SymCryptMd5Init

(

_Out_ PSYMCRYPT_MD5_STATE

pState

)

Definition at line 182 of file md5.c.

{
    SYMCRYPT_SET_MAGIC( pState );
 
    pState->dataLengthL = 0;
    pState->dataLengthH = 0;
    pState->bytesInBuffer = 0;
 
    memcpy( &pState->chain.H[0], &md5InitialState[0], sizeof( md5InitialState ) );
 
    //
    // There is no need to initialize the buffer part of the state as that will be
    // filled before it is used.
    //
}

Referenced by SymCryptMd5Result().

SymCryptMd5Result()

VOID SYMCRYPT_CALL SymCryptMd5Result	(	_Inout_ PSYMCRYPT_MD5_STATE	pState,
		_Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE	pbResult
	)

Definition at line 217 of file md5.c.

{
    SymCryptHashCommonPaddingMd4Style( SymCryptMd5Algorithm, (PSYMCRYPT_COMMON_HASH_STATE) pState );
 
    //
    // Write the output in the correct byte order
    //
    SymCryptUint32ToLsbFirst( &pState->chain.H[0], pbResult, 4 );
 
    //
    // Wipe & re-initialize
    // We have to wipe the whole state because the Init call
    // might be optimized away by a smart compiler.
    // And we need to wipe old data.
    //
    SymCryptWipeKnownSize( pState, sizeof( *pState ) );
    SymCryptMd5Init( pState );
}

SymCryptMd5Selftest()

VOID SYMCRYPT_CALL SymCryptMd5Selftest

(

void

)

Definition at line 492 of file md5.c.

{
    BYTE result[SYMCRYPT_MD5_RESULT_SIZE];
 
    SymCryptMd5( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
 
    SymCryptInjectError( result, sizeof( result ) );
 
    if( memcmp( result, md5KATAnswer, sizeof( result ) ) != 0 ) {
        SymCryptFatal( 'MD5t' );
    }
}

SymCryptMd5StateExport()

VOID SYMCRYPT_CALL SymCryptMd5StateExport	(	_In_ PCSYMCRYPT_MD5_STATE	pState,
		_Out_writes_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PBYTE	pbBlob
	)

Definition at line 406 of file md5.c.

{
    SYMCRYPT_MD5_STATE_EXPORT_BLOB    blob;           // local copy to have proper alignment.
    C_ASSERT( sizeof( blob ) == SYMCRYPT_MD5_STATE_EXPORT_SIZE );
 
    SYMCRYPT_CHECK_MAGIC( pState );
 
    SymCryptWipeKnownSize( &blob, sizeof( blob ) ); // wipe to avoid any data leakage
 
    blob.header.magic = SYMCRYPT_BLOB_MAGIC;
    blob.header.size = SYMCRYPT_MD5_STATE_EXPORT_SIZE;
    blob.header.type = SymCryptBlobTypeMd5State;
 
    //
    // Copy the relevant data. Buffer will be 0-padded.
    //
 
    SymCryptUint32ToLsbFirst( &pState->chain.H[0], &blob.chain[0], 4 );
    blob.dataLength = pState->dataLengthL;
    memcpy( &blob.buffer[0], &pState->buffer[0], blob.dataLength & 0x3f );
 
    SYMCRYPT_ASSERT( (PCBYTE) &blob + sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ) == (PCBYTE) &blob.trailer );
    SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), &blob.trailer.checksum[0] );
 
    memcpy( pbBlob, &blob, sizeof( blob ) );
 
//cleanup:
    SymCryptWipeKnownSize( &blob, sizeof( blob ) );
    return;
}

SymCryptMd5StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd5StateImport	(	_Out_ PSYMCRYPT_MD5_STATE	pState,
		_In_reads_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PCBYTE	pbBlob
	)

Definition at line 441 of file md5.c.

{
    SYMCRYPT_ERROR                  scError = SYMCRYPT_NO_ERROR;
    SYMCRYPT_MD5_STATE_EXPORT_BLOB  blob;                       // local copy to have proper alignment.
    BYTE                            checksum[8];
 
    C_ASSERT( sizeof( blob ) == SYMCRYPT_MD5_STATE_EXPORT_SIZE );
    memcpy( &blob, pbBlob, sizeof( blob ) );
 
    if( blob.header.magic != SYMCRYPT_BLOB_MAGIC ||
        blob.header.size != SYMCRYPT_MD5_STATE_EXPORT_SIZE ||
        blob.header.type != SymCryptBlobTypeMd5State )
    {
        scError = SYMCRYPT_INVALID_BLOB;
        goto cleanup;
    }
 
    SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), checksum );
    if( memcmp( checksum, &blob.trailer.checksum[0], 8 ) != 0 )
    {
        scError = SYMCRYPT_INVALID_BLOB;
        goto cleanup;
    }
 
    SymCryptLsbFirstToUint32( &blob.chain[0], &pState->chain.H[0], 4 );
    pState->dataLengthL = blob.dataLength;
    pState->dataLengthH = 0;
    pState->bytesInBuffer = blob.dataLength & 0x3f;
    memcpy( &pState->buffer[0], &blob.buffer[0], pState->bytesInBuffer );
 
    SYMCRYPT_SET_MAGIC( pState );
 
cleanup:
    SymCryptWipeKnownSize( &blob, sizeof(blob) );
    return scError;
}

Variable Documentation

md5Const

const UINT32 md5Const[64]

static

Definition at line 51 of file md5.c.

md5InitialState

const UINT32 md5InitialState[4]

static

Initial value:

= {
    0x67452301UL,
    0xefcdab89UL,
    0x98badcfeUL,
    0x10325476UL,
}

Definition at line 158 of file md5.c.

Referenced by SymCryptMd5Init().

md5KATAnswer

const BYTE md5KATAnswer[16]

static

Initial value:

= {
    0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0,
    0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72,
}

Definition at line 485 of file md5.c.

Referenced by SymCryptMd5Selftest().

md5MsgIndex

const int md5MsgIndex[64]

static

Initial value:

= {
     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
     1,  6, 11,  0,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12,
     5,  8, 11, 14,  1,  4,  7, 10, 13,  0,  3,  6,  9, 12, 15,  2,
     0,  7, 14,  5, 12,  3, 10,  1,  8, 15,  6, 13,  4, 11,  2,  9,
}

Definition at line 148 of file md5.c.

md5Rotate

const int md5Rotate[64]

static

Initial value:

= {
    7, 12, 17, 22,
    7, 12, 17, 22,
    7, 12, 17, 22,
    7, 12, 17, 22,
 
    5, 9, 14, 20,
    5, 9, 14, 20,
    5, 9, 14, 20,
    5, 9, 14, 20,
 
    4, 11, 16, 23,
    4, 11, 16, 23,
    4, 11, 16, 23,
    4, 11, 16, 23,
 
    6, 10, 15, 21,
    6, 10, 15, 21,
    6, 10, 15, 21,
    6, 10, 15, 21,
}

Definition at line 122 of file md5.c.

SymCryptMd5Algorithm

const PCSYMCRYPT_HASH SymCryptMd5Algorithm = &SymCryptMd5Algorithm_default

Definition at line 43 of file md5.c.

Referenced by init_hash_impl(), SymCryptMd5Append(), and SymCryptMd5Result().

SymCryptMd5Algorithm_default

const SYMCRYPT_HASH SymCryptMd5Algorithm_default

Initial value:

= {
    &SymCryptMd5Init,
    &SymCryptMd5Append,
    &SymCryptMd5Result,
    &SymCryptMd5AppendBlocks,
    &SymCryptMd5StateCopy,
    sizeof( SYMCRYPT_MD5_STATE ),
    SYMCRYPT_MD5_RESULT_SIZE,
    SYMCRYPT_MD5_INPUT_BLOCK_SIZE,
    SYMCRYPT_FIELD_OFFSET( SYMCRYPT_MD5_STATE, chain ),
    SYMCRYPT_FIELD_SIZE( SYMCRYPT_MD5_STATE, chain ),
}

Definition at line 30 of file md5.c.