scsTools.c File Reference

#include "precomp.h"

Include dependency graph for scsTools.c:

Go to the source code of this file.

Macros
#define	MIN_BUFFER_SIZE   (32)

Functions
UINT32 SYMCRYPT_CALL	SymCryptMask32IsNonzeroU31 (UINT32 v)
UINT32 SYMCRYPT_CALL	SymCryptMask32IsZeroU31 (UINT32 v)
UINT32 SYMCRYPT_CALL	SymCryptMask32NeqU31 (UINT32 a, UINT32 b)
UINT32 SYMCRYPT_CALL	SymCryptMask32LtU31 (UINT32 a, UINT32 b)
UINT32 SYMCRYPT_CALL	SymCryptMask32EqU32 (UINT32 a, UINT32 b)
SIZE_T SYMCRYPT_CALL	SymCryptRoundUpPow2Sizet (SIZE_T v)
VOID SYMCRYPT_CALL	SymCryptScsCopy (_In_reads_(cbDst) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
VOID SYMCRYPT_CALL	SymCryptScsRotateBuffer (_Inout_updates_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, SIZE_T lshift)
UINT32 SYMCRYPT_CALL	SymCryptMapUint32 (UINT32 u32Input, UINT32 u32Default, _In_reads_(nMap) PCSYMCRYPT_UINT32_MAP pcMap, SIZE_T nMap)

Macro Definition Documentation

MIN_BUFFER_SIZE

#define MIN_BUFFER_SIZE   (32)

Definition at line 15 of file scsTools.c.

Function Documentation

SymCryptMapUint32()

UINT32 SYMCRYPT_CALL SymCryptMapUint32	(	UINT32	u32Input,
		UINT32	u32Default,
		_In_reads_(nMap) PCSYMCRYPT_UINT32_MAP	pcMap,
		SIZE_T	nMap
	)

Definition at line 351 of file scsTools.c.

{
    UINT32 mask;
    UINT32 u32Output    = u32Default;
 
    for (SIZE_T i = 0; i < nMap; ++i)
    {
        mask = SymCryptMask32EqU32(u32Input, pcMap[i].from);
        u32Output ^= (u32Output ^ pcMap[i].to) & mask;
    }
 
    return u32Output;
}

SymCryptMask32EqU32()

UINT32 SYMCRYPT_CALL SymCryptMask32EqU32	(	UINT32	a,
		UINT32	b
	)

Definition at line 67 of file scsTools.c.

{
    return ~(UINT32) ( (-(INT64)(a^b)) >> 32);
}

Referenced by SymCryptMapUint32().

SymCryptMask32IsNonzeroU31()

UINT32 SYMCRYPT_CALL SymCryptMask32IsNonzeroU31

(

UINT32

v

)

Definition at line 28 of file scsTools.c.

{
    SYMCRYPT_ASSERT( v < (1UL<<31) );
    return (-(INT32) v) >> 31;
}

Referenced by SymCryptMask32NeqU31(), SymCryptPaddingPkcs7Remove(), SymCryptRsaOaepRemoveEncryptionPadding(), and SymCryptRsaPkcs1RemoveEncryptionPadding().

SymCryptMask32IsZeroU31()

UINT32 SYMCRYPT_CALL SymCryptMask32IsZeroU31

(

UINT32

v

)

Definition at line 36 of file scsTools.c.

{
    return ~SymCryptMask32IsNonzeroU31( v );
}

Referenced by SymCryptPaddingPkcs7Remove(), SymCryptRsaOaepRemoveEncryptionPadding(), and SymCryptRsaPkcs1RemoveEncryptionPadding().

SymCryptMask32LtU31()

UINT32 SYMCRYPT_CALL SymCryptMask32LtU31	(	UINT32	a,
		UINT32	b
	)

Definition at line 53 of file scsTools.c.

{
    SYMCRYPT_ASSERT( a < (1UL<<31) );
    SYMCRYPT_ASSERT( b < (1UL<<31) );
 
    // Casting to INT32 is defined as a and b are < 2^31
    return ((INT32) a - (INT32) b) >> 31;
}

Referenced by SymCryptAesKwpDecrypt(), SymCryptPaddingPkcs7Remove(), SymCryptRsaPkcs1RemoveEncryptionPadding(), and SymCryptScsCopy().

SymCryptMask32NeqU31()

UINT32 SYMCRYPT_CALL SymCryptMask32NeqU31	(	UINT32	a,
		UINT32	b
	)

Definition at line 43 of file scsTools.c.

{
    SYMCRYPT_ASSERT( a < (1UL<<31) );
    SYMCRYPT_ASSERT( b < (1UL<<31) );
 
    return SymCryptMask32IsNonzeroU31( a ^ b );
}

Referenced by SymCryptRsaPkcs1RemoveEncryptionPadding().

SymCryptRoundUpPow2Sizet()

SIZE_T SYMCRYPT_CALL SymCryptRoundUpPow2Sizet

(

SIZE_T

v

)

Definition at line 76 of file scsTools.c.

{
    SIZE_T res;
 
    SYMCRYPT_ASSERT( v <= (SIZE_T_MAX / 2) + 1);
    // If v is very large, then the result res might overflow.
    // As SIZE_T is an unsigned type, the overflow is defined to
    // be modulo 2^n for some n, and therefore we'll get res==0
    // which will terminate the loop.
 
    res = 1;
    while( res < v )
    {
        res += res;
 
        // Catch any overflows; should never happen but break to avoid infinite loop
        if( res == 0 )
        {
            break;
        }
    }
 
    return res;
}

Referenced by SymCryptRsaPkcs1Decrypt(), and SymCryptTlsCbcHmacVerifyCore().

SymCryptScsCopy()

VOID SYMCRYPT_CALL SymCryptScsCopy	(	_In_reads_(cbDst) PCBYTE	pbSrc,
		SIZE_T	cbSrc,
		_Out_writes_(cbDst) PBYTE	pbDst,
		SIZE_T	cbDst
	)

Definition at line 108 of file scsTools.c.

{
    UINT32 i;
 
    SYMCRYPT_ASSERT( cbSrc <= (1UL << 31) && cbDst <= (1UL << 31) );
 
    // Loop over the destination buffer and update each byte with the source data (if appropriate)
    // We round-robin loop over the source buffer
    for( i = 0; i < cbDst; i++ )
    {
        pbDst[ i ] ^= (pbSrc[ i ] ^ pbDst[ i ]) & SymCryptMask32LtU31( i, (UINT32) cbSrc );
    }
}

Referenced by SymCryptMlKemDecapsulate(), and SymCryptRsaPkcs1RemoveEncryptionPadding().

SymCryptScsRotateBuffer()

VOID SYMCRYPT_CALL SymCryptScsRotateBuffer	(	_Inout_updates_(cbBuffer) PBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		SIZE_T	lshift
	)

Definition at line 179 of file scsTools.c.

{
    NATIVE_UINT * pBuf;
    UINT32 n;
    UINT32 a;
    UINT32 b;
    UINT32 i;
    UINT32 j;
    UINT32 blockSize;
    UINT32 blockSizeLog;
    UINT32 blockSizeLimit;
 
    NATIVE_UINT V;
    NATIVE_UINT T;
    NATIVE_UINT A;
    NATIVE_UINT B;
    NATIVE_UINT C;
    NATIVE_UINT D;
    NATIVE_UINT M;
    NATIVE_UINT M0;
    NATIVE_UINT M1;
 
    NATIVE_UINT Mask[ 16 ];      // Size must be a power of 2
 
    SYMCRYPT_ASSERT( (cbBuffer & (cbBuffer - 1)) == 0 && cbBuffer >= MIN_BUFFER_SIZE );
    SYMCRYPT_ASSERT( lshift < cbBuffer );
 
    pBuf = (NATIVE_UINT *) pbBuffer;
    n = (UINT32)cbBuffer / NATIVE_BYTES;
 
    // First a rotate left by lshift % NATIVE_BYTES
    // This is more complex because shifting by NATIVE_BITS is not a defined operation, and behavior is different
    // on different CPUs.
 
    // Compute the shift amounts & mask
    // M = 0 if lshift % NATIVE_BYTES == 0, -1 otherwise
    a = 8 * (lshift & (NATIVE_BYTES-1));            // Core shift
    M = (-(NATIVE_INT)a) >> (NATIVE_BITS - 1);      // mask
    b = (NATIVE_BITS - a) & (UINT32) M;         // complementary shift, or 0 if it would be equal to NATIVE_BITS
 
    i = n;
    V = pBuf[0];
    do{
        // Loop invariant: i > 0 && v = pBuf[i] from before any changes;
        i--;
        T = pBuf[i];
        pBuf[i] = T >> a | ((V << b) & M);
        V = T;
    } while( i > 0 );
 
    // Now that the rotation is word-aligned, we can start our word rotation
    lshift >>= NATIVE_BYTES_LOG2;           // convert to # words to rotate.
 
    // We know we have at least 4 words, so we start with a pass do do 4-word rotations
    SYMCRYPT_ASSERT( n >= 4 );
 
    M = -(NATIVE_INT)(lshift & 1);
    M0 = -(NATIVE_INT)( ((lshift + 0) >> 1) & 1 );      // s + 0 mod 4 >= 2
    M1 = -(NATIVE_INT)( ((lshift + 1) >> 1) & 1 );      // s + 1 mod 4 >= 2
 
    for( i=0; i<n; i+=4 )
    {
        A = pBuf[i];
        B = pBuf[i+1];
        C = pBuf[i+2];
        D = pBuf[i+3];
 
        T = (A ^ B) & M;
        A ^= T;
        B ^= T;
 
        T = (C ^ D) & M;
        C ^= T;
        D ^= T;
 
        T = (A ^ C) & M0;
        A ^= T;
        C ^= T;
 
        T = (B ^ D) & M1;
        B ^= T;
        D ^= T;
 
        pBuf[i  ] = A;
        pBuf[i+1] = B;
        pBuf[i+2] = C;
        pBuf[i+3] = D;
    }
 
    // Do the swaps using the mask array
    blockSize = 4;  // size of rotated blocks
    blockSizeLog = 2;
 
    //
    // Using the mask array is beneficial as long as the array is used twice or more
    // Each swap loop processes 2 * blockSize of data, so the block size should never
    // be larger than n/4
    blockSizeLimit = SYMCRYPT_MIN( SYMCRYPT_ARRAY_SIZE( Mask ), n/4 );
    while( blockSize <= blockSizeLimit )
    {
        // Compute the masks for this level
        for( i=0; i<blockSize; i++ )
        {
            Mask[i] =-(NATIVE_INT)( ((i + lshift) >> blockSizeLog) & 1);
        }
 
        // Now swap the elements of pairs of blocks according to the masks
        for( i=0; i < n; i += 2 * blockSize )
        {
            for( j=0; j < blockSize; j++ )
            {
                A = pBuf[ i + j ];
                B = pBuf[ i + j + blockSize ];
                T = (A ^ B) & Mask[j];
                A ^= T;
                B ^= T;
                pBuf[ i + j ] = A;
                pBuf[ i + j + blockSize ] = B;
            }
        }
        blockSize *= 2;
        blockSizeLog += 1;
    }
 
    // Do the rest without using a mask array, either because we are only
    // going to use each mask value once, or because we don't have a large-enough
    // array
    while( blockSize < n  )
    {
        // Now swap the elements of pairs of blocks according to the masks
        for( i=0; i < n; i += 2 * blockSize )
        {
            for( j=0; j < blockSize; j++ )
            {
                M = -(NATIVE_INT)( ((j + lshift) >> blockSizeLog) & 1);
                A = pBuf[ i + j ];
                B = pBuf[ i + j + blockSize ];
                T = (A ^ B) & M;
                A ^= T;
                B ^= T;
                pBuf[ i + j ] = A;
                pBuf[ i + j + blockSize ] = B;
            }
        }
        blockSize *= 2;
        blockSizeLog += 1;
    }
 
}

Referenced by SymCryptRsaPkcs1RemoveEncryptionPadding(), and SymCryptTlsCbcHmacVerifyCore().