owner-nrf52sdk/nRF5_SDK_17.0.2/external/infineon/optiga/cmd/CommandLib.c

/**
* MIT License
*
* Copyright (c) 2018 Infineon Technologies AG
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE
*
*
* \file
*
* \brief   This file implements the command library.
*
* \addtogroup  grCmdLib
* @{
*/

#include <stdint.h>
#include "optiga/common/Util.h"
#include "optiga/cmd/CommandLib.h"
#include "optiga/common/MemoryMgmt.h"

#ifdef USE_CMDLIB_WITH_RTOS
#include "optiga/pal/pal_os_timer.h"
#endif

/// @cond hidden

static optiga_comms_t* p_optiga_comms;

///Maximum size of buffer, considering Maximum size of arbitrary data (1500) and header bytes
#define MAX_APDU_BUFF_LEN               1558

///Get Data Parameter
#define PARAM_GET_DATA                  0x00

///Get Meta Data Parameter
#define PARAM_GET_METADATA              0x01

///Set Data Parameter
#define PARAM_SET_DATA                  0x00

///Set Meta Data Parameter
#define PARAM_SET_METADATA              0x01

///Erase and Write Parameter
#define PARAM_SET_DATA_ERASE            0x40

///ECDSA Set Auth message
#define PARAM_SET_AUTH_MSG              0x01

///ECDSA Get Auth message
#define PARAM_GET_AUTH_MSG              0x02

///Encrypt Data
#define PARAM_ENC_DATA                  0x61

///Decrypt Data
#define PARAM_DEC_DATA                  0x51

///Number of bytes in CMD
#define BYTES_CMD                       0x01

///Number of bytes in PARAM
#define BYTES_PARAM                     0x01

///Number of bytes in LEN
#define BYTES_LENGTH                    0x02

///Number of bytes in Sequence
#define BYTES_SEQ                       0x01

///Number of bytes in OID
#define BYTES_OID                       0x02

///Number of bytes in OFFSET
#define BYTES_OFFSET                    0x02

///Offset of status in the response APDU
#define OFFSET_RESP_STATUS              0x00

///Offset of CMD byte
#define OFFSET_CMD                      (0x00)

///Offset of PARAM byte
#define OFFSET_PARAM                    (OFFSET_CMD + BYTES_CMD)

///Offset of LEN byte
#define OFFSET_LENGTH                   (OFFSET_PARAM + BYTES_PARAM)

///Offset of PAYLOAD
#define OFFSET_PAYLOAD                  (OFFSET_LENGTH + BYTES_LENGTH)

///Offset of TAG
#define TAG_LENGTH_OFFSET               0x01

///Offset of TAG + LEN
#define TAG_VALUE_OFFSET                0x03

///Cmd of Get Data Object
#define CMD_GETDATA                     0x01

///Cmd of Set Data Object
#define CMD_SETDATA                     0x02

///Cmd of Set Auth Scheme
#define CMD_SETAUTH_SCM                 0x10

///Cmd of Set Auth Data
#define CMD_SETAUTH_MSG                 0x19

///Cmd of Get Auth Data
#define CMD_GETAUTH_MSG                 0x18

///Cmd of Get Random
#define CMD_GET_RND                     0x0C

///Cmd of Open Application
#define CMD_OPEN_APP                    0x70

///Cmd for ProcUplinkMsg
#define CMD_GETMSG                      0x1A

///Cmd for ProcDownlinkMsg
#define CMD_PUTMSG                      0x1B

///Cmd for Encrypt Data
#define CMD_ENCDATA                     CMD_GETMSG

///Cmd for Decrypt Data
#define CMD_DECDATA                     CMD_PUTMSG

///Cmd for CalcHash
#define CMD_CALCHASH                    0x30

///Cmd for VerifySign
#define CMD_VERIFYSIGN                  0x32

///Cmd for GenKeyPair
#define CMD_GENERATE_KEY_PAIR           0x38

///Cmd for CalcSign
#define CMD_CALC_SIGN                   0x31

///Cmd for CalcSSec
#define CMD_CALC_SHARED_SEC             0x33

///Cmd for DeriveKey
#define CMD_DERIVE_KEY                  0x34

///Payload length of Get Data
#define LEN_PL_OIDDATA                  0x06

///Payload length of OID
#define LEN_PL_OID                      0x02

///Oid of error object
#define OID_ERROR                       0xF1C2

///Cmd with MSB set
#define CMD_CODE_MSB_SET                0x80

/// Unique application identifier
#define UNIQUE_APP_IDENTIFIER           0xD2, 0x76, 0x00, 0x00, 0x04, 0x47, 0x65, 0x6E, 0x41, 0x75, 0x74, 0x68, 0x41, 0x70, 0x70, 0x6C

///Session ID Lower value
#define SESSION_ID_LOWER_VALUE          0xE100

///Session ID Higher value
#define SESSION_ID_HIGHER_VALUE         0xE103

///Tag for unprotected Message in the response data
#define TAG_UNPROTECTED                 0x60

///Tag for protected Message in the response data
#define TAG_PROTECTED                   0x50

///Mask the higher nibble
#define MASK_HIGHER_NIBBLE              0xF0

///Mask the higher nibble
#define MASK_LOWER_NIBBLE               0x0F

///Offset of tag byte
#define OFFSET_TAG                      (OFFSET_PAYLOAD + BYTES_SESSIONID)

///Offset of Tag Length byte
#define OFFSET_TAG_LEN                  (OFFSET_TAG + 1)

///Offset of Tag data
#define OFFSET_TAG_DATA                 (OFFSET_TAG_LEN + BYTES_LENGTH)

///GMT Unix time tag
#define TAG_GMTUNIX_TIME                0x31

///Number of bytes of GMT time
#define BYTES_GMT_TIME                  0x04

///Certificate OID tag
#define TAG_CERTIFICATE_OID             0x32

///Invalid value for Max size of comms buffer
#define INVALID_MAX_COMMS_BUFF_SIZE     0xFFFF

///Tag for digest
#define TAG_DIGEST                      0x01

///Tag for signature
#define TAG_SIGNATURE                   0x02

///Tag for public key oid
#define TAG_PUB_KEY_OID                 0x04

///Tag for algorithm identifier
#define TAG_ALGO_IDENTIFIER             0x05

///Tag for private key OID
#define TAG_OID                         0x01

///Tag for key usage identifier
#define TAG_KEY_USAGE_IDENTIFIER        0x02

///Tag for OID of signature key
#define TAG_OID_SIG_KEY                 0x03

///Tag for seed
#define TAG_SEED					    0x02

/// Length for OID of signature key
#define LEN_OID_SIG_KEY                 0x0002

///Len for algorithm identifier
#define LEN_KEY_USAGE_IDENTIFIER        0x0001

///Tag for export key pair
#define TAG_EXPORT_KEY_PAIR             0x07

///Len for private key oid
#define LEN_PRI_KEY                     0x0002

///Len for Shared Secret oid
#define LEN_SHARED_SECRET_OID           0x0002

///Len for exported key pair
#define LEN_EXPORT_KEY_PAIR             0x0000

///Tag for public key
#define TAG_PUB_KEY                     0x06

///Len for public key oid
#define LEN_PUB_KEY                     0x0002

///Len for algorithm identifier
#define LEN_ALGO_IDENTIFIER             0x0001

///Error in security chip indicating data out of boundary
#define ERR_DATA_OUT_OF_BOUND           0x00000008

//Maximum size of the communication buffer
/*lint --e{552} suppress "Temporary" */
uint16_t wMaxCommsBuffer = INVALID_MAX_COMMS_BUFF_SIZE;

//Finds minimum amongst the given 2 value
#ifndef MIN
#define MIN(a,b) ((a<b)?a:b)
#endif

///Hash Output length for SHA256 Hash Algorithm
#define SHA256_HASH_LEN                 32

///ECC NIST P 256 Private key length
#define ECC_NIST_P_256_KEY_LEN          32

///ECC NIST P 384 Private key length
#define ECC_NIST_P_384_KEY_LEN          48

/**
 * Initializes the APDU buffer in stack.<br>
 **/
#define INIT_STACK_APDUBUFFER(pbBuffer,wLen)    \
{                                               \
    /*lint --e{733,830} suppress "Used only within Command Lib Block" */\
    uint8_t rgbAPDUBuffer[wLen];                \
    pbBuffer = rgbAPDUBuffer;                   \
}

/**
 * Initializes the APDU buffer in heap.<br>
 **/
#define INIT_HEAP_APDUBUFFER(pbBuffer,wLen)                     \
{                                                               \
    if(INVALID_MAX_COMMS_BUFF_SIZE == wMaxCommsBuffer)          \
    {                                                           \
        i4Status = (int32_t)CMD_DEV_EXEC_ERROR;                 \
    break;                                                      \
    }                                                           \
    pbBuffer = (uint8_t*)OCP_MALLOC(wLen);                      \
    if(NULL == pbBuffer)                                        \
    {                                                           \
        i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;        \
        break;                                                  \
    }                                                           \
}

/**
 * Frees the heap memory.<br>
 **/
#define FREE_HEAP_APDUBUFFER(pbBuffer)  \
{                                       \
    if(NULL != pbBuffer)                \
    {                                   \
            OCP_FREE(pbBuffer);         \
            pbBuffer = NULL;            \
    }                                   \
}


//Hash info details for Hash algorithm
sHashinfo_d sHashInfo[1]={
{eSHA256, SHA256_HASH_LEN, CALC_HASH_SHA256_CONTEXT_SIZE}
};

/**
 * \brief Structure to specify algorithm identifier and key length.
 */
typedef struct sAlgoinfo
{
    ///Algorithm type
    eAlgId_d eAlgKeyId;

    ///Key Length
    uint8_t bKeyLen;

}sAlgoInfo_d;

//Algorithm identifier
sAlgoInfo_d sAlgoInfo[2]={
    {eECC_NIST_P256, ECC_NIST_P_256_KEY_LEN},
    {eECC_NIST_P384, ECC_NIST_P_384_KEY_LEN}
};

/**
 * \brief Structure to specify GetDataObject command parameters.
 */
typedef struct sApduData_d
{
    ///Cmd of the APDU
    uint8_t bCmd;

    ///Param of APDU
    uint8_t bParam;

    ///Payload length
    uint16_t wPayloadLength;

    //Payload Data
    uint8_t* prgbAPDUBuffer;

        //Response Data
    uint8_t* prgbRespBuffer;

    //Response Length
    uint16_t wResponseLength;
}sApduData_d;

/**
 * \brief Enumeration to specify the sequence of message/record.
 */
//lint --e{749} suppress "Added for future use"
typedef enum eFragSeq_d
{
    ///Start
    eStart =    0x00,

    ///Final
    eFinal =    0x01,

    ///Intermediate
    eContinue = 0x02
}eFragSeq_d;

volatile static host_lib_status_t optiga_comms_status;

//lint --e{715, 818} suppress "This is ignored as app_event_handler_t handler function prototype requires this argument.This will be used for object based implementation"
static void optiga_comms_event_handler(void* upper_layer_ctx, host_lib_status_t event)
{
    optiga_comms_status = event;
}

/**
 *
 * Gets the device error code by reading the Error code object id.<br>
 * If there is an internal error in function, then #CMD_DEV_ERROR is returned.<br>
 * Otherwise,the device error code is ORed with #CMD_DEV_ERROR and returned.<br>
 *
 *
 * \retval    #CMD_DEV_ERROR
 * \retval    #CMD_LIB_ERROR
 * \retval    #CMD_DEV_EXEC_ERROR
 *
 */
_STATIC_H int32_t CmdLib_GetDeviceError(void)
{
    int32_t i4Status  = (int32_t)CMD_DEV_ERROR;
    uint8_t rgbErrorCmd[] = {CMD_GETDATA,0x00,0x00,0x02,(uint8_t)(OID_ERROR>>8),(uint8_t)OID_ERROR};
    uint16_t wBufferLength = sizeof(rgbErrorCmd);

    do
    {
        p_optiga_comms->upper_layer_handler = optiga_comms_event_handler;
        optiga_comms_status  = OPTIGA_COMMS_BUSY;
        i4Status  =  optiga_comms_transceive(p_optiga_comms,rgbErrorCmd,&wBufferLength,
                                                 rgbErrorCmd,&wBufferLength);
        if(OPTIGA_COMMS_SUCCESS != i4Status)
        {
            i4Status = (int32_t)CMD_DEV_EXEC_ERROR;
            break;
        }

        //wait for completion
        while(optiga_comms_status == OPTIGA_COMMS_BUSY){
#ifdef USE_CMDLIB_WITH_RTOS
                pal_os_timer_delay_in_milliseconds(1);
#endif
        };
        if(optiga_comms_status != OPTIGA_COMMS_SUCCESS)
        {
            i4Status = (int32_t)CMD_DEV_EXEC_ERROR;
            break;
        }

        if(0 == rgbErrorCmd[OFFSET_RESP_STATUS])
        {   //If response Header
            i4Status = (int32_t)(CMD_DEV_ERROR | rgbErrorCmd[OFFSET_PAYLOAD]);
        }
        else
        {
            //In this case, execution error is returned.
            i4Status  = (int32_t)CMD_DEV_EXEC_ERROR;
        }
    }while(FALSE);
    return i4Status;
}


/**
 * \brief Formats data as per Security Chip application and send using the communication functions.
 */
