From c85f8ccdbec93cb72dd3e21e39b5aac28a572b27 Mon Sep 17 00:00:00 2001 From: bvenkateswarlu Date: Wed, 15 Apr 2020 20:35:49 +0100 Subject: [PATCH 01/13] Integrated getHmacParameters and computeHmacParameters --- HAL/keymaster/4.1/CborConverter.cpp | 34 ++++++----- .../4.1/JavacardKeymaster4Device.cpp | 57 +++++++++++++++---- HAL/keymaster/include/CborConverter.h | 1 + 3 files changed, 67 insertions(+), 25 deletions(-) diff --git a/HAL/keymaster/4.1/CborConverter.cpp b/HAL/keymaster/4.1/CborConverter.cpp index 2e1c9b26..7b22b550 100644 --- a/HAL/keymaster/4.1/CborConverter.cpp +++ b/HAL/keymaster/4.1/CborConverter.cpp @@ -24,17 +24,15 @@ using namespace cppbor; #define UNUSED(A) A = A -HardwareAuthenticatorType convertToHardwareAuthenticatorType(uint64_t val) { - switch (static_cast(val)) { - case HardwareAuthenticatorType::NONE: - return HardwareAuthenticatorType::NONE; - case HardwareAuthenticatorType::PASSWORD: - return HardwareAuthenticatorType::PASSWORD; - case HardwareAuthenticatorType::FINGERPRINT: - return HardwareAuthenticatorType::FINGERPRINT; - case HardwareAuthenticatorType::ANY: - return HardwareAuthenticatorType::ANY; - } +namespace { +template +inline T legacyEnumConversion(const unint64_t val) { + return static_cast(val); +} + +} +ErrorCode convertToErrorcode(uint64_t val) { + } bool convertToTag(uint64_t val, Tag& tag) { @@ -144,12 +142,12 @@ bool CborConverter::getHardwareAuthToken(const std::unique_ptr& item, cons uint64_t authType; if (!getUint64(item, pos+3, authType)) return ret; - token.authenticatorType = convertToHardwareAuthenticatorType(authType); + token.authenticatorType = legacyEnumConversion(authType); //Timestamp if (!getUint64(item, pos+4, token.timestamp)) return ret; //MAC - if (!getBinaryArray(item, pos + 5, mac)) + if (!getBinaryArray(item, pos+5, mac)) return ret; token.mac.setToExternal(mac.data(), mac.size()); ret = true; @@ -175,3 +173,13 @@ bool CborConverter::getKeyParameters(const std::unique_ptr& item, const ui return ret; } +bool CborConverter::getErrorCode(const std::unique_ptr& item, const uint32_t pos, ErrorCode& errorCode) { + bool ret = false; + uint64_t errorVal; + if (!getUint64(item, pos, errorVal)) + return ret; + errorCode = legacyEnumConversion(errorVal); + ret = true; + return ret; +} + diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index e8abdca3..afaa4d45 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -16,22 +16,27 @@ */ #define LOG_TAG "android.hardware.keymaster@4.1-service.javacard" - +#include +#include +#include #include #include #include #include +#include "../include/JavacardKeymaster4Device.h" -/* TODO Remove below UNUSED */ -#define UNUSED(a) a=a +#define UNUSED(a) a=a /* TODO Remove UNUSED. Added temporarily to solve compilation errors. */ +#define JAVACARD_KEYMASTER_NAME "JavacardKeymaster4.1Device v0.1" +#define JAVACARD_KEYMASTER_AUTHOR "Android Open Source Project" namespace android { namespace hardware { namespace keymaster { namespace V4_1 { -JavacardKeymaster4Device::JavacardKeymaster4Device() { - // TODO +JavacardKeymaster4Device::JavacardKeymaster4Device() + : cborConverter_(new CborConverter()) { + } JavacardKeymaster4Device::~JavacardKeymaster4Device() { @@ -39,21 +44,49 @@ JavacardKeymaster4Device::~JavacardKeymaster4Device() { // Methods from IKeymasterDevice follow. Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_cb) { - _hidl_cb(::android::hardware::keymaster::V4_0::SecurityLevel::STRONGBOX, "JavacardKeymaster4.1Device v0.1", "Android Open Source Project"); + _hidl_cb(SecurityLevel::STRONGBOX, JAVACARD_KEYMASTER_NAME, JAVACARD_KEYMASTER_AUTHOR); return Void(); } Return JavacardKeymaster4Device::getHmacSharingParameters(getHmacSharingParameters_cb _hidl_cb) { - // TODO implement - UNUSED(_hidl_cb); + vec cborData; + CborConverter cc; + ::android::hardware::keymaster::V4_0::HmacSharingParameters hmacSharingParameters; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = 0; + + // TODO Call OMAPI layer and get the Cbor format data. + + auto ctx = cc.decodeData(cborData); + if (ctx != null) { + cc.getErrorCode(ctx, 0, errorCode); //Error Code + cc.getHmacSharingParameters(ctx, 1, hmacSharingParameters); //HmacSharingParameters. + _hidl_cb(errorCode, hmacSharingParameters); + } return Void(); } Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::android::hardware::keymaster::V4_0::HmacSharingParameters>& params, computeSharedHmac_cb _hidl_cb) { - // TODO implement - size_t size = params.size(); - UNUSED(size); - UNUSED(_hidl_cb); + Array array; + CborConverter cc; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = 0; + for(size_t i = 0; i < params.size(); ++i) { + array.add(params[i].seed); + array.add(params[i].nonce); + } + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + auto ctx = cc.decodeData(cborOutData); /* TODO Is this separate API required */ + if (ctx != null) { + std::vector bstr; + hidl_vec sharingCheck; + cc.getErrorCode(ctx, 0, errorCode); //Error Code + cc.getBinaryArray(ctx, 1, bstr); + sharingCheck.setToExternal(bstr.data(), bstr.size()); + _hidl_cb(errorCode, sharingCheck); + } return Void(); } diff --git a/HAL/keymaster/include/CborConverter.h b/HAL/keymaster/include/CborConverter.h index eae9f4e3..81eb5eaa 100644 --- a/HAL/keymaster/include/CborConverter.h +++ b/HAL/keymaster/include/CborConverter.h @@ -60,6 +60,7 @@ class CborConverter bool getBinaryArray(const std::unique_ptr& item, const uint32_t pos, std::vector& vec); bool getHardwareAuthToken(const std::unique_ptr& item, const uint32_t pos, HardwareAuthToken& authType); bool getKeyParameters(const std::unique_ptr& item, const uint32_t pos, std::vector keyParams); + bool getErrorCode(const std::unique_ptr& item, const uint32_t pos, ErrorCode& errorCode); private: From fdf170106cc91ab38013a9a16320548111bc52f9 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Fri, 17 Apr 2020 14:56:19 +0530 Subject: [PATCH 02/13] Implemented getHamcSharingParameters, computeSharedHmac and verifyAuthorization APIs --- HAL/keymaster/4.1/CborConverter.cpp | 150 +++++++++++++----- .../4.1/JavacardKeymaster4Device.cpp | 84 ++++++---- HAL/keymaster/include/CborConverter.h | 8 +- 3 files changed, 170 insertions(+), 72 deletions(-) diff --git a/HAL/keymaster/4.1/CborConverter.cpp b/HAL/keymaster/4.1/CborConverter.cpp index 7b22b550..ccab26fc 100644 --- a/HAL/keymaster/4.1/CborConverter.cpp +++ b/HAL/keymaster/4.1/CborConverter.cpp @@ -19,44 +19,14 @@ #include #include #include +#include #include using namespace cppbor; +using ::android::hardware::keymaster::V4_0::KeyParameter; +using ::android::hardware::keymaster::V4_0::TagType; #define UNUSED(A) A = A -namespace { -template -inline T legacyEnumConversion(const unint64_t val) { - return static_cast(val); -} - -} -ErrorCode convertToErrorcode(uint64_t val) { - -} - -bool convertToTag(uint64_t val, Tag& tag) { - UNUSED(tag); - UNUSED(val); -#if 0 - switch (static_cast(val)) { - case TAG::ABC: - tag = TAG::ABC; - break; - case TAG::DEF: - tag = TAG::DEF; - break; - case TAG::GHI: - tag = TAG::GHI; - break; - default: - return false; - } - return true; -#endif - return false; -} - bool getTagValue(Tag& tag, KeyParameter& keyParam, uint64_t& value) { UNUSED(value); UNUSED(keyParam); @@ -64,6 +34,41 @@ bool getTagValue(Tag& tag, KeyParameter& keyParam, uint64_t& value) { return false; } +bool CborConverter::addKeyparameters(Array& array, const android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams) { + Map map; + for(size_t i = 0; i < keyParams.size(); i++) { + KeyParameter param = keyParams[i]; + TagType tagType = static_cast(param.tag & (0xF << 28)); + switch(tagType) { + case TagType::ENUM: + case TagType::ENUM_REP: + case TagType::UINT: + case TagType::UINT_REP: + map.add(static_cast(param.tag), param.f.integer); + break; + case TagType::ULONG: + case TagType::ULONG_REP: + map.add(static_cast(param.tag), param.f.longInteger); + break; + case TagType::DATE: + map.add(static_cast(param.tag), param.f.dateTime); + break; + case TagType::BOOL: + map.add(static_cast(param.tag), param.f.boolValue); + break; + case TagType::BIGNUM: + case TagType::BYTES: + map.add(static_cast(param.tag), (std::vector(param.blob))); + break; + default: + /* Invalid skip */ + break; + } + } + array.add(std::move(map)); + return true; +} + bool CborConverter::getKeyparameter(const std::pair&, const std::unique_ptr&> pair, KeyParameter& keyParam) { bool ret = false; @@ -72,21 +77,38 @@ bool CborConverter::getKeyparameter(const std::pair& if (!getUint64(pair.first, 0, value)) { return ret; } - if (!convertToTag(value, keyParam.tag)) return false; + keyParam.tag = static_cast(value); if (MajorType::UINT == getType(pair.second)) { - if (!getUint64(pair.second, 0, value)) { - return ret; + TagType tagType = static_cast(keyParam.tag & (0xF << 28)); + switch(tagType) { + case TagType::ENUM: + case TagType::ENUM_REP: + case TagType::UINT: + case TagType::UINT_REP: + keyParam.f.integer = static_cast(value); + break; + case TagType::ULONG: + case TagType::ULONG_REP: + keyParam.f.longInteger = static_cast(value); + break; + case TagType::DATE: + keyParam.f.dateTime = static_cast(value); + break; + case TagType::BOOL: + keyParam.f.boolValue = static_cast(value); + break; + default: + /* Invalid skip */ + break; } - /* TODO*/ - //Convert value to corresponding enum and assign to keyParam.f } else if (MajorType::BSTR == getType(pair.second)) { - std::vector blob; + std::vector blob; if (!getBinaryArray(pair.second, 0, blob)) { return ret; } - keyParam.blob.setToExternal(blob.data(), blob.size()); + keyParam.blob.setToExternal(blob.data(), blob.size()); } return ret; } @@ -126,6 +148,17 @@ bool CborConverter::getHmacSharingParameters(const std::unique_ptr& item, return ret; } +bool CborConverter::addHardwareAuthToken(Array& array, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& +authToken) { + array.add(authToken.challenge); + array.add(authToken.userId); + array.add(authToken.authenticatorId); + array.add(static_cast(authToken.authenticatorType)); + array.add(authToken.timestamp); + array.add((std::vector(authToken.mac))); + return true; +} + bool CborConverter::getHardwareAuthToken(const std::unique_ptr& item, const uint32_t pos, HardwareAuthToken& token) { bool ret = false; std::vector mac; @@ -142,7 +175,7 @@ bool CborConverter::getHardwareAuthToken(const std::unique_ptr& item, cons uint64_t authType; if (!getUint64(item, pos+3, authType)) return ret; - token.authenticatorType = legacyEnumConversion(authType); + token.authenticatorType = static_cast(authType); //Timestamp if (!getUint64(item, pos+4, token.timestamp)) return ret; @@ -154,6 +187,39 @@ bool CborConverter::getHardwareAuthToken(const std::unique_ptr& item, cons return ret; } +bool CborConverter::getVerificationToken(const std::unique_ptr& item, const uint32_t pos, VerificationToken& +token) { + bool ret = false; + std::vector mac; + //challenge + if (!getUint64(item, pos, token.challenge)) + return ret; + + //timestamp + if (!getUint64(item, pos+1, token.timestamp)) + return ret; + + //List of KeyParameters + std::vector keyParams; + if (!getKeyParameters(item, pos+2, keyParams)) + return ret; + token.parametersVerified.setToExternal(keyParams.data(), keyParams.size()); + + //AuthenticatorId + uint64_t val; + if (!getUint64(item, pos+3, val)) + return ret; + token.securityLevel = static_cast(val); + + //MAC + if (!getBinaryArray(item, pos+4, mac)) + return ret; + token.mac.setToExternal(mac.data(), mac.size()); + ret = true; + return ret; + +} + bool CborConverter::getKeyParameters(const std::unique_ptr& item, const uint32_t pos, std::vector keyParams) { bool ret = false; const std::unique_ptr& mapItem = getItemAtPos(item, pos); @@ -178,7 +244,7 @@ bool CborConverter::getErrorCode(const std::unique_ptr& item, const uint32 uint64_t errorVal; if (!getUint64(item, pos, errorVal)) return ret; - errorCode = legacyEnumConversion(errorVal); + errorCode = static_cast(errorVal); ret = true; return ret; } diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index afaa4d45..027f8232 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -23,7 +23,9 @@ #include #include #include -#include "../include/JavacardKeymaster4Device.h" +#include +#include +#include #define UNUSED(a) a=a /* TODO Remove UNUSED. Added temporarily to solve compilation errors. */ #define JAVACARD_KEYMASTER_NAME "JavacardKeymaster4.1Device v0.1" @@ -34,8 +36,7 @@ namespace hardware { namespace keymaster { namespace V4_1 { -JavacardKeymaster4Device::JavacardKeymaster4Device() - : cborConverter_(new CborConverter()) { +JavacardKeymaster4Device::JavacardKeymaster4Device() { } @@ -49,55 +50,80 @@ Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_ } Return JavacardKeymaster4Device::getHmacSharingParameters(getHmacSharingParameters_cb _hidl_cb) { - vec cborData; - CborConverter cc; + std::vector cborData; + const uint8_t* pos; + std::unique_ptr item; + std::string message; ::android::hardware::keymaster::V4_0::HmacSharingParameters hmacSharingParameters; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = 0; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; // TODO Call OMAPI layer and get the Cbor format data. - auto ctx = cc.decodeData(cborData); - if (ctx != null) { - cc.getErrorCode(ctx, 0, errorCode); //Error Code - cc.getHmacSharingParameters(ctx, 1, hmacSharingParameters); //HmacSharingParameters. - _hidl_cb(errorCode, hmacSharingParameters); + std::tie(item, pos, message) = parse(cborData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Error Code + cborConverter_.getHmacSharingParameters(item, 1, hmacSharingParameters); //HmacSharingParameters. } + _hidl_cb(errorCode, hmacSharingParameters); return Void(); } Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::android::hardware::keymaster::V4_0::HmacSharingParameters>& params, computeSharedHmac_cb _hidl_cb) { - Array array; - CborConverter cc; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = 0; + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec sharingCheck; + + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + std::vector tempVec; for(size_t i = 0; i < params.size(); ++i) { - array.add(params[i].seed); - array.add(params[i].nonce); + array.add(static_cast>(params[i].seed)); + for(size_t j = 0; i < params[j].nonce.size(); j++) { + tempVec.push_back(params[i].nonce[j]); + } + array.add(tempVec); + tempVec.clear(); } std::vector cborData = array.encode(); // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. std::vector cborOutData; /*Received from OMAPI */ - auto ctx = cc.decodeData(cborOutData); /* TODO Is this separate API required */ - if (ctx != null) { + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { std::vector bstr; - hidl_vec sharingCheck; - cc.getErrorCode(ctx, 0, errorCode); //Error Code - cc.getBinaryArray(ctx, 1, bstr); + cborConverter_.getErrorCode(item, 0, errorCode); //Error Code + cborConverter_.getBinaryArray(item, 1, bstr); sharingCheck.setToExternal(bstr.data(), bstr.size()); - _hidl_cb(errorCode, sharingCheck); } + _hidl_cb(errorCode, sharingCheck); return Void(); } Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& parametersToVerify, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, verifyAuthorization_cb _hidl_cb) { - // TODO implement - UNUSED(operationHandle); - size_t size = parametersToVerify.size(); - UNUSED(size); - uint64_t challenge = authToken.challenge; - UNUSED(challenge); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::keymaster::V4_0::VerificationToken verificationToken; + + /* Convert input data to cbor format */ + array.add(operationHandle); + cborConverter_.addKeyparameters(array, parametersToVerify); + cborConverter_.addHardwareAuthToken(array, authToken); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getVerificationToken(item, 1, verificationToken); + } + _hidl_cb(errorCode, verificationToken); return Void(); } diff --git a/HAL/keymaster/include/CborConverter.h b/HAL/keymaster/include/CborConverter.h index 81eb5eaa..2e4ba890 100644 --- a/HAL/keymaster/include/CborConverter.h +++ b/HAL/keymaster/include/CborConverter.h @@ -26,6 +26,7 @@ #include #include #include +#include #include #define EMPTY(A) *(A*)nullptr @@ -61,7 +62,12 @@ class CborConverter bool getHardwareAuthToken(const std::unique_ptr& item, const uint32_t pos, HardwareAuthToken& authType); bool getKeyParameters(const std::unique_ptr& item, const uint32_t pos, std::vector keyParams); bool getErrorCode(const std::unique_ptr& item, const uint32_t pos, ErrorCode& errorCode); - + bool addKeyparameters(Array& array, const android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& + keyParams); +bool addHardwareAuthToken(Array& array, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& +authToken); +bool getVerificationToken(const std::unique_ptr& item, const uint32_t pos, VerificationToken& +token); private: inline MajorType getType(const std::unique_ptr &item) { return item.get()->type(); } From 47d07c26694aca66c70f5a503a8d6e4f0e731cff Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Sat, 18 Apr 2020 03:33:47 +0530 Subject: [PATCH 03/13] Completed conversion from hidl to cbor and cbor back to hidl types. --- HAL/keymaster/4.1/CborConverter.cpp | 97 ++-- .../4.1/JavacardKeymaster4Device.cpp | 447 ++++++++++++++---- HAL/keymaster/include/CborConverter.h | 100 ++-- 3 files changed, 478 insertions(+), 166 deletions(-) diff --git a/HAL/keymaster/4.1/CborConverter.cpp b/HAL/keymaster/4.1/CborConverter.cpp index ccab26fc..7e321766 100644 --- a/HAL/keymaster/4.1/CborConverter.cpp +++ b/HAL/keymaster/4.1/CborConverter.cpp @@ -45,32 +45,48 @@ bool CborConverter::addKeyparameters(Array& array, const android::hardware::hidl case TagType::UINT: case TagType::UINT_REP: map.add(static_cast(param.tag), param.f.integer); - break; + break; case TagType::ULONG: case TagType::ULONG_REP: map.add(static_cast(param.tag), param.f.longInteger); - break; + break; case TagType::DATE: map.add(static_cast(param.tag), param.f.dateTime); - break; + break; case TagType::BOOL: map.add(static_cast(param.tag), param.f.boolValue); - break; + break; case TagType::BIGNUM: case TagType::BYTES: map.add(static_cast(param.tag), (std::vector(param.blob))); break; default: - /* Invalid skip */ - break; + /* Invalid skip */ + break; } } array.add(std::move(map)); return true; } +bool CborConverter::getKeyCharacteristics(const std::unique_ptr &item, const uint32_t pos, + ::android::hardware::keymaster::V4_0::KeyCharacteristics& keyCharacteristics) { + bool ret = false; + + if (!getKeyParameters(item, pos, keyCharacteristics.softwareEnforced)) { + return ret; + } + + if (!getKeyParameters(item, pos+1, keyCharacteristics.hardwareEnforced)) { + return ret; + } + //success + ret = true; + return ret; +} + bool CborConverter::getKeyparameter(const std::pair&, - const std::unique_ptr&> pair, KeyParameter& keyParam) { + const std::unique_ptr&> pair, KeyParameter& keyParam) { bool ret = false; uint64_t value; //TAG will be always uint32_t @@ -87,20 +103,20 @@ bool CborConverter::getKeyparameter(const std::pair& case TagType::UINT: case TagType::UINT_REP: keyParam.f.integer = static_cast(value); - break; + break; case TagType::ULONG: case TagType::ULONG_REP: keyParam.f.longInteger = static_cast(value); - break; + break; case TagType::DATE: keyParam.f.dateTime = static_cast(value); - break; + break; case TagType::BOOL: keyParam.f.boolValue = static_cast(value); - break; + break; default: - /* Invalid skip */ - break; + /* Invalid skip */ + break; } } else if (MajorType::BSTR == getType(pair.second)) { @@ -117,6 +133,24 @@ ParseResult CborConverter::decodeData(const std::vector cborData) { return parse(cborData); } +bool CborConverter::getMultiBinaryArray(const std::unique_ptr& item, const uint32_t pos, + ::android::hardware::hidl_vec<::android::hardware::hidl_vec>& data) { + bool ret = false; + const std::unique_ptr& arrayItem = getItemAtPos(item, pos); + if ((arrayItem == nullptr) && (MajorType::ARRAY != getType(arrayItem))) + return ret; + const Array* arr = arrayItem.get()->asArray(); + size_t arrSize = arr->size(); + for (int i = 0; i < arrSize; i++) { + std::vector innerData; + if (!getBinaryArray(arrayItem, i, innerData)) + return ret; + data[i].setToExternal(innerData.data(), innerData.size()); + } + ret = true; // success + return ret; +} + bool CborConverter::getBinaryArray(const std::unique_ptr& item, const uint32_t pos, std::vector& value) { bool ret = false; const std::unique_ptr& strItem = getItemAtPos(item, pos); @@ -148,8 +182,18 @@ bool CborConverter::getHmacSharingParameters(const std::unique_ptr& item, return ret; } +bool CborConverter::addVerificationToken(Array& array, const ::android::hardware::keymaster::V4_0::VerificationToken& + verificationToken) { + array.add(verificationToken.challenge); + array.add(verificationToken.timestamp); + addKeyparameters(array, verificationToken.parametersVerified); + array.add(static_cast(verificationToken.securityLevel)); + array.add((std::vector(verificationToken.mac))); + return true; +} + bool CborConverter::addHardwareAuthToken(Array& array, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& -authToken) { + authToken) { array.add(authToken.challenge); array.add(authToken.userId); array.add(authToken.authenticatorId); @@ -188,7 +232,7 @@ bool CborConverter::getHardwareAuthToken(const std::unique_ptr& item, cons } bool CborConverter::getVerificationToken(const std::unique_ptr& item, const uint32_t pos, VerificationToken& -token) { + token) { bool ret = false; std::vector mac; //challenge @@ -200,17 +244,15 @@ token) { return ret; //List of KeyParameters - std::vector keyParams; - if (!getKeyParameters(item, pos+2, keyParams)) + if (!getKeyParameters(item, pos+2, token.parametersVerified)) return ret; - token.parametersVerified.setToExternal(keyParams.data(), keyParams.size()); //AuthenticatorId uint64_t val; if (!getUint64(item, pos+3, val)) return ret; token.securityLevel = static_cast(val); - + //MAC if (!getBinaryArray(item, pos+4, mac)) return ret; @@ -220,7 +262,7 @@ token) { } -bool CborConverter::getKeyParameters(const std::unique_ptr& item, const uint32_t pos, std::vector keyParams) { +bool CborConverter::getKeyParameters(const std::unique_ptr& item, const uint32_t pos, android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams) { bool ret = false; const std::unique_ptr& mapItem = getItemAtPos(item, pos); if ((mapItem == nullptr) && (MajorType::MAP != getType(mapItem))) @@ -229,23 +271,12 @@ bool CborConverter::getKeyParameters(const std::unique_ptr& item, const ui const Map* map = mapItem.get()->asMap(); size_t mapSize = map->size(); for (int i = 0; i < mapSize; i++) { - KeyParameter param; + ::android::hardware::keymaster::V4_0::KeyParameter param; if (!getKeyparameter((*map)[i], param)) { return ret; } - keyParams.push_back(param); + keyParams[i] = std::move(param); } ret = true; return ret; } - -bool CborConverter::getErrorCode(const std::unique_ptr& item, const uint32_t pos, ErrorCode& errorCode) { - bool ret = false; - uint64_t errorVal; - if (!getUint64(item, pos, errorVal)) - return ret; - errorCode = static_cast(errorVal); - ret = true; - return ret; -} - diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index 027f8232..b08ecc1b 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -79,11 +79,11 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi std::vector tempVec; for(size_t i = 0; i < params.size(); ++i) { array.add(static_cast>(params[i].seed)); - for(size_t j = 0; i < params[j].nonce.size(); j++) { - tempVec.push_back(params[i].nonce[j]); - } + for(size_t j = 0; i < params[j].nonce.size(); j++) { + tempVec.push_back(params[i].nonce[j]); + } array.add(tempVec); - tempVec.clear(); + tempVec.clear(); } std::vector cborData = array.encode(); @@ -128,155 +128,414 @@ Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHan } Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::addRngEntropy(const hidl_vec& data) { - // TODO implement - size_t size = data.size(); - UNUSED(size); - return ::android::hardware::keymaster::V4_0::ErrorCode {}; + const uint8_t* pos; + cppbor::Array array; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + /* Convert input data to cbor format */ + array.add(std::vector(data)); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } + return errorCode; } Return JavacardKeymaster4Device::generateKey(const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams, generateKey_cb _hidl_cb) { - // TODO implement - UNUSED(_hidl_cb); - size_t size = keyParams.size(); - UNUSED(size); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec keyBlob; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + + cborConverter_.addKeyparameters(array, keyParams); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + keyBlob.setToExternal(bstr.data(), bstr.size()); + cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + } + _hidl_cb(errorCode, keyBlob, keyCharacteristics); return Void(); } Return JavacardKeymaster4Device::importKey(const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams, ::android::hardware::keymaster::V4_0::KeyFormat keyFormat, const hidl_vec& keyData, importKey_cb _hidl_cb) { - // TODO implement - size_t size = keyParams.size(); - size = keyData.size(); - UNUSED(size); - UNUSED(keyFormat); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec keyBlob; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + + cborConverter_.addKeyparameters(array, keyParams); + array.add(static_cast(keyFormat)); + array.add(std::vector(keyData)); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + keyBlob.setToExternal(bstr.data(), bstr.size()); + cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + } + _hidl_cb(errorCode, keyBlob, keyCharacteristics); return Void(); } Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& wrappedKeyData, const hidl_vec& wrappingKeyBlob, const hidl_vec& maskingKey, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& unwrappingParams, uint64_t passwordSid, uint64_t biometricSid, importWrappedKey_cb _hidl_cb) { - // TODO implement - size_t size = wrappedKeyData.size(); - size = wrappingKeyBlob.size(); - size = maskingKey.size(); - size = unwrappingParams.size(); - UNUSED(size); - UNUSED(passwordSid); - UNUSED(biometricSid); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec keyBlob; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + + array.add(std::vector(wrappedKeyData)); + array.add(std::vector(wrappingKeyBlob)); + array.add(std::vector(maskingKey)); + cborConverter_.addKeyparameters(array, unwrappingParams); + array.add(passwordSid); + array.add(biometricSid); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + keyBlob.setToExternal(bstr.data(), bstr.size()); + cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + } + _hidl_cb(errorCode, keyBlob, keyCharacteristics); + return Void(); } Return JavacardKeymaster4Device::getKeyCharacteristics(const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, getKeyCharacteristics_cb _hidl_cb) { - // TODO implement - size_t size = keyBlob.size(); - size = clientId.size(); - size = appData.size(); - UNUSED(size); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + + array.add(std::vector(keyBlob)); + array.add(std::vector(clientId)); + array.add(std::vector(appData)); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyCharacteristics(item, 1, keyCharacteristics); + } + _hidl_cb(errorCode, keyCharacteristics); return Void(); } Return JavacardKeymaster4Device::exportKey(::android::hardware::keymaster::V4_0::KeyFormat keyFormat, const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, exportKey_cb _hidl_cb) { - // TODO implement - size_t size = clientId.size(); - size = keyBlob.size(); - size = appData.size(); - UNUSED(size); - UNUSED(keyFormat); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec keyMaterial; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + array.add(static_cast(keyFormat)); + array.add(std::vector(keyBlob)); + array.add(std::vector(clientId)); + array.add(std::vector(appData)); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + keyMaterial.setToExternal(bstr.data(), bstr.size()); + } + _hidl_cb(errorCode, keyMaterial); return Void(); } Return JavacardKeymaster4Device::attestKey(const hidl_vec& keyToAttest, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& attestParams, attestKey_cb _hidl_cb) { - // TODO implement - size_t size = attestParams.size(); - size = keyToAttest.size(); - UNUSED(size); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec keyBlob; + ::android::hardware::hidl_vec<::android::hardware::hidl_vec> certChain; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + array.add(std::vector(keyToAttest)); + cborConverter_.addKeyparameters(array, attestParams); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getMultiBinaryArray(item, 1, certChain); + } + _hidl_cb(errorCode, certChain); return Void(); } Return JavacardKeymaster4Device::upgradeKey(const hidl_vec& keyBlobToUpgrade, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& upgradeParams, upgradeKey_cb _hidl_cb) { - // TODO implement - size_t size = keyBlobToUpgrade.size(); - size = upgradeParams.size(); - UNUSED(size); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + hidl_vec upgradedKeyBlob; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + array.add(std::vector(keyBlobToUpgrade)); + cborConverter_.addKeyparameters(array, upgradeParams); + std::vector cborData = array.encode(); + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + upgradedKeyBlob.setToExternal(bstr.data(), bstr.size()); + } + _hidl_cb(errorCode, upgradedKeyBlob); return Void(); } Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::deleteKey(const hidl_vec& keyBlob) { - // TODO implement - size_t size = keyBlob.size(); - UNUSED(size); - return ::android::hardware::keymaster::V4_0::ErrorCode {}; + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + array.add(std::vector(keyBlob)); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } + return errorCode; } Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::deleteAllKeys() { - // TODO implement - return ::android::hardware::keymaster::V4_0::ErrorCode {}; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } + return errorCode; } Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::destroyAttestationIds() { - // TODO implement - return ::android::hardware::keymaster::V4_0::ErrorCode {}; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } + return errorCode; } Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_0::KeyPurpose purpose, const hidl_vec& keyBlob, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, begin_cb _hidl_cb) { - // TODO implement - UNUSED(purpose); - size_t size = keyBlob.size(); - size = inParams.size(); - UNUSED(size); - uint64_t challenge = authToken.challenge; - UNUSED(challenge); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; + uint64_t operationHandle = 0; + + /* Convert input data to cbor format */ + array.add(static_cast(purpose)); + array.add(std::vector(keyBlob)); + cborConverter_.addKeyparameters(array, inParams); + cborConverter_.addHardwareAuthToken(array, authToken); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyParameters(item, 1, outParams); + cborConverter_.getUint64(item, 2, operationHandle); + } + _hidl_cb(errorCode, outParams, operationHandle); return Void(); } Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const hidl_vec& input, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken, update_cb _hidl_cb) { - // TODO implement - UNUSED(operationHandle); - size_t size = inParams.size(); - size = input.size(); - UNUSED(size); - uint64_t challange = verificationToken.challenge; - challange = authToken.challenge; - UNUSED(challange); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; + uint32_t inputConsumed = 0; + hidl_vec output; + + /* Convert input data to cbor format */ + array.add(operationHandle); + cborConverter_.addKeyparameters(array, inParams); + array.add(std::vector(input)); + cborConverter_.addHardwareAuthToken(array, authToken); + cborConverter_.addVerificationToken(array, verificationToken); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getUint64(item, 1, inputConsumed); + cborConverter_.getKeyParameters(item, 2, outParams); + cborConverter_.getBinaryArray(item, 3, bstr); + output.setToExternal(bstr.data(), bstr.size()); + } + _hidl_cb(errorCode, inputConsumed, outParams, output); return Void(); } Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const hidl_vec& input, const hidl_vec& signature, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken, finish_cb _hidl_cb) { - // TODO implement - UNUSED(operationHandle); - size_t size = inParams.size(); - size = input.size(); - size = signature.size(); - uint64_t challange = authToken.challenge; - challange = verificationToken.challenge; - UNUSED(challange); - UNUSED(_hidl_cb); + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; + hidl_vec output; + + /* Convert input data to cbor format */ + array.add(operationHandle); + cborConverter_.addKeyparameters(array, inParams); + array.add(std::vector(input)); + array.add(std::vector(signature)); + cborConverter_.addHardwareAuthToken(array, authToken); + cborConverter_.addVerificationToken(array, verificationToken); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyParameters(item, 1, outParams); + cborConverter_.getBinaryArray(item, 2, bstr); + output.setToExternal(bstr.data(), bstr.size()); + } + _hidl_cb(errorCode, outParams, output); return Void(); } Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::abort(uint64_t operationHandle) { - // TODO implement - UNUSED(operationHandle); - return ::android::hardware::keymaster::V4_0::ErrorCode {}; + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + + /* Convert input data to cbor format */ + array.add(operationHandle); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode<::android::hardware::keymaster::V4_0::ErrorCode>(item, 0, errorCode); //Errorcode + } + return errorCode; } // Methods from ::android::hardware::keymaster::V4_1::IKeymasterDevice follow. Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device::deviceLocked(bool passwordOnly, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken) { - // TODO implement - UNUSED(passwordOnly); - size_t challenge = verificationToken.challenge; - UNUSED(challenge); - return ::android::hardware::keymaster::V4_1::ErrorCode {}; + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_1::ErrorCode errorCode = ::android::hardware::keymaster::V4_1::ErrorCode::UNKNOWN_ERROR; + + /* Convert input data to cbor format */ + array.add(passwordOnly); + cborConverter_.addVerificationToken(array, verificationToken); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } + return errorCode; } Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device::earlyBootEnded() { - // TODO implement - return ::android::hardware::keymaster::V4_1::ErrorCode {}; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + ::android::hardware::keymaster::V4_1::ErrorCode errorCode = ::android::hardware::keymaster::V4_1::ErrorCode::UNKNOWN_ERROR; + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } + return errorCode; } } // namespace V4_1 diff --git a/HAL/keymaster/include/CborConverter.h b/HAL/keymaster/include/CborConverter.h index 2e4ba890..84e86299 100644 --- a/HAL/keymaster/include/CborConverter.h +++ b/HAL/keymaster/include/CborConverter.h @@ -48,53 +48,75 @@ using ::android::hardware::keymaster::V4_0::VerificationToken; class CborConverter { -public: - CborConverter() = default; - ~CborConverter() = default; - - ParseResult decodeData(const std::vector cborData); - - /* Use this function to get both signed and usinged integers.*/ - template - bool getUint64(const std::unique_ptr& item, const uint32_t pos, T& value); - bool getHmacSharingParameters(const std::unique_ptr& item, const uint32_t pos, HmacSharingParameters& params); - bool getBinaryArray(const std::unique_ptr& item, const uint32_t pos, std::vector& vec); - bool getHardwareAuthToken(const std::unique_ptr& item, const uint32_t pos, HardwareAuthToken& authType); - bool getKeyParameters(const std::unique_ptr& item, const uint32_t pos, std::vector keyParams); - bool getErrorCode(const std::unique_ptr& item, const uint32_t pos, ErrorCode& errorCode); - bool addKeyparameters(Array& array, const android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& - keyParams); -bool addHardwareAuthToken(Array& array, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& -authToken); -bool getVerificationToken(const std::unique_ptr& item, const uint32_t pos, VerificationToken& -token); - -private: - inline MajorType getType(const std::unique_ptr &item) { return item.get()->type(); } - bool getKeyparameter(const std::pair&, - const std::unique_ptr&> pair, KeyParameter& keyParam); - inline const std::unique_ptr& getItemAtPos(const std::unique_ptr& item, const uint32_t pos) { - const Array* arr = nullptr; - - if (MajorType::ARRAY != getType(item)) { - return EMPTY(std::unique_ptr); - } - arr = item.get()->asArray(); - if (arr->size() < (pos + 1)) { - return EMPTY(std::unique_ptr); + public: + CborConverter() = default; + ~CborConverter() = default; + + ParseResult decodeData(const std::vector cborData); + + /* Use this function to get both signed and usinged integers.*/ + template + bool getUint64(const std::unique_ptr& item, const uint32_t pos, T& value); + bool getHmacSharingParameters(const std::unique_ptr& item, const uint32_t pos, HmacSharingParameters& params); + bool getBinaryArray(const std::unique_ptr& item, const uint32_t pos, std::vector& vec); + bool getHardwareAuthToken(const std::unique_ptr& item, const uint32_t pos, HardwareAuthToken& authType); + bool getKeyParameters(const std::unique_ptr& item, const uint32_t pos, android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams); + bool addKeyparameters(Array& array, const android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& + keyParams); + bool addHardwareAuthToken(Array& array, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& + authToken); + bool getVerificationToken(const std::unique_ptr& item, const uint32_t pos, VerificationToken& + token); + bool getKeyCharacteristics(const std::unique_ptr &item, const uint32_t pos, + ::android::hardware::keymaster::V4_0::KeyCharacteristics& keyCharacteristics); + bool getMultiBinaryArray(const std::unique_ptr& item, const uint32_t pos, + ::android::hardware::hidl_vec<::android::hardware::hidl_vec>& data); + bool addVerificationToken(Array& array, const ::android::hardware::keymaster::V4_0::VerificationToken& + verificationToken); + + template) || + (std::is_same_v)>> + inline bool getErrorCode(const std::unique_ptr& item, const uint32_t pos, T& errorCode) { + bool ret = false; + uint64_t errorVal; + if (!getUint64(item, pos, errorVal)) { + return ret; + } + errorCode = static_cast(errorVal); + + ret = true; + return ret; + } + + + + + private: + inline MajorType getType(const std::unique_ptr &item) { return item.get()->type(); } + bool getKeyparameter(const std::pair&, + const std::unique_ptr&> pair, KeyParameter& keyParam); + inline const std::unique_ptr& getItemAtPos(const std::unique_ptr& item, const uint32_t pos) { + const Array* arr = nullptr; + + if (MajorType::ARRAY != getType(item)) { + return EMPTY(std::unique_ptr); + } + arr = item.get()->asArray(); + if (arr->size() < (pos + 1)) { + return EMPTY(std::unique_ptr); + } + return (*arr)[pos]; } - return (*arr)[pos]; - } }; template bool CborConverter::getUint64(const std::unique_ptr& item, const uint32_t pos, T& value) { bool ret = false; const std::unique_ptr& intItem = getItemAtPos(item, pos); - + if ((intItem == nullptr) || - (std::is_unsigned::value && (MajorType::UINT != getType(intItem))) || - ((std::is_signed::value && (MajorType::NINT != getType(intItem))))) { + (std::is_unsigned::value && (MajorType::UINT != getType(intItem))) || + ((std::is_signed::value && (MajorType::NINT != getType(intItem))))) { return ret; } From 1a1ec7c2284f793458b60d498b3ffa7dbba4655b Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Tue, 28 Apr 2020 18:33:28 +0530 Subject: [PATCH 04/13] Modified the ordering HmacSharingParameters and KeyCharacaterstics --- HAL/keymaster/4.1/CborConverter.cpp | 20 +++++++++++++++---- .../4.1/JavacardKeymaster4Device.cpp | 13 +++++++++--- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/HAL/keymaster/4.1/CborConverter.cpp b/HAL/keymaster/4.1/CborConverter.cpp index 7e321766..2679697a 100644 --- a/HAL/keymaster/4.1/CborConverter.cpp +++ b/HAL/keymaster/4.1/CborConverter.cpp @@ -73,11 +73,15 @@ bool CborConverter::getKeyCharacteristics(const std::unique_ptr &item, con ::android::hardware::keymaster::V4_0::KeyCharacteristics& keyCharacteristics) { bool ret = false; - if (!getKeyParameters(item, pos, keyCharacteristics.softwareEnforced)) { + const std::unique_ptr& arrayItem = getItemAtPos(item, pos); + if ((arrayItem == nullptr) && (MajorType::ARRAY != getType(arrayItem))) + return ret; + + if (!getKeyParameters(arrayItem, 0, keyCharacteristics.softwareEnforced)) { return ret; } - if (!getKeyParameters(item, pos+1, keyCharacteristics.hardwareEnforced)) { + if (!getKeyParameters(arrayItem, 1, keyCharacteristics.hardwareEnforced)) { return ret; } //success @@ -169,13 +173,21 @@ bool CborConverter::getBinaryArray(const std::unique_ptr& item, const uint bool CborConverter::getHmacSharingParameters(const std::unique_ptr& item, const uint32_t pos, HmacSharingParameters& params) { std::vector paramValue; bool ret = false; + + //1. Get ArrayItem + //2. First item in the array seed; second item in the array is nonce. + const std::unique_ptr& arrayItem = getItemAtPos(item, pos); + if ((arrayItem == nullptr) && (MajorType::ARRAY != getType(arrayItem))) + return ret; + //Seed - if (!getBinaryArray(item, pos, paramValue)) + if (!getBinaryArray(arrayItem, 0, paramValue)) return ret; params.seed.setToExternal(paramValue.data(), paramValue.size()); paramValue.clear(); + //nonce - if (!getBinaryArray(item, pos+1, paramValue)) + if (!getBinaryArray(arrayItem, 1, paramValue)) return ret; memcpy(params.nonce.data(), paramValue.data(), paramValue.size()); ret = true; diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index b08ecc1b..dd8be396 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -77,14 +77,16 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; std::vector tempVec; + cppbor::Array innerArray; for(size_t i = 0; i < params.size(); ++i) { - array.add(static_cast>(params[i].seed)); + innerArray.add(static_cast>(params[i].seed)); for(size_t j = 0; i < params[j].nonce.size(); j++) { tempVec.push_back(params[i].nonce[j]); } - array.add(tempVec); + innerArray.add(tempVec); tempVec.clear(); } + array.add(std::move(innerArray)); std::vector cborData = array.encode(); // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. @@ -166,6 +168,7 @@ Return JavacardKeymaster4Device::generateKey(const hidl_vec<::android::har if (item != nullptr) { std::vector bstr; cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + /* TODO keyBlob is BSTR */ cborConverter_.getBinaryArray(item, 1, bstr); keyBlob.setToExternal(bstr.data(), bstr.size()); cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); @@ -193,6 +196,7 @@ Return JavacardKeymaster4Device::importKey(const hidl_vec<::android::hardw if (item != nullptr) { std::vector bstr; cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + /* TODO keyBlob is BSTR */ cborConverter_.getBinaryArray(item, 1, bstr); keyBlob.setToExternal(bstr.data(), bstr.size()); cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); @@ -215,12 +219,13 @@ Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& array.add(std::vector(maskingKey)); cborConverter_.addKeyparameters(array, unwrappingParams); array.add(passwordSid); - array.add(biometricSid); + array.add(biometricSid); /* TODO if biometricSid optional if user not sent this don't encode this cbor format */ std::vector cborData = array.encode(); // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. std::vector cborOutData; /*Received from OMAPI */ std::tie(item, pos, message) = parse(cborOutData); if (item != nullptr) { + /* TODO keyBlob is BSTR */ std::vector bstr; cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode cborConverter_.getBinaryArray(item, 1, bstr); @@ -272,6 +277,7 @@ Return JavacardKeymaster4Device::exportKey(::android::hardware::keymaster: std::vector cborOutData; /*Received from OMAPI */ std::tie(item, pos, message) = parse(cborOutData); if (item != nullptr) { + /* TODO Keyblobc - BSTR()*/ std::vector bstr; cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode cborConverter_.getBinaryArray(item, 1, bstr); @@ -319,6 +325,7 @@ Return JavacardKeymaster4Device::upgradeKey(const hidl_vec& keyBl std::vector cborOutData; /*Received from OMAPI */ std::tie(item, pos, message) = parse(cborOutData); if (item != nullptr) { + /* TODO Keyblob BSTR(ARRAY) */ std::vector bstr; cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode cborConverter_.getBinaryArray(item, 1, bstr); From f0ab72e8778218f1ff8eb2f1fec526c571f0f2c0 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Mon, 4 May 2020 22:45:37 +0530 Subject: [PATCH 05/13] Initial implementation of transport library --- .../4.1/JavacardKeymaster4Device.cpp | 49 ++++----- HAL/keymaster/4.1/OmapiTransport.cpp | 57 ++++++++++ HAL/keymaster/4.1/SocketTransport.cpp | 100 ++++++++++++++++++ HAL/keymaster/Android.bp | 58 +++++++++- .../include/JavacardKeymaster4Device.h | 12 ++- HAL/keymaster/include/Transport.h | 62 +++++++++++ HAL/keymaster/include/TransportFactory.h | 63 +++++++++++ 7 files changed, 372 insertions(+), 29 deletions(-) create mode 100644 HAL/keymaster/4.1/OmapiTransport.cpp create mode 100644 HAL/keymaster/4.1/SocketTransport.cpp create mode 100644 HAL/keymaster/include/Transport.h create mode 100644 HAL/keymaster/include/TransportFactory.h diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index dd8be396..2ae12410 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -27,7 +27,6 @@ #include #include -#define UNUSED(a) a=a /* TODO Remove UNUSED. Added temporarily to solve compilation errors. */ #define JAVACARD_KEYMASTER_NAME "JavacardKeymaster4.1Device v0.1" #define JAVACARD_KEYMASTER_AUTHOR "Android Open Source Project" @@ -36,10 +35,6 @@ namespace hardware { namespace keymaster { namespace V4_1 { -JavacardKeymaster4Device::JavacardKeymaster4Device() { - -} - JavacardKeymaster4Device::~JavacardKeymaster4Device() { } @@ -390,29 +385,35 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device } Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_0::KeyPurpose purpose, const hidl_vec& keyBlob, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, begin_cb _hidl_cb) { - cppbor::Array array; - const uint8_t* pos; - std::unique_ptr item; - std::string message; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; uint64_t operationHandle = 0; - /* Convert input data to cbor format */ - array.add(static_cast(purpose)); - array.add(std::vector(keyBlob)); - cborConverter_.addKeyparameters(array, inParams); - cborConverter_.addHardwareAuthToken(array, authToken); - std::vector cborData = array.encode(); - - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getKeyParameters(item, 1, outParams); - cborConverter_.getUint64(item, 2, operationHandle); + if (::android::hardware::keymaster::V4_0::KeyPurpose::ENCRYPT == purpose || + ::android::hardware::keymaster::V4_0::KeyPurpose::VERIFY == purpose) { + /* Public key operations are handled here*/ + } else { + cppbor::Array array; + const uint8_t* pos; + std::unique_ptr item; + std::string message; + + /* Convert input data to cbor format */ + array.add(static_cast(purpose)); + array.add(std::vector(keyBlob)); + cborConverter_.addKeyparameters(array, inParams); + cborConverter_.addHardwareAuthToken(array, authToken); + std::vector cborData = array.encode(); + + // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + + std::vector cborOutData; /*Received from OMAPI */ + std::tie(item, pos, message) = parse(cborOutData); + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyParameters(item, 1, outParams); + cborConverter_.getUint64(item, 2, operationHandle); + } } _hidl_cb(errorCode, outParams, operationHandle); return Void(); diff --git a/HAL/keymaster/4.1/OmapiTransport.cpp b/HAL/keymaster/4.1/OmapiTransport.cpp new file mode 100644 index 00000000..30ec5060 --- /dev/null +++ b/HAL/keymaster/4.1/OmapiTransport.cpp @@ -0,0 +1,57 @@ +/* + ** + ** Copyright 2020, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ +#include +#include +#include +#include +#include +#include +#include "Transport.h" + +#define PORT 8080 +#define IPADDR "10.9.40.24" +#define UNUSED_V(a) a=a + +namespace se_transport { + +bool OmapiTransport::openConnection(connectionCallback cb) { + cb(true); + return true; +} + +bool OmapiTransport::sendData(const char* inData, const uint32_t inLen, responseCallback cb) { + std::vector test(inData, inData+inLen); + cb(test); + return true; + +} + +bool OmapiTransport::sendData(const char* inData, const uint32_t inLen, std::vector& output) { + std::vector test(inData, inData+inLen); + output = std::move(test); + return true; +} + +bool OmapiTransport::closeConnection() { + return true; +} + +bool OmapiTransport::isConnected() { + return true; +} + +} diff --git a/HAL/keymaster/4.1/SocketTransport.cpp b/HAL/keymaster/4.1/SocketTransport.cpp new file mode 100644 index 00000000..6c23f5bc --- /dev/null +++ b/HAL/keymaster/4.1/SocketTransport.cpp @@ -0,0 +1,100 @@ +/* + ** + ** Copyright 2020, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ +#include +#include +#include +#include +#include "Transport.h" + +/* TODO How to get these two values */ +#define PORT 8080 +#define IPADDR "10.9.40.24" +#define MAX_RECV_BUFFER_SIZE 2048 + +namespace se_transport { + +bool SocketTransport::openConnection(connectionCallback cb) { + struct sockaddr_in serv_addr; + + if ((mSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) + { + LOG(ERROR) << "Socket creation failed"; + return false; + } + + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(PORT); + + // Convert IPv4 and IPv6 addresses from text to binary form + if(inet_pton(AF_INET, IPADDR, &serv_addr.sin_addr)<=0) + { + LOG(ERROR) << "Invalid address/ Address not supported."; + return false; + } + + if (connect(mSocket, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) + { + LOG(ERROR) << "Connection failed."; + return false; + } + cb(true);// This can be used for Asynchronous calls. + return true; +} + +bool SocketTransport::sendData(const char* data, uint32_t dataSize, responseCallback cb) { + uint8_t buffer[MAX_RECV_BUFFER_SIZE]; + if (0 > send(mSocket, data ,dataSize , 0 )) { + LOG(ERROR) << "Failed to send data over socket."; + return false; + } + ssize_t valRead = read( mSocket , buffer, MAX_RECV_BUFFER_SIZE); + if(0 > valRead) { + LOG(ERROR) << "Failed to read data from socket."; + } + std::vector output(buffer, buffer+valRead); + cb(output); + return true; +} + +bool SocketTransport::sendData(const char* inData, const uint32_t inLen, std::vector& output) { + uint8_t buffer[MAX_RECV_BUFFER_SIZE]; + if (0 > send(mSocket, inData, inLen , 0 )) { + LOG(ERROR) << "Failed to send data over socket."; + return false; + } + ssize_t valRead = read( mSocket , buffer, MAX_RECV_BUFFER_SIZE); + if(0 > valRead) { + LOG(ERROR) << "Failed to read data from socket."; + } + for(size_t i = 0; i < valRead; i++) { + output.push_back(buffer[i]); + } + return true; + +} + +bool SocketTransport::closeConnection() { + close(mSocket); + return true; +} + +bool SocketTransport::isConnected() { + //TODO + return true; +} + +} diff --git a/HAL/keymaster/Android.bp b/HAL/keymaster/Android.bp index 9720ea6a..d708814f 100644 --- a/HAL/keymaster/Android.bp +++ b/HAL/keymaster/Android.bp @@ -14,9 +14,7 @@ // cc_binary { - name: "android.hardware.keymaster@4.1-service.javacard", - relative_install_path: "hw", - vendor: true, + name: "android.hardware.keymaster@4.1-javacard-service", init_rc: ["4.1/android.hardware.keymaster@4.1-service.javacard.rc"], srcs: [ "4.1/service.cpp", @@ -35,7 +33,59 @@ cc_binary { "libhardware", "libhidlbase", "libkeymaster_messages", - "libcppbor_external", + "libcppbor_external", + "omapi_external", "android.hardware.keymaster@4.1", + "jc_transport", + ], +} + +cc_library { + name: "android.hardware.keymaster@4.1-javacard", + srcs: [ + "4.1/service.cpp", + "4.1/JavacardKeymaster4Device.cpp", + "4.1/CborConverter.cpp", + ], + local_include_dirs: [ + "include", + ], + shared_libs: [ + "liblog", + "libcutils", + "libdl", + "libbase", + "libutils", + "libhardware", + "libhidlbase", + "libkeymaster_messages", + "libcppbor_external", + "omapi_external", + "android.hardware.keymaster@4.1", + "android.hardware.keymaster@4.0", + "jc_transport", + ], +} + + + +cc_library { + name: "jc_transport", + host_supported: true, + vendor_available: true, + + srcs: [ + "4.1/SocketTransport.cpp", + "4.1/OmapiTransport.cpp" + ], + export_include_dirs: [ + "include" + ], + shared_libs: [ + "libbinder", + "libbase", + "liblog", + "libutils", + "libcurl" ], } diff --git a/HAL/keymaster/include/JavacardKeymaster4Device.h b/HAL/keymaster/include/JavacardKeymaster4Device.h index f8e54856..0494890c 100644 --- a/HAL/keymaster/include/JavacardKeymaster4Device.h +++ b/HAL/keymaster/include/JavacardKeymaster4Device.h @@ -21,7 +21,9 @@ #include #include #include +#include #include "CborConverter.h" +#include "TransportFactory.h" namespace android { namespace hardware { @@ -38,8 +40,15 @@ using ::android::sp; class JavacardKeymaster4Device : public IKeymasterDevice { public: - explicit JavacardKeymaster4Device(); + JavacardKeymaster4Device() { + if(android::base::GetBoolProperty("ro.kernel.qemu", false)) + pTransportFactory = std::make_unique(true); + else + pTransportFactory = std::make_unique(false); + } + virtual ~JavacardKeymaster4Device(); + // Methods from ::android::hardware::keymaster::V4_0::IKeymasterDevice follow. Return getHardwareInfo(getHardwareInfo_cb _hidl_cb) override; Return getHmacSharingParameters(getHmacSharingParameters_cb _hidl_cb) override; @@ -67,6 +76,7 @@ class JavacardKeymaster4Device : public IKeymasterDevice { protected: CborConverter cborConverter_; + std::unique_ptr pTransportFactory; }; } // namespace V4_1 diff --git a/HAL/keymaster/include/Transport.h b/HAL/keymaster/include/Transport.h new file mode 100644 index 00000000..b07f2d20 --- /dev/null +++ b/HAL/keymaster/include/Transport.h @@ -0,0 +1,62 @@ +/* + ** + ** Copyright 2020, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ +#ifndef __SE_TRANSPORT__ +#define __SE_TRANSPORT__ + +namespace se_transport { + +typedef void (*connectionCallback)(bool connected); +typedef void (*responseCallback)(std::vector output); + +class ITransport { + public: + virtual ~ITransport(){} + virtual bool openConnection(connectionCallback cb) = 0; + virtual bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) = 0; + virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) = 0; + virtual bool closeConnection() = 0; + virtual bool isConnected() = 0; + +}; + +class OmapiTransport : public ITransport { + +public: + + bool openConnection(connectionCallback cb) override; + bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) override; + virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) override; + bool closeConnection() override; + bool isConnected() override; + +}; + +class SocketTransport : public ITransport { + +public: + bool openConnection(connectionCallback cb) override; + bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) override; + virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) override; + bool closeConnection() override; + bool isConnected() override; +private: + int mSocket; + +}; + +} +#endif /* __SE_TRANSPORT__ */ diff --git a/HAL/keymaster/include/TransportFactory.h b/HAL/keymaster/include/TransportFactory.h new file mode 100644 index 00000000..3c631886 --- /dev/null +++ b/HAL/keymaster/include/TransportFactory.h @@ -0,0 +1,63 @@ +/* + ** + ** Copyright 2020, The Android Open Source Project + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ +#ifndef __SE_TRANSPORT_FACTORY__ +#define __SE_TRANSPORT_FACTORY__ + +#include "Transport.h" + +namespace se_transport { + +class TransportFactory { + public: + /*TransportFactory(bool isDevice) : mTransport( isDevice ? std::unique_ptr(new OmapiTransport()) : + std::unique_ptr(new SocketTransport())) { + }*/ + TransportFactory(bool isDevice) { + if (isDevice) + mTransport = std::unique_ptr(new OmapiTransport()); + else + mTransport = std::unique_ptr(new SocketTransport()); + } + + ~TransportFactory() {} + + inline bool openConnection(connectionCallback cb) { + return mTransport->openConnection(cb); + } + + inline bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) { + return mTransport->sendData(inData, inLen, cb); + } + + inline bool sendData(const char* inData, const uint32_t inLen, std::vector& output) { + return mTransport->sendData(inData, inLen, output); + } + + inline bool closeConnection() { + return mTransport->closeConnection(); + } + + inline bool isConnected() { + return mTransport->isConnected(); + } + + private: + std::unique_ptr mTransport; + +}; +} +#endif /* __SE_TRANSPORT_FACTORY__ */ From 0b4e6964c1e29aa333fd6d03dcfe1110f0d67845 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Tue, 5 May 2020 14:26:18 +0530 Subject: [PATCH 06/13] construct and decode Apdu functions added --- .../4.1/JavacardKeymaster4Device.cpp | 78 ++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-) diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index 2ae12410..74f540dd 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -35,12 +36,87 @@ namespace hardware { namespace keymaster { namespace V4_1 { +#define APDU_CLS 0x80 +#define APDU_P1 0x40 +#define APDU_P2 0x00 +#define APDU_RESP_STATUS_OK 0x9000 + +enum class Instruction { + INS_GENERATE_KEY_CMD = 0x10; + INS_IMPORT_KEY_CMD = 0x11; + INS_IMPORT_WRAPPED_KEY_CMD = 0x12; + INS_EXPORT_KEY_CMD = 0x13; + INS_ATTEST_KEY_CMD = 0x14; + INS_UPGRADE_KEY_CMD = 0x15; + INS_DELETE_KEY_CMD = 0x16; + INS_DELETE_ALL_KEYS_CMD = 0x17; + INS_ADD_RNG_ENTROPY_CMD = 0x18; + INS_COMPUTE_SHARED_HMAC_CMD = 0x19; + INS_DESTROY_ATT_IDS_CMD = 0x1A; + INS_VERIFY_AUTHORIZATION_CMD = 0x1B; + INS_GET_HMAC_SHARING_PARAM_CMD = 0x1C; + INS_GET_KEY_CHARACTERISTICS_CMD = 0x1D; + INS_GET_HW_INFO_CMD = 0x1E; + INS_BEGIN_OPERATION_CMD = 0x1F; + INS_UPDATE_OPERATION_CMD = 0x20; + INS_FINISH_OPERATION_CMD = 0x21; + INS_ABORT_OPERATION_CMD = 0x22; + INS_PROVISION_CMD = 0x23; +}; + +bool constructApduMessage(Instruction& ins, std::vector& inputData, std::vector& apduOut) { + apduOut.push_back(static_cast(APDU_CLS)); //CLS + apduOut.push_back(static_cast(ins)); //INS + apduOut.push_back(static_cast(APDU_P1)); //P1 + apduOut.push_back(static_cast(APDU_P2)); //P2 + + if(UCHAR_MAX < inputData.size() && USHRT_MAX >= inputData.size()) { + //Extended length 3 bytes, starts with 0x00 + apduOut.push_back(static_cast(0x00)); + apduOut.push_back(static_cast(inputData.size() >> 8)); + apduOut.push_back(static_cast(inputData.size() & 0xFF)); + //Data + apduOut.insert(apduOut.end(), inputData.begin(), inputData.end()); + //Expected length of output + apduOut.push_back(static_cast(0x00)); + apduOut.push_back(static_cast(0x00)); + apduOut.push_back(static_cast(0x00)); //TODO Max expected out ?? + } else if(0 <= inputData.size() && UCHAR_MAX >= inputData.szie()) { + //Short length + apduOut.push_back(static_cast(inputData.size())); + //Data + if(inputData.size() > 0) + apduOut.insert(apduOut.end(), inputData.begin(), inputData.end()); + //Expected length of output + apduOut.push_back(static_cast(0x00));//TODO Max expected out ?? + } else { + return false; + } + + return true; +} + +bool parseApduMessage(std::vector& inputData, std::vector &resOut) { + uint16_t status = (inputData.at(inputData.size()-2) << 8) | (inputData.at(inputData.size()-1)); + if (status == (uint16_t)APDU_RESP_STATUS_OK) { + resout.insert(resOut.begin(), inputData.begin(), inputData.end()-2); + return true; + } + return false; +} + JavacardKeymaster4Device::~JavacardKeymaster4Device() { } // Methods from IKeymasterDevice follow. Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_cb) { - _hidl_cb(SecurityLevel::STRONGBOX, JAVACARD_KEYMASTER_NAME, JAVACARD_KEYMASTER_AUTHOR); + //_hidl_cb(SecurityLevel::STRONGBOX, JAVACARD_KEYMASTER_NAME, JAVACARD_KEYMASTER_AUTHOR); + std::vector output; + if(!constructApduMessage(INS_GET_HW_INFO_CMD, std::vector(), output ) { + LOG(ERROR) << "Failed to get hardware info"; + } + pTransport->openConnection(); + pTransport->sendData(output.data(), output.size() return Void(); } From d6fbd6ec319e4d370f13d5e8aca1b98930d1e24c Mon Sep 17 00:00:00 2001 From: bvenkateswarlu Date: Tue, 5 May 2020 11:56:29 +0100 Subject: [PATCH 07/13] Integration of Apdu message with getHardwareInfo function --- .../4.1/JavacardKeymaster4Device.cpp | 47 ++++++++++++---- HAL/keymaster/4.1/OmapiTransport.cpp | 4 ++ HAL/keymaster/4.1/SocketTransport.cpp | 56 ++++++++++++++----- .../include/JavacardKeymaster4Device.h | 7 +-- HAL/keymaster/include/Transport.h | 3 + HAL/keymaster/include/TransportFactory.h | 7 +-- 6 files changed, 90 insertions(+), 34 deletions(-) diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index 74f540dd..a1d6d50c 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -27,6 +27,7 @@ #include #include #include +#include #define JAVACARD_KEYMASTER_NAME "JavacardKeymaster4.1Device v0.1" #define JAVACARD_KEYMASTER_AUTHOR "Android Open Source Project" @@ -96,13 +97,14 @@ bool constructApduMessage(Instruction& ins, std::vector& inputData, std return true; } -bool parseApduMessage(std::vector& inputData, std::vector &resOut) { - uint16_t status = (inputData.at(inputData.size()-2) << 8) | (inputData.at(inputData.size()-1)); - if (status == (uint16_t)APDU_RESP_STATUS_OK) { - resout.insert(resOut.begin(), inputData.begin(), inputData.end()-2); +uint16_t getStatus(std::vector& inputData) { + //Last two bytes are the status SW0SW1 + return (inputData.at(inputData.size()-2) << 8) | (inputData.at(inputData.size()-1)); + /*if (status == (uint16_t)APDU_RESP_STATUS_OK) { + resOut.insert(resOut.begin(), inputData.begin(), inputData.end()-2); return true; } - return false; + return false;*/ } JavacardKeymaster4Device::~JavacardKeymaster4Device() { @@ -111,12 +113,37 @@ JavacardKeymaster4Device::~JavacardKeymaster4Device() { // Methods from IKeymasterDevice follow. Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_cb) { //_hidl_cb(SecurityLevel::STRONGBOX, JAVACARD_KEYMASTER_NAME, JAVACARD_KEYMASTER_AUTHOR); - std::vector output; - if(!constructApduMessage(INS_GET_HW_INFO_CMD, std::vector(), output ) { - LOG(ERROR) << "Failed to get hardware info"; + std::vector apdu; + std::vector resp; + std::unique_ptr item; + std::string message; + uint64_t securityLevel; + hidl_string jcKeymasterName; + hidl_string jcKeymasterAuthor; + + bool ret; + ret = constructApduMessage(INS_GET_HW_INFO_CMD, std::vector(), apdu ); + static_assert(ret, "Failed to get hardware info"); + + ret = pTransport->openConnection(); + static_assert(ret, "Failed to open connection with secure element"); + + ret = pTransport->sendData(apdu.data(), apdu.size(), resp); + static_assert(ret, "Failed to send data to secure element"); + + static_assert(APDU_RESP_STATUS_OK == getStatus(resp), "Failed to get response from secure element."); + + std::tie(item, pos, message) = parse(std::vector(resp.begin(), resp.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector temp; + cborConverter_.getUint64(item, 0, securityLevel); //SecurityLevel + cborConverter_.getBinaryArray(item, 1, temp); + jcKeymasterName.setToExternal(temp.data(), temp.size()); + temp.clear(); + cborConverter_.getBinaryArray(item, 2, temp); + jcKeymasterAuthor.setToExternal(temp.data(), temp.size()); } - pTransport->openConnection(); - pTransport->sendData(output.data(), output.size() + _hidl_cb(static_cast(securityLevel), jcKeymasterName, jcKeymasterAuthor); return Void(); } diff --git a/HAL/keymaster/4.1/OmapiTransport.cpp b/HAL/keymaster/4.1/OmapiTransport.cpp index 30ec5060..3a278bbd 100644 --- a/HAL/keymaster/4.1/OmapiTransport.cpp +++ b/HAL/keymaster/4.1/OmapiTransport.cpp @@ -28,6 +28,10 @@ namespace se_transport { +bool OmapiTransport::openConnection() { + return true; +} + bool OmapiTransport::openConnection(connectionCallback cb) { cb(true); return true; diff --git a/HAL/keymaster/4.1/SocketTransport.cpp b/HAL/keymaster/4.1/SocketTransport.cpp index 6c23f5bc..c17bbdec 100644 --- a/HAL/keymaster/4.1/SocketTransport.cpp +++ b/HAL/keymaster/4.1/SocketTransport.cpp @@ -27,27 +27,54 @@ namespace se_transport { +bool SocketTransport::openConnection() { + struct sockaddr_in serv_addr; + + if ((mSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) + { + LOG(ERROR) << "Socket creation failed"; + return false; + } + + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(PORT); + + // Convert IPv4 and IPv6 addresses from text to binary form + if(inet_pton(AF_INET, IPADDR, &serv_addr.sin_addr)<=0) + { + LOG(ERROR) << "Invalid address/ Address not supported."; + return false; + } + + if (connect(mSocket, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) + { + LOG(ERROR) << "Connection failed."; + return false; + } + return true; +} + bool SocketTransport::openConnection(connectionCallback cb) { - struct sockaddr_in serv_addr; + struct sockaddr_in serv_addr; - if ((mSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) - { + if ((mSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) + { LOG(ERROR) << "Socket creation failed"; - return false; - } - - serv_addr.sin_family = AF_INET; - serv_addr.sin_port = htons(PORT); - - // Convert IPv4 and IPv6 addresses from text to binary form - if(inet_pton(AF_INET, IPADDR, &serv_addr.sin_addr)<=0) - { + return false; + } + + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(PORT); + + // Convert IPv4 and IPv6 addresses from text to binary form + if(inet_pton(AF_INET, IPADDR, &serv_addr.sin_addr)<=0) + { LOG(ERROR) << "Invalid address/ Address not supported."; return false; } - if (connect(mSocket, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) - { + if (connect(mSocket, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) + { LOG(ERROR) << "Connection failed."; return false; } @@ -84,7 +111,6 @@ bool SocketTransport::sendData(const char* inData, const uint32_t inLen, std::ve output.push_back(buffer[i]); } return true; - } bool SocketTransport::closeConnection() { diff --git a/HAL/keymaster/include/JavacardKeymaster4Device.h b/HAL/keymaster/include/JavacardKeymaster4Device.h index 0494890c..0795ea5f 100644 --- a/HAL/keymaster/include/JavacardKeymaster4Device.h +++ b/HAL/keymaster/include/JavacardKeymaster4Device.h @@ -41,10 +41,9 @@ using ::android::sp; class JavacardKeymaster4Device : public IKeymasterDevice { public: JavacardKeymaster4Device() { - if(android::base::GetBoolProperty("ro.kernel.qemu", false)) - pTransportFactory = std::make_unique(true); - else - pTransportFactory = std::make_unique(false); + /* TODO instead do we need to create object like this std::unique_ptr(new TransportFactory(true));*/ + pTransportFactory = std::make_unique( + android::base::GetBoolProperty("ro.kernel.qemu", false)); } virtual ~JavacardKeymaster4Device(); diff --git a/HAL/keymaster/include/Transport.h b/HAL/keymaster/include/Transport.h index b07f2d20..3d38fc9a 100644 --- a/HAL/keymaster/include/Transport.h +++ b/HAL/keymaster/include/Transport.h @@ -26,6 +26,7 @@ class ITransport { public: virtual ~ITransport(){} virtual bool openConnection(connectionCallback cb) = 0; + virtual bool openConnection() = 0; virtual bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) = 0; virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) = 0; virtual bool closeConnection() = 0; @@ -38,6 +39,7 @@ class OmapiTransport : public ITransport { public: bool openConnection(connectionCallback cb) override; + bool openConnection() override; bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) override; virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) override; bool closeConnection() override; @@ -49,6 +51,7 @@ class SocketTransport : public ITransport { public: bool openConnection(connectionCallback cb) override; + bool openConnection() override; bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) override; virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) override; bool closeConnection() override; diff --git a/HAL/keymaster/include/TransportFactory.h b/HAL/keymaster/include/TransportFactory.h index 3c631886..6fa8344d 100644 --- a/HAL/keymaster/include/TransportFactory.h +++ b/HAL/keymaster/include/TransportFactory.h @@ -23,11 +23,8 @@ namespace se_transport { class TransportFactory { public: - /*TransportFactory(bool isDevice) : mTransport( isDevice ? std::unique_ptr(new OmapiTransport()) : - std::unique_ptr(new SocketTransport())) { - }*/ - TransportFactory(bool isDevice) { - if (isDevice) + TransportFactory(bool isEmulator) { + if (!isEmulator) mTransport = std::unique_ptr(new OmapiTransport()); else mTransport = std::unique_ptr(new SocketTransport()); From 1dde4674313129b4dc7436ab550bfafbac0f9ce0 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Tue, 5 May 2020 20:28:18 +0530 Subject: [PATCH 08/13] Fixed compilation errors for getHardwareinfo --- .../4.1/JavacardKeymaster4Device.cpp | 108 ++++++++++-------- HAL/keymaster/4.1/OmapiTransport.cpp | 4 +- HAL/keymaster/4.1/SocketTransport.cpp | 4 +- HAL/keymaster/include/Transport.h | 12 +- HAL/keymaster/include/TransportFactory.h | 8 +- 5 files changed, 74 insertions(+), 62 deletions(-) diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index a1d6d50c..86f85b96 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -43,29 +43,29 @@ namespace V4_1 { #define APDU_RESP_STATUS_OK 0x9000 enum class Instruction { - INS_GENERATE_KEY_CMD = 0x10; - INS_IMPORT_KEY_CMD = 0x11; - INS_IMPORT_WRAPPED_KEY_CMD = 0x12; - INS_EXPORT_KEY_CMD = 0x13; - INS_ATTEST_KEY_CMD = 0x14; - INS_UPGRADE_KEY_CMD = 0x15; - INS_DELETE_KEY_CMD = 0x16; - INS_DELETE_ALL_KEYS_CMD = 0x17; - INS_ADD_RNG_ENTROPY_CMD = 0x18; - INS_COMPUTE_SHARED_HMAC_CMD = 0x19; - INS_DESTROY_ATT_IDS_CMD = 0x1A; - INS_VERIFY_AUTHORIZATION_CMD = 0x1B; - INS_GET_HMAC_SHARING_PARAM_CMD = 0x1C; - INS_GET_KEY_CHARACTERISTICS_CMD = 0x1D; - INS_GET_HW_INFO_CMD = 0x1E; - INS_BEGIN_OPERATION_CMD = 0x1F; - INS_UPDATE_OPERATION_CMD = 0x20; - INS_FINISH_OPERATION_CMD = 0x21; - INS_ABORT_OPERATION_CMD = 0x22; - INS_PROVISION_CMD = 0x23; + INS_GENERATE_KEY_CMD = 0x10, + INS_IMPORT_KEY_CMD = 0x11, + INS_IMPORT_WRAPPED_KEY_CMD = 0x12, + INS_EXPORT_KEY_CMD = 0x13, + INS_ATTEST_KEY_CMD = 0x14, + INS_UPGRADE_KEY_CMD = 0x15, + INS_DELETE_KEY_CMD = 0x16, + INS_DELETE_ALL_KEYS_CMD = 0x17, + INS_ADD_RNG_ENTROPY_CMD = 0x18, + INS_COMPUTE_SHARED_HMAC_CMD = 0x19, + INS_DESTROY_ATT_IDS_CMD = 0x1A, + INS_VERIFY_AUTHORIZATION_CMD = 0x1B, + INS_GET_HMAC_SHARING_PARAM_CMD = 0x1C, + INS_GET_KEY_CHARACTERISTICS_CMD = 0x1D, + INS_GET_HW_INFO_CMD = 0x1E, + INS_BEGIN_OPERATION_CMD = 0x1F, + INS_UPDATE_OPERATION_CMD = 0x20, + INS_FINISH_OPERATION_CMD = 0x21, + INS_ABORT_OPERATION_CMD = 0x22, + INS_PROVISION_CMD = 0x23 }; -bool constructApduMessage(Instruction& ins, std::vector& inputData, std::vector& apduOut) { +int32_t constructApduMessage(Instruction& ins, std::vector& inputData, std::vector& apduOut) { apduOut.push_back(static_cast(APDU_CLS)); //CLS apduOut.push_back(static_cast(ins)); //INS apduOut.push_back(static_cast(APDU_P1)); //P1 @@ -82,7 +82,7 @@ bool constructApduMessage(Instruction& ins, std::vector& inputData, std apduOut.push_back(static_cast(0x00)); apduOut.push_back(static_cast(0x00)); apduOut.push_back(static_cast(0x00)); //TODO Max expected out ?? - } else if(0 <= inputData.size() && UCHAR_MAX >= inputData.szie()) { + } else if(0 <= inputData.size() && UCHAR_MAX >= inputData.size()) { //Short length apduOut.push_back(static_cast(inputData.size())); //Data @@ -91,20 +91,35 @@ bool constructApduMessage(Instruction& ins, std::vector& inputData, std //Expected length of output apduOut.push_back(static_cast(0x00));//TODO Max expected out ?? } else { - return false; + return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::INSUFFICIENT_BUFFER_SPACE); } - return true; + return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK);//success } uint16_t getStatus(std::vector& inputData) { //Last two bytes are the status SW0SW1 return (inputData.at(inputData.size()-2) << 8) | (inputData.at(inputData.size()-1)); - /*if (status == (uint16_t)APDU_RESP_STATUS_OK) { - resOut.insert(resOut.begin(), inputData.begin(), inputData.end()-2); - return true; +} + +inline int32_t sendData(std::unique_ptr& transport, Instruction ins, std::vector& inData, +std::vector& response) { + std::vector apdu; + int32_t ret = constructApduMessage(ins, inData, apdu); + if(ret != 0) return ret; + + if(!transport->openConnection()) { + return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::SECURE_HW_COMMUNICATION_FAILED); + } + + if(!transport->sendData(apdu.data(), apdu.size(), response)) { + return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::SECURE_HW_COMMUNICATION_FAILED); + } + + if(APDU_RESP_STATUS_OK != getStatus(response)) { + return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR); } - return false;*/ + return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK);//success } JavacardKeymaster4Device::~JavacardKeymaster4Device() { @@ -113,35 +128,28 @@ JavacardKeymaster4Device::~JavacardKeymaster4Device() { // Methods from IKeymasterDevice follow. Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_cb) { //_hidl_cb(SecurityLevel::STRONGBOX, JAVACARD_KEYMASTER_NAME, JAVACARD_KEYMASTER_AUTHOR); - std::vector apdu; std::vector resp; + std::vector input; + const uint8_t* pos; std::unique_ptr item; std::string message; - uint64_t securityLevel; + uint64_t securityLevel = static_cast(SecurityLevel::STRONGBOX); hidl_string jcKeymasterName; hidl_string jcKeymasterAuthor; - bool ret; - ret = constructApduMessage(INS_GET_HW_INFO_CMD, std::vector(), apdu ); - static_assert(ret, "Failed to get hardware info"); - - ret = pTransport->openConnection(); - static_assert(ret, "Failed to open connection with secure element"); - - ret = pTransport->sendData(apdu.data(), apdu.size(), resp); - static_assert(ret, "Failed to send data to secure element"); + int32_t ret = sendData(pTransportFactory, Instruction::INS_GET_HW_INFO_CMD, input, resp); - static_assert(APDU_RESP_STATUS_OK == getStatus(resp), "Failed to get response from secure element."); - - std::tie(item, pos, message) = parse(std::vector(resp.begin(), resp.end()-2));//Skip last 2 bytes, it is status. - if (item != nullptr) { - std::vector temp; - cborConverter_.getUint64(item, 0, securityLevel); //SecurityLevel - cborConverter_.getBinaryArray(item, 1, temp); - jcKeymasterName.setToExternal(temp.data(), temp.size()); - temp.clear(); - cborConverter_.getBinaryArray(item, 2, temp); - jcKeymasterAuthor.setToExternal(temp.data(), temp.size()); + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(resp.begin(), resp.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector temp; + cborConverter_.getUint64(item, 0, securityLevel); //SecurityLevel + cborConverter_.getBinaryArray(item, 1, temp); + jcKeymasterName = std::string(temp.begin(), temp.end()); + temp.clear(); + cborConverter_.getBinaryArray(item, 2, temp); + jcKeymasterAuthor = std::string(temp.begin(), temp.end()); + } } _hidl_cb(static_cast(securityLevel), jcKeymasterName, jcKeymasterAuthor); return Void(); diff --git a/HAL/keymaster/4.1/OmapiTransport.cpp b/HAL/keymaster/4.1/OmapiTransport.cpp index 3a278bbd..a981edb2 100644 --- a/HAL/keymaster/4.1/OmapiTransport.cpp +++ b/HAL/keymaster/4.1/OmapiTransport.cpp @@ -37,14 +37,14 @@ bool OmapiTransport::openConnection(connectionCallback cb) { return true; } -bool OmapiTransport::sendData(const char* inData, const uint32_t inLen, responseCallback cb) { +bool OmapiTransport::sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) { std::vector test(inData, inData+inLen); cb(test); return true; } -bool OmapiTransport::sendData(const char* inData, const uint32_t inLen, std::vector& output) { +bool OmapiTransport::sendData(const uint8_t* inData, const size_t inLen, std::vector& output) { std::vector test(inData, inData+inLen); output = std::move(test); return true; diff --git a/HAL/keymaster/4.1/SocketTransport.cpp b/HAL/keymaster/4.1/SocketTransport.cpp index c17bbdec..11ecd6d8 100644 --- a/HAL/keymaster/4.1/SocketTransport.cpp +++ b/HAL/keymaster/4.1/SocketTransport.cpp @@ -82,7 +82,7 @@ bool SocketTransport::openConnection(connectionCallback cb) { return true; } -bool SocketTransport::sendData(const char* data, uint32_t dataSize, responseCallback cb) { +bool SocketTransport::sendData(const uint8_t* data, const size_t dataSize, responseCallback cb) { uint8_t buffer[MAX_RECV_BUFFER_SIZE]; if (0 > send(mSocket, data ,dataSize , 0 )) { LOG(ERROR) << "Failed to send data over socket."; @@ -97,7 +97,7 @@ bool SocketTransport::sendData(const char* data, uint32_t dataSize, responseCall return true; } -bool SocketTransport::sendData(const char* inData, const uint32_t inLen, std::vector& output) { +bool SocketTransport::sendData(const uint8_t* inData, const size_t inLen, std::vector& output) { uint8_t buffer[MAX_RECV_BUFFER_SIZE]; if (0 > send(mSocket, inData, inLen , 0 )) { LOG(ERROR) << "Failed to send data over socket."; diff --git a/HAL/keymaster/include/Transport.h b/HAL/keymaster/include/Transport.h index 3d38fc9a..a6b917b3 100644 --- a/HAL/keymaster/include/Transport.h +++ b/HAL/keymaster/include/Transport.h @@ -27,8 +27,8 @@ class ITransport { virtual ~ITransport(){} virtual bool openConnection(connectionCallback cb) = 0; virtual bool openConnection() = 0; - virtual bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) = 0; - virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) = 0; + virtual bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) = 0; + virtual bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) = 0; virtual bool closeConnection() = 0; virtual bool isConnected() = 0; @@ -40,8 +40,8 @@ class OmapiTransport : public ITransport { bool openConnection(connectionCallback cb) override; bool openConnection() override; - bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) override; - virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) override; + bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) override; + virtual bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) override; bool closeConnection() override; bool isConnected() override; @@ -52,8 +52,8 @@ class SocketTransport : public ITransport { public: bool openConnection(connectionCallback cb) override; bool openConnection() override; - bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) override; - virtual bool sendData(const char* inData, const uint32_t inLen, std::vector& output) override; + bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) override; + virtual bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) override; bool closeConnection() override; bool isConnected() override; private: diff --git a/HAL/keymaster/include/TransportFactory.h b/HAL/keymaster/include/TransportFactory.h index 6fa8344d..f8d9240b 100644 --- a/HAL/keymaster/include/TransportFactory.h +++ b/HAL/keymaster/include/TransportFactory.h @@ -36,11 +36,15 @@ class TransportFactory { return mTransport->openConnection(cb); } - inline bool sendData(const char* inData, const uint32_t inLen, responseCallback cb) { + inline bool openConnection() { + return mTransport->openConnection(); + } + + inline bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) { return mTransport->sendData(inData, inLen, cb); } - inline bool sendData(const char* inData, const uint32_t inLen, std::vector& output) { + inline bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) { return mTransport->sendData(inData, inLen, output); } From 8a43205d9dcce06ecddbd426aa1141d64df9d681 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Fri, 8 May 2020 21:09:13 +0530 Subject: [PATCH 09/13] Modified getItemAtPos method --- HAL/keymaster/4.1/CborConverter.cpp | 18 +++++++++++++----- HAL/keymaster/include/CborConverter.h | 15 ++++++++------- 2 files changed, 21 insertions(+), 12 deletions(-) diff --git a/HAL/keymaster/4.1/CborConverter.cpp b/HAL/keymaster/4.1/CborConverter.cpp index 2679697a..c0ec86ef 100644 --- a/HAL/keymaster/4.1/CborConverter.cpp +++ b/HAL/keymaster/4.1/CborConverter.cpp @@ -72,8 +72,9 @@ bool CborConverter::addKeyparameters(Array& array, const android::hardware::hidl bool CborConverter::getKeyCharacteristics(const std::unique_ptr &item, const uint32_t pos, ::android::hardware::keymaster::V4_0::KeyCharacteristics& keyCharacteristics) { bool ret = false; + std::unique_ptr arrayItem(nullptr); - const std::unique_ptr& arrayItem = getItemAtPos(item, pos); + getItemAtPos(item, pos, arrayItem); if ((arrayItem == nullptr) && (MajorType::ARRAY != getType(arrayItem))) return ret; @@ -140,7 +141,9 @@ ParseResult CborConverter::decodeData(const std::vector cborData) { bool CborConverter::getMultiBinaryArray(const std::unique_ptr& item, const uint32_t pos, ::android::hardware::hidl_vec<::android::hardware::hidl_vec>& data) { bool ret = false; - const std::unique_ptr& arrayItem = getItemAtPos(item, pos); + std::unique_ptr arrayItem(nullptr); + + getItemAtPos(item, pos, arrayItem); if ((arrayItem == nullptr) && (MajorType::ARRAY != getType(arrayItem))) return ret; const Array* arr = arrayItem.get()->asArray(); @@ -157,7 +160,9 @@ bool CborConverter::getMultiBinaryArray(const std::unique_ptr& item, const bool CborConverter::getBinaryArray(const std::unique_ptr& item, const uint32_t pos, std::vector& value) { bool ret = false; - const std::unique_ptr& strItem = getItemAtPos(item, pos); + std::unique_ptr strItem(nullptr); + + getItemAtPos(item, pos, strItem); if ((strItem == nullptr) && (MajorType::BSTR != getType(strItem))) return ret; @@ -173,10 +178,12 @@ bool CborConverter::getBinaryArray(const std::unique_ptr& item, const uint bool CborConverter::getHmacSharingParameters(const std::unique_ptr& item, const uint32_t pos, HmacSharingParameters& params) { std::vector paramValue; bool ret = false; + std::unique_ptr arrayItem(nullptr); //1. Get ArrayItem //2. First item in the array seed; second item in the array is nonce. - const std::unique_ptr& arrayItem = getItemAtPos(item, pos); + + getItemAtPos(item, pos, arrayItem); if ((arrayItem == nullptr) && (MajorType::ARRAY != getType(arrayItem))) return ret; @@ -276,7 +283,8 @@ bool CborConverter::getVerificationToken(const std::unique_ptr& item, cons bool CborConverter::getKeyParameters(const std::unique_ptr& item, const uint32_t pos, android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams) { bool ret = false; - const std::unique_ptr& mapItem = getItemAtPos(item, pos); + std::unique_ptr mapItem(nullptr); + getItemAtPos(item, pos, mapItem); if ((mapItem == nullptr) && (MajorType::MAP != getType(mapItem))) return ret; diff --git a/HAL/keymaster/include/CborConverter.h b/HAL/keymaster/include/CborConverter.h index 84e86299..5cd60584 100644 --- a/HAL/keymaster/include/CborConverter.h +++ b/HAL/keymaster/include/CborConverter.h @@ -95,24 +95,25 @@ class CborConverter inline MajorType getType(const std::unique_ptr &item) { return item.get()->type(); } bool getKeyparameter(const std::pair&, const std::unique_ptr&> pair, KeyParameter& keyParam); - inline const std::unique_ptr& getItemAtPos(const std::unique_ptr& item, const uint32_t pos) { - const Array* arr = nullptr; + inline void getItemAtPos(const std::unique_ptr& item, const uint32_t pos, std::unique_ptr& subItem) { + Array* arr = nullptr; if (MajorType::ARRAY != getType(item)) { - return EMPTY(std::unique_ptr); + return; } - arr = item.get()->asArray(); + arr = const_cast(item.get()->asArray()); if (arr->size() < (pos + 1)) { - return EMPTY(std::unique_ptr); + return; } - return (*arr)[pos]; + subItem = std::move((*arr)[pos]); } }; template bool CborConverter::getUint64(const std::unique_ptr& item, const uint32_t pos, T& value) { bool ret = false; - const std::unique_ptr& intItem = getItemAtPos(item, pos); + std::unique_ptr intItem(nullptr); + getItemAtPos(item, pos, intItem); if ((intItem == nullptr) || (std::is_unsigned::value && (MajorType::UINT != getType(intItem))) || From f9183607f50a8a0d16e140b43ee9219b2ea6ec31 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Fri, 8 May 2020 22:15:37 +0530 Subject: [PATCH 10/13] Calling transport send method in all the APIs --- .../4.1/JavacardKeymaster4Device.cpp | 348 ++++++++++-------- 1 file changed, 203 insertions(+), 145 deletions(-) diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index 86f85b96..26d478f3 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -62,7 +62,9 @@ enum class Instruction { INS_UPDATE_OPERATION_CMD = 0x20, INS_FINISH_OPERATION_CMD = 0x21, INS_ABORT_OPERATION_CMD = 0x22, - INS_PROVISION_CMD = 0x23 + INS_PROVISION_CMD = 0x23, + INS_DEVICE_LOCKED_CMD = 0x24, + INS_EARLY_BOOT_ENDED_CMD = 0x25 }; int32_t constructApduMessage(Instruction& ins, std::vector& inputData, std::vector& apduOut) { @@ -158,17 +160,20 @@ Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_ Return JavacardKeymaster4Device::getHmacSharingParameters(getHmacSharingParameters_cb _hidl_cb) { std::vector cborData; const uint8_t* pos; + std::vector input; std::unique_ptr item; std::string message; ::android::hardware::keymaster::V4_0::HmacSharingParameters hmacSharingParameters; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - // TODO Call OMAPI layer and get the Cbor format data. + int32_t ret = sendData(pTransportFactory, Instruction::INS_GET_HMAC_SHARING_PARAM_CMD, input, cborData); - std::tie(item, pos, message) = parse(cborData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Error Code - cborConverter_.getHmacSharingParameters(item, 1, hmacSharingParameters); //HmacSharingParameters. + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborData.begin(), cborData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Error Code + cborConverter_.getHmacSharingParameters(item, 1, hmacSharingParameters); //HmacSharingParameters. + } } _hidl_cb(errorCode, hmacSharingParameters); return Void(); @@ -178,6 +183,7 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi cppbor::Array array; const uint8_t* pos; std::unique_ptr item; + std::vector cborOutData; std::string message; hidl_vec sharingCheck; @@ -195,15 +201,16 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi array.add(std::move(innerArray)); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_COMPUTE_SHARED_HMAC_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Error Code - cborConverter_.getBinaryArray(item, 1, bstr); - sharingCheck.setToExternal(bstr.data(), bstr.size()); + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Error Code + cborConverter_.getBinaryArray(item, 1, bstr); + sharingCheck.setToExternal(bstr.data(), bstr.size()); + } } _hidl_cb(errorCode, sharingCheck); return Void(); @@ -213,6 +220,7 @@ Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHan cppbor::Array array; const uint8_t* pos; std::unique_ptr item; + std::vector cborOutData; std::string message; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::keymaster::V4_0::VerificationToken verificationToken; @@ -223,13 +231,14 @@ Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHan cborConverter_.addHardwareAuthToken(array, authToken); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_VERIFY_AUTHORIZATION_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getVerificationToken(item, 1, verificationToken); + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getVerificationToken(item, 1, verificationToken); + } } _hidl_cb(errorCode, verificationToken); return Void(); @@ -238,6 +247,7 @@ Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHan Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::addRngEntropy(const hidl_vec& data) { const uint8_t* pos; cppbor::Array array; + std::vector cborOutData; std::unique_ptr item; std::string message; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; @@ -246,12 +256,13 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device array.add(std::vector(data)); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_ADD_RNG_ENTROPY_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } } return errorCode; } @@ -262,22 +273,25 @@ Return JavacardKeymaster4Device::generateKey(const hidl_vec<::android::har std::unique_ptr item; std::string message; hidl_vec keyBlob; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; cborConverter_.addKeyparameters(array, keyParams); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - /* TODO keyBlob is BSTR */ - cborConverter_.getBinaryArray(item, 1, bstr); - keyBlob.setToExternal(bstr.data(), bstr.size()); - cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_GENERATE_KEY_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + /* TODO keyBlob is BSTR */ + cborConverter_.getBinaryArray(item, 1, bstr); + keyBlob.setToExternal(bstr.data(), bstr.size()); + cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + } } _hidl_cb(errorCode, keyBlob, keyCharacteristics); return Void(); @@ -289,6 +303,7 @@ Return JavacardKeymaster4Device::importKey(const hidl_vec<::android::hardw std::unique_ptr item; std::string message; hidl_vec keyBlob; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; @@ -296,16 +311,19 @@ Return JavacardKeymaster4Device::importKey(const hidl_vec<::android::hardw array.add(static_cast(keyFormat)); array.add(std::vector(keyData)); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - /* TODO keyBlob is BSTR */ - cborConverter_.getBinaryArray(item, 1, bstr); - keyBlob.setToExternal(bstr.data(), bstr.size()); - cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_IMPORT_KEY_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + /* TODO keyBlob is BSTR */ + cborConverter_.getBinaryArray(item, 1, bstr); + keyBlob.setToExternal(bstr.data(), bstr.size()); + cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + } } _hidl_cb(errorCode, keyBlob, keyCharacteristics); return Void(); @@ -317,6 +335,7 @@ Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& std::unique_ptr item; std::string message; hidl_vec keyBlob; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; @@ -327,16 +346,19 @@ Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& array.add(passwordSid); array.add(biometricSid); /* TODO if biometricSid optional if user not sent this don't encode this cbor format */ std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - /* TODO keyBlob is BSTR */ - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getBinaryArray(item, 1, bstr); - keyBlob.setToExternal(bstr.data(), bstr.size()); - cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_IMPORT_WRAPPED_KEY_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + /* TODO keyBlob is BSTR */ + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + keyBlob.setToExternal(bstr.data(), bstr.size()); + cborConverter_.getKeyCharacteristics(item, 2, keyCharacteristics); + } } _hidl_cb(errorCode, keyBlob, keyCharacteristics); @@ -348,6 +370,7 @@ Return JavacardKeymaster4Device::getKeyCharacteristics(const hidl_vec item; std::string message; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; @@ -355,12 +378,15 @@ Return JavacardKeymaster4Device::getKeyCharacteristics(const hidl_vec(clientId)); array.add(std::vector(appData)); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getKeyCharacteristics(item, 1, keyCharacteristics); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_GET_KEY_CHARACTERISTICS_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyCharacteristics(item, 1, keyCharacteristics); + } } _hidl_cb(errorCode, keyCharacteristics); return Void(); @@ -372,6 +398,7 @@ Return JavacardKeymaster4Device::exportKey(::android::hardware::keymaster: std::unique_ptr item; std::string message; hidl_vec keyMaterial; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; array.add(static_cast(keyFormat)); @@ -379,15 +406,18 @@ Return JavacardKeymaster4Device::exportKey(::android::hardware::keymaster: array.add(std::vector(clientId)); array.add(std::vector(appData)); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - /* TODO Keyblobc - BSTR()*/ - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getBinaryArray(item, 1, bstr); - keyMaterial.setToExternal(bstr.data(), bstr.size()); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_EXPORT_KEY_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + /* TODO Keyblobc - BSTR()*/ + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + keyMaterial.setToExternal(bstr.data(), bstr.size()); + } } _hidl_cb(errorCode, keyMaterial); return Void(); @@ -399,18 +429,22 @@ Return JavacardKeymaster4Device::attestKey(const hidl_vec& keyToA std::unique_ptr item; std::string message; hidl_vec keyBlob; + std::vector cborOutData; ::android::hardware::hidl_vec<::android::hardware::hidl_vec> certChain; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; array.add(std::vector(keyToAttest)); cborConverter_.addKeyparameters(array, attestParams); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getMultiBinaryArray(item, 1, certChain); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_ATTEST_KEY_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getMultiBinaryArray(item, 1, certChain); + } } _hidl_cb(errorCode, certChain); return Void(); @@ -422,20 +456,24 @@ Return JavacardKeymaster4Device::upgradeKey(const hidl_vec& keyBl std::unique_ptr item; std::string message; hidl_vec upgradedKeyBlob; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; array.add(std::vector(keyBlobToUpgrade)); cborConverter_.addKeyparameters(array, upgradeParams); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - /* TODO Keyblob BSTR(ARRAY) */ - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getBinaryArray(item, 1, bstr); - upgradedKeyBlob.setToExternal(bstr.data(), bstr.size()); + + int32_t ret = sendData(pTransportFactory, Instruction::INS_UPGRADE_KEY_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + /* TODO Keyblob BSTR(ARRAY) */ + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getBinaryArray(item, 1, bstr); + upgradedKeyBlob.setToExternal(bstr.data(), bstr.size()); + } } _hidl_cb(errorCode, upgradedKeyBlob); return Void(); @@ -446,17 +484,19 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; array.add(std::vector(keyBlob)); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_DELETE_KEY_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } } return errorCode; } @@ -465,15 +505,17 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; + std::vector input; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + int32_t ret = sendData(pTransportFactory, Instruction::INS_DELETE_ALL_KEYS_CMD, input, cborOutData); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } } return errorCode; } @@ -482,15 +524,17 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; + std::vector input; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + int32_t ret = sendData(pTransportFactory, Instruction::INS_DESTROY_ATT_IDS_CMD, input, cborOutData); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } } return errorCode; } @@ -506,6 +550,7 @@ Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_ } else { cppbor::Array array; const uint8_t* pos; + std::vector cborOutData; std::unique_ptr item; std::string message; @@ -516,14 +561,15 @@ Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_ cborConverter_.addHardwareAuthToken(array, authToken); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_BEGIN_OPERATION_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getKeyParameters(item, 1, outParams); - cborConverter_.getUint64(item, 2, operationHandle); + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyParameters(item, 1, outParams); + cborConverter_.getUint64(item, 2, operationHandle); + } } } _hidl_cb(errorCode, outParams, operationHandle); @@ -535,6 +581,7 @@ Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hi const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; uint32_t inputConsumed = 0; @@ -548,17 +595,18 @@ Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hi cborConverter_.addVerificationToken(array, verificationToken); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. - - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getUint64(item, 1, inputConsumed); - cborConverter_.getKeyParameters(item, 2, outParams); - cborConverter_.getBinaryArray(item, 3, bstr); - output.setToExternal(bstr.data(), bstr.size()); + int32_t ret = sendData(pTransportFactory, Instruction::INS_UPDATE_OPERATION_CMD, cborData, cborOutData); + + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getUint64(item, 1, inputConsumed); + cborConverter_.getKeyParameters(item, 2, outParams); + cborConverter_.getBinaryArray(item, 3, bstr); + output.setToExternal(bstr.data(), bstr.size()); + } } _hidl_cb(errorCode, inputConsumed, outParams, output); return Void(); @@ -569,6 +617,7 @@ Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hi const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; hidl_vec output; @@ -582,16 +631,17 @@ Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hi cborConverter_.addVerificationToken(array, verificationToken); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_FINISH_OPERATION_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - std::vector bstr; - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode - cborConverter_.getKeyParameters(item, 1, outParams); - cborConverter_.getBinaryArray(item, 2, bstr); - output.setToExternal(bstr.data(), bstr.size()); + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + std::vector bstr; + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + cborConverter_.getKeyParameters(item, 1, outParams); + cborConverter_.getBinaryArray(item, 2, bstr); + output.setToExternal(bstr.data(), bstr.size()); + } } _hidl_cb(errorCode, outParams, output); return Void(); @@ -602,18 +652,20 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; /* Convert input data to cbor format */ array.add(operationHandle); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_ABORT_OPERATION_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode<::android::hardware::keymaster::V4_0::ErrorCode>(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode<::android::hardware::keymaster::V4_0::ErrorCode>(item, 0, errorCode); //Errorcode + } } return errorCode; } @@ -624,6 +676,7 @@ Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; ::android::hardware::keymaster::V4_1::ErrorCode errorCode = ::android::hardware::keymaster::V4_1::ErrorCode::UNKNOWN_ERROR; /* Convert input data to cbor format */ @@ -631,12 +684,14 @@ Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device cborConverter_.addVerificationToken(array, verificationToken); std::vector cborData = array.encode(); - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + /* TODO DeviceLocked command handled inside HAL */ + int32_t ret = sendData(pTransportFactory, Instruction::INS_DEVICE_LOCKED_CMD, cborData, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } } return errorCode; } @@ -645,14 +700,17 @@ Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device const uint8_t* pos; std::unique_ptr item; std::string message; + std::vector cborOutData; + std::vector cborInput; ::android::hardware::keymaster::V4_1::ErrorCode errorCode = ::android::hardware::keymaster::V4_1::ErrorCode::UNKNOWN_ERROR; - // TODO Call OMAPI layer and sent the cbor data and get the Cbor format data back. + int32_t ret = sendData(pTransportFactory, Instruction::INS_EARLY_BOOT_ENDED_CMD, cborInput, cborOutData); - std::vector cborOutData; /*Received from OMAPI */ - std::tie(item, pos, message) = parse(cborOutData); - if (item != nullptr) { - cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. + if (item != nullptr) { + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode + } } return errorCode; } From 5f96e483402415e82fcf93f8db7ef39d71755777 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Wed, 13 May 2020 19:12:41 +0530 Subject: [PATCH 11/13] some code refactoring --- .../4.1/JavacardKeymaster4Device.cpp | 234 +++++++++--------- HAL/keymaster/Android.bp | 38 +-- .../include/JavacardKeymaster4Device.h | 71 +++--- 3 files changed, 156 insertions(+), 187 deletions(-) diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index 26d478f3..2f3c3684 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -15,33 +15,26 @@ ** limitations under the License. */ -#define LOG_TAG "android.hardware.keymaster@4.1-service.javacard" -#include -#include #include #include -#include -#include -#include -#include #include #include #include #include +#include -#define JAVACARD_KEYMASTER_NAME "JavacardKeymaster4.1Device v0.1" -#define JAVACARD_KEYMASTER_AUTHOR "Android Open Source Project" - -namespace android { -namespace hardware { -namespace keymaster { -namespace V4_1 { - +//#define JAVACARD_KEYMASTER_NAME "JavacardKeymaster4.1Device v0.1" +//#define JAVACARD_KEYMASTER_AUTHOR "Android Open Source Project" #define APDU_CLS 0x80 #define APDU_P1 0x40 #define APDU_P2 0x00 #define APDU_RESP_STATUS_OK 0x9000 +namespace keymaster { +namespace V4_1 { +namespace javacard { + + enum class Instruction { INS_GENERATE_KEY_CMD = 0x10, INS_IMPORT_KEY_CMD = 0x11, @@ -67,7 +60,7 @@ enum class Instruction { INS_EARLY_BOOT_ENDED_CMD = 0x25 }; -int32_t constructApduMessage(Instruction& ins, std::vector& inputData, std::vector& apduOut) { +ErrorCode constructApduMessage(Instruction& ins, std::vector& inputData, std::vector& apduOut) { apduOut.push_back(static_cast(APDU_CLS)); //CLS apduOut.push_back(static_cast(ins)); //INS apduOut.push_back(static_cast(APDU_P1)); //P1 @@ -83,7 +76,7 @@ int32_t constructApduMessage(Instruction& ins, std::vector& inputData, //Expected length of output apduOut.push_back(static_cast(0x00)); apduOut.push_back(static_cast(0x00)); - apduOut.push_back(static_cast(0x00)); //TODO Max expected out ?? + apduOut.push_back(static_cast(0x00));//Accepting complete length of output at a time } else if(0 <= inputData.size() && UCHAR_MAX >= inputData.size()) { //Short length apduOut.push_back(static_cast(inputData.size())); @@ -91,12 +84,13 @@ int32_t constructApduMessage(Instruction& ins, std::vector& inputData, if(inputData.size() > 0) apduOut.insert(apduOut.end(), inputData.begin(), inputData.end()); //Expected length of output - apduOut.push_back(static_cast(0x00));//TODO Max expected out ?? + apduOut.push_back(static_cast(0x00));//Accepting complete length of output at a time + } else { - return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::INSUFFICIENT_BUFFER_SPACE); + return (ErrorCode::INSUFFICIENT_BUFFER_SPACE); } - return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK);//success + return (ErrorCode::OK);//success } uint16_t getStatus(std::vector& inputData) { @@ -104,27 +98,24 @@ uint16_t getStatus(std::vector& inputData) { return (inputData.at(inputData.size()-2) << 8) | (inputData.at(inputData.size()-1)); } -inline int32_t sendData(std::unique_ptr& transport, Instruction ins, std::vector& inData, +inline ErrorCode sendData(std::unique_ptr& transport, Instruction ins, std::vector& inData, std::vector& response) { std::vector apdu; - int32_t ret = constructApduMessage(ins, inData, apdu); - if(ret != 0) return ret; + ErrorCode ret = constructApduMessage(ins, inData, apdu); + if(ret != ErrorCode::OK) return ret; if(!transport->openConnection()) { - return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::SECURE_HW_COMMUNICATION_FAILED); + return (ErrorCode::SECURE_HW_COMMUNICATION_FAILED); } if(!transport->sendData(apdu.data(), apdu.size(), response)) { - return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::SECURE_HW_COMMUNICATION_FAILED); + return (ErrorCode::SECURE_HW_COMMUNICATION_FAILED); } if(APDU_RESP_STATUS_OK != getStatus(response)) { - return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR); + return (ErrorCode::UNKNOWN_ERROR); } - return static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK);//success -} - -JavacardKeymaster4Device::~JavacardKeymaster4Device() { + return (ErrorCode::OK);//success } // Methods from IKeymasterDevice follow. @@ -139,9 +130,9 @@ Return JavacardKeymaster4Device::getHardwareInfo(getHardwareInfo_cb _hidl_ hidl_string jcKeymasterName; hidl_string jcKeymasterAuthor; - int32_t ret = sendData(pTransportFactory, Instruction::INS_GET_HW_INFO_CMD, input, resp); + ErrorCode ret = sendData(pTransportFactory, Instruction::INS_GET_HW_INFO_CMD, input, resp); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(ret == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(resp.begin(), resp.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { std::vector temp; @@ -163,12 +154,12 @@ Return JavacardKeymaster4Device::getHmacSharingParameters(getHmacSharingPa std::vector input; std::unique_ptr item; std::string message; - ::android::hardware::keymaster::V4_0::HmacSharingParameters hmacSharingParameters; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + HmacSharingParameters hmacSharingParameters; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; - int32_t ret = sendData(pTransportFactory, Instruction::INS_GET_HMAC_SHARING_PARAM_CMD, input, cborData); + errorCode = sendData(pTransportFactory, Instruction::INS_GET_HMAC_SHARING_PARAM_CMD, input, cborData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborData.begin(), cborData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Error Code @@ -179,7 +170,7 @@ Return JavacardKeymaster4Device::getHmacSharingParameters(getHmacSharingPa return Void(); } -Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::android::hardware::keymaster::V4_0::HmacSharingParameters>& params, computeSharedHmac_cb _hidl_cb) { +Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec& params, computeSharedHmac_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; @@ -187,7 +178,7 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi std::string message; hidl_vec sharingCheck; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; std::vector tempVec; cppbor::Array innerArray; for(size_t i = 0; i < params.size(); ++i) { @@ -201,9 +192,9 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi array.add(std::move(innerArray)); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_COMPUTE_SHARED_HMAC_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_COMPUTE_SHARED_HMAC_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { std::vector bstr; @@ -216,14 +207,14 @@ Return JavacardKeymaster4Device::computeSharedHmac(const hidl_vec<::androi return Void(); } -Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& parametersToVerify, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, verifyAuthorization_cb _hidl_cb) { +Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHandle, const hidl_vec& parametersToVerify, const HardwareAuthToken& authToken, verifyAuthorization_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::vector cborOutData; std::string message; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::keymaster::V4_0::VerificationToken verificationToken; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + VerificationToken verificationToken; /* Convert input data to cbor format */ array.add(operationHandle); @@ -231,9 +222,9 @@ Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHan cborConverter_.addHardwareAuthToken(array, authToken); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_VERIFY_AUTHORIZATION_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_VERIFY_AUTHORIZATION_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -244,21 +235,21 @@ Return JavacardKeymaster4Device::verifyAuthorization(uint64_t operationHan return Void(); } -Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::addRngEntropy(const hidl_vec& data) { +Return JavacardKeymaster4Device::addRngEntropy(const hidl_vec& data) { const uint8_t* pos; cppbor::Array array; std::vector cborOutData; std::unique_ptr item; std::string message; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; /* Convert input data to cbor format */ array.add(std::vector(data)); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_ADD_RNG_ENTROPY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_ADD_RNG_ENTROPY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -267,22 +258,22 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device return errorCode; } -Return JavacardKeymaster4Device::generateKey(const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams, generateKey_cb _hidl_cb) { +Return JavacardKeymaster4Device::generateKey(const hidl_vec& keyParams, generateKey_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; hidl_vec keyBlob; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + KeyCharacteristics keyCharacteristics; cborConverter_.addKeyparameters(array, keyParams); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_GENERATE_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_GENERATE_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { std::vector bstr; @@ -297,24 +288,24 @@ Return JavacardKeymaster4Device::generateKey(const hidl_vec<::android::har return Void(); } -Return JavacardKeymaster4Device::importKey(const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams, ::android::hardware::keymaster::V4_0::KeyFormat keyFormat, const hidl_vec& keyData, importKey_cb _hidl_cb) { +Return JavacardKeymaster4Device::importKey(const hidl_vec& keyParams, KeyFormat keyFormat, const hidl_vec& keyData, importKey_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; hidl_vec keyBlob; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + KeyCharacteristics keyCharacteristics; cborConverter_.addKeyparameters(array, keyParams); array.add(static_cast(keyFormat)); array.add(std::vector(keyData)); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_IMPORT_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_IMPORT_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { std::vector bstr; @@ -329,15 +320,15 @@ Return JavacardKeymaster4Device::importKey(const hidl_vec<::android::hardw return Void(); } -Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& wrappedKeyData, const hidl_vec& wrappingKeyBlob, const hidl_vec& maskingKey, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& unwrappingParams, uint64_t passwordSid, uint64_t biometricSid, importWrappedKey_cb _hidl_cb) { +Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& wrappedKeyData, const hidl_vec& wrappingKeyBlob, const hidl_vec& maskingKey, const hidl_vec& unwrappingParams, uint64_t passwordSid, uint64_t biometricSid, importWrappedKey_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; hidl_vec keyBlob; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + KeyCharacteristics keyCharacteristics; array.add(std::vector(wrappedKeyData)); array.add(std::vector(wrappingKeyBlob)); @@ -347,9 +338,9 @@ Return JavacardKeymaster4Device::importWrappedKey(const hidl_vec& array.add(biometricSid); /* TODO if biometricSid optional if user not sent this don't encode this cbor format */ std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_IMPORT_WRAPPED_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_IMPORT_WRAPPED_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { /* TODO keyBlob is BSTR */ @@ -371,17 +362,17 @@ Return JavacardKeymaster4Device::getKeyCharacteristics(const hidl_vec item; std::string message; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::keymaster::V4_0::KeyCharacteristics keyCharacteristics; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + KeyCharacteristics keyCharacteristics; array.add(std::vector(keyBlob)); array.add(std::vector(clientId)); array.add(std::vector(appData)); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_GET_KEY_CHARACTERISTICS_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_GET_KEY_CHARACTERISTICS_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -392,14 +383,14 @@ Return JavacardKeymaster4Device::getKeyCharacteristics(const hidl_vec JavacardKeymaster4Device::exportKey(::android::hardware::keymaster::V4_0::KeyFormat keyFormat, const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, exportKey_cb _hidl_cb) { +Return JavacardKeymaster4Device::exportKey(KeyFormat keyFormat, const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, exportKey_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; hidl_vec keyMaterial; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; array.add(static_cast(keyFormat)); array.add(std::vector(keyBlob)); @@ -407,9 +398,9 @@ Return JavacardKeymaster4Device::exportKey(::android::hardware::keymaster: array.add(std::vector(appData)); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_EXPORT_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_EXPORT_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { /* TODO Keyblobc - BSTR()*/ @@ -423,23 +414,23 @@ Return JavacardKeymaster4Device::exportKey(::android::hardware::keymaster: return Void(); } -Return JavacardKeymaster4Device::attestKey(const hidl_vec& keyToAttest, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& attestParams, attestKey_cb _hidl_cb) { +Return JavacardKeymaster4Device::attestKey(const hidl_vec& keyToAttest, const hidl_vec& attestParams, attestKey_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; hidl_vec keyBlob; std::vector cborOutData; - ::android::hardware::hidl_vec<::android::hardware::hidl_vec> certChain; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + hidl_vec> certChain; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; array.add(std::vector(keyToAttest)); cborConverter_.addKeyparameters(array, attestParams); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_ATTEST_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_ATTEST_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -450,22 +441,22 @@ Return JavacardKeymaster4Device::attestKey(const hidl_vec& keyToA return Void(); } -Return JavacardKeymaster4Device::upgradeKey(const hidl_vec& keyBlobToUpgrade, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& upgradeParams, upgradeKey_cb _hidl_cb) { +Return JavacardKeymaster4Device::upgradeKey(const hidl_vec& keyBlobToUpgrade, const hidl_vec& upgradeParams, upgradeKey_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; hidl_vec upgradedKeyBlob; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; array.add(std::vector(keyBlobToUpgrade)); cborConverter_.addKeyparameters(array, upgradeParams); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_UPGRADE_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_UPGRADE_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { /* TODO Keyblob BSTR(ARRAY) */ @@ -479,20 +470,20 @@ Return JavacardKeymaster4Device::upgradeKey(const hidl_vec& keyBl return Void(); } -Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::deleteKey(const hidl_vec& keyBlob) { +Return JavacardKeymaster4Device::deleteKey(const hidl_vec& keyBlob) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; array.add(std::vector(keyBlob)); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_DELETE_KEY_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_DELETE_KEY_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -501,17 +492,17 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device return errorCode; } -Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::deleteAllKeys() { +Return JavacardKeymaster4Device::deleteAllKeys() { const uint8_t* pos; std::unique_ptr item; std::string message; std::vector cborOutData; std::vector input; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; - int32_t ret = sendData(pTransportFactory, Instruction::INS_DELETE_ALL_KEYS_CMD, input, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_DELETE_ALL_KEYS_CMD, input, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -520,17 +511,17 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device return errorCode; } -Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::destroyAttestationIds() { +Return JavacardKeymaster4Device::destroyAttestationIds() { const uint8_t* pos; std::unique_ptr item; std::string message; std::vector cborOutData; std::vector input; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; - int32_t ret = sendData(pTransportFactory, Instruction::INS_DESTROY_ATT_IDS_CMD, input, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_DESTROY_ATT_IDS_CMD, input, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -539,13 +530,13 @@ Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device return errorCode; } -Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_0::KeyPurpose purpose, const hidl_vec& keyBlob, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, begin_cb _hidl_cb) { - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; +Return JavacardKeymaster4Device::begin(KeyPurpose purpose, const hidl_vec& keyBlob, const hidl_vec& inParams, const HardwareAuthToken& authToken, begin_cb _hidl_cb) { + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + hidl_vec outParams; uint64_t operationHandle = 0; - if (::android::hardware::keymaster::V4_0::KeyPurpose::ENCRYPT == purpose || - ::android::hardware::keymaster::V4_0::KeyPurpose::VERIFY == purpose) { + if (KeyPurpose::ENCRYPT == purpose || + KeyPurpose::VERIFY == purpose) { /* Public key operations are handled here*/ } else { cppbor::Array array; @@ -561,9 +552,9 @@ Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_ cborConverter_.addHardwareAuthToken(array, authToken); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_BEGIN_OPERATION_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_BEGIN_OPERATION_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -576,14 +567,14 @@ Return JavacardKeymaster4Device::begin(::android::hardware::keymaster::V4_ return Void(); } -Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const hidl_vec& input, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken, update_cb _hidl_cb) { +Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hidl_vec& inParams, const hidl_vec& input, const HardwareAuthToken& authToken, const VerificationToken& verificationToken, update_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + hidl_vec outParams; uint32_t inputConsumed = 0; hidl_vec output; @@ -595,9 +586,9 @@ Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hi cborConverter_.addVerificationToken(array, verificationToken); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_UPDATE_OPERATION_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_UPDATE_OPERATION_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { std::vector bstr; @@ -612,14 +603,14 @@ Return JavacardKeymaster4Device::update(uint64_t operationHandle, const hi return Void(); } -Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const hidl_vec& input, const hidl_vec& signature, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken, finish_cb _hidl_cb) { +Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hidl_vec& inParams, const hidl_vec& input, const hidl_vec& signature, const HardwareAuthToken& authToken, const VerificationToken& verificationToken, finish_cb _hidl_cb) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; - ::android::hardware::hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter> outParams; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; + hidl_vec outParams; hidl_vec output; /* Convert input data to cbor format */ @@ -631,9 +622,9 @@ Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hi cborConverter_.addVerificationToken(array, verificationToken); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_FINISH_OPERATION_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_FINISH_OPERATION_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { std::vector bstr; @@ -647,31 +638,31 @@ Return JavacardKeymaster4Device::finish(uint64_t operationHandle, const hi return Void(); } -Return<::android::hardware::keymaster::V4_0::ErrorCode> JavacardKeymaster4Device::abort(uint64_t operationHandle) { +Return JavacardKeymaster4Device::abort(uint64_t operationHandle) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; std::string message; std::vector cborOutData; - ::android::hardware::keymaster::V4_0::ErrorCode errorCode = ::android::hardware::keymaster::V4_0::ErrorCode::UNKNOWN_ERROR; + ErrorCode errorCode = ErrorCode::UNKNOWN_ERROR; /* Convert input data to cbor format */ array.add(operationHandle); std::vector cborData = array.encode(); - int32_t ret = sendData(pTransportFactory, Instruction::INS_ABORT_OPERATION_CMD, cborData, cborOutData); + errorCode = sendData(pTransportFactory, Instruction::INS_ABORT_OPERATION_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(errorCode == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { - cborConverter_.getErrorCode<::android::hardware::keymaster::V4_0::ErrorCode>(item, 0, errorCode); //Errorcode + cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode } } return errorCode; } // Methods from ::android::hardware::keymaster::V4_1::IKeymasterDevice follow. -Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device::deviceLocked(bool passwordOnly, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken) { +Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device::deviceLocked(bool passwordOnly, const VerificationToken& verificationToken) { cppbor::Array array; const uint8_t* pos; std::unique_ptr item; @@ -685,9 +676,9 @@ Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device std::vector cborData = array.encode(); /* TODO DeviceLocked command handled inside HAL */ - int32_t ret = sendData(pTransportFactory, Instruction::INS_DEVICE_LOCKED_CMD, cborData, cborOutData); + ErrorCode ret = sendData(pTransportFactory, Instruction::INS_DEVICE_LOCKED_CMD, cborData, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(ret == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -704,9 +695,9 @@ Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device std::vector cborInput; ::android::hardware::keymaster::V4_1::ErrorCode errorCode = ::android::hardware::keymaster::V4_1::ErrorCode::UNKNOWN_ERROR; - int32_t ret = sendData(pTransportFactory, Instruction::INS_EARLY_BOOT_ENDED_CMD, cborInput, cborOutData); + ErrorCode ret = sendData(pTransportFactory, Instruction::INS_EARLY_BOOT_ENDED_CMD, cborInput, cborOutData); - if(ret == static_cast(::android::hardware::keymaster::V4_0::ErrorCode::OK)) { + if(ret == ErrorCode::OK) { std::tie(item, pos, message) = parse(std::vector(cborOutData.begin(), cborOutData.end()-2));//Skip last 2 bytes, it is status. if (item != nullptr) { cborConverter_.getErrorCode(item, 0, errorCode); //Errorcode @@ -715,7 +706,6 @@ Return<::android::hardware::keymaster::V4_1::ErrorCode> JavacardKeymaster4Device return errorCode; } +} // javacard } // namespace V4_1 } // namespace keymaster -} // namespace hardware -} // namespace android diff --git a/HAL/keymaster/Android.bp b/HAL/keymaster/Android.bp index d708814f..65302a74 100644 --- a/HAL/keymaster/Android.bp +++ b/HAL/keymaster/Android.bp @@ -13,37 +13,9 @@ // limitations under the License. // -cc_binary { - name: "android.hardware.keymaster@4.1-javacard-service", - init_rc: ["4.1/android.hardware.keymaster@4.1-service.javacard.rc"], - srcs: [ - "4.1/service.cpp", - "4.1/JavacardKeymaster4Device.cpp", - "4.1/CborConverter.cpp" - ], - local_include_dirs: [ - "include", - ], - shared_libs: [ - "liblog", - "libcutils", - "libdl", - "libbase", - "libutils", - "libhardware", - "libhidlbase", - "libkeymaster_messages", - "libcppbor_external", - "omapi_external", - "android.hardware.keymaster@4.1", - "jc_transport", - ], -} - cc_library { - name: "android.hardware.keymaster@4.1-javacard", + name: "libJavacardKeymaster41", srcs: [ - "4.1/service.cpp", "4.1/JavacardKeymaster4Device.cpp", "4.1/CborConverter.cpp", ], @@ -63,14 +35,12 @@ cc_library { "omapi_external", "android.hardware.keymaster@4.1", "android.hardware.keymaster@4.0", - "jc_transport", + "libjc_transport", ], } - - cc_library { - name: "jc_transport", + name: "libjc_transport", host_supported: true, vendor_available: true, @@ -85,7 +55,5 @@ cc_library { "libbinder", "libbase", "liblog", - "libutils", - "libcurl" ], } diff --git a/HAL/keymaster/include/JavacardKeymaster4Device.h b/HAL/keymaster/include/JavacardKeymaster4Device.h index 0795ea5f..11318f20 100644 --- a/HAL/keymaster/include/JavacardKeymaster4Device.h +++ b/HAL/keymaster/include/JavacardKeymaster4Device.h @@ -15,8 +15,8 @@ ** limitations under the License. */ -#ifndef ANDROID_HARDWARE_KEYMASTER_V4_1_JAVACARDKEYMASTER4DEVICE_H_ -#define ANDROID_HARDWARE_KEYMASTER_V4_1_JAVACARDKEYMASTER4DEVICE_H_ +#ifndef KEYMASTER_V4_1_JAVACARD_JAVACARDKEYMASTER4DEVICE_H_ +#define KEYMASTER_V4_1_JAVACARD_JAVACARDKEYMASTER4DEVICE_H_ #include #include @@ -25,18 +25,30 @@ #include "CborConverter.h" #include "TransportFactory.h" -namespace android { -namespace hardware { namespace keymaster { namespace V4_1 { +namespace javacard { -using ::android::hardware::hidl_array; -using ::android::hardware::hidl_memory; -using ::android::hardware::hidl_string; using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; using ::android::hardware::Return; using ::android::hardware::Void; -using ::android::sp; + +using ::android::hardware::keymaster::V4_0::ErrorCode; +using ::android::hardware::keymaster::V4_0::HardwareAuthenticatorType; +using ::android::hardware::keymaster::V4_0::HardwareAuthToken; +using ::android::hardware::keymaster::V4_0::HmacSharingParameters; +using ::android::hardware::keymaster::V4_0::KeyCharacteristics; +using ::android::hardware::keymaster::V4_0::KeyFormat; +using ::android::hardware::keymaster::V4_0::KeyParameter; +using ::android::hardware::keymaster::V4_0::KeyPurpose; +using ::android::hardware::keymaster::V4_0::OperationHandle; +using ::android::hardware::keymaster::V4_0::SecurityLevel; +using ::android::hardware::keymaster::V4_0::VerificationToken; +using ::android::hardware::keymaster::V4_1::IKeymasterDevice; +using ::android::hardware::keymaster::V4_1::Tag; + +using V41ErrorCode = ::android::hardware::keymaster::V4_1::ErrorCode; class JavacardKeymaster4Device : public IKeymasterDevice { public: @@ -46,41 +58,40 @@ class JavacardKeymaster4Device : public IKeymasterDevice { android::base::GetBoolProperty("ro.kernel.qemu", false)); } - virtual ~JavacardKeymaster4Device(); + virtual ~JavacardKeymaster4Device() {} // Methods from ::android::hardware::keymaster::V4_0::IKeymasterDevice follow. Return getHardwareInfo(getHardwareInfo_cb _hidl_cb) override; Return getHmacSharingParameters(getHmacSharingParameters_cb _hidl_cb) override; - Return computeSharedHmac(const hidl_vec<::android::hardware::keymaster::V4_0::HmacSharingParameters>& params, computeSharedHmac_cb _hidl_cb) override; - Return verifyAuthorization(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& parametersToVerify, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, verifyAuthorization_cb _hidl_cb) override; - Return<::android::hardware::keymaster::V4_0::ErrorCode> addRngEntropy(const hidl_vec& data) override; - Return generateKey(const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams, generateKey_cb _hidl_cb) override; - Return importKey(const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& keyParams, ::android::hardware::keymaster::V4_0::KeyFormat keyFormat, const hidl_vec& keyData, importKey_cb _hidl_cb) override; - Return importWrappedKey(const hidl_vec& wrappedKeyData, const hidl_vec& wrappingKeyBlob, const hidl_vec& maskingKey, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& unwrappingParams, uint64_t passwordSid, uint64_t biometricSid, importWrappedKey_cb _hidl_cb) override; + Return computeSharedHmac(const hidl_vec& params, computeSharedHmac_cb _hidl_cb) override; + Return verifyAuthorization(uint64_t operationHandle, const hidl_vec& parametersToVerify, const HardwareAuthToken& authToken, verifyAuthorization_cb _hidl_cb) override; + Return addRngEntropy(const hidl_vec& data) override; + Return generateKey(const hidl_vec& keyParams, generateKey_cb _hidl_cb) override; + Return importKey(const hidl_vec& keyParams, KeyFormat keyFormat, const hidl_vec& keyData, importKey_cb _hidl_cb) override; + Return importWrappedKey(const hidl_vec& wrappedKeyData, const hidl_vec& wrappingKeyBlob, const hidl_vec& maskingKey, const hidl_vec& unwrappingParams, uint64_t passwordSid, uint64_t biometricSid, importWrappedKey_cb _hidl_cb) override; Return getKeyCharacteristics(const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, getKeyCharacteristics_cb _hidl_cb) override; - Return exportKey(::android::hardware::keymaster::V4_0::KeyFormat keyFormat, const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, exportKey_cb _hidl_cb) override; - Return attestKey(const hidl_vec& keyToAttest, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& attestParams, attestKey_cb _hidl_cb) override; - Return upgradeKey(const hidl_vec& keyBlobToUpgrade, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& upgradeParams, upgradeKey_cb _hidl_cb) override; - Return<::android::hardware::keymaster::V4_0::ErrorCode> deleteKey(const hidl_vec& keyBlob) override; - Return<::android::hardware::keymaster::V4_0::ErrorCode> deleteAllKeys() override; - Return<::android::hardware::keymaster::V4_0::ErrorCode> destroyAttestationIds() override; - Return begin(::android::hardware::keymaster::V4_0::KeyPurpose purpose, const hidl_vec& keyBlob, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, begin_cb _hidl_cb) override; - Return update(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const hidl_vec& input, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken, update_cb _hidl_cb) override; - Return finish(uint64_t operationHandle, const hidl_vec<::android::hardware::keymaster::V4_0::KeyParameter>& inParams, const hidl_vec& input, const hidl_vec& signature, const ::android::hardware::keymaster::V4_0::HardwareAuthToken& authToken, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken, finish_cb _hidl_cb) override; - Return<::android::hardware::keymaster::V4_0::ErrorCode> abort(uint64_t operationHandle) override; + Return exportKey(KeyFormat keyFormat, const hidl_vec& keyBlob, const hidl_vec& clientId, const hidl_vec& appData, exportKey_cb _hidl_cb) override; + Return attestKey(const hidl_vec& keyToAttest, const hidl_vec& attestParams, attestKey_cb _hidl_cb) override; + Return upgradeKey(const hidl_vec& keyBlobToUpgrade, const hidl_vec& upgradeParams, upgradeKey_cb _hidl_cb) override; + Return deleteKey(const hidl_vec& keyBlob) override; + Return deleteAllKeys() override; + Return destroyAttestationIds() override; + Return begin(KeyPurpose purpose, const hidl_vec& keyBlob, const hidl_vec& inParams, const HardwareAuthToken& authToken, begin_cb _hidl_cb) override; + Return update(uint64_t operationHandle, const hidl_vec& inParams, const hidl_vec& input, const HardwareAuthToken& authToken, const VerificationToken& verificationToken, update_cb _hidl_cb) override; + Return finish(uint64_t operationHandle, const hidl_vec& inParams, const hidl_vec& input, const hidl_vec& signature, const HardwareAuthToken& authToken, const VerificationToken& verificationToken, finish_cb _hidl_cb) override; + Return abort(uint64_t operationHandle) override; // Methods from ::android::hardware::keymaster::V4_1::IKeymasterDevice follow. - Return<::android::hardware::keymaster::V4_1::ErrorCode> deviceLocked(bool passwordOnly, const ::android::hardware::keymaster::V4_0::VerificationToken& verificationToken) override; - Return<::android::hardware::keymaster::V4_1::ErrorCode> earlyBootEnded() override; + Return deviceLocked(bool passwordOnly, const VerificationToken& verificationToken) override; + Return earlyBootEnded() override; protected: CborConverter cborConverter_; std::unique_ptr pTransportFactory; }; +} // namespace javacard } // namespace V4_1 } // namespace keymaster -} // namespace hardware -} // namespace android -#endif // ANDROID_HARDWARE_KEYMASTER_V4_1_JAVACARDKEYMASTER4DEVICE_H_ +#endif // KEYMASTER_V4_1_JAVACARD_JAVACARDKEYMASTER4DEVICE_H_ From e50e516ee832f1e90203fcf807f246e2eeb27398 Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Wed, 13 May 2020 22:00:02 +0530 Subject: [PATCH 12/13] openConnection moved to Constructor --- HAL/keymaster/4.1/JavacardKeymaster4Device.cpp | 6 +++--- HAL/keymaster/include/JavacardKeymaster4Device.h | 1 + 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp index 2f3c3684..0c28f055 100644 --- a/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp +++ b/HAL/keymaster/4.1/JavacardKeymaster4Device.cpp @@ -104,9 +104,9 @@ std::vector& response) { ErrorCode ret = constructApduMessage(ins, inData, apdu); if(ret != ErrorCode::OK) return ret; - if(!transport->openConnection()) { - return (ErrorCode::SECURE_HW_COMMUNICATION_FAILED); - } + //if(!transport->openConnection()) { + // return (ErrorCode::SECURE_HW_COMMUNICATION_FAILED); + //} if(!transport->sendData(apdu.data(), apdu.size(), response)) { return (ErrorCode::SECURE_HW_COMMUNICATION_FAILED); diff --git a/HAL/keymaster/include/JavacardKeymaster4Device.h b/HAL/keymaster/include/JavacardKeymaster4Device.h index 11318f20..0ced32ab 100644 --- a/HAL/keymaster/include/JavacardKeymaster4Device.h +++ b/HAL/keymaster/include/JavacardKeymaster4Device.h @@ -56,6 +56,7 @@ class JavacardKeymaster4Device : public IKeymasterDevice { /* TODO instead do we need to create object like this std::unique_ptr(new TransportFactory(true));*/ pTransportFactory = std::make_unique( android::base::GetBoolProperty("ro.kernel.qemu", false)); + pTransportFactory->openConnection(); } virtual ~JavacardKeymaster4Device() {} From 53b9d1c3837e855d9d80d84b66830c91360dddba Mon Sep 17 00:00:00 2001 From: BKSSM Venkateswarlu Date: Wed, 13 May 2020 23:00:15 +0530 Subject: [PATCH 13/13] Remove unnecessary functions and add assert statement --- HAL/keymaster/4.1/OmapiTransport.cpp | 12 ------ HAL/keymaster/4.1/SocketTransport.cpp | 43 ------------------- .../include/JavacardKeymaster4Device.h | 8 ++-- HAL/keymaster/include/Transport.h | 9 ---- HAL/keymaster/include/TransportFactory.h | 8 ---- 5 files changed, 4 insertions(+), 76 deletions(-) diff --git a/HAL/keymaster/4.1/OmapiTransport.cpp b/HAL/keymaster/4.1/OmapiTransport.cpp index a981edb2..5aaefc91 100644 --- a/HAL/keymaster/4.1/OmapiTransport.cpp +++ b/HAL/keymaster/4.1/OmapiTransport.cpp @@ -32,18 +32,6 @@ bool OmapiTransport::openConnection() { return true; } -bool OmapiTransport::openConnection(connectionCallback cb) { - cb(true); - return true; -} - -bool OmapiTransport::sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) { - std::vector test(inData, inData+inLen); - cb(test); - return true; - -} - bool OmapiTransport::sendData(const uint8_t* inData, const size_t inLen, std::vector& output) { std::vector test(inData, inData+inLen); output = std::move(test); diff --git a/HAL/keymaster/4.1/SocketTransport.cpp b/HAL/keymaster/4.1/SocketTransport.cpp index 11ecd6d8..b03262d1 100644 --- a/HAL/keymaster/4.1/SocketTransport.cpp +++ b/HAL/keymaster/4.1/SocketTransport.cpp @@ -54,49 +54,6 @@ bool SocketTransport::openConnection() { return true; } -bool SocketTransport::openConnection(connectionCallback cb) { - struct sockaddr_in serv_addr; - - if ((mSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) - { - LOG(ERROR) << "Socket creation failed"; - return false; - } - - serv_addr.sin_family = AF_INET; - serv_addr.sin_port = htons(PORT); - - // Convert IPv4 and IPv6 addresses from text to binary form - if(inet_pton(AF_INET, IPADDR, &serv_addr.sin_addr)<=0) - { - LOG(ERROR) << "Invalid address/ Address not supported."; - return false; - } - - if (connect(mSocket, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) - { - LOG(ERROR) << "Connection failed."; - return false; - } - cb(true);// This can be used for Asynchronous calls. - return true; -} - -bool SocketTransport::sendData(const uint8_t* data, const size_t dataSize, responseCallback cb) { - uint8_t buffer[MAX_RECV_BUFFER_SIZE]; - if (0 > send(mSocket, data ,dataSize , 0 )) { - LOG(ERROR) << "Failed to send data over socket."; - return false; - } - ssize_t valRead = read( mSocket , buffer, MAX_RECV_BUFFER_SIZE); - if(0 > valRead) { - LOG(ERROR) << "Failed to read data from socket."; - } - std::vector output(buffer, buffer+valRead); - cb(output); - return true; -} - bool SocketTransport::sendData(const uint8_t* inData, const size_t inLen, std::vector& output) { uint8_t buffer[MAX_RECV_BUFFER_SIZE]; if (0 > send(mSocket, inData, inLen , 0 )) { diff --git a/HAL/keymaster/include/JavacardKeymaster4Device.h b/HAL/keymaster/include/JavacardKeymaster4Device.h index 0ced32ab..6bb62387 100644 --- a/HAL/keymaster/include/JavacardKeymaster4Device.h +++ b/HAL/keymaster/include/JavacardKeymaster4Device.h @@ -18,6 +18,7 @@ #ifndef KEYMASTER_V4_1_JAVACARD_JAVACARDKEYMASTER4DEVICE_H_ #define KEYMASTER_V4_1_JAVACARD_JAVACARDKEYMASTER4DEVICE_H_ +#include #include #include #include @@ -53,10 +54,9 @@ using V41ErrorCode = ::android::hardware::keymaster::V4_1::ErrorCode; class JavacardKeymaster4Device : public IKeymasterDevice { public: JavacardKeymaster4Device() { - /* TODO instead do we need to create object like this std::unique_ptr(new TransportFactory(true));*/ - pTransportFactory = std::make_unique( - android::base::GetBoolProperty("ro.kernel.qemu", false)); - pTransportFactory->openConnection(); + pTransportFactory = std::unique_ptr(new se_transport::TransportFactory( + android::base::GetBoolProperty("ro.kernel.qemu", false))); + assert(pTransportFactory->openConnection() && "Failed to open connection with secure element"); } virtual ~JavacardKeymaster4Device() {} diff --git a/HAL/keymaster/include/Transport.h b/HAL/keymaster/include/Transport.h index a6b917b3..aadb3f00 100644 --- a/HAL/keymaster/include/Transport.h +++ b/HAL/keymaster/include/Transport.h @@ -19,15 +19,10 @@ namespace se_transport { -typedef void (*connectionCallback)(bool connected); -typedef void (*responseCallback)(std::vector output); - class ITransport { public: virtual ~ITransport(){} - virtual bool openConnection(connectionCallback cb) = 0; virtual bool openConnection() = 0; - virtual bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) = 0; virtual bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) = 0; virtual bool closeConnection() = 0; virtual bool isConnected() = 0; @@ -38,9 +33,7 @@ class OmapiTransport : public ITransport { public: - bool openConnection(connectionCallback cb) override; bool openConnection() override; - bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) override; virtual bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) override; bool closeConnection() override; bool isConnected() override; @@ -50,9 +43,7 @@ class OmapiTransport : public ITransport { class SocketTransport : public ITransport { public: - bool openConnection(connectionCallback cb) override; bool openConnection() override; - bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) override; virtual bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) override; bool closeConnection() override; bool isConnected() override; diff --git a/HAL/keymaster/include/TransportFactory.h b/HAL/keymaster/include/TransportFactory.h index f8d9240b..2e01e66b 100644 --- a/HAL/keymaster/include/TransportFactory.h +++ b/HAL/keymaster/include/TransportFactory.h @@ -32,18 +32,10 @@ class TransportFactory { ~TransportFactory() {} - inline bool openConnection(connectionCallback cb) { - return mTransport->openConnection(cb); - } - inline bool openConnection() { return mTransport->openConnection(); } - inline bool sendData(const uint8_t* inData, const size_t inLen, responseCallback cb) { - return mTransport->sendData(inData, inLen, cb); - } - inline bool sendData(const uint8_t* inData, const size_t inLen, std::vector& output) { return mTransport->sendData(inData, inLen, output); }