| /* |
| * |
| * Copyright 2018-2020 NXP |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| /** @file */ |
| |
| #include <fsl_sss_se05x_apis.h> |
| #include <nxLog_sss.h> |
| |
| #if SSS_HAVE_APPLET_SE05X_IOT |
| #include <Applet_SE050_Ver.h> |
| #include <se05x_APDU.h> |
| #include <se05x_const.h> |
| #include <se05x_tlv.h> |
| #include <string.h> |
| |
| uint32_t se05x_sssKeyTypeLenToCurveId(sss_cipher_type_t cipherType, size_t keyBits) |
| { |
| uint32_t u32_curve_id = 0; |
| switch (cipherType) { |
| case kSSS_CipherType_EC_NIST_P: { |
| SE05x_ECCurve_t eCurveID; |
| switch (keyBits) { |
| case 192: |
| eCurveID = kSE05x_ECCurve_NIST_P192; |
| break; |
| case 224: |
| eCurveID = kSE05x_ECCurve_NIST_P224; |
| break; |
| case 256: |
| eCurveID = kSE05x_ECCurve_NIST_P256; |
| break; |
| case 384: |
| eCurveID = kSE05x_ECCurve_NIST_P384; |
| break; |
| case 521: |
| eCurveID = kSE05x_ECCurve_NIST_P521; |
| break; |
| default: |
| eCurveID = 0; |
| } |
| u32_curve_id = (uint32_t)eCurveID; |
| break; |
| } |
| case kSSS_CipherType_EC_BRAINPOOL: { |
| SE05x_ECCurve_t eCurveID; |
| switch (keyBits) { |
| case 160: |
| eCurveID = kSE05x_ECCurve_Brainpool160; |
| break; |
| case 192: |
| eCurveID = kSE05x_ECCurve_Brainpool192; |
| break; |
| case 224: |
| eCurveID = kSE05x_ECCurve_Brainpool224; |
| break; |
| case 256: |
| eCurveID = kSE05x_ECCurve_Brainpool256; |
| break; |
| case 320: |
| eCurveID = kSE05x_ECCurve_Brainpool320; |
| break; |
| case 384: |
| eCurveID = kSE05x_ECCurve_Brainpool384; |
| break; |
| case 512: |
| eCurveID = kSE05x_ECCurve_Brainpool512; |
| break; |
| default: |
| eCurveID = 0; |
| } |
| u32_curve_id = (uint32_t)eCurveID; |
| break; |
| } |
| case kSSS_CipherType_EC_NIST_K: { |
| SE05x_ECCurve_t eCurveID; |
| switch (keyBits) { |
| case 160: |
| eCurveID = kSE05x_ECCurve_Secp160k1; |
| break; |
| case 192: |
| eCurveID = kSE05x_ECCurve_Secp192k1; |
| break; |
| case 224: |
| eCurveID = kSE05x_ECCurve_Secp224k1; |
| break; |
| case 256: |
| eCurveID = kSE05x_ECCurve_Secp256k1; |
| break; |
| default: |
| eCurveID = 0; |
| } |
| u32_curve_id = (uint32_t)eCurveID; |
| break; |
| } |
| case kSSS_CipherType_EC_MONTGOMERY: { |
| SE05x_ECCurve_t eCurveID; |
| switch (keyBits) { |
| #if SSS_HAVE_SE05X_VER_GTE_06_00 |
| case 448: |
| eCurveID = kSE05x_ECCurve_RESERVED_ID_ECC_MONT_DH_448; |
| break; |
| #endif |
| case 256: |
| eCurveID = kSE05x_ECCurve_RESERVED_ID_ECC_MONT_DH_25519; |
| break; |
| default: |
| eCurveID = 0; |
| } |
| u32_curve_id = (uint32_t)eCurveID; |
| break; |
| } |
| case kSSS_CipherType_EC_TWISTED_ED: { |
| SE05x_ECCurve_t eCurveID; |
| switch (keyBits) { |
| case 256: |
| eCurveID = kSE05x_ECCurve_RESERVED_ID_ECC_ED_25519; |
| break; |
| default: |
| eCurveID = 0; |
| } |
| u32_curve_id = (uint32_t)eCurveID; |
| break; |
| } |
| case kSSS_CipherType_EC_BARRETO_NAEHRIG: { |
| SE05x_ECCurve_t eCurveID; |
| switch (keyBits) { |
| case 256: |
| eCurveID = kSE05x_ECCurve_TPM_ECC_BN_P256; |
| break; |
| default: |
| eCurveID = 0; |
| } |
| u32_curve_id = (uint32_t)eCurveID; |
| break; |
| } |
| default: |
| break; |
| } |
| return u32_curve_id; |
| } |
| |
| smStatus_t Se05x_API_EC_CurveGetId(pSe05xSession_t session_ctx, uint32_t objectID, SE05x_ECCurve_t *pcurveId) |
| { |
| smStatus_t ret = SM_NOT_OK; |
| if (pcurveId) { |
| uint8_t u8curve = 0; |
| ret = Se05x_API_GetECCurveId(session_ctx, objectID, &u8curve); |
| if (ret == SM_OK) { |
| *pcurveId = (SE05x_ECCurve_t)u8curve; |
| } |
| } |
| return ret; |
| } |
| |
| smStatus_t Se05x_i2c_master_txn(sss_session_t *sess, SE05x_I2CM_cmd_t *p, uint8_t noOftags) |
| { |
| smStatus_t retval = SM_NOT_OK; |
| uint8_t buffer[SE05X_I2CM_MAX_BUF_SIZE_CMD] = {0}; |
| size_t bufferLen = 0; |
| uint8_t iCnt = 0; |
| uint8_t remainingCnt = 0; |
| int tlvRet = 0; |
| uint8_t rspbuffer[SE05X_I2CM_MAX_BUF_SIZE_RSP] = {0}; |
| size_t rspbufferLen = sizeof(rspbuffer); |
| |
| sss_se05x_session_t *se05x_session = (sss_se05x_session_t *)sess; |
| Se05xSession_t *se050session_id = NULL; |
| |
| uint8_t *pCmdbuf = &buffer[0]; |
| const uint8_t *pSendbuf = &buffer[0]; |
| size_t SendLen = 0; |
| |
| if (se05x_session->subsystem == kType_SSS_SE_SE05x) { |
| se050session_id = &se05x_session->s_ctx; |
| } |
| else { |
| goto cleanup; |
| } |
| |
| for (iCnt = 0; iCnt < noOftags; iCnt++) { |
| if (p[iCnt].type == kSE05x_I2CM_Configure) { |
| uint8_t configBuf[2] = {0}; |
| size_t configBufLen = sizeof(configBuf); |
| configBuf[0] = p[iCnt].cmd.cfg.I2C_addr; |
| configBuf[1] = p[iCnt].cmd.cfg.I2C_baudRate; |
| tlvRet = TLVSET_u8buf_I2CM( |
| "I2CM Configure", &pCmdbuf, &bufferLen, kSE05x_TAG_I2CM_Config, configBuf, configBufLen); |
| if (0 != tlvRet) { |
| goto cleanup; |
| } |
| } |
| //else if (p[iCnt].type == kSE05x_I2CM_Security) { |
| //} |
| else if (p[iCnt].type == kSE05x_I2CM_Write) { |
| tlvRet = TLVSET_u8buf_I2CM("I2CM Write", |
| &pCmdbuf, |
| &bufferLen, |
| kSE05x_TAG_I2CM_Write, |
| p[iCnt].cmd.w.writebuf, |
| p[iCnt].cmd.w.writeLength); |
| if (0 != tlvRet) { |
| goto cleanup; |
| } |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Read) { |
| uint8_t readLenBuf[2]; |
| size_t readLenBufLen = sizeof(readLenBuf); |
| readLenBuf[0] = (uint8_t)(p[iCnt].cmd.rd.readLength >> 8); |
| readLenBuf[1] = (uint8_t)(p[iCnt].cmd.rd.readLength); |
| tlvRet = |
| TLVSET_u8buf_I2CM("I2CM Read", &pCmdbuf, &bufferLen, kSE05x_TAG_I2CM_Read, readLenBuf, readLenBufLen); |
| if (0 != tlvRet) { |
| goto cleanup; |
| } |
| } |
| else { |
| break; |
| } |
| } |
| |
| SendLen = bufferLen; |
| retval = Se05x_API_I2CM_Send(se050session_id, pSendbuf, SendLen, rspbuffer, &rspbufferLen); |
| |
| if (retval == SM_OK) { |
| // Walk through the result. |
| // In principle the order of results matches the order the incoming commands. |
| // Exception: Structural error in format incoming commands |
| uint8_t *rspTag = &rspbuffer[0]; |
| unsigned int rspPos = 1u; |
| for (iCnt = 0; iCnt < noOftags; iCnt++) { |
| if (*rspTag == kSE05x_I2CM_StructuralIssue) { |
| // Modify TLV type of command to report back error |
| p[iCnt].type = kSE05x_I2CM_StructuralIssue; |
| p[iCnt].cmd.issue.issueStatus = rspbuffer[rspPos]; |
| break; |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Configure) { |
| // Check whether response is in expected order |
| if (*rspTag != p[iCnt].type) { |
| LOG_W("Response out-of-order"); |
| break; |
| } |
| p[iCnt].cmd.cfg.status = rspbuffer[rspPos]; |
| } |
| //else if (p[iCnt].type == kSE05x_I2CM_Security) { |
| //} |
| else if (p[iCnt].type == kSE05x_I2CM_Write) { |
| // Check whether response is in expected order |
| if (*rspTag != p[iCnt].type) { |
| LOG_W("Response out-of-order"); |
| break; |
| } |
| p[iCnt].cmd.w.wrStatus = rspbuffer[rspPos]; |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Read) { |
| // Check whether response is in expected order |
| if (*rspTag != p[iCnt].type) { |
| LOG_W("Response out-of-order"); |
| break; |
| } |
| p[iCnt].cmd.rd.rdStatus = rspbuffer[rspPos]; |
| if (p[iCnt].cmd.rd.rdStatus == kSE05x_I2CM_Success) { |
| // Receiving less data than requested is not considered an error |
| uint16_t reportedRead = (rspbuffer[rspPos + 1] << 8) + rspbuffer[rspPos + 2]; |
| rspPos += 2; |
| if (reportedRead < p[iCnt].cmd.rd.readLength) { |
| LOG_W("kSE05x_I2CM_Read: Requested %d, Received %d byte", |
| p[iCnt].cmd.rd.readLength, |
| reportedRead); |
| p[iCnt].cmd.rd.readLength = reportedRead; |
| } |
| // Did we receive enough data? |
| if (rspbufferLen > (rspPos + p[iCnt].cmd.rd.readLength)) { |
| memcpy(p[iCnt].cmd.rd.rdBuf, &rspbuffer[rspPos + 1], p[iCnt].cmd.rd.readLength); |
| rspPos += p[iCnt].cmd.rd.readLength; |
| } |
| else { |
| // TODO: Indicate we could not transfer result into buffer |
| LOG_E( |
| "kSE05x_I2CM_Read: Expecting more data (%d) than " |
| "was received", |
| p[iCnt].cmd.rd.readLength); |
| break; |
| } |
| } |
| } |
| else { |
| break; |
| } |
| // Update parsing position |
| if (rspbufferLen > rspPos + 2u) { |
| rspTag = &rspbuffer[rspPos + 1]; |
| rspPos += 2; |
| } |
| } |
| // If we dropped out before handling all tags, clear the tagtype of the tags |
| // that were not handled |
| for (remainingCnt = iCnt + 1; remainingCnt < noOftags; remainingCnt++) { |
| p[remainingCnt].type = kSE05x_I2CM_None; |
| } |
| } |
| |
| cleanup: |
| return retval; |
| } |
| |
| smStatus_t Se05x_i2c_master_attst_txn(sss_session_t *sess, |
| sss_object_t *keyObject, |
| SE05x_I2CM_cmd_t *p, |
| uint8_t *random_attst, |
| size_t random_attstLen, |
| SE05x_AttestationAlgo_t attst_algo, |
| SE05x_TimeStamp_t *ptimeStamp, |
| size_t *timeStampLen, |
| uint8_t *freshness, |
| size_t *pfreshnessLen, |
| uint8_t *chipId, |
| size_t *pchipIdLen, |
| uint8_t *signature, |
| size_t *psignatureLen, |
| uint8_t noOftags) |
| { |
| smStatus_t retval = SM_NOT_OK; |
| uint8_t buffer[SE05X_I2CM_MAX_BUF_SIZE_CMD] = {0}; |
| size_t bufferLen = 0; |
| uint8_t iCnt = 0; |
| uint8_t remainingCnt = 0; |
| int tlvRet = 0; |
| uint8_t rspbuffer[SE05X_I2CM_MAX_BUF_SIZE_RSP] = {0}; |
| size_t rspbufferLen = sizeof(rspbuffer); |
| uint32_t attestID; |
| |
| sss_se05x_session_t *se05x_session = (sss_se05x_session_t *)sess; |
| Se05xSession_t *se050session_id = NULL; |
| |
| sss_se05x_object_t *keyObject_attst = (sss_se05x_object_t *)keyObject; |
| attestID = keyObject_attst->keyId; |
| |
| uint8_t *pCmdbuf = &buffer[0]; |
| const uint8_t *pSendbuf = &buffer[0]; |
| size_t SendLen = 0; |
| |
| if (se05x_session->subsystem == kType_SSS_SE_SE05x) { |
| se050session_id = &se05x_session->s_ctx; |
| } |
| else { |
| goto cleanup; |
| } |
| |
| for (iCnt = 0; iCnt < noOftags; iCnt++) { |
| if (p[iCnt].type == kSE05x_I2CM_Configure) { |
| uint8_t configBuf[2] = {0}; |
| size_t configBufLen = sizeof(configBuf); |
| configBuf[0] = p[iCnt].cmd.cfg.I2C_addr; |
| configBuf[1] = p[iCnt].cmd.cfg.I2C_baudRate; |
| tlvRet = TLVSET_u8buf_I2CM( |
| "I2CM Configure", &pCmdbuf, &bufferLen, kSE05x_TAG_I2CM_Config, configBuf, configBufLen); |
| if (0 != tlvRet) { |
| goto cleanup; |
| } |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Write) { |
| tlvRet = TLVSET_u8buf_I2CM("I2CM Write", |
| &pCmdbuf, |
| &bufferLen, |
| kSE05x_TAG_I2CM_Write, |
| p[iCnt].cmd.w.writebuf, |
| p[iCnt].cmd.w.writeLength); |
| if (0 != tlvRet) { |
| goto cleanup; |
| } |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Read) { |
| uint8_t readLenBuf[2]; |
| size_t readLenBufLen = sizeof(readLenBuf); |
| readLenBuf[0] = (uint8_t)(p[iCnt].cmd.rd.readLength >> 8); |
| readLenBuf[1] = (uint8_t)(p[iCnt].cmd.rd.readLength); |
| tlvRet = |
| TLVSET_u8buf_I2CM("I2CM Read", &pCmdbuf, &bufferLen, kSE05x_TAG_I2CM_Read, readLenBuf, readLenBufLen); |
| if (0 != tlvRet) { |
| goto cleanup; |
| } |
| } |
| else { |
| break; |
| } |
| } |
| *timeStampLen = sizeof(SE05x_TimeStamp_t); |
| SendLen = bufferLen; |
| retval = Se05x_API_I2CM_ExecuteCommandSet(se050session_id, |
| pSendbuf, |
| SendLen, |
| attestID, |
| attst_algo, |
| rspbuffer, |
| &rspbufferLen, |
| ptimeStamp, |
| freshness, |
| pfreshnessLen, |
| chipId, |
| pchipIdLen, |
| signature, |
| psignatureLen, |
| random_attst, |
| random_attstLen); |
| |
| if (retval == SM_OK) { |
| // Walk through the result. |
| // In principle the order of results matches the order the incoming commands. |
| // Exception: Structural error in format incoming commands |
| uint8_t *rspTag = &rspbuffer[0]; |
| unsigned int rspPos = 1u; |
| for (iCnt = 0; iCnt < noOftags; iCnt++) { |
| if (*rspTag == kSE05x_I2CM_StructuralIssue) { |
| // Modify TLV type of command to report back error |
| p[iCnt].type = kSE05x_I2CM_StructuralIssue; |
| p[iCnt].cmd.issue.issueStatus = rspbuffer[rspPos]; |
| break; |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Configure) { |
| // Check whether response is in expected order |
| if (*rspTag != p[iCnt].type) { |
| LOG_W("Response out-of-order"); |
| break; |
| } |
| p[iCnt].cmd.cfg.status = rspbuffer[rspPos]; |
| } |
| //else if (p[iCnt].type == kSE05x_I2CM_Security) { |
| //} |
| else if (p[iCnt].type == kSE05x_I2CM_Write) { |
| // Check whether response is in expected order |
| if (*rspTag != p[iCnt].type) { |
| LOG_W("Response out-of-order"); |
| break; |
| } |
| p[iCnt].cmd.w.wrStatus = rspbuffer[rspPos]; |
| } |
| else if (p[iCnt].type == kSE05x_I2CM_Read) { |
| // Check whether response is in expected order |
| if (*rspTag != p[iCnt].type) { |
| LOG_W("Response out-of-order"); |
| break; |
| } |
| p[iCnt].cmd.rd.rdStatus = rspbuffer[rspPos]; |
| if (p[iCnt].cmd.rd.rdStatus == kSE05x_I2CM_Success) { |
| // Receiving less data than requested is not considered an error |
| uint16_t reportedRead = (rspbuffer[rspPos + 1] << 8) + rspbuffer[rspPos + 2]; |
| rspPos += 2; |
| if (reportedRead < p[iCnt].cmd.rd.readLength) { |
| LOG_W("kSE05x_I2CM_Read: Requested %d, Received %d byte", |
| p[iCnt].cmd.rd.readLength, |
| reportedRead); |
| p[iCnt].cmd.rd.readLength = reportedRead; |
| } |
| // Did we receive enough data? |
| if (rspbufferLen > (rspPos + p[iCnt].cmd.rd.readLength)) { |
| memcpy(p[iCnt].cmd.rd.rdBuf, &rspbuffer[rspPos + 1], p[iCnt].cmd.rd.readLength); |
| rspPos += p[iCnt].cmd.rd.readLength; |
| } |
| else { |
| // TODO: Indicate we could not transfer result into buffer |
| LOG_E( |
| "kSE05x_I2CM_Read: Expecting more data (%d) than " |
| "was received", |
| p[iCnt].cmd.rd.readLength); |
| break; |
| } |
| } |
| } |
| else { |
| break; |
| } |
| // Update parsing position |
| if (rspbufferLen > rspPos + 2u) { |
| rspTag = &rspbuffer[rspPos + 1]; |
| rspPos += 2; |
| } |
| } |
| // If we dropped out before handling all tags, clear the tagtype of the tags |
| // that were not handled |
| for (remainingCnt = iCnt + 1; remainingCnt < noOftags; remainingCnt++) { |
| p[remainingCnt].type = kSE05x_I2CM_None; |
| } |
| } |
| |
| cleanup: |
| return retval; |
| } |
| |
| #endif /* SSS_HAVE_APPLET_SE05X_IOT */ |
