Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2025 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 "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 :
10 : #pragma pack(1)
11 : typedef struct {
12 : spdm_negotiate_algorithms_request_t spdm_request_version10;
13 : spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
14 : } libspdm_negotiate_algorithms_request_spdm11_t;
15 :
16 : typedef struct {
17 : spdm_negotiate_algorithms_request_t spdm_request_version10;
18 : uint32_t extra[21];
19 : spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
20 : } libspdm_negotiate_algorithms_request_spdm11_oversized_t;
21 :
22 : typedef struct {
23 : spdm_negotiate_algorithms_request_t spdm_request_version10;
24 : spdm_negotiate_algorithms_common_struct_table_t struct_table[12];
25 : } libspdm_negotiate_algorithms_request_spdm11_multiple_tables_t;
26 :
27 : typedef struct {
28 : spdm_negotiate_algorithms_request_t spdm_request_version10;
29 : spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
30 : } libspdm_negotiate_algorithms_request_spdm12_t;
31 :
32 : typedef struct {
33 : spdm_negotiate_algorithms_request_t spdm_request_version10;
34 : spdm_negotiate_algorithms_common_struct_table_t struct_table[5];
35 : } libspdm_negotiate_algorithms_request_spdm12_more_algo_t;
36 :
37 : typedef struct {
38 : spdm_message_header_t header;
39 : uint16_t length;
40 : uint8_t measurement_specification_sel;
41 : uint8_t reserved;
42 : uint32_t measurement_hash_algo;
43 : uint32_t base_asym_sel;
44 : uint32_t base_hash_sel;
45 : uint8_t reserved2[12];
46 : uint8_t ext_asym_sel_count;
47 : uint8_t ext_hash_sel_count;
48 : uint16_t reserved3;
49 : spdm_negotiate_algorithms_common_struct_table_t struct_table[4];
50 : } libspdm_algorithms_response_mine_t;
51 : #pragma pack()
52 :
53 : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithms_request1 = {
54 : { SPDM_MESSAGE_VERSION_10, SPDM_NEGOTIATE_ALGORITHMS, 0, 0 },
55 : sizeof(spdm_negotiate_algorithms_request_t),
56 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
57 : };
58 : size_t m_libspdm_negotiate_algorithms_request1_size =
59 : sizeof(m_libspdm_negotiate_algorithms_request1);
60 :
61 : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithms_request2 = {
62 : { SPDM_MESSAGE_VERSION_10, SPDM_NEGOTIATE_ALGORITHMS, 0, 0 },
63 : sizeof(spdm_negotiate_algorithms_request_t),
64 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
65 : };
66 : size_t m_libspdm_negotiate_algorithms_request2_size = sizeof(spdm_message_header_t);
67 :
68 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request3 = {
69 : {
70 : {
71 : SPDM_MESSAGE_VERSION_11,
72 : SPDM_NEGOTIATE_ALGORITHMS,
73 : 4,
74 : 0
75 : },
76 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
77 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
78 : },
79 : {
80 : {
81 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
82 : 0x20,
83 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
84 : },
85 : {
86 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
87 : 0x20,
88 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
89 : },
90 : {
91 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
92 : 0x20,
93 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
94 : },
95 : {
96 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
97 : 0x20,
98 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
99 : }
100 : }
101 : };
102 : size_t m_libspdm_negotiate_algorithm_request3_size = sizeof(m_libspdm_negotiate_algorithm_request3);
103 :
104 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request4 = {
105 : {
106 : {
107 : SPDM_MESSAGE_VERSION_11,
108 : SPDM_NEGOTIATE_ALGORITHMS,
109 : 4,
110 : 0
111 : },
112 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
113 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
114 : },
115 : {
116 : {
117 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
118 : 0x20,
119 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
120 : },
121 : {
122 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
123 : 0x20,
124 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
125 : },
126 : {
127 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
128 : 0x20,
129 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
130 : },
131 : {
132 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
133 : 0x20,
134 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
135 : }
136 : }
137 : };
138 : size_t m_libspdm_negotiate_algorithm_request4_size = sizeof(m_libspdm_negotiate_algorithm_request4);
139 :
140 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request5 = {
141 : {
142 : {
143 : SPDM_MESSAGE_VERSION_11,
144 : SPDM_NEGOTIATE_ALGORITHMS,
145 : 4,
146 : 0
147 : },
148 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
149 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
150 : },
151 : {
152 : {
153 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
154 : 0x20,
155 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
156 : },
157 : {
158 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
159 : 0x20,
160 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
161 : },
162 : {
163 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
164 : 0x20,
165 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
166 : },
167 : {
168 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
169 : 0x20,
170 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
171 : }
172 : }
173 : };
174 : size_t m_libspdm_negotiate_algorithm_request5_size = sizeof(m_libspdm_negotiate_algorithm_request5);
175 :
176 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request6 = {
177 : {
178 : {
179 : SPDM_MESSAGE_VERSION_11,
180 : SPDM_NEGOTIATE_ALGORITHMS,
181 : 4,
182 : 0
183 : },
184 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
185 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
186 : },
187 : {
188 : {
189 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
190 : 0x20,
191 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_521_R1
192 : },
193 : {
194 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
195 : 0x20,
196 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
197 : },
198 : {
199 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
200 : 0x20,
201 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
202 : },
203 : {
204 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
205 : 0x20,
206 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
207 : }
208 : }
209 : };
210 : size_t m_libspdm_negotiate_algorithm_request6_size = sizeof(m_libspdm_negotiate_algorithm_request6);
211 :
212 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request7 = {
213 : {
214 : {
215 : SPDM_MESSAGE_VERSION_11,
216 : SPDM_NEGOTIATE_ALGORITHMS,
217 : 4,
218 : 0
219 : },
220 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
221 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
222 : },
223 : {
224 : {
225 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
226 : 0x20,
227 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
228 : },
229 : {
230 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
231 : 0x20,
232 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_CHACHA20_POLY1305
233 : },
234 : {
235 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
236 : 0x20,
237 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
238 : },
239 : {
240 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
241 : 0x20,
242 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
243 : }
244 : }
245 : };
246 : size_t m_libspdm_negotiate_algorithm_request7_size = sizeof(m_libspdm_negotiate_algorithm_request7);
247 :
248 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request8 = {
249 : {
250 : {
251 : SPDM_MESSAGE_VERSION_11,
252 : SPDM_NEGOTIATE_ALGORITHMS,
253 : 4,
254 : 0
255 : },
256 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
257 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
258 : },
259 : {
260 : {
261 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
262 : 0x20,
263 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
264 : },
265 : {
266 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
267 : 0x20,
268 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
269 : },
270 : {
271 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
272 : 0x20,
273 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521
274 : },
275 : {
276 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
277 : 0x20,
278 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
279 : }
280 : }
281 : };
282 : size_t m_libspdm_negotiate_algorithm_request8_size = sizeof(m_libspdm_negotiate_algorithm_request8);
283 :
284 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request9 = {
285 : {
286 : {
287 : SPDM_MESSAGE_VERSION_11,
288 : SPDM_NEGOTIATE_ALGORITHMS,
289 : 4,
290 : 0
291 : },
292 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
293 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
294 : },
295 : {
296 : {
297 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
298 : 0x20,
299 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
300 : },
301 : {
302 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
303 : 0x20,
304 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
305 : },
306 : {
307 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
308 : 0x20,
309 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
310 : },
311 : {
312 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
313 : 0x20,
314 : 0x00000020
315 : }
316 : }
317 : };
318 : size_t m_libspdm_negotiate_algorithm_request9_size = sizeof(m_libspdm_negotiate_algorithm_request9);
319 :
320 : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithm_request10 = {
321 : {
322 : SPDM_MESSAGE_VERSION_10,
323 : SPDM_NEGOTIATE_ALGORITHMS,
324 : 0,
325 : 0
326 : },
327 : 0x44,
328 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
329 : };
330 : size_t m_libspdm_negotiate_algorithm_request10_size = 0x44;
331 :
332 : libspdm_negotiate_algorithms_request_spdm11_oversized_t m_libspdm_negotiate_algorithm_request11 = {
333 : {
334 : {
335 : SPDM_MESSAGE_VERSION_11,
336 : SPDM_NEGOTIATE_ALGORITHMS,
337 : 4,
338 : 0
339 : },
340 : sizeof(libspdm_negotiate_algorithms_request_spdm11_oversized_t),
341 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
342 : },
343 : {0},
344 : {
345 : {
346 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
347 : 0x20,
348 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
349 : },
350 : {
351 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
352 : 0x20,
353 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
354 : },
355 : {
356 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
357 : 0x20,
358 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
359 : },
360 : {
361 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
362 : 0x20,
363 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
364 : }
365 : }
366 : };
367 : size_t m_libspdm_negotiate_algorithm_request11_size =
368 : sizeof(m_libspdm_negotiate_algorithm_request11);
369 :
370 : libspdm_negotiate_algorithms_request_spdm11_multiple_tables_t
371 : m_libspdm_negotiate_algorithm_request12 =
372 : {
373 : {
374 : {
375 : SPDM_MESSAGE_VERSION_11,
376 : SPDM_NEGOTIATE_ALGORITHMS,
377 : 12,
378 : 0
379 : },
380 : sizeof(libspdm_negotiate_algorithms_request_spdm11_multiple_tables_t),
381 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
382 : },
383 : {
384 : {
385 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
386 : 0x20,
387 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_FFDHE_2048
388 : },
389 : {
390 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
391 : 0x20,
392 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_128_GCM
393 : },
394 : {
395 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
396 : 0x20,
397 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256
398 : },
399 : {
400 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
401 : 0x20,
402 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
403 : },
404 : {
405 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
406 : 0x20,
407 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_FFDHE_3072
408 : },
409 : {
410 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
411 : 0x20,
412 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_CHACHA20_POLY1305
413 : },
414 : {
415 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
416 : 0x20,
417 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384
418 : },
419 : {
420 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
421 : 0x20,
422 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
423 : },
424 : {
425 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
426 : 0x20,
427 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
428 : },
429 : {
430 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
431 : 0x20,
432 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
433 : },
434 : {
435 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
436 : 0x20,
437 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
438 : },
439 : {
440 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
441 : 0x20,
442 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
443 : }
444 : }
445 : };
446 : size_t m_libspdm_negotiate_algorithm_request12_size =
447 : sizeof(m_libspdm_negotiate_algorithm_request12);
448 :
449 : libspdm_negotiate_algorithms_request_spdm11_t
450 : m_libspdm_negotiate_algorithm_request13 =
451 : {
452 : {
453 : {
454 : SPDM_MESSAGE_VERSION_11,
455 : SPDM_NEGOTIATE_ALGORITHMS,
456 : 3,
457 : 0
458 : },
459 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t)-
460 : sizeof(spdm_negotiate_algorithms_common_struct_table_t),
461 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
462 : },
463 : {
464 : {
465 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
466 : 0x20,
467 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
468 : },
469 : {
470 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
471 : 0x20,
472 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
473 : },
474 : {
475 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
476 : 0x20,
477 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
478 : },
479 : {
480 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
481 : 0x20,
482 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
483 : }
484 : }
485 : };
486 : size_t m_libspdm_negotiate_algorithm_request13_size =
487 : sizeof(m_libspdm_negotiate_algorithm_request13)-
488 : sizeof(
489 : spdm_negotiate_algorithms_common_struct_table_t);
490 :
491 : libspdm_negotiate_algorithms_request_spdm11_t
492 : m_libspdm_negotiate_algorithm_request14 =
493 : {
494 : {
495 : {
496 : SPDM_MESSAGE_VERSION_11,
497 : SPDM_NEGOTIATE_ALGORITHMS,
498 : 5,
499 : 0
500 : },
501 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t)+
502 : sizeof(spdm_negotiate_algorithms_common_struct_table_t),
503 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
504 : },
505 : {
506 : {
507 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
508 : 0x20,
509 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_FFDHE_2048
510 : },
511 : {
512 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
513 : 0x20,
514 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_128_GCM
515 : },
516 : {
517 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
518 : 0x20,
519 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256
520 : },
521 : {
522 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
523 : 0x20,
524 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
525 : },
526 : }
527 : };
528 : size_t m_libspdm_negotiate_algorithm_request14_size =
529 : sizeof(m_libspdm_negotiate_algorithm_request14)+
530 : sizeof(
531 : spdm_negotiate_algorithms_common_struct_table_t);
532 :
533 : libspdm_negotiate_algorithms_request_spdm11_t
534 : m_libspdm_negotiate_algorithm_request15 =
535 : {
536 : {
537 : {
538 : SPDM_MESSAGE_VERSION_11,
539 : SPDM_NEGOTIATE_ALGORITHMS,
540 : 12,
541 : 0
542 : },
543 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
544 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
545 : },
546 : {
547 : {
548 : 1,
549 : 0x20,
550 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
551 : },
552 : {
553 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
554 : 0x20,
555 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
556 : },
557 : {
558 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
559 : 0x20,
560 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
561 : },
562 : {
563 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
564 : 0x20,
565 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
566 : }
567 : }
568 : };
569 : size_t m_libspdm_negotiate_algorithm_request15_size =
570 : sizeof(m_libspdm_negotiate_algorithm_request15);
571 :
572 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request16 = {
573 : {
574 : {
575 : SPDM_MESSAGE_VERSION_11,
576 : SPDM_NEGOTIATE_ALGORITHMS,
577 : 4,
578 : 0
579 : },
580 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
581 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
582 : },
583 : {
584 : {
585 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
586 : 0x20,
587 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1 |
588 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_384_R1
589 : },
590 : {
591 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
592 : 0x20,
593 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
594 : },
595 : {
596 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
597 : 0x20,
598 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
599 : },
600 : {
601 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
602 : 0x20,
603 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
604 : }
605 : }
606 : };
607 : size_t m_libspdm_negotiate_algorithm_request16_size =
608 : sizeof(m_libspdm_negotiate_algorithm_request16);
609 :
610 : libspdm_negotiate_algorithms_request_spdm12_t
611 : m_libspdm_negotiate_algorithm_request17 =
612 : {
613 : {
614 : {
615 : SPDM_MESSAGE_VERSION_12,
616 : SPDM_NEGOTIATE_ALGORITHMS,
617 : 4,
618 : 0
619 : },
620 : sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
621 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
622 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
623 : },
624 : {
625 : {
626 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
627 : 0x20,
628 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
629 : },
630 : {
631 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
632 : 0x20,
633 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
634 : },
635 : {
636 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
637 : 0x20,
638 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
639 : },
640 : {
641 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
642 : 0x20,
643 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
644 : }
645 : }
646 : };
647 : size_t m_libspdm_negotiate_algorithm_request17_size =
648 : sizeof(m_libspdm_negotiate_algorithm_request17);
649 :
650 : libspdm_negotiate_algorithms_request_spdm12_t
651 : m_libspdm_negotiate_algorithm_request18 =
652 : {
653 : {
654 : {
655 : SPDM_MESSAGE_VERSION_12,
656 : SPDM_NEGOTIATE_ALGORITHMS,
657 : 4,
658 : 0
659 : },
660 : sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
661 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
662 : /* Illegal OpaqueDataFmt. */
663 : 0x04,
664 : },
665 : {
666 : {
667 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
668 : 0x20,
669 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
670 : },
671 : {
672 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
673 : 0x20,
674 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
675 : },
676 : {
677 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
678 : 0x20,
679 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
680 : },
681 : {
682 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
683 : 0x20,
684 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
685 : }
686 : }
687 : };
688 : size_t m_libspdm_negotiate_algorithm_request18_size =
689 : sizeof(m_libspdm_negotiate_algorithm_request18);
690 :
691 : libspdm_negotiate_algorithms_request_spdm11_t m_libspdm_negotiate_algorithm_request24 = {
692 : {
693 : {
694 : SPDM_MESSAGE_VERSION_12,
695 : SPDM_NEGOTIATE_ALGORITHMS,
696 : 4,
697 : 0
698 : },
699 : sizeof(libspdm_negotiate_algorithms_request_spdm11_t),
700 : 0, /* SPDM_MEASUREMENT_SPECIFICATION_DMTF */
701 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
702 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
703 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
704 : },
705 : {
706 : {
707 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
708 : 0x20,
709 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
710 : },
711 : {
712 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
713 : 0x20,
714 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
715 : },
716 : {
717 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
718 : 0x20,
719 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
720 : },
721 : {
722 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
723 : 0x20,
724 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
725 : }
726 : }
727 : };
728 : size_t m_libspdm_negotiate_algorithm_request24_size =
729 : sizeof(m_libspdm_negotiate_algorithm_request24);
730 :
731 : libspdm_negotiate_algorithms_request_spdm12_t
732 : m_libspdm_negotiate_algorithm_request25 =
733 : {
734 : {
735 : {
736 : SPDM_MESSAGE_VERSION_12,
737 : SPDM_NEGOTIATE_ALGORITHMS,
738 : 4,
739 : 0
740 : },
741 : sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
742 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
743 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
744 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
745 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
746 : },
747 : {
748 : {
749 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
750 : 0x20,
751 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
752 : },
753 : {
754 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
755 : 0x20,
756 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
757 : },
758 : {
759 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
760 : 0x20,
761 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
762 : },
763 : {
764 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
765 : 0x20,
766 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
767 : }
768 : }
769 : };
770 : size_t m_libspdm_negotiate_algorithm_request25_size =
771 : sizeof(m_libspdm_negotiate_algorithm_request25);
772 :
773 : libspdm_negotiate_algorithms_request_spdm12_t
774 : m_libspdm_negotiate_algorithm_request26 =
775 : {
776 : {
777 : {
778 : SPDM_MESSAGE_VERSION_12,
779 : SPDM_NEGOTIATE_ALGORITHMS,
780 : 4,
781 : 0
782 : },
783 : sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
784 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
785 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
786 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
787 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
788 : },
789 : {
790 : {
791 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
792 : 0x20,
793 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
794 : },
795 : {
796 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
797 : 0x20,
798 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
799 : },
800 : {
801 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
802 : 0x20,
803 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
804 : },
805 : {
806 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
807 : 0x20,
808 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
809 : }
810 : }
811 : };
812 : size_t m_libspdm_negotiate_algorithm_request26_size =
813 : sizeof(m_libspdm_negotiate_algorithm_request26);
814 :
815 : libspdm_negotiate_algorithms_request_spdm12_more_algo_t
816 : m_libspdm_negotiate_algorithm_request27 =
817 : {
818 : {
819 : {
820 : SPDM_MESSAGE_VERSION_12,
821 : SPDM_NEGOTIATE_ALGORITHMS,
822 : 5,
823 : 0
824 : },
825 : sizeof(libspdm_negotiate_algorithms_request_spdm12_more_algo_t),
826 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
827 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
828 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
829 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
830 : },
831 : {
832 : {
833 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE - 1,
834 : 0x20,
835 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
836 : },
837 : {
838 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
839 : 0x20,
840 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
841 : },
842 : {
843 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
844 : 0x20,
845 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
846 : },
847 : {
848 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
849 : 0x20,
850 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
851 : },
852 : {
853 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
854 : 0x20,
855 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
856 : },
857 : }
858 : };
859 : size_t m_libspdm_negotiate_algorithm_request27_size =
860 : sizeof(m_libspdm_negotiate_algorithm_request27);
861 :
862 : libspdm_negotiate_algorithms_request_spdm12_more_algo_t
863 : m_libspdm_negotiate_algorithm_request28 =
864 : {
865 : {
866 : {
867 : SPDM_MESSAGE_VERSION_12,
868 : SPDM_NEGOTIATE_ALGORITHMS,
869 : 5,
870 : 0
871 : },
872 : sizeof(libspdm_negotiate_algorithms_request_spdm12_more_algo_t),
873 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
874 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
875 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
876 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
877 : },
878 : {
879 : {
880 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
881 : 0x20,
882 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
883 : },
884 : {
885 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
886 : 0x20,
887 : SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM
888 : },
889 : {
890 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
891 : 0x20,
892 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
893 : },
894 : {
895 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
896 : 0x20,
897 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
898 : },
899 : {
900 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE + 1,
901 : 0x20,
902 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
903 : }
904 : }
905 : };
906 : size_t m_libspdm_negotiate_algorithm_request28_size =
907 : sizeof(m_libspdm_negotiate_algorithm_request28);
908 :
909 : libspdm_negotiate_algorithms_request_spdm12_t
910 : m_libspdm_negotiate_algorithm_request29 =
911 : {
912 : {
913 : {
914 : SPDM_MESSAGE_VERSION_12,
915 : SPDM_NEGOTIATE_ALGORITHMS,
916 : 4,
917 : 0
918 : },
919 : sizeof(libspdm_negotiate_algorithms_request_spdm12_t),
920 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
921 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1,
922 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256,
923 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256,
924 : },
925 : {
926 : {
927 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE,
928 : 0x20,
929 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1
930 : },
931 : {
932 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD,
933 : 0x20,
934 : /* No supported AlgTypes */
935 : 0x00
936 : },
937 : {
938 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG,
939 : 0x20,
940 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048
941 : },
942 : {
943 : SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE,
944 : 0x20,
945 : SPDM_ALGORITHMS_KEY_SCHEDULE_SPDM
946 : }
947 : }
948 : };
949 : size_t m_libspdm_negotiate_algorithm_request29_size =
950 : sizeof(m_libspdm_negotiate_algorithm_request29);
951 :
952 : spdm_negotiate_algorithms_request_t m_libspdm_negotiate_algorithms_request30 = {
953 : { SPDM_MESSAGE_VERSION_13, SPDM_NEGOTIATE_ALGORITHMS, 0, 0 },
954 : sizeof(spdm_negotiate_algorithms_request_t),
955 : SPDM_MEASUREMENT_SPECIFICATION_DMTF,
956 : SPDM_ALGORITHMS_MULTI_KEY_CONN,
957 : };
958 : size_t m_libspdm_negotiate_algorithms_request30_size =
959 : sizeof(m_libspdm_negotiate_algorithms_request30);
960 :
961 1 : void libspdm_test_responder_algorithms_case1(void **state)
962 : {
963 : libspdm_return_t status;
964 : libspdm_test_context_t *spdm_test_context;
965 : libspdm_context_t *spdm_context;
966 : size_t response_size;
967 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
968 : spdm_algorithms_response_t *spdm_response;
969 :
970 1 : spdm_test_context = *state;
971 1 : spdm_context = spdm_test_context->spdm_context;
972 1 : spdm_test_context->case_id = 0x1;
973 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
974 : SPDM_VERSION_NUMBER_SHIFT_BIT;
975 1 : spdm_context->connection_info.connection_state =
976 : LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
977 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
978 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
979 :
980 1 : response_size = sizeof(response);
981 1 : status = libspdm_get_response_algorithms(
982 : spdm_context, m_libspdm_negotiate_algorithms_request1_size,
983 : &m_libspdm_negotiate_algorithms_request1, &response_size,
984 : response);
985 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
986 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
987 1 : spdm_response = (void *)response;
988 1 : assert_int_equal(spdm_response->header.request_response_code,
989 : SPDM_ALGORITHMS);
990 1 : }
991 :
992 1 : void libspdm_test_responder_algorithms_case2(void **state)
993 : {
994 : libspdm_return_t status;
995 : libspdm_test_context_t *spdm_test_context;
996 : libspdm_context_t *spdm_context;
997 : size_t response_size;
998 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
999 : spdm_algorithms_response_t *spdm_response;
1000 :
1001 1 : spdm_test_context = *state;
1002 1 : spdm_context = spdm_test_context->spdm_context;
1003 1 : spdm_test_context->case_id = 0x2;
1004 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1005 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1006 1 : spdm_context->connection_info.connection_state =
1007 : LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1008 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1009 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1010 :
1011 1 : response_size = sizeof(response);
1012 1 : status = libspdm_get_response_algorithms(
1013 : spdm_context, m_libspdm_negotiate_algorithms_request2_size,
1014 : &m_libspdm_negotiate_algorithms_request2, &response_size,
1015 : response);
1016 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1017 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1018 1 : spdm_response = (void *)response;
1019 1 : assert_int_equal(spdm_response->header.request_response_code,
1020 : SPDM_ERROR);
1021 1 : assert_int_equal(spdm_response->header.param1,
1022 : SPDM_ERROR_CODE_INVALID_REQUEST);
1023 1 : assert_int_equal(spdm_response->header.param2, 0);
1024 1 : }
1025 :
1026 1 : void libspdm_test_responder_algorithms_case3(void **state)
1027 : {
1028 : libspdm_return_t status;
1029 : libspdm_test_context_t *spdm_test_context;
1030 : libspdm_context_t *spdm_context;
1031 : size_t response_size;
1032 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1033 : spdm_algorithms_response_t *spdm_response;
1034 :
1035 1 : spdm_test_context = *state;
1036 1 : spdm_context = spdm_test_context->spdm_context;
1037 1 : spdm_test_context->case_id = 0x3;
1038 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1039 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1040 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
1041 1 : spdm_context->connection_info.connection_state =
1042 : LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1043 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1044 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1045 :
1046 1 : response_size = sizeof(response);
1047 1 : status = libspdm_get_response_algorithms(
1048 : spdm_context, m_libspdm_negotiate_algorithms_request1_size,
1049 : &m_libspdm_negotiate_algorithms_request1, &response_size,
1050 : response);
1051 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1052 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1053 1 : spdm_response = (void *)response;
1054 1 : assert_int_equal(spdm_response->header.request_response_code,
1055 : SPDM_ERROR);
1056 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
1057 1 : assert_int_equal(spdm_response->header.param2, 0);
1058 1 : assert_int_equal(spdm_context->response_state,
1059 : LIBSPDM_RESPONSE_STATE_BUSY);
1060 1 : }
1061 :
1062 1 : void libspdm_test_responder_algorithms_case4(void **state)
1063 : {
1064 : libspdm_return_t status;
1065 : libspdm_test_context_t *spdm_test_context;
1066 : libspdm_context_t *spdm_context;
1067 : size_t response_size;
1068 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1069 : spdm_algorithms_response_t *spdm_response;
1070 :
1071 1 : spdm_test_context = *state;
1072 1 : spdm_context = spdm_test_context->spdm_context;
1073 1 : spdm_test_context->case_id = 0x4;
1074 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1075 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1076 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
1077 1 : spdm_context->connection_info.connection_state =
1078 : LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1079 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1080 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1081 :
1082 1 : response_size = sizeof(response);
1083 1 : status = libspdm_get_response_algorithms(
1084 : spdm_context, m_libspdm_negotiate_algorithms_request1_size,
1085 : &m_libspdm_negotiate_algorithms_request1, &response_size,
1086 : response);
1087 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1088 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1089 1 : spdm_response = (void *)response;
1090 1 : assert_int_equal(spdm_response->header.request_response_code,
1091 : SPDM_ERROR);
1092 1 : assert_int_equal(spdm_response->header.param1,
1093 : SPDM_ERROR_CODE_REQUEST_RESYNCH);
1094 1 : assert_int_equal(spdm_response->header.param2, 0);
1095 1 : assert_int_equal(spdm_context->response_state,
1096 : LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
1097 1 : }
1098 :
1099 1 : void libspdm_test_responder_algorithms_case6(void **state)
1100 : {
1101 : libspdm_return_t status;
1102 : libspdm_test_context_t *spdm_test_context;
1103 : libspdm_context_t *spdm_context;
1104 : size_t response_size;
1105 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1106 : spdm_algorithms_response_t *spdm_response;
1107 :
1108 1 : spdm_test_context = *state;
1109 1 : spdm_context = spdm_test_context->spdm_context;
1110 1 : spdm_test_context->case_id = 0x6;
1111 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1112 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1113 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
1114 1 : spdm_context->connection_info.connection_state =
1115 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
1116 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1117 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1118 :
1119 1 : response_size = sizeof(response);
1120 1 : status = libspdm_get_response_algorithms(
1121 : spdm_context, m_libspdm_negotiate_algorithms_request1_size,
1122 : &m_libspdm_negotiate_algorithms_request1, &response_size,
1123 : response);
1124 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1125 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1126 1 : spdm_response = (void *)response;
1127 1 : assert_int_equal(spdm_response->header.request_response_code,
1128 : SPDM_ERROR);
1129 1 : assert_int_equal(spdm_response->header.param1,
1130 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
1131 1 : assert_int_equal(spdm_response->header.param2, 0);
1132 1 : }
1133 :
1134 1 : void libspdm_test_responder_algorithms_case7(void **state) {
1135 : libspdm_return_t status;
1136 : libspdm_test_context_t *spdm_test_context;
1137 : libspdm_context_t *spdm_context;
1138 : size_t response_size;
1139 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1140 : libspdm_algorithms_response_mine_t *spdm_response;
1141 :
1142 1 : spdm_test_context = *state;
1143 1 : spdm_context = spdm_test_context->spdm_context;
1144 1 : spdm_test_context->case_id = 0x7;
1145 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1146 :
1147 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1148 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1149 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1150 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1151 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1152 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1153 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1154 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1155 :
1156 1 : libspdm_reset_message_a(spdm_context);
1157 :
1158 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1159 1 : spdm_context->connection_info.capability.flags |=
1160 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1161 :
1162 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1163 1 : spdm_context->connection_info.capability.flags |=
1164 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1165 :
1166 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1167 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1168 :
1169 1 : spdm_context->local_context.capability.flags |=
1170 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1171 1 : spdm_context->connection_info.capability.flags |=
1172 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1173 :
1174 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1175 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1176 :
1177 1 : response_size = sizeof(response);
1178 1 : status = libspdm_get_response_algorithms (spdm_context,
1179 : m_libspdm_negotiate_algorithm_request3_size,
1180 : &m_libspdm_negotiate_algorithm_request3,
1181 : &response_size,
1182 : response);
1183 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1184 1 : assert_int_equal (response_size,
1185 : sizeof(spdm_algorithms_response_t)+4*
1186 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
1187 1 : spdm_response = (void *)response;
1188 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ALGORITHMS);
1189 1 : assert_int_equal (spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_11);
1190 :
1191 1 : assert_int_equal (spdm_response->struct_table[0].alg_supported,
1192 : spdm_context->local_context.algorithm.dhe_named_group);
1193 1 : assert_int_equal (spdm_response->struct_table[1].alg_supported,
1194 : spdm_context->local_context.algorithm.aead_cipher_suite);
1195 1 : assert_int_equal (spdm_response->struct_table[2].alg_supported,
1196 : spdm_context->local_context.algorithm.req_base_asym_alg);
1197 1 : assert_int_equal (spdm_response->struct_table[3].alg_supported,
1198 : spdm_context->local_context.algorithm.key_schedule);
1199 1 : }
1200 :
1201 1 : void libspdm_test_responder_algorithms_case8(void **state) {
1202 : libspdm_return_t status;
1203 : libspdm_test_context_t *spdm_test_context;
1204 : libspdm_context_t *spdm_context;
1205 : size_t response_size;
1206 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1207 : spdm_algorithms_response_t *spdm_response;
1208 :
1209 1 : spdm_test_context = *state;
1210 1 : spdm_context = spdm_test_context->spdm_context;
1211 1 : spdm_test_context->case_id = 0x8;
1212 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1213 :
1214 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1215 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1216 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1217 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1218 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1219 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1220 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1221 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1222 :
1223 1 : libspdm_reset_message_a(spdm_context);
1224 :
1225 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
1226 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1227 :
1228 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1229 1 : spdm_context->connection_info.capability.flags |=
1230 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1231 :
1232 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1233 1 : spdm_context->connection_info.capability.flags |=
1234 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1235 :
1236 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1237 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1238 :
1239 1 : spdm_context->local_context.capability.flags |=
1240 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1241 1 : spdm_context->connection_info.capability.flags |=
1242 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1243 :
1244 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1245 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1246 :
1247 1 : response_size = sizeof(response);
1248 1 : status = libspdm_get_response_algorithms (spdm_context,
1249 : m_libspdm_negotiate_algorithm_request4_size,
1250 : &m_libspdm_negotiate_algorithm_request4,
1251 : &response_size,
1252 : response);
1253 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1254 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1255 1 : spdm_response = (void *)response;
1256 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1257 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1258 1 : assert_int_equal (spdm_response->header.param2, 0);
1259 1 : }
1260 :
1261 1 : void libspdm_test_responder_algorithms_case9(void **state) {
1262 : libspdm_return_t status;
1263 : libspdm_test_context_t *spdm_test_context;
1264 : libspdm_context_t *spdm_context;
1265 : size_t response_size;
1266 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1267 : spdm_algorithms_response_t *spdm_response;
1268 :
1269 1 : spdm_test_context = *state;
1270 1 : spdm_context = spdm_test_context->spdm_context;
1271 1 : spdm_test_context->case_id = 0x9;
1272 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1273 :
1274 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1275 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1276 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1277 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1278 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1279 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1280 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1281 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1282 :
1283 1 : libspdm_reset_message_a(spdm_context);
1284 :
1285 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
1286 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1287 :
1288 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1289 1 : spdm_context->connection_info.capability.flags |=
1290 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1291 :
1292 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1293 1 : spdm_context->connection_info.capability.flags |=
1294 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1295 :
1296 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1297 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1298 :
1299 1 : spdm_context->local_context.capability.flags |=
1300 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1301 1 : spdm_context->connection_info.capability.flags |=
1302 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1303 :
1304 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1305 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1306 :
1307 1 : response_size = sizeof(response);
1308 1 : status = libspdm_get_response_algorithms (spdm_context,
1309 : m_libspdm_negotiate_algorithm_request5_size,
1310 : &m_libspdm_negotiate_algorithm_request5,
1311 : &response_size,
1312 : response);
1313 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1314 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1315 1 : spdm_response = (void *)response;
1316 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1317 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1318 1 : assert_int_equal (spdm_response->header.param2, 0);
1319 1 : }
1320 :
1321 1 : void libspdm_test_responder_algorithms_case10(void **state) {
1322 : libspdm_return_t status;
1323 : libspdm_test_context_t *spdm_test_context;
1324 : libspdm_context_t *spdm_context;
1325 : size_t response_size;
1326 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1327 : spdm_algorithms_response_t *spdm_response;
1328 :
1329 1 : spdm_test_context = *state;
1330 1 : spdm_context = spdm_test_context->spdm_context;
1331 1 : spdm_test_context->case_id = 0xA;
1332 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1333 :
1334 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1335 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1336 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1337 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1338 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1339 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1340 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1341 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1342 :
1343 1 : libspdm_reset_message_a(spdm_context);
1344 :
1345 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
1346 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1347 :
1348 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1349 1 : spdm_context->connection_info.capability.flags |=
1350 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1351 :
1352 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1353 1 : spdm_context->connection_info.capability.flags |=
1354 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1355 :
1356 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1357 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1358 :
1359 1 : spdm_context->local_context.capability.flags |=
1360 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1361 1 : spdm_context->connection_info.capability.flags |=
1362 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1363 :
1364 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1365 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1366 :
1367 1 : response_size = sizeof(response);
1368 1 : status = libspdm_get_response_algorithms (spdm_context,
1369 : m_libspdm_negotiate_algorithm_request6_size,
1370 : &m_libspdm_negotiate_algorithm_request6,
1371 : &response_size,
1372 : response);
1373 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1374 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1375 1 : spdm_response = (void *)response;
1376 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1377 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1378 1 : assert_int_equal (spdm_response->header.param2, 0);
1379 1 : }
1380 :
1381 1 : void libspdm_test_responder_algorithms_case11(void **state) {
1382 : libspdm_return_t status;
1383 : libspdm_test_context_t *spdm_test_context;
1384 : libspdm_context_t *spdm_context;
1385 : size_t response_size;
1386 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1387 : spdm_algorithms_response_t *spdm_response;
1388 :
1389 1 : spdm_test_context = *state;
1390 1 : spdm_context = spdm_test_context->spdm_context;
1391 1 : spdm_test_context->case_id = 0xB;
1392 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1393 :
1394 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1395 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1396 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1397 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1398 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1399 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1400 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1401 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1402 :
1403 1 : libspdm_reset_message_a(spdm_context);
1404 :
1405 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
1406 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1407 :
1408 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1409 1 : spdm_context->connection_info.capability.flags |=
1410 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1411 :
1412 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1413 1 : spdm_context->connection_info.capability.flags |=
1414 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1415 :
1416 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1417 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1418 :
1419 1 : spdm_context->local_context.capability.flags |=
1420 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1421 1 : spdm_context->connection_info.capability.flags |=
1422 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1423 :
1424 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1425 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1426 :
1427 1 : response_size = sizeof(response);
1428 1 : status = libspdm_get_response_algorithms (spdm_context,
1429 : m_libspdm_negotiate_algorithm_request7_size,
1430 : &m_libspdm_negotiate_algorithm_request7,
1431 : &response_size,
1432 : response);
1433 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1434 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1435 1 : spdm_response = (void *)response;
1436 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1437 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1438 1 : assert_int_equal (spdm_response->header.param2, 0);
1439 1 : }
1440 :
1441 1 : void libspdm_test_responder_algorithms_case12(void **state) {
1442 : libspdm_return_t status;
1443 : libspdm_test_context_t *spdm_test_context;
1444 : libspdm_context_t *spdm_context;
1445 : size_t response_size;
1446 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1447 : spdm_algorithms_response_t *spdm_response;
1448 :
1449 1 : spdm_test_context = *state;
1450 1 : spdm_context = spdm_test_context->spdm_context;
1451 1 : spdm_test_context->case_id = 0xC;
1452 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1453 :
1454 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1455 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1456 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1457 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1458 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1459 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1460 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1461 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1462 :
1463 1 : libspdm_reset_message_a(spdm_context);
1464 :
1465 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
1466 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1467 :
1468 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1469 1 : spdm_context->connection_info.capability.flags |=
1470 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1471 :
1472 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1473 1 : spdm_context->connection_info.capability.flags |=
1474 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1475 :
1476 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1477 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1478 :
1479 1 : spdm_context->local_context.capability.flags |=
1480 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1481 1 : spdm_context->connection_info.capability.flags |=
1482 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1483 :
1484 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1485 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1486 :
1487 1 : response_size = sizeof(response);
1488 1 : status = libspdm_get_response_algorithms (spdm_context,
1489 : m_libspdm_negotiate_algorithm_request8_size,
1490 : &m_libspdm_negotiate_algorithm_request8,
1491 : &response_size,
1492 : response);
1493 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1494 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1495 1 : spdm_response = (void *)response;
1496 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1497 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1498 1 : assert_int_equal (spdm_response->header.param2, 0);
1499 1 : }
1500 :
1501 1 : void libspdm_test_responder_algorithms_case13(void **state) {
1502 : libspdm_return_t status;
1503 : libspdm_test_context_t *spdm_test_context;
1504 : libspdm_context_t *spdm_context;
1505 : size_t response_size;
1506 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1507 : spdm_algorithms_response_t *spdm_response;
1508 :
1509 1 : spdm_test_context = *state;
1510 1 : spdm_context = spdm_test_context->spdm_context;
1511 1 : spdm_test_context->case_id = 0xD;
1512 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1513 :
1514 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1515 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1516 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1517 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1518 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1519 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1520 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1521 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1522 :
1523 1 : libspdm_reset_message_a(spdm_context);
1524 :
1525 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP;
1526 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHAL_CAP;
1527 :
1528 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1529 1 : spdm_context->connection_info.capability.flags |=
1530 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1531 :
1532 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1533 1 : spdm_context->connection_info.capability.flags |=
1534 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1535 :
1536 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1537 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1538 :
1539 1 : spdm_context->local_context.capability.flags |=
1540 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1541 1 : spdm_context->connection_info.capability.flags |=
1542 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1543 :
1544 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1545 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1546 :
1547 1 : response_size = sizeof(response);
1548 1 : status = libspdm_get_response_algorithms (spdm_context,
1549 : m_libspdm_negotiate_algorithm_request9_size,
1550 : &m_libspdm_negotiate_algorithm_request9,
1551 : &response_size,
1552 : response);
1553 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1554 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1555 1 : spdm_response = (void *)response;
1556 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1557 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1558 1 : assert_int_equal (spdm_response->header.param2, 0);
1559 1 : }
1560 :
1561 1 : void libspdm_test_responder_algorithms_case14(void **state) {
1562 : libspdm_return_t status;
1563 : libspdm_test_context_t *spdm_test_context;
1564 : libspdm_context_t *spdm_context;
1565 : size_t response_size;
1566 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1567 : spdm_algorithms_response_t *spdm_response;
1568 :
1569 1 : spdm_test_context = *state;
1570 1 : spdm_context = spdm_test_context->spdm_context;
1571 1 : spdm_test_context->case_id = 0xE;
1572 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1573 :
1574 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
1575 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1576 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1577 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1578 :
1579 1 : libspdm_reset_message_a(spdm_context);
1580 :
1581 1 : response_size = sizeof(response);
1582 1 : status = libspdm_get_response_algorithms (spdm_context,
1583 : m_libspdm_negotiate_algorithm_request10_size,
1584 : &m_libspdm_negotiate_algorithm_request10,
1585 : &response_size,
1586 : response);
1587 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1588 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1589 1 : spdm_response = (void *)response;
1590 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1591 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1592 1 : assert_int_equal (spdm_response->header.param2, 0);
1593 1 : }
1594 :
1595 1 : void libspdm_test_responder_algorithms_case15(void **state) {
1596 : libspdm_return_t status;
1597 : libspdm_test_context_t *spdm_test_context;
1598 : libspdm_context_t *spdm_context;
1599 : size_t response_size;
1600 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1601 : spdm_algorithms_response_t *spdm_response;
1602 :
1603 1 : spdm_test_context = *state;
1604 1 : spdm_context = spdm_test_context->spdm_context;
1605 1 : spdm_test_context->case_id = 0xF;
1606 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1607 :
1608 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1609 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1610 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1611 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1612 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1613 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1614 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1615 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1616 :
1617 1 : libspdm_reset_message_a(spdm_context);
1618 :
1619 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1620 1 : spdm_context->connection_info.capability.flags |=
1621 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1622 :
1623 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1624 1 : spdm_context->connection_info.capability.flags |=
1625 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1626 :
1627 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1628 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1629 :
1630 1 : spdm_context->local_context.capability.flags |=
1631 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1632 1 : spdm_context->connection_info.capability.flags |=
1633 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1634 :
1635 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1636 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1637 :
1638 1 : response_size = sizeof(response);
1639 1 : status = libspdm_get_response_algorithms (spdm_context,
1640 : m_libspdm_negotiate_algorithm_request11_size,
1641 : &m_libspdm_negotiate_algorithm_request11,
1642 : &response_size,
1643 : response);
1644 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1645 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1646 1 : spdm_response = (void *)response;
1647 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1648 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1649 1 : assert_int_equal (spdm_response->header.param2, 0);
1650 1 : }
1651 :
1652 1 : void libspdm_test_responder_algorithms_case16(void **state) {
1653 : libspdm_return_t status;
1654 : libspdm_test_context_t *spdm_test_context;
1655 : libspdm_context_t *spdm_context;
1656 : size_t response_size;
1657 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1658 : libspdm_algorithms_response_mine_t *spdm_response;
1659 :
1660 1 : spdm_test_context = *state;
1661 1 : spdm_context = spdm_test_context->spdm_context;
1662 1 : spdm_test_context->case_id = 0x10;
1663 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1664 :
1665 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1666 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1667 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1668 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1669 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1670 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1671 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1672 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1673 :
1674 1 : libspdm_reset_message_a(spdm_context);
1675 :
1676 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1677 1 : spdm_context->connection_info.capability.flags |=
1678 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1679 :
1680 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1681 1 : spdm_context->connection_info.capability.flags |=
1682 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1683 :
1684 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1685 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1686 :
1687 1 : spdm_context->local_context.capability.flags |=
1688 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1689 1 : spdm_context->connection_info.capability.flags |=
1690 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1691 :
1692 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1693 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1694 :
1695 1 : response_size = sizeof(response);
1696 1 : status = libspdm_get_response_algorithms (spdm_context,
1697 : m_libspdm_negotiate_algorithm_request12_size,
1698 : &m_libspdm_negotiate_algorithm_request12,
1699 : &response_size,
1700 : response);
1701 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1702 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1703 1 : spdm_response = (void*)response;
1704 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1705 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1706 1 : assert_int_equal(spdm_response->header.param2, 0);
1707 1 : }
1708 :
1709 1 : void libspdm_test_responder_algorithms_case17(void **state) {
1710 : libspdm_return_t status;
1711 : libspdm_test_context_t *spdm_test_context;
1712 : libspdm_context_t *spdm_context;
1713 : size_t response_size;
1714 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1715 : libspdm_algorithms_response_mine_t *spdm_response;
1716 :
1717 1 : spdm_test_context = *state;
1718 1 : spdm_context = spdm_test_context->spdm_context;
1719 1 : spdm_test_context->case_id = 0x11;
1720 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1721 :
1722 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1723 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1724 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1725 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1726 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1727 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1728 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1729 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1730 :
1731 1 : libspdm_reset_message_a(spdm_context);
1732 :
1733 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1734 1 : spdm_context->connection_info.capability.flags |=
1735 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1736 :
1737 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1738 1 : spdm_context->connection_info.capability.flags |=
1739 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1740 :
1741 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1742 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1743 :
1744 1 : spdm_context->local_context.capability.flags |=
1745 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1746 1 : spdm_context->connection_info.capability.flags |=
1747 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1748 :
1749 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1750 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1751 :
1752 1 : response_size = sizeof(response);
1753 1 : status = libspdm_get_response_algorithms (spdm_context,
1754 : m_libspdm_negotiate_algorithm_request13_size,
1755 : &m_libspdm_negotiate_algorithm_request13,
1756 : &response_size,
1757 : response);
1758 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1759 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1760 1 : spdm_response = (void*)response;
1761 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1762 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1763 1 : assert_int_equal(spdm_response->header.param2, 0);
1764 1 : }
1765 :
1766 1 : void libspdm_test_responder_algorithms_case18(void **state) {
1767 : libspdm_return_t status;
1768 : libspdm_test_context_t *spdm_test_context;
1769 : libspdm_context_t *spdm_context;
1770 : size_t response_size;
1771 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1772 : libspdm_algorithms_response_mine_t *spdm_response;
1773 :
1774 1 : spdm_test_context = *state;
1775 1 : spdm_context = spdm_test_context->spdm_context;
1776 1 : spdm_test_context->case_id = 0x12;
1777 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1778 :
1779 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1780 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1781 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1782 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1783 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1784 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1785 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1786 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1787 :
1788 1 : libspdm_reset_message_a(spdm_context);
1789 :
1790 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1791 1 : spdm_context->connection_info.capability.flags |=
1792 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1793 :
1794 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1795 1 : spdm_context->connection_info.capability.flags |=
1796 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1797 :
1798 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1799 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1800 :
1801 1 : spdm_context->local_context.capability.flags |=
1802 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1803 1 : spdm_context->connection_info.capability.flags |=
1804 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1805 :
1806 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1807 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1808 :
1809 1 : response_size = sizeof(response);
1810 1 : status = libspdm_get_response_algorithms (spdm_context,
1811 : m_libspdm_negotiate_algorithm_request14_size,
1812 : &m_libspdm_negotiate_algorithm_request14,
1813 : &response_size,
1814 : response);
1815 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1816 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
1817 1 : spdm_response = (void *)response;
1818 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
1819 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1820 1 : assert_int_equal (spdm_response->header.param2, 0);
1821 1 : }
1822 :
1823 1 : void libspdm_test_responder_algorithms_case19(void **state) {
1824 : libspdm_return_t status;
1825 : libspdm_test_context_t *spdm_test_context;
1826 : libspdm_context_t *spdm_context;
1827 : size_t response_size;
1828 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1829 : libspdm_algorithms_response_mine_t *spdm_response;
1830 :
1831 1 : spdm_test_context = *state;
1832 1 : spdm_context = spdm_test_context->spdm_context;
1833 1 : spdm_test_context->case_id = 0x13;
1834 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1835 :
1836 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1837 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1838 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1839 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1840 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1841 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1842 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1843 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1844 :
1845 1 : libspdm_reset_message_a(spdm_context);
1846 :
1847 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1848 1 : spdm_context->connection_info.capability.flags |=
1849 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1850 :
1851 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1852 1 : spdm_context->connection_info.capability.flags |=
1853 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1854 :
1855 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1856 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1857 :
1858 1 : spdm_context->local_context.capability.flags |=
1859 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1860 1 : spdm_context->connection_info.capability.flags |=
1861 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1862 :
1863 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1864 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1865 :
1866 1 : response_size = sizeof(response);
1867 1 : status = libspdm_get_response_algorithms (spdm_context,
1868 : m_libspdm_negotiate_algorithm_request15_size,
1869 : &m_libspdm_negotiate_algorithm_request15,
1870 : &response_size,
1871 : response);
1872 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1873 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1874 1 : spdm_response = (void*)response;
1875 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1876 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1877 1 : assert_int_equal(spdm_response->header.param2, 0);
1878 1 : }
1879 :
1880 : /* When both of requester and responder support multiple algorithms, then defaults to choose the strongest available algorithm*/
1881 1 : void libspdm_test_responder_algorithms_case20(void **state) {
1882 : libspdm_return_t status;
1883 : libspdm_test_context_t *spdm_test_context;
1884 : libspdm_context_t *spdm_context;
1885 : size_t response_size;
1886 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1887 : libspdm_algorithms_response_mine_t *spdm_response;
1888 :
1889 1 : spdm_test_context = *state;
1890 1 : spdm_context = spdm_test_context->spdm_context;
1891 1 : spdm_test_context->case_id = 0x14;
1892 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1893 :
1894 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1895 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1896 1 : spdm_context->local_context.algorithm.base_hash_algo =
1897 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512 |
1898 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256;
1899 1 : spdm_context->local_context.algorithm.base_asym_algo =
1900 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521 |
1901 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384 |
1902 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
1903 1 : spdm_context->local_context.algorithm.dhe_named_group =
1904 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_521_R1 |
1905 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_384_R1 |
1906 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1;
1907 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1908 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1909 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1910 :
1911 1 : libspdm_reset_message_a(spdm_context);
1912 :
1913 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1914 1 : spdm_context->connection_info.capability.flags |=
1915 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1916 :
1917 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
1918 1 : spdm_context->connection_info.capability.flags |=
1919 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
1920 :
1921 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
1922 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
1923 :
1924 1 : spdm_context->local_context.capability.flags |=
1925 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
1926 1 : spdm_context->connection_info.capability.flags |=
1927 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
1928 :
1929 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
1930 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
1931 :
1932 1 : response_size = sizeof(response);
1933 1 : status = libspdm_get_response_algorithms (spdm_context,
1934 : m_libspdm_negotiate_algorithm_request16_size,
1935 : &m_libspdm_negotiate_algorithm_request16,
1936 : &response_size,
1937 : response);
1938 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
1939 1 : assert_int_equal (response_size,
1940 : sizeof(spdm_algorithms_response_t)+4*
1941 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
1942 1 : spdm_response = (void *)response;
1943 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ALGORITHMS);
1944 1 : assert_int_equal (spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_11);
1945 :
1946 1 : assert_int_equal (spdm_response->base_hash_sel, SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512);
1947 1 : assert_int_equal (spdm_response->base_hash_sel,
1948 : spdm_context->connection_info.algorithm.base_hash_algo);
1949 :
1950 1 : assert_int_equal (spdm_response->base_asym_sel,
1951 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521);
1952 1 : assert_int_equal (spdm_response->base_asym_sel,
1953 : spdm_context->connection_info.algorithm.base_asym_algo);
1954 :
1955 1 : assert_int_equal (spdm_response->struct_table[0].alg_supported,
1956 : SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_384_R1);
1957 1 : assert_int_equal (spdm_response->struct_table[0].alg_supported,
1958 : spdm_context->connection_info.algorithm.dhe_named_group);
1959 :
1960 1 : assert_int_equal (spdm_response->struct_table[1].alg_supported,
1961 : spdm_context->connection_info.algorithm.aead_cipher_suite);
1962 1 : assert_int_equal (spdm_response->struct_table[2].alg_supported,
1963 : spdm_context->connection_info.algorithm.req_base_asym_alg);
1964 1 : assert_int_equal (spdm_response->struct_table[3].alg_supported,
1965 : spdm_context->connection_info.algorithm.key_schedule);
1966 1 : }
1967 :
1968 1 : void libspdm_test_responder_algorithms_case21(void **state) {
1969 : libspdm_return_t status;
1970 : libspdm_test_context_t *spdm_test_context;
1971 : libspdm_context_t *spdm_context;
1972 : size_t response_size;
1973 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1974 : libspdm_algorithms_response_mine_t *spdm_response;
1975 : size_t arbitrary_size;
1976 :
1977 1 : spdm_test_context = *state;
1978 1 : spdm_context = spdm_test_context->spdm_context;
1979 1 : spdm_test_context->case_id = 0x15;
1980 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
1981 :
1982 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_11 <<
1983 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1984 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1985 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1986 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
1987 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
1988 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
1989 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
1990 :
1991 1 : libspdm_reset_message_a(spdm_context);
1992 :
1993 1 : spdm_context->local_context.capability.flags |=
1994 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
1995 1 : spdm_context->connection_info.capability.flags |=
1996 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
1997 :
1998 1 : spdm_context->local_context.capability.flags |=
1999 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2000 1 : spdm_context->connection_info.capability.flags |=
2001 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2002 :
2003 1 : spdm_context->local_context.capability.flags |=
2004 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2005 1 : spdm_context->connection_info.capability.flags |=
2006 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2007 :
2008 1 : spdm_context->local_context.capability.flags |=
2009 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2010 1 : spdm_context->connection_info.capability.flags |=
2011 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2012 :
2013 1 : spdm_context->local_context.capability.flags |=
2014 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2015 1 : spdm_context->connection_info.capability.flags |=
2016 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2017 :
2018 : /*filling A with arbitrary data*/
2019 1 : arbitrary_size = 10;
2020 1 : libspdm_set_mem(spdm_context->transcript.message_a.buffer, arbitrary_size, (uint8_t) 0xFF);
2021 1 : spdm_context->transcript.message_a.buffer_size = arbitrary_size;
2022 :
2023 1 : response_size = sizeof(response);
2024 1 : status = libspdm_get_response_algorithms(
2025 : spdm_context,
2026 : m_libspdm_negotiate_algorithm_request3_size, &m_libspdm_negotiate_algorithm_request3,
2027 : &response_size, response);
2028 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2029 1 : assert_int_equal(response_size,
2030 : sizeof(spdm_algorithms_response_t) +
2031 : 4*sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2032 1 : spdm_response = (void *)response;
2033 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
2034 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_11);
2035 :
2036 1 : assert_int_equal(spdm_response->struct_table[0].alg_supported,
2037 : spdm_context->local_context.algorithm.dhe_named_group);
2038 1 : assert_int_equal(spdm_response->struct_table[1].alg_supported,
2039 : spdm_context->local_context.algorithm.aead_cipher_suite);
2040 1 : assert_int_equal(spdm_response->struct_table[2].alg_supported,
2041 : spdm_context->local_context.algorithm.req_base_asym_alg);
2042 1 : assert_int_equal(spdm_response->struct_table[3].alg_supported,
2043 : spdm_context->local_context.algorithm.key_schedule);
2044 :
2045 1 : assert_int_equal(spdm_context->transcript.message_a.buffer_size,
2046 : arbitrary_size + m_libspdm_negotiate_algorithm_request3_size + response_size);
2047 1 : assert_memory_equal(spdm_context->transcript.message_a.buffer + arbitrary_size,
2048 : &m_libspdm_negotiate_algorithm_request3,
2049 : m_libspdm_negotiate_algorithm_request3_size);
2050 1 : assert_memory_equal(spdm_context->transcript.message_a.buffer + arbitrary_size +
2051 : m_libspdm_negotiate_algorithm_request3_size, response, response_size);
2052 1 : }
2053 :
2054 1 : void libspdm_test_responder_algorithms_case22(void **state)
2055 : {
2056 : libspdm_return_t status;
2057 : libspdm_test_context_t *spdm_test_context;
2058 : libspdm_context_t *spdm_context;
2059 : size_t response_size;
2060 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2061 : libspdm_algorithms_response_mine_t *spdm_response;
2062 :
2063 1 : spdm_test_context = *state;
2064 1 : spdm_context = spdm_test_context->spdm_context;
2065 1 : spdm_test_context->case_id = 0x16;
2066 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2067 :
2068 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2069 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2070 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2071 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2072 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2073 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2074 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2075 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2076 1 : spdm_context->local_context.algorithm.other_params_support =
2077 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
2078 : /* spdm_context->connection_info.algorithm.other_params_support = SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1; */
2079 1 : libspdm_reset_message_a(spdm_context);
2080 1 : spdm_context->local_context.capability.flags = 0;
2081 1 : spdm_context->connection_info.capability.flags = 0;
2082 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2083 1 : spdm_context->connection_info.capability.flags |=
2084 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2085 :
2086 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2087 1 : spdm_context->connection_info.capability.flags |=
2088 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2089 :
2090 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2091 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2092 :
2093 1 : spdm_context->local_context.capability.flags |=
2094 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2095 1 : spdm_context->connection_info.capability.flags |=
2096 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2097 :
2098 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2099 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2100 :
2101 1 : response_size = sizeof(response);
2102 1 : status = libspdm_get_response_algorithms (spdm_context,
2103 : m_libspdm_negotiate_algorithm_request17_size,
2104 : &m_libspdm_negotiate_algorithm_request17,
2105 : &response_size,
2106 : response);
2107 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2108 1 : assert_int_equal (response_size,
2109 : sizeof(spdm_algorithms_response_t)+4*
2110 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2111 1 : spdm_response = (void *)response;
2112 1 : assert_int_equal (spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
2113 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ALGORITHMS);
2114 1 : assert_int_equal(spdm_response->header.param1, 4);
2115 1 : assert_int_equal (spdm_response->struct_table[0].alg_supported,
2116 : spdm_context->local_context.algorithm.dhe_named_group);
2117 1 : assert_int_equal (spdm_response->struct_table[1].alg_supported,
2118 : spdm_context->local_context.algorithm.aead_cipher_suite);
2119 1 : assert_int_equal (spdm_response->struct_table[2].alg_supported,
2120 : spdm_context->local_context.algorithm.req_base_asym_alg);
2121 1 : assert_int_equal (spdm_response->struct_table[3].alg_supported,
2122 : spdm_context->local_context.algorithm.key_schedule);
2123 1 : }
2124 :
2125 1 : void libspdm_test_responder_algorithms_case23(void **state)
2126 : {
2127 : libspdm_return_t status;
2128 : libspdm_test_context_t *spdm_test_context;
2129 : libspdm_context_t *spdm_context;
2130 : size_t response_size;
2131 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2132 : spdm_algorithms_response_t *spdm_response;
2133 :
2134 1 : spdm_test_context = *state;
2135 1 : spdm_context = spdm_test_context->spdm_context;
2136 1 : spdm_test_context->case_id = 0x17;
2137 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2138 :
2139 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2140 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2141 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2142 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2143 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2144 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2145 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2146 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2147 1 : libspdm_reset_message_a(spdm_context);
2148 1 : spdm_context->local_context.capability.flags = 0;
2149 1 : spdm_context->connection_info.capability.flags = 0;
2150 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2151 1 : spdm_context->connection_info.capability.flags |=
2152 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2153 :
2154 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2155 1 : spdm_context->connection_info.capability.flags |=
2156 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2157 :
2158 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2159 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2160 :
2161 1 : spdm_context->local_context.capability.flags |=
2162 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2163 1 : spdm_context->connection_info.capability.flags |=
2164 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2165 :
2166 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2167 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2168 :
2169 : /* Sub Case 1: other_params_support set OpaqueDataFmt1 */
2170 1 : m_libspdm_negotiate_algorithm_request18.spdm_request_version10.other_params_support =
2171 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
2172 1 : spdm_context->local_context.algorithm.other_params_support =
2173 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
2174 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2175 1 : libspdm_reset_message_a(spdm_context);
2176 :
2177 1 : response_size = sizeof(response);
2178 1 : status = libspdm_get_response_algorithms (spdm_context,
2179 : m_libspdm_negotiate_algorithm_request18_size,
2180 : &m_libspdm_negotiate_algorithm_request18,
2181 : &response_size,
2182 : response);
2183 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2184 1 : assert_int_equal(response_size,
2185 : sizeof(spdm_algorithms_response_t) + 4*
2186 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2187 1 : spdm_response = (void *)response;
2188 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
2189 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
2190 1 : assert_int_equal(spdm_response->other_params_selection, SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
2191 1 : assert_int_equal(spdm_context->connection_info.algorithm.other_params_support,
2192 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
2193 :
2194 : /* Sub Case 2: Populate reserved field for version 1.2.
2195 : * Field values marked as Reserved shall be written as zero (0). */
2196 1 : spdm_context->local_context.algorithm.other_params_support =
2197 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1 |
2198 : SPDM_ALGORITHMS_MULTI_KEY_CONN;
2199 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2200 1 : libspdm_reset_message_a(spdm_context);
2201 1 : response_size = sizeof(response);
2202 1 : status = libspdm_get_response_algorithms (spdm_context,
2203 : m_libspdm_negotiate_algorithm_request18_size,
2204 : &m_libspdm_negotiate_algorithm_request18,
2205 : &response_size,
2206 : response);
2207 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2208 1 : assert_int_equal(response_size,
2209 : sizeof(spdm_algorithms_response_t) + 4*
2210 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2211 1 : spdm_response = (void *)response;
2212 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
2213 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
2214 1 : assert_int_equal(spdm_response->other_params_selection, SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
2215 1 : assert_int_equal(spdm_context->connection_info.algorithm.other_params_support,
2216 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
2217 :
2218 : /* Sub Case 3: OpaqueDataFmt. Supports both SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0 and
2219 : * SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1. */
2220 1 : m_libspdm_negotiate_algorithm_request18.spdm_request_version10.other_params_support =
2221 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0 |
2222 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
2223 1 : spdm_context->local_context.algorithm.other_params_support =
2224 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0 |
2225 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
2226 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2227 1 : libspdm_reset_message_a(spdm_context);
2228 1 : response_size = sizeof(response);
2229 1 : status = libspdm_get_response_algorithms (spdm_context,
2230 : m_libspdm_negotiate_algorithm_request18_size,
2231 : &m_libspdm_negotiate_algorithm_request18,
2232 : &response_size,
2233 : response);
2234 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2235 1 : assert_int_equal(response_size,
2236 : sizeof(spdm_algorithms_response_t) + 4*
2237 : sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2238 1 : spdm_response = (void *)response;
2239 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
2240 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ALGORITHMS);
2241 1 : assert_int_equal(spdm_response->other_params_selection, SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
2242 1 : assert_int_equal(spdm_context->connection_info.algorithm.other_params_support,
2243 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1);
2244 1 : }
2245 :
2246 1 : void libspdm_test_responder_algorithms_case24(void **state)
2247 : {
2248 : libspdm_return_t status;
2249 : libspdm_test_context_t *spdm_test_context;
2250 : libspdm_context_t *spdm_context;
2251 : size_t response_size;
2252 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2253 : spdm_algorithms_response_t *spdm_response;
2254 :
2255 1 : spdm_test_context = *state;
2256 1 : spdm_context = spdm_test_context->spdm_context;
2257 1 : spdm_test_context->case_id = 0x18;
2258 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2259 :
2260 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2261 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2262 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2263 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2264 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2265 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2266 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2267 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2268 1 : spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2269 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2270 : m_libspdm_use_measurement_hash_algo;
2271 1 : libspdm_reset_message_a(spdm_context);
2272 1 : spdm_context->local_context.capability.flags =
2273 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2274 1 : spdm_context->connection_info.capability.flags = 0;
2275 :
2276 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2277 1 : spdm_context->connection_info.capability.flags |=
2278 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2279 :
2280 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2281 1 : spdm_context->connection_info.capability.flags |=
2282 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2283 :
2284 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2285 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2286 :
2287 1 : spdm_context->local_context.capability.flags |=
2288 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2289 1 : spdm_context->connection_info.capability.flags |=
2290 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2291 :
2292 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2293 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2294 :
2295 1 : response_size = sizeof(response);
2296 1 : status = libspdm_get_response_algorithms (spdm_context,
2297 : m_libspdm_negotiate_algorithm_request24_size,
2298 : &m_libspdm_negotiate_algorithm_request24,
2299 : &response_size,
2300 : response);
2301 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2302 1 : assert_int_equal(response_size,
2303 : sizeof(spdm_algorithms_response_t) +
2304 : 4*sizeof(spdm_negotiate_algorithms_common_struct_table_t));
2305 1 : spdm_response = (void *)response;
2306 1 : assert_int_equal(spdm_response->header.request_response_code,
2307 : SPDM_ALGORITHMS);
2308 1 : assert_int_equal(spdm_response->measurement_hash_algo, 0);
2309 1 : assert_int_equal(spdm_response->measurement_specification_sel, 0);
2310 1 : }
2311 :
2312 1 : void libspdm_test_responder_algorithms_case25(void **state)
2313 : {
2314 : libspdm_return_t status;
2315 : libspdm_test_context_t *spdm_test_context;
2316 : libspdm_context_t *spdm_context;
2317 : size_t response_size;
2318 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2319 : spdm_algorithms_response_t *spdm_response;
2320 :
2321 1 : spdm_test_context = *state;
2322 1 : spdm_context = spdm_test_context->spdm_context;
2323 1 : spdm_test_context->case_id = 0x19;
2324 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2325 :
2326 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2327 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2328 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2329 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2330 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2331 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2332 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2333 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2334 1 : spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2335 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2336 : m_libspdm_use_measurement_hash_algo;
2337 1 : libspdm_reset_message_a(spdm_context);
2338 1 : spdm_context->local_context.capability.flags =
2339 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2340 1 : spdm_context->connection_info.capability.flags = 0;
2341 :
2342 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2343 1 : spdm_context->connection_info.capability.flags |=
2344 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2345 :
2346 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2347 1 : spdm_context->connection_info.capability.flags |=
2348 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2349 :
2350 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2351 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2352 :
2353 1 : spdm_context->local_context.capability.flags |=
2354 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2355 1 : spdm_context->connection_info.capability.flags |=
2356 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2357 :
2358 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2359 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2360 :
2361 1 : response_size = sizeof(response);
2362 1 : status = libspdm_get_response_algorithms (spdm_context,
2363 : m_libspdm_negotiate_algorithm_request25_size,
2364 : &m_libspdm_negotiate_algorithm_request25,
2365 : &response_size,
2366 : response);
2367 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2368 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2369 1 : spdm_response = (void *)response;
2370 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
2371 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2372 1 : assert_int_equal (spdm_response->header.param2, 0);
2373 1 : }
2374 :
2375 1 : void libspdm_test_responder_algorithms_case26(void **state)
2376 : {
2377 : libspdm_return_t status;
2378 : libspdm_test_context_t *spdm_test_context;
2379 : libspdm_context_t *spdm_context;
2380 : size_t response_size;
2381 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2382 : spdm_algorithms_response_t *spdm_response;
2383 :
2384 1 : spdm_test_context = *state;
2385 1 : spdm_context = spdm_test_context->spdm_context;
2386 1 : spdm_test_context->case_id = 0x1A;
2387 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2388 :
2389 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2390 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2391 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2392 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2393 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2394 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2395 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2396 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2397 1 : spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2398 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2399 : m_libspdm_use_measurement_hash_algo;
2400 1 : libspdm_reset_message_a(spdm_context);
2401 1 : spdm_context->local_context.capability.flags =
2402 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2403 1 : spdm_context->connection_info.capability.flags = 0;
2404 :
2405 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2406 1 : spdm_context->connection_info.capability.flags |=
2407 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2408 :
2409 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2410 1 : spdm_context->connection_info.capability.flags |=
2411 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2412 :
2413 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2414 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2415 :
2416 1 : spdm_context->local_context.capability.flags |=
2417 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2418 1 : spdm_context->connection_info.capability.flags |=
2419 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2420 :
2421 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2422 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2423 :
2424 1 : response_size = sizeof(response);
2425 1 : status = libspdm_get_response_algorithms (spdm_context,
2426 : m_libspdm_negotiate_algorithm_request26_size,
2427 : &m_libspdm_negotiate_algorithm_request26,
2428 : &response_size,
2429 : response);
2430 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2431 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2432 1 : spdm_response = (void *)response;
2433 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
2434 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2435 1 : assert_int_equal (spdm_response->header.param2, 0);
2436 1 : }
2437 :
2438 1 : void libspdm_test_responder_algorithms_case27(void **state)
2439 : {
2440 : libspdm_return_t status;
2441 : libspdm_test_context_t *spdm_test_context;
2442 : libspdm_context_t *spdm_context;
2443 : size_t response_size;
2444 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2445 : spdm_algorithms_response_t *spdm_response;
2446 :
2447 1 : spdm_test_context = *state;
2448 1 : spdm_context = spdm_test_context->spdm_context;
2449 1 : spdm_test_context->case_id = 0x1B;
2450 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2451 :
2452 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2453 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2454 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2455 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2456 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2457 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2458 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2459 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2460 1 : spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2461 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2462 : m_libspdm_use_measurement_hash_algo;
2463 1 : libspdm_reset_message_a(spdm_context);
2464 1 : spdm_context->local_context.capability.flags =
2465 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2466 1 : spdm_context->connection_info.capability.flags = 0;
2467 :
2468 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2469 1 : spdm_context->connection_info.capability.flags |=
2470 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2471 :
2472 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2473 1 : spdm_context->connection_info.capability.flags |=
2474 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2475 :
2476 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2477 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2478 :
2479 1 : spdm_context->local_context.capability.flags |=
2480 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2481 1 : spdm_context->connection_info.capability.flags |=
2482 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2483 :
2484 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2485 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2486 :
2487 1 : response_size = sizeof(response);
2488 1 : status = libspdm_get_response_algorithms (spdm_context,
2489 : m_libspdm_negotiate_algorithm_request27_size,
2490 : &m_libspdm_negotiate_algorithm_request27,
2491 : &response_size,
2492 : response);
2493 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2494 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2495 1 : spdm_response = (void *)response;
2496 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
2497 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2498 1 : assert_int_equal (spdm_response->header.param2, 0);
2499 1 : }
2500 :
2501 1 : void libspdm_test_responder_algorithms_case28(void **state)
2502 : {
2503 : libspdm_return_t status;
2504 : libspdm_test_context_t *spdm_test_context;
2505 : libspdm_context_t *spdm_context;
2506 : size_t response_size;
2507 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2508 : spdm_algorithms_response_t *spdm_response;
2509 :
2510 1 : spdm_test_context = *state;
2511 1 : spdm_context = spdm_test_context->spdm_context;
2512 1 : spdm_test_context->case_id = 0x1C;
2513 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2514 :
2515 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2516 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2517 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2518 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2519 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2520 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2521 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2522 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2523 1 : spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2524 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2525 : m_libspdm_use_measurement_hash_algo;
2526 1 : libspdm_reset_message_a(spdm_context);
2527 1 : spdm_context->local_context.capability.flags =
2528 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2529 1 : spdm_context->connection_info.capability.flags = 0;
2530 :
2531 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP;
2532 1 : spdm_context->connection_info.capability.flags |=
2533 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
2534 :
2535 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP;
2536 1 : spdm_context->connection_info.capability.flags |=
2537 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
2538 :
2539 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP;
2540 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP;
2541 :
2542 1 : spdm_context->local_context.capability.flags |=
2543 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP;
2544 1 : spdm_context->connection_info.capability.flags |=
2545 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
2546 :
2547 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP;
2548 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP;
2549 :
2550 1 : response_size = sizeof(response);
2551 1 : status = libspdm_get_response_algorithms (spdm_context,
2552 : m_libspdm_negotiate_algorithm_request28_size,
2553 : &m_libspdm_negotiate_algorithm_request28,
2554 : &response_size,
2555 : response);
2556 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2557 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2558 1 : spdm_response = (void *)response;
2559 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
2560 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2561 1 : assert_int_equal (spdm_response->header.param2, 0);
2562 1 : }
2563 :
2564 1 : void libspdm_test_responder_algorithms_case29(void **state)
2565 : {
2566 : libspdm_return_t status;
2567 : libspdm_test_context_t *spdm_test_context;
2568 : libspdm_context_t *spdm_context;
2569 : size_t response_size;
2570 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2571 : spdm_algorithms_response_t *spdm_response;
2572 :
2573 1 : spdm_test_context = *state;
2574 1 : spdm_context = spdm_test_context->spdm_context;
2575 1 : spdm_test_context->case_id = 0x1C;
2576 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2577 :
2578 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
2579 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2580 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2581 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2582 1 : spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
2583 1 : spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
2584 1 : spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
2585 1 : spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
2586 1 : spdm_context->local_context.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
2587 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2588 : m_libspdm_use_measurement_hash_algo;
2589 1 : libspdm_reset_message_a(spdm_context);
2590 :
2591 1 : response_size = sizeof(response);
2592 1 : status = libspdm_get_response_algorithms (spdm_context,
2593 : m_libspdm_negotiate_algorithm_request29_size,
2594 : &m_libspdm_negotiate_algorithm_request29,
2595 : &response_size,
2596 : response);
2597 1 : assert_int_equal (status, LIBSPDM_STATUS_SUCCESS);
2598 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2599 1 : spdm_response = (void *)response;
2600 1 : assert_int_equal (spdm_response->header.request_response_code, SPDM_ERROR);
2601 1 : assert_int_equal (spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
2602 1 : assert_int_equal (spdm_response->header.param2, 0);
2603 1 : }
2604 :
2605 : /**
2606 : * Test 30: MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP value calculation
2607 : * +---------------+--------------------------+--------------------+
2608 : * | MULTI_KEY_CAP | RequesterMultiKeyConnSel | MULTI_KEY_CONN_REQ |
2609 : * +---------------+--------------------------+--------------------+
2610 : * | 00b | 0 | false |
2611 : * ----------------------------------------------------------------
2612 : * | 00b | 1 | invalid |
2613 : * ----------------------------------------------------------------
2614 : * | 01b | 0 | invalid |
2615 : * ----------------------------------------------------------------
2616 : * | 01b | 1 | true |
2617 : * ----------------------------------------------------------------
2618 : * | 10b | 0 | false |
2619 : * ----------------------------------------------------------------
2620 : * | 10b | 1 | true |
2621 : * +---------------+--------------------------+--------------------+
2622 : * | MULTI_KEY_CAP | ResponderMultiKeyConn | MULTI_KEY_CONN_RSP |
2623 : * +---------------+--------------------------+--------------------+
2624 : * | 00b | 0 | false |
2625 : * ----------------------------------------------------------------
2626 : * | 00b | 1 | invalid |
2627 : * ----------------------------------------------------------------
2628 : * | 01b | 0 | invalid |
2629 : * ----------------------------------------------------------------
2630 : * | 01b | 1 | true |
2631 : * ----------------------------------------------------------------
2632 : * | 10b | 0 | false |
2633 : * ----------------------------------------------------------------
2634 : * | 10b | 1 | true |
2635 : * ----------------------------------------------------------------
2636 : **/
2637 1 : void libspdm_test_responder_algorithms_case30(void **state)
2638 : {
2639 : libspdm_return_t status;
2640 : libspdm_test_context_t *spdm_test_context;
2641 : libspdm_context_t *spdm_context;
2642 : size_t response_size;
2643 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2644 : spdm_algorithms_response_t *spdm_response;
2645 :
2646 1 : spdm_test_context = *state;
2647 1 : spdm_context = spdm_test_context->spdm_context;
2648 1 : spdm_test_context->case_id = 0x1D;
2649 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2650 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2651 :
2652 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2653 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2654 1 : spdm_context->local_context.algorithm.measurement_hash_algo = 0;
2655 1 : spdm_context->local_context.algorithm.measurement_spec = 0;
2656 1 : spdm_context->local_context.capability.flags = 0;
2657 :
2658 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2659 1 : libspdm_reset_message_a(spdm_context);
2660 :
2661 1 : spdm_context->local_context.capability.flags = 0;
2662 1 : spdm_context->local_context.algorithm.other_params_support = 0;
2663 1 : spdm_context->connection_info.capability.flags = 0;
2664 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
2665 :
2666 1 : response_size = sizeof(response);
2667 1 : status = libspdm_get_response_algorithms(
2668 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2669 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2670 : response);
2671 :
2672 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2673 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2674 1 : spdm_response = (void *)response;
2675 1 : assert_int_equal(spdm_response->header.request_response_code,
2676 : SPDM_ALGORITHMS);
2677 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, false);
2678 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_req, false);
2679 :
2680 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2681 1 : libspdm_reset_message_a(spdm_context);
2682 :
2683 1 : spdm_context->local_context.capability.flags = 0;
2684 1 : spdm_context->local_context.algorithm.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
2685 1 : spdm_context->connection_info.capability.flags = 0;
2686 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
2687 :
2688 1 : response_size = sizeof(response);
2689 1 : status = libspdm_get_response_algorithms(
2690 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2691 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2692 : response);
2693 : /* MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP invalid */
2694 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2695 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2696 1 : spdm_response = (void *)response;
2697 1 : assert_int_equal(spdm_response->header.request_response_code,
2698 : SPDM_ERROR);
2699 :
2700 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2701 1 : libspdm_reset_message_a(spdm_context);
2702 :
2703 1 : spdm_context->local_context.capability.flags =
2704 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_ONLY;
2705 1 : spdm_context->local_context.algorithm.other_params_support = 0;
2706 1 : spdm_context->connection_info.capability.flags =
2707 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY;
2708 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
2709 :
2710 1 : response_size = sizeof(response);
2711 1 : status = libspdm_get_response_algorithms(
2712 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2713 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2714 : response);
2715 : /* MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP invalid */
2716 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2717 1 : assert_int_equal (response_size, sizeof(spdm_error_response_t));
2718 1 : spdm_response = (void *)response;
2719 1 : assert_int_equal(spdm_response->header.request_response_code,
2720 : SPDM_ERROR);
2721 :
2722 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2723 1 : libspdm_reset_message_a(spdm_context);
2724 :
2725 1 : spdm_context->local_context.capability.flags =
2726 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_ONLY;
2727 1 : spdm_context->local_context.algorithm.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
2728 1 : spdm_context->connection_info.capability.flags =
2729 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY;
2730 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
2731 :
2732 1 : response_size = sizeof(response);
2733 1 : status = libspdm_get_response_algorithms(
2734 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2735 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2736 : response);
2737 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2738 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2739 1 : spdm_response = (void *)response;
2740 1 : assert_int_equal(spdm_response->header.request_response_code,
2741 : SPDM_ALGORITHMS);
2742 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, true);
2743 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_req, true);
2744 :
2745 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2746 1 : libspdm_reset_message_a(spdm_context);
2747 :
2748 1 : spdm_context->local_context.capability.flags =
2749 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_NEG;
2750 1 : spdm_context->local_context.algorithm.other_params_support = 0;
2751 1 : spdm_context->connection_info.capability.flags =
2752 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_NEG;
2753 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
2754 :
2755 1 : response_size = sizeof(response);
2756 1 : status = libspdm_get_response_algorithms(
2757 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2758 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2759 : response);
2760 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2761 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2762 1 : spdm_response = (void *)response;
2763 1 : assert_int_equal(spdm_response->header.request_response_code,
2764 : SPDM_ALGORITHMS);
2765 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, false);
2766 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_req, false);
2767 :
2768 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2769 1 : libspdm_reset_message_a(spdm_context);
2770 :
2771 1 : spdm_context->local_context.capability.flags =
2772 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MULTI_KEY_CAP_NEG;
2773 1 : spdm_context->local_context.algorithm.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
2774 1 : spdm_context->connection_info.capability.flags =
2775 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_NEG;
2776 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = SPDM_ALGORITHMS_MULTI_KEY_CONN;
2777 :
2778 1 : response_size = sizeof(response);
2779 1 : status = libspdm_get_response_algorithms(
2780 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2781 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2782 : response);
2783 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2784 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2785 1 : spdm_response = (void *)response;
2786 1 : assert_int_equal(spdm_response->header.request_response_code,
2787 : SPDM_ALGORITHMS);
2788 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_rsp, true);
2789 1 : assert_int_equal(spdm_context->connection_info.multi_key_conn_req, true);
2790 1 : }
2791 :
2792 :
2793 : /**
2794 : * Test 31: NEGOTIATE_ALGORITHMS message received with MEL correct
2795 : * Expected Behavior: get a RETURN_SUCCESS return code
2796 : **/
2797 1 : void libspdm_test_responder_algorithms_case31(void **state)
2798 : {
2799 : libspdm_return_t status;
2800 : libspdm_test_context_t *spdm_test_context;
2801 : libspdm_context_t *spdm_context;
2802 : size_t response_size;
2803 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2804 : spdm_algorithms_response_t *spdm_response;
2805 :
2806 1 : spdm_test_context = *state;
2807 1 : spdm_context = spdm_test_context->spdm_context;
2808 1 : spdm_test_context->case_id = 0x1E;
2809 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
2810 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2811 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2812 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2813 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2814 1 : spdm_context->local_context.algorithm.measurement_hash_algo = 0;
2815 1 : spdm_context->local_context.algorithm.measurement_spec = 0;
2816 1 : spdm_context->local_context.capability.flags = 0;
2817 1 : spdm_context->local_context.algorithm.other_params_support = 0;
2818 1 : spdm_context->local_context.algorithm.mel_spec = SPDM_MEL_SPECIFICATION_DMTF;
2819 1 : libspdm_reset_message_a(spdm_context);
2820 :
2821 : /* Sub Case 1: MEL_CAP set 1, mel_specification set SPDM_MEL_SPECIFICATION_DMTF*/
2822 1 : m_libspdm_negotiate_algorithms_request30.other_params_support = 0;
2823 1 : m_libspdm_negotiate_algorithms_request30.mel_specification = SPDM_MEL_SPECIFICATION_DMTF;
2824 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
2825 :
2826 1 : response_size = sizeof(response);
2827 1 : status = libspdm_get_response_algorithms(
2828 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2829 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2830 : response);
2831 :
2832 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2833 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2834 1 : spdm_response = (void *)response;
2835 1 : assert_int_equal(spdm_response->header.request_response_code,
2836 : SPDM_ALGORITHMS);
2837 1 : assert_int_equal(spdm_response->mel_specification_sel, SPDM_MEL_SPECIFICATION_DMTF);
2838 1 : assert_int_equal(spdm_context->connection_info.algorithm.mel_spec, SPDM_MEL_SPECIFICATION_DMTF);
2839 :
2840 : /* Sub Case 2: MEL_CAP set 0, mel_specification set SPDM_MEL_SPECIFICATION_DMTF*/
2841 1 : m_libspdm_negotiate_algorithms_request30.mel_specification = SPDM_MEL_SPECIFICATION_DMTF;
2842 1 : spdm_context->local_context.capability.flags = 0;
2843 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2844 1 : libspdm_reset_message_a(spdm_context);
2845 :
2846 1 : response_size = sizeof(response);
2847 1 : status = libspdm_get_response_algorithms(
2848 : spdm_context, m_libspdm_negotiate_algorithms_request30_size,
2849 : &m_libspdm_negotiate_algorithms_request30, &response_size,
2850 : response);
2851 :
2852 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2853 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2854 1 : spdm_response = (void *)response;
2855 1 : assert_int_equal(spdm_response->header.request_response_code,
2856 : SPDM_ALGORITHMS);
2857 1 : assert_int_equal(spdm_response->mel_specification_sel, 0);
2858 1 : assert_int_equal(spdm_context->connection_info.algorithm.mel_spec, 0);
2859 1 : }
2860 :
2861 : /**
2862 : * Test 32: NEGOTIATE_ALGORITHMS message received with MEAS correct
2863 : * Expected Behavior: get a RETURN_SUCCESS return code
2864 : **/
2865 1 : void libspdm_test_responder_algorithms_case32(void **state)
2866 : {
2867 : libspdm_return_t status;
2868 : libspdm_test_context_t *spdm_test_context;
2869 : libspdm_context_t *spdm_context;
2870 : size_t response_size;
2871 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
2872 : spdm_algorithms_response_t *spdm_response;
2873 :
2874 1 : spdm_test_context = *state;
2875 1 : spdm_context = spdm_test_context->spdm_context;
2876 1 : spdm_test_context->case_id = 0x1F;
2877 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_10 <<
2878 : SPDM_VERSION_NUMBER_SHIFT_BIT;
2879 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2880 1 : spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
2881 1 : spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
2882 1 : spdm_context->local_context.algorithm.measurement_spec = 0;
2883 1 : spdm_context->local_context.algorithm.measurement_spec |= SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2884 1 : spdm_context->local_context.capability.flags = 0;
2885 1 : spdm_context->local_context.algorithm.other_params_support = 0;
2886 1 : libspdm_reset_message_a(spdm_context);
2887 :
2888 : /* Sub Case 1: MEL_CAP set 1, measurement_spec set SPDM_MEASUREMENT_SPECIFICATION_DMTF*/
2889 1 : spdm_context->local_context.capability.flags |=
2890 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_SIG;
2891 1 : spdm_context->local_context.algorithm.measurement_spec |= SPDM_MEASUREMENT_SPECIFICATION_DMTF;
2892 1 : spdm_context->local_context.algorithm.measurement_hash_algo =
2893 : m_libspdm_use_measurement_hash_algo;
2894 :
2895 1 : response_size = sizeof(response);
2896 1 : status = libspdm_get_response_algorithms(
2897 : spdm_context, m_libspdm_negotiate_algorithms_request1_size,
2898 : &m_libspdm_negotiate_algorithms_request1, &response_size,
2899 : response);
2900 :
2901 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2902 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2903 1 : spdm_response = (void *)response;
2904 1 : assert_int_equal(spdm_response->header.request_response_code,
2905 : SPDM_ALGORITHMS);
2906 1 : assert_int_equal(spdm_response->measurement_specification_sel,
2907 : SPDM_MEASUREMENT_SPECIFICATION_DMTF);
2908 1 : assert_int_equal(spdm_context->connection_info.algorithm.measurement_spec,
2909 : SPDM_MEASUREMENT_SPECIFICATION_DMTF);
2910 :
2911 : /* Sub Case 2: MEL_CAP set 0, measurement_spec set 0*/
2912 1 : spdm_context->local_context.capability.flags = 0;
2913 1 : spdm_context->local_context.algorithm.measurement_hash_algo = 0;
2914 1 : spdm_context->local_context.algorithm.measurement_spec = 0;
2915 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
2916 1 : m_libspdm_negotiate_algorithms_request1.measurement_specification = 0;
2917 1 : libspdm_reset_message_a(spdm_context);
2918 :
2919 1 : response_size = sizeof(response);
2920 1 : status = libspdm_get_response_algorithms(
2921 : spdm_context, m_libspdm_negotiate_algorithms_request1_size,
2922 : &m_libspdm_negotiate_algorithms_request1, &response_size,
2923 : response);
2924 :
2925 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
2926 1 : assert_int_equal(response_size, sizeof(spdm_algorithms_response_t));
2927 1 : spdm_response = (void *)response;
2928 1 : assert_int_equal(spdm_response->header.request_response_code,
2929 : SPDM_ALGORITHMS);
2930 1 : assert_int_equal(spdm_response->measurement_specification_sel, 0);
2931 1 : assert_int_equal(spdm_context->connection_info.algorithm.measurement_spec, 0);
2932 1 : }
2933 :
2934 1 : int libspdm_responder_algorithms_test_main(void)
2935 : {
2936 1 : const struct CMUnitTest spdm_responder_algorithms_tests[] = {
2937 : /* Success Case*/
2938 : cmocka_unit_test(libspdm_test_responder_algorithms_case1),
2939 : /* Bad request size*/
2940 : cmocka_unit_test(libspdm_test_responder_algorithms_case2),
2941 : /* response_state: LIBSPDM_RESPONSE_STATE_BUSY*/
2942 : cmocka_unit_test(libspdm_test_responder_algorithms_case3),
2943 : /* response_state: LIBSPDM_RESPONSE_STATE_NEED_RESYNC*/
2944 : cmocka_unit_test(libspdm_test_responder_algorithms_case4),
2945 : /* connection_state Check*/
2946 : cmocka_unit_test(libspdm_test_responder_algorithms_case6),
2947 : /* Success case V1.1*/
2948 : cmocka_unit_test(libspdm_test_responder_algorithms_case7),
2949 : /* No match for base_asym_algo*/
2950 : cmocka_unit_test(libspdm_test_responder_algorithms_case8),
2951 : /* No match for base_hash_algo*/
2952 : cmocka_unit_test(libspdm_test_responder_algorithms_case9),
2953 : /* No match for dhe_named_group*/
2954 : cmocka_unit_test(libspdm_test_responder_algorithms_case10),
2955 : /* No match for aead_cipher_suite*/
2956 : cmocka_unit_test(libspdm_test_responder_algorithms_case11),
2957 : /* No match for req_base_asym_alg*/
2958 : cmocka_unit_test(libspdm_test_responder_algorithms_case12),
2959 : /* No match for key_schedule*/
2960 : cmocka_unit_test(libspdm_test_responder_algorithms_case13),
2961 : /* Spdm length greater than 64 bytes for V1.0*/
2962 : cmocka_unit_test(libspdm_test_responder_algorithms_case14),
2963 : /* Spdm length greater than 128 bytes for V1.1*/
2964 : cmocka_unit_test(libspdm_test_responder_algorithms_case15),
2965 : /* Multiple repeated Alg structs for V1.1*/
2966 : cmocka_unit_test(libspdm_test_responder_algorithms_case16),
2967 : /* param1 is smaller than the number of Alg structs for V1.1*/
2968 : cmocka_unit_test(libspdm_test_responder_algorithms_case17),
2969 : /* param1 is bigger than the number of Alg structs for V1.1*/
2970 : cmocka_unit_test(libspdm_test_responder_algorithms_case18),
2971 : /* Invalid Alg structs + valid Alg Structs for V1.1*/
2972 : cmocka_unit_test(libspdm_test_responder_algorithms_case19),
2973 : /* When support multiple algorithms, then defaults to choose the strongest available algorithm*/
2974 : cmocka_unit_test(libspdm_test_responder_algorithms_case20),
2975 : /* Buffer verification*/
2976 : cmocka_unit_test(libspdm_test_responder_algorithms_case21),
2977 : /* Success case V1.2*/
2978 : cmocka_unit_test(libspdm_test_responder_algorithms_case22),
2979 : /* Version 1.2 Check other_params_support */
2980 : cmocka_unit_test(libspdm_test_responder_algorithms_case23),
2981 : /* No support for MEASUREMENT from requester*/
2982 : cmocka_unit_test(libspdm_test_responder_algorithms_case24),
2983 : /* Invalid (Redundant) alg_type value*/
2984 : cmocka_unit_test(libspdm_test_responder_algorithms_case25),
2985 : /* Invalid (Decreasing) alg_type value*/
2986 : cmocka_unit_test(libspdm_test_responder_algorithms_case26),
2987 : /* Invalid (smaller than DHE) alg_type value*/
2988 : cmocka_unit_test(libspdm_test_responder_algorithms_case27),
2989 : /* Invalid (bigger than KEY_SCHEDULE) alg_type value*/
2990 : cmocka_unit_test(libspdm_test_responder_algorithms_case28),
2991 : /* Invalid AlgStruct, contains an AlgSupported=0 (Non-supported)*/
2992 : cmocka_unit_test(libspdm_test_responder_algorithms_case29),
2993 : /* MULTI_KEY_CONN_REQ and MULTI_KEY_CONN_RSP value validation*/
2994 : cmocka_unit_test(libspdm_test_responder_algorithms_case30),
2995 : /* Success Case , set MELspecificationSel*/
2996 : cmocka_unit_test(libspdm_test_responder_algorithms_case31),
2997 : /* Success Case , set MeasurementSpecification*/
2998 : cmocka_unit_test(libspdm_test_responder_algorithms_case32),
2999 : };
3000 :
3001 1 : m_libspdm_negotiate_algorithms_request1.base_asym_algo = m_libspdm_use_asym_algo;
3002 1 : m_libspdm_negotiate_algorithms_request1.base_hash_algo = m_libspdm_use_hash_algo;
3003 1 : m_libspdm_negotiate_algorithms_request2.base_asym_algo = m_libspdm_use_asym_algo;
3004 1 : m_libspdm_negotiate_algorithms_request2.base_hash_algo = m_libspdm_use_hash_algo;
3005 1 : m_libspdm_negotiate_algorithm_request3.spdm_request_version10.base_asym_algo =
3006 : m_libspdm_use_asym_algo;
3007 1 : m_libspdm_negotiate_algorithm_request3.spdm_request_version10.base_hash_algo =
3008 : m_libspdm_use_hash_algo;
3009 1 : m_libspdm_negotiate_algorithm_request4.spdm_request_version10.base_asym_algo =
3010 1 : (m_libspdm_use_asym_algo >> 1);
3011 1 : m_libspdm_negotiate_algorithm_request4.spdm_request_version10.base_hash_algo =
3012 : m_libspdm_use_hash_algo;
3013 1 : m_libspdm_negotiate_algorithm_request5.spdm_request_version10.base_asym_algo =
3014 : m_libspdm_use_asym_algo;
3015 1 : m_libspdm_negotiate_algorithm_request5.spdm_request_version10.base_hash_algo =
3016 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512;
3017 1 : m_libspdm_negotiate_algorithm_request6.spdm_request_version10.base_asym_algo =
3018 : m_libspdm_use_asym_algo;
3019 1 : m_libspdm_negotiate_algorithm_request6.spdm_request_version10.base_hash_algo =
3020 : m_libspdm_use_hash_algo;
3021 1 : m_libspdm_negotiate_algorithm_request7.spdm_request_version10.base_asym_algo =
3022 : m_libspdm_use_asym_algo;
3023 1 : m_libspdm_negotiate_algorithm_request7.spdm_request_version10.base_hash_algo =
3024 : m_libspdm_use_hash_algo;
3025 1 : m_libspdm_negotiate_algorithm_request8.spdm_request_version10.base_asym_algo =
3026 : m_libspdm_use_asym_algo;
3027 1 : m_libspdm_negotiate_algorithm_request8.spdm_request_version10.base_hash_algo =
3028 : m_libspdm_use_hash_algo;
3029 1 : m_libspdm_negotiate_algorithm_request9.spdm_request_version10.base_asym_algo =
3030 : m_libspdm_use_asym_algo;
3031 1 : m_libspdm_negotiate_algorithm_request9.spdm_request_version10.base_hash_algo =
3032 : m_libspdm_use_hash_algo;
3033 1 : m_libspdm_negotiate_algorithm_request10.base_asym_algo = m_libspdm_use_asym_algo;
3034 1 : m_libspdm_negotiate_algorithm_request10.base_hash_algo = m_libspdm_use_hash_algo;
3035 1 : m_libspdm_negotiate_algorithm_request10.ext_asym_count = 0x09;
3036 1 : m_libspdm_negotiate_algorithm_request11.spdm_request_version10.base_asym_algo =
3037 : m_libspdm_use_asym_algo;
3038 1 : m_libspdm_negotiate_algorithm_request11.spdm_request_version10.base_hash_algo =
3039 : m_libspdm_use_hash_algo;
3040 1 : m_libspdm_negotiate_algorithm_request11.spdm_request_version10.ext_asym_count = 0x15;
3041 1 : m_libspdm_negotiate_algorithm_request12.spdm_request_version10.base_asym_algo =
3042 : m_libspdm_use_asym_algo;
3043 1 : m_libspdm_negotiate_algorithm_request12.spdm_request_version10.base_hash_algo =
3044 : m_libspdm_use_hash_algo;
3045 1 : m_libspdm_negotiate_algorithm_request13.spdm_request_version10.base_asym_algo =
3046 : m_libspdm_use_asym_algo;
3047 1 : m_libspdm_negotiate_algorithm_request13.spdm_request_version10.base_hash_algo =
3048 : m_libspdm_use_hash_algo;
3049 1 : m_libspdm_negotiate_algorithm_request14.spdm_request_version10.base_asym_algo =
3050 : m_libspdm_use_asym_algo;
3051 1 : m_libspdm_negotiate_algorithm_request14.spdm_request_version10.base_hash_algo =
3052 : m_libspdm_use_hash_algo;
3053 1 : m_libspdm_negotiate_algorithm_request15.spdm_request_version10.base_asym_algo =
3054 : m_libspdm_use_asym_algo;
3055 1 : m_libspdm_negotiate_algorithm_request15.spdm_request_version10.base_hash_algo =
3056 : m_libspdm_use_hash_algo;
3057 1 : m_libspdm_negotiate_algorithm_request16.spdm_request_version10.base_asym_algo =
3058 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521 |
3059 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384 |
3060 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256 |
3061 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072 |
3062 : SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
3063 1 : m_libspdm_negotiate_algorithm_request16.spdm_request_version10.base_hash_algo =
3064 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512 |
3065 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384 |
3066 : SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256;
3067 1 : m_libspdm_negotiate_algorithm_request17.spdm_request_version10.base_hash_algo =
3068 : m_libspdm_use_hash_algo;
3069 1 : m_libspdm_negotiate_algorithm_request17.spdm_request_version10.base_asym_algo =
3070 : m_libspdm_use_asym_algo;
3071 1 : m_libspdm_negotiate_algorithm_request18.spdm_request_version10.base_hash_algo =
3072 : m_libspdm_use_hash_algo;
3073 1 : m_libspdm_negotiate_algorithm_request18.spdm_request_version10.base_asym_algo =
3074 : m_libspdm_use_asym_algo;
3075 1 : m_libspdm_negotiate_algorithm_request24.spdm_request_version10.base_asym_algo =
3076 : m_libspdm_use_asym_algo;
3077 :
3078 1 : libspdm_test_context_t test_context = {
3079 : LIBSPDM_TEST_CONTEXT_VERSION,
3080 : false,
3081 : };
3082 :
3083 1 : libspdm_setup_test_context(&test_context);
3084 :
3085 1 : return cmocka_run_group_tests(spdm_responder_algorithms_tests,
3086 : libspdm_unit_test_group_setup,
3087 : libspdm_unit_test_group_teardown);
3088 : }
|