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         case OSSL_FUNC_KEYMGMT_VALIDATE_DOMPARAMS:
 148             if (keymgmt->validatedomparams != NULL)
 149                 break;
 150             keymgmt->validatedomparams =
 151                 OSSL_get_OP_keymgmt_validate_domparams(fns);
 152             break;
 153         case OSSL_FUNC_KEYMGMT_VALIDATE_PUBLIC:
 154             if (keymgmt->validatepublic != NULL)
 155                 break;
 156             keymgmt->validatepublic =
 157                 OSSL_get_OP_keymgmt_validate_public(fns);
 158             break;
 159         case OSSL_FUNC_KEYMGMT_VALIDATE_PRIVATE:
 160             if (keymgmt->validateprivate != NULL)
 161                 break;
 162             keymgmt->validateprivate =
 163                 OSSL_get_OP_keymgmt_validate_private(fns);
 164             break;
 165         case OSSL_FUNC_KEYMGMT_VALIDATE_PAIRWISE:
 166             if (keymgmt->validatepairwise != NULL)
 167                 break;
 168             keymgmt->validatepairwise =
 169                 OSSL_get_OP_keymgmt_validate_pairwise(fns);
 170             break;
 171         }
 172     }
 173     /*
 174      * Try to check that the method is sensible.
 175      * It makes no sense being able to free stuff if you can't create it.
 176      * It makes no sense providing OSSL_PARAM descriptors for import and
 177      * export if you can't import or export.
 178      */
 179     if ((keymgmt->freedomparams != NULL
 180          && (keymgmt->importdomparams == NULL
 181              && keymgmt->gendomparams == NULL))
 182         || (keymgmt->freekey != NULL
 183             && (keymgmt->importkey == NULL
 184                 && keymgmt->genkey == NULL
 185                 && keymgmt->loadkey == NULL))
 186         || (keymgmt->importdomparam_types != NULL
 187             && keymgmt->importdomparams == NULL)
 188         || (keymgmt->exportdomparam_types != NULL
 189             && keymgmt->exportdomparams == NULL)
 190         || (keymgmt->gettable_domparam_params != NULL
 191             && keymgmt->get_domparam_params == NULL)
 192         || (keymgmt->importkey_types != NULL
 193             && keymgmt->importkey == NULL)
 194         || (keymgmt->exportkey_types != NULL
 195             && keymgmt->exportkey == NULL)
 196         || (keymgmt->gettable_key_params != NULL
 197             && keymgmt->get_key_params == NULL)) {
 198         EVP_KEYMGMT_free(keymgmt);
 199         EVPerr(0, EVP_R_INVALID_PROVIDER_FUNCTIONS);
 200         return NULL;
 201     }
 202     keymgmt->prov = prov;
 203     if (prov != NULL)
 204         ossl_provider_up_ref(prov);
 205
 206     return keymgmt;
 207 }
 208
 209 EVP_KEYMGMT *evp_keymgmt_fetch_by_number(OPENSSL_CTX *ctx, int name_id,
 210                                          const char *properties)
 211 {
 212     return evp_generic_fetch_by_number(ctx,
 213                                        OSSL_OP_KEYMGMT, name_id, properties,
 214                                        keymgmt_from_dispatch,
 215                                        (int (*)(void *))EVP_KEYMGMT_up_ref,
 216                                        (void (*)(void *))EVP_KEYMGMT_free);
 217 }
 218
 219 EVP_KEYMGMT *EVP_KEYMGMT_fetch(OPENSSL_CTX *ctx, const char *algorithm,
 220                                const char *properties)
 221 {
 222     return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
 223                              keymgmt_from_dispatch,
 224                              (int (*)(void *))EVP_KEYMGMT_up_ref,
 225                              (void (*)(void *))EVP_KEYMGMT_free);
 226 }
 227
 228 int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
 229 {
 230     int ref = 0;
 231
 232     CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
 233     return 1;
 234 }
 235
 236 void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
 237 {
 238     int ref = 0;
 239
 240     if (keymgmt == NULL)
 241         return;
 242
 243     CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
 244     if (ref > 0)
 245         return;
 246     ossl_provider_free(keymgmt->prov);
 247     CRYPTO_THREAD_lock_free(keymgmt->lock);
 248     OPENSSL_free(keymgmt);
 249 }
 250
 251 const OSSL_PROVIDER *EVP_KEYMGMT_provider(const EVP_KEYMGMT *keymgmt)
 252 {
 253     return keymgmt->prov;
 254 }
 255
 256 int EVP_KEYMGMT_number(const EVP_KEYMGMT *keymgmt)
 257 {
 258     return keymgmt->name_id;
 259 }
 260
 261 int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name)
 262 {
 263     return evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
 264 }
 265
 266 void EVP_KEYMGMT_do_all_provided(OPENSSL_CTX *libctx,
 267                                  void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
 268                                  void *arg)
 269 {
 270     evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
 271                        (void (*)(void *, void *))fn, arg,
 272                        keymgmt_from_dispatch,
 273                        (void (*)(void *))EVP_KEYMGMT_free);
 274 }
 275
 276 void EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
 277                               void (*fn)(const char *name, void *data),
 278                               void *data)
 279 {
 280     if (keymgmt->prov != NULL)
 281         evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
 282 }