/*
* Copyright 2020 NXP
*
* SPDX-License-Identifier: Apache-2.0
*/

#include "se05x_ImportExternalObjectPrepare.h"

#include <ex_sss_boot.h>
#include <fsl_sss_se05x_policy.h>
#include <nxEnsure.h>
#include <nxLog_App.h>
#include <nxScp03_Apis.h>
#include <nxScp03_Const.h>
#include <se05x_APDU.h>
#include <se05x_tlv.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <smCom.h>

#include "fsl_sss_util_asn1_der.h"
#include "smCom.h"

static ex_sss_boot_ctx_t gex_sss_import_external_prepare;
uint8_t gTxBuffer[SE05X_MAX_BUF_SIZE_CMD];
size_t gTxBufferLen;
Se05xSession_t *pgSe05xSessionCtx;

#define EX_SSS_BOOT_PCONTEXT (&gex_sss_import_external_prepare)
#define EX_SSS_BOOT_DO_ERASE 0
#define EX_SSS_BOOT_EXPOSE_ARGC_ARGV 1
#define EX_SSS_BOOT_SKIP_SELECT_APPLET 1

#include <ex_sss_main_inc.h>

void usage()
{
    LOG_W(
        "\n\
    Usage:\n\
    se05x_ImportExternalObjectPrepare.exe \n\
        -keyid <ECDSA auth object id>\n\
        -file  <Input ECDSA keypair file>");
    return;
}

static sss_status_t parse_command_line_args(int argc, const char **argv);
static sss_status_t calculate_shared_secret(ex_sss_boot_ctx_t *pCtx);
static sss_status_t calculate_master_secret(ex_sss_boot_ctx_t *pCtx);
static sss_status_t nxECKey_HostLocal_CalculateSessionKeys(ex_sss_boot_ctx_t *pCtx);
static sss_status_t nxECKey_Calculate_Initial_Mac_Chaining_Value(ex_sss_boot_ctx_t *pCtx);

static sss_status_t read_se_ecka_and_store(ex_sss_boot_ctx_t *pCtx);
static sss_status_t generate_tee_ecka_and_export(ex_sss_boot_ctx_t *pCtx,
    uint8_t *pk_tee_ecka,
    size_t *pk_tee_ecka_len,
    size_t *publicKeyLen,
    uint16_t *outKeyIndex);
static sss_status_t store_ecdsa_key(ex_sss_boot_ctx_t *pCtx);
static sss_status_t create_internal_auth_data(ex_sss_boot_ctx_t *pCtx,
    uint8_t *p_to_be_signed_buf,
    size_t *to_be_signed_len,
    uint8_t *pk_tee_ecka,
    size_t publicKeyLen);

smStatus_t se05x_ImportExtObjTransformBuffer(Se05xSession_t *pwrite_apdubufferctx,
    const tlvHeader_t *hdr,
    uint8_t *cmdBuf,
    size_t cmdBufLen,
    uint8_t *rsp,
    size_t *rspLen,
    uint8_t hasle);

smStatus_t se05x_ImportExtObjCreateAPDU(Se05xSession_t *pwrite_apdubufferctx,
    const tlvHeader_t *hdr,
    uint8_t *cmdBuf,
    size_t cmdBufLen,
    uint8_t *rsp,
    size_t *rspLen,
    uint8_t hasle);

static smStatus_t se05x_ImportExtObjTransmitBuffer(void *conn_ctx,
    struct _sss_se05x_tunnel_context *pChannelCtx,
    SE_AuthType_t currAuth,
    const tlvHeader_t *hdr,
    uint8_t *cmdBuf,
    size_t cmdBufLen,
    uint8_t *rsp,
    size_t *rspLen,
    uint8_t hasle);

smStatus_t se05x_ImportExtObjDecryptResponse(
    struct Se05xSession *pSessionCtx, size_t cmd_cmacLen, uint8_t *rsp, size_t *rspLength, uint8_t hasle);

