#include "cmd_handler.h"



#include "ccm.h"

#include "factory.h"

#include "sec_apdu.h"

#include "sem.h"

#include "scpkm.h"

#include "scrs.h"

#include "service_key.h"

#include "sse.h"

#include "ssp.h"



#ifdef FACTORY_RESET

#include "fra.h"

#endif /* FACTORY_RESET */



#ifdef SCP11_ENABLE

#include "SCP11.h"

#endif /* SCP11_ENABLE */



#ifdef USE_GRDM

#include "grdm.h"

#include "grdm_app.h"

#include "tz_debug.h"



#include "tz_platform.h"



static bool_t isOpened = FALSE;

#endif /* USE_GRDM */



#ifdef DEBUG_LOW

#include "iso7816_self_test.h"

void crypto_test(void);

#endif /* DEBUG_LOW */



void cmdHandler(int32_t commandId, p_cmd_t pCmd, p_rsp_t pRsp) {

#ifdef USE_GRDM

    GRDM_RESULT result = GRDM_NO_ERROR;



    if (commandId != CMD_GRDM_OPEN && FALSE == isOpened){

        LOGE("TZ spi is not opened");

        pRsp->ret = GRDM_SPIOPEN_ERROR;

        return;

    }

#endif /* USE_GRDM */



    LOGD("SEM Trusted Application is entering with commandId : %d", commandId);

    /* Process command message */

    switch (commandId) {

        case CMD_CHECK_SSP:

            getSspVerStatus(pRsp);

            break;

        case CMD_PROVISION_OTP:

            provisionKotp(pCmd, pRsp, 0);

            break;

        case CMD_PROVISION_OTP_M:

            provisionKotp(pCmd, pRsp, 1);

            break;

        case CMD_IS_SSP_VALID:

            isSspValid(pCmd, pRsp);

            break;

#if 0

        case CMD_REQUEST_RESET:

            requestReset(pRsp);

            break;

        case CMD_RESET_SSP:

            resetSsp(pCmd, pRsp);

            break;

#endif

        case CMD_RESET_SSP_FOR_FACTORY:

            resetSspForFactory(pRsp);

            break;

        case CMD_DELETE_ALL_SS_ENTRY:

            deleteAllSSEntry(pCmd, pRsp);

            break;

        case CMD_CHECK_SSE:

            getSseVer(pRsp);

            break;

        case CMD_SEM_SERVICEKEY_UNWRAP:

            unwrapSEMServiceKey(pCmd, pRsp);

            break;

        case CMD_SEM_SERVICEKEY_REWRAP:

            rewrapSEMServiceKey(pCmd, pRsp);

            break;

        case CMD_SEM_REWAPPED_SERVICEKEY_UNWRAP:

            unwrapRewrappedSEMServiceKey(pCmd, pRsp);

            break;

        case CMD_HANDLE_CCM_DATA_P1:

            handleCCMDataPart1(pCmd, pRsp);

            break;

#ifdef LCCM_SPI

        case CMD_HANDLE_CCM_DATA_P2:

            handleCCMDataPart2(pCmd, pRsp);

            break;

#endif /* LCCM_SPI */

        case CMD_UPDATE_DEFAULT_ENTRY_AUTH:

            updateDefaultEntryAuth(pCmd, pRsp);

            break;

        case CMD_UPDATE_DSI_ENTRY:

            updateDSIEntry(pCmd, pRsp);

            break;

        case CMD_UPDATE_WARRANTYBIT_ENTRY_NORMAL:

            updateWarrantyBitEntry_Normal(pCmd, pRsp);

            break;

        case CMD_UPDATE_WARRANTYBIT_ENTRY_ABNORMAL:

            updateWarrantyBitEntry_Abnormal(pCmd, pRsp);

            break;

        case CMD_UPDATE_SSE_DEFAULT_ENTRY_TA_ID:

            updateSSEDefaultEntryTaId(pCmd, pRsp);

            break;

        case CMD_DELETE_FIDO_DEFAULT_ENTRY:

            deleteFIDODefaultEntry(pCmd, pRsp);

            break;

#ifdef COMMON_VENDOR

        case CMD_SPI_INIT:

            if (pCmd->dataLen == 1) {

                if (spiOpenWithChipVendor(pCmd->data[0]) == 0) {

                    pRsp->ret = RET_SUCCESS;

                } else {

                    pRsp->ret = RET_ERR_TZ;

                }

            } else {

                LOGI("Use default vendor : NXP");

                if (spiOpenWithChipVendor(CHIP_VENDOR_NXP_JCOP40) == 0) {

                    pRsp->ret = RET_SUCCESS;

                } else {

                    pRsp->ret = RET_ERR_TZ;

                }

            }

            break;

#else

        case CMD_SPI_INIT:

            if (spiOpen() == 0) {

                pRsp->ret = RET_SUCCESS;

            } else {

                pRsp->ret = RET_ERR_TZ;

            }

            break;

#endif

        case CMD_SPI_DEINIT:

            if (spiClose() == 0) {

                pRsp->ret = RET_SUCCESS;

            } else {

                pRsp->ret = RET_ERR_TZ;

            }

            break;

        case CMD_GET_CPLC:

            getCPLC(pRsp);

            break;

        case CMD_CHECK_ESE_RESTRICTED:

            getRestrictedMode(pRsp);

            break;

        case CMD_GET_ATTACKED :

            getAttacked(pRsp);

            break;

        case CMD_GET_OK_ATTACKED :

            getOkAttacked(pRsp);

            break;

        case CMD_GET_ACDUMP :

            getACDump(pRsp);

            break;

        case CMD_GET_DEFAULT_WALLET_LIST:

            getDefaultCardPackageList(pRsp);

            break;

        case CMD_GET_DEFAULT_CARD_AID:

            getDefaultCardAid(pCmd, pRsp);

            break;

        case CMD_DELETE_DEFAULT_CARD:

            deleteDefaultCard(pCmd, pRsp);

            break;

        case CMD_GET_RF_ACTIVATION_LIST:

            getRFActivationList(pRsp);

            break;

        case CMD_DEACTIVATION_AID:

            deactivationRFAID(pCmd, pRsp);

            break;

        case CMD_DEACTIVATION_AID_DEBUG:

            deactivationRFAIDDebug(pCmd, pRsp);

            break;

        case CMD_GET_HQM_MEMORY:

            getHQMMemory(pRsp);

            break;

        case CMD_CHECK_SE_STATE:

            checkSeState(pCmd, pRsp);

            break;

        case CMD_REQUEST_CREDENTIALS:

            requestCredentials(pCmd, pRsp);

            break;

        case CMD_SKMS_SERVICEKEY_REWRAP:

            rewrapSKMSServiceKey(pCmd, pRsp);

            break;

        case CMD_SKMS_REWRAPPED_SERVICEKEY_UNWRAP:

            // 0 means nothing

            unwrapRewrappedSKMSServiceKey(pCmd, pRsp, 0);

            break;

        case CMD_SKMS_REQ_SIGN:

            signMsgUnwrappedSKMSServiceKey(pCmd, pRsp);

            break;

        case CMD_SKMS_REWRAPPED_SERVICEKEY_UNWRAP_DRK:

            // extract DRK cert

            unwrapRewrappedSKMSServiceKey(pCmd, pRsp, 1);

            break;

        case CMD_SKMS_REWRAPPED_SERVICEKEY_UNWRAP_SVC:

            // extract SVC cert

            unwrapRewrappedSKMSServiceKey(pCmd, pRsp, 2);

            break;

#ifdef FACTORY_RESET

        case CMD_IS_FACTORY_RESET:

            isFactoryReset(pCmd, pRsp);

            break;

#endif /* FACTORY_RESET */

#if 0

        case CMD_FIDO_GET_ENTRY:

            fido_getEntry(pCmd, pRsp);

            break;

#endif /* if 0  */

#if defined LOW_SPI_TEST && defined DEBUG_LOW

        case CMD_SEND_DATA:

            sendData(pCmd, pRsp);

            break;

#endif /* LOW_SPI_TEST && DEBUG_LOW */

#if defined(EXTENDED_APDU)

        case CMD_EXTENDED_APDU_ECHO:

            extendedApduEcho(pRsp);

            break;

#endif

#ifdef DEBUG_LOW

        case CMD_GEN_ENTRYID_TEST:

            genEntryIdTest();

            break;

        case CMD_PUT_ENTRY_DATA_TEST:

            putEntryDataTest(pCmd, pRsp);

            break;

        case CMD_GET_ENTRY_DATA_TEST:

            getEntryDataTest(pCmd, pRsp);

            break;

        case CMD_UPDATE_AUTH_TEST:

            updateAuthTest(pCmd, pRsp);

            break;

        case CMD_DELETE_ENTRY_TEST:

            deleteEntryTest(pCmd, pRsp);

            break;

        case CMD_DELETE_ALL_TEST:

            deleteAllTest(pCmd, pRsp);

            break;

        case CMD_GET_DEFAULT_ENTRY_TEST:

            getDefaultEntryTest(pCmd, pRsp);

            break;

        case CMD_PUT_DEFAULT_ENTRY_TEST:

            putDefaultEntryTest(pCmd);

            break;

        case CMD_ISO7816_TEST:

            ChannelTest();

            break;

        case CMD_CRYPTO_TEST:

            crypto_test();

            break;

        case CMD_GET_INFO_TEST:

            getInfoTest();

            break;

        case CMD_ATTACK_TEST:

            attackTest();

            break;

        case CMD_RESTRICTED_CHECK_TEST:

            restirctedCheck();

            break;

        case CMD_TA_TEST:

            ta_test(pCmd, pRsp);

            break;

        case CMD_GET_CASD_CERT:

            getCASDCert(pRsp);

            break;

        case CMD_START_USE_CARD:

            scrs_command_operation(CMD_SCRS_START_USE_CARD, pCmd, pRsp);

            break;

        case CMD_END_USE_CARD:

            scrs_command_operation(CMD_SCRS_END_USE_CARD, pCmd, pRsp);

            break;

        case CMD_SET_DEFAULT_CARD:

            scrs_command_operation(CMD_SCRS_SET_DEFAULT_CARD, pCmd, pRsp);

            break;

        case CMD_GET_DEFAULT_CARD:

            scrs_command_operation(CMD_SCRS_GET_DEFAULT_CARD, pCmd, pRsp);

            break;

        case CMD_SET_DEFAULT_WALLET:

            scrs_command_operation(CMD_SCRS_SET_DEFAULT_WALLET, pCmd, pRsp);

            break;

        case CMD_GET_DEFAULT_WALLET:

            scrs_command_operation(CMD_SCRS_GET_DEFAULT_WALLET, pCmd, pRsp);

            break;

        case CMD_GET_WALLET_LIST:

            scrs_command_operation(CMD_SCRS_GET_WALLET_LIST, pCmd, pRsp);

            break;

        case CMD_SET_STATUS_ACTIVATED:

            scrs_command_operation(CMD_SCRS_SET_STATUS_ACTIVATED, pCmd, pRsp);

            break;

        case CMD_SET_STATUS_DEACTIVATED:

            scrs_command_operation(CMD_SCRS_SET_STATUS_DEACTIVATED, pCmd, pRsp);

            break;

        case CMD_STRESS_TEST_1:

            StressTest1(pRsp);

            break;

        case CMD_STRESS_TEST_2:

            StressTest2(pRsp);

            break;

        case CMD_SCPKM_TEST:

            scpKmTest(pCmd, pRsp);

            break;

        case CMD_PUT_ENTRY_DATA_TEST_STRESS:

            putEntryDataTest_stress(pCmd, pRsp);

            break;

        case CMD_GET_ENTRY_DATA_TEST_STRESS:

            getEntryDataTest_stress(pCmd, pRsp);

            break;

        case CMD_DELETE_ENTRY_TEST_STRESS:

            deleteEntryTest_stress(pCmd, pRsp);

            break;

        case CMD_SCP_11_A_TEST:

#ifdef SCP11_ENABLE

            scp11a_test(pCmd, pRsp);

            break;

        case CMD_SCP_11_B_TEST:

            scp11b_test(pCmd, pRsp);

            break;

#endif /* SCP11_ENABLE */

#if defined(SCP03_TEST)

        case CMD_SCP_03_TEST:

            scp03_test(cmd, rsp);

            break;

#endif

#endif /* DEBUG_LOW */

/*********************************************** GRDM ***********************************************/

#ifdef USE_GRDM

        case CMD_GRDM_OPEN:

            LOGD("CMD_GRDM_OPEN");

            result = grdm_openLogicalChannel();

            if (result == GRDM_NO_ERROR) {

                pRsp->ret = RET_SUCCESS;

                isOpened = TRUE;

            } else {

                LOGE("CMD_GRDM_OPEN error %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_CLOSE:

            LOGD("CMD_GRDM_CLOSE");

            result = grdm_closeLogicalChannel();

            if (result == GRDM_NO_ERROR) {

                pRsp->ret = RET_SUCCESS;

                isOpened = FALSE;

            } else {

                LOGE("CMD_GRDM_CLOSE error %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_GET_IMEI:

            LOGD("CMD_GRDM_GET_IMEI");

            pRsp->dataLen = 62; // CP INFO : IMEI 1(15B) + IMEI 2(15B) + CP Info Hash(IMEIs + CP Serial Data : 32B) = 62B

            result = grdmGetImei(pRsp->data,&pRsp->dataLen);

            if (result == GRDM_NO_ERROR) {

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("CMD_GRDM_GET_IMEI error %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_INJECT_IMEI:

            LOGD("CMD_GRDM_INJECT_IMEI");

            result = grdmInjectImei(pCmd->data, pCmd->dataLen);

            if (result == GRDM_NO_ERROR) {

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("CMD_GRDM_INJECT_IMEI error %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_GET_INFO:   

            LOGD("CMD_GRDM_GET_INFO");

            uint8_t grdm_status = 0;

            uint8_t grdm_chipid[30] = {0,};

            uint32_t grdm_chipid_len =30;

            uint8_t grdm_fwVer[10] = {0,};

            uint32_t grdm_fwVerLen = 10;

            pRsp->dataLen = 1;

            result = grdm_getinfo(pRsp->data, grdm_chipid, &grdm_chipid_len, grdm_fwVer, &grdm_fwVerLen );

            if (result == GRDM_NO_ERROR) {

                LOGD("CMD_GRDM_GET_INFO grdm_status = %02x grdm_chipid_len = %d", grdm_status, grdm_chipid_len);

                hex_print_tag_debug("GRDM Chip ID", grdm_chipid, grdm_chipid_len);

				hex_print_tag_debug("GRDM FW Version", grdm_fwVer, grdm_fwVerLen);

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("CMD_GRDM_GET_INFO error = %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_PROVISION_ADMIN:   

            LOGD("CMD_GRDM_PROVISION_ADMIN");

            pRsp->dataLen = GRDM_ADMIN_KEYBLOB_BUFFER_SIZE;

            result = grdmProvisionAdmin(pRsp->data,&pRsp->dataLen);

            if (result == GRDM_NO_ERROR) {

                LOGD("grdmProvisionAdmin success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmProvisionAdmin error = %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_PUT_KEY:   

            LOGD("CMD_GRDM_PUT_KEY");

            pRsp->dataLen = GRDM_DOMAIN_KEYBLOB_BUFFER_SIZE;

            result = grdmPutKey(pCmd->data,pCmd->dataLen,pRsp->data,&pRsp->dataLen);



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmPutKey success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmPutKey error = %d", result);

                pRsp->ret = result;

            }

            break;	

        case CMD_GRDM_RESET_ADMIN:   

            LOGD("CMD_GRDM_RESET_ADMIN");

            result = grdmResetAdmin();



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmResetAdmin success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmResetAdmin error = %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_FW_CHECK_IMAGE:   

            LOGD("CMD_GRDM_FW_CHECK_IMAGE");

            pRsp->dataLen = 8;

            result = grdmFWcheckImage(pCmd->data, pCmd->dataLen, pRsp->data,&pRsp->dataLen);



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmFWcheckImage success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmFWcheckImage error = %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_FW_START_UPGRADE:   

            LOGD("CMD_GRDM_FW_START_UPGRADE");

            result = grdmFWstartUpgrade(pCmd->data, pCmd->dataLen);



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmFWstartUpgrade success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmFWstartUpgrade error = %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_FW_CHECK_HEADER:   

            LOGD("CMD_GRDM_FW_CHECK_HEADER");

            result = grdmFWcheckHeader(pCmd->data, pCmd->dataLen, pRsp->data);



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmFWcheckHeader success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmFWcheckHeader error = %d", result);

                pRsp->ret = result;

            }

            break;

         case CMD_GRDM_FW_READ_VERSION:

             LOGD("CMD_GRDM_FW_READ_VERSION");

             result = grdmFwReadVersion(pRsp->data, &pRsp->dataLen);

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmFwReadVersion success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmFwReadVersion error = %d", result);

                 pRsp->ret = result;

             }

             break;

        case CMD_GRDM_FW_UPDATE_UPGRADE:   

            LOGD("CMD_GRDM_FW_UPDATE_UPGRADE");

            result = grdmFWupdateUpgrade(pCmd->data, pCmd->dataLen);



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmFWupdateUpgrade success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmFWupdateUpgrade error = %d", result);

                pRsp->ret = result;

            }

            break;

        case CMD_GRDM_FW_FINISH_UPGRADE:   

            LOGD("CMD_GRDM_FW_UPDATE_UPGRADE");

            result = grdmFWfinishUpgrade(pRsp->data, &pRsp->dataLen);



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmFWfinishUpgrade success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmFWfinishUpgrade error = %d", result);

                pRsp->ret = result;

            }

            break;

         case CMD_GRDM_GET_ATTESCERT:   

             LOGD("CMD_GRDM_GET_ATTESCERT");

             pRsp->dataLen = 2048;

             result = grdm_getAttesCertificate(pCmd->data[0],pRsp->data,&pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("CMD_GRDM_GET_ATTESCERT %02x cert_len = %d", pCmd->data[0], pRsp->dataLen);

                 hex_print_tag_debug("GRDM", pRsp->data, pRsp->dataLen);

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("CMD_GRDM_GET_ATTESCERT error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_FDC_CHECK_STATUS:

             LOGD("CMD_GRDM_FDC_CHECK_STATUS");

             pRsp->dataLen = 2;

             result = grdmFDCCheckStatus(pRsp->data, &pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmFDCCheckStatus success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmFDCCheckStatus error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_FDC_CHECK_RESTRICTION:

             LOGD("CMD_GRDM_FDC_CHECK_RESTRICTION");

             pRsp->dataLen = 2;

             result = grdmFDCCheckRestriction(pRsp->data, &pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmFDCCheckRestriction success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmFDCCheckRestriction error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_FDC_CHECK_LOG:

             LOGD("CMD_GRDM_FDC_CHECK_LOG");

             pRsp->dataLen = 2048;

             result = grdmFDCCheckLog(pRsp->data, &pRsp->dataLen, pCmd->data[0]);

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmFDCCheckLog %02x dataLen = %d", pCmd->data[0], pRsp->dataLen);

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmFDCCheckLog error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_CHECK_STATUS:

             LOGD("CMD_GRDM_CHECK_STATUS");

             pRsp->dataLen = 32;

             result = grdm_checkStatus(pRsp->data, &pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdm_checkStatus  success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdm_checkStatus error = %d", result);

                 pRsp->ret = result;

             }

             break;

 #ifdef DEBUG_LOW

         case CMD_GRDM_GET_BLCREDENTIAL:

             LOGD("CMD_GRDM_GET_BLCREDENTIAL");

             break;

         case CMD_GRDM_GET_ATTES_PUBKEY:   

             LOGD("CMD_GRDM_GET_ATTES_PUBKEY");

             pRsp->dataLen = 2048;

             result = grdm_getAttesPublicKey(pCmd->data[0],pRsp->data,&pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("CMD_GRDM_GET_ATTES_PUBKEY %02x pub_len = %d", pCmd->data[0], pRsp->dataLen);

                 hex_print_tag("GRDM", pRsp->data, pRsp->dataLen);

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("CMD_GRDM_GET_ATTES_PUBKEY error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_ECDSA_ATTESKEY:   

             LOGD("CMD_GRDM_ECDSA_ATTESKEY");

             pRsp->dataLen = 80;

             result = grdm_ecdsa_AttesKey(ATTESTATION_ENDENTITY, pCmd->data, pCmd->dataLen, pRsp->data, &pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("CMD_GRDM_ECDSA_ATTESKEY sigLen = %d", pRsp->dataLen);

                 hex_print_tag("GRDM", pRsp->data, pRsp->dataLen);

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("CMD_GRDM_ECDSA_ATTESKEY error = %d", result);

                 pRsp->ret = result;

             }

             break;

 		case CMD_GRDM_ECDSAWITHHASH_ATTESKEY:   

             LOGD("CMD_GRDM_ECDSAWITHHASH_ATTESKEY");

             pRsp->dataLen = 80;

             result = grdm_ecdsaWithHash_AttesKey(ATTESTATION_ENDENTITY, pCmd->data, pCmd->dataLen, pRsp->data, &pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("CMD_GRDM_ECDSAWITHHASH_ATTESKEY sigLen = %d", pRsp->dataLen);

                 hex_print_tag("GRDM", pRsp->data, pRsp->dataLen);

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("CMD_GRDM_ECDSAWITHHASH_ATTESKEY error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_DELETE_CREDENTIAL:   

             LOGD("CMD_GRDM_DELETE_CREDENTIAL");

             result = grdmDeleteCredential(pCmd->data,pCmd->dataLen);

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmDeleteCredential success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmDeleteCredential error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_STORE_CREDENTIAL:   

             LOGD("CMD_GRDM_STORE_CREDENTIAL");

             result = grdmStoreCredential(pCmd->data,pCmd->dataLen);

             

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmStoreCredential success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmStoreCredential error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_GET_CREDENTIAL:   

             LOGD("CMD_GRDM_GET_CREDENTIAL");

             result = grdmGetCredential(pCmd->data,pCmd->dataLen);

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmGetCredential success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmGetCredential error = %d", result);

                 pRsp->ret = result;

             }

             break;	

         case CMD_GRDM_GED_DEVICE_ATTESTATION:   

             LOGD("CMD_GRDM_GED_DEVICE_ATTESTATION");

             pRsp->dataLen = 3072;

             result = grdmGetDeviceAttestation(pCmd->data, pCmd->dataLen, pRsp->data, &pRsp->dataLen);

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmGetDeviceAttestation success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmGetDeviceAttestation error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_FACTORY_RESET:

             LOGD("CMD_GRDM_FACTORY_RESET");

             result = grdmFactoryReset();

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmFactoryReset success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmFactoryReset error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_ADMINKEY_RESET:

             LOGD("CMD_GRDM_ADMINKEY_RESET");

             result = grdmAdminKeyReset();

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmAdminKeyReset success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmAdminKeyReset error = %d", result);

                 pRsp->ret = result;

             }

         case CMD_GRDM_ECDSA_SAK:

             LOGD("CMD_GRDM_ECDSA_SAK");

             pRsp->dataLen = 200;

             uint8_t tempKey[32] = {0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,

                                    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x81};

             uint8_t tempKeyLen = 32;

             hex_print_tag("message", pCmd->data, pCmd->dataLen);

             result = grdm_ecdsa_SAK(DOMAIN_INDEX_KM, tempKey, tempKeyLen, pCmd->data, pCmd->dataLen, pRsp->data, &pRsp->dataLen);

             hex_print_tag("signature", pRsp->data, pRsp->dataLen);

             if (result == GRDM_NO_ERROR) {

                 LOGD("CMD_GRDM_ECDSA_SAK sigLen = %d", pRsp->dataLen);

                 hex_print_tag("GRDM",pRsp->data,pRsp->dataLen);

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("CMD_GRDM_ECDSA_SAK error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_KM_PUTKEY:

             LOGD("CMD_GRDM_KM_PUTKEY");

             result = grdmKMPutkey();

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmKMPutkey success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmKMPutkey error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_ICCC_PUTKEY:

             LOGD("CMD_GRDM_ICCC_PUTKEY");

             result = grdmICCCPutkey();

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmICCCPutkey success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmICCCPutkey error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_GET_BL_CREDENTIAL:

             LOGD("CMD_GRDM_GET_BL_CREDENTIAL");

             result = grdmGetBLCredential();

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmGetBLCredential success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmGetBLCredential error = %d", result);

                 pRsp->ret = result;

             }

             break;

         case CMD_GRDM_FDC_ATTCK:

             LOGD("CMD_GRDM_FDC_ATTCK");

             pRsp->dataLen = 2;

             result = grdmFDCAttack(pRsp->data, &pRsp->dataLen, pCmd->data[0]);

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmFDCAttack success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmFDCAttack error = %d", result);

                 pRsp->ret = result;

             }

             break;

 #endif /* DEBUG_LOW */

 #ifdef GRDM_TEST

        case CMD_GRDM_RESET_STATUS:

            LOGD("CMD_GRDM_RESET_STATUS");

            result = grdmResetStatus();



            if (result == GRDM_NO_ERROR) {

                LOGD("grdmResetStatus success");

                pRsp->ret = RET_SUCCESS;

            } else {

                LOGE("grdmResetStatus error = %d", result);

                pRsp->ret = result;

            }

            break;

         case CMD_GRDM_BL_PUTKEY:   

             LOGD("CMD_GRDM_BL_PUTKEY");

             result = grdmBlPutkey();

 

             if (result == GRDM_NO_ERROR) {

                 LOGD("grdmBlPutkey success");

                 pRsp->ret = RET_SUCCESS;

             } else {

                 LOGE("grdmBlPutkey error = %d", result);

                 pRsp->ret = result;

             }

             break;

 #endif /* GRDM_TEST */

#endif /* USE_GRDM */

/*********************************************** GRDM ***********************************************/

        default :

            LOGE("Matched command is not exist !!!");

            pRsp->ret = RET_ERR_NOT_SUPPORTED;

            break;

    }

    

    LOGD("SEM Trusted Application is exiting with return : %x, status : %x", pRsp->ret, pRsp->status);

}