_STATIC_H int32_t TransceiveAPDU(sApduData_d *PpsApduData,uint8_t bGetError)
{
    //lint --e{818} suppress "PpsResponse is out parameter"
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wTotalLength;
    do
    {
        if(NULL == PpsApduData || NULL == p_optiga_comms)
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }
        PpsApduData->prgbAPDUBuffer[OFFSET_CMD] = PpsApduData->bCmd;
        PpsApduData->prgbAPDUBuffer[OFFSET_PARAM] = PpsApduData->bParam;

        //copy length
        PpsApduData->prgbAPDUBuffer[OFFSET_LENGTH] = (uint8_t)(PpsApduData->wPayloadLength >> BITS_PER_BYTE);
        PpsApduData->prgbAPDUBuffer[OFFSET_LENGTH+1] = (uint8_t)PpsApduData->wPayloadLength;

        //update total length to consider total header length
        wTotalLength = PpsApduData->wPayloadLength + LEN_APDUHEADER;

        p_optiga_comms->upper_layer_handler = optiga_comms_event_handler;
        optiga_comms_status  = OPTIGA_COMMS_BUSY;
        i4Status  =  optiga_comms_transceive(p_optiga_comms,PpsApduData->prgbAPDUBuffer,&wTotalLength,
                                                PpsApduData->prgbRespBuffer,&PpsApduData->wResponseLength);
        if(OPTIGA_COMMS_SUCCESS != i4Status)
        {
            i4Status = (int32_t)CMD_DEV_EXEC_ERROR;
            break;
        }
        //wait for completion
        do
        {
#ifdef USE_CMDLIB_WITH_RTOS
                pal_os_timer_delay_in_milliseconds(1);
#endif
        }while(optiga_comms_status == OPTIGA_COMMS_BUSY);

        if(optiga_comms_status != OPTIGA_COMMS_SUCCESS)
        {
            i4Status = (int32_t)CMD_DEV_EXEC_ERROR;
            break;
        }
        //return device error if not success
        if(0 != PpsApduData->prgbRespBuffer[OFFSET_RESP_STATUS])
        {
            if(TRUE == bGetError)
            {
                i4Status = CmdLib_GetDeviceError();
            }
            else
            {
                i4Status = (int32_t)CMD_LIB_ERROR;
            }
            break;
        }
        i4Status = CMD_LIB_OK;

    }while(FALSE);

    return i4Status;
}

/**
 * \brief Read the maximum size of communication buffer supported by the security chip by reading "Max comms buffer size" OID.
 */
_STATIC_H int32_t GetMaxCommsBuffer()
{
#define GETDATA_MAX_COMMS_SIZE  10
#define OID_MAX_COMMS_SIZE      0xE0C6

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;

    do
    {
        INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer,GETDATA_MAX_COMMS_SIZE);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        //Set the CMD
        sApduData.bCmd = CMD_GETDATA;
        sApduData.bParam = PARAM_GET_DATA;
        sApduData.wPayloadLength = LEN_PL_OID;
                sApduData.wResponseLength = GETDATA_MAX_COMMS_SIZE;
        //copy OID
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(OID_MAX_COMMS_SIZE >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD +1] = (uint8_t)OID_MAX_COMMS_SIZE;

        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        //Assign value to MaxCommsBuffer
        wMaxCommsBuffer = (uint16_t )((sApduData.prgbRespBuffer[LEN_APDUHEADER] << 8) | (sApduData.prgbRespBuffer[LEN_APDUHEADER+1]));
    }while(FALSE);

#undef GETDATA_MAX_COMMS_SIZE
#undef OID_MAX_COMMS_SIZE
    return i4Status;
}


#ifdef MODULE_ENABLE_DTLS_MUTUAL_AUTH
/**
 * \brief A common function for CmdLib_Encrypt and CmdLib_Decrypt.
 *
 */
_STATIC_H int32_t CmdLib_EncDecHelper(sProcCryptoData_d *PpsCryptoVector, uint8_t PbCmd, uint8_t PbParam);

/**
* A common function for CmdLib_Encrypt and CmdLib_Decrypt.<br>
* Forms the APDU required for encryption/decryption and sends to the security chip for processing.<br>
*
*
* \param[in,out] PpsCryptoVector Pointer to structure containing Ciphertext and Plaintext
* \param[in] bCmd ProcUplink or ProcDownlink
* \param[in] bParam  Parameter to Encrypt/Decrypt data
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_LIB_INVALID_SESSIONID
* \retval  #CMD_LIB_INVALID_LEN
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
_STATIC_H int32_t CmdLib_EncDecHelper(sProcCryptoData_d *PpsCryptoVector, uint8_t PbCmd, uint8_t PbParam)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wRespLen;
    uint16_t wDataRemaining;
    uint16_t wMaxDataLen;
    uint16_t wTotalEncDecLen =0;
    uint16_t wOffset = ADDITIONALBYTES_ENCDEC;
    uint16_t wMaxPlaintText;
    uint8_t bFragSeq ;
    uint8_t bSendTag,bRecvTag;
    uint8_t *pbResponse;
    uint8_t bGetError = TRUE;
    sApduData_d sApduData;

    do
    {
        //NULL checks
        if((NULL == PpsCryptoVector) || (NULL == PpsCryptoVector->sInData.prgbStream) ||
        (NULL == PpsCryptoVector->sOutData.prgbBuffer))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        //Verify the Session OID reference
        if((SESSION_ID_LOWER_VALUE > PpsCryptoVector->wSessionKeyOID) ||
        (SESSION_ID_HIGHER_VALUE < PpsCryptoVector->wSessionKeyOID))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_SESSIONID;
            break;
        }

        if((0 == PpsCryptoVector->wInDataLength) ||
        (PpsCryptoVector->sInData.wLen < (PpsCryptoVector->wInDataLength + OVERHEAD_UPDOWNLINK)))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_LEN;
            break;
        }

        //Check if plaintext length is more than the size of the out buffer
        if(PpsCryptoVector->wInDataLength > PpsCryptoVector->sOutData.wBufferLength)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        PpsCryptoVector->sOutData.wRespLength = 0;

        //Assign cmd,param
        sApduData.bCmd = PbCmd;
        sApduData.bParam = PbParam;

                wMaxPlaintText = wMaxCommsBuffer - OVERHEAD_UPDOWNLINK;

        //Data that is yet to be encrypted/decrypted
        wDataRemaining = PpsCryptoVector->wInDataLength;

        //Set the fragment sequence to start
        bFragSeq = (wDataRemaining>wMaxPlaintText)?(uint8_t)eStart:(uint8_t)eFinal;

        //Assign send or receive Tag
        if(PARAM_ENC_DATA == PbParam)
        {
            bSendTag = TAG_UNPROTECTED;
            bRecvTag = TAG_PROTECTED;
        }
        else
        {
            bSendTag= TAG_PROTECTED;
            bRecvTag = TAG_UNPROTECTED;
            bGetError = FALSE;
        }

        pbResponse = PpsCryptoVector->sOutData.prgbBuffer;

        while(wDataRemaining !=0)
        {
            //Maximum data that can be sent to chip in one APDU
            wMaxDataLen = (wDataRemaining>wMaxPlaintText)?wMaxPlaintText:wDataRemaining;

            //Assign InData memory pointer to the APDU Buffer in the Apdu structure
            sApduData.prgbAPDUBuffer = PpsCryptoVector->sInData.prgbStream + wOffset;

            //Form data and assign to apdu structure
            //Total payload length is Session ID Length + bytes for tag encoding + data
            sApduData.wPayloadLength = BYTES_SESSIONID + LEN_TAG_ENCODING + wMaxDataLen;

            //Add the session ID to the buffer
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsCryptoVector->wSessionKeyOID >> BITS_PER_BYTE);
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + 1] = (uint8_t)PpsCryptoVector->wSessionKeyOID;

            //Add the encoding tag to the buffer
            sApduData.prgbAPDUBuffer[OFFSET_TAG] = (bSendTag | bFragSeq);
            sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN] = (uint8_t)(wMaxDataLen >> 8);
            sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN + 1] = (uint8_t)wMaxDataLen;

            //Payload data should already be present in input buffer as per documentation
            sApduData.prgbRespBuffer = pbResponse;
            sApduData.wResponseLength = PpsCryptoVector->sOutData.wBufferLength - wTotalEncDecLen;

            //Now Transmit data
            i4Status = TransceiveAPDU(&sApduData,bGetError);
            if(CMD_LIB_OK != i4Status)
            {
                if(PARAM_DEC_DATA == PbParam)
                {
                    i4Status = (int32_t)CMD_LIB_DECRYPT_FAILURE;
                }
                break;
            }

            //Remove 4 byte apdu header + tag encoding
            sApduData.wResponseLength -= OVERHEAD_ENCDEC_RESPONSE;

            //Sequence of flag for start,continue or final should be same that was sent
            if((bRecvTag|bFragSeq) != (*(sApduData.prgbRespBuffer + LEN_APDUHEADER)))
            {
                i4Status = (int32_t)CMD_LIB_INVALID_TAG;
                break;
            }

            //Extract the tag length field to get enc data length
            wRespLen = Utility_GetUint16(sApduData.prgbRespBuffer + LEN_APDUHEADER + 1);

            //Length validation for response length with the tag length
            if(sApduData.wResponseLength != wRespLen)
            {
                i4Status = (int32_t)CMD_LIB_INVALID_TAGLEN;
                break;
            }

            //Copy the data to output data buffer
            Utility_Memmove(pbResponse,sApduData.prgbRespBuffer+(LEN_APDUHEADER + LEN_TAG_ENCODING),wRespLen);

            wTotalEncDecLen += wRespLen;
            pbResponse += wRespLen;
            //Data remaining to encrypt
            wDataRemaining -= wMaxDataLen;
            //Since using the buffer provided by user, using offset to form next APDU command
            wOffset += wMaxDataLen;
            //If last fragment then make flag final else let it continue
            bFragSeq = (wDataRemaining>wMaxPlaintText)?(uint8_t)eContinue:(uint8_t)eFinal;
        }

        //Update on success only
        if(CMD_LIB_OK == i4Status)
        {
            PpsCryptoVector->sOutData.wRespLength = wTotalEncDecLen;
        }

    }while(FALSE);

    return i4Status;
}
#endif /* MODULE_ENABLE_DTLS_MUTUAL_AUTH*/

#ifdef MODULE_ENABLE_TOOLBOX
/**
 * This function returns Hash Algorithm information such as Hash output length, Hash context data.
 *
 * \param[in]        PeHashAlgo		Hash Algorithm type
 * \param[in,out]    PpsHashinfo    Pointer to a structure containing Hash algorithm information
 *
 * \retval  #CMD_LIB_OK
 * \retval  #CMD_LIB_ERROR
 */
_STATIC_H int32_t Get_HashInfo(eHashAlg_d PeHashAlgo,sHashinfo_d** PppsHashinfo )
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint8_t bCount;

    //Search the table for the given session key id
    for(bCount= 0;bCount<(sizeof(sHashInfo)/sizeof(sHashinfo_d));bCount++)
    {
        if(PeHashAlgo == sHashInfo[bCount].eHashAlgo)
        {
            *PppsHashinfo = &sHashInfo[bCount];
            i4Status = (int32_t) CMD_LIB_OK;
            break;
        }
    }
    return i4Status;
}

/**
 * This function returns key size based on the algorithm.
 *
 * \param[in]        PeAlgoIden		Algorithm identifier type
 * \param[in,out]    PpsAlgoinfo    Pointer to a structure containing key size of algorithm identifier
 *
 * \retval  #CMD_LIB_OK
 * \retval  #CMD_LIB_ERROR
 */
_STATIC_H int32_t Get_KeySize(eAlgId_d PeAlgoIden,uint8_t* pbKeySize )
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint8_t bCount;

    //Search the table for the given session key id
    for(bCount= 0;bCount<(sizeof(sAlgoInfo)/sizeof(sAlgoInfo_d));bCount++)
    {
        if(PeAlgoIden == sAlgoInfo[bCount].eAlgKeyId)
        {
                        *pbKeySize = sAlgoInfo[bCount].bKeyLen;
            i4Status = (int32_t) CMD_LIB_OK;
            break;
        }
    }
    return i4Status;
}
#endif/*MODULE_ENABLE_TOOLBOX*/

/// @endcond

/**
* Sets the OPTIGA Comms context provided by user application in the command libary.
*
* <br>
* \param[in] p_input_optiga_comms Pointer to OPTIGA comms context
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
*/
void CmdLib_SetOptigaCommsContext(const optiga_comms_t *p_input_optiga_comms)
{
        p_optiga_comms = (optiga_comms_t*)p_input_optiga_comms;
}

