diff options
author | Lee Campbell <leecam@google.com> | 2016-04-15 05:20:46 +0000 |
---|---|---|
committer | android-build-merger <android-build-merger@google.com> | 2016-04-15 05:20:46 +0000 |
commit | 460106e27a5ddb6d2e93a43315ed5938efca9f86 (patch) | |
tree | af0d945a0f8936f2b94a5ae087d9d6a3634d71a0 | |
parent | 8c816b034025423dd65fc2393a3dae483dd33e7f (diff) | |
parent | c87abf7ca8b45976286c5431030fe6743280b6c0 (diff) | |
download | intel-460106e27a5ddb6d2e93a43315ed5938efca9f86.tar.gz |
Merge "Revert "chaabi: initial commit for intel keymaster""
am: c87abf7
* commit 'c87abf7ca8b45976286c5431030fe6743280b6c0':
Revert "chaabi: initial commit for intel keymaster"
Change-Id: I0a714928b2a3d3ac48a4c683dc21f8f1d24f7d76
-rw-r--r-- | peripheral/keystore/chaabi/src/hal.mk | 26 | ||||
-rw-r--r-- | peripheral/keystore/chaabi/src/intel_keymaster.cpp | 1450 | ||||
-rw-r--r-- | peripheral/keystore/chaabi/src/intelkeymaster_firmware_api.h | 146 | ||||
-rw-r--r-- | peripheral/keystore/chaabi/src/intelkeymaster_middleware_api.h | 52 | ||||
-rw-r--r-- | peripheral/keystore/chaabi/src/peripheral.mk | 17 |
5 files changed, 0 insertions, 1691 deletions
diff --git a/peripheral/keystore/chaabi/src/hal.mk b/peripheral/keystore/chaabi/src/hal.mk deleted file mode 100644 index d8417e3..0000000 --- a/peripheral/keystore/chaabi/src/hal.mk +++ /dev/null @@ -1,26 +0,0 @@ -# Copyright (C) 2016 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. - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) -LOCAL_MODULE := keystore.$(TARGET_DEVICE) -LOCAL_MODULE_RELATIVE_PATH := hw -LOCAL_SRC_FILES := intel_keymaster.cpp -LOCAL_C_INCLUDES := system/security/keystore -LOCAL_CFLAGS = -fvisibility=hidden -Wall -Werror -LOCAL_SHARED_LIBRARIES := libcutils libcrypto liblog libkeystore_binder libkeymaster -LOCAL_MODULE_TAGS := optional -LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/hal.mk $(LOCAL_PATH)/peripheral.mk -include $(BUILD_SHARED_LIBRARY) diff --git a/peripheral/keystore/chaabi/src/intel_keymaster.cpp b/peripheral/keystore/chaabi/src/intel_keymaster.cpp deleted file mode 100644 index 12ad18b..0000000 --- a/peripheral/keystore/chaabi/src/intel_keymaster.cpp +++ /dev/null @@ -1,1450 +0,0 @@ -/* - * Copyright (C) 2016 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 <errno.h> -#include <cstdlib> -#include <string> - -#include <keystore/keystore.h> - -#include <hardware/hardware.h> -#include <hardware/keymaster0.h> - -#include <openssl/evp.h> -#include <openssl/bio.h> -#include <openssl/rsa.h> -#include <openssl/err.h> -#include <openssl/x509.h> - -#include <cutils/properties.h> -#include <UniquePtr.h> - -#include "intelkeymaster_firmware_api.h" -#include "intelkeymaster_middleware_api.h" -// For debugging -//#define LOG_NDEBUG 0 - -#define LOG_TAG "IntelKeyMaster" -#include <cutils/log.h> - -struct BIGNUM_Delete { - void operator()(BIGNUM* p) const { - BN_free(p); - } -}; -typedef UniquePtr<BIGNUM, BIGNUM_Delete> Unique_BIGNUM; - -struct EVP_PKEY_Delete { - void operator()(EVP_PKEY* p) const { - EVP_PKEY_free(p); - } -}; -typedef UniquePtr<EVP_PKEY, EVP_PKEY_Delete> Unique_EVP_PKEY; - -struct PKCS8_PRIV_KEY_INFO_Delete { - void operator()(PKCS8_PRIV_KEY_INFO* p) const { - PKCS8_PRIV_KEY_INFO_free(p); - } -}; -typedef UniquePtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_Delete> Unique_PKCS8_PRIV_KEY_INFO; - -struct RSA_Delete { - void operator()(RSA* p) const { - RSA_free(p); - } -}; -typedef UniquePtr<RSA, RSA_Delete> Unique_RSA; - -struct Malloc_Free { - void operator()(void* p) const { free(p); } -}; - -typedef UniquePtr<keymaster0_device_t> Unique_keymaster_device_t; - -/* intel keymaster functions */ -int intel_keymaster_generate_rsa_keypair(const keymaster_rsa_keygen_params_t* rsa_params, - uint8_t** keyBlob, size_t* keyBlobLength); - -int intel_keymaster_import_rsa_keypair(const RSA *rsa, - uint8_t** keyBlob, size_t* keyBlobLength); - -EVP_PKEY* intel_keymaster_unwrap_key(const uint8_t* keyBlob, const size_t keyBlobLength); - -int intel_keymaster_sign_rsa(const uint8_t* keyBlob, const size_t keyBlobLength, - const uint8_t* data, const size_t dataLength, - uint8_t** signedData, size_t* signedDataLength); - -int intel_keymaster_verify_rsa(const uint8_t* keyBlob, const size_t keyBlobLength, - const uint8_t* signedData, const size_t signedDataLength, - const uint8_t* signature, const size_t signatureLength); - -/** - * Many OpenSSL APIs take ownership of an argument on success but don't free the argument - * on failure. This means we need to tell our scoped pointers when we've transferred ownership, - * without triggering a warning by not using the result of release(). - */ -#define OWNERSHIP_TRANSFERRED(obj) \ - typeof (obj.release()) _dummy __attribute__((unused)) = obj.release() - -/* - * Size in bytes of an empty RSA public key modulus. Used as an error code. - */ -#define NULL_RSA_MODULUS_SIZE_IN_BYTES 0 - -/* - * Checks this thread's OpenSSL error queue and logs if - * necessary. - */ -static void logOpenSSLError(const char* location) { - int error = ERR_get_error(); - - if (error != 0) { - char message[256]; - ERR_error_string_n(error, message, sizeof(message)); - ALOGE("OpenSSL error in %s %d: %s", location, error, message); - } - - ERR_clear_error(); - ERR_remove_state(0); -} - -static int wrap_key(EVP_PKEY* pkey, int type, uint8_t** keyBlob, size_t* keyBlobLength) { - /* - * Find the length of each size. Public key is not needed anymore but must be kept for - * alignment purposes. - */ - int publicLen = 0; - int privateLen = i2d_PrivateKey(pkey, NULL); - - if (privateLen <= 0) { - ALOGE("private key size was too big"); - return -1; - } - - /* int type + int size + private key data + int size + public key data */ - *keyBlobLength = get_softkey_header_size() + sizeof(type) + sizeof(publicLen) + privateLen - + sizeof(privateLen) + publicLen; - - UniquePtr<unsigned char, Malloc_Free> derData(static_cast<unsigned char*>(malloc(*keyBlobLength))); - - if (derData.get() == NULL) { - ALOGE("could not allocate memory for key blob"); - return -1; - } - unsigned char* p = derData.get(); - - /* Write the magic value for software keys. */ - p = add_softkey_header(p, *keyBlobLength); - - /* Write key type to allocated buffer */ - for (int i = sizeof(type) - 1; i >= 0; i--) { - *p++ = (type >> (8*i)) & 0xFF; - } - - /* Write public key to allocated buffer */ - for (int i = sizeof(publicLen) - 1; i >= 0; i--) { - *p++ = (publicLen >> (8*i)) & 0xFF; - } - - /* Write private key to allocated buffer */ - for (int i = sizeof(privateLen) - 1; i >= 0; i--) { - *p++ = (privateLen >> (8*i)) & 0xFF; - } - if (i2d_PrivateKey(pkey, &p) != privateLen) { - logOpenSSLError("wrap_key"); - return -1; - } - - *keyBlob = derData.release(); - - return 0; -} - -static EVP_PKEY* unwrap_key(const uint8_t* keyBlob, const size_t keyBlobLength) { - long publicLen = 0; - long privateLen = 0; - const uint8_t* p = keyBlob; - const uint8_t *const end = keyBlob + keyBlobLength; - int type = 0; - - if (keyBlob == NULL) { - ALOGE("supplied key blob was NULL"); - return NULL; - } - - // Should be large enough for: - // int32 magic, int32 type, int32 pubLen, char* pub, int32 privLen, char* priv - if (keyBlobLength < (get_softkey_header_size() + sizeof(type) + sizeof(publicLen) + 1 - + sizeof(privateLen) + 1)) { - ALOGE("key blob appears to be truncated"); - return NULL; - } - - if (!is_softkey(p, keyBlobLength)) { - ALOGE("cannot read key; it was not made by this keymaster"); - return NULL; - } - p += get_softkey_header_size(); - - for (size_t i = 0; i < sizeof(type); i++) { - type = (type << 8) | *p++; - } - - for (size_t i = 0; i < sizeof(publicLen); i++) { - publicLen = (publicLen << 8) | *p++; - } - if (p + publicLen > end) { - ALOGE("public key length encoding error: size=%ld, end=%td", publicLen, end - p); - return NULL; - } - - p += publicLen; - if (end - p < 2) { - ALOGE("private key truncated"); - return NULL; - } - for (size_t i = 0; i < sizeof(privateLen); i++) { - privateLen = (privateLen << 8) | *p++; - } - if (p + privateLen > end) { - ALOGE("private key length encoding error: size=%ld, end=%td", privateLen, end - p); - return NULL; - } - - Unique_EVP_PKEY pkey(EVP_PKEY_new()); - if (pkey.get() == NULL) { - logOpenSSLError("unwrap_key"); - return NULL; - } - EVP_PKEY* tmp = pkey.get(); - - if (d2i_PrivateKey(type, &tmp, &p, privateLen) == NULL) { - logOpenSSLError("unwrap_key"); - return NULL; - } - - return pkey.release(); -} - -__attribute__ ((visibility ("default"))) -int intel_keymaster_generate_keypair(const keymaster0_device_t*, - const keymaster_keypair_t key_type, const void* key_params, - uint8_t** keyBlob, size_t* keyBlobLength) { - - if (key_type == TYPE_RSA) { - return intel_keymaster_generate_rsa_keypair( - reinterpret_cast<const keymaster_rsa_keygen_params_t*>(key_params), - keyBlob, keyBlobLength); - } - - Unique_EVP_PKEY pkey(EVP_PKEY_new()); - if (pkey.get() == NULL) { - logOpenSSLError("intel_keymaster_generate_keypair"); - return -1; - } - - if (key_params == NULL) { - ALOGW("key_params == null"); - return -1; - } else { - ALOGW("Unsupported key type %d", key_type); - return -1; - } - - if (wrap_key(pkey.get(), EVP_PKEY_type(pkey->type), keyBlob, keyBlobLength)) { - return -1; - } - - return 0; -} - -__attribute__ ((visibility ("default"))) -int intel_keymaster_import_keypair(const keymaster0_device_t*, - const uint8_t* key, const size_t key_length, - uint8_t** key_blob, size_t* key_blob_length) { - if (key == NULL) { - ALOGW("input key == NULL"); - return -1; - } else if (key_blob == NULL || key_blob_length == NULL) { - ALOGW("output key blob or length == NULL"); - return -1; - } - - Unique_PKCS8_PRIV_KEY_INFO pkcs8(d2i_PKCS8_PRIV_KEY_INFO(NULL, &key, key_length)); - if (pkcs8.get() == NULL) { - logOpenSSLError("intel_keymaster_import_keypair"); - return -1; - } - - /* assign to EVP */ - Unique_EVP_PKEY pkey(EVP_PKCS82PKEY(pkcs8.get())); - if (pkey.get() == NULL) { - logOpenSSLError("intel_keymaster_import_keypair"); - return -1; - } - - int type = EVP_PKEY_type(pkey->type); - if (type == EVP_PKEY_RSA) { - Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey.get())); - if (rsa.get() == NULL) { - ALOGE("rsa == NULL"); - return -1; - } - return intel_keymaster_import_rsa_keypair(rsa.get(), key_blob, key_blob_length); - } - - if (wrap_key(pkey.get(), EVP_PKEY_type(pkey->type), key_blob, key_blob_length)) { - return -1; - } - - return 0; -} - -__attribute__ ((visibility ("default"))) -int intel_keymaster_get_keypair_public(const struct keymaster0_device*, - const uint8_t* key_blob, const size_t key_blob_length, - uint8_t** x509_data, size_t* x509_data_length) { - - if (x509_data == NULL || x509_data_length == NULL) { - ALOGW("output public key buffer == NULL"); - return -1; - } - - Unique_EVP_PKEY pkey(unwrap_key(key_blob, key_blob_length)); - if (pkey.get() == NULL) { - /* if the keyblob cannot be unwrapped using the softkey method, - then assume it is intel generated keyblob - */ - pkey.reset(intel_keymaster_unwrap_key(key_blob, key_blob_length)); - if (pkey.get() == NULL) { - return -1; - } - } - - int len = i2d_PUBKEY(pkey.get(), NULL); - if (len <= 0) { - logOpenSSLError("intel_keymaster_get_keypair_public"); - return -1; - } - - UniquePtr<uint8_t, Malloc_Free> key(static_cast<uint8_t*>(malloc(len))); - if (key.get() == NULL) { - ALOGE("Could not allocate memory for public key data"); - return -1; - } - - unsigned char* tmp = reinterpret_cast<unsigned char*>(key.get()); - if (i2d_PUBKEY(pkey.get(), &tmp) != len) { - logOpenSSLError("intel_keymaster_get_keypair_public"); - return -1; - } - - ALOGV("Length of x509 data is %d", len); - *x509_data_length = len; - *x509_data = key.release(); - - return 0; -} - -static int sign_rsa(EVP_PKEY* pkey, keymaster_rsa_sign_params_t* sign_params, const uint8_t* data, - const size_t dataLength, uint8_t** signedData, size_t* signedDataLength) { - if (sign_params->digest_type != DIGEST_NONE) { - ALOGW("Cannot handle digest type %d", sign_params->digest_type); - return -1; - } else if (sign_params->padding_type != PADDING_NONE) { - ALOGW("Cannot handle padding type %d", sign_params->padding_type); - return -1; - } - - Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey)); - if (rsa.get() == NULL) { - logOpenSSLError("openssl_sign_rsa"); - return -1; - } - - UniquePtr<uint8_t, Malloc_Free> signedDataPtr(reinterpret_cast<uint8_t*>(malloc(dataLength))); - if (signedDataPtr.get() == NULL) { - logOpenSSLError("openssl_sign_rsa"); - return -1; - } - - unsigned char* tmp = reinterpret_cast<unsigned char*>(signedDataPtr.get()); - if (RSA_private_encrypt(dataLength, data, tmp, rsa.get(), RSA_NO_PADDING) <= 0) { - logOpenSSLError("openssl_sign_rsa"); - return -1; - } - - *signedDataLength = dataLength; - *signedData = signedDataPtr.release(); - - return 0; -} - -__attribute__ ((visibility ("default"))) -int intel_keymaster_sign_data(const keymaster0_device_t*, - const void* params, - const uint8_t* keyBlob, const size_t keyBlobLength, - const uint8_t* data, const size_t dataLength, - uint8_t** signedData, size_t* signedDataLength) { - if (data == NULL) { - ALOGW("input data to sign == NULL"); - return -1; - } else if (signedData == NULL || signedDataLength == NULL) { - ALOGW("output signature buffer == NULL"); - return -1; - } - - Unique_EVP_PKEY pkey(unwrap_key(keyBlob, keyBlobLength)); - if (pkey.get() == NULL) { - /* if the keyblob cannot be unwrapped using the softkey method, - then assume it is intel generated keyblob - */ - return intel_keymaster_sign_rsa(keyBlob, keyBlobLength, - data, dataLength, - signedData, signedDataLength); - } - - int type = EVP_PKEY_type(pkey->type); - if (type == EVP_PKEY_RSA) { - keymaster_rsa_sign_params_t* sign_params = (keymaster_rsa_sign_params_t*) params; - return sign_rsa(pkey.get(), sign_params, data, dataLength, signedData, signedDataLength); - } else { - ALOGW("Unsupported key type"); - return -1; - } -} - -static int verify_rsa(EVP_PKEY* pkey, keymaster_rsa_sign_params_t* sign_params, - const uint8_t* signedData, const size_t signedDataLength, const uint8_t* signature, - const size_t signatureLength) { - if (sign_params->digest_type != DIGEST_NONE) { - ALOGW("Cannot handle digest type %d", sign_params->digest_type); - return -1; - } else if (sign_params->padding_type != PADDING_NONE) { - ALOGW("Cannot handle padding type %d", sign_params->padding_type); - return -1; - } else if (signatureLength != signedDataLength) { - ALOGW("signed data length must be signature length"); - return -1; - } - - Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey)); - if (rsa.get() == NULL) { - logOpenSSLError("verify_rsa"); - return -1; - } - - UniquePtr<uint8_t, Malloc_Free> dataPtr(reinterpret_cast<uint8_t*>(malloc(signedDataLength))); - if (dataPtr.get() == NULL) { - logOpenSSLError("verify_rsa"); - return -1; - } - - unsigned char* tmp = reinterpret_cast<unsigned char*>(dataPtr.get()); - if (!RSA_public_decrypt(signatureLength, signature, tmp, rsa.get(), RSA_NO_PADDING)) { - logOpenSSLError("verify_rsa"); - return -1; - } - - int result = 0; - for (size_t i = 0; i < signedDataLength; i++) { - result |= tmp[i] ^ signedData[i]; - } - - return result == 0 ? 0 : -1; -} - -__attribute__ ((visibility ("default"))) -int intel_keymaster_verify_data(const keymaster0_device_t*, - const void* params, - const uint8_t* keyBlob, const size_t keyBlobLength, - const uint8_t* signedData, const size_t signedDataLength, - const uint8_t* signature, const size_t signatureLength) { - - if (signedData == NULL || signature == NULL) { - ALOGW("data or signature buffers == NULL"); - return -1; - } - - Unique_EVP_PKEY pkey(unwrap_key(keyBlob, keyBlobLength)); - if (pkey.get() == NULL) { - /* if the keyblob cannot be unwrapped using the softkey method, - then assume it is intel generated keyblob - */ - return intel_keymaster_verify_rsa(keyBlob, keyBlobLength, - signedData, signedDataLength, - signature, signatureLength); - } - - int type = EVP_PKEY_type(pkey->type); - if (type == EVP_PKEY_RSA) { - keymaster_rsa_sign_params_t* sign_params = (keymaster_rsa_sign_params_t*) params; - return verify_rsa(pkey.get(), sign_params, signedData, signedDataLength, signature, - signatureLength); - } else { - ALOGW("Unsupported key type %d", type); - return -1; - } - -} - -int intel_keymaster_generate_rsa_keypair(const keymaster_rsa_keygen_params_t* rsa_params, - uint8_t** keyBlob, size_t* keyBlobLength) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_keygen_params_t *keygen_params; - intel_keymaster_rsa_keygen_params_t *rsa_keygen_params; - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - intel_keymaster_key_blob_t *key_blob; - uint32_t rsp_result_and_data_length; - - if ((rsa_params == NULL) || (keyBlob == NULL) || (keyBlobLength == NULL)) { - return -1; - } - - if (cmd_buf.get() == NULL) { - return -1; - } - - if (rsp_buf.get() == NULL) { - return -1; - } - - keygen_params = (intel_keymaster_keygen_params_t *)cmd_buf->cmd_data; - keygen_params->key_type = KEY_TYPE_RSA; - rsa_keygen_params = (intel_keymaster_rsa_keygen_params_t *)keygen_params->key_params; - rsa_keygen_params->modulus_size = rsa_params->modulus_size; - rsa_keygen_params->reserved = 0; - rsa_keygen_params->public_exponent = rsa_params->public_exponent; - cmd_buf->cmd_id = KEYMASTER_CMD_GENERATE_KEYPAIR; - cmd_buf->cmd_data_length = sizeof(intel_keymaster_rsa_keygen_params_t) + - offsetof(intel_keymaster_keygen_params_t, key_params); - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return -1; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return -1; - } - - // rsp_result_and_data_length should include at least the result field - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length too small, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return -1; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return -1; - } - - key_blob = (intel_keymaster_key_blob_t *)rsp_buf->rsp_data; - - if (key_blob->key_blob_length == 0) { - ALOGE("key_blob_length is 0"); - return -1; - } - - rsp_result_and_data_length = key_blob->key_blob_length + - offsetof(intel_keymaster_key_blob_t, key_blob) + sizeof(intel_keymaster_result_t); - if (rsp_result_and_data_length != rsp_buf->rsp_result_and_data_length) { - ALOGE("calculated rsp_result_and_data_length %u does not match rsp_result_and_data_length " - "%u in structure", - rsp_result_and_data_length, rsp_buf->rsp_result_and_data_length); - return -1; - } - - if (rsp_buf->rsp_result_and_data_length + offsetof(intel_keymaster_firmware_rsp_t, result) != - rsp_len) { - ALOGE("rsp_result_and_data_length %u is inconsistent with rsp_len %u", - rsp_buf->rsp_result_and_data_length, rsp_len); - return -1; - } - - *keyBlobLength = key_blob->key_blob_length; - /* freeing memory allocated here is the responsibility of the caller several layers above */ - *keyBlob = (uint8_t *)malloc(key_blob->key_blob_length); - if (*keyBlob == NULL) { - ALOGE("memory allocation for keyBlob failed"); - return -1; - } - - memcpy(*keyBlob, key_blob->key_blob, key_blob->key_blob_length); - - return 0; -} - -int intel_keymaster_import_rsa_keypair(const RSA *rsa, - uint8_t** keyBlob, size_t* keyBlobLength) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_import_key_t *import_params; - intel_keymaster_rsa_key_t *rsa_key; - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - intel_keymaster_key_blob_t *key_blob; - uint32_t rsp_result_and_data_length; - uint32_t modulus_length, public_exponent_length, private_exponent_length; - - if ((rsa == NULL) || (rsa->n == NULL) || (rsa->e == NULL) || (rsa->d == NULL) || - (keyBlob == NULL) || (keyBlobLength == NULL)) { - return -1; - } - - if (cmd_buf.get() == NULL) { - return -1; - } - - if (rsp_buf.get() == NULL) { - return -1; - } - - modulus_length = BN_num_bytes(rsa->n); - public_exponent_length = BN_num_bytes(rsa->e); - private_exponent_length = BN_num_bytes(rsa->d); - - cmd_buf->cmd_id = KEYMASTER_CMD_IMPORT_KEYPAIR; - cmd_buf->cmd_data_length = modulus_length + public_exponent_length + private_exponent_length + - offsetof(intel_keymaster_rsa_key_t, bytes) + - offsetof(intel_keymaster_import_key_t, key_data); - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - if (cmd_len > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) { - ALOGE("combination of modulus, public exponent and private exponent length is too big," - " modulus_length = %u, public_exponent_length = %u, private_exponent_length = %u", - modulus_length, public_exponent_length, private_exponent_length); - return -1; - } - - import_params = (intel_keymaster_import_key_t *)cmd_buf->cmd_data; - import_params->key_type = KEY_TYPE_RSA; - rsa_key = (intel_keymaster_rsa_key_t *)import_params->key_data; - rsa_key->modulus_length = modulus_length; - rsa_key->public_exponent_length = public_exponent_length; - rsa_key->private_exponent_length = private_exponent_length; - BN_bn2bin(rsa->n, rsa_key->bytes); - BN_bn2bin(rsa->e, rsa_key->bytes + modulus_length); - BN_bn2bin(rsa->d, rsa_key->bytes + modulus_length + public_exponent_length); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return -1; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return -1; - } - - // rsp_result_and_data_length should include at least the result field - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length too small, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return -1; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return -1; - } - - key_blob = (intel_keymaster_key_blob_t *)rsp_buf->rsp_data; - - if (key_blob->key_blob_length == 0) { - ALOGE("key_blob_length is 0"); - return -1; - } - - if (key_blob->key_blob_length > MAX_KEY_BLOB_SIZE) { - ALOGE("key_blob_length is too large"); - return -1; - } - - rsp_result_and_data_length = key_blob->key_blob_length + - offsetof(intel_keymaster_key_blob_t, key_blob) + sizeof(intel_keymaster_result_t); - if (rsp_result_and_data_length != rsp_buf->rsp_result_and_data_length) { - ALOGE("calculated rsp_result_and_data_length %u does not match rsp_result_and_data_length " - "%u in structure", - rsp_result_and_data_length, rsp_buf->rsp_result_and_data_length); - return -1; - } - - if (rsp_buf->rsp_result_and_data_length + offsetof(intel_keymaster_firmware_rsp_t, result) != - rsp_len) { - ALOGE("rsp_result_and_data_length %u is inconsistent with rsp_len %u", - rsp_buf->rsp_result_and_data_length, rsp_len); - return -1; - } - - *keyBlobLength = key_blob->key_blob_length; - /* freeing memory allocated here is the responsibility of the caller several layers above */ - *keyBlob = (uint8_t *)malloc(key_blob->key_blob_length); - if (*keyBlob == NULL) { - ALOGE("memory allocation for keyBlob failed"); - return -1; - } - - memcpy(*keyBlob, key_blob->key_blob, key_blob->key_blob_length); - - return 0; -} - -EVP_PKEY* intel_keymaster_unwrap_key(const uint8_t* keyBlob, const size_t keyBlobLength) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_key_blob_t *key_blob; - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - intel_keymaster_public_key_t *public_key; - intel_keymaster_rsa_public_key_t *rsa_public_key; - uint32_t rsp_result_and_data_length; - - if ((keyBlob == NULL) || (keyBlobLength == 0) || (keyBlobLength > MAX_KEY_BLOB_SIZE)) { - return NULL; - } - - if (cmd_buf.get() == NULL) { - return NULL; - } - - if (rsp_buf.get() == NULL) { - return NULL; - } - - cmd_buf->cmd_id = KEYMASTER_CMD_GET_KEYPAIR_PUBLIC; - cmd_buf->cmd_data_length = keyBlobLength + offsetof(intel_keymaster_key_blob_t, key_blob); - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - if (cmd_len > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) { - ALOGE("keyBlob is too big, keyBlobLength = %u", keyBlobLength); - return NULL; - } - - key_blob = (intel_keymaster_key_blob_t *)cmd_buf->cmd_data; - key_blob->key_blob_length = keyBlobLength; - memcpy(key_blob->key_blob, keyBlob, keyBlobLength); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return NULL; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return NULL; - } - - // rsp_result_and_data_length should include at least the result field - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length too small, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return NULL; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return NULL; - } - - public_key = (intel_keymaster_public_key_t *)rsp_buf->rsp_data; - - if (public_key->key_type != KEY_TYPE_RSA) { - ALOGE("key type other than RSA is not yet supported"); - return NULL; - } - - rsa_public_key = (intel_keymaster_rsa_public_key_t *)public_key->public_key_data; - - if (rsa_public_key->modulus_length > MAX_MODULUS_LENGTH) { - ALOGE("Modulus Length is too large"); - return NULL; - } - - if (rsa_public_key->public_exponent_length > MAX_EXPONENT_LENGTH) { - ALOGE("Exponent Length is too large"); - return NULL; - } - - rsp_result_and_data_length = rsa_public_key->modulus_length + - rsa_public_key->public_exponent_length + - offsetof(intel_keymaster_rsa_public_key_t, bytes) + - offsetof(intel_keymaster_public_key_t, public_key_data) + - sizeof(intel_keymaster_result_t); - if (rsp_result_and_data_length != rsp_buf->rsp_result_and_data_length) { - ALOGE("calculated rsp_result_and_data_length %u does not match rsp_result_and_data_length " - "%u in structure", - rsp_result_and_data_length, rsp_buf->rsp_result_and_data_length); - return NULL; - } - - if (rsp_buf->rsp_result_and_data_length + offsetof(intel_keymaster_firmware_rsp_t, result) != - rsp_len) { - ALOGE("rsp_result_and_data_length %u is inconsistent with rsp_len %u", - rsp_buf->rsp_result_and_data_length, rsp_len); - return NULL; - } - - // convert to DER encoded format - Unique_RSA rsa(RSA_new()); - if (rsa.get() == NULL) { - ALOGE("Memory allocation for rsa failed"); - return NULL; - } - - rsa->n = BN_bin2bn(rsa_public_key->bytes, rsa_public_key->modulus_length, NULL); - if (rsa->n == NULL) { - ALOGE("Couldn't create modulus from public key byte array"); - return NULL; - } - - rsa->e = BN_bin2bn(rsa_public_key->bytes + rsa_public_key->modulus_length, - rsa_public_key->public_exponent_length, NULL); - if (rsa->e == NULL) { - ALOGE("Couldn't create public exponent from public key byte array"); - return NULL; - } - - Unique_EVP_PKEY pkey(EVP_PKEY_new()); - if (pkey.get() == NULL) { - ALOGE("Memory allocation for pkey failed"); - return NULL; - } - - if (!EVP_PKEY_assign_RSA(pkey.get(), rsa.get())) { - ALOGE("Couldn't assign rsa to pkey\n"); - return NULL; - } - - OWNERSHIP_TRANSFERRED(rsa); - - return pkey.release(); -} - -/* - * @brief Returns the size of a key blob RSA public key modulus. - * - * @param[in] pKeyBlob Key blob that contains the RSA public key. - * - * @param[in] keyBlobLengthInBytes Length of the key blob in bytes. - * - * @return The size of the RSA public key modulus in bytes. - * - * @retval NULL_RSA_MODULUS_SIZE_IN_BYTES Failed to get the size of the RSA public key modulus. - */ -static uint32_t get_rsa_public_key_modulus_size_in_bytes(const uint8_t * const pKeyBlob, const size_t keyBlobLengthInBytes) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_key_blob_t *p_key_blob = NULL; - uint32_t cmd_len = 0; - uint32_t rsp_len = 0; - sep_keymaster_return_t sep_ret = SEP_KEYMASTER_FAILURE; - intel_keymaster_public_key_t *p_public_key = NULL; - intel_keymaster_rsa_public_key_t *p_rsa_public_key = NULL; - uint32_t rsp_result_and_data_length = 0; - - - /* Check parameters for illegal values. */ - if (NULL == pKeyBlob) - { - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - if ((0 == keyBlobLengthInBytes) || (keyBlobLengthInBytes > MAX_KEY_BLOB_SIZE)) - { - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - // Check command buffer. - if (NULL == cmd_buf.get()) - { - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - if (NULL == rsp_buf.get()) - { - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - - // Create a firmware command to unwrap key blob. - cmd_buf->cmd_id = KEYMASTER_CMD_GET_KEYPAIR_PUBLIC; - - cmd_buf->cmd_data_length = keyBlobLengthInBytes + offsetof(intel_keymaster_key_blob_t, key_blob); - - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - if (cmd_len > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) - { - ALOGE("%s:%d: Key blob size of %u bytes is too large.\n", __func__, __LINE__, keyBlobLengthInBytes); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - p_key_blob = (intel_keymaster_key_blob_t *)cmd_buf->cmd_data; - - p_key_blob->key_blob_length = keyBlobLengthInBytes; - - (void)memcpy(p_key_blob->key_blob, pKeyBlob, keyBlobLengthInBytes); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - - - // Unwrap the key blob in the firmware to get the RSA public key. - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), &rsp_len); - - if (SEP_KEYMASTER_SUCCESS != sep_ret) - { - // Sending the firmware command failed. - ALOGE("%s:%d: Failed to send command to firmware; sep_keymaster_send_cmd() " - "returned error 0x%X.\n", __func__, __LINE__, sep_ret); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) - { - // Incorrect size of response from the firmware. - ALOGE("%s:%d: Firmware response of %u bytes is too small.\n", __func__, - __LINE__, rsp_buf->rsp_result_and_data_length); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - if (KEYMASTER_RESULT_SUCCESS != rsp_buf->result) - { - // Firmware had an error. - ALOGE("%s: %d: Failed to unwrap RSA public key; firmware returned error 0x%X", - __func__, __LINE__, (unsigned int)rsp_buf->result); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - - // Get the RSA public key from the firmware response. - p_public_key = (intel_keymaster_public_key_t *)rsp_buf->rsp_data; - - if (KEY_TYPE_RSA != p_public_key->key_type) - { - ALOGE("%s:%d: Not a RSA public key.\n", __func__, __LINE__); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - p_rsa_public_key = (intel_keymaster_rsa_public_key_t *)p_public_key->public_key_data; - - if ((p_rsa_public_key->modulus_length > MAX_MODULUS_LENGTH) - || (p_rsa_public_key->public_exponent_length > MAX_EXPONENT_LENGTH)) - { - ALOGE("Modulus or Exponent are too large"); - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - // Verify that the correct amount of RSA public key data was returned from - // the firmware. - rsp_result_and_data_length = p_rsa_public_key->modulus_length + - p_rsa_public_key->public_exponent_length + - offsetof(intel_keymaster_rsa_public_key_t, bytes) + - offsetof(intel_keymaster_public_key_t, public_key_data) + - sizeof(intel_keymaster_result_t); - - if (rsp_result_and_data_length != rsp_buf->rsp_result_and_data_length) - { - ALOGE("%s:%d: Computed firmware response data size of %u bytes does not " - "equal returned firmware data size of %u bytes.\n", __func__, __LINE__, - rsp_result_and_data_length, rsp_buf->rsp_result_and_data_length); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - if ((rsp_buf->rsp_result_and_data_length + offsetof (intel_keymaster_firmware_rsp_t, result)) != rsp_len) - { - ALOGE("%s:%d: Firmware response and data length of %u bytes does not " - "equal firmware response length of %u bytes.\n", __func__, __LINE__, - rsp_buf->rsp_result_and_data_length, rsp_len); - - return NULL_RSA_MODULUS_SIZE_IN_BYTES; - } - - - // Return the RSA public key modulus length. - return p_rsa_public_key->modulus_length; -} - -static bool is_zero_buf(const uint8_t* const buf, const size_t buf_len) -{ - // Iterate through array - for (size_t i = 0; i < buf_len; i++) - { - // If value is anything else than 0 then array cannot be zero - if (buf[i] != 0) - { - return false; - } - } - return true; -} - -int intel_keymaster_sign_rsa(const uint8_t* keyBlob, const size_t keyBlobLength, - const uint8_t* data, const size_t dataLength, - uint8_t** signedData, size_t* signedDataLength) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_signing_cmd_data_t *signing_data; - intel_keymaster_signature_t *signature; - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - uint32_t rsp_result_and_data_length; - - if ((keyBlob == NULL) || (data == NULL) || (signedData == NULL) || (signedDataLength == NULL)) - { - return -1; - } - - if ((keyBlobLength == 0) || (dataLength == 0) - || (keyBlobLength > MAX_KEY_BLOB_SIZE) - || (dataLength > INTEL_KEYMASTER_MAX_MESSAGE_SIZE)) { - return -2; - } - - if (cmd_buf.get() == NULL || rsp_buf.get() == NULL) { - return -3; - } - - // Check if incoming data buffer (message to sign) is all zeroes. - if (is_zero_buf(data, dataLength) == true) - { - *signedDataLength = get_rsa_public_key_modulus_size_in_bytes(keyBlob, keyBlobLength); - if (NULL_RSA_MODULUS_SIZE_IN_BYTES == *signedDataLength) - { - ALOGE("%s:%d: Failed to get the RSA public key modulus size.\n", __func__, __LINE__); - return -4; - } - - *signedData = (uint8_t *)calloc(*signedDataLength, sizeof(uint8_t)); - if (NULL == *signedData) - { - // Could not allocate memory for the RSA signature. - ALOGE("%s:%d: Failed to allocate memory for RSA signature.\n", __func__, __LINE__); - return -5; - } - - // When everything is done, exit - return 0; - } - - cmd_buf->cmd_id = KEYMASTER_CMD_SIGN_DATA; - cmd_buf->cmd_data_length = keyBlobLength + dataLength + - offsetof(intel_keymaster_signing_cmd_data_t, buffer); - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - if (cmd_len > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) { - ALOGE("combination of keyblob and data length is too big, keyBlobLength = %u, " - "dataLength = %u", - keyBlobLength, dataLength); - return -1; - } - - signing_data = (intel_keymaster_signing_cmd_data_t *)cmd_buf->cmd_data; - signing_data->key_blob_length = keyBlobLength; - signing_data->data_length = dataLength; - memcpy(signing_data->buffer, keyBlob, keyBlobLength); - memcpy(signing_data->buffer + keyBlobLength, data, dataLength); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return -1; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return -1; - } - - // rsp_result_and_data_length should include at least the result field - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length too small, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return -1; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return -1; - } - - signature = (intel_keymaster_signature_t *)rsp_buf->rsp_data; - - if (signature->signature_length == 0) { - ALOGE("signature_length is 0"); - return -1; - } - - if (signature->signature_length > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) { - ALOGE("signature length is too large"); - return -1; - } - - rsp_result_and_data_length = signature->signature_length + - offsetof(intel_keymaster_signature_t, signature) + sizeof(intel_keymaster_result_t); - if (rsp_result_and_data_length != rsp_buf->rsp_result_and_data_length) { - ALOGE("calculated rsp_result_and_data_length %u does not match rsp_result_and_data_length " - "%u in structure", - rsp_result_and_data_length, rsp_buf->rsp_result_and_data_length); - return -1; - } - - if (rsp_buf->rsp_result_and_data_length + offsetof(intel_keymaster_firmware_rsp_t, result) != - rsp_len) { - ALOGE("rsp_result_and_data_length %u is inconsistent with rsp_len %u", - rsp_buf->rsp_result_and_data_length, rsp_len); - return -1; - } - - *signedDataLength = signature->signature_length; - /* freeing memory allocated here is the responsibility of the caller several layers above */ - *signedData = (uint8_t *)malloc(signature->signature_length); - if (*signedData == NULL) { - ALOGE("memory allocation for signedData failed"); - return -1; - } - - memcpy(*signedData, signature->signature, signature->signature_length); - - return 0; -} - -int intel_keymaster_verify_rsa(const uint8_t* keyBlob, const size_t keyBlobLength, - const uint8_t* signedData, const size_t signedDataLength, - const uint8_t* signature, const size_t signatureLength) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_verification_data_t *verification_data; - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - - if ((keyBlob == NULL) || (signedData == NULL) || (signature == NULL)) { - return -1; - } - - if ((keyBlobLength == 0) || (signedDataLength == 0) || (signatureLength == 0)) { - return -1; - } - - if ((keyBlobLength > MAX_KEY_BLOB_SIZE) || (signedDataLength > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) - || (signatureLength > INTEL_KEYMASTER_MAX_MESSAGE_SIZE)) { - return -1; - } - - if (cmd_buf.get() == NULL) { - return -1; - } - - if (rsp_buf.get() == NULL) { - return -1; - } - - cmd_buf->cmd_id = KEYMASTER_CMD_VERIFY_DATA; - cmd_buf->cmd_data_length = keyBlobLength + signedDataLength + signatureLength + - offsetof(intel_keymaster_verification_data_t, buffer); - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - if (cmd_len > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) { - ALOGE("combination of keyBlobLength, signedDataLength and signatureLength is too big, " - "keyBlobLength = %u, signedDataLength = %u, signatureLength = %u", - keyBlobLength, signedDataLength, signatureLength); - return -1; - } - - verification_data = (intel_keymaster_verification_data_t *)cmd_buf->cmd_data; - verification_data->key_blob_length = keyBlobLength; - verification_data->data_length = signedDataLength; - verification_data->signature_length = signatureLength; - memcpy(verification_data->buffer, keyBlob, keyBlobLength); - memcpy(verification_data->buffer + keyBlobLength, signedData, signedDataLength); - memcpy(verification_data->buffer + keyBlobLength + signedDataLength, signature, - signatureLength); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return -1; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return -1; - } - - // rsp_result_and_data_length should include the result field only - if (rsp_buf->rsp_result_and_data_length != sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length unexpected, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return -1; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return -1; - } - - return 0; -} - -int intel_keymaster_delete_keypair(const struct keymaster0_device*, - const uint8_t* keyBlob, const size_t keyBlobLength) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - intel_keymaster_key_blob_t *key_blob; - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - - if ((keyBlob == NULL) || (keyBlobLength == 0) || (keyBlobLength > MAX_KEY_BLOB_SIZE)) { - return -1; - } - - if (cmd_buf.get() == NULL) { - return -1; - } - - if (rsp_buf.get() == NULL) { - return -1; - } - - cmd_buf->cmd_id = KEYMASTER_CMD_DELETE_KEYPAIR; - cmd_buf->cmd_data_length = keyBlobLength + offsetof(intel_keymaster_key_blob_t, key_blob); - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - if (cmd_len > INTEL_KEYMASTER_MAX_MESSAGE_SIZE) { - ALOGE("keyBlob is too big, keyBlobLength = %u", keyBlobLength); - return -1; - } - - key_blob = (intel_keymaster_key_blob_t *)cmd_buf->cmd_data; - key_blob->key_blob_length = keyBlobLength; - memcpy(key_blob->key_blob, keyBlob, keyBlobLength); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return -1; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return -1; - } - - // rsp_result_and_data_length should include at least the result field - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length too small, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return -1; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return -1; - } - - return 0; -} - -int intel_keymaster_delete_all(const struct keymaster0_device*) -{ - UniquePtr<intel_keymaster_firmware_cmd_t, Malloc_Free> cmd_buf( - static_cast<intel_keymaster_firmware_cmd_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - UniquePtr<intel_keymaster_firmware_rsp_t, Malloc_Free> rsp_buf( - static_cast<intel_keymaster_firmware_rsp_t *>(malloc(INTEL_KEYMASTER_MAX_MESSAGE_SIZE))); - uint32_t cmd_len, rsp_len; - sep_keymaster_return_t sep_ret; - - if (cmd_buf.get() == NULL) { - return -1; - } - - if (rsp_buf.get() == NULL) { - return -1; - } - - cmd_buf->cmd_id = KEYMASTER_CMD_DELETE_ALL; - cmd_buf->cmd_data_length = 0; - cmd_len = cmd_buf->cmd_data_length + offsetof(intel_keymaster_firmware_cmd_t, cmd_data); - - rsp_len = INTEL_KEYMASTER_MAX_MESSAGE_SIZE; - sep_ret = sep_keymaster_send_cmd((uint8_t *)cmd_buf.get(), cmd_len, (uint8_t *)rsp_buf.get(), - &rsp_len); - - if (sep_ret != SEP_KEYMASTER_SUCCESS) { - ALOGE("sep_keymaster_send_cmd() returned error %d", sep_ret); - return -1; - } - - // response should contain at least rsp_id, rsp_result_and_data_length and result - if (rsp_len < offsetof(intel_keymaster_firmware_rsp_t, rsp_data)) { - ALOGE("response is too short, rsp_len = %u", rsp_len); - return -1; - } - - // rsp_result_and_data_length should include at least the result field - if (rsp_buf->rsp_result_and_data_length < sizeof(intel_keymaster_result_t)) { - ALOGE("rsp_result_and_data_length too small, rsp_result_and_data_length = %u", - rsp_buf->rsp_result_and_data_length); - return -1; - } - - // the result must indicate success - if (rsp_buf->result != KEYMASTER_RESULT_SUCCESS) { - ALOGE("firmware returned result is not successful, result = 0x%x", rsp_buf->result); - return -1; - } - - return 0; -} - -/* keymaster module */ - -typedef UniquePtr<keymaster0_device_t> Unique_keymaster_device_t; - -/* Close an opened intel keymaster instance */ -static int intel_keymaster_close(hw_device_t *dev) { - delete dev; - return 0; -} - -/* - * Generic device handling - */ -static int intel_keymaster_open(const hw_module_t* module, const char* name, - hw_device_t** device) { - if (strcmp(name, KEYSTORE_KEYMASTER) != 0) - return -EINVAL; - - Unique_keymaster_device_t dev(new keymaster0_device_t); - if (dev.get() == NULL) - return -ENOMEM; - - char platform[PATH_MAX] = {0}; - property_get("ro.board.platform", platform, NULL); - - dev->common.tag = HARDWARE_DEVICE_TAG; - dev->common.version = 1; - dev->common.module = (struct hw_module_t*) module; - dev->common.close = intel_keymaster_close; - - dev->flags = KEYMASTER_BLOBS_ARE_STANDALONE; - - dev->generate_keypair = intel_keymaster_generate_keypair; - dev->import_keypair = intel_keymaster_import_keypair; - dev->get_keypair_public = intel_keymaster_get_keypair_public; - if (strcmp(platform, "merrifield") == 0 || - strcmp(platform, "moorefield") == 0) { - dev->delete_keypair = intel_keymaster_delete_keypair; - dev->delete_all = intel_keymaster_delete_all; - } - else { - dev->delete_keypair = NULL; - dev->delete_all = NULL; - } - dev->sign_data = intel_keymaster_sign_data; - dev->verify_data = intel_keymaster_verify_data; - - ERR_load_crypto_strings(); - ERR_load_BIO_strings(); - - *device = reinterpret_cast<hw_device_t*>(dev.release()); - - return 0; -} - -static struct hw_module_methods_t keystore_module_methods = { - .open = intel_keymaster_open, -}; - -struct keystore_module HAL_MODULE_INFO_SYM -__attribute__ ((visibility ("default"))) = { - .common = { - .tag = HARDWARE_MODULE_TAG, - .module_api_version = KEYMASTER_MODULE_API_VERSION_0_3, - .hal_api_version = HARDWARE_HAL_API_VERSION, - .id = KEYSTORE_HARDWARE_MODULE_ID, - .name = "Keymaster Intel HAL", - .author = "The Android Open Source Project", - .methods = &keystore_module_methods, - .dso = 0, - .reserved = {}, - }, -}; diff --git a/peripheral/keystore/chaabi/src/intelkeymaster_firmware_api.h b/peripheral/keystore/chaabi/src/intelkeymaster_firmware_api.h deleted file mode 100644 index 1823a78..0000000 --- a/peripheral/keystore/chaabi/src/intelkeymaster_firmware_api.h +++ /dev/null @@ -1,146 +0,0 @@ -/********************************************************************** - * Copyright 2016 (c) Intel Corporation. All rights reserved. - - * 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 INTELKEYMASTER_FIRMWARE_API_H -#define INTELKEYMASTER_FIRMWARE_API_H - -#include <stdint.h> - -// for now, only KEY_TYPE_RSA is supported -typedef enum { - KEY_TYPE_RSA = 1, - KEY_TYPE_DSA, - KEY_TYPE_EC -} intel_keymaster_key_type_t; - -typedef struct { - uint32_t modulus_size; // in bits, example 2048 - uint32_t reserved; - // the public exponent is passed in little endian format from the keymaster HAL - // and needs to be converted to big endian for RSA mathematics in firmware - // the leading zeros can be discarded - uint64_t public_exponent; // 0x10001 -} intel_keymaster_rsa_keygen_params_t; - -typedef enum { - KEYMASTER_CMD_GENERATE_KEYPAIR = 1, - KEYMASTER_CMD_IMPORT_KEYPAIR, - KEYMASTER_CMD_GET_KEYPAIR_PUBLIC, - KEYMASTER_CMD_DELETE_KEYPAIR, - KEYMASTER_CMD_DELETE_ALL, - KEYMASTER_CMD_SIGN_DATA, - KEYMASTER_CMD_VERIFY_DATA, - KEYMASTER_RSP_FLAG = 0x80000000 // responses are flagged with cmd_id with msb changed to 1 -} intel_keymaster_cmd_t; - -// this is the input for KEYMASTER_CMD_GENERATE_KEYPAIR -typedef struct { - intel_keymaster_key_type_t key_type; - uint8_t key_params[]; // cast to intel_keymaster_rsa_keygen_params_t if key_type == KEY_TYPE_RSA -} intel_keymaster_keygen_params_t; - -// this is the output of KEYMASTER_CMD_GENERATE_KEYPAIR and KEYMASTER_CMD_IMPORT_KEYPAIR -// and input for KEYMASTER_CMD_GET_KEYPAIR_PUBLIC and KEYMASTER_CMD_DELETE_KEYPAIR -typedef struct { - uint32_t key_blob_length; - uint8_t key_blob[]; // opaque structure intepreted by firmware only, private key is wrapped with device specific key -} intel_keymaster_key_blob_t; - -// the big numbers in the bytes[] array in the following structure are in big endian format -// private key is unencrypted -typedef struct { - uint32_t modulus_length; // in bytes - uint32_t public_exponent_length; // in bytes - uint32_t private_exponent_length;// in bytes - uint8_t bytes[]; // concatenation of modulus, public exponent and private exponent -} intel_keymaster_rsa_key_t; - -// this is the input for KEYMASTER_CMD_IMPORT_KEYPAIR -typedef struct { - intel_keymaster_key_type_t key_type; - uint8_t key_data[]; // cast to intel_keymaster_rsa_key_t if key_type == KEY_TYPE_RSA -} intel_keymaster_import_key_t; - -// the big numbers in the bytes[] array in the following structure are in big endian format -typedef struct { - uint32_t modulus_length; // in bytes - uint32_t public_exponent_length; // in bytes - uint8_t bytes[]; // concatenation of modulus and public exponent -} intel_keymaster_rsa_public_key_t; - -// this is the output of KEYMASTER_CMD_GET_KEYPAIR_PUBLIC -typedef struct { - intel_keymaster_key_type_t key_type; - uint8_t public_key_data[]; // cast to intel_keymaster_rsa_public_key_t if key_type == KEY_TYPE_RSA -} intel_keymaster_public_key_t; - -// this is the input for KEYMASTER_CMD_SIGN_DATA -typedef struct { - uint32_t key_blob_length; - uint32_t data_length; // because of no hashing and no padding, data size must be equal to modulus size - uint8_t buffer[]; // concatenation of key blob and data block to be signed -} intel_keymaster_signing_cmd_data_t; - -// this is the output of KEYMASTER_CMD_SIGN_DATA -typedef struct { - uint32_t signature_length; - uint8_t signature[]; -} intel_keymaster_signature_t; - -// this is the input for KEYMASTER_CMD_VERIFY_DATA -typedef struct { - uint32_t key_blob_length; - uint32_t data_length; // because of no hashing and no padding, data size must be equal to modulus size - uint32_t signature_length; // because of no hashing and no padding, signature size must be equal to modulus size - uint8_t buffer[]; // concatenation of key blob, data block and signature block -} intel_keymaster_verification_data_t; - -typedef enum { - KEYMASTER_RESULT_SUCCESS = 0, - KEYMASTER_RESULT_INVALID_INPUT = 1, - KEYMASTER_RESULT_NOT_SUPPORTED = 2, - KEYMASTER_RESULT_AGAIN = 3, - KEYMASTER_RESULT_MEM_ALLOC = 4, - KEYMASTER_RESULT_DERIVE_KEY = 5, - KEYMASTER_RESULT_GEN_KEY = 6, - KEYMASTER_RESULT_DATA_SIGN = 7, - KEYMASTER_RESULT_DATA_VERIFY = 8, - KEYMASTER_RESULT_CRYS_FAIL = 9, - KEYMASTER_RESULT_INTERNAL_ERR = 10, - KEYMASTER_RESULT_FAILURE = 0xFFFFFFFF -} intel_keymaster_result_t; - -// this is the command structure, it follows any platform specific message header(s) if exist -typedef struct { - intel_keymaster_cmd_t cmd_id; - uint32_t cmd_data_length; // this does not include the size of cmd_id and cmd_data_length itself - uint8_t cmd_data[]; -} intel_keymaster_firmware_cmd_t; - -// this is the command response, it follows any platform specific message header(s) if exist -typedef struct { - intel_keymaster_cmd_t rsp_id; // cmd_id | KEYMASTER_RSP_FLAG - uint32_t rsp_result_and_data_length; // this does not include the size of rsp_id and rsp_result_and_data_length itself, but it does include the size of result field - intel_keymaster_result_t result; - uint8_t rsp_data[]; -} intel_keymaster_firmware_rsp_t; - -#define INTEL_KEYMASTER_MAX_MESSAGE_SIZE 4000 // less platform specific headers -#define MAX_KEY_BLOB_SIZE 4096 -#define MAX_MODULUS_LENGTH 384 -#define MAX_EXPONENT_LENGTH 4 - -#endif /* INTELKEYMASTER_FIRMWARE_API_H */ diff --git a/peripheral/keystore/chaabi/src/intelkeymaster_middleware_api.h b/peripheral/keystore/chaabi/src/intelkeymaster_middleware_api.h deleted file mode 100644 index a351c80..0000000 --- a/peripheral/keystore/chaabi/src/intelkeymaster_middleware_api.h +++ /dev/null @@ -1,52 +0,0 @@ -/********************************************************************** - * Copyright 2016 (c) Intel Corporation. All rights reserved. - - * 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 __LIBKEYMASTER_API_H__ -#define __LIBKEYMASTER_API_H__ - -typedef enum { - SEP_KEYMASTER_SUCCESS = 0, - SEP_KEYMASTER_BAD_PARAMETER, - SEP_KEYMASTER_CMD_BUFFER_TOO_BIG, - SEP_KEYMASTER_RSP_BUFFER_TOO_SMALL, - SEP_KEYMASTER_CC_INIT_FAILURE, - SEP_KEYMASTER_FAILURE -} sep_keymaster_return_t; - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * Send a keymaster command to sep, and waits for a response - * @param cmd_buffer : Pointer to command buffer - * @param buffer_length : Number of command bytes - * @param rsp_buffer : Pointer to response buffer - * @param rsp_length : Upon input, size of response buffer - * Upon return, actual size of response - * @return SEP_KEYMASTER_CMD_SUCCESS if command was sent and - * response received; non zero value if there was a failure - */ -sep_keymaster_return_t sep_keymaster_send_cmd(const uint8_t * const cmd_buffer, - uint32_t cmd_length, - uint8_t * const rsp_buffer, - uint32_t * const rsp_length); - -#ifdef __cplusplus -} -#endif - -#endif /* __LIBKEYMASTER_API_H__ */ diff --git a/peripheral/keystore/chaabi/src/peripheral.mk b/peripheral/keystore/chaabi/src/peripheral.mk deleted file mode 100644 index d7ab7cb..0000000 --- a/peripheral/keystore/chaabi/src/peripheral.mk +++ /dev/null @@ -1,17 +0,0 @@ -# Copyright 2016 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. -# - -DEVICE_PACKAGES += \ - keystore.$(TARGET_DEVICE) |