#include "sse.h"

#include "sse_entry_manage_util.h"

#include "sse_private.h"

#include "ssp.h"



#include "tz_debug.h"



#define SELECT_SSE_RESPONSE_SIZE                3



#ifdef DEBUG_LOW

#include "ssp_util.h"

#endif



void getSseVer(p_rsp_t rsp) {

    ESESTATUS ese_status;

    uint8_t channelId = 0x00;

    uint8_t sseVer[3] = {0x00,};

    secEse_7816_rpdu_t response;

    uint8_t r_data[SELECT_SSE_RESPONSE_SIZE];



    LOGD("getSseVer start");



    response.pdata = r_data;



    ese_status = secEseOpen(&channelId);



    if (ESESTATUS_SUCCESS != ese_status) {

        LOGE("Failed to open channel in getSseVer ESESTATUS = 0x%08X", ese_status );

        rsp->ret = RET_ERR_IS_SSP_VALID;

        goto error;

    }

    

    ese_status = secEseSelect(channelId, (uint8_t*)SSE_AID, 0, 0x10, &response);



    if (ESESTATUS_SUCCESS != ese_status) {

        LOGE( "ESESTATUS = 0x%08X", ese_status );

        rsp->ret = RET_ERR_IS_SSP_VALID;

        goto error;

    }



    if (response.sw1 != 0x90 || response.sw2 != 0x00) {

        LOGE( "SSE SW = %02X %02x", response.sw1, response.sw2 );

        rsp->ret = RET_ERR_IS_SSP_VALID;

        goto error;

    }



    getSSEVersion(response.pdata[0], response.pdata[1], sseVer, sseVer + 1, sseVer + 2);



    rsp->data[0] = sseVer[0];

    rsp->data[1] = sseVer[1];

    rsp->data[2] = sseVer[2];

    rsp->dataLen = SELECT_SSE_RESPONSE_SIZE;

    rsp->ret = RET_SUCCESS;



error:

    secEseClose(channelId);

    LOGD("Ver : %x.%x.%x", sseVer[0], sseVer[1], sseVer[2]);

    LOGD("getSseVer returned: %d", rsp->ret);

}



void deleteAllSSEntry(p_cmd_t cmd, p_rsp_t rsp) {

    SSESTATUS sse_ret;

    uint8_t otp_key_blob[SSP_MAX_WRAPPED_OTP_KEY_SIZE];



    const uint8_t semTID[16] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B };

    uint32_t inputSize;



    LOGD("--SSEM-------------deleteAllSSEntry title: Delte All entries!---");

    inputSize = cmd->dataLen;

    // Copy otp key blob from cmd data

    if (inputSize > SSP_MAX_WRAPPED_OTP_KEY_SIZE) {

        LOGE("Input data is over the buffer.");

        rsp->ret = RET_ERR_BUFFER_OVERFLOW;

        return ;

    }

    memcpy(otp_key_blob, cmd->data, inputSize);



    sse_ret = startService(otp_key_blob, inputSize, semTID);

    if (sse_ret != SSESTATUS_OK) {

        LOGE("--SSEM-- deleteAllSSEntry() failed on startService() , sse_ret : 0x%04x", sse_ret);

        rsp->ret = RET_ERR_DELETE_ALL_SS_ENTRY;

        goto error;

    }



    sse_ret = deleteAllEntry(); // SSEM

    if (sse_ret != SSESTATUS_OK) {

        LOGE("--SSEM-- deleteAllSSEntry() failed on deleteDataEntryAll() , sse_ret : 0x%04x", sse_ret);

        rsp->ret = RET_ERR_DELETE_ALL_SS_ENTRY;

        goto error;

    }



    rsp->ret = RET_SUCCESS;



error:

    if (SSPSTATUS_SUCCESS != stopService()) {

        rsp->ret = RET_ERR_TZ;

        LOGE("failed to stop service");

    } else {

        rsp->status = sse_ret;

    }

    return;

}



