crypto/openssl/crypto/engine/eng_pkey.c

   1 /* crypto/engine/eng_pkey.c */
   2 /* ====================================================================
   3  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * 3. All advertising materials mentioning features or use of this
  18  *    software must display the following acknowledgment:
  19  *    "This product includes software developed by the OpenSSL Project
  20  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  21  *
  22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  23  *    endorse or promote products derived from this software without
  24  *    prior written permission. For written permission, please contact
  25  *    licensing@OpenSSL.org.
  26  *
  27  * 5. Products derived from this software may not be called "OpenSSL"
  28  *    nor may "OpenSSL" appear in their names without prior written
  29  *    permission of the OpenSSL Project.
  30  *
  31  * 6. Redistributions of any form whatsoever must retain the following
  32  *    acknowledgment:
  33  *    "This product includes software developed by the OpenSSL Project
  34  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  47  * OF THE POSSIBILITY OF SUCH DAMAGE.
  48  * ====================================================================
  49  *
  50  * This product includes cryptographic software written by Eric Young
  51  * (eay@cryptsoft.com).  This product includes software written by Tim
  52  * Hudson (tjh@cryptsoft.com).
  53  *
  54  */
  55
  56 #include "eng_int.h"
  57
  58 /* Basic get/set stuff */
  59
  60 int ENGINE_set_load_privkey_function(ENGINE *e,
  61                                      ENGINE_LOAD_KEY_PTR loadpriv_f)
  62 {
  63     e->load_privkey = loadpriv_f;
  64     return 1;
  65 }
  66
  67 int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f)
  68 {
  69     e->load_pubkey = loadpub_f;
  70     return 1;
  71 }
  72
  73 int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
  74                                              ENGINE_SSL_CLIENT_CERT_PTR
  75                                              loadssl_f)
  76 {
  77     e->load_ssl_client_cert = loadssl_f;
  78     return 1;
  79 }
  80
  81 ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e)
  82 {
  83     return e->load_privkey;
  84 }
  85
  86 ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e)
  87 {
  88     return e->load_pubkey;
  89 }
  90
  91 ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE
  92                                                                *e)
  93 {
  94     return e->load_ssl_client_cert;
  95 }
  96
  97 /* API functions to load public/private keys */
  98
  99 EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
 100                                   UI_METHOD *ui_method, void *callback_data)
 101 {
 102     EVP_PKEY *pkey;
 103
 104     if (e == NULL) {
 105         ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
 106                   ERR_R_PASSED_NULL_PARAMETER);
 107         return 0;
 108     }
 109     CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 110     if (e->funct_ref == 0) {
 111         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 112         ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY, ENGINE_R_NOT_INITIALISED);
 113         return 0;
 114     }
 115     CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 116     if (!e->load_privkey) {
 117         ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
 118                   ENGINE_R_NO_LOAD_FUNCTION);
 119         return 0;
 120     }
 121     pkey = e->load_privkey(e, key_id, ui_method, callback_data);
 122     if (!pkey) {
 123         ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
 124                   ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
 125         return 0;
 126     }
 127     return pkey;
 128 }
 129
 130 EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
 131                                  UI_METHOD *ui_method, void *callback_data)
 132 {
 133     EVP_PKEY *pkey;
 134
 135     if (e == NULL) {
 136         ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
 137                   ERR_R_PASSED_NULL_PARAMETER);
 138         return 0;
 139     }
 140     CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 141     if (e->funct_ref == 0) {
 142         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 143         ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY, ENGINE_R_NOT_INITIALISED);
 144         return 0;
 145     }
 146     CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 147     if (!e->load_pubkey) {
 148         ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY, ENGINE_R_NO_LOAD_FUNCTION);
 149         return 0;
 150     }
 151     pkey = e->load_pubkey(e, key_id, ui_method, callback_data);
 152     if (!pkey) {
 153         ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
 154                   ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
 155         return 0;
 156     }
 157     return pkey;
 158 }
 159
 160 int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s,
 161                                 STACK_OF(X509_NAME) *ca_dn, X509 **pcert,
 162                                 EVP_PKEY **ppkey, STACK_OF(X509) **pother,
 163                                 UI_METHOD *ui_method, void *callback_data)
 164 {
 165
 166     if (e == NULL) {
 167         ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT,
 168                   ERR_R_PASSED_NULL_PARAMETER);
 169         return 0;
 170     }
 171     CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 172     if (e->funct_ref == 0) {
 173         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 174         ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT,
 175                   ENGINE_R_NOT_INITIALISED);
 176         return 0;
 177     }
 178     CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 179     if (!e->load_ssl_client_cert) {
 180         ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT,
 181                   ENGINE_R_NO_LOAD_FUNCTION);
 182         return 0;
 183     }
 184     return e->load_ssl_client_cert(e, s, ca_dn, pcert, ppkey, pother,
 185                                    ui_method, callback_data);
 186 }