Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2024 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 RETURN_SUCCESS return code, and correct response message size and fields
16 : **/
17 1 : void libspdm_test_responder_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 1 : spdm_context->local_context.total_key_pairs = libspdm_read_total_key_pairs();
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: Successful response to set key pair info with key pair id 4: need reset
130 : * Expected Behavior: get a RETURN_SUCCESS return code, and correct response message size and fields
131 : **/
132 1 : void libspdm_test_responder_set_key_pair_info_ack_case2(void **state)
133 : {
134 : libspdm_return_t status;
135 : libspdm_test_context_t *spdm_test_context;
136 : libspdm_context_t *spdm_context;
137 : size_t response_size;
138 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
139 : spdm_set_key_pair_info_ack_response_t *spdm_response;
140 :
141 : uint8_t key_pair_id;
142 : size_t set_key_pair_info_request_size;
143 : spdm_set_key_pair_info_request_t *set_key_pair_info_request;
144 : uint8_t *ptr;
145 : uint16_t desired_key_usage;
146 : uint32_t desired_asym_algo;
147 : uint8_t desired_assoc_cert_slot_mask;
148 :
149 1 : set_key_pair_info_request = malloc(sizeof(spdm_set_key_pair_info_request_t) +
150 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) +
151 : sizeof(uint8_t));
152 :
153 1 : spdm_test_context = *state;
154 1 : spdm_context = spdm_test_context->spdm_context;
155 1 : spdm_test_context->case_id = 0x2;
156 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
157 : SPDM_VERSION_NUMBER_SHIFT_BIT;
158 1 : spdm_context->connection_info.connection_state =
159 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
160 1 : spdm_context->connection_info.algorithm.base_asym_algo =
161 : m_libspdm_use_asym_algo;
162 1 : spdm_context->local_context.capability.flags |=
163 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
164 1 : spdm_context->local_context.total_key_pairs = libspdm_read_total_key_pairs();
165 1 : key_pair_id = 4;
166 :
167 : /*set responder need reset*/
168 1 : spdm_context->local_context.capability.flags |=
169 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
170 :
171 1 : response_size = sizeof(response);
172 :
173 : /*Before reset, change: remove an association with slot*/
174 1 : set_key_pair_info_request_size =
175 : sizeof(spdm_set_key_pair_info_request_t) +
176 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
177 :
178 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
179 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
180 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
181 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
182 1 : set_key_pair_info_request->header.param2 = 0;
183 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
184 :
185 1 : status = libspdm_get_response_set_key_pair_info_ack(
186 : spdm_context, set_key_pair_info_request_size,
187 : set_key_pair_info_request, &response_size, response);
188 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
189 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
190 1 : spdm_response = (void *)response;
191 1 : assert_int_equal(spdm_response->header.request_response_code,
192 : SPDM_ERROR);
193 1 : assert_int_equal(spdm_response->header.param1,
194 : SPDM_ERROR_CODE_RESET_REQUIRED);
195 1 : assert_int_equal(spdm_response->header.param2, 0);
196 :
197 : /*After reset, change: remove an association with slot*/
198 1 : status = libspdm_get_response_set_key_pair_info_ack(
199 : spdm_context, set_key_pair_info_request_size,
200 : set_key_pair_info_request, &response_size, response);
201 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
202 1 : assert_int_equal(response_size,
203 : sizeof(spdm_set_key_pair_info_ack_response_t));
204 1 : spdm_response = (void *)response;
205 1 : assert_int_equal(spdm_response->header.request_response_code,
206 : SPDM_SET_KEY_PAIR_INFO_ACK);
207 :
208 : /*Before reset, erase: erase the keyusage and asymalgo*/
209 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
210 1 : set_key_pair_info_request_size =
211 : sizeof(spdm_set_key_pair_info_request_t);
212 1 : status = libspdm_get_response_set_key_pair_info_ack(
213 : spdm_context, set_key_pair_info_request_size,
214 : set_key_pair_info_request, &response_size, response);
215 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
216 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
217 1 : spdm_response = (void *)response;
218 1 : assert_int_equal(spdm_response->header.request_response_code,
219 : SPDM_ERROR);
220 1 : assert_int_equal(spdm_response->header.param1,
221 : SPDM_ERROR_CODE_RESET_REQUIRED);
222 1 : assert_int_equal(spdm_response->header.param2, 0);
223 :
224 : /*After reset, erase: erase the keyusage and asymalgo*/
225 1 : status = libspdm_get_response_set_key_pair_info_ack(
226 : spdm_context, set_key_pair_info_request_size,
227 : set_key_pair_info_request, &response_size, response);
228 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
229 1 : assert_int_equal(response_size,
230 : sizeof(spdm_set_key_pair_info_ack_response_t));
231 1 : spdm_response = (void *)response;
232 1 : assert_int_equal(spdm_response->header.request_response_code,
233 : SPDM_SET_KEY_PAIR_INFO_ACK);
234 :
235 :
236 : /*Before reset, generate: generate a new key pair*/
237 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
238 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
239 1 : desired_assoc_cert_slot_mask = 0x08;
240 1 : set_key_pair_info_request_size =
241 : sizeof(spdm_set_key_pair_info_request_t) +
242 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
243 :
244 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
245 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
246 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
247 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
248 1 : set_key_pair_info_request->header.param2 = 0;
249 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
250 :
251 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
252 1 : ptr += sizeof(uint8_t);
253 :
254 1 : libspdm_write_uint16(ptr, desired_key_usage);
255 1 : ptr += sizeof(uint16_t);
256 :
257 1 : libspdm_write_uint32(ptr, desired_asym_algo);
258 1 : ptr += sizeof(uint32_t);
259 :
260 1 : *ptr = desired_assoc_cert_slot_mask;
261 :
262 1 : status = libspdm_get_response_set_key_pair_info_ack(
263 : spdm_context, set_key_pair_info_request_size,
264 : set_key_pair_info_request, &response_size, response);
265 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
266 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
267 1 : spdm_response = (void *)response;
268 1 : assert_int_equal(spdm_response->header.request_response_code,
269 : SPDM_ERROR);
270 1 : assert_int_equal(spdm_response->header.param1,
271 : SPDM_ERROR_CODE_RESET_REQUIRED);
272 1 : assert_int_equal(spdm_response->header.param2, 0);
273 :
274 : /*After reset, generate: generate a new key pair*/
275 1 : status = libspdm_get_response_set_key_pair_info_ack(
276 : spdm_context, set_key_pair_info_request_size,
277 : set_key_pair_info_request, &response_size, response);
278 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
279 1 : assert_int_equal(response_size,
280 : sizeof(spdm_set_key_pair_info_ack_response_t));
281 1 : spdm_response = (void *)response;
282 1 : assert_int_equal(spdm_response->header.request_response_code,
283 : SPDM_SET_KEY_PAIR_INFO_ACK);
284 1 : free(set_key_pair_info_request);
285 1 : }
286 :
287 : /**
288 : * Test 2: The collection of multiple sub-cases.
289 : **/
290 1 : void libspdm_test_responder_set_key_pair_info_ack_case3(void **state)
291 : {
292 : libspdm_return_t status;
293 : libspdm_test_context_t *spdm_test_context;
294 : libspdm_context_t *spdm_context;
295 : size_t response_size;
296 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
297 : spdm_set_key_pair_info_ack_response_t *spdm_response;
298 :
299 : uint8_t key_pair_id;
300 : size_t set_key_pair_info_request_size;
301 : spdm_set_key_pair_info_request_t *set_key_pair_info_request;
302 : uint8_t *ptr;
303 : uint16_t desired_key_usage;
304 : uint32_t desired_asym_algo;
305 : uint8_t desired_assoc_cert_slot_mask;
306 :
307 : uint8_t temp_buf[LIBSPDM_RECEIVER_BUFFER_SIZE];
308 1 : set_key_pair_info_request = (spdm_set_key_pair_info_request_t *)temp_buf;
309 :
310 1 : spdm_test_context = *state;
311 1 : spdm_context = spdm_test_context->spdm_context;
312 1 : spdm_test_context->case_id = 0x3;
313 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
314 : SPDM_VERSION_NUMBER_SHIFT_BIT;
315 1 : spdm_context->connection_info.connection_state =
316 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
317 1 : spdm_context->connection_info.algorithm.base_asym_algo =
318 : m_libspdm_use_asym_algo;
319 1 : spdm_context->local_context.capability.flags |=
320 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_SET_KEY_PAIR_INFO_CAP;
321 1 : spdm_context->local_context.total_key_pairs = libspdm_read_total_key_pairs();
322 1 : key_pair_id = 4;
323 :
324 : /*set responder need reset*/
325 1 : spdm_context->local_context.capability.flags |=
326 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CERT_INSTALL_RESET_CAP;
327 :
328 : /*Before reset, change: remove an association with slot*/
329 1 : set_key_pair_info_request_size =
330 : sizeof(spdm_set_key_pair_info_request_t) +
331 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
332 :
333 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
334 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
335 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
336 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
337 1 : set_key_pair_info_request->header.param2 = 0;
338 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
339 :
340 1 : response_size = sizeof(response);
341 1 : status = libspdm_get_response_set_key_pair_info_ack(
342 : spdm_context, set_key_pair_info_request_size,
343 : set_key_pair_info_request, &response_size, response);
344 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
345 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
346 1 : spdm_response = (void *)response;
347 1 : assert_int_equal(spdm_response->header.request_response_code,
348 : SPDM_ERROR);
349 1 : assert_int_equal(spdm_response->header.param1,
350 : SPDM_ERROR_CODE_RESET_REQUIRED);
351 1 : assert_int_equal(spdm_response->header.param2, 0);
352 :
353 : /* Sub Case 1: If KeyPairErase is set, all fields after the KeyPairID field in this request should not exist. */
354 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
355 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256;
356 1 : desired_assoc_cert_slot_mask = 0x08;
357 1 : set_key_pair_info_request_size =
358 : sizeof(spdm_set_key_pair_info_request_t) +
359 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
360 :
361 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
362 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
363 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
364 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_ERASE_OPERATION;
365 1 : set_key_pair_info_request->header.param2 = 0;
366 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
367 :
368 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
369 1 : ptr += sizeof(uint8_t);
370 :
371 1 : libspdm_write_uint16(ptr, desired_key_usage);
372 1 : ptr += sizeof(uint16_t);
373 :
374 1 : libspdm_write_uint32(ptr, desired_asym_algo);
375 1 : ptr += sizeof(uint32_t);
376 :
377 1 : *ptr = desired_assoc_cert_slot_mask;
378 :
379 1 : response_size = sizeof(response);
380 1 : status = libspdm_get_response_set_key_pair_info_ack(
381 : spdm_context, set_key_pair_info_request_size,
382 : set_key_pair_info_request, &response_size, response);
383 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
384 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
385 1 : spdm_response = (void *)response;
386 1 : assert_int_equal(spdm_response->header.request_response_code,
387 : SPDM_ERROR);
388 1 : assert_int_equal(spdm_response->header.param1,
389 : SPDM_ERROR_CODE_OPERATION_FAILED);
390 1 : assert_int_equal(spdm_response->header.param2, 0);
391 :
392 : /*Sub Case 2: When GenerateKeyPair is set, the fields of DesiredKeyUsage, DesiredAsymAlgo and DesiredAssocCertSlotMask should exist. */
393 1 : set_key_pair_info_request_size =
394 : sizeof(spdm_set_key_pair_info_request_t);
395 :
396 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
397 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
398 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
399 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_GENERATE_OPERATION;
400 1 : set_key_pair_info_request->header.param2 = 0;
401 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
402 :
403 1 : response_size = sizeof(response);
404 1 : status = libspdm_get_response_set_key_pair_info_ack(
405 : spdm_context, set_key_pair_info_request_size,
406 : set_key_pair_info_request, &response_size, response);
407 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
408 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
409 1 : spdm_response = (void *)response;
410 1 : assert_int_equal(spdm_response->header.request_response_code,
411 : SPDM_ERROR);
412 1 : assert_int_equal(spdm_response->header.param1,
413 : SPDM_ERROR_CODE_INVALID_REQUEST);
414 1 : assert_int_equal(spdm_response->header.param2, 0);
415 :
416 : /*Sub Case 3: key_pair_id = 0 */
417 1 : set_key_pair_info_request_size =
418 : sizeof(spdm_set_key_pair_info_request_t);
419 :
420 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
421 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
422 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
423 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_GENERATE_OPERATION;
424 1 : set_key_pair_info_request->header.param2 = 0;
425 1 : set_key_pair_info_request->key_pair_id = 0;
426 :
427 1 : response_size = sizeof(response);
428 1 : status = libspdm_get_response_set_key_pair_info_ack(
429 : spdm_context, set_key_pair_info_request_size,
430 : set_key_pair_info_request, &response_size, response);
431 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
432 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
433 1 : spdm_response = (void *)response;
434 1 : assert_int_equal(spdm_response->header.request_response_code,
435 : SPDM_ERROR);
436 1 : assert_int_equal(spdm_response->header.param1,
437 : SPDM_ERROR_CODE_INVALID_REQUEST);
438 1 : assert_int_equal(spdm_response->header.param2, 0);
439 :
440 : /* Sub Case 4: DesiredAsymAlgo must not have multiple bits set. */
441 1 : desired_key_usage = SPDM_KEY_USAGE_BIT_MASK_KEY_EX_USE;
442 1 : desired_asym_algo = SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC256 |
443 : SPDM_KEY_PAIR_ASYM_ALGO_CAP_ECC384;
444 1 : desired_assoc_cert_slot_mask = 0x08;
445 1 : set_key_pair_info_request_size =
446 : sizeof(spdm_set_key_pair_info_request_t) +
447 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
448 :
449 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
450 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
451 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
452 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
453 1 : set_key_pair_info_request->header.param2 = 0;
454 1 : set_key_pair_info_request->key_pair_id = key_pair_id;
455 :
456 1 : ptr = (uint8_t*)(set_key_pair_info_request + 1);
457 1 : ptr += sizeof(uint8_t);
458 :
459 1 : libspdm_write_uint16(ptr, desired_key_usage);
460 1 : ptr += sizeof(uint16_t);
461 :
462 1 : libspdm_write_uint32(ptr, desired_asym_algo);
463 1 : ptr += sizeof(uint32_t);
464 :
465 1 : *ptr = desired_assoc_cert_slot_mask;
466 :
467 1 : response_size = sizeof(response);
468 1 : status = libspdm_get_response_set_key_pair_info_ack(
469 : spdm_context, set_key_pair_info_request_size,
470 : set_key_pair_info_request, &response_size, response);
471 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
472 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
473 1 : spdm_response = (void *)response;
474 1 : assert_int_equal(spdm_response->header.request_response_code,
475 : SPDM_ERROR);
476 1 : assert_int_equal(spdm_response->header.param1,
477 : SPDM_ERROR_CODE_INVALID_REQUEST);
478 1 : assert_int_equal(spdm_response->header.param2, 0);
479 :
480 : /*Before reset, change: remove an association with slot*/
481 1 : set_key_pair_info_request_size =
482 : sizeof(spdm_set_key_pair_info_request_t) +
483 : sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint8_t);
484 :
485 1 : libspdm_zero_mem(set_key_pair_info_request, set_key_pair_info_request_size);
486 1 : set_key_pair_info_request->header.spdm_version = SPDM_MESSAGE_VERSION_13;
487 1 : set_key_pair_info_request->header.request_response_code = SPDM_SET_KEY_PAIR_INFO;
488 1 : set_key_pair_info_request->header.param1 = SPDM_SET_KEY_PAIR_INFO_CHANGE_OPERATION;
489 1 : set_key_pair_info_request->header.param2 = 0;
490 1 : set_key_pair_info_request->key_pair_id = 0x1;
491 :
492 1 : response_size = sizeof(response);
493 1 : status = libspdm_get_response_set_key_pair_info_ack(
494 : spdm_context, set_key_pair_info_request_size,
495 : set_key_pair_info_request, &response_size, response);
496 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
497 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
498 1 : spdm_response = (void *)response;
499 1 : assert_int_equal(spdm_response->header.request_response_code,
500 : SPDM_ERROR);
501 1 : assert_int_equal(spdm_response->header.param1,
502 : SPDM_ERROR_CODE_RESET_REQUIRED);
503 1 : assert_int_equal(spdm_response->header.param2, 0);
504 1 : }
505 :
506 1 : int libspdm_responder_set_key_pair_info_ack_test_main(void)
507 : {
508 1 : const struct CMUnitTest spdm_responder_set_key_pair_info_ack_tests[] = {
509 : /* Success Case to set key pair info*/
510 : cmocka_unit_test(libspdm_test_responder_set_key_pair_info_ack_case1),
511 : /* Success Case to set key pair info with reset*/
512 : cmocka_unit_test(libspdm_test_responder_set_key_pair_info_ack_case2),
513 : /* The collection of multiple sub-cases.*/
514 : cmocka_unit_test(libspdm_test_responder_set_key_pair_info_ack_case3),
515 : };
516 :
517 1 : libspdm_test_context_t test_context = {
518 : LIBSPDM_TEST_CONTEXT_VERSION,
519 : false,
520 : };
521 1 : libspdm_setup_test_context(&test_context);
522 :
523 1 : return cmocka_run_group_tests(spdm_responder_set_key_pair_info_ack_tests,
524 : libspdm_unit_test_group_setup,
525 : libspdm_unit_test_group_teardown);
526 : }
527 :
528 : #endif /* LIBSPDM_ENABLE_CAPABILITY_SET_KEY_PAIR_INFO_CAP*/
|