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