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