| /* Copyright 2019,2020 NXP |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <ex_sss.h> |
| #include <ex_sss_boot.h> |
| #include <fsl_sss_se05x_apis.h> |
| #include <nxLog_App.h> |
| #include <se05x_APDU.h> |
| #include <se05x_const.h> |
| #include <se05x_ecc_curves.h> |
| #include <se05x_ecc_curves_values.h> |
| #include <se05x_tlv.h> |
| #include <string.h> |
| #include <nxEnsure.h> |
| |
| #include "ex_sss_auth.h" |
| #include "global_platf.h" |
| #include "smCom.h" |
| |
| static ex_sss_boot_ctx_t gex_sss_get_info_ctx; |
| |
| #define EX_SSS_BOOT_PCONTEXT (&gex_sss_get_info_ctx) |
| #define EX_SSS_BOOT_DO_ERASE 0 |
| #define EX_SSS_BOOT_EXPOSE_ARGC_ARGV 1 |
| #define EX_SSS_BOOT_SKIP_SELECT_APPLET 1 |
| |
| #define SEMS_LITE_AGENT_CHANNEL_1 0x01 |
| #define SEMS_LITE_GETDATA_UUID_TAG 0xFE |
| |
| #include <ex_sss_main_inc.h> |
| |
| static sss_status_t JCOP4_GetDataIdentify(void *conn_ctx); |
| static sss_status_t JCOP4_GetCPLCData(void *conn_ctx); |
| static sss_status_t SemsLite_Applet_Identify(void *conn_ctx); |
| static sss_status_t Iot_Applet_Identify(sss_se05x_session_t *pSession, int getUid); |
| static sss_status_t sems_lite_session_open(void *conn_ctx); |
| static sss_status_t iot_applet_session_open(ex_sss_boot_ctx_t *pCtx); |
| |
| sss_status_t ex_sss_entry(ex_sss_boot_ctx_t *pCtx) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| sss_se05x_session_t *pSession = (sss_se05x_session_t *)&pCtx->session; |
| |
| status = sems_lite_session_open(pSession->s_ctx.conn_ctx); |
| |
| if (status == kStatus_SSS_Success) { |
| /* Get UID from semslite */ |
| status = SemsLite_Applet_Identify(pSession->s_ctx.conn_ctx); |
| if (status != kStatus_SSS_Success) { |
| goto cleanup; |
| } |
| |
| status = iot_applet_session_open(pCtx); |
| if (status != kStatus_SSS_Success) { |
| LOG_I("No IoT applet found"); |
| } |
| else { |
| /* Get applet version and config details */ |
| status = Iot_Applet_Identify(pSession, 0); |
| if (status != kStatus_SSS_Success) { |
| goto cleanup; |
| } |
| } |
| } |
| else { |
| LOG_W("No SemsLite Applet Available. "); |
| /* Try connecting to iot applet */ |
| status = iot_applet_session_open(pCtx); |
| if (status != kStatus_SSS_Success) { |
| LOG_I("Error in iot applet session open"); |
| goto cleanup; |
| } |
| |
| /* Get UID, applet version and config details */ |
| status = Iot_Applet_Identify(pSession, 1); |
| if (status != kStatus_SSS_Success) { |
| goto cleanup; |
| } |
| } |
| |
| status = JCOP4_GetDataIdentify(pSession->s_ctx.conn_ctx); |
| if (status != kStatus_SSS_Success) |
| goto cleanup; |
| |
| status = JCOP4_GetCPLCData(pSession->s_ctx.conn_ctx); |
| if (status != kStatus_SSS_Success) |
| goto cleanup; |
| |
| status = kStatus_SSS_Success; |
| cleanup: |
| return status; |
| } |
| |
| static sss_status_t iot_applet_session_open(ex_sss_boot_ctx_t *pCtx) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| const char *portName; |
| |
| ex_sss_session_close(pCtx); |
| |
| status = ex_sss_boot_connectstring(gex_sss_argc, gex_sss_argv, &portName); |
| if (kStatus_SSS_Success != status) { |
| LOG_E("ex_sss_boot_connectstring Failed"); |
| goto cleanup; |
| } |
| |
| pCtx->se05x_open_ctx.skip_select_applet = 0; |
| |
| status = ex_sss_boot_open(pCtx, portName); |
| if (kStatus_SSS_Success != status) { |
| LOG_E("ex_sss_session_open Failed"); |
| goto cleanup; |
| } |
| |
| status = kStatus_SSS_Success; |
| cleanup: |
| return status; |
| } |
| |
| static sss_status_t sems_lite_session_open(void *conn_ctx) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| U32 ret = 0; |
| smStatus_t retStatus = SM_NOT_OK; |
| |
| #ifdef SEMS_LITE_AGENT_CHANNEL_1 |
| const uint8_t openCmd[] = {0x00, 0x70, 0x00, 0x00, 0x01}; |
| U16 openCmdLen = sizeof(openCmd); |
| #endif |
| |
| /* clang-format off */ |
| const uint8_t selectCmd[] = { |
| #ifdef SEMS_LITE_AGENT_CHANNEL_1 |
| 0x01, 0xA4, 0x04, 0x00, 0x10, 0xA0, 0x00, 0x00, |
| #else |
| 0x00, 0xA4, 0x04, 0x00, 0x10, 0xA0, 0x00, 0x00, |
| #endif |
| 0x03, 0x96, 0x54, 0x53, 0x00, 0x00, 0x00, 0x01, |
| 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, |
| }; |
| /* clang-format on */ |
| U16 selectCmdLen = sizeof(selectCmd); |
| |
| uint8_t resp[128] = {0x00}; |
| U32 respLen = sizeof(resp); |
| |
| ENSURE_OR_GO_EXIT(conn_ctx != NULL); |
| |
| #ifdef SEMS_LITE_AGENT_CHANNEL_1 |
| ret = smCom_TransceiveRaw(conn_ctx, (uint8_t *)openCmd, openCmdLen, resp, &respLen); |
| ENSURE_OR_GO_EXIT(ret == SM_OK); |
| #endif |
| |
| respLen = sizeof(resp); |
| ret = smCom_TransceiveRaw(conn_ctx, (uint8_t *)selectCmd, selectCmdLen, resp, &respLen); |
| ENSURE_OR_GO_EXIT(ret == SM_OK); |
| |
| retStatus = (resp[respLen - 2] << 8) | (resp[respLen - 1]); |
| if (retStatus != SM_OK) { |
| goto exit; |
| } |
| |
| status = kStatus_SSS_Success; |
| exit: |
| return status; |
| } |
| |
| #define CHECK_FEATURE_PRESENT(AppletConfig, ITEM) \ |
| if (((kSE05x_AppletConfig_##ITEM) == ((AppletConfig) & (kSE05x_AppletConfig_##ITEM)))) { \ |
| LOG_I("With " #ITEM); \ |
| } \ |
| else { \ |
| LOG_I("WithOut " #ITEM); \ |
| } |
| |
| static sss_status_t sems_lite_verify_GetDataResponse(uint8_t tag_P2, uint8_t *pRspBuf, U32 *pRspBufLen) |
| { |
| sss_status_t sss_stat = kStatus_SSS_Fail; |
| size_t getDataRspLen = 0; |
| smStatus_t retStatus = SM_NOT_OK; |
| if (*pRspBufLen > 2) { |
| getDataRspLen = *pRspBufLen; |
| retStatus = (pRspBuf[getDataRspLen - 2] << 8) | (pRspBuf[getDataRspLen - 1]); |
| if (retStatus == SM_OK) { |
| if (pRspBuf[0] == tag_P2) { |
| if (pRspBuf[1] > 0) { |
| *pRspBufLen = pRspBuf[1]; |
| memmove(pRspBuf, pRspBuf + 2, pRspBuf[1]); |
| sss_stat = kStatus_SSS_Success; |
| } |
| else { |
| memset(pRspBuf, 0, *pRspBufLen); |
| *pRspBufLen = 0; |
| } |
| } |
| } |
| } |
| return sss_stat; |
| } |
| |
| static sss_status_t SemsLite_Applet_Identify(void *conn_ctx) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| U32 ret = 0; |
| uint8_t uid[64]; |
| U32 uidLen = sizeof(uid); |
| |
| uint8_t tag_P1 = 0x00; |
| uint8_t tag_P2 = SEMS_LITE_GETDATA_UUID_TAG; |
| |
| uint8_t getDataCmd[32] = { |
| 0x80, // CLA '80' / '00' GlobalPlatform / ISO / IEC |
| 0xCA, // INS 'CA' GET DATA(IDENTIFY) |
| 0x00, // P1 '00' High order tag value |
| 0x00, // P2 - proprietary data coming from respective function |
| 0x00, // Lc is Le'00' Case 2 command |
| }; |
| U16 getDataCmdLen = 5; |
| |
| getDataCmd[2] = tag_P1; |
| getDataCmd[3] = tag_P2; |
| |
| #ifdef SEMS_LITE_AGENT_CHANNEL_1 |
| getDataCmd[0] = getDataCmd[0] | SEMS_LITE_AGENT_CHANNEL_1; |
| #endif |
| |
| ret = smCom_TransceiveRaw(conn_ctx, (uint8_t *)getDataCmd, getDataCmdLen, uid, &uidLen); |
| if (ret != SM_OK) { |
| LOG_E("Could not get requested Data!!!"); |
| goto cleanup; |
| } |
| |
| if (kStatus_SSS_Success != sems_lite_verify_GetDataResponse(SEMS_LITE_GETDATA_UUID_TAG, uid, &uidLen)) { |
| goto cleanup; |
| } |
| |
| LOG_W("#####################################################"); |
| LOG_AU8_I(uid, uidLen); |
| |
| status = kStatus_SSS_Success; |
| cleanup: |
| return status; |
| } |
| |
| static sss_status_t Iot_Applet_Identify(sss_se05x_session_t *pSession, int getUid) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| smStatus_t sw_status; |
| SE05x_Result_t result = kSE05x_Result_NA; |
| uint8_t uid[SE050_MODULE_UNIQUE_ID_LEN]; |
| size_t uidLen = sizeof(uid); |
| uint8_t applet_version[7]; |
| size_t applet_versionLen = sizeof(applet_version); |
| |
| if (getUid == 1) { |
| sw_status = Se05x_API_CheckObjectExists(&pSession->s_ctx, kSE05x_AppletResID_UNIQUE_ID, &result); |
| if (SM_OK != sw_status) { |
| LOG_E("Failed Se05x_API_CheckObjectExists"); |
| goto cleanup; |
| } |
| |
| sw_status = |
| Se05x_API_ReadObject(&pSession->s_ctx, kSE05x_AppletResID_UNIQUE_ID, 0, (uint16_t)uidLen, uid, &uidLen); |
| if (SM_OK != sw_status) { |
| LOG_E("Failed Se05x_API_CheckObjectExists"); |
| goto cleanup; |
| } |
| LOG_W("#####################################################"); |
| LOG_AU8_I(uid, uidLen); |
| } |
| |
| // VersionInfo is a 7 - byte value consisting of : |
| // - 1 - byte Major applet version |
| // - 1 - byte Minor applet version |
| // - 1 - byte patch applet version |
| // - 2 - byte AppletConfig, indicating the supported applet features |
| // - 2-byte Secure Box version: major version (MSB) concatenated with minor version (LSB). |
| |
| sw_status = Se05x_API_GetVersion(&pSession->s_ctx, applet_version, &applet_versionLen); |
| if (SM_OK != sw_status) { |
| LOG_E("Failed Se05x_API_GetVersion"); |
| goto cleanup; |
| } |
| LOG_W("#####################################################"); |
| LOG_I("Applet Major = %d", applet_version[0]); |
| LOG_I("Applet Minor = %d", applet_version[1]); |
| LOG_I("Applet patch = %d", applet_version[2]); |
| LOG_I("AppletConfig = %02X%02X", applet_version[3], applet_version[4]); |
| { |
| U16 AppletConfig = applet_version[3] << 8 | applet_version[4]; |
| CHECK_FEATURE_PRESENT(AppletConfig, ECDAA); |
| CHECK_FEATURE_PRESENT(AppletConfig, ECDSA_ECDH_ECDHE); |
| CHECK_FEATURE_PRESENT(AppletConfig, EDDSA); |
| CHECK_FEATURE_PRESENT(AppletConfig, DH_MONT); |
| CHECK_FEATURE_PRESENT(AppletConfig, HMAC); |
| CHECK_FEATURE_PRESENT(AppletConfig, RSA_PLAIN); |
| CHECK_FEATURE_PRESENT(AppletConfig, RSA_CRT); |
| CHECK_FEATURE_PRESENT(AppletConfig, AES); |
| CHECK_FEATURE_PRESENT(AppletConfig, DES); |
| CHECK_FEATURE_PRESENT(AppletConfig, PBKDF); |
| CHECK_FEATURE_PRESENT(AppletConfig, TLS); |
| CHECK_FEATURE_PRESENT(AppletConfig, MIFARE); |
| CHECK_FEATURE_PRESENT(AppletConfig, I2CM); |
| } |
| LOG_I("Internal = %02X%02X", applet_version[5], applet_version[6]); |
| |
| status = kStatus_SSS_Success; |
| cleanup: |
| return status; |
| } |
| |
| /* Execute and decode GET DATA IDENTIFY as specified for SE05x JCOP |
| * |
| * @warn After this call, the applet is deselected and applet commands won't work. |
| * The applet session needs to be re-established |
| * (select applet, establish optional session, like in the sss_session_open() |
| */ |
| |
| static sss_status_t JCOP4_GetDataIdentify(void *conn_ctx) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| smStatus_t rxStatus; |
| char jcop_platform_id[17] = {0}; |
| /* Must be packed */ |
| typedef struct |
| { |
| //0xFE Tag value - proprietary data Only present if class byte is 0x80 |
| uint8_t vTag_value_proprietary_data; |
| //0x49 / 0x45 Length of following data Only present if class byte is 0x80 |
| uint8_t vLength_of_following_data; |
| //0xDF28 Tag card identification data Only present if class byte is 0x80 |
| uint8_t vTag_card_identification_data[0x02]; |
| //0x46 Length of card identification data Only present if class byte is 0x80 |
| uint8_t vLength_of_card_identification_data; |
| //0x01 Tag configuration ID Identifies the configuration content |
| uint8_t vTag_configuration_ID; |
| uint8_t vLength_configuration_ID; //0x0C Length configuration ID |
| uint8_t vConfiguration_ID[0x0C]; //var Configuration ID |
| uint8_t vTag_patch_ID; //0x02 Tag patch ID Identifies the patch level |
| uint8_t vLength_patch_ID; //0x08 Length patch ID |
| uint8_t vPatch_ID[0x08]; //var Patch ID |
| //0x03 Tag platform build ID1 Identifies the JCOP platform |
| uint8_t vTag_platform_build_ID1; |
| uint8_t vLength_platform_build_ID; //0x18 Length platform build ID |
| uint8_t vPlatform_build_ID[0x18]; //var Platform build ID |
| uint8_t vTag_FIPS_mode; //0x052 Tag FIPS mode FIPS mode active |
| uint8_t vLength_FIPS_mode; //0x01 Length FIPS mode |
| //var FIPS mode 0x00 - FIPS mode not active, 0x01 - FIPS mode active |
| uint8_t vFIPS_mode; |
| |
| //uint8_t vTag_modules_enabled; //0x06 Tag modules enabled Lists enabled and disabled modules |
| //uint8_t vLength_modules_enabled; //0x02 Length modules enabled Big endian format |
| //uint8_t vBit_mask_of_enabled_modules[0x02]; //var Bit mask of enabled modules See Table 5.3 |
| |
| //0x07 Tag pre-perso state Lists pre-perso state |
| uint8_t vTag_pre_perso_state; |
| |
| //0x01 Length pre-perso state |
| uint8_t vLength_pre_perso_state; |
| |
| //var Bit mask of pre-perso state bit0 = 1 = config module available, |
| // bit1 = 1 = transport state is active. |
| // Unused bits are set to 0x0. |
| uint8_t vBit_mask_of_pre_perso_state; |
| uint8_t vTag_ROM_ID; //'08' Tag ROM ID Indentifies the ROM content |
| uint8_t vLength_ROM_ID; //'08' Length ROM ID Normal ending |
| uint8_t vROM_ID[0x08]; //var ROM ID |
| uint8_t vStatus_Word_SW_[0x02]; //9000h Status Word (SW) |
| } identifyRsp_t; |
| |
| const uint8_t cmd[] = { |
| 0x80, // CLA '80' / '00' GlobalPlatform / ISO / IEC |
| 0xCA, // INS 'CA' GET DATA(IDENTIFY) |
| 0x00, // P1 '00' High order tag value |
| 0xFE, // P2 'FE' Low order tag value - proprietary data |
| 0x02, // Lc '02' Length of data field |
| 0xDF, |
| 0x28, // Data 'DF28' Card identification data |
| 0x00 // Le '00' Length of response data |
| }; |
| |
| identifyRsp_t identifyRsp = {0}; |
| U32 prspLen = sizeof(identifyRsp_t); |
| |
| U16 dummyResponse16 = sizeof(identifyRsp_t); |
| /* Select card manager / ISD |
| * (ReUsing same dummy buffers) */ |
| rxStatus = GP_Select(conn_ctx, (uint8_t *)&identifyRsp /* dummy */, 0, (uint8_t *)&identifyRsp, &dummyResponse16); |
| if (rxStatus != SM_OK) { |
| LOG_E("Could not select ISD."); |
| goto cleanup; |
| } |
| |
| rxStatus = smCom_TransceiveRaw(conn_ctx, (uint8_t *)cmd, sizeof(cmd), (uint8_t *)&identifyRsp, &prspLen); |
| if (rxStatus == SM_OK && prspLen == sizeof(identifyRsp)) { |
| LOG_W("#####################################################"); |
| LOG_I("%s = 0x%02X", "Tag value - proprietary data 0xFE", identifyRsp.vTag_value_proprietary_data); |
| LOG_I("%s = 0x%02X", "Length of following data 0x45", identifyRsp.vLength_of_following_data); |
| LOG_MAU8_I("Tag card identification data", |
| identifyRsp.vTag_card_identification_data, |
| sizeof(identifyRsp.vTag_card_identification_data)); |
| LOG_I("%s = 0x%02X", |
| "Length of card identification data", // 0x46 |
| identifyRsp.vLength_of_card_identification_data); |
| LOG_I("%s = 0x%02X", "Tag configuration ID (Must be 0x01)", identifyRsp.vTag_configuration_ID); |
| LOG_D("%s = 0x%02X", "Length configuration ID 0x0C", identifyRsp.vLength_configuration_ID); |
| LOG_MAU8_I("Configuration ID", identifyRsp.vConfiguration_ID, sizeof(identifyRsp.vConfiguration_ID)); |
| |
| //Third and fourth Byte of vConfiguration_ID is the OEF ID |
| LOG_MAU8_I("OEF ID", &identifyRsp.vConfiguration_ID[2], 2); |
| LOG_I("%s = 0x%02X", "Tag patch ID (Must be 0x02)", identifyRsp.vTag_patch_ID); |
| LOG_D("%s = 0x%02X", "Length patch ID 0x08", identifyRsp.vLength_patch_ID); |
| LOG_MAU8_I("Patch ID", identifyRsp.vPatch_ID, sizeof(identifyRsp.vPatch_ID)); |
| LOG_I("%s = 0x%02X", "Tag platform build ID1 (Must be 0x03)", identifyRsp.vTag_platform_build_ID1); |
| LOG_D("%s = 0x%02X", "Length platform build ID 0x18", identifyRsp.vLength_platform_build_ID); |
| LOG_MAU8_I("Platform build ID", identifyRsp.vPlatform_build_ID, sizeof(identifyRsp.vPlatform_build_ID)); |
| memcpy(jcop_platform_id, identifyRsp.vPlatform_build_ID, 16); |
| |
| LOG_I("%s = %s", "JCOP Platform ID", jcop_platform_id); |
| LOG_I("%s = 0x%02X", "Tag FIPS mode (Must be 0x05)", identifyRsp.vTag_FIPS_mode); |
| LOG_D("%s = 0x%02X", "Length FIPS mode 0x01", identifyRsp.vLength_FIPS_mode); |
| LOG_I("%s = 0x%02X", "FIPS mode var", identifyRsp.vFIPS_mode); |
| //LOG_I("%s = 0x%02X", "Tag modules enabled 0x06", identifyRsp.vTag_modules_enabled); |
| //LOG_I("%s = 0x%02X", "Length modules enabled 0x02", identifyRsp.vLength_modules_enabled); |
| //LOG_MAU8_I("Bit mask of enabled modules", identifyRsp.vBit_mask_of_enabled_modules, sizeof(identifyRsp.vBit_mask_of_enabled_modules)); |
| LOG_I("%s = 0x%02X", "Tag pre-perso state (Must be 0x07)", identifyRsp.vTag_pre_perso_state); |
| LOG_D("%s = 0x%02X", "Length pre-perso state 0x01", identifyRsp.vLength_pre_perso_state); |
| LOG_I("%s = 0x%02X", "Bit mask of pre-perso state var", identifyRsp.vBit_mask_of_pre_perso_state); |
| |
| LOG_I("%s = 0x%02X", "Tag ROM ID (Must be 0x08)", identifyRsp.vTag_ROM_ID); |
| LOG_D("%s = 0x%02X", "Length ROM ID 0x08", identifyRsp.vLength_ROM_ID); |
| LOG_MAU8_I("ROM ID", identifyRsp.vROM_ID, sizeof(identifyRsp.vROM_ID)); |
| LOG_MAU8_I("Status Word (SW)", identifyRsp.vStatus_Word_SW_, sizeof(identifyRsp.vStatus_Word_SW_)); |
| } |
| else { |
| LOG_E("Error in retreiving the JCOP Identifier. Response is as follows"); |
| LOG_AU8_E((uint8_t *)&identifyRsp, sizeof(identifyRsp)); |
| goto cleanup; |
| } |
| status = kStatus_SSS_Success; |
| |
| cleanup: |
| if (kStatus_SSS_Success == status) { |
| LOG_I("se05x_GetInfoPlainApplet Example Success !!!..."); |
| } |
| else { |
| LOG_E("se05x_GetInfoPlainApplet Example Failed !!!..."); |
| } |
| return status; |
| } |
| |
| /* See 5.1.1.2 Get CPLC data |
| * This command returns the Card Production Life Cycle (CPLC) data. The APDU can be sent without prior authentication. |
| * |
| * |
| * The Card Production Life Cycle data as defined in VISA GlobalPlatform Card Specification 2.1.1 are coded in 42 |
| * bytes. The CPLC format and the default values are shown below |
| * |
| */ |
| |
| static sss_status_t JCOP4_GetCPLCData(void *conn_ctx) |
| { |
| sss_status_t status = kStatus_SSS_Fail; |
| smStatus_t rxStatus; |
| /* Must be packed */ |
| typedef struct |
| { |
| uint8_t p9F7F[2]; |
| uint8_t pLen[1]; // = 2A |
| uint8_t IC_fabricator[2]; // 2 '4790' NXP |
| uint8_t IC_type1[2]; // 2 'D321' NXP |
| uint8_t Operating_system_identifier[2]; // 2 '47' SS NXP |
| uint8_t Operating_system_release_date[2]; // 2 SS SS NXP |
| uint8_t Operating_system_release_level[2]; // 2 <Mask ID> <Patch ID> NXP |
| uint8_t IC_fabrication_date[2]; // tt NXP |
| uint8_t IC_Serial_number[4]; // 4 nnnb NXP |
| uint8_t IC_Batch_identifier[2]; // 2 bb NXP |
| uint8_t IC_module_fabricator[2]; // 2 '00' '00' Customer |
| uint8_t IC_module_packaging_date[2]; // 2 '00' '00' Customer |
| uint8_t ICC_manufacturer[2]; // 2 '00' '00' Customer |
| uint8_t IC_embedding_date[2]; // 2 '00' '00' Customer |
| uint8_t IC_OS_initializer[2]; // 2 WX Customer |
| uint8_t IC_OS_initialization_date[2]; // 2 YN Customer |
| uint8_t IC_OS_initialization_equipment[4]; // ID 4 NNNN Customer |
| uint8_t IC_personalizer[2]; // 2 '00' '00' Customer |
| uint8_t IC_personalization_date[2]; // 2 '00' '00' Customer |
| uint8_t IC_personalization_equipment_ID[4]; // 4 '00'. . . '00' Customer |
| uint8_t SW[2]; |
| } cplcRsp_t; |
| |
| const uint8_t cmd[] = { |
| 0x80, // CLA '80' / '00' GlobalPlatform / ISO / IEC |
| 0xCA, // INS |
| 0x9F, // P1 |
| 0x7F, // P2 |
| 0x00, // Lc |
| }; |
| |
| cplcRsp_t cplc_data = {{0}}; |
| U32 cplc_data_len = sizeof(cplcRsp_t); |
| |
| SSS_ASSERT(sizeof(cplcRsp_t) == 47); |
| |
| rxStatus = smCom_TransceiveRaw(conn_ctx, (uint8_t *)cmd, sizeof(cmd), (uint8_t *)&cplc_data, &cplc_data_len); |
| if (rxStatus == SM_OK && cplc_data_len == sizeof(cplc_data)) { |
| LOG_W("#####################################################"); |
| LOG_AU8_I(cplc_data.IC_fabricator, sizeof(cplc_data.IC_fabricator)); |
| LOG_AU8_I(cplc_data.IC_type1, sizeof(cplc_data.IC_type1)); |
| LOG_AU8_I(cplc_data.Operating_system_identifier, sizeof(cplc_data.Operating_system_identifier)); |
| LOG_AU8_I(cplc_data.Operating_system_release_date, sizeof(cplc_data.Operating_system_release_date)); |
| LOG_AU8_I(cplc_data.Operating_system_release_level, sizeof(cplc_data.Operating_system_release_level)); |
| LOG_AU8_I(cplc_data.IC_fabrication_date, sizeof(cplc_data.IC_fabrication_date)); |
| LOG_AU8_I(cplc_data.IC_Serial_number, sizeof(cplc_data.IC_Serial_number)); |
| LOG_AU8_I(cplc_data.IC_Batch_identifier, sizeof(cplc_data.IC_Batch_identifier)); |
| LOG_AU8_I(cplc_data.IC_module_fabricator, sizeof(cplc_data.IC_module_fabricator)); |
| LOG_AU8_I(cplc_data.IC_module_packaging_date, sizeof(cplc_data.IC_module_packaging_date)); |
| LOG_AU8_I(cplc_data.ICC_manufacturer, sizeof(cplc_data.ICC_manufacturer)); |
| LOG_AU8_I(cplc_data.IC_embedding_date, sizeof(cplc_data.IC_embedding_date)); |
| LOG_AU8_I(cplc_data.IC_OS_initializer, sizeof(cplc_data.IC_OS_initializer)); |
| LOG_AU8_I(cplc_data.IC_OS_initialization_date, sizeof(cplc_data.IC_OS_initialization_date)); |
| LOG_AU8_I(cplc_data.IC_OS_initialization_equipment, sizeof(cplc_data.IC_OS_initialization_equipment)); |
| LOG_AU8_I(cplc_data.IC_personalizer, sizeof(cplc_data.IC_personalizer)); |
| LOG_AU8_I(cplc_data.IC_personalization_date, sizeof(cplc_data.IC_personalization_date)); |
| LOG_AU8_I(cplc_data.IC_personalization_equipment_ID, sizeof(cplc_data.IC_personalization_equipment_ID)); |
| LOG_AU8_I(cplc_data.SW, sizeof(cplc_data.SW)); |
| } |
| else { |
| LOG_E("Error in retreiving the CPLC Data. Response is as follows"); |
| LOG_AU8_E((uint8_t *)&cplc_data, sizeof(cplc_data)); |
| goto cleanup; |
| } |
| status = kStatus_SSS_Success; |
| |
| cleanup: |
| return status; |
| } |
