hmac_pattern.c File Reference

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

Go to the source code of this file.

Functions
VOID SYMCRYPT_CALL	SYMCRYPT_HmacXxxStateCopy (_In_ PCSYMCRYPT_HMAC_XXX_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_XXX_STATE pDst)
VOID SYMCRYPT_CALL	SYMCRYPT_HmacXxxKeyCopy (_In_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_XXX_EXPANDED_KEY pDst)
SYMCRYPT_ERROR SYMCRYPT_CALL	SYMCRYPT_HmacXxxExpandKey (_Out_ PSYMCRYPT_HMAC_XXX_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL	SYMCRYPT_HmacXxxInit (_Out_ PSYMCRYPT_HMAC_XXX_STATE pState, _In_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY pExpandedKey)
VOID SYMCRYPT_CALL	SYMCRYPT_HmacXxxAppend (_Inout_ PSYMCRYPT_HMAC_XXX_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
	C_ASSERT (SYMCRYPT_XXX_RESULT_SIZE==SYMCRYPT_HMAC_XXX_RESULT_SIZE)
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL	SYMCRYPT_HmacXxxResult (_Inout_ PSYMCRYPT_HMAC_XXX_STATE pState, _Out_writes_(SYMCRYPT_HMAC_XXX_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL	SYMCRYPT_HmacXxx (_In_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_XXX_RESULT_SIZE) PBYTE pbResult)

Function Documentation

C_ASSERT()

C_ASSERT

(

SYMCRYPT_XXX_RESULT_SIZE

= =SYMCRYPT_HMAC_XXX_RESULT_SIZE

)

SYMCRYPT_HmacXxx()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SYMCRYPT_HmacXxx	(	_In_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_writes_(SYMCRYPT_HMAC_XXX_RESULT_SIZE) PBYTE	pbResult
	)

Definition at line 185 of file hmac_pattern.c.

{
    SYMCRYPT_HMAC_XXX_STATE state;
 
    SYMCRYPT_HmacXxxInit( &state, pExpandedKey );
    SYMCRYPT_HmacXxxAppend( &state, pbData, cbData );
    SYMCRYPT_HmacXxxResult( &state, pbResult );
 
}

SYMCRYPT_HmacXxxAppend()

VOID SYMCRYPT_CALL SYMCRYPT_HmacXxxAppend	(	_Inout_ PSYMCRYPT_HMAC_XXX_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 127 of file hmac_pattern.c.

{
    SYMCRYPT_XxxAppend( &pState->hash, pbData, cbData );
}

SYMCRYPT_HmacXxxExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SYMCRYPT_HmacXxxExpandKey	(	_Out_ PSYMCRYPT_HMAC_XXX_EXPANDED_KEY	pExpandedKey,
		_In_reads_opt_(cbKey) PCBYTE	pbKey,
		SIZE_T	cbKey
	)

Definition at line 45 of file hmac_pattern.c.

{
    SYMCRYPT_XXX_STATE  hashState;
    SYMCRYPT_ALIGN BYTE iblock[ SYMCRYPT_XXX_INPUT_BLOCK_SIZE ];  // One input block for the hash function
    SIZE_T tmp;
 
    SYMCRYPT_SET_MAGIC( pExpandedKey );
 
    //
    // Initialize our hash state and our input block
    // We wipe the whole block & then copy the key into it. This is often faster
    // as the compiler can optimize the wipe because it knows the size at compile time.
    //
    SYMCRYPT_XxxInit( &hashState );
    memset( iblock, 0, sizeof( iblock ) );
 
    if( cbKey <= sizeof( iblock ) )
    {
        if( cbKey > 0 )
        {
            memcpy( iblock, pbKey, cbKey );
        }
    } else {
        //
        // We can use the existing MD5 state to hash the long key.
        // The state is re-initialized by the SymCryptMd5Result() function.
        //
        SYMCRYPT_XxxAppend( &hashState, pbKey, cbKey );
        SYMCRYPT_XxxResult( &hashState, iblock );
    }
 
    XorByteIntoBuffer( iblock, sizeof( iblock )/8, HMAC_IPAD_BYTE );
 
    //
    // Copy the initial chaining state to both states in the expanded key
    //
    pExpandedKey->innerState = hashState.chain;
    pExpandedKey->outerState = hashState.chain;
 
    //
    // Update the state in the expanded key directly
    //
    SYMCRYPT_XxxAppendBlocks( &pExpandedKey->innerState, iblock, sizeof( iblock ), &tmp );
 
    XorByteIntoBuffer( iblock, sizeof( iblock )/8, HMAC_IPAD_BYTE ^ HMAC_OPAD_BYTE );
 
    SYMCRYPT_XxxAppendBlocks( &pExpandedKey->outerState, iblock, sizeof( iblock ), &tmp );
 
    SymCryptWipeKnownSize( iblock, sizeof( iblock ) );
    SymCryptWipeKnownSize( &hashState, sizeof( hashState ) );
 
    return SYMCRYPT_NO_ERROR;
}

SYMCRYPT_HmacXxxInit()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SYMCRYPT_HmacXxxInit	(	_Out_ PSYMCRYPT_HMAC_XXX_STATE	pState,
		_In_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY	pExpandedKey
	)

Definition at line 106 of file hmac_pattern.c.

{
    SYMCRYPT_CHECK_MAGIC( pExpandedKey );
 
    SYMCRYPT_SET_MAGIC( pState );
 
    //
    // We don't call SymCryptXxxInit on the hash sub-state;
    // instead we directly initialize its fields.
    //
    SYMCRYPT_SET_MAGIC( &pState->hash );
    pState->hash.chain = pExpandedKey->innerState;
    SET_DATALENGTH( pState->hash, SYMCRYPT_XXX_INPUT_BLOCK_SIZE );
    pState->hash.bytesInBuffer = 0;
    pState->pKey = pExpandedKey;
}

SYMCRYPT_HmacXxxKeyCopy()

VOID SYMCRYPT_CALL SYMCRYPT_HmacXxxKeyCopy	(	_In_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY	pSrc,
		_Out_ PSYMCRYPT_HMAC_XXX_EXPANDED_KEY	pDst
	)

Definition at line 36 of file hmac_pattern.c.

{
    SYMCRYPT_CHECK_MAGIC( pSrc );
    *pDst = *pSrc;
    SYMCRYPT_SET_MAGIC( pDst );
}

SYMCRYPT_HmacXxxResult()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SYMCRYPT_HmacXxxResult	(	_Inout_ PSYMCRYPT_HMAC_XXX_STATE	pState,
		_Out_writes_(SYMCRYPT_HMAC_XXX_RESULT_SIZE) PBYTE	pbResult
	)

Definition at line 140 of file hmac_pattern.c.

{
    BYTE    innerRes[SYMCRYPT_XXX_RESULT_SIZE];
 
    SYMCRYPT_CHECK_MAGIC( pState );
 
    //
    // We have to buffer the inner hash result. We can't put it directly in the
    // hash state data buffer as the Result() function wipes that buffer before returning.
    //
 
    SYMCRYPT_XxxResult( &pState->hash, innerRes );
 
    SYMCRYPT_CHECK_MAGIC( pState->pKey )
 
    pState->hash.chain = pState->pKey->outerState;
 
    //
    // We put the data directly in the buffer, rather than call the Append function.
    //
    memcpy( &pState->hash.buffer, innerRes, sizeof( innerRes ) );
    SET_DATALENGTH(  pState->hash, SYMCRYPT_XXX_INPUT_BLOCK_SIZE + SYMCRYPT_XXX_RESULT_SIZE );
    pState->hash.bytesInBuffer = SYMCRYPT_XXX_RESULT_SIZE;
 
    SYMCRYPT_XxxResult( &pState->hash, pbResult );
 
    //
    // The SymCryptXxxResult already wipes the hash state.
    // We only need to wipe our own buffer.
    //
    // We also set the key pointer to NULL. This is not for security;
    // it creates a clear error when callers forget to call the Init routine
    // when re-using a state. Rather than the wrong result, they will get
    // a NULL pointer exception, and they will fix their code.
    //
 
    SymCryptWipe( innerRes, sizeof( innerRes ) );
    pState->pKey = NULL;
}

SYMCRYPT_HmacXxxStateCopy()

VOID SYMCRYPT_CALL SYMCRYPT_HmacXxxStateCopy	(	_In_ PCSYMCRYPT_HMAC_XXX_STATE	pSrc,
		_In_opt_ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY	pExpandedKey,
		_Out_ PSYMCRYPT_HMAC_XXX_STATE	pDst
	)

Definition at line 12 of file hmac_pattern.c.

{
    SYMCRYPT_CHECK_MAGIC( pSrc );
 
    SYMCRYPT_XxxStateCopy( &pSrc->hash, &pDst->hash );
 
    if( pExpandedKey != NULL )
    {
        SYMCRYPT_CHECK_MAGIC( pExpandedKey );
        pDst->pKey = pExpandedKey;
    }
    else
    {
        SYMCRYPT_CHECK_MAGIC( pSrc->pKey );
        pDst->pKey = pSrc->pKey;
    }
    SYMCRYPT_SET_MAGIC( pDst );
}