ScsTable.c File Reference

#include "precomp.h"

Include dependency graph for ScsTable.c:

Go to the source code of this file.

Macros
#define	SYMCRYPT_SCSTABLE_USE64   0
#define	SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE   16
#define	SYMCRYPT_SCSTABLE_GROUP_SIZE   4
#define	SCS_MASK_EQUAL32(_a, _b)   (SYMCRYPT_MASK32_EQ( _a, _b ))

Typedefs
typedef UINT32	SYMCRYPT_SCSTABLE_TYPE

Functions
UINT32 SYMCRYPT_CALL	SymCryptScsTableInit (_Out_ PSYMCRYPT_SCSTABLE pScsTable, UINT32 nElements, UINT32 elementSize)
VOID SYMCRYPT_CALL	SymCryptScsTableSetBuffer (_Inout_ PSYMCRYPT_SCSTABLE pScsTable, _Inout_updates_bytes_(cbBuffer) PBYTE pbBuffer, UINT32 cbBuffer)
	C_ASSERT (SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE==16||SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE==32)
VOID SYMCRYPT_CALL	SymCryptScsTableStoreC (_Inout_ PSYMCRYPT_SCSTABLE pScsTable, UINT32 iIndex, _In_reads_bytes_(cbData) PCBYTE pbData, UINT32 cbData)
VOID SYMCRYPT_CALL	SymCryptScsTableLoadC (_In_ PSYMCRYPT_SCSTABLE pScsTable, UINT32 iIndex, _Out_writes_bytes_(cbData) PBYTE pbData, UINT32 cbData)
VOID SYMCRYPT_CALL	SymCryptScsTableStore (_Inout_ PSYMCRYPT_SCSTABLE pScsTable, UINT32 iIndex, _In_reads_bytes_(cbData) PCBYTE pbData, UINT32 cbData)
VOID SYMCRYPT_CALL	SymCryptScsTableLoad (_In_ PSYMCRYPT_SCSTABLE pScsTable, UINT32 iIndex, _Out_writes_bytes_(cbData) PBYTE pbData, UINT32 cbData)
VOID SYMCRYPT_CALL	SymCryptScsTableWipe (_Inout_ PSYMCRYPT_SCSTABLE pScsTable)

Macro Definition Documentation

SCS_MASK_EQUAL32

#define SCS_MASK_EQUAL32	(		_a,
			_b
	)		(SYMCRYPT_MASK32_EQ( _a, _b ))

SYMCRYPT_SCSTABLE_GROUP_SIZE

#define SYMCRYPT_SCSTABLE_GROUP_SIZE   4

Definition at line 50 of file ScsTable.c.

SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE

#define SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE   16

Definition at line 49 of file ScsTable.c.

SYMCRYPT_SCSTABLE_USE64

#define SYMCRYPT_SCSTABLE_USE64   0

Definition at line 48 of file ScsTable.c.

Typedef Documentation

SYMCRYPT_SCSTABLE_TYPE

typedef UINT32 SYMCRYPT_SCSTABLE_TYPE

Definition at line 51 of file ScsTable.c.

Function Documentation

C_ASSERT()

C_ASSERT

(

SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE

= =16||SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE==32

)

SymCryptScsTableInit()

UINT32 SYMCRYPT_CALL SymCryptScsTableInit	(	_Out_ PSYMCRYPT_SCSTABLE	pScsTable,
		UINT32	nElements,
		UINT32	elementSize
	)

Definition at line 56 of file ScsTable.c.

{
    UINT32  groupSize;
    UINT32  interleaveSize;
    UINT32  cbBuffer;
 
    SYMCRYPT_ASSERT( nElements > 0 );
 
#pragma warning( suppress: 4127 )       // conditional expression is constant
    if( SYMCRYPT_CPU_AMD64 && elementSize == 128 )
    {
        // Highly optimized assembler mode for 1024-bit entries for RSA-2048...
        interleaveSize = 128;
        groupSize = 1;
    } else {
        // Standard C implementation
        interleaveSize = SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE;
        groupSize = SYMCRYPT_SCSTABLE_GROUP_SIZE;
    }
 
    // Right now, we limit ourselves to element sizes that are a multiple of the interleaveSize and
    // # elements that are a multiple of the group size.
    // We also limit ourselves to sensible input sizes
    SYMCRYPT_ASSERT( elementSize % interleaveSize == 0 && nElements % groupSize == 0 && (elementSize | nElements) < (1 << 16) && elementSize > 0 );
 
    cbBuffer = elementSize * nElements; // Each factor is < 2^16, so there is no overflow in the mul
 
    pScsTable->groupSize = groupSize;
    pScsTable->interleaveSize = interleaveSize;
    pScsTable->nElements = nElements;
    pScsTable->elementSize = elementSize;
    pScsTable->cbTableData = cbBuffer;
    pScsTable->pbTableData = NULL;
 
    return cbBuffer;
}

