1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /***********************************************************************
3 * Copyright (c) 2017-2018, Intel Corporation
4 *
5 * All rights reserved.
6 ***********************************************************************/
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <stdarg.h>
12 #include <stddef.h>
13 #include <string.h>
14 #include <setjmp.h>
15 #include <cmocka.h>
16 #include <stdio.h>
17 #include "tss2_mu.h"
18 #include "util/tss2_endian.h"
19
20 /*
21 * Success case
22 */
23 static void
tpml_marshal_success(void ** state)24 tpml_marshal_success(void **state)
25 {
26 TPML_HANDLE hndl = {0};
27 TPML_PCR_SELECTION sel = {0};
28 uint8_t buffer[sizeof(hndl) + sizeof(sel)] = { 0 };
29 size_t buffer_size = sizeof(buffer);
30 TPML_HANDLE *ptr;
31 TSS2_RC rc;
32
33 hndl.count = 2;
34 hndl.handle[0] = 0x81000001;
35 hndl.handle[1] = 0x81000002;
36
37 ptr = (TPML_HANDLE *) buffer;
38
39 rc = Tss2_MU_TPML_HANDLE_Marshal(&hndl, buffer, buffer_size, NULL);
40 assert_int_equal (rc, TSS2_RC_SUCCESS);
41 assert_int_equal (ptr->count, HOST_TO_BE_32(2));
42 assert_int_equal (ptr->handle[0], HOST_TO_BE_32(0x81000001));
43 assert_int_equal (ptr->handle[1], HOST_TO_BE_32(0x81000002));
44
45 sel.count = 2;
46 sel.pcrSelections[0].hash = TPM2_ALG_SHA1;
47 sel.pcrSelections[0].sizeofSelect = 3;
48 sel.pcrSelections[0].pcrSelect[0] = 0xaa;
49 sel.pcrSelections[0].pcrSelect[1] = 0xbb;
50 sel.pcrSelections[0].pcrSelect[2] = 0xcc;
51 sel.pcrSelections[1].hash = TPM2_ALG_SHA256;
52 sel.pcrSelections[1].sizeofSelect = 2;
53 sel.pcrSelections[1].pcrSelect[0] = 0xdd;
54 sel.pcrSelections[1].pcrSelect[1] = 0xee;
55
56 rc = Tss2_MU_TPML_PCR_SELECTION_Marshal(&sel, buffer, buffer_size, NULL);
57 assert_int_equal (rc, TSS2_RC_SUCCESS);
58
59 uint8_t expect [] = {
60 0, 0, 0, 2,
61 0, 0x04, /* TPM2_ALG_SHA1 */
62 3,
63 0xaa, 0xbb, 0xcc,
64 0, 0x0b, /* TPM2_ALG_SHA256 */
65 2,
66 0xdd, 0xee};
67
68 assert_memory_equal(buffer, &expect[0], sizeof(expect));
69 }
70
71 /*
72 * Success case with a valid offset
73 */
74 static void
tpml_marshal_success_offset(void ** state)75 tpml_marshal_success_offset(void **state)
76 {
77 TPML_HANDLE hndl = {0};
78 TPML_PCR_SELECTION sel = {0};
79 uint8_t buffer[sizeof(hndl) + sizeof(sel) + 10] = { 0 };
80 size_t buffer_size = sizeof(buffer);
81 TPML_HANDLE *ptr;
82 size_t offset = 10;
83 TSS2_RC rc;
84
85 hndl.count = 2;
86 hndl.handle[0] = 0x81000001;
87 hndl.handle[1] = 0x81000002;
88
89 ptr = (TPML_HANDLE *) (buffer + 10);
90
91 rc = Tss2_MU_TPML_HANDLE_Marshal(&hndl, buffer, buffer_size, &offset);
92 assert_int_equal (rc, TSS2_RC_SUCCESS);
93 assert_int_equal (ptr->count, HOST_TO_BE_32(2));
94 assert_int_equal (ptr->handle[0], HOST_TO_BE_32(0x81000001));
95 assert_int_equal (ptr->handle[1], HOST_TO_BE_32(0x81000002));
96 assert_int_equal (offset, 10 + 4 + 4 + 4);
97
98 sel.count = 2;
99 sel.pcrSelections[0].hash = TPM2_ALG_SHA1;
100 sel.pcrSelections[0].sizeofSelect = 3;
101 sel.pcrSelections[0].pcrSelect[0] = 0xaa;
102 sel.pcrSelections[0].pcrSelect[1] = 0xbb;
103 sel.pcrSelections[0].pcrSelect[2] = 0xcc;
104 sel.pcrSelections[1].hash = TPM2_ALG_SHA256;
105 sel.pcrSelections[1].sizeofSelect = 2;
106 sel.pcrSelections[1].pcrSelect[0] = 0xdd;
107 sel.pcrSelections[1].pcrSelect[1] = 0xee;
108
109 rc = Tss2_MU_TPML_PCR_SELECTION_Marshal(&sel, buffer, buffer_size, &offset);
110 assert_int_equal (rc, TSS2_RC_SUCCESS);
111
112 uint8_t expect [] = {
113 0, 0, 0, 2,
114 0, 0x04, /* TPM2_ALG_SHA1 */
115 3,
116 0xaa, 0xbb, 0xcc,
117 0, 0x0b, /* TPM2_ALG_SHA256 */
118 2,
119 0xdd, 0xee};
120
121 assert_memory_equal((buffer + 10 + 4 + 4 + 4), &expect[0], sizeof(expect));
122
123 assert_int_equal (offset, 10 + 4 + 4 + 4 + 4 + 2 + 1 + 1 + 1 + 1 + 2 + 1 + 1 + 1);
124 }
125
126 /*
127 * Success case with a null buffer
128 */
129 static void
tpml_marshal_buffer_null_with_offset(void ** state)130 tpml_marshal_buffer_null_with_offset(void **state)
131 {
132 TPML_HANDLE hndl = {0};
133 TPML_PCR_SELECTION sel = {0};
134 TPML_DIGEST dgst = {0};
135 TPML_DIGEST_VALUES dgst_vals = {0};
136 size_t buffer_size = sizeof(hndl) + sizeof(sel) + sizeof(dgst) + 99;
137 size_t offset = 99;
138 TSS2_RC rc;
139
140 hndl.count = 2;
141 hndl.handle[0] = 0x81000001;
142 hndl.handle[1] = 0x81000002;
143
144 rc = Tss2_MU_TPML_HANDLE_Marshal(&hndl, NULL, buffer_size, &offset);
145 assert_int_equal (rc, TSS2_RC_SUCCESS);
146 assert_int_equal (offset, 99 + 4 + 4 + 4);
147
148 sel.count = 2;
149 sel.pcrSelections[0].hash = TPM2_ALG_SHA1;
150 sel.pcrSelections[0].sizeofSelect = 3;
151 sel.pcrSelections[0].pcrSelect[0] = 0xaa;
152 sel.pcrSelections[0].pcrSelect[1] = 0xbb;
153 sel.pcrSelections[0].pcrSelect[2] = 0xcc;
154 sel.pcrSelections[1].hash = TPM2_ALG_SHA256;
155 sel.pcrSelections[1].sizeofSelect = 2;
156 sel.pcrSelections[1].pcrSelect[0] = 0xdd;
157 sel.pcrSelections[1].pcrSelect[1] = 0xee;
158
159 rc = Tss2_MU_TPML_PCR_SELECTION_Marshal(&sel, NULL, buffer_size, &offset);
160 assert_int_equal (rc, TSS2_RC_SUCCESS);
161 assert_int_equal (offset, 99 + 4 + 4 + 4 + 4 + 2 + 1 + 1 + 1 + 1 + 2 + 1 + 1 + 1);
162
163 offset = 99;
164 dgst.count = 2;
165 dgst.digests[0].size = TPM2_SHA1_DIGEST_SIZE;
166 dgst.digests[1].size = TPM2_SHA512_DIGEST_SIZE;
167 rc = Tss2_MU_TPML_DIGEST_Marshal(&dgst, NULL, buffer_size, &offset);
168 assert_int_equal (rc, TSS2_RC_SUCCESS);
169 assert_int_equal (offset, 99 + sizeof(UINT32) + 2*sizeof(UINT16) +
170 TPM2_SHA1_DIGEST_SIZE + TPM2_SHA512_DIGEST_SIZE);
171
172 offset = 99;
173 dgst_vals.count = 2;
174 dgst_vals.digests[0].hashAlg = TPM2_ALG_SHA1;
175 dgst_vals.digests[1].hashAlg = TPM2_ALG_SHA512;
176 rc = Tss2_MU_TPML_DIGEST_VALUES_Marshal(&dgst_vals, NULL, buffer_size, &offset);
177 assert_int_equal (rc, TSS2_RC_SUCCESS);
178 assert_int_equal (offset, 99 + sizeof(UINT32) + 2*sizeof(TPMI_ALG_HASH) +
179 TPM2_SHA1_DIGEST_SIZE + TPM2_SHA512_DIGEST_SIZE);
180 }
181
182 /*
183 * Invalid case with a null buffer and a null offset
184 */
185 static void
tpml_marshal_buffer_null_offset_null(void ** state)186 tpml_marshal_buffer_null_offset_null(void **state)
187 {
188 TPML_HANDLE hndl = {0};
189 TPML_PCR_SELECTION sel = {0};
190 TSS2_RC rc;
191
192 hndl.count = 2;
193 hndl.handle[0] = 0x81000001;
194 hndl.handle[1] = 0x81000002;
195
196 rc = Tss2_MU_TPML_HANDLE_Marshal(&hndl, NULL, sizeof(hndl), NULL);
197 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
198
199 rc = Tss2_MU_TPML_PCR_SELECTION_Marshal(&sel, NULL, sizeof(sel), NULL);
200 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
201 }
202
203 /*
204 * Invalid case with not big enough buffer
205 */
206 static void
tpml_marshal_buffer_size_lt_data_nad_lt_offset(void ** state)207 tpml_marshal_buffer_size_lt_data_nad_lt_offset(void **state)
208 {
209 TPML_HANDLE hndl = {0};
210 TPML_PCR_SELECTION sel = {0};
211 uint8_t buffer[sizeof(hndl) + sizeof(sel) + 10] = { 0 };
212 size_t buffer_size = 3 * 4;
213 size_t offset = 10;
214 TSS2_RC rc;
215
216 hndl.count = 2;
217 hndl.handle[0] = 0x81000001;
218 hndl.handle[1] = 0x81000002;
219
220 rc = Tss2_MU_TPML_HANDLE_Marshal(&hndl, buffer, buffer_size, &offset);
221 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
222 assert_int_equal (offset, 10);
223
224 sel.count = 2;
225 sel.pcrSelections[0].hash = TPM2_ALG_SHA1;
226 sel.pcrSelections[0].sizeofSelect = 3;
227 sel.pcrSelections[0].pcrSelect[0] = 0xaa;
228 sel.pcrSelections[0].pcrSelect[1] = 0xbb;
229 sel.pcrSelections[0].pcrSelect[2] = 0xcc;
230 sel.pcrSelections[1].hash = TPM2_ALG_SHA256;
231 sel.pcrSelections[1].sizeofSelect = 2;
232 sel.pcrSelections[1].pcrSelect[0] = 0xdd;
233 sel.pcrSelections[1].pcrSelect[1] = 0xee;
234
235 offset = 2;
236 buffer_size = 4 + 2 + 4 + 2 + 2;
237 rc = Tss2_MU_TPML_PCR_SELECTION_Marshal(&sel, buffer, buffer_size, &offset);
238 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
239 assert_int_equal (offset, 2);
240 }
241
242 /*
243 * Invalid case with too big count
244 */
245 static void
tpml_marshal_invalid_count(void ** state)246 tpml_marshal_invalid_count(void **state)
247 {
248 TPML_HANDLE hndl = {0};
249 TPML_PCR_SELECTION sel = {0};
250 uint8_t buffer[sizeof(hndl) + sizeof(sel)] = { 0 };
251 size_t buffer_size = sizeof(buffer);
252 TSS2_RC rc;
253
254 hndl.count = TPM2_MAX_CAP_HANDLES + 2;
255 hndl.handle[0] = 0x81000001;
256 hndl.handle[1] = 0x81000002;
257
258 rc = Tss2_MU_TPML_HANDLE_Marshal(&hndl, buffer, buffer_size, NULL);
259 assert_int_equal (rc, TSS2_SYS_RC_BAD_VALUE);
260
261 sel.count = TPM2_NUM_PCR_BANKS + 2;
262 sel.pcrSelections[0].hash = TPM2_ALG_SHA1;
263 sel.pcrSelections[0].sizeofSelect = 3;
264 sel.pcrSelections[0].pcrSelect[0] = 0xaa;
265 sel.pcrSelections[0].pcrSelect[1] = 0xbb;
266 sel.pcrSelections[0].pcrSelect[2] = 0xcc;
267 sel.pcrSelections[1].hash = TPM2_ALG_SHA256;
268 sel.pcrSelections[1].sizeofSelect = 2;
269 sel.pcrSelections[1].pcrSelect[0] = 0xdd;
270 sel.pcrSelections[1].pcrSelect[1] = 0xee;
271
272 rc = Tss2_MU_TPML_PCR_SELECTION_Marshal(&sel, buffer, buffer_size, NULL);
273 assert_int_equal (rc, TSS2_SYS_RC_BAD_VALUE);
274 }
275
276 /*
277 * Success case
278 */
279 static void
tpml_unmarshal_success(void ** state)280 tpml_unmarshal_success(void **state)
281 {
282 TPML_HANDLE hndl = {0};
283 TPML_PCR_SELECTION sel = {0};
284 uint8_t buffer[sizeof(hndl) + sizeof(sel) + 10] = { 0 };
285 size_t buffer_size = sizeof(buffer);
286 TPML_HANDLE *ptr;
287 size_t offset = 0;
288 TSS2_RC rc;
289
290 ptr = (TPML_HANDLE *) (buffer);
291 ptr->count = HOST_TO_BE_32(2);
292 ptr->handle[0] = HOST_TO_BE_32(0x81000001);
293 ptr->handle[1] = HOST_TO_BE_32(0x81000002);
294
295 rc = Tss2_MU_TPML_HANDLE_Unmarshal(buffer, buffer_size, &offset, &hndl);
296 assert_int_equal (rc, TSS2_RC_SUCCESS);
297 assert_int_equal (hndl.count, 2);
298 assert_int_equal (hndl.handle[0], 0x81000001);
299 assert_int_equal (hndl.handle[1], 0x81000002);
300 assert_int_equal (offset, 4 + 4 + 4);
301
302 uint8_t data [] = {
303 0, 0, 0, 2,
304 0, 0x04, /* TPM2_ALG_SHA1 */
305 3,
306 0xaa, 0xbb, 0xcc,
307 0, 0x0b, /* TPM2_ALG_SHA256 */
308 2,
309 0xdd, 0xee};
310
311 memcpy(buffer + 4 + 4 + 4, &data[0], sizeof(data));
312
313 rc = Tss2_MU_TPML_PCR_SELECTION_Unmarshal(buffer, buffer_size, &offset, &sel);
314 assert_int_equal (rc, TSS2_RC_SUCCESS);
315 assert_int_equal (sel.count, 2);
316 assert_int_equal (sel.pcrSelections[0].hash, TPM2_ALG_SHA1);
317 assert_int_equal (sel.pcrSelections[0].sizeofSelect, 3);
318 assert_int_equal (sel.pcrSelections[0].pcrSelect[0], 0xaa);
319 assert_int_equal (sel.pcrSelections[0].pcrSelect[1], 0xbb);
320 assert_int_equal (sel.pcrSelections[0].pcrSelect[2], 0xcc);
321 assert_int_equal (sel.pcrSelections[1].hash, TPM2_ALG_SHA256);
322 assert_int_equal (sel.pcrSelections[1].sizeofSelect, 2);
323 assert_int_equal (sel.pcrSelections[1].pcrSelect[0], 0xdd);
324 assert_int_equal (sel.pcrSelections[1].pcrSelect[1], 0xee);
325 assert_int_equal (offset, 4 + 4 + 4 + 4 + 2 + 1 + 1 + 1 + 1 + 2 + 1 + 1 + 1);
326 }
327
328 /*
329 * Invalid test case with buffer null and dest null
330 */
331 static void
tpml_unmarshal_dest_null_buff_null(void ** state)332 tpml_unmarshal_dest_null_buff_null(void **state)
333 {
334 size_t offset = 1;
335 TSS2_RC rc;
336
337 rc = Tss2_MU_TPML_HANDLE_Unmarshal(NULL, 120, &offset, NULL);
338 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
339 assert_int_equal (offset, 1);
340
341 rc = Tss2_MU_TPML_PCR_SELECTION_Unmarshal(NULL, 120, &offset, NULL);
342 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
343 assert_int_equal (offset, 1);
344 }
345
346 /*
347 * Invalid test case with offset null and dest null
348 */
349 static void
tpml_unmarshal_buffer_null_offset_null(void ** state)350 tpml_unmarshal_buffer_null_offset_null(void **state)
351 {
352 uint8_t buffer[sizeof(TPML_HANDLE) + sizeof(TPML_PCR_SELECTION)] = { 0 };
353 size_t buffer_size = sizeof(buffer);
354 TSS2_RC rc;
355
356 rc = Tss2_MU_TPML_HANDLE_Unmarshal(buffer, buffer_size, NULL, NULL);
357 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
358
359 rc = Tss2_MU_TPML_PCR_SELECTION_Unmarshal(buffer, buffer_size, NULL, NULL);
360 assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
361 }
362
363 /*
364 * Test case ensures the offset is updated when dest is NULL
365 * and offset is valid
366 */
367 static void
tpml_unmarshal_dest_null_offset_valid(void ** state)368 tpml_unmarshal_dest_null_offset_valid(void **state)
369 {
370 uint8_t buffer[sizeof(TPML_HANDLE) + sizeof(TPML_PCR_SELECTION) + 10] = { 0 };
371 size_t buffer_size = sizeof(buffer);
372 TPML_HANDLE *ptr;
373 size_t offset = 0;
374 TSS2_RC rc;
375
376 ptr = (TPML_HANDLE *) (buffer);
377 ptr->count = HOST_TO_BE_32(2);
378 ptr->handle[0] = HOST_TO_BE_32(0x81000001);
379 ptr->handle[1] = HOST_TO_BE_32(0x81000002);
380
381 rc = Tss2_MU_TPML_HANDLE_Unmarshal(buffer, buffer_size, &offset, NULL);
382 assert_int_equal (rc, TSS2_RC_SUCCESS);
383 assert_int_equal (offset, 4 + 4 + 4);
384
385 uint8_t data [] = {
386 0, 0, 0, 2,
387 0, 0x04, /* TPM2_ALG_SHA1 */
388 3,
389 0xaa, 0xbb, 0xcc,
390 0, 0x0b, /* TPM2_ALG_SHA256 */
391 2,
392 0xdd, 0xee};
393
394 memcpy(buffer + 4 + 4 + 4, &data[0], sizeof(data));
395
396 rc = Tss2_MU_TPML_PCR_SELECTION_Unmarshal(buffer, buffer_size, &offset, NULL);
397 assert_int_equal (rc, TSS2_RC_SUCCESS);
398 assert_int_equal (offset, 4 + 4 + 4 + 4 + 2 + 1 + 1 + 1 + 1 + 2 + 1 + 1 + 1);
399 }
400
401 /*
402 * Invalid case with not big enough buffer. Make sure offest is untouched.
403 */
404 static void
tpml_unmarshal_buffer_size_lt_data_nad_lt_offset(void ** state)405 tpml_unmarshal_buffer_size_lt_data_nad_lt_offset(void **state)
406 {
407 uint8_t buffer[sizeof(TPML_HANDLE) + sizeof(TPML_PCR_SELECTION)] = { 0 };
408 TPML_HANDLE *ptr;
409 size_t offset = 2;
410 TSS2_RC rc;
411
412 ptr = (TPML_HANDLE *) (buffer + 2);
413 ptr->count = HOST_TO_BE_32(2);
414 ptr->handle[0] = HOST_TO_BE_32(0x81000001);
415 ptr->handle[1] = HOST_TO_BE_32(0x81000002);
416
417 rc = Tss2_MU_TPML_HANDLE_Unmarshal(buffer, 3 * 4, &offset, NULL);
418 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
419 assert_int_equal (offset, 2);
420
421 uint8_t data [] = {
422 0, 0, 0, 2,
423 0, 0x04, /* TPM2_ALG_SHA1 */
424 3,
425 0xaa, 0xbb, 0xcc,
426 0, 0x0b, /* TPM2_ALG_SHA256 */
427 2,
428 0xdd, 0xee};
429
430 memcpy(buffer + 2, &data[0], sizeof(data));
431
432 rc = Tss2_MU_TPML_PCR_SELECTION_Unmarshal(buffer, 4 + 2 + 1 + 1 + 1 + 1 + 2 + 1 + 1 + 1, &offset, NULL);
433 assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
434 assert_int_equal (offset, 2);
435 }
436
437 /*
438 * Invalid case with too big count
439 */
440 static void
tpml_unmarshal_invalid_count(void ** state)441 tpml_unmarshal_invalid_count(void **state)
442 {
443 TPML_HANDLE hndl = {0};
444 TPML_PCR_SELECTION sel = {0};
445 uint8_t buffer[sizeof(hndl) + sizeof(sel) + 10] = { 0 };
446 size_t buffer_size = sizeof(buffer);
447 TPML_HANDLE *ptr;
448 TPML_PCR_SELECTION *ptr2;
449 size_t offset = 0;
450 TSS2_RC rc;
451
452 ptr = (TPML_HANDLE *) (buffer);
453 ptr->count = HOST_TO_BE_32(TPM2_MAX_CAP_HANDLES + 2);
454 ptr->handle[0] = HOST_TO_BE_32(0x81000001);
455 ptr->handle[1] = HOST_TO_BE_32(0x81000002);
456
457 rc = Tss2_MU_TPML_HANDLE_Unmarshal(buffer, buffer_size, &offset, &hndl);
458 assert_int_equal (rc, TSS2_SYS_RC_MALFORMED_RESPONSE);
459
460 ptr2 = (TPML_PCR_SELECTION *)(buffer + 4 + 4 + 4);
461 ptr2->count = HOST_TO_BE_32(TPM2_NUM_PCR_BANKS + 2);
462 ptr2->pcrSelections[0].hash = HOST_TO_BE_16(TPM2_ALG_SHA1);
463 ptr2->pcrSelections[0].sizeofSelect = 3;
464 ptr2->pcrSelections[0].pcrSelect[0] = 0xaa;
465 ptr2->pcrSelections[0].pcrSelect[1] = 0xbb;
466 ptr2->pcrSelections[0].pcrSelect[2] = 0xcc;
467 ptr2->pcrSelections[1].hash = HOST_TO_BE_16(TPM2_ALG_SHA256);
468 ptr2->pcrSelections[1].sizeofSelect = 2;
469 ptr2->pcrSelections[1].pcrSelect[0] = 0xdd;
470 ptr2->pcrSelections[1].pcrSelect[1] = 0xee;
471
472 rc = Tss2_MU_TPML_PCR_SELECTION_Unmarshal(buffer, buffer_size, &offset, &sel);
473 assert_int_equal (rc, TSS2_SYS_RC_MALFORMED_RESPONSE);
474 }
475
main(void)476 int main(void) {
477 const struct CMUnitTest tests[] = {
478 cmocka_unit_test (tpml_marshal_success),
479 cmocka_unit_test (tpml_marshal_success_offset),
480 cmocka_unit_test (tpml_marshal_buffer_null_with_offset),
481 cmocka_unit_test (tpml_marshal_buffer_null_offset_null),
482 cmocka_unit_test (tpml_marshal_buffer_size_lt_data_nad_lt_offset),
483 cmocka_unit_test (tpml_marshal_invalid_count),
484 cmocka_unit_test (tpml_unmarshal_success),
485 cmocka_unit_test (tpml_unmarshal_dest_null_buff_null),
486 cmocka_unit_test (tpml_unmarshal_buffer_null_offset_null),
487 cmocka_unit_test (tpml_unmarshal_dest_null_offset_valid),
488 cmocka_unit_test (tpml_unmarshal_buffer_size_lt_data_nad_lt_offset),
489 cmocka_unit_test (tpml_unmarshal_invalid_count),
490 };
491 return cmocka_run_group_tests(tests, NULL, NULL);
492 }
493