ReactOS 0.4.17-dev-1005-g171e1de
Classes | Macros | Typedefs | Enumerations | Functions | Variables
xmss.c File Reference
#include "precomp.h"
Include dependency graph for xmss.c:

Go to the source code of this file.

Classes

struct  _SYMCRYPT_XMSS_WOTSP_PARAMS
 
struct  _SYMCRYPT_XMSS_PARAMETER_PREDEFINED
 

Macros

#define SYMCRYPT_XMSS_MAX_PREFIX_SIZE   SYMCRYPT_HASH_MAX_RESULT_SIZE
 
#define SYMCRYPT_XMSS_F   0x00
 
#define SYMCRYPT_XMSS_H   0x01
 
#define SYMCRYPT_XMSS_H_MSG   0x02
 
#define SYMCRYPT_XMSS_PRF   0x03
 
#define SYMCRYPT_XMSS_PRF_KEYGEN   0x04
 

Typedefs

typedef enum _SYMCRYPT_XMSS_WOTSP_ALGID SYMCRYPT_XMSS_WOTSP_ALGID
 
typedef enum _SYMCRYPT_XMSS_WOTSP_ALGID * PSYMCRYPT_XMSS_WOTSP_ALGID
 
typedef struct _SYMCRYPT_XMSS_WOTSP_PARAMS SYMCRYPT_XMSS_WOTSP_PARAMS
 
typedef struct _SYMCRYPT_XMSS_WOTSP_PARAMS * PSYMCRYPT_XMSS_WOTSP_PARAMS
 
typedef struct _SYMCRYPT_XMSS_PARAMETER_PREDEFINED SYMCRYPT_XMSS_PARAMETER_PREDEFINED
 
typedef SYMCRYPT_XMSS_PARAMETER_PREDEFINED * PSYMCRYPT_XMSS_PARAMETER_PREDEFINED
 
typedef const SYMCRYPT_XMSS_PARAMETER_PREDEFINED * PCSYMCRYPT_XMSS_PARAMETER_PREDEFINED
 

Enumerations

enum  _SYMCRYPT_XMSS_WOTSP_ALGID {
  SYMCRYPT_XMSS_WOTSP_SHA2_256 = 0x00000001 , SYMCRYPT_XMSS_WOTSP_SHA2_512 = 0x00000002 , SYMCRYPT_XMSS_WOTSP_SHAKE_256 = 0x00000003 , SYMCRYPT_XMSS_WOTSP_SHAKE_512 = 0x00000004 ,
  SYMCRYPT_XMSS_WOTSP_SHA2_192 = 0x00000005 , SYMCRYPT_XMSS_WOTSP_SHAKE256_256 = 0x00000006 , SYMCRYPT_XMSS_WOTSP_SHAKE256_192 = 0x00000007
}
 

Functions

VOID SYMCRYPT_CALL SymCryptHbsGetWinternitzLengths (UINT32 n, UINT32 w, _Out_ PUINT32 puLen1, _Out_ PUINT32 puLen2)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssGetWotspParams (SYMCRYPT_XMSS_WOTSP_ALGID id, _Out_ PSYMCRYPT_XMSS_PARAMS pParams)
 
VOID SYMCRYPT_CALL SymCryptXmssDeriveParams (_Inout_ PSYMCRYPT_XMSS_PARAMS pParams)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssParamsFromAlgIdCommon (UINT32 id, BOOLEAN isMultiTree, _Out_ PSYMCRYPT_XMSS_PARAMS pParams)
 
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)
 
VOID SYMCRYPT_CALL SymCryptXmssSetAdrsType (_Out_ PXMSS_ADRS adrs, UINT32 type)
 
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofSignatureFromParams (_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
 
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)
 
VOID SYMCRYPT_CALL SymCryptXmsskeyFree (_Inout_ PSYMCRYPT_XMSS_KEY pKey)
 
PSYMCRYPT_INCREMENTAL_TREEHASH SYMCRYPT_CALL SymCryptHbsIncrementalTreehashInit (UINT32 nLeaves, PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 cbHashResult, PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC funcCompressNodes, PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pContext)
 
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetNode (_In_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, SIZE_T index)
 
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashAllocNode (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, UINT32 nLeafIndex)
 
VOID SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetTopNodes (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, _Out_ PSYMCRYPT_TREEHASH_NODE *ppNodeLeft, _Out_ PSYMCRYPT_TREEHASH_NODE *ppNodeRight)
 
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcessCommon (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, BOOLEAN fFinal)
 
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcess (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash)
 
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashFinalize (_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash)
 
UINT32 SYMCRYPT_CALL SymCryptHbsIncrementalTreehashStackDepth (UINT32 nLeaves)
 
SIZE_T SYMCRYPT_CALL SymCryptHbsSizeofScratchBytesForIncrementalTreehash (UINT32 cbNode, UINT32 nLeaves)
 
VOID SYMCRYPT_CALL SymCryptXmssPrfInit (_In_ PCSYMCRYPT_HASH hash, BYTE PrfType, SIZE_T prefixLength, _Out_ PSYMCRYPT_HASH_STATE state)
 
VOID SYMCRYPT_CALL SymCryptXmssPrfKey (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _Out_ SYMCRYPT_HASH_STATE *pState)
 
