170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root/*
270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * Copyright (C) 2012 The Android Open Source Project
370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root *
470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * Licensed under the Apache License, Version 2.0 (the "License");
570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * you may not use this file except in compliance with the License.
670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * You may obtain a copy of the License at
770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root *
870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root *      http://www.apache.org/licenses/LICENSE-2.0
970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root *
1070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * Unless required by applicable law or agreed to in writing, software
1170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * distributed under the License is distributed on an "AS IS" BASIS,
1270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * See the License for the specific language governing permissions and
1470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * limitations under the License.
1570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root */
1670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <errno.h>
1770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <string.h>
1870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <stdint.h>
1970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
20822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root#include <keystore.h>
21822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root
2270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <hardware/hardware.h>
2370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <hardware/keymaster.h>
2470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
2570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <openssl/evp.h>
2670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <openssl/bio.h>
2770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <openssl/rsa.h>
2870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <openssl/err.h>
2970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <openssl/x509.h>
3070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
3198c2f8fcc1263a9d94adac66994fffc96c0df699Colin Cross#include <utils/UniquePtr.h>
3270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
3370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root// For debugging
3470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root//#define LOG_NDEBUG 0
3570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
3670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#define LOG_TAG "OpenSSLKeyMaster"
3770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#include <cutils/log.h>
3870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
3970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstruct BIGNUM_Delete {
4070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    void operator()(BIGNUM* p) const {
4170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        BN_free(p);
4270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
4370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root};
4470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Roottypedef UniquePtr<BIGNUM, BIGNUM_Delete> Unique_BIGNUM;
4570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
4670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstruct EVP_PKEY_Delete {
4770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    void operator()(EVP_PKEY* p) const {
4870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        EVP_PKEY_free(p);
4970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
5070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root};
5170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Roottypedef UniquePtr<EVP_PKEY, EVP_PKEY_Delete> Unique_EVP_PKEY;
5270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
5370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstruct PKCS8_PRIV_KEY_INFO_Delete {
5470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    void operator()(PKCS8_PRIV_KEY_INFO* p) const {
5570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        PKCS8_PRIV_KEY_INFO_free(p);
5670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
5770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root};
5870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Roottypedef UniquePtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_Delete> Unique_PKCS8_PRIV_KEY_INFO;
5970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
6070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstruct RSA_Delete {
6170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    void operator()(RSA* p) const {
6270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        RSA_free(p);
6370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
6470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root};
6570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Roottypedef UniquePtr<RSA, RSA_Delete> Unique_RSA;
6670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
6770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Roottypedef UniquePtr<keymaster_device_t> Unique_keymaster_device_t;
6870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
6970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root/**
7070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * Many OpenSSL APIs take ownership of an argument on success but don't free the argument
7170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * on failure. This means we need to tell our scoped pointers when we've transferred ownership,
7270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * without triggering a warning by not using the result of release().
7370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root */
7470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root#define OWNERSHIP_TRANSFERRED(obj) \
7570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    typeof (obj.release()) _dummy __attribute__((unused)) = obj.release()
7670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
7770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
7870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root/*
7970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * Checks this thread's OpenSSL error queue and logs if
8070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * necessary.
8170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root */
8270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic void logOpenSSLError(const char* location) {
8370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int error = ERR_get_error();
8470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
8570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (error != 0) {
8670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        char message[256];
8770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ERR_error_string_n(error, message, sizeof(message));
8870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("OpenSSL error in %s %d: %s", location, error, message);
8970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
9070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
9170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    ERR_clear_error();
9270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    ERR_remove_state(0);
9370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
9470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
9570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int wrap_key(EVP_PKEY* pkey, int type, uint8_t** keyBlob, size_t* keyBlobLength) {
9670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* Find the length of each size */
9770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int publicLen = i2d_PublicKey(pkey, NULL);
9870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int privateLen = i2d_PrivateKey(pkey, NULL);
9970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
10070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (privateLen <= 0 || publicLen <= 0) {
10170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("private or public key size was too big");
10270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
10370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
10470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
10570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* int type + int size + private key data + int size + public key data */
106822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    *keyBlobLength = get_softkey_header_size() + sizeof(int) + sizeof(int) + privateLen
107822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root            + sizeof(int) + publicLen;
10870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
10970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    UniquePtr<unsigned char[]> derData(new unsigned char[*keyBlobLength]);
11070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (derData.get() == NULL) {
11170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("could not allocate memory for key blob");
11270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
11370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
11470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    unsigned char* p = derData.get();
11570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
116822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    /* Write the magic value for software keys. */
117822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    p = add_softkey_header(p, *keyBlobLength);
118822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root
11970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* Write key type to allocated buffer */
12070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (int i = sizeof(int) - 1; i >= 0; i--) {
12170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        *p++ = (type >> (8*i)) & 0xFF;
12270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
12370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
12470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* Write public key to allocated buffer */
12570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (int i = sizeof(int) - 1; i >= 0; i--) {
12670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        *p++ = (publicLen >> (8*i)) & 0xFF;
12770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
12870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (i2d_PublicKey(pkey, &p) != publicLen) {
12970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("wrap_key");
13070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
13170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
13270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
13370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* Write private key to allocated buffer */
13470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (int i = sizeof(int) - 1; i >= 0; i--) {
13570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        *p++ = (privateLen >> (8*i)) & 0xFF;
13670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
13770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (i2d_PrivateKey(pkey, &p) != privateLen) {
13870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("wrap_key");
13970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
14070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
14170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
14270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    *keyBlob = derData.release();
14370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
14470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
14570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
14670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
14770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic EVP_PKEY* unwrap_key(const uint8_t* keyBlob, const size_t keyBlobLength) {
14870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    long publicLen = 0;
14970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    long privateLen = 0;
15070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    const uint8_t* p = keyBlob;
15170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    const uint8_t *const end = keyBlob + keyBlobLength;
15270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
15370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (keyBlob == NULL) {
15470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("supplied key blob was NULL");
15570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return NULL;
15670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
15770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
15870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    // Should be large enough for:
159822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    // int32 magic, int32 type, int32 pubLen, char* pub, int32 privLen, char* priv
160822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    if (keyBlobLength < (get_softkey_header_size() + sizeof(int) + sizeof(int) + 1
161822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root            + sizeof(int) + 1)) {
16270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("key blob appears to be truncated");
16370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return NULL;
16470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
16570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
166822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    if (!is_softkey(p, keyBlobLength)) {
167822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root        ALOGE("cannot read key; it was not made by this keymaster");
168822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root        return NULL;
169822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    }
170822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    p += get_softkey_header_size();
171822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root
17270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int type = 0;
17370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (size_t i = 0; i < sizeof(int); i++) {
17470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        type = (type << 8) | *p++;
17570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
17670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
17770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_EVP_PKEY pkey(EVP_PKEY_new());
17870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkey.get() == NULL) {
17970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("unwrap_key");
18070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return NULL;
18170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
18270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
18370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (size_t i = 0; i < sizeof(int); i++) {
18470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        publicLen = (publicLen << 8) | *p++;
18570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
18670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (p + publicLen > end) {
18770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("public key length encoding error: size=%ld, end=%d", publicLen, end - p);
18870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return NULL;
18970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
19070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    EVP_PKEY* tmp = pkey.get();
19170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    d2i_PublicKey(type, &tmp, &p, publicLen);
19270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
19370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (end - p < 2) {
19470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("private key truncated");
19570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return NULL;
19670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
19770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (size_t i = 0; i < sizeof(int); i++) {
19870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        privateLen = (privateLen << 8) | *p++;
19970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
20070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (p + privateLen > end) {
20170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("private key length encoding error: size=%ld, end=%d", privateLen, end - p);
20270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return NULL;
20370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
20470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    d2i_PrivateKey(type, &tmp, &p, privateLen);
20570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
20670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return pkey.release();
20770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
20870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
20970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_generate_keypair(const keymaster_device_t* dev,
21070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const keymaster_keypair_t key_type, const void* key_params,
21170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        uint8_t** keyBlob, size_t* keyBlobLength) {
21270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    ssize_t privateLen, publicLen;
21370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
21470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (key_type != TYPE_RSA) {
21570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Unsupported key type %d", key_type);
21670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
21770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    } else if (key_params == NULL) {
21870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("key_params == null");
21970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
22070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
22170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
22270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    keymaster_rsa_keygen_params_t* rsa_params = (keymaster_rsa_keygen_params_t*) key_params;
22370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
22470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_BIGNUM bn(BN_new());
22570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (bn.get() == NULL) {
22670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_generate_keypair");
22770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
22870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
22970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
23070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (BN_set_word(bn.get(), rsa_params->public_exponent) == 0) {
23170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_generate_keypair");
23270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
23370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
23470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
23570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* initialize RSA */
23670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_RSA rsa(RSA_new());
23770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (rsa.get() == NULL) {
23870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_generate_keypair");
23970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
24070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
24170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
24270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (!RSA_generate_key_ex(rsa.get(), rsa_params->modulus_size, bn.get(), NULL)
24370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root            || RSA_check_key(rsa.get()) < 0) {
24470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_generate_keypair");
24570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
24670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
24770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
24870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* assign to EVP */
24970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_EVP_PKEY pkey(EVP_PKEY_new());
25070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkey.get() == NULL) {
25170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_generate_keypair");
25270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
25370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
25470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
25570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (EVP_PKEY_assign_RSA(pkey.get(), rsa.get()) == 0) {
25670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_generate_keypair");
25770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
25870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
25970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    OWNERSHIP_TRANSFERRED(rsa);
26070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
26170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (wrap_key(pkey.get(), EVP_PKEY_RSA, keyBlob, keyBlobLength)) {
26270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
26370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
26470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
26570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
26670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
26770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
26870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_import_keypair(const keymaster_device_t* dev,
26970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* key, const size_t key_length,
27070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        uint8_t** key_blob, size_t* key_blob_length) {
27170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int response = -1;
27270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
27370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (key == NULL) {
27470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("input key == NULL");
27570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
27670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    } else if (key_blob == NULL || key_blob_length == NULL) {
27770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("output key blob or length == NULL");
27870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
27970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
28070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
28170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_PKCS8_PRIV_KEY_INFO pkcs8(d2i_PKCS8_PRIV_KEY_INFO(NULL, &key, key_length));
28270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkcs8.get() == NULL) {
28370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_import_keypair");
28470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
28570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
28670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
28770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    /* assign to EVP */
28870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_EVP_PKEY pkey(EVP_PKCS82PKEY(pkcs8.get()));
28970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkey.get() == NULL) {
29070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_import_keypair");
29170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
29270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
29370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    OWNERSHIP_TRANSFERRED(pkcs8);
29470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
29570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (wrap_key(pkey.get(), EVP_PKEY_type(pkey->type), key_blob, key_blob_length)) {
29670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
29770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
29870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
29970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
30070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
30170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
30270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_get_keypair_public(const struct keymaster_device* dev,
30370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* key_blob, const size_t key_blob_length,
30470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        uint8_t** x509_data, size_t* x509_data_length) {
30570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
30670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (x509_data == NULL || x509_data_length == NULL) {
30770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("output public key buffer == NULL");
30870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
30970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
31070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
31170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_EVP_PKEY pkey(unwrap_key(key_blob, key_blob_length));
31270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkey.get() == NULL) {
31370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
31470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
31570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
31670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int len = i2d_PUBKEY(pkey.get(), NULL);
31770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (len <= 0) {
31870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_get_keypair_public");
31970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
32070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
32170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
32270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    UniquePtr<uint8_t> key(static_cast<uint8_t*>(malloc(len)));
32370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (key.get() == NULL) {
32470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGE("Could not allocate memory for public key data");
32570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
32670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
32770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
32870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    unsigned char* tmp = reinterpret_cast<unsigned char*>(key.get());
32970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (i2d_PUBKEY(pkey.get(), &tmp) != len) {
33070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_get_keypair_public");
33170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
33270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
33370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
33470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    ALOGV("Length of x509 data is %d", len);
33570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    *x509_data_length = len;
33670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    *x509_data = key.release();
33770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
33870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
33970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
34070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
34170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_sign_data(const keymaster_device_t* dev,
34270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const void* params,
34370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* keyBlob, const size_t keyBlobLength,
34470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* data, const size_t dataLength,
34570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        uint8_t** signedData, size_t* signedDataLength) {
34670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
34770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int result = -1;
34870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    EVP_MD_CTX ctx;
34970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    size_t maxSize;
35070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
35170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (data == NULL) {
35270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("input data to sign == NULL");
35370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
35470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    } else if (signedData == NULL || signedDataLength == NULL) {
35570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("output signature buffer == NULL");
35670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
35770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
35870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
35970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_EVP_PKEY pkey(unwrap_key(keyBlob, keyBlobLength));
36070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkey.get() == NULL) {
36170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
36270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
36370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
36470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (EVP_PKEY_type(pkey->type) != EVP_PKEY_RSA) {
36570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Cannot handle non-RSA keys yet");
36670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
36770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
36870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
36970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    keymaster_rsa_sign_params_t* sign_params = (keymaster_rsa_sign_params_t*) params;
37070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (sign_params->digest_type != DIGEST_NONE) {
37170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Cannot handle digest type %d", sign_params->digest_type);
37270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
37370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    } else if (sign_params->padding_type != PADDING_NONE) {
37470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Cannot handle padding type %d", sign_params->padding_type);
37570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
37670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
37770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
37870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey.get()));
37970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (rsa.get() == NULL) {
38070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_sign_data");
38170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
38270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
38370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
38470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    UniquePtr<uint8_t> signedDataPtr(reinterpret_cast<uint8_t*>(malloc(dataLength)));
38570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (signedDataPtr.get() == NULL) {
38670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_sign_data");
38770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
38870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
38970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
39070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    unsigned char* tmp = reinterpret_cast<unsigned char*>(signedDataPtr.get());
39170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (RSA_private_encrypt(dataLength, data, tmp, rsa.get(), RSA_NO_PADDING) <= 0) {
39270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_sign_data");
39370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
39470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
39570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
39670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    *signedDataLength = dataLength;
39770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    *signedData = signedDataPtr.release();
39870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
39970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
40070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
40170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_verify_data(const keymaster_device_t* dev,
40270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const void* params,
40370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* keyBlob, const size_t keyBlobLength,
40470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* signedData, const size_t signedDataLength,
40570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        const uint8_t* signature, const size_t signatureLength) {
40670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
40770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (signedData == NULL || signature == NULL) {
40870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("data or signature buffers == NULL");
40970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
41070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
41170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
41270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_EVP_PKEY pkey(unwrap_key(keyBlob, keyBlobLength));
41370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (pkey.get() == NULL) {
41470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
41570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
41670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
41770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (EVP_PKEY_type(pkey->type) != EVP_PKEY_RSA) {
41870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Cannot handle non-RSA keys yet");
41970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
42070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
42170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
42270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    keymaster_rsa_sign_params_t* sign_params = (keymaster_rsa_sign_params_t*) params;
42370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (sign_params->digest_type != DIGEST_NONE) {
42470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Cannot handle digest type %d", sign_params->digest_type);
42570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
42670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    } else if (sign_params->padding_type != PADDING_NONE) {
42770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("Cannot handle padding type %d", sign_params->padding_type);
42870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
42970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    } else if (signatureLength != signedDataLength) {
43070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        ALOGW("signed data length must be signature length");
43170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
43270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
43370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
43470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey.get()));
43570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (rsa.get() == NULL) {
43670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_verify_data");
43770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
43870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
43970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
44070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    UniquePtr<uint8_t> dataPtr(reinterpret_cast<uint8_t*>(malloc(signedDataLength)));
44170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (dataPtr.get() == NULL) {
44270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_verify_data");
44370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
44470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
44570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
44670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    unsigned char* tmp = reinterpret_cast<unsigned char*>(dataPtr.get());
44770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (!RSA_public_decrypt(signatureLength, signature, tmp, rsa.get(), RSA_NO_PADDING)) {
44870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        logOpenSSLError("openssl_verify_data");
44970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -1;
45070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
45170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
45270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    int result = 0;
45370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    for (size_t i = 0; i < signedDataLength; i++) {
45470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        result |= tmp[i] ^ signedData[i];
45570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    }
45670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
45770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return result == 0 ? 0 : -1;
45870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
45970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
46070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root/* Close an opened OpenSSL instance */
46170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_close(hw_device_t *dev) {
46270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    free(dev);
46370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
46470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
46570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
46670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root/*
46770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root * Generic device handling
46870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root */
46970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic int openssl_open(const hw_module_t* module, const char* name,
47070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        hw_device_t** device) {
47170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (strcmp(name, KEYSTORE_KEYMASTER) != 0)
47270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -EINVAL;
47370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
47470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    Unique_keymaster_device_t dev(new keymaster_device_t);
47570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    if (dev.get() == NULL)
47670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root        return -ENOMEM;
47770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
47870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->common.tag = HARDWARE_DEVICE_TAG;
47970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->common.version = 1;
48070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->common.module = (struct hw_module_t*) module;
48170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->common.close = openssl_close;
48270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
483822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root    dev->flags = KEYMASTER_SOFTWARE_ONLY;
484822c3a99d930e9299e2fad2fb3e0ff91b119b95aKenny Root
48570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->generate_keypair = openssl_generate_keypair;
48670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->import_keypair = openssl_import_keypair;
48770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->get_keypair_public = openssl_get_keypair_public;
48870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->delete_keypair = NULL;
489c0ff10d48be65cbf498636539316cc378b1c9424Kenny Root    dev->delete_all = NULL;
49070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->sign_data = openssl_sign_data;
49170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    dev->verify_data = openssl_verify_data;
49270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
49370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    ERR_load_crypto_strings();
49470e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    ERR_load_BIO_strings();
49570e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
49670e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    *device = reinterpret_cast<hw_device_t*>(dev.release());
49770e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
49870e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    return 0;
49970e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root}
50070e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root
50170e3a86abd2c412d602a018967c01c177eb6cf4eKenny Rootstatic struct hw_module_methods_t keystore_module_methods = {
50270e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root    open: openssl_open,
50370e3a86abd2c412d602a018967c01c177eb6cf4eKenny Root};
504