hash.c

//
// hash.c generic code used in many hash implementations.
// Copyright (c) Microsoft Corporation. Licensed under the MIT license.
//

#include "precomp.h"

VOID
SYMCRYPT_CALL
SymCryptHashAppendInternal( 
    _In_                        PCSYMCRYPT_HASH             pHash,
    _Inout_                     PSYMCRYPT_COMMON_HASH_STATE pState,
    _In_reads_bytes_( cbData )  PCBYTE                      pbData,
                                SIZE_T                      cbData )
{
    UINT32  bytesInBuffer;
    UINT32  freeInBuffer;
    SIZE_T  tmp;

    SYMCRYPT_CHECK_MAGIC( pState );

    pState->dataLengthL += cbData;
    if( pState->dataLengthL < cbData ) {
        pState->dataLengthH ++;                         // This is almost-unreachable code as it requires 2^64 bytes to be hashed.
    }

    bytesInBuffer = pState->bytesInBuffer;

    //
    // If previous data in buffer, buffer new input and transform if possible.
    //
    if( bytesInBuffer > 0 )
    {
        SYMCRYPT_ASSERT( pHash->inputBlockSize > bytesInBuffer );

        freeInBuffer = pHash->inputBlockSize - bytesInBuffer;
        if( cbData < freeInBuffer )
        {
            //
            // All the data will fit in the buffer.
            // We don't do anything here. 
            // As cbData < inputBlockSize the bulk data processing is skipped,
            // and the data will be copied to the buffer at the end
            // of this code.
        } else {
            //
            // Enough data to fill the whole buffer & process it
            //
            memcpy(&pState->buffer[bytesInBuffer], pbData, freeInBuffer);
            pbData += freeInBuffer;
            cbData -= freeInBuffer;
            (*pHash->appendBlockFunc)( (PBYTE)pState + pHash->chainOffset, &pState->buffer[0], pHash->inputBlockSize, &tmp );
            
            bytesInBuffer = 0;
        }
    }

    //
    // Internal buffer is empty; process all remaining whole blocks in the input
    //
    if( cbData >= pHash->inputBlockSize )
    {
        (*pHash->appendBlockFunc)( (PBYTE)pState + pHash->chainOffset, pbData, cbData, &tmp );
        SYMCRYPT_ASSERT( tmp < pHash->inputBlockSize );
        pbData += cbData - tmp;
        cbData = tmp;
    }

    SYMCRYPT_ASSERT( cbData < pHash->inputBlockSize );

    //
    // buffer remaining input if necessary.
    //
    if( cbData > 0 )
    {
        memcpy( &pState->buffer[bytesInBuffer], pbData, cbData );
        bytesInBuffer += (UINT32) cbData;
    }

    pState->bytesInBuffer = bytesInBuffer;
}

VOID
SYMCRYPT_CALL
SymCryptHashCommonPaddingMd4Style(
    _In_                        PCSYMCRYPT_HASH             pHash,
    _Inout_                     PSYMCRYPT_COMMON_HASH_STATE pState )
{
    SIZE_T tmp;
    SIZE_T bytesInBuffer = pState->bytesInBuffer;

    SYMCRYPT_CHECK_MAGIC( pState );
    SYMCRYPT_ASSERT( pHash->inputBlockSize == 64 );
    SYMCRYPT_ASSERT( bytesInBuffer == (pState->dataLengthL & 0x3f) );

    //
    // The buffer is never completely full, so we can always put the first
    // padding byte in.
    //
    pState->buffer[bytesInBuffer++] = 0x80;

    if( bytesInBuffer > 64-8 ) {
        //
        // No room for the rest of the padding. Pad with zeroes & process block
        // bytesInBuffer is at most 64, so we do not have an integer underflow
        //
        SymCryptWipe( &pState->buffer[bytesInBuffer], 64-bytesInBuffer );
        (*pHash->appendBlockFunc)( (PBYTE)pState + pHash->chainOffset, pState->buffer, 64, &tmp );
        SYMCRYPT_ASSERT( tmp == 0 );
        bytesInBuffer = 0;
    }

    //
    // Set rest of padding
    // At this point bytesInBuffer <= 64-8, so we don't have an underflow
    // We wipe to the end of the buffer as it is 16-aligned,
    // and it is faster to wipe to an aligned point
    //
    SymCryptWipe( &pState->buffer[bytesInBuffer], 64-bytesInBuffer );
    SYMCRYPT_STORE_LSBFIRST64( &pState->buffer[64-8], pState->dataLengthL * 8 );

    //
    // Process the final block
    //
    (*pHash->appendBlockFunc)( (PBYTE)pState + pHash->chainOffset, pState->buffer, 64, &tmp );
}



