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 }
 283
 284 /*
 285  * Internal API that interfaces with the method function pointers
 286  */
 287 void *evp_keymgmt_importdomparams(const EVP_KEYMGMT *keymgmt,
 288                                   const OSSL_PARAM params[])
 289 {
 290     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 291
 292     return keymgmt->importdomparams(provctx, params);
 293 }
 294
 295 void *evp_keymgmt_gendomparams(const EVP_KEYMGMT *keymgmt,
 296                                const OSSL_PARAM params[])
 297 {
 298     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 299
 300     return keymgmt->gendomparams(provctx, params);
 301 }
 302
 303 void evp_keymgmt_freedomparams(const EVP_KEYMGMT *keymgmt,
 304                                void *provdomparams)
 305 {
 306     keymgmt->freedomparams(provdomparams);
 307 }
 308
 309 int evp_keymgmt_exportdomparams(const EVP_KEYMGMT *keymgmt,
 310                                 void *provdomparams,
 311                                 OSSL_CALLBACK *param_cb, void *cbarg)
 312 {
 313     return keymgmt->exportdomparams(provdomparams, param_cb, cbarg);
 314 }
 315
 316 const OSSL_PARAM *evp_keymgmt_importdomparam_types(const EVP_KEYMGMT *keymgmt)
 317 {
 318     return keymgmt->importdomparam_types();
 319 }
 320
 321 /*
 322  * TODO(v3.0) investigate if we need this function.  'openssl provider' may
 323  * be a caller...
 324  */
 325 const OSSL_PARAM *evp_keymgmt_exportdomparam_types(const EVP_KEYMGMT *keymgmt)
 326 {
 327     return keymgmt->exportdomparam_types();
 328 }
 329
 330 int evp_keymgmt_get_domparam_params(const EVP_KEYMGMT *keymgmt,
 331                                      void *provdomparams, OSSL_PARAM params[])
 332 {
 333     if (keymgmt->get_domparam_params == NULL)
 334         return 1;
 335     return keymgmt->get_domparam_params(provdomparams, params);
 336 }
 337
 338 const OSSL_PARAM *
 339 evp_keymgmt_gettable_domparam_params(const EVP_KEYMGMT *keymgmt)
 340 {
 341     if (keymgmt->gettable_domparam_params == NULL)
 342         return NULL;
 343     return keymgmt->gettable_domparam_params();
 344 }
 345
 346
 347 void *evp_keymgmt_importkey(const EVP_KEYMGMT *keymgmt,
 348                             const OSSL_PARAM params[])
 349 {
 350     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 351
 352     return keymgmt->importkey(provctx, params);
 353 }
 354
 355 void *evp_keymgmt_genkey(const EVP_KEYMGMT *keymgmt, void *domparams,
 356                          const OSSL_PARAM params[])
 357 {
 358     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 359
 360     return keymgmt->genkey(provctx, domparams, params);
 361 }
 362
 363 void *evp_keymgmt_loadkey(const EVP_KEYMGMT *keymgmt,
 364                           void *id, size_t idlen)
 365 {
 366     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 367
 368     return keymgmt->loadkey(provctx, id, idlen);
 369 }
 370
 371 void evp_keymgmt_freekey(const EVP_KEYMGMT *keymgmt, void *provkey)
 372 {
 373     keymgmt->freekey(provkey);
 374 }
 375
 376 int evp_keymgmt_exportkey(const EVP_KEYMGMT *keymgmt, void *provkey,
 377                           OSSL_CALLBACK *param_cb, void *cbarg)
 378 {
 379     return keymgmt->exportkey(provkey, param_cb, cbarg);
 380 }
 381
 382 const OSSL_PARAM *evp_keymgmt_importkey_types(const EVP_KEYMGMT *keymgmt)
 383 {
 384     return keymgmt->importkey_types();
 385 }
 386
 387 /*
 388  * TODO(v3.0) investigate if we need this function.  'openssl provider' may
 389  * be a caller...
 390  */
 391 const OSSL_PARAM *evp_keymgmt_exportkey_types(const EVP_KEYMGMT *keymgmt)
 392 {
 393     return keymgmt->exportkey_types();
 394 }
 395
 396 int evp_keymgmt_get_key_params(const EVP_KEYMGMT *keymgmt,
 397                                void *provkey, OSSL_PARAM params[])
 398 {
 399     if (keymgmt->get_key_params == NULL)
 400         return 1;
 401     return keymgmt->get_key_params(provkey, params);
 402 }
 403
 404 const OSSL_PARAM *evp_keymgmt_gettable_key_params(const EVP_KEYMGMT *keymgmt)
 405 {
 406     if (keymgmt->gettable_key_params == NULL)
 407         return NULL;
 408     return keymgmt->gettable_key_params();
 409 }
 410
 411 int evp_keymgmt_validate_domparams(const EVP_KEYMGMT *keymgmt, void *provkey)
 412 {
 413     /* if domainparams are not supported - then pass */
 414     if (keymgmt->validatedomparams == NULL)
 415         return 1;
 416     return keymgmt->validatedomparams(provkey);
 417 }
 418
 419 int evp_keymgmt_validate_public(const EVP_KEYMGMT *keymgmt, void *provkey)
 420 {
 421     return keymgmt->validatepublic(provkey);
 422 }
 423
 424 int evp_keymgmt_validate_private(const EVP_KEYMGMT *keymgmt, void *provkey)
 425 {
 426     return keymgmt->validateprivate(provkey);
 427 }
 428
 429 int evp_keymgmt_validate_pairwise(const EVP_KEYMGMT *keymgmt, void *provkey)
 430 {
 431     return keymgmt->validatepairwise(provkey);
 432 }