VOID SYMCRYPT_CALL SymCryptXmssPrf (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, BYTE PrfType, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_bytes_(cbMsg) PCBYTE pbMsg, SIZE_T cbMsg, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmssRandHash (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbLeft, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbRight, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmssTreeNodeCompress (_In_ PSYMCRYPT_TREEHASH_NODE pNodeLeft, _In_ PSYMCRYPT_TREEHASH_NODE pNodeRight, _Out_ PSYMCRYPT_TREEHASH_NODE pNodeOut, _Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pCtxIncHash)
 
VOID SYMCRYPT_CALL SymCryptXmssLtreeNodeCompress (_In_ PSYMCRYPT_TREEHASH_NODE pNodeLeft, _In_ PSYMCRYPT_TREEHASH_NODE pNodeRight, _Out_ PSYMCRYPT_TREEHASH_NODE pNodeOut, _Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pCtxIncHash)
 
VOID SYMCRYPT_CALL SymCryptXmssCreateWotspSecret (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Inout_ XMSS_ADRS *adrs, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmssChain (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbInput, UINT32 startIndex, UINT32 steps, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Inout_ XMSS_ADRS *adrs, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmssCreateWotspPublickey (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmssComputeSubtreeRoot (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, UINT32 uLeaf, UINT32 uHeight, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbRoot)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssComputePublicRoot (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed, _In_reads_bytes_(cbSkXmss) PCBYTE pbSkXmss, SIZE_T cbSkXmss, _Out_writes_bytes_(cbRoot) PBYTE pbRoot, SIZE_T cbRoot)
 
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyVerifyRoot (_In_ PCSYMCRYPT_XMSS_KEY pKey)
 
SYMCRYPT_ERROR SYMCRYPT_CALL 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)
 
UINT32 SYMCRYPT_CALL SymCryptHbsGetDigit (UINT32 width, _In_ PCBYTE pbBuffer, SIZE_T cbBuffer, UINT32 index)
 
VOID SYMCRYPT_CALL SymCryptXmssTreeRootFromAuthenticationPath (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbStartingNode, _In_reads_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PCBYTE pbAuthNodes, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
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)
 
VOID SYMCRYPT_CALL SymCryptXmssWotspPublickeyFromSignature (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, UINT32 idx, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbMsg, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput *pParams->len) PCBYTE pbSignature, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
 
VOID SYMCRYPT_CALL SymCryptXmssTreeRootFromSignature (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbHash, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput *pParams->len) PCBYTE pbWotspSig, _In_reads_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PCBYTE pbAuthNodes, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
 
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofWotspSignature (_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
 
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofAuthNodes (_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
 
UINT64 SYMCRYPT_CALL SymCryptXmssSignatureGetIdx (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig)
 
PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetRandomness (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig)
 
PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetWotspSig (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig, UINT32 uLayer)
 
PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetAuthNodes (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig, UINT32 uLayer)
 
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)
 
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 SymCryptXmssWotspSign (_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbInput, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _Out_writes_bytes_(pParams->cbHashOutput *pParams->len) PBYTE pbOutput)
 
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)
 
VOID SYMCRYPT_CALL SymCryptXmssComputeRandomness (_In_ PCSYMCRYPT_XMSS_KEY pKey, UINT64 Idx, _Out_writes_bytes_(pKey->params.cbHashOutput) PBYTE pbRandomness)
 
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)
 

Variables

static const PCSYMCRYPT_HASH * XmssHashArray []
 
static const SYMCRYPT_XMSS_WOTSP_PARAMS XmssWotspParams []
 
static const SYMCRYPT_XMSS_PARAMETER_PREDEFINED XmssParametersPredefined []
 
static const SYMCRYPT_XMSS_PARAMETER_PREDEFINED XmssMtParametersPredefined []
 

Macro Definition Documentation

◆ SYMCRYPT_XMSS_F

#define SYMCRYPT_XMSS_F   0x00

Definition at line 18 of file xmss.c.

◆ SYMCRYPT_XMSS_H

#define SYMCRYPT_XMSS_H   0x01

Definition at line 19 of file xmss.c.

◆ SYMCRYPT_XMSS_H_MSG

#define SYMCRYPT_XMSS_H_MSG   0x02

Definition at line 20 of file xmss.c.

◆ SYMCRYPT_XMSS_MAX_PREFIX_SIZE

#define SYMCRYPT_XMSS_MAX_PREFIX_SIZE   SYMCRYPT_HASH_MAX_RESULT_SIZE

Definition at line 15 of file xmss.c.

◆ SYMCRYPT_XMSS_PRF

#define SYMCRYPT_XMSS_PRF   0x03

Definition at line 21 of file xmss.c.

◆ SYMCRYPT_XMSS_PRF_KEYGEN

#define SYMCRYPT_XMSS_PRF_KEYGEN   0x04

Definition at line 22 of file xmss.c.

Typedef Documentation

◆ PCSYMCRYPT_XMSS_PARAMETER_PREDEFINED

typedef const SYMCRYPT_XMSS_PARAMETER_PREDEFINED* PCSYMCRYPT_XMSS_PARAMETER_PREDEFINED

Definition at line 85 of file xmss.c.

◆ PSYMCRYPT_XMSS_PARAMETER_PREDEFINED

typedef SYMCRYPT_XMSS_PARAMETER_PREDEFINED* PSYMCRYPT_XMSS_PARAMETER_PREDEFINED

Definition at line 84 of file xmss.c.

◆ PSYMCRYPT_XMSS_WOTSP_ALGID

typedef enum _SYMCRYPT_XMSS_WOTSP_ALGID * PSYMCRYPT_XMSS_WOTSP_ALGID

◆ PSYMCRYPT_XMSS_WOTSP_PARAMS

typedef struct _SYMCRYPT_XMSS_WOTSP_PARAMS * PSYMCRYPT_XMSS_WOTSP_PARAMS

◆ SYMCRYPT_XMSS_PARAMETER_PREDEFINED

typedef struct _SYMCRYPT_XMSS_PARAMETER_PREDEFINED SYMCRYPT_XMSS_PARAMETER_PREDEFINED

◆ SYMCRYPT_XMSS_WOTSP_ALGID

typedef enum _SYMCRYPT_XMSS_WOTSP_ALGID SYMCRYPT_XMSS_WOTSP_ALGID

◆ SYMCRYPT_XMSS_WOTSP_PARAMS

typedef struct _SYMCRYPT_XMSS_WOTSP_PARAMS SYMCRYPT_XMSS_WOTSP_PARAMS

Enumeration Type Documentation

◆ _SYMCRYPT_XMSS_WOTSP_ALGID

enum _SYMCRYPT_XMSS_WOTSP_ALGID
Enumerator
SYMCRYPT_XMSS_WOTSP_SHA2_256 
SYMCRYPT_XMSS_WOTSP_SHA2_512 
SYMCRYPT_XMSS_WOTSP_SHAKE_256 
SYMCRYPT_XMSS_WOTSP_SHAKE_512 
SYMCRYPT_XMSS_WOTSP_SHA2_192 
SYMCRYPT_XMSS_WOTSP_SHAKE256_256 
SYMCRYPT_XMSS_WOTSP_SHAKE256_192 

Definition at line 33 of file xmss.c.

34{
35 // Hash Fn. RFC-8391 SP800-208
36 SYMCRYPT_XMSS_WOTSP_SHA2_256 = 0x00000001, // SHA-256 X X
37 SYMCRYPT_XMSS_WOTSP_SHA2_512 = 0x00000002, // SHA-512 X
38 SYMCRYPT_XMSS_WOTSP_SHAKE_256 = 0x00000003, // SHAKE128 X
39 SYMCRYPT_XMSS_WOTSP_SHAKE_512 = 0x00000004, // SHAKE256 X
40 SYMCRYPT_XMSS_WOTSP_SHA2_192 = 0x00000005, // SHA-256 X
41 SYMCRYPT_XMSS_WOTSP_SHAKE256_256 = 0x00000006, // SHAKE256 X
42 SYMCRYPT_XMSS_WOTSP_SHAKE256_192 = 0x00000007, // SHAKE256 X
43
44} SYMCRYPT_XMSS_WOTSP_ALGID, *PSYMCRYPT_XMSS_WOTSP_ALGID;
PSYMCRYPT_XMSS_WOTSP_ALGID
enum _SYMCRYPT_XMSS_WOTSP_ALGID * PSYMCRYPT_XMSS_WOTSP_ALGID
SYMCRYPT_XMSS_WOTSP_ALGID
enum _SYMCRYPT_XMSS_WOTSP_ALGID SYMCRYPT_XMSS_WOTSP_ALGID
SYMCRYPT_XMSS_WOTSP_SHA2_192
@ SYMCRYPT_XMSS_WOTSP_SHA2_192
Definition: xmss.c:40
SYMCRYPT_XMSS_WOTSP_SHAKE256_192
@ SYMCRYPT_XMSS_WOTSP_SHAKE256_192
Definition: xmss.c:42
SYMCRYPT_XMSS_WOTSP_SHAKE256_256
@ SYMCRYPT_XMSS_WOTSP_SHAKE256_256
Definition: xmss.c:41
SYMCRYPT_XMSS_WOTSP_SHAKE_256
@ SYMCRYPT_XMSS_WOTSP_SHAKE_256
Definition: xmss.c:38
SYMCRYPT_XMSS_WOTSP_SHAKE_512
@ SYMCRYPT_XMSS_WOTSP_SHAKE_512
Definition: xmss.c:39
SYMCRYPT_XMSS_WOTSP_SHA2_512
@ SYMCRYPT_XMSS_WOTSP_SHA2_512
Definition: xmss.c:37
SYMCRYPT_XMSS_WOTSP_SHA2_256
@ SYMCRYPT_XMSS_WOTSP_SHA2_256
Definition: xmss.c:36

Function Documentation

◆ SymCryptHbsGetDigit()

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

Definition at line 1429 of file xmss.c.

1434{
1435 UNREFERENCED_PARAMETER(cbBuffer);
1436
1437 SYMCRYPT_ASSERT(width == 1 || width == 2 || width == 4 || width == 8);
1438 SYMCRYPT_ASSERT(index < ((cbBuffer * 8) / width));
1439
1440 UINT32 digitsPerByte = 8 / width;
1441
1442 BYTE value = pbBuffer[index / digitsPerByte];
1443
1444 value >>= width * (digitsPerByte - 1 - (index % digitsPerByte));
1445
1446 value &= (1 << width) - 1;
1447
1448 return value;
1449}
width
GLint GLint GLsizei width
Definition: gl.h:1546
index
GLuint index
Definition: glext.h:6031
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
cbBuffer
SIZE_T cbBuffer
Definition: sc_lib_mldsa.h:405
SYMCRYPT_ASSERT
#define SYMCRYPT_ASSERT(_x)
Definition: symcrypt.h:10807
UINT32
uint32_t UINT32
Definition: typedefs.h:59
value
Definition: pdh_main.c:64
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by LmsComputeOtsPubKeyCandidate(), LmsOtsCalculateChecksum(), LmsOtskeySign(), SymCryptXmssWotspPublickeyFromSignature(), and SymCryptXmssWotspSign().

◆ SymCryptHbsGetWinternitzLengths()

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

Definition at line 188 of file xmss.c.

194{
195 UINT32 len1;
196 UINT32 len2;
197 UINT32 maxChecksum;
198 UINT32 msb;
199
200 SYMCRYPT_ASSERT(n > 0);
201 SYMCRYPT_ASSERT(w >= 1 && w <= 8);
202
203 // number of w-bit digits in an n-byte input
204 len1 = (8 * n + (w - 1)) / w;
205
206 // maximum value the checksum can take (each w-bit digit can have value at most 2^w-1)
207 maxChecksum = len1 * ((1 << w) - 1);
208
209 msb = 31 - SymCryptCountLeadingZeros32(maxChecksum);
210
211 // msb + 1 bits are required to store the maxChecksum,
212 // calculate the number of w-bit blocks to represent that
213 len2 = (msb + 1 + (w - 1)) / w;
214
215 *puLen1 = len1;
216 *puLen2 = len2;
217}
n
GLdouble n
Definition: glext.h:7729
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
SymCryptCountLeadingZeros32
FORCEINLINE UINT32 SymCryptCountLeadingZeros32(UINT32 value)
Definition: sc_lib.h:5079
len2
UINT32 len2
Definition: symcrypt_internal.h:3097
len1
UINT32 len1
Definition: symcrypt_internal.h:3096

Referenced by SymCryptLmsParamsFromAlgId(), SymCryptLmsSetParams(), and SymCryptXmssDeriveParams().

◆ SymCryptHbsIncrementalTreehashAllocNode()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashAllocNode ( _Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH  pIncHash,
UINT32  nLeafIndex 
)

Definition at line 623 of file xmss.c.

626{
627 SYMCRYPT_ASSERT(pIncHash->nSize < pIncHash->nCapacity);
628
629 PSYMCRYPT_TREEHASH_NODE pNode = SymCryptHbsIncrementalTreehashGetNode(pIncHash, pIncHash->nSize);
630
631 pNode->height = 0;
632 pNode->index = nLeafIndex;
633
634 pIncHash->nSize++;
635
636 return pNode;
637}
_SYMCRYPT_TREEHASH_NODE
Definition: sc_lib.h:4591
_SYMCRYPT_TREEHASH_NODE::height
UINT32 height
Definition: sc_lib.h:4593
_SYMCRYPT_TREEHASH_NODE::index
UINT32 index
Definition: sc_lib.h:4592
SymCryptHbsIncrementalTreehashGetNode
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetNode(_In_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, SIZE_T index)
Definition: xmss.c:609

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashFinalize()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashFinalize ( _Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH  pIncHash)

Definition at line 695 of file xmss.c.

697{
698 return SymCryptHbsIncrementalTreehashProcessCommon(pIncHash, TRUE);
699}
TRUE
#define TRUE
Definition: types.h:120
SymCryptHbsIncrementalTreehashProcessCommon
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcessCommon(_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, BOOLEAN fFinal)
Definition: xmss.c:655

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashGetNode()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetNode ( _In_ PSYMCRYPT_INCREMENTAL_TREEHASH  pIncHash,
SIZE_T  index 
)

Definition at line 609 of file xmss.c.

612{
613 PBYTE pNode = (PBYTE)pIncHash->arrNodes;
614
615 pNode += index * pIncHash->cbNode;
616
617 return (PSYMCRYPT_TREEHASH_NODE)pNode;
618}
return
return
Definition: dirsup.c:529
PBYTE
BYTE * PBYTE
Definition: pedump.c:66

Referenced by SymCryptHbsIncrementalTreehashAllocNode(), and SymCryptHbsIncrementalTreehashGetTopNodes().

◆ SymCryptHbsIncrementalTreehashGetTopNodes()

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

Definition at line 642 of file xmss.c.

646{
647 *ppNodeRight = (pIncHash->nSize < 1) ? NULL : SymCryptHbsIncrementalTreehashGetNode(pIncHash, pIncHash->nSize - 1);
648
649 *ppNodeLeft = (pIncHash->nSize < 2) ? NULL : SymCryptHbsIncrementalTreehashGetNode(pIncHash, pIncHash->nSize - 2);
650}
NULL
#define NULL
Definition: types.h:112

Referenced by SymCryptHbsIncrementalTreehashProcessCommon().

◆ SymCryptHbsIncrementalTreehashInit()

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

Definition at line 582 of file xmss.c.

589{
590 UNREFERENCED_PARAMETER(cbBuffer);
591
592 SYMCRYPT_ASSERT(cbBuffer >= SymCryptHbsSizeofScratchBytesForIncrementalTreehash(cbHashResult, nLeaves));
593
594 PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash = (PSYMCRYPT_INCREMENTAL_TREEHASH)pbBuffer;
595
596 pIncHash->cbNode = 2 * sizeof(UINT32) + cbHashResult;
597 pIncHash->nSize = 0;
598 pIncHash->nCapacity = SymCryptHbsIncrementalTreehashStackDepth(nLeaves);
599 pIncHash->nLastLeafIndex = 0;
600 pIncHash->funcCompressNodes = funcCompressNodes;
601 pIncHash->pContext = pContext;
602
603 return pIncHash;
604}
PSYMCRYPT_INCREMENTAL_TREEHASH
struct _SYMCRYPT_INCREMENTAL_TREEHASH * PSYMCRYPT_INCREMENTAL_TREEHASH
_SYMCRYPT_INCREMENTAL_TREEHASH
Definition: sc_lib.h:4621
_SYMCRYPT_INCREMENTAL_TREEHASH::cbNode
UINT32 cbNode
Definition: sc_lib.h:4622
_SYMCRYPT_INCREMENTAL_TREEHASH::nSize
UINT32 nSize
Definition: sc_lib.h:4623
_SYMCRYPT_INCREMENTAL_TREEHASH::nLastLeafIndex
UINT32 nLastLeafIndex
Definition: sc_lib.h:4625
_SYMCRYPT_INCREMENTAL_TREEHASH::nCapacity
UINT32 nCapacity
Definition: sc_lib.h:4624
_SYMCRYPT_INCREMENTAL_TREEHASH::funcCompressNodes
PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC funcCompressNodes
Definition: sc_lib.h:4626
_SYMCRYPT_INCREMENTAL_TREEHASH::pContext
PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pContext
Definition: sc_lib.h:4627
SymCryptHbsIncrementalTreehashStackDepth
UINT32 SYMCRYPT_CALL SymCryptHbsIncrementalTreehashStackDepth(UINT32 nLeaves)
Definition: xmss.c:704
SymCryptHbsSizeofScratchBytesForIncrementalTreehash
SIZE_T SYMCRYPT_CALL SymCryptHbsSizeofScratchBytesForIncrementalTreehash(UINT32 cbNode, UINT32 nLeaves)
Definition: xmss.c:719

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashProcess()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcess ( _Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH  pIncHash)

Definition at line 686 of file xmss.c.

688{
689 return SymCryptHbsIncrementalTreehashProcessCommon(pIncHash, FALSE);
690}
FALSE
#define FALSE
Definition: types.h:117

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ SymCryptHbsIncrementalTreehashProcessCommon()

PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcessCommon ( _Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH  pIncHash,
BOOLEAN  fFinal 
)

Definition at line 655 of file xmss.c.

658{
659 PSYMCRYPT_TREEHASH_NODE pNodeLeft = NULL;
660 PSYMCRYPT_TREEHASH_NODE pNodeRight = NULL;
661
662 SYMCRYPT_ASSERT(pIncHash->nSize > 0);
663
664 SymCryptHbsIncrementalTreehashGetTopNodes(pIncHash, &pNodeLeft, &pNodeRight);
665
666 while ( pNodeLeft &&
667 (fFinal || (pNodeLeft->height == pNodeRight->height)) )
668 {
669 pIncHash->funcCompressNodes(
670 pNodeLeft,
671 pNodeRight,
672 pNodeLeft,
673 pIncHash->pContext);
674
675 pIncHash->nSize--;
676
677 SymCryptHbsIncrementalTreehashGetTopNodes(pIncHash, &pNodeLeft, &pNodeRight);
678 }
679
680 return pNodeRight;
681}
SymCryptHbsIncrementalTreehashGetTopNodes
VOID SYMCRYPT_CALL SymCryptHbsIncrementalTreehashGetTopNodes(_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, _Out_ PSYMCRYPT_TREEHASH_NODE *ppNodeLeft, _Out_ PSYMCRYPT_TREEHASH_NODE *ppNodeRight)
Definition: xmss.c:642

Referenced by SymCryptHbsIncrementalTreehashFinalize(), and SymCryptHbsIncrementalTreehashProcess().

◆ SymCryptHbsIncrementalTreehashStackDepth()

UINT32 SYMCRYPT_CALL SymCryptHbsIncrementalTreehashStackDepth ( UINT32  nLeaves)

Definition at line 704 of file xmss.c.

706{
707 UINT32 h;
708
709 // Minimum height binary tree that contains nLeaves many leaves is h+1
710 h = 31 - SymCryptCountLeadingZeros32(nLeaves);
711
712 // Tree root computation will require a stack of depth equal to tree height plus 1
713 return (h + 2);
714}
h
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723

Referenced by SymCryptHbsIncrementalTreehashInit(), and SymCryptHbsSizeofScratchBytesForIncrementalTreehash().

◆ SymCryptHbsSizeofScratchBytesForIncrementalTreehash()

SIZE_T SYMCRYPT_CALL SymCryptHbsSizeofScratchBytesForIncrementalTreehash ( UINT32  cbNode,
UINT32  nLeaves 
)

Definition at line 719 of file xmss.c.

722{
723 SIZE_T nodeSize = cbNode + 2 * sizeof(UINT32);
724 SIZE_T result = (sizeof(SYMCRYPT_INCREMENTAL_TREEHASH) - sizeof(SYMCRYPT_TREEHASH_NODE));
725
726 result += nodeSize * SymCryptHbsIncrementalTreehashStackDepth(nLeaves);
727 return result;
728}
result
GLuint64EXT * result
Definition: glext.h:11304
SYMCRYPT_INCREMENTAL_TREEHASH
struct _SYMCRYPT_INCREMENTAL_TREEHASH SYMCRYPT_INCREMENTAL_TREEHASH
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80

Referenced by SymCryptHbsIncrementalTreehashInit(), SymCryptXmssComputePublicRoot(), SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssChain()

VOID SYMCRYPT_CALL SymCryptXmssChain ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbInput,
UINT32  startIndex,
UINT32  steps,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_Inout_ XMSS_ADRS *  adrs,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 889 of file xmss.c.

897{
898 BYTE tmp[SYMCRYPT_HASH_MAX_RESULT_SIZE];
899 BYTE key[SYMCRYPT_HASH_MAX_RESULT_SIZE];
900 BYTE bm[SYMCRYPT_HASH_MAX_RESULT_SIZE];
901 SYMCRYPT_HASH_STATE stateKey;
902 SYMCRYPT_HASH_STATE stateMask;
903
904 memcpy(tmp, pbInput, pParams->cbHashOutput);
905
906 for (UINT32 i = startIndex; i < startIndex + steps; i++)
907 {
908 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Hash, i);
909
910 SymCryptXmssPrfKey(pParams, pbSeed, pParams->cbHashOutput, &stateKey);
911 SymCryptHashStateCopy(pParams->hash, &stateKey, &stateMask);
912
913 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 0);
914 SymCryptHashAppend(pParams->hash, &stateKey, (PCBYTE)adrs, sizeof(*adrs));
915 SymCryptHashResult(pParams->hash, &stateKey, key, pParams->cbHashOutput);
916
917 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 1);
918 SymCryptHashAppend(pParams->hash, &stateMask, (PCBYTE)adrs, sizeof(*adrs));
919 SymCryptHashResult(pParams->hash, &stateMask, bm, pParams->cbHashOutput);
920
921 SymCryptXorBytes(tmp, bm, tmp, pParams->cbHashOutput);
922
923 SymCryptXmssPrf(pParams, SYMCRYPT_XMSS_F, key, pParams->cbHashOutput, tmp, pParams->cbHashOutput, tmp);
924 }
925
926 // reset used ADRS fields
927 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Hash, 0);
928 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 0);
929
930 memcpy(pbOutput, tmp, pParams->cbHashOutput);
931}
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
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
steps
static DWORD DWORD DWORD DWORD * steps
Definition: cursoricon.c:1804
key
Definition: copy.c:22
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
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
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
SYMCRYPT_STORE_MSBFIRST32
#define SYMCRYPT_STORE_MSBFIRST32(p, v)
Definition: symcrypt.h:311
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_MAX_RESULT_SIZE
#define SYMCRYPT_HASH_MAX_RESULT_SIZE
Definition: symcrypt_internal.h:1176
PCBYTE
const BYTE * PCBYTE
Definition: symcrypt_internal.h:248
pbSeed
PBYTE pbSeed
Definition: symcrypt_internal.h:2846
_SYMCRYPT_HASH_STATE
Definition: symcrypt_internal.h:1158
SymCryptXmssPrfKey
VOID SYMCRYPT_CALL SymCryptXmssPrfKey(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _Out_ SYMCRYPT_HASH_STATE *pState)
Definition: xmss.c:753
SYMCRYPT_XMSS_F
#define SYMCRYPT_XMSS_F
Definition: xmss.c:18
SymCryptXmssPrf
VOID SYMCRYPT_CALL SymCryptXmssPrf(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, BYTE PrfType, _In_reads_bytes_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_bytes_(cbMsg) PCBYTE pbMsg, SIZE_T cbMsg, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:765

Referenced by SymCryptXmssCreateWotspPublickey(), SymCryptXmssWotspPublickeyFromSignature(), and SymCryptXmssWotspSign().

◆ SymCryptXmssComputePublicRoot()

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

Definition at line 1069 of file xmss.c.

1077{
1078 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1079 PBYTE pbScratch = NULL;
1080 SIZE_T cbScratch = 0;
1081 XMSS_ADRS adrs;
1082
1083 SYMCRYPT_ASSERT(pParams->nLayerHeight < 32); // Ensure nLeaves fits in 32 bits
1084
1085 if (pbRoot == NULL || cbRoot != pParams->cbHashOutput ||
1086 pbSeed == NULL || cbSeed != pParams->cbHashOutput ||
1087 pbSkXmss == NULL || cbSkXmss != pParams->cbHashOutput)
1088 {
1089 scError = SYMCRYPT_INVALID_ARGUMENT;
1090 goto cleanup;
1091 }
1092
1093 cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, 1ULL << pParams->nLayerHeight);
1094 cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len);
1095
1096 SYMCRYPT_ASSERT(cbScratch > 0);
1097 pbScratch = SymCryptCallbackAlloc(cbScratch);
1098
1099 if (pbScratch == NULL)
1100 {
1101 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1102 goto cleanup;
1103 }
1104
1105 SymCryptWipeKnownSize(&adrs, sizeof(XMSS_ADRS));
1106 SYMCRYPT_STORE_MSBFIRST32(adrs.en32Layer, pParams->nLayers - 1);
1107
1108 SymCryptXmssComputeSubtreeRoot(
1109 pParams,
1110 &adrs,
1111 pbSkXmss,
1112 pbSeed,
1113 0,
1114 pParams->nLayerHeight,
1115 pbScratch,
1116 cbScratch,
1117 pbRoot );
1118
1119cleanup:
1120
1121 if (pbScratch != NULL)
1122 {
1123 SymCryptWipe(pbScratch, cbScratch);
1124 SymCryptCallbackFree(pbScratch);
1125 }
1126
1127 return scError;
1128}
cleanup
static void cleanup(void)
Definition: main.c:1335
SymCryptCallbackFree
void SYMCRYPT_CALL SymCryptCallbackFree(void *ptr)
Definition: implglue.c:42
SymCryptCallbackAlloc
void *SYMCRYPT_CALL SymCryptCallbackAlloc(SIZE_T size)
Definition: implglue.c:37
cbScratch
UINT32 UINT32 UINT32 UINT32 cbScratch
Definition: sc_lib_mldsa.h:1073
_XMSS_ADRS
Definition: sc_lib.h:4503
_XMSS_ADRS::en32Layer
BYTE en32Layer[4]
Definition: sc_lib.h:4504
SymCryptWipeKnownSize
FORCEINLINE VOID SYMCRYPT_CALL SymCryptWipeKnownSize(_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
Definition: symcrypt_internal.h:3411
SymCryptWipe
VOID SYMCRYPT_CALL SymCryptWipe(_Out_writes_bytes_(cbData) PVOID pbData, SIZE_T cbData)
Definition: libmain.c:137
SYMCRYPT_ERROR
SYMCRYPT_ERROR
Definition: symcrypt.h:227
cbSeed
UINT32 cbSeed
Definition: symcrypt_internal.h:2831
SymCryptXmssComputeSubtreeRoot
VOID SYMCRYPT_CALL SymCryptXmssComputeSubtreeRoot(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, UINT32 uLeaf, UINT32 uHeight, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbRoot)
Definition: xmss.c:1003

Referenced by SymCryptXmsskeyGenerate(), and SymCryptXmsskeyVerifyRoot().

◆ SymCryptXmssComputeRandomness()

VOID SYMCRYPT_CALL SymCryptXmssComputeRandomness ( _In_ PCSYMCRYPT_XMSS_KEY  pKey,
UINT64  Idx,
_Out_writes_bytes_(pKey->params.cbHashOutput) PBYTE  pbRandomness 
)

Definition at line 2000 of file xmss.c.

2004{
2005 BYTE IdxBuffer[32];
2006
2007 SymCryptWipeKnownSize(IdxBuffer, sizeof(IdxBuffer));
2008 SYMCRYPT_STORE_MSBFIRST64(IdxBuffer + sizeof(IdxBuffer) - sizeof(Idx), Idx);
2009
2010 SymCryptXmssPrf(
2011 &pKey->params,
2012 SYMCRYPT_XMSS_PRF,
2013 pKey->SkPrf,
2014 pKey->params.cbHashOutput,
2015 IdxBuffer,
2016 sizeof(IdxBuffer),
2017 pbRandomness);
2018}
SYMCRYPT_STORE_MSBFIRST64
#define SYMCRYPT_STORE_MSBFIRST64(p, v)
Definition: symcrypt.h:312
pKey
PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY pKey
Definition: symcrypt_internal.h:1324
SYMCRYPT_XMSS_PRF
#define SYMCRYPT_XMSS_PRF
Definition: xmss.c:21

Referenced by SymCryptXmssSign().

◆ SymCryptXmssComputeSubtreeRoot()

VOID SYMCRYPT_CALL SymCryptXmssComputeSubtreeRoot ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_ XMSS_ADRS *  adrs,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSkXmss,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
UINT32  uLeaf,
UINT32  uHeight,
_Out_writes_bytes_opt_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbRoot 
)

