1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
|
/** @file
SLH-DSA API implementation based on OpenSSL
Copyright (c) 2026, Intel Corporation. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <Library/BaseCryptLib.h>
#include <Library/DebugLib.h>
/**
Creates a new SLH-DSA context by Crypto NID.
This function allocates and initializes a new SLH-DSA context for the specified
SLH-DSA variant. The context is created with no key material; the EVP_PKEY
structure is set to NULL. The caller must call SlhDsaFree() to release the
context when done.
Before keys can be used for signing or verification, they must be set using
SlhDsaSetPrivKey() or SlhDsaSetPubKey().
If Nid is not a supported SLH-DSA variant, then return NULL.
If memory allocation fails, then return NULL.
@param[in] Nid Crypto NID of the SLH-DSA variant (e.g., CRYPTO_NID_SLH_DSA_SHAKE_256S).
@retval Pointer to new SLH-DSA context if successful.
@retval NULL if Nid is unsupported or allocation failed.
**/
VOID *
EFIAPI
SlhDsaNewByNid (
IN UINTN Nid
)
{
ASSERT (FALSE);
return NULL;
}
/**
Frees an SLH-DSA context and all associated resources.
This function releases all memory associated with the SLH-DSA context, including
the EVP_PKEY structure. After calling this function, the SlhDsaContext pointer
should not be used.
If SlhDsaContext is NULL, then this function returns immediately without action.
@param[in] SlhDsaContext Pointer to the SLH-DSA context to be released.
**/
VOID
EFIAPI
SlhDsaFree (
IN VOID *SlhDsaContext
)
{
ASSERT (FALSE);
}
/**
Retrieves the SLH-DSA public key from the SLH-DSA context.
This function extracts the public key from the SLH-DSA context and copies it to
the provided buffer. The public key is returned in raw binary format.
The context must have a key set (either via SlhDsaSetPrivKey() or SlhDsaSetPubKey())
before calling this function.
If SlhDsaContext is NULL, then return FALSE.
If PublicKeySize is NULL, then return FALSE.
If the context does not contain a valid key, then return FALSE.
If PublicKey buffer is too small, PublicKeySize is updated with required size and return FALSE.
@param[in] SlhDsaContext Pointer to SLH-DSA context containing the key.
@param[out] PublicKey Pointer to buffer to receive the public key.
@param[in,out] PublicKeySize On input, size of PublicKey buffer in bytes.
On output, actual size of public key written.
@retval TRUE SLH-DSA public key retrieved successfully.
@retval FALSE Invalid parameters or buffer too small.
**/
BOOLEAN
EFIAPI
SlhDsaGetPubKey (
IN VOID *SlhDsaContext,
OUT UINT8 *PublicKey,
IN OUT UINTN *PublicKeySize
)
{
ASSERT (FALSE);
return FALSE;
}
/**
Sets the SLH-DSA public key in the SLH-DSA context.
This function imports a raw public key into the SLH-DSA context. The public key
must be in raw binary format (not PEM or DER encoded). The key size must match
the expected size for the SLH-DSA variant (64 bytes for SLH-DSA-SHAKE-256s).
After setting the public key, the context can be used for signature verification
but not for signing (which requires the private key).
If SlhDsaContext is NULL, then return FALSE.
If PublicKey is NULL, then return FALSE.
If PublicKeySize does not match the expected size for the variant, then return FALSE.
@param[in] SlhDsaContext Pointer to SLH-DSA context created by SlhDsaNewByNid().
@param[in] PublicKey Pointer to raw public key bytes.
@param[in] PublicKeySize Size of the public key in bytes.
@retval TRUE SLH-DSA public key was set successfully.
@retval FALSE Invalid parameters or key size mismatch.
**/
BOOLEAN
EFIAPI
SlhDsaSetPubKey (
IN VOID *SlhDsaContext,
IN UINT8 *PublicKey,
IN UINTN PublicKeySize
)
{
ASSERT (FALSE);
return FALSE;
}
/**
Sets the SLH-DSA private key in the SLH-DSA context.
This function imports a raw private key into the SLH-DSA context. The private key
must be in raw binary format (not PEM or DER encoded). The key size must match
the expected size for the SLH-DSA variant (128 bytes for SLH-DSA-SHAKE-256s).
OpenSSL automatically derives the public key from the private key, so after
calling this function, both signing and verification operations are possible.
If SlhDsaContext is NULL, then return FALSE.
If PrivateKey is NULL, then return FALSE.
If PrivateKeySize does not match the expected size for the variant, then return FALSE.
@param[in] SlhDsaContext Pointer to SLH-DSA context created by SlhDsaNewByNid().
@param[in] PrivateKey Pointer to raw private key bytes.
@param[in] PrivateKeySize Size of the private key in bytes.
@retval TRUE SLH-DSA private key was set successfully.
@retval FALSE Invalid parameters or key size mismatch.
**/
BOOLEAN
EFIAPI
SlhDsaSetPrivKey (
IN VOID *SlhDsaContext,
IN UINT8 *PrivateKey,
IN UINTN PrivateKeySize
)
{
ASSERT (FALSE);
return FALSE;
}
/**
Generates and retrieves the public key from a private key context.
This function extracts the public key from an SLH-DSA context that contains
a private key. It is equivalent to calling SlhDsaGetPubKey() but is provided
for API consistency with other cryptographic implementations.
The context must contain a private key (set via SlhDsaSetPrivKey()) before
calling this function.
If SlhDsaContext is NULL, then return FALSE.
If PublicKey is NULL, then return FALSE.
If PublicKeySize does not match the expected size for the variant, then return FALSE.
@param[in] SlhDsaContext Pointer to SLH-DSA context containing the private key.
@param[out] PublicKey Pointer to buffer to receive the public key.
@param[in] PublicKeySize Size of the PublicKey buffer in bytes.
@retval TRUE Public key generated and retrieved successfully.
@retval FALSE Invalid parameters or public key extraction failed.
**/
BOOLEAN
EFIAPI
SlhDsaGeneratePubKey (
IN VOID *SlhDsaContext,
OUT UINT8 *PublicKey,
IN UINTN PublicKeySize
)
{
ASSERT (FALSE);
return FALSE;
}
/**
Generates an SLH-DSA signature for a given message.
This function creates an SLH-DSA signature using the private key stored in the
SLH-DSA context. SLH-DSA signatures can include an optional context string for
domain separation, allowing the same key to be used in different contexts
without creating security vulnerabilities.
The context must contain a private key (set via SlhDsaSetPrivKey()) before
calling this function.
If SlhDsaContext is NULL, then return FALSE.
If Message is NULL, then return FALSE.
If Signature is NULL, then return FALSE.
If SigSize is NULL, then return FALSE.
If SigSize buffer is too small, SigSize is updated with required size and return FALSE.
Context may be NULL if no context string is used (ContextSize must be 0).
@param[in] SlhDsaContext Pointer to SLH-DSA context containing the private key.
@param[in] Context Optional context string for domain separation.
May be NULL for default context.
@param[in] ContextSize Size of context string in bytes. Set to 0 if Context is NULL.
@param[in] Message Pointer to message data to be signed.
@param[in] MessageSize Size of message in bytes.
@param[out] Signature Pointer to buffer to receive the signature.
@param[in,out] SigSize On input, size of Signature buffer.
On output, actual size of signature (29792 bytes for SLH-DSA-SHAKE-256s).
@retval TRUE SLH-DSA signature generated successfully.
@retval FALSE Invalid parameters or signature generation failed.
**/
BOOLEAN
EFIAPI
SlhDsaSign (
IN VOID *SlhDsaContext,
IN UINT8 *Context,
IN UINTN ContextSize,
IN CONST UINT8 *Message,
IN UINTN MessageSize,
OUT UINT8 *Signature,
IN OUT UINTN *SigSize
)
{
ASSERT (FALSE);
return FALSE;
}
/**
Verifies the SLH-DSA signature for a given message.
This function verifies an SLH-DSA signature against a message using the public key
contained in the SLH-DSA context. An optional context string can be provided which
must match the context used during signing.
The context must contain a key (either public or private) set via SlhDsaSetPrivKey()
or SlhDsaSetPubKey() before calling this function.
If SlhDsaContext is NULL, then return FALSE.
If Message is NULL, then return FALSE.
If Signature is NULL, then return FALSE.
If SigSize is 0 or exceeds INT_MAX, then return FALSE.
Context may be NULL if no context string is used.
@param[in] SlhDsaContext Pointer to SLH-DSA context containing the public key.
@param[in] Context Optional context string for domain separation.
May be NULL for default context.
@param[in] ContextSize Size of context string in bytes. Set to 0 if Context is NULL.
@param[in] Message Pointer to the message data to verify.
@param[in] MessageSize Size of the message in bytes.
@param[in] Signature Pointer to the SLH-DSA signature to verify.
@param[in] SigSize Size of the signature in bytes.
@retval TRUE SLH-DSA signature verification succeeded.
@retval FALSE SLH-DSA signature verification failed or invalid parameters.
**/
BOOLEAN
EFIAPI
SlhDsaVerify (
IN VOID *SlhDsaContext,
IN UINT8 *Context,
IN UINTN ContextSize,
IN CONST UINT8 *Message,
IN UINTN MessageSize,
IN UINT8 *Signature,
IN UINTN SigSize
)
{
ASSERT (FALSE);
return FALSE;
}
|
