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 :
10 : #if LIBSPDM_ENABLE_CAPABILITY_MEL_CAP
11 :
12 : spdm_get_measurement_extension_log_request_t m_libspdm_get_measurement_extension_log_request1 = {
13 : { SPDM_MESSAGE_VERSION_13, SPDM_GET_MEASUREMENT_EXTENSION_LOG, 0, 0 },
14 : 0,
15 : LIBSPDM_MAX_MEL_BLOCK_LEN
16 : };
17 : size_t m_libspdm_get_measurement_extension_log_request1_size =
18 : sizeof(m_libspdm_get_measurement_extension_log_request1);
19 :
20 : spdm_get_measurement_extension_log_request_t m_libspdm_get_measurement_extension_log_request2 = {
21 : { SPDM_MESSAGE_VERSION_13, SPDM_GET_MEASUREMENT_EXTENSION_LOG, 0, 0 },
22 : 0,
23 : 0
24 : };
25 : size_t m_libspdm_get_measurement_extension_log_request2_size =
26 : sizeof(m_libspdm_get_measurement_extension_log_request2);
27 :
28 : spdm_get_measurement_extension_log_request_t m_libspdm_get_measurement_extension_log_request3 = {
29 : { SPDM_MESSAGE_VERSION_13, SPDM_GET_MEASUREMENT_EXTENSION_LOG, 0, 0 },
30 : 0,
31 : LIBSPDM_MAX_MEL_BLOCK_LEN + 1
32 : };
33 : size_t m_libspdm_get_measurement_extension_log_request3_size =
34 : sizeof(m_libspdm_get_measurement_extension_log_request3);
35 :
36 : spdm_get_measurement_extension_log_request_t m_libspdm_get_measurement_extension_log_request4 = {
37 : { SPDM_MESSAGE_VERSION_13, SPDM_GET_MEASUREMENT_EXTENSION_LOG, 0, 0 },
38 : LIBSPDM_MAX_MEL_BLOCK_LEN,
39 : LIBSPDM_MAX_MEL_BLOCK_LEN
40 : };
41 : size_t m_libspdm_get_measurement_extension_log_request4_size =
42 : sizeof(m_libspdm_get_measurement_extension_log_request4);
43 :
44 : /**
45 : * Test 1: request the first LIBSPDM_MAX_MEL_BLOCK_LEN bytes of the MEL
46 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
47 : **/
48 1 : void libspdm_test_responder_measurement_extension_log_case1(void **state)
49 : {
50 : libspdm_return_t status;
51 : libspdm_test_context_t *spdm_test_context;
52 : libspdm_context_t *spdm_context;
53 : size_t response_size;
54 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
55 : spdm_measurement_extension_log_response_t *spdm_response;
56 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
57 : size_t spdm_mel_len;
58 :
59 1 : spdm_test_context = *state;
60 1 : spdm_context = spdm_test_context->spdm_context;
61 1 : spdm_test_context->case_id = 0x1;
62 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
63 : SPDM_VERSION_NUMBER_SHIFT_BIT;
64 1 : spdm_context->connection_info.connection_state =
65 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
66 1 : spdm_context->local_context.capability.flags |=
67 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
68 1 : spdm_context->connection_info.algorithm.base_hash_algo =
69 : m_libspdm_use_hash_algo;
70 1 : spdm_context->connection_info.algorithm.base_asym_algo =
71 : m_libspdm_use_asym_algo;
72 1 : spdm_context->connection_info.algorithm.measurement_spec =
73 : m_libspdm_use_measurement_spec;
74 1 : spdm_context->connection_info.algorithm.mel_spec =
75 : m_libspdm_use_mel_spec;
76 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
77 : m_libspdm_use_measurement_hash_algo;
78 :
79 1 : response_size = sizeof(response);
80 1 : status = libspdm_get_response_measurement_extension_log(
81 : spdm_context, m_libspdm_get_measurement_extension_log_request1_size,
82 : &m_libspdm_get_measurement_extension_log_request1, &response_size, response);
83 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
84 :
85 1 : spdm_mel = NULL;
86 1 : spdm_mel_len = 0;
87 1 : libspdm_measurement_extension_log_collection(
88 : spdm_context,
89 : m_libspdm_use_mel_spec,
90 : m_libspdm_use_measurement_spec,
91 : m_libspdm_use_measurement_hash_algo,
92 : (void **)&spdm_mel, &spdm_mel_len);
93 :
94 1 : assert_int_equal(response_size,
95 : sizeof(spdm_measurement_extension_log_response_t) +
96 : spdm_mel_len);
97 1 : spdm_response = (void *)response;
98 1 : assert_int_equal(spdm_response->header.request_response_code,
99 : SPDM_MEASUREMENT_EXTENSION_LOG);
100 1 : assert_int_equal(spdm_response->header.param1, 0);
101 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len);
102 1 : assert_int_equal(spdm_response->remainder_length, 0);
103 1 : assert_memory_equal(spdm_response + 1, spdm_mel, spdm_mel_len);
104 1 : }
105 :
106 : /**
107 : * Test 2: request.length is less than the MEL len
108 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
109 : **/
110 1 : void libspdm_test_responder_measurement_extension_log_case2(void **state)
111 : {
112 : libspdm_return_t status;
113 : libspdm_test_context_t *spdm_test_context;
114 : libspdm_context_t *spdm_context;
115 : size_t response_size;
116 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
117 : spdm_measurement_extension_log_response_t *spdm_response;
118 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
119 : size_t spdm_mel_len;
120 :
121 1 : spdm_test_context = *state;
122 1 : spdm_context = spdm_test_context->spdm_context;
123 1 : spdm_test_context->case_id = 0x2;
124 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
125 : SPDM_VERSION_NUMBER_SHIFT_BIT;
126 1 : spdm_context->connection_info.connection_state =
127 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
128 1 : spdm_context->local_context.capability.flags |=
129 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
130 1 : spdm_context->connection_info.algorithm.base_hash_algo =
131 : m_libspdm_use_hash_algo;
132 1 : spdm_context->connection_info.algorithm.base_asym_algo =
133 : m_libspdm_use_asym_algo;
134 1 : spdm_context->connection_info.algorithm.measurement_spec =
135 : m_libspdm_use_measurement_spec;
136 1 : spdm_context->connection_info.algorithm.mel_spec =
137 : m_libspdm_use_mel_spec;
138 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
139 : m_libspdm_use_measurement_hash_algo;
140 :
141 1 : spdm_mel = NULL;
142 1 : spdm_mel_len = 0;
143 1 : libspdm_measurement_extension_log_collection(spdm_context,
144 : m_libspdm_use_mel_spec,
145 : m_libspdm_use_measurement_spec,
146 : m_libspdm_use_measurement_hash_algo,
147 : (void **)&spdm_mel, &spdm_mel_len);
148 :
149 : /* Test the validity of the request.length.*/
150 1 : m_libspdm_get_measurement_extension_log_request2.length = (uint32_t)spdm_mel_len / 2;
151 :
152 1 : response_size = sizeof(response);
153 1 : status = libspdm_get_response_measurement_extension_log(
154 : spdm_context, m_libspdm_get_measurement_extension_log_request2_size,
155 : &m_libspdm_get_measurement_extension_log_request2, &response_size, response);
156 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
157 :
158 1 : assert_int_equal(response_size,
159 : sizeof(spdm_measurement_extension_log_response_t) +
160 : spdm_mel_len / 2);
161 1 : spdm_response = (void *)response;
162 1 : assert_int_equal(spdm_response->header.request_response_code,
163 : SPDM_MEASUREMENT_EXTENSION_LOG);
164 1 : assert_int_equal(spdm_response->header.param1, 0);
165 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len / 2);
166 1 : assert_int_equal(spdm_response->remainder_length, spdm_mel_len / 2 + 1);
167 1 : assert_memory_equal(spdm_response + 1, (void *)spdm_mel,
168 : response_size - sizeof(spdm_measurement_extension_log_response_t));
169 1 : }
170 :
171 : /**
172 : * Test 3: When the request.length is greater than LIBSPDM_MAX_MEL_BLOCK_LEN.
173 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
174 : **/
175 1 : void libspdm_test_responder_measurement_extension_log_case3(void **state)
176 : {
177 : libspdm_return_t status;
178 : libspdm_test_context_t *spdm_test_context;
179 : libspdm_context_t *spdm_context;
180 : size_t response_size;
181 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
182 : spdm_measurement_extension_log_response_t *spdm_response;
183 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
184 : size_t spdm_mel_len;
185 :
186 1 : spdm_test_context = *state;
187 1 : spdm_context = spdm_test_context->spdm_context;
188 1 : spdm_test_context->case_id = 0x3;
189 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
190 : SPDM_VERSION_NUMBER_SHIFT_BIT;
191 1 : spdm_context->connection_info.connection_state =
192 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
193 1 : spdm_context->local_context.capability.flags |=
194 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
195 1 : spdm_context->connection_info.algorithm.base_hash_algo =
196 : m_libspdm_use_hash_algo;
197 1 : spdm_context->connection_info.algorithm.base_asym_algo =
198 : m_libspdm_use_asym_algo;
199 1 : spdm_context->connection_info.algorithm.measurement_spec =
200 : m_libspdm_use_measurement_spec;
201 1 : spdm_context->connection_info.algorithm.mel_spec =
202 : m_libspdm_use_mel_spec;
203 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
204 : m_libspdm_use_measurement_hash_algo;
205 :
206 1 : response_size = sizeof(response);
207 1 : status = libspdm_get_response_measurement_extension_log(
208 : spdm_context, m_libspdm_get_measurement_extension_log_request3_size,
209 : &m_libspdm_get_measurement_extension_log_request3, &response_size, response);
210 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
211 :
212 1 : spdm_mel = NULL;
213 1 : spdm_mel_len = 0;
214 1 : libspdm_measurement_extension_log_collection(spdm_context,
215 : m_libspdm_use_mel_spec,
216 : m_libspdm_use_measurement_spec,
217 : m_libspdm_use_measurement_hash_algo,
218 : (void **)&spdm_mel, &spdm_mel_len);
219 :
220 1 : assert_int_equal(response_size,
221 : sizeof(spdm_measurement_extension_log_response_t) +
222 : spdm_mel_len);
223 1 : spdm_response = (void *)response;
224 1 : assert_int_equal(spdm_response->header.request_response_code,
225 : SPDM_MEASUREMENT_EXTENSION_LOG);
226 1 : assert_int_equal(spdm_response->header.param1, 0);
227 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len);
228 1 : assert_int_equal(spdm_response->remainder_length, 0);
229 1 : assert_memory_equal(spdm_response + 1, (void *)spdm_mel,
230 : response_size - sizeof(spdm_measurement_extension_log_response_t));
231 1 : }
232 :
233 : /**
234 : * Test 4: request.offset > spdm mel len , wrong request message
235 : * Expected Behavior: Generate error response message
236 : **/
237 1 : void libspdm_test_responder_measurement_extension_log_case4(void **state)
238 : {
239 : libspdm_return_t status;
240 : libspdm_test_context_t *spdm_test_context;
241 : libspdm_context_t *spdm_context;
242 : size_t response_size;
243 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
244 : spdm_measurement_extension_log_response_t *spdm_response;
245 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
246 : size_t spdm_mel_len;
247 :
248 1 : spdm_test_context = *state;
249 1 : spdm_context = spdm_test_context->spdm_context;
250 1 : spdm_test_context->case_id = 0x4;
251 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
252 : SPDM_VERSION_NUMBER_SHIFT_BIT;
253 1 : spdm_context->connection_info.connection_state =
254 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
255 1 : spdm_context->local_context.capability.flags |=
256 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
257 1 : spdm_context->connection_info.algorithm.base_hash_algo =
258 : m_libspdm_use_hash_algo;
259 1 : spdm_context->connection_info.algorithm.base_asym_algo =
260 : m_libspdm_use_asym_algo;
261 1 : spdm_context->connection_info.algorithm.measurement_spec =
262 : m_libspdm_use_measurement_spec;
263 1 : spdm_context->connection_info.algorithm.mel_spec =
264 : m_libspdm_use_mel_spec;
265 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
266 : m_libspdm_use_measurement_hash_algo;
267 :
268 1 : spdm_mel = NULL;
269 1 : spdm_mel_len = 0;
270 1 : libspdm_measurement_extension_log_collection(spdm_context,
271 : m_libspdm_use_mel_spec,
272 : m_libspdm_use_measurement_spec,
273 : m_libspdm_use_measurement_hash_algo,
274 : (void **)&spdm_mel, &spdm_mel_len);
275 : /* request.offset > total MEL len*/
276 1 : m_libspdm_get_measurement_extension_log_request4.offset = (uint32_t)spdm_mel_len +
277 : LIBSPDM_MAX_MEL_BLOCK_LEN;
278 :
279 1 : response_size = sizeof(response);
280 1 : status = libspdm_get_response_measurement_extension_log(
281 : spdm_context, m_libspdm_get_measurement_extension_log_request4_size,
282 : &m_libspdm_get_measurement_extension_log_request4, &response_size, response);
283 :
284 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
285 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
286 1 : spdm_response = (void *)response;
287 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
288 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
289 1 : assert_int_equal(spdm_response->header.param2, 0);
290 1 : }
291 :
292 : /**
293 : * Test 5: A correct and not zero request.offset.
294 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
295 : **/
296 1 : void libspdm_test_responder_measurement_extension_log_case5(void **state)
297 : {
298 : libspdm_return_t status;
299 : libspdm_test_context_t *spdm_test_context;
300 : libspdm_context_t *spdm_context;
301 : size_t response_size;
302 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
303 : spdm_measurement_extension_log_response_t *spdm_response;
304 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
305 : size_t spdm_mel_len;
306 :
307 1 : spdm_test_context = *state;
308 1 : spdm_context = spdm_test_context->spdm_context;
309 1 : spdm_test_context->case_id = 0x5;
310 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
311 : SPDM_VERSION_NUMBER_SHIFT_BIT;
312 1 : spdm_context->connection_info.connection_state =
313 : LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
314 1 : spdm_context->local_context.capability.flags |=
315 : SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
316 1 : spdm_context->connection_info.algorithm.base_hash_algo =
317 : m_libspdm_use_hash_algo;
318 1 : spdm_context->connection_info.algorithm.base_asym_algo =
319 : m_libspdm_use_asym_algo;
320 1 : spdm_context->connection_info.algorithm.measurement_spec =
321 : m_libspdm_use_measurement_spec;
322 1 : spdm_context->connection_info.algorithm.mel_spec =
323 : m_libspdm_use_mel_spec;
324 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
325 : m_libspdm_use_measurement_hash_algo;
326 :
327 1 : spdm_mel = NULL;
328 1 : spdm_mel_len = 0;
329 1 : libspdm_measurement_extension_log_collection(spdm_context,
330 : m_libspdm_use_mel_spec,
331 : m_libspdm_use_measurement_spec,
332 : m_libspdm_use_measurement_hash_algo,
333 : (void **)&spdm_mel, &spdm_mel_len);
334 :
335 : /* Test the validity of the request.offset.*/
336 1 : m_libspdm_get_measurement_extension_log_request2.offset = (uint32_t)spdm_mel_len / 2;
337 1 : m_libspdm_get_measurement_extension_log_request2.length = LIBSPDM_MAX_MEL_BLOCK_LEN;
338 :
339 1 : response_size = sizeof(response);
340 1 : status = libspdm_get_response_measurement_extension_log(
341 : spdm_context, m_libspdm_get_measurement_extension_log_request2_size,
342 : &m_libspdm_get_measurement_extension_log_request2, &response_size, response);
343 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
344 :
345 1 : assert_int_equal(response_size,
346 : sizeof(spdm_measurement_extension_log_response_t) +
347 : spdm_mel_len / 2 + 1);
348 1 : spdm_response = (void *)response;
349 1 : assert_int_equal(spdm_response->header.request_response_code,
350 : SPDM_MEASUREMENT_EXTENSION_LOG);
351 1 : assert_int_equal(spdm_response->header.param1, 0);
352 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len / 2 + 1);
353 1 : assert_int_equal(spdm_response->remainder_length, 0);
354 1 : assert_memory_equal(spdm_response + 1, (void *)((uint8_t *)spdm_mel + spdm_mel_len / 2),
355 : response_size - sizeof(spdm_measurement_extension_log_response_t));
356 1 : }
357 :
358 1 : int libspdm_responder_measurement_extension_log_test_main(void)
359 : {
360 1 : const struct CMUnitTest spdm_responder_measurement_extension_log_tests[] = {
361 : /* Success Case*/
362 : cmocka_unit_test(libspdm_test_responder_measurement_extension_log_case1),
363 : /* Success Case, request.length < total MEL len*/
364 : cmocka_unit_test(libspdm_test_responder_measurement_extension_log_case2),
365 : /* Success Case, request.length > LIBSPDM_MAX_MEL_BLOCK_LEN*/
366 : cmocka_unit_test(libspdm_test_responder_measurement_extension_log_case3),
367 : /* failed Case, request.offset > total MEL len*/
368 : cmocka_unit_test(libspdm_test_responder_measurement_extension_log_case4),
369 : /* Success Case, request.offset < total MEL len*/
370 : cmocka_unit_test(libspdm_test_responder_measurement_extension_log_case5),
371 : };
372 :
373 1 : libspdm_test_context_t test_context = {
374 : LIBSPDM_TEST_CONTEXT_VERSION,
375 : false,
376 : };
377 :
378 1 : libspdm_setup_test_context(&test_context);
379 :
380 1 : return cmocka_run_group_tests(spdm_responder_measurement_extension_log_tests,
381 : libspdm_unit_test_group_setup,
382 : libspdm_unit_test_group_teardown);
383 : }
384 :
385 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP */
|