Definition at line 1003 of file xmss.c.

1013{
1014 UNREFERENCED_PARAMETER(cbScratch);
1015
1016 PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash = NULL;
1017 PSYMCRYPT_TREEHASH_NODE pNode = NULL;
1018 SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT ctxIncHash;
1019
1020 SYMCRYPT_ASSERT((uLeaf & ((1UL << uHeight) - 1)) == 0); // uLeaf must be a multiple of 2^uHeight
1021 SYMCRYPT_ASSERT(pParams->nLayerHeight < 32); // Ensure nLeaves fits in 32 bits
1022
1023 SIZE_T cbScratchTree = SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, 1ULL << pParams->nLayerHeight);
1024 SIZE_T cbScratchLtree = SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len);
1025
1026 SYMCRYPT_ASSERT(cbScratch >= (cbScratchTree + cbScratchLtree));
1027
1028 PBYTE pbScratchTree = pbScratch;
1029 PBYTE pbScratchLtree = pbScratch + cbScratchTree;
1030
1031 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_HASH_TREE);
1032
1033 ctxIncHash.adrs = *adrs;
1034 ctxIncHash.pParams = pParams;
1035 ctxIncHash.pbSeed = pbSeed;
1036
1037 pIncHash = SymCryptHbsIncrementalTreehashInit(
1038 1ULL << uHeight,
1039 pbScratchTree,
1040 cbScratchTree,
1041 pParams->cbHashOutput,
1042 SymCryptXmssTreeNodeCompress,
1043 &ctxIncHash);
1044
1045 for (UINT32 nLeafIndex = uLeaf; nLeafIndex < uLeaf + (1UL << uHeight); nLeafIndex++)
1046 {
1047 pNode = SymCryptHbsIncrementalTreehashAllocNode(pIncHash, nLeafIndex);
1048
1049 SymCryptXmssCreateWotspPublickey(pParams,
1050 adrs,
1051 nLeafIndex,
1052 pbSkXmss,
1053 pbSeed,
1054 pbScratchLtree,
1055 cbScratchLtree,
1056 pNode->value );
1057
1058 SymCryptHbsIncrementalTreehashProcess(pIncHash);
1059 }
1060
1061 pNode = SymCryptHbsIncrementalTreehashFinalize(pIncHash);
1062
1063 memcpy(pbRoot, pNode->value, pParams->cbHashOutput);
1064}
XMSS_ADRS_TYPE_HASH_TREE
@ XMSS_ADRS_TYPE_HASH_TREE
Definition: sc_lib.h:4478
_SYMCRYPT_TREEHASH_NODE::value
BYTE value[SYMCRYPT_ANYSIZE_ARRAY]
Definition: sc_lib.h:4594
_SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT
Definition: sc_lib.h:4603
_SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT::pParams
PCSYMCRYPT_XMSS_PARAMS pParams
Definition: sc_lib.h:4604
_SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT::adrs
XMSS_ADRS adrs
Definition: sc_lib.h:4606
_SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT::pbSeed
PCBYTE pbSeed
Definition: sc_lib.h:4605
SymCryptHbsIncrementalTreehashFinalize
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashFinalize(_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash)
Definition: xmss.c:695
SymCryptXmssCreateWotspPublickey
VOID SYMCRYPT_CALL SymCryptXmssCreateWotspPublickey(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:936
SymCryptXmssSetAdrsType
VOID SYMCRYPT_CALL SymCryptXmssSetAdrsType(_Out_ PXMSS_ADRS adrs, UINT32 type)
Definition: xmss.c:465
SymCryptHbsIncrementalTreehashInit
PSYMCRYPT_INCREMENTAL_TREEHASH SYMCRYPT_CALL SymCryptHbsIncrementalTreehashInit(UINT32 nLeaves, PBYTE pbBuffer, SIZE_T cbBuffer, UINT32 cbHashResult, PSYMCRYPT_INCREMENTAL_TREEHASH_FUNC funcCompressNodes, PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pContext)
Definition: xmss.c:582
SymCryptHbsIncrementalTreehashProcess
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashProcess(_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash)
Definition: xmss.c:686
SymCryptHbsIncrementalTreehashAllocNode
PSYMCRYPT_TREEHASH_NODE SYMCRYPT_CALL SymCryptHbsIncrementalTreehashAllocNode(_Inout_ PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash, UINT32 nLeafIndex)
Definition: xmss.c:623
SymCryptXmssTreeNodeCompress
VOID SYMCRYPT_CALL SymCryptXmssTreeNodeCompress(_In_ PSYMCRYPT_TREEHASH_NODE pNodeLeft, _In_ PSYMCRYPT_TREEHASH_NODE pNodeRight, _Out_ PSYMCRYPT_TREEHASH_NODE pNodeOut, _Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pCtxIncHash)
Definition: xmss.c:825

Referenced by SymCryptXmssComputePublicRoot(), and SymCryptXmssTreeSignHash().

◆ SymCryptXmssCreateWotspPublickey()

VOID SYMCRYPT_CALL SymCryptXmssCreateWotspPublickey ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_Inout_ XMSS_ADRS *  adrs,
UINT32  uLeaf,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSkXmss,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_Out_writes_bytes_opt_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 936 of file xmss.c.

945{
946 PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash = NULL;
947 PSYMCRYPT_TREEHASH_NODE pNode = NULL;
948 SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT ctxIncHash;
949
950 SYMCRYPT_ASSERT(cbScratch >= SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len));
951
952 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_LTREE);
953 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ltree.en32Leaf, uLeaf);
954
955 ctxIncHash.adrs = *adrs;
956 ctxIncHash.pParams = pParams;
957 ctxIncHash.pbSeed = pbSeed;
958
959 pIncHash = SymCryptHbsIncrementalTreehashInit(
960 pParams->len,
961 pbScratch,
962 cbScratch,
963 pParams->cbHashOutput,
964 SymCryptXmssLtreeNodeCompress,
965 &ctxIncHash);
966
967 for (UINT32 i = 0; i < pParams->len; i++)
968 {
969 pNode = SymCryptHbsIncrementalTreehashAllocNode(pIncHash, i);
970
971 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_OTS);
972 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Leaf, uLeaf);
973 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Chain, i);
974
975 SymCryptXmssCreateWotspSecret(
976 pParams,
977 pbSkXmss,
978 pbSeed,
979 adrs,
980 pNode->value);
981
982 SymCryptXmssChain(
983 pParams,
984 pNode->value,
985 0,
986 (1 << pParams->nWinternitzWidth) - 1,
987 pbSeed,
988 adrs,
989 pNode->value);
990
991 SymCryptHbsIncrementalTreehashProcess(pIncHash);
992
993 }
994
995 pNode = SymCryptHbsIncrementalTreehashFinalize(pIncHash);
996
997 memcpy(pbOutput, pNode->value, pParams->cbHashOutput);
998}
XMSS_ADRS_TYPE_LTREE
@ XMSS_ADRS_TYPE_LTREE
Definition: sc_lib.h:4477
XMSS_ADRS_TYPE_OTS
@ XMSS_ADRS_TYPE_OTS
Definition: sc_lib.h:4476
SymCryptXmssChain
VOID SYMCRYPT_CALL SymCryptXmssChain(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbInput, UINT32 startIndex, UINT32 steps, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Inout_ XMSS_ADRS *adrs, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:889
SymCryptXmssLtreeNodeCompress
VOID SYMCRYPT_CALL SymCryptXmssLtreeNodeCompress(_In_ PSYMCRYPT_TREEHASH_NODE pNodeLeft, _In_ PSYMCRYPT_TREEHASH_NODE pNodeRight, _Out_ PSYMCRYPT_TREEHASH_NODE pNodeOut, _Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT pCtxIncHash)
Definition: xmss.c:848
SymCryptXmssCreateWotspSecret
VOID SYMCRYPT_CALL SymCryptXmssCreateWotspSecret(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Inout_ XMSS_ADRS *adrs, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:871

Referenced by SymCryptXmssComputeSubtreeRoot(), and SymCryptXmssTreeSignHash().

◆ SymCryptXmssCreateWotspSecret()

VOID SYMCRYPT_CALL SymCryptXmssCreateWotspSecret ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSkXmss,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_Inout_ XMSS_ADRS *  adrs,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 871 of file xmss.c.

877{
878 SYMCRYPT_HASH_STATE state;
879
880 SymCryptXmssPrfInit(pParams->hash, SYMCRYPT_XMSS_PRF_KEYGEN, pParams->cbPrefix, &state);
881 SymCryptHashAppend(pParams->hash, &state, pbSkXmss, pParams->cbHashOutput);
882 SymCryptHashAppend(pParams->hash, &state, pbSeed, pParams->cbHashOutput);
883 SymCryptHashAppend(pParams->hash, &state, (PCBYTE)adrs, sizeof(*adrs));
884 SymCryptHashResult(pParams->hash, &state, pbOutput, pParams->cbHashOutput);
885}
state
static int state
Definition: maze.c:121
SYMCRYPT_XMSS_PRF_KEYGEN
#define SYMCRYPT_XMSS_PRF_KEYGEN
Definition: xmss.c:22
SymCryptXmssPrfInit
VOID SYMCRYPT_CALL SymCryptXmssPrfInit(_In_ PCSYMCRYPT_HASH hash, BYTE PrfType, SIZE_T prefixLength, _Out_ PSYMCRYPT_HASH_STATE state)
Definition: xmss.c:733

Referenced by SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspSign().

◆ SymCryptXmssDeriveParams()

VOID SYMCRYPT_CALL SymCryptXmssDeriveParams ( _Inout_ PSYMCRYPT_XMSS_PARAMS  pParams)

Definition at line 255 of file xmss.c.

257{
258 SymCryptHbsGetWinternitzLengths(
259 pParams->cbHashOutput,
260 pParams->nWinternitzWidth,
261 &pParams->len1,
262 &pParams->len2);
263
264 pParams->len = pParams->len1 + pParams->len2;
265
266 UINT32 nChecksumBits = pParams->len2 * pParams->nWinternitzWidth;
267 SYMCRYPT_ASSERT(nChecksumBits <= 32);
268 pParams->nLeftShift32 = (UINT8)(32 - nChecksumBits);
269
270 if (pParams->nLayers == 1)
271 {
272 // single trees have a 32-bit Idx value
273 pParams->cbIdx = 4;
274 }
275 else
276 {
277 // number of bytes to store h-bits for Idx
278 pParams->cbIdx = (pParams->nTotalTreeHeight + 7) / 8;
279 }
280
281 pParams->nLayerHeight = pParams->nTotalTreeHeight / pParams->nLayers;
282}
UINT8
unsigned char UINT8
Definition: actypes.h:128
SymCryptHbsGetWinternitzLengths
VOID SYMCRYPT_CALL SymCryptHbsGetWinternitzLengths(UINT32 n, UINT32 w, _Out_ PUINT32 puLen1, _Out_ PUINT32 puLen2)
Definition: xmss.c:188

Referenced by SymCryptXmssParamsFromAlgIdCommon(), and SymCryptXmssSetParams().

◆ SymCryptXmssGetWotspParams()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssGetWotspParams ( SYMCRYPT_XMSS_WOTSP_ALGID  id,
_Out_ PSYMCRYPT_XMSS_PARAMS  pParams 
)

Definition at line 221 of file xmss.c.

224{
225 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
226
227 for (UINT32 i = 0; i < SYMCRYPT_ARRAY_SIZE(XmssWotspParams); i++)
228 {
229 if (XmssWotspParams[i].wotspId == id)
230 {
231 SYMCRYPT_ASSERT(XmssWotspParams[i].hashIndex < SYMCRYPT_ARRAY_SIZE(XmssHashArray));
232 pParams->hash = *XmssHashArray[XmssWotspParams[i].hashIndex];
233 pParams->cbHashOutput = XmssWotspParams[i].n;
234 pParams->nWinternitzWidth = XmssWotspParams[i].w;
235 pParams->cbPrefix = XmssWotspParams[i].cbPrefix;
236 goto cleanup;
237 }
238 }
239
240 scError = SYMCRYPT_INVALID_ARGUMENT;
241
242cleanup:
243
244 return scError;
245}
SYMCRYPT_ARRAY_SIZE
#define SYMCRYPT_ARRAY_SIZE(_x)
Definition: sc_lib.h:342
_SYMCRYPT_XMSS_WOTSP_PARAMS::hashIndex
UINT8 hashIndex
Definition: xmss.c:50
_SYMCRYPT_XMSS_WOTSP_PARAMS::w
UINT8 w
Definition: xmss.c:52
_SYMCRYPT_XMSS_WOTSP_PARAMS::n
UINT8 n
Definition: xmss.c:51
_SYMCRYPT_XMSS_WOTSP_PARAMS::cbPrefix
UINT8 cbPrefix
Definition: xmss.c:53
XmssWotspParams
static const SYMCRYPT_XMSS_WOTSP_PARAMS XmssWotspParams[]
Definition: xmss.c:58
XmssHashArray
static const PCSYMCRYPT_HASH * XmssHashArray[]
Definition: xmss.c:25

Referenced by SymCryptXmssParamsFromAlgIdCommon().

◆ 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}
flags
GLbitfield flags
Definition: glext.h:7161
SYMCRYPT_XMSSKEY_TYPE_NONE
@ SYMCRYPT_XMSSKEY_TYPE_NONE
Definition: symcrypt.h:9152
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
SYMCRYPT_SET_MAGIC
#define SYMCRYPT_SET_MAGIC(p)
Definition: symcrypt_internal.h:358
cbSize
UINT32 cbSize
Definition: symcrypt_internal.h:2409

◆ 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}
SYMCRYPT_CHECK_MAGIC
#define SYMCRYPT_CHECK_MAGIC(p)
Definition: symcrypt_internal.h:359

