static int sign_ec(EVP_PKEY* pkey, keymaster_ec_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;
}
Unique_EC_KEY eckey(EVP_PKEY_get1_EC_KEY(pkey));
if (eckey.get() == NULL) {
logOpenSSLError("openssl_sign_ec");
return -1;
}
unsigned int ecdsaSize = ECDSA_size(eckey.get());
UniquePtr<uint8_t, Malloc_Free> signedDataPtr(reinterpret_cast<uint8_t*>(malloc(ecdsaSize)));
if (signedDataPtr.get() == NULL) {
logOpenSSLError("openssl_sign_ec");
return -1;
}
unsigned char* tmp = reinterpret_cast<unsigned char*>(signedDataPtr.get());
if (ECDSA_sign(0, data, dataLength, tmp, &ecdsaSize, eckey.get()) <= 0) {
logOpenSSLError("openssl_sign_ec");
return -1;
}
*signedDataLength = ecdsaSize;
*signedData = signedDataPtr.release();
return 0;
}
__attribute__((visibility("default"))) int openssl_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("openssl_import_keypair");
return -1;
}
/* assign to EVP */
Unique_EVP_PKEY pkey(EVP_PKCS82PKEY(pkcs8.get()));
if (pkey.get() == NULL) {
logOpenSSLError("openssl_import_keypair");
return -1;
}
if (wrap_key(pkey.get(), EVP_PKEY_type(pkey->type), key_blob, key_blob_length)) {
return -1;
}
return 0;
}
static int generate_rsa_keypair(EVP_PKEY* pkey, const keymaster_rsa_keygen_params_t* rsa_params) {
Unique_BIGNUM bn(BN_new());
if (bn.get() == NULL) {
logOpenSSLError("generate_rsa_keypair");
return -1;
}
if (BN_set_word(bn.get(), rsa_params->public_exponent) == 0) {
logOpenSSLError("generate_rsa_keypair");
return -1;
}
/* initialize RSA */
Unique_RSA rsa(RSA_new());
if (rsa.get() == NULL) {
logOpenSSLError("generate_rsa_keypair");
return -1;
}
if (!RSA_generate_key_ex(rsa.get(), rsa_params->modulus_size, bn.get(), NULL) ||
RSA_check_key(rsa.get()) < 0) {
logOpenSSLError("generate_rsa_keypair");
return -1;
}
if (EVP_PKEY_assign_RSA(pkey, rsa.get()) == 0) {
logOpenSSLError("generate_rsa_keypair");
return -1;
}
release_because_ownership_transferred(rsa);
return 0;
}
static int openssl_import_keypair(const keymaster_device_t* dev,
const uint8_t* key, const size_t key_length,
uint8_t** key_blob, size_t* key_blob_length) {
int response = -1;
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("openssl_import_keypair");
return -1;
}
/* assign to EVP */
Unique_EVP_PKEY pkey(EVP_PKCS82PKEY(pkcs8.get()));
if (pkey.get() == NULL) {
logOpenSSLError("openssl_import_keypair");
return -1;
}
OWNERSHIP_TRANSFERRED(pkcs8);
if (wrap_key(pkey.get(), EVP_PKEY_type(pkey->type), key_blob, key_blob_length)) {
return -1;
}
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;
}
static int openssl_sign_data(const keymaster_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) {
int result = -1;
EVP_MD_CTX ctx;
size_t maxSize;
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) {
return -1;
}
if (EVP_PKEY_type(pkey->type) != EVP_PKEY_RSA) {
ALOGW("Cannot handle non-RSA keys yet");
return -1;
}
keymaster_rsa_sign_params_t* sign_params = (keymaster_rsa_sign_params_t*) params;
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.get()));
if (rsa.get() == NULL) {
logOpenSSLError("openssl_sign_data");
return -1;
}
UniquePtr<uint8_t> signedDataPtr(reinterpret_cast<uint8_t*>(malloc(dataLength)));
if (signedDataPtr.get() == NULL) {
logOpenSSLError("openssl_sign_data");
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_data");
return -1;
}
*signedDataLength = dataLength;
*signedData = signedDataPtr.release();
return 0;
}
static int openssl_verify_data(const keymaster_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) {
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) {
return -1;
}
if (EVP_PKEY_type(pkey->type) != EVP_PKEY_RSA) {
ALOGW("Cannot handle non-RSA keys yet");
return -1;
}
keymaster_rsa_sign_params_t* sign_params = (keymaster_rsa_sign_params_t*) params;
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.get()));
if (rsa.get() == NULL) {
logOpenSSLError("openssl_verify_data");
return -1;
}
UniquePtr<uint8_t> dataPtr(reinterpret_cast<uint8_t*>(malloc(signedDataLength)));
if (dataPtr.get() == NULL) {
logOpenSSLError("openssl_verify_data");
return -1;
}
unsigned char* tmp = reinterpret_cast<unsigned char*>(dataPtr.get());
if (!RSA_public_decrypt(signatureLength, signature, tmp, rsa.get(), RSA_NO_PADDING)) {
logOpenSSLError("openssl_verify_data");
return -1;
}
int result = 0;
for (size_t i = 0; i < signedDataLength; i++) {
result |= tmp[i] ^ signedData[i];
}
return result == 0 ? 0 : -1;
}
static int generate_ec_keypair(EVP_PKEY* pkey, const keymaster_ec_keygen_params_t* ec_params) {
Unique_EC_GROUP group;
switch (ec_params->field_size) {
case 224:
group.reset(EC_GROUP_new_by_curve_name(NID_secp224r1));
break;
case 256:
group.reset(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1));
break;
case 384:
group.reset(EC_GROUP_new_by_curve_name(NID_secp384r1));
break;
case 521:
group.reset(EC_GROUP_new_by_curve_name(NID_secp521r1));
break;
default:
break;
}
if (group.get() == NULL) {
logOpenSSLError("generate_ec_keypair");
return -1;
}
#if !defined(OPENSSL_IS_BORINGSSL)
EC_GROUP_set_point_conversion_form(group.get(), POINT_CONVERSION_UNCOMPRESSED);
EC_GROUP_set_asn1_flag(group.get(), OPENSSL_EC_NAMED_CURVE);
#endif
/* initialize EC key */
Unique_EC_KEY eckey(EC_KEY_new());
if (eckey.get() == NULL) {
logOpenSSLError("generate_ec_keypair");
return -1;
}
if (EC_KEY_set_group(eckey.get(), group.get()) != 1) {
logOpenSSLError("generate_ec_keypair");
return -1;
}
if (EC_KEY_generate_key(eckey.get()) != 1 || EC_KEY_check_key(eckey.get()) < 0) {
logOpenSSLError("generate_ec_keypair");
return -1;
}
if (EVP_PKEY_assign_EC_KEY(pkey, eckey.get()) == 0) {
logOpenSSLError("generate_ec_keypair");
return -1;
}
release_because_ownership_transferred(eckey);
return 0;
}
static int wrap_key(EVP_PKEY* pkey, int type, uint8_t** keyBlob, size_t* keyBlobLength) {
/* Find the length of each size */
int publicLen = i2d_PublicKey(pkey, NULL);
int privateLen = i2d_PrivateKey(pkey, NULL);
if (privateLen <= 0 || publicLen <= 0) {
ALOGE("private or public 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(int) + sizeof(int) + privateLen
+ sizeof(int) + publicLen;
UniquePtr<unsigned char[]> derData(new unsigned char[*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(int) - 1; i >= 0; i--) {
*p++ = (type >> (8*i)) & 0xFF;
}
/* Write public key to allocated buffer */
for (int i = sizeof(int) - 1; i >= 0; i--) {
*p++ = (publicLen >> (8*i)) & 0xFF;
}
if (i2d_PublicKey(pkey, &p) != publicLen) {
logOpenSSLError("wrap_key");
return -1;
}
/* Write private key to allocated buffer */
for (int i = sizeof(int) - 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;
}
__attribute__((visibility("default"))) int openssl_generate_keypair(
const keymaster0_device_t*, const keymaster_keypair_t key_type, const void* key_params,
uint8_t** keyBlob, size_t* keyBlobLength) {
Unique_EVP_PKEY pkey(EVP_PKEY_new());
if (pkey.get() == NULL) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
if (key_params == NULL) {
ALOGW("key_params == null");
return -1;
} else if (key_type == TYPE_DSA) {
const keymaster_dsa_keygen_params_t* dsa_params =
(const keymaster_dsa_keygen_params_t*)key_params;
generate_dsa_keypair(pkey.get(), dsa_params);
} else if (key_type == TYPE_EC) {
const keymaster_ec_keygen_params_t* ec_params =
(const keymaster_ec_keygen_params_t*)key_params;
generate_ec_keypair(pkey.get(), ec_params);
} else if (key_type == TYPE_RSA) {
const keymaster_rsa_keygen_params_t* rsa_params =
(const keymaster_rsa_keygen_params_t*)key_params;
generate_rsa_keypair(pkey.get(), rsa_params);
} 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;
}
static int verify_dsa(EVP_PKEY* pkey, keymaster_dsa_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;
}
Unique_DSA dsa(EVP_PKEY_get1_DSA(pkey));
if (dsa.get() == NULL) {
logOpenSSLError("openssl_verify_dsa");
return -1;
}
if (DSA_verify(0, signedData, signedDataLength, signature, signatureLength, dsa.get()) <= 0) {
logOpenSSLError("openssl_verify_dsa");
return -1;
}
return 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;
// derData will be returned to the caller, so allocate it with malloc.
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;
}
__attribute__((visibility("default"))) int openssl_get_keypair_public(const keymaster0_device_t*,
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) {
return -1;
}
int len = i2d_PUBKEY(pkey.get(), NULL);
if (len <= 0) {
logOpenSSLError("openssl_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("openssl_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 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("openssl_verify_data");
return -1;
}
UniquePtr<uint8_t[]> dataPtr(new uint8_t[signedDataLength]);
if (dataPtr.get() == NULL) {
logOpenSSLError("openssl_verify_data");
return -1;
}
unsigned char* tmp = reinterpret_cast<unsigned char*>(dataPtr.get());
if (!RSA_public_decrypt(signatureLength, signature, tmp, rsa.get(), RSA_NO_PADDING)) {
logOpenSSLError("openssl_verify_data");
return -1;
}
int result = 0;
for (size_t i = 0; i < signedDataLength; i++) {
result |= tmp[i] ^ signedData[i];
}
return result == 0 ? 0 : -1;
}
static int openssl_generate_keypair(const keymaster_device_t* dev,
const keymaster_keypair_t key_type, const void* key_params,
uint8_t** keyBlob, size_t* keyBlobLength) {
ssize_t privateLen, publicLen;
if (key_type != TYPE_RSA) {
ALOGW("Unsupported key type %d", key_type);
return -1;
} else if (key_params == NULL) {
ALOGW("key_params == null");
return -1;
}
keymaster_rsa_keygen_params_t* rsa_params = (keymaster_rsa_keygen_params_t*) key_params;
Unique_BIGNUM bn(BN_new());
if (bn.get() == NULL) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
if (BN_set_word(bn.get(), rsa_params->public_exponent) == 0) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
/* initialize RSA */
Unique_RSA rsa(RSA_new());
if (rsa.get() == NULL) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
if (!RSA_generate_key_ex(rsa.get(), rsa_params->modulus_size, bn.get(), NULL)
|| RSA_check_key(rsa.get()) < 0) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
/* assign to EVP */
Unique_EVP_PKEY pkey(EVP_PKEY_new());
if (pkey.get() == NULL) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
if (EVP_PKEY_assign_RSA(pkey.get(), rsa.get()) == 0) {
logOpenSSLError("openssl_generate_keypair");
return -1;
}
OWNERSHIP_TRANSFERRED(rsa);
if (wrap_key(pkey.get(), EVP_PKEY_RSA, keyBlob, keyBlobLength)) {
return -1;
}
return 0;
}
static int generate_dsa_keypair(EVP_PKEY* pkey, const keymaster_dsa_keygen_params_t* dsa_params) {
if (dsa_params->key_size < 512) {
ALOGI("Requested DSA key size is too small (<512)");
return -1;
}
Unique_DSA dsa(DSA_new());
if (dsa_params->generator_len == 0 || dsa_params->prime_p_len == 0 ||
dsa_params->prime_q_len == 0 || dsa_params->generator == NULL ||
dsa_params->prime_p == NULL || dsa_params->prime_q == NULL) {
if (DSA_generate_parameters_ex(dsa.get(), dsa_params->key_size, NULL, 0, NULL, NULL,
NULL) != 1) {
logOpenSSLError("generate_dsa_keypair");
return -1;
}
} else {
dsa->g = BN_bin2bn(dsa_params->generator, dsa_params->generator_len, NULL);
if (dsa->g == NULL) {
logOpenSSLError("generate_dsa_keypair");
return -1;
}
dsa->p = BN_bin2bn(dsa_params->prime_p, dsa_params->prime_p_len, NULL);
if (dsa->p == NULL) {
logOpenSSLError("generate_dsa_keypair");
return -1;
}
dsa->q = BN_bin2bn(dsa_params->prime_q, dsa_params->prime_q_len, NULL);
if (dsa->q == NULL) {
logOpenSSLError("generate_dsa_keypair");
return -1;
}
}
if (DSA_generate_key(dsa.get()) != 1) {
logOpenSSLError("generate_dsa_keypair");
return -1;
}
if (EVP_PKEY_assign_DSA(pkey, dsa.get()) == 0) {
logOpenSSLError("generate_dsa_keypair");
return -1;
}
release_because_ownership_transferred(dsa);
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;
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(int) + sizeof(int) + 1
+ sizeof(int) + 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();
int type = 0;
for (size_t i = 0; i < sizeof(int); i++) {
type = (type << 8) | *p++;
}
Unique_EVP_PKEY pkey(EVP_PKEY_new());
if (pkey.get() == NULL) {
logOpenSSLError("unwrap_key");
return NULL;
}
for (size_t i = 0; i < sizeof(int); i++) {
publicLen = (publicLen << 8) | *p++;
}
if (p + publicLen > end) {
ALOGE("public key length encoding error: size=%ld, end=%d", publicLen, end - p);
return NULL;
}
EVP_PKEY* tmp = pkey.get();
d2i_PublicKey(type, &tmp, &p, publicLen);
if (end - p < 2) {
ALOGE("private key truncated");
return NULL;
}
for (size_t i = 0; i < sizeof(int); i++) {
privateLen = (privateLen << 8) | *p++;
}
if (p + privateLen > end) {
ALOGE("private key length encoding error: size=%ld, end=%d", privateLen, end - p);
return NULL;
}
d2i_PrivateKey(type, &tmp, &p, privateLen);
return pkey.release();
}