void deleteFIDODefaultEntry(p_cmd_t cmd, p_rsp_t rsp) {

    SSESTATUS sse_ret;



    uint8_t otp_key_blob[SSP_MAX_WRAPPED_OTP_KEY_SIZE];

    uint8_t fidoDefaultEntry[3][4] = {{0x19,0x56,0x77,0x7E},{0xCB,0x1B,0x4C,0x10},{0xA2,0x8F,0xE2,0x4B}};

    uint8_t outRetryCnt[1] = {0};

    delete_data_param_t deleteParam;



    uint8_t channelId = 0;

    uint8_t sseVersion[3] = {0,};



    int index = 0;

    int successCnt = 0;



    uint32_t inputSize;



    LOGD("deleteFIDODefaultEntry [start] ");

    inputSize = cmd->dataLen;

    memset(&deleteParam, 0, sizeof(delete_data_param_t));

    // Copy otp key blob from cmd data

    if (inputSize > SSP_MAX_WRAPPED_OTP_KEY_SIZE) {

        LOGE("Input data is over the buffer.");

        rsp->ret = RET_ERR_BUFFER_OVERFLOW;

        return ;

    }

    memcpy(otp_key_blob, cmd->data, inputSize);



    for (index = 0; index < 3; index++) {

        LOGD("%d ---------------- deleteFIDODefaultEntry [start] ",index);



        sse_ret = startService(otp_key_blob, inputSize, SEM_TID);

        if (sse_ret != SSESTATUS_OK) {

            rsp->ret = RET_ERR_DELETE_FIDO_DEFAULT_ENTRY;

            stopService();

        }



        getSSEVer(sseVersion);



        LOGD("SSE VERSION : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

        if (sseVersion[0] < 0x02) {

            LOGI( "SSE version is not supported. Low version = : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

            rsp->ret = RET_ERR_DELETE_FIDO_DEFAULT_ENTRY;

            secEseClose(channelId);

            return;

        }



        if (sseVersion[0] == 0x02 && (sseVersion[1] == 0x01 || sseVersion[1] == 0x02)) {

            LOGD("start Delete all FIDO default entries");

        } else {

            LOGI("Not matching case for deleteFIDODefaultEntry");

            rsp->ret = RET_ERR_DELETE_FIDO_DEFAULT_ENTRY;

            secEseClose(channelId);

            return;

        }



        deleteParam.data_type = GED_DATA_TYPE_NORMAL;

        deleteParam.entryId = fidoDefaultEntry[index];

        deleteParam.outRemainRetryCnt = outRetryCnt;

        deleteParam.auth_type = GED_AUTH_TYPE_NONE;

        LOGD(" %d ============================deleteEntryData============================",index);

        sse_ret= deleteEntryData(&deleteParam);



        if (sse_ret== SSESTATUS_OK || sse_ret== SSESTATUS_REF_DATA_NOT_FOUND) {

            LOGD("Success delete entries");

            successCnt++;

        } else {

            LOGE("Failed to delete %x", fidoDefaultEntry[index][0]);

        }



        stopService();

    }



    if (successCnt == index-1) {

        rsp->ret = RET_SUCCESS;

    }



    return;

}



void updateWarrantyBitEntry_Normal(p_cmd_t cmd, p_rsp_t rsp) {

    SSESTATUS sse_ret;



    uint8_t otp_key_blob[SSP_MAX_WRAPPED_OTP_KEY_SIZE];

    uint8_t warrantyBitEntryId[4] = {0xA2,0xBA,0x49,0x64}; // "WarrantyBit"



    put_data_param_t putParam;

    get_data_param_t getParam;



    uint8_t outRemainRetryCnt = 0;



    uint8_t channelId = 0;

    uint8_t sseVersion[3] = {0,};



    uint8_t outData = {0x00};



    uint8_t inData = {0x00};



    uint32_t inputSize;



    LOGI("updateWarrantyBitEntry_Normal");

    inputSize = cmd->dataLen;

    // Copy otp key blob from cmd data

    if (inputSize > SSP_MAX_WRAPPED_OTP_KEY_SIZE) {

        LOGE("Input data is over the buffer.");

        return ;

    }

    memcpy(otp_key_blob, cmd->data, inputSize);



    sse_ret = startService(otp_key_blob, inputSize, SEM_TID);

    if (sse_ret != SSESTATUS_OK) {

        rsp->ret = RET_ERR_UPDATE_DSI_ENTRY;

        stopService();

    }



    getSSEVer(sseVersion);



    LOGD("SSE VERSION : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

    if (sseVersion[0] < 0x02) {

        LOGI( "SSE version is not supported. Low version = : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

        rsp->ret = RET_ERR_UPDATE_DSI_ENTRY;

        secEseClose(channelId);

        goto error;

    }



    memset(&putParam, 0, sizeof(put_data_param_t));

    putParam.entryId = warrantyBitEntryId;

    putParam.accessableTAID = (uint8_t*)SEM_TID;

    putParam.accessableTAIDLen= 16;

    putParam.entryCreation = PED_ENTRY_CREATE_N_PUT_DATA;// PED_ENTRY_EXISTS_N_PUT_DATA;//

    putParam.data_type = PED_DATA_TYPE_NORMAL;

    putParam.scope =  PED_SCOPE_PUBLIC;

    putParam.auth_type = PED_AUTH_TYPE_NONE;

    putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

    putParam.delete_option = PED_DELETE_OPTION_DELETABLE;

    putParam.inData = &inData;

    putParam.inDataLen = 1;

    putParam.outRemainRetryCnt = &outRemainRetryCnt;



    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = warrantyBitEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = &outData;

    getParam.outDataLen = 1;

    getParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret = getEntryData(&getParam);



    hex_print_tag_debug("updateWarrantyBitEntry_Normal() - before", getParam.outData, getParam.outDataLen);



    if (sse_ret != SSESTATUS_OK) {

        if(sse_ret == SSESTATUS_REF_DATA_NOT_FOUND) {

            LOGD("updateWarrantyBitEntry_Normal() WarrantyBitEntry not exists. Create.");

            putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA;

        } else {

            LOGE("updateWarrantyBitEntry_Normal failed, sse_ret : 0x%04x", sse_ret);

        }

    } else {

        LOGD("updateWarrantyBitEntry_Normal() entry exists. Update.");

        putParam.entryCreation =  PED_ENTRY_EXISTS_N_PUT_DATA;

    }



    sse_ret= putEntryData(&putParam);



/*

    // for validation

    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = warrantyBitEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = &outData;

    getParam.outDataLen = 1;

    getParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret = getEntryData(&getParam);

    hex_print_tag_debug("updateWarrantyBitEntry_Normal() - after", getParam.outData, getParam.outDataLen);

*/



error:

    if (SSPSTATUS_SUCCESS != stopService()) {

        rsp->ret = RET_ERR_TZ;

        LOGE("updateDSIEntry() failed to stop service");

    } else {

        rsp->status = sse_ret;

    }



    return;

}



void updateWarrantyBitEntry_Abnormal(p_cmd_t cmd, p_rsp_t rsp) {

    SSESTATUS sse_ret;



    uint8_t otp_key_blob[SSP_MAX_WRAPPED_OTP_KEY_SIZE];

    uint8_t warrantyBitEntryId[4] = {0xA2,0xBA,0x49,0x64}; // "WarrantyBit"



    put_data_param_t putParam;

    get_data_param_t getParam;

//    delete_data_param_t deleteParam;



    uint8_t outRemainRetryCnt = 0;



    uint8_t channelId = 0;

    uint8_t sseVersion[3] = {0,};



    uint8_t outData = {0x00};

    uint8_t inData = {0x01};



    uint32_t inputSize;



    LOGI("updateWarrantyBitEntry_Abnormal");

    inputSize = cmd->dataLen;

    // Copy otp key blob from cmd data

    if (inputSize > SSP_MAX_WRAPPED_OTP_KEY_SIZE) {

        LOGE("Input data is over the buffer.");

        return ;

    }

    memcpy(otp_key_blob, cmd->data, inputSize);



    sse_ret = startService(otp_key_blob, inputSize, SEM_TID);

    if (sse_ret != SSESTATUS_OK) {

        rsp->ret = RET_ERR_UPDATE_DSI_ENTRY;

        stopService();

    }



    getSSEVer(sseVersion);



    LOGD("SSE VERSION : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

    if (sseVersion[0] < 0x02) {

        LOGI( "SSE version is not supported. Low version = : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

        rsp->ret = RET_ERR_UPDATE_DSI_ENTRY;

        secEseClose(channelId);

        goto error;

    }



    memset(&putParam, 0, sizeof(put_data_param_t));

    putParam.entryId = warrantyBitEntryId;

    putParam.accessableTAID = (uint8_t*)SEM_TID;

    putParam.accessableTAIDLen= 16;

    putParam.entryCreation = PED_ENTRY_CREATE_N_PUT_DATA;// PED_ENTRY_EXISTS_N_PUT_DATA;//

    putParam.data_type = PED_DATA_TYPE_NORMAL;

    putParam.scope =  PED_SCOPE_PUBLIC;

    putParam.auth_type = PED_AUTH_TYPE_NONE;

    putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

    putParam.delete_option = PED_DELETE_OPTION_DELETABLE;

    putParam.inData = &inData;

    putParam.inDataLen = 1;

    putParam.outRemainRetryCnt = &outRemainRetryCnt;



    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = warrantyBitEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = &outData;

    getParam.outDataLen = 1;

    getParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret = getEntryData(&getParam);



    hex_print_tag_debug("updateWarrantyBitEntry_Abnormal() - before", getParam.outData, getParam.outDataLen);



    if (sse_ret != SSESTATUS_OK) {

        if(sse_ret == SSESTATUS_REF_DATA_NOT_FOUND) {

            LOGD("updateWarrantyBitEntry_Abnormal() WarrantyBitEntry not exists. Create.");

            putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA;

        } else {

            LOGE("updateWarrantyBitEntry_Abnormal failed, sse_ret : 0x%04x", sse_ret);

        }

    } else {

        LOGD("updateWarrantyBitEntry_Abnormal() entry exists. Update.");

        putParam.entryCreation =  PED_ENTRY_EXISTS_N_PUT_DATA;

    }



    sse_ret= putEntryData(&putParam);



/*

    // for validation

    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = warrantyBitEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = &outData;

    getParam.outDataLen = 1;

    getParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret = getEntryData(&getParam);

    hex_print_tag_debug("updateWarrantyBitEntry_Abnormal() - after", getParam.outData, getParam.outDataLen);



    memset(&deleteParam, 0, sizeof(delete_data_param_t));

    deleteParam.data_type = GED_DATA_TYPE_NORMAL;

    deleteParam.entryId = warrantyBitEntryId;

    deleteParam.outRemainRetryCnt = outRemainRetryCnt;

    deleteParam.auth_type = DED_AUTH_TYPE_NONE;

    sse_ret= deleteEntryData(&deleteParam);

*/

error:

    if (SSPSTATUS_SUCCESS != stopService()) {

        rsp->ret = RET_ERR_TZ;

        LOGE("updateWarrantyBitEntry_Abnormal() failed to stop service");

    } else {

        rsp->status = sse_ret;

    }



    return;

}



void updateDSIEntry(p_cmd_t cmd, p_rsp_t rsp) {

    SSESTATUS sse_ret;



    uint8_t otp_key_blob[SSP_MAX_WRAPPED_OTP_KEY_SIZE];

    uint8_t dsiEntryId[4] = {0x76,0x0E,0xC7,0xDC};



    put_data_param_t putParam;

    get_data_param_t getParam;



    uint8_t outRemainRetryCnt = 0;



    uint8_t channelId = 0;

    uint8_t sseVersion[3] = {0,};



    uint8_t outData[4] = {0x00, };

// [[ validation code

    uint8_t __tempInData1[4] = {0x00, 0x01, 0x02, 0x03};

//    uint8_t __tempInData2[4] = {0x10, 0x11, 0x12, 0x13};

//    uint8_t __tempOutRetryCnt = 0;

//    delete_data_param_t deleteParam;

//    ]] validation code



    uint32_t inputSize;



    LOGI("updateDSIEntry");

    inputSize = cmd->dataLen;

    // Copy otp key blob from cmd data

    if (inputSize > SSP_MAX_WRAPPED_OTP_KEY_SIZE) {

        LOGE("Input data is over the buffer.");

        return ;

    }

    memcpy(otp_key_blob, cmd->data, inputSize);



    sse_ret = startService(otp_key_blob, inputSize, SEM_TID);

    if (sse_ret != SSESTATUS_OK) {

        rsp->ret = RET_ERR_UPDATE_DSI_ENTRY;

        stopService();

    }



    getSSEVer(sseVersion);



    LOGD("SSE VERSION : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

    if (sseVersion[0] < 0x02) {

        LOGI( "SSE version is not supported. Low version = : %x.%x.%x", sseVersion[0], sseVersion[1], sseVersion[2]);

        rsp->ret = RET_ERR_UPDATE_DSI_ENTRY;

        secEseClose(channelId);

        goto error;

    }

/* [[ validation code

    memset(&deleteParam, 0, sizeof(delete_data_param_t));

    deleteParam.data_type = GED_DATA_TYPE_NORMAL;

    deleteParam.entryId = dsiEntryId;

    deleteParam.outRemainRetryCnt = outRemainRetryCnt;

    deleteParam.auth_type = PED_AUTH_TYPE_NONE;

    sse_ret= deleteEntryData(&deleteParam);

    LOGD("updateDSIEntry deleteEntry : sse_ret = 0x%04x", sse_ret);



    memset(&putParam, 0, sizeof(delete_data_param_t));

    putParam.entryId = dsiEntryId;

    putParam.accessableTAID = (uint8_t*)SEM_TID;

    putParam.accessableTAIDLen= 16;

    putParam.entryCreation = PED_ENTRY_CREATE_N_PUT_DATA;// PED_ENTRY_EXISTS_N_PUT_DATA;//

    putParam.data_type = PED_DATA_TYPE_NORMAL;

    putParam.scope =  PED_SCOPE_PUBLIC;

    putParam.auth_type = PED_AUTH_TYPE_NONE;

    putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

    putParam.delete_option = PED_DELETE_OPTION_DELETABLE;

    putParam.inData = __tempInData1;

    putParam.inDataLen = 4;

    putParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret= putEntryData(&putParam);



    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = dsiEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = outData;

    getParam.outDataLen = 4;

    getParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret = getEntryData(&getParam);

    LOGI("updateDSIEntry, CreatePut -> getEntryData 1 =0x%02X,0x%02X,0x%02X,0x%02X , Len=0x%02x", getParam.outData[0],getParam.outData[1],getParam.outData[2],getParam.outData[3], getParam.outDataLen);

    ]] validation code

*/



    // TODO : GET SYSCOPE value by ICCC ?



    memset(&putParam, 0, sizeof(put_data_param_t));

    putParam.entryId = dsiEntryId;

    putParam.accessableTAID = (uint8_t*)SEM_TID;

    putParam.accessableTAIDLen= 16;

    putParam.entryCreation = PED_ENTRY_CREATE_N_PUT_DATA;// PED_ENTRY_EXISTS_N_PUT_DATA;//

    putParam.data_type = PED_DATA_TYPE_NORMAL;

    putParam.scope =  PED_SCOPE_PUBLIC;

    putParam.auth_type = PED_AUTH_TYPE_NONE;

    putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

    putParam.delete_option = PED_DELETE_OPTION_DELETABLE;

    putParam.inData = __tempInData1;

    putParam.inDataLen = 4;

    putParam.outRemainRetryCnt = &outRemainRetryCnt;



    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = dsiEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = outData;

    getParam.outDataLen = 4;

    getParam.outRemainRetryCnt = &outRemainRetryCnt;

    sse_ret = getEntryData(&getParam);



    hex_print_tag_debug("updateDSIEntry() - before", getParam.outData, getParam.outDataLen);



    if (sse_ret != SSESTATUS_OK) {

        if(sse_ret == SSESTATUS_REF_DATA_NOT_FOUND) {

            LOGD("updateDSIEntry() DSI entry not exists. Create.");

            putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA;

        } else {

            LOGE("DSI getEntryData failed, sse_ret : 0x%04x", sse_ret);

        }

    } else {

        LOGD("updateDSIEntry() DSI entry exists. Update.");

        putParam.entryCreation =  PED_ENTRY_EXISTS_N_PUT_DATA;

    }



    sse_ret= putEntryData(&putParam);



/* [[ validation code

    getParam.entryId = dsiEntryId;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = outData;

    getParam.outDataLen = 4;

    getParam.outRemainRetryCnt = &__tempOutRetryCnt;

    sse_ret = getEntryData(&getParam);

    hex_print_tag_debug("updateDSIEntry - after", getParam.outData, getParam.outDataLen);

    //]] validation code

*/

error:

    if (SSPSTATUS_SUCCESS != stopService()) {

        rsp->ret = RET_ERR_TZ;

        LOGE("updateDSIEntry() failed to stop service");

    } else {

        rsp->status = sse_ret;

    }



    return;

}



void updateDefaultEntryAuth(p_cmd_t cmd, p_rsp_t rsp) {

    uint8_t defaultEntriesId[][4] = { \

        {0xAB,0xF3,0x63,0x6E},{0x19,0x56,0x77,0x7E},{0x89,0x16,0x03,0x33},{0x12,0x5b,0x12,0x19},{0xcb,0x1b,0x4c,0x10}, \

        {0x57,0x4b,0x4c,0x4b},{0xa1,0x41,0x96,0x8c},{0xA2,0x8F,0xE2,0x4B},{0x55,0x10,0x28,0xA2},{0x51,0xd0,0x54,0x2f} };

    int i=0;

#ifdef DEBUG_LOW

    int defaultEntryCount = 0;

#endif

    put_data_param_t putParam;

    uint8_t outRemainRetryCnt = 0;

    SSESTATUS sseStatus = SSESTATUS_OK;

    uint32_t inputSize;



//    uint8_t tempData[] = {10,9,8,7,6};



    inputSize = cmd->dataLen;

    memset(&putParam, 0, sizeof(put_data_param_t));

#ifdef DEBUG_LOW

    defaultEntryCount = sizeof(defaultEntriesId) / 4;

    LOGD("sizeof(defaultEntries) / 4 = %d", defaultEntryCount);

#endif

    if (0 != startService(cmd->data, inputSize, SEM_TID)) {

        LOGE("  updateDefaultEntryAuth opensession failed ");

        rsp->ret = RET_ERR_TZ;

        return ;

    }



    for ( i=0 ; i < 1/*defaultEntryCount*/; i++) {

        LOGD("========= UPDATE DEFAULT ENTRIES AUTH [start (%d)]==========",i);

        putParam.entryId = defaultEntriesId[i];

        putParam.accessableTAID = (uint8_t*)SEM_TID;

        putParam.accessableTAIDLen= 16;

        putParam.entryCreation =  PED_ENTRY_EXISTS_N_PUT_DATA;

        putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

        putParam.outRemainRetryCnt = &outRemainRetryCnt;

        putParam.delete_option = PED_DELETE_OPTION_PERMANENT;

//        putParam.inData = tempData;

//        putParam.inDataLen = 5;



        sseStatus = putEntryData(&putParam);

        if (sseStatus == SSESTATUS_OK) {

            LOGD("ENTRY#[%d] SUCCESS",i);

        } else {

            LOGE("ENTRY#[%d] failed",i);

            rsp->ret = RET_ERR_TZ;

            goto error;

        }

        LOGD("========= UPDATE DEFAULT ENTRIES AUTH [end (%d)]==========",i);

    }



    rsp->ret = RET_SUCCESS;



error:

    stopService();

}



void updateSSEDefaultEntryTaId(p_cmd_t cmd, p_rsp_t rsp) {

    uint8_t apdu_read_entry[] = {

        0x80, 0xCA, 0x00, 0x00, 

        0x08, 0xE0, 0x06, 0xE2, 0x04, 0xAB, 0xF3, 0x63, 

        0x6E

    };

    uint8_t apdu_update_ta_id[] = {

        //0x80, 0xDA, 0x60, 0x40, 

        //0x21,

        0xE0, 0x1F, 0xE1, 0x03, 0x00, 0x00, 0x00, 0xE2, 

        0x04, 0xAB, 0xF3, 0x63, 0x6E, 0xE3, 0x12, 0xE6, 

        0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 

        0x1B

    };

    uint8_t tid_sem[SSP_TID_SIZE] = { 

        0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 

        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B 

    };

    uint8_t r_data[MAX_RAPDU_DATA_SIZE] = {0,};

    

    uint8_t channel_id;

    uint32_t session_id;

    secEse_7816_rpdu_t rpdu;

    secEse_7816_cpdu_t cpdu;

    

    ESESTATUS ese_status = ESESTATUS_FAILED;

    SSPSTATUS ssp_status = SSPSTATUS_FAILED;



    rpdu.sw1 = 0;

    rpdu.sw2 = 0;

    rpdu.pdata = r_data;



    // read default entry without ssp

    ese_status = secEseOpen(&channel_id);



    if (ese_status != ESESTATUS_SUCCESS) {

        LOGE("Failed to open channel in updateSSEDefaultEntryTaId");

        rsp->status = ese_status;

        rsp->ret = RET_ERR_ESE_OPEN_FAILED;

        return;

    }



    ese_status = secEseSelect(channel_id, (uint8_t*)SSE_AID, 0, sizeof(SSE_AID), &rpdu);



    if (ese_status != ESESTATUS_SUCCESS || rpdu.sw1 != 0x90 || rpdu.sw2 != 0x00) {

        LOGE("updateSSEDefaultEntryTaId ESESTATUS = 0x%08X", ese_status);

        rsp->status = ese_status;

        rsp->ret = RET_ERR_ESE_SELECT_FAILED;

        secEseClose(channel_id);

        return;

    }



    ese_status = secEseAPDUTransmit(channel_id, apdu_read_entry,sizeof(apdu_read_entry), &rpdu);



    if (ese_status != RET_SUCCESS ) {

        LOGE("updateSSEDefaultEntryTaId Transmit failed.");

        rsp->status = ese_status;

        rsp->ret = RET_ERR_ESE_TRANSMIT_FAILED;        

        secEseClose(channel_id);

        return;

    }



    if (rpdu.sw1 == 0x69 && rpdu.sw2 == 0x85) {

        LOGD("updateSSEDefaultEntryTaId Aleady updated.");

        rsp->ret = RET_SUCCESS;        

        secEseClose(channel_id);

        return;

    }



    if (!(rpdu.sw1 == 0x90 && rpdu.sw2 == 0x00)) {

        LOGE("updateSSEDefaultEntryTaId unknown status");

        rsp->status = (rpdu.sw1 << 8) + rpdu.sw2;

        rsp->ret = RET_ERR_SSE_UPDATE_ENTRY_TA_ID_UNKNOWN_ESE_SW_BEFORE_UPDATE;

        secEseClose(channel_id);

        return;

    }



    // set sse default entry ta-id with ssp

    ssp_status = ssp_openSession(&session_id, channel_id, cmd->data, cmd->dataLen, tid_sem, SSE_AID, 16);



    if (ssp_status != SSPSTATUS_SUCCESS) {

        LOGE("updateSSEDefaultEntryTaId ssp_openSession failed. SSPSTATUS = 0x%08X", ssp_status);

        rsp->status = ssp_status;

        rsp->ret = RET_ERR_SSP_OPEN_FAILED;

        secEseClose(channel_id);

        return;

    }



    cpdu.cla = 0x80;

    cpdu.ins = 0xDA;

    cpdu.p1 = 0x60;

    cpdu.p2 = 0x40;

    cpdu.lc = sizeof(apdu_update_ta_id);

    cpdu.pdata = apdu_update_ta_id;

    cpdu.le_type = 0x00;

    cpdu.le = 0x00;

    cpdu.cpdu_type = 0;



    ssp_status = ssp_transaction(session_id, &cpdu, &rpdu);

    

    if (ssp_status != SSPSTATUS_SUCCESS) {

        LOGE("updateSSEDefaultEntryTaId ssp_transaction failed. SSPSTATUS = 0x%08X", ssp_status);

        rsp->status = ssp_status;

        rsp->ret = RET_ERR_SSP_TRANSACTION_FAILED;        

        ssp_closeSession(session_id);

        secEseClose(channel_id);

        return;

    }



    if (!(rpdu.sw1 == 0x90 && rpdu.sw2 == 0x00)) {

        rsp->status = (rpdu.sw1 << 8) + rpdu.sw2;

        LOGE("updateSSEDefaultEntryTaId ssp_transaction failed. unknown ssp sw. sw = 0x%08X", rsp->status);

        rsp->ret = RET_ERR_SSE_UPDATE_ENTRY_TA_ID_UNKNOWN_SSP_SW;        

        ssp_closeSession(session_id);

        secEseClose(channel_id);

        return;

    }



    ssp_status = ssp_closeSession(session_id);

    

    if (ssp_status != SSPSTATUS_SUCCESS) {

        LOGE("updateSSEDefaultEntryTaId ssp_closeSession failed. SSPSTATUS = 0x%08X", ssp_status);

        rsp->status = ssp_status;

        rsp->ret = RET_ERR_SSP_CLOSE_FAILED;        

        secEseClose(channel_id);

        return;

    }



    // retry read default entry without ssp.

    ese_status = secEseAPDUTransmit(channel_id, apdu_read_entry,sizeof(apdu_read_entry), &rpdu);



    if (ese_status != RET_SUCCESS) {

        LOGE("updateSSEDefaultEntryTaId Transmit failed.");

        rsp->status = ese_status;

        rsp->ret = RET_ERR_ESE_TRANSMIT_FAILED;        

        secEseClose(channel_id);

        return;

    }



    if (rpdu.sw1 == 0x90 && rpdu.sw2 == 0x00) {

        rsp->ret = RET_ERR_SSE_UPDATE_ENTRY_TA_ID_NOT_UPDATED;        

        secEseClose(channel_id);

        return;

    }



    if (!(rpdu.sw1 == 0x69 && rpdu.sw2 == 0x85)) {

        LOGE("updateSSEDefaultEntryTaId unknown status");

        rsp->status = (rpdu.sw1 << 8) + rpdu.sw2;

        rsp->ret = RET_ERR_SSE_UPDATE_ENTRY_TA_ID_UNKNOWN_ESE_SW_AFTER_UPDATE;        

        secEseClose(channel_id);

        return;

    }



    LOGD("updateSSEDefaultEntryTaId updated.");

    rsp->ret = RET_SUCCESS;        

    secEseClose(channel_id);

    return;

}



#ifdef DEBUG_LOW



void putEntryDataTest_stress(p_cmd_t cmd, p_rsp_t rsp) {

//    int i=0;

//    uint8_t outData[100] = {0,};



    put_data_param_t putParam;

    int ret=-1;



    uint32_t inputSize;

    uint8_t outRemainRetryCnt = 0;



    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0x01};

    uint8_t entrydata_48[48] =

        {0X00,0X01,0X02,0X03,0X04,0X05,0X06,0X07,0X08,0X09,0X0A,0X0B,0X0C,0X0D,0X0E,0X0F,

     0X10,0X11,0X12,0X13,0X14,0X15,0X16,0X17,0X18,0X19,0X1A,0X1B,0X1C,0X1D,0X1E,0X1F,

     0X20,0X21,0X22,0X23,0X24,0X25,0X26,0X27,0X28,0X29,0X2A,0X2B,0X2C,0X2D,0X2E,0X2F};



    memset(&putParam, 0, sizeof(put_data_param_t));





/*

    uint8_t kvn30[48] = { \

        0x4a,0x56,0x57,0x23,0xd3,0x53,0xc3,0xdf,0xc5,0x54,0xf8,0xce,0x1d,0x4c,0xca,0x8d \

        ,0x6c,0x1e,0xe7,0x9c,0x1c,0x40,0xae,0x94,0x0c,0x60,0x66,0x2e,0x86,0x1e,0xbc,0x61 \

        ,0xce,0xd7,0xee,0x11,0x58,0xe9,0xfd,0xcc,0x2b,0x52,0xd7,0x2b,0xa9,0xa4,0x61,0x1c};



    uint8_t kvn30_ot[48] = { \

        0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3 \

        ,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3 \

        ,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3 };



    uint8_t kvn30_otdummy[45] = { \

        0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03, \

        0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03, \

        0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03};

*/

    putParam.entryId = entryid;

    putParam.accessableTAID = (uint8_t*)SEM_TID;

    putParam.accessableTAIDLen= 16;

    putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA; //PED_ENTRY_EXISTS_N_PUT_DATA ;

    putParam.data_type = PED_DATA_TYPE_NORMAL;

    putParam.update_command = GED_UPDATE_DATA_N_ACCESS_RULE;

    putParam.scope =  PED_SCOPE_PRIVATE;

    putParam.outRemainRetryCnt = &outRemainRetryCnt;

    putParam.delete_option = GED_DELETE_OPTION_DELETABLE;

    putParam.auth_type = PED_AUTH_TYPE_NONE;

    putParam.inData = entrydata_48;

    putParam.inDataLen = 48;



    LOGI("putEntryDataTest [start]");

    inputSize = cmd->dataLen;

    if( 0 != startService(cmd->data, inputSize, SEM_TID)) {

        LOGE("puttEntryDataTest opensession failed ");

        return ;

    }



    ret=putEntryData(&putParam);



/*

    for(i=0 ; i < 3 ; i++) {

        LOGD("%d == == == == == == == == == == puttEntryDataTest :: puttEntryData == == == == == == == == == == ",i );

        putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA;

        putParam.entryId = fidoDefaultEntry[i];

        putParam.inData = fidoDefaultEntryData[i];

        putParam.inDataLen = 10;

        putEntryData(&putParam);

    }



    for(i=0; i< 3 ; i++) {

        LOGD("%d == == == == == == == == == == gettEntryDataTest :: gettEntryData == == == == == == == == == == ",i );

        getParam.entryId = fidoDefaultEntry[i];

        getParam.data_type = GED_DATA_TYPE_NORMAL;

        getParam.outData = outData;

        getParam.outDataLen = sizeof(outData);

        getParam.outRemainRetryCnt = &outRemainRetryCnt;

        getEntryData(&getParam);

        hex_print_tag_debug("[ TEST ] entry :: ", outData, getParam.outDataLen);

    }

*/

    stopService();

    LOGI("putEntryDataTest [END]");

    rsp->ret = ret;





}



void getEntryDataTest_stress(p_cmd_t cmd, p_rsp_t rsp) {

    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0x01};

    uint8_t outData[2048] = {0,};

    uint8_t outRetryCnt = 0;

    get_data_param_t getParam;

    int ret = -1;

    uint32_t inputSize;



    memset(&getParam, 0, sizeof(get_data_param_t));

    getParam.entryId = entryid;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = outData;

    getParam.outDataLen = 48;

    getParam.outRemainRetryCnt = &outRetryCnt;



    LOGI("getEntryDataTest [start]");

    inputSize = cmd->dataLen;

    if( 0 != startService(cmd->data, inputSize, SEM_TID)) {

        LOGE("  getEntryDataTest opensession failed ");

        return ;

    }



    ret=getEntryData(&getParam);



    LOGD("getEntryDataTest Value :: %d", getParam.outDataLen);

    hex_print_tag_debug("getEntryDataTest Value :: ", getParam.outData, getParam.outDataLen);



    stopService();

    LOGI("getEntryDataTest [end]");

    rsp->ret = ret;

}



void deleteEntryTest_stress(p_cmd_t cmd, p_rsp_t rsp) {

    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0x01};

    uint8_t outRetryCnt[1] = {0};

    int ret = -1;

    uint32_t inputSize;



    delete_data_param_t deleteParam;

    memset(&deleteParam, 0, sizeof(delete_data_param_t));



    deleteParam.data_type = GED_DATA_TYPE_NORMAL;

    deleteParam.entryId = entryid;

    deleteParam.outRemainRetryCnt = outRetryCnt;

    deleteParam.auth_type = PED_AUTH_TYPE_NONE;



    LOGI("deleteEntryTest [start]");

    inputSize = cmd->dataLen;

    if( 0 != startService(cmd->data, inputSize, SEM_TID)) {

        LOGE("deleteEntryTest opensession failed ");

        return ;

    }



    LOGD("= = = == = = == = = == = = == = = =deleteEntryTest = = = == = = == = = == = = == = = =" );

    ret=deleteEntryData(&deleteParam);



    stopService();



    LOGI("deleteEntryTest [end] " );

    rsp->ret = ret;

}



void verifyStartSecureSession(p_cmd_t cmd, p_rsp_t rsp) {

    SSPSTATUS ret;

    const uint8_t semTID[16] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B };

    uint8_t blob[SSP_MAX_WRAPPED_OTP_KEY_SIZE] = {0,};



    LOGD("verifyStartSecureSession start");

    memcpy(blob, cmd->data, cmd->dataLen);

    hex_print_tag_debug("OTP_KEY_BLOB", blob, cmd->dataLen);



    ret = startService(blob, cmd->dataLen, semTID);

    if (ret == SSPSTATUS_SUCCESS) {

        rsp->ret = RET_SUCCESS;

    } else {

        rsp->ret = RET_ERR_TZ;

    }



    LOGD("verifyStartSecureSession end. %02X", rsp->ret);

}



void verifyStopSecureSession(p_rsp_t rsp) {

    LOGD("verifyStopSecureSession start");

    if (rsp == NULL) {

        LOGE("rsp is null");

        return;

    }



    if (SSPSTATUS_SUCCESS != stopService()) {

        rsp->ret = RET_ERR_TZ;

        goto error;

    }

    rsp->ret = RET_SUCCESS;

error:

    LOGD("verifyStopSecureSession end. %02X", rsp->ret);

}



void verifyDeleteDataAll(p_rsp_t rsp) {

    LOGD("verifyDeleteDataAll start");



    if (rsp == NULL) {

        LOGE("Invalid parameters");

        return;

    }



    if (SSPSTATUS_SUCCESS != deleteAllEntry()) {

        rsp->ret = RET_ERR_TZ;

        goto error;

    }

    rsp->ret = RET_SUCCESS;

error:

    LOGD("verifyDeleteDataAll end. %02X", rsp->ret);

}



void genEntryIdTest() {

    uint8_t input1[] = "NobleFidoAttestationEcc256Cert";

    uint8_t input2[] = "NobleScp03DmsdKvn#30";

    uint8_t input3[] = "NobleFidoAttestationRsa2048Cert";

    uint8_t input4[] = "NobleFidoAttestationEcc256";

    uint8_t input5[] = "NobleFidoAttestationRsa2048";

    uint8_t input6[] = "NobleFidoAttestationEcc256RoamingCert";

    uint8_t input7[] = "NobleFidoAttestationEcc256Roaming";



    uint8_t input8[] = "NobleFidoAttestationRsa2048AAID&Publickey";

    uint8_t input9[] = "NobleFidoAttestationEcc256Bound";

    uint8_t input10[] = "NobleFidoAttestationEcc256BoundCert";

    uint8_t input11[] = "NobleFidoAttestationEcc256BoundAAID&Publickey";

    uint8_t input12[] = "NobleFidoAttestationEcc256RoamingAAID&Publickey";



    uint8_t out1[4];

    uint8_t out2[4];

    uint8_t out3[4];

    uint8_t out4[4];

    uint8_t out5[4];

    uint8_t out6[4];

    uint8_t out7[4];



    uint8_t out8[4];

    uint8_t out9[4];

    uint8_t out10[4];

    uint8_t out11[4];

    uint8_t out12[4];



    ssp_genEntryID(input1, sizeof(input1), out1);

    LOGD("!  out1 : %02x%02x%02x%02x, src :: [%s]",out1[0],out1[1],out1[2],out1[3],(char*)input1);

    ssp_genEntryID(input2, sizeof(input2), out2);

    LOGD("!  out2 : %02x%02x%02x%02x, src :: [%s]",out2[0],out2[1],out2[2],out2[3],(char*)input2);

    ssp_genEntryID(input3, sizeof(input3), out3);

    LOGD("!  out3 : %02x%02x%02x%02x, src :: [%s]",out3[0],out3[1],out3[2],out3[3],(char*)input3);

    ssp_genEntryID(input4, sizeof(input4), out4);

    LOGD("!  out4 : %02x%02x%02x%02x, src :: [%s]",out4[0],out4[1],out4[2],out4[3],(char*)input4);

    ssp_genEntryID(input5, sizeof(input5), out5);

    LOGD("!  out5 : %02x%02x%02x%02x, src :: [%s]",out5[0],out5[1],out5[2],out5[3],(char*)input5);

    ssp_genEntryID(input6, sizeof(input6), out6);

    LOGD("!  out6 : %02x%02x%02x%02x, src :: [%s]",out6[0],out6[1],out6[2],out6[3],(char*)input6);

    ssp_genEntryID(input7, sizeof(input7), out7);

    LOGD("!  out7 : %02x%02x%02x%02x, src :: [%s]",out7[0],out7[1],out7[2],out7[3],(char*)input7);



    ssp_genEntryID(input8, sizeof(input8), out8);

    LOGD("!  out8 : %02x%02x%02x%02x, src :: [%s]",out8[0],out8[1],out8[2],out8[3],(char*)input8);

    ssp_genEntryID(input9, sizeof(input9), out9);

    LOGD("!  out9 : %02x%02x%02x%02x, src :: [%s]",out9[0],out9[1],out9[2],out9[3],(char*)input9);

    ssp_genEntryID(input10, sizeof(input10), out10);

    LOGD("!  out10 : %02x%02x%02x%02x, src :: [%s]",out10[0],out10[1],out10[2],out10[3],(char*)input10);

    ssp_genEntryID(input11, sizeof(input11), out11);

    LOGD("!  out11 : %02x%02x%02x%02x, src :: [%s]",out11[0],out11[1],out11[2],out11[3],(char*)input11);

    ssp_genEntryID(input12, sizeof(input12), out12);

    LOGD("!  out12 : %02x%02x%02x%02x, src :: [%s]",out12[0],out12[1],out12[2],out12[3],(char*)input12);

}





void putEntryDataTest(p_cmd_t cmd, p_rsp_t rsp) {

//    int i=0;

//    uint8_t outData[100] = {0,};



    put_data_param_t putParam;



    uint8_t outRemainRetryCnt = 0;



    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0xaa};

    uint8_t entrydata_512[512] =

        {0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9, \

        0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1};



    (void)rsp;



    memset(&putParam, 0, sizeof(put_data_param_t));





/*

    uint8_t kvn30[48] = { \

        0x4a,0x56,0x57,0x23,0xd3,0x53,0xc3,0xdf,0xc5,0x54,0xf8,0xce,0x1d,0x4c,0xca,0x8d \

        ,0x6c,0x1e,0xe7,0x9c,0x1c,0x40,0xae,0x94,0x0c,0x60,0x66,0x2e,0x86,0x1e,0xbc,0x61 \

        ,0xce,0xd7,0xee,0x11,0x58,0xe9,0xfd,0xcc,0x2b,0x52,0xd7,0x2b,0xa9,0xa4,0x61,0x1c};



    uint8_t kvn30_ot[48] = { \

        0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3 \

        ,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3 \

        ,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3,0xDC,0xC3 };



    uint8_t kvn30_otdummy[45] = { \

        0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03, \

        0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03, \

        0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03,0x01,0x02,0x03};

*/

    putParam.entryId = entryid;

    putParam.accessableTAID = (uint8_t*)SEM_TID;

    putParam.accessableTAIDLen= 16;

    putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA; //PED_ENTRY_EXISTS_N_PUT_DATA ;

    putParam.data_type = PED_DATA_TYPE_NORMAL;

    putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

    putParam.scope =  PED_SCOPE_PRIVATE;

    putParam.outRemainRetryCnt = &outRemainRetryCnt;

    putParam.delete_option = PED_DELETE_OPTION_DELETABLE;

    putParam.auth_type = PED_AUTH_TYPE_NONE;

    putParam.inData = entrydata_512;

    putParam.inDataLen = 512;



    LOGI("putEntryDataTest [start]");

    hex_print_tag_debug("[ TEST ] SEM_TID :: ", (uint8_t*)SEM_TID, SSP_TID_SIZE);

    hex_print_tag_debug("[ TEST ] putParam.accessableTAID :: ", putParam.accessableTAID, SSP_TID_SIZE);

    if( 0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("puttEntryDataTest opensession failed ");

        return ;

    }



    putEntryData(&putParam);



/*

    for(i=0 ; i < 3 ; i++) {

        LOGD("%d == == == == == == == == == == puttEntryDataTest :: puttEntryData == == == == == == == == == == ",i );

        putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA;

        putParam.entryId = fidoDefaultEntry[i];

        putParam.inData = fidoDefaultEntryData[i];

        putParam.inDataLen = 10;

        putEntryData(&putParam);

    }



    for(i=0; i< 3 ; i++) {

        LOGD("%d == == == == == == == == == == gettEntryDataTest :: gettEntryData == == == == == == == == == == ",i );

        getParam.entryId = fidoDefaultEntry[i];

        getParam.data_type = GED_DATA_TYPE_NORMAL;

        getParam.outData = outData;

        getParam.outDataLen = sizeof(outData);

        getParam.outRemainRetryCnt = &outRemainRetryCnt;

        getEntryData(&getParam);

        hex_print_tag_debug("[ TEST ] entry :: ", outData, getParam.outDataLen);

    }

*/

    stopService();

    LOGI("putEntryDataTest [END]");



}



void getEntryDataTest(p_cmd_t cmd, p_rsp_t rsp) {

#if 1 // NORMAL

    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0xaa};

    uint8_t outData[2048] = {0,};

    uint8_t outRetryCnt = 0;

    get_data_param_t getParam;



    (void)rsp;



    memset(&getParam, 0, sizeof(get_data_param_t));



    getParam.entryId = entryid;

    getParam.data_type = GED_DATA_TYPE_NORMAL;

    getParam.outData = outData;

    getParam.outDataLen = 512;

    getParam.outRemainRetryCnt = &outRetryCnt;



    LOGI("getEntryDataTest [start]");

    if( 0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("  getEntryDataTest opensession failed ");

        return ;

    }



    getEntryData(&getParam);



    LOGD("getEntryDataTest Value :: %d", getParam.outDataLen);

    hex_print_tag_debug("getEntryDataTest Value :: ", getParam.outData, getParam.outDataLen);



    stopService();

    LOGI("getEntryDataTest [end]");



#else // OPEN SESSION WITH COMMAND

    uint8_t channelId = 0;

    ESESTATUS ese_status = ESESTATUS_OK;

    SSPSTATUS ssp_status = SSPSTATUS_SUCCESS;

    uint32_t sessionId = 0;

    uint8_t getKVN30Apdu[] = {0x80, 0xCA, 0x00, 0x00, 0x08, 0xE0, 0x06, 0xE2, 0x04, 0x00, 0x00, 0x00, 0xaa};

    secEse_7816_rpdu_t response;

    uint8_t r_data[MAX_RAPDU_DATA_SIZE] = {0,};

    uint8_t otp_key_blob[SSP_ENCRYPTED_OTP_KEY_SIZE] = {0,};



    get_data_param_t getParam;

    memset(&getParam, 0, sizeof(get_data_param_t));



    memset(&response, 0, sizeof(response));

    response.pdata= r_data;



    memcpy(otp_key_blob, cmd->data, SSP_ENCRYPTED_OTP_KEY_SIZE);

    hex_print_tag_debug("** OTP KEY ENCRYPTED **", otp_key_blob, SSP_ENCRYPTED_OTP_KEY_SIZE);

    ese_status = secEseOpen(&channelId);



    if (ese_status != ESESTATUS_OK) {

        LOGE("Failed to secEseOpen");

        rsp->ret = RET_ERR_TZ;

        goto error;

    }

    LOGD("channelId : %u", channelId);



    ese_status = secEseSelect(channelId, (uint8_t*)SSE_AID, 0, 16, &response);

    if (ese_status != ESESTATUS_OK || response.sw1 != 0x90 || response.sw2 !=0x00) {

        LOGE("Failed to [SELECT SSE]");

        rsp->ret = RET_ERR_TZ;

        goto error;

    }



    LOGD("####################################################################### ");

    ssp_status = ssp_openSession_with_command(&sessionId, channelId, otp_key_blob, SEM_TID, SSE_AID, 16, getKVN30Apdu, sizeof(getKVN30Apdu), &response);

    if (ssp_status == SSPSTATUS_SUCCESS) {

        hex_print_tag_debug("OPEN SESSION WITH COMMAND SUCCESS ::", response.pdata, response.len);

        LOGD("OPEN SESSION WITH COMMAND SUCCESS :: %d",response.len);

        rsp->ret = RET_SUCCESS;

    } else {

        LOGD("OPEN SESSION WITH COMMAND FAILURE ");

        rsp->ret = RET_ERR_TZ;

    }



    ssp_closeSession(sessionId);

error:

    secEseClose(channelId);

#endif

}



void updateAuthTest(p_cmd_t cmd, p_rsp_t rsp) {

    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0xaa};

//    uint8_t oldpassword[6] = {1,1,1,1,1,1};

    uint8_t newpassword[6] = {1,1,1,1,1,1};

    update_auth_param_t uaParam;



    (void)rsp;



    LOGI("updateAuthTest [start]");



    memset(&uaParam, 0, sizeof(update_auth_param_t));

    uaParam.ua_command = UA_APPLY_NEW_AUTH;

    uaParam.entryId = entryid;



    uaParam.old_data_type = UA_DATA_TYPE_NORMAL;

    uaParam.old_auth_type = UA_AUTH_TYPE_NONE;

//    uaParam.old_password = oldpassword;

//    uaParam.old_passwordLen = 6;



    uaParam.new_data_type = UA_DATA_TYPE_NORMAL;

    uaParam.new_auth_type = UA_AUTH_TYPE_PASSWD;

    uaParam.new_password = newpassword;

    uaParam.new_passwordLen = 6;



    uaParam.new_iterationCounter1 = 5;

    uaParam.new_retryCounter = 7;



    if( 0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("updateAuthTest opensession failed ");

        return ;

    }

    LOGD("= = = == = = == = = == = = == = = =updateAuthTest = = = == = = == = = == = = == = = =" );



    updateAuth(&uaParam);



    stopService();

    LOGI("updateAuthTest [end] " );

}



