Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2024-2025 DMTF. All rights reserved.
4 : * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
5 : **/
6 :
7 : #include "spdm_unit_test.h"
8 : #include "internal/libspdm_responder_lib.h"
9 : #include "internal/libspdm_requester_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP
12 :
13 : /**
14 : * Test 1: Successful response to set key pair info with key pair id 4
15 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, and correct response message size and fields
16 : **/
17 1 : static void rsp_set_key_pair_info_ack_case1(void **state)
18 : {
19 : libspdm_return_t status;
20 : libspdm_test_context_t *spdm_test_context;
21 : libspdm_context_t *spdm_context;
22 : size_t response_size;
23 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
24 : spdm_set_key_pair_info_ack_response_t *spdm_response;
25 :
26 : uint8_t key_pair_id;
27 : size_t set_key_pair_info_request_size;
28 : spdm_set_key_pair_info_request_t *set_key_pair_info_request;
29 : uint8_t *ptr;
30 : uint16_t desired_key_usage;
31 : uint32_t desired_asym_algo;
32 : uint8_t desired_assoc_cert_slot_mask;
33 :
34 1 : set_key_pair_info_request = malloc(sizeof(spdm_set_key_pair_info_request_t) +
35 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) +
36 : sizeof(uint8_t));
37 :
38 1 : spdm_test_context = *state;
39 1 : spdm_context = spdm_test_context->spdm_context;
40 1 : spdm_test_context->case_id = 0x1;
41 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
42 : SPDM_VERSION_NUMBER_SHIFT_BIT;
43 1 : spdm_context->connection_info.connection_state =
44 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
45 1 : spdm_context->connection_info.algorithm.base_asym_algo =
46 : m_libspdm_use_asym_algo;
47 1 : spdm_context->local_context.capability.flags |=
48 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
49 :
50 1 : key_pair_id = 4;
51 :
52 1 : response_size = sizeof(response);
53 :
54 : /*change: remove an association with slot*/
55 1 : set_key_pair_info_request_size =
56 : sizeof(spdm_set_key_pair_info_request_t) +
57 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
58 :
59 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
60 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
61 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
62 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
63 1 : set_key_pair_info_request->header.param2 = 0;
64 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
65 :
66 1 : status = libspdm_get_response_set_key_pair_info_ack(
67 : spdm_context, set_key_pair_info_request_size,
68 : set_key_pair_info_request, &response_size, response);
69 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
70 1 : assert_int_equal(response_size,
71 : sizeof(spdm_set_key_pair_info_ack_response_t));
72 1 : spdm_response = (void *)response;
73 1 : assert_int_equal(spdm_response->header.request_response_code,
74 : SPDM_SET_KEY_PAIR_INFO_ACK);
75 :
76 : /*erase: erase the keyusage and asymalgo*/
77 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
78 1 : set_key_pair_info_request_size =
79 : sizeof(spdm_set_key_pair_info_request_t);
80 1 : status = libspdm_get_response_set_key_pair_info_ack(
81 : spdm_context, set_key_pair_info_request_size,
82 : set_key_pair_info_request, &response_size, response);
83 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
84 1 : assert_int_equal(response_size,
85 : sizeof(spdm_set_key_pair_info_ack_response_t));
86 1 : spdm_response = (void *)response;
87 1 : assert_int_equal(spdm_response->header.request_response_code,
88 : SPDM_SET_KEY_PAIR_INFO_ACK);
89 :
90 : /*generate: generate a new key pair*/
91 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
92 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
93 1 : desired_assoc_cert_slot_mask = 0x08;
94 1 : set_key_pair_info_request_size =
95 : sizeof(spdm_set_key_pair_info_request_t) +
96 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
97 :
98 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
99 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
100 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
101 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
102 1 : set_key_pair_info_request->header.param2 = 0;
103 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
104 :
105 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
106 1 : ptr += sizeof(uint8_t);
107 :
108 1 : libspdm_write_uint16(ptr, desired_key_usage);
109 1 : ptr += sizeof(uint16_t);
110 :
111 1 : libspdm_write_uint32(ptr, desired_asym_algo);
112 1 : ptr += sizeof(uint32_t);
113 :
114 1 : *ptr = desired_assoc_cert_slot_mask;
115 :
116 1 : status = libspdm_get_response_set_key_pair_info_ack(
117 : spdm_context, set_key_pair_info_request_size,
118 : set_key_pair_info_request, &response_size, response);
119 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
120 1 : assert_int_equal(response_size,
121 : sizeof(spdm_set_key_pair_info_ack_response_t));
122 1 : spdm_response = (void *)response;
123 1 : assert_int_equal(spdm_response->header.request_response_code,
124 : SPDM_SET_KEY_PAIR_INFO_ACK);
125 1 : free(set_key_pair_info_request);
126 1 : }
127 :
128 : /**
129 : * Test 2: Can be populated with new test.
130 : **/
131 1 : static void rsp_set_key_pair_info_ack_case2(void **state)
132 : {
133 1 : }
134 :
135 : /**
136 : * Test 3: The collection of multiple sub-cases.
137 : **/
138 1 : static void rsp_set_key_pair_info_ack_case3(void **state)
139 : {
140 : libspdm_return_t status;
141 : libspdm_test_context_t *spdm_test_context;
142 : libspdm_context_t *spdm_context;
143 : size_t response_size;
144 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
145 : spdm_set_key_pair_info_ack_response_t *spdm_response;
146 :
147 : uint8_t key_pair_id;
148 : size_t set_key_pair_info_request_size;
149 : spdm_set_key_pair_info_request_t *set_key_pair_info_request;
150 : uint8_t *ptr;
151 : uint16_t desired_key_usage;
152 : uint32_t desired_asym_algo;
153 : uint8_t desired_assoc_cert_slot_mask;
154 : uint8_t desired_pqc_asym_algo_len;
155 : uint32_t desired_pqc_asym_algo;
156 :
157 : uint8_t temp_buf[LIBSPDM_RECEIVER_BUFFER_SIZE];
158 1 : set_key_pair_info_request = (spdm_set_key_pair_info_request_t *)temp_buf;
159 :
160 1 : spdm_test_context = *state;
161 1 : spdm_context = spdm_test_context->spdm_context;
162 1 : spdm_test_context->case_id = 0x3;
163 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
164 : SPDM_VERSION_NUMBER_SHIFT_BIT;
165 1 : spdm_context->connection_info.connection_state =
166 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
167 1 : spdm_context->connection_info.algorithm.base_asym_algo =
168 : m_libspdm_use_asym_algo;
169 1 : spdm_context->local_context.capability.flags |=
170 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
171 :
172 1 : key_pair_id = 4;
173 :
174 : /*set responder need reset, spdm 1.4 */
175 1 : spdm_context->local_context.capability.flags |=
176 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_RESET_CAP;
177 :
178 : /*Before reset, change: remove an association with slot*/
179 1 : set_key_pair_info_request_size =
180 : sizeof(spdm_set_key_pair_info_request_t) +
181 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t) +
182 : sizeof(uint8_t);
183 :
184 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
185 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
186 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
187 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
188 1 : set_key_pair_info_request->header.param2 = 0;
189 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
190 :
191 1 : response_size = sizeof(response);
192 1 : status = libspdm_get_response_set_key_pair_info_ack(
193 : spdm_context, set_key_pair_info_request_size,
194 : set_key_pair_info_request, &response_size, response);
195 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
196 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
197 1 : spdm_response = (void *)response;
198 1 : assert_int_equal(spdm_response->header.request_response_code,
199 : SPDM_ERROR);
200 1 : assert_int_equal(spdm_response->header.param1,
201 : SPDM_ERROR_CODE_RESET_REQUIRED);
202 1 : assert_int_equal(spdm_response->header.param2, 0);
203 :
204 : /* Sub Case 1: If KeyPairErase is set, all fields after the KeyPairID field in this request should not exist. */
205 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
206 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
207 1 : desired_pqc_asym_algo_len = sizeof(desired_pqc_asym_algo);
208 1 : desired_pqc_asym_algo = 0;
209 1 : desired_assoc_cert_slot_mask = 0x08;
210 1 : set_key_pair_info_request_size =
211 : sizeof(spdm_set_key_pair_info_request_t) +
212 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t) +
213 : sizeof(uint8_t) + sizeof(uint32_t);
214 :
215 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
216 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
217 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
218 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
219 1 : set_key_pair_info_request->header.param2 = 0;
220 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
221 :
222 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
223 1 : ptr += sizeof(uint8_t);
224 :
225 1 : libspdm_write_uint16(ptr, desired_key_usage);
226 1 : ptr += sizeof(uint16_t);
227 :
228 1 : libspdm_write_uint32(ptr, desired_asym_algo);
229 1 : ptr += sizeof(uint32_t);
230 :
231 1 : *ptr = desired_assoc_cert_slot_mask;
232 1 : ptr += sizeof(uint8_t);
233 :
234 1 : *ptr = desired_pqc_asym_algo_len;
235 1 : ptr += sizeof(uint8_t);
236 :
237 1 : libspdm_write_uint32(ptr, desired_pqc_asym_algo);
238 :
239 1 : response_size = sizeof(response);
240 1 : status = libspdm_get_response_set_key_pair_info_ack(
241 : spdm_context, set_key_pair_info_request_size,
242 : set_key_pair_info_request, &response_size, response);
243 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
244 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
245 1 : spdm_response = (void *)response;
246 1 : assert_int_equal(spdm_response->header.request_response_code,
247 : SPDM_ERROR);
248 1 : assert_int_equal(spdm_response->header.param1,
249 : SPDM_ERROR_CODE_OPERATION_FAILED);
250 1 : assert_int_equal(spdm_response->header.param2, 0);
251 :
252 : /*Sub Case 2: When GenerateKeyPair is set, the fields of DesiredKeyUsage, DesiredAsymAlgo and DesiredAssocCertSlotMask should exist. */
253 1 : set_key_pair_info_request_size =
254 : sizeof(spdm_set_key_pair_info_request_t);
255 :
256 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
257 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
258 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
259 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_GENERATE_OPERATION;
260 1 : set_key_pair_info_request->header.param2 = 0;
261 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
262 :
263 1 : response_size = sizeof(response);
264 1 : status = libspdm_get_response_set_key_pair_info_ack(
265 : spdm_context, set_key_pair_info_request_size,
266 : set_key_pair_info_request, &response_size, response);
267 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
268 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
269 1 : spdm_response = (void *)response;
270 1 : assert_int_equal(spdm_response->header.request_response_code,
271 : SPDM_ERROR);
272 1 : assert_int_equal(spdm_response->header.param1,
273 : SPDM_ERROR_CODE_INVALID_REQUEST);
274 1 : assert_int_equal(spdm_response->header.param2, 0);
275 :
276 : /*Sub Case 3: key_pair_id = 0 */
277 1 : set_key_pair_info_request_size =
278 : sizeof(spdm_set_key_pair_info_request_t);
279 :
280 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
281 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
282 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
283 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_GENERATE_OPERATION;
284 1 : set_key_pair_info_request->header.param2 = 0;
285 1 : set_key_pair_info_request->key_pair_id = 0;
286 :
287 1 : response_size = sizeof(response);
288 1 : status = libspdm_get_response_set_key_pair_info_ack(
289 : spdm_context, set_key_pair_info_request_size,
290 : set_key_pair_info_request, &response_size, response);
291 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
292 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
293 1 : spdm_response = (void *)response;
294 1 : assert_int_equal(spdm_response->header.request_response_code,
295 : SPDM_ERROR);
296 1 : assert_int_equal(spdm_response->header.param1,
297 : SPDM_ERROR_CODE_INVALID_REQUEST);
298 1 : assert_int_equal(spdm_response->header.param2, 0);
299 :
300 : /* Sub Case 4: DesiredAsymAlgo must not have multiple bits set. */
301 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
302 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256 |
303 : SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC384;
304 1 : desired_pqc_asym_algo_len = sizeof(desired_pqc_asym_algo);
305 1 : desired_pqc_asym_algo = 0;
306 1 : desired_assoc_cert_slot_mask = 0x08;
307 1 : set_key_pair_info_request_size =
308 : sizeof(spdm_set_key_pair_info_request_t) +
309 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t) +
310 : sizeof(uint8_t) + sizeof(uint32_t);
311 :
312 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
313 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
314 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
315 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
316 1 : set_key_pair_info_request->header.param2 = 0;
317 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
318 :
319 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
320 1 : ptr += sizeof(uint8_t);
321 :
322 1 : libspdm_write_uint16(ptr, desired_key_usage);
323 1 : ptr += sizeof(uint16_t);
324 :
325 1 : libspdm_write_uint32(ptr, desired_asym_algo);
326 1 : ptr += sizeof(uint32_t);
327 :
328 1 : *ptr = desired_assoc_cert_slot_mask;
329 1 : ptr += sizeof(uint8_t);
330 :
331 1 : *ptr = desired_pqc_asym_algo_len;
332 1 : ptr += sizeof(uint8_t);
333 :
334 1 : libspdm_write_uint32(ptr, desired_pqc_asym_algo);
335 :
336 1 : response_size = sizeof(response);
337 1 : status = libspdm_get_response_set_key_pair_info_ack(
338 : spdm_context, set_key_pair_info_request_size,
339 : set_key_pair_info_request, &response_size, response);
340 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
341 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
342 1 : spdm_response = (void *)response;
343 1 : assert_int_equal(spdm_response->header.request_response_code,
344 : SPDM_ERROR);
345 1 : assert_int_equal(spdm_response->header.param1,
346 : SPDM_ERROR_CODE_INVALID_REQUEST);
347 1 : assert_int_equal(spdm_response->header.param2, 0);
348 :
349 : /*Before reset, change: remove an association with slot*/
350 1 : set_key_pair_info_request_size =
351 : sizeof(spdm_set_key_pair_info_request_t) +
352 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t) +
353 : sizeof(uint8_t);
354 :
355 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
356 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
357 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
358 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
359 1 : set_key_pair_info_request->header.param2 = 0;
360 1 : set_key_pair_info_request->key_pair_id = 0x1;
361 :
362 1 : response_size = sizeof(response);
363 1 : status = libspdm_get_response_set_key_pair_info_ack(
364 : spdm_context, set_key_pair_info_request_size,
365 : set_key_pair_info_request, &response_size, response);
366 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
367 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
368 1 : spdm_response = (void *)response;
369 1 : assert_int_equal(spdm_response->header.request_response_code,
370 : SPDM_ERROR);
371 1 : assert_int_equal(spdm_response->header.param1,
372 : SPDM_ERROR_CODE_RESET_REQUIRED);
373 1 : assert_int_equal(spdm_response->header.param2, 0);
374 1 : }
375 :
376 : /**
377 : * Test 4: Successful response to set key pair info with key pair id 4: need reset, spdm 1.4
378 : * Expected Behavior: get a LIBSPDM_STATUS_SUCCESS return code, and correct response message size and fields
379 : **/
380 1 : static void rsp_set_key_pair_info_ack_case4(void **state)
381 : {
382 : /* reference case 2 */
383 : libspdm_return_t status;
384 : libspdm_test_context_t *spdm_test_context;
385 : libspdm_context_t *spdm_context;
386 : size_t response_size;
387 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
388 : spdm_set_key_pair_info_ack_response_t *spdm_response;
389 :
390 : uint8_t key_pair_id;
391 : size_t set_key_pair_info_request_size;
392 : spdm_set_key_pair_info_request_t *set_key_pair_info_request;
393 : uint8_t *ptr;
394 : uint16_t desired_key_usage;
395 : uint32_t desired_asym_algo;
396 : uint8_t desired_assoc_cert_slot_mask;
397 : uint8_t desired_pqc_asym_algo_len;
398 : uint32_t desired_pqc_asym_algo;
399 :
400 1 : set_key_pair_info_request = malloc(sizeof(spdm_set_key_pair_info_request_t) +
401 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) +
402 : sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint32_t));
403 :
404 1 : spdm_test_context = *state;
405 1 : spdm_context = spdm_test_context->spdm_context;
406 1 : spdm_test_context->case_id = 0x4;
407 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_14 <<
408 : SPDM_VERSION_NUMBER_SHIFT_BIT;
409 1 : spdm_context->connection_info.connection_state =
410 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
411 1 : spdm_context->connection_info.algorithm.base_asym_algo =
412 : m_libspdm_use_asym_algo;
413 1 : spdm_context->local_context.capability.flags = 0; /* clear flags */
414 1 : spdm_context->local_context.capability.flags |=
415 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
416 :
417 1 : key_pair_id = 4;
418 :
419 : /*set responder need reset, spdm 1.4 */
420 1 : spdm_context->local_context.capability.flags |=
421 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_RESET_CAP;
422 :
423 1 : response_size = sizeof(response);
424 :
425 : /*Before reset, change: remove an association with slot*/
426 1 : set_key_pair_info_request_size =
427 : sizeof(spdm_set_key_pair_info_request_t) +
428 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t) +
429 : sizeof(uint8_t);
430 :
431 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
432 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
433 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
434 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
435 1 : set_key_pair_info_request->header.param2 = 0;
436 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
437 :
438 1 : status = libspdm_get_response_set_key_pair_info_ack(
439 : spdm_context, set_key_pair_info_request_size,
440 : set_key_pair_info_request, &response_size, response);
441 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
442 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
443 1 : spdm_response = (void *)response;
444 1 : assert_int_equal(spdm_response->header.request_response_code,
445 : SPDM_ERROR);
446 1 : assert_int_equal(spdm_response->header.param1,
447 : SPDM_ERROR_CODE_RESET_REQUIRED);
448 1 : assert_int_equal(spdm_response->header.param2, 0);
449 :
450 : /*After reset, change: remove an association with slot*/
451 1 : status = libspdm_get_response_set_key_pair_info_ack(
452 : spdm_context, set_key_pair_info_request_size,
453 : set_key_pair_info_request, &response_size, response);
454 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
455 1 : assert_int_equal(response_size,
456 : sizeof(spdm_set_key_pair_info_ack_response_t));
457 1 : spdm_response = (void *)response;
458 1 : assert_int_equal(spdm_response->header.request_response_code,
459 : SPDM_SET_KEY_PAIR_INFO_ACK);
460 :
461 : /*Before reset, erase: erase the keyusage and asymalgo*/
462 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
463 1 : set_key_pair_info_request_size =
464 : sizeof(spdm_set_key_pair_info_request_t);
465 1 : status = libspdm_get_response_set_key_pair_info_ack(
466 : spdm_context, set_key_pair_info_request_size,
467 : set_key_pair_info_request, &response_size, response);
468 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
469 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
470 1 : spdm_response = (void *)response;
471 1 : assert_int_equal(spdm_response->header.request_response_code,
472 : SPDM_ERROR);
473 1 : assert_int_equal(spdm_response->header.param1,
474 : SPDM_ERROR_CODE_RESET_REQUIRED);
475 1 : assert_int_equal(spdm_response->header.param2, 0);
476 :
477 : /*After reset, erase: erase the keyusage and asymalgo*/
478 1 : status = libspdm_get_response_set_key_pair_info_ack(
479 : spdm_context, set_key_pair_info_request_size,
480 : set_key_pair_info_request, &response_size, response);
481 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
482 1 : assert_int_equal(response_size,
483 : sizeof(spdm_set_key_pair_info_ack_response_t));
484 1 : spdm_response = (void *)response;
485 1 : assert_int_equal(spdm_response->header.request_response_code,
486 : SPDM_SET_KEY_PAIR_INFO_ACK);
487 :
488 :
489 : /*Before reset, generate: generate a new key pair*/
490 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
491 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
492 1 : desired_pqc_asym_algo_len = sizeof(desired_pqc_asym_algo);
493 1 : desired_pqc_asym_algo = 0;
494 1 : desired_assoc_cert_slot_mask = 0x08;
495 1 : set_key_pair_info_request_size =
496 : sizeof(spdm_set_key_pair_info_request_t) +
497 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t) +
498 : sizeof(uint8_t) + sizeof(uint32_t);
499 :
500 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
501 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_14;
502 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
503 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
504 1 : set_key_pair_info_request->header.param2 = 0;
505 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
506 :
507 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
508 1 : ptr += sizeof(uint8_t);
509 :
510 1 : libspdm_write_uint16(ptr, desired_key_usage);
511 1 : ptr += sizeof(uint16_t);
512 :
513 1 : libspdm_write_uint32(ptr, desired_asym_algo);
514 1 : ptr += sizeof(uint32_t);
515 :
516 1 : *ptr = desired_assoc_cert_slot_mask;
517 1 : ptr += sizeof(uint8_t);
518 :
519 1 : *ptr = desired_pqc_asym_algo_len;
520 1 : ptr += sizeof(uint8_t);
521 :
522 1 : libspdm_write_uint32(ptr, desired_pqc_asym_algo);
523 :
524 1 : status = libspdm_get_response_set_key_pair_info_ack(
525 : spdm_context, set_key_pair_info_request_size,
526 : set_key_pair_info_request, &response_size, response);
527 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
528 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
529 1 : spdm_response = (void *)response;
530 1 : assert_int_equal(spdm_response->header.request_response_code,
531 : SPDM_ERROR);
532 1 : assert_int_equal(spdm_response->header.param1,
533 : SPDM_ERROR_CODE_RESET_REQUIRED);
534 1 : assert_int_equal(spdm_response->header.param2, 0);
535 :
536 : /*After reset, generate: generate a new key pair*/
537 1 : status = libspdm_get_response_set_key_pair_info_ack(
538 : spdm_context, set_key_pair_info_request_size,
539 : set_key_pair_info_request, &response_size, response);
540 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
541 1 : assert_int_equal(response_size,
542 : sizeof(spdm_set_key_pair_info_ack_response_t));
543 1 : spdm_response = (void *)response;
544 1 : assert_int_equal(spdm_response->header.request_response_code,
545 : SPDM_SET_KEY_PAIR_INFO_ACK);
546 1 : free(set_key_pair_info_request);
547 1 : }
548 :
549 1 : int libspdm_rsp_set_key_pair_info_ack_test(void)
550 : {
551 1 : const struct CMUnitTest test_cases[] = {
552 : /* Success Case to set key pair info*/
553 : cmocka_unit_test(rsp_set_key_pair_info_ack_case1),
554 : /* Can be populated with new test*/
555 : cmocka_unit_test(rsp_set_key_pair_info_ack_case2),
556 : /* The collection of multiple sub-cases.*/
557 : cmocka_unit_test(rsp_set_key_pair_info_ack_case3),
558 : /* Success Case to set key pair info with reset, spdm 1.4*/
559 : cmocka_unit_test(rsp_set_key_pair_info_ack_case4),
560 : };
561 :
562 1 : libspdm_test_context_t test_context = {
563 : LIBSPDM_TEST_CONTEXT_VERSION,
564 : false,
565 : };
566 1 : libspdm_setup_test_context(&test_context);
567 :
568 1 : return cmocka_run_group_tests(test_cases,
569 : libspdm_unit_test_group_setup,
570 : libspdm_unit_test_group_teardown);
571 : }
572 :
573 : #endif /* LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP*/
|
