Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2026 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 :
10 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP
11 :
12 : #define LIBSPDM_MAX_CSR_SIZE 0x1000
13 :
14 : /*refer to https://github.com/Mbed-TLS/mbedtls/blob/3048c8c90654eb116a6b17c0d2d27c3ccbe6782c/programs/x509/cert_req.c#L119-L129*/
15 : #define LIBSPDM_MAX_REQ_INFO_BUFFER_SIZE 4096
16 :
17 : uint8_t m_csr_opaque_data[8] = "libspdm";
18 :
19 : /*ECC 256 req_info(include right req_info attribute)*/
20 : uint8_t req_info_sequence[] = {0x30, 0x81, 0xBF,};
21 : uint8_t req_info_version[] = {0x02, 0x01, 0x00,};
22 : uint8_t req_info_subject[] = {
23 : 0x30, 0x45, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31,
24 : 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0C, 0x0A, 0x53, 0x6F, 0x6D, 0x65, 0x2D, 0x53,
25 : 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x0C, 0x18, 0x49,
26 : 0x6E, 0x74, 0x65, 0x72, 0x6E, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20,
27 : 0x50, 0x74, 0x79, 0x20, 0x4C, 0x74, 0x64,
28 : };
29 : uint8_t req_info_right_attributes[] = {
30 : /*[0]: attributes*/
31 : 0xA0, 0x18, 0x30, 0x16,
32 : /*OID*/
33 : 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x07,
34 : /*attributes*/
35 : 0x31, 0x09, 0x0C, 0x07, 0x74, 0x65, 0x73, 0x74, 0x31, 0x32, 0x33
36 : };
37 :
38 : /*the unique attribute from right_req_info*/
39 : uint8_t right_req_info_string[] = {0x74, 0x65, 0x73, 0x74, 0x31, 0x32, 0x33};
40 : /*the default subject without req_info*/
41 : uint8_t default_subject1[] = {
42 : 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x4E, 0x4C,
43 : };
44 :
45 : uint8_t default_subject2[] = {
46 : 0x06, 0x03, 0x55, 0x04, 0x0A, 0x0C, 0x08, 0x50, 0x6F, 0x6C, 0x61, 0x72, 0x53, 0x53, 0x4C,
47 : };
48 : uint8_t default_subject3[] = {
49 : 0x0C, 0x11, 0x50, 0x6F, 0x6C, 0x61, 0x72, 0x53, 0x53, 0x4C, 0x20, 0x53, 0x65, 0x72, 0x76,
50 : 0x65, 0x72, 0x20, 0x31
51 : };
52 :
53 : static uint8_t right_req_info[LIBSPDM_MAX_REQ_INFO_BUFFER_SIZE];
54 : static uint8_t wrong_req_info[LIBSPDM_MAX_REQ_INFO_BUFFER_SIZE];
55 : static uint16_t req_info_len;
56 :
57 : /*gen right_req_info and wrong_req_info*/
58 1 : void libspdm_gen_req_info()
59 : {
60 : uint8_t *req_info_p;
61 : void *req_info_pkinfo;
62 : size_t req_info_pkinfo_len;
63 :
64 1 : libspdm_zero_mem(right_req_info, sizeof(right_req_info));
65 1 : libspdm_zero_mem(wrong_req_info, sizeof(wrong_req_info));
66 :
67 1 : req_info_p = right_req_info;
68 1 : req_info_len = sizeof(right_req_info);
69 :
70 1 : if (!libspdm_read_responder_public_key(m_libspdm_use_asym_algo,
71 : &req_info_pkinfo, &req_info_pkinfo_len)) {
72 0 : return;
73 : }
74 :
75 : /*concat right_req_info*/
76 1 : libspdm_copy_mem(req_info_p, req_info_len, req_info_sequence, sizeof(req_info_sequence));
77 1 : req_info_p += sizeof(req_info_sequence);
78 1 : req_info_len -= sizeof(req_info_sequence);
79 :
80 1 : libspdm_copy_mem(req_info_p, req_info_len, req_info_version, sizeof(req_info_version));
81 1 : req_info_p += sizeof(req_info_version);
82 1 : req_info_len -= sizeof(req_info_version);
83 :
84 1 : libspdm_copy_mem(req_info_p, req_info_len, req_info_subject, sizeof(req_info_subject));
85 1 : req_info_p += sizeof(req_info_subject);
86 1 : req_info_len -= sizeof(req_info_subject);
87 :
88 1 : libspdm_copy_mem(req_info_p, req_info_len, req_info_pkinfo, req_info_pkinfo_len);
89 1 : req_info_p += req_info_pkinfo_len;
90 1 : req_info_len = (uint16_t)(req_info_len - req_info_pkinfo_len);
91 :
92 1 : libspdm_copy_mem(req_info_p, req_info_len,
93 : req_info_right_attributes, sizeof(req_info_right_attributes));
94 1 : req_info_p += sizeof(req_info_right_attributes);
95 1 : req_info_len -= sizeof(req_info_right_attributes);
96 :
97 1 : req_info_len = sizeof(right_req_info) - req_info_len;
98 :
99 : /*concat wrong_req_info*/
100 1 : libspdm_copy_mem(wrong_req_info, sizeof(wrong_req_info), right_req_info, req_info_len);
101 : /*make the wrong_req_info is wrong*/
102 1 : *wrong_req_info = '1';
103 :
104 1 : free(req_info_pkinfo);
105 : }
106 :
107 : /*find destination buffer from source buffer*/
108 7 : bool libspdm_find_buffer(uint8_t *src, size_t src_len, uint8_t *dst, size_t dst_len)
109 : {
110 : size_t index;
111 :
112 7 : if ((src == NULL) || (dst == NULL)) {
113 0 : return false;
114 : }
115 :
116 7 : if (src_len < dst_len) {
117 0 : return false;
118 : }
119 :
120 552 : for (index = 0; index < src_len - dst_len; index++) {
121 552 : if ((*(src + index) == *dst) && libspdm_consttime_is_mem_equal(src + index, dst, dst_len)) {
122 7 : return true;
123 : }
124 : }
125 :
126 0 : return false;
127 : }
128 :
129 : /*get the cached csr*/
130 6 : bool libspdm_test_read_cached_csr(uint8_t **csr_pointer, size_t *csr_len)
131 : {
132 : bool res;
133 : char *file;
134 :
135 6 : file = "test_csr/cached.csr";
136 :
137 6 : res = libspdm_read_input_file(file, (void **)csr_pointer, csr_len);
138 6 : return res;
139 : }
140 :
141 : /*
142 : * If device need reset to set csr, the function simulates the CSR state before device reset.
143 : * The returned status indicates whether the setting was successful or unsuccessful.
144 : **/
145 5 : bool libspdm_set_csr_before_reset()
146 : {
147 5 : char *file_name = "test_csr/cached.csr";
148 5 : char *new_name = "test_csr/cached.staging";
149 :
150 5 : if (rename(file_name, new_name) != 0) {
151 0 : return false;
152 : }
153 :
154 5 : return true;
155 : }
156 :
157 : /*
158 : * If device need reset to set csr, the function simulates the CSR state after device reset.
159 : * The returned status indicates whether the setting was successful or unsuccessful.
160 : **/
161 5 : bool libspdm_set_csr_after_reset()
162 : {
163 5 : char *file_name = "test_csr/cached.csr";
164 5 : char *new_name = "test_csr/cached.staging";
165 :
166 5 : if (rename(new_name, file_name) != 0) {
167 0 : return false;
168 : }
169 :
170 5 : return true;
171 : }
172 :
173 : /*ensure that cached.csr exists in test_csr at the beginning*/
174 1 : void libspdm_clear_cached_csr()
175 : {
176 1 : char *new_name = "test_csr/cached.csr";
177 1 : char *file_name = "test_csr/cached.staging";
178 :
179 1 : rename(file_name, new_name);
180 1 : }
181 :
182 : /*clean the cached last SPDM csr request*/
183 6 : void libspdm_test_clear_cached_last_request()
184 : {
185 : uint8_t index;
186 :
187 6 : char file[] = "cached_last_csr_x_request";
188 :
189 48 : for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) {
190 42 : file[16] = (char)(index + '0');
191 42 : libspdm_write_output_file(file, NULL, 0);
192 : }
193 6 : }
194 :
195 : /*check the csr is consistent with the is_device_cert_model*/
196 2 : bool libspdm_check_csr_basic_constraints(uint8_t *csr, uint16_t csr_len, bool is_device_cert_model)
197 : {
198 : bool result;
199 : uint8_t *ptr;
200 : uint16_t length;
201 : size_t obj_len;
202 : uint8_t *end;
203 :
204 : /*basic_constraints: CA: false */
205 : #define BASIC_CONSTRAINTS_STRING_FALSE {0x30, 0x00}
206 2 : uint8_t basic_constraints_false[] = BASIC_CONSTRAINTS_STRING_FALSE;
207 :
208 : /*basic_constraints: CA: true */
209 : #define BASIC_CONSTRAINTS_STRING_TRUE {0x30, 0x03, 0x01, 0x01, 0xFF}
210 2 : uint8_t basic_constraints_true[] = BASIC_CONSTRAINTS_STRING_TRUE;
211 :
212 2 : length = csr_len;
213 2 : ptr = (uint8_t*)csr;
214 2 : obj_len = 0;
215 2 : end = ptr + length;
216 :
217 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
218 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
219 2 : if (!result) {
220 0 : return false;
221 : }
222 :
223 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
224 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
225 2 : if (!result) {
226 0 : return false;
227 : }
228 :
229 2 : end = ptr + obj_len;
230 :
231 : /*version*/
232 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len, LIBSPDM_CRYPTO_ASN1_INTEGER);
233 2 : if (!result) {
234 0 : return false;
235 : }
236 2 : ptr += obj_len;
237 :
238 : /*subject*/
239 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
240 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
241 2 : if (!result) {
242 0 : return false;
243 : }
244 2 : ptr += obj_len;
245 :
246 : /*PKinfo*/
247 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
248 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
249 2 : if (!result) {
250 0 : return false;
251 : }
252 2 : ptr += obj_len;
253 :
254 : /*attribute*/
255 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
256 : LIBSPDM_CRYPTO_ASN1_CONTEXT_SPECIFIC |
257 : LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
258 2 : if (!result) {
259 0 : return false;
260 : }
261 :
262 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
263 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
264 2 : if (!result) {
265 0 : return false;
266 : }
267 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len, LIBSPDM_CRYPTO_ASN1_OID);
268 2 : if (!result) {
269 0 : return false;
270 : }
271 2 : ptr += obj_len;
272 :
273 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
274 : LIBSPDM_CRYPTO_ASN1_SET | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
275 2 : if (!result) {
276 0 : return false;
277 : }
278 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
279 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
280 2 : if (!result) {
281 0 : return false;
282 : }
283 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len,
284 : LIBSPDM_CRYPTO_ASN1_SEQUENCE | LIBSPDM_CRYPTO_ASN1_CONSTRUCTED);
285 2 : if (!result) {
286 0 : return false;
287 : }
288 : /*basic constraints oid*/
289 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len, LIBSPDM_CRYPTO_ASN1_OID);
290 2 : if (!result) {
291 0 : return false;
292 : }
293 2 : ptr += obj_len;
294 :
295 : /*basic constraints*/
296 2 : result = libspdm_asn1_get_tag(&ptr, end, &obj_len, LIBSPDM_CRYPTO_ASN1_OCTET_STRING);
297 2 : if (!result) {
298 0 : return false;
299 : }
300 :
301 2 : if (is_device_cert_model) {
302 1 : result = libspdm_consttime_is_mem_equal(
303 : ptr, basic_constraints_false, sizeof(basic_constraints_false));
304 : } else {
305 1 : result = libspdm_consttime_is_mem_equal(
306 : ptr, basic_constraints_true, sizeof(basic_constraints_true));
307 : }
308 :
309 2 : return result;
310 : }
311 :
312 : /**
313 : * Test 1: receives a valid GET_CSR request message from Requester
314 : * Expected Behavior: produces a valid CSR response message with device_cert mode
315 : **/
316 1 : static void rsp_csr_case1(void **state)
317 : {
318 : libspdm_return_t status;
319 : libspdm_test_context_t *spdm_test_context;
320 : libspdm_context_t *spdm_context;
321 : size_t response_size;
322 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
323 : spdm_csr_response_t *spdm_response;
324 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
325 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
326 : bool result;
327 : bool is_device_cert_model;
328 :
329 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
330 :
331 1 : spdm_test_context = *state;
332 1 : spdm_context = spdm_test_context->spdm_context;
333 1 : spdm_test_context->case_id = 0x1;
334 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
335 : SPDM_VERSION_NUMBER_SHIFT_BIT;
336 :
337 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
338 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
339 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
340 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
341 :
342 1 : is_device_cert_model = true;
343 1 : spdm_context->local_context.capability.flags &=
344 : ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ALIAS_CERT_CAP;
345 :
346 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t));
347 :
348 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
349 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
350 1 : m_libspdm_get_csr_request->header.param1 = 0;
351 1 : m_libspdm_get_csr_request->header.param2 = 0;
352 :
353 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
354 1 : m_libspdm_get_csr_request->requester_info_length = 0;
355 :
356 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t);
357 :
358 : /*init req_info*/
359 1 : libspdm_gen_req_info();
360 :
361 1 : response_size = sizeof(response);
362 1 : status = libspdm_get_response_csr(spdm_context,
363 : m_libspdm_get_csr_request_size,
364 : m_libspdm_get_csr_request,
365 : &response_size, response);
366 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
367 :
368 1 : spdm_response = (void *)response;
369 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
370 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
371 :
372 : /*check returned CSR not zero */
373 1 : assert_memory_not_equal(spdm_response + 1, wrong_csr, spdm_response->csr_length);
374 :
375 : /*check the resulting CSR shall be for a Device Certificate*/
376 1 : result = libspdm_check_csr_basic_constraints((uint8_t *)(spdm_response + 1),
377 1 : spdm_response->csr_length, is_device_cert_model);
378 1 : assert_true(result);
379 :
380 : /*check that returned CSR contains default subject*/
381 1 : assert_true(libspdm_find_buffer((uint8_t *)(spdm_response + 1), spdm_response->csr_length,
382 : default_subject1, sizeof(default_subject1)));
383 1 : assert_true(libspdm_find_buffer((uint8_t *)(spdm_response + 1), spdm_response->csr_length,
384 : default_subject2, sizeof(default_subject2)));
385 1 : assert_true(libspdm_find_buffer((uint8_t *)(spdm_response + 1), spdm_response->csr_length,
386 : default_subject3, sizeof(default_subject3)));
387 1 : free(m_libspdm_get_csr_request);
388 1 : }
389 :
390 : /**
391 : * Test 2: Wrong GET_CSR message size (larger than expected)
392 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_INVALID_REQUEST
393 : **/
394 1 : static void rsp_csr_case2(void **state)
395 : {
396 : libspdm_return_t status;
397 : libspdm_test_context_t *spdm_test_context;
398 : libspdm_context_t *spdm_context;
399 : size_t response_size;
400 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
401 : spdm_csr_response_t *spdm_response;
402 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
403 :
404 1 : spdm_test_context = *state;
405 1 : spdm_context = spdm_test_context->spdm_context;
406 1 : spdm_test_context->case_id = 0x2;
407 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
408 : SPDM_VERSION_NUMBER_SHIFT_BIT;
409 :
410 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
411 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
412 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
413 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
414 :
415 :
416 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t));
417 :
418 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
419 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
420 1 : m_libspdm_get_csr_request->header.param1 = 0;
421 1 : m_libspdm_get_csr_request->header.param2 = 0;
422 :
423 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
424 1 : m_libspdm_get_csr_request->requester_info_length = 0;
425 :
426 : /* Bad request size*/
427 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) - 1;
428 :
429 1 : response_size = sizeof(response);
430 1 : status = libspdm_get_response_csr(spdm_context,
431 : m_libspdm_get_csr_request_size,
432 : m_libspdm_get_csr_request,
433 : &response_size, response);
434 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
435 :
436 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
437 1 : spdm_response = (void *)response;
438 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
439 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
440 1 : assert_int_equal(spdm_response->header.param2, 0);
441 :
442 1 : free(m_libspdm_get_csr_request);
443 1 : }
444 :
445 : /**
446 : * Test 3: receives a valid GET_CSR request message from Requester with non-null right req_info
447 : * Expected Behavior: produces a valid CSR response message
448 : **/
449 1 : static void rsp_csr_case3(void **state)
450 : {
451 : libspdm_return_t status;
452 : libspdm_test_context_t *spdm_test_context;
453 : libspdm_context_t *spdm_context;
454 : size_t response_size;
455 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
456 : spdm_csr_response_t *spdm_response;
457 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
458 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
459 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
460 : uint8_t *csr;
461 :
462 1 : spdm_test_context = *state;
463 1 : spdm_context = spdm_test_context->spdm_context;
464 1 : spdm_test_context->case_id = 0x3;
465 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
466 : SPDM_VERSION_NUMBER_SHIFT_BIT;
467 :
468 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
469 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
470 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
471 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
472 :
473 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
474 :
475 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
476 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
477 1 : m_libspdm_get_csr_request->header.param1 = 0;
478 1 : m_libspdm_get_csr_request->header.param2 = 0;
479 :
480 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
481 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
482 :
483 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
484 :
485 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
486 : req_info_len;
487 :
488 1 : response_size = sizeof(response);
489 1 : status = libspdm_get_response_csr(spdm_context,
490 : m_libspdm_get_csr_request_size,
491 : m_libspdm_get_csr_request,
492 : &response_size, response);
493 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
494 :
495 1 : spdm_response = (void *)response;
496 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
497 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
498 :
499 : /*check returned CSR not zero */
500 1 : assert_memory_not_equal(spdm_response + 1, wrong_csr, spdm_response->csr_length);
501 :
502 1 : csr = (uint8_t *)(spdm_response + 1);
503 : /*check that returned CSR contains req_info attribute*/
504 1 : assert_true(libspdm_find_buffer(csr, spdm_response->csr_length,
505 : right_req_info_string, sizeof(right_req_info_string)));
506 :
507 : /*check that returned CSR contains req_info subject*/
508 1 : assert_true(libspdm_find_buffer(csr, spdm_response->csr_length,
509 : req_info_subject, sizeof(req_info_subject)));
510 :
511 1 : free(m_libspdm_get_csr_request);
512 1 : }
513 :
514 : /**
515 : * Test 4: receives a valid GET_CSR request message from Requester with non-null opaque_data
516 : * Expected Behavior: produces a valid CSR response message
517 : **/
518 1 : static void rsp_csr_case4(void **state)
519 : {
520 : libspdm_return_t status;
521 : libspdm_test_context_t *spdm_test_context;
522 : libspdm_context_t *spdm_context;
523 : size_t response_size;
524 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
525 : spdm_csr_response_t *spdm_response;
526 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
527 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
528 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
529 :
530 1 : spdm_test_context = *state;
531 1 : spdm_context = spdm_test_context->spdm_context;
532 1 : spdm_test_context->case_id = 0x4;
533 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
534 : SPDM_VERSION_NUMBER_SHIFT_BIT;
535 :
536 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
537 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
538 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
539 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
540 1 : spdm_context->connection_info.algorithm.other_params_support =
541 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0;
542 :
543 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + sizeof(m_csr_opaque_data));
544 :
545 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
546 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
547 1 : m_libspdm_get_csr_request->header.param1 = 0;
548 1 : m_libspdm_get_csr_request->header.param2 = 0;
549 :
550 1 : m_libspdm_get_csr_request->opaque_data_length = sizeof(m_csr_opaque_data);
551 1 : m_libspdm_get_csr_request->requester_info_length = 0;
552 :
553 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, sizeof(m_csr_opaque_data),
554 : m_csr_opaque_data, sizeof(m_csr_opaque_data));
555 :
556 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
557 : sizeof(m_csr_opaque_data);
558 :
559 1 : response_size = sizeof(response);
560 1 : status = libspdm_get_response_csr(spdm_context,
561 : m_libspdm_get_csr_request_size,
562 : m_libspdm_get_csr_request,
563 : &response_size, response);
564 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
565 :
566 1 : spdm_response = (void *)response;
567 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
568 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
569 :
570 : /*check returned CSR not zero */
571 1 : assert_memory_not_equal(spdm_response + 1, wrong_csr, spdm_response->csr_length);
572 :
573 1 : free(m_libspdm_get_csr_request);
574 1 : }
575 :
576 : /**
577 : * Test 5: receives a valid GET_CSR request message from Requester with non-null wrong req_info
578 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_INVALID_REQUEST
579 : **/
580 1 : static void rsp_csr_case5(void **state)
581 : {
582 : libspdm_return_t status;
583 : libspdm_test_context_t *spdm_test_context;
584 : libspdm_context_t *spdm_context;
585 : size_t response_size;
586 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
587 : spdm_csr_response_t *spdm_response;
588 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
589 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
590 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
591 :
592 1 : spdm_test_context = *state;
593 1 : spdm_context = spdm_test_context->spdm_context;
594 1 : spdm_test_context->case_id = 0x5;
595 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
596 : SPDM_VERSION_NUMBER_SHIFT_BIT;
597 :
598 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
599 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
600 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
601 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
602 :
603 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
604 :
605 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
606 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
607 1 : m_libspdm_get_csr_request->header.param1 = 0;
608 1 : m_libspdm_get_csr_request->header.param2 = 0;
609 :
610 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
611 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
612 :
613 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, wrong_req_info, req_info_len);
614 :
615 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
616 : req_info_len;
617 :
618 1 : response_size = sizeof(response);
619 1 : status = libspdm_get_response_csr(spdm_context,
620 : m_libspdm_get_csr_request_size,
621 : m_libspdm_get_csr_request,
622 : &response_size, response);
623 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
624 :
625 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
626 1 : spdm_response = (void *)response;
627 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
628 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
629 1 : assert_int_equal(spdm_response->header.param2, 0);
630 :
631 1 : free(m_libspdm_get_csr_request);
632 1 : }
633 :
634 : /**
635 : * Test 6: receives a valid GET_CSR request message from Requester with need_reset
636 : * Expected Behavior: the first get_csr: responder return need reset;
637 : * the second get_csr after device reset: get the cached valid csr;
638 : **/
639 1 : static void rsp_csr_case6(void **state)
640 : {
641 : libspdm_return_t status;
642 : libspdm_test_context_t *spdm_test_context;
643 : libspdm_context_t *spdm_context;
644 : size_t response_size;
645 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
646 : spdm_csr_response_t *spdm_response;
647 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
648 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
649 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
650 :
651 : uint8_t *csr_pointer;
652 : size_t csr_len;
653 :
654 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
655 0 : assert_false(true);
656 : }
657 :
658 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
659 1 : free(csr_pointer);
660 :
661 1 : spdm_test_context = *state;
662 1 : spdm_context = spdm_test_context->spdm_context;
663 1 : spdm_test_context->case_id = 0x6;
664 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
665 : SPDM_VERSION_NUMBER_SHIFT_BIT;
666 :
667 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
668 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
669 :
670 : /*set responder need reset*/
671 1 : spdm_context->local_context.capability.flags |=
672 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
673 :
674 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
675 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
676 :
677 : /*set csr before reset*/
678 1 : assert_true(libspdm_set_csr_before_reset());
679 :
680 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
681 :
682 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
683 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
684 1 : m_libspdm_get_csr_request->header.param1 = 0;
685 1 : m_libspdm_get_csr_request->header.param2 = 0;
686 :
687 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
688 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
689 :
690 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
691 :
692 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
693 : req_info_len;
694 :
695 1 : response_size = sizeof(response);
696 :
697 1 : status = libspdm_get_response_csr(spdm_context,
698 : m_libspdm_get_csr_request_size,
699 : m_libspdm_get_csr_request,
700 : &response_size, response);
701 : /*first get_csr: the responder need reset*/
702 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
703 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
704 1 : spdm_response = (void *)response;
705 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
706 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
707 1 : assert_int_equal(spdm_response->header.param2, 0);
708 :
709 : /*set csr after reset*/
710 1 : assert_true(libspdm_set_csr_after_reset());
711 :
712 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
713 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
714 1 : m_libspdm_get_csr_request->header.param1 = 0;
715 1 : m_libspdm_get_csr_request->header.param2 = 0;
716 :
717 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
718 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
719 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
720 :
721 1 : response_size = sizeof(response);
722 1 : status = libspdm_get_response_csr(spdm_context,
723 : m_libspdm_get_csr_request_size,
724 : m_libspdm_get_csr_request,
725 : &response_size, response);
726 : /*second get_csr after device reset: get the responder cached csr*/
727 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
728 :
729 1 : spdm_response = (void *)response;
730 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
731 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
732 :
733 : /*check returned CSR is equal the cached CSR */
734 1 : assert_memory_equal(spdm_response + 1, cached_csr, spdm_response->csr_length);
735 :
736 : /*clear cached req_info*/
737 1 : libspdm_test_clear_cached_last_request();
738 1 : free(m_libspdm_get_csr_request);
739 1 : }
740 :
741 : /**
742 : * Test 7: receives a valid GET_CSR request message from Requester with non-null right req_info and opaque_data
743 : * Expected Behavior: produces a valid CSR response message
744 : **/
745 1 : static void rsp_csr_case7(void **state)
746 : {
747 : libspdm_return_t status;
748 : libspdm_test_context_t *spdm_test_context;
749 : libspdm_context_t *spdm_context;
750 : size_t response_size;
751 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
752 : spdm_csr_response_t *spdm_response;
753 : spdm_get_csr_request_t *libspdm_get_csr_request;
754 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
755 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
756 : uint8_t *csr;
757 :
758 1 : spdm_test_context = *state;
759 1 : spdm_context = spdm_test_context->spdm_context;
760 1 : spdm_test_context->case_id = 0x7;
761 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
762 : SPDM_VERSION_NUMBER_SHIFT_BIT;
763 :
764 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
765 1 : spdm_context->local_context.capability.flags = 0;
766 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
767 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
768 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
769 :
770 1 : libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) +
771 : sizeof(m_csr_opaque_data) +
772 : req_info_len);
773 :
774 1 : libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
775 1 : libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
776 1 : libspdm_get_csr_request->header.param1 = 0;
777 1 : libspdm_get_csr_request->header.param2 = 0;
778 1 : libspdm_get_csr_request->opaque_data_length = sizeof(m_csr_opaque_data);
779 1 : libspdm_get_csr_request->requester_info_length = req_info_len;
780 :
781 1 : libspdm_copy_mem(libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
782 :
783 1 : libspdm_copy_mem((uint8_t *)(libspdm_get_csr_request + 1) + req_info_len,
784 : sizeof(m_csr_opaque_data),
785 : m_csr_opaque_data, sizeof(m_csr_opaque_data));
786 :
787 1 : size_t libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
788 1 : sizeof(m_csr_opaque_data) +
789 : req_info_len;
790 :
791 1 : response_size = sizeof(response);
792 1 : status = libspdm_get_response_csr(spdm_context,
793 : libspdm_get_csr_request_size,
794 : libspdm_get_csr_request,
795 : &response_size, response);
796 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
797 :
798 1 : spdm_response = (void *)response;
799 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
800 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
801 :
802 : /*check returned CSR not zero */
803 1 : assert_memory_not_equal(spdm_response + 1, wrong_csr, spdm_response->csr_length);
804 :
805 1 : csr = (uint8_t *)(spdm_response + 1);
806 1 : assert_true(libspdm_find_buffer(csr, spdm_response->csr_length,
807 : right_req_info_string, sizeof(right_req_info_string)));
808 : /*check that returned CSR contains req_info subject*/
809 1 : assert_true(libspdm_find_buffer(csr, spdm_response->csr_length,
810 : req_info_subject, sizeof(req_info_subject)));
811 :
812 1 : free(libspdm_get_csr_request);
813 1 : }
814 :
815 : /**
816 : * Test 8: receives a invalid GET_CSR request message from Requester With chaotic req_info and opaque_data
817 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_INVALID_REQUEST
818 : **/
819 1 : static void rsp_csr_case8(void **state)
820 : {
821 : libspdm_return_t status;
822 : libspdm_test_context_t *spdm_test_context;
823 : libspdm_context_t *spdm_context;
824 : size_t response_size;
825 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
826 : spdm_csr_response_t *spdm_response;
827 : spdm_get_csr_request_t *libspdm_get_csr_request;
828 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
829 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
830 :
831 1 : spdm_test_context = *state;
832 1 : spdm_context = spdm_test_context->spdm_context;
833 1 : spdm_test_context->case_id = 0x8;
834 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
835 : SPDM_VERSION_NUMBER_SHIFT_BIT;
836 :
837 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
838 1 : spdm_context->local_context.capability.flags = 0;
839 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
840 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
841 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
842 :
843 1 : libspdm_get_csr_request = malloc(LIBSPDM_RECEIVER_BUFFER_SIZE);
844 1 : libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
845 1 : libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
846 1 : libspdm_get_csr_request->header.param1 = 0;
847 1 : libspdm_get_csr_request->header.param2 = 0;
848 :
849 : /* Swap right_req_info and m_csr_opaque_data */
850 1 : libspdm_get_csr_request->opaque_data_length = req_info_len;
851 1 : libspdm_get_csr_request->requester_info_length = sizeof(m_csr_opaque_data);
852 1 : libspdm_copy_mem(libspdm_get_csr_request + 1, sizeof(m_csr_opaque_data),
853 : m_csr_opaque_data, sizeof(m_csr_opaque_data));
854 1 : libspdm_copy_mem((uint8_t *)(libspdm_get_csr_request + 1) + req_info_len,
855 : req_info_len,
856 : right_req_info, req_info_len);
857 :
858 1 : size_t libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
859 1 : sizeof(m_csr_opaque_data) +
860 : req_info_len;
861 :
862 1 : response_size = sizeof(response);
863 1 : status = libspdm_get_response_csr(spdm_context,
864 : libspdm_get_csr_request_size,
865 : libspdm_get_csr_request,
866 : &response_size, response);
867 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
868 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
869 1 : spdm_response = (void *)response;
870 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
871 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
872 1 : assert_int_equal(spdm_response->header.param2, 0);
873 1 : free(libspdm_get_csr_request);
874 1 : }
875 :
876 : /**
877 : * Test 9: receives a valid GET_CSR request message from Requester with non-null opaque_data
878 : * the OpaqueDataFmt1 bit is selected in OtherParamsSelection of ALGORITHMS ,
879 : * Expected Behavior: produces a valid CSR response message
880 : **/
881 1 : static void rsp_csr_case9(void **state)
882 : {
883 : libspdm_return_t status;
884 : libspdm_test_context_t *spdm_test_context;
885 : libspdm_context_t *spdm_context;
886 : size_t response_size;
887 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
888 : spdm_csr_response_t *spdm_response;
889 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
890 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
891 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
892 : spdm_general_opaque_data_table_header_t
893 : *spdm_general_opaque_data_table_header;
894 : opaque_element_table_header_t
895 : *opaque_element_table_header;
896 : uint8_t *ptr;
897 : size_t opaque_data_size;
898 : uint8_t element_num;
899 : uint8_t element_index;
900 : size_t current_element_len;
901 : uint16_t opaque_element_data_len;
902 :
903 1 : spdm_test_context = *state;
904 1 : spdm_context = spdm_test_context->spdm_context;
905 1 : spdm_test_context->case_id = 0x9;
906 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
907 : SPDM_VERSION_NUMBER_SHIFT_BIT;
908 :
909 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
910 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
911 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
912 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
913 1 : spdm_context->connection_info.algorithm.other_params_support =
914 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
915 :
916 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + SPDM_MAX_OPAQUE_DATA_SIZE);
917 :
918 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
919 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
920 1 : m_libspdm_get_csr_request->header.param1 = 0;
921 1 : m_libspdm_get_csr_request->header.param2 = 0;
922 :
923 1 : spdm_general_opaque_data_table_header = (void *)(m_libspdm_get_csr_request + 1);
924 1 : spdm_general_opaque_data_table_header->total_elements = 1;
925 1 : opaque_element_table_header = (void *)(spdm_general_opaque_data_table_header + 1);
926 :
927 1 : element_num = spdm_general_opaque_data_table_header->total_elements;
928 1 : opaque_data_size = sizeof(spdm_general_opaque_data_table_header_t);
929 :
930 2 : for (element_index = 0; element_index < element_num; element_index++) {
931 1 : opaque_element_table_header->id = SPDM_REGISTRY_ID_MAX;
932 1 : opaque_element_table_header->vendor_len = 0;
933 1 : opaque_element_data_len = 8;
934 :
935 1 : ptr = (void *)(opaque_element_table_header + 1);
936 1 : ptr += opaque_element_table_header->vendor_len;
937 :
938 1 : libspdm_copy_mem((uint16_t *)ptr,
939 : sizeof(opaque_element_data_len),
940 : &opaque_element_data_len,
941 : sizeof(opaque_element_data_len));
942 :
943 1 : libspdm_copy_mem(ptr + sizeof(opaque_element_data_len),
944 : SPDM_MAX_OPAQUE_DATA_SIZE -
945 : sizeof(opaque_element_table_header_t), "libspdm",
946 : strlen("libspdm"));
947 :
948 1 : current_element_len = sizeof(opaque_element_table_header_t) +
949 1 : opaque_element_table_header->vendor_len +
950 1 : sizeof(opaque_element_data_len) +
951 : opaque_element_data_len;
952 :
953 1 : current_element_len = (current_element_len + 3) & ~3;
954 :
955 : /*move to next element*/
956 1 : opaque_element_table_header =
957 : (opaque_element_table_header_t *)
958 : ((uint8_t *)opaque_element_table_header + current_element_len);
959 :
960 1 : opaque_data_size += current_element_len;
961 : }
962 :
963 1 : m_libspdm_get_csr_request->opaque_data_length = (uint16_t)opaque_data_size;
964 1 : m_libspdm_get_csr_request->requester_info_length = 0;
965 :
966 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) + opaque_data_size;
967 :
968 1 : response_size = sizeof(response);
969 1 : status = libspdm_get_response_csr(spdm_context,
970 : m_libspdm_get_csr_request_size,
971 : m_libspdm_get_csr_request,
972 : &response_size, response);
973 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
974 :
975 1 : spdm_response = (void *)response;
976 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
977 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
978 :
979 : /*check returned CSR not zero */
980 1 : assert_memory_not_equal(spdm_response + 1, wrong_csr, spdm_response->csr_length);
981 :
982 1 : free(m_libspdm_get_csr_request);
983 1 : }
984 :
985 : /**
986 : * Test 10: receives a invalid GET_CSR request message from Requester with non-null alignPadding in opaque_data is not zero
987 : * the OpaqueDataFmt1 bit is selected in OtherParamsSelection of ALGORITHMS
988 : * Expected Behavior: generate an ERROR_RESPONSE with code SPDM_ERROR_CODE_INVALID_REQUEST
989 : **/
990 1 : static void rsp_csr_case10(void **state)
991 : {
992 : libspdm_return_t status;
993 : libspdm_test_context_t *spdm_test_context;
994 : libspdm_context_t *spdm_context;
995 : size_t response_size;
996 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
997 : spdm_csr_response_t *spdm_response;
998 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
999 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
1000 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
1001 : spdm_general_opaque_data_table_header_t
1002 : *spdm_general_opaque_data_table_header;
1003 : opaque_element_table_header_t
1004 : *opaque_element_table_header;
1005 : uint8_t *ptr;
1006 : size_t opaque_data_size;
1007 : uint8_t element_num;
1008 : uint8_t element_index;
1009 : size_t current_element_len;
1010 : uint16_t opaque_element_data_len;
1011 :
1012 1 : spdm_test_context = *state;
1013 1 : spdm_context = spdm_test_context->spdm_context;
1014 1 : spdm_test_context->case_id = 0xA;
1015 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1016 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1017 :
1018 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1019 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1020 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1021 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1022 1 : spdm_context->connection_info.algorithm.other_params_support =
1023 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_1;
1024 :
1025 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + SPDM_MAX_OPAQUE_DATA_SIZE);
1026 :
1027 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1028 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1029 1 : m_libspdm_get_csr_request->header.param1 = 0;
1030 1 : m_libspdm_get_csr_request->header.param2 = 0;
1031 :
1032 1 : spdm_general_opaque_data_table_header = (void *)(m_libspdm_get_csr_request + 1);
1033 1 : spdm_general_opaque_data_table_header->total_elements = 1;
1034 1 : opaque_element_table_header = (void *)(spdm_general_opaque_data_table_header + 1);
1035 :
1036 1 : element_num = spdm_general_opaque_data_table_header->total_elements;
1037 1 : opaque_data_size = sizeof(spdm_general_opaque_data_table_header_t);
1038 :
1039 2 : for (element_index = 0; element_index < element_num; element_index++) {
1040 1 : opaque_element_table_header->id = SPDM_REGISTRY_ID_MAX;
1041 1 : opaque_element_table_header->vendor_len = 0;
1042 1 : opaque_element_data_len = (uint16_t)strlen("libspdm");
1043 :
1044 1 : ptr = (void *)(opaque_element_table_header + 1);
1045 1 : ptr += opaque_element_table_header->vendor_len;
1046 :
1047 1 : libspdm_copy_mem((uint16_t *)ptr,
1048 : sizeof(opaque_element_data_len),
1049 : &opaque_element_data_len,
1050 : sizeof(opaque_element_data_len));
1051 :
1052 1 : libspdm_copy_mem(ptr + sizeof(opaque_element_data_len),
1053 : SPDM_MAX_OPAQUE_DATA_SIZE -
1054 : sizeof(opaque_element_table_header_t), "libspdm",
1055 : strlen("libspdm"));
1056 :
1057 1 : current_element_len = sizeof(opaque_element_table_header_t) +
1058 1 : opaque_element_table_header->vendor_len +
1059 1 : sizeof(opaque_element_data_len) +
1060 : opaque_element_data_len;
1061 :
1062 1 : *(uint8_t *)((size_t)(opaque_element_table_header) + current_element_len) = 0xFF;
1063 :
1064 1 : current_element_len += 1;
1065 1 : current_element_len = (current_element_len + 3) & ~3;
1066 :
1067 : /*move to next element*/
1068 1 : opaque_element_table_header =
1069 : (opaque_element_table_header_t *)
1070 : ((uint8_t *)opaque_element_table_header + current_element_len);
1071 :
1072 1 : opaque_data_size += current_element_len;
1073 : }
1074 :
1075 1 : m_libspdm_get_csr_request->opaque_data_length = (uint16_t)opaque_data_size;
1076 1 : m_libspdm_get_csr_request->requester_info_length = 0;
1077 :
1078 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) + opaque_data_size;
1079 :
1080 1 : response_size = sizeof(response);
1081 1 : status = libspdm_get_response_csr(spdm_context,
1082 : m_libspdm_get_csr_request_size,
1083 : m_libspdm_get_csr_request,
1084 : &response_size, response);
1085 :
1086 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1087 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1088 1 : spdm_response = (void *)response;
1089 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1090 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1091 1 : assert_int_equal(spdm_response->header.param2, 0);
1092 :
1093 1 : free(m_libspdm_get_csr_request);
1094 1 : }
1095 :
1096 : /**
1097 : * Test 11: receives a valid GET_CSR request message from Requester
1098 : * Expected Behavior: produces a valid CSR response message with alias_cert mode
1099 : **/
1100 1 : static void rsp_csr_case11(void **state)
1101 : {
1102 : libspdm_return_t status;
1103 : libspdm_test_context_t *spdm_test_context;
1104 : libspdm_context_t *spdm_context;
1105 : size_t response_size;
1106 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1107 : spdm_csr_response_t *spdm_response;
1108 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1109 : uint8_t wrong_csr[LIBSPDM_MAX_CSR_SIZE];
1110 : bool result;
1111 : bool is_device_cert_model;
1112 :
1113 1 : libspdm_zero_mem(wrong_csr, LIBSPDM_MAX_CSR_SIZE);
1114 :
1115 1 : spdm_test_context = *state;
1116 1 : spdm_context = spdm_test_context->spdm_context;
1117 1 : spdm_test_context->case_id = 0xB;
1118 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1119 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1120 :
1121 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1122 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1123 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1124 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1125 :
1126 : /*set alias cert mode*/
1127 1 : spdm_context->local_context.capability.flags |=
1128 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ALIAS_CERT_CAP;
1129 1 : is_device_cert_model = false;
1130 :
1131 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t));
1132 :
1133 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1134 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1135 1 : m_libspdm_get_csr_request->header.param1 = 0;
1136 1 : m_libspdm_get_csr_request->header.param2 = 0;
1137 :
1138 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1139 1 : m_libspdm_get_csr_request->requester_info_length = 0;
1140 :
1141 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t);
1142 :
1143 1 : response_size = sizeof(response);
1144 1 : status = libspdm_get_response_csr(spdm_context,
1145 : m_libspdm_get_csr_request_size,
1146 : m_libspdm_get_csr_request,
1147 : &response_size, response);
1148 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1149 :
1150 1 : spdm_response = (void *)response;
1151 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
1152 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
1153 :
1154 : /*check returned CSR not zero */
1155 1 : assert_memory_not_equal(spdm_response + 1, wrong_csr, spdm_response->csr_length);
1156 :
1157 : /*check the resulting CSR shall be for a Device Certificate CA.*/
1158 1 : result = libspdm_check_csr_basic_constraints((uint8_t *)(spdm_response + 1),
1159 1 : spdm_response->csr_length, is_device_cert_model);
1160 1 : assert_true(result);
1161 :
1162 1 : free(m_libspdm_get_csr_request);
1163 1 : }
1164 :
1165 : /**
1166 : * Test 12: receives a valid GET_CSR request message from Requester with need_reset
1167 : * Expected Behavior: the first get_csr: responder return need reset;
1168 : * the second get_csr without device reset: responder return need reset;
1169 : **/
1170 1 : static void rsp_csr_case12(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_csr_response_t *spdm_response;
1178 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1179 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1180 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1181 :
1182 : uint8_t *csr_pointer;
1183 : size_t csr_len;
1184 :
1185 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1186 0 : assert_false(true);
1187 : }
1188 :
1189 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1190 1 : free(csr_pointer);
1191 :
1192 1 : spdm_test_context = *state;
1193 1 : spdm_context = spdm_test_context->spdm_context;
1194 1 : spdm_test_context->case_id = 0xC;
1195 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
1196 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1197 :
1198 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1199 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1200 :
1201 : /*set responder need reset*/
1202 1 : spdm_context->local_context.capability.flags |=
1203 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
1204 :
1205 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1206 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1207 :
1208 : /*set csr before reset*/
1209 1 : assert_true(libspdm_set_csr_before_reset());
1210 :
1211 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
1212 :
1213 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1214 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1215 1 : m_libspdm_get_csr_request->header.param1 = 0;
1216 1 : m_libspdm_get_csr_request->header.param2 = 0;
1217 :
1218 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1219 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1220 :
1221 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1222 :
1223 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
1224 : req_info_len;
1225 :
1226 1 : response_size = sizeof(response);
1227 :
1228 1 : status = libspdm_get_response_csr(spdm_context,
1229 : m_libspdm_get_csr_request_size,
1230 : m_libspdm_get_csr_request,
1231 : &response_size, response);
1232 : /*first get_csr: the responder need reset*/
1233 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1234 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1235 1 : spdm_response = (void *)response;
1236 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1237 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1238 1 : assert_int_equal(spdm_response->header.param2, 0);
1239 :
1240 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_12;
1241 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1242 1 : m_libspdm_get_csr_request->header.param1 = 0;
1243 1 : m_libspdm_get_csr_request->header.param2 = 0;
1244 :
1245 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1246 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1247 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1248 :
1249 1 : response_size = sizeof(response);
1250 :
1251 1 : status = libspdm_get_response_csr(spdm_context,
1252 : m_libspdm_get_csr_request_size,
1253 : m_libspdm_get_csr_request,
1254 : &response_size, response);
1255 : /*second get_csr without device reset: get the responder cached csr*/
1256 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1257 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1258 1 : spdm_response = (void *)response;
1259 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1260 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1261 1 : assert_int_equal(spdm_response->header.param2, 0);
1262 :
1263 : /*clear cached req_info*/
1264 1 : libspdm_test_clear_cached_last_request();
1265 1 : free(m_libspdm_get_csr_request);
1266 :
1267 : /*set csr to the origin state*/
1268 1 : assert_true(libspdm_set_csr_after_reset());
1269 1 : }
1270 :
1271 : /**
1272 : * Test 13: receives a valid GET_CSR request message from Requester with need_reset for SPDM 1.3
1273 : * Expected Behavior: the first get_csr with csr_tracking_tag 0: responder return need reset and available csr_tracking_tag;
1274 : * After reset, the second get_csr with returned available csr_tracking_tag: after device reset: get the cached valid csr;
1275 : **/
1276 1 : static void rsp_csr_case13(void **state)
1277 : {
1278 : libspdm_return_t status;
1279 : libspdm_test_context_t *spdm_test_context;
1280 : libspdm_context_t *spdm_context;
1281 : size_t response_size;
1282 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1283 : spdm_csr_response_t *spdm_response;
1284 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1285 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1286 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1287 :
1288 : uint8_t *csr_pointer;
1289 : size_t csr_len;
1290 : uint8_t csr_tracking_tag;
1291 :
1292 1 : csr_tracking_tag = 0;
1293 :
1294 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1295 0 : assert_false(true);
1296 : }
1297 :
1298 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1299 1 : free(csr_pointer);
1300 :
1301 1 : spdm_test_context = *state;
1302 1 : spdm_context = spdm_test_context->spdm_context;
1303 1 : spdm_test_context->case_id = 0xD;
1304 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1305 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1306 :
1307 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1308 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1309 :
1310 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1311 : /*set responder need reset*/
1312 1 : spdm_context->local_context.capability.flags |=
1313 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
1314 :
1315 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1316 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1317 :
1318 : /*set csr before reset*/
1319 1 : assert_true(libspdm_set_csr_before_reset());
1320 :
1321 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
1322 :
1323 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1324 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1325 1 : m_libspdm_get_csr_request->header.param1 = 1;
1326 1 : m_libspdm_get_csr_request->header.param2 =
1327 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1328 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1329 :
1330 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1331 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1332 :
1333 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1334 :
1335 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
1336 : req_info_len;
1337 :
1338 1 : response_size = sizeof(response);
1339 1 : status = libspdm_get_response_csr(spdm_context,
1340 : m_libspdm_get_csr_request_size,
1341 : m_libspdm_get_csr_request,
1342 : &response_size, response);
1343 :
1344 : /*set csr after reset*/
1345 1 : assert_true(libspdm_set_csr_after_reset());
1346 : /*first get_csr: the responder need reset*/
1347 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1348 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1349 1 : spdm_response = (void *)response;
1350 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1351 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1352 1 : assert_int_equal(spdm_response->header.param2, 1);
1353 :
1354 1 : csr_tracking_tag = spdm_response->header.param2;
1355 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1356 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1357 1 : m_libspdm_get_csr_request->header.param1 = 1;
1358 1 : m_libspdm_get_csr_request->header.param2 =
1359 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1360 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1361 :
1362 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1363 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1364 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1365 :
1366 1 : response_size = sizeof(response);
1367 1 : status = libspdm_get_response_csr(spdm_context,
1368 : m_libspdm_get_csr_request_size,
1369 : m_libspdm_get_csr_request,
1370 : &response_size, response);
1371 : /*second get_csr after device reset: get the responder cached csr*/
1372 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1373 :
1374 1 : spdm_response = (void *)response;
1375 1 : assert_int_equal(response_size, sizeof(spdm_csr_response_t) + spdm_response->csr_length);
1376 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_CSR);
1377 :
1378 : /*check returned CSR is equal the cached CSR */
1379 1 : assert_memory_equal(spdm_response + 1, cached_csr, spdm_response->csr_length);
1380 : /*clear cached req_info*/
1381 1 : libspdm_test_clear_cached_last_request();
1382 1 : free(m_libspdm_get_csr_request);
1383 1 : }
1384 :
1385 : /**
1386 : * Test 14: receives a valid GET_CSR request message from Requester with need_reset for SPDM 1.3
1387 : * Expected Behavior: the first get_csr with csr_tracking_tag 0: responder return need reset and available csr_tracking_tag;
1388 : * After reset, then send get_csr with csr_tracking_tag 0 six times: responder return need reset and available csr_tracking_tag;
1389 : * Then send get_csr with csr_tracking_tag 0: responder return busy error;
1390 : **/
1391 1 : static void rsp_csr_case14(void **state)
1392 : {
1393 : libspdm_return_t status;
1394 : libspdm_test_context_t *spdm_test_context;
1395 : libspdm_context_t *spdm_context;
1396 : size_t response_size;
1397 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1398 : spdm_csr_response_t *spdm_response;
1399 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1400 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1401 : uint8_t index;
1402 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1403 :
1404 : uint8_t *csr_pointer;
1405 : size_t csr_len;
1406 : uint8_t csr_tracking_tag;
1407 :
1408 1 : csr_tracking_tag = 0;
1409 :
1410 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1411 0 : assert_false(true);
1412 : }
1413 :
1414 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1415 1 : free(csr_pointer);
1416 :
1417 1 : spdm_test_context = *state;
1418 1 : spdm_context = spdm_test_context->spdm_context;
1419 1 : spdm_test_context->case_id = 0xE;
1420 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1421 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1422 :
1423 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1424 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1425 :
1426 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1427 : /*set responder need reset*/
1428 1 : spdm_context->local_context.capability.flags |=
1429 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
1430 :
1431 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1432 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1433 :
1434 : /*set csr before reset*/
1435 1 : assert_true(libspdm_set_csr_before_reset());
1436 :
1437 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
1438 :
1439 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1440 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1441 1 : m_libspdm_get_csr_request->header.param1 = 1;
1442 1 : m_libspdm_get_csr_request->header.param2 =
1443 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1444 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1445 :
1446 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1447 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1448 :
1449 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1450 :
1451 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
1452 : req_info_len;
1453 :
1454 1 : response_size = sizeof(response);
1455 1 : status = libspdm_get_response_csr(spdm_context,
1456 : m_libspdm_get_csr_request_size,
1457 : m_libspdm_get_csr_request,
1458 : &response_size, response);
1459 :
1460 : /*set csr after reset*/
1461 1 : assert_true(libspdm_set_csr_after_reset());
1462 : /*first get_csr: the responder need reset*/
1463 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1464 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1465 1 : spdm_response = (void *)response;
1466 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1467 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1468 1 : assert_int_equal(spdm_response->header.param2, 1);
1469 :
1470 7 : for (index = 1; index < SPDM_MAX_CSR_TRACKING_TAG; index++) {
1471 6 : csr_tracking_tag = 0;
1472 6 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1473 6 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1474 6 : m_libspdm_get_csr_request->header.param1 = 1;
1475 6 : m_libspdm_get_csr_request->header.param2 =
1476 6 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1477 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1478 :
1479 6 : m_libspdm_get_csr_request->opaque_data_length = 0;
1480 6 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1481 6 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1482 :
1483 6 : response_size = sizeof(response);
1484 6 : status = libspdm_get_response_csr(spdm_context,
1485 : m_libspdm_get_csr_request_size,
1486 : m_libspdm_get_csr_request,
1487 : &response_size, response);
1488 : /*second get_csr after device reset: get the responder cached csr*/
1489 6 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1490 6 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1491 6 : spdm_response = (void *)response;
1492 6 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1493 6 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1494 6 : assert_int_equal(spdm_response->header.param2, index + 1);
1495 : }
1496 :
1497 1 : csr_tracking_tag = 0;
1498 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1499 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1500 1 : m_libspdm_get_csr_request->header.param1 = 1;
1501 1 : m_libspdm_get_csr_request->header.param2 =
1502 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1503 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1504 :
1505 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1506 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1507 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1508 :
1509 1 : response_size = sizeof(response);
1510 1 : status = libspdm_get_response_csr(spdm_context,
1511 : m_libspdm_get_csr_request_size,
1512 : m_libspdm_get_csr_request,
1513 : &response_size, response);
1514 : /*second get_csr after device reset: get the responder cached csr*/
1515 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1516 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1517 1 : spdm_response = (void *)response;
1518 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1519 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
1520 1 : assert_int_equal(spdm_response->header.param2, 0);
1521 : /*clear cached req_info*/
1522 1 : libspdm_test_clear_cached_last_request();
1523 1 : free(m_libspdm_get_csr_request);
1524 1 : }
1525 :
1526 : /**
1527 : * Test 15: receives a valid GET_CSR request message from Requester with need_reset for SPDM 1.3
1528 : * Expected Behavior: the first get_csr with csr_tracking_tag 0: responder return need reset and available csr_tracking_tag;
1529 : * Without reset, then send get_csr with unmatched csr_tracking_tag：responder return unexpected error;
1530 : * Without reset, then send get_csr with matched csr_tracking_tag：responder return busy error;
1531 : * Without reset, then send get_csr with non-0 csr_tracking_tag, and overwrite is set：responder return invalid error;
1532 : * After reset, then send get_csr with unmatched csr_tracking_tag：responder return unexpected error;
1533 : * After reset, then send get_csr with csr_tracking_tag 0, and overwrite is set：responder return need reset and available csr_tracking_tag;
1534 : **/
1535 1 : static void rsp_csr_case15(void **state)
1536 : {
1537 : libspdm_return_t status;
1538 : libspdm_test_context_t *spdm_test_context;
1539 : libspdm_context_t *spdm_context;
1540 : size_t response_size;
1541 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1542 : spdm_csr_response_t *spdm_response;
1543 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1544 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1545 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1546 :
1547 : uint8_t *csr_pointer;
1548 : size_t csr_len;
1549 : uint8_t csr_tracking_tag;
1550 :
1551 1 : csr_tracking_tag = 0;
1552 :
1553 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1554 0 : assert_false(true);
1555 : }
1556 :
1557 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1558 1 : free(csr_pointer);
1559 :
1560 1 : spdm_test_context = *state;
1561 1 : spdm_context = spdm_test_context->spdm_context;
1562 1 : spdm_test_context->case_id = 0xF;
1563 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1564 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1565 :
1566 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1567 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1568 :
1569 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1570 : /*set responder need reset*/
1571 1 : spdm_context->local_context.capability.flags |=
1572 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
1573 :
1574 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1575 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1576 :
1577 : /*set csr before reset*/
1578 1 : assert_true(libspdm_set_csr_before_reset());
1579 :
1580 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
1581 :
1582 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1583 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1584 1 : m_libspdm_get_csr_request->header.param1 = 1;
1585 1 : m_libspdm_get_csr_request->header.param2 =
1586 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1587 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1588 :
1589 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1590 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1591 :
1592 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1593 :
1594 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
1595 : req_info_len;
1596 :
1597 1 : response_size = sizeof(response);
1598 1 : status = libspdm_get_response_csr(spdm_context,
1599 : m_libspdm_get_csr_request_size,
1600 : m_libspdm_get_csr_request,
1601 : &response_size, response);
1602 : /*first get_csr: the responder need reset*/
1603 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1604 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1605 1 : spdm_response = (void *)response;
1606 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1607 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1608 1 : assert_int_equal(spdm_response->header.param2, 1);
1609 :
1610 : /*unmatched csr_tracking_tag*/
1611 1 : csr_tracking_tag = 3;
1612 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1613 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1614 1 : m_libspdm_get_csr_request->header.param1 = 1;
1615 1 : m_libspdm_get_csr_request->header.param2 =
1616 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1617 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1618 :
1619 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1620 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1621 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1622 :
1623 1 : response_size = sizeof(response);
1624 1 : status = libspdm_get_response_csr(spdm_context,
1625 : m_libspdm_get_csr_request_size,
1626 : m_libspdm_get_csr_request,
1627 : &response_size, response);
1628 : /*second get_csr after device reset: get the responder cached csr*/
1629 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1630 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1631 1 : spdm_response = (void *)response;
1632 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1633 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1634 1 : assert_int_equal(spdm_response->header.param2, 0);
1635 :
1636 : /*matched csr_tracking_tag without overwrite*/
1637 1 : csr_tracking_tag = 1;
1638 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1639 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1640 1 : m_libspdm_get_csr_request->header.param1 = 1;
1641 1 : m_libspdm_get_csr_request->header.param2 =
1642 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1643 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1644 :
1645 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1646 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1647 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1648 :
1649 1 : response_size = sizeof(response);
1650 1 : status = libspdm_get_response_csr(spdm_context,
1651 : m_libspdm_get_csr_request_size,
1652 : m_libspdm_get_csr_request,
1653 : &response_size, response);
1654 : /*second get_csr after device reset: get the responder cached csr*/
1655 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1656 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1657 1 : spdm_response = (void *)response;
1658 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1659 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY);
1660 1 : assert_int_equal(spdm_response->header.param2, 0);
1661 :
1662 : /*matched csr_tracking_tag with overwrite*/
1663 1 : csr_tracking_tag = 1;
1664 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1665 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1666 1 : m_libspdm_get_csr_request->header.param1 = 1;
1667 1 : m_libspdm_get_csr_request->header.param2 =
1668 1 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET) |
1669 : SPDM_GET_CSR_REQUEST_ATTRIBUTES_OVERWRITE;
1670 :
1671 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1672 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1673 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1674 :
1675 1 : response_size = sizeof(response);
1676 1 : status = libspdm_get_response_csr(spdm_context,
1677 : m_libspdm_get_csr_request_size,
1678 : m_libspdm_get_csr_request,
1679 : &response_size, response);
1680 : /*second get_csr after device reset: get the responder cached csr*/
1681 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1682 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1683 1 : spdm_response = (void *)response;
1684 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1685 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1686 1 : assert_int_equal(spdm_response->header.param2, 0);
1687 :
1688 : /*set csr after reset*/
1689 1 : assert_true(libspdm_set_csr_after_reset());
1690 :
1691 : /*unmatched csr_tracking_tag*/
1692 1 : csr_tracking_tag = 3;
1693 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1694 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1695 1 : m_libspdm_get_csr_request->header.param1 = 1;
1696 1 : m_libspdm_get_csr_request->header.param2 =
1697 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1698 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1699 :
1700 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1701 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1702 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1703 :
1704 1 : response_size = sizeof(response);
1705 1 : status = libspdm_get_response_csr(spdm_context,
1706 : m_libspdm_get_csr_request_size,
1707 : m_libspdm_get_csr_request,
1708 : &response_size, response);
1709 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1710 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1711 1 : spdm_response = (void *)response;
1712 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1713 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1714 1 : assert_int_equal(spdm_response->header.param2, 0);
1715 :
1716 : /*csr_tracking_tag 0 and overwrite*/
1717 1 : csr_tracking_tag = 0;
1718 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1719 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1720 1 : m_libspdm_get_csr_request->header.param1 = 1;
1721 1 : m_libspdm_get_csr_request->header.param2 =
1722 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1723 1 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET) |
1724 : SPDM_GET_CSR_REQUEST_ATTRIBUTES_OVERWRITE;
1725 :
1726 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1727 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1728 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1729 :
1730 1 : response_size = sizeof(response);
1731 1 : status = libspdm_get_response_csr(spdm_context,
1732 : m_libspdm_get_csr_request_size,
1733 : m_libspdm_get_csr_request,
1734 : &response_size, response);
1735 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1736 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1737 1 : spdm_response = (void *)response;
1738 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1739 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_RESET_REQUIRED);
1740 1 : assert_int_equal(spdm_response->header.param2, 1);
1741 : /*clear cached req_info*/
1742 1 : libspdm_test_clear_cached_last_request();
1743 1 : free(m_libspdm_get_csr_request);
1744 1 : }
1745 :
1746 : /**
1747 : * Test 16: Illegal combination of MULTI_KEY_CONN_RSP = true and CSRCertModel = 0.
1748 : * Expected Behavior: produces SPDM_ERROR_CODE_INVALID_REQUEST message.
1749 : **/
1750 1 : static void rsp_csr_case16(void **state)
1751 : {
1752 : libspdm_return_t status;
1753 : libspdm_test_context_t *spdm_test_context;
1754 : libspdm_context_t *spdm_context;
1755 : size_t response_size;
1756 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1757 : spdm_csr_response_t *spdm_response;
1758 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1759 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1760 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1761 :
1762 : uint8_t *csr_pointer;
1763 : size_t csr_len;
1764 : uint8_t csr_tracking_tag;
1765 :
1766 1 : csr_tracking_tag = 0;
1767 :
1768 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1769 0 : assert_false(true);
1770 : }
1771 :
1772 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1773 1 : free(csr_pointer);
1774 :
1775 1 : spdm_test_context = *state;
1776 1 : spdm_context = spdm_test_context->spdm_context;
1777 1 : spdm_test_context->case_id = 0x10;
1778 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1779 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1780 :
1781 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1782 1 : spdm_context->local_context.capability.flags = SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1783 :
1784 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1785 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1786 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1787 :
1788 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
1789 :
1790 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1791 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1792 1 : m_libspdm_get_csr_request->header.param1 = 1;
1793 1 : m_libspdm_get_csr_request->header.param2 =
1794 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_NONE |
1795 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1796 :
1797 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1798 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1799 :
1800 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1801 :
1802 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) + req_info_len;
1803 :
1804 1 : response_size = sizeof(response);
1805 1 : status = libspdm_get_response_csr(spdm_context,
1806 : m_libspdm_get_csr_request_size,
1807 : m_libspdm_get_csr_request,
1808 : &response_size, response);
1809 :
1810 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1811 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1812 1 : spdm_response = (void *)response;
1813 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1814 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1815 1 : assert_int_equal(spdm_response->header.param2, 0);
1816 :
1817 : /*clear cached req_info*/
1818 1 : libspdm_test_clear_cached_last_request();
1819 1 : free(m_libspdm_get_csr_request);
1820 1 : }
1821 :
1822 1 : int libspdm_rsp_csr_test(void)
1823 : {
1824 1 : const struct CMUnitTest test_cases[] = {
1825 : /* Success Case for csr response with device_cert mode */
1826 : cmocka_unit_test(rsp_csr_case1),
1827 : /* Bad request size*/
1828 : cmocka_unit_test(rsp_csr_case2),
1829 : /* Success Case for csr response with non-null right req_info */
1830 : cmocka_unit_test(rsp_csr_case3),
1831 : /* Success Case for csr response with non-null opaque_data */
1832 : cmocka_unit_test(rsp_csr_case4),
1833 : /* Failed Case for csr response with non-null wrong req_info */
1834 : cmocka_unit_test(rsp_csr_case5),
1835 : /* Responder need reset to gen csr, the second send after device reset*/
1836 : cmocka_unit_test(rsp_csr_case6),
1837 : /* Success Case for csr response with non-null right req_info and opaque_data */
1838 : cmocka_unit_test(rsp_csr_case7),
1839 : /* Failed Case for csr response With chaotic req_info and opaque_data */
1840 : cmocka_unit_test(rsp_csr_case8),
1841 : /* the OpaqueDataFmt1 bit is selected in OtherParamsSelection of ALGORITHMS*/
1842 : cmocka_unit_test(rsp_csr_case9),
1843 : /* Failed Case OpaqueDataFmt1, When AlignPadding is not zero*/
1844 : cmocka_unit_test(rsp_csr_case10),
1845 : /* Success Case for csr response with alias_cert mode */
1846 : cmocka_unit_test(rsp_csr_case11),
1847 : /* Responder need reset to gen csr, the second send without device reset*/
1848 : cmocka_unit_test(rsp_csr_case12),
1849 : /* Success Case: Responder need reset to gen csr for SPDM1.3, the second send with matched csr_tracking_tag after device reset*/
1850 : cmocka_unit_test(rsp_csr_case13),
1851 : /* Failed Case: Responder need reset to gen csr for SPDM1.3, test for busy error*/
1852 : cmocka_unit_test(rsp_csr_case14),
1853 : /* Failed Case: Responder need reset to gen csr for SPDM1.3, test for unmatched csr_tracking_tag and overwrite*/
1854 : cmocka_unit_test(rsp_csr_case15),
1855 : cmocka_unit_test(rsp_csr_case16),
1856 : };
1857 :
1858 1 : libspdm_test_context_t test_context = {
1859 : LIBSPDM_TEST_CONTEXT_VERSION,
1860 : false,
1861 : };
1862 :
1863 1 : libspdm_setup_test_context(&test_context);
1864 :
1865 : /*ensure that cached.csr exists in test_csr at the beginning*/
1866 1 : libspdm_clear_cached_csr();
1867 :
1868 1 : return cmocka_run_group_tests(test_cases,
1869 : libspdm_unit_test_group_setup,
1870 : libspdm_unit_test_group_teardown);
1871 : }
1872 :
1873 : #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP*/
|
