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 :
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 : static void rsp_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 = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
65 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
66 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
67 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
68 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
69 1 : spdm_context->connection_info.algorithm.mel_spec = m_libspdm_use_mel_spec;
70 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
71 : m_libspdm_use_measurement_hash_algo;
72 :
73 1 : response_size = sizeof(response);
74 1 : status = libspdm_get_response_measurement_extension_log(
75 : spdm_context, m_libspdm_get_measurement_extension_log_request1_size,
76 : &m_libspdm_get_measurement_extension_log_request1, &response_size, response);
77 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
78 :
79 1 : spdm_mel = NULL;
80 1 : spdm_mel_len = 0;
81 1 : libspdm_measurement_extension_log_collection(
82 : spdm_context,
83 : m_libspdm_use_mel_spec,
84 : m_libspdm_use_measurement_spec,
85 : m_libspdm_use_measurement_hash_algo,
86 : (void **)&spdm_mel, &spdm_mel_len);
87 :
88 1 : assert_int_equal(response_size,
89 : sizeof(spdm_measurement_extension_log_response_t) +
90 : spdm_mel_len);
91 1 : spdm_response = (void *)response;
92 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENT_EXTENSION_LOG);
93 1 : assert_int_equal(spdm_response->header.param1, 0);
94 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len);
95 1 : assert_int_equal(spdm_response->remainder_length, 0);
96 1 : assert_memory_equal(spdm_response + 1, spdm_mel, spdm_mel_len);
97 1 : }
98 :
99 : /**
100 : * Test 2: request.length is less than the MEL len
101 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
102 : **/
103 1 : static void rsp_measurement_extension_log_case2(void **state)
104 : {
105 : libspdm_return_t status;
106 : libspdm_test_context_t *spdm_test_context;
107 : libspdm_context_t *spdm_context;
108 : size_t response_size;
109 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
110 : spdm_measurement_extension_log_response_t *spdm_response;
111 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
112 : size_t spdm_mel_len;
113 :
114 1 : spdm_test_context = *state;
115 1 : spdm_context = spdm_test_context->spdm_context;
116 1 : spdm_test_context->case_id = 0x2;
117 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
118 : SPDM_VERSION_NUMBER_SHIFT_BIT;
119 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
120 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
121 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
122 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
123 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
124 1 : spdm_context->connection_info.algorithm.mel_spec = m_libspdm_use_mel_spec;
125 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
126 : m_libspdm_use_measurement_hash_algo;
127 :
128 1 : spdm_mel = NULL;
129 1 : spdm_mel_len = 0;
130 1 : libspdm_measurement_extension_log_collection(spdm_context,
131 : m_libspdm_use_mel_spec,
132 : m_libspdm_use_measurement_spec,
133 : m_libspdm_use_measurement_hash_algo,
134 : (void **)&spdm_mel, &spdm_mel_len);
135 :
136 : /* Test the validity of the request.length.*/
137 1 : m_libspdm_get_measurement_extension_log_request2.length = (uint32_t)spdm_mel_len / 2;
138 :
139 1 : response_size = sizeof(response);
140 1 : status = libspdm_get_response_measurement_extension_log(
141 : spdm_context, m_libspdm_get_measurement_extension_log_request2_size,
142 : &m_libspdm_get_measurement_extension_log_request2, &response_size, response);
143 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
144 :
145 1 : assert_int_equal(response_size,
146 : sizeof(spdm_measurement_extension_log_response_t) +
147 : spdm_mel_len / 2);
148 1 : spdm_response = (void *)response;
149 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENT_EXTENSION_LOG);
150 1 : assert_int_equal(spdm_response->header.param1, 0);
151 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len / 2);
152 1 : assert_int_equal(spdm_response->remainder_length, spdm_mel_len / 2 + 1);
153 1 : assert_memory_equal(spdm_response + 1, (void *)spdm_mel,
154 : response_size - sizeof(spdm_measurement_extension_log_response_t));
155 1 : }
156 :
157 : /**
158 : * Test 3: When the request.length is greater than LIBSPDM_MAX_MEL_BLOCK_LEN.
159 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
160 : **/
161 1 : static void rsp_measurement_extension_log_case3(void **state)
162 : {
163 : libspdm_return_t status;
164 : libspdm_test_context_t *spdm_test_context;
165 : libspdm_context_t *spdm_context;
166 : size_t response_size;
167 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
168 : spdm_measurement_extension_log_response_t *spdm_response;
169 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
170 : size_t spdm_mel_len;
171 :
172 1 : spdm_test_context = *state;
173 1 : spdm_context = spdm_test_context->spdm_context;
174 1 : spdm_test_context->case_id = 0x3;
175 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
176 : SPDM_VERSION_NUMBER_SHIFT_BIT;
177 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
178 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
179 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
180 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
181 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
182 1 : spdm_context->connection_info.algorithm.mel_spec = m_libspdm_use_mel_spec;
183 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
184 : m_libspdm_use_measurement_hash_algo;
185 :
186 1 : response_size = sizeof(response);
187 1 : status = libspdm_get_response_measurement_extension_log(
188 : spdm_context, m_libspdm_get_measurement_extension_log_request3_size,
189 : &m_libspdm_get_measurement_extension_log_request3, &response_size, response);
190 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
191 :
192 1 : spdm_mel = NULL;
193 1 : spdm_mel_len = 0;
194 1 : libspdm_measurement_extension_log_collection(spdm_context,
195 : m_libspdm_use_mel_spec,
196 : m_libspdm_use_measurement_spec,
197 : m_libspdm_use_measurement_hash_algo,
198 : (void **)&spdm_mel, &spdm_mel_len);
199 :
200 1 : assert_int_equal(response_size,
201 : sizeof(spdm_measurement_extension_log_response_t) +
202 : spdm_mel_len);
203 1 : spdm_response = (void *)response;
204 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENT_EXTENSION_LOG);
205 1 : assert_int_equal(spdm_response->header.param1, 0);
206 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len);
207 1 : assert_int_equal(spdm_response->remainder_length, 0);
208 1 : assert_memory_equal(spdm_response + 1, (void *)spdm_mel,
209 : response_size - sizeof(spdm_measurement_extension_log_response_t));
210 1 : }
211 :
212 : /**
213 : * Test 4: request.offset > spdm mel len , wrong request message
214 : * Expected Behavior: Generate error response message
215 : **/
216 1 : static void rsp_measurement_extension_log_case4(void **state)
217 : {
218 : libspdm_return_t status;
219 : libspdm_test_context_t *spdm_test_context;
220 : libspdm_context_t *spdm_context;
221 : size_t response_size;
222 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
223 : spdm_measurement_extension_log_response_t *spdm_response;
224 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
225 : size_t spdm_mel_len;
226 :
227 1 : spdm_test_context = *state;
228 1 : spdm_context = spdm_test_context->spdm_context;
229 1 : spdm_test_context->case_id = 0x4;
230 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
231 : SPDM_VERSION_NUMBER_SHIFT_BIT;
232 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
233 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
234 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
235 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
236 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
237 1 : spdm_context->connection_info.algorithm.mel_spec = m_libspdm_use_mel_spec;
238 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
239 : m_libspdm_use_measurement_hash_algo;
240 :
241 1 : spdm_mel = NULL;
242 1 : spdm_mel_len = 0;
243 1 : libspdm_measurement_extension_log_collection(spdm_context,
244 : m_libspdm_use_mel_spec,
245 : m_libspdm_use_measurement_spec,
246 : m_libspdm_use_measurement_hash_algo,
247 : (void **)&spdm_mel, &spdm_mel_len);
248 : /* request.offset > total MEL len*/
249 1 : m_libspdm_get_measurement_extension_log_request4.offset = (uint32_t)spdm_mel_len +
250 : LIBSPDM_MAX_MEL_BLOCK_LEN;
251 :
252 1 : response_size = sizeof(response);
253 1 : status = libspdm_get_response_measurement_extension_log(
254 : spdm_context, m_libspdm_get_measurement_extension_log_request4_size,
255 : &m_libspdm_get_measurement_extension_log_request4, &response_size, response);
256 :
257 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
258 1 : assert_int_equal(response_size, sizeof(spdm_error_response_t));
259 1 : spdm_response = (void *)response;
260 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_ERROR);
261 1 : assert_int_equal(spdm_response->header.param1, SPDM_ERROR_CODE_INVALID_REQUEST);
262 1 : assert_int_equal(spdm_response->header.param2, 0);
263 1 : }
264 :
265 : /**
266 : * Test 5: A correct and not zero request.offset.
267 : * Expected Behavior: generate a correctly formed MEL message, including its portion_length and remainder_length fields
268 : **/
269 1 : static void rsp_measurement_extension_log_case5(void **state)
270 : {
271 : libspdm_return_t status;
272 : libspdm_test_context_t *spdm_test_context;
273 : libspdm_context_t *spdm_context;
274 : size_t response_size;
275 : uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
276 : spdm_measurement_extension_log_response_t *spdm_response;
277 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
278 : size_t spdm_mel_len;
279 :
280 1 : spdm_test_context = *state;
281 1 : spdm_context = spdm_test_context->spdm_context;
282 1 : spdm_test_context->case_id = 0x5;
283 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
284 : SPDM_VERSION_NUMBER_SHIFT_BIT;
285 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
286 1 : spdm_context->local_context.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
287 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
288 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
289 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
290 1 : spdm_context->connection_info.algorithm.mel_spec = m_libspdm_use_mel_spec;
291 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
292 : m_libspdm_use_measurement_hash_algo;
293 :
294 1 : spdm_mel = NULL;
295 1 : spdm_mel_len = 0;
296 1 : libspdm_measurement_extension_log_collection(spdm_context,
297 : m_libspdm_use_mel_spec,
298 : m_libspdm_use_measurement_spec,
299 : m_libspdm_use_measurement_hash_algo,
300 : (void **)&spdm_mel, &spdm_mel_len);
301 :
302 : /* Test the validity of the request.offset.*/
303 1 : m_libspdm_get_measurement_extension_log_request2.offset = (uint32_t)spdm_mel_len / 2;
304 1 : m_libspdm_get_measurement_extension_log_request2.length = LIBSPDM_MAX_MEL_BLOCK_LEN;
305 :
306 1 : response_size = sizeof(response);
307 1 : status = libspdm_get_response_measurement_extension_log(
308 : spdm_context, m_libspdm_get_measurement_extension_log_request2_size,
309 : &m_libspdm_get_measurement_extension_log_request2, &response_size, response);
310 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
311 :
312 1 : assert_int_equal(response_size,
313 : sizeof(spdm_measurement_extension_log_response_t) +
314 : spdm_mel_len / 2 + 1);
315 1 : spdm_response = (void *)response;
316 1 : assert_int_equal(spdm_response->header.request_response_code, SPDM_MEASUREMENT_EXTENSION_LOG);
317 1 : assert_int_equal(spdm_response->header.param1, 0);
318 1 : assert_int_equal(spdm_response->portion_length, spdm_mel_len / 2 + 1);
319 1 : assert_int_equal(spdm_response->remainder_length, 0);
320 1 : assert_memory_equal(spdm_response + 1, (void *)((uint8_t *)spdm_mel + spdm_mel_len / 2),
321 : response_size - sizeof(spdm_measurement_extension_log_response_t));
322 1 : }
323 :
324 1 : int libspdm_rsp_measurement_extension_log_test(void)
325 : {
326 1 : const struct CMUnitTest test_cases[] = {
327 : /* Success Case*/
328 : cmocka_unit_test(rsp_measurement_extension_log_case1),
329 : /* Success Case, request.length < total MEL len*/
330 : cmocka_unit_test(rsp_measurement_extension_log_case2),
331 : /* Success Case, request.length > LIBSPDM_MAX_MEL_BLOCK_LEN*/
332 : cmocka_unit_test(rsp_measurement_extension_log_case3),
333 : /* failed Case, request.offset > total MEL len*/
334 : cmocka_unit_test(rsp_measurement_extension_log_case4),
335 : /* Success Case, request.offset < total MEL len*/
336 : cmocka_unit_test(rsp_measurement_extension_log_case5),
337 : };
338 :
339 1 : libspdm_test_context_t test_context = {
340 : LIBSPDM_TEST_CONTEXT_VERSION,
341 : false,
342 : };
343 :
344 1 : libspdm_setup_test_context(&test_context);
345 :
346 1 : return cmocka_run_group_tests(test_cases,
347 : libspdm_unit_test_group_setup,
348 : libspdm_unit_test_group_teardown);
349 : }
350 :
351 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP */
|