◆ 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}
SymCryptCallbackRandom
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCallbackRandom(BYTE *buf, SIZE_T size)
Definition: implglue.c:56
SYMCRYPT_XMSSKEY_TYPE_PRIVATE
@ SYMCRYPT_XMSSKEY_TYPE_PRIVATE
Definition: symcrypt.h:9154
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}
keyType
SYMCRYPT_XMSSKEY_TYPE keyType
Definition: sc_lib.h:4525
SYMCRYPT_XMSSKEY_TYPE_PUBLIC
@ SYMCRYPT_XMSSKEY_TYPE_PUBLIC
Definition: symcrypt.h:9153
cbKey
PCBYTE SIZE_T cbKey
Definition: symcrypt_internal.h:1987
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}
UINT64
COMPILER_DEPENDENT_UINT64 UINT64
Definition: actypes.h:131
SYMCRYPT_LOAD_MSBFIRST32
#define SYMCRYPT_LOAD_MSBFIRST32(p)
Definition: symcrypt.h:303
SYMCRYPT_LOAD_MSBFIRST64
#define SYMCRYPT_LOAD_MSBFIRST64(p)
Definition: symcrypt.h:304
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

◆ SymCryptXmsskeyVerifyRoot()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmsskeyVerifyRoot ( _In_ PCSYMCRYPT_XMSS_KEY  pKey)

