Line data Source code
1 : /**
2 : * Copyright Notice:
3 : * Copyright 2025-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_requester_lib.h"
9 : #include "internal/libspdm_secured_message_lib.h"
10 :
11 : #if LIBSPDM_ENABLE_CAPABILITY_MEL_CAP
12 :
13 : #define LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE 0x1000
14 :
15 : static uint8_t m_libspdm_mel_test[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
16 : static size_t m_libspdm_mel_len;
17 : static uint8_t m_libspdm_mel_number;
18 :
19 4 : static void generate_mel_entry_test(void)
20 : {
21 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
22 : uint32_t mel_index;
23 : spdm_mel_entry_dmtf_t *mel_entry;
24 : size_t mel_entry_size;
25 4 : uint8_t rom_informational[] = "ROM";
26 :
27 : /*generate MEL*/
28 4 : libspdm_zero_mem(m_libspdm_mel_test, sizeof(m_libspdm_mel_test));
29 4 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
30 :
31 4 : measurement_extension_log->number_of_entries = 0;
32 4 : measurement_extension_log->mel_entries_len = 0;
33 4 : measurement_extension_log->reserved = 0;
34 :
35 4 : m_libspdm_mel_len = sizeof(spdm_measurement_extension_log_dmtf_t);
36 4 : mel_entry = (spdm_mel_entry_dmtf_t *)((uint8_t *)measurement_extension_log +
37 : sizeof(spdm_measurement_extension_log_dmtf_t));
38 :
39 4 : mel_index = 0;
40 4 : mel_entry_size = 0;
41 :
42 : while (1)
43 : {
44 1092 : if((m_libspdm_mel_len + sizeof(spdm_mel_entry_dmtf_t) + sizeof(rom_informational)) >
45 : sizeof(m_libspdm_mel_test)) {
46 4 : break;
47 : }
48 :
49 1088 : mel_entry->mel_index = mel_index;
50 1088 : mel_entry->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM;
51 :
52 1088 : libspdm_write_uint24(mel_entry->reserved, 0);
53 1088 : mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_type =
54 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_VERSION |
55 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM;
56 1088 : mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size =
57 : sizeof(rom_informational);
58 1088 : libspdm_copy_mem((void *)(mel_entry + 1), sizeof(rom_informational),
59 : rom_informational, sizeof(rom_informational));
60 :
61 1088 : mel_entry_size = (sizeof(spdm_mel_entry_dmtf_t) + sizeof(rom_informational));
62 1088 : m_libspdm_mel_len += mel_entry_size;
63 :
64 1088 : measurement_extension_log->number_of_entries = mel_index;
65 1088 : measurement_extension_log->mel_entries_len += (uint32_t)mel_entry_size;
66 1088 : measurement_extension_log->reserved = 0;
67 :
68 1088 : mel_entry = (spdm_mel_entry_dmtf_t *)
69 1088 : ((uint8_t *)mel_entry + sizeof(spdm_mel_entry_dmtf_t)+
70 1088 : mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size);
71 :
72 1088 : mel_index++;
73 : }
74 4 : }
75 :
76 : /*generate different long mel according to the m_libspdm_mel_number*/
77 7 : static void generate_long_mel(uint32_t measurement_hash_algo)
78 : {
79 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
80 : spdm_mel_entry_dmtf_t *mel_entry1;
81 : spdm_mel_entry_dmtf_t *mel_entry2;
82 : spdm_mel_entry_dmtf_t *mel_entry3;
83 : spdm_mel_entry_dmtf_t *mel_entry;
84 : uint8_t index;
85 :
86 7 : uint8_t rom_informational[] = "ROM";
87 7 : uint8_t bootfv_informational[] = "Boot FW";
88 7 : uint32_t version = 0x0100030A;
89 :
90 : /*generate MEL*/
91 7 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
92 :
93 7 : measurement_extension_log->number_of_entries = m_libspdm_mel_number;
94 7 : measurement_extension_log->mel_entries_len =
95 7 : measurement_extension_log->number_of_entries * sizeof(spdm_mel_entry_dmtf_t) +
96 7 : sizeof(rom_informational) - 1 + sizeof(bootfv_informational) - 1 +
97 7 : sizeof(version) * (m_libspdm_mel_number - 2);
98 7 : measurement_extension_log->reserved = 0;
99 :
100 : /*MEL Entry 1: informational ROM */
101 7 : mel_entry1 = (spdm_mel_entry_dmtf_t *)((uint8_t *)measurement_extension_log +
102 : sizeof(spdm_measurement_extension_log_dmtf_t));
103 7 : mel_entry1->mel_index = 1;
104 7 : mel_entry1->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM;
105 7 : libspdm_write_uint24(mel_entry1->reserved, 0);
106 7 : mel_entry1->measurement_block_dmtf_header.dmtf_spec_measurement_value_type =
107 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_INFORMATIONAL |
108 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM;
109 7 : mel_entry1->measurement_block_dmtf_header.dmtf_spec_measurement_value_size =
110 : sizeof(rom_informational) - 1;
111 7 : libspdm_copy_mem((void *)(mel_entry1 + 1), sizeof(rom_informational) - 1,
112 : rom_informational, sizeof(rom_informational) - 1);
113 :
114 : /*MEL Entry 2: informational Boot FW */
115 7 : mel_entry2 = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry1 + 1) +
116 : sizeof(rom_informational) - 1);
117 7 : mel_entry2->mel_index = 2;
118 7 : mel_entry2->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM;
119 7 : libspdm_write_uint24(mel_entry2->reserved, 0);
120 7 : mel_entry2->measurement_block_dmtf_header.dmtf_spec_measurement_value_type =
121 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_INFORMATIONAL |
122 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM;
123 7 : mel_entry2->measurement_block_dmtf_header.dmtf_spec_measurement_value_size =
124 : sizeof(bootfv_informational) - 1;
125 7 : libspdm_copy_mem((void *)(mel_entry2 + 1), sizeof(bootfv_informational) - 1,
126 : bootfv_informational, sizeof(bootfv_informational) - 1);
127 :
128 : /*MEL Entry 3: version 0x0100030A */
129 7 : mel_entry3 = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry2 + 1) +
130 : sizeof(bootfv_informational) - 1);
131 7 : mel_entry3->mel_index = 3;
132 7 : mel_entry3->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM;
133 7 : libspdm_write_uint24(mel_entry3->reserved, 0);
134 7 : mel_entry3->measurement_block_dmtf_header.dmtf_spec_measurement_value_type =
135 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_VERSION |
136 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM;
137 7 : mel_entry3->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = sizeof(version);
138 7 : libspdm_copy_mem((void *)(mel_entry3 + 1), sizeof(version), &version, sizeof(version));
139 :
140 : /*MEL Entry 4 -> m_libspdm_mel_number: version 0x0100030A */
141 7 : mel_entry = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry3 + 1) + sizeof(version));
142 694 : for (index = 4; index <= m_libspdm_mel_number; index++) {
143 687 : mel_entry->mel_index = index;
144 687 : mel_entry->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM;
145 687 : libspdm_write_uint24(mel_entry->reserved, 0);
146 687 : mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_type =
147 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_VERSION |
148 : SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM;
149 687 : mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = sizeof(version);
150 687 : libspdm_copy_mem((void *)(mel_entry + 1), sizeof(version), &version, sizeof(version));
151 687 : mel_entry = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry + 1) + sizeof(version));
152 : }
153 7 : }
154 :
155 15 : static libspdm_return_t send_message(
156 : void *spdm_context, size_t request_size, const void *request, uint64_t timeout)
157 : {
158 : libspdm_test_context_t *spdm_test_context;
159 :
160 15 : spdm_test_context = libspdm_get_test_context();
161 15 : switch (spdm_test_context->case_id) {
162 1 : case 0x1:
163 1 : return LIBSPDM_STATUS_SEND_FAIL;
164 14 : case 0x2:
165 : case 0x3:
166 : case 0x4:
167 : case 0x5:
168 : case 0x6:
169 : case 0x7:
170 : case 0x8:
171 : case 0x9:
172 14 : return LIBSPDM_STATUS_SUCCESS;
173 0 : default:
174 0 : return LIBSPDM_STATUS_SEND_FAIL;
175 : }
176 : }
177 :
178 14 : static libspdm_return_t receive_message(
179 : void *spdm_context, size_t *response_size, void **response, uint64_t timeout)
180 : {
181 : libspdm_test_context_t *spdm_test_context;
182 :
183 14 : spdm_test_context = libspdm_get_test_context();
184 14 : switch (spdm_test_context->case_id) {
185 0 : case 0x1:
186 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
187 :
188 1 : case 0x2: {
189 : spdm_measurement_extension_log_response_t *spdm_response;
190 : size_t spdm_response_size;
191 : size_t transport_header_size;
192 : uint32_t portion_length;
193 : uint32_t remainder_length;
194 : size_t count;
195 : static size_t calling_index = 0;
196 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
197 :
198 1 : spdm_mel = NULL;
199 1 : m_libspdm_mel_len = 0;
200 :
201 1 : libspdm_measurement_extension_log_collection(
202 : spdm_context,
203 : m_libspdm_use_mel_spec,
204 : m_libspdm_use_measurement_spec,
205 : m_libspdm_use_measurement_hash_algo,
206 : (void **)&spdm_mel, &m_libspdm_mel_len);
207 :
208 1 : count = (m_libspdm_mel_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
209 1 : if (calling_index != count - 1) {
210 0 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
211 0 : remainder_length =
212 0 : (uint32_t)(m_libspdm_mel_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
213 : } else {
214 1 : portion_length = (uint32_t)(
215 : m_libspdm_mel_len -
216 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
217 1 : remainder_length = 0;
218 : }
219 :
220 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
221 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
222 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
223 :
224 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
225 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
226 1 : spdm_response->header.param1 = 0;
227 1 : spdm_response->header.param2 = 0;
228 1 : spdm_response->portion_length = portion_length;
229 1 : spdm_response->remainder_length = remainder_length;
230 1 : libspdm_copy_mem(spdm_response + 1,
231 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
232 1 : (uint8_t *)spdm_mel +
233 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
234 : portion_length);
235 :
236 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
237 : false, spdm_response_size,
238 : spdm_response, response_size,
239 : response);
240 :
241 1 : calling_index++;
242 1 : if (calling_index == count) {
243 1 : calling_index = 0;
244 : }
245 : }
246 1 : return LIBSPDM_STATUS_SUCCESS;
247 1 : case 0x3: {
248 : spdm_measurement_extension_log_response_t *spdm_response;
249 : size_t spdm_response_size;
250 : size_t transport_header_size;
251 : uint32_t portion_length;
252 : uint32_t remainder_length;
253 : size_t count;
254 : static size_t calling_index = 0;
255 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
256 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
257 : size_t mel_new_len;
258 : size_t mel_send_len;
259 :
260 1 : spdm_mel = NULL;
261 1 : m_libspdm_mel_len = 0;
262 1 : mel_new_len = 0;
263 1 : mel_send_len = 0;
264 1 : m_libspdm_mel_number = 3;
265 :
266 1 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
267 :
268 1 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
269 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
270 1 : m_libspdm_mel_len = (size_t)(measurement_extension_log->mel_entries_len) +
271 : sizeof(spdm_measurement_extension_log_dmtf_t);
272 :
273 1 : if (calling_index == 1) {
274 0 : m_libspdm_mel_number = 4;
275 0 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
276 0 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
277 0 : mel_new_len = (size_t)(measurement_extension_log->mel_entries_len) +
278 : sizeof(spdm_measurement_extension_log_dmtf_t);
279 : }
280 :
281 1 : mel_send_len = (m_libspdm_mel_len > mel_new_len) ? m_libspdm_mel_len : mel_new_len;
282 :
283 1 : count = (mel_send_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
284 1 : if (calling_index != count - 1) {
285 0 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
286 0 : remainder_length =
287 0 : (uint32_t)(mel_send_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
288 : } else {
289 1 : portion_length = (uint32_t)(
290 : m_libspdm_mel_len -
291 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
292 1 : remainder_length = (uint32_t)(
293 1 : mel_send_len -
294 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1) -
295 : portion_length);
296 : }
297 :
298 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
299 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
300 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
301 :
302 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
303 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
304 1 : spdm_response->header.param1 = 0;
305 1 : spdm_response->header.param2 = 0;
306 1 : spdm_response->portion_length = portion_length;
307 1 : spdm_response->remainder_length = remainder_length;
308 1 : libspdm_copy_mem(spdm_response + 1,
309 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
310 : (uint8_t *)spdm_mel +
311 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
312 : portion_length);
313 :
314 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
315 : false, spdm_response_size,
316 : spdm_response, response_size,
317 : response);
318 :
319 1 : calling_index++;
320 1 : if (calling_index == count) {
321 1 : calling_index = 0;
322 : }
323 : }
324 1 : return LIBSPDM_STATUS_SUCCESS;
325 2 : case 0x4: {
326 : spdm_measurement_extension_log_response_t *spdm_response;
327 : size_t spdm_response_size;
328 : size_t transport_header_size;
329 : uint32_t portion_length;
330 : uint32_t remainder_length;
331 : size_t count;
332 : static size_t calling_index = 0;
333 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
334 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
335 : size_t mel_new_len;
336 : size_t mel_send_len;
337 :
338 2 : spdm_mel = NULL;
339 2 : m_libspdm_mel_len = 0;
340 2 : mel_new_len = 0;
341 2 : mel_send_len = 0;
342 2 : m_libspdm_mel_number = 100;
343 :
344 2 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
345 :
346 2 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
347 2 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
348 2 : m_libspdm_mel_len = (size_t)(measurement_extension_log->mel_entries_len) +
349 : sizeof(spdm_measurement_extension_log_dmtf_t);
350 :
351 2 : if (calling_index == 1) {
352 1 : m_libspdm_mel_number = 105;
353 1 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
354 1 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
355 1 : mel_new_len = (size_t)(measurement_extension_log->mel_entries_len) +
356 : sizeof(spdm_measurement_extension_log_dmtf_t);
357 : }
358 :
359 2 : mel_send_len = (m_libspdm_mel_len > mel_new_len) ? m_libspdm_mel_len : mel_new_len;
360 :
361 2 : count = (m_libspdm_mel_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
362 2 : if (calling_index != count - 1) {
363 1 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
364 1 : remainder_length =
365 1 : (uint32_t)(mel_send_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
366 : } else {
367 1 : portion_length = (uint32_t)(
368 : m_libspdm_mel_len -
369 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
370 1 : remainder_length = (uint32_t)(
371 1 : mel_send_len -
372 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1) -
373 : portion_length);
374 : }
375 :
376 2 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
377 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
378 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
379 :
380 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
381 2 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
382 2 : spdm_response->header.param1 = 0;
383 2 : spdm_response->header.param2 = 0;
384 2 : spdm_response->portion_length = portion_length;
385 2 : spdm_response->remainder_length = remainder_length;
386 2 : libspdm_copy_mem(spdm_response + 1,
387 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
388 : (uint8_t *)spdm_mel +
389 2 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
390 : portion_length);
391 :
392 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
393 : false, spdm_response_size,
394 : spdm_response, response_size,
395 : response);
396 :
397 2 : calling_index++;
398 2 : if (calling_index == count) {
399 1 : calling_index = 0;
400 : }
401 : }
402 2 : return LIBSPDM_STATUS_SUCCESS;
403 2 : case 0x5: {
404 : spdm_measurement_extension_log_response_t *spdm_response;
405 : size_t spdm_response_size;
406 : size_t transport_header_size;
407 : uint32_t portion_length;
408 : uint32_t remainder_length;
409 : size_t count;
410 : static size_t calling_index = 0;
411 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
412 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
413 : size_t mel_new_len;
414 : size_t mel_send_len;
415 :
416 2 : spdm_mel = NULL;
417 2 : m_libspdm_mel_len = 0;
418 2 : mel_new_len = 0;
419 2 : mel_send_len = 0;
420 2 : m_libspdm_mel_number = 100;
421 :
422 2 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
423 :
424 2 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
425 2 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
426 2 : m_libspdm_mel_len = (size_t)(measurement_extension_log->mel_entries_len) +
427 : sizeof(spdm_measurement_extension_log_dmtf_t);
428 :
429 2 : if (calling_index == 1) {
430 1 : m_libspdm_mel_number = 200;
431 1 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
432 1 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
433 1 : mel_new_len = (size_t)(measurement_extension_log->mel_entries_len) +
434 : sizeof(spdm_measurement_extension_log_dmtf_t);
435 : }
436 :
437 2 : mel_send_len = (m_libspdm_mel_len > mel_new_len) ? m_libspdm_mel_len : mel_new_len;
438 :
439 2 : count = (m_libspdm_mel_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
440 2 : if (calling_index != count - 1) {
441 1 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
442 1 : remainder_length =
443 1 : (uint32_t)(mel_send_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
444 : } else {
445 1 : portion_length = (uint32_t)(
446 : m_libspdm_mel_len -
447 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
448 1 : remainder_length = (uint32_t)(
449 1 : mel_send_len -
450 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1) -
451 : portion_length);
452 : }
453 :
454 2 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
455 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
456 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
457 :
458 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
459 2 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
460 2 : spdm_response->header.param1 = 0;
461 2 : spdm_response->header.param2 = 0;
462 2 : spdm_response->portion_length = portion_length;
463 2 : spdm_response->remainder_length = remainder_length;
464 2 : libspdm_copy_mem(spdm_response + 1,
465 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
466 : (uint8_t *)spdm_mel +
467 2 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
468 : portion_length);
469 :
470 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
471 : false, spdm_response_size,
472 : spdm_response, response_size,
473 : response);
474 :
475 2 : calling_index++;
476 2 : if (calling_index == count) {
477 1 : calling_index = 0;
478 : }
479 : }
480 2 : return LIBSPDM_STATUS_SUCCESS;
481 4 : case 0x6:
482 : {
483 : spdm_measurement_extension_log_response_t *spdm_response;
484 : size_t spdm_response_size;
485 : size_t transport_header_size;
486 : uint32_t portion_length;
487 : uint32_t remainder_length;
488 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
489 :
490 : static size_t count = 0;
491 : static size_t calling_index = 0;
492 :
493 4 : if (calling_index == 0) {
494 1 : count = (m_libspdm_mel_len / LIBSPDM_MAX_MEL_BLOCK_LEN) + 1;
495 : }
496 :
497 4 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
498 :
499 4 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
500 4 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
501 :
502 4 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
503 4 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
504 4 : spdm_response->header.param1 = 0;
505 4 : spdm_response->header.param2 = 0;
506 :
507 4 : if(m_libspdm_mel_len > LIBSPDM_MAX_MEL_BLOCK_LEN) {
508 3 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
509 3 : remainder_length = (uint32_t)(m_libspdm_mel_len - LIBSPDM_MAX_MEL_BLOCK_LEN);
510 : } else {
511 1 : portion_length = (uint32_t)m_libspdm_mel_len;
512 1 : remainder_length = 0;
513 : }
514 :
515 4 : spdm_response->portion_length = portion_length;
516 4 : spdm_response->remainder_length = remainder_length;
517 :
518 4 : libspdm_copy_mem(spdm_response + 1,
519 4 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
520 : (uint8_t *)spdm_mel +
521 4 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
522 : portion_length);
523 :
524 4 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
525 :
526 4 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
527 : false, spdm_response_size,
528 : spdm_response, response_size,
529 : response);
530 :
531 4 : m_libspdm_mel_len -= portion_length;
532 4 : calling_index++;
533 :
534 4 : if (calling_index == count) {
535 0 : calling_index = 0;
536 0 : m_libspdm_mel_len = 0;
537 : }
538 : }
539 4 : return LIBSPDM_STATUS_SUCCESS;
540 :
541 2 : case 0x7:
542 : {
543 : spdm_measurement_extension_log_response_t *spdm_response;
544 : size_t spdm_response_size;
545 : size_t transport_header_size;
546 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
547 :
548 : static size_t calling_index = 0;
549 :
550 2 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
551 :
552 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
553 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
554 :
555 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
556 2 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
557 2 : spdm_response->header.param1 = 0;
558 2 : spdm_response->header.param2 = 0;
559 2 : if (calling_index == 0) {
560 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
561 1 : spdm_response->remainder_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
562 : } else {
563 : /* The total amount of messages actually sent by the responder is less than the negotiated total mel len*/
564 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN / 2;
565 1 : spdm_response->remainder_length = 0;
566 : }
567 :
568 2 : libspdm_copy_mem(spdm_response + 1,
569 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
570 : (uint8_t *)spdm_mel,
571 : LIBSPDM_MAX_MEL_BLOCK_LEN);
572 :
573 2 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
574 : LIBSPDM_MAX_MEL_BLOCK_LEN;
575 :
576 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
577 : false, spdm_response_size,
578 : spdm_response, response_size,
579 : response);
580 2 : calling_index++;
581 : }
582 2 : return LIBSPDM_STATUS_SUCCESS;
583 1 : case 0x8:
584 : {
585 : spdm_measurement_extension_log_response_t *spdm_response;
586 : size_t spdm_response_size;
587 : size_t transport_header_size;
588 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
589 :
590 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
591 :
592 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
593 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
594 :
595 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
596 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
597 1 : spdm_response->header.param1 = 0;
598 1 : spdm_response->header.param2 = 0;
599 : /* Portion_length is greater than the LIBSPDM_MAX_MEL_BLOCK_LEN */
600 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN + 1;
601 1 : spdm_response->remainder_length = 0;
602 :
603 1 : libspdm_copy_mem(spdm_response + 1,
604 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
605 : (uint8_t *)spdm_mel,
606 : LIBSPDM_MAX_MEL_BLOCK_LEN);
607 :
608 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
609 : LIBSPDM_MAX_MEL_BLOCK_LEN;
610 :
611 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
612 : false, spdm_response_size,
613 : spdm_response, response_size,
614 : response);
615 : }
616 1 : return LIBSPDM_STATUS_SUCCESS;
617 :
618 1 : case 0x9:
619 : {
620 : spdm_measurement_extension_log_response_t *spdm_response;
621 : size_t spdm_response_size;
622 : size_t transport_header_size;
623 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
624 :
625 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
626 :
627 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
628 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
629 :
630 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
631 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
632 1 : spdm_response->header.param1 = 0;
633 1 : spdm_response->header.param2 = 0;
634 : /* The total MEL length is larger than SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE*/
635 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
636 1 : spdm_response->remainder_length = SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE;
637 :
638 1 : libspdm_copy_mem(spdm_response + 1,
639 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
640 : (uint8_t *)spdm_mel,
641 : LIBSPDM_MAX_MEL_BLOCK_LEN);
642 :
643 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
644 : LIBSPDM_MAX_MEL_BLOCK_LEN;
645 :
646 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
647 : false, spdm_response_size,
648 : spdm_response, response_size,
649 : response);
650 : }
651 1 : return LIBSPDM_STATUS_SUCCESS;
652 :
653 0 : default:
654 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
655 : }
656 : }
657 :
658 : /**
659 : * Test 1: message could not be sent
660 : * Expected Behavior: get a LIBSPDM_STATUS_SEND_FAIL, with no MEL messages received
661 : **/
662 1 : static void req_get_measurement_extension_log_case1(void **state)
663 : {
664 : libspdm_return_t status;
665 : libspdm_test_context_t *spdm_test_context;
666 : libspdm_context_t *spdm_context;
667 : size_t spdm_mel_size;
668 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
669 :
670 1 : spdm_test_context = *state;
671 1 : spdm_context = spdm_test_context->spdm_context;
672 1 : spdm_test_context->case_id = 0x1;
673 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
674 : SPDM_VERSION_NUMBER_SHIFT_BIT;
675 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
676 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
677 :
678 1 : libspdm_reset_message_b(spdm_context);
679 :
680 1 : spdm_mel_size = sizeof(spdm_mel);
681 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
682 :
683 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
684 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
685 : m_libspdm_use_measurement_hash_algo;
686 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
687 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
688 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
689 :
690 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
691 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
692 1 : }
693 :
694 : /**
695 : * Test 2: Normal case, request a MEL, the MEL size remains unchanged
696 : * Expected Behavior: receives a valid MEL
697 : **/
698 1 : static void req_get_measurement_extension_log_case2(void **state)
699 : {
700 : libspdm_return_t status;
701 : libspdm_test_context_t *spdm_test_context;
702 : libspdm_context_t *spdm_context;
703 : size_t spdm_mel_size;
704 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
705 :
706 1 : spdm_test_context = *state;
707 1 : spdm_context = spdm_test_context->spdm_context;
708 1 : spdm_test_context->case_id = 0x2;
709 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
710 : SPDM_VERSION_NUMBER_SHIFT_BIT;
711 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
712 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
713 :
714 1 : libspdm_reset_message_b(spdm_context);
715 1 : spdm_mel_size = sizeof(spdm_mel);
716 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
717 :
718 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
719 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
720 : m_libspdm_use_measurement_hash_algo;
721 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
722 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
723 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
724 :
725 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
726 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
727 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
728 1 : }
729 :
730 : /**
731 : * Test 3: Normal case, request a MEL, the MEL size become more bigger when get MEL
732 : * The original MEL number is 3, the new MEL number is 4.
733 : * Expected Behavior: receives a valid MEL, and the MEL size is same with the before MEL size.
734 : **/
735 1 : static void req_get_measurement_extension_log_case3(void **state)
736 : {
737 : libspdm_return_t status;
738 : libspdm_test_context_t *spdm_test_context;
739 : libspdm_context_t *spdm_context;
740 : size_t spdm_mel_size;
741 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
742 :
743 1 : spdm_test_context = *state;
744 1 : spdm_context = spdm_test_context->spdm_context;
745 :
746 1 : spdm_test_context->case_id = 0x3;
747 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
748 : SPDM_VERSION_NUMBER_SHIFT_BIT;
749 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
750 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
751 :
752 1 : libspdm_reset_message_b(spdm_context);
753 1 : spdm_mel_size = sizeof(spdm_mel);
754 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
755 :
756 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
757 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
758 : m_libspdm_use_measurement_hash_algo;
759 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
760 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
761 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
762 :
763 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
764 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
765 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
766 1 : }
767 :
768 : /**
769 : * Test 4: Normal case, request a MEL, the MEL size become more bigger when get MEL
770 : * The original MEL number is 100, the new MEL number is 105.
771 : * Expected Behavior: receives a valid MEL, and the MEL size is same with the before MEL size.
772 : **/
773 1 : static void req_get_measurement_extension_log_case4(void **state)
774 : {
775 : libspdm_return_t status;
776 : libspdm_test_context_t *spdm_test_context;
777 : libspdm_context_t *spdm_context;
778 : size_t spdm_mel_size;
779 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
780 :
781 1 : spdm_test_context = *state;
782 1 : spdm_context = spdm_test_context->spdm_context;
783 1 : spdm_test_context->case_id = 0x4;
784 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
785 : SPDM_VERSION_NUMBER_SHIFT_BIT;
786 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
787 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
788 :
789 1 : libspdm_reset_message_b(spdm_context);
790 1 : spdm_mel_size = sizeof(spdm_mel);
791 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
792 :
793 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
794 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
795 : m_libspdm_use_measurement_hash_algo;
796 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
797 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
798 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
799 :
800 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
801 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
802 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
803 1 : }
804 :
805 : /**
806 : * Test 5: Normal case, request a MEL, the MEL size become more bigger when get MEL
807 : * The original MEL number is 100, the new MEL number is 200.
808 : * Expected Behavior: receives a valid MEL, and the MEL size is same with the before MEL size.
809 : **/
810 1 : static void req_get_measurement_extension_log_case5(void **state)
811 : {
812 : libspdm_return_t status;
813 : libspdm_test_context_t *spdm_test_context;
814 : libspdm_context_t *spdm_context;
815 : size_t spdm_mel_size;
816 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
817 :
818 1 : spdm_test_context = *state;
819 1 : spdm_context = spdm_test_context->spdm_context;
820 1 : spdm_test_context->case_id = 0x5;
821 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
822 : SPDM_VERSION_NUMBER_SHIFT_BIT;
823 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
824 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
825 :
826 1 : libspdm_reset_message_b(spdm_context);
827 1 : spdm_mel_size = sizeof(spdm_mel);
828 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
829 :
830 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
831 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
832 : m_libspdm_use_measurement_hash_algo;
833 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
834 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
835 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
836 :
837 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
838 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
839 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
840 1 : }
841 :
842 : /**
843 : * Test 6: Normal case, request a LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE MEL
844 : * Expected Behavior: receives a valid MEL
845 : **/
846 1 : static void req_get_measurement_extension_log_case6(void **state)
847 : {
848 : libspdm_return_t status;
849 : libspdm_test_context_t *spdm_test_context;
850 : libspdm_context_t *spdm_context;
851 : size_t spdm_mel_size;
852 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
853 : size_t mel_buffer_size;
854 :
855 1 : spdm_test_context = *state;
856 1 : spdm_context = spdm_test_context->spdm_context;
857 1 : spdm_test_context->case_id = 0x6;
858 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
859 : SPDM_VERSION_NUMBER_SHIFT_BIT;
860 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
861 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
862 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
863 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
864 : m_libspdm_use_measurement_hash_algo;
865 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
866 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
867 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
868 :
869 1 : libspdm_reset_message_b(spdm_context);
870 1 : spdm_mel_size = sizeof(spdm_mel);
871 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
872 :
873 1 : generate_mel_entry_test();
874 1 : mel_buffer_size = m_libspdm_mel_len;
875 :
876 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
877 :
878 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
879 1 : assert_int_equal(spdm_mel_size, mel_buffer_size);
880 1 : assert_memory_equal(m_libspdm_mel_test, (void *)spdm_mel, spdm_mel_size);
881 1 : }
882 :
883 : /**
884 : * Test 7: The total amount of messages actually sent by the responder is less than the negotiated total mel len.
885 : * Expected Behavior: returns with status LIBSPDM_STATUS_INVALID_MSG_FIELD.
886 : **/
887 1 : static void req_get_measurement_extension_log_case7(void **state)
888 : {
889 : libspdm_return_t status;
890 : libspdm_test_context_t *spdm_test_context;
891 : libspdm_context_t *spdm_context;
892 : size_t spdm_mel_size;
893 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
894 :
895 1 : spdm_test_context = *state;
896 1 : spdm_context = spdm_test_context->spdm_context;
897 1 : spdm_test_context->case_id = 0x7;
898 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
899 : SPDM_VERSION_NUMBER_SHIFT_BIT;
900 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
901 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
902 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
903 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
904 : m_libspdm_use_measurement_hash_algo;
905 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
906 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
907 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
908 :
909 1 : libspdm_reset_message_b(spdm_context);
910 1 : spdm_mel_size = sizeof(spdm_mel);
911 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
912 :
913 1 : generate_mel_entry_test();
914 :
915 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
916 :
917 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
918 1 : }
919 :
920 : /**
921 : * Test 8: Portion_length is greater than the LIBSPDM_MAX_MEL_BLOCK_LEN
922 : * Expected Behavior: returns with status LIBSPDM_STATUS_INVALID_MSG_FIELD.
923 : **/
924 1 : static void req_get_measurement_extension_log_case8(void **state)
925 : {
926 : libspdm_return_t status;
927 : libspdm_test_context_t *spdm_test_context;
928 : libspdm_context_t *spdm_context;
929 : size_t spdm_mel_size;
930 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
931 : uint32_t original_max_spdm_msg_size;
932 :
933 1 : spdm_test_context = *state;
934 1 : spdm_context = spdm_test_context->spdm_context;
935 1 : spdm_test_context->case_id = 0x8;
936 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
937 : SPDM_VERSION_NUMBER_SHIFT_BIT;
938 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
939 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
940 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
941 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
942 : m_libspdm_use_measurement_hash_algo;
943 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
944 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
945 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
946 1 : original_max_spdm_msg_size = spdm_context->local_context.capability.max_spdm_msg_size;
947 1 : spdm_context->local_context.capability.max_spdm_msg_size =
948 : LIBSPDM_MAX_MEL_BLOCK_LEN +
949 : sizeof(spdm_measurement_extension_log_response_t);
950 :
951 1 : libspdm_reset_message_b(spdm_context);
952 1 : spdm_mel_size = sizeof(spdm_mel);
953 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
954 :
955 1 : generate_mel_entry_test();
956 :
957 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
958 :
959 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
960 1 : spdm_context->local_context.capability.max_spdm_msg_size = original_max_spdm_msg_size;
961 1 : }
962 :
963 : /**
964 : * Test 9: The total MEL length is larger than SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE
965 : * Expected Behavior: returns with status LIBSPDM_STATUS_INVALID_MSG_FIELD.
966 : **/
967 1 : static void req_get_measurement_extension_log_case9(void **state)
968 : {
969 : libspdm_return_t status;
970 : libspdm_test_context_t *spdm_test_context;
971 : libspdm_context_t *spdm_context;
972 : size_t spdm_mel_size;
973 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
974 :
975 1 : spdm_test_context = *state;
976 1 : spdm_context = spdm_test_context->spdm_context;
977 1 : spdm_test_context->case_id = 0x9;
978 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
979 : SPDM_VERSION_NUMBER_SHIFT_BIT;
980 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
981 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
982 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
983 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
984 : m_libspdm_use_measurement_hash_algo;
985 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
986 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
987 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
988 :
989 1 : libspdm_reset_message_b(spdm_context);
990 1 : spdm_mel_size = sizeof(spdm_mel);
991 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
992 :
993 1 : generate_mel_entry_test();
994 :
995 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
996 :
997 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
998 1 : }
999 :
1000 1 : int libspdm_req_get_measurement_extension_log_test(void)
1001 : {
1002 1 : const struct CMUnitTest test_cases[] = {
1003 : /* SendRequest failed*/
1004 : cmocka_unit_test(req_get_measurement_extension_log_case1),
1005 : /* Successful response, the MEL size remains unchanged*/
1006 : cmocka_unit_test(req_get_measurement_extension_log_case2),
1007 : /* Successful response, the MEL size become more bigger when get MEL. MEL number change from 3 to 4*/
1008 : cmocka_unit_test(req_get_measurement_extension_log_case3),
1009 : /* Successful response, the MEL size become more bigger when get MEL. MEL number change from 100 to 105*/
1010 : cmocka_unit_test(req_get_measurement_extension_log_case4),
1011 : /* Successful response, the MEL size become more bigger when get MEL. MEL number change from 100 to 200*/
1012 : cmocka_unit_test(req_get_measurement_extension_log_case5),
1013 : /* Successful response , LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE*/
1014 : cmocka_unit_test(req_get_measurement_extension_log_case6),
1015 : /* Failed response , The total amount of messages actually sent by the responder is less than the negotiated total mel len*/
1016 : cmocka_unit_test(req_get_measurement_extension_log_case7),
1017 : /* Failed response , Portion_length is greater than the LIBSPDM_MAX_MEL_BLOCK_LEN*/
1018 : cmocka_unit_test(req_get_measurement_extension_log_case8),
1019 : /* Failed response , The total MEL length is larger than SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE*/
1020 : cmocka_unit_test(req_get_measurement_extension_log_case9),
1021 :
1022 : };
1023 :
1024 1 : libspdm_test_context_t test_context = {
1025 : LIBSPDM_TEST_CONTEXT_VERSION,
1026 : true,
1027 : send_message,
1028 : receive_message,
1029 : };
1030 :
1031 1 : libspdm_setup_test_context(&test_context);
1032 :
1033 1 : return cmocka_run_group_tests(test_cases,
1034 : libspdm_unit_test_group_setup,
1035 : libspdm_unit_test_group_teardown);
1036 : }
1037 :
1038 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP */
|
