trusty/keymaster/trusty_keymaster_device.cpp - android-core - Git at Google

 /*
  * Copyright 2014 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.
  */

 #define LOG_TAG "TrustyKeymaster"

 #include <assert.h>
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>

 #include <type_traits>

 #include <hardware/keymaster0.h>
 #include <keymaster/authorization_set.h>
 #include <log/log.h>

 #include "trusty_keymaster_device.h"
 #include "trusty_keymaster_ipc.h"
 #include "keymaster_ipc.h"

 const uint32_t SEND_BUF_SIZE = 8192;
 const uint32_t RECV_BUF_SIZE = 8192;

 namespace keymaster {

 static keymaster_error_t translate_error(int err) {
     switch (err) {
     case 0:
         return KM_ERROR_OK;
     case -EPERM:
     case -EACCES:
         return KM_ERROR_SECURE_HW_ACCESS_DENIED;

     case -ECANCELED:
         return KM_ERROR_OPERATION_CANCELLED;

     case -ENODEV:
         return KM_ERROR_UNIMPLEMENTED;

     case -ENOMEM:
         return KM_ERROR_MEMORY_ALLOCATION_FAILED;

     case -EBUSY:
         return KM_ERROR_SECURE_HW_BUSY;

     case -EIO:
         return KM_ERROR_SECURE_HW_COMMUNICATION_FAILED;

     case -EOVERFLOW:
         return KM_ERROR_INVALID_INPUT_LENGTH;

     default:
         return KM_ERROR_UNKNOWN_ERROR;
     }
 }

 TrustyKeymasterDevice::TrustyKeymasterDevice(const hw_module_t* module) {
     static_assert(std::is_standard_layout<TrustyKeymasterDevice>::value,
                   "TrustyKeymasterDevice must be standard layout");
     static_assert(offsetof(TrustyKeymasterDevice, device_) == 0,
                   "device_ must be the first member of KeymasterOpenSsl");
     static_assert(offsetof(TrustyKeymasterDevice, device_.common) == 0,
                   "common must be the first member of keymaster_device");

     ALOGI("Creating device");
     ALOGD("Device address: %p", this);

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

     device_.common.tag = HARDWARE_DEVICE_TAG;
     device_.common.version = 1;
     device_.common.module = const_cast<hw_module_t*>(module);
     device_.common.close = close_device;

     device_.flags = KEYMASTER_BLOBS_ARE_STANDALONE | KEYMASTER_SUPPORTS_EC;

     device_.generate_keypair = generate_keypair;
     device_.import_keypair = import_keypair;
     device_.get_keypair_public = get_keypair_public;
     device_.delete_keypair = NULL;
     device_.delete_all = NULL;
     device_.sign_data = sign_data;
     device_.verify_data = verify_data;

     device_.context = NULL;

     int rc = trusty_keymaster_connect();
     error_ = translate_error(rc);
     if (rc < 0) {
         ALOGE("failed to connect to keymaster (%d)", rc);
         return;
     }

     GetVersionRequest version_request;
     GetVersionResponse version_response;
     error_ = Send(version_request, &version_response);
     if (error_ == KM_ERROR_INVALID_ARGUMENT || error_ == KM_ERROR_UNIMPLEMENTED) {
         ALOGI("\"Bad parameters\" error on GetVersion call.  Assuming version 0.");
         message_version_ = 0;
         error_ = KM_ERROR_OK;
     }
     message_version_ = MessageVersion(version_response.major_ver, version_response.minor_ver,
                                       version_response.subminor_ver);
     if (message_version_ < 0) {
         // Can't translate version?  Keymaster implementation must be newer.
         ALOGE("Keymaster version %d.%d.%d not supported.", version_response.major_ver,
               version_response.minor_ver, version_response.subminor_ver);
         error_ = KM_ERROR_VERSION_MISMATCH;
     }
 }

 TrustyKeymasterDevice::~TrustyKeymasterDevice() {
     trusty_keymaster_disconnect();
 }

 const uint64_t HUNDRED_YEARS = 1000LL * 60 * 60 * 24 * 365 * 100;

 int TrustyKeymasterDevice::generate_keypair(const keymaster_keypair_t key_type,
                                             const void* key_params, uint8_t** key_blob,
                                             size_t* key_blob_length) {
     ALOGD("Device received generate_keypair");

     if (error_ != KM_ERROR_OK)
         return error_;

     GenerateKeyRequest req(message_version_);
     StoreNewKeyParams(&req.key_description);

     switch (key_type) {
     case TYPE_RSA: {
         req.key_description.push_back(TAG_ALGORITHM, KM_ALGORITHM_RSA);
         const keymaster_rsa_keygen_params_t* rsa_params =
             static_cast<const keymaster_rsa_keygen_params_t*>(key_params);
         ALOGD("Generating RSA pair, modulus size: %u, public exponent: %lu",
               rsa_params->modulus_size, rsa_params->public_exponent);
         req.key_description.push_back(TAG_KEY_SIZE, rsa_params->modulus_size);
         req.key_description.push_back(TAG_RSA_PUBLIC_EXPONENT, rsa_params->public_exponent);
         break;
     }

     case TYPE_EC: {
         req.key_description.push_back(TAG_ALGORITHM, KM_ALGORITHM_EC);
         const keymaster_ec_keygen_params_t* ec_params =
             static_cast<const keymaster_ec_keygen_params_t*>(key_params);
         ALOGD("Generating ECDSA pair, key size: %u", ec_params->field_size);
         req.key_description.push_back(TAG_KEY_SIZE, ec_params->field_size);
         break;
     }
     default:
         ALOGD("Received request for unsuported key type %d", key_type);
         return KM_ERROR_UNSUPPORTED_ALGORITHM;
     }

     GenerateKeyResponse rsp(message_version_);
     ALOGD("Sending generate request");
     keymaster_error_t err = Send(req, &rsp);
     if (err != KM_ERROR_OK) {
         ALOGE("Got error %d from send", err);
         return err;
     }

     *key_blob_length = rsp.key_blob.key_material_size;
     *key_blob = static_cast<uint8_t*>(malloc(*key_blob_length));
     memcpy(*key_blob, rsp.key_blob.key_material, *key_blob_length);
     ALOGD("Returning %d bytes in key blob\n", (int)*key_blob_length);

     return KM_ERROR_OK;
 }

 struct EVP_PKEY_Delete {
     void operator()(EVP_PKEY* p) const { EVP_PKEY_free(p); }
 };

 struct PKCS8_PRIV_KEY_INFO_Delete {
     void operator()(PKCS8_PRIV_KEY_INFO* p) const { PKCS8_PRIV_KEY_INFO_free(p); }
 };

 int TrustyKeymasterDevice::import_keypair(const uint8_t* key, const size_t key_length,
                                           uint8_t** key_blob, size_t* key_blob_length) {
     ALOGD("Device received import_keypair");
     if (error_ != KM_ERROR_OK)
         return error_;

     if (!key)
         return KM_ERROR_UNEXPECTED_NULL_POINTER;

     if (!key_blob || !key_blob_length)
         return KM_ERROR_OUTPUT_PARAMETER_NULL;

     ImportKeyRequest request(message_version_);
     StoreNewKeyParams(&request.key_description);
     keymaster_algorithm_t algorithm;
     keymaster_error_t err = GetPkcs8KeyAlgorithm(key, key_length, &algorithm);
     if (err != KM_ERROR_OK)
         return err;
     request.key_description.push_back(TAG_ALGORITHM, algorithm);

     request.SetKeyMaterial(key, key_length);
     request.key_format = KM_KEY_FORMAT_PKCS8;
     ImportKeyResponse response(message_version_);
     err = Send(request, &response);
     if (err != KM_ERROR_OK)
         return err;

     *key_blob_length = response.key_blob.key_material_size;
     *key_blob = static_cast<uint8_t*>(malloc(*key_blob_length));
     memcpy(*key_blob, response.key_blob.key_material, *key_blob_length);
     printf("Returning %d bytes in key blob\n", (int)*key_blob_length);

     return KM_ERROR_OK;
 }

 keymaster_error_t TrustyKeymasterDevice::GetPkcs8KeyAlgorithm(const uint8_t* key, size_t key_length,
                                                               keymaster_algorithm_t* algorithm) {
     if (key == NULL) {
         ALOGE("No key specified for import");
         return KM_ERROR_UNEXPECTED_NULL_POINTER;
     }

     UniquePtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_Delete> pkcs8(
         d2i_PKCS8_PRIV_KEY_INFO(NULL, &key, key_length));
     if (pkcs8.get() == NULL) {
         ALOGE("Could not parse PKCS8 key blob");
         return KM_ERROR_INVALID_KEY_BLOB;
     }

     UniquePtr<EVP_PKEY, EVP_PKEY_Delete> pkey(EVP_PKCS82PKEY(pkcs8.get()));
     if (pkey.get() == NULL) {
         ALOGE("Could not extract key from PKCS8 key blob");
         return KM_ERROR_INVALID_KEY_BLOB;
     }

     switch (EVP_PKEY_type(pkey->type)) {
     case EVP_PKEY_RSA:
         *algorithm = KM_ALGORITHM_RSA;
         break;
     case EVP_PKEY_EC:
         *algorithm = KM_ALGORITHM_EC;
         break;
     default:
         ALOGE("Unsupported algorithm %d", EVP_PKEY_type(pkey->type));
         return KM_ERROR_UNSUPPORTED_ALGORITHM;
     }

     return KM_ERROR_OK;
 }

 int TrustyKeymasterDevice::get_keypair_public(const uint8_t* key_blob, const size_t key_blob_length,
                                               uint8_t** x509_data, size_t* x509_data_length) {
     ALOGD("Device received get_keypair_public");
     if (error_ != KM_ERROR_OK)
         return error_;

     ExportKeyRequest request(message_version_);
     request.SetKeyMaterial(key_blob, key_blob_length);
     request.key_format = KM_KEY_FORMAT_X509;
     ExportKeyResponse response(message_version_);
     keymaster_error_t err = Send(request, &response);
     if (err != KM_ERROR_OK)
         return err;

     *x509_data_length = response.key_data_length;
     *x509_data = static_cast<uint8_t*>(malloc(*x509_data_length));
     memcpy(*x509_data, response.key_data, *x509_data_length);
     printf("Returning %d bytes in x509 key\n", (int)*x509_data_length);

     return KM_ERROR_OK;
 }

 int TrustyKeymasterDevice::sign_data(const void* signing_params, const uint8_t* key_blob,
                                      const size_t key_blob_length, const uint8_t* data,
                                      const size_t data_length, uint8_t** signed_data,
                                      size_t* signed_data_length) {
     ALOGD("Device received sign_data, %d", error_);
     if (error_ != KM_ERROR_OK)
         return error_;

     BeginOperationRequest begin_request(message_version_);
     begin_request.purpose = KM_PURPOSE_SIGN;
     begin_request.SetKeyMaterial(key_blob, key_blob_length);
     keymaster_error_t err = StoreSigningParams(signing_params, key_blob, key_blob_length,
                                                &begin_request.additional_params);
     if (err != KM_ERROR_OK) {
         ALOGE("Error extracting signing params: %d", err);
         return err;
     }

     BeginOperationResponse begin_response(message_version_);
     ALOGD("Sending signing request begin");
     err = Send(begin_request, &begin_response);
     if (err != KM_ERROR_OK) {
         ALOGE("Error sending sign begin: %d", err);
         return err;
     }

     UpdateOperationRequest update_request(message_version_);
     update_request.op_handle = begin_response.op_handle;
     update_request.input.Reinitialize(data, data_length);
     UpdateOperationResponse update_response(message_version_);
     ALOGD("Sending signing request update");
     err = Send(update_request, &update_response);
     if (err != KM_ERROR_OK) {
         ALOGE("Error sending sign update: %d", err);
         return err;
     }

     FinishOperationRequest finish_request(message_version_);
     finish_request.op_handle = begin_response.op_handle;
     FinishOperationResponse finish_response(message_version_);
     ALOGD("Sending signing request finish");
     err = Send(finish_request, &finish_response);
     if (err != KM_ERROR_OK) {
         ALOGE("Error sending sign finish: %d", err);
         return err;
     }

     *signed_data_length = finish_response.output.available_read();
     *signed_data = static_cast<uint8_t*>(malloc(*signed_data_length));
     if (!finish_response.output.read(*signed_data, *signed_data_length)) {
         ALOGE("Error reading response data: %d", err);
         return KM_ERROR_UNKNOWN_ERROR;
     }
     return KM_ERROR_OK;
 }

 int TrustyKeymasterDevice::verify_data(const void* signing_params, const uint8_t* key_blob,
                                        const size_t key_blob_length, const uint8_t* signed_data,
                                        const size_t signed_data_length, const uint8_t* signature,
                                        const size_t signature_length) {
     ALOGD("Device received verify_data");
     if (error_ != KM_ERROR_OK)
         return error_;

     BeginOperationRequest begin_request(message_version_);
     begin_request.purpose = KM_PURPOSE_VERIFY;
     begin_request.SetKeyMaterial(key_blob, key_blob_length);
     keymaster_error_t err = StoreSigningParams(signing_params, key_blob, key_blob_length,
                                                &begin_request.additional_params);
     if (err != KM_ERROR_OK)
         return err;

     BeginOperationResponse begin_response(message_version_);
     err = Send(begin_request, &begin_response);
     if (err != KM_ERROR_OK)
         return err;

     UpdateOperationRequest update_request(message_version_);
     update_request.op_handle = begin_response.op_handle;
     update_request.input.Reinitialize(signed_data, signed_data_length);
     UpdateOperationResponse update_response(message_version_);
     err = Send(update_request, &update_response);
     if (err != KM_ERROR_OK)
         return err;

     FinishOperationRequest finish_request(message_version_);
     finish_request.op_handle = begin_response.op_handle;
     finish_request.signature.Reinitialize(signature, signature_length);
     FinishOperationResponse finish_response(message_version_);
     err = Send(finish_request, &finish_response);
     if (err != KM_ERROR_OK)
         return err;
     return KM_ERROR_OK;
 }

 hw_device_t* TrustyKeymasterDevice::hw_device() {
     return &device_.common;
 }

 static inline TrustyKeymasterDevice* convert_device(const keymaster0_device_t* dev) {
     return reinterpret_cast<TrustyKeymasterDevice*>(const_cast<keymaster0_device_t*>(dev));
 }

 /* static */
 int TrustyKeymasterDevice::close_device(hw_device_t* dev) {
     delete reinterpret_cast<TrustyKeymasterDevice*>(dev);
     return 0;
 }

 /* static */
 int TrustyKeymasterDevice::generate_keypair(const keymaster0_device_t* dev,
                                             const keymaster_keypair_t key_type,
                                             const void* key_params, uint8_t** keyBlob,
                                             size_t* keyBlobLength) {
     ALOGD("Generate keypair, sending to device: %p", convert_device(dev));
     return convert_device(dev)->generate_keypair(key_type, key_params, keyBlob, keyBlobLength);
 }

 /* static */
 int TrustyKeymasterDevice::import_keypair(const keymaster0_device_t* dev, const uint8_t* key,
                                           const size_t key_length, uint8_t** key_blob,
                                           size_t* key_blob_length) {
     return convert_device(dev)->import_keypair(key, key_length, key_blob, key_blob_length);
 }

 /* static */
 int TrustyKeymasterDevice::get_keypair_public(const keymaster0_device_t* dev,
                                               const uint8_t* key_blob, const size_t key_blob_length,
                                               uint8_t** x509_data, size_t* x509_data_length) {
     return convert_device(dev)
         ->get_keypair_public(key_blob, key_blob_length, x509_data, x509_data_length);
 }

 /* static */
 int TrustyKeymasterDevice::sign_data(const keymaster0_device_t* dev, 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) {
     return convert_device(dev)
         ->sign_data(params, keyBlob, keyBlobLength, data, dataLength, signedData, signedDataLength);
 }

 /* static */
 int TrustyKeymasterDevice::verify_data(const keymaster0_device_t* dev, 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) {
     return convert_device(dev)->verify_data(params, keyBlob, keyBlobLength, signedData,
                                             signedDataLength, signature, signatureLength);
 }

 keymaster_error_t TrustyKeymasterDevice::Send(uint32_t command, const Serializable& req,
                                               KeymasterResponse* rsp) {
     uint32_t req_size = req.SerializedSize();
     if (req_size > SEND_BUF_SIZE)
         return KM_ERROR_MEMORY_ALLOCATION_FAILED;
     uint8_t send_buf[SEND_BUF_SIZE];
     Eraser send_buf_eraser(send_buf, SEND_BUF_SIZE);
     req.Serialize(send_buf, send_buf + req_size);

     // Send it
     uint8_t recv_buf[RECV_BUF_SIZE];
     Eraser recv_buf_eraser(recv_buf, RECV_BUF_SIZE);
     uint32_t rsp_size = RECV_BUF_SIZE;
     printf("Sending %d byte request\n", (int)req.SerializedSize());
     int rc = trusty_keymaster_call(command, send_buf, req_size, recv_buf, &rsp_size);
     if (rc < 0) {
         ALOGE("tipc error: %d\n", rc);
         // TODO(swillden): Distinguish permanent from transient errors and set error_ appropriately.
         return translate_error(rc);
     } else {
         ALOGV("Received %d byte response\n", rsp_size);
     }

     const keymaster_message* msg = (keymaster_message *) recv_buf;
     const uint8_t *p = msg->payload;
     if (!rsp->Deserialize(&p, p + rsp_size)) {
         ALOGE("Error deserializing response of size %d\n", (int)rsp_size);
         return KM_ERROR_UNKNOWN_ERROR;
     } else if (rsp->error != KM_ERROR_OK) {
         ALOGE("Response of size %d contained error code %d\n", (int)rsp_size, (int)rsp->error);
         return rsp->error;
     }
     return rsp->error;
 }

 keymaster_error_t TrustyKeymasterDevice::StoreSigningParams(const void* signing_params,
                                                             const uint8_t* key_blob,
                                                             size_t key_blob_length,
                                                             AuthorizationSet* auth_set) {
     uint8_t* pub_key_data;
     size_t pub_key_data_length;
     int err = get_keypair_public(&device_, key_blob, key_blob_length, &pub_key_data,
                                  &pub_key_data_length);
     if (err < 0) {
         ALOGE("Error %d extracting public key to determine algorithm", err);
         return KM_ERROR_INVALID_KEY_BLOB;
     }
     UniquePtr<uint8_t, Malloc_Delete> pub_key(pub_key_data);

     const uint8_t* p = pub_key_data;
     UniquePtr<EVP_PKEY, EVP_PKEY_Delete> pkey(
         d2i_PUBKEY(nullptr /* allocate new struct */, &p, pub_key_data_length));

     switch (EVP_PKEY_type(pkey->type)) {
     case EVP_PKEY_RSA: {
         const keymaster_rsa_sign_params_t* rsa_params =
             reinterpret_cast<const keymaster_rsa_sign_params_t*>(signing_params);
         if (rsa_params->digest_type != DIGEST_NONE)
             return KM_ERROR_UNSUPPORTED_DIGEST;
         if (rsa_params->padding_type != PADDING_NONE)
             return KM_ERROR_UNSUPPORTED_PADDING_MODE;
         if (!auth_set->push_back(TAG_DIGEST, KM_DIGEST_NONE) ||
             !auth_set->push_back(TAG_PADDING, KM_PAD_NONE))
             return KM_ERROR_MEMORY_ALLOCATION_FAILED;
     } break;
     case EVP_PKEY_EC: {
         const keymaster_ec_sign_params_t* ecdsa_params =
             reinterpret_cast<const keymaster_ec_sign_params_t*>(signing_params);
         if (ecdsa_params->digest_type != DIGEST_NONE)
             return KM_ERROR_UNSUPPORTED_DIGEST;
         if (!auth_set->push_back(TAG_DIGEST, KM_DIGEST_NONE))
             return KM_ERROR_MEMORY_ALLOCATION_FAILED;
     } break;
     default:
         return KM_ERROR_UNSUPPORTED_ALGORITHM;
     }
     return KM_ERROR_OK;
 }

 void TrustyKeymasterDevice::StoreNewKeyParams(AuthorizationSet* auth_set) {
     auth_set->push_back(TAG_PURPOSE, KM_PURPOSE_SIGN);
     auth_set->push_back(TAG_PURPOSE, KM_PURPOSE_VERIFY);
     auth_set->push_back(TAG_ALL_USERS);
     auth_set->push_back(TAG_NO_AUTH_REQUIRED);
     uint64_t now = java_time(time(NULL));
     auth_set->push_back(TAG_CREATION_DATETIME, now);
     auth_set->push_back(TAG_ORIGINATION_EXPIRE_DATETIME, now + HUNDRED_YEARS);
     if (message_version_ == 0) {
         auth_set->push_back(TAG_DIGEST_OLD, KM_DIGEST_NONE);
         auth_set->push_back(TAG_PADDING_OLD, KM_PAD_NONE);
     } else {
         auth_set->push_back(TAG_DIGEST, KM_DIGEST_NONE);
         auth_set->push_back(TAG_PADDING, KM_PAD_NONE);
     }
 }

 }  // namespace keymaster
	/*
	* Copyright 2014 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.
	*/

	#define LOG_TAG "TrustyKeymaster"

	#include <assert.h>
	#include <openssl/evp.h>
	#include <openssl/x509.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>

	#include <type_traits>

	#include <hardware/keymaster0.h>
	#include <keymaster/authorization_set.h>
	#include <log/log.h>

	#include "trusty_keymaster_device.h"
	#include "trusty_keymaster_ipc.h"
	#include "keymaster_ipc.h"

	const uint32_t SEND_BUF_SIZE = 8192;
	const uint32_t RECV_BUF_SIZE = 8192;

	namespace keymaster {

	static keymaster_error_t translate_error(int err) {
	switch (err) {
	case 0:
	return KM_ERROR_OK;
	case -EPERM:
	case -EACCES:
	return KM_ERROR_SECURE_HW_ACCESS_DENIED;

	case -ECANCELED:
	return KM_ERROR_OPERATION_CANCELLED;

	case -ENODEV:
	return KM_ERROR_UNIMPLEMENTED;

	case -ENOMEM:
	return KM_ERROR_MEMORY_ALLOCATION_FAILED;

	case -EBUSY:
	return KM_ERROR_SECURE_HW_BUSY;

	case -EIO:
	return KM_ERROR_SECURE_HW_COMMUNICATION_FAILED;

	case -EOVERFLOW:
	return KM_ERROR_INVALID_INPUT_LENGTH;

	default:
	return KM_ERROR_UNKNOWN_ERROR;
	}
	}

	TrustyKeymasterDevice::TrustyKeymasterDevice(const hw_module_t* module) {
	static_assert(std::is_standard_layout<TrustyKeymasterDevice>::value,
	"TrustyKeymasterDevice must be standard layout");
	static_assert(offsetof(TrustyKeymasterDevice, device_) == 0,
	"device_ must be the first member of KeymasterOpenSsl");
	static_assert(offsetof(TrustyKeymasterDevice, device_.common) == 0,
	"common must be the first member of keymaster_device");

	ALOGI("Creating device");
	ALOGD("Device address: %p", this);

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

	device_.common.tag = HARDWARE_DEVICE_TAG;
	device_.common.version = 1;
	device_.common.module = const_cast<hw_module_t*>(module);
	device_.common.close = close_device;

	device_.flags = KEYMASTER_BLOBS_ARE_STANDALONE \| KEYMASTER_SUPPORTS_EC;

	device_.generate_keypair = generate_keypair;
	device_.import_keypair = import_keypair;
	device_.get_keypair_public = get_keypair_public;
	device_.delete_keypair = NULL;
	device_.delete_all = NULL;
	device_.sign_data = sign_data;
	device_.verify_data = verify_data;

	device_.context = NULL;

	int rc = trusty_keymaster_connect();
	error_ = translate_error(rc);
	if (rc < 0) {
	ALOGE("failed to connect to keymaster (%d)", rc);
	return;
	}

	GetVersionRequest version_request;
	GetVersionResponse version_response;
	error_ = Send(version_request, &version_response);
	if (error_ == KM_ERROR_INVALID_ARGUMENT \|\| error_ == KM_ERROR_UNIMPLEMENTED) {
	ALOGI("\"Bad parameters\" error on GetVersion call. Assuming version 0.");
	message_version_ = 0;
	error_ = KM_ERROR_OK;
	}
	message_version_ = MessageVersion(version_response.major_ver, version_response.minor_ver,
	version_response.subminor_ver);
	if (message_version_ < 0) {
	// Can't translate version? Keymaster implementation must be newer.
	ALOGE("Keymaster version %d.%d.%d not supported.", version_response.major_ver,
	version_response.minor_ver, version_response.subminor_ver);
	error_ = KM_ERROR_VERSION_MISMATCH;
	}
	}

	TrustyKeymasterDevice::~TrustyKeymasterDevice() {
	trusty_keymaster_disconnect();
	}

	const uint64_t HUNDRED_YEARS = 1000LL * 60 * 60 * 24 * 365 * 100;

	int TrustyKeymasterDevice::generate_keypair(const keymaster_keypair_t key_type,
	const void* key_params, uint8_t** key_blob,
	size_t* key_blob_length) {
	ALOGD("Device received generate_keypair");

	if (error_ != KM_ERROR_OK)
	return error_;

	GenerateKeyRequest req(message_version_);
	StoreNewKeyParams(&req.key_description);

	switch (key_type) {
	case TYPE_RSA: {
	req.key_description.push_back(TAG_ALGORITHM, KM_ALGORITHM_RSA);
	const keymaster_rsa_keygen_params_t* rsa_params =
	static_cast<const keymaster_rsa_keygen_params_t*>(key_params);
	ALOGD("Generating RSA pair, modulus size: %u, public exponent: %lu",
	rsa_params->modulus_size, rsa_params->public_exponent);
	req.key_description.push_back(TAG_KEY_SIZE, rsa_params->modulus_size);
	req.key_description.push_back(TAG_RSA_PUBLIC_EXPONENT, rsa_params->public_exponent);
	break;
	}

	case TYPE_EC: {
	req.key_description.push_back(TAG_ALGORITHM, KM_ALGORITHM_EC);
	const keymaster_ec_keygen_params_t* ec_params =
	static_cast<const keymaster_ec_keygen_params_t*>(key_params);
	ALOGD("Generating ECDSA pair, key size: %u", ec_params->field_size);
	req.key_description.push_back(TAG_KEY_SIZE, ec_params->field_size);
	break;
	}
	default:
	ALOGD("Received request for unsuported key type %d", key_type);
	return KM_ERROR_UNSUPPORTED_ALGORITHM;
	}

	GenerateKeyResponse rsp(message_version_);
	ALOGD("Sending generate request");
	keymaster_error_t err = Send(req, &rsp);
	if (err != KM_ERROR_OK) {
	ALOGE("Got error %d from send", err);
	return err;
	}

	*key_blob_length = rsp.key_blob.key_material_size;
	key_blob = static_cast<uint8_t>(malloc(*key_blob_length));
	memcpy(key_blob, rsp.key_blob.key_material, key_blob_length);
	ALOGD("Returning %d bytes in key blob\n", (int)*key_blob_length);

	return KM_ERROR_OK;
	}

	struct EVP_PKEY_Delete {
	void operator()(EVP_PKEY* p) const { EVP_PKEY_free(p); }
	};

	struct PKCS8_PRIV_KEY_INFO_Delete {
	void operator()(PKCS8_PRIV_KEY_INFO* p) const { PKCS8_PRIV_KEY_INFO_free(p); }
	};

	int TrustyKeymasterDevice::import_keypair(const uint8_t* key, const size_t key_length,
	uint8_t** key_blob, size_t* key_blob_length) {
	ALOGD("Device received import_keypair");
	if (error_ != KM_ERROR_OK)
	return error_;

	if (!key)
	return KM_ERROR_UNEXPECTED_NULL_POINTER;

	if (!key_blob \|\| !key_blob_length)
	return KM_ERROR_OUTPUT_PARAMETER_NULL;

	ImportKeyRequest request(message_version_);
	StoreNewKeyParams(&request.key_description);
	keymaster_algorithm_t algorithm;
	keymaster_error_t err = GetPkcs8KeyAlgorithm(key, key_length, &algorithm);
	if (err != KM_ERROR_OK)
	return err;
	request.key_description.push_back(TAG_ALGORITHM, algorithm);

	request.SetKeyMaterial(key, key_length);
	request.key_format = KM_KEY_FORMAT_PKCS8;
	ImportKeyResponse response(message_version_);
	err = Send(request, &response);
	if (err != KM_ERROR_OK)
	return err;

	*key_blob_length = response.key_blob.key_material_size;
	key_blob = static_cast<uint8_t>(malloc(*key_blob_length));
	memcpy(key_blob, response.key_blob.key_material, key_blob_length);
	printf("Returning %d bytes in key blob\n", (int)*key_blob_length);

	return KM_ERROR_OK;
	}

	keymaster_error_t TrustyKeymasterDevice::GetPkcs8KeyAlgorithm(const uint8_t* key, size_t key_length,
	keymaster_algorithm_t* algorithm) {
	if (key == NULL) {
	ALOGE("No key specified for import");
	return KM_ERROR_UNEXPECTED_NULL_POINTER;
	}

	UniquePtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_Delete> pkcs8(
	d2i_PKCS8_PRIV_KEY_INFO(NULL, &key, key_length));
	if (pkcs8.get() == NULL) {
	ALOGE("Could not parse PKCS8 key blob");
	return KM_ERROR_INVALID_KEY_BLOB;
	}

	UniquePtr<EVP_PKEY, EVP_PKEY_Delete> pkey(EVP_PKCS82PKEY(pkcs8.get()));
	if (pkey.get() == NULL) {
	ALOGE("Could not extract key from PKCS8 key blob");
	return KM_ERROR_INVALID_KEY_BLOB;
	}

	switch (EVP_PKEY_type(pkey->type)) {
	case EVP_PKEY_RSA:
	*algorithm = KM_ALGORITHM_RSA;
	break;
	case EVP_PKEY_EC:
	*algorithm = KM_ALGORITHM_EC;
	break;
	default:
	ALOGE("Unsupported algorithm %d", EVP_PKEY_type(pkey->type));
	return KM_ERROR_UNSUPPORTED_ALGORITHM;
	}

	return KM_ERROR_OK;
	}

	int TrustyKeymasterDevice::get_keypair_public(const uint8_t* key_blob, const size_t key_blob_length,
	uint8_t** x509_data, size_t* x509_data_length) {
	ALOGD("Device received get_keypair_public");
	if (error_ != KM_ERROR_OK)
	return error_;

	ExportKeyRequest request(message_version_);
	request.SetKeyMaterial(key_blob, key_blob_length);
	request.key_format = KM_KEY_FORMAT_X509;
	ExportKeyResponse response(message_version_);
	keymaster_error_t err = Send(request, &response);
	if (err != KM_ERROR_OK)
	return err;

	*x509_data_length = response.key_data_length;
	x509_data = static_cast<uint8_t>(malloc(*x509_data_length));
	memcpy(x509_data, response.key_data, x509_data_length);
	printf("Returning %d bytes in x509 key\n", (int)*x509_data_length);

	return KM_ERROR_OK;
	}

	int TrustyKeymasterDevice::sign_data(const void* signing_params, const uint8_t* key_blob,
	const size_t key_blob_length, const uint8_t* data,
	const size_t data_length, uint8_t** signed_data,
	size_t* signed_data_length) {
	ALOGD("Device received sign_data, %d", error_);
	if (error_ != KM_ERROR_OK)
	return error_;

	BeginOperationRequest begin_request(message_version_);
	begin_request.purpose = KM_PURPOSE_SIGN;
	begin_request.SetKeyMaterial(key_blob, key_blob_length);
	keymaster_error_t err = StoreSigningParams(signing_params, key_blob, key_blob_length,
	&begin_request.additional_params);
	if (err != KM_ERROR_OK) {
	ALOGE("Error extracting signing params: %d", err);
	return err;
	}

	BeginOperationResponse begin_response(message_version_);
	ALOGD("Sending signing request begin");
	err = Send(begin_request, &begin_response);
	if (err != KM_ERROR_OK) {
	ALOGE("Error sending sign begin: %d", err);
	return err;
	}

	UpdateOperationRequest update_request(message_version_);
	update_request.op_handle = begin_response.op_handle;
	update_request.input.Reinitialize(data, data_length);
	UpdateOperationResponse update_response(message_version_);
	ALOGD("Sending signing request update");
	err = Send(update_request, &update_response);
	if (err != KM_ERROR_OK) {
	ALOGE("Error sending sign update: %d", err);
	return err;
	}

	FinishOperationRequest finish_request(message_version_);
	finish_request.op_handle = begin_response.op_handle;
	FinishOperationResponse finish_response(message_version_);
	ALOGD("Sending signing request finish");
	err = Send(finish_request, &finish_response);
	if (err != KM_ERROR_OK) {
	ALOGE("Error sending sign finish: %d", err);
	return err;
	}

	*signed_data_length = finish_response.output.available_read();
	signed_data = static_cast<uint8_t>(malloc(*signed_data_length));
	if (!finish_response.output.read(signed_data, signed_data_length)) {
	ALOGE("Error reading response data: %d", err);
	return KM_ERROR_UNKNOWN_ERROR;
	}
	return KM_ERROR_OK;
	}

	int TrustyKeymasterDevice::verify_data(const void* signing_params, const uint8_t* key_blob,
	const size_t key_blob_length, const uint8_t* signed_data,
	const size_t signed_data_length, const uint8_t* signature,
	const size_t signature_length) {
	ALOGD("Device received verify_data");
	if (error_ != KM_ERROR_OK)
	return error_;

	BeginOperationRequest begin_request(message_version_);
	begin_request.purpose = KM_PURPOSE_VERIFY;
	begin_request.SetKeyMaterial(key_blob, key_blob_length);
	keymaster_error_t err = StoreSigningParams(signing_params, key_blob, key_blob_length,
	&begin_request.additional_params);
	if (err != KM_ERROR_OK)
	return err;

	BeginOperationResponse begin_response(message_version_);
	err = Send(begin_request, &begin_response);
	if (err != KM_ERROR_OK)
	return err;

	UpdateOperationRequest update_request(message_version_);
	update_request.op_handle = begin_response.op_handle;
	update_request.input.Reinitialize(signed_data, signed_data_length);
	UpdateOperationResponse update_response(message_version_);
	err = Send(update_request, &update_response);
	if (err != KM_ERROR_OK)
	return err;

	FinishOperationRequest finish_request(message_version_);
	finish_request.op_handle = begin_response.op_handle;
	finish_request.signature.Reinitialize(signature, signature_length);
	FinishOperationResponse finish_response(message_version_);
	err = Send(finish_request, &finish_response);
	if (err != KM_ERROR_OK)
	return err;
	return KM_ERROR_OK;
	}

	hw_device_t* TrustyKeymasterDevice::hw_device() {
	return &device_.common;
	}

	static inline TrustyKeymasterDevice* convert_device(const keymaster0_device_t* dev) {
	return reinterpret_cast<TrustyKeymasterDevice>(const_cast<keymaster0_device_t>(dev));
	}

	/* static */
	int TrustyKeymasterDevice::close_device(hw_device_t* dev) {
	delete reinterpret_cast<TrustyKeymasterDevice*>(dev);
	return 0;
	}

	/* static */
	int TrustyKeymasterDevice::generate_keypair(const keymaster0_device_t* dev,
	const keymaster_keypair_t key_type,
	const void* key_params, uint8_t** keyBlob,
	size_t* keyBlobLength) {
	ALOGD("Generate keypair, sending to device: %p", convert_device(dev));
	return convert_device(dev)->generate_keypair(key_type, key_params, keyBlob, keyBlobLength);
	}

	/* static */
	int TrustyKeymasterDevice::import_keypair(const keymaster0_device_t* dev, const uint8_t* key,
	const size_t key_length, uint8_t** key_blob,
	size_t* key_blob_length) {
	return convert_device(dev)->import_keypair(key, key_length, key_blob, key_blob_length);
	}

	/* static */
	int TrustyKeymasterDevice::get_keypair_public(const keymaster0_device_t* dev,
	const uint8_t* key_blob, const size_t key_blob_length,
	uint8_t** x509_data, size_t* x509_data_length) {
	return convert_device(dev)
	->get_keypair_public(key_blob, key_blob_length, x509_data, x509_data_length);
	}

	/* static */
	int TrustyKeymasterDevice::sign_data(const keymaster0_device_t* dev, 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) {
	return convert_device(dev)
	->sign_data(params, keyBlob, keyBlobLength, data, dataLength, signedData, signedDataLength);
	}

	/* static */
	int TrustyKeymasterDevice::verify_data(const keymaster0_device_t* dev, 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) {
	return convert_device(dev)->verify_data(params, keyBlob, keyBlobLength, signedData,
	signedDataLength, signature, signatureLength);
	}

	keymaster_error_t TrustyKeymasterDevice::Send(uint32_t command, const Serializable& req,
	KeymasterResponse* rsp) {
	uint32_t req_size = req.SerializedSize();
	if (req_size > SEND_BUF_SIZE)
	return KM_ERROR_MEMORY_ALLOCATION_FAILED;
	uint8_t send_buf[SEND_BUF_SIZE];
	Eraser send_buf_eraser(send_buf, SEND_BUF_SIZE);
	req.Serialize(send_buf, send_buf + req_size);

	// Send it
	uint8_t recv_buf[RECV_BUF_SIZE];
	Eraser recv_buf_eraser(recv_buf, RECV_BUF_SIZE);
	uint32_t rsp_size = RECV_BUF_SIZE;
	printf("Sending %d byte request\n", (int)req.SerializedSize());
	int rc = trusty_keymaster_call(command, send_buf, req_size, recv_buf, &rsp_size);
	if (rc < 0) {
	ALOGE("tipc error: %d\n", rc);
	// TODO(swillden): Distinguish permanent from transient errors and set error_ appropriately.
	return translate_error(rc);
	} else {
	ALOGV("Received %d byte response\n", rsp_size);
	}

	const keymaster_message* msg = (keymaster_message *) recv_buf;
	const uint8_t *p = msg->payload;
	if (!rsp->Deserialize(&p, p + rsp_size)) {
	ALOGE("Error deserializing response of size %d\n", (int)rsp_size);
	return KM_ERROR_UNKNOWN_ERROR;
	} else if (rsp->error != KM_ERROR_OK) {
	ALOGE("Response of size %d contained error code %d\n", (int)rsp_size, (int)rsp->error);
	return rsp->error;
	}
	return rsp->error;
	}

	keymaster_error_t TrustyKeymasterDevice::StoreSigningParams(const void* signing_params,
	const uint8_t* key_blob,
	size_t key_blob_length,
	AuthorizationSet* auth_set) {
	uint8_t* pub_key_data;
	size_t pub_key_data_length;
	int err = get_keypair_public(&device_, key_blob, key_blob_length, &pub_key_data,
	&pub_key_data_length);
	if (err < 0) {
	ALOGE("Error %d extracting public key to determine algorithm", err);
	return KM_ERROR_INVALID_KEY_BLOB;
	}
	UniquePtr<uint8_t, Malloc_Delete> pub_key(pub_key_data);

	const uint8_t* p = pub_key_data;
	UniquePtr<EVP_PKEY, EVP_PKEY_Delete> pkey(
	d2i_PUBKEY(nullptr /* allocate new struct */, &p, pub_key_data_length));

	switch (EVP_PKEY_type(pkey->type)) {
	case EVP_PKEY_RSA: {
	const keymaster_rsa_sign_params_t* rsa_params =
	reinterpret_cast<const keymaster_rsa_sign_params_t*>(signing_params);
	if (rsa_params->digest_type != DIGEST_NONE)
	return KM_ERROR_UNSUPPORTED_DIGEST;
	if (rsa_params->padding_type != PADDING_NONE)
	return KM_ERROR_UNSUPPORTED_PADDING_MODE;
	if (!auth_set->push_back(TAG_DIGEST, KM_DIGEST_NONE) \|\|
	!auth_set->push_back(TAG_PADDING, KM_PAD_NONE))
	return KM_ERROR_MEMORY_ALLOCATION_FAILED;
	} break;
	case EVP_PKEY_EC: {
	const keymaster_ec_sign_params_t* ecdsa_params =
	reinterpret_cast<const keymaster_ec_sign_params_t*>(signing_params);
	if (ecdsa_params->digest_type != DIGEST_NONE)
	return KM_ERROR_UNSUPPORTED_DIGEST;
	if (!auth_set->push_back(TAG_DIGEST, KM_DIGEST_NONE))
	return KM_ERROR_MEMORY_ALLOCATION_FAILED;
	} break;
	default:
	return KM_ERROR_UNSUPPORTED_ALGORITHM;
	}
	return KM_ERROR_OK;
	}

	void TrustyKeymasterDevice::StoreNewKeyParams(AuthorizationSet* auth_set) {
	auth_set->push_back(TAG_PURPOSE, KM_PURPOSE_SIGN);
	auth_set->push_back(TAG_PURPOSE, KM_PURPOSE_VERIFY);
	auth_set->push_back(TAG_ALL_USERS);
	auth_set->push_back(TAG_NO_AUTH_REQUIRED);
	uint64_t now = java_time(time(NULL));
	auth_set->push_back(TAG_CREATION_DATETIME, now);
	auth_set->push_back(TAG_ORIGINATION_EXPIRE_DATETIME, now + HUNDRED_YEARS);
	if (message_version_ == 0) {
	auth_set->push_back(TAG_DIGEST_OLD, KM_DIGEST_NONE);
	auth_set->push_back(TAG_PADDING_OLD, KM_PAD_NONE);
	} else {
	auth_set->push_back(TAG_DIGEST, KM_DIGEST_NONE);
	auth_set->push_back(TAG_PADDING, KM_PAD_NONE);
	}
	}

	} // namespace keymaster