Definition at line 1133 of file xmss.c.

1135{
1136 BYTE Root[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1137 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1138
1139 SYMCRYPT_CHECK_MAGIC(pKey);
1140
1141 // key to be verified has to be a private key
1142 if (pKey->keyType != SYMCRYPT_XMSSKEY_TYPE_PRIVATE)
1143 {
1144 scError = SYMCRYPT_INVALID_ARGUMENT;
1145 goto cleanup;
1146 }
1147
1148 SymCryptWipeKnownSize(Root, sizeof(Root));
1149
1150 scError = SymCryptXmssComputePublicRoot(
1151 &pKey->params,
1152 pKey->Seed,
1153 pKey->params.cbHashOutput,
1154 pKey->SkXmss,
1155 pKey->params.cbHashOutput,
1156 Root,
1157 pKey->params.cbHashOutput);
1158
1159 if (scError != SYMCRYPT_NO_ERROR)
1160 {
1161 goto cleanup;
1162 }
1163
1164 if (!SymCryptEqual(Root, pKey->Root, pKey->params.cbHashOutput))
1165 {
1166 scError = SYMCRYPT_HBS_PUBLIC_ROOT_MISMATCH;
1167 }
1168
1169cleanup:
1170
1171 return scError;
1172}
Root
@ Root
Definition: cmtypes.h:261
SymCryptEqual
BOOLEAN SYMCRYPT_CALL SymCryptEqual(_In_reads_(cbBytes) PCBYTE pbSrc1, _In_reads_(cbBytes) PCBYTE pbSrc2, SIZE_T cbBytes)
Definition: equal.c:11

Referenced by SymCryptXmsskeySetValue().

◆ SymCryptXmssLtreeNodeCompress()

VOID SYMCRYPT_CALL SymCryptXmssLtreeNodeCompress ( _In_ PSYMCRYPT_TREEHASH_NODE  pNodeLeft,
_In_ PSYMCRYPT_TREEHASH_NODE  pNodeRight,
_Out_ PSYMCRYPT_TREEHASH_NODE  pNodeOut,
_Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT  pCtxIncHash 
)

Definition at line 848 of file xmss.c.

853{
854 SYMCRYPT_STORE_MSBFIRST32(pCtxIncHash->adrs.u.ltree.en32Height, pNodeLeft->height);
855 SYMCRYPT_STORE_MSBFIRST32(pCtxIncHash->adrs.u.ltree.en32Index, pNodeLeft->index / 2);
856
857 SymCryptXmssRandHash(
858 pCtxIncHash->pParams,
859 &pCtxIncHash->adrs,
860 pCtxIncHash->pbSeed,
861 pNodeLeft->value,
862 pNodeRight->value,
863 pNodeOut->value);
864
865 pNodeOut->index = pNodeLeft->index / 2;
866 pNodeOut->height = pNodeLeft->height + 1;
867}
SymCryptXmssRandHash
VOID SYMCRYPT_CALL SymCryptXmssRandHash(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbLeft, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbRight, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:785

Referenced by SymCryptXmssCreateWotspPublickey(), and SymCryptXmssWotspPublickeyFromSignature().

◆ 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}

◆ SymCryptXmssParamsFromAlgIdCommon()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssParamsFromAlgIdCommon ( UINT32  id,
BOOLEAN  isMultiTree,
_Out_ PSYMCRYPT_XMSS_PARAMS  pParams 
)

Definition at line 291 of file xmss.c.

295{
296 SYMCRYPT_ERROR scError = SYMCRYPT_INVALID_ARGUMENT;
297 PCSYMCRYPT_XMSS_PARAMETER_PREDEFINED pParameters = NULL;
298 SIZE_T uParameterCount;
299
300 SymCryptWipeKnownSize(pParams, sizeof(*pParams));
301
302 if (isMultiTree)
303 {
304 pParameters = XmssMtParametersPredefined;
305 uParameterCount = SYMCRYPT_ARRAY_SIZE(XmssMtParametersPredefined);
306 }
307 else
308 {
309 pParameters = XmssParametersPredefined;
310 uParameterCount = SYMCRYPT_ARRAY_SIZE(XmssParametersPredefined);
311 }
312
313 for (UINT32 i = 0; i < uParameterCount; i++)
314 {
315 if (pParameters[i].idAlg == id)
316 {
317 scError = SymCryptXmssGetWotspParams(pParameters[i].idWotsp, pParams);
318
319 if (scError == SYMCRYPT_NO_ERROR)
320 {
321 SYMCRYPT_ASSERT(pParams->cbHashOutput <= SYMCRYPT_HASH_MAX_RESULT_SIZE);
322
323 pParams->id = id;
324 pParams->nTotalTreeHeight = pParameters[i].h;
325 pParams->nLayers = pParameters[i].d;
326 SymCryptXmssDeriveParams(pParams);
327 }
328
329 break;
330 }
331 }
332
333 return scError;
334}
id
GLuint id
Definition: glext.h:5910
_SYMCRYPT_XMSS_PARAMETER_PREDEFINED
Definition: xmss.c:71
_SYMCRYPT_XMSS_PARAMETER_PREDEFINED::d
UINT8 d
Definition: xmss.c:80
_SYMCRYPT_XMSS_PARAMETER_PREDEFINED::h
UINT8 h
Definition: xmss.c:77
XmssMtParametersPredefined
static const SYMCRYPT_XMSS_PARAMETER_PREDEFINED XmssMtParametersPredefined[]
Definition: xmss.c:115
SymCryptXmssDeriveParams
VOID SYMCRYPT_CALL SymCryptXmssDeriveParams(_Inout_ PSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:255
SymCryptXmssGetWotspParams
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptXmssGetWotspParams(SYMCRYPT_XMSS_WOTSP_ALGID id, _Out_ PSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:221
XmssParametersPredefined
static const SYMCRYPT_XMSS_PARAMETER_PREDEFINED XmssParametersPredefined[]
Definition: xmss.c:88

Referenced by SymCryptXmssMtParamsFromAlgId(), and SymCryptXmssParamsFromAlgId().

◆ SymCryptXmssPrf()

VOID SYMCRYPT_CALL SymCryptXmssPrf ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
BYTE  PrfType,
_In_reads_bytes_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_In_reads_bytes_(cbMsg) PCBYTE  pbMsg,
SIZE_T  cbMsg,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 765 of file xmss.c.

773{
774 SYMCRYPT_HASH_STATE state;
775
776 SymCryptXmssPrfInit(pParams->hash, PrfType, pParams->cbPrefix, &state);
777 SymCryptHashAppend(pParams->hash, &state, pbKey, cbKey);
778 SymCryptHashAppend(pParams->hash, &state, pbMsg, cbMsg);
779 SymCryptHashResult(pParams->hash, &state, pbOutput, pParams->cbHashOutput);
780}
pbKey
PCBYTE pbKey
Definition: symcrypt_internal.h:1987

Referenced by SymCryptXmssChain(), SymCryptXmssComputeRandomness(), and SymCryptXmssRandHash().

◆ SymCryptXmssPrfInit()

VOID SYMCRYPT_CALL SymCryptXmssPrfInit ( _In_ PCSYMCRYPT_HASH  hash,
BYTE  PrfType,
SIZE_T  prefixLength,
_Out_ PSYMCRYPT_HASH_STATE  state 
)

Definition at line 733 of file xmss.c.

738{
739 BYTE prefix[SYMCRYPT_XMSS_MAX_PREFIX_SIZE];
740
741 SYMCRYPT_ASSERT(prefixLength <= SYMCRYPT_XMSS_MAX_PREFIX_SIZE);
742
743 SymCryptWipe(prefix, prefixLength);
744 prefix[prefixLength - 1] = PrfType;
745
746 SymCryptHashInit(hash, state);
747 SymCryptHashAppend(hash, state, prefix, prefixLength);
748}
SymCryptHashInit
VOID SYMCRYPT_CALL SymCryptHashInit(_In_ PCSYMCRYPT_HASH pHash, _Out_writes_bytes_(pHash->stateSize) PVOID pState)
Definition: hash.c:173
prefix
Character const *const prefix
Definition: tempnam.cpp:195
SYMCRYPT_XMSS_MAX_PREFIX_SIZE
#define SYMCRYPT_XMSS_MAX_PREFIX_SIZE
Definition: xmss.c:15

Referenced by SymCryptXmssCreateWotspSecret(), SymCryptXmssPrf(), SymCryptXmssPrfKey(), and SymCryptXmssRandomizedHash().

◆ SymCryptXmssPrfKey()

VOID SYMCRYPT_CALL SymCryptXmssPrfKey ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_reads_bytes_(cbKey) PCBYTE  pbKey,
SIZE_T  cbKey,
_Out_ SYMCRYPT_HASH_STATE *  pState 
)

Definition at line 753 of file xmss.c.

758{
759 SymCryptXmssPrfInit(pParams->hash, SYMCRYPT_XMSS_PRF, pParams->cbPrefix, pState);
760 SymCryptHashAppend(pParams->hash, pState, pbKey, cbKey);
761}
pState
PSYMCRYPT_COMMON_HASH_STATE pState
Definition: symcrypt_internal.h:1278

Referenced by SymCryptXmssChain(), and SymCryptXmssRandHash().

◆ SymCryptXmssRandHash()

VOID SYMCRYPT_CALL SymCryptXmssRandHash ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_Inout_ XMSS_ADRS *  adrs,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbLeft,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbRight,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 785 of file xmss.c.

792{
793 BYTE key[SYMCRYPT_HASH_MAX_RESULT_SIZE];
794 BYTE bitmask[2 * SYMCRYPT_HASH_MAX_RESULT_SIZE];
795 SYMCRYPT_HASH_STATE stateKeyed;
796 SYMCRYPT_HASH_STATE stateMask;
797
798 SYMCRYPT_ASSERT(pParams->cbHashOutput <= SYMCRYPT_HASH_MAX_RESULT_SIZE);
799
800 SymCryptXmssPrfKey(pParams, pbSeed, pParams->cbHashOutput, &stateKeyed);
801
802 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 1);
803 SymCryptHashStateCopy(pParams->hash, &stateKeyed, &stateMask);
804 SymCryptHashAppend(pParams->hash, &stateMask, (PCBYTE)adrs, sizeof(*adrs));
805 SymCryptHashResult(pParams->hash, &stateMask, &bitmask[0], pParams->cbHashOutput);
806
807 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 2);
808 SymCryptHashStateCopy(pParams->hash, &stateKeyed, &stateMask);
809 SymCryptHashAppend(pParams->hash, &stateMask, (PCBYTE)adrs, sizeof(*adrs));
810 SymCryptHashResult(pParams->hash, &stateMask, &bitmask[pParams->cbHashOutput], pParams->cbHashOutput);
811
812 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 0);
813 SymCryptHashAppend(pParams->hash, &stateKeyed, (PCBYTE)adrs, sizeof(*adrs));
814 SymCryptHashResult(pParams->hash, &stateKeyed, key, pParams->cbHashOutput);
815
816 SymCryptXorBytes(&bitmask[0], pbLeft, &bitmask[0], pParams->cbHashOutput);
817 SymCryptXorBytes(&bitmask[pParams->cbHashOutput], pbRight, &bitmask[pParams->cbHashOutput], pParams->cbHashOutput);
818
819 SymCryptXmssPrf(pParams, SYMCRYPT_XMSS_H, key, pParams->cbHashOutput, bitmask, 2 * pParams->cbHashOutput, pbOutput);
820}
SYMCRYPT_XMSS_H
#define SYMCRYPT_XMSS_H
Definition: xmss.c:19

