/* SPDX-License-Identifier: BSD-2-Clause */
/***********************************************************************
 * Copyright (c) 2017-2018, Intel Corporation
 *
 * All rights reserved.
 ***********************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h" // IWYU pragma: keep
#endif

#include <stddef.h> // for NULL, size_t
#include <stdint.h> // for uint8_t

#include "../helper/cmocka_all.h" // for assert_int_equal, cmocka_unit_test
#include "tss2_common.h"          // for BYTE, TSS2_RC, TSS2_RC_SUCCESS, TSS2_M...
#include "tss2_mu.h"              // for Tss2_MU_TPMT_PUBLIC_PARMS_Unmarshal
#include "tss2_tpm2_types.h"      // for TPMT_TK_CREATION, TPM2B_DIGEST, TPMT_P...
#include "util/tss2_endian.h"     // for HOST_TO_BE_16, HOST_TO_BE_32

/*
 * Success case
 */
static void
tpmt_marshal_success(void **state) {
    TPMT_TK_CREATION   tkt = { 0 };
    TPMT_PUBLIC        pub = { 0 };
    uint8_t            buffer[sizeof(tkt) + sizeof(pub)] = { 0 };
    size_t             buffer_size = sizeof(buffer);
    TPMT_TK_CREATION  *ptr;
    TPMI_RH_HIERARCHY *ptr2;
    TPM2B_DIGEST      *ptr3;
    TPMT_PUBLIC       *ptr4;
    TPMU_PUBLIC_PARMS *ptr5;
    TSS2_RC            rc;

    tkt.tag = 0xbeef;
    tkt.hierarchy = TPM2_RH_OWNER;
    tkt.digest.size = 4;
    tkt.digest.buffer[0] = 0xde;
    tkt.digest.buffer[1] = 0xad;
    tkt.digest.buffer[2] = 0xbe;
    tkt.digest.buffer[3] = 0xef;
    rc = Tss2_MU_TPMT_TK_CREATION_Marshal(&tkt, buffer, buffer_size, NULL);
    assert_int_equal(rc, TSS2_RC_SUCCESS);

    ptr = (TPMT_TK_CREATION *)buffer;
    ptr2 = (TPMI_RH_HIERARCHY *)(buffer + sizeof(tkt.tag));
    ptr3 = (TPM2B_DIGEST *)(buffer + sizeof(tkt.tag) + sizeof(tkt.hierarchy));

    assert_int_equal(ptr->tag, HOST_TO_BE_16(0xbeef));
    assert_int_equal(*ptr2, HOST_TO_BE_32(TPM2_RH_OWNER));
    assert_int_equal(ptr3->size, HOST_TO_BE_16(4));
    assert_int_equal(ptr3->buffer[0], 0xde);
    assert_int_equal(ptr3->buffer[1], 0xad);
    assert_int_equal(ptr3->buffer[2], 0xbe);
    assert_int_equal(ptr3->buffer[3], 0xef);

    pub.type = TPM2_ALG_RSA;
    pub.nameAlg = TPM2_ALG_SHA1;
    pub.parameters.symDetail.sym.algorithm = TPM2_ALG_NULL;
    pub.parameters.rsaDetail.scheme.scheme = TPM2_ALG_NULL;
    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_TPMT_PUBLIC_Marshal(&pub, buffer, buffer_size, NULL);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    ptr4 = (TPMT_PUBLIC *)buffer;
    ptr5 = (TPMU_PUBLIC_PARMS *)(buffer + sizeof(TPMI_ALG_PUBLIC) + sizeof(TPMI_ALG_HASH)
                                 + sizeof(TPMA_OBJECT) + 2);
    assert_int_equal(ptr4->type, HOST_TO_BE_16(TPM2_ALG_RSA));
    assert_int_equal(ptr5->rsaDetail.symmetric.algorithm, HOST_TO_BE_16(TPM2_ALG_AES));
    assert_int_equal(ptr5->rsaDetail.symmetric.keyBits.aes, HOST_TO_BE_16(128));
    assert_int_equal(ptr5->rsaDetail.symmetric.mode.aes, HOST_TO_BE_16(TPM2_ALG_CBC));
}
/*
 * Success case with a valid offset
 */
