Home | History | Annotate | Download | only in native 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "UniquePtr.h"
     18 
     19 #include <stdarg.h>
     20 #include <string.h>
     21 #include <unistd.h>
     22 
     23 #include <openssl/objects.h>
     24 #include <openssl/engine.h>
     25 #include <openssl/evp.h>
     26 #include <openssl/pem.h>
     27 
     28 #define DYNAMIC_ENGINE
     29 #define TEST_ENGINE_ID   "javacoretests"
     30 #define TEST_ENGINE_NAME "libcore test engine"
     31 
     32 struct RSA_Delete {
     33     void operator()(RSA* p) const {
     34         RSA_free(p);
     35     }
     36 };
     37 typedef UniquePtr<RSA, RSA_Delete> Unique_RSA;
     38 
     39 static const char* HMAC_TAG = "-HMAC-";
     40 static const size_t HMAC_TAG_LEN = strlen(HMAC_TAG);
     41 
     42 static EVP_PKEY *test_load_key(ENGINE* e, const char *key_id,
     43         EVP_PKEY* (*read_func)(BIO*, EVP_PKEY**, pem_password_cb*, void*)) {
     44     void* data = static_cast<void*>(const_cast<char*>(key_id));
     45 
     46     EVP_PKEY *key = NULL;
     47 
     48     const size_t key_len = strlen(key_id);
     49     if (key_len > HMAC_TAG_LEN && !strncmp(key_id, HMAC_TAG, HMAC_TAG_LEN)) {
     50         key = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, e, reinterpret_cast<const unsigned char*>(key_id),
     51                 key_len);
     52     } else {
     53         BIO* in = BIO_new_mem_buf(data, strlen(key_id));
     54         if (!in) {
     55             return NULL;
     56         }
     57         key = read_func(in, NULL, 0, NULL);
     58         BIO_free(in);
     59 
     60         if (key != NULL && EVP_PKEY_type(key->type) == EVP_PKEY_RSA) {
     61             ENGINE_init(e);
     62 
     63             Unique_RSA rsa(EVP_PKEY_get1_RSA(key));
     64             rsa->engine = e;
     65             rsa->flags |= RSA_FLAG_EXT_PKEY;
     66         }
     67     }
     68 
     69     return key;
     70 }
     71 
     72 static EVP_PKEY* test_load_privkey(ENGINE* e, const char* key_id, UI_METHOD*, void*) {
     73     return test_load_key(e, key_id, PEM_read_bio_PrivateKey);
     74 }
     75 
     76 static EVP_PKEY* test_load_pubkey(ENGINE* e, const char* key_id, UI_METHOD*, void*) {
     77     return test_load_key(e, key_id, PEM_read_bio_PUBKEY);
     78 }
     79 
     80 static const int meths[] = {
     81         EVP_PKEY_HMAC,
     82 };
     83 
     84 static int pkey_meths(ENGINE*, EVP_PKEY_METHOD** meth, const int** nids, int nid) {
     85     if (nid == EVP_PKEY_HMAC) {
     86         *meth = const_cast<EVP_PKEY_METHOD*>(EVP_PKEY_meth_find(nid));
     87         return 1;
     88     } else if (nid != 0) {
     89         return 0;
     90     }
     91 
     92     if (nids != NULL) {
     93         *nids = meths;
     94         return 1;
     95     }
     96 
     97     return 0;
     98 }
     99 
    100 static int test_engine_setup(ENGINE* e) {
    101     if (!ENGINE_set_id(e, TEST_ENGINE_ID)
    102             || !ENGINE_set_name(e, TEST_ENGINE_NAME)
    103             || !ENGINE_set_flags(e, 0)
    104             || !ENGINE_set_RSA(e, RSA_get_default_method())
    105             || !ENGINE_set_load_privkey_function(e, test_load_privkey)
    106             || !ENGINE_set_load_pubkey_function(e, test_load_pubkey)
    107             || !ENGINE_set_pkey_meths(e, pkey_meths)) {
    108         return 0;
    109     }
    110 
    111     return 1;
    112 }
    113 
    114 static int test_engine_bind_fn(ENGINE *e, const char *id) {
    115     if (id && (strcmp(id, TEST_ENGINE_ID) != 0)) {
    116         return 0;
    117     }
    118 
    119     if (!test_engine_setup(e)) {
    120         return 0;
    121     }
    122 
    123     return 1;
    124 }
    125 
    126 extern "C" {
    127 #undef OPENSSL_EXPORT
    128 #define OPENSSL_EXPORT extern __attribute__ ((visibility ("default")))
    129 
    130 IMPLEMENT_DYNAMIC_CHECK_FN()
    131 IMPLEMENT_DYNAMIC_BIND_FN(test_engine_bind_fn)
    132 };
    133