void deleteEntryTest(p_cmd_t cmd, p_rsp_t rsp) {

    uint8_t entryid[4] = { 0x00, 0x00, 0x00, 0xaa};

    uint8_t outRetryCnt[1] = {0};

    uint8_t newpassword[6] = {1,1,1,1,1,1};



    delete_data_param_t deleteParam;

    memset(&deleteParam, 0, sizeof(delete_data_param_t));



    deleteParam.data_type = GED_DATA_TYPE_NORMAL;

    deleteParam.entryId = entryid;

    deleteParam.outRemainRetryCnt = outRetryCnt;

    deleteParam.auth_type = GED_AUTH_TYPE_PASSWD;

    deleteParam.password = newpassword;

    deleteParam.passwordLen = 6;



    (void)rsp;



    LOGI("deleteEntryTest [start]");



    if( 0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("deleteEntryTest opensession failed ");

        return ;

    }



    LOGD("= = = == = = == = = == = = == = = =deleteEntryTest = = = == = = == = = == = = == = = =" );

    deleteEntryData(&deleteParam);



    stopService();



    LOGI("deleteEntryTest [end] " );



}



void deleteAllTest(p_cmd_t cmd, p_rsp_t rsp) {

    (void)rsp;



    LOGD("deleteAllTest [start]");



    if (  0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("deleteAllTest opensession failed ");

        return ;

    }

    LOGD("= = = == = = == = = == = = == = = =deleteEntryTest = = = == = = == = = == = = == = = =" );

    deleteAllEntry();



    stopService();

    LOGI("deleteEntryTest [end] " );

}