Referenced by SymCryptXmssLtreeNodeCompress(), SymCryptXmssTreeNodeCompress(), and SymCryptXmssTreeRootFromAuthenticationPath().

◆ 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 at line 1501 of file xmss.c.

1509{
1510 SYMCRYPT_HASH_STATE state;
1511 BYTE idxBuf[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1512
1513 SymCryptWipe(idxBuf, pParams->cbHashOutput);
1514 SYMCRYPT_STORE_MSBFIRST64(&idxBuf[pParams->cbHashOutput - sizeof(Idx)], Idx);
1515
1516 SymCryptXmssPrfInit(pParams->hash, SYMCRYPT_XMSS_H_MSG, pParams->cbPrefix, &state);
1517 SymCryptHashAppend(pParams->hash, &state, pbRandomizer, pParams->cbHashOutput);
1518 SymCryptHashAppend(pParams->hash, &state, pbRoot, pParams->cbHashOutput);
1519 SymCryptHashAppend(pParams->hash, &state, idxBuf, pParams->cbHashOutput);
1520 SymCryptHashAppend(pParams->hash, &state, pbMsg, cbMsg);
1521 SymCryptHashResult(pParams->hash, &state, pbOutput, pParams->cbHashOutput);
1522}
SYMCRYPT_XMSS_H_MSG
#define SYMCRYPT_XMSS_H_MSG
Definition: xmss.c:20

Referenced by SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssSetAdrsType()

VOID SYMCRYPT_CALL SymCryptXmssSetAdrsType ( _Out_ PXMSS_ADRS  adrs,
UINT32  type 
)

Definition at line 465 of file xmss.c.

468{
469 SYMCRYPT_STORE_MSBFIRST32(adrs->en32Type, type);
470 SymCryptWipeKnownSize(&adrs->u, sizeof(adrs->u));
471 SYMCRYPT_STORE_MSBFIRST32(adrs->en32KeyAndMask, 0);
472}
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

Referenced by SymCryptXmssComputeSubtreeRoot(), SymCryptXmssCreateWotspPublickey(), SymCryptXmssTreeRootFromAuthenticationPath(), SymCryptXmssWotspPublickeyFromSignature(), and SymCryptXmssWotspSign().

◆ 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}
cbHashOutput
UINT32 cbHashOutput
Definition: symcrypt_internal.h:3087
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

◆ 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::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
SymCryptXmssSizeofSignatureFromParams
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofSignatureFromParams(_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:477

◆ SymCryptXmssSignatureGetAuthNodes()

PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetAuthNodes ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_ PCBYTE  pbSig,
UINT32  uLayer 
)

Definition at line 1721 of file xmss.c.

1725{
1726 PBYTE pb = SymCryptXmssSignatureGetWotspSig(pParams, pbSig, uLayer);
1727
1728 // AuthNodes follow WOTSP signature
1729 pb += SymCryptXmssSizeofWotspSignature(pParams);
1730
1731 return pb;
1732}
SymCryptXmssSizeofWotspSignature
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofWotspSignature(_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:1655

Referenced by SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssSignatureGetIdx()

UINT64 SYMCRYPT_CALL SymCryptXmssSignatureGetIdx ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_ PCBYTE  pbSig 
)

Definition at line 1672 of file xmss.c.

1675{
1676 UINT64 Idx = 0;
1677
1678 for (UINT8 i = 0; i < pParams->cbIdx; i++)
1679 {
1680 Idx <<= 8;
1681 Idx |= (UINT64)pbSig[i];
1682 }
1683
1684 return Idx;
1685}

Referenced by SymCryptXmssVerifyInternal().

◆ SymCryptXmssSignatureGetRandomness()

PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetRandomness ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_ PCBYTE  pbSig 
)

Definition at line 1689 of file xmss.c.

1692{
1693 PBYTE pb = (PBYTE)pbSig;
1694
1695 // randomness comes after idx
1696 pb += pParams->cbIdx;
1697
1698 return pb;
1699}

Referenced by SymCryptXmssSign(), SymCryptXmssSignatureGetWotspSig(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssSignatureGetWotspSig()

PBYTE SYMCRYPT_CALL SymCryptXmssSignatureGetWotspSig ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_In_ PCBYTE  pbSig,
UINT32  uLayer 
)

Definition at line 1703 of file xmss.c.

1707{
1708 PBYTE pb = SymCryptXmssSignatureGetRandomness(pParams, pbSig);
1709
1710 // skip randomness
1711 pb += pParams->cbHashOutput;
1712
1713 // each layer contains WOTSP signature and AuthNodes
1714 pb += uLayer * (SymCryptXmssSizeofWotspSignature(pParams) + SymCryptXmssSizeofAuthNodes(pParams));
1715
1716 return pb;
1717}
SymCryptXmssSizeofAuthNodes
SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofAuthNodes(_In_ PCSYMCRYPT_XMSS_PARAMS pParams)
Definition: xmss.c:1663

Referenced by SymCryptXmssSign(), SymCryptXmssSignatureGetAuthNodes(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssSizeofAuthNodes()

SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofAuthNodes ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams)

Definition at line 1663 of file xmss.c.

1665{
1666 // size of authentication nodes for single tree
1667 return pParams->cbHashOutput * pParams->nLayerHeight;
1668}

Referenced by SymCryptXmssSignatureGetWotspSig().

◆ 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}
size
GLsizeiptr size
Definition: glext.h:5919

Referenced by SymCryptXmssSign(), and SymCryptXmssVerifyInternal().

◆ SymCryptXmssSizeofWotspSignature()

SIZE_T SYMCRYPT_CALL SymCryptXmssSizeofWotspSignature ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams)

Definition at line 1655 of file xmss.c.

1656{
1657 // WOTSP signature size is len = len1 + len2 many hash outputs
1658 return pParams->cbHashOutput * pParams->len;
1659}

Referenced by SymCryptXmssSignatureGetAuthNodes(), and SymCryptXmssSignatureGetWotspSig().

◆ SymCryptXmssTreeNodeCompress()

VOID SYMCRYPT_CALL SymCryptXmssTreeNodeCompress ( _In_ PSYMCRYPT_TREEHASH_NODE  pNodeLeft,
_In_ PSYMCRYPT_TREEHASH_NODE  pNodeRight,
_Out_ PSYMCRYPT_TREEHASH_NODE  pNodeOut,
_Inout_ PSYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT  pCtxIncHash 
)

Definition at line 825 of file xmss.c.

830{
831 SYMCRYPT_STORE_MSBFIRST32(pCtxIncHash->adrs.u.hashtree.en32Height, pNodeLeft->height);
832 SYMCRYPT_STORE_MSBFIRST32(pCtxIncHash->adrs.u.hashtree.en32Index, pNodeLeft->index / 2);
833
834 SymCryptXmssRandHash(
835 pCtxIncHash->pParams,
836 &pCtxIncHash->adrs,
837 pCtxIncHash->pbSeed,
838 pNodeLeft->value,
839 pNodeRight->value,
840 pNodeOut->value);
841
842 pNodeOut->index = pNodeLeft->index / 2;
843 pNodeOut->height = pNodeLeft->height + 1;
844}

