apps/lib/engine.c

   1 /*
   2  * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * Here is a set of wrappers for the ENGINE API, which are no-ops when the
  12  * ENGINE API is disabled / removed.
  13  * We need to suppress deprecation warnings to make this work.
  14  */
  15 #define OPENSSL_SUPPRESS_DEPRECATED
  16
  17 #include <string.h> /* strcmp */
  18
  19 #include <openssl/types.h> /* Ensure we have the ENGINE type, regardless */
  20 #include <openssl/err.h>
  21 #ifndef OPENSSL_NO_ENGINE
  22 # include <openssl/engine.h>
  23 #endif
  24 #include "apps.h"
  25
  26 #ifndef OPENSSL_NO_ENGINE
  27 /* Try to load an engine in a shareable library */
  28 static ENGINE *try_load_engine(const char *engine)
  29 {
  30     ENGINE *e = NULL;
  31
  32     if ((e = ENGINE_by_id("dynamic")) != NULL) {
  33         if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", engine, 0)
  34             || !ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0)) {
  35             ENGINE_free(e);
  36             e = NULL;
  37         }
  38     }
  39     return e;
  40 }
  41 #endif
  42
  43 ENGINE *setup_engine_methods(const char *id, unsigned int methods, int debug)
  44 {
  45     ENGINE *e = NULL;
  46
  47 #ifndef OPENSSL_NO_ENGINE
  48     if (id != NULL) {
  49         if (strcmp(id, "auto") == 0) {
  50             BIO_printf(bio_err, "Enabling auto ENGINE support\n");
  51             ENGINE_register_all_complete();
  52             return NULL;
  53         }
  54         if ((e = ENGINE_by_id(id)) == NULL
  55             && (e = try_load_engine(id)) == NULL) {
  56             BIO_printf(bio_err, "Invalid engine \"%s\"\n", id);
  57             ERR_print_errors(bio_err);
  58             return NULL;
  59         }
  60         if (debug)
  61             (void)ENGINE_ctrl(e, ENGINE_CTRL_SET_LOGSTREAM, 0, bio_err, 0);
  62         if (!ENGINE_ctrl_cmd(e, "SET_USER_INTERFACE", 0,
  63                              (void *)get_ui_method(), 0, 1)
  64                 || !ENGINE_set_default(e, methods)) {
  65             BIO_printf(bio_err, "Cannot use engine \"%s\"\n", ENGINE_get_id(e));
  66             ERR_print_errors(bio_err);
  67             ENGINE_free(e);
  68             return NULL;
  69         }
  70
  71         BIO_printf(bio_err, "Engine \"%s\" set.\n", ENGINE_get_id(e));
  72     }
  73 #endif
  74     return e;
  75 }
  76
  77 void release_engine(ENGINE *e)
  78 {
  79 #ifndef OPENSSL_NO_ENGINE
  80     /* Free our "structural" reference. */
  81     ENGINE_free(e);
  82 #endif
  83 }
  84
  85 int init_engine(ENGINE *e)
  86 {
  87     int rv = 1;
  88
  89 #ifndef OPENSSL_NO_ENGINE
  90     rv = ENGINE_init(e);
  91 #endif
  92     return rv;
  93 }
  94
  95 int finish_engine(ENGINE *e)
  96 {
  97     int rv = 1;
  98
  99 #ifndef OPENSSL_NO_ENGINE
 100     rv = ENGINE_finish(e);
 101 #endif
 102     return rv;
 103 }
 104
 105 char *make_engine_uri(ENGINE *e, const char *key_id, const char *desc)
 106 {
 107     char *new_uri = NULL;
 108
 109 #ifndef OPENSSL_NO_ENGINE
 110     if (e == NULL) {
 111         BIO_printf(bio_err, "No engine specified for loading %s\n", desc);
 112     } else if (key_id == NULL) {
 113         BIO_printf(bio_err, "No engine key id specified for loading %s\n", desc);
 114     } else {
 115         const char *engineid = ENGINE_get_id(e);
 116         size_t uri_sz =
 117             sizeof(ENGINE_SCHEME_COLON) - 1
 118             + strlen(engineid)
 119             + 1 /* : */
 120             + strlen(key_id)
 121             + 1 /* \0 */
 122             ;
 123
 124         new_uri = OPENSSL_malloc(uri_sz);
 125         if (new_uri != NULL) {
 126             OPENSSL_strlcpy(new_uri, ENGINE_SCHEME_COLON, uri_sz);
 127             OPENSSL_strlcat(new_uri, engineid, uri_sz);
 128             OPENSSL_strlcat(new_uri, ":", uri_sz);
 129             OPENSSL_strlcat(new_uri, key_id, uri_sz);
 130         }
 131     }
 132 #else
 133     BIO_printf(bio_err, "Engines not supported for loading %s\n", desc);
 134 #endif
 135     return new_uri;
 136 }
 137
 138 int get_legacy_pkey_id(OSSL_LIB_CTX *libctx, const char *algname, ENGINE *e)
 139 {
 140     const EVP_PKEY_ASN1_METHOD *ameth;
 141     ENGINE *tmpeng = NULL;
 142     int pkey_id = NID_undef;
 143
 144     ERR_set_mark();
 145     ameth = EVP_PKEY_asn1_find_str(&tmpeng, algname, -1);
 146
 147 #if !defined(OPENSSL_NO_ENGINE)
 148     ENGINE_finish(tmpeng);
 149
 150     if (ameth == NULL && e != NULL)
 151         ameth = ENGINE_get_pkey_asn1_meth_str(e, algname, -1);
 152     else
 153 #endif
 154     /* We're only interested if it comes from an ENGINE */
 155     if (tmpeng == NULL)
 156         ameth = NULL;
 157
 158     ERR_pop_to_mark();
 159     if (ameth == NULL)
 160         return NID_undef;
 161
 162     EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth);
 163
 164     return pkey_id;
 165 }
 166
 167 const EVP_MD *get_digest_from_engine(const char *name)
 168 {
 169 #ifndef OPENSSL_NO_ENGINE
 170     ENGINE *eng;
 171
 172     eng = ENGINE_get_digest_engine(OBJ_sn2nid(name));
 173     if (eng != NULL) {
 174         ENGINE_finish(eng);
 175         return EVP_get_digestbyname(name);
 176     }
 177 #endif
 178     return NULL;
 179 }
 180
 181 const EVP_CIPHER *get_cipher_from_engine(const char *name)
 182 {
 183 #ifndef OPENSSL_NO_ENGINE
 184     ENGINE *eng;
 185
 186     eng = ENGINE_get_cipher_engine(OBJ_sn2nid(name));
 187     if (eng != NULL) {
 188         ENGINE_finish(eng);
 189         return EVP_get_cipherbyname(name);
 190     }
 191 #endif
 192     return NULL;
 193 }