SIZE_T
SYMCRYPT_CALL
SymCryptHashResultSize( _In_ PCSYMCRYPT_HASH pHash )
{
    return pHash->resultSize;
}


SIZE_T
SYMCRYPT_CALL
SymCryptHashInputBlockSize( _In_ PCSYMCRYPT_HASH pHash )
{
    return pHash->inputBlockSize;
}

SIZE_T
SYMCRYPT_CALL
SymCryptHashStateSize( _In_ PCSYMCRYPT_HASH pHash )
{
    return pHash->stateSize;
}


VOID
SYMCRYPT_CALL
SymCryptHash( 
    _In_                                                         PCSYMCRYPT_HASH pHash,
    _In_reads_( cbData )                                         PCBYTE          pbData, 
                                                                 SIZE_T          cbData,
    _Out_writes_( SYMCRYPT_MIN( cbResult, pHash->resultSize ) )  PBYTE           pbResult,
                                                                 SIZE_T          cbResult )
{
    SYMCRYPT_HASH_STATE hash;

    _Analysis_assume_( pHash->stateSize <= sizeof( hash ) );
    SymCryptHashInit( pHash, &hash );
    SymCryptHashAppend( pHash, &hash, pbData, cbData );
    SymCryptHashResult( pHash, &hash, pbResult, cbResult );
    SymCryptWipe( &hash, pHash->stateSize );
}

VOID
SYMCRYPT_CALL
SymCryptHashInit(
    _In_                                        PCSYMCRYPT_HASH pHash,
    _Out_writes_bytes_( pHash->stateSize )      PVOID           pState )
{
    (*pHash->initFunc)( pState );
}

VOID
SYMCRYPT_CALL
SymCryptHashAppend(
    _In_                                        PCSYMCRYPT_HASH pHash,
    _Inout_updates_bytes_( pHash->stateSize )   PVOID           pState,
    _In_reads_( cbData )                        PCBYTE          pbData,
                                                SIZE_T          cbData )
{
    (*pHash->appendFunc)( pState, pbData, cbData );
}

VOID
SYMCRYPT_CALL
SymCryptHashResult( 
    _In_                                                         PCSYMCRYPT_HASH pHash,
    _Inout_updates_bytes_( pHash->stateSize )                    PVOID           pState,
    _Out_writes_( SYMCRYPT_MIN( cbResult, pHash->resultSize ) )  PBYTE           pbResult,
                                                                 SIZE_T          cbResult )
{
    BYTE    buf[SYMCRYPT_HASH_MAX_RESULT_SIZE];

    _Analysis_assume_( pHash->resultSize <= SYMCRYPT_HASH_MAX_RESULT_SIZE );

    (*pHash->resultFunc)( pState, buf );
    memcpy( pbResult, buf, SYMCRYPT_MIN( cbResult, pHash->resultSize ));
    SymCryptWipe( buf, pHash->resultSize );
}

VOID
SYMCRYPT_CALL
SymCryptHashStateCopy(
    _In_                                PCSYMCRYPT_HASH pHash,
    _In_reads_( pHash->stateSize )      PCVOID          pSrc,
    _Out_writes_( pHash->stateSize )    PVOID           pDst)
{
    (*pHash->stateCopyFunc)( pSrc, pDst );
}