sss_status_t ex_sss_entry(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status;
    smStatus_t sm_status     = SM_NOT_OK;
    int argc                 = gex_sss_argc;
    const char **argv        = gex_sss_argv;
    uint8_t pk_tee_ecka[256] = {0};
    size_t pk_tee_ecka_len   = sizeof(pk_tee_ecka);
    size_t publicKeyLen;
    uint16_t outKeyIndex;
    uint8_t to_be_signed[200] = {0};
    size_t to_be_signed_len   = 0;
    sss_digest_t digest_ctx;
    uint8_t digest[32] = {0};
    size_t digestLen   = sizeof(digest);
    sss_asymmetric_t asymm_ctx;
    uint8_t signature[80]                       = {0};
    size_t signatureLen                         = sizeof(signature);
    uint8_t internal_auth_pk_tee_ecka_sig_tag[] = INTERNAL_AUTH_PK_TEE_ECKA_SIG_TAG;
    uint8_t auth_data[256]                      = {0};
    size_t auth_data_len                        = 0;
    uint8_t auth_id[4]                          = {0};
    NXSCP03_DynCtx_t dyn_ctx;
    uint8_t EncryptedAPDU[100]           = {0};
    uint8_t EncryptedAPDUWithHeader[300] = {0};
    size_t EncryptedAPDUWithHeaderLen    = 0;
    uint8_t mac[16]                      = {0};
    size_t macLen;

    sss_se05x_session_t *se05x_session = (sss_se05x_session_t *)&pCtx->session;
    pgSe05xSessionCtx                  = &se05x_session->s_ctx;

    /* Parse commandline arguments */
    status = parse_command_line_args(argc, argv);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    for (int i = 0; i < 4; ++i)
        auth_id[i] = ((uint8_t *)&ecdsa_auth_id)[3 - i];

    sss_se05x_session_t se05xWriteBufferSession;
    Se05xSession_t *pse05xWriteBufferSessionCtx = &se05xWriteBufferSession.s_ctx;

    /* Read PK.SE.ECKA */
    status = read_se_ecka_and_store(pCtx);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Generate SK.TEE.ECKA and read PK.TEE.ECKA */
    status = generate_tee_ecka_and_export(pCtx, pk_tee_ecka, &pk_tee_ecka_len, &publicKeyLen, &outKeyIndex);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Store ECDSA key in host */
    status = store_ecdsa_key(pCtx);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Create InternalAuth TLV to be signed by ECDSA key */
    status = create_internal_auth_data(pCtx, to_be_signed, &to_be_signed_len, &pk_tee_ecka[outKeyIndex], publicKeyLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Sign InternalAuth data
     * Data should be hashed and signed
     * Signature algorithm should be kAlgorithm_SSS_ECDSA_SHA256
     */
    status = sss_digest_context_init(&digest_ctx, &pCtx->host_session, kAlgorithm_SSS_SHA256, kMode_SSS_Digest);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_digest_one_go(&digest_ctx, to_be_signed, to_be_signed_len, digest, &digestLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    sss_digest_context_free(&digest_ctx);

    status = sss_asymmetric_context_init(
        &asymm_ctx, &pCtx->host_session, &hostECDSAkey_object, kAlgorithm_SSS_SHA256, kMode_SSS_Sign);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_asymmetric_sign_digest(&asymm_ctx, digest, digestLen, signature, &signatureLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    sss_asymmetric_context_free(&asymm_ctx);

    /* Add signature to 0x5F37 tag */

    memcpy(&auth_data[auth_data_len], to_be_signed, to_be_signed_len);
    auth_data_len += to_be_signed_len;
    memcpy(&auth_data[auth_data_len], internal_auth_pk_tee_ecka_sig_tag, sizeof(internal_auth_pk_tee_ecka_sig_tag));
    auth_data_len += sizeof(internal_auth_pk_tee_ecka_sig_tag);
    auth_data[auth_data_len++] = (uint8_t)signatureLen;
    memcpy(&auth_data[auth_data_len], signature, signatureLen);
    auth_data_len += signatureLen;

    status = calculate_shared_secret(pCtx);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = calculate_master_secret(pCtx);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = nxECKey_HostLocal_CalculateSessionKeys(pCtx);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = nxECKey_Calculate_Initial_Mac_Chaining_Value(pCtx);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    pse05xWriteBufferSessionCtx->authType     = kSSS_AuthType_ECKey;
    pse05xWriteBufferSessionCtx->pdynScp03Ctx = &dyn_ctx;
    memcpy(&pse05xWriteBufferSessionCtx->pdynScp03Ctx->Enc, &enc_obj, sizeof(sss_object_t));
    memcpy(&pse05xWriteBufferSessionCtx->pdynScp03Ctx->Mac, &mac_obj, sizeof(sss_object_t));
    memcpy(&pse05xWriteBufferSessionCtx->pdynScp03Ctx->Rmac, &rmac_obj, sizeof(sss_object_t));
    memcpy(pse05xWriteBufferSessionCtx->pdynScp03Ctx->MCV, iniMacChaining, 16);
    memcpy(pse05xWriteBufferSessionCtx->pdynScp03Ctx->cCounter, commandCounter, 16);
    pse05xWriteBufferSessionCtx->pdynScp03Ctx->authType      = kSSS_AuthType_ECKey;
    pse05xWriteBufferSessionCtx->pdynScp03Ctx->SecurityLevel = SECURITY_LEVEL;

    /* doc:start:writesecureobjbuf */
    /* Symmetric Key */
    /* clang-format off */
    uint8_t keyValue[] = {0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x31};
    /* clang-format on */
    /* API to create buffer */
    pse05xWriteBufferSessionCtx->fp_TXn = &se05x_ImportExtObjCreateAPDU;
    int index                           = 0;

    sm_status = Se05x_API_WriteSymmKey(pse05xWriteBufferSessionCtx,
        NULL,
        SE05x_MaxAttemps_NA,
        __LINE__,
        SE05x_KeyID_KEK_NONE,
        keyValue,
        sizeof(keyValue),
        kSE05x_INS_NA,
        kSE05x_SymmKeyType_AES);
    if (sm_status != SM_OK) {
        LOG_E("Failed to create buffer");
        status = kStatus_SSS_Fail;
        goto exit;
    }

    /* WriteSecureObject API will prepare complete APDU.
     * We need to skip initial CLA INS P1 P2 and use just the TLVs
     *
     * The length is determined by the first length byte. If it
     * is 0x00, the next two bytes are the length, otherwise that
     * byte is the length.
     *
     * Determine the length here and accordingly determine the TLV.
     */
    if (gTxBuffer[4] == 0x00) {
        WriteSymmKeyAPDU_len = ((gTxBuffer[5] << 8) && 0xFF00) | ((gTxBuffer[6]) && 0xFF);
        index                = 7;
    }
    else {
        WriteSymmKeyAPDU_len = gTxBuffer[4];
        index                = 5;
    }
    if (WriteSymmKeyAPDU_len > sizeof(WriteSymmKeyAPDU)) {
        LOG_E("Insufficient buffer");
        status = kStatus_SSS_Fail;
        goto exit;
    }
    memcpy(WriteSymmKeyAPDU, &gTxBuffer[index], WriteSymmKeyAPDU_len);
    /* doc:end:writesecureobjbuf */

    /* Wrap WriteSecureObject APDU with FastSCP context */
    memcpy(EncryptedAPDU, WriteSymmKeyAPDU, WriteSymmKeyAPDU_len);
    status =
        nxSCP03_Encrypt_CommandAPDU(pse05xWriteBufferSessionCtx->pdynScp03Ctx, EncryptedAPDU, &WriteSymmKeyAPDU_len);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Add header containing CLA INS P1 P2 */
    EncryptedAPDUWithHeader[0] = 0x84; /* CLA */
    EncryptedAPDUWithHeader[1] = 0x01; /* INS */
    EncryptedAPDUWithHeader[2] = 0x03; /* P1 */
    EncryptedAPDUWithHeader[3] = 0x00; /* P2 */
    EncryptedAPDUWithHeader[4] = (uint8_t)WriteSymmKeyAPDU_len + 8 /* Length of mac added */;

    memcpy(&EncryptedAPDUWithHeader[5], EncryptedAPDU, WriteSymmKeyAPDU_len);
    EncryptedAPDUWithHeaderLen = WriteSymmKeyAPDU_len + 5;
    /* Add MAC to the wrapped command */
    status = nxpSCP03_CalculateMac_CommandAPDU(
        pse05xWriteBufferSessionCtx->pdynScp03Ctx, EncryptedAPDUWithHeader, EncryptedAPDUWithHeaderLen, mac, &macLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

#if SSS_HAVE_SE05X_VER_GTE_06_00
    /* Save MAC for RMAC calculation */
    memcpy(ObjectMAC, mac, 16);
#endif

    memcpy(&EncryptedAPDUWithHeader[EncryptedAPDUWithHeaderLen], mac, 8);
    EncryptedAPDUWithHeaderLen += 8;
    LOG_D("Restore MCV ");
#if SSS_HAVE_SE05X_VER_GTE_06_00
    /* For 5.10 applet onwards Current MAC is MCV*/
    memcpy(pse05xWriteBufferSessionCtx->pdynScp03Ctx->MCV, ObjectMAC, 16);
#else
    /* Before 5.10 applet initial MAC is MCV*/
    memcpy(pse05xWriteBufferSessionCtx->pdynScp03Ctx->MCV, iniMacChaining, 16);
#endif

    pse05xWriteBufferSessionCtx->fp_TXn     = &se05x_ImportExtObjTransformBuffer;
    pse05xWriteBufferSessionCtx->fp_RawTXn  = &se05x_ImportExtObjTransmitBuffer;
    pse05xWriteBufferSessionCtx->fp_DeCrypt = &se05x_ImportExtObjDecryptResponse;
    /* Create raw APDU for ImportExternalObject */
    sm_status = Se05x_API_ImportExternalObject(pse05xWriteBufferSessionCtx,
        auth_data,
        auth_data_len,
        auth_id,
        sizeof(auth_id),
        EncryptedAPDUWithHeader,
        EncryptedAPDUWithHeaderLen);

    status = (sm_status == SM_OK) ? kStatus_SSS_Success : kStatus_SSS_Fail;

exit:
    if (kStatus_SSS_Success == status) {
        LOG_I("se05x_ImportExternalObjectPrepare Example Success !!!...");
    }
    else {
        LOG_E("se05x_ImportExternalObjectPrepare Example Failed !!!...");
    }
    return status;
}

static sss_status_t parse_command_line_args(int argc, const char **argv)
{
    bool ecdsa_file_parameter_passed = false;
    bool ecdsa_auth_id_passed        = false;

    for (int j = 1; j < argc; j++) {
        if (strcmp(argv[j], "-file") == 0) {
            ecdsa_file_parameter_passed = true;
            j++;
            const char *filename = argv[j];
            FILE *fp             = fopen(filename, "rb");
            if (fp == NULL) {
                LOG_E("Cannot open file");
                return kStatus_SSS_Fail;
            }
            fread(hostEcdsakey, sizeof(hostEcdsakey), 1, fp);
            fclose(fp);
        }
        else if (strcmp(argv[j], "-keyid") == 0) {
            ecdsa_auth_id_passed = true;
            j++;
            ecdsa_auth_id = (uint32_t)strtoul(argv[j], NULL, 16);
        }
    }
    if (!ecdsa_file_parameter_passed) {
        LOG_E("ECDSA file parameter not passed");
        usage();
        return kStatus_SSS_Fail;
    }
    if (!ecdsa_auth_id_passed) {
        LOG_E("ECDSA KeyID not passed");
        usage();
        return kStatus_SSS_Fail;
    }

    return kStatus_SSS_Success;
}

static sss_status_t calculate_shared_secret(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status = kStatus_SSS_Fail;
    sss_derive_key_t dervCtx;
    size_t sharedSecBitLen = 0;
    /* Derive shared secret using PK.SE.ECKA and SK.TEE.ECKA
     * This will be stored in shsSecret object
     */
    status = sss_key_object_init(&shsSecret, &pCtx->host_ks);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(
        &shsSecret, __LINE__, kSSS_KeyPart_Default, kSSS_CipherType_AES, 32, kKeyObject_Mode_Transient);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    status = sss_derive_key_context_init(
        &dervCtx, &pCtx->host_session, &sk_tee_ecka_obj, kAlgorithm_SSS_ECDH, kMode_SSS_ComputeSharedSecret);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);

    status = sss_derive_key_dh(&dervCtx, &se_ecka_pub_host_obj, &shsSecret);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);

    status = sss_key_store_get_key(shsSecret.keyStore, &shsSecret, sharedSecret, &sharedSecretLen, &sharedSecBitLen);
    LOG_D("sharedSecret");
    LOG_AU8_D(sharedSecret, sharedSecretLen);

cleanup:
    sss_derive_key_context_free(&dervCtx);
    sss_key_object_free(&shsSecret);
    return status;
}

static sss_status_t calculate_master_secret(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status = kStatus_SSS_Fail;
    sss_digest_t md;
    /* Fixed DR.SE */
    uint8_t dr_se[16] = {0};
    size_t dr_se_len  = sizeof(dr_se);

    uint8_t derivationInput[100] = {0};
    size_t derivationInputLen    = 0;

#if SSS_HAVE_SE05X_VER_GTE_06_00 || SSS_HAVE_FIPS
    const uint8_t kdf_counter[] = {0x00, 0x00, 0x00, 0x01};
    memcpy(&derivationInput[derivationInputLen], kdf_counter, sizeof(kdf_counter));
    derivationInputLen += sizeof(kdf_counter);
#endif
    /* Calculate master secret using previously derived shared secret and dr.se (fixed) */
    memcpy(&derivationInput[derivationInputLen], sharedSecret, sharedSecretLen);
    derivationInputLen += sharedSecretLen;
    memcpy(&derivationInput[derivationInputLen], dr_se, dr_se_len);
    derivationInputLen += dr_se_len;

    derivationInput[derivationInputLen++] = SCP_CONFIG;
    derivationInput[derivationInputLen++] = SECURITY_LEVEL;
    derivationInput[derivationInputLen++] = GPCS_KEY_TYPE_AES;
    derivationInput[derivationInputLen++] = GPCS_KEY_LEN_AES;

    status = sss_digest_context_init(&md, &pCtx->host_session, kAlgorithm_SSS_SHA256, kMode_SSS_Digest);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    status = sss_digest_one_go(&md, derivationInput, derivationInputLen, masterSk, &masterSkLen);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    sss_digest_context_free(&md);
    masterSkLen = 16;
    LOG_MAU8_D("Master Secret", masterSk, masterSkLen);
    /*Set the Master secret as AES Key*/
    status = sss_key_object_init(&masterSec, &pCtx->host_ks);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(
        &masterSec, __LINE__, kSSS_KeyPart_Default, kSSS_CipherType_AES, 32, kKeyObject_Mode_Persistent);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    status = sss_host_key_store_set_key(&pCtx->host_ks, &masterSec, masterSk, masterSkLen, masterSkLen * 8, NULL, 0);
    ENSURE_OR_GO_CLEANUP(status == kStatus_SSS_Success);
    LOG_I("master shared Secret !!!!");
    LOG_AU8_I(masterSk, masterSkLen);
cleanup:
    return status;
}

static sss_status_t nxECKey_HostLocal_CalculateSessionKeys(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status = kStatus_SSS_Fail;
    uint8_t ddA[128];
    uint16_t ddALen = sizeof(ddA);
    uint8_t sessionEncKey[16];
    uint8_t sessionMacKey[16];
    uint8_t sessionRmacKey[16];
    uint32_t signatureLen = 16;

    /* Generation and Creation of Session ENC SSS Key Object */

    // Set the Derviation data
    nxScp03_setDerivationData(
        ddA, &ddALen, DATA_DERIVATION_SENC, DATA_DERIVATION_L_128BIT, DATA_DERIVATION_KDF_CTR, NULL, 0);
    // Calculate the Session-ENC key
    status = nxScp03_Generate_SessionKey(&masterSec, ddA, ddALen, sessionEncKey, &signatureLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    LOG_MAU8_I("sessionEncKey", sessionEncKey, 16);
    // Set the Session-ENC key
    status = sss_key_object_init(&enc_obj, &pCtx->host_ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(
        &enc_obj, __LINE__, kSSS_KeyPart_Default, kSSS_CipherType_AES, 32, kKeyObject_Mode_Persistent);
    status = sss_key_store_set_key(&pCtx->host_ks, &enc_obj, sessionEncKey, 16, (16) * 8, NULL, 0);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Generation and Creation of Session MAC SSS Key Object */

    // Set the Derviation data
    nxScp03_setDerivationData(
        ddA, &ddALen, DATA_DERIVATION_SMAC, DATA_DERIVATION_L_128BIT, DATA_DERIVATION_KDF_CTR, NULL, 0);
    // Calculate the Session-MAC key
    status = nxScp03_Generate_SessionKey(&masterSec, ddA, ddALen, sessionMacKey, &signatureLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    LOG_MAU8_I("sessionMacKey", sessionMacKey, 16);
    // Set the Session-MAC key
    status = sss_key_object_init(&mac_obj, &pCtx->host_ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(
        &mac_obj, __LINE__, kSSS_KeyPart_Default, kSSS_CipherType_AES, 32, kKeyObject_Mode_Persistent);
    status = sss_host_key_store_set_key(&pCtx->host_ks, &mac_obj, sessionMacKey, 16, (16) * 8, NULL, 0);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Generation and Creation of Session RMAC SSS Key Object */

    // Set the Derviation data
    nxScp03_setDerivationData(
        ddA, &ddALen, DATA_DERIVATION_SRMAC, DATA_DERIVATION_L_128BIT, DATA_DERIVATION_KDF_CTR, NULL, 0);
    // Calculate the Session-RMAC key
    status = nxScp03_Generate_SessionKey(&masterSec, ddA, ddALen, sessionRmacKey, &signatureLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    LOG_MAU8_I("sessionRmacKey", sessionRmacKey, 16);
    // Set the Session-RMAC key
    status = sss_key_object_init(&rmac_obj, &pCtx->host_ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(
        &rmac_obj, __LINE__, kSSS_KeyPart_Default, kSSS_CipherType_AES, 32, kKeyObject_Mode_Persistent);
    status = sss_host_key_store_set_key(&pCtx->host_ks, &rmac_obj, sessionRmacKey, 16, (16) * 8, NULL, 0);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
exit:
    return status;
}

static sss_status_t nxECKey_Calculate_Initial_Mac_Chaining_Value(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status = kStatus_SSS_Fail;
    uint8_t ddA[128];
    uint16_t ddALen       = sizeof(ddA);
    uint32_t signatureLen = 16;

    // Set the Derviation data
    nxScp03_setDerivationData(
        ddA, &ddALen, DATA_DERIVATION_INITIAL_MCV, DATA_DERIVATION_L_128BIT, DATA_DERIVATION_KDF_CTR, NULL, 0);
    // Calculate the Initial MCV value
    status = nxScp03_Generate_SessionKey(&masterSec, ddA, ddALen, iniMacChaining, &signatureLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    LOG_MAU8_I("Initial MCV", iniMacChaining, 16);
    // Set the Initial MCV value
exit:
    return status;
}
/* doc:start:transformsapdubuf */
/* This API transforms buffer to APDU and internally calls transmit and Decrypt */
smStatus_t se05x_ImportExtObjTransformBuffer(Se05xSession_t *pSe05xSession,
    const tlvHeader_t *hdr,
    uint8_t *cmdBuf,
    size_t cmdBufLen,
    uint8_t *rsp,
    size_t *rspLen,
    uint8_t hasle)
{
    memset(gTxBuffer, 0, sizeof(gTxBuffer));
    size_t i = 0;
    memcpy(&gTxBuffer[i], hdr, sizeof(*hdr));
    smStatus_t ret = SM_NOT_OK;
    i += sizeof(*hdr);
    if (cmdBufLen > 0) {
        // The Lc field must be extended in case the length does not fit
        // into a single byte (Note, while the standard would allow to
        // encode 0x100 as 0x00 in the Lc field, nobody who is sane in his mind
        // would actually do that).
        if ((cmdBufLen < 0xFF) && !hasle) {
            gTxBuffer[i++] = (uint8_t)cmdBufLen;
        }
        else {
            gTxBuffer[i++] = 0x00;
            gTxBuffer[i++] = 0xFFu & (cmdBufLen >> 8);
            gTxBuffer[i++] = 0xFFu & (cmdBufLen);
        }
        ENSURE_OR_GO_EXIT(cmdBufLen <= sizeof(gTxBuffer) - i);
        memcpy(&gTxBuffer[i], cmdBuf, cmdBufLen);
        i += cmdBufLen;
    }
    if (hasle) {
        gTxBuffer[i++] = 0x00;
        gTxBuffer[i++] = 0x00;
    }
    gTxBufferLen = i;

    LOG_D("Here is the buffer of Object needs to be Import");
    LOG_AU8_D(gTxBuffer, gTxBufferLen);

    ret = pSe05xSession->fp_RawTXn(
        pgSe05xSessionCtx->conn_ctx, NULL, kSSS_AuthType_None, hdr, cmdBuf, cmdBufLen, rsp, rspLen, hasle);
    ENSURE_OR_GO_EXIT(ret == SM_OK);
    ret = pSe05xSession->fp_DeCrypt(pSe05xSession, cmdBufLen, rsp, rspLen, hasle);
exit:
    return ret;
}
/* doc:end:transformsapdubuf */

/* doc:start:decryptsresponsebuf */
/* This API decrypts the response buffer  */
smStatus_t se05x_ImportExtObjDecryptResponse(
    struct Se05xSession *pSessionCtx, size_t cmd_cmacLen, uint8_t *rsp, size_t *rspLength, uint8_t hasle)
{
    U16 rv = SM_NOT_OK;

    if (*rspLength >= 2) {
        rv = rsp[(*rspLength) - 2] << 8 | rsp[(*rspLength) - 1];
        if ((rv == SM_OK) && (pSessionCtx->pdynScp03Ctx != NULL)) {
#if SSS_HAVE_SCP_SCP03_SSS
            rv = nxpSCP03_Decrypt_ResponseAPDU(pSessionCtx->pdynScp03Ctx, cmd_cmacLen, rsp, rspLength, hasle);
#else
            LOG_W("Decrypting without SSS_HAVE_SCP_SCP03_SSS");
            rv = SM_NOT_OK;
#endif
        }
#if SSS_HAVE_SCP_SCP03_SSS
        else { /*Counter to be increament only in case of authentication is all kind of SCP
               and response is not 9000 */
            if ((rv != SM_OK) && (pSessionCtx->pdynScp03Ctx != NULL)) {
                if (((pSessionCtx->pdynScp03Ctx->authType == kSSS_AuthType_AESKey) ||
                        (pSessionCtx->pdynScp03Ctx->authType == kSSS_AuthType_ECKey)) ||
                    ((pSessionCtx->pdynScp03Ctx->authType == kSSS_AuthType_SCP03) && (cmd_cmacLen - 8) > 0)) {
                    nxpSCP03_Inc_CommandCounter(pSessionCtx->pdynScp03Ctx);
                }
            }
        }
#endif
    }
    else {
        rv = SM_NOT_OK;
    }

    return rv;
}
/* doc:end:decryptsresponsebuf */

/* doc:start:transmitapdubuf */
/* This API transmit the buffer in default session */
static smStatus_t se05x_ImportExtObjTransmitBuffer(void *conn_ctx,
    struct _sss_se05x_tunnel_context *pChannelCtx,
    SE_AuthType_t currAuth,
    const tlvHeader_t *hdr,
    uint8_t *cmdBuf,
    size_t cmdBufLen,
    uint8_t *rsp,
    size_t *rspLen,
    uint8_t hasle)
{
    uint8_t txBuf[SE05X_MAX_BUF_SIZE_CMD] = {0};
    size_t i                              = 0;
    memcpy(&txBuf[i], hdr, sizeof(*hdr));
    smStatus_t ret = SM_NOT_OK;
    i += sizeof(*hdr);
    if (cmdBufLen > 0) {
        // The Lc field must be extended in case the length does not fit
        // into a single byte (Note, while the standard would allow to
        // encode 0x100 as 0x00 in the Lc field, nobody who is sane in his mind
        // would actually do that).
        if ((cmdBufLen < 0xFF) && !hasle) {
            txBuf[i++] = (uint8_t)cmdBufLen;
        }
        else {
            txBuf[i++] = 0x00;
            txBuf[i++] = 0xFFu & (cmdBufLen >> 8);
            txBuf[i++] = 0xFFu & (cmdBufLen);
        }
        memcpy(&txBuf[i], cmdBuf, cmdBufLen);
        i += cmdBufLen;
    }
    else {
        if (cmdBufLen == 0) {
            txBuf[i++] = 0x00;
        }
    }

    if (hasle) {
        txBuf[i++] = 0x00;
        txBuf[i++] = 0x00;
    }

    uint32_t U32rspLen = (uint32_t)*rspLen;
    ret                = (smStatus_t)smCom_TransceiveRaw(conn_ctx, txBuf, (U16)i, rsp, &U32rspLen);
    *rspLen            = U32rspLen;
    return ret;
}
/* doc:end:transmitapdubuf */

/* doc:start:createapdubuf */
/* This API creates an APDU buffer of the object stores it to the global buffer */
smStatus_t se05x_ImportExtObjCreateAPDU(Se05xSession_t *pwrite_apdubufferctx,
    const tlvHeader_t *hdr,
    uint8_t *cmdBuf,
    size_t cmdBufLen,
    uint8_t *rsp,
    size_t *rspLen,
    uint8_t hasle)
{
    memset(gTxBuffer, 0, sizeof(gTxBuffer));
    size_t i = 0;
    memcpy(&gTxBuffer[i], hdr, sizeof(*hdr));
    smStatus_t ret = SM_OK;
    i += sizeof(*hdr);
    if (cmdBufLen > 0) {
        // The Lc field must be extended in case the length does not fit
        // into a single byte (Note, while the standard would allow to
        // encode 0x100 as 0x00 in the Lc field, nobody who is sane in his mind
        // would actually do that).
        if ((cmdBufLen < 0xFF) && !hasle) {
            gTxBuffer[i++] = (uint8_t)cmdBufLen;
        }
        else {
            gTxBuffer[i++] = 0x00;
            gTxBuffer[i++] = 0xFFu & (cmdBufLen >> 8);
            gTxBuffer[i++] = 0xFFu & (cmdBufLen);
        }
        memcpy(&gTxBuffer[i], cmdBuf, cmdBufLen);
        i += cmdBufLen;
    }
    if (hasle) {
        gTxBuffer[i++] = 0x00;
        gTxBuffer[i++] = 0x00;
    }
    ret          = SM_OK;
    gTxBufferLen = i;

    LOG_AU8_I(gTxBuffer, gTxBufferLen);

    return ret;
}
/* doc:end:createapdubuf */

static sss_status_t read_se_ecka_and_store(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status = kStatus_SSS_Fail;
    size_t keyBitLen    = 256;
    status              = sss_key_object_init(&se_ecka_pub_obj, &pCtx->ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_get_handle(&se_ecka_pub_obj, SE_ECKA_PUB_OBJID);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_store_get_key(&pCtx->ks, &se_ecka_pub_obj, se_ecka_pub, &se_ecka_pub_len, &keyBitLen);

    LOG_D("SE ECKA Public Key");
    LOG_AU8_D(se_ecka_pub, se_ecka_pub_len);

    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    /* Set PK.SE.ECKA in host */
    status = sss_key_object_init(&se_ecka_pub_host_obj, &pCtx->host_ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(&se_ecka_pub_host_obj,
        __LINE__,
        kSSS_KeyPart_Public,
        kSSS_CipherType_EC_NIST_P,
        256,
        kKeyObject_Mode_Persistent);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status =
        sss_key_store_set_key(&pCtx->host_ks, &se_ecka_pub_host_obj, se_ecka_pub, se_ecka_pub_len, keyBitLen, NULL, 0);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

exit:
    return status;
}

static sss_status_t generate_tee_ecka_and_export(
    ex_sss_boot_ctx_t *pCtx, uint8_t *pk_tee_ecka, size_t *pk_tee_ecka_len, size_t *publicKeyLen, uint16_t *outKeyIndex)
{
    sss_status_t status = kStatus_SSS_Fail;
    size_t keyBitLen    = 256;
    status              = sss_key_object_init(&sk_tee_ecka_obj, &pCtx->host_ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(&sk_tee_ecka_obj,
        MAKE_TEST_ID(__LINE__),
        kSSS_KeyPart_Pair,
        kSSS_CipherType_EC_NIST_P,
        sizeof(hostEcdsakey),
        kKeyObject_Mode_Persistent);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_store_generate_key(&pCtx->host_ks, &sk_tee_ecka_obj, 256, NULL);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

    status = sss_key_store_get_key(&pCtx->host_ks, &sk_tee_ecka_obj, pk_tee_ecka, pk_tee_ecka_len, &keyBitLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    LOG_D("HOST ECKA Keypair");
    LOG_AU8_D(pk_tee_ecka, *pk_tee_ecka_len);
    status = sss_util_pkcs8_asn1_get_ec_public_key_index(pk_tee_ecka, *pk_tee_ecka_len, outKeyIndex, publicKeyLen);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
exit:
    return status;
}

static sss_status_t store_ecdsa_key(ex_sss_boot_ctx_t *pCtx)
{
    sss_status_t status = kStatus_SSS_Fail;
    status              = sss_key_object_init(&hostECDSAkey_object, &pCtx->host_ks);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status = sss_key_object_allocate_handle(&hostECDSAkey_object,
        MAKE_TEST_ID(__LINE__),
        kSSS_KeyPart_Pair,
        kSSS_CipherType_EC_NIST_P,
        sizeof(hostEcdsakey),
        kKeyObject_Mode_Persistent);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);
    status =
        sss_key_store_set_key(&pCtx->host_ks, &hostECDSAkey_object, hostEcdsakey, sizeof(hostEcdsakey), 256, NULL, 0);
    ENSURE_OR_GO_EXIT(status == kStatus_SSS_Success);

exit:
    return status;
}

static sss_status_t create_internal_auth_data(ex_sss_boot_ctx_t *pCtx,
    uint8_t *p_to_be_signed_buf,
    size_t *to_be_signed_len,
    uint8_t *pk_tee_ecka,
    size_t publicKeyLen)
{
    sss_status_t status                       = kStatus_SSS_Success;
    uint8_t internal_auth_pk_tee_ecka_tag[]   = INTERNAL_AUTH_PK_TEE_ECKA_TAG;
    size_t internal_auth_pk_tee_ecka_tag_size = sizeof(internal_auth_pk_tee_ecka_tag);

    uint8_t eckey_fixed_params[] = ECKEY_PARAMS;
    /* Copy fixed ECKey params of InternalAuthenticate */
    memcpy(&p_to_be_signed_buf[*to_be_signed_len], eckey_fixed_params, sizeof(eckey_fixed_params));
    (*to_be_signed_len) += sizeof(eckey_fixed_params);
    /* Create 0x7F49 TLV */
    memcpy(&p_to_be_signed_buf[*to_be_signed_len], internal_auth_pk_tee_ecka_tag, internal_auth_pk_tee_ecka_tag_size);
    (*to_be_signed_len) += internal_auth_pk_tee_ecka_tag_size;
    /* Length of value of 0x7F49 */
    uint8_t *pinternal_auth_pk_tee_ecka_len   = &p_to_be_signed_buf[(*to_be_signed_len)++];
    p_to_be_signed_buf[(*to_be_signed_len)++] = 0xB0;                  /* PK.TEE.ECKA Tag */
    p_to_be_signed_buf[(*to_be_signed_len)++] = (uint8_t)publicKeyLen; /* PK.TEE.ECKA Tag */
    memcpy(&p_to_be_signed_buf[*to_be_signed_len], pk_tee_ecka, publicKeyLen);
    (*to_be_signed_len) += publicKeyLen;
    p_to_be_signed_buf[(*to_be_signed_len)++] = 0xF0; /* ECCurve identifier Tag */
    p_to_be_signed_buf[(*to_be_signed_len)++] = 0x01; /* ECCurve identifier Length */
    p_to_be_signed_buf[(*to_be_signed_len)++] = 0x03; /* ECCurve identifier Value */
    *pinternal_auth_pk_tee_ecka_len =
        (uint8_t)(publicKeyLen + 2 /* Tag & Length for 0xF0 */ + 3 /* TLV for ECCurve Identifier */);

    return status;
}