/**
* Opens the Security Chip Application. The Unique Application Identifier is used internally by
* the function while forming a command APDU.
*
*\param[in] PpsOpenApp Pointer to a structure #sOpenApp_d containing inputs for opening application on security chip
*
* Notes:
* - This function must be mandatorily invoked before starting any interactions with security Chip after the reset.
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INVALID_PARAM
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_OpenApplication(const sOpenApp_d* PpsOpenApp)
{
/// @cond hidden
#define OPEN_APDU_BUF_LEN    25
/// @endcond

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint8_t rgbUID[] = {UNIQUE_APP_IDENTIFIER};
    sApduData_d sApduData;

    do
    {
        INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer,OPEN_APDU_BUF_LEN);

        if(NULL == PpsOpenApp)
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }
        //Validate option for opening application
        if(eInit != PpsOpenApp->eOpenType)
        {
            i4Status = (int32_t)CMD_LIB_INVALID_PARAM;
            break;
        }

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        //Open application command with MSB set to flush the last error code
        sApduData.bCmd = CMD_OPEN_APP | CMD_CODE_MSB_SET ;
        sApduData.bParam = (uint8_t)PpsOpenApp->eOpenType;
        sApduData.wPayloadLength = sizeof(rgbUID);
                sApduData.wResponseLength = OPEN_APDU_BUF_LEN;
        OCP_MEMCPY(sApduData.prgbAPDUBuffer+OFFSET_PAYLOAD, rgbUID, sizeof(rgbUID));
        i4Status = TransceiveAPDU(&sApduData,FALSE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        //Read Max comms buffer size if not already read
        if(INVALID_MAX_COMMS_BUFF_SIZE == wMaxCommsBuffer)
        {
            //Get Maximum Comms buffer size
            i4Status = GetMaxCommsBuffer();
        }
    }while(FALSE);

/// @cond hidden
#undef OPEN_APDU_BUF_LEN
/// @endcond

    return i4Status;
}

#ifdef MODULE_ENABLE_READ_WRITE
/**
* Reads data or metadata of the specified data object by issuing GetDataObject command based on input parameters.
*
* <br>
* Notes:
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
* - The function does not verify if the read access is permitted for the data object.<br>
*
*\param[in] PpsGDVector Pointer to Get Data Object inputs
*\param[in,out] PpsResponse Pointer to Response structure
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_GetDataObject(const sGetData_d *PpsGDVector, sCmdResponse_d *PpsResponse)
{
/// @cond hidden
#define ALLOCATE_ADDITIONAL_BYTES	6		// hdr(4) + oid(2)
/// @endcond

    //lint --e{818} suppress "PpsResponse is out parameter"
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wTotalRecvLen = 0;
    uint16_t wReadLen = 0;
    uint16_t wOffset = 0;
    sApduData_d sApduData;
    sApduData.prgbAPDUBuffer = NULL;
    do
    {
//To use stack memory for APDU buffer, define STACK_ALLOC macro locally and else heap memory is used
#ifdef STACK_ALLOC
        #error "Implement the inilization of stack memory for the required buffer"
                //INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer, wLen);    //wLen to be replaced with the required const length
#else
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,wMaxCommsBuffer + ALLOCATE_ADDITIONAL_BYTES);
#endif

        if((NULL == PpsGDVector)||(NULL == PpsResponse)||(NULL == PpsResponse->prgbBuffer))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }
        if(0x00 == PpsResponse->wBufferLength)
        {
            i4Status = (int32_t)CMD_LIB_LENZERO_ERROR;
            break;
        }
        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer+ALLOCATE_ADDITIONAL_BYTES;
        sApduData.bCmd = CMD_GETDATA;
        //copy OID
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsGDVector->wOID >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD +1] = (uint8_t)PpsGDVector->wOID;
        //set param, payload length and offset ,if reading data
        if(eDATA == PpsGDVector->eDataOrMdata)
        {
            sApduData.bParam = PARAM_GET_DATA;
            sApduData.wPayloadLength = LEN_PL_OIDDATA;
            wOffset = PpsGDVector->wOffset;
        }
        //set param and payload length ,if reading metadata
        else if(eMETA_DATA == PpsGDVector->eDataOrMdata)
        {
            sApduData.bParam = PARAM_GET_METADATA;
            sApduData.wPayloadLength = LEN_PL_OID;
        }
        else
        {
            i4Status = (int32_t)CMD_LIB_INVALID_PARAM;
            break;
        }

        do
        {
            if(eDATA == PpsGDVector->eDataOrMdata)
            {
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_OID] = (uint8_t)(wOffset >> BITS_PER_BYTE);
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_OID +1] = (uint8_t)wOffset;

                //copy read length
                wReadLen = MIN((wMaxCommsBuffer-LEN_APDUHEADER),(PpsGDVector->wLength-wTotalRecvLen));
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_OID + BYTES_OFFSET] = (uint8_t)(wReadLen >> BITS_PER_BYTE);
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_OID + BYTES_OFFSET +1] = (uint8_t)wReadLen;
            }

            sApduData.wResponseLength = wMaxCommsBuffer;

            i4Status = TransceiveAPDU(&sApduData,TRUE);
            if(CMD_LIB_OK != i4Status)
            {
                break;
            }
            //strip 4 byte apdu header
            sApduData.wResponseLength -= LEN_APDUHEADER;

            //Copy read data
            if(((PpsResponse->wBufferLength-wTotalRecvLen) < sApduData.wResponseLength))
            {
                i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
                break;
            }
            OCP_MEMCPY(PpsResponse->prgbBuffer+wTotalRecvLen,sApduData.prgbRespBuffer+LEN_APDUHEADER,sApduData.wResponseLength);
            //Update total received data
            wTotalRecvLen += sApduData.wResponseLength;
            //increment the offset to get data from
            wOffset += sApduData.wResponseLength;

            //If requested data is read
            if(wTotalRecvLen == PpsGDVector->wLength)
            {
                break;
            }
        //continue, if total requested data not yet received and more data available for reading
        }while(wReadLen == sApduData.wResponseLength);

        if((CMD_LIB_OK != i4Status)&&((wTotalRecvLen == 0)||
        (ERR_DATA_OUT_OF_BOUND != (i4Status^(int32_t)CMD_DEV_ERROR))))
        {
            //Clear existing data
            OCP_MEMSET(PpsResponse->prgbBuffer,0,wTotalRecvLen);
            PpsResponse->wRespLength = 0;
            break;
        }

        PpsResponse->wRespLength = wTotalRecvLen;
        i4Status = (int32_t)CMD_LIB_OK;
    }while(FALSE);

#ifndef STACK_ALLOC
        FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);
#else
        #undef STACK_ALLOC
#endif

///@cond hidden
#undef ALLOCATE_ADDITIONAL_BYTES
///@endcond

    return i4Status;
}

/**
* Writes data or metadata to the specified data object by issuing SetDataObject command based on input parameters.
*
* <br>
* Notes: <br>
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
*
* - The function does not verify if the write access permitted for the data object.
*
* - While writing metadata, the metadata must be specified in an already TLV encoded
*   byte array format. For example, to set LcsO to operational the value passed by
*   the user must be 0x20 0x03 0xC0, 0x01, 0x07. <br>
*
* - The function does not validate if the provided input data bytes are correctly
*   formatted. For example, while setting LcsO to operational, function does not
*   verify if the value is indeed 0x07. <br>
*
* - In case of failure,it is possible that partial data is written into the data object.<br>
*   In such a case, the user should decide if the data has to be re-written.
*
*\param[in] PpsSDVector Pointer to Set Data Object inputs
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INVALID_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_SetDataObject(const sSetData_d *PpsSDVector)
{
/// @cond hidden
#define BUFFER_SIZE (wMaxCommsBuffer)
/// @endcond

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wTotalWriteLen = 0;
    uint16_t wWriteLen = 0;
    uint16_t wOffset;
    sApduData_d sApduData;
    sApduData.prgbAPDUBuffer = NULL;

    do
    {
//To use stack memory for APDU buffer, define STACK_ALLOC macro locally and else heap memory is used
#ifdef STACK_ALLOC
        #error "Implement the inilization of stack memory for the required buffer"
                //INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer, wLen);    //wLen to be replaced with the required const length
#else
                INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,BUFFER_SIZE);
#endif

        if((NULL == PpsSDVector)||(NULL == PpsSDVector->prgbData))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }
        if(0x00 == PpsSDVector->wLength)
        {
            i4Status = (int32_t)CMD_LIB_LENZERO_ERROR;
            break;
        }

        sApduData.bCmd = CMD_SETDATA;

        if((eDATA == PpsSDVector->eDataOrMdata)&&
        (eWRITE == PpsSDVector->eWriteOption))
        {
            sApduData.bParam = PARAM_SET_DATA;
        }
        else if((eDATA == PpsSDVector->eDataOrMdata)&&
        (eERASE_AND_WRITE == PpsSDVector->eWriteOption))
        {
            sApduData.bParam = PARAM_SET_DATA_ERASE;
        }
        else if((eMETA_DATA == PpsSDVector->eDataOrMdata)&&
        (eWRITE == PpsSDVector->eWriteOption))
        {
            sApduData.bParam = PARAM_SET_METADATA;
        }
        else
        {
            i4Status = (int32_t)CMD_LIB_INVALID_PARAM;
            break;
        }

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer+7;
        //copy OID
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsSDVector->wOID >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + 1] = (uint8_t)PpsSDVector->wOID;
        wOffset = PpsSDVector->wOffset;
        do
        {
            //While chaining for erase & write option, all subsequent write must be only write operation
            if((sApduData.bParam == PARAM_SET_DATA_ERASE)&&
            (wTotalWriteLen != 0))
            {
                sApduData.bParam = PARAM_SET_DATA;
            }
/// @cond hidden
#define OVERHEAD (OFFSET_PAYLOAD+BYTES_OID+BYTES_OFFSET)
/// @endcond

            wWriteLen = MIN((wMaxCommsBuffer-OVERHEAD),(PpsSDVector->wLength-wTotalWriteLen));

            //set data payload length is 4(OID length + offset length) plus length of data to write
            sApduData.wPayloadLength = BYTES_OID + BYTES_OFFSET + wWriteLen;

            //copy offset
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_OID] = (uint8_t)(wOffset >> BITS_PER_BYTE);
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_OID + 1] = (uint8_t)wOffset;
            //copy the data

            OCP_MEMCPY(sApduData.prgbAPDUBuffer+OVERHEAD,PpsSDVector->prgbData+wTotalWriteLen,wWriteLen);

                        //Set Response buffer length
                        sApduData.wResponseLength = BUFFER_SIZE;

            i4Status = TransceiveAPDU(&sApduData,TRUE);
            if(CMD_LIB_OK != i4Status)
            {
                break;
            }

            wTotalWriteLen += wWriteLen;
                        wOffset += wWriteLen;
        }while(wTotalWriteLen != PpsSDVector->wLength);
    }while(FALSE);

#ifndef STACK_ALLOC
        FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);
#else
        #undef STACK_ALLOC
#endif

/// @cond hidden
#undef OVERHEAD
#undef BUFFER_SIZE
/// @endcond

    return i4Status;
}

/**
* Reads maximum communication buffer size supported by the security chip.<br>
*
*
* Notes:
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
* - The function does not verify if the read access is permitted for the data object.<br>
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
*/
uint16_t CmdLib_GetMaxCommsBufferSize(Void)
{
        return wMaxCommsBuffer;
}
#endif /* MODULE_ENABLE_READ_WRITE */

/**
* Gets the signature generated by Security Chip. The message to be signed is provided by the user.<br>
* The following commands are issued in the sequence.<br>
* - SetAuthScheme : To set authentication scheme and the private key to be used <br>
* - SetAuthMsg : To write the message to Security Chip that must be digitally signed.<br>
* - GetAuthMsg : To read the digitally signed message from Security Chip.<br>
*
* <br>
* Notes: <br>
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
* - The function just returns the signature without verifying it.
* - The private key to be used in set auth scheme is passed in \ref #sAuthMsg_d.wOIDDevPrivKey.
* - The \ref #sAuthMsg_d.prgbRnd and \ref #sAuthMsg_d.wRndLength carry the challenge to be signed.
* - The length of challenge should be between 8 and 256 bytes. If the length of challenge is out of this range, #CMD_LIB_INVALID_LEN error is returned.<br>
*
*\param[in] PpsAuthMsg Pointer to Get Signature Object inputs
*\param[in,out] PpsResponse Pointer to Response structure
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INVALID_LEN
*/
int32_t CmdLib_GetSignature(const sAuthMsg_d *PpsAuthMsg, sCmdResponse_d *PpsResponse)
{
/// @cond hidden
#define STACK_ALLOC
#define GETSIGN_APDU_BUF_LEN	270             //4 (cmd header) + 256 (Max Payload) + additional 10
/// @endcond

    //lint --e{818} suppress "PpsResponse is out parameter"
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;
    sAuthScheme_d sAuthScheme;

    do
    {
//To use stack memory for APDU buffer, define STACK_ALLOC locally else heap memory is used
#ifdef STACK_ALLOC
        INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer,GETSIGN_APDU_BUF_LEN);
#else
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,GETSIGN_APDU_BUF_LEN);
#endif

        if((NULL == PpsAuthMsg)||(NULL == PpsAuthMsg->prgbRnd)||
        (NULL == PpsResponse)||(NULL == PpsResponse->prgbBuffer))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        //Check if Challenge length is in between 8 to 256
        if((CHALLENGE_MIN_LEN > PpsAuthMsg->wRndLength) || (CHALLENGE_MAX_LEN < PpsAuthMsg->wRndLength))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_LEN;
            break;
        }

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
                sApduData.wResponseLength = GETSIGN_APDU_BUF_LEN;

        //Set Auth scheme
                sAuthScheme.eAuthScheme = eECDSA;
                sAuthScheme.wDevicePrivKey = PpsAuthMsg->wOIDDevPrivKey;
                i4Status = CmdLib_SetAuthScheme(&sAuthScheme);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        //Set Auth msg
        sApduData.bCmd = CMD_SETAUTH_MSG;
        sApduData.bParam = PARAM_SET_AUTH_MSG;
        sApduData.wPayloadLength = PpsAuthMsg->wRndLength;
                sApduData.wResponseLength = GETSIGN_APDU_BUF_LEN;
        //copy the random number
        OCP_MEMCPY(sApduData.prgbAPDUBuffer+OFFSET_PAYLOAD,PpsAuthMsg->prgbRnd,PpsAuthMsg->wRndLength);
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        //Get Auth msg
        sApduData.bCmd = CMD_GETAUTH_MSG;
        sApduData.bParam = PARAM_GET_AUTH_MSG;
        sApduData.wPayloadLength = 0;
                sApduData.wResponseLength = GETSIGN_APDU_BUF_LEN;
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        //strip 4 byte apdu header
        sApduData.wResponseLength -= LEN_APDUHEADER;
        PpsResponse->wRespLength = sApduData.wResponseLength;
        if(PpsResponse->wBufferLength < sApduData.wResponseLength)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }
        OCP_MEMCPY(PpsResponse->prgbBuffer,sApduData.prgbAPDUBuffer+LEN_APDUHEADER,sApduData.wResponseLength);

    }while(FALSE);
