You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
446 lines
15 KiB
446 lines
15 KiB
/* SPDX-License-Identifier: BSD-2-Clause */
|
|
/***********************************************************************
|
|
* Copyright (c) 2017-2018, Intel Corporation
|
|
*
|
|
* All rights reserved.
|
|
***********************************************************************/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <setjmp.h>
|
|
#include <cmocka.h>
|
|
#include "tss2_mu.h"
|
|
#include "util/tss2_endian.h"
|
|
|
|
/*
|
|
* Success case
|
|
*/
|
|
static void
|
|
tpm2b_marshal_success(void **state) {
|
|
TPM2B_DIGEST dgst = {4, {0}};
|
|
TPM2B_ECC_POINT point = {0};
|
|
uint8_t buffer[sizeof(dgst) + sizeof(point)] = {0};
|
|
size_t buffer_size = sizeof(buffer);
|
|
uint16_t *size_ptr = (uint16_t *) buffer;
|
|
uint32_t *ptr = (uint32_t *) (buffer + 2);
|
|
uint32_t value = 0xdeadbeef;
|
|
uint64_t value2 = 0xdeadbeefdeadbeefULL;
|
|
uint64_t *ptr2;
|
|
TSS2_RC rc;
|
|
|
|
memcpy(dgst.buffer, &value, sizeof(value));
|
|
memcpy(point.point.x.buffer, &value, sizeof(value));
|
|
point.point.x.size = sizeof(value);
|
|
memcpy(point.point.y.buffer, &value2, sizeof(value2));
|
|
point.point.y.size = sizeof(value2);
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, buffer, buffer_size, NULL);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (*size_ptr, HOST_TO_BE_16(4));
|
|
assert_int_equal (*ptr, value);
|
|
|
|
size_ptr = (uint16_t *) buffer;
|
|
ptr = (uint32_t *) (buffer + 4);
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Marshal(&point, buffer, buffer_size, NULL);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
/*
|
|
* size_ptr points to the size of the whole TPMS_ECC_POINT:
|
|
* sizeof(unit16) + sizeof(value) + sizeof(unit16) + sizeof(value2)
|
|
*/
|
|
assert_int_equal (*size_ptr, HOST_TO_BE_16(2 + 4 + 2 + 8));
|
|
/* check point.x: */
|
|
assert_int_equal (*(size_ptr + 1), HOST_TO_BE_16(4));
|
|
assert_int_equal (*ptr, value);
|
|
size_ptr = (uint16_t *) (buffer + 2 + 2 + 4);
|
|
ptr2 = (uint64_t *) (buffer + 2 + 2 + 2 + 4);
|
|
/* check point.y: */
|
|
assert_int_equal (*size_ptr, HOST_TO_BE_16(8));
|
|
assert_int_equal (*ptr2, value2);
|
|
}
|
|
|
|
/*
|
|
* Success case with a valid offset
|
|
*/
|
|
static void
|
|
tpm2b_marshal_success_offset(void **state) {
|
|
TPM2B_DIGEST dgst = {4, {0}};
|
|
TPM2B_ECC_POINT point = {0};
|
|
size_t offset = 10;
|
|
uint8_t buffer[sizeof(dgst) + sizeof(point) + 10] = {0};
|
|
size_t buffer_size = sizeof(buffer);
|
|
uint16_t *size_ptr = (uint16_t *) (buffer + 10);
|
|
uint32_t *ptr = (uint32_t *) (buffer + 2 + 10);
|
|
uint32_t value = 0xdeadbeef;
|
|
uint64_t value2 = 0xdeadbeefdeadbeefULL;
|
|
uint64_t *ptr2;
|
|
TSS2_RC rc;
|
|
|
|
memcpy(dgst.buffer, &value, sizeof(value));
|
|
memcpy(point.point.x.buffer, &value, sizeof(value));
|
|
point.point.x.size = sizeof(value);
|
|
memcpy(point.point.y.buffer, &value2, sizeof(value2));
|
|
point.point.y.size = sizeof(value2);
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, buffer, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (*size_ptr, HOST_TO_BE_16(4));
|
|
assert_int_equal (*ptr, value);
|
|
/* check the offset */
|
|
assert_int_equal (offset, 10 + 2 + 4);
|
|
|
|
size_ptr = (uint16_t *) (buffer + offset);
|
|
ptr = (uint32_t *) (buffer + offset + 4);
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Marshal(&point, buffer, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
/*
|
|
* size_ptr points to the size of the whole TPMS_ECC_POINT:
|
|
* sizeof(unit16) + sizeof(value) + sizeof(unit16) + sizeof(value2)
|
|
*/
|
|
assert_int_equal (*size_ptr, HOST_TO_BE_16(2 + 4 + 2 + 8));
|
|
/* check point.x: */
|
|
assert_int_equal (*(size_ptr + 1), HOST_TO_BE_16(4));
|
|
assert_int_equal (*ptr, value);
|
|
size_ptr = (uint16_t *) (buffer + 10 + 2 + 4 + 2 + 2 + 4);
|
|
ptr2 = (uint64_t *) (buffer + 10 + 2 + 4 + 2 + 2 + 4 + 2);
|
|
|
|
/* check point.y: */
|
|
assert_int_equal (*size_ptr, HOST_TO_BE_16(8));
|
|
assert_int_equal (*ptr2, value2);
|
|
/* check the offset */
|
|
assert_int_equal (offset, 10 + 2 + 4 + 2 + 2 + 4 + 2 + 8);
|
|
}
|
|
|
|
/*
|
|
* Success case with a null buffer
|
|
*/
|
|
static void
|
|
tpm2b_marshal_buffer_null_with_offset(void **state)
|
|
{
|
|
TPM2B_DIGEST dgst = {4, {0}};
|
|
TPM2B_ECC_POINT point = {0};
|
|
size_t offset = 10;
|
|
size_t buffer_size = sizeof(dgst) + sizeof(point) + 10;
|
|
uint32_t value = 0xdeadbeef;
|
|
uint64_t value2 = 0xdeadbeefdeadbeefULL;
|
|
|
|
TSS2_RC rc;
|
|
|
|
memcpy(dgst.buffer, &value, sizeof(value));
|
|
memcpy(point.point.x.buffer, &value, sizeof(value));
|
|
point.point.x.size = sizeof(value);
|
|
memcpy(point.point.y.buffer, &value2, sizeof(value2));
|
|
point.point.y.size = sizeof(value2);
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, NULL, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (offset, 10 + 2 + 4);
|
|
|
|
offset = 10;
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Marshal(&point, NULL, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (offset, 10 + 2 + 2 + sizeof(value) + 2 + sizeof(value2));
|
|
offset = 0;
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, NULL, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
/*
|
|
* TSS MU spec states:
|
|
* If the 'buffer' parameter is NULL the implementation shall not write
|
|
* any marshaled data but the 'offset' parameter shall be updated as
|
|
* though it had.
|
|
* The offset of call with NULL and not NULL buffer will be compared.
|
|
*/
|
|
uint8_t buffer[offset];
|
|
|
|
size_t offset1 = 0;
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, NULL, buffer_size, &offset1);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
|
|
size_t offset2 = 0;
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, buffer, buffer_size, &offset2);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal(offset1, offset2);
|
|
|
|
}
|
|
|
|
/*
|
|
* Invalid case with a null buffer and a null offset
|
|
*/
|
|
static void
|
|
tpm2b_marshal_buffer_null_offset_null(void **state)
|
|
{
|
|
TPM2B_DIGEST dgst = {4, {0}};
|
|
TPM2B_ECC_POINT point = {0};
|
|
size_t buffer_size = 1024;
|
|
TSS2_RC rc;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, NULL, buffer_size, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Marshal(&point, NULL, buffer_size, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
}
|
|
|
|
/*
|
|
* Invalid case with not big enough buffer
|
|
*/
|
|
static void
|
|
tpm2b_marshal_buffer_size_lt_data_nad_lt_offset(void **state) {
|
|
TPM2B_DIGEST dgst = {4, {0}};
|
|
TPM2B_ECC_POINT point = {0};
|
|
size_t offset = 10;
|
|
uint8_t buffer[sizeof(dgst) + sizeof(point)] = {0};
|
|
size_t buffer_size = sizeof(buffer);
|
|
uint32_t value = 0xdeadbeef;
|
|
uint64_t value2 = 0xdeadbeefdeadbeefULL;
|
|
TSS2_RC rc;
|
|
|
|
memcpy(dgst.buffer, &value, sizeof(value));
|
|
memcpy(point.point.x.buffer, &value, sizeof(value));
|
|
point.point.x.size = sizeof(value);
|
|
memcpy(point.point.y.buffer, &value2, sizeof(value2));
|
|
point.point.y.size = sizeof(value2);
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Marshal(&dgst, buffer, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Marshal(&point, buffer, buffer_size, &offset);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
}
|
|
|
|
/*
|
|
* Unmarshal success case
|
|
*/
|
|
static void
|
|
tpm2b_unmarshal_success(void **state)
|
|
{
|
|
TPM2B_DIGEST dgst = {0};
|
|
TPM2B_ECC_POINT point = {0};
|
|
size_t offset = 0;
|
|
uint8_t buffer[] = { 0x00, 0x04, 0xef, 0xbe, 0xad, 0xde, /* digest of 4 bytes */
|
|
0x00, 0x0c, /* size of TPM2B_ECC_POINT */
|
|
0x00, 0x04, 0xef, 0xbe, 0xad, 0xde, /* ECC_POINT.x - 4 bytes */
|
|
0x00, 0x04, 0x44, 0x33, 0x22, 0x11 }; /* ECC_POINT.y - 4 bytes */
|
|
|
|
size_t buffer_size = sizeof(buffer);
|
|
uint32_t value = 0xdeadbeef;
|
|
uint32_t value2 = 0x11223344;
|
|
uint32_t val;
|
|
TSS2_RC rc;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal(buffer, buffer_size, &offset, &dgst);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (dgst.size, 4);
|
|
memcpy(&val, dgst.buffer, sizeof(val));
|
|
assert_int_equal (le32toh(val), value);
|
|
assert_int_equal (offset, 6);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal(buffer, buffer_size, &offset, &point);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (point.point.x.size, 4);
|
|
memcpy(&val, point.point.x.buffer, sizeof(val));
|
|
assert_int_equal (le32toh(val), value);
|
|
assert_int_equal (point.point.y.size, 4);
|
|
memcpy(&val, point.point.y.buffer, sizeof(val));
|
|
assert_int_equal (le32toh(val), value2);
|
|
assert_int_equal (offset, 20);
|
|
}
|
|
|
|
/*
|
|
* Unmarshal success case with offset
|
|
*/
|
|
static void
|
|
tpm2b_unmarshal_success_offset(void **state)
|
|
{
|
|
TPM2B_DIGEST dgst = {0};
|
|
TPM2B_ECC_POINT point = {0};
|
|
size_t offset = 6;
|
|
uint8_t buffer[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, /* random 6 bytes offset */
|
|
0x00, 0x04, 0xef, 0xbe, 0xad, 0xde, /* digest of 4 bytes */
|
|
0x00, 0x10, /* size of TPM2B_ECC_POINT - 16 bytes */
|
|
0x00, 0x08, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, /* ECC_POINT.x - 8 bytes */
|
|
0x00, 0x04, 0x44, 0x33, 0x22, 0x11 }; /* ECC_POINT.y - 4 bytes */
|
|
|
|
size_t buffer_size = sizeof(buffer);
|
|
uint32_t value = 0xdeadbeef;
|
|
uint64_t value2 = 0xdeadbeefdeadbeefULL;
|
|
uint32_t value3 = 0x11223344;
|
|
uint32_t val;
|
|
uint64_t val2;
|
|
TSS2_RC rc;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal(buffer, buffer_size, &offset, &dgst);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (dgst.size, 4);
|
|
memcpy(&val, dgst.buffer, sizeof(val));
|
|
assert_int_equal (le32toh(val), value);
|
|
assert_int_equal (offset, 12);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal(buffer, buffer_size, &offset, &point);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (point.point.x.size, 8);
|
|
memcpy(&val2, point.point.x.buffer, sizeof(val2));
|
|
assert_int_equal (le64toh(val2), value2);
|
|
assert_int_equal (point.point.y.size, 4);
|
|
memcpy(&val, point.point.y.buffer, sizeof(val));
|
|
assert_int_equal (le32toh(val), value3);
|
|
assert_int_equal (offset, 30);
|
|
}
|
|
|
|
/*
|
|
* Test case ensures a NULL buffer parameter produces a BAD_REFERENCE RC.
|
|
*/
|
|
void
|
|
tpm2b_unmarshal_buffer_null (void **state)
|
|
{
|
|
TPM2B_DIGEST dgst = {0};
|
|
TPM2B_ECC_POINT point = {0};
|
|
TSS2_RC rc;
|
|
size_t offset = 0;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal (NULL, 1, NULL, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal (NULL, 1, NULL, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal (NULL, 1, &offset, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal (NULL, 1, &offset, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal (NULL, 1, NULL, &dgst);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal (NULL, 1, NULL, &point);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
}
|
|
/*
|
|
* Test case ensures a NULL dest and offset parameters produce an
|
|
* INSUFFICIENT_BUFFER RC.
|
|
*/
|
|
void
|
|
tpm2b_unmarshal_dest_null (void **state)
|
|
{
|
|
uint8_t buffer [1];
|
|
TSS2_RC rc;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, sizeof (buffer), NULL, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal (buffer, 1, NULL, NULL);
|
|
assert_int_equal (rc, TSS2_MU_RC_BAD_REFERENCE);
|
|
}
|
|
|
|
/*
|
|
* Test case ensures the offset is updated when dest is NULL
|
|
* and offset is valid
|
|
*/
|
|
void
|
|
tpm2b_unmarshal_dest_null_offset_valid (void **state)
|
|
{
|
|
size_t offset = 0;
|
|
uint8_t buffer[] = { 0x00, 0x04, 0xef, 0xbe, 0xad, 0xde, /* digest of 4 bytes */
|
|
0x00, 0x10, /* size of TPM2B_ECC_POINT - 16 bytes */
|
|
0x00, 0x08, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, /* ECC_POINT.x - 8 bytes */
|
|
0x00, 0x04, 0x44, 0x33, 0x22, 0x11 }; /* ECC_POINT.y - 4 bytes */
|
|
TSS2_RC rc;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, sizeof (buffer), &offset, NULL);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (offset, 6);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal (buffer, sizeof (buffer), &offset, NULL);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
assert_int_equal (offset, 24);
|
|
}
|
|
|
|
/*
|
|
* Invalid case with not big enough buffer
|
|
*/
|
|
static void
|
|
tpm2b_unmarshal_buffer_size_lt_data_nad_lt_offset(void **state)
|
|
{
|
|
TPM2B_DIGEST dgst = {4, {0x00, 0x01, 0x02, 0x03}};
|
|
TPM2B_ECC_POINT point = {0};
|
|
uint8_t buffer[sizeof(dgst) + sizeof(point)] = { 0 };
|
|
size_t offset = sizeof(dgst) - 5;
|
|
TSS2_RC rc;
|
|
|
|
rc = Tss2_MU_TPM2B_DIGEST_Unmarshal (buffer, 6, &offset, &dgst);
|
|
assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
|
|
assert_int_equal (offset, sizeof(dgst) - 5);
|
|
|
|
rc = Tss2_MU_TPM2B_ECC_POINT_Unmarshal (buffer, 1, &offset, &point);
|
|
assert_int_equal (rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
|
|
assert_int_equal (offset, sizeof(dgst) - 5);
|
|
}
|
|
|
|
/*
|
|
* Success case
|
|
*/
|
|
static void
|
|
tpm2b_public_rsa_marshal_success(void **state) {
|
|
TPM2B_PUBLIC pub2b = {0};
|
|
TPMT_PUBLIC *pub = &pub2b.publicArea;
|
|
uint8_t buffer[sizeof(pub2b)] = { 0 };
|
|
size_t buffer_size = sizeof(buffer);
|
|
TPM2B_PUBLIC *ptr1;
|
|
TSS2_RC rc;
|
|
|
|
pub->type = TPM2_ALG_RSA;
|
|
pub->parameters.rsaDetail.symmetric.algorithm = TPM2_ALG_AES;
|
|
pub->parameters.rsaDetail.symmetric.keyBits.aes = 128;
|
|
pub->parameters.rsaDetail.symmetric.mode.aes = TPM2_ALG_CBC;
|
|
rc = Tss2_MU_TPM2B_PUBLIC_Marshal(&pub2b, buffer, buffer_size, NULL);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
ptr1 = (TPM2B_PUBLIC *)buffer;
|
|
assert_int_equal (ptr1->size, HOST_TO_BE_16(0x1a));
|
|
}
|
|
|
|
/*
|
|
* Success case
|
|
*/
|
|
static void
|
|
tpm2b_public_rsa_unique_size_marshal_success(void **state) {
|
|
TPM2B_PUBLIC pub2b = {0};
|
|
TPMT_PUBLIC *pub = &pub2b.publicArea;
|
|
uint8_t buffer[sizeof(pub2b)] = { 0 };
|
|
size_t buffer_size = sizeof(buffer);
|
|
TPM2B_PUBLIC *ptr1;
|
|
TSS2_RC rc;
|
|
|
|
pub->type = TPM2_ALG_RSA;
|
|
pub->parameters.rsaDetail.symmetric.algorithm = TPM2_ALG_AES;
|
|
pub->parameters.rsaDetail.symmetric.keyBits.aes = 128;
|
|
pub->parameters.rsaDetail.symmetric.mode.aes = TPM2_ALG_CBC;
|
|
pub->unique.rsa.size = 0x100;
|
|
rc = Tss2_MU_TPM2B_PUBLIC_Marshal(&pub2b, buffer, buffer_size, NULL);
|
|
assert_int_equal (rc, TSS2_RC_SUCCESS);
|
|
ptr1 = (TPM2B_PUBLIC *)buffer;
|
|
assert_int_equal (ptr1->size, HOST_TO_BE_16(0x11a));
|
|
}
|
|
|
|
int main(void) {
|
|
const struct CMUnitTest tests[] = {
|
|
cmocka_unit_test(tpm2b_marshal_success),
|
|
cmocka_unit_test(tpm2b_marshal_success_offset),
|
|
cmocka_unit_test(tpm2b_marshal_buffer_null_with_offset),
|
|
cmocka_unit_test(tpm2b_marshal_buffer_null_offset_null),
|
|
cmocka_unit_test(tpm2b_marshal_buffer_size_lt_data_nad_lt_offset),
|
|
cmocka_unit_test(tpm2b_unmarshal_success),
|
|
cmocka_unit_test(tpm2b_unmarshal_success_offset),
|
|
cmocka_unit_test(tpm2b_unmarshal_buffer_null),
|
|
cmocka_unit_test(tpm2b_unmarshal_dest_null),
|
|
cmocka_unit_test(tpm2b_unmarshal_dest_null_offset_valid),
|
|
cmocka_unit_test(tpm2b_unmarshal_buffer_size_lt_data_nad_lt_offset),
|
|
cmocka_unit_test(tpm2b_public_rsa_marshal_success),
|
|
cmocka_unit_test(tpm2b_public_rsa_unique_size_marshal_success),
|
|
};
|
|
return cmocka_run_group_tests(tests, NULL, NULL);
|
|
}
|