void getDefaultEntryTest(p_cmd_t cmd, p_rsp_t rsp) {

    SSESTATUS sseRet = 0;

    int index = 0, get_entries_cnt = 0;

    get_data_param_t getParam;



    uint8_t default_entries[10][4] = {

        {0xAB, 0xF3, 0x63, 0x6E},

        {0x19, 0x56, 0x77, 0x7E}, {0x89, 0x16, 0x03, 0x33}, {0x12, 0x5b, 0x12, 0x19},

        {0xcb, 0x1b, 0x4c, 0x10}, {0x57, 0x4b, 0x4c, 0x4b}, {0xa1, 0x41, 0x96, 0x8c},

        {0xA2, 0x8F, 0xE2, 0x4B}, {0x55, 0x10, 0x28, 0xA2}, {0x51, 0xd0, 0x54, 0x2f}};

    uint8_t get_default_entries_result[10] = {0, };



    (void)rsp;



    LOGD("getDefaultEntryTest [start]");

    if ( 0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("deleteAllTest opensession failed ");

        return ;

    }



    memset(&getParam, 0, sizeof(get_data_param_t));

    for (index = 0 ; index < 10 ; index++) {

        uint8_t outData[1200] = {0,};

        uint8_t outRetryCnt = 0;



        getParam.entryId = default_entries[index];

        getParam.data_type = GED_DATA_TYPE_NORMAL;

        getParam.outData = outData;

        getParam.outDataLen = sizeof(outData);

        getParam.outRemainRetryCnt = &outRetryCnt;



        sseRet = getEntryData(&getParam);

        if (sseRet != SSESTATUS_OK) {

            LOGE("FAILED to get default entry index [%d]", index);

            get_default_entries_result[index] = 0;

        } else {

            LOGI("SUCCESS to get default entry index [%d]", index);

            get_default_entries_result[index] = 1;

            get_entries_cnt++;

            hex_print_tag_debug("outData", getParam.outData, getParam.outDataLen);

        }

    }

    stopService();



    LOGD("Default entry state :");

    LOGD("KVN30 : %d", get_default_entries_result[0]);

    LOGD("SK.RSA2048  : %d, CERT.RSA2048  : %d, AAID&PUB RSA2048  : %d", get_default_entries_result[1], get_default_entries_result[2], get_default_entries_result[3]);

    LOGD("SK_1.ECC256 : %d, CERT_1.ECC256 : %d, AAID&PUB_1 ECC256 : %d", get_default_entries_result[4], get_default_entries_result[5], get_default_entries_result[6]);

    LOGD("SK_2.ECC256 : %d, CERT_2.ECC256 : %d, AAID&PUB_2 ECC256 : %d", get_default_entries_result[7], get_default_entries_result[8], get_default_entries_result[9]);

    LOGD("getDefaultEntryTest [end] : get entry count : %d", get_entries_cnt);

}



