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 16 : 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 16 : spdm_test_context = libspdm_get_test_context();
161 16 : switch (spdm_test_context->case_id) {
162 1 : case 0x1:
163 1 : return LIBSPDM_STATUS_SEND_FAIL;
164 15 : case 0x2:
165 : case 0x3:
166 : case 0x4:
167 : case 0x5:
168 : case 0x6:
169 : case 0x7:
170 : case 0x8:
171 : case 0x9:
172 : case 0xA:
173 15 : return LIBSPDM_STATUS_SUCCESS;
174 0 : default:
175 0 : return LIBSPDM_STATUS_SEND_FAIL;
176 : }
177 : }
178 :
179 15 : static libspdm_return_t receive_message(
180 : void *spdm_context, size_t *response_size, void **response, uint64_t timeout)
181 : {
182 : libspdm_test_context_t *spdm_test_context;
183 :
184 15 : spdm_test_context = libspdm_get_test_context();
185 15 : switch (spdm_test_context->case_id) {
186 0 : case 0x1:
187 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
188 :
189 1 : case 0x2: {
190 : spdm_measurement_extension_log_response_t *spdm_response;
191 : size_t spdm_response_size;
192 : size_t transport_header_size;
193 : uint32_t portion_length;
194 : uint32_t remainder_length;
195 : size_t count;
196 : static size_t calling_index = 0;
197 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
198 :
199 1 : spdm_mel = NULL;
200 1 : m_libspdm_mel_len = 0;
201 :
202 1 : libspdm_measurement_extension_log_collection(
203 : spdm_context,
204 : m_libspdm_use_mel_spec,
205 : m_libspdm_use_measurement_spec,
206 : m_libspdm_use_measurement_hash_algo,
207 : (void **)&spdm_mel, &m_libspdm_mel_len);
208 :
209 1 : count = (m_libspdm_mel_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
210 1 : if (calling_index != count - 1) {
211 0 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
212 0 : remainder_length =
213 0 : (uint32_t)(m_libspdm_mel_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
214 : } else {
215 1 : portion_length = (uint32_t)(
216 : m_libspdm_mel_len -
217 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
218 1 : remainder_length = 0;
219 : }
220 :
221 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
222 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
223 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
224 :
225 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
226 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
227 1 : spdm_response->header.param1 = 0;
228 1 : spdm_response->header.param2 = 0;
229 1 : spdm_response->portion_length = portion_length;
230 1 : spdm_response->remainder_length = remainder_length;
231 1 : libspdm_copy_mem(spdm_response + 1,
232 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
233 1 : (uint8_t *)spdm_mel +
234 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
235 : portion_length);
236 :
237 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
238 : false, spdm_response_size,
239 : spdm_response, response_size,
240 : response);
241 :
242 1 : calling_index++;
243 1 : if (calling_index == count) {
244 1 : calling_index = 0;
245 : }
246 : }
247 1 : return LIBSPDM_STATUS_SUCCESS;
248 1 : case 0x3: {
249 : spdm_measurement_extension_log_response_t *spdm_response;
250 : size_t spdm_response_size;
251 : size_t transport_header_size;
252 : uint32_t portion_length;
253 : uint32_t remainder_length;
254 : size_t count;
255 : static size_t calling_index = 0;
256 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
257 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
258 : size_t mel_new_len;
259 : size_t mel_send_len;
260 :
261 1 : spdm_mel = NULL;
262 1 : m_libspdm_mel_len = 0;
263 1 : mel_new_len = 0;
264 1 : mel_send_len = 0;
265 1 : m_libspdm_mel_number = 3;
266 :
267 1 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
268 :
269 1 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
270 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
271 1 : m_libspdm_mel_len = (size_t)(measurement_extension_log->mel_entries_len) +
272 : sizeof(spdm_measurement_extension_log_dmtf_t);
273 :
274 1 : if (calling_index == 1) {
275 0 : m_libspdm_mel_number = 4;
276 0 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
277 0 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
278 0 : mel_new_len = (size_t)(measurement_extension_log->mel_entries_len) +
279 : sizeof(spdm_measurement_extension_log_dmtf_t);
280 : }
281 :
282 1 : mel_send_len = (m_libspdm_mel_len > mel_new_len) ? m_libspdm_mel_len : mel_new_len;
283 :
284 1 : count = (mel_send_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
285 1 : if (calling_index != count - 1) {
286 0 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
287 0 : remainder_length =
288 0 : (uint32_t)(mel_send_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
289 : } else {
290 1 : portion_length = (uint32_t)(
291 : m_libspdm_mel_len -
292 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
293 1 : remainder_length = (uint32_t)(
294 1 : mel_send_len -
295 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1) -
296 : portion_length);
297 : }
298 :
299 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
300 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
301 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
302 :
303 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
304 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
305 1 : spdm_response->header.param1 = 0;
306 1 : spdm_response->header.param2 = 0;
307 1 : spdm_response->portion_length = portion_length;
308 1 : spdm_response->remainder_length = remainder_length;
309 1 : libspdm_copy_mem(spdm_response + 1,
310 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
311 : (uint8_t *)spdm_mel +
312 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
313 : portion_length);
314 :
315 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
316 : false, spdm_response_size,
317 : spdm_response, response_size,
318 : response);
319 :
320 1 : calling_index++;
321 1 : if (calling_index == count) {
322 1 : calling_index = 0;
323 : }
324 : }
325 1 : return LIBSPDM_STATUS_SUCCESS;
326 2 : case 0x4: {
327 : spdm_measurement_extension_log_response_t *spdm_response;
328 : size_t spdm_response_size;
329 : size_t transport_header_size;
330 : uint32_t portion_length;
331 : uint32_t remainder_length;
332 : size_t count;
333 : static size_t calling_index = 0;
334 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
335 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
336 : size_t mel_new_len;
337 : size_t mel_send_len;
338 :
339 2 : spdm_mel = NULL;
340 2 : m_libspdm_mel_len = 0;
341 2 : mel_new_len = 0;
342 2 : mel_send_len = 0;
343 2 : m_libspdm_mel_number = 100;
344 :
345 2 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
346 :
347 2 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
348 2 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
349 2 : m_libspdm_mel_len = (size_t)(measurement_extension_log->mel_entries_len) +
350 : sizeof(spdm_measurement_extension_log_dmtf_t);
351 :
352 2 : if (calling_index == 1) {
353 1 : m_libspdm_mel_number = 105;
354 1 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
355 1 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
356 1 : mel_new_len = (size_t)(measurement_extension_log->mel_entries_len) +
357 : sizeof(spdm_measurement_extension_log_dmtf_t);
358 : }
359 :
360 2 : mel_send_len = (m_libspdm_mel_len > mel_new_len) ? m_libspdm_mel_len : mel_new_len;
361 :
362 2 : count = (m_libspdm_mel_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
363 2 : if (calling_index != count - 1) {
364 1 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
365 1 : remainder_length =
366 1 : (uint32_t)(mel_send_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
367 : } else {
368 1 : portion_length = (uint32_t)(
369 : m_libspdm_mel_len -
370 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
371 1 : remainder_length = (uint32_t)(
372 1 : mel_send_len -
373 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1) -
374 : portion_length);
375 : }
376 :
377 2 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
378 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
379 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
380 :
381 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
382 2 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
383 2 : spdm_response->header.param1 = 0;
384 2 : spdm_response->header.param2 = 0;
385 2 : spdm_response->portion_length = portion_length;
386 2 : spdm_response->remainder_length = remainder_length;
387 2 : libspdm_copy_mem(spdm_response + 1,
388 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
389 : (uint8_t *)spdm_mel +
390 2 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
391 : portion_length);
392 :
393 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
394 : false, spdm_response_size,
395 : spdm_response, response_size,
396 : response);
397 :
398 2 : calling_index++;
399 2 : if (calling_index == count) {
400 1 : calling_index = 0;
401 : }
402 : }
403 2 : return LIBSPDM_STATUS_SUCCESS;
404 2 : case 0x5: {
405 : spdm_measurement_extension_log_response_t *spdm_response;
406 : size_t spdm_response_size;
407 : size_t transport_header_size;
408 : uint32_t portion_length;
409 : uint32_t remainder_length;
410 : size_t count;
411 : static size_t calling_index = 0;
412 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
413 : spdm_measurement_extension_log_dmtf_t *measurement_extension_log;
414 : size_t mel_new_len;
415 : size_t mel_send_len;
416 :
417 2 : spdm_mel = NULL;
418 2 : m_libspdm_mel_len = 0;
419 2 : mel_new_len = 0;
420 2 : mel_send_len = 0;
421 2 : m_libspdm_mel_number = 100;
422 :
423 2 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
424 :
425 2 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
426 2 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
427 2 : m_libspdm_mel_len = (size_t)(measurement_extension_log->mel_entries_len) +
428 : sizeof(spdm_measurement_extension_log_dmtf_t);
429 :
430 2 : if (calling_index == 1) {
431 1 : m_libspdm_mel_number = 200;
432 1 : generate_long_mel(m_libspdm_use_measurement_hash_algo);
433 1 : measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
434 1 : mel_new_len = (size_t)(measurement_extension_log->mel_entries_len) +
435 : sizeof(spdm_measurement_extension_log_dmtf_t);
436 : }
437 :
438 2 : mel_send_len = (m_libspdm_mel_len > mel_new_len) ? m_libspdm_mel_len : mel_new_len;
439 :
440 2 : count = (m_libspdm_mel_len + LIBSPDM_MAX_MEL_BLOCK_LEN - 1) / LIBSPDM_MAX_MEL_BLOCK_LEN;
441 2 : if (calling_index != count - 1) {
442 1 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
443 1 : remainder_length =
444 1 : (uint32_t)(mel_send_len - LIBSPDM_MAX_MEL_BLOCK_LEN * (calling_index + 1));
445 : } else {
446 1 : portion_length = (uint32_t)(
447 : m_libspdm_mel_len -
448 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1));
449 1 : remainder_length = (uint32_t)(
450 1 : mel_send_len -
451 1 : LIBSPDM_MAX_MEL_BLOCK_LEN * (count - 1) -
452 : portion_length);
453 : }
454 :
455 2 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
456 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
457 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
458 :
459 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
460 2 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
461 2 : spdm_response->header.param1 = 0;
462 2 : spdm_response->header.param2 = 0;
463 2 : spdm_response->portion_length = portion_length;
464 2 : spdm_response->remainder_length = remainder_length;
465 2 : libspdm_copy_mem(spdm_response + 1,
466 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
467 : (uint8_t *)spdm_mel +
468 2 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
469 : portion_length);
470 :
471 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
472 : false, spdm_response_size,
473 : spdm_response, response_size,
474 : response);
475 :
476 2 : calling_index++;
477 2 : if (calling_index == count) {
478 1 : calling_index = 0;
479 : }
480 : }
481 2 : return LIBSPDM_STATUS_SUCCESS;
482 4 : case 0x6:
483 : {
484 : spdm_measurement_extension_log_response_t *spdm_response;
485 : size_t spdm_response_size;
486 : size_t transport_header_size;
487 : uint32_t portion_length;
488 : uint32_t remainder_length;
489 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
490 :
491 : static size_t count = 0;
492 : static size_t calling_index = 0;
493 :
494 4 : if (calling_index == 0) {
495 1 : count = (m_libspdm_mel_len / LIBSPDM_MAX_MEL_BLOCK_LEN) + 1;
496 : }
497 :
498 4 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
499 :
500 4 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
501 4 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
502 :
503 4 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
504 4 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
505 4 : spdm_response->header.param1 = 0;
506 4 : spdm_response->header.param2 = 0;
507 :
508 4 : if(m_libspdm_mel_len > LIBSPDM_MAX_MEL_BLOCK_LEN) {
509 3 : portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
510 3 : remainder_length = (uint32_t)(m_libspdm_mel_len - LIBSPDM_MAX_MEL_BLOCK_LEN);
511 : } else {
512 1 : portion_length = (uint32_t)m_libspdm_mel_len;
513 1 : remainder_length = 0;
514 : }
515 :
516 4 : spdm_response->portion_length = portion_length;
517 4 : spdm_response->remainder_length = remainder_length;
518 :
519 4 : libspdm_copy_mem(spdm_response + 1,
520 4 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
521 : (uint8_t *)spdm_mel +
522 4 : LIBSPDM_MAX_MEL_BLOCK_LEN * calling_index,
523 : portion_length);
524 :
525 4 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) + portion_length;
526 :
527 4 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
528 : false, spdm_response_size,
529 : spdm_response, response_size,
530 : response);
531 :
532 4 : m_libspdm_mel_len -= portion_length;
533 4 : calling_index++;
534 :
535 4 : if (calling_index == count) {
536 0 : calling_index = 0;
537 0 : m_libspdm_mel_len = 0;
538 : }
539 : }
540 4 : return LIBSPDM_STATUS_SUCCESS;
541 :
542 2 : case 0x7:
543 : {
544 : spdm_measurement_extension_log_response_t *spdm_response;
545 : size_t spdm_response_size;
546 : size_t transport_header_size;
547 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
548 :
549 : static size_t calling_index = 0;
550 :
551 2 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
552 :
553 2 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
554 2 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
555 :
556 2 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
557 2 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
558 2 : spdm_response->header.param1 = 0;
559 2 : spdm_response->header.param2 = 0;
560 2 : if (calling_index == 0) {
561 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
562 1 : spdm_response->remainder_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
563 : } else {
564 : /* The total amount of messages actually sent by the responder is less than the negotiated total mel len*/
565 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN / 2;
566 1 : spdm_response->remainder_length = 0;
567 : }
568 :
569 2 : libspdm_copy_mem(spdm_response + 1,
570 2 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
571 : (uint8_t *)spdm_mel,
572 : LIBSPDM_MAX_MEL_BLOCK_LEN);
573 :
574 2 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
575 : LIBSPDM_MAX_MEL_BLOCK_LEN;
576 :
577 2 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
578 : false, spdm_response_size,
579 : spdm_response, response_size,
580 : response);
581 2 : calling_index++;
582 : }
583 2 : return LIBSPDM_STATUS_SUCCESS;
584 1 : case 0x8:
585 : {
586 : spdm_measurement_extension_log_response_t *spdm_response;
587 : size_t spdm_response_size;
588 : size_t transport_header_size;
589 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
590 :
591 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
592 :
593 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
594 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
595 :
596 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
597 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
598 1 : spdm_response->header.param1 = 0;
599 1 : spdm_response->header.param2 = 0;
600 : /* Portion_length is greater than the LIBSPDM_MAX_MEL_BLOCK_LEN */
601 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN + 1;
602 1 : spdm_response->remainder_length = 0;
603 :
604 1 : libspdm_copy_mem(spdm_response + 1,
605 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
606 : (uint8_t *)spdm_mel,
607 : LIBSPDM_MAX_MEL_BLOCK_LEN);
608 :
609 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
610 : LIBSPDM_MAX_MEL_BLOCK_LEN;
611 :
612 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
613 : false, spdm_response_size,
614 : spdm_response, response_size,
615 : response);
616 : }
617 1 : return LIBSPDM_STATUS_SUCCESS;
618 :
619 1 : case 0x9:
620 : {
621 : spdm_measurement_extension_log_response_t *spdm_response;
622 : size_t spdm_response_size;
623 : size_t transport_header_size;
624 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
625 :
626 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
627 :
628 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
629 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
630 :
631 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
632 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
633 1 : spdm_response->header.param1 = 0;
634 1 : spdm_response->header.param2 = 0;
635 : /* The total MEL length is larger than SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE*/
636 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
637 1 : spdm_response->remainder_length = SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE;
638 :
639 1 : libspdm_copy_mem(spdm_response + 1,
640 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
641 : (uint8_t *)spdm_mel,
642 : LIBSPDM_MAX_MEL_BLOCK_LEN);
643 :
644 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
645 : LIBSPDM_MAX_MEL_BLOCK_LEN;
646 :
647 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
648 : false, spdm_response_size,
649 : spdm_response, response_size,
650 : response);
651 : }
652 1 : return LIBSPDM_STATUS_SUCCESS;
653 :
654 1 : case 0xA:
655 : {
656 : spdm_measurement_extension_log_response_t *spdm_response;
657 : size_t spdm_response_size;
658 : size_t transport_header_size;
659 : spdm_measurement_extension_log_dmtf_t *spdm_mel;
660 :
661 1 : spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel_test;
662 :
663 1 : transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
664 1 : spdm_response = (void *)((uint8_t *)*response + transport_header_size);
665 :
666 1 : spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
667 1 : spdm_response->header.request_response_code = SPDM_MEASUREMENT_EXTENSION_LOG;
668 1 : spdm_response->header.param1 = 0;
669 1 : spdm_response->header.param2 = 0;
670 : /* The entire MEL is delivered in a single response. */
671 1 : spdm_response->portion_length = LIBSPDM_MAX_MEL_BLOCK_LEN;
672 1 : spdm_response->remainder_length = 0;
673 :
674 1 : libspdm_copy_mem(spdm_response + 1,
675 1 : (size_t)(*response) + *response_size - (size_t)(spdm_response + 1),
676 : (uint8_t *)spdm_mel,
677 : LIBSPDM_MAX_MEL_BLOCK_LEN);
678 :
679 1 : spdm_response_size = sizeof(spdm_measurement_extension_log_response_t) +
680 : LIBSPDM_MAX_MEL_BLOCK_LEN;
681 :
682 1 : libspdm_transport_test_encode_message(spdm_context, NULL, false,
683 : false, spdm_response_size,
684 : spdm_response, response_size,
685 : response);
686 : }
687 1 : return LIBSPDM_STATUS_SUCCESS;
688 :
689 0 : default:
690 0 : return LIBSPDM_STATUS_RECEIVE_FAIL;
691 : }
692 : }
693 :
694 : /**
695 : * Test 1: message could not be sent
696 : * Expected Behavior: get a LIBSPDM_STATUS_SEND_FAIL, with no MEL messages received
697 : **/
698 1 : static void req_get_measurement_extension_log_case1(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 = 0x1;
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 :
716 1 : spdm_mel_size = sizeof(spdm_mel);
717 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
718 :
719 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
720 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
721 : m_libspdm_use_measurement_hash_algo;
722 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
723 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
724 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
725 :
726 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
727 1 : assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
728 1 : }
729 :
730 : /**
731 : * Test 2: Normal case, request a MEL, the MEL size remains unchanged
732 : * Expected Behavior: receives a valid MEL
733 : **/
734 1 : static void req_get_measurement_extension_log_case2(void **state)
735 : {
736 : libspdm_return_t status;
737 : libspdm_test_context_t *spdm_test_context;
738 : libspdm_context_t *spdm_context;
739 : size_t spdm_mel_size;
740 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
741 :
742 1 : spdm_test_context = *state;
743 1 : spdm_context = spdm_test_context->spdm_context;
744 1 : spdm_test_context->case_id = 0x2;
745 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
746 : SPDM_VERSION_NUMBER_SHIFT_BIT;
747 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
748 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
749 :
750 1 : libspdm_reset_message_b(spdm_context);
751 1 : spdm_mel_size = sizeof(spdm_mel);
752 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
753 :
754 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
755 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
756 : m_libspdm_use_measurement_hash_algo;
757 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
758 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
759 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
760 :
761 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
762 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
763 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
764 1 : }
765 :
766 : /**
767 : * Test 3: Normal case, request a MEL, the MEL size become more bigger when get MEL
768 : * The original MEL number is 3, the new MEL number is 4.
769 : * Expected Behavior: receives a valid MEL, and the MEL size is same with the before MEL size.
770 : **/
771 1 : static void req_get_measurement_extension_log_case3(void **state)
772 : {
773 : libspdm_return_t status;
774 : libspdm_test_context_t *spdm_test_context;
775 : libspdm_context_t *spdm_context;
776 : size_t spdm_mel_size;
777 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
778 :
779 1 : spdm_test_context = *state;
780 1 : spdm_context = spdm_test_context->spdm_context;
781 :
782 1 : spdm_test_context->case_id = 0x3;
783 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
784 : SPDM_VERSION_NUMBER_SHIFT_BIT;
785 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
786 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
787 :
788 1 : libspdm_reset_message_b(spdm_context);
789 1 : spdm_mel_size = sizeof(spdm_mel);
790 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
791 :
792 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
793 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
794 : m_libspdm_use_measurement_hash_algo;
795 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
796 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
797 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
798 :
799 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
800 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
801 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
802 1 : }
803 :
804 : /**
805 : * Test 4: Normal case, request a MEL, the MEL size become more bigger when get MEL
806 : * The original MEL number is 100, the new MEL number is 105.
807 : * Expected Behavior: receives a valid MEL, and the MEL size is same with the before MEL size.
808 : **/
809 1 : static void req_get_measurement_extension_log_case4(void **state)
810 : {
811 : libspdm_return_t status;
812 : libspdm_test_context_t *spdm_test_context;
813 : libspdm_context_t *spdm_context;
814 : size_t spdm_mel_size;
815 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
816 :
817 1 : spdm_test_context = *state;
818 1 : spdm_context = spdm_test_context->spdm_context;
819 1 : spdm_test_context->case_id = 0x4;
820 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
821 : SPDM_VERSION_NUMBER_SHIFT_BIT;
822 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
823 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
824 :
825 1 : libspdm_reset_message_b(spdm_context);
826 1 : spdm_mel_size = sizeof(spdm_mel);
827 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
828 :
829 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
830 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
831 : m_libspdm_use_measurement_hash_algo;
832 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
833 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
834 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
835 :
836 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
837 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
838 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
839 1 : }
840 :
841 : /**
842 : * Test 5: Normal case, request a MEL, the MEL size become more bigger when get MEL
843 : * The original MEL number is 100, the new MEL number is 200.
844 : * Expected Behavior: receives a valid MEL, and the MEL size is same with the before MEL size.
845 : **/
846 1 : static void req_get_measurement_extension_log_case5(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 :
854 1 : spdm_test_context = *state;
855 1 : spdm_context = spdm_test_context->spdm_context;
856 1 : spdm_test_context->case_id = 0x5;
857 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
858 : SPDM_VERSION_NUMBER_SHIFT_BIT;
859 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
860 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
861 :
862 1 : libspdm_reset_message_b(spdm_context);
863 1 : spdm_mel_size = sizeof(spdm_mel);
864 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
865 :
866 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
867 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
868 : m_libspdm_use_measurement_hash_algo;
869 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
870 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
871 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
872 :
873 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
874 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
875 1 : assert_int_equal(spdm_mel_size, m_libspdm_mel_len);
876 1 : }
877 :
878 : /**
879 : * Test 6: Normal case, request a LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE MEL
880 : * Expected Behavior: receives a valid MEL
881 : **/
882 1 : static void req_get_measurement_extension_log_case6(void **state)
883 : {
884 : libspdm_return_t status;
885 : libspdm_test_context_t *spdm_test_context;
886 : libspdm_context_t *spdm_context;
887 : size_t spdm_mel_size;
888 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
889 : size_t mel_buffer_size;
890 :
891 1 : spdm_test_context = *state;
892 1 : spdm_context = spdm_test_context->spdm_context;
893 1 : spdm_test_context->case_id = 0x6;
894 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
895 : SPDM_VERSION_NUMBER_SHIFT_BIT;
896 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
897 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
898 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
899 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
900 : m_libspdm_use_measurement_hash_algo;
901 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
902 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
903 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
904 :
905 1 : libspdm_reset_message_b(spdm_context);
906 1 : spdm_mel_size = sizeof(spdm_mel);
907 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
908 :
909 1 : generate_mel_entry_test();
910 1 : mel_buffer_size = m_libspdm_mel_len;
911 :
912 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
913 :
914 1 : assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
915 1 : assert_int_equal(spdm_mel_size, mel_buffer_size);
916 1 : assert_memory_equal(m_libspdm_mel_test, (void *)spdm_mel, spdm_mel_size);
917 1 : }
918 :
919 : /**
920 : * Test 7: The total amount of messages actually sent by the responder is less than the negotiated total mel len.
921 : * Expected Behavior: returns with status LIBSPDM_STATUS_INVALID_MSG_FIELD.
922 : **/
923 1 : static void req_get_measurement_extension_log_case7(void **state)
924 : {
925 : libspdm_return_t status;
926 : libspdm_test_context_t *spdm_test_context;
927 : libspdm_context_t *spdm_context;
928 : size_t spdm_mel_size;
929 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
930 :
931 1 : spdm_test_context = *state;
932 1 : spdm_context = spdm_test_context->spdm_context;
933 1 : spdm_test_context->case_id = 0x7;
934 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
935 : SPDM_VERSION_NUMBER_SHIFT_BIT;
936 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
937 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
938 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
939 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
940 : m_libspdm_use_measurement_hash_algo;
941 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
942 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
943 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
944 :
945 1 : libspdm_reset_message_b(spdm_context);
946 1 : spdm_mel_size = sizeof(spdm_mel);
947 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
948 :
949 1 : generate_mel_entry_test();
950 :
951 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
952 :
953 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
954 1 : }
955 :
956 : /**
957 : * Test 8: Portion_length is greater than the LIBSPDM_MAX_MEL_BLOCK_LEN
958 : * Expected Behavior: returns with status LIBSPDM_STATUS_INVALID_MSG_FIELD.
959 : **/
960 1 : static void req_get_measurement_extension_log_case8(void **state)
961 : {
962 : libspdm_return_t status;
963 : libspdm_test_context_t *spdm_test_context;
964 : libspdm_context_t *spdm_context;
965 : size_t spdm_mel_size;
966 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
967 : uint32_t original_max_spdm_msg_size;
968 :
969 1 : spdm_test_context = *state;
970 1 : spdm_context = spdm_test_context->spdm_context;
971 1 : spdm_test_context->case_id = 0x8;
972 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
973 : SPDM_VERSION_NUMBER_SHIFT_BIT;
974 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
975 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
976 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
977 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
978 : m_libspdm_use_measurement_hash_algo;
979 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
980 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
981 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
982 1 : original_max_spdm_msg_size = spdm_context->local_context.capability.max_spdm_msg_size;
983 1 : spdm_context->local_context.capability.max_spdm_msg_size =
984 : LIBSPDM_MAX_MEL_BLOCK_LEN +
985 : sizeof(spdm_measurement_extension_log_response_t);
986 :
987 1 : libspdm_reset_message_b(spdm_context);
988 1 : spdm_mel_size = sizeof(spdm_mel);
989 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
990 :
991 1 : generate_mel_entry_test();
992 :
993 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
994 :
995 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
996 1 : spdm_context->local_context.capability.max_spdm_msg_size = original_max_spdm_msg_size;
997 1 : }
998 :
999 : /**
1000 : * Test 9: The total MEL length is larger than SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE
1001 : * Expected Behavior: returns with status LIBSPDM_STATUS_INVALID_MSG_FIELD.
1002 : **/
1003 1 : static void req_get_measurement_extension_log_case9(void **state)
1004 : {
1005 : libspdm_return_t status;
1006 : libspdm_test_context_t *spdm_test_context;
1007 : libspdm_context_t *spdm_context;
1008 : size_t spdm_mel_size;
1009 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
1010 :
1011 1 : spdm_test_context = *state;
1012 1 : spdm_context = spdm_test_context->spdm_context;
1013 1 : spdm_test_context->case_id = 0x9;
1014 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1015 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1016 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1017 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
1018 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1019 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1020 : m_libspdm_use_measurement_hash_algo;
1021 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1022 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1023 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1024 :
1025 1 : libspdm_reset_message_b(spdm_context);
1026 1 : spdm_mel_size = sizeof(spdm_mel);
1027 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
1028 :
1029 1 : generate_mel_entry_test();
1030 :
1031 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
1032 :
1033 1 : assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
1034 1 : }
1035 :
1036 : /**
1037 : * Test 10: The Requester's MEL buffer is smaller than the MEASUREMENT_EXTENSION_LOG response's
1038 : * PortionLength.
1039 : * Expected Behavior: get a LIBSPDM_STATUS_BUFFER_TOO_SMALL return code
1040 : **/
1041 1 : static void req_get_measurement_extension_log_case10(void **state)
1042 : {
1043 : libspdm_return_t status;
1044 : libspdm_test_context_t *spdm_test_context;
1045 : libspdm_context_t *spdm_context;
1046 : size_t spdm_mel_size;
1047 : uint8_t spdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE];
1048 :
1049 1 : spdm_test_context = *state;
1050 1 : spdm_context = spdm_test_context->spdm_context;
1051 1 : spdm_test_context->case_id = 0xA;
1052 1 : spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
1053 : SPDM_VERSION_NUMBER_SHIFT_BIT;
1054 1 : spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AUTHENTICATED;
1055 1 : spdm_context->connection_info.capability.flags |= SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MEL_CAP;
1056 :
1057 1 : libspdm_reset_message_b(spdm_context);
1058 1 : libspdm_zero_mem(spdm_mel, sizeof(spdm_mel));
1059 :
1060 1 : spdm_context->connection_info.algorithm.measurement_spec = m_libspdm_use_measurement_spec;
1061 1 : spdm_context->connection_info.algorithm.measurement_hash_algo =
1062 : m_libspdm_use_measurement_hash_algo;
1063 1 : spdm_context->connection_info.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
1064 1 : spdm_context->connection_info.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
1065 1 : spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
1066 :
1067 : /* Case 0xA responds with a PortionLength of LIBSPDM_MAX_MEL_BLOCK_LEN. */
1068 1 : spdm_mel_size = LIBSPDM_MAX_MEL_BLOCK_LEN - 1;
1069 :
1070 1 : status = libspdm_get_measurement_extension_log(spdm_context, NULL, &spdm_mel_size, spdm_mel);
1071 1 : assert_int_equal(status, LIBSPDM_STATUS_BUFFER_TOO_SMALL);
1072 1 : }
1073 :
1074 1 : int libspdm_req_get_measurement_extension_log_test(void)
1075 : {
1076 1 : const struct CMUnitTest test_cases[] = {
1077 : /* SendRequest failed*/
1078 : cmocka_unit_test(req_get_measurement_extension_log_case1),
1079 : /* Successful response, the MEL size remains unchanged*/
1080 : cmocka_unit_test(req_get_measurement_extension_log_case2),
1081 : /* Successful response, the MEL size become more bigger when get MEL. MEL number change from 3 to 4*/
1082 : cmocka_unit_test(req_get_measurement_extension_log_case3),
1083 : /* Successful response, the MEL size become more bigger when get MEL. MEL number change from 100 to 105*/
1084 : cmocka_unit_test(req_get_measurement_extension_log_case4),
1085 : /* Successful response, the MEL size become more bigger when get MEL. MEL number change from 100 to 200*/
1086 : cmocka_unit_test(req_get_measurement_extension_log_case5),
1087 : /* Successful response , LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE*/
1088 : cmocka_unit_test(req_get_measurement_extension_log_case6),
1089 : /* Failed response , The total amount of messages actually sent by the responder is less than the negotiated total mel len*/
1090 : cmocka_unit_test(req_get_measurement_extension_log_case7),
1091 : /* Failed response , Portion_length is greater than the LIBSPDM_MAX_MEL_BLOCK_LEN*/
1092 : cmocka_unit_test(req_get_measurement_extension_log_case8),
1093 : /* Failed response , The total MEL length is larger than SPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE*/
1094 : cmocka_unit_test(req_get_measurement_extension_log_case9),
1095 : /* Failed response , The caller's MEL buffer is smaller than the portion length*/
1096 : cmocka_unit_test(req_get_measurement_extension_log_case10),
1097 : };
1098 :
1099 1 : libspdm_test_context_t test_context = {
1100 : LIBSPDM_TEST_CONTEXT_VERSION,
1101 : true,
1102 : send_message,
1103 : receive_message,
1104 : };
1105 :
1106 1 : libspdm_setup_test_context(&test_context);
1107 :
1108 1 : return cmocka_run_group_tests(test_cases,
1109 : libspdm_unit_test_group_setup,
1110 : libspdm_unit_test_group_teardown);
1111 : }
1112 :
1113 : #endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP */
|
