#include <symcrypt_low_level.h>
#include "sc_lib_mlkem.h"
#include "sc_lib_mldsa.h"

Include dependency graph for sc_lib.h:

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

Classes
struct	_SYMCRYPT_BLOB_HEADER

struct	_SYMCRYPT_BLOB_TRAILER

struct	_SYMCRYPT_MD2_STATE_EXPORT_BLOB

struct	_SYMCRYPT_MD4_STATE_EXPORT_BLOB

struct	_SYMCRYPT_MD5_STATE_EXPORT_BLOB

struct	_SYMCRYPT_SHA1_STATE_EXPORT_BLOB

struct	_SYMCRYPT_SHA256_STATE_EXPORT_BLOB

struct	_SYMCRYPT_SHA512_STATE_EXPORT_BLOB

struct	_SYMCRYPT_KECCAK_STATE_EXPORT_BLOB

struct	_SYMCRYPT_MODULAR_FUNCTIONS

struct	_SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

struct	_SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

struct	_SYMCRYPT_ECURVE_FUNCTIONS

struct	_SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

struct	_XMSS_OTS_ADDRESS

struct	_XMSS_LTREE_ADDRESS

struct	_XMSS_HASHTREE_ADDRESS

struct	_XMSS_ADRS

struct	_SYMCRYPT_TREEHASH_NODE

struct	_SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

struct	_SYMCRYPT_INCREMENTAL_TREEHASH

Macros
#define	SYMCRYPT_DISABLE_CFG

#define	SYMCRYPT_FLAG_LIB_INITIALIZED 0x00000001

#define	TRUE (1)

#define	FALSE (0)

#define	UNREFERENCED_PARAMETER(x) ((void)x)

#define	FAST_FAIL_CRYPTO_LIBRARY 22

#define	NATIVE_BITS (32)

#define	NATIVE_BYTES (4)

#define	NATIVE_BYTES_LOG2 (2)

#define	CONCAT_I2(a, b) a##b

#define	CONCAT_I3(a, b, c) a##b##c

#define	CONCAT2(a, b) CONCAT_I2( a, b )

#define	CONCAT3(a, b, c) CONCAT_I3( a, b, c )

#define	SYMCRYPT_XXX_STATE CONCAT3( SYMCRYPT_, ALG, _STATE )

#define	PSYMCRYPT_XXX_STATE CONCAT3( PSYMCRYPT_, ALG, _STATE )

#define	PCSYMCRYPT_XXX_STATE CONCAT3( PCSYMCRYPT_, ALG, _STATE )

#define	SYMCRYPT_Xxx CONCAT2( SymCrypt, Alg )

#define	SYMCRYPT_XxxStateCopy CONCAT3( SymCrypt, Alg, StateCopy )

#define	SYMCRYPT_XxxInit CONCAT3( SymCrypt, Alg, Init )

#define	SYMCRYPT_XxxAppend CONCAT3( SymCrypt, Alg, Append )

#define	SYMCRYPT_XxxResult CONCAT3( SymCrypt, Alg, Result )

#define	SYMCRYPT_XxxAppendBlocks CONCAT3( SymCrypt, Alg, AppendBlocks )

#define	SYMCRYPT_XxxStateImport CONCAT3( SymCrypt, Alg, StateImport)

#define	SYMCRYPT_XxxStateExport CONCAT3( SymCrypt, Alg, StateExport)

#define	SYMCRYPT_XXX_EXPANDED_KEY CONCAT3( SYMCRYPT_, ALG, _EXPANDED_KEY )

#define	PSYMCRYPT_XXX_EXPANDED_KEY CONCAT3( PSYMCRYPT_, ALG, _EXPANDED_KEY )

#define	PCSYMCRYPT_XXX_EXPANDED_KEY CONCAT3( PCSYMCRYPT_, ALG, _EXPANDED_KEY )

#define	SYMCRYPT_XxxEx CONCAT3( SymCrypt, Alg, Ex)

#define	SYMCRYPT_XxxDefault CONCAT3( SymCrypt, Alg, Default )

#define	SYMCRYPT_XxxExpandKey CONCAT3( SymCrypt, Alg, ExpandKey )

#define	SYMCRYPT_XxxExpandKeyEx CONCAT3( SymCrypt, Alg, ExpandKeyEx )

#define	SYMCRYPT_XxxExtract CONCAT3( SymCrypt, Alg, Extract )

#define	SYMCRYPT_XxxResultEx CONCAT3( SymCrypt, Alg, ResultEx )

#define	SYMCRYPT_XxxKeyCopy CONCAT3( SymCrypt, Alg, KeyCopy )

#define	SYMCRYPT_HmacXxx CONCAT2( SymCryptHmac, Alg )

#define	SYMCRYPT_HmacXxxStateCopy CONCAT3( SymCryptHmac, Alg, StateCopy )

#define	SYMCRYPT_HmacXxxKeyCopy CONCAT3( SymCryptHmac, Alg, KeyCopy )

#define	SYMCRYPT_HmacXxxExpandKey CONCAT3( SymCryptHmac, Alg, ExpandKey )

#define	SYMCRYPT_HmacXxxInit CONCAT3( SymCryptHmac, Alg, Init )

#define	SYMCRYPT_HmacXxxAppend CONCAT3( SymCryptHmac, Alg, Append )

#define	SYMCRYPT_HmacXxxResult CONCAT3( SymCryptHmac, Alg, Result )

#define	SYMCRYPT_XXX_INPUT_BLOCK_SIZE CONCAT3( SYMCRYPT_, ALG, _INPUT_BLOCK_SIZE )

#define	SYMCRYPT_XXX_RESULT_SIZE CONCAT3( SYMCRYPT_, ALG, _RESULT_SIZE )

#define	SYMCRYPT_HMAC_XXX_INPUT_BLOCK_SIZE SYMCRYPT_XXX_INPUT_BLOCK_SIZE

#define	SYMCRYPT_HMAC_XXX_RESULT_SIZE SYMCRYPT_XXX_RESULT_SIZE

#define	PSYMCRYPT_HMAC_XXX_EXPANDED_KEY CONCAT3( PSYMCRYPT_HMAC_, ALG, _EXPANDED_KEY )

#define	PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY CONCAT3( PCSYMCRYPT_HMAC_, ALG, _EXPANDED_KEY )

#define	SYMCRYPT_HMAC_XXX_STATE CONCAT3( SYMCRYPT_HMAC_, ALG, _STATE )

#define	PSYMCRYPT_HMAC_XXX_STATE CONCAT3( PSYMCRYPT_HMAC_, ALG, _STATE )

#define	PCSYMCRYPT_HMAC_XXX_STATE CONCAT3( PCSYMCRYPT_HMAC_, ALG, _STATE )

#define	HMAC_IPAD_BYTE 0x36

#define	HMAC_OPAD_BYTE 0x5c

#define	SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE (SYMCRYPT_CPU_FEATURE_PCLMULQDQ \| SYMCRYPT_CPU_FEATURE_SSSE3 \| SYMCRYPT_CPU_FEATURE_SAVEXMM_NOFAIL )

#define	SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE (SYMCRYPT_CPU_FEATURE_SSSE3 \| SYMCRYPT_CPU_FEATURE_AESNI)

#define	SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE (SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE \| SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE)

#define	SYMCRYPT_CPU_FEATURES_FOR_VAES_256_CODE (SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE \| SYMCRYPT_CPU_FEATURE_AVX2 \| SYMCRYPT_CPU_FEATURE_VAES)

#define	SYMCRYPT_CPU_FEATURES_FOR_VAES_512_CODE (SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE \| SYMCRYPT_CPU_FEATURE_AVX512 \| SYMCRYPT_CPU_FEATURE_VAES)

#define	SYMCRYPT_CPU_FEATURES_FOR_SHANI_CODE (SYMCRYPT_CPU_FEATURE_SSSE3 \| SYMCRYPT_CPU_FEATURE_SHANI)

#define	SYMCRYPT_CPU_FEATURES_FOR_MULX (SYMCRYPT_CPU_FEATURE_BMI2 \| SYMCRYPT_CPU_FEATURE_ADX \| SYMCRYPT_CPU_FEATURE_SSE2 )

#define	ROL16(x, n) ((UINT16)( ( ((x) << (n)) \| ((x) >> (16-(n))) ) ))

#define	ROR16(x, n) ((UINT16)( ( ((x) >> (n)) \| ((x) << (16-(n))) ) ))

#define	SYMCRYPT_ARRAY_SIZE(_x) (sizeof(_x)/sizeof(_x[0]))

#define	REPEAT_BYTE_TO_UINT32(x) (((UINT32)x << 24) \| ((UINT32)x << 16) \| ((UINT32)x << 8) \| x)

#define	REPEAT_BYTE_TO_UINT64(x) ( ((UINT64)REPEAT_BYTE_TO_UINT32(x) << 32) \| REPEAT_BYTE_TO_UINT32(x) )

#define	SYMCRYPT_CPUID_DETECT_FLAG_CHECK_OS_SUPPORT_FOR_YMM 1

#define	SYMCRYPT_BLOB_MAGIC ('cmys')

#define	GCM_YMM_MINBLOCKS 16

#define	PAR_SCRATCH_ELEMENTS_256 (4+8+64)

#define	PAR_SCRATCH_ELEMENTS_512 (4+8+80)

#define	SYMCRYPT_SHA3_PADDING_VALUE 0x06

#define	SYMCRYPT_SHAKE_PADDING_VALUE 0x1f

#define	SYMCRYPT_CSHAKE_PADDING_VALUE 0x04

#define	SYMCRYPT_ASSERT_ASYM_ALIGNED(_p) SYMCRYPT_ASSERT( ((SIZE_T)(_p) & (SYMCRYPT_ASYM_ALIGN_VALUE - 1)) == 0 );

#define	SYMCRYPT_FDEF_DIGIT_NUINT32 ((UINT32)(SYMCRYPT_FDEF_DIGIT_SIZE / sizeof( UINT32 ) ))

#define	SYMCRYPT_OBJ_NDIGITS(_p) ((_p)->nDigits)

#define	SYMCRYPT_OBJ_NBYTES(_p) ((_p)->nDigits * SYMCRYPT_FDEF_DIGIT_SIZE)

#define	SYMCRYPT_OBJ_NUINT32(_p) ((_p)->nDigits * SYMCRYPT_FDEF_DIGIT_SIZE / sizeof( UINT32 ))

#define	SYMCRYPT_MODULAR_FUNCTIONS_SIZE (sizeof( SYMCRYPT_MODULAR_FUNCTIONS ) )

#define	SYMCRYPT_MODULUS_FEATURE_MONTGOMERY 1

#define	SYMCRYPT_MODULUS_FEATURE_NISTP384 8

#define	SYMCRYPT_MOD_CALL(v) ((SYMCRYPT_MODULAR_FUNCTIONS *)(( SYMCRYPT_FORCE_READ32( &(v)->type) & g_SymCryptModFnsMask) + (PBYTE)(&g_SymCryptModFns) ))->

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_GENERIC

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_ARM64256

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_ARM64P384

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX256

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULXP256

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX384

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULXP384

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF369_MONTGOMERY

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY512

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY1024

#define	SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX1024

#define	SYMCRYPT_RUN_SELFTEST_ONCE(AlgorithmSelftestFunction, AlgorithmSelftestFlag)

#define	SYMCRYPT_RUN_KEY_GEN_PCT(KeySelftestFunction, Key, KeySelftestFlag)

#define	CHECK_ALGORITHM_INFO_FLAG_POW2(flag) C_ASSERT( (flag != 0) && ((flag & (flag-1)) == 0) );

#define	CHECK_ALGORITHM_INFO_FLAGS_DISTINCT(flag0, flag1, flag2, flag3, flag4) C_ASSERT( (flag0 < flag1) && (flag1 < flag2) && (flag2 < flag3) && (flag3 < flag4) );

#define	SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT (10)

#define	SYMCRYPT_ECURVE_FUNCTIONS_SIZE (sizeof( SYMCRYPT_ECURVE_FUNCTIONS ) )

#define	SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS (256)

#define	SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P256 (65)

#define	SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P384 (97)

#define	SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_CURVE_25519 (32)

#define	SYMCRYPT_COMPOSITE_SIZEOF_MAX_ENCODED_EC_PUBLIC_KEY SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P384

#define	SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P256 (51)

#define	SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P384 (64)

#define	SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_CURVE_25519 (32)

#define	SYMCRYPT_SIZEOF_TREEHASH_NODE(cbValue) (sizeof(SYMCRYPT_TREEHASH_NODE) - 1 + (cbValue))

#define	SYMCRYPT_TREEHASH_NODE_GET(aNodes, cbValue, i) ((PSYMCRYPT_TREEHASH_NODE)((PBYTE)(aNodes) + (i) * SYMCRYPT_SIZEOF_TREEHASH_NODE(cbValue)))

#define	SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH(w) ( ((w) == 1) \|\| ((w) == 2) \|\| ((w) == 4) \|\| ((w) == 8) )

#define	SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE 16

#define	SYMCRYPT_LMS_MAX_N 32

#define	SYMCRYPT_LMS_MAX_P 265

#define	SYMCRYPT_LMS_MAX_H 25

#define	SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT 31

#define	SYMCRYPT_LMS_CHECKSUM_SIZE 16

#define	SYMCRYPT_LMS_PUB_KEY_SIZE(cbHashOutput) (8 + SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE + cbHashOutput)

#define	SYMCRYPT_LMS_PRIV_KEY_SIZE(cbHashOutput) (SYMCRYPT_LMS_PUB_KEY_SIZE(cbHashOutput) + sizeof(UINT32) + cbHashOutput)

Typedefs
typedef int	BOOL

typedef INT32	NATIVE_INT

typedef UINT32	NATIVE_UINT

typedef enum _SYMCRYPT_BLOB_TYPE	SYMCRYPT_BLOB_TYPE

typedef struct _SYMCRYPT_BLOB_HEADER	SYMCRYPT_BLOB_HEADER

typedef struct _SYMCRYPT_BLOB_HEADER *	PSYMCRYPT_BLOB_HEADER

typedef struct _SYMCRYPT_BLOB_TRAILER	SYMCRYPT_BLOB_TRAILER

typedef struct _SYMCRYPT_BLOB_TRAILER *	PSYMCRYPT_BLOB_TRAILER

typedef struct _SYMCRYPT_MD2_STATE_EXPORT_BLOB	SYMCRYPT_MD2_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_MD4_STATE_EXPORT_BLOB	SYMCRYPT_MD4_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_MD5_STATE_EXPORT_BLOB	SYMCRYPT_MD5_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_SHA1_STATE_EXPORT_BLOB	SYMCRYPT_SHA1_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_SHA256_STATE_EXPORT_BLOB	SYMCRYPT_SHA256_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_SHA512_STATE_EXPORT_BLOB	SYMCRYPT_SHA512_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_KECCAK_STATE_EXPORT_BLOB	SYMCRYPT_KECCAK_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB	SYMCRYPT_SHA3_224_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB	SYMCRYPT_SHA3_256_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB	SYMCRYPT_SHA3_384_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB	SYMCRYPT_SHA3_512_STATE_EXPORT_BLOB

typedef VOID(SYMCRYPT_CALL *	SYMCRYPT_MOD_BINARY_OP_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	SYMCRYPT_MOD_UNARY_OP_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef SYMCRYPT_ERROR(SYMCRYPT_CALL *	SYMCRYPT_MOD_UNARY_OP_FLAG_STATUS_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	SYMCRYPT_MOD_SET_POST_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef PCUINT32(SYMCRYPT_CALL *	SYMCRYPT_MOD_PRE_GET_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	SYMCRYPT_MOD_COPY_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst)

typedef VOID(SYMCRYPT_CALL *	SYMCRYPT_MODULUS_COPYFIXUP_FN) (_In_ PCSYMCRYPT_MODULUS pmSrc, _Out_ PSYMCRYPT_MODULUS pmDst)

typedef VOID(SYMCRYPT_CALL *	SYMCRYPT_MODULUS_INIT_FN) (_Inout_ PSYMCRYPT_MODULUS pmObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef struct _SYMCRYPT_MODULAR_FUNCTIONS	SYMCRYPT_MODULAR_FUNCTIONS

typedef struct _SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY	SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

typedef struct _SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY *	PSYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

typedef const SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY *	PCSYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

typedef struct _SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

typedef const SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS *	PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_SET_ZERO_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_SET_DISTINGUISHED_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_SET_RANDOM_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_INT piScalar, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef UINT32(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_ISEQUAL_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef UINT32(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_ONCURVE_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef UINT32(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_ISZERO_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_ADD_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_ADD_DIFF_NONZERO_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_DOUBLE_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_NEGATE_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Inout_ PSYMCRYPT_ECPOINT poSrc, UINT32 mask, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef SYMCRYPT_ERROR(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_SCALAR_MUL_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_INT piScalar, _In_opt_ PCSYMCRYPT_ECPOINT poSrc, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef SYMCRYPT_ERROR(SYMCRYPT_CALL *	PSYMCRYPT_ECPOINT_MULTI_SCALAR_MUL_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_reads_(nPoints) PCSYMCRYPT_INT piSrcScalarArray, _In_reads_(nPoints) PCSYMCRYPT_ECPOINT poSrcEcpointArray, UINT32 nPoints, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_ECURVE_FILL_SCRATCH_SPACES_FUNC) (_Inout_ PSYMCRYPT_ECURVE pCurve)

typedef struct _SYMCRYPT_ECURVE_FUNCTIONS	SYMCRYPT_ECURVE_FUNCTIONS

typedef struct _SYMCRYPT_ECURVE_FUNCTIONS *	PSYMCRYPT_ECURVE_FUNCTIONS

typedef const SYMCRYPT_ECURVE_FUNCTIONS *	PCSYMCRYPT_ECURVE_FUNCTIONS

typedef enum SYMCRYPT_CACHED_ECURVE_ID *	PSYMCRYPT_CACHED_ECURVE_ID

typedef struct _SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS	SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

typedef struct _SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS *	PSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

typedef const SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS *	PCSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

typedef SYMCRYPT_ASYM_ALIGN_STRUCT	_SYMCRYPT_COMPOSITE_MLKEMKEY

typedef const SYMCRYPT_COMPOSITE_MLKEMKEY *	PCSYMCRYPT_COMPOSITE_MLKEMKEY

typedef enum _XMSS_ADRS_TYPE	XMSS_ADRS_TYPE

typedef struct _XMSS_OTS_ADDRESS	XMSS_OTS_ADDRESS

typedef struct _XMSS_OTS_ADDRESS *	PXMSS_OTS_ADDRESS

typedef struct _XMSS_LTREE_ADDRESS	XMSS_LTREE_ADDRESS

typedef struct _XMSS_LTREE_ADDRESS *	PXMSS_LTREE_ADDRESS

typedef struct _XMSS_HASHTREE_ADDRESS	XMSS_HASHTREE_ADDRESS

typedef struct _XMSS_HASHTREE_ADDRESS *	PXMSS_HASHTREE_ADDRESS

typedef struct _XMSS_ADRS	XMSS_ADRS

typedef struct _XMSS_ADRS *	PXMSS_ADRS

typedef SYMCRYPT_ASYM_ALIGN_STRUCT	_SYMCRYPT_XMSS_KEY

typedef SYMCRYPT_XMSS_KEY *	PSYMCRYPT_XMSS_KEY

typedef struct _SYMCRYPT_TREEHASH_NODE	SYMCRYPT_TREEHASH_NODE

typedef struct _SYMCRYPT_TREEHASH_NODE *	PSYMCRYPT_TREEHASH_NODE

typedef struct _SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT	SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

typedef struct _SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT *	PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

typedef VOID(SYMCRYPT_CALL *	PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC) (_In_ PSYMCRYPT_TREEHASH_NODE pNodeLeft, _In_ PSYMCRYPT_TREEHASH_NODE pNodeRight, _Out_ PSYMCRYPT_TREEHASH_NODE pNodeOut, _Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pContext)

typedef struct _SYMCRYPT_INCREMENTAL_TREEHASH	SYMCRYPT_INCREMENTAL_TREEHASH

typedef struct _SYMCRYPT_INCREMENTAL_TREEHASH *	PSYMCRYPT_INCREMENTAL_TREEHASH

typedef SYMCRYPT_ASYM_ALIGN_STRUCT	_SYMCRYPT_LMS_KEY

typedef SYMCRYPT_LMS_KEY *	PSYMCRYPT_LMS_KEY

typedef const SYMCRYPT_LMS_KEY *	PCSYMCRYPT_LMS_KEY

Enumerations
enum	{ STATE_NEXT = 0 , STATE_DATA_START , STATE_DATA_END , STATE_RESULT2 , STATE_RESULT_DONE }

enum	_SYMCRYPT_BLOB_TYPE { SymCryptBlobTypeUnknown = 0 , SymCryptBlobTypeHashState = 0x100 , SymCryptBlobTypeMd2State = SymCryptBlobTypeHashState + 1 , SymCryptBlobTypeMd4State = SymCryptBlobTypeHashState + 2 , SymCryptBlobTypeMd5State = SymCryptBlobTypeHashState + 3 , SymCryptBlobTypeSha1State = SymCryptBlobTypeHashState + 4 , SymCryptBlobTypeSha256State = SymCryptBlobTypeHashState + 5 , SymCryptBlobTypeSha384State = SymCryptBlobTypeHashState + 6 , SymCryptBlobTypeSha512State = SymCryptBlobTypeHashState + 7 , SymCryptBlobTypeSha3_256State = SymCryptBlobTypeHashState + 8 , SymCryptBlobTypeSha3_384State = SymCryptBlobTypeHashState + 9 , SymCryptBlobTypeSha3_512State = SymCryptBlobTypeHashState + 10 , SymCryptBlobTypeSha224State = SymCryptBlobTypeHashState + 11 , SymCryptBlobTypeSha512_224State = SymCryptBlobTypeHashState + 12 , SymCryptBlobTypeSha512_256State = SymCryptBlobTypeHashState + 13 , SymCryptBlobTypeSha3_224State = SymCryptBlobTypeHashState + 14 }

enum	SYMCRYPT_CACHED_ECURVE_ID { SYMCRYPT_CACHED_ECURVE_ID_NIST_P256 = 0 , SYMCRYPT_CACHED_ECURVE_ID_NIST_P384 , SYMCRYPT_CACHED_ECURVE_ID_CURVE_25519 , SYMCRYPT_CACHED_ECURVE_ID_COUNT }

enum	_XMSS_ADRS_TYPE { XMSS_ADRS_TYPE_OTS = 0 , XMSS_ADRS_TYPE_LTREE = 1 , XMSS_ADRS_TYPE_HASH_TREE = 2 }

Functions
VOID SYMCRYPT_CALL	SymCryptInitEnvCommon (UINT32 version)

_Analysis_noreturn_ VOID SYMCRYPT_CALL	SymCryptFatalHang (UINT32 fatalcode)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptCheckLibraryInitialized (void)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptUint32ToMsbFirst (_In_reads_(cuData) PCUINT32 puData, _Out_writes_(4 *cuData) PBYTE pbResult, SIZE_T cuData)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptMsbFirstToUint32 (_In_reads_(4 *cuResult) PCBYTE pbData, _Out_writes_(cuResult) PUINT32 puResult, SIZE_T cuResult)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptUint32ToLsbFirst (_In_reads_(cuData) PCUINT32 puData, _Out_writes_(4 *cuData) PBYTE pbResult, SIZE_T cuData)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptLsbFirstToUint32 (_In_reads_(4 *cuResult) PCBYTE pbData, _Out_writes_(cuResult) PUINT32 puResult, SIZE_T cuResult)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptUint64ToLsbFirst (_In_reads_(cuData) PCUINT64 puData, _Out_writes_(8 *cuData) PBYTE pbResult, SIZE_T cuData)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptLsbFirstToUint64 (_In_reads_(8 *cuResult) PCBYTE pbData, _Out_writes_(cuResult) PUINT64 puResult, SIZE_T cuResult)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptUint64ToMsbFirst (_In_reads_(cuData) PCUINT64 puData, _Out_writes_(8 *cuData) PBYTE pbResult, SIZE_T cuData)

FORCEINLINE VOID SYMCRYPT_CALL	SymCryptMsbFirstToUint64 (_In_reads_(8 *cuResult) PCBYTE pbData, _Out_writes_(cuResult) PUINT64 puResult, SIZE_T cuResult)

VOID SYMCRYPT_CALL	SymCryptSha1AppendBlocks (_Inout_ SYMCRYPT_SHA1_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha256AppendBlocks (_Inout_ SYMCRYPT_SHA256_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha256AppendBlocks_xmm_4blocks (_Inout_ SYMCRYPT_SHA256_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha256AppendBlocks_xmm_ssse3_asm (_Inout_ SYMCRYPT_SHA256_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha256AppendBlocks_ymm_8blocks (_Inout_ SYMCRYPT_SHA256_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha256AppendBlocks_ymm_avx2_asm (_Inout_ SYMCRYPT_SHA256_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks_xmm (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks_ymm_1block (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks_ymm_2blocks (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks_ymm_4blocks (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks_ymm_avx2_asm (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptSha512AppendBlocks_ymm_avx512vl_asm (_Inout_ SYMCRYPT_SHA512_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

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	SymCryptMd4AppendBlocks (_Inout_ SYMCRYPT_MD4_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

VOID SYMCRYPT_CALL	SymCryptMd2AppendBlocks (_Inout_ SYMCRYPT_MD2_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T pcbRemaining)

FORCEINLINE VOID SYMCRYPT_CALL	XorByteIntoBuffer (_Inout_updates_(8 *cqBuf) PBYTE pbBuf, SIZE_T cqBuf, BYTE v)

VOID SYMCRYPT_CALL	SymCryptGHashExpandKey (_Out_ PSYMCRYPT_GHASH_EXPANDED_KEY expandedKey, _In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE pH)

VOID SYMCRYPT_CALL	SymCryptGHashExpandKeyC (_Out_writes_(SYMCRYPT_GF128_FIELD_SIZE) PSYMCRYPT_GF128_ELEMENT expandedKey, _In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE pH)

VOID SYMCRYPT_CALL	SymCryptGHashExpandKeyX86 (_Out_ PSYMCRYPT_GHASH_EXPANDED_KEY expandedKey, _In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE pH)

VOID SYMCRYPT_CALL	SymCryptGHashExpandKeyAmd64 (_Out_writes_(SYMCRYPT_GF128_FIELD_SIZE) PSYMCRYPT_GF128_ELEMENT expandedKey, _In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE pH)

VOID SYMCRYPT_CALL	SymCryptGHashAppendData (_In_ PCSYMCRYPT_GHASH_EXPANDED_KEY expandedKey, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGHashAppendDataC (_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGHashAppendDataXmm (_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGHashAppendDataNeon (_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGHashAppendDataPclmulqdq (_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGHashResult (_In_ PCSYMCRYPT_GF128_ELEMENT pState, _Out_writes_(SYMCRYPT_GF128_BLOCK_SIZE) PBYTE pbResult)

VOID SYMCRYPT_CALL	SymCryptMarvin32AppendBlocks (_Inout_ PSYMCRYPT_MARVIN32_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptInjectError (PBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptDetectCpuFeaturesByCpuid (UINT32 flags)

VOID SYMCRYPT_CALL	SymCryptDetectCpuFeaturesFromRegisters (void)

VOID SYMCRYPT_CALL	SymCryptDetectCpuFeaturesFromRegistersNoTry (void)

VOID SYMCRYPT_CALL	SymCryptDetectCpuFeaturesFromIsProcessorFeaturePresent (void)

VOID SYMCRYPT_CALL	SymCryptCpuidExFunc (int cpuInfo[4], int function_id, int subfunction_id)

	C_ASSERT (sizeof(SYMCRYPT_MD2_STATE_EXPORT_BLOB)==SYMCRYPT_MD2_STATE_EXPORT_SIZE)

	C_ASSERT (sizeof(SYMCRYPT_MD4_STATE_EXPORT_BLOB)==SYMCRYPT_MD4_STATE_EXPORT_SIZE)

	C_ASSERT (sizeof(SYMCRYPT_MD5_STATE_EXPORT_BLOB)==SYMCRYPT_MD5_STATE_EXPORT_SIZE)

	C_ASSERT (sizeof(SYMCRYPT_SHA1_STATE_EXPORT_BLOB)==SYMCRYPT_SHA1_STATE_EXPORT_SIZE)

	C_ASSERT (sizeof(SYMCRYPT_SHA256_STATE_EXPORT_BLOB)==SYMCRYPT_SHA256_STATE_EXPORT_SIZE)

	C_ASSERT (sizeof(SYMCRYPT_SHA512_STATE_EXPORT_BLOB)==SYMCRYPT_SHA512_STATE_EXPORT_SIZE)

	C_ASSERT (sizeof(SYMCRYPT_SHA3_224_STATE_EXPORT_BLOB)==SYMCRYPT_SHA3_224_STATE_EXPORT_SIZE)

VOID SYMCRYPT_CALL	SymCryptAes4Sbox (_In_reads_(4) PCBYTE pIn, _Out_writes_(4) PBYTE pOut, BOOL UseSimd)

VOID SYMCRYPT_CALL	SymCryptAes4SboxC (_In_reads_(4) PCBYTE pIn, _Out_writes_(4) PBYTE pOut)

VOID SYMCRYPT_CALL	SymCryptAes4SboxXmm (_In_reads_(4) PCBYTE pIn, _Out_writes_(4) PBYTE pOut)

VOID SYMCRYPT_CALL	SymCryptAes4SboxNeon (_In_reads_(4) PCBYTE pIn, _Out_writes_(4) PBYTE pOut)

VOID SYMCRYPT_CALL	SymCryptAesCreateDecryptionRoundKey (_In_reads_(16) PCBYTE pEncryptionRoundKey, _Out_writes_(16) PBYTE pDecryptionRoundKey, BOOL UseSimd)

VOID SYMCRYPT_CALL	SymCryptAesCreateDecryptionRoundKeyC (_In_reads_(16) PCBYTE pEncryptionRoundKey, _Out_writes_(16) PBYTE pDecryptionRoundKey)

VOID SYMCRYPT_CALL	SymCryptAesCreateDecryptionRoundKeyXmm (_In_reads_(16) PCBYTE pEncryptionRoundKey, _Out_writes_(16) PBYTE pDecryptionRoundKey)

VOID SYMCRYPT_CALL	SymCryptAesCreateDecryptionRoundKeyNeon (_In_reads_(16) PCBYTE pEncryptionRoundKey, _Out_writes_(16) PBYTE pDecryptionRoundKey)

VOID SYMCRYPT_CALL	SymCryptAesEncryptC (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesEncryptAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesEncryptXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesEncryptNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesDecryptC (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesDecryptAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesDecryptXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesDecryptNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)

VOID SYMCRYPT_CALL	SymCryptAesEcbEncryptC (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesEcbEncryptAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesEcbEncryptXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesEcbEncryptNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesEcbDecryptC (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcEncryptAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcEncryptXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcEncryptNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcDecryptAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcDecryptXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcDecryptNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcMacXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCbcMacNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCtrMsb64Asm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCtrMsb64Xmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCtrMsb64Neon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCtrMsb32Xmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCtrMsb32Neon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesEncryptDataUnitC (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesDecryptDataUnitC (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesEncryptDataUnitAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesDecryptDataUnitAsm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesEncryptDataUnitXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE pbScratch, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesDecryptDataUnitXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE pbScratch, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesEncryptDataUnitZmm_2048 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE pbScratch, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesDecryptDataUnitZmm_2048 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE pbScratch, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesEncryptDataUnitYmm_2048 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE pbScratch, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesDecryptDataUnitYmm_2048 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE pbScratch, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesEncryptDataUnitNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsAesDecryptDataUnitNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsEncryptDataUnit (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptXtsDecryptDataUnit (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbTweakBlock, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmEncryptStitchedXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmDecryptStitchedXmm (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmEncryptStitchedYmm_2048 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmDecryptStitchedYmm_2048 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmEncryptStitchedNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmDecryptStitchedNeon (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT expandedKeyTable, _Inout_ PSYMCRYPT_GF128_ELEMENT pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmEncryptPart (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesGcmDecryptPart (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGcmEncryptPartTwoPass (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptGcmDecryptPartTwoPass (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptCtrMsb32 (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptAesCtrMsb32 (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptParallelHashProcess_serial (_In_ PCSYMCRYPT_PARALLEL_HASH pParHash, _Inout_updates_bytes_(nStates *pParHash->pHash->stateSize) PVOID pStates, SIZE_T nStates, _Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION pOperations, SIZE_T nOperations, _Out_writes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptParallelHashProcess (_In_ PCSYMCRYPT_PARALLEL_HASH pParHash, _Inout_updates_bytes_(nStates *pParHash->pHash->stateSize) PVOID pStates, SIZE_T nStates, _Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION pOperations, SIZE_T nOperations, _Out_writes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, UINT32 maxParallel)

VOID SYMCRYPT_CALL	SymCryptHashAppendInternal (_In_ PCSYMCRYPT_HASH pHash, _Inout_ PSYMCRYPT_COMMON_HASH_STATE pState, _In_reads_bytes_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptHashCommonPaddingMd4Style (_In_ PCSYMCRYPT_HASH pHash, _Inout_ PSYMCRYPT_COMMON_HASH_STATE pState)

VOID SYMCRYPT_CALL	SymCryptParallelSha256AppendBlocks_ymm (_Inout_updates_(8) PSYMCRYPT_SHA256_CHAINING_STATE pChain, _Inout_updates_(8) PCBYTE ppByte, SIZE_T nBytes, _Out_writes_(PAR_SCRATCH_ELEMENTS_256 *32) PBYTE pScratch)

VOID SYMCRYPT_CALL	SymCryptParallelSha512AppendBlocks_ymm (_Inout_updates_(4) PSYMCRYPT_SHA512_CHAINING_STATE pChain, _Inout_updates_(4) PCBYTE ppByte, SIZE_T nBytes, _Out_writes_(PAR_SCRATCH_ELEMENTS_512 *32) PBYTE pScratch)

VOID SYMCRYPT_CALL	SymCryptKeccakPermute (_Inout_updates_(25) UINT64 *pState)

VOID SYMCRYPT_CALL	SymCryptKeccakInit (_Out_ PSYMCRYPT_KECCAK_STATE pState, UINT32 inputBlockSize, UINT8 padding)

VOID SYMCRYPT_CALL	SymCryptKeccakReset (_Out_ PSYMCRYPT_KECCAK_STATE pState)

VOID SYMCRYPT_CALL	SymCryptKeccakZeroAppendBlock (_Inout_ PSYMCRYPT_KECCAK_STATE pState)

VOID SYMCRYPT_CALL	SymCryptKeccakAppend (_Inout_ PSYMCRYPT_KECCAK_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)

VOID SYMCRYPT_CALL	SymCryptKeccakExtract (_Inout_ PSYMCRYPT_KECCAK_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)

VOID SYMCRYPT_CALL	SymCryptKeccakStateExport (SYMCRYPT_BLOB_TYPE type, _In_ PCSYMCRYPT_KECCAK_STATE pState, _Out_writes_bytes_(SYMCRYPT_KECCAK_STATE_EXPORT_SIZE) PBYTE pbBlob)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptKeccakStateImport (SYMCRYPT_BLOB_TYPE type, _Out_ PSYMCRYPT_KECCAK_STATE pState, _In_reads_bytes_(SYMCRYPT_KECCAK_STATE_EXPORT_SIZE) PCBYTE pbBlob)

VOID SYMCRYPT_CALL	SymCryptKeccakAppendEncodeTimes8 (_Inout_ SYMCRYPT_KECCAK_STATE *pState, UINT64 uValue, BOOLEAN bLeftEncode)

VOID SYMCRYPT_CALL	SymCryptKeccakAppendEncodedString (_Inout_ PSYMCRYPT_KECCAK_STATE pState, _In_reads_(cbString) PCBYTE pbString, SIZE_T cbString)

VOID SYMCRYPT_CALL	SymCryptCShakeEncodeInputStrings (_Inout_ PSYMCRYPT_KECCAK_STATE pState, _In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)

VOID SYMCRYPT_CALL	SymCryptFatalIntercept (UINT32 fatalCode)

	C_ASSERT ((SYMCRYPT_MODULAR_FUNCTIONS_SIZE &(SYMCRYPT_MODULAR_FUNCTIONS_SIZE-1))==0)

VOID SYMCRYPT_CALL	SymCryptFdefMaskedCopy (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCBYTE pbSrc, _Inout_updates_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE pbDst, UINT32 nDigits, UINT32 mask)

VOID SYMCRYPT_CALL	SymCryptFdefConditionalSwap (_Inout_updates_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE pbSrc1, _Inout_updates_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE pbSrc2, UINT32 nDigits, UINT32 cond)

VOID SYMCRYPT_CALL	SymCryptFdefClaimScratch (PBYTE pbScratch, SIZE_T cbScratch, SIZE_T cbMin)

UINT32	SymCryptFdefDigitsFromBits (UINT32 nBits)

PSYMCRYPT_INT SYMCRYPT_CALL	SymCryptFdefIntAllocate (UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefSizeofIntFromDigits (UINT32 nDigits)

PSYMCRYPT_INT SYMCRYPT_CALL	SymCryptFdefIntCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nDigits)

VOID	SymCryptFdefIntCopy (_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)

VOID	SymCryptFdefIntMaskedCopy (_In_ PCSYMCRYPT_INT piSrc, _Inout_ PSYMCRYPT_INT piDst, UINT32 mask)

VOID SYMCRYPT_CALL	SymCryptFdefIntConditionalCopy (_In_ PCSYMCRYPT_INT piSrc, _Inout_ PSYMCRYPT_INT piDst, UINT32 cond)

VOID SYMCRYPT_CALL	SymCryptFdefIntConditionalSwap (_Inout_ PSYMCRYPT_INT piSrc1, _Inout_ PSYMCRYPT_INT piSrc2, UINT32 cond)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntBitsizeOfObject (_In_ PCSYMCRYPT_INT piSrc)

UINT32 SYMCRYPT_CALL	SymCryptFdefNumberofDigitsFromInt (_In_ PCSYMCRYPT_INT piSrc)

SYMCRYPT_ERROR	SymCryptFdefIntCopyMixedSize (_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntBitsizeOfValue (_In_ PCSYMCRYPT_INT piSrc)

VOID SYMCRYPT_CALL	SymCryptFdefIntSetValueUint32 (UINT32 u32Src, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntSetValueUint64 (UINT64 u64Src, _Out_ PSYMCRYPT_INT piDst)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefIntSetValue (_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT format, _Out_ PSYMCRYPT_INT piDst)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefIntGetValue (_In_ PCSYMCRYPT_INT piSrc, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_NUMBER_FORMAT format)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntGetValueLsbits32 (_In_ PCSYMCRYPT_INT piSrc)

UINT64 SYMCRYPT_CALL	SymCryptFdefIntGetValueLsbits64 (_In_ PCSYMCRYPT_INT piSrc)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntAddUint32 (_In_ PCSYMCRYPT_INT piSrc1, UINT32 u32Src2, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntAddSameSize (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntAddMixedSize (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntSubUint32 (_In_ PCSYMCRYPT_INT piSrc1, UINT32 u32Src2, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntSubSameSize (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntSubMixedSize (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntNeg (_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntMulPow2 (_In_ PCSYMCRYPT_INT piSrc, SIZE_T Exp, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntDivPow2 (_In_ PCSYMCRYPT_INT piSrc, SIZE_T exp, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntShr1 (UINT32 highestBit, _In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntModPow2 (_In_ PCSYMCRYPT_INT piSrc, SIZE_T exp, _Out_ PSYMCRYPT_INT piDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntGetBit (_In_ PCSYMCRYPT_INT piSrc, UINT32 iBit)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntGetBits (_In_ PCSYMCRYPT_INT piSrc, UINT32 iBit, UINT32 nBits)

VOID SYMCRYPT_CALL	SymCryptFdefIntSetBits (_In_ PSYMCRYPT_INT piDst, UINT32 value, UINT32 iBit, UINT32 nBits)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntIsEqualUint32 (_In_ PCSYMCRYPT_INT piSrc1, _In_ UINT32 u32Src2)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntIsEqual (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntIsLessThan (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntMulUint32 (_In_ PCSYMCRYPT_INT piSrc1, UINT32 Src2, _Out_ PSYMCRYPT_INT piDst)

VOID SYMCRYPT_CALL	SymCryptFdefIntMulSameSize (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefIntSquare (_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefIntMulMixedSize (_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

PSYMCRYPT_DIVISOR SYMCRYPT_CALL	SymCryptFdefDivisorAllocate (UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefSizeofDivisorFromDigits (UINT32 nDigits)

PSYMCRYPT_DIVISOR SYMCRYPT_CALL	SymCryptFdefDivisorCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nDigits)

PSYMCRYPT_DIVISOR SYMCRYPT_CALL	SymCryptFdefDivisorRetrieveHandle (_In_ PBYTE pbBuffer)

VOID	SymCryptFdefDivisorCopy (_In_ PCSYMCRYPT_DIVISOR pdSrc, _Out_ PSYMCRYPT_DIVISOR pdDst)

VOID	SymCryptFdefDivisorCopyFixup (_In_ PCSYMCRYPT_DIVISOR pSrc, _Out_ PSYMCRYPT_DIVISOR pDst)

PSYMCRYPT_INT SYMCRYPT_CALL	SymCryptFdefIntFromDivisor (_In_ PSYMCRYPT_DIVISOR pdSrc)

VOID SYMCRYPT_CALL	SymCryptFdefIntToDivisor (_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_DIVISOR pdDst, UINT32 totalOperations, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefIntDivMod (_In_ PCSYMCRYPT_INT piSrc, _In_ PCSYMCRYPT_DIVISOR pdDivisor, _Out_opt_ PSYMCRYPT_INT piQuotient, _Out_opt_ PSYMCRYPT_INT piRemainder, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefRawDivMod (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pNum, UINT32 nDigits, _In_ PCSYMCRYPT_DIVISOR pdDivisor, _Out_writes_opt_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pQuotient, _Out_writes_opt_(SYMCRYPT_OBJ_NUINT32(pdDivisor)) PUINT32 pRemainder, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

PSYMCRYPT_MODULUS SYMCRYPT_CALL	SymCryptFdefModulusAllocate (UINT32 nDigits)

VOID SYMCRYPT_CALL	SymCryptFdefModulusFree (_Out_ PSYMCRYPT_MODULUS pmObj)

UINT32 SYMCRYPT_CALL	SymCryptFdefSizeofModulusFromDigits (UINT32 nDigits)

PSYMCRYPT_MODULUS SYMCRYPT_CALL	SymCryptFdefModulusCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nDigits)

PSYMCRYPT_MODULUS SYMCRYPT_CALL	SymCryptFdefModulusRetrieveHandle (_In_ PBYTE pbBuffer)

VOID	SymCryptFdefModulusCopy (_In_ PCSYMCRYPT_MODULUS pmSrc, _Out_ PSYMCRYPT_MODULUS pmDst)

PSYMCRYPT_MODELEMENT SYMCRYPT_CALL	SymCryptFdefModElementAllocate (_In_ PCSYMCRYPT_MODULUS pmMod)

VOID SYMCRYPT_CALL	SymCryptFdefModElementFree (_In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peObj)

UINT32 SYMCRYPT_CALL	SymCryptFdefSizeofModElementFromModulus (PCSYMCRYPT_MODULUS pmMod)

PSYMCRYPT_MODELEMENT SYMCRYPT_CALL	SymCryptFdefModElementCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, PCSYMCRYPT_MODULUS pmMod)

PSYMCRYPT_MODELEMENT SYMCRYPT_CALL	SymCryptFdefModElementRetrieveHandle (_In_ PBYTE pbBuffer)

VOID SYMCRYPT_CALL	SymCryptFdefModElementWipe (_In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID	SymCryptFdefModElementCopy (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID	SymCryptFdefModElementMaskedCopy (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, UINT32 mask)

PSYMCRYPT_DIVISOR SYMCRYPT_CALL	SymCryptFdefDivisorFromModulus (_In_ PSYMCRYPT_MODULUS pmSrc)

VOID	SymCryptFdefModElementConditionalSwap (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peData1, _Inout_ PSYMCRYPT_MODELEMENT peData2, _In_ UINT32 cond)

PSYMCRYPT_INT SYMCRYPT_CALL	SymCryptFdefIntFromModulus (_In_ PSYMCRYPT_MODULUS pmSrc)

VOID SYMCRYPT_CALL	SymCryptFdefIntToModulus (_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_MODULUS pmDst, UINT32 averageOperations, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefIntToModElement (_In_ PCSYMCRYPT_INT piSrc, _In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModElementToIntGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_reads_bytes_(pmMod->nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc, _Out_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefRawSetValue (_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT format, _Out_writes_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst, UINT32 nDigits)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefModElementSetValueGeneric (_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT format, _In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModElementSetValueUint32Generic (UINT32 value, _In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModElementSetValueNegUint32 (UINT32 value, _In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefRawGetValue (_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_NUMBER_FORMAT format)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefModElementGetValue (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_NUMBER_FORMAT format, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptFdefModElementIsEqual (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2)

UINT32 SYMCRYPT_CALL	SymCryptFdefModElementIsZero (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc)

VOID SYMCRYPT_CALL	SymCryptFdefModAddGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModAddMulx256Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModAddMulx384Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModAdd256Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModAdd384Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdef369ModAddGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSubGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdef369ModSubGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSub256Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModSub384Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModNegGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSetPostGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSetPostMontgomery (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSetPostMontgomeryMulx256 (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSetPostMontgomeryMulxP384 (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdef369ModSetPostMontgomery (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

PCUINT32 SYMCRYPT_CALL	SymCryptFdefModPreGetGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

PCUINT32 SYMCRYPT_CALL	SymCryptFdefModPreGetMontgomery (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

PCUINT32 SYMCRYPT_CALL	SymCryptFdefModPreGetMontgomery256 (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

PCUINT32 SYMCRYPT_CALL	SymCryptFdef369ModPreGetMontgomery (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModulusCopyFixupGeneric (_In_ PCSYMCRYPT_MODULUS pmSrc, _Out_ PSYMCRYPT_MODULUS pmDst)

VOID SYMCRYPT_CALL	SymCryptFdefModulusCopyFixupMontgomery (_In_ PCSYMCRYPT_MODULUS pmSrc, _Out_ PSYMCRYPT_MODULUS pmDst)

VOID SYMCRYPT_CALL	SymCryptFdefModulusInitGeneric (_Inout_ PSYMCRYPT_MODULUS pmObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModulusInitMontgomeryInternal (_Inout_ PSYMCRYPT_MODULUS pmObj, UINT32 nUint32Used, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModulusInitMontgomery (_Inout_ PSYMCRYPT_MODULUS pmObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModulusInitMontgomery256 (_Inout_ PSYMCRYPT_MODULUS pmObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdef369ModulusInitMontgomery (_Inout_ PSYMCRYPT_MODULUS pmObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawAdd (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src2, _Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 Dst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawSub (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc2, _Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 pDst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawSubUint32 (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc1, UINT32 Src2, _Out_writes_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 pDst, UINT32 nDigits)

VOID SYMCRYPT_CALL	SymCryptFdefModMulGeneric (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomery (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomeryMulx256Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomeryMulxP384Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomery256Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomeryP384Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdef369ModMulMontgomery (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomeryMulx (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModMulMontgomeryMulx1024 (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareGeneric (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomery (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomeryMulx256Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomeryMulxP384Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomery256Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomeryP384Asm (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc1, _In_ PCSYMCRYPT_MODELEMENT pSrc2, _Out_ PSYMCRYPT_MODELEMENT pDst)

VOID SYMCRYPT_CALL	SymCryptFdef369ModSquareMontgomery (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomeryMulx (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSquareMontgomeryMulx1024 (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefRawMul (_In_reads_(nDigits1 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits1, _In_reads_(nDigits2 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits2, _Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawMulMulx (_In_reads_(nDigits1 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits1, _In_reads_(nDigits2 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits2, _Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawMulMulx1024 (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, _In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits, _Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawSquare (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_(2 nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawSquareMulx (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_(2 nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawSquareMulx1024 (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_(2 nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdef369RawMul (_In_reads_(nDigits1 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits1, _In_reads_(nDigits2 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits2, _Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawIsEqualUint32 (_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits, _In_ UINT32 u32Src2)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawNeg (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc1, UINT32 carryIn, _Out_writes_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 pDst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawMaskedAdd (_Inout_updates_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pAcc, _In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 mask, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawMaskedSub (_Inout_updates_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pAcc, _In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 mask, UINT32 nDigits)

VOID SYMCRYPT_CALL	SymCryptFdefModDivPow2 (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, UINT32 exp, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModDivSmallPow2 (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _In_range_(1, NATIVE_BITS) UINT32 exp, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModDivSmallPow2Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _In_range_(1, NATIVE_BITS) UINT32 exp, _Out_ PSYMCRYPT_MODELEMENT peDst)

VOID SYMCRYPT_CALL	SymCryptFdefModDivSmallPow2Mulx (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _In_range_(1, NATIVE_BITS) UINT32 exp, _Out_ PSYMCRYPT_MODELEMENT peDst)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefModInvGeneric (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefModInvMontgomery (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdefModInvMontgomery256 (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptFdef369ModInvMontgomery (_In_ PCSYMCRYPT_MODULUS pMod, _In_ PCSYMCRYPT_MODELEMENT pSrc, _Out_ PSYMCRYPT_MODELEMENT pDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptModExpGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peBase, _In_ PCSYMCRYPT_INT piExp, UINT32 nBitsExp, UINT32 flags, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptModMultiExpGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _In_reads_(nBases) PCSYMCRYPT_MODELEMENT peBaseArray, _In_reads_(nBases) PCSYMCRYPT_INT piExpArray, UINT32 nBases, UINT32 nBitsExp, UINT32 flags, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefModSetRandomGeneric (_In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawAddUint32 (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src1, UINT32 Src2, _Out_writes_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 Dst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawAddAsm (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src2, _Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 Dst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdef369RawAddAsm (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 Src2, _Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 Dst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawSubAsm (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc2, _Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 pDst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdef369RawSubAsm (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc2, _Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32 pDst, UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefRawIsLessThan (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc1, _In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32 pSrc2, UINT32 nDigits)

VOID SYMCRYPT_CALL	SymCryptFdefMaskedCopyAsm (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCBYTE pbSrc, _Inout_updates_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE pbDst, UINT32 nDigits, UINT32 mask)

VOID SYMCRYPT_CALL	SymCryptFdef369MaskedCopyAsm (_In_reads_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PCBYTE pbSrc, _Inout_updates_bytes_(nDigits SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE pbDst, UINT32 nDigits, UINT32 mask)

VOID SYMCRYPT_CALL	SymCryptFdefRawMulAsm (_In_reads_(nDigits1 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits1, _In_reads_(nDigits2 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits2, _Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawSquareAsm (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_(2 nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdef369RawMulAsm (_In_reads_(nDigits1 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits1, _In_reads_(nDigits2 SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits2, _Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawMul512Asm (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, _In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits, _Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawSquare512Asm (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_(2 nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawMul1024Asm (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, _In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc2, UINT32 nDigits, _Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefRawSquare1024Asm (_In_reads_(nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc, UINT32 nDigits, _Out_writes_(2 nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefMontgomeryReduceAsm (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefMontgomeryReduce256Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefMontgomeryReduce512Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefMontgomeryReduce1024Asm (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdef369MontgomeryReduce (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdef369MontgomeryReduceAsm (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefMontgomeryReduceMulx (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

VOID SYMCRYPT_CALL	SymCryptFdefMontgomeryReduceMulx1024 (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PUINT32 pSrc, _Out_ PUINT32 pDst)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_PCT_DSA)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_PCT_ECDSA)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_PCT_RSA_SIGN)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_KEY_NO_FIPS)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_DLKEY_DSA)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_DLKEY_DH)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_ECKEY_ECDSA)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_ECKEY_ECDH)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_RSAKEY_SIGN)

	CHECK_ALGORITHM_INFO_FLAG_POW2 (SYMCRYPT_FLAG_RSAKEY_ENCRYPT)

	CHECK_ALGORITHM_INFO_FLAGS_DISTINCT (SYMCRYPT_PCT_DSA, SYMCRYPT_FLAG_KEY_NO_FIPS, SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION, SYMCRYPT_FLAG_DLKEY_DSA, SYMCRYPT_FLAG_DLKEY_DH)

	CHECK_ALGORITHM_INFO_FLAGS_DISTINCT (SYMCRYPT_PCT_ECDSA, SYMCRYPT_FLAG_KEY_NO_FIPS, SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION, SYMCRYPT_FLAG_ECKEY_ECDSA, SYMCRYPT_FLAG_ECKEY_ECDH)

	CHECK_ALGORITHM_INFO_FLAGS_DISTINCT (SYMCRYPT_PCT_RSA_SIGN, SYMCRYPT_FLAG_KEY_NO_FIPS, SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION, SYMCRYPT_FLAG_RSAKEY_SIGN, SYMCRYPT_FLAG_RSAKEY_ENCRYPT)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptRsaSignVerifyPct (PCSYMCRYPT_RSAKEY pkRsakey)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptDsaPct (PCSYMCRYPT_DLKEY pkDlkey)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEcDsaPct (PCSYMCRYPT_ECKEY pkEckey)

	C_ASSERT ((SYMCRYPT_ECURVE_FUNCTIONS_SIZE &(SYMCRYPT_ECURVE_FUNCTIONS_SIZE-1))==0)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassFillScratchSpaces (_In_ PSYMCRYPT_ECURVE pCurve)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassSetZero (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassSetDistinguished (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptShortWeierstrassIsEqual (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptShortWeierstrassIsZero (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptShortWeierstrassOnCurve (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassAdd (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassAddDiffNonZero (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassDouble (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassNegate (_In_ PCSYMCRYPT_ECURVE pCurve, _Inout_ PSYMCRYPT_ECPOINT poSrc, UINT32 mask, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptShortWeierstrassDoubleSpecializedAm3 (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsFillScratchSpaces (_In_ PSYMCRYPT_ECURVE pCurve)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsSetDistinguished (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsAdd (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsAddDiffNonZero (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsDouble (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptTwistedEdwardsIsEqual (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptTwistedEdwardsOnCurve (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptTwistedEdwardsIsZero (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsSetZero (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptTwistedEdwardsNegate (_In_ PCSYMCRYPT_ECURVE pCurve, _Inout_ PSYMCRYPT_ECPOINT poSrc, UINT32 mask, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptMontgomeryFillScratchSpaces (_In_ PSYMCRYPT_ECURVE pCurve)

VOID SYMCRYPT_CALL	SymCryptMontgomerySetDistinguished (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptMontgomeryIsEqual (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

UINT32 SYMCRYPT_CALL	SymCryptMontgomeryIsZero (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptMontgomeryPointScalarMul (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_INT piScalar, _In_opt_ PCSYMCRYPT_ECPOINT poSrc, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptOfflinePrecomputation (_In_ PSYMCRYPT_ECURVE pCurve, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEcpointScalarMulFixedWindow (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_INT piScalar, _In_opt_ PCSYMCRYPT_ECPOINT poSrc, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEcpointMultiScalarMulWnafWithInterleaving (_In_ PCSYMCRYPT_ECURVE pCurve, _In_reads_(nPoints) PCSYMCRYPT_INT piSrcScalarArray, _In_reads_(nPoints) PCSYMCRYPT_ECPOINT poSrcEcpointArray, UINT32 nPoints, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptEcpointGenericSetRandom (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_INT piScalar, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptEcurveFillScratchSpaces (_Inout_ PSYMCRYPT_ECURVE pCurve)

UINT32 SYMCRYPT_CALL	SymCryptSizeofEcpointEx (UINT32 cbModElement, UINT32 numOfCoordinates)

PCSYMCRYPT_TRIALDIVISION_CONTEXT SYMCRYPT_CALL	SymCryptFdefCreateTrialDivisionContext (UINT32 nDigits)

UINT32 SYMCRYPT_CALL	SymCryptFdefIntFindSmallDivisor (_In_ PCSYMCRYPT_TRIALDIVISION_CONTEXT pContext, _In_ PCSYMCRYPT_INT piSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

VOID SYMCRYPT_CALL	SymCryptFdefFreeTrialDivisionContext (PCSYMCRYPT_TRIALDIVISION_CONTEXT pContext)

UINT64	SymCryptInverseMod2e64 (UINT64 m)

VOID SYMCRYPT_CALL	SymCryptEckeyWipePrivateState (_Inout_ PSYMCRYPT_ECKEY pkEckey)

VOID SYMCRYPT_CALL	SymCryptFixedWindowRecoding (UINT32 W, _Inout_ PSYMCRYPT_INT piK, _Inout_ PSYMCRYPT_INT piTmp, _Out_writes_(nRecodedDigits) PUINT32 absofKIs, _Out_writes_(nRecodedDigits) PUINT32 sigofKIs, UINT32 nRecodedDigits)

VOID SYMCRYPT_CALL	SymCryptWidthNafRecoding (UINT32 W, _Inout_ PSYMCRYPT_INT piK, _Out_writes_(nRecodedDigits) PUINT32 absofKIs, _Out_writes_(nRecodedDigits) PUINT32 sigofKIs, UINT32 nRecodedDigits)

VOID SYMCRYPT_CALL	SymCryptPositiveWidthNafRecoding (UINT32 W, _In_ PCSYMCRYPT_INT piK, UINT32 nBitsExp, _Out_writes_(nRecodedDigits) PUINT32 absofKIs, UINT32 nRecodedDigits)

PCSYMCRYPT_ECURVE SYMCRYPT_CALL	SymCryptGetCachedEcurve (SYMCRYPT_CACHED_ECURVE_ID curveId)

UINT32 SYMCRYPT_CALL	SymCryptCompositeGetSizeOfEncodedEcSk (SYMCRYPT_CACHED_ECURVE_ID curveId)

UINT32 SYMCRYPT_CALL	SymCryptCompositeGetSizeOfEncodedEcPk (SYMCRYPT_CACHED_ECURVE_ID curveId)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEckeyGetValueCompositeEncodingSk (_In_ PCSYMCRYPT_ECKEY pEckey, SYMCRYPT_CACHED_ECURVE_ID curveId, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEckeyGetValueCompositeEncodingPk (_In_ PCSYMCRYPT_ECKEY pEckey, SYMCRYPT_CACHED_ECURVE_ID curveId, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEckeySetValueCompositeEncodingPk (_In_ SYMCRYPT_CACHED_ECURVE_ID curveId, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, UINT32 flags, _Inout_ PSYMCRYPT_ECKEY pEckey)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptEckeySetValueCompositeEncodingSk (SYMCRYPT_CACHED_ECURVE_ID curveId, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, UINT32 flags, _Inout_ PSYMCRYPT_ECKEY pEckey)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptCompositeMlKemGetRandomScalarForEcKeyEx (SYMCRYPT_CACHED_ECURVE_ID ecurveId, SYMCRYPT_NUMBER_FORMAT numFormat, _In_reads_bytes_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed, _Out_writes_bytes_(cbScalar) PBYTE pbScalar, SIZE_T cbScalar)

SYMCRYPT_MAGIC_FIELD	SYMCRYPT_ALIGN_AT (16) UINT64 Idx

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptXmssComputePublicRoot (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed, _In_reads_bytes_(cbSkXmss) PCBYTE pbSkXmss, SIZE_T cbSkXmss, _Out_writes_bytes_(cbRoot) PBYTE pbRoot, SIZE_T cbRoot)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptXmsskeyVerifyRoot (_In_ PCSYMCRYPT_XMSS_KEY pKey)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptXmssVerifyInternal (_Inout_ PSYMCRYPT_XMSS_KEY pKey, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, UINT32 flags, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature)

VOID SYMCRYPT_CALL	SymCryptHbsGetWinternitzLengths (UINT32 n, UINT32 w, _Out_ PUINT32 puLen1, _Out_ PUINT32 puLen2)

PSYMCRYPT_INCREMENTAL_TREEHASH SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashInit (UINT32 nLeaves, PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 cbHashResult, PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC funcCompressNodes, PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pContext)

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashGetNode (_In_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, SIZE_T index)

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashAllocNode (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, UINT32 nLeafIndex)

VOID SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashGetTopNodes (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, _Out_ PSYMCRYPT_TREEHASH_NODE ppNodeLeft, _Out_ PSYMCRYPT_TREEHASH_NODE ppNodeRight)

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashProcessCommon (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, BOOLEAN fFinal)

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashProcess (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash)

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashFinalize (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash)

UINT32 SYMCRYPT_CALL	SymCryptHbsIncrementalTreehashStackDepth (UINT32 nLeaves)

SIZE_T SYMCRYPT_CALL	SymCryptHbsSizeofScratchBytesForIncrementalTreehash (UINT32 cbNode, UINT32 nLeaves)

UINT32 SYMCRYPT_CALL	SymCryptHbsGetDigit (UINT32 width, _In_ PCBYTE pbBuffer, SIZE_T cbBuffer, UINT32 index)

SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptLmsVerifyInternal (_In_ PCSYMCRYPT_LMS_KEY pKey, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, UINT32 flags, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature)

FORCEINLINE UINT32	SymCryptCountTrailingZeros32 (UINT32 value)

FORCEINLINE UINT32	SymCryptCountTrailingZeros64 (UINT64 value)

FORCEINLINE UINT32	SymCryptCountLeadingZeros32 (UINT32 value)

FORCEINLINE UINT32	SymCryptCountLeadingZeros64 (UINT64 value)

Variables
UINT32	g_SymCryptFlags

const BYTE	SymCryptTestMsg3 [3]

const BYTE	SymCryptTestMsg16 [16]

const BYTE	SymCryptTestKey32 [32]

const SYMCRYPT_BLOCKCIPHER	SymCryptAesBlockCipherNoOpt

const PCSYMCRYPT_PARALLEL_HASH	SymCryptParallelSha256Algorithm

const PCSYMCRYPT_PARALLEL_HASH	SymCryptParallelSha384Algorithm

const PCSYMCRYPT_PARALLEL_HASH	SymCryptParallelSha512Algorithm

const SYMCRYPT_HASH	SymCryptMd2Algorithm_default

const SYMCRYPT_HASH	SymCryptMd4Algorithm_default

const SYMCRYPT_HASH	SymCryptMd5Algorithm_default

const SYMCRYPT_HASH	SymCryptSha1Algorithm_default

const SYMCRYPT_HASH	SymCryptSha224Algorithm_default

const SYMCRYPT_HASH	SymCryptSha256Algorithm_default

const SYMCRYPT_HASH	SymCryptSha384Algorithm_default

const SYMCRYPT_HASH	SymCryptSha512Algorithm_default

const SYMCRYPT_HASH	SymCryptSha512_224Algorithm_default

const SYMCRYPT_HASH	SymCryptSha512_256Algorithm_default

const SYMCRYPT_HASH	SymCryptSha3_224Algorithm_default

const SYMCRYPT_HASH	SymCryptSha3_256Algorithm_default

const SYMCRYPT_HASH	SymCryptSha3_384Algorithm_default

const SYMCRYPT_HASH	SymCryptSha3_512Algorithm_default

const SYMCRYPT_HASH	SymCryptShake128HashAlgorithm_default

const SYMCRYPT_HASH	SymCryptShake256HashAlgorithm_default

const BYTE	SymCryptSha256KATAnswer [32]

const BYTE	SymCryptSha384KATAnswer [48]

const BYTE	SymCryptSha512KATAnswer [64]

const SYMCRYPT_MODULAR_FUNCTIONS	g_SymCryptModFns []

const UINT32	g_SymCryptModFnsMask

const SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY	SymCryptModulusTypeSelections []

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsModp2048

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsModp3072

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsModp4096

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsModp6144

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsModp8192

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsffdhe2048

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsffdhe3072

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsffdhe4096

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsffdhe6144

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptDlgroupDhSafePrimeParamsffdhe8192

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS	SymCryptNamedSafePrimeGroups [SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT]

const PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION	SymCryptEcurveParamsV2ExtensionShortWeierstrass

const PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION	SymCryptEcurveParamsV2ExtensionTwistedEdwards

const PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION	SymCryptEcurveParamsV2ExtensionMontgomery

const UINT32	SymCryptEcpointFormatNumberofElements [4]

PSYMCRYPT_MLKEMKEY	pkMlKemkey

PSYMCRYPT_ECKEY	pkEcKey

BOOLEAN	hasPrivateSeed

BYTE	privateSeed [SYMCRYPT_COMPOSITE_MLKEM_IRTF_PRIVATE_SEED_SIZE]

SYMCRYPT_MAGIC_FIELD	SYMCRYPT_COMPOSITE_MLKEMKEY

SYMCRYPT_MAGIC_FIELD *	PSYMCRYPT_COMPOSITE_MLKEMKEY

SYMCRYPT_XMSS_PARAMS	params

SYMCRYPT_XMSSKEY_TYPE	keyType

BYTE	Root [SYMCRYPT_HASH_MAX_RESULT_SIZE]

BYTE	Seed [SYMCRYPT_HASH_MAX_RESULT_SIZE]

BYTE	SkXmss [SYMCRYPT_HASH_MAX_RESULT_SIZE]

BYTE	SkPrf [SYMCRYPT_HASH_MAX_RESULT_SIZE]

	SYMCRYPT_XMSS_KEY

UINT64	nNextUnusedLeaf

BYTE	abId [SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE]

BYTE	abPublicRoot [SYMCRYPT_LMS_MAX_N]

BYTE	abSeed [SYMCRYPT_LMS_MAX_N]

SYMCRYPT_MAGIC_FIELD	SYMCRYPT_LMS_KEY

Macro Definition Documentation

◆ CHECK_ALGORITHM_INFO_FLAG_POW2

#define CHECK_ALGORITHM_INFO_FLAG_POW2 ( flag ) C_ASSERT( (flag != 0) && ((flag & (flag-1)) == 0) );

Definition at line 3708 of file sc_lib.h.

◆ CHECK_ALGORITHM_INFO_FLAGS_DISTINCT

#define CHECK_ALGORITHM_INFO_FLAGS_DISTINCT	(	flag0,
		flag1,
		flag2,
		flag3,
		flag4
	)	C_ASSERT( (flag0 < flag1) && (flag1 < flag2) && (flag2 < flag3) && (flag3 < flag4) );

Definition at line 3712 of file sc_lib.h.

◆ CONCAT2

#define CONCAT2	(	a,
		b
	)	CONCAT_I2( a, b )

Definition at line 110 of file sc_lib.h.

◆ CONCAT3

#define CONCAT3	(	a,
		b,
		c
	)	CONCAT_I3( a, b, c )

Definition at line 111 of file sc_lib.h.

◆ CONCAT_I2

#define CONCAT_I2	(	a,
		b
	)	a##b

Definition at line 106 of file sc_lib.h.

◆ CONCAT_I3

#define CONCAT_I3	(	a,
		b,
		c
	)	a##b##c

Definition at line 107 of file sc_lib.h.

◆ FALSE

#define FALSE (0)

Definition at line 50 of file sc_lib.h.

◆ FAST_FAIL_CRYPTO_LIBRARY

#define FAST_FAIL_CRYPTO_LIBRARY 22

Definition at line 58 of file sc_lib.h.

◆ GCM_YMM_MINBLOCKS

#define GCM_YMM_MINBLOCKS 16

Definition at line 1611 of file sc_lib.h.

◆ HMAC_IPAD_BYTE

#define HMAC_IPAD_BYTE 0x36

Definition at line 301 of file sc_lib.h.

◆ HMAC_OPAD_BYTE

#define HMAC_OPAD_BYTE 0x5c

Definition at line 302 of file sc_lib.h.

◆ NATIVE_BITS

#define NATIVE_BITS (32)

Definition at line 78 of file sc_lib.h.

◆ NATIVE_BYTES

#define NATIVE_BYTES (4)

Definition at line 79 of file sc_lib.h.

◆ NATIVE_BYTES_LOG2

#define NATIVE_BYTES_LOG2 (2)

Definition at line 80 of file sc_lib.h.

◆ PAR_SCRATCH_ELEMENTS_256

#define PAR_SCRATCH_ELEMENTS_256 (4+8+64)

Definition at line 1767 of file sc_lib.h.

◆ PAR_SCRATCH_ELEMENTS_512

#define PAR_SCRATCH_ELEMENTS_512 (4+8+80)

Definition at line 1768 of file sc_lib.h.

◆ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY

#define PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY CONCAT3( PCSYMCRYPT_HMAC_, ALG, _EXPANDED_KEY )

Definition at line 158 of file sc_lib.h.

◆ PCSYMCRYPT_HMAC_XXX_STATE

#define PCSYMCRYPT_HMAC_XXX_STATE CONCAT3( PCSYMCRYPT_HMAC_, ALG, _STATE )

Definition at line 161 of file sc_lib.h.

◆ PCSYMCRYPT_XXX_EXPANDED_KEY

#define PCSYMCRYPT_XXX_EXPANDED_KEY CONCAT3( PCSYMCRYPT_, ALG, _EXPANDED_KEY )

Definition at line 133 of file sc_lib.h.

◆ PCSYMCRYPT_XXX_STATE

#define PCSYMCRYPT_XXX_STATE CONCAT3( PCSYMCRYPT_, ALG, _STATE )

Definition at line 118 of file sc_lib.h.

◆ PSYMCRYPT_HMAC_XXX_EXPANDED_KEY

#define PSYMCRYPT_HMAC_XXX_EXPANDED_KEY CONCAT3( PSYMCRYPT_HMAC_, ALG, _EXPANDED_KEY )

Definition at line 157 of file sc_lib.h.

◆ PSYMCRYPT_HMAC_XXX_STATE

#define PSYMCRYPT_HMAC_XXX_STATE CONCAT3( PSYMCRYPT_HMAC_, ALG, _STATE )

Definition at line 160 of file sc_lib.h.

◆ PSYMCRYPT_XXX_EXPANDED_KEY

#define PSYMCRYPT_XXX_EXPANDED_KEY CONCAT3( PSYMCRYPT_, ALG, _EXPANDED_KEY )

Definition at line 132 of file sc_lib.h.

◆ PSYMCRYPT_XXX_STATE

#define PSYMCRYPT_XXX_STATE CONCAT3( PSYMCRYPT_, ALG, _STATE )

Definition at line 117 of file sc_lib.h.

◆ REPEAT_BYTE_TO_UINT32

#define REPEAT_BYTE_TO_UINT32 ( x ) (((UINT32)x << 24) | ((UINT32)x << 16) | ((UINT32)x << 8) | x)

Definition at line 889 of file sc_lib.h.

◆ REPEAT_BYTE_TO_UINT64

#define REPEAT_BYTE_TO_UINT64 ( x ) ( ((UINT64)REPEAT_BYTE_TO_UINT32(x) << 32) | REPEAT_BYTE_TO_UINT32(x) )

Definition at line 890 of file sc_lib.h.

◆ ROL16

#define ROL16	(	x,
		n
	)	((UINT16)( ( ((x) << (n)) \| ((x) >> (16-(n))) ) ))

Definition at line 324 of file sc_lib.h.

◆ ROR16

#define ROR16	(	x,
		n
	)	((UINT16)( ( ((x) >> (n)) \| ((x) << (16-(n))) ) ))

Definition at line 325 of file sc_lib.h.

◆ SYMCRYPT_ARRAY_SIZE

#define SYMCRYPT_ARRAY_SIZE ( _x ) (sizeof(_x)/sizeof(_x[0]))

Definition at line 342 of file sc_lib.h.

◆ SYMCRYPT_ASSERT_ASYM_ALIGNED

#define SYMCRYPT_ASSERT_ASYM_ALIGNED ( _p ) SYMCRYPT_ASSERT( ((SIZE_T)(_p) & (SYMCRYPT_ASYM_ALIGN_VALUE - 1)) == 0 );

Definition at line 1912 of file sc_lib.h.

◆ SYMCRYPT_BLOB_MAGIC

#define SYMCRYPT_BLOB_MAGIC ('cmys')

Definition at line 1077 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_CURVE_25519

#define SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_CURVE_25519 (32)

Definition at line 4377 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P256

#define SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P256 (51)

Definition at line 4375 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P384

#define SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P384 (64)

Definition at line 4376 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_CURVE_25519

#define SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_CURVE_25519 (32)

Definition at line 4371 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P256

#define SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P256 (65)

Definition at line 4369 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P384

#define SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P384 (97)

Definition at line 4370 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_SIZEOF_MAX_ENCODED_EC_PUBLIC_KEY

#define SYMCRYPT_COMPOSITE_SIZEOF_MAX_ENCODED_EC_PUBLIC_KEY SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P384

Definition at line 4373 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE

#define SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE (SYMCRYPT_CPU_FEATURE_SSSE3 | SYMCRYPT_CPU_FEATURE_AESNI)

Definition at line 307 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE

#define SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE (SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE | SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE)

Definition at line 308 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_MULX

#define SYMCRYPT_CPU_FEATURES_FOR_MULX (SYMCRYPT_CPU_FEATURE_BMI2 | SYMCRYPT_CPU_FEATURE_ADX | SYMCRYPT_CPU_FEATURE_SSE2 )

Definition at line 314 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE

#define SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE (SYMCRYPT_CPU_FEATURE_PCLMULQDQ | SYMCRYPT_CPU_FEATURE_SSSE3 | SYMCRYPT_CPU_FEATURE_SAVEXMM_NOFAIL )

Definition at line 305 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_SHANI_CODE

#define SYMCRYPT_CPU_FEATURES_FOR_SHANI_CODE (SYMCRYPT_CPU_FEATURE_SSSE3 | SYMCRYPT_CPU_FEATURE_SHANI)

Definition at line 312 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_VAES_256_CODE

#define SYMCRYPT_CPU_FEATURES_FOR_VAES_256_CODE (SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE | SYMCRYPT_CPU_FEATURE_AVX2 | SYMCRYPT_CPU_FEATURE_VAES)

Definition at line 309 of file sc_lib.h.

◆ SYMCRYPT_CPU_FEATURES_FOR_VAES_512_CODE

#define SYMCRYPT_CPU_FEATURES_FOR_VAES_512_CODE (SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE | SYMCRYPT_CPU_FEATURE_AVX512 | SYMCRYPT_CPU_FEATURE_VAES)

Definition at line 310 of file sc_lib.h.

◆ SYMCRYPT_CPUID_DETECT_FLAG_CHECK_OS_SUPPORT_FOR_YMM

#define SYMCRYPT_CPUID_DETECT_FLAG_CHECK_OS_SUPPORT_FOR_YMM 1

Definition at line 1025 of file sc_lib.h.

◆ SYMCRYPT_CSHAKE_PADDING_VALUE

#define SYMCRYPT_CSHAKE_PADDING_VALUE 0x04

Definition at line 1810 of file sc_lib.h.

◆ SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT

#define SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT (10)

Definition at line 3788 of file sc_lib.h.

◆ SYMCRYPT_DISABLE_CFG

#define SYMCRYPT_DISABLE_CFG

Definition at line 15 of file sc_lib.h.

◆ SYMCRYPT_ECURVE_FUNCTIONS_SIZE

#define SYMCRYPT_ECURVE_FUNCTIONS_SIZE (sizeof( SYMCRYPT_ECURVE_FUNCTIONS ) )

Definition at line 3922 of file sc_lib.h.

◆ SYMCRYPT_FDEF_DIGIT_NUINT32

#define SYMCRYPT_FDEF_DIGIT_NUINT32 ((UINT32)(SYMCRYPT_FDEF_DIGIT_SIZE / sizeof( UINT32 ) ))

Definition at line 1916 of file sc_lib.h.

◆ SYMCRYPT_FLAG_LIB_INITIALIZED

#define SYMCRYPT_FLAG_LIB_INITIALIZED 0x00000001

Definition at line 22 of file sc_lib.h.

◆ SYMCRYPT_HMAC_XXX_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_XXX_INPUT_BLOCK_SIZE SYMCRYPT_XXX_INPUT_BLOCK_SIZE

Definition at line 154 of file sc_lib.h.

◆ SYMCRYPT_HMAC_XXX_RESULT_SIZE

#define SYMCRYPT_HMAC_XXX_RESULT_SIZE SYMCRYPT_XXX_RESULT_SIZE

Definition at line 155 of file sc_lib.h.

◆ SYMCRYPT_HMAC_XXX_STATE

#define SYMCRYPT_HMAC_XXX_STATE CONCAT3( SYMCRYPT_HMAC_, ALG, _STATE )

Definition at line 159 of file sc_lib.h.

◆ SYMCRYPT_HmacXxx

#define SYMCRYPT_HmacXxx CONCAT2( SymCryptHmac, Alg )

Definition at line 142 of file sc_lib.h.

◆ SYMCRYPT_HmacXxxAppend

#define SYMCRYPT_HmacXxxAppend CONCAT3( SymCryptHmac, Alg, Append )

Definition at line 147 of file sc_lib.h.

◆ SYMCRYPT_HmacXxxExpandKey

#define SYMCRYPT_HmacXxxExpandKey CONCAT3( SymCryptHmac, Alg, ExpandKey )

Definition at line 145 of file sc_lib.h.

◆ SYMCRYPT_HmacXxxInit

#define SYMCRYPT_HmacXxxInit CONCAT3( SymCryptHmac, Alg, Init )

Definition at line 146 of file sc_lib.h.

◆ SYMCRYPT_HmacXxxKeyCopy

#define SYMCRYPT_HmacXxxKeyCopy CONCAT3( SymCryptHmac, Alg, KeyCopy )

Definition at line 144 of file sc_lib.h.

◆ SYMCRYPT_HmacXxxResult

#define SYMCRYPT_HmacXxxResult CONCAT3( SymCryptHmac, Alg, Result )

Definition at line 148 of file sc_lib.h.

◆ SYMCRYPT_HmacXxxStateCopy

#define SYMCRYPT_HmacXxxStateCopy CONCAT3( SymCryptHmac, Alg, StateCopy )

Definition at line 143 of file sc_lib.h.

◆ SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH

#define SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH ( w ) ( ((w) == 1) || ((w) == 2) || ((w) == 4) || ((w) == 8) )

Definition at line 4701 of file sc_lib.h.

◆ SYMCRYPT_LMS_CHECKSUM_SIZE

#define SYMCRYPT_LMS_CHECKSUM_SIZE 16

Definition at line 4707 of file sc_lib.h.

◆ SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE

#define SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE 16

Definition at line 4702 of file sc_lib.h.

◆ SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT

#define SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT 31

Definition at line 4706 of file sc_lib.h.

◆ SYMCRYPT_LMS_MAX_H

#define SYMCRYPT_LMS_MAX_H 25

Definition at line 4705 of file sc_lib.h.

◆ SYMCRYPT_LMS_MAX_N

#define SYMCRYPT_LMS_MAX_N 32

Definition at line 4703 of file sc_lib.h.

◆ SYMCRYPT_LMS_MAX_P

#define SYMCRYPT_LMS_MAX_P 265

Definition at line 4704 of file sc_lib.h.

◆ SYMCRYPT_LMS_PRIV_KEY_SIZE

#define SYMCRYPT_LMS_PRIV_KEY_SIZE ( cbHashOutput ) (SYMCRYPT_LMS_PUB_KEY_SIZE(cbHashOutput) + sizeof(UINT32) + cbHashOutput)

Definition at line 4713 of file sc_lib.h.

◆ SYMCRYPT_LMS_PUB_KEY_SIZE

#define SYMCRYPT_LMS_PUB_KEY_SIZE ( cbHashOutput ) (8 + SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE + cbHashOutput)

Definition at line 4710 of file sc_lib.h.

◆ SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS

#define SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS (256)

Definition at line 4347 of file sc_lib.h.

◆ SYMCRYPT_MOD_CALL

#define SYMCRYPT_MOD_CALL ( v ) ((SYMCRYPT_MODULAR_FUNCTIONS *)(( SYMCRYPT_FORCE_READ32( &(v)->type) & g_SymCryptModFnsMask) + (PBYTE)(&g_SymCryptModFns) ))->

Definition at line 2039 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF369_MONTGOMERY

#define SYMCRYPT_MOD_FUNCTIONS_FDEF369_MONTGOMERY

Value:

    {\
    &SymCryptFdef369ModAddGeneric,\
    &SymCryptFdef369ModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdef369ModMulMontgomery,\
    &SymCryptFdef369ModSquareMontgomery,\
    &SymCryptFdef369ModInvMontgomery,\
    &SymCryptFdef369ModSetPostMontgomery,\
    &SymCryptFdef369ModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdef369ModulusInitMontgomery,\
}

Definition at line 2145 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_GENERIC

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_GENERIC

Value:

    {\
    &SymCryptFdefModAddGeneric,\
    &SymCryptFdefModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdefModMulGeneric,\
    &SymCryptFdefModSquareGeneric,\
    &SymCryptFdefModInvGeneric,\
    &SymCryptFdefModSetPostGeneric,\
    &SymCryptFdefModPreGetGeneric,\
    &SymCryptFdefModulusCopyFixupGeneric,\
    &SymCryptFdefModulusInitGeneric,\
}

Definition at line 2041 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY

Value:

    {\
    &SymCryptFdefModAddGeneric,\
    &SymCryptFdefModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdefModMulMontgomery,\
    &SymCryptFdefModSquareMontgomery,\
    &SymCryptFdefModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomery,\
    &SymCryptFdefModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery,\
}

Definition at line 2054 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY1024

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY1024

Value:

    {\
    &SymCryptFdefModAddGeneric,\
    &SymCryptFdefModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdefModMulMontgomery1024,\
    &SymCryptFdefModSquareMontgomery1024,\
    &SymCryptFdefModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomery,\
    &SymCryptFdefModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery,\
}

Definition at line 2184 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY512

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY512

Value:

    {\
    &SymCryptFdefModAddGeneric,\
    &SymCryptFdefModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdefModMulMontgomery512,\
    &SymCryptFdefModSquareMontgomery512,\
    &SymCryptFdefModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomery,\
    &SymCryptFdefModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery,\
}

Definition at line 2171 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_ARM64256

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_ARM64256

Value:

    {\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModAdd256Asm,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModSub256Asm,\
    &SymCryptFdefModNegGeneric,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModMulMontgomery256Asm, \
    (SYMCRYPT_MOD_UNARY_OP_FN) &SymCryptFdefModSquareMontgomery256Asm, \
    &SymCryptFdefModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomery,\
    &SymCryptFdefModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery,\
}

Definition at line 2067 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_ARM64P384

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_ARM64P384

Value:

    {\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModAdd384Asm,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModSub384Asm,\
    &SymCryptFdefModNegGeneric,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModMulMontgomeryP384Asm, \
    (SYMCRYPT_MOD_UNARY_OP_FN) &SymCryptFdefModSquareMontgomeryP384Asm, \
    &SymCryptFdef369ModInvMontgomery,\
    &SymCryptFdef369ModSetPostMontgomery,\
    &SymCryptFdef369ModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdef369ModulusInitMontgomery,\
}

Definition at line 2080 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX

Value:

    {\
    &SymCryptFdefModAddGeneric,\
    &SymCryptFdefModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdefModMulMontgomeryMulx,\
    &SymCryptFdefModSquareMontgomeryMulx,\
    &SymCryptFdefModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomery,\
    &SymCryptFdefModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery,\
}

Definition at line 2158 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX1024

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX1024

Value:

    {\
    &SymCryptFdefModAddGeneric,\
    &SymCryptFdefModSubGeneric,\
    &SymCryptFdefModNegGeneric,\
    &SymCryptFdefModMulMontgomeryMulx1024,\
    &SymCryptFdefModSquareMontgomeryMulx1024,\
    &SymCryptFdefModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomery,\
    &SymCryptFdefModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery,\
}

Definition at line 2197 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX256

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX256

Value:

    {\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModAddMulx256Asm,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModSub256Asm,\
    &SymCryptFdefModNegGeneric,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModMulMontgomeryMulx256Asm,\
    (SYMCRYPT_MOD_UNARY_OP_FN) &SymCryptFdefModSquareMontgomeryMulx256Asm,\
    &SymCryptFdefModInvMontgomery256,\
    &SymCryptFdefModSetPostMontgomeryMulx256,\
    &SymCryptFdefModPreGetMontgomery256,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery256,\
}

Definition at line 2093 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX384

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULX384

Value:

    {\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModAddMulx384Asm,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModSub384Asm,\
    &SymCryptFdefModNegGeneric,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModMulMontgomeryMulx384Asm,\
    (SYMCRYPT_MOD_UNARY_OP_FN) &SymCryptFdefModSquareMontgomeryMulx384Asm,\
    &SymCryptFdef369ModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomeryMulx384,\
    &SymCryptFdef369ModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdef369ModulusInitMontgomery,\
}

Definition at line 2119 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULXP256

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULXP256

Value:

    {\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModAddMulx256Asm,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModSub256Asm,\
    &SymCryptFdefModNegGeneric,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModMulMontgomeryMulxP256Asm,\
    (SYMCRYPT_MOD_UNARY_OP_FN) &SymCryptFdefModSquareMontgomeryMulxP256Asm,\
    &SymCryptFdefModInvMontgomery256,\
    &SymCryptFdefModSetPostMontgomeryMulx256,\
    &SymCryptFdefModPreGetMontgomery256,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdefModulusInitMontgomery256,\
}

Definition at line 2106 of file sc_lib.h.

◆ SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULXP384

#define SYMCRYPT_MOD_FUNCTIONS_FDEF_MONTGOMERY_MULXP384

Value:

    {\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModAddMulx384Asm,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModSub384Asm,\
    &SymCryptFdefModNegGeneric,\
    (SYMCRYPT_MOD_BINARY_OP_FN) &SymCryptFdefModMulMontgomeryMulxP384Asm,\
    (SYMCRYPT_MOD_UNARY_OP_FN) &SymCryptFdefModSquareMontgomeryMulxP384Asm,\
    &SymCryptFdef369ModInvMontgomery,\
    &SymCryptFdefModSetPostMontgomeryMulxP384,\
    &SymCryptFdef369ModPreGetMontgomery,\
    &SymCryptFdefModulusCopyFixupMontgomery,\
    &SymCryptFdef369ModulusInitMontgomery,\
}

Definition at line 2132 of file sc_lib.h.

◆ SYMCRYPT_MODULAR_FUNCTIONS_SIZE

#define SYMCRYPT_MODULAR_FUNCTIONS_SIZE (sizeof( SYMCRYPT_MODULAR_FUNCTIONS ) )

Definition at line 2007 of file sc_lib.h.

◆ SYMCRYPT_MODULUS_FEATURE_MONTGOMERY

#define SYMCRYPT_MODULUS_FEATURE_MONTGOMERY 1

Definition at line 2018 of file sc_lib.h.

◆ SYMCRYPT_MODULUS_FEATURE_NISTP384

#define SYMCRYPT_MODULUS_FEATURE_NISTP384 8

Definition at line 2021 of file sc_lib.h.

◆ SYMCRYPT_OBJ_NBYTES

#define SYMCRYPT_OBJ_NBYTES ( _p ) ((_p)->nDigits * SYMCRYPT_FDEF_DIGIT_SIZE)

Definition at line 1919 of file sc_lib.h.

◆ SYMCRYPT_OBJ_NDIGITS

#define SYMCRYPT_OBJ_NDIGITS ( _p ) ((_p)->nDigits)

Definition at line 1918 of file sc_lib.h.

◆ SYMCRYPT_OBJ_NUINT32

#define SYMCRYPT_OBJ_NUINT32 ( _p ) ((_p)->nDigits * SYMCRYPT_FDEF_DIGIT_SIZE / sizeof( UINT32 ))

Definition at line 1920 of file sc_lib.h.

◆ SYMCRYPT_RUN_KEY_GEN_PCT

#define SYMCRYPT_RUN_KEY_GEN_PCT	(	KeySelftestFunction,
		Key,
		KeySelftestFlag
	)

Value:

if( ( Key->fAlgorithmInfo & (KeySelftestFlag | SYMCRYPT_FLAG_KEY_NO_FIPS) ) == 0 ) \
{ \
    /* PCT should never fail on key generation - FIPS assert that it does not */ \
    SYMCRYPT_FIPS_ASSERT( KeySelftestFunction( Key ) == SYMCRYPT_NO_ERROR ); \
    SYMCRYPT_ATOMIC_OR32_PRE_RELAXED(&Key->fAlgorithmInfo, KeySelftestFlag); \
}

Definition at line 3699 of file sc_lib.h.

◆ SYMCRYPT_RUN_SELFTEST_ONCE

#define SYMCRYPT_RUN_SELFTEST_ONCE	(	AlgorithmSelftestFunction,
		AlgorithmSelftestFlag
	)

Value:

if( ( g_SymCryptFipsSelftestsPerformed & AlgorithmSelftestFlag ) == 0 ) \
{ \
    AlgorithmSelftestFunction( ); \
    SYMCRYPT_ATOMIC_OR32_PRE_RELAXED( &g_SymCryptFipsSelftestsPerformed, AlgorithmSelftestFlag ); \
}

Definition at line 3686 of file sc_lib.h.

◆ SYMCRYPT_SHA3_PADDING_VALUE

#define SYMCRYPT_SHA3_PADDING_VALUE 0x06

Definition at line 1808 of file sc_lib.h.

◆ SYMCRYPT_SHAKE_PADDING_VALUE

#define SYMCRYPT_SHAKE_PADDING_VALUE 0x1f

Definition at line 1809 of file sc_lib.h.

◆ SYMCRYPT_SIZEOF_TREEHASH_NODE

#define SYMCRYPT_SIZEOF_TREEHASH_NODE ( cbValue ) (sizeof(SYMCRYPT_TREEHASH_NODE) - 1 + (cbValue))

Definition at line 4597 of file sc_lib.h.

◆ SYMCRYPT_TREEHASH_NODE_GET

#define SYMCRYPT_TREEHASH_NODE_GET	(	aNodes,
		cbValue,
		i
	)	((PSYMCRYPT_TREEHASH_NODE)((PBYTE)(aNodes) + (i) * SYMCRYPT_SIZEOF_TREEHASH_NODE(cbValue)))

Definition at line 4599 of file sc_lib.h.

◆ SYMCRYPT_Xxx

#define SYMCRYPT_Xxx CONCAT2( SymCrypt, Alg )

Definition at line 120 of file sc_lib.h.

◆ SYMCRYPT_XXX_EXPANDED_KEY

#define SYMCRYPT_XXX_EXPANDED_KEY CONCAT3( SYMCRYPT_, ALG, _EXPANDED_KEY )

Definition at line 131 of file sc_lib.h.

◆ SYMCRYPT_XXX_INPUT_BLOCK_SIZE

#define SYMCRYPT_XXX_INPUT_BLOCK_SIZE CONCAT3( SYMCRYPT_, ALG, _INPUT_BLOCK_SIZE )

Definition at line 151 of file sc_lib.h.

◆ SYMCRYPT_XXX_RESULT_SIZE

#define SYMCRYPT_XXX_RESULT_SIZE CONCAT3( SYMCRYPT_, ALG, _RESULT_SIZE )

Definition at line 152 of file sc_lib.h.

◆ SYMCRYPT_XXX_STATE

#define SYMCRYPT_XXX_STATE CONCAT3( SYMCRYPT_, ALG, _STATE )

Definition at line 116 of file sc_lib.h.

◆ SYMCRYPT_XxxAppend

#define SYMCRYPT_XxxAppend CONCAT3( SymCrypt, Alg, Append )

Definition at line 124 of file sc_lib.h.

◆ SYMCRYPT_XxxAppendBlocks

#define SYMCRYPT_XxxAppendBlocks CONCAT3( SymCrypt, Alg, AppendBlocks )

Definition at line 126 of file sc_lib.h.

◆ SYMCRYPT_XxxDefault

#define SYMCRYPT_XxxDefault CONCAT3( SymCrypt, Alg, Default )

Definition at line 135 of file sc_lib.h.

◆ SYMCRYPT_XxxEx

#define SYMCRYPT_XxxEx CONCAT3( SymCrypt, Alg, Ex)

Definition at line 134 of file sc_lib.h.

◆ SYMCRYPT_XxxExpandKey

#define SYMCRYPT_XxxExpandKey CONCAT3( SymCrypt, Alg, ExpandKey )

Definition at line 136 of file sc_lib.h.

◆ SYMCRYPT_XxxExpandKeyEx

#define SYMCRYPT_XxxExpandKeyEx CONCAT3( SymCrypt, Alg, ExpandKeyEx )

Definition at line 137 of file sc_lib.h.

◆ SYMCRYPT_XxxExtract

#define SYMCRYPT_XxxExtract CONCAT3( SymCrypt, Alg, Extract )

Definition at line 138 of file sc_lib.h.

◆ SYMCRYPT_XxxInit

#define SYMCRYPT_XxxInit CONCAT3( SymCrypt, Alg, Init )

Definition at line 123 of file sc_lib.h.

◆ SYMCRYPT_XxxKeyCopy

#define SYMCRYPT_XxxKeyCopy CONCAT3( SymCrypt, Alg, KeyCopy )

Definition at line 140 of file sc_lib.h.

◆ SYMCRYPT_XxxResult

#define SYMCRYPT_XxxResult CONCAT3( SymCrypt, Alg, Result )

Definition at line 125 of file sc_lib.h.

◆ SYMCRYPT_XxxResultEx

#define SYMCRYPT_XxxResultEx CONCAT3( SymCrypt, Alg, ResultEx )

Definition at line 139 of file sc_lib.h.

◆ SYMCRYPT_XxxStateCopy

#define SYMCRYPT_XxxStateCopy CONCAT3( SymCrypt, Alg, StateCopy )

Definition at line 122 of file sc_lib.h.

◆ SYMCRYPT_XxxStateExport

#define SYMCRYPT_XxxStateExport CONCAT3( SymCrypt, Alg, StateExport)

Definition at line 128 of file sc_lib.h.

◆ SYMCRYPT_XxxStateImport

#define SYMCRYPT_XxxStateImport CONCAT3( SymCrypt, Alg, StateImport)

Definition at line 127 of file sc_lib.h.

◆ TRUE

#define TRUE (1)

Definition at line 46 of file sc_lib.h.

◆ UNREFERENCED_PARAMETER

#define UNREFERENCED_PARAMETER ( x ) ((void)x)

Definition at line 54 of file sc_lib.h.

Typedef Documentation

◆ _SYMCRYPT_COMPOSITE_MLKEMKEY

typedef SYMCRYPT_ASYM_ALIGN_STRUCT _SYMCRYPT_COMPOSITE_MLKEMKEY

Initial value:

{

PCSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS pParams

_SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

Definition: sc_lib.h:4427

Definition at line 4442 of file sc_lib.h.

◆ _SYMCRYPT_LMS_KEY

typedef SYMCRYPT_ASYM_ALIGN_STRUCT _SYMCRYPT_LMS_KEY

Initial value:

{

SIZE_T cbSize

cbSize

UINT32 cbSize

Definition: symcrypt_internal.h:2409

SIZE_T

ULONG_PTR SIZE_T

Definition: typedefs.h:80

Definition at line 4718 of file sc_lib.h.

◆ _SYMCRYPT_XMSS_KEY

typedef SYMCRYPT_ASYM_ALIGN_STRUCT _SYMCRYPT_XMSS_KEY

Initial value:

{

UINT32 version

version

static const WCHAR version[]

Definition: asmname.c:66

UINT32

uint32_t UINT32

Definition: typedefs.h:59

Definition at line 4519 of file sc_lib.h.

◆ BOOL

typedef int BOOL

Definition at line 43 of file sc_lib.h.

◆ NATIVE_INT

typedef INT32 NATIVE_INT

Definition at line 76 of file sc_lib.h.

◆ NATIVE_UINT

typedef UINT32 NATIVE_UINT

Definition at line 77 of file sc_lib.h.

◆ PCSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

typedef const SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS* PCSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

Definition at line 4440 of file sc_lib.h.

◆ PCSYMCRYPT_COMPOSITE_MLKEMKEY

typedef const SYMCRYPT_COMPOSITE_MLKEMKEY* PCSYMCRYPT_COMPOSITE_MLKEMKEY

Definition at line 4454 of file sc_lib.h.

◆ PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

typedef const SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS* PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

Definition at line 3768 of file sc_lib.h.

◆ PCSYMCRYPT_ECURVE_FUNCTIONS

typedef const SYMCRYPT_ECURVE_FUNCTIONS* PCSYMCRYPT_ECURVE_FUNCTIONS

Definition at line 3920 of file sc_lib.h.

◆ PCSYMCRYPT_LMS_KEY

typedef const SYMCRYPT_LMS_KEY* PCSYMCRYPT_LMS_KEY

Definition at line 4740 of file sc_lib.h.

◆ PCSYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

typedef const SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY* PCSYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

Definition at line 2030 of file sc_lib.h.

◆ PSYMCRYPT_BLOB_HEADER

typedef struct _SYMCRYPT_BLOB_HEADER * PSYMCRYPT_BLOB_HEADER

◆ PSYMCRYPT_BLOB_TRAILER

typedef struct _SYMCRYPT_BLOB_TRAILER * PSYMCRYPT_BLOB_TRAILER

◆ PSYMCRYPT_CACHED_ECURVE_ID

typedef enum SYMCRYPT_CACHED_ECURVE_ID * PSYMCRYPT_CACHED_ECURVE_ID

◆ PSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

typedef struct _SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS * PSYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

◆ PSYMCRYPT_ECPOINT_ADD_DIFF_NONZERO_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_ADD_DIFF_NONZERO_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3852 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_ADD_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_ADD_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3842 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_DOUBLE_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_DOUBLE_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3861 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_ISEQUAL_FUNC

typedef UINT32(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_ISEQUAL_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3819 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_ISZERO_FUNC

typedef UINT32(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_ISZERO_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3835 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_MULTI_SCALAR_MUL_FUNC

typedef SYMCRYPT_ERROR(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_MULTI_SCALAR_MUL_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_reads_(nPoints) PCSYMCRYPT_INT *piSrcScalarArray, _In_reads_(nPoints) PCSYMCRYPT_ECPOINT *poSrcEcpointArray, UINT32 nPoints, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3889 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_NEGATE_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_NEGATE_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Inout_ PSYMCRYPT_ECPOINT poSrc, UINT32 mask, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3870 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_ONCURVE_FUNC

typedef UINT32(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_ONCURVE_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3828 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_SCALAR_MUL_FUNC

typedef SYMCRYPT_ERROR(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_SCALAR_MUL_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_INT piScalar, _In_opt_ PCSYMCRYPT_ECPOINT poSrc, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3878 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_SET_DISTINGUISHED_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_SET_DISTINGUISHED_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3804 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_SET_RANDOM_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_SET_RANDOM_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_INT piScalar, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3811 of file sc_lib.h.

◆ PSYMCRYPT_ECPOINT_SET_ZERO_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECPOINT_SET_ZERO_FUNC) (_In_ PCSYMCRYPT_ECURVE pCurve, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 3797 of file sc_lib.h.

◆ PSYMCRYPT_ECURVE_FILL_SCRATCH_SPACES_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_ECURVE_FILL_SCRATCH_SPACES_FUNC) (_Inout_ PSYMCRYPT_ECURVE pCurve)

Definition at line 3899 of file sc_lib.h.

◆ PSYMCRYPT_ECURVE_FUNCTIONS

typedef struct _SYMCRYPT_ECURVE_FUNCTIONS * PSYMCRYPT_ECURVE_FUNCTIONS

◆ PSYMCRYPT_INCREMENTAL_TREEHASH

typedef struct _SYMCRYPT_INCREMENTAL_TREEHASH * PSYMCRYPT_INCREMENTAL_TREEHASH

◆ PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC

typedef VOID(SYMCRYPT_CALL * PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC) (_In_ PSYMCRYPT_TREEHASH_NODE pNodeLeft, _In_ PSYMCRYPT_TREEHASH_NODE pNodeRight, _Out_ PSYMCRYPT_TREEHASH_NODE pNodeOut, _Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pContext)

Definition at line 4612 of file sc_lib.h.

◆ PSYMCRYPT_LMS_KEY

typedef SYMCRYPT_LMS_KEY* PSYMCRYPT_LMS_KEY

Definition at line 4739 of file sc_lib.h.

◆ PSYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

typedef struct _SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY * PSYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

◆ PSYMCRYPT_TREEHASH_NODE

typedef struct _SYMCRYPT_TREEHASH_NODE * PSYMCRYPT_TREEHASH_NODE

◆ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

typedef struct _SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT * PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

◆ PSYMCRYPT_XMSS_KEY

typedef SYMCRYPT_XMSS_KEY* PSYMCRYPT_XMSS_KEY

Definition at line 4541 of file sc_lib.h.

◆ PXMSS_ADRS

typedef struct _XMSS_ADRS * PXMSS_ADRS

◆ PXMSS_HASHTREE_ADDRESS

typedef struct _XMSS_HASHTREE_ADDRESS * PXMSS_HASHTREE_ADDRESS

◆ PXMSS_LTREE_ADDRESS

typedef struct _XMSS_LTREE_ADDRESS * PXMSS_LTREE_ADDRESS

◆ PXMSS_OTS_ADDRESS

typedef struct _XMSS_OTS_ADDRESS * PXMSS_OTS_ADDRESS

◆ SYMCRYPT_BLOB_HEADER

typedef struct _SYMCRYPT_BLOB_HEADER SYMCRYPT_BLOB_HEADER

◆ SYMCRYPT_BLOB_TRAILER

typedef struct _SYMCRYPT_BLOB_TRAILER SYMCRYPT_BLOB_TRAILER

◆ SYMCRYPT_BLOB_TYPE

typedef enum _SYMCRYPT_BLOB_TYPE SYMCRYPT_BLOB_TYPE

◆ SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

typedef struct _SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS SYMCRYPT_COMPOSITE_MLKEM_INTERNAL_PARAMS

◆ SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

typedef struct _SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS

◆ SYMCRYPT_ECURVE_FUNCTIONS

typedef struct _SYMCRYPT_ECURVE_FUNCTIONS SYMCRYPT_ECURVE_FUNCTIONS

◆ SYMCRYPT_INCREMENTAL_TREEHASH

typedef struct _SYMCRYPT_INCREMENTAL_TREEHASH SYMCRYPT_INCREMENTAL_TREEHASH

◆ SYMCRYPT_KECCAK_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_KECCAK_STATE_EXPORT_BLOB SYMCRYPT_KECCAK_STATE_EXPORT_BLOB

◆ SYMCRYPT_MD2_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_MD2_STATE_EXPORT_BLOB SYMCRYPT_MD2_STATE_EXPORT_BLOB

◆ SYMCRYPT_MD4_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_MD4_STATE_EXPORT_BLOB SYMCRYPT_MD4_STATE_EXPORT_BLOB

◆ SYMCRYPT_MD5_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_MD5_STATE_EXPORT_BLOB SYMCRYPT_MD5_STATE_EXPORT_BLOB

◆ SYMCRYPT_MOD_BINARY_OP_FN

typedef VOID(SYMCRYPT_CALL * SYMCRYPT_MOD_BINARY_OP_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 1929 of file sc_lib.h.

◆ SYMCRYPT_MOD_COPY_FN

typedef VOID(SYMCRYPT_CALL * SYMCRYPT_MOD_COPY_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst)

Definition at line 1964 of file sc_lib.h.

◆ SYMCRYPT_MOD_PRE_GET_FN

typedef PCUINT32(SYMCRYPT_CALL * SYMCRYPT_MOD_PRE_GET_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 1958 of file sc_lib.h.

◆ SYMCRYPT_MOD_SET_POST_FN

typedef VOID(SYMCRYPT_CALL * SYMCRYPT_MOD_SET_POST_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _Inout_ PSYMCRYPT_MODELEMENT peObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 1952 of file sc_lib.h.

◆ SYMCRYPT_MOD_UNARY_OP_FLAG_STATUS_FN

typedef SYMCRYPT_ERROR(SYMCRYPT_CALL * SYMCRYPT_MOD_UNARY_OP_FLAG_STATUS_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 1944 of file sc_lib.h.

◆ SYMCRYPT_MOD_UNARY_OP_FN

typedef VOID(SYMCRYPT_CALL * SYMCRYPT_MOD_UNARY_OP_FN) (_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 1937 of file sc_lib.h.

◆ SYMCRYPT_MODULAR_FUNCTIONS

typedef struct _SYMCRYPT_MODULAR_FUNCTIONS SYMCRYPT_MODULAR_FUNCTIONS

◆ SYMCRYPT_MODULUS_COPYFIXUP_FN

typedef VOID(SYMCRYPT_CALL * SYMCRYPT_MODULUS_COPYFIXUP_FN) (_In_ PCSYMCRYPT_MODULUS pmSrc, _Out_ PSYMCRYPT_MODULUS pmDst)

Definition at line 1969 of file sc_lib.h.

◆ SYMCRYPT_MODULUS_INIT_FN

typedef VOID(SYMCRYPT_CALL * SYMCRYPT_MODULUS_INIT_FN) (_Inout_ PSYMCRYPT_MODULUS pmObj, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)

Definition at line 1973 of file sc_lib.h.

◆ SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

typedef struct _SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY

◆ SYMCRYPT_SHA1_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_SHA1_STATE_EXPORT_BLOB SYMCRYPT_SHA1_STATE_EXPORT_BLOB

◆ SYMCRYPT_SHA256_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_SHA256_STATE_EXPORT_BLOB SYMCRYPT_SHA256_STATE_EXPORT_BLOB

◆ SYMCRYPT_SHA3_224_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB SYMCRYPT_SHA3_224_STATE_EXPORT_BLOB

Definition at line 1178 of file sc_lib.h.

◆ SYMCRYPT_SHA3_256_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB SYMCRYPT_SHA3_256_STATE_EXPORT_BLOB

Definition at line 1179 of file sc_lib.h.

◆ SYMCRYPT_SHA3_384_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB SYMCRYPT_SHA3_384_STATE_EXPORT_BLOB

Definition at line 1180 of file sc_lib.h.

◆ SYMCRYPT_SHA3_512_STATE_EXPORT_BLOB

typedef SYMCRYPT_KECCAK_STATE_EXPORT_BLOB SYMCRYPT_SHA3_512_STATE_EXPORT_BLOB

Definition at line 1181 of file sc_lib.h.

◆ SYMCRYPT_SHA512_STATE_EXPORT_BLOB

typedef struct _SYMCRYPT_SHA512_STATE_EXPORT_BLOB SYMCRYPT_SHA512_STATE_EXPORT_BLOB

◆ SYMCRYPT_TREEHASH_NODE

typedef struct _SYMCRYPT_TREEHASH_NODE SYMCRYPT_TREEHASH_NODE

◆ SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

typedef struct _SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT

◆ XMSS_ADRS

typedef struct _XMSS_ADRS XMSS_ADRS

◆ XMSS_ADRS_TYPE

typedef enum _XMSS_ADRS_TYPE XMSS_ADRS_TYPE

◆ XMSS_HASHTREE_ADDRESS

typedef struct _XMSS_HASHTREE_ADDRESS XMSS_HASHTREE_ADDRESS

◆ XMSS_LTREE_ADDRESS

typedef struct _XMSS_LTREE_ADDRESS XMSS_LTREE_ADDRESS

◆ XMSS_OTS_ADDRESS

typedef struct _XMSS_OTS_ADDRESS XMSS_OTS_ADDRESS

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
STATE_NEXT
STATE_DATA_START
STATE_DATA_END
STATE_RESULT2
STATE_RESULT_DONE

Definition at line 344 of file sc_lib.h.

    {
    STATE_NEXT = 0,         // starting state = 0, set by structure wipe.
    STATE_DATA_START,
    STATE_DATA_END,
    STATE_RESULT2,          // 2nd phase of result computation (1st phase is at STATE_NEXT when the result operation is found)
    STATE_RESULT_DONE,      // 3rd phase of result computation
};

◆ _SYMCRYPT_BLOB_TYPE

enum _SYMCRYPT_BLOB_TYPE

Enumerator
SymCryptBlobTypeUnknown
SymCryptBlobTypeHashState
SymCryptBlobTypeMd2State
SymCryptBlobTypeMd4State
SymCryptBlobTypeMd5State
SymCryptBlobTypeSha1State
SymCryptBlobTypeSha256State
SymCryptBlobTypeSha384State
SymCryptBlobTypeSha512State
SymCryptBlobTypeSha3_256State
SymCryptBlobTypeSha3_384State
SymCryptBlobTypeSha3_512State
SymCryptBlobTypeSha224State
SymCryptBlobTypeSha512_224State
SymCryptBlobTypeSha512_256State
SymCryptBlobTypeSha3_224State

Definition at line 1058 of file sc_lib.h.

                                 {
    SymCryptBlobTypeUnknown     = 0,
    SymCryptBlobTypeHashState   = 0x100,
    SymCryptBlobTypeMd2State    = SymCryptBlobTypeHashState + 1,       // explicit constants as these have to remain the same forever.
    SymCryptBlobTypeMd4State    = SymCryptBlobTypeHashState + 2,
    SymCryptBlobTypeMd5State    = SymCryptBlobTypeHashState + 3,
    SymCryptBlobTypeSha1State   = SymCryptBlobTypeHashState + 4,
    SymCryptBlobTypeSha256State = SymCryptBlobTypeHashState + 5,
    SymCryptBlobTypeSha384State = SymCryptBlobTypeHashState + 6,
    SymCryptBlobTypeSha512State = SymCryptBlobTypeHashState + 7,
    SymCryptBlobTypeSha3_256State = SymCryptBlobTypeHashState + 8,
    SymCryptBlobTypeSha3_384State = SymCryptBlobTypeHashState + 9,
    SymCryptBlobTypeSha3_512State = SymCryptBlobTypeHashState + 10,
    SymCryptBlobTypeSha224State = SymCryptBlobTypeHashState + 11,
    SymCryptBlobTypeSha512_224State = SymCryptBlobTypeHashState + 12,
    SymCryptBlobTypeSha512_256State = SymCryptBlobTypeHashState + 13,
    SymCryptBlobTypeSha3_224State = SymCryptBlobTypeHashState + 14,
} SYMCRYPT_BLOB_TYPE;

◆ _XMSS_ADRS_TYPE

enum _XMSS_ADRS_TYPE

Enumerator
XMSS_ADRS_TYPE_OTS
XMSS_ADRS_TYPE_LTREE
XMSS_ADRS_TYPE_HASH_TREE

Definition at line 4474 of file sc_lib.h.

{
    XMSS_ADRS_TYPE_OTS          = 0,
    XMSS_ADRS_TYPE_LTREE        = 1,
    XMSS_ADRS_TYPE_HASH_TREE    = 2,
} XMSS_ADRS_TYPE;

◆ SYMCRYPT_CACHED_ECURVE_ID

enum SYMCRYPT_CACHED_ECURVE_ID

Enumerator
SYMCRYPT_CACHED_ECURVE_ID_NIST_P256
SYMCRYPT_CACHED_ECURVE_ID_NIST_P384
SYMCRYPT_CACHED_ECURVE_ID_CURVE_25519
SYMCRYPT_CACHED_ECURVE_ID_COUNT

Definition at line 4357 of file sc_lib.h.

             {
    SYMCRYPT_CACHED_ECURVE_ID_NIST_P256 = 0,
    SYMCRYPT_CACHED_ECURVE_ID_NIST_P384,
    SYMCRYPT_CACHED_ECURVE_ID_CURVE_25519,
    SYMCRYPT_CACHED_ECURVE_ID_COUNT
} SYMCRYPT_CACHED_ECURVE_ID, *PSYMCRYPT_CACHED_ECURVE_ID;

Function Documentation

◆ C_ASSERT() [1/9]

C_ASSERT ( (SYMCRYPT_ECURVE_FUNCTIONS_SIZE &(SYMCRYPT_ECURVE_FUNCTIONS_SIZE-1)) = =0 )

◆ C_ASSERT() [2/9]

C_ASSERT ( (SYMCRYPT_MODULAR_FUNCTIONS_SIZE &(SYMCRYPT_MODULAR_FUNCTIONS_SIZE-1)) = =0 )

◆ C_ASSERT() [3/9]

C_ASSERT ( sizeof(SYMCRYPT_MD2_STATE_EXPORT_BLOB) = =SYMCRYPT_MD2_STATE_EXPORT_SIZE )

◆ C_ASSERT() [4/9]

C_ASSERT ( sizeof(SYMCRYPT_MD4_STATE_EXPORT_BLOB) = =SYMCRYPT_MD4_STATE_EXPORT_SIZE )

◆ C_ASSERT() [5/9]

C_ASSERT ( sizeof(SYMCRYPT_MD5_STATE_EXPORT_BLOB) = =SYMCRYPT_MD5_STATE_EXPORT_SIZE )

◆ C_ASSERT() [6/9]

C_ASSERT ( sizeof(SYMCRYPT_SHA1_STATE_EXPORT_BLOB) = =SYMCRYPT_SHA1_STATE_EXPORT_SIZE )

◆ C_ASSERT() [7/9]

C_ASSERT ( sizeof(SYMCRYPT_SHA256_STATE_EXPORT_BLOB) = =SYMCRYPT_SHA256_STATE_EXPORT_SIZE )

◆ C_ASSERT() [8/9]

C_ASSERT ( sizeof(SYMCRYPT_SHA3_224_STATE_EXPORT_BLOB) = =SYMCRYPT_SHA3_224_STATE_EXPORT_SIZE )

◆ C_ASSERT() [9/9]

C_ASSERT ( sizeof(SYMCRYPT_SHA512_STATE_EXPORT_BLOB) = =SYMCRYPT_SHA512_STATE_EXPORT_SIZE )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [1/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_DLKEY_DH )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [2/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_DLKEY_DSA )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [3/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_ECKEY_ECDH )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [4/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_ECKEY_ECDSA )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [5/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [6/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_KEY_NO_FIPS )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [7/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_RSAKEY_ENCRYPT )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [8/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_FLAG_RSAKEY_SIGN )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [9/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_PCT_DSA )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [10/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_PCT_ECDSA )

◆ CHECK_ALGORITHM_INFO_FLAG_POW2() [11/11]

CHECK_ALGORITHM_INFO_FLAG_POW2 ( SYMCRYPT_PCT_RSA_SIGN )

◆ CHECK_ALGORITHM_INFO_FLAGS_DISTINCT() [1/3]

CHECK_ALGORITHM_INFO_FLAGS_DISTINCT	(	SYMCRYPT_PCT_DSA	,
		SYMCRYPT_FLAG_KEY_NO_FIPS	,
		SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION	,
		SYMCRYPT_FLAG_DLKEY_DSA	,
		SYMCRYPT_FLAG_DLKEY_DH
	)

◆ CHECK_ALGORITHM_INFO_FLAGS_DISTINCT() [2/3]

CHECK_ALGORITHM_INFO_FLAGS_DISTINCT	(	SYMCRYPT_PCT_ECDSA	,
		SYMCRYPT_FLAG_KEY_NO_FIPS	,
		SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION	,
		SYMCRYPT_FLAG_ECKEY_ECDSA	,
		SYMCRYPT_FLAG_ECKEY_ECDH
	)

◆ CHECK_ALGORITHM_INFO_FLAGS_DISTINCT() [3/3]

CHECK_ALGORITHM_INFO_FLAGS_DISTINCT	(	SYMCRYPT_PCT_RSA_SIGN	,
		SYMCRYPT_FLAG_KEY_NO_FIPS	,
		SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION	,
		SYMCRYPT_FLAG_RSAKEY_SIGN	,
		SYMCRYPT_FLAG_RSAKEY_ENCRYPT
	)

◆ SYMCRYPT_ALIGN_AT()

SYMCRYPT_MAGIC_FIELD SYMCRYPT_ALIGN_AT ( 16 )

◆ SymCryptAes4Sbox()

VOID SYMCRYPT_CALL SymCryptAes4Sbox	(	_In_reads_(4) PCBYTE	pIn,
		_Out_writes_(4) PBYTE	pOut,
		BOOL	UseSimd
	)

Definition at line 44 of file aes-default.c.

{
#if SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_AMD64
    if( UseSimd )
    {
        SymCryptAes4SboxXmm( pIn, pOut );
    } else {
        SymCryptAes4SboxC( pIn, pOut );
    }
#elif SYMCRYPT_CPU_ARM64
    if( UseSimd )
    {
        SymCryptAes4SboxNeon( pIn, pOut );
    } else {
        SymCryptAes4SboxC( pIn, pOut );
    }
#else
    UNREFERENCED_PARAMETER( UseSimd );
    SymCryptAes4SboxC( pIn, pOut );         // never use XMM on SaveXmm arch, save/restore overhead is too large.
#endif
}

Referenced by SymCryptAesExpandKeyInternal().

◆ SymCryptAes4SboxC()

VOID SYMCRYPT_CALL SymCryptAes4SboxC	(	_In_reads_(4) PCBYTE	pIn,
		_Out_writes_(4) PBYTE	pOut
	)

Referenced by SymCryptAes4Sbox().

◆ SymCryptAes4SboxNeon()

VOID SYMCRYPT_CALL SymCryptAes4SboxNeon	(	_In_reads_(4) PCBYTE	pIn,
		_Out_writes_(4) PBYTE	pOut
	)

Referenced by SymCryptAes4Sbox().

◆ SymCryptAes4SboxXmm()

VOID SYMCRYPT_CALL SymCryptAes4SboxXmm	(	_In_reads_(4) PCBYTE	pIn,
		_Out_writes_(4) PBYTE	pOut
	)

Referenced by SymCryptAes4Sbox().

◆ SymCryptAesCbcDecryptAsm()

VOID SYMCRYPT_CALL SymCryptAesCbcDecryptAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcDecrypt().

◆ SymCryptAesCbcDecryptNeon()

VOID SYMCRYPT_CALL SymCryptAesCbcDecryptNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcDecrypt().

◆ SymCryptAesCbcDecryptXmm()

VOID SYMCRYPT_CALL SymCryptAesCbcDecryptXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcDecrypt().

◆ SymCryptAesCbcEncryptAsm()

VOID SYMCRYPT_CALL SymCryptAesCbcEncryptAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcEncrypt().

◆ SymCryptAesCbcEncryptNeon()

VOID SYMCRYPT_CALL SymCryptAesCbcEncryptNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcEncrypt().

◆ SymCryptAesCbcEncryptXmm()

VOID SYMCRYPT_CALL SymCryptAesCbcEncryptXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcEncrypt().

◆ SymCryptAesCbcMacNeon()

VOID SYMCRYPT_CALL SymCryptAesCbcMacNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcMac().

◆ SymCryptAesCbcMacXmm()

VOID SYMCRYPT_CALL SymCryptAesCbcMacXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCbcMac().

◆ SymCryptAesCreateDecryptionRoundKey()

VOID SYMCRYPT_CALL SymCryptAesCreateDecryptionRoundKey	(	_In_reads_(16) PCBYTE	pEncryptionRoundKey,
		_Out_writes_(16) PBYTE	pDecryptionRoundKey,
		BOOL	UseSimd
	)

Definition at line 68 of file aes-default.c.

{
#if SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_AMD64
    if( UseSimd )
    {
        SymCryptAesCreateDecryptionRoundKeyXmm( pEncryptionRoundKey, pDecryptionRoundKey );
    } else {
        SymCryptAesCreateDecryptionRoundKeyC( pEncryptionRoundKey, pDecryptionRoundKey );
    }
#elif SYMCRYPT_CPU_ARM64
    if( UseSimd )
    {
        SymCryptAesCreateDecryptionRoundKeyNeon( pEncryptionRoundKey, pDecryptionRoundKey );
    } else {
        SymCryptAesCreateDecryptionRoundKeyC( pEncryptionRoundKey, pDecryptionRoundKey );
    }
#else
    UNREFERENCED_PARAMETER( UseSimd );
    SymCryptAesCreateDecryptionRoundKeyC( pEncryptionRoundKey, pDecryptionRoundKey );   // never use XMM on SaveXmm arch, save/restore overhead is too large.
#endif
}

Referenced by SymCryptAesExpandKeyInternal().

◆ SymCryptAesCreateDecryptionRoundKeyC()

VOID SYMCRYPT_CALL SymCryptAesCreateDecryptionRoundKeyC	(	_In_reads_(16) PCBYTE	pEncryptionRoundKey,
		_Out_writes_(16) PBYTE	pDecryptionRoundKey
	)

Definition at line 81 of file aes-c.c.

{
    int i;
    PBYTE p = pDecryptionRoundKey;
    PCBYTE q = pEncryptionRoundKey;
 
    for( i=0; i<4; i++ ) {
        *(UINT32 *)p =
            *(UINT32 *)SymCryptAesInvMatrixMult[0][q[0]] ^
            *(UINT32 *)SymCryptAesInvMatrixMult[1][q[1]] ^
            *(UINT32 *)SymCryptAesInvMatrixMult[2][q[2]] ^
            *(UINT32 *)SymCryptAesInvMatrixMult[3][q[3]];
        p += 4;
        q += 4;
    }
 
}

Referenced by SymCryptAesCreateDecryptionRoundKey().

◆ SymCryptAesCreateDecryptionRoundKeyNeon()

VOID SYMCRYPT_CALL SymCryptAesCreateDecryptionRoundKeyNeon	(	_In_reads_(16) PCBYTE	pEncryptionRoundKey,
		_Out_writes_(16) PBYTE	pDecryptionRoundKey
	)

Referenced by SymCryptAesCreateDecryptionRoundKey().

◆ SymCryptAesCreateDecryptionRoundKeyXmm()

VOID SYMCRYPT_CALL SymCryptAesCreateDecryptionRoundKeyXmm	(	_In_reads_(16) PCBYTE	pEncryptionRoundKey,
		_Out_writes_(16) PBYTE	pDecryptionRoundKey
	)

Referenced by SymCryptAesCreateDecryptionRoundKey().

◆ SymCryptAesCtrMsb32()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb32	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 359 of file aes-default.c.

{
#if SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
    {
        SymCryptAesCtrMsb32Xmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
    } else {
        SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
        SymCryptCtrMsb32( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
    }
 
#elif SYMCRYPT_CPU_X86
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
        SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptAesCtrMsb32Xmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
        SymCryptRestoreXmm( &SaveData );
    } else {
        SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
        SymCryptCtrMsb32( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
    }
 
#elif SYMCRYPT_CPU_ARM64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
    {
        SymCryptAesCtrMsb32Neon( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
    } else {
        SymCryptCtrMsb32( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
    }
 
#else
    SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
    SymCryptCtrMsb32( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
#endif
}

Referenced by SymCryptAesGcmDecryptPartOnePass(), and SymCryptAesGcmEncryptPartOnePass().

◆ SymCryptAesCtrMsb32Neon()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb32Neon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCtrMsb32().

◆ SymCryptAesCtrMsb32Xmm()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb32Xmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCtrMsb32().

◆ SymCryptAesCtrMsb64Asm()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb64Asm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCtrMsb64().

◆ SymCryptAesCtrMsb64Neon()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb64Neon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCtrMsb64().

◆ SymCryptAesCtrMsb64Xmm()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb64Xmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesCtrMsb64().

◆ SymCryptAesDecryptAsm()

VOID SYMCRYPT_CALL SymCryptAesDecryptAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Referenced by SymCryptAesDecrypt().

◆ SymCryptAesDecryptC()

VOID SYMCRYPT_CALL SymCryptAesDecryptC	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Definition at line 242 of file aes-c.c.

{
    SYMCRYPT_ALIGN BYTE state[4][4] = { 0 };
    SYMCRYPT_ALIGN UINT32 state2[4] = { 0 };
 
    const BYTE (*keyPtr)[4][4];
    const BYTE (*keyLimit)[4][4];
 
#if NEED_ALIGN
    SYMCRYPT_ALIGN BYTE   alignBuffer[SYMCRYPT_AES_BLOCK_SIZE];
#endif
 
#if NEED_ALIGN
    //
    // Callers who don't have their buffers aligned don't care about speed,
    // so we do this in the simplest way.
    //
    if( !(IS_UINT32_ALIGNED( pbPlaintext ) & IS_UINT32_ALIGNED( pbCiphertext )) ) {
        memcpy( alignBuffer, pbCiphertext, SYMCRYPT_AES_BLOCK_SIZE );
        SymCryptAesDecrypt( pExpandedKey, alignBuffer, alignBuffer );
        memcpy( pbPlaintext, alignBuffer, SYMCRYPT_AES_BLOCK_SIZE );
        SymCryptWipeKnownSize( alignBuffer, sizeof( alignBuffer ) );
        return;
    }
#endif
 
    SYMCRYPT_CHECK_MAGIC( pExpandedKey );
 
    keyPtr = &pExpandedKey->lastEncRoundKey[0];     // First round key
    keyLimit = &pExpandedKey->lastDecRoundKey[0];   // Last round key
 
    // Initial round (AddRoundKey)
    *((UINT32 *) &state[0][0]) = *(UINT32 *) (*keyPtr)[0] ^ *(UINT32 *) &pbCiphertext[0];
    *((UINT32 *) &state[1][0]) = *(UINT32 *) (*keyPtr)[1] ^ *(UINT32 *) &pbCiphertext[4];
    *((UINT32 *) &state[2][0]) = *(UINT32 *) (*keyPtr)[2] ^ *(UINT32 *) &pbCiphertext[8];
    *((UINT32 *) &state[3][0]) = *(UINT32 *) (*keyPtr)[3] ^ *(UINT32 *) &pbCiphertext[12];
 
    keyPtr += 1;
 
    // Main rounds
    while (keyPtr < keyLimit)
    {
 
        // SubBytes/ShiftRows/MixColumns for col. 0
        state2[0] = *((UINT32 *) &SymCryptAesInvSboxMatrixMult[0][ state[0][0] ]);
        state2[1] = *((UINT32 *) &SymCryptAesInvSboxMatrixMult[1][ state[0][1] ]);
        state2[2] = *((UINT32 *) &SymCryptAesInvSboxMatrixMult[2][ state[0][2] ]);
        state2[3] = *((UINT32 *) &SymCryptAesInvSboxMatrixMult[3][ state[0][3] ]);
 
        // SubBytes/ShiftRows/MixColumns for col. 1
        state2[1] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[0][ state[1][0] ]);
        state2[2] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[1][ state[1][1] ]);
        state2[3] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[2][ state[1][2] ]);
        state2[0] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[3][ state[1][3] ]);
 
        // SubBytes/ShiftRows/MixColumns for col. 2
        state2[2] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[0][ state[2][0] ]);
        state2[3] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[1][ state[2][1] ]);
        state2[0] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[2][ state[2][2] ]);
        state2[1] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[3][ state[2][3] ]);
 
        // SubBytes/ShiftRows/MixColumns for col. 3
        state2[3] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[0][ state[3][0] ]);
        state2[0] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[1][ state[3][1] ]);
        state2[1] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[2][ state[3][2] ]);
        state2[2] ^= *((UINT32 *) &SymCryptAesInvSboxMatrixMult[3][ state[3][3] ]);
 
        // AddRoundKey
        *((UINT32 *) &state[0][0]) = *(UINT32 *) (*keyPtr)[0] ^ state2[0];
        *((UINT32 *) &state[1][0]) = *(UINT32 *) (*keyPtr)[1] ^ state2[1];
        *((UINT32 *) &state[2][0]) = *(UINT32 *) (*keyPtr)[2] ^ state2[2];
        *((UINT32 *) &state[3][0]) = *(UINT32 *) (*keyPtr)[3] ^ state2[3];
 
        keyPtr += 1;
    }
 
    // Final round
 
    // SubBytes/ShiftRows for col. 0
    state2[0] = (UINT32) SymCryptAesInvSbox[ state[0][0] ];
    state2[1] = (UINT32) SymCryptAesInvSbox[ state[0][1] ] << 8;
    state2[2] = (UINT32) SymCryptAesInvSbox[ state[0][2] ] << 16;
    state2[3] = (UINT32) SymCryptAesInvSbox[ state[0][3] ] << 24;
 
    // SubBytes/ShiftRows for col. 1
    state2[1] |= (UINT32) SymCryptAesInvSbox[ state[1][0] ];
    state2[2] |= (UINT32) SymCryptAesInvSbox[ state[1][1] ] << 8;
    state2[3] |= (UINT32) SymCryptAesInvSbox[ state[1][2] ] << 16;
    state2[0] |= (UINT32) SymCryptAesInvSbox[ state[1][3] ] << 24;
 
    // SubBytes/ShiftRows for col. 2
    state2[2] |= (UINT32) SymCryptAesInvSbox[ state[2][0] ];
    state2[3] |= (UINT32) SymCryptAesInvSbox[ state[2][1] ] << 8;
    state2[0] |= (UINT32) SymCryptAesInvSbox[ state[2][2] ] << 16;
    state2[1] |= (UINT32) SymCryptAesInvSbox[ state[2][3] ] << 24;
 
    // SubBytes/ShiftRows for col. 3
    state2[3] |= (UINT32) SymCryptAesInvSbox[ state[3][0] ];
    state2[0] |= (UINT32) SymCryptAesInvSbox[ state[3][1] ] << 8;
    state2[1] |= (UINT32) SymCryptAesInvSbox[ state[3][2] ] << 16;
    state2[2] |= (UINT32) SymCryptAesInvSbox[ state[3][3] ] << 24;
 
    // AddRoundKey
    *((UINT32 *) &pbPlaintext[0 ]) = *(UINT32 *) (*keyPtr)[0] ^ state2[0];
    *((UINT32 *) &pbPlaintext[4 ]) = *(UINT32 *) (*keyPtr)[1] ^ state2[1];
    *((UINT32 *) &pbPlaintext[8 ]) = *(UINT32 *) (*keyPtr)[2] ^ state2[2];
    *((UINT32 *) &pbPlaintext[12]) = *(UINT32 *) (*keyPtr)[3] ^ state2[3];
 
    SymCryptWipeKnownSize( state, sizeof( state ) );
    SymCryptWipeKnownSize( state2, sizeof( state2 ) );
 
    return;
}

Referenced by SymCryptAesDecrypt(), and SymCryptAesEcbDecryptC().

◆ SymCryptAesDecryptNeon()

VOID SYMCRYPT_CALL SymCryptAesDecryptNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Referenced by SymCryptAesDecrypt().

◆ SymCryptAesDecryptXmm()

VOID SYMCRYPT_CALL SymCryptAesDecryptXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Referenced by SymCryptAesDecrypt().

◆ SymCryptAesEcbDecryptC()

VOID SYMCRYPT_CALL SymCryptAesEcbDecryptC	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 378 of file aes-c.c.

{
    while( cbData >= SYMCRYPT_AES_BLOCK_SIZE )
    {
        SymCryptAesDecryptC( pExpandedKey, pbSrc, pbDst );
        pbSrc += SYMCRYPT_AES_BLOCK_SIZE;
        pbDst += SYMCRYPT_AES_BLOCK_SIZE;
        cbData -= SYMCRYPT_AES_BLOCK_SIZE;
    }
}

◆ SymCryptAesEcbEncryptAsm()

VOID SYMCRYPT_CALL SymCryptAesEcbEncryptAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesEcbEncrypt().

◆ SymCryptAesEcbEncryptC()

VOID SYMCRYPT_CALL SymCryptAesEcbEncryptC	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 361 of file aes-c.c.

{
    while( cbData >= SYMCRYPT_AES_BLOCK_SIZE )
    {
        SymCryptAesEncryptC( pExpandedKey, pbSrc, pbDst );
        pbSrc += SYMCRYPT_AES_BLOCK_SIZE;
        pbDst += SYMCRYPT_AES_BLOCK_SIZE;
        cbData -= SYMCRYPT_AES_BLOCK_SIZE;
    }
}

Referenced by SymCryptAesEcbEncrypt().

◆ SymCryptAesEcbEncryptNeon()

VOID SYMCRYPT_CALL SymCryptAesEcbEncryptNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesEcbEncrypt().

◆ SymCryptAesEcbEncryptXmm()

VOID SYMCRYPT_CALL SymCryptAesEcbEncryptXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesEcbEncrypt().

◆ SymCryptAesEncryptAsm()

VOID SYMCRYPT_CALL SymCryptAesEncryptAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Referenced by SymCryptAesEncrypt().

◆ SymCryptAesEncryptC()

VOID SYMCRYPT_CALL SymCryptAesEncryptC	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Definition at line 115 of file aes-c.c.

{
    SYMCRYPT_ALIGN BYTE state[4][4] = { 0 };
    SYMCRYPT_ALIGN UINT32 state2[4] = { 0 };
 
    const BYTE (*keyPtr)[4][4];
    const BYTE (*keyLimit)[4][4];
 
#if NEED_ALIGN
    SYMCRYPT_ALIGN BYTE   alignBuffer[SYMCRYPT_AES_BLOCK_SIZE];
#endif
 
#if NEED_ALIGN
 
    //
    // Callers who don't have their buffers aligned don't care about speed,
    // so we do this in the simplest way.
    //
    if( !(IS_UINT32_ALIGNED( pbPlaintext ) & IS_UINT32_ALIGNED( pbCiphertext )) ) {
        memcpy( alignBuffer, pbPlaintext, SYMCRYPT_AES_BLOCK_SIZE );
        SymCryptAesEncrypt( pExpandedKey, alignBuffer, alignBuffer );
        memcpy( pbCiphertext, alignBuffer, SYMCRYPT_AES_BLOCK_SIZE );
        SymCryptWipeKnownSize( alignBuffer, sizeof( alignBuffer ) );
        return;
    }
#endif
 
    SYMCRYPT_CHECK_MAGIC( pExpandedKey );
 
    //
    // From this point on all our data is UINT32 aligned or better on those
    // platforms that have alignment restrictions.
    //
 
    keyPtr = &pExpandedKey->RoundKey[0];            // First round key
    keyLimit = &pExpandedKey->lastEncRoundKey[0];   // Last round key
 
    // Initial round (AddRoundKey)
    *((UINT32 *) &state[0][0]) = *(UINT32 *) (*keyPtr)[0] ^ *(UINT32 *) &pbPlaintext[0];
    *((UINT32 *) &state[1][0]) = *(UINT32 *) (*keyPtr)[1] ^ *(UINT32 *) &pbPlaintext[4];
    *((UINT32 *) &state[2][0]) = *(UINT32 *) (*keyPtr)[2] ^ *(UINT32 *) &pbPlaintext[8];
    *((UINT32 *) &state[3][0]) = *(UINT32 *) (*keyPtr)[3] ^ *(UINT32 *) &pbPlaintext[12];
 
    keyPtr += 1;
 
    // Main rounds
    while (keyPtr < keyLimit)
    {
 
        // SubBytes/ShiftRows/MixColumns for col. 0
        state2[0] = *((UINT32 *) &SymCryptAesSboxMatrixMult[0][ state[0][0] ]);
        state2[3] = *((UINT32 *) &SymCryptAesSboxMatrixMult[1][ state[0][1] ]);
        state2[2] = *((UINT32 *) &SymCryptAesSboxMatrixMult[2][ state[0][2] ]);
        state2[1] = *((UINT32 *) &SymCryptAesSboxMatrixMult[3][ state[0][3] ]);
 
        // SubBytes/ShiftRows/MixColumns for col. 1
        state2[1] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[0][ state[1][0] ]);
        state2[0] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[1][ state[1][1] ]);
        state2[3] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[2][ state[1][2] ]);
        state2[2] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[3][ state[1][3] ]);
 
        // SubBytes/ShiftRows/MixColumns for col. 2
        state2[2] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[0][ state[2][0] ]);
        state2[1] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[1][ state[2][1] ]);
        state2[0] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[2][ state[2][2] ]);
        state2[3] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[3][ state[2][3] ]);
 
        // SubBytes/ShiftRows/MixColumns for col. 3
        state2[3] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[0][ state[3][0] ]);
        state2[2] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[1][ state[3][1] ]);
        state2[1] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[2][ state[3][2] ]);
        state2[0] ^= *((UINT32 *) &SymCryptAesSboxMatrixMult[3][ state[3][3] ]);
 
        // AddRoundKey
        *((UINT32 *) &state[0][0]) = *(UINT32 *) (*keyPtr)[0] ^ state2[0];
        *((UINT32 *) &state[1][0]) = *(UINT32 *) (*keyPtr)[1] ^ state2[1];
        *((UINT32 *) &state[2][0]) = *(UINT32 *) (*keyPtr)[2] ^ state2[2];
        *((UINT32 *) &state[3][0]) = *(UINT32 *) (*keyPtr)[3] ^ state2[3];
 
        keyPtr += 1;
    }
 
    // Final round
 
    // SubBytes/ShiftRows for col. 0
    state2[0] = (UINT32) SymCryptAesSboxMatrixMult[0][ state[0][0] ][1];
    state2[3] = (UINT32) SymCryptAesSboxMatrixMult[0][ state[0][1] ][1] << 8;
    state2[2] = (UINT32) SymCryptAesSboxMatrixMult[0][ state[0][2] ][1] << 16;
    state2[1] = (UINT32) SymCryptAesSboxMatrixMult[0][ state[0][3] ][1] << 24;
 
    // SubBytes/ShiftRows for col. 1
    state2[1] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[1][0] ][1];
    state2[0] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[1][1] ][1] << 8;
    state2[3] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[1][2] ][1] << 16;
    state2[2] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[1][3] ][1] << 24;
 
    // SubBytes/ShiftRows for col. 2
    state2[2] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[2][0] ][1];
    state2[1] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[2][1] ][1] << 8;
    state2[0] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[2][2] ][1] << 16;
    state2[3] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[2][3] ][1] << 24;
 
    // SubBytes/ShiftRows for col. 3
    state2[3] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[3][0] ][1];
    state2[2] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[3][1] ][1] << 8;
    state2[1] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[3][2] ][1] << 16;
    state2[0] |= (UINT32) SymCryptAesSboxMatrixMult[0][ state[3][3] ][1] << 24;
 
    // AddRoundKey
    *((UINT32 *) &pbCiphertext[0 ]) = *(UINT32 *) (*keyPtr)[0] ^ state2[0];
    *((UINT32 *) &pbCiphertext[4 ]) = *(UINT32 *) (*keyPtr)[1] ^ state2[1];
    *((UINT32 *) &pbCiphertext[8 ]) = *(UINT32 *) (*keyPtr)[2] ^ state2[2];
    *((UINT32 *) &pbCiphertext[12]) = *(UINT32 *) (*keyPtr)[3] ^ state2[3];
 
    SymCryptWipeKnownSize( state, sizeof( state ) );
    SymCryptWipeKnownSize( state2, sizeof( state2 ) );
 
    return;
}

Referenced by SymCryptAesEcbEncryptC(), and SymCryptAesEncrypt().

◆ SymCryptAesEncryptNeon()

VOID SYMCRYPT_CALL SymCryptAesEncryptNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Referenced by SymCryptAesEncrypt().

◆ SymCryptAesEncryptXmm()

VOID SYMCRYPT_CALL SymCryptAesEncryptXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbDst
	)

Referenced by SymCryptAesEncrypt().

◆ SymCryptAesGcmDecryptPart()

VOID SYMCRYPT_CALL SymCryptAesGcmDecryptPart	(	_Inout_ PSYMCRYPT_GCM_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 835 of file aes-default.c.

{
#if SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE ) )
    {
        SymCryptAesGcmDecryptPartOnePass( pState, pbSrc, pbDst, cbData );
    } else {
        SymCryptGcmDecryptPartTwoPass( pState, pbSrc, pbDst, cbData );
    }
 
#elif SYMCRYPT_CPU_X86
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE ) &&
        SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptAesGcmDecryptPartOnePass( pState, pbSrc, pbDst, cbData );
        SymCryptRestoreXmm( &SaveData );
    } else {
        SymCryptGcmDecryptPartTwoPass( pState, pbSrc, pbDst, cbData );
    }
 
#elif SYMCRYPT_CPU_ARM64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES | SYMCRYPT_CPU_FEATURE_NEON_PMULL ) )
    {
        SymCryptAesGcmDecryptPartOnePass( pState, pbSrc, pbDst, cbData );
    } else {
        SymCryptGcmDecryptPartTwoPass( pState, pbSrc, pbDst, cbData );
    }
 
#else
    SymCryptGcmDecryptPartTwoPass( pState, pbSrc, pbDst, cbData );
#endif
}

◆ SymCryptAesGcmDecryptStitchedNeon()

VOID SYMCRYPT_CALL SymCryptAesGcmDecryptStitchedNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesGcmDecryptPartOnePass().

◆ SymCryptAesGcmDecryptStitchedXmm()

VOID SYMCRYPT_CALL SymCryptAesGcmDecryptStitchedXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesGcmDecryptPartOnePass().

◆ SymCryptAesGcmDecryptStitchedYmm_2048()

VOID SYMCRYPT_CALL SymCryptAesGcmDecryptStitchedYmm_2048	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesGcmDecryptPartOnePass().

◆ SymCryptAesGcmEncryptPart()

VOID SYMCRYPT_CALL SymCryptAesGcmEncryptPart	(	_Inout_ PSYMCRYPT_GCM_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 794 of file aes-default.c.

{
#if SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE ) )
    {
        SymCryptAesGcmEncryptPartOnePass( pState, pbSrc, pbDst, cbData );
    } else {
        SymCryptGcmEncryptPartTwoPass( pState, pbSrc, pbDst, cbData );
    }
 
#elif SYMCRYPT_CPU_X86
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE ) &&
        SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptAesGcmEncryptPartOnePass( pState, pbSrc, pbDst, cbData );
        SymCryptRestoreXmm( &SaveData );
    } else {
        SymCryptGcmEncryptPartTwoPass( pState, pbSrc, pbDst, cbData );
    }
 
#elif SYMCRYPT_CPU_ARM64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES | SYMCRYPT_CPU_FEATURE_NEON_PMULL ) )
    {
        SymCryptAesGcmEncryptPartOnePass( pState, pbSrc, pbDst, cbData );
    } else {
        SymCryptGcmEncryptPartTwoPass( pState, pbSrc, pbDst, cbData );
    }
 
#else
    SymCryptGcmEncryptPartTwoPass( pState, pbSrc, pbDst, cbData );
#endif
}

◆ SymCryptAesGcmEncryptStitchedNeon()

VOID SYMCRYPT_CALL SymCryptAesGcmEncryptStitchedNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesGcmEncryptPartOnePass().

◆ SymCryptAesGcmEncryptStitchedXmm()

VOID SYMCRYPT_CALL SymCryptAesGcmEncryptStitchedXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesGcmEncryptPartOnePass().

◆ SymCryptAesGcmEncryptStitchedYmm_2048()

VOID SYMCRYPT_CALL SymCryptAesGcmEncryptStitchedYmm_2048	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Referenced by SymCryptAesGcmEncryptPartOnePass().

◆ SymCryptCheckLibraryInitialized()

FORCEINLINE VOID SYMCRYPT_CALL SymCryptCheckLibraryInitialized ( void )

Definition at line 296 of file sc_lib.h.

297{

298}

◆ SymCryptCompositeGetSizeOfEncodedEcPk()

UINT32 SYMCRYPT_CALL SymCryptCompositeGetSizeOfEncodedEcPk ( SYMCRYPT_CACHED_ECURVE_ID curveId )

◆ SymCryptCompositeGetSizeOfEncodedEcSk()

UINT32 SYMCRYPT_CALL SymCryptCompositeGetSizeOfEncodedEcSk ( SYMCRYPT_CACHED_ECURVE_ID curveId )

◆ SymCryptCompositeMlKemGetRandomScalarForEcKeyEx()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemGetRandomScalarForEcKeyEx	(	SYMCRYPT_CACHED_ECURVE_ID	ecurveId,
		SYMCRYPT_NUMBER_FORMAT	numFormat,
		_In_reads_bytes_(cbSeed) PCBYTE	pbSeed,
		SIZE_T	cbSeed,
		_Out_writes_bytes_(cbScalar) PBYTE	pbScalar,
		SIZE_T	cbScalar
	)

◆ SymCryptCountLeadingZeros32()

FORCEINLINE UINT32 SymCryptCountLeadingZeros32 ( UINT32 value )

Definition at line 5079 of file sc_lib.h.

{
    unsigned long zeros = 0;
 
    if(value == 0)
    {
        return 32;
    }
 
#if SYMCRYPT_PLATFORM_WINDOWS && (SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM)
    _BitScanReverse(&zeros, value);
    zeros = 31 - zeros;
#elif SYMCRYPT_GNUC
    zeros = __builtin_clz(value);
#else
    while( (value & 0x80000000) == 0 )
    {
        zeros++;
        value <<= 1;
    }
#endif
 
    return (UINT32)zeros;
}

Referenced by SymCryptHbsGetWinternitzLengths(), and SymCryptHbsIncrementalTreehashStackDepth().

◆ SymCryptCountLeadingZeros64()

FORCEINLINE UINT32 SymCryptCountLeadingZeros64 ( UINT64 value )

Definition at line 5106 of file sc_lib.h.

{
    unsigned long zeros = 0;
 
    if(value == 0)
    {
        return 64;
    }
 
#if SYMCRYPT_PLATFORM_WINDOWS && (SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_ARM64)
    _BitScanReverse64(&zeros, value);
    zeros = 63 - zeros;
#elif SYMCRYPT_PLATFORM_WINDOWS && (SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM)
    if( (value >> 32) == 0 )
    {
        _BitScanReverse(&zeros, (UINT32)value);
        zeros = 63 - zeros;
    } else {
        _BitScanReverse(&zeros, (UINT32)(value >> 32));
        zeros = 31 - zeros;
    }
#elif SYMCRYPT_GNUC
    zeros = __builtin_clzll(value);
#else
    while( (value & 0x8000000000000000) == 0 )
    {
        zeros++;
        value <<= 1;
    }
#endif
 
    return (UINT32)zeros;
}

◆ SymCryptCountTrailingZeros32()

FORCEINLINE UINT32 SymCryptCountTrailingZeros32 ( UINT32 value )

Definition at line 5020 of file sc_lib.h.

{
    unsigned long index = 0;
    if( value == 0 )
    {
        return 32;
    }
 
#if SYMCRYPT_PLATFORM_WINDOWS && (SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM)
    _BitScanForward(&index, value);
#elif SYMCRYPT_GNUC
    index = __builtin_ctz(value);
#else
    while( (value & 1) == 0 )
    {
        index++;
        value >>= 1;
    }
#endif
 
    return (UINT32)index;
}

Referenced by SymCryptFdefModInvGeneric().

◆ SymCryptCountTrailingZeros64()

FORCEINLINE UINT32 SymCryptCountTrailingZeros64 ( UINT64 value )

Definition at line 5045 of file sc_lib.h.

{
    unsigned long index = 0;
    if( value == 0 )
    {
        return 64;
    }
 
#if SYMCRYPT_PLATFORM_WINDOWS && (SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_ARM64)
    _BitScanForward64(&index, value);
#elif SYMCRYPT_PLATFORM_WINDOWS && (SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM)
    if( ((UINT32)value) == 0 )
    {
        _BitScanForward(&index, (UINT32)(value>>32));
        index += 32;
    } else {
        _BitScanForward(&index, (UINT32)value);
    }
 
#elif SYMCRYPT_GNUC
    index = __builtin_ctzll(value);
#else
    while( (value & 1) == 0 )
    {
        index++;
        value >>= 1;
    }
#endif
 
    return (UINT32)index;
}

Referenced by SymCryptRsakeyCalculatePrimesFromPrivateExponent().

◆ SymCryptCpuidExFunc()

VOID SYMCRYPT_CALL SymCryptCpuidExFunc	(	int	cpuInfo[4],
		int	function_id,
		int	subfunction_id
	)

◆ SymCryptCShakeEncodeInputStrings()

VOID SYMCRYPT_CALL SymCryptCShakeEncodeInputStrings	(	_Inout_ PSYMCRYPT_KECCAK_STATE	pState,
		_In_reads_(cbFunctionNameString) PCBYTE	pbFunctionNameString,
		SIZE_T	cbFunctionNameString,
		_In_reads_(cbCustomizationString) PCBYTE	pbCustomizationString,
		SIZE_T	cbCustomizationString
	)

Definition at line 221 of file shake.c.

{
    SYMCRYPT_ASSERT((cbFunctionNameString > 0) || (cbCustomizationString > 0));
 
    // left_encode( inputBlockSize ) for byte_pad function
    //
    // SymCryptKeccakEncodeTimes8 function encodes 8 times the value passed to
    // it. Here, we want the actual value of pState->inputBlockSize to be encoded,
    // hence the division by 8.
    SymCryptKeccakAppendEncodeTimes8(pState, pState->inputBlockSize / 8, TRUE);
 
    SymCryptKeccakAppendEncodedString(pState, pbFunctionNameString, cbFunctionNameString);
    SymCryptKeccakAppendEncodedString(pState, pbCustomizationString, cbCustomizationString);
 
    // Appending of Customization String may have already called the permutation
    // if the appended data is aligned to input block size, in which case the zero
    // padding has been done.
    if (pState->stateIndex != 0)
    {
        SymCryptKeccakZeroAppendBlock(pState);
    }
}

Referenced by SYMCRYPT_XxxInit().

◆ SymCryptCtrMsb32()

VOID SYMCRYPT_CALL SymCryptCtrMsb32	(	_In_ PCSYMCRYPT_BLOCKCIPHER	pBlockCipher,
		_In_ PCVOID	pExpandedKey,
		_Inout_updates_(pBlockCipher->blockSize) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 249 of file blockciphermodes.c.

{
    SYMCRYPT_ALIGN BYTE buf[2 * SYMCRYPT_MAX_BLOCK_SIZE];
    PBYTE count = &buf[0];
    PBYTE keystream= &buf[SYMCRYPT_MAX_BLOCK_SIZE];
    SIZE_T blockSize;
    PCBYTE pbSrcEnd;
 
    blockSize = pBlockCipher->blockSize;
    SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
 
    //
    // Compute the end of the data, rounding the size down to a multiple of the block size.
    //
    pbSrcEnd = &pbSrc[ cbData & ~(blockSize - 1) ];
 
    //
    // We keep the chaining state in a local buffer to enforce the read-once write-once rule.
    // It also improves memory locality.
    //
    #pragma warning(suppress: 22105)
    memcpy( count, pbChainingValue, blockSize );
    while( pbSrc < pbSrcEnd )
    {
        SYMCRYPT_ASSERT( pbSrc <= pbSrcEnd - blockSize );   // help PreFast
        (*pBlockCipher->encryptFunc)( pExpandedKey, count, keystream );
        SymCryptXorBytes( keystream, pbSrc, pbDst, blockSize );
 
        //
        // We only need to increment the last 32 bits of the counter value.
        //
        SYMCRYPT_STORE_MSBFIRST32( &count[ blockSize-4 ], 1 + SYMCRYPT_LOAD_MSBFIRST32( &count[ blockSize-4 ] ) );
 
        pbSrc += blockSize;
        pbDst += blockSize;
    }
 
    memcpy( pbChainingValue, count, blockSize );
 
    SymCryptWipeKnownSize( buf, sizeof( buf ));
}

Referenced by SymCryptAesCtrMsb32(), SymCryptGcmComputeTag(), SymCryptGcmDecrypt(), SymCryptGcmEncrypt(), and SymCryptGcmEncryptDecryptPart().

◆ SymCryptDetectCpuFeaturesByCpuid()

VOID SYMCRYPT_CALL SymCryptDetectCpuFeaturesByCpuid ( UINT32 flags )

Referenced by SymCryptInitEnvWindowsUsermodeWin8_1nLater().

◆ SymCryptDetectCpuFeaturesFromIsProcessorFeaturePresent()

VOID SYMCRYPT_CALL SymCryptDetectCpuFeaturesFromIsProcessorFeaturePresent ( void )

Referenced by SymCryptInitEnvWindowsUsermodeWin8_1nLater().

◆ SymCryptDetectCpuFeaturesFromRegisters()

VOID SYMCRYPT_CALL SymCryptDetectCpuFeaturesFromRegisters ( void )

◆ SymCryptDetectCpuFeaturesFromRegistersNoTry()

VOID SYMCRYPT_CALL SymCryptDetectCpuFeaturesFromRegistersNoTry ( void )

◆ SymCryptDsaPct()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaPct ( PCSYMCRYPT_DLKEY pkDlkey )

Referenced by SymCryptDlkeyGenerate().

◆ SymCryptEcDsaPct()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaPct ( PCSYMCRYPT_ECKEY pkEckey )

Referenced by SymCryptEcDsaSign(), and SymCryptEckeyGetValue().

◆ SymCryptEckeyGetValueCompositeEncodingPk()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyGetValueCompositeEncodingPk	(	_In_ PCSYMCRYPT_ECKEY	pEckey,
		SYMCRYPT_CACHED_ECURVE_ID	curveId,
		_Out_writes_bytes_(cbDst) PBYTE	pbDst,
		SIZE_T	cbDst
	)

◆ SymCryptEckeyGetValueCompositeEncodingSk()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyGetValueCompositeEncodingSk	(	_In_ PCSYMCRYPT_ECKEY	pEckey,
		SYMCRYPT_CACHED_ECURVE_ID	curveId,
		_Out_writes_bytes_(cbDst) PBYTE	pbDst,
		SIZE_T	cbDst
	)

◆ SymCryptEckeySetValueCompositeEncodingPk()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetValueCompositeEncodingPk	(	_In_ SYMCRYPT_CACHED_ECURVE_ID	curveId,
		_In_reads_bytes_(cbSrc) PCBYTE	pbSrc,
		SIZE_T	cbSrc,
		UINT32	flags,
		_Inout_ PSYMCRYPT_ECKEY	pEckey
	)

◆ SymCryptEckeySetValueCompositeEncodingSk()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetValueCompositeEncodingSk	(	SYMCRYPT_CACHED_ECURVE_ID	curveId,
		_In_reads_bytes_(cbSrc) PCBYTE	pbSrc,
		SIZE_T	cbSrc,
		UINT32	flags,
		_Inout_ PSYMCRYPT_ECKEY	pEckey
	)

◆ SymCryptEckeyWipePrivateState()

VOID SYMCRYPT_CALL SymCryptEckeyWipePrivateState ( _Inout_ PSYMCRYPT_ECKEY pkEckey )

Definition at line 106 of file eckey.c.

{
    SymCryptIntSetValueUint32( 0, pkEckey->piPrivateKey );
    pkEckey->hasPrivateKey = FALSE;
}

◆ SymCryptEcpointGenericSetRandom()

VOID SYMCRYPT_CALL SymCryptEcpointGenericSetRandom	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Out_ PSYMCRYPT_INT	piScalar,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 546 of file ec_mul.c.

{
    PSYMCRYPT_MODELEMENT peScalar = NULL;
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_SCALAR_ECURVE_OPERATIONS(pCurve, 1) );
    SYMCRYPT_ASSERT( cbScratch >= pCurve->cbModElement );
 
    peScalar = SymCryptModElementCreate( pbScratch, pCurve->cbModElement, pCurve->GOrd );
    SYMCRYPT_ASSERT( peScalar != NULL );
 
    // Setting a random mod element in the [1, SubgroupOrder-1] set
    SymCryptModSetRandom( pCurve->GOrd, peScalar, (SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE|SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE), pbScratch + pCurve->cbModElement, cbScratch - pCurve->cbModElement );
 
    // Setting the integer
    SymCryptModElementToInt( pCurve->GOrd, peScalar, piScalar, pbScratch + pCurve->cbModElement, cbScratch - pCurve->cbModElement );
 
    // Do the multiplication (pass over the entire scratch space as it is not needed anymore)
    // !! Explicitly not checking the error return here as the only error is from specifying invalid flags !!
    SymCryptEcpointScalarMul( pCurve, piScalar, NULL, 0, poDst, pbScratch, cbScratch );
}

◆ SymCryptEcpointMultiScalarMulWnafWithInterleaving()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcpointMultiScalarMulWnafWithInterleaving	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_reads_(nPoints) PCSYMCRYPT_INT *	piSrcScalarArray,
		_In_reads_(nPoints) PCSYMCRYPT_ECPOINT *	poSrcEcpointArray,
		UINT32	nPoints,
		UINT32	flags,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptEcpointScalarMulFixedWindow()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcpointScalarMulFixedWindow	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_INT	piScalar,
		_In_opt_ PCSYMCRYPT_ECPOINT	poSrc,
		UINT32	flags,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 90 of file ec_mul.c.

{
    SYMCRYPT_ERROR  scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
 
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
 
    UINT32  i, j;
 
    UINT32  w = pCurve->info.sw.window;
    UINT32  nPrecompPoints = pCurve->info.sw.nPrecompPoints;
    // dcl - assuming that nRecodedDigits has some reasonably small range - please document
    // so that we can know usage of this variable will not cause problems
    // Also, documentation of inputs, notes, etc at the function definition would be quite helpful
    UINT32  nRecodedDigits = ((pCurve->GOrdBitsize + w - 2) / (w-1)) + 1;
 
    // Masks
    UINT32  fZero = 0;
    UINT32  fEven = 0;
    UINT32  indexMask = 0;
 
    BOOLEAN bPrecompOffline = FALSE;
 
    // ====================================================
    // Temporaries
    PSYMCRYPT_MODELEMENT    peT = NULL;
    PSYMCRYPT_ECPOINT       poPIs[SYMCRYPT_ECURVE_SW_MAX_NPRECOMP_POINTS] = { 0 };
    PSYMCRYPT_ECPOINT       poQ = NULL;
    PSYMCRYPT_ECPOINT       poTmp = NULL;
    PSYMCRYPT_INT           piRem = NULL;
    PSYMCRYPT_INT           piTmp = NULL;
    PUINT32                 absofKIs = NULL;
    PUINT32                 sigofKIs = NULL;
    // ===================================================
 
    PSYMCRYPT_MODELEMENT    peQX = NULL;
    PSYMCRYPT_MODELEMENT    peQY = NULL;
    PSYMCRYPT_MODELEMENT    peQZ = NULL;
 
    SIZE_T cbEcpoint = SymCryptSizeofEcpointFromCurve( pCurve );
    SIZE_T cbScalar = SymCryptSizeofIntFromDigits( pCurve->GOrdDigits );
 
    // Make sure we only specify the correct flags
    if ((flags & ~SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL) != 0)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto exit;
    }
 
    // Check if poSrc is NULL and if yes set it to G
    if (poSrc == NULL)
    {
        poSrc = pCurve->G;
        bPrecompOffline = TRUE;
    }
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) ||
                     SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_SCALAR_ECURVE_OPERATIONS(pCurve, 1) );
 
    SYMCRYPT_ASSERT( cbScratch >=
                        pCurve->cbModElement +
                        (nPrecompPoints+2)*cbEcpoint +
                        2*cbScalar +
                        ((2*nRecodedDigits*sizeof(UINT32) + SYMCRYPT_ASYM_ALIGN_VALUE - 1)/SYMCRYPT_ASYM_ALIGN_VALUE )*SYMCRYPT_ASYM_ALIGN_VALUE +
                        SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    // Creating temporary modelement
    peT = SymCryptModElementCreate( pbScratch, pCurve->cbModElement, FMod );
    SYMCRYPT_ASSERT( peT != NULL );
    pbScratch += pCurve->cbModElement;
 
    // Creating temporary precomputed points (if needed)
    SYMCRYPT_ASSERT( nPrecompPoints <= SYMCRYPT_ECURVE_SW_MAX_NPRECOMP_POINTS );
    for (i=0; i<nPrecompPoints; i++)
    {
        if (bPrecompOffline)
        {
            poPIs[i] = pCurve->info.sw.poPrecompPoints[i];
        }
        else
        {
            poPIs[i] = SymCryptEcpointCreate( pbScratch, cbEcpoint, pCurve );
            SYMCRYPT_ASSERT( poPIs[i] != NULL );
            pbScratch += cbEcpoint;
        }
    }
 
    // Creating temporary points
    poQ = SymCryptEcpointCreate( pbScratch, cbEcpoint, pCurve );
    SYMCRYPT_ASSERT( poQ != NULL );
    pbScratch += cbEcpoint;
 
    poTmp = SymCryptEcpointCreate( pbScratch, cbEcpoint, pCurve );
    SYMCRYPT_ASSERT( poTmp != NULL );
    pbScratch += cbEcpoint;
 
    // Creating temporary scalar for the remainder
    piRem = SymCryptIntCreate( pbScratch, cbScalar, pCurve->GOrdDigits );
    SYMCRYPT_ASSERT( piRem != NULL);
    pbScratch += cbScalar;
 
    piTmp = SymCryptIntCreate( pbScratch, cbScalar, pCurve->GOrdDigits );
    SYMCRYPT_ASSERT( piTmp != NULL);
    pbScratch += cbScalar;
 
    // Fixing pointers to recoded digits (be careful that the remaining space is SYMCRYPT_ASYM_ALIGNed)
    absofKIs = (PUINT32) pbScratch;
    pbScratch += nRecodedDigits * sizeof(UINT32);
    sigofKIs = (PUINT32) pbScratch;
    pbScratch += nRecodedDigits * sizeof(UINT32);
    pbScratch = (PBYTE) ( ((SIZE_T)pbScratch + SYMCRYPT_ASYM_ALIGN_VALUE - 1) & ~(SYMCRYPT_ASYM_ALIGN_VALUE - 1) );
 
    // Fixing remaining scratch space size
    cbScratch -= ( pCurve->cbModElement + (nPrecompPoints+2)*cbEcpoint + 2*cbScalar );
    cbScratch -= (((2*nRecodedDigits*sizeof(UINT32) + SYMCRYPT_ASYM_ALIGN_VALUE - 1)/SYMCRYPT_ASYM_ALIGN_VALUE )*SYMCRYPT_ASYM_ALIGN_VALUE);
 
    //
    // Main algorithm
    //
 
    // It is the caller's responsibility to ensure that the provided piScalar <= GOrd, double check this in debug mode
    SYMCRYPT_ASSERT( !SymCryptIntIsLessThan( SymCryptIntFromModulus( pCurve->GOrd ), piScalar ) );
 
    // Store k into an int
    SymCryptIntCopy( piScalar, piRem );
 
    // Check if k is 0
    fZero = SymCryptIntIsEqualUint32( piRem, 0 );
 
    // Or if the src point is zero
    fZero |= SymCryptEcpointIsZero( pCurve, poSrc, pbScratch, cbScratch );
 
    // Check if k is even and convert it to r-k if true
    fEven = SYMCRYPT_MASK32_ZERO(SymCryptIntGetBit( piRem, 0 ));
    SymCryptIntSubSameSize( SymCryptIntFromModulus(pCurve->GOrd), piRem, piTmp);
    SymCryptIntMaskedCopy( piTmp, piRem, fEven );
 
    // Recoding stage
    SymCryptFixedWindowRecoding( w, piRem, piTmp, absofKIs, sigofKIs, nRecodedDigits );
 
    // Precomputation stage
    if (!bPrecompOffline)
    {
        // Copy the first point in the start of the poPIs array
        SymCryptEcpointCopy( pCurve, poSrc, poPIs[0] );
 
        SymCryptPrecomputation( pCurve, nPrecompPoints, poPIs, poQ, pbScratch, cbScratch );
    }
 
 
    // Get the pointers to Q
    peQX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poQ );
    peQY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poQ );
    peQZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poQ );
 
    // Q = P[ (|k_t|-1)/2 ] in memory access side-channel safe way
    // That is, we touch all the precomputed points. The access pattern of KIs is fixed.
    for (j=0; j<nPrecompPoints; j++)
    {
        indexMask = DELTA_MASK( j, absofKIs[nRecodedDigits-1] );
        SymCryptEcpointMaskedCopy( pCurve, poPIs[j], poQ, indexMask);
    }
 
    for (i=nRecodedDigits - 2; i>0; i--)
    {
        // Q = 2^(w-1) * Q
        for (j=0; j<w-1; j++)
        {
            SymCryptEcpointDouble( pCurve, poQ, poQ, 0, pbScratch, cbScratch );
        }
 
        // Copy the required precomputed point into poTmp (touch all points)
        for (j=0; j<nPrecompPoints; j++)
        {
            indexMask = DELTA_MASK( j, absofKIs[i] );
            SymCryptEcpointMaskedCopy( pCurve, poPIs[j], poTmp, indexMask);
        }
 
        // Negate if needed
        SymCryptEcpointNegate( pCurve, poTmp, sigofKIs[i], pbScratch, cbScratch );
 
        // Do the addition Q + s_i P[k_i]
        SymCryptEcpointAddDiffNonZero( pCurve, poQ, poTmp, poQ, pbScratch, cbScratch );
    }
 
    // Q = 2^(w-1) * Q
    for (j=0; j<w-1; j++)
    {
        SymCryptEcpointDouble( pCurve, poQ, poQ, 0, pbScratch, cbScratch );
    }
 
    // Copy the point s_0 P[k_0] into poTmp
    for (j=0; j<nPrecompPoints; j++)
    {
        indexMask = DELTA_MASK( j, absofKIs[0] );
        SymCryptEcpointMaskedCopy( pCurve, poPIs[j], poTmp, indexMask);
    }
 
    // Negate if needed
    SymCryptEcpointNegate( pCurve, poTmp, sigofKIs[0], pbScratch, cbScratch );
 
    // Complete addition routine
    SymCryptEcpointAdd( pCurve, poQ, poTmp, poQ, 0, pbScratch, cbScratch );
 
    // If even invert
    SymCryptEcpointNegate( pCurve, poQ, fEven, pbScratch, cbScratch );
 
    // Multiply by the cofactor (if needed) by continuing the doubling
    if ((pCurve->coFactorPower!=0) && ((flags & SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL) != 0))
    {
        for (j=0; j<pCurve->coFactorPower; j++)
        {
            SymCryptEcpointDouble( pCurve, poQ, poQ, 0, pbScratch, cbScratch );
        }
    }
 
    // If the resultant point is zero, ensure it will be set to the canonical zero point
    fZero |= SymCryptEcpointIsZero( pCurve, poQ, pbScratch, cbScratch );
 
    // Set the zero point
    SymCryptEcpointSetZero( pCurve, poTmp, pbScratch, cbScratch );
    SymCryptEcpointMaskedCopy( pCurve, poTmp, poQ, fZero );
 
    // Output the result (normalized flag == FALSE)
    SymCryptEcpointCopy( pCurve, poQ, poDst );
 
    scError = SYMCRYPT_NO_ERROR;
 
exit:
 
    return scError;
}

◆ SymCryptEcurveFillScratchSpaces()

VOID SYMCRYPT_CALL SymCryptEcurveFillScratchSpaces ( _Inout_ PSYMCRYPT_ECURVE pCurve )

Definition at line 296 of file ec_dispatch.c.

{
    SYMCRYPT_ECURVE_CALL( pCurve ) fillScratchSpacesFunc( pCurve );
}

Referenced by SymCryptEcurveInitialize().

◆ SymCryptFatalHang()

_Analysis_noreturn_ VOID SYMCRYPT_CALL SymCryptFatalHang ( UINT32 fatalcode )

Definition at line 101 of file libmain.c.

{
    UINT32   fcode;
 
    //
    // Put the fatal code in a location we can find
    //
    SYMCRYPT_FORCE_WRITE32( &fcode, fatalCode );
 
fatalInfiniteLoop:
    goto fatalInfiniteLoop;
}

Referenced by SymCryptFatalEnvWindowsUsermodeWin8_1nLater().

◆ SymCryptFatalIntercept()

VOID SYMCRYPT_CALL SymCryptFatalIntercept ( UINT32 fatalCode )

Definition at line 20 of file FatalIntercept.c.

{
    UNREFERENCED_PARAMETER( fatalCode );
}

Referenced by SymCryptFatalEnvWindowsUsermodeWin8_1nLater().

◆ SymCryptFdef369MaskedCopyAsm()

VOID SYMCRYPT_CALL SymCryptFdef369MaskedCopyAsm	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCBYTE	pbSrc,
		_Inout_updates_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE	pbDst,
		UINT32	nDigits,
		UINT32	mask
	)

◆ SymCryptFdef369ModAddGeneric()

VOID SYMCRYPT_CALL SymCryptFdef369ModAddGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModInvMontgomery()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdef369ModInvMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModMulMontgomery()

VOID SYMCRYPT_CALL SymCryptFdef369ModMulMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModPreGetMontgomery()

PCUINT32 SYMCRYPT_CALL SymCryptFdef369ModPreGetMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModSetPostMontgomery()

VOID SYMCRYPT_CALL SymCryptFdef369ModSetPostMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModSquareMontgomery()

VOID SYMCRYPT_CALL SymCryptFdef369ModSquareMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModSubGeneric()

VOID SYMCRYPT_CALL SymCryptFdef369ModSubGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369ModulusInitMontgomery()

VOID SYMCRYPT_CALL SymCryptFdef369ModulusInitMontgomery	(	_Inout_ PSYMCRYPT_MODULUS	pmObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdef369MontgomeryReduce()

VOID SYMCRYPT_CALL SymCryptFdef369MontgomeryReduce	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

◆ SymCryptFdef369MontgomeryReduceAsm()

VOID SYMCRYPT_CALL SymCryptFdef369MontgomeryReduceAsm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

◆ SymCryptFdef369RawAddAsm()

UINT32 SYMCRYPT_CALL SymCryptFdef369RawAddAsm	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	Dst,
		UINT32	nDigits
	)

◆ SymCryptFdef369RawMul()

VOID SYMCRYPT_CALL SymCryptFdef369RawMul	(	_In_reads_(nDigits1 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		UINT32	nDigits1,
		_In_reads_(nDigits2 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits2,
		_Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdef369RawMulAsm()

VOID SYMCRYPT_CALL SymCryptFdef369RawMulAsm	(	_In_reads_(nDigits1 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		UINT32	nDigits1,
		_In_reads_(nDigits2 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits2,
		_Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdef369RawSubAsm()

UINT32 SYMCRYPT_CALL SymCryptFdef369RawSubAsm	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	pDst,
		UINT32	nDigits
	)

◆ SymCryptFdefClaimScratch()

VOID SYMCRYPT_CALL SymCryptFdefClaimScratch	(	PBYTE	pbScratch,
		SIZE_T	cbScratch,
		SIZE_T	cbMin
	)

Definition at line 912 of file fdef_general.c.

{
#if SYMCRYPT_DEBUG
    SYMCRYPT_ASSERT( cbScratch >= cbMin );
    SymCryptWipe( pbScratch, cbMin );
#else
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
    UNREFERENCED_PARAMETER( cbMin );
#endif
}

Referenced by SymCryptFdefIntMulMixedSize(), SymCryptFdefIntSquare(), SymCryptFdefIntToDivisor(), SymCryptFdefModAddGeneric(), SymCryptFdefModElementGetValue(), SymCryptFdefModElementSetValueGeneric(), SymCryptFdefModElementSetValueNegUint32(), SymCryptFdefModElementSetValueUint32Generic(), SymCryptFdefModElementToIntGeneric(), SymCryptFdefModMulGeneric(), SymCryptFdefModNegGeneric(), SymCryptFdefModSetRandomGeneric(), SymCryptFdefModSquareGeneric(), SymCryptFdefModSubGeneric(), and SymCryptFdefRawDivMod().

◆ SymCryptFdefConditionalSwap()

VOID SYMCRYPT_CALL SymCryptFdefConditionalSwap	(	_Inout_updates_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE	pbSrc1,
		_Inout_updates_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE	pbSrc2,
		UINT32	nDigits,
		UINT32	cond
	)

Definition at line 122 of file fdef_general.c.

{
    SymCryptFdefConditionalSwapC( pbSrc1, pbSrc2, nDigits, cond );
}

Referenced by SymCryptFdefIntConditionalSwap(), and SymCryptFdefModElementConditionalSwap().

◆ SymCryptFdefCreateTrialDivisionContext()

PCSYMCRYPT_TRIALDIVISION_CONTEXT SYMCRYPT_CALL SymCryptFdefCreateTrialDivisionContext ( UINT32 nDigits )

Definition at line 1136 of file fdef_general.c.

{
    PSYMCRYPT_TRIALDIVISION_CONTEXT pRes = NULL;
    PBYTE pAlloc;
    UINT32 nBytes;
    UINT32 iPrime;
    UINT32 iGroup;
    UINT32 nPrimes;
    UINT32 nGroups;
    UINT32 M;
    UINT32 iGroupSpec;
    UINT32 i;
    UINT32 j;
    UINT64 cRabinMillerCost;
    UINT64 cPerPrimeCost;
    UINT64 tmp64;
    UINT32 maxPrime;
    UINT32 minPrime;
    UINT32 nSmallPrimes = 0;
    UINT32 n;
    UINT32 nP;
    UINT32 nG;
    PUINT32 pSmallPrimeList = NULL;
 
    // First we estimate the largest prime we will do trial division with
    // Inputs:
    // - cycles/digit of reduction per group of primes
    // - cycles/prime of divide test
    // - cycles per digit^3 for a Rabin-Miller test
    // We optimize in this model, which is pretty accurate for large inputs but underestimates the RM cost
    // for smaller sizes.
 
    // Compute the Rabin-Miller cost estimate. We reduce it by 20% because our cost model does not take
    // into account some of the trial-division cost such as memory footprint, cache pressure,
    // setup cost, etc. Reducing the Rabin-Miller cost leads us to do fewer trial divisions to approximately
    // balance the hidden costs.
 
    if( nDigits <= 1000 )
    {
        // nDigits is small enough to not have any overflows in this computation
        if( nDigits == 0 )
        {
            goto cleanup; // return NULL
        }
 
        cRabinMillerCost = (UINT64) nDigits * nDigits * nDigits * (SYMCRYPT_RABINMILLER_DIGIT_CYCLES * 8 / 10);
        i = 0;
        minPrime = 0;
        for(;;)
        {
            nPrimes = g_SymCryptSmallPrimeGroupsSpec[i].nPrimes;
            maxPrime = g_SymCryptSmallPrimeGroupsSpec[i].maxPrime;
            nGroups = g_SymCryptSmallPrimeGroupsSpec[i].nGroups;
            cPerPrimeCost = (UINT64) nDigits * SYMCRYPT_TRIALDIVISION_DIGIT_REDUCTION_CYCLES / nPrimes + SYMCRYPT_TRIALDIVISION_DIVIDE_TEST_CYCLES;
 
            // If the last group isn't worth it, we shouldn't go to even fewer primes
            if( nGroups == 0 || maxPrime * cPerPrimeCost >=  cRabinMillerCost)
            {
                break;
            }
            i++;
            minPrime = maxPrime;
        }
 
        // Now we know how many primes are in the last groups, let's find out how large the largest prime should be
        tmp64 = cRabinMillerCost / cPerPrimeCost;
        tmp64 = SYMCRYPT_MIN( tmp64, SYMCRYPT_TRIALDIVISION_MAX_SMALL_PRIME );
        maxPrime = (UINT32) tmp64;
        maxPrime = SYMCRYPT_MAX( maxPrime, minPrime );       // Make sure we don't fall into the previous group size that we don't want
    }
    else
    {
        maxPrime = SYMCRYPT_TRIALDIVISION_MAX_SMALL_PRIME;
    }
 
    nSmallPrimes = SymCryptGenerateSmallPrimes( maxPrime, &pSmallPrimeList );
 
    // Find out how many groups we'll have, and how many actual primes we'll use
    n = nSmallPrimes;
    nG = 0;
    nP = 0;
    i = 0;
    for(;;)
    {
        nPrimes = g_SymCryptSmallPrimeGroupsSpec[i].nPrimes;
        nGroups = g_SymCryptSmallPrimeGroupsSpec[i].nGroups;
 
        if( n < nPrimes * nGroups || nGroups == 0 )
        {
            // At the right nPrimes, compute exactly how many groups to add
            n = n / nPrimes;
            nG += n;
            nP += n * nPrimes;
            n = 0;      // No primes left
            break;
        }
 
        // Use up all the groups of this size...
        nG += nGroups;
        nP += nPrimes * nGroups;
        n -= nPrimes * nGroups;
        i++;
    }
 
    // dcl - Potential integer overflow
    // Need to document sizes, and limits of nG, nP, and confirm
    // an overflow is not possible, also recall that size_t varies in size, but nBytes is 32-bit
    nBytes = sizeof( SYMCRYPT_TRIALDIVISION_CONTEXT )
            + (nG + 1) * sizeof( SYMCRYPT_TRIALDIVISION_GROUP )     // + 1 for 0 sentinel
            + (nP + 1) * sizeof( SYMCRYPT_TRIALDIVISION_PRIME )     // + 1 for 0 sentinel
            + (nP + 1) * sizeof( UINT32 );                          // + 1 for 0 sentinel
 
    pAlloc = SymCryptCallbackAlloc( nBytes );
    if( pAlloc == NULL )
    {
        goto cleanup;
    }
 
    pRes = (PSYMCRYPT_TRIALDIVISION_CONTEXT) pAlloc;
    pAlloc += sizeof( *pRes );
 
    pRes->nBytesAlloc = nBytes;
 
    pRes->pGroupList = (PSYMCRYPT_TRIALDIVISION_GROUP)pAlloc;
    pAlloc += (nG + 1) * sizeof( SYMCRYPT_TRIALDIVISION_GROUP );
 
    pRes->pPrimeList = (PSYMCRYPT_TRIALDIVISION_PRIME) pAlloc;
    pAlloc += (nP + 1) * sizeof( SYMCRYPT_TRIALDIVISION_PRIME );
 
    pRes->pPrimes = (PUINT32) pAlloc;
    pAlloc += (nP + 1) * sizeof( UINT32 );
 
    SYMCRYPT_ASSERT( nBytes == (SIZE_T)(pAlloc - (PBYTE)pRes) );
 
    // Initialize the primes 3, 5, and 17
    SymCryptFdefInitTrialdivisionPrime(  3, &pRes->Primes3_5_17[0] );
    SymCryptFdefInitTrialdivisionPrime(  5, &pRes->Primes3_5_17[1] );
    SymCryptFdefInitTrialdivisionPrime( 17, &pRes->Primes3_5_17[2] );
 
    memcpy( pRes->pPrimes, pSmallPrimeList, nP * sizeof( UINT32 ) );
    pRes->pPrimes[nP] = 0;
    pRes->maxTrialPrime = pRes->pPrimes[nP-1];
 
    /*
    *** Old code to decrypt the nibble encoding. Keep in case we want it back later...
    // Generate the other primes from the difference table.
    // We initialize the prime structures, and a list of the primes that is used to compute the group specs
 
    pNibs = &g_SymCryptSmallPrimeDifferenceNibbles[0];
 
    smallPrime = 3;
    nPrimes = 0;
    while( smallPrime < SYMCRYPT_MAX_SMALL_PRIME )
    {
        b = *pNibs++;
        nib = b & 0xf;
 
        if( nib == 0 )
        {
            smallPrime += 30;
            // No check for termination here as we wouldn't encode a 0 if there wasn't another prime.
        } else {
            smallPrime += 2*nib;
            pRes->pPrimes[nPrimes] = smallPrime;
            SymCryptFdefInitTrialdivisionPrime( smallPrime, &pRes->pPrimeList[nPrimes] );
            nPrimes++;
            if( smallPrime >= SYMCRYPT_MAX_SMALL_PRIME )
            {
                break;
            }
        }
        nib = b >> 4;
        if( nib == 0 )
        {
            smallPrime += 30;
        } else {
            smallPrime += 2*nib;
            pRes->pPrimes[nPrimes] = smallPrime;
            SymCryptFdefInitTrialdivisionPrime( smallPrime, &pRes->pPrimeList[nPrimes] );
            nPrimes++;
        }
    }
    SYMCRYPT_ASSERT( smallPrime == SYMCRYPT_MAX_SMALL_PRIME && nPrimes == SYMCRYPT_N_SMALL_PRIMES_ENCODED );
    */
 
    for( iPrime = 0; iPrime < nP; iPrime++ )
    {
        SymCryptFdefInitTrialdivisionPrime( pRes->pPrimes[iPrime], &pRes->pPrimeList[iPrime] );
    }
 
    // Add the trailing 0s
    pRes->pPrimeList[nP].invMod2e64 = 0;
    pRes->pPrimeList[nP].compareLimit = 0;
 
    // Make sure we have the 32-bit tables, not the 64-bit ones.
    // dcl - warning suppression is not portable. Also, if it is a compile time constant, shouldn't it be a compile assert?
#pragma warning( suppress: 4127 )       // conditional expression is constant
    SYMCRYPT_ASSERT( SYMCRYPT_MAX_SMALL_PRIME_GROUP_PRODUCT <= (UINT32)-1 );
 
    iGroup = 0;
    iPrime = 0;
    iGroupSpec = 0;
    nPrimes = g_SymCryptSmallPrimeGroupsSpec[iGroupSpec].nPrimes;
    nGroups = g_SymCryptSmallPrimeGroupsSpec[iGroupSpec].nGroups;
    while( iPrime < nP )
    {
        if( nGroups == 0 )
        {
            iGroupSpec +=1 ;
            nPrimes = g_SymCryptSmallPrimeGroupsSpec[iGroupSpec].nPrimes;
            nGroups = g_SymCryptSmallPrimeGroupsSpec[iGroupSpec].nGroups;
            if( nGroups == 0 )
            {
                nGroups = nG - iGroup;
            }
        }
 
        SYMCRYPT_ASSERT( iPrime + nPrimes <= nP );
        M = pRes->pPrimes[iPrime++];
        for( j=1; j<nPrimes; j++ )
        {
            SYMCRYPT_ASSERT( M <= SYMCRYPT_MAX_SMALL_PRIME_GROUP_PRODUCT / pRes->pPrimes[iPrime] );
            M *= pRes->pPrimes[iPrime++];
        }
        SymCryptFdefInitTrialDivisionGroup( &pRes->pGroupList[iGroup], nPrimes, M );
        iGroup++;
 
        nGroups--;
    }
 
    SYMCRYPT_ASSERT( iPrime == nP && iGroup == nG );
 
    // Add the trailing sentinel group
    pRes->pGroupList[iGroup].nPrimes = 0;
 
cleanup:
    if( pSmallPrimeList != NULL )
    {
        SymCryptWipe( pSmallPrimeList, nSmallPrimes * sizeof( UINT32 ) );
        SymCryptCallbackFree( pSmallPrimeList );
        pSmallPrimeList = NULL;
    }
    return pRes;
}

Referenced by SymCryptCreateTrialDivisionContext().

◆ SymCryptFdefDigitsFromBits()

UINT32 SymCryptFdefDigitsFromBits ( UINT32 nBits )

Definition at line 133 of file fdef_general.c.

{
    UINT32  res;
 
    if( nBits == 0 )
    {
        res = 1;
    }
    else
    {
        SYMCRYPT_ASSERT( nBits <= SYMCRYPT_INT_MAX_BITS );
 
        // Callers with integers larger than SYMCRYPT_INT_MAX_BITS should not occur in real use cases
        // To avoid overflow issues, return the 0 digits to indicate an error which can be handled by
        // callers, or flow through into object allocation which will in turn recognize the invalid
        // digit count.
        if( nBits > SYMCRYPT_INT_MAX_BITS )
        {
            res = 0;
        } else {
            res = SYMCRYPT_FDEF_DIGITS_FROM_BITS( nBits );
        }
    }
 
    return res;
}

Referenced by SymCryptDigitsFromBits().

◆ SymCryptFdefDivisorAllocate()

PSYMCRYPT_DIVISOR SYMCRYPT_CALL SymCryptFdefDivisorAllocate ( UINT32 nDigits )

Definition at line 796 of file fdef_general.c.

{
    PVOID               p = NULL;
    UINT32              cb;
    PSYMCRYPT_DIVISOR   res = NULL;
 
    //
    // The nDigits requirements are enforced by SymCryptFdefSizeofDivisorFromDigits. Thus
    // the result does not overflow and is upper bounded by 2^19.
    //
    cb = SymCryptFdefSizeofDivisorFromDigits( nDigits );
 
    if( cb != 0 )
    {
        p = SymCryptCallbackAlloc( cb );
    }
 
    if( p == NULL )
    {
        goto cleanup;
    }
 
    res = SymCryptFdefDivisorCreate( p, cb, nDigits );
 
cleanup:
    return res;
}

Referenced by SymCryptDivisorAllocate().

◆ SymCryptFdefDivisorCopy()

VOID SymCryptFdefDivisorCopy	(	_In_ PCSYMCRYPT_DIVISOR	pdSrc,
		_Out_ PSYMCRYPT_DIVISOR	pdDst
	)

Definition at line 891 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( pdSrc );
    SYMCRYPT_CHECK_MAGIC( pdDst );
 
    SYMCRYPT_ASSERT( pdSrc->nDigits == pdDst->nDigits );
 
    // in-place copy is somewhat common, and addresses are always public, so we can test for a no-op copy.
    if( pdSrc != pdDst )
    {
        memcpy( pdDst, pdSrc, pdDst->cbSize );
 
        SymCryptFdefDivisorCopyFixup( pdSrc, pdDst );
    }
}

Referenced by SymCryptDivisorCopy().

◆ SymCryptFdefDivisorCopyFixup()

VOID SymCryptFdefDivisorCopyFixup	(	_In_ PCSYMCRYPT_DIVISOR	pSrc,
		_Out_ PSYMCRYPT_DIVISOR	pDst
	)

Definition at line 878 of file fdef_general.c.

{
    UNREFERENCED_PARAMETER( pdSrc );
    UNREFERENCED_PARAMETER( pdDst );
 
    SymCryptFdefIntCopyFixup( &pdSrc->Int, &pdDst->Int );
 
    SYMCRYPT_SET_MAGIC( pdDst );
}

Referenced by SymCryptFdefDivisorCopy(), and SymCryptFdefModulusCopy().

◆ SymCryptFdefDivisorCreate()

PSYMCRYPT_DIVISOR SYMCRYPT_CALL SymCryptFdefDivisorCreate	(	_Out_writes_bytes_(cbBuffer) PBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		UINT32	nDigits
	)

Definition at line 842 of file fdef_general.c.

{
    PSYMCRYPT_DIVISOR  pdDiv = NULL;
    UINT32 cb = SymCryptSizeofDivisorFromDigits( nDigits );
 
    SYMCRYPT_ASSERT( cb >= sizeof(SYMCRYPT_DIVISOR) );
    SYMCRYPT_ASSERT( cbBuffer >= cb );
    if( (cb == 0) || (cbBuffer < cb) )
    {
        goto cleanup; // return NULL
    }
 
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
    pdDiv = (PSYMCRYPT_DIVISOR) pbBuffer;
 
    pdDiv->type = 'gD' << 16;
    pdDiv->nDigits = nDigits;
 
    //
    // The nDigits requirements are enforced by SymCryptFdefSizeofDivisorFromDigits. Thus
    // the result does not overflow and is upper bounded by 2^19.
    //
    pdDiv->cbSize = cb;
 
    SYMCRYPT_SET_MAGIC( pdDiv );
 
    SymCryptIntCreate( (PBYTE)&pdDiv->Int, cbBuffer - SYMCRYPT_FIELD_OFFSET( SYMCRYPT_DIVISOR, Int ), nDigits );
 
cleanup:
    return pdDiv;
}

Referenced by SymCryptDivisorCreate(), SymCryptFdefDivisorAllocate(), and SymCryptFdefModulusCreate().

◆ SymCryptFdefDivisorFromModulus()

PSYMCRYPT_DIVISOR SYMCRYPT_CALL SymCryptFdefDivisorFromModulus ( _In_ PSYMCRYPT_MODULUS pmSrc )

Definition at line 265 of file fdef_mod.c.

{
    return &pmSrc->Divisor;
}

Referenced by SymCryptDivisorFromModulus().

◆ SymCryptFdefDivisorRetrieveHandle()

PSYMCRYPT_DIVISOR SYMCRYPT_CALL SymCryptFdefDivisorRetrieveHandle ( _In_ PBYTE pbBuffer )

◆ SymCryptFdefFreeTrialDivisionContext()

VOID SYMCRYPT_CALL SymCryptFdefFreeTrialDivisionContext ( PCSYMCRYPT_TRIALDIVISION_CONTEXT pContext )

Definition at line 1383 of file fdef_general.c.

{
    // No security reason to wipe it, but our test code verifies that we wipe everything...
    // Perf cost is minor
    SymCryptWipe( (PBYTE) pContext, pContext->nBytesAlloc );
    SymCryptCallbackFree( (PSYMCRYPT_TRIALDIVISION_CONTEXT) pContext );
}

Referenced by SymCryptFreeTrialDivisionContext().

◆ SymCryptFdefIntAddMixedSize()

UINT32 SYMCRYPT_CALL SymCryptFdefIntAddMixedSize	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 113 of file fdef_int.c.

{
    UINT32      nS1 = piSrc1->nDigits;
    UINT32      nS2 = piSrc2->nDigits;
    UINT32      nD  = piDst->nDigits;
    UINT32      c;
    UINT32      nW;
 
    SYMCRYPT_ASSERT( nD >= nS1 && nD >= nS2 );
 
    if( nS1 < nS2 )
    {
        c = SymCryptFdefRawAdd( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), SYMCRYPT_FDEF_INT_PUINT32( piDst ), nS1 );
        c = SymCryptFdefRawAddUint32( &SYMCRYPT_FDEF_INT_PUINT32( piSrc2 )[nS1 * SYMCRYPT_FDEF_DIGIT_NUINT32], c, &SYMCRYPT_FDEF_INT_PUINT32( piDst )[nS1 * SYMCRYPT_FDEF_DIGIT_NUINT32], nS2 - nS1 );
        nW = nS2;
    } else {
        // nS2 < nS1
        c = SymCryptFdefRawAdd( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), SYMCRYPT_FDEF_INT_PUINT32( piDst ), nS2 );
        c = SymCryptFdefRawAddUint32( &SYMCRYPT_FDEF_INT_PUINT32( piSrc1 )[nS2 * SYMCRYPT_FDEF_DIGIT_NUINT32], c, &SYMCRYPT_FDEF_INT_PUINT32( piDst )[nS2 * SYMCRYPT_FDEF_DIGIT_NUINT32], nS1 - nS2 );
        nW = nS1;
    }
 
    if( nW < nD )
    {
        SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piDst )[nW * SYMCRYPT_FDEF_DIGIT_NUINT32], (nD - nW) * SYMCRYPT_FDEF_DIGIT_SIZE );
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[nW * SYMCRYPT_FDEF_DIGIT_NUINT32] = c;
        c = 0;
    }
 
    return c;
}

Referenced by SymCryptIntAddMixedSize().

◆ SymCryptFdefIntAddSameSize()

UINT32 SYMCRYPT_CALL SymCryptFdefIntAddSameSize	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 98 of file fdef_int.c.

{
    SYMCRYPT_ASSERT( piSrc1->nDigits == piSrc2->nDigits && piSrc2->nDigits == piDst->nDigits );
 
    return SymCryptFdefRawAdd(  SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ),
                                SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ),
                                SYMCRYPT_FDEF_INT_PUINT32( piDst ),
                                piDst->nDigits );
}

Referenced by SymCryptIntAddSameSize().

◆ SymCryptFdefIntAddUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefIntAddUint32	(	_In_ PCSYMCRYPT_INT	piSrc1,
		UINT32	u32Src2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 83 of file fdef_int.c.

{
    SYMCRYPT_CHECK_MAGIC( piSrc1 );
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    SYMCRYPT_ASSERT( piSrc1->nDigits == piDst->nDigits );
 
    return SymCryptFdefRawAddUint32( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), u32Src2, SYMCRYPT_FDEF_INT_PUINT32( piDst ), piDst->nDigits );
}

Referenced by SymCryptIntAddUint32().

◆ SymCryptFdefIntAllocate()

PSYMCRYPT_INT SYMCRYPT_CALL SymCryptFdefIntAllocate ( UINT32 nDigits )

Definition at line 165 of file fdef_general.c.

{
    PVOID               p = NULL;
    UINT32              cb;
    PSYMCRYPT_INT       res = NULL;
 
    //
    // The nDigits requirements are enforced by SymCryptFdefSizeofIntFromDigits. Thus
    // the result does not overflow and is upper bounded by 2^18.
    //
    cb = SymCryptFdefSizeofIntFromDigits( nDigits );
 
    if( cb != 0 )
    {
        p = SymCryptCallbackAlloc( cb );
    }
 
    if( p == NULL )
    {
        goto cleanup;
    }
 
    res = SymCryptIntCreate( p, cb, nDigits );
 
cleanup:
    return res;
}

Referenced by SymCryptIntAllocate().

◆ SymCryptFdefIntBitsizeOfObject()

UINT32 SYMCRYPT_CALL SymCryptFdefIntBitsizeOfObject ( _In_ PCSYMCRYPT_INT piSrc )

Definition at line 328 of file fdef_general.c.

{
    // This does not overflow since the nDigits field is
    // bounded by SYMCRYPT_FDEF_UPB_DIGITS.
    return SYMCRYPT_FDEF_DIGIT_BITS * piSrc->nDigits;
}

Referenced by SymCryptIntBitsizeOfObject().

◆ SymCryptFdefIntBitsizeOfValue()

UINT32 SYMCRYPT_CALL SymCryptFdefIntBitsizeOfValue ( _In_ PCSYMCRYPT_INT piSrc )

Definition at line 451 of file fdef_general.c.

{
    UINT32  nUint32 = SYMCRYPT_OBJ_NUINT32( piSrc );
 
    UINT32  res = 0;
    UINT32  msNonzeroWord = 0;      // most significant nonzero digit
    UINT32  searchingMask = SYMCRYPT_MASK32_SET; // Set if still searching, 0 otherwise
    UINT32  d;
    UINT32  dIsNonzeroMask;
    UINT32  foundMask;
 
    SYMCRYPT_CHECK_MAGIC( piSrc );
 
    // This while loop reveals the value of nUint32, is that OK?
    // If so, document why
    while( nUint32 > 0 )
    {
        //
        // Invariant:
        // If no nonzero digit has been found, res = 0 and updateMask = -1.
        // If a nonzero digit has been found:
        //  msNonzeroDigit = most significant nonzero digit in Src
        //  res = index where most-significant nonzero digit was found
        //  updateMask = 0
        //
 
        nUint32--;
        d = SYMCRYPT_FDEF_INT_PUINT32( piSrc )[nUint32];
 
        dIsNonzeroMask = SYMCRYPT_MASK32_NONZERO( d );
        foundMask = dIsNonzeroMask & searchingMask;
        res |= nUint32 & foundMask;
        msNonzeroWord |= d & foundMask;
        searchingMask &= ~foundMask;
    }
 
    //
    // If all words are zero, then res == 0 and msNonzeroDigit == 0.
    //
    res = res * 8 * sizeof( UINT32 ) + SymCryptFdefBitsizeOfUint32( msNonzeroWord );
 
    return res;
}

Referenced by SymCryptIntBitsizeOfValue().

◆ SymCryptFdefIntConditionalCopy()

VOID SYMCRYPT_CALL SymCryptFdefIntConditionalCopy	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Inout_ PSYMCRYPT_INT	piDst,
		UINT32	cond
	)

Definition at line 298 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( piSrc );
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
 
    SymCryptFdefMaskedCopy( (PBYTE) SYMCRYPT_FDEF_INT_PUINT32( piSrc ), (PBYTE) SYMCRYPT_FDEF_INT_PUINT32( piDst ), piSrc->nDigits, SYMCRYPT_MASK32_NONZERO( cond ) );
}

Referenced by SymCryptIntConditionalCopy().

◆ SymCryptFdefIntConditionalSwap()

VOID SYMCRYPT_CALL SymCryptFdefIntConditionalSwap	(	_Inout_ PSYMCRYPT_INT	piSrc1,
		_Inout_ PSYMCRYPT_INT	piSrc2,
		UINT32	cond
	)

Definition at line 313 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( piSrc1 );
    SYMCRYPT_CHECK_MAGIC( piSrc2 );
 
    SYMCRYPT_ASSERT( piSrc1->nDigits == piSrc2->nDigits );
 
    SymCryptFdefConditionalSwap( (PBYTE) SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), (PBYTE) SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), piSrc1->nDigits, cond );
}

Referenced by SymCryptIntConditionalSwap().

◆ SymCryptFdefIntCopy()

VOID SymCryptFdefIntCopy	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 259 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( piSrc );
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
 
    //
    // in-place copy is somewhat common, and addresses are always public, so we can test for a no-op copy.
    //
    if( piSrc != piDst )
    {
        // This is normally considered a banned, unsafe function. A note about why it is safe in this use
        // would be good.
        memcpy( SYMCRYPT_FDEF_INT_PUINT32( piDst ), SYMCRYPT_FDEF_INT_PUINT32( piSrc ), SYMCRYPT_OBJ_NBYTES( piDst ));
    }
}

Referenced by SymCryptFdefIntToDivisor(), and SymCryptIntCopy().

◆ SymCryptFdefIntCopyMixedSize()

SYMCRYPT_ERROR SymCryptFdefIntCopyMixedSize	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 343 of file fdef_general.c.

{
    UINT32  n;
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
 
    SYMCRYPT_CHECK_MAGIC( piSrc );
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    // in-place copy is somewhat common, and addresses are always public, so we can test for a no-op copy.
    if( piSrc == piDst )
    {
        goto cleanup;
    }
 
    //
    // Copy the digits that are available in both
    //
    n = SYMCRYPT_MIN( piSrc->nDigits, piDst->nDigits );
    memcpy( SYMCRYPT_FDEF_INT_PUINT32( piDst ), SYMCRYPT_FDEF_INT_PUINT32( piSrc ), n * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    if( piDst->nDigits > n )
    {
        SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piDst )[n * SYMCRYPT_FDEF_DIGIT_NUINT32], (piDst->nDigits - n) * SYMCRYPT_FDEF_DIGIT_SIZE );
    }
 
    if( piSrc->nDigits > n )
    {
        // Check that the rest of the source is zero
        PUINT64 p = (PUINT64) &SYMCRYPT_FDEF_INT_PUINT32( piSrc )[n * SYMCRYPT_FDEF_DIGIT_NUINT32];
        UINT64 v = 0;
        UINT32 i = (piSrc->nDigits - n) * SYMCRYPT_FDEF_DIGIT_SIZE / sizeof( UINT64 );
        while( i > 0 )
        {
            v |= *p++;
            i--;
        }
 
        //
        // If the Src doesn't fit, we are allowed to publish that fact, so we can use an IF.
        //
        if( v != 0 )
        {
            scError = SYMCRYPT_BUFFER_TOO_SMALL;
            goto cleanup;
        }
    }
 
cleanup:
    return scError;
}

Referenced by SymCryptIntCopyMixedSize().

◆ SymCryptFdefIntCreate()

PSYMCRYPT_INT SYMCRYPT_CALL SymCryptFdefIntCreate	(	_Out_writes_bytes_(cbBuffer) PBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		UINT32	nDigits
	)

Definition at line 213 of file fdef_general.c.

{
    PSYMCRYPT_INT pInt = NULL;
    UINT32 cb = SymCryptFdefSizeofIntFromDigits( nDigits );
 
    SYMCRYPT_ASSERT( cb >= sizeof(SYMCRYPT_INT) );
    SYMCRYPT_ASSERT( cbBuffer >= cb );
    if( (cb == 0) || (cbBuffer < cb) )
    {
        goto cleanup; // return NULL
    }
 
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
    pInt = (PSYMCRYPT_INT) pbBuffer;
 
    pInt->type = 'gI' << 16;
    pInt->nDigits = nDigits;
 
    //
    // The nDigits requirements are enforced by SymCryptFdefSizeofIntFromDigits. Thus
    // the result does not overflow and is upper bounded by 2^18.
    //
    pInt->cbSize = cb;
 
    SYMCRYPT_SET_MAGIC( pInt );
 
cleanup:
    return pInt;
}

Referenced by SymCryptIntCreate().

◆ SymCryptFdefIntDivMod()

VOID SYMCRYPT_CALL SymCryptFdefIntDivMod	(	_In_ PCSYMCRYPT_INT	piSrc,
		_In_ PCSYMCRYPT_DIVISOR	pdDivisor,
		_Out_opt_ PSYMCRYPT_INT	piQuotient,
		_Out_opt_ PSYMCRYPT_INT	piRemainder,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1219 of file fdef_int.c.

{
    UINT32  nDigits = SYMCRYPT_OBJ_NDIGITS( piSrc );
 
    SYMCRYPT_ASSERT( piQuotient  == NULL || piQuotient->nDigits >= piSrc->nDigits );
    SYMCRYPT_ASSERT( piRemainder == NULL || piRemainder->nDigits >= pdDivisor->nDigits );
 
    SymCryptFdefRawDivMod(
        SYMCRYPT_FDEF_INT_PUINT32( piSrc ),
        nDigits,
        pdDivisor,
        piQuotient  == NULL ? NULL : SYMCRYPT_FDEF_INT_PUINT32( piQuotient ),
        piRemainder == NULL ? NULL : SYMCRYPT_FDEF_INT_PUINT32( piRemainder ),
        pbScratch,
        cbScratch
        );
 
    if ((piQuotient != NULL) && (piQuotient->nDigits > piSrc->nDigits))
    {
        SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piQuotient )[piSrc->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32], (piQuotient->nDigits - piSrc->nDigits) * SYMCRYPT_FDEF_DIGIT_SIZE );
    }
 
    if ((piRemainder != NULL) && (piRemainder->nDigits > pdDivisor->nDigits))
    {
        SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piRemainder )[pdDivisor->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32], (piRemainder->nDigits - pdDivisor->nDigits) * SYMCRYPT_FDEF_DIGIT_SIZE );
    }
}

Referenced by SymCryptIntDivMod().

◆ SymCryptFdefIntDivPow2()

VOID SYMCRYPT_CALL SymCryptFdefIntDivPow2	(	_In_ PCSYMCRYPT_INT	piSrc,
		SIZE_T	exp,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 469 of file fdef_int.c.

{
    SIZE_T  shiftWords = exp / NATIVE_BITS;
    SIZE_T  shiftRightBits  = exp % NATIVE_BITS;
    SIZE_T  shiftLeftBits   = (NATIVE_BITS-1) - shiftRightBits;
    NATIVE_UINT lowWord, highWord, highPart;
    SIZE_T i = 0;
 
    NATIVE_UINT nWords = piDst->nDigits * SYMCRYPT_FDEF_DIGIT_NNATIVE_UINT;
 
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
 
    shiftWords = SYMCRYPT_MIN(shiftWords, nWords);
    if( shiftWords < nWords )
    {
        lowWord = SYMCRYPT_FDEF_INT_PNATIVE_UINT(piSrc)[shiftWords];
        while( i+shiftWords+1 < nWords )
        {
            highWord = SYMCRYPT_FDEF_INT_PNATIVE_UINT(piSrc)[i+shiftWords+1];
 
            // We always shift highWord left by 1 to keep variable shiftLeftBits in range [0,NATIVE_BITS-1]
            highPart = (highWord << shiftLeftBits)<<1;
 
            SYMCRYPT_FDEF_INT_PNATIVE_UINT(piDst)[i] = (lowWord >> shiftRightBits) | highPart;
 
            lowWord = highWord;
            i++;
        }
        SYMCRYPT_FDEF_INT_PNATIVE_UINT(piDst)[i] = (lowWord >> shiftRightBits);
        i++;
    }
 
    SYMCRYPT_ASSERT(i + shiftWords == nWords);
 
    SymCryptWipe( &SYMCRYPT_FDEF_INT_PNATIVE_UINT( piDst )[nWords-shiftWords], shiftWords * NATIVE_BYTES );
}

Referenced by SymCryptIntDivPow2().

◆ SymCryptFdefIntFindSmallDivisor()

UINT32 SYMCRYPT_CALL SymCryptFdefIntFindSmallDivisor	(	_In_ PCSYMCRYPT_TRIALDIVISION_CONTEXT	pContext,
		_In_ PCSYMCRYPT_INT	piSrc,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1393 of file fdef_general.c.

{
    PCUINT32    pSrc = SYMCRYPT_FDEF_INT_PUINT32( piSrc );
    PCUINT32    p;
    UINT32      nDigits = piSrc->nDigits;
    UINT32      nUint32 = nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
    UINT64      Acc;
    PCSYMCRYPT_TRIALDIVISION_GROUP pGroup;
    PCSYMCRYPT_TRIALDIVISION_PRIME pPrime;
    UINT32      nPrimes;
    UINT32      res;
 
    // Check for 2. Not really needed for prime generation, but it makes the function easier to test/document/describe.
    if( (*pSrc & 1) == 0 )
    {
        res = 2;
        goto cleanup;
    }
 
    // Check the factors 3, 5, 17. These are special as they divide 2^32 - 1
    // (We could also do 257 and 65537 but that doesn't seem worth the added complexity.)
    Acc = 0;
    p = pSrc;
    do {
#if SYMCRYPT_FDEF_DIGIT_SIZE == 16
        Acc = Acc + p[0] + p[1] + p[2] + p[3];
        p += 4;
#elif (SYMCRYPT_FDEF_DIGIT_SIZE % 32) == 0
        Acc = Acc + p[0] + p[1] + p[2] + p[3] + p[4] + p[5] + p[6] + p[7];
        p += 8;
#else
        // dcl - ideally, #error would have a descriptive message so it is easily found in code if encountered, same below
#error ??
#endif
    } while( p < pSrc + nUint32 );
 
    if( SymCryptIsMultipleOfSmallPrime( Acc, &pContext->Primes3_5_17[0] ) )
    {
        res = 3;
        goto cleanup;
    }
 
    if( SymCryptIsMultipleOfSmallPrime( Acc, &pContext->Primes3_5_17[1] ) )
    {
        res = 5;
        goto cleanup;
    }
 
    if( SymCryptIsMultipleOfSmallPrime( Acc, &pContext->Primes3_5_17[2] ) )
    {
        res = 17;
        goto cleanup;
    }
 
    pGroup = pContext->pGroupList;
    pPrime = pContext->pPrimeList;
    while( (nPrimes = pGroup->nPrimes) != 0 )
    {
        // Reduce Src modulo the group product to a 64-bit value
        Acc = 0;
        p = pSrc + nUint32;
 
#if SYMCRYPT_FDEF_DIGIT_SIZE == 16
        if( (nUint32 & 4) != 0 )
        {
            // nUInt32 is 4 mod 8, process the top 4 words only
            p -= 4;
            Acc =
                p[0] +
                SYMCRYPT_MUL32x32TO64( p[1],  pGroup->factor[0] ) +
                SYMCRYPT_MUL32x32TO64( p[2],  pGroup->factor[1] ) +
                SYMCRYPT_MUL32x32TO64( p[3],  pGroup->factor[2] );
        } else {
            // Process 8 words to start
            p -= 8;
            Acc =
                p[0] +
                SYMCRYPT_MUL32x32TO64( p[1],  pGroup->factor[0] ) +
                SYMCRYPT_MUL32x32TO64( p[2],  pGroup->factor[1] ) +
                SYMCRYPT_MUL32x32TO64( p[3],  pGroup->factor[2] ) +
                SYMCRYPT_MUL32x32TO64( p[4],  pGroup->factor[3] ) +
                SYMCRYPT_MUL32x32TO64( p[5],  pGroup->factor[4] ) +
                SYMCRYPT_MUL32x32TO64( p[6],  pGroup->factor[5] ) +
                SYMCRYPT_MUL32x32TO64( p[7],  pGroup->factor[6] );
        }
#elif (SYMCRYPT_FDEF_DIGIT_SIZE % 32) == 0
 
        p -= 8;
        Acc =
            p[0] +
            SYMCRYPT_MUL32x32TO64( p[1],  pGroup->factor[0] ) +
            SYMCRYPT_MUL32x32TO64( p[2],  pGroup->factor[1] ) +
            SYMCRYPT_MUL32x32TO64( p[3],  pGroup->factor[2] ) +
            SYMCRYPT_MUL32x32TO64( p[4],  pGroup->factor[3] ) +
            SYMCRYPT_MUL32x32TO64( p[5],  pGroup->factor[4] ) +
            SYMCRYPT_MUL32x32TO64( p[6],  pGroup->factor[5] ) +
            SYMCRYPT_MUL32x32TO64( p[7],  pGroup->factor[6] );
 
#else
#error ??
#endif
        while( p > pSrc )
        {
            p -= 8;
            Acc =
                p[0] +
                SYMCRYPT_MUL32x32TO64( p[1],  pGroup->factor[0] ) +
                SYMCRYPT_MUL32x32TO64( p[2],  pGroup->factor[1] ) +
                SYMCRYPT_MUL32x32TO64( p[3],  pGroup->factor[2] ) +
                SYMCRYPT_MUL32x32TO64( p[4],  pGroup->factor[3] ) +
                SYMCRYPT_MUL32x32TO64( p[5],  pGroup->factor[4] ) +
                SYMCRYPT_MUL32x32TO64( p[6],  pGroup->factor[5] ) +
                SYMCRYPT_MUL32x32TO64( p[7],  pGroup->factor[6] ) +
                SYMCRYPT_MUL32x32TO64( (UINT32) Acc       , pGroup->factor[7] ) +
                SYMCRYPT_MUL32x32TO64( (UINT32)(Acc >> 32), pGroup->factor[8] );
        }
 
        // Now we check whether we have a multiple of one of the primes
        while( nPrimes > 0 )
        {
            if( SymCryptIsMultipleOfSmallPrime( Acc, pPrime ) )
            {
                res = pContext->pPrimes[ (pPrime - pContext->pPrimeList) ];    // pointer subtraction auto-divides by size...
                goto cleanup;
            }
            pPrime++;
            nPrimes--;
        }
 
        pGroup++;
    }
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    // Did not find a small factor, return zero
    res = 0;
 
cleanup:
    return res;
}

Referenced by SymCryptIntFindSmallDivisor().

◆ SymCryptFdefIntFromDivisor()

PSYMCRYPT_INT SYMCRYPT_CALL SymCryptFdefIntFromDivisor ( _In_ PSYMCRYPT_DIVISOR pdSrc )

Definition at line 915 of file fdef_int.c.

{
    return &pdSrc->Int;
}

Referenced by SymCryptFdefIntFromModulus(), and SymCryptIntFromDivisor().

◆ SymCryptFdefIntFromModulus()

PSYMCRYPT_INT SYMCRYPT_CALL SymCryptFdefIntFromModulus ( _In_ PSYMCRYPT_MODULUS pmSrc )

Definition at line 282 of file fdef_mod.c.

{
 
    return SymCryptFdefIntFromDivisor( &pmSrc->Divisor );
}

Referenced by SymCryptIntFromModulus().

◆ SymCryptFdefIntGetBit()

UINT32 SYMCRYPT_CALL SymCryptFdefIntGetBit	(	_In_ PCSYMCRYPT_INT	piSrc,
		UINT32	iBit
	)

Definition at line 580 of file fdef_int.c.

{
    SYMCRYPT_ASSERT( iBit < piSrc->nDigits * SYMCRYPT_FDEF_DIGIT_BITS );
 
    return (((SYMCRYPT_FDEF_INT_PUINT32( piSrc)[iBit / 32]) >> (iBit % 32)) & 1);
}

Referenced by SymCryptIntGetBit().

◆ SymCryptFdefIntGetBits()

UINT32 SYMCRYPT_CALL SymCryptFdefIntGetBits	(	_In_ PCSYMCRYPT_INT	piSrc,
		UINT32	iBit,
		UINT32	nBits
	)

Definition at line 591 of file fdef_int.c.

{
    UINT32 mainMask = 0;
    UINT32 result = 0;
 
    SYMCRYPT_ASSERT( (nBits > 0) &&
                     (nBits < 33) &&
                     (iBit < piSrc->nDigits * SYMCRYPT_FDEF_DIGIT_BITS) &&
                     (iBit + nBits <= piSrc->nDigits * SYMCRYPT_FDEF_DIGIT_BITS) );
 
    mainMask = (UINT32)(-1) >> (32-nBits);
 
    // Get the lower word first (it exists since iBit is smaller than the max bit)
    result = SYMCRYPT_FDEF_INT_PUINT32(piSrc)[iBit/32];
 
    // Shift to the right accordingly
    result >>= (iBit%32);
 
    // Get the upper word (if we need it)
    // Note: the iBit and nBits values are public
    if ((iBit%32!=0) && ( iBit/32 + 1 < piSrc->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32 ))
    {
        result |= ( SYMCRYPT_FDEF_INT_PUINT32(piSrc)[iBit/32+1] << (32 - iBit%32) );
    }
 
    // Mask out the top bits
    result &= mainMask;
 
    return result;
}

Referenced by SymCryptIntGetBits().

◆ SymCryptFdefIntGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefIntGetValue	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_writes_bytes_(cbDst) PBYTE	pbDst,
		SIZE_T	cbDst,
		SYMCRYPT_NUMBER_FORMAT	format
	)

Definition at line 695 of file fdef_general.c.

{
    SYMCRYPT_ERROR scError;
 
    SYMCRYPT_CHECK_MAGIC( piSrc );
 
    scError = SymCryptFdefRawGetValue( &SYMCRYPT_FDEF_INT_PUINT32( piSrc )[0], piSrc->nDigits, pbDst, cbDst, format );
 
    return scError;
}

Referenced by SymCryptIntGetValue().

◆ SymCryptFdefIntGetValueLsbits32()

UINT32 SYMCRYPT_CALL SymCryptFdefIntGetValueLsbits32 ( _In_ PCSYMCRYPT_INT piSrc )

Definition at line 713 of file fdef_general.c.

{
    // nDigits cannot be zero, so we don't have to test
    return SYMCRYPT_FDEF_INT_PUINT32( piSrc )[0];
}

Referenced by SymCryptIntGetValueLsbits32().

◆ SymCryptFdefIntGetValueLsbits64()

UINT64 SYMCRYPT_CALL SymCryptFdefIntGetValueLsbits64 ( _In_ PCSYMCRYPT_INT piSrc )

Definition at line 721 of file fdef_general.c.

{
    // nDigits cannot be zero, so we don't have to test
    PCUINT32 p = SYMCRYPT_FDEF_INT_PUINT32( piSrc );
    return ((UINT64)(p[1]) << 32) | p[0];
}

Referenced by SymCryptIntGetValueLsbits64().

◆ SymCryptFdefIntIsEqual()

UINT32 SYMCRYPT_CALL SymCryptFdefIntIsEqual	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2
	)

Definition at line 758 of file fdef_general.c.

{
    UINT32 d;
    UINT32  n1 = SYMCRYPT_OBJ_NUINT32( piSrc1 );
    UINT32  n2 = SYMCRYPT_OBJ_NUINT32( piSrc2 );
    UINT32  i;
    UINT32  n;
    PCUINT32 pSrc1 = SYMCRYPT_FDEF_INT_PUINT32( piSrc1 );
    PCUINT32 pSrc2 = SYMCRYPT_FDEF_INT_PUINT32( piSrc2 );
 
    n = SYMCRYPT_MIN( n1, n2 );
    d = 0;
    for( i=0; i < n ; i++ )
    {
        d |= pSrc1[i] ^ pSrc2[i];
    }
 
    // i == n1 or i == n2, so at most one of the 2 loops below is ever run
 
    while( i < n1 )
    {
        d |= pSrc1[i];
        i++;
    }
 
    while( i < n2 )
    {
        d |= pSrc2[i];
        i++;
    }
 
    return SYMCRYPT_MASK32_ZERO( d );
}

Referenced by SymCryptIntIsEqual().

◆ SymCryptFdefIntIsEqualUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefIntIsEqualUint32	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ UINT32	u32Src2
	)

Definition at line 749 of file fdef_general.c.

{
    return SymCryptFdefRawIsEqualUint32( &SYMCRYPT_FDEF_INT_PUINT32( piSrc1 )[0], piSrc1->nDigits, u32Src2 );
}

Referenced by SymCryptIntIsEqualUint32().

◆ SymCryptFdefIntIsLessThan()

UINT32 SYMCRYPT_CALL SymCryptFdefIntIsLessThan	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2
	)

Definition at line 368 of file fdef_int.c.

{
    UINT32  nD1 = piSrc1->nDigits;
    UINT32  nD2 = piSrc2->nDigits;
 
    UINT32 res;
 
    if( nD1 == nD2 )
    {
        res = SymCryptFdefRawIsLessThan( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), nD1 );
    } else if( nD1 < nD2 ) {
        res =  SymCryptFdefRawIsLessThan( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), nD1 );
        res |= ~SymCryptFdefRawIsZero( &SYMCRYPT_FDEF_INT_PUINT32( piSrc2 )[ nD1 * SYMCRYPT_FDEF_DIGIT_NUINT32 ], nD2 - nD1 );
    } else {
        res =  SymCryptFdefRawIsLessThan( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), nD2 );
        res &= SymCryptFdefRawIsZero( &SYMCRYPT_FDEF_INT_PUINT32( piSrc1 )[ nD2 * SYMCRYPT_FDEF_DIGIT_NUINT32 ], nD1 - nD2 );
    }
 
    return res;
}

Referenced by SymCryptIntIsLessThan().

◆ SymCryptFdefIntMaskedCopy()

VOID SymCryptFdefIntMaskedCopy	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Inout_ PSYMCRYPT_INT	piDst,
		UINT32	mask
	)

Definition at line 280 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( piSrc );
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
 
    SymCryptFdefMaskedCopy( (PBYTE) SYMCRYPT_FDEF_INT_PUINT32( piSrc ), (PBYTE) SYMCRYPT_FDEF_INT_PUINT32( piDst ), piSrc->nDigits, mask );
}

Referenced by SymCryptIntMaskedCopy().

◆ SymCryptFdefIntModPow2()

VOID SYMCRYPT_CALL SymCryptFdefIntModPow2	(	_In_ PCSYMCRYPT_INT	piSrc,
		SIZE_T	exp,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 539 of file fdef_int.c.

{
    SIZE_T  expWords = exp / 32;        // index of word with the partial mask
    SIZE_T  expBits  = exp % 32;        // # bits to leave in that word
 
    UINT32  nWords = piDst->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
 
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
 
    if( piSrc != piDst )
    {
        memcpy( SYMCRYPT_FDEF_INT_PUINT32( piDst ), SYMCRYPT_FDEF_INT_PUINT32( piSrc ), nWords * sizeof( UINT32 ) );
    }
 
    if( expWords >= nWords )
    {
        // exp is so large that Dst = Src is sufficient.
        goto cleanup;
    }
 
    for( SIZE_T i=expWords + 1; i < nWords; i++ )
    {
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[i] = 0;
    }
 
    if( expBits != 0 )
    {
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[expWords] &= ((UINT32) -1) >> (32 - expBits );
    } else {
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[expWords] = 0;
    }
 
cleanup:
    ;
}

Referenced by SymCryptIntModPow2().

◆ SymCryptFdefIntMulMixedSize()

VOID SYMCRYPT_CALL SymCryptFdefIntMulMixedSize	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2,
		_Out_ PSYMCRYPT_INT	piDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 889 of file fdef_int.c.

{
    UINT32      nS1 = piSrc1->nDigits;
    UINT32      nS2 = piSrc2->nDigits;
    UINT32      nD  = piDst ->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_FDEF_SCRATCH_BYTES_FOR_INT_MUL( piDst->nDigits ) );
 
    SYMCRYPT_ASSERT( nS1 + nS2 <= nD );
 
    SymCryptFdefRawMul( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), nS1, SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), nS2, SYMCRYPT_FDEF_INT_PUINT32( piDst ) );
 
    if( nS1 + nS2 < nD )
    {
        SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piDst )[(nS1 + nS2) * SYMCRYPT_FDEF_DIGIT_NUINT32], (nD - (nS1 + nS2)) * SYMCRYPT_FDEF_DIGIT_SIZE );
    }
}

Referenced by SymCryptFdefIntMulSameSize(), and SymCryptIntMulMixedSize().

◆ SymCryptFdefIntMulPow2()

VOID SYMCRYPT_CALL SymCryptFdefIntMulPow2	(	_In_ PCSYMCRYPT_INT	piSrc,
		SIZE_T	Exp,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 407 of file fdef_int.c.

{
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
 
    SIZE_T  shiftWords = Exp / (8 * sizeof( UINT32 ) );
    SIZE_T  shiftBits  = Exp % (8 * sizeof( UINT32 ) );
 
    UINT32  nWords = piDst->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
 
    if( shiftWords >= nWords )
    {
        SymCryptWipe( SYMCRYPT_FDEF_INT_PUINT32( piDst ), nWords * sizeof( UINT32 ) );
        goto cleanup;
    }
 
    SIZE_T i = nWords;
    while( i > shiftWords )
    {
        i--;
        UINT64 t = (UINT64)SYMCRYPT_FDEF_INT_PUINT32( piSrc )[i - shiftWords] << 32;
        if( i > shiftWords )
        {
            t |= SYMCRYPT_FDEF_INT_PUINT32( piSrc )[i - shiftWords - 1];
        }
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[i] = (UINT32)(t >> (32 - shiftBits));
    }
 
    while( i > 0 )
    {
        i--;
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[i] = 0;
    }
 
cleanup:
    ;
}

Referenced by SymCryptIntMulPow2().

◆ SymCryptFdefIntMulSameSize()

VOID SYMCRYPT_CALL SymCryptFdefIntMulSameSize	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2,
		_Out_ PSYMCRYPT_INT	piDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 704 of file fdef_int.c.

{
    SymCryptFdefIntMulMixedSize( piSrc1, piSrc2, piDst, pbScratch, cbScratch );
}

Referenced by SymCryptIntMulSameSize().

◆ SymCryptFdefIntMulUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefIntMulUint32	(	_In_ PCSYMCRYPT_INT	piSrc1,
		UINT32	Src2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 681 of file fdef_int.c.

{
    UINT32  nWords = piDst->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
 
    SYMCRYPT_ASSERT( piSrc1->nDigits == piDst->nDigits );
 
    UINT64 c = 0;
    for( UINT32 i=0; i<nWords; i++ )
    {
        c += SYMCRYPT_MUL32x32TO64( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 )[i], Src2 );
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[i] = (UINT32) c;
        c >>= 32;
    }
 
    return (UINT32) c;
}

Referenced by SymCryptIntMulUint32().

◆ SymCryptFdefIntNeg()

VOID SYMCRYPT_CALL SymCryptFdefIntNeg	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 394 of file fdef_int.c.

{
    UINT32 nDigits = piDst->nDigits;
    SYMCRYPT_ASSERT( piSrc->nDigits == nDigits );
 
    SymCryptFdefRawNeg( SYMCRYPT_FDEF_INT_PUINT32( piSrc ), 0, SYMCRYPT_FDEF_INT_PUINT32( piDst ), nDigits );
}

Referenced by SymCryptIntNeg().

◆ SymCryptFdefIntSetBits()

VOID SYMCRYPT_CALL SymCryptFdefIntSetBits	(	_In_ PSYMCRYPT_INT	piDst,
		UINT32	value,
		UINT32	iBit,
		UINT32	nBits
	)

Definition at line 627 of file fdef_int.c.

{
    UINT32 mainMask = 0;
 
    UINT32 alignedVal = 0;
    UINT32 alignedMask = 0;
 
    SYMCRYPT_ASSERT( (nBits > 0) &&
                     (nBits < 33) &&
                     (iBit < piDst->nDigits * SYMCRYPT_FDEF_DIGIT_BITS) &&
                     (iBit + nBits <= piDst->nDigits * SYMCRYPT_FDEF_DIGIT_BITS) );
 
    // Zero out the not needed bits of the value
    mainMask = (UINT32)(-1) >> (32-nBits);
    value &= mainMask;
 
    //
    // Lower word
    //
 
    // Create the needed mask
    alignedMask = mainMask << (iBit%32);
 
    // Align the value
    alignedVal = value << (iBit%32);
 
    // Set the lower word first (it exists since iBit is smaller than the max bit)
    SYMCRYPT_FDEF_INT_PUINT32(piDst)[iBit/32] = (SYMCRYPT_FDEF_INT_PUINT32(piDst)[iBit/32] & ~alignedMask) | alignedVal;
 
    //
    // Upper word
    //
 
    if ((iBit%32!=0) && ( iBit/32 + 1 < piDst->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32 ))
    {
        // Create the needed mask
        alignedMask = mainMask >> (32 - iBit%32);
 
        // Align the value
        alignedVal = value >> (32 - iBit%32);
 
        // Set the upper word
        SYMCRYPT_FDEF_INT_PUINT32(piDst)[iBit/32 + 1] = (SYMCRYPT_FDEF_INT_PUINT32(piDst)[iBit/32 + 1] & ~alignedMask) | alignedVal;
    }
 
}

Referenced by SymCryptIntSetBits().

◆ SymCryptFdefIntSetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefIntSetValue	(	_In_reads_bytes_(cbSrc) PCBYTE	pbSrc,
		SIZE_T	cbSrc,
		SYMCRYPT_NUMBER_FORMAT	format,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 601 of file fdef_general.c.

{
    SYMCRYPT_ERROR scError;
 
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    scError = SymCryptFdefRawSetValue( pbSrc, cbSrc, format, SYMCRYPT_FDEF_INT_PUINT32( piDst ), piDst->nDigits );
 
    return scError;
}

Referenced by SymCryptIntSetValue().

◆ SymCryptFdefIntSetValueUint32()

VOID SYMCRYPT_CALL SymCryptFdefIntSetValueUint32	(	UINT32	u32Src,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 497 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    SymCryptWipe( SYMCRYPT_FDEF_INT_PUINT32( piDst ), SYMCRYPT_OBJ_NBYTES( piDst ) );
    SYMCRYPT_FDEF_INT_PUINT32( piDst )[0] = u32Src;
}

Referenced by SymCryptIntSetValueUint32().

◆ SymCryptFdefIntSetValueUint64()

VOID SYMCRYPT_CALL SymCryptFdefIntSetValueUint64	(	UINT64	u64Src,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 511 of file fdef_general.c.

{
    SYMCRYPT_CHECK_MAGIC( piDst );
 
    SymCryptWipe( SYMCRYPT_FDEF_INT_PUINT32( piDst ), SYMCRYPT_OBJ_NBYTES( piDst ) );
    SYMCRYPT_FDEF_INT_PUINT32( piDst )[0] = (UINT32) u64Src;
    SYMCRYPT_FDEF_INT_PUINT32( piDst )[1] = (UINT32)(u64Src >> 32);
}

Referenced by SymCryptIntSetValueUint64().

◆ SymCryptFdefIntShr1()

VOID SYMCRYPT_CALL SymCryptFdefIntShr1	(	UINT32	highestBit,
		_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 511 of file fdef_int.c.

{
    UINT32  nWords = piDst->nDigits * SYMCRYPT_FDEF_DIGIT_NNATIVE_UINT;
 
    SYMCRYPT_ASSERT( piSrc->nDigits == piDst->nDigits );
    SYMCRYPT_ASSERT( highestBit < 2 );
 
    SIZE_T i = 0;
    NATIVE_UINT lowWord = SYMCRYPT_FDEF_INT_PNATIVE_UINT(piSrc)[0];
    NATIVE_UINT highWord = 0;
    while( i+1 < nWords )
    {
        highWord = SYMCRYPT_FDEF_INT_PNATIVE_UINT(piSrc)[i+1];
 
        SYMCRYPT_FDEF_INT_PNATIVE_UINT(piDst)[i] = (lowWord >> 1) | (highWord << (NATIVE_BITS - 1));
 
        lowWord = highWord;
        i++;
    }
 
    SYMCRYPT_FDEF_INT_PNATIVE_UINT(piDst)[i] = (lowWord >> 1) | ((NATIVE_UINT)highestBit) << (NATIVE_BITS - 1);
}

Referenced by SymCryptIntShr1().

◆ SymCryptFdefIntSquare()

VOID SYMCRYPT_CALL SymCryptFdefIntSquare	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_INT	piDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 716 of file fdef_int.c.

{
    UINT32      nS = piSrc->nDigits;
    UINT32      nD = piDst->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_FDEF_SCRATCH_BYTES_FOR_INT_MUL( piDst->nDigits ) );
 
    SYMCRYPT_ASSERT( 2*nS <= nD );
 
    SymCryptFdefRawSquare( SYMCRYPT_FDEF_INT_PUINT32( piSrc ), nS, SYMCRYPT_FDEF_INT_PUINT32( piDst ) );
 
    if( 2*nS < nD )
    {
        SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piDst )[2 * nS * SYMCRYPT_FDEF_DIGIT_NUINT32], (nD - 2*nS) * SYMCRYPT_FDEF_DIGIT_SIZE );
    }
}

Referenced by SymCryptIntSquare().

◆ SymCryptFdefIntSubMixedSize()

UINT32 SYMCRYPT_CALL SymCryptFdefIntSubMixedSize	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 260 of file fdef_int.c.

{
    UINT32      nS1 = piSrc1->nDigits;
    UINT32      nS2 = piSrc2->nDigits;
    UINT32      nD  = piDst->nDigits;
    UINT32      c;
    UINT32      n;
 
    SYMCRYPT_ASSERT( nD >= nS1 && nD >= nS2 );
 
    if( nS1 < nS2 )
    {
        c = SymCryptFdefRawSub( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), SYMCRYPT_FDEF_INT_PUINT32( piDst ), nS1 );
        c = SymCryptFdefRawNeg( &SYMCRYPT_FDEF_INT_PUINT32( piSrc2 )[nS1 * SYMCRYPT_FDEF_DIGIT_NUINT32], c, &SYMCRYPT_FDEF_INT_PUINT32( piDst )[nS1 * SYMCRYPT_FDEF_DIGIT_NUINT32], nS2 - nS1 );
        n = nS2 * SYMCRYPT_FDEF_DIGIT_NUINT32;
    } else {
        // nS2 < nS1
        c = SymCryptFdefRawSub( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), SYMCRYPT_FDEF_INT_PUINT32( piDst ), nS2 );
        c = SymCryptFdefRawSubUint32( &SYMCRYPT_FDEF_INT_PUINT32( piSrc1 )[nS2 * SYMCRYPT_FDEF_DIGIT_NUINT32], c, &SYMCRYPT_FDEF_INT_PUINT32( piDst )[nS2 * SYMCRYPT_FDEF_DIGIT_NUINT32], nS1 - nS2 );
        n = nS1 * SYMCRYPT_FDEF_DIGIT_NUINT32;
    }
 
    //
    // Set the rest of the result to 0s or 1s
    //
    while( n < nD * SYMCRYPT_FDEF_DIGIT_NUINT32 )
    {
        SYMCRYPT_FDEF_INT_PUINT32( piDst )[n++] = 0 - c;
    }
 
    return c;
}

Referenced by SymCryptIntSubMixedSize().

◆ SymCryptFdefIntSubSameSize()

UINT32 SYMCRYPT_CALL SymCryptFdefIntSubSameSize	(	_In_ PCSYMCRYPT_INT	piSrc1,
		_In_ PCSYMCRYPT_INT	piSrc2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 248 of file fdef_int.c.

{
    SYMCRYPT_ASSERT( piSrc1->nDigits == piSrc2->nDigits && piSrc1->nDigits == piDst->nDigits );
 
    return SymCryptFdefRawSub( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), SYMCRYPT_FDEF_INT_PUINT32( piSrc2 ), SYMCRYPT_FDEF_INT_PUINT32( piDst ), piDst->nDigits );
}

Referenced by SymCryptIntSubSameSize().

◆ SymCryptFdefIntSubUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefIntSubUint32	(	_In_ PCSYMCRYPT_INT	piSrc1,
		UINT32	u32Src2,
		_Out_ PSYMCRYPT_INT	piDst
	)

Definition at line 236 of file fdef_int.c.

{
    SYMCRYPT_ASSERT( piSrc1->nDigits == piDst->nDigits );
 
    return SymCryptFdefRawSubUint32( SYMCRYPT_FDEF_INT_PUINT32( piSrc1 ), u32Src2, SYMCRYPT_FDEF_INT_PUINT32( piDst ), piDst->nDigits );
}

Referenced by SymCryptIntSubUint32().

◆ SymCryptFdefIntToDivisor()

VOID SYMCRYPT_CALL SymCryptFdefIntToDivisor	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_DIVISOR	pdDst,
		UINT32	totalOperations,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 922 of file fdef_int.c.

{
    UINT32      W;
    UINT32      nBits;
    UINT32      nWords;
    UINT32      bitToTest;
    UINT64      P;
 
    UNREFERENCED_PARAMETER( totalOperations );
    UNREFERENCED_PARAMETER( flags );
 
    SYMCRYPT_CHECK_MAGIC( piSrc );
    SYMCRYPT_CHECK_MAGIC( pdDst );
 
    SYMCRYPT_ASSERT( piSrc->nDigits == pdDst->nDigits );
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_FDEF_SCRATCH_BYTES_FOR_INT_TO_DIVISOR( piSrc->nDigits ) );
 
    //
    // Copy the Int.
    //
    SymCryptFdefIntCopy( piSrc, &pdDst->Int );
 
    //
    // For an N-bit divisor M, and D-bit divisor digit size,
    // the value W is defined as
    //     floor( (2^{N+D} - 1) / M } - 2^D
    // which is the largest W such that (W * M + 2^D * M )< 2^{N+D}
    // To compute W we use a binary search.
    // This can be optimized, but this is the simplest side-channel safe solution.
    // We can compute the upper bits of W * M + 2^D * M in a simple loop.
    //
    // For now we only compute a 32-bit W for a 32-bit digit divisor size.
    //
 
    nBits = SymCryptIntBitsizeOfValue( &pdDst->Int );
 
    SYMCRYPT_ASSERT( nBits != 0 );
    if( nBits == 0 )
    {
        // Can't create a divisor from a Int whose value is 0
 
        // We really should not have any callers which get here (it is a requirement that Src != 0)
        // We assert in CHKed builds
        // In release set the divisor to 1 instead
        SymCryptIntSetValueUint32( 1, &pdDst->Int );
    }
 
    pdDst->nBits = nBits;
 
    nWords = (nBits + 31)/32;
    bitToTest = (UINT32)1 << 31;
    W = 0;
    while( bitToTest > 0 )
    {
        W |= bitToTest;
        // Do the multiplication
        P = 0;
        for( UINT32 i=0; i<nWords; i++ )
        {
            // Invariant:
            // P <= 2^{2D} - 2 which ensures the mul-add doesn't generate an overflow
            // P  = floor( (W + 2^32)*M[0..i-1] / 2^{32*i} )
            P += SYMCRYPT_MUL32x32TO64( W, SYMCRYPT_FDEF_INT_PUINT32( &pdDst->Int )[i] );
            P >>= 32;
            P += SYMCRYPT_FDEF_INT_PUINT32( &pdDst->Int )[i];
        }
        // We are interested in bit N+D, and P[0] is bit nWords*D, this shift brings the relevant bit to position 0
        P >>= ((nBits+31) % 32) + 1;
        // If the bit is 1, W*M is too large and we reset the corresponding bit in W.
        W ^= bitToTest & (0 - ((UINT32)P & 1));
        bitToTest >>= 1;
    }
    pdDst->td.fdef.W = W;
 
    SYMCRYPT_SET_MAGIC( pdDst );
}

Referenced by SymCryptIntToDivisor().

◆ SymCryptFdefIntToModElement()

VOID SYMCRYPT_CALL SymCryptFdefIntToModElement	(	_In_ PCSYMCRYPT_INT	piSrc,
		_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 407 of file fdef_mod.c.

{
    SymCryptFdefRawDivMod(
        SYMCRYPT_FDEF_INT_PUINT32( piSrc ),
        piSrc->nDigits,
        &pmMod->Divisor,
        NULL,                   // throw away the quotient
        &peDst->d.uint32[0],
        pbScratch,
        cbScratch );
 
    SYMCRYPT_MOD_CALL( pmMod ) modSetPost( pmMod, peDst, pbScratch, cbScratch );
}

Referenced by SymCryptIntToModElement().

◆ SymCryptFdefIntToModulus()

VOID SYMCRYPT_CALL SymCryptFdefIntToModulus	(	_In_ PCSYMCRYPT_INT	piSrc,
		_Out_ PSYMCRYPT_MODULUS	pmDst,
		UINT32	averageOperations,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 385 of file fdef_mod.c.

{
    pmDst->flags = flags;
    SymCryptIntToDivisor( piSrc, &pmDst->Divisor, averageOperations, flags & SYMCRYPT_FLAG_DATA_PUBLIC, pbScratch, cbScratch );
 
    pmDst->type = SymCryptFdefDecideModulusType( piSrc, pmDst->nDigits, averageOperations, flags );
 
    // Set inv64 - note the value is only valid if the modulus is odd, but the computation
    // is constant time regardless of the parity, so we can safely compute it in all cases
    pmDst->inv64 = 0 - SymCryptInverseMod2e64( SymCryptIntGetValueLsbits64(piSrc) );
 
    SYMCRYPT_MOD_CALL( pmDst ) modulusInit( pmDst, pbScratch, cbScratch );
}

Referenced by SymCryptIntToModulus().

◆ SymCryptFdefMaskedCopy()

VOID SYMCRYPT_CALL SymCryptFdefMaskedCopy	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCBYTE	pbSrc,
		_Inout_updates_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE	pbDst,
		UINT32	nDigits,
		UINT32	mask
	)

Definition at line 74 of file fdef_general.c.

{
#if SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_ARM
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbSrc );
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbDst );
    SymCryptFdefMaskedCopyAsm( pbSrc, pbDst, nDigits, mask );
#else
    SymCryptFdefMaskedCopyC( pbSrc, pbDst, nDigits, mask );
#endif
}

Referenced by SymCryptEcpointMaskedCopy(), SymCryptFdefIntConditionalCopy(), SymCryptFdefIntMaskedCopy(), SymCryptFdefModAddGeneric(), SymCryptFdefModElementMaskedCopy(), SymCryptFdefModSubGeneric(), and SymCryptFdefMontgomeryReduceC().

◆ SymCryptFdefMaskedCopyAsm()

VOID SYMCRYPT_CALL SymCryptFdefMaskedCopyAsm	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCBYTE	pbSrc,
		_Inout_updates_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PBYTE	pbDst,
		UINT32	nDigits,
		UINT32	mask
	)

Referenced by SymCryptFdefMaskedCopy().

◆ SymCryptFdefModAdd256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModAdd256Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

◆ SymCryptFdefModAdd384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModAdd384Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

◆ SymCryptFdefModAddGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModAddGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 548 of file fdef_mod.c.

{
    UINT32 c;
    UINT32 d;
    UINT32 nDigits = pmMod->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
    SYMCRYPT_ASSERT( cbScratch >= nDigits*SYMCRYPT_FDEF_DIGIT_SIZE );
 
    //
    // Doing add/cmp/sub might be faster or not.
    // Masked add is hard because the mask operations destroy the carry flag.
    //
 
    // dcl - cleanup?
 
//    c = SymCryptFdefRawAdd( &pSrc1->uint32[0], &pSrc2->uint32[0], &pDst->uint32[0], nDigits);
//    d = SymCryptFdefRawSub( &pDst->uint32[0], &pMod->Divisor.Int.uint32[0], &pDst->uint32[0], nDigits );
//    e = SymCryptFdefRawMaskedAdd( &pDst->uint32[0], &pMod->Divisor.Int.uint32[0], 0 - (c^d), nDigits );
 
    c = SymCryptFdefRawAdd( &peSrc1->d.uint32[0], &peSrc2->d.uint32[0], &peDst->d.uint32[0], nDigits );
    d = SymCryptFdefRawSub( &peDst->d.uint32[0], SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int ), (PUINT32) pbScratch, nDigits );
    SymCryptFdefMaskedCopy( pbScratch, (PBYTE) &peDst->d.uint32[0], nDigits, (c^d) - 1 );
 
    // We can't have a carry in the first addition, and no carry in the subtraction.
    SYMCRYPT_ASSERT( !( c == 1 && d == 0 ) );
}

◆ SymCryptFdefModAddMulx256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModAddMulx256Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

◆ SymCryptFdefModAddMulx384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModAddMulx384Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

◆ SymCryptFdefModDivPow2()

VOID SYMCRYPT_CALL SymCryptFdefModDivPow2	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		UINT32	exp,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 872 of file fdef_mod.c.

{
    UINT32 shiftAmount;
 
    UNREFERENCED_PARAMETER(pbScratch);
    UNREFERENCED_PARAMETER(cbScratch);
 
    // mod must be odd
    SYMCRYPT_ASSERT( (SYMCRYPT_FDEF_INT_PUINT32(&pmMod->Divisor.Int)[0] & 1) != 0 );
 
    if( exp == 0 )
    {
        // If exp is 0 we just need to copy peSrc to peDst
        SymCryptFdefModElementCopy( pmMod, peSrc, peDst );
        return;
    }
 
    do
    {
        shiftAmount = SYMCRYPT_MIN(NATIVE_BITS, exp);
        SymCryptFdefModDivSmallPow2( pmMod, peSrc, shiftAmount, peDst );
        exp -= shiftAmount;
 
        // First iteration reads from peSrc and writes to peDst
        // subsequent iterations must read from and write to peDst
        peSrc = peDst;
    } while( exp > 0 );
}

Referenced by SymCryptModDivPow2().

◆ SymCryptFdefModDivSmallPow2()

VOID SYMCRYPT_CALL SymCryptFdefModDivSmallPow2	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_In_range_(1, NATIVE_BITS) UINT32	exp,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

Definition at line 844 of file fdef_mod.c.

{
 
#if SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_MULX ) )
    {
        SymCryptFdefModDivSmallPow2Mulx( pmMod, peSrc, exp, peDst );
    }
    else
    {
        // Currently SymCryptAsm does not support AMD64 functions with shl/shr/shrd
        // by a variable count, as this needs special handling of the rcx (cl) register
        // For now we just fallback to the generic implementation on machines without MULX
        SymCryptFdefModDivSmallPow2Generic( pmMod, peSrc, exp, peDst );
    }
#elif SYMCRYPT_CPU_ARM64
    SymCryptFdefModDivSmallPow2Asm( pmMod, peSrc, exp, peDst );
#else
    SymCryptFdefModDivSmallPow2Generic( pmMod, peSrc, exp, peDst );
#endif
}

Referenced by SymCryptFdefModDivPow2(), and SymCryptFdefModInvGeneric().

◆ SymCryptFdefModDivSmallPow2Asm()

VOID SYMCRYPT_CALL SymCryptFdefModDivSmallPow2Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_In_range_(1, NATIVE_BITS) UINT32	exp,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

Referenced by SymCryptFdefModDivSmallPow2().

◆ SymCryptFdefModDivSmallPow2Mulx()

VOID SYMCRYPT_CALL SymCryptFdefModDivSmallPow2Mulx	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_In_range_(1, NATIVE_BITS) UINT32	exp,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

Referenced by SymCryptFdefModDivSmallPow2().

◆ SymCryptFdefModElementAllocate()

PSYMCRYPT_MODELEMENT SYMCRYPT_CALL SymCryptFdefModElementAllocate ( _In_ PCSYMCRYPT_MODULUS pmMod )

Definition at line 157 of file fdef_mod.c.

{
    PVOID                   p;
    UINT32                  cb;
    PSYMCRYPT_MODELEMENT    res = NULL;
 
    //
    // The nDigits requirements are enforced by the modulus object. Thus
    // the result does not overflow and is upper bounded by 2^17.
    //
    cb = SymCryptFdefSizeofModElementFromModulus( pmMod );
 
    p = SymCryptCallbackAlloc( cb );
 
    if( p == NULL )
    {
        goto cleanup;
    }
 
    res = SymCryptFdefModElementCreate( p, cb, pmMod );
 
cleanup:
    return res;
}

Referenced by SymCryptModElementAllocate().

◆ SymCryptFdefModElementConditionalSwap()

VOID SymCryptFdefModElementConditionalSwap	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PSYMCRYPT_MODELEMENT	peData1,
		_Inout_ PSYMCRYPT_MODELEMENT	peData2,
		_In_ UINT32	cond
	)

Definition at line 271 of file fdef_mod.c.

{
    SymCryptFdefConditionalSwap( (PBYTE) &peData1->d.uint32[0], (PBYTE) &peData2->d.uint32[0], pmMod->nDigits, cond );
}

Referenced by SymCryptModElementConditionalSwap().

◆ SymCryptFdefModElementCopy()

VOID SymCryptFdefModElementCopy	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

Definition at line 241 of file fdef_mod.c.

{
    if( peSrc != peDst )
    {
        memcpy( peDst, peSrc, pmMod->cbModElement );
    }
}

Referenced by SymCryptFdefModDivPow2(), and SymCryptModElementCopy().

◆ SymCryptFdefModElementCreate()

PSYMCRYPT_MODELEMENT SYMCRYPT_CALL SymCryptFdefModElementCreate	(	_Out_writes_bytes_(cbBuffer) PBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		PCSYMCRYPT_MODULUS	pmMod
	)

Definition at line 202 of file fdef_mod.c.

{
    PSYMCRYPT_MODELEMENT pDst = (PSYMCRYPT_MODELEMENT) pbBuffer;
 
    UNREFERENCED_PARAMETER( pmMod );
    UNREFERENCED_PARAMETER( cbBuffer );
 
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
    SYMCRYPT_ASSERT( cbBuffer >= SymCryptFdefSizeofModElementFromModulus( pmMod ) );
    SYMCRYPT_ASSERT( cbBuffer >= pmMod->nDigits*SYMCRYPT_FDEF_DIGIT_SIZE );
 
    //
    // We have various optimizations where we use only part of the last digit
    // Simple and fast solution: always wipe the last digit
    //
#if (SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_ARM64)
    UINT32 nDigits = pmMod->nDigits;
 
    SymCryptWipeKnownSize( pbBuffer + (nDigits-1) * SYMCRYPT_FDEF_DIGIT_SIZE, SYMCRYPT_FDEF_DIGIT_SIZE );
#endif
 
    // There is nothing to initialize...
 
    return pDst;
}

Referenced by SymCryptFdefModElementAllocate(), and SymCryptModElementCreate().

◆ SymCryptFdefModElementFree()

VOID SYMCRYPT_CALL SymCryptFdefModElementFree	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peObj
	)

Definition at line 184 of file fdef_mod.c.

{
    SymCryptFdefModElementWipe( pmMod, peObj );
    SymCryptCallbackFree( peObj );
}

Referenced by SymCryptModElementFree().

◆ SymCryptFdefModElementGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefModElementGetValue	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_Out_writes_bytes_(cbDst) PBYTE	pbDst,
		SIZE_T	cbDst,
		SYMCRYPT_NUMBER_FORMAT	format,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 484 of file fdef_mod.c.

{
    SYMCRYPT_ERROR scError;
    PCUINT32 pUint32;
    UINT32  nDigits = pmMod->nDigits;
 
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    SYMCRYPT_ASSERT( cbDst <= nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    pUint32 = SYMCRYPT_MOD_CALL( pmMod ) modPreGet( pmMod, peSrc, pbScratch, cbScratch );
 
    scError = SymCryptFdefRawGetValue( pUint32, nDigits, pbDst, cbDst, format );
 
    return scError;
}

Referenced by SymCryptModElementGetValue().

◆ SymCryptFdefModElementIsEqual()

UINT32 SYMCRYPT_CALL SymCryptFdefModElementIsEqual	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2
	)

Definition at line 511 of file fdef_mod.c.

{
    UINT32 d;
    UINT32 i;
 
    d = 0;
    for( i=0; i < pmMod->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32 ; i++ )
    {
        d |= peSrc1->d.uint32[i] ^ peSrc2->d.uint32[i];
    }
 
    return SYMCRYPT_MASK32_ZERO( d );
}

Referenced by SymCryptModElementIsEqual().

◆ SymCryptFdefModElementIsZero()

UINT32 SYMCRYPT_CALL SymCryptFdefModElementIsZero	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc
	)

Definition at line 530 of file fdef_mod.c.

{
    UINT32 d;
    UINT32 i;
 
    d = 0;
    for( i=0; i < pmMod->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32 ; i++ )
    {
        d |= peSrc->d.uint32[i];        // Check that all bits are zero
    }
 
    return SYMCRYPT_MASK32_ZERO( d );
}

Referenced by SymCryptModElementIsZero().

◆ SymCryptFdefModElementMaskedCopy()

VOID SymCryptFdefModElementMaskedCopy	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		UINT32	mask
	)

Definition at line 253 of file fdef_mod.c.

{
    SymCryptFdefMaskedCopy( (PCBYTE) peSrc, (PBYTE) peDst, pmMod->nDigits, mask );
}

Referenced by SymCryptModElementMaskedCopy().

◆ SymCryptFdefModElementRetrieveHandle()

PSYMCRYPT_MODELEMENT SYMCRYPT_CALL SymCryptFdefModElementRetrieveHandle ( _In_ PBYTE pbBuffer )

◆ SymCryptFdefModElementSetValueGeneric()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefModElementSetValueGeneric	(	_In_reads_bytes_(cbSrc) PCBYTE	pbSrc,
		SIZE_T	cbSrc,
		SYMCRYPT_NUMBER_FORMAT	format,
		_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 445 of file fdef_mod.c.

{
    SYMCRYPT_ERROR scError;
    UINT32  nDigits = pmMod->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    SYMCRYPT_ASSERT( cbSrc <= nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    scError = SymCryptFdefRawSetValue( pbSrc, cbSrc, format, &peDst->d.uint32[0], nDigits );
    if( scError != SYMCRYPT_NO_ERROR )
    {
        goto cleanup;
    }
 
    SymCryptFdefRawDivMod(
        &peDst->d.uint32[0],
        nDigits,
        &pmMod->Divisor,
        NULL,
        &peDst->d.uint32[0],
        pbScratch,
        cbScratch );
 
    scError = SYMCRYPT_NO_ERROR;
 
cleanup:
    return scError;
}

Referenced by SymCryptModElementSetValue().

◆ SymCryptFdefModElementSetValueNegUint32()

VOID SYMCRYPT_CALL SymCryptFdefModElementSetValueNegUint32	(	UINT32	value,
		_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 663 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    if( pmMod->Divisor.nBits <= 32 && value >= SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int )[0] )
    {
        // The value is >=  the modulus; this is not supported.
 
        // For now do a possibly non-sidechannel safe, but mathematically correct modulo operation
        value %= SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int )[0];
    }
 
    if( value == 0 )
    {
        SymCryptWipe( &peDst->d.uint32[0], nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
    } else {
        SymCryptFdefRawSubUint32( SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int ), value, &peDst->d.uint32[0], nDigits );
    }
 
    //
    // Possible future optimization: we can optimize the value==0 and value==1 cases on a per-type basis
    //
    SYMCRYPT_MOD_CALL( pmMod ) modSetPost( pmMod, peDst, pbScratch, cbScratch );
}

Referenced by SymCryptModElementSetValueNegUint32().

◆ SymCryptFdefModElementSetValueUint32Generic()

VOID SYMCRYPT_CALL SymCryptFdefModElementSetValueUint32Generic	(	UINT32	value,
		_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 637 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    if( pmMod->Divisor.nBits <= 32 && value >= SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int )[0] )
    {
        // The value is >=  the modulus; this is not supported
 
        // For now do a possibly non-sidechannel safe, but mathematically correct modulo operation
        value %= SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int )[0];
    }
 
    peDst->d.uint32[0] = value;
 
    SymCryptWipe( &peDst->d.uint32[1], nDigits * SYMCRYPT_FDEF_DIGIT_SIZE - sizeof( UINT32 ) );
}

Referenced by SymCryptFdefModInvGeneric(), and SymCryptModElementSetValueUint32().

◆ SymCryptFdefModElementToIntGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModElementToIntGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_reads_bytes_(pmMod->nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc,
		_Out_ PSYMCRYPT_INT	piDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 428 of file fdef_mod.c.

{
    memcpy( SYMCRYPT_FDEF_INT_PUINT32( piDst ), pSrc, pmMod->nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    SymCryptWipe( &SYMCRYPT_FDEF_INT_PUINT32( piDst )[pmMod->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32], (piDst->nDigits - pmMod->nDigits) * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pmMod->nDigits ) );
}

Referenced by SymCryptFdefModInvGeneric(), and SymCryptModElementToInt().

◆ SymCryptFdefModElementWipe()

VOID SYMCRYPT_CALL SymCryptFdefModElementWipe	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

Definition at line 233 of file fdef_mod.c.

{
    SymCryptWipe( peDst, pmMod->cbModElement );
}

Referenced by SymCryptFdefModElementFree(), and SymCryptModElementWipe().

◆ SymCryptFdefModInvGeneric()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefModInvGeneric	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 960 of file fdef_mod.c.

{
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
    UINT32 nDigits = pmMod->nDigits;
    UINT32 nBytes;
    UINT32 c;
    UINT32 leastSignificantUint32;
    UINT32 trailingZeros;
 
    //
    // This function is called on Montgomery moduli so we can't directly call specifically optimized modular operations from here.
    //
    // For now we use dispatch functions with pmMod to perform potentially optimized modular operations.
    // This approach makes sense when on average the cost of dispatch is less than the benefit using an optimized operation.
    // The alternative is to make specialized ModInv routines for different types of moduli, but we do not yet do this to
    // reduce code duplication / code size.
    //
 
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_MODINV( nDigits ) );
 
    if( (pmMod->flags & (SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME )) != (SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME ) )
    {
        // Inversion over non-public or non-prime moduli currently not supported.
        // Our blinding below only works for prime moduli.
        // As the modulus cannot be blinded, it requires a fully side-channel safe algorithm which is much more complicated and
        // slower.
        // When this is necessary, we will add a second ModInv implementation for those cases.
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    //
    // Algorithm:
    // R = random nonzero value mod Mod
    // X := Src * R (mod Mod)
    // A = X
    // B = Mod
    // Va = 1
    // Vb = 0
    // invariant: A = Va*X (mod Mod), B = Vb*X (mod Mod),
    //
    // if( A == 0 ): error
    //
    // verify (A | B) is odd
    // if B even: swap (A,B), swap( Va, Vb)
    //
    //  repeat:
    //      while( A even ):
    //          A /= 2; Va /= 2 (mod Mod)
    //      if( A == 1 ): break1
    //      (A, Va, B, Vb) = (B-A, Vb - Va, A, Va)
    //      if( A == 0 ): error (not co-prime)
 
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
 
    SYMCRYPT_ASSERT( cbScratch >= 4*nBytes );
    PSYMCRYPT_MODELEMENT peR = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
    PSYMCRYPT_MODELEMENT peX = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
    PSYMCRYPT_MODELEMENT peVa = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
    PSYMCRYPT_MODELEMENT peVb = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
    cbScratch -= 4*nBytes;
 
    PSYMCRYPT_MODELEMENT peVtmpPtr;
 
    nBytes = SymCryptSizeofIntFromDigits( nDigits );
    SYMCRYPT_ASSERT( cbScratch >= 3 * nBytes );
    PSYMCRYPT_INT piA = SymCryptIntCreate( pbScratch, nBytes, nDigits );
    pbScratch += nBytes;
    PSYMCRYPT_INT piB = SymCryptIntCreate( pbScratch, nBytes, nDigits );
    pbScratch += nBytes;
    PSYMCRYPT_INT piT = SymCryptIntCreate( pbScratch, nBytes, nDigits );
    pbScratch += nBytes;
    cbScratch -= 3*nBytes;
 
    PSYMCRYPT_INT piTmpPtr;
 
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    // If the data is not public, multiply by a random blinding factor; otherwise copy the value
    if( (flags & SYMCRYPT_FLAG_DATA_PUBLIC) == 0 )
    {
        SymCryptModSetRandom( pmMod, peR, SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE | SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE, pbScratch, cbScratch );   //R = random
        SymCryptModMul( pmMod, peR, peSrc, peX, pbScratch, cbScratch );     // X = R * Src
    } else
    {
        SymCryptModElementCopy( pmMod, peSrc, peX );
    }
 
    // Set up piA and piB
    SymCryptFdefModElementToIntGeneric( pmMod, &peX->d.uint32[0], piA, pbScratch, cbScratch );   // A = X
    SymCryptIntCopy( SymCryptIntFromModulus( (PSYMCRYPT_MODULUS) pmMod ), piB );          // B = Mod
 
    // Reject if A = 0, B = 0, or A and B both even
    if( SymCryptIntIsEqualUint32( piA, 0 ) |
        SymCryptIntIsEqualUint32( piB, 0 ) |
        (((SymCryptIntGetValueLsbits32( piA ) | SymCryptIntGetValueLsbits32( piB )) & 1) ^ 1) )
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    if( SymCryptIntIsEqualUint32( piB, 2 ) )
    {
        // Mod = 2 is a valid input. Luckily, modular inversion is easy.
        // The rest of the code assumes that Mod is odd. Other even values are not prime.
        SymCryptModElementCopy( pmMod, peSrc, peDst);
        goto cleanup;
    }
 
    SymCryptFdefModElementSetValueUint32Generic( 1, pmMod, peVa, pbScratch, cbScratch );               // Va = 1
    SymCryptFdefModElementSetValueUint32Generic( 0, pmMod, peVb, pbScratch, cbScratch );               // Vb = 0
 
    for(;;)
    {
        // invariant: A = Va*X (mod Mod), B = Vb*X (mod Mod), A != 0, B > 1.
        // Remove factors of 2 from A. This loop terminates because A != 0
        leastSignificantUint32 = SymCryptIntGetValueLsbits32(piA);
        while( (leastSignificantUint32 & 1) == 0 )
        {
            trailingZeros = SymCryptCountTrailingZeros32( leastSignificantUint32 );
            SymCryptIntDivPow2( piA, trailingZeros, piA );
            SymCryptFdefModDivSmallPow2( pmMod, peVa, trailingZeros, peVa );
            leastSignificantUint32 = SymCryptIntGetValueLsbits32(piA);
        }
 
        if( SymCryptIntIsEqualUint32( piA, 1 ) )
        {
            // A = 1 = Va * X (mod Mod), so Va is the inverse of X
            break;
        }
 
        c = SymCryptIntSubSameSize( piB, piA, piT );
 
        // If A != 1 and A=B, then A is the GCD of the original inputs, and there is no inverse
        if( SymCryptIntIsEqualUint32( piT, 0 ) )
        {
            scError = SYMCRYPT_INVALID_ARGUMENT;
            goto cleanup;
        }
 
        if( c == 0 )
        {
            // B > A, we set B to B-A and swap (B,A)
            // that way we continue our halving on B-A
 
            SymCryptIntCopy( piT, piB );
            SymCryptModSub( pmMod, peVb, peVa, peVb, pbScratch, cbScratch );
 
            piTmpPtr  = piB;  piB  = piA;  piA  = piTmpPtr;
            peVtmpPtr = peVb; peVb = peVa; peVa = peVtmpPtr;
        } else {
            // B < A, Set A to A-B and continue halving A
            SymCryptIntNeg( piT, piA );
            SymCryptModSub( pmMod, peVa, peVb, peVa, pbScratch, cbScratch );
        }
    }
 
    // 1 = A = Va * X (mod Mod), so Va is the inverse of X
    // Check computation that we can test in the debugger
    SymCryptModMul( pmMod, peVa, peX, peVb, pbScratch, cbScratch );
 
    // Actual answer
 
    // If the data is not public, multiply by the random blinding factor; otherwise copy the value
    if( (flags & SYMCRYPT_FLAG_DATA_PUBLIC) == 0 )
    {
        SymCryptModMul( pmMod, peVa, peR, peDst, pbScratch, cbScratch );
    } else
    {
        SymCryptModElementCopy( pmMod, peVa, peDst );
    }
 
cleanup:
    return scError;
}

Referenced by SymCryptFdefModInvMontgomery().

◆ SymCryptFdefModInvMontgomery()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefModInvMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1440 of file fdef_mod.c.

{
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
    UINT32 nDigits = pmMod->nDigits;
    UINT32 nBytes = nDigits * SYMCRYPT_FDEF_DIGIT_SIZE;
    PUINT32 pTmp = (PUINT32) pbScratch;
 
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pTmp );
 
    //
    // We have R*X; we first apply the montgomery reduction twice to get X/R, and then invert that
    // using the generic inversion to get R/X.
    //
    SYMCRYPT_ASSERT( cbScratch >= 2 * nBytes );
    memcpy( pTmp, &peSrc->d.uint32[0], nBytes );
 
    SymCryptWipe( (PBYTE)pTmp + nBytes, nBytes );
    SymCryptFdefMontgomeryReduce( pmMod, pTmp, pTmp );
 
    SymCryptWipe( (PBYTE)pTmp + nBytes, nBytes );
    SymCryptFdefMontgomeryReduce( pmMod, pTmp, &peDst->d.uint32[0] );
 
    scError = SymCryptFdefModInvGeneric( pmMod, peDst, peDst, flags, pbScratch, cbScratch );
 
    return scError;
}

◆ SymCryptFdefModInvMontgomery256()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefModInvMontgomery256	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModMulGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModMulGeneric	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 909 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
    PUINT32 pTmp = (PUINT32) pbScratch;
    UINT32  scratchOffset = 2 * nDigits * SYMCRYPT_FDEF_DIGIT_SIZE;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
    SYMCRYPT_ASSERT( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) >= scratchOffset + SYMCRYPT_FDEF_SCRATCH_BYTES_FOR_INT_DIVMOD( 2 * nDigits, nDigits ) );
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbScratch );
 
    // Tmp space is enough for the product plus the DivMod scratch
 
    SymCryptFdefRawMul( &peSrc1->d.uint32[0], nDigits, &peSrc2->d.uint32[0], nDigits, pTmp );
 
    SymCryptFdefRawDivMod( pTmp, 2*nDigits, &pmMod->Divisor, NULL, &peDst->d.uint32[0], pbScratch + scratchOffset, cbScratch - scratchOffset );
}

◆ SymCryptFdefModMulMontgomery()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1316 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
    PUINT32 pTmp = (PUINT32) pbScratch;
 
    // dcl - missing assert?
    UNREFERENCED_PARAMETER( cbScratch );
    SYMCRYPT_ASSERT( cbScratch >= 2 * nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    SymCryptFdefRawMul( &peSrc1->d.uint32[0], nDigits, &peSrc2->d.uint32[0], nDigits, pTmp );
    SymCryptFdefMontgomeryReduce( pmMod, pTmp, &peDst->d.uint32[0] );
}

◆ SymCryptFdefModMulMontgomery256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomery256Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModMulMontgomeryMulx()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomeryMulx	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModMulMontgomeryMulx1024()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomeryMulx1024	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModMulMontgomeryMulx256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomeryMulx256Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModMulMontgomeryMulxP384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomeryMulxP384Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModMulMontgomeryP384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModMulMontgomeryP384Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModNegGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModNegGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 609 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
    UINT32 isZero;
    UINT32 i;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    //
    // We have to be careful to handle the value 0 properly as it does NOT map to Modulus - Value.
    //
    isZero = SymCryptFdefRawIsEqualUint32( &peSrc->d.uint32[0], nDigits , 0 );
    SymCryptFdefRawSub( SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int ), &peSrc->d.uint32[0], &peDst->d.uint32[0], nDigits );
 
    // Now we set the result to zero if the input was zero
    for( i=0; i< nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32; i++ )
    {
        peDst->d.uint32[i] &= ~isZero;
    }
}

◆ SymCryptFdefModPreGetGeneric()

PCUINT32 SYMCRYPT_CALL SymCryptFdefModPreGetGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 368 of file fdef_mod.c.

{
    UNREFERENCED_PARAMETER( pmMod );
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    return &peObj->d.uint32[0];
}

◆ SymCryptFdefModPreGetMontgomery()

PCUINT32 SYMCRYPT_CALL SymCryptFdefModPreGetMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1282 of file fdef_mod.c.

{
    PUINT32 pTmp = (PUINT32) pbScratch;
    UINT32 nDigits = pmMod->nDigits;
 
    // dcl - this should not incur significant cost, consider checking always
    SYMCRYPT_ASSERT( cbScratch >= nDigits * 2 * SYMCRYPT_FDEF_DIGIT_SIZE );
    UNREFERENCED_PARAMETER( cbScratch );
 
    memcpy( pTmp, &peObj->d.uint32[0], nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
    SymCryptWipe( pTmp + nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32, nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
    SymCryptFdefMontgomeryReduce( pmMod, pTmp, pTmp );
 
    return pTmp;
}

◆ SymCryptFdefModPreGetMontgomery256()

PCUINT32 SYMCRYPT_CALL SymCryptFdefModPreGetMontgomery256	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModSetPostGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModSetPostGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 354 of file fdef_mod.c.

{
    UNREFERENCED_PARAMETER( pmMod );
    UNREFERENCED_PARAMETER( peObj );
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
}

◆ SymCryptFdefModSetPostMontgomery()

VOID SYMCRYPT_CALL SymCryptFdefModSetPostMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1261 of file fdef_mod.c.

{
    // Montgomery representation for X is R*X mod M where R = 2^<nDigits * bits-per-digit>
    // Montgomery reduction performs an implicit division by R
    // This function converts to the internal representation by multiplying by R^2 mod M and then performing a Montgomery reduction
    UINT32 nDigits = pmMod->nDigits;
 
    // dcl - this should not incur significant cost, consider checking always
    SYMCRYPT_ASSERT( cbScratch >= nDigits * 2 * SYMCRYPT_FDEF_DIGIT_SIZE );
    UNREFERENCED_PARAMETER( cbScratch );
 
    SymCryptFdefRawMul( &peObj->d.uint32[0], nDigits, pmMod->tm.montgomery.Rsqr, nDigits, (PUINT32) pbScratch );
    SymCryptFdefMontgomeryReduce( pmMod, (PUINT32) pbScratch, &peObj->d.uint32[0] );
}

◆ SymCryptFdefModSetPostMontgomeryMulx256()

VOID SYMCRYPT_CALL SymCryptFdefModSetPostMontgomeryMulx256	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModSetPostMontgomeryMulxP384()

VOID SYMCRYPT_CALL SymCryptFdefModSetPostMontgomeryMulxP384	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PSYMCRYPT_MODELEMENT	peObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModSetRandomGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModSetRandomGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 703 of file fdef_mod.c.

{
    UINT32 offset;
    UINT32 ulimit;
    UINT32 nDigits = pmMod->nDigits;
    PUINT32 pTmp = (PUINT32) pbScratch;
    UINT32 nUsedBytes;
    UINT32 mask;
    UINT32 c;
    UINT32 cntr;
    PUINT32 pDst = &peDst->d.uint32[0];
    PCUINT32 pMod = SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int );
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
 
    if( (flags & SYMCRYPT_FLAG_MODRANDOM_ALLOW_ZERO) != 0 )
    {
        // SYMCRYPT_FLAG_MODRANDOM_ALLOW_ZERO => SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE
        offset = 0;
    } else if( (flags & SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE) != 0 )
    {
        offset = 1;
    } else
    {
        offset = 2;
    }
 
    if( (flags & SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE ) )
    {
        ulimit = 0;
    } else {
        ulimit = 1;
    }
 
    //
    // Special case for small divisors:
    //  When the divisor is 1, 2, or 3 we always allow returning -1
    //  We may also allow returning 1 or 0 depending on the flags specified
    if ( pmMod->Divisor.nBits < 3 )
    {
        // At a minimum, allow -1
        offset = SYMCRYPT_MIN(offset, pMod[0] - 1);
        ulimit = 0;
    }
 
    // Set pTmp to pMod-(offset+ulimit)
    SYMCRYPT_ASSERT( nDigits * SYMCRYPT_FDEF_DIGIT_SIZE <= cbScratch );
    c = SymCryptFdefRawSubUint32( pMod, offset + ulimit, pTmp, nDigits );
    SYMCRYPT_ASSERT( c == 0 );
 
    nUsedBytes = (pmMod->Divisor.nBits + 7)/8;
    mask = 0x100 >> ( (8-pmMod->Divisor.nBits) & 7);
    mask -= 1;
 
    // Wipe any bytes we won't fill with random
    SymCryptWipe( (PBYTE)pDst + nUsedBytes, (nDigits * SYMCRYPT_FDEF_DIGIT_SIZE) - nUsedBytes );
 
    for(cntr=0; cntr<FDEF_MOD_SET_RANDOM_GENERIC_LIMIT; cntr++)
    {
        // Try random values until we get one we like
        SymCryptCallbackRandom( (PBYTE)pDst, nUsedBytes );
        ((PBYTE)pDst)[nUsedBytes-1] &= (BYTE) mask;
 
        // Compare value to pMod-(offset+ulimit)
        if( SymCryptFdefRawIsLessThan( pDst, pTmp, nDigits ) )
        {
            // The value is within required range [0, Divisor-offset-ulimit)
            break;
        }
    }
 
    // Wipe all the digits in pTmp
    SymCryptWipe( pTmp, nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    if (cntr >= FDEF_MOD_SET_RANDOM_GENERIC_LIMIT)
    {
        SymCryptFatal( 'rndc');
    }
 
    // Add the offset which allows us to avoid 0 and/or 1 if required.
    // Now result is in range [offset, Divisor-ulimit)
    c = SymCryptFdefRawAddUint32( pDst, offset, pDst, nDigits );
    SYMCRYPT_ASSERT( c == 0 );
}

Referenced by SymCryptModSetRandom().

◆ SymCryptFdefModSquareGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModSquareGeneric	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 935 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
    PUINT32 pTmp = (PUINT32) pbScratch;
    UINT32  scratchOffset = 2 * nDigits * SYMCRYPT_FDEF_DIGIT_SIZE;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
    SYMCRYPT_ASSERT( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) >= scratchOffset + SYMCRYPT_FDEF_SCRATCH_BYTES_FOR_INT_DIVMOD( 2 * nDigits, nDigits ) );
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbScratch );
 
    // Tmp space is enough for the product plus the DivMod scratch
 
    SymCryptFdefRawSquare( &peSrc->d.uint32[0], nDigits, pTmp );
 
    SymCryptFdefRawDivMod( pTmp, 2*nDigits, &pmMod->Divisor, NULL, &peDst->d.uint32[0], pbScratch + scratchOffset, cbScratch - scratchOffset );
}

◆ SymCryptFdefModSquareMontgomery()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1380 of file fdef_mod.c.

{
    UINT32 nDigits = pmMod->nDigits;
    PUINT32 pTmp = (PUINT32) pbScratch;
 
    UNREFERENCED_PARAMETER( cbScratch );
    SYMCRYPT_ASSERT( cbScratch >= 2 * nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
 
    SymCryptFdefRawSquare( &peSrc->d.uint32[0], nDigits, pTmp );
    SymCryptFdefMontgomeryReduce( pmMod, pTmp, &peDst->d.uint32[0] );
}

◆ SymCryptFdefModSquareMontgomery256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomery256Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModSquareMontgomeryMulx()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomeryMulx	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModSquareMontgomeryMulx1024()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomeryMulx1024	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModSquareMontgomeryMulx256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomeryMulx256Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModSquareMontgomeryMulxP384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomeryMulxP384Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModSquareMontgomeryP384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModSquareMontgomeryP384Asm	(	_In_ PCSYMCRYPT_MODULUS	pMod,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	pSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	pDst
	)

◆ SymCryptFdefModSub256Asm()

VOID SYMCRYPT_CALL SymCryptFdefModSub256Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

◆ SymCryptFdefModSub384Asm()

VOID SYMCRYPT_CALL SymCryptFdefModSub384Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst
	)

◆ SymCryptFdefModSubGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModSubGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc1,
		_In_ PCSYMCRYPT_MODELEMENT	peSrc2,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 584 of file fdef_mod.c.

{
    UINT32 c;
    UINT32 d;
    UINT32 nDigits = pmMod->nDigits;
 
    SymCryptFdefClaimScratch( pbScratch, cbScratch, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ) );
    SYMCRYPT_ASSERT( cbScratch >= nDigits*SYMCRYPT_FDEF_DIGIT_SIZE );
 
    c = SymCryptFdefRawSub( &peSrc1->d.uint32[0], &peSrc2->d.uint32[0], &peDst->d.uint32[0], nDigits );
    d = SymCryptFdefRawAdd( &peDst->d.uint32[0], SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int ), (PUINT32) pbScratch, nDigits );
    SymCryptFdefMaskedCopy( pbScratch, (PBYTE) &peDst->d.uint32[0], nDigits, 0 - c );
 
    SYMCRYPT_ASSERT( !(c == 1 && d == 0) );
}

◆ SymCryptFdefModulusAllocate()

PSYMCRYPT_MODULUS SYMCRYPT_CALL SymCryptFdefModulusAllocate ( UINT32 nDigits )

Definition at line 11 of file fdef_mod.c.

{
    PVOID               p = NULL;
    UINT32              cb;
    PSYMCRYPT_MODULUS   res = NULL;
 
    //
    // The nDigits requirements are enforced by SymCryptFdefSizeofModulusFromDigits. Thus
    // the result does not overflow and is upper bounded by 2^19.
    //
    cb = SymCryptFdefSizeofModulusFromDigits( nDigits );
 
    if( cb != 0 )
    {
        p = SymCryptCallbackAlloc( cb );
    }
 
    if( p == NULL )
    {
        goto cleanup;
    }
 
    res = SymCryptFdefModulusCreate( p, cb, nDigits );
 
cleanup:
    return res;
}

Referenced by SymCryptModulusAllocate().

◆ SymCryptFdefModulusCopy()

VOID SymCryptFdefModulusCopy	(	_In_ PCSYMCRYPT_MODULUS	pmSrc,
		_Out_ PSYMCRYPT_MODULUS	pmDst
	)

Definition at line 124 of file fdef_mod.c.

{
    SYMCRYPT_ASSERT( pmSrc->nDigits == pmDst->nDigits );
 
    if( pmSrc != pmDst )
    {
        memcpy( pmDst, pmSrc, pmDst->cbSize );
 
        SymCryptFdefDivisorCopyFixup( &pmSrc->Divisor, &pmDst->Divisor );
 
        // Copy the type-specific fields
        SYMCRYPT_MOD_CALL( pmSrc ) modulusCopyFixup( pmSrc, pmDst );
 
        SYMCRYPT_SET_MAGIC( pmDst );
    }
}

Referenced by SymCryptModulusCopy().

◆ SymCryptFdefModulusCopyFixupGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModulusCopyFixupGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmSrc,
		_Out_ PSYMCRYPT_MODULUS	pmDst
	)

Definition at line 145 of file fdef_mod.c.

{
    // Only have to handle the type-specific fields, which we don't have any of.
    UNREFERENCED_PARAMETER( pmSrc );
    UNREFERENCED_PARAMETER( pmDst );
}

◆ SymCryptFdefModulusCopyFixupMontgomery()

VOID SYMCRYPT_CALL SymCryptFdefModulusCopyFixupMontgomery	(	_In_ PCSYMCRYPT_MODULUS	pmSrc,
		_Out_ PSYMCRYPT_MODULUS	pmDst
	)

Definition at line 1304 of file fdef_mod.c.

{
    // We only have to fix up the Montgomery-specific stuff here
    // dcl - not sure I understand why you pass pmSrc here
    UNREFERENCED_PARAMETER( pmSrc );
    pmDst->tm.montgomery.Rsqr = (PUINT32)((PBYTE)&pmDst->Divisor + SymCryptFdefSizeofDivisorFromDigits( pmDst->nDigits ));
}

◆ SymCryptFdefModulusCreate()

PSYMCRYPT_MODULUS SYMCRYPT_CALL SymCryptFdefModulusCreate	(	_Out_writes_bytes_(cbBuffer) PBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		UINT32	nDigits
	)

Definition at line 67 of file fdef_mod.c.

{
    PSYMCRYPT_MODULUS pmMod = NULL;
    UINT32 cb = SymCryptFdefSizeofModulusFromDigits( nDigits );
 
    const UINT32 offset = SYMCRYPT_FIELD_OFFSET( SYMCRYPT_MODULUS, Divisor );
 
    SYMCRYPT_ASSERT( cb >= sizeof(SYMCRYPT_MODULUS) );
    SYMCRYPT_ASSERT( cbBuffer >= cb );
    if( (cb == 0) || (cbBuffer < cb) )
    {
        goto cleanup; // return NULL
    }
 
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
    pmMod = (PSYMCRYPT_MODULUS) pbBuffer;
 
    pmMod->type = 'gM' << 16;
    pmMod->nDigits = nDigits;
 
    //
    // The nDigits requirements are enforced by SymCryptFdefSizeofModulusFromDigits. Thus
    // the result does not overflow and is upper bounded by 2^19.
    //
    pmMod->cbSize = cb;
    pmMod->flags = 0;
 
    // The following is bounded by 2^17
    pmMod->cbModElement = nDigits * SYMCRYPT_FDEF_DIGIT_SIZE;
 
    SymCryptFdefDivisorCreate( pbBuffer + offset, cbBuffer - offset, nDigits );
 
    // We don't have a modulus value yet, so we don't create/initialize any implementation-specific things.
 
    SYMCRYPT_SET_MAGIC( pmMod );
 
cleanup:
    return pmMod;
}

Referenced by SymCryptFdefModulusAllocate(), and SymCryptModulusCreate().

◆ SymCryptFdefModulusFree()

VOID SYMCRYPT_CALL SymCryptFdefModulusFree ( _Out_ PSYMCRYPT_MODULUS pmObj )

Definition at line 41 of file fdef_mod.c.

{
    SymCryptModulusWipe( pmObj );
    SymCryptCallbackFree( pmObj );
}

Referenced by SymCryptModulusFree().

◆ SymCryptFdefModulusInitGeneric()

VOID SYMCRYPT_CALL SymCryptFdefModulusInitGeneric	(	_Inout_ PSYMCRYPT_MODULUS	pmObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 112 of file fdef_mod.c.

{
    UNREFERENCED_PARAMETER( pmMod );
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
}

◆ SymCryptFdefModulusInitMontgomery()

VOID SYMCRYPT_CALL SymCryptFdefModulusInitMontgomery	(	_Inout_ PSYMCRYPT_MODULUS	pmObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1191 of file fdef_mod.c.

{
    SymCryptFdefModulusInitMontgomeryInternal( pmMod, pmMod->nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32, pbScratch, cbScratch );
}

◆ SymCryptFdefModulusInitMontgomery256()

VOID SYMCRYPT_CALL SymCryptFdefModulusInitMontgomery256	(	_Inout_ PSYMCRYPT_MODULUS	pmObj,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptFdefModulusInitMontgomeryInternal()

VOID SYMCRYPT_CALL SymCryptFdefModulusInitMontgomeryInternal	(	_Inout_ PSYMCRYPT_MODULUS	pmObj,
		UINT32	nUint32Used,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1152 of file fdef_mod.c.

{
    // Scratch space is big enough for an nDigit+1 byte value + sufficient divmod scratch
    PUINT32 pR2;
    UINT32  cbR2;
    UINT32 nDigits;
 
    PUINT32 modR2;
    PUINT32 negDivisor;
 
    nDigits = pmMod->nDigits;
    modR2 = (PUINT32)((PBYTE)&pmMod->Divisor + SymCryptFdefSizeofDivisorFromDigits( nDigits ));
 
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbScratch );
 
    pmMod->tm.montgomery.Rsqr = modR2;
    negDivisor = (PUINT32)((PBYTE)modR2 + (nDigits * SYMCRYPT_FDEF_DIGIT_SIZE));
 
    // We pre-compute R^2 mod M
 
    pR2 = (PUINT32) pbScratch;
    cbR2 = (2*nDigits + 1) * SYMCRYPT_FDEF_DIGIT_SIZE;
    SYMCRYPT_ASSERT( cbScratch >= cbR2 );
    SYMCRYPT_ASSERT( cbScratch >= 2 * nUint32Used * sizeof(UINT32) );
 
    // Set it to R^2
    SymCryptWipe( pR2, cbR2 );
    pR2[ 2 * nUint32Used ] = 1;
    SymCryptFdefRawDivMod( pR2, 2*nDigits + 1, &pmMod->Divisor, NULL, modR2, pbScratch + cbR2, cbScratch - cbR2 );
 
    SymCryptFdefRawNeg( SYMCRYPT_FDEF_INT_PUINT32( &pmMod->Divisor.Int ), 0, negDivisor, nDigits );
}

Referenced by SymCryptFdefModulusInitMontgomery().

◆ SymCryptFdefModulusRetrieveHandle()

PSYMCRYPT_MODULUS SYMCRYPT_CALL SymCryptFdefModulusRetrieveHandle ( _In_ PBYTE pbBuffer )

◆ SymCryptFdefMontgomeryReduce1024Asm()

VOID SYMCRYPT_CALL SymCryptFdefMontgomeryReduce1024Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

◆ SymCryptFdefMontgomeryReduce256Asm()

VOID SYMCRYPT_CALL SymCryptFdefMontgomeryReduce256Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

◆ SymCryptFdefMontgomeryReduce512Asm()

VOID SYMCRYPT_CALL SymCryptFdefMontgomeryReduce512Asm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

◆ SymCryptFdefMontgomeryReduceAsm()

VOID SYMCRYPT_CALL SymCryptFdefMontgomeryReduceAsm	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

Referenced by SymCryptFdefMontgomeryReduce().

◆ SymCryptFdefMontgomeryReduceMulx()

VOID SYMCRYPT_CALL SymCryptFdefMontgomeryReduceMulx	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

Referenced by SymCryptFdefMontgomeryReduce().

◆ SymCryptFdefMontgomeryReduceMulx1024()

VOID SYMCRYPT_CALL SymCryptFdefMontgomeryReduceMulx1024	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_Inout_ PUINT32	pSrc,
		_Out_ PUINT32	pDst
	)

◆ SymCryptFdefNumberofDigitsFromInt()

UINT32 SYMCRYPT_CALL SymCryptFdefNumberofDigitsFromInt ( _In_ PCSYMCRYPT_INT piSrc )

Definition at line 337 of file fdef_general.c.

{
    return piSrc->nDigits;
}

◆ SymCryptFdefRawAdd()

UINT32 SYMCRYPT_CALL SymCryptFdefRawAdd	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	Dst,
		UINT32	nDigits
	)

Definition at line 45 of file fdef_int.c.

{
#if SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_ARM
    return SymCryptFdefRawAddAsm( pSrc1, pSrc2, pDst, nDigits );
#else
    return SymCryptFdefRawAddC( pSrc1, pSrc2, pDst, nDigits );
#endif
}

Referenced by SymCryptFdefIntAddMixedSize(), SymCryptFdefIntAddSameSize(), SymCryptFdefModAddGeneric(), and SymCryptFdefModSubGeneric().

◆ SymCryptFdefRawAddAsm()

UINT32 SYMCRYPT_CALL SymCryptFdefRawAddAsm	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	Dst,
		UINT32	nDigits
	)

Referenced by SymCryptFdefRawAdd().

◆ SymCryptFdefRawAddUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefRawAddUint32	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	Src1,
		UINT32	Src2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	Dst,
		UINT32	nDigits
	)

Definition at line 61 of file fdef_int.c.

{
    UINT32 i;
    UINT64 t;
 
    t = Src2;
    for( i=0; i<nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32; i++ )
    {
        t = t + Src1[i];
        Dst[i] = (UINT32) t;
        t >>= 32;
    }
 
    return (UINT32) t;
}

Referenced by SymCryptFdefIntAddMixedSize(), SymCryptFdefIntAddUint32(), and SymCryptFdefModSetRandomGeneric().

◆ SymCryptFdefRawDivMod()

VOID SYMCRYPT_CALL SymCryptFdefRawDivMod	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pNum,
		UINT32	nDigits,
		_In_ PCSYMCRYPT_DIVISOR	pdDivisor,
		_Out_writes_opt_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pQuotient,
		_Out_writes_opt_(SYMCRYPT_OBJ_NUINT32(pdDivisor)) PUINT32	pRemainder,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 1106 of file fdef_int.c.

{
    UINT32 nWords = nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
    UINT32 activeDivWords = (pdDivisor->nBits + 8 * sizeof(UINT32) - 1) / (8 * sizeof( UINT32 ) );
    UINT32 remainderWords = SYMCRYPT_OBJ_NUINT32( pdDivisor );
 
    UINT32 cbScratchNeeded = (nWords+4) * sizeof( UINT32 );
    PUINT32 pTmp = (PUINT32) pbScratch;
    UINT32 Qest;
    UINT32 Q;
    UINT32 c;
    UINT32 d;
    UINT32 shift;
    UINT32 X0, X1;
    UINT32 W;
    UINT64 T;
    UINT32 nQ;
 
    SYMCRYPT_ASSERT( cbScratch >= cbScratchNeeded );
    SYMCRYPT_ASSERT_ASYM_ALIGNED( pbScratch );
 
    if( nWords < activeDivWords )
    {
        //
        // input is smaller in size than the significant size of the divisor, no division to do.
        // Note that both values in the if() statement are public, so this does not create a side channel.
        //
 
        // Set quotient to zero, and the remainder to the input value
        if( pQuotient != NULL )
        {
            SymCryptWipe( pQuotient, nDigits * SYMCRYPT_FDEF_DIGIT_SIZE );
        }
 
        if( pRemainder != NULL )
        {
            SYMCRYPT_ASSERT( remainderWords >= nWords );
            memcpy( pRemainder, pNum, nWords * sizeof( UINT32 ) );
            SymCryptWipe( &pRemainder[nWords], (remainderWords - nWords) * sizeof( UINT32 ) );        // clear the rest of the remainder words
        }
 
        SymCryptFdefClaimScratch( pbScratch, cbScratch, cbScratchNeeded );
        goto cleanup;
    }
 
    //
    // We have two zero words in front and two zero words behind the tmp value to allow unrestricted accesses.
    // We keep the explicit offset of 2 rather than adjust the pTmp pointer to avoid negative indexes which appear
    // to be buffer overflows, and cause trouble with unsigned computations of negative index values that overflow
    // to 2^32 - 1 on a 64-bit CPU.
    //
    pTmp[0] = pTmp[1] = 0;
    memcpy( &pTmp[2], pNum, nWords * sizeof( UINT32 ) );
    pTmp[nWords + 2] = pTmp[nWords + 3] = 0;
    shift = (0 - pdDivisor->nBits) & 31;   // # bits we have to shift top words to the left to align with the W value
 
    // We generate the quotient words one at a time, starting at the most significant position
    // The top (divWords - 1) words are always zero
 
    if( pQuotient != NULL )
    {
        SymCryptWipe( &pQuotient[nWords - activeDivWords + 1], (activeDivWords - 1) * sizeof( UINT32 ) );
    }
 
    nQ = nWords - activeDivWords + 1;
 
    // There is always at least one word of Q to be computed, so we can use a do-while loop which
    // also avoids the UINT32 underflow.
    do
    {
        nQ--;
        X0 = ( ((UINT64) pTmp[nQ + activeDivWords + 2] << 32) + pTmp[nQ + activeDivWords + 1] ) >> (32 - shift);
        X1 = ( ((UINT64) pTmp[nQ + activeDivWords + 1] << 32) + pTmp[nQ + activeDivWords + 0] ) >> (32 - shift);
 
        W = (UINT32) pdDivisor->td.fdef.W;
        T = SYMCRYPT_MUL32x32TO64( W, X0 ) + (((UINT64)X0) << 32) + X1 + ((W>>1) & ((UINT32)0 - (X1 >> 31)));
        Qest = (UINT32)(T >> 32);
        // At this point the estimator is correct or one too small, add one but don't overflow
        Qest += 1;
        Qest += SYMCRYPT_MASK32_ZERO( Qest );
 
        c = SymCryptFdefRawMultSubUint32( &pTmp[nQ+2], SYMCRYPT_FDEF_INT_PUINT32( &pdDivisor->Int ), Qest, activeDivWords );
        Q = Qest - c;
        d = SymCryptFdefRawMaskedAddSubdigit( &pTmp[nQ+2], SYMCRYPT_FDEF_INT_PUINT32( &pdDivisor->Int ), (0-c), activeDivWords );
        SYMCRYPT_ASSERT( c == d );
        SYMCRYPT_ASSERT( pTmp[nQ + activeDivWords+2] == (0 - c) );
 
        if( pQuotient != NULL )
        {
            pQuotient[nQ] = Q;
        }
    } while( nQ > 0 );
 
    if( pRemainder != NULL )
    {
        memcpy( pRemainder, pTmp+2, activeDivWords * sizeof( UINT32 ) );
        SymCryptWipe( &pRemainder[activeDivWords], (remainderWords - activeDivWords) * sizeof( UINT32 ) );
    }
 
cleanup:
    return;         // label needs a statement to follow it...
}

Referenced by SymCryptFdefIntDivMod(), SymCryptFdefIntToModElement(), SymCryptFdefModElementSetValueGeneric(), SymCryptFdefModMulGeneric(), SymCryptFdefModSquareGeneric(), and SymCryptFdefModulusInitMontgomeryInternal().

◆ SymCryptFdefRawGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefRawGetValue	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_bytes_(cbDst) PBYTE	pbDst,
		SIZE_T	cbDst,
		SYMCRYPT_NUMBER_FORMAT	format
	)

Definition at line 619 of file fdef_general.c.

{
    SYMCRYPT_ERROR scError;
    UINT32  b;
    INT32   step;
    UINT32  w;
    UINT32  windex;
    UINT32  i;
    UINT32  nWords = nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
 
    //
    // This is a very simple and slow generic implementation;
    // We'll create optimized versions for specific CPU platforms
    // (e.g. use of memcpy)
    //
 
    switch( format )
    {
    case SYMCRYPT_NUMBER_FORMAT_LSB_FIRST:
        step = 1;
        break;
    case SYMCRYPT_NUMBER_FORMAT_MSB_FIRST:
        step = -1;
        pbDst += cbDst; // avoid tripping pointer overflow sanitizer with cbSrc == 0
        pbDst--;
        break;
    default:
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    for( windex = 0; windex < nWords; windex++ )
    {
        w = pSrc[windex];
        for( i=0; i<4; i++ )
        {
            b = w & 0xff;
            w >>= 8;
 
            // write the next byte
            if( cbDst > 0 )
            {
                *pbDst = (BYTE)b;
                cbDst -= 1;
                pbDst += step;
            } else {
                if( b != 0 )
                {
                    scError = SYMCRYPT_BUFFER_TOO_SMALL;
                    goto cleanup;
                }
            }
        }
    }
 
    // Zero any remaining output bytes
    while( cbDst > 0 )
    {
        *pbDst = 0;
        pbDst += step;
        cbDst -= 1;
    }
 
    scError = SYMCRYPT_NO_ERROR;
 
cleanup:
    return scError;
}

Referenced by SymCryptFdefDecideModulusType(), SymCryptFdefIntGetValue(), and SymCryptFdefModElementGetValue().

◆ SymCryptFdefRawIsEqualUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefRawIsEqualUint32	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		UINT32	nDigits,
		_In_ UINT32	u32Src2
	)

Definition at line 730 of file fdef_general.c.

{
    UINT32 d;
    UINT32 nWords = nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
 
    d = pSrc1[0] ^ u32Src2;
    for( UINT32 i=1; i<nWords; i++)
    {
        d |= pSrc1[i];
    }
 
    return SYMCRYPT_MASK32_ZERO( d );
}

Referenced by SymCryptDlkeyGenerate(), SymCryptFdefIntIsEqualUint32(), and SymCryptFdefModNegGeneric().

◆ SymCryptFdefRawIsLessThan()

UINT32 SYMCRYPT_CALL SymCryptFdefRawIsLessThan	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc2,
		UINT32	nDigits
	)

Definition at line 322 of file fdef_int.c.

{
#if 0 & SYMCRYPT_CPU_AMD64
//    return SymCryptFdefRawIsLessThanAsm( pSrc1, pSrc2, nDigits );
#else
    return SymCryptFdefRawIsLessThanC( pSrc1, pSrc2, nDigits );
#endif
}

Referenced by SymCryptFdefIntIsLessThan(), and SymCryptFdefModSetRandomGeneric().

◆ SymCryptFdefRawMaskedAdd()

UINT32 SYMCRYPT_CALL SymCryptFdefRawMaskedAdd	(	_Inout_updates_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pAcc,
		_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	mask,
		UINT32	nDigits
	)

Definition at line 1070 of file fdef_int.c.

{
    return SymCryptFdefRawMaskedAddSubdigit( pAcc, pSrc, mask, nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32 );
}

◆ SymCryptFdefRawMaskedSub()

UINT32 SYMCRYPT_CALL SymCryptFdefRawMaskedSub	(	_Inout_updates_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pAcc,
		_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	mask,
		UINT32	nDigits
	)

Definition at line 1081 of file fdef_int.c.

{
    UINT32 i;
    UINT64 t;
    UINT32 c;
 
    c = 0;
    for( i=0; i<nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32; i++ )
    {
        t = (UINT64) pAcc[i] - (mask & pSrc[i]) - c;
        pAcc[i] = (UINT32) t;
        c = (UINT32)(t >>= 32) & 1;
    }
 
    return c;
}

◆ SymCryptFdefRawMul()

VOID SYMCRYPT_CALL SymCryptFdefRawMul	(	_In_reads_(nDigits1 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		UINT32	nDigits1,
		_In_reads_(nDigits2 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits2,
		_Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

Definition at line 773 of file fdef_int.c.

{
#if SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_MULX ) )
    {
        SymCryptFdefRawMulMulx( pSrc1, nDigits1, pSrc2, nDigits2, pDst );
    } else {
        SymCryptFdefRawMulAsm( pSrc1, nDigits1, pSrc2, nDigits2, pDst );
    }
#elif SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_ARM
    SymCryptFdefRawMulAsm( pSrc1, nDigits1, pSrc2, nDigits2, pDst );
#else
    SymCryptFdefRawMulC( pSrc1, nDigits1, pSrc2, nDigits2, pDst );
#endif
}

Referenced by SymCryptFdefIntMulMixedSize(), SymCryptFdefModMulGeneric(), SymCryptFdefModMulMontgomery(), and SymCryptFdefModSetPostMontgomery().

◆ SymCryptFdefRawMul1024Asm()

VOID SYMCRYPT_CALL SymCryptFdefRawMul1024Asm	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdefRawMul512Asm()

VOID SYMCRYPT_CALL SymCryptFdefRawMul512Asm	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdefRawMulAsm()

VOID SYMCRYPT_CALL SymCryptFdefRawMulAsm	(	_In_reads_(nDigits1 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		UINT32	nDigits1,
		_In_reads_(nDigits2 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits2,
		_Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

Referenced by SymCryptFdefRawMul(), and SymCryptFdefRawSquare().

◆ SymCryptFdefRawMulMulx()

VOID SYMCRYPT_CALL SymCryptFdefRawMulMulx	(	_In_reads_(nDigits1 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		UINT32	nDigits1,
		_In_reads_(nDigits2 *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits2,
		_Out_writes_((nDigits1+nDigits2) *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

Referenced by SymCryptFdefRawMul().

◆ SymCryptFdefRawMulMulx1024()

VOID SYMCRYPT_CALL SymCryptFdefRawMulMulx1024	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc1,
		_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc2,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdefRawNeg()

UINT32 SYMCRYPT_CALL SymCryptFdefRawNeg	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc1,
		UINT32	carryIn,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	pDst,
		UINT32	nDigits
	)

Definition at line 213 of file fdef_int.c.

{
    UINT32 i;
    UINT64 t;
    UINT32 c;
 
    c = carryIn;
    for( i=0; i<nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32; i++ )
    {
        t = (UINT64)0 - pSrc1[i] - c;
        pDst[i] = (UINT32) t;
        c = (UINT32)(t >> 32) & 1;
    }
 
    return c;
}

Referenced by SymCryptFdefIntNeg(), SymCryptFdefIntSubMixedSize(), and SymCryptFdefModulusInitMontgomeryInternal().

◆ SymCryptFdefRawSetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptFdefRawSetValue	(	_In_reads_bytes_(cbSrc) PCBYTE	pbSrc,
		SIZE_T	cbSrc,
		SYMCRYPT_NUMBER_FORMAT	format,
		_Out_writes_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst,
		UINT32	nDigits
	)

Definition at line 524 of file fdef_general.c.

{
    SYMCRYPT_ERROR scError;
    UINT32  b;
    INT32   step;
    UINT32  w;
    UINT32  windex;
    UINT32  i;
    UINT32  nWords = nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32;
 
    //
    // This is a very simple and slow generic implementation;
    // We'll create optimized versions for specific CPU platforms
    // (e.g. use of memcpy)
    //
 
    // I assume the number format is public?
    switch( format )
    {
    case SYMCRYPT_NUMBER_FORMAT_LSB_FIRST:
        step = 1;
        break;
    case SYMCRYPT_NUMBER_FORMAT_MSB_FIRST:
        step = -1;
        pbSrc += cbSrc; // avoid tripping pointer overflow sanitizer with cbSrc == 0
        pbSrc--;
        break;
    default:
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    for( windex = 0; windex < nWords; windex++ )
    {
        w = 0;
        for( i=0; i<4; i++ )
        {
            // read the next byte into b
            if( cbSrc > 0 )
            {
                b = *pbSrc;
                cbSrc -= 1;
                pbSrc += step;
                w |= b << 8*i;
            }
        }
        pDst[windex] = w;
    }
 
    // Inspect any remaining input bytes
    b = 0;
    while( cbSrc > 0 )
    {
        b |= *pbSrc;
        pbSrc += step;
        cbSrc -= 1;
    }
 
    if( b > 0 )
    {
        scError = SYMCRYPT_BUFFER_TOO_SMALL;
        goto cleanup;
    }
 
    scError = SYMCRYPT_NO_ERROR;
 
cleanup:
    return scError;
}

Referenced by SymCryptFdefIntSetValue(), and SymCryptFdefModElementSetValueGeneric().

◆ SymCryptFdefRawSquare()

VOID SYMCRYPT_CALL SymCryptFdefRawSquare	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

Definition at line 866 of file fdef_int.c.

{
#if SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_MULX ) )
    {
        SymCryptFdefRawSquareMulx( pSrc, nDigits, pDst );
    } else {
        SymCryptFdefRawSquareAsm( pSrc, nDigits, pDst );
    }
#elif SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_ARM
    SymCryptFdefRawSquareAsm( pSrc, nDigits, pDst );
#elif SYMCRYPT_CPU_X86
    SymCryptFdefRawMulAsm( pSrc, nDigits, pSrc, nDigits, pDst );
#else
    SymCryptFdefRawSquareC( pSrc, nDigits, pDst );
#endif
}

Referenced by SymCryptFdefIntSquare(), SymCryptFdefModSquareGeneric(), and SymCryptFdefModSquareMontgomery().

◆ SymCryptFdefRawSquare1024Asm()

VOID SYMCRYPT_CALL SymCryptFdefRawSquare1024Asm	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdefRawSquare512Asm()

VOID SYMCRYPT_CALL SymCryptFdefRawSquare512Asm	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdefRawSquareAsm()

VOID SYMCRYPT_CALL SymCryptFdefRawSquareAsm	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

Referenced by SymCryptFdefRawSquare().

◆ SymCryptFdefRawSquareMulx()

VOID SYMCRYPT_CALL SymCryptFdefRawSquareMulx	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

Referenced by SymCryptFdefRawSquare().

◆ SymCryptFdefRawSquareMulx1024()

VOID SYMCRYPT_CALL SymCryptFdefRawSquareMulx1024	(	_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32	pSrc,
		UINT32	nDigits,
		_Out_writes_(2 nDigits SYMCRYPT_FDEF_DIGIT_NUINT32) PUINT32	pDst
	)

◆ SymCryptFdefRawSub()

UINT32 SYMCRYPT_CALL SymCryptFdefRawSub	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	pDst,
		UINT32	nDigits
	)

Definition at line 174 of file fdef_int.c.

{
#if SYMCRYPT_CPU_AMD64 | SYMCRYPT_CPU_X86 | SYMCRYPT_CPU_ARM64 | SYMCRYPT_CPU_ARM
    return SymCryptFdefRawSubAsm( pSrc1, pSrc2, pDst, nDigits );
#else
    return SymCryptFdefRawSubC( pSrc1, pSrc2, pDst, nDigits );
#endif
}

Referenced by SymCryptFdefIntSubMixedSize(), SymCryptFdefIntSubSameSize(), SymCryptFdefModAddGeneric(), SymCryptFdefModNegGeneric(), SymCryptFdefModSubGeneric(), and SymCryptFdefMontgomeryReduceC().

◆ SymCryptFdefRawSubAsm()

UINT32 SYMCRYPT_CALL SymCryptFdefRawSubAsm	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc1,
		_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	pDst,
		UINT32	nDigits
	)

Referenced by SymCryptFdefRawSub().

◆ SymCryptFdefRawSubUint32()

UINT32 SYMCRYPT_CALL SymCryptFdefRawSubUint32	(	_In_reads_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PCUINT32	pSrc1,
		UINT32	Src2,
		_Out_writes_bytes_(nDigits *SYMCRYPT_FDEF_DIGIT_SIZE) PUINT32	pDst,
		UINT32	nDigits
	)

Definition at line 190 of file fdef_int.c.

{
    UINT32 i;
    UINT64 t;
    UINT32 c;
 
    c = Src2;
    for( i=0; i<nDigits * SYMCRYPT_FDEF_DIGIT_NUINT32; i++ )
    {
        t = (UINT64)pSrc1[i] - c;
        pDst[i] = (UINT32) t;
        c = (UINT32)(t >> 32) & 1;
    }
 
    return c;
}

Referenced by SymCryptFdefIntSubMixedSize(), SymCryptFdefIntSubUint32(), SymCryptFdefModElementSetValueNegUint32(), and SymCryptFdefModSetRandomGeneric().

◆ SymCryptFdefSizeofDivisorFromDigits()

UINT32 SYMCRYPT_CALL SymCryptFdefSizeofDivisorFromDigits ( UINT32 nDigits )

Definition at line 826 of file fdef_general.c.

{
    SYMCRYPT_ASSERT( nDigits != 0 );
    SYMCRYPT_ASSERT( nDigits <= SYMCRYPT_FDEF_UPB_DIGITS );
 
    // Ensure we do not overflow the following calculation when provided with invalid inputs
    if( nDigits == 0 || nDigits > SYMCRYPT_FDEF_UPB_DIGITS )
    {
        return 0;
    }
 
    return SYMCRYPT_FIELD_OFFSET( SYMCRYPT_DIVISOR, Int ) + SymCryptFdefSizeofIntFromDigits( nDigits );
}

Referenced by SymCryptFdefDivisorAllocate(), SymCryptFdefModulusCopyFixupMontgomery(), SymCryptFdefModulusInitMontgomeryInternal(), SymCryptFdefSizeofModulusFromDigits(), and SymCryptSizeofDivisorFromDigits().

◆ SymCryptFdefSizeofIntFromDigits()

UINT32 SYMCRYPT_CALL SymCryptFdefSizeofIntFromDigits ( UINT32 nDigits )

Definition at line 196 of file fdef_general.c.

{
    SYMCRYPT_ASSERT( nDigits != 0 );
    SYMCRYPT_ASSERT( nDigits <= SYMCRYPT_FDEF_UPB_DIGITS );
 
    // Ensure we do not overflow the following calculation when provided with invalid inputs
    if( nDigits == 0 || nDigits > SYMCRYPT_FDEF_UPB_DIGITS )
    {
        return 0;
    }
 
    // Note: ti stands for 'Type-Int' and it helps catch type errors when type-casting macros are used.
    return SYMCRYPT_FIELD_OFFSET( SYMCRYPT_INT, ti ) + nDigits * SYMCRYPT_FDEF_DIGIT_SIZE;
}

Referenced by SymCryptFdefIntAllocate(), SymCryptFdefIntCreate(), SymCryptFdefSizeofDivisorFromDigits(), and SymCryptSizeofIntFromDigits().

◆ SymCryptFdefSizeofModElementFromModulus()

UINT32 SYMCRYPT_CALL SymCryptFdefSizeofModElementFromModulus ( PCSYMCRYPT_MODULUS pmMod )

Definition at line 194 of file fdef_mod.c.

{
    // Upper bounded by 2^17 since the modulus is up to SYMCRYPT_INT_MAXBITS = 2^20 bits.
    return pmMod->cbModElement;
}

Referenced by SymCryptFdefModElementAllocate(), SymCryptFdefModElementCreate(), and SymCryptSizeofModElementFromModulus().

◆ SymCryptFdefSizeofModulusFromDigits()

UINT32 SYMCRYPT_CALL SymCryptFdefSizeofModulusFromDigits ( UINT32 nDigits )

Definition at line 49 of file fdef_mod.c.

{
    SYMCRYPT_ASSERT( nDigits != 0 );
    SYMCRYPT_ASSERT( nDigits <= SYMCRYPT_FDEF_UPB_DIGITS );
 
    // Ensure we do not overflow the following calculation when provided with invalid inputs
    if( nDigits == 0 || nDigits > SYMCRYPT_FDEF_UPB_DIGITS )
    {
        return 0;
    }
 
    // Room for the Modulus structure, the Divisor, the negated divisor, and the R^2 Montgomery factor
    //
    return SYMCRYPT_FIELD_OFFSET( SYMCRYPT_MODULUS, Divisor ) + SymCryptFdefSizeofDivisorFromDigits( nDigits ) + (2 * nDigits * SYMCRYPT_FDEF_DIGIT_SIZE);
}

Referenced by SymCryptFdefModulusAllocate(), SymCryptFdefModulusCreate(), and SymCryptSizeofModulusFromDigits().

◆ SymCryptFixedWindowRecoding()

VOID SYMCRYPT_CALL SymCryptFixedWindowRecoding	(	UINT32	W,
		_Inout_ PSYMCRYPT_INT	piK,
		_Inout_ PSYMCRYPT_INT	piTmp,
		_Out_writes_(nRecodedDigits) PUINT32	absofKIs,
		_Out_writes_(nRecodedDigits) PUINT32	sigofKIs,
		UINT32	nRecodedDigits
	)

Definition at line 44 of file recoding.c.

{
    UINT32 T1 = 0;
    UINT32 T2 = 0;
    UINT32 mask = ~(0xffffffff << W);       // Window mask = 2^w - 1 (e.g. 0x0000003f for w = 6)
    UINT32 smask = 0x1 << (W-1);            // Sign mask   = 2^(w-1) (e.g. 0x00000020 for w = 6)
 
    SYMCRYPT_ASSERT( W < 32 );
 
    for (UINT32 i=0; i < nRecodedDigits - 1; i++)
    {
        T1 = SymCryptIntGetValueLsbits32( piK ) & mask;         // T1 = k mod 2^W
 
        // At this point if the w-th bit of T1 is 1 then we know that T1 > 2^(w-1)
        // (Since k = odd is a loop invariant).
        //
        // In this case, (case A), T1 & ~smask is equal to (k mod 2^w) - 2^(w-1) = k_i = |k_i|.
        //
        // Otherwise, (case B), we know that T1 < 2^(w-1). Therefore 2^(w-1) - T1 = |k_i|.
 
        sigofKIs[i] = SYMCRYPT_MASK32_ZERO( T1 & smask );       // If the sign of k_i is - this mask is set to 0xffffffff. (Case B)
 
        T2 = T1 & ~smask;                                       // |k_i| in case A
        T1 = smask - T1;                                        // |k_i| in case B
 
        absofKIs[i] = ((T1 & sigofKIs[i]) | (T2 & ~sigofKIs[i])) >> 1; // Setting (masked) the absolute value of k_i in absofKIs (divided by 2)
 
        SymCryptIntSubUint32( piK, T2, piTmp );                 // This gives k - k_i in case (A)
        SymCryptIntAddUint32( piK, T1, piK );                   // This gives k - k_i in case (B)
 
        SymCryptIntMaskedCopy( piTmp, piK, ~sigofKIs[i] );      // Copy the result to piK in case (B)
 
        SymCryptIntDivPow2( piK, W-1, piK );                    // k := k / 2^(w-1)
    }
 
    // The last sign is positive given k < GOrd => k_t < 2^w
    sigofKIs[nRecodedDigits - 1] = 0;
    // Belts and braces, select only the bottom w-1 bits (ensure all absofKIs represent odd values in range [1,2^(w-1)-1])
    absofKIs[nRecodedDigits - 1] = (SymCryptIntGetValueLsbits32( piK ) & mask & ~smask) >> 1;
}

Referenced by SymCryptEcpointScalarMulFixedWindow().

◆ SymCryptGcmDecryptPartTwoPass()

VOID SYMCRYPT_CALL SymCryptGcmDecryptPartTwoPass	(	_Inout_ PSYMCRYPT_GCM_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 543 of file gcm.c.

{
    SymCryptGcmAddMacData( pState, pbSrc, cbData );
 
    //
    // Do the actual decryption
    // This violates the read-once rule, but it is safe for the same reasons as above
    // in the encryption case.
    //
 
    SymCryptGcmEncryptDecryptPart( pState, pbSrc, pbDst, cbData );
}

Referenced by SymCryptAesGcmDecryptPart(), SymCryptGcmDecrypt(), and SymCryptGcmDecryptPart().

◆ SymCryptGcmEncryptPartTwoPass()

VOID SYMCRYPT_CALL SymCryptGcmEncryptPartTwoPass	(	_Inout_ PSYMCRYPT_GCM_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 481 of file gcm.c.

{
    //
    // Do the actual encryption
    //
    SymCryptGcmEncryptDecryptPart( pState, pbSrc, pbDst, cbData );
 
    //
    // We break the read-once/write once rule here by reading the pbDst data back.
    // In this particular situation this is safe, and avoiding it is expensive as it
    // requires an extra copy and an extra memory buffer.
    // The first write exposes the GCM key stream, independent of the underlying data that
    // we are processing. From an attacking point of view we can think of this as literally
    // handing over the key stream. So encryption consists of two steps:
    // - hand over the key stream
    // - MAC some ciphertext
    // In this view (which has equivalent security properties to GCM) is obviously doesn't
    // matter that we read pbDst back.
    //
 
    SymCryptGcmAddMacData( pState, pbDst, cbData );
}

Referenced by SymCryptAesGcmEncryptPart(), SymCryptGcmEncrypt(), and SymCryptGcmEncryptPart().

◆ SymCryptGetCachedEcurve()

PCSYMCRYPT_ECURVE SYMCRYPT_CALL SymCryptGetCachedEcurve ( SYMCRYPT_CACHED_ECURVE_ID curveId )

Definition at line 33 of file ec_internal_curves.c.

{
    PCSYMCRYPT_ECURVE pCachedCurve = NULL;
    PSYMCRYPT_ECURVE pNewCurve = NULL;
    PSYMCRYPT_ECURVE pCurrCurve = NULL;
    PCSYMCRYPT_ECURVE_PARAMS pParams = NULL;
 
    if ( curveId < 0 || curveId >= SYMCRYPT_CACHED_ECURVE_ID_COUNT )
    {
        return NULL;
    }
 
    pCachedCurve = (PCSYMCRYPT_ECURVE) SYMCRYPT_ATOMIC_LOADPTR_ACQUIRE( &rgpCachedCurves[curveId] );
    if ( pCachedCurve != NULL )
    {
        return pCachedCurve;
    }
 
    pParams = SymCryptGetCachedEcurveParams( curveId );
    if ( pParams == NULL )
    {
        return NULL;
    }
 
    pNewCurve = SymCryptEcurveAllocate( pParams, 0 );
    if ( pNewCurve == NULL )
    {
        return NULL;
    }
 
    pCurrCurve = SYMCRYPT_ATOMIC_CAS_PTR_ACQUIRE_RELEASE(
                    &rgpCachedCurves[curveId],
                    pNewCurve,
                    NULL);
 
    // Means the original curve was already filled
    // and that our new curve was not used. So we
    // free the new curve and return the existing one.
    if ( pCurrCurve != NULL )
    {
        SymCryptEcurveFree( pNewCurve );
        return pCurrCurve;
    }
 
    return pNewCurve;
}

◆ SymCryptGHashAppendData()

VOID SYMCRYPT_CALL SymCryptGHashAppendData	(	_In_ PCSYMCRYPT_GHASH_EXPANDED_KEY	expandedKey,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 884 of file ghash.c.

{
#if SYMCRYPT_CPU_X86
    PCSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    pExpandedKeyTable = (PSYMCRYPT_GF128_ELEMENT)&expandedKey->tableSpace[expandedKey->tableOffset];
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE ) )
    {
        if( SymCryptSaveXmm( &SaveData ) != SYMCRYPT_NO_ERROR )
        {
            SymCryptFatal( 'pclm' );
        }
        SymCryptGHashAppendDataPclmulqdq( pExpandedKeyTable, pState, pbData, cbData );
        SymCryptRestoreXmm( &SaveData );
    } else if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_SSE2 ) && SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptGHashAppendDataXmm( pExpandedKeyTable, pState, pbData, cbData );
        SymCryptRestoreXmm( &SaveData );
    } else {
        SymCryptGHashAppendDataC( pExpandedKeyTable, pState, pbData, cbData );
    }
 
#elif SYMCRYPT_CPU_AMD64
    PCSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
 
    pExpandedKeyTable = &expandedKey->table[0];
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE ) )
    {
        SymCryptGHashAppendDataPclmulqdq( pExpandedKeyTable, pState, pbData, cbData );
    } else if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_SSE2 ) )
    {
        SymCryptGHashAppendDataXmm( pExpandedKeyTable, pState, pbData, cbData );
    } else {
        SymCryptGHashAppendDataC( pExpandedKeyTable, pState, pbData, cbData );
    }
#elif SYMCRYPT_CPU_ARM
    PCSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
 
    pExpandedKeyTable = &expandedKey->table[0];
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON ) )
    {
        SymCryptGHashAppendDataNeon( pExpandedKeyTable, pState, pbData, cbData );
    } else {
        SymCryptGHashAppendDataC( pExpandedKeyTable, pState, pbData, cbData );
    }
#elif SYMCRYPT_CPU_ARM64
    PCSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
 
    pExpandedKeyTable = &expandedKey->table[0];
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_PMULL ) )
    {
        SymCryptGHashAppendDataPmull( pExpandedKeyTable, pState, pbData, cbData );
    } else if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON ) )
    {
        SymCryptGHashAppendDataNeon( pExpandedKeyTable, pState, pbData, cbData );
    } else {
        SymCryptGHashAppendDataC( pExpandedKeyTable, pState, pbData, cbData );
    }
#else
    SymCryptGHashAppendDataC( &expandedKey->table[0], pState, pbData, cbData );
#endif
}

Referenced by SymCryptAesGcmDecryptPartOnePass(), SymCryptAesGcmEncryptPartOnePass(), SymCryptGcmAddMacData(), SymCryptGcmComputeTag(), SymCryptGcmDecrypt(), SymCryptGcmEncrypt(), SymCryptGcmPadMacData(), and SymCryptGcmSetNonce().

◆ SymCryptGHashAppendDataC()

VOID SYMCRYPT_CALL SymCryptGHashAppendDataC	(	_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 61 of file ghash.c.

{
    UINT64 R0, R1;
    UINT64 mask;
    SYMCRYPT_ALIGN UINT32 state32[4];
    UINT32 t;
    int i,j;
    while( cbData >= SYMCRYPT_GF128_BLOCK_SIZE )
    {
        R0 = R1 = 0;
 
        //
        // We have two nested loops so that we can do most of our operations
        // on 32-bit words. 64-bit rotates/shifts can be really slow on a 32-bit CPU.
        // On AMD64 we use the XMM version which is much faster.
        //
        state32[0] = (UINT32)pState->ull[0];
        state32[1] = (UINT32)(pState->ull[0] >> 32);
        state32[2] = (UINT32)pState->ull[1];
        state32[3] = (UINT32)(pState->ull[1] >> 32);
        for( i=0; i<4; i++ )
        {
            t = SYMCRYPT_LOAD_MSBFIRST32( &pbData[4*i] ) ^ state32[3-i];
            for( j=31; j>=0; j-- )
            {
                mask = (UINT64)( -(INT64)(t & 1 ));
                R0 ^= expandedKeyTable[32*i+j].ull[0] & mask;
                R1 ^= expandedKeyTable[32*i+j].ull[1] & mask;
                t >>= 1;
            }
        }
        pState->ull[0] = R0;
        pState->ull[1] = R1;
        pbData += SYMCRYPT_GF128_BLOCK_SIZE;
        cbData -= SYMCRYPT_GF128_BLOCK_SIZE;
    }
 
    SymCryptWipeKnownSize( state32, sizeof( state32 ) );
}

Referenced by SymCryptGHashAppendData().

◆ SymCryptGHashAppendDataNeon()

VOID SYMCRYPT_CALL SymCryptGHashAppendDataNeon	(	_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Referenced by SymCryptGHashAppendData().

◆ SymCryptGHashAppendDataPclmulqdq()

VOID SYMCRYPT_CALL SymCryptGHashAppendDataPclmulqdq	(	_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Referenced by SymCryptGHashAppendData().

◆ SymCryptGHashAppendDataXmm()

VOID SYMCRYPT_CALL SymCryptGHashAppendDataXmm	(	_In_reads_(SYMCRYPT_GF128_FIELD_SIZE) PCSYMCRYPT_GF128_ELEMENT	expandedKeyTable,
		_Inout_ PSYMCRYPT_GF128_ELEMENT	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Referenced by SymCryptGHashAppendData().

◆ SymCryptGHashExpandKey()

VOID SYMCRYPT_CALL SymCryptGHashExpandKey	(	_Out_ PSYMCRYPT_GHASH_EXPANDED_KEY	expandedKey,
		_In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE	pH
	)

Definition at line 816 of file ghash.c.

{
#if  SYMCRYPT_CPU_X86
    PSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    //
    // Initialize offset into table space for 16-alignment.
    //
    expandedKey->tableOffset = (0 -((UINT_PTR) &expandedKey->tableSpace[0])) % sizeof(SYMCRYPT_GF128_ELEMENT);
 
    pExpandedKeyTable = (PSYMCRYPT_GF128_ELEMENT)&expandedKey->tableSpace[expandedKey->tableOffset];
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE ) )
    {
        //
        // We can only use the PCLMULQDQ data representation if the SaveXmm never fails.
        // This is one of the CPU features required.
        // We check anyway...
        //
        if( SymCryptSaveXmm( &SaveData ) != SYMCRYPT_NO_ERROR )
        {
            SymCryptFatal( 'pclm' );
        }
        SymCryptGHashExpandKeyPclmulqdq( pExpandedKeyTable, pH );
        SymCryptRestoreXmm( &SaveData );
    } else if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_SSE2 ) && SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptGHashExpandKeyXmm( pExpandedKeyTable, pH );
        SymCryptRestoreXmm( &SaveData );
    } else {
        SymCryptGHashExpandKeyC( pExpandedKeyTable, pH );
    }
 
#elif SYMCRYPT_CPU_AMD64
    PSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
    pExpandedKeyTable = &expandedKey->table[0];
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE ) )
    {
        SymCryptGHashExpandKeyPclmulqdq( pExpandedKeyTable, pH );
    } else if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_SSE2 ) )
    {
        SymCryptGHashExpandKeyXmm( pExpandedKeyTable, pH );
    } else {
        SymCryptGHashExpandKeyC( pExpandedKeyTable, pH );
    }
 
#elif SYMCRYPT_CPU_ARM64
    PSYMCRYPT_GF128_ELEMENT pExpandedKeyTable;
    pExpandedKeyTable = &expandedKey->table[0];
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_PMULL ) )
    {
        SymCryptGHashExpandKeyPmull( pExpandedKeyTable, pH );
    } else {
        SymCryptGHashExpandKeyC( pExpandedKeyTable, pH );
    }
 
#else
    SymCryptGHashExpandKeyC( &expandedKey->table[0], pH );      // Default expansion (does not need alignment)
#endif
}

Referenced by SymCryptGcmExpandKey().

◆ SymCryptGHashExpandKeyAmd64()

VOID SYMCRYPT_CALL SymCryptGHashExpandKeyAmd64	(	_Out_writes_(SYMCRYPT_GF128_FIELD_SIZE) PSYMCRYPT_GF128_ELEMENT	expandedKey,
		_In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE	pH
	)

◆ SymCryptGHashExpandKeyC()

VOID SYMCRYPT_CALL SymCryptGHashExpandKeyC	(	_Out_writes_(SYMCRYPT_GF128_FIELD_SIZE) PSYMCRYPT_GF128_ELEMENT	expandedKey,
		_In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE	pH
	)

Definition at line 27 of file ghash.c.

{
    UINT64 H0, H1, t;
    UINT32 i;
 
    //
    // (H1, H0) form a 128-bit integer, H1 is the upper part, H0 the lower part.
    // Convert pH[] to (H1, H0) using MSByte first convention.
    //
    H1 = SYMCRYPT_LOAD_MSBFIRST64( &pH[0] );
    H0 = SYMCRYPT_LOAD_MSBFIRST64( &pH[8] );
 
    for( i=0; i<SYMCRYPT_GF128_FIELD_SIZE; i++ )
    {
        expandedKey[i].ull[0] = H0;
        expandedKey[i].ull[1] = H1;
        //
        // Multiply (H1,H0) by x in the GF(2^128) field using the field encoding from SP800-38D
        //
        t =  UINT64_NEG(H0 & 1) & ((UINT64)GF128_FIELD_R_BYTE << (8 * ( sizeof( UINT64 ) - 1 )) ) ;
        H0 = (H0 >> 1) | (H1 << 63);
        H1 = (H1 >> 1) ^ t;
    }
}

Referenced by SymCryptGHashExpandKey(), and SymCryptGHashExpandKeyXmm().

◆ SymCryptGHashExpandKeyX86()

VOID SYMCRYPT_CALL SymCryptGHashExpandKeyX86	(	_Out_ PSYMCRYPT_GHASH_EXPANDED_KEY	expandedKey,
		_In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE	pH
	)

◆ SymCryptGHashResult()

VOID SYMCRYPT_CALL SymCryptGHashResult	(	_In_ PCSYMCRYPT_GF128_ELEMENT	pState,
		_Out_writes_(SYMCRYPT_GF128_BLOCK_SIZE) PBYTE	pbResult
	)

Definition at line 108 of file ghash.c.

{
    SYMCRYPT_STORE_MSBFIRST64( pbResult    , pState->ull[1] );
    SYMCRYPT_STORE_MSBFIRST64( pbResult + 8, pState->ull[0] );
}

Referenced by SymCryptGcmSetNonce().

◆ SymCryptHashAppendInternal()

VOID SYMCRYPT_CALL SymCryptHashAppendInternal	(	_In_ PCSYMCRYPT_HASH	pHash,
		_Inout_ PSYMCRYPT_COMMON_HASH_STATE	pState,
		_In_reads_bytes_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 10 of file hash.c.

{
    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;
}

Referenced by SymCryptMd2Append(), SymCryptMd4Append(), SymCryptMd5Append(), and SymCryptSha1Append().

◆ SymCryptHashCommonPaddingMd4Style()

VOID SYMCRYPT_CALL SymCryptHashCommonPaddingMd4Style	(	_In_ PCSYMCRYPT_HASH	pHash,
		_Inout_ PSYMCRYPT_COMMON_HASH_STATE	pState
	)

Definition at line 85 of file hash.c.

{
    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 );
}

Referenced by SymCryptMd4Result(), and SymCryptMd5Result().

◆ SymCryptHbsGetDigit()

UINT32 SYMCRYPT_CALL SymCryptHbsGetDigit	(	UINT32	width,
		_In_ PCBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		UINT32	index
	)

Definition at line 1429 of file xmss.c.

{
    UNREFERENCED_PARAMETER(cbBuffer);
 
    SYMCRYPT_ASSERT(width == 1 || width == 2 || width == 4 || width == 8);
    SYMCRYPT_ASSERT(index < ((cbBuffer * 8) / width));
 
    UINT32 digitsPerByte = 8 / width;
 
    BYTE value = pbBuffer[index / digitsPerByte];
 
    value >>= width * (digitsPerByte - 1 - (index % digitsPerByte));
 
    value &= (1 << width) - 1;
 
    return value;
}

Referenced by LmsComputeOtsPubKeyCandidate(), LmsOtsCalculateChecksum(), LmsOtskeySign(), SymCryptXmssWotspPublickeyFromSignature(), and SymCryptXmssWotspSign().

◆ SymCryptHbsGetWinternitzLengths()

VOID SYMCRYPT_CALL SymCryptHbsGetWinternitzLengths	(	UINT32	n,
		UINT32	w,
		_Out_ PUINT32	puLen1,
		_Out_ PUINT32	puLen2
	)

Definition at line 188 of file xmss.c.

{
    UINT32  len1;
    UINT32  len2;
    UINT32  maxChecksum;
    UINT32  msb;
 
    SYMCRYPT_ASSERT(n > 0);
    SYMCRYPT_ASSERT(w >= 1 && w <= 8);
 
    // number of w-bit digits in an n-byte input
    len1 = (8 * n + (w - 1)) / w;
 
    // maximum value the checksum can take (each w-bit digit can have value at most 2^w-1)
    maxChecksum = len1 * ((1 << w) - 1);
 
    msb = 31 - SymCryptCountLeadingZeros32(maxChecksum);
 
    // msb + 1 bits are required to store the maxChecksum,
    // calculate the number of w-bit blocks to represent that
    len2 = (msb + 1 + (w - 1)) / w;
 
    *puLen1 = len1;
    *puLen2 = len2;
}

Referenced by SymCryptLmsParamsFromAlgId(), SymCryptLmsSetParams(), and SymCryptXmssDeriveParams().

◆ SymCryptHbsIncrementalTreehashAllocNode()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashAllocNode	(	_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH	pIncHash,
		UINT32	nLeafIndex
	)

Definition at line 623 of file xmss.c.

{
    SYMCRYPT_ASSERT(pIncHash->nSize < pIncHash->nCapacity);
 
    PSYMCRYPT_TREEHASH_NODE pNode = SymCryptHbsIncrementalTreehashGetNode(pIncHash, pIncHash->nSize);
 
    pNode->height = 0;
    pNode->index = nLeafIndex;
 
    pIncHash->nSize++;
 
    return pNode;
}

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashFinalize()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashFinalize ( _Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash )

Definition at line 695 of file xmss.c.

{
    return SymCryptHbsIncrementalTreehashProcessCommon(pIncHash, TRUE);
}

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashGetNode()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetNode	(	_In_ PSYMCRYPT_INCREMENTAL_TREEHASH	pIncHash,
		SIZE_T	index
	)

Definition at line 609 of file xmss.c.

{
    PBYTE pNode = (PBYTE)pIncHash->arrNodes;
 
    pNode += index * pIncHash->cbNode;
 
    return (PSYMCRYPT_TREEHASH_NODE)pNode;
}

Referenced by SymCryptHbsIncrementalTreehashAllocNode(), and SymCryptHbsIncrementalTreehashGetTopNodes().

◆ SymCryptHbsIncrementalTreehashGetTopNodes()

VOID SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetTopNodes	(	_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH	pIncHash,
		_Out_ PSYMCRYPT_TREEHASH_NODE *	ppNodeLeft,
		_Out_ PSYMCRYPT_TREEHASH_NODE *	ppNodeRight
	)

Definition at line 642 of file xmss.c.

{
    *ppNodeRight = (pIncHash->nSize < 1) ? NULL : SymCryptHbsIncrementalTreehashGetNode(pIncHash, pIncHash->nSize - 1);
 
    *ppNodeLeft = (pIncHash->nSize < 2) ? NULL : SymCryptHbsIncrementalTreehashGetNode(pIncHash, pIncHash->nSize - 2);
}

Referenced by SymCryptHbsIncrementalTreehashProcessCommon().

◆ SymCryptHbsIncrementalTreehashInit()

PSYMCRYPT_INCREMENTAL_TREEHASH SYMCRYPT_CALL SymCryptHbsIncrementalTreehashInit	(	UINT32	nLeaves,
		PBYTE	pbBuffer,
		SIZE_T	cbBuffer,
		UINT32	cbHashResult,
		PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC	funcCompressNodes,
		PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT	pContext
	)

Definition at line 582 of file xmss.c.

{
    UNREFERENCED_PARAMETER(cbBuffer);
 
    SYMCRYPT_ASSERT(cbBuffer >= SymCryptHbsSizeofScratchBytesForIncrementalTreehash(cbHashResult, nLeaves));
 
    PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash = (PSYMCRYPT_INCREMENTAL_TREEHASH)pbBuffer;
 
    pIncHash->cbNode = 2 * sizeof(UINT32) + cbHashResult;
    pIncHash->nSize = 0;
    pIncHash->nCapacity = SymCryptHbsIncrementalTreehashStackDepth(nLeaves);
    pIncHash->nLastLeafIndex = 0;
    pIncHash->funcCompressNodes = funcCompressNodes;
    pIncHash->pContext = pContext;
 
    return pIncHash;
}

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashProcess()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcess ( _Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash )

Definition at line 686 of file xmss.c.

{
    return SymCryptHbsIncrementalTreehashProcessCommon(pIncHash, FALSE);
}

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashProcessCommon()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcessCommon	(	_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH	pIncHash,
		BOOLEAN	fFinal
	)

Definition at line 655 of file xmss.c.

{
    PSYMCRYPT_TREEHASH_NODE pNodeLeft = NULL;
    PSYMCRYPT_TREEHASH_NODE pNodeRight = NULL;
 
    SYMCRYPT_ASSERT(pIncHash->nSize > 0);
 
    SymCryptHbsIncrementalTreehashGetTopNodes(pIncHash, &pNodeLeft, &pNodeRight);
 
    while ( pNodeLeft &&
            (fFinal || (pNodeLeft->height == pNodeRight->height)) )
    {
        pIncHash->funcCompressNodes(
            pNodeLeft,
            pNodeRight,
            pNodeLeft,
            pIncHash->pContext);
 
        pIncHash->nSize--;
 
        SymCryptHbsIncrementalTreehashGetTopNodes(pIncHash, &pNodeLeft, &pNodeRight);
    }
 
    return pNodeRight;
}

Referenced by SymCryptHbsIncrementalTreehashFinalize(), and SymCryptHbsIncrementalTreehashProcess().

◆ SymCryptHbsIncrementalTreehashStackDepth()

UINT32 SYMCRYPT_CALL SymCryptHbsIncrementalTreehashStackDepth ( UINT32 nLeaves )

Definition at line 704 of file xmss.c.

{
    UINT32 h;
 
    // Minimum height binary tree that contains nLeaves many leaves is h+1
    h = 31 - SymCryptCountLeadingZeros32(nLeaves);
 
    // Tree root computation will require a stack of depth equal to tree height plus 1
    return (h + 2);
}

Referenced by SymCryptHbsIncrementalTreehashInit(), and SymCryptHbsSizeofScratchBytesForIncrementalTreehash().

◆ SymCryptHbsSizeofScratchBytesForIncrementalTreehash()

SIZE_T SYMCRYPT_CALL SymCryptHbsSizeofScratchBytesForIncrementalTreehash	(	UINT32	cbNode,
		UINT32	nLeaves
	)

Definition at line 719 of file xmss.c.

{
    SIZE_T nodeSize = cbNode + 2 * sizeof(UINT32);
    SIZE_T result = (sizeof(SYMCRYPT_INCREMENTAL_TREEHASH) - sizeof(SYMCRYPT_TREEHASH_NODE));
 
    result += nodeSize * SymCryptHbsIncrementalTreehashStackDepth(nLeaves);
    return result;
}

Referenced by SymCryptHbsIncrementalTreehashInit(), SymCryptXmssComputePublicRoot(), SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptInitEnvCommon()

VOID SYMCRYPT_CALL SymCryptInitEnvCommon ( UINT32 version )

Definition at line 43 of file libmain.c.

{
    UINT32 tmp;
 
    const CHAR * p;
 
    // Assertion that verifies that the calling application was compiled with
    // the same version header files as the library.
    if( version != SYMCRYPT_API_VERSION )
    {
        SymCryptFatal( 'apiv' );
    }
 
    //
    // Use an interlocked to set the flag in case we add other flags
    // that are modified by different threads.
    //
    SYMCRYPT_ATOMIC_OR32_PRE_RELAXED( &g_SymCryptFlags, SYMCRYPT_FLAG_LIB_INITIALIZED );
 
    //
    // Do a forced write of our code version. This ensures that the code
    // version is part of the binary, so we can look at a binary and figure
    // out which version of SymCrypt it was linked with.
    //
    SYMCRYPT_FORCE_WRITE32( &tmp, SYMCRYPT_API_VERSION );
 
    //
    // Force the build string to be in memory, because otherwise the
    // compiler might get smart and remove it.
    // This ensures we can always track back to the SymCrypt source code from
    // any binary that links this library
    //
    for( p = SymCryptBuildString; *p!=0; p++ )
    {
        SYMCRYPT_FORCE_WRITE8( (PBYTE) &tmp, *p );
    }
 
    //
    // Make an inverted copy of the CPU detection results.
    // This helps us diagnose corruption of our flags
    // Force-write otherwise the compiler optimizes it away
    //
    SYMCRYPT_FORCE_WRITE32( &g_SymCryptCpuFeaturesPresentCheck, ~g_SymCryptCpuFeaturesNotPresent );
 
    //
    // Test that the C and assembler code agree on the various structure member offsets.
    // This gets optimized away in FRE builds as all the values are compile-time computable.
    //
#define SYMCRYPT_CHECK_ASM_OFFSET( a, b ) if( (a) != (b) ) {SymCryptFatal( b );}
    SYMCRYPT_CHECK_ASM_OFFSETS;
#undef SYMCRYPT_CHECK_ASM_OFFSET
}

Referenced by SymCryptInitEnvWindowsUsermodeWin8_1nLater().

◆ SymCryptInjectError()

VOID SYMCRYPT_CALL SymCryptInjectError	(	PBYTE	pbData,
		SIZE_T	cbData
	)

◆ SymCryptInverseMod2e64()

UINT64 SymCryptInverseMod2e64 ( UINT64 m )

Definition at line 932 of file fdef_general.c.

{
    // Compute the inv64 value such that inv64 * m = 1 mod 2^64 for odd m.
    // If m is even, there exists no inverse, this function will return a
    // useless value in constant time.
    //
    // We use Newton's method to search for a zero of f(x) := x^-1 - m, working modulo 2^64
    // We get the iteration formula
    //  x_{i+1} = x_i - f(x_i)/f'(x_i)
    //          = x_i - (x_i^-1 - m)/(-x_i^-2)
    //          = x_i + x_i^2(1/x_i - m)
    //          = x_i + x_i - (x_i^2 * m)
    //          = x_i (2 - x_i*m)
    //
    // Let x_i = d + 2^n * e where d = inv64 = m^-1 mod 2^64, and 2^n * e is the error term that is zero in the n least
    // significant bits. We have
    //  x_{i+1} = (d + 2^n * e) (2 - (d + 2^n * e) * m)
    //          = (d + 2^n * e) (2 - d*m - 2^n * e * m)
    //          = (d + 2^n * e) (2 - 1 - 2^n * e * m)
    //          = (d + 2^n * e) (1 - 2^n * e * m)
    //          = d - (2^n * e * (d*m)) + (2^n * e) - (2^{2n} * e^2 * m)
    //          = d - (2^{2n} * e^2 * m)
    // In other words, the error has been squared and multiplied by m. In our case, working modulo 2^64, the number of correct bits
    // on the least significant side is doubled.
    //
    // To get a 4-bit correct estimate for m^-1 given odd m, we consider the least significant 4 bits of m and inv:
    // m   = ... m_3 m_2 m_1 m_0
    // inv = ... i_3 i_2 i_1 i_0
    // We want to directly compute i_[3..0] s.t. (m*inv) & 0xf == 1
    // working through some simple simultaneous equations it is easily shown that:
    // i_0 = m_0 = 1
    // i_1 = m_1
    // i_2 = m_2
    // i_3 = m_1 ^ m_2 ^ m_3
    // Once we have 4 correct bits, we can double that multiple times using Newton's method.
    //
    // We use 32-bit operations for most of the iterations for speed on 32-bit platforms.
    //
    UINT32 inv32;
    UINT64 inv64;
    UINT32 m32;
 
    m32 = (UINT32)m;
 
    inv32 = m32 ^ (((m32 - 1) * 0x6) & 0x8); // sets inv32 bits [3..0]
    SYMCRYPT_ASSERT( ((m&1) == 0) || (((inv32 * m32) & 0xf) == 1) );
 
    inv32 = inv32 * (2 - inv32 * m32 );
    SYMCRYPT_ASSERT( ((m&1) == 0) || (((inv32 * m32) & 0xff) == 1) );
 
    inv32 = inv32 * (2 - inv32 * m32 );
    SYMCRYPT_ASSERT( ((m&1) == 0) || (((inv32 * m32) & 0xffff) == 1) );
 
    inv32 = inv32 * (2 - inv32 * m32 );
    SYMCRYPT_ASSERT( ((m&1) == 0) || ((inv32 * m32) == 1) );
 
    inv64 = inv32;
    inv64 = inv64 * (2 - inv64 * m );
    SYMCRYPT_ASSERT( ((m&1) == 0) || ((inv64 * m) == 1) );
 
    return inv64;
}

Referenced by SymCryptFdefInitTrialdivisionPrime(), and SymCryptFdefIntToModulus().

◆ SymCryptKeccakAppend()

VOID SYMCRYPT_CALL SymCryptKeccakAppend	(	_Inout_ PSYMCRYPT_KECCAK_STATE	pState,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 285 of file sha3.c.

{
    SYMCRYPT_ASSERT(pState->inputBlockSize % 8 == 0);
 
    // If we were in squeeze mode (Append is called after an Extract without wiping),
    // switch to absorb mode to start a new hash computation.
    if (pState->squeezeMode)
    {
        SymCryptKeccakReset(pState);
    }
 
    SYMCRYPT_ASSERT(pState->stateIndex < pState->inputBlockSize);
 
    // Make pState->stateIndex a multiple of 8.
    // Message block boundary will not be crossed, check
    // if permutation is needed after this part.
    while (cbData > 0 && (pState->stateIndex & 0x7))
    {
        SymCryptKeccakAppendByte(pState, *pbData);
        pbData++;
        cbData--;
    }
 
    // Permute if input message block is filled
    if (pState->stateIndex == pState->inputBlockSize)
    {
        SymCryptKeccakPermute(pState->state);
        pState->stateIndex = 0;
    }
 
    // Append full lanes
    SIZE_T uFullLanes = cbData / sizeof(UINT64);
    if (uFullLanes > 0)
    {
        SymCryptKeccakAppendLanes(pState, pbData, uFullLanes);
        pbData += uFullLanes * sizeof(UINT64);
        cbData -= uFullLanes * sizeof(UINT64);
    }
 
    SYMCRYPT_ASSERT(cbData < sizeof(UINT64));
    SymCryptKeccakAppendBytes(pState, pbData, cbData);
 
    SYMCRYPT_ASSERT(pState->stateIndex != pState->inputBlockSize);
}

Referenced by SYMCRYPT_XxxAppend(), SymCryptKeccakAppendEncodedString(), SymCryptKeccakAppendEncodeTimes8(), SymCryptSha3_224Append(), SymCryptSha3_256Append(), SymCryptSha3_384Append(), and SymCryptSha3_512Append().

◆ SymCryptKeccakAppendEncodedString()

VOID SYMCRYPT_CALL SymCryptKeccakAppendEncodedString	(	_Inout_ PSYMCRYPT_KECCAK_STATE	pState,
		_In_reads_(cbString) PCBYTE	pbString,
		SIZE_T	cbString
	)

Definition at line 330 of file shake.c.

{
    SymCryptKeccakAppendEncodeTimes8(pState, cbString, TRUE);
    SymCryptKeccakAppend(pState, pbString, cbString);
}

Referenced by SYMCRYPT_XxxExpandKeyEx(), and SymCryptCShakeEncodeInputStrings().

◆ SymCryptKeccakAppendEncodeTimes8()

VOID SYMCRYPT_CALL SymCryptKeccakAppendEncodeTimes8	(	_Inout_ SYMCRYPT_KECCAK_STATE *	pState,
		UINT64	uValue,
		BOOLEAN	bLeftEncode
	)

Definition at line 310 of file shake.c.

{
    BYTE encoding[1 + (1 + sizeof(UINT64))];
    SIZE_T ret;
 
    ret = SymCryptKeccakEncodeTimes8(uValue, encoding, sizeof(encoding), bLeftEncode);
 
    SymCryptKeccakAppend(pState, encoding, ret);
}

Referenced by SYMCRYPT_XxxExpandKeyEx(), SYMCRYPT_XxxExtract(), SYMCRYPT_XxxResultEx(), SymCryptCShakeEncodeInputStrings(), and SymCryptKeccakAppendEncodedString().

◆ SymCryptKeccakExtract()

VOID SYMCRYPT_CALL SymCryptKeccakExtract	(	_Inout_ PSYMCRYPT_KECCAK_STATE	pState,
		_Out_writes_(cbResult) PBYTE	pbResult,
		SIZE_T	cbResult,
		BOOLEAN	bWipe
	)

Definition at line 411 of file sha3.c.

{
    // Apply padding and switch to squeeze mode if this is the first call to Extract
    if (!pState->squeezeMode)
    {
        SymCryptKeccakApplyPadding(pState);
    }
 
    // Do the permutation if there are no bytes available in the state
    if ( (cbResult > 0) && (pState->stateIndex == pState->inputBlockSize) )
    {
        SymCryptKeccakPermute(pState->state);
        pState->stateIndex= 0;
    }
 
    // Make stateIndex a multiple of 8 so that the extraction can be performed in lanes.
    // We don't call the permutation as soon as the stateIndex reaches inputBlockSize,
    // cbResult must also be non-zero for that. This condition is checked
    // in ExtractLanes or in the 'remaining bytes' block that follows it.
    while (cbResult > 0 && (pState->stateIndex & 0x7))
    {
        *pbResult = SymCryptKeccakExtractByte(pState);
        pbResult++;
        cbResult--;
    }
 
    SYMCRYPT_ASSERT((cbResult == 0) || ((pState->stateIndex & 0x7) == 0));
 
    // Extract full lanes
    SIZE_T uFullLanes = cbResult / sizeof(UINT64);
    if (uFullLanes > 0)
    {
        SymCryptKeccakExtractLanes(pState, pbResult, uFullLanes);
        pbResult += uFullLanes * sizeof(UINT64);
        cbResult -= uFullLanes * sizeof(UINT64);
    }
 
    // Extract the remaining bytes
    SYMCRYPT_ASSERT(cbResult < sizeof(UINT64));
    while (cbResult > 0)
    {
        if (pState->stateIndex == pState->inputBlockSize)
        {
            SymCryptKeccakPermute(pState->state);
            pState->stateIndex = 0;
        }
 
        *pbResult = SymCryptKeccakExtractByte(pState);
        pbResult++;
        cbResult--;
    }
 
    if (bWipe)
    {
        // Wipe the Keccak state and make it ready for a new hash computation
        SymCryptKeccakReset(pState);
    }
}

Referenced by SYMCRYPT_XxxExtract(), SYMCRYPT_XxxResult(), SYMCRYPT_XxxResultEx(), SymCryptSha3_224Result(), SymCryptSha3_256Result(), SymCryptSha3_384Result(), and SymCryptSha3_512Result().

◆ SymCryptKeccakInit()

VOID SYMCRYPT_CALL SymCryptKeccakInit	(	_Out_ PSYMCRYPT_KECCAK_STATE	pState,
		UINT32	inputBlockSize,
		UINT8	padding
	)

Definition at line 174 of file sha3.c.

{
    pState->inputBlockSize = inputBlockSize;
    pState->paddingValue = paddingValue;
 
    // Initialize the Keccak permutation state and set mutable state variables
    // to their default values.
    SymCryptKeccakReset(pState);
}

Referenced by SYMCRYPT_XxxInit(), SymCryptSha3_224Init(), SymCryptSha3_256Init(), SymCryptSha3_384Init(), and SymCryptSha3_512Init().

◆ SymCryptKeccakPermute()

VOID SYMCRYPT_CALL SymCryptKeccakPermute ( _Inout_updates_(25) UINT64 * pState )

Definition at line 160 of file sha3.c.

{
    for (int r = 0; r < 24; r++)
    {
        KECCAK_PERM_ROUND(pState, r);
    }
}

Referenced by SymCryptKeccakAppend(), SymCryptKeccakAppendLanes(), SymCryptKeccakApplyPadding(), SymCryptKeccakExtract(), SymCryptKeccakExtractLanes(), and SymCryptKeccakZeroAppendBlock().

◆ SymCryptKeccakReset()

VOID SYMCRYPT_CALL SymCryptKeccakReset ( _Out_ PSYMCRYPT_KECCAK_STATE pState )

Definition at line 186 of file sha3.c.

{
    //
    // Wipe & re-initialize
    //
    // Wipe the Keccak permutation state and set the mutable state variables to their
    // default values. Non-mutable state variables retain their values. State becomes
    // re-initialized after this call.
    SymCryptWipeKnownSize(pState->state, sizeof(pState->state));
    pState->stateIndex = 0;
    pState->squeezeMode = FALSE;
}

Referenced by SymCryptKeccakAppend(), SymCryptKeccakExtract(), and SymCryptKeccakInit().

◆ SymCryptKeccakStateExport()

VOID SYMCRYPT_CALL SymCryptKeccakStateExport	(	SYMCRYPT_BLOB_TYPE	type,
		_In_ PCSYMCRYPT_KECCAK_STATE	pState,
		_Out_writes_bytes_(SYMCRYPT_KECCAK_STATE_EXPORT_SIZE) PBYTE	pbBlob
	)

Definition at line 479 of file sha3.c.

{
 
    SYMCRYPT_ALIGN SYMCRYPT_KECCAK_STATE_EXPORT_BLOB    blob;           // local copy to have proper alignment.
    C_ASSERT(sizeof(blob) == SYMCRYPT_KECCAK_STATE_EXPORT_SIZE);
 
    SymCryptWipeKnownSize(&blob, sizeof(blob)); // wipe to avoid any data leakage
 
    blob.header.magic = SYMCRYPT_BLOB_MAGIC;
    blob.header.size = SYMCRYPT_KECCAK_STATE_EXPORT_SIZE;
    blob.header.type = type;
 
    //
    // Copy the relevant data. Buffer will be 0-padded.
    //
 
    SymCryptUint64ToLsbFirst(&pState->state[0], &blob.state[0], 25);
    blob.stateIndex = pState->stateIndex;
    blob.paddingValue = pState->paddingValue;
    blob.squeezeMode = pState->squeezeMode;
 
    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));
 
    SymCryptWipeKnownSize(&blob, sizeof(blob));
    return;
}

Referenced by SymCryptSha3_224StateExport(), SymCryptSha3_256StateExport(), SymCryptSha3_384StateExport(), and SymCryptSha3_512StateExport().

◆ SymCryptKeccakStateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKeccakStateImport	(	SYMCRYPT_BLOB_TYPE	type,
		_Out_ PSYMCRYPT_KECCAK_STATE	pState,
		_In_reads_bytes_(SYMCRYPT_KECCAK_STATE_EXPORT_SIZE) PCBYTE	pbBlob
	)

Definition at line 518 of file sha3.c.

{
    SYMCRYPT_ERROR                  scError = SYMCRYPT_NO_ERROR;
 
    SYMCRYPT_ALIGN SYMCRYPT_KECCAK_STATE_EXPORT_BLOB blob;                       // local copy to have proper alignment.
    BYTE checksum[8];
 
    C_ASSERT(sizeof(blob) == SYMCRYPT_KECCAK_STATE_EXPORT_SIZE);
    memcpy(&blob, pbBlob, sizeof(blob));
 
    if (blob.header.magic != SYMCRYPT_BLOB_MAGIC ||
        blob.header.size != SYMCRYPT_KECCAK_STATE_EXPORT_SIZE ||
        blob.header.type != (UINT32)type)
    {
        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;
    }
 
    SymCryptLsbFirstToUint64(&blob.state[0], &pState->state[0], 25);
    pState->stateIndex = blob.stateIndex;
    pState->paddingValue = blob.paddingValue;
    pState->squeezeMode = blob.squeezeMode;
 
    //
    // Set state fields based on the blob type and do validation
    //
 
    // default values indicate error
    pState->inputBlockSize = 0;
    pState->paddingValue = 0;
 
    switch (blob.header.type)
    {
        case SymCryptBlobTypeSha3_224State:
            pState->inputBlockSize = SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE;
            if (blob.paddingValue == SYMCRYPT_SHA3_PADDING_VALUE)
            {
                pState->paddingValue = blob.paddingValue;
            }
            break;
        case SymCryptBlobTypeSha3_256State:
            pState->inputBlockSize = SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE;
            if (blob.paddingValue == SYMCRYPT_SHA3_PADDING_VALUE)
            {
                pState->paddingValue = blob.paddingValue;
            }
            break;
 
        case SymCryptBlobTypeSha3_384State:
            pState->inputBlockSize = SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE;
            if (blob.paddingValue == SYMCRYPT_SHA3_PADDING_VALUE)
            {
                pState->paddingValue = blob.paddingValue;
            }
            break;
 
        case SymCryptBlobTypeSha3_512State:
            pState->inputBlockSize = SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE;
            if (blob.paddingValue == SYMCRYPT_SHA3_PADDING_VALUE)
            {
                pState->paddingValue = blob.paddingValue;
            }
            break;
        default:
            scError = SYMCRYPT_INVALID_BLOB;
            goto cleanup;
    }
 
    if (pState->inputBlockSize == 0 || pState->paddingValue == 0)
    {
        scError = SYMCRYPT_INVALID_BLOB;
        goto cleanup;
    }
 
    if (pState->stateIndex > pState->inputBlockSize)
    {
        scError = SYMCRYPT_INVALID_BLOB;
        goto cleanup;
    }
 
    // Allow stateIndex = inputBlockSize only in squeeze mode
    if ((pState->stateIndex == pState->inputBlockSize) && !pState->squeezeMode)
    {
        scError = SYMCRYPT_INVALID_BLOB;
        goto cleanup;
    }
 
cleanup:
    SymCryptWipeKnownSize(&blob, sizeof(blob));
 
    return scError;
}

Referenced by SymCryptSha3_224StateImport(), SymCryptSha3_256StateImport(), SymCryptSha3_384StateImport(), and SymCryptSha3_512StateImport().

◆ SymCryptKeccakZeroAppendBlock()

VOID SYMCRYPT_CALL SymCryptKeccakZeroAppendBlock ( _Inout_ PSYMCRYPT_KECCAK_STATE pState )

Definition at line 273 of file sha3.c.

{
    SYMCRYPT_ASSERT(!pState->squeezeMode);
    SymCryptKeccakPermute(pState->state);
    pState->stateIndex = 0;
}

Referenced by SYMCRYPT_XxxExpandKeyEx(), and SymCryptCShakeEncodeInputStrings().

◆ SymCryptLmsVerifyInternal()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsVerifyInternal	(	_In_ PCSYMCRYPT_LMS_KEY	pKey,
		_In_reads_bytes_(cbMessage) PCBYTE	pbMessage,
		SIZE_T	cbMessage,
		UINT32	flags,
		_In_reads_bytes_(cbSignature) PCBYTE	pbSignature,
		SIZE_T	cbSignature
	)

Definition at line 1048 of file lms.c.

{
    SYMCRYPT_ASSERT(pKey != NULL);
    SYMCRYPT_ASSERT(pKey->keyType != SYMCRYPT_LMSKEY_TYPE_NONE);
    SYMCRYPT_CHECK_MAGIC(pKey);
 
    SYMCRYPT_ERROR          scError                                     = SYMCRYPT_NO_ERROR;
    UINT32                  cbHashOutput                                = pKey->params.cbHashOutput;
    PCSYMCRYPT_LMS_PARAMS   pLmsKeyParams                               = &pKey->params;
    PCBYTE                  pbLocSignature                              = pbSignature;
    BYTE                    abRootCandidate[SYMCRYPT_LMS_MAX_N]         = { 0 };
    BYTE                    abOtsPubKeyCandidate[SYMCRYPT_LMS_MAX_N]    = { 0 };
 
    if (flags != 0)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    if (cbSignature != SymCryptLmsSizeofSignatureFromParams(&pKey->params))
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    UINT32 nLeafNumber = SYMCRYPT_LOAD_MSBFIRST32(pbLocSignature);
    pbLocSignature += sizeof(UINT32);
    if (nLeafNumber >= ((UINT32)1 << pKey->params.nTreeHeight))
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    UINT32 nOtsSigtype = SYMCRYPT_LOAD_MSBFIRST32(pbLocSignature);
    pbLocSignature += sizeof(UINT32);
 
    if (nOtsSigtype != pLmsKeyParams->lmsOtsAlgID)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    pbLocSignature += cbHashOutput * (pKey->params.nByteStringCount + 1); // +1 is for the randomizer
    UINT32 nSigType = SYMCRYPT_LOAD_MSBFIRST32(pbLocSignature);
    pbLocSignature += sizeof(UINT32);
 
    if (nSigType != pLmsKeyParams->lmsAlgID)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    scError = LmsComputeOtsPubKeyCandidate(
        nLeafNumber,
        pbMessage,
        cbMessage,
        pbSignature + sizeof(UINT32), //the +sizeof(UINT32) is to skip the leaf number and reach the LMS-OTS signature
        LmsOtsSizeofSignatureFromParams(&pKey->params),
        pKey->abId,
        pLmsKeyParams,
        abOtsPubKeyCandidate);
    if (scError != SYMCRYPT_NO_ERROR)
    {
        goto cleanup;
    }
 
    LmsComputeRootCandidate(
        nLeafNumber,
        pLmsKeyParams,
        pKey->abId,
        pbLocSignature,
        abOtsPubKeyCandidate,
        abRootCandidate);
    if (!SymCryptEqual(abRootCandidate, pKey->abPublicRoot, cbHashOutput))
    {
        scError = SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE;
        goto cleanup;
    }
 
cleanup:
    return scError;
}

Referenced by SymCryptLmsVerify().

◆ SymCryptLsbFirstToUint32()

VOID SYMCRYPT_CALL SymCryptLsbFirstToUint32	(	_In_reads_(4 *cuResult) PCBYTE	pbData,
		_Out_writes_(cuResult) PUINT32	puResult,
		SIZE_T	cuResult
	)

Definition at line 487 of file sc_lib.h.

{
    while( cuResult != 0 )
    {
        *puResult = SYMCRYPT_LOAD_LSBFIRST32( pbData );
        pbData += 4;
        puResult++;
        cuResult--;
    }
}

Referenced by SymCryptChaCha20Init(), SymCryptMd4StateImport(), and SymCryptMd5StateImport().

◆ SymCryptLsbFirstToUint64()

FORCEINLINE VOID SYMCRYPT_CALL SymCryptLsbFirstToUint64	(	_In_reads_(8 *cuResult) PCBYTE	pbData,
		_Out_writes_(cuResult) PUINT64	puResult,
		SIZE_T	cuResult
	)

Definition at line 554 of file sc_lib.h.

{
    while( cuResult != 0 )
    {
        *puResult = SYMCRYPT_LOAD_LSBFIRST64( pbData );
        pbData += 8;
        puResult++;
        cuResult--;
    }
}

Referenced by SymCryptKeccakStateImport().

◆ SymCryptMarvin32AppendBlocks()

VOID SYMCRYPT_CALL SymCryptMarvin32AppendBlocks	(	_Inout_ PSYMCRYPT_MARVIN32_CHAINING_STATE	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData
	)

Definition at line 194 of file marvin32.c.

{
    UINT32 s0 = pChain->s[0];
    UINT32 s1 = pChain->s[1];
 
    SIZE_T bytesInFirstBlock = cbData & 0xc;        // 0, 4, 8, or 12
 
    SYMCRYPT_ASSERT( (cbData & 3) == 0 );
 
 
    pbData += bytesInFirstBlock;
    cbData -= bytesInFirstBlock;
 
    switch( bytesInFirstBlock )
    {
    case 0: // This handles the cbData == 0 case too
        while( cbData > 0 )
        {
            pbData += 16;
            cbData -= 16;
 
            s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData - 16 );
            BLOCK( s0, s1 );
    case 12:
            s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData - 12 );
            BLOCK( s0, s1 );
    case 8:
            s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData -  8 );
            BLOCK( s0, s1 );
    case 4:
            s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData -  4 );
            BLOCK( s0, s1 );
        }
    }
 
    pChain->s[0] = s0;
    pChain->s[1] = s1;
}

Referenced by SymCryptMarvin32Result().

◆ SymCryptMd2AppendBlocks()

VOID SYMCRYPT_CALL SymCryptMd2AppendBlocks	(	_Inout_ SYMCRYPT_MD2_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptMd4AppendBlocks()

VOID SYMCRYPT_CALL SymCryptMd4AppendBlocks	(	_Inout_ SYMCRYPT_MD4_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ 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 ) );
}

◆ SymCryptModExpGeneric()

VOID SYMCRYPT_CALL SymCryptModExpGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_ PCSYMCRYPT_MODELEMENT	peBase,
		_In_ PCSYMCRYPT_INT	piExp,
		UINT32	nBitsExp,
		UINT32	flags,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 217 of file modexp.c.

{
    if ( ((flags & SYMCRYPT_FLAG_DATA_PUBLIC)!=0) && (nBitsExp <= sizeof(UINT32)*8) )
    {
        SymCryptModExpSquareAndMultiply32( pmMod, peBase, piExp, peDst, pbScratch, cbScratch );
    }
    else
    {
        SymCryptModExpWindowed( pmMod, peBase, piExp, nBitsExp, peDst, pbScratch, cbScratch );  // This is the default
    }
}

Referenced by SymCryptModExp().

◆ SymCryptModMultiExpGeneric()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptModMultiExpGeneric	(	_In_ PCSYMCRYPT_MODULUS	pmMod,
		_In_reads_(nBases) PCSYMCRYPT_MODELEMENT *	peBaseArray,
		_In_reads_(nBases) PCSYMCRYPT_INT *	piExpArray,
		UINT32	nBases,
		UINT32	nBitsExp,
		UINT32	flags,
		_Out_ PSYMCRYPT_MODELEMENT	peDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 449 of file modexp.c.

{
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
 
    if ( (nBases > SYMCRYPT_MODMULTIEXP_MAX_NBASES) ||
         (nBitsExp > SYMCRYPT_MODMULTIEXP_MAX_NBITSEXP) )
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    if ((flags & SYMCRYPT_FLAG_DATA_PUBLIC)!=0)
    {
        SymCryptModMultiExpWnafWithInterleaving( pmMod, peBaseArray, piExpArray, nBases, nBitsExp, peDst, pbScratch, cbScratch );
    }
    else
    {
        UINT32 cbModElement = 0;
        PSYMCRYPT_MODELEMENT peTemp = NULL;
        PSYMCRYPT_MODELEMENT peAcc = NULL;
 
        // Use two temporary modelements to store the results
        // *** Make sure that the scratch space is enough i.e. the scratch space of ModMultiExp is
        //  at least 2 modelements bigger than the scratch space of ModExp
        cbModElement = SymCryptSizeofModElementFromModulus( pmMod );
 
        SYMCRYPT_ASSERT( SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP(SymCryptModulusDigitsizeOfObject(pmMod)) + 2*cbModElement <=
                         SYMCRYPT_SCRATCH_BYTES_FOR_MODMULTIEXP( SymCryptModulusDigitsizeOfObject(pmMod), nBases, nBitsExp ) );
        SYMCRYPT_ASSERT( cbScratch >= 2*cbModElement + SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP(SymCryptModulusDigitsizeOfObject(pmMod)) );
 
        peTemp = SymCryptModElementCreate( pbScratch, cbModElement, pmMod );
        pbScratch += cbModElement; cbScratch -= cbModElement;
 
        peAcc = SymCryptModElementCreate( pbScratch, cbModElement, pmMod );
        pbScratch += cbModElement; cbScratch -= cbModElement;
 
        // Set peAcc to 1
        SymCryptModElementSetValueUint32( 1, pmMod, peAcc, pbScratch, cbScratch );
 
        for (UINT32 i=0; i<nBases; i++)
        {
            SymCryptModExpWindowed( pmMod, peBaseArray[i], piExpArray[i], nBitsExp, peTemp, pbScratch, cbScratch );
 
            SymCryptModMul( pmMod, peAcc, peTemp, peAcc, pbScratch, cbScratch );
        }
 
        // Copy the result into the destination
        SymCryptModElementCopy( pmMod, peAcc, peDst );
    }
 
cleanup:
    return scError;
}

Referenced by SymCryptModMultiExp().

◆ SymCryptMontgomeryFillScratchSpaces()

VOID SYMCRYPT_CALL SymCryptMontgomeryFillScratchSpaces ( _In_ PSYMCRYPT_ECURVE pCurve )

Definition at line 11 of file ec_montgomery.c.

{
    UINT32 nDigits = SymCryptDigitsFromBits( pCurve->FModBitsize );
    UINT32 nBytes = SymCryptSizeofModElementFromModulus( pCurve->FMod );
    UINT32 nCommon = SYMCRYPT_MAX( SymCryptSizeofIntFromDigits( nDigits ), SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits ), SYMCRYPT_SCRATCH_BYTES_FOR_MODINV( nDigits ) ) );
    UINT32 cbModElement = pCurve->cbModElement;
    UINT32 nDigitsFieldLength = pCurve->FModDigits;
 
    //
    // All the scratch space computations are upper bounded by the SizeofXXX bound (2^19) and
    // the SCRATCH_BYTES_FOR_XXX bound (2^24) (see symcrypt_internal.h).
    //
    // One caveat is SymCryptSizeofEcpointFromCurve and SymCryptSizeofEcpointEx which calculate the
    // size of EcPoint with 4 coordinates (each one a modelement of max size 2^17). Thus upper
    // bounded by 2^20.
    //
 
    pCurve->cbScratchCommon = nCommon;
    pCurve->cbScratchScalar =
        SymCryptSizeofIntFromDigits(nDigits) +
        6 * nBytes +
        nCommon;
 
    pCurve->cbScratchScalarMulti = 0;
    pCurve->cbScratchGetSetValue =
        SymCryptSizeofEcpointEx( cbModElement, SYMCRYPT_ECPOINT_FORMAT_MAX_LENGTH ) +
        2 * cbModElement +
        SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigitsFieldLength ),
             SYMCRYPT_SCRATCH_BYTES_FOR_MODINV( nDigitsFieldLength ) );
 
    pCurve->cbScratchGetSetValue = SYMCRYPT_MAX( pCurve->cbScratchGetSetValue, SymCryptSizeofIntFromDigits( nDigits ) );
 
    pCurve->cbScratchEckey =
        SYMCRYPT_MAX( cbModElement + SymCryptSizeofIntFromDigits(SymCryptEcurveDigitsofScalarMultiplier(pCurve)),
            SymCryptSizeofEcpointFromCurve( pCurve ) ) +
        SYMCRYPT_MAX( pCurve->cbScratchScalar, pCurve->cbScratchGetSetValue );
}

◆ SymCryptMontgomeryIsEqual()

UINT32 SYMCRYPT_CALL SymCryptMontgomeryIsEqual	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 78 of file ec_montgomery.c.

{
    PSYMCRYPT_MODELEMENT  peTemp[2];
    PSYMCRYPT_MODELEMENT  peSrc1X, peSrc1Z;
    PSYMCRYPT_MODELEMENT  peSrc2X, peSrc2Z;
    PSYMCRYPT_MODULUS     pmMod = pCurve->FMod;
    SIZE_T nBytes;
 
    SYMCRYPT_ASSERT( (flags & ~(SYMCRYPT_FLAG_ECPOINT_EQUAL|SYMCRYPT_FLAG_ECPOINT_NEG_EQUAL)) == 0 );
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_MONTGOMERY_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc1->pCurve) && SymCryptEcurveIsSame(pCurve, poSrc2->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    UNREFERENCED_PARAMETER( flags );
 
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
 
    SYMCRYPT_ASSERT( cbScratch >= 2 * nBytes );
 
    for (UINT32 i = 0; i < 2; ++i)
    {
        peTemp[i] = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
        pbScratch += nBytes;
        cbScratch -= nBytes;
    }
 
    peSrc1X = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc1 );
    peSrc1Z = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc1 );
 
    peSrc2X = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc2 );
    peSrc2Z = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc2 );
 
    // peTemp[0] = X1 * Z2
    SymCryptModMul( pmMod, peSrc1X, peSrc2Z, peTemp[0], pbScratch, cbScratch );
 
    // peTemp[1] = X2 * Z1
    SymCryptModMul( pmMod, peSrc2X, peSrc1Z, peTemp[1], pbScratch, cbScratch );
 
    return SymCryptModElementIsEqual( pmMod, peTemp[0], peTemp[1] );
}

◆ SymCryptMontgomeryIsZero()

UINT32 SYMCRYPT_CALL SymCryptMontgomeryIsZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 128 of file ec_montgomery.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peZ = NULL;    // Pointer to Z
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_MONTGOMERY_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    // Getting pointer to Z of the source point
    peZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1,  pCurve, poSrc );
 
    return SymCryptModElementIsZero( FMod, peZ );
}

◆ SymCryptMontgomeryPointScalarMul()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMontgomeryPointScalarMul	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_INT	piScalar,
		_In_opt_ PCSYMCRYPT_ECPOINT	poSrc,
		UINT32	flags,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 297 of file ec_montgomery.c.

{
    SYMCRYPT_ERROR        scError = SYMCRYPT_NO_ERROR;
 
    PSYMCRYPT_MODULUS     pmMod;
    PSYMCRYPT_MODELEMENT  peX1, peZ1, peA24, peX2, peZ2, peX3, peZ3, peTemp1, peTemp2, peResult;
    UINT32                i, nBytes, nDigits, cond, newcond, nCommon;
    PBYTE                 pBegin;
    SIZE_T                cbAllScratch;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_MONTGOMERY_TYPE(pCurve) );
    SYMCRYPT_ASSERT( (poSrc == NULL || SymCryptEcurveIsSame(pCurve, poSrc->pCurve)) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
 
    // Make sure we only specify the correct flags
    if ((flags & ~SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL) != 0)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    if (poSrc == NULL)
    {
        poSrc = pCurve->G;
    }
 
    //
    // Set up structure for X2, Z2, X3, Z3, Temp1, and Temp2, and the scratch space.
    //
    pmMod = pCurve->FMod;
 
    nDigits = SymCryptDigitsFromBits( pCurve->FModBitsize );
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
    nCommon = SYMCRYPT_MAX( SymCryptSizeofIntFromDigits(nDigits), SYMCRYPT_MAX(SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(nDigits), SYMCRYPT_SCRATCH_BYTES_FOR_MODINV(nDigits)));
 
    SYMCRYPT_ASSERT( cbScratch >= 6 * nBytes + nCommon );
 
    cbAllScratch = cbScratch;
    pBegin = pbScratch;
 
    //
    // Create mod elements
    //
    peX2 = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
 
    peZ2 = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
 
    peX3 = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
 
    peZ3 = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
 
    peTemp1 = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
 
    peTemp2 = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
    pbScratch += nBytes;
 
    cbScratch = nCommon;
 
    //
    // Set up values
    //
 
    peA24 = pCurve->A;
 
    // X1 = X, Z1 = Z
    peX1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc);
    peZ1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc);
 
    // X2 = 1, Z2 = 0, X3 = X, Z3 = Z
    SymCryptModElementSetValueUint32( 1, pmMod, peX2, pbScratch, cbScratch );
    SymCryptModElementSetValueUint32( 0, pmMod, peZ2, pbScratch, cbScratch );
    SymCryptModElementCopy( pmMod, peX1, peX3 );
    SymCryptModElementCopy( pmMod, peZ1, peZ3 );
 
    if ( poSrc->normalized )
    {
        // Set peZ1 to NULL to avoid redundant multiplications in SymCryptMontgomeryDoubleAndAdd
        peZ1 = NULL;
    }
 
    //
    //  Montgomery ladder scalar multiplication
    //
 
    i = (pCurve->GOrdBitsize + pCurve->coFactorPower);
    cond = 0;
    while ( i != 0 )
    {
        // If cond = 0, we have (X2, Z2, X3, Z3)
        // if cond = 1, we have (X3, Z3, X2, Z2)
        i--;
        newcond = SymCryptIntGetBit( piScalar, i );
        cond ^= newcond;
 
        SymCryptModElementConditionalSwap( pmMod, peX2, peX3, cond);
        SymCryptModElementConditionalSwap( pmMod, peZ2, peZ3, cond);
 
        cond = newcond;
 
        SymCryptMontgomeryDoubleAndAdd( pmMod, peX1, peZ1, peA24, peX2, peZ2, peX3, peZ3, peTemp1, peTemp2, pbScratch, cbScratch );
    }
 
    // Now put them back in the normal order
    SymCryptModElementConditionalSwap( pmMod, peX2, peX3, cond);
    SymCryptModElementConditionalSwap( pmMod, peZ2, peZ3, cond);
 
    // Multiply by the cofactor (if needed) by continuing the doubling
    if ((flags & SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL) != 0)
    {
        i = pCurve->coFactorPower;
        while (i!=0)
        {
            i--;
            // We only use the doubling output here, so we definitely don't need to provide Z1
            // We could refactor to have a separate SymCryptMontgomeryDouble function but for Curve25519 this loop is ~1% of runtime
            SymCryptMontgomeryDoubleAndAdd( pmMod, peX1, NULL, peA24, peX2, peZ2, peX3, peZ3, peTemp1, peTemp2, pbScratch, cbScratch );
        }
    }
 
    // Set X coordinate
    peResult = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst);
    SymCryptModElementCopy( pCurve->FMod, peX2, peResult );
 
    // Set Z coordinate
    peResult = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst);
    SymCryptModElementCopy( pCurve->FMod, peZ2, peResult );
 
    poDst->normalized = FALSE;
 
    scError = SYMCRYPT_NO_ERROR;
 
cleanup:
    return scError;
}

◆ SymCryptMontgomerySetDistinguished()

VOID SYMCRYPT_CALL SymCryptMontgomerySetDistinguished	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 51 of file ec_montgomery.c.

{
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_MONTGOMERY_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    SymCryptEcpointCopy( pCurve, pCurve->G, poDst );
}

◆ SymCryptMsbFirstToUint32()

VOID SYMCRYPT_CALL SymCryptMsbFirstToUint32	(	_In_reads_(4 *cuResult) PCBYTE	pbData,
		_Out_writes_(cuResult) PUINT32	puResult,
		SIZE_T	cuResult
	)

Definition at line 422 of file sc_lib.h.

{
    while( cuResult != 0 )
    {
        *puResult = SYMCRYPT_LOAD_MSBFIRST32( pbData );
        puResult++;
        pbData += 4;
        cuResult--;
    }
}

Referenced by SymCryptSha1StateImport(), and SymCryptSha256StateImportCore().

◆ SymCryptMsbFirstToUint64()

VOID SYMCRYPT_CALL SymCryptMsbFirstToUint64	(	_In_reads_(8 *cuResult) PCBYTE	pbData,
		_Out_writes_(cuResult) PUINT64	puResult,
		SIZE_T	cuResult
	)

Definition at line 592 of file sc_lib.h.

{
    while( cuResult != 0 )
    {
        *puResult = SYMCRYPT_LOAD_MSBFIRST64( pbData );
        puResult++;
        pbData += 8;
        cuResult--;
    }
}

Referenced by SymCryptSha512StateImportCore().

◆ SymCryptOfflinePrecomputation()

VOID SYMCRYPT_CALL SymCryptOfflinePrecomputation	(	_In_ PSYMCRYPT_ECURVE	pCurve,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 55 of file ec_mul.c.

{
    PSYMCRYPT_ECPOINT poQ = NULL;
 
    UINT32 cbEcpoint = SymCryptSizeofEcpointFromCurve( pCurve );
 
    SYMCRYPT_ASSERT( cbScratch >= cbEcpoint + SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) );
 
    poQ = SymCryptEcpointCreate( pbScratch, cbEcpoint, pCurve );
    SYMCRYPT_ASSERT( poQ != NULL );
    pbScratch += cbEcpoint;
    cbScratch -= cbEcpoint;
 
    SymCryptPrecomputation(
                pCurve,
                pCurve->info.sw.nPrecompPoints,
                pCurve->info.sw.poPrecompPoints,
                poQ,
                pbScratch,
                cbScratch );
}

Referenced by SymCryptEcurveInitialize().

◆ SymCryptParallelHashProcess()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelHashProcess	(	_In_ PCSYMCRYPT_PARALLEL_HASH	pParHash,
		_Inout_updates_bytes_(nStates *pParHash->pHash->stateSize) PVOID	pStates,
		SIZE_T	nStates,
		_Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION	pOperations,
		SIZE_T	nOperations,
		_Out_writes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch,
		UINT32	maxParallel
	)

◆ SymCryptParallelHashProcess_serial()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelHashProcess_serial	(	_In_ PCSYMCRYPT_PARALLEL_HASH	pParHash,
		_Inout_updates_bytes_(nStates *pParHash->pHash->stateSize) PVOID	pStates,
		SIZE_T	nStates,
		_Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION	pOperations,
		SIZE_T	nOperations,
		_Out_writes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

◆ SymCryptParallelSha256AppendBlocks_ymm()

VOID SYMCRYPT_CALL SymCryptParallelSha256AppendBlocks_ymm	(	_Inout_updates_(8) PSYMCRYPT_SHA256_CHAINING_STATE *	pChain,
		_Inout_updates_(8) PCBYTE *	ppByte,
		SIZE_T	nBytes,
		_Out_writes_(PAR_SCRATCH_ELEMENTS_256 *32) PBYTE	pScratch
	)

◆ SymCryptParallelSha512AppendBlocks_ymm()

VOID SYMCRYPT_CALL SymCryptParallelSha512AppendBlocks_ymm	(	_Inout_updates_(4) PSYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_Inout_updates_(4) PCBYTE *	ppByte,
		SIZE_T	nBytes,
		_Out_writes_(PAR_SCRATCH_ELEMENTS_512 *32) PBYTE	pScratch
	)

◆ SymCryptPositiveWidthNafRecoding()

VOID SYMCRYPT_CALL SymCryptPositiveWidthNafRecoding	(	UINT32	W,
		_In_ PCSYMCRYPT_INT	piK,
		UINT32	nBitsExp,
		_Out_writes_(nRecodedDigits) PUINT32	absofKIs,
		UINT32	nRecodedDigits
	)

Definition at line 180 of file recoding.c.

{
    UINT32 T1 = 0;
    UINT32 cntrZ = W;       // Counter that specifies when we filled the last non-zero NAF digit
 
    SYMCRYPT_ASSERT( nRecodedDigits <= SymCryptIntBitsizeOfObject( piK ) );
 
    for (UINT32 i=0; i < nRecodedDigits; i++)
    {
        T1 = SymCryptIntGetBits( piK, i, SYMCRYPT_MIN(W, nBitsExp-i) );   // Get a batch of W bits (but don't go over nBitsExp)
 
        if ((cntrZ>=W) && ((T1 & 0x01) > 0))    // Only store odd digits
        {
            absofKIs[i] = T1;
            cntrZ = 0;
        }
        else
        {
            absofKIs[i] = 0;
        }
 
        cntrZ++;        // Prepare the counter for the next iteration
    }
}

Referenced by SymCryptModMultiExpWnafWithInterleaving().

◆ SymCryptRsaSignVerifyPct()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaSignVerifyPct ( PCSYMCRYPT_RSAKEY pkRsakey )

Definition at line 51 of file implglue.c.

{
    return SYMCRYPT_NO_ERROR;
}

Referenced by SymCryptRsakeyGenerate().

◆ SymCryptSha1AppendBlocks()

VOID SYMCRYPT_CALL SymCryptSha1AppendBlocks	(	_Inout_ SYMCRYPT_SHA1_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Definition at line 230 of file sha1.c.

{
 
    SYMCRYPT_ALIGN UINT32 W[16];
    UINT32 A, B, C, D, E;
    UINT32 Wt;
 
    A = pChain->H[0];
    B = pChain->H[1];
    C = pChain->H[2];
    D = pChain->H[3];
    E = pChain->H[4];
 
    while( cbData >= 64 )
    {
        //
        // initial rounds 1 to 16
        //
 
        IROUND(  A, B, C, D, E,  0, CH );
        IROUND(  E, A, B, C, D,  1, CH );
        IROUND(  D, E, A, B, C,  2, CH );
        IROUND(  C, D, E, A, B,  3, CH );
        IROUND(  B, C, D, E, A,  4, CH );
        IROUND(  A, B, C, D, E,  5, CH );
        IROUND(  E, A, B, C, D,  6, CH );
        IROUND(  D, E, A, B, C,  7, CH );
        IROUND(  C, D, E, A, B,  8, CH );
        IROUND(  B, C, D, E, A,  9, CH );
        IROUND(  A, B, C, D, E, 10, CH );
        IROUND(  E, A, B, C, D, 11, CH );
        IROUND(  D, E, A, B, C, 12, CH );
        IROUND(  C, D, E, A, B, 13, CH );
        IROUND(  B, C, D, E, A, 14, CH );
        IROUND(  A, B, C, D, E, 15, CH );
 
        //
        // Full rounds (including msg expansion) from here on
        //
        FROUND(  E, A, B, C, D, 16, CH );
        FROUND(  D, E, A, B, C, 17, CH );
        FROUND(  C, D, E, A, B, 18, CH );
        FROUND(  B, C, D, E, A, 19, CH );
 
 
        FROUND(  A, B, C, D, E, 20, PARITY );
        FROUND(  E, A, B, C, D, 21, PARITY );
        FROUND(  D, E, A, B, C, 22, PARITY );
        FROUND(  C, D, E, A, B, 23, PARITY );
        FROUND(  B, C, D, E, A, 24, PARITY );
        FROUND(  A, B, C, D, E, 25, PARITY );
        FROUND(  E, A, B, C, D, 26, PARITY );
        FROUND(  D, E, A, B, C, 27, PARITY );
        FROUND(  C, D, E, A, B, 28, PARITY );
        FROUND(  B, C, D, E, A, 29, PARITY );
        FROUND(  A, B, C, D, E, 30, PARITY );
        FROUND(  E, A, B, C, D, 31, PARITY );
        FROUND(  D, E, A, B, C, 32, PARITY );
        FROUND(  C, D, E, A, B, 33, PARITY );
        FROUND(  B, C, D, E, A, 34, PARITY );
        FROUND(  A, B, C, D, E, 35, PARITY );
        FROUND(  E, A, B, C, D, 36, PARITY );
        FROUND(  D, E, A, B, C, 37, PARITY );
        FROUND(  C, D, E, A, B, 38, PARITY );
        FROUND(  B, C, D, E, A, 39, PARITY );
 
 
        FROUND(  A, B, C, D, E, 40, MAJ );
        FROUND(  E, A, B, C, D, 41, MAJ );
        FROUND(  D, E, A, B, C, 42, MAJ );
        FROUND(  C, D, E, A, B, 43, MAJ );
        FROUND(  B, C, D, E, A, 44, MAJ );
        FROUND(  A, B, C, D, E, 45, MAJ );
        FROUND(  E, A, B, C, D, 46, MAJ );
        FROUND(  D, E, A, B, C, 47, MAJ );
        FROUND(  C, D, E, A, B, 48, MAJ );
        FROUND(  B, C, D, E, A, 49, MAJ );
        FROUND(  A, B, C, D, E, 50, MAJ );
        FROUND(  E, A, B, C, D, 51, MAJ );
        FROUND(  D, E, A, B, C, 52, MAJ );
        FROUND(  C, D, E, A, B, 53, MAJ );
        FROUND(  B, C, D, E, A, 54, MAJ );
        FROUND(  A, B, C, D, E, 55, MAJ );
        FROUND(  E, A, B, C, D, 56, MAJ );
        FROUND(  D, E, A, B, C, 57, MAJ );
        FROUND(  C, D, E, A, B, 58, MAJ );
        FROUND(  B, C, D, E, A, 59, MAJ );
 
        FROUND(  A, B, C, D, E, 60, PARITY );
        FROUND(  E, A, B, C, D, 61, PARITY );
        FROUND(  D, E, A, B, C, 62, PARITY );
        FROUND(  C, D, E, A, B, 63, PARITY );
        FROUND(  B, C, D, E, A, 64, PARITY );
        FROUND(  A, B, C, D, E, 65, PARITY );
        FROUND(  E, A, B, C, D, 66, PARITY );
        FROUND(  D, E, A, B, C, 67, PARITY );
        FROUND(  C, D, E, A, B, 68, PARITY );
        FROUND(  B, C, D, E, A, 69, PARITY );
        FROUND(  A, B, C, D, E, 70, PARITY );
        FROUND(  E, A, B, C, D, 71, PARITY );
        FROUND(  D, E, A, B, C, 72, PARITY );
        FROUND(  C, D, E, A, B, 73, PARITY );
        FROUND(  B, C, D, E, A, 74, PARITY );
        FROUND(  A, B, C, D, E, 75, PARITY );
        FROUND(  E, A, B, C, D, 76, PARITY );
        FROUND(  D, E, A, B, C, 77, PARITY );
        FROUND(  C, D, E, A, B, 78, PARITY );
        FROUND(  B, C, D, E, A, 79, PARITY );
 
 
        pChain->H[0] = A = A + pChain->H[0];
        pChain->H[1] = B = B + pChain->H[1];
        pChain->H[2] = C = C + pChain->H[2];
        pChain->H[3] = D = D + pChain->H[3];
        pChain->H[4] = E = E + pChain->H[4];
 
        pbData += 64;
        cbData -= 64;
    }
 
    *pcbRemaining = cbData;
 
    //
    // Wipe the variables;
    //
    SymCryptWipeKnownSize( W, sizeof( W ) );
    SYMCRYPT_FORCE_WRITE32( &A, 0 );
    SYMCRYPT_FORCE_WRITE32( &B, 0 );
    SYMCRYPT_FORCE_WRITE32( &C, 0 );
    SYMCRYPT_FORCE_WRITE32( &D, 0 );
    SYMCRYPT_FORCE_WRITE32( &E, 0 );
    SYMCRYPT_FORCE_WRITE32( &Wt, 0 );
}

Referenced by SymCryptSha1Result().

◆ SymCryptSha256AppendBlocks()

VOID SYMCRYPT_CALL SymCryptSha256AppendBlocks	(	_Inout_ SYMCRYPT_SHA256_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Definition at line 1812 of file sha256.c.

{
#if SYMCRYPT_CPU_AMD64
 
    SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
 
    if (SYMCRYPT_CPU_FEATURES_PRESENT(SYMCRYPT_CPU_FEATURES_FOR_SHANI_CODE) &&
        SymCryptSaveXmm(&SaveData) == SYMCRYPT_NO_ERROR)
    {
        SymCryptSha256AppendBlocks_shani(pChain, pbData, cbData, pcbRemaining);
 
        SymCryptRestoreXmm(&SaveData);
    }
    // Temporarily disabling use of Ymm in SHA2
    // else if (SYMCRYPT_CPU_FEATURES_PRESENT(SYMCRYPT_CPU_FEATURE_AVX2 | SYMCRYPT_CPU_FEATURE_BMI2) &&
    //         SymCryptSaveYmm(&SaveData) == SYMCRYPT_NO_ERROR)
    // {
    //     //SymCryptSha256AppendBlocks_ul1(pChain, pbData, cbData, pcbRemaining);
    //     //SymCryptSha256AppendBlocks_ymm_8blocks(pChain, pbData, cbData, pcbRemaining);
    //     SymCryptSha256AppendBlocks_ymm_avx2_asm(pChain, pbData, cbData, pcbRemaining);
 
    //     SymCryptRestoreYmm(&SaveData);
    // }
    else if (SYMCRYPT_CPU_FEATURES_PRESENT(SYMCRYPT_CPU_FEATURE_SSSE3 | SYMCRYPT_CPU_FEATURE_BMI2) &&
            SymCryptSaveXmm(&SaveData) == SYMCRYPT_NO_ERROR)
    {
        //SymCryptSha256AppendBlocks_xmm_4blocks(pChain, pbData, cbData, pcbRemaining);
        SymCryptSha256AppendBlocks_xmm_ssse3_asm(pChain, pbData, cbData, pcbRemaining);
 
        SymCryptRestoreXmm(&SaveData);
    }
    else
    {
       SymCryptSha256AppendBlocks_ul1( pChain, pbData, cbData, pcbRemaining );
       //SymCryptSha256AppendBlocks_ul2(pChain, pbData, cbData, pcbRemaining);
    }
#elif SYMCRYPT_CPU_X86
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_SHANI_CODE | SYMCRYPT_CPU_FEATURE_SAVEXMM_NOFAIL ) &&
        SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptSha256AppendBlocks_shani( pChain, pbData, cbData, pcbRemaining );
        SymCryptRestoreXmm( &SaveData );
    }
    else if (SYMCRYPT_CPU_FEATURES_PRESENT(SYMCRYPT_CPU_FEATURE_SSSE3 | SYMCRYPT_CPU_FEATURE_BMI2)
            && SymCryptSaveXmm(&SaveData) == SYMCRYPT_NO_ERROR)
    {
        SymCryptSha256AppendBlocks_xmm_4blocks(pChain, pbData, cbData, pcbRemaining);
        SymCryptRestoreXmm(&SaveData);
    }
    else {
        SymCryptSha256AppendBlocks_ul1( pChain, pbData, cbData, pcbRemaining );
    }
#elif SYMCRYPT_CPU_ARM64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_SHA256 ) )
    {
        SymCryptSha256AppendBlocks_instr( pChain, pbData, cbData, pcbRemaining );
    } else {
        SymCryptSha256AppendBlocks_ul1( pChain, pbData, cbData, pcbRemaining );
    }
#else
    SymCryptSha256AppendBlocks_ul1( pChain, pbData, cbData, pcbRemaining );
#endif
 
    //SymCryptSha256AppendBlocks_ul2( pChain, pbData, cbData, pcbRemaining );
    //SymCryptSha256AppendBlocks_xmm1( pChain, pbData, cbData, pcbRemaining );  !!! Needs Save/restore logic
    //SymCryptSha256AppendBlocks_xmm2( pChain, pbData, cbData, pcbRemaining );
}

Referenced by SymCryptSha256Append(), and SymCryptSha256Result().

◆ SymCryptSha256AppendBlocks_xmm_4blocks()

VOID SYMCRYPT_CALL SymCryptSha256AppendBlocks_xmm_4blocks	(	_Inout_ SYMCRYPT_SHA256_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Referenced by SymCryptSha256AppendBlocks().

◆ SymCryptSha256AppendBlocks_xmm_ssse3_asm()

VOID SYMCRYPT_CALL SymCryptSha256AppendBlocks_xmm_ssse3_asm	(	_Inout_ SYMCRYPT_SHA256_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Referenced by SymCryptSha256AppendBlocks().

◆ SymCryptSha256AppendBlocks_ymm_8blocks()

VOID SYMCRYPT_CALL SymCryptSha256AppendBlocks_ymm_8blocks	(	_Inout_ SYMCRYPT_SHA256_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptSha256AppendBlocks_ymm_avx2_asm()

VOID SYMCRYPT_CALL SymCryptSha256AppendBlocks_ymm_avx2_asm	(	_Inout_ SYMCRYPT_SHA256_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptSha512AppendBlocks()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Definition at line 1643 of file sha512.c.

{
#if SYMCRYPT_CPU_AMD64
 
    // Temporarily disabling use of Ymm in SHA2
    // SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
 
    // if (SYMCRYPT_CPU_FEATURES_PRESENT(SYMCRYPT_CPU_FEATURE_AVX512 | SYMCRYPT_CPU_FEATURE_BMI2) &&
    //     SymCryptSaveYmm(&SaveData) == SYMCRYPT_NO_ERROR)
    // {
    //     SymCryptSha512AppendBlocks_ymm_avx512vl_asm(pChain, pbData, cbData, pcbRemaining);
 
    //     SymCryptRestoreYmm(&SaveData);
    // }
    // else if (SYMCRYPT_CPU_FEATURES_PRESENT(SYMCRYPT_CPU_FEATURE_AVX2 | SYMCRYPT_CPU_FEATURE_BMI2) &&
    //     SymCryptSaveYmm(&SaveData) == SYMCRYPT_NO_ERROR)
    // {
    //     //SymCryptSha512AppendBlocks_ymm_1block(pChain, pbData, cbData, pcbRemaining);
    //     //SymCryptSha512AppendBlocks_ymm_2blocks(pChain, pbData, cbData, pcbRemaining);
    //     //SymCryptSha512AppendBlocks_ymm_4blocks(pChain, pbData, cbData, pcbRemaining);
    //     SymCryptSha512AppendBlocks_ymm_avx2_asm(pChain, pbData, cbData, pcbRemaining);
 
    //     SymCryptRestoreYmm(&SaveData);
    // }
    // else
    {
        SymCryptSha512AppendBlocks_ull( pChain, pbData, cbData, pcbRemaining );
        //SymCryptSha512AppendBlocks_ull2( pChain, pbData, cbData, pcbRemaining );
        //SymCryptSha512AppendBlocks_ull3( pChain, pbData, cbData, pcbRemaining );
    }
 
 
#elif SYMCRYPT_CPU_ARM
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON ) )
    {
        SymCryptSha512AppendBlocks_neon( pChain, pbData, cbData, pcbRemaining );      // Tegra T3: 48 c/B
    } else {
        SymCryptSha512AppendBlocks_ull( pChain, pbData, cbData, pcbRemaining );       // Tegra T3: 65.34 c/B
        //SymCryptSha512AppendBlocks_ull2( pChain, pbData, cbData, pcbRemaining );      // Tegra T3: 77.4 c/B
        //SymCryptSha512AppendBlocks_ull3( pChain, pbData, cbData, pcbRemaining );      // Tegra T3: 71.6 c/B
    }
 
#elif SYMCRYPT_CPU_X86
 
    SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_SSSE3 ) && SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
    {
        SymCryptSha512AppendBlocks_xmm( pChain, pbData, cbData, pcbRemaining );
        SymCryptRestoreXmm( &SaveData );
    } else {
        SymCryptSha512AppendBlocks_ull( pChain, pbData, cbData, pcbRemaining );       // core2: 36.40 c/B
        //SymCryptSha512AppendBlocks_ull2( pChain, pbData, cbData, pcbRemaining );      // core2: 49.09 c/B
        //SymCryptSha512AppendBlocks_ull3( pChain, pbData, cbData, pcbRemaining );      // core2: 38.29 c/B
    }
 
#else
 
    SymCryptSha512AppendBlocks_ull( pChain, pbData, cbData, pcbRemaining );       // need tuning...
 
#endif
}

Referenced by SymCryptSha512Append(), and SymCryptSha512Result().

◆ SymCryptSha512AppendBlocks_xmm()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks_xmm	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

Referenced by SymCryptSha512AppendBlocks().

◆ SymCryptSha512AppendBlocks_ymm_1block()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks_ymm_1block	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptSha512AppendBlocks_ymm_2blocks()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks_ymm_2blocks	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptSha512AppendBlocks_ymm_4blocks()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks_ymm_4blocks	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptSha512AppendBlocks_ymm_avx2_asm()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks_ymm_avx2_asm	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptSha512AppendBlocks_ymm_avx512vl_asm()

VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks_ymm_avx512vl_asm	(	_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *	pChain,
		_In_reads_(cbData) PCBYTE	pbData,
		SIZE_T	cbData,
		_Out_ SIZE_T *	pcbRemaining
	)

◆ SymCryptShortWeierstrassAdd()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassAdd	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 843 of file ec_short_weierstrass.c.

{
    UINT32 dSrc1Zero = 0;
    UINT32 dSrc2Zero = 0;
    UINT32 dSrcEqual = 0;
 
    // Temporary points
    PSYMCRYPT_ECPOINT   poQ0 = NULL;
    PSYMCRYPT_ECPOINT   poQ1 = NULL;
 
    SIZE_T cbEcpoint = SymCryptSizeofEcpointFromCurve( pCurve );
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc1->pCurve) && SymCryptEcurveIsSame(pCurve, poSrc2->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );     // We will need the entire scratch space
 
    SYMCRYPT_ASSERT( cbScratch > 2*cbEcpoint );
 
    if ((flags & SYMCRYPT_FLAG_DATA_PUBLIC) != 0)
    {
        SymCryptShortWeierstrassAddSideChannelUnsafe( pCurve, poSrc1, poSrc2, poDst, pbScratch, cbScratch );
    }
    else
    {
        // Creating temporary points
        poQ0 = SymCryptEcpointCreate( pbScratch, cbEcpoint, pCurve );
        SYMCRYPT_ASSERT( poQ0 != NULL);
        pbScratch += cbEcpoint;
 
        poQ1 = SymCryptEcpointCreate( pbScratch, cbEcpoint, pCurve );
        SYMCRYPT_ASSERT( poQ1 != NULL);
        pbScratch += cbEcpoint;
 
        // Fixing remaining scratch space size
        cbScratch -= 2*cbEcpoint;
 
        // Calculate the masks
        dSrc1Zero = SymCryptShortWeierstrassIsZero( pCurve, poSrc1, pbScratch, cbScratch );
        dSrc2Zero = SymCryptShortWeierstrassIsZero( pCurve, poSrc2, pbScratch, cbScratch );
        dSrcEqual = SymCryptShortWeierstrassIsEqual( pCurve, poSrc1, poSrc2, SYMCRYPT_FLAG_ECPOINT_EQUAL, pbScratch, cbScratch );
 
        // Side-channel safe computations
        SymCryptShortWeierstrassAddDiffNonZero( pCurve, poSrc1, poSrc2, poQ0, pbScratch, cbScratch );   // This covers the cases where Src1 != Src2 or Src1 = -Src2
 
        SymCryptEcpointDouble( pCurve, poSrc1, poQ1, 0, pbScratch, cbScratch );     // Dispatch to Double function; enables type assertion on SymCryptShortWeierstrassDouble to be specific
        SymCryptEcpointMaskedCopy( pCurve, poQ1, poQ0, dSrcEqual );                                     // (Masked) copy if the points are equal
 
        SymCryptEcpointMaskedCopy( pCurve, poSrc1, poQ0, dSrc2Zero );                                   // (Masked) copy if Src2 = 0
        SymCryptEcpointMaskedCopy( pCurve, poSrc2, poQ0, dSrc1Zero );                                   // (Masked) copy if Src1 = 0
 
        SymCryptEcpointCopy( pCurve, poQ0, poDst );                                 // Copy the final result to destination
    }
}

◆ SymCryptShortWeierstrassAddDiffNonZero()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassAddDiffNonZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 603 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
 
    PCSYMCRYPT_MODELEMENT peX1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc1 );
    PCSYMCRYPT_MODELEMENT peY1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc1 );
    PCSYMCRYPT_MODELEMENT peZ1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc1 );
 
    PCSYMCRYPT_MODELEMENT peX2 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc2 );
    PCSYMCRYPT_MODELEMENT peY2 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc2 );
    PCSYMCRYPT_MODELEMENT peZ2 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc2 );
 
    PSYMCRYPT_MODELEMENT  peX3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
    PSYMCRYPT_MODELEMENT  peY3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
    PSYMCRYPT_MODELEMENT  peZ3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
 
    PSYMCRYPT_MODELEMENT peT[7] = { 0 };  // Temporaries
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc1->pCurve) && SymCryptEcurveIsSame(pCurve, poSrc2->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + 7 * pCurve->cbModElement );
 
    // Creating temporaries
    for (UINT32 i=0; i<7; i++)
    {
        peT[i] = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
 
        SYMCRYPT_ASSERT( peT[i] != NULL);
 
        pbScratch += pCurve->cbModElement;
    }
 
    // Fixing remaining scratch space size
    cbScratch -= 7*pCurve->cbModElement;
 
    // Calculation
 
    SymCryptModSquare( FMod, peZ1, peT[0], pbScratch, cbScratch );          /* T0 := Z1 * Z1 = Z1Z1 */
    SymCryptModMul( FMod, peZ1, peT[0], peT[1], pbScratch, cbScratch );     /* T1 := Z1*Z1Z1 */
 
    SymCryptModSquare( FMod, peZ2, peT[6], pbScratch, cbScratch );          /* T6 := Z2 * Z2 = Z2Z2 */
    SymCryptModMul( FMod, peX1, peT[6], peT[2], pbScratch, cbScratch );     /* T2 := X1 * T6 = X1*Z2Z2 = U1 */
    SymCryptModMul( FMod, peX2, peT[0], peT[3], pbScratch, cbScratch );     /* T3 := X2 * Z1Z1 = U2 */
    SymCryptModSub( FMod, peT[3], peT[2], peT[5], pbScratch, cbScratch );   /* T5 := T3 - T2 = U2 - U1 = H */
    SymCryptModAdd( FMod, peT[5], peT[5], peT[3], pbScratch, cbScratch );   /* T3 := T5 + T5 = 2H */
 
    SymCryptModMul( FMod, peZ1, peZ2, peT[4], pbScratch, cbScratch );       /* T4 := Z1 * Z2 */
 
    SymCryptModMul( FMod, peZ2, peT[6], peT[6], pbScratch, cbScratch );     /* T6 := Z2 * T6 = Z2*Z2Z2 */
    SymCryptModMul( FMod, peT[4], peT[3], peZ3, pbScratch, cbScratch );     /* Z3 := T4 * T3 = Z1*Z2*2H */
 
    SymCryptModMul( FMod, peY1, peT[6], peT[6], pbScratch, cbScratch );     /* T6 := Y1 * T6 = Y1*Z2*Z2Z2 = S1 */
    SymCryptModMul( FMod, peY2, peT[1], peT[4], pbScratch, cbScratch );     /* T4 := Y2*Z1*Z1Z1 = S2 */
    SymCryptModSub( FMod, peT[4], peT[6], peT[4], pbScratch, cbScratch );   /* T4 := T4 - T6 = S2-S1 */
    SymCryptModAdd( FMod, peT[4], peT[4], peT[4], pbScratch, cbScratch );   /* T4 := T4 + T4 = 2*(S2-S1) = r */
 
    SymCryptModSquare( FMod, peT[3], peT[3], pbScratch, cbScratch );        /* T3 := T3 * T3 = (2*H)^2 = I */
    SymCryptModMul( FMod, peT[3], peT[5], peT[5], pbScratch, cbScratch );   /* T5 := T3 * T5 = H*I = J */
    SymCryptModMul( FMod, peT[2], peT[3], peT[3], pbScratch, cbScratch );   /* T3 := T2 * T3 = U1*I = V */
 
    SymCryptModSquare( FMod, peT[4], peT[2], pbScratch, cbScratch );        /* T2 := T4 * T4 = r^2 */
    SymCryptModSub( FMod, peT[2], peT[5], peT[2], pbScratch, cbScratch );   /* T2 := T2 - T5 = r^2 - J */
    SymCryptModSub( FMod, peT[2], peT[3], peT[2], pbScratch, cbScratch );   /* T2 := T2 - T3 = r^2 - J - V */
    SymCryptModSub( FMod, peT[2], peT[3], peX3, pbScratch, cbScratch );     /* T2 := T2 - T3 = r^2 - J - 2*V = X3 */
 
    SymCryptModSub( FMod, peT[3], peX3, peT[3], pbScratch, cbScratch );     /* T3 := T3 - T2 = V - X3 */
    SymCryptModMul( FMod, peT[3], peT[4], peT[3], pbScratch, cbScratch );   /* T3 := T3 * T4 = r*(V-X3) */
    SymCryptModMul( FMod, peT[6], peT[5], peT[6], pbScratch, cbScratch );   /* T6 := T6 * T5 = S1*J */
    SymCryptModAdd( FMod, peT[6], peT[6], peT[6], pbScratch, cbScratch );   /* T6 := T6 + T6 = 2*S1*J */
    SymCryptModSub( FMod, peT[3], peT[6], peY3, pbScratch, cbScratch );     /* Y3 := T6 - T3 = r*(V-X3) - 2*S1*J */
}

Referenced by SymCryptShortWeierstrassAdd().

◆ SymCryptShortWeierstrassDouble()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassDouble	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 391 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peT[3] = { 0 };    // Temporaries
 
    PCSYMCRYPT_MODELEMENT peX1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc );
    PCSYMCRYPT_MODELEMENT peY1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc );
    PCSYMCRYPT_MODELEMENT peZ1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    PSYMCRYPT_MODELEMENT  peX3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
    PSYMCRYPT_MODELEMENT  peY3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
    PSYMCRYPT_MODELEMENT  peZ3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
 
    SYMCRYPT_ASSERT( pCurve->type == SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + 3 * pCurve->cbModElement );
 
    UNREFERENCED_PARAMETER( flags );
 
    // Creating temporaries
    for (UINT32 i=0; i<3; i++)
    {
        peT[i] = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
 
        SYMCRYPT_ASSERT( peT[i] != NULL);
 
        pbScratch += pCurve->cbModElement;
    }
 
    // Fixing remaining scratch space size
    cbScratch -= 3*pCurve->cbModElement;
 
    // Calculate the points
    SymCryptModAdd( FMod, peY1, peY1, peT[0], pbScratch, cbScratch );           /* T0 := Y1 + Y1 = 2Y */
    SymCryptModSquare( FMod, peZ1, peT[1], pbScratch, cbScratch );              /* T1 := Z1 * Z1 = ZZ */
    SymCryptModMul( FMod, peT[0], peZ1, peZ3, pbScratch, cbScratch );           /* Z3 := 2Y * Z1 = 2YZ */
 
    SymCryptModMul( FMod, peY1, peT[0], peY3, pbScratch, cbScratch );           /* Y3 := 2Y * Y1 = 2YY */
    SymCryptModAdd( FMod, peY3, peY3, peT[0], pbScratch, cbScratch );           /* T0 := 2YY + 2YY = 4YY */
    SymCryptModMul( FMod, peT[0], peY3, peY3, pbScratch, cbScratch );           /* Y3 := 2YY * 4YY = 8YYYY */
 
    SymCryptModMul( FMod, peT[0], peX1, peT[0], pbScratch, cbScratch );         /* T0 := X1 * 4YY = 4XYY = S */
 
    SymCryptModSquare( FMod, peT[1], peT[1], pbScratch, cbScratch );            /* T1 := T1 * T1 = ZZZZ */
    SymCryptModSquare( FMod, peX1, peT[2], pbScratch, cbScratch );              /* T2 := X1 * X1 = XX */
    SymCryptModMul( FMod, peT[1], pCurve->A, peT[1], pbScratch, cbScratch );    /* T1 := T1 * a  = a*ZZZZ */
    SymCryptModAdd( FMod, peT[2], peT[1], peT[1], pbScratch, cbScratch );       /* T1 := T2 + T1 = XX + a*ZZZZ */
    SymCryptModAdd( FMod, peT[2], peT[2], peT[2], pbScratch, cbScratch );       /* T2 := T2 + T2 = 2*XX */
    SymCryptModAdd( FMod, peT[0], peT[0], peX3, pbScratch, cbScratch );         /* X3 := 2*S */
    SymCryptModAdd( FMod, peT[2], peT[1], peT[1], pbScratch, cbScratch );       /* T1 := T2 + T1 = 3*XX + a*ZZZZ = M */
 
    SymCryptModSquare( FMod, peT[1], peT[2], pbScratch, cbScratch );            /* T2 := M^2 */
    SymCryptModSub( FMod, peT[2], peX3, peX3, pbScratch, cbScratch );           /* X3 := M^2 - 2*S = T */
 
    SymCryptModSub( FMod, peT[0], peX3, peT[0], pbScratch, cbScratch );         /* T0 := S - T */
    SymCryptModMul( FMod, peT[1], peT[0], peT[0], pbScratch, cbScratch );       /* T0 := M * (S - T) */
    SymCryptModSub( FMod, peT[0], peY3, peY3, pbScratch, cbScratch );           /* Y3 := M * (S - T) - 8*YYYY */
}

◆ SymCryptShortWeierstrassDoubleSpecializedAm3()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassDoubleSpecializedAm3	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 499 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peT[3] = { 0 };    // Temporaries
 
    PCSYMCRYPT_MODELEMENT peX1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc );
    PCSYMCRYPT_MODELEMENT peY1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc );
    PCSYMCRYPT_MODELEMENT peZ1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    PSYMCRYPT_MODELEMENT  peX3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
    PSYMCRYPT_MODELEMENT  peY3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
    PSYMCRYPT_MODELEMENT  peZ3 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
 
    SYMCRYPT_ASSERT( pCurve->type == SYMCRYPT_INTERNAL_ECURVE_TYPE_SHORT_WEIERSTRASS_AM3 );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + 3 * pCurve->cbModElement );
 
    UNREFERENCED_PARAMETER( flags );
 
    // Creating temporaries
    for (UINT32 i=0; i<3; i++)
    {
        peT[i] = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
 
        SYMCRYPT_ASSERT( peT[i] != NULL);
 
        pbScratch += pCurve->cbModElement;
    }
 
    // Fixing remaining scratch space size
    cbScratch -= 3*pCurve->cbModElement;
 
    // Calculate the points
    SymCryptModAdd( FMod, peY1, peY1, peT[0], pbScratch, cbScratch );       /* T0 := Y1 + Y1 = 2Y */
    SymCryptModSquare( FMod, peZ1, peT[1], pbScratch, cbScratch );          /* T1 := Z1 * Z1 = ZZ */
    SymCryptModMul( FMod, peY1, peT[0], peY3, pbScratch, cbScratch );       /* Y3 := 2Y * Y1 = 2YY */
 
    SymCryptModMul( FMod, peT[0], peZ1, peZ3, pbScratch, cbScratch );       /* Z3 := 2Y * Z1 = 2YZ */
 
    SymCryptModAdd( FMod, peY3, peY3, peT[0], pbScratch, cbScratch );       /* T0 := 2YY + 2YY = 4YY */
    SymCryptModAdd( FMod, peX1, peT[1], peT[2], pbScratch, cbScratch );     /* T2 := X1 + ZZ */
    SymCryptModMul( FMod, peT[0], peY3, peY3, pbScratch, cbScratch );       /* Y3 := 2YY * 4YY = 8YYYY */
 
    SymCryptModSub( FMod, peX1, peT[1], peT[1], pbScratch, cbScratch );     /* T1 := X1 - ZZ */
    SymCryptModMul( FMod, peT[0], peX1, peT[0], pbScratch, cbScratch );     /* T0 := X1 * 4YY = 4XYY = S */
 
    SymCryptModMul( FMod, peT[2], peT[1], peT[2], pbScratch, cbScratch );   /* T2 := (X1 + ZZ)*(X1 - ZZ) = XX - ZZZZ */
    SymCryptModAdd( FMod, peT[2], peT[2], peT[1], pbScratch, cbScratch );   /* T1 := 2*(XX - ZZZZ) */
    SymCryptModAdd( FMod, peT[0], peT[0], peX3, pbScratch, cbScratch );     /* X3 := 2*S */
    SymCryptModAdd( FMod, peT[1], peT[2], peT[1], pbScratch, cbScratch );   /* T1 := 3*(XX - ZZZZ) = M */
 
    SymCryptModSquare( FMod, peT[1], peT[2], pbScratch, cbScratch );        /* T2 := M^2 */
    SymCryptModSub( FMod, peT[2], peX3, peX3, pbScratch, cbScratch );       /* X3 := M^2 - 2*S = T */
 
    SymCryptModSub( FMod, peT[0], peX3, peT[0], pbScratch, cbScratch );     /* T0 := S - T */
    SymCryptModMul( FMod, peT[1], peT[0], peT[0], pbScratch, cbScratch );   /* T0 := M * (S - T) */
    SymCryptModSub( FMod, peT[0], peY3, peY3, pbScratch, cbScratch );       /* Y3 := M * (S - T) - 8*YYYY */
}

◆ SymCryptShortWeierstrassFillScratchSpaces()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassFillScratchSpaces ( _In_ PSYMCRYPT_ECURVE pCurve )

Definition at line 62 of file ec_short_weierstrass.c.

{
    UINT32 nDigits = SymCryptDigitsFromBits( pCurve->FModBitsize );
 
    //
    // All the scratch space computations are upper bounded by the SizeofXXX bound (2^19) and
    // the SCRATCH_BYTES_FOR_XXX bound (2^24) (see symcrypt_internal.h).
    //
    // One caveat is SymCryptSizeofEcpointFromCurve and SymCryptSizeofEcpointEx which calculate
    // the size of EcPoint with 4 coordinates (each one a modelement of max size 2^17). Thus upper
    // bounded by 2^20.
    //
    // Another is the precomp points computation where the nPrecompPoints are up to
    // 2^SYMCRYPT_ECURVE_SW_DEF_WINDOW = 2^6 and the nRecodedDigits are equal to the
    // GOrd bitsize < 2^20.
    //
    // Thus cbScratchScalarMulti is upper bounded by 2^6*2^20 + 2*2^20*2^4 ~ 2^26.
    //
 
    // Common
    pCurve->cbScratchCommon =
            8 * pCurve->cbModElement +
            2 * SymCryptSizeofEcpointFromCurve( pCurve ) +
            SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits );
 
    // Scalar (Overhead)
    pCurve->cbScratchScalar =
            pCurve->cbModElement +
            2 * SymCryptSizeofEcpointFromCurve( pCurve ) +
            2 * SymCryptSizeofIntFromDigits( pCurve->GOrdDigits ) +
            SYMCRYPT_MAX( pCurve->cbScratchCommon, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->GOrdDigits ));
 
    // Scalar dependent on precomp points (be careful to align the UINT32 arrays properly)
    pCurve->cbScratchScalarMulti =
            pCurve->info.sw.nPrecompPoints * SymCryptSizeofEcpointFromCurve( pCurve ) +
            ((2*pCurve->info.sw.nRecodedDigits * sizeof(UINT32) + SYMCRYPT_ASYM_ALIGN_VALUE - 1 )/SYMCRYPT_ASYM_ALIGN_VALUE) * SYMCRYPT_ASYM_ALIGN_VALUE;
 
    // GetSetValue
    pCurve->cbScratchGetSetValue =
            SymCryptSizeofEcpointEx( pCurve->cbModElement, SYMCRYPT_ECPOINT_FORMAT_MAX_LENGTH ) +
            2 * pCurve->cbModElement +
            SYMCRYPT_MAX(    SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ),
                    SYMCRYPT_SCRATCH_BYTES_FOR_MODINV( pCurve->FModDigits ) );
 
    pCurve->cbScratchGetSetValue = SYMCRYPT_MAX( pCurve->cbScratchGetSetValue, SymCryptSizeofIntFromDigits( nDigits ) );
 
    // Eckey
    pCurve->cbScratchEckey =
            SYMCRYPT_MAX( pCurve->cbModElement + SymCryptSizeofIntFromDigits(SymCryptEcurveDigitsofScalarMultiplier(pCurve)),
                SymCryptSizeofEcpointFromCurve( pCurve ) ) +
            SYMCRYPT_MAX( pCurve->cbScratchScalar + pCurve->cbScratchScalarMulti, pCurve->cbScratchGetSetValue );
}

◆ SymCryptShortWeierstrassIsEqual()

UINT32 SYMCRYPT_CALL SymCryptShortWeierstrassIsEqual	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 181 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
 
    PSYMCRYPT_MODELEMENT peX1 = NULL;    // Pointer to X1
    PSYMCRYPT_MODELEMENT peY1 = NULL;    // Pointer to Y1
    PSYMCRYPT_MODELEMENT peZ1 = NULL;    // Pointer to Z1
    PSYMCRYPT_MODELEMENT peX2 = NULL;    // Pointer to X2
    PSYMCRYPT_MODELEMENT peY2 = NULL;    // Pointer to Y2
    PSYMCRYPT_MODELEMENT peZ2 = NULL;    // Pointer to Z2
 
    UINT32  dResX = 0;
    UINT32  dResY = 0;
    UINT32  dResYN = 0;
 
    PSYMCRYPT_MODELEMENT peT[4] = { 0 };  // Temporaries
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc1->pCurve) && SymCryptEcurveIsSame(pCurve, poSrc2->pCurve) );
    SYMCRYPT_ASSERT( (flags & ~(SYMCRYPT_FLAG_ECPOINT_EQUAL|SYMCRYPT_FLAG_ECPOINT_NEG_EQUAL)) == 0 );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + 4 * pCurve->cbModElement );
 
    // Creating temporaries
    for (UINT32 i=0; i<4; i++)
    {
        peT[i] = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
 
        SYMCRYPT_ASSERT( peT[i] != NULL);
 
        pbScratch += pCurve->cbModElement;
    }
 
    // Fixing remaining scratch space size
    cbScratch -= 4 * pCurve->cbModElement;
 
    // Getting pointers to x and y of the source point
    peX1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc1 );
    peY1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc1 );
    peZ1 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc1 );
    peX2 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc2 );
    peY2 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc2 );
    peZ2 = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc2 );
 
    // Setting the default flag if flags == 0
    flags |= ( SYMCRYPT_MASK32_ZERO( flags ) & SYMCRYPT_FLAG_ECPOINT_EQUAL );
 
    // Calculation
    SymCryptModSquare( FMod, peZ1, peT[0], pbScratch, cbScratch );            // T0 := Z1 * Z1 = Z1^2
    SymCryptModSquare( FMod, peZ2, peT[1], pbScratch, cbScratch );            // T1 := Z2 * Z2 = Z2^2
    SymCryptModMul( FMod, peX1, peT[1], peT[2], pbScratch, cbScratch );       // T2 := X1 * T1 = X1*Z2^2
    SymCryptModMul( FMod, peX2, peT[0], peT[3], pbScratch, cbScratch );       // T3 := X2 * T0 = X2*Z1^2
 
    dResX = SymCryptModElementIsEqual( FMod, peT[2], peT[3] );
 
    SymCryptModMul( FMod, peZ1, peT[0], peT[0], pbScratch, cbScratch );       // T0 := Z1 * T0 = Z1^3
    SymCryptModMul( FMod, peZ2, peT[1], peT[1], pbScratch, cbScratch );       // T1 := Z2 * T1 = Z2^3
    SymCryptModMul( FMod, peY1, peT[1], peT[2], pbScratch, cbScratch );       // T2 := Y1 * T1 = Y1*Z2^3
    SymCryptModMul( FMod, peY2, peT[0], peT[3], pbScratch, cbScratch );       // T3 := Y2 * T0 = Y2*Z1^3
 
    dResY = SymCryptModElementIsEqual( FMod, peT[2], peT[3] );
 
    SymCryptModNeg( FMod, peT[3], peT[3], pbScratch, cbScratch );             // T3 := -T3 = -Y2*Z1^3
 
    dResYN = SymCryptModElementIsEqual( FMod, peT[2], peT[3] );
 
    return (SYMCRYPT_MASK32_NONZERO(flags & SYMCRYPT_FLAG_ECPOINT_EQUAL) & dResX & dResY) |
           (SYMCRYPT_MASK32_NONZERO(flags & SYMCRYPT_FLAG_ECPOINT_NEG_EQUAL) & dResX & dResYN);
}

Referenced by SymCryptShortWeierstrassAdd().

◆ SymCryptShortWeierstrassIsZero()

UINT32 SYMCRYPT_CALL SymCryptShortWeierstrassIsZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 262 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peZ = NULL;    // Pointer to Z
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    // Getting pointer to Z of the source point
    peZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    // Setting temporary to 0
    return SymCryptModElementIsZero( FMod, peZ );
}

Referenced by SymCryptShortWeierstrassAdd().

◆ SymCryptShortWeierstrassNegate()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassNegate	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Inout_ PSYMCRYPT_ECPOINT	poSrc,
		UINT32	mask,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 907 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc);
 
    PSYMCRYPT_MODELEMENT peTmp = NULL;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + pCurve->cbModElement);
 
    peTmp = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
    SYMCRYPT_ASSERT( peTmp != NULL);
 
    pbScratch += pCurve->cbModElement;
    cbScratch -= pCurve->cbModElement;
 
    SymCryptModNeg( FMod, peY, peTmp, pbScratch, cbScratch );
    SymCryptModElementMaskedCopy( FMod, peTmp, peY, mask );
}

◆ SymCryptShortWeierstrassOnCurve()

UINT32 SYMCRYPT_CALL SymCryptShortWeierstrassOnCurve	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 291 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
 
    PSYMCRYPT_MODELEMENT peX = NULL;    // Pointer to X
    PSYMCRYPT_MODELEMENT peY = NULL;    // Pointer to Y
    PSYMCRYPT_MODELEMENT peZ = NULL;    // Pointer to Z
 
    PSYMCRYPT_MODELEMENT peT[2] = { 0 }; // Temporaries
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + 2 * pCurve->cbModElement );
 
    // Creating temporaries
    for (UINT32 i=0; i<2; i++)
    {
        peT[i] = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
 
        SYMCRYPT_ASSERT( peT[i] != NULL);
 
        pbScratch += pCurve->cbModElement;
    }
 
    // Fixing remaining scratch space size
    cbScratch -= 2*pCurve->cbModElement;
 
    // Getting pointers to coordinates of the source point
    peX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc );
    peY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc );
    peZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    // Calculation
    SymCryptModSquare( FMod, peZ, peT[0], pbScratch, cbScratch );               // T1 := Z  * Z  = Z^2
    SymCryptModSquare( FMod, peT[0], peT[1], pbScratch, cbScratch );            // T2 := T1 * T1 = Z^4
    SymCryptModMul( FMod, peT[0], peT[1], peT[0], pbScratch, cbScratch );       // T1 := T1 * T2 = Z^6
 
    SymCryptModMul( FMod, peT[0], pCurve->B, peT[0], pbScratch, cbScratch );    // T1 := T1 * b  = bZ^6
 
    SymCryptModMul( FMod, peT[1], peX, peT[1], pbScratch, cbScratch );          // T2 := T2 * X  = XZ^4
    SymCryptModMul( FMod, peT[1], pCurve->A, peT[1], pbScratch, cbScratch );    // T2 := T2 * a  = aXZ^4
 
    SymCryptModAdd( FMod, peT[0], peT[1], peT[1], pbScratch, cbScratch );       // T2 := T1 + T2 = aXZ^4 + bZ^6
 
    SymCryptModSquare( FMod, peX, peT[0], pbScratch, cbScratch );               // T1 := X  * X  = X^2
    SymCryptModMul( FMod, peT[0], peX, peT[0], pbScratch, cbScratch );          // T1 := T1 * X  = X^3
    SymCryptModAdd( FMod, peT[0], peT[1], peT[1], pbScratch, cbScratch );       // T2 := T1 + T2 = X^3 + aXZ^4 + bZ^6
 
    SymCryptModSquare( FMod, peY, peT[0], pbScratch, cbScratch );               // T1 := Y  * Y  = Y^2
 
    return SymCryptModElementIsEqual( FMod, peT[0], peT[1] );
}

◆ SymCryptShortWeierstrassSetDistinguished()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassSetDistinguished	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 155 of file ec_short_weierstrass.c.

{
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    SymCryptEcpointCopy( pCurve, pCurve->G, poDst );
}

◆ SymCryptShortWeierstrassSetZero()

VOID SYMCRYPT_CALL SymCryptShortWeierstrassSetZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 120 of file ec_short_weierstrass.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peTmp = NULL;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_SHORT_WEIERSTRASS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) );
 
    // Getting handle to X
    peTmp = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
 
    // Setting the right value (always 1)
    SymCryptModElementSetValueUint32( 1, FMod, peTmp, pbScratch, cbScratch );
 
    // Getting handle to Y
    peTmp = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
 
    // Setting the right value (always 1)
    SymCryptModElementSetValueUint32( 1, FMod, peTmp, pbScratch, cbScratch );
 
    // Getting handle to Z
    peTmp = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
 
    // Setting the right value (always 0)
    SymCryptModElementSetValueUint32( 0, pCurve->FMod, peTmp, pbScratch, cbScratch );
}

◆ SymCryptSizeofEcpointEx()

UINT32 SYMCRYPT_CALL SymCryptSizeofEcpointEx	(	UINT32	cbModElement,
		UINT32	numOfCoordinates
	)

Definition at line 19 of file ecpoint.c.

{
    SYMCRYPT_ASSERT(numOfCoordinates > 0);
    SYMCRYPT_ASSERT(numOfCoordinates <= SYMCRYPT_ECPOINT_FORMAT_MAX_LENGTH);
 
    // Callers should never specify numOfCoordinates equal to 0 or greater than
    // SYMCRYPT_ECPOINT_FORMAT_MAX_LENGTH
    // Return 0 to indicate failure if a caller does specify invalid numOfCoordinates
    if( (numOfCoordinates == 0) || (numOfCoordinates > SYMCRYPT_ECPOINT_FORMAT_MAX_LENGTH) )
    {
        return 0;
    }
 
    // Since the maximum number of coordinates is 4 this result is bounded
    // by 4*2^17 + overhead ~ 2^20
    return sizeof(SYMCRYPT_ECPOINT) + numOfCoordinates * cbModElement;
}

Referenced by SymCryptEcpointCreateEx(), SymCryptEcpointGetValue(), SymCryptEcpointSetValue(), SymCryptEcurveValidateAndComputeSizes(), SymCryptMontgomeryFillScratchSpaces(), SymCryptShortWeierstrassFillScratchSpaces(), SymCryptSizeofEcpointFromCurve(), and SymCryptTwistedEdwardsFillScratchSpaces().

◆ SymCryptTwistedEdwardsAdd()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsAdd	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 313 of file ec_twisted_edwards.c.

{
    PSYMCRYPT_MODELEMENT  peTemp[8];
    PSYMCRYPT_MODULUS     pmMod = pCurve->FMod;
    SIZE_T nBytes;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc1->pCurve) && SymCryptEcurveIsSame(pCurve, poSrc2->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    UNREFERENCED_PARAMETER( flags );
 
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
 
    SYMCRYPT_ASSERT( cbScratch >= 8*nBytes );
 
    for (UINT32 i = 0; i < 8; ++i)
    {
       peTemp[i] = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
       pbScratch += nBytes;
       cbScratch -= nBytes;
    }
 
    PSYMCRYPT_MODELEMENT peSrc1X = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc1 );
    PSYMCRYPT_MODELEMENT peSrc1Y = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc1 );
    PSYMCRYPT_MODELEMENT peSrc1Z = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc1 );
    PSYMCRYPT_MODELEMENT peSrc1T = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 3, pCurve, poSrc1 );
 
    PSYMCRYPT_MODELEMENT peSrc2X = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc2 );
    PSYMCRYPT_MODELEMENT peSrc2Y = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc2 );
    PSYMCRYPT_MODELEMENT peSrc2Z = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc2 );
    PSYMCRYPT_MODELEMENT peSrc2T = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 3, pCurve, poSrc2 );
 
    PSYMCRYPT_MODELEMENT peDstX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstT = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 3, pCurve, poDst );
 
    PSYMCRYPT_MODELEMENT peA = peTemp[0];
    PSYMCRYPT_MODELEMENT peB = peTemp[1];
    PSYMCRYPT_MODELEMENT peC = peTemp[2];
    PSYMCRYPT_MODELEMENT peD = peTemp[3];
    PSYMCRYPT_MODELEMENT peE = peTemp[4];
    PSYMCRYPT_MODELEMENT peF = peTemp[5];
    PSYMCRYPT_MODELEMENT peG = peTemp[6];
    PSYMCRYPT_MODELEMENT peH = peTemp[7];
 
    // A = X1 * X2
    SymCryptModMul( pmMod, peSrc1X, peSrc2X, peA, pbScratch, cbScratch );
 
    // B = Y1 * Y2
    SymCryptModMul( pmMod, peSrc1Y, peSrc2Y, peB, pbScratch, cbScratch );
 
    // C1 = T1 * T2
    SymCryptModMul( pmMod, peSrc1T, peSrc2T, peC, pbScratch, cbScratch );
 
    // C = d * C1 = d * T1 * T2
    SymCryptModMul( pmMod, pCurve->B, peC, peC, pbScratch, cbScratch );
 
    // D = Z1 * Z2
    SymCryptModMul( pmMod, peSrc1Z, peSrc2Z, peD, pbScratch, cbScratch );
 
    // E1 = X1 + Y1
    SymCryptModAdd( pmMod, peSrc1X, peSrc1Y, peE, pbScratch, cbScratch );
 
    // E2 = X2 + Y2
    SymCryptModAdd( pmMod, peSrc2X, peSrc2Y, peF, pbScratch, cbScratch );
 
    // E = E * F
    SymCryptModMul( pmMod, peE, peF, peE, pbScratch, cbScratch );
 
    // E = E - A
    SymCryptModSub( pmMod, peE, peA, peE, pbScratch, cbScratch );
 
    // E = E - B
    SymCryptModSub( pmMod, peE, peB, peE, pbScratch, cbScratch );
 
    // F = D - C
    SymCryptModSub( pmMod, peD, peC, peF, pbScratch, cbScratch );
 
    // G = D + C
    SymCryptModAdd( pmMod, peD, peC, peG, pbScratch, cbScratch );
 
    // H = a * A
    SymCryptModMul( pmMod, pCurve->A, peA, peH, pbScratch, cbScratch );
 
    // H = B - a * A
    SymCryptModSub( pmMod, peB, peH, peH, pbScratch, cbScratch );
 
    // X3 = E * F
    SymCryptModMul( pmMod, peE, peF, peDstX, pbScratch, cbScratch );
 
    // Y3 = G * H
    SymCryptModMul( pmMod, peG, peH, peDstY, pbScratch, cbScratch );
 
    // T3 = E * H
    SymCryptModMul( pmMod, peE, peH, peDstT, pbScratch, cbScratch );
 
    // Y3 = F * G
    SymCryptModMul( pmMod, peF, peG, peDstZ, pbScratch, cbScratch );
}

Referenced by SymCryptTwistedEdwardsAddDiffNonZero().

◆ SymCryptTwistedEdwardsAddDiffNonZero()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsAddDiffNonZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 425 of file ec_twisted_edwards.c.

{
    SymCryptTwistedEdwardsAdd( pCurve, poSrc1, poSrc2, poDst, 0, pbScratch, cbScratch );
}

◆ SymCryptTwistedEdwardsDouble()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsDouble	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 195 of file ec_twisted_edwards.c.

{
    PSYMCRYPT_MODELEMENT  peTemp[8];
    PSYMCRYPT_MODULUS     pmMod = pCurve->FMod;
    SIZE_T nBytes;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) && SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    UNREFERENCED_PARAMETER( flags );
 
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
 
    SYMCRYPT_ASSERT( cbScratch >= 8*nBytes );
 
    for (UINT32 i = 0; i < 8; ++i)
    {
       peTemp[i] = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
       pbScratch += nBytes;
       cbScratch -= nBytes;
    }
 
    PSYMCRYPT_MODELEMENT peSrcX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc );
    PSYMCRYPT_MODELEMENT peSrcY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc );
    PSYMCRYPT_MODELEMENT peSrcZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    PSYMCRYPT_MODELEMENT peDstX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstT = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 3, pCurve, poDst );
 
    PSYMCRYPT_MODELEMENT peA = peTemp[0];
    PSYMCRYPT_MODELEMENT peB = peTemp[1];
    PSYMCRYPT_MODELEMENT peC = peTemp[2];
    PSYMCRYPT_MODELEMENT peD = peTemp[3];
    PSYMCRYPT_MODELEMENT peE = peTemp[4];
    PSYMCRYPT_MODELEMENT peF = peTemp[5];
    PSYMCRYPT_MODELEMENT peG = peTemp[6];
    PSYMCRYPT_MODELEMENT peH = peTemp[7];
 
 
    // A = X1^2
    SymCryptModSquare( pmMod, peSrcX, peA, pbScratch, cbScratch );
 
    // B = Y1^2
    SymCryptModSquare( pmMod, peSrcY, peB, pbScratch, cbScratch );
 
    // C1 = Z1^2
    SymCryptModSquare( pmMod, peSrcZ, peC, pbScratch, cbScratch );
 
    // C = C1 + C1 = Z1^2 + Z1^2 = 2 * Z1^2
    SymCryptModAdd( pmMod, peC, peC, peC, pbScratch, cbScratch );
 
    // D = a * A
    SymCryptModMul( pmMod, pCurve->A, peA, peD, pbScratch, cbScratch );
 
    // E1 = X1 + Y1
    SymCryptModAdd( pmMod, peSrcX, peSrcY, peE, pbScratch, cbScratch );
 
    // E2 = E1^2 = (X1 + Y1)^2
    SymCryptModSquare( pmMod, peE, peE, pbScratch, cbScratch );
 
    // E3 = E2 - A = (X1 + Y1)^2 - A
    SymCryptModSub( pmMod, peE, peA, peE, pbScratch, cbScratch );
 
    // E = E3 - B = (X1 + Y1)^2 - A - B
    SymCryptModSub( pmMod, peE, peB, peE, pbScratch, cbScratch );
 
    // G = D + B
    SymCryptModAdd( pmMod, peD, peB, peG, pbScratch, cbScratch );
 
    // F = G - C
    SymCryptModSub( pmMod, peG, peC, peF, pbScratch, cbScratch );
 
    // H = D - B
    SymCryptModSub( pmMod, peD, peB, peH, pbScratch, cbScratch );
 
    // X3 = E * F
    SymCryptModMul( pmMod, peE, peF, peDstX, pbScratch, cbScratch );
 
    // Y3 = G * H
    SymCryptModMul( pmMod, peG, peH, peDstY, pbScratch, cbScratch );
 
    // T3 = E * H
    SymCryptModMul( pmMod, peE, peH, peDstT, pbScratch, cbScratch );
 
    // Z3 = F * G
    SymCryptModMul( pmMod, peF, peG, peDstZ, pbScratch, cbScratch );
}

◆ SymCryptTwistedEdwardsFillScratchSpaces()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsFillScratchSpaces ( _In_ PSYMCRYPT_ECURVE pCurve )

Definition at line 11 of file ec_twisted_edwards.c.

{
    UINT32 nDigits = SymCryptDigitsFromBits( pCurve->FModBitsize );
    UINT32 cbModElement = pCurve->cbModElement;
    UINT32 nDigitsFieldLength = pCurve->FModDigits;
 
    //
    // All the scratch space computations are upper bounded by the SizeofXXX bound (2^19) and
    // the SCRATCH_BYTES_FOR_XXX bound (2^24) (see symcrypt_internal.h).
    //
    // One caveat is SymCryptSizeofEcpointFromCurve and SymCryptSizeofEcpointEx which calculate
    // the size of EcPoint with 4 coordinates (each one a modelement of max size 2^17). Thus upper
    // bounded by 2^20.
    //
    // Another is the precomp points computation where the nPrecompPoints are up to
    // 2^SYMCRYPT_ECURVE_SW_DEF_WINDOW = 2^6 and the nRecodedDigits are equal to the
    // GOrd bitsize < 2^20.
    //
    // Thus cbScratchScalarMulti is upper bounded by 2^6*2^20 + 2*2^20*2^4 ~ 2^26.
    //
 
    pCurve->cbScratchCommon = 8 * cbModElement + SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigits );
 
    pCurve->cbScratchScalar =
            (pCurve->cbModElement) +
            2 * SymCryptSizeofEcpointFromCurve( pCurve ) +
            2 * SymCryptSizeofIntFromDigits( pCurve->GOrdDigits ) +
            SYMCRYPT_MAX( pCurve->cbScratchCommon, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->GOrdDigits ));
 
    pCurve->cbScratchScalarMulti =
            pCurve->info.sw.nPrecompPoints * SymCryptSizeofEcpointFromCurve( pCurve ) +
            ((2*pCurve->info.sw.nRecodedDigits * sizeof(UINT32) + SYMCRYPT_ASYM_ALIGN_VALUE - 1 )/SYMCRYPT_ASYM_ALIGN_VALUE) * SYMCRYPT_ASYM_ALIGN_VALUE;
 
    pCurve->cbScratchGetSetValue =
        SymCryptSizeofEcpointEx(cbModElement, SYMCRYPT_ECPOINT_FORMAT_MAX_LENGTH) +
        2 * cbModElement +
        SYMCRYPT_MAX(SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(nDigitsFieldLength),
        SYMCRYPT_SCRATCH_BYTES_FOR_MODINV(nDigitsFieldLength));
 
    pCurve->cbScratchGetSetValue = SYMCRYPT_MAX( pCurve->cbScratchGetSetValue, SymCryptSizeofIntFromDigits( nDigits ) );
 
    pCurve->cbScratchEckey =
        SYMCRYPT_MAX( pCurve->cbModElement + SymCryptSizeofIntFromDigits(SymCryptEcurveDigitsofScalarMultiplier(pCurve)),
                SymCryptSizeofEcpointFromCurve( pCurve ) ) +
        SYMCRYPT_MAX( pCurve->cbScratchScalar + pCurve->cbScratchScalarMulti, pCurve->cbScratchGetSetValue );
}

◆ SymCryptTwistedEdwardsIsEqual()

UINT32 SYMCRYPT_CALL SymCryptTwistedEdwardsIsEqual	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc1,
		_In_ PCSYMCRYPT_ECPOINT	poSrc2,
		UINT32	flags,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 447 of file ec_twisted_edwards.c.

{
    PSYMCRYPT_MODELEMENT  peTemp[2];
    PSYMCRYPT_MODELEMENT  peSrc1X, peSrc1Y, peSrc1Z;
    PSYMCRYPT_MODELEMENT  peSrc2X, peSrc2Y, peSrc2Z;
    PSYMCRYPT_MODULUS     pmMod = pCurve->FMod;
    SIZE_T nBytes;
    UINT32  dResX = 0;
    UINT32  dResXN = 0;
    UINT32  dResY = 0;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc1->pCurve) && SymCryptEcurveIsSame(pCurve, poSrc2->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
 
    SYMCRYPT_ASSERT( cbScratch >= 2*nBytes );
 
    for (UINT32 i = 0; i < 2; ++i)
    {
        peTemp[i] = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
        pbScratch += nBytes;
        cbScratch -= nBytes;
    }
 
    peSrc1X = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc1 );
    peSrc1Y = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc1 );
    peSrc1Z = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc1 );
 
    peSrc2X = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc2 );
    peSrc2Y = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc2 );
    peSrc2Z = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc2 );
 
    // Setting the default flag if flags == 0
    flags |= (SYMCRYPT_MASK32_ZERO(flags) & SYMCRYPT_FLAG_ECPOINT_EQUAL);
 
    // peTemp[0] = X1 * Z2
    SymCryptModMul( pmMod, peSrc1X, peSrc2Z, peTemp[0], pbScratch, cbScratch );
 
    // peTemp[1] = X2 * Z1
    SymCryptModMul( pmMod, peSrc2X, peSrc1Z, peTemp[1], pbScratch, cbScratch );
 
    dResX = SymCryptModElementIsEqual( pmMod, peTemp[0], peTemp[1] );
 
    // Neg peTemp[1]
    SymCryptModNeg(pmMod, peTemp[1], peTemp[1], pbScratch, cbScratch);
    dResXN = SymCryptModElementIsEqual(pmMod, peTemp[0], peTemp[1]);
 
    // peTemp[0] = Y1 * Z2
    SymCryptModMul( pmMod, peSrc1Y, peSrc2Z, peTemp[0], pbScratch, cbScratch );
 
    // peTemp[1] = Y2 * Z1
    SymCryptModMul( pmMod, peSrc2Y, peSrc1Z, peTemp[1], pbScratch, cbScratch );
 
    dResY = SymCryptModElementIsEqual( pmMod, peTemp[0], peTemp[1] );
 
    return (SYMCRYPT_MASK32_NONZERO( flags & SYMCRYPT_FLAG_ECPOINT_EQUAL ) & dResX & dResY ) |
           (SYMCRYPT_MASK32_NONZERO( flags & SYMCRYPT_FLAG_ECPOINT_NEG_EQUAL ) & dResXN & dResY );
}

◆ SymCryptTwistedEdwardsIsZero()

UINT32 SYMCRYPT_CALL SymCryptTwistedEdwardsIsZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 78 of file ec_twisted_edwards.c.

{
    PSYMCRYPT_MODULUS     pmMod = pCurve->FMod;
    UINT32 dResX = 0, dResY = 0;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    PSYMCRYPT_MODELEMENT peSrcX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc );
    PSYMCRYPT_MODELEMENT peSrcY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc );
    PSYMCRYPT_MODELEMENT peSrcZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    dResX = SymCryptModElementIsZero( pmMod, peSrcX );
    dResY = SymCryptModElementIsEqual( pmMod, peSrcY, peSrcZ );
 
    return ( dResX & dResY );
}

◆ SymCryptTwistedEdwardsNegate()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsNegate	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Inout_ PSYMCRYPT_ECPOINT	poSrc,
		UINT32	mask,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 543 of file ec_twisted_edwards.c.

{
    PCSYMCRYPT_MODULUS FMod = pCurve->FMod;
    PSYMCRYPT_MODELEMENT peX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0,pCurve, poSrc);
    PSYMCRYPT_MODELEMENT peT = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 3,pCurve, poSrc);
 
    PSYMCRYPT_MODELEMENT peTmp = NULL;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) + pCurve->cbModElement );
 
    peTmp = SymCryptModElementCreate(
                pbScratch,
                pCurve->cbModElement,
                FMod );
    SYMCRYPT_ASSERT( peTmp != NULL);
 
    pbScratch += pCurve->cbModElement;
    cbScratch -= pCurve->cbModElement;
 
    SymCryptModNeg( FMod, peX, peTmp, pbScratch, cbScratch );
    SymCryptModElementMaskedCopy( FMod, peTmp, peX, mask );
 
    SymCryptModNeg( FMod, peT, peTmp, pbScratch, cbScratch );
    SymCryptModElementMaskedCopy( FMod, peTmp, peT, mask );
}

◆ SymCryptTwistedEdwardsOnCurve()

UINT32 SYMCRYPT_CALL SymCryptTwistedEdwardsOnCurve	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_In_ PCSYMCRYPT_ECPOINT	poSrc,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 113 of file ec_twisted_edwards.c.

{
    PSYMCRYPT_MODELEMENT  peTemp[4];
    PSYMCRYPT_MODULUS     pmMod = pCurve->FMod;
    SIZE_T nBytes;
 
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poSrc->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    nBytes = SymCryptSizeofModElementFromModulus( pmMod );
 
    SYMCRYPT_ASSERT( cbScratch >= 4*nBytes );
 
    for (UINT32 i = 0; i < 4; ++i)
    {
       peTemp[i] = SymCryptModElementCreate( pbScratch, nBytes, pmMod );
       pbScratch += nBytes;
       cbScratch -= nBytes;
    }
 
    PSYMCRYPT_MODELEMENT peSrcX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poSrc );
    PSYMCRYPT_MODELEMENT peSrcY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poSrc );
    PSYMCRYPT_MODELEMENT peSrcZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poSrc );
 
    // peTemp[0] = X^2
    SymCryptModSquare( pmMod, peSrcX, peTemp[0], pbScratch, cbScratch);
 
    // peTemp[1] = Y^2
    SymCryptModSquare( pmMod, peSrcY, peTemp[1], pbScratch, cbScratch);
 
    // peTemp[2] = Z^2
    SymCryptModSquare( pmMod, peSrcZ, peTemp[2], pbScratch, cbScratch);
 
    // peTemp[3] = a * X^2
    SymCryptModMul( pmMod, pCurve->A, peTemp[0], peTemp[3], pbScratch, cbScratch );
 
    // peTemp[3] = a * X^2 + Y^2
    SymCryptModAdd( pmMod, peTemp[3], peTemp[1], peTemp[3], pbScratch, cbScratch );
 
    // peTemp[3] = Z^2 (a * X^2 + Y^2)
    SymCryptModMul( pmMod, peTemp[3], peTemp[2], peTemp[3], pbScratch, cbScratch );
 
    // peTemp[1] = X^2 * Y^2
    SymCryptModMul( pmMod, peTemp[0], peTemp[1], peTemp[1], pbScratch, cbScratch );
 
    // peTemp[1] = d * X^2 *Y^2
    SymCryptModMul( pmMod, pCurve->B, peTemp[1], peTemp[1], pbScratch, cbScratch );
 
    // peTemp[2] = Z^4
    SymCryptModMul( pmMod, peTemp[2], peTemp[2], peTemp[2], pbScratch, cbScratch );
 
    // peTemp[1] = Z^4 + d * X^2 * Y^2
    SymCryptModAdd( pmMod, peTemp[2], peTemp[1], peTemp[1], pbScratch, cbScratch );
 
    return SymCryptModElementIsEqual( pmMod, peTemp[1], peTemp[3] );
}

◆ SymCryptTwistedEdwardsSetDistinguished()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsSetDistinguished	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 60 of file ec_twisted_edwards.c.

{
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
 
    UNREFERENCED_PARAMETER( pbScratch );
    UNREFERENCED_PARAMETER( cbScratch );
 
    SymCryptEcpointCopy( pCurve, pCurve->G, poDst );
}

◆ SymCryptTwistedEdwardsSetZero()

VOID SYMCRYPT_CALL SymCryptTwistedEdwardsSetZero	(	_In_ PCSYMCRYPT_ECURVE	pCurve,
		_Out_ PSYMCRYPT_ECPOINT	poDst,
		_Out_writes_bytes_(cbScratch) PBYTE	pbScratch,
		SIZE_T	cbScratch
	)

Definition at line 517 of file ec_twisted_edwards.c.

{
    SYMCRYPT_ASSERT( SYMCRYPT_CURVE_IS_TWISTED_EDWARDS_TYPE(pCurve) );
    SYMCRYPT_ASSERT( SymCryptEcurveIsSame(pCurve, poDst->pCurve) );
    SYMCRYPT_ASSERT( cbScratch >= SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
 
    PSYMCRYPT_MODULUS  pmMod = pCurve->FMod;
 
    PSYMCRYPT_MODELEMENT peDstX = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 0, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstY = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 1, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstZ = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 2, pCurve, poDst );
    PSYMCRYPT_MODELEMENT peDstT = SYMCRYPT_INTERNAL_ECPOINT_COORDINATE( 3, pCurve, poDst );
 
    SymCryptModElementSetValueUint32( 0, pmMod, peDstX, pbScratch, cbScratch );
    SymCryptModElementSetValueUint32( 1, pmMod, peDstY, pbScratch, cbScratch );
    SymCryptModElementSetValueUint32( 1, pmMod, peDstZ, pbScratch, cbScratch );
    SymCryptModElementSetValueUint32( 0, pmMod, peDstT, pbScratch, cbScratch );
}

◆ SymCryptUint32ToLsbFirst()

VOID SYMCRYPT_CALL SymCryptUint32ToLsbFirst	(	_In_reads_(cuData) PCUINT32	puData,
		_Out_writes_(4 *cuData) PBYTE	pbResult,
		SIZE_T	cuData
	)

Definition at line 471 of file sc_lib.h.

{
    while( cuData != 0 )
    {
        SYMCRYPT_STORE_LSBFIRST32( pbResult, *puData );
        puData++;
        pbResult += 4;
        cuData--;
    }
}

Referenced by SymCryptMd4Result(), SymCryptMd4StateExport(), SymCryptMd5Result(), and SymCryptMd5StateExport().

◆ SymCryptUint32ToMsbFirst()

VOID SYMCRYPT_CALL SymCryptUint32ToMsbFirst	(	_In_reads_(cuData) PCUINT32	puData,
		_Out_writes_(4 *cuData) PBYTE	pbResult,
		SIZE_T	cuData
	)

Definition at line 405 of file sc_lib.h.

{
    while( cuData != 0 )
    {
        SYMCRYPT_STORE_MSBFIRST32( pbResult, *puData );
        puData++;
        pbResult += 4;
        cuData--;
    }
}

Referenced by SymCryptSha1Result(), SymCryptSha1StateExport(), SymCryptSha256Result(), SymCryptSha256StateExportCore(), and SymCryptTlsCbcHmacVerify().

◆ SymCryptUint64ToLsbFirst()

FORCEINLINE VOID SYMCRYPT_CALL SymCryptUint64ToLsbFirst	(	_In_reads_(cuData) PCUINT64	puData,
		_Out_writes_(8 *cuData) PBYTE	pbResult,
		SIZE_T	cuData
	)

Definition at line 538 of file sc_lib.h.

{
    while( cuData != 0 )
    {
        SYMCRYPT_STORE_LSBFIRST64( pbResult, *puData );
        puData++;
        pbResult += 8;
        cuData--;
    }
}

Referenced by SymCryptKeccakStateExport().

◆ SymCryptUint64ToMsbFirst()

VOID SYMCRYPT_CALL SymCryptUint64ToMsbFirst	(	_In_reads_(cuData) PCUINT64	puData,
		_Out_writes_(8 *cuData) PBYTE	pbResult,
		SIZE_T	cuData
	)

Definition at line 576 of file sc_lib.h.

{
    while( cuData != 0 )
    {
        SYMCRYPT_STORE_MSBFIRST64( pbResult, *puData );
        pbResult += 8;
        puData ++;
        cuData --;
    }
}

Referenced by SymCryptSha512Result(), SymCryptSha512StateExportCore(), and SymCryptTlsCbcHmacVerify().

◆ SymCryptWidthNafRecoding()

VOID SYMCRYPT_CALL SymCryptWidthNafRecoding	(	UINT32	W,
		_Inout_ PSYMCRYPT_INT	piK,
		_Out_writes_(nRecodedDigits) PUINT32	absofKIs,
		_Out_writes_(nRecodedDigits) PUINT32	sigofKIs,
		UINT32	nRecodedDigits
	)

Definition at line 125 of file recoding.c.

{
    UINT32 T1 = 0;
    UINT32 mask = ~(0xffffffff << W);       // Window mask = 2^w - 1 (e.g. 0x0000003f for w = 6)
    UINT32 modulus = mask + 1;              // 2^w
    UINT32 smask = 0x1 << (W-1);            // Sign mask   = 2^(w-1) (e.g. 0x00000020 for w = 6)
 
    SYMCRYPT_ASSERT( W < 32 );
 
    for (UINT32 i=0; i < nRecodedDigits; i++)
    {
        T1 = SymCryptIntGetValueLsbits32( piK ) & mask;         // T1 = k mod 2^W
 
        if (T1 & 0x1)
        {
            if (T1 > smask)
            {
                sigofKIs[i] = 0xffffffff;
                absofKIs[i] = modulus - T1;                         // 2^W - T1 = |T1 - 2^W|
                SymCryptIntAddUint32( piK, absofKIs[i], piK );      // k-k_i
            }
            else
            {
                // Here (k mod 2^W) is already in the specified range
                sigofKIs[i] = 0x00000001;
                absofKIs[i] = T1;
                SymCryptIntSubUint32( piK, absofKIs[i], piK );      // k-k_i
            }
        }
        else
        {
            absofKIs[i] = 0;
            sigofKIs[i] = 0;
        }
 
        SymCryptIntDivPow2( piK, 1, piK );                      // k := k / 2
    }
}

Referenced by SymCryptEcpointMultiScalarMulWnafWithInterleaving().

◆ SymCryptXmssComputePublicRoot()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssComputePublicRoot	(	_In_ PCSYMCRYPT_XMSS_PARAMS	pParams,
		_In_reads_bytes_(cbSeed) PCBYTE	pbSeed,
		SIZE_T	cbSeed,
		_In_reads_bytes_(cbSkXmss) PCBYTE	pbSkXmss,
		SIZE_T	cbSkXmss,
		_Out_writes_bytes_(cbRoot) PBYTE	pbRoot,
		SIZE_T	cbRoot
	)

Definition at line 1069 of file xmss.c.

{
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
    PBYTE pbScratch = NULL;
    SIZE_T cbScratch = 0;
    XMSS_ADRS adrs;
 
    SYMCRYPT_ASSERT(pParams->nLayerHeight < 32); // Ensure nLeaves fits in 32 bits
 
    if (pbRoot == NULL || cbRoot != pParams->cbHashOutput ||
        pbSeed == NULL || cbSeed != pParams->cbHashOutput ||
        pbSkXmss == NULL || cbSkXmss != pParams->cbHashOutput)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, 1ULL << pParams->nLayerHeight);
    cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len);
 
    SYMCRYPT_ASSERT(cbScratch > 0);
    pbScratch = SymCryptCallbackAlloc(cbScratch);
 
    if (pbScratch == NULL)
    {
        scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
        goto cleanup;
    }
 
    SymCryptWipeKnownSize(&adrs, sizeof(XMSS_ADRS));
    SYMCRYPT_STORE_MSBFIRST32(adrs.en32Layer, pParams->nLayers - 1);
 
    SymCryptXmssComputeSubtreeRoot(
        pParams,
        &adrs,
        pbSkXmss,
        pbSeed,
        0,
        pParams->nLayerHeight,
        pbScratch,
        cbScratch,
        pbRoot );
 
cleanup:
 
    if (pbScratch != NULL)
    {
        SymCryptWipe(pbScratch, cbScratch);
        SymCryptCallbackFree(pbScratch);
    }
 
    return scError;
}

Referenced by SymCryptXmsskeyGenerate(), and SymCryptXmsskeyVerifyRoot().

◆ SymCryptXmsskeyVerifyRoot()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyVerifyRoot ( _In_ PCSYMCRYPT_XMSS_KEY pKey )

Definition at line 1133 of file xmss.c.

{
    BYTE Root[SYMCRYPT_HASH_MAX_RESULT_SIZE];
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
 
    SYMCRYPT_CHECK_MAGIC(pKey);
 
    // key to be verified has to be a private key
    if (pKey->keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE)
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    SymCryptWipeKnownSize(Root, sizeof(Root));
 
    scError = SymCryptXmssComputePublicRoot(
        &pKey->params,
        pKey->Seed,
        pKey->params.cbHashOutput,
        pKey->SkXmss,
        pKey->params.cbHashOutput,
        Root,
        pKey->params.cbHashOutput);
 
    if (scError != SYMCRYPT_NO_ERROR)
    {
        goto cleanup;
    }
 
    if (!SymCryptEqual(Root, pKey->Root, pKey->params.cbHashOutput))
    {
        scError = SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH;
    }
 
cleanup:
 
    return scError;
}

Referenced by SymCryptXmsskeySetValue().

◆ SymCryptXmssVerifyInternal()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssVerifyInternal	(	_Inout_ PSYMCRYPT_XMSS_KEY	pKey,
		_In_reads_bytes_(cbMessage) PCBYTE	pbMessage,
		SIZE_T	cbMessage,
		UINT32	flags,
		_In_reads_bytes_(cbSignature) PCBYTE	pbSignature,
		SIZE_T	cbSignature
	)

Definition at line 1736 of file xmss.c.

{
    SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
    PBYTE pbScratch = NULL;
    SIZE_T cbScratch = 0;
    PCSYMCRYPT_XMSS_PARAMS pParams = &pKey->params;
    BYTE RandomizedHash[SYMCRYPT_HASH_MAX_RESULT_SIZE];
    BYTE ComputedRoot[SYMCRYPT_HASH_MAX_RESULT_SIZE];
    XMSS_ADRS adrs;
    UINT32 uLayer;
    UINT64 uTree;
    UINT32 uLeaf;
    const UINT64 LeafMask = (1ULL << pParams->nLayerHeight) - 1;
 
    SYMCRYPT_CHECK_MAGIC(pKey);
 
    SYMCRYPT_ASSERT(pParams->nLayerHeight < 32); // Ensure nLeaves fits in 32 bits
 
    if (flags != 0 ||
        pbSignature == NULL ||
        cbSignature != SymCryptXmssSizeofSignatureFromParams(pParams) ||
        pKey->keyType == SYMCRYPT_XMSSKEY_TYPE_NONE )
    {
        scError = SYMCRYPT_INVALID_ARGUMENT;
        goto cleanup;
    }
 
    cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len);
    cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, 1ULL << pParams->nLayerHeight);
 
    pbScratch = (PBYTE)SymCryptCallbackAlloc(cbScratch);
 
    if (pbScratch == NULL)
    {
        scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
        goto cleanup;
    }
 
    PBYTE pbRandomness = SymCryptXmssSignatureGetRandomness(pParams, pbSignature);
    UINT64 Idx = SymCryptXmssSignatureGetIdx(pParams, pbSignature);
 
    SymCryptXmssRandomizedHash(
        pParams,
        Idx,
        pbRandomness,
        pKey->Root,
        pbMessage,
        cbMessage,
        RandomizedHash);
 
    SymCryptWipeKnownSize(&adrs, sizeof(XMSS_ADRS));
 
    for (uLayer = 0; uLayer < pParams->nLayers; uLayer++)
    {
        uTree = Idx >> pParams->nLayerHeight;
        uLeaf = (UINT32)(Idx & LeafMask);
 
        SYMCRYPT_STORE_MSBFIRST32(adrs.en32Layer, uLayer);
        SYMCRYPT_STORE_MSBFIRST64(adrs.en64Tree, uTree);
        SymCryptXmssTreeRootFromSignature(
            pParams,
            &adrs,
            pKey->Seed,
            uLayer == 0 ? RandomizedHash : ComputedRoot,
            uLeaf,
            SymCryptXmssSignatureGetWotspSig(pParams, pbSignature, uLayer),
            SymCryptXmssSignatureGetAuthNodes(pParams, pbSignature, uLayer),
            ComputedRoot,
            pbScratch,
            cbScratch);
 
        Idx >>= pParams->nLayerHeight;
    }
 
    if (!SymCryptEqual(ComputedRoot, pKey->Root, pParams->cbHashOutput))
    {
        scError = SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE;
        goto cleanup;
    }
 
cleanup:
 
    if (pbScratch)
    {
        SymCryptWipe(pbScratch, cbScratch);
        SymCryptCallbackFree(pbScratch);
    }
 
    return scError;
}

Referenced by SymCryptXmssVerify().

◆ SymCryptXtsAesDecryptDataUnitAsm()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptDataUnitAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 629 of file xtsaes.c.

{
    SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
    SymCryptXtsDecryptDataUnit(
            &SymCryptAesBlockCipherNoOpt,
            pExpandedKey,
            pbTweakBlock,
            pbSrc,
            pbDst,
            cbData );
}

◆ SymCryptXtsAesDecryptDataUnitC()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptDataUnitC	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 668 of file xtsaes.c.

{
    SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
    SymCryptXtsDecryptDataUnit(
        &SymCryptAesBlockCipherNoOpt,
        pExpandedKey,
        pbTweakBlock,
        pbSrc,
        pbDst,
        cbData );
 
}

◆ SymCryptXtsAesDecryptDataUnitNeon()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptDataUnitNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesDecryptDataUnitXmm()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptDataUnitXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE	pbScratch,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesDecryptDataUnitYmm_2048()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptDataUnitYmm_2048	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE	pbScratch,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesDecryptDataUnitZmm_2048()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptDataUnitZmm_2048	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE	pbScratch,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesEncryptDataUnitAsm()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptDataUnitAsm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 610 of file xtsaes.c.

{
    SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
    SymCryptXtsEncryptDataUnit(
            &SymCryptAesBlockCipherNoOpt,
            pExpandedKey,
            pbTweakBlock,
            pbSrc,
            pbDst,
            cbData );
}

◆ SymCryptXtsAesEncryptDataUnitC()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptDataUnitC	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 648 of file xtsaes.c.

{
    // No special optimizations...
    SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
    SymCryptXtsEncryptDataUnit(
        &SymCryptAesBlockCipherNoOpt,
        pExpandedKey,
        pbTweakBlock,
        pbSrc,
        pbDst,
        cbData );
}

◆ SymCryptXtsAesEncryptDataUnitNeon()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptDataUnitNeon	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesEncryptDataUnitXmm()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptDataUnitXmm	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE	pbScratch,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesEncryptDataUnitYmm_2048()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptDataUnitYmm_2048	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE	pbScratch,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsAesEncryptDataUnitZmm_2048()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptDataUnitZmm_2048	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE	pbTweakBlock,
		_Out_writes_(SYMCRYPT_AES_BLOCK_SIZE *16) PBYTE	pbScratch,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

◆ SymCryptXtsDecryptDataUnit()

VOID SYMCRYPT_CALL SymCryptXtsDecryptDataUnit	(	_In_ PCSYMCRYPT_BLOCKCIPHER	pBlockCipher,
		_In_ PCVOID	pExpandedKey,
		_Inout_updates_(pBlockCipher->blockSize) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 524 of file xtsaes.c.

{
    BYTE buf[2*SYMCRYPT_AES_BLOCK_SIZE];
    BYTE tweakBuf[SYMCRYPT_AES_BLOCK_SIZE];
 
    while( cbData >= 2*SYMCRYPT_AES_BLOCK_SIZE )
    {
        SymCryptXorBytes( pbTweakBlock, pbSrc, buf, SYMCRYPT_AES_BLOCK_SIZE );
        (*pBlockCipher->decryptFunc)( pExpandedKey, buf, buf );
        SymCryptXorBytes( pbTweakBlock, buf, pbDst, SYMCRYPT_AES_BLOCK_SIZE );
 
        SYMCRYPT_ASSERT( pBlockCipher->blockSize == SYMCRYPT_AES_BLOCK_SIZE );
        SymCryptXtsUpdateTweak( pbTweakBlock );
 
        pbSrc += SYMCRYPT_AES_BLOCK_SIZE;
        pbDst += SYMCRYPT_AES_BLOCK_SIZE;
        cbData -= SYMCRYPT_AES_BLOCK_SIZE;
    }
 
    if( cbData > SYMCRYPT_AES_BLOCK_SIZE )
    {
        // Ciphertext stealing decryption
        //
        //                      +--------------+
        //                      |              |
        //                      |              V
        // +-----------------+  |  +-----+-----------+
        // |      C_m-1      |  |  | C_m |++++CP+++++|
        // +-----------------+  |  +-----+-----------+
        //          |           |           |
        //        dec_m         |        dec_m-1
        //          |           |           |
        //          V           |           V
        // +-----+-----------+  |  +-----------------+
        // | P_m |++++CP+++++|--+  |      P_m-1      |
        // +-----+-----------+     +-----------------+
        //    |                   /
        //    +----------------  /  --+
        //                      /     |
        //                      |     V
        // +-----------------+  |  +-----+
        // |      P_m-1      |<-+  | P_m |
        // +-----------------+     +-----+
 
        // Save penultimate value of tweak to tweakBuf
        memcpy( tweakBuf, pbTweakBlock, SYMCRYPT_AES_BLOCK_SIZE );
 
        // Do final tweak update
        SymCryptXtsUpdateTweak( pbTweakBlock );
 
        // Decrypt penultimate ciphertext block into buf
        SymCryptXorBytes( pbTweakBlock, pbSrc, buf, SYMCRYPT_AES_BLOCK_SIZE );
        (*pBlockCipher->decryptFunc)( pExpandedKey, buf, buf );
        SymCryptXorBytes( pbTweakBlock, buf, buf, SYMCRYPT_AES_BLOCK_SIZE );
 
        cbData -= SYMCRYPT_AES_BLOCK_SIZE;
 
        // Copy buf to buf[SYMCRYPT_AES_BLOCK_SIZE]
        memcpy( &buf[SYMCRYPT_AES_BLOCK_SIZE], buf, SYMCRYPT_AES_BLOCK_SIZE );
        // Copy final ciphertext bytes to prefix of buf - we must read before writing to support in-place decryption
        memcpy( buf, pbSrc + SYMCRYPT_AES_BLOCK_SIZE, cbData );
        // Copy prefix of buf[SYMCRYPT_AES_BLOCK_SIZE] to the right place in the destination buffer
        memcpy( pbDst + SYMCRYPT_AES_BLOCK_SIZE, &buf[SYMCRYPT_AES_BLOCK_SIZE], cbData );
 
        // Set pbSrc and pbTweakBlock correctly to share code with non-ciphertext stealing case
        pbSrc = &buf[0];
        pbTweakBlock = &tweakBuf[0];
    }
 
    // Final full block decryption
    SymCryptXorBytes( pbTweakBlock, pbSrc, buf, SYMCRYPT_AES_BLOCK_SIZE );
    (*pBlockCipher->decryptFunc)( pExpandedKey, buf, buf );
    SymCryptXorBytes( pbTweakBlock, buf, pbDst, SYMCRYPT_AES_BLOCK_SIZE );
 
    SymCryptWipeKnownSize( buf, sizeof(buf) );
    SymCryptWipeKnownSize( tweakBuf, sizeof(tweakBuf) );
}

Referenced by SymCryptXtsAesDecryptDataUnitAsm(), and SymCryptXtsAesDecryptDataUnitC().

◆ SymCryptXtsEncryptDataUnit()

VOID SYMCRYPT_CALL SymCryptXtsEncryptDataUnit	(	_In_ PCSYMCRYPT_BLOCKCIPHER	pBlockCipher,
		_In_ PCVOID	pExpandedKey,
		_Inout_updates_(pBlockCipher->blockSize) PBYTE	pbTweakBlock,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 444 of file xtsaes.c.

{
    BYTE  buf[2*SYMCRYPT_AES_BLOCK_SIZE];
 
    while( cbData >= 2*SYMCRYPT_AES_BLOCK_SIZE )
    {
        SymCryptXorBytes( pbTweakBlock, pbSrc, buf, SYMCRYPT_AES_BLOCK_SIZE );
        (*pBlockCipher->encryptFunc)( pExpandedKey, buf, buf );
        SymCryptXorBytes( pbTweakBlock, buf, pbDst, SYMCRYPT_AES_BLOCK_SIZE );
 
        SYMCRYPT_ASSERT( pBlockCipher->blockSize == SYMCRYPT_AES_BLOCK_SIZE );
        SymCryptXtsUpdateTweak( pbTweakBlock );
 
        pbSrc += SYMCRYPT_AES_BLOCK_SIZE;
        pbDst += SYMCRYPT_AES_BLOCK_SIZE;
        cbData -= SYMCRYPT_AES_BLOCK_SIZE;
    }
 
    if( cbData > SYMCRYPT_AES_BLOCK_SIZE )
    {
        // Ciphertext stealing encryption
        //
        //                      +--------------+
        //                      |              |
        //                      |              V
        // +-----------------+  |  +-----+-----------+
        // |      P_m-1      |  |  | P_m |++++CP+++++|
        // +-----------------+  |  +-----+-----------+
        //          |           |           |
        //       enc_m-1        |         enc_m
        //          |           |           |
        //          V           |           V
        // +-----+-----------+  |  +-----------------+
        // | C_m |++++CP+++++|--+  |      C_m-1      |
        // +-----+-----------+     +-----------------+
        //    |                   /
        //    +----------------  /  --+
        //                      /     |
        //                      |     V
        // +-----------------+  |  +-----+
        // |      C_m-1      |<-+  | C_m |
        // +-----------------+     +-----+
 
        // Encrypt penultimate plaintext block into buf
        SymCryptXorBytes( pbTweakBlock, pbSrc, buf, SYMCRYPT_AES_BLOCK_SIZE );
        (*pBlockCipher->encryptFunc)( pExpandedKey, buf, buf );
        SymCryptXorBytes( pbTweakBlock, buf, buf, SYMCRYPT_AES_BLOCK_SIZE );
 
        cbData -= SYMCRYPT_AES_BLOCK_SIZE;
 
        // Copy buf to buf[SYMCRYPT_AES_BLOCK_SIZE]
        memcpy( &buf[SYMCRYPT_AES_BLOCK_SIZE], buf, SYMCRYPT_AES_BLOCK_SIZE );
        // Copy final plaintext bytes to prefix of buf - we must read before writing to support in-place encryption
        memcpy( buf, pbSrc + SYMCRYPT_AES_BLOCK_SIZE, cbData );
        // Copy prefix of buf[SYMCRYPT_AES_BLOCK_SIZE] to the right place in the destination buffer
        memcpy( pbDst + SYMCRYPT_AES_BLOCK_SIZE, &buf[SYMCRYPT_AES_BLOCK_SIZE], cbData );
 
        // Do final tweak update
        SymCryptXtsUpdateTweak( pbTweakBlock );
 
        // Set pbSrc correctly to share code with non-ciphertext stealing case
        pbSrc = &buf[0];
    }
 
    // Final full block encryption
    SymCryptXorBytes( pbTweakBlock, pbSrc, buf, SYMCRYPT_AES_BLOCK_SIZE );
    (*pBlockCipher->encryptFunc)( pExpandedKey, buf, buf );
    SymCryptXorBytes( pbTweakBlock, buf, pbDst, SYMCRYPT_AES_BLOCK_SIZE );
 
    SymCryptWipeKnownSize( buf, sizeof(buf) );
}

Referenced by SymCryptXtsAesEncryptDataUnitAsm(), and SymCryptXtsAesEncryptDataUnitC().

◆ XorByteIntoBuffer()

FORCEINLINE VOID SYMCRYPT_CALL XorByteIntoBuffer	(	_Inout_updates_(8 *cqBuf) PBYTE	pbBuf,
		SIZE_T	cqBuf,
		BYTE	v
	)

Definition at line 915 of file sc_lib.h.

{
    SIZE_T i;
 
    for( i=0; i<8*cqBuf; i++ )
    {
        pbBuf[i] ^= v;
    }
}

Referenced by SYMCRYPT_HmacXxxExpandKey(), and SymCryptHmacExpandKey().

Variable Documentation

◆ abId

BYTE abId[SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE]

Definition at line 4729 of file sc_lib.h.

◆ abPublicRoot

BYTE abPublicRoot[SYMCRYPT_LMS_MAX_N]

Definition at line 4732 of file sc_lib.h.

Referenced by SymCryptLmskeyVerifyRoot().

◆ abSeed

BYTE abSeed[SYMCRYPT_LMS_MAX_N]

Definition at line 4735 of file sc_lib.h.

Referenced by SymCrypt802_11SaeCustomInit(), SymCryptRngAesGenerateSmall(), and SymCryptRngAesReseed().

◆ g_SymCryptFlags

UINT32 g_SymCryptFlags

extern

Definition at line 18 of file libmain.c.

Referenced by SymCryptInitEnvCommon(), and SymCryptInitEnvWindowsUsermodeWin8_1nLater().

◆ g_SymCryptModFns

const SYMCRYPT_MODULAR_FUNCTIONS g_SymCryptModFns[]

extern

Definition at line 21 of file a_dispatch.c.

◆ g_SymCryptModFnsMask

const UINT32 g_SymCryptModFnsMask

extern

Definition at line 72 of file a_dispatch.c.

◆ hasPrivateSeed

BOOLEAN hasPrivateSeed

Definition at line 4449 of file sc_lib.h.

◆ keyType

UINT32 keyType

Definition at line 4525 of file sc_lib.h.

Referenced by SymCryptLmskeyGetValue(), SymCryptLmskeySetValue(), SymCryptLmsSizeofKeyBlobFromParams(), SymCryptXmsskeyGetValue(), SymCryptXmsskeySetValue(), and SymCryptXmssSizeofKeyBlobFromParams().

◆ nNextUnusedLeaf

UINT64 nNextUnusedLeaf

Definition at line 4723 of file sc_lib.h.

◆ params

SYMCRYPT_LMS_PARAMS params

Definition at line 4523 of file sc_lib.h.

◆ pkEcKey

PSYMCRYPT_ECKEY pkEcKey

Definition at line 4445 of file sc_lib.h.

◆ pkMlKemkey

PSYMCRYPT_MLKEMKEY pkMlKemkey

Definition at line 4444 of file sc_lib.h.

Referenced by SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulate(), SymCryptMlKemEncapsulateEx(), SymCryptMlKemEncapsulateInternal(), SymCryptMlKemkeyComputeEncapsulationKeyHash(), SymCryptMlKemkeyExpandFromPrivateSeed(), SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed(), SymCryptMlKemkeyFree(), SymCryptMlKemkeyGenerate(), SymCryptMlKemkeyGetValue(), SymCryptMlKemkeySetValue(), and SymCryptMlKemkeyWipePrivateState().

◆ privateSeed

BYTE privateSeed[SYMCRYPT_COMPOSITE_MLKEM_IRTF_PRIVATE_SEED_SIZE]

Definition at line 4450 of file sc_lib.h.

Referenced by SymCryptMlKemkeyGenerate().

◆ PSYMCRYPT_COMPOSITE_MLKEMKEY

SYMCRYPT_MAGIC_FIELD * PSYMCRYPT_COMPOSITE_MLKEMKEY

Definition at line 4453 of file sc_lib.h.

◆ Root

BYTE Root[SYMCRYPT_HASH_MAX_RESULT_SIZE]

Definition at line 4528 of file sc_lib.h.

◆ Seed

BYTE Seed[SYMCRYPT_HASH_MAX_RESULT_SIZE]

Definition at line 4529 of file sc_lib.h.

Referenced by ChecksumCompute(), CCabinet::ComputeChecksum(), LsapCreateRandomDomainSid(), NtAllocateUuids(), NtSetUuidSeed(), NvNetBackoffReseedEx(), RtlRandom(), RtlRandomEx(), and RtlUniform().

◆ SkPrf

BYTE SkPrf[SYMCRYPT_HASH_MAX_RESULT_SIZE]

Definition at line 4537 of file sc_lib.h.

◆ SkXmss

BYTE SkXmss[SYMCRYPT_HASH_MAX_RESULT_SIZE]

Definition at line 4536 of file sc_lib.h.

◆ SYMCRYPT_COMPOSITE_MLKEMKEY

SYMCRYPT_MAGIC_FIELD SYMCRYPT_COMPOSITE_MLKEMKEY

Definition at line 4453 of file sc_lib.h.

◆ SYMCRYPT_LMS_KEY

SYMCRYPT_MAGIC_FIELD SYMCRYPT_LMS_KEY

Definition at line 4738 of file sc_lib.h.

◆ SYMCRYPT_XMSS_KEY

SYMCRYPT_XMSS_KEY

Definition at line 4539 of file sc_lib.h.

◆ SymCryptAesBlockCipherNoOpt

const SYMCRYPT_BLOCKCIPHER SymCryptAesBlockCipherNoOpt

extern

Definition at line 20 of file aes-default.c.

Referenced by SymCryptAesCbcDecrypt(), SymCryptAesCbcEncrypt(), SymCryptAesCbcMac(), SymCryptAesCtrMsb32(), SymCryptAesCtrMsb64(), SymCryptXtsAesDecryptDataUnitAsm(), SymCryptXtsAesDecryptDataUnitC(), SymCryptXtsAesEncryptDataUnitAsm(), and SymCryptXtsAesEncryptDataUnitC().

◆ SymCryptDlgroupDhSafePrimeParamsffdhe2048

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsffdhe2048

extern

Definition at line 902 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsffdhe3072

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsffdhe3072

extern

Definition at line 903 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsffdhe4096

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsffdhe4096

extern

Definition at line 904 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsffdhe6144

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsffdhe6144

extern

Definition at line 905 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsffdhe8192

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsffdhe8192

extern

Definition at line 906 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsModp2048

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsModp2048

extern

Definition at line 896 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsModp3072

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsModp3072

extern

Definition at line 897 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsModp4096

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsModp4096

extern

Definition at line 898 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsModp6144

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsModp6144

extern

Definition at line 899 of file dl_internal_groups.c.

◆ SymCryptDlgroupDhSafePrimeParamsModp8192

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptDlgroupDhSafePrimeParamsModp8192

extern

Definition at line 900 of file dl_internal_groups.c.

◆ SymCryptEcpointFormatNumberofElements

const UINT32 SymCryptEcpointFormatNumberofElements[4]

extern

Definition at line 11 of file ecpoint.c.

Referenced by SymCryptEckeySizeofPublicKey(), SymCryptEcpointGetValue(), and SymCryptEcpointSetValue().

◆ SymCryptEcurveParamsV2ExtensionMontgomery

const PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION SymCryptEcurveParamsV2ExtensionMontgomery

extern

Definition at line 597 of file ec_internal_curve_params.c.

Referenced by SymCryptEcurveInitialize().

◆ SymCryptEcurveParamsV2ExtensionShortWeierstrass

const PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION SymCryptEcurveParamsV2ExtensionShortWeierstrass

extern

Definition at line 595 of file ec_internal_curve_params.c.

Referenced by SymCryptEcurveInitialize().

◆ SymCryptEcurveParamsV2ExtensionTwistedEdwards

const PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION SymCryptEcurveParamsV2ExtensionTwistedEdwards

extern

Definition at line 596 of file ec_internal_curve_params.c.

Referenced by SymCryptEcurveInitialize().

◆ SymCryptMd2Algorithm_default

const SYMCRYPT_HASH SymCryptMd2Algorithm_default

extern

Definition at line 27 of file md2.c.

◆ SymCryptMd4Algorithm_default

const SYMCRYPT_HASH SymCryptMd4Algorithm_default

extern

Definition at line 33 of file md4.c.

◆ SymCryptMd5Algorithm_default

const SYMCRYPT_HASH SymCryptMd5Algorithm_default

extern

Definition at line 30 of file md5.c.

◆ SymCryptModulusTypeSelections

const SYMCRYPT_MODULUS_TYPE_SELECTION_ENTRY SymCryptModulusTypeSelections[]

extern

Definition at line 77 of file a_dispatch.c.

Referenced by SymCryptFdefDecideModulusType().

◆ SymCryptNamedSafePrimeGroups

const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptNamedSafePrimeGroups[SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT]

extern

Definition at line 910 of file dl_internal_groups.c.

Referenced by SymCryptDlgroupAutoCompleteNamedSafePrimeGroup(), and SymCryptDlgroupSetValueSafePrime().

◆ SymCryptParallelSha256Algorithm

const PCSYMCRYPT_PARALLEL_HASH SymCryptParallelSha256Algorithm

extern

◆ SymCryptParallelSha384Algorithm

const PCSYMCRYPT_PARALLEL_HASH SymCryptParallelSha384Algorithm

extern

◆ SymCryptParallelSha512Algorithm

const PCSYMCRYPT_PARALLEL_HASH SymCryptParallelSha512Algorithm

extern

◆ SymCryptSha1Algorithm_default

const SYMCRYPT_HASH SymCryptSha1Algorithm_default

extern

Definition at line 16 of file sha1.c.

◆ SymCryptSha224Algorithm_default

const SYMCRYPT_HASH SymCryptSha224Algorithm_default

extern

Definition at line 19 of file sha256.c.

◆ SymCryptSha256Algorithm_default

const SYMCRYPT_HASH SymCryptSha256Algorithm_default

extern

Definition at line 32 of file sha256.c.

◆ SymCryptSha256KATAnswer

const BYTE SymCryptSha256KATAnswer[32]

extern

Definition at line 476 of file sha256.c.

Referenced by SymCryptSha256Selftest().

◆ SymCryptSha384Algorithm_default

const SYMCRYPT_HASH SymCryptSha384Algorithm_default

extern

Definition at line 117 of file sha512.c.

◆ SymCryptSha384KATAnswer

const BYTE SymCryptSha384KATAnswer[48]

extern

Definition at line 728 of file sha512.c.

Referenced by SymCryptSha384Selftest().

◆ SymCryptSha3_224Algorithm_default

const SYMCRYPT_HASH SymCryptSha3_224Algorithm_default

extern

Definition at line 14 of file sha3_224.c.

◆ SymCryptSha3_256Algorithm_default

const SYMCRYPT_HASH SymCryptSha3_256Algorithm_default

extern

Definition at line 14 of file sha3_256.c.

◆ SymCryptSha3_384Algorithm_default

const SYMCRYPT_HASH SymCryptSha3_384Algorithm_default

extern

Definition at line 14 of file sha3_384.c.

◆ SymCryptSha3_512Algorithm_default

const SYMCRYPT_HASH SymCryptSha3_512Algorithm_default

extern

Definition at line 14 of file sha3_512.c.

◆ SymCryptSha512_224Algorithm_default

const SYMCRYPT_HASH SymCryptSha512_224Algorithm_default

extern

Definition at line 143 of file sha512.c.

◆ SymCryptSha512_256Algorithm_default

const SYMCRYPT_HASH SymCryptSha512_256Algorithm_default

extern

Definition at line 156 of file sha512.c.

◆ SymCryptSha512Algorithm_default

const SYMCRYPT_HASH SymCryptSha512Algorithm_default

extern

Definition at line 130 of file sha512.c.

◆ SymCryptSha512KATAnswer

const BYTE SymCryptSha512KATAnswer[64]

extern

Definition at line 695 of file sha512.c.

Referenced by SymCryptSha512Selftest().

◆ SymCryptShake128HashAlgorithm_default

const SYMCRYPT_HASH SymCryptShake128HashAlgorithm_default

extern

Definition at line 28 of file shake.c.

◆ SymCryptShake256HashAlgorithm_default

const SYMCRYPT_HASH SymCryptShake256HashAlgorithm_default

extern

Definition at line 80 of file shake.c.

◆ SymCryptTestKey32

const BYTE SymCryptTestKey32[32]

extern

Definition at line 10 of file selftest.c.

◆ SymCryptTestMsg16

const BYTE SymCryptTestMsg16[16]

extern

Definition at line 15 of file selftest.c.

Referenced by SymCryptChaCha20Poly1305Selftest(), SymCryptChaCha20Selftest(), SymCryptKmac128Selftest(), SymCryptKmac256Selftest(), and SymCryptPoly1305Selftest().

◆ SymCryptTestMsg3

const BYTE SymCryptTestMsg3[3]

extern

Definition at line 8 of file selftest.c.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CHECK_ALGORITHM_INFO_FLAG_POW2

◆ CHECK_ALGORITHM_INFO_FLAGS_DISTINCT

◆ CONCAT2

◆ CONCAT3

◆ CONCAT_I2

◆ CONCAT_I3

◆ FALSE

◆ FAST_FAIL_CRYPTO_LIBRARY

◆ GCM_YMM_MINBLOCKS

◆ HMAC_IPAD_BYTE

◆ HMAC_OPAD_BYTE

◆ NATIVE_BITS

◆ NATIVE_BYTES

◆ NATIVE_BYTES_LOG2

◆ PAR_SCRATCH_ELEMENTS_256

◆ PAR_SCRATCH_ELEMENTS_512

◆ PCSYMCRYPT_HMAC_XXX_EXPANDED_KEY

◆ PCSYMCRYPT_HMAC_XXX_STATE

◆ PCSYMCRYPT_XXX_EXPANDED_KEY

◆ PCSYMCRYPT_XXX_STATE

◆ PSYMCRYPT_HMAC_XXX_EXPANDED_KEY

◆ PSYMCRYPT_HMAC_XXX_STATE

◆ PSYMCRYPT_XXX_EXPANDED_KEY

◆ PSYMCRYPT_XXX_STATE

◆ REPEAT_BYTE_TO_UINT32

◆ REPEAT_BYTE_TO_UINT64

◆ ROL16

◆ ROR16

◆ SYMCRYPT_ARRAY_SIZE

◆ SYMCRYPT_ASSERT_ASYM_ALIGNED

◆ SYMCRYPT_BLOB_MAGIC

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_CURVE_25519

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P256

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PRIVATE_KEY_P384

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_CURVE_25519

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P256

◆ SYMCRYPT_COMPOSITE_SIZEOF_ENCODED_EC_PUBLIC_KEY_P384

◆ SYMCRYPT_COMPOSITE_SIZEOF_MAX_ENCODED_EC_PUBLIC_KEY

◆ SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE

◆ SYMCRYPT_CPU_FEATURES_FOR_AESNI_PCLMULQDQ_CODE

◆ SYMCRYPT_CPU_FEATURES_FOR_MULX

◆ SYMCRYPT_CPU_FEATURES_FOR_PCLMULQDQ_CODE

◆ SYMCRYPT_CPU_FEATURES_FOR_SHANI_CODE

◆ SYMCRYPT_CPU_FEATURES_FOR_VAES_256_CODE

◆ SYMCRYPT_CPU_FEATURES_FOR_VAES_512_CODE

◆ SYMCRYPT_CPUID_DETECT_FLAG_CHECK_OS_SUPPORT_FOR_YMM

◆ SYMCRYPT_CSHAKE_PADDING_VALUE

◆ SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT

◆ SYMCRYPT_DISABLE_CFG

◆ SYMCRYPT_ECURVE_FUNCTIONS_SIZE

◆ SYMCRYPT_FDEF_DIGIT_NUINT32

◆ SYMCRYPT_FLAG_LIB_INITIALIZED

◆ SYMCRYPT_HMAC_XXX_INPUT_BLOCK_SIZE

◆ SYMCRYPT_HMAC_XXX_RESULT_SIZE

◆ SYMCRYPT_HMAC_XXX_STATE

◆ SYMCRYPT_HmacXxx

◆ SYMCRYPT_HmacXxxAppend

◆ SYMCRYPT_HmacXxxExpandKey

◆ SYMCRYPT_HmacXxxInit

◆ SYMCRYPT_HmacXxxKeyCopy

◆ SYMCRYPT_HmacXxxResult

◆ SYMCRYPT_HmacXxxStateCopy

◆ SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH

◆ SYMCRYPT_LMS_CHECKSUM_SIZE

◆ SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE

◆ SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT

◆ SYMCRYPT_LMS_MAX_H

◆ SYMCRYPT_LMS_MAX_N

◆ SYMCRYPT_LMS_MAX_P

◆ SYMCRYPT_LMS_PRIV_KEY_SIZE

◆ SYMCRYPT_LMS_PUB_KEY_SIZE

◆ SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS

◆ SYMCRYPT_MOD_CALL