crypto/evp/evp_fetch.c

   1 /*
   2  * Copyright 2019-2023 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 <stddef.h>
  11 #include <openssl/types.h>
  12 #include <openssl/evp.h>
  13 #include <openssl/core.h>
  14 #include "internal/cryptlib.h"
  15 #include "internal/thread_once.h"
  16 #include "internal/property.h"
  17 #include "internal/core.h"
  18 #include "internal/provider.h"
  19 #include "internal/namemap.h"
  20 #include "crypto/decoder.h"
  21 #include "crypto/evp.h"    /* evp_local.h needs it */
  22 #include "evp_local.h"
  23
  24 #define NAME_SEPARATOR ':'
  25
  26 /* Data to be passed through ossl_method_construct() */
  27 struct evp_method_data_st {
  28     OSSL_LIB_CTX *libctx;
  29     int operation_id;            /* For get_evp_method_from_store() */
  30     int name_id;                 /* For get_evp_method_from_store() */
  31     const char *names;           /* For get_evp_method_from_store() */
  32     const char *propquery;       /* For get_evp_method_from_store() */
  33
  34     OSSL_METHOD_STORE *tmp_store; /* For get_tmp_evp_method_store() */
  35
  36     unsigned int flag_construct_error_occurred : 1;
  37
  38     void *(*method_from_algorithm)(int name_id, const OSSL_ALGORITHM *,
  39                                    OSSL_PROVIDER *);
  40     int (*refcnt_up_method)(void *method);
  41     void (*destruct_method)(void *method);
  42 };
  43
  44 /*
  45  * Generic routines to fetch / create EVP methods with ossl_method_construct()
  46  */
  47 static void *get_tmp_evp_method_store(void *data)
  48 {
  49     struct evp_method_data_st *methdata = data;
  50
  51     if (methdata->tmp_store == NULL)
  52         methdata->tmp_store = ossl_method_store_new(methdata->libctx);
  53     return methdata->tmp_store;
  54 }
  55
  56  static void dealloc_tmp_evp_method_store(void *store)
  57 {
  58     if (store != NULL)
  59         ossl_method_store_free(store);
  60 }
  61
  62 static OSSL_METHOD_STORE *get_evp_method_store(OSSL_LIB_CTX *libctx)
  63 {
  64     return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_EVP_METHOD_STORE_INDEX);
  65 }
  66
  67 static int reserve_evp_method_store(void *store, void *data)
  68 {
  69     struct evp_method_data_st *methdata = data;
  70
  71     if (store == NULL
  72         && (store = get_evp_method_store(methdata->libctx)) == NULL)
  73         return 0;
  74
  75     return ossl_method_lock_store(store);
  76 }
  77
  78 static int unreserve_evp_method_store(void *store, void *data)
  79 {
  80     struct evp_method_data_st *methdata = data;
  81
  82     if (store == NULL
  83         && (store = get_evp_method_store(methdata->libctx)) == NULL)
  84         return 0;
  85
  86     return ossl_method_unlock_store(store);
  87 }
  88
  89 /*
  90  * To identify the method in the EVP method store, we mix the name identity
  91  * with the operation identity, under the assumption that we don't have more
  92  * than 2^23 names or more than 2^8 operation types.
  93  *
  94  * The resulting identity is a 31-bit integer, composed like this:
  95  *
  96  * +---------23 bits--------+-8 bits-+
  97  * |      name identity     | op id  |
  98  * +------------------------+--------+
  99  *
 100  * We limit this composite number to 31 bits, thus leaving the top uint32_t
 101  * bit always zero, to avoid negative sign extension when downshifting after
 102  * this number happens to be passed to an int (which happens as soon as it's
 103  * passed to ossl_method_store_cache_set(), and it's in that form that it
 104  * gets passed along to filter_on_operation_id(), defined further down.
 105  */
 106 #define METHOD_ID_OPERATION_MASK        0x000000FF
 107 #define METHOD_ID_OPERATION_MAX         ((1 << 8) - 1)
 108 #define METHOD_ID_NAME_MASK             0x7FFFFF00
 109 #define METHOD_ID_NAME_OFFSET           8
 110 #define METHOD_ID_NAME_MAX              ((1 << 23) - 1)
 111 static uint32_t evp_method_id(int name_id, unsigned int operation_id)
 112 {
 113     if (!ossl_assert(name_id > 0 && name_id <= METHOD_ID_NAME_MAX)
 114         || !ossl_assert(operation_id > 0
 115                         && operation_id <= METHOD_ID_OPERATION_MAX))
 116         return 0;
 117     return (((name_id << METHOD_ID_NAME_OFFSET) & METHOD_ID_NAME_MASK)
 118             | (operation_id & METHOD_ID_OPERATION_MASK));
 119 }
 120
 121 static void *get_evp_method_from_store(void *store, const OSSL_PROVIDER **prov,
 122                                        void *data)
 123 {
 124     struct evp_method_data_st *methdata = data;
 125     void *method = NULL;
 126     int name_id;
 127     uint32_t meth_id;
 128
 129     /*
 130      * get_evp_method_from_store() is only called to try and get the method
 131      * that evp_generic_fetch() is asking for, and the operation id as well
 132      * as the name or name id are passed via methdata.
 133      */
 134     if ((name_id = methdata->name_id) == 0 && methdata->names != NULL) {
 135         OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx);
 136         const char *names = methdata->names;
 137         const char *q = strchr(names, NAME_SEPARATOR);
 138         size_t l = (q == NULL ? strlen(names) : (size_t)(q - names));
 139
 140         if (namemap == 0)
 141             return NULL;
 142         name_id = ossl_namemap_name2num_n(namemap, names, l);
 143     }
 144
 145     if (name_id == 0
 146         || (meth_id = evp_method_id(name_id, methdata->operation_id)) == 0)
 147         return NULL;
 148
 149     if (store == NULL
 150         && (store = get_evp_method_store(methdata->libctx)) == NULL)
 151         return NULL;
 152
 153     if (!ossl_method_store_fetch(store, meth_id, methdata->propquery, prov,
 154                                  &method))
 155         return NULL;
 156     return method;
 157 }
 158
 159 static int put_evp_method_in_store(void *store, void *method,
 160                                    const OSSL_PROVIDER *prov,
 161                                    const char *names, const char *propdef,
 162                                    void *data)
 163 {
 164     struct evp_method_data_st *methdata = data;
 165     OSSL_NAMEMAP *namemap;
 166     int name_id;
 167     uint32_t meth_id;
 168     size_t l = 0;
 169
 170     /*
 171      * put_evp_method_in_store() is only called with an EVP method that was
 172      * successfully created by construct_method() below, which means that
 173      * all the names should already be stored in the namemap with the same
 174      * numeric identity, so just use the first to get that identity.
 175      */
 176     if (names != NULL) {
 177         const char *q = strchr(names, NAME_SEPARATOR);
 178
 179         l = (q == NULL ? strlen(names) : (size_t)(q - names));
 180     }
 181
 182     if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
 183         || (name_id = ossl_namemap_name2num_n(namemap, names, l)) == 0
 184         || (meth_id = evp_method_id(name_id, methdata->operation_id)) == 0)
 185         return 0;
 186
 187     if (store == NULL
 188         && (store = get_evp_method_store(methdata->libctx)) == NULL)
 189         return 0;
 190
 191     return ossl_method_store_add(store, prov, meth_id, propdef, method,
 192                                  methdata->refcnt_up_method,
 193                                  methdata->destruct_method);
 194 }
 195
 196 /*
 197  * The core fetching functionality passes the name of the implementation.
 198  * This function is responsible to getting an identity number for it.
 199  */
 200 static void *construct_evp_method(const OSSL_ALGORITHM *algodef,
 201                                   OSSL_PROVIDER *prov, void *data)
 202 {
 203     /*
 204      * This function is only called if get_evp_method_from_store() returned
 205      * NULL, so it's safe to say that of all the spots to create a new
 206      * namemap entry, this is it.  Should the name already exist there, we
 207      * know that ossl_namemap_add_name() will return its corresponding
 208      * number.
 209      */
 210     struct evp_method_data_st *methdata = data;
 211     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 212     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 213     const char *names = algodef->algorithm_names;
 214     int name_id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
 215     void *method;
 216
 217     if (name_id == 0)
 218         return NULL;
 219
 220     method = methdata->method_from_algorithm(name_id, algodef, prov);
 221
 222     /*
 223      * Flag to indicate that there was actual construction errors.  This
 224      * helps inner_evp_generic_fetch() determine what error it should
 225      * record on inaccessible algorithms.
 226      */
 227     if (method == NULL)
 228         methdata->flag_construct_error_occurred = 1;
 229
 230     return method;
 231 }
 232
 233 static void destruct_evp_method(void *method, void *data)
 234 {
 235     struct evp_method_data_st *methdata = data;
 236
 237     methdata->destruct_method(method);
 238 }
 239
 240 static void *
 241 inner_evp_generic_fetch(struct evp_method_data_st *methdata,
 242                         OSSL_PROVIDER *prov, int operation_id,
 243                         const char *name, const char *properties,
 244                         void *(*new_method)(int name_id,
 245                                             const OSSL_ALGORITHM *algodef,
 246                                             OSSL_PROVIDER *prov),
 247                         int (*up_ref_method)(void *),
 248                         void (*free_method)(void *))
 249 {
 250     OSSL_METHOD_STORE *store = get_evp_method_store(methdata->libctx);
 251     OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx);
 252     const char *const propq = properties != NULL ? properties : "";
 253     uint32_t meth_id = 0;
 254     void *method = NULL;
 255     int unsupported, name_id;
 256
 257     if (store == NULL || namemap == NULL) {
 258         ERR_raise(ERR_LIB_EVP, ERR_R_PASSED_INVALID_ARGUMENT);
 259         return NULL;
 260     }
 261
 262     /*
 263      * If there's ever an operation_id == 0 passed, we have an internal
 264      * programming error.
 265      */
 266     if (!ossl_assert(operation_id > 0)) {
 267         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 268         return NULL;
 269     }
 270
 271     /* If we haven't received a name id yet, try to get one for the name */
 272     name_id = name != NULL ? ossl_namemap_name2num(namemap, name) : 0;
 273
 274     /*
 275      * If we have a name id, calculate a method id with evp_method_id().
 276      *
 277      * evp_method_id returns 0 if we have too many operations (more than
 278      * about 2^8) or too many names (more than about 2^24).  In that case,
 279      * we can't create any new method.
 280      * For all intents and purposes, this is an internal error.
 281      */
 282     if (name_id != 0 && (meth_id = evp_method_id(name_id, operation_id)) == 0) {
 283         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 284         return NULL;
 285     }
 286
 287     /*
 288      * If we haven't found the name yet, chances are that the algorithm to
 289      * be fetched is unsupported.
 290      */
 291     unsupported = name_id == 0;
 292
 293     if (meth_id == 0
 294         || !ossl_method_store_cache_get(store, prov, meth_id, propq, &method)) {
 295         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
 296             get_tmp_evp_method_store,
 297             reserve_evp_method_store,
 298             unreserve_evp_method_store,
 299             get_evp_method_from_store,
 300             put_evp_method_in_store,
 301             construct_evp_method,
 302             destruct_evp_method
 303         };
 304
 305         methdata->operation_id = operation_id;
 306         methdata->name_id = name_id;
 307         methdata->names = name;
 308         methdata->propquery = propq;
 309         methdata->method_from_algorithm = new_method;
 310         methdata->refcnt_up_method = up_ref_method;
 311         methdata->destruct_method = free_method;
 312         methdata->flag_construct_error_occurred = 0;
 313         if ((method = ossl_method_construct(methdata->libctx, operation_id,
 314                                             &prov, 0 /* !force_cache */,
 315                                             &mcm, methdata)) != NULL) {
 316             /*
 317              * If construction did create a method for us, we know that
 318              * there is a correct name_id and meth_id, since those have
 319              * already been calculated in get_evp_method_from_store() and
 320              * put_evp_method_in_store() above.
 321              */
 322             if (name_id == 0)
 323                 name_id = ossl_namemap_name2num(namemap, name);
 324             meth_id = evp_method_id(name_id, operation_id);
 325             if (name_id != 0)
 326                 ossl_method_store_cache_set(store, prov, meth_id, propq,
 327                                             method, up_ref_method, free_method);
 328         }
 329
 330         /*
 331          * If we never were in the constructor, the algorithm to be fetched
 332          * is unsupported.
 333          */
 334         unsupported = !methdata->flag_construct_error_occurred;
 335     }
 336
 337     if ((name_id != 0 || name != NULL) && method == NULL) {
 338         int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED;
 339
 340         if (name == NULL)
 341             name = ossl_namemap_num2name(namemap, name_id, 0);
 342         ERR_raise_data(ERR_LIB_EVP, code,
 343                        "%s, Algorithm (%s : %d), Properties (%s)",
 344                        ossl_lib_ctx_get_descriptor(methdata->libctx),
 345                        name == NULL ? "<null>" : name, name_id,
 346                        properties == NULL ? "<null>" : properties);
 347     }
 348
 349     return method;
 350 }
 351
 352 void *evp_generic_fetch(OSSL_LIB_CTX *libctx, int operation_id,
 353                         const char *name, const char *properties,
 354                         void *(*new_method)(int name_id,
 355                                             const OSSL_ALGORITHM *algodef,
 356                                             OSSL_PROVIDER *prov),
 357                         int (*up_ref_method)(void *),
 358                         void (*free_method)(void *))
 359 {
 360     struct evp_method_data_st methdata;
 361     void *method;
 362
 363     methdata.libctx = libctx;
 364     methdata.tmp_store = NULL;
 365     method = inner_evp_generic_fetch(&methdata, NULL, operation_id,
 366                                      name, properties,
 367                                      new_method, up_ref_method, free_method);
 368     dealloc_tmp_evp_method_store(methdata.tmp_store);
 369     return method;
 370 }
 371
 372 /*
 373  * evp_generic_fetch_from_prov() is special, and only returns methods from
 374  * the given provider.
 375  * This is meant to be used when one method needs to fetch an associated
 376  * method.
 377  */
 378 void *evp_generic_fetch_from_prov(OSSL_PROVIDER *prov, int operation_id,
 379                                   const char *name, const char *properties,
 380                                   void *(*new_method)(int name_id,
 381                                                       const OSSL_ALGORITHM *algodef,
 382                                                       OSSL_PROVIDER *prov),
 383                                   int (*up_ref_method)(void *),
 384                                   void (*free_method)(void *))
 385 {
 386     struct evp_method_data_st methdata;
 387     void *method;
 388
 389     methdata.libctx = ossl_provider_libctx(prov);
 390     methdata.tmp_store = NULL;
 391     method = inner_evp_generic_fetch(&methdata, prov, operation_id,
 392                                      name, properties,
 393                                      new_method, up_ref_method, free_method);
 394     dealloc_tmp_evp_method_store(methdata.tmp_store);
 395     return method;
 396 }
 397
 398 int evp_method_store_cache_flush(OSSL_LIB_CTX *libctx)
 399 {
 400     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 401
 402     if (store != NULL)
 403         return ossl_method_store_cache_flush_all(store);
 404     return 1;
 405 }
 406
 407 int evp_method_store_remove_all_provided(const OSSL_PROVIDER *prov)
 408 {
 409     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 410     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 411
 412     if (store != NULL)
 413         return ossl_method_store_remove_all_provided(store, prov);
 414     return 1;
 415 }
 416
 417 static int evp_set_parsed_default_properties(OSSL_LIB_CTX *libctx,
 418                                              OSSL_PROPERTY_LIST *def_prop,
 419                                              int loadconfig,
 420                                              int mirrored)
 421 {
 422     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 423     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
 424
 425     if (plp != NULL && store != NULL) {
 426         int ret;
 427 #ifndef FIPS_MODULE
 428         char *propstr = NULL;
 429         size_t strsz;
 430
 431         if (mirrored) {
 432             if (ossl_global_properties_no_mirrored(libctx))
 433                 return 0;
 434         } else {
 435             /*
 436              * These properties have been explicitly set on this libctx, so
 437              * don't allow any mirroring from a parent libctx.
 438              */
 439             ossl_global_properties_stop_mirroring(libctx);
 440         }
 441
 442         strsz = ossl_property_list_to_string(libctx, def_prop, NULL, 0);
 443         if (strsz > 0)
 444             propstr = OPENSSL_malloc(strsz);
 445         if (propstr == NULL) {
 446             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 447             return 0;
 448         }
 449         if (ossl_property_list_to_string(libctx, def_prop, propstr,
 450                                          strsz) == 0) {
 451             OPENSSL_free(propstr);
 452             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 453             return 0;
 454         }
 455         ossl_provider_default_props_update(libctx, propstr);
 456         OPENSSL_free(propstr);
 457 #endif
 458         ossl_property_free(*plp);
 459         *plp = def_prop;
 460
 461         ret = ossl_method_store_cache_flush_all(store);
 462 #ifndef FIPS_MODULE
 463         ossl_decoder_cache_flush(libctx);
 464 #endif
 465         return ret;
 466     }
 467     ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 468     return 0;
 469 }
 470
 471 int evp_set_default_properties_int(OSSL_LIB_CTX *libctx, const char *propq,
 472                                    int loadconfig, int mirrored)
 473 {
 474     OSSL_PROPERTY_LIST *pl = NULL;
 475
 476     if (propq != NULL && (pl = ossl_parse_query(libctx, propq, 1)) == NULL) {
 477         ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR);
 478         return 0;
 479     }
 480     if (!evp_set_parsed_default_properties(libctx, pl, loadconfig, mirrored)) {
 481         ossl_property_free(pl);
 482         return 0;
 483     }
 484     return 1;
 485 }
 486
 487 int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq)
 488 {
 489     return evp_set_default_properties_int(libctx, propq, 1, 0);
 490 }
 491
 492 static int evp_default_properties_merge(OSSL_LIB_CTX *libctx, const char *propq,
 493                                         int loadconfig)
 494 {
 495     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
 496     OSSL_PROPERTY_LIST *pl1, *pl2;
 497
 498     if (propq == NULL)
 499         return 1;
 500     if (plp == NULL || *plp == NULL)
 501         return evp_set_default_properties_int(libctx, propq, 0, 0);
 502     if ((pl1 = ossl_parse_query(libctx, propq, 1)) == NULL) {
 503         ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR);
 504         return 0;
 505     }
 506     pl2 = ossl_property_merge(pl1, *plp);
 507     ossl_property_free(pl1);
 508     if (pl2 == NULL) {
 509         ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
 510         return 0;
 511     }
 512     if (!evp_set_parsed_default_properties(libctx, pl2, 0, 0)) {
 513         ossl_property_free(pl2);
 514         return 0;
 515     }
 516     return 1;
 517 }
 518
 519 static int evp_default_property_is_enabled(OSSL_LIB_CTX *libctx,
 520                                            const char *prop_name)
 521 {
 522     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, 1);
 523
 524     return plp != NULL && ossl_property_is_enabled(libctx, prop_name, *plp);
 525 }
 526
 527 int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx)
 528 {
 529     return evp_default_property_is_enabled(libctx, "fips");
 530 }
 531
 532 int evp_default_properties_enable_fips_int(OSSL_LIB_CTX *libctx, int enable,
 533                                            int loadconfig)
 534 {
 535     const char *query = (enable != 0) ? "fips=yes" : "-fips";
 536
 537     return evp_default_properties_merge(libctx, query, loadconfig);
 538 }
 539
 540 int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable)
 541 {
 542     return evp_default_properties_enable_fips_int(libctx, enable, 1);
 543 }
 544
 545 char *evp_get_global_properties_str(OSSL_LIB_CTX *libctx, int loadconfig)
 546 {
 547     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
 548     char *propstr = NULL;
 549     size_t sz;
 550
 551     if (plp == NULL)
 552         return OPENSSL_strdup("");
 553
 554     sz = ossl_property_list_to_string(libctx, *plp, NULL, 0);
 555     if (sz == 0) {
 556         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 557         return NULL;
 558     }
 559
 560     propstr = OPENSSL_malloc(sz);
 561     if (propstr == NULL)
 562         return NULL;
 563     if (ossl_property_list_to_string(libctx, *plp, propstr, sz) == 0) {
 564         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 565         OPENSSL_free(propstr);
 566         return NULL;
 567     }
 568     return propstr;
 569 }
 570
 571 struct filter_data_st {
 572     int operation_id;
 573     void (*user_fn)(void *method, void *arg);
 574     void *user_arg;
 575 };
 576
 577 static void filter_on_operation_id(int id, void *method, void *arg)
 578 {
 579     struct filter_data_st *data = arg;
 580
 581     if ((id & METHOD_ID_OPERATION_MASK) == data->operation_id)
 582         data->user_fn(method, data->user_arg);
 583 }
 584
 585 void evp_generic_do_all(OSSL_LIB_CTX *libctx, int operation_id,
 586                         void (*user_fn)(void *method, void *arg),
 587                         void *user_arg,
 588                         void *(*new_method)(int name_id,
 589                                             const OSSL_ALGORITHM *algodef,
 590                                             OSSL_PROVIDER *prov),
 591                         int (*up_ref_method)(void *),
 592                         void (*free_method)(void *))
 593 {
 594     struct evp_method_data_st methdata;
 595     struct filter_data_st data;
 596
 597     methdata.libctx = libctx;
 598     methdata.tmp_store = NULL;
 599     (void)inner_evp_generic_fetch(&methdata, NULL, operation_id, NULL, NULL,
 600                                   new_method, up_ref_method, free_method);
 601
 602     data.operation_id = operation_id;
 603     data.user_fn = user_fn;
 604     data.user_arg = user_arg;
 605     if (methdata.tmp_store != NULL)
 606         ossl_method_store_do_all(methdata.tmp_store, &filter_on_operation_id,
 607                                  &data);
 608     ossl_method_store_do_all(get_evp_method_store(libctx),
 609                              &filter_on_operation_id, &data);
 610     dealloc_tmp_evp_method_store(methdata.tmp_store);
 611 }
 612
 613 int evp_is_a(OSSL_PROVIDER *prov, int number,
 614              const char *legacy_name, const char *name)
 615 {
 616     /*
 617      * For a |prov| that is NULL, the library context will be NULL
 618      */
 619     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 620     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 621
 622     if (prov == NULL)
 623         number = ossl_namemap_name2num(namemap, legacy_name);
 624     return ossl_namemap_name2num(namemap, name) == number;
 625 }
 626
 627 int evp_names_do_all(OSSL_PROVIDER *prov, int number,
 628                      void (*fn)(const char *name, void *data),
 629                      void *data)
 630 {
 631     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 632     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 633
 634     return ossl_namemap_doall_names(namemap, number, fn, data);
 635 }