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