#ifndef STACK_ALLOC
        FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);
#else
        #undef STACK_ALLOC
#endif

///@cond hidden
#undef GETSIGN_APDU_BUF_LEN
///@endcond

    return i4Status;
}

/**
 * Gets random bytes generated by the Security Chip.<br>
 *
 * <br>
 * Notes: <br>
 * - Command chaining is not supported in this API.<br>
 * - If the requested length of random bytes is either more than communication buffer size or more than the buffer size in PpsResponse,#CMD_LIB_INSUFFICIENT_MEMORY error is returned.<br>
 *
 *\param[in]		PpsRng		Pointer to sRngOptions_d to specify random number generation
 *\param[in,out]	PpsResponse Pointer to sCmdResponse_d to store random number
 *
 * \retval  #CMD_LIB_OK
 * \retval  #CMD_LIB_ERROR
 * \retval  #CMD_LIB_INSUFFICIENT_MEMORY
 * \retval  #CMD_LIB_LENZERO_ERROR
 * \retval  #CMD_DEV_ERROR
 * \retval  #CMD_LIB_NULL_PARAM
 */
int32_t CmdLib_GetRandom(const sRngOptions_d *PpsRng, sCmdResponse_d *PpsResponse)
{
    //lint --e{818} suppress "PpsResponse is out parameter"
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;

    do
    {
        //Initial value set it to NULL
        sApduData.prgbAPDUBuffer = NULL;

        if((NULL == PpsRng)||(NULL == PpsResponse)||(NULL == PpsResponse->prgbBuffer))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }
        if(0x00 == PpsResponse->wBufferLength)
        {
            i4Status = (int32_t)CMD_LIB_LENZERO_ERROR;
            break;
        }

        //If the length of requested random bytes is more than the maximum comms buffer size
        if((wMaxCommsBuffer) < (LEN_APDUHEADER + PpsRng->wRandomDataLen))
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }
        PpsResponse->wRespLength = 0;
        sApduData.bCmd = CMD_GET_RND;
        sApduData.bParam = (uint8_t)PpsRng->eRngType;
        sApduData.wPayloadLength = LEN_PL_OID;

        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer, (LEN_APDUHEADER + PpsRng->wRandomDataLen));

        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsRng->wRandomDataLen >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + 1] = (uint8_t)PpsRng->wRandomDataLen;
        sApduData.wResponseLength = (LEN_APDUHEADER + PpsRng->wRandomDataLen);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;

        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }
        //strip 4 byte apdu header
        sApduData.wResponseLength -= LEN_APDUHEADER;
        if(PpsResponse->wBufferLength < sApduData.wResponseLength)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }
        OCP_MEMCPY(PpsResponse->prgbBuffer,sApduData.prgbAPDUBuffer+LEN_APDUHEADER,sApduData.wResponseLength);
        PpsResponse->wRespLength = sApduData.wResponseLength;

    }while(FALSE);

    FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);

    return i4Status;
}

/**
* Sets the Authentication Scheme by issuing SetAuthScheme command to Security Chip.
*
* <br>
* Notes: <br>
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
* - Currently only 1 session OID (0xE100) is supported by the security chip.
*
*\param[in] PpsAuthVector Pointer to Authentication Scheme data
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INVALID_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_SetAuthScheme(const sAuthScheme_d *PpsAuthVector)
{
/// @cond hidden
#define SET_AUTH_SCHEME_APDU_BUF_LEN    10
/// @endcond

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;
    uint16_t wPayloadSize;

    do
    {
        INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer, SET_AUTH_SCHEME_APDU_BUF_LEN);

        if(NULL == PpsAuthVector)
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        //verify the param
        if(eDTLSClient == PpsAuthVector->eAuthScheme)
        {
            //Verify the range of session ID
            if((SESSION_ID_LOWER_VALUE > PpsAuthVector->wSessionKeyId)
                || (SESSION_ID_HIGHER_VALUE < PpsAuthVector->wSessionKeyId))
            {
                i4Status = (int32_t)CMD_LIB_INVALID_SESSIONID;
                break;
            }
            wPayloadSize = 4;
        }
        else if(eECDSA == PpsAuthVector->eAuthScheme)
        {
            wPayloadSize = 2;
        }
        else
        {
            i4Status = (int32_t)CMD_LIB_INVALID_PARAM;
            break;
        }

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;

        //Form the command
        //Assign Cmd,param,payload length
        sApduData.bCmd = CMD_SETAUTH_SCM;
        sApduData.bParam = (uint8_t)PpsAuthVector->eAuthScheme;
        sApduData.wPayloadLength = wPayloadSize;

        //Assign the device private key OID at payload offset
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsAuthVector->wDevicePrivKey >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD+1] = (uint8_t)PpsAuthVector->wDevicePrivKey;

        sApduData.wResponseLength = SET_AUTH_SCHEME_APDU_BUF_LEN;

        if(eDTLSClient == PpsAuthVector->eAuthScheme)
        {
            //Assign the session OID
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD+2] = (uint8_t)(PpsAuthVector->wSessionKeyId >> BITS_PER_BYTE);
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD+3] = (uint8_t)PpsAuthVector->wSessionKeyId;
        }

        //Transmit the Data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

    }while(FALSE);

/// @cond hidden
#undef SET_AUTH_SCHEME_APDU_BUF_LEN
/// @endcond

    return i4Status;
}

#ifdef MODULE_ENABLE_TOOLBOX
/**
* Calculates the hash of input data by using the Security Chip.<br>
*
* Input:<br>
* - Provide the required type of input data for hashing. Use \ref sCalcHash_d.eHashDataType with the following options,
*   - eDataStream : Indicates, sDataStream is considered as hash input.
*   - eOIDData : Indicates, sOIDData is considered for hash input.
*
* - Provide the input to import/export the hash context. Use \ref sContextInfo_d.eContextAction with the following options,
*   - #eImport : Import hash context to perform the hash.
*   - #eExport : Export current active hash context.
*   - #eImportExport : Import hash context and Export back the context after hashing.
*   - #eUnused : Context data import/export feature is not used. This option is also recommended for #eHashSequence_d as #eStartFinalizeHash or #eTerminateHash.
*
* Output:<br>
* - Successful API execution,
*   - Hash is returned in sOutHash only if #eHashSequence_d is #eStartFinalizeHash,#eIntermediateHash or #eFinalizeHash.<br>
*   - Hash context data is returned only if \ref sContextInfo_d.eContextAction is #eExport or #eImportExport.<br>
*
* Notes: <br>
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
* - #eTerminateHash in #eHashSequence_d is used to terminate any existing hash session. Any input data or hash context options supplied with this sequence is ignored.
* - Sequences for generating a hash successfully can be as follows:<br>
*     - #eStartHash,#eFinalizeHash<br>
*     - #eStartHash,#eContinueHash (single or multiple),#eFinalizeHash<br>
*     - #eStartFinalizeHash<br>
*     - #eStartHash,#eIntermediateHash,#eContinueHash,#eFinalizeHash<br>
*
* - If the memory buffer is not sufficient to store output hash/hash context or the data to be sent to security chip is more than communication buffer,#CMD_LIB_INSUFFICIENT_MEMORY error is retured.
* - This API does not maintain any state of hashing operations.<br>
* - There is no support for chaining while sending data therefore in order to avoid communication buffer overflow, the user must take care of fragmenting the data for hashing.<br>
*   Use the API #CmdLib_GetMaxCommsBufferSize to check the maximum communication buffer size supported by the security chip. In addition, the overhead for command APDU header and
*   TLV encoding must be considered as explained below.<br>
*
*   Read the maximum communication buffer size using the API #CmdLib_GetMaxCommsBufferSize() and store in a variable <b>"wMaxCommsBuffer"</b><br>
*   Substract the header overheads and hash context size(depends on applicable Hash algorithm) respectively from wMaxCommsBuffer. The result gives the Available_Size to frame the hash data input.<br>
*
*   - Only hash calculation : <br>
*   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Available_Size = (wMaxCommsBuffer - #CALC_HASH_FIXED_OVERHEAD_SIZE)<br>
*   - Import context to security chip and calculate hash  : <br>
*   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Available_Size = (wMaxCommsBuffer - #CALC_HASH_FIXED_OVERHEAD_SIZE - #CALC_HASH_IMPORT_OR_EXPORT_OVERHEAD_SIZE - #CALC_HASH_SHA256_CONTEXT_SIZE)<br>
*   - Calulate hash and export context out of security chip : <br>
*   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Available_Size = (wMaxCommsBuffer - #CALC_HASH_FIXED_OVERHEAD_SIZE - #CALC_HASH_IMPORT_OR_EXPORT_OVERHEAD_SIZE)<br>
*   - Import context to security chip, calculate hash and export context out of security chip :<br>
*   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Available_Size = (wMaxCommsBuffer - #CALC_HASH_FIXED_OVERHEAD_SIZE - #CALC_HASH_IMPORT_AND_EXPORT_OVERHEAD_SIZE - #CALC_HASH_SHA256_CONTEXT_SIZE)<br>
*
*
* \param[in,out] PpsCalcHash Pointer to #sCalcHash_d that contains information to calculate hash
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_EXEC_ERROR
* \retval  #CMD_DEV_ERROR
*/
int32_t CmdLib_CalcHash(sCalcHash_d* PpsCalcHash)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;
    eDataType_d eHashDataType;
    uint16_t wMemoryAllocLen;
    uint16_t wInDataLen;
    sHashinfo_d* psHashinfo;
    uint16_t wOptTagLen = 0;
    uint16_t wOptTagOffset = 0;
    uint16_t wOffset;
    uint16_t wBufferLen;

    do
    {
        //Initial value set it to NULL
        sApduData.prgbAPDUBuffer = NULL;

        //Check for NULL inputs
        if(NULL == PpsCalcHash)
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        i4Status = Get_HashInfo(PpsCalcHash->eHashAlg, &psHashinfo);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        //For eHashSequence_d as eFinalizeHash,validate sOutData
        if(((eFinalizeHash == PpsCalcHash->eHashSequence) || (eStartFinalizeHash == PpsCalcHash->eHashSequence) ||
                        (eIntermediateHash == PpsCalcHash->eHashSequence)) && (NULL == PpsCalcHash->sOutHash.prgbBuffer))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        //Validate the Context data buffer if optional tag is provided
        if((eUnused != PpsCalcHash->sContextInfo.eContextAction) && (NULL == PpsCalcHash->sContextInfo.pbContextData))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

/// @cond hidden
#define INDATA_LEN_OID     (BYTES_OID + BYTES_LENGTH + BYTES_OFFSET)
#define NIBBLE_LEN      4
/// @endcond

        eHashDataType = PpsCalcHash->eHashDataType;

        //For eHashDataType_d as eDataStream, validate psDataStream
        if(eTerminateHash == PpsCalcHash->eHashSequence)
        {
            wInDataLen = 0;
                        eHashDataType = eDataStream;
        }
        else if(eDataStream == eHashDataType)
        {
            if(NULL == PpsCalcHash->sDataStream.prgbStream)
            {
                i4Status = (int32_t)CMD_LIB_NULL_PARAM;
                break;
            }
            //Set the total data length as input length
            wInDataLen = PpsCalcHash->sDataStream.wLen;
        }
        else
        {
            //Set the total data length as 6 bytes (2 byte OID + 2 bytes Offset + 2 bytes Length)
            wInDataLen = INDATA_LEN_OID;
        }

        //Calculate the offset and length for optional tags in the command APDU
        if(eUnused != PpsCalcHash->sContextInfo.eContextAction)
        {
            wOptTagLen = (eExport != PpsCalcHash->sContextInfo.eContextAction)? (CALC_HASH_IMPORT_OR_EXPORT_OVERHEAD_SIZE + PpsCalcHash->sContextInfo.dwContextLen) : (CALC_HASH_IMPORT_OR_EXPORT_OVERHEAD_SIZE);
            //Total length of optional tag which includes tag, length and data
            if(eImportExport == PpsCalcHash->sContextInfo.eContextAction)
            {
                wOptTagLen += CALC_HASH_IMPORT_OR_EXPORT_OVERHEAD_SIZE;
            }
            wOptTagOffset = (eDataStream == PpsCalcHash->eHashDataType)? (OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH + wInDataLen) :
                                (OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH + INDATA_LEN_OID);
        }

        //Validate the size of input data with the Communication buffer
        if((wInDataLen + wOptTagLen + CALC_HASH_FIXED_OVERHEAD_SIZE) > wMaxCommsBuffer)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        //Form data
        sApduData.bCmd = CMD_CALCHASH;
        sApduData.bParam = (uint8_t)PpsCalcHash->eHashAlg;

        wMemoryAllocLen = CALC_HASH_FIXED_OVERHEAD_SIZE + wInDataLen + wOptTagLen;

        wBufferLen = CALC_HASH_FIXED_OVERHEAD_SIZE;

        //Check to validate sufficient memory to store the output
        //If Hash is the output
        if((eFinalizeHash == PpsCalcHash->eHashSequence) || (eStartFinalizeHash == PpsCalcHash->eHashSequence) ||
            (eIntermediateHash == PpsCalcHash->eHashSequence))
        {
             wBufferLen +=  psHashinfo->bHashLen;
        }
        //If context data is output
        if((eExport == PpsCalcHash->sContextInfo.eContextAction) || (eImportExport == PpsCalcHash->sContextInfo.eContextAction))
        {
            wBufferLen += psHashinfo->wHashCntx;
        }

        if(wBufferLen > wMemoryAllocLen)
        {
            wMemoryAllocLen = wBufferLen;
        }

        // Allocate the memory
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer, wMemoryAllocLen);

        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(((uint8_t)eHashDataType << NIBBLE_LEN) | (uint8_t) PpsCalcHash->eHashSequence);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ] = (uint8_t)(wInDataLen >> 8);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + 1] = (uint8_t)wInDataLen ;

        if(eTerminateHash != PpsCalcHash->eHashSequence)
        {
                        //If the DataType is Data stream, copy the input data to the buffer
            if(eDataStream == eHashDataType)
            {
                OCP_MEMCPY(&sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH], PpsCalcHash->sDataStream.prgbStream,
                wInDataLen);
            }
            else
            {
                //If the Data type is OID, copy the OID information to the buffer
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH] = (uint8_t)(PpsCalcHash->sOIDData.wOID >> 8);
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH + 1] = (uint8_t)PpsCalcHash->sOIDData.wOID;
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH + BYTES_OID] = (uint8_t)(PpsCalcHash->sOIDData.wOffset >> 8);
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + BYTES_LENGTH + BYTES_OID + 1] = (uint8_t)PpsCalcHash->sOIDData.wOffset;
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + INDATA_LEN_OID] = (uint8_t)(PpsCalcHash->sOIDData.wLength >> 8);
                sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + BYTES_SEQ + INDATA_LEN_OID + 1] = (uint8_t)(PpsCalcHash->sOIDData.wLength);
            }

