crypto/evp/keymgmt_meth.c

   1 /*
   2  * Copyright 2019 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 #include <openssl/crypto.h>
  11 #include <openssl/core_numbers.h>
  12 #include <openssl/evp.h>
  13 #include <openssl/err.h>
  14 #include "internal/provider.h"
  15 #include "internal/refcount.h"
  16 #include "crypto/evp.h"
  17 #include "evp_local.h"
  18
  19
  20 static void *keymgmt_new(void)
  21 {
  22     EVP_KEYMGMT *keymgmt = NULL;
  23
  24     if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL
  25         || (keymgmt->lock = CRYPTO_THREAD_lock_new()) == NULL) {
  26         EVP_KEYMGMT_free(keymgmt);
  27         EVPerr(0, ERR_R_MALLOC_FAILURE);
  28         return NULL;
  29     }
  30
  31     keymgmt->refcnt = 1;
  32
  33     return keymgmt;
  34 }
  35
  36 static void *keymgmt_from_dispatch(int name_id,
  37                                    const OSSL_DISPATCH *fns,
  38                                    OSSL_PROVIDER *prov)
  39 {
  40     EVP_KEYMGMT *keymgmt = NULL;
  41
  42     if ((keymgmt = keymgmt_new()) == NULL) {
  43         EVP_KEYMGMT_free(keymgmt);
  44         return NULL;
  45     }
  46     keymgmt->name_id = name_id;
  47
  48     for (; fns->function_id != 0; fns++) {
  49         switch (fns->function_id) {
  50         case OSSL_FUNC_KEYMGMT_IMPORTDOMPARAMS:
  51             if (keymgmt->importdomparams != NULL)
  52                 break;
  53             keymgmt->importdomparams =
  54                 OSSL_get_OP_keymgmt_importdomparams(fns);
  55             break;
  56         case OSSL_FUNC_KEYMGMT_GENDOMPARAMS:
  57             if (keymgmt->gendomparams != NULL)
  58                 break;
  59             keymgmt->gendomparams = OSSL_get_OP_keymgmt_gendomparams(fns);
  60             break;
  61         case OSSL_FUNC_KEYMGMT_FREEDOMPARAMS:
  62             if (keymgmt->freedomparams != NULL)
  63                 break;
  64             keymgmt->freedomparams = OSSL_get_OP_keymgmt_freedomparams(fns);
  65             break;
  66         case OSSL_FUNC_KEYMGMT_EXPORTDOMPARAMS:
  67             if (keymgmt->exportdomparams != NULL)
  68                 break;
  69             keymgmt->exportdomparams =
  70                 OSSL_get_OP_keymgmt_exportdomparams(fns);
  71             break;
  72         case OSSL_FUNC_KEYMGMT_IMPORTDOMPARAM_TYPES:
  73             if (keymgmt->importdomparam_types != NULL)
  74                 break;
  75             keymgmt->importdomparam_types =
  76                 OSSL_get_OP_keymgmt_importdomparam_types(fns);
  77             break;
  78         case OSSL_FUNC_KEYMGMT_EXPORTDOMPARAM_TYPES:
  79             if (keymgmt->exportdomparam_types != NULL)
  80                 break;
  81             keymgmt->exportdomparam_types =
  82                 OSSL_get_OP_keymgmt_exportdomparam_types(fns);
  83             break;
  84         case OSSL_FUNC_KEYMGMT_GET_DOMPARAM_PARAMS:
  85             if (keymgmt->get_domparam_params == NULL)
  86                 keymgmt->get_domparam_params =
  87                     OSSL_get_OP_keymgmt_get_domparam_params(fns);
  88             break;
  89         case OSSL_FUNC_KEYMGMT_GETTABLE_DOMPARAM_PARAMS:
  90             if (keymgmt->gettable_domparam_params == NULL)
  91                 keymgmt->gettable_domparam_params =
  92                     OSSL_get_OP_keymgmt_gettable_domparam_params(fns);
  93             break;
  94         case OSSL_FUNC_KEYMGMT_IMPORTKEY:
  95             if (keymgmt->importkey != NULL)
  96                 break;
  97             keymgmt->importkey = OSSL_get_OP_keymgmt_importkey(fns);
  98             break;
  99         case OSSL_FUNC_KEYMGMT_GENKEY:
 100             if (keymgmt->genkey != NULL)
 101                 break;
 102             keymgmt->genkey = OSSL_get_OP_keymgmt_genkey(fns);
 103             break;
 104         case OSSL_FUNC_KEYMGMT_LOADKEY:
 105             if (keymgmt->loadkey != NULL)
 106                 break;
 107             keymgmt->loadkey = OSSL_get_OP_keymgmt_loadkey(fns);
 108             break;
 109         case OSSL_FUNC_KEYMGMT_FREEKEY:
 110             if (keymgmt->freekey != NULL)
 111                 break;
 112             keymgmt->freekey = OSSL_get_OP_keymgmt_freekey(fns);
 113             break;
 114         case OSSL_FUNC_KEYMGMT_EXPORTKEY:
 115             if (keymgmt->exportkey != NULL)
 116                 break;
 117             keymgmt->exportkey = OSSL_get_OP_keymgmt_exportkey(fns);
 118             break;
 119         case OSSL_FUNC_KEYMGMT_IMPORTKEY_TYPES:
 120             if (keymgmt->importkey_types != NULL)
 121                 break;
 122             keymgmt->importkey_types =
 123                 OSSL_get_OP_keymgmt_importkey_types(fns);
 124             break;
 125         case OSSL_FUNC_KEYMGMT_EXPORTKEY_TYPES:
 126             if (keymgmt->exportkey_types != NULL)
 127                 break;
 128             keymgmt->exportkey_types =
 129                 OSSL_get_OP_keymgmt_exportkey_types(fns);
 130             break;
 131         case OSSL_FUNC_KEYMGMT_GET_KEY_PARAMS:
 132             if (keymgmt->get_key_params == NULL)
 133                 keymgmt->get_key_params =
 134                     OSSL_get_OP_keymgmt_get_key_params(fns);
 135             break;
 136         case OSSL_FUNC_KEYMGMT_GETTABLE_KEY_PARAMS:
 137             if (keymgmt->gettable_key_params == NULL)
 138                 keymgmt->gettable_key_params =
 139                     OSSL_get_OP_keymgmt_gettable_key_params(fns);
 140             break;
 141         case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
 142             if (keymgmt->query_operation_name != NULL)
 143                 break;
 144             keymgmt->query_operation_name =
 145                 OSSL_get_OP_keymgmt_query_operation_name(fns);
 146             break;
 147         }
 148     }
 149     /*
 150      * Try to check that the method is sensible.
 151      * It makes no sense being able to free stuff if you can't create it.
 152      * It makes no sense providing OSSL_PARAM descriptors for import and
 153      * export if you can't import or export.
 154      */
 155     if ((keymgmt->freedomparams != NULL
 156          && (keymgmt->importdomparams == NULL
 157              && keymgmt->gendomparams == NULL))
 158         || (keymgmt->freekey != NULL
 159             && (keymgmt->importkey == NULL
 160                 && keymgmt->genkey == NULL
 161                 && keymgmt->loadkey == NULL))
 162         || (keymgmt->importdomparam_types != NULL
 163             && keymgmt->importdomparams == NULL)
 164         || (keymgmt->exportdomparam_types != NULL
 165             && keymgmt->exportdomparams == NULL)
 166         || (keymgmt->gettable_domparam_params != NULL
 167             && keymgmt->get_domparam_params == NULL)
 168         || (keymgmt->importkey_types != NULL
 169             && keymgmt->importkey == NULL)
 170         || (keymgmt->exportkey_types != NULL
 171             && keymgmt->exportkey == NULL)
 172         || (keymgmt->gettable_key_params != NULL
 173             && keymgmt->get_key_params == NULL)) {
 174         EVP_KEYMGMT_free(keymgmt);
 175         EVPerr(0, EVP_R_INVALID_PROVIDER_FUNCTIONS);
 176         return NULL;
 177     }
 178     keymgmt->prov = prov;
 179     if (prov != NULL)
 180         ossl_provider_up_ref(prov);
 181
 182     return keymgmt;
 183 }
 184
 185 EVP_KEYMGMT *evp_keymgmt_fetch_by_number(OPENSSL_CTX *ctx, int name_id,
 186                                          const char *properties)
 187 {
 188     return evp_generic_fetch_by_number(ctx,
 189                                        OSSL_OP_KEYMGMT, name_id, properties,
 190                                        keymgmt_from_dispatch,
 191                                        (int (*)(void *))EVP_KEYMGMT_up_ref,
 192                                        (void (*)(void *))EVP_KEYMGMT_free);
 193 }
 194
 195 EVP_KEYMGMT *EVP_KEYMGMT_fetch(OPENSSL_CTX *ctx, const char *algorithm,
 196                                const char *properties)
 197 {
 198     return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
 199                              keymgmt_from_dispatch,
 200                              (int (*)(void *))EVP_KEYMGMT_up_ref,
 201                              (void (*)(void *))EVP_KEYMGMT_free);
 202 }
 203
 204 int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
 205 {
 206     int ref = 0;
 207
 208     CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
 209     return 1;
 210 }
 211
 212 void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
 213 {
 214     int ref = 0;
 215
 216     if (keymgmt == NULL)
 217         return;
 218
 219     CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
 220     if (ref > 0)
 221         return;
 222     ossl_provider_free(keymgmt->prov);
 223     CRYPTO_THREAD_lock_free(keymgmt->lock);
 224     OPENSSL_free(keymgmt);
 225 }
 226
 227 const OSSL_PROVIDER *EVP_KEYMGMT_provider(const EVP_KEYMGMT *keymgmt)
 228 {
 229     return keymgmt->prov;
 230 }
 231
 232 int EVP_KEYMGMT_number(const EVP_KEYMGMT *keymgmt)
 233 {
 234     return keymgmt->name_id;
 235 }
 236
 237 int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name)
 238 {
 239     return evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
 240 }
 241
 242 void EVP_KEYMGMT_do_all_provided(OPENSSL_CTX *libctx,
 243                                  void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
 244                                  void *arg)
 245 {
 246     evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
 247                        (void (*)(void *, void *))fn, arg,
 248                        keymgmt_from_dispatch,
 249                        (void (*)(void *))EVP_KEYMGMT_free);
 250 }
 251
 252 void EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
 253                               void (*fn)(const char *name, void *data),
 254                               void *data)
 255 {
 256     if (keymgmt->prov != NULL)
 257         evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
 258 }