264 lines
9.1 KiB
C
264 lines
9.1 KiB
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 functionality to form and process DTLS messages for OCP Library.
|
|
*
|
|
* \addtogroup grMutualAuth
|
|
* @{
|
|
*/
|
|
|
|
#include "optiga/dtls/MessageLayer.h"
|
|
|
|
#ifdef MODULE_ENABLE_DTLS_MUTUAL_AUTH
|
|
|
|
#define CALL_BACK_OK 0x00000001
|
|
|
|
|
|
/**
|
|
* Call back function to allocate memory to the received message from Security Chip.<br>
|
|
*
|
|
* \param[in,out] PpCBParam Pointer to structure containing information required to allocate memory
|
|
* \param[in] psInOutMsg Pointer to sBlob containing the received Handshake message from Security Chip
|
|
*
|
|
* \retval #CMD_LIB_OK Successful Execution
|
|
* \retval #CMD_LIB_ERROR Failure Execution
|
|
*/
|
|
int32_t CallBack_GetMessage(Void* PpCBParam, const sbBlob_d* psInOutMsg)
|
|
{
|
|
int32_t i4Status = (int32_t) CMD_LIB_ERROR;
|
|
uint32_t dwFragLen;
|
|
uint32_t dwTotalLen;
|
|
uint32_t dwOffset;
|
|
|
|
/// @cond hidden
|
|
#define PS_CBGETMSG ((sCBGetMsg_d*)PpCBParam)
|
|
#define OFFSET_MSG_FRAG_LENGTH 9
|
|
#define OFFSET_MSG_TOTAL_LENGTH 1
|
|
#define OFFSET_MSG_FRAGMENT_OFFSET 6
|
|
/// @endcond
|
|
|
|
do
|
|
{
|
|
dwFragLen = Utility_GetUint24(psInOutMsg->prgbStream + OFFSET_MSG_FRAG_LENGTH);
|
|
dwTotalLen = Utility_GetUint24(psInOutMsg->prgbStream + OFFSET_MSG_TOTAL_LENGTH);
|
|
dwOffset = Utility_GetUint24(psInOutMsg->prgbStream + OFFSET_MSG_FRAGMENT_OFFSET);
|
|
|
|
//If first time, allocate memory
|
|
if(FALSE == PS_CBGETMSG->bRepeatCall)
|
|
{
|
|
//Allocate memory
|
|
PS_CBGETMSG->dwMsgLen = (uint16_t)dwTotalLen + OVERHEAD_LEN;
|
|
PS_CBGETMSG->pbActualMsg = (uint8_t*)OCP_MALLOC(dwTotalLen + OVERHEAD_LEN);
|
|
if(PS_CBGETMSG->pbActualMsg == NULL)
|
|
{
|
|
i4Status = (int32_t)OCP_ML_MALLOC_FAILURE;
|
|
break;
|
|
}
|
|
//Set to true indicating memory is already allocated
|
|
PS_CBGETMSG->bRepeatCall = TRUE;
|
|
|
|
OCP_MEMCPY(PS_CBGETMSG->pbActualMsg + (OVERHEAD_LEN - MSG_HEADER_LEN),psInOutMsg->prgbStream,(uint16_t)(dwFragLen + MSG_HEADER_LEN));
|
|
|
|
//Set fragment offset to zero and fragment len to total len
|
|
Utility_SetUint24((PS_CBGETMSG->pbActualMsg + (OVERHEAD_LEN - 3)), dwTotalLen);
|
|
}
|
|
else
|
|
{
|
|
//copy data from offset
|
|
OCP_MEMCPY(PS_CBGETMSG->pbActualMsg + dwOffset + OVERHEAD_LEN, (psInOutMsg->prgbStream + MSG_HEADER_LEN), (uint16_t)dwFragLen);
|
|
}
|
|
i4Status = CMD_LIB_OK;
|
|
}while(FALSE);
|
|
|
|
/// @cond hidden
|
|
#undef OFFSET_MSG_FRAG_LENGTH
|
|
#undef OFFSET_MSG_TOTAL_LENGTH
|
|
#undef OFFSET_MSG_FRAGMENT_OFFSET
|
|
#undef PS_CBGETMSG
|
|
/// @endcond
|
|
|
|
return i4Status;
|
|
|
|
}
|
|
|
|
/**
|
|
* Provide Handshake message using Command Library.<br>
|
|
* Under some erroneous conditions, error codes from Command Library can also be returned.<br>
|
|
*
|
|
* \param[in] eMsgType Message type of the handshake message to be received from Security Chip
|
|
* \param[in] PpsMessageLayer Pointer to structure containing information required for Message Layer
|
|
* \param[out] PpsMessage Pointer to sBlob containing the Handshake message
|
|
*
|
|
* \retval #OCP_ML_OK Successful Execution
|
|
* \retval #OCP_ML_ERROR Failure Execution
|
|
* \retval #OCP_ML_INVALID_UNIXTIME Invalid unix time provided by user
|
|
*/
|
|
int32_t MsgLayer_FormMessage(eMsgType_d eMsgType,const sMessageLayer_d* PpsMessageLayer, sbBlob_d* PpsMessage)
|
|
{
|
|
int32_t i4Status = (int32_t) OCP_ML_ERROR;
|
|
sProcMsgData_d sGMsgVector;
|
|
sCallBack_d sCallBack;
|
|
sCBGetMsg_d sCBGetMsg;
|
|
uMsgParams_d uMsgParams;
|
|
|
|
do
|
|
{
|
|
//Null Check
|
|
if((NULL == PpsMessageLayer) || (NULL == PpsMessage))
|
|
{
|
|
i4Status = (int32_t)OCP_ML_NULL_PARAM;
|
|
break;
|
|
}
|
|
|
|
//Assign the call back function parameters
|
|
sCBGetMsg.bRepeatCall = FALSE;
|
|
sCBGetMsg.pbActualMsg = NULL;
|
|
sCBGetMsg.dwMsgLen = 0;
|
|
|
|
//Assign call back function to allocate memory
|
|
sCallBack.pfAcceptMessage = CallBack_GetMessage;
|
|
sCallBack.fvParams = (Void*) &sCBGetMsg;
|
|
|
|
//Form the Get message command APDU parameters
|
|
sGMsgVector.eParam = eMsgType;
|
|
sGMsgVector.wSessionKeyOID = PpsMessageLayer->wSessionID;
|
|
sGMsgVector.psCallBack = &sCallBack;
|
|
sGMsgVector.psBlobInBuffer = NULL;
|
|
//sGMsgVector.puMsgParams = &uMsgParams;
|
|
sGMsgVector.puMsgParams = NULL;
|
|
|
|
//Based on the message type set the message specific data
|
|
switch((uint8_t)eMsgType)
|
|
{
|
|
case eClientHello:
|
|
if(NULL != PpsMessageLayer->pfGetUnixTIme)
|
|
{
|
|
sGMsgVector.puMsgParams = &uMsgParams;
|
|
|
|
//To use the unix time provided
|
|
i4Status = PpsMessageLayer->pfGetUnixTIme(&sGMsgVector.puMsgParams->sMsgParamCH_d.dwUnixTime);
|
|
if(CALL_BACK_OK != i4Status)
|
|
{
|
|
i4Status = (int32_t) OCP_ML_INVALID_UNIXTIME;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case eClientCertificate:
|
|
if(0x0000 != PpsMessageLayer->wOIDDevCertificate)
|
|
{
|
|
sGMsgVector.puMsgParams = &uMsgParams;
|
|
sGMsgVector.puMsgParams->sMsgParamCert_d.wCertOID = PpsMessageLayer->wOIDDevCertificate;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
//lint -e788 suppress "Default values for return are already set.No more operation required here"
|
|
//For other messages there is no message specific data
|
|
break;
|
|
}
|
|
|
|
if(((int32_t) OCP_ML_INVALID_UNIXTIME == i4Status) || ((int32_t) OCP_ML_INVALID_CERTTYPE == i4Status))
|
|
{
|
|
break;
|
|
}
|
|
//Get the Message using Get Message command from the Security Chip
|
|
i4Status = CmdLib_GetMessage(&sGMsgVector);
|
|
if(CMD_LIB_OK != i4Status)
|
|
{
|
|
LOG_TRANSPORTDBVAL(i4Status,eInfo);
|
|
break;
|
|
}
|
|
|
|
//Allocated memory is assigned the sBlob
|
|
PpsMessage->prgbStream = sCBGetMsg.pbActualMsg;
|
|
PpsMessage->wLen = sCBGetMsg.dwMsgLen;
|
|
|
|
i4Status = (int32_t) OCP_ML_OK ;
|
|
}while(FALSE);
|
|
|
|
return i4Status;
|
|
}
|
|
|
|
/**
|
|
* Process Handshake message using Command Library.<br>
|
|
* Under some erroneous conditions, error codes from Command Library can also be returned. <br>
|
|
*
|
|
* \param[in] eMsgType Message type of the handshake message to be send to Security Chip
|
|
* \param[in] PpsMessageLayer Pointer to structure containing information required for Message Layer
|
|
* \param[in] PpsMessage Pointer to sBlob containing the Handshake message
|
|
*
|
|
* \retval #OCP_ML_OK Successful Execution
|
|
* \retval #OCP_ML_ERROR Failure Execution
|
|
*/
|
|
int32_t MsgLayer_ProcessMessage(eMsgType_d eMsgType,const sMessageLayer_d* PpsMessageLayer, sbBlob_d* PpsMessage)
|
|
{
|
|
int32_t i4Status = (int32_t) OCP_ML_ERROR;
|
|
sProcMsgData_d sPMsgVector ;
|
|
|
|
do
|
|
{
|
|
//Null Check
|
|
if((NULL == PpsMessageLayer) || (NULL == PpsMessage) || (NULL == PpsMessage->prgbStream))
|
|
{
|
|
i4Status = (int32_t)OCP_ML_NULL_PARAM;
|
|
break;
|
|
}
|
|
|
|
//Length check for input parameters
|
|
if(0 == PpsMessage->wLen)
|
|
{
|
|
i4Status = (int32_t)OCP_ML_ZERO_LEN;
|
|
break;
|
|
}
|
|
|
|
//Assign the required parameter(s) for the Put Message command
|
|
sPMsgVector.eParam = eMsgType;
|
|
sPMsgVector.psBlobInBuffer = PpsMessage;
|
|
sPMsgVector.wSessionKeyOID = PpsMessageLayer->wSessionID;
|
|
sPMsgVector.puMsgParams = NULL;
|
|
sPMsgVector.psCallBack = NULL;
|
|
|
|
//Invoke the Put Message command API from the command library to send the message to Security Chip to Process
|
|
i4Status = CmdLib_PutMessage(&sPMsgVector);
|
|
if(CMD_LIB_OK != i4Status)
|
|
{
|
|
LOG_TRANSPORTDBVAL(i4Status,eInfo);
|
|
break;
|
|
}
|
|
|
|
i4Status = (int32_t) OCP_ML_OK;
|
|
}while(FALSE);
|
|
|
|
#undef PhOCPHandle
|
|
return i4Status;
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
#endif /*MODULE_ENABLE_DTLS_MUTUAL_AUTH*/
|