/// @cond hidden
#define OFFSET_EXPORT_CNTXTAG   (wOptTagOffset + BYTES_SEQ+ BYTES_LENGTH + PpsCalcHash->sContextInfo.dwContextLen)
/// @endcond

            //If the optional tag is either eImport or eImportAndExport, 0x06 tag is sent as part of command APDU
            if((eImportExport == PpsCalcHash->sContextInfo.eContextAction) ||
            (eImport == PpsCalcHash->sContextInfo.eContextAction))
            {
                sApduData.prgbAPDUBuffer[wOptTagOffset] = (uint8_t)eImport;
                sApduData.prgbAPDUBuffer[wOptTagOffset + BYTES_SEQ] = (uint8_t)(PpsCalcHash->sContextInfo.dwContextLen >> 8);
                sApduData.prgbAPDUBuffer[wOptTagOffset + BYTES_SEQ + 1] = (uint8_t)(PpsCalcHash->sContextInfo.dwContextLen);
                OCP_MEMCPY(&sApduData.prgbAPDUBuffer[wOptTagOffset + BYTES_SEQ + BYTES_LENGTH], PpsCalcHash->sContextInfo.pbContextData,
                            PpsCalcHash->sContextInfo.dwContextLen);
            }

            //If the optional tag is either eExport or eImportAndeExport, 0x07 tag is sent as part of command APDU
            if((eImportExport == PpsCalcHash->sContextInfo.eContextAction) ||
            (eExport == PpsCalcHash->sContextInfo.eContextAction))
            {
                wOffset = (eExport == PpsCalcHash->sContextInfo.eContextAction)?wOptTagOffset : OFFSET_EXPORT_CNTXTAG;
                sApduData.prgbAPDUBuffer[wOffset] = (uint8_t)eExport;
                sApduData.prgbAPDUBuffer[wOffset + BYTES_SEQ] = 0x00;
                sApduData.prgbAPDUBuffer[wOffset + BYTES_SEQ + 1] =0x00;
            }
        }

        //set data payload length is 3(BYTES_SEQ + BYTES_LENGTH) plus length of data to write
        sApduData.wPayloadLength = BYTES_SEQ + BYTES_LENGTH + wInDataLen + wOptTagLen;

        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;

        sApduData.wResponseLength = wMemoryAllocLen;

        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

/// @cond hidden
#define TAG_HASH_OUTPUT         0x01
#define TAG_CONTEXT_OUTPUT      0x06
/// @endcond

        sApduData.wResponseLength -= LEN_APDUHEADER;

        //Validate the output buffer size if tag received on reponse is 0x01 and
        //copy the hash data to sOutput buffer
        if((TAG_HASH_OUTPUT == (*(sApduData.prgbRespBuffer + LEN_APDUHEADER))) && (sApduData.wResponseLength != 0))
        {
            //Length check for sOutData
            if((psHashinfo->bHashLen) > PpsCalcHash->sOutHash.wBufferLength)
            {
                i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
                break;
            }

            PpsCalcHash->sOutHash.wRespLength = Utility_GetUint16(sApduData.prgbRespBuffer + LEN_APDUHEADER + BYTES_SEQ);
            OCP_MEMCPY(PpsCalcHash->sOutHash.prgbBuffer, (sApduData.prgbRespBuffer + CALC_HASH_FIXED_OVERHEAD_SIZE), PpsCalcHash->sOutHash.wRespLength);
        }

        //Validate the Context buffer size if the 0x06 context data tag is there in response and
        //copy the context data to pbContextData buffer
        if((TAG_CONTEXT_OUTPUT == (*(sApduData.prgbRespBuffer + LEN_APDUHEADER))) && (sApduData.wResponseLength != 0))
        {
            //Length check for Context Data
            if((psHashinfo->wHashCntx) > PpsCalcHash->sContextInfo.dwContextLen)
            {
                i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
                break;
            }

            PpsCalcHash->sContextInfo.dwContextLen = Utility_GetUint16(sApduData.prgbRespBuffer + LEN_APDUHEADER + BYTES_SEQ);
            OCP_MEMCPY(PpsCalcHash->sContextInfo.pbContextData, (sApduData.prgbRespBuffer + CALC_HASH_FIXED_OVERHEAD_SIZE), PpsCalcHash->sContextInfo.dwContextLen);
        }

    }while(FALSE);

        FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);

/// @cond hidden
#undef INDATA_LEN_OID
#undef NIBBLE_LEN
#undef OFFSET_EXPORT_CNTXTAG
#undef TAG_HASH_OUTPUT
#undef TAG_CONTEXT_OUTPUT
/// @endcond

    return i4Status;
}

/**
* Verifies the signature over the input digest by using the Security Chip.<br>
*
* Input:<br>
* - For eVerifyDataType
*   - #eDataStream indicates that sPubKeyInput is considered for signature verification.<br>
*   - #eOIDData indicates that wOIDPubKey is considered for signature verification.<br>
*
* Output:<br>
* - Successful signature verification returns #CMD_LIB_OK.<br>
*
* Notes: <br>
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.<br>
* - If the the data to be sent to security chip is more than communication buffer,#CMD_LIB_INSUFFICIENT_MEMORY is returned. Refer OPTIGA_Trust_X_SolutionReferenceManual_v1.x.pdf for more details.
*
* \param[in]     PpsVerifySign  Pointer to information for verifying signature
* \param[in,out] PpsDigest      pointer to a blob which holds the Digest
* \param[in,out] PpsSignature   pointer to a blob which holds the Signature to be verified
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_EXEC_ERROR
* \retval  #CMD_DEV_ERROR
*/
int32_t CmdLib_VerifySign(const sVerifyOption_d* PpsVerifySign,const sbBlob_d * PpsDigest,const sbBlob_d * PpsSignature)
{

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData = {0};
    uint16_t wWritePosition = OFFSET_PAYLOAD;
    uint16_t wCalApduLen = 0;

/// @cond hidden
        ///Minimum length of APDU InData in case of Public Key from Host. [TLV Header(3) for Digest + TLV Header (3) for Signature + TLV Header(3) for Public Key + TLV for Algo (4)]
        #define DATA_STREAM_APDU_INDATA_LEN		13
        ///Minimum length of APDU InData in case of Public Key OID. [TLV Header(3) for Digest + TLV Header (3) for Signature + TLV for Public Key OID (5)]
        #define OID_APDU_INDATA_LEN				11
/// @endcond

    do
        {
        //NULL checks
        if((NULL == PpsVerifySign) || (NULL == PpsDigest->prgbStream) ||
        (NULL == PpsSignature->prgbStream))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }
        if(eDataStream == PpsVerifySign->eVerifyDataType)
        {
            //NULL checks
            if(NULL == PpsVerifySign->sPubKeyInput.sDataStream.prgbStream)
            {
                i4Status = (int32_t)CMD_LIB_NULL_PARAM;
                break;
            }
            wCalApduLen = OFFSET_PAYLOAD + DATA_STREAM_APDU_INDATA_LEN + PpsDigest->wLen + PpsSignature->wLen + PpsVerifySign->sPubKeyInput.sDataStream.wLen;
        }
        if(eOIDData == PpsVerifySign->eVerifyDataType)
        {
            wCalApduLen = OFFSET_PAYLOAD + OID_APDU_INDATA_LEN + PpsDigest->wLen + PpsSignature->wLen;
        }
        if((wMaxCommsBuffer) < wCalApduLen)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        //Allocating Heap memory
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,wCalApduLen);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
                                sApduData.wResponseLength = wMaxCommsBuffer;
        //Set digest tag, length, data
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = TAG_DIGEST;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], PpsDigest->wLen);
        OCP_MEMCPY(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET],PpsDigest->prgbStream,PpsDigest->wLen);
        wWritePosition += TAG_VALUE_OFFSET+ PpsDigest->wLen;

        //Set signature tag, length, data
        sApduData.prgbAPDUBuffer[wWritePosition] = TAG_SIGNATURE;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], PpsSignature->wLen);
        OCP_MEMCPY(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET],PpsSignature->prgbStream,PpsSignature->wLen);
        wWritePosition += TAG_VALUE_OFFSET + PpsSignature->wLen;


        if(eDataStream == PpsVerifySign->eVerifyDataType)
        {
            //Set TLV values for external public key
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_ALGO_IDENTIFIER;

            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_ALGO_IDENTIFIER);
            sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET] = (uint8_t)PpsVerifySign->sPubKeyInput.eAlgId;

            sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET + BYTES_SEQ] = (uint8_t)TAG_PUB_KEY;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET + BYTES_OFFSET], PpsVerifySign->sPubKeyInput.sDataStream.wLen);
            wWritePosition += TAG_VALUE_OFFSET + BYTES_OFFSET + BYTES_OFFSET;
            OCP_MEMCPY(&sApduData.prgbAPDUBuffer[wWritePosition],PpsVerifySign->sPubKeyInput.sDataStream.prgbStream ,PpsVerifySign->sPubKeyInput.sDataStream.wLen);
            //Total payload length
            sApduData.wPayloadLength = (uint16_t)(wWritePosition + PpsVerifySign->sPubKeyInput.sDataStream.wLen - OFFSET_PAYLOAD);
        }

        if(eOIDData == PpsVerifySign->eVerifyDataType)
        {
            //Set TLV values for public key OID
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_PUB_KEY_OID;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_PUB_KEY);
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET], PpsVerifySign->wOIDPubKey);
            //Total payload length
            sApduData.wPayloadLength = (uint16_t)(wWritePosition + TAG_VALUE_OFFSET + BYTES_OFFSET - OFFSET_PAYLOAD);
        }

        //Form Command
        sApduData.bCmd = CMD_VERIFYSIGN;
        sApduData.bParam = (uint8_t)PpsVerifySign->eSignScheme;


        //Transmit data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }
    }while(FALSE);

    //Free the allocated memory for buffer
    FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);

/// @cond hidden
    #undef DATA_STREAM_APDU_INDATA_LEN
    #undef OID_APDU_INDATA_LEN
/// @endcond

    return i4Status;
}