Referenced by SymCryptModExpWindowed().

SymCryptScsTableLoad()

VOID SYMCRYPT_CALL SymCryptScsTableLoad	(	_In_ PSYMCRYPT_SCSTABLE	pScsTable,
		UINT32	iIndex,
		_Out_writes_bytes_(cbData) PBYTE	pbData,
		UINT32	cbData
	)

Definition at line 358 of file ScsTable.c.

{
    // This is the side-channel safe routine
 
#if SYMCRYPT_CPU_AMD64
 
    if( pScsTable->elementSize == 128 )
    {
        SymCryptScsTableLoad128Xmm( pScsTable, iIndex, pbData, cbData );
    } else {
        SymCryptScsTableLoadC( pScsTable, iIndex, pbData, cbData );
    }
 
#else
 
    SymCryptScsTableLoadC( pScsTable, iIndex, pbData, cbData );
 
#endif
}

Referenced by SymCryptModExpWindowed().

SymCryptScsTableLoadC()

VOID SYMCRYPT_CALL SymCryptScsTableLoadC	(	_In_ PSYMCRYPT_SCSTABLE	pScsTable,
		UINT32	iIndex,
		_Out_writes_bytes_(cbData) PBYTE	pbData,
		UINT32	cbData
	)

Definition at line 185 of file ScsTable.c.

{
    UINT32 groupSize = SYMCRYPT_SCSTABLE_GROUP_SIZE;
    UINT32 interleaveSize = SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE;
    UINT32 elementSize = pScsTable->elementSize;
 
    SYMCRYPT_SCSTABLE_TYPE mask0, mask1, mask2, mask3;
    UINT32 i;
    UINT32 j;
    UINT32 nElements = pScsTable->nElements;
 
    const SYMCRYPT_SCSTABLE_TYPE * pSrc = (SYMCRYPT_SCSTABLE_TYPE *) pScsTable->pbTableData;
    SYMCRYPT_SCSTABLE_TYPE * pDst = (SYMCRYPT_SCSTABLE_TYPE *) pbData;
    SYMCRYPT_SCSTABLE_TYPE * pD;
 
    UINT32 nInterleaves = elementSize / interleaveSize;
 
 
    SYMCRYPT_ASSERT( groupSize ==  pScsTable->groupSize );
    SYMCRYPT_ASSERT( interleaveSize == pScsTable->interleaveSize );
 
    SYMCRYPT_ASSERT( cbData >= sizeof( SYMCRYPT_SCSTABLE_TYPE ) * SYMCRYPT_SCSTABLE_GROUP_SIZE );
    SYMCRYPT_ASSERT( cbData == pScsTable->elementSize );
    UNREFERENCED_PARAMETER( cbData );
 
#if SYMCRYPT_SCSTABLE_USE64
#define SCS_MASK_EQUAL32( _a, _b )  ( ~(UINT64) ((INT64) ((UINT64)0 - (_a ^ _b)) >> 32 ) )
#else
#define SCS_MASK_EQUAL32( _a, _b )  (SYMCRYPT_MASK32_EQ( _a, _b ))
#endif
 
    i = 0;
 
    mask0 = SCS_MASK_EQUAL32( i+0, iIndex );
    mask1 = SCS_MASK_EQUAL32( i+1, iIndex );
    mask2 = SCS_MASK_EQUAL32( i+2, iIndex );
    mask3 = SCS_MASK_EQUAL32( i+3, iIndex );
 
    j = nInterleaves;
    pD = pDst;
 
    do {
        pD[0] = (mask0 & pSrc[0]) | (mask1 & pSrc[4]) | (mask2 & pSrc[ 8]) | (mask3 & pSrc[12]);
        pD[1] = (mask0 & pSrc[1]) | (mask1 & pSrc[5]) | (mask2 & pSrc[ 9]) | (mask3 & pSrc[13]);
        pD[2] = (mask0 & pSrc[2]) | (mask1 & pSrc[6]) | (mask2 & pSrc[10]) | (mask3 & pSrc[14]);
        pD[3] = (mask0 & pSrc[3]) | (mask1 & pSrc[7]) | (mask2 & pSrc[11]) | (mask3 & pSrc[15]);
        pD += interleaveSize / sizeof( *pD );
        pSrc += interleaveSize * groupSize / sizeof( *pSrc );
        j--;
    } while( j > 0 );
 
    i += groupSize;
 
    while (i + groupSize <= nElements)
    {
 
        mask0 = SCS_MASK_EQUAL32( i+0, iIndex );
        mask1 = SCS_MASK_EQUAL32( i+1, iIndex );
        mask2 = SCS_MASK_EQUAL32( i+2, iIndex );
        mask3 = SCS_MASK_EQUAL32( i+3, iIndex );
 
        j = nInterleaves;
        pD = pDst;
 
        do {
            pD[0] |= (mask0 & pSrc[0]) | (mask1 & pSrc[4]) | (mask2 & pSrc[ 8]) | (mask3 & pSrc[12]);
            pD[1] |= (mask0 & pSrc[1]) | (mask1 & pSrc[5]) | (mask2 & pSrc[ 9]) | (mask3 & pSrc[13]);
            pD[2] |= (mask0 & pSrc[2]) | (mask1 & pSrc[6]) | (mask2 & pSrc[10]) | (mask3 & pSrc[14]);
            pD[3] |= (mask0 & pSrc[3]) | (mask1 & pSrc[7]) | (mask2 & pSrc[11]) | (mask3 & pSrc[15]);
            pD += interleaveSize / sizeof( *pD );
            pSrc += interleaveSize * groupSize / sizeof( *pSrc );
            j--;
        } while( j > 0 );
 
        i += groupSize;
    }
}

