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