/**
* Generates a key pair by using the Security Chip.<br>
*
* Input:
* - Provide the required option for exporting the generated keys. Use \ref sKeyPairOption_d.eKeyExport
*   - #eStorePrivKeyOnly indicates that only private key is stored in the OID and public key is exported.
*   - #eExportKeyPair indicates that both public and private keys are exported.
*
* Output:
* - Successful API execution,
*   - Public key is returned in \ref sOutKeyPair_d.sPublicKey.
*   - Private key is returned in \ref sOutKeyPair_d.sPrivateKey , if input is #eExportKeyPair.
*
* Notes:
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.
* - Values of #eKeyUsage_d can be logically 'ORed' and passed to \ref sKeyPairOption_d.eKeyUsage.
* - If the memory buffers in #sOutKeyPair_d is not sufficient to store the generated keys,#CMD_LIB_INSUFFICIENT_MEMORY is returned. Refer OPTIGA_Trust_X_SolutionReferenceManual_v1.x.pdf for more details.
*
* \param[in] PpsKeyPairOption Pointer to #sKeyPairOption_d to provide input for key pair generation
* \param[in,out] PpsOutKeyPair Pointer to #sOutKeyPair_d that contains generated key pair
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_EXEC_ERROR
* \retval  #CMD_DEV_ERROR
*/
int32_t CmdLib_GenerateKeyPair(const sKeyPairOption_d* PpsKeyPairOption,sOutKeyPair_d* PpsOutKeyPair)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wWritePosition = LEN_APDUHEADER;
    uint16_t wCalApduLen;
    uint16_t wLen;
    uint16_t wParsLen;
    uint8_t bMultiplier;
    sApduData_d sApduData = {0};
    uint8_t wAlgoLen;
    sbBlob_d * psBlobKey = NULL;

/// @cond hidden
    ///Tag for public key
    #define TAG_PUBLIC_KEY                  0x02
    ///Minimum length of APDU InData in case of Private key store. [TLV Header(3) of OID + OID (2) + TLV Header(3) for key usage identifier  + Identifier (1)]
    #define PRIV_KEY_APDU_INDATA_LEN		9
    /// Encoding bytes for private and public key
    #define KEY_PAIR_INDATA_LEN				4
/// @endcond

    do
    {
        //NULL checks
        if((NULL == PpsKeyPairOption) || (NULL == PpsOutKeyPair) || (NULL == PpsOutKeyPair->sPublicKey.prgbStream))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        wCalApduLen = LEN_APDUHEADER + PRIV_KEY_APDU_INDATA_LEN;
        bMultiplier = 2;
        if(eExportKeyPair == PpsKeyPairOption->eKeyExport)
        {
            //NULL checks
            if(NULL == PpsOutKeyPair->sPrivateKey.prgbStream)
            {
                i4Status = (int32_t)CMD_LIB_NULL_PARAM;
                break;
            }
            wCalApduLen = LEN_APDUHEADER + KEY_PAIR_INDATA_LEN + TAG_VALUE_OFFSET + TAG_VALUE_OFFSET;
            bMultiplier = 3;
        }
        //Get key size using algorithm identifier
        i4Status = Get_KeySize(PpsKeyPairOption->eAlgId, &wAlgoLen);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        wCalApduLen += ((wAlgoLen * bMultiplier) + 2);
        //Allocating Heap memory
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,wCalApduLen);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        sApduData.wResponseLength = wCalApduLen;
        if(eStorePrivKeyOnly == PpsKeyPairOption->eKeyExport)
        {
            //Set private key OID tag, length, data
            sApduData.prgbAPDUBuffer[LEN_APDUHEADER] = TAG_OID;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_PRI_KEY);
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET], PpsKeyPairOption->wOIDPrivKey);

            wWritePosition += TAG_VALUE_OFFSET+ BYTES_OFFSET;

            //Set key usage identifier tag, length, data
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_KEY_USAGE_IDENTIFIER;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_KEY_USAGE_IDENTIFIER);
            sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET] = (uint8_t)PpsKeyPairOption->eKeyUsage;
            wWritePosition += TAG_VALUE_OFFSET + BYTES_SEQ;
        }

        if(eExportKeyPair == PpsKeyPairOption->eKeyExport)
        {
            //Set TLV values for extract key pair
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_EXPORT_KEY_PAIR;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_EXPORT_KEY_PAIR);
            wWritePosition += TAG_VALUE_OFFSET;
        }
        sApduData.wPayloadLength = (uint16_t)(wWritePosition - LEN_APDUHEADER);
        //Form Command
        sApduData.bCmd = CMD_GENERATE_KEY_PAIR;
        sApduData.bParam = (uint8_t)PpsKeyPairOption->eAlgId;

        //Transmit data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        wParsLen = LEN_APDUHEADER;

        do
        {
            wLen = Utility_GetUint16(&sApduData.prgbRespBuffer[wParsLen+BYTES_SEQ]);
            psBlobKey = (TAG_PUBLIC_KEY == sApduData.prgbRespBuffer[wParsLen])?&(PpsOutKeyPair->sPublicKey):&(PpsOutKeyPair->sPrivateKey);
            if(wLen > psBlobKey->wLen)
            {
                i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
                break;
            }
            //Copy public key to output buffer
            OCP_MEMCPY(psBlobKey->prgbStream,&sApduData.prgbRespBuffer[TAG_VALUE_OFFSET + wParsLen] ,wLen);
            psBlobKey->wLen = wLen;
            wParsLen += (wLen + TAG_VALUE_OFFSET);

        } while (wParsLen != sApduData.wResponseLength);

    } while(FALSE);

    //Free the allocated memory for buffer
    FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);

/// @cond hidden
    #undef TAG_PUBLIC_KEY
    #undef PRIV_KEY_APDU_INDATA_LEN
    #undef KEY_PAIR_INDATA_LEN
/// @endcond

    return i4Status;
}

/**
* Calculates signature on a digest by using the Security Chip.<br>
*
* Input:
* - Provide the signature scheme. Use \ref sCalcSignOptions_d.eSignScheme.
* - Provide the digest to be signed. Use \ref sCalcSignOptions_d.sDigestToSign.
* - Provide the OID of the private key. Use \ref sCalcSignOptions_d.wOIDSignKey.
*
* Output:
* - Successful API execution,
*   - Signature is returned in PpsSignature.<br>
*
* Notes:
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.
* - If the the data to be sent to security chip is more than communication buffer,#CMD_LIB_INSUFFICIENT_MEMORY is returned. Refer OPTIGA_Trust_X_SolutionReferenceManual_v1.x.pdf for more details.
* - If the memory buffer in PpsSignature is not sufficient to store the generated signature,#CMD_LIB_INSUFFICIENT_MEMORY is returned.

*
* \param[in] PpsCalcSign Pointer to #sCalcSignOptions_d to provide input for signature generation
* \param[in,out] PpsSignature Pointer to #sbBlob_d that contains generated signature
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_EXEC_ERROR
* \retval  #CMD_DEV_ERROR
*/
int32_t CmdLib_CalculateSign(const sCalcSignOptions_d *PpsCalcSign,sbBlob_d *PpsSignature)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wWritePosition = LEN_APDUHEADER;
    uint16_t wCalApduLen;
    sApduData_d sApduData = {0};


    do
    {
        //NULL checks
        if((NULL == PpsCalcSign) || (NULL == PpsSignature->prgbStream) || (NULL == PpsCalcSign->sDigestToSign.prgbStream))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }


/// @cond hidden
///Minimum length of APDU InData in case of calculate sign. [TLV Header(3) of OID  + OID (2) + TLV Header(3) for digest ]
#define CALSIGN_APDU_LEN        8
///Tag for Signature length
#define SIGNATURE_LEN           0x77
///Total value required while sending the command
#define TX_LEN                  (CALSIGN_APDU_LEN + PpsCalcSign->sDigestToSign.wLen)
/// @endcond

        //Calculate the size of memory to be allocated
        wCalApduLen = LEN_APDUHEADER + (TX_LEN > SIGNATURE_LEN ? TX_LEN : SIGNATURE_LEN);
        if((wMaxCommsBuffer) < wCalApduLen)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        //Allocating Heap memory
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,wCalApduLen);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        sApduData.wResponseLength = wCalApduLen;

        //Set digest tag, length, data
        sApduData.prgbAPDUBuffer[LEN_APDUHEADER] = TAG_DIGEST;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], PpsCalcSign->sDigestToSign.wLen);
        OCP_MEMCPY(&sApduData.prgbRespBuffer[TAG_VALUE_OFFSET + wWritePosition],PpsCalcSign->sDigestToSign.prgbStream,PpsCalcSign->sDigestToSign.wLen);
        wWritePosition += TAG_VALUE_OFFSET + PpsCalcSign->sDigestToSign.wLen;

        //Set OID of signature key tag, length, data
        sApduData.prgbAPDUBuffer[wWritePosition] = TAG_OID_SIG_KEY;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_OID_SIG_KEY);
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET], PpsCalcSign->wOIDSignKey);

        wWritePosition += TAG_VALUE_OFFSET + LEN_OID_SIG_KEY;

        sApduData.wPayloadLength = (uint16_t)(wWritePosition - LEN_APDUHEADER);
        //Form Command
        sApduData.bCmd = CMD_CALC_SIGN;
        sApduData.bParam = (uint8_t)PpsCalcSign->eSignScheme;

        //Transmit data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }
        sApduData.wResponseLength -= LEN_APDUHEADER;
        if(sApduData.wResponseLength > PpsSignature->wLen)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }
        //Copy signature to output buffer
        OCP_MEMCPY(PpsSignature->prgbStream,&sApduData.prgbRespBuffer[LEN_APDUHEADER],sApduData.wResponseLength);
        PpsSignature->wLen = sApduData.wResponseLength;

    }while(FALSE);

    //Free the allocated memory for buffer
    FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);


/// @cond hidden
#undef CALSIGN_APDU_LEN
#undef SIGNATURE_LEN
#undef TX_LEN
/// @endcond
    return i4Status;
}

/**
* Generates a shared secret by using the Security Chip.<br>
*
* Input:
* - Provide the key agreement algorithm for generating shared secret. Use \ref sCalcSSecOptions_d.eKeyAgreementType.
* - Provide the OID of private key. Use \ref sCalcSSecOptions_d.wOIDPrivKey.
* - Provide the algorithm identifier of the public key. Use \ref sCalcSSecOptions_d.ePubKeyAlgId.
* - Provide the public key. Use \ref sCalcSSecOptions_d.sPubKey.
* - Provide the OID to store the shared secret. Use \ref sCalcSSecOptions_d.wOIDSharedSecret.
*   - 0x0000 indicates that the shared secret is exported.
*
* Output:
* - Successful API execution,
*   - Calculated shared secret is returned in PpsSecret if \ref sCalcSSecOptions_d.wOIDSharedSecret is 0x0000.
*
* Notes:
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.
* - If the the data to be sent to security chip is more than communication buffer,#CMD_LIB_INSUFFICIENT_MEMORY is returned. Refer OPTIGA_Trust_X_SolutionReferenceManual_v1.x.pdf for more details.
* - If the memory buffer in PpsSecret is not sufficient to store the calculated secret,#CMD_LIB_INSUFFICIENT_MEMORY is returned.

*
* \param[in] PpsCalcSSec Pointer to #sCalcSSecOptions_d to provide input for shared secret calculation
* \param[in,out] PpsSecret Pointer to #sbBlob_d that contains calculated shared secret
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_EXEC_ERROR
* \retval  #CMD_DEV_ERROR
*/
int32_t CmdLib_CalculateSharedSecret(const sCalcSSecOptions_d *PpsCalcSSec,sbBlob_d *PpsSecret)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wWritePosition = LEN_APDUHEADER;
    uint16_t wCalApduLen = 0;
    sApduData_d sApduData = {0};

    do
    {
        //NULL checks
        if((NULL == PpsCalcSSec) || (NULL == PpsCalcSSec->sPubKey.prgbStream))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        /// @cond hidden
        ///Minimum length of APDU InData in case of calculate shared secret.
                ///[TLV Header(3) of OID Private key + OID Private key (2) + TLV Header(3) for public key algoId + algoId (1) + TLV Header(3) for public key + TLV Header(3) for alternative ]
        #define CALCSSEC_APDU_LEN		15
        ///Tag for public key
        #define TAG_PUBLIC_KEY			0x06
        ///Len for privet key oid
        #define LEN_EXPORT_SHAR_SEC     0x0000
        ///Len for share sec oid
        #define	LEN_OID_SHARE_SEC		0x0002
        ///Share sec OID zero value
        #define	OID_SHARE_SEC_ZERO	    0x0000
        ///Tag for export share secret
        #define TAG_EXPORT_SHARE_SEC    0x07
        ///Tag for share secret oid
        #define TAG_OID_SHARE_SEC		0x08
        ///Minimum length of APDU
        #define TX_LEN					(CALCSSEC_APDU_LEN + PpsCalcSSec->sPubKey.wLen + 2)
        /// @endcond

                //Considering the size of Indata for allocating memory as this size is also sufficient for storing the response
        wCalApduLen = LEN_APDUHEADER + TX_LEN;
        //NULL checks
        if(OID_SHARE_SEC_ZERO == PpsCalcSSec->wOIDSharedSecret)
        {
            if(NULL == PpsSecret->prgbStream)
            {
                    i4Status = (int32_t)CMD_LIB_NULL_PARAM;
                    break;
            }
            wCalApduLen -=2;
        }

                //Check max comms buffer size
        if((wMaxCommsBuffer) < wCalApduLen)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        //Allocating Heap memory
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,wCalApduLen);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        sApduData.wResponseLength = wCalApduLen;

        //Set privet key tag, length, data
        sApduData.prgbAPDUBuffer[LEN_APDUHEADER] = TAG_OID;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET],LEN_PRI_KEY);
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET],PpsCalcSSec->wOIDPrivKey);
        wWritePosition += TAG_VALUE_OFFSET + LEN_PRI_KEY;

        //Set public key algoId tag, length, data
        sApduData.prgbAPDUBuffer[wWritePosition] = TAG_ALGO_IDENTIFIER;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET],LEN_ALGO_IDENTIFIER);
        sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET] = (uint8_t)PpsCalcSSec->ePubKeyAlgId;
        wWritePosition += TAG_VALUE_OFFSET + LEN_ALGO_IDENTIFIER;

        //Set public key tag, length, data
        sApduData.prgbAPDUBuffer[wWritePosition] = TAG_PUBLIC_KEY;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET],PpsCalcSSec->sPubKey.wLen);
        OCP_MEMCPY(&sApduData.prgbRespBuffer[TAG_VALUE_OFFSET + wWritePosition],PpsCalcSSec->sPubKey.prgbStream,PpsCalcSSec->sPubKey.wLen);
        wWritePosition += TAG_VALUE_OFFSET + PpsCalcSSec->sPubKey.wLen;

        if(OID_SHARE_SEC_ZERO == PpsCalcSSec->wOIDSharedSecret)
        {
            //Set export share sec tag, length, data
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_EXPORT_SHARE_SEC;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_EXPORT_SHAR_SEC);
            wWritePosition += TAG_VALUE_OFFSET;
        }
        else
        {
            //Set OID of signature key tag, length, data
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_OID_SHARE_SEC;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_OID_SHARE_SEC);
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET], PpsCalcSSec->wOIDSharedSecret);
            wWritePosition += TAG_VALUE_OFFSET + LEN_OID_SHARE_SEC;
        }

        sApduData.wPayloadLength = (uint16_t)(wWritePosition - LEN_APDUHEADER);
        //Form Command
        sApduData.bCmd = CMD_CALC_SHARED_SEC;
        sApduData.bParam = (uint8_t)PpsCalcSSec->eKeyAgreementType;

        //Transmit data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        sApduData.wResponseLength -= LEN_APDUHEADER;
        if(OID_SHARE_SEC_ZERO == PpsCalcSSec->wOIDSharedSecret)
        {
            if(sApduData.wResponseLength > PpsSecret->wLen)
            {
                i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
                break;
            }
            //Copy signature to output buffer
            OCP_MEMCPY(PpsSecret->prgbStream,&sApduData.prgbRespBuffer[LEN_APDUHEADER],sApduData.wResponseLength);
            PpsSecret->wLen = sApduData.wResponseLength;
        }
    }while(FALSE);

    //Free the allocated memory for buffer
    FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);

    /// @cond hidden
    #undef CALCSSEC_APDU_LEN
    #undef TAG_PUBLIC_KEY
    #undef LEN_EXPORT_SHAR_SEC
    #undef LEN_OID_SHARE_SEC
    #undef OID_SHARE_SEC_ZERO
    #undef TAG_EXPORT_SHARE_SEC
    #undef TAG_OID_SHARE_SEC
    #undef TX_LEN
    /// @endcond
    return i4Status;
}

