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_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP
12 :
13 : #define LIBSPDM_MAX_CSR_SIZE 0x1000
14 :
15 : /*refer to https://github.com/Mbed-TLS/mbedtls/blob/3048c8c90654eb116a6b17c0d2d27c3ccbe6782c/programs/x509/cert_req.c#L119-L129*/
16 : #define LIBSPDM_MAX_REQ_INFO_BUFFER_SIZE 4096
17 :
18 : uint8_t csr_pointer[LIBSPDM_MAX_CSR_SIZE] = {0};
19 : uint8_t *csr_data_pointer = csr_pointer;
20 : size_t global_csr_len;
21 :
22 : uint8_t m_csr_opaque_data[8] = "libspdm";
23 : uint16_t m_csr_opaque_data_size = sizeof(m_csr_opaque_data);
24 :
25 : /*ECC 256 req_info(include right req_info attribute)*/
26 : uint8_t req_info_sequence[] = {0x30, 0x81, 0xBF,};
27 : uint8_t req_info_version[] = {0x02, 0x01, 0x00,};
28 : uint8_t req_info_subject[] = {
29 : 0x30, 0x45, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31,
30 : 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0C, 0x0A, 0x53, 0x6F, 0x6D, 0x65, 0x2D, 0x53,
31 : 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x0C, 0x18, 0x49,
32 : 0x6E, 0x74, 0x65, 0x72, 0x6E, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20,
33 : 0x50, 0x74, 0x79, 0x20, 0x4C, 0x74, 0x64,
34 : };
35 : uint8_t req_info_right_attributes[] = {
36 : /*[0]: attributes*/
37 : 0xA0, 0x18, 0x30, 0x16,
38 : /*OID*/
39 : 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x07,
40 : /*attributes*/
41 : 0x31, 0x09, 0x0C, 0x07, 0x74, 0x65, 0x73, 0x74, 0x31, 0x32, 0x33
42 : };
43 :
44 : /*the unique attribute from right_req_info*/
45 : char right_req_info_string[] = {0x74, 0x65, 0x73, 0x74, 0x31, 0x32, 0x33};
46 :
47 : static uint8_t right_req_info[LIBSPDM_MAX_REQ_INFO_BUFFER_SIZE];
48 : static uint16_t right_req_info_size;
49 :
50 : /*gen right_req_info*/
51 1 : void libspdm_gen_req_info() {
52 : uint8_t *req_info_p;
53 : void *req_info_pkinfo;
54 : size_t req_info_pkinfo_len;
55 :
56 1 : libspdm_zero_mem(right_req_info, sizeof(right_req_info));
57 :
58 1 : req_info_p = right_req_info;
59 1 : right_req_info_size = sizeof(right_req_info);
60 :
61 1 : libspdm_read_responder_public_key(m_libspdm_use_asym_algo,
62 : &req_info_pkinfo, &req_info_pkinfo_len);
63 :
64 : /*concat right_req_info*/
65 1 : libspdm_copy_mem(req_info_p, right_req_info_size, req_info_sequence, sizeof(req_info_sequence));
66 1 : req_info_p += sizeof(req_info_sequence);
67 1 : right_req_info_size -= sizeof(req_info_sequence);
68 :
69 1 : libspdm_copy_mem(req_info_p, right_req_info_size, req_info_version, sizeof(req_info_version));
70 1 : req_info_p += sizeof(req_info_version);
71 1 : right_req_info_size -= sizeof(req_info_version);
72 :
73 1 : libspdm_copy_mem(req_info_p, right_req_info_size, req_info_subject, sizeof(req_info_subject));
74 1 : req_info_p += sizeof(req_info_subject);
75 1 : right_req_info_size -= sizeof(req_info_subject);
76 :
77 1 : libspdm_copy_mem(req_info_p, right_req_info_size, req_info_pkinfo, req_info_pkinfo_len);
78 1 : req_info_p += req_info_pkinfo_len;
79 1 : right_req_info_size = (uint16_t)(right_req_info_size - req_info_pkinfo_len);
80 :
81 1 : libspdm_copy_mem(req_info_p, right_req_info_size,
82 : req_info_right_attributes, sizeof(req_info_right_attributes));
83 1 : req_info_p += sizeof(req_info_right_attributes);
84 1 : right_req_info_size -= sizeof(req_info_right_attributes);
85 :
86 1 : right_req_info_size = sizeof(right_req_info) - right_req_info_size;
87 :
88 1 : free(req_info_pkinfo);
89 1 : }
90 :
91 5 : bool libspdm_read_requester_gen_csr(void **csr_data, size_t *csr_len)
92 : {
93 : char *file;
94 : bool res;
95 :
96 5 : file = "test_csr/cached.csr";
97 5 : res = libspdm_read_input_file(file, csr_data, csr_len);
98 5 : if (!res) {
99 0 : return res;
100 : }
101 :
102 5 : return res;
103 : }
104 :
105 : /*ensure that cached.csr exists in test_csr at the beginning*/
106 1 : void libspdm_clear_cached_csr()
107 : {
108 1 : char *new_name = "test_csr/cached.csr";
109 1 : char *file_name = "test_csr/cached.staging";
110 :
111 1 : rename(file_name, new_name);
112 1 : }
113 :
114 7 : libspdm_return_t libspdm_requester_get_csr_test_send_message(
115 : void *spdm_context, size_t request_size, const void *request,
116 : uint64_t timeout)
117 : {
118 : libspdm_test_context_t *spdm_test_context;
119 :
120 7 : spdm_test_context = libspdm_get_test_context();
121 7 : switch (spdm_test_context->case_id) {
122 1 : case 0x1:
123 1 : return LIBSPDM_STATUS_SEND_FAIL;
124 1 : case 0x2:
125 1 : return LIBSPDM_STATUS_SUCCESS;
126 2 : case 0x3:
127 2 : return LIBSPDM_STATUS_SUCCESS;
128 1 : case 0x4: {
129 : const spdm_get_csr_request_t *spdm_request;
130 : uint16_t requester_info_length;
131 : uint16_t opaque_data_length;
132 : uint8_t *opaque_data;
133 : uint8_t *requester_info;
134 :
135 : /* Obtain the real spdm_request */
136 1 : spdm_request =
137 : (const spdm_get_csr_request_t *)((const uint8_t *)request +
138 : sizeof(libspdm_test_message_header_t));
139 :
140 1 : requester_info_length = spdm_request->requester_info_length;
141 1 : opaque_data_length = spdm_request->opaque_data_length;
142 :
143 1 : requester_info = (void*)((size_t)(spdm_request + 1));
144 1 : assert_memory_equal(requester_info, right_req_info, requester_info_length);
145 1 : opaque_data = (void *)(requester_info + requester_info_length);
146 1 : assert_memory_equal(opaque_data, m_csr_opaque_data, opaque_data_length);
147 1 : return LIBSPDM_STATUS_SUCCESS;
148 : }
149 1 : case 0x5:
150 1 : return LIBSPDM_STATUS_SUCCESS;
151 1 : case 0x6:
152 1 : return LIBSPDM_STATUS_SUCCESS;
153 0 : case 0x7:
154 0 : assert_true(false);
155 0 : return LIBSPDM_STATUS_SUCCESS;
156 0 : default:
157 0 : return LIBSPDM_STATUS_SEND_FAIL;
158 : }
159 : }
160 :
161 6 : libspdm_return_t libspdm_requester_get_csr_test_receive_message(
162 : void *spdm_context, size_t *response_size,
163 : void **response, uint64_t timeout)
164 : {
165 : libspdm_test_context_t *spdm_test_context;
166 : libspdm_context_t *context;
167 :
168 6 : spdm_test_context = libspdm_get_test_context();
169 6 : switch (spdm_test_context->case_id) {
170 0 : case 0x1:
171 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
172 :
173 1 : case 0x2: {
174 : spdm_csr_response_t *spdm_response;
175 : size_t spdm_response_size;
176 : size_t transport_header_size;
177 :
178 1 : libspdm_read_requester_gen_csr((void *)&csr_data_pointer, &global_csr_len);
179 :
180 1 : spdm_response_size = sizeof(spdm_csr_response_t) + global_csr_len;
181 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
182 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
183 :
184 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
185 1 : spdm_response->header.request_response_code = SPDM_CSR;
186 1 : spdm_response->header.param1 = 0;
187 1 : spdm_response->header.param2 = 0;
188 1 : spdm_response->csr_length = (uint16_t)global_csr_len;
189 1 : spdm_response->reserved = 0;
190 :
191 1 : libspdm_copy_mem(spdm_response + 1, global_csr_len, csr_data_pointer, global_csr_len);
192 :
193 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
194 : false, spdm_response_size,
195 : spdm_response, response_size,
196 : response);
197 : }
198 1 : return LIBSPDM_STATUS_SUCCESS;
199 :
200 2 : case 0x3: {
201 : spdm_csr_response_t *spdm_response;
202 : size_t spdm_response_size;
203 : size_t transport_header_size;
204 :
205 2 : libspdm_read_requester_gen_csr((void *)&csr_data_pointer, &global_csr_len);
206 :
207 2 : spdm_response_size = sizeof(spdm_csr_response_t) + global_csr_len;
208 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
209 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
210 :
211 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
212 2 : spdm_response->header.param2 = 0;
213 2 : spdm_response->csr_length = (uint16_t)global_csr_len;
214 2 : spdm_response->reserved = 0;
215 :
216 2 : context = spdm_context;
217 :
218 2 : if (context->connection_info.capability.flags &
219 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP) {
220 1 : spdm_response->header.request_response_code = SPDM_ERROR;
221 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESET_REQUIRED;
222 : } else {
223 1 : spdm_response->header.request_response_code = SPDM_CSR;
224 1 : spdm_response->header.param1 = 0;
225 :
226 1 : libspdm_copy_mem(spdm_response + 1, global_csr_len, csr_data_pointer, global_csr_len);
227 : }
228 :
229 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
230 : false, spdm_response_size,
231 : spdm_response, response_size,
232 : response);
233 : }
234 2 : return LIBSPDM_STATUS_SUCCESS;
235 1 : case 0x4: {
236 : spdm_csr_response_t *spdm_response;
237 : size_t spdm_response_size;
238 : size_t transport_header_size;
239 :
240 1 : libspdm_read_requester_gen_csr((void *)&csr_data_pointer, &global_csr_len);
241 1 : spdm_response_size = sizeof(spdm_csr_response_t) + global_csr_len;
242 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
243 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
244 :
245 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_12;
246 1 : spdm_response->header.request_response_code = SPDM_CSR;
247 1 : spdm_response->header.param1 = 0;
248 1 : spdm_response->header.param2 = 0;
249 1 : spdm_response->csr_length = (uint16_t)global_csr_len;
250 1 : spdm_response->reserved = 0;
251 1 : libspdm_copy_mem(spdm_response + 1, global_csr_len, csr_data_pointer, global_csr_len);
252 :
253 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
254 : false, spdm_response_size,
255 : spdm_response, response_size,
256 : response);
257 : }
258 1 : return LIBSPDM_STATUS_SUCCESS;
259 1 : case 0x5: {
260 : spdm_csr_response_t *spdm_response;
261 : size_t spdm_response_size;
262 : size_t transport_header_size;
263 :
264 1 : libspdm_read_requester_gen_csr((void *)&csr_data_pointer, &global_csr_len);
265 :
266 1 : spdm_response_size = sizeof(spdm_csr_response_t) + global_csr_len;
267 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
268 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
269 :
270 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
271 1 : spdm_response->header.request_response_code = SPDM_ERROR;
272 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESET_REQUIRED;
273 1 : spdm_response->header.param2 = 1;
274 1 : spdm_response->csr_length = (uint16_t)global_csr_len;
275 1 : spdm_response->reserved = 0;
276 :
277 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
278 : false, spdm_response_size,
279 : spdm_response, response_size,
280 : response);
281 : }
282 1 : return LIBSPDM_STATUS_SUCCESS;
283 1 : case 0x6: {
284 : spdm_error_response_t *spdm_response;
285 : size_t spdm_response_size;
286 : size_t transport_header_size;
287 :
288 1 : spdm_response_size = sizeof(spdm_error_response_t);
289 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
290 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
291 :
292 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
293 1 : spdm_response->header.request_response_code = SPDM_ERROR;
294 1 : spdm_response->header.param1 = SPDM_ERROR_CODE_RESET_REQUIRED;
295 1 : spdm_response->header.param2 = 1;
296 :
297 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
298 : false, spdm_response_size,
299 : spdm_response, response_size,
300 : response);
301 : }
302 1 : return LIBSPDM_STATUS_SUCCESS;
303 0 : case 0x7:
304 0 : assert_true(false);
305 0 : return LIBSPDM_STATUS_SUCCESS;
306 0 : default:
307 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
308 : }
309 : }
310 :
311 : /**
312 : * Test 1: message could not be sent
313 : * Expected Behavior: get a RETURN_DEVICE_ERROR return code
314 : **/
315 1 : void libspdm_test_requester_get_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 :
321 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
322 : size_t csr_len;
323 :
324 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
325 :
326 1 : spdm_test_context = *state;
327 1 : spdm_context = spdm_test_context->spdm_context;
328 1 : spdm_test_context->case_id = 0x1;
329 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
330 : SPDM_VERSION_NUMBER_SHIFT_BIT;
331 :
332 1 : spdm_context->connection_info.connection_state =
333 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
334 1 : spdm_context->connection_info.capability.flags |=
335 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
336 :
337 : /*init req_info*/
338 1 : libspdm_gen_req_info();
339 :
340 1 : status = libspdm_get_csr(spdm_context, NULL, NULL, 0, NULL, 0, (void *)&csr_form_get,
341 : &csr_len);
342 :
343 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
344 1 : }
345 :
346 : /**
347 : * Test 2: Successful response to get csr
348 : * Expected Behavior: get a RETURN_SUCCESS return code
349 : **/
350 1 : void libspdm_test_requester_get_csr_case2(void **state)
351 : {
352 : libspdm_return_t status;
353 : libspdm_test_context_t *spdm_test_context;
354 : libspdm_context_t *spdm_context;
355 :
356 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
357 : size_t csr_len;
358 :
359 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
360 :
361 1 : spdm_test_context = *state;
362 1 : spdm_context = spdm_test_context->spdm_context;
363 1 : spdm_test_context->case_id = 0x2;
364 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
365 : SPDM_VERSION_NUMBER_SHIFT_BIT;
366 :
367 1 : spdm_context->connection_info.connection_state =
368 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
369 1 : spdm_context->connection_info.capability.flags |=
370 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
371 :
372 1 : status = libspdm_get_csr(spdm_context, NULL, NULL, 0, NULL, 0, (void *)&csr_form_get,
373 : &csr_len);
374 :
375 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
376 1 : assert_int_equal(csr_len, global_csr_len);
377 1 : assert_memory_equal(csr_form_get, csr_data_pointer, global_csr_len);
378 1 : }
379 :
380 : /**
381 : * Test 3: Successful response to get csr,
382 : * with a reset required
383 : * Expected Behavior: get a RETURN_SUCCESS return code
384 : **/
385 1 : void libspdm_test_requester_get_csr_case3(void **state)
386 : {
387 : libspdm_return_t status;
388 : libspdm_test_context_t *spdm_test_context;
389 : libspdm_context_t *spdm_context;
390 :
391 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
392 : size_t csr_len;
393 :
394 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
395 :
396 1 : spdm_test_context = *state;
397 1 : spdm_context = spdm_test_context->spdm_context;
398 1 : spdm_test_context->case_id = 0x3;
399 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
400 : SPDM_VERSION_NUMBER_SHIFT_BIT;
401 :
402 1 : spdm_context->connection_info.connection_state =
403 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
404 1 : spdm_context->connection_info.capability.flags |=
405 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP |
406 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
407 :
408 1 : status = libspdm_get_csr(spdm_context, NULL, NULL, 0, NULL, 0, (void *)&csr_form_get,
409 : &csr_len);
410 :
411 1 : assert_int_equal(status, LIBSPDM_STATUS_RESET_REQUIRED_PEER);
412 :
413 : /* Let's reset the responder and send the request again */
414 1 : spdm_context->connection_info.capability.flags &=
415 : ~SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
416 :
417 1 : status = libspdm_get_csr(spdm_context, NULL, NULL, 0, NULL, 0, (void *)&csr_form_get,
418 : &csr_len);
419 :
420 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
421 1 : assert_int_equal(csr_len, global_csr_len);
422 1 : assert_memory_equal(csr_form_get, csr_data_pointer, global_csr_len);
423 1 : }
424 :
425 : /**
426 : * Test 4: Send correct req_info and opaque_data
427 : * Expected Behavior: get a RETURN_SUCCESS return code and determine if req_info and opaque_data are correct
428 : **/
429 1 : void libspdm_test_requester_get_csr_case4(void **state)
430 : {
431 : libspdm_return_t status;
432 : libspdm_test_context_t *spdm_test_context;
433 : libspdm_context_t *spdm_context;
434 :
435 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
436 : size_t csr_len;
437 :
438 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
439 :
440 1 : spdm_test_context = *state;
441 1 : spdm_context = spdm_test_context->spdm_context;
442 1 : spdm_test_context->case_id = 0x4;
443 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_12 <<
444 : SPDM_VERSION_NUMBER_SHIFT_BIT;
445 :
446 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
447 1 : spdm_context->local_context.capability.flags = 0;
448 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
449 :
450 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
451 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
452 :
453 1 : spdm_context->connection_info.algorithm.other_params_support =
454 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0;
455 :
456 1 : status = libspdm_get_csr(spdm_context, NULL,
457 : right_req_info, right_req_info_size,
458 : m_csr_opaque_data, m_csr_opaque_data_size,
459 : (void *)&csr_form_get, &csr_len);
460 :
461 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
462 1 : assert_int_equal(csr_len, global_csr_len);
463 1 : assert_memory_equal(csr_form_get, csr_data_pointer, global_csr_len);
464 1 : }
465 :
466 : /**
467 : * Test 5: Successful response to libspdm_get_csr_ex,
468 : * with a reset required
469 : * Expected Behavior: get a LIBSPDM_STATUS_RESET_REQUIRED_PEER return code and available csr_tracking_tag
470 : **/
471 1 : void libspdm_test_requester_get_csr_case5(void **state)
472 : {
473 : libspdm_test_context_t *spdm_test_context;
474 : libspdm_context_t *spdm_context;
475 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX
476 : libspdm_return_t status;
477 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
478 : size_t csr_len;
479 : uint8_t reset_csr_tracking_tag;
480 :
481 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
482 1 : reset_csr_tracking_tag = 0;
483 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX*/
484 1 : spdm_test_context = *state;
485 1 : spdm_context = spdm_test_context->spdm_context;
486 1 : spdm_test_context->case_id = 0x5;
487 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
488 : SPDM_VERSION_NUMBER_SHIFT_BIT;
489 :
490 1 : spdm_context->connection_info.connection_state =
491 : LIBSPDM_CONNECTION_STATE_NEGOTIATED;
492 1 : spdm_context->connection_info.capability.flags |=
493 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP |
494 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
495 :
496 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX
497 1 : status = libspdm_get_csr_ex(spdm_context, NULL, NULL, 0, NULL, 0, (void *)&csr_form_get,
498 : &csr_len, 0, 0, &reset_csr_tracking_tag);
499 :
500 1 : assert_int_equal(status, LIBSPDM_STATUS_RESET_REQUIRED_PEER);
501 1 : assert_int_equal(reset_csr_tracking_tag, 1);
502 : #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX*/
503 1 : }
504 :
505 : /**
506 : * Test 6: A 1.3 Responder returns ResetRequired when its CERT_INSTALL_RESET_CAP is 0.
507 : * Expected Behavior: libspdm returns LIBSPDM_STATUS_ERROR_PEER since Responder should
508 : * not produce that error message unless CERT_INSTALL_RESET_CAP is 1.
509 : **/
510 1 : void libspdm_test_requester_get_csr_case6(void **state)
511 : {
512 : libspdm_return_t status;
513 : libspdm_test_context_t *spdm_test_context;
514 : libspdm_context_t *spdm_context;
515 :
516 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
517 : size_t csr_len;
518 :
519 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
520 :
521 1 : spdm_test_context = *state;
522 1 : spdm_context = spdm_test_context->spdm_context;
523 1 : spdm_test_context->case_id = 0x6;
524 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
525 : SPDM_VERSION_NUMBER_SHIFT_BIT;
526 :
527 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
528 1 : spdm_context->local_context.capability.flags = 0;
529 : /* Don't set CERT_INSTALL_RESET_CAP. */
530 1 : spdm_context->connection_info.capability.flags = SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
531 :
532 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
533 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
534 :
535 1 : spdm_context->connection_info.algorithm.other_params_support =
536 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0;
537 :
538 1 : status = libspdm_get_csr(spdm_context, NULL,
539 : right_req_info, right_req_info_size,
540 : m_csr_opaque_data, m_csr_opaque_data_size,
541 : (void *)&csr_form_get, &csr_len);
542 :
543 1 : assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
544 1 : }
545 :
546 : /**
547 : * Test 7: Illegal combination of MULTI_KEY_CONN_RSP = true and CSRCertModel = 0.
548 : * Expected Behavior: returns LIBSPDM_STATUS_INVALID_PARAMETER.
549 : **/
550 1 : void libspdm_test_requester_get_csr_case7(void **state)
551 : {
552 : #if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX
553 : libspdm_return_t status;
554 : libspdm_test_context_t *spdm_test_context;
555 : libspdm_context_t *spdm_context;
556 :
557 1 : uint8_t csr_form_get[LIBSPDM_MAX_CSR_SIZE] = {0};
558 : size_t csr_len;
559 : uint8_t tracking_tag;
560 :
561 1 : csr_len = LIBSPDM_MAX_CSR_SIZE;
562 :
563 1 : spdm_test_context = *state;
564 1 : spdm_context = spdm_test_context->spdm_context;
565 1 : spdm_test_context->case_id = 0x7;
566 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
567 : SPDM_VERSION_NUMBER_SHIFT_BIT;
568 :
569 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_NEGOTIATED;
570 1 : spdm_context->local_context.capability.flags = 0;
571 1 : spdm_context->connection_info.capability.flags = SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CSR_CAP;
572 1 : spdm_context->connection_info.multi_key_conn_rsp = true;
573 :
574 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
575 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
576 :
577 1 : spdm_context->connection_info.algorithm.other_params_support =
578 : SPDM_ALGORITHMS_OPAQUE_DATA_FORMAT_0;
579 :
580 1 : status = libspdm_get_csr_ex(spdm_context, NULL, NULL, 0, NULL, 0, (void *)&csr_form_get,
581 : &csr_len, SPDM_CERTIFICATE_INFO_CERT_MODEL_NONE, 1, &tracking_tag);
582 :
583 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_PARAMETER);
584 : #endif /* LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX */
585 1 : }
586 :
587 1 : int libspdm_requester_get_csr_test_main(void)
588 : {
589 1 : const struct CMUnitTest spdm_requester_get_csr_tests[] = {
590 : /* SendRequest failed*/
591 : cmocka_unit_test(libspdm_test_requester_get_csr_case1),
592 : /* Successful response to get csr*/
593 : cmocka_unit_test(libspdm_test_requester_get_csr_case2),
594 : /* Successful response to get csr with a reset required */
595 : cmocka_unit_test(libspdm_test_requester_get_csr_case3),
596 : /* Send req_info and opaque_data Successful response to get csr */
597 : cmocka_unit_test(libspdm_test_requester_get_csr_case4),
598 : /* Successful response to libspdm_get_csr_ex with a reset required */
599 : cmocka_unit_test(libspdm_test_requester_get_csr_case5),
600 : /* Illegal ResetRequired error response. */
601 : cmocka_unit_test(libspdm_test_requester_get_csr_case6),
602 : cmocka_unit_test(libspdm_test_requester_get_csr_case7),
603 : };
604 :
605 1 : libspdm_test_context_t test_context = {
606 : LIBSPDM_TEST_CONTEXT_VERSION,
607 : true,
608 : libspdm_requester_get_csr_test_send_message,
609 : libspdm_requester_get_csr_test_receive_message,
610 : };
611 :
612 1 : libspdm_setup_test_context(&test_context);
613 :
614 : /*ensure that cached.csr exists in test_csr at the beginning*/
615 1 : libspdm_clear_cached_csr();
616 :
617 1 : return cmocka_run_group_tests(spdm_requester_get_csr_tests,
618 : libspdm_unit_test_group_setup,
619 : libspdm_unit_test_group_teardown);
620 : }
621 :
622 : #endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP*/
|
