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