/**
* Derives a session key by using the Security Chip.<br>
*
* Input:
* - Provide the key derivation method. Use \ref sDeriveKeyOptions_d.eKDM.
* - Provide the OID of the shared secret. Use \ref sDeriveKeyOptions_d.wOIDSharedSecret.
* - Provide the input seed. Use \ref sDeriveKeyOptions_d.sSeed.
* - Provide the length for derived key. Use \ref sDeriveKeyOptions_d.wDerivedKeyLen.
* - Provide the OID to store the derived key. Use \ref sDeriveKeyOptions_d.wOIDDerivedKey.
*   - 0x0000 indicates that the derived key is exported.
*
* Output:
* - Successful API execution,
*   - Derived key is returned in PpsKey if \ref sDeriveKeyOptions_d.wOIDDerivedKey is 0x0000.
*
* Notes:
* - Application on security chip must be opened using #CmdLib_OpenApplication before using this API.
* - If the the data to be sent to security chip is more than communication buffer,#CMD_LIB_INSUFFICIENT_MEMORY is returned. Refer OPTIGA_Trust_X_SolutionReferenceManual_v1.x.pdf for more details.
* - If the memory buffer in PpsKey is not sufficient to store the derived key,#CMD_LIB_INSUFFICIENT_MEMORY is returned.

*
* \param[in] PpsDeriveKey	Pointer to #sDeriveKeyOptions_d to provide input for session key generation
* \param[in,out] PpsKey		Pointer to #sbBlob_d that contains the derived key
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_NULL_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_EXEC_ERROR
* \retval  #CMD_DEV_ERROR
*/
int32_t CmdLib_DeriveKey(const sDeriveKeyOptions_d *PpsDeriveKey,sbBlob_d *PpsKey)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    uint16_t wWritePosition = LEN_APDUHEADER;
    uint16_t wCalApduLen = 0;
    sApduData_d sApduData = {0};

    do
    {
        //NULL checks
        if((NULL == PpsDeriveKey) || (NULL == PpsDeriveKey->sSeed.prgbStream))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        /// @cond hidden
        ///Minimum length of APDU InData in case of calculate shared secret.
                ///[TLV Header(3) of OID share secret + OID share secret (2) + TLV Header(3) for seed + TLV Header(3) for derive secret length + derive secret length(2) + TLV Header(3) for alternative ]
        #define DERIVEKEY_APDU_LEN		16
        ///Tag for derive key
        #define TAG_DERIVE_KEY			0x03
        ///Len for export derive key
        #define LEN_EXPORT_DERIVE_KEY   0x0000
        ///Len for share sec oid
        #define	LEN_DERIVE_KEY			0x0002
        ///Derive key OID zero value
        #define	OID_DERIVE_SEC_ZERO	    0x0000
        ///Tag for export derive share secret
        #define TAG_EXPORT_DERIVE_KEY   0x07
        ///Tag for derive key oid
        #define TAG_OID_DERIVE_KEY		0x08
        ///Minimum length of APDU
        #define TX_LEN					(DERIVEKEY_APDU_LEN + 2)
        /// @endcond

        //Considering the size of Indata for allocating memory as this size is also sufficient for storing the response
        wCalApduLen = LEN_APDUHEADER + TX_LEN + (PpsDeriveKey->sSeed.wLen > PpsDeriveKey->wDerivedKeyLen ? PpsDeriveKey->sSeed.wLen : PpsDeriveKey->wDerivedKeyLen);
        //NULL checks
        if(OID_DERIVE_SEC_ZERO == PpsDeriveKey->wOIDDerivedKey)
        {
            if(NULL == PpsKey->prgbStream)
            {
                i4Status = (int32_t)CMD_LIB_NULL_PARAM;
                break;
            }
            wCalApduLen -= 2;
        }

        //Check max comms buffer size
        if((wMaxCommsBuffer) < wCalApduLen)
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        //Allocating Heap memory
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,wCalApduLen);

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        sApduData.wResponseLength = wCalApduLen;

        //Set share secret key tag, length, data
        sApduData.prgbAPDUBuffer[LEN_APDUHEADER] = TAG_OID;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET],LEN_SHARED_SECRET_OID);
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET],PpsDeriveKey->wOIDSharedSecret);
        wWritePosition += TAG_VALUE_OFFSET + LEN_PRI_KEY;

        //Set public key algoId tag, length, data
        sApduData.prgbAPDUBuffer[wWritePosition] = TAG_SEED;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET],PpsDeriveKey->sSeed.wLen);
        OCP_MEMCPY(&sApduData.prgbRespBuffer[TAG_VALUE_OFFSET + wWritePosition],PpsDeriveKey->sSeed.prgbStream,PpsDeriveKey->sSeed.wLen);
        wWritePosition += TAG_VALUE_OFFSET + PpsDeriveKey->sSeed.wLen;

        //Set public key tag, length, data
        sApduData.prgbAPDUBuffer[wWritePosition] = TAG_DERIVE_KEY;
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET],LEN_DERIVE_KEY);
        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET],PpsDeriveKey->wDerivedKeyLen);
        wWritePosition += TAG_VALUE_OFFSET + LEN_DERIVE_KEY;

        if(OID_DERIVE_SEC_ZERO == PpsDeriveKey->wOIDDerivedKey)
        {
            //Set export share sec tag, length, data
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_EXPORT_DERIVE_KEY;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_EXPORT_DERIVE_KEY);
            wWritePosition += TAG_VALUE_OFFSET;
        }
        else
        {
            //Set OID of signature key tag, length, data
            sApduData.prgbAPDUBuffer[wWritePosition] = TAG_OID_DERIVE_KEY;
            Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_LENGTH_OFFSET], LEN_DERIVE_KEY);
                        Utility_SetUint16(&sApduData.prgbAPDUBuffer[wWritePosition + TAG_VALUE_OFFSET], PpsDeriveKey->wOIDDerivedKey);
            wWritePosition += TAG_VALUE_OFFSET + LEN_DERIVE_KEY;
        }

        sApduData.wPayloadLength = (uint16_t)(wWritePosition - LEN_APDUHEADER);
        //Form Command
        sApduData.bCmd = CMD_DERIVE_KEY;
        sApduData.bParam = (uint8_t)PpsDeriveKey->eKDM;

        //Transmit data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }

        sApduData.wResponseLength -= LEN_APDUHEADER;
        if(OID_DERIVE_SEC_ZERO == PpsDeriveKey->wOIDDerivedKey)
        {
            if(sApduData.wResponseLength > PpsKey->wLen)
            {
                i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
                break;
            }
            //Copy signature to output buffer
            OCP_MEMCPY(PpsKey->prgbStream,&sApduData.prgbRespBuffer[LEN_APDUHEADER],sApduData.wResponseLength);
            PpsKey->wLen = sApduData.wResponseLength;
        }
    }while(FALSE);

    //Free the allocated memory for buffer
    FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);

    /// @cond hidden
        #undef DERIVEKEY_APDU_LEN
        #undef TAG_DERIVE_KEY
        #undef LEN_EXPORT_DERIVE_KEY
        #undef LEN_DERIVE_KEY
        #undef OID_DERIVE_SEC_ZERO
        #undef TAG_EXPORT_DERIVE_KEY
        #undef TAG_OID_DERIVE_KEY
    #undef TX_LEN
    /// @endcond
    return i4Status;
}


#endif/*MODULE_ENABLE_TOOLBOX*/