static void
tpmt_marshal_success_offset(void **state) {
    TPMT_TK_CREATION      tkt = { 0 };
    TPMT_PUBLIC_PARMS     pub = { 0 };
    uint8_t               buffer[sizeof(tkt) + sizeof(pub) + 10] = { 0 };
    size_t                buffer_size = sizeof(buffer);
    TPMT_TK_CREATION     *ptr;
    TPMI_RH_HIERARCHY    *ptr2;
    TPM2B_DIGEST         *ptr3;
    TPMT_PUBLIC_PARMS    *ptr4;
    TPMS_KEYEDHASH_PARMS *ptr5;
    size_t                offset = 10;
    TSS2_RC               rc;

    tkt.tag = 0xbeef;
    tkt.hierarchy = TPM2_RH_OWNER;
    tkt.digest.size = 4;
    tkt.digest.buffer[0] = 0xde;
    tkt.digest.buffer[1] = 0xad;
    tkt.digest.buffer[2] = 0xbe;
    tkt.digest.buffer[3] = 0xef;
    rc = Tss2_MU_TPMT_TK_CREATION_Marshal(&tkt, buffer, buffer_size, &offset);
    assert_int_equal(rc, TSS2_RC_SUCCESS);

    ptr = (TPMT_TK_CREATION *)(buffer + 10);
    ptr2 = (TPMI_RH_HIERARCHY *)(buffer + 10 + sizeof(tkt.tag));
    ptr3 = (TPM2B_DIGEST *)(buffer + 10 + sizeof(tkt.tag) + sizeof(tkt.hierarchy));

    assert_int_equal(ptr->tag, HOST_TO_BE_16(0xbeef));
    assert_int_equal(*ptr2, HOST_TO_BE_32(TPM2_RH_OWNER));
    assert_int_equal(ptr3->size, HOST_TO_BE_16(4));
    assert_int_equal(ptr3->buffer[0], 0xde);
    assert_int_equal(ptr3->buffer[1], 0xad);
    assert_int_equal(ptr3->buffer[2], 0xbe);
    assert_int_equal(ptr3->buffer[3], 0xef);
    assert_int_equal(offset, 10 + 2 + 4 + 2 + 1 + 1 + 1 + 1);

    offset = 10;
    pub.type = TPM2_ALG_KEYEDHASH;
    pub.parameters.keyedHashDetail.scheme.scheme = TPM2_ALG_HMAC;
    pub.parameters.keyedHashDetail.scheme.details.hmac.hashAlg = TPM2_ALG_SHA256;

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Marshal(&pub, buffer, buffer_size, &offset);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    ptr4 = (TPMT_PUBLIC_PARMS *)(buffer + 10);
    ptr5 = (TPMS_KEYEDHASH_PARMS *)(buffer + 10 + 2);
    assert_int_equal(ptr4->type, HOST_TO_BE_16(TPM2_ALG_KEYEDHASH));
    assert_int_equal(ptr5->scheme.scheme, HOST_TO_BE_16(TPM2_ALG_HMAC));
    assert_int_equal(ptr5->scheme.details.hmac.hashAlg, HOST_TO_BE_16(TPM2_ALG_SHA256));
    assert_int_equal(offset, 10 + 2 + 2 + 2);
}

/*
 * Success case with a null buffer
 */
static void
tpmt_marshal_buffer_null_with_offset(void **state) {
    TPMT_TK_CREATION  tkt = { 0 };
    TPMT_PUBLIC_PARMS pub = { 0 };
    size_t            buffer_size = sizeof(tkt) + sizeof(pub) + 10;
    size_t            offset = 10;
    TSS2_RC           rc;

    tkt.tag = 0xbeef;
    tkt.hierarchy = TPM2_RH_OWNER;
    tkt.digest.size = 4;
    tkt.digest.buffer[0] = 0xde;
    tkt.digest.buffer[1] = 0xad;
    tkt.digest.buffer[2] = 0xbe;
    tkt.digest.buffer[3] = 0xef;
    rc = Tss2_MU_TPMT_TK_CREATION_Marshal(&tkt, NULL, buffer_size, &offset);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    assert_int_equal(offset, 10 + 2 + 4 + 2 + 1 + 1 + 1 + 1);

    offset = 10;
    pub.type = TPM2_ALG_KEYEDHASH;
    pub.parameters.keyedHashDetail.scheme.scheme = TPM2_ALG_HMAC;
    pub.parameters.keyedHashDetail.scheme.details.hmac.hashAlg = TPM2_ALG_SHA256;

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Marshal(&pub, NULL, buffer_size, &offset);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    assert_int_equal(offset, 10 + 2 + 2 + 2);
}

