Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2021-2022 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 : (LIBSPDM_SET_CERT_CSR_PARAMS) ?
1633 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY) :
1634 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1635 1 : assert_int_equal(spdm_response->header.param2, 0);
1636 : #else
1637 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1638 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1639 : spdm_response = (void *)response;
1640 : assert_int_equal(spdm_response->header.request_response_code,
1641 : SPDM_ERROR);
1642 : assert_int_equal(spdm_response->header.param1,
1643 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
1644 : assert_int_equal(spdm_response->header.param2, 0);
1645 : #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX*/
1646 : /*clear cached req_info*/
1647 1 : libspdm_test_clear_cached_last_request();
1648 1 : free(m_libspdm_get_csr_request);
1649 1 : }
1650 :
1651 : /**
1652 : * Test 15: receives a valid GET_CSR request message from Requester with need_reset for SPDM 1.3
1653 : * Expected Behavior: the first get_csr with csr_tracking_tag 0: responder return need reset and available csr_tracking_tag;
1654 : * Without reset, then send get_csr with unmatched csr_tracking_tag：responder return unexpected error;
1655 : * Without reset, then send get_csr with matched csr_tracking_tag：responder return busy error;
1656 : * Without reset, then send get_csr with non-0 csr_tracking_tag, and overwrite is set：responder return invalid error;
1657 : * After reset, then send get_csr with unmatched csr_tracking_tag：responder return unexpected error;
1658 : * After reset, then send get_csr with csr_tracking_tag 0, and overwrite is set：responder return need reset and available csr_tracking_tag;
1659 : **/
1660 1 : void libspdm_test_responder_csr_case15(void **state)
1661 : {
1662 : libspdm_return_t status;
1663 : libspdm_test_context_t *spdm_test_context;
1664 : libspdm_context_t *spdm_context;
1665 : size_t response_size;
1666 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1667 : spdm_csr_response_t *spdm_response;
1668 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1669 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1670 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1671 :
1672 : uint8_t *csr_pointer;
1673 : size_t csr_len;
1674 : uint8_t csr_tracking_tag;
1675 :
1676 1 : csr_tracking_tag = 0;
1677 :
1678 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1679 0 : assert_false(true);
1680 : }
1681 :
1682 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1683 1 : free(csr_pointer);
1684 :
1685 1 : spdm_test_context = *state;
1686 1 : spdm_context = spdm_test_context->spdm_context;
1687 1 : spdm_test_context->case_id = 0xF;
1688 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1689 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1690 :
1691 1 : spdm_context->connection_info.connection_state =
1692 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1693 1 : spdm_context->local_context.capability.flags |=
1694 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1695 :
1696 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1697 : /*set responder need reset*/
1698 1 : spdm_context->local_context.capability.flags |=
1699 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
1700 :
1701 1 : spdm_context->connection_info.algorithm.base_hash_algo =
1702 : m_libspdm_use_hash_algo;
1703 1 : spdm_context->connection_info.algorithm.base_asym_algo =
1704 : m_libspdm_use_asym_algo;
1705 :
1706 : /*set csr before reset*/
1707 1 : assert_true(libspdm_set_csr_before_reset());
1708 :
1709 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) +
1710 : req_info_len);
1711 :
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 :
1722 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len,
1723 : right_req_info, req_info_len);
1724 :
1725 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) +
1726 : req_info_len;
1727 :
1728 1 : response_size = sizeof(response);
1729 1 : status = libspdm_get_response_csr(spdm_context,
1730 : m_libspdm_get_csr_request_size,
1731 : m_libspdm_get_csr_request,
1732 : &response_size, response);
1733 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX
1734 : /*first get_csr: the responder need reset*/
1735 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1736 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1737 1 : spdm_response = (void *)response;
1738 1 : assert_int_equal(spdm_response->header.request_response_code,
1739 : SPDM_ERROR);
1740 1 : assert_int_equal(spdm_response->header.param1,
1741 : SPDM_ERROR_CODE_RESET_REQUIRED);
1742 1 : assert_int_equal(spdm_response->header.param2, 1);
1743 :
1744 : /*unmatched csr_tracking_tag*/
1745 1 : csr_tracking_tag = 3;
1746 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1747 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1748 1 : m_libspdm_get_csr_request->header.param1 = 1;
1749 1 : m_libspdm_get_csr_request->header.param2 =
1750 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1751 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1752 :
1753 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1754 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1755 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len,
1756 : right_req_info, req_info_len);
1757 :
1758 1 : response_size = sizeof(response);
1759 1 : status = libspdm_get_response_csr(spdm_context,
1760 : m_libspdm_get_csr_request_size,
1761 : m_libspdm_get_csr_request,
1762 : &response_size, response);
1763 : /*second get_csr after device reset: get the responder cached csr*/
1764 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1765 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1766 1 : spdm_response = (void *)response;
1767 1 : assert_int_equal(spdm_response->header.request_response_code,
1768 : SPDM_ERROR);
1769 1 : assert_int_equal(spdm_response->header.param1,
1770 : SPDM_ERROR_CODE_INVALID_REQUEST);
1771 1 : assert_int_equal(spdm_response->header.param2, 0);
1772 :
1773 : /*matched csr_tracking_tag without overwrite*/
1774 1 : csr_tracking_tag = 1;
1775 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1776 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1777 1 : m_libspdm_get_csr_request->header.param1 = 1;
1778 1 : m_libspdm_get_csr_request->header.param2 =
1779 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1780 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1781 :
1782 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1783 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1784 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len,
1785 : right_req_info, req_info_len);
1786 :
1787 1 : response_size = sizeof(response);
1788 1 : status = libspdm_get_response_csr(spdm_context,
1789 : m_libspdm_get_csr_request_size,
1790 : m_libspdm_get_csr_request,
1791 : &response_size, response);
1792 : /*second get_csr after device reset: get the responder cached csr*/
1793 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1794 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1795 1 : spdm_response = (void *)response;
1796 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1797 : (LIBSPDM_SET_CERT_CSR_PARAMS) ?
1798 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_BUSY) :
1799 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1800 1 : assert_int_equal(spdm_response->header.param2, 0);
1801 :
1802 :
1803 : /*matched csr_tracking_tag with overwrite*/
1804 1 : csr_tracking_tag = 1;
1805 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1806 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1807 1 : m_libspdm_get_csr_request->header.param1 = 1;
1808 1 : m_libspdm_get_csr_request->header.param2 =
1809 1 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET) |
1810 : SPDM_GET_CSR_REQUEST_ATTRIBUTES_OVERWRITE;
1811 :
1812 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1813 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1814 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len,
1815 : right_req_info, req_info_len);
1816 :
1817 1 : response_size = sizeof(response);
1818 1 : status = libspdm_get_response_csr(spdm_context,
1819 : m_libspdm_get_csr_request_size,
1820 : m_libspdm_get_csr_request,
1821 : &response_size, response);
1822 : /*second get_csr after device reset: get the responder cached csr*/
1823 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1824 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1825 1 : spdm_response = (void *)response;
1826 1 : assert_int_equal(spdm_response->header.request_response_code,
1827 : SPDM_ERROR);
1828 1 : assert_int_equal(spdm_response->header.param1,
1829 : SPDM_ERROR_CODE_INVALID_REQUEST);
1830 1 : assert_int_equal(spdm_response->header.param2, 0);
1831 :
1832 : /*set csr after reset*/
1833 1 : assert_true(libspdm_set_csr_after_reset());
1834 :
1835 : /*unmatched csr_tracking_tag*/
1836 1 : csr_tracking_tag = 3;
1837 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1838 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1839 1 : m_libspdm_get_csr_request->header.param1 = 1;
1840 1 : m_libspdm_get_csr_request->header.param2 =
1841 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1842 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1843 :
1844 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1845 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1846 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len,
1847 : right_req_info, req_info_len);
1848 :
1849 1 : response_size = sizeof(response);
1850 1 : status = libspdm_get_response_csr(spdm_context,
1851 : m_libspdm_get_csr_request_size,
1852 : m_libspdm_get_csr_request,
1853 : &response_size, response);
1854 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1855 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1856 1 : spdm_response = (void *)response;
1857 1 : assert_int_equal(spdm_response->header.request_response_code,
1858 : SPDM_ERROR);
1859 1 : assert_int_equal(spdm_response->header.param1,
1860 : SPDM_ERROR_CODE_INVALID_REQUEST);
1861 1 : assert_int_equal(spdm_response->header.param2, 0);
1862 :
1863 : /*csr_tracking_tag 0 and overwrite*/
1864 1 : csr_tracking_tag = 0;
1865 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1866 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1867 1 : m_libspdm_get_csr_request->header.param1 = 1;
1868 1 : m_libspdm_get_csr_request->header.param2 =
1869 : SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT |
1870 1 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET) |
1871 : SPDM_GET_CSR_REQUEST_ATTRIBUTES_OVERWRITE;
1872 :
1873 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1874 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1875 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len,
1876 : right_req_info, req_info_len);
1877 :
1878 1 : response_size = sizeof(response);
1879 1 : status = libspdm_get_response_csr(spdm_context,
1880 : m_libspdm_get_csr_request_size,
1881 : m_libspdm_get_csr_request,
1882 : &response_size, response);
1883 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1884 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1885 1 : spdm_response = (void *)response;
1886 1 : assert_int_equal(spdm_response->header.request_response_code,
1887 : SPDM_ERROR);
1888 1 : assert_int_equal(spdm_response->header.param1,
1889 : SPDM_ERROR_CODE_RESET_REQUIRED);
1890 1 : assert_int_equal(spdm_response->header.param2, 1);
1891 :
1892 : #else
1893 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1894 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1895 : spdm_response = (void *)response;
1896 : assert_int_equal(spdm_response->header.request_response_code,
1897 : SPDM_ERROR);
1898 : assert_int_equal(spdm_response->header.param1,
1899 : SPDM_ERROR_CODE_UNEXPECTED_REQUEST);
1900 : assert_int_equal(spdm_response->header.param2, 0);
1901 : /*set csr after reset*/
1902 : assert_true(libspdm_set_csr_after_reset());
1903 : #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX*/
1904 : /*clear cached req_info*/
1905 1 : libspdm_test_clear_cached_last_request();
1906 1 : free(m_libspdm_get_csr_request);
1907 1 : }
1908 :
1909 : /**
1910 : * Test 16: Illegal combination of MULTI_KEY_CONN_RSP = true and CSRCertModel = 0.
1911 : * Expected Behavior: produces SPDM_ERROR_CODE_INVALID_REQUEST message.
1912 : **/
1913 1 : void libspdm_test_responder_csr_case16(void **state)
1914 : {
1915 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX
1916 : libspdm_return_t status;
1917 : libspdm_test_context_t *spdm_test_context;
1918 : libspdm_context_t *spdm_context;
1919 : size_t response_size;
1920 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
1921 : spdm_csr_response_t *spdm_response;
1922 : spdm_get_csr_request_t *m_libspdm_get_csr_request;
1923 : uint8_t cached_csr[LIBSPDM_MAX_CSR_SIZE];
1924 1 : libspdm_zero_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE);
1925 :
1926 : uint8_t *csr_pointer;
1927 : size_t csr_len;
1928 : uint8_t csr_tracking_tag;
1929 :
1930 1 : csr_tracking_tag = 0;
1931 :
1932 1 : if (!libspdm_test_read_cached_csr(&csr_pointer, &csr_len)) {
1933 0 : assert_false(true);
1934 : }
1935 :
1936 1 : libspdm_copy_mem(cached_csr, LIBSPDM_MAX_CSR_SIZE, csr_pointer, csr_len);
1937 1 : free(csr_pointer);
1938 :
1939 1 : spdm_test_context = *state;
1940 1 : spdm_context = spdm_test_context->spdm_context;
1941 1 : spdm_test_context->case_id = 0x10;
1942 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1943 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1944 :
1945 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
1946 1 : spdm_context->local_context.capability.flags = SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
1947 :
1948 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
1949 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1950 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1951 :
1952 1 : m_libspdm_get_csr_request = malloc(sizeof(spdm_get_csr_request_t) + req_info_len);
1953 :
1954 1 : m_libspdm_get_csr_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
1955 1 : m_libspdm_get_csr_request->header.request_response_code = SPDM_GET_CSR;
1956 1 : m_libspdm_get_csr_request->header.param1 = 1;
1957 1 : m_libspdm_get_csr_request->header.param2 =
1958 1 : SPDM_CERTIFICATE_INFO_CERT_MODEL_NONE |
1959 : (csr_tracking_tag << SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET);
1960 :
1961 1 : m_libspdm_get_csr_request->opaque_data_length = 0;
1962 1 : m_libspdm_get_csr_request->requester_info_length = req_info_len;
1963 :
1964 1 : libspdm_copy_mem(m_libspdm_get_csr_request + 1, req_info_len, right_req_info, req_info_len);
1965 :
1966 1 : size_t m_libspdm_get_csr_request_size = sizeof(spdm_get_csr_request_t) + req_info_len;
1967 :
1968 1 : response_size = sizeof(response);
1969 1 : status = libspdm_get_response_csr(spdm_context,
1970 : m_libspdm_get_csr_request_size,
1971 : m_libspdm_get_csr_request,
1972 : &response_size, response);
1973 :
1974 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
1975 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
1976 1 : spdm_response = (void *)response;
1977 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
1978 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
1979 1 : assert_int_equal(spdm_response->header.param2, 0);
1980 :
1981 : /*clear cached req_info*/
1982 1 : libspdm_test_clear_cached_last_request();
1983 1 : free(m_libspdm_get_csr_request);
1984 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX */
1985 1 : }
1986 :
1987 1 : int libspdm_responder_csr_test_main(void)
1988 : {
1989 1 : const struct CMUnitTest spdm_responder_csr_tests[] = {
1990 : /* Success Case for csr response with device_cert mode */
1991 : cmocka_unit_test(libspdm_test_responder_csr_case1),
1992 : /* Bad request size*/
1993 : cmocka_unit_test(libspdm_test_responder_csr_case2),
1994 : /* Success Case for csr response with non-null right req_info */
1995 : cmocka_unit_test(libspdm_test_responder_csr_case3),
1996 : /* Success Case for csr response with non-null opaque_data */
1997 : cmocka_unit_test(libspdm_test_responder_csr_case4),
1998 : /* Failed Case for csr response with non-null wrong req_info */
1999 : cmocka_unit_test(libspdm_test_responder_csr_case5),
2000 : /* Responder need reset to gen csr, the second send after device reset*/
2001 : cmocka_unit_test(libspdm_test_responder_csr_case6),
2002 : /* Success Case for csr response with non-null right req_info and opaque_data */
2003 : cmocka_unit_test(libspdm_test_responder_csr_case7),
2004 : /* Failed Case for csr response With chaotic req_info and opaque_data */
2005 : cmocka_unit_test(libspdm_test_responder_csr_case8),
2006 : /* the OpaqueDataFmt1 bit is selected in OtherParamsSelection of ALGORITHMS*/
2007 : cmocka_unit_test(libspdm_test_responder_csr_case9),
2008 : /* Failed Case OpaqueDataFmt1, When AlignPadding is not zero*/
2009 : cmocka_unit_test(libspdm_test_responder_csr_case10),
2010 : /* Success Case for csr response with alias_cert mode */
2011 : cmocka_unit_test(libspdm_test_responder_csr_case11),
2012 : /* Responder need reset to gen csr, the second send without device reset*/
2013 : cmocka_unit_test(libspdm_test_responder_csr_case12),
2014 : /* Success Case: Responder need reset to gen csr for SPDM1.3, the second send with matched csr_tracking_tag after device reset*/
2015 : cmocka_unit_test(libspdm_test_responder_csr_case13),
2016 : /* Failed Case: Responder need reset to gen csr for SPDM1.3, test for busy error*/
2017 : cmocka_unit_test(libspdm_test_responder_csr_case14),
2018 : /* Failed Case: Responder need reset to gen csr for SPDM1.3, test for unmatched csr_tracking_tag and overwrite*/
2019 : cmocka_unit_test(libspdm_test_responder_csr_case15),
2020 : cmocka_unit_test(libspdm_test_responder_csr_case16),
2021 : };
2022 :
2023 1 : libspdm_test_context_t test_context = {
2024 : LIBSPDM_TEST_CONTEXT_VERSION,
2025 : false,
2026 : };
2027 :
2028 1 : libspdm_setup_test_context(&test_context);
2029 :
2030 : /*ensure that cached.csr exists in test_csr at the beginning*/
2031 1 : libspdm_clear_cached_csr();
2032 :
2033 1 : return cmocka_run_group_tests(spdm_responder_csr_tests,
2034 : libspdm_unit_test_group_setup,
2035 : libspdm_unit_test_group_teardown);
2036 : }
2037 :
2038 : #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP*/
|