#ifdef MODULE_ENABLE_DTLS_MUTUAL_AUTH
/**
* Gets Handshake message from Security Chip.<br>
*
*
* Notes: <br>
* - User should provide a callback through #sCallBack_d.
* - This callback allows the caller to allocate memory for the message and keep copying data into the memory in case of lengthy messages.
* - Allocated buffer is returned to user in #sCBGetMsg_d.
* - The callback should return #CMD_LIB_OK for successful allocation of memory else #CMD_LIB_ERROR in case of error.<br>
*
* - Any Message specific data must be provided by the user in the union puMsgParams.<br>
*   The union is defined as #uMsgParams_d.
*
* - The user must provide correct data in puMsgParams.This function does not <br>
*   validate the content of the message specific data.
*   E.g For sending gmt_unix_time for Client Hello message,uMsgParams_d.sMsgParamCH_d.dwUnixTime must be set.
*   If puMsgParams is set to NULL,then random dwUnixTime will be considered for Client Hello message <br>
*   and certificate will not be send for Client Certificate message.
*
*   The psBlobInBuffer pointer which is member of sProcMsgData_d should be set to NULL
*
* \param[in,out] PpsGMsgVector Pointer to DTLS Handshake Message parameters
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INVALID_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_GetMessage(const sProcMsgData_d *PpsGMsgVector)
{
///@cond hidden
#define STACK_ALLOC
///@endcond

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;
    uint8_t bFragSeq ;
    uint16_t wRespLen;
    sbBlob_d sBlobMessage;

    do
    {
//To use stack memory for APDU buffer, define STACK_ALLOC locally else heap memory is used
#ifdef STACK_ALLOC
        INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer,MAX_APDU_BUFF_LEN);
#else
        INIT_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer,MAX_APDU_BUFF_LEN);
#endif

        //NULL checks
        if((NULL == PpsGMsgVector) || (NULL == PpsGMsgVector->psCallBack) ||
                        (NULL == PpsGMsgVector->psCallBack->pfAcceptMessage) || (NULL == PpsGMsgVector->psCallBack->fvParams))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        //Verify the range of the param
        if((eClientHello != PpsGMsgVector->eParam) && (eClientHelloWithCookie != PpsGMsgVector->eParam) &&
        (eClientCertificate != PpsGMsgVector->eParam) && (eClientKeyExchange != PpsGMsgVector->eParam) &&
        (eCertificateVerify != PpsGMsgVector->eParam) && (eClientFinished != PpsGMsgVector->eParam))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_PARAM;
            break;
        }

        //Verify the Session OID reference
        if((SESSION_ID_LOWER_VALUE > PpsGMsgVector->wSessionKeyOID) ||
        (SESSION_ID_HIGHER_VALUE < PpsGMsgVector->wSessionKeyOID))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_SESSIONID;
            break;
        }

        //Set the fragment sequence to start
        bFragSeq = (uint8_t)eStart;

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;

        while((eFragSeq_d)bFragSeq != eFinal)
        {
            //Form data and assign to apdu structure
            //Assign cmd,param,length

            sApduData.bCmd = CMD_GETMSG;
            sApduData.bParam = (uint8_t)PpsGMsgVector->eParam;
            //Total payload length is Session ID Length
            sApduData.wPayloadLength = BYTES_SESSIONID;

            //Form the data in order in the buffer
            //Add the session ID to the buffer
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsGMsgVector->wSessionKeyOID >> BITS_PER_BYTE);
            sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + 1] = (uint8_t)PpsGMsgVector->wSessionKeyOID;
                        sApduData.wResponseLength = MAX_APDU_BUFF_LEN;

            if(((uint8_t)eClientHello == sApduData.bParam) && (NULL != PpsGMsgVector->puMsgParams))
            {
                sApduData.wPayloadLength += LEN_TAG_ENCODING + BYTES_GMT_TIME;
                sApduData.prgbAPDUBuffer[OFFSET_TAG] = TAG_GMTUNIX_TIME;
                sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN] = 0x00;
                sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN + 1] = BYTES_GMT_TIME;
                Utility_SetUint32 (&sApduData.prgbAPDUBuffer[OFFSET_TAG_DATA],PpsGMsgVector->puMsgParams->sMsgParamCH_d.dwUnixTime);
            }
            else if(((uint8_t)eClientCertificate == sApduData.bParam) && (NULL != PpsGMsgVector->puMsgParams))
            {
                sApduData.wPayloadLength += LEN_TAG_ENCODING + BYTES_OID;
                sApduData.prgbAPDUBuffer[OFFSET_TAG] = TAG_CERTIFICATE_OID;
                sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN] = 0x00;
                sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN + 1] = BYTES_OID;
                Utility_SetUint16 (&sApduData.prgbAPDUBuffer[OFFSET_TAG_DATA],PpsGMsgVector->puMsgParams->sMsgParamCert_d.wCertOID);
            }
            //Transmit data
            i4Status = TransceiveAPDU(&sApduData,TRUE);
            if(CMD_LIB_OK != i4Status)
            {
                break;
            }

            //Remove 4 byte apdu header + tag encoding
            sApduData.wResponseLength -= (LEN_APDUHEADER + LEN_TAG_ENCODING);

            //Verify the TLV encoding
            //Verify the Tag
            if(TAG_UNPROTECTED != (*(sApduData.prgbRespBuffer + LEN_APDUHEADER) & MASK_HIGHER_NIBBLE))
            {
                i4Status = (int32_t)CMD_LIB_INVALID_TAG;
                break;
            }

            //Extract the fragment sequence information
            bFragSeq = *(sApduData.prgbRespBuffer + LEN_APDUHEADER) & MASK_LOWER_NIBBLE;

            //extract the tag length field
            wRespLen = Utility_GetUint16(sApduData.prgbRespBuffer + LEN_APDUHEADER + 1);

            //Length validation for response length with the tag length
            if(sApduData.wResponseLength != wRespLen)
            {
                i4Status = (int32_t)CMD_LIB_INVALID_TAGLEN;
                break;
            }
            //Assign the handshake message pointer to the sblob
            sBlobMessage.prgbStream = sApduData.prgbRespBuffer + LEN_APDUHEADER + LEN_TAG_ENCODING;

            //Assign the response length(only Handshake message) excluding the tag encoding
            sBlobMessage.wLen = sApduData.wResponseLength;

            //Call back function to allocate the memory for handshake message based the response length
            i4Status = PpsGMsgVector->psCallBack->pfAcceptMessage(PpsGMsgVector->psCallBack->fvParams, &sBlobMessage);
            if(i4Status != CMD_LIB_OK)
            {
                i4Status = (int32_t)CMD_LIB_ERROR;
                break;
            }
        }
        //Note: If data is encoded with eContinue then loop to get complete data till eFinal is encoded
        //The response pointer should be updated for each loop and check for buffer overflow
    }while(FALSE);

    //Free the allocated memory for buffer
#ifndef STACK_ALLOC
        FREE_HEAP_APDUBUFFER(sApduData.prgbAPDUBuffer);
#else
        #undef STACK_ALLOC
#endif

    return i4Status;
}

/**
* Sends Handshake message to Security Chip for processing.<br>
*
*
* Notes: <br>
* - Input buffer must be provided by the user.<br>
* - Clearing of the buffers is the responsibility of the user.
*
* - The input pointer should contain sufficient memory to accommodate <br>
*   APDU header and data formatting.
*
* - The API will not recopy the Authentication message data but add the header and data<br>
*   formatting information before it, in the same input buffer.
*
*	The puMsgParams and psCallBack pointer which is member of sProcMsgData_d should be set to NULL
*
* \param[in] PpsPMsgVector Pointer to DTLS Handshake Message parameters
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INVALID_PARAM
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_PutMessage(const sProcMsgData_d *PpsPMsgVector)
{
    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;

    do
    {
        //NULL checks
        if((NULL == PpsPMsgVector) || (NULL == PpsPMsgVector->psBlobInBuffer) ||
        (NULL == PpsPMsgVector->psBlobInBuffer->prgbStream))
        {
            i4Status = (int32_t)CMD_LIB_NULL_PARAM;
            break;
        }

        //Zero length checks
        if(0x00 == PpsPMsgVector->psBlobInBuffer->wLen)
        {
            i4Status = (int32_t)CMD_LIB_LENZERO_ERROR;
            break;
        }

        //Verify the range of the param
        if(((eServerCertificate > PpsPMsgVector->eParam) || (eServerHelloDone < PpsPMsgVector->eParam)) &&
        ((eServerHello != PpsPMsgVector->eParam) && (eHelloVerifyRequest != PpsPMsgVector->eParam) &&
        (eServerFinished != PpsPMsgVector->eParam)))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_PARAM;
            break;
        }

        //Verify the Session OID reference
        if((SESSION_ID_LOWER_VALUE > PpsPMsgVector->wSessionKeyOID) ||
        (SESSION_ID_HIGHER_VALUE < PpsPMsgVector->wSessionKeyOID))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_SESSIONID;
            break;
        }

        //Length of data + OverHeadLen should not to be more than wMaxCommsBuffer
        //Currently, chaining is not supported by Command library and security chip.Hence, this length check is performed.
        if(PpsPMsgVector->psBlobInBuffer->wLen > (wMaxCommsBuffer) )
        {
            i4Status = (int32_t)CMD_LIB_INSUFFICIENT_MEMORY;
            break;
        }

        //Assign In memory pointer to the APDU Buffer in the Apdu structure
        sApduData.prgbAPDUBuffer = PpsPMsgVector->psBlobInBuffer->prgbStream;
        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        //Form data and assign to apdu structure
        //Assign cmd,param,length
        sApduData.bCmd = CMD_PUTMSG;
        sApduData.bParam = (uint8_t)PpsPMsgVector->eParam;
        //Total payload length is sum of length of Session ID , Tag, Tag length and the data
        sApduData.wPayloadLength = PpsPMsgVector->psBlobInBuffer->wLen - OFFSET_PAYLOAD;

        //Add the session ID to the buffer
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)(PpsPMsgVector->wSessionKeyOID >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + 1] = (uint8_t)PpsPMsgVector->wSessionKeyOID;
        //Add the encoding tag to the buffer
        sApduData.prgbAPDUBuffer[OFFSET_TAG] = TAG_UNPROTECTED;

        sApduData.prgbAPDUBuffer[OFFSET_TAG] |= (uint8_t)eFinal;

        //Add the tag length to the buffer
        //lint --e{702} suppress "Acknowledging the shift. Reviewed it"
        sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN] = (uint8_t)(((PpsPMsgVector->psBlobInBuffer->wLen) - (OFFSET_PAYLOAD + BYTES_SESSIONID + LEN_TAG_ENCODING)) >> BITS_PER_BYTE);

        sApduData.prgbAPDUBuffer[OFFSET_TAG_LEN + 1] = (uint8_t)(PpsPMsgVector->psBlobInBuffer->wLen - (OFFSET_PAYLOAD + BYTES_SESSIONID + LEN_TAG_ENCODING));

        sApduData.wResponseLength = PpsPMsgVector->psBlobInBuffer->wLen;
        //Transmit data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }
    }while(FALSE);

    return i4Status;
}

/**
*
* Closes the DTLS session as indicated by the Session OID.<br>
*
*
* \param[in] PwSessionRefId session OID to be closed
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INVALID_SESSIONID
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
*/
int32_t CmdLib_CloseSession(uint16_t PwSessionRefId)
{
/// @cond hidden
#define CLOSE_SESSION_APDU_BUF_LEN    6
/// @endcond

    int32_t i4Status = (int32_t)CMD_LIB_ERROR;
    sApduData_d sApduData;

    do
    {
        INIT_STACK_APDUBUFFER(sApduData.prgbAPDUBuffer,CLOSE_SESSION_APDU_BUF_LEN);

        //Verify the session id
        if((SESSION_ID_LOWER_VALUE > PwSessionRefId) ||
        (SESSION_ID_HIGHER_VALUE < PwSessionRefId))
        {
            i4Status = (int32_t)CMD_LIB_INVALID_SESSIONID;
            break;
        }

        //Set the pointer to the response buffer
        sApduData.prgbRespBuffer = sApduData.prgbAPDUBuffer;
        //Form the command
        //Assign Cmd,param,payload length
        sApduData.bCmd = CMD_GETMSG;
        sApduData.bParam = (uint8_t)eCloseSession;

        //Total payload length is equal to session ID length
        sApduData.wPayloadLength = BYTES_SESSIONID;

        //Assign the session key
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD] = (uint8_t)( PwSessionRefId >> BITS_PER_BYTE);
        sApduData.prgbAPDUBuffer[OFFSET_PAYLOAD + 1] = (uint8_t)PwSessionRefId;

                sApduData.wResponseLength = CLOSE_SESSION_APDU_BUF_LEN;

        //Transmit the Data
        i4Status = TransceiveAPDU(&sApduData,TRUE);
        if(CMD_LIB_OK != i4Status)
        {
            break;
        }
    }while(FALSE);

/// @cond hidden
#undef CLOSE_SESSION_APDU_BUF_LEN
/// @endcond

    return i4Status;
}

/**
* Encrypts data by issuing ProcUpLink command to Security Chip.<br>
*
*
* Notes: <br>
* - Input and Output buffers must be provided by the user.
*Buffer deallocation is the responsibility of the user.<br>
*
* - The input data in #sbBlob_d sInData should contain sufficient memory to accommodate APDU header,
*data formatting,Plaintext.<br>
*The Plaintext and any specific data for encryption should start after an overhead of #OVERHEAD_UPDOWNLINK.<br>
*
* - wInDataLength in #sProcCryptoData_d should be greater than zero.<br>
*
* - Ciphertext is returned in #sCmdResponse_d* sOutData from zero offset.<br>
*
* - In addition to the Ciphertext, the length of buffer in sOutData
*should be sufficient to accommodate Response APDU header and data formatting. This is defined as #OVERHEAD_ENCDEC_RESPONSE<br>
*The total length of the Ciphertext is returned in wRespLength of #sCmdResponse_d.<br>
*
* - The current implementation of Security chip does not support command chaining.
*The maximum value of wInDataLength depends on the value supported by the security chip.<br>
*
* - Currently,the security chip supports only 0xE100 as session key OID.
*
* \param[in,out] PpsEncVector Pointer to structure containing Plaintext and Ciphertext
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_LIB_INVALID_SESSIONID
* \retval  #CMD_LIB_INVALID_LEN
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_Encrypt(sProcCryptoData_d *PpsEncVector)
{
        return CmdLib_EncDecHelper(PpsEncVector,CMD_ENCDATA,PARAM_ENC_DATA);
}

/**
* Decrypts data by issuing ProcDownLink command to Security Chip.<br>
*
*
* Notes: <br>
* - Input and Output buffers must be provided by the user.
*Buffer deallocation is the responsibility of the user.<br>
*
* - The input data in #sbBlob_d sInData should contain sufficient memory to accommodate APDU header,
*data formatting,Ciphertext.<br>
*The Ciphertext and any specific data for decryption should start after an overhead of #OVERHEAD_UPDOWNLINK.<br>
*
* - wInDataLength in #sProcCryptoData_d should be greater than zero.<br>
*
* - Plaintext is returned in #sCmdResponse_d* sOutData from zero offset.<br>
*
* - In addition to the Plaintext, the length of buffer in sOutData
*should be sufficient to accommodate Response APDU header and data formatting. This is defined as #OVERHEAD_ENCDEC_RESPONSE<br>
*The total length of the Plaintext is returned in wRespLength of #sCmdResponse_d.<br>
*
* - The current implementation of Security chip does not support command chaining.
*The maximum value of wInDataLength depends on the value supported by the security chip.<br>
*
* - Currently,the security chip supports only 0xE100 as session key OID.
*
* \param[in,out] PpsDecVector Pointer to structure containing Ciphertext and Plaintext
*
* \retval  #CMD_LIB_OK
* \retval  #CMD_LIB_ERROR
* \retval  #CMD_LIB_INSUFFICIENT_MEMORY
* \retval  #CMD_LIB_INVALID_SESSIONID
* \retval  #CMD_LIB_INVALID_LEN
* \retval  #CMD_DEV_ERROR
* \retval  #CMD_LIB_DECRYPT_FAILURE
* \retval  #CMD_LIB_NULL_PARAM
*/
int32_t CmdLib_Decrypt(sProcCryptoData_d *PpsDecVector)
{
        return CmdLib_EncDecHelper(PpsDecVector,CMD_DECDATA,PARAM_DEC_DATA);
}
#endif /* MODULE_ENABLE_DTLS_MUTUAL_AUTH*/

/**
* @}
*/