Branch data Line data Source code
1 : : /**
2 : : * Copyright Notice:
3 : : * Copyright 2025-2026 DMTF. All rights reserved.
4 : : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : : **/
6 : :
7 : : #include "internal/libspdm_crypt_lib.h"
8 : : #include "library/spdm_common_lib.h"
9 : :
10 : 41 : uint32_t libspdm_get_pqc_asym_signature_size(uint32_t pqc_asym_algo)
11 : : {
12 [ - - - - : 41 : switch (pqc_asym_algo) {
- - - - -
- - - - -
- + ]
13 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44:
14 : : #if LIBSPDM_ML_DSA_44_SUPPORT
15 : : return 2420;
16 : : #else
17 : 0 : return 0;
18 : : #endif
19 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65:
20 : : #if LIBSPDM_ML_DSA_65_SUPPORT
21 : : return 3309;
22 : : #else
23 : 0 : return 0;
24 : : #endif
25 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87:
26 : : #if LIBSPDM_ML_DSA_87_SUPPORT
27 : : return 4627;
28 : : #else
29 : 0 : return 0;
30 : : #endif
31 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S:
32 : : #if LIBSPDM_SLH_DSA_SHA2_128S_SUPPORT
33 : : return 7856;
34 : : #else
35 : 0 : return 0;
36 : : #endif
37 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S:
38 : : #if LIBSPDM_SLH_DSA_SHAKE_128S_SUPPORT
39 : : return 7856;
40 : : #else
41 : 0 : return 0;
42 : : #endif
43 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F:
44 : : #if LIBSPDM_SLH_DSA_SHA2_128F_SUPPORT
45 : : return 17088;
46 : : #else
47 : 0 : return 0;
48 : : #endif
49 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F:
50 : : #if LIBSPDM_SLH_DSA_SHAKE_128F_SUPPORT
51 : : return 17088;
52 : : #else
53 : 0 : return 0;
54 : : #endif
55 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S:
56 : : #if LIBSPDM_SLH_DSA_SHA2_192S_SUPPORT
57 : : return 16224;
58 : : #else
59 : 0 : return 0;
60 : : #endif
61 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S:
62 : : #if LIBSPDM_SLH_DSA_SHAKE_192S_SUPPORT
63 : : return 16224;
64 : : #else
65 : 0 : return 0;
66 : : #endif
67 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F:
68 : : #if LIBSPDM_SLH_DSA_SHA2_192F_SUPPORT
69 : : return 35664;
70 : : #else
71 : 0 : return 0;
72 : : #endif
73 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F:
74 : : #if LIBSPDM_SLH_DSA_SHAKE_192F_SUPPORT
75 : : return 35664;
76 : : #else
77 : 0 : return 0;
78 : : #endif
79 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S:
80 : : #if LIBSPDM_SLH_DSA_SHA2_256S_SUPPORT
81 : : return 29792;
82 : : #else
83 : 0 : return 0;
84 : : #endif
85 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S:
86 : : #if LIBSPDM_SLH_DSA_SHAKE_256S_SUPPORT
87 : : return 29792;
88 : : #else
89 : 0 : return 0;
90 : : #endif
91 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F:
92 : : #if LIBSPDM_SLH_DSA_SHA2_256F_SUPPORT
93 : : return 49856;
94 : : #else
95 : 0 : return 0;
96 : : #endif
97 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F:
98 : : #if LIBSPDM_SLH_DSA_SHAKE_256F_SUPPORT
99 : : return 49856;
100 : : #else
101 : 0 : return 0;
102 : : #endif
103 : 41 : default:
104 : 41 : return 0;
105 : : }
106 : : }
107 : :
108 : : #if LIBSPDM_CERT_PARSE_SUPPORT
109 : 0 : bool libspdm_pqc_asym_get_public_key_from_x509(uint32_t pqc_asym_algo,
110 : : const uint8_t *cert,
111 : : size_t cert_size,
112 : : void **context)
113 : : {
114 [ # # # ]: 0 : switch (pqc_asym_algo) {
115 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44:
116 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65:
117 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87:
118 : : #if LIBSPDM_ML_DSA_SUPPORT
119 : : return libspdm_mldsa_get_public_key_from_x509(cert, cert_size, context);
120 : : #else
121 : 0 : LIBSPDM_ASSERT(false);
122 : 0 : return false;
123 : : #endif
124 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S:
125 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S:
126 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F:
127 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F:
128 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S:
129 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S:
130 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F:
131 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F:
132 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S:
133 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S:
134 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F:
135 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F:
136 : : #if LIBSPDM_SLH_DSA_SUPPORT
137 : : return libspdm_slhdsa_get_public_key_from_x509(cert, cert_size, context);
138 : : #else
139 : 0 : LIBSPDM_ASSERT(false);
140 : 0 : return false;
141 : : #endif
142 : 0 : default:
143 : 0 : LIBSPDM_ASSERT(false);
144 : 0 : return false;
145 : : }
146 : : }
147 : : #endif /* LIBSPDM_CERT_PARSE_SUPPORT */
148 : :
149 : 0 : bool libspdm_pqc_asym_get_public_key_from_der(uint32_t pqc_asym_algo,
150 : : const uint8_t *der_data,
151 : : size_t der_size,
152 : : void **context)
153 : : {
154 [ # # # ]: 0 : switch (pqc_asym_algo) {
155 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44:
156 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65:
157 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87:
158 : : #if LIBSPDM_ML_DSA_SUPPORT
159 : : return libspdm_mldsa_get_public_key_from_der(der_data, der_size, context);
160 : : #else
161 : 0 : LIBSPDM_ASSERT(false);
162 : 0 : return false;
163 : : #endif
164 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S:
165 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S:
166 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F:
167 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F:
168 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S:
169 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S:
170 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F:
171 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F:
172 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S:
173 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S:
174 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F:
175 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F:
176 : : #if LIBSPDM_SLH_DSA_SUPPORT
177 : : return libspdm_slhdsa_get_public_key_from_der(der_data, der_size, context);
178 : : #else
179 : 0 : LIBSPDM_ASSERT(false);
180 : 0 : return false;
181 : : #endif
182 : 0 : default:
183 : 0 : LIBSPDM_ASSERT(false);
184 : 0 : return false;
185 : : }
186 : : }
187 : :
188 : 0 : void libspdm_pqc_asym_free(uint32_t pqc_asym_algo, void *context)
189 : : {
190 [ # # ]: 0 : if (context == NULL) {
191 : 0 : return;
192 : : }
193 [ # # # ]: 0 : switch (pqc_asym_algo) {
194 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44:
195 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65:
196 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87:
197 : : #if LIBSPDM_ML_DSA_SUPPORT
198 : : libspdm_mldsa_free(context);
199 : : #else
200 : 0 : LIBSPDM_ASSERT(false);
201 : : #endif
202 : 0 : break;
203 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S:
204 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S:
205 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F:
206 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F:
207 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S:
208 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S:
209 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F:
210 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F:
211 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S:
212 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S:
213 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F:
214 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F:
215 : : #if LIBSPDM_SLH_DSA_SUPPORT
216 : : libspdm_slhdsa_free(context);
217 : : #else
218 : 0 : LIBSPDM_ASSERT(false);
219 : : #endif
220 : 0 : break;
221 : 0 : default:
222 : 0 : LIBSPDM_ASSERT(false);
223 : 0 : break;
224 : : }
225 : 0 : return;
226 : : }
227 : :
228 : 0 : static bool libspdm_pqc_asym_sign_wrap (
229 : : void *context, uint32_t pqc_asym_algo,
230 : : const uint8_t *param, size_t param_size,
231 : : const uint8_t *message, size_t message_size,
232 : : uint8_t *signature, size_t *sig_size)
233 : : {
234 [ # # # ]: 0 : switch (pqc_asym_algo) {
235 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44:
236 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65:
237 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87:
238 : : #if LIBSPDM_ML_DSA_SUPPORT
239 : : return libspdm_mldsa_sign(context,
240 : : param, param_size,
241 : : message, message_size,
242 : : signature, sig_size);
243 : : #else
244 : 0 : LIBSPDM_ASSERT(false);
245 : 0 : return false;
246 : : #endif
247 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S:
248 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S:
249 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F:
250 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F:
251 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S:
252 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S:
253 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F:
254 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F:
255 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S:
256 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S:
257 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F:
258 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F:
259 : : #if LIBSPDM_SLH_DSA_SUPPORT
260 : : return libspdm_slhdsa_sign(context,
261 : : param, param_size,
262 : : message, message_size,
263 : : signature, sig_size);
264 : : #else
265 : 0 : LIBSPDM_ASSERT(false);
266 : 0 : return false;
267 : : #endif
268 : 0 : default:
269 : 0 : LIBSPDM_ASSERT(false);
270 : 0 : return false;
271 : : }
272 : : }
273 : :
274 : 0 : static bool libspdm_pqc_asym_verify_wrap(
275 : : void *context, uint32_t pqc_asym_algo,
276 : : const uint8_t *param, size_t param_size,
277 : : const uint8_t *message, size_t message_size,
278 : : const uint8_t *signature, size_t sig_size)
279 : : {
280 [ # # # ]: 0 : switch (pqc_asym_algo) {
281 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44:
282 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65:
283 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87:
284 : : #if LIBSPDM_ML_DSA_SUPPORT
285 : : return libspdm_mldsa_verify(context,
286 : : param, param_size,
287 : : message, message_size,
288 : : signature, sig_size);
289 : : #else
290 : 0 : LIBSPDM_ASSERT(false);
291 : 0 : return false;
292 : : #endif
293 : 0 : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S:
294 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S:
295 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F:
296 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F:
297 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S:
298 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S:
299 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F:
300 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F:
301 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S:
302 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S:
303 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F:
304 : : case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F:
305 : : #if LIBSPDM_SLH_DSA_SUPPORT
306 : : return libspdm_slhdsa_verify(context,
307 : : param, param_size,
308 : : message, message_size,
309 : : signature, sig_size);
310 : : #else
311 : 0 : LIBSPDM_ASSERT(false);
312 : 0 : return false;
313 : : #endif
314 : 0 : default:
315 : 0 : LIBSPDM_ASSERT(false);
316 : 0 : return false;
317 : : }
318 : : }
319 : :
320 : 0 : bool libspdm_pqc_asym_verify(
321 : : spdm_version_number_t spdm_version, uint8_t op_code,
322 : : uint32_t pqc_asym_algo, uint32_t base_hash_algo,
323 : : void *context,
324 : : const uint8_t *message, size_t message_size,
325 : : const uint8_t *signature, size_t sig_size)
326 : : {
327 : : size_t hash_size;
328 : : bool result;
329 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
330 : : LIBSPDM_MAX_HASH_SIZE];
331 : : const void *param;
332 : : size_t param_size;
333 : :
334 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, false, ¶m_size);
335 : :
336 : 0 : libspdm_create_signing_context (spdm_version, op_code, false,
337 : : spdm12_signing_context_with_hash);
338 : 0 : hash_size = libspdm_get_hash_size(base_hash_algo);
339 : 0 : result = libspdm_hash_all(base_hash_algo, message, message_size,
340 : : &spdm12_signing_context_with_hash[
341 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE]);
342 [ # # ]: 0 : if (!result) {
343 : 0 : return false;
344 : : }
345 : :
346 : : /* re-assign message and message_size for signing */
347 : 0 : message = spdm12_signing_context_with_hash;
348 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
349 : :
350 : 0 : result = libspdm_pqc_asym_verify_wrap(context, pqc_asym_algo,
351 : : param, param_size,
352 : : message, message_size,
353 : : signature, sig_size);
354 : 0 : return result;
355 : : }
356 : :
357 : 0 : bool libspdm_pqc_asym_verify_hash(
358 : : spdm_version_number_t spdm_version, uint8_t op_code,
359 : : uint32_t pqc_asym_algo, uint32_t base_hash_algo, void *context,
360 : : const uint8_t *message_hash, size_t hash_size,
361 : : const uint8_t *signature, size_t sig_size)
362 : : {
363 : : uint8_t *message;
364 : : size_t message_size;
365 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
366 : : LIBSPDM_MAX_HASH_SIZE];
367 : : const void *param;
368 : : size_t param_size;
369 : :
370 [ # # ]: 0 : LIBSPDM_ASSERT (hash_size == libspdm_get_hash_size(base_hash_algo));
371 : :
372 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, false, ¶m_size);
373 : :
374 : 0 : libspdm_create_signing_context (spdm_version, op_code, false,
375 : : spdm12_signing_context_with_hash);
376 : 0 : libspdm_copy_mem(&spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE],
377 : : sizeof(spdm12_signing_context_with_hash) -
378 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE,
379 : : message_hash, hash_size);
380 : :
381 : : /* assign message and message_size for signing */
382 : 0 : message = spdm12_signing_context_with_hash;
383 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
384 : :
385 : 0 : return libspdm_pqc_asym_verify_wrap(context, pqc_asym_algo,
386 : : param, param_size,
387 : : message, message_size,
388 : : signature, sig_size);
389 : : }
390 : :
391 : 0 : bool libspdm_pqc_asym_sign(
392 : : spdm_version_number_t spdm_version, uint8_t op_code,
393 : : uint32_t pqc_asym_algo, uint32_t base_hash_algo,
394 : : void *context, const uint8_t *message,
395 : : size_t message_size, uint8_t *signature,
396 : : size_t *sig_size)
397 : : {
398 : : size_t hash_size;
399 : : bool result;
400 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
401 : : LIBSPDM_MAX_HASH_SIZE];
402 : : const void *param;
403 : : size_t param_size;
404 : :
405 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, false, ¶m_size);
406 : :
407 : 0 : libspdm_create_signing_context (spdm_version, op_code, false,
408 : : spdm12_signing_context_with_hash);
409 : 0 : hash_size = libspdm_get_hash_size(base_hash_algo);
410 : 0 : result = libspdm_hash_all(base_hash_algo, message, message_size,
411 : : &spdm12_signing_context_with_hash[
412 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE]);
413 [ # # ]: 0 : if (!result) {
414 : 0 : return false;
415 : : }
416 : :
417 : : /* re-assign message and message_size for signing */
418 : 0 : message = spdm12_signing_context_with_hash;
419 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
420 : :
421 : 0 : return libspdm_pqc_asym_sign_wrap(context, pqc_asym_algo,
422 : : param, param_size,
423 : : message, message_size,
424 : : signature, sig_size);
425 : : }
426 : :
427 : 0 : bool libspdm_pqc_asym_sign_hash(
428 : : spdm_version_number_t spdm_version, uint8_t op_code,
429 : : uint32_t pqc_asym_algo, uint32_t base_hash_algo,
430 : : void *context, const uint8_t *message_hash,
431 : : size_t hash_size, uint8_t *signature,
432 : : size_t *sig_size)
433 : : {
434 : : uint8_t *message;
435 : : size_t message_size;
436 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
437 : : LIBSPDM_MAX_HASH_SIZE];
438 : : const void *param;
439 : : size_t param_size;
440 : :
441 [ # # ]: 0 : LIBSPDM_ASSERT (hash_size == libspdm_get_hash_size(base_hash_algo));
442 : :
443 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, false, ¶m_size);
444 : :
445 : 0 : libspdm_create_signing_context (spdm_version, op_code, false,
446 : : spdm12_signing_context_with_hash);
447 : 0 : libspdm_copy_mem(&spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE],
448 : : sizeof(spdm12_signing_context_with_hash) -
449 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE,
450 : : message_hash, hash_size);
451 : :
452 : : /* assign message and message_size for signing */
453 : 0 : message = spdm12_signing_context_with_hash;
454 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
455 : :
456 : 0 : return libspdm_pqc_asym_sign_wrap(context, pqc_asym_algo,
457 : : param, param_size,
458 : : message, message_size,
459 : : signature, sig_size);
460 : :
461 : : }
462 : :
463 : 17 : uint32_t libspdm_get_req_pqc_asym_signature_size(uint32_t req_pqc_asym_alg)
464 : : {
465 : 17 : return libspdm_get_pqc_asym_signature_size(req_pqc_asym_alg);
466 : : }
467 : :
468 : : #if LIBSPDM_CERT_PARSE_SUPPORT
469 : 0 : bool libspdm_req_pqc_asym_get_public_key_from_x509(uint32_t pqc_asym_algo,
470 : : const uint8_t *cert,
471 : : size_t cert_size,
472 : : void **context)
473 : : {
474 : 0 : return libspdm_pqc_asym_get_public_key_from_x509(
475 : : pqc_asym_algo, cert, cert_size, context);
476 : : }
477 : : #endif /* LIBSPDM_CERT_PARSE_SUPPORT */
478 : :
479 : 0 : bool libspdm_req_pqc_asym_get_public_key_from_der(uint32_t req_pqc_asym_alg,
480 : : const uint8_t *der_data,
481 : : size_t der_size,
482 : : void **context)
483 : : {
484 : 0 : return libspdm_pqc_asym_get_public_key_from_der(
485 : : req_pqc_asym_alg, der_data, der_size, context);
486 : : }
487 : :
488 : 0 : void libspdm_req_pqc_asym_free(uint32_t req_pqc_asym_alg, void *context)
489 : : {
490 : 0 : libspdm_pqc_asym_free(req_pqc_asym_alg, context);
491 : 0 : }
492 : :
493 : 0 : bool libspdm_req_pqc_asym_verify(
494 : : spdm_version_number_t spdm_version, uint8_t op_code,
495 : : uint32_t req_pqc_asym_alg,
496 : : uint32_t base_hash_algo, void *context,
497 : : const uint8_t *message, size_t message_size,
498 : : const uint8_t *signature, size_t sig_size)
499 : : {
500 : : size_t hash_size;
501 : : bool result;
502 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
503 : : LIBSPDM_MAX_HASH_SIZE];
504 : : const void *param;
505 : : size_t param_size;
506 : :
507 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, true, ¶m_size);
508 : :
509 : 0 : libspdm_create_signing_context (spdm_version, op_code, true,
510 : : spdm12_signing_context_with_hash);
511 : 0 : hash_size = libspdm_get_hash_size(base_hash_algo);
512 : 0 : result = libspdm_hash_all(base_hash_algo, message, message_size,
513 : : &spdm12_signing_context_with_hash[
514 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE]);
515 [ # # ]: 0 : if (!result) {
516 : 0 : return false;
517 : : }
518 : :
519 : : /* re-assign message and message_size for signing */
520 : 0 : message = spdm12_signing_context_with_hash;
521 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
522 : 0 : result = libspdm_pqc_asym_verify_wrap(context, req_pqc_asym_alg,
523 : : param, param_size,
524 : : message, message_size,
525 : : signature, sig_size);
526 : :
527 : 0 : return result;
528 : : }
529 : :
530 : 0 : bool libspdm_req_pqc_asym_verify_hash(
531 : : spdm_version_number_t spdm_version, uint8_t op_code,
532 : : uint32_t req_pqc_asym_alg,
533 : : uint32_t base_hash_algo, void *context,
534 : : const uint8_t *message_hash, size_t hash_size,
535 : : const uint8_t *signature, size_t sig_size)
536 : : {
537 : : uint8_t *message;
538 : : size_t message_size;
539 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
540 : : LIBSPDM_MAX_HASH_SIZE];
541 : : const void *param;
542 : : size_t param_size;
543 : :
544 [ # # ]: 0 : LIBSPDM_ASSERT (hash_size == libspdm_get_hash_size(base_hash_algo));
545 : :
546 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, true, ¶m_size);
547 : :
548 : 0 : libspdm_create_signing_context (spdm_version, op_code, true,
549 : : spdm12_signing_context_with_hash);
550 : 0 : libspdm_copy_mem(&spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE],
551 : : sizeof(spdm12_signing_context_with_hash) -
552 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE,
553 : : message_hash, hash_size);
554 : :
555 : : /* assign message and message_size for signing */
556 : 0 : message = spdm12_signing_context_with_hash;
557 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
558 : :
559 : 0 : return libspdm_pqc_asym_verify_wrap(context, req_pqc_asym_alg,
560 : : param, param_size,
561 : : message, message_size,
562 : : signature, sig_size);
563 : : }
564 : :
565 : 0 : bool libspdm_req_pqc_asym_sign(
566 : : spdm_version_number_t spdm_version, uint8_t op_code,
567 : : uint32_t req_pqc_asym_alg,
568 : : uint32_t base_hash_algo, void *context,
569 : : const uint8_t *message, size_t message_size,
570 : : uint8_t *signature, size_t *sig_size)
571 : : {
572 : : size_t hash_size;
573 : : bool result;
574 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
575 : : LIBSPDM_MAX_HASH_SIZE];
576 : : const void *param;
577 : : size_t param_size;
578 : :
579 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, true, ¶m_size);
580 : :
581 : 0 : libspdm_create_signing_context (spdm_version, op_code, true,
582 : : spdm12_signing_context_with_hash);
583 : 0 : hash_size = libspdm_get_hash_size(base_hash_algo);
584 : 0 : result = libspdm_hash_all(base_hash_algo, message, message_size,
585 : : &spdm12_signing_context_with_hash[
586 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE]);
587 [ # # ]: 0 : if (!result) {
588 : 0 : return false;
589 : : }
590 : :
591 : : /* re-assign message and message_size for signing */
592 : 0 : message = spdm12_signing_context_with_hash;
593 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
594 : :
595 : 0 : return libspdm_pqc_asym_sign_wrap(context, req_pqc_asym_alg,
596 : : param, param_size,
597 : : message, message_size,
598 : : signature, sig_size);
599 : : }
600 : :
601 : 0 : bool libspdm_req_pqc_asym_sign_hash(
602 : : spdm_version_number_t spdm_version, uint8_t op_code,
603 : : uint32_t req_pqc_asym_alg,
604 : : uint32_t base_hash_algo, void *context,
605 : : const uint8_t *message_hash, size_t hash_size,
606 : : uint8_t *signature, size_t *sig_size)
607 : : {
608 : : uint8_t *message;
609 : : size_t message_size;
610 : : uint8_t spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE +
611 : : LIBSPDM_MAX_HASH_SIZE];
612 : : const void *param;
613 : : size_t param_size;
614 : :
615 [ # # ]: 0 : LIBSPDM_ASSERT (hash_size == libspdm_get_hash_size(base_hash_algo));
616 : :
617 : 0 : param = libspdm_get_signing_context_string (spdm_version, op_code, true, ¶m_size);
618 : :
619 : 0 : libspdm_create_signing_context (spdm_version, op_code, true,
620 : : spdm12_signing_context_with_hash);
621 : 0 : libspdm_copy_mem(&spdm12_signing_context_with_hash[SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE],
622 : : sizeof(spdm12_signing_context_with_hash) -
623 : : SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE,
624 : : message_hash, hash_size);
625 : :
626 : : /* assign message and message_size for signing */
627 : 0 : message = spdm12_signing_context_with_hash;
628 : 0 : message_size = SPDM_VERSION_1_2_SIGNING_CONTEXT_SIZE + hash_size;
629 : :
630 : 0 : return libspdm_pqc_asym_sign_wrap(context, req_pqc_asym_alg,
631 : : param, param_size,
632 : : message, message_size,
633 : : signature, sig_size);
634 : : }
|
