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