Referenced by SymCryptXmssComputeSubtreeRoot().

◆ SymCryptXmssTreeRootFromAuthenticationPath()

VOID SYMCRYPT_CALL SymCryptXmssTreeRootFromAuthenticationPath ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_Inout_ XMSS_ADRS *  adrs,
UINT32  uLeaf,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbStartingNode,
_In_reads_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PCBYTE  pbAuthNodes,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 1454 of file xmss.c.

1466{
1467 BYTE node[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1468 BYTE tmp[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1469 UINT32 uNodeIndex = uLeaf;
1470
1471 memcpy(node, pbStartingNode, pParams->cbHashOutput);
1472
1473 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_HASH_TREE);
1474 SYMCRYPT_STORE_MSBFIRST32(adrs->u.hashtree.en32Index, uNodeIndex);
1475
1476 for (UINT32 i = 0; i < pParams->nLayerHeight; i++)
1477 {
1478 SYMCRYPT_STORE_MSBFIRST32(adrs->u.hashtree.en32Height, i);
1479
1480 if ( ((uLeaf >> i) & 1) == 0 )
1481 {
1482 uNodeIndex = uNodeIndex / 2;
1483 SYMCRYPT_STORE_MSBFIRST32(adrs->u.hashtree.en32Index, uNodeIndex);
1484 SymCryptXmssRandHash(pParams, adrs, pbSeed, node, &pbAuthNodes[pParams->cbHashOutput * i], tmp);
1485 }
1486 else
1487 {
1488 uNodeIndex = (uNodeIndex - 1) / 2;
1489 SYMCRYPT_STORE_MSBFIRST32(adrs->u.hashtree.en32Index, uNodeIndex);
1490 SymCryptXmssRandHash(pParams, adrs, pbSeed, &pbAuthNodes[pParams->cbHashOutput * i], node, tmp);
1491 }
1492
1493 memcpy(node, tmp, pParams->cbHashOutput);
1494 }
1495
1496 memcpy(pbOutput, node, pParams->cbHashOutput);
1497}
node
Definition: dlist.c:348

Referenced by SymCryptXmssTreeRootFromSignature(), and SymCryptXmssTreeSignHash().

◆ SymCryptXmssTreeRootFromSignature()

VOID SYMCRYPT_CALL SymCryptXmssTreeRootFromSignature ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_Inout_ XMSS_ADRS *  adrs,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbHash,
UINT32  uLeaf,
_In_reads_bytes_(pParams->cbHashOutput *pParams->len) PCBYTE  pbWotspSig,
_In_reads_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PCBYTE  pbAuthNodes,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput,
_Out_writes_bytes_opt_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch 
)

Definition at line 1612 of file xmss.c.

1629{
1630 BYTE WotspPublickey[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1631
1632 SymCryptXmssWotspPublickeyFromSignature(
1633 pParams,
1634 adrs,
1635 uLeaf,
1636 pbHash,
1637 pbSeed,
1638 pbWotspSig,
1639 pbScratch,
1640 cbScratch,
1641 WotspPublickey);
1642
1643 SymCryptXmssTreeRootFromAuthenticationPath(
1644 pParams,
1645 adrs,
1646 uLeaf,
1647 WotspPublickey,
1648 pbAuthNodes,
1649 pbSeed,
1650 pbOutput);
1651}
pbHash
static const BYTE pbHash[]
Definition: ssh_kdf_sha256.c:24
SymCryptXmssTreeRootFromAuthenticationPath
VOID SYMCRYPT_CALL SymCryptXmssTreeRootFromAuthenticationPath(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbStartingNode, _In_reads_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PCBYTE pbAuthNodes, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:1454
SymCryptXmssWotspPublickeyFromSignature
VOID SYMCRYPT_CALL SymCryptXmssWotspPublickeyFromSignature(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, UINT32 idx, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbMsg, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput *pParams->len) PCBYTE pbSignature, _Out_writes_bytes_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput)
Definition: xmss.c:1527

Referenced by SymCryptXmssVerifyInternal().

◆ 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 at line 1920 of file xmss.c.

1939{
1940 BYTE WotspPublicKey[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1941
1942 SymCryptXmssWotspSign(
1943 pParams,
1944 adrs,
1945 pbHash,
1946 Idx,
1947 pbSeed,
1948 pbSkXmss,
1949 pbWotspSig );
1950
1951 // Generate authentication path
1952 for (UINT32 h = 0; h < pParams->nLayerHeight; h++)
1953 {
1954 UINT32 uLeaf = ((Idx >> h) ^ 1UL) << h;
1955 SymCryptXmssComputeSubtreeRoot(
1956 pParams,
1957 adrs,
1958 pbSkXmss,
1959 pbSeed,
1960 uLeaf,
1961 h,
1962 pbScratch,
1963 cbScratch,
1964 &pbAuthNodes[h * pParams->cbHashOutput]);
1965 }
1966
1967 //
1968 // Calculate tree root if requested by the caller
1969 //
1970 // This is used to return the tree root to be signed with the upper
1971 // layer in XMSS^MT.
1972 if (pbRoot)
1973 {
1974 SymCryptXmssCreateWotspPublickey(
1975 pParams,
1976 adrs,
1977 Idx,
1978 pbSkXmss,
1979 pbSeed,
1980 pbScratch,
1981 cbScratch,
1982 WotspPublicKey);
1983
1984 SymCryptXmssTreeRootFromAuthenticationPath(
1985 pParams,
1986 adrs,
1987 Idx,
1988 WotspPublicKey,
1989 pbAuthNodes,
1990 pbSeed,
1991 pbRoot);
1992 }
1993}
SymCryptXmssWotspSign
VOID SYMCRYPT_CALL SymCryptXmssWotspSign(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbInput, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSkXmss, _Out_writes_bytes_(pParams->cbHashOutput *pParams->len) PBYTE pbOutput)
Definition: xmss.c:1858

Referenced by SymCryptXmssSign().

◆ 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}
SYMCRYPT_RUN_SELFTEST_ONCE
#define SYMCRYPT_RUN_SELFTEST_ONCE(AlgorithmSelftestFunction, AlgorithmSelftestFlag)
Definition: sc_lib.h:3686
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

◆ SymCryptXmssVerifyInternal()

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

Definition at line 1736 of file xmss.c.

1743{
1744 SYMCRYPT_ERROR scError = SYMCRYPT_NO_ERROR;
1745 PBYTE pbScratch = NULL;
1746 SIZE_T cbScratch = 0;
1747 PCSYMCRYPT_XMSS_PARAMS pParams = &pKey->params;
1748 BYTE RandomizedHash[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1749 BYTE ComputedRoot[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1750 XMSS_ADRS adrs;
1751 UINT32 uLayer;
1752 UINT64 uTree;
1753 UINT32 uLeaf;
1754 const UINT64 LeafMask = (1ULL << pParams->nLayerHeight) - 1;
1755
1756 SYMCRYPT_CHECK_MAGIC(pKey);
1757
1758 SYMCRYPT_ASSERT(pParams->nLayerHeight < 32); // Ensure nLeaves fits in 32 bits
1759
1760 if (flags != 0 ||
1761 pbSignature == NULL ||
1762 cbSignature != SymCryptXmssSizeofSignatureFromParams(pParams) ||
1763 pKey->keyType == SYMCRYPT_XMSSKEY_TYPE_NONE )
1764 {
1765 scError = SYMCRYPT_INVALID_ARGUMENT;
1766 goto cleanup;
1767 }
1768
1769 cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, pParams->len);
1770 cbScratch += SymCryptHbsSizeofScratchBytesForIncrementalTreehash(pParams->cbHashOutput, 1ULL << pParams->nLayerHeight);
1771
1772 pbScratch = (PBYTE)SymCryptCallbackAlloc(cbScratch);
1773
1774 if (pbScratch == NULL)
1775 {
1776 scError = SYMCRYPT_MEMORY_ALLOCATION_FAILURE;
1777 goto cleanup;
1778 }
1779
1780 PBYTE pbRandomness = SymCryptXmssSignatureGetRandomness(pParams, pbSignature);
1781 UINT64 Idx = SymCryptXmssSignatureGetIdx(pParams, pbSignature);
1782
1783 SymCryptXmssRandomizedHash(
1784 pParams,
1785 Idx,
1786 pbRandomness,
1787 pKey->Root,
1788 pbMessage,
1789 cbMessage,
1790 RandomizedHash);
1791
1792 SymCryptWipeKnownSize(&adrs, sizeof(XMSS_ADRS));
1793
1794 for (uLayer = 0; uLayer < pParams->nLayers; uLayer++)
1795 {
1796 uTree = Idx >> pParams->nLayerHeight;
1797 uLeaf = (UINT32)(Idx & LeafMask);
1798
1799 SYMCRYPT_STORE_MSBFIRST32(adrs.en32Layer, uLayer);
1800 SYMCRYPT_STORE_MSBFIRST64(adrs.en64Tree, uTree);
1801 SymCryptXmssTreeRootFromSignature(
1802 pParams,
1803 &adrs,
1804 pKey->Seed,
1805 uLayer == 0 ? RandomizedHash : ComputedRoot,
1806 uLeaf,
1807 SymCryptXmssSignatureGetWotspSig(pParams, pbSignature, uLayer),
1808 SymCryptXmssSignatureGetAuthNodes(pParams, pbSignature, uLayer),
1809 ComputedRoot,
1810 pbScratch,
1811 cbScratch);
1812
1813 Idx >>= pParams->nLayerHeight;
1814 }
1815
1816 if (!SymCryptEqual(ComputedRoot, pKey->Root, pParams->cbHashOutput))
1817 {
1818 scError = SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE;
1819 goto cleanup;
1820 }
1821
1822cleanup:
1823
1824 if (pbScratch)
1825 {
1826 SymCryptWipe(pbScratch, cbScratch);
1827 SymCryptCallbackFree(pbScratch);
1828 }
1829
1830 return scError;
1831}
PCSYMCRYPT_XMSS_PARAMS
const SYMCRYPT_XMSS_PARAMS * PCSYMCRYPT_XMSS_PARAMS
Definition: symcrypt_internal.h:3107
SymCryptXmssTreeRootFromSignature
VOID SYMCRYPT_CALL SymCryptXmssTreeRootFromSignature(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _Inout_ XMSS_ADRS *adrs, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbSeed, _In_reads_bytes_(pParams->cbHashOutput) PCBYTE pbHash, UINT32 uLeaf, _In_reads_bytes_(pParams->cbHashOutput *pParams->len) PCBYTE pbWotspSig, _In_reads_bytes_(pParams->cbHashOutput *pParams->nLayerHeight) PCBYTE pbAuthNodes, _Out_writes_bytes_(pParams->cbHashOutput) PBYTE pbOutput, _Out_writes_bytes_opt_(cbScratch) PBYTE pbScratch, SIZE_T cbScratch)
Definition: xmss.c:1612
SymCryptXmssSignatureGetIdx
UINT64 SYMCRYPT_CALL SymCryptXmssSignatureGetIdx(_In_ PCSYMCRYPT_XMSS_PARAMS pParams, _In_ PCBYTE pbSig)
Definition: xmss.c:1672

Referenced by SymCryptXmssVerify().

◆ SymCryptXmssWotspPublickeyFromSignature()

VOID SYMCRYPT_CALL SymCryptXmssWotspPublickeyFromSignature ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_Inout_ XMSS_ADRS *  adrs,
UINT32  idx,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbMsg,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_In_reads_bytes_(pParams->cbHashOutput *pParams->len) PCBYTE  pbSignature,
_Out_writes_bytes_(cbScratch) PBYTE  pbScratch,
SIZE_T  cbScratch,
_Out_writes_bytes_(pParams->cbHashOutput) PBYTE  pbOutput 
)

Definition at line 1527 of file xmss.c.

1542{
1543
1544 UINT32 digit;
1545 UINT32 checksum = 0;
1546 BYTE en32Checksum[4];
1547 const UINT32 maxChainIndex = (1 << pParams->nWinternitzWidth) - 1;
1548 PSYMCRYPT_INCREMENTAL_TREEHASH pIncHash = NULL;
1549 PSYMCRYPT_TREEHASH_NODE pNode = NULL;
1550 SYMCRYPT_XMSS_INCREMENTAL_TREEHASH_CONTEXT ctxIncHash;
1551
1552 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_LTREE);
1553 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ltree.en32Leaf, idx);
1554
1555 ctxIncHash.adrs = *adrs;
1556 ctxIncHash.pParams = pParams;
1557 ctxIncHash.pbSeed = pbSeed;
1558
1559 pIncHash = SymCryptHbsIncrementalTreehashInit(
1560 pParams->len,
1561 pbScratch,
1562 cbScratch,
1563 pParams->cbHashOutput,
1564 SymCryptXmssLtreeNodeCompress,
1565 &ctxIncHash);
1566
1567 for (UINT32 i = 0; i < pParams->len; i++)
1568 {
1569 if (i < pParams->len1)
1570 {
1571 digit = SymCryptHbsGetDigit(pParams->nWinternitzWidth, pbMsg, pParams->cbHashOutput, i);
1572
1573 checksum += maxChainIndex - digit;
1574 }
1575 else
1576 {
1577 if (i == pParams->len1)
1578 {
1579 checksum <<= pParams->nLeftShift32;
1580 SYMCRYPT_STORE_MSBFIRST32(en32Checksum, checksum);
1581 }
1582
1583 digit = SymCryptHbsGetDigit(pParams->nWinternitzWidth, en32Checksum, sizeof(en32Checksum), i - pParams->len1);
1584 }
1585
1586 pNode = SymCryptHbsIncrementalTreehashAllocNode(pIncHash, i);
1587
1588 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_OTS);
1589 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Leaf, idx);
1590 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Chain, i);
1591
1592 SymCryptXmssChain(
1593 pParams,
1594 &pbSignature[pParams->cbHashOutput * i],
1595 digit,
1596 maxChainIndex - digit,
1597 pbSeed,
1598 adrs,
1599 pNode->value);
1600
1601 SymCryptHbsIncrementalTreehashProcess(pIncHash);
1602 }
1603
1604 pNode = SymCryptHbsIncrementalTreehashFinalize(pIncHash);
1605
1606 memcpy(pbOutput, pNode->value, pParams->cbHashOutput);
1607}
idx
unsigned int idx
Definition: utils.c:40
checksum
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353
__crt_stdio_output::character_type::digit
@ digit
SymCryptHbsGetDigit
UINT32 SYMCRYPT_CALL SymCryptHbsGetDigit(UINT32 width, _In_ PCBYTE pbBuffer, SIZE_T cbBuffer, UINT32 index)
Definition: xmss.c:1429