/*
 * Invalid case with a null buffer and a null offset
 */
static void
tpmt_marshal_buffer_null_offset_null(void **state) {
    TPMT_TK_CREATION  tkt = { 0 };
    TPMT_PUBLIC_PARMS pub = { 0 };
    TSS2_RC           rc;

    rc = Tss2_MU_TPMT_TK_CREATION_Marshal(&tkt, NULL, sizeof(tkt), NULL);
    assert_int_equal(rc, TSS2_MU_RC_BAD_REFERENCE);

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Marshal(&pub, NULL, sizeof(pub), NULL);
    assert_int_equal(rc, TSS2_MU_RC_BAD_REFERENCE);
}

/*
 * Invalid case with not big enough buffer
 */
static void
tpmt_marshal_buffer_size_lt_data_nad_lt_offset(void **state) {
    TPMT_TK_CREATION  tkt = { 0 };
    TPMT_PUBLIC_PARMS pub = { 0 };
    uint8_t           buffer[sizeof(tkt) + sizeof(pub) + 10] = { 0 };
    size_t            offset = 10;
    TSS2_RC           rc;

    tkt.tag = 0xbeef;
    tkt.hierarchy = TPM2_RH_OWNER;
    tkt.digest.size = 4;
    tkt.digest.buffer[0] = 0xde;
    tkt.digest.buffer[1] = 0xad;
    tkt.digest.buffer[2] = 0xbe;
    tkt.digest.buffer[3] = 0xef;
    rc = Tss2_MU_TPMT_TK_CREATION_Marshal(&tkt, buffer, 10, &offset);
    assert_int_equal(rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
    assert_int_equal(offset, 10);

    pub.type = TPM2_ALG_KEYEDHASH;
    pub.parameters.keyedHashDetail.scheme.scheme = TPM2_ALG_HMAC;
    pub.parameters.keyedHashDetail.scheme.details.hmac.hashAlg = TPM2_ALG_SHA256;

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Marshal(&pub, buffer, 8, &offset);
    assert_int_equal(rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
    assert_int_equal(offset, 10);
}

/*
 * Success case
 */
static void
tpmt_unmarshal_success(void **state) {
    TPMT_TK_CREATION      tkt = { 0 };
    TPMT_PUBLIC_PARMS     pub = { 0 };
    uint8_t               buffer[sizeof(tkt) + sizeof(pub)] = { 0 };
    size_t                buffer_size = sizeof(buffer);
    TPMT_TK_CREATION     *ptr;
    TPMI_RH_HIERARCHY    *ptr2;
    TPM2B_DIGEST         *ptr3;
    TPMT_PUBLIC_PARMS    *ptr4;
    TPMS_KEYEDHASH_PARMS *ptr5;
    size_t                offset = 0;
    TSS2_RC               rc;

    ptr = (TPMT_TK_CREATION *)(buffer);
    ptr2 = (TPMI_RH_HIERARCHY *)(buffer + sizeof(tkt.tag));
    ptr3 = (TPM2B_DIGEST *)(buffer + sizeof(tkt.tag) + sizeof(tkt.hierarchy));

    ptr->tag = HOST_TO_BE_16(0xbeef);
    *ptr2 = HOST_TO_BE_32(TPM2_RH_OWNER);
    ptr3->size = HOST_TO_BE_16(4);
    ptr3->buffer[0] = 0xde;
    ptr3->buffer[1] = 0xad;
    ptr3->buffer[2] = 0xbe;
    ptr3->buffer[3] = 0xef;

    rc = Tss2_MU_TPMT_TK_CREATION_Unmarshal(buffer, buffer_size, &offset, &tkt);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    assert_int_equal(tkt.tag, 0xbeef);
    assert_int_equal(tkt.hierarchy, TPM2_RH_OWNER);
    assert_int_equal(tkt.digest.size, 4);
    assert_int_equal(tkt.digest.buffer[0], 0xde);
    assert_int_equal(tkt.digest.buffer[1], 0xad);
    assert_int_equal(tkt.digest.buffer[2], 0xbe);
    assert_int_equal(tkt.digest.buffer[3], 0xef);
    assert_int_equal(offset, 2 + 4 + 2 + 1 + 1 + 1 + 1);

    offset = 0;
    ptr4 = (TPMT_PUBLIC_PARMS *)(buffer);
    ptr5 = (TPMS_KEYEDHASH_PARMS *)(buffer + 2);
    ptr4->type = HOST_TO_BE_16(TPM2_ALG_KEYEDHASH);
    ptr5->scheme.scheme = HOST_TO_BE_16(TPM2_ALG_HMAC);
    ptr5->scheme.details.hmac.hashAlg = HOST_TO_BE_16(TPM2_ALG_SHA256);

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Unmarshal(buffer, buffer_size, &offset, &pub);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    assert_int_equal(pub.type, TPM2_ALG_KEYEDHASH);
    assert_int_equal(pub.parameters.keyedHashDetail.scheme.scheme, TPM2_ALG_HMAC);
    assert_int_equal(pub.parameters.keyedHashDetail.scheme.details.hmac.hashAlg, TPM2_ALG_SHA256);
    assert_int_equal(offset, 2 + 2 + 2);
}

/*
 * Invalid test case with buffer null and dest null
 */
static void
tpmt_unmarshal_dest_null_buff_null(void **state) {
    size_t  offset = 1;
    TSS2_RC rc;

    rc = Tss2_MU_TPMT_TK_CREATION_Unmarshal(NULL, 120, &offset, NULL);
    assert_int_equal(rc, TSS2_MU_RC_BAD_REFERENCE);
    assert_int_equal(offset, 1);

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Unmarshal(NULL, 120, &offset, NULL);
    assert_int_equal(rc, TSS2_MU_RC_BAD_REFERENCE);
    assert_int_equal(offset, 1);
}

/*
 * Invalid test case with offset null and dest null
 */
static void
tpmt_unmarshal_buffer_null_offset_null(void **state) {
    uint8_t buffer[sizeof(TPMT_TK_CREATION) + sizeof(TPMT_PUBLIC_PARMS)] = { 0 };
    size_t  buffer_size = sizeof(buffer);
    TSS2_RC rc;

    rc = Tss2_MU_TPMT_TK_CREATION_Unmarshal(buffer, buffer_size, NULL, NULL);
    assert_int_equal(rc, TSS2_MU_RC_BAD_REFERENCE);

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Unmarshal(buffer, buffer_size, 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
 */
static void
tpmt_unmarshal_dest_null_offset_valid(void **state) {
    TPMT_TK_CREATION      tkt;
    uint8_t               buffer[sizeof(tkt) + sizeof(TPMT_PUBLIC_PARMS)] = { 0 };
    size_t                buffer_size = sizeof(buffer);
    TPMT_TK_CREATION     *ptr;
    TPMI_RH_HIERARCHY    *ptr2;
    TPM2B_DIGEST         *ptr3;
    TPMT_PUBLIC_PARMS    *ptr4;
    TPMS_KEYEDHASH_PARMS *ptr5;
    size_t                offset = 0;
    TSS2_RC               rc;

    ptr = (TPMT_TK_CREATION *)(buffer);
    ptr2 = (TPMI_RH_HIERARCHY *)(buffer + sizeof(tkt.tag));
    ptr3 = (TPM2B_DIGEST *)(buffer + sizeof(tkt.tag) + sizeof(tkt.hierarchy));

    ptr->tag = HOST_TO_BE_16(0xbeef);
    *ptr2 = HOST_TO_BE_32(TPM2_RH_OWNER);
    ptr3->size = HOST_TO_BE_16(4);
    ptr3->buffer[0] = 0xde;
    ptr3->buffer[1] = 0xad;
    ptr3->buffer[2] = 0xbe;
    ptr3->buffer[3] = 0xef;

    rc = Tss2_MU_TPMT_TK_CREATION_Unmarshal(buffer, buffer_size, &offset, NULL);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    assert_int_equal(offset, 2 + 4 + 2 + 1 + 1 + 1 + 1);

    offset = 0;
    ptr4 = (TPMT_PUBLIC_PARMS *)(buffer);
    ptr5 = (TPMS_KEYEDHASH_PARMS *)(buffer + 2);
    ptr4->type = HOST_TO_BE_16(TPM2_ALG_KEYEDHASH);
    ptr5->scheme.scheme = HOST_TO_BE_16(TPM2_ALG_HMAC);
    ptr5->scheme.details.hmac.hashAlg = HOST_TO_BE_16(TPM2_ALG_SHA256);

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Unmarshal(buffer, buffer_size, &offset, NULL);
    assert_int_equal(rc, TSS2_RC_SUCCESS);
    assert_int_equal(offset, 2 + 2 + 2);
}

/*
 * Invalid case with not big enough buffer. Make sure offest is untouched.
 */
static void
tpmt_unmarshal_buffer_size_lt_data_nad_lt_offset(void **state) {
    TPMT_TK_CREATION      tkt;
    uint8_t               buffer[sizeof(tkt) + sizeof(TPMT_PUBLIC_PARMS)] = { 0 };
    TPMT_TK_CREATION     *ptr;
    TPMI_RH_HIERARCHY    *ptr2;
    TPM2B_DIGEST         *ptr3;
    TPMT_PUBLIC_PARMS    *ptr4;
    TPMS_KEYEDHASH_PARMS *ptr5;
    size_t                offset = 5;
    TSS2_RC               rc;

    ptr = (TPMT_TK_CREATION *)(buffer);
    ptr2 = (TPMI_RH_HIERARCHY *)(buffer + sizeof(tkt.tag));
    ptr3 = (TPM2B_DIGEST *)(buffer + sizeof(tkt.tag) + sizeof(tkt.hierarchy));

    ptr->tag = HOST_TO_BE_16(0xbeef);
    *ptr2 = HOST_TO_BE_32(TPM2_RH_OWNER);
    ptr3->size = HOST_TO_BE_16(4);
    ptr3->buffer[0] = 0xde;
    ptr3->buffer[1] = 0xad;
    ptr3->buffer[2] = 0xbe;
    ptr3->buffer[3] = 0xef;
    rc = Tss2_MU_TPMT_TK_CREATION_Unmarshal(buffer, 15, &offset, NULL);
    assert_int_equal(rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
    assert_int_equal(offset, 5);

    offset = 5;
    ptr4 = (TPMT_PUBLIC_PARMS *)(buffer);
    ptr5 = (TPMS_KEYEDHASH_PARMS *)(buffer + 2);
    ptr4->type = HOST_TO_BE_16(TPM2_ALG_KEYEDHASH);
    ptr5->scheme.scheme = HOST_TO_BE_16(TPM2_ALG_HMAC);
    ptr5->scheme.details.hmac.hashAlg = HOST_TO_BE_16(TPM2_ALG_SHA256);

    rc = Tss2_MU_TPMT_PUBLIC_PARMS_Unmarshal(buffer, 6, &offset, NULL);
    assert_int_equal(rc, TSS2_MU_RC_INSUFFICIENT_BUFFER);
    assert_int_equal(offset, 5);
}

static void
tpmt_marshal_unmarshal_sig_invalid_selector(void **state) {
    TPMT_SIGNATURE sig = { 0 };
    uint8_t        buf[256] = { 0 };
    size_t         size = 256, offset = 0;
    TPM2_ALG_ID    invalid_id = HOST_TO_BE_16(0xbeef);
    TPM2_RC        rc;

    sig.sigAlg = invalid_id;

    /* Marshal with invalid selector case */
    rc = Tss2_MU_TPMT_SIGNATURE_Marshal(&sig, buf, sizeof(sig), &offset);
    assert_int_equal(rc, TSS2_MU_RC_BAD_VALUE);
    assert_int_equal(offset, 0);

    /* Unarshal with invalid selector case */
    rc = Tss2_MU_TPMT_SIGNATURE_Unmarshal(buf, size, &offset, &sig);
    assert_int_equal(rc, TSS2_MU_RC_BAD_VALUE);
    assert_int_equal(offset, 0);
}

int
main(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(tpmt_marshal_success),
        cmocka_unit_test(tpmt_marshal_success_offset),
        cmocka_unit_test(tpmt_marshal_buffer_null_with_offset),
        cmocka_unit_test(tpmt_marshal_buffer_null_offset_null),
        cmocka_unit_test(tpmt_marshal_buffer_size_lt_data_nad_lt_offset),
        cmocka_unit_test(tpmt_marshal_unmarshal_sig_invalid_selector),
        cmocka_unit_test(tpmt_unmarshal_success),
        cmocka_unit_test(tpmt_unmarshal_dest_null_buff_null),
        cmocka_unit_test(tpmt_unmarshal_buffer_null_offset_null),
        cmocka_unit_test(tpmt_unmarshal_dest_null_offset_valid),
        cmocka_unit_test(tpmt_unmarshal_buffer_size_lt_data_nad_lt_offset),
    };
    return cmocka_run_group_tests(tests, NULL, NULL);
}