Referenced by SymCryptScsTableLoad().

SymCryptScsTableSetBuffer()

VOID SYMCRYPT_CALL SymCryptScsTableSetBuffer	(	_Inout_ PSYMCRYPT_SCSTABLE	pScsTable,
		_Inout_updates_bytes_(cbBuffer) PBYTE	pbBuffer,
		UINT32	cbBuffer
	)

Definition at line 98 of file ScsTable.c.

{
    SYMCRYPT_ASSERT(cbBuffer >= pScsTable->cbTableData);
    UNREFERENCED_PARAMETER( cbBuffer );
 
    pScsTable->pbTableData = pbBuffer;
}

Referenced by SymCryptModExpWindowed().

SymCryptScsTableStore()

VOID SYMCRYPT_CALL SymCryptScsTableStore	(	_Inout_ PSYMCRYPT_SCSTABLE	pScsTable,
		UINT32	iIndex,
		_In_reads_bytes_(cbData) PCBYTE	pbData,
		UINT32	cbData
	)

Definition at line 334 of file ScsTable.c.

{
#if SYMCRYPT_CPU_AMD64
 
    if( pScsTable->elementSize == 128 )
    {
        SymCryptScsTableStore128Xmm( pScsTable, iIndex, pbData, cbData );
    } else {
        SymCryptScsTableStoreC( pScsTable, iIndex, pbData, cbData );
    }
 
#else
 
    SymCryptScsTableStoreC( pScsTable, iIndex, pbData, cbData );
 
#endif
}

Referenced by SymCryptModExpWindowed().

SymCryptScsTableStoreC()

VOID SYMCRYPT_CALL SymCryptScsTableStoreC	(	_Inout_ PSYMCRYPT_SCSTABLE	pScsTable,
		UINT32	iIndex,
		_In_reads_bytes_(cbData) PCBYTE	pbData,
		UINT32	cbData
	)

Definition at line 116 of file ScsTable.c.

{
    UINT32 groupSize = SYMCRYPT_SCSTABLE_GROUP_SIZE;
    UINT32 interleaveSize = SYMCRYPT_SCSTABLE_INTERLEAVE_SIZE;
    UINT32 elementSize = pScsTable->elementSize;
    UINT32 groupOffset;
 
    SYMCRYPT_ASSERT( groupSize ==  pScsTable->groupSize );
    SYMCRYPT_ASSERT( interleaveSize == pScsTable->interleaveSize );
 
    SYMCRYPT_ASSERT( cbData == elementSize );
    UNREFERENCED_PARAMETER( cbData );
 
    SYMCRYPT_ASSERT(iIndex < pScsTable->nElements);
 
    groupOffset = iIndex % groupSize;
 
    // dcl - document why this can't be an integer overflow
    SYMCRYPT_SCSTABLE_TYPE * pDst = (SYMCRYPT_SCSTABLE_TYPE *) (pScsTable->pbTableData + (iIndex - groupOffset) * elementSize + groupOffset * interleaveSize);
    SYMCRYPT_SCSTABLE_TYPE * pSrc = (SYMCRYPT_SCSTABLE_TYPE *) pbData;
 
    UINT32 nInterleaves = elementSize / interleaveSize;
 
    do
    {
        pDst[0] = pSrc[0];
        pDst[1] = pSrc[1];
        pDst[2] = pSrc[2];
        pDst[3] = pSrc[3];
 
        pDst += interleaveSize * groupSize / sizeof( *pDst );
        pSrc += interleaveSize / sizeof( *pSrc );
        nInterleaves--;
    } while( nInterleaves > 0 );
 
}

Referenced by SymCryptScsTableStore().

SymCryptScsTableWipe()

VOID SYMCRYPT_CALL SymCryptScsTableWipe

(

_Inout_ PSYMCRYPT_SCSTABLE

pScsTable

)

Definition at line 384 of file ScsTable.c.

{
    SymCryptWipe( pScsTable->pbTableData, pScsTable->cbTableData );
}