ReactOS 0.4.17-dev-1005-g171e1de
Classes | Macros | Typedefs | Enumerations | Functions | Variables
symcrypt.h File Reference
#include "symcrypt_internal_shared.inc"
#include "symcrypt_internal.h"
Include dependency graph for symcrypt.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _SYMCRYPT_RSA_PARAMS
 
struct  _SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION
 
struct  _SYMCRYPT_ECURVE_PARAMS
 
struct  _SYMCRYPT_UINT32_MAP
 

Macros

#define SYMCRYPT_API_VERSION   ((SYMCRYPT_CODE_VERSION_API << 16) | SYMCRYPT_CODE_VERSION_MINOR)
 
#define _Return_type_success_(expr)
 
#define SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_DEFAULT   SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919
 
#define SYMCRYPT_LOAD_LSBFIRST16(p)   SYMCRYPT_INTERNAL_LOAD_LSBFIRST16( p )
 
#define SYMCRYPT_LOAD_LSBFIRST32(p)   SYMCRYPT_INTERNAL_LOAD_LSBFIRST32( p )
 
#define SYMCRYPT_LOAD_LSBFIRST64(p)   SYMCRYPT_INTERNAL_LOAD_LSBFIRST64( p )
 
#define SYMCRYPT_LOAD_MSBFIRST16(p)   SYMCRYPT_INTERNAL_LOAD_MSBFIRST16( p )
 
#define SYMCRYPT_LOAD_MSBFIRST32(p)   SYMCRYPT_INTERNAL_LOAD_MSBFIRST32( p )
 
#define SYMCRYPT_LOAD_MSBFIRST64(p)   SYMCRYPT_INTERNAL_LOAD_MSBFIRST64( p )
 
#define SYMCRYPT_STORE_LSBFIRST16(p, v)   SYMCRYPT_INTERNAL_STORE_LSBFIRST16( p, v )
 
#define SYMCRYPT_STORE_LSBFIRST32(p, v)   SYMCRYPT_INTERNAL_STORE_LSBFIRST32( p, v )
 
#define SYMCRYPT_STORE_LSBFIRST64(p, v)   SYMCRYPT_INTERNAL_STORE_LSBFIRST64( p, v )
 
#define SYMCRYPT_STORE_MSBFIRST16(p, v)   SYMCRYPT_INTERNAL_STORE_MSBFIRST16( p, v )
 
#define SYMCRYPT_STORE_MSBFIRST32(p, v)   SYMCRYPT_INTERNAL_STORE_MSBFIRST32( p, v )
 
#define SYMCRYPT_STORE_MSBFIRST64(p, v)   SYMCRYPT_INTERNAL_STORE_MSBFIRST64( p, v )
 
#define SYMCRYPT_FORCE_READ8( _p)   SYMCRYPT_INTERNAL_FORCE_READ8( _p )
 
#define SYMCRYPT_FORCE_READ16(_p)   SYMCRYPT_INTERNAL_FORCE_READ16( _p )
 
#define SYMCRYPT_FORCE_READ32(_p)   SYMCRYPT_INTERNAL_FORCE_READ32( _p )
 
#define SYMCRYPT_FORCE_READ64(_p)   SYMCRYPT_INTERNAL_FORCE_READ64( _p )
 
#define SYMCRYPT_FORCE_WRITE8( _p, _v)   SYMCRYPT_INTERNAL_FORCE_WRITE8( _p, _v )
 
#define SYMCRYPT_FORCE_WRITE16(_p, _v)   SYMCRYPT_INTERNAL_FORCE_WRITE16( _p, _v )
 
#define SYMCRYPT_FORCE_WRITE32(_p, _v)   SYMCRYPT_INTERNAL_FORCE_WRITE32( _p, _v )
 
#define SYMCRYPT_FORCE_WRITE64(_p, _v)   SYMCRYPT_INTERNAL_FORCE_WRITE64( _p, _v )
 
#define SYMCRYPT_MODULE_INIT()   SymCryptModuleInit( SYMCRYPT_CODE_VERSION_API, SYMCRYPT_CODE_VERSION_MINOR );
 
#define SYMCRYPT_MD2_RESULT_SIZE   (16)
 
#define SYMCRYPT_MD2_INPUT_BLOCK_SIZE   (16)
 
#define SYMCRYPT_MD4_RESULT_SIZE   (16)
 
#define SYMCRYPT_MD4_INPUT_BLOCK_SIZE   (64)
 
#define SYMCRYPT_MD5_RESULT_SIZE   (16)
 
#define SYMCRYPT_MD5_INPUT_BLOCK_SIZE   (64)
 
#define SYMCRYPT_SHA1_RESULT_SIZE   (20)
 
#define SYMCRYPT_SHA1_INPUT_BLOCK_SIZE   (64)
 
#define SYMCRYPT_SHA224_RESULT_SIZE   (28)
 
#define SYMCRYPT_SHA224_INPUT_BLOCK_SIZE   (64)
 
#define SYMCRYPT_SHA256_RESULT_SIZE   (32)
 
#define SYMCRYPT_SHA256_INPUT_BLOCK_SIZE   (64)
 
#define SYMCRYPT_SHA384_RESULT_SIZE   (48)
 
#define SYMCRYPT_SHA384_INPUT_BLOCK_SIZE   (128)
 
#define SYMCRYPT_SHA512_RESULT_SIZE   (64)
 
#define SYMCRYPT_SHA512_INPUT_BLOCK_SIZE   (128)
 
#define SYMCRYPT_SHA512_224_RESULT_SIZE   (28)
 
#define SYMCRYPT_SHA512_224_INPUT_BLOCK_SIZE   (128)
 
#define SYMCRYPT_SHA512_256_RESULT_SIZE   (32)
 
#define SYMCRYPT_SHA512_256_INPUT_BLOCK_SIZE   (128)
 
#define SYMCRYPT_SHA3_224_RESULT_SIZE   (28)
 
#define SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE   (144)
 
#define SYMCRYPT_SHA3_256_RESULT_SIZE   (32)
 
#define SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE   (136)
 
#define SYMCRYPT_SHA3_384_RESULT_SIZE   (48)
 
#define SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE   (104)
 
#define SYMCRYPT_SHA3_512_RESULT_SIZE   (64)
 
#define SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE   (72)
 
#define SYMCRYPT_SHAKE128_RESULT_SIZE   (32)
 
#define SYMCRYPT_SHAKE128_INPUT_BLOCK_SIZE   (168)
 
#define SYMCRYPT_SHAKE256_RESULT_SIZE   (64)
 
#define SYMCRYPT_SHAKE256_INPUT_BLOCK_SIZE   (136)
 
#define SYMCRYPT_CSHAKE128_RESULT_SIZE   SYMCRYPT_SHAKE128_RESULT_SIZE
 
#define SYMCRYPT_CSHAKE128_INPUT_BLOCK_SIZE   SYMCRYPT_SHAKE128_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_CSHAKE256_RESULT_SIZE   SYMCRYPT_SHAKE256_RESULT_SIZE
 
#define SYMCRYPT_CSHAKE256_INPUT_BLOCK_SIZE   SYMCRYPT_SHAKE256_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_MD5_RESULT_SIZE   SYMCRYPT_MD5_RESULT_SIZE
 
#define SYMCRYPT_HMAC_MD5_INPUT_BLOCK_SIZE   SYMCRYPT_MD5_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA1_RESULT_SIZE   SYMCRYPT_SHA1_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA1_INPUT_BLOCK_SIZE   SYMCRYPT_SHA1_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA224_RESULT_SIZE   SYMCRYPT_SHA224_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA224_INPUT_BLOCK_SIZE   SYMCRYPT_SHA224_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA256_RESULT_SIZE   SYMCRYPT_SHA256_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA256_INPUT_BLOCK_SIZE   SYMCRYPT_SHA256_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA384_RESULT_SIZE   SYMCRYPT_SHA384_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA384_INPUT_BLOCK_SIZE   SYMCRYPT_SHA384_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA512_RESULT_SIZE   SYMCRYPT_SHA512_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA512_INPUT_BLOCK_SIZE   SYMCRYPT_SHA512_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE   SYMCRYPT_SHA512_224_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA512_224_INPUT_BLOCK_SIZE   SYMCRYPT_SHA512_224_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE   SYMCRYPT_SHA512_256_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA512_256_INPUT_BLOCK_SIZE   SYMCRYPT_SHA512_256_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE   SYMCRYPT_SHA3_224_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA3_224_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE   SYMCRYPT_SHA3_256_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA3_256_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE   SYMCRYPT_SHA3_384_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA3_384_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE   SYMCRYPT_SHA3_512_RESULT_SIZE
 
#define SYMCRYPT_HMAC_SHA3_512_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_AES_CMAC_RESULT_SIZE   (16)
 
#define SYMCRYPT_AES_CMAC_INPUT_BLOCK_SIZE   (16)
 
#define SYMCRYPT_KMAC128_RESULT_SIZE   SYMCRYPT_CSHAKE128_RESULT_SIZE
 
#define SYMCRYPT_KMAC128_INPUT_BLOCK_SIZE   SYMCRYPT_CSHAKE128_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_KMAC256_RESULT_SIZE   SYMCRYPT_CSHAKE256_RESULT_SIZE
 
#define SYMCRYPT_KMAC256_INPUT_BLOCK_SIZE   SYMCRYPT_CSHAKE256_INPUT_BLOCK_SIZE
 
#define SYMCRYPT_POLY1305_RESULT_SIZE   (16)
 
#define SYMCRYPT_POLY1305_BLOCK_SIZE   (16)
 
#define SYMCRYPT_POLY1305_KEY_SIZE   (32)
 
#define SYMCRYPT_MARVIN32_RESULT_SIZE   (8)
 
#define SYMCRYPT_MARVIN32_SEED_SIZE   (8)
 
#define SYMCRYPT_MARVIN32_INPUT_BLOCK_SIZE   (4)
 
#define SYMCRYPT_AES_BLOCK_SIZE   (16)
 
#define SYMCRYPT_AES_SELFTEST_BASE   0x01
 
#define SYMCRYPT_AES_SELFTEST_ECB   0x02
 
#define SYMCRYPT_AES_SELFTEST_CBC   0x04
 
#define SYMCRYPT_AES_SELFTEST_CBCMAC   0x08
 
#define SYMCRYPT_AES_SELFTEST_CTR   0x10
 
#define SYMCRYPT_AES_SELFTEST_ALL   0x1f
 
#define SYMCRYPT_DES_BLOCK_SIZE   (8)
 
#define SYMCRYPT_3DES_BLOCK_SIZE   (8)
 
#define SYMCRYPT_DESX_BLOCK_SIZE   (8)
 
#define SYMCRYPT_RC2_BLOCK_SIZE   (8)
 
#define SYMCRYPT_TLS_MAX_LABEL_SIZE   256
 
#define SYMCRYPT_TLS_MAX_SEED_SIZE   256
 
#define SYMCRYPT_SSHKDF_IV_CLIENT_TO_SERVER   0x41
 
#define SYMCRYPT_SSHKDF_IV_SERVER_TO_CLIENT   0x42
 
#define SYMCRYPT_SSHKDF_ENCRYPTION_KEY_CLIENT_TO_SERVER   0x43
 
#define SYMCRYPT_SSHKDF_ENCRYPTION_KEY_SERVER_TO_CLIENT   0x44
 
#define SYMCRYPT_SSHKDF_INTEGRITY_KEY_CLIENT_TO_SERVER   0x45
 
#define SYMCRYPT_SSHKDF_INTEGRITY_KEY_SERVER_TO_CLIENT   0x46
 
#define SYMCRYPT_SRTP_ENCRYPTION_KEY   0x00
 
#define SYMCRYPT_SRTP_AUTHENTICATION_KEY   0x01
 
#define SYMCRYPT_SRTP_SALTING_KEY   0x02
 
#define SYMCRYPT_SRTCP_ENCRYPTION_KEY   0x03
 
#define SYMCRYPT_SRTCP_AUTHENTICATION_KEY   0x04
 
#define SYMCRYPT_SRTCP_SALTING_KEY   0x05
 
#define SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE   (32 + 16)
 
#define SYMCRYPT_RNG_AES_MIN_RESEED_SIZE   (32)
 
#define SYMCRYPT_RNG_AES_MAX_SEED_SIZE   (256)
 
#define SYMCRYPT_SIZEOF_RSAKEY_FROM_PARAMS(modBits, nPrimes, nPubExps)    SYMCRYPT_INTERNAL_SIZEOF_RSAKEY_FROM_PARAMS( modBits, nPrimes, nPubExps )
 
#define SYMCRYPT_FLAG_KEY_NO_FIPS   (0x100)
 
#define SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION   (0x200)
 
#define SYMCRYPT_FLAG_DLKEY_DSA   (0x1000)
 
#define SYMCRYPT_FLAG_DLKEY_DH   (0x2000)
 
#define SYMCRYPT_FLAG_ECKEY_ECDSA   (0x1000)
 
#define SYMCRYPT_FLAG_ECKEY_ECDH   (0x2000)
 
#define SYMCRYPT_FLAG_RSAKEY_SIGN   (0x1000)
 
#define SYMCRYPT_FLAG_RSAKEY_ENCRYPT   (0x2000)
 
#define SYMCRYPT_DLGROUP_FIPS_LATEST   (SYMCRYPT_DLGROUP_FIPS_186_3)
 
#define SYMCRYPT_FLAG_DLKEY_GEN_MODP   (0x01)
 
#define SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION   (0x08)
 
#define SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1   (0x01)
 
#define SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID   (0x02)
 
#define SYMCRYPT_FLAG_RSA_PSS_VERIFY_WITH_MINIMUM_SALT   (0x04)
 
#define SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT   (0x00000001)
 
#define SYMCRYPT_FLAG_LMSKEY_VERIFY_ROOT   (0x00000001)
 
#define SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE   (2*32)
 
#define SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM512   (800)
 
#define SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM768   (1184)
 
#define SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM1024   (1568)
 
#define SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM512   (1632)
 
#define SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM768   (2400)
 
#define SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM1024   (3168)
 
#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM512   (768)
 
#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM768   (1088)
 
#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM1024   (1568)
 
#define SYMCRYPT_COMPOSITE_MLKEM_IRTF_PRIVATE_SEED_SIZE   (32)
 
#define SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM768_P256   (115)
 
#define SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM768_X25519   (96)
 
#define SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM1024_P384   (128)
 
#define SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM768_P256   (1249)
 
#define SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM768_X25519   (1216)
 
#define SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM1024_P384   (1665)
 
#define SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM768_P256   (1153)
 
#define SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM768_X25519   (1120)
 
#define SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM1024_P384   (1665)
 
#define SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH   (255)
 
#define SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA44   (2420)
 
#define SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA65   (3309)
 
#define SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA87   (4627)
 
#define SYMCRYPT_ASSERT(_x)    _Analysis_assume_( _x )
 

Typedefs

typedef enum _SYMCRYPT_ECURVE_TYPE SYMCRYPT_ECURVE_TYPE
 
typedef enum _SYMCRYPT_DLGROUP_FIPS SYMCRYPT_DLGROUP_FIPS
 
typedef enum _SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE
 
typedef enum _SYMCRYPT_HASH_ID SYMCRYPT_HASH_ID
 
typedef enum _SYMCRYPT_MAC_ID SYMCRYPT_MAC_ID
 
typedef enum _SYMCRYPT_BLOCKCIPHER_ID SYMCRYPT_BLOCKCIPHER_ID
 
typedef enum _SYMCRYPT_NUMBER_FORMAT SYMCRYPT_NUMBER_FORMAT
 
typedef struct _SYMCRYPT_RSA_PARAMS SYMCRYPT_RSA_PARAMS
 
typedef struct _SYMCRYPT_RSA_PARAMS * PSYMCRYPT_RSA_PARAMS
 
typedef const SYMCRYPT_RSA_PARAMS * PCSYMCRYPT_RSA_PARAMS
 
typedef enum _SYMCRYPT_ECURVE_GEN_ALG_ID SYMCRYPT_ECURVE_GEN_ALG_ID
 
typedef struct _SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION
 
typedef struct _SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION * PSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION
 
typedef const SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION * PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION
 
typedef enum _SYMCRYPT_ECKEY_PRIVATE_FORMAT SYMCRYPT_ECKEY_PRIVATE_FORMAT
 
typedef struct _SYMCRYPT_ECURVE_PARAMS SYMCRYPT_ECURVE_PARAMS
 
typedef struct _SYMCRYPT_ECURVE_PARAMS * PSYMCRYPT_ECURVE_PARAMS
 
typedef const SYMCRYPT_ECURVE_PARAMS * PCSYMCRYPT_ECURVE_PARAMS
 
typedef enum _SYMCRYPT_ECPOINT_FORMAT SYMCRYPT_ECPOINT_FORMAT
 
typedef enum _SYMCRYPT_ECURVE_ID SYMCRYPT_ECURVE_ID
 
typedef enum _SYMCRYPT_XMSS_ALGID SYMCRYPT_XMSS_ALGID
 
typedef enum _SYMCRYPT_XMSSMT_ALGID SYMCRYPT_XMSSMT_ALGID
 
typedef enum _SYMCRYPT_XMSSKEY_TYPE SYMCRYPT_XMSSKEY_TYPE
 
typedef enum _SYMCRYPT_LMS_ALGID SYMCRYPT_LMS_ALGID
 
typedef enum _SYMCRYPT_LMS_OTS_ALGID SYMCRYPT_LMS_OTS_ALGID
 
typedef enum _SYMCRYPT_LMSKEY_TYPE SYMCRYPT_LMSKEY_TYPE
 
typedef enum _SYMCRYPT_MLKEMKEY_FORMAT SYMCRYPT_MLKEMKEY_FORMAT
 
typedef enum _SYMCRYPT_MLKEM_PARAMS SYMCRYPT_MLKEM_PARAMS
 
typedef enum _SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT
 
typedef enum _SYMCRYPT_COMPOSITE_MLKEM_PARAMS SYMCRYPT_COMPOSITE_MLKEM_PARAMS
 
typedef enum _SYMCRYPT_MLDSAKEY_FORMAT SYMCRYPT_MLDSAKEY_FORMAT
 
typedef enum _SYMCRYPT_MLDSA_PARAMS SYMCRYPT_MLDSA_PARAMS
 
typedef enum _SYMCRYPT_PQDSA_HASH_ID SYMCRYPT_PQDSA_HASH_ID
 
typedef struct _SYMCRYPT_UINT32_MAP SYMCRYPT_UINT32_MAP
 
typedef struct _SYMCRYPT_UINT32_MAP * PSYMCRYPT_UINT32_MAP
 
typedef const SYMCRYPT_UINT32_MAP * PCSYMCRYPT_UINT32_MAP
 

Enumerations

enum  _SYMCRYPT_ECURVE_TYPE { SYMCRYPT_ECURVE_TYPE_NULL = 0 , SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS = 1 , SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS = 2 , SYMCRYPT_ECURVE_TYPE_MONTGOMERY = 3 }
 
enum  _SYMCRYPT_DLGROUP_FIPS { SYMCRYPT_DLGROUP_FIPS_NONE = 0 , SYMCRYPT_DLGROUP_FIPS_186_2 = 1 , SYMCRYPT_DLGROUP_FIPS_186_3 = 2 }
 
enum  _SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE { SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_NONE = 0 , SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_IKE_3526 = 1 , SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919 = 2 }
 
enum  _SYMCRYPT_HASH_ID {
  SYMCRYPT_HASH_ID_NULL = 0 , SYMCRYPT_HASH_ID_MD2 = 1 , SYMCRYPT_HASH_ID_MD4 = 2 , SYMCRYPT_HASH_ID_MD5 = 3 ,
  SYMCRYPT_HASH_ID_SHA1 = 4 , SYMCRYPT_HASH_ID_SHA224 = 5 , SYMCRYPT_HASH_ID_SHA256 = 6 , SYMCRYPT_HASH_ID_SHA384 = 7 ,
  SYMCRYPT_HASH_ID_SHA512 = 8 , SYMCRYPT_HASH_ID_SHA512_224 = 9 , SYMCRYPT_HASH_ID_SHA512_256 = 10 , SYMCRYPT_HASH_ID_SHA3_224 = 11 ,
  SYMCRYPT_HASH_ID_SHA3_256 = 12 , SYMCRYPT_HASH_ID_SHA3_384 = 13 , SYMCRYPT_HASH_ID_SHA3_512 = 14 , SYMCRYPT_HASH_ID_SHAKE128 = 15 ,
  SYMCRYPT_HASH_ID_SHAKE256 = 16
}
 
enum  _SYMCRYPT_MAC_ID {
  SYMCRYPT_MAC_ID_NULL = 0 , SYMCRYPT_MAC_ID_HMAC_MD5 = 1 , SYMCRYPT_MAC_ID_HMAC_SHA1 = 2 , SYMCRYPT_MAC_ID_HMAC_SHA224 = 3 ,
  SYMCRYPT_MAC_ID_HMAC_SHA256 = 4 , SYMCRYPT_MAC_ID_HMAC_SHA384 = 5 , SYMCRYPT_MAC_ID_HMAC_SHA512 = 6 , SYMCRYPT_MAC_ID_HMAC_SHA512_224 = 7 ,
  SYMCRYPT_MAC_ID_HMAC_SHA512_256 = 8 , SYMCRYPT_MAC_ID_HMAC_SHA3_224 = 9 , SYMCRYPT_MAC_ID_HMAC_SHA3_256 = 10 , SYMCRYPT_MAC_ID_HMAC_SHA3_384 = 11 ,
  SYMCRYPT_MAC_ID_HMAC_SHA3_512 = 12 , SYMCRYPT_MAC_ID_AES_CMAC = 13 , SYMCRYPT_MAC_ID_KMAC_128 = 14 , SYMCRYPT_MAC_ID_KMAC_256 = 15
}
 
enum  _SYMCRYPT_BLOCKCIPHER_ID {
  SYMCRYPT_BLOCKCIPHER_ID_NULL = 0 , SYMCRYPT_BLOCKCIPHER_ID_AES = 1 , SYMCRYPT_BLOCKCIPHER_ID_DES = 2 , SYMCRYPT_BLOCKCIPHER_ID_3DES = 3 ,
  SYMCRYPT_BLOCKCIPHER_ID_DESX = 4 , SYMCRYPT_BLOCKCIPHER_ID_RC2 = 5
}
 
enum  _SYMCRYPT_NUMBER_FORMAT { SYMCRYPT_NUMBER_FORMAT_LSB_FIRST = 1 , SYMCRYPT_NUMBER_FORMAT_MSB_FIRST = 2 }
 
enum  _SYMCRYPT_ECURVE_GEN_ALG_ID { SYMCRYPT_ECURVE_GEN_ALG_ID_NULL = 0 }
 
enum  _SYMCRYPT_ECKEY_PRIVATE_FORMAT { SYMCRYPT_ECKEY_PRIVATE_FORMAT_NULL = 0 , SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL = 1 , SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH = 2 , SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH = 3 }
 
enum  _SYMCRYPT_ECPOINT_FORMAT { SYMCRYPT_ECPOINT_FORMAT_X = 1 , SYMCRYPT_ECPOINT_FORMAT_XY = 2 }
 
enum  _SYMCRYPT_ECURVE_ID {
  SYMCRYPT_ECURVE_ID_NULL = 0 , SYMCRYPT_ECURVE_ID_NIST_P192 = 1 , SYMCRYPT_ECURVE_ID_NIST_P224 = 2 , SYMCRYPT_ECURVE_ID_NIST_P256 = 3 ,
  SYMCRYPT_ECURVE_ID_NIST_P384 = 4 , SYMCRYPT_ECURVE_ID_NIST_P521 = 5 , SYMCRYPT_ECURVE_ID_NUMS_P256T1 = 6 , SYMCRYPT_ECURVE_ID_NUMS_P384T1 = 7 ,
  SYMCRYPT_ECURVE_ID_NUMS_P512T1 = 8 , SYMCRYPT_ECURVE_ID_CURVE25519 = 9
}
 
enum  _SYMCRYPT_XMSS_ALGID {
  SYMCRYPT_XMSS_SHA2_10_256 = 0x00000001 , SYMCRYPT_XMSS_SHA2_16_256 = 0x00000002 , SYMCRYPT_XMSS_SHA2_20_256 = 0x00000003 , SYMCRYPT_XMSS_SHA2_10_512 = 0x00000004 ,
  SYMCRYPT_XMSS_SHA2_16_512 = 0x00000005 , SYMCRYPT_XMSS_SHA2_20_512 = 0x00000006 , SYMCRYPT_XMSS_SHAKE_10_256 = 0x00000007 , SYMCRYPT_XMSS_SHAKE_16_256 = 0x00000008 ,
  SYMCRYPT_XMSS_SHAKE_20_256 = 0x00000009 , SYMCRYPT_XMSS_SHAKE_10_512 = 0x0000000A , SYMCRYPT_XMSS_SHAKE_16_512 = 0x0000000B , SYMCRYPT_XMSS_SHAKE_20_512 = 0x0000000C ,
  SYMCRYPT_XMSS_SHA2_10_192 = 0x0000000D , SYMCRYPT_XMSS_SHA2_16_192 = 0x0000000E , SYMCRYPT_XMSS_SHA2_20_192 = 0x0000000F , SYMCRYPT_XMSS_SHAKE256_10_256 = 0x00000010 ,
  SYMCRYPT_XMSS_SHAKE256_16_256 = 0x00000011 , SYMCRYPT_XMSS_SHAKE256_20_256 = 0x00000012 , SYMCRYPT_XMSS_SHAKE256_10_192 = 0x00000013 , SYMCRYPT_XMSS_SHAKE256_16_192 = 0x00000014 ,
  SYMCRYPT_XMSS_SHAKE256_20_192 = 0x00000015
}
 
enum  _SYMCRYPT_XMSSMT_ALGID {
  SYMCRYPT_XMSSMT_SHA2_20_2_256 = 0x00000001 , SYMCRYPT_XMSSMT_SHA2_20_4_256 = 0x00000002 , SYMCRYPT_XMSSMT_SHA2_40_2_256 = 0x00000003 , SYMCRYPT_XMSSMT_SHA2_40_4_256 = 0x00000004 ,
  SYMCRYPT_XMSSMT_SHA2_40_8_256 = 0x00000005 , SYMCRYPT_XMSSMT_SHA2_60_3_256 = 0x00000006 , SYMCRYPT_XMSSMT_SHA2_60_6_256 = 0x00000007 , SYMCRYPT_XMSSMT_SHA2_60_12_256 = 0x00000008 ,
  SYMCRYPT_XMSSMT_SHA2_20_2_512 = 0x00000009 , SYMCRYPT_XMSSMT_SHA2_20_4_512 = 0x0000000A , SYMCRYPT_XMSSMT_SHA2_40_2_512 = 0x0000000B , SYMCRYPT_XMSSMT_SHA2_40_4_512 = 0x0000000C ,
  SYMCRYPT_XMSSMT_SHA2_40_8_512 = 0x0000000D , SYMCRYPT_XMSSMT_SHA2_60_3_512 = 0x0000000E , SYMCRYPT_XMSSMT_SHA2_60_6_512 = 0x0000000F , SYMCRYPT_XMSSMT_SHA2_60_12_512 = 0x00000010 ,
  SYMCRYPT_XMSSMT_SHAKE_20_2_256 = 0x00000011 , SYMCRYPT_XMSSMT_SHAKE_20_4_256 = 0x00000012 , SYMCRYPT_XMSSMT_SHAKE_40_2_256 = 0x00000013 , SYMCRYPT_XMSSMT_SHAKE_40_4_256 = 0x00000014 ,
  SYMCRYPT_XMSSMT_SHAKE_40_8_256 = 0x00000015 , SYMCRYPT_XMSSMT_SHAKE_60_3_256 = 0x00000016 , SYMCRYPT_XMSSMT_SHAKE_60_6_256 = 0x00000017 , SYMCRYPT_XMSSMT_SHAKE_60_12_256 = 0x00000018 ,
  SYMCRYPT_XMSSMT_SHAKE_20_2_512 = 0x00000019 , SYMCRYPT_XMSSMT_SHAKE_20_4_512 = 0x0000001A , SYMCRYPT_XMSSMT_SHAKE_40_2_512 = 0x0000001B , SYMCRYPT_XMSSMT_SHAKE_40_4_512 = 0x0000001C ,
  SYMCRYPT_XMSSMT_SHAKE_40_8_512 = 0x0000001D , SYMCRYPT_XMSSMT_SHAKE_60_3_512 = 0x0000001E , SYMCRYPT_XMSSMT_SHAKE_60_6_512 = 0x0000001F , SYMCRYPT_XMSSMT_SHAKE_60_12_512 = 0x00000020 ,
  SYMCRYPT_XMSSMT_SHA2_20_2_192 = 0x00000021 , SYMCRYPT_XMSSMT_SHA2_20_4_192 = 0x00000022 , SYMCRYPT_XMSSMT_SHA2_40_2_192 = 0x00000023 , SYMCRYPT_XMSSMT_SHA2_40_4_192 = 0x00000024 ,
  SYMCRYPT_XMSSMT_SHA2_40_8_192 = 0x00000025 , SYMCRYPT_XMSSMT_SHA2_60_3_192 = 0x00000026 , SYMCRYPT_XMSSMT_SHA2_60_6_192 = 0x00000027 , SYMCRYPT_XMSSMT_SHA2_60_12_192 = 0x00000028 ,
  SYMCRYPT_XMSSMT_SHAKE256_20_2_256 = 0x00000029 , SYMCRYPT_XMSSMT_SHAKE256_20_4_256 = 0x0000002A , SYMCRYPT_XMSSMT_SHAKE256_40_2_256 = 0x0000002B , SYMCRYPT_XMSSMT_SHAKE256_40_4_256 = 0x0000002C ,
  SYMCRYPT_XMSSMT_SHAKE256_40_8_256 = 0x0000002D , SYMCRYPT_XMSSMT_SHAKE256_60_3_256 = 0x0000002E , SYMCRYPT_XMSSMT_SHAKE256_60_6_256 = 0x0000002F , SYMCRYPT_XMSSMT_SHAKE256_60_12_256 = 0x00000030 ,
  SYMCRYPT_XMSSMT_SHAKE256_20_2_192 = 0x00000031 , SYMCRYPT_XMSSMT_SHAKE256_20_4_192 = 0x00000032 , SYMCRYPT_XMSSMT_SHAKE256_40_2_192 = 0x00000033 , SYMCRYPT_XMSSMT_SHAKE256_40_4_192 = 0x00000034 ,
  SYMCRYPT_XMSSMT_SHAKE256_40_8_192 = 0x00000035 , SYMCRYPT_XMSSMT_SHAKE256_60_3_192 = 0x00000036 , SYMCRYPT_XMSSMT_SHAKE256_60_6_192 = 0x00000037 , SYMCRYPT_XMSSMT_SHAKE256_60_12_192 = 0x00000038
}
 
enum  _SYMCRYPT_XMSSKEY_TYPE { SYMCRYPT_XMSSKEY_TYPE_NONE = 0 , SYMCRYPT_XMSSKEY_TYPE_PUBLIC = 1 , SYMCRYPT_XMSSKEY_TYPE_PRIVATE = 2 }
 
enum  _SYMCRYPT_LMS_ALGID {
  SYMCRYPT_LMS_SHA256_M32_H5 = 0x00000005 , SYMCRYPT_LMS_SHA256_M32_H10 = 0x00000006 , SYMCRYPT_LMS_SHA256_M32_H15 = 0x00000007 , SYMCRYPT_LMS_SHA256_M32_H20 = 0x00000008 ,
  SYMCRYPT_LMS_SHA256_M32_H25 = 0x00000009 , SYMCRYPT_LMS_SHA256_M24_H5 = 0x0000000A , SYMCRYPT_LMS_SHA256_M24_H10 = 0x0000000B , SYMCRYPT_LMS_SHA256_M24_H15 = 0x0000000C ,
  SYMCRYPT_LMS_SHA256_M24_H20 = 0x0000000D , SYMCRYPT_LMS_SHA256_M24_H25 = 0x0000000E , SYMCRYPT_LMS_SHAKE_M32_H5 = 0x0000000F , SYMCRYPT_LMS_SHAKE_M32_H10 = 0x00000010 ,
  SYMCRYPT_LMS_SHAKE_M32_H15 = 0x00000011 , SYMCRYPT_LMS_SHAKE_M32_H20 = 0x00000012 , SYMCRYPT_LMS_SHAKE_M32_H25 = 0x00000013 , SYMCRYPT_LMS_SHAKE_M24_H5 = 0x00000014 ,
  SYMCRYPT_LMS_SHAKE_M24_H10 = 0x00000015 , SYMCRYPT_LMS_SHAKE_M24_H15 = 0x00000016 , SYMCRYPT_LMS_SHAKE_M24_H20 = 0x00000017 , SYMCRYPT_LMS_SHAKE_M24_H25 = 0x00000018
}
 
enum  _SYMCRYPT_LMS_OTS_ALGID {
  SYMCRYPT_LMS_OTS_SHA256_N32_W1 = 0x00000001 , SYMCRYPT_LMS_OTS_SHA256_N32_W2 = 0x00000002 , SYMCRYPT_LMS_OTS_SHA256_N32_W4 = 0x00000003 , SYMCRYPT_LMS_OTS_SHA256_N32_W8 = 0x00000004 ,
  SYMCRYPT_LMS_OTS_SHA256_N24_W1 = 0x00000005 , SYMCRYPT_LMS_OTS_SHA256_N24_W2 = 0x00000006 , SYMCRYPT_LMS_OTS_SHA256_N24_W4 = 0x00000007 , SYMCRYPT_LMS_OTS_SHA256_N24_W8 = 0x00000008 ,
  SYMCRYPT_LMS_OTS_SHAKE_N32_W1 = 0x00000009 , SYMCRYPT_LMS_OTS_SHAKE_N32_W2 = 0x0000000A , SYMCRYPT_LMS_OTS_SHAKE_N32_W4 = 0x0000000B , SYMCRYPT_LMS_OTS_SHAKE_N32_W8 = 0x0000000C ,
  SYMCRYPT_LMS_OTS_SHAKE_N24_W1 = 0x0000000D , SYMCRYPT_LMS_OTS_SHAKE_N24_W2 = 0x0000000E , SYMCRYPT_LMS_OTS_SHAKE_N24_W4 = 0x0000000F , SYMCRYPT_LMS_OTS_SHAKE_N24_W8 = 0x00000010
}
 
enum  _SYMCRYPT_LMSKEY_TYPE { SYMCRYPT_LMSKEY_TYPE_NONE = 0 , SYMCRYPT_LMSKEY_TYPE_PUBLIC = 1 , SYMCRYPT_LMSKEY_TYPE_PRIVATE = 2 }
 
enum  _SYMCRYPT_MLKEMKEY_FORMAT { SYMCRYPT_MLKEMKEY_FORMAT_NULL = 0 , SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED = 1 , SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY = 2 , SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY = 3 }
 
enum  _SYMCRYPT_MLKEM_PARAMS { SYMCRYPT_MLKEM_PARAMS_NULL = 0 , SYMCRYPT_MLKEM_PARAMS_MLKEM512 = 1 , SYMCRYPT_MLKEM_PARAMS_MLKEM768 = 2 , SYMCRYPT_MLKEM_PARAMS_MLKEM1024 = 3 }
 
enum  _SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT { SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_NULL = 0 , SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_IRTF_PRIVATE_SEED = 1 , SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_LAMPS_PRIVATE_KEY = 2 , SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_PUBLIC_KEY = 3 }
 
enum  _SYMCRYPT_COMPOSITE_MLKEM_PARAMS { SYMCRYPT_COMPOSITE_MLKEM_PARAMS_NULL = 0 , SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_P256 = 1 , SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_X25519 = 2 , SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM1024_P384 = 3 }
 
enum  _SYMCRYPT_MLDSAKEY_FORMAT { SYMCRYPT_MLDSAKEY_FORMAT_NULL = 0 , SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_SEED = 1 , SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_KEY = 2 , SYMCRYPT_MLDSAKEY_FORMAT_PUBLIC_KEY = 3 }
 
enum  _SYMCRYPT_MLDSA_PARAMS { SYMCRYPT_MLDSA_PARAMS_NULL = 0 , SYMCRYPT_MLDSA_PARAMS_MLDSA44 = 1 , SYMCRYPT_MLDSA_PARAMS_MLDSA65 = 2 , SYMCRYPT_MLDSA_PARAMS_MLDSA87 = 3 }
 
enum  _SYMCRYPT_PQDSA_HASH_ID {
  SYMCRYPT_PQDSA_HASH_ID_NULL = 0 , SYMCRYPT_PQDSA_HASH_ID_SHA256 = 1 , SYMCRYPT_PQDSA_HASH_ID_SHA384 = 2 , SYMCRYPT_PQDSA_HASH_ID_SHA512 = 3 ,
  SYMCRYPT_PQDSA_HASH_ID_SHA512_256 = 4 , SYMCRYPT_PQDSA_HASH_ID_SHA3_256 = 5 , SYMCRYPT_PQDSA_HASH_ID_SHA3_384 = 6 , SYMCRYPT_PQDSA_HASH_ID_SHA3_512 = 7 ,
  SYMCRYPT_PQDSA_HASH_ID_SHAKE128 = 8 , SYMCRYPT_PQDSA_HASH_ID_SHAKE256 = 9
}
 

Functions

typedef _Return_type_success_ (return==SYMCRYPT_NO_ERROR) enum
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadLsbFirstUint32 (_In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_ PUINT32 pDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadLsbFirstUint64 (_In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_ PUINT64 pDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadMsbFirstUint32 (_In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_ PUINT32 pDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadMsbFirstUint64 (_In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_ PUINT64 pDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreLsbFirstUint32 (UINT32 src, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreLsbFirstUint64 (UINT64 src, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreMsbFirstUint32 (UINT32 src, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreMsbFirstUint64 (UINT64 src, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
 
UINT32 SymCryptUint32Bitsize (UINT32 value)
 
UINT32 SymCryptUint64Bitsize (UINT64 value)
 
UINT32 SymCryptUint32Bytesize (UINT32 value)
 
UINT32 SymCryptUint64Bytesize (UINT64 value)
 
VOID SYMCRYPT_CALL SymCryptInit (void)
 
VOID SYMCRYPT_CALL SymCryptModuleInit (_In_ UINT32 api, _In_ UINT32 minor)
 
VOID SYMCRYPT_CALL SymCryptWipe (_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
 
FORCEINLINE VOID SYMCRYPT_CALL SymCryptWipeKnownSize (_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptXorBytes (_In_reads_(cbBytes) PCBYTE pbSrc1, _In_reads_(cbBytes) PCBYTE pbSrc2, _Out_writes_(cbBytes) PBYTE pbResult, SIZE_T cbBytes)
 
BOOLEAN SYMCRYPT_CALL SymCryptEqual (_In_reads_(cbBytes) PCBYTE pbSrc1, _In_reads_(cbBytes) PCBYTE pbSrc2, SIZE_T cbBytes)
 
PCSYMCRYPT_HASH SYMCRYPT_CALL SymCryptGetHashAlgorithm (SYMCRYPT_HASH_ID hashId)
 
SIZE_T SYMCRYPT_CALL SymCryptHashResultSize (_In_ PCSYMCRYPT_HASH pHash)
 
SIZE_T SYMCRYPT_CALL SymCryptHashInputBlockSize (_In_ PCSYMCRYPT_HASH pHash)
 
SIZE_T SYMCRYPT_CALL SymCryptHashStateSize (_In_ PCSYMCRYPT_HASH pHash)
 
VOID SYMCRYPT_CALL SymCryptHash (_In_ PCSYMCRYPT_HASH pHash, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptHashInit (_In_ PCSYMCRYPT_HASH pHash, _Out_writes_bytes_(pHash->stateSize) PVOID pState)
 
VOID SYMCRYPT_CALL SymCryptHashAppend (_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHashResult (_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptHashStateCopy (_In_ PCSYMCRYPT_HASH pHash, _In_reads_(pHash->stateSize) PCVOID pSrc, _Out_writes_(pHash->stateSize) PVOID pDst)
 
VOID SYMCRYPT_CALL SymCryptMd2 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MD2_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMd2Init (_Out_ PSYMCRYPT_MD2_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptMd2Append (_Inout_ PSYMCRYPT_MD2_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptMd2Result (_Inout_ PSYMCRYPT_MD2_STATE pState, _Out_writes_(SYMCRYPT_MD2_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMd2StateCopy (_In_ PCSYMCRYPT_MD2_STATE pSrc, _Out_ PSYMCRYPT_MD2_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptMd2StateExport (_In_ PCSYMCRYPT_MD2_STATE pState, _Out_writes_bytes_(SYMCRYPT_MD2_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd2StateImport (_Out_ PSYMCRYPT_MD2_STATE pState, _In_reads_bytes_(SYMCRYPT_MD2_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptMd2Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptMd4 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MD4_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMd4Init (_Out_ PSYMCRYPT_MD4_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptMd4Append (_Inout_ PSYMCRYPT_MD4_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptMd4Result (_Inout_ PSYMCRYPT_MD4_STATE pState, _Out_writes_(SYMCRYPT_MD4_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMd4StateCopy (_In_ PCSYMCRYPT_MD4_STATE pSrc, _Out_ PSYMCRYPT_MD4_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptMd4StateExport (_In_ PCSYMCRYPT_MD4_STATE pState, _Out_writes_bytes_(SYMCRYPT_MD4_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd4StateImport (_Out_ PSYMCRYPT_MD4_STATE pState, _In_reads_bytes_(SYMCRYPT_MD4_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptMd4Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptMd5 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMd5Init (_Out_ PSYMCRYPT_MD5_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptMd5Append (_Inout_ PSYMCRYPT_MD5_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptMd5Result (_Inout_ PSYMCRYPT_MD5_STATE pState, _Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMd5StateCopy (_In_ PCSYMCRYPT_MD5_STATE pSrc, _Out_ PSYMCRYPT_MD5_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptMd5StateExport (_In_ PCSYMCRYPT_MD5_STATE pState, _Out_writes_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd5StateImport (_Out_ PSYMCRYPT_MD5_STATE pState, _In_reads_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptMd5Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha1 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA1_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha1Init (_Out_ PSYMCRYPT_SHA1_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha1Append (_Inout_ PSYMCRYPT_SHA1_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha1Result (_Inout_ PSYMCRYPT_SHA1_STATE pState, _Out_writes_(SYMCRYPT_SHA1_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha1StateCopy (_In_ PCSYMCRYPT_SHA1_STATE pSrc, _Out_ PSYMCRYPT_SHA1_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha1StateExport (_In_ PCSYMCRYPT_SHA1_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA1_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha1StateImport (_Out_ PSYMCRYPT_SHA1_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA1_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha1Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha224 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha224Init (_Out_ PSYMCRYPT_SHA224_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha224Append (_Inout_ PSYMCRYPT_SHA224_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha224Result (_Inout_ PSYMCRYPT_SHA224_STATE pState, _Out_writes_(SYMCRYPT_SHA224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha224StateCopy (_In_ PCSYMCRYPT_SHA224_STATE pSrc, _Out_ PSYMCRYPT_SHA224_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha224StateExport (_In_ PCSYMCRYPT_SHA224_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA224_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha224StateImport (_Out_ PSYMCRYPT_SHA224_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA224_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha224Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha256 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha256Init (_Out_ PSYMCRYPT_SHA256_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha256Append (_Inout_ PSYMCRYPT_SHA256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha256Result (_Inout_ PSYMCRYPT_SHA256_STATE pState, _Out_writes_(SYMCRYPT_SHA256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha256StateCopy (_In_ PCSYMCRYPT_SHA256_STATE pSrc, _Out_ PSYMCRYPT_SHA256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha256StateExport (_In_ PCSYMCRYPT_SHA256_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA256_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha256StateImport (_Out_ PSYMCRYPT_SHA256_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA256_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha384 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha384Init (_Out_ PSYMCRYPT_SHA384_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha384Append (_Inout_ PSYMCRYPT_SHA384_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha384Result (_Inout_ PSYMCRYPT_SHA384_STATE pState, _Out_writes_(SYMCRYPT_SHA384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha384StateCopy (_In_ PCSYMCRYPT_SHA384_STATE pSrc, _Out_ PSYMCRYPT_SHA384_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha384StateExport (_In_ PCSYMCRYPT_SHA384_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA384_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha384StateImport (_Out_ PSYMCRYPT_SHA384_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA384_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha384Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha512 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha512Init (_Out_ PSYMCRYPT_SHA512_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha512Append (_Inout_ PSYMCRYPT_SHA512_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha512Result (_Inout_ PSYMCRYPT_SHA512_STATE pState, _Out_writes_(SYMCRYPT_SHA512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha512StateCopy (_In_ PCSYMCRYPT_SHA512_STATE pSrc, _Out_ PSYMCRYPT_SHA512_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha512StateExport (_In_ PCSYMCRYPT_SHA512_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA512_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512StateImport (_Out_ PSYMCRYPT_SHA512_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA512_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha512Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha512_224 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA512_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha512_224Init (_Out_ PSYMCRYPT_SHA512_224_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha512_224Append (_Inout_ PSYMCRYPT_SHA512_224_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha512_224Result (_Inout_ PSYMCRYPT_SHA512_224_STATE pState, _Out_writes_(SYMCRYPT_SHA512_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha512_224StateCopy (_In_ PCSYMCRYPT_SHA512_224_STATE pSrc, _Out_ PSYMCRYPT_SHA512_224_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha512_224StateExport (_In_ PCSYMCRYPT_SHA512_224_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA512_224_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512_224StateImport (_Out_ PSYMCRYPT_SHA512_224_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA512_224_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha512_224Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha512_256 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA512_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha512_256Init (_Out_ PSYMCRYPT_SHA512_256_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha512_256Append (_Inout_ PSYMCRYPT_SHA512_256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha512_256Result (_Inout_ PSYMCRYPT_SHA512_256_STATE pState, _Out_writes_(SYMCRYPT_SHA512_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha512_256StateCopy (_In_ PCSYMCRYPT_SHA512_256_STATE pSrc, _Out_ PSYMCRYPT_SHA512_256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha512_256StateExport (_In_ PCSYMCRYPT_SHA512_256_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA512_256_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512_256StateImport (_Out_ PSYMCRYPT_SHA512_256_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA512_256_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha512_256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha3_224 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_224Init (_Out_ PSYMCRYPT_SHA3_224_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha3_224Append (_Inout_ PSYMCRYPT_SHA3_224_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha3_224Result (_Inout_ PSYMCRYPT_SHA3_224_STATE pState, _Out_writes_(SYMCRYPT_SHA3_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_224StateCopy (_In_ PCSYMCRYPT_SHA3_224_STATE pSrc, _Out_ PSYMCRYPT_SHA3_224_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha3_224StateExport (_In_ PCSYMCRYPT_SHA3_224_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA3_224_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_224StateImport (_Out_ PSYMCRYPT_SHA3_224_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA3_224_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha3_224Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha3_256 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_256Init (_Out_ PSYMCRYPT_SHA3_256_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha3_256Append (_Inout_ PSYMCRYPT_SHA3_256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha3_256Result (_Inout_ PSYMCRYPT_SHA3_256_STATE pState, _Out_writes_(SYMCRYPT_SHA3_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_256StateCopy (_In_ PCSYMCRYPT_SHA3_256_STATE pSrc, _Out_ PSYMCRYPT_SHA3_256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha3_256StateExport (_In_ PCSYMCRYPT_SHA3_256_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA3_256_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_256StateImport (_Out_ PSYMCRYPT_SHA3_256_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA3_256_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha3_256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha3_384 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_384Init (_Out_ PSYMCRYPT_SHA3_384_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha3_384Append (_Inout_ PSYMCRYPT_SHA3_384_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha3_384Result (_Inout_ PSYMCRYPT_SHA3_384_STATE pState, _Out_writes_(SYMCRYPT_SHA3_384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_384StateCopy (_In_ PCSYMCRYPT_SHA3_384_STATE pSrc, _Out_ PSYMCRYPT_SHA3_384_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha3_384StateExport (_In_ PCSYMCRYPT_SHA3_384_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA3_384_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_384StateImport (_Out_ PSYMCRYPT_SHA3_384_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA3_384_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha3_384Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptSha3_512 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_512Init (_Out_ PSYMCRYPT_SHA3_512_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptSha3_512Append (_Inout_ PSYMCRYPT_SHA3_512_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptSha3_512Result (_Inout_ PSYMCRYPT_SHA3_512_STATE pState, _Out_writes_(SYMCRYPT_SHA3_512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptSha3_512StateCopy (_In_ PCSYMCRYPT_SHA3_512_STATE pSrc, _Out_ PSYMCRYPT_SHA3_512_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptSha3_512StateExport (_In_ PCSYMCRYPT_SHA3_512_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA3_512_STATE_EXPORT_SIZE) PBYTE pbBlob)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_512StateImport (_Out_ PSYMCRYPT_SHA3_512_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA3_512_STATE_EXPORT_SIZE) PCBYTE pbBlob)
 
VOID SYMCRYPT_CALL SymCryptSha3_512Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptShake128Default (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHAKE128_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptShake128 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptShake128Init (_Out_ PSYMCRYPT_SHAKE128_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptShake128Append (_Inout_ PSYMCRYPT_SHAKE128_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptShake128Extract (_Inout_ PSYMCRYPT_SHAKE128_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)
 
VOID SYMCRYPT_CALL SymCryptShake128Result (_Inout_ PSYMCRYPT_SHAKE128_STATE pState, _Out_writes_(SYMCRYPT_SHAKE128_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptShake128StateCopy (_In_ PCSYMCRYPT_SHAKE128_STATE pSrc, _Out_ PSYMCRYPT_SHAKE128_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptShake128Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptShake256Default (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHAKE256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptShake256 (_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptShake256Init (_Out_ PSYMCRYPT_SHAKE256_STATE pState)
 
VOID SYMCRYPT_CALL SymCryptShake256Append (_Inout_ PSYMCRYPT_SHAKE256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptShake256Extract (_Inout_ PSYMCRYPT_SHAKE256_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)
 
VOID SYMCRYPT_CALL SymCryptShake256Result (_Inout_ PSYMCRYPT_SHAKE256_STATE pState, _Out_writes_(SYMCRYPT_SHAKE256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptShake256StateCopy (_In_ PCSYMCRYPT_SHAKE256_STATE pSrc, _Out_ PSYMCRYPT_SHAKE256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptShake256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptCShake128 (_In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptCShake128Init (_Out_ PSYMCRYPT_CSHAKE128_STATE pState, _In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)
 
VOID SYMCRYPT_CALL SymCryptCShake128Append (_Inout_ PSYMCRYPT_CSHAKE128_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptCShake128Extract (_Inout_ PSYMCRYPT_CSHAKE128_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)
 
VOID SYMCRYPT_CALL SymCryptCShake128Result (_Inout_ PSYMCRYPT_CSHAKE128_STATE pState, _Out_writes_(SYMCRYPT_CSHAKE128_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptCShake128StateCopy (_In_ PCSYMCRYPT_CSHAKE128_STATE pSrc, _Out_ PSYMCRYPT_CSHAKE128_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptCShake128Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptCShake256 (_In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptCShake256Init (_Out_ PSYMCRYPT_CSHAKE256_STATE pState, _In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)
 
VOID SYMCRYPT_CALL SymCryptCShake256Append (_Inout_ PSYMCRYPT_CSHAKE256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptCShake256Extract (_Inout_ PSYMCRYPT_CSHAKE256_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)
 
VOID SYMCRYPT_CALL SymCryptCShake256Result (_Inout_ PSYMCRYPT_CSHAKE256_STATE pState, _Out_writes_(SYMCRYPT_CSHAKE256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptCShake256StateCopy (_In_ PCSYMCRYPT_CSHAKE256_STATE pSrc, _Out_ PSYMCRYPT_CSHAKE256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptCShake256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptParallelSha256Init (_Out_writes_(nStates) PSYMCRYPT_SHA256_STATE pStates, SIZE_T nStates)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelSha256Process (_Inout_updates_(nStates) PSYMCRYPT_SHA256_STATE pStates, SIZE_T nStates, _Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION pOperations, SIZE_T nOperations, _Out_writes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
 
VOID SYMCRYPT_CALL SymCryptParallelSha384Init (_Out_writes_(nStates) PSYMCRYPT_SHA384_STATE pStates, SIZE_T nStates)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelSha384Process (_Inout_updates_(nStates) PSYMCRYPT_SHA384_STATE pStates, SIZE_T nStates, _Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION pOperations, SIZE_T nOperations, _Out_writes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
 
VOID SYMCRYPT_CALL SymCryptParallelSha512Init (_Out_writes_(nStates) PSYMCRYPT_SHA512_STATE pStates, SIZE_T nStates)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelSha512Process (_Inout_updates_(nStates) PSYMCRYPT_SHA512_STATE pStates, SIZE_T nStates, _Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION pOperations, SIZE_T nOperations, _Out_writes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
 
VOID SYMCRYPT_CALL SymCryptParallelSha256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptParallelSha384Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptParallelSha512Selftest (void)
 
PCSYMCRYPT_MAC SYMCRYPT_CALL SymCryptGetMacAlgorithm (SYMCRYPT_MAC_ID macId)
 
VOID SYMCRYPT_CALL SymCryptHmacStateCopy (_In_ PCSYMCRYPT_HMAC_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacKeyCopy (_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_EXPANDED_KEY pDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacExpandKey (_In_ PCSYMCRYPT_HASH pHash, _Out_ PSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacInit (_Out_ PSYMCRYPT_HMAC_STATE pState, _In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacAppend (_Inout_ PSYMCRYPT_HMAC_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacResult (_Inout_ PSYMCRYPT_HMAC_STATE pState, _Out_writes_(pState->pKey->pHash->resultSize) PBYTE pbResult)
 
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmac (_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(pExpandedKey->pHash->resultSize) PBYTE pbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacMd5ExpandKey (_Out_ PSYMCRYPT_HMAC_MD5_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5KeyCopy (_In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_MD5_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5 (_In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_MD5_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5StateCopy (_In_ PCSYMCRYPT_HMAC_MD5_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_MD5_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5Init (_Out_ PSYMCRYPT_HMAC_MD5_STATE pState, _In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5Append (_Inout_ PSYMCRYPT_HMAC_MD5_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5Result (_Inout_ PSYMCRYPT_HMAC_MD5_STATE pState, _Out_writes_(SYMCRYPT_HMAC_MD5_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacMd5Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha1ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1 (_In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA1_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1StateCopy (_In_ PCSYMCRYPT_HMAC_SHA1_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA1_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1Init (_Out_ PSYMCRYPT_HMAC_SHA1_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1Append (_Inout_ PSYMCRYPT_HMAC_SHA1_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1Result (_Inout_ PSYMCRYPT_HMAC_SHA1_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA1_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha1Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha224ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224 (_In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224StateCopy (_In_ PCSYMCRYPT_HMAC_SHA224_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA224_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224Init (_Out_ PSYMCRYPT_HMAC_SHA224_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224Append (_Inout_ PSYMCRYPT_HMAC_SHA224_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224Result (_Inout_ PSYMCRYPT_HMAC_SHA224_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha224Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha256ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256 (_In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256StateCopy (_In_ PCSYMCRYPT_HMAC_SHA256_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256Init (_Out_ PSYMCRYPT_HMAC_SHA256_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256Append (_Inout_ PSYMCRYPT_HMAC_SHA256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256Result (_Inout_ PSYMCRYPT_HMAC_SHA256_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha256Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha384ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384 (_In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384StateCopy (_In_ PCSYMCRYPT_HMAC_SHA384_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA384_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384Init (_Out_ PSYMCRYPT_HMAC_SHA384_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384Append (_Inout_ PSYMCRYPT_HMAC_SHA384_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384Result (_Inout_ PSYMCRYPT_HMAC_SHA384_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha384Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512 (_In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512StateCopy (_In_ PCSYMCRYPT_HMAC_SHA512_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA512_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512Init (_Out_ PSYMCRYPT_HMAC_SHA512_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512Append (_Inout_ PSYMCRYPT_HMAC_SHA512_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512Result (_Inout_ PSYMCRYPT_HMAC_SHA512_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512_224ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224 (_In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224StateCopy (_In_ PCSYMCRYPT_HMAC_SHA512_224_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA512_224_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224Init (_Out_ PSYMCRYPT_HMAC_SHA512_224_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224Append (_Inout_ PSYMCRYPT_HMAC_SHA512_224_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224Result (_Inout_ PSYMCRYPT_HMAC_SHA512_224_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_224Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512_256ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256 (_In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256StateCopy (_In_ PCSYMCRYPT_HMAC_SHA512_256_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA512_256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256Init (_Out_ PSYMCRYPT_HMAC_SHA512_256_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256Append (_Inout_ PSYMCRYPT_HMAC_SHA512_256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256Result (_Inout_ PSYMCRYPT_HMAC_SHA512_256_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha512_256Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_224ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224 (_In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224StateCopy (_In_ PCSYMCRYPT_HMAC_SHA3_224_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA3_224_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224Init (_Out_ PSYMCRYPT_HMAC_SHA3_224_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224Append (_Inout_ PSYMCRYPT_HMAC_SHA3_224_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224Result (_Inout_ PSYMCRYPT_HMAC_SHA3_224_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_224Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_256ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256 (_In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256StateCopy (_In_ PCSYMCRYPT_HMAC_SHA3_256_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA3_256_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256Init (_Out_ PSYMCRYPT_HMAC_SHA3_256_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256Append (_Inout_ PSYMCRYPT_HMAC_SHA3_256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256Result (_Inout_ PSYMCRYPT_HMAC_SHA3_256_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_256Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_384ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384 (_In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384StateCopy (_In_ PCSYMCRYPT_HMAC_SHA3_384_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA3_384_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384Init (_Out_ PSYMCRYPT_HMAC_SHA3_384_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384Append (_Inout_ PSYMCRYPT_HMAC_SHA3_384_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384Result (_Inout_ PSYMCRYPT_HMAC_SHA3_384_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_384Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_512ExpandKey (_Out_ PSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512KeyCopy (_In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512 (_In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512StateCopy (_In_ PCSYMCRYPT_HMAC_SHA3_512_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_SHA3_512_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512Init (_Out_ PSYMCRYPT_HMAC_SHA3_512_STATE pState, _In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512Append (_Inout_ PSYMCRYPT_HMAC_SHA3_512_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512Result (_Inout_ PSYMCRYPT_HMAC_SHA3_512_STATE pState, _Out_writes_(SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptHmacSha3_512Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesCmacExpandKey (_Out_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptAesCmacKeyCopy (_In_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptAesCmac (_In_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_AES_CMAC_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptAesCmacStateCopy (_In_ PCSYMCRYPT_AES_CMAC_STATE pSrc, _In_opt_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_AES_CMAC_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptAesCmacInit (_Out_ PSYMCRYPT_AES_CMAC_STATE pState, _In_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptAesCmacAppend (_Inout_ PSYMCRYPT_AES_CMAC_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptAesCmacResult (_Inout_ PSYMCRYPT_AES_CMAC_STATE pState, _Out_writes_(SYMCRYPT_AES_CMAC_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptAesCmacSelftest (void)
 
VOID SYMCRYPT_CALL SymCryptKmac128 (_In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, _Out_writes_bytes_(SYMCRYPT_KMAC128_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptKmac128Ex (_In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, _Out_writes_bytes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac128ExpandKey (_Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac128ExpandKeyEx (_Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_bytes_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)
 
VOID SYMCRYPT_CALL SymCryptKmac128Init (_Out_ PSYMCRYPT_KMAC128_STATE pState, _In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptKmac128Append (_Inout_ PSYMCRYPT_KMAC128_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptKmac128Extract (_Inout_ PSYMCRYPT_KMAC128_STATE pState, _Out_writes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput, BOOLEAN bWipe)
 
VOID SYMCRYPT_CALL SymCryptKmac128Result (_Inout_ PSYMCRYPT_KMAC128_STATE pState, _Out_writes_(SYMCRYPT_KMAC128_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptKmac128ResultEx (_Inout_ PSYMCRYPT_KMAC128_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptKmac128KeyCopy (_In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptKmac128StateCopy (_In_ const SYMCRYPT_KMAC128_STATE *pSrc, _Out_ SYMCRYPT_KMAC128_STATE *pDst)
 
VOID SYMCRYPT_CALL SymCryptKmac128Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptKmac256 (_In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, _Out_writes_bytes_(SYMCRYPT_KMAC256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptKmac256Ex (_In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, _Out_writes_bytes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac256ExpandKey (_Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac256ExpandKeyEx (_Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_bytes_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)
 
VOID SYMCRYPT_CALL SymCryptKmac256Init (_Out_ PSYMCRYPT_KMAC256_STATE pState, _In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey)
 
VOID SYMCRYPT_CALL SymCryptKmac256Append (_Inout_ PSYMCRYPT_KMAC256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptKmac256Extract (_Inout_ PSYMCRYPT_KMAC256_STATE pState, _Out_writes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput, BOOLEAN bWipe)
 
VOID SYMCRYPT_CALL SymCryptKmac256Result (_Inout_ PSYMCRYPT_KMAC256_STATE pState, _Out_writes_(SYMCRYPT_KMAC256_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptKmac256ResultEx (_Inout_ PSYMCRYPT_KMAC256_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptKmac256KeyCopy (_In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptKmac256StateCopy (_In_ const SYMCRYPT_KMAC256_STATE *pSrc, _Out_ SYMCRYPT_KMAC256_STATE *pDst)
 
VOID SYMCRYPT_CALL SymCryptKmac256Selftest (void)
 
VOID SYMCRYPT_CALL SymCryptPoly1305 (_In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE pbKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptPoly1305Init (_Out_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE pbKey)
 
VOID SYMCRYPT_CALL SymCryptPoly1305Append (_Inout_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptPoly1305Result (_Inout_ PSYMCRYPT_POLY1305_STATE pState, _Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptPoly1305Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Poly1305Encrypt (_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Poly1305Decrypt (_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptChaCha20Poly1305Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMarvin32ExpandSeed (_Out_ PSYMCRYPT_MARVIN32_EXPANDED_SEED pExpandedSeed, _In_reads_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed)
 
PCSYMCRYPT_MARVIN32_EXPANDED_SEED SYMCRYPT_CALL SymCryptGetMarvin32DefaultSeed (void)
 
VOID SYMCRYPT_CALL SymCryptMarvin32SeedCopy (_In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED pSrc, _Out_ PSYMCRYPT_MARVIN32_EXPANDED_SEED pDst)
 
VOID SYMCRYPT_CALL SymCryptMarvin32 (_In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED pExpandedSeed, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MARVIN32_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMarvin32StateCopy (_In_ PCSYMCRYPT_MARVIN32_STATE pSrc, _In_opt_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED pExpandedSeed, _Out_ PSYMCRYPT_MARVIN32_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptMarvin32Init (_Out_ PSYMCRYPT_MARVIN32_STATE pState, _In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED pExpandedSeed)
 
VOID SYMCRYPT_CALL SymCryptMarvin32Append (_Inout_ PSYMCRYPT_MARVIN32_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptMarvin32Result (_Inout_ PSYMCRYPT_MARVIN32_STATE pState, _Out_writes_(SYMCRYPT_MARVIN32_RESULT_SIZE) PBYTE pbResult)
 
VOID SYMCRYPT_CALL SymCryptMarvin32Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKey (_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKeyEncryptOnly (_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptAesKeyCopy (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_AES_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptAesEncrypt (_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 SymCryptAesDecrypt (_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 SymCryptAesEcbEncrypt (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptAesEcbDecrypt (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptAesCbcEncrypt (_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 SymCryptAesCbcDecrypt (_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 SymCryptAesCbcMac (_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 SymCryptAesCtrMsb64 (_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 SymCryptAesSelftest (UINT32 maskTestsToRun)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesExpandKey (_Out_ PSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptDesEncrypt (_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCryptDesDecrypt (_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCryptDesSetOddParity (_Inout_updates_(cbData) PBYTE pbData, _In_ SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptDesSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCrypt3DesExpandKey (_Out_ PSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCrypt3DesEncrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCrypt3DesDecrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCrypt3DesCbcEncrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCrypt3DesCbcDecrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCrypt3DesSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesxExpandKey (_Out_ PSYMCRYPT_DESX_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptDesxEncrypt (_In_ PCSYMCRYPT_DESX_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DESX_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DESX_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCryptDesxDecrypt (_In_ PCSYMCRYPT_DESX_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DESX_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DESX_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCryptDesxSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc2ExpandKey (_Out_ PSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc2ExpandKeyEx (_Out_ PSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, UINT32 effectiveKeySizeInBits)
 
VOID SYMCRYPT_CALL SymCryptRc2Encrypt (_In_ PCSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_RC2_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_RC2_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCryptRc2Decrypt (_In_ PCSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_RC2_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_RC2_BLOCK_SIZE) PBYTE pbDst)
 
VOID SYMCRYPT_CALL SymCryptRc2Selftest (void)
 
PCSYMCRYPT_BLOCKCIPHER SYMCRYPT_CALL SymCryptGetBlockCipher (SYMCRYPT_BLOCKCIPHER_ID blockCipherId)
 
VOID SYMCRYPT_CALL SymCryptEcbEncrypt (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptEcbDecrypt (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptCbcEncrypt (_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 SymCryptCbcDecrypt (_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 SymCryptCbcMac (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptCtrMsb64 (_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 SymCryptCfbEncrypt (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, SIZE_T cbShift, _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 SymCryptCfbDecrypt (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, SIZE_T cbShift, _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 SymCryptPaddingPkcs7Add (SIZE_T cbBlockSize, _In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_to_(cbDst, *pcbResult) PBYTE pbDst, SIZE_T cbDst, SIZE_T *pcbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPaddingPkcs7Remove (SIZE_T cbBlockSize, _In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_to_(cbDst, *pcbResult) PBYTE pbDst, SIZE_T cbDst, SIZE_T *pcbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmValidateParameters (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ SIZE_T cbNonce, _In_ SIZE_T cbAssociatedData, _In_ UINT64 cbData, _In_ SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptCcmEncrypt (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmDecrypt (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptCcmInit (_Out_ PSYMCRYPT_CCM_STATE pState, _In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, UINT64 cbData, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptCcmEncryptPart (_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptCcmEncryptFinal (_Inout_ PSYMCRYPT_CCM_STATE pState, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptCcmDecryptPart (_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmDecryptFinal (_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptCcmSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmValidateParameters (_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ SIZE_T cbNonce, _In_ UINT64 cbAssociatedData, _In_ UINT64 cbData, _In_ SIZE_T cbTag)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmExpandKey (_Out_ PSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptGcmKeyCopy (_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_GCM_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptGcmEncrypt (_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecrypt (_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptGcmInit (_Out_ PSYMCRYPT_GCM_STATE pState, _In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce)
 
VOID SYMCRYPT_CALL SymCryptGcmStateCopy (_In_ PCSYMCRYPT_GCM_STATE pSrc, _In_opt_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKeyCopy, _Out_ PSYMCRYPT_GCM_STATE pDst)
 
VOID SYMCRYPT_CALL SymCryptGcmAuthPart (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_opt_(cbData) PCBYTE pbAuthData, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptGcmEncryptPart (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptGcmEncryptFinal (_Inout_ PSYMCRYPT_GCM_STATE pState, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptGcmDecryptPart (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecryptFinal (_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
 
VOID SYMCRYPT_CALL SymCryptGcmSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionSenderInit (_Inout_ PSYMCRYPT_SESSION pSession, UINT32 senderId, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionReceiverInit (_Inout_ PSYMCRYPT_SESSION pSession, UINT32 senderId, UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptSessionDestroy (_Inout_ PSYMCRYPT_SESSION pSession)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionGcmEncrypt (_Inout_ PSYMCRYPT_SESSION pSession, _In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag, _Out_opt_ PUINT64 pu64MessageNumber)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionGcmDecrypt (_Inout_ PSYMCRYPT_SESSION pSession, UINT64 messageNumber, _In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc4Init (_Out_ PSYMCRYPT_RC4_STATE pState, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey)
 
VOID SYMCRYPT_CALL SymCryptRc4Crypt (_Inout_ PSYMCRYPT_RC4_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, _In_ SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptRc4Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Init (_Out_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, UINT64 offset)
 
VOID SYMCRYPT_CALL SymCryptChaCha20SetOffset (_Inout_ PSYMCRYPT_CHACHA20_STATE pState, UINT64 offset)
 
VOID SYMCRYPT_CALL SymCryptChaCha20Crypt (_Inout_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptChaCha20Selftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2ExpandKey (_Out_ PSYMCRYPT_PBKDF2_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2Derive (_In_ PCSYMCRYPT_PBKDF2_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT64 iterationCnt, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2 (PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT64 iterationCnt, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptPbkdf2_HmacSha1SelfTest (void)
 
VOID SYMCRYPT_CALL SymCryptPbkdf2_HmacSha256SelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108ExpandKey (_Out_ PSYMCRYPT_SP800_108_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108Derive (_In_ PCSYMCRYPT_SP800_108_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, _In_reads_opt_(cbContext) PCBYTE pbContext, SIZE_T cbContext, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108 (PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, _In_reads_opt_(cbContext) PCBYTE pbContext, SIZE_T cbContext, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha1SelfTest (void)
 
VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha256SelfTest (void)
 
VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha384SelfTest (void)
 
VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha512SelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1ExpandKey (_Out_ PSYMCRYPT_TLSPRF1_1_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1Derive (_In_ PCSYMCRYPT_TLSPRF1_1_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1 (_In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptTlsPrf1_1SelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2ExpandKey (_Out_ PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2Derive (_In_ PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2 (_In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptTlsPrf1_2SelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfExpandKey (_Out_ PSYMCRYPT_SSHKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_HASH pHashFunc, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfDerive (_In_ PCSYMCRYPT_SSHKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, BYTE label, _In_reads_(cbSessionId) PCBYTE pbSessionId, SIZE_T cbSessionId, _Inout_updates_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdf (_In_ PCSYMCRYPT_HASH pHashFunc, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, BYTE label, _In_reads_(cbSessionId) PCBYTE pbSessionId, SIZE_T cbSessionId, _Out_writes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
 
VOID SYMCRYPT_CALL SymCryptSshKdfSha256SelfTest (void)
 
VOID SYMCRYPT_CALL SymCryptSshKdfSha512SelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdfExpandKey (_Out_ PSYMCRYPT_SRTPKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdfDerive (_In_ PCSYMCRYPT_SRTPKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT32 uKeyDerivationRate, UINT64 uIndex, UINT32 uIndexWidth, BYTE label, _Out_writes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdf (_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT32 uKeyDerivationRate, UINT64 uIndex, UINT32 uIndexWidth, BYTE label, _Out_writes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
 
VOID SYMCRYPT_CALL SymCryptSrtpKdfSelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExpandKey (_Out_ PSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbIkm) PCBYTE pbIkm, SIZE_T cbIkm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExtractPrk (_In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbIkm) PCBYTE pbIkm, SIZE_T cbIkm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, _Out_writes_(cbPrk) PBYTE pbPrk, SIZE_T cbPrk)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfPrkExpandKey (_Out_ PSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbPrk) PCBYTE pbPrk, SIZE_T cbPrk)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfDerive (_In_ PCSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdf (PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbIkm) PCBYTE pbIkm, SIZE_T cbIkm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptHkdfSelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMacExpandSalt (_Out_ PSYMCRYPT_SSKDF_MAC_EXPANDED_SALT pExpandedSalt, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMacDerive (_In_ PCSYMCRYPT_SSKDF_MAC_EXPANDED_SALT pExpandedSalt, SIZE_T cbMacOutputSize, _In_reads_(cbSecret) PCBYTE pbSecret, SIZE_T cbSecret, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMac (_In_ PCSYMCRYPT_MAC macAlgorithm, SIZE_T cbMacOutputSize, _In_reads_(cbSecret) PCBYTE pbSecret, SIZE_T cbSecret, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfHash (_In_ PCSYMCRYPT_HASH hashAlgorithm, SIZE_T cbHashOutputSize, _In_reads_(cbSecret) PCBYTE pbSecret, SIZE_T cbSecret, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
 
VOID SYMCRYPT_CALL SymCryptSskdfSelfTest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesInstantiate (_Out_ PSYMCRYPT_RNG_AES_STATE pRngState, _In_reads_(cbSeedMaterial) PCBYTE pcbSeedMaterial, _In_range_(SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T cbSeedMaterial)
 
VOID SYMCRYPT_CALL SymCryptRngAesGenerate (_Inout_ PSYMCRYPT_RNG_AES_STATE pRngState, _Out_writes_(cbRandom) PBYTE pbRandom, SIZE_T cbRandom)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesReseed (_Inout_ PSYMCRYPT_RNG_AES_STATE pRngState, _In_reads_(cbSeedMaterial) PCBYTE pcbSeedMaterial, _In_range_(SYMCRYPT_RNG_AES_MIN_RESEED_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T cbSeedMaterial)
 
VOID SYMCRYPT_CALL SymCryptRngAesUninstantiate (_Inout_ PSYMCRYPT_RNG_AES_STATE pRngState)
 
VOID SYMCRYPT_CALL SymCryptRngAesInstantiateSelftest (void)
 
VOID SYMCRYPT_CALL SymCryptRngAesReseedSelftest (void)
 
VOID SYMCRYPT_CALL SymCryptRngAesGenerateSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesFips140_2Instantiate (_Out_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE pRngState, _In_reads_(cbSeedMaterial) PCBYTE pcbSeedMaterial, _In_range_(SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T cbSeedMaterial)
 
VOID SYMCRYPT_CALL SymCryptRngAesFips140_2Generate (_Inout_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE pRngState, _Out_writes_(cbRandom) PBYTE pbRandom, SIZE_T cbRandom)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesFips140_2Reseed (_Inout_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE pRngState, _In_reads_(cbSeedMaterial) PCBYTE pcbSeedMaterial, _In_range_(SYMCRYPT_RNG_AES_MIN_RESEED_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T cbSeedMaterial)
 
VOID SYMCRYPT_CALL SymCryptRngAesFips140_2Uninstantiate (_Inout_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE pRngState)
 
VOID SYMCRYPT_CALL SymCryptRandom (_Out_writes_(cbRandom) PBYTE pbRandom, SIZE_T cbRandom)
 
VOID SYMCRYPT_CALL SymCryptProvideEntropy (_In_reads_(cbEntropy) PCBYTE pbEntropy, SIZE_T cbEntropy)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXtsAesExpandKey (_Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXtsAesExpandKeyEx (_Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptXtsAesKeyCopy (_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY pDst)
 
VOID SYMCRYPT_CALL SymCryptXtsAesEncrypt (_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, UINT64 tweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptXtsAesDecrypt (_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, UINT64 tweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptXtsAesEncryptWith128bTweak (_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbTweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptXtsAesDecryptWith128bTweak (_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbTweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
 
VOID SYMCRYPT_CALL SymCryptXtsAesSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwEncrypt (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_to_(cbDst, *pcbResult) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwDecrypt (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_to_(cbDst, *pcbResult) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwpEncrypt (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_to_(cbDst, *pcbResult) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwpDecrypt (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_to_(cbDst, *pcbResult) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbResult)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsCbcHmacVerify (_In_ PCSYMCRYPT_MAC pMacAlgorithm, _In_ PVOID pExpandedKey, _Inout_ PVOID pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
 
PVOID SYMCRYPT_CALL SymCryptCallbackAlloc (SIZE_T nBytes)
 
VOID SYMCRYPT_CALL SymCryptCallbackFree (PVOID pMem)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SYMCRYPT_WEAK_SYMBOL SymCryptCallbackRandom (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer)
 
PVOID SYMCRYPT_CALL SymCryptCallbackAllocateMutexFastInproc (void)
 
VOID SYMCRYPT_CALL SymCryptCallbackFreeMutexFastInproc (_Inout_ PVOID pMutex)
 
VOID SYMCRYPT_CALL SymCryptCallbackAcquireMutexFastInproc (_Inout_ PVOID pMutex)
 
VOID SYMCRYPT_CALL SymCryptCallbackReleaseMutexFastInproc (_Inout_ PVOID pMutex)
 
PSYMCRYPT_RSAKEY SYMCRYPT_CALL SymCryptRsakeyAllocate (_In_ PCSYMCRYPT_RSA_PARAMS pParams, _In_ UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptRsakeyFree (_Out_ PSYMCRYPT_RSAKEY pkObj)
 
UINT32 SYMCRYPT_CALL SymCryptSizeofRsakeyFromParams (_In_ PCSYMCRYPT_RSA_PARAMS pParams)
 
PSYMCRYPT_RSAKEY SYMCRYPT_CALL SymCryptRsakeyCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, _In_ PCSYMCRYPT_RSA_PARAMS pParams)
 
VOID SYMCRYPT_CALL SymCryptRsakeyWipe (_Out_ PSYMCRYPT_RSAKEY pkDst)
 
PSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlgroupAllocate (UINT32 nBitsOfP, UINT32 nBitsOfQ)
 
VOID SYMCRYPT_CALL SymCryptDlgroupFree (_Out_ PSYMCRYPT_DLGROUP pgObj)
 
UINT32 SYMCRYPT_CALL SymCryptSizeofDlgroupFromBitsizes (UINT32 nBitsOfP, UINT32 nBitsOfQ)
 
PSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlgroupCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nBitsOfP, UINT32 nBitsOfQ)
 
VOID SYMCRYPT_CALL SymCryptDlgroupWipe (_Out_ PSYMCRYPT_DLGROUP pgDst)
 
VOID SYMCRYPT_CALL SymCryptDlgroupCopy (_In_ PCSYMCRYPT_DLGROUP pgSrc, _Out_ PSYMCRYPT_DLGROUP pgDst)
 
PSYMCRYPT_DLKEY SYMCRYPT_CALL SymCryptDlkeyAllocate (_In_ PCSYMCRYPT_DLGROUP pDlgroup)
 
VOID SYMCRYPT_CALL SymCryptDlkeyFree (_Out_ PSYMCRYPT_DLKEY pkObj)
 
UINT32 SYMCRYPT_CALL SymCryptSizeofDlkeyFromDlgroup (_In_ PCSYMCRYPT_DLGROUP pDlgroup)
 
PSYMCRYPT_DLKEY SYMCRYPT_CALL SymCryptDlkeyCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, _In_ PCSYMCRYPT_DLGROUP pDlgroup)
 
VOID SYMCRYPT_CALL SymCryptDlkeyWipe (_Out_ PSYMCRYPT_DLKEY pkDst)
 
VOID SYMCRYPT_CALL SymCryptDlkeyCopy (_In_ PCSYMCRYPT_DLKEY pkSrc, _Out_ PSYMCRYPT_DLKEY pkDst)
 
PSYMCRYPT_ECURVE SYMCRYPT_CALL SymCryptEcurveAllocate (_In_ PCSYMCRYPT_ECURVE_PARAMS pParams, _In_ UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptEcurveFree (_Out_ PSYMCRYPT_ECURVE pCurve)
 
PSYMCRYPT_ECKEY SYMCRYPT_CALL SymCryptEckeyAllocate (_In_ PCSYMCRYPT_ECURVE pCurve)
 
VOID SYMCRYPT_CALL SymCryptEckeyFree (_Out_ PSYMCRYPT_ECKEY pkObj)
 
UINT32 SYMCRYPT_CALL SymCryptSizeofEckeyFromCurve (_In_ PCSYMCRYPT_ECURVE pCurve)
 
PSYMCRYPT_ECKEY SYMCRYPT_CALL SymCryptEckeyCreate (_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, PCSYMCRYPT_ECURVE pCurve)
 
VOID SYMCRYPT_CALL SymCryptEckeyWipe (_Out_ PSYMCRYPT_ECKEY pkDst)
 
VOID SymCryptEckeyCopy (_In_ PCSYMCRYPT_ECKEY pkSrc, _Out_ PSYMCRYPT_ECKEY pkDst)
 
BOOLEAN SYMCRYPT_CALL SymCryptRsakeyHasPrivateKey (_In_ PCSYMCRYPT_RSAKEY pkRsakey)
 
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofModulus (_In_ PCSYMCRYPT_RSAKEY pkRsakey)
 
UINT32 SYMCRYPT_CALL SymCryptRsakeyModulusBits (_In_ PCSYMCRYPT_RSAKEY pkRsakey)
 
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofPublicExponent (_In_ PCSYMCRYPT_RSAKEY pRsakey, UINT32 index)
 
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofPrime (_In_ PCSYMCRYPT_RSAKEY pkRsakey, UINT32 index)
 
UINT32 SYMCRYPT_CALL SymCryptRsakeyGetNumberOfPublicExponents (_In_ PCSYMCRYPT_RSAKEY pkRsakey)
 
UINT32 SYMCRYPT_CALL SymCryptRsakeyGetNumberOfPrimes (_In_ PCSYMCRYPT_RSAKEY pkRsakey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGenerate (_Inout_ PSYMCRYPT_RSAKEY pkRsakey, _In_reads_opt_(nPubExp) PCUINT64 pu64PubExp, UINT32 nPubExp, _In_ UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeySetValue (_In_reads_bytes_(cbModulus) PCBYTE pbModulus, SIZE_T cbModulus, _In_reads_(nPubExp) PCUINT64 pu64PubExp, UINT32 nPubExp, _In_reads_opt_(nPrimes) PCBYTE *ppPrimes, _In_reads_opt_(nPrimes) SIZE_T *pcbPrimes, UINT32 nPrimes, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Inout_ PSYMCRYPT_RSAKEY pkRsakey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeySetValueFromPrivateExponent (_In_reads_bytes_(cbModulus) PCBYTE pbModulus, SIZE_T cbModulus, UINT64 u64PubExp, _In_reads_bytes_(cbPrivateExponent) PCBYTE pbPrivateExponent, SIZE_T cbPrivateExponent, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Inout_ PSYMCRYPT_RSAKEY pkRsakey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGetValue (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _Out_writes_bytes_(cbModulus) PBYTE pbModulus, SIZE_T cbModulus, _Out_writes_opt_(nPubExp) PUINT64 pu64PubExp, UINT32 nPubExp, _Out_writes_opt_(nPrimes) PBYTE *ppPrimes, _In_reads_opt_(nPrimes) SIZE_T *pcbPrimes, UINT32 nPrimes, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGetCrtValue (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _Out_writes_opt_(nCrtExponents) PBYTE *ppCrtExponents, _In_reads_(nCrtExponents) SIZE_T *pcbCrtExponents, UINT32 nCrtExponents, _Out_writes_bytes_opt_(cbCrtCoefficient) PBYTE pbCrtCoefficient, SIZE_T cbCrtCoefficient, _Out_writes_bytes_opt_(cbPrivateExponent) PBYTE pbPrivateExponent, SIZE_T cbPrivateExponent, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyExtendKeyUsage (_Inout_ PSYMCRYPT_RSAKEY pkRsakey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGenerate (_In_ PCSYMCRYPT_HASH hashAlgorithm, _In_ SYMCRYPT_DLGROUP_FIPS fipsStandard, _Inout_ PSYMCRYPT_DLGROUP pDlgroup)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupSetValueSafePrime (SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE dhSafePrimeType, _Inout_ PSYMCRYPT_DLGROUP pDlgroup)
 
BOOLEAN SYMCRYPT_CALL SymCryptDlgroupIsSame (_In_ PCSYMCRYPT_DLGROUP pDlgroup1, _In_ PCSYMCRYPT_DLGROUP pDlgroup2)
 
VOID SYMCRYPT_CALL SymCryptDlgroupGetSizes (_In_ PCSYMCRYPT_DLGROUP pDlgroup, _Out_ SIZE_T *pcbPrimeP, _Out_ SIZE_T *pcbPrimeQ, _Out_ SIZE_T *pcbGenG, _Out_ SIZE_T *pcbSeed)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupSetValue (_In_reads_bytes_(cbPrimeP) PCBYTE pbPrimeP, SIZE_T cbPrimeP, _In_reads_bytes_(cbPrimeQ) PCBYTE pbPrimeQ, SIZE_T cbPrimeQ, _In_reads_bytes_(cbGenG) PCBYTE pbGenG, SIZE_T cbGenG, SYMCRYPT_NUMBER_FORMAT numFormat, _In_opt_ PCSYMCRYPT_HASH pHashAlgorithm, _In_reads_bytes_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed, UINT32 genCounter, SYMCRYPT_DLGROUP_FIPS fipsStandard, _Inout_ PSYMCRYPT_DLGROUP pDlgroup)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGetValue (_In_ PCSYMCRYPT_DLGROUP pDlgroup, _Out_writes_bytes_(cbPrimeP) PBYTE pbPrimeP, SIZE_T cbPrimeP, _Out_writes_bytes_(cbPrimeQ) PBYTE pbPrimeQ, SIZE_T cbPrimeQ, _Out_writes_bytes_(cbGenG) PBYTE pbGenG, SIZE_T cbGenG, SYMCRYPT_NUMBER_FORMAT numFormat, _Out_ PCSYMCRYPT_HASH *ppHashAlgorithm, _Out_writes_bytes_(cbSeed) PBYTE pbSeed, SIZE_T cbSeed, _Out_ PUINT32 pGenCounter)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeySetPrivateKeyLength (_Inout_ PSYMCRYPT_DLKEY pkDlkey, UINT32 nBitsPriv, UINT32 flags)
 
PCSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlkeyGetGroup (_In_ PCSYMCRYPT_DLKEY pkDlkey)
 
UINT32 SYMCRYPT_CALL SymCryptDlkeySizeofPublicKey (_In_ PCSYMCRYPT_DLKEY pkDlkey)
 
UINT32 SYMCRYPT_CALL SymCryptDlkeySizeofPrivateKey (_In_ PCSYMCRYPT_DLKEY pkDlkey)
 
BOOLEAN SYMCRYPT_CALL SymCryptDlkeyHasPrivateKey (_In_ PCSYMCRYPT_DLKEY pkDlkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyGenerate (_In_ UINT32 flags, _Inout_ PSYMCRYPT_DLKEY pkDlkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeySetValue (_In_reads_bytes_(cbPrivateKey) PCBYTE pbPrivateKey, SIZE_T cbPrivateKey, _In_reads_bytes_(cbPublicKey) PCBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Inout_ PSYMCRYPT_DLKEY pkDlkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyGetValue (_In_ PCSYMCRYPT_DLKEY pkDlkey, _Out_writes_bytes_(cbPrivateKey) PBYTE pbPrivateKey, SIZE_T cbPrivateKey, _Out_writes_bytes_(cbPublicKey) PBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyExtendKeyUsage (_Inout_ PSYMCRYPT_DLKEY pkDlkey, UINT32 flags)
 
UINT32 SYMCRYPT_CALL SymCryptEcurvePrivateKeyDefaultFormat (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveHighBitRestrictionNumOfBits (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveHighBitRestrictionPosition (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveHighBitRestrictionValue (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveBitsizeofFieldModulus (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveBitsizeofGroupOrder (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveSizeofFieldElement (_In_ PCSYMCRYPT_ECURVE pCurve)
 
UINT32 SYMCRYPT_CALL SymCryptEcurveSizeofScalarMultiplier (_In_ PCSYMCRYPT_ECURVE pCurve)
 
BOOLEAN SYMCRYPT_CALL SymCryptEcurveIsSame (_In_ PCSYMCRYPT_ECURVE pCurve1, _In_ PCSYMCRYPT_ECURVE pCurve2)
 
PCSYMCRYPT_ECURVE_PARAMS SYMCRYPT_CALL SymCryptGetEcurveParams (SYMCRYPT_ECURVE_ID ecurveId)
 
UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPublicKey (_In_ PCSYMCRYPT_ECKEY pkEckey, _In_ SYMCRYPT_ECPOINT_FORMAT ecPointFormat)
 
UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPrivateKey (_In_ PCSYMCRYPT_ECKEY pkEckey)
 
BOOLEAN SYMCRYPT_CALL SymCryptEckeyHasPrivateKey (_In_ PCSYMCRYPT_ECKEY pkEckey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetValue (_In_reads_bytes_(cbPrivateKey) PCBYTE pbPrivateKey, SIZE_T cbPrivateKey, _In_reads_bytes_(cbPublicKey) PCBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, SYMCRYPT_ECPOINT_FORMAT ecPointFormat, UINT32 flags, _Inout_ PSYMCRYPT_ECKEY pEckey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetRandom (_In_ UINT32 flags, _Inout_ PSYMCRYPT_ECKEY pEckey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyGetValue (_In_ PCSYMCRYPT_ECKEY pEckey, _Out_writes_bytes_(cbPrivateKey) PBYTE pbPrivateKey, SIZE_T cbPrivateKey, _Out_writes_bytes_(cbPublicKey) PBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, SYMCRYPT_ECPOINT_FORMAT ecPointFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyExtendKeyUsage (_Inout_ PSYMCRYPT_ECKEY pEckey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaRawEncrypt (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaRawDecrypt (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Encrypt (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfDst, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Decrypt (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT nfSrc, UINT32 flags, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepEncrypt (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfDst, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepDecrypt (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT nfSrc, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, UINT32 flags, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Sign (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_ PCSYMCRYPT_OID pHashOIDs, _In_ SIZE_T nOIDCount, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfSignature, _Out_writes_opt_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature, _Out_ SIZE_T *pcbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Verify (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT nfSignature, _In_reads_opt_(nOIDCount) PCSYMCRYPT_OID pHashOID, _In_ SIZE_T nOIDCount, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssSign (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_ PCSYMCRYPT_HASH hashAlgorithm, SIZE_T cbSalt, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfSignature, _Out_writes_opt_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature, _Out_ SIZE_T *pcbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssVerify (_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT nfSignature, _In_ PCSYMCRYPT_HASH hashAlgorithm, SIZE_T cbSalt, UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptRsaSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaSign (_In_ PCSYMCRYPT_DLKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaVerify (_In_ PCSYMCRYPT_DLKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptDsaSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDhSecretAgreement (_In_ PCSYMCRYPT_DLKEY pkPrivate, _In_ PCSYMCRYPT_DLKEY pkPublic, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
 
VOID SYMCRYPT_CALL SymCryptDhSecretAgreementSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaSign (_In_ PCSYMCRYPT_ECKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaVerify (_In_ PCSYMCRYPT_ECKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptEcDsaSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDhSecretAgreement (_In_ PCSYMCRYPT_ECKEY pkPrivate, _In_ PCSYMCRYPT_ECKEY pkPublic, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
 
VOID SYMCRYPT_CALL SymCryptEcDhSecretAgreementSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssParamsFromAlgId (SYMCRYPT_XMSS_ALGID id, _Out_ PSYMCRYPT_XMSS_PARAMS pParams)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssMtParamsFromAlgId (SYMCRYPT_XMSSMT_ALGID id, _Out_ PSYMCRYPT_XMSS_PARAMS pParams)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssSetParams (_Out_ PSYMCRYPT_XMSS_PARAMS pParams, UINT32 id, _In_ PCSYMCRYPT_HASH pHash, UINT32 cbHashOutput, UINT32 nWinternitzWidth, UINT32 nTotalTreeHeight, UINT32 nLayers, UINT32 cbPrefix)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssSizeofKeyBlobFromParams (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, SYMCRYPT_XMSSKEY_TYPE keyType, _Out_ SIZE_T *pcbKey)
 
PSYMCRYPT_XMSS_KEY SYMCRYPT_CALL SymCryptXmsskeyAllocate (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyGenerate (_Inout_ PSYMCRYPT_XMSS_KEY pKey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeySetValue (_In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, SYMCRYPT_XMSSKEY_TYPE keyType, UINT32 flags, _Inout_ PSYMCRYPT_XMSS_KEY pKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyGetValue (_In_ PCSYMCRYPT_XMSS_KEY pKey, SYMCRYPT_XMSSKEY_TYPE keyType, UINT32 flags, _Out_writes_bytes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmsskeyFree (_Inout_ PSYMCRYPT_XMSS_KEY pKey)
 
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofSignatureFromParams (_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssSign (_Inout_ PSYMCRYPT_XMSS_KEY pKey, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssVerify (_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 SymCryptXmssSelftest (void)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsParamsFromAlgId (SYMCRYPT_LMS_ALGID lmsAlgID, SYMCRYPT_LMS_OTS_ALGID lmsOtsAlgID, _Out_ PSYMCRYPT_LMS_PARAMS pParams)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsSetParams (_Out_ PSYMCRYPT_LMS_PARAMS pParams, UINT32 lmsAlgID, UINT32 lmsOtsAlgID, _In_ PCSYMCRYPT_HASH pLmsHashFunction, UINT32 cbHashOutput, UINT32 nTreeHeight, UINT32 nWinternitzChainWidth)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsSizeofKeyBlobFromParams (_In_ PCSYMCRYPT_LMS_PARAMS pParams, SYMCRYPT_LMSKEY_TYPE keyType, _Out_ SIZE_T *pcbKey)
 
PSYMCRYPT_LMS_KEY SYMCRYPT_CALL SymCryptLmskeyAllocate (_In_ PCSYMCRYPT_LMS_PARAMS pParams, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmskeyGenerate (_Inout_ PSYMCRYPT_LMS_KEY pKey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmskeySetValue (_In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, SYMCRYPT_LMSKEY_TYPE keyType, UINT32 flags, _Inout_ PSYMCRYPT_LMS_KEY pKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmskeyGetValue (_In_ PCSYMCRYPT_LMS_KEY pKey, SYMCRYPT_LMSKEY_TYPE keyType, UINT32 flags, _Out_writes_bytes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
 
VOID SYMCRYPT_CALL SymCryptLmskeyFree (_Inout_ PSYMCRYPT_LMS_KEY pKey)
 
SIZE_T SYMCRYPT_CALL SymCryptLmsSizeofSignatureFromParams (_In_ PCSYMCRYPT_LMS_PARAMS pParams)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsSign (_Inout_ PSYMCRYPT_LMS_KEY pKey, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsVerify (_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)
 
VOID SYMCRYPT_CALL SymCryptLmsSelftest (void)
 
PSYMCRYPT_MLKEMKEY SYMCRYPT_CALL SymCryptMlKemkeyAllocate (SYMCRYPT_MLKEM_PARAMS params)
 
VOID SYMCRYPT_CALL SymCryptMlKemkeyFree (_Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemSizeofKeyFormatFromParams (SYMCRYPT_MLKEM_PARAMS params, SYMCRYPT_MLKEMKEY_FORMAT mlKemkeyformat, _Out_ SIZE_T *pcbKeyFormat)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemSizeofCiphertextFromParams (SYMCRYPT_MLKEM_PARAMS params, _Out_ SIZE_T *pcbCiphertext)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeyGenerate (_Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeySetValue (_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_MLKEMKEY_FORMAT mlKemkeyFormat, UINT32 flags, _Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeyGetValue (_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_MLKEMKEY_FORMAT mlKemkeyFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemEncapsulate (_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret, _Out_writes_bytes_(cbCiphertext) PBYTE pbCiphertext, SIZE_T cbCiphertext)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemDecapsulate (_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _In_reads_bytes_(cbCiphertext) PCBYTE pbCiphertext, SIZE_T cbCiphertext, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
 
VOID SYMCRYPT_CALL SymCryptMlKemSelftest (void)
 
PSYMCRYPT_COMPOSITE_MLKEMKEY SYMCRYPT_CALL SymCryptCompositeMlKemkeyAllocate (SYMCRYPT_COMPOSITE_MLKEM_PARAMS params)
 
VOID SYMCRYPT_CALL SymCryptCompositeMlKemkeyFree (_Inout_ PSYMCRYPT_COMPOSITE_MLKEMKEY pkCompositeMlKemkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemSizeofKeyFormatFromParams (SYMCRYPT_COMPOSITE_MLKEM_PARAMS params, SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT compositeMlKemkeyformat, _Out_ SIZE_T *pcbKeyFormat)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemSizeofCiphertextFromParams (SYMCRYPT_COMPOSITE_MLKEM_PARAMS params, _Out_ SIZE_T *pcbCiphertext)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemkeyGenerate (_Inout_ PSYMCRYPT_COMPOSITE_MLKEMKEY pkCompositeMlKemkey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemkeySetValue (_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT compositeMlKemkeyFormat, UINT32 flags, _Inout_ PSYMCRYPT_COMPOSITE_MLKEMKEY pkCompositeMlKemkey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemkeyGetValue (_In_ PCSYMCRYPT_COMPOSITE_MLKEMKEY pkCompositeMlKemkey, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT compositeMlKemkeyFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemEncapsulate (_In_ PCSYMCRYPT_COMPOSITE_MLKEMKEY pkCompositeMlKemkey, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret, _Out_writes_bytes_(cbCiphertext) PBYTE pbCiphertext, SIZE_T cbCiphertext)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemDecapsulate (_In_ PCSYMCRYPT_COMPOSITE_MLKEMKEY pkCompositeMlKemkey, _In_reads_bytes_(cbCiphertext) PCBYTE pbCiphertext, SIZE_T cbCiphertext, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaSizeofKeyFormatFromParams (SYMCRYPT_MLDSA_PARAMS params, SYMCRYPT_MLDSAKEY_FORMAT mlDsakeyFormat, _Out_ SIZE_T *pcbKeyFormat)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaSizeofSignatureFromParams (SYMCRYPT_MLDSA_PARAMS params, _Out_ SIZE_T *pcbSignature)
 
 _Success_ (return !=NULL) PSYMCRYPT_MLDSAKEY SYMCRYPT_CALL SymCryptMlDsakeyAllocate(SYMCRYPT_MLDSA_PARAMS params)
 Returns the name of an atom.
 
VOID SYMCRYPT_CALL SymCryptMlDsakeyFree (_Post_invalid_ PSYMCRYPT_MLDSAKEY pkMlDsakey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsakeyGenerate (_Inout_ PSYMCRYPT_MLDSAKEY pkMlDsakey, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsakeySetValue (_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_MLDSAKEY_FORMAT mlDsakeyFormat, UINT32 flags, _Inout_ PSYMCRYPT_MLDSAKEY pkMlDsakey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsakeyGetValue (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_MLDSAKEY_FORMAT mlDsakeyFormat, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaSign (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, _In_reads_bytes_opt_(cbContext) PCBYTE pbContext, _In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T cbContext, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptExternalMuMlDsaSign (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, _In_reads_bytes_(cbMu) PCBYTE pbMu, SIZE_T cbMu, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHashMlDsaSign (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, SYMCRYPT_PQDSA_HASH_ID hashAlg, _In_reads_bytes_(cbHash) PCBYTE pbHash, SIZE_T cbHash, _In_reads_bytes_opt_(cbContext) PCBYTE pbContext, _In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T cbContext, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaVerify (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, _In_reads_bytes_opt_(cbContext) PCBYTE pbContext, _In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T cbContext, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptExternalMuMlDsaVerify (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, _In_reads_bytes_(cbMu) PCBYTE pbMu, SIZE_T cbMu, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, UINT32 flags)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHashMlDsaVerify (_In_ PCSYMCRYPT_MLDSAKEY pkMlDsakey, SYMCRYPT_PQDSA_HASH_ID hashAlg, _In_reads_bytes_(cbHash) PCBYTE pbHash, SIZE_T cbHash, _In_reads_bytes_opt_(cbContext) PCBYTE pbContext, _In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T cbContext, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, UINT32 flags)
 
VOID SYMCRYPT_CALL SymCryptMlDsaSelftest (void)
 
_Analysis_noreturn_ VOID SYMCRYPT_CALL SymCryptFatal (UINT32 fatalCode)
 
UINT32 SYMCRYPT_CALL SymCryptMapUint32 (UINT32 u32Input, UINT32 u32Default, _In_reads_(nMap) PCSYMCRYPT_UINT32_MAP pcMap, SIZE_T nMap)
 

Variables

 SYMCRYPT_ERROR
 
const PCSYMCRYPT_HASH SymCryptMd2Algorithm
 
const PCSYMCRYPT_HASH SymCryptMd4Algorithm
 
const PCSYMCRYPT_HASH SymCryptMd5Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha1Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha224Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha256Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha384Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha512Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha512_224Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha512_256Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha3_224Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha3_256Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha3_384Algorithm
 
const PCSYMCRYPT_HASH SymCryptSha3_512Algorithm
 
const PCSYMCRYPT_HASH SymCryptShake128HashAlgorithm
 
const PCSYMCRYPT_HASH SymCryptShake256HashAlgorithm
 
const PCSYMCRYPT_MAC SymCryptHmacMd5Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha1Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha224Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha256Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha384Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha512Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha512_224Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha512_256Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha3_224Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha3_256Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha3_384Algorithm
 
const PCSYMCRYPT_MAC SymCryptHmacSha3_512Algorithm
 
const PCSYMCRYPT_MAC SymCryptAesCmacAlgorithm
 
const PCSYMCRYPT_MAC SymCryptKmac128Algorithm
 
const PCSYMCRYPT_MAC SymCryptKmac256Algorithm
 
PCSYMCRYPT_MARVIN32_EXPANDED_SEED const SymCryptMarvin32DefaultSeed
 
const PCSYMCRYPT_BLOCKCIPHER SymCryptAesBlockCipher
 
const PCSYMCRYPT_BLOCKCIPHER SymCryptDesBlockCipher
 
const PCSYMCRYPT_BLOCKCIPHER SymCrypt3DesBlockCipher
 
const PCSYMCRYPT_BLOCKCIPHER SymCryptDesxBlockCipher
 
const PCSYMCRYPT_BLOCKCIPHER SymCryptRc2BlockCipher
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP192
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP224
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP256
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP384
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP521
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNumsP256t1
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNumsP384t1
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNumsP512t1
 
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsCurve25519
 

Macro Definition Documentation

◆ _Return_type_success_

#define _Return_type_success_ (   expr)

Definition at line 200 of file symcrypt.h.

◆ SYMCRYPT_3DES_BLOCK_SIZE

#define SYMCRYPT_3DES_BLOCK_SIZE   (8)

Definition at line 4440 of file symcrypt.h.

◆ SYMCRYPT_AES_BLOCK_SIZE

#define SYMCRYPT_AES_BLOCK_SIZE   (16)

Definition at line 4255 of file symcrypt.h.

◆ SYMCRYPT_AES_CMAC_INPUT_BLOCK_SIZE

#define SYMCRYPT_AES_CMAC_INPUT_BLOCK_SIZE   (16)

Definition at line 3442 of file symcrypt.h.

◆ SYMCRYPT_AES_CMAC_RESULT_SIZE

#define SYMCRYPT_AES_CMAC_RESULT_SIZE   (16)

Definition at line 3441 of file symcrypt.h.

◆ SYMCRYPT_AES_SELFTEST_ALL

#define SYMCRYPT_AES_SELFTEST_ALL   0x1f

Definition at line 4362 of file symcrypt.h.

◆ SYMCRYPT_AES_SELFTEST_BASE

#define SYMCRYPT_AES_SELFTEST_BASE   0x01

Definition at line 4356 of file symcrypt.h.

◆ SYMCRYPT_AES_SELFTEST_CBC

#define SYMCRYPT_AES_SELFTEST_CBC   0x04

Definition at line 4358 of file symcrypt.h.

◆ SYMCRYPT_AES_SELFTEST_CBCMAC

#define SYMCRYPT_AES_SELFTEST_CBCMAC   0x08

Definition at line 4359 of file symcrypt.h.

◆ SYMCRYPT_AES_SELFTEST_CTR

#define SYMCRYPT_AES_SELFTEST_CTR   0x10

Definition at line 4360 of file symcrypt.h.

◆ SYMCRYPT_AES_SELFTEST_ECB

#define SYMCRYPT_AES_SELFTEST_ECB   0x02

Definition at line 4357 of file symcrypt.h.

◆ SYMCRYPT_API_VERSION

#define SYMCRYPT_API_VERSION   ((SYMCRYPT_CODE_VERSION_API << 16) | SYMCRYPT_CODE_VERSION_MINOR)

Definition at line 16 of file symcrypt.h.

◆ SYMCRYPT_ASSERT

#define SYMCRYPT_ASSERT (   _x)     _Analysis_assume_( _x )

Definition at line 10807 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM1024_P384

#define SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM1024_P384   (1665)

Definition at line 10254 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM768_P256

#define SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM768_P256   (1153)

Definition at line 10252 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM768_X25519

#define SYMCRYPT_COMPOSITE_MLKEM_CIPHERTEXT_SIZE_MLKEM768_X25519   (1120)

Definition at line 10253 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_IRTF_PRIVATE_SEED_SIZE

#define SYMCRYPT_COMPOSITE_MLKEM_IRTF_PRIVATE_SEED_SIZE   (32)

Definition at line 10228 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM1024_P384

#define SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM1024_P384   (128)

Definition at line 10232 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM768_P256

#define SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM768_P256   (115)

Definition at line 10230 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM768_X25519

#define SYMCRYPT_COMPOSITE_MLKEM_LAMPS_PRIVATE_KEY_SIZE_MLKEM768_X25519   (96)

Definition at line 10231 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM1024_P384

#define SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM1024_P384   (1665)

Definition at line 10236 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM768_P256

#define SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM768_P256   (1249)

Definition at line 10234 of file symcrypt.h.

◆ SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM768_X25519

#define SYMCRYPT_COMPOSITE_MLKEM_PUBLIC_KEY_SIZE_MLKEM768_X25519   (1216)

Definition at line 10235 of file symcrypt.h.

◆ SYMCRYPT_CSHAKE128_INPUT_BLOCK_SIZE

#define SYMCRYPT_CSHAKE128_INPUT_BLOCK_SIZE   SYMCRYPT_SHAKE128_INPUT_BLOCK_SIZE

Definition at line 2088 of file symcrypt.h.

◆ SYMCRYPT_CSHAKE128_RESULT_SIZE

#define SYMCRYPT_CSHAKE128_RESULT_SIZE   SYMCRYPT_SHAKE128_RESULT_SIZE

Definition at line 2087 of file symcrypt.h.

◆ SYMCRYPT_CSHAKE256_INPUT_BLOCK_SIZE

#define SYMCRYPT_CSHAKE256_INPUT_BLOCK_SIZE   SYMCRYPT_SHAKE256_INPUT_BLOCK_SIZE

Definition at line 2145 of file symcrypt.h.

◆ SYMCRYPT_CSHAKE256_RESULT_SIZE

#define SYMCRYPT_CSHAKE256_RESULT_SIZE   SYMCRYPT_SHAKE256_RESULT_SIZE

Definition at line 2144 of file symcrypt.h.

◆ SYMCRYPT_DES_BLOCK_SIZE

#define SYMCRYPT_DES_BLOCK_SIZE   (8)

Definition at line 4385 of file symcrypt.h.

◆ SYMCRYPT_DESX_BLOCK_SIZE

#define SYMCRYPT_DESX_BLOCK_SIZE   (8)

Definition at line 4500 of file symcrypt.h.

◆ SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_DEFAULT

#define SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_DEFAULT   SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919

Definition at line 266 of file symcrypt.h.

◆ SYMCRYPT_DLGROUP_FIPS_LATEST

#define SYMCRYPT_DLGROUP_FIPS_LATEST   (SYMCRYPT_DLGROUP_FIPS_186_3)

Definition at line 7872 of file symcrypt.h.

◆ SYMCRYPT_FLAG_DLKEY_DH

#define SYMCRYPT_FLAG_DLKEY_DH   (0x2000)

Definition at line 7593 of file symcrypt.h.

◆ SYMCRYPT_FLAG_DLKEY_DSA

#define SYMCRYPT_FLAG_DLKEY_DSA   (0x1000)

Definition at line 7592 of file symcrypt.h.

◆ SYMCRYPT_FLAG_DLKEY_GEN_MODP

#define SYMCRYPT_FLAG_DLKEY_GEN_MODP   (0x01)

Definition at line 8065 of file symcrypt.h.

◆ SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION

#define SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION   (0x08)

Definition at line 8327 of file symcrypt.h.

◆ SYMCRYPT_FLAG_ECKEY_ECDH

#define SYMCRYPT_FLAG_ECKEY_ECDH   (0x2000)

Definition at line 7596 of file symcrypt.h.

◆ SYMCRYPT_FLAG_ECKEY_ECDSA

#define SYMCRYPT_FLAG_ECKEY_ECDSA   (0x1000)

Definition at line 7595 of file symcrypt.h.

◆ SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION

#define SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION   (0x200)

Definition at line 7586 of file symcrypt.h.

◆ SYMCRYPT_FLAG_KEY_NO_FIPS

#define SYMCRYPT_FLAG_KEY_NO_FIPS   (0x100)

Definition at line 7579 of file symcrypt.h.

◆ SYMCRYPT_FLAG_LMSKEY_VERIFY_ROOT

#define SYMCRYPT_FLAG_LMSKEY_VERIFY_ROOT   (0x00000001)

Definition at line 9618 of file symcrypt.h.

◆ SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1

#define SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1   (0x01)

Definition at line 8671 of file symcrypt.h.

◆ SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID

#define SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID   (0x02)

Definition at line 8672 of file symcrypt.h.

◆ SYMCRYPT_FLAG_RSA_PSS_VERIFY_WITH_MINIMUM_SALT

#define SYMCRYPT_FLAG_RSA_PSS_VERIFY_WITH_MINIMUM_SALT   (0x04)

Definition at line 8674 of file symcrypt.h.

◆ SYMCRYPT_FLAG_RSAKEY_ENCRYPT

#define SYMCRYPT_FLAG_RSAKEY_ENCRYPT   (0x2000)

Definition at line 7599 of file symcrypt.h.

◆ SYMCRYPT_FLAG_RSAKEY_SIGN

#define SYMCRYPT_FLAG_RSAKEY_SIGN   (0x1000)

Definition at line 7598 of file symcrypt.h.

◆ SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT

#define SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT   (0x00000001)

Definition at line 9243 of file symcrypt.h.

◆ SYMCRYPT_FORCE_READ16

#define SYMCRYPT_FORCE_READ16 (   _p)    SYMCRYPT_INTERNAL_FORCE_READ16( _p )

Definition at line 417 of file symcrypt.h.

◆ SYMCRYPT_FORCE_READ32

#define SYMCRYPT_FORCE_READ32 (   _p)    SYMCRYPT_INTERNAL_FORCE_READ32( _p )

Definition at line 418 of file symcrypt.h.

◆ SYMCRYPT_FORCE_READ64

#define SYMCRYPT_FORCE_READ64 (   _p)    SYMCRYPT_INTERNAL_FORCE_READ64( _p )

Definition at line 419 of file symcrypt.h.

◆ SYMCRYPT_FORCE_READ8

#define SYMCRYPT_FORCE_READ8 (   _p)    SYMCRYPT_INTERNAL_FORCE_READ8( _p )

Definition at line 416 of file symcrypt.h.

◆ SYMCRYPT_FORCE_WRITE16

#define SYMCRYPT_FORCE_WRITE16 (   _p,
  _v 
)    SYMCRYPT_INTERNAL_FORCE_WRITE16( _p, _v )

Definition at line 422 of file symcrypt.h.

◆ SYMCRYPT_FORCE_WRITE32

#define SYMCRYPT_FORCE_WRITE32 (   _p,
  _v 
)    SYMCRYPT_INTERNAL_FORCE_WRITE32( _p, _v )

Definition at line 423 of file symcrypt.h.

◆ SYMCRYPT_FORCE_WRITE64

#define SYMCRYPT_FORCE_WRITE64 (   _p,
  _v 
)    SYMCRYPT_INTERNAL_FORCE_WRITE64( _p, _v )

Definition at line 424 of file symcrypt.h.

◆ SYMCRYPT_FORCE_WRITE8

#define SYMCRYPT_FORCE_WRITE8 (   _p,
  _v 
)    SYMCRYPT_INTERNAL_FORCE_WRITE8( _p, _v )

Definition at line 421 of file symcrypt.h.

◆ SYMCRYPT_HMAC_MD5_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_MD5_INPUT_BLOCK_SIZE   SYMCRYPT_MD5_INPUT_BLOCK_SIZE

Definition at line 2661 of file symcrypt.h.

◆ SYMCRYPT_HMAC_MD5_RESULT_SIZE

#define SYMCRYPT_HMAC_MD5_RESULT_SIZE   SYMCRYPT_MD5_RESULT_SIZE

Definition at line 2660 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA1_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA1_INPUT_BLOCK_SIZE   SYMCRYPT_SHA1_INPUT_BLOCK_SIZE

Definition at line 2726 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA1_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA1_RESULT_SIZE   SYMCRYPT_SHA1_RESULT_SIZE

Definition at line 2725 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA224_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA224_INPUT_BLOCK_SIZE   SYMCRYPT_SHA224_INPUT_BLOCK_SIZE

Definition at line 2793 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA224_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA224_RESULT_SIZE   SYMCRYPT_SHA224_RESULT_SIZE

Definition at line 2792 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA256_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA256_INPUT_BLOCK_SIZE   SYMCRYPT_SHA256_INPUT_BLOCK_SIZE

Definition at line 2857 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA256_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA256_RESULT_SIZE   SYMCRYPT_SHA256_RESULT_SIZE

Definition at line 2856 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA384_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA384_INPUT_BLOCK_SIZE   SYMCRYPT_SHA384_INPUT_BLOCK_SIZE

Definition at line 2921 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA384_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA384_RESULT_SIZE   SYMCRYPT_SHA384_RESULT_SIZE

Definition at line 2920 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_224_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA3_224_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE

Definition at line 3183 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE   SYMCRYPT_SHA3_224_RESULT_SIZE

Definition at line 3182 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_256_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA3_256_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE

Definition at line 3247 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE   SYMCRYPT_SHA3_256_RESULT_SIZE

Definition at line 3246 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_384_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA3_384_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE

Definition at line 3311 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE   SYMCRYPT_SHA3_384_RESULT_SIZE

Definition at line 3310 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_512_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA3_512_INPUT_BLOCK_SIZE   SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE

Definition at line 3375 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE   SYMCRYPT_SHA3_512_RESULT_SIZE

Definition at line 3374 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA512_224_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA512_224_INPUT_BLOCK_SIZE   SYMCRYPT_SHA512_224_INPUT_BLOCK_SIZE

Definition at line 3051 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE   SYMCRYPT_SHA512_224_RESULT_SIZE

Definition at line 3050 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA512_256_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA512_256_INPUT_BLOCK_SIZE   SYMCRYPT_SHA512_256_INPUT_BLOCK_SIZE

Definition at line 3117 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE   SYMCRYPT_SHA512_256_RESULT_SIZE

Definition at line 3116 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA512_INPUT_BLOCK_SIZE

#define SYMCRYPT_HMAC_SHA512_INPUT_BLOCK_SIZE   SYMCRYPT_SHA512_INPUT_BLOCK_SIZE

Definition at line 2985 of file symcrypt.h.

◆ SYMCRYPT_HMAC_SHA512_RESULT_SIZE

#define SYMCRYPT_HMAC_SHA512_RESULT_SIZE   SYMCRYPT_SHA512_RESULT_SIZE

Definition at line 2984 of file symcrypt.h.

◆ SYMCRYPT_KMAC128_INPUT_BLOCK_SIZE

#define SYMCRYPT_KMAC128_INPUT_BLOCK_SIZE   SYMCRYPT_CSHAKE128_INPUT_BLOCK_SIZE

Definition at line 3675 of file symcrypt.h.

◆ SYMCRYPT_KMAC128_RESULT_SIZE

#define SYMCRYPT_KMAC128_RESULT_SIZE   SYMCRYPT_CSHAKE128_RESULT_SIZE

Definition at line 3674 of file symcrypt.h.

◆ SYMCRYPT_KMAC256_INPUT_BLOCK_SIZE

#define SYMCRYPT_KMAC256_INPUT_BLOCK_SIZE   SYMCRYPT_CSHAKE256_INPUT_BLOCK_SIZE

Definition at line 3763 of file symcrypt.h.

◆ SYMCRYPT_KMAC256_RESULT_SIZE

#define SYMCRYPT_KMAC256_RESULT_SIZE   SYMCRYPT_CSHAKE256_RESULT_SIZE

Definition at line 3762 of file symcrypt.h.

◆ SYMCRYPT_LOAD_LSBFIRST16

#define SYMCRYPT_LOAD_LSBFIRST16 (   p)    SYMCRYPT_INTERNAL_LOAD_LSBFIRST16( p )

Definition at line 298 of file symcrypt.h.

◆ SYMCRYPT_LOAD_LSBFIRST32

#define SYMCRYPT_LOAD_LSBFIRST32 (   p)    SYMCRYPT_INTERNAL_LOAD_LSBFIRST32( p )

Definition at line 299 of file symcrypt.h.

◆ SYMCRYPT_LOAD_LSBFIRST64

#define SYMCRYPT_LOAD_LSBFIRST64 (   p)    SYMCRYPT_INTERNAL_LOAD_LSBFIRST64( p )

Definition at line 300 of file symcrypt.h.

◆ SYMCRYPT_LOAD_MSBFIRST16

#define SYMCRYPT_LOAD_MSBFIRST16 (   p)    SYMCRYPT_INTERNAL_LOAD_MSBFIRST16( p )

Definition at line 302 of file symcrypt.h.

◆ SYMCRYPT_LOAD_MSBFIRST32

#define SYMCRYPT_LOAD_MSBFIRST32 (   p)    SYMCRYPT_INTERNAL_LOAD_MSBFIRST32( p )

Definition at line 303 of file symcrypt.h.

◆ SYMCRYPT_LOAD_MSBFIRST64

#define SYMCRYPT_LOAD_MSBFIRST64 (   p)    SYMCRYPT_INTERNAL_LOAD_MSBFIRST64( p )

Definition at line 304 of file symcrypt.h.

◆ SYMCRYPT_MARVIN32_INPUT_BLOCK_SIZE

#define SYMCRYPT_MARVIN32_INPUT_BLOCK_SIZE   (4)

Definition at line 3990 of file symcrypt.h.

◆ SYMCRYPT_MARVIN32_RESULT_SIZE

#define SYMCRYPT_MARVIN32_RESULT_SIZE   (8)

Definition at line 3988 of file symcrypt.h.

◆ SYMCRYPT_MARVIN32_SEED_SIZE

#define SYMCRYPT_MARVIN32_SEED_SIZE   (8)

Definition at line 3989 of file symcrypt.h.

◆ SYMCRYPT_MD2_INPUT_BLOCK_SIZE

#define SYMCRYPT_MD2_INPUT_BLOCK_SIZE   (16)

Definition at line 892 of file symcrypt.h.

◆ SYMCRYPT_MD2_RESULT_SIZE

#define SYMCRYPT_MD2_RESULT_SIZE   (16)

Definition at line 891 of file symcrypt.h.

◆ SYMCRYPT_MD4_INPUT_BLOCK_SIZE

#define SYMCRYPT_MD4_INPUT_BLOCK_SIZE   (64)

Definition at line 955 of file symcrypt.h.

◆ SYMCRYPT_MD4_RESULT_SIZE

#define SYMCRYPT_MD4_RESULT_SIZE   (16)

Definition at line 954 of file symcrypt.h.

◆ SYMCRYPT_MD5_INPUT_BLOCK_SIZE

#define SYMCRYPT_MD5_INPUT_BLOCK_SIZE   (64)

Definition at line 1018 of file symcrypt.h.

◆ SYMCRYPT_MD5_RESULT_SIZE

#define SYMCRYPT_MD5_RESULT_SIZE   (16)

Definition at line 1017 of file symcrypt.h.

◆ SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH

#define SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH   (255)

Definition at line 10395 of file symcrypt.h.

◆ SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA44

#define SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA44   (2420)

Definition at line 10457 of file symcrypt.h.

◆ SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA65

#define SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA65   (3309)

Definition at line 10458 of file symcrypt.h.

◆ SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA87

#define SYMCRYPT_MLDSA_SIGNATURE_SIZE_MLDSA87   (4627)

Definition at line 10459 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM1024

#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM1024   (1568)

Definition at line 10032 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM512

#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM512   (768)

Definition at line 10030 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM768

#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM768   (1088)

Definition at line 10031 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM1024

#define SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM1024   (3168)

Definition at line 10015 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM512

#define SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM512   (1632)

Definition at line 10013 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM768

#define SYMCRYPT_MLKEM_DECAPSULATION_KEY_SIZE_MLKEM768   (2400)

Definition at line 10014 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM1024

#define SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM1024   (1568)

Definition at line 10011 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM512

#define SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM512   (800)

Definition at line 10009 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM768

#define SYMCRYPT_MLKEM_ENCAPSULATION_KEY_SIZE_MLKEM768   (1184)

Definition at line 10010 of file symcrypt.h.

◆ SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE

#define SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE   (2*32)

Definition at line 10007 of file symcrypt.h.

◆ SYMCRYPT_MODULE_INIT

#define SYMCRYPT_MODULE_INIT ( )    SymCryptModuleInit( SYMCRYPT_CODE_VERSION_API, SYMCRYPT_CODE_VERSION_MINOR );

Definition at line 531 of file symcrypt.h.

◆ SYMCRYPT_POLY1305_BLOCK_SIZE

#define SYMCRYPT_POLY1305_BLOCK_SIZE   (16)

Definition at line 3857 of file symcrypt.h.

◆ SYMCRYPT_POLY1305_KEY_SIZE

#define SYMCRYPT_POLY1305_KEY_SIZE   (32)

Definition at line 3858 of file symcrypt.h.

◆ SYMCRYPT_POLY1305_RESULT_SIZE

#define SYMCRYPT_POLY1305_RESULT_SIZE   (16)

Definition at line 3856 of file symcrypt.h.

◆ SYMCRYPT_RC2_BLOCK_SIZE

#define SYMCRYPT_RC2_BLOCK_SIZE   (8)

Definition at line 4543 of file symcrypt.h.

◆ SYMCRYPT_RNG_AES_MAX_SEED_SIZE

#define SYMCRYPT_RNG_AES_MAX_SEED_SIZE   (256)

Definition at line 6182 of file symcrypt.h.

◆ SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE

#define SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE   (32 + 16)

Definition at line 6180 of file symcrypt.h.

◆ SYMCRYPT_RNG_AES_MIN_RESEED_SIZE

#define SYMCRYPT_RNG_AES_MIN_RESEED_SIZE   (32)

Definition at line 6181 of file symcrypt.h.

◆ SYMCRYPT_SHA1_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA1_INPUT_BLOCK_SIZE   (64)

Definition at line 1091 of file symcrypt.h.

◆ SYMCRYPT_SHA1_RESULT_SIZE

#define SYMCRYPT_SHA1_RESULT_SIZE   (20)

Definition at line 1090 of file symcrypt.h.

◆ SYMCRYPT_SHA224_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA224_INPUT_BLOCK_SIZE   (64)

Definition at line 1158 of file symcrypt.h.

◆ SYMCRYPT_SHA224_RESULT_SIZE

#define SYMCRYPT_SHA224_RESULT_SIZE   (28)

Definition at line 1157 of file symcrypt.h.

◆ SYMCRYPT_SHA256_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA256_INPUT_BLOCK_SIZE   (64)

Definition at line 1223 of file symcrypt.h.

◆ SYMCRYPT_SHA256_RESULT_SIZE

#define SYMCRYPT_SHA256_RESULT_SIZE   (32)

Definition at line 1222 of file symcrypt.h.

◆ SYMCRYPT_SHA384_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA384_INPUT_BLOCK_SIZE   (128)

Definition at line 1288 of file symcrypt.h.

◆ SYMCRYPT_SHA384_RESULT_SIZE

#define SYMCRYPT_SHA384_RESULT_SIZE   (48)

Definition at line 1287 of file symcrypt.h.

◆ SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE   (144)

Definition at line 1561 of file symcrypt.h.

◆ SYMCRYPT_SHA3_224_RESULT_SIZE

#define SYMCRYPT_SHA3_224_RESULT_SIZE   (28)

Definition at line 1560 of file symcrypt.h.

◆ SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE   (136)

Definition at line 1615 of file symcrypt.h.

◆ SYMCRYPT_SHA3_256_RESULT_SIZE

#define SYMCRYPT_SHA3_256_RESULT_SIZE   (32)

Definition at line 1614 of file symcrypt.h.

◆ SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE   (104)

Definition at line 1669 of file symcrypt.h.

◆ SYMCRYPT_SHA3_384_RESULT_SIZE

#define SYMCRYPT_SHA3_384_RESULT_SIZE   (48)

Definition at line 1668 of file symcrypt.h.

◆ SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE   (72)

Definition at line 1723 of file symcrypt.h.

◆ SYMCRYPT_SHA3_512_RESULT_SIZE

#define SYMCRYPT_SHA3_512_RESULT_SIZE   (64)

Definition at line 1722 of file symcrypt.h.

◆ SYMCRYPT_SHA512_224_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA512_224_INPUT_BLOCK_SIZE   (128)

Definition at line 1421 of file symcrypt.h.

◆ SYMCRYPT_SHA512_224_RESULT_SIZE

#define SYMCRYPT_SHA512_224_RESULT_SIZE   (28)

Definition at line 1420 of file symcrypt.h.

◆ SYMCRYPT_SHA512_256_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA512_256_INPUT_BLOCK_SIZE   (128)

Definition at line 1489 of file symcrypt.h.

◆ SYMCRYPT_SHA512_256_RESULT_SIZE

#define SYMCRYPT_SHA512_256_RESULT_SIZE   (32)

Definition at line 1488 of file symcrypt.h.

◆ SYMCRYPT_SHA512_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHA512_INPUT_BLOCK_SIZE   (128)

Definition at line 1353 of file symcrypt.h.

◆ SYMCRYPT_SHA512_RESULT_SIZE

#define SYMCRYPT_SHA512_RESULT_SIZE   (64)

Definition at line 1352 of file symcrypt.h.

◆ SYMCRYPT_SHAKE128_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHAKE128_INPUT_BLOCK_SIZE   (168)

Definition at line 1909 of file symcrypt.h.

◆ SYMCRYPT_SHAKE128_RESULT_SIZE

#define SYMCRYPT_SHAKE128_RESULT_SIZE   (32)

Definition at line 1908 of file symcrypt.h.

◆ SYMCRYPT_SHAKE256_INPUT_BLOCK_SIZE

#define SYMCRYPT_SHAKE256_INPUT_BLOCK_SIZE   (136)

Definition at line 1965 of file symcrypt.h.

◆ SYMCRYPT_SHAKE256_RESULT_SIZE

#define SYMCRYPT_SHAKE256_RESULT_SIZE   (64)

Definition at line 1964 of file symcrypt.h.

◆ SYMCRYPT_SIZEOF_RSAKEY_FROM_PARAMS

#define SYMCRYPT_SIZEOF_RSAKEY_FROM_PARAMS (   modBits,
  nPrimes,
  nPubExps 
)     SYMCRYPT_INTERNAL_SIZEOF_RSAKEY_FROM_PARAMS( modBits, nPrimes, nPubExps )

Definition at line 7292 of file symcrypt.h.

◆ SYMCRYPT_SRTCP_AUTHENTICATION_KEY

#define SYMCRYPT_SRTCP_AUTHENTICATION_KEY   0x04

Definition at line 5866 of file symcrypt.h.

◆ SYMCRYPT_SRTCP_ENCRYPTION_KEY

#define SYMCRYPT_SRTCP_ENCRYPTION_KEY   0x03

Definition at line 5865 of file symcrypt.h.

◆ SYMCRYPT_SRTCP_SALTING_KEY

#define SYMCRYPT_SRTCP_SALTING_KEY   0x05

Definition at line 5867 of file symcrypt.h.

◆ SYMCRYPT_SRTP_AUTHENTICATION_KEY

#define SYMCRYPT_SRTP_AUTHENTICATION_KEY   0x01

Definition at line 5863 of file symcrypt.h.

◆ SYMCRYPT_SRTP_ENCRYPTION_KEY

#define SYMCRYPT_SRTP_ENCRYPTION_KEY   0x00

Definition at line 5862 of file symcrypt.h.

◆ SYMCRYPT_SRTP_SALTING_KEY

#define SYMCRYPT_SRTP_SALTING_KEY   0x02

Definition at line 5864 of file symcrypt.h.

◆ SYMCRYPT_SSHKDF_ENCRYPTION_KEY_CLIENT_TO_SERVER

#define SYMCRYPT_SSHKDF_ENCRYPTION_KEY_CLIENT_TO_SERVER   0x43

Definition at line 5759 of file symcrypt.h.

◆ SYMCRYPT_SSHKDF_ENCRYPTION_KEY_SERVER_TO_CLIENT

#define SYMCRYPT_SSHKDF_ENCRYPTION_KEY_SERVER_TO_CLIENT   0x44

Definition at line 5760 of file symcrypt.h.

◆ SYMCRYPT_SSHKDF_INTEGRITY_KEY_CLIENT_TO_SERVER

#define SYMCRYPT_SSHKDF_INTEGRITY_KEY_CLIENT_TO_SERVER   0x45

Definition at line 5761 of file symcrypt.h.

◆ SYMCRYPT_SSHKDF_INTEGRITY_KEY_SERVER_TO_CLIENT

#define SYMCRYPT_SSHKDF_INTEGRITY_KEY_SERVER_TO_CLIENT   0x46

Definition at line 5762 of file symcrypt.h.

◆ SYMCRYPT_SSHKDF_IV_CLIENT_TO_SERVER

#define SYMCRYPT_SSHKDF_IV_CLIENT_TO_SERVER   0x41

Definition at line 5757 of file symcrypt.h.

◆ SYMCRYPT_SSHKDF_IV_SERVER_TO_CLIENT

#define SYMCRYPT_SSHKDF_IV_SERVER_TO_CLIENT   0x42

Definition at line 5758 of file symcrypt.h.

◆ SYMCRYPT_STORE_LSBFIRST16

#define SYMCRYPT_STORE_LSBFIRST16 (   p,
  v 
)    SYMCRYPT_INTERNAL_STORE_LSBFIRST16( p, v )

Definition at line 306 of file symcrypt.h.

◆ SYMCRYPT_STORE_LSBFIRST32

#define SYMCRYPT_STORE_LSBFIRST32 (   p,
  v 
)    SYMCRYPT_INTERNAL_STORE_LSBFIRST32( p, v )

Definition at line 307 of file symcrypt.h.

◆ SYMCRYPT_STORE_LSBFIRST64

#define SYMCRYPT_STORE_LSBFIRST64 (   p,
  v 
)    SYMCRYPT_INTERNAL_STORE_LSBFIRST64( p, v )

Definition at line 308 of file symcrypt.h.

◆ SYMCRYPT_STORE_MSBFIRST16

#define SYMCRYPT_STORE_MSBFIRST16 (   p,
  v 
)    SYMCRYPT_INTERNAL_STORE_MSBFIRST16( p, v )

Definition at line 310 of file symcrypt.h.

◆ SYMCRYPT_STORE_MSBFIRST32

#define SYMCRYPT_STORE_MSBFIRST32 (   p,
  v 
)    SYMCRYPT_INTERNAL_STORE_MSBFIRST32( p, v )

Definition at line 311 of file symcrypt.h.

◆ SYMCRYPT_STORE_MSBFIRST64

#define SYMCRYPT_STORE_MSBFIRST64 (   p,
  v 
)    SYMCRYPT_INTERNAL_STORE_MSBFIRST64( p, v )

Definition at line 312 of file symcrypt.h.

◆ SYMCRYPT_TLS_MAX_LABEL_SIZE

#define SYMCRYPT_TLS_MAX_LABEL_SIZE   256

Definition at line 5671 of file symcrypt.h.

◆ SYMCRYPT_TLS_MAX_SEED_SIZE

#define SYMCRYPT_TLS_MAX_SEED_SIZE   256

Definition at line 5672 of file symcrypt.h.

Typedef Documentation

◆ PCSYMCRYPT_ECURVE_PARAMS

typedef const SYMCRYPT_ECURVE_PARAMS* PCSYMCRYPT_ECURVE_PARAMS

Definition at line 7187 of file symcrypt.h.

◆ PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION

typedef const SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION* PCSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION

Definition at line 7101 of file symcrypt.h.

◆ PCSYMCRYPT_RSA_PARAMS

typedef const SYMCRYPT_RSA_PARAMS* PCSYMCRYPT_RSA_PARAMS

Definition at line 7038 of file symcrypt.h.

◆ PCSYMCRYPT_UINT32_MAP

typedef const SYMCRYPT_UINT32_MAP* PCSYMCRYPT_UINT32_MAP

Definition at line 10775 of file symcrypt.h.

◆ PSYMCRYPT_ECURVE_PARAMS

typedef struct _SYMCRYPT_ECURVE_PARAMS * PSYMCRYPT_ECURVE_PARAMS

◆ PSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION

typedef struct _SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION * PSYMCRYPT_ECURVE_PARAMS_V2_EXTENSION

◆ PSYMCRYPT_RSA_PARAMS

typedef struct _SYMCRYPT_RSA_PARAMS * PSYMCRYPT_RSA_PARAMS

◆ PSYMCRYPT_UINT32_MAP

typedef struct _SYMCRYPT_UINT32_MAP * PSYMCRYPT_UINT32_MAP

◆ SYMCRYPT_BLOCKCIPHER_ID

typedef enum _SYMCRYPT_BLOCKCIPHER_ID SYMCRYPT_BLOCKCIPHER_ID

◆ SYMCRYPT_COMPOSITE_MLKEM_PARAMS

typedef enum _SYMCRYPT_COMPOSITE_MLKEM_PARAMS SYMCRYPT_COMPOSITE_MLKEM_PARAMS

◆ SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT

typedef enum _SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT

◆ SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE

typedef enum _SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE

◆ SYMCRYPT_DLGROUP_FIPS

typedef enum _SYMCRYPT_DLGROUP_FIPS SYMCRYPT_DLGROUP_FIPS

◆ SYMCRYPT_ECKEY_PRIVATE_FORMAT

typedef enum _SYMCRYPT_ECKEY_PRIVATE_FORMAT SYMCRYPT_ECKEY_PRIVATE_FORMAT

◆ SYMCRYPT_ECPOINT_FORMAT

typedef enum _SYMCRYPT_ECPOINT_FORMAT SYMCRYPT_ECPOINT_FORMAT

◆ SYMCRYPT_ECURVE_GEN_ALG_ID

typedef enum _SYMCRYPT_ECURVE_GEN_ALG_ID SYMCRYPT_ECURVE_GEN_ALG_ID

◆ SYMCRYPT_ECURVE_ID

typedef enum _SYMCRYPT_ECURVE_ID SYMCRYPT_ECURVE_ID

◆ SYMCRYPT_ECURVE_PARAMS

typedef struct _SYMCRYPT_ECURVE_PARAMS SYMCRYPT_ECURVE_PARAMS

◆ SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION

typedef struct _SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION SYMCRYPT_ECURVE_PARAMS_V2_EXTENSION

◆ SYMCRYPT_ECURVE_TYPE

typedef enum _SYMCRYPT_ECURVE_TYPE SYMCRYPT_ECURVE_TYPE

◆ SYMCRYPT_HASH_ID

typedef enum _SYMCRYPT_HASH_ID SYMCRYPT_HASH_ID

◆ SYMCRYPT_LMS_ALGID

typedef enum _SYMCRYPT_LMS_ALGID SYMCRYPT_LMS_ALGID

◆ SYMCRYPT_LMS_OTS_ALGID

typedef enum _SYMCRYPT_LMS_OTS_ALGID SYMCRYPT_LMS_OTS_ALGID

◆ SYMCRYPT_LMSKEY_TYPE

typedef enum _SYMCRYPT_LMSKEY_TYPE SYMCRYPT_LMSKEY_TYPE

◆ SYMCRYPT_MAC_ID

typedef enum _SYMCRYPT_MAC_ID SYMCRYPT_MAC_ID

◆ SYMCRYPT_MLDSA_PARAMS

typedef enum _SYMCRYPT_MLDSA_PARAMS SYMCRYPT_MLDSA_PARAMS

◆ SYMCRYPT_MLDSAKEY_FORMAT

typedef enum _SYMCRYPT_MLDSAKEY_FORMAT SYMCRYPT_MLDSAKEY_FORMAT

◆ SYMCRYPT_MLKEM_PARAMS

typedef enum _SYMCRYPT_MLKEM_PARAMS SYMCRYPT_MLKEM_PARAMS

◆ SYMCRYPT_MLKEMKEY_FORMAT

typedef enum _SYMCRYPT_MLKEMKEY_FORMAT SYMCRYPT_MLKEMKEY_FORMAT

◆ SYMCRYPT_NUMBER_FORMAT

typedef enum _SYMCRYPT_NUMBER_FORMAT SYMCRYPT_NUMBER_FORMAT

◆ SYMCRYPT_PQDSA_HASH_ID

typedef enum _SYMCRYPT_PQDSA_HASH_ID SYMCRYPT_PQDSA_HASH_ID

◆ SYMCRYPT_RSA_PARAMS

typedef struct _SYMCRYPT_RSA_PARAMS SYMCRYPT_RSA_PARAMS

◆ SYMCRYPT_UINT32_MAP

typedef struct _SYMCRYPT_UINT32_MAP SYMCRYPT_UINT32_MAP

◆ SYMCRYPT_XMSS_ALGID

typedef enum _SYMCRYPT_XMSS_ALGID SYMCRYPT_XMSS_ALGID

◆ SYMCRYPT_XMSSKEY_TYPE

typedef enum _SYMCRYPT_XMSSKEY_TYPE SYMCRYPT_XMSSKEY_TYPE

◆ SYMCRYPT_XMSSMT_ALGID

typedef enum _SYMCRYPT_XMSSMT_ALGID SYMCRYPT_XMSSMT_ALGID

Enumeration Type Documentation

◆ _SYMCRYPT_BLOCKCIPHER_ID

enum _SYMCRYPT_BLOCKCIPHER_ID
Enumerator
SYMCRYPT_BLOCKCIPHER_ID_NULL 
SYMCRYPT_BLOCKCIPHER_ID_AES 
SYMCRYPT_BLOCKCIPHER_ID_DES 
SYMCRYPT_BLOCKCIPHER_ID_3DES 
SYMCRYPT_BLOCKCIPHER_ID_DESX 
SYMCRYPT_BLOCKCIPHER_ID_RC2 

Definition at line 4618 of file symcrypt.h.

4619{
4620 SYMCRYPT_BLOCKCIPHER_ID_NULL = 0,
4621 SYMCRYPT_BLOCKCIPHER_ID_AES = 1,
4622 SYMCRYPT_BLOCKCIPHER_ID_DES = 2,
4623 SYMCRYPT_BLOCKCIPHER_ID_3DES = 3,
4624 SYMCRYPT_BLOCKCIPHER_ID_DESX = 4,
4625 SYMCRYPT_BLOCKCIPHER_ID_RC2 = 5
4626} SYMCRYPT_BLOCKCIPHER_ID;
SYMCRYPT_BLOCKCIPHER_ID_DESX
@ SYMCRYPT_BLOCKCIPHER_ID_DESX
Definition: symcrypt.h:4624
SYMCRYPT_BLOCKCIPHER_ID_DES
@ SYMCRYPT_BLOCKCIPHER_ID_DES
Definition: symcrypt.h:4622
SYMCRYPT_BLOCKCIPHER_ID_AES
@ SYMCRYPT_BLOCKCIPHER_ID_AES
Definition: symcrypt.h:4621
SYMCRYPT_BLOCKCIPHER_ID_3DES
@ SYMCRYPT_BLOCKCIPHER_ID_3DES
Definition: symcrypt.h:4623
SYMCRYPT_BLOCKCIPHER_ID_RC2
@ SYMCRYPT_BLOCKCIPHER_ID_RC2
Definition: symcrypt.h:4625
SYMCRYPT_BLOCKCIPHER_ID_NULL
@ SYMCRYPT_BLOCKCIPHER_ID_NULL
Definition: symcrypt.h:4620
SYMCRYPT_BLOCKCIPHER_ID
enum _SYMCRYPT_BLOCKCIPHER_ID SYMCRYPT_BLOCKCIPHER_ID

◆ _SYMCRYPT_COMPOSITE_MLKEM_PARAMS

enum _SYMCRYPT_COMPOSITE_MLKEM_PARAMS
Enumerator
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_NULL 
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_P256 
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_X25519 
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM1024_P384 

Definition at line 10200 of file symcrypt.h.

10200 {
10201 SYMCRYPT_COMPOSITE_MLKEM_PARAMS_NULL = 0,
10202 SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_P256 = 1,
10203 SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_X25519 = 2,
10204 SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM1024_P384 = 3,
10205} SYMCRYPT_COMPOSITE_MLKEM_PARAMS;
SYMCRYPT_COMPOSITE_MLKEM_PARAMS
enum _SYMCRYPT_COMPOSITE_MLKEM_PARAMS SYMCRYPT_COMPOSITE_MLKEM_PARAMS
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_P256
@ SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_P256
Definition: symcrypt.h:10202
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM1024_P384
@ SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM1024_P384
Definition: symcrypt.h:10204
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_NULL
@ SYMCRYPT_COMPOSITE_MLKEM_PARAMS_NULL
Definition: symcrypt.h:10201
SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_X25519
@ SYMCRYPT_COMPOSITE_MLKEM_PARAMS_MLKEM768_X25519
Definition: symcrypt.h:10203

◆ _SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT

enum _SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT
Enumerator
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_NULL 
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_IRTF_PRIVATE_SEED 
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_LAMPS_PRIVATE_KEY 
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_PUBLIC_KEY 

Definition at line 10182 of file symcrypt.h.

10182 {
10183 SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_NULL = 0,
10184 SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_IRTF_PRIVATE_SEED = 1,
10185 // 32-byte seed for deriving Composite ML-KEM key, per irtf-cfrg-hybrid-kems CG framework
10186 SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_LAMPS_PRIVATE_KEY = 2,
10187 // Standard byte encoding of a Composite ML-KEM private key, per LAMPS composite ML-KEM draft 12.
10188 // Concatenation of ML-KEM private seed and private key of the traditional component:
10189 // mlkemSeed || tradSK
10190 // Size in bytes are MLKEM768_P256: 115, MLKEM768_X25519: 96, MLKEM1024_P384: 128
10191 SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_PUBLIC_KEY = 3,
10192 // Standard byte encoding of a Composite ML-KEM public key, per irtf-cfrg-hybrid-kems CG framework
10193 // and LAMPS composite ML-KEM draft 12.
10194 // Concatenation of ML-KEM encapsulation key and public key of the traditional component:
10195 // mlkemPK || tradPK
10196 // Size in bytes are MLKEM768_P256: 1249, MLKEM768_X25519: 1216, MLKEM1024_P384: 1665
10197} SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT;
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT
enum _SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_IRTF_PRIVATE_SEED
@ SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_IRTF_PRIVATE_SEED
Definition: symcrypt.h:10184
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_LAMPS_PRIVATE_KEY
@ SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_LAMPS_PRIVATE_KEY
Definition: symcrypt.h:10186
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_PUBLIC_KEY
@ SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_PUBLIC_KEY
Definition: symcrypt.h:10191
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_NULL
@ SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT_NULL
Definition: symcrypt.h:10183

◆ _SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE

enum _SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE
Enumerator
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_NONE 
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_IKE_3526 
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919 

Definition at line 261 of file symcrypt.h.

261 {
262 SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_NONE = 0,
263 SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_IKE_3526 = 1,
264 SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919 = 2,
265} SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE;
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_NONE
@ SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_NONE
Definition: symcrypt.h:262
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919
@ SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_TLS_7919
Definition: symcrypt.h:264
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_IKE_3526
@ SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_IKE_3526
Definition: symcrypt.h:263
SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE
enum _SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE

◆ _SYMCRYPT_DLGROUP_FIPS

enum _SYMCRYPT_DLGROUP_FIPS
Enumerator
SYMCRYPT_DLGROUP_FIPS_NONE 
SYMCRYPT_DLGROUP_FIPS_186_2 
SYMCRYPT_DLGROUP_FIPS_186_3 

Definition at line 247 of file symcrypt.h.

247 {
248 SYMCRYPT_DLGROUP_FIPS_NONE = 0,
249 SYMCRYPT_DLGROUP_FIPS_186_2 = 1,
250 SYMCRYPT_DLGROUP_FIPS_186_3 = 2,
251} SYMCRYPT_DLGROUP_FIPS;
SYMCRYPT_DLGROUP_FIPS_186_3
@ SYMCRYPT_DLGROUP_FIPS_186_3
Definition: symcrypt.h:250
SYMCRYPT_DLGROUP_FIPS_186_2
@ SYMCRYPT_DLGROUP_FIPS_186_2
Definition: symcrypt.h:249
SYMCRYPT_DLGROUP_FIPS_NONE
@ SYMCRYPT_DLGROUP_FIPS_NONE
Definition: symcrypt.h:248
SYMCRYPT_DLGROUP_FIPS
enum _SYMCRYPT_DLGROUP_FIPS SYMCRYPT_DLGROUP_FIPS

◆ _SYMCRYPT_ECKEY_PRIVATE_FORMAT

enum _SYMCRYPT_ECKEY_PRIVATE_FORMAT
Enumerator
SYMCRYPT_ECKEY_PRIVATE_FORMAT_NULL 
SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL 
SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH 
SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH 

Definition at line 7128 of file symcrypt.h.

7128 {
7129 SYMCRYPT_ECKEY_PRIVATE_FORMAT_NULL = 0,
7130 SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL = 1,
7131 SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH = 2,
7132 SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH = 3,
7133} SYMCRYPT_ECKEY_PRIVATE_FORMAT;
SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH
@ SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH
Definition: symcrypt.h:7132
SYMCRYPT_ECKEY_PRIVATE_FORMAT_NULL
@ SYMCRYPT_ECKEY_PRIVATE_FORMAT_NULL
Definition: symcrypt.h:7129
SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL
@ SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL
Definition: symcrypt.h:7130
SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH
@ SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH
Definition: symcrypt.h:7131
SYMCRYPT_ECKEY_PRIVATE_FORMAT
enum _SYMCRYPT_ECKEY_PRIVATE_FORMAT SYMCRYPT_ECKEY_PRIVATE_FORMAT

◆ _SYMCRYPT_ECPOINT_FORMAT

enum _SYMCRYPT_ECPOINT_FORMAT
Enumerator
SYMCRYPT_ECPOINT_FORMAT_X 
SYMCRYPT_ECPOINT_FORMAT_XY 

Definition at line 7193 of file symcrypt.h.

7193 {
7194 SYMCRYPT_ECPOINT_FORMAT_X = 1, // One value, encoding the X coordinate only of a point
7195 SYMCRYPT_ECPOINT_FORMAT_XY = 2, // Two equally-sized values, the first one encoding X and the second one encoding Y
7196} SYMCRYPT_ECPOINT_FORMAT;
SYMCRYPT_ECPOINT_FORMAT_X
@ SYMCRYPT_ECPOINT_FORMAT_X
Definition: symcrypt.h:7194
SYMCRYPT_ECPOINT_FORMAT_XY
@ SYMCRYPT_ECPOINT_FORMAT_XY
Definition: symcrypt.h:7195
SYMCRYPT_ECPOINT_FORMAT
enum _SYMCRYPT_ECPOINT_FORMAT SYMCRYPT_ECPOINT_FORMAT

◆ _SYMCRYPT_ECURVE_GEN_ALG_ID

enum _SYMCRYPT_ECURVE_GEN_ALG_ID
Enumerator
SYMCRYPT_ECURVE_GEN_ALG_ID_NULL 

Definition at line 7086 of file symcrypt.h.

7086 {
7087 SYMCRYPT_ECURVE_GEN_ALG_ID_NULL = 0,
7088} SYMCRYPT_ECURVE_GEN_ALG_ID;
SYMCRYPT_ECURVE_GEN_ALG_ID_NULL
@ SYMCRYPT_ECURVE_GEN_ALG_ID_NULL
Definition: symcrypt.h:7087
SYMCRYPT_ECURVE_GEN_ALG_ID
enum _SYMCRYPT_ECURVE_GEN_ALG_ID SYMCRYPT_ECURVE_GEN_ALG_ID

◆ _SYMCRYPT_ECURVE_ID

enum _SYMCRYPT_ECURVE_ID
Enumerator
SYMCRYPT_ECURVE_ID_NULL 
SYMCRYPT_ECURVE_ID_NIST_P192 
SYMCRYPT_ECURVE_ID_NIST_P224 
SYMCRYPT_ECURVE_ID_NIST_P256 
SYMCRYPT_ECURVE_ID_NIST_P384 
SYMCRYPT_ECURVE_ID_NIST_P521 
SYMCRYPT_ECURVE_ID_NUMS_P256T1 
SYMCRYPT_ECURVE_ID_NUMS_P384T1 
SYMCRYPT_ECURVE_ID_NUMS_P512T1 
SYMCRYPT_ECURVE_ID_CURVE25519 

Definition at line 8297 of file symcrypt.h.

8298{
8299 SYMCRYPT_ECURVE_ID_NULL = 0,
8300 SYMCRYPT_ECURVE_ID_NIST_P192 = 1,
8301 SYMCRYPT_ECURVE_ID_NIST_P224 = 2,
8302 SYMCRYPT_ECURVE_ID_NIST_P256 = 3,
8303 SYMCRYPT_ECURVE_ID_NIST_P384 = 4,
8304 SYMCRYPT_ECURVE_ID_NIST_P521 = 5,
8305 SYMCRYPT_ECURVE_ID_NUMS_P256T1 = 6,
8306 SYMCRYPT_ECURVE_ID_NUMS_P384T1 = 7,
8307 SYMCRYPT_ECURVE_ID_NUMS_P512T1 = 8,
8308 SYMCRYPT_ECURVE_ID_CURVE25519 = 9
8309} SYMCRYPT_ECURVE_ID;
SYMCRYPT_ECURVE_ID
enum _SYMCRYPT_ECURVE_ID SYMCRYPT_ECURVE_ID
SYMCRYPT_ECURVE_ID_NIST_P256
@ SYMCRYPT_ECURVE_ID_NIST_P256
Definition: symcrypt.h:8302
SYMCRYPT_ECURVE_ID_NUMS_P256T1
@ SYMCRYPT_ECURVE_ID_NUMS_P256T1
Definition: symcrypt.h:8305
SYMCRYPT_ECURVE_ID_NUMS_P384T1
@ SYMCRYPT_ECURVE_ID_NUMS_P384T1
Definition: symcrypt.h:8306
SYMCRYPT_ECURVE_ID_NUMS_P512T1
@ SYMCRYPT_ECURVE_ID_NUMS_P512T1
Definition: symcrypt.h:8307
SYMCRYPT_ECURVE_ID_NIST_P224
@ SYMCRYPT_ECURVE_ID_NIST_P224
Definition: symcrypt.h:8301
SYMCRYPT_ECURVE_ID_NIST_P384
@ SYMCRYPT_ECURVE_ID_NIST_P384
Definition: symcrypt.h:8303
SYMCRYPT_ECURVE_ID_NIST_P521
@ SYMCRYPT_ECURVE_ID_NIST_P521
Definition: symcrypt.h:8304
SYMCRYPT_ECURVE_ID_CURVE25519
@ SYMCRYPT_ECURVE_ID_CURVE25519
Definition: symcrypt.h:8308
SYMCRYPT_ECURVE_ID_NULL
@ SYMCRYPT_ECURVE_ID_NULL
Definition: symcrypt.h:8299
SYMCRYPT_ECURVE_ID_NIST_P192
@ SYMCRYPT_ECURVE_ID_NIST_P192
Definition: symcrypt.h:8300

◆ _SYMCRYPT_ECURVE_TYPE

enum _SYMCRYPT_ECURVE_TYPE
Enumerator
SYMCRYPT_ECURVE_TYPE_NULL 
SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS 
SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS 
SYMCRYPT_ECURVE_TYPE_MONTGOMERY 

Definition at line 231 of file symcrypt.h.

231 {
232 SYMCRYPT_ECURVE_TYPE_NULL = 0,
233 SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS = 1,
234 SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS = 2,
235 SYMCRYPT_ECURVE_TYPE_MONTGOMERY = 3,
236} SYMCRYPT_ECURVE_TYPE;
SYMCRYPT_ECURVE_TYPE
enum _SYMCRYPT_ECURVE_TYPE SYMCRYPT_ECURVE_TYPE
SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS
@ SYMCRYPT_ECURVE_TYPE_TWISTED_EDWARDS
Definition: symcrypt.h:234
SYMCRYPT_ECURVE_TYPE_NULL
@ SYMCRYPT_ECURVE_TYPE_NULL
Definition: symcrypt.h:232
SYMCRYPT_ECURVE_TYPE_MONTGOMERY
@ SYMCRYPT_ECURVE_TYPE_MONTGOMERY
Definition: symcrypt.h:235
SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS
@ SYMCRYPT_ECURVE_TYPE_SHORT_WEIERSTRASS
Definition: symcrypt.h:233

◆ _SYMCRYPT_HASH_ID

enum _SYMCRYPT_HASH_ID
Enumerator
SYMCRYPT_HASH_ID_NULL 
SYMCRYPT_HASH_ID_MD2 
SYMCRYPT_HASH_ID_MD4 
SYMCRYPT_HASH_ID_MD5 
SYMCRYPT_HASH_ID_SHA1 
SYMCRYPT_HASH_ID_SHA224 
SYMCRYPT_HASH_ID_SHA256 
SYMCRYPT_HASH_ID_SHA384 
SYMCRYPT_HASH_ID_SHA512 
SYMCRYPT_HASH_ID_SHA512_224 
SYMCRYPT_HASH_ID_SHA512_256 
SYMCRYPT_HASH_ID_SHA3_224 
SYMCRYPT_HASH_ID_SHA3_256 
SYMCRYPT_HASH_ID_SHA3_384 
SYMCRYPT_HASH_ID_SHA3_512 
SYMCRYPT_HASH_ID_SHAKE128 
SYMCRYPT_HASH_ID_SHAKE256 

Definition at line 767 of file symcrypt.h.

768{
769 SYMCRYPT_HASH_ID_NULL = 0,
770 SYMCRYPT_HASH_ID_MD2 = 1,
771 SYMCRYPT_HASH_ID_MD4 = 2,
772 SYMCRYPT_HASH_ID_MD5 = 3,
773 SYMCRYPT_HASH_ID_SHA1 = 4,
774 SYMCRYPT_HASH_ID_SHA224 = 5,
775 SYMCRYPT_HASH_ID_SHA256 = 6,
776 SYMCRYPT_HASH_ID_SHA384 = 7,
777 SYMCRYPT_HASH_ID_SHA512 = 8,
778 SYMCRYPT_HASH_ID_SHA512_224 = 9,
779 SYMCRYPT_HASH_ID_SHA512_256 = 10,
780 SYMCRYPT_HASH_ID_SHA3_224 = 11,
781 SYMCRYPT_HASH_ID_SHA3_256 = 12,
782 SYMCRYPT_HASH_ID_SHA3_384 = 13,
783 SYMCRYPT_HASH_ID_SHA3_512 = 14,
784 SYMCRYPT_HASH_ID_SHAKE128 = 15,
785 SYMCRYPT_HASH_ID_SHAKE256 = 16
786} SYMCRYPT_HASH_ID;
SYMCRYPT_HASH_ID_SHA224
@ SYMCRYPT_HASH_ID_SHA224
Definition: symcrypt.h:774
SYMCRYPT_HASH_ID_SHA384
@ SYMCRYPT_HASH_ID_SHA384
Definition: symcrypt.h:776
SYMCRYPT_HASH_ID_MD2
@ SYMCRYPT_HASH_ID_MD2
Definition: symcrypt.h:770
SYMCRYPT_HASH_ID_NULL
@ SYMCRYPT_HASH_ID_NULL
Definition: symcrypt.h:769
SYMCRYPT_HASH_ID_SHA512_256
@ SYMCRYPT_HASH_ID_SHA512_256
Definition: symcrypt.h:779
SYMCRYPT_HASH_ID_SHA3_384
@ SYMCRYPT_HASH_ID_SHA3_384
Definition: symcrypt.h:782
SYMCRYPT_HASH_ID_SHA1
@ SYMCRYPT_HASH_ID_SHA1
Definition: symcrypt.h:773
SYMCRYPT_HASH_ID_SHAKE128
@ SYMCRYPT_HASH_ID_SHAKE128
Definition: symcrypt.h:784
SYMCRYPT_HASH_ID_SHA256
@ SYMCRYPT_HASH_ID_SHA256
Definition: symcrypt.h:775
SYMCRYPT_HASH_ID_SHAKE256
@ SYMCRYPT_HASH_ID_SHAKE256
Definition: symcrypt.h:785
SYMCRYPT_HASH_ID_SHA512
@ SYMCRYPT_HASH_ID_SHA512
Definition: symcrypt.h:777
SYMCRYPT_HASH_ID_MD5
@ SYMCRYPT_HASH_ID_MD5
Definition: symcrypt.h:772
SYMCRYPT_HASH_ID_SHA3_224
@ SYMCRYPT_HASH_ID_SHA3_224
Definition: symcrypt.h:780
SYMCRYPT_HASH_ID_SHA3_512
@ SYMCRYPT_HASH_ID_SHA3_512
Definition: symcrypt.h:783
SYMCRYPT_HASH_ID_SHA3_256
@ SYMCRYPT_HASH_ID_SHA3_256
Definition: symcrypt.h:781
SYMCRYPT_HASH_ID_MD4
@ SYMCRYPT_HASH_ID_MD4
Definition: symcrypt.h:771
SYMCRYPT_HASH_ID_SHA512_224
@ SYMCRYPT_HASH_ID_SHA512_224
Definition: symcrypt.h:778
SYMCRYPT_HASH_ID
enum _SYMCRYPT_HASH_ID SYMCRYPT_HASH_ID

◆ _SYMCRYPT_LMS_ALGID

enum _SYMCRYPT_LMS_ALGID
Enumerator
SYMCRYPT_LMS_SHA256_M32_H5 
SYMCRYPT_LMS_SHA256_M32_H10 
SYMCRYPT_LMS_SHA256_M32_H15 
SYMCRYPT_LMS_SHA256_M32_H20 
SYMCRYPT_LMS_SHA256_M32_H25 
SYMCRYPT_LMS_SHA256_M24_H5 
SYMCRYPT_LMS_SHA256_M24_H10 
SYMCRYPT_LMS_SHA256_M24_H15 
SYMCRYPT_LMS_SHA256_M24_H20 
SYMCRYPT_LMS_SHA256_M24_H25 
SYMCRYPT_LMS_SHAKE_M32_H5 
SYMCRYPT_LMS_SHAKE_M32_H10 
SYMCRYPT_LMS_SHAKE_M32_H15 
SYMCRYPT_LMS_SHAKE_M32_H20 
SYMCRYPT_LMS_SHAKE_M32_H25 
SYMCRYPT_LMS_SHAKE_M24_H5 
SYMCRYPT_LMS_SHAKE_M24_H10 
SYMCRYPT_LMS_SHAKE_M24_H15 
SYMCRYPT_LMS_SHAKE_M24_H20 
SYMCRYPT_LMS_SHAKE_M24_H25 

Definition at line 9559 of file symcrypt.h.

9560{
9561 //
9562 // Algorithm IDs for Leighton-Micali Hash-Based Signatures (LMS)
9563 // M equals the output length of the hash function, where H is the tree height.
9564 // The M parameter primarily affects the security and size of the signatures, while the H parameter
9565 // impacts the number of possible signatures and the computational cost for signing and verification.
9566 // Larger M increases security and signature size, but increases the computational cost
9567 // Higher H means more signatures but higher computational cost for signing and verification
9568 //
9569 SYMCRYPT_LMS_SHA256_M32_H5 = 0x00000005,
9570 SYMCRYPT_LMS_SHA256_M32_H10 = 0x00000006,
9571 SYMCRYPT_LMS_SHA256_M32_H15 = 0x00000007,
9572 SYMCRYPT_LMS_SHA256_M32_H20 = 0x00000008,
9573 SYMCRYPT_LMS_SHA256_M32_H25 = 0x00000009,
9574 SYMCRYPT_LMS_SHA256_M24_H5 = 0x0000000A,
9575 SYMCRYPT_LMS_SHA256_M24_H10 = 0x0000000B,
9576 SYMCRYPT_LMS_SHA256_M24_H15 = 0x0000000C,
9577 SYMCRYPT_LMS_SHA256_M24_H20 = 0x0000000D,
9578 SYMCRYPT_LMS_SHA256_M24_H25 = 0x0000000E,
9579 SYMCRYPT_LMS_SHAKE_M32_H5 = 0x0000000F,
9580 SYMCRYPT_LMS_SHAKE_M32_H10 = 0x00000010,
9581 SYMCRYPT_LMS_SHAKE_M32_H15 = 0x00000011,
9582 SYMCRYPT_LMS_SHAKE_M32_H20 = 0x00000012,
9583 SYMCRYPT_LMS_SHAKE_M32_H25 = 0x00000013,
9584 SYMCRYPT_LMS_SHAKE_M24_H5 = 0x00000014,
9585 SYMCRYPT_LMS_SHAKE_M24_H10 = 0x00000015,
9586 SYMCRYPT_LMS_SHAKE_M24_H15 = 0x00000016,
9587 SYMCRYPT_LMS_SHAKE_M24_H20 = 0x00000017,
9588 SYMCRYPT_LMS_SHAKE_M24_H25 = 0x00000018,
9589} SYMCRYPT_LMS_ALGID;
SYMCRYPT_LMS_ALGID
enum _SYMCRYPT_LMS_ALGID SYMCRYPT_LMS_ALGID
SYMCRYPT_LMS_SHA256_M24_H20
@ SYMCRYPT_LMS_SHA256_M24_H20
Definition: symcrypt.h:9577
SYMCRYPT_LMS_SHAKE_M32_H25
@ SYMCRYPT_LMS_SHAKE_M32_H25
Definition: symcrypt.h:9583
SYMCRYPT_LMS_SHAKE_M24_H5
@ SYMCRYPT_LMS_SHAKE_M24_H5
Definition: symcrypt.h:9584
SYMCRYPT_LMS_SHAKE_M32_H10
@ SYMCRYPT_LMS_SHAKE_M32_H10
Definition: symcrypt.h:9580
SYMCRYPT_LMS_SHA256_M24_H15
@ SYMCRYPT_LMS_SHA256_M24_H15
Definition: symcrypt.h:9576
SYMCRYPT_LMS_SHA256_M24_H25
@ SYMCRYPT_LMS_SHA256_M24_H25
Definition: symcrypt.h:9578
SYMCRYPT_LMS_SHA256_M32_H25
@ SYMCRYPT_LMS_SHA256_M32_H25
Definition: symcrypt.h:9573
SYMCRYPT_LMS_SHAKE_M24_H20
@ SYMCRYPT_LMS_SHAKE_M24_H20
Definition: symcrypt.h:9587
SYMCRYPT_LMS_SHA256_M32_H5
@ SYMCRYPT_LMS_SHA256_M32_H5
Definition: symcrypt.h:9569
SYMCRYPT_LMS_SHA256_M32_H20
@ SYMCRYPT_LMS_SHA256_M32_H20
Definition: symcrypt.h:9572
SYMCRYPT_LMS_SHA256_M32_H10
@ SYMCRYPT_LMS_SHA256_M32_H10
Definition: symcrypt.h:9570
SYMCRYPT_LMS_SHAKE_M24_H25
@ SYMCRYPT_LMS_SHAKE_M24_H25
Definition: symcrypt.h:9588
SYMCRYPT_LMS_SHA256_M32_H15
@ SYMCRYPT_LMS_SHA256_M32_H15
Definition: symcrypt.h:9571
SYMCRYPT_LMS_SHA256_M24_H10
@ SYMCRYPT_LMS_SHA256_M24_H10
Definition: symcrypt.h:9575
SYMCRYPT_LMS_SHAKE_M24_H15
@ SYMCRYPT_LMS_SHAKE_M24_H15
Definition: symcrypt.h:9586
SYMCRYPT_LMS_SHAKE_M24_H10
@ SYMCRYPT_LMS_SHAKE_M24_H10
Definition: symcrypt.h:9585
SYMCRYPT_LMS_SHA256_M24_H5
@ SYMCRYPT_LMS_SHA256_M24_H5
Definition: symcrypt.h:9574
SYMCRYPT_LMS_SHAKE_M32_H5
@ SYMCRYPT_LMS_SHAKE_M32_H5
Definition: symcrypt.h:9579
SYMCRYPT_LMS_SHAKE_M32_H15
@ SYMCRYPT_LMS_SHAKE_M32_H15
Definition: symcrypt.h:9581
SYMCRYPT_LMS_SHAKE_M32_H20
@ SYMCRYPT_LMS_SHAKE_M32_H20
Definition: symcrypt.h:9582

◆ _SYMCRYPT_LMS_OTS_ALGID

enum _SYMCRYPT_LMS_OTS_ALGID
Enumerator
SYMCRYPT_LMS_OTS_SHA256_N32_W1 
SYMCRYPT_LMS_OTS_SHA256_N32_W2 
SYMCRYPT_LMS_OTS_SHA256_N32_W4 
SYMCRYPT_LMS_OTS_SHA256_N32_W8 
SYMCRYPT_LMS_OTS_SHA256_N24_W1 
SYMCRYPT_LMS_OTS_SHA256_N24_W2 
SYMCRYPT_LMS_OTS_SHA256_N24_W4 
SYMCRYPT_LMS_OTS_SHA256_N24_W8 
SYMCRYPT_LMS_OTS_SHAKE_N32_W1 
SYMCRYPT_LMS_OTS_SHAKE_N32_W2 
SYMCRYPT_LMS_OTS_SHAKE_N32_W4 
SYMCRYPT_LMS_OTS_SHAKE_N32_W8 
SYMCRYPT_LMS_OTS_SHAKE_N24_W1 
SYMCRYPT_LMS_OTS_SHAKE_N24_W2 
SYMCRYPT_LMS_OTS_SHAKE_N24_W4 
SYMCRYPT_LMS_OTS_SHAKE_N24_W8 

Definition at line 9591 of file symcrypt.h.

9592{
9593 // Algorithm IDs for Leighton-Micali Hash-Based Signatures (LMS) One-Time-Signature (OTS)
9594 // N parameter represents the number of bytes in the hash function output. It determines the size of the hash values used in
9595 // the LMS OTS scheme.
9596 // W parameter represents the width of the Winternitz parameter used in LMS OTS. A larger value of w results in shorter
9597 // signatures but requires more computation during key generation, signature generation, and signature verification.
9598 //
9599 SYMCRYPT_LMS_OTS_SHA256_N32_W1 = 0x00000001,
9600 SYMCRYPT_LMS_OTS_SHA256_N32_W2 = 0x00000002,
9601 SYMCRYPT_LMS_OTS_SHA256_N32_W4 = 0x00000003,
9602 SYMCRYPT_LMS_OTS_SHA256_N32_W8 = 0x00000004,
9603 SYMCRYPT_LMS_OTS_SHA256_N24_W1 = 0x00000005,
9604 SYMCRYPT_LMS_OTS_SHA256_N24_W2 = 0x00000006,
9605 SYMCRYPT_LMS_OTS_SHA256_N24_W4 = 0x00000007,
9606 SYMCRYPT_LMS_OTS_SHA256_N24_W8 = 0x00000008,
9607 SYMCRYPT_LMS_OTS_SHAKE_N32_W1 = 0x00000009,
9608 SYMCRYPT_LMS_OTS_SHAKE_N32_W2 = 0x0000000A,
9609 SYMCRYPT_LMS_OTS_SHAKE_N32_W4 = 0x0000000B,
9610 SYMCRYPT_LMS_OTS_SHAKE_N32_W8 = 0x0000000C,
9611 SYMCRYPT_LMS_OTS_SHAKE_N24_W1 = 0x0000000D,
9612 SYMCRYPT_LMS_OTS_SHAKE_N24_W2 = 0x0000000E,
9613 SYMCRYPT_LMS_OTS_SHAKE_N24_W4 = 0x0000000F,
9614 SYMCRYPT_LMS_OTS_SHAKE_N24_W8 = 0x00000010,
9615} SYMCRYPT_LMS_OTS_ALGID;
SYMCRYPT_LMS_OTS_SHA256_N24_W4
@ SYMCRYPT_LMS_OTS_SHA256_N24_W4
Definition: symcrypt.h:9605
SYMCRYPT_LMS_OTS_SHAKE_N32_W1
@ SYMCRYPT_LMS_OTS_SHAKE_N32_W1
Definition: symcrypt.h:9607
SYMCRYPT_LMS_OTS_SHAKE_N32_W8
@ SYMCRYPT_LMS_OTS_SHAKE_N32_W8
Definition: symcrypt.h:9610
SYMCRYPT_LMS_OTS_SHAKE_N24_W4
@ SYMCRYPT_LMS_OTS_SHAKE_N24_W4
Definition: symcrypt.h:9613
SYMCRYPT_LMS_OTS_SHA256_N32_W8
@ SYMCRYPT_LMS_OTS_SHA256_N32_W8
Definition: symcrypt.h:9602
SYMCRYPT_LMS_OTS_SHA256_N32_W1
@ SYMCRYPT_LMS_OTS_SHA256_N32_W1
Definition: symcrypt.h:9599
SYMCRYPT_LMS_OTS_SHA256_N24_W2
@ SYMCRYPT_LMS_OTS_SHA256_N24_W2
Definition: symcrypt.h:9604
SYMCRYPT_LMS_OTS_SHAKE_N32_W2
@ SYMCRYPT_LMS_OTS_SHAKE_N32_W2
Definition: symcrypt.h:9608
SYMCRYPT_LMS_OTS_SHA256_N32_W4
@ SYMCRYPT_LMS_OTS_SHA256_N32_W4
Definition: symcrypt.h:9601
SYMCRYPT_LMS_OTS_SHAKE_N24_W2
@ SYMCRYPT_LMS_OTS_SHAKE_N24_W2
Definition: symcrypt.h:9612
SYMCRYPT_LMS_OTS_SHAKE_N32_W4
@ SYMCRYPT_LMS_OTS_SHAKE_N32_W4
Definition: symcrypt.h:9609
SYMCRYPT_LMS_OTS_SHA256_N24_W8
@ SYMCRYPT_LMS_OTS_SHA256_N24_W8
Definition: symcrypt.h:9606
SYMCRYPT_LMS_OTS_SHA256_N32_W2
@ SYMCRYPT_LMS_OTS_SHA256_N32_W2
Definition: symcrypt.h:9600
SYMCRYPT_LMS_OTS_SHAKE_N24_W1
@ SYMCRYPT_LMS_OTS_SHAKE_N24_W1
Definition: symcrypt.h:9611
SYMCRYPT_LMS_OTS_SHAKE_N24_W8
@ SYMCRYPT_LMS_OTS_SHAKE_N24_W8
Definition: symcrypt.h:9614
SYMCRYPT_LMS_OTS_SHA256_N24_W1
@ SYMCRYPT_LMS_OTS_SHA256_N24_W1
Definition: symcrypt.h:9603
SYMCRYPT_LMS_OTS_ALGID
enum _SYMCRYPT_LMS_OTS_ALGID SYMCRYPT_LMS_OTS_ALGID

◆ _SYMCRYPT_LMSKEY_TYPE

enum _SYMCRYPT_LMSKEY_TYPE
Enumerator
SYMCRYPT_LMSKEY_TYPE_NONE 
SYMCRYPT_LMSKEY_TYPE_PUBLIC 
SYMCRYPT_LMSKEY_TYPE_PRIVATE 

Definition at line 9620 of file symcrypt.h.

9621{
9622 SYMCRYPT_LMSKEY_TYPE_NONE = 0, // Key object does not contain any key material
9623 SYMCRYPT_LMSKEY_TYPE_PUBLIC = 1, // Key object contains only public key
9624 SYMCRYPT_LMSKEY_TYPE_PRIVATE = 2, // Key object contains both public key and private key
9625} SYMCRYPT_LMSKEY_TYPE;
SYMCRYPT_LMSKEY_TYPE
enum _SYMCRYPT_LMSKEY_TYPE SYMCRYPT_LMSKEY_TYPE
SYMCRYPT_LMSKEY_TYPE_PRIVATE
@ SYMCRYPT_LMSKEY_TYPE_PRIVATE
Definition: symcrypt.h:9624
SYMCRYPT_LMSKEY_TYPE_PUBLIC
@ SYMCRYPT_LMSKEY_TYPE_PUBLIC
Definition: symcrypt.h:9623
SYMCRYPT_LMSKEY_TYPE_NONE
@ SYMCRYPT_LMSKEY_TYPE_NONE
Definition: symcrypt.h:9622

◆ _SYMCRYPT_MAC_ID

enum _SYMCRYPT_MAC_ID
Enumerator
SYMCRYPT_MAC_ID_NULL 
SYMCRYPT_MAC_ID_HMAC_MD5 
SYMCRYPT_MAC_ID_HMAC_SHA1 
SYMCRYPT_MAC_ID_HMAC_SHA224 
SYMCRYPT_MAC_ID_HMAC_SHA256 
SYMCRYPT_MAC_ID_HMAC_SHA384 
SYMCRYPT_MAC_ID_HMAC_SHA512 
SYMCRYPT_MAC_ID_HMAC_SHA512_224 
SYMCRYPT_MAC_ID_HMAC_SHA512_256 
SYMCRYPT_MAC_ID_HMAC_SHA3_224 
SYMCRYPT_MAC_ID_HMAC_SHA3_256 
SYMCRYPT_MAC_ID_HMAC_SHA3_384 
SYMCRYPT_MAC_ID_HMAC_SHA3_512 
SYMCRYPT_MAC_ID_AES_CMAC 
SYMCRYPT_MAC_ID_KMAC_128 
SYMCRYPT_MAC_ID_KMAC_256 

Definition at line 2572 of file symcrypt.h.

2573{
2574 SYMCRYPT_MAC_ID_NULL = 0,
2575 SYMCRYPT_MAC_ID_HMAC_MD5 = 1,
2576 SYMCRYPT_MAC_ID_HMAC_SHA1 = 2,
2577 SYMCRYPT_MAC_ID_HMAC_SHA224 = 3,
2578 SYMCRYPT_MAC_ID_HMAC_SHA256 = 4,
2579 SYMCRYPT_MAC_ID_HMAC_SHA384 = 5,
2580 SYMCRYPT_MAC_ID_HMAC_SHA512 = 6,
2581 SYMCRYPT_MAC_ID_HMAC_SHA512_224 = 7,
2582 SYMCRYPT_MAC_ID_HMAC_SHA512_256 = 8,
2583 SYMCRYPT_MAC_ID_HMAC_SHA3_224 = 9,
2584 SYMCRYPT_MAC_ID_HMAC_SHA3_256 = 10,
2585 SYMCRYPT_MAC_ID_HMAC_SHA3_384 = 11,
2586 SYMCRYPT_MAC_ID_HMAC_SHA3_512 = 12,
2587 SYMCRYPT_MAC_ID_AES_CMAC = 13,
2588 SYMCRYPT_MAC_ID_KMAC_128 = 14,
2589 SYMCRYPT_MAC_ID_KMAC_256 = 15
2590} SYMCRYPT_MAC_ID;
SYMCRYPT_MAC_ID
enum _SYMCRYPT_MAC_ID SYMCRYPT_MAC_ID
SYMCRYPT_MAC_ID_AES_CMAC
@ SYMCRYPT_MAC_ID_AES_CMAC
Definition: symcrypt.h:2587
SYMCRYPT_MAC_ID_HMAC_SHA256
@ SYMCRYPT_MAC_ID_HMAC_SHA256
Definition: symcrypt.h:2578
SYMCRYPT_MAC_ID_HMAC_SHA3_256
@ SYMCRYPT_MAC_ID_HMAC_SHA3_256
Definition: symcrypt.h:2584
SYMCRYPT_MAC_ID_HMAC_SHA512_256
@ SYMCRYPT_MAC_ID_HMAC_SHA512_256
Definition: symcrypt.h:2582
SYMCRYPT_MAC_ID_HMAC_SHA3_512
@ SYMCRYPT_MAC_ID_HMAC_SHA3_512
Definition: symcrypt.h:2586
SYMCRYPT_MAC_ID_HMAC_SHA512
@ SYMCRYPT_MAC_ID_HMAC_SHA512
Definition: symcrypt.h:2580
SYMCRYPT_MAC_ID_HMAC_SHA384
@ SYMCRYPT_MAC_ID_HMAC_SHA384
Definition: symcrypt.h:2579
SYMCRYPT_MAC_ID_HMAC_SHA3_384
@ SYMCRYPT_MAC_ID_HMAC_SHA3_384
Definition: symcrypt.h:2585
SYMCRYPT_MAC_ID_HMAC_MD5
@ SYMCRYPT_MAC_ID_HMAC_MD5
Definition: symcrypt.h:2575
SYMCRYPT_MAC_ID_HMAC_SHA3_224
@ SYMCRYPT_MAC_ID_HMAC_SHA3_224
Definition: symcrypt.h:2583
SYMCRYPT_MAC_ID_KMAC_128
@ SYMCRYPT_MAC_ID_KMAC_128
Definition: symcrypt.h:2588
SYMCRYPT_MAC_ID_NULL
@ SYMCRYPT_MAC_ID_NULL
Definition: symcrypt.h:2574
SYMCRYPT_MAC_ID_HMAC_SHA512_224
@ SYMCRYPT_MAC_ID_HMAC_SHA512_224
Definition: symcrypt.h:2581
SYMCRYPT_MAC_ID_HMAC_SHA224
@ SYMCRYPT_MAC_ID_HMAC_SHA224
Definition: symcrypt.h:2577
SYMCRYPT_MAC_ID_HMAC_SHA1
@ SYMCRYPT_MAC_ID_HMAC_SHA1
Definition: symcrypt.h:2576
SYMCRYPT_MAC_ID_KMAC_256
@ SYMCRYPT_MAC_ID_KMAC_256
Definition: symcrypt.h:2589

◆ _SYMCRYPT_MLDSA_PARAMS

enum _SYMCRYPT_MLDSA_PARAMS
Enumerator
SYMCRYPT_MLDSA_PARAMS_NULL 
SYMCRYPT_MLDSA_PARAMS_MLDSA44 
SYMCRYPT_MLDSA_PARAMS_MLDSA65 
SYMCRYPT_MLDSA_PARAMS_MLDSA87 

Definition at line 10415 of file symcrypt.h.

10415 {
10416 SYMCRYPT_MLDSA_PARAMS_NULL = 0,
10417 SYMCRYPT_MLDSA_PARAMS_MLDSA44 = 1,
10418 SYMCRYPT_MLDSA_PARAMS_MLDSA65 = 2,
10419 SYMCRYPT_MLDSA_PARAMS_MLDSA87 = 3,
10420} SYMCRYPT_MLDSA_PARAMS;
SYMCRYPT_MLDSA_PARAMS_MLDSA44
@ SYMCRYPT_MLDSA_PARAMS_MLDSA44
Definition: symcrypt.h:10417
SYMCRYPT_MLDSA_PARAMS_MLDSA65
@ SYMCRYPT_MLDSA_PARAMS_MLDSA65
Definition: symcrypt.h:10418
SYMCRYPT_MLDSA_PARAMS_NULL
@ SYMCRYPT_MLDSA_PARAMS_NULL
Definition: symcrypt.h:10416
SYMCRYPT_MLDSA_PARAMS_MLDSA87
@ SYMCRYPT_MLDSA_PARAMS_MLDSA87
Definition: symcrypt.h:10419
SYMCRYPT_MLDSA_PARAMS
enum _SYMCRYPT_MLDSA_PARAMS SYMCRYPT_MLDSA_PARAMS

◆ _SYMCRYPT_MLDSAKEY_FORMAT

enum _SYMCRYPT_MLDSAKEY_FORMAT
Enumerator
SYMCRYPT_MLDSAKEY_FORMAT_NULL 
SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_SEED 
SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_KEY 
SYMCRYPT_MLDSAKEY_FORMAT_PUBLIC_KEY 

Definition at line 10401 of file symcrypt.h.

10401 {
10402 SYMCRYPT_MLDSAKEY_FORMAT_NULL = 0,
10403 SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_SEED = 1,
10404 // 32-byte private root seed xi from which all other parameters can be derived.
10405 // On its own it is ambiguous which ML-DSA parameter set this represents; callers wanting to
10406 // store this format must track the parameter set alongside the key.
10407 SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_KEY = 2,
10408 // Standard byte encoding of an ML-DSA private key, per FIPS 204.
10409 // Size is 2560, 4032, or 4896 bytes for ML-DSA 44, 65, and 87 respectively.
10410 SYMCRYPT_MLDSAKEY_FORMAT_PUBLIC_KEY = 3,
10411 // Standard byte encoding of an ML-DSA public key, per FIPS 204.
10412 // Size is 1312, 1952, or 2592 bytes for ML-DSA 44, 65, and 87 respectively.
10413} SYMCRYPT_MLDSAKEY_FORMAT;
SYMCRYPT_MLDSAKEY_FORMAT_NULL
@ SYMCRYPT_MLDSAKEY_FORMAT_NULL
Definition: symcrypt.h:10402
SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_KEY
@ SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_KEY
Definition: symcrypt.h:10407
SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_SEED
@ SYMCRYPT_MLDSAKEY_FORMAT_PRIVATE_SEED
Definition: symcrypt.h:10403
SYMCRYPT_MLDSAKEY_FORMAT_PUBLIC_KEY
@ SYMCRYPT_MLDSAKEY_FORMAT_PUBLIC_KEY
Definition: symcrypt.h:10410
SYMCRYPT_MLDSAKEY_FORMAT
enum _SYMCRYPT_MLDSAKEY_FORMAT SYMCRYPT_MLDSAKEY_FORMAT

◆ _SYMCRYPT_MLKEM_PARAMS

enum _SYMCRYPT_MLKEM_PARAMS
Enumerator
SYMCRYPT_MLKEM_PARAMS_NULL 
SYMCRYPT_MLKEM_PARAMS_MLKEM512 
SYMCRYPT_MLKEM_PARAMS_MLKEM768 
SYMCRYPT_MLKEM_PARAMS_MLKEM1024 

Definition at line 9978 of file symcrypt.h.

9978 {
9979 SYMCRYPT_MLKEM_PARAMS_NULL = 0,
9980 SYMCRYPT_MLKEM_PARAMS_MLKEM512 = 1,
9981 SYMCRYPT_MLKEM_PARAMS_MLKEM768 = 2,
9982 SYMCRYPT_MLKEM_PARAMS_MLKEM1024 = 3,
9983} SYMCRYPT_MLKEM_PARAMS;
SYMCRYPT_MLKEM_PARAMS
enum _SYMCRYPT_MLKEM_PARAMS SYMCRYPT_MLKEM_PARAMS
SYMCRYPT_MLKEM_PARAMS_MLKEM768
@ SYMCRYPT_MLKEM_PARAMS_MLKEM768
Definition: symcrypt.h:9981
SYMCRYPT_MLKEM_PARAMS_MLKEM512
@ SYMCRYPT_MLKEM_PARAMS_MLKEM512
Definition: symcrypt.h:9980
SYMCRYPT_MLKEM_PARAMS_MLKEM1024
@ SYMCRYPT_MLKEM_PARAMS_MLKEM1024
Definition: symcrypt.h:9982
SYMCRYPT_MLKEM_PARAMS_NULL
@ SYMCRYPT_MLKEM_PARAMS_NULL
Definition: symcrypt.h:9979

◆ _SYMCRYPT_MLKEMKEY_FORMAT

enum _SYMCRYPT_MLKEMKEY_FORMAT
Enumerator
SYMCRYPT_MLKEMKEY_FORMAT_NULL 
SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED 
SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY 
SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY 

Definition at line 9962 of file symcrypt.h.

9962 {
9963 SYMCRYPT_MLKEMKEY_FORMAT_NULL = 0,
9964 SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED = 1,
9965 // 64-byte concatenation of d || z from FIPS 203. Smallest representation of a full
9966 // ML-KEM key.
9967 // On its own it is ambiguous which ML-KEM parameter set this represents; callers wanting to
9968 // store this format must track the parameter set alongside the key.
9969 SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY = 2,
9970 // Standard byte encoding of an ML-KEM Decapsulation key, per FIPS 203.
9971 // Size is 1632, 2400, or 3168 bytes for ML-KEM 512, 768, and 1024 respectively.
9972 SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY = 3,
9973 // Standard byte encoding of an ML-KEM Encapsulation key, per FIPS 203.
9974 // Size is 800, 1184, or 1568 bytes for ML-KEM 512, 768, and 1024 respectively.
9975} SYMCRYPT_MLKEMKEY_FORMAT;
SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED
@ SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED
Definition: symcrypt.h:9964
SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY
@ SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY
Definition: symcrypt.h:9972
SYMCRYPT_MLKEMKEY_FORMAT_NULL
@ SYMCRYPT_MLKEMKEY_FORMAT_NULL
Definition: symcrypt.h:9963
SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY
@ SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY
Definition: symcrypt.h:9969
SYMCRYPT_MLKEMKEY_FORMAT
enum _SYMCRYPT_MLKEMKEY_FORMAT SYMCRYPT_MLKEMKEY_FORMAT

◆ _SYMCRYPT_NUMBER_FORMAT

enum _SYMCRYPT_NUMBER_FORMAT
Enumerator
SYMCRYPT_NUMBER_FORMAT_LSB_FIRST 
SYMCRYPT_NUMBER_FORMAT_MSB_FIRST 

Definition at line 7015 of file symcrypt.h.

7015 {
7016 SYMCRYPT_NUMBER_FORMAT_LSB_FIRST = 1,
7017 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST = 2,
7018} SYMCRYPT_NUMBER_FORMAT;
SYMCRYPT_NUMBER_FORMAT
enum _SYMCRYPT_NUMBER_FORMAT SYMCRYPT_NUMBER_FORMAT
SYMCRYPT_NUMBER_FORMAT_MSB_FIRST
@ SYMCRYPT_NUMBER_FORMAT_MSB_FIRST
Definition: symcrypt.h:7017
SYMCRYPT_NUMBER_FORMAT_LSB_FIRST
@ SYMCRYPT_NUMBER_FORMAT_LSB_FIRST
Definition: symcrypt.h:7016

◆ _SYMCRYPT_PQDSA_HASH_ID

enum _SYMCRYPT_PQDSA_HASH_ID
Enumerator
SYMCRYPT_PQDSA_HASH_ID_NULL 
SYMCRYPT_PQDSA_HASH_ID_SHA256 
SYMCRYPT_PQDSA_HASH_ID_SHA384 
SYMCRYPT_PQDSA_HASH_ID_SHA512 
SYMCRYPT_PQDSA_HASH_ID_SHA512_256 
SYMCRYPT_PQDSA_HASH_ID_SHA3_256 
SYMCRYPT_PQDSA_HASH_ID_SHA3_384 
SYMCRYPT_PQDSA_HASH_ID_SHA3_512 
SYMCRYPT_PQDSA_HASH_ID_SHAKE128 
SYMCRYPT_PQDSA_HASH_ID_SHAKE256 

Definition at line 10423 of file symcrypt.h.

10423 {
10424 SYMCRYPT_PQDSA_HASH_ID_NULL = 0,
10425 SYMCRYPT_PQDSA_HASH_ID_SHA256 = 1,
10426 SYMCRYPT_PQDSA_HASH_ID_SHA384 = 2,
10427 SYMCRYPT_PQDSA_HASH_ID_SHA512 = 3,
10428 SYMCRYPT_PQDSA_HASH_ID_SHA512_256 = 4,
10429 SYMCRYPT_PQDSA_HASH_ID_SHA3_256 = 5,
10430 SYMCRYPT_PQDSA_HASH_ID_SHA3_384 = 6,
10431 SYMCRYPT_PQDSA_HASH_ID_SHA3_512 = 7,
10432 SYMCRYPT_PQDSA_HASH_ID_SHAKE128 = 8,
10433 SYMCRYPT_PQDSA_HASH_ID_SHAKE256 = 9,
10434} SYMCRYPT_PQDSA_HASH_ID;
SYMCRYPT_PQDSA_HASH_ID
enum _SYMCRYPT_PQDSA_HASH_ID SYMCRYPT_PQDSA_HASH_ID
SYMCRYPT_PQDSA_HASH_ID_SHA512
@ SYMCRYPT_PQDSA_HASH_ID_SHA512
Definition: symcrypt.h:10427
SYMCRYPT_PQDSA_HASH_ID_SHA256
@ SYMCRYPT_PQDSA_HASH_ID_SHA256
Definition: symcrypt.h:10425
SYMCRYPT_PQDSA_HASH_ID_SHA3_512
@ SYMCRYPT_PQDSA_HASH_ID_SHA3_512
Definition: symcrypt.h:10431
SYMCRYPT_PQDSA_HASH_ID_SHAKE256
@ SYMCRYPT_PQDSA_HASH_ID_SHAKE256
Definition: symcrypt.h:10433
SYMCRYPT_PQDSA_HASH_ID_SHA3_384
@ SYMCRYPT_PQDSA_HASH_ID_SHA3_384
Definition: symcrypt.h:10430
SYMCRYPT_PQDSA_HASH_ID_NULL
@ SYMCRYPT_PQDSA_HASH_ID_NULL
Definition: symcrypt.h:10424
SYMCRYPT_PQDSA_HASH_ID_SHA384
@ SYMCRYPT_PQDSA_HASH_ID_SHA384
Definition: symcrypt.h:10426
SYMCRYPT_PQDSA_HASH_ID_SHA512_256
@ SYMCRYPT_PQDSA_HASH_ID_SHA512_256
Definition: symcrypt.h:10428
SYMCRYPT_PQDSA_HASH_ID_SHA3_256
@ SYMCRYPT_PQDSA_HASH_ID_SHA3_256
Definition: symcrypt.h:10429
SYMCRYPT_PQDSA_HASH_ID_SHAKE128
@ SYMCRYPT_PQDSA_HASH_ID_SHAKE128
Definition: symcrypt.h:10432

◆ _SYMCRYPT_XMSS_ALGID

enum _SYMCRYPT_XMSS_ALGID
Enumerator
SYMCRYPT_XMSS_SHA2_10_256 
SYMCRYPT_XMSS_SHA2_16_256 
SYMCRYPT_XMSS_SHA2_20_256 
SYMCRYPT_XMSS_SHA2_10_512 
SYMCRYPT_XMSS_SHA2_16_512 
SYMCRYPT_XMSS_SHA2_20_512 
SYMCRYPT_XMSS_SHAKE_10_256 
SYMCRYPT_XMSS_SHAKE_16_256 
SYMCRYPT_XMSS_SHAKE_20_256 
SYMCRYPT_XMSS_SHAKE_10_512 
SYMCRYPT_XMSS_SHAKE_16_512 
SYMCRYPT_XMSS_SHAKE_20_512 
SYMCRYPT_XMSS_SHA2_10_192 
SYMCRYPT_XMSS_SHA2_16_192 
SYMCRYPT_XMSS_SHA2_20_192 
SYMCRYPT_XMSS_SHAKE256_10_256 
SYMCRYPT_XMSS_SHAKE256_16_256 
SYMCRYPT_XMSS_SHAKE256_20_256 
SYMCRYPT_XMSS_SHAKE256_10_192 
SYMCRYPT_XMSS_SHAKE256_16_192 
SYMCRYPT_XMSS_SHAKE256_20_192 

Definition at line 9047 of file symcrypt.h.

9048{
9049 // Hash Fn. RFC-8391 SP800-208
9050 SYMCRYPT_XMSS_SHA2_10_256 = 0x00000001, // SHA-256 X X
9051 SYMCRYPT_XMSS_SHA2_16_256 = 0x00000002, // SHA-256 X X
9052 SYMCRYPT_XMSS_SHA2_20_256 = 0x00000003, // SHA-256 X X
9053 SYMCRYPT_XMSS_SHA2_10_512 = 0x00000004, // SHA-512 X
9054 SYMCRYPT_XMSS_SHA2_16_512 = 0x00000005, // SHA-512 X
9055 SYMCRYPT_XMSS_SHA2_20_512 = 0x00000006, // SHA-512 X
9056 SYMCRYPT_XMSS_SHAKE_10_256 = 0x00000007, // SHAKE128 X
9057 SYMCRYPT_XMSS_SHAKE_16_256 = 0x00000008, // SHAKE128 X
9058 SYMCRYPT_XMSS_SHAKE_20_256 = 0x00000009, // SHAKE128 X
9059 SYMCRYPT_XMSS_SHAKE_10_512 = 0x0000000A, // SHAKE256 X
9060 SYMCRYPT_XMSS_SHAKE_16_512 = 0x0000000B, // SHAKE256 X
9061 SYMCRYPT_XMSS_SHAKE_20_512 = 0x0000000C, // SHAKE256 X
9062 SYMCRYPT_XMSS_SHA2_10_192 = 0x0000000D, // SHA-256 X
9063 SYMCRYPT_XMSS_SHA2_16_192 = 0x0000000E, // SHA-256 X
9064 SYMCRYPT_XMSS_SHA2_20_192 = 0x0000000F, // SHA-256 X
9065 SYMCRYPT_XMSS_SHAKE256_10_256 = 0x00000010, // SHAKE256 X
9066 SYMCRYPT_XMSS_SHAKE256_16_256 = 0x00000011, // SHAKE256 X
9067 SYMCRYPT_XMSS_SHAKE256_20_256 = 0x00000012, // SHAKE256 X
9068 SYMCRYPT_XMSS_SHAKE256_10_192 = 0x00000013, // SHAKE256 X
9069 SYMCRYPT_XMSS_SHAKE256_16_192 = 0x00000014, // SHAKE256 X
9070 SYMCRYPT_XMSS_SHAKE256_20_192 = 0x00000015, // SHAKE256 X
9071
9072} SYMCRYPT_XMSS_ALGID;
SYMCRYPT_XMSS_ALGID
enum _SYMCRYPT_XMSS_ALGID SYMCRYPT_XMSS_ALGID
SYMCRYPT_XMSS_SHAKE256_16_192
@ SYMCRYPT_XMSS_SHAKE256_16_192
Definition: symcrypt.h:9069
SYMCRYPT_XMSS_SHA2_16_512
@ SYMCRYPT_XMSS_SHA2_16_512
Definition: symcrypt.h:9054
SYMCRYPT_XMSS_SHA2_20_256
@ SYMCRYPT_XMSS_SHA2_20_256
Definition: symcrypt.h:9052
SYMCRYPT_XMSS_SHAKE256_16_256
@ SYMCRYPT_XMSS_SHAKE256_16_256
Definition: symcrypt.h:9066
SYMCRYPT_XMSS_SHA2_16_256
@ SYMCRYPT_XMSS_SHA2_16_256
Definition: symcrypt.h:9051
SYMCRYPT_XMSS_SHA2_10_512
@ SYMCRYPT_XMSS_SHA2_10_512
Definition: symcrypt.h:9053
SYMCRYPT_XMSS_SHAKE_16_512
@ SYMCRYPT_XMSS_SHAKE_16_512
Definition: symcrypt.h:9060
SYMCRYPT_XMSS_SHAKE_10_256
@ SYMCRYPT_XMSS_SHAKE_10_256
Definition: symcrypt.h:9056
SYMCRYPT_XMSS_SHAKE256_20_192
@ SYMCRYPT_XMSS_SHAKE256_20_192
Definition: symcrypt.h:9070
SYMCRYPT_XMSS_SHAKE256_10_256
@ SYMCRYPT_XMSS_SHAKE256_10_256
Definition: symcrypt.h:9065
SYMCRYPT_XMSS_SHA2_10_192
@ SYMCRYPT_XMSS_SHA2_10_192
Definition: symcrypt.h:9062
SYMCRYPT_XMSS_SHA2_10_256
@ SYMCRYPT_XMSS_SHA2_10_256
Definition: symcrypt.h:9050
SYMCRYPT_XMSS_SHAKE_16_256
@ SYMCRYPT_XMSS_SHAKE_16_256
Definition: symcrypt.h:9057
SYMCRYPT_XMSS_SHA2_20_512
@ SYMCRYPT_XMSS_SHA2_20_512
Definition: symcrypt.h:9055
SYMCRYPT_XMSS_SHAKE_10_512
@ SYMCRYPT_XMSS_SHAKE_10_512
Definition: symcrypt.h:9059
SYMCRYPT_XMSS_SHAKE_20_256
@ SYMCRYPT_XMSS_SHAKE_20_256
Definition: symcrypt.h:9058
SYMCRYPT_XMSS_SHA2_20_192
@ SYMCRYPT_XMSS_SHA2_20_192
Definition: symcrypt.h:9064
SYMCRYPT_XMSS_SHA2_16_192
@ SYMCRYPT_XMSS_SHA2_16_192
Definition: symcrypt.h:9063
SYMCRYPT_XMSS_SHAKE256_20_256
@ SYMCRYPT_XMSS_SHAKE256_20_256
Definition: symcrypt.h:9067
SYMCRYPT_XMSS_SHAKE256_10_192
@ SYMCRYPT_XMSS_SHAKE256_10_192
Definition: symcrypt.h:9068
SYMCRYPT_XMSS_SHAKE_20_512
@ SYMCRYPT_XMSS_SHAKE_20_512
Definition: symcrypt.h:9061

◆ _SYMCRYPT_XMSSKEY_TYPE

enum _SYMCRYPT_XMSSKEY_TYPE
Enumerator
SYMCRYPT_XMSSKEY_TYPE_NONE 
SYMCRYPT_XMSSKEY_TYPE_PUBLIC 
SYMCRYPT_XMSSKEY_TYPE_PRIVATE 

Definition at line 9150 of file symcrypt.h.

9151{
9152 SYMCRYPT_XMSSKEY_TYPE_NONE = 0,
9153 SYMCRYPT_XMSSKEY_TYPE_PUBLIC = 1, // Key object contains only public key
9154 SYMCRYPT_XMSSKEY_TYPE_PRIVATE = 2, // Key object contains both public key and private key
9155} SYMCRYPT_XMSSKEY_TYPE;
SYMCRYPT_XMSSKEY_TYPE
enum _SYMCRYPT_XMSSKEY_TYPE SYMCRYPT_XMSSKEY_TYPE
SYMCRYPT_XMSSKEY_TYPE_PUBLIC
@ SYMCRYPT_XMSSKEY_TYPE_PUBLIC
Definition: symcrypt.h:9153
SYMCRYPT_XMSSKEY_TYPE_PRIVATE
@ SYMCRYPT_XMSSKEY_TYPE_PRIVATE
Definition: symcrypt.h:9154
SYMCRYPT_XMSSKEY_TYPE_NONE
@ SYMCRYPT_XMSSKEY_TYPE_NONE
Definition: symcrypt.h:9152

◆ _SYMCRYPT_XMSSMT_ALGID

enum _SYMCRYPT_XMSSMT_ALGID
Enumerator
SYMCRYPT_XMSSMT_SHA2_20_2_256 
SYMCRYPT_XMSSMT_SHA2_20_4_256 
SYMCRYPT_XMSSMT_SHA2_40_2_256 
SYMCRYPT_XMSSMT_SHA2_40_4_256 
SYMCRYPT_XMSSMT_SHA2_40_8_256 
SYMCRYPT_XMSSMT_SHA2_60_3_256 
SYMCRYPT_XMSSMT_SHA2_60_6_256 
SYMCRYPT_XMSSMT_SHA2_60_12_256 
SYMCRYPT_XMSSMT_SHA2_20_2_512 
SYMCRYPT_XMSSMT_SHA2_20_4_512 
SYMCRYPT_XMSSMT_SHA2_40_2_512 
SYMCRYPT_XMSSMT_SHA2_40_4_512 
SYMCRYPT_XMSSMT_SHA2_40_8_512 
SYMCRYPT_XMSSMT_SHA2_60_3_512 
SYMCRYPT_XMSSMT_SHA2_60_6_512 
SYMCRYPT_XMSSMT_SHA2_60_12_512 
SYMCRYPT_XMSSMT_SHAKE_20_2_256 
SYMCRYPT_XMSSMT_SHAKE_20_4_256 
SYMCRYPT_XMSSMT_SHAKE_40_2_256 
SYMCRYPT_XMSSMT_SHAKE_40_4_256 
SYMCRYPT_XMSSMT_SHAKE_40_8_256 
SYMCRYPT_XMSSMT_SHAKE_60_3_256 
SYMCRYPT_XMSSMT_SHAKE_60_6_256 
SYMCRYPT_XMSSMT_SHAKE_60_12_256 
SYMCRYPT_XMSSMT_SHAKE_20_2_512 
SYMCRYPT_XMSSMT_SHAKE_20_4_512 
SYMCRYPT_XMSSMT_SHAKE_40_2_512 
SYMCRYPT_XMSSMT_SHAKE_40_4_512 
SYMCRYPT_XMSSMT_SHAKE_40_8_512 
SYMCRYPT_XMSSMT_SHAKE_60_3_512 
SYMCRYPT_XMSSMT_SHAKE_60_6_512 
SYMCRYPT_XMSSMT_SHAKE_60_12_512 
SYMCRYPT_XMSSMT_SHA2_20_2_192 
SYMCRYPT_XMSSMT_SHA2_20_4_192 
SYMCRYPT_XMSSMT_SHA2_40_2_192 
SYMCRYPT_XMSSMT_SHA2_40_4_192 
SYMCRYPT_XMSSMT_SHA2_40_8_192 
SYMCRYPT_XMSSMT_SHA2_60_3_192 
SYMCRYPT_XMSSMT_SHA2_60_6_192 
SYMCRYPT_XMSSMT_SHA2_60_12_192 
SYMCRYPT_XMSSMT_SHAKE256_20_2_256 
SYMCRYPT_XMSSMT_SHAKE256_20_4_256 
SYMCRYPT_XMSSMT_SHAKE256_40_2_256 
SYMCRYPT_XMSSMT_SHAKE256_40_4_256 
SYMCRYPT_XMSSMT_SHAKE256_40_8_256 
SYMCRYPT_XMSSMT_SHAKE256_60_3_256 
SYMCRYPT_XMSSMT_SHAKE256_60_6_256 
SYMCRYPT_XMSSMT_SHAKE256_60_12_256 
SYMCRYPT_XMSSMT_SHAKE256_20_2_192 
SYMCRYPT_XMSSMT_SHAKE256_20_4_192 
SYMCRYPT_XMSSMT_SHAKE256_40_2_192 
SYMCRYPT_XMSSMT_SHAKE256_40_4_192 
SYMCRYPT_XMSSMT_SHAKE256_40_8_192 
SYMCRYPT_XMSSMT_SHAKE256_60_3_192 
SYMCRYPT_XMSSMT_SHAKE256_60_6_192 
SYMCRYPT_XMSSMT_SHAKE256_60_12_192 

Definition at line 9074 of file symcrypt.h.

9075{
9076 // Hash Fn. RFC-8391 SP800-208
9077 // SHA-256 X X
9078 SYMCRYPT_XMSSMT_SHA2_20_2_256 = 0x00000001,
9079 SYMCRYPT_XMSSMT_SHA2_20_4_256 = 0x00000002,
9080 SYMCRYPT_XMSSMT_SHA2_40_2_256 = 0x00000003,
9081 SYMCRYPT_XMSSMT_SHA2_40_4_256 = 0x00000004,
9082 SYMCRYPT_XMSSMT_SHA2_40_8_256 = 0x00000005,
9083 SYMCRYPT_XMSSMT_SHA2_60_3_256 = 0x00000006,
9084 SYMCRYPT_XMSSMT_SHA2_60_6_256 = 0x00000007,
9085 SYMCRYPT_XMSSMT_SHA2_60_12_256 = 0x00000008,
9086
9087 // SHA-512 X
9088 SYMCRYPT_XMSSMT_SHA2_20_2_512 = 0x00000009,
9089 SYMCRYPT_XMSSMT_SHA2_20_4_512 = 0x0000000A,
9090 SYMCRYPT_XMSSMT_SHA2_40_2_512 = 0x0000000B,
9091 SYMCRYPT_XMSSMT_SHA2_40_4_512 = 0x0000000C,
9092 SYMCRYPT_XMSSMT_SHA2_40_8_512 = 0x0000000D,
9093 SYMCRYPT_XMSSMT_SHA2_60_3_512 = 0x0000000E,
9094 SYMCRYPT_XMSSMT_SHA2_60_6_512 = 0x0000000F,
9095 SYMCRYPT_XMSSMT_SHA2_60_12_512 = 0x00000010,
9096
9097 // SHAKE128 X
9098 SYMCRYPT_XMSSMT_SHAKE_20_2_256 = 0x00000011,
9099 SYMCRYPT_XMSSMT_SHAKE_20_4_256 = 0x00000012,
9100 SYMCRYPT_XMSSMT_SHAKE_40_2_256 = 0x00000013,
9101 SYMCRYPT_XMSSMT_SHAKE_40_4_256 = 0x00000014,
9102 SYMCRYPT_XMSSMT_SHAKE_40_8_256 = 0x00000015,
9103 SYMCRYPT_XMSSMT_SHAKE_60_3_256 = 0x00000016,
9104 SYMCRYPT_XMSSMT_SHAKE_60_6_256 = 0x00000017,
9105 SYMCRYPT_XMSSMT_SHAKE_60_12_256 = 0x00000018,
9106
9107 // SHAKE256 X
9108 SYMCRYPT_XMSSMT_SHAKE_20_2_512 = 0x00000019,
9109 SYMCRYPT_XMSSMT_SHAKE_20_4_512 = 0x0000001A,
9110 SYMCRYPT_XMSSMT_SHAKE_40_2_512 = 0x0000001B,
9111 SYMCRYPT_XMSSMT_SHAKE_40_4_512 = 0x0000001C,
9112 SYMCRYPT_XMSSMT_SHAKE_40_8_512 = 0x0000001D,
9113 SYMCRYPT_XMSSMT_SHAKE_60_3_512 = 0x0000001E,
9114 SYMCRYPT_XMSSMT_SHAKE_60_6_512 = 0x0000001F,
9115 SYMCRYPT_XMSSMT_SHAKE_60_12_512 = 0x00000020,
9116
9117 // SHA-256 X
9118 SYMCRYPT_XMSSMT_SHA2_20_2_192 = 0x00000021,
9119 SYMCRYPT_XMSSMT_SHA2_20_4_192 = 0x00000022,
9120 SYMCRYPT_XMSSMT_SHA2_40_2_192 = 0x00000023,
9121 SYMCRYPT_XMSSMT_SHA2_40_4_192 = 0x00000024,
9122 SYMCRYPT_XMSSMT_SHA2_40_8_192 = 0x00000025,
9123 SYMCRYPT_XMSSMT_SHA2_60_3_192 = 0x00000026,
9124 SYMCRYPT_XMSSMT_SHA2_60_6_192 = 0x00000027,
9125 SYMCRYPT_XMSSMT_SHA2_60_12_192 = 0x00000028,
9126
9127 // SHAKE256 X
9128 SYMCRYPT_XMSSMT_SHAKE256_20_2_256 = 0x00000029,
9129 SYMCRYPT_XMSSMT_SHAKE256_20_4_256 = 0x0000002A,
9130 SYMCRYPT_XMSSMT_SHAKE256_40_2_256 = 0x0000002B,
9131 SYMCRYPT_XMSSMT_SHAKE256_40_4_256 = 0x0000002C,
9132 SYMCRYPT_XMSSMT_SHAKE256_40_8_256 = 0x0000002D,
9133 SYMCRYPT_XMSSMT_SHAKE256_60_3_256 = 0x0000002E,
9134 SYMCRYPT_XMSSMT_SHAKE256_60_6_256 = 0x0000002F,
9135 SYMCRYPT_XMSSMT_SHAKE256_60_12_256 = 0x00000030,
9136
9137 // SHAKE256 X
9138 SYMCRYPT_XMSSMT_SHAKE256_20_2_192 = 0x00000031,
9139 SYMCRYPT_XMSSMT_SHAKE256_20_4_192 = 0x00000032,
9140 SYMCRYPT_XMSSMT_SHAKE256_40_2_192 = 0x00000033,
9141 SYMCRYPT_XMSSMT_SHAKE256_40_4_192 = 0x00000034,
9142 SYMCRYPT_XMSSMT_SHAKE256_40_8_192 = 0x00000035,
9143 SYMCRYPT_XMSSMT_SHAKE256_60_3_192 = 0x00000036,
9144 SYMCRYPT_XMSSMT_SHAKE256_60_6_192 = 0x00000037,
9145 SYMCRYPT_XMSSMT_SHAKE256_60_12_192 = 0x00000038,
9146
9147} SYMCRYPT_XMSSMT_ALGID;
SYMCRYPT_XMSSMT_SHAKE256_40_4_256
@ SYMCRYPT_XMSSMT_SHAKE256_40_4_256
Definition: symcrypt.h:9131
SYMCRYPT_XMSSMT_SHA2_20_2_256
@ SYMCRYPT_XMSSMT_SHA2_20_2_256
Definition: symcrypt.h:9078
SYMCRYPT_XMSSMT_SHAKE_40_8_256
@ SYMCRYPT_XMSSMT_SHAKE_40_8_256
Definition: symcrypt.h:9102
SYMCRYPT_XMSSMT_SHA2_60_3_512
@ SYMCRYPT_XMSSMT_SHA2_60_3_512
Definition: symcrypt.h:9093
SYMCRYPT_XMSSMT_SHAKE_60_6_512
@ SYMCRYPT_XMSSMT_SHAKE_60_6_512
Definition: symcrypt.h:9114
SYMCRYPT_XMSSMT_SHAKE_60_12_256
@ SYMCRYPT_XMSSMT_SHAKE_60_12_256
Definition: symcrypt.h:9105
SYMCRYPT_XMSSMT_SHAKE256_40_4_192
@ SYMCRYPT_XMSSMT_SHAKE256_40_4_192
Definition: symcrypt.h:9141
SYMCRYPT_XMSSMT_SHA2_40_2_512
@ SYMCRYPT_XMSSMT_SHA2_40_2_512
Definition: symcrypt.h:9090
SYMCRYPT_XMSSMT_SHA2_20_2_192
@ SYMCRYPT_XMSSMT_SHA2_20_2_192
Definition: symcrypt.h:9118
SYMCRYPT_XMSSMT_SHAKE_20_4_512
@ SYMCRYPT_XMSSMT_SHAKE_20_4_512
Definition: symcrypt.h:9109
SYMCRYPT_XMSSMT_SHAKE256_20_4_192
@ SYMCRYPT_XMSSMT_SHAKE256_20_4_192
Definition: symcrypt.h:9139
SYMCRYPT_XMSSMT_SHA2_60_12_512
@ SYMCRYPT_XMSSMT_SHA2_60_12_512
Definition: symcrypt.h:9095
SYMCRYPT_XMSSMT_SHA2_60_12_192
@ SYMCRYPT_XMSSMT_SHA2_60_12_192
Definition: symcrypt.h:9125
SYMCRYPT_XMSSMT_SHAKE_60_6_256
@ SYMCRYPT_XMSSMT_SHAKE_60_6_256
Definition: symcrypt.h:9104
SYMCRYPT_XMSSMT_SHAKE_20_2_512
@ SYMCRYPT_XMSSMT_SHAKE_20_2_512
Definition: symcrypt.h:9108
SYMCRYPT_XMSSMT_SHA2_60_6_512
@ SYMCRYPT_XMSSMT_SHA2_60_6_512
Definition: symcrypt.h:9094
SYMCRYPT_XMSSMT_SHA2_20_4_192
@ SYMCRYPT_XMSSMT_SHA2_20_4_192
Definition: symcrypt.h:9119
SYMCRYPT_XMSSMT_SHAKE256_60_3_256
@ SYMCRYPT_XMSSMT_SHAKE256_60_3_256
Definition: symcrypt.h:9133
SYMCRYPT_XMSSMT_SHA2_40_4_256
@ SYMCRYPT_XMSSMT_SHA2_40_4_256
Definition: symcrypt.h:9081
SYMCRYPT_XMSSMT_SHA2_60_3_256
@ SYMCRYPT_XMSSMT_SHA2_60_3_256
Definition: symcrypt.h:9083
SYMCRYPT_XMSSMT_SHAKE256_20_2_256
@ SYMCRYPT_XMSSMT_SHAKE256_20_2_256
Definition: symcrypt.h:9128
SYMCRYPT_XMSSMT_SHAKE256_60_6_256
@ SYMCRYPT_XMSSMT_SHAKE256_60_6_256
Definition: symcrypt.h:9134
SYMCRYPT_XMSSMT_SHA2_40_8_192
@ SYMCRYPT_XMSSMT_SHA2_40_8_192
Definition: symcrypt.h:9122
SYMCRYPT_XMSSMT_SHAKE_40_2_256
@ SYMCRYPT_XMSSMT_SHAKE_40_2_256
Definition: symcrypt.h:9100
SYMCRYPT_XMSSMT_SHA2_40_4_192
@ SYMCRYPT_XMSSMT_SHA2_40_4_192
Definition: symcrypt.h:9121
SYMCRYPT_XMSSMT_SHA2_40_8_512
@ SYMCRYPT_XMSSMT_SHA2_40_8_512
Definition: symcrypt.h:9092
SYMCRYPT_XMSSMT_SHAKE256_60_12_256
@ SYMCRYPT_XMSSMT_SHAKE256_60_12_256
Definition: symcrypt.h:9135
SYMCRYPT_XMSSMT_SHA2_40_2_256
@ SYMCRYPT_XMSSMT_SHA2_40_2_256
Definition: symcrypt.h:9080
SYMCRYPT_XMSSMT_SHAKE256_60_3_192
@ SYMCRYPT_XMSSMT_SHAKE256_60_3_192
Definition: symcrypt.h:9143
SYMCRYPT_XMSSMT_SHAKE_20_4_256
@ SYMCRYPT_XMSSMT_SHAKE_20_4_256
Definition: symcrypt.h:9099
SYMCRYPT_XMSSMT_SHA2_60_6_256
@ SYMCRYPT_XMSSMT_SHA2_60_6_256
Definition: symcrypt.h:9084
SYMCRYPT_XMSSMT_SHAKE256_40_2_192
@ SYMCRYPT_XMSSMT_SHAKE256_40_2_192
Definition: symcrypt.h:9140
SYMCRYPT_XMSSMT_SHAKE_40_2_512
@ SYMCRYPT_XMSSMT_SHAKE_40_2_512
Definition: symcrypt.h:9110
SYMCRYPT_XMSSMT_SHA2_20_2_512
@ SYMCRYPT_XMSSMT_SHA2_20_2_512
Definition: symcrypt.h:9088
SYMCRYPT_XMSSMT_SHA2_40_2_192
@ SYMCRYPT_XMSSMT_SHA2_40_2_192
Definition: symcrypt.h:9120
SYMCRYPT_XMSSMT_SHAKE256_40_8_192
@ SYMCRYPT_XMSSMT_SHAKE256_40_8_192
Definition: symcrypt.h:9142
SYMCRYPT_XMSSMT_SHAKE256_60_6_192
@ SYMCRYPT_XMSSMT_SHAKE256_60_6_192
Definition: symcrypt.h:9144
SYMCRYPT_XMSSMT_SHAKE256_40_2_256
@ SYMCRYPT_XMSSMT_SHAKE256_40_2_256
Definition: symcrypt.h:9130
SYMCRYPT_XMSSMT_SHA2_20_4_256
@ SYMCRYPT_XMSSMT_SHA2_20_4_256
Definition: symcrypt.h:9079
SYMCRYPT_XMSSMT_SHAKE_20_2_256
@ SYMCRYPT_XMSSMT_SHAKE_20_2_256
Definition: symcrypt.h:9098
SYMCRYPT_XMSSMT_SHAKE_60_3_512
@ SYMCRYPT_XMSSMT_SHAKE_60_3_512
Definition: symcrypt.h:9113
SYMCRYPT_XMSSMT_SHA2_60_6_192
@ SYMCRYPT_XMSSMT_SHA2_60_6_192
Definition: symcrypt.h:9124
SYMCRYPT_XMSSMT_SHA2_20_4_512
@ SYMCRYPT_XMSSMT_SHA2_20_4_512
Definition: symcrypt.h:9089
SYMCRYPT_XMSSMT_SHAKE_60_12_512
@ SYMCRYPT_XMSSMT_SHAKE_60_12_512
Definition: symcrypt.h:9115
SYMCRYPT_XMSSMT_SHAKE256_20_4_256
@ SYMCRYPT_XMSSMT_SHAKE256_20_4_256
Definition: symcrypt.h:9129
SYMCRYPT_XMSSMT_SHA2_40_4_512
@ SYMCRYPT_XMSSMT_SHA2_40_4_512
Definition: symcrypt.h:9091
SYMCRYPT_XMSSMT_SHA2_40_8_256
@ SYMCRYPT_XMSSMT_SHA2_40_8_256
Definition: symcrypt.h:9082
SYMCRYPT_XMSSMT_SHAKE256_20_2_192
@ SYMCRYPT_XMSSMT_SHAKE256_20_2_192
Definition: symcrypt.h:9138
SYMCRYPT_XMSSMT_SHA2_60_12_256
@ SYMCRYPT_XMSSMT_SHA2_60_12_256
Definition: symcrypt.h:9085
SYMCRYPT_XMSSMT_SHAKE_40_4_512
@ SYMCRYPT_XMSSMT_SHAKE_40_4_512
Definition: symcrypt.h:9111
SYMCRYPT_XMSSMT_SHA2_60_3_192
@ SYMCRYPT_XMSSMT_SHA2_60_3_192
Definition: symcrypt.h:9123
SYMCRYPT_XMSSMT_SHAKE_40_4_256
@ SYMCRYPT_XMSSMT_SHAKE_40_4_256
Definition: symcrypt.h:9101
SYMCRYPT_XMSSMT_SHAKE_60_3_256
@ SYMCRYPT_XMSSMT_SHAKE_60_3_256
Definition: symcrypt.h:9103
SYMCRYPT_XMSSMT_SHAKE256_40_8_256
@ SYMCRYPT_XMSSMT_SHAKE256_40_8_256
Definition: symcrypt.h:9132
SYMCRYPT_XMSSMT_SHAKE_40_8_512
@ SYMCRYPT_XMSSMT_SHAKE_40_8_512
Definition: symcrypt.h:9112
SYMCRYPT_XMSSMT_SHAKE256_60_12_192
@ SYMCRYPT_XMSSMT_SHAKE256_60_12_192
Definition: symcrypt.h:9145
SYMCRYPT_XMSSMT_ALGID
enum _SYMCRYPT_XMSSMT_ALGID SYMCRYPT_XMSSMT_ALGID

Function Documentation

◆ _Return_type_success_()

typedef _Return_type_success_ ( return  = = SYMCRYPT_NO_ERROR)

Definition at line 203 of file symcrypt.h.

203 {
204 SYMCRYPT_NO_ERROR = 0,
205 SYMCRYPT_UNUSED = 0x8000, // Start our error codes here so they're easier to distinguish
206 SYMCRYPT_WRONG_KEY_SIZE,
207 SYMCRYPT_WRONG_BLOCK_SIZE,
208 SYMCRYPT_WRONG_DATA_SIZE,
209 SYMCRYPT_WRONG_NONCE_SIZE,
210 SYMCRYPT_WRONG_TAG_SIZE,
211 SYMCRYPT_WRONG_ITERATION_COUNT,
212 SYMCRYPT_AUTHENTICATION_FAILURE,
213 SYMCRYPT_EXTERNAL_FAILURE,
214 SYMCRYPT_FIPS_FAILURE,
215 SYMCRYPT_HARDWARE_FAILURE,
216 SYMCRYPT_NOT_IMPLEMENTED,
217 SYMCRYPT_INVALID_BLOB,
218 SYMCRYPT_BUFFER_TOO_SMALL,
219 SYMCRYPT_INVALID_ARGUMENT,
220 SYMCRYPT_MEMORY_ALLOCATION_FAILURE,
221 SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE,
222 SYMCRYPT_INCOMPATIBLE_FORMAT,
223 SYMCRYPT_VALUE_TOO_LARGE,
224 SYMCRYPT_SESSION_REPLAY_FAILURE,
225 SYMCRYPT_HBS_NO_OTS_KEYS_LEFT,
226 SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH,
227} SYMCRYPT_ERROR;
SYMCRYPT_ERROR
SYMCRYPT_ERROR
Definition: symcrypt.h:227

◆ _Success_()

_Success_ ( return !  = 0)

Returns the name of an atom.

Parameters
atom- The atom to be queried.
pustrName- Pointer to an initialized UNICODE_STRING that receives the name of the atom. The function does not update the Length member. The string is always NULL-terminated.
Returns
The length of the name in characters, or 0 if the function fails.
Note
The function does not aquire any global lock, since synchronisation is handled by the RtlAtom function.

Definition at line 436 of file fsctrl.c.

3189{
3190 PLIST_ENTRY Link;
3191
3192 PVPB Vpb = Vcb->Vpb;
3193 PVPB OldVpb;
3194
3195 BOOLEAN Remount = FALSE;
3196
3197 PAGED_CODE();
3198
3199 UNREFERENCED_PARAMETER( IrpContext );
3200
3201 //
3202 // Check whether we are looking for a device only Mvcb.
3203 //
3204
3205 for (Link = CdData.VcbQueue.Flink;
3206 Link != &CdData.VcbQueue;
3207 Link = Link->Flink) {
3208
3209 *OldVcb = CONTAINING_RECORD( Link, VCB, VcbLinks );
3210
3211 //
3212 // Skip ourselves.
3213 //
3214
3215 if (Vcb == *OldVcb) { continue; }
3216
3217 //
3218 // Look at the Vpb and state of the previous Vcb.
3219 //
3220
3221 OldVpb = (*OldVcb)->Vpb;
3222
3223 if ((OldVpb != Vpb) &&
3224 (OldVpb->RealDevice == Vpb->RealDevice) &&
3225 ((*OldVcb)->VcbCondition == VcbNotMounted)) {
3226
3227 //
3228 // If the current disk is a raw disk then it can match a previous music or
3229 // raw disk.
3230 //
3231
3232 if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
3233
3234 if (FlagOn( (*OldVcb)->VcbState, VCB_STATE_AUDIO_DISK )) {
3235
3236 //
3237 // If we have both TOC then fail the remount if the lengths
3238 // are different or they don't match.
3239 //
3240
3241 if ((Vcb->TocLength != (*OldVcb)->TocLength) ||
3242 ((Vcb->TocLength != 0) &&
3243 !RtlEqualMemory( Vcb->CdromToc,
3244 (*OldVcb)->CdromToc,
3245 Vcb->TocLength ))) {
3246
3247 continue;
3248 }
3249
3250 Remount = TRUE;
3251 break;
3252 }
3253
3254 //
3255 // The current disk is not a raw disk. Go ahead and compare
3256 // serial numbers, volume label and TOC.
3257 //
3258
3259 }
3260 else if ((OldVpb->SerialNumber == Vpb->SerialNumber) &&
3261 (Vcb->TocLength == (*OldVcb)->TocLength) &&
3262 ((Vcb->TocLength == 0) || RtlEqualMemory( Vcb->CdromToc,
3263 (*OldVcb)->CdromToc,
3264 Vcb->TocLength )) &&
3265 (Vpb->VolumeLabelLength == OldVpb->VolumeLabelLength) &&
3266 (RtlEqualMemory( OldVpb->VolumeLabel,
3267 Vpb->VolumeLabel,
3268 Vpb->VolumeLabelLength ))) {
3269 //
3270 // Remember the old Vcb. Then set the return value to
3271 // TRUE and break.
3272 //
3273
3274 Remount = TRUE;
3275 break;
3276 }
3277 }
3278 }
3279
3280 return Remount;
3281}
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_EvalMethod.c:89
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
CdData
CD_DATA CdData
Definition: cddata.c:42
VCB_STATE_AUDIO_DISK
#define VCB_STATE_AUDIO_DISK
Definition: cdstruc.h:712
VcbNotMounted
@ VcbNotMounted
Definition: cdstruc.h:490
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
FlagOn
#define FlagOn(_F, _SF)
Definition: ext2fs.h:179
Vpb
IN OUT PVCB IN PDEVICE_OBJECT IN PVPB Vpb
Definition: fatprocs.h:1676
RtlEqualMemory
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
Vcb
#define Vcb
Definition: cdprocs.h:1415
_CD_DATA::VcbQueue
LIST_ENTRY VcbQueue
Definition: cdstruc.h:334
_LIST_ENTRY
Definition: typedefs.h:120
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_VCB
Definition: cdstruc.h:498
_VPB
Definition: iotypes.h:189
_VPB::VolumeLabel
WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH/sizeof(WCHAR)]
Definition: iotypes.h:198
_VPB::VolumeLabelLength
USHORT VolumeLabelLength
Definition: iotypes.h:193
_VPB::SerialNumber
ULONG SerialNumber
Definition: iotypes.h:196
_VPB::RealDevice
struct _DEVICE_OBJECT * RealDevice
Definition: iotypes.h:195
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
Link
static int Link(const char **args)
Definition: vfdcmd.c:2414

◆ SymCrypt3DesCbcDecrypt()

VOID SYMCRYPT_CALL SymCrypt3DesCbcDecrypt ( _In_ PCSYMCRYPT_3DES_EXPANDED_KEY  pExpandedKey,
_Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE  pbChainingValue,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 180 of file 3des.c.

186{
187 SYMCRYPT_ASSERT( SymCrypt3DesBlockCipher->blockSize == SYMCRYPT_3DES_BLOCK_SIZE );
188 SymCryptCbcDecrypt( SymCrypt3DesBlockCipher, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
189}
SymCrypt3DesBlockCipher
const PCSYMCRYPT_BLOCKCIPHER SymCrypt3DesBlockCipher
Definition: 3des.c:75
SYMCRYPT_ASSERT
#define SYMCRYPT_ASSERT(_x)
Definition: symcrypt.h:10807
SYMCRYPT_3DES_BLOCK_SIZE
#define SYMCRYPT_3DES_BLOCK_SIZE
Definition: symcrypt.h:4440
SymCryptCbcDecrypt
VOID SYMCRYPT_CALL SymCryptCbcDecrypt(_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: blockciphermodes.c:143
pbChainingValue
PBYTE pbChainingValue
Definition: symcrypt_internal.h:1990
pbSrc
PCBYTE pbSrc
Definition: symcrypt_internal.h:1988
cbData
PCBYTE PBYTE SIZE_T cbData
Definition: symcrypt_internal.h:1989
pbDst
PCBYTE PBYTE pbDst
Definition: symcrypt_internal.h:1988
pExpandedKey
PCVOID pExpandedKey
Definition: symcrypt_internal.h:1826

◆ SymCrypt3DesCbcEncrypt()

VOID SYMCRYPT_CALL SymCrypt3DesCbcEncrypt ( _In_ PCSYMCRYPT_3DES_EXPANDED_KEY  pExpandedKey,
_Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE  pbChainingValue,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 167 of file 3des.c.

173{
174 SYMCRYPT_ASSERT( SymCrypt3DesBlockCipher->blockSize == SYMCRYPT_3DES_BLOCK_SIZE );
175 SymCryptCbcEncrypt( SymCrypt3DesBlockCipher, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
176}
SymCryptCbcEncrypt
VOID SYMCRYPT_CALL SymCryptCbcEncrypt(_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: blockciphermodes.c:78

◆ SymCrypt3DesDecrypt()

VOID SYMCRYPT_CALL SymCrypt3DesDecrypt ( _In_ PCSYMCRYPT_3DES_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 478 of file 3des.c.

482{
483 UINT32 L, R, Ta, Tb;
484 int r;
485
486 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
487
488 R = SYMCRYPT_LOAD_LSBFIRST32( pbSrc );
489 L = SYMCRYPT_LOAD_LSBFIRST32( pbSrc + 4 );
490
491 R = ROL32(R, 4);
492 Ta = (L ^ R) & 0xf0f0f0f0;
493 L ^= Ta;
494 R ^= Ta;
495
496 L = ROL32(L, 20);
497 Ta = (L ^ R) & 0xfff0000f;
498 L ^= Ta;
499 R ^= Ta;
500
501 L = ROL32(L, 14);
502 Ta = (L ^ R) & 0x33333333;
503 L ^= Ta;
504 R ^= Ta;
505
506 R = ROL32(R, 22);
507 Ta = (L ^ R) & 0x03fc03fc;
508 L ^= Ta;
509 R ^= Ta;
510
511 R = ROL32(R, 9);
512 Ta = (L ^ R) & 0xaaaaaaaa;
513 L ^= Ta;
514 R ^= Ta;
515
516 L = ROL32(L, 1);
517
518
519 // Decrypt with key 2
520 for( r=14; r>=0; r -= 2 )
521 {
522 F( L, R, pExpandedKey->roundKey[2][r+1] );
523 F( R, L, pExpandedKey->roundKey[2][r ] );
524 }
525
526 // Encrypt with key 1
527 for( r=0; r<16; r += 2 )
528 {
529 F( R, L, pExpandedKey->roundKey[1][r ] );
530 F( L, R, pExpandedKey->roundKey[1][r+1] );
531 }
532
533 // Decrypt with key 0
534 for( r=14; r>=0; r -= 2 )
535 {
536 F( L, R, pExpandedKey->roundKey[0][r+1] );
537 F( R, L, pExpandedKey->roundKey[0][r ] );
538 }
539
540 /* Inverse permutation, also from Hoey via Outerbridge and Schneier */
541
542 R = ROR32(R, 1);
543 Ta = (L ^ R) & 0xaaaaaaaa;
544 L ^= Ta;
545 R ^= Ta;
546
547 L = ROR32(L, 9);
548 Ta = (L ^ R) & 0x03fc03fc;
549 L ^= Ta;
550 R ^= Ta;
551
552 L = ROR32(L, 22);
553 Ta = (L ^ R) & 0x33333333;
554 L ^= Ta;
555 R ^= Ta;
556
557 R = ROR32(R, 14);
558 Ta = (L ^ R) & 0xfff0000f;
559 L ^= Ta;
560 R ^= Ta;
561
562 R = ROR32(R, 20);
563 Ta = (L ^ R) & 0xf0f0f0f0;
564 L ^= Ta;
565 R ^= Ta;
566
567 L = ROR32(L, 4);
568
569 SYMCRYPT_STORE_LSBFIRST32( pbDst, L );
570 SYMCRYPT_STORE_LSBFIRST32( pbDst + 4, R );
571}
F
#define F(L, R, keyptr)
Definition: 3des.c:335
Tb
static PTUNNEL Tb
Definition: FsRtlTunnel.c:26
R
@ R
Definition: bidi.c:79
L
#define L(x)
Definition: resources.c:13
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
SYMCRYPT_LOAD_LSBFIRST32
#define SYMCRYPT_LOAD_LSBFIRST32(p)
Definition: symcrypt.h:299
SYMCRYPT_STORE_LSBFIRST32
#define SYMCRYPT_STORE_LSBFIRST32(p, v)
Definition: symcrypt.h:307
SYMCRYPT_CHECK_MAGIC
#define SYMCRYPT_CHECK_MAGIC(p)
Definition: symcrypt_internal.h:359
UINT32
uint32_t UINT32
Definition: typedefs.h:59

Referenced by decrypt_block_impl(), SymCrypt3DesSelftest(), and SymCryptDesDecrypt().

◆ SymCrypt3DesEncrypt()

VOID SYMCRYPT_CALL SymCrypt3DesEncrypt ( _In_ PCSYMCRYPT_3DES_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 358 of file 3des.c.

362{
363 UINT32 L, R, Ta, Tb;
364 int r;
365
366 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
367
368 R = SYMCRYPT_LOAD_LSBFIRST32( pbSrc );
369 L = SYMCRYPT_LOAD_LSBFIRST32( pbSrc + 4 );
370
371 //
372 // Hoey's wonderful initial permutation algorithm, from Outerbridge
373 // (see Schneier p 478)
374 //
375 // The algorithm we use is derived (through several intermediate forms) from the mentioned source.
376 // But the algorithm cannot be copyrighted, only patented, and if there were any patents
377 // they have expired by now.
378 // The expression of the algorithm in code is purely MS generated,
379 // within the confines of implementing the algorithm in the best way such that even a simple
380 // compiler will create good code.
381 //
382
383 R = ROL32(R, 4);
384 Ta = (L ^ R) & 0xf0f0f0f0;
385 L ^= Ta;
386 R ^= Ta;
387
388 L = ROL32(L, 20);
389 Ta = (L ^ R) & 0xfff0000f;
390 R ^= Ta;
391 L ^= Ta;
392
393 L = ROL32(L,14);
394 Ta = (L ^ R) & 0x33333333;
395 R ^= Ta;
396 L ^= Ta;
397
398 R = ROL32(R, 22);
399 Ta = (L ^ R) & 0x03fc03fc;
400 R ^= Ta;
401 L ^= Ta;
402
403 R = ROL32(R, 9);
404 Ta = (L ^ R) & 0xaaaaaaaa;
405 R ^= Ta;
406 L ^= Ta;
407
408 L = ROL32(L, 1);
409
410 //
411 // First: encryption
412 //
413 for( r=0; r<16; r += 2 )
414 {
415 F( L, R, pExpandedKey->roundKey[0][r ] );
416 F( R, L, pExpandedKey->roundKey[0][r+1] );
417 }
418
419 //
420 // Second: decryption
421 // Note that L and R are swapped here, and the round counter counts down.
422 //
423 for( r=14; r>=0; r -= 2 )
424 {
425 F( R, L, pExpandedKey->roundKey[1][r+1] );
426 F( L, R, pExpandedKey->roundKey[1][r ] );
427 }
428
429 //
430 // Third: encryption
431 //
432 for( r=0; r<16; r += 2 )
433 {
434 F( L, R, pExpandedKey->roundKey[2][r ] );
435 F( R, L, pExpandedKey->roundKey[2][r+1] );
436 }
437
438 R = ROR32(R, 1);
439 Ta = (L ^ R) & 0xaaaaaaaa;
440 R ^= Ta;
441 L ^= Ta;
442
443 L = ROR32(L, 9);
444 Ta = (L ^ R) & 0x03fc03fc;
445 R ^= Ta;
446 L ^= Ta;
447
448 L = ROR32(L, 22);
449 Ta = (L ^ R) & 0x33333333;
450 R ^= Ta;
451 L ^= Ta;
452
453 R = ROR32(R, 14);
454 Ta = (L ^ R) & 0xfff0000f;
455 R ^= Ta;
456 L ^= Ta;
457
458 R = ROR32(R, 20);
459 Ta = (L ^ R) & 0xf0f0f0f0;
460 R ^= Ta;
461 L ^= Ta;
462
463 L = ROR32(L, 4);
464
465 SYMCRYPT_STORE_LSBFIRST32( pbDst, L );
466 SYMCRYPT_STORE_LSBFIRST32( pbDst + 4, R );
467}

Referenced by encrypt_block_impl(), SymCrypt3DesSelftest(), and SymCryptDesEncrypt().

◆ SymCrypt3DesExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCrypt3DesExpandKey ( _Out_ PSYMCRYPT_3DES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 295 of file 3des.c.

299{
300 SIZE_T keyIndex = 0;
301 int i;
302
303 if( cbKey != 8 && cbKey != 16 && cbKey != 24 )
304 {
305 return SYMCRYPT_WRONG_KEY_SIZE;
306 }
307
308 //
309 // A loop that goes over the provided key as a circular buffer provides
310 // the right result with the least complexity.
311 // This is inefficient for the cases cbKey=8 and cbKey=16, but those should
312 // not be used anyway.
313 //
314 for( i=0; i<3; i++ )
315 {
316 SYMCRYPT_ASSERT( keyIndex <= cbKey - 8 ); // help PreFast
317 SymCryptDesExpandSingleKey( pExpandedKey->roundKey[i], pbKey + keyIndex );
318 keyIndex = (keyIndex + 8) % cbKey;
319 }
320
321 SYMCRYPT_SET_MAGIC( pExpandedKey );
322
323 return SYMCRYPT_NO_ERROR;
324}
SymCryptDesExpandSingleKey
VOID SYMCRYPT_CALL SymCryptDesExpandSingleKey(_Out_writes_bytes_(128) UINT32 expandedKeyTable[16][2], _In_reads_(8) PCBYTE pKey)
Definition: 3des.c:195
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
pbKey
PCBYTE pbKey
Definition: symcrypt_internal.h:1987
cbKey
PCBYTE SIZE_T cbKey
Definition: symcrypt_internal.h:1987
SYMCRYPT_SET_MAGIC
#define SYMCRYPT_SET_MAGIC(p)
Definition: symcrypt_internal.h:358
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80

Referenced by setup_key_impl(), SymCrypt3DesSelftest(), and SymCryptDesExpandKey().

◆ SymCrypt3DesSelftest()

VOID SYMCRYPT_CALL SymCrypt3DesSelftest ( void  )

Definition at line 656 of file 3des.c.

657{
658 BYTE buf[SYMCRYPT_3DES_BLOCK_SIZE];
659 SYMCRYPT_3DES_EXPANDED_KEY key;
660
661 if( SymCrypt3DesExpandKey( &key, SP800_67Key, 24 ) != SYMCRYPT_NO_ERROR )
662 {
663 SymCryptFatal( 'des3' );
664 }
665
666 SymCrypt3DesEncrypt( &key, des3KnownPlaintext, buf );
667
668 SymCryptInjectError( buf, SYMCRYPT_3DES_BLOCK_SIZE );
669
670 if( memcmp( buf, des3KnownCiphertext, SYMCRYPT_3DES_BLOCK_SIZE ) != 0 )
671 {
672 SymCryptFatal( 'des4' );
673 }
674
675 SymCrypt3DesDecrypt( &key, des3KnownCiphertext, buf );
676
677 SymCryptInjectError( buf, SYMCRYPT_3DES_BLOCK_SIZE );
678
679 if( memcmp( buf, des3KnownPlaintext, SYMCRYPT_3DES_BLOCK_SIZE ) != 0 )
680 {
681 SymCryptFatal( 'des5' );
682 }
683}
des3KnownCiphertext
static const BYTE des3KnownCiphertext[8]
Definition: 3des.c:613
SP800_67Key
static const BYTE SP800_67Key[24]
Definition: 3des.c:603
SymCrypt3DesEncrypt
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCrypt3DesEncrypt(_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbDst)
Definition: 3des.c:358
SymCrypt3DesExpandKey
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCrypt3DesExpandKey(_Out_ PSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: 3des.c:295
des3KnownPlaintext
static const BYTE des3KnownPlaintext[8]
Definition: 3des.c:609
SymCrypt3DesDecrypt
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCrypt3DesDecrypt(_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbDst)
Definition: 3des.c:478
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2807
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
SymCryptInjectError
VOID SYMCRYPT_CALL SymCryptInjectError(PBYTE pbData, SIZE_T cbData)
key
Definition: copy.c:22
SymCryptFatal
_Analysis_noreturn_ VOID SYMCRYPT_CALL SymCryptFatal(UINT32 fatalCode)
SYMCRYPT_3DES_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_3DES_EXPANDED_KEY
Definition: symcrypt_internal.h:1788
BYTE
unsigned char BYTE
Definition: xxhash.c:193

◆ SymCryptAesCbcDecrypt()

VOID SYMCRYPT_CALL SymCryptAesCbcDecrypt ( _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 214 of file aes-default.c.

220{
221#if SYMCRYPT_CPU_AMD64
222 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
223 {
224 SymCryptAesCbcDecryptXmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
225 } else {
226 SymCryptAesCbcDecryptAsm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
227 }
228#elif SYMCRYPT_CPU_X86
229 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
230
231 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
232 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
233 {
234 SymCryptAesCbcDecryptXmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
235 SymCryptRestoreXmm( &SaveData );
236 } else {
237 SymCryptAesCbcDecryptAsm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
238 }
239#elif SYMCRYPT_CPU_ARM
240 SymCryptAesCbcDecryptAsm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
241#elif SYMCRYPT_CPU_ARM64
242 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
243 {
244 SymCryptAesCbcDecryptNeon( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
245 } else {
246 SymCryptCbcDecrypt( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
247 }
248#else
249 SymCryptCbcDecrypt( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
250#endif
251}
SymCryptAesBlockCipherNoOpt
const SYMCRYPT_BLOCKCIPHER SymCryptAesBlockCipherNoOpt
Definition: aes-default.c:20
SaveData
VOID SaveData(HWND hwndDlg)
Definition: volume.c:368
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)
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)
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)
SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE
#define SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE
Definition: sc_lib.h:307
SYMCRYPT_CPU_FEATURES_PRESENT
#define SYMCRYPT_CPU_FEATURES_PRESENT(x)
Definition: symcrypt_internal.h:423

◆ SymCryptAesCbcEncrypt()

VOID SYMCRYPT_CALL SymCryptAesCbcEncrypt ( _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 173 of file aes-default.c.

179{
180#if SYMCRYPT_CPU_AMD64
181 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
182 {
183 SymCryptAesCbcEncryptXmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
184 } else {
185 SymCryptAesCbcEncryptAsm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
186 }
187#elif SYMCRYPT_CPU_X86
188 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
189
190 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
191 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
192 {
193 SymCryptAesCbcEncryptXmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
194 SymCryptRestoreXmm( &SaveData );
195 } else {
196 SymCryptAesCbcEncryptAsm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
197 }
198#elif SYMCRYPT_CPU_ARM
199 SymCryptAesCbcEncryptAsm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
200#elif SYMCRYPT_CPU_ARM64
201 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
202 {
203 SymCryptAesCbcEncryptNeon( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
204 } else {
205 SymCryptCbcEncrypt( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
206 }
207#else
208 SymCryptCbcEncrypt( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
209#endif
210}
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)
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)
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)

◆ SymCryptAesCbcMac()

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

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

322{
323#if SYMCRYPT_CPU_AMD64
324 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
325 {
326 SymCryptAesCbcMacXmm( pExpandedKey, pbChainingValue, pbData, cbData );
327 } else {
328 SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE );
329 SymCryptCbcMac( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbData, cbData );
330 }
331#elif SYMCRYPT_CPU_X86
332 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
333
334 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
335 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
336 {
337 SymCryptAesCbcMacXmm( pExpandedKey, pbChainingValue, pbData, cbData );
338 SymCryptRestoreXmm( &SaveData );
339 } else {
340 SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE );
341 SymCryptCbcMac( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbData, cbData );
342 }
343#elif SYMCRYPT_CPU_ARM64
344 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
345 {
346 SymCryptAesCbcMacNeon( pExpandedKey, pbChainingValue, pbData, cbData );
347 } else {
348 SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE );
349 SymCryptCbcMac( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbData, cbData );
350 }
351#else
352 SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE );
353 SymCryptCbcMac( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbData, cbData );
354#endif
355}
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)
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)
SYMCRYPT_AES_BLOCK_SIZE
#define SYMCRYPT_AES_BLOCK_SIZE
Definition: symcrypt.h:4255
SymCryptCbcMac
VOID SYMCRYPT_CALL SymCryptCbcMac(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, SIZE_T cbData)
Definition: blockciphermodes.c:198
pbData
PCBYTE pbData
Definition: symcrypt_internal.h:1246

Referenced by SymCryptAesCmacAppend(), SymCryptAesCmacResult(), and SymCryptRngAesBcc().

◆ SymCryptAesCmac()

VOID SYMCRYPT_CALL SymCryptAesCmac ( _In_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_AES_CMAC_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 93 of file aescmac.c.

98{
99 SYMCRYPT_AES_CMAC_STATE state;
100
101 SymCryptAesCmacInit( &state, pExpandedKey );
102 SymCryptAesCmacAppend( &state, pbData, cbData );
103 SymCryptAesCmacResult( &state, pbResult );
104
105 SymCryptWipeKnownSize( &state, sizeof( state ) );
106}
SymCryptAesCmacInit
VOID SYMCRYPT_CALL SymCryptAesCmacInit(_Out_ PSYMCRYPT_AES_CMAC_STATE pState, _In_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey)
Definition: aescmac.c:135
SymCryptAesCmacAppend
VOID SYMCRYPT_CALL SymCryptAesCmacAppend(_Inout_ PSYMCRYPT_AES_CMAC_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: aescmac.c:150
SymCryptAesCmacResult
VOID SYMCRYPT_CALL SymCryptAesCmacResult(_Inout_ PSYMCRYPT_AES_CMAC_STATE pState, _Out_writes_(SYMCRYPT_AES_CMAC_RESULT_SIZE) PBYTE pbResult)
Definition: aescmac.c:202
state
static int state
Definition: maze.c:121
pbResult
static const BYTE pbResult[]
Definition: ssh_kdf_sha256.c:38
SymCryptWipeKnownSize
FORCEINLINE VOID SYMCRYPT_CALL SymCryptWipeKnownSize(_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
Definition: symcrypt_internal.h:3411
SYMCRYPT_AES_CMAC_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_AES_CMAC_STATE
Definition: symcrypt_internal.h:1681

Referenced by SymCryptAesCmacSelftest().

◆ SymCryptAesCmacAppend()

VOID SYMCRYPT_CALL SymCryptAesCmacAppend ( _Inout_ PSYMCRYPT_AES_CMAC_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 150 of file aescmac.c.

154{
155
156 SYMCRYPT_CHECK_MAGIC( pState );
157
158 if( pState->bytesInBuf != 0 )
159 {
160 SIZE_T freeInBuf = SYMCRYPT_AES_BLOCK_SIZE - pState->bytesInBuf;
161 SYMCRYPT_ASSERT( freeInBuf < SYMCRYPT_AES_BLOCK_SIZE );
162
163 if( cbData <= freeInBuf )
164 {
165 // Do nothing.
166 // the data will be copied into the buf at the end of this function
167 //
168 }
169 else
170 {
171 memcpy( &pState->buf[pState->bytesInBuf], pbData, freeInBuf );
172 pbData += freeInBuf;
173 cbData -= freeInBuf;
174 SymCryptAesCbcMac( &pState->pKey->aesKey, &pState->chain[0], &pState->buf[0], SYMCRYPT_AES_BLOCK_SIZE );
175 pState->bytesInBuf = 0;
176 }
177 }
178
179 //
180 // At this point, either pState->bytesInBuf == 0, or it is !=0 but cbData is small enough that all the
181 // data will still fit in the buffer without further processing.
182 //
183
184 if( cbData > SYMCRYPT_AES_BLOCK_SIZE )
185 {
186 SIZE_T bytesToDo = (cbData-1) & ~(SIZE_T)(SYMCRYPT_AES_BLOCK_SIZE - 1);
187 SymCryptAesCbcMac( &pState->pKey->aesKey, &pState->chain[0], pbData, bytesToDo );
188 pbData += bytesToDo;
189 cbData -= bytesToDo;
190 }
191
192 if( cbData > 0 )
193 {
194 memcpy( &pState->buf[pState->bytesInBuf], pbData, cbData );
195 pState->bytesInBuf += cbData;
196 }
197}
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
SymCryptAesCbcMac
VOID SYMCRYPT_CALL SymCryptAesCbcMac(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: aes-default.c:317
pState
PSYMCRYPT_COMMON_HASH_STATE pState
Definition: symcrypt_internal.h:1278

Referenced by SymCryptAesCmac().

◆ SymCryptAesCmacExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesCmacExpandKey ( _Out_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 44 of file aescmac.c.

48{
49 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
50 SYMCRYPT_ALIGN BYTE buf[SYMCRYPT_AES_BLOCK_SIZE];
51
52 scError = SymCryptAesExpandKey( &pExpandedKey->aesKey, pbKey, cbKey );
53 if( scError != SYMCRYPT_NO_ERROR )
54 {
55 goto cleanup;
56 }
57
58 SymCryptWipeKnownSize( buf, sizeof( buf ) );
59
60 SymCryptAesEncrypt( &pExpandedKey->aesKey, buf, buf );
61
62 SymCryptCmacMunge( buf );
63 memcpy( &pExpandedKey->K1, buf, sizeof( buf ) );
64 SymCryptCmacMunge( buf );
65 memcpy( &pExpandedKey->K2, buf, sizeof( buf ) );
66
67 SymCryptWipeKnownSize( buf, sizeof( buf ) );
68
69 SYMCRYPT_SET_MAGIC( pExpandedKey );
70
71cleanup:
72
73 return scError;
74}
SymCryptCmacMunge
VOID SYMCRYPT_CALL SymCryptCmacMunge(_Inout_updates_bytes_(SYMCRYPT_AES_BLOCK_SIZE) BYTE buf[SYMCRYPT_AES_BLOCK_SIZE])
Definition: aescmac.c:25
cleanup
static void cleanup(void)
Definition: main.c:1335
SymCryptAesExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKey(_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: aes-key.c:219
SymCryptAesEncrypt
VOID SYMCRYPT_CALL SymCryptAesEncrypt(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)
Definition: aes-default.c:95
SYMCRYPT_ALIGN
#define SYMCRYPT_ALIGN
Definition: symcrypt_internal.h:306

Referenced by SymCryptAesCmacSelftest().

◆ SymCryptAesCmacInit()

VOID SYMCRYPT_CALL SymCryptAesCmacInit ( _Out_ PSYMCRYPT_AES_CMAC_STATE  pState,
_In_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY  pExpandedKey 
)

Definition at line 135 of file aescmac.c.

138{
139 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
140
141 pState->bytesInBuf = 0;
142 SymCryptWipeKnownSize( pState->chain, sizeof( pState->chain ) );
143 pState->pKey = pExpandedKey;
144
145 SYMCRYPT_SET_MAGIC( pState );
146}

Referenced by SymCryptAesCmac().

◆ SymCryptAesCmacKeyCopy()

VOID SYMCRYPT_CALL SymCryptAesCmacKeyCopy ( _In_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY  pDst 
)

Definition at line 79 of file aescmac.c.

82{
83 SYMCRYPT_CHECK_MAGIC( pSrc );
84 SymCryptAesKeyCopy( &pSrc->aesKey, &pDst->aesKey );
85 memcpy( pDst->K1, pSrc->K1, sizeof( pDst->K1 ) );
86 memcpy( pDst->K2, pSrc->K2, sizeof( pDst->K2 ) );
87 SYMCRYPT_SET_MAGIC( pDst );
88}
SymCryptAesKeyCopy
VOID SYMCRYPT_CALL SymCryptAesKeyCopy(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_AES_EXPANDED_KEY pDst)
Definition: aes-key.c:240

◆ SymCryptAesCmacResult()

VOID SYMCRYPT_CALL SymCryptAesCmacResult ( _Inout_ PSYMCRYPT_AES_CMAC_STATE  pState,
_Out_writes_(SYMCRYPT_AES_CMAC_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 202 of file aescmac.c.

205{
206 SYMCRYPT_CHECK_MAGIC( pState );
207
208 if( pState->bytesInBuf < SYMCRYPT_AES_BLOCK_SIZE )
209 {
210 SymCryptWipe( &pState->buf[pState->bytesInBuf + 1], SYMCRYPT_AES_BLOCK_SIZE - pState->bytesInBuf - 1 );
211 pState->buf[pState->bytesInBuf] = 0x80;
212 SymCryptXorBytes( &pState->buf[0], &pState->pKey->K2[0], &pState->buf[0], SYMCRYPT_AES_BLOCK_SIZE );
213 }
214 else
215 {
216 SymCryptXorBytes( &pState->buf[0], &pState->pKey->K1[0], &pState->buf[0], SYMCRYPT_AES_BLOCK_SIZE );
217 }
218
219 SymCryptAesCbcMac( &pState->pKey->aesKey, &pState->chain[0], &pState->buf[0], SYMCRYPT_AES_BLOCK_SIZE );
220 memcpy( pbResult, &pState->chain[0], SYMCRYPT_AES_BLOCK_SIZE );
221
222 //
223 // Put the state back in the original starting state,
224 // and wipe any traces of the data.
225 //
226 pState->bytesInBuf = 0;
227 SymCryptWipeKnownSize( pState->chain, sizeof( pState->chain ) );
228 SymCryptWipeKnownSize( pState->buf, sizeof( pState->buf ) );
229}
SymCryptWipe
VOID SYMCRYPT_CALL SymCryptWipe(_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
Definition: libmain.c:137
SymCryptXorBytes
VOID SYMCRYPT_CALL SymCryptXorBytes(_In_reads_(cbBytes) PCBYTE pbSrc1, _In_reads_(cbBytes) PCBYTE pbSrc2, _Out_writes_(cbBytes) PBYTE pbResult, SIZE_T cbBytes)
Definition: libmain.c:236

Referenced by SymCryptAesCmac().

◆ SymCryptAesCmacSelftest()

VOID SYMCRYPT_CALL SymCryptAesCmacSelftest ( void  )

Definition at line 240 of file aescmac.c.

241{
242 SYMCRYPT_AES_CMAC_EXPANDED_KEY xKey;
243 BYTE res[SYMCRYPT_AES_CMAC_RESULT_SIZE];
244
245 SymCryptAesCmacExpandKey( &xKey, SymCryptTestKey32, 16 );
246 SymCryptAesCmac( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
247
248 SymCryptInjectError( res, sizeof( res ) );
249 if( memcmp( res, aesCmacKat, sizeof( res ) ) != 0 )
250 {
251 SymCryptFatal( 'hsh5' );
252 }
253
254 //
255 // Normally we would wipe the expanded key structure here,
256 // but as this is a selftest with known data this is not needed.
257 //
258}
SymCryptAesCmac
VOID SYMCRYPT_CALL SymCryptAesCmac(_In_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_AES_CMAC_RESULT_SIZE) PBYTE pbResult)
Definition: aescmac.c:93
aesCmacKat
static const BYTE aesCmacKat[SYMCRYPT_AES_CMAC_RESULT_SIZE]
Definition: aescmac.c:233
SymCryptAesCmacExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesCmacExpandKey(_Out_ PSYMCRYPT_AES_CMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: aescmac.c:44
res
GLuint res
Definition: glext.h:9613
SymCryptTestKey32
const BYTE SymCryptTestKey32[32]
Definition: selftest.c:10
SymCryptTestMsg3
const BYTE SymCryptTestMsg3[3]
Definition: selftest.c:8
SYMCRYPT_AES_CMAC_RESULT_SIZE
#define SYMCRYPT_AES_CMAC_RESULT_SIZE
Definition: symcrypt.h:3441
SYMCRYPT_AES_CMAC_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_AES_CMAC_EXPANDED_KEY
Definition: symcrypt_internal.h:1670

◆ SymCryptAesCmacStateCopy()

VOID SYMCRYPT_CALL SymCryptAesCmacStateCopy ( _In_ PCSYMCRYPT_AES_CMAC_STATE  pSrc,
_In_opt_ PCSYMCRYPT_AES_CMAC_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_AES_CMAC_STATE  pDst 
)

Definition at line 111 of file aescmac.c.

115{
116 SYMCRYPT_CHECK_MAGIC( pSrc );
117 *pDst = *pSrc;
118
119 if( pExpandedKey == NULL )
120 {
121 SYMCRYPT_CHECK_MAGIC( pSrc->pKey );
122 pDst->pKey = pSrc->pKey;
123 }
124 else
125 {
126 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
127 pDst->pKey = pExpandedKey;
128 }
129
130 SYMCRYPT_SET_MAGIC( pDst );
131}
NULL
#define NULL
Definition: types.h:112

◆ SymCryptAesCtrMsb64()

VOID SYMCRYPT_CALL SymCryptAesCtrMsb64 ( _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 404 of file aes-default.c.

410{
411#if SYMCRYPT_CPU_AMD64
412 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
413 {
414 SymCryptAesCtrMsb64Xmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
415 } else {
416 SymCryptAesCtrMsb64Asm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
417 }
418
419#elif SYMCRYPT_CPU_X86
420 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
421
422 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
423 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
424 {
425 SymCryptAesCtrMsb64Xmm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
426 SymCryptRestoreXmm( &SaveData );
427 } else {
428 SymCryptAesCtrMsb64Asm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
429 }
430
431#elif SYMCRYPT_CPU_ARM
432 SymCryptAesCtrMsb64Asm( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
433
434#elif SYMCRYPT_CPU_ARM64
435 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
436 {
437 SymCryptAesCtrMsb64Neon( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
438 } else {
439 SymCryptCtrMsb64( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
440 }
441
442#else
443 SYMCRYPT_ASSERT( SymCryptAesBlockCipherNoOpt.blockSize == SYMCRYPT_AES_BLOCK_SIZE ); // keep Prefast happy
444 SymCryptCtrMsb64( &SymCryptAesBlockCipherNoOpt, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
445#endif
446}
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)
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)
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)
SymCryptCtrMsb64
VOID SYMCRYPT_CALL SymCryptCtrMsb64(_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: blockciphermodes.c:300

Referenced by SymCryptRngAesGenerateBlocks(), and SymCryptSrtpKdfDerive().

◆ SymCryptAesDecrypt()

VOID SYMCRYPT_CALL SymCryptAesDecrypt ( _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 134 of file aes-default.c.

138{
139#if SYMCRYPT_CPU_AMD64
140 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
141 {
142 SymCryptAesDecryptXmm( pExpandedKey, pbSrc, pbDst );
143 } else {
144 SymCryptAesDecryptAsm( pExpandedKey, pbSrc, pbDst );
145 }
146#elif SYMCRYPT_CPU_X86
147 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
148
149 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
150 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
151 {
152 SymCryptAesDecryptXmm( pExpandedKey, pbSrc, pbDst );
153 SymCryptRestoreXmm( &SaveData );
154 } else {
155 SymCryptAesDecryptAsm( pExpandedKey, pbSrc, pbDst );
156 }
157#elif SYMCRYPT_CPU_ARM
158 SymCryptAesDecryptAsm( pExpandedKey, pbSrc, pbDst );
159#elif SYMCRYPT_CPU_ARM64
160 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
161 {
162 SymCryptAesDecryptNeon( pExpandedKey, pbSrc, pbDst );
163 } else {
164 SymCryptAesDecryptC( pExpandedKey, pbSrc, pbDst );
165 }
166#else
167 SymCryptAesDecryptC( pExpandedKey, pbSrc, pbDst );
168#endif
169}
SymCryptAesDecryptC
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptAesDecryptC(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbCiphertext, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbPlaintext)
Definition: aes-c.c:242
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)
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)
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 decrypt_block_impl(), SymCryptAesDecryptC(), SymCryptAesEcbDecrypt(), SymCryptAesKwpDecrypt(), and SymCryptAesKwxInternalUnwrap().

◆ SymCryptAesEcbDecrypt()

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

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

305{
306 while( cbData >= SYMCRYPT_AES_BLOCK_SIZE )
307 {
308 SymCryptAesDecrypt( pExpandedKey, pbSrc, pbDst );
309 pbSrc += SYMCRYPT_AES_BLOCK_SIZE;
310 pbDst += SYMCRYPT_AES_BLOCK_SIZE;
311 cbData -= SYMCRYPT_AES_BLOCK_SIZE;
312 }
313}
SymCryptAesDecrypt
VOID SYMCRYPT_CALL SymCryptAesDecrypt(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)
Definition: aes-default.c:134

◆ SymCryptAesEcbEncrypt()

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

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

260{
261#if SYMCRYPT_CPU_AMD64
262 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
263 {
264 SymCryptAesEcbEncryptXmm( pExpandedKey, pbSrc, pbDst, cbData );
265 } else {
266 SymCryptAesEcbEncryptAsm( pExpandedKey, pbSrc, pbDst, cbData );
267 }
268#elif SYMCRYPT_CPU_X86
269 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
270
271 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
272 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
273 {
274 SymCryptAesEcbEncryptXmm( pExpandedKey, pbSrc, pbDst, cbData );
275 SymCryptRestoreXmm( &SaveData );
276 } else {
277 SymCryptAesEcbEncryptAsm( pExpandedKey, pbSrc, pbDst, cbData );
278 }
279#elif SYMCRYPT_CPU_ARM
280 SymCryptAesEcbEncryptAsm( pExpandedKey, pbSrc, pbDst, cbData );
281#elif SYMCRYPT_CPU_ARM64
282 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
283 {
284 SymCryptAesEcbEncryptNeon( pExpandedKey, pbSrc, pbDst, cbData );
285 } else {
286 SymCryptAesEcbEncryptC( pExpandedKey, pbSrc, pbDst, cbData );
287 }
288#else
289 SymCryptAesEcbEncryptC( pExpandedKey, pbSrc, pbDst, cbData );
290#endif
291}
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: aes-c.c:361
SymCryptAesEcbEncryptXmm
VOID SYMCRYPT_CALL SymCryptAesEcbEncryptXmm(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
SymCryptAesEcbEncryptNeon
VOID SYMCRYPT_CALL SymCryptAesEcbEncryptNeon(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
SymCryptAesEcbEncryptAsm
VOID SYMCRYPT_CALL SymCryptAesEcbEncryptAsm(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)

◆ SymCryptAesEncrypt()

VOID SYMCRYPT_CALL SymCryptAesEncrypt ( _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 95 of file aes-default.c.

99{
100#if SYMCRYPT_CPU_AMD64
101 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
102 {
103 SymCryptAesEncryptXmm( pExpandedKey, pbSrc, pbDst );
104 } else {
105 SymCryptAesEncryptAsm( pExpandedKey, pbSrc, pbDst );
106 }
107#elif SYMCRYPT_CPU_X86
108 SYMCRYPT_EXTENDED_SAVE_DATA SaveData;
109
110 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) &&
111 SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
112 {
113 SymCryptAesEncryptXmm( pExpandedKey, pbSrc, pbDst );
114 SymCryptRestoreXmm( &SaveData );
115 } else {
116 SymCryptAesEncryptAsm( pExpandedKey, pbSrc, pbDst );
117 }
118#elif SYMCRYPT_CPU_ARM
119 SymCryptAesEncryptAsm( pExpandedKey, pbSrc, pbDst );
120#elif SYMCRYPT_CPU_ARM64
121 if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
122 {
123 SymCryptAesEncryptNeon( pExpandedKey, pbSrc, pbDst );
124 } else {
125 SymCryptAesEncryptC( pExpandedKey, pbSrc, pbDst );
126 }
127#else
128 SymCryptAesEncryptC( pExpandedKey, pbSrc, pbDst );
129#endif
130}
SymCryptAesEncryptC
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptAesEncryptC(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbPlaintext, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbCiphertext)
Definition: aes-c.c:115
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)
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)
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 encrypt_block_impl(), SymCryptAesCmacExpandKey(), SymCryptAesEncryptC(), SymCryptAesKwpEncrypt(), SymCryptAesKwxInternalWrap(), SymCryptRngAesDf(), and SymCryptRngAesGenerateBlocks().

◆ SymCryptAesExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKey ( _Out_ PSYMCRYPT_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 219 of file aes-key.c.

224{
225 return SymCryptAesExpandKeyInternal( pExpandedKey, pbKey, cbKey, TRUE );
226}
SymCryptAesExpandKeyInternal
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKeyInternal(_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, BOOLEAN fCreateDecryptionKeys)
Definition: aes-key.c:35

Referenced by setup_key_impl(), SymCryptAesCmacExpandKey(), SymCryptCcmSelftest(), and SymCryptXtsAesExpandKey().

◆ SymCryptAesExpandKeyEncryptOnly()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKeyEncryptOnly ( _Out_ PSYMCRYPT_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 230 of file aes-key.c.

234{
235 return SymCryptAesExpandKeyInternal( pExpandedKey, pbKey, cbKey, FALSE );
236}

Referenced by SymCryptRngAesDf(), SymCryptRngAesGenerateSmall(), SymCryptRngAesUpdate(), SymCryptSrtpKdfExpandKey(), and SymCryptXtsAesExpandKey().

◆ SymCryptAesKeyCopy()

VOID SYMCRYPT_CALL SymCryptAesKeyCopy ( _In_ PCSYMCRYPT_AES_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_AES_EXPANDED_KEY  pDst 
)

Definition at line 240 of file aes-key.c.

242{
243 SYMCRYPT_CHECK_MAGIC( pSrc );
244
245 *pDst = *pSrc;
246 pDst->lastEncRoundKey = &pDst->RoundKey[0] + (pSrc->lastEncRoundKey - &pSrc->RoundKey[0]);
247 pDst->lastDecRoundKey = &pDst->RoundKey[0] + (pSrc->lastDecRoundKey - &pSrc->RoundKey[0]);
248
249 SYMCRYPT_SET_MAGIC( pDst );
250}

Referenced by duplicate_key_impl(), SymCryptAesCmacKeyCopy(), and SymCryptXtsAesKeyCopy().

◆ SymCryptAesKwDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwDecrypt ( _In_ PCSYMCRYPT_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_writes_to_(cbDst, *pcbResult) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbResult 
)

Definition at line 228 of file aeskw.c.

235{
236 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
237 PBYTE pbScratch = NULL;
238 UINT32 cbScratch = 0;
239
240 if( (cbSrc < SymCryptAesKWMinCiphertextLen) ||
241 (cbSrc > SymCryptAesKWMaxCiphertextLen) ||
242 ((cbSrc & (SYMCRYPT_AES_SEMIBLOCK_SIZE-1)) != 0) )
243 {
244 scError = SYMCRYPT_INVALID_ARGUMENT;
245 goto cleanup;
246 }
247
248 cbScratch = (UINT32) cbSrc;
249 if( cbDst < cbScratch-SYMCRYPT_AES_SEMIBLOCK_SIZE )
250 {
251 scError = SYMCRYPT_BUFFER_TOO_SMALL;
252 goto cleanup;
253 }
254
255 pbScratch = SymCryptCallbackAlloc( cbScratch );
256 if( pbScratch == NULL )
257 {
258 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
259 goto cleanup;
260 }
261
262 // set up input buffer as C
263 memcpy( pbScratch, pbSrc, cbSrc );
264
265 // decrypt input buffer in place
266 SymCryptAesKwxInternalUnwrap( pExpandedKey, pbScratch, cbScratch );
267
268 // check first semi-block has the expected value
269 if( SYMCRYPT_LOAD_LSBFIRST64( pbScratch ) != SymCryptAesKwDefaultICV )
270 {
271 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
272 goto cleanup;
273 }
274
275 // copy decrypted buffer to output
276 memcpy( pbDst, pbScratch+SYMCRYPT_AES_SEMIBLOCK_SIZE, cbScratch-SYMCRYPT_AES_SEMIBLOCK_SIZE );
277 *pcbResult = cbScratch-SYMCRYPT_AES_SEMIBLOCK_SIZE;
278
279cleanup:
280 if( pbScratch != NULL )
281 {
282 SymCryptWipe( pbScratch, cbScratch );
283 SymCryptCallbackFree( pbScratch );
284 }
285 return scError;
286
287}
SymCryptAesKwDefaultICV
const UINT64 SymCryptAesKwDefaultICV
Definition: aeskw.c:31
SymCryptAesKwxInternalUnwrap
static VOID SYMCRYPT_CALL SymCryptAesKwxInternalUnwrap(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_bytes_(cbBuf) PBYTE pbBuf, UINT32 cbBuf)
Definition: aeskw.c:116
SymCryptAesKWMinCiphertextLen
const SIZE_T SymCryptAesKWMinCiphertextLen
Definition: aeskw.c:37
SymCryptAesKWMaxCiphertextLen
const SIZE_T SymCryptAesKWMaxCiphertextLen
Definition: aeskw.c:38
SYMCRYPT_AES_SEMIBLOCK_SIZE
#define SYMCRYPT_AES_SEMIBLOCK_SIZE
Definition: aeskw.c:33
SymCryptCallbackFree
void SYMCRYPT_CALL SymCryptCallbackFree(void *ptr)
Definition: implglue.c:42
SymCryptCallbackAlloc
void *SYMCRYPT_CALL SymCryptCallbackAlloc(SIZE_T size)
Definition: implglue.c:37
PBYTE
BYTE * PBYTE
Definition: pedump.c:66
cbScratch
UINT32 UINT32 UINT32 UINT32 cbScratch
Definition: sc_lib_mldsa.h:1073
SYMCRYPT_LOAD_LSBFIRST64
#define SYMCRYPT_LOAD_LSBFIRST64(p)
Definition: symcrypt.h:300

◆ SymCryptAesKwEncrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwEncrypt ( _In_ PCSYMCRYPT_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_writes_to_(cbDst, *pcbResult) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbResult 
)

Definition at line 172 of file aeskw.c.

179{
180 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
181 PBYTE pbScratch = NULL;
182 UINT32 cbScratch = 0;
183
184 if( (cbSrc < SymCryptAesKWMinPlaintextLen) ||
185 (cbSrc > SymCryptAesKWMaxPlaintextLen) ||
186 ((cbSrc & (SYMCRYPT_AES_SEMIBLOCK_SIZE-1)) != 0) )
187 {
188 scError = SYMCRYPT_INVALID_ARGUMENT;
189 goto cleanup;
190 }
191
192 cbScratch = ((UINT32) cbSrc)+SYMCRYPT_AES_SEMIBLOCK_SIZE;
193 if( cbDst < cbScratch )
194 {
195 scError = SYMCRYPT_BUFFER_TOO_SMALL;
196 goto cleanup;
197 }
198
199 pbScratch = SymCryptCallbackAlloc( cbScratch );
200 if( pbScratch == NULL )
201 {
202 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
203 goto cleanup;
204 }
205
206 // set up input buffer as ICV1 || P
207 SYMCRYPT_STORE_LSBFIRST64( pbScratch, SymCryptAesKwDefaultICV );
208 memcpy( pbScratch+8, pbSrc, cbSrc );
209
210 // encrypt input buffer in place
211 SymCryptAesKwxInternalWrap( pExpandedKey, pbScratch, cbScratch );
212
213 // copy encrypted buffer to output
214 memcpy( pbDst, pbScratch, cbScratch );
215 *pcbResult = cbScratch;
216
217cleanup:
218 if( pbScratch != NULL )
219 {
220 SymCryptWipe( pbScratch, cbScratch );
221 SymCryptCallbackFree( pbScratch );
222 }
223 return scError;
224}
SymCryptAesKWMinPlaintextLen
const SIZE_T SymCryptAesKWMinPlaintextLen
Definition: aeskw.c:35
SymCryptAesKWMaxPlaintextLen
const SIZE_T SymCryptAesKWMaxPlaintextLen
Definition: aeskw.c:36
SymCryptAesKwxInternalWrap
static VOID SYMCRYPT_CALL SymCryptAesKwxInternalWrap(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _Inout_updates_bytes_(cbBuf) PBYTE pbBuf, UINT32 cbBuf)
Definition: aeskw.c:54
SYMCRYPT_STORE_LSBFIRST64
#define SYMCRYPT_STORE_LSBFIRST64(p, v)
Definition: symcrypt.h:308

◆ SymCryptAesKwpDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwpDecrypt ( _In_ PCSYMCRYPT_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_writes_to_(cbDst, *pcbResult) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbResult 
)

Definition at line 365 of file aeskw.c.

372{
373 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
374 PBYTE pbScratch = NULL;
375 UINT32 cbScratch = 0;
376 UINT32 cbPlaintext = 0;
377 UINT32 cbPad = 0;
378 UINT32 mVerificationError = 0; // Mask indicating whether the decrypted buffer is malformed
379 UINT32 mIsPlaintext = 0; // Mask for plaintext bytes in the final semi-block
380
381 if( (cbSrc < SymCryptAesKWPMinCiphertextLen) ||
382 (cbSrc > SymCryptAesKWPMaxCiphertextLen) ||
383 ((cbSrc & (SYMCRYPT_AES_SEMIBLOCK_SIZE-1)) != 0) )
384 {
385 scError = SYMCRYPT_INVALID_ARGUMENT;
386 goto cleanup;
387 }
388
389 cbScratch = (UINT32) cbSrc;
390 if( cbDst < cbScratch-SYMCRYPT_AES_SEMIBLOCK_SIZE-7 )
391 {
392 scError = SYMCRYPT_BUFFER_TOO_SMALL;
393 goto cleanup;
394 }
395
396 pbScratch = SymCryptCallbackAlloc( cbScratch );
397 if( pbScratch == NULL )
398 {
399 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
400 goto cleanup;
401 }
402
403 // set up input buffer as C
404 memcpy( pbScratch, pbSrc, cbSrc );
405
406 // decrypt input buffer in place
407 if( cbScratch == SYMCRYPT_AES_BLOCK_SIZE )
408 {
409 // special case for AES-KWP with small ciphertext
410 SymCryptAesDecrypt( pExpandedKey, pbScratch, pbScratch );
411 } else {
412 SymCryptAesKwxInternalUnwrap( pExpandedKey, pbScratch, cbScratch );
413 }
414
415 // Check if the decrypted buffer is of an expected form
416 // check bytes [0..3] are expected ICV
417 mVerificationError |= SYMCRYPT_LOAD_LSBFIRST32( pbScratch ) ^ SymCryptAesKwpDefaultICV;
418
419 // check bytes [4..7] are a valid plaintext length (i.e. computed cbPad in range [0,7])
420 cbPlaintext = SYMCRYPT_LOAD_MSBFIRST32( pbScratch+4 );
421 cbPad = (UINT32) cbSrc - cbPlaintext - SYMCRYPT_AES_SEMIBLOCK_SIZE;
422 mVerificationError |= (cbPad & 0xfffffff8);
423
424 // check that padding is all 0s
425 for( UINT32 i = 1; i<SYMCRYPT_AES_SEMIBLOCK_SIZE; i++ )
426 {
427 mIsPlaintext = SymCryptMask32LtU31(i, SYMCRYPT_AES_SEMIBLOCK_SIZE-(cbPad&7));
428 mVerificationError |= ((UINT32) pbScratch[ cbScratch-SYMCRYPT_AES_SEMIBLOCK_SIZE+i ]) & ~mIsPlaintext;
429 }
430
431 // Now if there was any verification error, we fail
432 if( mVerificationError != 0 )
433 {
434 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
435 goto cleanup;
436 }
437
438 // We are variable time w.r.t. the plaintext length on success
439 if( cbDst < cbPlaintext )
440 {
441 scError = SYMCRYPT_BUFFER_TOO_SMALL;
442 goto cleanup;
443 }
444
445 // copy decrypted buffer to output
446 memcpy( pbDst, pbScratch+SYMCRYPT_AES_SEMIBLOCK_SIZE, cbPlaintext );
447 *pcbResult = cbPlaintext;
448
449cleanup:
450 if( pbScratch != NULL )
451 {
452 SymCryptWipe( pbScratch, cbScratch );
453 SymCryptCallbackFree( pbScratch );
454 }
455 return scError;
456
457}
SymCryptAesKWPMinCiphertextLen
const SIZE_T SymCryptAesKWPMinCiphertextLen
Definition: aeskw.c:42
SymCryptAesKWPMaxCiphertextLen
const SIZE_T SymCryptAesKWPMaxCiphertextLen
Definition: aeskw.c:43
SymCryptAesKwpDefaultICV
const UINT32 SymCryptAesKwpDefaultICV
Definition: aeskw.c:32
SYMCRYPT_LOAD_MSBFIRST32
#define SYMCRYPT_LOAD_MSBFIRST32(p)
Definition: symcrypt.h:303
SymCryptAesDecrypt
VOID SYMCRYPT_CALL SymCryptAesDecrypt(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_AES_BLOCK_SIZE) PBYTE pbDst)
Definition: aes-default.c:134
SymCryptMask32LtU31
UINT32 SYMCRYPT_CALL SymCryptMask32LtU31(UINT32 a, UINT32 b)
Definition: scsTools.c:53

◆ SymCryptAesKwpEncrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesKwpEncrypt ( _In_ PCSYMCRYPT_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_writes_to_(cbDst, *pcbResult) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbResult 
)

Definition at line 291 of file aeskw.c.

298{
299 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
300 PBYTE pbScratch = NULL;
301 UINT32 cbScratch = 0;
302 UINT32 cbPad = 0;
303
304 if( (cbSrc < SymCryptAesKWPMinPlaintextLen) ||
305 (cbSrc > SymCryptAesKWPMaxPlaintextLen) )
306 {
307 scError = SYMCRYPT_INVALID_ARGUMENT;
308 goto cleanup;
309 }
310
311 cbPad = SYMCRYPT_AES_SEMIBLOCK_SIZE - ((UINT32) cbSrc & (SYMCRYPT_AES_SEMIBLOCK_SIZE-1));
312 if( cbPad == SYMCRYPT_AES_SEMIBLOCK_SIZE )
313 {
314 cbPad = 0;
315 }
316
317 cbScratch = (UINT32) cbSrc + SYMCRYPT_AES_SEMIBLOCK_SIZE + cbPad;
318 if( cbDst < cbScratch )
319 {
320 scError = SYMCRYPT_BUFFER_TOO_SMALL;
321 goto cleanup;
322 }
323
324 SYMCRYPT_ASSERT( cbScratch >= 16 );
325
326 pbScratch = SymCryptCallbackAlloc( cbScratch );
327 if( pbScratch == NULL )
328 {
329 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
330 goto cleanup;
331 }
332
333 // set up input buffer as ICV2 || len(P) || P || PAD
334 SYMCRYPT_STORE_LSBFIRST32( pbScratch, SymCryptAesKwpDefaultICV );
335 SYMCRYPT_STORE_MSBFIRST32( pbScratch+4, (UINT32) cbSrc );
336 // pad by unconditionally setting the last 8 bytes to 0
337 // then overwrite some or all of the padding bytes with plaintext
338 SYMCRYPT_STORE_LSBFIRST64( pbScratch+cbScratch-SYMCRYPT_AES_SEMIBLOCK_SIZE, 0u );
339 memcpy( pbScratch+8, pbSrc, cbSrc );
340
341 // encrypt input buffer in place
342 if( cbScratch == SYMCRYPT_AES_BLOCK_SIZE )
343 {
344 // special case for AES-KWP with small plaintext
345 SymCryptAesEncrypt( pExpandedKey, pbScratch, pbScratch );
346 } else {
347 SymCryptAesKwxInternalWrap( pExpandedKey, pbScratch, cbScratch );
348 }
349
350 // copy encrypted buffer to output
351 memcpy( pbDst, pbScratch, cbScratch );
352 *pcbResult = cbScratch;
353
354cleanup:
355 if( pbScratch != NULL )
356 {
357 SymCryptWipe( pbScratch, cbScratch );
358 SymCryptCallbackFree( pbScratch );
359 }
360 return scError;
361}
SymCryptAesKWPMaxPlaintextLen
const SIZE_T SymCryptAesKWPMaxPlaintextLen
Definition: aeskw.c:41
SymCryptAesKWPMinPlaintextLen
const SIZE_T SymCryptAesKWPMinPlaintextLen
Definition: aeskw.c:40
u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
SYMCRYPT_STORE_MSBFIRST32
#define SYMCRYPT_STORE_MSBFIRST32(p, v)
Definition: symcrypt.h:311

◆ SymCryptAesSelftest()

VOID SYMCRYPT_CALL SymCryptAesSelftest ( UINT32  maskTestsToRun)

◆ SymCryptCallbackAcquireMutexFastInproc()

VOID SYMCRYPT_CALL SymCryptCallbackAcquireMutexFastInproc ( _Inout_ PVOID  pMutex)

Referenced by SymCryptSessionDecryptUpdateStateLock().

◆ SymCryptCallbackAlloc()

PVOID SYMCRYPT_CALL SymCryptCallbackAlloc ( SIZE_T  nBytes)

Definition at line 37 of file implglue.c.

38{
39 return _aligned_malloc( size, SYMCRYPT_ASYM_ALIGN_VALUE );
40}
_aligned_malloc
void *CDECL _aligned_malloc(size_t size, size_t alignment)
Definition: heap.c:603
size
GLsizeiptr size
Definition: glext.h:5919
SYMCRYPT_ASYM_ALIGN_VALUE
#define SYMCRYPT_ASYM_ALIGN_VALUE
Definition: symcrypt_internal.h:2297

Referenced by SymCrypt802_11SaeCustomCommitCreateGeneric(), SymCrypt802_11SaeCustomCommitProcessGeneric(), SymCrypt802_11SaeCustomCreatePTGeneric(), SymCrypt802_11SaeCustomInit(), SymCrypt802_11SaeCustomInitH2EGeneric(), SymCryptAesKwDecrypt(), SymCryptAesKwEncrypt(), SymCryptAesKwpDecrypt(), SymCryptAesKwpEncrypt(), SymCryptDhSecretAgreement(), SymCryptDlgroupAllocate(), SymCryptDlgroupGenerate(), SymCryptDlgroupGetValue(), SymCryptDlgroupSetValue(), SymCryptDlgroupSetValueSafePrime(), SymCryptDlkeyAllocate(), SymCryptDlkeyGenerate(), SymCryptDlkeyGetValue(), SymCryptDlkeySetValue(), SymCryptDsaSignEx(), SymCryptDsaVerify(), SymCryptEcDhSecretAgreement(), SymCryptEcDsaSignEx(), SymCryptEcDsaVerify(), SymCryptEckeyAllocate(), SymCryptEckeyGetValue(), SymCryptEckeySetRandom(), SymCryptEckeySetValue(), SymCryptEcpointAllocate(), SymCryptEcurveAllocate(), SymCryptFdefCreateTrialDivisionContext(), SymCryptFdefDivisorAllocate(), SymCryptFdefIntAllocate(), SymCryptFdefModElementAllocate(), SymCryptFdefModulusAllocate(), SymCryptGenerateSmallPrimes(), SymCryptLmskeyAllocate(), SymCryptMlDsakeyAllocate(), SymCryptMlDsakeyGenerate(), SymCryptMlDsaTemporariesAllocateAndInitialize(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulateEx(), SymCryptMlKemkeyAllocate(), SymCryptMlKemkeyGenerate(), SymCryptMlKemkeySetValue(), SymCryptRsakeyAllocate(), SymCryptRsakeyGenerate(), SymCryptRsakeyGetCrtValue(), SymCryptRsakeySetValueInternal(), SymCryptRsaOaepDecrypt(), SymCryptRsaOaepEncrypt(), SymCryptRsaPkcs1Decrypt(), SymCryptRsaPkcs1Encrypt(), SymCryptRsaPkcs1Sign(), SymCryptRsaPkcs1Verify(), SymCryptRsaPssSign(), SymCryptRsaPssVerify(), SymCryptRsaRawDecrypt(), SymCryptRsaRawEncrypt(), SymCryptXmssComputePublicRoot(), SymCryptXmsskeyAllocate(), SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptCallbackAllocateMutexFastInproc()

PVOID SYMCRYPT_CALL SymCryptCallbackAllocateMutexFastInproc ( void  )

Referenced by SymCryptSessionReceiverInit().

◆ SymCryptCallbackFree()

VOID SYMCRYPT_CALL SymCryptCallbackFree ( PVOID  pMem)

◆ SymCryptCallbackFreeMutexFastInproc()

VOID SYMCRYPT_CALL SymCryptCallbackFreeMutexFastInproc ( _Inout_ PVOID  pMutex)

Referenced by SymCryptSessionDestroy().

◆ SymCryptCallbackRandom()

SYMCRYPT_ERROR SYMCRYPT_CALL SYMCRYPT_WEAK_SYMBOL SymCryptCallbackRandom ( _Out_writes_bytes_(cbBuffer) PBYTE  pbBuffer,
SIZE_T  cbBuffer 
)

◆ SymCryptCallbackReleaseMutexFastInproc()

VOID SYMCRYPT_CALL SymCryptCallbackReleaseMutexFastInproc ( _Inout_ PVOID  pMutex)

Referenced by SymCryptSessionDecryptUpdateStateLock().

◆ SymCryptCbcDecrypt()

VOID SYMCRYPT_CALL SymCryptCbcDecrypt ( _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 143 of file blockciphermodes.c.

151{
152 SYMCRYPT_ALIGN BYTE buf[3 * SYMCRYPT_MAX_BLOCK_SIZE];
153 PBYTE chain = &buf[0];
154 PBYTE ciphertext = &buf[SYMCRYPT_MAX_BLOCK_SIZE];
155 PBYTE tmp = &buf[2*SYMCRYPT_MAX_BLOCK_SIZE];
156
157 SIZE_T blockSize;
158 PCBYTE pbSrcEnd;
159
160 if( pBlockCipher->cbcDecryptFunc != NULL )
161 {
162 (*pBlockCipher->cbcDecryptFunc)( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
163 return;
164 }
165
166 blockSize = pBlockCipher->blockSize;
167 SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
168
169 //
170 // Compute the end of the data, rounding the size down to a multiple of the block size.
171 //
172 pbSrcEnd = &pbSrc[ cbData & ~(blockSize-1) ];
173
174#pragma warning(suppress: 22105)
175 memcpy( chain, pbChainingValue, blockSize );
176
177 //
178 // Loop structured to obey the read-once/write-once rule
179 //
180 while( pbSrc < pbSrcEnd )
181 {
182 SYMCRYPT_ASSERT( pbSrc <= pbSrcEnd - blockSize ); // help PreFast
183 memcpy( ciphertext, pbSrc, blockSize );
184 (*pBlockCipher->decryptFunc)( pExpandedKey, ciphertext, tmp );
185 SymCryptXorBytes( tmp, chain, pbDst, blockSize );
186 memcpy( chain, ciphertext, blockSize );
187 pbDst += blockSize;
188 pbSrc += blockSize;
189 }
190
191 memcpy( pbChainingValue, chain, blockSize );
192
193 SymCryptWipeKnownSize( buf, sizeof( buf ));
194}
_SYMCRYPT_BLOCKCIPHER::decryptFunc
PSYMCRYPT_BLOCKCIPHER_CRYPT decryptFunc
Definition: symcrypt_internal.h:1997
_SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc
PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE cbcDecryptFunc
Definition: symcrypt_internal.h:2001
SYMCRYPT_MAX_BLOCK_SIZE
#define SYMCRYPT_MAX_BLOCK_SIZE
Definition: symcrypt_internal.h:1984
pBlockCipher
PCSYMCRYPT_BLOCKCIPHER pBlockCipher
Definition: symcrypt_internal.h:1958
PCBYTE
const BYTE * PCBYTE
Definition: symcrypt_internal.h:248
chain
struct sock * chain
Definition: tcpcore.h:1

Referenced by SymCrypt3DesCbcDecrypt(), and SymCryptAesCbcDecrypt().

◆ SymCryptCbcEncrypt()

VOID SYMCRYPT_CALL SymCryptCbcEncrypt ( _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 78 of file blockciphermodes.c.

86{
87 SYMCRYPT_ALIGN BYTE buf[SYMCRYPT_MAX_BLOCK_SIZE];
88 SIZE_T blockSize;
89 PCBYTE pbSrcEnd;
90 PCBYTE pSrc = pbSrc;
91 PBYTE pDst = pbDst;
92
93 if( pBlockCipher->cbcEncryptFunc != NULL )
94 {
95 //
96 // Use optimized implementation if available
97 //
98 (*pBlockCipher->cbcEncryptFunc)( pExpandedKey, pbChainingValue, pSrc, pDst, cbData );
99 return;
100 }
101
102 blockSize = pBlockCipher->blockSize;
103
104 SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
105
106
107 //
108 // Compute the end of the data, rounding the size down to a multiple of the block size.
109 //
110 pbSrcEnd = &pbSrc[ cbData & ~(blockSize - 1) ];
111
112 //
113 // We keep the chaining state in a local buffer to enforce the read-once write-once rule.
114 //
115 memcpy( buf, pbChainingValue, blockSize );
116 while( pSrc < pbSrcEnd )
117 {
118 SYMCRYPT_ASSERT( pSrc <= pbSrc + cbData - blockSize ); // help PreFast
119 SYMCRYPT_ASSERT( pDst <= pbDst + cbData - blockSize ); // help PreFast
120 SYMCRYPT_ASSERT( blockSize <= cbData ); // help PreFast
121 SymCryptXorBytes( pSrc, buf, buf, blockSize );
122 (*pBlockCipher->encryptFunc)( pExpandedKey, buf, buf );
123 memcpy( pDst, buf, blockSize );
124 pSrc += blockSize;
125 pDst += blockSize;
126 }
127
128 memcpy( pbChainingValue, buf, blockSize );
129
130 SymCryptWipeKnownSize( buf, sizeof( buf ));
131}
_SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc
PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE cbcEncryptFunc
Definition: symcrypt_internal.h:2000
_SYMCRYPT_BLOCKCIPHER::encryptFunc
PSYMCRYPT_BLOCKCIPHER_CRYPT encryptFunc
Definition: symcrypt_internal.h:1996

Referenced by SymCrypt3DesCbcEncrypt(), and SymCryptAesCbcEncrypt().

◆ SymCryptCbcMac()

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

Definition at line 198 of file blockciphermodes.c.

205{
206 SYMCRYPT_ALIGN BYTE buf[32];
207 SIZE_T blockSize;
208 PCBYTE pbSrcEnd;
209 PCBYTE p;
210
211 if( pBlockCipher->cbcMacFunc != NULL )
212 {
213 //
214 // Use optimized implementation if available
215 //
216 (*pBlockCipher->cbcMacFunc)( pExpandedKey, pbChainingValue, pbSrc, cbData );
217 return;
218 }
219
220 blockSize = pBlockCipher->blockSize;
221 SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
222
223 //
224 // Compute the end of the data, rounding the size down to a multiple of the block size.
225 //
226 pbSrcEnd = &pbSrc[ cbData & ~(blockSize - 1) ];
227
228 //
229 // We keep the chaining state in a local buffer to enforce the read-once write-once rule.
230 // It also improves memory locality.
231 //
232 memcpy( buf, pbChainingValue, blockSize );
233 p = pbSrc;
234 while( p < pbSrcEnd )
235 {
236 SYMCRYPT_ASSERT( p <= pbSrc + cbData - blockSize );
237 SymCryptXorBytes( p, buf, buf, blockSize );
238 (*pBlockCipher->encryptFunc)( pExpandedKey, buf, buf );
239 p += blockSize;
240 }
241
242 memcpy( pbChainingValue, buf, blockSize );
243
244 SymCryptWipeKnownSize( buf, sizeof( buf ));
245}
p
GLfloat GLfloat p
Definition: glext.h:8902
_SYMCRYPT_BLOCKCIPHER::cbcMacFunc
PSYMCRYPT_BLOCKCIPHER_MAC_MODE cbcMacFunc
Definition: symcrypt_internal.h:2002

Referenced by SymCryptAesCbcMac(), and SymCryptCcmAddMacData().

◆ SymCryptCcmDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmDecrypt ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ PCVOID  pExpandedKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_In_reads_(cbTag) PCBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 257 of file ccm.c.

269{
270 SYMCRYPT_CCM_STATE state;
271 SYMCRYPT_ERROR status;
272
273 SymCryptCcmInit( &state,
274 pBlockCipher,
275 pExpandedKey,
276 pbNonce, cbNonce,
277 pbAuthData, cbAuthData,
278 cbData, cbTag );
279
280
281 SymCryptCcmDecryptPart( &state, pbSrc, pbDst, cbData );
282
283 status = SymCryptCcmDecryptFinal( &state, pbTag, cbTag );
284
285 //
286 // If we failed for any reason we wipe our output buffer to avoid returning
287 // decrypted but unauthenticated data.
288 //
289 if( status != SYMCRYPT_NO_ERROR )
290 {
291 SymCryptWipe( pbDst, cbData );
292 }
293
294 return status;
295}
SymCryptCcmDecryptPart
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptCcmDecryptPart(_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: ccm.c:503
SymCryptCcmDecryptFinal
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmDecryptFinal(_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
Definition: ccm.c:542
SymCryptCcmInit
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptCcmInit(_Out_ PSYMCRYPT_CCM_STATE pState, _In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, UINT64 cbData, SIZE_T cbTag)
Definition: ccm.c:300
status
Definition: ps.c:97
cbTag
SIZE_T cbTag
Definition: symcrypt_internal.h:1828
cbAuthData
UINT64 cbAuthData
Definition: symcrypt_internal.h:1970
SYMCRYPT_CCM_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_CCM_STATE
Definition: symcrypt_internal.h:1837
cbNonce
SIZE_T cbNonce
Definition: symcrypt_internal.h:1829

Referenced by SymCryptCcmSelftest().

◆ SymCryptCcmDecryptFinal()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmDecryptFinal ( _Inout_ PSYMCRYPT_CCM_STATE  pState,
_In_reads_(cbTag) PCBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 542 of file ccm.c.

546{
547 SYMCRYPT_ERROR status;
548
549 //
550 // Check invariants in checked builds
551 //
552 SYMCRYPT_CHECK_MAGIC( pState );
553
554 SYMCRYPT_ASSERT( cbTag == pState->cbTag && pState->bytesProcessed == pState->cbData );
555
556 SymCryptCcmPadMacData( pState );
557
558 //
559 // Set the counter value to zero to get the counter value that encrypts the tag,
560 // and then encrypt the tag
561 // We reset bytesProcessed so that the partial encrypt/decrypt function will do the right thing
562 //
563 SymCryptWipe( &pState->counterBlock[1 + pState->cbNonce], pState->cbCounter );
564
565 pState->bytesProcessed = 0;
566
567 SymCryptCcmEncryptDecryptPart( pState, &pState->macBlock[0], &pState->macBlock[0], SYMCRYPT_CCM_BLOCK_SIZE );
568
569 if( !SymCryptEqual( pbTag, &pState->macBlock[0], cbTag ) )
570 {
571 status = SYMCRYPT_AUTHENTICATION_FAILURE;
572 }
573 else
574 {
575 status = SYMCRYPT_NO_ERROR;
576 }
577
578 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
579 SYMCRYPT_ASSERT( pState->bytesInMacBlock == 0 );
580
581 return status;
582}
SymCryptCcmPadMacData
VOID SYMCRYPT_CALL SymCryptCcmPadMacData(_Inout_ PSYMCRYPT_CCM_STATE pState)
Definition: ccm.c:209
SymCryptCcmEncryptDecryptPart
VOID SYMCRYPT_CALL SymCryptCcmEncryptDecryptPart(_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: ccm.c:93
SymCryptEqual
BOOLEAN SYMCRYPT_CALL SymCryptEqual(_In_reads_(cbBytes) PCBYTE pbSrc1, _In_reads_(cbBytes) PCBYTE pbSrc2, SIZE_T cbBytes)
Definition: equal.c:11
SYMCRYPT_CCM_BLOCK_SIZE
#define SYMCRYPT_CCM_BLOCK_SIZE
Definition: symcrypt_internal.h:1822

Referenced by SymCryptCcmDecrypt().

◆ SymCryptCcmDecryptPart()

VOID SYMCRYPT_CALL SymCryptCcmDecryptPart ( _Inout_ PSYMCRYPT_CCM_STATE  pState,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 503 of file ccm.c.

508{
509 UINT64 bytesProcessedAfterThisCall;
510
511 SYMCRYPT_CHECK_MAGIC( pState );
512
513 bytesProcessedAfterThisCall = cbData + pState->bytesProcessed;
514
515 SYMCRYPT_ASSERT( bytesProcessedAfterThisCall >= cbData &&
516 bytesProcessedAfterThisCall <= pState->cbData );
517
518
519 //
520 // We are violating the read-once/write-once implementation rule here.
521 // We write the decrypted data and then read it back for the authentication function.
522 // In this particular situation this is safe to do.
523 //
524 // Anyone who can access the memory space that contains the source and destination of this
525 // function can recover the key stream used for this (key,nonce) combination.
526 // We can think of the decryption function as merely exposing the key stream, and then the
527 // caller picking the ciphertext (and by implication the plaintext) to be authenticated.
528 // Thus the data we read during authentication is the 'real' plaintext, and the
529 // decryption function merely made the key stream available.
530 //
531 // Note that this would not safe in general, it is only safe because CTR mode decryption already
532 // reveals the key stream.
533 //
534 SymCryptCcmEncryptDecryptPart( pState, pbSrc, pbDst, cbData );
535 SymCryptCcmAddMacData( pState, pbDst, cbData );
536
537}
UINT64
COMPILER_DEPENDENT_UINT64 UINT64
Definition: actypes.h:131
SymCryptCcmAddMacData
VOID SYMCRYPT_CALL SymCryptCcmAddMacData(_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: ccm.c:164

Referenced by SymCryptCcmDecrypt().

◆ SymCryptCcmEncrypt()

VOID SYMCRYPT_CALL SymCryptCcmEncrypt ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ PCVOID  pExpandedKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_Out_writes_(cbTag) PBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 227 of file ccm.c.

239{
240 SYMCRYPT_CCM_STATE state;
241
242 SymCryptCcmInit( &state,
243 pBlockCipher,
244 pExpandedKey,
245 pbNonce, cbNonce,
246 pbAuthData, cbAuthData,
247 cbData, cbTag );
248
249 SymCryptCcmEncryptPart( &state, pbSrc, pbDst, cbData );
250
251 SymCryptCcmEncryptFinal( &state, pbTag, cbTag );
252}
SymCryptCcmEncryptPart
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptCcmEncryptPart(_Inout_ PSYMCRYPT_CCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: ccm.c:433
SymCryptCcmEncryptFinal
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptCcmEncryptFinal(_Inout_ PSYMCRYPT_CCM_STATE pState, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
Definition: ccm.c:468

Referenced by SymCryptCcmSelftest().

◆ SymCryptCcmEncryptFinal()

VOID SYMCRYPT_CALL SymCryptCcmEncryptFinal ( _Inout_ PSYMCRYPT_CCM_STATE  pState,
_Out_writes_(cbTag) PBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 468 of file ccm.c.

472{
473 //
474 // Check invariants in checked builds
475 //
476 SYMCRYPT_CHECK_MAGIC( pState );
477
478 SYMCRYPT_ASSERT( cbTag == pState->cbTag && pState->bytesProcessed == pState->cbData );
479
480
481 SymCryptCcmPadMacData( pState );
482
483 //
484 // Set the counter value to zero to get the counter value that encrypts the tag,
485 // and then encrypt the tag.
486 // We reset bytesProcessed so that the partial encrypt/decrypt function will do the right thing
487 //
488 SymCryptWipe( &pState->counterBlock[1 + pState->cbNonce], pState->cbCounter );
489
490 pState->bytesProcessed = 0;
491
492 SymCryptCcmEncryptDecryptPart( pState, &pState->macBlock[0], &pState->macBlock[0], SYMCRYPT_CCM_BLOCK_SIZE );
493
494 memcpy( pbTag, &pState->macBlock[0], cbTag );
495
496 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
497 SYMCRYPT_ASSERT( pState->bytesInMacBlock == 0 );
498}

Referenced by SymCryptCcmEncrypt().

◆ SymCryptCcmEncryptPart()

VOID SYMCRYPT_CALL SymCryptCcmEncryptPart ( _Inout_ PSYMCRYPT_CCM_STATE  pState,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 433 of file ccm.c.

438{
439 UINT64 bytesProcessedAfterThisCall;
440
441 SYMCRYPT_CHECK_MAGIC( pState );
442
443 bytesProcessedAfterThisCall = cbData + pState->bytesProcessed;
444
445 SYMCRYPT_ASSERT( bytesProcessedAfterThisCall >= cbData &&
446 bytesProcessedAfterThisCall <= pState->cbData );
447
448 //
449 // We are violating the read-once implementation rule here. We read the data twice:
450 // once for MACing and once for encryption.
451 // In this particular situation this is safe to do.
452 // We consider the read for the MAC operation as reading the 'real' value.
453 // The encryption code reads the data, but all it does is XOR the key stream into
454 // it. (CCM encryption uses CTR mode for the encryption part.)
455 // We don't care if the attacker modifies the data before the encryption.
456 // We are revealing the key stream anyway (from the plaintext and ciphertext) and
457 // the exact byte value that we xor the key stream into is irrelevant.
458 //
459 SymCryptCcmAddMacData( pState, pbSrc, cbData );
460
461 SymCryptCcmEncryptDecryptPart( pState, pbSrc, pbDst, cbData );
462
463}

Referenced by SymCryptCcmEncrypt().

◆ SymCryptCcmInit()

VOID SYMCRYPT_CALL SymCryptCcmInit ( _Out_ PSYMCRYPT_CCM_STATE  pState,
_In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ PCVOID  pExpandedKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
UINT64  cbData,
SIZE_T  cbTag 
)

Definition at line 300 of file ccm.c.

310{
311 BYTE flags;
312 BYTE tmpBuf[ SYMCRYPT_CCM_BLOCK_SIZE ];
313 SIZE_T cbCounter;
314
315 SYMCRYPT_SET_MAGIC( pState );
316
317 //
318 // Validate parameters in checked builds
319 //
320 SYMCRYPT_ASSERT( SymCryptCcmValidateParameters( pBlockCipher, cbNonce, cbAuthData, cbData, cbTag ) == SYMCRYPT_NO_ERROR );
321
322
323 //
324 // compute # bytes in the counter field
325 // We limit cbNonce to 15 so that cbCounter + cbNonce = 15 will always hold
326 // This is much cheaper than full parameter validation, and it is enough to
327 // avoid any buffer overflows.
328 //
329 cbNonce &= SYMCRYPT_CCM_BLOCK_SIZE - 1;
330 cbCounter = SYMCRYPT_CCM_BLOCK_SIZE - 1 - cbNonce;
331
332 pState->pBlockCipher = pBlockCipher;
333 pState->pExpandedKey = pExpandedKey;
334 pState->cbNonce = cbNonce;
335 pState->cbData = cbData;
336 pState->cbTag = cbTag;
337 pState->cbCounter = cbCounter;
338 pState->bytesProcessed = 0;
339 pState->bytesInMacBlock = 0;
340
341 //
342 // Build the initial blocks for authentication and en/decryption
343 //
344 // Per Sp800-38c the flag byte is made up of four fields:
345 // Bits 0-2 are cbCounter - 1
346 // Bits 3-5 are (cbTag-2)/2
347 // Bit 6 is 1 if cbAuthData > 0
348 // Bit 7 is reserved and set to 0.
349 flags = (BYTE) (pState->cbCounter - 1);
350 flags |= ((cbTag-2)/2) << 3;
351 if( cbAuthData > 0 )
352 {
353 //
354 // No side-channel concerns with this if statements as we don't try to hide the
355 // data length or presence of authdata.
356 //
357 flags |= (1 << 6);
358 }
359
360
361 //
362 // The MAC starting block consists of three fields:
363 // the flag byte, the nonce, and cbData encoded into cbCounter bytes.
364 //
365 pState->macBlock[0] = flags;
366 memcpy( &pState->macBlock[1], pbNonce, cbNonce );
367 SYMCRYPT_STORE_MSBFIRST64( &tmpBuf[0], cbData );
368 memcpy( &pState->macBlock[1+cbNonce], &tmpBuf[ 8 - cbCounter ], cbCounter );
369
370 //
371 // The counter block is similar in layout, but with two changes:
372 // Bits 3-7 of the flag bytes are set to 0.
373 // The counter field is set to one (first counter value used for data encryption).
374 // Wiping the whole block first is probably faster, as the size is known and the
375 // block is aligned.
376 // We also copy the nonce from the mac block to follow the read-once rule.
377 //
378 SymCryptWipeKnownSize( &pState->counterBlock[0], SYMCRYPT_CCM_BLOCK_SIZE );
379 pState->counterBlock[0] = (BYTE)(flags & 0x7);
380 memcpy( &pState->counterBlock[1], &pState->macBlock[1], cbNonce );
381 pState->counterBlock[ SYMCRYPT_CCM_BLOCK_SIZE - 1] = 1;
382
383 //
384 // Encrypt the current MAC block; our CBC convention is to do the encryption
385 // as soon as we have enough data.
386 //
387 pBlockCipher->encryptFunc( pExpandedKey, &pState->macBlock[0], &pState->macBlock[0] );
388
389 //
390 // Next we process the associated data
391 // See the CCM specs for the details
392 //
393 if( cbAuthData <= 0 )
394 {
395 //
396 // cbAuthData == 0, nothing needs to be done.
397 //
398 } else if( cbAuthData < AUTHDATA_16BIT_LIMIT )
399 {
400 //
401 // 16-bit length encoding.
402 //
403 SYMCRYPT_STORE_MSBFIRST16( &tmpBuf[0], (UINT16) cbAuthData );
404 SymCryptCcmAddMacData( pState, &tmpBuf[0], 2 );
405 } else if( fcbAuthDataLt32bitLimitStatic || cbAuthData < AUTHDATA_32BIT_LIMIT )
406 {
407 //
408 // 32-bit length
409 //
410 tmpBuf[0] = 0xff;
411 tmpBuf[1] = 0xfe; // Magic prefix as per SP 800-38c
412 SYMCRYPT_STORE_MSBFIRST32( &tmpBuf[2], (UINT32) cbAuthData );
413 SymCryptCcmAddMacData( pState, &tmpBuf[0], 2 + sizeof( UINT32 ) );
414 } else
415 {
416 //
417 // 64-bit length
418 //
419 tmpBuf[0] = 0xff;
420 tmpBuf[1] = 0xff; // Magic prefix as per SP 800-38c
421 SYMCRYPT_STORE_MSBFIRST64( &tmpBuf[2], cbAuthData );
422 SymCryptCcmAddMacData( pState, &tmpBuf[0], 2 + sizeof( UINT64 ) );
423 }
424
425 SymCryptCcmAddMacData( pState, pbAuthData, cbAuthData );
426 SymCryptCcmPadMacData( pState ); // Pad MAC data with zeroes until the next block size boundary
427
428}
UINT16
unsigned short UINT16
Definition: actypes.h:129
flags
GLbitfield flags
Definition: glext.h:7161
AUTHDATA_16BIT_LIMIT
#define AUTHDATA_16BIT_LIMIT
Definition: ccm.c:16
SymCryptCcmValidateParameters
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmValidateParameters(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ SIZE_T cbNonce, _In_ SIZE_T cbAssociatedData, _In_ UINT64 cbData, _In_ SIZE_T cbTag)
Definition: ccm.c:28
fcbAuthDataLt32bitLimitStatic
const BOOL fcbAuthDataLt32bitLimitStatic
Definition: ccm.c:21
AUTHDATA_32BIT_LIMIT
#define AUTHDATA_32BIT_LIMIT
Definition: ccm.c:17
SYMCRYPT_STORE_MSBFIRST16
#define SYMCRYPT_STORE_MSBFIRST16(p, v)
Definition: symcrypt.h:310
SYMCRYPT_STORE_MSBFIRST64
#define SYMCRYPT_STORE_MSBFIRST64(p, v)
Definition: symcrypt.h:312
cbCounter
SIZE_T cbCounter
Definition: symcrypt_internal.h:1830

Referenced by SymCryptCcmDecrypt(), and SymCryptCcmEncrypt().

◆ SymCryptCcmSelftest()

VOID SYMCRYPT_CALL SymCryptCcmSelftest ( void  )

Definition at line 593 of file ccm.c.

594{
595 BYTE buf[ 3 + SYMCRYPT_AES_BLOCK_SIZE ];
596 SYMCRYPT_AES_EXPANDED_KEY key;
597 SYMCRYPT_ERROR err;
598
599 if( SymCryptAesExpandKey( &key, SymCryptTestKey32, 16 ) != SYMCRYPT_NO_ERROR )
600 {
601 SymCryptFatal( 'ccm0' );
602 }
603
604 SymCryptCcmEncrypt( SymCryptAesBlockCipher,
605 &key,
606 &SymCryptTestKey32[16], 12,
607 NULL, 0,
608 &SymCryptTestMsg3[0], buf, 3,
609 &buf[3], SYMCRYPT_AES_BLOCK_SIZE );
610
611 SymCryptInjectError( buf, sizeof( buf ) );
612 if( memcmp( buf, SymCryptCcmSelftestResult, sizeof( buf ) ) != 0 )
613 {
614 SymCryptFatal( 'ccm1' );
615 }
616
617 // inject error into the ciphertext or tag
618 SymCryptInjectError( buf, sizeof( buf ) );
619
620 err = SymCryptCcmDecrypt( SymCryptAesBlockCipher,
621 &key,
622 &SymCryptTestKey32[16], 12,
623 NULL, 0,
624 buf, buf, 3,
625 &buf[3], SYMCRYPT_AES_BLOCK_SIZE );
626
627 SymCryptInjectError( buf, 3 );
628
629 if( err != SYMCRYPT_NO_ERROR || memcmp( buf, SymCryptTestMsg3, 3 ) != 0 )
630 {
631 SymCryptFatal( 'ccm2' );
632 }
633
634}
err
#define err(...)
Definition: reactos_support_code.h:30
SymCryptCcmSelftestResult
static const BYTE SymCryptCcmSelftestResult[3+SYMCRYPT_AES_BLOCK_SIZE]
Definition: ccm.c:585
SymCryptCcmDecrypt
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmDecrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
Definition: ccm.c:257
SymCryptCcmEncrypt
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptCcmEncrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
Definition: ccm.c:227
SymCryptAesBlockCipher
const PCSYMCRYPT_BLOCKCIPHER SymCryptAesBlockCipher
Definition: aes-default-bc.c:92
SYMCRYPT_AES_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_AES_EXPANDED_KEY
Definition: symcrypt_internal.h:1655

◆ SymCryptCcmValidateParameters()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCcmValidateParameters ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ SIZE_T  cbNonce,
_In_ SIZE_T  cbAssociatedData,
_In_ UINT64  cbData,
_In_ SIZE_T  cbTag 
)

Definition at line 28 of file ccm.c.

35{
36 SIZE_T cbCounter;
37
38 UNREFERENCED_PARAMETER( cbAssociatedData );
39
40 if( pBlockCipher->blockSize != SYMCRYPT_CCM_BLOCK_SIZE )
41 {
42 return SYMCRYPT_WRONG_BLOCK_SIZE;
43 }
44
45 //
46 // Test against limits in SP800-38C appendix A
47 //
48 if( cbNonce < CCM_MIN_NONCE_SIZE || cbNonce > CCM_MAX_NONCE_SIZE )
49 {
50 return SYMCRYPT_WRONG_NONCE_SIZE;
51 }
52
53 //
54 // cbAssociatedData is limited to <2^64
55 // We don't test for this. None of our platforms has a SIZE_T that is
56 // large enough to violate this condition. And the test
57 // is of a form that the compiler cannot optimize away.
58 //
59
60 //
61 // The counter block consists of a single flag byte, the nonce, and the counter field.
62 //
63 cbCounter = SYMCRYPT_CCM_BLOCK_SIZE - cbNonce - 1;
64
65 //
66 // per SP800-38C cbData is limited to 2^{8*cbCounter}
67 // There is no way to do this test in a single comparison.
68 // We don't have to worry about side-channels in the && because
69 // cbCounter depends only on the length of the nonce, and we do not
70 // try to hide any lengths.
71 //
72 if( cbCounter < sizeof( UINT64 ) &&
73 cbData >= ((UINT64)1 << (8*cbCounter)) )
74 {
75 return SYMCRYPT_WRONG_DATA_SIZE;
76 }
77
78 if( cbTag < CCM_MIN_TAG_SIZE ||
79 cbTag > CCM_MAX_TAG_SIZE ||
80 (cbTag & 1) == 1 // valid tag lengths are [4, 6, 8, ..., 16]
81 )
82 {
83 return SYMCRYPT_WRONG_TAG_SIZE;
84 }
85
86 return SYMCRYPT_NO_ERROR;
87}
CCM_MAX_TAG_SIZE
#define CCM_MAX_TAG_SIZE
Definition: ccm.c:12
CCM_MIN_TAG_SIZE
#define CCM_MIN_TAG_SIZE
Definition: ccm.c:11
CCM_MAX_NONCE_SIZE
#define CCM_MAX_NONCE_SIZE
Definition: ccm.c:10

Referenced by SymCryptCcmInit().

◆ SymCryptCfbDecrypt()

VOID SYMCRYPT_CALL SymCryptCfbDecrypt ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
SIZE_T  cbShift,
_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 423 of file blockciphermodes.c.

432{
433 SYMCRYPT_ALIGN BYTE buf[2*SYMCRYPT_MAX_BLOCK_SIZE];
434 PBYTE chain = &buf[0];
435 PBYTE tmp = &buf[SYMCRYPT_MAX_BLOCK_SIZE];
436 SIZE_T blockSize;
437
438 blockSize = pBlockCipher->blockSize;
439 SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
440
441 // Force cbShift to either be 1 or blockSize
442 if(cbShift != 1)
443 {
444 cbShift = blockSize;
445 }
446
447 memcpy( chain, pbChainingValue, blockSize );
448 while( cbData >= cbShift )
449 {
450 (*pBlockCipher->encryptFunc)( pExpandedKey, chain, tmp );
451
452 //
453 // First we update the chain block
454 //
455
456 memmove( chain, chain + cbShift, blockSize - cbShift );
457 memcpy( chain + blockSize - cbShift, pbSrc, cbShift );
458
459 //
460 // To obey the read-once rule, we take the ciphertext from the updated chain block.
461 //
462 SymCryptXorBytes( chain + blockSize - cbShift, tmp, pbDst, cbShift );
463
464 pbDst += cbShift;
465 pbSrc += cbShift;
466 cbData -= cbShift;
467 }
468
469 memcpy( pbChainingValue, chain, blockSize );
470}
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881

◆ SymCryptCfbEncrypt()

VOID SYMCRYPT_CALL SymCryptCfbEncrypt ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
SIZE_T  cbShift,
_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 360 of file blockciphermodes.c.

387{
388 SYMCRYPT_ALIGN BYTE buf[2*SYMCRYPT_MAX_BLOCK_SIZE];
389 PBYTE chain = &buf[0];
390 PBYTE tmp = &buf[SYMCRYPT_MAX_BLOCK_SIZE];
391 SIZE_T blockSize;
392
393 blockSize = pBlockCipher->blockSize;
394 SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
395
396 // Force cbShift to either be 1 or blockSize
397 if(cbShift != 1)
398 {
399 cbShift = blockSize;
400 }
401
402 memcpy( chain, pbChainingValue, blockSize );
403 while( cbData >= cbShift )
404 {
405 (*pBlockCipher->encryptFunc)( pExpandedKey, chain, tmp );
406 SymCryptXorBytes( pbSrc, tmp, tmp, cbShift ); // tmp[0..cbShift-1] ^= pbSrc[0..cbShift-1]
407 memcpy( pbDst, tmp, cbShift );
408
409 memmove( chain, chain + cbShift, blockSize - cbShift );
410 memcpy( chain + blockSize - cbShift, tmp, cbShift );
411
412 pbDst += cbShift;
413 pbSrc += cbShift;
414 cbData -= cbShift;
415 }
416
417 memcpy( pbChainingValue, chain, blockSize );
418}

◆ SymCryptChaCha20Crypt()

VOID SYMCRYPT_CALL SymCryptChaCha20Crypt ( _Inout_ PSYMCRYPT_CHACHA20_STATE  pState,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 69 of file chacha20.c.

74{
75 UINT32 blockOffset;
76 SIZE_T nBytes;
77
78 blockOffset = pState->offset & 0x3f;
79
80 // If the offset is in the middle of the block, we first crypt until the end
81 // of the block
82 if( blockOffset != 0 )
83 {
84 if( !pState->keystreamBufferValid )
85 {
86 // Generate a block of key stream
87 SymCryptWipe( &pState->keystream[0], 64 );
88 SymCryptChaCha20CryptBlocks( pState,
89 &pState->keystream[0],
90 &pState->keystream[0],
91 64 );
92 pState->offset -= 64; // Don't update the offset yet
93 }
94
95 nBytes = 64 - blockOffset; // # bytes in buffer starting at offset
96 if( cbData < nBytes )
97 {
98 // We don't use the generated block to the end. The buffer will be valid
99 // at the end as the offset won't advance beyond the block.
100 nBytes = cbData;
101 pState->keystreamBufferValid = TRUE;
102 } else {
103 // We'll use the rest of the generated block. After that the key stream
104 // buffer won't be valid as the offset will advance beyond it.
105 pState->keystreamBufferValid = FALSE;
106 }
107
108 SymCryptXorBytes( pbSrc, &pState->keystream[ blockOffset ], pbDst, nBytes );
109 pbSrc += nBytes;
110 pbDst += nBytes;
111 cbData -= nBytes;
112 pState->offset += nBytes;
113 }
114
115 // Here: pbSrc, pbDst, cbData, and pState->offset all in sync
116 // and either cbData == 0 or offset is at a block boundary
117
118 if( cbData >= 64 )
119 {
120 nBytes = cbData & ~0x3f;
121 SymCryptChaCha20CryptBlocks( pState, pbSrc, pbDst, nBytes );
122 pbSrc += nBytes;
123 pbDst += nBytes;
124 cbData -= nBytes;
125 }
126
127 if( cbData > 0 )
128 {
129 // Generate a block of key stream
130 SymCryptWipe( &pState->keystream[0], 64 );
131 SymCryptChaCha20CryptBlocks( pState,
132 &pState->keystream[0],
133 &pState->keystream[0],
134 64 );
135 pState->offset -= 64; // Don't update the offset yet
136 pState->keystreamBufferValid = TRUE;
137
138 SymCryptXorBytes( pbSrc, &pState->keystream[0], pbDst, cbData );
139 pState->offset += cbData;
140 // The following updates are correct but not needed
141 // pbSrc += cbData;
142 // pbDst += cbData;
143 // cbData -= cbData;
144 }
145}
SymCryptChaCha20CryptBlocks
VOID SYMCRYPT_CALL SymCryptChaCha20CryptBlocks(_Inout_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: chacha20.c:156

Referenced by SymCryptChaCha20Poly1305Decrypt(), SymCryptChaCha20Poly1305Encrypt(), and SymCryptChaCha20Selftest().

◆ SymCryptChaCha20Init()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Init ( _Out_ PSYMCRYPT_CHACHA20_STATE  pState,
_In_reads_(cbKey) PCBYTE  pbKey,
_In_ SIZE_T  cbKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
UINT64  offset 
)

Definition at line 26 of file chacha20.c.

33{
34 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
35
36 if (cbKey != 32)
37 {
38 scError = SYMCRYPT_WRONG_KEY_SIZE;
39 goto cleanup;
40 }
41
42 if (cbNonce != 12)
43 {
44 scError = SYMCRYPT_WRONG_NONCE_SIZE;
45 goto cleanup;
46 }
47
48 SymCryptLsbFirstToUint32( pbKey, &pState->key[0], 8 );
49 SymCryptLsbFirstToUint32( pbNonce, &pState->nonce[0], 3 );
50
51 SymCryptChaCha20SetOffset( pState, offset );
52
53cleanup:
54 return scError;
55}
offset
GLintptr offset
Definition: glext.h:5920
SymCryptLsbFirstToUint32
FORCEINLINE VOID SYMCRYPT_CALL SymCryptLsbFirstToUint32(_In_reads_(4 *cuResult) PCBYTE pbData, _Out_writes_(cuResult) PUINT32 puResult, SIZE_T cuResult)
Definition: sc_lib.h:487
SymCryptChaCha20SetOffset
VOID SYMCRYPT_CALL SymCryptChaCha20SetOffset(_Inout_ PSYMCRYPT_CHACHA20_STATE pState, UINT64 offset)
Definition: chacha20.c:59

Referenced by SymCryptChaCha20Poly1305Decrypt(), SymCryptChaCha20Poly1305Encrypt(), and SymCryptChaCha20Selftest().

◆ SymCryptChaCha20Poly1305Decrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Poly1305Decrypt ( _In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_In_reads_(cbTag) PCBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 138 of file chacha20_poly1305.c.

150{
151 SYMCRYPT_ERROR status = SYMCRYPT_NO_ERROR;
152 SYMCRYPT_CHACHA20_STATE ChaCha20State;
153 SYMCRYPT_POLY1305_STATE Poly1305State;
154 SYMCRYPT_ALIGN BYTE buf[SYMCRYPT_POLY1305_RESULT_SIZE];
155 SYMCRYPT_ALIGN BYTE key[SYMCRYPT_POLY1305_KEY_SIZE];
156
157 if ( !fcbDataLteMaxDataSizeStatic && cbData > CHACHA20_POLY1305_MAX_DATA_SIZE )
158 {
159 status = SYMCRYPT_WRONG_DATA_SIZE;
160 goto cleanup;
161 }
162
163 if ( cbTag != SYMCRYPT_POLY1305_RESULT_SIZE )
164 {
165 status = SYMCRYPT_WRONG_TAG_SIZE;
166 goto cleanup;
167 }
168
169 status = SymCryptChaCha20Init( &ChaCha20State, pbKey, cbKey, pbNonce, cbNonce, 0 );
170 if ( status != SYMCRYPT_NO_ERROR )
171 {
172 goto cleanup;
173 }
174
175 // Generate the first 32 bytes of keystream.
176 SymCryptWipeKnownSize( key, sizeof( key ) );
177 SymCryptChaCha20Crypt( &ChaCha20State, key, key, sizeof( key ) );
178
179 // Create the Poly1305 key using the first 32 bytes of the ChaCha20 keystream.
180 SymCryptPoly1305Init( &Poly1305State, key );
181 SymCryptWipeKnownSize( key, sizeof( key ) );
182
183 // We read the ciphertext back, violating the general rule not to rely on I/O buffers
184 // as they can reside in a different security domain. For ChaCha20Poly1305, like GCM,
185 // this read-back of data is not a problem. An attacker with access to the buffer
186 // will get the ChaCha20 key stream plus the Poly1305 authenticator of a single value.
187 // As Poly1305 is strong even with attacker-controlled data, this is harmless.
188 SymCryptChaCha20Poly1305ComputeTag( &Poly1305State, pbAuthData, cbAuthData,
189 pbSrc, cbData, buf );
190
191 // Validate tag.
192 if (!SymCryptEqual(pbTag, buf, cbTag))
193 {
194 status = SYMCRYPT_AUTHENTICATION_FAILURE;
195 goto cleanup;
196 }
197
198 // Decrypt data if needed.
199 if ( cbData > 0)
200 {
201 // Advance the keystream to counter 1 (offset 64) for data decryption.
202 SymCryptChaCha20SetOffset( &ChaCha20State, 64 );
203 SymCryptChaCha20Crypt( &ChaCha20State, pbSrc, pbDst, cbData );
204 }
205
206cleanup:
207
208 SymCryptWipeKnownSize( &ChaCha20State, sizeof( ChaCha20State ) );
209 SymCryptWipeKnownSize( &Poly1305State, sizeof( Poly1305State ) );
210
211 return status;
212}
CHACHA20_POLY1305_MAX_DATA_SIZE
#define CHACHA20_POLY1305_MAX_DATA_SIZE
Definition: chacha20_poly1305.c:9
fcbDataLteMaxDataSizeStatic
const BOOL fcbDataLteMaxDataSizeStatic
Definition: chacha20_poly1305.c:13
SymCryptChaCha20Poly1305ComputeTag
VOID SYMCRYPT_CALL SymCryptChaCha20Poly1305ComputeTag(_Inout_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE pbTag)
Definition: chacha20_poly1305.c:17
SymCryptChaCha20Crypt
VOID SYMCRYPT_CALL SymCryptChaCha20Crypt(_Inout_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: chacha20.c:69
SymCryptPoly1305Init
VOID SYMCRYPT_CALL SymCryptPoly1305Init(_Out_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE pbKey)
Definition: poly1305.c:33
SYMCRYPT_POLY1305_KEY_SIZE
#define SYMCRYPT_POLY1305_KEY_SIZE
Definition: symcrypt.h:3858
SymCryptChaCha20SetOffset
VOID SYMCRYPT_CALL SymCryptChaCha20SetOffset(_Inout_ PSYMCRYPT_CHACHA20_STATE pState, UINT64 offset)
Definition: chacha20.c:59
SYMCRYPT_POLY1305_RESULT_SIZE
#define SYMCRYPT_POLY1305_RESULT_SIZE
Definition: symcrypt.h:3856
SymCryptChaCha20Init
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Init(_Out_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, UINT64 offset)
Definition: chacha20.c:26
SYMCRYPT_CHACHA20_STATE
SYMCRYPT_CHACHA20_STATE
Definition: symcrypt_internal.h:2126
SYMCRYPT_POLY1305_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_POLY1305_STATE
Definition: symcrypt_internal.h:1697

Referenced by SymCryptChaCha20Poly1305Selftest().

◆ SymCryptChaCha20Poly1305Encrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Poly1305Encrypt ( _In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_Out_writes_(cbTag) PBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 68 of file chacha20_poly1305.c.

80{
81 SYMCRYPT_ERROR status = SYMCRYPT_NO_ERROR;
82 SYMCRYPT_CHACHA20_STATE ChaCha20State;
83 SYMCRYPT_POLY1305_STATE Poly1305State;
84 SYMCRYPT_ALIGN BYTE key[SYMCRYPT_POLY1305_KEY_SIZE];
85
86 if ( !fcbDataLteMaxDataSizeStatic && cbData > CHACHA20_POLY1305_MAX_DATA_SIZE )
87 {
88 status = SYMCRYPT_WRONG_DATA_SIZE;
89 goto cleanup;
90 }
91
92 if ( cbTag != SYMCRYPT_POLY1305_RESULT_SIZE )
93 {
94 status = SYMCRYPT_WRONG_TAG_SIZE;
95 goto cleanup;
96 }
97
98 status = SymCryptChaCha20Init( &ChaCha20State, pbKey, cbKey, pbNonce, cbNonce, 0 );
99 if ( status != SYMCRYPT_NO_ERROR )
100 {
101 goto cleanup;
102 }
103
104 // Generate the first 32 bytes of keystream.
105 SymCryptWipeKnownSize( key, sizeof( key ) );
106 SymCryptChaCha20Crypt( &ChaCha20State, key, key, sizeof ( key ) );
107
108 // Create the Poly1305 key using the first 32 bytes of the ChaCha20 keystream.
109 SymCryptPoly1305Init( &Poly1305State, key );
110 SymCryptWipeKnownSize( key, sizeof( key ) );
111
112 // Encrypt data if needed.
113 if ( cbData > 0 )
114 {
115 // Advance the keystream to counter 1 (offset 64) for data encryption.
116 SymCryptChaCha20SetOffset( &ChaCha20State, 64 );
117 SymCryptChaCha20Crypt( &ChaCha20State, pbSrc, pbDst, cbData );
118 }
119
120 // We read the ciphertext back, violating the general rule not to rely on I/O buffers
121 // as they can reside in a different security domain. For ChaCha20Poly1305, like GCM,
122 // this read-back of data is not a problem. An attacker with access to the buffer
123 // will get the ChaCha20 key stream plus the Poly1305 authenticator of a single value.
124 // As Poly1305 is strong even with attacker-controlled data, this is harmless.
125 SymCryptChaCha20Poly1305ComputeTag( &Poly1305State, pbAuthData, cbAuthData,
126 pbDst, cbData, pbTag );
127cleanup:
128
129 SymCryptWipeKnownSize( &ChaCha20State, sizeof( ChaCha20State ) );
130 SymCryptWipeKnownSize( &Poly1305State, sizeof( Poly1305State ) );
131
132 return status;
133}

Referenced by SymCryptChaCha20Poly1305Selftest().

◆ SymCryptChaCha20Poly1305Selftest()

VOID SYMCRYPT_CALL SymCryptChaCha20Poly1305Selftest ( void  )

Definition at line 223 of file chacha20_poly1305.c.

224{
225 BYTE buf[3 + SYMCRYPT_POLY1305_RESULT_SIZE];
226 SYMCRYPT_ERROR err;
227
228 if ( SymCryptChaCha20Poly1305Encrypt( SymCryptTestKey32, sizeof( SymCryptTestKey32 ),
229 SymCryptTestMsg16, 12,
230 SymCryptTestMsg16, sizeof( SymCryptTestMsg16 ),
231 &SymCryptTestMsg3[0], buf, 3,
232 &buf[3], SYMCRYPT_POLY1305_RESULT_SIZE ) != SYMCRYPT_NO_ERROR )
233 {
234 SymCryptFatal( 'ccp0' );
235 }
236
237 SymCryptInjectError( buf, sizeof( buf ) );
238 if ( memcmp( buf, SymCryptChaCha20Poly1305Result, sizeof( buf ) ) != 0 )
239 {
240 SymCryptFatal( 'ccp1' );
241 }
242
243 // Inject error into the ciphertext or tag.
244 SymCryptInjectError( buf, sizeof( buf ) );
245
246 err = SymCryptChaCha20Poly1305Decrypt( SymCryptTestKey32, sizeof( SymCryptTestKey32 ),
247 SymCryptTestMsg16, 12,
248 SymCryptTestMsg16, sizeof( SymCryptTestMsg16 ),
249 buf, buf, 3,
250 &buf[3], SYMCRYPT_POLY1305_RESULT_SIZE );
251 SymCryptInjectError( buf, 3 );
252
253 if ( err != SYMCRYPT_NO_ERROR || memcmp( buf, SymCryptTestMsg3, 3 ) != 0 )
254 {
255 SymCryptFatal( 'ccp2' );
256 }
257}
SymCryptChaCha20Poly1305Encrypt
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Poly1305Encrypt(_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
Definition: chacha20_poly1305.c:68
SymCryptChaCha20Poly1305Result
static const BYTE SymCryptChaCha20Poly1305Result[3+SYMCRYPT_POLY1305_RESULT_SIZE]
Definition: chacha20_poly1305.c:215
SymCryptChaCha20Poly1305Decrypt
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Poly1305Decrypt(_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
Definition: chacha20_poly1305.c:138
SymCryptTestMsg16
const BYTE SymCryptTestMsg16[16]
Definition: selftest.c:15

◆ SymCryptChaCha20Selftest()

VOID SYMCRYPT_CALL SymCryptChaCha20Selftest ( void  )

Definition at line 249 of file chacha20.c.

250{
251 BYTE buf[3];
252 SYMCRYPT_CHACHA20_STATE state;
253
254 SymCryptChaCha20Init( &state,
255 SymCryptTestKey32, sizeof( SymCryptTestKey32 ),
256 SymCryptTestMsg16, 12,
257 0 );
258
259 SymCryptChaCha20Crypt( &state, SymCryptTestMsg3, buf, sizeof( buf ) );
260
261 SymCryptInjectError( buf, sizeof( buf ) );
262
263 if( memcmp( buf, chacha20KatAnswer, sizeof( buf )) != 0 )
264 {
265 SymCryptFatal( 'Cha2' );
266 }
267}
chacha20KatAnswer
static const BYTE chacha20KatAnswer[3]
Definition: chacha20.c:245
SymCryptChaCha20Crypt
VOID SYMCRYPT_CALL SymCryptChaCha20Crypt(_Inout_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: chacha20.c:69
SymCryptChaCha20Init
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptChaCha20Init(_Out_ PSYMCRYPT_CHACHA20_STATE pState, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, UINT64 offset)
Definition: chacha20.c:26

◆ SymCryptChaCha20SetOffset()

VOID SYMCRYPT_CALL SymCryptChaCha20SetOffset ( _Inout_ PSYMCRYPT_CHACHA20_STATE  pState,
UINT64  offset 
)

Definition at line 59 of file chacha20.c.

62{
63 pState->offset = offset;
64 pState->keystreamBufferValid = FALSE;
65}

Referenced by SymCryptChaCha20Init(), SymCryptChaCha20Poly1305Decrypt(), and SymCryptChaCha20Poly1305Encrypt().

◆ SymCryptCompositeMlKemDecapsulate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemDecapsulate ( _In_ PCSYMCRYPT_COMPOSITE_MLKEMKEY  pkCompositeMlKemkey,
_In_reads_bytes_(cbCiphertext) PCBYTE  pbCiphertext,
SIZE_T  cbCiphertext,
_Out_writes_bytes_(cbAgreedSecret) PBYTE  pbAgreedSecret,
SIZE_T  cbAgreedSecret 
)

◆ SymCryptCompositeMlKemEncapsulate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemEncapsulate ( _In_ PCSYMCRYPT_COMPOSITE_MLKEMKEY  pkCompositeMlKemkey,
_Out_writes_bytes_(cbAgreedSecret) PBYTE  pbAgreedSecret,
SIZE_T  cbAgreedSecret,
_Out_writes_bytes_(cbCiphertext) PBYTE  pbCiphertext,
SIZE_T  cbCiphertext 
)

◆ SymCryptCompositeMlKemkeyAllocate()

PSYMCRYPT_COMPOSITE_MLKEMKEY SYMCRYPT_CALL SymCryptCompositeMlKemkeyAllocate ( SYMCRYPT_COMPOSITE_MLKEM_PARAMS  params)

◆ SymCryptCompositeMlKemkeyFree()

VOID SYMCRYPT_CALL SymCryptCompositeMlKemkeyFree ( _Inout_ PSYMCRYPT_COMPOSITE_MLKEMKEY  pkCompositeMlKemkey)

◆ SymCryptCompositeMlKemkeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemkeyGenerate ( _Inout_ PSYMCRYPT_COMPOSITE_MLKEMKEY  pkCompositeMlKemkey,
UINT32  flags 
)

◆ SymCryptCompositeMlKemkeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemkeyGetValue ( _In_ PCSYMCRYPT_COMPOSITE_MLKEMKEY  pkCompositeMlKemkey,
_Out_writes_bytes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT  compositeMlKemkeyFormat,
UINT32  flags 
)

◆ SymCryptCompositeMlKemkeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemkeySetValue ( _In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT  compositeMlKemkeyFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_COMPOSITE_MLKEMKEY  pkCompositeMlKemkey 
)

◆ SymCryptCompositeMlKemSizeofCiphertextFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemSizeofCiphertextFromParams ( SYMCRYPT_COMPOSITE_MLKEM_PARAMS  params,
_Out_ SIZE_T *  pcbCiphertext 
)

◆ SymCryptCompositeMlKemSizeofKeyFormatFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCompositeMlKemSizeofKeyFormatFromParams ( SYMCRYPT_COMPOSITE_MLKEM_PARAMS  params,
SYMCRYPT_COMPOSITE_MLKEMKEY_FORMAT  compositeMlKemkeyformat,
_Out_ SIZE_T *  pcbKeyFormat 
)

◆ SymCryptCShake128()

VOID SYMCRYPT_CALL SymCryptCShake128 ( _In_reads_(cbFunctionNameString) PCBYTE  pbFunctionNameString,
SIZE_T  cbFunctionNameString,
_In_reads_(cbCustomizationString) PCBYTE  pbCustomizationString,
SIZE_T  cbCustomizationString,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Referenced by SymCryptCShake128Selftest().

◆ SymCryptCShake128Append()

VOID SYMCRYPT_CALL SymCryptCShake128Append ( _Inout_ PSYMCRYPT_CSHAKE128_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptCShake128Extract()

VOID SYMCRYPT_CALL SymCryptCShake128Extract ( _Inout_ PSYMCRYPT_CSHAKE128_STATE  pState,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult,
BOOLEAN  bWipe 
)

◆ SymCryptCShake128Init()

VOID SYMCRYPT_CALL SymCryptCShake128Init ( _Out_ PSYMCRYPT_CSHAKE128_STATE  pState,
_In_reads_(cbFunctionNameString) PCBYTE  pbFunctionNameString,
SIZE_T  cbFunctionNameString,
_In_reads_(cbCustomizationString) PCBYTE  pbCustomizationString,
SIZE_T  cbCustomizationString 
)

◆ SymCryptCShake128Result()

VOID SYMCRYPT_CALL SymCryptCShake128Result ( _Inout_ PSYMCRYPT_CSHAKE128_STATE  pState,
_Out_writes_(SYMCRYPT_CSHAKE128_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptCShake128Selftest()

VOID SYMCRYPT_CALL SymCryptCShake128Selftest ( void  )

Definition at line 146 of file shake.c.

147{
148 BYTE result[SYMCRYPT_CSHAKE128_RESULT_SIZE];
149 static const unsigned char Nstr[] = { 'N' };
150 static const unsigned char Sstr[] = { 'S' };
151
152 SymCryptCShake128( Nstr, sizeof(Nstr),
153 Sstr, sizeof(Sstr),
154 SymCryptTestMsg3, sizeof(SymCryptTestMsg3),
155 result, sizeof(result));
156
157 SymCryptInjectError(result, sizeof(result));
158
159 if (memcmp(result, cshake128KATAnswer, sizeof(result)) != 0)
160 {
161 SymCryptFatal('cshk');
162 }
163}
result
GLuint64EXT * result
Definition: glext.h:11304
cshake128KATAnswer
static const BYTE cshake128KATAnswer[SYMCRYPT_CSHAKE128_RESULT_SIZE]
Definition: shake.c:137
SYMCRYPT_CSHAKE128_RESULT_SIZE
#define SYMCRYPT_CSHAKE128_RESULT_SIZE
Definition: symcrypt.h:2087
SymCryptCShake128
VOID SYMCRYPT_CALL SymCryptCShake128(_In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)

◆ SymCryptCShake128StateCopy()

VOID SYMCRYPT_CALL SymCryptCShake128StateCopy ( _In_ PCSYMCRYPT_CSHAKE128_STATE  pSrc,
_Out_ PSYMCRYPT_CSHAKE128_STATE  pDst 
)

◆ SymCryptCShake256()

VOID SYMCRYPT_CALL SymCryptCShake256 ( _In_reads_(cbFunctionNameString) PCBYTE  pbFunctionNameString,
SIZE_T  cbFunctionNameString,
_In_reads_(cbCustomizationString) PCBYTE  pbCustomizationString,
SIZE_T  cbCustomizationString,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Referenced by SymCryptCShake256Selftest().

◆ SymCryptCShake256Append()

VOID SYMCRYPT_CALL SymCryptCShake256Append ( _Inout_ PSYMCRYPT_CSHAKE256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptCShake256Extract()

VOID SYMCRYPT_CALL SymCryptCShake256Extract ( _Inout_ PSYMCRYPT_CSHAKE256_STATE  pState,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult,
BOOLEAN  bWipe 
)

◆ SymCryptCShake256Init()

VOID SYMCRYPT_CALL SymCryptCShake256Init ( _Out_ PSYMCRYPT_CSHAKE256_STATE  pState,
_In_reads_(cbFunctionNameString) PCBYTE  pbFunctionNameString,
SIZE_T  cbFunctionNameString,
_In_reads_(cbCustomizationString) PCBYTE  pbCustomizationString,
SIZE_T  cbCustomizationString 
)

◆ SymCryptCShake256Result()

VOID SYMCRYPT_CALL SymCryptCShake256Result ( _Inout_ PSYMCRYPT_CSHAKE256_STATE  pState,
_Out_writes_(SYMCRYPT_CSHAKE256_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptCShake256Selftest()

VOID SYMCRYPT_CALL SymCryptCShake256Selftest ( void  )

Definition at line 193 of file shake.c.

194{
195 BYTE result[SYMCRYPT_CSHAKE256_RESULT_SIZE];
196 static const unsigned char Nstr[] = { 'N' };
197 static const unsigned char Sstr[] = { 'S' };
198
199 SymCryptCShake256(Nstr, sizeof(Nstr),
200 Sstr, sizeof(Sstr),
201 SymCryptTestMsg3, sizeof(SymCryptTestMsg3),
202 result, sizeof(result));
203
204 SymCryptInjectError(result, sizeof(result));
205
206 if (memcmp(result, cshake256KATAnswer, sizeof(result)) != 0)
207 {
208 SymCryptFatal('cshk');
209 }
210}
cshake256KATAnswer
static const BYTE cshake256KATAnswer[SYMCRYPT_CSHAKE256_RESULT_SIZE]
Definition: shake.c:184
SYMCRYPT_CSHAKE256_RESULT_SIZE
#define SYMCRYPT_CSHAKE256_RESULT_SIZE
Definition: symcrypt.h:2144
SymCryptCShake256
VOID SYMCRYPT_CALL SymCryptCShake256(_In_reads_(cbFunctionNameString) PCBYTE pbFunctionNameString, SIZE_T cbFunctionNameString, _In_reads_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)

◆ SymCryptCShake256StateCopy()

VOID SYMCRYPT_CALL SymCryptCShake256StateCopy ( _In_ PCSYMCRYPT_CSHAKE256_STATE  pSrc,
_Out_ PSYMCRYPT_CSHAKE256_STATE  pDst 
)

◆ SymCryptCtrMsb64()

VOID SYMCRYPT_CALL SymCryptCtrMsb64 ( _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 300 of file blockciphermodes.c.

308{
309 SYMCRYPT_ALIGN BYTE buf[2 * SYMCRYPT_MAX_BLOCK_SIZE];
310 PBYTE count = &buf[0];
311 PBYTE keystream= &buf[SYMCRYPT_MAX_BLOCK_SIZE];
312 SIZE_T blockSize;
313 PCBYTE pbSrcEnd;
314
315 if( pBlockCipher->ctrMsb64Func != NULL )
316 {
317 //
318 // Use optimized implementation if available
319 //
320 (*pBlockCipher->ctrMsb64Func)( pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
321 return;
322 }
323
324 blockSize = pBlockCipher->blockSize;
325 SYMCRYPT_ASSERT( blockSize <= SYMCRYPT_MAX_BLOCK_SIZE );
326
327 //
328 // Compute the end of the data, rounding the size down to a multiple of the block size.
329 //
330 pbSrcEnd = &pbSrc[ cbData & ~(blockSize - 1) ];
331
332 //
333 // We keep the chaining state in a local buffer to enforce the read-once write-once rule.
334 // It also improves memory locality.
335 //
336 #pragma warning(suppress: 22105)
337 memcpy( count, pbChainingValue, blockSize );
338 while( pbSrc < pbSrcEnd )
339 {
340 SYMCRYPT_ASSERT( pbSrc <= pbSrcEnd - blockSize ); // help PreFast
341 (*pBlockCipher->encryptFunc)( pExpandedKey, count, keystream );
342 SymCryptXorBytes( keystream, pbSrc, pbDst, blockSize );
343
344 //
345 // We only need to increment the last 64 bits of the counter value.
346 //
347 SYMCRYPT_STORE_MSBFIRST64( &count[ blockSize-8 ], 1 + SYMCRYPT_LOAD_MSBFIRST64( &count[ blockSize-8 ] ) );
348
349 pbSrc += blockSize;
350 pbDst += blockSize;
351 }
352
353 memcpy( pbChainingValue, count, blockSize );
354
355 SymCryptWipeKnownSize( buf, sizeof( buf ));
356}
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
_SYMCRYPT_BLOCKCIPHER::ctrMsb64Func
PSYMCRYPT_BLOCKCIPHER_CRYPT_MODE ctrMsb64Func
Definition: symcrypt_internal.h:2003
SYMCRYPT_LOAD_MSBFIRST64
#define SYMCRYPT_LOAD_MSBFIRST64(p)
Definition: symcrypt.h:304
keystream
BYTE keystream[64]
Definition: symcrypt_internal.h:2125

Referenced by SymCryptAesCtrMsb64(), and SymCryptCcmEncryptDecryptPart().

◆ SymCryptDesDecrypt()

VOID SYMCRYPT_CALL SymCryptDesDecrypt ( _In_ PCSYMCRYPT_DES_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 152 of file 3des.c.

156{
157 SymCrypt3DesDecrypt( &pExpandedKey->threeDes, pbSrc, pbDst );
158}

Referenced by decrypt_block_impl(), SymCryptDesSelftest(), and SymCryptDesxDecrypt().

◆ SymCryptDesEncrypt()

VOID SYMCRYPT_CALL SymCryptDesEncrypt ( _In_ PCSYMCRYPT_DES_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 142 of file 3des.c.

146{
147 SymCrypt3DesEncrypt( &pExpandedKey->threeDes, pbSrc, pbDst );
148}

Referenced by encrypt_block_impl(), SymCryptDesSelftest(), and SymCryptDesxEncrypt().

◆ SymCryptDesExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesExpandKey ( _Out_ PSYMCRYPT_DES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 124 of file 3des.c.

128{
129 if( cbKey != 8 )
130 {
131 //
132 // cbKey should be a compile-time constant in most cases,
133 // so this should be optimized away
134 //
135 return SYMCRYPT_WRONG_KEY_SIZE;
136 }
137 return SymCrypt3DesExpandKey( &pExpandedKey->threeDes, pbKey, cbKey );
138}

Referenced by setup_key_impl(), SymCryptDesSelftest(), and SymCryptDesxExpandKey().

◆ SymCryptDesSelftest()

VOID SYMCRYPT_CALL SymCryptDesSelftest ( void  )

Definition at line 624 of file 3des.c.

625{
626 BYTE buf[SYMCRYPT_DES_BLOCK_SIZE];
627 SYMCRYPT_DES_EXPANDED_KEY key;
628
629 if( SymCryptDesExpandKey( &key, SP800_67Key, 8 ) != SYMCRYPT_NO_ERROR )
630 {
631 SymCryptFatal( 'desa' );
632 }
633
634 SymCryptDesEncrypt( &key, des3KnownPlaintext, buf );
635
636 SymCryptInjectError( buf, SYMCRYPT_DES_BLOCK_SIZE );
637
638 if( memcmp( buf, desKnownCiphertext, SYMCRYPT_DES_BLOCK_SIZE ) != 0 )
639 {
640 SymCryptFatal( 'desb' );
641 }
642
643 SymCryptDesDecrypt( &key, desKnownCiphertext, buf );
644
645 SymCryptInjectError( buf, SYMCRYPT_DES_BLOCK_SIZE );
646
647 if( memcmp( buf, des3KnownPlaintext, SYMCRYPT_DES_BLOCK_SIZE ) != 0 )
648 {
649 SymCryptFatal( 'desc' );
650 }
651}
SymCryptDesEncrypt
VOID SYMCRYPT_CALL SymCryptDesEncrypt(_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
Definition: 3des.c:142
SymCryptDesExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesExpandKey(_Out_ PSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: 3des.c:124
desKnownCiphertext
static const BYTE desKnownCiphertext[8]
Definition: 3des.c:617
SymCryptDesDecrypt
VOID SYMCRYPT_CALL SymCryptDesDecrypt(_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
Definition: 3des.c:152
SYMCRYPT_DES_BLOCK_SIZE
#define SYMCRYPT_DES_BLOCK_SIZE
Definition: symcrypt.h:4385
SYMCRYPT_DES_EXPANDED_KEY
SYMCRYPT_DES_EXPANDED_KEY
Definition: symcrypt_internal.h:1796

◆ SymCryptDesSetOddParity()

VOID SYMCRYPT_CALL SymCryptDesSetOddParity ( _Inout_updates_(cbData) PBYTE  pbData,
_In_ SIZE_T  cbData 
)

Definition at line 577 of file 3des.c.

584{
585 SIZE_T i;
586 BYTE b, t;
587 for( i=0; i<cbData; i++ )
588 {
589 // We obey the read-once write-once rule
590 b = *pbData;
591
592 t = b ^ (b>>4); // parity(b) = parity( t & 0xf )
593 t ^= t>>2; // = parity( t & 0x3 )
594 t ^= t>>1; // = parity( t & 0x1 )
595 *pbData++ = b ^ (t&1) ^ 1;
596 }
597}
t
GLdouble GLdouble t
Definition: gl.h:2047
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
b
#define b
Definition: ke_i.h:79

◆ SymCryptDesxDecrypt()

VOID SYMCRYPT_CALL SymCryptDesxDecrypt ( _In_ PCSYMCRYPT_DESX_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_DESX_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_DESX_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 68 of file desx.c.

72{
73 SYMCRYPT_ALIGN BYTE buf[8];
74
75 //
76 // We buffer the result locally to obey the read once/write once rule.
77 //
78 SymCryptXorBytes( pbSrc, pExpandedKey->outputWhitening, buf, 8 );
79 SymCryptDesDecrypt( &pExpandedKey->desKey, buf, buf );
80 SymCryptXorBytes( buf, pExpandedKey->inputWhitening, pbDst, 8 );
81
82 SymCryptWipeKnownSize( buf, sizeof( buf ) );
83}
SymCryptDesDecrypt
VOID SYMCRYPT_CALL SymCryptDesDecrypt(_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
Definition: 3des.c:152

Referenced by SymCryptDesxSelftest().

◆ SymCryptDesxEncrypt()

VOID SYMCRYPT_CALL SymCryptDesxEncrypt ( _In_ PCSYMCRYPT_DESX_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_DESX_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_DESX_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 49 of file desx.c.

53{
54 SYMCRYPT_ALIGN BYTE buf[8];
55
56 //
57 // We buffer the result locally to obey the read once/write once rule.
58 //
59 SymCryptXorBytes( pbSrc, pExpandedKey->inputWhitening, buf, 8 );
60 SymCryptDesEncrypt( &pExpandedKey->desKey, buf, buf );
61 SymCryptXorBytes( buf, pExpandedKey->outputWhitening, pbDst, 8 );
62
63 SymCryptWipeKnownSize( buf, sizeof( buf ) );
64}
SymCryptDesEncrypt
VOID SYMCRYPT_CALL SymCryptDesEncrypt(_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
Definition: 3des.c:142

Referenced by SymCryptDesxSelftest().

◆ SymCryptDesxExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesxExpandKey ( _Out_ PSYMCRYPT_DESX_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 31 of file desx.c.

34{
35 if( cbKey != 24 )
36 {
37 return SYMCRYPT_WRONG_KEY_SIZE;
38 }
39
40 SymCryptDesExpandKey( &pExpandedKey->desKey, pbKey, 8 );
41 memcpy( pExpandedKey->inputWhitening, pbKey+8, 8 );
42 memcpy( pExpandedKey->outputWhitening, pbKey+16, 8 );
43
44 return SYMCRYPT_NO_ERROR;
45}
SymCryptDesExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesExpandKey(_Out_ PSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: 3des.c:124

Referenced by SymCryptDesxSelftest().

◆ SymCryptDesxSelftest()

VOID SYMCRYPT_CALL SymCryptDesxSelftest ( void  )

Definition at line 103 of file desx.c.

104{
105 SYMCRYPT_DESX_EXPANDED_KEY key;
106 BYTE buf[SYMCRYPT_DESX_BLOCK_SIZE];
107
108 if( SymCryptDesxExpandKey( &key, desxKnownKey, sizeof( desxKnownKey )) != SYMCRYPT_NO_ERROR )
109 {
110 SymCryptFatal( 'desx' );
111 }
112
113 SymCryptDesxEncrypt( &key, desxKnownPlaintext, buf );
114
115 SymCryptInjectError( buf, SYMCRYPT_DESX_BLOCK_SIZE );
116
117 if( memcmp( buf, desxKnownCiphertext, SYMCRYPT_DESX_BLOCK_SIZE ) != 0 )
118 {
119 SymCryptFatal( 'desy' );
120 }
121
122 SymCryptDesxDecrypt( &key, desxKnownCiphertext, buf );
123
124 SymCryptInjectError( buf, SYMCRYPT_DESX_BLOCK_SIZE );
125
126 if( memcmp( buf, desxKnownPlaintext, SYMCRYPT_DESX_BLOCK_SIZE ) != 0 )
127 {
128 SymCryptFatal( 'desz' );
129 }
130
131}
SymCryptDesxEncrypt
VOID SYMCRYPT_CALL SymCryptDesxEncrypt(_In_ PCSYMCRYPT_DESX_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DESX_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DESX_BLOCK_SIZE) PBYTE pbDst)
Definition: desx.c:49
desxKnownPlaintext
static const BYTE desxKnownPlaintext[]
Definition: desx.c:92
SymCryptDesxExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesxExpandKey(_Out_ PSYMCRYPT_DESX_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: desx.c:31
desxKnownCiphertext
static const BYTE desxKnownCiphertext[]
Definition: desx.c:96
SymCryptDesxDecrypt
VOID SYMCRYPT_CALL SymCryptDesxDecrypt(_In_ PCSYMCRYPT_DESX_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DESX_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DESX_BLOCK_SIZE) PBYTE pbDst)
Definition: desx.c:68
desxKnownKey
static const BYTE desxKnownKey[24]
Definition: desx.c:86
SYMCRYPT_DESX_BLOCK_SIZE
#define SYMCRYPT_DESX_BLOCK_SIZE
Definition: symcrypt.h:4500
SYMCRYPT_DESX_EXPANDED_KEY
SYMCRYPT_DESX_EXPANDED_KEY
Definition: symcrypt_internal.h:1806

◆ SymCryptDhSecretAgreement()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDhSecretAgreement ( _In_ PCSYMCRYPT_DLKEY  pkPrivate,
_In_ PCSYMCRYPT_DLKEY  pkPublic,
SYMCRYPT_NUMBER_FORMAT  format,
UINT32  flags,
_Out_writes_(cbAgreedSecret) PBYTE  pbAgreedSecret,
SIZE_T  cbAgreedSecret 
)

Definition at line 12 of file dh.c.

19{
20 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
21
22 PBYTE pbScratch = NULL;
23 SIZE_T cbScratch = 0;
24 PBYTE pbScratchInternal = NULL;
25 SIZE_T cbScratchInternal = 0;
26
27 PCSYMCRYPT_DLGROUP pDlgroup = NULL;
28
29 PSYMCRYPT_MODELEMENT peRes = NULL;
30 UINT32 cbModelement = 0;
31
32 UINT32 nBitsOfExp = 0;
33
34 // Make sure that the keys may be used in DH
35 if ( ((pkPrivate->fAlgorithmInfo & SYMCRYPT_FLAG_DLKEY_DH) == 0) ||
36 ((pkPublic->fAlgorithmInfo & SYMCRYPT_FLAG_DLKEY_DH) == 0) )
37 {
38 scError = SYMCRYPT_INVALID_ARGUMENT;
39 goto cleanup;
40 }
41
42 // Make sure we only specify the correct flags and that
43 // there is a private key
44 if ( (flags != 0) || (!pkPrivate->fHasPrivateKey) )
45 {
46 scError = SYMCRYPT_INVALID_ARGUMENT;
47 goto cleanup;
48 }
49
50 // Check that the group is the same for both keys
51 if ( SymCryptDlgroupIsSame( pkPrivate->pDlgroup, pkPublic->pDlgroup ) )
52 {
53 pDlgroup = pkPrivate->pDlgroup;
54 }
55 else
56 {
57 scError = SYMCRYPT_INVALID_ARGUMENT;
58 goto cleanup;
59 }
60
61 // Check the output buffer has the correct size
62 if (cbAgreedSecret != SymCryptDlkeySizeofPublicKey( pkPrivate ))
63 {
64 scError = SYMCRYPT_WRONG_BLOCK_SIZE;
65 goto cleanup;
66 }
67
68 // Objects and scratch space size calculation
69 cbModelement = SymCryptSizeofModElementFromModulus( pDlgroup->pmP );
70 cbScratch = cbModelement +
71 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP( pDlgroup->nDigitsOfP ),
72 SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pDlgroup->nDigitsOfP ));
73
74 // Scratch space allocation
75 pbScratch = SymCryptCallbackAlloc( cbScratch );
76 if ( pbScratch == NULL )
77 {
78 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
79 goto cleanup;
80 }
81
82 // Creating temporary
83 pbScratchInternal = pbScratch;
84 cbScratchInternal = cbScratch;
85 peRes = SymCryptModElementCreate( pbScratchInternal, cbModelement, pDlgroup->pmP );
86 pbScratchInternal += cbModelement;
87 cbScratchInternal -= cbModelement;
88
89 SYMCRYPT_ASSERT( peRes != NULL);
90
91 // Fix the bits of the exponent (the private key might be either mod Q, mod 2^nBitsPriv, or mod P)
92 if (pkPrivate->fPrivateModQ)
93 {
94 nBitsOfExp = pkPrivate->nBitsPriv;
95 }
96 else
97 {
98 nBitsOfExp = pDlgroup->nBitsOfP;
99 }
100
101 // Calculate the secret
102 SymCryptModExp(
103 pDlgroup->pmP,
104 pkPublic->pePublicKey,
105 pkPrivate->piPrivateKey,
106 nBitsOfExp,
107 0, // SC safe
108 peRes,
109 pbScratchInternal,
110 cbScratchInternal );
111
112 // Check if the result is zero
113 if ( SymCryptModElementIsZero( pDlgroup->pmP, peRes ) )
114 {
115 scError = SYMCRYPT_INVALID_BLOB;
116 goto cleanup;
117 }
118
119 // Output the result
120 scError = SymCryptModElementGetValue(
121 pDlgroup->pmP,
122 peRes,
123 pbAgreedSecret,
124 cbAgreedSecret,
125 format,
126 pbScratchInternal,
127 cbScratchInternal );
128 if ( scError != SYMCRYPT_NO_ERROR )
129 {
130 goto cleanup;
131 }
132
133cleanup:
134 if ( pbScratch != NULL )
135 {
136 SymCryptWipe( pbScratch, cbScratch );
137 SymCryptCallbackFree( pbScratch );
138 }
139
140 return scError;
141}
SymCryptDlkeySizeofPublicKey
UINT32 SYMCRYPT_CALL SymCryptDlkeySizeofPublicKey(_In_ PCSYMCRYPT_DLKEY pkDlkey)
Definition: dlkey.c:160
SYMCRYPT_FLAG_DLKEY_DH
#define SYMCRYPT_FLAG_DLKEY_DH
Definition: symcrypt.h:7593
SymCryptDlgroupIsSame
BOOLEAN SYMCRYPT_CALL SymCryptDlgroupIsSame(_In_ PCSYMCRYPT_DLGROUP pDlgroup1, _In_ PCSYMCRYPT_DLGROUP pDlgroup2)
Definition: dlgroup.c:1233
pDlgroup
PCSYMCRYPT_DLGROUP pDlgroup
Definition: symcrypt_internal.h:2872
PSYMCRYPT_MODELEMENT
SYMCRYPT_MODELEMENT * PSYMCRYPT_MODELEMENT
Definition: symcrypt_internal.h:2341
SYMCRYPT_MAX
#define SYMCRYPT_MAX(_a, _b)
Definition: symcrypt_internal.h:311
PCSYMCRYPT_DLGROUP
const SYMCRYPT_DLGROUP * PCSYMCRYPT_DLGROUP
Definition: symcrypt_internal.h:2857
SymCryptSizeofModElementFromModulus
UINT32 SYMCRYPT_CALL SymCryptSizeofModElementFromModulus(PCSYMCRYPT_MODULUS pmMod)
Definition: a_dispatch.c:658
SymCryptModElementIsZero
UINT32 SYMCRYPT_CALL SymCryptModElementIsZero(_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc)
Definition: a_dispatch.c:828
SymCryptModElementGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptModElementGetValue(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: a_dispatch.c:804
SymCryptModElementCreate
PSYMCRYPT_MODELEMENT SYMCRYPT_CALL SymCryptModElementCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, _In_ PCSYMCRYPT_MODULUS pmMod)
Definition: a_dispatch.c:665
SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS
#define SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(_nDigits)
Definition: symcrypt_low_level.h:1505
SymCryptModExp
VOID SYMCRYPT_CALL SymCryptModExp(_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: a_dispatch.c:961
SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP
#define SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP(_nDigits)
Definition: symcrypt_low_level.h:1835

◆ SymCryptDhSecretAgreementSelftest()

VOID SYMCRYPT_CALL SymCryptDhSecretAgreementSelftest ( void  )

Referenced by SymCryptDlkeyGenerate(), and SymCryptDlkeySetValue().

◆ SymCryptDlgroupAllocate()

PSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlgroupAllocate ( UINT32  nBitsOfP,
UINT32  nBitsOfQ 
)

Definition at line 42 of file dlgroup.c.

43{
44 PVOID p;
45 SIZE_T cb;
46 PSYMCRYPT_DLGROUP res = NULL;
47
48 // Invalid parameters
49 if ( (nBitsOfP < SYMCRYPT_DLGROUP_MIN_BITSIZE_P) ||
50 ((nBitsOfQ > 0) && (nBitsOfQ < SYMCRYPT_DLGROUP_MIN_BITSIZE_Q)) ||
51 (nBitsOfP < nBitsOfQ) )
52 {
53 goto cleanup;
54 }
55
56 cb = SymCryptSizeofDlgroupFromBitsizes( nBitsOfP, nBitsOfQ );
57
58 p = SymCryptCallbackAlloc( cb );
59
60 if ( p==NULL )
61 {
62 goto cleanup;
63 }
64
65 res = SymCryptDlgroupCreate( p, cb, nBitsOfP, nBitsOfQ );
66
67cleanup:
68 return res;
69}
SymCryptSizeofDlgroupFromBitsizes
UINT32 SYMCRYPT_CALL SymCryptSizeofDlgroupFromBitsizes(UINT32 nBitsOfP, UINT32 nBitsOfQ)
Definition: dlgroup.c:82
SymCryptDlgroupCreate
PSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlgroupCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nBitsOfP, UINT32 nBitsOfQ)
Definition: dlgroup.c:116
cb
static MonoProfilerRuntimeShutdownBeginCallback cb
Definition: metahost.c:118
SYMCRYPT_DLGROUP_MIN_BITSIZE_P
#define SYMCRYPT_DLGROUP_MIN_BITSIZE_P
Definition: symcrypt_internal.h:2803
nBitsOfP
UINT32 nBitsOfP
Definition: symcrypt_internal.h:2812
nBitsOfQ
UINT32 nBitsOfQ
Definition: symcrypt_internal.h:2817
PSYMCRYPT_DLGROUP
SYMCRYPT_DLGROUP * PSYMCRYPT_DLGROUP
Definition: symcrypt_internal.h:2856
SYMCRYPT_DLGROUP_MIN_BITSIZE_Q
#define SYMCRYPT_DLGROUP_MIN_BITSIZE_Q
Definition: symcrypt_internal.h:2804

◆ SymCryptDlgroupCopy()

VOID SYMCRYPT_CALL SymCryptDlgroupCopy ( _In_ PCSYMCRYPT_DLGROUP  pgSrc,
_Out_ PSYMCRYPT_DLGROUP  pgDst 
)

Definition at line 224 of file dlgroup.c.

227{
228 //
229 // in-place copy is somewhat common...
230 //
231 if( pgSrc != pgDst )
232 {
233 pgDst->cbTotalSize = pgSrc->cbTotalSize;
234 pgDst->fHasPrimeQ = pgSrc->fHasPrimeQ;
235
236 pgDst->nBitsOfP = pgSrc->nBitsOfP;
237 pgDst->cbPrimeP = pgSrc->cbPrimeP;
238 pgDst->nDigitsOfP = pgSrc->nDigitsOfP;
239 pgDst->nMaxBitsOfP = pgSrc->nMaxBitsOfP;
240
241 pgDst->nBitsOfQ = pgSrc->nBitsOfQ;
242 pgDst->cbPrimeQ = pgSrc->cbPrimeQ;
243 pgDst->nDigitsOfQ = pgSrc->nDigitsOfQ;
244 pgDst->nMaxBitsOfQ = pgSrc->nMaxBitsOfQ;
245
246 pgDst->isSafePrimeGroup = pgSrc->isSafePrimeGroup;
247 pgDst->nMinBitsPriv = pgSrc->nMinBitsPriv;
248 pgDst->nDefaultBitsPriv = pgSrc->nDefaultBitsPriv;
249
250 pgDst->nBitsOfSeed = pgSrc->nBitsOfSeed;
251 pgDst->cbSeed = pgSrc->cbSeed;
252
253 pgDst->eFipsStandard = pgSrc->eFipsStandard;
254 pgDst->pHashAlgorithm = pgSrc->pHashAlgorithm;
255 pgDst->dwGenCounter = pgSrc->dwGenCounter;
256 pgDst->bIndexGenG = pgSrc->bIndexGenG;
257 pgDst->pbQ = pgSrc->pbQ;
258
259 memcpy( (PBYTE)pgDst + sizeof(SYMCRYPT_DLGROUP), (PCBYTE)pgSrc + sizeof(SYMCRYPT_DLGROUP), pgSrc->cbTotalSize - sizeof(SYMCRYPT_DLGROUP) );
260 }
261}
SYMCRYPT_DLGROUP
SYMCRYPT_MAGIC_FIELD SYMCRYPT_DLGROUP
Definition: symcrypt_internal.h:2855

◆ SymCryptDlgroupCreate()

PSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlgroupCreate ( _Out_writes_bytes_(cbBuffer) PBYTE  pbBuffer,
SIZE_T  cbBuffer,
UINT32  nBitsOfP,
UINT32  nBitsOfQ 
)

Definition at line 116 of file dlgroup.c.

121{
122 PSYMCRYPT_DLGROUP pDlgroup = NULL;
123
124 UINT32 cbModP;
125 UINT32 cbModQ;
126 UINT32 cbModElement;
127
128 SYMCRYPT_ASSERT( cbBuffer >= SymCryptSizeofDlgroupFromBitsizes( nBitsOfP, nBitsOfQ ) );
129 UNREFERENCED_PARAMETER( cbBuffer ); // only referenced in ASSERTs...
130 SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
131
132 // Invalid parameters
133 if ( (nBitsOfP < SYMCRYPT_DLGROUP_MIN_BITSIZE_P) ||
134 ((nBitsOfQ > 0) && (nBitsOfQ < SYMCRYPT_DLGROUP_MIN_BITSIZE_Q)) ||
135 (nBitsOfP < nBitsOfQ) )
136 {
137 goto cleanup;
138 }
139
140 if ( nBitsOfP == nBitsOfQ )
141 {
142 nBitsOfQ--;
143 }
144
145 pDlgroup = (PSYMCRYPT_DLGROUP) pbBuffer;
146
147 SYMCRYPT_ASSERT( cbBuffer > sizeof(SYMCRYPT_DLGROUP) );
148
149 // DLGROUP parameters
150 pDlgroup->cbTotalSize = SymCryptSizeofDlgroupFromBitsizes( nBitsOfP, nBitsOfQ );
151 pDlgroup->fHasPrimeQ = FALSE;
152
153 pDlgroup->nBitsOfP = nBitsOfP;
154 pDlgroup->cbPrimeP = (nBitsOfP+7)/8;
155 pDlgroup->nDigitsOfP = SymCryptDigitsFromBits( nBitsOfP );
156 pDlgroup->nMaxBitsOfP = nBitsOfP;
157
158 pDlgroup->nBitsOfQ = nBitsOfQ; // 0 value possible
159 pDlgroup->cbPrimeQ = (nBitsOfQ+7)/8; // 0 value possible
160 pDlgroup->nDigitsOfQ = (nBitsOfQ>0)?SymCryptDigitsFromBits( nBitsOfQ ):0; // 0 value possible
161 pDlgroup->nMaxBitsOfQ = (nBitsOfQ==0)?(nBitsOfP-1):nBitsOfQ;
162
163 pDlgroup->isSafePrimeGroup = FALSE;
164 pDlgroup->nMinBitsPriv = 0;
165 pDlgroup->nDefaultBitsPriv = nBitsOfQ; // 0 value possible
166
167 pDlgroup->nBitsOfSeed = nBitsOfQ; // 0 value possible
168 pDlgroup->cbSeed = (pDlgroup->nBitsOfSeed+7)/8; // 0 value possible
169
170 pDlgroup->eFipsStandard = SYMCRYPT_DLGROUP_FIPS_NONE; // This will be set either on generate or import
171 pDlgroup->pHashAlgorithm = NULL; // Like-wise
172 pDlgroup->dwGenCounter = 0; // Like-wise
173 pDlgroup->bIndexGenG = 1; // Default: 1
174
175 // Create SymCrypt objects
176 pbBuffer += sizeof(SYMCRYPT_DLGROUP);
177
178 cbModP = SymCryptSizeofModulusFromDigits( pDlgroup->nDigitsOfP );
179 SYMCRYPT_ASSERT( cbBuffer > sizeof(SYMCRYPT_DLGROUP) + cbModP );
180 pDlgroup->pmP = SymCryptModulusCreate( pbBuffer, cbModP, pDlgroup->nDigitsOfP );
181 pbBuffer += cbModP;
182
183 //
184 // **** Always defer the creation of the Q modulus until the group generation or
185 // import of the modulus. This way it is always the fastest possible even when the caller
186 // specified nBitsOfQ = 0.
187 //
188 if (nBitsOfQ>0)
189 {
190 cbModQ = SymCryptSizeofModulusFromDigits( pDlgroup->nDigitsOfQ );
191 }
192 else
193 {
194 cbModQ = cbModP;
195 }
196 SYMCRYPT_ASSERT( cbBuffer > sizeof(SYMCRYPT_DLGROUP) + cbModP + cbModQ );
197 pDlgroup->pbQ = pbBuffer; // Set the aligned buffer
198 pDlgroup->pmQ = NULL;
199 pbBuffer += cbModQ;
200
201 cbModElement = SymCryptSizeofModElementFromModulus( pDlgroup->pmP );
202 SYMCRYPT_ASSERT( cbBuffer > sizeof(SYMCRYPT_DLGROUP) + cbModP + cbModQ + cbModElement );
203 pDlgroup->peG = SymCryptModElementCreate( pbBuffer, cbModElement, pDlgroup->pmP );
204 pbBuffer += cbModElement;
205
206 pDlgroup->pbSeed = pbBuffer;
207
208 // Setting the magic
209 SYMCRYPT_SET_MAGIC( pDlgroup );
210
211cleanup:
212 return pDlgroup;
213}
SYMCRYPT_ASSERT_ASYM_ALIGNED
#define SYMCRYPT_ASSERT_ASYM_ALIGNED(_p)
Definition: sc_lib.h:1912
cbBuffer
SIZE_T cbBuffer
Definition: sc_lib_mldsa.h:405
cbModElement
UINT32 cbModElement
Definition: symcrypt_internal.h:2451
SymCryptDigitsFromBits
UINT32 SymCryptDigitsFromBits(UINT32 nBits)
Definition: a_dispatch.c:111
SymCryptModulusCreate
PSYMCRYPT_MODULUS SYMCRYPT_CALL SymCryptModulusCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nDigits)
Definition: a_dispatch.c:608
SymCryptSizeofModulusFromDigits
UINT32 SYMCRYPT_CALL SymCryptSizeofModulusFromDigits(UINT32 nDigits)
Definition: a_dispatch.c:601

Referenced by SymCryptDlgroupAllocate().

◆ SymCryptDlgroupFree()

VOID SYMCRYPT_CALL SymCryptDlgroupFree ( _Out_ PSYMCRYPT_DLGROUP  pgObj)

Definition at line 73 of file dlgroup.c.

74{
75 SYMCRYPT_CHECK_MAGIC( pgObj );
76 SymCryptDlgroupWipe( pgObj );
77 SymCryptCallbackFree( pgObj );
78}
SymCryptDlgroupWipe
VOID SYMCRYPT_CALL SymCryptDlgroupWipe(_Out_ PSYMCRYPT_DLGROUP pgDst)
Definition: dlgroup.c:217

◆ SymCryptDlgroupGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGenerate ( _In_ PCSYMCRYPT_HASH  hashAlgorithm,
_In_ SYMCRYPT_DLGROUP_FIPS  fipsStandard,
_Inout_ PSYMCRYPT_DLGROUP  pDlgroup 
)

Definition at line 850 of file dlgroup.c.

854{
855 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
856
857 PBYTE pbScratch = NULL;
858 SIZE_T cbScratch = 0;
859 PBYTE pbScratchInternal = NULL;
860 SIZE_T cbScratchInternal = 0;
861
862 UINT32 fPrimeQFound = 0;
863 UINT32 fPrimePFound = 0;
864
865 // A divisor equal to 2*Q will be needed for the generation of P
866 PSYMCRYPT_DIVISOR pdDivTwoQ = NULL;
867 UINT32 cbDivTwoQ = 0;
868 UINT32 ndDivTwoQ = 0;
869
870 UINT32 nBitsOfP = 0;
871 UINT32 nDigitsOfP = 0;
872 UINT32 nBitsOfQ = 0;
873 UINT32 nDigitsOfQ = 0;
874
875 PCSYMCRYPT_TRIALDIVISION_CONTEXT pTrialDivisionContext = NULL;
876
877 if (fipsStandard == SYMCRYPT_DLGROUP_FIPS_NONE)
878 {
879 fipsStandard = SYMCRYPT_DLGROUP_FIPS_LATEST;
880 }
881
882 // Numbered comments refer to the steps in the FIPS standard
883 // 1. Check that L,N is in the list of acceptable pairs
884 // => Skipped as SymCrypt supports more sizes
885
886 // 2. Check that seedlen >= N
887 // => Skipped as we always have seedlen == N (see below)
888
889
890 // Make sure that a hash algorithm is passed (if needed)
891 // and set the FIPS standard
892 if (fipsStandard == SYMCRYPT_DLGROUP_FIPS_186_2)
893 {
894 if (hashAlgorithm != NULL)
895 {
896 scError = SYMCRYPT_INVALID_ARGUMENT;
897 goto cleanup;
898 }
899
900 pDlgroup->eFipsStandard = fipsStandard;
901 hashAlgorithm = SymCryptSha1Algorithm;
902 }
903 else
904 {
905 if (hashAlgorithm == NULL)
906 {
907 scError = SYMCRYPT_INVALID_ARGUMENT;
908 goto cleanup;
909 }
910
911 pDlgroup->eFipsStandard = fipsStandard;
912 }
913
914 // If during allocation the caller didn't know the size of Q
915 // and set it to 0, pick the default bitsize here
916 // and fix all the zero parameters.
917 if (pDlgroup->nBitsOfQ == 0)
918 {
919 pDlgroup->nBitsOfQ = SymCryptDlgroupCalculateBitsizeOfQ(pDlgroup->nBitsOfP);
920
921 if (pDlgroup->nBitsOfQ > pDlgroup->nMaxBitsOfQ)
922 {
923 scError = SYMCRYPT_FIPS_FAILURE; // This hits when nMaxBitsOfQ = (nBitsOfP-1) <= 160
924 goto cleanup;
925 }
926
927 pDlgroup->cbPrimeQ = (pDlgroup->nBitsOfQ + 7)/8;
928 pDlgroup->nDigitsOfQ = SymCryptDigitsFromBits( pDlgroup->nBitsOfQ );
929 pDlgroup->nDefaultBitsPriv = pDlgroup->nBitsOfQ;
930 pDlgroup->nBitsOfSeed = pDlgroup->nBitsOfQ;
931 pDlgroup->cbSeed = (pDlgroup->nBitsOfSeed+7)/8;
932 }
933
934 // Helper variables
935 nBitsOfP = pDlgroup->nBitsOfP;
936 nDigitsOfP = pDlgroup->nDigitsOfP;
937 nBitsOfQ = pDlgroup->nBitsOfQ;
938 nDigitsOfQ = pDlgroup->nDigitsOfQ;
939
940 // Create the modulus Q
941 pDlgroup->pmQ = SymCryptModulusCreate( pDlgroup->pbQ, SymCryptSizeofModulusFromDigits( nDigitsOfQ ), nDigitsOfQ );
942
943 // Conditions on the hash function output size
944 // The second condition is needed for generation of G in SymCrypt
945 // since it allows even very small sizes of P.
946 if ( (8*((UINT32)SymCryptHashResultSize( hashAlgorithm )) < nBitsOfQ) ||
947 (8*((UINT32)SymCryptHashResultSize( hashAlgorithm )) > nBitsOfP) )
948 {
949 scError = SYMCRYPT_INVALID_ARGUMENT;
950 goto cleanup;
951 }
952
953 // Set the group's hash algorithm
954 pDlgroup->pHashAlgorithm = hashAlgorithm;
955
956 // Calculate sizes for the 2*Q divisor
957 ndDivTwoQ = SymCryptDigitsFromBits(nBitsOfQ + 1);
958 cbDivTwoQ = SymCryptSizeofDivisorFromDigits(ndDivTwoQ);
959
960 // Scratch space
961 //
962 // From symcrypt_internal.h we have:
963 // - sizeof results are upper bounded by 2^19
964 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
965 // - SymCryptDlgroupScratchSpace_FIPS is bounded by 2^28.
966 //
967 // Thus the following calculation does not overflow cbScratch.
968 //
969 cbScratch = SymCryptDlgroupScratchSpace_FIPS( nBitsOfP, nBitsOfQ, hashAlgorithm );
970 pbScratch = SymCryptCallbackAlloc(cbScratch);
971 if (pbScratch==NULL)
972 {
973 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
974 goto cleanup;
975 }
976
977 // Create a divisor 2*Q (needed for the generation of P)
978 pdDivTwoQ = SymCryptDivisorCreate( pbScratch, cbDivTwoQ, ndDivTwoQ );
979 pbScratchInternal = pbScratch + cbDivTwoQ;
980 cbScratchInternal = cbScratch - cbDivTwoQ;
981
982 // Create a trial division context for both P and Q
983 pTrialDivisionContext = SymCryptCreateTrialDivisionContext( pDlgroup->nDigitsOfP );
984 if (pTrialDivisionContext == NULL)
985 {
986 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
987 goto cleanup;
988 }
989
990 do
991 {
992 do
993 {
994 // Fill the seed buffer in the DLGroup with seedlen bits
995 scError = SymCryptCallbackRandom( pDlgroup->pbSeed, pDlgroup->cbSeed );
996 if (scError != SYMCRYPT_NO_ERROR)
997 {
998 goto cleanup;
999 }
1000
1001 // Zero-out the top bits if needed
1002 if ((pDlgroup->nBitsOfSeed)%8 != 0)
1003 {
1004 pDlgroup->pbSeed[0] &= ((BYTE)0xff >> (8 - (pDlgroup->nBitsOfSeed)%8));
1005 }
1006
1007 scError = SymCryptDlgroupGeneratePrimeQ_FIPS(
1008 pDlgroup,
1009 pTrialDivisionContext,
1010 &fPrimeQFound,
1011 SymCryptIntFromModulus(pDlgroup->pmQ),
1012 pdDivTwoQ,
1013 pbScratchInternal,
1014 cbScratchInternal );
1015 if (scError != SYMCRYPT_NO_ERROR)
1016 {
1017 goto cleanup;
1018 }
1019 }
1020 while (fPrimeQFound == 0);
1021
1022 scError = SymCryptDlgroupGeneratePrimeP_FIPS(
1023 pDlgroup,
1024 pdDivTwoQ,
1025 4*nBitsOfP - 1,
1026 pTrialDivisionContext,
1027 &fPrimePFound,
1028 SymCryptIntFromModulus(pDlgroup->pmP),
1029 &(pDlgroup->dwGenCounter),
1030 pbScratchInternal,
1031 cbScratchInternal );
1032 if (scError != SYMCRYPT_NO_ERROR)
1033 {
1034 goto cleanup;
1035 }
1036 }
1037 while (fPrimePFound == 0);
1038
1039 // Specify that we have a Q
1040 pDlgroup->fHasPrimeQ = TRUE;
1041
1042 // Convert both of P and Q to moduli
1043 // IntToModulus requirement:
1044 // Both P,Q > 0 since they are primes
1045 SymCryptIntToModulus(
1046 SymCryptIntFromModulus( pDlgroup->pmP ),
1047 pDlgroup->pmP,
1048 1000*nBitsOfP, // Average operations
1049 SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
1050 pbScratch,
1051 cbScratch );
1052
1053 SymCryptIntToModulus(
1054 SymCryptIntFromModulus( pDlgroup->pmQ ),
1055 pDlgroup->pmQ,
1056 1000*nBitsOfP, // Average operations
1057 SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
1058 pbScratch,
1059 cbScratch );
1060
1061 // Generate G
1062 scError = SymCryptDlgroupGenerateGenG_FIPS( pDlgroup, pDlgroup->peG, pbScratch, cbScratch );
1063 if (scError != SYMCRYPT_NO_ERROR)
1064 {
1065 goto cleanup;
1066 }
1067
1068cleanup:
1069 if (pTrialDivisionContext!=NULL)
1070 {
1071 SymCryptFreeTrialDivisionContext( pTrialDivisionContext );
1072 }
1073
1074 if (pbScratch!=NULL)
1075 {
1076 SymCryptWipe( pbScratch, cbScratch );
1077 SymCryptCallbackFree( pbScratch );
1078 }
1079 return scError;
1080}
SymCryptDlgroupCalculateBitsizeOfQ
UINT32 SYMCRYPT_CALL SymCryptDlgroupCalculateBitsizeOfQ(UINT32 nBitsOfP)
Definition: dlgroup.c:28
SymCryptDlgroupGeneratePrimeP_FIPS
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGeneratePrimeP_FIPS(_In_ PSYMCRYPT_DLGROUP pDlgroup, _In_ PSYMCRYPT_DIVISOR pdDivTwoQ, _In_ UINT32 dwMaxCounter, _In_ PCSYMCRYPT_TRIALDIVISION_CONTEXT pTrialDivisionContext, _Out_ PUINT32 pfPrimePFound, _Out_ PSYMCRYPT_INT piP, _Out_ PUINT32 pdwCounter, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: dlgroup.c:421
SymCryptDlgroupGeneratePrimeQ_FIPS
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGeneratePrimeQ_FIPS(_In_ PSYMCRYPT_DLGROUP pDlgroup, _In_ PCSYMCRYPT_TRIALDIVISION_CONTEXT pTrialDivisionContext, _Out_ PUINT32 pfPrimeQFound, _Out_ PSYMCRYPT_INT piQ, _Out_ PSYMCRYPT_DIVISOR pdDivTwoQ, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: dlgroup.c:268
SymCryptDlgroupScratchSpace_FIPS
UINT32 SYMCRYPT_CALL SymCryptDlgroupScratchSpace_FIPS(UINT32 nBitsOfP, UINT32 nBitsOfQ, PCSYMCRYPT_HASH pHashAlgorithm)
Definition: dlgroup.c:805
SymCryptDlgroupGenerateGenG_FIPS
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGenerateGenG_FIPS(_In_ PSYMCRYPT_DLGROUP pDlgroup, _Out_ PSYMCRYPT_MODELEMENT peG, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: dlgroup.c:639
SymCryptCallbackRandom
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCallbackRandom(BYTE *buf, SIZE_T size)
Definition: implglue.c:56
_SYMCRYPT_TRIALDIVISION_CONTEXT
Definition: symcrypt_internal.h:2786
SymCryptHashResultSize
SIZE_T SYMCRYPT_CALL SymCryptHashResultSize(_In_ PCSYMCRYPT_HASH pHash)
Definition: hash.c:132
SymCryptSha1Algorithm
const PCSYMCRYPT_HASH SymCryptSha1Algorithm
Definition: sha1.c:29
SYMCRYPT_DLGROUP_FIPS_LATEST
#define SYMCRYPT_DLGROUP_FIPS_LATEST
Definition: symcrypt.h:7872
nDigitsOfQ
UINT32 nDigitsOfQ
Definition: symcrypt_internal.h:2819
PSYMCRYPT_DIVISOR
SYMCRYPT_DIVISOR * PSYMCRYPT_DIVISOR
Definition: symcrypt_internal.h:2331
nDigitsOfP
UINT32 nDigitsOfP
Definition: symcrypt_internal.h:2814
SymCryptCreateTrialDivisionContext
PCSYMCRYPT_TRIALDIVISION_CONTEXT SYMCRYPT_CALL SymCryptCreateTrialDivisionContext(UINT32 nDigits)
Definition: a_dispatch.c:1007
SymCryptSizeofDivisorFromDigits
UINT32 SYMCRYPT_CALL SymCryptSizeofDivisorFromDigits(UINT32 nDigits)
Definition: a_dispatch.c:512
SYMCRYPT_FLAG_MODULUS_PRIME
#define SYMCRYPT_FLAG_MODULUS_PRIME
Definition: symcrypt_low_level.h:1503
SymCryptDivisorCreate
PSYMCRYPT_DIVISOR SYMCRYPT_CALL SymCryptDivisorCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nDigits)
Definition: a_dispatch.c:519
SymCryptIntFromModulus
PSYMCRYPT_INT SYMCRYPT_CALL SymCryptIntFromModulus(_In_ PSYMCRYPT_MODULUS pmSrc)
Definition: a_dispatch.c:720
SymCryptFreeTrialDivisionContext
VOID SYMCRYPT_CALL SymCryptFreeTrialDivisionContext(PCSYMCRYPT_TRIALDIVISION_CONTEXT pContext)
Definition: a_dispatch.c:1025
SymCryptIntToModulus
VOID SYMCRYPT_CALL SymCryptIntToModulus(_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_MODULUS pmDst, UINT32 averageOperations, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:727
SYMCRYPT_FLAG_DATA_PUBLIC
#define SYMCRYPT_FLAG_DATA_PUBLIC
Definition: symcrypt_low_level.h:100

◆ SymCryptDlgroupGetSizes()

VOID SYMCRYPT_CALL SymCryptDlgroupGetSizes ( _In_ PCSYMCRYPT_DLGROUP  pDlgroup,
_Out_ SIZE_T *  pcbPrimeP,
_Out_ SIZE_T *  pcbPrimeQ,
_Out_ SIZE_T *  pcbGenG,
_Out_ SIZE_T *  pcbSeed 
)

Definition at line 1261 of file dlgroup.c.

1267{
1268 if (pcbPrimeP!=NULL)
1269 {
1270 *pcbPrimeP = pDlgroup->cbPrimeP;
1271 }
1272
1273 if (pcbPrimeQ!=NULL)
1274 {
1275 *pcbPrimeQ = pDlgroup->cbPrimeQ; // This returns 0 if the group does not have a prime Q
1276 }
1277
1278 if (pcbGenG!=NULL)
1279 {
1280 *pcbGenG = pDlgroup->cbPrimeP;
1281 }
1282
1283 if (pcbSeed!=NULL)
1284 {
1285 *pcbSeed = pDlgroup->cbSeed; // This returns 0 if the group does not have a prime Q
1286 }
1287}

◆ SymCryptDlgroupGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGetValue ( _In_ PCSYMCRYPT_DLGROUP  pDlgroup,
_Out_writes_bytes_(cbPrimeP) PBYTE  pbPrimeP,
SIZE_T  cbPrimeP,
_Out_writes_bytes_(cbPrimeQ) PBYTE  pbPrimeQ,
SIZE_T  cbPrimeQ,
_Out_writes_bytes_(cbGenG) PBYTE  pbGenG,
SIZE_T  cbGenG,
SYMCRYPT_NUMBER_FORMAT  numFormat,
_Out_ PCSYMCRYPT_HASH *  ppHashAlgorithm,
_Out_writes_bytes_(cbSeed) PBYTE  pbSeed,
SIZE_T  cbSeed,
_Out_ PUINT32  pGenCounter 
)

Definition at line 1901 of file dlgroup.c.

1914{
1915 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1916
1917 PBYTE pbScratch = NULL;
1918 SIZE_T cbScratch = 0;
1919
1920 if ( ((pbPrimeP==NULL)&&(cbPrimeP>0)) ||
1921 ((pbPrimeQ==NULL)&&(cbPrimeQ>0)) ||
1922 ((pbGenG==NULL)&&(cbGenG>0)) ||
1923 ((pbSeed==NULL)&&(cbSeed>0)) ||
1924 ((pbSeed!=NULL)&&(cbSeed!=pDlgroup->cbSeed)) )
1925 {
1926 scError = SYMCRYPT_INVALID_ARGUMENT;
1927 goto cleanup;
1928 }
1929
1930 if ((pbPrimeQ!=NULL) && (!pDlgroup->fHasPrimeQ))
1931 {
1932 scError = SYMCRYPT_INVALID_BLOB;
1933 goto cleanup;
1934 }
1935
1936 if (pbPrimeP!=NULL)
1937 {
1938 scError = SymCryptIntGetValue(
1939 SymCryptIntFromModulus(pDlgroup->pmP),
1940 pbPrimeP,
1941 cbPrimeP,
1942 numFormat );
1943 if (scError!=SYMCRYPT_NO_ERROR)
1944 {
1945 goto cleanup;
1946 }
1947 }
1948
1949 if (pbPrimeQ!=NULL)
1950 {
1951 scError = SymCryptIntGetValue(
1952 SymCryptIntFromModulus(pDlgroup->pmQ),
1953 pbPrimeQ,
1954 cbPrimeQ,
1955 numFormat );
1956 if (scError!=SYMCRYPT_NO_ERROR)
1957 {
1958 goto cleanup;
1959 }
1960 }
1961
1962 if (pbGenG!=NULL)
1963 {
1964 // Scratch space is needed
1965 cbScratch = SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pDlgroup->nDigitsOfP);
1966 pbScratch = SymCryptCallbackAlloc( cbScratch );
1967 if (pbScratch==NULL)
1968 {
1969 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1970 goto cleanup;
1971 }
1972
1973 scError = SymCryptModElementGetValue(
1974 pDlgroup->pmP,
1975 pDlgroup->peG,
1976 pbGenG,
1977 cbGenG,
1978 numFormat,
1979 pbScratch,
1980 cbScratch );
1981 if (scError!=SYMCRYPT_NO_ERROR)
1982 {
1983 goto cleanup;
1984 }
1985 }
1986
1987 if (ppHashAlgorithm!=NULL)
1988 {
1989 if (pDlgroup->eFipsStandard == SYMCRYPT_DLGROUP_FIPS_186_2)
1990 {
1991 *ppHashAlgorithm = NULL;
1992 }
1993 else
1994 {
1995 *ppHashAlgorithm = pDlgroup->pHashAlgorithm;
1996 }
1997 }
1998
1999 if (pbSeed!=NULL && pDlgroup->pbSeed!=NULL)
2000 {
2001 memcpy( pbSeed, pDlgroup->pbSeed, pDlgroup->cbSeed);
2002 }
2003
2004 if (pGenCounter!=NULL)
2005 {
2006 *pGenCounter = pDlgroup->dwGenCounter;
2007 }
2008
2009cleanup:
2010 if (pbScratch!=NULL)
2011 {
2012 SymCryptWipe( pbScratch, cbScratch );
2013 SymCryptCallbackFree( pbScratch );
2014 }
2015 return scError;
2016}
cbPrimeP
UINT32 cbPrimeP
Definition: symcrypt_internal.h:2813
cbPrimeQ
UINT32 cbPrimeQ
Definition: symcrypt_internal.h:2818
cbSeed
UINT32 cbSeed
Definition: symcrypt_internal.h:2831
pbSeed
PBYTE pbSeed
Definition: symcrypt_internal.h:2846
SymCryptIntGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptIntGetValue(_In_ PCSYMCRYPT_INT piSrc, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, SYMCRYPT_NUMBER_FORMAT format)
Definition: a_dispatch.c:259

◆ SymCryptDlgroupIsSame()

BOOLEAN SYMCRYPT_CALL SymCryptDlgroupIsSame ( _In_ PCSYMCRYPT_DLGROUP  pDlgroup1,
_In_ PCSYMCRYPT_DLGROUP  pDlgroup2 
)

Definition at line 1233 of file dlgroup.c.

1236{
1237 BOOLEAN fIsSameGroup = FALSE;
1238
1239 if ( pDlgroup1 == pDlgroup2 )
1240 {
1241 fIsSameGroup = TRUE;
1242 goto cleanup;
1243 }
1244
1245 if ( (pDlgroup1->nBitsOfP != pDlgroup2->nBitsOfP) ||
1246 (pDlgroup1->nDigitsOfP != pDlgroup2->nDigitsOfP) ||
1247 !SymCryptIntIsEqual ( SymCryptIntFromModulus(pDlgroup1->pmP), SymCryptIntFromModulus(pDlgroup2->pmP) ) ||
1248 !SymCryptModElementIsEqual ( pDlgroup1->pmP, pDlgroup1->peG, pDlgroup2->peG ))
1249 {
1250 goto cleanup;
1251 }
1252
1253 fIsSameGroup = TRUE;
1254
1255cleanup:
1256 return fIsSameGroup;
1257}
SymCryptModElementIsEqual
UINT32 SYMCRYPT_CALL SymCryptModElementIsEqual(_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc1, _In_ PCSYMCRYPT_MODELEMENT peSrc2)
Definition: a_dispatch.c:818
SymCryptIntIsEqual
UINT32 SYMCRYPT_CALL SymCryptIntIsEqual(_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2)
Definition: a_dispatch.c:433

Referenced by SymCryptDhSecretAgreement().

◆ SymCryptDlgroupSetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupSetValue ( _In_reads_bytes_(cbPrimeP) PCBYTE  pbPrimeP,
SIZE_T  cbPrimeP,
_In_reads_bytes_(cbPrimeQ) PCBYTE  pbPrimeQ,
SIZE_T  cbPrimeQ,
_In_reads_bytes_(cbGenG) PCBYTE  pbGenG,
SIZE_T  cbGenG,
SYMCRYPT_NUMBER_FORMAT  numFormat,
_In_opt_ PCSYMCRYPT_HASH  pHashAlgorithm,
_In_reads_bytes_(cbSeed) PCBYTE  pbSeed,
SIZE_T  cbSeed,
UINT32  genCounter,
SYMCRYPT_DLGROUP_FIPS  fipsStandard,
_Inout_ PSYMCRYPT_DLGROUP  pDlgroup 
)

Definition at line 1410 of file dlgroup.c.

1424{
1425 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1426
1427 PBYTE pbScratch = NULL;
1428 SIZE_T cbScratch = 0;
1429 SIZE_T cbScratchVerify = 0;
1430
1431 PSYMCRYPT_INT piTemp = NULL;
1432
1433 UINT32 nBitsOfP = 0;
1434 UINT32 nBitsOfQ = 0;
1435
1436 UINT32 nMaxDigitsOfP = SymCryptDigitsFromBits(pDlgroup->nMaxBitsOfP);
1437 UINT32 nMaxDigitsOfQ = SymCryptDigitsFromBits(pDlgroup->nMaxBitsOfQ);
1438
1439 PCSYMCRYPT_TRIALDIVISION_CONTEXT pTrialDivisionContext = NULL;
1440
1441 // Make sure that the inputs make sense
1442 if ( (pbPrimeP==NULL) || (cbPrimeP==0) || // Prime P is needed
1443 ((pbGenG==NULL)&&(cbGenG>0)) ||
1444 ((pbPrimeQ==NULL)&&(cbPrimeQ>0)) ||
1445 ((pbGenG==NULL)&&(pbPrimeQ==NULL)) || // We can't have both Q and G missing
1446 ((pbSeed==NULL)&&(cbSeed>0)) )
1447 {
1448 scError = SYMCRYPT_INVALID_ARGUMENT;
1449 goto cleanup;
1450 }
1451
1452 // FIPS 186-4 verification is needed
1453 if (fipsStandard != SYMCRYPT_DLGROUP_FIPS_NONE)
1454 {
1455 // Make sure we have what we need
1456 if ((pbPrimeQ == NULL)||
1457 (cbPrimeQ == 0) ||
1458 (pbSeed == NULL) ||
1459 (cbSeed == 0) ||
1460 ((fipsStandard == SYMCRYPT_DLGROUP_FIPS_186_2) && (pHashAlgorithm != NULL)) ||
1461 ((fipsStandard != SYMCRYPT_DLGROUP_FIPS_186_2) && (pHashAlgorithm == NULL)) )
1462 {
1463 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
1464 goto cleanup;
1465 }
1466 }
1467
1468 // Set the hashAlgorithm
1469 if ( (fipsStandard == SYMCRYPT_DLGROUP_FIPS_186_2) ||
1470 ((pHashAlgorithm==NULL) && (pbGenG == NULL)) )
1471 {
1472 // This hits either when:
1473 // - The FIPS standard is 186-2
1474 // - When we don't specify an algorithm or generator G (thus we need a hash algorithm to generate it
1475 // ourselves)
1476 pDlgroup->pHashAlgorithm = SymCryptSha1Algorithm;
1477 }
1478 else
1479 {
1480 pDlgroup->pHashAlgorithm = pHashAlgorithm;
1481 }
1482
1483 if ( (fipsStandard != SYMCRYPT_DLGROUP_FIPS_NONE) || (pbGenG == NULL))
1484 {
1485 // The following is the scratch space for generation / verification
1486 // Notice that we take the maximum size possible so it can get relatively big.
1487 // Also, we will need some additional space for the computed parameters:
1488 // computedP, computedQ, and computedG.
1489 cbScratchVerify = SymCryptDlgroupScratchSpace_FIPS( pDlgroup->nMaxBitsOfP, pDlgroup->nMaxBitsOfQ, pDlgroup->pHashAlgorithm ) +
1490 SYMCRYPT_MAX( SymCryptSizeofIntFromDigits(nMaxDigitsOfP),
1491 SYMCRYPT_MAX( SymCryptSizeofIntFromDigits(nMaxDigitsOfQ),
1492 2*SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS(nMaxDigitsOfP)));
1493 }
1494
1495 // Scratch space
1496 //
1497 // From symcrypt_internal.h we have:
1498 // - sizeof results are upper bounded by 2^19
1499 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
1500 // - SymCryptDlgroupScratchSpace_FIPS is bounded by 2^28.
1501 //
1502 // Thus the following calculation does not overflow cbScratch.
1503 //
1504 cbScratch = SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(nMaxDigitsOfP) +
1505 SYMCRYPT_MAX( SymCryptSizeofIntFromDigits(nMaxDigitsOfQ),
1506 SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_MODULUS(nMaxDigitsOfP) ),
1507 cbScratchVerify );
1508 pbScratch = SymCryptCallbackAlloc( cbScratch );
1509 if (pbScratch==NULL)
1510 {
1511 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1512 goto cleanup;
1513 }
1514
1515 //
1516 // Prime P
1517 //
1518
1519 // Set the prime P (this will fail if the number cannot fit in the object)
1520 scError = SymCryptIntSetValue( pbPrimeP, cbPrimeP, numFormat, SymCryptIntFromModulus(pDlgroup->pmP) );
1521 if (scError!=SYMCRYPT_NO_ERROR)
1522 {
1523 goto cleanup;
1524 }
1525
1526 // Check the bitsize of value
1527 nBitsOfP = SymCryptIntBitsizeOfValue(SymCryptIntFromModulus(pDlgroup->pmP));
1528 if ( nBitsOfP > pDlgroup->nMaxBitsOfP)
1529 {
1530 scError = SYMCRYPT_INVALID_ARGUMENT;
1531 goto cleanup;
1532 }
1533
1534 if (nBitsOfP < SYMCRYPT_DLGROUP_MIN_BITSIZE_P)
1535 {
1536 scError = SYMCRYPT_WRONG_KEY_SIZE;
1537 goto cleanup;
1538 }
1539
1540 // FIPS 186-4 verification is needed
1541 // Check genCounter is not too big
1542 if (fipsStandard != SYMCRYPT_DLGROUP_FIPS_NONE &&
1543 genCounter > 4*nBitsOfP-1 )
1544 {
1545 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
1546 goto cleanup;
1547 }
1548
1549 if( (SymCryptIntGetValueLsbits32( SymCryptIntFromModulus( pDlgroup->pmP ) ) & 1) == 0 )
1550 {
1551 // P is even, when it should be a prime of at least 32 bits
1552 scError = SYMCRYPT_INVALID_ARGUMENT;
1553 goto cleanup;
1554 }
1555
1556 // Set the bitsize and bytesize of the value
1557 pDlgroup->nBitsOfP = nBitsOfP;
1558 pDlgroup->cbPrimeP = (nBitsOfP + 7)/8;
1559
1560 // IntToModulus requirement:
1561 // nBitsOfP >= SYMCRYPT_DLGROUP_MIN_BITSIZE_P --> P > 0
1562 SymCryptIntToModulus(
1563 SymCryptIntFromModulus( pDlgroup->pmP ),
1564 pDlgroup->pmP,
1565 1000*nBitsOfP, // Average operations
1566 SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
1567 pbScratch,
1568 cbScratch );
1569
1570 //
1571 // Prime Q
1572 //
1573
1574 // Wiping of previous (optional) parameters related to Q
1575 if (pDlgroup->pmQ != NULL)
1576 {
1577 SymCryptModulusWipe( pDlgroup->pmQ );
1578 }
1579 if (pDlgroup->cbSeed != 0)
1580 {
1581 SymCryptWipe( pDlgroup->pbSeed, pDlgroup->cbSeed);
1582 }
1583
1584 if (pbPrimeQ != NULL)
1585 {
1586 // Create an integer piTemp
1587 piTemp = SymCryptIntCreate( pbScratch, cbScratch, nMaxDigitsOfQ );
1588
1589 // Set the prime Q (this will fail if the number cannot fit in the object)
1590 scError = SymCryptIntSetValue( pbPrimeQ, cbPrimeQ, numFormat, piTemp );
1591 if (scError!=SYMCRYPT_NO_ERROR)
1592 {
1593 goto cleanup;
1594 }
1595
1596 // Check the bitsize of value
1597 nBitsOfQ = SymCryptIntBitsizeOfValue(piTemp);
1598 if ( nBitsOfQ > pDlgroup->nMaxBitsOfQ)
1599 {
1600 scError = SYMCRYPT_INVALID_ARGUMENT;
1601 goto cleanup;
1602 }
1603
1604 if (nBitsOfQ < SYMCRYPT_DLGROUP_MIN_BITSIZE_Q)
1605 {
1606 scError = SYMCRYPT_WRONG_KEY_SIZE;
1607 goto cleanup;
1608 }
1609
1610 if( (SymCryptIntGetValueLsbits32( piTemp ) & 1) == 0 )
1611 {
1612 // Some of our modinv algorithms require odd inputs, and Q should be odd as it
1613 // claims to be a prime.
1614 // (Q can't be 2 as it must be at least 32 bits long.)
1615 scError = SYMCRYPT_INVALID_ARGUMENT;
1616 goto cleanup;
1617 }
1618
1619 // Set the bitsize and bytesize of the value
1620 pDlgroup->nBitsOfQ = nBitsOfQ;
1621 pDlgroup->cbPrimeQ = (nBitsOfQ + 7)/8;
1622 pDlgroup->nDigitsOfQ = SymCryptDigitsFromBits(nBitsOfQ);
1623 pDlgroup->nDefaultBitsPriv = nBitsOfQ;
1624 pDlgroup->nBitsOfSeed = nBitsOfQ;
1625 pDlgroup->cbSeed = (nBitsOfQ+7)/8;
1626
1627 // Create the modulus Q
1628 pDlgroup->pmQ = SymCryptModulusCreate( pDlgroup->pbQ, SymCryptSizeofModulusFromDigits( pDlgroup->nDigitsOfQ ), pDlgroup->nDigitsOfQ );
1629
1630 // Set the prime Q
1631 scError = SymCryptIntCopyMixedSize( piTemp, SymCryptIntFromModulus(pDlgroup->pmQ) );
1632 if (scError!=SYMCRYPT_NO_ERROR)
1633 {
1634 goto cleanup;
1635 }
1636
1637 // piTemp is not needed any more so we are free to re-use the scratch space
1638
1639 // IntToModulus requirement:
1640 // nBitsOfQ >= SYMCRYPT_DLGROUP_MIN_BITSIZE_Q --> Q > 0
1641 SymCryptIntToModulus(
1642 SymCryptIntFromModulus( pDlgroup->pmQ ),
1643 pDlgroup->pmQ,
1644 1000*nBitsOfP, // Average operations
1645 SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
1646 pbScratch,
1647 cbScratch );
1648
1649 pDlgroup->fHasPrimeQ = TRUE;
1650 }
1651 else
1652 {
1653 // Clear all info about Q
1654 pDlgroup->cbPrimeQ = 0;
1655 pDlgroup->nBitsOfQ = 0;
1656 pDlgroup->nDigitsOfQ = 0;
1657
1658 pDlgroup->nDefaultBitsPriv = 0;
1659 pDlgroup->nBitsOfSeed = 0;
1660 pDlgroup->cbSeed = 0;
1661
1662 pDlgroup->pmQ = NULL;
1663 pDlgroup->fHasPrimeQ = FALSE;
1664 }
1665
1666 pDlgroup->isSafePrimeGroup = FALSE;
1667 pDlgroup->nMinBitsPriv = 0;
1668
1669 //
1670 // Provided Generator G
1671 //
1672 if (pbGenG != NULL)
1673 {
1674 // Set the generator G (this will fail if the number cannot fit in the object)
1675 scError = SymCryptModElementSetValue( pbGenG, cbGenG, numFormat, pDlgroup->pmP, pDlgroup->peG, pbScratch, cbScratch );
1676 if (scError!=SYMCRYPT_NO_ERROR)
1677 {
1678 goto cleanup;
1679 }
1680
1681 scError = SymCryptDlgroupAutoCompleteNamedSafePrimeGroup( pDlgroup, pbScratch, cbScratch );
1682 if (scError!=SYMCRYPT_NO_ERROR)
1683 {
1684 goto cleanup;
1685 }
1686
1687 // Successfully detected, validated and autocompleted named safe-prime group
1688 if (pDlgroup->isSafePrimeGroup)
1689 {
1690 goto cleanup;
1691 }
1692 }
1693
1694 //
1695 // Verification data (this has to be done before possibly generating G)
1696 //
1697
1698 // Set the FIPS standard
1699 pDlgroup->eFipsStandard = fipsStandard;
1700
1701 // Set the seed
1702 if (pbSeed != NULL)
1703 {
1704 if (cbSeed != pDlgroup->cbSeed)
1705 {
1706 scError = SYMCRYPT_INVALID_ARGUMENT;
1707 goto cleanup;
1708 }
1709 memcpy( pDlgroup->pbSeed, pbSeed, cbSeed );
1710 }
1711
1712 // Set the genCounter
1713 pDlgroup->dwGenCounter = genCounter;
1714
1715 //
1716 // Generator G
1717 //
1718
1719 if (pbGenG == NULL)
1720 {
1721 // Let's generate G here since none was given
1722
1723 // // We need Q (check at the beginning)
1724 // if (pbPrimeQ==NULL)
1725 // {
1726 // scError = SYMCRYPT_INVALID_ARGUMENT;
1727 // goto cleanup;
1728 // }
1729
1730 // If no seed was given let's generate our own
1731 if (pbSeed==NULL)
1732 {
1733 SymCryptCallbackRandom(pDlgroup->pbSeed, pDlgroup->cbSeed);
1734 }
1735
1736 scError = SymCryptDlgroupGenerateGenG_FIPS(
1737 pDlgroup,
1738 pDlgroup->peG,
1739 pbScratch,
1740 cbScratch );
1741 if (scError!=SYMCRYPT_NO_ERROR)
1742 {
1743 goto cleanup;
1744 }
1745 }
1746
1747
1748 // Verification
1749 if (fipsStandard != SYMCRYPT_DLGROUP_FIPS_NONE)
1750 {
1751 // Verification
1752 PBYTE pbScratchInternal = pbScratch;
1753 SIZE_T cbScratchInternal = cbScratch;
1754
1755 UINT32 ndDivTwoQ = 0;
1756 UINT32 cbDivTwoQ = 0;
1757 PSYMCRYPT_DIVISOR pdDivTwoQ = NULL;
1758
1759 UINT32 cbComputed = 0;
1760 PSYMCRYPT_INT piComputed = NULL;
1761 UINT32 fPrimeComputed = 0;
1762 UINT32 dwComputedCounter = 0;
1763
1764 PSYMCRYPT_MODELEMENT peComputed = NULL;
1765 PSYMCRYPT_MODELEMENT peOne = NULL;
1766
1767 // Step 3: Acceptable pairs of L,N => skipped
1768
1769 // Step 6: nBitsOfSeed < nBitsOfQ => skipped
1770
1771 // Create the divisor object
1772 ndDivTwoQ = SymCryptDigitsFromBits(pDlgroup->nBitsOfQ + 1);
1773 cbDivTwoQ = SymCryptSizeofDivisorFromDigits( ndDivTwoQ );
1774 pdDivTwoQ = SymCryptDivisorCreate( pbScratchInternal, cbDivTwoQ, ndDivTwoQ );
1775 pbScratchInternal += cbDivTwoQ;
1776 cbScratchInternal -= cbDivTwoQ;
1777
1778 // Create the temporary integer of size Q
1779 cbComputed = SymCryptSizeofIntFromDigits( pDlgroup->nDigitsOfQ );
1780 piComputed = SymCryptIntCreate( pbScratchInternal, cbComputed, pDlgroup->nDigitsOfQ );
1781 pbScratchInternal += cbComputed;
1782 cbScratchInternal -= cbComputed;
1783
1784 // Create a trial division context for both P and Q
1785 pTrialDivisionContext = SymCryptCreateTrialDivisionContext( pDlgroup->nDigitsOfP );
1786 if (pTrialDivisionContext == NULL)
1787 {
1788 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1789 goto cleanup;
1790 }
1791
1792 // Steps 8,9: Check if computed_q is prime and equal to q
1793 scError = SymCryptDlgroupGeneratePrimeQ_FIPS(
1794 pDlgroup,
1795 pTrialDivisionContext,
1796 &fPrimeComputed,
1797 piComputed,
1798 pdDivTwoQ,
1799 pbScratchInternal,
1800 cbScratchInternal );
1801 if (scError != SYMCRYPT_NO_ERROR)
1802 {
1803 scError = SYMCRYPT_AUTHENTICATION_FAILURE; // Overwrite any possible error
1804 goto cleanup;
1805 }
1806
1807 if ((!fPrimeComputed)||(!SymCryptIntIsEqual( piComputed, SymCryptIntFromModulus(pDlgroup->pmQ))))
1808 {
1809 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
1810 goto cleanup;
1811 }
1812
1813 // Create the temporary integer of size P
1814 pbScratchInternal -= cbComputed;
1815 cbScratchInternal += cbComputed;
1816 cbComputed = SymCryptSizeofIntFromDigits( pDlgroup->nDigitsOfP );
1817 piComputed = SymCryptIntCreate( pbScratchInternal, cbComputed, pDlgroup->nDigitsOfP );
1818 pbScratchInternal += cbComputed;
1819 cbScratchInternal -= cbComputed;
1820
1821 // Steps 10-14: Check if computed_p is prime and equal to p
1822 scError = SymCryptDlgroupGeneratePrimeP_FIPS(
1823 pDlgroup,
1824 pdDivTwoQ,
1825 pDlgroup->dwGenCounter, // Go up to this
1826 pTrialDivisionContext,
1827 &fPrimeComputed,
1828 piComputed,
1829 &dwComputedCounter,
1830 pbScratchInternal,
1831 cbScratchInternal );
1832 if (scError != SYMCRYPT_NO_ERROR)
1833 {
1834 scError = SYMCRYPT_AUTHENTICATION_FAILURE; // Overwrite any possible error
1835 goto cleanup;
1836 }
1837
1838 if ((!fPrimeComputed)||(dwComputedCounter!=pDlgroup->dwGenCounter)||(!SymCryptIntIsEqual( piComputed, SymCryptIntFromModulus(pDlgroup->pmP))))
1839 {
1840 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
1841 goto cleanup;
1842 }
1843
1844 // Validation of G
1845
1846 // Create the temporary modelement mod P
1847 pbScratchInternal -= cbComputed;
1848 cbScratchInternal += cbComputed;
1849 cbComputed = SymCryptSizeofModElementFromModulus( pDlgroup->pmP );
1850 peOne = SymCryptModElementCreate( pbScratchInternal, cbComputed, pDlgroup->pmP );
1851 pbScratchInternal += cbComputed;
1852 cbScratchInternal -= cbComputed;
1853 peComputed = SymCryptModElementCreate( pbScratchInternal, cbComputed, pDlgroup->pmP );
1854 pbScratchInternal += cbComputed;
1855 cbScratchInternal -= cbComputed;
1856
1857 // Step 2: Verify that 2<= G <= p-1
1858 SymCryptModElementSetValueUint32( 1, pDlgroup->pmP, peOne, pbScratchInternal, cbScratchInternal ); // Set the temporary to 1
1859
1860 if ((SymCryptModElementIsZero(pDlgroup->pmP, pDlgroup->peG)) || (SymCryptModElementIsEqual(pDlgroup->pmP, pDlgroup->peG, peOne)))
1861 {
1862 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
1863 goto cleanup;
1864 }
1865
1866 // Step 3: Verify that G^Q == 1
1867 SymCryptModExp(
1868 pDlgroup->pmP,
1869 pDlgroup->peG,
1870 SymCryptIntFromModulus(pDlgroup->pmQ),
1871 nBitsOfQ,
1872 SYMCRYPT_FLAG_DATA_PUBLIC,
1873 peComputed,
1874 pbScratchInternal,
1875 cbScratchInternal );
1876
1877 if (!SymCryptModElementIsEqual(pDlgroup->pmP, peComputed, peOne))
1878 {
1879 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
1880 goto cleanup;
1881 }
1882
1883 }
1884
1885cleanup:
1886 if (pTrialDivisionContext!=NULL)
1887 {
1888 SymCryptFreeTrialDivisionContext( pTrialDivisionContext );
1889 }
1890
1891 if (pbScratch!=NULL)
1892 {
1893 SymCryptWipe( pbScratch, cbScratch );
1894 SymCryptCallbackFree( pbScratch );
1895 }
1896 return scError;
1897}
SymCryptDlgroupAutoCompleteNamedSafePrimeGroup
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupAutoCompleteNamedSafePrimeGroup(_Inout_ PSYMCRYPT_DLGROUP pDlgroup, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: dlgroup.c:1291
PSYMCRYPT_INT
SYMCRYPT_INT * PSYMCRYPT_INT
Definition: symcrypt_internal.h:2326
pHashAlgorithm
PCSYMCRYPT_HASH pHashAlgorithm
Definition: symcrypt_internal.h:2835
SymCryptIntGetValueLsbits32
UINT32 SYMCRYPT_CALL SymCryptIntGetValueLsbits32(_In_ PCSYMCRYPT_INT piSrc)
Definition: a_dispatch.c:270
SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_MODULUS
#define SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_MODULUS(_nDigits)
Definition: symcrypt_low_level.h:1461
SymCryptIntCopyMixedSize
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptIntCopyMixedSize(_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:214
SymCryptModElementSetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptModElementSetValue(_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT format, PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:781
SymCryptModulusWipe
VOID SYMCRYPT_CALL SymCryptModulusWipe(_Out_ PSYMCRYPT_MODULUS pmObj)
Definition: a_dispatch.c:618
SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS
#define SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS(_bitsize)
Definition: symcrypt_low_level.h:451
SymCryptIntSetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptIntSetValue(_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT format, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:248
SymCryptModElementSetValueUint32
VOID SYMCRYPT_CALL SymCryptModElementSetValueUint32(UINT32 value, _In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:908
SymCryptIntBitsizeOfValue
UINT32 SYMCRYPT_CALL SymCryptIntBitsizeOfValue(_In_ PCSYMCRYPT_INT piSrc)
Definition: a_dispatch.c:223
SymCryptSizeofIntFromDigits
UINT32 SYMCRYPT_CALL SymCryptSizeofIntFromDigits(UINT32 nDigits)
Definition: a_dispatch.c:134
SymCryptIntCreate
PSYMCRYPT_INT SYMCRYPT_CALL SymCryptIntCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 nDigits)
Definition: a_dispatch.c:141

◆ SymCryptDlgroupSetValueSafePrime()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupSetValueSafePrime ( SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE  dhSafePrimeType,
_Inout_ PSYMCRYPT_DLGROUP  pDlgroup 
)

Definition at line 1084 of file dlgroup.c.

1087{
1088 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1089
1090 PBYTE pbScratch = NULL;
1091 SIZE_T cbScratch = 0;
1092
1093 PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS safePrimeParams = NULL;
1094
1095 UINT32 i;
1096 UINT32 nBitsOfQ;
1097
1098 // Given we know nBitsOfP = nBitsOfQ+1 for all safe-prime groups, this specifies a tight bound when selecting a group
1099 UINT32 nMaxBitsOfP = SYMCRYPT_MIN(pDlgroup->nMaxBitsOfP, pDlgroup->nMaxBitsOfQ+1);
1100 UINT32 nMaxDigitsOfP;
1101
1102 if ( dhSafePrimeType == SYMCRYPT_DLGROUP_DH_SAFEPRIMETYPE_NONE )
1103 {
1104 scError = SYMCRYPT_INVALID_ARGUMENT;
1105 goto cleanup;
1106 }
1107
1108 // Iterate through all named safe-prime groups until we find one which fits the requested parameters
1109 // We can definitely do something smarter here, but we have only 10 values to check so do the dumb thing for now
1110 // Relies on the fact the SymCryptNamedSafePrimeGroups is ordered from largest to smallest
1111 for ( i=0; i<SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT; i++ )
1112 {
1113 if ( SymCryptNamedSafePrimeGroups[i]->eDhSafePrimeType == dhSafePrimeType &&
1114 SymCryptNamedSafePrimeGroups[i]->nBitsOfP <= nMaxBitsOfP )
1115 {
1116 safePrimeParams = SymCryptNamedSafePrimeGroups[i];
1117 break;
1118 }
1119 }
1120
1121 if (safePrimeParams == NULL)
1122 {
1123 scError = SYMCRYPT_INVALID_ARGUMENT;
1124 goto cleanup;
1125 }
1126
1127 nMaxDigitsOfP = SymCryptDigitsFromBits(safePrimeParams->nBitsOfP);
1128
1129 // Scratch space
1130 //
1131 // From symcrypt_internal.h we have:
1132 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
1133 //
1134 // Thus the following calculation does not overflow cbScratch.
1135 //
1136 cbScratch = SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_MODULUS(nMaxDigitsOfP),
1137 SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(nMaxDigitsOfP) );
1138 pbScratch = SymCryptCallbackAlloc( cbScratch );
1139 if (pbScratch==NULL)
1140 {
1141 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1142 goto cleanup;
1143 }
1144
1145 // Set fields marking the Dlgroup as being a named safe-prime group
1146 pDlgroup->isSafePrimeGroup = TRUE;
1147 pDlgroup->eFipsStandard = SYMCRYPT_DLGROUP_FIPS_NONE;
1148 pDlgroup->nMinBitsPriv = safePrimeParams->nMinBitsPriv;
1149 pDlgroup->nDefaultBitsPriv = safePrimeParams->nDefaultBitsPriv;
1150
1151 // Ensure that fields which don't apply to named safe-prime groups are cleared
1152 pDlgroup->pHashAlgorithm = NULL;
1153 pDlgroup->dwGenCounter = 0;
1154
1155 pDlgroup->nBitsOfSeed = 0;
1156 pDlgroup->pbSeed = NULL;
1157 pDlgroup->cbSeed = 0;
1158
1159 // Set the bitsize and bytesize of P
1160 pDlgroup->nBitsOfP = safePrimeParams->nBitsOfP;
1161 pDlgroup->cbPrimeP = (safePrimeParams->nBitsOfP + 7)/ 8;
1162 pDlgroup->nDigitsOfP = SymCryptDigitsFromBits(safePrimeParams->nBitsOfP);
1163
1164 // Set the bitsize and bytesize of Q
1165 nBitsOfQ = pDlgroup->nBitsOfP - 1;
1166 pDlgroup->nBitsOfQ = nBitsOfQ;
1167 pDlgroup->cbPrimeQ = (nBitsOfQ + 7)/8;
1168 pDlgroup->nDigitsOfQ = SymCryptDigitsFromBits(nBitsOfQ);
1169 pDlgroup->fHasPrimeQ = TRUE;
1170
1171 //
1172 // Prime P
1173 //
1174
1175 // Recreate the modulus P
1176 // (this will set nDigits in the modulus object appropriately, which is necessary for use of SymCryptIntShr1 below)
1177 pDlgroup->pmP = SymCryptModulusCreate( (PBYTE) pDlgroup->pmP, SymCryptSizeofModulusFromDigits( pDlgroup->nDigitsOfP ), pDlgroup->nDigitsOfP );
1178
1179 scError = SymCryptIntSetValue( safePrimeParams->pcbPrimeP, pDlgroup->cbPrimeP, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, SymCryptIntFromModulus(pDlgroup->pmP) );
1180 if (scError!=SYMCRYPT_NO_ERROR)
1181 {
1182 goto cleanup;
1183 }
1184
1185 // IntToModulus requirement:
1186 // nBitsOfP >= SYMCRYPT_DLGROUP_MIN_BITSIZE_P --> P > 0
1187 SymCryptIntToModulus(
1188 SymCryptIntFromModulus( pDlgroup->pmP ),
1189 pDlgroup->pmP,
1190 1000*pDlgroup->nBitsOfP, // Average operations
1191 SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
1192 pbScratch,
1193 cbScratch );
1194
1195 //
1196 // Prime Q
1197 //
1198
1199 // Create the modulus Q
1200 pDlgroup->pmQ = SymCryptModulusCreate( pDlgroup->pbQ, SymCryptSizeofModulusFromDigits( pDlgroup->nDigitsOfQ ), pDlgroup->nDigitsOfQ );
1201
1202 // Q = floor( P / 2 )
1203 SymCryptIntShr1( 0, SymCryptIntFromModulus(pDlgroup->pmP), SymCryptIntFromModulus(pDlgroup->pmQ) );
1204
1205 // IntToModulus requirement:
1206 // nBitsOfQ >= SYMCRYPT_DLGROUP_MIN_BITSIZE_Q --> Q > 0
1207 SymCryptIntToModulus(
1208 SymCryptIntFromModulus( pDlgroup->pmQ ),
1209 pDlgroup->pmQ,
1210 1000*nBitsOfQ, // Average operations
1211 SYMCRYPT_FLAG_DATA_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
1212 pbScratch,
1213 cbScratch );
1214
1215 //
1216 // Generator G
1217 //
1218
1219 // G to 2
1220 SymCryptModElementSetValueUint32( 2, pDlgroup->pmP, pDlgroup->peG, pbScratch, cbScratch );
1221
1222cleanup:
1223 if (pbScratch!=NULL)
1224 {
1225 SymCryptWipe( pbScratch, cbScratch );
1226 SymCryptCallbackFree( pbScratch );
1227 }
1228 return scError;
1229}
SymCryptNamedSafePrimeGroups
const PCSYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS SymCryptNamedSafePrimeGroups[SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT]
Definition: dl_internal_groups.c:910
SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT
#define SYMCRYPT_DH_SAFEPRIME_GROUP_COUNT
Definition: sc_lib.h:3788
_SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS
Definition: sc_lib.h:3756
_SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS::nMinBitsPriv
UINT32 nMinBitsPriv
Definition: sc_lib.h:3762
_SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS::pcbPrimeP
PCBYTE pcbPrimeP
Definition: sc_lib.h:3759
_SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS::nDefaultBitsPriv
UINT32 nDefaultBitsPriv
Definition: sc_lib.h:3764
_SYMCRYPT_DLGROUP_DH_SAFEPRIME_PARAMS::nBitsOfP
UINT32 nBitsOfP
Definition: sc_lib.h:3761
SYMCRYPT_MIN
#define SYMCRYPT_MIN(_a, _b)
Definition: symcrypt_internal.h:312
nMaxBitsOfP
UINT32 nMaxBitsOfP
Definition: symcrypt_internal.h:2815
SymCryptIntShr1
VOID SYMCRYPT_CALL SymCryptIntShr1(UINT32 highestBit, _In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:374

◆ SymCryptDlgroupWipe()

VOID SYMCRYPT_CALL SymCryptDlgroupWipe ( _Out_ PSYMCRYPT_DLGROUP  pgDst)

Definition at line 217 of file dlgroup.c.

218{
219 SymCryptWipe( (PBYTE) pgDst, pgDst->cbTotalSize );
220}

Referenced by SymCryptDlgroupFree().

◆ SymCryptDlkeyAllocate()

PSYMCRYPT_DLKEY SYMCRYPT_CALL SymCryptDlkeyAllocate ( _In_ PCSYMCRYPT_DLGROUP  pDlgroup)

Definition at line 12 of file dlkey.c.

13{
14 PVOID p;
15 SIZE_T cb;
16 PSYMCRYPT_DLKEY res = NULL;
17
18 cb = SymCryptSizeofDlkeyFromDlgroup( pDlgroup );
19
20 p = SymCryptCallbackAlloc( cb );
21
22 if ( p==NULL )
23 {
24 goto cleanup;
25 }
26
27 res = SymCryptDlkeyCreate( p, cb, pDlgroup );
28
29cleanup:
30 return res;
31}
SymCryptSizeofDlkeyFromDlgroup
UINT32 SYMCRYPT_CALL SymCryptSizeofDlkeyFromDlgroup(_In_ PCSYMCRYPT_DLGROUP pDlgroup)
Definition: dlkey.c:44
SymCryptDlkeyCreate
PSYMCRYPT_DLKEY SYMCRYPT_CALL SymCryptDlkeyCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, _In_ PCSYMCRYPT_DLGROUP pDlgroup)
Definition: dlkey.c:52
PSYMCRYPT_DLKEY
SYMCRYPT_DLKEY * PSYMCRYPT_DLKEY
Definition: symcrypt_internal.h:2884

◆ SymCryptDlkeyCopy()

VOID SYMCRYPT_CALL SymCryptDlkeyCopy ( _In_ PCSYMCRYPT_DLKEY  pkSrc,
_Out_ PSYMCRYPT_DLKEY  pkDst 
)

Definition at line 109 of file dlkey.c.

112{
113 PCSYMCRYPT_DLGROUP pDlgroup = pkSrc->pDlgroup;
114
115 //
116 // in-place copy is somewhat common...
117 //
118 if( pkSrc != pkDst )
119 {
120 pkDst->fAlgorithmInfo = pkSrc->fAlgorithmInfo;
121 pkDst->fHasPrivateKey = pkSrc->fHasPrivateKey;
122 pkDst->fPrivateModQ = pkSrc->fPrivateModQ;
123 pkDst->nBitsPriv = pkSrc->nBitsPriv;
124
125 // Copy the public key
126 SymCryptModElementCopy( pDlgroup->pmP, pkSrc->pePublicKey, pkDst->pePublicKey );
127
128 // Copy the private key
129 SymCryptIntCopy( pkSrc->piPrivateKey, pkDst->piPrivateKey );
130 }
131}
SymCryptIntCopy
VOID SYMCRYPT_CALL SymCryptIntCopy(_In_ PCSYMCRYPT_INT piSrc, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:161
SymCryptModElementCopy
VOID SymCryptModElementCopy(_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst)
Definition: a_dispatch.c:683

◆ SymCryptDlkeyCreate()

PSYMCRYPT_DLKEY SYMCRYPT_CALL SymCryptDlkeyCreate ( _Out_writes_bytes_(cbBuffer) PBYTE  pbBuffer,
SIZE_T  cbBuffer,
_In_ PCSYMCRYPT_DLGROUP  pDlgroup 
)

Definition at line 52 of file dlkey.c.

56{
57 PSYMCRYPT_DLKEY pkRes = NULL;
58 UINT32 cbModElement = SymCryptSizeofModElementFromModulus( pDlgroup->pmP );
59
60 SYMCRYPT_ASSERT( cbBuffer >= SymCryptSizeofDlkeyFromDlgroup( pDlgroup ) );
61 SYMCRYPT_ASSERT( cbBuffer >= sizeof(SYMCRYPT_DLKEY) + cbModElement );
62 UNREFERENCED_PARAMETER( cbBuffer ); // only referenced in above ASSERTs...
63 SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
64
65 pkRes = (PSYMCRYPT_DLKEY) pbBuffer;
66
67 // DLKEY parameters
68 pkRes->fAlgorithmInfo = 0;
69 pkRes->pDlgroup = pDlgroup;
70 pkRes->fHasPrivateKey = FALSE;
71 pkRes->fPrivateModQ = FALSE; // This will be properly set during generate or setvalue
72 pkRes->nBitsPriv = pDlgroup->nDefaultBitsPriv;
73
74 // Create SymCrypt objects
75 pbBuffer += sizeof(SYMCRYPT_DLKEY);
76
77 pkRes->pePublicKey = SymCryptModElementCreate( pbBuffer, cbModElement, pDlgroup->pmP );
78 if (pkRes->pePublicKey == NULL)
79 {
80 goto cleanup;
81 }
82 pbBuffer += cbModElement;
83
84 //
85 // **** Always defer the creation of the private key until the key generation or
86 // set value.
87 //
88 // In place of the pbPrivate pointer store the pointer to the allocated buffer.
89 //
90 pkRes->pbPrivate = pbBuffer;
91 pkRes->piPrivateKey = NULL;
92
93 // Setting the magic
94 SYMCRYPT_SET_MAGIC( pkRes );
95
96cleanup:
97 return pkRes;
98}
SYMCRYPT_DLKEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_DLKEY
Definition: symcrypt_internal.h:2883

Referenced by SymCryptDlkeyAllocate().

◆ SymCryptDlkeyExtendKeyUsage()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyExtendKeyUsage ( _Inout_ PSYMCRYPT_DLKEY  pkDlkey,
UINT32  flags 
)

Definition at line 901 of file dlkey.c.

904{
905 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
906
907 // Ensure caller has specified what algorithm(s) the key will be used with
908 UINT32 algorithmFlags = SYMCRYPT_FLAG_DLKEY_DSA | SYMCRYPT_FLAG_DLKEY_DH;
909
910 if ( ( ( flags & ~algorithmFlags ) != 0 ) ||
911 ( ( flags & algorithmFlags ) == 0) )
912 {
913 scError = SYMCRYPT_INVALID_ARGUMENT;
914 goto cleanup;
915 }
916
917 pkDlkey->fAlgorithmInfo |= flags;
918
919cleanup:
920 return scError;
921}
SYMCRYPT_FLAG_DLKEY_DSA
#define SYMCRYPT_FLAG_DLKEY_DSA
Definition: symcrypt.h:7592

◆ SymCryptDlkeyFree()

VOID SYMCRYPT_CALL SymCryptDlkeyFree ( _Out_ PSYMCRYPT_DLKEY  pkObj)

Definition at line 35 of file dlkey.c.

36{
37 SYMCRYPT_CHECK_MAGIC( pkObj );
38 SymCryptDlkeyWipe( pkObj );
39 SymCryptCallbackFree( pkObj );
40}
SymCryptDlkeyWipe
VOID SYMCRYPT_CALL SymCryptDlkeyWipe(_Out_ PSYMCRYPT_DLKEY pkDst)
Definition: dlkey.c:102

◆ SymCryptDlkeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyGenerate ( _In_ UINT32  flags,
_Inout_ PSYMCRYPT_DLKEY  pkDlkey 
)

Definition at line 283 of file dlkey.c.

286{
287 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
288 PBYTE pbScratch = NULL;
289 SIZE_T cbScratch = 0;
290 PBYTE pbScratchInternal = NULL;
291 SIZE_T cbScratchInternal = 0;
292
293 PCSYMCRYPT_DLGROUP pDlgroup = pkDlkey->pDlgroup;
294
295 PSYMCRYPT_MODELEMENT pePrivateKey = NULL;
296 UINT32 cbPrivateKey = 0;
297
298 PSYMCRYPT_MODULUS pmPriv = NULL;
299 UINT32 nDigitsPriv = 0;
300 UINT32 nBitsPriv = 0;
301 UINT32 fFlagsForModSetRandom = 0;
302
303 BOOLEAN useModSetRandom = TRUE;
304 UINT32 nBytesPriv = 0;
305 UINT32 dwShiftBits;
306 BYTE privMask;
307 UINT32 cntr;
308
309 PSYMCRYPT_MODELEMENT peTmp = NULL;
310 UINT32 cbModElement = SymCryptSizeofModElementFromModulus( pDlgroup->pmP );
311
312 // Ensure caller has specified what algorithm(s) the key will be used with
313 UINT32 algorithmFlags = SYMCRYPT_FLAG_DLKEY_DSA | SYMCRYPT_FLAG_DLKEY_DH;
314 // Make sure only allowed flags are specified
315 UINT32 allowedFlags = SYMCRYPT_FLAG_DLKEY_GEN_MODP | SYMCRYPT_FLAG_KEY_NO_FIPS | algorithmFlags;
316
317 if ( ( ( flags & ~allowedFlags ) != 0 ) ||
318 ( ( flags & algorithmFlags ) == 0 ) )
319 {
320 scError = SYMCRYPT_INVALID_ARGUMENT;
321 goto cleanup;
322 }
323
324 // Extra sanity checks when running with FIPS
325 // Either Dlgroup is named SafePrime group and key is for DH,
326 // or Dlgroup is not named SafePrime group and key is for DSA
327 if ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
328 ( (pDlgroup->isSafePrimeGroup && (flags & SYMCRYPT_FLAG_DLKEY_DSA)) ||
329 (!(pDlgroup->isSafePrimeGroup) && (flags & SYMCRYPT_FLAG_DLKEY_DH)) ) )
330 {
331 scError = SYMCRYPT_INVALID_ARGUMENT;
332 goto cleanup;
333 }
334
335 pkDlkey->fPrivateModQ = (((flags & SYMCRYPT_FLAG_DLKEY_GEN_MODP)==0) && (pDlgroup->fHasPrimeQ));
336
337 if (pkDlkey->fPrivateModQ)
338 {
339 pmPriv = pDlgroup->pmQ;
340 nDigitsPriv = pDlgroup->nDigitsOfQ;
341 nBitsPriv = pDlgroup->nBitsOfQ;
342 fFlagsForModSetRandom = SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE | SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE; // 1 to Q-1
343
344 if ( pDlgroup->isSafePrimeGroup && (pkDlkey->nBitsPriv != pDlgroup->nBitsOfQ) )
345 {
346 useModSetRandom = FALSE;
347 SYMCRYPT_ASSERT( pkDlkey->nBitsPriv < pDlgroup->nBitsOfQ ); // 2^nBitsPriv < Q
348
349 nBitsPriv = pkDlkey->nBitsPriv; // 1 to (2^nBitsPriv)-1
350 nBytesPriv = (pkDlkey->nBitsPriv + 7) / 8;
351 }
352 }
353 else
354 {
355 // We perform Private key range validation by construction
356 // The Private key is constructed in the range [1,min(2^nBitsPriv,Q)-1] precisely when pkDlkey->fPrivateModQ
357 if ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 )
358 {
359 scError = SYMCRYPT_INVALID_ARGUMENT;
360 goto cleanup;
361 }
362
363 pmPriv = pDlgroup->pmP;
364 nDigitsPriv = pDlgroup->nDigitsOfP;
365 nBitsPriv = pDlgroup->nBitsOfP;
366 fFlagsForModSetRandom = SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE; // 1 to P-2
367 }
368
369 cbPrivateKey = SymCryptSizeofModElementFromModulus( pmPriv );
370
371 //
372 // From symcrypt_internal.h we have:
373 // - sizeof results are upper bounded by 2^19
374 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
375 // Thus the following calculation does not overflow cbScratch.
376 //
377 cbScratch = SYMCRYPT_MAX( cbPrivateKey + SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(nDigitsPriv),
378 (2 * cbModElement) + SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP(pDlgroup->nDigitsOfP));
379 pbScratch = SymCryptCallbackAlloc( cbScratch );
380 if (pbScratch == NULL)
381 {
382 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
383 goto cleanup;
384 }
385
386 // Create the private key integer
387 pkDlkey->piPrivateKey = SymCryptIntCreate( pkDlkey->pbPrivate, SymCryptSizeofIntFromDigits(nDigitsPriv), nDigitsPriv );
388
389 if (useModSetRandom)
390 {
391 // Create the private key modelement
392 pePrivateKey = SymCryptModElementCreate( pbScratch, cbPrivateKey, pmPriv );
393 pbScratchInternal = pbScratch + cbPrivateKey;
394 cbScratchInternal = cbScratch - cbPrivateKey;
395
396 // Set a modelement from 1 to q-1 (or 1 to p-2)
397 SymCryptModSetRandom(
398 pmPriv,
399 pePrivateKey,
400 fFlagsForModSetRandom,
401 pbScratchInternal,
402 cbScratchInternal );
403
404 // Set the private key
405 SymCryptModElementToInt(
406 pmPriv,
407 pePrivateKey,
408 pkDlkey->piPrivateKey,
409 pbScratchInternal,
410 cbScratchInternal );
411 }
412 else
413 {
414 // Set private key from 1 to (2^nBitsPriv)-1
415 // Wipe any bytes we won't fill with random
416 SymCryptWipe( pbScratch + nBytesPriv, (nDigitsPriv * SYMCRYPT_FDEF_DIGIT_SIZE) - nBytesPriv );
417
418 dwShiftBits = (0u-nBitsPriv) & 7;
419 privMask = (BYTE)(0xff >> dwShiftBits);
420
421 for(cntr=0; cntr<DLKEY_GEN_RANDOM_GENERIC_LIMIT; cntr++)
422 {
423 // Try random values until we get one we like
424 SymCryptCallbackRandom( pbScratch, nBytesPriv );
425
426 pbScratch[nBytesPriv-1] &= privMask;
427
428 // If non-zero we have a value in range [1, (2^nBitsPriv)-1]
429 if( !SymCryptFdefRawIsEqualUint32( (PCUINT32)pbScratch, nDigitsPriv, 0 ) )
430 {
431 break;
432 }
433 }
434
435 if (cntr >= DLKEY_GEN_RANDOM_GENERIC_LIMIT)
436 {
437 SymCryptFatal( 'rndl' );
438 }
439
440 scError = SymCryptIntSetValue( pbScratch, nBytesPriv, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, pkDlkey->piPrivateKey );
441 if ( scError != SYMCRYPT_NO_ERROR )
442 {
443 goto cleanup;
444 }
445 }
446
447 // Calculate the public key
448 SymCryptModExp(
449 pDlgroup->pmP,
450 pDlgroup->peG,
451 pkDlkey->piPrivateKey,
452 nBitsPriv,
453 0, // Side-channel safe
454 pkDlkey->pePublicKey,
455 pbScratch, // We can overwrite pePrivateKey now
456 cbScratch );
457
458 // Perform range validation on generated Public key.
459 if ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 )
460 {
461 // Perform Public key validation.
462 // Always perform range validation, and validation that Public key is in subgroup of order Q
463 scError = SymCryptDlkeyPerformPublicKeyValidation(
464 pkDlkey,
465 SYMCRYPT_FLAG_DLKEY_PUBLIC_KEY_ORDER_VALIDATION,
466 pbScratch,
467 cbScratch );
468 if ( scError != SYMCRYPT_NO_ERROR )
469 {
470 goto cleanup;
471 }
472 }
473
474 // Set the fHasPrivateKey flag
475 pkDlkey->fHasPrivateKey = TRUE;
476
477 pkDlkey->fAlgorithmInfo = flags; // We want to track all of the flags in the Dlkey
478
479 if ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 )
480 {
481 if( ( flags & SYMCRYPT_FLAG_DLKEY_DSA ) != 0 )
482 {
483 // Ensure DSA algorithm selftest is run before first use of DSA algorithm
484 SYMCRYPT_RUN_SELFTEST_ONCE(
485 SymCryptDsaSelftest,
486 SYMCRYPT_SELFTEST_ALGORITHM_DSA );
487
488 // Run PCT eagerly as the key can only be used for DSA - there is no value in deferring
489 SYMCRYPT_RUN_KEY_GEN_PCT(
490 SymCryptDsaPct,
491 pkDlkey,
492 SYMCRYPT_PCT_DSA );
493 }
494
495 if( ( flags & SYMCRYPT_FLAG_DLKEY_DH ) != 0 )
496 {
497 // Ensure we have run the algorithm selftest at least once.
498 SYMCRYPT_RUN_SELFTEST_ONCE(
499 SymCryptDhSecretAgreementSelftest,
500 SYMCRYPT_SELFTEST_ALGORITHM_DH );
501
502 // Run PCT eagerly as the key can only be used for DH
503
504 // DH PCT per SP80056a-rev3 5.6.2.1.4 b)
505 // Recompute the public key from the private key
506 // Option a) appears to be explicitly overruled by 140-3 IG
507
508 // Calculate the public key from the private key in scratch
509 pbScratchInternal = pbScratch;
510 cbScratchInternal = cbScratch;
511
512 peTmp = SymCryptModElementCreate( pbScratchInternal, cbModElement, pDlgroup->pmP );
513 pbScratchInternal += cbModElement;
514 cbScratchInternal -= cbModElement;
515
516 SymCryptModExp(
517 pDlgroup->pmP,
518 pDlgroup->peG,
519 pkDlkey->piPrivateKey,
520 nBitsPriv, // This is either bits of P, Q, or some caller-defined value i.e. public values
521 0, // Side-channel safe
522 peTmp,
523 pbScratchInternal,
524 cbScratchInternal );
525
526 SYMCRYPT_FIPS_ASSERT( SymCryptModElementIsEqual(pDlgroup->pmP, peTmp, pkDlkey->pePublicKey) );
527 }
528 }
529
530cleanup:
531 if (pbScratch!=NULL)
532 {
533 SymCryptWipe( pbScratch, cbScratch );
534 SymCryptCallbackFree( pbScratch );
535 }
536 return scError;
537}
SymCryptDlkeyPerformPublicKeyValidation
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyPerformPublicKeyValidation(_In_ PCSYMCRYPT_DLKEY pkDlkey, _In_ UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: dlkey.c:206
DLKEY_GEN_RANDOM_GENERIC_LIMIT
#define DLKEY_GEN_RANDOM_GENERIC_LIMIT
Definition: dlkey.c:279
SYMCRYPT_FLAG_DLKEY_PUBLIC_KEY_ORDER_VALIDATION
#define SYMCRYPT_FLAG_DLKEY_PUBLIC_KEY_ORDER_VALIDATION
Definition: dlkey.c:202
SymCryptFdefRawIsEqualUint32
UINT32 SYMCRYPT_CALL SymCryptFdefRawIsEqualUint32(_In_reads_(nDigits *SYMCRYPT_FDEF_DIGIT_NUINT32) PCUINT32 pSrc1, UINT32 nDigits, _In_ UINT32 u32Src2)
Definition: fdef_general.c:730
SYMCRYPT_RUN_KEY_GEN_PCT
#define SYMCRYPT_RUN_KEY_GEN_PCT(KeySelftestFunction, Key, KeySelftestFlag)
Definition: sc_lib.h:3699
SYMCRYPT_RUN_SELFTEST_ONCE
#define SYMCRYPT_RUN_SELFTEST_ONCE(AlgorithmSelftestFunction, AlgorithmSelftestFlag)
Definition: sc_lib.h:3686
SymCryptDsaPct
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaPct(PCSYMCRYPT_DLKEY pkDlkey)
SymCryptDsaSelftest
VOID SYMCRYPT_CALL SymCryptDsaSelftest(void)
SymCryptDhSecretAgreementSelftest
VOID SYMCRYPT_CALL SymCryptDhSecretAgreementSelftest(void)
SYMCRYPT_FLAG_KEY_NO_FIPS
#define SYMCRYPT_FLAG_KEY_NO_FIPS
Definition: symcrypt.h:7579
SYMCRYPT_FLAG_DLKEY_GEN_MODP
#define SYMCRYPT_FLAG_DLKEY_GEN_MODP
Definition: symcrypt.h:8065
SYMCRYPT_SELFTEST_ALGORITHM_DSA
@ SYMCRYPT_SELFTEST_ALGORITHM_DSA
Definition: symcrypt_internal.h:3426
SYMCRYPT_SELFTEST_ALGORITHM_DH
@ SYMCRYPT_SELFTEST_ALGORITHM_DH
Definition: symcrypt_internal.h:3429
SYMCRYPT_FDEF_DIGIT_SIZE
#define SYMCRYPT_FDEF_DIGIT_SIZE
Definition: symcrypt_internal.h:2296
SYMCRYPT_PCT_DSA
#define SYMCRYPT_PCT_DSA
Definition: symcrypt_internal.h:3469
SYMCRYPT_FIPS_ASSERT
#define SYMCRYPT_FIPS_ASSERT(x)
Definition: symcrypt_internal.h:3418
PCUINT32
const UINT32 * PCUINT32
Definition: symcrypt_internal.h:254
PSYMCRYPT_MODULUS
SYMCRYPT_MODULUS * PSYMCRYPT_MODULUS
Definition: symcrypt_internal.h:2336
nBitsPriv
UINT32 nBitsPriv
Definition: symcrypt_internal.h:2870
SymCryptModSetRandom
VOID SYMCRYPT_CALL SymCryptModSetRandom(_In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:993
SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE
#define SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE
Definition: symcrypt_low_level.h:1692
SymCryptModElementToInt
VOID SYMCRYPT_CALL SymCryptModElementToInt(_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:762
SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE
#define SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE
Definition: symcrypt_low_level.h:1693

◆ SymCryptDlkeyGetGroup()

PCSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlkeyGetGroup ( _In_ PCSYMCRYPT_DLKEY  pkDlkey)

Definition at line 153 of file dlkey.c.

154{
155 return pkDlkey->pDlgroup;
156}

◆ SymCryptDlkeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyGetValue ( _In_ PCSYMCRYPT_DLKEY  pkDlkey,
_Out_writes_bytes_(cbPrivateKey) PBYTE  pbPrivateKey,
SIZE_T  cbPrivateKey,
_Out_writes_bytes_(cbPublicKey) PBYTE  pbPublicKey,
SIZE_T  cbPublicKey,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags 
)

Definition at line 825 of file dlkey.c.

835{
836 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
837 PBYTE pbScratch = NULL;
838 UINT32 cbScratch = 0;
839
840 PCSYMCRYPT_DLGROUP pDlgroup = pkDlkey->pDlgroup;
841
842 UNREFERENCED_PARAMETER( flags );
843
844 if ( ((pbPrivateKey==NULL) && (cbPrivateKey!=0)) ||
845 ((pbPublicKey==NULL) && (cbPublicKey!=0)) ||
846 ((pbPrivateKey==NULL) && (pbPublicKey==NULL)) ||
847 ((pbPrivateKey!=NULL) && !pkDlkey->fHasPrivateKey) )
848 {
849 scError = SYMCRYPT_INVALID_ARGUMENT;
850 goto cleanup;
851 }
852
853 if (pbPrivateKey != NULL)
854 {
855 scError = SymCryptIntGetValue(
856 pkDlkey->piPrivateKey,
857 pbPrivateKey,
858 cbPrivateKey,
859 numFormat );
860 if (scError!=SYMCRYPT_NO_ERROR)
861 {
862 goto cleanup;
863 }
864 }
865
866 if (pbPublicKey != NULL)
867 {
868 cbScratch = SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(pDlgroup->nDigitsOfP);
869 pbScratch = SymCryptCallbackAlloc( cbScratch );
870 if (pbScratch == NULL)
871 {
872 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
873 goto cleanup;
874 }
875
876 scError = SymCryptModElementGetValue(
877 pDlgroup->pmP,
878 pkDlkey->pePublicKey,
879 pbPublicKey,
880 cbPublicKey,
881 numFormat,
882 pbScratch,
883 cbScratch );
884 if (scError!=SYMCRYPT_NO_ERROR)
885 {
886 goto cleanup;
887 }
888 }
889
890cleanup:
891 if (pbScratch!=NULL)
892 {
893 SymCryptWipe( pbScratch, cbScratch );
894 SymCryptCallbackFree( pbScratch );
895 }
896 return scError;
897}

◆ SymCryptDlkeyHasPrivateKey()

BOOLEAN SYMCRYPT_CALL SymCryptDlkeyHasPrivateKey ( _In_ PCSYMCRYPT_DLKEY  pkDlkey)

Definition at line 197 of file dlkey.c.

198{
199 return pkDlkey->fHasPrivateKey;
200}

◆ SymCryptDlkeySetPrivateKeyLength()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeySetPrivateKeyLength ( _Inout_ PSYMCRYPT_DLKEY  pkDlkey,
UINT32  nBitsPriv,
UINT32  flags 
)

Definition at line 138 of file dlkey.c.

139{
140 if( nBitsPriv > pkDlkey->pDlgroup->nBitsOfQ ||
141 nBitsPriv < pkDlkey->pDlgroup->nMinBitsPriv ||
142 flags != 0 )
143 {
144 return SYMCRYPT_INVALID_ARGUMENT;
145 }
146
147 pkDlkey->nBitsPriv = nBitsPriv;
148 return SYMCRYPT_NO_ERROR;
149}

◆ SymCryptDlkeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeySetValue ( _In_reads_bytes_(cbPrivateKey) PCBYTE  pbPrivateKey,
SIZE_T  cbPrivateKey,
_In_reads_bytes_(cbPublicKey) PCBYTE  pbPublicKey,
SIZE_T  cbPublicKey,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_DLKEY  pkDlkey 
)

Definition at line 541 of file dlkey.c.

549{
550 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
551 PBYTE pbScratch = NULL;
552 UINT32 cbScratch = 0;
553 PBYTE pbScratchInternal = NULL;
554 UINT32 cbScratchInternal = 0;
555
556 PCSYMCRYPT_DLGROUP pDlgroup = pkDlkey->pDlgroup;
557
558 UINT32 nDigitsPriv = 0;
559 UINT32 nBitsPriv = 0;
560
561 PSYMCRYPT_MODELEMENT peTmp = NULL;
562 UINT32 cbModElement = SymCryptSizeofModElementFromModulus( pDlgroup->pmP );
563 UINT32 fValidatePublicKeyOrder = SYMCRYPT_FLAG_DLKEY_PUBLIC_KEY_ORDER_VALIDATION;
564
565 if ( ((pbPrivateKey==NULL) && (cbPrivateKey!=0)) ||
566 ((pbPublicKey==NULL) && (cbPublicKey!=0)) ||
567 ((pbPrivateKey==NULL) && (pbPublicKey==NULL)) )
568 {
569 scError = SYMCRYPT_INVALID_ARGUMENT;
570 goto cleanup;
571 }
572
573 // Ensure caller has specified what algorithm(s) the key will be used with
574 UINT32 algorithmFlags = SYMCRYPT_FLAG_DLKEY_DSA | SYMCRYPT_FLAG_DLKEY_DH;
575 // Make sure only allowed flags are specified
576 UINT32 allowedFlags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION | algorithmFlags;
577
578 if ( ( ( flags & ~allowedFlags ) != 0 ) ||
579 ( ( flags & algorithmFlags ) == 0 ) )
580 {
581 scError = SYMCRYPT_INVALID_ARGUMENT;
582 goto cleanup;
583 }
584
585 // Extra sanity checks when running with FIPS
586 // Either Dlgroup is named SafePrime group and key is for DH,
587 // or Dlgroup is not named SafePrime group and key is for DSA
588 if ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
589 ( (pDlgroup->isSafePrimeGroup && (flags & SYMCRYPT_FLAG_DLKEY_DSA)) ||
590 (!(pDlgroup->isSafePrimeGroup) && (flags & SYMCRYPT_FLAG_DLKEY_DH)) ) )
591 {
592 scError = SYMCRYPT_INVALID_ARGUMENT;
593 goto cleanup;
594 }
595
596 // Check that minimal validation flag only specified with no fips
597 if ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
598 ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) != 0 ) )
599 {
600 scError = SYMCRYPT_INVALID_ARGUMENT;
601 goto cleanup;
602 }
603
604 if ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) != 0 )
605 {
606 fValidatePublicKeyOrder = 0;
607 }
608
609 //
610 // From symcrypt_internal.h we have:
611 // - sizeof results are upper bounded by 2^19
612 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
613 // Thus the following calculation does not overflow cbScratch.
614 //
615 cbScratch = SYMCRYPT_MAX( cbModElement + SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS(pDlgroup->nDigitsOfP),
616 (2 * cbModElement) + SYMCRYPT_SCRATCH_BYTES_FOR_MODEXP(pDlgroup->nDigitsOfP) );
617 pbScratch = SymCryptCallbackAlloc( cbScratch );
618 if (pbScratch == NULL)
619 {
620 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
621 goto cleanup;
622 }
623
624 if ( pbPrivateKey != NULL )
625 {
626 //
627 // Check the size of the imported private key to detect if it is mod P or mod Q
628 // If the group does not have a Q assume that the imported key is modulo P as
629 // it wouldn't help us assume otherwise (the bitsize of the private key should be kept
630 // secret from SC attacks).
631 // If the private key has had some non-default value set for nBitsPriv then the caller
632 // has explicitly opted in to more stringent range checking.
633 //
634 pkDlkey->fPrivateModQ = ( (pDlgroup->fHasPrimeQ) &&
635 ((cbPrivateKey < pDlgroup->cbPrimeQ) ||
636 ((cbPrivateKey == pDlgroup->cbPrimeQ) && (pDlgroup->cbPrimeQ < pDlgroup->cbPrimeP)) ||
637 (pkDlkey->nBitsPriv != pDlgroup->nDefaultBitsPriv)) );
638
639 if ( pkDlkey->fPrivateModQ )
640 {
641 nDigitsPriv = pDlgroup->nDigitsOfQ;
642 nBitsPriv = pDlgroup->nBitsOfQ;
643
644 if ( pDlgroup->isSafePrimeGroup )
645 {
646 nBitsPriv = pkDlkey->nBitsPriv;
647 }
648 }
649 else
650 {
651 nDigitsPriv = pDlgroup->nDigitsOfP;
652 nBitsPriv = pDlgroup->nBitsOfP;
653 }
654
655 pkDlkey->piPrivateKey = SymCryptIntCreate( pkDlkey->pbPrivate, SymCryptSizeofIntFromDigits(nDigitsPriv), nDigitsPriv );
656
657 scError = SymCryptIntSetValue(
658 pbPrivateKey,
659 cbPrivateKey,
660 numFormat,
661 pkDlkey->piPrivateKey );
662 if ( scError != SYMCRYPT_NO_ERROR )
663 {
664 goto cleanup;
665 }
666
667 // Perform range validation on imported Private key.
668 // Check if Private key is 0 - perform unconditionally as it is cheap
669 // and it never makes sense for private key to be 0 intentionally
670 if ( SymCryptIntIsEqualUint32( pkDlkey->piPrivateKey, 0 ) )
671 {
672 scError = SYMCRYPT_INVALID_ARGUMENT;
673 goto cleanup;
674 }
675
676 // Continue range validation on imported Private key.
677 if ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 )
678 {
679 // Ensure that Q is specified in the Dlgroup
680 if ( !pDlgroup->fHasPrimeQ )
681 {
682 scError = SYMCRYPT_INVALID_ARGUMENT;
683 goto cleanup;
684 }
685
686 // If nBitsPriv is specified, check if Private key is greater than or equal to 2^nBitsPriv
687 // Otherwise, check if Private key is greater than or equal to Q
688 if ( ( ( (nBitsPriv < pDlgroup->nBitsOfQ) &&
689 SymCryptIntBitsizeOfValue( pkDlkey->piPrivateKey ) > nBitsPriv ) ) ||
690 ( (nBitsPriv >= pDlgroup->nBitsOfQ) &&
691 !SymCryptIntIsLessThan( pkDlkey->piPrivateKey, SymCryptIntFromModulus( pDlgroup->pmQ ) ) ) )
692 {
693 scError = SYMCRYPT_INVALID_ARGUMENT;
694 goto cleanup;
695 }
696 }
697
698 pkDlkey->fHasPrivateKey = TRUE;
699 }
700
701 if ( pbPublicKey != NULL )
702 {
703 scError = SymCryptModElementSetValue(
704 pbPublicKey,
705 cbPublicKey,
706 numFormat,
707 pDlgroup->pmP,
708 pkDlkey->pePublicKey,
709 pbScratch,
710 cbScratch );
711 if ( scError != SYMCRYPT_NO_ERROR )
712 {
713 goto cleanup;
714 }
715
716 // Perform range validation on imported Public key.
717 if ( (flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION) == 0 )
718 {
719 // Perform Public key validation.
720 // Always perform range validation
721 // May also perform validation that Public key is in subgroup of order Q, depending on flags
722 scError = SymCryptDlkeyPerformPublicKeyValidation(
723 pkDlkey,
724 fValidatePublicKeyOrder,
725 pbScratch,
726 cbScratch );
727 if ( scError != SYMCRYPT_NO_ERROR )
728 {
729 goto cleanup;
730 }
731 }
732 }
733
734 // Calculating the public key if no key was provided
735 // or if needed for keypair regeneration validation
736 if ( (pbPublicKey==NULL) ||
737 ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
738 (pbPrivateKey!=NULL) && (pbPublicKey!=NULL) ) )
739 {
740 // Calculate the public key from the private key
741 pbScratchInternal = pbScratch;
742 cbScratchInternal = cbScratch;
743
744 // By default calculate the public key directly where it will be persisted
745 peTmp = pkDlkey->pePublicKey;
746
747 if ( pbPublicKey != NULL )
748 {
749 // If doing regeneration validation calculate the public key in scratch
750 peTmp = SymCryptModElementCreate( pbScratchInternal, cbModElement, pDlgroup->pmP);
751 pbScratchInternal += cbModElement;
752 cbScratchInternal -= cbModElement;
753 }
754
755 SymCryptModExp(
756 pDlgroup->pmP,
757 pDlgroup->peG,
758 pkDlkey->piPrivateKey,
759 nBitsPriv, // This is either bits of P, Q, or some caller-defined value i.e. public values
760 0, // Side-channel safe
761 peTmp,
762 pbScratchInternal,
763 cbScratchInternal );
764
765 if ( pbPublicKey != NULL )
766 {
767 if ( !SymCryptModElementIsEqual(pDlgroup->pmP, peTmp, pkDlkey->pePublicKey) )
768 {
769 scError = SYMCRYPT_AUTHENTICATION_FAILURE;
770 goto cleanup;
771 }
772 }
773 else if ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) == 0 )
774 {
775 // Perform Public key validation on generated public key.
776 // Always perform range validation
777 // May also perform validation that Public key is in subgroup of order Q, depending on flags
778 scError = SymCryptDlkeyPerformPublicKeyValidation(
779 pkDlkey,
780 fValidatePublicKeyOrder,
781 pbScratch,
782 cbScratch );
783 if ( scError != SYMCRYPT_NO_ERROR )
784 {
785 goto cleanup;
786 }
787 }
788 }
789
790 pkDlkey->fAlgorithmInfo = flags; // We want to track all of the flags in the Dlkey
791
792 if ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 )
793 {
794 if( ( flags & SYMCRYPT_FLAG_DLKEY_DSA ) != 0 )
795 {
796 // Ensure DSA algorithm selftest is run before first use of DSA algorithm
797 SYMCRYPT_RUN_SELFTEST_ONCE(
798 SymCryptDsaSelftest,
799 SYMCRYPT_SELFTEST_ALGORITHM_DSA );
800
801 // PCT does not need to be run on import - mark it as done
802 pkDlkey->fAlgorithmInfo |= SYMCRYPT_PCT_DSA;
803 }
804
805 if( ( flags & SYMCRYPT_FLAG_DLKEY_DH ) != 0 )
806 {
807 SYMCRYPT_RUN_SELFTEST_ONCE(
808 SymCryptDhSecretAgreementSelftest,
809 SYMCRYPT_SELFTEST_ALGORITHM_DH );
810 }
811 }
812
813cleanup:
814 if (pbScratch!=NULL)
815 {
816 SymCryptWipe( pbScratch, cbScratch );
817 SymCryptCallbackFree( pbScratch );
818 }
819 return scError;
820}
SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION
#define SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION
Definition: symcrypt.h:7586
SymCryptIntIsLessThan
UINT32 SYMCRYPT_CALL SymCryptIntIsLessThan(_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2)
Definition: a_dispatch.c:442
SymCryptIntIsEqualUint32
UINT32 SYMCRYPT_CALL SymCryptIntIsEqualUint32(_In_ PCSYMCRYPT_INT piSrc1, _In_ UINT32 u32Src2)
Definition: a_dispatch.c:424

◆ SymCryptDlkeySizeofPrivateKey()

UINT32 SYMCRYPT_CALL SymCryptDlkeySizeofPrivateKey ( _In_ PCSYMCRYPT_DLKEY  pkDlkey)

Definition at line 167 of file dlkey.c.

168{
169 PCSYMCRYPT_DLGROUP pDlgroup = pkDlkey->pDlgroup;
170
171 if (pkDlkey->fPrivateModQ)
172 {
173 if (pDlgroup->fHasPrimeQ)
174 {
175 if (pkDlkey->nBitsPriv != pDlgroup->nBitsOfQ)
176 {
177 return (pkDlkey->nBitsPriv + 7) / 8;
178 }
179 else
180 {
181 return pDlgroup->cbPrimeQ;
182 }
183 }
184 else
185 {
186 return pDlgroup->cbPrimeP; // Somehow the group has no prime Q but the key was set with prime Q, return the safe option
187 }
188 }
189 else
190 {
191 return pDlgroup->cbPrimeP;
192 }
193}

◆ SymCryptDlkeySizeofPublicKey()

UINT32 SYMCRYPT_CALL SymCryptDlkeySizeofPublicKey ( _In_ PCSYMCRYPT_DLKEY  pkDlkey)

Definition at line 160 of file dlkey.c.

161{
162 return pkDlkey->pDlgroup->cbPrimeP;
163}

Referenced by SymCryptDhSecretAgreement().

◆ SymCryptDlkeyWipe()

VOID SYMCRYPT_CALL SymCryptDlkeyWipe ( _Out_ PSYMCRYPT_DLKEY  pkDst)

Definition at line 102 of file dlkey.c.

103{
104 SymCryptWipe( (PBYTE) pkDst, SymCryptSizeofDlkeyFromDlgroup(pkDst->pDlgroup) );
105}

Referenced by SymCryptDlkeyFree().

◆ SymCryptDsaSelftest()

VOID SYMCRYPT_CALL SymCryptDsaSelftest ( void  )

Referenced by SymCryptDlkeyGenerate(), and SymCryptDlkeySetValue().

◆ SymCryptDsaSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaSign ( _In_ PCSYMCRYPT_DLKEY  pKey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
SYMCRYPT_NUMBER_FORMAT  format,
UINT32  flags,
_Out_writes_bytes_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature 
)

Definition at line 395 of file dsa.c.

403{
404 return SymCryptDsaSignEx( pKey, pbHashValue, cbHashValue, NULL, format, flags, pbSignature, cbSignature );
405}
SymCryptDsaSignEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaSignEx(_In_ PCSYMCRYPT_DLKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_opt_ PCSYMCRYPT_INT piK, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
Definition: dsa.c:59
pKey
PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pKey
Definition: symcrypt_internal.h:1324

◆ SymCryptDsaVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaVerify ( _In_ PCSYMCRYPT_DLKEY  pKey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
SYMCRYPT_NUMBER_FORMAT  format,
UINT32  flags 
)

Definition at line 410 of file dsa.c.

418{
419 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
420 BOOLEAN fValidSignature = FALSE;
421
422 PBYTE pbScratch = NULL;
423 SIZE_T cbScratch = 0;
424 PBYTE pbScratchInternal = NULL;
425 SIZE_T cbScratchInternal = 0;
426
427 PCSYMCRYPT_DLGROUP pDlgroup = pKey->pDlgroup;
428 UINT32 nDigitsOfP = pDlgroup->nDigitsOfP;
429 UINT32 nDigitsOfQ = pDlgroup->nDigitsOfQ;
430
431 UINT32 ndIntLarge = 0;
432
433 UINT32 cbIntLarge = 0;
434 UINT32 cbIntQ = 0;
435 UINT32 cbIntP = 0;
436
437 UINT32 cbModelementP = 0;
438 UINT32 cbModelementQ = 0;
439
440 PSYMCRYPT_MODELEMENT peBases[2] = { NULL, NULL }; // Array with pointers to base points
441
442 // Helper Integers
443 PSYMCRYPT_INT piIntLarge = NULL; // Safe size for all caller specified sizes
444 PSYMCRYPT_INT piIntP = NULL; // Same number of digits as P
445 PSYMCRYPT_INT piIntQ[2] = { NULL, NULL }; // Same number of digits as Q
446
447 // Elements modulo P
448 PSYMCRYPT_MODELEMENT peResP = NULL;
449
450 // Elements modulo Q
451 PSYMCRYPT_MODELEMENT peR = NULL;
452 PSYMCRYPT_MODELEMENT peS = NULL;
453 PSYMCRYPT_MODELEMENT peT = NULL; // Temp
454
455 UNREFERENCED_PARAMETER( flags );
456
457 // Make sure that the key may be used in DSA
458 if ( ((pKey->fAlgorithmInfo & SYMCRYPT_FLAG_DLKEY_DSA) == 0) )
459 {
460 scError = SYMCRYPT_INVALID_ARGUMENT;
461 goto cleanup;
462 }
463
464 // Make sure that the group has a prime q, and we are not using a named DH safe-prime group
465 if (!pDlgroup->fHasPrimeQ || pDlgroup->isSafePrimeGroup)
466 {
467 scError = SYMCRYPT_INVALID_ARGUMENT;
468 goto cleanup;
469 }
470
471 // Calculate the digit sizes
472 ndIntLarge = SymCryptDigitsFromBits( (UINT32)cbHashValue * 8 );
473 ndIntLarge = SYMCRYPT_MAX( ndIntLarge, SymCryptDigitsFromBits( (UINT32)cbSignature * 4 ) ); // pbSignature contains (R,S)
474
475 // Calculate the sizes of temp objects
476 cbIntLarge = SymCryptSizeofIntFromDigits(ndIntLarge);
477 cbIntQ = SymCryptSizeofIntFromDigits(nDigitsOfQ);
478 cbIntP = SymCryptSizeofIntFromDigits(nDigitsOfP);
479
480 cbModelementP = SymCryptSizeofModElementFromModulus( pDlgroup-> pmP );
481 cbModelementQ = SymCryptSizeofModElementFromModulus( pDlgroup-> pmQ );
482
483 //
484 // From symcrypt_internal.h we have:
485 // - sizeof results are upper bounded by 2^19
486 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
487 // Thus the following calculation does not overflow cbScratch.
488 //
489 cbScratch = cbIntLarge + cbIntP + 2*cbIntQ + cbModelementP + 3*cbModelementQ +
490 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_INT_DIVMOD(nDigitsOfP,nDigitsOfQ),
491 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigitsOfQ ),
492 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( nDigitsOfP ),
493 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_MODMULTIEXP( SymCryptModulusDigitsizeOfObject(pDlgroup->pmP), 2, pDlgroup->nBitsOfQ ),
494 SYMCRYPT_SCRATCH_BYTES_FOR_MODINV( nDigitsOfQ ) ))));
495 pbScratch = SymCryptCallbackAlloc( cbScratch );
496 if (pbScratch==NULL)
497 {
498 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
499 goto cleanup;
500 }
501
502 // Create the objects
503 pbScratchInternal = pbScratch;
504 cbScratchInternal = cbScratch;
505
506 piIntLarge = SymCryptIntCreate(pbScratchInternal, cbIntLarge, ndIntLarge); pbScratchInternal += cbIntLarge; cbScratchInternal -= cbIntLarge;
507 piIntP = SymCryptIntCreate(pbScratchInternal, cbIntP, nDigitsOfP); pbScratchInternal += cbIntP; cbScratchInternal -= cbIntP;
508 piIntQ[0] = SymCryptIntCreate(pbScratchInternal, cbIntQ, nDigitsOfQ); pbScratchInternal += cbIntQ; cbScratchInternal -= cbIntQ;
509 piIntQ[1] = SymCryptIntCreate(pbScratchInternal, cbIntQ, nDigitsOfQ); pbScratchInternal += cbIntQ; cbScratchInternal -= cbIntQ;
510
511 peResP = SymCryptModElementCreate(pbScratchInternal, cbModelementP, pDlgroup->pmP); pbScratchInternal += cbModelementP; cbScratchInternal -= cbModelementP;
512
513 peR = SymCryptModElementCreate(pbScratchInternal, cbModelementQ, pDlgroup->pmQ); pbScratchInternal += cbModelementQ; cbScratchInternal -= cbModelementQ;
514 peS = SymCryptModElementCreate(pbScratchInternal, cbModelementQ, pDlgroup->pmQ); pbScratchInternal += cbModelementQ; cbScratchInternal -= cbModelementQ;
515 peT = SymCryptModElementCreate(pbScratchInternal, cbModelementQ, pDlgroup->pmQ); pbScratchInternal += cbModelementQ; cbScratchInternal -= cbModelementQ;
516
517 // Get R
518 scError = SymCryptIntSetValue( pbSignature, cbSignature / 2, format, piIntLarge );
519 if ( scError != SYMCRYPT_NO_ERROR )
520 {
521 goto cleanup;
522 }
523
524 // Check if R is less than Q
525 if ( !SymCryptIntIsLessThan( piIntLarge, SymCryptIntFromModulus( pDlgroup->pmQ ) ) )
526 {
527 goto cleanup;
528 }
529
530 // R mod Q (use piIntQ[0] as temp space)
531 scError = SymCryptIntCopyMixedSize( piIntLarge, piIntQ[0] );
532 if ( scError != SYMCRYPT_NO_ERROR )
533 {
534 // This should never fail here as we verified that IntLarge is less than Q
535 goto cleanup;
536 }
537 SymCryptIntToModElement( piIntQ[0], pDlgroup->pmQ, peR, pbScratchInternal, cbScratchInternal );
538
539 // Check if R is zero
540 if (SymCryptModElementIsZero( pDlgroup->pmQ, peR ))
541 {
542 goto cleanup;
543 }
544
545 // Get S
546 scError = SymCryptIntSetValue( pbSignature + cbSignature / 2, cbSignature / 2, format, piIntLarge );
547 if ( scError != SYMCRYPT_NO_ERROR )
548 {
549 goto cleanup;
550 }
551
552 // Check if S is less than Q
553 if ( !SymCryptIntIsLessThan( piIntLarge, SymCryptIntFromModulus( pDlgroup->pmQ ) ) )
554 {
555 goto cleanup;
556 }
557
558 // S mod Q (use piIntQ[0] as temp space)
559 scError = SymCryptIntCopyMixedSize( piIntLarge, piIntQ[0] );
560 if ( scError != SYMCRYPT_NO_ERROR )
561 {
562 // This should never fail here as we verified that IntLarge is less than Q
563 goto cleanup;
564 }
565 SymCryptIntToModElement( piIntQ[0], pDlgroup->pmQ, peS, pbScratchInternal, cbScratchInternal );
566
567 // Check if S is zero
568 if (SymCryptModElementIsZero( pDlgroup->pmQ, peS ))
569 {
570 goto cleanup;
571 }
572
573 // Calculate 1/S mod Q
574 // S is part of the signature and therefore not a secret.
575 // We mark it public to avoid the use of random blinding, which would require a source of randomness
576 // just to verify a DSA signature.
577 scError = SymCryptModInv( pDlgroup->pmQ, peS, peS, SYMCRYPT_FLAG_DATA_PUBLIC, pbScratchInternal, cbScratchInternal );
578 if( scError != SYMCRYPT_NO_ERROR )
579 {
580 goto cleanup;
581 }
582
583 // Get the message into a modelement
584 scError = SymCryptDsaTruncateHash(
585 pDlgroup,
586 pbHashValue,
587 cbHashValue,
588 flags,
589 peT,
590 piIntLarge,
591 piIntQ[0],
592 pbScratchInternal,
593 cbScratchInternal );
594 if (scError!=SYMCRYPT_NO_ERROR)
595 {
596 goto cleanup;
597 }
598
599 // Calculate U1 = Hash(M)/S modQ
600 SymCryptModMul(
601 pDlgroup->pmQ,
602 peT,
603 peS,
604 peT,
605 pbScratchInternal,
606 cbScratchInternal );
607
608 // Convert U1 to integer
609 SymCryptModElementToInt(
610 pDlgroup->pmQ,
611 peT,
612 piIntQ[0],
613 pbScratchInternal,
614 cbScratchInternal );
615
616 // Calculate U2 = R/S modQ
617 SymCryptModMul(
618 pDlgroup->pmQ,
619 peR,
620 peS,
621 peT,
622 pbScratchInternal,
623 cbScratchInternal );
624
625 // Convert U2 to integer
626 SymCryptModElementToInt(
627 pDlgroup->pmQ,
628 peT,
629 piIntQ[1],
630 pbScratchInternal,
631 cbScratchInternal );
632
633 // Arrange the pointers for v = G^U1 * Y^U2
634 peBases[0] = pDlgroup->peG;
635 peBases[1] = pKey->pePublicKey;
636
637 // v = G^U1 * Y^U2
638 scError = SymCryptModMultiExp(
639 pDlgroup->pmP,
640 peBases,
641 piIntQ,
642 2,
643 pDlgroup->nBitsOfQ,
644 SYMCRYPT_FLAG_DATA_PUBLIC,
645 peResP,
646 pbScratchInternal,
647 cbScratchInternal );
648 if (scError!=SYMCRYPT_NO_ERROR)
649 {
650 goto cleanup;
651 }
652
653 // Convert V to a modelement modulo Q
654 SymCryptModElementToInt(
655 pDlgroup->pmP,
656 peResP,
657 piIntP,
658 pbScratchInternal,
659 cbScratchInternal );
660 SymCryptIntDivMod(
661 piIntP,
662 SymCryptDivisorFromModulus( pDlgroup->pmQ ),
663 NULL,
664 piIntQ[0],
665 pbScratchInternal,
666 cbScratchInternal );
667 SymCryptIntToModElement(
668 piIntQ[0],
669 pDlgroup->pmQ,
670 peT,
671 pbScratchInternal,
672 cbScratchInternal );
673
674 // Comparison V = R
675 if (SymCryptModElementIsEqual( pDlgroup->pmQ, peT, peR ))
676 {
677 fValidSignature = TRUE;
678 }
679
680
681cleanup:
682
683 if (!fValidSignature)
684 {
685 scError = SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE;
686 }
687
688 if ( pbScratch != NULL )
689 {
690 SymCryptWipe( pbScratch, cbScratch );
691 SymCryptCallbackFree( pbScratch );
692 }
693
694 return scError;
695}
SymCryptDsaTruncateHash
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaTruncateHash(_In_ PCSYMCRYPT_DLGROUP pDlgroup, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, UINT32 flags, _Out_ PSYMCRYPT_MODELEMENT peMsghash, _Out_ PSYMCRYPT_INT piIntLarge, _Out_ PSYMCRYPT_INT piIntQ, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: dsa.c:13
pmQ
PSYMCRYPT_MODULUS pmQ
Definition: symcrypt_internal.h:2842
pmP
PSYMCRYPT_MODULUS pmP
Definition: symcrypt_internal.h:2841
SymCryptIntToModElement
VOID SYMCRYPT_CALL SymCryptIntToModElement(_In_ PCSYMCRYPT_INT piSrc, _In_ PCSYMCRYPT_MODULUS pmMod, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:749
SYMCRYPT_SCRATCH_BYTES_FOR_MODMULTIEXP
#define SYMCRYPT_SCRATCH_BYTES_FOR_MODMULTIEXP(_nDigits, _nBases, _nBitsExp)
Definition: symcrypt_low_level.h:1882
SymCryptDivisorFromModulus
PSYMCRYPT_DIVISOR SYMCRYPT_CALL SymCryptDivisorFromModulus(_In_ PSYMCRYPT_MODULUS pmSrc)
Definition: a_dispatch.c:703
SYMCRYPT_SCRATCH_BYTES_FOR_INT_DIVMOD
#define SYMCRYPT_SCRATCH_BYTES_FOR_INT_DIVMOD(_nSrcDigits, _nDivisorDigits)
Definition: symcrypt_low_level.h:1131
SymCryptModMul
VOID SYMCRYPT_CALL SymCryptModMul(_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: a_dispatch.c:867
SymCryptModInv
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptModInv(_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, _Out_ PSYMCRYPT_MODELEMENT peDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:948
SymCryptModMultiExp
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptModMultiExp(_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: a_dispatch.c:976
SymCryptIntDivMod
VOID SYMCRYPT_CALL SymCryptIntDivMod(_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: a_dispatch.c:573
SymCryptModulusDigitsizeOfObject
UINT32 SYMCRYPT_CALL SymCryptModulusDigitsizeOfObject(_In_ PCSYMCRYPT_MODULUS pmSrc)
Definition: a_dispatch.c:635
SYMCRYPT_SCRATCH_BYTES_FOR_MODINV
#define SYMCRYPT_SCRATCH_BYTES_FOR_MODINV(_nDigits)
Definition: symcrypt_low_level.h:1804

◆ SymCryptEcbDecrypt()

VOID SYMCRYPT_CALL SymCryptEcbDecrypt ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ PCVOID  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 42 of file blockciphermodes.c.

48{
49 SIZE_T i;
50 SIZE_T cbToDo = cbData & ~(pBlockCipher->blockSize - 1);
51
52 if( pBlockCipher->ecbDecryptFunc != NULL )
53 {
54 //
55 // Use optimized implementation if available
56 //
57 (*pBlockCipher->ecbDecryptFunc)( pExpandedKey, pbSrc, pbDst, cbData );
58 return;
59 }
60
61 for( i=0; i<cbToDo; i+= pBlockCipher->blockSize )
62 {
63 (*pBlockCipher->decryptFunc)( pExpandedKey, pbSrc + i, pbDst + i );
64 }
65}
_SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc
PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB ecbDecryptFunc
Definition: symcrypt_internal.h:1999

◆ SymCryptEcbEncrypt()

VOID SYMCRYPT_CALL SymCryptEcbEncrypt ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ PCVOID  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 11 of file blockciphermodes.c.

17{
18 SIZE_T i;
19 SIZE_T cbToDo = cbData & ~(pBlockCipher->blockSize - 1);
20
21 if( pBlockCipher->ecbEncryptFunc != NULL )
22 {
23 //
24 // Use optimized implementation if available
25 //
26 (*pBlockCipher->ecbEncryptFunc)( pExpandedKey, pbSrc, pbDst, cbData );
27 return;
28 }
29
30 //
31 // To avoid buffer overruns we truncate the work to an integral number of blocks.
32 //
33
34 for( i=0; i<cbToDo; i+= pBlockCipher->blockSize )
35 {
36 (*pBlockCipher->encryptFunc)( pExpandedKey, pbSrc + i, pbDst + i );
37 }
38}
_SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc
PSYMCRYPT_BLOCKCIPHER_CRYPT_ECB ecbEncryptFunc
Definition: symcrypt_internal.h:1998

◆ SymCryptEcDhSecretAgreement()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDhSecretAgreement ( _In_ PCSYMCRYPT_ECKEY  pkPrivate,
_In_ PCSYMCRYPT_ECKEY  pkPublic,
SYMCRYPT_NUMBER_FORMAT  format,
UINT32  flags,
_Out_writes_(cbAgreedSecret) PBYTE  pbAgreedSecret,
SIZE_T  cbAgreedSecret 
)

Definition at line 12 of file ec_dh.c.

19{
20 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
21
22 PBYTE pbScratch = NULL;
23 SIZE_T cbScratch = 0;
24 SIZE_T cbScratchInternal = 0;
25 PBYTE pCurr = NULL;
26
27 PCSYMCRYPT_ECURVE pCurve = NULL;
28
29 PSYMCRYPT_ECPOINT poQ = NULL;
30 PBYTE pbX = NULL;
31
32 UINT32 cbQ = 0;
33 UINT32 cbX = 0;
34
35 // Make sure that the keys may be used in ECDH
36 if ( ((pkPrivate->fAlgorithmInfo & SYMCRYPT_FLAG_ECKEY_ECDH) == 0) ||
37 ((pkPublic->fAlgorithmInfo & SYMCRYPT_FLAG_ECKEY_ECDH) == 0) )
38 {
39 scError = SYMCRYPT_INVALID_ARGUMENT;
40 goto cleanup;
41 }
42
43 // Make sure we only specify the correct flags and that
44 // there is a private key
45 if ( (flags != 0) ||
46 (!pkPrivate->hasPrivateKey) )
47 {
48 scError = SYMCRYPT_INVALID_ARGUMENT;
49 goto cleanup;
50 }
51
52 // Check that the curve is the same for both keys
53 if ( SymCryptEcurveIsSame( pkPrivate->pCurve, pkPublic->pCurve ) )
54 {
55 pCurve = pkPrivate->pCurve;
56 }
57 else
58 {
59 scError = SYMCRYPT_INVALID_ARGUMENT;
60 goto cleanup;
61 }
62
63 // Objects and scratch space size calculation
64 cbQ = SymCryptSizeofEcpointFromCurve( pCurve );
65 cbX = SymCryptEcurveSizeofFieldElement( pCurve );
66
67 // Check the output buffer has the correct size
68 if (cbAgreedSecret != cbX)
69 {
70 scError = SYMCRYPT_WRONG_BLOCK_SIZE;
71 goto cleanup;
72 }
73
74 cbScratchInternal = SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS(pCurve),
75 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_SCALAR_ECURVE_OPERATIONS( pCurve ),
76 SYMCRYPT_SCRATCH_BYTES_FOR_GETSET_VALUE_ECURVE_OPERATIONS( pCurve ) ));
77
78 //
79 // From symcrypt_internal.h we have:
80 // - sizeof results are upper bounded by 2^19
81 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
82 // Thus the following calculation does not overflow cbScratch.
83 //
84 cbScratch = cbScratchInternal + cbQ + cbX;
85
86 // Scratch space allocation
87 pbScratch = SymCryptCallbackAlloc( cbScratch );
88 if ( pbScratch == NULL )
89 {
90 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
91 goto cleanup;
92 }
93
94 // Creating temporaries
95 pCurr = pbScratch + cbScratchInternal;
96 poQ = SymCryptEcpointCreate( pCurr, cbQ, pCurve );
97 pCurr += cbQ;
98 pbX = pCurr;
99
100 SYMCRYPT_ASSERT( poQ != NULL);
101
102 // Make sure that the public key is not the zero point
103 // No need to check that the point is on the curve; that check is done when the
104 // public key is created.
105 if (SymCryptEcpointIsZero(pCurve, pkPublic->poPublicKey, pbScratch, cbScratchInternal))
106 {
107 scError = SYMCRYPT_INVALID_ARGUMENT;
108 goto cleanup;
109 }
110
111 // Calculate the secret
112 // Always do low order clearing by multiplying by the cofactor.
113 // Note: the internal format of piPrivateKey is "DivH", so we
114 // get the correct result.
115 scError = SymCryptEcpointScalarMul(
116 pCurve,
117 pkPrivate->piPrivateKey,
118 pkPublic->poPublicKey,
119 SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL,
120 poQ,
121 pbScratch,
122 cbScratchInternal );
123 if ( scError != SYMCRYPT_NO_ERROR )
124 {
125 goto cleanup;
126 }
127
128 // Check if the result is the identity point
129 if ( SymCryptEcpointIsZero(
130 pCurve,
131 poQ,
132 pbScratch,
133 cbScratchInternal ) )
134 {
135 scError = SYMCRYPT_INVALID_BLOB;
136 goto cleanup;
137 }
138
139 // Get the x from poQ
140 scError = SymCryptEcpointGetValue( pCurve, poQ, format, SYMCRYPT_ECPOINT_FORMAT_X, pbX, cbX, 0, pbScratch, cbScratchInternal);
141 if ( scError != SYMCRYPT_NO_ERROR )
142 {
143 goto cleanup;
144 }
145
146 // Store it in the destination
147 memcpy( pbAgreedSecret, pbX, cbX);
148
149cleanup:
150 if ( pbScratch != NULL )
151 {
152 SymCryptWipe( pbScratch, cbScratch );
153 SymCryptCallbackFree( pbScratch );
154 }
155
156 return scError;
157}
SymCryptEcurveIsSame
BOOLEAN SYMCRYPT_CALL SymCryptEcurveIsSame(_In_ PCSYMCRYPT_ECURVE pCurve1, _In_ PCSYMCRYPT_ECURVE pCurve2)
Definition: ecurve.c:745
SymCryptEcurveSizeofFieldElement
UINT32 SYMCRYPT_CALL SymCryptEcurveSizeofFieldElement(_In_ PCSYMCRYPT_ECURVE pCurve)
Definition: ecurve.c:689
SYMCRYPT_FLAG_ECKEY_ECDH
#define SYMCRYPT_FLAG_ECKEY_ECDH
Definition: symcrypt.h:7596
pCurve
PCSYMCRYPT_ECURVE pCurve
Definition: symcrypt_internal.h:3045
PSYMCRYPT_ECPOINT
SYMCRYPT_ECPOINT * PSYMCRYPT_ECPOINT
Definition: symcrypt_internal.h:2346
PCSYMCRYPT_ECURVE
const SYMCRYPT_ECURVE * PCSYMCRYPT_ECURVE
Definition: symcrypt_internal.h:3007
SymCryptEcpointScalarMul
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcpointScalarMul(_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_INT piScalar, _In_opt_ PCSYMCRYPT_ECPOINT poSrc, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ec_dispatch.c:262
SymCryptEcpointIsZero
UINT32 SYMCRYPT_CALL SymCryptEcpointIsZero(_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ec_dispatch.c:176
SYMCRYPT_SCRATCH_BYTES_FOR_SCALAR_ECURVE_OPERATIONS
#define SYMCRYPT_SCRATCH_BYTES_FOR_SCALAR_ECURVE_OPERATIONS(_pCurve)
Definition: symcrypt_low_level.h:2617
SymCryptEcpointCreate
PSYMCRYPT_ECPOINT SYMCRYPT_CALL SymCryptEcpointCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, _In_ PCSYMCRYPT_ECURVE pCurve)
Definition: ecpoint.c:142
SymCryptSizeofEcpointFromCurve
UINT32 SYMCRYPT_CALL SymCryptSizeofEcpointFromCurve(PCSYMCRYPT_ECURVE pCurve)
Definition: ecpoint.c:41
SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS
#define SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS(_pCurve)
Definition: symcrypt_low_level.h:2428
SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL
#define SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL
Definition: symcrypt_low_level.h:2422
SYMCRYPT_SCRATCH_BYTES_FOR_GETSET_VALUE_ECURVE_OPERATIONS
#define SYMCRYPT_SCRATCH_BYTES_FOR_GETSET_VALUE_ECURVE_OPERATIONS(_pCurve)
Definition: symcrypt_low_level.h:2335
SymCryptEcpointGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcpointGetValue(_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, SYMCRYPT_NUMBER_FORMAT nformat, SYMCRYPT_ECPOINT_FORMAT eformat, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ecpoint.c:705

◆ SymCryptEcDhSecretAgreementSelftest()

VOID SYMCRYPT_CALL SymCryptEcDhSecretAgreementSelftest ( void  )

Referenced by SymCryptEckeySetRandom(), and SymCryptEckeySetValue().

◆ SymCryptEcDsaSelftest()

VOID SYMCRYPT_CALL SymCryptEcDsaSelftest ( void  )

Referenced by SymCryptEckeySetRandom(), and SymCryptEckeySetValue().

◆ SymCryptEcDsaSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaSign ( _In_ PCSYMCRYPT_ECKEY  pKey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
SYMCRYPT_NUMBER_FORMAT  format,
UINT32  flags,
_Out_writes_bytes_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature 
)

Definition at line 408 of file ec_dsa.c.

416{
417 // Make sure that only the correct flags are set
418 if ( (flags & ~SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION) != 0 )
419 {
420 return SYMCRYPT_INVALID_ARGUMENT;
421 }
422
423 // We must have a private key to perform PCT or signature
424 if( !pKey->hasPrivateKey || !(pKey->fAlgorithmInfo & SYMCRYPT_FLAG_ECKEY_ECDSA) )
425 {
426 return SYMCRYPT_INVALID_ARGUMENT;
427 }
428
429 // If the key was generated in SymCrypt and has not yet had a PCT performed - perform PCT before first use
430 SYMCRYPT_RUN_KEY_GEN_PCT(
431 SymCryptEcDsaPct,
432 pKey,
433 SYMCRYPT_PCT_ECDSA );
434
435 return SymCryptEcDsaSignEx( pKey, pbHashValue, cbHashValue, NULL, format, flags, pbSignature, cbSignature );
436}
SymCryptEcDsaSignEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaSignEx(_In_ PCSYMCRYPT_ECKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_opt_ PCSYMCRYPT_INT piK, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
Definition: ec_dsa.c:146
SymCryptEcDsaPct
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaPct(PCSYMCRYPT_ECKEY pkEckey)
SYMCRYPT_FLAG_ECKEY_ECDSA
#define SYMCRYPT_FLAG_ECKEY_ECDSA
Definition: symcrypt.h:7595
SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION
#define SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION
Definition: symcrypt.h:8327
SYMCRYPT_PCT_ECDSA
#define SYMCRYPT_PCT_ECDSA
Definition: symcrypt_internal.h:3474

◆ SymCryptEcDsaVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaVerify ( _In_ PCSYMCRYPT_ECKEY  pKey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
SYMCRYPT_NUMBER_FORMAT  format,
UINT32  flags 
)

Definition at line 440 of file ec_dsa.c.

448{
449 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
450 PBYTE pbScratch = NULL;
451 SIZE_T cbScratch = 0;
452 SIZE_T cbScratchInternal = 0;
453 PBYTE pCurr = NULL;
454 BOOLEAN fValidSignature = FALSE;
455
456 PCSYMCRYPT_ECURVE pCurve = pKey->pCurve;
457
458 PSYMCRYPT_INT piTmp = NULL;
459 PSYMCRYPT_INT piMul1 = NULL;
460 PSYMCRYPT_INT piMul2 = NULL;
461 PSYMCRYPT_ECPOINT poQ1 = NULL;
462 PSYMCRYPT_ECPOINT poQ2 = NULL;
463
464 PSYMCRYPT_MODELEMENT peMsghash = NULL;
465 PSYMCRYPT_MODELEMENT peSigC = NULL;
466 PSYMCRYPT_MODELEMENT peSigD = NULL;
467 PSYMCRYPT_MODELEMENT peTmp = NULL;
468
469 PBYTE pbX = NULL;
470 PCSYMCRYPT_ECPOINT poTable[2] = { 0 };
471 PCSYMCRYPT_INT piTable[2] = { 0 };
472
473 UINT32 nDigitsInt = 0;
474 UINT32 nDigitsMul = 0;
475
476 UINT32 cbInt = 0;
477 UINT32 cbMul = 0;
478 UINT32 cbKG = 0;
479 UINT32 cbRs = 0;
480 UINT32 cbX = 0;
481
482 // Make sure that the key may be used in ECDSA
483 if ( ((pKey->fAlgorithmInfo & SYMCRYPT_FLAG_ECKEY_ECDSA) == 0) )
484 {
485 scError = SYMCRYPT_INVALID_ARGUMENT;
486 goto cleanup;
487 }
488
489 // Make sure that only the correct flags are set
490 if ( (flags & ~SYMCRYPT_FLAG_ECDSA_NO_TRUNCATION) != 0 )
491 {
492 scError = SYMCRYPT_INVALID_ARGUMENT;
493 goto cleanup;
494 }
495
496 // Calculating the digits for the temporary integer
497 nDigitsInt = SYMCRYPT_MAX( pCurve->FModDigits, pCurve->GOrdDigits );
498 nDigitsInt = SYMCRYPT_MAX( nDigitsInt, SymCryptDigitsFromBits( (UINT32)cbSignature * 4 ) ); // pbSignature contains (c,d)
499
500 nDigitsMul = SymCryptEcurveDigitsofScalarMultiplier(pCurve);
501
502 // Objects and scratch space size calculation
503 cbInt = SymCryptSizeofIntFromDigits( nDigitsInt );
504 cbMul = SymCryptSizeofIntFromDigits( nDigitsMul );
505 cbKG = SymCryptSizeofEcpointFromCurve( pCurve );
506 cbRs = SymCryptSizeofModElementFromModulus( pCurve->GOrd );
507 cbX = SymCryptEcurveSizeofFieldElement( pCurve );
508
509 cbScratchInternal = SYMCRYPT_SCRATCH_BYTES_FOR_MULTI_SCALAR_ECURVE_OPERATIONS( pCurve, 2 );
510 cbScratchInternal = SYMCRYPT_MAX( cbScratchInternal, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->GOrdDigits ) );
511 cbScratchInternal = SYMCRYPT_MAX( cbScratchInternal, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pCurve->FModDigits ) );
512 cbScratchInternal = SYMCRYPT_MAX( cbScratchInternal, SYMCRYPT_SCRATCH_BYTES_FOR_MODINV( pCurve->GOrdDigits ) );
513 cbScratchInternal = SYMCRYPT_MAX( cbScratchInternal, SYMCRYPT_SCRATCH_BYTES_FOR_GETSET_VALUE_ECURVE_OPERATIONS( pCurve ) );
514 cbScratchInternal = SYMCRYPT_MAX( cbScratchInternal, SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_ECURVE_OPERATIONS( pCurve ) );
515
516 //
517 // From symcrypt_internal.h we have:
518 // - sizeof results are upper bounded by 2^19
519 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
520 // Thus the following calculation does not overflow cbScratch.
521 //
522 cbScratch = cbScratchInternal + cbInt + 2*cbMul + 2*cbKG + 4*cbRs + cbX;
523
524 // Scratch space allocation
525 pbScratch = SymCryptCallbackAlloc( cbScratch );
526 if ( pbScratch == NULL )
527 {
528 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
529 goto cleanup;
530 }
531
532 // Creating temporaries
533 pCurr = pbScratch + cbScratchInternal;
534 piTmp = SymCryptIntCreate( pCurr, cbInt, nDigitsInt );
535 pCurr += cbInt;
536 piMul1 = SymCryptIntCreate( pCurr, cbMul, nDigitsMul );
537 pCurr += cbMul;
538 piMul2 = SymCryptIntCreate( pCurr, cbMul, nDigitsMul );
539 pCurr += cbMul;
540 poQ1 = SymCryptEcpointCreate( pCurr, cbKG, pCurve );
541 pCurr += cbKG;
542 poQ2 = SymCryptEcpointCreate( pCurr, cbKG, pCurve );
543 pCurr += cbKG;
544 peMsghash = SymCryptModElementCreate( pCurr, cbRs, pCurve->GOrd );
545 pCurr += cbRs;
546 peSigC = SymCryptModElementCreate( pCurr, cbRs, pCurve->GOrd );
547 pCurr += cbRs;
548 peSigD = SymCryptModElementCreate( pCurr, cbRs, pCurve->GOrd );
549 pCurr += cbRs;
550 peTmp = SymCryptModElementCreate( pCurr, cbRs, pCurve->GOrd );
551 pCurr += cbRs;
552 pbX = pCurr;
553
554 SYMCRYPT_ASSERT( piTmp != NULL);
555 SYMCRYPT_ASSERT( piMul1 != NULL);
556 SYMCRYPT_ASSERT( piMul2 != NULL);
557 SYMCRYPT_ASSERT( poQ1 != NULL);
558 SYMCRYPT_ASSERT( poQ2 != NULL);
559 SYMCRYPT_ASSERT( peMsghash != NULL);
560 SYMCRYPT_ASSERT( peSigC != NULL);
561 SYMCRYPT_ASSERT( peSigD != NULL);
562 SYMCRYPT_ASSERT( peTmp != NULL);
563
564 // Get c
565 scError = SymCryptIntSetValue( pbSignature, cbSignature / 2, format, piTmp );
566 if ( scError != SYMCRYPT_NO_ERROR )
567 {
568 goto cleanup;
569 }
570
571 // Check if c is less than r
572 if ( !SymCryptIntIsLessThan( piTmp, SymCryptIntFromModulus( pCurve->GOrd ) ) )
573 {
574 goto cleanup;
575 }
576
577 // c mod r
578 SymCryptIntToModElement( piTmp, pCurve->GOrd, peSigC, pbScratch, cbScratchInternal );
579
580 // Check if c is zero
581 if (SymCryptModElementIsZero( pCurve->GOrd, peSigC ))
582 {
583 goto cleanup;
584 }
585
586 // Get d
587 scError = SymCryptIntSetValue( pbSignature + cbSignature / 2, cbSignature / 2, format, piTmp );
588 if ( scError != SYMCRYPT_NO_ERROR )
589 {
590 goto cleanup;
591 }
592
593 // Check if d is less than r
594 if ( !SymCryptIntIsLessThan( piTmp, SymCryptIntFromModulus( pCurve->GOrd ) ) )
595 {
596 goto cleanup;
597 }
598
599 // d mod r
600 SymCryptIntToModElement( piTmp, pCurve->GOrd, peSigD, pbScratch, cbScratchInternal );
601
602 // Check if d is zero
603 if (SymCryptModElementIsZero( pCurve->GOrd, peSigD ))
604 {
605 goto cleanup;
606 }
607
608 // Calculate 1/d mod r
609 // The D value is not secret; it is part of the signature.
610 // We mark it public to avoid the use of random blinding, which would require a source of randomness
611 // just to verify an ECDSA signature.
612 scError = SymCryptModInv( pCurve->GOrd, peSigD, peSigD, SYMCRYPT_FLAG_DATA_PUBLIC, pbScratch, cbScratchInternal );
613 if( scError != SYMCRYPT_NO_ERROR )
614 {
615 goto cleanup;
616 }
617
618 // Truncate the message according to the flags
619 scError = SymCryptEcDsaTruncateHash(
620 pCurve,
621 pbHashValue,
622 cbHashValue,
623 flags,
624 peMsghash,
625 piTmp,
626 pbScratch,
627 cbScratchInternal );
628 if ( scError != SYMCRYPT_NO_ERROR )
629 {
630 goto cleanup;
631 }
632
633 SymCryptModMul( pCurve->GOrd, peMsghash, peSigD, peMsghash, pbScratch, cbScratchInternal ); // msghash / d = h1
634 SymCryptModMul( pCurve->GOrd, peSigC, peSigD, peTmp, pbScratch, cbScratchInternal ); // c / d = h2
635
636 SymCryptModElementToInt( pCurve->GOrd, peMsghash, piMul1, pbScratch, cbScratchInternal );
637 SymCryptModElementToInt( pCurve->GOrd, peTmp, piMul2, pbScratch, cbScratchInternal );
638
639 // h1*G + h2*W
640 piTable[0] = piMul1;
641 piTable[1] = piMul2;
642
643 poTable[0] = NULL; // The first base point is the generator G of the group
644 poTable[1] = pKey->poPublicKey;
645
646 scError = SymCryptEcpointMultiScalarMul( pCurve, piTable, poTable, 2, SYMCRYPT_FLAG_DATA_PUBLIC, poQ1, pbScratch, cbScratchInternal );
647 if ( scError != SYMCRYPT_NO_ERROR )
648 {
649 goto cleanup;
650 }
651
652 // Check for point at infinity
653 if ( SymCryptEcpointIsZero( pCurve, poQ1, pbScratch, cbScratchInternal ) )
654 {
655 goto cleanup;
656 }
657
658 // Get the x from poQ1
659 scError = SymCryptEcpointGetValue( pCurve, poQ1, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, SYMCRYPT_ECPOINT_FORMAT_X, pbX, cbX, SYMCRYPT_FLAG_DATA_PUBLIC, pbScratch, cbScratchInternal);
660 if ( scError != SYMCRYPT_NO_ERROR )
661 {
662 goto cleanup;
663 }
664
665 // Store it in a big enough INT
666 scError = SymCryptIntSetValue( pbX, cbX, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, piTmp );
667 if ( scError != SYMCRYPT_NO_ERROR )
668 {
669 goto cleanup;
670 }
671
672 SymCryptIntToModElement( piTmp, pCurve->GOrd, peTmp, pbScratch, cbScratchInternal ); // x mod r
673
674 // Comparison c = x
675 if (SymCryptModElementIsEqual( pCurve->GOrd, peSigC, peTmp ))
676 {
677 fValidSignature = TRUE;
678 }
679
680cleanup:
681
682 if (!fValidSignature)
683 {
684 scError = SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE;
685 }
686
687 if ( pbScratch != NULL )
688 {
689 SymCryptWipe( pbScratch, cbScratch );
690 SymCryptCallbackFree( pbScratch );
691 }
692
693 return scError;
694}
SymCryptEcDsaTruncateHash
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaTruncateHash(_In_ PCSYMCRYPT_ECURVE pCurve, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, UINT32 flags, _Out_ PSYMCRYPT_MODELEMENT peMsghash, _Out_ PSYMCRYPT_INT piTmp, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ec_dsa.c:84
PCSYMCRYPT_ECPOINT
const SYMCRYPT_ECPOINT * PCSYMCRYPT_ECPOINT
Definition: symcrypt_internal.h:2347
PCSYMCRYPT_INT
const SYMCRYPT_INT * PCSYMCRYPT_INT
Definition: symcrypt_internal.h:2327
SymCryptEcpointMultiScalarMul
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcpointMultiScalarMul(_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_INT *piSrcScalarArray, _In_ PCSYMCRYPT_ECPOINT *poSrcEcpointArray, UINT32 nPoints, UINT32 flags, _Out_ PSYMCRYPT_ECPOINT poDst, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ec_dispatch.c:279
SYMCRYPT_SCRATCH_BYTES_FOR_MULTI_SCALAR_ECURVE_OPERATIONS
#define SYMCRYPT_SCRATCH_BYTES_FOR_MULTI_SCALAR_ECURVE_OPERATIONS(_pCurve, _nPoints)
Definition: symcrypt_low_level.h:2618
SymCryptEcurveDigitsofScalarMultiplier
UINT32 SYMCRYPT_CALL SymCryptEcurveDigitsofScalarMultiplier(_In_ PCSYMCRYPT_ECURVE pCurve)
Definition: ecurve.c:710

◆ SymCryptEckeyAllocate()

PSYMCRYPT_ECKEY SYMCRYPT_CALL SymCryptEckeyAllocate ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 12 of file eckey.c.

13{
14 PVOID p;
15 SIZE_T cb;
16 PSYMCRYPT_ECKEY res = NULL;
17
18 cb = SymCryptSizeofEckeyFromCurve( pCurve );
19
20 p = SymCryptCallbackAlloc( cb );
21
22 if ( p==NULL )
23 {
24 goto cleanup;
25 }
26
27 res = SymCryptEckeyCreate( p, cb, pCurve );
28
29cleanup:
30 return res;
31}
SymCryptEckeyCreate
PSYMCRYPT_ECKEY SYMCRYPT_CALL SymCryptEckeyCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, PCSYMCRYPT_ECURVE pCurve)
Definition: eckey.c:58
SymCryptSizeofEckeyFromCurve
UINT32 SYMCRYPT_CALL SymCryptSizeofEckeyFromCurve(_In_ PCSYMCRYPT_ECURVE pCurve)
Definition: eckey.c:44
PSYMCRYPT_ECKEY
SYMCRYPT_ECKEY * PSYMCRYPT_ECKEY
Definition: symcrypt_internal.h:3067

◆ SymCryptEckeyCopy()

VOID SymCryptEckeyCopy ( _In_ PCSYMCRYPT_ECKEY  pkSrc,
_Out_ PSYMCRYPT_ECKEY  pkDst 
)

Definition at line 122 of file eckey.c.

125{
126 //
127 // in-place copy is somewhat common...
128 //
129 if( pkSrc != pkDst )
130 {
131 // Copy the fAlgorithmInfo flags
132 pkDst->fAlgorithmInfo = pkSrc->fAlgorithmInfo;
133
134 // Copy the hasPrivateKey flag
135 pkDst->hasPrivateKey = pkSrc->hasPrivateKey;
136
137 // Copy the public key
138 SymCryptEcpointCopy( pkSrc->pCurve, pkSrc->poPublicKey, pkDst->poPublicKey );
139
140 // Copy the private key
141 SymCryptIntCopy( pkSrc->piPrivateKey, pkDst->piPrivateKey );
142 }
143}
SymCryptEcpointCopy
VOID SymCryptEcpointCopy(_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc, _Out_ PSYMCRYPT_ECPOINT poDst)
Definition: ecpoint.c:173

◆ SymCryptEckeyCreate()

PSYMCRYPT_ECKEY SYMCRYPT_CALL SymCryptEckeyCreate ( _Out_writes_bytes_(cbBuffer) PBYTE  pbBuffer,
SIZE_T  cbBuffer,
PCSYMCRYPT_ECURVE  pCurve 
)

Definition at line 58 of file eckey.c.

62{
63 PSYMCRYPT_ECKEY pkObj = NULL;
64 UINT32 privateKeyDigits = SymCryptEcurveDigitsofScalarMultiplier(pCurve);
65
66 SIZE_T cbPublicKey = SymCryptSizeofEcpointFromCurve( pCurve );
67 SIZE_T cbPrivateKey = SymCryptSizeofIntFromDigits( privateKeyDigits );
68
69 UNREFERENCED_PARAMETER( cbBuffer ); // only referenced in ASSERTs...
70
71 SYMCRYPT_ASSERT( pCurve != NULL );
72 SYMCRYPT_ASSERT( cbBuffer >= SymCryptSizeofEckeyFromCurve( pCurve ) );
73
74 SYMCRYPT_ASSERT( cbBuffer >= sizeof(SYMCRYPT_ECKEY) +
75 cbPublicKey +
76 cbPrivateKey );
77
78 SYMCRYPT_ASSERT_ASYM_ALIGNED( pbBuffer );
79
80 pkObj = (PSYMCRYPT_ECKEY) pbBuffer;
81
82 pkObj->fAlgorithmInfo = 0;
83 pkObj->hasPrivateKey = FALSE;
84 pkObj->pCurve = pCurve;
85
86 pkObj->poPublicKey = SymCryptEcpointCreate(
87 pbBuffer + sizeof(SYMCRYPT_ECKEY),
88 cbPublicKey,
89 pCurve );
90 SYMCRYPT_ASSERT( pkObj->poPublicKey != NULL );
91
92 pkObj->piPrivateKey = SymCryptIntCreate(
93 pbBuffer + sizeof(SYMCRYPT_ECKEY) + cbPublicKey,
94 cbPrivateKey,
95 privateKeyDigits );
96 SYMCRYPT_ASSERT( pkObj->piPrivateKey );
97
98 // Setting the magic
99 SYMCRYPT_SET_MAGIC( pkObj );
100
101 return pkObj;
102}
SYMCRYPT_ECKEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_ECKEY
Definition: symcrypt_internal.h:3066

Referenced by SymCryptEckeyAllocate().

◆ SymCryptEckeyExtendKeyUsage()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyExtendKeyUsage ( _Inout_ PSYMCRYPT_ECKEY  pEckey,
UINT32  flags 
)

Definition at line 976 of file eckey.c.

979{
980 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
981
982 // Ensure caller has specified what algorithm(s) the key will be used with
983 UINT32 algorithmFlags = SYMCRYPT_FLAG_ECKEY_ECDSA | SYMCRYPT_FLAG_ECKEY_ECDH;
984
985 if ( ( ( flags & ~algorithmFlags ) != 0 ) ||
986 ( ( flags & algorithmFlags ) == 0) )
987 {
988 scError = SYMCRYPT_INVALID_ARGUMENT;
989 goto cleanup;
990 }
991
992 pEckey->fAlgorithmInfo |= flags;
993
994cleanup:
995 return scError;
996}

◆ SymCryptEckeyFree()

VOID SYMCRYPT_CALL SymCryptEckeyFree ( _Out_ PSYMCRYPT_ECKEY  pkObj)

Definition at line 35 of file eckey.c.

36{
37 SYMCRYPT_CHECK_MAGIC( pkObj );
38 SymCryptEckeyWipe( pkObj );
39 SymCryptCallbackFree( pkObj );
40}
SymCryptEckeyWipe
VOID SYMCRYPT_CALL SymCryptEckeyWipe(_Out_ PSYMCRYPT_ECKEY pkDst)
Definition: eckey.c:115

◆ SymCryptEckeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyGetValue ( _In_ PCSYMCRYPT_ECKEY  pEckey,
_Out_writes_bytes_(cbPrivateKey) PBYTE  pbPrivateKey,
SIZE_T  cbPrivateKey,
_Out_writes_bytes_(cbPublicKey) PBYTE  pbPublicKey,
SIZE_T  cbPublicKey,
SYMCRYPT_NUMBER_FORMAT  numFormat,
SYMCRYPT_ECPOINT_FORMAT  ecPointFormat,
UINT32  flags 
)

Definition at line 581 of file eckey.c.

592{
593 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
594 PBYTE pbScratch = NULL;
595 UINT32 cbScratch = 0;
596 PBYTE pbScratchInternal = NULL;
597 UINT32 cbScratchInternal = 0;
598
599 PCSYMCRYPT_ECURVE pCurve = pEckey->pCurve;
600
601 PSYMCRYPT_INT piTmpInteger = NULL;
602 UINT32 cbTmpInteger = 0;
603 PSYMCRYPT_MODELEMENT peTmpModElement = NULL;
604 UINT32 cbTmpModElement = pCurve->cbModElement;
605
606 UINT32 privateKeyDigits = SymCryptEcurveDigitsofScalarMultiplier(pCurve);
607
608 SYMCRYPT_ASSERT( (cbPrivateKey==0) || (cbPrivateKey == SymCryptEcurveSizeofScalarMultiplier( pEckey->pCurve )) );
609 SYMCRYPT_ASSERT( (cbPublicKey==0) || (cbPublicKey == SymCryptEckeySizeofPublicKey( pEckey, ecPointFormat)) );
610
611 // Make sure we only specify the correct flags
612 if (flags != 0)
613 {
614 scError = SYMCRYPT_INVALID_ARGUMENT;
615 goto cleanup;
616 }
617
618 // Allocate scratch space
619 cbScratch = SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_ECKEY_ECURVE_OPERATIONS( pCurve );
620 pbScratch = SymCryptCallbackAlloc( cbScratch );
621 if ( pbScratch == NULL )
622 {
623 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
624 goto cleanup;
625 }
626
627 pbScratchInternal = pbScratch;
628 cbScratchInternal = cbScratch;
629
630 // Allocate the integer
631 cbTmpInteger = SymCryptSizeofIntFromDigits( privateKeyDigits );
632 piTmpInteger = SymCryptIntCreate( pbScratchInternal, cbTmpInteger, privateKeyDigits );
633 SYMCRYPT_ASSERT( piTmpInteger != NULL );
634
635 pbScratchInternal += cbTmpInteger;
636 cbScratchInternal -= cbTmpInteger;
637
638 // Allocate the modelement
639 peTmpModElement = SymCryptModElementCreate( pbScratchInternal, cbTmpModElement, pCurve->GOrd );
640 SYMCRYPT_ASSERT( peTmpModElement != NULL );
641
642 pbScratchInternal += cbTmpModElement;
643 cbScratchInternal -= cbTmpModElement;
644
645 if ((cbPrivateKey == 0) && (cbPublicKey == 0))
646 {
647 scError = SYMCRYPT_INVALID_ARGUMENT;
648 goto cleanup;
649 }
650
651 if (cbPrivateKey != 0)
652 {
653 if (!pEckey->hasPrivateKey)
654 {
655 scError = SYMCRYPT_INVALID_BLOB;
656 goto cleanup;
657 }
658
659 // If this keypair may be used in ECDSA, and does not have the no FIPS flag, run the PCT if
660 // it has not already been run
661 if ( ((pEckey->fAlgorithmInfo & SYMCRYPT_FLAG_ECKEY_ECDSA) != 0) &&
662 ((pEckey->fAlgorithmInfo & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0) )
663 {
664 SYMCRYPT_RUN_KEY_GEN_PCT(
665 SymCryptEcDsaPct,
666 pEckey,
667 SYMCRYPT_PCT_ECDSA );
668 }
669
670 // Copy the key into the temporary integer
671 SymCryptIntCopy( pEckey->piPrivateKey, piTmpInteger );
672
673 // Convert the "DivH" format into the external format
674 if (pCurve->coFactorPower>0)
675 {
676 // For the "Canonical" format: Multiply the integer by h
677 // and then take the result modulo GOrd
678 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL)
679 {
680 SymCryptIntMulPow2( piTmpInteger, pCurve->coFactorPower, piTmpInteger );
681 SymCryptIntDivMod(
682 piTmpInteger,
683 SymCryptDivisorFromModulus(pCurve->GOrd),
684 NULL,
685 piTmpInteger,
686 pbScratchInternal,
687 cbScratchInternal );
688 }
689
690 // For the "TimesH" format: Multiply the integer by h again by shifting
691 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH)
692 {
693 SymCryptIntMulPow2( piTmpInteger, pCurve->coFactorPower, piTmpInteger );
694 }
695 }
696
697 scError = SymCryptIntGetValue( piTmpInteger, pbPrivateKey, cbPrivateKey, numFormat );
698 if (scError != SYMCRYPT_NO_ERROR)
699 {
700 goto cleanup;
701 }
702 }
703
704 if (cbPublicKey != 0)
705 {
706 scError = SymCryptEcpointGetValue(
707 pCurve,
708 pEckey->poPublicKey,
709 numFormat,
710 ecPointFormat,
711 pbPublicKey,
712 cbPublicKey,
713 SYMCRYPT_FLAG_DATA_PUBLIC,
714 pbScratch,
715 cbScratch );
716 }
717
718cleanup:
719
720 if ( pbScratch != NULL )
721 {
722 SymCryptWipe( pbScratch, cbScratch );
723 SymCryptCallbackFree( pbScratch );
724 }
725
726 return scError;
727}
SymCryptEckeySizeofPublicKey
UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPublicKey(_In_ PCSYMCRYPT_ECKEY pkEckey, _In_ SYMCRYPT_ECPOINT_FORMAT ecPointFormat)
Definition: eckey.c:147
SymCryptEcurveSizeofScalarMultiplier
UINT32 SYMCRYPT_CALL SymCryptEcurveSizeofScalarMultiplier(_In_ PCSYMCRYPT_ECURVE pCurve)
Definition: ecurve.c:696
SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_ECKEY_ECURVE_OPERATIONS
#define SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_ECKEY_ECURVE_OPERATIONS(_pCurve)
Definition: symcrypt_internal.h:3038
SymCryptIntMulPow2
VOID SYMCRYPT_CALL SymCryptIntMulPow2(_In_ PCSYMCRYPT_INT piSrc, SIZE_T exp, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:354

◆ SymCryptEckeyHasPrivateKey()

BOOLEAN SYMCRYPT_CALL SymCryptEckeyHasPrivateKey ( _In_ PCSYMCRYPT_ECKEY  pkEckey)

Definition at line 171 of file eckey.c.

172{
173 return pkEckey->hasPrivateKey;
174}

◆ SymCryptEckeySetRandom()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetRandom ( _In_ UINT32  flags,
_Inout_ PSYMCRYPT_ECKEY  pEckey 
)

Definition at line 733 of file eckey.c.

736{
737 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
738 PBYTE pbScratch = NULL;
739 UINT32 cbScratch = 0;
740 PBYTE pbScratchInternal = NULL;
741 UINT32 cbScratchInternal = 0;
742
743 PCSYMCRYPT_ECURVE pCurve = pEckey->pCurve;
744
745 PSYMCRYPT_ECPOINT poTmp = NULL;
746 UINT32 cbTmp = 0;
747
748 INT32 cntr = SYMCRYPT_ECPOINT_SET_RANDOM_MAX_TRIES;
749
750 PSYMCRYPT_MODELEMENT peScalar = NULL;
751 PSYMCRYPT_INT piScalar = NULL;
752 UINT32 cbScalar = 0;
753
754 UINT32 highBitRestrictionPosition = pCurve->HighBitRestrictionPosition;
755
756 // Ensure caller has specified what algorithm(s) the key will be used with
757 UINT32 algorithmFlags = SYMCRYPT_FLAG_ECKEY_ECDSA | SYMCRYPT_FLAG_ECKEY_ECDH;
758 // Make sure only allowed flags are specified
759 UINT32 allowedFlags = SYMCRYPT_FLAG_KEY_NO_FIPS | algorithmFlags;
760
761 if ( ( ( flags & ~allowedFlags ) != 0 ) ||
762 ( ( flags & algorithmFlags ) == 0 ) )
763 {
764 scError = SYMCRYPT_INVALID_ARGUMENT;
765 goto cleanup;
766 }
767
768 //
769 // From symcrypt_internal.h we have:
770 // - sizeof results are upper bounded by 2^19
771 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
772 // Thus the following calculation does not overflow cbScratch.
773 //
774 cbScratch = SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_ECKEY_ECURVE_OPERATIONS( pCurve );
775 pbScratch = SymCryptCallbackAlloc( cbScratch );
776 if ( pbScratch == NULL )
777 {
778 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
779 goto cleanup;
780 }
781
782 // Allocating temporaries
783 pbScratchInternal = pbScratch;
784 cbScratchInternal = cbScratch;
785
786 peScalar = SymCryptModElementCreate( pbScratchInternal, pCurve->cbModElement, pCurve->GOrd );
787 SYMCRYPT_ASSERT( peScalar != NULL );
788
789 pbScratchInternal += pCurve->cbModElement;
790 cbScratchInternal -= pCurve->cbModElement;
791
792 cbScalar = SymCryptSizeofIntFromDigits( SymCryptEcurveDigitsofScalarMultiplier(pCurve) );
793 piScalar = SymCryptIntCreate( pbScratchInternal, cbScalar, SymCryptEcurveDigitsofScalarMultiplier(pCurve) );
794
795 pbScratchInternal += cbScalar;
796 cbScratchInternal -= cbScalar;
797
798 // Shift the high bit position if the format is "TIMESH"
799 // Note: Do not actually multiply the integer as we will check if it is
800 // less than the group order
801 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH)
802 {
803 highBitRestrictionPosition -= pCurve->coFactorPower;
804 }
805
806 // Main loop
807 do
808 {
809 // We perform Private key range validation by construction
810 // Setting a random mod element in the [1, SubgroupOrder-1] set
811 // This will be the "DivH" format of the private key. This means
812 // that PublicKey = h * PrivateKey * G
813 SymCryptModSetRandom(
814 pCurve->GOrd,
815 peScalar,
816 (SYMCRYPT_FLAG_MODRANDOM_ALLOW_ONE|SYMCRYPT_FLAG_MODRANDOM_ALLOW_MINUSONE),
817 pbScratchInternal,
818 cbScratchInternal );
819
820 // Converting to "canonical" format
821 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL)
822 {
823 for (UINT32 i=0; i<pCurve->coFactorPower; i++)
824 {
825 SymCryptModAdd( pCurve->GOrd, peScalar, peScalar, peScalar, pbScratchInternal, cbScratchInternal );
826 }
827 }
828
829 // Set the temporary scalar to verify the format
830 SymCryptModElementToInt( pCurve->GOrd, peScalar, piScalar, pbScratchInternal, cbScratchInternal );
831
832 if (pCurve->HighBitRestrictionNumOfBits > 0)
833 {
834 // Set the desired bits
835 SymCryptIntSetBits(
836 piScalar,
837 pCurve->HighBitRestrictionValue,
838 highBitRestrictionPosition,
839 pCurve->HighBitRestrictionNumOfBits );
840
841 // Make sure we didn't exceed the group order
842 if ( SymCryptIntIsLessThan(
843 piScalar,
844 SymCryptIntFromModulus( pCurve->GOrd )) )
845 {
846 break;
847 }
848 }
849 else
850 {
851 // No high bit restriction was specified
852 break;
853 }
854
855 cntr--;
856 }
857 while (cntr>0);
858
859 if (cntr <= 0)
860 {
861 scError = SYMCRYPT_INVALID_ARGUMENT;
862 goto cleanup;
863 }
864
865 // Here piScalar has a private key that satisfies the restriction(s)
866 // Move it to the modelement
867 SymCryptIntToModElement( piScalar, pCurve->GOrd, peScalar, pbScratchInternal, cbScratchInternal );
868
869 // Convert the private key back to "DIVH" format
870 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL)
871 {
872 SymCryptModDivPow2( pCurve->GOrd, peScalar, pCurve->coFactorPower, peScalar, pbScratchInternal, cbScratchInternal );
873 }
874
875 // Set the private key
876 SymCryptModElementToInt( pCurve->GOrd, peScalar, pEckey->piPrivateKey, pbScratchInternal, cbScratchInternal );
877
878 // Do the multiplication (pass over the entire scratch space as it is not needed anymore)
879 scError = SymCryptEcpointScalarMul(
880 pCurve,
881 pEckey->piPrivateKey,
882 NULL,
883 SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL,
884 pEckey->poPublicKey,
885 pbScratch,
886 cbScratch );
887 if ( scError != SYMCRYPT_NO_ERROR )
888 {
889 goto cleanup;
890 }
891
892 // Perform range and public key order validation on generated Public key.
893 if ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 )
894 {
895 // Perform Public key validation.
896 // Always perform range validation and validation that Public key is in subgroup of order GOrd
897 scError = SymCryptEckeyPerformPublicKeyValidation(
898 pEckey,
899 SYMCRYPT_FLAG_ECKEY_PUBLIC_KEY_ORDER_VALIDATION,
900 pbScratch,
901 cbScratch );
902 if ( scError != SYMCRYPT_NO_ERROR )
903 {
904 goto cleanup;
905 }
906 }
907
908 pEckey->hasPrivateKey = TRUE;
909
910 pEckey->fAlgorithmInfo = flags; // We want to track all of the flags in the Eckey
911
912 if ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 )
913 {
914 if( ( flags & SYMCRYPT_FLAG_ECKEY_ECDSA ) != 0 )
915 {
916 // Ensure ECDSA algorithm selftest is run before first use of ECDSA algorithm
917 SYMCRYPT_RUN_SELFTEST_ONCE(
918 SymCryptEcDsaSelftest,
919 SYMCRYPT_SELFTEST_ALGORITHM_ECDSA );
920 }
921
922 if( ( flags & SYMCRYPT_FLAG_ECKEY_ECDH ) != 0 )
923 {
924 // Ensure we have run the algorithm selftest at least once.
925 SYMCRYPT_RUN_SELFTEST_ONCE(
926 SymCryptEcDhSecretAgreementSelftest,
927 SYMCRYPT_SELFTEST_ALGORITHM_ECDH );
928
929 // Run PCT eagerly so it only needs to be defined here
930 // The important case for performance is ECDH key generation
931
932 // ECDH PCT per SP80056a-rev3 5.6.2.1.4 b)
933 // Recompute the public key from the private key
934 // Option a) appears to be explicitly overruled by 140-3 IG
935 pbScratchInternal = pbScratch;
936 cbScratchInternal = cbScratch;
937
938 cbTmp = SymCryptSizeofEcpointFromCurve( pCurve );
939 poTmp = SymCryptEcpointCreate( pbScratchInternal, cbTmp, pCurve );
940 pbScratchInternal += cbTmp;
941 cbScratchInternal -= cbTmp;
942
943 SYMCRYPT_ASSERT( poTmp != NULL );
944
945 // Always multiply by the cofactor since the internal format is "DIVH"
946 scError = SymCryptEcpointScalarMul(
947 pCurve,
948 pEckey->piPrivateKey,
949 NULL,
950 SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL,
951 poTmp,
952 pbScratchInternal,
953 cbScratchInternal );
954 if ( scError != SYMCRYPT_NO_ERROR )
955 {
956 goto cleanup;
957 }
958
959 SYMCRYPT_FIPS_ASSERT( SymCryptEcpointIsEqual( pCurve, poTmp, pEckey->poPublicKey, 0, pbScratchInternal, cbScratchInternal ) );
960 }
961 }
962
963cleanup:
964
965 if ( pbScratch != NULL )
966 {
967 SymCryptWipe( pbScratch, cbScratch );
968 SymCryptCallbackFree( pbScratch );
969 }
970
971 return scError;
972}
SYMCRYPT_FLAG_ECKEY_PUBLIC_KEY_ORDER_VALIDATION
#define SYMCRYPT_FLAG_ECKEY_PUBLIC_KEY_ORDER_VALIDATION
Definition: eckey.c:176
SymCryptEckeyPerformPublicKeyValidation
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyPerformPublicKeyValidation(_In_ PCSYMCRYPT_ECKEY pEckey, _In_ UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: eckey.c:180
SYMCRYPT_ECPOINT_SET_RANDOM_MAX_TRIES
#define SYMCRYPT_ECPOINT_SET_RANDOM_MAX_TRIES
Definition: eckey.c:729
SymCryptEcDsaSelftest
VOID SYMCRYPT_CALL SymCryptEcDsaSelftest(void)
SymCryptEcDhSecretAgreementSelftest
VOID SYMCRYPT_CALL SymCryptEcDhSecretAgreementSelftest(void)
SYMCRYPT_SELFTEST_ALGORITHM_ECDH
@ SYMCRYPT_SELFTEST_ALGORITHM_ECDH
Definition: symcrypt_internal.h:3430
SYMCRYPT_SELFTEST_ALGORITHM_ECDSA
@ SYMCRYPT_SELFTEST_ALGORITHM_ECDSA
Definition: symcrypt_internal.h:3427
SymCryptIntSetBits
VOID SYMCRYPT_CALL SymCryptIntSetBits(_In_ PSYMCRYPT_INT piDst, UINT32 value, UINT32 iBit, UINT32 nBits)
Definition: a_dispatch.c:413
SymCryptModAdd
VOID SYMCRYPT_CALL SymCryptModAdd(_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: a_dispatch.c:838
SymCryptEcpointIsEqual
UINT32 SYMCRYPT_CALL SymCryptEcpointIsEqual(_In_ PCSYMCRYPT_ECURVE pCurve, _In_ PCSYMCRYPT_ECPOINT poSrc1, _In_ PCSYMCRYPT_ECPOINT poSrc2, UINT32 flags, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ec_dispatch.c:161
SymCryptModDivPow2
VOID SYMCRYPT_CALL SymCryptModDivPow2(_In_ PCSYMCRYPT_MODULUS pmMod, _In_ PCSYMCRYPT_MODELEMENT peSrc, UINT32 exp, _Out_ PSYMCRYPT_MODELEMENT peDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:934
INT32
int32_t INT32
Definition: typedefs.h:58

◆ SymCryptEckeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetValue ( _In_reads_bytes_(cbPrivateKey) PCBYTE  pbPrivateKey,
SIZE_T  cbPrivateKey,
_In_reads_bytes_(cbPublicKey) PCBYTE  pbPublicKey,
SIZE_T  cbPublicKey,
SYMCRYPT_NUMBER_FORMAT  numFormat,
SYMCRYPT_ECPOINT_FORMAT  ecPointFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_ECKEY  pEckey 
)

Definition at line 261 of file eckey.c.

272{
273 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
274 PBYTE pbScratch = NULL;
275 UINT32 cbScratch = 0;
276 PBYTE pbScratchInternal = NULL;
277 UINT32 cbScratchInternal = 0;
278
279 PCSYMCRYPT_ECURVE pCurve = pEckey->pCurve;
280
281 PSYMCRYPT_ECPOINT poTmp = NULL;
282 UINT32 cbTmp = 0;
283
284 PSYMCRYPT_INT piTmpInteger = NULL;
285 UINT32 cbTmpInteger = 0;
286 PSYMCRYPT_MODELEMENT peTmpModElement = NULL;
287 UINT32 cbTmpModElement = pCurve->cbModElement;
288
289 UINT32 privateKeyDigits = SymCryptEcurveDigitsofScalarMultiplier(pCurve);
290
291 UINT32 fValidatePublicKeyOrder = SYMCRYPT_FLAG_ECKEY_PUBLIC_KEY_ORDER_VALIDATION;
292
293 // Ensure caller has specified what algorithm(s) the key will be used with
294 UINT32 algorithmFlags = SYMCRYPT_FLAG_ECKEY_ECDSA | SYMCRYPT_FLAG_ECKEY_ECDH;
295 // Make sure only allowed flags are specified
296 UINT32 allowedFlags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION | algorithmFlags;
297
298 if ( ( ( flags & ~allowedFlags ) != 0 ) ||
299 ( ( flags & algorithmFlags ) == 0 ) )
300 {
301 scError = SYMCRYPT_INVALID_ARGUMENT;
302 goto cleanup;
303 }
304
305 // Check that minimal validation flag only specified with no fips
306 if ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
307 ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) != 0 ) )
308 {
309 scError = SYMCRYPT_INVALID_ARGUMENT;
310 goto cleanup;
311 }
312
313 if ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) != 0 )
314 {
315 fValidatePublicKeyOrder = 0;
316 }
317
318 if ( ( ( cbPrivateKey == 0 ) && ( cbPublicKey == 0 ) ) ||
319 ( ( cbPrivateKey != 0 ) && ( cbPrivateKey != SymCryptEcurveSizeofScalarMultiplier( pEckey->pCurve ) ) ) ||
320 ( ( cbPublicKey != 0 ) && ( cbPublicKey != SymCryptEckeySizeofPublicKey( pEckey, ecPointFormat ) ) ) )
321 {
322 scError = SYMCRYPT_INVALID_ARGUMENT;
323 goto cleanup;
324 }
325
326 // Allocate scratch space
327 cbScratch = SYMCRYPT_INTERNAL_SCRATCH_BYTES_FOR_ECKEY_ECURVE_OPERATIONS( pCurve );
328 pbScratch = SymCryptCallbackAlloc( cbScratch );
329 if ( pbScratch == NULL )
330 {
331 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
332 goto cleanup;
333 }
334
335 if ( pbPrivateKey != NULL )
336 {
337 //
338 // Private key calculations
339 //
340
341 pbScratchInternal = pbScratch;
342 cbScratchInternal = cbScratch;
343
344 // Allocate the integer
345 cbTmpInteger = SymCryptSizeofIntFromDigits( privateKeyDigits );
346 piTmpInteger = SymCryptIntCreate( pbScratchInternal, cbTmpInteger, privateKeyDigits );
347 SYMCRYPT_ASSERT( piTmpInteger != NULL );
348
349 pbScratchInternal += cbTmpInteger;
350 cbScratchInternal -= cbTmpInteger;
351
352 // Allocate the modelement
353 peTmpModElement = SymCryptModElementCreate( pbScratchInternal, cbTmpModElement, pCurve->GOrd );
354 SYMCRYPT_ASSERT( peTmpModElement != NULL );
355
356 pbScratchInternal += cbTmpModElement;
357 cbScratchInternal -= cbTmpModElement;
358
359 // Get the "raw" private key
360 scError = SymCryptIntSetValue( pbPrivateKey, cbPrivateKey, numFormat, piTmpInteger );
361 if (scError != SYMCRYPT_NO_ERROR)
362 {
363 goto cleanup;
364 }
365
366 // Validation steps
367 if ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) == 0 )
368 {
369 // Perform range validation on imported Private key if it is in canonical format
370 if ( pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL )
371 {
372 // Check if Private key is greater than or equal to GOrd
373 if ( !SymCryptIntIsLessThan( piTmpInteger, SymCryptIntFromModulus( pCurve->GOrd ) ) )
374 {
375 scError = SYMCRYPT_INVALID_ARGUMENT;
376 goto cleanup;
377 }
378 }
379
380 // "TimesH" formats
381 // IntGetBits requirements:
382 // We know that coFactorPower is up to SYMCRYPT_ECURVE_MAX_COFACTOR_POWER. Thus
383 // less than 32 and less than the digits size in bits.
384 if ( (pCurve->coFactorPower>0) &&
385 (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH) &&
386 (SymCryptIntGetBits( piTmpInteger, 0, pCurve->coFactorPower) != 0) )
387 {
388 scError = SYMCRYPT_INVALID_ARGUMENT;
389 goto cleanup;
390 }
391
392
393 // High bit restrictions
394 // IntGetBits requirements:
395 // Satisfied by asserting that
396 // HighBitRestrictionPosition + HighBitRestrictionNumOfBits <= GOrdBitsize + coFactorPower
397 // during EcurveAllocate.
398 if ( (pCurve->HighBitRestrictionNumOfBits>0) &&
399 (SymCryptIntGetBits(
400 piTmpInteger,
401 pCurve->HighBitRestrictionPosition,
402 pCurve->HighBitRestrictionNumOfBits) != pCurve->HighBitRestrictionValue) )
403 {
404 scError = SYMCRYPT_INVALID_ARGUMENT;
405 goto cleanup;
406 }
407 }
408
409 // Convert the private key to "DivH" format
410 if (pCurve->coFactorPower>0)
411 {
412 // "TimesH" format: Divide the input private key with the cofactor
413 // by shifting right the appropriate number of bits
414 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_DIVH_TIMESH)
415 {
416 SymCryptIntDivPow2( piTmpInteger, pCurve->coFactorPower, piTmpInteger );
417 }
418
419 // "Canonical" format: Divide by h modulo GOrd
420 if (pCurve->PrivateKeyDefaultFormat == SYMCRYPT_ECKEY_PRIVATE_FORMAT_CANONICAL)
421 {
422 SymCryptIntToModElement( piTmpInteger, pCurve->GOrd, peTmpModElement, pbScratchInternal, cbScratchInternal );
423 SymCryptModDivPow2( pCurve->GOrd, peTmpModElement, pCurve->coFactorPower, peTmpModElement, pbScratchInternal, cbScratchInternal );
424 SymCryptModElementToInt( pCurve->GOrd, peTmpModElement, piTmpInteger, pbScratchInternal, cbScratchInternal );
425 }
426 }
427
428 // Divide the input private key since it could be larger than subgroup order
429 SymCryptIntDivMod(
430 piTmpInteger,
431 SymCryptDivisorFromModulus(pCurve->GOrd),
432 NULL,
433 piTmpInteger,
434 pbScratchInternal,
435 cbScratchInternal );
436
437 // Check if Private key is 0 after dividing it by the subgroup order
438 // Other part of range validation - perform unconditionally as it is cheap
439 // and it never makes sense for private key to be 0 intentionally
440 if (SymCryptIntIsEqualUint32( piTmpInteger, 0 ))
441 {
442 scError = SYMCRYPT_INVALID_ARGUMENT;
443 goto cleanup;
444 }
445
446 // Copy into the ECKEY
447 SymCryptIntCopy( piTmpInteger, pEckey->piPrivateKey );
448
449 pEckey->hasPrivateKey = TRUE;
450 }
451
452 if ( pbPublicKey != NULL )
453 {
454 scError = SymCryptEcpointSetValue(
455 pCurve,
456 pbPublicKey,
457 cbPublicKey,
458 numFormat,
459 ecPointFormat,
460 pEckey->poPublicKey,
461 SYMCRYPT_FLAG_DATA_PUBLIC,
462 pbScratch,
463 cbScratch );
464 if ( scError != SYMCRYPT_NO_ERROR )
465 {
466 goto cleanup;
467 }
468
469 // Perform Public key validation on imported Public key.
470 if ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) == 0 )
471 {
472 scError = SymCryptEckeyPerformPublicKeyValidation(
473 pEckey,
474 fValidatePublicKeyOrder,
475 pbScratch,
476 cbScratch );
477 if ( scError != SYMCRYPT_NO_ERROR )
478 {
479 goto cleanup;
480 }
481 }
482 }
483
484 // Calculating the public key if no key was provided
485 // or if needed for keypair regeneration validation
486 if ( (pbPublicKey==NULL) ||
487 ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
488 (pbPrivateKey!=NULL) && (pbPublicKey!=NULL) ) )
489 {
490 // Calculate the public key from the private key
491 pbScratchInternal = pbScratch;
492 cbScratchInternal = cbScratch;
493
494 // By default calculate the Public key directly where it will be persisted
495 poTmp = pEckey->poPublicKey;
496
497 if ( pbPublicKey != NULL )
498 {
499 // If doing regeneration validation calculate the Public key in scratch
500 cbTmp = SymCryptSizeofEcpointFromCurve( pCurve );
501 poTmp = SymCryptEcpointCreate( pbScratchInternal, cbTmp, pCurve );
502 pbScratchInternal += cbTmp;
503 cbScratchInternal -= cbTmp;
504 }
505
506 SYMCRYPT_ASSERT( poTmp != NULL );
507
508 // Always multiply by the cofactor since the internal format is "DIVH"
509 scError = SymCryptEcpointScalarMul(
510 pCurve,
511 pEckey->piPrivateKey,
512 NULL,
513 SYMCRYPT_FLAG_ECC_LL_COFACTOR_MUL,
514 poTmp,
515 pbScratchInternal,
516 cbScratchInternal );
517 if ( scError != SYMCRYPT_NO_ERROR )
518 {
519 goto cleanup;
520 }
521
522 if ( pbPublicKey != NULL )
523 {
524 if ( !SymCryptEcpointIsEqual( pCurve, poTmp, pEckey->poPublicKey, 0, pbScratchInternal, cbScratchInternal ) )
525 {
526 scError = SYMCRYPT_INVALID_ARGUMENT;
527 goto cleanup;
528 }
529 }
530 else if ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) == 0 )
531 {
532 // Perform Public key validation on generated Public key.
533 scError = SymCryptEckeyPerformPublicKeyValidation(
534 pEckey,
535 fValidatePublicKeyOrder,
536 pbScratch,
537 cbScratch );
538 if ( scError != SYMCRYPT_NO_ERROR )
539 {
540 goto cleanup;
541 }
542 }
543 }
544
545 pEckey->fAlgorithmInfo = flags; // We want to track all of the flags in the Eckey
546
547 if ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 )
548 {
549 if ( ( flags & SYMCRYPT_FLAG_ECKEY_ECDSA ) != 0 )
550 {
551 // Ensure ECDSA algorithm selftest is run before first use of ECDSA algorithm
552 SYMCRYPT_RUN_SELFTEST_ONCE(
553 SymCryptEcDsaSelftest,
554 SYMCRYPT_SELFTEST_ALGORITHM_ECDSA );
555
556 // PCT does not need to be run on import - mark it as done
557 pEckey->fAlgorithmInfo |= SYMCRYPT_PCT_ECDSA;
558 }
559
560 if ( ( flags & SYMCRYPT_FLAG_ECKEY_ECDH ) != 0 )
561 {
562 SYMCRYPT_RUN_SELFTEST_ONCE(
563 SymCryptEcDhSecretAgreementSelftest,
564 SYMCRYPT_SELFTEST_ALGORITHM_ECDH );
565 }
566 }
567
568cleanup:
569
570 if ( pbScratch != NULL )
571 {
572 SymCryptWipe( pbScratch, cbScratch );
573 SymCryptCallbackFree( pbScratch );
574 }
575
576 return scError;
577}
SymCryptEcpointSetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcpointSetValue(_In_ PCSYMCRYPT_ECURVE pCurve, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT nformat, SYMCRYPT_ECPOINT_FORMAT eformat, _Out_ PSYMCRYPT_ECPOINT poDst, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: ecpoint.c:605
SymCryptIntDivPow2
VOID SYMCRYPT_CALL SymCryptIntDivPow2(_In_ PCSYMCRYPT_INT piSrc, SIZE_T exp, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:364
SymCryptIntGetBits
UINT32 SYMCRYPT_CALL SymCryptIntGetBits(_In_ PCSYMCRYPT_INT piSrc, UINT32 iBit, UINT32 nBits)
Definition: a_dispatch.c:403

◆ SymCryptEckeySizeofPrivateKey()

UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPrivateKey ( _In_ PCSYMCRYPT_ECKEY  pkEckey)

Definition at line 164 of file eckey.c.

165{
166 return SymCryptEcurveSizeofScalarMultiplier( pkEckey->pCurve );
167}

◆ SymCryptEckeySizeofPublicKey()

UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPublicKey ( _In_ PCSYMCRYPT_ECKEY  pkEckey,
_In_ SYMCRYPT_ECPOINT_FORMAT  ecPointFormat 
)

Definition at line 147 of file eckey.c.

150{
151 //
152 // From symcrypt_internal.h we have:
153 // - sizeof results are upper bounded by 2^19
154 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
155 // - SymCryptEcpointFormatNumberofElements returns up to 4 elements.
156 //
157 // Thus the following calculation does not overflow cbScratch.
158 //
159 return SymCryptEcpointFormatNumberofElements[ecPointFormat] * SymCryptEcurveSizeofFieldElement( pkEckey->pCurve );
160}
SymCryptEcpointFormatNumberofElements
const UINT32 SymCryptEcpointFormatNumberofElements[]
Definition: ecpoint.c:11

Referenced by SymCryptEckeyGetValue(), and SymCryptEckeySetValue().

◆ SymCryptEckeyWipe()

VOID SYMCRYPT_CALL SymCryptEckeyWipe ( _Out_ PSYMCRYPT_ECKEY  pkDst)

Definition at line 115 of file eckey.c.

116{
117 // Wipe the whole structure in one go.
118 SymCryptWipe( pkDst, SymCryptSizeofEckeyFromCurve( pkDst->pCurve ) );
119}

Referenced by SymCryptEckeyFree().

◆ SymCryptEcurveAllocate()

PSYMCRYPT_ECURVE SYMCRYPT_CALL SymCryptEcurveAllocate ( _In_ PCSYMCRYPT_ECURVE_PARAMS  pParams,
_In_ UINT32  flags 
)

Definition at line 606 of file ecurve.c.

609{
610 SYMCRYPT_ECURVE_SIZES sizes;
611
612 PBYTE pbCurve = NULL;
613 PBYTE pbScratch = NULL;
614
615 PSYMCRYPT_ECURVE pCurve = NULL;
616
617 if ( !SymCryptEcurveValidateAndComputeSizes(pParams, &sizes) )
618 {
619 goto cleanup;
620 }
621
622 pbCurve = SymCryptCallbackAlloc( sizes.cbAlloc );
623 if ( pbCurve == NULL )
624 {
625 goto cleanup;
626 }
627
628 pbScratch = SymCryptCallbackAlloc( sizes.cbScratch );
629 if ( pbScratch == NULL )
630 {
631 goto cleanup;
632 }
633
634 pCurve = SymCryptEcurveInitialize( pParams, flags, &sizes, pbCurve, pbScratch );
635 if ( pCurve != NULL )
636 {
637 pbCurve = NULL;
638 }
639
640cleanup:
641 if ( pbScratch != NULL )
642 {
643 SymCryptWipe( pbScratch, sizes.cbScratch );
644 SymCryptCallbackFree( pbScratch );
645 }
646
647 if ( pbCurve != NULL )
648 {
649 SymCryptCallbackFree( pbCurve );
650 }
651
652 return pCurve;
653}
SymCryptEcurveValidateAndComputeSizes
static BOOLEAN SymCryptEcurveValidateAndComputeSizes(_In_ PCSYMCRYPT_ECURVE_PARAMS pParams, _Out_ PSYMCRYPT_ECURVE_SIZES pSizes)
Definition: ecurve.c:44
SymCryptEcurveInitialize
static PSYMCRYPT_ECURVE SymCryptEcurveInitialize(_In_ PCSYMCRYPT_ECURVE_PARAMS pParams, _In_ UINT32 flags, _In_ PCSYMCRYPT_ECURVE_SIZES pSizes, _Out_writes_bytes_(pSizes->cbAlloc) PBYTE pbCurve, _Out_writes_bytes_(pSizes->cbScratch) PBYTE pbScratch)
Definition: ecurve.c:187
_SYMCRYPT_ECURVE_SIZES
Definition: ecurve.c:26
_SYMCRYPT_ECURVE_SIZES::cbScratch
UINT32 cbScratch
Definition: ecurve.c:36
_SYMCRYPT_ECURVE_SIZES::cbAlloc
UINT32 cbAlloc
Definition: ecurve.c:30
PSYMCRYPT_ECURVE
SYMCRYPT_ECURVE * PSYMCRYPT_ECURVE
Definition: symcrypt_internal.h:3006

Referenced by SymCrypt802_11SaeCustomCreatePTGeneric(), SymCrypt802_11SaeCustomInit(), SymCrypt802_11SaeCustomInitH2EGeneric(), and SymCryptGetCachedEcurve().

◆ SymCryptEcurveBitsizeofFieldModulus()

UINT32 SYMCRYPT_CALL SymCryptEcurveBitsizeofFieldModulus ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 668 of file ecurve.c.

669{
670 return pCurve->FModBitsize;
671}

◆ SymCryptEcurveBitsizeofGroupOrder()

UINT32 SYMCRYPT_CALL SymCryptEcurveBitsizeofGroupOrder ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 675 of file ecurve.c.

676{
677 return pCurve->GOrdBitsize;
678}

Referenced by SymCryptEcDsaTruncateHash().

◆ SymCryptEcurveFree()

VOID SYMCRYPT_CALL SymCryptEcurveFree ( _Out_ PSYMCRYPT_ECURVE  pCurve)

Definition at line 657 of file ecurve.c.

658{
659 SYMCRYPT_CHECK_MAGIC( pCurve );
660
661 SymCryptWipe( (PBYTE) pCurve, pCurve->cbAlloc );
662
663 SymCryptCallbackFree( pCurve );
664}

Referenced by SymCrypt802_11SaeCustomCreatePTGeneric(), SymCrypt802_11SaeCustomDestroy(), and SymCryptGetCachedEcurve().

◆ SymCryptEcurveHighBitRestrictionNumOfBits()

UINT32 SYMCRYPT_CALL SymCryptEcurveHighBitRestrictionNumOfBits ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 724 of file ecurve.c.

725{
726 return pCurve->HighBitRestrictionNumOfBits;
727}

◆ SymCryptEcurveHighBitRestrictionPosition()

UINT32 SYMCRYPT_CALL SymCryptEcurveHighBitRestrictionPosition ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 731 of file ecurve.c.

732{
733 return pCurve->HighBitRestrictionPosition;
734}

◆ SymCryptEcurveHighBitRestrictionValue()

UINT32 SYMCRYPT_CALL SymCryptEcurveHighBitRestrictionValue ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 738 of file ecurve.c.

739{
740 return pCurve->HighBitRestrictionValue;
741}

◆ SymCryptEcurveIsSame()

BOOLEAN SYMCRYPT_CALL SymCryptEcurveIsSame ( _In_ PCSYMCRYPT_ECURVE  pCurve1,
_In_ PCSYMCRYPT_ECURVE  pCurve2 
)

Definition at line 745 of file ecurve.c.

748{
749 BOOLEAN fIsSameCurve = FALSE;
750
751 if ( pCurve1 == pCurve2 )
752 {
753 fIsSameCurve = TRUE;
754 goto cleanup;
755 }
756
757 if ( (pCurve1->type != pCurve2->type) ||
758 !SymCryptIntIsEqual (
759 SymCryptIntFromModulus( pCurve1->FMod ),
760 SymCryptIntFromModulus( pCurve2->FMod ) ) ||
761 !SymCryptModElementIsEqual ( pCurve1->FMod, pCurve1->A, pCurve2->A ) ||
762 !SymCryptModElementIsEqual ( pCurve1->FMod, pCurve1->B, pCurve2->B ) )
763 {
764 goto cleanup;
765 }
766
767 fIsSameCurve = TRUE;
768
769cleanup:
770 return fIsSameCurve;
771}

Referenced by SymCryptEcDhSecretAgreement(), SymCryptEcpointCopy(), SymCryptEcpointGenericSetRandom(), SymCryptEcpointMaskedCopy(), SymCryptEcpointMultiScalarMulWnafWithInterleaving(), SymCryptEcpointScalarMulFixedWindow(), SymCryptEcpointTransform(), SymCryptEcpointWipe(), SymCryptMontgomeryIsEqual(), SymCryptMontgomeryIsZero(), SymCryptMontgomeryPointScalarMul(), SymCryptMontgomerySetDistinguished(), SymCryptPrecomputation(), SymCryptShortWeierstrassAdd(), SymCryptShortWeierstrassAddDiffNonZero(), SymCryptShortWeierstrassAddSideChannelUnsafe(), SymCryptShortWeierstrassDouble(), SymCryptShortWeierstrassDoubleSpecializedAm3(), SymCryptShortWeierstrassIsEqual(), SymCryptShortWeierstrassIsZero(), SymCryptShortWeierstrassNegate(), SymCryptShortWeierstrassOnCurve(), SymCryptShortWeierstrassSetDistinguished(), SymCryptShortWeierstrassSetZero(), SymCryptTwistedEdwardsAdd(), SymCryptTwistedEdwardsDouble(), SymCryptTwistedEdwardsIsEqual(), SymCryptTwistedEdwardsIsZero(), SymCryptTwistedEdwardsNegate(), SymCryptTwistedEdwardsOnCurve(), SymCryptTwistedEdwardsSetDistinguished(), and SymCryptTwistedEdwardsSetZero().

◆ SymCryptEcurvePrivateKeyDefaultFormat()

UINT32 SYMCRYPT_CALL SymCryptEcurvePrivateKeyDefaultFormat ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 717 of file ecurve.c.

718{
719 return pCurve->PrivateKeyDefaultFormat;
720}

◆ SymCryptEcurveSizeofFieldElement()

UINT32 SYMCRYPT_CALL SymCryptEcurveSizeofFieldElement ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 689 of file ecurve.c.

690{
691 return pCurve->FModBytesize;
692}

Referenced by SymCryptEcDhSecretAgreement(), SymCryptEcDsaSignEx(), SymCryptEcDsaVerify(), SymCryptEckeySizeofPublicKey(), SymCryptEcpointGetValue(), and SymCryptEcpointSetValue().

◆ SymCryptEcurveSizeofScalarMultiplier()

UINT32 SYMCRYPT_CALL SymCryptEcurveSizeofScalarMultiplier ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 696 of file ecurve.c.

697{
698 return pCurve->GOrdBytesize;
699}

Referenced by SymCryptEckeyGetValue(), SymCryptEckeySetValue(), and SymCryptEckeySizeofPrivateKey().

◆ SymCryptEqual()

BOOLEAN SYMCRYPT_CALL SymCryptEqual ( _In_reads_(cbBytes) PCBYTE  pbSrc1,
_In_reads_(cbBytes) PCBYTE  pbSrc2,
SIZE_T  cbBytes 
)

Definition at line 11 of file equal.c.

14{
15 UINT32 neq = 0;
16 BYTE b;
17 volatile BYTE * p1 = (volatile BYTE *) pbSrc1;
18 volatile BYTE * p2 = (volatile BYTE *) pbSrc2;
19
20 //
21 // We use forced-access memory reads to ensure that the compiler doesn't get
22 // smart and implement an early-out solution.
23 //
24
25 while( cbBytes >= 4 )
26 {
27 neq |= SYMCRYPT_FORCE_READ32( (volatile UINT32 *) p1 ) ^ SYMCRYPT_FORCE_READ32( (volatile UINT32 *) p2 );
28 p1 += 4;
29 p2 += 4;
30 cbBytes -= 4;
31 }
32
33 // We have to deal with the remaining bytes using a separate accumulator to work around an issue in the ARM64 compiler.
34 if( cbBytes > 0 )
35 {
36 b = 0;
37 while( cbBytes > 0 )
38 {
39 b |= SYMCRYPT_FORCE_READ8( p1 ) ^ SYMCRYPT_FORCE_READ8( p2 );
40 p1++;
41 p2++;
42 cbBytes--;
43 }
44 neq |= b;
45 }
46
47 return neq == 0;
48}
SYMCRYPT_FORCE_READ8
#define SYMCRYPT_FORCE_READ8( _p)
Definition: symcrypt.h:416
SYMCRYPT_FORCE_READ32
#define SYMCRYPT_FORCE_READ32(_p)
Definition: symcrypt.h:418

Referenced by SymCryptCcmDecryptFinal(), SymCryptChaCha20Poly1305Decrypt(), SymCryptGcmDecrypt(), SymCryptGcmDecryptFinal(), SymCryptLmskeyVerifyRoot(), SymCryptLmsVerifyInternal(), SymCryptMlDsaVerifyEx(), SymCryptMlKemDecapsulate(), SymCryptMlKemkeyGenerate(), SymCryptMlKemkeySetValue(), SymCryptRsaOaepRemoveEncryptionPadding(), SymCryptRsaPkcs1CheckSignaturePadding(), SymCryptRsaPssVerifySignaturePadding(), SymCryptXmsskeyVerifyRoot(), SymCryptXmssVerifyInternal(), and SymCryptXtsAesExpandKeyEx().

◆ SymCryptExternalMuMlDsaSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptExternalMuMlDsaSign ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
_In_reads_bytes_(cbMu) PCBYTE  pbMu,
SIZE_T  cbMu,
UINT32  flags,
_Out_writes_bytes_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature 
)

◆ SymCryptExternalMuMlDsaVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptExternalMuMlDsaVerify ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
_In_reads_bytes_(cbMu) PCBYTE  pbMu,
SIZE_T  cbMu,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
UINT32  flags 
)

◆ SymCryptFatal()

_Analysis_noreturn_ VOID SYMCRYPT_CALL SymCryptFatal ( UINT32  fatalCode)

Referenced by SymCrypt3DesSelftest(), SymCryptAesCmacSelftest(), SymCryptCcmSelftest(), SymCryptChaCha20Poly1305Selftest(), SymCryptChaCha20Selftest(), SymCryptCShake128Selftest(), SymCryptCShake256Selftest(), SymCryptDesSelftest(), SymCryptDesxSelftest(), SymCryptDlkeyGenerate(), SymCryptFdefModSetRandomGeneric(), SymCryptGcmSelftest(), SymCryptGHashAppendData(), SymCryptGHashExpandKey(), SymCryptHmacMd5Selftest(), SymCryptHmacSha1Selftest(), SymCryptHmacSha224Selftest(), SymCryptHmacSha256Selftest(), SymCryptHmacSha384Selftest(), SymCryptHmacSha3_224Selftest(), SymCryptHmacSha3_256Selftest(), SymCryptHmacSha3_384Selftest(), SymCryptHmacSha3_512Selftest(), SymCryptHmacSha512_224Selftest(), SymCryptHmacSha512_256Selftest(), SymCryptHmacSha512Selftest(), SymCryptInitEnvCommon(), SymCryptKmac128Selftest(), SymCryptKmac256Selftest(), SymCryptMarvin32Selftest(), SymCryptMd2Selftest(), SymCryptMd4Selftest(), SymCryptMd5Selftest(), SymCryptPbkdf2_HmacSha1SelfTest(), SymCryptPbkdf2_HmacSha256SelfTest(), SymCryptPoly1305Selftest(), SymCryptRc2Selftest(), SymCryptRc4Selftest(), SymCryptRngAesCheckBlocksNotIdentical(), SymCryptRngAesGenerate(), SymCryptRngAesGenerateBlocks(), SymCryptRngAesTestGenerate(), SymCryptRngAesTestInstantiate(), SymCryptRngAesTestReseed(), SymCryptRngAesTestUninstantiate(), SymCryptSha1Selftest(), SymCryptSha224Selftest(), SymCryptSha256Selftest(), SymCryptSha384Selftest(), SymCryptSha3_224Selftest(), SymCryptSha3_256Selftest(), SymCryptSha3_384Selftest(), SymCryptSha3_512Selftest(), SymCryptSha512_224Selftest(), SymCryptSha512_256Selftest(), SymCryptSha512Selftest(), SymCryptShake128Selftest(), SymCryptShake256Selftest(), SymCryptSp800_108_HmacSha1SelfTest(), SymCryptSp800_108_HmacSha256SelfTest(), SymCryptSp800_108_HmacSha384SelfTest(), SymCryptSp800_108_HmacSha512SelfTest(), SymCryptSshKdfSha256SelfTest(), SymCryptSshKdfSha512SelfTest(), and SymCryptXtsAesSelftest().

◆ SymCryptGcmAuthPart()

VOID SYMCRYPT_CALL SymCryptGcmAuthPart ( _Inout_ PSYMCRYPT_GCM_STATE  pState,
_In_reads_opt_(cbData) PCBYTE  pbAuthData,
SIZE_T  cbData 
)

Definition at line 435 of file gcm.c.

439{
440 SYMCRYPT_CHECK_MAGIC( pState );
441 SYMCRYPT_ASSERT( pState->cbData == 0 );
442
443 SymCryptGcmAddMacData( pState, pbAuthData, cbData );
444 pState->cbAuthData += cbData;
445}
SymCryptGcmAddMacData
VOID SYMCRYPT_CALL SymCryptGcmAddMacData(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_opt_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: gcm.c:65

◆ SymCryptGcmDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecrypt ( _In_ PCSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_In_reads_(cbTag) PCBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 731 of file gcm.c.

742{
743 SYMCRYPT_ERROR status;
744 SYMCRYPT_ALIGN BYTE buf[2 * SYMCRYPT_GCM_BLOCK_SIZE];
745 SYMCRYPT_GCM_STATE state;
746 PSYMCRYPT_GCM_STATE pState = &state;
747
748 // SymCryptGcmInit( &state, pExpandedKey, pbNonce, cbNonce );
749 UNREFERENCED_PARAMETER( cbNonce ); // It is used in an ASSERT, but only in CHKed builds.
750
751 SYMCRYPT_ASSERT( cbNonce >= GCM_MIN_NONCE_SIZE );
752 SYMCRYPT_ASSERT( cbTag >= GCM_MIN_TAG_SIZE && cbTag <= GCM_MAX_TAG_SIZE );
753
754 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
755
756 pState->pKey = pExpandedKey;
757 pState->cbData = 0;
758 pState->cbAuthData = 0;
759 pState->bytesInMacBlock = 0;
760 SymCryptWipeKnownSize( &pState->ghashState, sizeof( pState->ghashState ) );
761
762 SymCryptGcmSetNonce( pState, pbNonce, cbNonce );
763
764 // SymCryptGcmAuthPart( &state, pbAuthData, cbAuthData );
765 pState->cbAuthData += cbAuthData;
766 if( cbAuthData >= SYMCRYPT_GCM_BLOCK_SIZE )
767 {
768 SIZE_T bytesToDo = cbAuthData & SYMCRYPT_GCM_BLOCK_ROUND_MASK;
769
770 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, pbAuthData, bytesToDo );
771
772 pbAuthData += bytesToDo;
773 cbAuthData -= bytesToDo;
774 }
775
776 if( cbAuthData > 0 )
777 {
778 //
779 // Pad the MAC data with zeroes until we hit the block size.
780 //
781 SymCryptWipeKnownSize( &pState->macBlock[0], SYMCRYPT_GCM_BLOCK_SIZE );
782 memcpy( &pState->macBlock[0], pbAuthData, cbAuthData );
783 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, &pState->macBlock[0], SYMCRYPT_GCM_BLOCK_SIZE );
784 }
785
786 // SymCryptGcmDecryptPart( &state, pbSrc, pbDst, cbData );
787 if ( pState->pKey->pBlockCipher->gcmDecryptPartFunc != NULL )
788 {
789 //
790 // Use optimized implementation if available
791 //
792 (*pState->pKey->pBlockCipher->gcmDecryptPartFunc) ( pState, pbSrc, pbDst, cbData );
793 }
794 else
795 {
796 SymCryptGcmDecryptPartTwoPass( pState, pbSrc, pbDst, cbData );
797 }
798
799 //status = SymCryptGcmDecryptFinal( &state, pbTag, cbTag );
800 SYMCRYPT_STORE_MSBFIRST64( &buf[16], pState->cbAuthData * 8 );
801 SYMCRYPT_STORE_MSBFIRST64( &buf[24], pState->cbData * 8 );
802
803 if( pState->bytesInMacBlock > 0 )
804 {
805 //
806 // Pad the MAC data with zeroes until we hit the block size
807 //
808 SymCryptWipeKnownSize( &buf[0], SYMCRYPT_GCM_BLOCK_SIZE );
809 memcpy( buf, &pState->macBlock[0], pState->bytesInMacBlock );
810
811 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, &buf[0], 2 * SYMCRYPT_GCM_BLOCK_SIZE );
812 }
813 else
814 {
815 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, &buf[16], SYMCRYPT_GCM_BLOCK_SIZE );
816 }
817
818 SymCryptGcmResetCounterBlock( pState );
819
820 //
821 // Convert the GHash state to an array of bytes
822 //
823 SYMCRYPT_STORE_MSBFIRST64( &buf[0], pState->ghashState.ull[1] );
824 SYMCRYPT_STORE_MSBFIRST64( &buf[8], pState->ghashState.ull[0] );
825
826 SYMCRYPT_ASSERT( pState->pKey->pBlockCipher->blockSize == SYMCRYPT_GCM_BLOCK_SIZE );
827 SymCryptCtrMsb32( pState->pKey->pBlockCipher,
828 &pState->pKey->blockcipherKey,
829 &pState->counterBlock[0],
830 buf,
831 buf,
832 SYMCRYPT_GCM_BLOCK_SIZE );
833
834 if( !SymCryptEqual( pbTag, buf, cbTag ) )
835 {
836 status = SYMCRYPT_AUTHENTICATION_FAILURE;
837 }
838 else
839 {
840 status = SYMCRYPT_NO_ERROR;
841 }
842
843 SymCryptWipeKnownSize( buf, sizeof( buf ) );
844 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
845
846 if( status != SYMCRYPT_NO_ERROR )
847 {
848 SymCryptWipe( pbDst, cbData );
849 }
850
851 return status;
852}
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: blockciphermodes.c:249
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: ghash.c:884
GCM_MAX_TAG_SIZE
#define GCM_MAX_TAG_SIZE
Definition: gcm.c:11
SymCryptGcmDecryptPartTwoPass
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptGcmDecryptPartTwoPass(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: gcm.c:543
GCM_MIN_TAG_SIZE
#define GCM_MIN_TAG_SIZE
Definition: gcm.c:10
GCM_MIN_NONCE_SIZE
#define GCM_MIN_NONCE_SIZE
Definition: gcm.c:9
SymCryptGcmSetNonce
VOID SYMCRYPT_CALL SymCryptGcmSetNonce(_Out_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce)
Definition: gcm.c:334
SymCryptGcmResetCounterBlock
FORCEINLINE VOID SYMCRYPT_CALL SymCryptGcmResetCounterBlock(_Inout_ PSYMCRYPT_GCM_STATE pState)
Definition: gcm.c:203
PSYMCRYPT_GCM_STATE
SYMCRYPT_MAGIC_FIELD * PSYMCRYPT_GCM_STATE
Definition: symcrypt_internal.h:1977
SYMCRYPT_GCM_BLOCK_SIZE
#define SYMCRYPT_GCM_BLOCK_SIZE
Definition: symcrypt_internal.h:1853
SYMCRYPT_GCM_BLOCK_ROUND_MASK
#define SYMCRYPT_GCM_BLOCK_ROUND_MASK
Definition: symcrypt_internal.h:1860
SYMCRYPT_GCM_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_GCM_STATE
Definition: symcrypt_internal.h:1977

Referenced by SymCryptGcmSelftest(), and SymCryptSessionGcmDecrypt().

◆ SymCryptGcmDecryptFinal()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecryptFinal ( _Inout_ PSYMCRYPT_GCM_STATE  pState,
_In_reads_(cbTag) PCBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 585 of file gcm.c.

589{
590 SYMCRYPT_ALIGN BYTE buf[SYMCRYPT_GCM_BLOCK_SIZE];
591 SYMCRYPT_ERROR status;
592
593 SYMCRYPT_ASSERT( cbTag >= GCM_MIN_TAG_SIZE && cbTag <= GCM_MAX_TAG_SIZE );
594
595 SymCryptGcmComputeTag( pState, &buf[0] );
596
597 if( !SymCryptEqual( pbTag, buf, cbTag ) )
598 {
599 status = SYMCRYPT_AUTHENTICATION_FAILURE;
600 }
601 else
602 {
603 status = SYMCRYPT_NO_ERROR;
604 }
605
606 SymCryptWipeKnownSize( buf, sizeof( buf ) );
607
608 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
609 SYMCRYPT_ASSERT( pState->bytesInMacBlock == 0 );
610
611 return status;
612}
SymCryptGcmComputeTag
VOID SYMCRYPT_CALL SymCryptGcmComputeTag(_Inout_ PSYMCRYPT_GCM_STATE pState, _Out_writes_(SYMCRYPT_GCM_BLOCK_SIZE) PBYTE pbTag)
Definition: gcm.c:222

◆ SymCryptGcmDecryptPart()

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

Definition at line 512 of file gcm.c.

517{
518 if( pState->cbData == 0 )
519 {
520 //
521 // This is the first actual encryption data, pad the Auth data with zeroes if needed.
522 //
523 SymCryptGcmPadMacData( pState );
524 }
525
526 if ( pState->pKey->pBlockCipher->gcmDecryptPartFunc != NULL )
527 {
528 //
529 // Use optimized implementation if available
530 //
531 (*pState->pKey->pBlockCipher->gcmDecryptPartFunc) ( pState, pbSrc, pbDst, cbData );
532 SYMCRYPT_ASSERT( pState->bytesInMacBlock <= 15 );
533 }
534 else
535 {
536 SymCryptGcmDecryptPartTwoPass( pState, pbSrc, pbDst, cbData );
537 }
538}
SymCryptGcmPadMacData
VOID SYMCRYPT_CALL SymCryptGcmPadMacData(_Inout_ PSYMCRYPT_GCM_STATE pState)
Definition: gcm.c:110

◆ SymCryptGcmEncrypt()

VOID SYMCRYPT_CALL SymCryptGcmEncrypt ( _In_ PCSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_Out_writes_(cbTag) PBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 618 of file gcm.c.

629{
630 SYMCRYPT_ALIGN BYTE buf[2 * SYMCRYPT_GCM_BLOCK_SIZE];
631 SYMCRYPT_GCM_STATE state;
632 PSYMCRYPT_GCM_STATE pState = &state;
633
634 // SymCryptGcmInit( &state, pExpandedKey, pbNonce, cbNonce );
635 UNREFERENCED_PARAMETER( cbNonce ); // It is used in an ASSERT, but only in CHKed builds.
636
637 SYMCRYPT_ASSERT( cbNonce >= GCM_MIN_NONCE_SIZE );
638 SYMCRYPT_ASSERT( cbTag >= GCM_MIN_TAG_SIZE && cbTag <= GCM_MAX_TAG_SIZE );
639
640 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
641
642 pState->pKey = pExpandedKey;
643 pState->cbData = 0;
644 pState->cbAuthData = 0;
645 pState->bytesInMacBlock = 0;
646 SymCryptWipeKnownSize( &pState->ghashState, sizeof( pState->ghashState ) );
647
648 SymCryptGcmSetNonce( pState, pbNonce, cbNonce );
649
650 // SymCryptGcmAuthPart( &state, pbAuthData, cbAuthData );
651 pState->cbAuthData += cbAuthData;
652 if( cbAuthData >= SYMCRYPT_GCM_BLOCK_SIZE )
653 {
654 SIZE_T bytesToDo = cbAuthData & SYMCRYPT_GCM_BLOCK_ROUND_MASK;
655
656 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, pbAuthData, bytesToDo );
657
658 pbAuthData += bytesToDo;
659 cbAuthData -= bytesToDo;
660 }
661
662 if( cbAuthData > 0 )
663 {
664 //
665 // Pad the MAC data with zeroes until we hit the block size.
666 //
667 SymCryptWipeKnownSize( &pState->macBlock[0], SYMCRYPT_GCM_BLOCK_SIZE );
668 memcpy( &pState->macBlock[0], pbAuthData, cbAuthData );
669 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, &pState->macBlock[0], SYMCRYPT_GCM_BLOCK_SIZE );
670 }
671
672 // SymCryptGcmEncryptPart( &state, pbSrc, pbDst, cbData );
673 if ( pState->pKey->pBlockCipher->gcmEncryptPartFunc != NULL )
674 {
675 //
676 // Use optimized implementation if available
677 //
678 (*pState->pKey->pBlockCipher->gcmEncryptPartFunc) ( pState, pbSrc, pbDst, cbData );
679 }
680 else
681 {
682 SymCryptGcmEncryptPartTwoPass( pState, pbSrc, pbDst, cbData );
683 }
684
685 // SymCryptGcmEncryptFinal( &state, pbTag, cbTag );
686 SYMCRYPT_STORE_MSBFIRST64( &buf[16], pState->cbAuthData * 8 );
687 SYMCRYPT_STORE_MSBFIRST64( &buf[24], pState->cbData * 8 );
688
689 if( pState->bytesInMacBlock > 0 )
690 {
691 //
692 // Pad the MAC data with zeroes until we hit the block size
693 //
694 SymCryptWipeKnownSize( &buf[0], SYMCRYPT_GCM_BLOCK_SIZE );
695 memcpy( buf, &pState->macBlock[0], pState->bytesInMacBlock );
696
697 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, &buf[0], 2 * SYMCRYPT_GCM_BLOCK_SIZE );
698 }
699 else
700 {
701 SymCryptGHashAppendData( &pState->pKey->ghashKey, &pState->ghashState, &buf[16], SYMCRYPT_GCM_BLOCK_SIZE );
702 }
703
704 // Reset the counter block prior to computing the tag
705 SymCryptGcmResetCounterBlock( pState );
706
707 //
708 // Convert the GHash state to an array of bytes
709 //
710 SYMCRYPT_STORE_MSBFIRST64( &buf[0], pState->ghashState.ull[1] );
711 SYMCRYPT_STORE_MSBFIRST64( &buf[8], pState->ghashState.ull[0] );
712
713 SYMCRYPT_ASSERT( pState->pKey->pBlockCipher->blockSize == SYMCRYPT_GCM_BLOCK_SIZE );
714 SymCryptCtrMsb32( pState->pKey->pBlockCipher,
715 &pState->pKey->blockcipherKey,
716 &pState->counterBlock[0],
717 buf,
718 buf,
719 SYMCRYPT_GCM_BLOCK_SIZE );
720
721 memcpy( pbTag, buf, cbTag );
722
723 SymCryptWipeKnownSize( buf, sizeof( buf ) );
724 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
725}
SymCryptGcmEncryptPartTwoPass
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptGcmEncryptPartTwoPass(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: gcm.c:481

Referenced by SymCryptGcmSelftest(), and SymCryptSessionGcmEncrypt().

◆ SymCryptGcmEncryptFinal()

VOID SYMCRYPT_CALL SymCryptGcmEncryptFinal ( _Inout_ PSYMCRYPT_GCM_STATE  pState,
_Out_writes_(cbTag) PBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 564 of file gcm.c.

568{
569 SYMCRYPT_ALIGN BYTE buf[SYMCRYPT_GCM_BLOCK_SIZE];
570
571 SYMCRYPT_ASSERT( cbTag >= GCM_MIN_TAG_SIZE && cbTag <= GCM_MAX_TAG_SIZE );
572
573 SymCryptGcmComputeTag( pState, &buf[0] );
574 memcpy( pbTag, buf, cbTag );
575
576 SymCryptWipeKnownSize( buf, sizeof( buf ) );
577
578 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
579 SYMCRYPT_ASSERT( pState->bytesInMacBlock == 0 );
580}

◆ SymCryptGcmEncryptPart()

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

Definition at line 450 of file gcm.c.

455{
456 if( pState->cbData == 0 )
457 {
458 //
459 // This is the first actual encryption data, pad the Auth data with zeroes if needed.
460 //
461 SymCryptGcmPadMacData( pState );
462 }
463
464 if ( pState->pKey->pBlockCipher->gcmEncryptPartFunc != NULL )
465 {
466 //
467 // Use optimized implementation if available
468 //
469 (*pState->pKey->pBlockCipher->gcmEncryptPartFunc) ( pState, pbSrc, pbDst, cbData );
470 SYMCRYPT_ASSERT( pState->bytesInMacBlock <= 15 );
471 }
472 else
473 {
474 SymCryptGcmEncryptPartTwoPass( pState, pbSrc, pbDst, cbData );
475 }
476}

◆ SymCryptGcmExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmExpandKey ( _Out_ PSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 268 of file gcm.c.

273{
274 SYMCRYPT_ALIGN BYTE H[SYMCRYPT_GCM_BLOCK_SIZE];
275 SYMCRYPT_ERROR status = SYMCRYPT_NO_ERROR;
276
277 if( cbKey > SYMCRYPT_GCM_MAX_KEY_SIZE )
278 {
279 status = SYMCRYPT_WRONG_KEY_SIZE;
280 goto cleanup;
281 }
282
283 //
284 // Perform the Block cipher key expansion first
285 //
286 pExpandedKey->pBlockCipher = pBlockCipher;
287 status = pBlockCipher->expandKeyFunc( &pExpandedKey->blockcipherKey, pbKey, cbKey );
288
289 if( status != SYMCRYPT_NO_ERROR )
290 {
291 goto cleanup;
292 }
293
294 //
295 // We keep a copy of the key to make it easy to
296 // implement the SymCryptGcmKeyCopy function
297 //
298 pExpandedKey->cbKey = cbKey;
299 memcpy( &pExpandedKey->abKey[0], pbKey, cbKey );
300
301 //
302 // Compute H and the GHASH expanded key
303 //
304 SymCryptWipeKnownSize( H, sizeof( H ) );
305 pBlockCipher->encryptFunc( &pExpandedKey->blockcipherKey, H, H );
306
307
308 SymCryptGHashExpandKey( &pExpandedKey->ghashKey, H );
309
310
311 SYMCRYPT_SET_MAGIC( pExpandedKey );
312
313 SymCryptWipeKnownSize( H, sizeof( H ) );
314
315cleanup:
316
317 return status;
318}
SymCryptGHashExpandKey
VOID SYMCRYPT_CALL SymCryptGHashExpandKey(_Out_ PSYMCRYPT_GHASH_EXPANDED_KEY expandedKey, _In_reads_(SYMCRYPT_GF128_BLOCK_SIZE) PCBYTE pH)
Definition: ghash.c:816
H
#define H
_SYMCRYPT_BLOCKCIPHER::expandKeyFunc
PSYMCRYPT_BLOCKCIPHER_EXPAND_KEY expandKeyFunc
Definition: symcrypt_internal.h:1995
SYMCRYPT_GCM_MAX_KEY_SIZE
#define SYMCRYPT_GCM_MAX_KEY_SIZE
Definition: symcrypt_internal.h:1854

Referenced by SymCryptGcmKeyCopy(), and SymCryptGcmSelftest().

◆ SymCryptGcmInit()

VOID SYMCRYPT_CALL SymCryptGcmInit ( _Out_ PSYMCRYPT_GCM_STATE  pState,
_In_ PCSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbNonce) PCBYTE  pbNonce,
SIZE_T  cbNonce 
)

Definition at line 391 of file gcm.c.

396{
397 UNREFERENCED_PARAMETER( cbNonce ); // It is used in an ASSERT, but only in CHKed builds.
398
399 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
400
401 pState->pKey = pExpandedKey;
402 pState->cbData = 0;
403 pState->cbAuthData = 0;
404 pState->bytesInMacBlock = 0;
405 SymCryptWipeKnownSize( &pState->ghashState, sizeof( pState->ghashState ) );
406
407 SymCryptGcmSetNonce(pState, pbNonce, cbNonce);
408
409 SYMCRYPT_SET_MAGIC( pState );
410}

◆ SymCryptGcmKeyCopy()

VOID SYMCRYPT_CALL SymCryptGcmKeyCopy ( _In_ PCSYMCRYPT_GCM_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_GCM_EXPANDED_KEY  pDst 
)

Definition at line 322 of file gcm.c.

323{
324 SYMCRYPT_ERROR status;
325
326 SYMCRYPT_CHECK_MAGIC( pSrc );
327
328 status = SymCryptGcmExpandKey( pDst, pSrc->pBlockCipher, &pSrc->abKey[0], pSrc->cbKey );
329 SYMCRYPT_ASSERT( status == SYMCRYPT_NO_ERROR );
330}
SymCryptGcmExpandKey
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmExpandKey(_Out_ PSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: gcm.c:268

◆ SymCryptGcmSelftest()

VOID SYMCRYPT_CALL SymCryptGcmSelftest ( void  )

Definition at line 863 of file gcm.c.

864{
865 BYTE buf[ 3 + SYMCRYPT_AES_BLOCK_SIZE ];
866 SYMCRYPT_GCM_EXPANDED_KEY key;
867 SYMCRYPT_ERROR err;
868
869 if( SymCryptGcmExpandKey( &key, SymCryptAesBlockCipher, SymCryptTestKey32, 16 ) != SYMCRYPT_NO_ERROR )
870 {
871 SymCryptFatal( 'gcm0' );
872 }
873
874 SymCryptGcmEncrypt( &key,
875 &SymCryptTestKey32[16], 12,
876 NULL, 0,
877 &SymCryptTestMsg3[0], buf, 3,
878 &buf[3], SYMCRYPT_AES_BLOCK_SIZE );
879
880 SymCryptInjectError( buf, sizeof( buf ) );
881 if( memcmp( buf, SymCryptGcmSelftestResult, sizeof( buf ) ) != 0 )
882 {
883 SymCryptFatal( 'gcm1' );
884 }
885
886 // inject error into the ciphertext or tag
887 SymCryptInjectError( buf, sizeof( buf ) );
888
889 err = SymCryptGcmDecrypt( &key,
890 &SymCryptTestKey32[16], 12,
891 NULL, 0,
892 buf, buf, 3,
893 &buf[3], SYMCRYPT_AES_BLOCK_SIZE );
894
895 SymCryptInjectError( buf, 3 );
896
897 if( err != SYMCRYPT_NO_ERROR || memcmp( buf, SymCryptTestMsg3, 3 ) != 0 )
898 {
899 SymCryptFatal( 'gcm2' );
900 }
901
902}
SymCryptGcmDecrypt
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecrypt(_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
Definition: gcm.c:731
SymCryptGcmSelftestResult
static const BYTE SymCryptGcmSelftestResult[3+SYMCRYPT_AES_BLOCK_SIZE]
Definition: gcm.c:855
SymCryptGcmEncrypt
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptGcmEncrypt(_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
Definition: gcm.c:618
SYMCRYPT_GCM_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_GCM_EXPANDED_KEY
Definition: symcrypt_internal.h:1963

◆ SymCryptGcmStateCopy()

VOID SYMCRYPT_CALL SymCryptGcmStateCopy ( _In_ PCSYMCRYPT_GCM_STATE  pSrc,
_In_opt_ PCSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKeyCopy,
_Out_ PSYMCRYPT_GCM_STATE  pDst 
)

Definition at line 415 of file gcm.c.

419{
420 SYMCRYPT_CHECK_MAGIC( pSrc );
421
422 *pDst = *pSrc;
423 if( pExpandedKeyCopy != NULL )
424 {
425 pDst->pKey = pExpandedKeyCopy;
426 }
427
428 SYMCRYPT_SET_MAGIC( pDst );
429}

◆ SymCryptGcmValidateParameters()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmValidateParameters ( _In_ PCSYMCRYPT_BLOCKCIPHER  pBlockCipher,
_In_ SIZE_T  cbNonce,
_In_ UINT64  cbAssociatedData,
_In_ UINT64  cbData,
_In_ SIZE_T  cbTag 
)

Definition at line 16 of file gcm.c.

22{
23 if( pBlockCipher->blockSize != SYMCRYPT_GCM_BLOCK_SIZE )
24 {
25 return SYMCRYPT_WRONG_BLOCK_SIZE;
26 }
27
28 //
29 // SP800-38D specifies that the nonce must be at least one bit, but we operate on bytes,
30 // so the minimum is one byte.
31 //
32 if( cbNonce < GCM_MIN_NONCE_SIZE )
33 {
34 return SYMCRYPT_WRONG_NONCE_SIZE;
35 }
36
37 //
38 // cbAssociatedData is limited to <2^61 bytes
39 //
40 if( (cbAssociatedData >> 61) > 0 )
41 {
42 return SYMCRYPT_WRONG_DATA_SIZE;
43 }
44
45 //
46 // per SP800-38D cbData is limited to 2^36 - 32 bytes
47 //
48 if( cbData > SYMCRYPT_GCM_MAX_DATA_SIZE )
49 {
50 return SYMCRYPT_WRONG_DATA_SIZE;
51 }
52
53 if( cbTag < GCM_MIN_TAG_SIZE || cbTag > GCM_MAX_TAG_SIZE )
54 {
55 return SYMCRYPT_WRONG_TAG_SIZE;
56 }
57
58 return SYMCRYPT_NO_ERROR;
59}
SYMCRYPT_GCM_MAX_DATA_SIZE
#define SYMCRYPT_GCM_MAX_DATA_SIZE
Definition: symcrypt_internal.h:1857

◆ SymCryptGetBlockCipher()

PCSYMCRYPT_BLOCKCIPHER SYMCRYPT_CALL SymCryptGetBlockCipher ( SYMCRYPT_BLOCKCIPHER_ID  blockCipherId)

◆ SymCryptGetEcurveParams()

PCSYMCRYPT_ECURVE_PARAMS SYMCRYPT_CALL SymCryptGetEcurveParams ( SYMCRYPT_ECURVE_ID  ecurveId)

◆ SymCryptGetHashAlgorithm()

PCSYMCRYPT_HASH SYMCRYPT_CALL SymCryptGetHashAlgorithm ( SYMCRYPT_HASH_ID  hashId)

◆ SymCryptGetMacAlgorithm()

PCSYMCRYPT_MAC SYMCRYPT_CALL SymCryptGetMacAlgorithm ( SYMCRYPT_MAC_ID  macId)

◆ SymCryptGetMarvin32DefaultSeed()

PCSYMCRYPT_MARVIN32_EXPANDED_SEED SYMCRYPT_CALL SymCryptGetMarvin32DefaultSeed ( void  )

◆ SymCryptHash()

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

Definition at line 155 of file hash.c.

161{
162 SYMCRYPT_HASH_STATE hash;
163
164 _Analysis_assume_( pHash->stateSize <= sizeof( hash ) );
165 SymCryptHashInit( pHash, &hash );
166 SymCryptHashAppend( pHash, &hash, pbData, cbData );
167 SymCryptHashResult( pHash, &hash, pbResult, cbResult );
168 SymCryptWipe( &hash, pHash->stateSize );
169}
_Analysis_assume_
#define _Analysis_assume_
Definition: no_sal2.h:388
SymCryptHashAppend
VOID SYMCRYPT_CALL SymCryptHashAppend(_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: hash.c:182
SymCryptHashInit
VOID SYMCRYPT_CALL SymCryptHashInit(_In_ PCSYMCRYPT_HASH pHash, _Out_writes_bytes_(pHash->stateSize) PVOID pState)
Definition: hash.c:173
SymCryptHashResult
VOID SYMCRYPT_CALL SymCryptHashResult(_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
Definition: hash.c:193
_SYMCRYPT_HASH_STATE
Definition: symcrypt_internal.h:1158

Referenced by SymCryptDlgroupGeneratePrimeP_FIPS(), SymCryptDlgroupGeneratePrimeQ_FIPS(), SymCryptHmacExpandKey(), SymCryptRsaOaepApplyEncryptionPadding(), SymCryptRsaOaepRemoveEncryptionPadding(), SymCryptRsaPssApplySignaturePadding(), and SymCryptRsaPssVerifySignaturePadding().

◆ SymCryptHashAppend()

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

Definition at line 182 of file hash.c.

187{
188 (*pHash->appendFunc)( pState, pbData, cbData );
189}

Referenced by LmsComputeOtsPubKeyCandidate(), LmsComputeRootCandidate(), LmsHashMessage(), LmsOtskeyComputePrivate(), LmsOtskeyComputePublic(), LmsOtskeySign(), SymCryptDlgroupGenerateGenG_FIPS(), SymCryptHash(), SymCryptHmacAppend(), SymCryptHmacExpandKey(), SymCryptHmacResult(), SymCryptRsaPaddingMaskGeneration(), SymCryptSshKdfDerive(), SymCryptSshKdfExpandKey(), SymCryptSskdfHash(), SymCryptXmssChain(), SymCryptXmssCreateWotspSecret(), SymCryptXmssPrf(), SymCryptXmssPrfInit(), SymCryptXmssPrfKey(), SymCryptXmssRandHash(), SymCryptXmssRandomizedHash(), and update_hash_impl().

◆ SymCryptHashInit()

VOID SYMCRYPT_CALL SymCryptHashInit ( _In_ PCSYMCRYPT_HASH  pHash,
_Out_writes_bytes_(pHash->stateSize) PVOID  pState 
)

Definition at line 173 of file hash.c.

176{
177 (*pHash->initFunc)( pState );
178}

Referenced by init_hash_impl(), LmsComputeOtsPubKeyCandidate(), LmsComputeRootCandidate(), LmsHashMessage(), LmsOtskeyComputePrivate(), LmsOtskeyComputePublic(), LmsOtskeySign(), SymCryptDlgroupGenerateGenG_FIPS(), SymCryptHash(), SymCryptHmacExpandKey(), SymCryptRsaPaddingMaskGeneration(), SymCryptSshKdfExpandKey(), SymCryptSskdfHash(), and SymCryptXmssPrfInit().

◆ SymCryptHashInputBlockSize()

SIZE_T SYMCRYPT_CALL SymCryptHashInputBlockSize ( _In_ PCSYMCRYPT_HASH  pHash)

Definition at line 140 of file hash.c.

141{
142 return pHash->inputBlockSize;
143}

Referenced by hash_block_len_impl(), and SymCryptSskdfMacExpandSalt().

◆ SymCryptHashMlDsaSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHashMlDsaSign ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
SYMCRYPT_PQDSA_HASH_ID  hashAlg,
_In_reads_bytes_(cbHash) PCBYTE  pbHash,
SIZE_T  cbHash,
_In_reads_bytes_opt_(cbContext) PCBYTE  pbContext,
_In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T  cbContext,
UINT32  flags,
_Out_writes_bytes_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature 
)

◆ SymCryptHashMlDsaVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHashMlDsaVerify ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
SYMCRYPT_PQDSA_HASH_ID  hashAlg,
_In_reads_bytes_(cbHash) PCBYTE  pbHash,
SIZE_T  cbHash,
_In_reads_bytes_opt_(cbContext) PCBYTE  pbContext,
_In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T  cbContext,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
UINT32  flags 
)

◆ SymCryptHashResult()

VOID SYMCRYPT_CALL SymCryptHashResult ( _In_ PCSYMCRYPT_HASH  pHash,
_Inout_updates_bytes_(pHash->stateSize) PVOID  pState,
_Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 193 of file hash.c.

198{
199 BYTE buf[SYMCRYPT_HASH_MAX_RESULT_SIZE];
200
201 _Analysis_assume_( pHash->resultSize <= SYMCRYPT_HASH_MAX_RESULT_SIZE );
202
203 (*pHash->resultFunc)( pState, buf );
204 memcpy( pbResult, buf, SYMCRYPT_MIN( cbResult, pHash->resultSize ));
205 SymCryptWipe( buf, pHash->resultSize );
206}
SYMCRYPT_HASH_MAX_RESULT_SIZE
#define SYMCRYPT_HASH_MAX_RESULT_SIZE
Definition: symcrypt_internal.h:1176

Referenced by finalize_hash_impl(), LmsComputeOtsPubKeyCandidate(), LmsComputeRootCandidate(), LmsHashMessage(), LmsOtskeyComputePrivate(), LmsOtskeyComputePublic(), LmsOtskeySign(), SymCryptDlgroupGenerateGenG_FIPS(), SymCryptHash(), SymCryptHmacResult(), SymCryptRsaPaddingMaskGeneration(), SymCryptSshKdfDerive(), SymCryptSskdfHash(), SymCryptXmssChain(), SymCryptXmssCreateWotspSecret(), SymCryptXmssPrf(), SymCryptXmssRandHash(), and SymCryptXmssRandomizedHash().

◆ SymCryptHashResultSize()

SIZE_T SYMCRYPT_CALL SymCryptHashResultSize ( _In_ PCSYMCRYPT_HASH  pHash)

Definition at line 132 of file hash.c.

133{
134 return pHash->resultSize;
135}

Referenced by hash_len_impl(), SymCryptDlgroupGenerate(), SymCryptDlgroupGenerateGenG_FIPS(), SymCryptDlgroupGeneratePrimeP_FIPS(), SymCryptDlgroupGeneratePrimeQ_FIPS(), SymCryptDlgroupScratchSpace_FIPS(), SymCryptRsaOaepApplyEncryptionPadding(), SymCryptRsaOaepRemoveEncryptionPadding(), SymCryptRsaPaddingMaskGeneration(), SymCryptRsaPssApplySignaturePadding(), SymCryptRsaPssVerifySignaturePadding(), and SymCryptSshKdfDerive().

◆ SymCryptHashStateCopy()

VOID SYMCRYPT_CALL SymCryptHashStateCopy ( _In_ PCSYMCRYPT_HASH  pHash,
_In_reads_(pHash->stateSize) PCVOID  pSrc,
_Out_writes_(pHash->stateSize) PVOID  pDst 
)

Definition at line 210 of file hash.c.

214{
215 (*pHash->stateCopyFunc)( pSrc, pDst );
216}

Referenced by SymCryptHmacInit(), SymCryptHmacKeyCopy(), SymCryptHmacResult(), SymCryptHmacStateCopy(), SymCryptSshKdfDerive(), SymCryptXmssChain(), and SymCryptXmssRandHash().

◆ SymCryptHashStateSize()

SIZE_T SYMCRYPT_CALL SymCryptHashStateSize ( _In_ PCSYMCRYPT_HASH  pHash)

Definition at line 147 of file hash.c.

148{
149 return pHash->stateSize;
150}

Referenced by SymCryptDlgroupGenerateGenG_FIPS(), SymCryptDlgroupScratchSpace_FIPS(), SymCryptRsaOaepApplyEncryptionPadding(), SymCryptRsaOaepRemoveEncryptionPadding(), SymCryptRsaPssApplySignaturePadding(), and SymCryptRsaPssVerifySignaturePadding().

◆ SymCryptHkdf()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdf ( PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbIkm) PCBYTE  pbIkm,
SIZE_T  cbIkm,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
_In_reads_opt_(cbInfo) PCBYTE  pbInfo,
SIZE_T  cbInfo,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 186 of file hkdf.c.

196{
197 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
198 SYMCRYPT_HKDF_EXPANDED_KEY key;
199
200 // Create the expanded key
201 scError = SymCryptHkdfExpandKey(
202 &key,
203 macAlgorithm,
204 pbIkm,
205 cbIkm,
206 pbSalt,
207 cbSalt );
208 if (scError != SYMCRYPT_NO_ERROR)
209 {
210 goto cleanup;
211 }
212
213 // Derive the key
214 scError = SymCryptHkdfDerive(
215 &key,
216 pbInfo,
217 cbInfo,
218 pbResult,
219 cbResult );
220 if (scError != SYMCRYPT_NO_ERROR)
221 {
222 goto cleanup;
223 }
224
225cleanup:
226 SymCryptWipeKnownSize(&key, sizeof(key));
227
228 return scError;
229}
SymCryptHkdfExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExpandKey(_Out_ PSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbIkm) PCBYTE pbIkm, SIZE_T cbIkm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt)
Definition: hkdf.c:18
SymCryptHkdfDerive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfDerive(_In_ PCSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: hkdf.c:106
_SYMCRYPT_HKDF_EXPANDED_KEY
Definition: symcrypt_internal.h:2262
macAlgorithm
PCSYMCRYPT_MAC macAlgorithm
Definition: symcrypt_internal.h:3072

◆ SymCryptHkdfDerive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfDerive ( _In_ PCSYMCRYPT_HKDF_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbInfo) PCBYTE  pbInfo,
SIZE_T  cbInfo,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 106 of file hkdf.c.

112{
113
114 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
115
116 SYMCRYPT_MAC_STATE state;
117
118 PCSYMCRYPT_MAC pMacAlgorithm = pExpandedKey->macAlg;
119
120 SYMCRYPT_ALIGN BYTE rbPartialResult[SYMCRYPT_MAC_MAX_RESULT_SIZE];
121 BYTE * pbCurr = pbResult;
122
123 SIZE_T cbMacResultSize = pMacAlgorithm->resultSize;
124
125 BYTE cntr = 0x01;
126
127 // Check that cbResult <= 255*HashLen
128 if (cbResult > 0xff * cbMacResultSize)
129 {
130 scError = SYMCRYPT_WRONG_DATA_SIZE;
131 goto cleanup;
132 }
133
134 // In the first iteration T(0) is the empty string
135 // Calculate T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)
136 pMacAlgorithm->initFunc( &state, pExpandedKey );
137 pMacAlgorithm->appendFunc( &state, pbInfo, cbInfo );
138 pMacAlgorithm->appendFunc( &state, &cntr, sizeof(cntr) );
139 pMacAlgorithm->resultFunc( &state, rbPartialResult );
140
141 // Store the result in the output buffer
142 memcpy(pbCurr, rbPartialResult, SYMCRYPT_MIN(cbResult, cbMacResultSize));
143 if (cbResult <= cbMacResultSize)
144 {
145 goto cleanup;
146 }
147
148 // Update counters
149 cntr++;
150 pbCurr += cbMacResultSize;
151 cbResult -= cbMacResultSize;
152
153 while( cbResult > 0 )
154 {
155 // Calculate T(i) = HMAC-Hash(PRK, T(i-1) | info | 0xi)
156 pMacAlgorithm->initFunc( &state, pExpandedKey );
157 pMacAlgorithm->appendFunc( &state, rbPartialResult, cbMacResultSize );
158 pMacAlgorithm->appendFunc( &state, pbInfo, cbInfo );
159 pMacAlgorithm->appendFunc( &state, &cntr, sizeof(cntr) );
160 pMacAlgorithm->resultFunc( &state, rbPartialResult );
161
162 // Store the result in the output buffer
163 memcpy(pbCurr, rbPartialResult, SYMCRYPT_MIN(cbResult, cbMacResultSize));
164 if (cbResult <= cbMacResultSize)
165 {
166 goto cleanup;
167 }
168
169 // Update counters
170 cntr++;
171 pbCurr += cbMacResultSize;
172 cbResult -= cbMacResultSize;
173 }
174
175cleanup:
176 SymCryptWipeKnownSize(&rbPartialResult[0], sizeof(rbPartialResult));
177
178 return scError;
179}
_SYMCRYPT_MAC
Definition: symcrypt_internal.h:1767
_SYMCRYPT_MAC::resultFunc
PSYMCRYPT_MAC_RESULT resultFunc
Definition: symcrypt_internal.h:1771
_SYMCRYPT_MAC::appendFunc
PSYMCRYPT_MAC_APPEND appendFunc
Definition: symcrypt_internal.h:1770
_SYMCRYPT_MAC::resultSize
SIZE_T resultSize
Definition: symcrypt_internal.h:1774
_SYMCRYPT_MAC::initFunc
PSYMCRYPT_MAC_INIT initFunc
Definition: symcrypt_internal.h:1769
SYMCRYPT_MAC_MAX_RESULT_SIZE
#define SYMCRYPT_MAC_MAX_RESULT_SIZE
Definition: symcrypt_internal.h:1717
_SYMCRYPT_MAC_STATE
Definition: symcrypt_internal.h:1720

Referenced by SymCrypt802_11SaeCustomCreatePTGeneric(), and SymCryptHkdf().

◆ SymCryptHkdfExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExpandKey ( _Out_ PSYMCRYPT_HKDF_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbIkm) PCBYTE  pbIkm,
SIZE_T  cbIkm,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt 
)

Definition at line 18 of file hkdf.c.

25{
26 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
27
28 SYMCRYPT_ALIGN BYTE rbPrk[SYMCRYPT_MAC_MAX_RESULT_SIZE] = { 0 };
29
30 SYMCRYPT_ASSERT( macAlgorithm->expandedKeySize <= sizeof( pExpandedKey->macKey ) );
31
32 scError = SymCryptHkdfExtractPrk( macAlgorithm, pbIkm, cbIkm, pbSalt, cbSalt, rbPrk, macAlgorithm->resultSize );
33 if (scError != SYMCRYPT_NO_ERROR)
34 {
35 goto cleanup;
36 }
37
38 scError = SymCryptHkdfPrkExpandKey( pExpandedKey, macAlgorithm, rbPrk, macAlgorithm->resultSize );
39 if (scError != SYMCRYPT_NO_ERROR)
40 {
41 goto cleanup;
42 }
43
44cleanup:
45 SymCryptWipeKnownSize(&rbPrk[0], sizeof(rbPrk));
46
47 return scError;
48}
SymCryptHkdfExtractPrk
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExtractPrk(_In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbIkm) PCBYTE pbIkm, SIZE_T cbIkm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, _Out_writes_(cbPrk) PBYTE pbPrk, SIZE_T cbPrk)
Definition: hkdf.c:52
SymCryptHkdfPrkExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfPrkExpandKey(_Out_ PSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbPrk) PCBYTE pbPrk, SIZE_T cbPrk)
Definition: hkdf.c:92
_SYMCRYPT_MAC::expandedKeySize
SIZE_T expandedKeySize
Definition: symcrypt_internal.h:1772

Referenced by SymCrypt802_11SaeCustomCreatePTGeneric(), and SymCryptHkdf().

◆ SymCryptHkdfExtractPrk()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExtractPrk ( _In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbIkm) PCBYTE  pbIkm,
SIZE_T  cbIkm,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
_Out_writes_(cbPrk) PBYTE  pbPrk,
SIZE_T  cbPrk 
)

Definition at line 52 of file hkdf.c.

60{
61 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
62
63 SYMCRYPT_MAC_STATE state;
64 SYMCRYPT_MAC_EXPANDED_KEY key;
65
66 // Ensure that pbPrk is the correct size
67 if (cbPrk != macAlgorithm->resultSize)
68 {
69 scError = SYMCRYPT_INVALID_ARGUMENT;
70 goto cleanup;
71 }
72
73 // Calculation of PRK = HMAC-Hash(salt, IKM)
74 scError = macAlgorithm->expandKeyFunc( &key, pbSalt, cbSalt );
75 if (scError != SYMCRYPT_NO_ERROR)
76 {
77 goto cleanup;
78 }
79
80 macAlgorithm->initFunc( &state, &key );
81 macAlgorithm->appendFunc( &state, pbIkm, cbIkm );
82 macAlgorithm->resultFunc( &state, pbPrk );
83
84cleanup:
85 SymCryptWipeKnownSize(&key, sizeof(key));
86
87 return scError;
88}
_SYMCRYPT_MAC::expandKeyFunc
PSYMCRYPT_MAC_EXPAND_KEY expandKeyFunc
Definition: symcrypt_internal.h:1768
_SYMCRYPT_MAC_EXPANDED_KEY
Definition: symcrypt_internal.h:1740

Referenced by SymCryptHkdfExpandKey().

◆ SymCryptHkdfPrkExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfPrkExpandKey ( _Out_ PSYMCRYPT_HKDF_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbPrk) PCBYTE  pbPrk,
SIZE_T  cbPrk 
)

Definition at line 92 of file hkdf.c.

97{
98 SYMCRYPT_ASSERT( macAlgorithm->expandedKeySize <= sizeof( pExpandedKey->macKey ) );
99
100 pExpandedKey->macAlg = macAlgorithm;
101 return macAlgorithm->expandKeyFunc( &pExpandedKey->macKey, pbPrk, cbPrk );
102}

Referenced by SymCryptHkdfExpandKey().

◆ SymCryptHkdfSelfTest()

VOID SYMCRYPT_CALL SymCryptHkdfSelfTest ( void  )

◆ SymCryptHmac()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmac ( _In_ PCSYMCRYPT_HMAC_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(pExpandedKey->pHash->resultSize) PBYTE  pbResult 
)

Definition at line 184 of file hmac.c.

189{
190 SYMCRYPT_HMAC_STATE state;
191
192 SymCryptHmacInit( &state, pExpandedKey );
193 SymCryptHmacAppend( &state, pbData, cbData );
194 SymCryptHmacResult( &state, pbResult );
195}
SymCryptHmacResult
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacResult(_Inout_ PSYMCRYPT_HMAC_STATE pState, _Out_writes_(pState->pKey->pHash->resultSize) PBYTE pbResult)
Definition: hmac.c:141
SymCryptHmacAppend
VOID SYMCRYPT_CALL SymCryptHmacAppend(_Inout_ PSYMCRYPT_HMAC_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: hmac.c:130
SymCryptHmacInit
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacInit(_Out_ PSYMCRYPT_HMAC_STATE pState, _In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey)
Definition: hmac.c:115
SYMCRYPT_HMAC_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_STATE
Definition: symcrypt_internal.h:1539

Referenced by SymCryptHmacSha3_224(), SymCryptHmacSha3_256(), SymCryptHmacSha3_384(), and SymCryptHmacSha3_512().

◆ SymCryptHmacAppend()

VOID SYMCRYPT_CALL SymCryptHmacAppend ( _Inout_ PSYMCRYPT_HMAC_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 130 of file hmac.c.

134{
135 SymCryptHashAppend( pState->pKey->pHash, &pState->hash, pbData, cbData );
136}
SymCryptHashAppend
VOID SYMCRYPT_CALL SymCryptHashAppend(_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: hash.c:182

Referenced by SymCryptHmac(), SymCryptHmacSha3_224Append(), SymCryptHmacSha3_256Append(), SymCryptHmacSha3_384Append(), and SymCryptHmacSha3_512Append().

◆ SymCryptHmacExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacExpandKey ( _In_ PCSYMCRYPT_HASH  pHash,
_Out_ PSYMCRYPT_HMAC_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 53 of file hmac.c.

58{
59 // This buffer has to be large enough to hold one input block
60 // and the result of the hash function.
61 // Using SHA3-224 input block size to satisfy those requirements.
62 SYMCRYPT_ALIGN BYTE iblock[ SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE ];
63
64 SYMCRYPT_ASSERT( sizeof(iblock) >= pHash->inputBlockSize );
65 SYMCRYPT_ASSERT( sizeof(iblock) >= pHash->resultSize );
66
67 // XorByteIntoBuffer function updates the buffer in multiples of 8-bytes
68 SYMCRYPT_ASSERT( pHash->inputBlockSize % 8 == 0);
69
70 memset( iblock, 0, sizeof( iblock ) );
71
72 if( cbKey <= pHash->inputBlockSize )
73 {
74 if( cbKey > 0 )
75 {
76 memcpy( iblock, pbKey, cbKey );
77 }
78 }
79 else
80 {
81 SymCryptHash( pHash, pbKey, cbKey, iblock, pHash->resultSize );
82 }
83
84 XorByteIntoBuffer( iblock, pHash->inputBlockSize / 8, HMAC_IPAD_BYTE );
85
86 //
87 // Initialize the inner and outer states in the expanded key
88 //
89 SymCryptHashInit( pHash, &pExpandedKey->innerState );
90 SymCryptHashInit( pHash, &pExpandedKey->outerState );
91
92 // Update the inner state in the expanded key
93 SymCryptHashAppend( pHash, &pExpandedKey->innerState, iblock, pHash->inputBlockSize );
94
95 XorByteIntoBuffer( iblock, pHash->inputBlockSize / 8, HMAC_IPAD_BYTE ^ HMAC_OPAD_BYTE );
96
97 // Update the outer state in the expanded key
98 SymCryptHashAppend( pHash, &pExpandedKey->outerState, iblock, pHash->inputBlockSize );
99
100 SymCryptWipeKnownSize( iblock, sizeof( iblock ) );
101
102 // Save the hash function in the expanded key, it will be used in other
103 // generic HMAC function calls.
104 pExpandedKey->pHash = pHash;
105
106 SYMCRYPT_SET_MAGIC(pExpandedKey);
107
108 return SYMCRYPT_NO_ERROR;
109}
HMAC_IPAD_BYTE
#define HMAC_IPAD_BYTE
Definition: sc_lib.h:301
HMAC_OPAD_BYTE
#define HMAC_OPAD_BYTE
Definition: sc_lib.h:302
XorByteIntoBuffer
FORCEINLINE VOID SYMCRYPT_CALL XorByteIntoBuffer(_Inout_updates_(8 *cqBuf) PBYTE pbBuf, SIZE_T cqBuf, BYTE v)
Definition: sc_lib.h:915
memset
#define memset(x, y, z)
Definition: compat.h:39
SymCryptHashInit
VOID SYMCRYPT_CALL SymCryptHashInit(_In_ PCSYMCRYPT_HASH pHash, _Out_writes_bytes_(pHash->stateSize) PVOID pState)
Definition: hash.c:173
SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE
#define SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE
Definition: symcrypt.h:1561
SymCryptHash
VOID SYMCRYPT_CALL SymCryptHash(_In_ PCSYMCRYPT_HASH pHash, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
Definition: hash.c:155
inputBlockSize
UINT32 inputBlockSize
Definition: symcrypt_internal.h:921

Referenced by SymCryptHmacSha3_224ExpandKey(), SymCryptHmacSha3_256ExpandKey(), SymCryptHmacSha3_384ExpandKey(), and SymCryptHmacSha3_512ExpandKey().

◆ SymCryptHmacInit()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacInit ( _Out_ PSYMCRYPT_HMAC_STATE  pState,
_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY  pExpandedKey 
)

Definition at line 115 of file hmac.c.

118{
119 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
120
121 SymCryptHashStateCopy( pExpandedKey->pHash, &pExpandedKey->innerState, &pState->hash );
122
123 pState->pKey = pExpandedKey;
124
125 SYMCRYPT_SET_MAGIC(pState);
126}
SymCryptHashStateCopy
VOID SYMCRYPT_CALL SymCryptHashStateCopy(_In_ PCSYMCRYPT_HASH pHash, _In_reads_(pHash->stateSize) PCVOID pSrc, _Out_writes_(pHash->stateSize) PVOID pDst)
Definition: hash.c:210

Referenced by SymCryptHmac(), SymCryptHmacSha3_224Init(), SymCryptHmacSha3_256Init(), SymCryptHmacSha3_384Init(), and SymCryptHmacSha3_512Init().

◆ SymCryptHmacKeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacKeyCopy ( _In_ PCSYMCRYPT_HMAC_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_EXPANDED_KEY  pDst 
)

Definition at line 36 of file hmac.c.

39{
40 SYMCRYPT_CHECK_MAGIC( pSrc );
41
42 // Copy innerState and outerState
43 SymCryptHashStateCopy(pSrc->pHash, &pSrc->innerState, &pDst->innerState );
44 SymCryptHashStateCopy(pSrc->pHash, &pSrc->outerState, &pDst->outerState );
45
46 pDst->pHash = pSrc->pHash;
47
48 SYMCRYPT_SET_MAGIC( pDst );
49}

Referenced by SymCryptHmacSha3_224KeyCopy(), SymCryptHmacSha3_256KeyCopy(), SymCryptHmacSha3_384KeyCopy(), and SymCryptHmacSha3_512KeyCopy().

◆ SymCryptHmacMd5()

VOID SYMCRYPT_CALL SymCryptHmacMd5 ( _In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_MD5_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacMd5Selftest().

◆ SymCryptHmacMd5Append()

VOID SYMCRYPT_CALL SymCryptHmacMd5Append ( _Inout_ PSYMCRYPT_HMAC_MD5_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacMd5ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacMd5ExpandKey ( _Out_ PSYMCRYPT_HMAC_MD5_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacMd5Selftest(), and SymCryptTlsPrf1_1ExpandKey().

◆ SymCryptHmacMd5Init()

VOID SYMCRYPT_CALL SymCryptHmacMd5Init ( _Out_ PSYMCRYPT_HMAC_MD5_STATE  pState,
_In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacMd5KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacMd5KeyCopy ( _In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_MD5_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacMd5Result()

VOID SYMCRYPT_CALL SymCryptHmacMd5Result ( _Inout_ PSYMCRYPT_HMAC_MD5_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_MD5_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacMd5Selftest()

VOID SYMCRYPT_CALL SymCryptHmacMd5Selftest ( void  )

Definition at line 37 of file hmacmd5.c.

38{
39 SYMCRYPT_HMAC_MD5_EXPANDED_KEY xKey;
40 BYTE res[SYMCRYPT_HMAC_MD5_RESULT_SIZE];
41
42 SymCryptHmacMd5ExpandKey( &xKey, SymCryptTestKey32, 16 );
43 SymCryptHmacMd5( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
44
45 SymCryptInjectError( res, sizeof( res ) );
46
47 if( memcmp( res, hmacMd5Kat, sizeof( res ) ) != 0 )
48 {
49 SymCryptFatal( 'hmd5');
50 }
51
52 //
53 // Normally we would wipe the expanded key structure here,
54 // but as this is a selftest with known data this is not needed.
55 //
56}
hmacMd5Kat
static const BYTE hmacMd5Kat[16]
Definition: hmacmd5.c:31
SYMCRYPT_HMAC_MD5_RESULT_SIZE
#define SYMCRYPT_HMAC_MD5_RESULT_SIZE
Definition: symcrypt.h:2660
SymCryptHmacMd5ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacMd5ExpandKey(_Out_ PSYMCRYPT_HMAC_MD5_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SymCryptHmacMd5
VOID SYMCRYPT_CALL SymCryptHmacMd5(_In_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_MD5_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_HMAC_MD5_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_MD5_EXPANDED_KEY
Definition: symcrypt_internal.h:1313

◆ SymCryptHmacMd5StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacMd5StateCopy ( _In_ PCSYMCRYPT_HMAC_MD5_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_MD5_STATE  pDst 
)

◆ SymCryptHmacResult()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacResult ( _Inout_ PSYMCRYPT_HMAC_STATE  pState,
_Out_writes_(pState->pKey->pHash->resultSize) PBYTE  pbResult 
)

Definition at line 141 of file hmac.c.

144{
145 BYTE innerRes[64];
146
147 PCSYMCRYPT_HASH pHash = pState->pKey->pHash;
148
149 SYMCRYPT_ASSERT(sizeof(innerRes) >= pHash->resultSize);
150
151 SYMCRYPT_CHECK_MAGIC( pState );
152
153 //
154 // We have to buffer the inner hash result. We can't put it directly in the
155 // hash state data buffer as the Result() function wipes that buffer before returning.
156 //
157 SymCryptHashResult( pHash, &pState->hash, innerRes, pHash->resultSize );
158
159 SYMCRYPT_CHECK_MAGIC( pState->pKey )
160
161 SymCryptHashStateCopy( pHash, &pState->pKey->outerState, &pState->hash );
162
163 SymCryptHashAppend( pHash, &pState->hash, innerRes, pHash->resultSize );
164
165 SymCryptHashResult( pHash, &pState->hash, pbResult, pHash->resultSize );
166
167 //
168 // The SymCryptHashResult already wipes the hash state.
169 // We only need to wipe our own buffer.
170 //
171 // We also set the key pointer to NULL. This is not for security;
172 // it creates a clear error when callers forget to call the Init routine
173 // when re-using a state. Rather than the wrong result, they will get
174 // a NULL pointer exception, and they will fix their code.
175 //
176
177 SymCryptWipeKnownSize( innerRes, sizeof( innerRes ) );
178 pState->pKey = NULL;
179}
SymCryptHashResult
VOID SYMCRYPT_CALL SymCryptHashResult(_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
Definition: hash.c:193
outerState
SYMCRYPT_MD5_CHAINING_STATE outerState
Definition: symcrypt_internal.h:1311
PCSYMCRYPT_HASH
const SYMCRYPT_HASH * PCSYMCRYPT_HASH
Definition: symcrypt_internal.h:1182
resultSize
UINT32 resultSize
Definition: symcrypt_internal.h:1200
sizeof
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

Referenced by SymCryptHmac(), SymCryptHmacSha3_224Result(), SymCryptHmacSha3_256Result(), SymCryptHmacSha3_384Result(), and SymCryptHmacSha3_512Result().

◆ SymCryptHmacSha1()

VOID SYMCRYPT_CALL SymCryptHmacSha1 ( _In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA1_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha1Selftest().

◆ SymCryptHmacSha1Append()

VOID SYMCRYPT_CALL SymCryptHmacSha1Append ( _Inout_ PSYMCRYPT_HMAC_SHA1_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacSha1ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha1ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacSha1Selftest(), and SymCryptTlsPrf1_1ExpandKey().

◆ SymCryptHmacSha1Init()

VOID SYMCRYPT_CALL SymCryptHmacSha1Init ( _Out_ PSYMCRYPT_HMAC_SHA1_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacSha1KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha1KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha1Result()

VOID SYMCRYPT_CALL SymCryptHmacSha1Result ( _Inout_ PSYMCRYPT_HMAC_SHA1_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA1_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacSha1Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha1Selftest ( void  )

Definition at line 46 of file hmacsha1.c.

47{
48 SYMCRYPT_HMAC_SHA1_EXPANDED_KEY xKey;
49 BYTE res[SYMCRYPT_HMAC_SHA1_RESULT_SIZE];
50
51 SymCryptHmacSha1ExpandKey( &xKey, SymCryptTestKey32, 16 );
52 SymCryptHmacSha1( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
53
54 SymCryptInjectError( res, sizeof( res ) );
55
56 if( memcmp( res, hmacSha1Kat, sizeof( res ) ) != 0 )
57 {
58 SymCryptFatal( 'hSh1' );
59 }
60
61 //
62 // Normally we would wipe the expanded key structure here,
63 // but as this is a selftest with known data this is not needed.
64 //
65}
hmacSha1Kat
static const BYTE hmacSha1Kat[20]
Definition: hmacsha1.c:38
SymCryptHmacSha1
VOID SYMCRYPT_CALL SymCryptHmacSha1(_In_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA1_RESULT_SIZE) PBYTE pbResult)
SymCryptHmacSha1ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha1ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_HMAC_SHA1_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA1_RESULT_SIZE
Definition: symcrypt.h:2725
SYMCRYPT_HMAC_SHA1_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA1_EXPANDED_KEY
Definition: symcrypt_internal.h:1340

◆ SymCryptHmacSha1StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha1StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA1_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA1_STATE  pDst 
)

◆ SymCryptHmacSha224()

VOID SYMCRYPT_CALL SymCryptHmacSha224 ( _In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA224_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha224Selftest().

◆ SymCryptHmacSha224Append()

VOID SYMCRYPT_CALL SymCryptHmacSha224Append ( _Inout_ PSYMCRYPT_HMAC_SHA224_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacSha224ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha224ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA224_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacSha224Selftest().

◆ SymCryptHmacSha224Init()

VOID SYMCRYPT_CALL SymCryptHmacSha224Init ( _Out_ PSYMCRYPT_HMAC_SHA224_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacSha224KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha224KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA224_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha224Result()

VOID SYMCRYPT_CALL SymCryptHmacSha224Result ( _Inout_ PSYMCRYPT_HMAC_SHA224_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA224_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacSha224Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha224Selftest ( void  )

Definition at line 43 of file hmacsha224.c.

44{
45 SYMCRYPT_HMAC_SHA224_EXPANDED_KEY xKey;
46 BYTE res[SYMCRYPT_HMAC_SHA224_RESULT_SIZE];
47
48 SymCryptHmacSha224ExpandKey( &xKey, SymCryptTestKey32, 16 );
49 SymCryptHmacSha224( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
50
51 SymCryptInjectError( res, sizeof( res ) );
52
53 if( memcmp( res, hmacSha224Kat, sizeof( res ) ) != 0 )
54 {
55 SymCryptFatal( 'hsh4' );
56 }
57
58 //
59 // Normally we would wipe the expanded key structure here,
60 // but as this is a selftest with known data this is not needed.
61 //
62}
hmacSha224Kat
static const BYTE hmacSha224Kat[28]
Definition: hmacsha224.c:33
SYMCRYPT_HMAC_SHA224_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA224_RESULT_SIZE
Definition: symcrypt.h:2792
SymCryptHmacSha224ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha224ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SymCryptHmacSha224
VOID SYMCRYPT_CALL SymCryptHmacSha224(_In_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA224_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_HMAC_SHA224_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA224_EXPANDED_KEY
Definition: symcrypt_internal.h:1367

◆ SymCryptHmacSha224StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha224StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA224_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA224_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA224_STATE  pDst 
)

◆ SymCryptHmacSha256()

VOID SYMCRYPT_CALL SymCryptHmacSha256 ( _In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha256Selftest().

◆ SymCryptHmacSha256Append()

VOID SYMCRYPT_CALL SymCryptHmacSha256Append ( _Inout_ PSYMCRYPT_HMAC_SHA256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Referenced by SymCrypt802_11SaeCustomInit().

◆ SymCryptHmacSha256ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha256ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCrypt802_11SaeCustomInit(), and SymCryptHmacSha256Selftest().

◆ SymCryptHmacSha256Init()

VOID SYMCRYPT_CALL SymCryptHmacSha256Init ( _Out_ PSYMCRYPT_HMAC_SHA256_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY  pExpandedKey 
)

Referenced by SymCrypt802_11SaeCustomInit().

◆ SymCryptHmacSha256KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha256KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha256Result()

VOID SYMCRYPT_CALL SymCryptHmacSha256Result ( _Inout_ PSYMCRYPT_HMAC_SHA256_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCrypt802_11SaeCustomInit().

◆ SymCryptHmacSha256Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha256Selftest ( void  )

Definition at line 41 of file hmacsha256.c.

42{
43 SYMCRYPT_HMAC_SHA256_EXPANDED_KEY xKey;
44 BYTE res[SYMCRYPT_HMAC_SHA256_RESULT_SIZE];
45
46 SymCryptHmacSha256ExpandKey( &xKey, SymCryptTestKey32, 16 );
47 SymCryptHmacSha256( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
48
49 SymCryptInjectError( res, sizeof( res ) );
50
51 if( memcmp( res, hmacSha256Kat, sizeof( res ) ) != 0 )
52 {
53 SymCryptFatal( 'hsh2' );
54 }
55
56 //
57 // Normally we would wipe the expanded key structure here,
58 // but as this is a selftest with known data this is not needed.
59 //
60}
hmacSha256Kat
static const BYTE hmacSha256Kat[32]
Definition: hmacsha256.c:31
SymCryptHmacSha256ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha256ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_HMAC_SHA256_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA256_RESULT_SIZE
Definition: symcrypt.h:2856
SymCryptHmacSha256
VOID SYMCRYPT_CALL SymCryptHmacSha256(_In_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA256_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_HMAC_SHA256_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA256_EXPANDED_KEY
Definition: symcrypt_internal.h:1394

◆ SymCryptHmacSha256StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha256StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA256_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA256_STATE  pDst 
)

◆ SymCryptHmacSha384()

VOID SYMCRYPT_CALL SymCryptHmacSha384 ( _In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA384_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha384Selftest().

◆ SymCryptHmacSha384Append()

VOID SYMCRYPT_CALL SymCryptHmacSha384Append ( _Inout_ PSYMCRYPT_HMAC_SHA384_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacSha384ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha384ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacSha384Selftest().

◆ SymCryptHmacSha384Init()

VOID SYMCRYPT_CALL SymCryptHmacSha384Init ( _Out_ PSYMCRYPT_HMAC_SHA384_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacSha384KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha384KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha384Result()

VOID SYMCRYPT_CALL SymCryptHmacSha384Result ( _Inout_ PSYMCRYPT_HMAC_SHA384_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA384_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacSha384Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha384Selftest ( void  )

Definition at line 41 of file hmacsha384.c.

42{
43 SYMCRYPT_HMAC_SHA384_EXPANDED_KEY xKey;
44 BYTE res[SYMCRYPT_HMAC_SHA384_RESULT_SIZE];
45
46 SymCryptHmacSha384ExpandKey( &xKey, SymCryptTestKey32, 16 );
47 SymCryptHmacSha384( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
48
49 SymCryptInjectError( res, sizeof( res ) );
50 if( memcmp( res, hmacSha384Kat, sizeof( res ) ) != 0 )
51 {
52 SymCryptFatal( 'hsh3' );
53 }
54
55 //
56 // Normally we would wipe the expanded key structure here,
57 // but as this is a selftest with known data this is not needed.
58 //
59}
hmacSha384Kat
static const BYTE hmacSha384Kat[48]
Definition: hmacsha384.c:33
SymCryptHmacSha384ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha384ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SymCryptHmacSha384
VOID SYMCRYPT_CALL SymCryptHmacSha384(_In_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA384_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_HMAC_SHA384_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA384_RESULT_SIZE
Definition: symcrypt.h:2920
SYMCRYPT_HMAC_SHA384_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA384_EXPANDED_KEY
Definition: symcrypt_internal.h:1421

◆ SymCryptHmacSha384StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha384StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA384_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA384_STATE  pDst 
)

◆ SymCryptHmacSha3_224()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224 ( _In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 30 of file hmacsha3_224.c.

35{
36 SymCryptHmac(&pExpandedKey->generic, pbData, cbData, pbResult);
37}
SymCryptHmac
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmac(_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(pExpandedKey->pHash->resultSize) PBYTE pbResult)
Definition: hmac.c:184

Referenced by SymCryptHmacSha3_224Selftest().

◆ SymCryptHmacSha3_224Append()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224Append ( _Inout_ PSYMCRYPT_HMAC_SHA3_224_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file hmacsha3_224.c.

64{
65 SymCryptHmacAppend(&pState->generic, pbData, cbData);
66}
SymCryptHmacAppend
VOID SYMCRYPT_CALL SymCryptHmacAppend(_Inout_ PSYMCRYPT_HMAC_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: hmac.c:130

◆ SymCryptHmacSha3_224ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_224ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 11 of file hmacsha3_224.c.

15{
16 return SymCryptHmacExpandKey(SymCryptSha3_224Algorithm, &pExpandedKey->generic, pbKey, cbKey);
17}
SymCryptSha3_224Algorithm
const PCSYMCRYPT_HASH SymCryptSha3_224Algorithm
Definition: sha3_224.c:27
SymCryptHmacExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacExpandKey(_In_ PCSYMCRYPT_HASH pHash, _Out_ PSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: hmac.c:53

Referenced by SymCryptHmacSha3_224Selftest().

◆ SymCryptHmacSha3_224Init()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224Init ( _Out_ PSYMCRYPT_HMAC_SHA3_224_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY  pExpandedKey 
)

Definition at line 51 of file hmacsha3_224.c.

54{
55 SymCryptHmacInit(&pState->generic, &pExpandedKey->generic);
56}
SymCryptHmacInit
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacInit(_Out_ PSYMCRYPT_HMAC_STATE pState, _In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey)
Definition: hmac.c:115

◆ SymCryptHmacSha3_224KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY  pDst 
)

Definition at line 21 of file hmacsha3_224.c.

24{
25 SymCryptHmacKeyCopy(&pSrc->generic, &pDst->generic);
26}
SymCryptHmacKeyCopy
VOID SYMCRYPT_CALL SymCryptHmacKeyCopy(_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_EXPANDED_KEY pDst)
Definition: hmac.c:36

◆ SymCryptHmacSha3_224Result()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224Result ( _Inout_ PSYMCRYPT_HMAC_SHA3_224_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 70 of file hmacsha3_224.c.

73{
74 SymCryptHmacResult(&pState->generic, pbResult);
75}
SymCryptHmacResult
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacResult(_Inout_ PSYMCRYPT_HMAC_STATE pState, _Out_writes_(pState->pKey->pHash->resultSize) PBYTE pbResult)
Definition: hmac.c:141

◆ SymCryptHmacSha3_224Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224Selftest ( void  )

Definition at line 103 of file hmacsha3_224.c.

104{
105 SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY xKey;
106 BYTE res[SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE];
107
108 SymCryptHmacSha3_224ExpandKey( &xKey, SymCryptTestKey32, 16 );
109 SymCryptHmacSha3_224( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
110
111 SymCryptInjectError( res, sizeof( res ) );
112
113 if( memcmp( res, hmacSha3_224Kat, sizeof( res ) ) != 0 )
114 {
115 SymCryptFatal( 'hsh3' );
116 }
117
118 //
119 // Normally we would wipe the expanded key structure here,
120 // but as this is a selftest with known data this is not needed.
121 //
122}
SymCryptHmacSha3_224
VOID SYMCRYPT_CALL SymCryptHmacSha3_224(_In_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE) PBYTE pbResult)
Definition: hmacsha3_224.c:30
hmacSha3_224Kat
static const BYTE hmacSha3_224Kat[28]
Definition: hmacsha3_224.c:93
SymCryptHmacSha3_224ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_224ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: hmacsha3_224.c:11
SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA3_224_RESULT_SIZE
Definition: symcrypt.h:3182
SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY
SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY
Definition: symcrypt_internal.h:1551

◆ SymCryptHmacSha3_224StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_224StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_224_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA3_224_STATE  pDst 
)

Definition at line 41 of file hmacsha3_224.c.

45{
46 SymCryptHmacStateCopy(&pSrc->generic, pExpandedKey == NULL ? NULL : &pExpandedKey->generic, &pDst->generic);
47}
SymCryptHmacStateCopy
VOID SYMCRYPT_CALL SymCryptHmacStateCopy(_In_ PCSYMCRYPT_HMAC_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_STATE pDst)
Definition: hmac.c:10

◆ SymCryptHmacSha3_256()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256 ( _In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 30 of file hmacsha3_256.c.

35{
36 SymCryptHmac(&pExpandedKey->generic, pbData, cbData, pbResult);
37}

Referenced by SymCryptHmacSha3_256Selftest().

◆ SymCryptHmacSha3_256Append()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256Append ( _Inout_ PSYMCRYPT_HMAC_SHA3_256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file hmacsha3_256.c.

64{
65 SymCryptHmacAppend(&pState->generic, pbData, cbData);
66}

◆ SymCryptHmacSha3_256ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_256ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 11 of file hmacsha3_256.c.

15{
16 return SymCryptHmacExpandKey(SymCryptSha3_256Algorithm, &pExpandedKey->generic, pbKey, cbKey);
17}
SymCryptSha3_256Algorithm
const PCSYMCRYPT_HASH SymCryptSha3_256Algorithm
Definition: sha3_256.c:27

Referenced by SymCryptHmacSha3_256Selftest().

◆ SymCryptHmacSha3_256Init()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256Init ( _Out_ PSYMCRYPT_HMAC_SHA3_256_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY  pExpandedKey 
)

Definition at line 51 of file hmacsha3_256.c.

54{
55 SymCryptHmacInit(&pState->generic, &pExpandedKey->generic);
56}

◆ SymCryptHmacSha3_256KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY  pDst 
)

Definition at line 21 of file hmacsha3_256.c.

24{
25 SymCryptHmacKeyCopy(&pSrc->generic, &pDst->generic);
26}

◆ SymCryptHmacSha3_256Result()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256Result ( _Inout_ PSYMCRYPT_HMAC_SHA3_256_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 70 of file hmacsha3_256.c.

73{
74 SymCryptHmacResult(&pState->generic, pbResult);
75}

◆ SymCryptHmacSha3_256Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256Selftest ( void  )

Definition at line 103 of file hmacsha3_256.c.

104{
105 SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY xKey;
106 BYTE res[SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE];
107
108 SymCryptHmacSha3_256ExpandKey( &xKey, SymCryptTestKey32, 16 );
109 SymCryptHmacSha3_256( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
110
111 SymCryptInjectError( res, sizeof( res ) );
112
113 if( memcmp( res, hmacSha3_256Kat, sizeof( res ) ) != 0 )
114 {
115 SymCryptFatal( 'hsh3' );
116 }
117
118 //
119 // Normally we would wipe the expanded key structure here,
120 // but as this is a selftest with known data this is not needed.
121 //
122}
SymCryptHmacSha3_256
VOID SYMCRYPT_CALL SymCryptHmacSha3_256(_In_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE) PBYTE pbResult)
Definition: hmacsha3_256.c:30
SymCryptHmacSha3_256ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_256ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: hmacsha3_256.c:11
hmacSha3_256Kat
static const BYTE hmacSha3_256Kat[32]
Definition: hmacsha3_256.c:93
SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA3_256_RESULT_SIZE
Definition: symcrypt.h:3246
SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY
SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY
Definition: symcrypt_internal.h:1575

◆ SymCryptHmacSha3_256StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_256StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_256_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA3_256_STATE  pDst 
)

Definition at line 41 of file hmacsha3_256.c.

45{
46 SymCryptHmacStateCopy(&pSrc->generic, pExpandedKey == NULL ? NULL : &pExpandedKey->generic, &pDst->generic);
47}

◆ SymCryptHmacSha3_384()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384 ( _In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 30 of file hmacsha3_384.c.

35{
36 SymCryptHmac(&pExpandedKey->generic, pbData, cbData, pbResult);
37}

Referenced by SymCryptHmacSha3_384Selftest().

◆ SymCryptHmacSha3_384Append()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384Append ( _Inout_ PSYMCRYPT_HMAC_SHA3_384_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file hmacsha3_384.c.

64{
65 SymCryptHmacAppend(&pState->generic, pbData, cbData);
66}

◆ SymCryptHmacSha3_384ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_384ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 11 of file hmacsha3_384.c.

15{
16 return SymCryptHmacExpandKey(SymCryptSha3_384Algorithm, &pExpandedKey->generic, pbKey, cbKey);
17}
SymCryptSha3_384Algorithm
const PCSYMCRYPT_HASH SymCryptSha3_384Algorithm
Definition: sha3_384.c:27

Referenced by SymCryptHmacSha3_384Selftest().

◆ SymCryptHmacSha3_384Init()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384Init ( _Out_ PSYMCRYPT_HMAC_SHA3_384_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY  pExpandedKey 
)

Definition at line 51 of file hmacsha3_384.c.

54{
55 SymCryptHmacInit(&pState->generic, &pExpandedKey->generic);
56}

◆ SymCryptHmacSha3_384KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY  pDst 
)

Definition at line 21 of file hmacsha3_384.c.

24{
25 SymCryptHmacKeyCopy(&pSrc->generic, &pDst->generic);
26}

◆ SymCryptHmacSha3_384Result()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384Result ( _Inout_ PSYMCRYPT_HMAC_SHA3_384_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 70 of file hmacsha3_384.c.

73{
74 SymCryptHmacResult(&pState->generic, pbResult);
75}

◆ SymCryptHmacSha3_384Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384Selftest ( void  )

Definition at line 105 of file hmacsha3_384.c.

106{
107 SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY xKey;
108 BYTE res[SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE];
109
110 SymCryptHmacSha3_384ExpandKey( &xKey, SymCryptTestKey32, 24 );
111 SymCryptHmacSha3_384( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
112
113 SymCryptInjectError( res, sizeof( res ) );
114
115 if( memcmp( res, hmacSha3_384Kat, sizeof( res ) ) != 0 )
116 {
117 SymCryptFatal( 'hsh3' );
118 }
119
120 //
121 // Normally we would wipe the expanded key structure here,
122 // but as this is a selftest with known data this is not needed.
123 //
124}
hmacSha3_384Kat
static const BYTE hmacSha3_384Kat[48]
Definition: hmacsha3_384.c:93
SymCryptHmacSha3_384
VOID SYMCRYPT_CALL SymCryptHmacSha3_384(_In_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE) PBYTE pbResult)
Definition: hmacsha3_384.c:30
SymCryptHmacSha3_384ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_384ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: hmacsha3_384.c:11
SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA3_384_RESULT_SIZE
Definition: symcrypt.h:3310
SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY
SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY
Definition: symcrypt_internal.h:1599

◆ SymCryptHmacSha3_384StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_384StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_384_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA3_384_STATE  pDst 
)

Definition at line 41 of file hmacsha3_384.c.

45{
46 SymCryptHmacStateCopy(&pSrc->generic, pExpandedKey == NULL ? NULL : &pExpandedKey->generic, &pDst->generic);
47}

◆ SymCryptHmacSha3_512()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512 ( _In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 30 of file hmacsha3_512.c.

35{
36 SymCryptHmac(&pExpandedKey->generic, pbData, cbData, pbResult);
37}

Referenced by SymCryptHmacSha3_512Selftest().

◆ SymCryptHmacSha3_512Append()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512Append ( _Inout_ PSYMCRYPT_HMAC_SHA3_512_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file hmacsha3_512.c.

64{
65 SymCryptHmacAppend(&pState->generic, pbData, cbData);
66}

◆ SymCryptHmacSha3_512ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_512ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 11 of file hmacsha3_512.c.

15{
16 return SymCryptHmacExpandKey(SymCryptSha3_512Algorithm, &pExpandedKey->generic, pbKey, cbKey);
17}
SymCryptSha3_512Algorithm
const PCSYMCRYPT_HASH SymCryptSha3_512Algorithm
Definition: sha3_512.c:27

Referenced by SymCryptHmacSha3_512Selftest().

◆ SymCryptHmacSha3_512Init()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512Init ( _Out_ PSYMCRYPT_HMAC_SHA3_512_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY  pExpandedKey 
)

Definition at line 51 of file hmacsha3_512.c.

54{
55 SymCryptHmacInit(&pState->generic, &pExpandedKey->generic);
56}

◆ SymCryptHmacSha3_512KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY  pDst 
)

Definition at line 21 of file hmacsha3_512.c.

24{
25 SymCryptHmacKeyCopy(&pSrc->generic, &pDst->generic);
26}

◆ SymCryptHmacSha3_512Result()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512Result ( _Inout_ PSYMCRYPT_HMAC_SHA3_512_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 70 of file hmacsha3_512.c.

73{
74 SymCryptHmacResult(&pState->generic, pbResult);
75}

◆ SymCryptHmacSha3_512Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512Selftest ( void  )

Definition at line 107 of file hmacsha3_512.c.

108{
109 SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY xKey;
110 BYTE res[SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE];
111
112 SymCryptHmacSha3_512ExpandKey( &xKey, SymCryptTestKey32, 32 );
113 SymCryptHmacSha3_512( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
114
115 SymCryptInjectError( res, sizeof( res ) );
116
117 if( memcmp( res, hmacSha3_512Kat, sizeof( res ) ) != 0 )
118 {
119 SymCryptFatal( 'hsh3' );
120 }
121
122 //
123 // Normally we would wipe the expanded key structure here,
124 // but as this is a selftest with known data this is not needed.
125 //
126}
SymCryptHmacSha3_512
VOID SYMCRYPT_CALL SymCryptHmacSha3_512(_In_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE) PBYTE pbResult)
Definition: hmacsha3_512.c:30
hmacSha3_512Kat
static const BYTE hmacSha3_512Kat[64]
Definition: hmacsha3_512.c:93
SymCryptHmacSha3_512ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha3_512ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: hmacsha3_512.c:11
SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA3_512_RESULT_SIZE
Definition: symcrypt.h:3374
SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY
SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY
Definition: symcrypt_internal.h:1623

◆ SymCryptHmacSha3_512StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha3_512StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA3_512_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA3_512_STATE  pDst 
)

Definition at line 41 of file hmacsha3_512.c.

45{
46 SymCryptHmacStateCopy(&pSrc->generic, pExpandedKey == NULL ? NULL : &pExpandedKey->generic, &pDst->generic);
47}

◆ SymCryptHmacSha512()

VOID SYMCRYPT_CALL SymCryptHmacSha512 ( _In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA512_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha512Selftest().

◆ SymCryptHmacSha512_224()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224 ( _In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha512_224Selftest().

◆ SymCryptHmacSha512_224Append()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224Append ( _Inout_ PSYMCRYPT_HMAC_SHA512_224_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacSha512_224ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512_224ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacSha512_224Selftest().

◆ SymCryptHmacSha512_224Init()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224Init ( _Out_ PSYMCRYPT_HMAC_SHA512_224_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacSha512_224KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha512_224Result()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224Result ( _Inout_ PSYMCRYPT_HMAC_SHA512_224_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacSha512_224Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224Selftest ( void  )

Definition at line 43 of file hmacsha512_224.c.

44{
45 SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY xKey;
46 BYTE res[SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE];
47
48 SymCryptHmacSha512_224ExpandKey( &xKey, SymCryptTestKey32, 16 );
49 SymCryptHmacSha512_224( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
50
51 SymCryptInjectError( res, sizeof( res ) );
52
53 if( memcmp( res, hmacSha512_224Kat, sizeof( res ) ) != 0 )
54 {
55 SymCryptFatal( 'hsh4' );
56 }
57
58 //
59 // Normally we would wipe the expanded key structure here,
60 // but as this is a selftest with known data this is not needed.
61 //
62}
hmacSha512_224Kat
static const BYTE hmacSha512_224Kat[28]
Definition: hmacsha512_224.c:33
SymCryptHmacSha512_224ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512_224ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE
Definition: symcrypt.h:3050
SymCryptHmacSha512_224
VOID SYMCRYPT_CALL SymCryptHmacSha512_224(_In_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA512_224_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY
Definition: symcrypt_internal.h:1473

◆ SymCryptHmacSha512_224StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha512_224StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA512_224_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA512_224_STATE  pDst 
)

◆ SymCryptHmacSha512_256()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256 ( _In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptHmacSha512_256Selftest().

◆ SymCryptHmacSha512_256Append()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256Append ( _Inout_ PSYMCRYPT_HMAC_SHA512_256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacSha512_256ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512_256ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacSha512_256Selftest().

◆ SymCryptHmacSha512_256Init()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256Init ( _Out_ PSYMCRYPT_HMAC_SHA512_256_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacSha512_256KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha512_256Result()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256Result ( _Inout_ PSYMCRYPT_HMAC_SHA512_256_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacSha512_256Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256Selftest ( void  )

Definition at line 43 of file hmacsha512_256.c.

44{
45 SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY xKey;
46 BYTE res[SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE];
47
48 SymCryptHmacSha512_256ExpandKey( &xKey, SymCryptTestKey32, 16 );
49 SymCryptHmacSha512_256( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
50
51 SymCryptInjectError( res, sizeof( res ) );
52
53 if( memcmp( res, hmacSha512_256Kat, sizeof( res ) ) != 0 )
54 {
55 SymCryptFatal( 'hsh4' );
56 }
57
58 //
59 // Normally we would wipe the expanded key structure here,
60 // but as this is a selftest with known data this is not needed.
61 //
62}
hmacSha512_256Kat
static const BYTE hmacSha512_256Kat[32]
Definition: hmacsha512_256.c:33
SymCryptHmacSha512_256
VOID SYMCRYPT_CALL SymCryptHmacSha512_256(_In_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE) PBYTE pbResult)
SymCryptHmacSha512_256ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512_256ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA512_256_RESULT_SIZE
Definition: symcrypt.h:3116
SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY
Definition: symcrypt_internal.h:1499

◆ SymCryptHmacSha512_256StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha512_256StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA512_256_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA512_256_STATE  pDst 
)

◆ SymCryptHmacSha512Append()

VOID SYMCRYPT_CALL SymCryptHmacSha512Append ( _Inout_ PSYMCRYPT_HMAC_SHA512_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptHmacSha512ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512ExpandKey ( _Out_ PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Referenced by SymCryptHmacSha512Selftest().

◆ SymCryptHmacSha512Init()

VOID SYMCRYPT_CALL SymCryptHmacSha512Init ( _Out_ PSYMCRYPT_HMAC_SHA512_STATE  pState,
_In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptHmacSha512KeyCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha512KeyCopy ( _In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY  pDst 
)

◆ SymCryptHmacSha512Result()

VOID SYMCRYPT_CALL SymCryptHmacSha512Result ( _Inout_ PSYMCRYPT_HMAC_SHA512_STATE  pState,
_Out_writes_(SYMCRYPT_HMAC_SHA512_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptHmacSha512Selftest()

VOID SYMCRYPT_CALL SymCryptHmacSha512Selftest ( void  )

Definition at line 41 of file hmacsha512.c.

42{
43 SYMCRYPT_HMAC_SHA512_EXPANDED_KEY xKey;
44 BYTE res[SYMCRYPT_HMAC_SHA512_RESULT_SIZE];
45
46 SymCryptHmacSha512ExpandKey( &xKey, SymCryptTestKey32, 16 );
47 SymCryptHmacSha512( &xKey, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
48
49 SymCryptInjectError( res, sizeof( res ) );
50 if( memcmp( res, hmacSha512Kat, sizeof( res ) ) != 0 )
51 {
52 SymCryptFatal( 'hsh5' );
53 }
54
55 //
56 // Normally we would wipe the expanded key structure here,
57 // but as this is a selftest with known data this is not needed.
58 //
59}
hmacSha512Kat
static const BYTE hmacSha512Kat[64]
Definition: hmacsha512.c:31
SymCryptHmacSha512
VOID SYMCRYPT_CALL SymCryptHmacSha512(_In_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_HMAC_SHA512_RESULT_SIZE) PBYTE pbResult)
SymCryptHmacSha512ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacSha512ExpandKey(_Out_ PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_HMAC_SHA512_RESULT_SIZE
#define SYMCRYPT_HMAC_SHA512_RESULT_SIZE
Definition: symcrypt.h:2984
SYMCRYPT_HMAC_SHA512_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_SHA512_EXPANDED_KEY
Definition: symcrypt_internal.h:1447

◆ SymCryptHmacSha512StateCopy()

VOID SYMCRYPT_CALL SymCryptHmacSha512StateCopy ( _In_ PCSYMCRYPT_HMAC_SHA512_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_SHA512_STATE  pDst 
)

◆ SymCryptHmacStateCopy()

VOID SYMCRYPT_CALL SymCryptHmacStateCopy ( _In_ PCSYMCRYPT_HMAC_STATE  pSrc,
_In_opt_ PCSYMCRYPT_HMAC_EXPANDED_KEY  pExpandedKey,
_Out_ PSYMCRYPT_HMAC_STATE  pDst 
)

Definition at line 10 of file hmac.c.

14{
15 SYMCRYPT_CHECK_MAGIC( pSrc );
16
17 PCSYMCRYPT_HASH pHash = pSrc->pKey->pHash;
18
19 SymCryptHashStateCopy( pHash, &pSrc->hash, &pDst->hash );
20
21 if( pExpandedKey != NULL )
22 {
23 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
24 pDst->pKey = pExpandedKey;
25 }
26 else
27 {
28 SYMCRYPT_CHECK_MAGIC( pSrc->pKey );
29 pDst->pKey = pSrc->pKey;
30 }
31 SYMCRYPT_SET_MAGIC( pDst );
32}

Referenced by SymCryptHmacSha3_224StateCopy(), SymCryptHmacSha3_256StateCopy(), SymCryptHmacSha3_384StateCopy(), and SymCryptHmacSha3_512StateCopy().

◆ SymCryptInit()

VOID SYMCRYPT_CALL SymCryptInit ( void  )

Referenced by DllMain().

◆ SymCryptKmac128()

VOID SYMCRYPT_CALL SymCryptKmac128 ( _In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbInput) PCBYTE  pbInput,
SIZE_T  cbInput,
_Out_writes_bytes_(SYMCRYPT_KMAC128_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptKmac128Selftest().

◆ SymCryptKmac128Append()

VOID SYMCRYPT_CALL SymCryptKmac128Append ( _Inout_ PSYMCRYPT_KMAC128_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptKmac128Ex()

VOID SYMCRYPT_CALL SymCryptKmac128Ex ( _In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbInput) PCBYTE  pbInput,
SIZE_T  cbInput,
_Out_writes_bytes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

◆ SymCryptKmac128ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac128ExpandKey ( _Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

◆ SymCryptKmac128ExpandKeyEx()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac128ExpandKeyEx ( _Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_bytes_(cbCustomizationString) PCBYTE  pbCustomizationString,
SIZE_T  cbCustomizationString 
)

Referenced by SymCryptKmac128Selftest(), and SymCryptSskdfMacExpandSalt().

◆ SymCryptKmac128Extract()

VOID SYMCRYPT_CALL SymCryptKmac128Extract ( _Inout_ PSYMCRYPT_KMAC128_STATE  pState,
_Out_writes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput,
BOOLEAN  bWipe 
)

◆ SymCryptKmac128Init()

VOID SYMCRYPT_CALL SymCryptKmac128Init ( _Out_ PSYMCRYPT_KMAC128_STATE  pState,
_In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptKmac128KeyCopy()

VOID SYMCRYPT_CALL SymCryptKmac128KeyCopy ( _In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY  pDst 
)

◆ SymCryptKmac128Result()

VOID SYMCRYPT_CALL SymCryptKmac128Result ( _Inout_ PSYMCRYPT_KMAC128_STATE  pState,
_Out_writes_(SYMCRYPT_KMAC128_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptKmac128ResultEx()

VOID SYMCRYPT_CALL SymCryptKmac128ResultEx ( _Inout_ PSYMCRYPT_KMAC128_STATE  pState,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Referenced by SymCryptSskdfMacDerive().

◆ SymCryptKmac128Selftest()

VOID SYMCRYPT_CALL SymCryptKmac128Selftest ( void  )

Definition at line 49 of file kmac.c.

50{
51 BYTE result[SYMCRYPT_KMAC128_RESULT_SIZE];
52 static const unsigned char Sstr[] = { 'S' };
53 SYMCRYPT_KMAC128_EXPANDED_KEY expandedKey;
54
55 SymCryptKmac128ExpandKeyEx(&expandedKey, SymCryptTestKey32, 16, Sstr, sizeof(Sstr));
56
57 SymCryptKmac128(&expandedKey, SymCryptTestMsg16, sizeof(SymCryptTestMsg16), result);
58
59 SymCryptInjectError(result, sizeof(result));
60
61 if (memcmp(result, kmac128KATAnswer, sizeof(result)) != 0)
62 {
63 SymCryptFatal('kmac');
64 }
65}
kmac128KATAnswer
static const BYTE kmac128KATAnswer[SYMCRYPT_KMAC128_RESULT_SIZE]
Definition: kmac.c:40
SYMCRYPT_KMAC128_RESULT_SIZE
#define SYMCRYPT_KMAC128_RESULT_SIZE
Definition: symcrypt.h:3674
SymCryptKmac128ExpandKeyEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac128ExpandKeyEx(_Out_ PSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_bytes_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)
SymCryptKmac128
VOID SYMCRYPT_CALL SymCryptKmac128(_In_ PCSYMCRYPT_KMAC128_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, _Out_writes_bytes_(SYMCRYPT_KMAC128_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_KMAC128_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_KMAC128_EXPANDED_KEY
Definition: symcrypt_internal.h:1033

◆ SymCryptKmac128StateCopy()

VOID SYMCRYPT_CALL SymCryptKmac128StateCopy ( _In_ const SYMCRYPT_KMAC128_STATE *  pSrc,
_Out_ SYMCRYPT_KMAC128_STATE *  pDst 
)

◆ SymCryptKmac256()

VOID SYMCRYPT_CALL SymCryptKmac256 ( _In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbInput) PCBYTE  pbInput,
SIZE_T  cbInput,
_Out_writes_bytes_(SYMCRYPT_KMAC256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptKmac256Selftest().

◆ SymCryptKmac256Append()

VOID SYMCRYPT_CALL SymCryptKmac256Append ( _Inout_ PSYMCRYPT_KMAC256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

◆ SymCryptKmac256Ex()

VOID SYMCRYPT_CALL SymCryptKmac256Ex ( _In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbInput) PCBYTE  pbInput,
SIZE_T  cbInput,
_Out_writes_bytes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

◆ SymCryptKmac256ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac256ExpandKey ( _Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

◆ SymCryptKmac256ExpandKeyEx()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac256ExpandKeyEx ( _Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY  pExpandedKey,
_In_reads_bytes_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_bytes_(cbCustomizationString) PCBYTE  pbCustomizationString,
SIZE_T  cbCustomizationString 
)

Referenced by SymCryptKmac256Selftest(), and SymCryptSskdfMacExpandSalt().

◆ SymCryptKmac256Extract()

VOID SYMCRYPT_CALL SymCryptKmac256Extract ( _Inout_ PSYMCRYPT_KMAC256_STATE  pState,
_Out_writes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput,
BOOLEAN  bWipe 
)

◆ SymCryptKmac256Init()

VOID SYMCRYPT_CALL SymCryptKmac256Init ( _Out_ PSYMCRYPT_KMAC256_STATE  pState,
_In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY  pExpandedKey 
)

◆ SymCryptKmac256KeyCopy()

VOID SYMCRYPT_CALL SymCryptKmac256KeyCopy ( _In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY  pDst 
)

◆ SymCryptKmac256Result()

VOID SYMCRYPT_CALL SymCryptKmac256Result ( _Inout_ PSYMCRYPT_KMAC256_STATE  pState,
_Out_writes_(SYMCRYPT_KMAC256_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptKmac256ResultEx()

VOID SYMCRYPT_CALL SymCryptKmac256ResultEx ( _Inout_ PSYMCRYPT_KMAC256_STATE  pState,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Referenced by SymCryptSskdfMacDerive().

◆ SymCryptKmac256Selftest()

VOID SYMCRYPT_CALL SymCryptKmac256Selftest ( void  )

Definition at line 107 of file kmac.c.

108{
109 BYTE result[SYMCRYPT_KMAC256_RESULT_SIZE];
110 static const unsigned char Sstr[] = { 'S' };
111 SYMCRYPT_KMAC256_EXPANDED_KEY expandedKey;
112
113 SymCryptKmac256ExpandKeyEx(&expandedKey, SymCryptTestKey32, 32, Sstr, sizeof(Sstr));
114
115 SymCryptKmac256(&expandedKey, SymCryptTestMsg16, sizeof(SymCryptTestMsg16), result);
116
117 SymCryptInjectError(result, sizeof(result));
118
119 if (memcmp(result, kmac256KATAnswer, sizeof(result)) != 0)
120 {
121 SymCryptFatal('kmac');
122 }
123}
kmac256KATAnswer
static const BYTE kmac256KATAnswer[SYMCRYPT_KMAC256_RESULT_SIZE]
Definition: kmac.c:98
SYMCRYPT_KMAC256_RESULT_SIZE
#define SYMCRYPT_KMAC256_RESULT_SIZE
Definition: symcrypt.h:3762
SymCryptKmac256ExpandKeyEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptKmac256ExpandKeyEx(_Out_ PSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_bytes_(cbCustomizationString) PCBYTE pbCustomizationString, SIZE_T cbCustomizationString)
SymCryptKmac256
VOID SYMCRYPT_CALL SymCryptKmac256(_In_ PCSYMCRYPT_KMAC256_EXPANDED_KEY pExpandedKey, _In_reads_bytes_(cbInput) PCBYTE pbInput, SIZE_T cbInput, _Out_writes_bytes_(SYMCRYPT_KMAC256_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_KMAC256_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_KMAC256_EXPANDED_KEY
Definition: symcrypt_internal.h:1057

◆ SymCryptKmac256StateCopy()

VOID SYMCRYPT_CALL SymCryptKmac256StateCopy ( _In_ const SYMCRYPT_KMAC256_STATE *  pSrc,
_Out_ SYMCRYPT_KMAC256_STATE *  pDst 
)

◆ SymCryptLmskeyAllocate()

PSYMCRYPT_LMS_KEY SYMCRYPT_CALL SymCryptLmskeyAllocate ( _In_ PCSYMCRYPT_LMS_PARAMS  pParams,
UINT32  flags 
)

Definition at line 543 of file lms.c.

546{
547 PSYMCRYPT_LMS_KEY pKey = NULL;
548 SIZE_T cbSize = sizeof(SYMCRYPT_LMS_KEY);
549
550 if (flags != 0)
551 {
552 goto cleanup;
553 }
554
555 pKey = SymCryptCallbackAlloc(cbSize);
556 if (pKey == NULL)
557 {
558 goto cleanup;
559 }
560
561 SymCryptWipe(pKey, cbSize);
562 pKey->cbSize = cbSize;
563
564 memcpy(&pKey->params, pParams, sizeof(*pParams));
565 SYMCRYPT_SET_MAGIC(pKey);
566
567cleanup:
568 return pKey;
569}
PSYMCRYPT_LMS_KEY
SYMCRYPT_LMS_KEY * PSYMCRYPT_LMS_KEY
Definition: symcrypt_internal.h:3150
cbSize
UINT32 cbSize
Definition: symcrypt_internal.h:2409
SYMCRYPT_LMS_KEY
struct _SYMCRYPT_LMS_KEY SYMCRYPT_LMS_KEY
Definition: symcrypt_internal.h:3149

◆ SymCryptLmskeyFree()

VOID SYMCRYPT_CALL SymCryptLmskeyFree ( _Inout_ PSYMCRYPT_LMS_KEY  pKey)

Definition at line 573 of file lms.c.

575{
576 SYMCRYPT_CHECK_MAGIC(pKey);
577
578 SymCryptWipeKnownSize(pKey, sizeof(*pKey));
579 SymCryptCallbackFree(pKey);
580}

◆ SymCryptLmskeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmskeyGenerate ( _Inout_ PSYMCRYPT_LMS_KEY  pKey,
UINT32  flags 
)

Definition at line 619 of file lms.c.

622{
623 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
624
625 SYMCRYPT_CHECK_MAGIC(pKey);
626
627 if (flags != 0)
628 {
629 scError = SYMCRYPT_INVALID_ARGUMENT;
630 goto cleanup;
631 }
632
633 pKey->nNextUnusedLeaf = 0;
634 // Set the LMS key identifier I
635 scError = SymCryptCallbackRandom(pKey->abId, SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE);
636 if (scError != SYMCRYPT_NO_ERROR)
637 {
638 goto cleanup;
639 }
640
641 // Set the private key Seed value
642 scError = SymCryptCallbackRandom(pKey->abSeed, pKey->params.cbHashOutput);
643 if (scError != SYMCRYPT_NO_ERROR)
644 {
645 goto cleanup;
646 }
647
648 // compute the public root from the private key
649 LmsComputeNodeValue(
650 pKey,
651 1,
652 pKey->abPublicRoot,
653 pKey->params.cbHashOutput);
654
655 pKey->keyType = SYMCRYPT_LMSKEY_TYPE_PRIVATE;
656
657cleanup:
658 if (scError != SYMCRYPT_NO_ERROR)
659 {
660 LmskeyWipe(pKey);
661 }
662 return scError;
663}
LmsComputeNodeValue
static VOID SYMCRYPT_CALL LmsComputeNodeValue(_In_ PCSYMCRYPT_LMS_KEY pKey, UINT32 nIndex, _Out_writes_bytes_(pKey->params.cbHashOutput) PBYTE pbNodeValue, SIZE_T cbNodeValue)
Definition: lms.c:318
LmskeyWipe
static VOID SYMCRYPT_CALL LmskeyWipe(_Inout_ PSYMCRYPT_LMS_KEY pKey)
Definition: lms.c:156
SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE
#define SYMCRYPT_LMS_KEY_PAIR_IDENTIFIER_SIZE
Definition: sc_lib.h:4702

◆ SymCryptLmskeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmskeyGetValue ( _In_ PCSYMCRYPT_LMS_KEY  pKey,
SYMCRYPT_LMSKEY_TYPE  keyType,
UINT32  flags,
_Out_writes_bytes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput 
)

◆ SymCryptLmskeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmskeySetValue ( _In_reads_bytes_(cbInput) PCBYTE  pbInput,
SIZE_T  cbInput,
SYMCRYPT_LMSKEY_TYPE  keyType,
UINT32  flags,
_Inout_ PSYMCRYPT_LMS_KEY  pKey 
)

◆ SymCryptLmsParamsFromAlgId()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsParamsFromAlgId ( SYMCRYPT_LMS_ALGID  lmsAlgID,
SYMCRYPT_LMS_OTS_ALGID  lmsOtsAlgID,
_Out_ PSYMCRYPT_LMS_PARAMS  pParams 
)

Definition at line 365 of file lms.c.

369{
370 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
371 SIZE_T uLmsParametersCount = 0;
372 SIZE_T uLmsOtsParametersCount = 0;
373 UINT32 u = 0;
374 UINT32 v = 0;
375 PCSYMCRYPT_LMS_PARAMETER_PREDEFINED pLmsParameters = NULL;
376 PCSYMCRYPT_LMS_OTS_PARAMETER_PREDEFINED pLmsOtsParameters = NULL;
377 BOOL bFound = FALSE;
378
379 SymCryptWipeKnownSize(pParams, sizeof(*pParams));
380 pLmsOtsParameters = LmsOtsParametersPredefined;
381 uLmsOtsParametersCount = SYMCRYPT_ARRAY_SIZE(LmsOtsParametersPredefined);
382 pLmsParameters = LmsParametersPredefined;
383 uLmsParametersCount = SYMCRYPT_ARRAY_SIZE(LmsParametersPredefined);
384
385 for (UINT32 i = 0; i < uLmsParametersCount; i++)
386 {
387 if (pLmsParameters[i].lmsAlgId == lmsAlgID)
388 {
389 pParams->lmsAlgID = lmsAlgID;
390 pParams->nTreeHeight = pLmsParameters[i].nTreeHeight;
391 SYMCRYPT_ASSERT(pParams->nTreeHeight <= SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT);
392
393 pParams->cbHashOutput = pLmsParameters[i].cbHashOutput;
394
395 SYMCRYPT_ASSERT(pLmsParameters[i].nHashIdx < SYMCRYPT_ARRAY_SIZE(LmsHashObjects));
396 pParams->pLmsHashFunction = *LmsHashObjects[pLmsParameters[i].nHashIdx];
397 bFound = TRUE;
398 break;
399 }
400 }
401 if (!bFound)
402 {
403 scError = SYMCRYPT_INVALID_ARGUMENT;
404 goto cleanup;
405 }
406
407 bFound = FALSE;
408 for (UINT32 i = 0; i < uLmsOtsParametersCount; i++)
409 {
410 if (pLmsOtsParameters[i].lmsOtsAlgId == lmsOtsAlgID)
411 {
412 SYMCRYPT_ASSERT(pLmsOtsParameters[i].nHashIdx < SYMCRYPT_ARRAY_SIZE(LmsHashObjects));
413
414 if (pParams->pLmsHashFunction != *LmsHashObjects[pLmsOtsParameters[i].nHashIdx] ||
415 pParams->cbHashOutput != pLmsOtsParameters[i].cbHashOutput)
416 {
417 scError = SYMCRYPT_INVALID_ARGUMENT;
418 goto cleanup;
419 }
420 pParams->lmsOtsAlgID = lmsOtsAlgID;
421 pParams->nWinternitzChainWidth = pLmsOtsParameters[i].nWidth;
422 SymCryptHbsGetWinternitzLengths(
423 pParams->cbHashOutput,
424 pParams->nWinternitzChainWidth,
425 &u,
426 &v);
427 SYMCRYPT_ASSERT((v * pParams->nWinternitzChainWidth) <= SYMCRYPT_LMS_CHECKSUM_SIZE);
428 pParams->nChecksumLShiftBits = SYMCRYPT_LMS_CHECKSUM_SIZE - (v * pParams->nWinternitzChainWidth);
429 pParams->nByteStringCount = u + v;
430 bFound = TRUE;
431 break;
432 }
433 }
434 if (!bFound)
435 {
436 scError = SYMCRYPT_INVALID_ARGUMENT;
437 goto cleanup;
438 }
439
440cleanup:
441 return scError;
442}
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
v
const GLdouble * v
Definition: gl.h:2040
LmsOtsParametersPredefined
static const SYMCRYPT_LMS_OTS_PARAMETER_PREDEFINED LmsOtsParametersPredefined[]
Definition: lms.c:76
LmsHashObjects
static const PCSYMCRYPT_HASH * LmsHashObjects[]
Definition: lms.c:12
LmsParametersPredefined
static const SYMCRYPT_LMS_PARAMETER_PREDEFINED LmsParametersPredefined[]
Definition: lms.c:35
SymCryptHbsGetWinternitzLengths
VOID SYMCRYPT_CALL SymCryptHbsGetWinternitzLengths(UINT32 n, UINT32 w, _Out_ PUINT32 puLen1, _Out_ PUINT32 puLen2)
Definition: xmss.c:188
SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT
#define SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT
Definition: sc_lib.h:4706
SYMCRYPT_ARRAY_SIZE
#define SYMCRYPT_ARRAY_SIZE(_x)
Definition: sc_lib.h:342
SYMCRYPT_LMS_CHECKSUM_SIZE
#define SYMCRYPT_LMS_CHECKSUM_SIZE
Definition: sc_lib.h:4707
_SYMCRYPT_LMS_OTS_PARAMETER_PREDEFINED
Definition: lms.c:61
_SYMCRYPT_LMS_OTS_PARAMETER_PREDEFINED::nWidth
UINT8 nWidth
Definition: lms.c:68
_SYMCRYPT_LMS_PARAMETER_PREDEFINED
Definition: lms.c:18
_SYMCRYPT_LMS_PARAMETER_PREDEFINED::nHashIdx
UINT8 nHashIdx
Definition: lms.c:28
_SYMCRYPT_LMS_PARAMETER_PREDEFINED::nTreeHeight
UINT8 nTreeHeight
Definition: lms.c:25
_SYMCRYPT_LMS_PARAMETER_PREDEFINED::cbHashOutput
UINT8 cbHashOutput
Definition: lms.c:22
lmsOtsAlgID
UINT32 lmsOtsAlgID
Definition: symcrypt_internal.h:3125

◆ SymCryptLmsSelftest()

VOID SYMCRYPT_CALL SymCryptLmsSelftest ( void  )

Referenced by SymCryptLmsVerify().

◆ SymCryptLmsSetParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsSetParams ( _Out_ PSYMCRYPT_LMS_PARAMS  pParams,
UINT32  lmsAlgID,
UINT32  lmsOtsAlgID,
_In_ PCSYMCRYPT_HASH  pLmsHashFunction,
UINT32  cbHashOutput,
UINT32  nTreeHeight,
UINT32  nWinternitzChainWidth 
)

Definition at line 460 of file lms.c.

468{
469 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
470 UINT32 u = 0;
471 UINT32 v = 0;
472
473 SymCryptWipeKnownSize(pParams, sizeof(*pParams));
474
475 // nTreeHeight must be positive and maximum SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT
476 if (nTreeHeight == 0 || nTreeHeight > SYMCRYPT_LMS_MAX_CUSTOM_TREE_HEIGHT)
477 {
478 scError = SYMCRYPT_INVALID_ARGUMENT;
479 goto cleanup;
480 }
481
482 // Output cbHashOutput cannot be larger than the hash output size or SYMCRYPT_LMS_MAX_N
483 if (cbHashOutput == 0 || cbHashOutput > pLmsHashFunction->resultSize || cbHashOutput > SYMCRYPT_LMS_MAX_N)
484 {
485 scError = SYMCRYPT_INVALID_ARGUMENT;
486 goto cleanup;
487 }
488
489 // Winternitz parameter must be one of 1, 2, 4, or 8
490 if (!SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH(nWinternitzChainWidth))
491 {
492 scError = SYMCRYPT_INVALID_ARGUMENT;
493 goto cleanup;
494 }
495
496 pParams->lmsAlgID = lmsAlgID;
497 pParams->lmsOtsAlgID = lmsOtsAlgID;
498 pParams->pLmsHashFunction = pLmsHashFunction;
499 pParams->nTreeHeight = nTreeHeight;
500 pParams->cbHashOutput = cbHashOutput;
501 pParams->nWinternitzChainWidth = nWinternitzChainWidth;
502 SymCryptHbsGetWinternitzLengths(
503 pParams->cbHashOutput,
504 pParams->nWinternitzChainWidth,
505 &u,
506 &v);
507 pParams->nChecksumLShiftBits = SYMCRYPT_LMS_CHECKSUM_SIZE - (v * pParams->nWinternitzChainWidth);
508 pParams->nByteStringCount = u + v;
509
510cleanup:
511 return scError;
512}
SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH
#define SYMCRYPT_IS_VALID_WINTERNITZ_WIDTH(w)
Definition: sc_lib.h:4701
SYMCRYPT_LMS_MAX_N
#define SYMCRYPT_LMS_MAX_N
Definition: sc_lib.h:4703
cbHashOutput
UINT32 cbHashOutput
Definition: symcrypt_internal.h:3087
pLmsHashFunction
PCSYMCRYPT_HASH pLmsHashFunction
Definition: symcrypt_internal.h:3128
nWinternitzChainWidth
UINT32 nWinternitzChainWidth
Definition: symcrypt_internal.h:3137
nTreeHeight
UINT32 nTreeHeight
Definition: symcrypt_internal.h:3131

◆ SymCryptLmsSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsSign ( _Inout_ PSYMCRYPT_LMS_KEY  pKey,
_In_reads_bytes_(cbMessage) PCBYTE  pbMessage,
SIZE_T  cbMessage,
UINT32  flags,
_Out_writes_bytes_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature 
)

Definition at line 821 of file lms.c.

828{
829 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
830 UINT32 nLeafNumber = (UINT32)pKey->nNextUnusedLeaf;
831 UINT32 cbHashOutput = pKey->params.cbHashOutput;
832 UINT32 nTreeHeight = pKey->params.nTreeHeight;
833 SIZE_T cbRemainingBytes = cbSignature;
834 UINT32 nLeavesCount = ((UINT32)1 << nTreeHeight);
835 UINT32 nNodeIndex = 0;
836 UINT32 nTemp = 0;
837 SIZE_T cbOtsSignature = LmsOtsSizeofSignatureFromParams(&pKey->params);
838 BYTE abLMSRandomizer[SYMCRYPT_LMS_MAX_N] = { 0 };
839
840 SYMCRYPT_CHECK_MAGIC(pKey);
841
842 if (flags != 0)
843 {
844 scError = SYMCRYPT_INVALID_ARGUMENT;
845 goto cleanup;
846 }
847
848 if (pKey->keyType != SYMCRYPT_LMSKEY_TYPE_PRIVATE)
849 {
850 scError = SYMCRYPT_INVALID_ARGUMENT;
851 goto cleanup;
852 }
853
854 if (cbSignature != SymCryptLmsSizeofSignatureFromParams(&pKey->params))
855 {
856 scError = SYMCRYPT_INVALID_ARGUMENT;
857 goto cleanup;
858 }
859
860 scError = SymCryptCallbackRandom(abLMSRandomizer, cbHashOutput);
861 if (scError != SYMCRYPT_NO_ERROR)
862 {
863 goto cleanup;
864 }
865
866 nLeafNumber = (UINT32)SYMCRYPT_ATOMIC_ADD64_POST_RELAXED(&pKey->nNextUnusedLeaf, 1) - 1;
867 if (nLeafNumber >= (nLeavesCount))
868 {
869 scError = SYMCRYPT_HBS_NO_OTS_KEYS_LEFT;
870 pKey->nNextUnusedLeaf = nLeavesCount;
871 goto cleanup;
872 }
873 SYMCRYPT_STORE_MSBFIRST32(pbSignature, nLeafNumber);
874 pbSignature += sizeof(UINT32);
875 cbRemainingBytes -= sizeof(UINT32);
876
877 LmsOtskeySign(
878 pKey,
879 nLeafNumber,
880 pbMessage,
881 cbMessage,
882 abLMSRandomizer,
883 pbSignature,
884 cbOtsSignature);
885 pbSignature += cbOtsSignature;
886 cbRemainingBytes -= cbOtsSignature;
887
888 SYMCRYPT_STORE_MSBFIRST32(pbSignature, pKey->params.lmsAlgID);
889 pbSignature += sizeof(UINT32);
890 cbRemainingBytes -= sizeof(UINT32);
891
892 nNodeIndex = nLeavesCount + nLeafNumber;
893 // write the path into the signature
894 for (UINT32 nIndex = 0; nIndex < nTreeHeight; nIndex++)
895 {
896 nTemp = (nNodeIndex >> nIndex) ^ 1;
897 LmsComputeNodeValue(
898 pKey,
899 nTemp,
900 pbSignature,
901 cbHashOutput);
902 pbSignature += cbHashOutput;
903 cbRemainingBytes -= cbHashOutput;
904 }
905 SYMCRYPT_ASSERT(cbRemainingBytes == 0);
906
907cleanup:
908 return scError;
909}
SymCryptLmsSizeofSignatureFromParams
SIZE_T SYMCRYPT_CALL SymCryptLmsSizeofSignatureFromParams(_In_ PCSYMCRYPT_LMS_PARAMS pParams)
Definition: lms.c:446
LmsOtskeySign
static VOID SYMCRYPT_CALL LmsOtskeySign(_In_ PSYMCRYPT_LMS_KEY pKey, UINT64 nLeafNumber, _In_reads_bytes_(cbMessage) PCBYTE pbMessage, SIZE_T cbMessage, _In_reads_bytes_(pKey->params.cbHashOutput) PCBYTE pbRandomizer, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
Definition: lms.c:207
LmsOtsSizeofSignatureFromParams
static SIZE_T SYMCRYPT_CALL LmsOtsSizeofSignatureFromParams(_In_ PCSYMCRYPT_LMS_PARAMS pParams)
Definition: lms.c:190

◆ SymCryptLmsSizeofKeyBlobFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsSizeofKeyBlobFromParams ( _In_ PCSYMCRYPT_LMS_PARAMS  pParams,
SYMCRYPT_LMSKEY_TYPE  keyType,
_Out_ SIZE_T *  pcbKey 
)

Definition at line 516 of file lms.c.

520{
521 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
522
523 switch (keyType)
524 {
525 case SYMCRYPT_LMSKEY_TYPE_PUBLIC:
526 *pcbKey = SYMCRYPT_LMS_PUB_KEY_SIZE(pParams->cbHashOutput);
527 break;
528
529 case SYMCRYPT_LMSKEY_TYPE_PRIVATE:
530 *pcbKey = SYMCRYPT_LMS_PRIV_KEY_SIZE(pParams->cbHashOutput);
531 break;
532
533 default:
534 scError = SYMCRYPT_INVALID_ARGUMENT;
535 break;
536 }
537
538 return scError;
539}
SYMCRYPT_LMS_PUB_KEY_SIZE
#define SYMCRYPT_LMS_PUB_KEY_SIZE(cbHashOutput)
Definition: sc_lib.h:4710
SYMCRYPT_LMS_PRIV_KEY_SIZE
#define SYMCRYPT_LMS_PRIV_KEY_SIZE(cbHashOutput)
Definition: sc_lib.h:4713
keyType
SYMCRYPT_XMSSKEY_TYPE keyType
Definition: sc_lib.h:4525

Referenced by SymCryptLmskeyGetValue(), and SymCryptLmskeySetValue().

◆ SymCryptLmsSizeofSignatureFromParams()

SIZE_T SYMCRYPT_CALL SymCryptLmsSizeofSignatureFromParams ( _In_ PCSYMCRYPT_LMS_PARAMS  pParams)

Definition at line 446 of file lms.c.

448{
449 SIZE_T size = 0;
450
451 size += sizeof(UINT32); // q
452 size += LmsOtsSizeofSignatureFromParams(pParams); // LMS-OTS signature
453 size += sizeof(UINT32); // type
454 size += pParams->nTreeHeight * pParams->cbHashOutput; // path[0..h-1]
455 return size;
456}

Referenced by SymCryptLmsSign(), and SymCryptLmsVerifyInternal().

◆ SymCryptLmsVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLmsVerify ( _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 1139 of file lms.c.

1146{
1147 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1148
1149 SYMCRYPT_RUN_SELFTEST_ONCE(
1150 SymCryptLmsSelftest,
1151 SYMCRYPT_SELFTEST_ALGORITHM_LMS);
1152
1153 scError = SymCryptLmsVerifyInternal(
1154 pKey,
1155 pbMessage,
1156 cbMessage,
1157 flags,
1158 pbSignature,
1159 cbSignature);
1160
1161 return scError;
1162}
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: lms.c:1048
SymCryptLmsSelftest
VOID SYMCRYPT_CALL SymCryptLmsSelftest(void)
SYMCRYPT_SELFTEST_ALGORITHM_LMS
@ SYMCRYPT_SELFTEST_ALGORITHM_LMS
Definition: symcrypt_internal.h:3433

◆ SymCryptLoadLsbFirstUint32()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadLsbFirstUint32 ( _In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_ PUINT32  pDst 
)

Definition at line 341 of file libmain.c.

345{
346 UINT64 v64;
347 UINT32 v32;
348 SYMCRYPT_ERROR scError;
349
350 scError = SymCryptLoadLsbFirstUint64( pbSrc, cbSrc, &v64 );
351 if( scError != SYMCRYPT_NO_ERROR )
352 {
353 goto cleanup;
354 }
355
356 v32 = (UINT32) v64;
357 if( v32 != v64 )
358 {
359 scError = SYMCRYPT_VALUE_TOO_LARGE;
360 goto cleanup;
361 }
362
363 *pDst = v32;
364
365cleanup:
366 return scError;
367}
SymCryptLoadLsbFirstUint64
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadLsbFirstUint64(_In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_ PUINT64 pDst)
Definition: libmain.c:371

◆ SymCryptLoadLsbFirstUint64()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadLsbFirstUint64 ( _In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_ PUINT64  pDst 
)

Definition at line 371 of file libmain.c.

375{
376 UINT64 v;
377 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
378
379 v = 0;
380 pbSrc += cbSrc;
381 while( cbSrc > 8 )
382 {
383 if( *--pbSrc != 0 )
384 {
385 scError = SYMCRYPT_VALUE_TOO_LARGE;
386 goto cleanup;
387 }
388 cbSrc--;
389 }
390
391 while( cbSrc > 0 )
392 {
393 v = (v << 8) | *--pbSrc;
394 cbSrc--;
395 }
396
397 *pDst = v;
398
399cleanup:
400 return scError;
401}

Referenced by SymCryptLoadLsbFirstUint32().

◆ SymCryptLoadMsbFirstUint32()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadMsbFirstUint32 ( _In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_ PUINT32  pDst 
)

Definition at line 405 of file libmain.c.

409{
410 UINT64 v64;
411 UINT32 v32;
412 SYMCRYPT_ERROR scError;
413
414 scError = SymCryptLoadMsbFirstUint64( pbSrc, cbSrc, &v64 );
415 if( scError != SYMCRYPT_NO_ERROR )
416 {
417 goto cleanup;
418 }
419
420 v32 = (UINT32) v64;
421 if( v32 != v64 )
422 {
423 scError = SYMCRYPT_VALUE_TOO_LARGE;
424 goto cleanup;
425 }
426
427 *pDst = v32;
428
429cleanup:
430 return scError;
431}
SymCryptLoadMsbFirstUint64
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadMsbFirstUint64(_In_reads_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _Out_ PUINT64 pDst)
Definition: libmain.c:436

◆ SymCryptLoadMsbFirstUint64()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptLoadMsbFirstUint64 ( _In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_ PUINT64  pDst 
)

Definition at line 436 of file libmain.c.

440{
441 UINT64 v;
442 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
443
444 v = 0;
445 while( cbSrc > 8 )
446 {
447 if( *pbSrc++ != 0 )
448 {
449 scError = SYMCRYPT_VALUE_TOO_LARGE;
450 goto cleanup;
451 }
452 cbSrc--;
453 }
454
455 while( cbSrc > 0 )
456 {
457 v = (v << 8) | *pbSrc++;
458 cbSrc--;
459 }
460
461 *pDst = v;
462
463cleanup:
464 return scError;
465}

Referenced by SymCryptLoadMsbFirstUint32().

◆ SymCryptMapUint32()

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

Definition at line 351 of file scsTools.c.

356{
357 UINT32 mask;
358 UINT32 u32Output = u32Default;
359
360 for (SIZE_T i = 0; i < nMap; ++i)
361 {
362 mask = SymCryptMask32EqU32(u32Input, pcMap[i].from);
363 u32Output ^= (u32Output ^ pcMap[i].to) & mask;
364 }
365
366 return u32Output;
367}
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
SymCryptMask32EqU32
UINT32 SYMCRYPT_CALL SymCryptMask32EqU32(UINT32 a, UINT32 b)
Definition: scsTools.c:67
from
CardRegion * from
Definition: spigame.cpp:19

◆ SymCryptMarvin32()

VOID SYMCRYPT_CALL SymCryptMarvin32 ( _In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED  pExpandedSeed,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_MARVIN32_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 239 of file marvin32.c.

247{
248 UINT32 tmp;
249
250 UINT32 s0 = pExpandedSeed->s[0];
251 UINT32 s1 = pExpandedSeed->s[1];
252
253 while( cbData > 7 )
254 {
255 s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData );
256 BLOCK( s0, s1 );
257 s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData + 4 );
258 BLOCK( s0, s1 );
259 pbData += 8;
260 cbData -= 8;
261 }
262
263 /*
264 switch( cbData )
265 {
266 case 3:
267 buf[2] = pbData[2];
268 case 2:
269 *(UINT16 *) &buf[0] = *(UINT16 *) pbData;
270 break;
271 case 1:
272 buf[0] = pbData[0];
273 case 0:
274 ;
275 }
276
277 buf[ cbData ] = 0x80;
278
279 s0 += LOAD_LSBFIRST32( buf );
280 */
281
282
283 switch( cbData )
284 {
285 default:
286 case 4: s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData ); BLOCK( s0, s1 ); pbData += 4;
287 case 0: tmp = 0x80; break;
288
289 case 5: s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData ); BLOCK( s0, s1 ); pbData += 4;
290 case 1: tmp = 0x8000 | pbData[0]; break;
291
292 case 6: s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData ); BLOCK( s0, s1 ); pbData += 4;
293 case 2: tmp = 0x800000 | SYMCRYPT_LOAD_LSBFIRST16( pbData ); break;
294
295 case 7: s0 += SYMCRYPT_LOAD_LSBFIRST32( pbData ); BLOCK( s0, s1 ); pbData += 4;
296 case 3: tmp = SYMCRYPT_LOAD_LSBFIRST16( pbData ) | (pbData[2] << 16) | 0x80000000; break;
297 }
298 s0 += tmp;
299
300
301 BLOCK( s0, s1 );
302 BLOCK( s0, s1 );
303
304 SYMCRYPT_STORE_LSBFIRST32( pbResult , s0 );
305 SYMCRYPT_STORE_LSBFIRST32( pbResult + 4, s1 );
306}
BLOCK
#define BLOCK(a, b)
Definition: marvin32.c:184
s1
struct S1 s1
SYMCRYPT_LOAD_LSBFIRST16
#define SYMCRYPT_LOAD_LSBFIRST16(p)
Definition: symcrypt.h:298

Referenced by SymCryptKeccakStateExport(), SymCryptKeccakStateImport(), SymCryptMarvin32Selftest(), SymCryptMd2StateExport(), SymCryptMd2StateImport(), SymCryptMd4StateExport(), SymCryptMd4StateImport(), SymCryptMd5StateExport(), SymCryptMd5StateImport(), SymCryptSha1StateExport(), SymCryptSha1StateImport(), SymCryptSha256StateExportCore(), SymCryptSha256StateImportCore(), SymCryptSha512StateExportCore(), and SymCryptSha512StateImportCore().

◆ SymCryptMarvin32Append()

VOID SYMCRYPT_CALL SymCryptMarvin32Append ( _Inout_ PSYMCRYPT_MARVIN32_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 120 of file marvin32.c.

123{
124 UINT32 bytesInBuffer = state->dataLength;
125
126 SYMCRYPT_CHECK_MAGIC( state );
127
128 state->dataLength += (UINT32) cbData; // We only keep track of the last 2 bits...
129
130#define ALG MARVIN32
131#define Alg Marvin32
132#include "hash_buffer_pattern.c"
133#undef ALG
134#undef Alg
135
136}
hash_buffer_pattern.c
bytesInBuffer
SIZE_T bytesInBuffer
Definition: symcrypt_internal.h:1693

◆ SymCryptMarvin32ExpandSeed()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMarvin32ExpandSeed ( _Out_ PSYMCRYPT_MARVIN32_EXPANDED_SEED  pExpandedSeed,
_In_reads_(cbSeed) PCBYTE  pbSeed,
SIZE_T  cbSeed 
)

Definition at line 42 of file marvin32.c.

46{
47 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
48
49 if( cbSeed != SYMCRYPT_MARVIN32_SEED_SIZE )
50 {
51 scError = SYMCRYPT_WRONG_KEY_SIZE;
52 goto cleanup;
53 }
54 pExpandedSeed->s[0] = SYMCRYPT_LOAD_LSBFIRST32( pbSeed );
55 pExpandedSeed->s[1] = SYMCRYPT_LOAD_LSBFIRST32( pbSeed + 4 );
56
57 SYMCRYPT_SET_MAGIC( pExpandedSeed );
58
59cleanup:
60 return scError;
61}
SYMCRYPT_MARVIN32_SEED_SIZE
#define SYMCRYPT_MARVIN32_SEED_SIZE
Definition: symcrypt.h:3989

◆ SymCryptMarvin32Init()

VOID SYMCRYPT_CALL SymCryptMarvin32Init ( _Out_ PSYMCRYPT_MARVIN32_STATE  pState,
_In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED  pExpandedSeed 
)

Definition at line 101 of file marvin32.c.

103{
104 pState->chain = *pExpandedSeed;
105 pState->dataLength = 0;
106 pState->pSeed = pExpandedSeed;
107
108 *(UINT32 *) &pState->buffer[4] = 0; // wipe the last 4 bytes of the buffer.
109
110 SYMCRYPT_SET_MAGIC( pState );
111}

◆ SymCryptMarvin32Result()

VOID SYMCRYPT_CALL SymCryptMarvin32Result ( _Inout_ PSYMCRYPT_MARVIN32_STATE  pState,
_Out_writes_(SYMCRYPT_MARVIN32_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 144 of file marvin32.c.

147{
148 SIZE_T bytesInBuffer = ( pState->dataLength) & 0x3;
149
150 SYMCRYPT_CHECK_MAGIC( pState );
151
152 //
153 // Wipe four bytes in the buffer.
154 // Doing this first ensures that this write is aligned when the input was of
155 // length 0 mod 4.
156 // The buffer is 8 bytes long, so we never overwrite anything else.
157 //
158 *(UINT32 *) &pState->buffer[bytesInBuffer] = 0;
159
160 //
161 // The buffer is never completely full, so we can always put the first
162 // padding byte in.
163 //
164 pState->buffer[bytesInBuffer++] = 0x80;
165
166 //
167 // Process the final block
168 //
169 SymCryptMarvin32AppendBlocks( &pState->chain, pState->buffer, 8 );
170
171 SYMCRYPT_STORE_LSBFIRST32( pbResult , pState->chain.s[0] );
172 SYMCRYPT_STORE_LSBFIRST32( pbResult + 4, pState->chain.s[1] );
173
174 //
175 // Wipe only those things that we need to wipe.
176 //
177
178 *(UINT32 *) &pState->buffer[0] = 0;
179 pState->dataLength = 0;
180
181 pState->chain = *pState->pSeed;
182}
SymCryptMarvin32AppendBlocks
VOID SYMCRYPT_CALL SymCryptMarvin32AppendBlocks(_Inout_ PSYMCRYPT_MARVIN32_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: marvin32.c:194

◆ SymCryptMarvin32SeedCopy()

VOID SYMCRYPT_CALL SymCryptMarvin32SeedCopy ( _In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED  pSrc,
_Out_ PSYMCRYPT_MARVIN32_EXPANDED_SEED  pDst 
)

Definition at line 65 of file marvin32.c.

67{
68 SYMCRYPT_CHECK_MAGIC( pSrc );
69 *pDst = *pSrc;
70 SYMCRYPT_SET_MAGIC( pDst );
71}

◆ SymCryptMarvin32Selftest()

VOID SYMCRYPT_CALL SymCryptMarvin32Selftest ( void  )

Definition at line 320 of file marvin32.c.

321{
322 BYTE res[SYMCRYPT_MARVIN32_RESULT_SIZE];
323
324 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), res );
325
326 SymCryptInjectError( res, sizeof( res ) );
327 if( memcmp( res, marvin32KATAnswer, sizeof( res ) ) != 0 )
328 {
329 SymCryptFatal( 'marv' );
330 }
331}
SymCryptMarvin32
VOID SYMCRYPT_CALL SymCryptMarvin32(_In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED pExpandedSeed, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MARVIN32_RESULT_SIZE) PBYTE pbResult)
Definition: marvin32.c:239
marvin32KATAnswer
static const BYTE marvin32KATAnswer[8]
Definition: marvin32.c:314
SymCryptMarvin32DefaultSeed
PCSYMCRYPT_MARVIN32_EXPANDED_SEED const SymCryptMarvin32DefaultSeed
Definition: marvin32.c:29
SYMCRYPT_MARVIN32_RESULT_SIZE
#define SYMCRYPT_MARVIN32_RESULT_SIZE
Definition: symcrypt.h:3988

◆ SymCryptMarvin32StateCopy()

VOID SYMCRYPT_CALL SymCryptMarvin32StateCopy ( _In_ PCSYMCRYPT_MARVIN32_STATE  pSrc,
_In_opt_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED  pExpandedSeed,
_Out_ PSYMCRYPT_MARVIN32_STATE  pDst 
)

Definition at line 76 of file marvin32.c.

80{
81 SYMCRYPT_CHECK_MAGIC( pSrc );
82 *pDst = *pSrc;
83
84 if( pExpandedSeed == NULL )
85 {
86 SYMCRYPT_CHECK_MAGIC( pSrc->pSeed );
87 pDst->pSeed = pSrc->pSeed;
88 }
89 else
90 {
91 SYMCRYPT_CHECK_MAGIC( pExpandedSeed );
92 pDst->pSeed = pExpandedSeed;
93 }
94
95 SYMCRYPT_SET_MAGIC( pDst );
96}

◆ SymCryptMd2()

VOID SYMCRYPT_CALL SymCryptMd2 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_MD2_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptMd2Selftest().

◆ SymCryptMd2Append()

VOID SYMCRYPT_CALL SymCryptMd2Append ( _Inout_ PSYMCRYPT_MD2_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 100 of file md2.c.

103{
104 SymCryptHashAppendInternal( SymCryptMd2Algorithm, (PSYMCRYPT_COMMON_HASH_STATE)pState, pbData, cbData );
105}
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: hash.c:10
SymCryptMd2Algorithm
const PCSYMCRYPT_HASH SymCryptMd2Algorithm
Definition: md2.c:40
PSYMCRYPT_COMMON_HASH_STATE
* PSYMCRYPT_COMMON_HASH_STATE
Definition: symcrypt_internal.h:695

◆ SymCryptMd2Init()

VOID SYMCRYPT_CALL SymCryptMd2Init ( _Out_ PSYMCRYPT_MD2_STATE  pState)

Definition at line 82 of file md2.c.

83{
84 //
85 // We use the secure wipe as the init routine is also used to re-initialize
86 // (and wipe) the state after a hash computation.
87 // In that case the compiler might conclude that this wipe can be optimized
88 // away, and that would leak data.
89 //
90 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
91 SYMCRYPT_SET_MAGIC( pState );
92}

Referenced by SymCryptMd2Result().

◆ SymCryptMd2Result()

VOID SYMCRYPT_CALL SymCryptMd2Result ( _Inout_ PSYMCRYPT_MD2_STATE  pState,
_Out_writes_(SYMCRYPT_MD2_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 113 of file md2.c.

115{
116 //
117 // The buffer is never completely full, so it is easy to compute the actual padding.
118 //
119 SIZE_T tmp;
120 SIZE_T paddingBytes = 16 - state->bytesInBuffer;
121
122
123 SYMCRYPT_CHECK_MAGIC( state );
124
125 memset( &state->buffer[state->bytesInBuffer], (BYTE)paddingBytes, paddingBytes );
126
127 SymCryptMd2AppendBlocks( &state->chain, state->buffer, SYMCRYPT_MD2_INPUT_BLOCK_SIZE, &tmp );
128
129 //
130 // Append the checksum
131 //
132 SymCryptMd2AppendBlocks( &state->chain, state->chain.C, SYMCRYPT_MD2_INPUT_BLOCK_SIZE, &tmp );
133
134 memcpy( pbResult, &state->chain.X[0], SYMCRYPT_MD2_RESULT_SIZE );
135
136 //
137 // Wipe & re-initialize
138 //
139 // (Our init code wipes the buffer too, so we don't have to.)
140 //
141 SymCryptMd2Init( state );
142}
SymCryptMd2AppendBlocks
VOID SYMCRYPT_CALL SymCryptMd2AppendBlocks(_Inout_ PSYMCRYPT_MD2_CHAINING_STATE pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T *pcbRemaining)
Definition: md2.c:147
SymCryptMd2Init
VOID SYMCRYPT_CALL SymCryptMd2Init(_Out_ PSYMCRYPT_MD2_STATE pState)
Definition: md2.c:82
SYMCRYPT_MD2_RESULT_SIZE
#define SYMCRYPT_MD2_RESULT_SIZE
Definition: symcrypt.h:891
SYMCRYPT_MD2_INPUT_BLOCK_SIZE
#define SYMCRYPT_MD2_INPUT_BLOCK_SIZE
Definition: symcrypt.h:892

◆ SymCryptMd2Selftest()

VOID SYMCRYPT_CALL SymCryptMd2Selftest ( void  )

Definition at line 296 of file md2.c.

297{
298 BYTE result[SYMCRYPT_MD2_RESULT_SIZE];
299
300 SymCryptMd2( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
301
302 SymCryptInjectError( result, sizeof( result ) );
303
304 if( memcmp( result, md2KATAnswer, sizeof( result ) ) != 0 ) {
305 SymCryptFatal( 'MD2t' );
306 }
307}
md2KATAnswer
static const BYTE md2KATAnswer[16]
Definition: md2.c:289
SymCryptMd2
VOID SYMCRYPT_CALL SymCryptMd2(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MD2_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptMd2StateCopy()

VOID SYMCRYPT_CALL SymCryptMd2StateCopy ( _In_ PCSYMCRYPT_MD2_STATE  pSrc,
_Out_ PSYMCRYPT_MD2_STATE  pDst 
)

◆ SymCryptMd2StateExport()

VOID SYMCRYPT_CALL SymCryptMd2StateExport ( _In_ PCSYMCRYPT_MD2_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_MD2_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 204 of file md2.c.

207{
208 SYMCRYPT_ALIGN SYMCRYPT_MD2_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
209 C_ASSERT( sizeof( blob ) == SYMCRYPT_MD2_STATE_EXPORT_SIZE );
210
211 SYMCRYPT_CHECK_MAGIC( pState );
212
213 SymCryptWipeKnownSize( &blob, sizeof( blob ) ); // wipe to avoid any data leakage
214
215 blob.header.magic = SYMCRYPT_BLOB_MAGIC;
216 blob.header.size = SYMCRYPT_MD2_STATE_EXPORT_SIZE;
217 blob.header.type = SymCryptBlobTypeMd2State;
218
219 //
220 // Copy the relevant data. Buffer will be 0-padded.
221 //
222 memcpy( &blob.C[0], &pState->chain.C[0], 16 );
223 memcpy( &blob.X[0], &pState->chain.X[0], 16 );
224 blob.bytesInBuffer = (UINT32) pState->bytesInBuffer;
225 memcpy( &blob.buffer[0], &pState->buffer[0], blob.bytesInBuffer );
226
227 SYMCRYPT_ASSERT( (PCBYTE) &blob + sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ) == (PCBYTE) &blob.trailer );
228 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), &blob.trailer.checksum[0] );
229
230 memcpy( pbBlob, &blob, sizeof( blob ) );
231
232//cleanup:
233 SymCryptWipeKnownSize( &blob, sizeof( blob ) );
234 return;
235}
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
SYMCRYPT_BLOB_MAGIC
#define SYMCRYPT_BLOB_MAGIC
Definition: sc_lib.h:1077
SymCryptBlobTypeMd2State
@ SymCryptBlobTypeMd2State
Definition: sc_lib.h:1061
_SYMCRYPT_BLOB_TRAILER
Definition: sc_lib.h:1090
_SYMCRYPT_MD2_STATE_EXPORT_BLOB
Definition: sc_lib.h:1094
blob
Definition: image.c:229
SymCryptMarvin32
VOID SYMCRYPT_CALL SymCryptMarvin32(_In_ PCSYMCRYPT_MARVIN32_EXPANDED_SEED pExpandedSeed, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MARVIN32_RESULT_SIZE) PBYTE pbResult)
Definition: marvin32.c:239
SymCryptMarvin32DefaultSeed
PCSYMCRYPT_MARVIN32_EXPANDED_SEED const SymCryptMarvin32DefaultSeed
Definition: marvin32.c:29
SYMCRYPT_MD2_STATE_EXPORT_SIZE
#define SYMCRYPT_MD2_STATE_EXPORT_SIZE
Definition: symcrypt_internal.h:2179

◆ SymCryptMd2StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd2StateImport ( _Out_ PSYMCRYPT_MD2_STATE  pState,
_In_reads_bytes_(SYMCRYPT_MD2_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 239 of file md2.c.

242{
243 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
244 SYMCRYPT_ALIGN SYMCRYPT_MD2_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
245 BYTE checksum[8];
246
247 C_ASSERT( sizeof( blob ) == SYMCRYPT_MD2_STATE_EXPORT_SIZE );
248 memcpy( &blob, pbBlob, sizeof( blob ) );
249
250 if( blob.header.magic != SYMCRYPT_BLOB_MAGIC ||
251 blob.header.size != SYMCRYPT_MD2_STATE_EXPORT_SIZE ||
252 blob.header.type != SymCryptBlobTypeMd2State )
253 {
254 scError = SYMCRYPT_INVALID_BLOB;
255 goto cleanup;
256 }
257
258 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), checksum );
259 if( memcmp( checksum, &blob.trailer.checksum[0], 8 ) != 0 )
260 {
261 scError = SYMCRYPT_INVALID_BLOB;
262 goto cleanup;
263 }
264
265 memcpy( &pState->chain.C[0], &blob.C[0], 16 );
266 memcpy( &pState->chain.X[0], &blob.X[0], 16 );
267 memcpy( &pState->buffer[0], &blob.buffer[0], 16 );
268 pState->bytesInBuffer = blob.bytesInBuffer;
269
270 pState->dataLengthL = blob.bytesInBuffer;
271 pState->dataLengthH = 1;
272
273 SYMCRYPT_SET_MAGIC( pState );
274
275cleanup:
276 SymCryptWipeKnownSize( &blob, sizeof(blob) );
277 return scError;
278}
checksum
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353

◆ SymCryptMd4()

VOID SYMCRYPT_CALL SymCryptMd4 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_MD4_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptMd4Selftest().

◆ SymCryptMd4Append()

VOID SYMCRYPT_CALL SymCryptMd4Append ( _Inout_ PSYMCRYPT_MD4_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 139 of file md4.c.

142{
143 SymCryptHashAppendInternal( SymCryptMd4Algorithm, (PSYMCRYPT_COMMON_HASH_STATE)pState, pbData, cbData );
144}
SymCryptMd4Algorithm
const PCSYMCRYPT_HASH SymCryptMd4Algorithm
Definition: md4.c:46

◆ SymCryptMd4Init()

VOID SYMCRYPT_CALL SymCryptMd4Init ( _Out_ PSYMCRYPT_MD4_STATE  pState)

Definition at line 117 of file md4.c.

118{
119 SYMCRYPT_SET_MAGIC( pState );
120
121 pState->dataLengthL = 0;
122 pState->dataLengthH = 0;
123 pState->bytesInBuffer = 0;
124
125 memcpy( &pState->chain.H[0], &md4InitialState[0], sizeof( md4InitialState ) );
126
127 //
128 // There is no need to initialize the buffer part of the state as that will be
129 // filled before it is used.
130 //
131}
md4InitialState
static const UINT32 md4InitialState[4]
Definition: md4.c:93

Referenced by SymCryptMd4Result().

◆ SymCryptMd4Result()

VOID SYMCRYPT_CALL SymCryptMd4Result ( _Inout_ PSYMCRYPT_MD4_STATE  pState,
_Out_writes_(SYMCRYPT_MD4_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 152 of file md4.c.

155{
156 SymCryptHashCommonPaddingMd4Style( SymCryptMd4Algorithm, (PSYMCRYPT_COMMON_HASH_STATE)pState );
157
158 //
159 // Write the output in the correct byte order
160 //
161 SymCryptUint32ToLsbFirst( &pState->chain.H[0], pbResult, 4 );
162
163 //
164 // Wipe & re-initialize
165 // We have to wipe the whole state as the initialization might be optimized away.
166 //
167 SymCryptWipeKnownSize( pState, sizeof( *pState ));
168 SymCryptMd4Init( pState );
169 }
SymCryptUint32ToLsbFirst
FORCEINLINE VOID SYMCRYPT_CALL SymCryptUint32ToLsbFirst(_In_reads_(cuData) PCUINT32 puData, _Out_writes_(4 *cuData) PBYTE pbResult, SIZE_T cuData)
Definition: sc_lib.h:471
SymCryptHashCommonPaddingMd4Style
VOID SYMCRYPT_CALL SymCryptHashCommonPaddingMd4Style(_In_ PCSYMCRYPT_HASH pHash, _Inout_ PSYMCRYPT_COMMON_HASH_STATE pState)
Definition: hash.c:85
SymCryptMd4Init
VOID SYMCRYPT_CALL SymCryptMd4Init(_Out_ PSYMCRYPT_MD4_STATE pState)
Definition: md4.c:117

◆ SymCryptMd4Selftest()

VOID SYMCRYPT_CALL SymCryptMd4Selftest ( void  )

Definition at line 414 of file md4.c.

415{
416 BYTE result[SYMCRYPT_MD4_RESULT_SIZE];
417
418 SymCryptMd4( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
419
420 SymCryptInjectError( result, sizeof( result ) );
421
422 if( memcmp( result, md4KATAnswer, sizeof( result ) ) != 0 ) {
423 SymCryptFatal( 'MD4t' );
424 }
425}
md4KATAnswer
static const BYTE md4KATAnswer[16]
Definition: md4.c:407
SymCryptMd4
VOID SYMCRYPT_CALL SymCryptMd4(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MD4_RESULT_SIZE) PBYTE pbResult)
SYMCRYPT_MD4_RESULT_SIZE
#define SYMCRYPT_MD4_RESULT_SIZE
Definition: symcrypt.h:954

◆ SymCryptMd4StateCopy()

VOID SYMCRYPT_CALL SymCryptMd4StateCopy ( _In_ PCSYMCRYPT_MD4_STATE  pSrc,
_Out_ PSYMCRYPT_MD4_STATE  pDst 
)

◆ SymCryptMd4StateExport()

VOID SYMCRYPT_CALL SymCryptMd4StateExport ( _In_ PCSYMCRYPT_MD4_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_MD4_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 327 of file md4.c.

330{
331 SYMCRYPT_ALIGN SYMCRYPT_MD4_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
332 C_ASSERT( sizeof( blob ) == SYMCRYPT_MD4_STATE_EXPORT_SIZE );
333
334 SYMCRYPT_CHECK_MAGIC( pState );
335
336 SymCryptWipeKnownSize( &blob, sizeof( blob ) ); // wipe to avoid any data leakage
337
338 blob.header.magic = SYMCRYPT_BLOB_MAGIC;
339 blob.header.size = SYMCRYPT_MD4_STATE_EXPORT_SIZE;
340 blob.header.type = SymCryptBlobTypeMd4State;
341
342 //
343 // Copy the relevant data. Buffer will be 0-padded.
344 //
345
346 SymCryptUint32ToLsbFirst( &pState->chain.H[0], &blob.chain[0], 4 );
347 blob.dataLength = pState->dataLengthL;
348 memcpy( &blob.buffer[0], &pState->buffer[0], blob.dataLength & 0x3f );
349
350 SYMCRYPT_ASSERT( (PCBYTE) &blob + sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ) == (PCBYTE) &blob.trailer );
351 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), &blob.trailer.checksum[0] );
352
353 memcpy( pbBlob, &blob, sizeof( blob ) );
354
355//cleanup:
356 SymCryptWipeKnownSize( &blob, sizeof( blob ) );
357 return;
358}
SymCryptBlobTypeMd4State
@ SymCryptBlobTypeMd4State
Definition: sc_lib.h:1062
_SYMCRYPT_MD4_STATE_EXPORT_BLOB
Definition: sc_lib.h:1107
SYMCRYPT_MD4_STATE_EXPORT_SIZE
#define SYMCRYPT_MD4_STATE_EXPORT_SIZE
Definition: symcrypt_internal.h:2180

◆ SymCryptMd4StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd4StateImport ( _Out_ PSYMCRYPT_MD4_STATE  pState,
_In_reads_bytes_(SYMCRYPT_MD4_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 362 of file md4.c.

365{
366 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
367 SYMCRYPT_ALIGN SYMCRYPT_MD4_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
368 BYTE checksum[8];
369
370 C_ASSERT( sizeof( blob ) == SYMCRYPT_MD4_STATE_EXPORT_SIZE );
371 memcpy( &blob, pbBlob, sizeof( blob ) );
372
373 if( blob.header.magic != SYMCRYPT_BLOB_MAGIC ||
374 blob.header.size != SYMCRYPT_MD4_STATE_EXPORT_SIZE ||
375 blob.header.type != SymCryptBlobTypeMd4State )
376 {
377 scError = SYMCRYPT_INVALID_BLOB;
378 goto cleanup;
379 }
380
381 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), checksum );
382 if( memcmp( checksum, &blob.trailer.checksum[0], 8 ) != 0 )
383 {
384 scError = SYMCRYPT_INVALID_BLOB;
385 goto cleanup;
386 }
387
388 SymCryptLsbFirstToUint32( &blob.chain[0], &pState->chain.H[0], 4 );
389 pState->dataLengthL = blob.dataLength;
390 pState->dataLengthH = 0;
391 pState->bytesInBuffer = blob.dataLength & 0x3f;
392 memcpy( &pState->buffer[0], &blob.buffer[0], pState->bytesInBuffer );
393
394 SYMCRYPT_SET_MAGIC( pState );
395
396cleanup:
397 SymCryptWipeKnownSize( &blob, sizeof(blob) );
398 return scError;
399}

◆ SymCryptMd5()

VOID SYMCRYPT_CALL SymCryptMd5 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptMd5Selftest().

◆ SymCryptMd5Append()

VOID SYMCRYPT_CALL SymCryptMd5Append ( _Inout_ PSYMCRYPT_MD5_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 204 of file md5.c.

208{
209 SymCryptHashAppendInternal( SymCryptMd5Algorithm, (PSYMCRYPT_COMMON_HASH_STATE)pState, pbData, cbData );
210}
SymCryptMd5Algorithm
const PCSYMCRYPT_HASH SymCryptMd5Algorithm
Definition: md5.c:43

◆ SymCryptMd5Init()

VOID SYMCRYPT_CALL SymCryptMd5Init ( _Out_ PSYMCRYPT_MD5_STATE  pState)

Definition at line 182 of file md5.c.

183{
184 SYMCRYPT_SET_MAGIC( pState );
185
186 pState->dataLengthL = 0;
187 pState->dataLengthH = 0;
188 pState->bytesInBuffer = 0;
189
190 memcpy( &pState->chain.H[0], &md5InitialState[0], sizeof( md5InitialState ) );
191
192 //
193 // There is no need to initialize the buffer part of the state as that will be
194 // filled before it is used.
195 //
196}
md5InitialState
static const UINT32 md5InitialState[4]
Definition: md5.c:158

Referenced by SymCryptMd5Result().

◆ SymCryptMd5Result()

VOID SYMCRYPT_CALL SymCryptMd5Result ( _Inout_ PSYMCRYPT_MD5_STATE  pState,
_Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 217 of file md5.c.

220{
221 SymCryptHashCommonPaddingMd4Style( SymCryptMd5Algorithm, (PSYMCRYPT_COMMON_HASH_STATE) pState );
222
223 //
224 // Write the output in the correct byte order
225 //
226 SymCryptUint32ToLsbFirst( &pState->chain.H[0], pbResult, 4 );
227
228 //
229 // Wipe & re-initialize
230 // We have to wipe the whole state because the Init call
231 // might be optimized away by a smart compiler.
232 // And we need to wipe old data.
233 //
234 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
235 SymCryptMd5Init( pState );
236}
SymCryptMd5Init
VOID SYMCRYPT_CALL SymCryptMd5Init(_Out_ PSYMCRYPT_MD5_STATE pState)
Definition: md5.c:182

◆ SymCryptMd5Selftest()

VOID SYMCRYPT_CALL SymCryptMd5Selftest ( void  )

Definition at line 492 of file md5.c.

493{
494 BYTE result[SYMCRYPT_MD5_RESULT_SIZE];
495
496 SymCryptMd5( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
497
498 SymCryptInjectError( result, sizeof( result ) );
499
500 if( memcmp( result, md5KATAnswer, sizeof( result ) ) != 0 ) {
501 SymCryptFatal( 'MD5t' );
502 }
503}
md5KATAnswer
static const BYTE md5KATAnswer[16]
Definition: md5.c:485
SYMCRYPT_MD5_RESULT_SIZE
#define SYMCRYPT_MD5_RESULT_SIZE
Definition: symcrypt.h:1017
SymCryptMd5
VOID SYMCRYPT_CALL SymCryptMd5(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MD5_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptMd5StateCopy()

VOID SYMCRYPT_CALL SymCryptMd5StateCopy ( _In_ PCSYMCRYPT_MD5_STATE  pSrc,
_Out_ PSYMCRYPT_MD5_STATE  pDst 
)

◆ SymCryptMd5StateExport()

VOID SYMCRYPT_CALL SymCryptMd5StateExport ( _In_ PCSYMCRYPT_MD5_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 406 of file md5.c.

409{
410 SYMCRYPT_MD5_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
411 C_ASSERT( sizeof( blob ) == SYMCRYPT_MD5_STATE_EXPORT_SIZE );
412
413 SYMCRYPT_CHECK_MAGIC( pState );
414
415 SymCryptWipeKnownSize( &blob, sizeof( blob ) ); // wipe to avoid any data leakage
416
417 blob.header.magic = SYMCRYPT_BLOB_MAGIC;
418 blob.header.size = SYMCRYPT_MD5_STATE_EXPORT_SIZE;
419 blob.header.type = SymCryptBlobTypeMd5State;
420
421 //
422 // Copy the relevant data. Buffer will be 0-padded.
423 //
424
425 SymCryptUint32ToLsbFirst( &pState->chain.H[0], &blob.chain[0], 4 );
426 blob.dataLength = pState->dataLengthL;
427 memcpy( &blob.buffer[0], &pState->buffer[0], blob.dataLength & 0x3f );
428
429 SYMCRYPT_ASSERT( (PCBYTE) &blob + sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ) == (PCBYTE) &blob.trailer );
430 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), &blob.trailer.checksum[0] );
431
432 memcpy( pbBlob, &blob, sizeof( blob ) );
433
434//cleanup:
435 SymCryptWipeKnownSize( &blob, sizeof( blob ) );
436 return;
437}
SymCryptBlobTypeMd5State
@ SymCryptBlobTypeMd5State
Definition: sc_lib.h:1063
_SYMCRYPT_MD5_STATE_EXPORT_BLOB
Definition: sc_lib.h:1119
SYMCRYPT_MD5_STATE_EXPORT_SIZE
#define SYMCRYPT_MD5_STATE_EXPORT_SIZE
Definition: symcrypt_internal.h:2181

◆ SymCryptMd5StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMd5StateImport ( _Out_ PSYMCRYPT_MD5_STATE  pState,
_In_reads_bytes_(SYMCRYPT_MD5_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 441 of file md5.c.

444{
445 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
446 SYMCRYPT_MD5_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
447 BYTE checksum[8];
448
449 C_ASSERT( sizeof( blob ) == SYMCRYPT_MD5_STATE_EXPORT_SIZE );
450 memcpy( &blob, pbBlob, sizeof( blob ) );
451
452 if( blob.header.magic != SYMCRYPT_BLOB_MAGIC ||
453 blob.header.size != SYMCRYPT_MD5_STATE_EXPORT_SIZE ||
454 blob.header.type != SymCryptBlobTypeMd5State )
455 {
456 scError = SYMCRYPT_INVALID_BLOB;
457 goto cleanup;
458 }
459
460 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), checksum );
461 if( memcmp( checksum, &blob.trailer.checksum[0], 8 ) != 0 )
462 {
463 scError = SYMCRYPT_INVALID_BLOB;
464 goto cleanup;
465 }
466
467 SymCryptLsbFirstToUint32( &blob.chain[0], &pState->chain.H[0], 4 );
468 pState->dataLengthL = blob.dataLength;
469 pState->dataLengthH = 0;
470 pState->bytesInBuffer = blob.dataLength & 0x3f;
471 memcpy( &pState->buffer[0], &blob.buffer[0], pState->bytesInBuffer );
472
473 SYMCRYPT_SET_MAGIC( pState );
474
475cleanup:
476 SymCryptWipeKnownSize( &blob, sizeof(blob) );
477 return scError;
478}

◆ SymCryptMlDsakeyFree()

VOID SYMCRYPT_CALL SymCryptMlDsakeyFree ( _Post_invalid_ PSYMCRYPT_MLDSAKEY  pkMlDsakey)

◆ SymCryptMlDsakeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsakeyGenerate ( _Inout_ PSYMCRYPT_MLDSAKEY  pkMlDsakey,
UINT32  flags 
)

◆ SymCryptMlDsakeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsakeyGetValue ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
_Out_writes_bytes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
SYMCRYPT_MLDSAKEY_FORMAT  mlDsakeyFormat,
UINT32  flags 
)

◆ SymCryptMlDsakeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsakeySetValue ( _In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_MLDSAKEY_FORMAT  mlDsakeyFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_MLDSAKEY  pkMlDsakey 
)

◆ SymCryptMlDsaSelftest()

VOID SYMCRYPT_CALL SymCryptMlDsaSelftest ( void  )

Referenced by SymCryptMlDsakeySetValue().

◆ SymCryptMlDsaSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaSign ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
_In_reads_bytes_(cbMessage) PCBYTE  pbMessage,
SIZE_T  cbMessage,
_In_reads_bytes_opt_(cbContext) PCBYTE  pbContext,
_In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T  cbContext,
UINT32  flags,
_Out_writes_bytes_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature 
)

◆ SymCryptMlDsaSizeofKeyFormatFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaSizeofKeyFormatFromParams ( SYMCRYPT_MLDSA_PARAMS  params,
SYMCRYPT_MLDSAKEY_FORMAT  mlDsakeyFormat,
_Out_ SIZE_T *  pcbKeyFormat 
)

◆ SymCryptMlDsaSizeofSignatureFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaSizeofSignatureFromParams ( SYMCRYPT_MLDSA_PARAMS  params,
_Out_ SIZE_T *  pcbSignature 
)

◆ SymCryptMlDsaVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlDsaVerify ( _In_ PCSYMCRYPT_MLDSAKEY  pkMlDsakey,
_In_reads_bytes_(cbMessage) PCBYTE  pbMessage,
SIZE_T  cbMessage,
_In_reads_bytes_opt_(cbContext) PCBYTE  pbContext,
_In_range_(0, SYMCRYPT_MLDSA_CONTEXT_MAX_LENGTH) SIZE_T  cbContext,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
UINT32  flags 
)

◆ SymCryptMlKemDecapsulate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemDecapsulate ( _In_ PCSYMCRYPT_MLKEMKEY  pkMlKemkey,
_In_reads_bytes_(cbCiphertext) PCBYTE  pbCiphertext,
SIZE_T  cbCiphertext,
_Out_writes_bytes_(cbAgreedSecret) PBYTE  pbAgreedSecret,
SIZE_T  cbAgreedSecret 
)

Definition at line 1026 of file mlkem.c.

1032{
1033 PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES pCompTemps = NULL;
1034 BYTE pbDecryptedRandom[SYMCRYPT_MLKEM_SIZEOF_ENCAPS_RANDOM];
1035 BYTE pbDecapsulatedSecret[SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET];
1036 BYTE pbImplicitRejectionSecret[SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET];
1037 PBYTE pbReadCiphertext, pbReencapsulatedCiphertext;
1038 BOOLEAN successfulReencrypt;
1039
1040 PBYTE pbCurr;
1041 PBYTE pbAlloc = NULL;
1042 const SIZE_T cbAlloc = sizeof(SYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES) + (2*cbCiphertext);
1043
1044 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1045 SIZE_T cbU, cbV, cbCopy;
1046 PSYMCRYPT_MLKEM_VECTOR pvu;
1047 PSYMCRYPT_MLKEM_POLYELEMENT peTmp0, peTmp1;
1048 PSYMCRYPT_MLKEM_POLYELEMENT_ACCUMULATOR paTmp;
1049 PSYMCRYPT_SHAKE256_STATE pShakeState;
1050 const UINT32 nRows = pkMlKemkey->params.nRows;
1051 const UINT32 nBitsOfU = pkMlKemkey->params.nBitsOfU;
1052 const UINT32 nBitsOfV = pkMlKemkey->params.nBitsOfV;
1053 const UINT32 cbPolyElement = pkMlKemkey->params.cbPolyElement;
1054 const UINT32 cbVector = pkMlKemkey->params.cbVector;
1055
1056 // u vector encoded with nBitsOfU * SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS bits per polynomial
1057 cbU = nRows * nBitsOfU * (SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS / 8);
1058 // v polynomial encoded with nBitsOfV * SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS bits
1059 cbV = nBitsOfV * (SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS / 8);
1060
1061 if( (cbAgreedSecret != SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET) ||
1062 (cbCiphertext != cbU + cbV) ||
1063 !pkMlKemkey->hasPrivateKey )
1064 {
1065 scError = SYMCRYPT_INVALID_ARGUMENT;
1066 goto cleanup;
1067 }
1068
1069 pbAlloc = SymCryptCallbackAlloc( cbAlloc );
1070 if( pbAlloc == NULL )
1071 {
1072 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1073 goto cleanup;
1074 }
1075 pbCurr = pbAlloc;
1076
1077 pCompTemps = (PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES) pbCurr;
1078 pbCurr += sizeof(SYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES);
1079
1080 pbReadCiphertext = pbCurr;
1081 pbCurr += cbCiphertext;
1082
1083 pbReencapsulatedCiphertext = pbCurr;
1084 pbCurr += cbCiphertext;
1085
1086 SYMCRYPT_ASSERT( pbCurr == (pbAlloc + cbAlloc) );
1087
1088 // Read the input ciphertext once to local pbReadCiphertext to ensure our view of ciphertext consistent
1089 memcpy( pbReadCiphertext, pbCiphertext, cbCiphertext );
1090
1091 pvu = SymCryptMlKemVectorCreate( pCompTemps->abVectorBuffer0, cbVector, nRows );
1092 SYMCRYPT_ASSERT( pvu != NULL );
1093 peTmp0 = SymCryptMlKemPolyElementCreate( pCompTemps->abPolyElementBuffer0, cbPolyElement );
1094 SYMCRYPT_ASSERT( peTmp0 != NULL );
1095 peTmp1 = SymCryptMlKemPolyElementCreate( pCompTemps->abPolyElementBuffer1, cbPolyElement );
1096 SYMCRYPT_ASSERT( peTmp1 != NULL );
1097 paTmp = SymCryptMlKemPolyElementAccumulatorCreate( pCompTemps->abPolyElementAccumulatorBuffer, 2*cbPolyElement );
1098 SYMCRYPT_ASSERT( paTmp != NULL );
1099
1100 // Decode and decompress u
1101 scError = SymCryptMlKemVectorDecodeAndDecompress( pbReadCiphertext, cbU, nBitsOfU, pvu );
1102 SYMCRYPT_ASSERT( scError == SYMCRYPT_NO_ERROR );
1103
1104 // Perform NTT on u
1105 SymCryptMlKemVectorNTT( pvu );
1106
1107 // peTmp0 = (s o NTT(u)) ./ R
1108 SymCryptMlKemVectorMontDotProduct( pkMlKemkey->pvs, pvu, peTmp0, paTmp );
1109
1110 // peTmp0 = INTT(s o NTT(u))
1111 SymCryptMlKemPolyElementINTTAndMulR( peTmp0 );
1112
1113 // Decode and decompress v
1114 scError = SymCryptMlKemPolyElementDecodeAndDecompress( pbReadCiphertext+cbU, nBitsOfV, peTmp1 );
1115 SYMCRYPT_ASSERT( scError == SYMCRYPT_NO_ERROR );
1116
1117 // peTmp0 = w = v - INTT(s o NTT(u))
1118 SymCryptMlKemPolyElementSub( peTmp1, peTmp0, peTmp0 );
1119
1120 // pbDecryptedRandom = m' = Encoding of w
1121 SymCryptMlKemPolyElementCompressAndEncode( peTmp0, 1, pbDecryptedRandom );
1122
1123 // Compute:
1124 // pbDecapsulatedSecret = K' = Decapsulated secret (without implicit rejection)
1125 // pbReencapsulatedCiphertext = c' = Ciphertext from re-encapsulating decrypted random value
1126 scError = SymCryptMlKemEncapsulateInternal(
1127 pkMlKemkey,
1128 pbDecapsulatedSecret, sizeof(pbDecapsulatedSecret),
1129 pbReencapsulatedCiphertext, cbCiphertext,
1130 pbDecryptedRandom,
1131 pCompTemps );
1132 SYMCRYPT_ASSERT( scError == SYMCRYPT_NO_ERROR );
1133
1134 // Compute the secret we will return if using implicit rejection
1135 // pbImplicitRejectionSecret = K_bar = SHAKE256( z || c )
1136 pShakeState = &pCompTemps->hashState0.shake256State;
1137 SymCryptShake256Init( pShakeState );
1138 SymCryptShake256Append( pShakeState, pkMlKemkey->privateRandom, sizeof(pkMlKemkey->privateRandom) );
1139 SymCryptShake256Append( pShakeState, pbReadCiphertext, cbCiphertext );
1140 SymCryptShake256Extract( pShakeState, pbImplicitRejectionSecret, sizeof(pbImplicitRejectionSecret), FALSE );
1141
1142 // Constant time test if re-encryption successful
1143 successfulReencrypt = SymCryptEqual( pbReencapsulatedCiphertext, pbReadCiphertext, cbCiphertext );
1144
1145 // If not successful, perform side-channel-safe copy of Implicit Rejection secret over Decapsulated secret
1146 cbCopy = (((SIZE_T)successfulReencrypt)-1) & SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET;
1147 SymCryptScsCopy( pbImplicitRejectionSecret, cbCopy, pbDecapsulatedSecret, SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET );
1148
1149 // Write agreed secret (with implicit rejection) to pbAgreedSecret
1150 memcpy( pbAgreedSecret, pbDecapsulatedSecret, SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET );
1151
1152cleanup:
1153 if( pbAlloc != NULL )
1154 {
1155 SymCryptWipe( pbAlloc, cbAlloc );
1156 SymCryptCallbackFree( pbAlloc );
1157 }
1158
1159 SymCryptWipeKnownSize( pbDecryptedRandom, sizeof(pbDecryptedRandom) );
1160 SymCryptWipeKnownSize( pbDecapsulatedSecret, sizeof(pbDecapsulatedSecret) );
1161 SymCryptWipeKnownSize( pbImplicitRejectionSecret, sizeof(pbImplicitRejectionSecret) );
1162
1163 return scError;
1164}
SymCryptMlKemEncapsulateInternal
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemEncapsulateInternal(_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret, _Out_writes_bytes_(cbCiphertext) PBYTE pbCiphertext, SIZE_T cbCiphertext, _In_reads_bytes_(SYMCRYPT_MLKEM_SIZEOF_ENCAPS_RANDOM) PCBYTE pbRandom, _Inout_ PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES pCompTemps)
Definition: mlkem.c:807
SymCryptMlKemPolyElementSub
VOID SYMCRYPT_CALL SymCryptMlKemPolyElementSub(_In_ PCSYMCRYPT_MLKEM_POLYELEMENT peSrc1, _In_ PCSYMCRYPT_MLKEM_POLYELEMENT peSrc2, _Out_ PSYMCRYPT_MLKEM_POLYELEMENT peDst)
Definition: mlkem_primitives.c:825
SymCryptMlKemVectorCreate
PSYMCRYPT_MLKEM_VECTOR SYMCRYPT_CALL SymCryptMlKemVectorCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, UINT32 cbBuffer, UINT32 nRows)
Definition: mlkem_primitives.c:156
SymCryptMlKemPolyElementCreate
PSYMCRYPT_MLKEM_POLYELEMENT SYMCRYPT_CALL SymCryptMlKemPolyElementCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, UINT32 cbBuffer)
Definition: mlkem_primitives.c:124
SymCryptMlKemPolyElementINTTAndMulR
VOID SYMCRYPT_CALL SymCryptMlKemPolyElementINTTAndMulR(_Inout_ PSYMCRYPT_MLKEM_POLYELEMENT peSrc)
Definition: mlkem_primitives.c:859
SymCryptMlKemVectorNTT
VOID SYMCRYPT_CALL SymCryptMlKemVectorNTT(_Inout_ PSYMCRYPT_MLKEM_VECTOR pvSrc)
Definition: mlkem_primitives.c:1328
SymCryptMlKemPolyElementAccumulatorCreate
PSYMCRYPT_MLKEM_POLYELEMENT_ACCUMULATOR SYMCRYPT_CALL SymCryptMlKemPolyElementAccumulatorCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, UINT32 cbBuffer)
Definition: mlkem_primitives.c:140
SymCryptMlKemPolyElementDecodeAndDecompress
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemPolyElementDecodeAndDecompress(_In_reads_bytes_(nBitsPerCoefficient *(SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS/8)) PCBYTE pbSrc, UINT32 nBitsPerCoefficient, _Out_ PSYMCRYPT_MLKEM_POLYELEMENT peDst)
Definition: mlkem_primitives.c:963
SymCryptMlKemVectorMontDotProduct
VOID SYMCRYPT_CALL SymCryptMlKemVectorMontDotProduct(_In_ PCSYMCRYPT_MLKEM_VECTOR pvSrc1, _In_ PCSYMCRYPT_MLKEM_VECTOR pvSrc2, _Inout_ PSYMCRYPT_MLKEM_POLYELEMENT peDst, _Inout_ PSYMCRYPT_MLKEM_POLYELEMENT_ACCUMULATOR paTmp)
Definition: mlkem_primitives.c:1211
SymCryptMlKemPolyElementCompressAndEncode
VOID SYMCRYPT_CALL SymCryptMlKemPolyElementCompressAndEncode(_In_ PCSYMCRYPT_MLKEM_POLYELEMENT peSrc, UINT32 nBitsPerCoefficient, _Out_writes_bytes_(nBitsPerCoefficient *(SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS/8)) PBYTE pbDst)
Definition: mlkem_primitives.c:890
SymCryptMlKemVectorDecodeAndDecompress
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemVectorDecodeAndDecompress(_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, UINT32 nBitsPerCoefficient, _Out_ PSYMCRYPT_MLKEM_VECTOR pvDst)
Definition: mlkem_primitives.c:1390
SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS
#define SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS
Definition: sc_lib.h:4347
pkMlKemkey
PSYMCRYPT_MLKEMKEY pkMlKemkey
Definition: sc_lib.h:4444
PSYMCRYPT_MLKEM_POLYELEMENT
SYMCRYPT_MLKEM_POLYELEMENT * PSYMCRYPT_MLKEM_POLYELEMENT
Definition: sc_lib_mlkem.h:18
cbPolyElement
UINT32 cbPolyElement
Definition: sc_lib_mlkem.h:65
PSYMCRYPT_MLKEM_POLYELEMENT_ACCUMULATOR
SYMCRYPT_MLKEM_POLYELEMENT_ACCUMULATOR * PSYMCRYPT_MLKEM_POLYELEMENT_ACCUMULATOR
Definition: sc_lib_mlkem.h:25
nBitsOfU
UINT8 nBitsOfU
Definition: sc_lib_mlkem.h:75
SYMCRYPT_MLKEM_SIZEOF_ENCAPS_RANDOM
#define SYMCRYPT_MLKEM_SIZEOF_ENCAPS_RANDOM
Definition: sc_lib_mlkem.h:133
nRows
UINT8 nRows
Definition: sc_lib_mlkem.h:69
SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET
#define SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET
Definition: sc_lib_mlkem.h:132
SYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES
SYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES
Definition: sc_lib_mlkem.h:153
cbVector
UINT32 cbVector
Definition: sc_lib_mlkem.h:66
PSYMCRYPT_MLKEM_VECTOR
* PSYMCRYPT_MLKEM_VECTOR
Definition: sc_lib_mlkem.h:37
nBitsOfV
UINT8 nBitsOfV
Definition: sc_lib_mlkem.h:77
PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES
SYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES * PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES
Definition: sc_lib_mlkem.h:154
SymCryptShake256Append
VOID SYMCRYPT_CALL SymCryptShake256Append(_Inout_ PSYMCRYPT_SHAKE256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
SymCryptShake256Extract
VOID SYMCRYPT_CALL SymCryptShake256Extract(_Inout_ PSYMCRYPT_SHAKE256_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)
SymCryptShake256Init
VOID SYMCRYPT_CALL SymCryptShake256Init(_Out_ PSYMCRYPT_SHAKE256_STATE pState)
cbAlloc
UINT32 cbAlloc
Definition: symcrypt_internal.h:2967
PSYMCRYPT_SHAKE256_STATE
SYMCRYPT_MAGIC_FIELD * PSYMCRYPT_SHAKE256_STATE
Definition: symcrypt_internal.h:997
SymCryptScsCopy
VOID SYMCRYPT_CALL SymCryptScsCopy(_In_reads_(cbDst) PCBYTE pbSrc, SIZE_T cbSrc, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
Definition: scsTools.c:108

Referenced by SymCryptMlKemkeyGenerate().

◆ SymCryptMlKemEncapsulate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemEncapsulate ( _In_ PCSYMCRYPT_MLKEMKEY  pkMlKemkey,
_Out_writes_bytes_(cbAgreedSecret) PBYTE  pbAgreedSecret,
SIZE_T  cbAgreedSecret,
_Out_writes_bytes_(cbCiphertext) PBYTE  pbCiphertext,
SIZE_T  cbCiphertext 
)

Definition at line 996 of file mlkem.c.

1002{
1003 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1004 BYTE pbm[SYMCRYPT_MLKEM_SIZEOF_ENCAPS_RANDOM];
1005
1006 scError = SymCryptCallbackRandom( pbm, sizeof(pbm) );
1007 if( scError != SYMCRYPT_NO_ERROR )
1008 {
1009 goto cleanup;
1010 }
1011
1012 scError = SymCryptMlKemEncapsulateEx(
1013 pkMlKemkey,
1014 pbm, sizeof(pbm),
1015 pbAgreedSecret, cbAgreedSecret,
1016 pbCiphertext, cbCiphertext );
1017
1018cleanup:
1019 SymCryptWipeKnownSize( pbm, sizeof(pbm) );
1020
1021 return scError;
1022}
SymCryptMlKemEncapsulateEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemEncapsulateEx(_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _In_reads_bytes_(cbRandom) PCBYTE pbRandom, SIZE_T cbRandom, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret, _Out_writes_bytes_(cbCiphertext) PBYTE pbCiphertext, SIZE_T cbCiphertext)
Definition: mlkem.c:952

Referenced by SymCryptMlKemkeyGenerate().

◆ SymCryptMlKemkeyAllocate()

PSYMCRYPT_MLKEMKEY SYMCRYPT_CALL SymCryptMlKemkeyAllocate ( SYMCRYPT_MLKEM_PARAMS  params)

Definition at line 140 of file mlkem.c.

142{
143 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
144 PBYTE pbKey = NULL;
145 UINT32 cbKey;
146 SYMCRYPT_MLKEM_INTERNAL_PARAMS internalParams;
147
148 PSYMCRYPT_MLKEMKEY pKey = NULL;
149
150 scError = SymCryptMlKemkeyGetInternalParamsFromParams(params, &internalParams);
151 if( scError != SYMCRYPT_NO_ERROR )
152 {
153 goto cleanup;
154 }
155
156 cbKey = sizeof(SYMCRYPT_MLKEMKEY) + internalParams.cbMatrix + (2*internalParams.cbVector);
157
158 pbKey = SymCryptCallbackAlloc( cbKey );
159 if ( pbKey == NULL )
160 {
161 goto cleanup;
162 }
163
164 pKey = SymCryptMlKemkeyInitialize( &internalParams, pbKey, cbKey );
165 if ( pKey == NULL )
166 {
167 goto cleanup;
168 }
169
170 pbKey = NULL;
171
172cleanup:
173 if ( pbKey != NULL )
174 {
175 SymCryptCallbackFree( pbKey );
176 }
177
178 return pKey;
179}
params
GLenum const GLfloat * params
Definition: glext.h:5645
SymCryptMlKemkeyInitialize
static PSYMCRYPT_MLKEMKEY SYMCRYPT_CALL SymCryptMlKemkeyInitialize(_In_ PCSYMCRYPT_MLKEM_INTERNAL_PARAMS pInternalParams, _Out_writes_bytes_(cbKey) PBYTE pbKey, UINT32 cbKey)
Definition: mlkem.c:90
SymCryptMlKemkeyGetInternalParamsFromParams
static SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeyGetInternalParamsFromParams(SYMCRYPT_MLKEM_PARAMS params, _Out_ PSYMCRYPT_MLKEM_INTERNAL_PARAMS pInternalParams)
Definition: mlkem.c:61
SYMCRYPT_MLKEM_INTERNAL_PARAMS
SYMCRYPT_MLKEM_INTERNAL_PARAMS
Definition: sc_lib_mlkem.h:79
SYMCRYPT_MLKEMKEY
struct _SYMCRYPT_MLKEMKEY SYMCRYPT_MLKEMKEY
Definition: symcrypt_internal.h:2638
PSYMCRYPT_MLKEMKEY
SYMCRYPT_MLKEMKEY * PSYMCRYPT_MLKEMKEY
Definition: symcrypt_internal.h:2639

◆ SymCryptMlKemkeyFree()

VOID SYMCRYPT_CALL SymCryptMlKemkeyFree ( _Inout_ PSYMCRYPT_MLKEMKEY  pkMlKemkey)

Definition at line 183 of file mlkem.c.

185{
186 SYMCRYPT_CHECK_MAGIC( pkMlKemkey );
187
188 SymCryptWipe( (PBYTE) pkMlKemkey, pkMlKemkey->cbTotalSize );
189
190 SymCryptCallbackFree( pkMlKemkey );
191}

◆ SymCryptMlKemkeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeyGenerate ( _Inout_ PSYMCRYPT_MLKEMKEY  pkMlKemkey,
UINT32  flags 
)

Definition at line 701 of file mlkem.c.

704{
705 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
706 BYTE privateSeed[SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE];
707 PBYTE pbPctCipherText = NULL;
708 SIZE_T cbPctCipherText = 0;
709
710 // Ensure only allowed flags are specified
711 UINT32 allowedFlags = SYMCRYPT_FLAG_KEY_NO_FIPS;
712
713 if ( ( flags & ~allowedFlags ) != 0 )
714 {
715 scError = SYMCRYPT_INVALID_ARGUMENT;
716 goto cleanup;
717 }
718
719 scError = SymCryptCallbackRandom( privateSeed, sizeof(privateSeed) );
720 if( scError != SYMCRYPT_NO_ERROR )
721 {
722 goto cleanup;
723 }
724
725 scError = SymCryptMlKemkeySetValue( privateSeed, sizeof(privateSeed), SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED, flags, pkMlKemkey );
726 if( scError != SYMCRYPT_NO_ERROR )
727 {
728 goto cleanup;
729 }
730
731 // SymCryptMlKemkeySetValue ensures the self-test is run before
732 // first operational use of MlKem
733
734 if( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 )
735 {
736 // PCT on key generation, encaps/decaps and check that both parties get the same shared secret with the generated key
737 SIZE_T cbU, cbV;
738 const UINT32 nRows = pkMlKemkey->params.nRows;
739 const UINT32 nBitsOfU = pkMlKemkey->params.nBitsOfU;
740 const UINT32 nBitsOfV = pkMlKemkey->params.nBitsOfV;
741
742 // u vector encoded with nBitsOfU * SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS bits per polynomial
743 cbU = nRows * nBitsOfU * (SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS / 8);
744 // v polynomial encoded with nBitsOfV * SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS bits
745 cbV = nBitsOfV * (SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS / 8);
746 cbPctCipherText = cbU + cbV;
747
748 pbPctCipherText = SymCryptCallbackAlloc( cbPctCipherText );
749 if( pbPctCipherText == NULL )
750 {
751 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
752 goto cleanup;
753 }
754
755 C_ASSERT( SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE >= 2*SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET );
756
757 // reuse bytes 0..31 of privateSeed buffer for encapsulation shared secret
758 scError = SymCryptMlKemEncapsulate(
759 pkMlKemkey,
760 &privateSeed[0], SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET,
761 pbPctCipherText, cbPctCipherText );
762 if( scError != SYMCRYPT_NO_ERROR )
763 {
764 scError = SYMCRYPT_FIPS_FAILURE;
765 goto cleanup;
766 }
767
768 // reuse second 32..63 bytes of privateSeed buffer for encapsulation shared secret
769 scError = SymCryptMlKemDecapsulate(
770 pkMlKemkey,
771 pbPctCipherText, cbPctCipherText,
772 &privateSeed[SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET], SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET );
773 if( scError != SYMCRYPT_NO_ERROR )
774 {
775 scError = SYMCRYPT_FIPS_FAILURE;
776 goto cleanup;
777 }
778
779 if( !SymCryptEqual( &privateSeed[0], &privateSeed[SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET], SYMCRYPT_MLKEM_SIZEOF_AGREED_SECRET ) )
780 {
781 // Do not fatal on PCT failure here, as it is expected with very low probability that
782 // with correct keygen and encaps/decaps, the agreed secrets do not match
783 scError = SYMCRYPT_FIPS_FAILURE;
784 goto cleanup;
785 }
786
787 // could track having run the PCT with a flag in pkMlKemkey->fAlgorithmInfo,
788 // but currently no need to do that given we don't ever defer the PCT
789 }
790
791cleanup:
792 if( pbPctCipherText != NULL )
793 {
794 // Wiping is not required for security, but has low relative cost
795 // and better to be on the safe side for FIPS
796 SymCryptWipe( pbPctCipherText, cbPctCipherText );
797 SymCryptCallbackFree( pbPctCipherText );
798 }
799
800 SymCryptWipeKnownSize( privateSeed, sizeof(privateSeed) );
801
802 return scError;
803}
SymCryptMlKemEncapsulate
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemEncapsulate(_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret, _Out_writes_bytes_(cbCiphertext) PBYTE pbCiphertext, SIZE_T cbCiphertext)
Definition: mlkem.c:996
SymCryptMlKemkeySetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeySetValue(_In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_MLKEMKEY_FORMAT mlKemkeyFormat, UINT32 flags, _Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey)
Definition: mlkem.c:428
SymCryptMlKemDecapsulate
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemDecapsulate(_In_ PCSYMCRYPT_MLKEMKEY pkMlKemkey, _In_reads_bytes_(cbCiphertext) PCBYTE pbCiphertext, SIZE_T cbCiphertext, _Out_writes_bytes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
Definition: mlkem.c:1026
privateSeed
BYTE privateSeed[SYMCRYPT_COMPOSITE_MLKEM_IRTF_PRIVATE_SEED_SIZE]
Definition: sc_lib.h:4450
SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE
#define SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE
Definition: symcrypt.h:10007

◆ SymCryptMlKemkeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeyGetValue ( _In_ PCSYMCRYPT_MLKEMKEY  pkMlKemkey,
_Out_writes_bytes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
SYMCRYPT_MLKEMKEY_FORMAT  mlKemkeyFormat,
UINT32  flags 
)

Definition at line 601 of file mlkem.c.

607{
608 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
609 PBYTE pbCurr = pbDst;
610 const UINT32 nRows = pkMlKemkey->params.nRows;
611 const SIZE_T cbEncodedVector = SYMCRYPT_MLKEM_SIZEOF_ENCODED_UNCOMPRESSED_VECTOR( nRows );
612
613 UNREFERENCED_PARAMETER( flags );
614
615 if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_NULL )
616 {
617 scError = SYMCRYPT_INVALID_ARGUMENT;
618 goto cleanup;
619 }
620
621 if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED )
622 {
623 if( cbDst != SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE )
624 {
625 scError = SYMCRYPT_WRONG_KEY_SIZE;
626 goto cleanup;
627 }
628
629 if( !pkMlKemkey->hasPrivateSeed )
630 {
631 scError = SYMCRYPT_INCOMPATIBLE_FORMAT;
632 goto cleanup;
633 }
634
635 memcpy( pbCurr, pkMlKemkey->privateSeed, sizeof(pkMlKemkey->privateSeed) );
636 pbCurr += sizeof(pkMlKemkey->privateSeed);
637
638 memcpy( pbCurr, pkMlKemkey->privateRandom, sizeof(pkMlKemkey->privateRandom) );
639 pbCurr += sizeof(pkMlKemkey->privateRandom);
640 }
641 else if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY )
642 {
643 if( cbDst != SYMCRYPT_MLKEM_SIZEOF_FORMAT_DECAPSULATION_KEY( nRows ) )
644 {
645 scError = SYMCRYPT_INVALID_ARGUMENT;
646 goto cleanup;
647 }
648
649 if( !pkMlKemkey->hasPrivateKey )
650 {
651 scError = SYMCRYPT_INCOMPATIBLE_FORMAT;
652 goto cleanup;
653 }
654
655 // We don't precompute byte-encoding of private key as exporting decapsulation key is not a critical path operation
656 // All other fields are kept in memory
657 SymCryptMlKemVectorCompressAndEncode( pkMlKemkey->pvs, 12, pbCurr, cbEncodedVector );
658 pbCurr += cbEncodedVector;
659
660 memcpy( pbCurr, pkMlKemkey->encodedT, cbEncodedVector );
661 pbCurr += cbEncodedVector;
662
663 memcpy( pbCurr, pkMlKemkey->publicSeed, sizeof(pkMlKemkey->publicSeed) );
664 pbCurr += sizeof(pkMlKemkey->publicSeed);
665
666 memcpy( pbCurr, pkMlKemkey->encapsKeyHash, sizeof(pkMlKemkey->encapsKeyHash) );
667 pbCurr += sizeof(pkMlKemkey->encapsKeyHash);
668
669 memcpy( pbCurr, pkMlKemkey->privateRandom, sizeof(pkMlKemkey->privateRandom) );
670 pbCurr += sizeof(pkMlKemkey->privateRandom);
671 }
672 else if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY )
673 {
674 if( cbDst != SYMCRYPT_MLKEM_SIZEOF_FORMAT_ENCAPSULATION_KEY( nRows ) )
675 {
676 scError = SYMCRYPT_INVALID_ARGUMENT;
677 goto cleanup;
678 }
679
680 memcpy( pbCurr, pkMlKemkey->encodedT, cbEncodedVector );
681 pbCurr += cbEncodedVector;
682
683 memcpy( pbCurr, pkMlKemkey->publicSeed, sizeof(pkMlKemkey->publicSeed) );
684 pbCurr += sizeof(pkMlKemkey->publicSeed);
685 }
686 else
687 {
688 scError = SYMCRYPT_NOT_IMPLEMENTED;
689 goto cleanup;
690 }
691
692 SYMCRYPT_ASSERT( pbCurr == pbDst + cbDst );
693
694cleanup:
695 return scError;
696}
SYMCRYPT_MLKEM_SIZEOF_FORMAT_ENCAPSULATION_KEY
#define SYMCRYPT_MLKEM_SIZEOF_FORMAT_ENCAPSULATION_KEY(_nRows)
Definition: mlkem.c:200
SYMCRYPT_MLKEM_SIZEOF_ENCODED_UNCOMPRESSED_VECTOR
#define SYMCRYPT_MLKEM_SIZEOF_ENCODED_UNCOMPRESSED_VECTOR(_nRows)
Definition: mlkem.c:193
SYMCRYPT_MLKEM_SIZEOF_FORMAT_DECAPSULATION_KEY
#define SYMCRYPT_MLKEM_SIZEOF_FORMAT_DECAPSULATION_KEY(_nRows)
Definition: mlkem.c:197
SymCryptMlKemVectorCompressAndEncode
VOID SYMCRYPT_CALL SymCryptMlKemVectorCompressAndEncode(_In_ PCSYMCRYPT_MLKEM_VECTOR pvSrc, UINT32 nBitsPerCoefficient, _Out_writes_bytes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
Definition: mlkem_primitives.c:1362

◆ SymCryptMlKemkeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemkeySetValue ( _In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_MLKEMKEY_FORMAT  mlKemkeyFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_MLKEMKEY  pkMlKemkey 
)

Definition at line 428 of file mlkem.c.

434{
435 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
436 PCBYTE pbCurr = pbSrc;
437 PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES pCompTemps = NULL;
438 const UINT32 nRows = pkMlKemkey->params.nRows;
439 const SIZE_T cbEncodedVector = SYMCRYPT_MLKEM_SIZEOF_ENCODED_UNCOMPRESSED_VECTOR( nRows );
440
441 // Ensure only allowed flags are specified
442 UINT32 allowedFlags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION;
443
444 if ( ( flags & ~allowedFlags ) != 0 )
445 {
446 scError = SYMCRYPT_INVALID_ARGUMENT;
447 goto cleanup;
448 }
449
450 // Check that minimal validation flag only specified with no fips
451 if ( ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 ) &&
452 ( ( flags & SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION ) != 0 ) )
453 {
454 scError = SYMCRYPT_INVALID_ARGUMENT;
455 goto cleanup;
456 }
457
458 if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_NULL )
459 {
460 scError = SYMCRYPT_INVALID_ARGUMENT;
461 goto cleanup;
462 }
463
464 if( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 )
465 {
466 // Ensure ML-KEM algorithm selftest is run before first use of ML-KEM algorithms;
467 // notably _before_ first full KeyGen
468 SYMCRYPT_RUN_SELFTEST_ONCE(
469 SymCryptMlKemSelftest,
470 SYMCRYPT_SELFTEST_ALGORITHM_MLKEM);
471 }
472
473 pCompTemps = SymCryptCallbackAlloc( sizeof(SYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES) );
474 if( pCompTemps == NULL )
475 {
476 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
477 goto cleanup;
478 }
479
480 if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED )
481 {
482 if( cbSrc != SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE )
483 {
484 scError = SYMCRYPT_WRONG_KEY_SIZE;
485 goto cleanup;
486 }
487
488 pkMlKemkey->hasPrivateSeed = TRUE;
489 memcpy( pkMlKemkey->privateSeed, pbCurr, sizeof(pkMlKemkey->privateSeed) );
490 pbCurr += sizeof(pkMlKemkey->privateSeed);
491
492 pkMlKemkey->hasPrivateKey = TRUE;
493 memcpy( pkMlKemkey->privateRandom, pbCurr, sizeof(pkMlKemkey->privateRandom) );
494 pbCurr += sizeof(pkMlKemkey->privateRandom);
495
496 SymCryptMlKemkeyExpandFromPrivateSeed( pkMlKemkey, pCompTemps );
497 }
498 else if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY )
499 {
500 if( cbSrc != SYMCRYPT_MLKEM_SIZEOF_FORMAT_DECAPSULATION_KEY( nRows ) )
501 {
502 scError = SYMCRYPT_WRONG_KEY_SIZE;
503 goto cleanup;
504 }
505
506 // decode s
507 scError = SymCryptMlKemVectorDecodeAndDecompress( pbCurr, cbEncodedVector, 12, pkMlKemkey->pvs );
508 if( scError != SYMCRYPT_NO_ERROR )
509 {
510 goto cleanup;
511 }
512 pbCurr += cbEncodedVector;
513
514 // copy t and decode t
515 memcpy( pkMlKemkey->encodedT, pbCurr, cbEncodedVector );
516 pbCurr += cbEncodedVector;
517 scError = SymCryptMlKemVectorDecodeAndDecompress( pkMlKemkey->encodedT, cbEncodedVector, 12, pkMlKemkey->pvt );
518 if( scError != SYMCRYPT_NO_ERROR )
519 {
520 goto cleanup;
521 }
522
523 // copy public seed and expand public matrix
524 memcpy( pkMlKemkey->publicSeed, pbCurr, sizeof(pkMlKemkey->publicSeed) );
525 pbCurr += sizeof(pkMlKemkey->publicSeed);
526 SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed( pkMlKemkey, pCompTemps );
527
528 // transpose A
529 SymCryptMlKemMatrixTranspose( pkMlKemkey->pmAtranspose );
530
531 // compute hash of encapsulation key blob
532 SymCryptMlKemkeyComputeEncapsulationKeyHash( pkMlKemkey, pCompTemps, cbEncodedVector );
533
534 // check hash of encapsulation key matches hash in the provided blob
535 if( !SymCryptEqual( pbCurr, pkMlKemkey->encapsKeyHash, sizeof(pkMlKemkey->encapsKeyHash) ) )
536 {
537 scError = SYMCRYPT_INVALID_BLOB;
538 goto cleanup;
539 }
540 pbCurr += sizeof(pkMlKemkey->encapsKeyHash);
541
542 // copy private random
543 memcpy( pkMlKemkey->privateRandom, pbCurr, sizeof(pkMlKemkey->privateRandom) );
544 pbCurr += sizeof(pkMlKemkey->privateRandom);
545
546 pkMlKemkey->hasPrivateSeed = FALSE;
547 pkMlKemkey->hasPrivateKey = TRUE;
548 }
549 else if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY )
550 {
551 if( cbSrc != SYMCRYPT_MLKEM_SIZEOF_FORMAT_ENCAPSULATION_KEY( nRows ) )
552 {
553 scError = SYMCRYPT_WRONG_KEY_SIZE;
554 goto cleanup;
555 }
556
557 // copy t and decode t
558 memcpy( pkMlKemkey->encodedT, pbCurr, cbEncodedVector );
559 pbCurr += cbEncodedVector;
560 scError = SymCryptMlKemVectorDecodeAndDecompress( pkMlKemkey->encodedT, cbEncodedVector, 12, pkMlKemkey->pvt );
561 if( scError != SYMCRYPT_NO_ERROR )
562 {
563 goto cleanup;
564 }
565
566 // copy public seed and expand public matrix
567 memcpy( pkMlKemkey->publicSeed, pbCurr, sizeof(pkMlKemkey->publicSeed) );
568 pbCurr += sizeof(pkMlKemkey->publicSeed);
569 SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed( pkMlKemkey, pCompTemps );
570
571 // transpose A
572 SymCryptMlKemMatrixTranspose( pkMlKemkey->pmAtranspose );
573
574 // precompute hash of encapsulation key blob
575 SymCryptMlKemkeyComputeEncapsulationKeyHash( pkMlKemkey, pCompTemps, cbEncodedVector );
576
577 pkMlKemkey->hasPrivateSeed = FALSE;
578 pkMlKemkey->hasPrivateKey = FALSE;
579 }
580 else
581 {
582 scError = SYMCRYPT_NOT_IMPLEMENTED;
583 goto cleanup;
584 }
585
586 SYMCRYPT_ASSERT( pbCurr == pbSrc + cbSrc );
587
588cleanup:
589 if( pCompTemps != NULL )
590 {
591 SymCryptWipe( pCompTemps, sizeof(*pCompTemps) );
592 SymCryptCallbackFree( pCompTemps );
593 }
594
595 return scError;
596}
SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed
static VOID SYMCRYPT_CALL SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed(_Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey, _Inout_ PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES pCompTemps)
Definition: mlkem.c:288
SymCryptMlKemkeyExpandFromPrivateSeed
static VOID SYMCRYPT_CALL SymCryptMlKemkeyExpandFromPrivateSeed(_Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey, _Inout_ PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES pCompTemps)
Definition: mlkem.c:337
SymCryptMlKemkeyComputeEncapsulationKeyHash
static VOID SYMCRYPT_CALL SymCryptMlKemkeyComputeEncapsulationKeyHash(_Inout_ PSYMCRYPT_MLKEMKEY pkMlKemkey, _Inout_ PSYMCRYPT_MLKEM_INTERNAL_COMPUTATION_TEMPORARIES pCompTemps, SIZE_T cbEncodedVector)
Definition: mlkem.c:321
SymCryptMlKemMatrixTranspose
VOID SYMCRYPT_CALL SymCryptMlKemMatrixTranspose(_Inout_ PSYMCRYPT_MLKEM_MATRIX pmSrc)
Definition: mlkem_primitives.c:1152
SymCryptMlKemSelftest
VOID SYMCRYPT_CALL SymCryptMlKemSelftest(void)
SYMCRYPT_SELFTEST_ALGORITHM_MLKEM
@ SYMCRYPT_SELFTEST_ALGORITHM_MLKEM
Definition: symcrypt_internal.h:3431

Referenced by SymCryptMlKemkeyGenerate().

◆ SymCryptMlKemSelftest()

VOID SYMCRYPT_CALL SymCryptMlKemSelftest ( void  )

Referenced by SymCryptMlKemkeySetValue().

◆ SymCryptMlKemSizeofCiphertextFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemSizeofCiphertextFromParams ( SYMCRYPT_MLKEM_PARAMS  params,
_Out_ SIZE_T *  pcbCiphertext 
)

Definition at line 257 of file mlkem.c.

260{
261 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
262 SYMCRYPT_MLKEM_INTERNAL_PARAMS internalParams;
263 SIZE_T cbU, cbV;
264
265 scError = SymCryptMlKemkeyGetInternalParamsFromParams(params, &internalParams);
266 if( scError != SYMCRYPT_NO_ERROR )
267 {
268 goto cleanup;
269 }
270
271 // u vector encoded with nBitsOfU * SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS bits per polynomial
272 cbU = ((SIZE_T)internalParams.nRows) * internalParams.nBitsOfU * (SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS / 8);
273 // v polynomial encoded with nBitsOfV * SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS bits
274 cbV = ((SIZE_T)internalParams.nBitsOfV) * (SYMCRYPT_MLWE_POLYNOMIAL_COEFFICIENTS / 8);
275 *pcbCiphertext = cbU + cbV;
276
277 SYMCRYPT_ASSERT( (internalParams.params != SYMCRYPT_MLKEM_PARAMS_MLKEM512) || ((cbU + cbV) == SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM512) );
278 SYMCRYPT_ASSERT( (internalParams.params != SYMCRYPT_MLKEM_PARAMS_MLKEM768) || ((cbU + cbV) == SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM768) );
279 SYMCRYPT_ASSERT( (internalParams.params != SYMCRYPT_MLKEM_PARAMS_MLKEM1024) || ((cbU + cbV) == SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM1024) );
280
281cleanup:
282 return scError;
283}
SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM768
#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM768
Definition: symcrypt.h:10031
SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM512
#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM512
Definition: symcrypt.h:10030
SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM1024
#define SYMCRYPT_MLKEM_CIPHERTEXT_SIZE_MLKEM1024
Definition: symcrypt.h:10032

◆ SymCryptMlKemSizeofKeyFormatFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptMlKemSizeofKeyFormatFromParams ( SYMCRYPT_MLKEM_PARAMS  params,
SYMCRYPT_MLKEMKEY_FORMAT  mlKemkeyformat,
_Out_ SIZE_T *  pcbKeyFormat 
)

Definition at line 212 of file mlkem.c.

216{
217 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
218 SYMCRYPT_MLKEM_INTERNAL_PARAMS internalParams;
219
220 if( mlKemkeyFormat == SYMCRYPT_MLKEMKEY_FORMAT_NULL )
221 {
222 scError = SYMCRYPT_INCOMPATIBLE_FORMAT;
223 goto cleanup;
224 }
225
226 scError = SymCryptMlKemkeyGetInternalParamsFromParams(params, &internalParams);
227 if( scError != SYMCRYPT_NO_ERROR )
228 {
229 goto cleanup;
230 }
231
232 switch( mlKemkeyFormat )
233 {
234 case SYMCRYPT_MLKEMKEY_FORMAT_PRIVATE_SEED:
235 *pcbKeyFormat = SYMCRYPT_MLKEM_PRIVATE_SEED_SIZE;
236 break;
237
238 case SYMCRYPT_MLKEMKEY_FORMAT_DECAPSULATION_KEY:
239 *pcbKeyFormat = SYMCRYPT_MLKEM_SIZEOF_FORMAT_DECAPSULATION_KEY(internalParams.nRows);
240 break;
241
242 case SYMCRYPT_MLKEMKEY_FORMAT_ENCAPSULATION_KEY:
243 *pcbKeyFormat = SYMCRYPT_MLKEM_SIZEOF_FORMAT_ENCAPSULATION_KEY(internalParams.nRows);
244 break;
245
246 default:
247 scError = SYMCRYPT_INVALID_ARGUMENT;
248 goto cleanup;
249 }
250
251cleanup:
252 return scError;
253}

◆ SymCryptModuleInit()

VOID SYMCRYPT_CALL SymCryptModuleInit ( _In_ UINT32  api,
_In_ UINT32  minor 
)

◆ SymCryptPaddingPkcs7Add()

VOID SYMCRYPT_CALL SymCryptPaddingPkcs7Add ( SIZE_T  cbBlockSize,
_In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_writes_to_(cbDst, *pcbResult) PBYTE  pbDst,
SIZE_T  cbDst,
SIZE_T *  pcbResult 
)

Definition at line 12 of file paddingPkcs7.c.

19{
20 SIZE_T cbPadVal; // PadVal is the number of bytes to pad.
21 SIZE_T cbDataLastBlock; // dwDataLastBlock is the number of bytes of data at the final block.
22 SIZE_T cbResult = 0; // This variable must always have a valid value when we finish the function.
23
24 SYMCRYPT_ASSERT(cbBlockSize < 256); // cbBlockSize must be < 256
25 SYMCRYPT_ASSERT((cbBlockSize & (cbBlockSize - 1)) == 0); // cbBlockSize must be a power of 2
26
27 //
28 // Compute the padding parameters.
29 //
30
31 cbDataLastBlock = (cbSrc & (cbBlockSize - 1));
32
33 cbResult = (cbSrc - cbDataLastBlock + cbBlockSize);
34
35 SYMCRYPT_ASSERT(cbDst >= cbResult); // cbDst >= cbSrc - cbSrc % cbBlockSize + cbBlockSize
36
37 if (cbResult > cbDst)
38 {
39 goto cleanup;
40 }
41
42 cbPadVal = (cbBlockSize - cbDataLastBlock);
43
44 //
45 // perform the padding
46 //
47
48 // cbSrc must be greater than zero. memcpy(pbDst, NULL, 0) is not defined!
49 if (pbDst != pbSrc && cbSrc > 0)
50 {
51 memcpy(pbDst, pbSrc, cbSrc);
52 }
53
54 memset(pbDst + cbSrc, (int)cbPadVal, cbPadVal);
55
56cleanup:
57 *pcbResult = cbResult;
58}

◆ SymCryptPaddingPkcs7Remove()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPaddingPkcs7Remove ( SIZE_T  cbBlockSize,
_In_reads_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_Out_writes_to_(cbDst, *pcbResult) PBYTE  pbDst,
SIZE_T  cbDst,
SIZE_T *  pcbResult 
)

Definition at line 63 of file paddingPkcs7.c.

70{
71 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
72
73 UINT32 mPaddingError = 0; // Indicates whether there is an error in padding or not.
74 UINT32 mBufferSizeError = 0; // Indicates whether pbDst is large enough to contain the entire message.
75 UINT32 mask = 0; // Mask for message bytes at the final block.
76 UINT32 cbPadVal; // PadVal is the number of padded bytes.
77 UINT32 cbSrc32;
78 UINT32 cbDst32;
79 UINT32 cbMsg32;
80
81 SIZE_T cbBulk = 0;
82 SIZE_T cbResult; // This variable must always have a valid value when we finish the function.
83
84
85 SYMCRYPT_ASSERT(cbBlockSize < 256); // cbBlockSize must be < 256
86 SYMCRYPT_ASSERT((cbBlockSize & (cbBlockSize - 1)) == 0); // cbBlockSize must be a power of 2
87 SYMCRYPT_ASSERT((cbSrc & (cbBlockSize - 1)) == 0); // cbSrc is a multiple of cbBlockSize
88 SYMCRYPT_ASSERT(cbSrc > 0); // cbSrc is greaten than zero
89
90 cbPadVal = (UINT32)pbSrc[cbSrc - 1];
91
92 // check the Padding to make sure it is valid.
93 mPaddingError |= SymCryptMask32IsZeroU31(cbPadVal) | SymCryptMask32LtU31((UINT32)cbBlockSize, cbPadVal);
94
95 // If cbPadVal is greater than cbSrc, SYMCRYPT_INVALID_ARGUMENT will be returned
96 // and cbResult will not be the right value.
97 cbResult = cbSrc - cbPadVal;
98
99 //
100 // Bulk processing
101 //
102
103 cbDst = SYMCRYPT_MIN(cbDst, cbSrc);
104
105 cbBulk = cbSrc - cbBlockSize;
106
107 // cbSrc, cbDst, and blockSize are not secrets.
108 // This condition can be checked in a non-side channel safe way.
109 if (cbDst < cbBulk)
110 {
111 scError = SYMCRYPT_BUFFER_TOO_SMALL;
112 goto cleanup;
113 }
114
115 if (pbDst != pbSrc)
116 {
117 memcpy(pbDst, pbSrc, cbBulk);
118 }
119
120 // Updating parameters
121 pbSrc += cbBulk; cbSrc -= cbBulk;
122 pbDst += cbBulk; cbDst -= cbBulk;
123
124 cbSrc32 = (UINT32)cbSrc;
125 cbDst32 = (UINT32)cbDst;
126
127 //
128 // Validating padding
129 //
130 // If cbPadVal is greater than cbBlockSize,
131 // we have to limit cbPadVal to be at most equal to cbBlockSize.
132 cbPadVal = 1 + ((cbPadVal - 1) & (cbBlockSize - 1));
133 cbMsg32 = (UINT32)(cbBlockSize - cbPadVal);
134
135 //check Dst buffer length to make sure it is possible copy the whole message (not including the padding).
136 mBufferSizeError |= SymCryptMask32LtU31(cbDst32, cbMsg32);
137
138 //
139 // Final Block processing
140 //
141
142 // Updating only the bytes of the message and leaving the other bytes in pbDst unchanged.
143 // Validating the value of the padded bytes.
144
145 for (UINT32 i = 0; i < cbBlockSize; ++i) // cbDst <= cbSrc == cbBlockSize
146 {
147 mask = SymCryptMask32LtU31(i, cbMsg32);
148
149 mPaddingError |= (SymCryptMask32IsNonzeroU31((UINT32)pbSrc[i] ^ cbPadVal) & ~mask);
150
151 if (i < cbDst)
152 {
153 pbDst[i] ^= (pbDst[i] ^ pbSrc[i]) & mask;
154 }
155 }
156
157cleanup:
158
159 *pcbResult = cbResult;
160
161 // Update scError with the two error masks.
162 // SYMCRYPT_INVALID_ARGUMENT gets precedence over SYMCRYPT_BUFFER_TOO_SMALL
163 scError ^= mBufferSizeError & (scError ^ SYMCRYPT_BUFFER_TOO_SMALL);
164 scError ^= mPaddingError & (scError ^ SYMCRYPT_INVALID_ARGUMENT);
165
166 return scError;
167}
SymCryptMask32IsNonzeroU31
UINT32 SYMCRYPT_CALL SymCryptMask32IsNonzeroU31(UINT32 v)
Definition: scsTools.c:28
SymCryptMask32IsZeroU31
UINT32 SYMCRYPT_CALL SymCryptMask32IsZeroU31(UINT32 v)
Definition: scsTools.c:36

◆ SymCryptParallelSha256Init()

VOID SYMCRYPT_CALL SymCryptParallelSha256Init ( _Out_writes_(nStates) PSYMCRYPT_SHA256_STATE  pStates,
SIZE_T  nStates 
)

◆ SymCryptParallelSha256Process()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelSha256Process ( _Inout_updates_(nStates) PSYMCRYPT_SHA256_STATE  pStates,
SIZE_T  nStates,
_Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION  pOperations,
SIZE_T  nOperations,
_Out_writes_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch 
)

◆ SymCryptParallelSha256Selftest()

VOID SYMCRYPT_CALL SymCryptParallelSha256Selftest ( void  )

◆ SymCryptParallelSha384Init()

VOID SYMCRYPT_CALL SymCryptParallelSha384Init ( _Out_writes_(nStates) PSYMCRYPT_SHA384_STATE  pStates,
SIZE_T  nStates 
)

◆ SymCryptParallelSha384Process()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelSha384Process ( _Inout_updates_(nStates) PSYMCRYPT_SHA384_STATE  pStates,
SIZE_T  nStates,
_Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION  pOperations,
SIZE_T  nOperations,
_Out_writes_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch 
)

◆ SymCryptParallelSha384Selftest()

VOID SYMCRYPT_CALL SymCryptParallelSha384Selftest ( void  )

◆ SymCryptParallelSha512Init()

VOID SYMCRYPT_CALL SymCryptParallelSha512Init ( _Out_writes_(nStates) PSYMCRYPT_SHA512_STATE  pStates,
SIZE_T  nStates 
)

◆ SymCryptParallelSha512Process()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptParallelSha512Process ( _Inout_updates_(nStates) PSYMCRYPT_SHA512_STATE  pStates,
SIZE_T  nStates,
_Inout_updates_(nOperations) PSYMCRYPT_PARALLEL_HASH_OPERATION  pOperations,
SIZE_T  nOperations,
_Out_writes_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch 
)

◆ SymCryptParallelSha512Selftest()

VOID SYMCRYPT_CALL SymCryptParallelSha512Selftest ( void  )

◆ SymCryptPbkdf2()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2 ( PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
UINT64  iterationCnt,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 89 of file pbkdf2.c.

98{
99 SYMCRYPT_PBKDF2_EXPANDED_KEY key;
100 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
101
102 scError = SymCryptPbkdf2ExpandKey( &key, macAlgorithm, pbKey, cbKey );
103 if( scError != SYMCRYPT_NO_ERROR )
104 {
105 goto cleanup;
106 }
107
108 scError = SymCryptPbkdf2Derive( &key, pbSalt, cbSalt, iterationCnt, pbResult, cbResult );
109 if( scError != SYMCRYPT_NO_ERROR )
110 {
111 goto cleanup;
112 }
113
114cleanup:
115
116 SymCryptWipeKnownSize( &key, sizeof( key ) );
117
118 return scError;
119
120}
SymCryptPbkdf2ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2ExpandKey(_Out_ PSYMCRYPT_PBKDF2_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: pbkdf2.c:75
SymCryptPbkdf2Derive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2Derive(_In_ PCSYMCRYPT_PBKDF2_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT64 iterationCnt, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: pbkdf2.c:16
_SYMCRYPT_PBKDF2_EXPANDED_KEY
Definition: symcrypt_internal.h:2205

Referenced by SymCryptPbkdf2_HmacSha1SelfTest(), and SymCryptPbkdf2_HmacSha256SelfTest().

◆ SymCryptPbkdf2_HmacSha1SelfTest()

VOID SYMCRYPT_CALL SymCryptPbkdf2_HmacSha1SelfTest ( void  )

Definition at line 23 of file pbkdf2_hmacsha1.c.

24{
25 BYTE res[sizeof(pbkdf2_sha1Answer)];
26
27 SymCryptPbkdf2(
28 SymCryptHmacSha1Algorithm,
29 &SymCryptTestKey32[0], 8,
30 &SymCryptTestKey32[16], 16,
31 pbkdf2_IterationCnt,
32 res,
33 sizeof(res));
34
35 SymCryptInjectError( res, sizeof( res ) );
36
37 if (memcmp(res, pbkdf2_sha1Answer, sizeof(res)) !=0)
38 {
39 SymCryptFatal('Pbk2');
40 }
41}
pbkdf2_sha1Answer
static const BYTE pbkdf2_sha1Answer[]
Definition: pbkdf2_hmacsha1.c:16
pbkdf2_IterationCnt
static const UINT64 pbkdf2_IterationCnt
Definition: pbkdf2_hmacsha1.c:14
SymCryptHmacSha1Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha1Algorithm
Definition: hmacsha1.c:36
SymCryptPbkdf2
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2(PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT64 iterationCnt, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: pbkdf2.c:89

◆ SymCryptPbkdf2_HmacSha256SelfTest()

VOID SYMCRYPT_CALL SymCryptPbkdf2_HmacSha256SelfTest ( void  )

Definition at line 23 of file pbkdf2_hmacsha256.c.

24{
25 BYTE res[sizeof(pbkdf2_sha256Answer)];
26
27 SymCryptPbkdf2(
28 SymCryptHmacSha256Algorithm,
29 &SymCryptTestKey32[0], 8,
30 &SymCryptTestKey32[16], 16,
31 pbkdf2_IterationCnt,
32 res,
33 sizeof(res));
34
35 SymCryptInjectError( res, sizeof( res ) );
36
37 if (memcmp(res, pbkdf2_sha256Answer, sizeof(res)) !=0)
38 {
39 SymCryptFatal('Pbk2');
40 }
41}
pbkdf2_sha256Answer
static const BYTE pbkdf2_sha256Answer[]
Definition: pbkdf2_hmacsha256.c:16
pbkdf2_IterationCnt
static const UINT64 pbkdf2_IterationCnt
Definition: pbkdf2_hmacsha256.c:14
SymCryptHmacSha256Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha256Algorithm
Definition: hmacsha256.c:29

◆ SymCryptPbkdf2Derive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2Derive ( _In_ PCSYMCRYPT_PBKDF2_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
UINT64  iterationCnt,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 16 of file pbkdf2.c.

23{
24 SYMCRYPT_MAC_STATE macState;
25 UINT32 iBlock;
26 SIZE_T bytes;
27 SIZE_T blockSize = pExpandedKey->macAlg->resultSize;
28 UINT64 iterations;
29 SYMCRYPT_ALIGN BYTE rbBlockResult[SYMCRYPT_MAC_MAX_RESULT_SIZE];
30 SYMCRYPT_ALIGN BYTE rbWorkBuffer[SYMCRYPT_MAC_MAX_RESULT_SIZE];
31
32 SYMCRYPT_ASSERT(
33 blockSize <= SYMCRYPT_MAC_MAX_RESULT_SIZE &&
34 cbResult > 0 );
35
36 if (iterationCnt == 0)
37 {
38 return SYMCRYPT_WRONG_ITERATION_COUNT;
39 }
40
41 iBlock = 0;
42 while( cbResult > 0 )
43 {
44 iBlock += 1;
45 SYMCRYPT_STORE_MSBFIRST32( &rbBlockResult[0], iBlock ); // use result buf as temp
46
47 pExpandedKey->macAlg->initFunc ( &macState, &pExpandedKey->macKey);
48 pExpandedKey->macAlg->appendFunc( &macState, pbSalt, cbSalt);
49 pExpandedKey->macAlg->appendFunc( &macState, &rbBlockResult[0], 4 ); // block count encoded in 4 bytes
50 pExpandedKey->macAlg->resultFunc( &macState, rbWorkBuffer);
51
52#pragma warning(suppress: 22105)
53 memcpy( rbBlockResult, rbWorkBuffer, blockSize );
54 for( iterations = 1; iterations < iterationCnt; iterations++ )
55 {
56 pExpandedKey->macAlg->initFunc ( &macState, &pExpandedKey->macKey );
57 pExpandedKey->macAlg->appendFunc( &macState, rbWorkBuffer, blockSize );
58 pExpandedKey->macAlg->resultFunc( &macState, rbWorkBuffer );
59 SymCryptXorBytes( &rbWorkBuffer[0], &rbBlockResult[0], &rbBlockResult[0], blockSize );
60 }
61
62 bytes = SYMCRYPT_MIN( cbResult, blockSize );
63 memcpy( pbResult, rbBlockResult, bytes );
64 pbResult += bytes;
65 cbResult -= bytes;
66 }
67
68 SymCryptWipeKnownSize( &rbWorkBuffer[0], sizeof( rbWorkBuffer ) );
69 SymCryptWipeKnownSize( &rbBlockResult[0], sizeof( rbBlockResult ) );
70 return SYMCRYPT_NO_ERROR;
71}
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
iterations
ULONGLONG iterations
Definition: bcrypt.c:539

Referenced by SymCryptPbkdf2().

◆ SymCryptPbkdf2ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2ExpandKey ( _Out_ PSYMCRYPT_PBKDF2_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 75 of file pbkdf2.c.

80{
81 SYMCRYPT_ASSERT( macAlgorithm->expandedKeySize <= sizeof( pExpandedKey->macKey ) );
82
83 pExpandedKey->macAlg = macAlgorithm;
84 return macAlgorithm->expandKeyFunc(&pExpandedKey->macKey, pbKey, cbKey );
85}

Referenced by SymCryptPbkdf2().

◆ SymCryptPoly1305()

VOID SYMCRYPT_CALL SymCryptPoly1305 ( _In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE  pbKey,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 18 of file poly1305.c.

23{
24 SYMCRYPT_POLY1305_STATE state;
25
26 SymCryptPoly1305Init( &state, pbKey );
27 SymCryptPoly1305Append( &state, pbData, cbData );
28 SymCryptPoly1305Result( &state, pbResult );
29}
SymCryptPoly1305Result
VOID SYMCRYPT_CALL SymCryptPoly1305Result(_Inout_ PSYMCRYPT_POLY1305_STATE pState, _Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE pbResult)
Definition: poly1305.c:109
SymCryptPoly1305Init
VOID SYMCRYPT_CALL SymCryptPoly1305Init(_Out_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE pbKey)
Definition: poly1305.c:33
SymCryptPoly1305Append
VOID SYMCRYPT_CALL SymCryptPoly1305Append(_Inout_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: poly1305.c:55

Referenced by SymCryptPoly1305Selftest().

◆ SymCryptPoly1305Append()

VOID SYMCRYPT_CALL SymCryptPoly1305Append ( _Inout_ PSYMCRYPT_POLY1305_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 55 of file poly1305.c.

59{
60 SIZE_T nBytes;
61 SIZE_T bytesInBuffer;
62
63 bytesInBuffer = pState->bytesInBuffer;
64 if( bytesInBuffer != 0 )
65 {
66 // We have a partial block in the buffer, keep filling the block
67
68 SYMCRYPT_ASSERT( bytesInBuffer < 16 );
69 nBytes = 16 - bytesInBuffer;
70 if( nBytes > cbData )
71 {
72 nBytes = cbData;
73 }
74
75 memcpy( &pState->buf[bytesInBuffer], pbData, nBytes );
76 pbData += nBytes;
77 cbData -= nBytes;
78 bytesInBuffer += nBytes;
79
80 if( bytesInBuffer == 16 )
81 {
82 // Buffer is full, process it and empty the buffer
83 SymCryptPoly1305ProcessBlocks( pState, pState->buf, bytesInBuffer );
84 bytesInBuffer = 0;
85 }
86 pState->bytesInBuffer = bytesInBuffer;
87 }
88
89 if( cbData >= 16 )
90 {
91 // There are whole blocks to process
92 SymCryptPoly1305ProcessBlocks( pState, pbData, cbData & ~0xf );
93 pbData += cbData;
94 cbData &= 0xf;
95 pbData -= cbData;
96 }
97
98 if( cbData > 0 )
99 {
100 // Copy remaining data to buffer
101 SYMCRYPT_ASSERT( cbData < 16 );
102 memcpy( &pState->buf[0], pbData, cbData );
103 pState->bytesInBuffer = cbData;
104 }
105}
SymCryptPoly1305ProcessBlocks
VOID SYMCRYPT_CALL SymCryptPoly1305ProcessBlocks(_Inout_ PSYMCRYPT_POLY1305_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: poly1305.c:323

Referenced by SymCryptChaCha20Poly1305ComputeTag(), and SymCryptPoly1305().

◆ SymCryptPoly1305Init()

VOID SYMCRYPT_CALL SymCryptPoly1305Init ( _Out_ PSYMCRYPT_POLY1305_STATE  pState,
_In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE  pbKey 
)

Definition at line 33 of file poly1305.c.

36{
37 pState->r[0] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 0 ) & 0x0fffffff;
38 pState->r[1] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 4 ) & 0x0ffffffc;
39 pState->r[2] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 8 ) & 0x0ffffffc;
40 pState->r[3] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 12 ) & 0x0ffffffc;
41
42 pState->s[0] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 16 );
43 pState->s[1] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 20 );
44 pState->s[2] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 24 );
45 pState->s[3] = SYMCRYPT_LOAD_LSBFIRST32( pbKey + 28 );
46
47 // Set accumulator to zero
48 SymCryptWipeKnownSize( &pState->a[0], sizeof( pState->a ) );
49
50 pState->bytesInBuffer = 0;
51}

Referenced by SymCryptChaCha20Poly1305Decrypt(), SymCryptChaCha20Poly1305Encrypt(), and SymCryptPoly1305().

◆ SymCryptPoly1305Result()

VOID SYMCRYPT_CALL SymCryptPoly1305Result ( _Inout_ PSYMCRYPT_POLY1305_STATE  pState,
_Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 109 of file poly1305.c.

112{
113 SIZE_T bytesInBuffer;
114 UINT64 t;
115 UINT32 a4, a3, a2, a1, a0;
116 UINT32 maskOld, maskNew;
117
118 bytesInBuffer = pState->bytesInBuffer;
119 if( bytesInBuffer > 0 )
120 {
121 // Add trailing '1' byte and pad with zeroes
122 // Wipe function deals with 0-length wipes properly
123 pState->buf[bytesInBuffer++] = 1;
124 SymCryptWipe( &pState->buf[bytesInBuffer], 16 - bytesInBuffer );
125
126 // Now we have to process the block, but the block function adds a trailing
127 // 1 byte to each 16-byte block. We compensate for that by decrementing
128 // the highest word of the accumulator first; the 1 byte added by the block
129 // processing function has the effect of incrementing the highest accumulator
130 // word so those two operations cancel each other out.
131 pState->a[4] -= 1;
132 SymCryptPoly1305ProcessBlocks( pState, pState->buf, 16 );
133 }
134
135 // We have to fully reduce the accumulator first
136 // We have a[4]<6 at this point
137 a0 = pState->a[0];
138 a1 = pState->a[1];
139 a2 = pState->a[2];
140 a3 = pState->a[3];
141 a4 = pState->a[4];
142
143 SYMCRYPT_ASSERT( a4 < 6 );
144 // Because a4 < 6, we have to subtract either 0*P or 1*P
145 // we subtract P and them mux-choose between the new and old value
146 // Subtracting P is the same as subtracting 2^130 and adding 5
147 t = 5;
148
149 t += a0;
150 a0 = (UINT32) t;
151 t >>= 32;
152
153 t += a1;
154 a1 = (UINT32) t;
155 t >>= 32;
156
157 t += a2;
158 a2 = (UINT32) t;
159 t >>= 32;
160
161 t += a3;
162 a3 = (UINT32) t;
163 t >>= 32;
164
165 t += a4;
166 t -= 4;
167 a4 = (UINT32) t;
168 t >>= 32;
169
170 // If this subtraction produced a carry, then t = 0xffffffff, otherwise it is 0
171 maskOld = (UINT32) t; // ffffffff if the old value is correct, 0 otherwise
172 maskNew = ~maskOld; // ffffffff if the new value is correct, 0 otherwise
173
174 a0 = (maskNew & a0) | (maskOld & pState->a[0]);
175 a1 = (maskNew & a1) | (maskOld & pState->a[1]);
176 a2 = (maskNew & a2) | (maskOld & pState->a[2]);
177 a3 = (maskNew & a3) | (maskOld & pState->a[3]);
178 // a4 = (maskNew & a4) | (maskOld & pState->a[4]); // We don't need a4...
179
180 // Now we add S and return the data
181 t = a0;
182 t += pState->s[0];
183 SYMCRYPT_STORE_LSBFIRST32( pbResult + 0, (UINT32) t );
184 t >>= 32;
185
186 t += a1;
187 t += pState->s[1];
188 SYMCRYPT_STORE_LSBFIRST32( pbResult + 4, (UINT32) t );
189 t >>= 32;
190
191 t += a2;
192 t += pState->s[2];
193 SYMCRYPT_STORE_LSBFIRST32( pbResult + 8, (UINT32) t );
194 t >>= 32;
195
196 t += a3;
197 t += pState->s[3];
198 SYMCRYPT_STORE_LSBFIRST32( pbResult + 12, (UINT32) t );
199
200 SymCryptWipeKnownSize( (PBYTE) pState, sizeof( *pState ) );
201}
a1
static const struct update_accum a1
Definition: msg.c:534
a2
static const struct update_accum a2
Definition: msg.c:542
a3
static const struct update_accum a3
Definition: msg.c:556
a4
static const struct update_accum a4
Definition: msg.c:2188

Referenced by SymCryptChaCha20Poly1305ComputeTag(), and SymCryptPoly1305().

◆ SymCryptPoly1305Selftest()

VOID SYMCRYPT_CALL SymCryptPoly1305Selftest ( void  )

Definition at line 456 of file poly1305.c.

457{
458 BYTE res[16];
459
460 SymCryptPoly1305( SymCryptTestKey32, SymCryptTestMsg16, 16, res );
461
462 SymCryptInjectError( res, sizeof( res ) );
463
464 if( memcmp( res, poly1305Kat, sizeof( res ) ) != 0 )
465 {
466 SymCryptFatal( 'p135');
467 }
468}
poly1305Kat
static const BYTE poly1305Kat[16]
Definition: poly1305.c:449
SymCryptPoly1305
VOID SYMCRYPT_CALL SymCryptPoly1305(_In_reads_(SYMCRYPT_POLY1305_KEY_SIZE) PCBYTE pbKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_POLY1305_RESULT_SIZE) PBYTE pbResult)
Definition: poly1305.c:18

◆ SymCryptProvideEntropy()

VOID SYMCRYPT_CALL SymCryptProvideEntropy ( _In_reads_(cbEntropy) PCBYTE  pbEntropy,
SIZE_T  cbEntropy 
)

◆ SymCryptRandom()

VOID SYMCRYPT_CALL SymCryptRandom ( _Out_writes_(cbRandom) PBYTE  pbRandom,
SIZE_T  cbRandom 
)

◆ SymCryptRc2Decrypt()

VOID SYMCRYPT_CALL SymCryptRc2Decrypt ( _In_ PCSYMCRYPT_RC2_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_RC2_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_RC2_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 330 of file rc2.c.

334{
335 UINT16 R0, R1, R2, R3;
336 PCUINT16 K;
337
338 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
339
340 //
341 // 1. Initialize words R[0], ..., R[3] to contain the 64-bit plaintext value.
342 //
343 R0 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[0] );
344 R1 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[2] );
345 R2 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[4] );
346 R3 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[6] );
347
348 //
349 // 2. Expand the key, so that words K[0], ..., K[63] become defined.
350 // (In our case the key was previously expanded, so we just grab the pointer to it.)
351 //
352 K = pExpandedKey->K;
353
354 //
355 // 3. Initialize j to 63.
356 //
357
358 //
359 // 4. Perform five r-mixing rounds.
360 //
361 RMIXROUND(15);
362 RMIXROUND(14);
363 RMIXROUND(13);
364 RMIXROUND(12);
365 RMIXROUND(11);
366
367 //
368 // 5. Perform one r-mashing round.
369 //
370 RMASHROUND();
371
372 //
373 // 6. Perform six r-mixing rounds.
374 //
375 RMIXROUND(10);
376 RMIXROUND(9);
377 RMIXROUND(8);
378 RMIXROUND(7);
379 RMIXROUND(6);
380 RMIXROUND(5);
381
382 //
383 // 7. Perform one r-mashing round.
384 //
385 RMASHROUND();
386
387 //
388 // 8. Perform five r-mixing rounds.
389 //
390 RMIXROUND(4);
391 RMIXROUND(3);
392 RMIXROUND(2);
393 RMIXROUND(1);
394 RMIXROUND(0);
395
396 SYMCRYPT_STORE_LSBFIRST16( &pbDst[0], R0 );
397 SYMCRYPT_STORE_LSBFIRST16( &pbDst[2], R1 );
398 SYMCRYPT_STORE_LSBFIRST16( &pbDst[4], R2 );
399 SYMCRYPT_STORE_LSBFIRST16( &pbDst[6], R3 );
400
401}
RMIXROUND
#define RMIXROUND(n)
Definition: rc2.c:308
RMASHROUND
#define RMASHROUND()
Definition: rc2.c:319
R1
#define R1(v, w, x, y, z, i)
Definition: sha1.c:36
R2
#define R2(v, w, x, y, z, i)
Definition: sha1.c:37
R0
#define R0(v, w, x, y, z, i)
Definition: sha1.c:35
R3
#define R3(v, w, x, y, z, i)
Definition: sha1.c:38
SYMCRYPT_STORE_LSBFIRST16
#define SYMCRYPT_STORE_LSBFIRST16(p, v)
Definition: symcrypt.h:306
PCUINT16
const UINT16 * PCUINT16
Definition: symcrypt_internal.h:251

Referenced by decrypt_block_impl(), and SymCryptRc2Selftest().

◆ SymCryptRc2Encrypt()

VOID SYMCRYPT_CALL SymCryptRc2Encrypt ( _In_ PCSYMCRYPT_RC2_EXPANDED_KEY  pExpandedKey,
_In_reads_(SYMCRYPT_RC2_BLOCK_SIZE) PCBYTE  pbSrc,
_Out_writes_(SYMCRYPT_RC2_BLOCK_SIZE) PBYTE  pbDst 
)

Definition at line 234 of file rc2.c.

238{
239 UINT16 R0, R1, R2, R3;
240 PCUINT16 K;
241
242 SYMCRYPT_CHECK_MAGIC( pExpandedKey );
243
244 //
245 // 1. Initialize words R[0], ..., R[3] to contain the 64-bit plaintext value.
246 //
247 R0 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[0] );
248 R1 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[2] );
249 R2 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[4] );
250 R3 = SYMCRYPT_LOAD_LSBFIRST16( &pbSrc[6] );
251
252 //
253 // 2. Expand the key, so that words K[0], ..., K[63] become defined.
254 // (In our case the key was previously expanded, so we just grab the pointer to it.)
255 //
256 K = pExpandedKey->K;
257
258 //
259 // 3. Initialize j to zero.
260 //
261
262 //
263 // 4. Perform five mixing rounds.
264 //
265 MIXROUND(0);
266 MIXROUND(1);
267 MIXROUND(2);
268 MIXROUND(3);
269 MIXROUND(4);
270
271 //
272 // 5. Perform one mashing round.
273 //
274 MASHROUND();
275
276 //
277 // 6. Perform six mixing rounds.
278 //
279 MIXROUND(5);
280 MIXROUND(6);
281 MIXROUND(7);
282 MIXROUND(8);
283 MIXROUND(9);
284 MIXROUND(10);
285
286 //
287 // 7. Perform one mashing round.
288 //
289 MASHROUND();
290
291 //
292 // 8. Perform five mixing rounds.
293 //
294 MIXROUND(11);
295 MIXROUND(12);
296 MIXROUND(13);
297 MIXROUND(14);
298 MIXROUND(15);
299
300 SYMCRYPT_STORE_LSBFIRST16( &pbDst[0], R0 );
301 SYMCRYPT_STORE_LSBFIRST16( &pbDst[2], R1 );
302 SYMCRYPT_STORE_LSBFIRST16( &pbDst[4], R2 );
303 SYMCRYPT_STORE_LSBFIRST16( &pbDst[6], R3 );
304
305}
MIXROUND
#define MIXROUND(n)
Definition: rc2.c:214
MASHROUND
#define MASHROUND()
Definition: rc2.c:225

Referenced by encrypt_block_impl(), and SymCryptRc2Selftest().

◆ SymCryptRc2ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc2ExpandKey ( _Out_ PSYMCRYPT_RC2_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 205 of file rc2.c.

209{
210 return SymCryptRc2ExpandKeyEx( pExpandedKey, pbKey, cbKey, (UINT32) (8*cbKey) );
211}
SymCryptRc2ExpandKeyEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc2ExpandKeyEx(_Out_ PSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, UINT32 effectiveKeySizeInBits)
Definition: rc2.c:129

◆ SymCryptRc2ExpandKeyEx()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc2ExpandKeyEx ( _Out_ PSYMCRYPT_RC2_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
UINT32  effectiveKeySizeInBits 
)

Definition at line 129 of file rc2.c.

134{
135 SYMCRYPT_ALIGN BYTE L[128];
136 UINT32 T;
137 UINT32 T1;
138 UINT32 T8;
139 UINT32 TM;
140 int i;
141
142 SYMCRYPT_SET_MAGIC( pExpandedKey );
143
144 //
145 // According to RFC 2268 any key size in 1..128 is allowed.
146 //
147 // The effective key size cannot be 0 as the RFC specs would lead to a buffer overflow
148 // in the key expansion.
149 //
150 // If the effective key size <= 8 then T8=1 and the key expansion backward recursion
151 // drops into a fixed point because L[i+1] xor L[i+T8] is zero.
152 // Therefore, we require an effective key size of at least 9.
153 //
154 if( cbKey < 1 || cbKey > 128 || effectiveKeySizeInBits < 9 || effectiveKeySizeInBits > 8*128 )
155 {
156 return SYMCRYPT_WRONG_KEY_SIZE;
157 }
158
159 T = (UINT32)cbKey; // 1 <= T1 <= 128
160
161 T1 = effectiveKeySizeInBits; // 9 <= T1 <= 1024
162 T8 = (T1+7)/8; // 2 <= T8 <= 128
163
164 TM = 255 & ((1 << (8 + (UINT32)T1 - 8*T8))-1);
165
166 //
167 // To be endian-agnostic our expanded key is stored as an array of UINT16s. We do the key
168 // expansion in a local buffer and copy the values into the expanded key using the proper conversion.
169 //
170 memcpy(L, pbKey, T);
171
172 for(i = T; i <= 127; i++)
173 {
174 L[i] = PITABLE[(L[i-1]+L[i-T]) & 0xff];
175 //
176 // If the key size T=1 then we lose one bit of key space in the key expansion because
177 // L[i-1] == L[i-T] which makes the index to PITABLE even. So L[1..128] depend only on
178 // 7 bits.
179 //
180 }
181
182 L[128-T8] = PITABLE[L[128-T8] & TM];
183
184 for( i = 127-T8; i >=0; i--)
185 {
186 L[i] = PITABLE[L[i+1] ^ L[i+T8]];
187 }
188
189 //
190 // Now we copy the result into the UINT16 array in our expanded key.
191 // This is a memcpy for little-endian platforms, but this code works on all CPUs.
192 //
193 for( i=0; i<64; i++ )
194 {
195 pExpandedKey->K[i] = SYMCRYPT_LOAD_LSBFIRST16( &L[2*i] );
196 }
197
198 SymCryptWipeKnownSize( L, sizeof( L ) );
199
200 return SYMCRYPT_NO_ERROR;
201}
PITABLE
static const BYTE PITABLE[]
Definition: rc2.c:40
T
#define T(num)
Definition: thunks.c:311

Referenced by setup_key_impl(), SymCryptRc2ExpandKey(), and SymCryptRc2Selftest().

◆ SymCryptRc2Selftest()

VOID SYMCRYPT_CALL SymCryptRc2Selftest ( void  )

Definition at line 410 of file rc2.c.

411{
412 SYMCRYPT_RC2_EXPANDED_KEY key;
413 BYTE buf[SYMCRYPT_RC2_BLOCK_SIZE];
414
415 if( SymCryptRc2ExpandKeyEx( &key, SymCryptTestKey32, 16, 87) != SYMCRYPT_NO_ERROR )
416 {
417 SymCryptFatal( 'rc21' );
418 }
419
420 SymCryptRc2Encrypt( &key, testPlaintext, buf );
421
422 SymCryptInjectError( buf, SYMCRYPT_RC2_BLOCK_SIZE );
423
424 if( memcmp( buf, testCiphertext, SYMCRYPT_RC2_BLOCK_SIZE ) != 0 )
425 {
426 SymCryptFatal( 'rc22' );
427 }
428
429 SymCryptRc2Decrypt( &key, testCiphertext, buf );
430
431 SymCryptInjectError( buf, SYMCRYPT_RC2_BLOCK_SIZE );
432
433 if( memcmp( buf, testPlaintext, SYMCRYPT_RC2_BLOCK_SIZE ) != 0 )
434 {
435 SymCryptFatal( 'rc23' );
436 }
437
438}
testCiphertext
static const BYTE testCiphertext[8]
Definition: rc2.c:404
SymCryptRc2Decrypt
VOID SYMCRYPT_CALL SymCryptRc2Decrypt(_In_ PCSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_RC2_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_RC2_BLOCK_SIZE) PBYTE pbDst)
Definition: rc2.c:330
testPlaintext
static const BYTE testPlaintext[8]
Definition: rc2.c:403
SymCryptRc2Encrypt
VOID SYMCRYPT_CALL SymCryptRc2Encrypt(_In_ PCSYMCRYPT_RC2_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_RC2_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_RC2_BLOCK_SIZE) PBYTE pbDst)
Definition: rc2.c:234
SYMCRYPT_RC2_BLOCK_SIZE
#define SYMCRYPT_RC2_BLOCK_SIZE
Definition: symcrypt.h:4543
SYMCRYPT_RC2_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_RC2_EXPANDED_KEY
Definition: symcrypt_internal.h:1815

◆ SymCryptRc4Crypt()

VOID SYMCRYPT_CALL SymCryptRc4Crypt ( _Inout_ PSYMCRYPT_RC4_STATE  pState,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
_In_ SIZE_T  cbData 
)

Definition at line 82 of file rc4.c.

87{
88 SIZE_T i;
89 SIZE_T j;
90 SYMCRYPT_RC4_S_TYPE Ti;
91 SYMCRYPT_RC4_S_TYPE Tj;
92 PCBYTE pbSrcEnd = pbSrc + cbData;
93
94 SYMCRYPT_CHECK_MAGIC( pState );
95
96 i = pState->i;
97 j = pState->j;
98
99 //
100 // I tried to unroll this loop 4x and use a single 32-bit operation to XOR the key
101 // stream with the data. This actually makes the code slower by 1 c/B on a Core 2.
102 // I suspect that that is because the instruction decoders are the bottleneck, and
103 // a small loop can be run out of the uop queue which bypasses the instruction decoders.
104 // A larger loop has to be decoded every time, and that slows things down.
105 // The theoretical gain of unrolling the loop is less than 1 c/B,
106 // and as Core 2 and derived CPUs are the most commonly used CPUs by our customers,
107 // it is not worthwhile to persue this further.
108 //
109 // - Niels Ferguson (niels) 2010-10-11
110 //
111
112 while( pbSrc < pbSrcEnd )
113 {
114 //
115 // Our i value is already incremented
116 //
117 Ti = pState->S[i];
118 j = (j + Ti ) & 0xff;
119 Tj = pState->S[j];
120 pState->S[i] = Tj;
121 pState->S[j] = Ti;
122 *pbDst = (BYTE) (*pbSrc ^ pState->S[(Ti + Tj) & 0xff]);
123
124 i = (i + 1) & 0xff;
125
126 pbSrc++;
127 pbDst++;
128 }
129
130 pState->i = (BYTE) i;
131 pState->j = (BYTE) j;
132}
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
SYMCRYPT_RC4_S_TYPE
BYTE SYMCRYPT_RC4_S_TYPE
Definition: symcrypt_internal.h:2107

Referenced by encrypt_stream_impl(), and SymCryptRc4Selftest().

◆ SymCryptRc4Init()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc4Init ( _Out_ PSYMCRYPT_RC4_STATE  pState,
_In_reads_(cbKey) PCBYTE  pbKey,
_In_ SIZE_T  cbKey 
)

Definition at line 15 of file rc4.c.

19{
20 SIZE_T i;
21 SIZE_T j;
22 BYTE keyBuf[256];
23 SIZE_T keyIdx;
24
25 SYMCRYPT_RC4_S_TYPE T;
26
27 if( cbKey > 256 || cbKey == 0 )
28 {
29 return SYMCRYPT_WRONG_KEY_SIZE;
30 }
31
32 //
33 // Make a copy of the key to obey the read-once rule.
34 // This is a case where it looks safe to break the read-once
35 // rule, but it isn't. RC4 with very long keys (e.g. 256 bytes)
36 // is actually very vulnerable against related-key attacks.
37 // One obvious precaution is to limit the length of the RC4 key,
38 // which one of the layers above us might do.
39 // Allowing the key bytes to change as we read them negates
40 // this countermeasure.
41 //
42 memcpy( keyBuf, pbKey, cbKey );
43
44 for( i=0; i<256; i++ )
45 {
46 pState->S[i] = (SYMCRYPT_RC4_S_TYPE) i;
47 }
48
49 j = 0;
50 keyIdx = 0;
51 for( i=0; i<256; i++ )
52 {
53
54 T = pState->S[i];
55 j = (j + T + keyBuf[keyIdx]) & 0xff;
56 pState->S[i] = pState->S[j];
57 pState->S[j] = T;
58 keyIdx++;
59 if( keyIdx == cbKey )
60 {
61 keyIdx = 0;
62 }
63 }
64
65 //
66 // We store the i value already incremented for the next byte.
67 // This seems to allow better instruction sequencing interleaving in the actual en/decrypt loop
68 //
69 pState->i = 1;
70 pState->j = 0;
71
72 SYMCRYPT_SET_MAGIC( pState );
73
74 SymCryptWipe( keyBuf, cbKey );
75
76 return SYMCRYPT_NO_ERROR;
77}

Referenced by setup_key_impl(), and SymCryptRc4Selftest().

◆ SymCryptRc4Selftest()

VOID SYMCRYPT_CALL SymCryptRc4Selftest ( void  )

Definition at line 140 of file rc4.c.

141{
142 BYTE buf[3];
143 SYMCRYPT_RC4_STATE state;
144
145 SymCryptRc4Init( &state, SymCryptTestKey32, sizeof( SymCryptTestKey32 ) );
146
147 SymCryptRc4Crypt( &state, SymCryptTestMsg3, buf, sizeof( buf ) );
148
149 SymCryptInjectError( buf, sizeof( buf ) );
150
151 if( memcmp( buf, rc4KatAnswer, sizeof( buf )) != 0 )
152 {
153 SymCryptFatal( 'rc4 ' );
154 }
155
156}
SymCryptRc4Crypt
VOID SYMCRYPT_CALL SymCryptRc4Crypt(_Inout_ PSYMCRYPT_RC4_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, _In_ SIZE_T cbData)
Definition: rc4.c:82
SymCryptRc4Init
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRc4Init(_Out_ PSYMCRYPT_RC4_STATE pState, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey)
Definition: rc4.c:15
rc4KatAnswer
static const BYTE rc4KatAnswer[3]
Definition: rc4.c:135
SYMCRYPT_RC4_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_RC4_STATE
Definition: symcrypt_internal.h:2114

◆ SymCryptRngAesFips140_2Generate()

VOID SYMCRYPT_CALL SymCryptRngAesFips140_2Generate ( _Inout_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE  pRngState,
_Out_writes_(cbRandom) PBYTE  pbRandom,
SIZE_T  cbRandom 
)

◆ SymCryptRngAesFips140_2Instantiate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesFips140_2Instantiate ( _Out_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE  pRngState,
_In_reads_(cbSeedMaterial) PCBYTE  pcbSeedMaterial,
_In_range_(SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T  cbSeedMaterial 
)

◆ SymCryptRngAesFips140_2Reseed()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesFips140_2Reseed ( _Inout_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE  pRngState,
_In_reads_(cbSeedMaterial) PCBYTE  pcbSeedMaterial,
_In_range_(SYMCRYPT_RNG_AES_MIN_RESEED_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T  cbSeedMaterial 
)

◆ SymCryptRngAesFips140_2Uninstantiate()

VOID SYMCRYPT_CALL SymCryptRngAesFips140_2Uninstantiate ( _Inout_ PSYMCRYPT_RNG_AES_FIPS140_2_STATE  pRngState)

◆ SymCryptRngAesGenerate()

VOID SYMCRYPT_CALL SymCryptRngAesGenerate ( _Inout_ PSYMCRYPT_RNG_AES_STATE  pRngState,
_Out_writes_(cbRandom) PBYTE  pbRandom,
SIZE_T  cbRandom 
)

◆ SymCryptRngAesGenerateSelftest()

VOID SYMCRYPT_CALL SymCryptRngAesGenerateSelftest ( void  )

Definition at line 918 of file aesCtrDrbg.c.

919{
920 SYMCRYPT_RNG_AES_STATE rng;
921
922 SymCryptRngAesTestGenerate( &rng );
923
924 //
925 // Uninstantiate has to be tested whenever another function is tested.
926 //
927 SymCryptRngAesTestUninstantiate( &rng );
928}
SymCryptRngAesTestGenerate
VOID SYMCRYPT_CALL SymCryptRngAesTestGenerate(PSYMCRYPT_RNG_AES_STATE pRngState)
Definition: aesCtrDrbg.c:800
SymCryptRngAesTestUninstantiate
VOID SYMCRYPT_CALL SymCryptRngAesTestUninstantiate(PSYMCRYPT_RNG_AES_STATE pRngState)
Definition: aesCtrDrbg.c:864
SYMCRYPT_RNG_AES_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_RNG_AES_STATE
Definition: symcrypt_internal.h:2143

◆ SymCryptRngAesInstantiate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesInstantiate ( _Out_ PSYMCRYPT_RNG_AES_STATE  pRngState,
_In_reads_(cbSeedMaterial) PCBYTE  pcbSeedMaterial,
_In_range_(SYMCRYPT_RNG_AES_MIN_INSTANTIATE_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T  cbSeedMaterial 
)

◆ SymCryptRngAesInstantiateSelftest()

VOID SYMCRYPT_CALL SymCryptRngAesInstantiateSelftest ( void  )

Definition at line 890 of file aesCtrDrbg.c.

891{
892 SYMCRYPT_RNG_AES_STATE rng;
893
894 SymCryptRngAesTestInstantiate( &rng );
895
896 //
897 // Uninstantiate has to be tested whenever another function is tested.
898 //
899 SymCryptRngAesTestUninstantiate( &rng );
900}
SymCryptRngAesTestInstantiate
VOID SYMCRYPT_CALL SymCryptRngAesTestInstantiate(PSYMCRYPT_RNG_AES_STATE pRngState)
Definition: aesCtrDrbg.c:727

◆ SymCryptRngAesReseed()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRngAesReseed ( _Inout_ PSYMCRYPT_RNG_AES_STATE  pRngState,
_In_reads_(cbSeedMaterial) PCBYTE  pcbSeedMaterial,
_In_range_(SYMCRYPT_RNG_AES_MIN_RESEED_SIZE, SYMCRYPT_RNG_AES_MAX_SEED_SIZE) SIZE_T  cbSeedMaterial 
)

◆ SymCryptRngAesReseedSelftest()

VOID SYMCRYPT_CALL SymCryptRngAesReseedSelftest ( void  )

Definition at line 904 of file aesCtrDrbg.c.

905{
906 SYMCRYPT_RNG_AES_STATE rng;
907
908 SymCryptRngAesTestReseed( &rng );
909
910 //
911 // Uninstantiate has to be tested whenever another function is tested.
912 //
913 SymCryptRngAesTestUninstantiate( &rng );
914}
SymCryptRngAesTestReseed
VOID SYMCRYPT_CALL SymCryptRngAesTestReseed(PSYMCRYPT_RNG_AES_STATE pRngState)
Definition: aesCtrDrbg.c:763

◆ SymCryptRngAesUninstantiate()

VOID SYMCRYPT_CALL SymCryptRngAesUninstantiate ( _Inout_ PSYMCRYPT_RNG_AES_STATE  pRngState)

◆ SymCryptRsakeyAllocate()

PSYMCRYPT_RSAKEY SYMCRYPT_CALL SymCryptRsakeyAllocate ( _In_ PCSYMCRYPT_RSA_PARAMS  pParams,
_In_ UINT32  flags 
)

Definition at line 13 of file rsakey.c.

16{
17 PVOID p;
18 SIZE_T cb;
19 PSYMCRYPT_RSAKEY res = NULL;
20
21 UNREFERENCED_PARAMETER( flags );
22
23 SYMCRYPT_ASSERT( pParams != NULL );
24
25 cb = SymCryptSizeofRsakeyFromParams( pParams );
26
27 p = SymCryptCallbackAlloc( cb );
28
29 if ( p==NULL )
30 {
31 goto cleanup;
32 }
33
34 res = SymCryptRsakeyCreate( p, cb, pParams );
35
36cleanup:
37 return res;
38}
SymCryptRsakeyCreate
PSYMCRYPT_RSAKEY SYMCRYPT_CALL SymCryptRsakeyCreate(_Out_writes_bytes_(cbBuffer) PBYTE pbBuffer, SIZE_T cbBuffer, _In_ PCSYMCRYPT_RSA_PARAMS pParams)
Definition: rsakey.c:83
SymCryptSizeofRsakeyFromParams
UINT32 SYMCRYPT_CALL SymCryptSizeofRsakeyFromParams(_In_ PCSYMCRYPT_RSA_PARAMS pParams)
Definition: rsakey.c:51
PSYMCRYPT_RSAKEY
SYMCRYPT_RSAKEY * PSYMCRYPT_RSAKEY
Definition: symcrypt_internal.h:2757

Referenced by alloc_rsa_key().

◆ SymCryptRsakeyCreate()

PSYMCRYPT_RSAKEY SYMCRYPT_CALL SymCryptRsakeyCreate ( _Out_writes_bytes_(cbBuffer) PBYTE  pbBuffer,
SIZE_T  cbBuffer,
_In_ PCSYMCRYPT_RSA_PARAMS  pParams 
)

Definition at line 83 of file rsakey.c.

87{
88 PSYMCRYPT_RSAKEY pkObj = NULL;
89
90 PBYTE pbCurr = pbBuffer;
91 SIZE_T cbNeeded;
92 SIZE_T itemSize;
93
94 SYMCRYPT_ASSERT( pParams != NULL );
95
96 cbNeeded = SymCryptSizeofRsakeyFromParams( pParams );
97
98 SYMCRYPT_ASSERT_ASYM_ALIGNED( pbCurr );
99
100 if (( cbBuffer < cbNeeded ) ||
101 ( pParams->nBitsOfModulus < SYMCRYPT_RSAKEY_MIN_BITSIZE_MODULUS ) ||
102 ( pParams->nBitsOfModulus > SYMCRYPT_RSAKEY_MAX_BITSIZE_MODULUS ) ||
103 ( pParams->nPubExp < 1 ) ||
104 ( pParams->nPubExp > SYMCRYPT_RSAKEY_MAX_NUMOF_PUBEXPS ) ||
105 ( pParams->nPrimes == 1 ) ||
106 ( pParams->nPrimes > SYMCRYPT_RSAKEY_MAX_NUMOF_PRIMES ) )
107 {
108 goto cleanup;
109 }
110 SYMCRYPT_ASSERT( cbBuffer >= sizeof( SYMCRYPT_RSAKEY ) );
111
112 pkObj = (PSYMCRYPT_RSAKEY) pbCurr;
113
114 // Set all the parameters to 0
115 SymCryptWipe( pbBuffer, cbBuffer );
116
117 // Main parameters of the RSAKEY
118 // Everything is 0 until created
119
120 pkObj->cbTotalSize = (UINT32) cbNeeded;
121 // The result should always be within 4 GB, but we check to avoid security bugs
122 SYMCRYPT_ASSERT( pkObj->cbTotalSize == cbNeeded );
123
124 pkObj->hasPrivateKey = FALSE;
125
126 pkObj->nSetBitsOfModulus = pParams->nBitsOfModulus;
127 pkObj->nDigitsOfModulus = SymCryptDigitsFromBits( pkObj->nSetBitsOfModulus ); // The modulus object has always this number of digits
128
129 pkObj->nPrimes = pParams->nPrimes;
130 pkObj->nPubExp = pParams->nPubExp;
131
132 pbCurr += sizeof( SYMCRYPT_RSAKEY );
133
134 // Modulus
135 itemSize = SymCryptSizeofModulusFromDigits( pkObj->nDigitsOfModulus );
136 SYMCRYPT_ASSERT( cbBuffer >= sizeof( SYMCRYPT_RSAKEY ) + itemSize
137 + (pkObj->nPrimes*SymCryptSizeofModulusFromDigits( pkObj->nDigitsOfModulus ))
138 + (pkObj->nPrimes*SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS( pParams->nBitsOfModulus ))
139 + (pkObj->nPubExp*SymCryptSizeofIntFromDigits( pkObj->nDigitsOfModulus ))
140 + (pkObj->nPubExp*pkObj->nPrimes*SymCryptSizeofIntFromDigits( pkObj->nDigitsOfModulus )) );
141 pkObj->pmModulus = SymCryptModulusCreate(
142 pbCurr,
143 itemSize,
144 pkObj->nDigitsOfModulus );
145 SYMCRYPT_ASSERT( pkObj->pmModulus != NULL );
146 pbCurr += itemSize;
147
148 // For the remaining objects
149 // defer creation until SymCryptRsakeyGenerate or
150 // SymCryptRsakeySetValue
151
152 // Primes
153 for (UINT32 i=0; i<pkObj->nPrimes; i++)
154 {
155 pkObj->pbPrimes[i] = pbCurr;
156 pbCurr += SymCryptSizeofModulusFromDigits( pkObj->nDigitsOfModulus );
157 }
158
159 // CRT Inverses of primes
160 for (UINT32 i=0; i<pkObj->nPrimes; i++)
161 {
162 pkObj->pbCrtInverses[i] = pbCurr;
163 pbCurr += SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS( pParams->nBitsOfModulus );
164 }
165
166 // Private exponents
167 for (UINT32 i=0; i<pkObj->nPubExp; i++)
168 {
169 pkObj->pbPrivExps[i] = pbCurr;
170 pbCurr += SymCryptSizeofIntFromDigits( pkObj->nDigitsOfModulus );
171 }
172
173 // Private exponents modulo each prime (minus 1)
174 for (UINT32 i=0; i<pkObj->nPubExp*pkObj->nPrimes; i++)
175 {
176 pkObj->pbCrtPrivExps[i] = pbCurr;
177 pbCurr += SymCryptSizeofIntFromDigits( pkObj->nDigitsOfModulus );
178 }
179
180 // Setting the magic
181 SYMCRYPT_SET_MAGIC( pkObj );
182
183cleanup:
184 return pkObj;
185}
SYMCRYPT_RSAKEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_RSAKEY
Definition: symcrypt_internal.h:2756
SYMCRYPT_RSAKEY_MAX_NUMOF_PRIMES
#define SYMCRYPT_RSAKEY_MAX_NUMOF_PRIMES
Definition: symcrypt_internal.h:2691
SYMCRYPT_RSAKEY_MAX_BITSIZE_MODULUS
#define SYMCRYPT_RSAKEY_MAX_BITSIZE_MODULUS
Definition: symcrypt_internal.h:2695
SYMCRYPT_RSAKEY_MAX_NUMOF_PUBEXPS
#define SYMCRYPT_RSAKEY_MAX_NUMOF_PUBEXPS
Definition: symcrypt_internal.h:2692
SYMCRYPT_RSAKEY_MIN_BITSIZE_MODULUS
#define SYMCRYPT_RSAKEY_MIN_BITSIZE_MODULUS
Definition: symcrypt_internal.h:2694

Referenced by SymCryptRsakeyAllocate().

◆ SymCryptRsakeyExtendKeyUsage()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyExtendKeyUsage ( _Inout_ PSYMCRYPT_RSAKEY  pkRsakey,
UINT32  flags 
)

Definition at line 1611 of file rsakey.c.

1614{
1615 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1616
1617 // Ensure caller has specified what algorithm(s) the key will be used with
1618 UINT32 algorithmFlags = SYMCRYPT_FLAG_RSAKEY_SIGN | SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
1619
1620 if ( ( ( flags & ~algorithmFlags ) != 0 ) ||
1621 ( ( flags & algorithmFlags ) == 0) )
1622 {
1623 scError = SYMCRYPT_INVALID_ARGUMENT;
1624 goto cleanup;
1625 }
1626
1627 pkRsakey->fAlgorithmInfo |= flags;
1628
1629cleanup:
1630 return scError;
1631}
SYMCRYPT_FLAG_RSAKEY_SIGN
#define SYMCRYPT_FLAG_RSAKEY_SIGN
Definition: symcrypt.h:7598
SYMCRYPT_FLAG_RSAKEY_ENCRYPT
#define SYMCRYPT_FLAG_RSAKEY_ENCRYPT
Definition: symcrypt.h:7599

◆ SymCryptRsakeyFree()

VOID SYMCRYPT_CALL SymCryptRsakeyFree ( _Out_ PSYMCRYPT_RSAKEY  pkObj)

Definition at line 42 of file rsakey.c.

43{
44 SYMCRYPT_CHECK_MAGIC( pkObj );
45 SymCryptRsakeyWipe( pkObj );
46 SymCryptCallbackFree( pkObj );
47}
SymCryptRsakeyWipe
VOID SYMCRYPT_CALL SymCryptRsakeyWipe(_Out_ PSYMCRYPT_RSAKEY pkDst)
Definition: rsakey.c:189

Referenced by free_key_impl(), and new_key_impl().

◆ SymCryptRsakeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGenerate ( _Inout_ PSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_opt_(nPubExp) PCUINT64  pu64PubExp,
UINT32  nPubExp,
_In_ UINT32  flags 
)

Definition at line 514 of file rsakey.c.

519{
520 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
521
522 // 3 sizes of temporary elements:
523 // - ndPrimes = number of digit size of each prime (we choose it to be the same for all primes)
524 // - ndMod = pkRsakey->nDigitsOfModulus
525 // - ndLarge = ndPrimes + ndMod
526
527 UINT32 ndPrimes = 0;
528
529 UINT32 cbPrimes = 0;
530 PSYMCRYPT_INT piLow = NULL;
531 PSYMCRYPT_INT piHigh = NULL;
532
533 UINT32 cbDivisor = 0;
534 PSYMCRYPT_DIVISOR pdTmp = NULL;
535
536 UINT32 ndMod = pkRsakey->nDigitsOfModulus;
537 UINT32 cbMod = 0;
538 PSYMCRYPT_INT piPhi = NULL;
539
540 UINT32 ndLarge = 0;
541 UINT32 cbLarge = 0;
542 PSYMCRYPT_INT piAcc = NULL;
543
544 PBYTE pbScratch = NULL;
545 UINT32 cbScratch = 0;
546 PBYTE pbFnScratch = NULL;
547 UINT32 cbFnScratch = 0;
548
549 UINT32 maxTries = 0; // For the prime generation (and the modulus operations ?)
550 UINT32 primeBits = 0;
551
552 const UINT64 defaultExponent = RSA_DEFAULT_PUBLIC_EXPONENT;
553
554 // Ensure caller has specified what algorithm(s) the key will be used with
555 UINT32 algorithmFlags = SYMCRYPT_FLAG_RSAKEY_SIGN | SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
556 // Ensure only allowed flags are specified
557 UINT32 allowedFlags = SYMCRYPT_FLAG_KEY_NO_FIPS | algorithmFlags;
558
559 if ( ( ( flags & ~allowedFlags ) != 0 ) ||
560 ( ( flags & algorithmFlags ) == 0) )
561 {
562 scError = SYMCRYPT_INVALID_ARGUMENT;
563 goto cleanup;
564 }
565
566 // SymCryptRsaSignVerifyPct requires the generated key to be at least 496 bits to avoid fatal
567 // Require caller to specify NO_FIPS for up to 1024 bits as running FIPS tests on too-small keys
568 // does not make it FIPS certifiable and gives the wrong impression to callers
569 if ( ( (flags & SYMCRYPT_FLAG_KEY_NO_FIPS) == 0 ) &&
570 ( pkRsakey->nSetBitsOfModulus < SYMCRYPT_RSAKEY_FIPS_MIN_BITSIZE_MODULUS ) )
571 {
572 scError = SYMCRYPT_INVALID_ARGUMENT;
573 goto cleanup;
574 }
575
576 // Handle the default exponent case
577 if( pu64PubExp == NULL && nPubExp == 0 )
578 {
579 pu64PubExp = &defaultExponent;
580 nPubExp = 1;
581 }
582
583 // Make sure we have:
584 // - exactly 2 primes
585 // - the right number of public exponents
586 // - exactly 1 public exponent
587 if (pkRsakey->nPrimes != 2 || nPubExp != pkRsakey->nPubExp || nPubExp != 1 )
588 {
589 scError = SYMCRYPT_INVALID_ARGUMENT;
590 goto cleanup;
591 }
592
593 // Copy the public exponent into the key
594 pkRsakey->au64PubExp[0] = pu64PubExp[0];
595
596 // Before doing anything calculate all the needed sizes
597 // The size limits were checked in SymCryptRsakeyCreate which is the only way to create an Rsakey object.
598 pkRsakey->nBitsOfModulus = pkRsakey->nSetBitsOfModulus; // This will be the exact bit size of our modulus
599
600 pkRsakey->nBitsOfPrimes[0] = (pkRsakey->nBitsOfModulus + 1)/2;
601 pkRsakey->nBitsOfPrimes[1] = pkRsakey->nBitsOfModulus/2; // The second prime is one bit smaller for odd-length moduli
602
603 pkRsakey->nDigitsOfPrimes[0] = SymCryptDigitsFromBits(pkRsakey->nBitsOfPrimes[0]);
604 pkRsakey->nDigitsOfPrimes[1] = SymCryptDigitsFromBits(pkRsakey->nBitsOfPrimes[1]);
605
606 pkRsakey->nMaxDigitsOfPrimes = SYMCRYPT_MAX(pkRsakey->nDigitsOfPrimes[0], pkRsakey->nDigitsOfPrimes[1]);
607
608 ndPrimes = pkRsakey->nMaxDigitsOfPrimes;
609 ndLarge = ndPrimes + ndMod;
610
611 primeBits = SYMCRYPT_MAX(pkRsakey->nBitsOfPrimes[0],pkRsakey->nBitsOfPrimes[1]);
612 maxTries = 100 * primeBits;
613
614 // Create all the SymCryptObjects
615 SymCryptRsakeyCreateAllObjects( pkRsakey );
616
617 // Allocate the temp integers and the scratch space
618 // All sizes are limited by the modulus sizes verified in SymCryptRsakeyCreate
619 cbPrimes = SymCryptSizeofIntFromDigits( ndPrimes );
620 cbMod = SymCryptSizeofIntFromDigits( ndMod );
621 cbLarge = SymCryptSizeofIntFromDigits( ndLarge );
622 cbDivisor = SymCryptSizeofDivisorFromDigits( ndPrimes );
623
624 cbScratch = 2*cbPrimes + cbMod + cbLarge + cbDivisor +
625 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_INT_PRIME_GEN(ndPrimes),
626 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_MODULUS(ndMod),
627 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_INT_MUL(ndMod),
628 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_CRT_GENERATION(ndPrimes),
629 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_EXTENDED_GCD(ndMod),
630 SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_DIVISOR(ndPrimes),
631 SYMCRYPT_SCRATCH_BYTES_FOR_INT_DIVMOD( ndMod, ndPrimes )
632 ))))));
633
634 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
635 if (pbScratch == NULL)
636 {
637 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
638 goto cleanup;
639 }
640
641 pbFnScratch = pbScratch;
642 cbFnScratch = cbScratch;
643
644 // Create temporaries
645 // dcl - this would be easier to review with one statement per line
646 piLow = SymCryptIntCreate( pbFnScratch, cbPrimes, ndPrimes ); pbFnScratch += cbPrimes; cbFnScratch -= cbPrimes;
647 piHigh = SymCryptIntCreate( pbFnScratch, cbPrimes, ndPrimes ); pbFnScratch += cbPrimes; cbFnScratch -= cbPrimes;
648
649 piPhi = SymCryptIntCreate( pbFnScratch, cbMod, ndMod ); pbFnScratch += cbMod; cbFnScratch -= cbMod;
650
651 piAcc = SymCryptIntCreate( pbFnScratch, cbLarge, ndLarge ); pbFnScratch += cbLarge; cbFnScratch -= cbLarge;
652
653 pdTmp = SymCryptDivisorCreate( pbFnScratch, cbDivisor, ndPrimes ); pbFnScratch += cbDivisor; cbFnScratch -= cbDivisor;
654
655 // ***Prime generation limits***
656 //
657 // If nBitsOfModulus is even (main case)
658 // Low limit = 2^{primeBits-1} + 2^{primeBits - 2}
659 // High limit = 2^primeBits - 1
660 //
661 // If nBitsOfModulus is odd we use different
662 // limits for the two primes (until we have an integer sqrt function)
663 //
664 // For the first
665 // Low limit = 2^{primeBits-1} + 2^{primeBits - 2}
666 // High limit = 2^primeBits - 1
667 // For the second
668 // Low limit = 2^{primeBits-2} + 2^{primeBits - 3}
669 // High limit = 2^{primeBits-1} - 1
670 //
671 // Notice that nBitsOfModulus is a public value.
672 //
673 // *** TODO: This works only for 2 primes to give modulus
674 // of exactly nBitsOfModulus bits.
675
676 SymCryptIntSetValueUint32( 3, piLow );
677 SymCryptIntMulPow2( piLow, primeBits - 2, piLow );
678
679 SymCryptIntSetValueUint32( 1, piHigh );
680 SymCryptIntMulPow2( piHigh, primeBits, piHigh );
681 SymCryptIntSubUint32( piHigh, 1, piHigh );
682
683 // Generate primes and at the same time accumulate their product into piPhi
684 SymCryptIntSetValueUint32( 1, piPhi );
685 for (UINT32 i=0; i<pkRsakey->nPrimes; i++)
686 {
687 if ( ((pkRsakey->nBitsOfModulus % 2)==1) && (i>0) )
688 {
689 SymCryptIntDivPow2( piLow, 1, piLow );
690 SymCryptIntDivPow2( piHigh, 1, piHigh );
691 }
692
693 // IntGenerateRandomPrime requirement:
694 // piLow > 3 since nBitsOfModulus is bounded by
695 // SYMCRYPT_RSAKEY_MIN_BITSIZE_MODULUS.
696 scError = SymCryptIntGenerateRandomPrime(
697 piLow,
698 piHigh,
699 pu64PubExp,
700 nPubExp,
701 maxTries,
702 0,
703 SymCryptIntFromModulus( pkRsakey->pmPrimes[i] ),
704 pbFnScratch,
705 cbFnScratch);
706 if (scError!=SYMCRYPT_NO_ERROR)
707 {
708 goto cleanup;
709 }
710
711 // IntToModulus requirement:
712 // piLow > 0 --> pkRsakey->pmPrimes[i] > 0
713 SymCryptIntToModulus(
714 SymCryptIntFromModulus( pkRsakey->pmPrimes[i] ),
715 pkRsakey->pmPrimes[i],
716 pkRsakey->nBitsOfModulus, // Average number of operations
717 SYMCRYPT_FLAG_MODULUS_PARITY_PUBLIC | SYMCRYPT_FLAG_MODULUS_PRIME,
718 pbFnScratch,
719 cbFnScratch );
720
721 SymCryptIntMulMixedSize( SymCryptIntFromModulus( pkRsakey->pmPrimes[i] ), piPhi, piAcc, pbFnScratch, cbFnScratch ); // P_i * Product
722 scError = SymCryptIntCopyMixedSize( piAcc, piPhi ); // Move the result to piPhi
723 if (scError!=SYMCRYPT_NO_ERROR)
724 {
725 goto cleanup;
726 }
727 }
728
729 // IntToModulus requirement:
730 // piPhi product of non-zero primes --> piPhi > 0
731 SymCryptIntCopy( piPhi, SymCryptIntFromModulus( pkRsakey->pmModulus ) );
732 SymCryptIntToModulus(
733 SymCryptIntFromModulus( pkRsakey->pmModulus ),
734 pkRsakey->pmModulus,
735 pkRsakey->nBitsOfModulus, // Average number of operations
736 SYMCRYPT_FLAG_DATA_PUBLIC,
737 pbFnScratch,
738 cbFnScratch );
739
740 if ( SymCryptIntBitsizeOfValue( piPhi ) != pkRsakey->nBitsOfModulus)
741 {
742 scError = SYMCRYPT_EXTERNAL_FAILURE; // This should never happen (make it assert)
743 goto cleanup;
744 }
745
746 // Calculate the rest of the fields
747 scError = SymCryptRsakeyCalculatePrivateFields( pkRsakey, pdTmp, piPhi, piAcc, pbFnScratch, cbFnScratch, 0 );
748 if ( scError != SYMCRYPT_NO_ERROR )
749 {
750 goto cleanup;
751 }
752
753 pkRsakey->hasPrivateKey = TRUE;
754
755 pkRsakey->fAlgorithmInfo = flags; // We want to track all of the flags in the Rsakey
756
757 if ( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 )
758 {
759 // Ensure RSA algorithm selftest is run before first use of RSA algorithm
760 // Per FIPS 140-3 IG, this selftest cannot be a PCT
761 SYMCRYPT_RUN_SELFTEST_ONCE(
762 SymCryptRsaSelftest,
763 SYMCRYPT_SELFTEST_ALGORITHM_RSA);
764
765 // Run SignVerify PCT on generated keypair
766 // Our current understanding is that this PCT is sufficient for both RSA_SIGN and RSA_ENCRYPT
767
768 // Unconditionally set the sign flag to enable SignVerify PCT on encrypt-only keypair
769 pkRsakey->fAlgorithmInfo |= SYMCRYPT_FLAG_RSAKEY_SIGN;
770
771 SYMCRYPT_RUN_KEY_GEN_PCT(
772 SymCryptRsaSignVerifyPct,
773 pkRsakey,
774 SYMCRYPT_PCT_RSA_SIGN );
775
776 // Unset the sign flag before returning encrypt-only keypair
777 if ( ( flags & SYMCRYPT_FLAG_RSAKEY_SIGN ) == 0 )
778 {
779 pkRsakey->fAlgorithmInfo ^= SYMCRYPT_FLAG_RSAKEY_SIGN;
780 }
781 }
782
783cleanup:
784 if (pbScratch!=NULL)
785 {
786 SymCryptWipe(pbScratch,cbScratch);
787 SymCryptCallbackFree(pbScratch);
788 }
789
790 return scError;
791}
SymCryptRsaSignVerifyPct
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaSignVerifyPct(const SYMCRYPT_RSAKEY *key)
Definition: implglue.c:51
SymCryptRsaSelftest
void SYMCRYPT_CALL SymCryptRsaSelftest(void)
Definition: implglue.c:47
SymCryptRsakeyCalculatePrivateFields
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyCalculatePrivateFields(_Inout_ PSYMCRYPT_RSAKEY pkRsakey, _Out_ PSYMCRYPT_DIVISOR pdTmp, _Out_ PSYMCRYPT_INT piPhi, _Out_ PSYMCRYPT_INT piAcc, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, UINT32 flags)
Definition: rsakey.c:357
SymCryptRsakeyCreateAllObjects
VOID SYMCRYPT_CALL SymCryptRsakeyCreateAllObjects(_Inout_ PSYMCRYPT_RSAKEY pkRsakey)
Definition: rsakey.c:312
RSA_DEFAULT_PUBLIC_EXPONENT
#define RSA_DEFAULT_PUBLIC_EXPONENT
Definition: rsakey.c:9
SYMCRYPT_RSAKEY_FIPS_MIN_BITSIZE_MODULUS
#define SYMCRYPT_RSAKEY_FIPS_MIN_BITSIZE_MODULUS
Definition: symcrypt_internal.h:2700
SYMCRYPT_SELFTEST_ALGORITHM_RSA
@ SYMCRYPT_SELFTEST_ALGORITHM_RSA
Definition: symcrypt_internal.h:3428
nPubExp
UINT32 nPubExp
Definition: symcrypt_internal.h:2722
SYMCRYPT_PCT_RSA_SIGN
#define SYMCRYPT_PCT_RSA_SIGN
Definition: symcrypt_internal.h:3479
SYMCRYPT_SCRATCH_BYTES_FOR_INT_MUL
#define SYMCRYPT_SCRATCH_BYTES_FOR_INT_MUL(_nResultDigits)
Definition: symcrypt_low_level.h:1020
SymCryptIntGenerateRandomPrime
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptIntGenerateRandomPrime(_In_ PCSYMCRYPT_INT piLow, _In_ PCSYMCRYPT_INT piHigh, _In_reads_opt_(nPubExp) PCUINT64 pu64PubExp, UINT32 nPubExp, UINT32 nTries, UINT32 flags, _Inout_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: primes.c:170
SYMCRYPT_SCRATCH_BYTES_FOR_INT_PRIME_GEN
#define SYMCRYPT_SCRATCH_BYTES_FOR_INT_PRIME_GEN(_nDigits)
Definition: symcrypt_low_level.h:1383
SYMCRYPT_SCRATCH_BYTES_FOR_EXTENDED_GCD
#define SYMCRYPT_SCRATCH_BYTES_FOR_EXTENDED_GCD(_nDigits)
Definition: symcrypt_low_level.h:1154
SYMCRYPT_FLAG_MODULUS_PARITY_PUBLIC
#define SYMCRYPT_FLAG_MODULUS_PARITY_PUBLIC
Definition: symcrypt_low_level.h:1501
SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_DIVISOR
#define SYMCRYPT_SCRATCH_BYTES_FOR_INT_TO_DIVISOR(_nDigits)
Definition: symcrypt_low_level.h:1100
SYMCRYPT_SCRATCH_BYTES_FOR_CRT_GENERATION
#define SYMCRYPT_SCRATCH_BYTES_FOR_CRT_GENERATION(_nDigits)
Definition: symcrypt_low_level.h:1226
SymCryptIntSubUint32
UINT32 SYMCRYPT_CALL SymCryptIntSubUint32(_In_ PCSYMCRYPT_INT piSrc1, UINT32 Src2, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:314
SymCryptIntMulMixedSize
VOID SYMCRYPT_CALL SymCryptIntMulMixedSize(_In_ PCSYMCRYPT_INT piSrc1, _In_ PCSYMCRYPT_INT piSrc2, _Out_ PSYMCRYPT_INT piDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: a_dispatch.c:485
SymCryptIntSetValueUint32
VOID SYMCRYPT_CALL SymCryptIntSetValueUint32(UINT32 u32Src, _Out_ PSYMCRYPT_INT piDst)
Definition: a_dispatch.c:230

Referenced by new_key_impl().

◆ SymCryptRsakeyGetCrtValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGetCrtValue ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_Out_writes_opt_(nCrtExponents) PBYTE *  ppCrtExponents,
_In_reads_(nCrtExponents) SIZE_T *  pcbCrtExponents,
UINT32  nCrtExponents,
_Out_writes_bytes_opt_(cbCrtCoefficient) PBYTE  pbCrtCoefficient,
SIZE_T  cbCrtCoefficient,
_Out_writes_bytes_opt_(cbPrivateExponent) PBYTE  pbPrivateExponent,
SIZE_T  cbPrivateExponent,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags 
)

Definition at line 1518 of file rsakey.c.

1529{
1530 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1531 PBYTE pbScratch = NULL;
1532 SIZE_T cbScratch = 0;
1533
1534 UNREFERENCED_PARAMETER( flags );
1535
1536 // Check if the arguments are correct
1537 if ( (ppCrtExponents==NULL) && (nCrtExponents!=0) ||
1538 (nCrtExponents != 0 && nCrtExponents != 2 ))
1539 {
1540 scError = SYMCRYPT_INVALID_ARGUMENT;
1541 goto cleanup;
1542 }
1543
1544 // Crt value can only be available we have private key.
1545 if (pkRsakey->hasPrivateKey == FALSE)
1546 {
1547 scError = SYMCRYPT_INVALID_ARGUMENT;
1548 goto cleanup;
1549 }
1550
1551 // Crt exponents
1552 for (UINT32 i=0; i<nCrtExponents; i++)
1553 {
1554 if (ppCrtExponents[i]!=NULL)
1555 {
1556 scError = SymCryptIntGetValue( pkRsakey->piCrtPrivExps[i], ppCrtExponents[i], pcbCrtExponents[i], numFormat );
1557 if (scError != SYMCRYPT_NO_ERROR )
1558 {
1559 goto cleanup;
1560 }
1561 }
1562 }
1563
1564 if (pbCrtCoefficient!=NULL)
1565 {
1566 cbScratch = SYMCRYPT_SCRATCH_BYTES_FOR_COMMON_MOD_OPERATIONS( pkRsakey->nDigitsOfModulus );
1567 pbScratch = SymCryptCallbackAlloc( cbScratch );
1568
1569 if (pbScratch==NULL)
1570 {
1571 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1572 goto cleanup;
1573 }
1574
1575 scError = SymCryptModElementGetValue(
1576 pkRsakey->pmPrimes[0],
1577 pkRsakey->peCrtInverses[0],
1578 pbCrtCoefficient,
1579 cbCrtCoefficient,
1580 numFormat,
1581 pbScratch,
1582 cbScratch);
1583 if (scError != SYMCRYPT_NO_ERROR )
1584 {
1585 goto cleanup;
1586 }
1587 }
1588
1589 if (pbPrivateExponent!=NULL)
1590 {
1591 scError = SymCryptIntGetValue( pkRsakey->piPrivExps[0], pbPrivateExponent, cbPrivateExponent, numFormat );
1592 if (scError != SYMCRYPT_NO_ERROR )
1593 {
1594 goto cleanup;
1595 }
1596 }
1597
1598cleanup:
1599
1600 if (pbScratch!=NULL)
1601 {
1602 SymCryptWipe(pbScratch,cbScratch);
1603 SymCryptCallbackFree(pbScratch);
1604 }
1605
1606 return scError;
1607}

Referenced by export_private_key_impl().

◆ SymCryptRsakeyGetNumberOfPrimes()

UINT32 SYMCRYPT_CALL SymCryptRsakeyGetNumberOfPrimes ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey)

Definition at line 305 of file rsakey.c.

306{
307 return pkRsakey->nPrimes;
308}

◆ SymCryptRsakeyGetNumberOfPublicExponents()

UINT32 SYMCRYPT_CALL SymCryptRsakeyGetNumberOfPublicExponents ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey)

Definition at line 298 of file rsakey.c.

299{
300 return pkRsakey->nPubExp;
301}

◆ SymCryptRsakeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGetValue ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_Out_writes_bytes_(cbModulus) PBYTE  pbModulus,
SIZE_T  cbModulus,
_Out_writes_opt_(nPubExp) PUINT64  pu64PubExp,
UINT32  nPubExp,
_Out_writes_opt_(nPrimes) PBYTE *  ppPrimes,
_In_reads_opt_(nPrimes) SIZE_T *  pcbPrimes,
UINT32  nPrimes,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags 
)

Definition at line 1445 of file rsakey.c.

1456{
1457 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1458
1459 UNREFERENCED_PARAMETER( flags );
1460
1461 // Check if private key needed but not there
1462 if ((nPrimes!=0) && (pkRsakey->hasPrivateKey == FALSE))
1463 {
1464 scError = SYMCRYPT_INVALID_ARGUMENT;
1465 goto cleanup;
1466 }
1467
1468 // Modulus
1469 if (pbModulus!=NULL)
1470 {
1471 // We'll get an error if cbModulus is 0 or too small
1472 scError = SymCryptIntGetValue( SymCryptIntFromModulus( pkRsakey->pmModulus ), pbModulus, cbModulus, numFormat );
1473 if (scError != SYMCRYPT_NO_ERROR )
1474 {
1475 goto cleanup;
1476 }
1477 }
1478
1479 // Public exponents
1480 if( pu64PubExp != NULL )
1481 {
1482 if( nPubExp != 1 )
1483 {
1484 scError = SYMCRYPT_INVALID_ARGUMENT;
1485 goto cleanup;
1486 }
1487 pu64PubExp[0] = pkRsakey->au64PubExp[0];
1488 }
1489
1490 // Primes i.e. private key
1491 if( nPrimes != 0 )
1492 {
1493 if( nPrimes != 2 || ppPrimes == NULL || pcbPrimes == NULL )
1494 {
1495 scError = SYMCRYPT_INVALID_ARGUMENT;
1496 goto cleanup;
1497 }
1498
1499 for (UINT32 i=0; i<nPrimes; i++)
1500 {
1501 if (ppPrimes[i]!=NULL)
1502 {
1503 scError = SymCryptIntGetValue( SymCryptIntFromModulus( pkRsakey->pmPrimes[i] ), ppPrimes[i], pcbPrimes[i], numFormat );
1504 if (scError != SYMCRYPT_NO_ERROR )
1505 {
1506 goto cleanup;
1507 }
1508 }
1509 }
1510 }
1511
1512cleanup:
1513 return scError;
1514}
nPrimes
UINT32 nPrimes
Definition: symcrypt_internal.h:2724

Referenced by export_private_key_impl(), and export_public_key_impl().

◆ SymCryptRsakeyHasPrivateKey()

BOOLEAN SYMCRYPT_CALL SymCryptRsakeyHasPrivateKey ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey)

Definition at line 257 of file rsakey.c.

258{
259 return pkRsakey->hasPrivateKey;
260}

Referenced by duplicate_key_impl().

◆ SymCryptRsakeyModulusBits()

UINT32 SYMCRYPT_CALL SymCryptRsakeyModulusBits ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey)

Definition at line 271 of file rsakey.c.

272{
273 return pkRsakey->nBitsOfModulus;
274}

◆ SymCryptRsakeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeySetValue ( _In_reads_bytes_(cbModulus) PCBYTE  pbModulus,
SIZE_T  cbModulus,
_In_reads_(nPubExp) PCUINT64  pu64PubExp,
UINT32  nPubExp,
_In_reads_opt_(nPrimes) PCBYTE *  ppPrimes,
_In_reads_opt_(nPrimes) SIZE_T *  pcbPrimes,
UINT32  nPrimes,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_RSAKEY  pkRsakey 
)

Definition at line 1399 of file rsakey.c.

1410{
1411 return SymCryptRsakeySetValueInternal(
1412 pbModulus, cbModulus,
1413 pu64PubExp, nPubExp,
1414 NULL, 0,
1415 ppPrimes, pcbPrimes, nPrimes,
1416 numFormat,
1417 flags,
1418 pkRsakey );
1419}
SymCryptRsakeySetValueInternal
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeySetValueInternal(_In_reads_bytes_(cbModulus) PCBYTE pbModulus, SIZE_T cbModulus, _In_reads_(nPubExp) PCUINT64 pu64PubExp, UINT32 nPubExp, _In_reads_bytes_opt_(cbPrivateExponent) PCBYTE pbPrivateExponent, SIZE_T cbPrivateExponent, _In_reads_opt_(nPrimes) PCBYTE *ppPrimes, _In_reads_opt_(nPrimes) SIZE_T *pcbPrimes, UINT32 nPrimes, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Inout_ PSYMCRYPT_RSAKEY pkRsakey)
Definition: rsakey.c:1115

Referenced by import_private_key_impl(), and import_public_key_impl().

◆ SymCryptRsakeySetValueFromPrivateExponent()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeySetValueFromPrivateExponent ( _In_reads_bytes_(cbModulus) PCBYTE  pbModulus,
SIZE_T  cbModulus,
UINT64  u64PubExp,
_In_reads_bytes_(cbPrivateExponent) PCBYTE  pbPrivateExponent,
SIZE_T  cbPrivateExponent,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags,
_Inout_ PSYMCRYPT_RSAKEY  pkRsakey 
)

Definition at line 1423 of file rsakey.c.

1432{
1433 return SymCryptRsakeySetValueInternal(
1434 pbModulus, cbModulus,
1435 &u64PubExp, 1,
1436 pbPrivateExponent, cbPrivateExponent,
1437 NULL, NULL, 0,
1438 numFormat,
1439 flags,
1440 pkRsakey );
1441}

◆ SymCryptRsakeySizeofModulus()

UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofModulus ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey)

Definition at line 264 of file rsakey.c.

265{
266 return (pkRsakey->nBitsOfModulus + 7)/8;
267}

Referenced by duplicate_key_impl(), export_private_key_impl(), export_public_key_impl(), rsa_decrypt(), rsa_encrypt(), SymCryptRsaCoreDec(), SymCryptRsaCoreVerifyInput(), SymCryptRsaOaepDecrypt(), SymCryptRsaOaepEncrypt(), SymCryptRsaPkcs1Decrypt(), SymCryptRsaPkcs1Encrypt(), SymCryptRsaPkcs1Sign(), SymCryptRsaPkcs1Verify(), SymCryptRsaPssSign(), SymCryptRsaPssVerify(), and verify_input().

◆ SymCryptRsakeySizeofPrime()

UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofPrime ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
UINT32  index 
)

Definition at line 289 of file rsakey.c.

292{
293 return (pkRsakey->nBitsOfPrimes[index] + 7)/8;
294}
index
GLuint index
Definition: glext.h:6031

Referenced by export_private_key_impl().

◆ SymCryptRsakeySizeofPublicExponent()

UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofPublicExponent ( _In_ PCSYMCRYPT_RSAKEY  pRsakey,
UINT32  index 
)

Definition at line 278 of file rsakey.c.

281{
282 SYMCRYPT_ASSERT( index == 0 );
283 UNREFERENCED_PARAMETER( index );
284 return SymCryptUint64Bytesize( pRsakey->au64PubExp[0] );
285}
SymCryptUint64Bytesize
UINT32 SymCryptUint64Bytesize(UINT64 value)
Definition: libmain.c:321

◆ SymCryptRsakeyWipe()

VOID SYMCRYPT_CALL SymCryptRsakeyWipe ( _Out_ PSYMCRYPT_RSAKEY  pkDst)

Definition at line 189 of file rsakey.c.

190{
191 // Wipe the whole structure in one go.
192 SymCryptWipe( pkDst, pkDst->cbTotalSize );
193}

Referenced by SymCryptRsakeyFree().

◆ SymCryptRsaOaepDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepDecrypt ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_NUMBER_FORMAT  nfSrc,
_In_ PCSYMCRYPT_HASH  hashAlgorithm,
_In_reads_bytes_(cbLabel) PCBYTE  pbLabel,
SIZE_T  cbLabel,
UINT32  flags,
_Out_writes_opt_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbDst 
)

Definition at line 937 of file rsa_enc.c.

949{
950 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
951 SIZE_T cbDstResult = 0; // We always return a value into *pcbDst
952
953 PBYTE pbScratch = NULL;
954 SIZE_T cbScratch = 0;
955
956 PBYTE pbTmp = NULL;
957 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
958
959 UNREFERENCED_PARAMETER( flags );
960
961 // Make sure that the key may be used in Encrypt/Decrypt
962 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_ENCRYPT) == 0 )
963 {
964 scError = SYMCRYPT_INVALID_ARGUMENT;
965 goto cleanup;
966 }
967
968 if (cbSrc > cbTmp)
969 {
970 scError = SYMCRYPT_INVALID_ARGUMENT;
971 goto cleanup;
972 }
973
974 // Make sure that the key has a private key
975 if (!pkRsakey->hasPrivateKey)
976 {
977 scError = SYMCRYPT_INVALID_ARGUMENT;
978 goto cleanup;
979 }
980
981 // The SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP macro does not
982 // overflow cbScratch since cbTmp < 2^17.
983#if (SYMCRYPT_CRT_DECRYPTION)
984 cbScratch = cbTmp + SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP( hashAlgorithm, cbSrc ), SymCryptRsaCoreDecCrtScratchSpace( pkRsakey ) );
985#else
986 cbScratch = cbTmp + SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP( hashAlgorithm, cbSrc ), SymCryptRsaCoreDecScratchSpace( pkRsakey ) );
987#endif
988
989 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
990 if (pbScratch == NULL)
991 {
992 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
993 goto cleanup;
994 }
995
996 pbTmp = pbScratch + cbScratch - cbTmp;
997
998 if (nfSrc == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
999 {
1000 // To implement this revert the buffer properly
1001 scError = SYMCRYPT_NOT_IMPLEMENTED;
1002 goto cleanup;
1003 }
1004
1005#if (SYMCRYPT_CRT_DECRYPTION)
1006 scError = SymCryptRsaCoreDecCrt(
1007 pkRsakey,
1008 pbSrc,
1009 cbSrc,
1010 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1011 flags,
1012 pbTmp,
1013 cbTmp,
1014 pbScratch,
1015 cbScratch - cbTmp );
1016#else
1017 scError = SymCryptRsaCoreDec(
1018 pkRsakey,
1019 pbSrc,
1020 cbSrc,
1021 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1022 flags,
1023 pbTmp,
1024 cbTmp,
1025 pbScratch,
1026 cbScratch - cbTmp );
1027#endif
1028
1029 if (scError != SYMCRYPT_NO_ERROR)
1030 {
1031 goto cleanup;
1032 }
1033
1034 scError = SymCryptRsaOaepRemoveEncryptionPadding(
1035 pbTmp,
1036 cbTmp,
1037 hashAlgorithm,
1038 pbLabel,
1039 cbLabel,
1040 flags,
1041 pbDst,
1042 cbDst,
1043 &cbDstResult,
1044 pbScratch,
1045 cbScratch - cbTmp );
1046 if (scError != SYMCRYPT_NO_ERROR)
1047 {
1048 goto cleanup;
1049 }
1050
1051 scError = SYMCRYPT_NO_ERROR;
1052
1053cleanup:
1054 if (pbScratch!=NULL)
1055 {
1056 SymCryptWipe(pbScratch,cbScratch);
1057 SymCryptCallbackFree(pbScratch);
1058 }
1059
1060 *pcbDst = cbDstResult;
1061
1062 return scError;
1063}
SymCryptRsaCoreDecCrt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaCoreDecCrt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_enc.c:208
SymCryptRsaCoreDec
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaCoreDec(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_enc.c:429
SymCryptRsaCoreDecCrtScratchSpace
UINT32 SYMCRYPT_CALL SymCryptRsaCoreDecCrtScratchSpace(_In_ PCSYMCRYPT_RSAKEY pkRsakey)
Definition: rsa_enc.c:170
SymCryptRsaCoreDecScratchSpace
UINT32 SYMCRYPT_CALL SymCryptRsaCoreDecScratchSpace(_In_ PCSYMCRYPT_RSAKEY pkRsakey)
Definition: rsa_enc.c:198
SymCryptRsakeySizeofModulus
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofModulus(_In_ PCSYMCRYPT_RSAKEY pkRsakey)
Definition: rsakey.c:264
SymCryptRsaOaepRemoveEncryptionPadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepRemoveEncryptionPadding(_In_reads_bytes_(cbOAEPFormat) PCBYTE pbOAEPFormat, SIZE_T cbOAEPFormat, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, UINT32 flags, _Out_writes_bytes_(cbPlaintext) PBYTE pbPlaintext, SIZE_T cbPlaintext, _Out_ SIZE_T *pcbPlaintext, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_padding.c:480
SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP
#define SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP(_hashAlgorithm, _nBytesOAEP)
Definition: symcrypt_low_level.h:2122

◆ SymCryptRsaOaepEncrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepEncrypt ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
_In_ PCSYMCRYPT_HASH  hashAlgorithm,
_In_reads_bytes_(cbLabel) PCBYTE  pbLabel,
SIZE_T  cbLabel,
UINT32  flags,
SYMCRYPT_NUMBER_FORMAT  nfDst,
_Out_writes_opt_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbDst 
)

Definition at line 833 of file rsa_enc.c.

845{
846 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
847
848 PBYTE pbScratch = NULL;
849 SIZE_T cbScratch = 0;
850
851 PBYTE pbTmp = NULL;
852 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
853
854 UNREFERENCED_PARAMETER( flags );
855
856 // Make sure that the key may be used in Encrypt/Decrypt
857 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_ENCRYPT) == 0 )
858 {
859 scError = SYMCRYPT_INVALID_ARGUMENT;
860 goto cleanup;
861 }
862
863 *pcbDst = cbTmp;
864
865 // Check if only *pcbDst is needed
866 if (pbDst == NULL)
867 {
868 scError = SYMCRYPT_NO_ERROR;
869 goto cleanup;
870 }
871
872 // The SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP macro does not
873 // overflow cbScratch since cbTmp < 2^17.
874 cbScratch = cbTmp + SYMCRYPT_MAX( SYMCRYPT_SCRATCH_BYTES_FOR_RSA_OAEP( hashAlgorithm, cbTmp ), SymCryptRsaCoreEncScratchSpace( pkRsakey ) );
875 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
876 if (pbScratch == NULL)
877 {
878 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
879 goto cleanup;
880 }
881
882 pbTmp = pbScratch + cbScratch - cbTmp;
883
884 scError = SymCryptRsaOaepApplyEncryptionPadding(
885 pbSrc,
886 cbSrc,
887 hashAlgorithm,
888 pbLabel,
889 cbLabel,
890 NULL, // Seed
891 0, // cbSeed
892 pbTmp,
893 cbTmp,
894 pbScratch,
895 cbScratch - cbTmp );
896 if (scError != SYMCRYPT_NO_ERROR)
897 {
898 goto cleanup;
899 }
900
901 scError = SymCryptRsaCoreEnc(
902 pkRsakey,
903 pbTmp,
904 cbTmp,
905 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, // Always MSB first for RSA OAEP
906 flags,
907 pbDst,
908 cbDst,
909 pbScratch,
910 cbScratch - cbTmp );
911 if (scError != SYMCRYPT_NO_ERROR)
912 {
913 goto cleanup;
914 }
915
916 if (nfDst == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
917 {
918 // To implement this revert the buffer properly
919 scError = SYMCRYPT_NOT_IMPLEMENTED;
920 goto cleanup;
921 }
922
923 scError = SYMCRYPT_NO_ERROR;
924
925cleanup:
926 if (pbScratch!=NULL)
927 {
928 SymCryptWipe(pbScratch,cbScratch);
929 SymCryptCallbackFree(pbScratch);
930 }
931
932 return scError;
933}
SymCryptRsaCoreEncScratchSpace
UINT32 SYMCRYPT_CALL SymCryptRsaCoreEncScratchSpace(_In_ PCSYMCRYPT_RSAKEY pkRsakey)
Definition: rsa_enc.c:15
SymCryptRsaCoreEnc
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaCoreEnc(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_enc.c:77
SymCryptRsaOaepApplyEncryptionPadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepApplyEncryptionPadding(_In_reads_bytes_(cbPlaintext) PCBYTE pbPlaintext, SIZE_T cbPlaintext, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, _In_reads_bytes_opt_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed, _Out_writes_bytes_(cbOaepFormat) PBYTE pbOaepFormat, SIZE_T cbOaepFormat, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_padding.c:364

◆ SymCryptRsaPkcs1Decrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Decrypt ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_NUMBER_FORMAT  nfSrc,
UINT32  flags,
_Out_writes_opt_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbDst 
)

Definition at line 725 of file rsa_enc.c.

734{
735 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
736
737 PBYTE pbScratch = NULL;
738 SIZE_T cbScratch = 0;
739
740 PBYTE pbTmp = NULL;
741 SIZE_T cbModulus = SymCryptRsakeySizeofModulus(pkRsakey);
742 SIZE_T cbTmp = SymCryptRoundUpPow2Sizet( cbModulus ); // tmp buffer needs to be a power of 2
743
744 // Make sure that the key may be used in Encrypt/Decrypt
745 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_ENCRYPT) == 0 )
746 {
747 scError = SYMCRYPT_INVALID_ARGUMENT;
748 goto cleanup;
749 }
750
751 // Make sure that the key has a private key
752 if (!pkRsakey->hasPrivateKey)
753 {
754 scError = SYMCRYPT_INVALID_ARGUMENT;
755 goto cleanup;
756 }
757
758#if (SYMCRYPT_CRT_DECRYPTION)
759 cbScratch = cbTmp + SymCryptRsaCoreDecCrtScratchSpace( pkRsakey );
760#else
761 cbScratch = cbTmp + SymCryptRsaCoreDecScratchSpace( pkRsakey );
762#endif
763
764 UNREFERENCED_PARAMETER( flags );
765
766 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
767 if (pbScratch == NULL)
768 {
769 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
770 goto cleanup;
771 }
772
773 pbTmp = pbScratch + cbScratch - cbTmp;
774
775 if (nfSrc == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
776 {
777 // To implement this revert the buffer properly
778 scError = SYMCRYPT_NOT_IMPLEMENTED;
779 goto cleanup;
780 }
781
782#if (SYMCRYPT_CRT_DECRYPTION)
783 scError = SymCryptRsaCoreDecCrt(
784 pkRsakey,
785 pbSrc,
786 cbSrc,
787 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
788 flags,
789 pbTmp,
790 cbModulus,
791 pbScratch,
792 cbScratch - cbTmp );
793#else
794 scError = SymCryptRsaCoreDec(
795 pkRsakey,
796 pbSrc,
797 cbSrc,
798 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
799 flags,
800 pbTmp,
801 cbModulus,
802 pbScratch,
803 cbScratch - cbTmp );
804#endif
805 if (scError != SYMCRYPT_NO_ERROR)
806 {
807 goto cleanup;
808 }
809
810 scError = SymCryptRsaPkcs1RemoveEncryptionPadding(
811 pbTmp,
812 cbModulus,
813 cbTmp,
814 pbDst,
815 cbDst,
816 pcbDst );
817 // The error that is returned from the encryption padding is confidential data
818 // due to Bleichenbacher-style attacks.
819 // Make sure we don't create a side-channel leak for it.
820
821cleanup:
822 if (pbScratch!=NULL)
823 {
824 SymCryptWipe(pbScratch,cbScratch);
825 SymCryptCallbackFree(pbScratch);
826 }
827
828 return scError;
829}
SymCryptRoundUpPow2Sizet
SIZE_T SYMCRYPT_CALL SymCryptRoundUpPow2Sizet(SIZE_T v)
Definition: scsTools.c:76
SymCryptRsaPkcs1RemoveEncryptionPadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1RemoveEncryptionPadding(_Inout_updates_bytes_(cbPkcs1Buffer) PBYTE pbPkcs1Format, SIZE_T cbPkcs1Format, SIZE_T cbPkcs1Buffer, _Out_writes_bytes_opt_(cbPlaintext) PBYTE pbPlaintext, SIZE_T cbPlaintext, _Out_ SIZE_T *pcbPlaintext)
Definition: rsa_padding.c:237

◆ SymCryptRsaPkcs1Encrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Encrypt ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
UINT32  flags,
SYMCRYPT_NUMBER_FORMAT  nfDst,
_Out_writes_opt_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst,
_Out_ SIZE_T *  pcbDst 
)

Definition at line 629 of file rsa_enc.c.

638{
639 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
640
641 PBYTE pbScratch = NULL;
642 SIZE_T cbScratch = 0;
643
644 PBYTE pbTmp = NULL;
645 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
646
647 cbScratch = cbTmp + SymCryptRsaCoreEncScratchSpace( pkRsakey );
648
649 UNREFERENCED_PARAMETER( flags );
650
651 // Make sure that the key may be used in Encrypt/Decrypt
652 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_ENCRYPT) == 0 )
653 {
654 scError = SYMCRYPT_INVALID_ARGUMENT;
655 goto cleanup;
656 }
657
658 *pcbDst = cbTmp;
659
660 // Check if only *pcbDst is needed
661 if (pbDst == NULL)
662 {
663 scError = SYMCRYPT_NO_ERROR;
664 goto cleanup;
665 }
666
667 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
668 if (pbScratch == NULL)
669 {
670 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
671 goto cleanup;
672 }
673
674 pbTmp = pbScratch + cbScratch - cbTmp;
675
676 scError = SymCryptRsaPkcs1ApplyEncryptionPadding(
677 pbSrc,
678 cbSrc,
679 pbTmp,
680 cbTmp );
681 if (scError != SYMCRYPT_NO_ERROR)
682 {
683 goto cleanup;
684 }
685
686 scError = SymCryptRsaCoreEnc(
687 pkRsakey,
688 pbTmp,
689 cbTmp,
690 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, // Always MSB first for RSA OAEP
691 flags,
692 pbDst,
693 cbDst,
694 pbScratch,
695 cbScratch - cbTmp );
696 if (scError != SYMCRYPT_NO_ERROR)
697 {
698 goto cleanup;
699 }
700
701 if (nfDst == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
702 {
703 // To implement this revert the buffer properly
704 scError = SYMCRYPT_NOT_IMPLEMENTED;
705 goto cleanup;
706 }
707
708 scError = SYMCRYPT_NO_ERROR;
709
710cleanup:
711 if (pbScratch!=NULL)
712 {
713 SymCryptWipe(pbScratch,cbScratch);
714 SymCryptCallbackFree(pbScratch);
715 }
716
717 return scError;
718}
SymCryptRsaPkcs1ApplyEncryptionPadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1ApplyEncryptionPadding(_In_reads_bytes_(cbPlaintext) PCBYTE pbPlaintext, SIZE_T cbPlaintext, _Out_writes_bytes_(cbPkcs1Format) PBYTE pbPkcs1Format, SIZE_T cbPkcs1Format)
Definition: rsa_padding.c:180

◆ SymCryptRsaPkcs1Sign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Sign ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
_In_ PCSYMCRYPT_OID  pHashOIDs,
_In_ SIZE_T  nOIDCount,
UINT32  flags,
SYMCRYPT_NUMBER_FORMAT  nfSignature,
_Out_writes_opt_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature,
_Out_ SIZE_T *  pcbSignature 
)

Definition at line 1071 of file rsa_enc.c.

1082{
1083 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1084
1085 PBYTE pbScratch = NULL;
1086 SIZE_T cbScratch = 0;
1087
1088 PBYTE pbTmp = NULL;
1089 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
1090
1091 PCBYTE pbOID = NULL;
1092 SIZE_T cbOID = 0;
1093
1094 UNREFERENCED_PARAMETER(nOIDCount);
1095
1096 pbOID = pHashOIDs ? pHashOIDs->pbOID : NULL;
1097 cbOID = pHashOIDs ? pHashOIDs->cbOID : 0;
1098
1099 // Make sure that the key may be used in Sign/Verify
1100 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_SIGN) == 0 )
1101 {
1102 scError = SYMCRYPT_INVALID_ARGUMENT;
1103 goto cleanup;
1104 }
1105
1106 // Make sure that the key has a private key
1107 if (!pkRsakey->hasPrivateKey)
1108 {
1109 scError = SYMCRYPT_INVALID_ARGUMENT;
1110 goto cleanup;
1111 }
1112
1113 *pcbSignature = cbTmp;
1114
1115 // Check if only *pcbSignature is needed
1116 if (pbSignature == NULL)
1117 {
1118 scError = SYMCRYPT_NO_ERROR;
1119 goto cleanup;
1120 }
1121
1122#if (SYMCRYPT_CRT_DECRYPTION)
1123 cbScratch = cbTmp + SymCryptRsaCoreDecCrtScratchSpace( pkRsakey );
1124#else
1125 cbScratch = cbTmp + SymCryptRsaCoreDecScratchSpace( pkRsakey );
1126#endif
1127
1128 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
1129 if (pbScratch == NULL)
1130 {
1131 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1132 goto cleanup;
1133 }
1134
1135 pbTmp = pbScratch + cbScratch - cbTmp;
1136
1137 scError = SymCryptRsaPkcs1ApplySignaturePadding(
1138 pbHashValue,
1139 cbHashValue,
1140 pbOID,
1141 cbOID,
1142 flags,
1143 pbTmp,
1144 cbTmp );
1145 if (scError != SYMCRYPT_NO_ERROR)
1146 {
1147 goto cleanup;
1148 }
1149
1150#if (SYMCRYPT_CRT_DECRYPTION)
1151 scError = SymCryptRsaCoreDecCrt(
1152 pkRsakey,
1153 pbTmp,
1154 cbTmp,
1155 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1156 flags,
1157 pbSignature,
1158 cbSignature,
1159 pbScratch,
1160 cbScratch - cbTmp );
1161#else
1162 scError = SymCryptRsaCoreDec(
1163 pkRsakey,
1164 pbTmp,
1165 cbTmp,
1166 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1167 flags,
1168 pbSignature,
1169 cbSignature,
1170 pbScratch,
1171 cbScratch - cbTmp );
1172#endif
1173 if (scError != SYMCRYPT_NO_ERROR)
1174 {
1175 goto cleanup;
1176 }
1177
1178 if (nfSignature == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
1179 {
1180 // To implement this revert the buffer properly
1181 scError = SYMCRYPT_NOT_IMPLEMENTED;
1182 goto cleanup;
1183 }
1184
1185 scError = SYMCRYPT_NO_ERROR;
1186
1187cleanup:
1188 if (pbScratch!=NULL)
1189 {
1190 SymCryptWipe(pbScratch,cbScratch);
1191 SymCryptCallbackFree(pbScratch);
1192 }
1193
1194 return scError;
1195}
SymCryptRsaPkcs1ApplySignaturePadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1ApplySignaturePadding(_In_reads_bytes_(cbHash) PCBYTE pbHash, SIZE_T cbHash, _In_reads_bytes_(cbHashOid) PCBYTE pbHashOid, SIZE_T cbHashOid, UINT32 flags, _Out_writes_bytes_(cbPKCS1Format) PBYTE pbPKCS1Format, SIZE_T cbPKCS1Format)
Definition: rsa_padding.c:651

◆ SymCryptRsaPkcs1Verify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Verify ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
SYMCRYPT_NUMBER_FORMAT  nfSignature,
_In_reads_opt_(nOIDCount) PCSYMCRYPT_OID  pHashOID,
_In_ SIZE_T  nOIDCount,
UINT32  flags 
)

Definition at line 1199 of file rsa_enc.c.

1209{
1210 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1211
1212 PBYTE pbScratch = NULL;
1213 SIZE_T cbScratch = 0;
1214
1215 PBYTE pbTmp = NULL;
1216 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
1217
1218 // Make sure that the key may be used in Sign/Verify
1219 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_SIGN) == 0 )
1220 {
1221 scError = SYMCRYPT_INVALID_ARGUMENT;
1222 goto cleanup;
1223 }
1224
1225 if (cbSignature > cbTmp)
1226 {
1227 scError = SYMCRYPT_INVALID_ARGUMENT;
1228 goto cleanup;
1229 }
1230
1231 if (nfSignature == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
1232 {
1233 // To implement this revert the buffer properly
1234 scError = SYMCRYPT_NOT_IMPLEMENTED;
1235 goto cleanup;
1236 }
1237
1238 // The SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PKCS1 macro does not
1239 // overflow cbScratch since cbTmp < 2^17.
1240 cbScratch = cbTmp +
1241 SYMCRYPT_MAX( SymCryptRsaCoreEncScratchSpace( pkRsakey ),
1242 SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PKCS1( cbTmp ) );
1243
1244 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
1245 if (pbScratch == NULL)
1246 {
1247 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1248 goto cleanup;
1249 }
1250
1251 pbTmp = pbScratch + cbScratch - cbTmp;
1252
1253 scError = SymCryptRsaCoreEnc(
1254 pkRsakey,
1255 pbSignature,
1256 cbSignature,
1257 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1258 flags,
1259 pbTmp,
1260 cbTmp,
1261 pbScratch,
1262 cbScratch - cbTmp );
1263 if (scError != SYMCRYPT_NO_ERROR)
1264 {
1265 goto cleanup;
1266 }
1267
1268 scError = SymCryptRsaPkcs1VerifySignaturePadding(
1269 pbHashValue,
1270 cbHashValue,
1271 pHashOIDs,
1272 nOIDCount,
1273 pbTmp,
1274 cbTmp,
1275 flags,
1276 pbScratch,
1277 cbScratch - cbTmp );
1278 if (scError != SYMCRYPT_NO_ERROR)
1279 {
1280 goto cleanup;
1281 }
1282
1283 scError = SYMCRYPT_NO_ERROR;
1284
1285cleanup:
1286 if (pbScratch!=NULL)
1287 {
1288 SymCryptWipe(pbScratch,cbScratch);
1289 SymCryptCallbackFree(pbScratch);
1290 }
1291
1292 return scError;
1293}
SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PKCS1
#define SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PKCS1(_nBytesPKCS1)
Definition: symcrypt_low_level.h:2185
SymCryptRsaPkcs1VerifySignaturePadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1VerifySignaturePadding(_In_reads_bytes_(cbHash) PCBYTE pbHash, SIZE_T cbHash, _In_reads_(nOIDCount) PCSYMCRYPT_OID pHashOIDs, _In_ SIZE_T nOIDCount, _In_reads_bytes_(cbPKCS1Format) PCBYTE pbPKCS1Format, SIZE_T cbPKCS1Format, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_padding.c:827

◆ SymCryptRsaPssSign()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssSign ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
_In_ PCSYMCRYPT_HASH  hashAlgorithm,
SIZE_T  cbSalt,
UINT32  flags,
SYMCRYPT_NUMBER_FORMAT  nfSignature,
_Out_writes_opt_(cbSignature) PBYTE  pbSignature,
SIZE_T  cbSignature,
_Out_ SIZE_T *  pcbSignature 
)

Definition at line 1297 of file rsa_enc.c.

1308{
1309 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1310
1311 PBYTE pbScratch = NULL;
1312 SIZE_T cbScratch = 0;
1313
1314 PBYTE pbTmp = NULL;
1315 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
1316
1317 // Make sure that the key may be used in Sign/Verify
1318 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_SIGN) == 0 )
1319 {
1320 scError = SYMCRYPT_INVALID_ARGUMENT;
1321 goto cleanup;
1322 }
1323
1324 if ( (cbHashValue > cbTmp) ||
1325 (cbSalt > cbTmp) )
1326 {
1327 scError = SYMCRYPT_INVALID_ARGUMENT;
1328 goto cleanup;
1329 }
1330
1331 // Make sure that the key has a private key
1332 if (!pkRsakey->hasPrivateKey)
1333 {
1334 scError = SYMCRYPT_INVALID_ARGUMENT;
1335 goto cleanup;
1336 }
1337
1338 *pcbSignature = cbTmp;
1339
1340 // Check if only *pcbSignature is needed
1341 if (pbSignature == NULL)
1342 {
1343 scError = SYMCRYPT_NO_ERROR;
1344 goto cleanup;
1345 }
1346
1347 // The SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS macro does not
1348 // overflow cbScratch since cbTmp < 2^17.
1349#if (SYMCRYPT_CRT_DECRYPTION)
1350 cbScratch = cbTmp +
1351 SYMCRYPT_MAX( SymCryptRsaCoreDecCrtScratchSpace( pkRsakey ),
1352 SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS( hashAlgorithm, cbHashValue, cbTmp ) );
1353#else
1354 cbScratch = cbTmp +
1355 SYMCRYPT_MAX( SymCryptRsaCoreDecScratchSpace( pkRsakey ),
1356 SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS( hashAlgorithm, cbHashValue, cbTmp ) );
1357#endif
1358
1359 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
1360 if (pbScratch == NULL)
1361 {
1362 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1363 goto cleanup;
1364 }
1365
1366 pbTmp = pbScratch + cbScratch - cbTmp;
1367
1368 scError = SymCryptRsaPssApplySignaturePadding(
1369 pbHashValue,
1370 cbHashValue,
1371 hashAlgorithm,
1372 NULL, // For now only random salt supported
1373 cbSalt,
1374 pkRsakey->nBitsOfModulus,
1375 flags,
1376 pbTmp,
1377 cbTmp,
1378 pbScratch,
1379 cbScratch - cbTmp );
1380 if (scError != SYMCRYPT_NO_ERROR)
1381 {
1382 goto cleanup;
1383 }
1384
1385#if (SYMCRYPT_CRT_DECRYPTION)
1386 scError = SymCryptRsaCoreDecCrt(
1387 pkRsakey,
1388 pbTmp,
1389 cbTmp,
1390 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1391 flags,
1392 pbSignature,
1393 cbSignature,
1394 pbScratch,
1395 cbScratch - cbTmp );
1396#else
1397 scError = SymCryptRsaCoreDec(
1398 pkRsakey,
1399 pbTmp,
1400 cbTmp,
1401 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1402 flags,
1403 pbSignature,
1404 cbSignature,
1405 pbScratch,
1406 cbScratch - cbTmp );
1407#endif
1408 if (scError != SYMCRYPT_NO_ERROR)
1409 {
1410 goto cleanup;
1411 }
1412
1413 if (nfSignature == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
1414 {
1415 // To implement this revert the buffer properly
1416 scError = SYMCRYPT_NOT_IMPLEMENTED;
1417 goto cleanup;
1418 }
1419
1420 scError = SYMCRYPT_NO_ERROR;
1421
1422cleanup:
1423 if (pbScratch!=NULL)
1424 {
1425 SymCryptWipe(pbScratch,cbScratch);
1426 SymCryptCallbackFree(pbScratch);
1427 }
1428
1429 return scError;
1430}
SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS
#define SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS(_hashAlgorithm, _nBytesMessage, _nBytesPSS)
Definition: symcrypt_low_level.h:2234
SymCryptRsaPssApplySignaturePadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssApplySignaturePadding(_In_reads_bytes_(cbHash) PCBYTE pbHash, SIZE_T cbHash, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_opt_(cbSalt) PCBYTE pbSalt, _In_range_(0, cbPSSFormat) SIZE_T cbSalt, UINT32 nBitsOfModulus, UINT32 flags, _Out_writes_bytes_(cbPSSFormat) PBYTE pbPSSFormat, SIZE_T cbPSSFormat, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_padding.c:918

◆ SymCryptRsaPssVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssVerify ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
_In_reads_bytes_(cbSignature) PCBYTE  pbSignature,
SIZE_T  cbSignature,
SYMCRYPT_NUMBER_FORMAT  nfSignature,
_In_ PCSYMCRYPT_HASH  hashAlgorithm,
SIZE_T  cbSalt,
UINT32  flags 
)

Definition at line 1434 of file rsa_enc.c.

1444{
1445 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1446
1447 PBYTE pbScratch = NULL;
1448 SIZE_T cbScratch = 0;
1449
1450 PBYTE pbTmp = NULL;
1451 SIZE_T cbTmp = SymCryptRsakeySizeofModulus(pkRsakey);
1452
1453 // Make sure that the key may be used in Sign/Verify
1454 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_SIGN) == 0 )
1455 {
1456 scError = SYMCRYPT_INVALID_ARGUMENT;
1457 goto cleanup;
1458 }
1459
1460 if ( (cbHashValue > cbTmp) ||
1461 (cbSalt > cbTmp) ||
1462 (cbSignature > cbTmp) )
1463 {
1464 scError = SYMCRYPT_INVALID_ARGUMENT;
1465 goto cleanup;
1466 }
1467
1468 if (nfSignature == SYMCRYPT_NUMBER_FORMAT_LSB_FIRST)
1469 {
1470 // To implement this revert the buffer properly
1471 scError = SYMCRYPT_NOT_IMPLEMENTED;
1472 goto cleanup;
1473 }
1474
1475 // The SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS macro does not
1476 // overflow cbScratch since cbTmp < 2^17.
1477 cbScratch = cbTmp +
1478 SYMCRYPT_MAX( SymCryptRsaCoreEncScratchSpace( pkRsakey ),
1479 SYMCRYPT_SCRATCH_BYTES_FOR_RSA_PSS( hashAlgorithm, cbHashValue, cbTmp ) );
1480
1481 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
1482 if (pbScratch == NULL)
1483 {
1484 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1485 goto cleanup;
1486 }
1487
1488 pbTmp = pbScratch + cbScratch - cbTmp;
1489
1490 scError = SymCryptRsaCoreEnc(
1491 pkRsakey,
1492 pbSignature,
1493 cbSignature,
1494 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1495 flags,
1496 pbTmp,
1497 cbTmp,
1498 pbScratch,
1499 cbScratch - cbTmp );
1500 if (scError != SYMCRYPT_NO_ERROR)
1501 {
1502 goto cleanup;
1503 }
1504
1505 scError = SymCryptRsaPssVerifySignaturePadding(
1506 pbHashValue,
1507 cbHashValue,
1508 hashAlgorithm,
1509 cbSalt,
1510 pbTmp,
1511 cbTmp,
1512 pkRsakey->nBitsOfModulus,
1513 flags,
1514 pbScratch,
1515 cbScratch - cbTmp );
1516 if (scError != SYMCRYPT_NO_ERROR)
1517 {
1518 goto cleanup;
1519 }
1520
1521 scError = SYMCRYPT_NO_ERROR;
1522
1523cleanup:
1524 if (pbScratch!=NULL)
1525 {
1526 SymCryptWipe(pbScratch,cbScratch);
1527 SymCryptCallbackFree(pbScratch);
1528 }
1529
1530 return scError;
1531}
SymCryptRsaPssVerifySignaturePadding
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssVerifySignaturePadding(_In_reads_bytes_(cbHash) PCBYTE pbHash, SIZE_T cbHash, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_range_(0, cbPSSFormat) SIZE_T cbSalt, _In_reads_bytes_(cbPSSFormat) PCBYTE pbPSSFormat, SIZE_T cbPSSFormat, UINT32 nBitsOfModulus, UINT32 flags, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: rsa_padding.c:1051

◆ SymCryptRsaRawDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaRawDecrypt ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags,
_Out_writes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst 
)

Definition at line 560 of file rsa_enc.c.

568{
569 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
570
571 PBYTE pbScratch = NULL;
572 UINT32 cbScratch = 0;
573
574 // Make sure that the key may be used in Encrypt/Decrypt
575 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_ENCRYPT) == 0 )
576 {
577 scError = SYMCRYPT_INVALID_ARGUMENT;
578 goto cleanup;
579 }
580
581 // Make sure that the key has a private key
582 if (!pkRsakey->hasPrivateKey)
583 {
584 scError = SYMCRYPT_INVALID_ARGUMENT;
585 goto cleanup;
586 }
587
588#define SYMCRYPT_CRT_DECRYPTION (1) // Set this to 0 to test the non-crt decryption
589
590 // Scratch space
591#if (SYMCRYPT_CRT_DECRYPTION)
592 cbScratch = SymCryptRsaCoreDecCrtScratchSpace( pkRsakey );
593#else
594 cbScratch = SymCryptRsaCoreDecScratchSpace( pkRsakey );
595#endif
596
597 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
598 if (pbScratch == NULL)
599 {
600 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
601 goto cleanup;
602 }
603
604#if (SYMCRYPT_CRT_DECRYPTION)
605 scError = SymCryptRsaCoreDecCrt( pkRsakey, pbSrc, cbSrc, numFormat, flags, pbDst, cbDst, pbScratch, cbScratch );
606#else
607 scError = SymCryptRsaCoreDec( pkRsakey, pbSrc, cbSrc, numFormat, flags, pbDst, cbDst, pbScratch, cbScratch );
608#endif
609
610 if (scError != SYMCRYPT_NO_ERROR)
611 {
612 goto cleanup;
613 }
614
615 scError = SYMCRYPT_NO_ERROR;
616
617cleanup:
618 if (pbScratch!=NULL)
619 {
620 SymCryptWipe(pbScratch,cbScratch);
621 SymCryptCallbackFree(pbScratch);
622 }
623
624 return scError;
625}

◆ SymCryptRsaRawEncrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaRawEncrypt ( _In_ PCSYMCRYPT_RSAKEY  pkRsakey,
_In_reads_bytes_(cbSrc) PCBYTE  pbSrc,
SIZE_T  cbSrc,
SYMCRYPT_NUMBER_FORMAT  numFormat,
UINT32  flags,
_Out_writes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst 
)

Definition at line 510 of file rsa_enc.c.

518{
519 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
520
521 PBYTE pbScratch = NULL;
522 UINT32 cbScratch = 0;
523
524 // Make sure that the key may be used in Encrypt/Decrypt
525 if ( (pkRsakey->fAlgorithmInfo & SYMCRYPT_FLAG_RSAKEY_ENCRYPT) == 0 )
526 {
527 scError = SYMCRYPT_INVALID_ARGUMENT;
528 goto cleanup;
529 }
530
531 cbScratch = SymCryptRsaCoreEncScratchSpace( pkRsakey );
532
533 pbScratch = (PBYTE)SymCryptCallbackAlloc( cbScratch );
534 if (pbScratch == NULL)
535 {
536 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
537 goto cleanup;
538 }
539
540 scError = SymCryptRsaCoreEnc( pkRsakey, pbSrc, cbSrc, numFormat, flags, pbDst, cbDst, pbScratch, cbScratch );
541 if (scError != SYMCRYPT_NO_ERROR)
542 {
543 goto cleanup;
544 }
545
546 scError = SYMCRYPT_NO_ERROR;
547
548cleanup:
549 if (pbScratch!=NULL)
550 {
551 SymCryptWipe(pbScratch,cbScratch);
552 SymCryptCallbackFree(pbScratch);
553 }
554
555 return scError;
556}

◆ SymCryptRsaSelftest()

VOID SYMCRYPT_CALL SymCryptRsaSelftest ( void  )

Definition at line 47 of file implglue.c.

48{
49}

Referenced by SymCryptRsakeyGenerate(), and SymCryptRsakeySetValueInternal().

◆ SymCryptSessionDestroy()

VOID SYMCRYPT_CALL SymCryptSessionDestroy ( _Inout_ PSYMCRYPT_SESSION  pSession)

Definition at line 76 of file session.c.

77{
78 if ( pSession->pMutex != NULL )
79 {
80 SymCryptCallbackFreeMutexFastInproc(pSession->pMutex);
81 }
82 SymCryptWipeKnownSize(pSession, sizeof(*pSession));
83}
SymCryptCallbackFreeMutexFastInproc
VOID SYMCRYPT_CALL SymCryptCallbackFreeMutexFastInproc(_Inout_ PVOID pMutex)

◆ SymCryptSessionGcmDecrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionGcmDecrypt ( _Inout_ PSYMCRYPT_SESSION  pSession,
UINT64  messageNumber,
_In_ PCSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_In_reads_(cbTag) PCBYTE  pbTag,
SIZE_T  cbTag 
)

Definition at line 311 of file session.c.

322{
323 BYTE nonce[12];
324 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
325
326 if ( (pSession->flags & SYMCRYPT_FLAG_SESSION_ENCRYPT) != 0 )
327 {
328 scError = SYMCRYPT_INVALID_ARGUMENT;
329 goto cleanup;
330 }
331
332 // Check for messageNumbers which are too high or not valid
333 if ( (messageNumber > SYMCRYPT_SESSION_MAX_MESSAGE_NUMBER) || (messageNumber == 0) )
334 {
335 scError = SYMCRYPT_INVALID_ARGUMENT;
336 goto cleanup;
337 }
338
339 // Check whether we are definitely too late to proceed before attempting to acquire mutex
340 // Do not need atomic read of full replayState here, but do need atomic 64b read of
341 // pSession->replayState.messageNumber
342 if ( messageNumber <= (UINT64) SYMCRYPT_ATOMIC_LOAD64_RELAXED(&pSession->replayState.messageNumber) - 64 )
343 {
344 scError = SYMCRYPT_SESSION_REPLAY_FAILURE;
345 goto cleanup;
346 }
347
348 SYMCRYPT_STORE_MSBFIRST32(&nonce[0], pSession->senderId);
349 SYMCRYPT_STORE_MSBFIRST64(&nonce[4], messageNumber);
350
351 scError = SymCryptGcmDecrypt(
352 pExpandedKey,
353 nonce,
354 sizeof(nonce),
355 pbAuthData,
356 cbAuthData,
357 pbSrc,
358 pbDst,
359 cbData,
360 pbTag,
361 cbTag);
362
363 if ( scError != SYMCRYPT_NO_ERROR )
364 {
365 goto cleanup; // wipes pbDst twice, but we don't care about performance in the error case
366 }
367
368 scError = SymCryptSessionDecryptUpdateState(pSession, messageNumber);
369
370cleanup:
371 if ( scError != SYMCRYPT_NO_ERROR )
372 {
373 SymCryptWipe( pbDst, cbData );
374 }
375
376 return scError;
377}
SymCryptSessionDecryptUpdateState
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionDecryptUpdateState(_Inout_ PSYMCRYPT_SESSION pSession, UINT64 messageNumber)
Definition: session.c:285
SymCryptGcmDecrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecrypt(_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
Definition: gcm.c:731
messageNumber
UINT64 messageNumber
Definition: symcrypt_internal.h:2063
SYMCRYPT_SESSION_MAX_MESSAGE_NUMBER
#define SYMCRYPT_SESSION_MAX_MESSAGE_NUMBER
Definition: symcrypt_internal.h:2085
SYMCRYPT_FLAG_SESSION_ENCRYPT
#define SYMCRYPT_FLAG_SESSION_ENCRYPT
Definition: symcrypt_internal.h:2016
nonce
UINT32 nonce[3]
Definition: symcrypt_internal.h:2122

◆ SymCryptSessionGcmEncrypt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionGcmEncrypt ( _Inout_ PSYMCRYPT_SESSION  pSession,
_In_ PCSYMCRYPT_GCM_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbAuthData) PCBYTE  pbAuthData,
SIZE_T  cbAuthData,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData,
_Out_writes_(cbTag) PBYTE  pbTag,
SIZE_T  cbTag,
_Out_opt_ PUINT64  pu64MessageNumber 
)

Definition at line 87 of file session.c.

98{
99 BYTE nonce[12];
100 UINT64 messageNumber;
101
102 if ( (pSession->flags & SYMCRYPT_FLAG_SESSION_ENCRYPT) != SYMCRYPT_FLAG_SESSION_ENCRYPT )
103 {
104 return SYMCRYPT_INVALID_ARGUMENT;
105 }
106
107 messageNumber = SYMCRYPT_ATOMIC_ADD64_POST_RELAXED(&pSession->replayState.messageNumber, 1);
108
109 // We do not allow messageNumber to go above some maximum value (currently 2^64 - 2^32)
110 if ( messageNumber > SYMCRYPT_SESSION_MAX_MESSAGE_NUMBER )
111 {
112 // Decrement the session messageNumber on the error path so that this session will continue
113 // to only generate errors
114 SYMCRYPT_ATOMIC_ADD64_POST_RELAXED(&pSession->replayState.messageNumber, -1ll);
115 return SYMCRYPT_INVALID_ARGUMENT;
116 }
117
118 SYMCRYPT_STORE_MSBFIRST32(&nonce[0], pSession->senderId);
119 SYMCRYPT_STORE_MSBFIRST64(&nonce[4], messageNumber);
120
121 SymCryptGcmEncrypt(
122 pExpandedKey,
123 nonce,
124 sizeof(nonce),
125 pbAuthData,
126 cbAuthData,
127 pbSrc,
128 pbDst,
129 cbData,
130 pbTag,
131 cbTag);
132
133 if( pu64MessageNumber != NULL )
134 {
135 *pu64MessageNumber = messageNumber;
136 }
137
138 return SYMCRYPT_NO_ERROR;
139}
SymCryptGcmEncrypt
VOID SYMCRYPT_CALL SymCryptGcmEncrypt(_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce, _In_reads_opt_(cbAuthData) PCBYTE pbAuthData, SIZE_T cbAuthData, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
Definition: gcm.c:618

◆ SymCryptSessionReceiverInit()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionReceiverInit ( _Inout_ PSYMCRYPT_SESSION  pSession,
UINT32  senderId,
UINT32  flags 
)

Definition at line 32 of file session.c.

36{
37 PVOID pMutex = NULL;
38
39 // Make sure we only specify the correct flags
40 if (flags != 0)
41 {
42 return SYMCRYPT_INVALID_ARGUMENT;
43 }
44
45#if SYMCRYPT_CPU_AMD64
46 if ( !SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_CMPXCHG16B ) )
47 {
48 pMutex = SymCryptCallbackAllocateMutexFastInproc();
49 if( pMutex == NULL )
50 {
51 return SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
52 }
53 }
54#elif SYMCRYPT_CPU_ARM64 // Arm64 always has support for CAS128 - so never need a lock
55#else // 32b and generic platforms will always need to use a lock
56 pMutex = SymCryptCallbackAllocateMutexFastInproc();
57 if( pMutex == NULL )
58 {
59 return SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
60 }
61#endif
62 pSession->pMutex = pMutex;
63
64 // This represents that the message numbers 1-64 inclusive have not yet been successfully use in decryption
65 pSession->replayState.replayMask = 0;
66 pSession->replayState.messageNumber = 64;
67
68 pSession->senderId = senderId;
69 pSession->flags = 0;
70
71 return SYMCRYPT_NO_ERROR;
72}
SymCryptCallbackAllocateMutexFastInproc
PVOID SYMCRYPT_CALL SymCryptCallbackAllocateMutexFastInproc(void)
pMutex
PVOID pMutex
Definition: symcrypt_internal.h:2080
senderId
UINT32 senderId
Definition: symcrypt_internal.h:2072

◆ SymCryptSessionSenderInit()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSessionSenderInit ( _Inout_ PSYMCRYPT_SESSION  pSession,
UINT32  senderId,
UINT32  flags 
)

Definition at line 11 of file session.c.

15{
16 // Make sure we only specify the correct flags
17 if (flags != 0)
18 {
19 return SYMCRYPT_INVALID_ARGUMENT;
20 }
21
22 pSession->replayState.messageNumber = 0;
23 pSession->senderId = senderId;
24 pSession->flags = SYMCRYPT_FLAG_SESSION_ENCRYPT;
25 pSession->pMutex = NULL;
26
27 return SYMCRYPT_NO_ERROR;
28}

◆ SymCryptSha1()

VOID SYMCRYPT_CALL SymCryptSha1 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA1_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha1Selftest().

◆ SymCryptSha1Append()

VOID SYMCRYPT_CALL SymCryptSha1Append ( _Inout_ PSYMCRYPT_SHA1_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 91 of file sha1.c.

95{
96 SymCryptHashAppendInternal( SymCryptSha1Algorithm, (PSYMCRYPT_COMMON_HASH_STATE)pState, pbData, cbData );
97}
SymCryptSha1Algorithm
const PCSYMCRYPT_HASH SymCryptSha1Algorithm
Definition: sha1.c:29

◆ SymCryptSha1Init()

VOID SYMCRYPT_CALL SymCryptSha1Init ( _Out_ PSYMCRYPT_SHA1_STATE  pState)

Definition at line 68 of file sha1.c.

69{
70 SYMCRYPT_SET_MAGIC( pState );
71
72 pState->dataLengthL = 0;
73 pState->dataLengthH = 0;
74 pState->bytesInBuffer = 0;
75
76 memcpy( &pState->chain.H[0], &sha1InitialState[0], sizeof( sha1InitialState ) );
77
78 //
79 // There is no need to initialize the buffer part of the state as that will be
80 // filled before it is used.
81 //
82}
sha1InitialState
static const UINT32 sha1InitialState[5]
Definition: sha1.c:42

Referenced by SymCryptSha1Result().

◆ SymCryptSha1Result()

VOID SYMCRYPT_CALL SymCryptSha1Result ( _Inout_ PSYMCRYPT_SHA1_STATE  pState,
_Out_writes_(SYMCRYPT_SHA1_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 106 of file sha1.c.

109{
110 UINT32 bytesInBuffer;
111 SIZE_T tmp;
112
113 //
114 // SHA-1 uses almost the MD4 padding, except that the length in the padding is stored
115 // MSBFirst, rather than LSBFirst.
116 // As SHA-256 has a dedicated (fast) padding anyway, there is no gain to create a
117 // common padding routine for SHA-1 as it wouldn't be shared by anyone right now.
118 //
119 SYMCRYPT_CHECK_MAGIC( pState );
120
121 bytesInBuffer = (UINT32)(pState->bytesInBuffer);
122
123 //
124 // The buffer is never completely full, so we can always put the first
125 // padding byte in.
126 //
127 pState->buffer[bytesInBuffer++] = 0x80;
128
129 if( bytesInBuffer > 64-8 ) {
130 //
131 // No room for the rest of the padding. Pad with zeroes & process block
132 // bytesInBuffer is at most 64, so we do not have an integer underflow
133 //
134 memset( &pState->buffer[bytesInBuffer], 0, 64-bytesInBuffer );
135 SymCryptSha1AppendBlocks( &pState->chain, pState->buffer, 64, &tmp );
136 bytesInBuffer = 0;
137 }
138
139 //
140 // Set rest of padding
141 // At this point bytesInBuffer <= 64-8, so we don't have an underflow
142 // We wipe to the end of the buffer as it is 16-aligned,
143 // and it is faster to wipe to an aligned point
144 //
145 memset( &pState->buffer[bytesInBuffer], 0, 64-bytesInBuffer );
146 SYMCRYPT_STORE_MSBFIRST64( &pState->buffer[64-8], pState->dataLengthL * 8 );
147
148 //
149 // Process the final block
150 //
151 SymCryptSha1AppendBlocks( &pState->chain, pState->buffer, 64, &tmp );
152
153 //
154 // Write the output in the correct byte order
155 //
156 SymCryptUint32ToMsbFirst( &pState->chain.H[0], pbResult, 5 );
157
158 //
159 // Wipe & re-initialize
160 // We have to wipe the whole state because the Init call
161 // might be optimized away by a smart compiler.
162 //
163 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
164 SymCryptSha1Init( pState );
165}
SymCryptUint32ToMsbFirst
FORCEINLINE VOID SYMCRYPT_CALL SymCryptUint32ToMsbFirst(_In_reads_(cuData) PCUINT32 puData, _Out_writes_(4 *cuData) PBYTE pbResult, SIZE_T cuData)
Definition: sc_lib.h:405
SymCryptSha1Init
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha1Init(_Out_ PSYMCRYPT_SHA1_STATE pState)
Definition: sha1.c:68
SymCryptSha1AppendBlocks
VOID SYMCRYPT_CALL SymCryptSha1AppendBlocks(_Inout_ SYMCRYPT_SHA1_CHAINING_STATE *pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T *pcbRemaining)
Definition: sha1.c:230

◆ SymCryptSha1Selftest()

VOID SYMCRYPT_CALL SymCryptSha1Selftest ( void  )

Definition at line 461 of file sha1.c.

462{
463 BYTE result[SYMCRYPT_SHA1_RESULT_SIZE];
464
465 SymCryptSha1( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
466
467 SymCryptInjectError( result, sizeof( result ) );
468
469 if( memcmp( result, sha1KATAnswer, sizeof( result ) ) != 0 ) {
470 SymCryptFatal( 'SHA1' );
471 }
472}
sha1KATAnswer
static const BYTE sha1KATAnswer[20]
Definition: sha1.c:451
SYMCRYPT_SHA1_RESULT_SIZE
#define SYMCRYPT_SHA1_RESULT_SIZE
Definition: symcrypt.h:1090
SymCryptSha1
VOID SYMCRYPT_CALL SymCryptSha1(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA1_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha1StateCopy()

VOID SYMCRYPT_CALL SymCryptSha1StateCopy ( _In_ PCSYMCRYPT_SHA1_STATE  pSrc,
_Out_ PSYMCRYPT_SHA1_STATE  pDst 
)

◆ SymCryptSha1StateExport()

VOID SYMCRYPT_CALL SymCryptSha1StateExport ( _In_ PCSYMCRYPT_SHA1_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA1_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 371 of file sha1.c.

374{
375 SYMCRYPT_ALIGN SYMCRYPT_SHA1_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
376 C_ASSERT( sizeof( blob ) == SYMCRYPT_SHA1_STATE_EXPORT_SIZE );
377
378 SYMCRYPT_CHECK_MAGIC( pState );
379
380 SymCryptWipeKnownSize( &blob, sizeof( blob ) ); // wipe to avoid any data leakage
381
382 blob.header.magic = SYMCRYPT_BLOB_MAGIC;
383 blob.header.size = SYMCRYPT_SHA1_STATE_EXPORT_SIZE;
384 blob.header.type = SymCryptBlobTypeSha1State;
385
386 //
387 // Copy the relevant data. Buffer will be 0-padded.
388 //
389
390 SymCryptUint32ToMsbFirst( &pState->chain.H[0], &blob.chain[0], 5 );
391 blob.dataLength = pState->dataLengthL;
392 memcpy( &blob.buffer[0], &pState->buffer[0], blob.dataLength & 0x3f );
393
394 SYMCRYPT_ASSERT( (PCBYTE) &blob + sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ) == (PCBYTE) &blob.trailer );
395 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), &blob.trailer.checksum[0] );
396
397 memcpy( pbBlob, &blob, sizeof( blob ) );
398
399//cleanup:
400 SymCryptWipeKnownSize( &blob, sizeof( blob ) );
401 return;
402}
SymCryptBlobTypeSha1State
@ SymCryptBlobTypeSha1State
Definition: sc_lib.h:1064
_SYMCRYPT_SHA1_STATE_EXPORT_BLOB
Definition: sc_lib.h:1131
SYMCRYPT_SHA1_STATE_EXPORT_SIZE
#define SYMCRYPT_SHA1_STATE_EXPORT_SIZE
Definition: symcrypt_internal.h:2182

◆ SymCryptSha1StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha1StateImport ( _Out_ PSYMCRYPT_SHA1_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA1_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 406 of file sha1.c.

409{
410 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
411 SYMCRYPT_ALIGN SYMCRYPT_SHA1_STATE_EXPORT_BLOB blob; // local copy to have proper alignment.
412 BYTE checksum[8];
413
414 C_ASSERT( sizeof( blob ) == SYMCRYPT_SHA1_STATE_EXPORT_SIZE );
415 memcpy( &blob, pbBlob, sizeof( blob ) );
416
417 if( blob.header.magic != SYMCRYPT_BLOB_MAGIC ||
418 blob.header.size != SYMCRYPT_SHA1_STATE_EXPORT_SIZE ||
419 blob.header.type != SymCryptBlobTypeSha1State )
420 {
421 scError = SYMCRYPT_INVALID_BLOB;
422 goto cleanup;
423 }
424
425 SymCryptMarvin32( SymCryptMarvin32DefaultSeed, (PCBYTE) &blob, sizeof( blob ) - sizeof( SYMCRYPT_BLOB_TRAILER ), checksum );
426 if( memcmp( checksum, &blob.trailer.checksum[0], 8 ) != 0 )
427 {
428 scError = SYMCRYPT_INVALID_BLOB;
429 goto cleanup;
430 }
431
432 SymCryptMsbFirstToUint32( &blob.chain[0], &pState->chain.H[0], 5 );
433 pState->dataLengthL = blob.dataLength;
434 pState->dataLengthH = 0;
435 pState->bytesInBuffer = blob.dataLength & 0x3f;
436 memcpy( &pState->buffer[0], &blob.buffer[0], pState->bytesInBuffer );
437
438 SYMCRYPT_SET_MAGIC( pState );
439
440cleanup:
441 SymCryptWipeKnownSize( &blob, sizeof(blob) );
442 return scError;
443}
SymCryptMsbFirstToUint32
FORCEINLINE VOID SYMCRYPT_CALL SymCryptMsbFirstToUint32(_In_reads_(4 *cuResult) PCBYTE pbData, _Out_writes_(cuResult) PUINT32 puResult, SIZE_T cuResult)
Definition: sc_lib.h:422

◆ SymCryptSha224()

VOID SYMCRYPT_CALL SymCryptSha224 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA224_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha224Selftest().

◆ SymCryptSha224Append()

VOID SYMCRYPT_CALL SymCryptSha224Append ( _Inout_ PSYMCRYPT_SHA224_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 247 of file sha256.c.

251{
252 SymCryptSha256Append( (PSYMCRYPT_SHA256_STATE)pState, pbData, cbData );
253}
SymCryptSha256Append
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha256Append(_Inout_ PSYMCRYPT_SHA256_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: sha256.c:171
PSYMCRYPT_SHA256_STATE
* PSYMCRYPT_SHA256_STATE
Definition: symcrypt_internal.h:817

◆ SymCryptSha224Init()

VOID SYMCRYPT_CALL SymCryptSha224Init ( _Out_ PSYMCRYPT_SHA224_STATE  pState)

Definition at line 148 of file sha256.c.

149{
150 SYMCRYPT_SET_MAGIC( pState );
151
152 pState->dataLengthL = 0;
153 //pState->dataLengthH = 0; // not used
154 pState->bytesInBuffer = 0;
155
156 memcpy( &pState->chain.H[0], &sha224InitialState[0], sizeof( sha224InitialState ) );
157
158 //
159 // There is no need to initialize the buffer part of the state as that will be
160 // filled before it is used.
161 //
162}
sha224InitialState
static const UINT32 sha224InitialState[8]
Definition: sha256.c:77

Referenced by SymCryptSha224Result().

◆ SymCryptSha224Result()

VOID SYMCRYPT_CALL SymCryptSha224Result ( _Inout_ PSYMCRYPT_SHA224_STATE  pState,
_Out_writes_(SYMCRYPT_SHA224_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 330 of file sha256.c.

333{
334 SYMCRYPT_ALIGN BYTE sha256Result[SYMCRYPT_SHA256_RESULT_SIZE]; // Buffer for SHA-256 output
335
336 //
337 // The SHA-3224 result is the first 28 bytes of the SHA-256 result of our state
338 //
339 SymCryptSha256Result( (PSYMCRYPT_SHA256_STATE)pState, sha256Result );
340 memcpy( pbResult, sha256Result, SYMCRYPT_SHA224_RESULT_SIZE );
341
342 //
343 // The buffer was already wiped by the SymCryptSha256Result function, we
344 // just have to re-initialize for SHA-224
345 //
346 SymCryptSha224Init( pState );
347
348 SymCryptWipeKnownSize( sha256Result, sizeof( sha256Result ) );
349}
SymCryptSha256Result
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha256Result(_Inout_ PSYMCRYPT_SHA256_STATE pState, _Out_writes_(SYMCRYPT_SHA256_RESULT_SIZE) PBYTE pbResult)
Definition: sha256.c:262
SymCryptSha224Init
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha224Init(_Out_ PSYMCRYPT_SHA224_STATE pState)
Definition: sha256.c:148
SYMCRYPT_SHA256_RESULT_SIZE
#define SYMCRYPT_SHA256_RESULT_SIZE
Definition: symcrypt.h:1222
SYMCRYPT_SHA224_RESULT_SIZE
#define SYMCRYPT_SHA224_RESULT_SIZE
Definition: symcrypt.h:1157

◆ SymCryptSha224Selftest()

VOID SYMCRYPT_CALL SymCryptSha224Selftest ( void  )

Definition at line 511 of file sha256.c.

512{
513 BYTE result[SYMCRYPT_SHA224_RESULT_SIZE];
514
515 SymCryptSha224( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
516
517 SymCryptInjectError( result, sizeof( result ) );
518
519 if( memcmp( result, SymCryptSha224KATAnswer, sizeof( result ) ) != 0 ) {
520 SymCryptFatal( 'SH22' );
521 }
522}
SymCryptSha224KATAnswer
const BYTE SymCryptSha224KATAnswer[28]
Definition: sha256.c:502
SymCryptSha224
VOID SYMCRYPT_CALL SymCryptSha224(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA224_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha224StateCopy()

VOID SYMCRYPT_CALL SymCryptSha224StateCopy ( _In_ PCSYMCRYPT_SHA224_STATE  pSrc,
_Out_ PSYMCRYPT_SHA224_STATE  pDst 
)

◆ SymCryptSha224StateExport()

VOID SYMCRYPT_CALL SymCryptSha224StateExport ( _In_ PCSYMCRYPT_SHA224_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA224_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

◆ SymCryptSha224StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha224StateImport ( _Out_ PSYMCRYPT_SHA224_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA224_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 463 of file sha256.c.

466{
467 return SymCryptSha256StateImportCore( (PSYMCRYPT_SHA256_STATE)pState, pbBlob, SymCryptBlobTypeSha224State );
468}
SymCryptBlobTypeSha224State
@ SymCryptBlobTypeSha224State
Definition: sc_lib.h:1071
SymCryptSha256StateImportCore
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha256StateImportCore(_Out_ PSYMCRYPT_SHA256_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA256_STATE_EXPORT_SIZE) PCBYTE pbBlob, _In_ UINT32 type)
Definition: sha256.c:411

◆ SymCryptSha256()

VOID SYMCRYPT_CALL SymCryptSha256 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha256Selftest().

◆ SymCryptSha256Append()

VOID SYMCRYPT_CALL SymCryptSha256Append ( _Inout_ PSYMCRYPT_SHA256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 171 of file sha256.c.

175{
176 UINT32 bytesInBuffer;
177 UINT32 freeInBuffer;
178 SIZE_T tmp;
179
180 SYMCRYPT_CHECK_MAGIC( pState );
181
182 pState->dataLengthL += cbData; // dataLengthH is not used...
183
184 bytesInBuffer = pState->bytesInBuffer;
185
186 //
187 // If previous data in buffer, buffer new input and transform if possible.
188 //
189 if( bytesInBuffer > 0 )
190 {
191 SYMCRYPT_ASSERT( SYMCRYPT_SHA256_INPUT_BLOCK_SIZE > bytesInBuffer );
192
193 freeInBuffer = SYMCRYPT_SHA256_INPUT_BLOCK_SIZE - bytesInBuffer;
194 if( cbData < freeInBuffer )
195 {
196 //
197 // All the data will fit in the buffer.
198 // We don't do anything here.
199 // As cbData < inputBlockSize the bulk data processing is skipped,
200 // and the data will be copied to the buffer at the end
201 // of this code.
202 } else {
203 //
204 // Enough data to fill the whole buffer & process it
205 //
206 memcpy(&pState->buffer[bytesInBuffer], pbData, freeInBuffer);
207 pbData += freeInBuffer;
208 cbData -= freeInBuffer;
209 SymCryptSha256AppendBlocks( &pState->chain, &pState->buffer[0], SYMCRYPT_SHA256_INPUT_BLOCK_SIZE, &tmp );
210
211 bytesInBuffer = 0;
212 }
213 }
214
215 //
216 // Internal buffer is empty; process all remaining whole blocks in the input
217 //
218 if( cbData >= SYMCRYPT_SHA256_INPUT_BLOCK_SIZE )
219 {
220 SymCryptSha256AppendBlocks( &pState->chain, pbData, cbData, &tmp );
221 SYMCRYPT_ASSERT( tmp < SYMCRYPT_SHA256_INPUT_BLOCK_SIZE );
222 pbData += cbData - tmp;
223 cbData = tmp;
224 }
225
226 SYMCRYPT_ASSERT( cbData < SYMCRYPT_SHA256_INPUT_BLOCK_SIZE );
227
228 //
229 // buffer remaining input if necessary.
230 //
231 if( cbData > 0 )
232 {
233 memcpy( &pState->buffer[bytesInBuffer], pbData, cbData );
234 bytesInBuffer += (UINT32) cbData;
235 }
236
237 pState->bytesInBuffer = bytesInBuffer;
238}
SymCryptSha256AppendBlocks
VOID SYMCRYPT_CALL SymCryptSha256AppendBlocks(_Inout_ SYMCRYPT_SHA256_CHAINING_STATE *pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T *pcbRemaining)
Definition: sha256.c:1812
SYMCRYPT_SHA256_INPUT_BLOCK_SIZE
#define SYMCRYPT_SHA256_INPUT_BLOCK_SIZE
Definition: symcrypt.h:1223

Referenced by SymCryptSha224Append().

◆ SymCryptSha256Init()

VOID SYMCRYPT_CALL SymCryptSha256Init ( _Out_ PSYMCRYPT_SHA256_STATE  pState)

Definition at line 125 of file sha256.c.

126{
127 SYMCRYPT_SET_MAGIC( pState );
128
129 pState->dataLengthL = 0;
130 //pState->dataLengthH = 0; // not used
131 pState->bytesInBuffer = 0;
132
133 memcpy( &pState->chain.H[0], &sha256InitialState[0], sizeof( sha256InitialState ) );
134
135 //
136 // There is no need to initialize the buffer part of the state as that will be
137 // filled before it is used.
138 //
139}
sha256InitialState
static const UINT32 sha256InitialState[8]
Definition: sha256.c:88

◆ SymCryptSha256Result()

VOID SYMCRYPT_CALL SymCryptSha256Result ( _Inout_ PSYMCRYPT_SHA256_STATE  pState,
_Out_writes_(SYMCRYPT_SHA256_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 262 of file sha256.c.

265{
266 //
267 // We don't use the common padding code as that is slower, and SHA-256 is very frequently used in
268 // performance-sensitive areas.
269 //
270 UINT32 bytesInBuffer;
271 SIZE_T tmp;
272
273 SYMCRYPT_CHECK_MAGIC( pState );
274
275 bytesInBuffer = pState->bytesInBuffer;
276
277 //
278 // The buffer is never completely full, so we can always put the first
279 // padding byte in.
280 //
281 pState->buffer[bytesInBuffer++] = 0x80;
282
283 if( bytesInBuffer > 64-8 ) {
284 //
285 // No room for the rest of the padding. Pad with zeroes & process block
286 // bytesInBuffer is at most 64, so we do not have an integer underflow
287 //
288 SymCryptWipe( &pState->buffer[bytesInBuffer], 64-bytesInBuffer );
289 SymCryptSha256AppendBlocks( &pState->chain, pState->buffer, 64, &tmp );
290 bytesInBuffer = 0;
291 }
292
293 //
294 // Set rest of padding
295 // At this point bytesInBuffer <= 64-8, so we don't have an underflow
296 // We wipe to the end of the buffer as it is 16-aligned,
297 // and it is faster to wipe to an aligned point
298 //
299 SymCryptWipe( &pState->buffer[bytesInBuffer], 64-bytesInBuffer );
300 SYMCRYPT_STORE_MSBFIRST64( &pState->buffer[64-8], pState->dataLengthL * 8 );
301
302 //
303 // Process the final block
304 //
305 SymCryptSha256AppendBlocks( &pState->chain, pState->buffer, 64, &tmp );
306
307 //
308 // Write the output in the correct byte order
309 //
310 SymCryptUint32ToMsbFirst( &pState->chain.H[0], pbResult, 8 );
311
312 //
313 // Wipe & re-initialize
314 // We have to wipe the whole state because the Init call
315 // might be optimized away by a smart compiler.
316 //
317 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
318
319 memcpy( &pState->chain.H[0], &sha256InitialState[0], sizeof( sha256InitialState ) );
320 SYMCRYPT_SET_MAGIC( pState );
321}

Referenced by SymCryptSha224Result().

◆ SymCryptSha256Selftest()

VOID SYMCRYPT_CALL SymCryptSha256Selftest ( void  )

Definition at line 485 of file sha256.c.

486{
487 BYTE result[SYMCRYPT_SHA256_RESULT_SIZE];
488
489 SymCryptSha256( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
490
491 SymCryptInjectError( result, sizeof( result ) );
492
493 if( memcmp( result, SymCryptSha256KATAnswer, sizeof( result ) ) != 0 ) {
494 SymCryptFatal( 'SH25' );
495 }
496}
SymCryptSha256KATAnswer
const BYTE SymCryptSha256KATAnswer[32]
Definition: sha256.c:476
SymCryptSha256
VOID SYMCRYPT_CALL SymCryptSha256(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA256_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha256StateCopy()

VOID SYMCRYPT_CALL SymCryptSha256StateCopy ( _In_ PCSYMCRYPT_SHA256_STATE  pSrc,
_Out_ PSYMCRYPT_SHA256_STATE  pDst 
)

◆ SymCryptSha256StateExport()

VOID SYMCRYPT_CALL SymCryptSha256StateExport ( _In_ PCSYMCRYPT_SHA256_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA256_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 391 of file sha256.c.

394{
395 SymCryptSha256StateExportCore( pState, pbBlob, SymCryptBlobTypeSha256State );
396}
SymCryptBlobTypeSha256State
@ SymCryptBlobTypeSha256State
Definition: sc_lib.h:1065
SymCryptSha256StateExportCore
VOID SYMCRYPT_CALL SymCryptSha256StateExportCore(_In_ PCSYMCRYPT_SHA256_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA256_STATE_EXPORT_SIZE) PBYTE pbBlob, _In_ UINT32 type)
Definition: sha256.c:354

◆ SymCryptSha256StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha256StateImport ( _Out_ PSYMCRYPT_SHA256_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA256_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 453 of file sha256.c.

456{
457 return SymCryptSha256StateImportCore( pState, pbBlob, SymCryptBlobTypeSha256State );
458}

◆ SymCryptSha384()

VOID SYMCRYPT_CALL SymCryptSha384 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA384_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha384Selftest().

◆ SymCryptSha384Append()

VOID SYMCRYPT_CALL SymCryptSha384Append ( _Inout_ PSYMCRYPT_SHA384_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 370 of file sha512.c.

374{
375
376 SymCryptSha512Append( (PSYMCRYPT_SHA512_STATE)pState, pbData, cbData );
377
378}
SymCryptSha512Append
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha512Append(_Inout_ PSYMCRYPT_SHA512_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: sha512.c:294
PSYMCRYPT_SHA512_STATE
* PSYMCRYPT_SHA512_STATE
Definition: symcrypt_internal.h:857

◆ SymCryptSha384Init()

VOID SYMCRYPT_CALL SymCryptSha384Init ( _Out_ PSYMCRYPT_SHA384_STATE  pState)

Definition at line 234 of file sha512.c.

235{
236 SYMCRYPT_SET_MAGIC( pState );
237
238 pState->dataLengthH = 0;
239 pState->dataLengthL = 0;
240 pState->bytesInBuffer = 0;
241
242 memcpy( &pState->chain.H[0], &SymCryptSha384InitialState[0], sizeof( SymCryptSha384InitialState ) );
243
244 //
245 // There is no need to initialize the buffer part of the state as that will be
246 // filled before it is used.
247 //
248}
SymCryptSha384InitialState
const UINT64 SymCryptSha384InitialState[8]
Definition: sha512.c:79

Referenced by SymCryptSha384Result().

◆ SymCryptSha384Result()

VOID SYMCRYPT_CALL SymCryptSha384Result ( _Inout_ PSYMCRYPT_SHA384_STATE  pState,
_Out_writes_(SYMCRYPT_SHA384_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 460 of file sha512.c.

463{
464 //
465 // For simplicity we re-use SymCryptSha512Result. This is slightly slower,
466 // but SHA-384 isn't used that much.
467 //
468 SYMCRYPT_ALIGN BYTE sha512Result[SYMCRYPT_SHA512_RESULT_SIZE]; // Buffer for SHA-512 output
469
470 //
471 // The SHA-384 result is the first 48 bytes of the SHA-512 result of our state
472 //
473 SymCryptSha512Result( (PSYMCRYPT_SHA512_STATE)pState, sha512Result );
474 memcpy( pbResult, sha512Result, SYMCRYPT_SHA384_RESULT_SIZE );
475
476 //
477 // The buffer was already wiped by the SymCryptSha512Result function, we
478 // just have to re-initialize for SHA-384
479 //
480 SymCryptSha384Init( pState );
481
482 SymCryptWipeKnownSize( sha512Result, sizeof( sha512Result ) );
483}
SymCryptSha384Init
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha384Init(_Out_ PSYMCRYPT_SHA384_STATE pState)
Definition: sha512.c:234
SymCryptSha512Result
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha512Result(_Inout_ PSYMCRYPT_SHA512_STATE pState, _Out_writes_(SYMCRYPT_SHA512_RESULT_SIZE) PBYTE pbResult)
Definition: sha512.c:406
SYMCRYPT_SHA384_RESULT_SIZE
#define SYMCRYPT_SHA384_RESULT_SIZE
Definition: symcrypt.h:1287
SYMCRYPT_SHA512_RESULT_SIZE
#define SYMCRYPT_SHA512_RESULT_SIZE
Definition: symcrypt.h:1352

◆ SymCryptSha384Selftest()

VOID SYMCRYPT_CALL SymCryptSha384Selftest ( void  )

Definition at line 740 of file sha512.c.

741{
742 BYTE result[SYMCRYPT_SHA384_RESULT_SIZE];
743
744 SymCryptSha384( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
745
746 SymCryptInjectError( result, sizeof( result ) );
747
748 if( memcmp( result, SymCryptSha384KATAnswer, sizeof( result ) ) != 0 ) {
749 SymCryptFatal( 'SH38' );
750 }
751}
SymCryptSha384KATAnswer
const BYTE SymCryptSha384KATAnswer[48]
Definition: sha512.c:728
SymCryptSha384
VOID SYMCRYPT_CALL SymCryptSha384(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA384_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha384StateCopy()

VOID SYMCRYPT_CALL SymCryptSha384StateCopy ( _In_ PCSYMCRYPT_SHA384_STATE  pSrc,
_Out_ PSYMCRYPT_SHA384_STATE  pDst 
)

◆ SymCryptSha384StateExport()

VOID SYMCRYPT_CALL SymCryptSha384StateExport ( _In_ PCSYMCRYPT_SHA384_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA384_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 584 of file sha512.c.

587{
588 SymCryptSha512StateExportCore( (PCSYMCRYPT_SHA512_STATE)pState, pbBlob, SymCryptBlobTypeSha384State );
589}
SymCryptBlobTypeSha384State
@ SymCryptBlobTypeSha384State
Definition: sc_lib.h:1066
SymCryptSha512StateExportCore
VOID SYMCRYPT_CALL SymCryptSha512StateExportCore(_In_ PCSYMCRYPT_SHA512_STATE pState, _Out_writes_bytes_(SYMCRYPT_SHA512_STATE_EXPORT_SIZE) PBYTE pbBlob, _In_ UINT32 type)
Definition: sha512.c:538
PCSYMCRYPT_SHA512_STATE
const SYMCRYPT_SHA512_STATE * PCSYMCRYPT_SHA512_STATE
Definition: symcrypt_internal.h:858

◆ SymCryptSha384StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha384StateImport ( _Out_ PSYMCRYPT_SHA384_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA384_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 663 of file sha512.c.

666{
667 return SymCryptSha512StateImportCore( (PSYMCRYPT_SHA512_STATE)pState, pbBlob, SymCryptBlobTypeSha384State );
668}
SymCryptSha512StateImportCore
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512StateImportCore(_Out_ PSYMCRYPT_SHA512_STATE pState, _In_reads_bytes_(SYMCRYPT_SHA512_STATE_EXPORT_SIZE) PCBYTE pbBlob, _In_ UINT32 type)
Definition: sha512.c:612

◆ SymCryptSha3_224()

VOID SYMCRYPT_CALL SymCryptSha3_224 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA3_224_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha3_224Selftest().

◆ SymCryptSha3_224Append()

VOID SYMCRYPT_CALL SymCryptSha3_224Append ( _Inout_ PSYMCRYPT_SHA3_224_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file sha3_224.c.

64{
65 SymCryptKeccakAppend(&pState->ks, pbData, cbData);
66}
SymCryptKeccakAppend
VOID SYMCRYPT_CALL SymCryptKeccakAppend(_Inout_ PSYMCRYPT_KECCAK_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: sha3.c:285

◆ SymCryptSha3_224Init()

VOID SYMCRYPT_CALL SymCryptSha3_224Init ( _Out_ PSYMCRYPT_SHA3_224_STATE  pState)

Definition at line 45 of file sha3_224.c.

46{
47 SymCryptKeccakInit(&pState->ks,
48 SYMCRYPT_SHA3_224_INPUT_BLOCK_SIZE,
49 SYMCRYPT_SHA3_PADDING_VALUE);
50
51 SYMCRYPT_SET_MAGIC(pState);
52}
SymCryptKeccakInit
VOID SYMCRYPT_CALL SymCryptKeccakInit(_Out_ PSYMCRYPT_KECCAK_STATE pState, UINT32 inputBlockSize, UINT8 padding)
Definition: sha3.c:174
SYMCRYPT_SHA3_PADDING_VALUE
#define SYMCRYPT_SHA3_PADDING_VALUE
Definition: sc_lib.h:1808

◆ SymCryptSha3_224Result()

VOID SYMCRYPT_CALL SymCryptSha3_224Result ( _Inout_ PSYMCRYPT_SHA3_224_STATE  pState,
_Out_writes_(SYMCRYPT_SHA3_224_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 74 of file sha3_224.c.

77{
78 SymCryptKeccakExtract(&pState->ks, pbResult, SYMCRYPT_SHA3_224_RESULT_SIZE, TRUE);
79}
SymCryptKeccakExtract
VOID SYMCRYPT_CALL SymCryptKeccakExtract(_Inout_ PSYMCRYPT_KECCAK_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe)
Definition: sha3.c:411
SYMCRYPT_SHA3_224_RESULT_SIZE
#define SYMCRYPT_SHA3_224_RESULT_SIZE
Definition: symcrypt.h:1560

◆ SymCryptSha3_224Selftest()

VOID SYMCRYPT_CALL SymCryptSha3_224Selftest ( void  )

Definition at line 129 of file sha3_224.c.

130{
131 BYTE result[SYMCRYPT_SHA3_224_RESULT_SIZE];
132
133 SymCryptSha3_224(SymCryptTestMsg3, sizeof(SymCryptTestMsg3), result);
134
135 SymCryptInjectError(result, sizeof(result));
136
137 if (memcmp(result, sha3_224KATAnswer, sizeof(result)) != 0)
138 {
139 SymCryptFatal('SHA3');
140 }
141}
sha3_224KATAnswer
static const BYTE sha3_224KATAnswer[28]
Definition: sha3_224.c:120
SymCryptSha3_224
VOID SYMCRYPT_CALL SymCryptSha3_224(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_224_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha3_224StateCopy()

VOID SYMCRYPT_CALL SymCryptSha3_224StateCopy ( _In_ PCSYMCRYPT_SHA3_224_STATE  pSrc,
_Out_ PSYMCRYPT_SHA3_224_STATE  pDst 
)

◆ SymCryptSha3_224StateExport()

VOID SYMCRYPT_CALL SymCryptSha3_224StateExport ( _In_ PCSYMCRYPT_SHA3_224_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA3_224_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 87 of file sha3_224.c.

90{
91 SYMCRYPT_CHECK_MAGIC(pState);
92 SymCryptKeccakStateExport(SymCryptBlobTypeSha3_224State, &pState->ks, pbBlob);
93}
SymCryptBlobTypeSha3_224State
@ SymCryptBlobTypeSha3_224State
Definition: sc_lib.h:1074
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: sha3.c:479

◆ SymCryptSha3_224StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_224StateImport ( _Out_ PSYMCRYPT_SHA3_224_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA3_224_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 101 of file sha3_224.c.

104{
105 SYMCRYPT_ERROR scError = SymCryptKeccakStateImport(SymCryptBlobTypeSha3_224State, &pState->ks, pbBlob);
106
107 if (scError == SYMCRYPT_NO_ERROR)
108 {
109 SYMCRYPT_SET_MAGIC(pState);
110 }
111
112 return scError;
113}
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: sha3.c:518

◆ SymCryptSha3_256()

VOID SYMCRYPT_CALL SymCryptSha3_256 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA3_256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha3_256Selftest().

◆ SymCryptSha3_256Append()

VOID SYMCRYPT_CALL SymCryptSha3_256Append ( _Inout_ PSYMCRYPT_SHA3_256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file sha3_256.c.

64{
65 SymCryptKeccakAppend(&pState->ks, pbData, cbData);
66}

Referenced by SymCryptMlKemkeyComputeEncapsulationKeyHash().

◆ SymCryptSha3_256Init()

VOID SYMCRYPT_CALL SymCryptSha3_256Init ( _Out_ PSYMCRYPT_SHA3_256_STATE  pState)

Definition at line 45 of file sha3_256.c.

46{
47 SymCryptKeccakInit(&pState->ks,
48 SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE,
49 SYMCRYPT_SHA3_PADDING_VALUE);
50
51 SYMCRYPT_SET_MAGIC(pState);
52}
SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE
#define SYMCRYPT_SHA3_256_INPUT_BLOCK_SIZE
Definition: symcrypt.h:1615

Referenced by SymCryptMlKemkeyComputeEncapsulationKeyHash().

◆ SymCryptSha3_256Result()

VOID SYMCRYPT_CALL SymCryptSha3_256Result ( _Inout_ PSYMCRYPT_SHA3_256_STATE  pState,
_Out_writes_(SYMCRYPT_SHA3_256_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 74 of file sha3_256.c.

77{
78 SymCryptKeccakExtract(&pState->ks, pbResult, SYMCRYPT_SHA3_256_RESULT_SIZE, TRUE);
79}
SYMCRYPT_SHA3_256_RESULT_SIZE
#define SYMCRYPT_SHA3_256_RESULT_SIZE
Definition: symcrypt.h:1614

Referenced by SymCryptMlKemkeyComputeEncapsulationKeyHash().

◆ SymCryptSha3_256Selftest()

VOID SYMCRYPT_CALL SymCryptSha3_256Selftest ( void  )

Definition at line 129 of file sha3_256.c.

130{
131 BYTE result[SYMCRYPT_SHA3_256_RESULT_SIZE];
132
133 SymCryptSha3_256(SymCryptTestMsg3, sizeof(SymCryptTestMsg3), result);
134
135 SymCryptInjectError(result, sizeof(result));
136
137 if (memcmp(result, sha3_256KATAnswer, sizeof(result)) != 0)
138 {
139 SymCryptFatal('SHA3');
140 }
141}
sha3_256KATAnswer
static const BYTE sha3_256KATAnswer[32]
Definition: sha3_256.c:120
SymCryptSha3_256
VOID SYMCRYPT_CALL SymCryptSha3_256(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_256_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha3_256StateCopy()

VOID SYMCRYPT_CALL SymCryptSha3_256StateCopy ( _In_ PCSYMCRYPT_SHA3_256_STATE  pSrc,
_Out_ PSYMCRYPT_SHA3_256_STATE  pDst 
)

◆ SymCryptSha3_256StateExport()

VOID SYMCRYPT_CALL SymCryptSha3_256StateExport ( _In_ PCSYMCRYPT_SHA3_256_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA3_256_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 87 of file sha3_256.c.

90{
91 SYMCRYPT_CHECK_MAGIC(pState);
92 SymCryptKeccakStateExport(SymCryptBlobTypeSha3_256State, &pState->ks, pbBlob);
93}
SymCryptBlobTypeSha3_256State
@ SymCryptBlobTypeSha3_256State
Definition: sc_lib.h:1068

◆ SymCryptSha3_256StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_256StateImport ( _Out_ PSYMCRYPT_SHA3_256_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA3_256_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 101 of file sha3_256.c.

104{
105 SYMCRYPT_ERROR scError = SymCryptKeccakStateImport(SymCryptBlobTypeSha3_256State, &pState->ks, pbBlob);
106
107 if (scError == SYMCRYPT_NO_ERROR)
108 {
109 SYMCRYPT_SET_MAGIC(pState);
110 }
111
112 return scError;
113}

◆ SymCryptSha3_384()

VOID SYMCRYPT_CALL SymCryptSha3_384 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA3_384_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha3_384Selftest().

◆ SymCryptSha3_384Append()

VOID SYMCRYPT_CALL SymCryptSha3_384Append ( _Inout_ PSYMCRYPT_SHA3_384_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file sha3_384.c.

64{
65 SymCryptKeccakAppend(&pState->ks, pbData, cbData);
66}

◆ SymCryptSha3_384Init()

VOID SYMCRYPT_CALL SymCryptSha3_384Init ( _Out_ PSYMCRYPT_SHA3_384_STATE  pState)

Definition at line 45 of file sha3_384.c.

46{
47 SymCryptKeccakInit(&pState->ks,
48 SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE,
49 SYMCRYPT_SHA3_PADDING_VALUE);
50
51 SYMCRYPT_SET_MAGIC(pState);
52}
SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE
#define SYMCRYPT_SHA3_384_INPUT_BLOCK_SIZE
Definition: symcrypt.h:1669

◆ SymCryptSha3_384Result()

VOID SYMCRYPT_CALL SymCryptSha3_384Result ( _Inout_ PSYMCRYPT_SHA3_384_STATE  pState,
_Out_writes_(SYMCRYPT_SHA3_384_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 74 of file sha3_384.c.

77{
78 SymCryptKeccakExtract(&pState->ks, pbResult, SYMCRYPT_SHA3_384_RESULT_SIZE, TRUE);
79}
SYMCRYPT_SHA3_384_RESULT_SIZE
#define SYMCRYPT_SHA3_384_RESULT_SIZE
Definition: symcrypt.h:1668

◆ SymCryptSha3_384Selftest()

VOID SYMCRYPT_CALL SymCryptSha3_384Selftest ( void  )

Definition at line 131 of file sha3_384.c.

132{
133 BYTE result[SYMCRYPT_SHA3_384_RESULT_SIZE];
134
135 SymCryptSha3_384(SymCryptTestMsg3, sizeof(SymCryptTestMsg3), result);
136
137 SymCryptInjectError(result, sizeof(result));
138
139 if (memcmp(result, sha3_384KATAnswer, sizeof(result)) != 0)
140 {
141 SymCryptFatal('SHA3');
142 }
143}
sha3_384KATAnswer
static const BYTE sha3_384KATAnswer[48]
Definition: sha3_384.c:120
SymCryptSha3_384
VOID SYMCRYPT_CALL SymCryptSha3_384(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_384_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha3_384StateCopy()

VOID SYMCRYPT_CALL SymCryptSha3_384StateCopy ( _In_ PCSYMCRYPT_SHA3_384_STATE  pSrc,
_Out_ PSYMCRYPT_SHA3_384_STATE  pDst 
)

◆ SymCryptSha3_384StateExport()

VOID SYMCRYPT_CALL SymCryptSha3_384StateExport ( _In_ PCSYMCRYPT_SHA3_384_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA3_384_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 87 of file sha3_384.c.

90{
91 SYMCRYPT_CHECK_MAGIC(pState);
92 SymCryptKeccakStateExport(SymCryptBlobTypeSha3_384State, &pState->ks, pbBlob);
93}
SymCryptBlobTypeSha3_384State
@ SymCryptBlobTypeSha3_384State
Definition: sc_lib.h:1069

◆ SymCryptSha3_384StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_384StateImport ( _Out_ PSYMCRYPT_SHA3_384_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA3_384_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 101 of file sha3_384.c.

104{
105 SYMCRYPT_ERROR scError = SymCryptKeccakStateImport(SymCryptBlobTypeSha3_384State, &pState->ks, pbBlob);
106
107 if (scError == SYMCRYPT_NO_ERROR)
108 {
109 SYMCRYPT_SET_MAGIC(pState);
110 }
111
112 return scError;
113}

◆ SymCryptSha3_512()

VOID SYMCRYPT_CALL SymCryptSha3_512 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA3_512_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptMlKemkeyExpandFromPrivateSeed(), and SymCryptSha3_512Selftest().

◆ SymCryptSha3_512Append()

VOID SYMCRYPT_CALL SymCryptSha3_512Append ( _Inout_ PSYMCRYPT_SHA3_512_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 60 of file sha3_512.c.

64{
65 SymCryptKeccakAppend(&pState->ks, pbData, cbData);
66}

Referenced by SymCryptMlKemEncapsulateInternal().

◆ SymCryptSha3_512Init()

VOID SYMCRYPT_CALL SymCryptSha3_512Init ( _Out_ PSYMCRYPT_SHA3_512_STATE  pState)

Definition at line 45 of file sha3_512.c.

46{
47 SymCryptKeccakInit(&pState->ks,
48 SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE,
49 SYMCRYPT_SHA3_PADDING_VALUE);
50
51 SYMCRYPT_SET_MAGIC(pState);
52}
SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE
#define SYMCRYPT_SHA3_512_INPUT_BLOCK_SIZE
Definition: symcrypt.h:1723

Referenced by SymCryptMlKemEncapsulateInternal().

◆ SymCryptSha3_512Result()

VOID SYMCRYPT_CALL SymCryptSha3_512Result ( _Inout_ PSYMCRYPT_SHA3_512_STATE  pState,
_Out_writes_(SYMCRYPT_SHA3_512_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 74 of file sha3_512.c.

77{
78 SymCryptKeccakExtract(&pState->ks, pbResult, SYMCRYPT_SHA3_512_RESULT_SIZE, TRUE);
79}
SYMCRYPT_SHA3_512_RESULT_SIZE
#define SYMCRYPT_SHA3_512_RESULT_SIZE
Definition: symcrypt.h:1722

Referenced by SymCryptMlKemEncapsulateInternal().

◆ SymCryptSha3_512Selftest()

VOID SYMCRYPT_CALL SymCryptSha3_512Selftest ( void  )

Definition at line 132 of file sha3_512.c.

133{
134 BYTE result[SYMCRYPT_SHA3_512_RESULT_SIZE];
135
136 SymCryptSha3_512(SymCryptTestMsg3, sizeof(SymCryptTestMsg3), result);
137
138 SymCryptInjectError(result, sizeof(result));
139
140 if (memcmp(result, sha3_512KATAnswer, sizeof(result)) != 0)
141 {
142 SymCryptFatal('SHA3');
143 }
144}
sha3_512KATAnswer
static const BYTE sha3_512KATAnswer[64]
Definition: sha3_512.c:119
SymCryptSha3_512
VOID SYMCRYPT_CALL SymCryptSha3_512(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA3_512_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha3_512StateCopy()

VOID SYMCRYPT_CALL SymCryptSha3_512StateCopy ( _In_ PCSYMCRYPT_SHA3_512_STATE  pSrc,
_Out_ PSYMCRYPT_SHA3_512_STATE  pDst 
)

◆ SymCryptSha3_512StateExport()

VOID SYMCRYPT_CALL SymCryptSha3_512StateExport ( _In_ PCSYMCRYPT_SHA3_512_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA3_512_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 87 of file sha3_512.c.

90{
91 SYMCRYPT_CHECK_MAGIC(pState);
92 SymCryptKeccakStateExport(SymCryptBlobTypeSha3_512State, &pState->ks, pbBlob);
93}
SymCryptBlobTypeSha3_512State
@ SymCryptBlobTypeSha3_512State
Definition: sc_lib.h:1070

◆ SymCryptSha3_512StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha3_512StateImport ( _Out_ PSYMCRYPT_SHA3_512_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA3_512_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 100 of file sha3_512.c.

103{
104 SYMCRYPT_ERROR scError = SymCryptKeccakStateImport(SymCryptBlobTypeSha3_512State, &pState->ks, pbBlob);
105
106 if (scError == SYMCRYPT_NO_ERROR)
107 {
108 SYMCRYPT_SET_MAGIC(pState);
109 }
110
111 return scError;
112}

◆ SymCryptSha512()

VOID SYMCRYPT_CALL SymCryptSha512 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA512_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha512Selftest().

◆ SymCryptSha512_224()

VOID SYMCRYPT_CALL SymCryptSha512_224 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA512_224_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha512_224Selftest().

◆ SymCryptSha512_224Append()

VOID SYMCRYPT_CALL SymCryptSha512_224Append ( _Inout_ PSYMCRYPT_SHA512_224_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 383 of file sha512.c.

387{
388 SymCryptSha512Append( (PSYMCRYPT_SHA512_STATE)pState, pbData, cbData );
389}

◆ SymCryptSha512_224Init()

VOID SYMCRYPT_CALL SymCryptSha512_224Init ( _Out_ PSYMCRYPT_SHA512_224_STATE  pState)

Definition at line 254 of file sha512.c.

255{
256 SYMCRYPT_SET_MAGIC( pState );
257
258 pState->dataLengthH = 0;
259 pState->dataLengthL = 0;
260 pState->bytesInBuffer = 0;
261
262 memcpy( &pState->chain.H[0], &SymCryptSha512_224InitialState[0], sizeof( SymCryptSha512_224InitialState ) );
263
264 //
265 // There is no need to initialize the buffer part of the state as that will be
266 // filled before it is used.
267 //
268}
SymCryptSha512_224InitialState
const UINT64 SymCryptSha512_224InitialState[8]
Definition: sha512.c:90

Referenced by SymCryptSha512_224Result().

◆ SymCryptSha512_224Result()

VOID SYMCRYPT_CALL SymCryptSha512_224Result ( _Inout_ PSYMCRYPT_SHA512_224_STATE  pState,
_Out_writes_(SYMCRYPT_SHA512_224_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 489 of file sha512.c.

492{
493 SYMCRYPT_ALIGN BYTE sha512Result[SYMCRYPT_SHA512_RESULT_SIZE]; // Buffer for SHA-512 output
494
495 //
496 // The SHA-512/224 result is the first 28 bytes of the SHA-512 result of our state
497 //
498 SymCryptSha512Result( (PSYMCRYPT_SHA512_STATE)pState, sha512Result );
499 memcpy( pbResult, sha512Result, SYMCRYPT_SHA512_224_RESULT_SIZE );
500
501 //
502 // The buffer was already wiped by the SymCryptSha512Result function, we
503 // just have to re-initialize for SHA-512/224
504 //
505 SymCryptSha512_224Init( pState );
506
507 SymCryptWipeKnownSize( sha512Result, sizeof( sha512Result ) );
508}
SymCryptSha512_224Init
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha512_224Init(_Out_ PSYMCRYPT_SHA512_224_STATE pState)
Definition: sha512.c:254
SYMCRYPT_SHA512_224_RESULT_SIZE
#define SYMCRYPT_SHA512_224_RESULT_SIZE
Definition: symcrypt.h:1420

◆ SymCryptSha512_224Selftest()

VOID SYMCRYPT_CALL SymCryptSha512_224Selftest ( void  )

Definition at line 767 of file sha512.c.

768{
769 BYTE result[SYMCRYPT_SHA512_224_RESULT_SIZE];
770
771 SymCryptSha512_224( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
772
773 SymCryptInjectError( result, sizeof( result ) );
774
775 if( memcmp( result, SymCryptSha512_224KATAnswer, sizeof( result ) ) != 0 ) {
776 SymCryptFatal( 'SH51' );
777 }
778}
SymCryptSha512_224KATAnswer
const BYTE SymCryptSha512_224KATAnswer[28]
Definition: sha512.c:757
SymCryptSha512_224
VOID SYMCRYPT_CALL SymCryptSha512_224(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA512_224_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha512_224StateCopy()

VOID SYMCRYPT_CALL SymCryptSha512_224StateCopy ( _In_ PCSYMCRYPT_SHA512_224_STATE  pSrc,
_Out_ PSYMCRYPT_SHA512_224_STATE  pDst 
)

◆ SymCryptSha512_224StateExport()

VOID SYMCRYPT_CALL SymCryptSha512_224StateExport ( _In_ PCSYMCRYPT_SHA512_224_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA512_224_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 593 of file sha512.c.

596{
597 SymCryptSha512StateExportCore( (PCSYMCRYPT_SHA512_STATE)pState, pbBlob, SymCryptBlobTypeSha512_224State );
598}
SymCryptBlobTypeSha512_224State
@ SymCryptBlobTypeSha512_224State
Definition: sc_lib.h:1072

◆ SymCryptSha512_224StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512_224StateImport ( _Out_ PSYMCRYPT_SHA512_224_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA512_224_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 672 of file sha512.c.

675{
676 return SymCryptSha512StateImportCore( (PSYMCRYPT_SHA512_STATE)pState, pbBlob, SymCryptBlobTypeSha512_224State );
677}

◆ SymCryptSha512_256()

VOID SYMCRYPT_CALL SymCryptSha512_256 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHA512_256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptSha512_256Selftest().

◆ SymCryptSha512_256Append()

VOID SYMCRYPT_CALL SymCryptSha512_256Append ( _Inout_ PSYMCRYPT_SHA512_256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 394 of file sha512.c.

398{
399 SymCryptSha512Append( (PSYMCRYPT_SHA512_STATE)pState, pbData, cbData );
400}

◆ SymCryptSha512_256Init()

VOID SYMCRYPT_CALL SymCryptSha512_256Init ( _Out_ PSYMCRYPT_SHA512_256_STATE  pState)

Definition at line 274 of file sha512.c.

275{
276 SYMCRYPT_SET_MAGIC( pState );
277
278 pState->dataLengthH = 0;
279 pState->dataLengthL = 0;
280 pState->bytesInBuffer = 0;
281
282 memcpy( &pState->chain.H[0], &SymCryptSha512_256InitialState[0], sizeof( SymCryptSha512_256InitialState ) );
283
284 //
285 // There is no need to initialize the buffer part of the state as that will be
286 // filled before it is used.
287 //
288}
SymCryptSha512_256InitialState
const UINT64 SymCryptSha512_256InitialState[8]
Definition: sha512.c:101

Referenced by SymCryptSha512_256Result().

◆ SymCryptSha512_256Result()

VOID SYMCRYPT_CALL SymCryptSha512_256Result ( _Inout_ PSYMCRYPT_SHA512_256_STATE  pState,
_Out_writes_(SYMCRYPT_SHA512_256_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 514 of file sha512.c.

517{
518 SYMCRYPT_ALIGN BYTE sha512Result[SYMCRYPT_SHA512_RESULT_SIZE]; // Buffer for SHA-512 output
519
520 //
521 // The SHA-512/256 result is the first 32 bytes of the SHA-512 result of our state
522 //
523 SymCryptSha512Result( (PSYMCRYPT_SHA512_STATE)pState, sha512Result );
524 memcpy( pbResult, sha512Result, SYMCRYPT_SHA512_256_RESULT_SIZE );
525
526 //
527 // The buffer was already wiped by the SymCryptSha512Result function, we
528 // just have to re-initialize for SHA-512/256
529 //
530 SymCryptSha512_256Init( pState );
531
532 SymCryptWipeKnownSize( sha512Result, sizeof( sha512Result ) );
533}
SymCryptSha512_256Init
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptSha512_256Init(_Out_ PSYMCRYPT_SHA512_256_STATE pState)
Definition: sha512.c:274
SYMCRYPT_SHA512_256_RESULT_SIZE
#define SYMCRYPT_SHA512_256_RESULT_SIZE
Definition: symcrypt.h:1488

◆ SymCryptSha512_256Selftest()

VOID SYMCRYPT_CALL SymCryptSha512_256Selftest ( void  )

Definition at line 794 of file sha512.c.

795{
796 BYTE result[SYMCRYPT_SHA512_256_RESULT_SIZE];
797
798 SymCryptSha512_256( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
799
800 SymCryptInjectError( result, sizeof( result ) );
801
802 if( memcmp( result, SymCryptSha512_256KATAnswer, sizeof( result ) ) != 0 ) {
803 SymCryptFatal( 'SH51' );
804 }
805}
SymCryptSha512_256KATAnswer
const BYTE SymCryptSha512_256KATAnswer[32]
Definition: sha512.c:784
SymCryptSha512_256
VOID SYMCRYPT_CALL SymCryptSha512_256(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA512_256_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha512_256StateCopy()

VOID SYMCRYPT_CALL SymCryptSha512_256StateCopy ( _In_ PCSYMCRYPT_SHA512_256_STATE  pSrc,
_Out_ PSYMCRYPT_SHA512_256_STATE  pDst 
)

◆ SymCryptSha512_256StateExport()

VOID SYMCRYPT_CALL SymCryptSha512_256StateExport ( _In_ PCSYMCRYPT_SHA512_256_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA512_256_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 602 of file sha512.c.

605{
606 SymCryptSha512StateExportCore( (PCSYMCRYPT_SHA512_STATE)pState, pbBlob, SymCryptBlobTypeSha512_256State );
607}
SymCryptBlobTypeSha512_256State
@ SymCryptBlobTypeSha512_256State
Definition: sc_lib.h:1073

◆ SymCryptSha512_256StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512_256StateImport ( _Out_ PSYMCRYPT_SHA512_256_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA512_256_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 681 of file sha512.c.

684{
685 return SymCryptSha512StateImportCore( (PSYMCRYPT_SHA512_STATE)pState, pbBlob, SymCryptBlobTypeSha512_256State );
686}

◆ SymCryptSha512Append()

VOID SYMCRYPT_CALL SymCryptSha512Append ( _Inout_ PSYMCRYPT_SHA512_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 294 of file sha512.c.

298{
299 UINT32 bytesInBuffer;
300 UINT32 freeInBuffer;
301 SIZE_T tmp;
302
303 SYMCRYPT_CHECK_MAGIC( pState );
304
305 pState->dataLengthL += cbData;
306 if( pState->dataLengthL < cbData ) {
307 pState->dataLengthH++;
308 }
309
310 bytesInBuffer = pState->bytesInBuffer;
311
312 //
313 // If previous data in buffer, buffer new input and transform if possible.
314 //
315 if( bytesInBuffer > 0 )
316 {
317 SYMCRYPT_ASSERT( SYMCRYPT_SHA512_INPUT_BLOCK_SIZE > bytesInBuffer );
318
319 freeInBuffer = SYMCRYPT_SHA512_INPUT_BLOCK_SIZE - bytesInBuffer;
320 if( cbData < freeInBuffer )
321 {
322 //
323 // All the data will fit in the buffer.
324 // We don't do anything here.
325 // As cbData < inputBlockSize the bulk data processing is skipped,
326 // and the data will be copied to the buffer at the end
327 // of this code.
328 } else {
329 //
330 // Enough data to fill the whole buffer & process it
331 //
332 memcpy(&pState->buffer[bytesInBuffer], pbData, freeInBuffer);
333 pbData += freeInBuffer;
334 cbData -= freeInBuffer;
335 SymCryptSha512AppendBlocks( &pState->chain, &pState->buffer[0], SYMCRYPT_SHA512_INPUT_BLOCK_SIZE, &tmp );
336
337 bytesInBuffer = 0;
338 }
339 }
340
341 //
342 // Internal buffer is empty; process all remaining whole blocks in the input
343 //
344 if( cbData >= SYMCRYPT_SHA512_INPUT_BLOCK_SIZE )
345 {
346 SymCryptSha512AppendBlocks( &pState->chain, pbData, cbData, &tmp );
347 SYMCRYPT_ASSERT( tmp < SYMCRYPT_SHA512_INPUT_BLOCK_SIZE );
348 pbData += cbData - tmp;
349 cbData = tmp;
350 }
351
352 SYMCRYPT_ASSERT( cbData < SYMCRYPT_SHA512_INPUT_BLOCK_SIZE );
353
354 //
355 // buffer remaining input if necessary.
356 //
357 if( cbData > 0 )
358 {
359 memcpy( &pState->buffer[bytesInBuffer], pbData, cbData );
360 bytesInBuffer += (UINT32) cbData;
361 }
362
363 pState->bytesInBuffer = bytesInBuffer;
364
365}
SymCryptSha512AppendBlocks
VOID SYMCRYPT_CALL SymCryptSha512AppendBlocks(_Inout_ SYMCRYPT_SHA512_CHAINING_STATE *pChain, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_ SIZE_T *pcbRemaining)
Definition: sha512.c:1643
SYMCRYPT_SHA512_INPUT_BLOCK_SIZE
#define SYMCRYPT_SHA512_INPUT_BLOCK_SIZE
Definition: symcrypt.h:1353

Referenced by SymCryptSha384Append(), SymCryptSha512_224Append(), and SymCryptSha512_256Append().

◆ SymCryptSha512Init()

VOID SYMCRYPT_CALL SymCryptSha512Init ( _Out_ PSYMCRYPT_SHA512_STATE  pState)

Definition at line 214 of file sha512.c.

215{
216 SYMCRYPT_SET_MAGIC( pState );
217
218 pState->dataLengthH = 0;
219 pState->dataLengthL = 0;
220 pState->bytesInBuffer = 0;
221
222 memcpy( &pState->chain.H[0], &SymCryptSha512InitialState[0], sizeof( SymCryptSha512InitialState ) );
223
224 //
225 // There is no need to initialize the buffer part of the state as that will be
226 // filled before it is used.
227 //
228}
SymCryptSha512InitialState
const UINT64 SymCryptSha512InitialState[8]
Definition: sha512.c:68

◆ SymCryptSha512Result()

VOID SYMCRYPT_CALL SymCryptSha512Result ( _Inout_ PSYMCRYPT_SHA512_STATE  pState,
_Out_writes_(SYMCRYPT_SHA512_RESULT_SIZE) PBYTE  pbResult 
)

Definition at line 406 of file sha512.c.

409{
410 UINT32 bytesInBuffer;
411 SIZE_T tmp;
412
413 SYMCRYPT_CHECK_MAGIC( pState );
414
415 bytesInBuffer = pState->bytesInBuffer;
416
417 //
418 // The buffer is never completely full, so we can always put the first
419 // padding byte in.
420 //
421 pState->buffer[bytesInBuffer++] = 0x80;
422
423 if( bytesInBuffer > 128-16 ) {
424 //
425 // No room for the rest of the padding. Pad with zeroes & process block
426 // bytesInBuffer is at most 128, so we do not have an integer underflow
427 //
428 SymCryptWipe( &pState->buffer[bytesInBuffer], 128-bytesInBuffer );
429 SymCryptSha512AppendBlocks( &pState->chain, pState->buffer, 128, &tmp );
430 bytesInBuffer = 0;
431 }
432
433 //
434 // Set rest of padding
435 // We wipe to the end of the buffer as it is 16-aligned,
436 // and it is faster to wipe to an aligned point
437 //
438 SymCryptWipe( &pState->buffer[bytesInBuffer], 128-bytesInBuffer );
439 SYMCRYPT_STORE_MSBFIRST64( &pState->buffer[128-16], (pState->dataLengthH << 3) + (pState->dataLengthL >> 61) );
440 SYMCRYPT_STORE_MSBFIRST64( &pState->buffer[128- 8], (pState->dataLengthL << 3) );
441
442 SymCryptSha512AppendBlocks( &pState->chain, pState->buffer, 128, &tmp );
443
444 SymCryptUint64ToMsbFirst( &pState->chain.H[0], pbResult, 8 );
445
446 //
447 // We have to wipe the whole state because the Init call
448 // might be optimized away by a smart compiler.
449 //
450 SymCryptWipeKnownSize( pState, sizeof( *pState ) );
451
452 SYMCRYPT_SET_MAGIC( pState );
453
454 memcpy( &pState->chain.H[0], &SymCryptSha512InitialState[0], sizeof( SymCryptSha512InitialState ) );
455 }
SymCryptUint64ToMsbFirst
FORCEINLINE VOID SYMCRYPT_CALL SymCryptUint64ToMsbFirst(_In_reads_(cuData) PCUINT64 puData, _Out_writes_(8 *cuData) PBYTE pbResult, SIZE_T cuData)
Definition: sc_lib.h:576

Referenced by SymCryptSha384Result(), SymCryptSha512_224Result(), and SymCryptSha512_256Result().

◆ SymCryptSha512Selftest()

VOID SYMCRYPT_CALL SymCryptSha512Selftest ( void  )

Definition at line 709 of file sha512.c.

710{
711 BYTE result[SYMCRYPT_SHA512_RESULT_SIZE];
712
713 SymCryptSha512( SymCryptTestMsg3, sizeof( SymCryptTestMsg3 ), result );
714
715 SymCryptInjectError( result, sizeof( result ) );
716
717 if( memcmp( result, SymCryptSha512KATAnswer, sizeof( result ) ) != 0 ) {
718 SymCryptFatal( 'SH51' );
719 }
720}
SymCryptSha512KATAnswer
const BYTE SymCryptSha512KATAnswer[64]
Definition: sha512.c:695
SymCryptSha512
VOID SYMCRYPT_CALL SymCryptSha512(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_SHA512_RESULT_SIZE) PBYTE pbResult)

◆ SymCryptSha512StateCopy()

VOID SYMCRYPT_CALL SymCryptSha512StateCopy ( _In_ PCSYMCRYPT_SHA512_STATE  pSrc,
_Out_ PSYMCRYPT_SHA512_STATE  pDst 
)

◆ SymCryptSha512StateExport()

VOID SYMCRYPT_CALL SymCryptSha512StateExport ( _In_ PCSYMCRYPT_SHA512_STATE  pState,
_Out_writes_bytes_(SYMCRYPT_SHA512_STATE_EXPORT_SIZE) PBYTE  pbBlob 
)

Definition at line 575 of file sha512.c.

578{
579 SymCryptSha512StateExportCore( pState, pbBlob, SymCryptBlobTypeSha512State );
580}
SymCryptBlobTypeSha512State
@ SymCryptBlobTypeSha512State
Definition: sc_lib.h:1067

◆ SymCryptSha512StateImport()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSha512StateImport ( _Out_ PSYMCRYPT_SHA512_STATE  pState,
_In_reads_bytes_(SYMCRYPT_SHA512_STATE_EXPORT_SIZE) PCBYTE  pbBlob 
)

Definition at line 654 of file sha512.c.

657{
658 return SymCryptSha512StateImportCore( pState, pbBlob, SymCryptBlobTypeSha512State );
659}

◆ SymCryptShake128()

VOID SYMCRYPT_CALL SymCryptShake128 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Referenced by SymCryptShake128Selftest().

◆ SymCryptShake128Append()

VOID SYMCRYPT_CALL SymCryptShake128Append ( _Inout_ PSYMCRYPT_SHAKE128_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Referenced by SymCryptMlDsaRejNttPoly(), and SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed().

◆ SymCryptShake128Default()

VOID SYMCRYPT_CALL SymCryptShake128Default ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHAKE128_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptShake128Extract()

VOID SYMCRYPT_CALL SymCryptShake128Extract ( _Inout_ PSYMCRYPT_SHAKE128_STATE  pState,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult,
BOOLEAN  bWipe 
)

Referenced by SymCryptMlDsaRejNttPoly(), and SymCryptMlKemPolyElementSampleNTTFromShake128().

◆ SymCryptShake128Init()

VOID SYMCRYPT_CALL SymCryptShake128Init ( _Out_ PSYMCRYPT_SHAKE128_STATE  pState)

Referenced by SymCryptMlDsaRejNttPoly(), and SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed().

◆ SymCryptShake128Result()

VOID SYMCRYPT_CALL SymCryptShake128Result ( _Inout_ PSYMCRYPT_SHAKE128_STATE  pState,
_Out_writes_(SYMCRYPT_SHAKE128_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptShake128Selftest()

VOID SYMCRYPT_CALL SymCryptShake128Selftest ( void  )

Definition at line 52 of file shake.c.

53{
54 BYTE result[SYMCRYPT_SHAKE128_RESULT_SIZE];
55
56 SymCryptShake128(SymCryptTestMsg3, sizeof(SymCryptTestMsg3), result, sizeof(result));
57
58 SymCryptInjectError(result, sizeof(result));
59
60 if (memcmp(result, shake128KATAnswer, sizeof(result)) != 0)
61 {
62 SymCryptFatal('shk1');
63 }
64}
shake128KATAnswer
static const BYTE shake128KATAnswer[SYMCRYPT_SHAKE128_RESULT_SIZE]
Definition: shake.c:43
SYMCRYPT_SHAKE128_RESULT_SIZE
#define SYMCRYPT_SHAKE128_RESULT_SIZE
Definition: symcrypt.h:1908
SymCryptShake128
VOID SYMCRYPT_CALL SymCryptShake128(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)

◆ SymCryptShake128StateCopy()

VOID SYMCRYPT_CALL SymCryptShake128StateCopy ( _In_ PCSYMCRYPT_SHAKE128_STATE  pSrc,
_Out_ PSYMCRYPT_SHAKE128_STATE  pDst 
)

Referenced by SymCryptMlKemkeyExpandPublicMatrixFromPublicSeed().

◆ SymCryptShake256()

VOID SYMCRYPT_CALL SymCryptShake256 ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Referenced by SymCryptMlDsaKeyGenerateEx(), SymCryptMlDsaSkDecode(), and SymCryptShake256Selftest().

◆ SymCryptShake256Append()

VOID SYMCRYPT_CALL SymCryptShake256Append ( _Inout_ PSYMCRYPT_SHAKE256_STATE  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Referenced by SymCryptMlDsaExpandMask(), SymCryptMlDsaKeyGenerateEx(), SymCryptMlDsaPkDecode(), SymCryptMlDsaRejBoundedPoly(), SymCryptMlDsaSampleInBall(), SymCryptMlDsaSignEx(), SymCryptMlDsaVerifyEx(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulateInternal(), and SymCryptMlKemkeyExpandFromPrivateSeed().

◆ SymCryptShake256Default()

VOID SYMCRYPT_CALL SymCryptShake256Default ( _In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData,
_Out_writes_(SYMCRYPT_SHAKE256_RESULT_SIZE) PBYTE  pbResult 
)

◆ SymCryptShake256Extract()

VOID SYMCRYPT_CALL SymCryptShake256Extract ( _Inout_ PSYMCRYPT_SHAKE256_STATE  pState,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult,
BOOLEAN  bWipe 
)

Referenced by SymCryptMlDsaExpandMask(), SymCryptMlDsaKeyGenerateEx(), SymCryptMlDsaRejBoundedPoly(), SymCryptMlDsaSampleInBall(), SymCryptMlDsaSignEx(), SymCryptMlDsaVerifyEx(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulateInternal(), and SymCryptMlKemkeyExpandFromPrivateSeed().

◆ SymCryptShake256Init()

VOID SYMCRYPT_CALL SymCryptShake256Init ( _Out_ PSYMCRYPT_SHAKE256_STATE  pState)

Referenced by SymCryptMlDsaKeyGenerateEx(), SymCryptMlDsaPkDecode(), SymCryptMlDsaRejBoundedPoly(), SymCryptMlDsaSampleInBall(), SymCryptMlDsaSignEx(), SymCryptMlDsaVerifyEx(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulateInternal(), and SymCryptMlKemkeyExpandFromPrivateSeed().

◆ SymCryptShake256Result()

VOID SYMCRYPT_CALL SymCryptShake256Result ( _Inout_ PSYMCRYPT_SHAKE256_STATE  pState,
_Out_writes_(SYMCRYPT_SHAKE256_RESULT_SIZE) PBYTE  pbResult 
)

Referenced by SymCryptMlDsaPkDecode(), SymCryptMlDsaSignEx(), and SymCryptMlDsaVerifyEx().

◆ SymCryptShake256Selftest()

VOID SYMCRYPT_CALL SymCryptShake256Selftest ( void  )

Definition at line 104 of file shake.c.

105{
106 BYTE result[SYMCRYPT_SHAKE256_RESULT_SIZE];
107
108 SymCryptShake256(SymCryptTestMsg3, sizeof(SymCryptTestMsg3), result, sizeof(result));
109
110 SymCryptInjectError(result, sizeof(result));
111
112 if (memcmp(result, shake256KATAnswer, sizeof(result)) != 0)
113 {
114 SymCryptFatal('shk2');
115 }
116}
shake256KATAnswer
static const BYTE shake256KATAnswer[SYMCRYPT_SHAKE256_RESULT_SIZE]
Definition: shake.c:95
SymCryptShake256
VOID SYMCRYPT_CALL SymCryptShake256(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
SYMCRYPT_SHAKE256_RESULT_SIZE
#define SYMCRYPT_SHAKE256_RESULT_SIZE
Definition: symcrypt.h:1964

◆ SymCryptShake256StateCopy()

VOID SYMCRYPT_CALL SymCryptShake256StateCopy ( _In_ PCSYMCRYPT_SHAKE256_STATE  pSrc,
_Out_ PSYMCRYPT_SHAKE256_STATE  pDst 
)

Referenced by SymCryptMlKemEncapsulateInternal(), and SymCryptMlKemkeyExpandFromPrivateSeed().

◆ SymCryptSizeofDlgroupFromBitsizes()

UINT32 SYMCRYPT_CALL SymCryptSizeofDlgroupFromBitsizes ( UINT32  nBitsOfP,
UINT32  nBitsOfQ 
)

Definition at line 82 of file dlgroup.c.

83{
84 UINT32 cbSeed = 0;
85
86 if (nBitsOfQ == 0)
87 {
88 nBitsOfQ = nBitsOfP-1; // Default to the maximum possible size for Q
89 }
90
91 // Invalid parameters
92 if ( (nBitsOfP < SYMCRYPT_DLGROUP_MIN_BITSIZE_P) ||
93 (nBitsOfQ < SYMCRYPT_DLGROUP_MIN_BITSIZE_Q) ||
94 (nBitsOfP < nBitsOfQ) )
95 {
96 return 0;
97 }
98
99 if ( nBitsOfP == nBitsOfQ )
100 {
101 nBitsOfQ--;
102 }
103
104 // Calculate the (tight) bytesize of the seed
105 cbSeed = (nBitsOfQ+7)/8;
106
107 return sizeof(SYMCRYPT_DLGROUP) +
108 SYMCRYPT_SIZEOF_MODULUS_FROM_BITS( nBitsOfP ) +
109 SYMCRYPT_SIZEOF_MODULUS_FROM_BITS( nBitsOfQ ) +
110 SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS( nBitsOfP ) +
111 ((cbSeed + SYMCRYPT_ASYM_ALIGN_VALUE - 1)/SYMCRYPT_ASYM_ALIGN_VALUE)*SYMCRYPT_ASYM_ALIGN_VALUE; // Make sure that the entire structure is ASYM_ALIGNED.
112}
SYMCRYPT_SIZEOF_MODULUS_FROM_BITS
#define SYMCRYPT_SIZEOF_MODULUS_FROM_BITS(_bitsize)
Definition: symcrypt_low_level.h:408

Referenced by SymCryptDlgroupAllocate(), and SymCryptDlgroupCreate().

◆ SymCryptSizeofDlkeyFromDlgroup()

UINT32 SYMCRYPT_CALL SymCryptSizeofDlkeyFromDlgroup ( _In_ PCSYMCRYPT_DLGROUP  pDlgroup)

Definition at line 44 of file dlkey.c.

45{
46 // Always allocate memory for large private keys
47 return sizeof(SYMCRYPT_DLKEY) + SymCryptSizeofModElementFromModulus( pDlgroup->pmP ) + SymCryptSizeofIntFromDigits( pDlgroup->nDigitsOfP );
48}

Referenced by SymCryptDlkeyAllocate(), SymCryptDlkeyCreate(), and SymCryptDlkeyWipe().

◆ SymCryptSizeofEckeyFromCurve()

UINT32 SYMCRYPT_CALL SymCryptSizeofEckeyFromCurve ( _In_ PCSYMCRYPT_ECURVE  pCurve)

Definition at line 44 of file eckey.c.

45{
46 //
47 // From symcrypt_internal.h we have:
48 // - sizeof results are upper bounded by 2^19
49 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
50 // - SymCryptSizeofEcpointFromCurve outputs the size of up to 4 modelements + some overhead
51 // Thus the following calculation does not overflow the result.
52 //
53 return sizeof(SYMCRYPT_ECKEY) + SymCryptSizeofEcpointFromCurve( pCurve ) + SymCryptSizeofIntFromDigits(SymCryptEcurveDigitsofScalarMultiplier(pCurve));
54}

Referenced by SymCryptEckeyAllocate(), SymCryptEckeyCreate(), and SymCryptEckeyWipe().

◆ SymCryptSizeofRsakeyFromParams()

UINT32 SYMCRYPT_CALL SymCryptSizeofRsakeyFromParams ( _In_ PCSYMCRYPT_RSA_PARAMS  pParams)

Definition at line 51 of file rsakey.c.

52{
53 UINT32 nModulusDigits;
54 UINT32 res;
55
56 SYMCRYPT_ASSERT( pParams != NULL );
57
58 nModulusDigits = SymCryptDigitsFromBits( pParams->nBitsOfModulus );
59
60 //
61 // From symcrypt_internal.h we have:
62 // - sizeof results are upper bounded by 2^19
63 // - SYMCRYPT_SCRATCH_BYTES results are upper bounded by 2^27 (including RSA and ECURVE)
64 // - nPrimes and nPubExps are bounded by SYMCRYPT_RSAKEY_MAX_NUMOF_PRIMES = 2 and
65 // SYMCRYPT_RSAKEY_MAX_NUMOF_PUBEXPS = 1
66 // Thus the following calculation does not overflow the result.
67 //
68 res = sizeof(SYMCRYPT_RSAKEY) +
69 SymCryptSizeofModulusFromDigits( nModulusDigits ) + // For Modulus
70 pParams->nPrimes * SymCryptSizeofModulusFromDigits( nModulusDigits ) + // For Primes
71 pParams->nPrimes * SYMCRYPT_SIZEOF_MODELEMENT_FROM_BITS( pParams->nBitsOfModulus ) + // For CrtInverses
72 pParams->nPubExp * SymCryptSizeofIntFromDigits( nModulusDigits ) + // For PrivExps
73 pParams->nPubExp * pParams->nPrimes * SymCryptSizeofIntFromDigits( nModulusDigits ); // For CrtPrivExps
74
75 // Consistency check with the static macro (optimized away in production)
76 SYMCRYPT_ASSERT( res <= SYMCRYPT_SIZEOF_RSAKEY_FROM_PARAMS( pParams->nBitsOfModulus, pParams->nPrimes, pParams->nPubExp ) );
77
78 return res;
79}
SYMCRYPT_SIZEOF_RSAKEY_FROM_PARAMS
#define SYMCRYPT_SIZEOF_RSAKEY_FROM_PARAMS(modBits, nPrimes, nPubExps)
Definition: symcrypt.h:7292

Referenced by SymCryptRsakeyAllocate(), and SymCryptRsakeyCreate().

◆ SymCryptSp800_108()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108 ( PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_opt_(cbLabel) PCBYTE  pbLabel,
SIZE_T  cbLabel,
_In_reads_opt_(cbContext) PCBYTE  pbContext,
SIZE_T  cbContext,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 104 of file sp800_108.c.

114{
115 SYMCRYPT_SP800_108_EXPANDED_KEY key;
116 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
117
118 scError = SymCryptSp800_108ExpandKey( &key, macAlgorithm, pbKey, cbKey );
119 if( scError != SYMCRYPT_NO_ERROR )
120 {
121 goto cleanup;
122 }
123
124 scError = SymCryptSp800_108Derive( &key, pbLabel, cbLabel, pbContext, cbContext, pbResult, cbResult );
125 if( scError != SYMCRYPT_NO_ERROR )
126 {
127 goto cleanup;
128 }
129
130cleanup:
131
132 SymCryptWipeKnownSize( &key, sizeof( key ) );
133
134 return scError;
135
136}
SymCryptSp800_108ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108ExpandKey(_Out_ PSYMCRYPT_SP800_108_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: sp800_108.c:90
SymCryptSp800_108Derive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108Derive(_In_ PCSYMCRYPT_SP800_108_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, _In_reads_opt_(cbContext) PCBYTE pbContext, SIZE_T cbContext, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: sp800_108.c:16
_SYMCRYPT_SP800_108_EXPANDED_KEY
Definition: symcrypt_internal.h:2215

Referenced by SymCryptSp800_108_HmacSha1SelfTest(), SymCryptSp800_108_HmacSha256SelfTest(), SymCryptSp800_108_HmacSha384SelfTest(), and SymCryptSp800_108_HmacSha512SelfTest().

◆ SymCryptSp800_108_HmacSha1SelfTest()

VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha1SelfTest ( void  )

Definition at line 21 of file sp800_108_hmacsha1.c.

22{
23 BYTE res[sizeof(sp800_108_sha1Answer)];
24
25 SymCryptSp800_108(
26 SymCryptHmacSha1Algorithm,
27 &SymCryptTestKey32[0], 8, // key
28 (PCBYTE)"Label", 5, // label
29 &SymCryptTestKey32[16], 16, // context
30 res,
31 sizeof(res));
32
33 SymCryptInjectError( res, sizeof( res ) );
34
35 if (memcmp(res, sp800_108_sha1Answer, sizeof(res)) !=0)
36 {
37 SymCryptFatal('8108');
38 }
39}
sp800_108_sha1Answer
static const BYTE sp800_108_sha1Answer[]
Definition: sp800_108_hmacsha1.c:14
SymCryptSp800_108
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108(PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, _In_reads_opt_(cbContext) PCBYTE pbContext, SIZE_T cbContext, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: sp800_108.c:104

◆ SymCryptSp800_108_HmacSha256SelfTest()

VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha256SelfTest ( void  )

Definition at line 21 of file sp800_108_hmacsha256.c.

22{
23 BYTE res[sizeof(sp800_108_sha256Answer)];
24
25 SymCryptSp800_108(
26 SymCryptHmacSha256Algorithm,
27 &SymCryptTestKey32[0], 8, // key
28 (PCBYTE)"Label", 5, // label
29 &SymCryptTestKey32[16], 16, // context
30 res,
31 sizeof(res));
32
33 SymCryptInjectError( res, sizeof( res ) );
34
35 if (memcmp(res, sp800_108_sha256Answer, sizeof(res)) !=0)
36 {
37 SymCryptFatal('8108');
38 }
39}
sp800_108_sha256Answer
static const BYTE sp800_108_sha256Answer[]
Definition: sp800_108_hmacsha256.c:14

◆ SymCryptSp800_108_HmacSha384SelfTest()

VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha384SelfTest ( void  )

Definition at line 21 of file sp800_108_hmacsha512.c.

22{
23 BYTE res[sizeof(sp800_108_sha384Answer)];
24
25 SymCryptSp800_108(
26 SymCryptHmacSha384Algorithm,
27 &SymCryptTestKey32[0], 8, // key
28 (PCBYTE)"Label", 5, // label
29 &SymCryptTestKey32[16], 16, // context
30 res,
31 sizeof(res));
32
33 SymCryptInjectError( res, sizeof( res ) );
34
35 if (memcmp(res, sp800_108_sha384Answer, sizeof(res)) !=0)
36 {
37 SymCryptFatal('8108');
38 }
39}
sp800_108_sha384Answer
static const BYTE sp800_108_sha384Answer[]
Definition: sp800_108_hmacsha512.c:14
SymCryptHmacSha384Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha384Algorithm
Definition: hmacsha384.c:31

◆ SymCryptSp800_108_HmacSha512SelfTest()

VOID SYMCRYPT_CALL SymCryptSp800_108_HmacSha512SelfTest ( void  )

Definition at line 48 of file sp800_108_hmacsha512.c.

49{
50 BYTE res[sizeof(sp800_108_sha512Answer)];
51
52 SymCryptSp800_108(
53 SymCryptHmacSha512Algorithm,
54 &SymCryptTestKey32[0], 8, // key
55 (PCBYTE)"Label", 5, // label
56 &SymCryptTestKey32[16], 16, // context
57 res,
58 sizeof(res));
59
60 SymCryptInjectError( res, sizeof( res ) );
61
62 if (memcmp(res, sp800_108_sha512Answer, sizeof(res)) !=0)
63 {
64 SymCryptFatal('8108');
65 }
66}
sp800_108_sha512Answer
static const BYTE sp800_108_sha512Answer[]
Definition: sp800_108_hmacsha512.c:41
SymCryptHmacSha512Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha512Algorithm
Definition: hmacsha512.c:29

◆ SymCryptSp800_108Derive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108Derive ( _In_ PCSYMCRYPT_SP800_108_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbLabel) PCBYTE  pbLabel,
SIZE_T  cbLabel,
_In_reads_opt_(cbContext) PCBYTE  pbContext,
SIZE_T  cbContext,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 16 of file sp800_108.c.

24{
25 SYMCRYPT_MAC_STATE macState;
26 UINT32 iBlock;
27 SIZE_T bytes;
28 SIZE_T blockSize = pExpandedKey->macAlg->resultSize;
29 SIZE_T bytesRemaining = cbResult;
30 BYTE buf[4];
31 SYMCRYPT_ALIGN BYTE rbBlockResult[SYMCRYPT_MAC_MAX_RESULT_SIZE];
32
33 SYMCRYPT_ASSERT(
34 blockSize <= SYMCRYPT_MAC_MAX_RESULT_SIZE &&
35 bytesRemaining > 0 );
36
37 if( cbResult > UINT32_MAX/8 )
38 {
39 // SP800-108 requires the output size in bits to be encoded in a 32-bit value.
40 // cbResults that are too large are impossible.
41 return SYMCRYPT_INVALID_ARGUMENT;
42 }
43
44 iBlock = 0;
45 while( bytesRemaining > 0 )
46 {
47 iBlock += 1;
48 pExpandedKey->macAlg->initFunc ( &macState, &pExpandedKey->macKey);
49
50 //
51 // We append the pieces into the MAC function. This is inefficient but works always.
52 // If we need more speed for large outputs, we could use a fixed-size stack buffer to build the
53 // concatenation & do a single append. This reduces the # calls in the loop, but adds one memcpy to
54 // the parameters. For small output sizes this is probably a wash.
55 //
56
57 SYMCRYPT_STORE_MSBFIRST32( &buf[0], iBlock );
58 pExpandedKey->macAlg->appendFunc( &macState, &buf[0], 4 ); // block count encoded in 4 bytes
59
60 if( cbLabel != (SIZE_T) -1 )
61 {
62 //
63 // cbLabel == -1 signals a generic input in the Context field.
64 //
65 pExpandedKey->macAlg->appendFunc( &macState, pbLabel, cbLabel ); // label
66
67 buf[0] = 0;
68 pExpandedKey->macAlg->appendFunc( &macState, &buf[0], 1 ); // zero byte
69 }
70
71 pExpandedKey->macAlg->appendFunc( &macState, pbContext, cbContext); // Context
72
73 SYMCRYPT_STORE_MSBFIRST32( &buf[0], 8 * (UINT32)cbResult );
74 pExpandedKey->macAlg->appendFunc( &macState, &buf[0], 4 ); // output length, in bits
75
76 pExpandedKey->macAlg->resultFunc( &macState, rbBlockResult );
77
78 bytes = SYMCRYPT_MIN( bytesRemaining, blockSize );
79 memcpy( pbResult, rbBlockResult, bytes );
80 pbResult += bytes;
81 bytesRemaining -= bytes;
82 }
83
84 SymCryptWipeKnownSize( rbBlockResult, sizeof( rbBlockResult ) );
85 return SYMCRYPT_NO_ERROR;
86}
UINT32_MAX
#define UINT32_MAX
Definition: stdint.h:85

Referenced by SymCryptSp800_108().

◆ SymCryptSp800_108ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSp800_108ExpandKey ( _Out_ PSYMCRYPT_SP800_108_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 90 of file sp800_108.c.

95{
96 SYMCRYPT_ASSERT( macAlgorithm->expandedKeySize <= sizeof( pExpandedKey->macKey ) );
97
98 pExpandedKey->macAlg = macAlgorithm;
99 return macAlgorithm->expandKeyFunc(&pExpandedKey->macKey, pbKey, cbKey );
100}

Referenced by SymCryptSp800_108().

◆ SymCryptSrtpKdf()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdf ( _In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
UINT32  uKeyDerivationRate,
UINT64  uIndex,
UINT32  uIndexWidth,
BYTE  label,
_Out_writes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput 
)

Definition at line 141 of file srtp_kdf.c.

152{
153 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
154 SYMCRYPT_SRTPKDF_EXPANDED_KEY expandedKey;
155
156 scError = SymCryptSrtpKdfExpandKey(&expandedKey, pbKey, cbKey);
157
158 if (scError != SYMCRYPT_NO_ERROR)
159 {
160 goto cleanup;
161 }
162
163 scError = SymCryptSrtpKdfDerive(&expandedKey,
164 pbSalt, cbSalt,
165 uKeyDerivationRate,
166 uIndex, uIndexWidth,
167 label,
168 pbOutput, cbOutput);
169
170cleanup:
171
172 SymCryptWipeKnownSize(&expandedKey, sizeof(expandedKey));
173
174 return scError;
175}
label
static const WCHAR label[]
Definition: itemdlg.c:1608
SymCryptSrtpKdfExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdfExpandKey(_Out_ PSYMCRYPT_SRTPKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: srtp_kdf.c:20
SymCryptSrtpKdfDerive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdfDerive(_In_ PCSYMCRYPT_SRTPKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT32 uKeyDerivationRate, UINT64 uIndex, UINT32 uIndexWidth, BYTE label, _Out_writes_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
Definition: srtp_kdf.c:31
_SYMCRYPT_SRTPKDF_EXPANDED_KEY
Definition: symcrypt_internal.h:2253

◆ SymCryptSrtpKdfDerive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdfDerive ( _In_ PCSYMCRYPT_SRTPKDF_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
UINT32  uKeyDerivationRate,
UINT64  uIndex,
UINT32  uIndexWidth,
BYTE  label,
_Out_writes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput 
)

Definition at line 31 of file srtp_kdf.c.

41{
42 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
43 BYTE X[16] = { 0 };
44
45 //
46 // uIndexWidth must be one of 0, 32 or 48. RFC 3711 defines SRTP indices to be
47 // 48-bits. SRTCP indices were first specified as 32-bit values and then updated to
48 // 48-bits by Errata ID 3712. uIndexWidth parameter allows specifying the width of
49 // the uIndex parameter for both SRTP and SRTCP indices. The test vectors use
50 // 32-bit SRTCP index values.
51 //
52 // The default value of 0 is equivalent to setting uIndexWidth to 48.
53 if (uIndexWidth == 0)
54 {
55 uIndexWidth = 48;
56 }
57 else if (uIndexWidth != 32 && uIndexWidth != 48)
58 {
59 scError = SYMCRYPT_INVALID_ARGUMENT;
60 goto cleanup;
61 }
62
63 if (cbSalt != SYMCRYPT_SRTP_KDF_SALT_SIZE)
64 {
65 scError = SYMCRYPT_INVALID_ARGUMENT;
66 goto cleanup;
67 }
68
69 // uKeyDerivationRate must be zero or 2^i for 0 <= i <= 24.
70 // This is verified by checking both it is not greater than 2^24 and it is either zero or a power of two.
71 if( (uKeyDerivationRate > (1 << 24)) || ((uKeyDerivationRate & (uKeyDerivationRate - 1)) != 0) )
72 {
73 scError = SYMCRYPT_INVALID_ARGUMENT;
74 goto cleanup;
75 }
76
77 // Initialize X to Salt || 0
78 memcpy(X, pbSalt, cbSalt);
79
80 // (uIndex DIV uKeyDerivationRate) operation can be performed with a right shift as
81 // uKeyDerivationRate is either zero or a power of 2. When uKeyDerivationRate is zero,
82 // DIV operation should evaluate to zero, which can be performed by shifting uIndex by 48 bits,
83 // i.e., maximum value it may have.
84 UINT32 kdrShift = 48;
85 if (uKeyDerivationRate)
86 {
87 for (UINT32 i = 0; i <= 24; i++)
88 {
89 if (uKeyDerivationRate == (1UL << i))
90 {
91 kdrShift = i;
92 break;
93 }
94 }
95 }
96
97 UINT64 r = uIndex >> kdrShift;
98
99 UINT64 key_id = ((UINT64)label << uIndexWidth) | r;
100
101 // XOR key_id into salt
102 //
103 // X = S0 ... |S6 ... S13| 0 0
104 // | key_id |
105 //
106 PBYTE pbXorPos = &X[SYMCRYPT_SRTP_KDF_SALT_SIZE - sizeof(key_id)];
107 UINT64 uSaltLsb = SYMCRYPT_LOAD_MSBFIRST64(pbXorPos);
108 SYMCRYPT_STORE_MSBFIRST64(pbXorPos, uSaltLsb ^ key_id);
109
110 //
111 // We break the read-once/write once rule here by writing to the pbOutput buffer twice.
112 // The first write wipes the buffer so that we get the raw keystream bytes from AES-CTR encryption.
113 // The second write to pbOutput occurs with the SymCryptAesCtrMsb64() call that produces the keystream bytes.
114 //
115 // Modification of pbOutput between the two calls does not leak any information, it just results in flipping of the
116 // corresponding bits of the correct output.
117 SymCryptWipe(pbOutput, cbOutput);
118 SymCryptAesCtrMsb64(&pExpandedKey->aesExpandedKey, X, pbOutput, pbOutput, cbOutput & ~0xf);
119
120 // SymCryptAesCtrMsb64 only processes full blocks. If cbOutput is not a multiple of 16 we generate the last block of
121 // keystream to local buffer and copy the necessary number of bytes to output.
122 if (cbOutput & 0xf)
123 {
124 BYTE lastBlockBytes[16] = { 0 };
125
126 SymCryptAesCtrMsb64(&pExpandedKey->aesExpandedKey, X, lastBlockBytes, lastBlockBytes, 16);
127
128 memcpy(pbOutput + 16 * (cbOutput / 16), lastBlockBytes, cbOutput & 0xf);
129
130 SymCryptWipeKnownSize(lastBlockBytes, sizeof(lastBlockBytes));
131 }
132
133cleanup:
134
135 return scError;
136}
SYMCRYPT_SRTP_KDF_SALT_SIZE
#define SYMCRYPT_SRTP_KDF_SALT_SIZE
Definition: srtp_kdf.c:14
SymCryptAesCtrMsb64
VOID SYMCRYPT_CALL SymCryptAesCtrMsb64(_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: aes-default.c:404

Referenced by SymCryptSrtpKdf().

◆ SymCryptSrtpKdfExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSrtpKdfExpandKey ( _Out_ PSYMCRYPT_SRTPKDF_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 20 of file srtp_kdf.c.

24{
25 return SymCryptAesExpandKeyEncryptOnly(&pExpandedKey->aesExpandedKey, pbKey, cbKey);
26}
SymCryptAesExpandKeyEncryptOnly
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKeyEncryptOnly(_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: aes-key.c:230

Referenced by SymCryptSrtpKdf().

◆ SymCryptSrtpKdfSelfTest()

VOID SYMCRYPT_CALL SymCryptSrtpKdfSelfTest ( void  )

◆ SymCryptSshKdf()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdf ( _In_ PCSYMCRYPT_HASH  pHashFunc,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
BYTE  label,
_In_reads_(cbSessionId) PCBYTE  pbSessionId,
SIZE_T  cbSessionId,
_Out_writes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput 
)

Definition at line 89 of file ssh_kdf.c.

100{
101 SYMCRYPT_SSHKDF_EXPANDED_KEY expandedKey;
102 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
103
104 scError = SymCryptSshKdfExpandKey(&expandedKey, pHashFunc, pbKey, cbKey);
105
106 if (scError != SYMCRYPT_NO_ERROR)
107 {
108 goto cleanup;
109 }
110
111 scError = SymCryptSshKdfDerive(&expandedKey,
112 pbHashValue, cbHashValue,
113 label,
114 pbSessionId, cbSessionId,
115 pbOutput, cbOutput);
116
117 cleanup:
118
119 SymCryptWipeKnownSize(&expandedKey, sizeof(expandedKey));
120
121 return scError;
122}
SymCryptSshKdfExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfExpandKey(_Out_ PSYMCRYPT_SSHKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_HASH pHashFunc, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: ssh_kdf.c:17
SymCryptSshKdfDerive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfDerive(_In_ PCSYMCRYPT_SSHKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, BYTE label, _In_reads_(cbSessionId) PCBYTE pbSessionId, SIZE_T cbSessionId, _Inout_updates_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
Definition: ssh_kdf.c:33
pbSessionId
static const BYTE pbSessionId[]
Definition: ssh_kdf_sha256.c:30
_SYMCRYPT_SSHKDF_EXPANDED_KEY
Definition: symcrypt_internal.h:2244

◆ SymCryptSshKdfDerive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfDerive ( _In_ PCSYMCRYPT_SSHKDF_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbHashValue) PCBYTE  pbHashValue,
SIZE_T  cbHashValue,
BYTE  label,
_In_reads_(cbSessionId) PCBYTE  pbSessionId,
SIZE_T  cbSessionId,
_Inout_updates_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput 
)

Definition at line 33 of file ssh_kdf.c.

42{
43 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
44 SYMCRYPT_HASH_STATE hashState;
45
46 PCBYTE pcbOutputSave = pbOutput;
47 PCSYMCRYPT_HASH pHashFunc = pExpandedKey->pHashFunc;
48 SIZE_T cbHashResultSize = SymCryptHashResultSize(pHashFunc);
49
50
51 while (cbOutput > 0)
52 {
53 SIZE_T cbGeneratedOutput = pbOutput - pcbOutputSave;
54
55 SymCryptHashStateCopy(pHashFunc, &pExpandedKey->hashState, &hashState);
56 SymCryptHashAppend(pHashFunc, &hashState, pbHashValue, cbHashValue); // hashState has (K || H)
57
58 // label and session ID are appended only in the first iteration
59 if (cbGeneratedOutput == 0)
60 {
61 SymCryptHashAppend(pHashFunc, &hashState, &label, 1);
62 SymCryptHashAppend(pHashFunc, &hashState, pbSessionId, cbSessionId);
63 }
64 else
65 {
66 // We break the read-once write-once rule here by appending data to a
67 // hash computation from pbOutput that was written by SymCryptHashResult()
68 // below.
69 // Modification of data in pbOutput buffer after it's written and before
70 // used again will have uncontrolled disturbances in the hash output and cannot
71 // be used to gain knowledge about the secret key.
72 SymCryptHashAppend(pHashFunc, &hashState, pcbOutputSave, cbGeneratedOutput); // hashState has (K || H || K1 .. Ki)
73 }
74
75 SymCryptHashResult(pHashFunc, &hashState, pbOutput, cbOutput);
76
77 SIZE_T bytesCopied = SYMCRYPT_MIN(cbOutput, cbHashResultSize);
78
79 pbOutput += bytesCopied;
80 cbOutput -= bytesCopied;
81 }
82
83 return scError;
84}

Referenced by SymCryptSshKdf(), SymCryptSshKdfSha256SelfTest(), and SymCryptSshKdfSha512SelfTest().

◆ SymCryptSshKdfExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfExpandKey ( _Out_ PSYMCRYPT_SSHKDF_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_HASH  pHashFunc,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 17 of file ssh_kdf.c.

22{
23 pExpandedKey->pHashFunc = pHashFunc;
24
25 SymCryptHashInit(pHashFunc, &pExpandedKey->hashState);
26 SymCryptHashAppend(pHashFunc, &pExpandedKey->hashState, pbKey, cbKey);
27
28 return SYMCRYPT_NO_ERROR;
29}

Referenced by SymCryptSshKdf(), SymCryptSshKdfSha256SelfTest(), and SymCryptSshKdfSha512SelfTest().

◆ SymCryptSshKdfSha256SelfTest()

VOID SYMCRYPT_CALL SymCryptSshKdfSha256SelfTest ( void  )

Definition at line 45 of file ssh_kdf_sha256.c.

46{
47 SYMCRYPT_SSHKDF_EXPANDED_KEY expandedKey;
48 SYMCRYPT_ALIGN BYTE rbResult[sizeof(pbResult)];
49
50 SymCryptSshKdfExpandKey(&expandedKey, SymCryptSha256Algorithm, pbKey, sizeof(pbKey));
51
52 SymCryptSshKdfDerive(&expandedKey,
53 pbHash, sizeof(pbHash),
54 label,
55 pbSessionId, sizeof(pbSessionId),
56 rbResult, sizeof(rbResult)
57 );
58
59 SymCryptInjectError(rbResult, sizeof(rbResult));
60
61 if (memcmp(rbResult, pbResult, sizeof(pbResult)) != 0)
62 {
63 SymCryptFatal('sshk');
64 }
65}
label
static const BYTE label
Definition: ssh_kdf_sha256.c:36
pbHash
static const BYTE pbHash[]
Definition: ssh_kdf_sha256.c:24
SymCryptSha256Algorithm
const PCSYMCRYPT_HASH SymCryptSha256Algorithm
Definition: sha256.c:46
SymCryptSshKdfExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfExpandKey(_Out_ PSYMCRYPT_SSHKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_HASH pHashFunc, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: ssh_kdf.c:17
SymCryptSshKdfDerive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSshKdfDerive(_In_ PCSYMCRYPT_SSHKDF_EXPANDED_KEY pExpandedKey, _In_reads_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, BYTE label, _In_reads_(cbSessionId) PCBYTE pbSessionId, SIZE_T cbSessionId, _Inout_updates_(cbOutput) PBYTE pbOutput, SIZE_T cbOutput)
Definition: ssh_kdf.c:33

◆ SymCryptSshKdfSha512SelfTest()

VOID SYMCRYPT_CALL SymCryptSshKdfSha512SelfTest ( void  )

Definition at line 50 of file ssh_kdf_sha512.c.

51{
52 SYMCRYPT_SSHKDF_EXPANDED_KEY expandedKey;
53 SYMCRYPT_ALIGN BYTE rbResult[sizeof(pbResult)];
54
55 SymCryptSshKdfExpandKey(&expandedKey, SymCryptSha512Algorithm, pbKey, sizeof(pbKey));
56
57 SymCryptSshKdfDerive(&expandedKey,
58 pbHash, sizeof(pbHash),
59 label,
60 pbSessionId, sizeof(pbSessionId),
61 rbResult, sizeof(rbResult)
62 );
63
64 SymCryptInjectError(rbResult, sizeof(rbResult));
65
66 if (memcmp(rbResult, pbResult, sizeof(pbResult)) != 0)
67 {
68 SymCryptFatal('sshk');
69 }
70}
label
static const BYTE label
Definition: ssh_kdf_sha512.c:40
pbHash
static const BYTE pbHash[]
Definition: ssh_kdf_sha512.c:24
pbSessionId
static const BYTE pbSessionId[]
Definition: ssh_kdf_sha512.c:32
pbResult
static const BYTE pbResult[]
Definition: ssh_kdf_sha512.c:42
SymCryptSha512Algorithm
const PCSYMCRYPT_HASH SymCryptSha512Algorithm
Definition: sha512.c:170

◆ SymCryptSskdfHash()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfHash ( _In_ PCSYMCRYPT_HASH  hashAlgorithm,
SIZE_T  cbHashOutputSize,
_In_reads_(cbSecret) PCBYTE  pbSecret,
SIZE_T  cbSecret,
_In_reads_opt_(cbInfo) PCBYTE  pbInfo,
SIZE_T  cbInfo,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 221 of file sskdf.c.

230{
231 SYMCRYPT_HASH_STATE state;
232
233 PBYTE pbCurr = pbResult;
234
235 SIZE_T cbHashResultSize = hashAlgorithm->resultSize;
236 SIZE_T cbPartialResult;
237 UINT32 cntr = 1;
238 BYTE ctrBuf[4];
239
240 if ( cbHashOutputSize > 64 ||
241 cbHashOutputSize > 0 && cbHashOutputSize != hashAlgorithm->resultSize )
242 {
243 return SYMCRYPT_INVALID_ARGUMENT;
244 }
245
246 while ( cbResult > 0 )
247 {
248 SYMCRYPT_STORE_MSBFIRST32( ctrBuf, cntr );
249
250 cbPartialResult = SYMCRYPT_MIN( cbResult, cbHashResultSize );
251
252 // Calculate K(i) = H(counter || Z || FixedInfo)
253 SymCryptHashInit( hashAlgorithm, &state );
254 SymCryptHashAppend( hashAlgorithm, &state, ctrBuf, sizeof( ctrBuf ) );
255 SymCryptHashAppend( hashAlgorithm, &state, pbSecret, cbSecret );
256 SymCryptHashAppend( hashAlgorithm, &state, pbInfo, cbInfo );
257 SymCryptHashResult( hashAlgorithm, &state, pbCurr, cbPartialResult );
258
259 // Update counters
260 cntr++;
261 pbCurr += cbPartialResult;
262 cbResult -= cbPartialResult;
263 }
264
265 return SYMCRYPT_NO_ERROR;
266}

◆ SymCryptSskdfMac()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMac ( _In_ PCSYMCRYPT_MAC  macAlgorithm,
SIZE_T  cbMacOutputSize,
_In_reads_(cbSecret) PCBYTE  pbSecret,
SIZE_T  cbSecret,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt,
_In_reads_opt_(cbInfo) PCBYTE  pbInfo,
SIZE_T  cbInfo,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 180 of file sskdf.c.

191{
192 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
193 SYMCRYPT_SSKDF_MAC_EXPANDED_SALT expandedSalt;
194
195 scError = SymCryptSskdfMacExpandSalt( &expandedSalt, macAlgorithm, pbSalt, cbSalt );
196
197 if ( scError != SYMCRYPT_NO_ERROR )
198 {
199 goto cleanup;
200 }
201
202 scError = SymCryptSskdfMacDerive(
203 &expandedSalt,
204 cbMacOutputSize,
205 pbSecret,
206 cbSecret,
207 pbInfo,
208 cbInfo,
209 pbResult,
210 cbResult );
211
212cleanup:
213
214 SymCryptWipeKnownSize( &expandedSalt, sizeof( expandedSalt ) );
215
216 return scError;
217}
SymCryptSskdfMacDerive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMacDerive(_In_ PCSYMCRYPT_SSKDF_MAC_EXPANDED_SALT pExpandedSalt, SIZE_T cbMacOutputSize, _In_reads_(cbSecret) PCBYTE pbSecret, SIZE_T cbSecret, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: sskdf.c:87
SymCryptSskdfMacExpandSalt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMacExpandSalt(_Out_ PSYMCRYPT_SSKDF_MAC_EXPANDED_SALT pExpandedSalt, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt)
Definition: sskdf.c:27
_SYMCRYPT_SSKDF_MAC_EXPANDED_SALT
Definition: symcrypt_internal.h:2271

◆ SymCryptSskdfMacDerive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMacDerive ( _In_ PCSYMCRYPT_SSKDF_MAC_EXPANDED_SALT  pExpandedSalt,
SIZE_T  cbMacOutputSize,
_In_reads_(cbSecret) PCBYTE  pbSecret,
SIZE_T  cbSecret,
_In_reads_opt_(cbInfo) PCBYTE  pbInfo,
SIZE_T  cbInfo,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 87 of file sskdf.c.

96{
97 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
98 SYMCRYPT_MAC_STATE state;
99 PCSYMCRYPT_MAC pMacAlgorithm = pExpandedSalt->macAlg;
100 PSYMCRYPT_MAC_RESULT_EX resultFuncEx = NULL;
101
102 SYMCRYPT_ALIGN BYTE rbPartialResult[SYMCRYPT_MAC_MAX_RESULT_SIZE];
103 PBYTE pbCurr = pbResult;
104
105 SIZE_T cbMacResultSize = pMacAlgorithm->resultSize;
106 SIZE_T cbBlock;
107 UINT32 cntr = 1;
108 BYTE ctrBuf[4];
109
110 if ( cbMacOutputSize > 64 )
111 {
112 scError = SYMCRYPT_INVALID_ARGUMENT;
113 goto cleanup;
114 }
115
116 if ( pMacAlgorithm == SymCryptKmac128Algorithm )
117 {
118 cbMacResultSize = cbMacOutputSize;
119 resultFuncEx = SymCryptKmac128ResultEx;
120 }
121 else if ( pMacAlgorithm == SymCryptKmac256Algorithm )
122 {
123 cbMacResultSize = cbMacOutputSize;
124 resultFuncEx = SymCryptKmac256ResultEx;
125 }
126 else if ( cbMacOutputSize > 0 && cbMacOutputSize != pMacAlgorithm->resultSize )
127 {
128 scError = SYMCRYPT_INVALID_ARGUMENT;
129 goto cleanup;
130 }
131
132 while ( cbResult > 0 )
133 {
134 SYMCRYPT_STORE_MSBFIRST32( ctrBuf, cntr );
135
136 // Calculate K(i) = H(counter || Z || FixedInfo)
137 pMacAlgorithm->initFunc( &state, &pExpandedSalt->macKey );
138 pMacAlgorithm->appendFunc( &state, ctrBuf, sizeof( ctrBuf ) );
139 pMacAlgorithm->appendFunc( &state, pbSecret, cbSecret );
140 pMacAlgorithm->appendFunc( &state, pbInfo, cbInfo );
141
142 cbBlock = SYMCRYPT_MIN( cbResult, cbMacResultSize );
143
144 if ( resultFuncEx != NULL )
145 {
146 if ( cbMacOutputSize > 0 )
147 {
148 resultFuncEx( &state, rbPartialResult, cbMacOutputSize );
149 }
150 else
151 {
152 // If the output size is not specified, calculate the full result
153 resultFuncEx( &state, pbResult, cbResult );
154 break;
155 }
156 }
157 else
158 {
159 pMacAlgorithm->resultFunc( &state, rbPartialResult );
160 }
161
162 // Store the result in the output buffer
163 memcpy( pbCurr, rbPartialResult, cbBlock );
164
165 // Update counters
166 cntr++;
167 pbCurr += cbBlock;
168 cbResult -= cbBlock;
169 }
170
171cleanup:
172
173 SymCryptWipeKnownSize( &rbPartialResult[0], sizeof( rbPartialResult ) );
174
175 return scError;
176}
SymCryptKmac256Algorithm
const PCSYMCRYPT_MAC SymCryptKmac256Algorithm
Definition: kmac.c:96
SymCryptKmac128Algorithm
const PCSYMCRYPT_MAC SymCryptKmac128Algorithm
Definition: kmac.c:38
SymCryptKmac256ResultEx
VOID SYMCRYPT_CALL SymCryptKmac256ResultEx(_Inout_ PSYMCRYPT_KMAC256_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
SymCryptKmac128ResultEx
VOID SYMCRYPT_CALL SymCryptKmac128ResultEx(_Inout_ PSYMCRYPT_KMAC128_STATE pState, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
PSYMCRYPT_MAC_RESULT_EX
VOID(SYMCRYPT_CALL * PSYMCRYPT_MAC_RESULT_EX)(PVOID pState, PVOID pbResult, SIZE_T cbResult)
Definition: symcrypt_internal.h:1764

Referenced by SymCryptSskdfMac().

◆ SymCryptSskdfMacExpandSalt()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptSskdfMacExpandSalt ( _Out_ PSYMCRYPT_SSKDF_MAC_EXPANDED_SALT  pExpandedSalt,
_In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_opt_(cbSalt) PCBYTE  pbSalt,
SIZE_T  cbSalt 
)

Definition at line 27 of file sskdf.c.

32{
33 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
34
35 const BYTE pbSaltDefault[SYMCRYPT_SSKDF_DEFAULT_SALT_MAX] = { 0 };
36
37 SYMCRYPT_ASSERT( macAlgorithm->expandedKeySize <= sizeof( pExpandedSalt->macKey ) );
38
39 pExpandedSalt->macAlg = macAlgorithm;
40
41 if ( pbSalt == NULL )
42 {
43 if ( macAlgorithm == SymCryptKmac128Algorithm )
44 {
45 cbSalt = SYMCRYPT_SSKDF_KMAC_128_DEFAULT_SALT_SIZE;
46 }
47 else if ( macAlgorithm == SymCryptKmac256Algorithm )
48 {
49 cbSalt = SYMCRYPT_SSKDF_KMAC_256_DEFAULT_SALT_SIZE;
50 }
51 else
52 {
53 cbSalt = SymCryptHashInputBlockSize( *(macAlgorithm->ppHashAlgorithm) );
54 }
55
56 pbSalt = pbSaltDefault;
57 }
58
59 if ( macAlgorithm == SymCryptKmac128Algorithm )
60 {
61 scError = SymCryptKmac128ExpandKeyEx(
62 &pExpandedSalt->macKey.kmac128Key,
63 pbSalt,
64 cbSalt,
65 pbKmacCustomizationString,
66 sizeof( pbKmacCustomizationString ) );
67 }
68 else if ( macAlgorithm == SymCryptKmac256Algorithm )
69 {
70 scError = SymCryptKmac256ExpandKeyEx(
71 &pExpandedSalt->macKey.kmac256Key,
72 pbSalt,
73 cbSalt,
74 pbKmacCustomizationString,
75 sizeof( pbKmacCustomizationString ) );
76 }
77 else
78 {
79 scError = macAlgorithm->expandKeyFunc( &pExpandedSalt->macKey, pbSalt, cbSalt );
80 }
81
82 return scError;
83}
SYMCRYPT_SSKDF_KMAC_128_DEFAULT_SALT_SIZE
#define SYMCRYPT_SSKDF_KMAC_128_DEFAULT_SALT_SIZE
Definition: sskdf.c:18
SYMCRYPT_SSKDF_KMAC_256_DEFAULT_SALT_SIZE
#define SYMCRYPT_SSKDF_KMAC_256_DEFAULT_SALT_SIZE
Definition: sskdf.c:19
SYMCRYPT_SSKDF_DEFAULT_SALT_MAX
#define SYMCRYPT_SSKDF_DEFAULT_SALT_MAX
Definition: sskdf.c:20
pbKmacCustomizationString
static const BYTE pbKmacCustomizationString[3]
Definition: sskdf.c:23
_SYMCRYPT_MAC::ppHashAlgorithm
const PCSYMCRYPT_HASH * ppHashAlgorithm
Definition: symcrypt_internal.h:1775
SymCryptHashInputBlockSize
SIZE_T SYMCRYPT_CALL SymCryptHashInputBlockSize(_In_ PCSYMCRYPT_HASH pHash)
Definition: hash.c:140

Referenced by SymCryptSskdfMac().

◆ SymCryptSskdfSelfTest()

VOID SYMCRYPT_CALL SymCryptSskdfSelfTest ( void  )

◆ SymCryptStoreLsbFirstUint32()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreLsbFirstUint32 ( UINT32  src,
_Out_writes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst 
)

Definition at line 470 of file libmain.c.

474{
475 return SymCryptStoreLsbFirstUint64( src, pbDst, cbDst );
476}
src
GLenum src
Definition: glext.h:6340
SymCryptStoreLsbFirstUint64
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreLsbFirstUint64(UINT64 src, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
Definition: libmain.c:480

◆ SymCryptStoreLsbFirstUint64()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreLsbFirstUint64 ( UINT64  src,
_Out_writes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst 
)

Definition at line 480 of file libmain.c.

484{
485 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
486
487 while( cbDst > 0 )
488 {
489 *pbDst++ = (BYTE) src;
490 src >>= 8;
491 cbDst--;
492 }
493
494 if( src != 0 )
495 {
496 scError = SYMCRYPT_VALUE_TOO_LARGE;
497 goto cleanup;
498 }
499
500cleanup:
501 return scError;
502}

Referenced by SymCryptStoreLsbFirstUint32().

◆ SymCryptStoreMsbFirstUint32()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreMsbFirstUint32 ( UINT32  src,
_Out_writes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst 
)

Definition at line 506 of file libmain.c.

510{
511 return SymCryptStoreMsbFirstUint64( src, pbDst, cbDst );
512}
SymCryptStoreMsbFirstUint64
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreMsbFirstUint64(UINT64 src, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
Definition: libmain.c:516

◆ SymCryptStoreMsbFirstUint64()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptStoreMsbFirstUint64 ( UINT64  src,
_Out_writes_(cbDst) PBYTE  pbDst,
SIZE_T  cbDst 
)

Definition at line 516 of file libmain.c.

520{
521 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
522
523 pbDst += cbDst;
524 while( cbDst > 0 )
525 {
526 *--pbDst = (BYTE) src;
527 src >>= 8;
528 cbDst--;
529 }
530
531 if( src != 0 )
532 {
533 scError = SYMCRYPT_VALUE_TOO_LARGE;
534 goto cleanup;
535 }
536
537cleanup:
538 return scError;
539}

Referenced by SymCryptStoreMsbFirstUint32().

◆ SymCryptTlsCbcHmacVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsCbcHmacVerify ( _In_ PCSYMCRYPT_MAC  pMacAlgorithm,
_In_ PVOID  pExpandedKey,
_Inout_ PVOID  pState,
_In_reads_(cbData) PCBYTE  pbData,
SIZE_T  cbData 
)

Definition at line 403 of file tlsCbcVerify.c.

409{
410 BYTE abMacValue[64];
411 BYTE abHashResult[48];
412 UINT32 u32PaddingError;
413 PSYMCRYPT_COMMON_HASH_STATE pHashState = (PSYMCRYPT_COMMON_HASH_STATE) pState;
414 PCSYMCRYPT_HASH pHashAlgorithm = *(pMacAlgorithm->ppHashAlgorithm);
415 UINT32 i;
416
417 SYMCRYPT_ASSERT(pMacAlgorithm == SymCryptHmacSha1Algorithm ||
418 pMacAlgorithm == SymCryptHmacSha256Algorithm ||
419 pMacAlgorithm == SymCryptHmacSha384Algorithm );
420 SYMCRYPT_ASSERT(((*(pMacAlgorithm->ppHashAlgorithm))->inputBlockSize)/2 <= 64);
421 SYMCRYPT_ASSERT((*(pMacAlgorithm->ppHashAlgorithm))->resultSize <= 48);
422
423 SymCryptTlsCbcHmacVerifyCore(
424 pHashAlgorithm,
425 pHashState,
426 pbData,
427 cbData,
428 abMacValue,
429 abHashResult,
430 &u32PaddingError );
431
432 // We have the hash value, convert it to a MAC value
433 // First we set up the chaining value
434 memcpy( ((PBYTE)pHashState + pHashAlgorithm->chainOffset),
435 (PBYTE)pExpandedKey + pMacAlgorithm->outerChainingStateOffset,
436 pHashAlgorithm->chainSize );
437 // Then copy the data & set the length
438 // The hash result wasn't BSWAPPED yet...
439 if( pMacAlgorithm->resultSize <= 32 )
440 {
441 SymCryptUint32ToMsbFirst( (UINT32 *) abHashResult, pHashState->buffer, pHashAlgorithm->resultSize / 4 );
442 } else {
443 SymCryptUint64ToMsbFirst( (UINT64 *) abHashResult, pHashState->buffer, pHashAlgorithm->resultSize / 8 );
444 }
445 pHashState->bytesInBuffer = pHashAlgorithm->resultSize;
446 pHashState->dataLengthL = pHashAlgorithm->resultSize + pHashAlgorithm->inputBlockSize;
447
448 (*pHashAlgorithm->resultFunc)( pHashState, abHashResult );
449
450 // Verify in 32-bit chunks to support SHA-1 without further problems
451 for( i=0; i<pHashAlgorithm->resultSize / 4; i++ )
452 {
453 u32PaddingError |= *(PUINT32)&abHashResult[4*i] ^ *(PUINT32)&abMacValue[4*i];
454 }
455
456 // We may reveal the final error-or-no-error as that will be visible anyway
457 return u32PaddingError == 0 ? SYMCRYPT_NO_ERROR : SYMCRYPT_AUTHENTICATION_FAILURE;
458}
PUINT32
unsigned int * PUINT32
Definition: basetsd.h:119
SymCryptTlsCbcHmacVerifyCore
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsCbcHmacVerifyCore(_In_ PCSYMCRYPT_HASH pHash, _Inout_ PSYMCRYPT_COMMON_HASH_STATE pState, _In_reads_bytes_(cbData) PCBYTE pbData, SIZE_T cbData, _Inout_updates_(pHash->inputBlockSize/2) PBYTE pbMacValue, _Inout_updates_(pHash->resultSize) PBYTE pbHashResult, _Out_ PUINT32 pu32PaddingError)
Definition: tlsCbcVerify.c:113

◆ SymCryptTlsPrf1_1()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1 ( _In_reads_(cbKey) PCBYTE  pbKey,
_In_ SIZE_T  cbKey,
_In_reads_opt_(cbLabel) PCBYTE  pbLabel,
_In_ SIZE_T  cbLabel,
_In_reads_(cbSeed) PCBYTE  pbSeed,
_In_ SIZE_T  cbSeed,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 484 of file tlsprf.c.

493{
494 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
495 SYMCRYPT_TLSPRF1_1_EXPANDED_KEY key;
496
497 // Create the expanded key
498 scError = SymCryptTlsPrf1_1ExpandKey(&key, pbKey, cbKey);
499 if (scError != SYMCRYPT_NO_ERROR)
500 {
501 goto cleanup;
502 }
503
504 // Derive the key
505 scError = SymCryptTlsPrf1_1Derive(
506 &key,
507 pbLabel,
508 cbLabel,
509 pbSeed,
510 cbSeed,
511 pbResult,
512 cbResult);
513 if (scError != SYMCRYPT_NO_ERROR)
514 {
515 goto cleanup;
516 }
517
518cleanup:
519 SymCryptWipeKnownSize(&key, sizeof(key));
520
521 return scError;
522}
_SYMCRYPT_TLSPRF1_1_EXPANDED_KEY
Definition: symcrypt_internal.h:2225
SymCryptTlsPrf1_1ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1ExpandKey(_Out_ PSYMCRYPT_TLSPRF1_1_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: tlsprf.c:58
SymCryptTlsPrf1_1Derive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1Derive(_In_ PCSYMCRYPT_TLSPRF1_1_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: tlsprf.c:299

◆ SymCryptTlsPrf1_1Derive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1Derive ( _In_ PCSYMCRYPT_TLSPRF1_1_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbLabel) PCBYTE  pbLabel,
_In_ SIZE_T  cbLabel,
_In_reads_(cbSeed) PCBYTE  pbSeed,
_In_ SIZE_T  cbSeed,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 299 of file tlsprf.c.

307{
308 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
309
310 SYMCRYPT_ALIGN BYTE rbLabelAndSeed[SYMCRYPT_TLS_MAX_LABEL_AND_SEED_SIZE];
311 SIZE_T cbLabelAndSeed = 0;
312
313 SYMCRYPT_ALIGN BYTE rbAiMd5[SYMCRYPT_HMAC_MD5_RESULT_SIZE];
314 SYMCRYPT_ALIGN BYTE rbPartialResultMd5[SYMCRYPT_TLS_1_1_CHUNK_SIZE];
315
316 SYMCRYPT_ALIGN BYTE rbAiSha1[SYMCRYPT_HMAC_SHA1_RESULT_SIZE];
317 SYMCRYPT_ALIGN BYTE rbPartialResultSha1[SYMCRYPT_TLS_1_1_CHUNK_SIZE];
318
319 BYTE * pbTmp = pbResult;
320 SIZE_T cbBytesToWrite = cbResult;
321
322 // Size checks
323 if ((cbLabel > SYMCRYPT_TLS_MAX_LABEL_SIZE) || (cbSeed > SYMCRYPT_TLS_MAX_SEED_SIZE))
324 {
325 scError = SYMCRYPT_WRONG_DATA_SIZE;
326 goto cleanup;
327 }
328
329 // Concatenating the label and the seed
330 pbTmp = rbLabelAndSeed;
331 if( cbLabel > 0 )
332 {
333 memcpy(pbTmp, pbLabel, cbLabel);
334 pbTmp += cbLabel;
335 }
336 memcpy(pbTmp, pbSeed, cbSeed);
337 cbLabelAndSeed = cbLabel + cbSeed;
338
339 // Build A(1)'s
340 SymCryptTlsPrfMac(
341 SymCryptHmacMd5Algorithm,
342 (PCSYMCRYPT_MAC_EXPANDED_KEY)&pExpandedKey->macMd5Key,
343 rbLabelAndSeed, // This is A(0)
344 cbLabelAndSeed,
345 NULL, // No "seed" part for A(i)'s
346 0,
347 rbAiMd5);
348
349 SymCryptTlsPrfMac(
350 SymCryptHmacSha1Algorithm,
351 (PCSYMCRYPT_MAC_EXPANDED_KEY)&pExpandedKey->macSha1Key,
352 rbLabelAndSeed, // This is A(0)
353 cbLabelAndSeed,
354 NULL, // No "seed" part for A(i)'s
355 0,
356 rbAiSha1);
357
358 // Calculate the output
359 pbTmp = pbResult;
360 while (cbBytesToWrite > 0)
361 {
362 // Calculate the two P_Hashes up to SYMCRYPT_TLS_1_1_CHUNK_SIZE bytes
363
364 // P_MD5
365 SymCryptTlsPrfPHash(
366 SymCryptHmacMd5Algorithm,
367 (PCSYMCRYPT_MAC_EXPANDED_KEY)&pExpandedKey->macMd5Key,
368 rbLabelAndSeed,
369 cbLabelAndSeed,
370 rbAiMd5,
371 SYMCRYPT_HMAC_MD5_RESULT_SIZE,
372 rbPartialResultMd5,
373 SYMCRYPT_MIN(cbBytesToWrite, SYMCRYPT_TLS_1_1_CHUNK_SIZE),
374 rbAiMd5,
375 SYMCRYPT_HMAC_MD5_RESULT_SIZE);
376
377 // P_SHA1
378 SymCryptTlsPrfPHash(
379 SymCryptHmacSha1Algorithm,
380 (PCSYMCRYPT_MAC_EXPANDED_KEY)&pExpandedKey->macSha1Key,
381 rbLabelAndSeed,
382 cbLabelAndSeed,
383 rbAiSha1,
384 SYMCRYPT_HMAC_SHA1_RESULT_SIZE,
385 rbPartialResultSha1,
386 SYMCRYPT_MIN(cbBytesToWrite, SYMCRYPT_TLS_1_1_CHUNK_SIZE),
387 rbAiSha1,
388 SYMCRYPT_HMAC_SHA1_RESULT_SIZE);
389
390 // XOR the two into the output
391 SymCryptXorBytes(
392 rbPartialResultMd5,
393 rbPartialResultSha1,
394 pbTmp,
395 SYMCRYPT_MIN(cbBytesToWrite, SYMCRYPT_TLS_1_1_CHUNK_SIZE));
396
397 if (cbBytesToWrite <= SYMCRYPT_TLS_1_1_CHUNK_SIZE)
398 {
399 break;
400 }
401
402 cbBytesToWrite -= SYMCRYPT_TLS_1_1_CHUNK_SIZE;
403 pbTmp += SYMCRYPT_TLS_1_1_CHUNK_SIZE;
404
405 }
406
407cleanup:
408 SymCryptWipeKnownSize(rbLabelAndSeed, sizeof(rbLabelAndSeed));
409 SymCryptWipeKnownSize(rbAiMd5, sizeof(rbAiMd5));
410 SymCryptWipeKnownSize(rbPartialResultMd5, sizeof(rbPartialResultMd5));
411 SymCryptWipeKnownSize(rbAiSha1, sizeof(rbAiSha1));
412 SymCryptWipeKnownSize(rbPartialResultSha1, sizeof(rbPartialResultSha1));
413
414 return scError;
415}
SymCryptHmacMd5Algorithm
const PCSYMCRYPT_MAC SymCryptHmacMd5Algorithm
Definition: hmacmd5.c:29
SYMCRYPT_TLS_MAX_LABEL_SIZE
#define SYMCRYPT_TLS_MAX_LABEL_SIZE
Definition: symcrypt.h:5671
SYMCRYPT_TLS_MAX_SEED_SIZE
#define SYMCRYPT_TLS_MAX_SEED_SIZE
Definition: symcrypt.h:5672
SymCryptTlsPrfPHash
VOID SYMCRYPT_CALL SymCryptTlsPrfPHash(_In_ PCSYMCRYPT_MAC pMacAlgorithm, _In_ PCSYMCRYPT_MAC_EXPANDED_KEY pMacExpandedKey, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _In_reads_opt_(cbAiIn) PCBYTE pbAiIn, _In_ SIZE_T cbAiIn, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, _Out_writes_opt_(cbAiOut) PBYTE pbAiOut, SIZE_T cbAiOut)
Definition: tlsprf.c:204
SymCryptTlsPrfMac
VOID SYMCRYPT_CALL SymCryptTlsPrfMac(_In_ PCSYMCRYPT_MAC pMacAlgorithm, _In_ PCSYMCRYPT_MAC_EXPANDED_KEY pMacExpandedKey, _In_reads_(cbAi) PCBYTE pbAi, _In_ SIZE_T cbAi, _In_reads_opt_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_ PBYTE pbResult)
Definition: tlsprf.c:160
SYMCRYPT_TLS_1_1_CHUNK_SIZE
#define SYMCRYPT_TLS_1_1_CHUNK_SIZE
Definition: tlsprf.c:23
SYMCRYPT_TLS_MAX_LABEL_AND_SEED_SIZE
#define SYMCRYPT_TLS_MAX_LABEL_AND_SEED_SIZE
Definition: tlsprf.c:19

Referenced by SymCryptTlsPrf1_1().

◆ SymCryptTlsPrf1_1ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1ExpandKey ( _Out_ PSYMCRYPT_TLSPRF1_1_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 58 of file tlsprf.c.

62{
63 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
64
65 SIZE_T cbKeySize;
66 SIZE_T cbHalfSecret;
67 SIZE_T cbOdd;
68
69 // Calculating the two halves
70 cbHalfSecret = cbKey / 2;
71 cbOdd = cbKey % 2;
72 cbKeySize = cbHalfSecret + cbOdd;
73
74 //
75 // The bytes of the key material are split as following:
76 // cbOdd == 0 => cbKeySize == cbHalfSecret
77 //
78 // ********************************************
79 // <----cbHalfSecret----><----cbHalfSecret---->
80 // <----cbKeySize-------><----cbKeySize------->
81 //
82 //
83 // cbOdd == 1 => cbKeySize == cbHalfSecret + 1
84 //
85 // **********************$**********************
86 // <----cbHalfSecret----> <----cbHalfSecret---->
87 // <----cbKeySize-------->
88 // <----cbKeySize-------->
89 //
90 // Note that the middle byte of the key input might be
91 // read twice (when the key length is odd). This violates
92 // the standard rule that input data should only be read
93 // once. In this case, we do this for the following reasons:
94 // - Avoiding the dual-read is difficult; we'd have to buffer
95 // an arbitrary-size input, and SymCrypt avoids memory
96 // allocations for symmetric algorithms.
97 // - The dual-reading of inputs is a problem when the
98 // memory is double-mapped to a different (less trusted)
99 // security context. (E.g. a kernel-mode operation on
100 // memory that is also mapped into a user address space.)
101 // This PRF is used by TLS in LSA where that situation
102 // does not occur.
103 // - This is used for TLS 1.0 and TLS 1.1, both of which
104 // are on the deprecation path.
105 // - In the dual-read attack, the input is typically provided
106 // by the attacker, and then changed whilst the code is
107 // accessing it. But if the attacker is providing the input,
108 // she could just as well have provided an even-length key
109 // input that provides full freedom for choosing both HMAC
110 // keys; there is simply no reason to try and perform the
111 // dual-read attack.
112 // - Even if the dual-read problem were to occur, it does not
113 // seem to help an attacker in any way.
114
115 // MD5 Key Expansion
116 scError = SymCryptHmacMd5ExpandKey(&pExpandedKey->macMd5Key, pbKey, cbKeySize);
117 if (scError != SYMCRYPT_NO_ERROR)
118 {
119 goto cleanup;
120 }
121
122 // SHA1 Key Expansion
123 scError = SymCryptHmacSha1ExpandKey(&pExpandedKey->macSha1Key, pbKey + cbHalfSecret, cbKeySize);
124 if (scError != SYMCRYPT_NO_ERROR)
125 {
126 SymCryptWipeKnownSize(&pExpandedKey->macMd5Key, sizeof(pExpandedKey->macMd5Key));
127
128 goto cleanup;
129 }
130
131cleanup:
132 return scError;
133}

Referenced by SymCryptTlsPrf1_1().

◆ SymCryptTlsPrf1_1SelfTest()

VOID SYMCRYPT_CALL SymCryptTlsPrf1_1SelfTest ( void  )

◆ SymCryptTlsPrf1_2()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2 ( _In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbKey) PCBYTE  pbKey,
_In_ SIZE_T  cbKey,
_In_reads_opt_(cbLabel) PCBYTE  pbLabel,
_In_ SIZE_T  cbLabel,
_In_reads_(cbSeed) PCBYTE  pbSeed,
_In_ SIZE_T  cbSeed,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 530 of file tlsprf.c.

540{
541 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
542 SYMCRYPT_TLSPRF1_2_EXPANDED_KEY key;
543
544 // Create the expanded key
545 scError = SymCryptTlsPrf1_2ExpandKey(&key, pMacAlgorithm, pbKey, cbKey);
546 if (scError != SYMCRYPT_NO_ERROR)
547 {
548 goto cleanup;
549 }
550
551 // Derive the key
552 scError = SymCryptTlsPrf1_2Derive(
553 &key,
554 pbLabel,
555 cbLabel,
556 pbSeed,
557 cbSeed,
558 pbResult,
559 cbResult);
560 if (scError != SYMCRYPT_NO_ERROR)
561 {
562 goto cleanup;
563 }
564
565cleanup:
566 SymCryptWipeKnownSize(&key, sizeof(key));
567
568 return scError;
569}
_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY
Definition: symcrypt_internal.h:2235
SymCryptTlsPrf1_2Derive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2Derive(_In_ PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: tlsprf.c:426
SymCryptTlsPrf1_2ExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2ExpandKey(_Out_ PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: tlsprf.c:137

◆ SymCryptTlsPrf1_2Derive()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2Derive ( _In_ PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY  pExpandedKey,
_In_reads_opt_(cbLabel) PCBYTE  pbLabel,
_In_ SIZE_T  cbLabel,
_In_reads_(cbSeed) PCBYTE  pbSeed,
_In_ SIZE_T  cbSeed,
_Out_writes_(cbResult) PBYTE  pbResult,
SIZE_T  cbResult 
)

Definition at line 426 of file tlsprf.c.

434{
435 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
436
437 SYMCRYPT_ALIGN BYTE rbLabelAndSeed[SYMCRYPT_TLS_MAX_LABEL_AND_SEED_SIZE];
438 BYTE * pbTmp;
439
440 // Size checks
441 if ((cbLabel > SYMCRYPT_TLS_MAX_LABEL_SIZE) || (cbSeed > SYMCRYPT_TLS_MAX_SEED_SIZE))
442 {
443 scError = SYMCRYPT_WRONG_DATA_SIZE;
444 goto cleanup;
445 }
446
447 // Concatenating the label and the seed
448 pbTmp = rbLabelAndSeed;
449 if( cbLabel > 0 )
450 {
451 memcpy(pbTmp, pbLabel, cbLabel);
452 pbTmp += cbLabel;
453 }
454 memcpy(pbTmp, pbSeed, cbSeed);
455
456 //
457 // According to RFC 2104 (HMAC), hash the secret if its length
458 // exceeds the basic compression block length. This is taken
459 // care by the specific HMAC inside SymCryptTlsPrfPHash.
460 //
461 SymCryptTlsPrfPHash(
462 pExpandedKey->macAlg,
463 &pExpandedKey->macKey,
464 rbLabelAndSeed,
465 cbLabel + cbSeed,
466 NULL,
467 0,
468 pbResult,
469 cbResult,
470 NULL,
471 0);
472
473cleanup:
474 SymCryptWipeKnownSize(rbLabelAndSeed, sizeof(rbLabelAndSeed));
475
476 return scError;
477}

Referenced by SymCryptTlsPrf1_2().

◆ SymCryptTlsPrf1_2ExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2ExpandKey ( _Out_ PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY  pExpandedKey,
_In_ PCSYMCRYPT_MAC  macAlgorithm,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 137 of file tlsprf.c.

142{
143 SYMCRYPT_ASSERT( macAlgorithm->expandedKeySize <= sizeof( pExpandedKey->macKey ) );
144
145 pExpandedKey->macAlg = macAlgorithm;
146 return macAlgorithm->expandKeyFunc( &pExpandedKey->macKey, pbKey, cbKey );
147}

Referenced by SymCryptTlsPrf1_2().

◆ SymCryptTlsPrf1_2SelfTest()

VOID SYMCRYPT_CALL SymCryptTlsPrf1_2SelfTest ( void  )

◆ SymCryptUint32Bitsize()

UINT32 SymCryptUint32Bitsize ( UINT32  value)

Definition at line 262 of file libmain.c.

267{
268 UINT32 res;
269
270 res = 0;
271 while( value != 0 )
272 {
273 res += 1;
274 value >>= 1;
275 }
276
277 return res;
278}
value
Definition: pdh_main.c:64

Referenced by SymCryptUint64Bitsize().

◆ SymCryptUint32Bytesize()

UINT32 SymCryptUint32Bytesize ( UINT32  value)

Definition at line 299 of file libmain.c.

300{
301 if( value == 0 )
302 {
303 return 0;
304 }
305 if( value < 0x100 )
306 {
307 return 1;
308 }
309 if( value < 0x10000 )
310 {
311 return 2;
312 }
313 if( value < 0x1000000 )
314 {
315 return 3;
316 }
317 return 4;
318}

Referenced by SymCryptUint64Bytesize().

◆ SymCryptUint64Bitsize()

UINT32 SymCryptUint64Bitsize ( UINT64  value)

Definition at line 281 of file libmain.c.

282{
283 UINT32 res;
284 UINT32 upper;
285
286 upper = (UINT32)(value >> 32);
287
288 if( upper == 0 )
289 {
290 res = SymCryptUint32Bitsize( (UINT32) value );
291 } else {
292 res = 32 + SymCryptUint32Bitsize( upper );
293 }
294
295 return res;
296}
SymCryptUint32Bitsize
UINT32 SymCryptUint32Bitsize(UINT32 value)
Definition: libmain.c:262

◆ SymCryptUint64Bytesize()

UINT32 SymCryptUint64Bytesize ( UINT64  value)

Definition at line 321 of file libmain.c.

322{
323 UINT32 res;
324 UINT32 upper;
325
326 upper = (UINT32)(value >> 32);
327
328 if( upper == 0 )
329 {
330 res = SymCryptUint32Bytesize( (UINT32) value );
331 } else {
332 res = 4 + SymCryptUint32Bytesize( upper );
333 }
334
335 return res;
336}
SymCryptUint32Bytesize
UINT32 SymCryptUint32Bytesize(UINT32 value)
Definition: libmain.c:299

Referenced by SymCryptRsakeySizeofPublicExponent().

◆ SymCryptWipe()

VOID SYMCRYPT_CALL SymCryptWipe ( _Out_writes_bytes_(cbData) PVOID  pbData,
SIZE_T  cbData 
)

Definition at line 137 of file libmain.c.

138{
139 volatile BYTE * p = (volatile BYTE *) pbData;
140 SIZE_T i;
141
142 for( i=0; i<cbData; i++ ){
143 p[i] = 0;
144 }
145
146}

Referenced by SymCrypt802_11SaeCustomCommitCreateGeneric(), SymCrypt802_11SaeCustomCommitProcessGeneric(), SymCrypt802_11SaeCustomCreatePTGeneric(), SymCrypt802_11SaeCustomInit(), SymCrypt802_11SaeCustomInitH2EGeneric(), SYMCRYPT_HmacXxxResult(), SymCryptAesCmacResult(), SymCryptAesKwDecrypt(), SymCryptAesKwEncrypt(), SymCryptAesKwpDecrypt(), SymCryptAesKwpEncrypt(), SymCryptCcmDecrypt(), SymCryptCcmDecryptFinal(), SymCryptCcmEncryptFinal(), SymCryptChaCha20Crypt(), SymCryptDhSecretAgreement(), SymCryptDivisorWipe(), SymCryptDlgroupGenerate(), SymCryptDlgroupGetValue(), SymCryptDlgroupSetValue(), SymCryptDlgroupSetValueSafePrime(), SymCryptDlgroupWipe(), SymCryptDlkeyGenerate(), SymCryptDlkeyGetValue(), SymCryptDlkeySetValue(), SymCryptDlkeyWipe(), SymCryptDsaSignEx(), SymCryptDsaVerify(), SymCryptEcDhSecretAgreement(), SymCryptEcDsaSignEx(), SymCryptEcDsaVerify(), SymCryptEckeyGetValue(), SymCryptEckeySetRandom(), SymCryptEckeySetValue(), SymCryptEckeyWipe(), SymCryptEcpointWipe(), SymCryptEcurveAllocate(), SymCryptEcurveFree(), SymCryptEcurveInitialize(), SymCryptFdefClaimScratch(), SymCryptFdefCreateTrialDivisionContext(), SymCryptFdefFreeTrialDivisionContext(), SymCryptFdefIntAddMixedSize(), SymCryptFdefIntCopyMixedSize(), SymCryptFdefIntDivMod(), SymCryptFdefIntDivPow2(), SymCryptFdefIntMulMixedSize(), SymCryptFdefIntMulPow2(), SymCryptFdefIntSetValueUint32(), SymCryptFdefIntSetValueUint64(), SymCryptFdefIntSquare(), SymCryptFdefModElementSetValueNegUint32(), SymCryptFdefModElementSetValueUint32Generic(), SymCryptFdefModElementToIntGeneric(), SymCryptFdefModElementWipe(), SymCryptFdefModInvMontgomery(), SymCryptFdefModPreGetMontgomery(), SymCryptFdefModSetRandomGeneric(), SymCryptFdefModulusInitMontgomeryInternal(), SymCryptFdefRawDivMod(), SymCryptFdefRawMulC(), SymCryptFdefRawSquareC(), SymCryptGcmDecrypt(), SymCryptGcmPadMacData(), SymCryptGenerateSmallPrimes(), SymCryptHash(), SymCryptHashCommonPaddingMd4Style(), SymCryptHashResult(), SymCryptIntWipe(), SymCryptLmskeyAllocate(), SymCryptMlDsaHintBitPack(), SymCryptMlDsakeyFree(), SymCryptMlDsakeyGenerate(), SymCryptMlDsakeyInitialize(), SymCryptMlDsaTemporariesAllocateAndInitialize(), SymCryptMlDsaTemporariesFree(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulateEx(), SymCryptMlKemkeyFree(), SymCryptMlKemkeyGenerate(), SymCryptMlKemkeySetValue(), SymCryptMlKemVectorSetZero(), SymCryptModMultiExpWnafWithInterleaving(), SymCryptModulusWipe(), SymCryptPoly1305Result(), SymCryptRc4Init(), SymCryptRngAesBcc(), SymCryptRngAesGenerateBlocks(), SymCryptRsakeyCreate(), SymCryptRsakeyGenerate(), SymCryptRsakeyGetCrtValue(), SymCryptRsakeySetValueInternal(), SymCryptRsakeyWipe(), SymCryptRsaOaepApplyEncryptionPadding(), SymCryptRsaOaepDecrypt(), SymCryptRsaOaepEncrypt(), SymCryptRsaPkcs1CheckSignaturePadding(), SymCryptRsaPkcs1Decrypt(), SymCryptRsaPkcs1Encrypt(), SymCryptRsaPkcs1Sign(), SymCryptRsaPkcs1Verify(), SymCryptRsaPssApplySignaturePadding(), SymCryptRsaPssSign(), SymCryptRsaPssVerify(), SymCryptRsaPssVerifySignaturePadding(), SymCryptRsaRawDecrypt(), SymCryptRsaRawEncrypt(), SymCryptScsTableWipe(), SymCryptSessionGcmDecrypt(), SymCryptSha256Result(), SymCryptSha512Result(), SymCryptSrtpKdfDerive(), SymCryptTlsCbcHmacVerifyCore(), SymCryptXmssComputePublicRoot(), SymCryptXmsskeyAllocate(), SymCryptXmssPrfInit(), SymCryptXmssRandomizedHash(), SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptWipeKnownSize()

FORCEINLINE VOID SYMCRYPT_CALL SymCryptWipeKnownSize ( _Out_writes_bytes_(cbData) PVOID  pbData,
SIZE_T  cbData 
)

Definition at line 3411 of file symcrypt_internal.h.

3412{
3413 SymCryptWipe(pbData, cbData);
3414}
SymCryptWipe
VOID SYMCRYPT_CALL SymCryptWipe(_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
Definition: libmain.c:137

Referenced by LmskeyWipe(), SymCrypt802_11SaeCustomDestroy(), SymCrypt802_11SaeCustomInit(), SymCrypt802_11SaeCustomInitH2EGeneric(), SYMCRYPT_HmacXxxExpandKey(), SYMCRYPT_XtsAesXxx(), SymCryptAesCmac(), SymCryptAesCmacExpandKey(), SymCryptAesCmacInit(), SymCryptAesCmacResult(), SymCryptAesDecryptC(), SymCryptAesEncryptC(), SymCryptAesGcmDecryptPartOnePass(), SymCryptAesGcmEncryptPartOnePass(), SymCryptAesKwxInternalUnwrap(), SymCryptAesKwxInternalWrap(), SymCryptCbcDecrypt(), SymCryptCbcEncrypt(), SymCryptCbcMac(), SymCryptCcmDecryptFinal(), SymCryptCcmEncryptDecryptPart(), SymCryptCcmEncryptFinal(), SymCryptCcmInit(), SymCryptChaCha20Poly1305ComputeTag(), SymCryptChaCha20Poly1305Decrypt(), SymCryptChaCha20Poly1305Encrypt(), SymCryptCtrMsb32(), SymCryptCtrMsb64(), SymCryptDesxDecrypt(), SymCryptDesxEncrypt(), SymCryptExternalMuMlDsaSign(), SymCryptFdefModElementCreate(), SymCryptGcmComputeTag(), SymCryptGcmDecrypt(), SymCryptGcmDecryptFinal(), SymCryptGcmEncrypt(), SymCryptGcmEncryptDecryptPart(), SymCryptGcmEncryptFinal(), SymCryptGcmExpandKey(), SymCryptGcmInit(), SymCryptGcmSetNonce(), SymCryptGHashAppendDataC(), SymCryptHashMlDsaSign(), SymCryptHkdf(), SymCryptHkdfDerive(), SymCryptHkdfExpandKey(), SymCryptHkdfExtractPrk(), SymCryptHmacExpandKey(), SymCryptHmacResult(), SymCryptKeccakReset(), SymCryptKeccakStateExport(), SymCryptKeccakStateImport(), SymCryptLmskeyFree(), SymCryptLmskeySetValue(), SymCryptLmsParamsFromAlgId(), SymCryptLmsSetParams(), SymCryptMd2Init(), SymCryptMd2StateExport(), SymCryptMd2StateImport(), SymCryptMd4AppendBlocks(), SymCryptMd4Result(), SymCryptMd4StateExport(), SymCryptMd4StateImport(), SymCryptMd5AppendBlocks(), SymCryptMd5Result(), SymCryptMd5StateExport(), SymCryptMd5StateImport(), SymCryptMlDsaExpandS(), SymCryptMlDsakeyGenerate(), SymCryptMlDsaKeyGenerateEx(), SymCryptMlDsaPkDecode(), SymCryptMlDsaRejBoundedPoly(), SymCryptMlDsaRejNttPoly(), SymCryptMlDsaSampleInBall(), SymCryptMlDsaSign(), SymCryptMlDsaSkDecode(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulate(), SymCryptMlKemEncapsulateInternal(), SymCryptMlKemkeyExpandFromPrivateSeed(), SymCryptMlKemkeyGenerate(), SymCryptMlKemkeyInitialize(), SymCryptMlKemkeyWipePrivateState(), SymCryptMlKemMatrixVectorMontMulAndAdd(), SymCryptMlKemVectorMontDotProduct(), SymCryptPbkdf2(), SymCryptPbkdf2Derive(), SymCryptPoly1305Init(), SymCryptPoly1305Result(), SymCryptRc2ExpandKeyEx(), SymCryptRngAesDf(), SymCryptRngAesGenerateSmall(), SymCryptRngAesInstantiate(), SymCryptRngAesReseed(), SymCryptRngAesUninstantiate(), SymCryptRngAesUpdate(), SymCryptSessionDestroy(), SymCryptSha1AppendBlocks(), SymCryptSha1Result(), SymCryptSha1StateExport(), SymCryptSha1StateImport(), SymCryptSha224Result(), SymCryptSha256AppendBlocks_ul1(), SymCryptSha256AppendBlocks_ul2(), SymCryptSha256Result(), SymCryptSha256StateExportCore(), SymCryptSha256StateImportCore(), SymCryptSha384Result(), SymCryptSha512_224Result(), SymCryptSha512_256Result(), SymCryptSha512AppendBlocks_ull(), SymCryptSha512AppendBlocks_ull2(), SymCryptSha512AppendBlocks_ull3(), SymCryptSha512Result(), SymCryptSha512StateExportCore(), SymCryptSha512StateImportCore(), SymCryptSp800_108(), SymCryptSp800_108Derive(), SymCryptSrtpKdf(), SymCryptSrtpKdfDerive(), SymCryptSshKdf(), SymCryptSskdfMac(), SymCryptSskdfMacDerive(), SymCryptTlsPrf1_1(), SymCryptTlsPrf1_1Derive(), SymCryptTlsPrf1_1ExpandKey(), SymCryptTlsPrf1_2(), SymCryptTlsPrf1_2Derive(), SymCryptTlsPrfPHash(), SymCryptXmssComputePublicRoot(), SymCryptXmssComputeRandomness(), SymCryptXmsskeyFree(), SymCryptXmsskeyGenerate(), SymCryptXmsskeySetValue(), SymCryptXmsskeyVerifyRoot(), SymCryptXmssParamsFromAlgIdCommon(), SymCryptXmssSetAdrsType(), SymCryptXmssSetParams(), SymCryptXmssSign(), SymCryptXmssVerifyInternal(), SymCryptXmssWotspSign(), SymCryptXtsAesSelftest(), SymCryptXtsDecryptDataUnit(), and SymCryptXtsEncryptDataUnit().

◆ SymCryptXmsskeyAllocate()

PSYMCRYPT_XMSS_KEY SYMCRYPT_CALL SymCryptXmsskeyAllocate ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
UINT32  flags 
)

Definition at line 535 of file xmss.c.

538{
539 PSYMCRYPT_XMSS_KEY pKey = NULL;
540
541 // No flags allowed
542 if (flags != 0)
543 {
544 goto cleanup;
545 }
546
547 SIZE_T cbSize = sizeof(SYMCRYPT_XMSS_KEY);
548
549 pKey = SymCryptCallbackAlloc(cbSize);
550
551 if (pKey == NULL)
552 {
553 goto cleanup;
554 }
555
556 SymCryptWipe(pKey, cbSize);
557 pKey->version = 1;
558 pKey->keyType = SYMCRYPT_XMSSKEY_TYPE_NONE;
559 pKey->params = *pParams;
560
561 SYMCRYPT_SET_MAGIC(pKey);
562
563 cleanup:
564
565 return pKey;
566}
SYMCRYPT_XMSS_KEY
struct _SYMCRYPT_XMSS_KEY SYMCRYPT_XMSS_KEY
Definition: symcrypt_internal.h:3110
PSYMCRYPT_XMSS_KEY
SYMCRYPT_XMSS_KEY * PSYMCRYPT_XMSS_KEY
Definition: symcrypt_internal.h:3111

◆ SymCryptXmsskeyFree()

VOID SYMCRYPT_CALL SymCryptXmsskeyFree ( _Inout_ PSYMCRYPT_XMSS_KEY  pKey)

Definition at line 571 of file xmss.c.

573{
574 SYMCRYPT_CHECK_MAGIC(pKey);
575 SymCryptWipeKnownSize(pKey, sizeof(*pKey));
576 SymCryptCallbackFree(pKey);
577}

◆ SymCryptXmsskeyGenerate()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyGenerate ( _Inout_ PSYMCRYPT_XMSS_KEY  pKey,
UINT32  flags 
)

Definition at line 1177 of file xmss.c.

1180{
1181 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1182
1183 SYMCRYPT_CHECK_MAGIC(pKey);
1184
1185 if (flags != 0)
1186 {
1187 scError = SYMCRYPT_INVALID_ARGUMENT;
1188 goto cleanup;
1189 }
1190
1191 // Wipe key material
1192 SymCryptWipeKnownSize(pKey->Root, sizeof(pKey->Root));
1193 SymCryptWipeKnownSize(pKey->Seed, sizeof(pKey->Seed));
1194 SymCryptWipeKnownSize(pKey->SkPrf, sizeof(pKey->SkPrf));
1195 SymCryptWipeKnownSize(pKey->SkXmss, sizeof(pKey->SkXmss));
1196 pKey->Idx = 0;
1197
1198 scError = SymCryptCallbackRandom(pKey->SkPrf, pKey->params.cbHashOutput);
1199
1200 if (scError != SYMCRYPT_NO_ERROR)
1201 {
1202 goto cleanup;
1203 }
1204
1205 scError = SymCryptCallbackRandom(pKey->SkXmss, pKey->params.cbHashOutput);
1206
1207 if (scError != SYMCRYPT_NO_ERROR)
1208 {
1209 goto cleanup;
1210 }
1211
1212 scError = SymCryptCallbackRandom(pKey->Seed, pKey->params.cbHashOutput);
1213
1214 if (scError != SYMCRYPT_NO_ERROR)
1215 {
1216 goto cleanup;
1217 }
1218
1219 // Compute public root from the private key
1220 scError = SymCryptXmssComputePublicRoot(
1221 &pKey->params,
1222 pKey->Seed,
1223 pKey->params.cbHashOutput,
1224 pKey->SkXmss,
1225 pKey->params.cbHashOutput,
1226 pKey->Root,
1227 pKey->params.cbHashOutput);
1228
1229 if (scError != SYMCRYPT_NO_ERROR)
1230 {
1231 goto cleanup;
1232 }
1233
1234 pKey->keyType = SYMCRYPT_XMSSKEY_TYPE_PRIVATE;
1235
1236cleanup:
1237
1238 if (scError != SYMCRYPT_NO_ERROR)
1239 {
1240 SymCryptWipeKnownSize(pKey->SkPrf, sizeof(pKey->SkPrf));
1241 SymCryptWipeKnownSize(pKey->SkXmss, sizeof(pKey->SkXmss));
1242 pKey->keyType = SYMCRYPT_XMSSKEY_TYPE_NONE;
1243 }
1244
1245 return scError;
1246}
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: xmss.c:1069

◆ SymCryptXmsskeyGetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyGetValue ( _In_ PCSYMCRYPT_XMSS_KEY  pKey,
SYMCRYPT_XMSSKEY_TYPE  keyType,
UINT32  flags,
_Out_writes_bytes_(cbOutput) PBYTE  pbOutput,
SIZE_T  cbOutput 
)

Definition at line 1349 of file xmss.c.

1355{
1356 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1357 SIZE_T cbKey;
1358
1359 SYMCRYPT_ASSERT(keyType == SYMCRYPT_XMSSKEY_TYPE_PUBLIC || keyType == SYMCRYPT_XMSSKEY_TYPE_PRIVATE);
1360
1361 SYMCRYPT_CHECK_MAGIC(pKey);
1362
1363 if (flags != 0 ||
1364 (keyType != SYMCRYPT_XMSSKEY_TYPE_PUBLIC && keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE) ||
1365 pKey->keyType == SYMCRYPT_XMSSKEY_TYPE_NONE)
1366 {
1367 scError = SYMCRYPT_INVALID_ARGUMENT;
1368 goto cleanup;
1369 }
1370
1371 // Cannot export private key from a public key object
1372 if (keyType == SYMCRYPT_XMSSKEY_TYPE_PRIVATE && pKey->keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE)
1373 {
1374 scError = SYMCRYPT_INVALID_ARGUMENT;
1375 goto cleanup;
1376 }
1377
1378 SymCryptXmssSizeofKeyBlobFromParams(&pKey->params, keyType, &cbKey);
1379
1380 if (cbOutput != cbKey)
1381 {
1382 scError = SYMCRYPT_INVALID_ARGUMENT;
1383 goto cleanup;
1384 }
1385
1386 //
1387 // Public Key
1388 //
1389
1390 // Alg Id
1391 SYMCRYPT_STORE_MSBFIRST32(pbOutput, pKey->params.id);
1392 pbOutput += sizeof(UINT32);
1393
1394 // Root
1395 memcpy(pbOutput, pKey->Root, pKey->params.cbHashOutput);
1396 pbOutput += pKey->params.cbHashOutput;
1397
1398 // Seed
1399 memcpy(pbOutput, pKey->Seed, pKey->params.cbHashOutput);
1400 pbOutput += pKey->params.cbHashOutput;
1401
1402 if (keyType == SYMCRYPT_XMSSKEY_TYPE_PRIVATE)
1403 {
1404 //
1405 // Private Key
1406 //
1407
1408 // Idx
1409 SYMCRYPT_STORE_MSBFIRST64(pbOutput, pKey->Idx);
1410 pbOutput += sizeof(pKey->Idx);
1411
1412 // SK_XMSS
1413 memcpy(pbOutput, pKey->SkXmss, pKey->params.cbHashOutput);
1414 pbOutput += pKey->params.cbHashOutput;
1415
1416 // SK_PRF
1417 memcpy(pbOutput, pKey->SkPrf, pKey->params.cbHashOutput);
1418 pbOutput += pKey->params.cbHashOutput;
1419 }
1420
1421cleanup:
1422
1423 return scError;
1424}
SymCryptXmssSizeofKeyBlobFromParams
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssSizeofKeyBlobFromParams(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, SYMCRYPT_XMSSKEY_TYPE keyType, _Out_ SIZE_T *pcbKey)
Definition: xmss.c:497

◆ SymCryptXmsskeySetValue()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeySetValue ( _In_reads_bytes_(cbInput) PCBYTE  pbInput,
SIZE_T  cbInput,
SYMCRYPT_XMSSKEY_TYPE  keyType,
UINT32  flags,
_Inout_ PSYMCRYPT_XMSS_KEY  pKey 
)

Definition at line 1251 of file xmss.c.

1257{
1258 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1259 UINT32 uAlgId;
1260 SIZE_T cbKey;
1261
1262 SYMCRYPT_ASSERT(keyType == SYMCRYPT_XMSSKEY_TYPE_PUBLIC || keyType == SYMCRYPT_XMSSKEY_TYPE_PRIVATE);
1263
1264 SYMCRYPT_CHECK_MAGIC(pKey);
1265
1266 if ((flags & (~SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT)) != 0 ||
1267 (keyType != SYMCRYPT_XMSSKEY_TYPE_PUBLIC && keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE))
1268 {
1269 scError = SYMCRYPT_INVALID_ARGUMENT;
1270 goto cleanup;
1271 }
1272
1273 // Public root validation can only be performed for private keys
1274 if ((flags & SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT) != 0 &&
1275 keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE)
1276 {
1277 scError = SYMCRYPT_INVALID_ARGUMENT;
1278 goto cleanup;
1279 }
1280
1281 SymCryptXmssSizeofKeyBlobFromParams(&pKey->params, keyType, &cbKey);
1282
1283 if (cbInput != cbKey)
1284 {
1285 scError = SYMCRYPT_INVALID_ARGUMENT;
1286 goto cleanup;
1287 }
1288
1289 uAlgId = SYMCRYPT_LOAD_MSBFIRST32(pbInput);
1290 pbInput += sizeof(UINT32);
1291
1292 if (uAlgId != pKey->params.id)
1293 {
1294 scError = SYMCRYPT_INVALID_BLOB;
1295 goto cleanup;
1296 }
1297
1298 // Wipe private key material
1299 pKey->Idx = 0;
1300 SymCryptWipeKnownSize(pKey->SkPrf, sizeof(pKey->SkPrf));
1301 SymCryptWipeKnownSize(pKey->SkXmss, sizeof(pKey->SkXmss));
1302
1303 pKey->keyType = keyType;
1304
1305 memcpy(pKey->Root, pbInput, pKey->params.cbHashOutput);
1306 pbInput += pKey->params.cbHashOutput;
1307
1308 memcpy(pKey->Seed, pbInput, pKey->params.cbHashOutput);
1309 pbInput += pKey->params.cbHashOutput;
1310
1311 if (keyType == SYMCRYPT_XMSSKEY_TYPE_PRIVATE)
1312 {
1313 pKey->Idx = SYMCRYPT_LOAD_MSBFIRST64(pbInput);
1314 pbInput += sizeof(UINT64);
1315
1316 memcpy(pKey->SkXmss, pbInput, pKey->params.cbHashOutput);
1317 pbInput += pKey->params.cbHashOutput;
1318
1319 memcpy(pKey->SkPrf, pbInput, pKey->params.cbHashOutput);
1320 pbInput += pKey->params.cbHashOutput;
1321
1322 if ((flags & SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT) != 0)
1323 {
1324 // pKey has been initialized by now
1325 scError = SymCryptXmsskeyVerifyRoot(pKey);
1326
1327 if (scError != SYMCRYPT_NO_ERROR)
1328 {
1329 goto cleanup;
1330 }
1331 }
1332 }
1333
1334cleanup:
1335
1336 if (scError != SYMCRYPT_NO_ERROR)
1337 {
1338 SymCryptWipeKnownSize(pKey->SkPrf, sizeof(pKey->SkPrf));
1339 SymCryptWipeKnownSize(pKey->SkXmss, sizeof(pKey->SkXmss));
1340 pKey->keyType = SYMCRYPT_XMSSKEY_TYPE_NONE;
1341 }
1342
1343 return scError;
1344}
SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT
#define SYMCRYPT_FLAG_XMSSKEY_VERIFY_ROOT
Definition: symcrypt.h:9243
SymCryptXmsskeyVerifyRoot
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyVerifyRoot(_In_ PCSYMCRYPT_XMSS_KEY pKey)
Definition: xmss.c:1133

◆ SymCryptXmssMtParamsFromAlgId()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssMtParamsFromAlgId ( SYMCRYPT_XMSSMT_ALGID  id,
_Out_ PSYMCRYPT_XMSS_PARAMS  pParams 
)

Definition at line 349 of file xmss.c.

352{
353 return SymCryptXmssParamsFromAlgIdCommon(id, TRUE, pParams);
354}
SymCryptXmssParamsFromAlgIdCommon
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssParamsFromAlgIdCommon(UINT32 id, BOOLEAN isMultiTree, _Out_ PSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:291

◆ SymCryptXmssParamsFromAlgId()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssParamsFromAlgId ( SYMCRYPT_XMSS_ALGID  id,
_Out_ PSYMCRYPT_XMSS_PARAMS  pParams 
)

Definition at line 339 of file xmss.c.

342{
343 return SymCryptXmssParamsFromAlgIdCommon(id, FALSE, pParams);
344}

◆ SymCryptXmssSelftest()

VOID SYMCRYPT_CALL SymCryptXmssSelftest ( void  )

Referenced by SymCryptXmssVerify().

◆ SymCryptXmssSetParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssSetParams ( _Out_ PSYMCRYPT_XMSS_PARAMS  pParams,
UINT32  id,
_In_ PCSYMCRYPT_HASH  pHash,
UINT32  cbHashOutput,
UINT32  nWinternitzWidth,
UINT32  nTotalTreeHeight,
UINT32  nLayers,
UINT32  cbPrefix 
)

Definition at line 365 of file xmss.c.

375{
376 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
377
378 if (pParams == NULL)
379 {
380 scError = SYMCRYPT_INVALID_ARGUMENT;
381 goto cleanup;
382 }
383
384 SymCryptWipeKnownSize(pParams, sizeof(*pParams));
385
386 if (pHash == NULL)
387 {
388 scError = SYMCRYPT_INVALID_ARGUMENT;
389 goto cleanup;
390 }
391
392 // Output size n can at most be equal to the hash output size
393 if (cbHashOutput == 0 ||
394 cbHashOutput > pHash->resultSize ||
395 cbHashOutput > SYMCRYPT_HASH_MAX_RESULT_SIZE)
396 {
397 scError = SYMCRYPT_INVALID_ARGUMENT;
398 goto cleanup;
399 }
400
401 // Winternitz parameter must be one of 1, 2, 4, or 8
402 if (nWinternitzWidth == 0 ||
403 nWinternitzWidth > 8 ||
404 (nWinternitzWidth & (nWinternitzWidth - 1)) != 0)
405 {
406 scError = SYMCRYPT_INVALID_ARGUMENT;
407 goto cleanup;
408 }
409
410 // nTotalTreeHeight and nLayers must both be positive and
411 // nLayers must divide nTotalTreeHeight
412 if (nTotalTreeHeight == 0 ||
413 nLayers == 0 ||
414 (nTotalTreeHeight % nLayers) != 0)
415 {
416 scError = SYMCRYPT_INVALID_ARGUMENT;
417 goto cleanup;
418 }
419
420 // Layer height (tree height of one layer) can be at most 31
421 if ((nTotalTreeHeight / nLayers) > 31)
422 {
423 scError = SYMCRYPT_INVALID_ARGUMENT;
424 goto cleanup;
425 }
426
427 // Total tree height can be at most 63
428 if (nTotalTreeHeight > 63)
429 {
430 scError = SYMCRYPT_INVALID_ARGUMENT;
431 goto cleanup;
432 }
433
434 if (cbPrefix == 0)
435 {
436 scError = SYMCRYPT_INVALID_ARGUMENT;
437 goto cleanup;
438 }
439
440 pParams->id = id;
441 pParams->hash = pHash;
442 pParams->cbHashOutput = cbHashOutput;
443 pParams->nWinternitzWidth = nWinternitzWidth;
444 pParams->nTotalTreeHeight = nTotalTreeHeight;
445 pParams->nLayers = nLayers;
446 SymCryptXmssDeriveParams(pParams);
447
448 pParams->cbPrefix = cbPrefix;
449
450cleanup:
451
452 return scError;
453}
id
GLuint id
Definition: glext.h:5910
cbPrefix
UINT32 cbPrefix
Definition: symcrypt_internal.h:3091
nTotalTreeHeight
UINT32 nTotalTreeHeight
Definition: symcrypt_internal.h:3089
nLayers
UINT32 nLayers
Definition: symcrypt_internal.h:3090
nWinternitzWidth
UINT32 nWinternitzWidth
Definition: symcrypt_internal.h:3088
SymCryptXmssDeriveParams
VOID SYMCRYPT_CALL SymCryptXmssDeriveParams(_Inout_ PSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:255

◆ SymCryptXmssSign()

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

Definition at line 2023 of file xmss.c.

2030{
2031 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
2032 PBYTE pbScratch = NULL;
2033 SIZE_T cbScratch = 0;
2034 PSYMCRYPT_XMSS_PARAMS pParams = &pKey->params;
2035 UINT64 Idx;
2036 BYTE en64Idx[sizeof(UINT64)];
2037 BYTE Randomness[SYMCRYPT_HASH_MAX_RESULT_SIZE];
2038 BYTE RandomizedHash[SYMCRYPT_HASH_MAX_RESULT_SIZE];
2039 BYTE TreeRoot[SYMCRYPT_HASH_MAX_RESULT_SIZE];
2040 XMSS_ADRS adrs;
2041 UINT32 uLayer;
2042 UINT64 uTree;
2043 UINT32 uLeaf;
2044 const UINT64 LeafMask = (1ULL << pParams->nLayerHeight) - 1;
2045
2046 SYMCRYPT_CHECK_MAGIC(pKey);
2047
2048 SYMCRYPT_ASSERT(pParams->nLayerHeight < 32); // Ensure nLeaves fits in 32 bits
2049
2050 if (flags != 0 ||
2051 pbSignature == NULL ||
2052 cbSignature != SymCryptXmssSizeofSignatureFromParams(pParams) ||
2053 pKey->keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE )
2054 {
2055 scError = SYMCRYPT_INVALID_ARGUMENT;
2056 goto cleanup;
2057 }
2058
2059 cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len); // Ltree hashing
2060 cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, 1ULL << pParams->nLayerHeight); // Merkle-tree hashing
2061
2062 pbScratch = (PBYTE)SymCryptCallbackAlloc(cbScratch);
2063
2064 if (pbScratch == NULL)
2065 {
2066 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
2067 goto cleanup;
2068 }
2069
2070 Idx = SYMCRYPT_ATOMIC_ADD64_POST_RELAXED(&pKey->Idx, 1) - 1;
2071 if (Idx >= (1ULL << pParams->nTotalTreeHeight))
2072 {
2073 // Set Idx to first unusable value
2074 pKey->Idx = (1ULL << pParams->nTotalTreeHeight);
2075
2076 scError = SYMCRYPT_HBS_NO_OTS_KEYS_LEFT;
2077 goto cleanup;
2078 }
2079
2080 SYMCRYPT_STORE_MSBFIRST64(en64Idx, Idx);
2081 memcpy(pbSignature, &en64Idx[sizeof(en64Idx) - pParams->cbIdx], pParams->cbIdx);
2082
2083 SymCryptXmssComputeRandomness(pKey, Idx, Randomness);
2084 memcpy(SymCryptXmssSignatureGetRandomness(pParams, pbSignature), Randomness, pKey->params.cbHashOutput);
2085
2086 SymCryptXmssRandomizedHash(&pKey->params, Idx, Randomness, pKey->Root, pbMessage, cbMessage, RandomizedHash);
2087
2088 SymCryptWipeKnownSize(&adrs, sizeof(XMSS_ADRS));
2089
2090 for (uLayer = 0; uLayer < pParams->nLayers; uLayer++)
2091 {
2092 uTree = Idx >> pParams->nLayerHeight;
2093 uLeaf = (UINT32)(Idx & LeafMask);
2094
2095 SYMCRYPT_STORE_MSBFIRST32(adrs.en32Layer, uLayer);
2096 SYMCRYPT_STORE_MSBFIRST64(adrs.en64Tree, uTree);
2097
2098 SymCryptXmssTreeSignHash(
2099 &pKey->params,
2100 &adrs,
2101 pKey->SkXmss,
2102 pKey->Seed,
2103 uLayer == 0 ? RandomizedHash : TreeRoot,
2104 uLeaf,
2105 SymCryptXmssSignatureGetWotspSig(pParams, pbSignature, uLayer),
2106 SymCryptXmssSignatureGetAuthNodes(pParams, pbSignature, uLayer),
2107 uLayer == (UINT32)(pParams->nLayers - 1) ? NULL : TreeRoot, // No need to compute the root for the top layer tree
2108 pbScratch,
2109 cbScratch);
2110
2111 Idx >>= pParams->nLayerHeight;
2112 }
2113
2114 if (scError != SYMCRYPT_NO_ERROR)
2115 {
2116 SymCryptWipe(pbSignature, cbSignature);
2117 goto cleanup;
2118 }
2119
2120cleanup:
2121
2122 if (pbScratch)
2123 {
2124 SymCryptWipe(pbScratch, cbScratch);
2125 SymCryptCallbackFree(pbScratch);
2126 }
2127
2128 return scError;
2129}
_XMSS_ADRS
Definition: sc_lib.h:4503
_XMSS_ADRS::en32Layer
BYTE en32Layer[4]
Definition: sc_lib.h:4504
_XMSS_ADRS::en64Tree
BYTE en64Tree[8]
Definition: sc_lib.h:4505
PSYMCRYPT_XMSS_PARAMS
SYMCRYPT_XMSS_PARAMS * PSYMCRYPT_XMSS_PARAMS
Definition: symcrypt_internal.h:3106
SymCryptXmssSignatureGetRandomness
PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetRandomness(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig)
Definition: xmss.c:1689
SymCryptXmssRandomizedHash
VOID SYMCRYPT_CALL SymCryptXmssRandomizedHash(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, UINT64 Idx, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbRandomizer, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbRoot, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbMsg, SIZE_T cbMsg, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:1501
SymCryptXmssSignatureGetWotspSig
PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetWotspSig(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig, UINT32 uLayer)
Definition: xmss.c:1703
SymCryptXmssComputeRandomness
VOID SYMCRYPT_CALL SymCryptXmssComputeRandomness(_In_ PCSYMCRYPT_XMSS_KEY pKey, UINT64 Idx, _Out_writes_bytes_(pKey->params.cbHashOutput) PBYTE pbRandomness)
Definition: xmss.c:2000
SymCryptXmssSignatureGetAuthNodes
PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetAuthNodes(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig, UINT32 uLayer)
Definition: xmss.c:1721
SymCryptXmssTreeSignHash
VOID SYMCRYPT_CALL SymCryptXmssTreeSignHash(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbHash, UINT32 Idx, _Out_writes_bytes_(pParams->cbHashOutput *pParams->len) PBYTE pbWotspSig, _Out_writes_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PBYTE pbAuthNodes, _Out_writes_bytes_opt_(pParams->cbHashOutput) PBYTE pbRoot, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: xmss.c:1920
SymCryptHbsSizeofScratchBytesForIncrementalTreehash
SIZE_T SYMCRYPT_CALL SymCryptHbsSizeofScratchBytesForIncrementalTreehash(UINT32 cbNode, UINT32 nLeaves)
Definition: xmss.c:719
SymCryptXmssSizeofSignatureFromParams
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofSignatureFromParams(_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:477

◆ SymCryptXmssSizeofKeyBlobFromParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssSizeofKeyBlobFromParams ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
SYMCRYPT_XMSSKEY_TYPE  keyType,
_Out_ SIZE_T *  pcbKey 
)

Definition at line 497 of file xmss.c.

501{
502 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
503 SIZE_T cbPublicKey = 0;
504 SIZE_T cbPrivateKey = 0;
505
506 // Public Key
507 cbPublicKey += sizeof(UINT32); // Alg ID
508 cbPublicKey += 2 * pParams->cbHashOutput; // Root and Seed
509
510 // Private Key (on top of the public key)
511 cbPrivateKey = cbPublicKey;
512 cbPrivateKey += sizeof(UINT64); // Idx
513 cbPrivateKey += 2 * pParams->cbHashOutput; // SK_XMSS and SK_PRF
514
515 switch (keyType)
516 {
517 case SYMCRYPT_XMSSKEY_TYPE_PUBLIC:
518 *pcbKey = cbPublicKey;
519 break;
520
521 case SYMCRYPT_XMSSKEY_TYPE_PRIVATE:
522 *pcbKey = cbPrivateKey;
523 break;
524
525 default:
526 scError = SYMCRYPT_INVALID_ARGUMENT;
527 break;
528 }
529
530 return scError;
531}

Referenced by SymCryptXmsskeyGetValue(), and SymCryptXmsskeySetValue().

◆ SymCryptXmssSizeofSignatureFromParams()

SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofSignatureFromParams ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams)

Definition at line 477 of file xmss.c.

479{
480 SYMCRYPT_ASSERT(pParams->nLayers != 0);
481 SYMCRYPT_ASSERT((pParams->nTotalTreeHeight % pParams->nLayers) == 0);
482 SYMCRYPT_ASSERT(pParams->nLayerHeight > 0);
483
484 SIZE_T size = 0;
485 size += pParams->cbIdx; // idx
486 size += pParams->cbHashOutput; // randomness
487
488 // WOTSP signature + authentication path for each layer
489 size += pParams->nLayers * ( pParams->cbHashOutput * (pParams->len + pParams->nLayerHeight) );
490
491 return size;
492}

Referenced by SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssVerify()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssVerify ( _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 1835 of file xmss.c.

1842{
1843 SYMCRYPT_RUN_SELFTEST_ONCE(
1844 SymCryptXmssSelftest,
1845 SYMCRYPT_SELFTEST_ALGORITHM_XMSS);
1846
1847 return SymCryptXmssVerifyInternal(
1848 pKey,
1849 pbMessage,
1850 cbMessage,
1851 flags,
1852 pbSignature,
1853 cbSignature);
1854}
SymCryptXmssSelftest
VOID SYMCRYPT_CALL SymCryptXmssSelftest(void)
SYMCRYPT_SELFTEST_ALGORITHM_XMSS
@ SYMCRYPT_SELFTEST_ALGORITHM_XMSS
Definition: symcrypt_internal.h:3432
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: xmss.c:1736

◆ SymCryptXorBytes()

VOID SYMCRYPT_CALL SymCryptXorBytes ( _In_reads_(cbBytes) PCBYTE  pbSrc1,
_In_reads_(cbBytes) PCBYTE  pbSrc2,
_Out_writes_(cbBytes) PBYTE  pbResult,
SIZE_T  cbBytes 
)

Definition at line 236 of file libmain.c.

241{
242 SIZE_T i;
243
244 for( i=0; i<cbBytes; i++ )
245 {
246 pbResult[i] = pbSrc1[i] ^ pbSrc2[i];
247 }
248}

Referenced by SymCryptAesCmacResult(), SymCryptAesGcmDecryptPartOnePass(), SymCryptAesGcmEncryptPartOnePass(), SymCryptCbcDecrypt(), SymCryptCbcEncrypt(), SymCryptCbcMac(), SymCryptCcmAddMacData(), SymCryptCfbDecrypt(), SymCryptCfbEncrypt(), SymCryptChaCha20Crypt(), SymCryptCtrMsb32(), SymCryptCtrMsb64(), SymCryptDesxDecrypt(), SymCryptDesxEncrypt(), SymCryptDlgroupGeneratePrimeQ_FIPS(), SymCryptGcmEncryptDecryptPart(), SymCryptMd2AppendBlocks(), SymCryptPbkdf2Derive(), SymCryptRngAesUpdate(), SymCryptTlsPrf1_1Derive(), SymCryptXmssChain(), SymCryptXmssRandHash(), SymCryptXtsDecryptDataUnit(), and SymCryptXtsEncryptDataUnit().

◆ SymCryptXtsAesDecrypt()

VOID SYMCRYPT_CALL SymCryptXtsAesDecrypt ( _In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY  pExpandedKey,
SIZE_T  cbDataUnit,
UINT64  tweak,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 354 of file xtsaes.c.

361{
362 SYMCRYPT_ALIGN BYTE fullTweak[SYMCRYPT_AES_BLOCK_SIZE];
363
364 SYMCRYPT_ASSERT( cbData % cbDataUnit == 0 );
365
366 if( cbDataUnit < SYMCRYPT_AES_BLOCK_SIZE )
367 {
368 // Invalid data unit size
369 // Return early to avoid repeated checks deeper in the code
370 return;
371 }
372
373 SYMCRYPT_STORE_LSBFIRST64(&fullTweak[0], tweak);
374 SYMCRYPT_STORE_LSBFIRST64(&fullTweak[8], 0);
375
376 SymCryptXtsAesDecryptInternal( pExpandedKey, cbDataUnit, &fullTweak[0], pbSrc, pbDst, cbData, FALSE );
377}
SymCryptXtsAesDecryptInternal
VOID SYMCRYPT_CALL SymCryptXtsAesDecryptInternal(_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbTweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, BOOLEAN bOverflow)
Definition: xtsaes.c:303

Referenced by SymCryptXtsAesSelftest().

◆ SymCryptXtsAesDecryptWith128bTweak()

VOID SYMCRYPT_CALL SymCryptXtsAesDecryptWith128bTweak ( _In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY  pExpandedKey,
SIZE_T  cbDataUnit,
_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE  pbTweak,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 381 of file xtsaes.c.

388{
389 if( cbDataUnit < SYMCRYPT_AES_BLOCK_SIZE )
390 {
391 // Invalid data unit size
392 // Return early to avoid repeated checks deeper in the code
393 return;
394 }
395
396 SymCryptXtsAesDecryptInternal( pExpandedKey, cbDataUnit, pbTweak, pbSrc, pbDst, cbData, TRUE );
397}

◆ SymCryptXtsAesEncrypt()

VOID SYMCRYPT_CALL SymCryptXtsAesEncrypt ( _In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY  pExpandedKey,
SIZE_T  cbDataUnit,
UINT64  tweak,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 255 of file xtsaes.c.

262{
263 SYMCRYPT_ALIGN BYTE fullTweak[SYMCRYPT_AES_BLOCK_SIZE];
264
265 SYMCRYPT_ASSERT( cbData % cbDataUnit == 0 );
266
267 if( cbDataUnit < SYMCRYPT_AES_BLOCK_SIZE )
268 {
269 // Invalid data unit size
270 // Return early to avoid repeated checks deeper in the code
271 return;
272 }
273
274 SYMCRYPT_STORE_LSBFIRST64(&fullTweak[0], tweak);
275 SYMCRYPT_STORE_LSBFIRST64(&fullTweak[8], 0);
276
277 SymCryptXtsAesEncryptInternal( pExpandedKey, cbDataUnit, &fullTweak[0], pbSrc, pbDst, cbData, FALSE );
278}
SymCryptXtsAesEncryptInternal
VOID SYMCRYPT_CALL SymCryptXtsAesEncryptInternal(_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, _In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE pbTweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData, BOOLEAN bOverflow)
Definition: xtsaes.c:204

Referenced by SymCryptXtsAesSelftest().

◆ SymCryptXtsAesEncryptWith128bTweak()

VOID SYMCRYPT_CALL SymCryptXtsAesEncryptWith128bTweak ( _In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY  pExpandedKey,
SIZE_T  cbDataUnit,
_In_reads_(SYMCRYPT_AES_BLOCK_SIZE) PCBYTE  pbTweak,
_In_reads_(cbData) PCBYTE  pbSrc,
_Out_writes_(cbData) PBYTE  pbDst,
SIZE_T  cbData 
)

Definition at line 282 of file xtsaes.c.

289{
290 if( cbDataUnit < SYMCRYPT_AES_BLOCK_SIZE )
291 {
292 // Invalid data unit size
293 // Return early to avoid repeated checks deeper in the code
294 return;
295 }
296
297 SymCryptXtsAesEncryptInternal( pExpandedKey, cbDataUnit, pbTweak, pbSrc, pbDst, cbData, TRUE );
298}

◆ SymCryptXtsAesExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXtsAesExpandKey ( _Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey 
)

Definition at line 11 of file xtsaes.c.

15{
16 SYMCRYPT_ERROR scError;
17 SIZE_T halfKeySize = cbKey / 2;
18
19 scError = SymCryptAesExpandKey( &pExpandedKey->key1, pbKey, halfKeySize );
20 if( scError != SYMCRYPT_NO_ERROR )
21 {
22 goto cleanup;
23 }
24
25 //
26 // Pass the 'rest' of the key to the second one. This catches errors such as
27 // an attempt to pass a 33 byte key.
28 // halfKeySize = 16, which is valid, but this expansion gets a 17-byte key which will fail.
29 // Key2 is only used for tweak encryption, so we can use the EncryptOnly key expansion.
30 //
31 scError = SymCryptAesExpandKeyEncryptOnly( &pExpandedKey->key2, pbKey + halfKeySize, cbKey - halfKeySize );
32 if( scError != SYMCRYPT_NO_ERROR )
33 {
34 goto cleanup;
35 }
36
37cleanup:
38
39 return scError;
40}

Referenced by SymCryptXtsAesExpandKeyEx().

◆ SymCryptXtsAesExpandKeyEx()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXtsAesExpandKeyEx ( _Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY  pExpandedKey,
_In_reads_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
UINT32  flags 
)

Definition at line 44 of file xtsaes.c.

49{
50 if( ( flags & SYMCRYPT_FLAG_KEY_NO_FIPS ) == 0 )
51 {
52 // FIPS IG C.I enforces that the two AES keys internally used in XTS-AES are non-equal
53 if( cbKey > 64 )
54 {
55 return SYMCRYPT_WRONG_KEY_SIZE;
56 }
57 if( SymCryptEqual( pbKey, pbKey+(cbKey/2), (cbKey/2) ) )
58 {
59 return SYMCRYPT_FIPS_FAILURE;
60 }
61 }
62
63 return SymCryptXtsAesExpandKey( pExpandedKey, pbKey, cbKey );
64}
SymCryptXtsAesExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXtsAesExpandKey(_Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: xtsaes.c:11

Referenced by SymCryptXtsAesSelftest().

◆ SymCryptXtsAesKeyCopy()

VOID SYMCRYPT_CALL SymCryptXtsAesKeyCopy ( _In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY  pSrc,
_Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY  pDst 
)

Definition at line 69 of file xtsaes.c.

72{
73 SymCryptAesKeyCopy( &pSrc->key1, &pDst->key1 );
74 SymCryptAesKeyCopy( &pSrc->key2, &pDst->key2 );
75}

◆ SymCryptXtsAesSelftest()

VOID SYMCRYPT_CALL SymCryptXtsAesSelftest ( void  )

Definition at line 695 of file xtsaes.c.

696{
697 SYMCRYPT_XTS_AES_EXPANDED_KEY key;
698 BYTE buf[32];
699 BYTE plaintext[sizeof( buf )];
700
701 SymCryptWipeKnownSize( buf, sizeof( buf ) );
702 buf[0] = 1;
703
704 if( SymCryptXtsAesExpandKeyEx( &key, buf, sizeof( buf ), 0 ) != SYMCRYPT_NO_ERROR )
705 {
706 SymCryptFatal( 'xtsa' );
707 }
708
709 SymCryptXtsAesEncrypt( &key, sizeof( buf ), 0, buf, buf, sizeof( buf ) );
710
711 SymCryptInjectError( buf, sizeof( buf ) );
712 if( memcmp( buf, SymCryptXtsAesCiphertext, sizeof( buf ) ) != 0 )
713 {
714 SymCryptFatal( 'xtsa' );
715 }
716
717 SymCryptXtsAesDecrypt( &key, sizeof( buf ), 0, buf, buf, sizeof( buf ) );
718
719 SymCryptInjectError( buf, sizeof( buf ) );
720
721 SymCryptWipeKnownSize( plaintext, sizeof( plaintext ) );
722 plaintext[0] = 1;
723 if( memcmp( buf, plaintext, sizeof( buf ) ) != 0 )
724 {
725 SymCryptFatal( 'xtsa' );
726 }
727}
SYMCRYPT_XTS_AES_EXPANDED_KEY
SYMCRYPT_XTS_AES_EXPANDED_KEY
Definition: symcrypt_internal.h:1707
SymCryptXtsAesExpandKeyEx
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXtsAesExpandKeyEx(_Out_ PSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, UINT32 flags)
Definition: xtsaes.c:44
SymCryptXtsAesDecrypt
VOID SYMCRYPT_CALL SymCryptXtsAesDecrypt(_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, UINT64 tweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: xtsaes.c:354
SymCryptXtsAesEncrypt
VOID SYMCRYPT_CALL SymCryptXtsAesEncrypt(_In_ PCSYMCRYPT_XTS_AES_EXPANDED_KEY pExpandedKey, SIZE_T cbDataUnit, UINT64 tweak, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: xtsaes.c:255
SymCryptXtsAesCiphertext
static const BYTE SymCryptXtsAesCiphertext[32]
Definition: xtsaes.c:686

Variable Documentation

◆ SymCrypt3DesBlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCrypt3DesBlockCipher
extern

Definition at line 75 of file 3des.c.

Referenced by SymCrypt3DesCbcDecrypt(), and SymCrypt3DesCbcEncrypt().

◆ SYMCRYPT_ERROR

SYMCRYPT_ERROR

Definition at line 227 of file symcrypt.h.

Referenced by LmsComputeOtsPubKeyCandidate(), SymCrypt802_11SaeCustomCommitCreateGeneric(), SymCrypt802_11SaeCustomCommitProcessGeneric(), SymCrypt802_11SaeCustomCreatePTGeneric(), SymCrypt802_11SaeCustomInit(), SymCrypt802_11SaeCustomInitH2EGeneric(), SymCrypt802_11SaeCustomSetRandMask(), SymCryptAesCmacExpandKey(), SymCryptAesExpandKeyInternal(), SymCryptAesKwDecrypt(), SymCryptAesKwEncrypt(), SymCryptAesKwpDecrypt(), SymCryptAesKwpEncrypt(), SymCryptCcmDecrypt(), SymCryptCcmDecryptFinal(), SymCryptCcmSelftest(), SymCryptChaCha20Init(), SymCryptChaCha20Poly1305Decrypt(), SymCryptChaCha20Poly1305Encrypt(), SymCryptChaCha20Poly1305Selftest(), SymCryptCrtGenerateForTwoCoprimes(), SymCryptCrtGenerateInverses(), SymCryptCrtSolve(), SymCryptDhSecretAgreement(), SymCryptDlgroupAutoCompleteNamedSafePrimeGroup(), SymCryptDlgroupGenerate(), SymCryptDlgroupGenerateGenG_FIPS(), SymCryptDlgroupGeneratePrimeP_FIPS(), SymCryptDlgroupGeneratePrimeQ_FIPS(), SymCryptDlgroupGetValue(), SymCryptDlgroupSetValue(), SymCryptDlgroupSetValueSafePrime(), SymCryptDlkeyExtendKeyUsage(), SymCryptDlkeyGenerate(), SymCryptDlkeyGetValue(), SymCryptDlkeySetValue(), SymCryptDsaSignEx(), SymCryptDsaTruncateHash(), SymCryptDsaVerify(), SymCryptEcDhSecretAgreement(), SymCryptEcDsaSignEx(), SymCryptEcDsaTruncateHash(), SymCryptEcDsaVerify(), SymCryptEckeyExtendKeyUsage(), SymCryptEckeyGetValue(), SymCryptEckeyPerformPublicKeyValidation(), SymCryptEckeySetRandom(), SymCryptEckeySetValue(), SymCryptEcpointGetValue(), SymCryptEcpointMultiScalarMulWnafWithInterleaving(), SymCryptEcpointScalarMulFixedWindow(), SymCryptEcpointSetValue(), SymCryptEcpointTransform(), SymCryptEcurveInitialize(), SymCryptExternalMuMlDsaSign(), SymCryptExternalMuMlDsaVerify(), SymCryptFdefIntCopyMixedSize(), SymCryptFdefIntGetValue(), SymCryptFdefIntSetValue(), SymCryptFdefModElementGetValue(), SymCryptFdefModElementSetValueGeneric(), SymCryptFdefModInvGeneric(), SymCryptFdefModInvMontgomery(), SymCryptFdefRawGetValue(), SymCryptFdefRawSetValue(), SymCryptGcmDecrypt(), SymCryptGcmDecryptFinal(), SymCryptGcmExpandKey(), SymCryptGcmKeyCopy(), SymCryptGcmSelftest(), SymCryptHashMlDsaSign(), SymCryptHashMlDsaValidateHashAlgAndGetOid(), SymCryptHashMlDsaVerify(), SymCryptHkdf(), SymCryptHkdfDerive(), SymCryptHkdfExpandKey(), SymCryptHkdfExtractPrk(), SymCryptIntGenerateRandomPrime(), SymCryptKeccakStateImport(), SymCryptLmskeyGenerate(), SymCryptLmskeyGetValue(), SymCryptLmskeySetValue(), SymCryptLmskeyVerifyRoot(), SymCryptLmsParamsFromAlgId(), SymCryptLmsSetParams(), SymCryptLmsSign(), SymCryptLmsSizeofKeyBlobFromParams(), SymCryptLmsVerify(), SymCryptLmsVerifyInternal(), SymCryptLoadLsbFirstUint32(), SymCryptLoadLsbFirstUint64(), SymCryptLoadMsbFirstUint32(), SymCryptLoadMsbFirstUint64(), SymCryptMarvin32ExpandSeed(), SymCryptMd2StateImport(), SymCryptMd4StateImport(), SymCryptMd5StateImport(), SymCryptMlDsaExpandMask(), SymCryptMlDsaGetInternalParamsFromParams(), SymCryptMlDsaHintBitUnpack(), SymCryptMlDsakeyAllocate(), SymCryptMlDsakeyGenerate(), SymCryptMlDsaKeyGenerateEx(), SymCryptMlDsakeyGetValue(), SymCryptMlDsakeySetValue(), SymCryptMlDsaPkDecode(), SymCryptMlDsaPkEncode(), SymCryptMlDsaSigDecode(), SymCryptMlDsaSign(), SymCryptMlDsaSignEx(), SymCryptMlDsaSizeofKeyFormatFromParams(), SymCryptMlDsaSizeofSignatureFromParams(), SymCryptMlDsaSkDecode(), SymCryptMlDsaSkEncode(), SymCryptMlDsaVectorDecode(), SymCryptMlDsaVerify(), SymCryptMlDsaVerifyEx(), SymCryptMlKemDecapsulate(), SymCryptMlKemEncapsulate(), SymCryptMlKemEncapsulateEx(), SymCryptMlKemEncapsulateInternal(), SymCryptMlKemkeyAllocate(), SymCryptMlKemkeyGenerate(), SymCryptMlKemkeyGetInternalParamsFromParams(), SymCryptMlKemkeyGetValue(), SymCryptMlKemkeySetValue(), SymCryptMlKemSizeofCiphertextFromParams(), SymCryptMlKemSizeofKeyFormatFromParams(), SymCryptMlKemVectorDecodeAndDecompress(), SymCryptModElementSetValue(), SymCryptModMultiExpGeneric(), SymCryptModSqrt(), SymCryptMontgomeryPointScalarMul(), SymCryptPaddingPkcs7Remove(), SymCryptPbkdf2(), SymCryptRngAesFips140_2Instantiate(), SymCryptRngAesGenerate(), SymCryptRngAesTestGenerate(), SymCryptRngAesTestInstantiate(), SymCryptRngAesTestReseed(), SymCryptRsaCoreDec(), SymCryptRsaCoreDecCrt(), SymCryptRsaCoreEnc(), SymCryptRsaCoreVerifyInput(), SymCryptRsakeyCalculatePrimesFromPrivateExponent(), SymCryptRsakeyCalculatePrivateFields(), SymCryptRsakeyExtendKeyUsage(), SymCryptRsakeyGenerate(), SymCryptRsakeyGetCrtValue(), SymCryptRsakeyGetValue(), SymCryptRsakeySetValueInternal(), SymCryptRsaOaepApplyEncryptionPadding(), SymCryptRsaOaepDecrypt(), SymCryptRsaOaepEncrypt(), SymCryptRsaOaepRemoveEncryptionPadding(), SymCryptRsaPkcs1ApplyEncryptionPadding(), SymCryptRsaPkcs1ApplySignaturePadding(), SymCryptRsaPkcs1CheckSignaturePadding(), SymCryptRsaPkcs1Decrypt(), SymCryptRsaPkcs1Encrypt(), SymCryptRsaPkcs1RemoveEncryptionPadding(), SymCryptRsaPkcs1Sign(), SymCryptRsaPkcs1Verify(), SymCryptRsaPkcs1VerifySignaturePadding(), SymCryptRsaPssApplySignaturePadding(), SymCryptRsaPssSign(), SymCryptRsaPssVerify(), SymCryptRsaPssVerifySignaturePadding(), SymCryptRsaRawDecrypt(), SymCryptRsaRawEncrypt(), SymCryptSessionDecryptComputeDesiredReplayState(), SymCryptSessionDecryptUpdateState(), SymCryptSessionDecryptUpdateStateLock(), SymCryptSessionGcmDecrypt(), SymCryptSha1StateImport(), SymCryptSha256StateImportCore(), SymCryptSha3_224StateImport(), SymCryptSha3_256StateImport(), SymCryptSha3_384StateImport(), SymCryptSha3_512StateImport(), SymCryptSha512StateImportCore(), SymCryptSp800_108(), SymCryptSrtpKdf(), SymCryptSrtpKdfDerive(), SymCryptSshKdf(), SymCryptSshKdfDerive(), SymCryptSskdfMac(), SymCryptSskdfMacDerive(), SymCryptSskdfMacExpandSalt(), SymCryptSswu(), SymCryptStoreLsbFirstUint64(), SymCryptStoreMsbFirstUint64(), SymCryptTlsCbcHmacVerifyCore(), SymCryptTlsPrf1_1(), SymCryptTlsPrf1_1Derive(), SymCryptTlsPrf1_1ExpandKey(), SymCryptTlsPrf1_2(), SymCryptTlsPrf1_2Derive(), SymCryptXmssComputePublicRoot(), SymCryptXmssGetWotspParams(), SymCryptXmsskeyGenerate(), SymCryptXmsskeyGetValue(), SymCryptXmsskeySetValue(), SymCryptXmsskeyVerifyRoot(), SymCryptXmssParamsFromAlgIdCommon(), SymCryptXmssSetParams(), SymCryptXmssSign(), SymCryptXmssSizeofKeyBlobFromParams(), SymCryptXmssVerifyInternal(), and SymCryptXtsAesExpandKey().

◆ SymCryptAesBlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCryptAesBlockCipher
extern

Definition at line 92 of file aes-default-bc.c.

Referenced by SymCryptCcmSelftest(), and SymCryptGcmSelftest().

◆ SymCryptAesCmacAlgorithm

const PCSYMCRYPT_MAC SymCryptAesCmacAlgorithm
extern

Definition at line 21 of file aescmac.c.

◆ SymCryptDesBlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCryptDesBlockCipher
extern

Definition at line 76 of file 3des.c.

◆ SymCryptDesxBlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCryptDesxBlockCipher
extern

Definition at line 27 of file desx.c.

◆ SymCryptEcurveParamsCurve25519

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsCurve25519
extern

Definition at line 593 of file ec_internal_curve_params.c.

Referenced by SymCryptGetCachedEcurveParams().

◆ SymCryptEcurveParamsNistP192

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP192
extern

Definition at line 583 of file ec_internal_curve_params.c.

◆ SymCryptEcurveParamsNistP224

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP224
extern

Definition at line 584 of file ec_internal_curve_params.c.

◆ SymCryptEcurveParamsNistP256

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP256
extern

Definition at line 585 of file ec_internal_curve_params.c.

Referenced by SymCrypt802_11SaeCustomInit(), and SymCryptGetCachedEcurveParams().

◆ SymCryptEcurveParamsNistP384

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP384
extern

Definition at line 586 of file ec_internal_curve_params.c.

Referenced by SymCryptFdefDecideModulusType(), and SymCryptGetCachedEcurveParams().

◆ SymCryptEcurveParamsNistP521

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP521
extern

Definition at line 587 of file ec_internal_curve_params.c.

◆ SymCryptEcurveParamsNumsP256t1

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNumsP256t1
extern

Definition at line 589 of file ec_internal_curve_params.c.

◆ SymCryptEcurveParamsNumsP384t1

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNumsP384t1
extern

Definition at line 590 of file ec_internal_curve_params.c.

◆ SymCryptEcurveParamsNumsP512t1

const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNumsP512t1
extern

Definition at line 591 of file ec_internal_curve_params.c.

◆ SymCryptHmacMd5Algorithm

const PCSYMCRYPT_MAC SymCryptHmacMd5Algorithm
extern

Definition at line 29 of file hmacmd5.c.

Referenced by SymCryptTlsPrf1_1Derive().

◆ SymCryptHmacSha1Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha1Algorithm
extern

Definition at line 36 of file hmacsha1.c.

Referenced by SymCryptPbkdf2_HmacSha1SelfTest(), SymCryptSp800_108_HmacSha1SelfTest(), SymCryptTlsCbcHmacVerify(), and SymCryptTlsPrf1_1Derive().

◆ SymCryptHmacSha224Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha224Algorithm
extern

Definition at line 31 of file hmacsha224.c.

◆ SymCryptHmacSha256Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha256Algorithm
extern

Definition at line 29 of file hmacsha256.c.

Referenced by SymCrypt802_11SaeCustomInit(), SymCryptPbkdf2_HmacSha256SelfTest(), SymCryptSp800_108_HmacSha256SelfTest(), and SymCryptTlsCbcHmacVerify().

◆ SymCryptHmacSha384Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha384Algorithm
extern

Definition at line 31 of file hmacsha384.c.

Referenced by SymCryptSp800_108_HmacSha384SelfTest(), and SymCryptTlsCbcHmacVerify().

◆ SymCryptHmacSha3_224Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha3_224Algorithm
extern

Definition at line 90 of file hmacsha3_224.c.

◆ SymCryptHmacSha3_256Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha3_256Algorithm
extern

Definition at line 90 of file hmacsha3_256.c.

◆ SymCryptHmacSha3_384Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha3_384Algorithm
extern

Definition at line 90 of file hmacsha3_384.c.

◆ SymCryptHmacSha3_512Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha3_512Algorithm
extern

Definition at line 90 of file hmacsha3_512.c.

◆ SymCryptHmacSha512_224Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha512_224Algorithm
extern

Definition at line 31 of file hmacsha512_224.c.

◆ SymCryptHmacSha512_256Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha512_256Algorithm
extern

Definition at line 31 of file hmacsha512_256.c.

◆ SymCryptHmacSha512Algorithm

const PCSYMCRYPT_MAC SymCryptHmacSha512Algorithm
extern

Definition at line 29 of file hmacsha512.c.

Referenced by SymCryptSp800_108_HmacSha512SelfTest().

◆ SymCryptKmac128Algorithm

const PCSYMCRYPT_MAC SymCryptKmac128Algorithm
extern

Definition at line 38 of file kmac.c.

Referenced by SymCryptSskdfMacDerive(), and SymCryptSskdfMacExpandSalt().

◆ SymCryptKmac256Algorithm

const PCSYMCRYPT_MAC SymCryptKmac256Algorithm
extern

Definition at line 96 of file kmac.c.

Referenced by SymCryptSskdfMacDerive(), and SymCryptSskdfMacExpandSalt().

◆ SymCryptMarvin32DefaultSeed

PCSYMCRYPT_MARVIN32_EXPANDED_SEED const SymCryptMarvin32DefaultSeed
extern

Definition at line 29 of file marvin32.c.

Referenced by SymCryptKeccakStateExport(), SymCryptKeccakStateImport(), SymCryptMarvin32Selftest(), SymCryptMd2StateExport(), SymCryptMd2StateImport(), SymCryptMd4StateExport(), SymCryptMd4StateImport(), SymCryptMd5StateExport(), SymCryptMd5StateImport(), SymCryptSha1StateExport(), SymCryptSha1StateImport(), SymCryptSha256StateExportCore(), SymCryptSha256StateImportCore(), SymCryptSha512StateExportCore(), and SymCryptSha512StateImportCore().

◆ SymCryptMd2Algorithm

const PCSYMCRYPT_HASH SymCryptMd2Algorithm
extern

Definition at line 40 of file md2.c.

Referenced by init_hash_impl(), and SymCryptMd2Append().

◆ SymCryptMd4Algorithm

const PCSYMCRYPT_HASH SymCryptMd4Algorithm
extern

Definition at line 46 of file md4.c.

Referenced by init_hash_impl(), SymCryptMd4Append(), and SymCryptMd4Result().

◆ SymCryptMd5Algorithm

const PCSYMCRYPT_HASH SymCryptMd5Algorithm
extern

Definition at line 43 of file md5.c.

Referenced by init_hash_impl(), SymCryptMd5Append(), and SymCryptMd5Result().

◆ SymCryptRc2BlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCryptRc2BlockCipher
extern

Definition at line 33 of file rc2.c.

◆ SymCryptSha1Algorithm

const PCSYMCRYPT_HASH SymCryptSha1Algorithm
extern

Definition at line 29 of file sha1.c.

Referenced by init_hash_impl(), SymCryptDlgroupGenerate(), SymCryptDlgroupGeneratePrimeQ_FIPS(), SymCryptDlgroupSetValue(), and SymCryptSha1Append().

◆ SymCryptSha224Algorithm

const PCSYMCRYPT_HASH SymCryptSha224Algorithm
extern

Definition at line 45 of file sha256.c.

◆ SymCryptSha256Algorithm

const PCSYMCRYPT_HASH SymCryptSha256Algorithm
extern

Definition at line 46 of file sha256.c.

Referenced by init_hash_impl(), and SymCryptSshKdfSha256SelfTest().

◆ SymCryptSha384Algorithm

const PCSYMCRYPT_HASH SymCryptSha384Algorithm
extern

Definition at line 169 of file sha512.c.

Referenced by init_hash_impl().

◆ SymCryptSha3_224Algorithm

const PCSYMCRYPT_HASH SymCryptSha3_224Algorithm
extern

Definition at line 27 of file sha3_224.c.

Referenced by SymCryptHmacSha3_224ExpandKey().

◆ SymCryptSha3_256Algorithm

const PCSYMCRYPT_HASH SymCryptSha3_256Algorithm
extern

Definition at line 27 of file sha3_256.c.

Referenced by SymCryptHmacSha3_256ExpandKey().

◆ SymCryptSha3_384Algorithm

const PCSYMCRYPT_HASH SymCryptSha3_384Algorithm
extern

Definition at line 27 of file sha3_384.c.

Referenced by SymCryptHmacSha3_384ExpandKey().

◆ SymCryptSha3_512Algorithm

const PCSYMCRYPT_HASH SymCryptSha3_512Algorithm
extern

Definition at line 27 of file sha3_512.c.

Referenced by SymCryptHmacSha3_512ExpandKey().

◆ SymCryptSha512_224Algorithm

const PCSYMCRYPT_HASH SymCryptSha512_224Algorithm
extern

Definition at line 171 of file sha512.c.

◆ SymCryptSha512_256Algorithm

const PCSYMCRYPT_HASH SymCryptSha512_256Algorithm
extern

Definition at line 172 of file sha512.c.

◆ SymCryptSha512Algorithm

const PCSYMCRYPT_HASH SymCryptSha512Algorithm
extern

Definition at line 170 of file sha512.c.

Referenced by init_hash_impl(), and SymCryptSshKdfSha512SelfTest().

◆ SymCryptShake128HashAlgorithm

const PCSYMCRYPT_HASH SymCryptShake128HashAlgorithm
extern

Definition at line 41 of file shake.c.

◆ SymCryptShake256HashAlgorithm

const PCSYMCRYPT_HASH SymCryptShake256HashAlgorithm
extern

Definition at line 93 of file shake.c.