Referenced by SymCryptXmssTreeRootFromSignature().

◆ SymCryptXmssWotspSign()

VOID SYMCRYPT_CALL SymCryptXmssWotspSign ( _In_ PCSYMCRYPT_XMSS_PARAMS  pParams,
_Inout_ XMSS_ADRS *  adrs,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbInput,
UINT32  uLeaf,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSeed,
_In_reads_bytes_(pParams->cbHashOutput) PCBYTE  pbSkXmss,
_Out_writes_bytes_(pParams->cbHashOutput *pParams->len) PBYTE  pbOutput 
)

Definition at line 1858 of file xmss.c.

1866{
1867 BYTE node[SYMCRYPT_HASH_MAX_RESULT_SIZE];
1868 UINT32 nChecksum = 0;
1869 BYTE en32Checksum[sizeof(UINT32)];
1870 UINT32 digit;
1871 const UINT32 maxChainIndex = (1UL << pParams->nWinternitzWidth) - 1;
1872
1873
1874 SymCryptXmssSetAdrsType(adrs, XMSS_ADRS_TYPE_OTS);
1875 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Leaf, uLeaf);
1876
1877 for (UINT32 i = 0; i < pParams->len; i++)
1878 {
1879 SYMCRYPT_STORE_MSBFIRST32(adrs->u.ots.en32Chain, i);
1880 SymCryptXmssCreateWotspSecret(
1881 pParams,
1882 pbSkXmss,
1883 pbSeed,
1884 adrs,
1885 node);
1886
1887 if (i < pParams->len1)
1888 {
1889 digit = SymCryptHbsGetDigit(pParams->nWinternitzWidth, pbInput, pParams->cbHashOutput, i);
1890
1891 nChecksum += maxChainIndex - digit;
1892 }
1893 else
1894 {
1895 if (i == pParams->len1)
1896 {
1897 nChecksum <<= pParams->nLeftShift32;
1898 SYMCRYPT_STORE_MSBFIRST32(en32Checksum, nChecksum);
1899 }
1900
1901 digit = SymCryptHbsGetDigit(pParams->nWinternitzWidth, en32Checksum, sizeof(en32Checksum), i - pParams->len1);
1902 }
1903
1904 SymCryptXmssChain(
1905 pParams,
1906 node,
1907 0,
1908 digit,
1909 pbSeed,
1910 adrs,
1911 &pbOutput[i * pParams->cbHashOutput]);
1912 }
1913
1914 SymCryptWipeKnownSize(node, sizeof(node));
1915}

Referenced by SymCryptXmssTreeSignHash().

Variable Documentation

◆ XmssHashArray

const PCSYMCRYPT_HASH* XmssHashArray[]
static
Initial value:
= {
&SymCryptSha256Algorithm,
&SymCryptSha512Algorithm,
&SymCryptShake128HashAlgorithm,
&SymCryptShake256HashAlgorithm,
}
SymCryptShake256HashAlgorithm
const PCSYMCRYPT_HASH SymCryptShake256HashAlgorithm
Definition: shake.c:93
SymCryptSha256Algorithm
const PCSYMCRYPT_HASH SymCryptSha256Algorithm
Definition: sha256.c:46
SymCryptShake128HashAlgorithm
const PCSYMCRYPT_HASH SymCryptShake128HashAlgorithm
Definition: shake.c:41
SymCryptSha512Algorithm
const PCSYMCRYPT_HASH SymCryptSha512Algorithm
Definition: sha512.c:170

Definition at line 25 of file xmss.c.

Referenced by SymCryptXmssGetWotspParams().

◆ XmssMtParametersPredefined

const SYMCRYPT_XMSS_PARAMETER_PREDEFINED XmssMtParametersPredefined[]
static

Definition at line 115 of file xmss.c.

Referenced by SymCryptXmssParamsFromAlgIdCommon().

◆ XmssParametersPredefined

const SYMCRYPT_XMSS_PARAMETER_PREDEFINED XmssParametersPredefined[]
static
Initial value:
= {
{ SYMCRYPT_XMSS_SHA2_10_256, SYMCRYPT_XMSS_WOTSP_SHA2_256, 10, 1 },
{ SYMCRYPT_XMSS_SHA2_16_256, SYMCRYPT_XMSS_WOTSP_SHA2_256, 16, 1 },
{ SYMCRYPT_XMSS_SHA2_20_256, SYMCRYPT_XMSS_WOTSP_SHA2_256, 20, 1 },
{ SYMCRYPT_XMSS_SHA2_10_512, SYMCRYPT_XMSS_WOTSP_SHA2_512, 10, 1 },
{ SYMCRYPT_XMSS_SHA2_16_512, SYMCRYPT_XMSS_WOTSP_SHA2_512, 16, 1 },
{ SYMCRYPT_XMSS_SHA2_20_512, SYMCRYPT_XMSS_WOTSP_SHA2_512, 20, 1 },
{ SYMCRYPT_XMSS_SHAKE_10_256, SYMCRYPT_XMSS_WOTSP_SHAKE_256, 10, 1 },
{ SYMCRYPT_XMSS_SHAKE_16_256, SYMCRYPT_XMSS_WOTSP_SHAKE_256, 16, 1 },
{ SYMCRYPT_XMSS_SHAKE_20_256, SYMCRYPT_XMSS_WOTSP_SHAKE_256, 20, 1 },
{ SYMCRYPT_XMSS_SHAKE_10_512, SYMCRYPT_XMSS_WOTSP_SHAKE_512, 10, 1 },
{ SYMCRYPT_XMSS_SHAKE_16_512, SYMCRYPT_XMSS_WOTSP_SHAKE_512, 16, 1 },
{ SYMCRYPT_XMSS_SHAKE_20_512, SYMCRYPT_XMSS_WOTSP_SHAKE_512, 20, 1 },
{ SYMCRYPT_XMSS_SHA2_10_192, SYMCRYPT_XMSS_WOTSP_SHA2_192, 10, 1 },
{ SYMCRYPT_XMSS_SHA2_16_192, SYMCRYPT_XMSS_WOTSP_SHA2_192, 16, 1 },
{ SYMCRYPT_XMSS_SHA2_20_192, SYMCRYPT_XMSS_WOTSP_SHA2_192, 20, 1 },
{ SYMCRYPT_XMSS_SHAKE256_10_256, SYMCRYPT_XMSS_WOTSP_SHAKE256_256, 10, 1 },
{ SYMCRYPT_XMSS_SHAKE256_16_256, SYMCRYPT_XMSS_WOTSP_SHAKE256_256, 16, 1 },
{ SYMCRYPT_XMSS_SHAKE256_20_256, SYMCRYPT_XMSS_WOTSP_SHAKE256_256, 20, 1 },
{ SYMCRYPT_XMSS_SHAKE256_10_192, SYMCRYPT_XMSS_WOTSP_SHAKE256_192, 10, 1 },
{ SYMCRYPT_XMSS_SHAKE256_16_192, SYMCRYPT_XMSS_WOTSP_SHAKE256_192, 16, 1 },
{ SYMCRYPT_XMSS_SHAKE256_20_192, SYMCRYPT_XMSS_WOTSP_SHAKE256_192, 20, 1 },
}
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

Definition at line 88 of file xmss.c.

Referenced by SymCryptXmssParamsFromAlgIdCommon().

◆ XmssWotspParams

const SYMCRYPT_XMSS_WOTSP_PARAMS XmssWotspParams[]
static
Initial value:
=
{
{ SYMCRYPT_XMSS_WOTSP_SHA2_256, 0, 32, 4, 32 },
{ SYMCRYPT_XMSS_WOTSP_SHA2_512, 1, 64, 4, 64 },
{ SYMCRYPT_XMSS_WOTSP_SHAKE_256, 2, 32, 4, 32 },
{ SYMCRYPT_XMSS_WOTSP_SHAKE_512, 3, 64, 4, 64 },
{ SYMCRYPT_XMSS_WOTSP_SHA2_192, 0, 24, 4, 4 },
{ SYMCRYPT_XMSS_WOTSP_SHAKE256_256, 3, 32, 4, 32 },
{ SYMCRYPT_XMSS_WOTSP_SHAKE256_192, 3, 24, 4, 4 },
}

Definition at line 58 of file xmss.c.

Referenced by SymCryptXmssGetWotspParams().