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 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request1 = {
11 : {
12 : SPDM_MESSAGE_VERSION_10,
13 : SPDM_GET_CAPABILITIES,
14 : },
15 : };
16 : /* version 1.0 message consists of only header (size 0x04).
17 : * However, spdm_get_capabilities_request_t has a size of 0x0c.
18 : * Therefore, sending a v1.0 request with this structure results in a wrong size request.
19 : * size information was corrected to reflect the actual size of a get_capabilities 1.0 message.*/
20 : size_t m_libspdm_get_capabilities_request1_size = sizeof(spdm_message_header_t);
21 :
22 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request2 = {
23 : {
24 : SPDM_MESSAGE_VERSION_10,
25 : SPDM_GET_CAPABILITIES,
26 : },
27 : };
28 : size_t m_libspdm_get_capabilities_request2_size = LIBSPDM_MAX_SPDM_MSG_SIZE;
29 :
30 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request4 = {
31 : {
32 : SPDM_MESSAGE_VERSION_11,
33 : SPDM_GET_CAPABILITIES,
34 : }, /*header*/
35 : 0x00, /*reserved*/
36 : 0x01, /*ct_exponent*/
37 : 0x0000, /*reserved, 2 bytes*/
38 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
39 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
40 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
41 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
42 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
43 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
44 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
45 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
46 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
47 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
48 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
49 : };
50 : size_t m_libspdm_get_capabilities_request4_size =
51 : sizeof(m_libspdm_get_capabilities_request4) -
52 : sizeof(m_libspdm_get_capabilities_request4.data_transfer_size) -
53 : sizeof(m_libspdm_get_capabilities_request4.max_spdm_msg_size);
54 :
55 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request5 = {
56 : {
57 : SPDM_MESSAGE_VERSION_11,
58 : SPDM_GET_CAPABILITIES,
59 : }, /*header*/
60 : 0x00, /*reserved*/
61 : 0x01, /*ct_exponent*/
62 : 0x0000, /*reserved, 2 bytes*/
63 : (0x01 | SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
64 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
65 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
66 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
67 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
68 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
69 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
70 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
71 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
72 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
73 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
74 : };
75 : size_t m_libspdm_get_capabilities_request5_size =
76 : sizeof(m_libspdm_get_capabilities_request5) -
77 : sizeof(m_libspdm_get_capabilities_request5.data_transfer_size) -
78 : sizeof(m_libspdm_get_capabilities_request5.max_spdm_msg_size);
79 :
80 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request6 = {
81 : {
82 : SPDM_MESSAGE_VERSION_11,
83 : SPDM_GET_CAPABILITIES,
84 : }, /*header*/
85 : 0x00, /*reserved*/
86 : 0x01, /*ct_exponent*/
87 : 0x0000, /*reserved, 2 bytes*/
88 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEAS_CAP_NO_SIG |
89 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
90 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
91 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
92 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
93 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
94 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
95 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
96 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
97 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
98 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
99 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
100 : };
101 : size_t m_libspdm_get_capabilities_request6_size =
102 : sizeof(m_libspdm_get_capabilities_request6) -
103 : sizeof(m_libspdm_get_capabilities_request6.data_transfer_size) -
104 : sizeof(m_libspdm_get_capabilities_request6.max_spdm_msg_size);
105 :
106 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request7 = {
107 : {
108 : SPDM_MESSAGE_VERSION_11,
109 : SPDM_GET_CAPABILITIES,
110 : }, /*header*/
111 : 0x00, /*reserved*/
112 : LIBSPDM_MAX_CT_EXPONENT + 1, /*Illegal ct_exponent*/
113 : 0x0000, /*reserved, 2 bytes*/
114 : (0x100000 | SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
115 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
116 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
117 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
118 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
119 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
120 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
121 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
122 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
123 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
124 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
125 : };
126 : size_t m_libspdm_get_capabilities_request7_size =
127 : sizeof(m_libspdm_get_capabilities_request7) -
128 : sizeof(m_libspdm_get_capabilities_request7.data_transfer_size) -
129 : sizeof(m_libspdm_get_capabilities_request7.max_spdm_msg_size);
130 :
131 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request8 = {
132 : {
133 : SPDM_MESSAGE_VERSION_11,
134 : SPDM_GET_CAPABILITIES,
135 : }, /*header*/
136 : 0x00, /*reserved*/
137 : 0x01, /*ct_exponent*/
138 : 0x0000, /*reserved, 2 bytes*/
139 : (0x100000 | SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
140 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
141 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
142 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
143 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
144 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
145 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
146 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
147 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
148 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
149 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
150 : };
151 : size_t m_libspdm_get_capabilities_request8_size =
152 : sizeof(m_libspdm_get_capabilities_request8) -
153 : sizeof(m_libspdm_get_capabilities_request8.data_transfer_size) -
154 : sizeof(m_libspdm_get_capabilities_request8.max_spdm_msg_size);
155 :
156 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request9 = {
157 : {
158 : SPDM_MESSAGE_VERSION_11,
159 : SPDM_GET_CAPABILITIES,
160 : }, /*header*/
161 : 0x00, /*reserved*/
162 : 0x01, /*ct_exponent*/
163 : 0x0000, /*reserved, 2 bytes*/
164 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PUB_KEY_ID_CAP |
165 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
166 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
167 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
168 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
169 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
170 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
171 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
172 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
173 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
174 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
175 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
176 : };
177 : size_t m_libspdm_get_capabilities_request9_size =
178 : sizeof(m_libspdm_get_capabilities_request9) -
179 : sizeof(m_libspdm_get_capabilities_request9.data_transfer_size) -
180 : sizeof(m_libspdm_get_capabilities_request9.max_spdm_msg_size);
181 :
182 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request10 = {
183 : {
184 : SPDM_MESSAGE_VERSION_11,
185 : SPDM_GET_CAPABILITIES,
186 : }, /*header*/
187 : 0x00, /*reserved*/
188 : 0x01, /*ct_exponent*/
189 : 0x0000, /*reserved, 2 bytes*/
190 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
191 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
192 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
193 :
194 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
195 :
196 :
197 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
198 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
199 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
200 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
201 : };
202 : size_t m_libspdm_get_capabilities_request10_size =
203 : sizeof(m_libspdm_get_capabilities_request10) -
204 : sizeof(m_libspdm_get_capabilities_request10.data_transfer_size) -
205 : sizeof(m_libspdm_get_capabilities_request10.max_spdm_msg_size);
206 :
207 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request11 = {
208 : {
209 : SPDM_MESSAGE_VERSION_11,
210 : SPDM_GET_CAPABILITIES,
211 : }, /*header*/
212 : 0x00, /*reserved*/
213 : 0x01, /*ct_exponent*/
214 : 0x0000, /*reserved, 2 bytes*/
215 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
216 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
217 :
218 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
219 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
220 :
221 :
222 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
223 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
224 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
225 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
226 : };
227 : size_t m_libspdm_get_capabilities_request11_size =
228 : sizeof(m_libspdm_get_capabilities_request11) -
229 : sizeof(m_libspdm_get_capabilities_request11.data_transfer_size) -
230 : sizeof(m_libspdm_get_capabilities_request11.max_spdm_msg_size);
231 :
232 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request12 = {
233 : {
234 : SPDM_MESSAGE_VERSION_11,
235 : SPDM_GET_CAPABILITIES,
236 : }, /*header*/
237 : 0x00, /*reserved*/
238 : 0x01, /*ct_exponent*/
239 : 0x0000, /*reserved, 2 bytes*/
240 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
241 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
242 :
243 :
244 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
245 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
246 :
247 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
248 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
249 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP
250 :
251 : )
252 : };
253 : size_t m_libspdm_get_capabilities_request12_size =
254 : sizeof(m_libspdm_get_capabilities_request12) -
255 : sizeof(m_libspdm_get_capabilities_request12.data_transfer_size) -
256 : sizeof(m_libspdm_get_capabilities_request12.max_spdm_msg_size);
257 :
258 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request13 = {
259 : {
260 : SPDM_MESSAGE_VERSION_11,
261 : SPDM_GET_CAPABILITIES,
262 : }, /*header*/
263 : 0x00, /*reserved*/
264 : 0x01, /*ct_exponent*/
265 : 0x0000, /*reserved, 2 bytes*/
266 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
267 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
268 :
269 :
270 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
271 :
272 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
273 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
274 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
275 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP
276 :
277 : )
278 : };
279 : size_t m_libspdm_get_capabilities_request13_size =
280 : sizeof(m_libspdm_get_capabilities_request13) -
281 : sizeof(m_libspdm_get_capabilities_request13.data_transfer_size) -
282 : sizeof(m_libspdm_get_capabilities_request13.max_spdm_msg_size);
283 :
284 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request14 = {
285 : {
286 : SPDM_MESSAGE_VERSION_11,
287 : SPDM_GET_CAPABILITIES,
288 : }, /*header*/
289 : 0x00, /*reserved*/
290 : 0x01, /*ct_exponent*/
291 : 0x0000, /*reserved, 2 bytes*/
292 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
293 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
294 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
295 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
296 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
297 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
298 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
299 :
300 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
301 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
302 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
303 : };
304 : size_t m_libspdm_get_capabilities_request14_size =
305 : sizeof(m_libspdm_get_capabilities_request14) -
306 : sizeof(m_libspdm_get_capabilities_request14.data_transfer_size) -
307 : sizeof(m_libspdm_get_capabilities_request14.max_spdm_msg_size);
308 :
309 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request15 = {
310 : {
311 : SPDM_MESSAGE_VERSION_11,
312 : SPDM_GET_CAPABILITIES,
313 : }, /*header*/
314 : 0x00, /*reserved*/
315 : 0x01, /*ct_exponent*/
316 : 0x0000, /*reserved, 2 bytes*/
317 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
318 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
319 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
320 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
321 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
322 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
323 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
324 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
325 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
326 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
327 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP |
328 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PUB_KEY_ID_CAP)
329 : };
330 : size_t m_libspdm_get_capabilities_request15_size =
331 : sizeof(m_libspdm_get_capabilities_request15) -
332 : sizeof(m_libspdm_get_capabilities_request15.data_transfer_size) -
333 : sizeof(m_libspdm_get_capabilities_request15.max_spdm_msg_size);
334 :
335 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request16 = {
336 : {
337 : SPDM_MESSAGE_VERSION_11,
338 : SPDM_GET_CAPABILITIES,
339 : }, /*header*/
340 : 0x00, /*reserved*/
341 : 0x01, /*ct_exponent*/
342 : 0x0000, /*reserved, 2 bytes*/
343 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
344 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
345 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
346 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
347 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
348 :
349 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
350 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
351 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
352 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
353 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
354 : };
355 : size_t m_libspdm_get_capabilities_request16_size =
356 : sizeof(m_libspdm_get_capabilities_request16) -
357 : sizeof(m_libspdm_get_capabilities_request16.data_transfer_size) -
358 : sizeof(m_libspdm_get_capabilities_request16.max_spdm_msg_size);
359 :
360 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request17 = {
361 : {
362 : SPDM_MESSAGE_VERSION_11,
363 : SPDM_GET_CAPABILITIES,
364 : }, /*header*/
365 : 0x00, /*reserved*/
366 : 0x01, /*ct_exponent*/
367 : 0x0000, /*reserved, 2 bytes*/
368 : (SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP | /*flags*/
369 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
370 :
371 :
372 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
373 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
374 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
375 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
376 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
377 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
378 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)
379 : };
380 : size_t m_libspdm_get_capabilities_request17_size =
381 : sizeof(m_libspdm_get_capabilities_request17) -
382 : sizeof(m_libspdm_get_capabilities_request17.data_transfer_size) -
383 : sizeof(m_libspdm_get_capabilities_request17.max_spdm_msg_size);
384 :
385 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request18 = {
386 : {
387 : SPDM_MESSAGE_VERSION_11,
388 : SPDM_GET_CAPABILITIES,
389 : }, /*header*/
390 : 0x00, /*reserved*/
391 : 0x01, /*ct_exponent*/
392 : 0x0000, /*reserved, 2 bytes*/
393 : ( /*flags*/
394 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHAL_CAP |
395 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCRYPT_CAP |
396 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MAC_CAP |
397 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MUT_AUTH_CAP |
398 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_EX_CAP |
399 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PSK_CAP_REQUESTER |
400 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_ENCAP_CAP |
401 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HBEAT_CAP |
402 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_KEY_UPD_CAP |
403 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP |
404 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_PUB_KEY_ID_CAP)
405 : };
406 : size_t m_libspdm_get_capabilities_request18_size =
407 : sizeof(m_libspdm_get_capabilities_request18) -
408 : sizeof(m_libspdm_get_capabilities_request18.data_transfer_size) -
409 : sizeof(m_libspdm_get_capabilities_request18.max_spdm_msg_size);
410 :
411 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request19 = {
412 : {
413 : SPDM_MESSAGE_VERSION_12,
414 : SPDM_GET_CAPABILITIES,
415 : }, /*header*/
416 : 0x00, /*reserved*/
417 : 0x01, /*ct_exponent*/
418 : 0x0000, /*reserved, 2 bytes*/
419 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP|
420 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ALIAS_CERT_CAP),
421 : LIBSPDM_DATA_TRANSFER_SIZE,
422 : LIBSPDM_MAX_SPDM_MSG_SIZE,
423 : };
424 : size_t m_libspdm_get_capabilities_request19_size = sizeof(m_libspdm_get_capabilities_request19);
425 :
426 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request25 = {
427 : {
428 : SPDM_MESSAGE_VERSION_12,
429 : SPDM_GET_CAPABILITIES,
430 : }, /*header*/
431 : 0x00, /*reserved*/
432 : 0x01, /*ct_exponent*/
433 : 0x0000, /*reserved, 2 bytes*/
434 : 0,
435 : LIBSPDM_DATA_TRANSFER_SIZE - 1,
436 : LIBSPDM_MAX_SPDM_MSG_SIZE,
437 : };
438 : size_t m_libspdm_get_capabilities_request25_size = sizeof(m_libspdm_get_capabilities_request25);
439 :
440 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request26 = {
441 : {
442 : SPDM_MESSAGE_VERSION_12,
443 : SPDM_GET_CAPABILITIES,
444 : }, /*header*/
445 : 0x00, /*reserved*/
446 : 0x01, /*ct_exponent*/
447 : 0x0000, /*reserved, 2 bytes*/
448 : (SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP|
449 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ALIAS_CERT_CAP),
450 : LIBSPDM_DATA_TRANSFER_SIZE,
451 : LIBSPDM_DATA_TRANSFER_SIZE - 1,
452 : };
453 : size_t m_libspdm_get_capabilities_request26_size = sizeof(m_libspdm_get_capabilities_request26);
454 :
455 :
456 : spdm_get_capabilities_request_t m_libspdm_get_capabilities_request27 = {
457 : {
458 : SPDM_MESSAGE_VERSION_13,
459 : SPDM_GET_CAPABILITIES,
460 : },
461 : 0x00, /*reserved*/
462 : 0x01, /*ct_exponent*/
463 : 0x0000, /*reserved, 2 bytes*/
464 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP |
465 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG |
466 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY,
467 : LIBSPDM_DATA_TRANSFER_SIZE,
468 : LIBSPDM_MAX_SPDM_MSG_SIZE,
469 : };
470 : size_t m_libspdm_get_capabilities_request27_size = sizeof(m_libspdm_get_capabilities_request27);
471 :
472 1 : void libspdm_test_responder_capabilities_case1(void **state)
473 : {
474 : libspdm_return_t status;
475 : libspdm_test_context_t *spdm_test_context;
476 : libspdm_context_t *spdm_context;
477 : size_t response_size;
478 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
479 : spdm_capabilities_response_t *spdm_response;
480 :
481 1 : spdm_test_context = *state;
482 1 : spdm_context = spdm_test_context->spdm_context;
483 1 : spdm_test_context->case_id = 0x1;
484 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
485 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
486 : spdm_context->transcript.message_m.buffer_size =
487 : spdm_context->transcript.message_m.max_buffer_size;
488 : #endif
489 :
490 1 : response_size = sizeof(response);
491 1 : status = libspdm_get_response_capabilities(
492 : spdm_context, m_libspdm_get_capabilities_request1_size,
493 : &m_libspdm_get_capabilities_request1, &response_size, response);
494 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
495 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
496 : sizeof(spdm_response->data_transfer_size) -
497 : sizeof(spdm_response->max_spdm_msg_size));
498 1 : spdm_response = (void *)response;
499 1 : assert_int_equal(m_libspdm_get_capabilities_request1.header.spdm_version,
500 : spdm_response->header.spdm_version);
501 1 : assert_int_equal(spdm_response->header.request_response_code,
502 : SPDM_CAPABILITIES);
503 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
504 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
505 : #endif
506 1 : }
507 :
508 1 : void libspdm_test_responder_capabilities_case2(void **state)
509 : {
510 : libspdm_return_t status;
511 : libspdm_test_context_t *spdm_test_context;
512 : libspdm_context_t *spdm_context;
513 : size_t response_size;
514 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
515 : spdm_capabilities_response_t *spdm_response;
516 :
517 1 : spdm_test_context = *state;
518 1 : spdm_context = spdm_test_context->spdm_context;
519 1 : spdm_test_context->case_id = 0x2;
520 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
521 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
522 : spdm_context->transcript.message_m.buffer_size =
523 : spdm_context->transcript.message_m.max_buffer_size;
524 : #endif
525 :
526 1 : response_size = sizeof(response);
527 1 : status = libspdm_get_response_capabilities(
528 : spdm_context, m_libspdm_get_capabilities_request2_size,
529 : &m_libspdm_get_capabilities_request2, &response_size, response);
530 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
531 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
532 : sizeof(spdm_response->data_transfer_size) -
533 : sizeof(spdm_response->max_spdm_msg_size));
534 1 : spdm_response = (void *)response;
535 1 : assert_int_equal(m_libspdm_get_capabilities_request2.header.spdm_version,
536 : spdm_response->header.spdm_version);
537 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CAPABILITIES);
538 : #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
539 : assert_int_equal(spdm_context->transcript.message_m.buffer_size, 0);
540 : #endif
541 1 : }
542 :
543 1 : void libspdm_test_responder_capabilities_case3(void **state)
544 : {
545 : libspdm_return_t status;
546 : libspdm_test_context_t *spdm_test_context;
547 : libspdm_context_t *spdm_context;
548 : size_t response_size;
549 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
550 : spdm_capabilities_response_t *spdm_response;
551 :
552 1 : spdm_test_context = *state;
553 1 : spdm_context = spdm_test_context->spdm_context;
554 1 : spdm_test_context->case_id = 0x3;
555 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_BUSY;
556 1 : spdm_context->connection_info.connection_state =
557 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
558 :
559 1 : response_size = sizeof(response);
560 1 : status = libspdm_get_response_capabilities(
561 : spdm_context, m_libspdm_get_capabilities_request1_size,
562 : &m_libspdm_get_capabilities_request1, &response_size, response);
563 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
564 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
565 1 : spdm_response = (void *)response;
566 1 : assert_int_equal(m_libspdm_get_capabilities_request1.header.spdm_version,
567 : spdm_response->header.spdm_version);
568 1 : assert_int_equal(spdm_response->header.request_response_code,
569 : SPDM_ERROR);
570 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
571 1 : assert_int_equal(spdm_response->header.param2, 0);
572 1 : assert_int_equal(spdm_context->response_state,
573 : LIBSPDM_RESPONSE_STATE_BUSY);
574 1 : }
575 :
576 1 : void libspdm_test_responder_capabilities_case4(void **state)
577 : {
578 : libspdm_return_t status;
579 : libspdm_test_context_t *spdm_test_context;
580 : libspdm_context_t *spdm_context;
581 : size_t response_size;
582 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
583 : spdm_capabilities_response_t *spdm_response;
584 :
585 1 : spdm_test_context = *state;
586 1 : spdm_context = spdm_test_context->spdm_context;
587 1 : spdm_test_context->case_id = 0x4;
588 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NEED_RESYNC;
589 1 : spdm_context->connection_info.connection_state =
590 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
591 :
592 1 : response_size = sizeof(response);
593 1 : status = libspdm_get_response_capabilities(
594 : spdm_context, m_libspdm_get_capabilities_request1_size,
595 : &m_libspdm_get_capabilities_request1, &response_size, response);
596 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
597 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
598 1 : spdm_response = (void *)response;
599 1 : assert_int_equal(m_libspdm_get_capabilities_request1.header.spdm_version,
600 : spdm_response->header.spdm_version);
601 1 : assert_int_equal(spdm_response->header.request_response_code,
602 : SPDM_ERROR);
603 1 : assert_int_equal(spdm_response->header.param1,
604 : SPDM_ERROR_CODE_REQUEST_RESYNCH);
605 1 : assert_int_equal(spdm_response->header.param2, 0);
606 1 : assert_int_equal(spdm_context->response_state,
607 : LIBSPDM_RESPONSE_STATE_NEED_RESYNC);
608 1 : }
609 :
610 1 : void libspdm_test_responder_capabilities_case6(void **state)
611 : {
612 : libspdm_return_t status;
613 : libspdm_test_context_t *spdm_test_context;
614 : libspdm_context_t *spdm_context;
615 : size_t response_size;
616 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
617 : spdm_capabilities_response_t *spdm_response;
618 :
619 1 : spdm_test_context = *state;
620 1 : spdm_context = spdm_test_context->spdm_context;
621 1 : spdm_test_context->case_id = 0x6;
622 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
623 1 : spdm_context->connection_info.connection_state =
624 : LIBSPDM_CONNECTION_STATE_NOT_STARTED;
625 :
626 1 : response_size = sizeof(response);
627 1 : status = libspdm_get_response_capabilities(
628 : spdm_context, m_libspdm_get_capabilities_request1_size,
629 : &m_libspdm_get_capabilities_request1, &response_size, response);
630 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
631 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
632 1 : spdm_response = (void *)response;
633 1 : assert_int_equal(m_libspdm_get_capabilities_request1.header.spdm_version,
634 : spdm_response->header.spdm_version);
635 1 : assert_int_equal(spdm_response->header.request_response_code,
636 : SPDM_ERROR);
637 1 : assert_int_equal(spdm_response->header.param1,
638 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
639 1 : assert_int_equal(spdm_response->header.param2, 0);
640 1 : }
641 :
642 : /**
643 : * Test 7: Requester sets a CTExponent value that is larger than LIBSPDM_MAX_CT_EXPONENT.
644 : * Expected behavior: returns with error code SPDM_ERROR_CODE_INVALID_REQUEST.
645 : **/
646 1 : void libspdm_test_responder_capabilities_case7(void **state)
647 : {
648 : libspdm_return_t status;
649 : libspdm_test_context_t *spdm_test_context;
650 : libspdm_context_t *spdm_context;
651 : size_t response_size;
652 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
653 : spdm_capabilities_response_t *spdm_response;
654 :
655 1 : spdm_test_context = *state;
656 1 : spdm_context = spdm_test_context->spdm_context;
657 1 : spdm_test_context->case_id = 0x7;
658 1 : spdm_context->response_state = LIBSPDM_RESPONSE_STATE_NORMAL;
659 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
660 :
661 1 : response_size = sizeof(response);
662 1 : status = libspdm_get_response_capabilities(
663 : spdm_context, m_libspdm_get_capabilities_request7_size,
664 : &m_libspdm_get_capabilities_request7, &response_size, response);
665 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
666 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
667 1 : spdm_response = (void *)response;
668 1 : assert_int_equal(m_libspdm_get_capabilities_request7.header.spdm_version,
669 : spdm_response->header.spdm_version);
670 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
671 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
672 1 : assert_int_equal(spdm_response->header.param2, 0);
673 1 : }
674 :
675 1 : void libspdm_test_responder_capabilities_case8(void **state)
676 : {
677 : libspdm_return_t status;
678 : libspdm_test_context_t *spdm_test_context;
679 : libspdm_context_t *spdm_context;
680 : size_t response_size;
681 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
682 : spdm_capabilities_response_t *spdm_response;
683 :
684 1 : spdm_test_context = *state;
685 1 : spdm_context = spdm_test_context->spdm_context;
686 1 : spdm_test_context->case_id = 0x8;
687 1 : spdm_context->connection_info.connection_state =
688 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
689 :
690 1 : response_size = sizeof(response);
691 1 : status = libspdm_get_response_capabilities(
692 : spdm_context, m_libspdm_get_capabilities_request4_size,
693 : &m_libspdm_get_capabilities_request4, &response_size, response);
694 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
695 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
696 : sizeof(spdm_response->data_transfer_size) -
697 : sizeof(spdm_response->max_spdm_msg_size));
698 1 : spdm_response = (void *)response;
699 1 : assert_int_equal(m_libspdm_get_capabilities_request4.header.spdm_version,
700 : spdm_response->header.spdm_version);
701 1 : assert_int_equal(spdm_response->header.request_response_code,
702 : SPDM_CAPABILITIES);
703 1 : }
704 :
705 1 : void libspdm_test_responder_capabilities_case9(void **state)
706 : {
707 : libspdm_return_t status;
708 : libspdm_test_context_t *spdm_test_context;
709 : libspdm_context_t *spdm_context;
710 : size_t response_size;
711 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
712 : spdm_capabilities_response_t *spdm_response;
713 :
714 1 : spdm_test_context = *state;
715 1 : spdm_context = spdm_test_context->spdm_context;
716 1 : spdm_test_context->case_id = 0x9;
717 1 : spdm_context->connection_info.connection_state =
718 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
719 :
720 1 : response_size = sizeof(response);
721 1 : status = libspdm_get_response_capabilities(
722 : spdm_context, m_libspdm_get_capabilities_request5_size,
723 : &m_libspdm_get_capabilities_request5, &response_size, response);
724 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
725 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
726 : sizeof(spdm_response->data_transfer_size) -
727 : sizeof(spdm_response->max_spdm_msg_size));
728 1 : spdm_response = (void *)response;
729 1 : assert_int_equal(m_libspdm_get_capabilities_request4.header.spdm_version,
730 : spdm_response->header.spdm_version);
731 1 : assert_int_equal(spdm_response->header.request_response_code,
732 : SPDM_CAPABILITIES);
733 1 : }
734 :
735 1 : void libspdm_test_responder_capabilities_case10(void **state)
736 : {
737 1 : }
738 :
739 1 : void libspdm_test_responder_capabilities_case11(void **state)
740 : {
741 1 : }
742 :
743 1 : void libspdm_test_responder_capabilities_case12(void **state)
744 : {
745 1 : }
746 :
747 1 : void libspdm_test_responder_capabilities_case13(void **state)
748 : {
749 : libspdm_return_t status;
750 : libspdm_test_context_t *spdm_test_context;
751 : libspdm_context_t *spdm_context;
752 : size_t response_size;
753 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
754 : spdm_capabilities_response_t *spdm_response;
755 :
756 1 : spdm_test_context = *state;
757 1 : spdm_context = spdm_test_context->spdm_context;
758 1 : spdm_test_context->case_id = 0xd;
759 1 : spdm_context->connection_info.connection_state =
760 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
761 :
762 1 : response_size = sizeof(response);
763 1 : status = libspdm_get_response_capabilities(
764 : spdm_context, m_libspdm_get_capabilities_request9_size,
765 : &m_libspdm_get_capabilities_request9, &response_size, response);
766 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
767 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
768 1 : spdm_response = (void *)response;
769 1 : assert_int_equal(m_libspdm_get_capabilities_request9.header.spdm_version,
770 : spdm_response->header.spdm_version);
771 1 : assert_int_equal(spdm_response->header.request_response_code,
772 : SPDM_ERROR);
773 1 : assert_int_equal(spdm_response->header.param1,
774 : SPDM_ERROR_CODE_INVALID_REQUEST);
775 1 : assert_int_equal(spdm_response->header.param2, 0);
776 1 : }
777 :
778 1 : void libspdm_test_responder_capabilities_case14(void **state)
779 : {
780 : libspdm_return_t status;
781 : libspdm_test_context_t *spdm_test_context;
782 : libspdm_context_t *spdm_context;
783 : size_t response_size;
784 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
785 : spdm_capabilities_response_t *spdm_response;
786 :
787 1 : spdm_test_context = *state;
788 1 : spdm_context = spdm_test_context->spdm_context;
789 1 : spdm_test_context->case_id = 0xe;
790 1 : spdm_context->connection_info.connection_state =
791 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
792 :
793 1 : response_size = sizeof(response);
794 1 : status = libspdm_get_response_capabilities(
795 : spdm_context, m_libspdm_get_capabilities_request10_size,
796 : &m_libspdm_get_capabilities_request10, &response_size, response);
797 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
798 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
799 1 : spdm_response = (void *)response;
800 1 : assert_int_equal(m_libspdm_get_capabilities_request10.header.spdm_version,
801 : spdm_response->header.spdm_version);
802 1 : assert_int_equal(spdm_response->header.request_response_code,
803 : SPDM_ERROR);
804 1 : assert_int_equal(spdm_response->header.param1,
805 : SPDM_ERROR_CODE_INVALID_REQUEST);
806 1 : assert_int_equal(spdm_response->header.param2, 0);
807 1 : }
808 :
809 1 : void libspdm_test_responder_capabilities_case15(void **state)
810 : {
811 : libspdm_return_t status;
812 : libspdm_test_context_t *spdm_test_context;
813 : libspdm_context_t *spdm_context;
814 : size_t response_size;
815 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
816 : spdm_capabilities_response_t *spdm_response;
817 :
818 1 : spdm_test_context = *state;
819 1 : spdm_context = spdm_test_context->spdm_context;
820 1 : spdm_test_context->case_id = 0xf;
821 1 : spdm_context->connection_info.connection_state =
822 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
823 :
824 1 : response_size = sizeof(response);
825 1 : status = libspdm_get_response_capabilities(
826 : spdm_context, m_libspdm_get_capabilities_request11_size,
827 : &m_libspdm_get_capabilities_request11, &response_size, response);
828 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
829 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
830 1 : spdm_response = (void *)response;
831 1 : assert_int_equal(m_libspdm_get_capabilities_request11.header.spdm_version,
832 : spdm_response->header.spdm_version);
833 1 : assert_int_equal(spdm_response->header.request_response_code,
834 : SPDM_ERROR);
835 1 : assert_int_equal(spdm_response->header.param1,
836 : SPDM_ERROR_CODE_INVALID_REQUEST);
837 1 : assert_int_equal(spdm_response->header.param2, 0);
838 1 : }
839 :
840 1 : void libspdm_test_responder_capabilities_case16(void **state)
841 : {
842 : libspdm_return_t status;
843 : libspdm_test_context_t *spdm_test_context;
844 : libspdm_context_t *spdm_context;
845 : size_t response_size;
846 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
847 : spdm_capabilities_response_t *spdm_response;
848 :
849 1 : spdm_test_context = *state;
850 1 : spdm_context = spdm_test_context->spdm_context;
851 1 : spdm_test_context->case_id = 0x10;
852 1 : spdm_context->connection_info.connection_state =
853 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
854 :
855 1 : response_size = sizeof(response);
856 1 : status = libspdm_get_response_capabilities(
857 : spdm_context, m_libspdm_get_capabilities_request12_size,
858 : &m_libspdm_get_capabilities_request12, &response_size, response);
859 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
860 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
861 1 : spdm_response = (void *)response;
862 1 : assert_int_equal(m_libspdm_get_capabilities_request12.header.spdm_version,
863 : spdm_response->header.spdm_version);
864 1 : assert_int_equal(spdm_response->header.request_response_code,
865 : SPDM_ERROR);
866 1 : assert_int_equal(spdm_response->header.param1,
867 : SPDM_ERROR_CODE_INVALID_REQUEST);
868 1 : assert_int_equal(spdm_response->header.param2, 0);
869 1 : }
870 :
871 1 : void libspdm_test_responder_capabilities_case17(void **state)
872 : {
873 : libspdm_return_t status;
874 : libspdm_test_context_t *spdm_test_context;
875 : libspdm_context_t *spdm_context;
876 : size_t response_size;
877 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
878 : spdm_capabilities_response_t *spdm_response;
879 :
880 1 : spdm_test_context = *state;
881 1 : spdm_context = spdm_test_context->spdm_context;
882 1 : spdm_test_context->case_id = 0x11;
883 1 : spdm_context->connection_info.connection_state =
884 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
885 :
886 1 : response_size = sizeof(response);
887 1 : status = libspdm_get_response_capabilities(
888 : spdm_context, m_libspdm_get_capabilities_request13_size,
889 : &m_libspdm_get_capabilities_request13, &response_size, response);
890 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
891 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
892 1 : spdm_response = (void *)response;
893 1 : assert_int_equal(m_libspdm_get_capabilities_request13.header.spdm_version,
894 : spdm_response->header.spdm_version);
895 1 : assert_int_equal(spdm_response->header.request_response_code,
896 : SPDM_ERROR);
897 1 : assert_int_equal(spdm_response->header.param1,
898 : SPDM_ERROR_CODE_INVALID_REQUEST);
899 1 : assert_int_equal(spdm_response->header.param2, 0);
900 1 : }
901 :
902 1 : void libspdm_test_responder_capabilities_case18(void **state)
903 : {
904 : libspdm_return_t status;
905 : libspdm_test_context_t *spdm_test_context;
906 : libspdm_context_t *spdm_context;
907 : size_t response_size;
908 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
909 : spdm_capabilities_response_t *spdm_response;
910 :
911 1 : spdm_test_context = *state;
912 1 : spdm_context = spdm_test_context->spdm_context;
913 1 : spdm_test_context->case_id = 0x12;
914 1 : spdm_context->connection_info.connection_state =
915 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
916 :
917 1 : libspdm_reset_message_a(spdm_context);
918 :
919 1 : response_size = sizeof(response);
920 1 : status = libspdm_get_response_capabilities(
921 : spdm_context, m_libspdm_get_capabilities_request14_size,
922 : &m_libspdm_get_capabilities_request14, &response_size, response);
923 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
924 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
925 1 : spdm_response = (void *)response;
926 1 : assert_int_equal(m_libspdm_get_capabilities_request14.header.spdm_version,
927 : spdm_response->header.spdm_version);
928 1 : assert_int_equal(spdm_response->header.request_response_code,
929 : SPDM_ERROR);
930 1 : assert_int_equal(spdm_response->header.param1,
931 : SPDM_ERROR_CODE_INVALID_REQUEST);
932 1 : assert_int_equal(spdm_response->header.param2, 0);
933 1 : }
934 :
935 1 : void libspdm_test_responder_capabilities_case19(void **state)
936 : {
937 : libspdm_return_t status;
938 : libspdm_test_context_t *spdm_test_context;
939 : libspdm_context_t *spdm_context;
940 : size_t response_size;
941 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
942 : spdm_capabilities_response_t *spdm_response;
943 :
944 1 : spdm_test_context = *state;
945 1 : spdm_context = spdm_test_context->spdm_context;
946 1 : spdm_test_context->case_id = 0x13;
947 1 : spdm_context->connection_info.connection_state =
948 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
949 :
950 1 : response_size = sizeof(response);
951 1 : status = libspdm_get_response_capabilities(
952 : spdm_context, m_libspdm_get_capabilities_request15_size,
953 : &m_libspdm_get_capabilities_request15, &response_size, response);
954 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
955 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
956 1 : spdm_response = (void *)response;
957 1 : assert_int_equal(m_libspdm_get_capabilities_request15.header.spdm_version,
958 : spdm_response->header.spdm_version);
959 1 : assert_int_equal(spdm_response->header.request_response_code,
960 : SPDM_ERROR);
961 1 : assert_int_equal(spdm_response->header.param1,
962 : SPDM_ERROR_CODE_INVALID_REQUEST);
963 1 : assert_int_equal(spdm_response->header.param2, 0);
964 1 : }
965 :
966 1 : void libspdm_test_responder_capabilities_case20(void **state)
967 : {
968 : libspdm_return_t status;
969 : libspdm_test_context_t *spdm_test_context;
970 : libspdm_context_t *spdm_context;
971 : size_t response_size;
972 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
973 : spdm_capabilities_response_t *spdm_response;
974 :
975 1 : spdm_test_context = *state;
976 1 : spdm_context = spdm_test_context->spdm_context;
977 1 : spdm_test_context->case_id = 0x14;
978 1 : spdm_context->connection_info.connection_state =
979 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
980 :
981 1 : response_size = sizeof(response);
982 1 : status = libspdm_get_response_capabilities(
983 : spdm_context, m_libspdm_get_capabilities_request16_size,
984 : &m_libspdm_get_capabilities_request16, &response_size, response);
985 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
986 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
987 1 : spdm_response = (void *)response;
988 1 : assert_int_equal(m_libspdm_get_capabilities_request16.header.spdm_version,
989 : spdm_response->header.spdm_version);
990 1 : assert_int_equal(spdm_response->header.request_response_code,
991 : SPDM_ERROR);
992 1 : assert_int_equal(spdm_response->header.param1,
993 : SPDM_ERROR_CODE_INVALID_REQUEST);
994 1 : assert_int_equal(spdm_response->header.param2, 0);
995 1 : }
996 :
997 1 : void libspdm_test_responder_capabilities_case21(void **state)
998 : {
999 1 : }
1000 :
1001 1 : void libspdm_test_responder_capabilities_case22(void **state)
1002 : {
1003 : libspdm_return_t status;
1004 : libspdm_test_context_t *spdm_test_context;
1005 : libspdm_context_t *spdm_context;
1006 : size_t response_size;
1007 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1008 : spdm_capabilities_response_t *spdm_response;
1009 :
1010 1 : spdm_test_context = *state;
1011 1 : spdm_context = spdm_test_context->spdm_context;
1012 1 : spdm_test_context->case_id = 0x16;
1013 1 : spdm_context->connection_info.connection_state =
1014 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
1015 :
1016 1 : response_size = sizeof(response);
1017 1 : status = libspdm_get_response_capabilities(
1018 : spdm_context, m_libspdm_get_capabilities_request18_size,
1019 : &m_libspdm_get_capabilities_request18, &response_size, response);
1020 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1021 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
1022 : sizeof(spdm_response->data_transfer_size) -
1023 : sizeof(spdm_response->max_spdm_msg_size));
1024 1 : spdm_response = (void *)response;
1025 1 : assert_int_equal(m_libspdm_get_capabilities_request18.header.spdm_version,
1026 : spdm_response->header.spdm_version);
1027 1 : assert_int_equal(spdm_response->header.request_response_code,
1028 : SPDM_CAPABILITIES);
1029 1 : }
1030 :
1031 1 : void libspdm_test_responder_capabilities_case23(void **state)
1032 : {
1033 : libspdm_return_t status;
1034 : libspdm_test_context_t *spdm_test_context;
1035 : libspdm_context_t *spdm_context;
1036 : size_t response_size;
1037 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1038 : spdm_capabilities_response_t *spdm_response;
1039 : size_t arbitrary_size;
1040 :
1041 1 : spdm_test_context = *state;
1042 1 : spdm_context = spdm_test_context->spdm_context;
1043 1 : spdm_test_context->case_id = 0x17;
1044 1 : spdm_context->connection_info.connection_state =
1045 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
1046 :
1047 : /*filling A with arbitrary data*/
1048 1 : arbitrary_size = 10;
1049 1 : libspdm_set_mem(spdm_context->transcript.message_a.buffer, arbitrary_size, (uint8_t) 0xFF);
1050 1 : spdm_context->transcript.message_a.buffer_size = arbitrary_size;
1051 :
1052 1 : response_size = sizeof(response);
1053 1 : status = libspdm_get_response_capabilities(
1054 : spdm_context, m_libspdm_get_capabilities_request4_size,
1055 : &m_libspdm_get_capabilities_request4, &response_size, response);
1056 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1057 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
1058 : sizeof(spdm_response->data_transfer_size) -
1059 : sizeof(spdm_response->max_spdm_msg_size));
1060 1 : spdm_response = (void *)response;
1061 1 : assert_int_equal(m_libspdm_get_capabilities_request4.header.spdm_version,
1062 : spdm_response->header.spdm_version);
1063 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CAPABILITIES);
1064 :
1065 1 : assert_int_equal(spdm_context->transcript.message_a.buffer_size,
1066 : arbitrary_size + m_libspdm_get_capabilities_request4_size + response_size);
1067 1 : assert_memory_equal(spdm_context->transcript.message_a.buffer + arbitrary_size,
1068 : &m_libspdm_get_capabilities_request4,
1069 : m_libspdm_get_capabilities_request4_size);
1070 1 : assert_memory_equal(spdm_context->transcript.message_a.buffer + arbitrary_size +
1071 : m_libspdm_get_capabilities_request4_size,
1072 : response, response_size);
1073 1 : }
1074 :
1075 1 : void libspdm_test_responder_capabilities_case24(void **state)
1076 : {
1077 : libspdm_return_t status;
1078 : libspdm_test_context_t *spdm_test_context;
1079 : libspdm_context_t *spdm_context;
1080 : size_t response_size;
1081 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1082 : spdm_capabilities_response_t *spdm_response;
1083 :
1084 1 : spdm_test_context = *state;
1085 1 : spdm_context = spdm_test_context->spdm_context;
1086 1 : spdm_test_context->case_id = 0x18;
1087 1 : spdm_context->connection_info.connection_state =
1088 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
1089 :
1090 1 : response_size = sizeof(response);
1091 1 : status = libspdm_get_response_capabilities(
1092 : spdm_context, m_libspdm_get_capabilities_request19_size,
1093 : &m_libspdm_get_capabilities_request19, &response_size, response);
1094 1 : assert_int_equal(spdm_context->connection_info.capability.max_spdm_msg_size,
1095 : m_libspdm_get_capabilities_request19.max_spdm_msg_size);
1096 1 : assert_int_equal(spdm_context->connection_info.capability.data_transfer_size,
1097 : m_libspdm_get_capabilities_request19.data_transfer_size);
1098 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1099 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t));
1100 1 : spdm_response = (void *)response;
1101 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
1102 1 : assert_int_equal(spdm_response->header.request_response_code,
1103 : SPDM_CAPABILITIES);
1104 1 : assert_int_equal(spdm_response->data_transfer_size, LIBSPDM_DATA_TRANSFER_SIZE);
1105 1 : assert_int_equal(spdm_response->max_spdm_msg_size, LIBSPDM_MAX_SPDM_MSG_SIZE);
1106 1 : }
1107 :
1108 1 : void libspdm_test_responder_capabilities_case25(void **state)
1109 : {
1110 : libspdm_return_t status;
1111 : libspdm_test_context_t *spdm_test_context;
1112 : libspdm_context_t *spdm_context;
1113 : size_t response_size;
1114 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1115 : spdm_capabilities_response_t *spdm_response;
1116 :
1117 1 : spdm_test_context = *state;
1118 1 : spdm_context = spdm_test_context->spdm_context;
1119 1 : spdm_test_context->case_id = 0x19;
1120 1 : spdm_context->connection_info.connection_state =
1121 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
1122 :
1123 1 : response_size = sizeof(response);
1124 1 : status = libspdm_get_response_capabilities(
1125 : spdm_context, m_libspdm_get_capabilities_request25_size,
1126 : &m_libspdm_get_capabilities_request25, &response_size, response);
1127 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1128 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1129 1 : spdm_response = (void *)response;
1130 1 : assert_int_equal(m_libspdm_get_capabilities_request25.header.spdm_version,
1131 : spdm_response->header.spdm_version);
1132 1 : assert_int_equal(spdm_response->header.request_response_code,
1133 : SPDM_ERROR);
1134 1 : assert_int_equal(spdm_response->header.param1,
1135 : SPDM_ERROR_CODE_INVALID_REQUEST);
1136 1 : assert_int_equal(spdm_response->header.param2, 0);
1137 1 : }
1138 :
1139 1 : void libspdm_test_responder_capabilities_case26(void **state)
1140 : {
1141 : libspdm_return_t status;
1142 : libspdm_test_context_t *spdm_test_context;
1143 : libspdm_context_t *spdm_context;
1144 : size_t response_size;
1145 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1146 : spdm_capabilities_response_t *spdm_response;
1147 :
1148 1 : spdm_test_context = *state;
1149 1 : spdm_context = spdm_test_context->spdm_context;
1150 1 : spdm_test_context->case_id = 0x1A;
1151 1 : spdm_context->connection_info.connection_state =
1152 : LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
1153 :
1154 1 : response_size = sizeof(response);
1155 1 : status = libspdm_get_response_capabilities(
1156 : spdm_context, m_libspdm_get_capabilities_request26_size,
1157 : &m_libspdm_get_capabilities_request26, &response_size, response);
1158 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1159 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1160 1 : spdm_response = (void *)response;
1161 1 : assert_int_equal(m_libspdm_get_capabilities_request26.header.spdm_version,
1162 : spdm_response->header.spdm_version);
1163 1 : assert_int_equal(spdm_response->header.request_response_code,
1164 : SPDM_ERROR);
1165 1 : assert_int_equal(spdm_response->header.param1,
1166 : SPDM_ERROR_CODE_INVALID_REQUEST);
1167 1 : assert_int_equal(spdm_response->header.param2, 0);
1168 1 : }
1169 :
1170 1 : void libspdm_test_responder_capabilities_case27(void **state)
1171 : {
1172 : libspdm_return_t status;
1173 : libspdm_test_context_t *spdm_test_context;
1174 : libspdm_context_t *spdm_context;
1175 : size_t response_size;
1176 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1177 : spdm_capabilities_response_t *spdm_response;
1178 :
1179 1 : spdm_test_context = *state;
1180 1 : spdm_context = spdm_test_context->spdm_context;
1181 1 : spdm_test_context->case_id = 0x1B;
1182 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
1183 :
1184 1 : response_size = sizeof(response);
1185 1 : status = libspdm_get_response_capabilities(
1186 : spdm_context, m_libspdm_get_capabilities_request27_size,
1187 : &m_libspdm_get_capabilities_request27, &response_size, response);
1188 :
1189 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1190 1 : assert_int_equal(response_size, sizeof(spdm_capabilities_response_t));
1191 1 : spdm_response = (void *)response;
1192 1 : assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
1193 1 : assert_int_equal(spdm_response->header.request_response_code,
1194 : SPDM_CAPABILITIES);
1195 1 : assert_int_equal(spdm_response->data_transfer_size, LIBSPDM_DATA_TRANSFER_SIZE);
1196 1 : assert_int_equal(spdm_response->max_spdm_msg_size, LIBSPDM_MAX_SPDM_MSG_SIZE);
1197 1 : assert_int_equal(spdm_context->connection_info.capability.flags,
1198 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CERT_CAP |
1199 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_EP_INFO_CAP_SIG |
1200 : SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY);
1201 1 : }
1202 :
1203 1 : int libspdm_responder_capabilities_test_main(void)
1204 : {
1205 1 : const struct CMUnitTest spdm_responder_capabilities_tests[] = {
1206 : /* Success Case*/
1207 : cmocka_unit_test(libspdm_test_responder_capabilities_case1),
1208 : /* Success case where request size is larger than actual message. */
1209 : cmocka_unit_test(libspdm_test_responder_capabilities_case2),
1210 : /* response_state: LIBSPDM_RESPONSE_STATE_BUSY*/
1211 : cmocka_unit_test(libspdm_test_responder_capabilities_case3),
1212 : /* response_state: LIBSPDM_RESPONSE_STATE_NEED_RESYNC*/
1213 : cmocka_unit_test(libspdm_test_responder_capabilities_case4),
1214 : /* connection_state Check*/
1215 : cmocka_unit_test(libspdm_test_responder_capabilities_case6),
1216 : /* Invalid requester capabilities flag (random flag)*/
1217 : cmocka_unit_test(libspdm_test_responder_capabilities_case7),
1218 : /* V1.1 Success case, all possible flags set*/
1219 : cmocka_unit_test(libspdm_test_responder_capabilities_case8),
1220 : /* Requester capabilities flag bit 0 is set. reserved value should ne ignored*/
1221 : cmocka_unit_test(libspdm_test_responder_capabilities_case9),
1222 : /* Can be populated with new test. */
1223 : cmocka_unit_test(libspdm_test_responder_capabilities_case10),
1224 : /* Can be populated with new test. */
1225 : cmocka_unit_test(libspdm_test_responder_capabilities_case11),
1226 : /* Can be populated with new test. */
1227 : cmocka_unit_test(libspdm_test_responder_capabilities_case12),
1228 : /* pub_key_id_cap and cert_cap set (flags are mutually exclusive)*/
1229 : cmocka_unit_test(libspdm_test_responder_capabilities_case13),
1230 : /* encrypt_cap set and key_ex_cap and psk_cap cleared (encrypt_cap demands key_ex_cap or psk_cap to be set)*/
1231 : cmocka_unit_test(libspdm_test_responder_capabilities_case14),
1232 : /* mac_cap set and key_ex_cap and psk_cap cleared (mac_cap demands key_ex_cap or psk_cap to be set)*/
1233 : cmocka_unit_test(libspdm_test_responder_capabilities_case15),
1234 : /* key_ex_cap set and encrypt_cap and mac_cap cleared (key_ex_cap demands encrypt_cap or mac_cap to be set)*/
1235 : cmocka_unit_test(libspdm_test_responder_capabilities_case16),
1236 : /* psk_cap set and encrypt_cap and mac_cap cleared (psk_cap demands encrypt_cap or mac_cap to be set)*/
1237 : cmocka_unit_test(libspdm_test_responder_capabilities_case17),
1238 : /* encap_cap cleared and MUT_AUTH set (MUT_AUTH demands encap_cap to be set)*/
1239 : cmocka_unit_test(libspdm_test_responder_capabilities_case18),
1240 : /* cert_cap set and pub_key_id_cap set (pub_key_id_cap demands cert_cap to be cleared)*/
1241 : cmocka_unit_test(libspdm_test_responder_capabilities_case19),
1242 : /* key_ex_cap cleared and handshake_in_the_clear_cap set (handshake_in_the_clear_cap demands key_ex_cap to be set)*/
1243 : cmocka_unit_test(libspdm_test_responder_capabilities_case20),
1244 : /* Open test case */
1245 : cmocka_unit_test(libspdm_test_responder_capabilities_case21),
1246 : /* cert_cap cleared and pub_key_id_cap set (pub_key_id_cap demands cert_cap to be cleared)*/
1247 : cmocka_unit_test(libspdm_test_responder_capabilities_case22),
1248 : /* Buffer verification*/
1249 : cmocka_unit_test(libspdm_test_responder_capabilities_case23),
1250 : /* V1.2 Success case, all possible flags set*/
1251 : cmocka_unit_test(libspdm_test_responder_capabilities_case24),
1252 : /* CHUNK_CAP == 0 and data_transfer_size != max_spdm_msg_size should result in error. */
1253 : cmocka_unit_test(libspdm_test_responder_capabilities_case25),
1254 : /* MaxSPDMmsgSize is less than DataTransferSize, then should result in error. */
1255 : cmocka_unit_test(libspdm_test_responder_capabilities_case26),
1256 : /* Success Case , capability supports MULTI_KEY_CAP */
1257 : cmocka_unit_test(libspdm_test_responder_capabilities_case27),
1258 : };
1259 :
1260 1 : libspdm_test_context_t test_context = {
1261 : LIBSPDM_TEST_CONTEXT_VERSION,
1262 : false,
1263 : };
1264 :
1265 1 : libspdm_setup_test_context(&test_context);
1266 :
1267 1 : return cmocka_run_group_tests(spdm_responder_capabilities_tests,
1268 : libspdm_unit_test_group_setup,
1269 : libspdm_unit_test_group_teardown);
1270 : }
|
