/* SPDX-License-Identifier: BSD-2-Clause */ /*********************************************************************** * Copyright (c) 2017-2018, Intel Corporation * * All rights reserved. ***********************************************************************/ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #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); }