crypto/evp/keymgmt_meth.c

   1 /*
   2  * Copyright 2019-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 #include <openssl/crypto.h>
  11 #include <openssl/core_dispatch.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     int setparamfncnt = 0, getparamfncnt = 0;
  42     int setgenparamfncnt = 0;
  43     int importfncnt = 0, exportfncnt = 0;
  44
  45     if ((keymgmt = keymgmt_new()) == NULL) {
  46         EVP_KEYMGMT_free(keymgmt);
  47         return NULL;
  48     }
  49     keymgmt->name_id = name_id;
  50
  51     for (; fns->function_id != 0; fns++) {
  52         switch (fns->function_id) {
  53         case OSSL_FUNC_KEYMGMT_NEW:
  54             if (keymgmt->new == NULL)
  55                 keymgmt->new = OSSL_FUNC_keymgmt_new(fns);
  56             break;
  57         case OSSL_FUNC_KEYMGMT_GEN_INIT:
  58             if (keymgmt->gen_init == NULL)
  59                 keymgmt->gen_init = OSSL_FUNC_keymgmt_gen_init(fns);
  60             break;
  61         case OSSL_FUNC_KEYMGMT_GEN_SET_TEMPLATE:
  62             if (keymgmt->gen_set_template == NULL)
  63                 keymgmt->gen_set_template =
  64                     OSSL_FUNC_keymgmt_gen_set_template(fns);
  65             break;
  66         case OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS:
  67             if (keymgmt->gen_set_params == NULL) {
  68                 setgenparamfncnt++;
  69                 keymgmt->gen_set_params =
  70                     OSSL_FUNC_keymgmt_gen_set_params(fns);
  71             }
  72             break;
  73         case OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS:
  74             if (keymgmt->gen_settable_params == NULL) {
  75                 setgenparamfncnt++;
  76                 keymgmt->gen_settable_params =
  77                     OSSL_FUNC_keymgmt_gen_settable_params(fns);
  78             }
  79             break;
  80         case OSSL_FUNC_KEYMGMT_GEN:
  81             if (keymgmt->gen == NULL)
  82                 keymgmt->gen = OSSL_FUNC_keymgmt_gen(fns);
  83             break;
  84         case OSSL_FUNC_KEYMGMT_GEN_CLEANUP:
  85             if (keymgmt->gen_cleanup == NULL)
  86                 keymgmt->gen_cleanup = OSSL_FUNC_keymgmt_gen_cleanup(fns);
  87             break;
  88         case OSSL_FUNC_KEYMGMT_FREE:
  89             if (keymgmt->free == NULL)
  90                 keymgmt->free = OSSL_FUNC_keymgmt_free(fns);
  91             break;
  92         case OSSL_FUNC_KEYMGMT_LOAD:
  93             if (keymgmt->load == NULL)
  94                 keymgmt->load = OSSL_FUNC_keymgmt_load(fns);
  95             break;
  96         case OSSL_FUNC_KEYMGMT_GET_PARAMS:
  97             if (keymgmt->get_params == NULL) {
  98                 getparamfncnt++;
  99                 keymgmt->get_params = OSSL_FUNC_keymgmt_get_params(fns);
 100             }
 101             break;
 102         case OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS:
 103             if (keymgmt->gettable_params == NULL) {
 104                 getparamfncnt++;
 105                 keymgmt->gettable_params =
 106                     OSSL_FUNC_keymgmt_gettable_params(fns);
 107             }
 108             break;
 109          case OSSL_FUNC_KEYMGMT_SET_PARAMS:
 110             if (keymgmt->set_params == NULL) {
 111                 setparamfncnt++;
 112                 keymgmt->set_params = OSSL_FUNC_keymgmt_set_params(fns);
 113             }
 114             break;
 115         case OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS:
 116             if (keymgmt->settable_params == NULL) {
 117                 setparamfncnt++;
 118                 keymgmt->settable_params =
 119                     OSSL_FUNC_keymgmt_settable_params(fns);
 120             }
 121             break;
 122         case OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME:
 123             if (keymgmt->query_operation_name == NULL)
 124                 keymgmt->query_operation_name =
 125                     OSSL_FUNC_keymgmt_query_operation_name(fns);
 126             break;
 127         case OSSL_FUNC_KEYMGMT_HAS:
 128             if (keymgmt->has == NULL)
 129                 keymgmt->has = OSSL_FUNC_keymgmt_has(fns);
 130             break;
 131         case OSSL_FUNC_KEYMGMT_COPY:
 132             if (keymgmt->copy == NULL)
 133                 keymgmt->copy = OSSL_FUNC_keymgmt_copy(fns);
 134             break;
 135         case OSSL_FUNC_KEYMGMT_VALIDATE:
 136             if (keymgmt->validate == NULL)
 137                 keymgmt->validate = OSSL_FUNC_keymgmt_validate(fns);
 138             break;
 139         case OSSL_FUNC_KEYMGMT_MATCH:
 140             if (keymgmt->match == NULL)
 141                 keymgmt->match = OSSL_FUNC_keymgmt_match(fns);
 142             break;
 143         case OSSL_FUNC_KEYMGMT_IMPORT:
 144             if (keymgmt->import == NULL) {
 145                 importfncnt++;
 146                 keymgmt->import = OSSL_FUNC_keymgmt_import(fns);
 147             }
 148             break;
 149         case OSSL_FUNC_KEYMGMT_IMPORT_TYPES:
 150             if (keymgmt->import_types == NULL) {
 151                 importfncnt++;
 152                 keymgmt->import_types = OSSL_FUNC_keymgmt_import_types(fns);
 153             }
 154             break;
 155         case OSSL_FUNC_KEYMGMT_EXPORT:
 156             if (keymgmt->export == NULL) {
 157                 exportfncnt++;
 158                 keymgmt->export = OSSL_FUNC_keymgmt_export(fns);
 159             }
 160             break;
 161         case OSSL_FUNC_KEYMGMT_EXPORT_TYPES:
 162             if (keymgmt->export_types == NULL) {
 163                 exportfncnt++;
 164                 keymgmt->export_types = OSSL_FUNC_keymgmt_export_types(fns);
 165             }
 166             break;
 167         }
 168     }
 169     /*
 170      * Try to check that the method is sensible.
 171      * At least one constructor and the destructor are MANDATORY
 172      * The functions 'has' is MANDATORY
 173      * It makes no sense being able to free stuff if you can't create it.
 174      * It makes no sense providing OSSL_PARAM descriptors for import and
 175      * export if you can't import or export.
 176      */
 177     if (keymgmt->free == NULL
 178         || (keymgmt->new == NULL
 179             && keymgmt->gen == NULL
 180             && keymgmt->load == NULL)
 181         || keymgmt->has == NULL
 182         || (getparamfncnt != 0 && getparamfncnt != 2)
 183         || (setparamfncnt != 0 && setparamfncnt != 2)
 184         || (setgenparamfncnt != 0 && setgenparamfncnt != 2)
 185         || (importfncnt != 0 && importfncnt != 2)
 186         || (exportfncnt != 0 && exportfncnt != 2)
 187         || (keymgmt->gen != NULL
 188             && (keymgmt->gen_init == NULL
 189                 || keymgmt->gen_cleanup == NULL))) {
 190         EVP_KEYMGMT_free(keymgmt);
 191         EVPerr(0, EVP_R_INVALID_PROVIDER_FUNCTIONS);
 192         return NULL;
 193     }
 194     keymgmt->prov = prov;
 195     if (prov != NULL)
 196         ossl_provider_up_ref(prov);
 197
 198     return keymgmt;
 199 }
 200
 201 EVP_KEYMGMT *evp_keymgmt_fetch_by_number(OPENSSL_CTX *ctx, int name_id,
 202                                          const char *properties)
 203 {
 204     return evp_generic_fetch_by_number(ctx,
 205                                        OSSL_OP_KEYMGMT, name_id, properties,
 206                                        keymgmt_from_dispatch,
 207                                        (int (*)(void *))EVP_KEYMGMT_up_ref,
 208                                        (void (*)(void *))EVP_KEYMGMT_free);
 209 }
 210
 211 EVP_KEYMGMT *EVP_KEYMGMT_fetch(OPENSSL_CTX *ctx, const char *algorithm,
 212                                const char *properties)
 213 {
 214     return evp_generic_fetch(ctx, OSSL_OP_KEYMGMT, algorithm, properties,
 215                              keymgmt_from_dispatch,
 216                              (int (*)(void *))EVP_KEYMGMT_up_ref,
 217                              (void (*)(void *))EVP_KEYMGMT_free);
 218 }
 219
 220 int EVP_KEYMGMT_up_ref(EVP_KEYMGMT *keymgmt)
 221 {
 222     int ref = 0;
 223
 224     CRYPTO_UP_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
 225     return 1;
 226 }
 227
 228 void EVP_KEYMGMT_free(EVP_KEYMGMT *keymgmt)
 229 {
 230     int ref = 0;
 231
 232     if (keymgmt == NULL)
 233         return;
 234
 235     CRYPTO_DOWN_REF(&keymgmt->refcnt, &ref, keymgmt->lock);
 236     if (ref > 0)
 237         return;
 238     ossl_provider_free(keymgmt->prov);
 239     CRYPTO_THREAD_lock_free(keymgmt->lock);
 240     OPENSSL_free(keymgmt);
 241 }
 242
 243 const OSSL_PROVIDER *EVP_KEYMGMT_provider(const EVP_KEYMGMT *keymgmt)
 244 {
 245     return keymgmt->prov;
 246 }
 247
 248 int EVP_KEYMGMT_number(const EVP_KEYMGMT *keymgmt)
 249 {
 250     return keymgmt->name_id;
 251 }
 252
 253 int EVP_KEYMGMT_is_a(const EVP_KEYMGMT *keymgmt, const char *name)
 254 {
 255     return evp_is_a(keymgmt->prov, keymgmt->name_id, NULL, name);
 256 }
 257
 258 void EVP_KEYMGMT_do_all_provided(OPENSSL_CTX *libctx,
 259                                  void (*fn)(EVP_KEYMGMT *keymgmt, void *arg),
 260                                  void *arg)
 261 {
 262     evp_generic_do_all(libctx, OSSL_OP_KEYMGMT,
 263                        (void (*)(void *, void *))fn, arg,
 264                        keymgmt_from_dispatch,
 265                        (void (*)(void *))EVP_KEYMGMT_free);
 266 }
 267
 268 void EVP_KEYMGMT_names_do_all(const EVP_KEYMGMT *keymgmt,
 269                               void (*fn)(const char *name, void *data),
 270                               void *data)
 271 {
 272     if (keymgmt->prov != NULL)
 273         evp_names_do_all(keymgmt->prov, keymgmt->name_id, fn, data);
 274 }
 275
 276 /*
 277  * Internal API that interfaces with the method function pointers
 278  */
 279 void *evp_keymgmt_newdata(const EVP_KEYMGMT *keymgmt)
 280 {
 281     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 282
 283     /*
 284      * TODO(3.0) 'new' is currently mandatory on its own, but when new
 285      * constructors appear, it won't be quite as mandatory, so we have
 286      * a check for future cases.
 287      */
 288     if (keymgmt->new == NULL)
 289         return NULL;
 290     return keymgmt->new(provctx);
 291 }
 292
 293 void evp_keymgmt_freedata(const EVP_KEYMGMT *keymgmt, void *keydata)
 294 {
 295     /* This is mandatory, no need to check for its presence */
 296     keymgmt->free(keydata);
 297 }
 298
 299 void *evp_keymgmt_gen_init(const EVP_KEYMGMT *keymgmt, int selection)
 300 {
 301     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 302
 303     if (keymgmt->gen_init == NULL)
 304         return NULL;
 305     return keymgmt->gen_init(provctx, selection);
 306 }
 307
 308 int evp_keymgmt_gen_set_template(const EVP_KEYMGMT *keymgmt, void *genctx,
 309                                  void *template)
 310 {
 311     /*
 312      * It's arguable if we actually should return success in this case, as
 313      * it allows the caller to set a template key, which is then ignored.
 314      * However, this is how the legacy methods (EVP_PKEY_METHOD) operate,
 315      * so we do this in the interest of backward compatibility.
 316      * TODO(3.0) Investigate if we should change this behaviour.
 317      */
 318     if (keymgmt->gen_set_template == NULL)
 319         return 1;
 320     return keymgmt->gen_set_template(genctx, template);
 321 }
 322
 323 int evp_keymgmt_gen_set_params(const EVP_KEYMGMT *keymgmt, void *genctx,
 324                                const OSSL_PARAM params[])
 325 {
 326     if (keymgmt->gen_set_params == NULL)
 327         return 0;
 328     return keymgmt->gen_set_params(genctx, params);
 329 }
 330
 331 const OSSL_PARAM *evp_keymgmt_gen_settable_params(const EVP_KEYMGMT *keymgmt)
 332 {
 333     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 334
 335     if (keymgmt->gen_settable_params == NULL)
 336         return NULL;
 337     return keymgmt->gen_settable_params(provctx);
 338 }
 339
 340 void *evp_keymgmt_gen(const EVP_KEYMGMT *keymgmt, void *genctx,
 341                       OSSL_CALLBACK *cb, void *cbarg)
 342 {
 343     if (keymgmt->gen == NULL)
 344         return NULL;
 345     return keymgmt->gen(genctx, cb, cbarg);
 346 }
 347
 348 void evp_keymgmt_gen_cleanup(const EVP_KEYMGMT *keymgmt, void *genctx)
 349 {
 350     if (keymgmt->gen != NULL)
 351         keymgmt->gen_cleanup(genctx);
 352 }
 353
 354 void *evp_keymgmt_load(const EVP_KEYMGMT *keymgmt,
 355                        const void *objref, size_t objref_sz)
 356 {
 357     if (keymgmt->load != NULL)
 358         return keymgmt->load(objref, objref_sz);
 359     return NULL;
 360 }
 361
 362 int evp_keymgmt_get_params(const EVP_KEYMGMT *keymgmt, void *keydata,
 363                            OSSL_PARAM params[])
 364 {
 365     if (keymgmt->get_params == NULL)
 366         return 1;
 367     return keymgmt->get_params(keydata, params);
 368 }
 369
 370 const OSSL_PARAM *evp_keymgmt_gettable_params(const EVP_KEYMGMT *keymgmt)
 371 {
 372     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 373
 374     if (keymgmt->gettable_params == NULL)
 375         return NULL;
 376     return keymgmt->gettable_params(provctx);
 377 }
 378
 379 int evp_keymgmt_set_params(const EVP_KEYMGMT *keymgmt, void *keydata,
 380                            const OSSL_PARAM params[])
 381 {
 382     if (keymgmt->set_params == NULL)
 383         return 1;
 384     return keymgmt->set_params(keydata, params);
 385 }
 386
 387 const OSSL_PARAM *evp_keymgmt_settable_params(const EVP_KEYMGMT *keymgmt)
 388 {
 389     void *provctx = ossl_provider_ctx(EVP_KEYMGMT_provider(keymgmt));
 390
 391     if (keymgmt->settable_params == NULL)
 392         return NULL;
 393     return keymgmt->settable_params(provctx);
 394 }
 395
 396 int evp_keymgmt_has(const EVP_KEYMGMT *keymgmt, void *keydata, int selection)
 397 {
 398     /* This is mandatory, no need to check for its presence */
 399     return keymgmt->has(keydata, selection);
 400 }
 401
 402 int evp_keymgmt_validate(const EVP_KEYMGMT *keymgmt, void *keydata,
 403                          int selection)
 404 {
 405     /* We assume valid if the implementation doesn't have a function */
 406     if (keymgmt->validate == NULL)
 407         return 1;
 408     return keymgmt->validate(keydata, selection);
 409 }
 410
 411 int evp_keymgmt_match(const EVP_KEYMGMT *keymgmt,
 412                       const void *keydata1, const void *keydata2,
 413                       int selection)
 414 {
 415     /* We assume no match if the implementation doesn't have a function */
 416     if (keymgmt->match == NULL)
 417         return 0;
 418     return keymgmt->match(keydata1, keydata2, selection);
 419 }
 420
 421 int evp_keymgmt_import(const EVP_KEYMGMT *keymgmt, void *keydata,
 422                        int selection, const OSSL_PARAM params[])
 423 {
 424     if (keymgmt->import == NULL)
 425         return 0;
 426     return keymgmt->import(keydata, selection, params);
 427 }
 428
 429 const OSSL_PARAM *evp_keymgmt_import_types(const EVP_KEYMGMT *keymgmt,
 430                                            int selection)
 431 {
 432     if (keymgmt->import_types == NULL)
 433         return NULL;
 434     return keymgmt->import_types(selection);
 435 }
 436
 437 int evp_keymgmt_export(const EVP_KEYMGMT *keymgmt, void *keydata,
 438                        int selection, OSSL_CALLBACK *param_cb, void *cbarg)
 439 {
 440     if (keymgmt->export == NULL)
 441         return 0;
 442     return keymgmt->export(keydata, selection, param_cb, cbarg);
 443 }
 444
 445 const OSSL_PARAM *evp_keymgmt_export_types(const EVP_KEYMGMT *keymgmt,
 446                                            int selection)
 447 {
 448     if (keymgmt->export_types == NULL)
 449         return NULL;
 450     return keymgmt->export_types(selection);
 451 }
 452
 453 int evp_keymgmt_copy(const EVP_KEYMGMT *keymgmt,
 454                      void *keydata_to, const void *keydata_from,
 455                      int selection)
 456 {
 457     /* We assume no copy if the implementation doesn't have a function */
 458     if (keymgmt->copy == NULL)
 459         return 0;
 460     return keymgmt->copy(keydata_to, keydata_from, selection);
 461 }