void putDefaultEntryTest(p_cmd_t cmd) {

    unsigned char rsa_c301_priv[] = {

        0x99, 0x0A, 0x70, 0x8B, 0x25, 0x64, 0x9F, 0x7A, 0xC9, 0x1C, 0xF8, 0xD5, 0x20, 0x53, 0xFB, 0x00,

        0x23, 0x2F, 0x7D, 0x5B, 0xFE, 0xAE, 0x43, 0x74, 0x29, 0xBE, 0x95, 0x4D, 0xF4, 0x90, 0xBB, 0x1A,

        0x69, 0x4C, 0xE1, 0x47, 0x4F, 0x4C, 0xA7, 0xD9, 0x3A, 0x73, 0xF1, 0x14, 0xFC, 0xAD, 0x2A, 0x3E,

        0x50, 0x21, 0x78, 0x5D, 0x7B, 0x50, 0x32, 0xB1, 0x48, 0x16, 0xC7, 0x8C, 0x51, 0xCF, 0x84, 0x85,

        0x16, 0x74, 0xD0, 0x72, 0xEA, 0x70, 0xFF, 0x63, 0xE6, 0x81, 0x4A, 0xD3, 0xC2, 0x6C, 0x78, 0x8A,

        0x85, 0x00, 0x83, 0x53, 0xAF, 0xA3, 0x6B, 0xEE, 0xD8, 0xA8, 0xE1, 0xEB, 0x10, 0xD2, 0x66, 0x0A,

        0x37, 0xE9, 0x4C, 0xDB, 0xC2, 0x03, 0xCF, 0xF2, 0x82, 0x73, 0xF6, 0xD6, 0xD5, 0xB9, 0x38, 0x77,

        0x3B, 0xE8, 0xDE, 0xF2, 0xAA, 0x10, 0x45, 0x39, 0x4B, 0xDC, 0xAE, 0x15, 0xCF, 0x15, 0x82, 0xC4,

        0x1E, 0x51, 0xC5, 0xA7, 0xFD, 0x1C, 0x41, 0x74, 0x21, 0x06, 0x87, 0xCE, 0x50, 0xD4, 0xB7, 0x60,

        0xAE, 0x0B, 0x64, 0x04, 0xB8, 0x6A, 0x00, 0xAA, 0x1D, 0x23, 0x81, 0xAF, 0x01, 0x60, 0xDD, 0x63,

        0x90, 0x57, 0xF2, 0x10, 0x08, 0x26, 0x5E, 0x97, 0x6F, 0xDB, 0xFD, 0x2B, 0x94, 0x35, 0x89, 0xC1,

        0xDC, 0x36, 0xDD, 0x98, 0x1A, 0x21, 0xF1, 0xA8, 0x8F, 0xE8, 0xCB, 0x8C, 0x83, 0xA3, 0x5E, 0xC9,

        0x40, 0x21, 0x3C, 0x27, 0x06, 0x40, 0xBA, 0xF2, 0x98, 0xCA, 0xDB, 0xAB, 0x05, 0x82, 0xEA, 0x00,

        0x5F, 0xAB, 0x89, 0x39, 0xF9, 0x65, 0xBB, 0x65, 0xC2, 0x6B, 0x02, 0x75, 0x14, 0x2F, 0x81, 0x73,

        0x34, 0x0E, 0xA9, 0xE0, 0x30, 0x1C, 0x4A, 0x91, 0x16, 0x20, 0x88, 0x91, 0xEA, 0x78, 0x70, 0x19,

        0x90, 0xBD, 0xA0, 0xFA, 0x4D, 0x67, 0xB6, 0x7B, 0xFA, 0x04, 0xF0, 0x96, 0x3E, 0x5B, 0x74, 0x6D,

        0x59, 0x57, 0x79, 0xDA, 0x11, 0x6B, 0x4B, 0x9A, 0xCF, 0x9B, 0x65, 0x3C, 0x6E, 0x51, 0xF8, 0x7E,

        0xDD, 0x0B, 0x95, 0x40, 0x46, 0x4E, 0x8F, 0x3C, 0x5A, 0x3E, 0x53, 0x45, 0x1E, 0x17, 0xFB, 0xD2,

        0x70, 0x54, 0x9C, 0x53, 0x17, 0xDD, 0x25, 0x43, 0xB0, 0x57, 0x0D, 0x0F, 0x76, 0x6E, 0xD4, 0xF1,

        0x69, 0xB0, 0x10, 0x67, 0x6A, 0x5C, 0xA8, 0x2B, 0x4C, 0x6D, 0x57, 0xF2, 0xF7, 0xB3, 0x90, 0xA6,

        0x6D, 0x34, 0xA6, 0x97, 0xDF, 0x7B, 0x35, 0xEC, 0xA9, 0x1D, 0x23, 0x84, 0xB9, 0xC4, 0xBF, 0x1E,

        0x06, 0x85, 0x05, 0x25, 0xAE, 0xAC, 0x55, 0x8F, 0x2A, 0xD6, 0x74, 0x84, 0xD8, 0xDE, 0x2B, 0x09,

        0x9E, 0x18, 0x49, 0x71, 0x25, 0x33, 0x3A, 0x8B, 0x55, 0x52, 0xC3, 0x70, 0x29, 0x76, 0xA6, 0x9B,

        0x1C, 0xD3, 0x56, 0x8C, 0x0D, 0x71, 0xD0, 0x27, 0xA1, 0xBC, 0xE3, 0xB8, 0x01, 0x9B, 0x8A, 0x29,

        0x72, 0x71, 0x7E, 0xCB, 0xB9, 0xAA, 0xF0, 0x55, 0x88, 0x49, 0x00, 0x24, 0x00, 0x84, 0x7D, 0x43,

        0x4A, 0x36, 0xD5, 0x49, 0xB6, 0x45, 0x5A, 0xD9, 0xE2, 0xFD, 0x10, 0xEA, 0x05, 0x06, 0x19, 0x9B,

        0x8E, 0xFA, 0x75, 0x50, 0x68, 0x4C, 0x69, 0x22, 0x02, 0x06, 0x86, 0x2E, 0x06, 0x5B, 0x09, 0xA2,

        0x0A, 0x05, 0x55, 0x60, 0x3D, 0xA5, 0x07, 0xFA, 0xD3, 0x43, 0x30, 0x89, 0x18, 0x6B, 0x0E, 0x3E,

        0x05, 0x59, 0x95, 0xFF, 0x18, 0x64, 0xC6, 0x2C, 0xD5, 0x5B, 0x97, 0xED, 0xEE, 0x15, 0x03, 0x01,

        0x8F, 0x7A, 0x9C, 0x40, 0x8E, 0x2D, 0xB8, 0x62, 0x7F, 0x60, 0x3E, 0x5E, 0x60, 0xEB, 0xD3, 0x4A,

        0xA9, 0x09, 0xC3, 0xA1, 0x80, 0xAF, 0x08, 0x0A, 0xD4, 0xFD, 0x05, 0x6F, 0xCF, 0xE1, 0x4A, 0x7E,

        0x1C, 0x4F, 0xEB, 0xEF, 0xDE, 0x93, 0x46, 0x38, 0xA1, 0xB1, 0x2C, 0x8F, 0x60, 0x90, 0x98, 0x35};

    unsigned char rsa_c301_cert[] = {

        0x30, 0x82, 0x04, 0x83, 0x30, 0x82, 0x03, 0x6B, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,

        0xDA, 0xCA, 0xFE, 0x51, 0xE2, 0xD5, 0x12, 0x96, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86,

        0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x05, 0x00, 0x30, 0x59, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55,

        0x04, 0x06, 0x13, 0x02, 0x4B, 0x52, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13,

        0x0A, 0x53, 0x75, 0x77, 0x6F, 0x6E, 0x20, 0x63, 0x69, 0x74, 0x79, 0x31, 0x17, 0x30, 0x15, 0x06,

        0x03, 0x55, 0x04, 0x0B, 0x13, 0x0E, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x4D, 0x6F,

        0x62, 0x69, 0x6C, 0x65, 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x13, 0x53,

        0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x63, 0x6F, 0x72, 0x70, 0x6F, 0x72, 0x61, 0x74, 0x69,

        0x6F, 0x6E, 0x30, 0x1E, 0x17, 0x0D, 0x31, 0x35, 0x30, 0x38, 0x31, 0x30, 0x30, 0x38, 0x34, 0x36,

        0x32, 0x32, 0x5A, 0x17, 0x0D, 0x33, 0x35, 0x30, 0x38, 0x30, 0x35, 0x30, 0x38, 0x34, 0x36, 0x32,

        0x32, 0x5A, 0x30, 0x81, 0xC3, 0x31, 0x2F, 0x30, 0x2D, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0C, 0x26,

        0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63, 0x74, 0x72, 0x6F, 0x6E,

        0x69, 0x63, 0x73, 0x20, 0x41, 0x54, 0x54, 0x2F, 0x41, 0x41, 0x49, 0x44, 0x3D, 0x35, 0x33, 0x45,

        0x43, 0x23, 0x43, 0x33, 0x30, 0x31, 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13,

        0x13, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63, 0x74, 0x72, 0x6F,

        0x6E, 0x69, 0x63, 0x73, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x0E, 0x53,

        0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C, 0x65, 0x31, 0x13, 0x30,

        0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0A, 0x53, 0x75, 0x77, 0x6F, 0x6E, 0x20, 0x63, 0x69,

        0x74, 0x79, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x4B, 0x52, 0x31,

        0x37, 0x30, 0x35, 0x06, 0x0A, 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x01, 0x13,

        0x27, 0x45, 0x4E, 0x47, 0x3A, 0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x31, 0x30, 0x3A, 0x30, 0x31,

        0x3A, 0x46, 0x46, 0x3A, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x3A, 0x46, 0x49, 0x44,

        0x4F, 0x3A, 0x46, 0x50, 0x3A, 0x52, 0x53, 0x41, 0x30, 0x82, 0x01, 0x22, 0x30, 0x0D, 0x06, 0x09,

        0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0F, 0x00,

        0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0x99, 0x0A, 0x70, 0x8B, 0x25, 0x64, 0x9F,

        0x7A, 0xC9, 0x1C, 0xF8, 0xD5, 0x20, 0x53, 0xFB, 0x00, 0x23, 0x2F, 0x7D, 0x5B, 0xFE, 0xAE, 0x43,

        0x74, 0x29, 0xBE, 0x95, 0x4D, 0xF4, 0x90, 0xBB, 0x1A, 0x69, 0x4C, 0xE1, 0x47, 0x4F, 0x4C, 0xA7,

        0xD9, 0x3A, 0x73, 0xF1, 0x14, 0xFC, 0xAD, 0x2A, 0x3E, 0x50, 0x21, 0x78, 0x5D, 0x7B, 0x50, 0x32,

        0xB1, 0x48, 0x16, 0xC7, 0x8C, 0x51, 0xCF, 0x84, 0x85, 0x16, 0x74, 0xD0, 0x72, 0xEA, 0x70, 0xFF,

        0x63, 0xE6, 0x81, 0x4A, 0xD3, 0xC2, 0x6C, 0x78, 0x8A, 0x85, 0x00, 0x83, 0x53, 0xAF, 0xA3, 0x6B,

        0xEE, 0xD8, 0xA8, 0xE1, 0xEB, 0x10, 0xD2, 0x66, 0x0A, 0x37, 0xE9, 0x4C, 0xDB, 0xC2, 0x03, 0xCF,

        0xF2, 0x82, 0x73, 0xF6, 0xD6, 0xD5, 0xB9, 0x38, 0x77, 0x3B, 0xE8, 0xDE, 0xF2, 0xAA, 0x10, 0x45,

        0x39, 0x4B, 0xDC, 0xAE, 0x15, 0xCF, 0x15, 0x82, 0xC4, 0x1E, 0x51, 0xC5, 0xA7, 0xFD, 0x1C, 0x41,

        0x74, 0x21, 0x06, 0x87, 0xCE, 0x50, 0xD4, 0xB7, 0x60, 0xAE, 0x0B, 0x64, 0x04, 0xB8, 0x6A, 0x00,

        0xAA, 0x1D, 0x23, 0x81, 0xAF, 0x01, 0x60, 0xDD, 0x63, 0x90, 0x57, 0xF2, 0x10, 0x08, 0x26, 0x5E,

        0x97, 0x6F, 0xDB, 0xFD, 0x2B, 0x94, 0x35, 0x89, 0xC1, 0xDC, 0x36, 0xDD, 0x98, 0x1A, 0x21, 0xF1,

        0xA8, 0x8F, 0xE8, 0xCB, 0x8C, 0x83, 0xA3, 0x5E, 0xC9, 0x40, 0x21, 0x3C, 0x27, 0x06, 0x40, 0xBA,

        0xF2, 0x98, 0xCA, 0xDB, 0xAB, 0x05, 0x82, 0xEA, 0x00, 0x5F, 0xAB, 0x89, 0x39, 0xF9, 0x65, 0xBB,

        0x65, 0xC2, 0x6B, 0x02, 0x75, 0x14, 0x2F, 0x81, 0x73, 0x34, 0x0E, 0xA9, 0xE0, 0x30, 0x1C, 0x4A,

        0x91, 0x16, 0x20, 0x88, 0x91, 0xEA, 0x78, 0x70, 0x19, 0x90, 0xBD, 0xA0, 0xFA, 0x4D, 0x67, 0xB6,

        0x7B, 0xFA, 0x04, 0xF0, 0x96, 0x3E, 0x5B, 0x74, 0x6D, 0x02, 0x03, 0x01, 0x00, 0x01, 0xA3, 0x81,

        0xE2, 0x30, 0x81, 0xDF, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04, 0x14, 0x30,

        0x84, 0x66, 0x76, 0xA7, 0xA8, 0xA2, 0x08, 0x12, 0xB7, 0xCC, 0x3D, 0x55, 0xA6, 0x1D, 0x09, 0x42,

        0x09, 0x37, 0x40, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14,

        0x1A, 0x38, 0x49, 0x59, 0x2E, 0x32, 0x21, 0x82, 0x0C, 0x77, 0x26, 0x0D, 0xCA, 0x11, 0xAD, 0xDD,

        0x9C, 0xCA, 0x43, 0x7D, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, 0xFF, 0x04, 0x04,

        0x03, 0x02, 0x06, 0xC0, 0x30, 0x3D, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x36, 0x30, 0x34, 0x30,

        0x32, 0xA0, 0x30, 0xA0, 0x2E, 0x86, 0x2C, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x72,

        0x6C, 0x2E, 0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x73, 0x65,

        0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2F, 0x72, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x2E,

        0x63, 0x72, 0x6C, 0x30, 0x0F, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04, 0x05, 0x30,

        0x03, 0x02, 0x01, 0x00, 0x30, 0x3D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x01, 0x01,

        0x04, 0x31, 0x30, 0x2F, 0x30, 0x2D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01,

        0x86, 0x21, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6F, 0x63, 0x73, 0x70, 0x2E, 0x73, 0x61,

        0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x73, 0x65, 0x63, 0x75, 0x72, 0x69,

        0x74, 0x79, 0x2F, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B,

        0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00, 0x4F, 0x11, 0x6D, 0x9A, 0xDD, 0x7A, 0x0A, 0x2C, 0x6F,

        0x93, 0x72, 0x29, 0x84, 0xAC, 0xB2, 0xE9, 0x43, 0xC2, 0xC2, 0x0A, 0x69, 0xB3, 0xFD, 0x90, 0xE9,

        0x98, 0x24, 0xA4, 0xA3, 0x5A, 0xEC, 0x4D, 0xA7, 0x08, 0x56, 0x21, 0x01, 0x80, 0x58, 0x4B, 0x30,

        0xF2, 0xFD, 0x0A, 0xCC, 0xF0, 0xA2, 0xE4, 0xF2, 0x76, 0x9F, 0x6A, 0x8D, 0x25, 0x1C, 0xBD, 0x05,

        0x1D, 0xFD, 0xFD, 0x57, 0xC3, 0x1A, 0x04, 0xFC, 0x66, 0x04, 0x0F, 0x8C, 0xFA, 0x20, 0x47, 0x3A,

        0xA9, 0xB6, 0x31, 0x77, 0x5D, 0x22, 0x61, 0xC9, 0x46, 0x6C, 0x1B, 0x33, 0x2F, 0xD9, 0x1A, 0xEB,

        0x0A, 0x07, 0x8D, 0xEB, 0x53, 0xAD, 0xCC, 0x80, 0x22, 0x77, 0xCD, 0xBF, 0xB7, 0x44, 0xC9, 0x76,

        0x22, 0xCC, 0x63, 0x25, 0x4F, 0x92, 0x88, 0x4C, 0x89, 0x44, 0x64, 0xC5, 0x6F, 0x41, 0x93, 0x0D,

        0xF5, 0xBC, 0xD7, 0x4D, 0x11, 0x97, 0x6B, 0x59, 0xE5, 0x03, 0xA5, 0x75, 0xD4, 0xB6, 0x94, 0x89,

        0x45, 0x87, 0xA9, 0xA9, 0x64, 0x3F, 0xFD, 0xF3, 0xCD, 0x6A, 0xBE, 0x8F, 0x53, 0x1A, 0x09, 0x1C,

        0x46, 0x67, 0xDC, 0x85, 0x3A, 0xB3, 0x77, 0xF0, 0x8A, 0x53, 0x06, 0x00, 0x84, 0xB0, 0xF0, 0xA6,

        0xF9, 0x9E, 0x46, 0xB2, 0x17, 0x8B, 0x9A, 0xDF, 0x60, 0xFC, 0x51, 0xEC, 0xDD, 0x10, 0x61, 0x1D,

        0xF7, 0x94, 0x6C, 0xB4, 0x7B, 0x35, 0x21, 0x08, 0x89, 0xF7, 0x49, 0x6A, 0x7F, 0xD4, 0x8C, 0xE7,

        0xC0, 0x88, 0x98, 0xE1, 0x1B, 0xCB, 0xA8, 0xA5, 0x01, 0xBA, 0x2B, 0x77, 0xEE, 0x2B, 0x28, 0x03,

        0xB5, 0xD0, 0xC7, 0x0C, 0x5F, 0x95, 0xD2, 0xCC, 0x25, 0xA9, 0x88, 0x2E, 0xA7, 0xFC, 0x08, 0xFC,

        0x90, 0x27, 0x40, 0x6D, 0x46, 0x27, 0xB9, 0xFA, 0x16, 0x09, 0x04, 0xDB, 0xAD, 0x5A, 0x44, 0x3A,

        0x64, 0x25, 0xB4, 0xDB, 0xFE, 0x09, 0xFD};

    unsigned char rsa_c301_aaid_pub[] = {

        0x35, 0x33, 0x45, 0x43, 0x23, 0x43, 0x33, 0x30, 0x31,

        0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0x99, 0x0A, 0x70, 0x8B, 0x25, 0x64, 0x9F,

        0x7A, 0xC9, 0x1C, 0xF8, 0xD5, 0x20, 0x53, 0xFB, 0x00, 0x23, 0x2F, 0x7D, 0x5B, 0xFE, 0xAE, 0x43,

        0x74, 0x29, 0xBE, 0x95, 0x4D, 0xF4, 0x90, 0xBB, 0x1A, 0x69, 0x4C, 0xE1, 0x47, 0x4F, 0x4C, 0xA7,

        0xD9, 0x3A, 0x73, 0xF1, 0x14, 0xFC, 0xAD, 0x2A, 0x3E, 0x50, 0x21, 0x78, 0x5D, 0x7B, 0x50, 0x32,

        0xB1, 0x48, 0x16, 0xC7, 0x8C, 0x51, 0xCF, 0x84, 0x85, 0x16, 0x74, 0xD0, 0x72, 0xEA, 0x70, 0xFF,

        0x63, 0xE6, 0x81, 0x4A, 0xD3, 0xC2, 0x6C, 0x78, 0x8A, 0x85, 0x00, 0x83, 0x53, 0xAF, 0xA3, 0x6B,

        0xEE, 0xD8, 0xA8, 0xE1, 0xEB, 0x10, 0xD2, 0x66, 0x0A, 0x37, 0xE9, 0x4C, 0xDB, 0xC2, 0x03, 0xCF,

        0xF2, 0x82, 0x73, 0xF6, 0xD6, 0xD5, 0xB9, 0x38, 0x77, 0x3B, 0xE8, 0xDE, 0xF2, 0xAA, 0x10, 0x45,

        0x39, 0x4B, 0xDC, 0xAE, 0x15, 0xCF, 0x15, 0x82, 0xC4, 0x1E, 0x51, 0xC5, 0xA7, 0xFD, 0x1C, 0x41,

        0x74, 0x21, 0x06, 0x87, 0xCE, 0x50, 0xD4, 0xB7, 0x60, 0xAE, 0x0B, 0x64, 0x04, 0xB8, 0x6A, 0x00,

        0xAA, 0x1D, 0x23, 0x81, 0xAF, 0x01, 0x60, 0xDD, 0x63, 0x90, 0x57, 0xF2, 0x10, 0x08, 0x26, 0x5E,

        0x97, 0x6F, 0xDB, 0xFD, 0x2B, 0x94, 0x35, 0x89, 0xC1, 0xDC, 0x36, 0xDD, 0x98, 0x1A, 0x21, 0xF1,

        0xA8, 0x8F, 0xE8, 0xCB, 0x8C, 0x83, 0xA3, 0x5E, 0xC9, 0x40, 0x21, 0x3C, 0x27, 0x06, 0x40, 0xBA,

        0xF2, 0x98, 0xCA, 0xDB, 0xAB, 0x05, 0x82, 0xEA, 0x00, 0x5F, 0xAB, 0x89, 0x39, 0xF9, 0x65, 0xBB,

        0x65, 0xC2, 0x6B, 0x02, 0x75, 0x14, 0x2F, 0x81, 0x73, 0x34, 0x0E, 0xA9, 0xE0, 0x30, 0x1C, 0x4A,

        0x91, 0x16, 0x20, 0x88, 0x91, 0xEA, 0x78, 0x70, 0x19, 0x90, 0xBD, 0xA0, 0xFA, 0x4D, 0x67, 0xB6,

        0x7B, 0xFA, 0x04, 0xF0, 0x96, 0x3E, 0x5B, 0x74, 0x6D, 0x02, 0x03, 0x01, 0x00, 0x01};



    unsigned char ecc_c301_priv[] = {

        0xd5, 0x2d, 0x47, 0xbd, 0xf7, 0x1d, 0x5c, 0x70, 0xee, 0x48, 0xd6, 0x28, 0xc4, 0xd3, 0xee, 0x76,

        0xb4, 0x2b, 0x47, 0x02, 0xfd, 0xca, 0xb3, 0xde, 0xb2, 0xfc, 0x83, 0xd4, 0xe1, 0xc7, 0x07, 0x5a};

    unsigned char ecc_c301_cert[] = {

        0x30, 0x82, 0x03, 0x48, 0x30, 0x82, 0x02, 0xED, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,

        0xBE, 0x7C, 0xF1, 0xD0, 0xEB, 0xB6, 0x61, 0x9E, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE,

        0x3D, 0x04, 0x03, 0x02, 0x05, 0x00, 0x30, 0x81, 0xA6, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55,

        0x04, 0x03, 0x13, 0x16, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63,

        0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63, 0x73, 0x20, 0x43, 0x41, 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03,

        0x55, 0x04, 0x0A, 0x13, 0x13, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65,

        0x63, 0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63, 0x73, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04,

        0x0B, 0x13, 0x0E, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C,

        0x65, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0A, 0x53, 0x75, 0x77, 0x6F,

        0x6E, 0x20, 0x63, 0x69, 0x74, 0x79, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,

        0x02, 0x4B, 0x52, 0x31, 0x2A, 0x30, 0x28, 0x06, 0x0A, 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C,

        0x64, 0x01, 0x01, 0x0C, 0x1A, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x44, 0x65, 0x76, 0x69,

        0x63, 0x65, 0x52, 0x6F, 0x6F, 0x74, 0x43, 0x41, 0x4B, 0x65, 0x79, 0x5F, 0x45, 0x43, 0x43, 0x30,

        0x1E, 0x17, 0x0D, 0x31, 0x35, 0x30, 0x38, 0x31, 0x30, 0x30, 0x38, 0x34, 0x35, 0x34, 0x37, 0x5A,

        0x17, 0x0D, 0x33, 0x35, 0x30, 0x38, 0x30, 0x35, 0x30, 0x38, 0x34, 0x35, 0x34, 0x37, 0x5A, 0x30,

        0x81, 0xC3, 0x31, 0x2F, 0x30, 0x2D, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0C, 0x26, 0x53, 0x61, 0x6D,

        0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63, 0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63, 0x73,

        0x20, 0x41, 0x54, 0x54, 0x2F, 0x41, 0x41, 0x49, 0x44, 0x3D, 0x35, 0x33, 0x45, 0x43, 0x23, 0x43,

        0x33, 0x30, 0x31, 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x13, 0x53, 0x61,

        0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63, 0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63,

        0x73, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x0E, 0x53, 0x61, 0x6D, 0x73,

        0x75, 0x6E, 0x67, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C, 0x65, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,

        0x55, 0x04, 0x07, 0x13, 0x0A, 0x53, 0x75, 0x77, 0x6F, 0x6E, 0x20, 0x63, 0x69, 0x74, 0x79, 0x31,

        0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x4B, 0x52, 0x31, 0x37, 0x30, 0x35,

        0x06, 0x0A, 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x01, 0x13, 0x27, 0x45, 0x4E,

        0x47, 0x3A, 0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x31, 0x30, 0x3A, 0x30, 0x31, 0x3A, 0x46, 0x46,

        0x3A, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x3A, 0x46, 0x49, 0x44, 0x4F, 0x3A, 0x46,

        0x50, 0x3A, 0x45, 0x43, 0x43, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D,

        0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04,

        0xB9, 0xA4, 0x2A, 0x65, 0xD6, 0xD2, 0x36, 0xE3, 0x65, 0x83, 0x1C, 0xCD, 0x0D, 0xDA, 0x4C, 0x9E,

        0xE9, 0xE7, 0xEF, 0xD0, 0x0E, 0x13, 0xA7, 0x13, 0xEA, 0x04, 0xD0, 0xB4, 0xFB, 0x0E, 0x24, 0x85,

        0x6D, 0x81, 0x0C, 0x06, 0xFD, 0xA4, 0xD8, 0xC2, 0xB9, 0xE5, 0x42, 0x83, 0x02, 0xF7, 0x77, 0xDE,

        0x20, 0x13, 0x68, 0xA7, 0x3A, 0x42, 0x39, 0x56, 0x82, 0x7B, 0x14, 0xF5, 0x23, 0x55, 0xA0, 0x0E,

        0xA3, 0x81, 0xE2, 0x30, 0x81, 0xDF, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04,

        0x14, 0x42, 0x4D, 0xCA, 0x52, 0xC3, 0xBF, 0x37, 0x45, 0x8B, 0x3C, 0xB0, 0x09, 0x32, 0xD1, 0xC5,

        0x21, 0xE5, 0xD4, 0x03, 0xCA, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16,

        0x80, 0x14, 0xB2, 0x99, 0x73, 0x6B, 0xB7, 0x67, 0x31, 0x2C, 0x93, 0x74, 0x78, 0xA9, 0x24, 0xA9,

        0x37, 0x3C, 0x63, 0x90, 0x46, 0x41, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, 0xFF,

        0x04, 0x04, 0x03, 0x02, 0x06, 0xC0, 0x30, 0x3D, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x36, 0x30,

        0x34, 0x30, 0x32, 0xA0, 0x30, 0xA0, 0x2E, 0x86, 0x2C, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F,

        0x63, 0x72, 0x6C, 0x2E, 0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x63, 0x6F, 0x6D, 0x2F,

        0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2F, 0x72, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,

        0x73, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x0F, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04,

        0x05, 0x30, 0x03, 0x02, 0x01, 0x00, 0x30, 0x3D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07,

        0x01, 0x01, 0x04, 0x31, 0x30, 0x2F, 0x30, 0x2D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07,

        0x30, 0x01, 0x86, 0x21, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6F, 0x63, 0x73, 0x70, 0x2E,

        0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x73, 0x65, 0x63, 0x75,

        0x72, 0x69, 0x74, 0x79, 0x2F, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03,

        0x02, 0x05, 0x00, 0x03, 0x47, 0x00, 0x30, 0x44, 0x02, 0x20, 0x08, 0xE2, 0xCF, 0x49, 0x11, 0x05,

        0x48, 0x41, 0x9D, 0xBA, 0x44, 0xD1, 0x7D, 0xFB, 0x75, 0xD9, 0x17, 0x79, 0x79, 0x40, 0x2D, 0xE6,

        0x8A, 0x50, 0xF1, 0x23, 0xE3, 0x1E, 0xCB, 0x6B, 0x49, 0xB8, 0x02, 0x20, 0x14, 0x7B, 0xB5, 0xCB,

        0x2D, 0xF9, 0x1D, 0x37, 0x93, 0x89, 0x8C, 0xEB, 0xCC, 0x1E, 0x7E, 0xF8, 0x6A, 0xFC, 0xD1, 0x55,

        0x39, 0x39, 0x88, 0xCB, 0xAA, 0x30, 0xF6, 0xAF, 0x7C, 0xC2, 0x8A, 0xA9};

    unsigned char ecc_c301_aaid_pub[] = {

        0x35, 0x33, 0x45, 0x43, 0x23, 0x43, 0x33, 0x30, 0x31, 0x04,

        0xB9, 0xA4, 0x2A, 0x65, 0xD6, 0xD2, 0x36, 0xE3, 0x65, 0x83, 0x1C, 0xCD, 0x0D, 0xDA, 0x4C, 0x9E,

        0xE9, 0xE7, 0xEF, 0xD0, 0x0E, 0x13, 0xA7, 0x13, 0xEA, 0x04, 0xD0, 0xB4, 0xFB, 0x0E, 0x24, 0x85,

        0x6D, 0x81, 0x0C, 0x06, 0xFD, 0xA4, 0xD8, 0xC2, 0xB9, 0xE5, 0x42, 0x83, 0x02, 0xF7, 0x77, 0xDE,

        0x20, 0x13, 0x68, 0xA7, 0x3A, 0x42, 0x39, 0x56, 0x82, 0x7B, 0x14, 0xF5, 0x23, 0x55, 0xA0, 0x0E};



    unsigned char ecc_cb01_priv[] = {

        0xa2, 0x85, 0xaf, 0x84, 0x50, 0x23, 0x03, 0xb4, 0x61, 0x68, 0xb4, 0xa5, 0x04, 0x6e, 0x12, 0x84,

        0xa3, 0x77, 0x30, 0xef, 0xfc, 0x23, 0x97, 0x89, 0xe0, 0x57, 0x90, 0x4b, 0x33, 0x80, 0xfa, 0xd2};

    unsigned char ecc_cb01_cert[] = {

        0x30, 0x82, 0x03, 0x48, 0x30, 0x82, 0x02, 0xED, 0xA0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x09, 0x00,

        0x99, 0x7C, 0x7C, 0xAE, 0x92, 0x02, 0xB4, 0xC1, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE,

        0x3D, 0x04, 0x03, 0x02, 0x05, 0x00, 0x30, 0x81, 0xA6, 0x31, 0x1F, 0x30, 0x1D, 0x06, 0x03, 0x55,

        0x04, 0x03, 0x13, 0x16, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63,

        0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63, 0x73, 0x20, 0x43, 0x41, 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03,

        0x55, 0x04, 0x0A, 0x13, 0x13, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65,

        0x63, 0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63, 0x73, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04,

        0x0B, 0x13, 0x0E, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C,

        0x65, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0A, 0x53, 0x75, 0x77, 0x6F,

        0x6E, 0x20, 0x63, 0x69, 0x74, 0x79, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,

        0x02, 0x4B, 0x52, 0x31, 0x2A, 0x30, 0x28, 0x06, 0x0A, 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C,

        0x64, 0x01, 0x01, 0x0C, 0x1A, 0x53, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x44, 0x65, 0x76, 0x69,

        0x63, 0x65, 0x52, 0x6F, 0x6F, 0x74, 0x43, 0x41, 0x4B, 0x65, 0x79, 0x5F, 0x45, 0x43, 0x43, 0x30,

        0x1E, 0x17, 0x0D, 0x31, 0x35, 0x30, 0x38, 0x31, 0x30, 0x30, 0x38, 0x34, 0x36, 0x33, 0x33, 0x5A,

        0x17, 0x0D, 0x33, 0x35, 0x30, 0x38, 0x30, 0x35, 0x30, 0x38, 0x34, 0x36, 0x33, 0x33, 0x5A, 0x30,

        0x81, 0xC3, 0x31, 0x2F, 0x30, 0x2D, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0C, 0x26, 0x53, 0x61, 0x6D,

        0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63, 0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63, 0x73,

        0x20, 0x41, 0x54, 0x54, 0x2F, 0x41, 0x41, 0x49, 0x44, 0x3D, 0x35, 0x33, 0x45, 0x43, 0x23, 0x43,

        0x42, 0x30, 0x31, 0x31, 0x1C, 0x30, 0x1A, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x13, 0x13, 0x53, 0x61,

        0x6D, 0x73, 0x75, 0x6E, 0x67, 0x20, 0x45, 0x6C, 0x65, 0x63, 0x74, 0x72, 0x6F, 0x6E, 0x69, 0x63,

        0x73, 0x31, 0x17, 0x30, 0x15, 0x06, 0x03, 0x55, 0x04, 0x0B, 0x13, 0x0E, 0x53, 0x61, 0x6D, 0x73,

        0x75, 0x6E, 0x67, 0x20, 0x4D, 0x6F, 0x62, 0x69, 0x6C, 0x65, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,

        0x55, 0x04, 0x07, 0x13, 0x0A, 0x53, 0x75, 0x77, 0x6F, 0x6E, 0x20, 0x63, 0x69, 0x74, 0x79, 0x31,

        0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x4B, 0x52, 0x31, 0x37, 0x30, 0x35,

        0x06, 0x0A, 0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x01, 0x13, 0x27, 0x45, 0x4E,

        0x47, 0x3A, 0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x31, 0x30, 0x3A, 0x30, 0x31, 0x3A, 0x46, 0x46,

        0x3A, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x44, 0x3A, 0x46, 0x49, 0x44, 0x4F, 0x3A, 0x46,

        0x50, 0x3A, 0x45, 0x43, 0x43, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D,

        0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04,

        0x73, 0x69, 0xA3, 0xF6, 0xC6, 0x61, 0x09, 0xE6, 0x0B, 0xEA, 0x50, 0x49, 0x3E, 0x3D, 0x07, 0x4F,

        0xE1, 0x0E, 0xF1, 0x2A, 0x04, 0x3E, 0x07, 0x3C, 0x98, 0xFD, 0xD9, 0x58, 0x3D, 0x01, 0xC6, 0x4F,

        0xC4, 0xD4, 0x2A, 0xF5, 0x46, 0x86, 0x09, 0xD4, 0x8D, 0x02, 0xBE, 0x91, 0xF7, 0xA3, 0x33, 0x72,

        0xA9, 0x83, 0x9D, 0x71, 0x5D, 0x2A, 0x56, 0x19, 0xE8, 0xD1, 0x47, 0x17, 0x6B, 0xB2, 0xBD, 0x15,

        0xA3, 0x81, 0xE2, 0x30, 0x81, 0xDF, 0x30, 0x1D, 0x06, 0x03, 0x55, 0x1D, 0x0E, 0x04, 0x16, 0x04,

        0x14, 0x29, 0xC3, 0x8E, 0x4C, 0xD8, 0x89, 0x2A, 0xEF, 0xAD, 0x0E, 0x82, 0xEB, 0xC4, 0x5F, 0x12,

        0x91, 0xC4, 0x06, 0x0D, 0xAF, 0x30, 0x1F, 0x06, 0x03, 0x55, 0x1D, 0x23, 0x04, 0x18, 0x30, 0x16,

        0x80, 0x14, 0xB2, 0x99, 0x73, 0x6B, 0xB7, 0x67, 0x31, 0x2C, 0x93, 0x74, 0x78, 0xA9, 0x24, 0xA9,

        0x37, 0x3C, 0x63, 0x90, 0x46, 0x41, 0x30, 0x0E, 0x06, 0x03, 0x55, 0x1D, 0x0F, 0x01, 0x01, 0xFF,

        0x04, 0x04, 0x03, 0x02, 0x06, 0xC0, 0x30, 0x3D, 0x06, 0x03, 0x55, 0x1D, 0x1F, 0x04, 0x36, 0x30,

        0x34, 0x30, 0x32, 0xA0, 0x30, 0xA0, 0x2E, 0x86, 0x2C, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F,

        0x63, 0x72, 0x6C, 0x2E, 0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x63, 0x6F, 0x6D, 0x2F,

        0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x2F, 0x72, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,

        0x73, 0x2E, 0x63, 0x72, 0x6C, 0x30, 0x0F, 0x06, 0x03, 0x55, 0x1D, 0x13, 0x01, 0x01, 0xFF, 0x04,

        0x05, 0x30, 0x03, 0x02, 0x01, 0x00, 0x30, 0x3D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07,

        0x01, 0x01, 0x04, 0x31, 0x30, 0x2F, 0x30, 0x2D, 0x06, 0x08, 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07,

        0x30, 0x01, 0x86, 0x21, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6F, 0x63, 0x73, 0x70, 0x2E,

        0x73, 0x61, 0x6D, 0x73, 0x75, 0x6E, 0x67, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x73, 0x65, 0x63, 0x75,

        0x72, 0x69, 0x74, 0x79, 0x2F, 0x30, 0x0C, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03,

        0x02, 0x05, 0x00, 0x03, 0x47, 0x00, 0x30, 0x44, 0x02, 0x20, 0x7A, 0x5D, 0xA7, 0xA5, 0x44, 0xCE,

        0x4D, 0xA7, 0x02, 0x60, 0xCE, 0xDF, 0x66, 0xD3, 0xF0, 0x36, 0xC5, 0x5A, 0x0B, 0x2C, 0xD2, 0x84,

        0x40, 0xF0, 0x91, 0x1E, 0xD3, 0x0D, 0x04, 0xE9, 0x80, 0xAC, 0x02, 0x20, 0x49, 0x96, 0x14, 0x02,

        0xC0, 0x70, 0x66, 0xDF, 0x8C, 0x98, 0x72, 0x6A, 0x87, 0x8D, 0xCD, 0x0B, 0xE1, 0xD0, 0xD4, 0x01,

        0x56, 0x58, 0xFF, 0x3F, 0x67, 0xE2, 0xAF, 0x80, 0xF5, 0xAD, 0x44, 0x9B};

    unsigned char ecc_cb01_aaid_pub[] = {

        0x35, 0x33, 0x45, 0x43, 0x23, 0x43, 0x42, 0x30, 0x31, 0x04,

        0x73, 0x69, 0xA3, 0xF6, 0xC6, 0x61, 0x09, 0xE6, 0x0B, 0xEA, 0x50, 0x49, 0x3E, 0x3D, 0x07, 0x4F,

        0xE1, 0x0E, 0xF1, 0x2A, 0x04, 0x3E, 0x07, 0x3C, 0x98, 0xFD, 0xD9, 0x58, 0x3D, 0x01, 0xC6, 0x4F,

        0xC4, 0xD4, 0x2A, 0xF5, 0x46, 0x86, 0x09, 0xD4, 0x8D, 0x02, 0xBE, 0x91, 0xF7, 0xA3, 0x33, 0x72,

        0xA9, 0x83, 0x9D, 0x71, 0x5D, 0x2A, 0x56, 0x19, 0xE8, 0xD1, 0x47, 0x17, 0x6B, 0xB2, 0xBD, 0x15};



    SSESTATUS sseRet = 0;

    int index = 0;

    put_data_param_t putParam;



    uint8_t default_entries[10][4] = {

        {0xAB, 0xF3, 0x63, 0x6E},

        {0x19, 0x56, 0x77, 0x7E}, {0x89, 0x16, 0x03, 0x33}, {0x12, 0x5b, 0x12, 0x19},

        {0xcb, 0x1b, 0x4c, 0x10}, {0x57, 0x4b, 0x4c, 0x4b}, {0xa1, 0x41, 0x96, 0x8c},

        {0xA2, 0x8F, 0xE2, 0x4B}, {0x55, 0x10, 0x28, 0xA2}, {0x51, 0xd0, 0x54, 0x2f}};

    uint8_t put_default_entries_result[10] = {0, };



    LOGD("pushFidoKey [start]");

    if ( 0 != startService(cmd->data, cmd->dataLen, SEM_TID)) {

        LOGE("deleteAllTest opensession failed ");

        return ;

    }



    memset(&putParam, 0, sizeof(put_data_param_t));

    for (index = 1 ; index < 10 ; index++) {

        uint8_t outRemainRetryCnt = 0;



        putParam.entryId = default_entries[index];

        putParam.accessableTAID = (uint8_t*)SEM_TID;

        putParam.accessableTAIDLen= 16;

        putParam.entryCreation =  PED_ENTRY_EXISTS_N_PUT_DATA; // PED_ENTRY_CREATE_N_PUT_DATA

        putParam.update_command = PED_UPDATE_DATA_N_ACCESS_RULE;

        putParam.outRemainRetryCnt = &outRemainRetryCnt;

        putParam.delete_option = PED_DELETE_OPTION_PERMANENT;

        if (index == 1) {

            putParam.inData = rsa_c301_priv;

            putParam.inDataLen = sizeof(rsa_c301_priv);

        } else if (index == 2) {

            putParam.inData = rsa_c301_cert;

            putParam.inDataLen = sizeof(rsa_c301_cert);

        } else if (index == 3) {

            putParam.inData = rsa_c301_aaid_pub;

            putParam.inDataLen = sizeof(rsa_c301_aaid_pub);

        } else if (index == 4) {

            putParam.inData = ecc_c301_priv;

            putParam.inDataLen = sizeof(ecc_c301_priv);

        } else if (index == 5) {

            putParam.inData = ecc_c301_cert;

            putParam.inDataLen = sizeof(ecc_c301_cert);

        } else if (index == 6) {

            putParam.inData = ecc_c301_aaid_pub;

            putParam.inDataLen = sizeof(ecc_c301_aaid_pub);

        } else if (index == 7) {

            putParam.inData = ecc_cb01_priv;

            putParam.inDataLen = sizeof(ecc_cb01_priv);

        } else if (index == 8) {

            putParam.inData = ecc_cb01_cert;

            putParam.inDataLen = sizeof(ecc_cb01_cert);

        } else if (index == 9) {

            putParam.inData = ecc_cb01_aaid_pub;

            putParam.inDataLen = sizeof(ecc_cb01_aaid_pub);

        } else {

            putParam.inData = ecc_cb01_aaid_pub;

            putParam.inDataLen = 0;

        }



retry:

        sseRet = putEntryData(&putParam);

        if (sseRet == SSESTATUS_REF_DATA_NOT_FOUND){

            putParam.entryCreation =  PED_ENTRY_CREATE_N_PUT_DATA;

            goto retry;

        } else if (sseRet != SSESTATUS_OK) {

            LOGE("FAILED to put default entry index [%d], sseRet : %x", index, sseRet);

            put_default_entries_result[index] = 0;

        } else {

            LOGI("SUCCESS to put default entry index [%d]", index);

            put_default_entries_result[index] = 1;

        }

    }

    stopService();



    LOGD("Put default entry result :");

    LOGD("SK.RSA2048  : %d, CERT.RSA2048  : %d, AAID&PUB RSA2048  : %d", put_default_entries_result[1], put_default_entries_result[2], put_default_entries_result[3]);

    LOGD("SK_1.ECC256 : %d, CERT_1.ECC256 : %d, AAID&PUB_1 ECC256 : %d", put_default_entries_result[4], put_default_entries_result[5], put_default_entries_result[6]);

    LOGD("SK_2.ECC256 : %d, CERT_2.ECC256 : %d, AAID&PUB_2 ECC256 : %d", put_default_entries_result[7], put_default_entries_result[8], put_default_entries_result[9]);

}

#endif