crypto/evp/evp_fetch.c

   1 /*
   2  * Copyright 2019-2024 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              * Note that there is a corner case here, in which, if a user
 322              * passes a name of the form name1:name2:..., then the construction
 323              * will create a method against all names, but the lookup will fail
 324              * as ossl_namemap_name2num treats the name string as a single name
 325              * rather than introducing new features where in the EVP_<obj>_fetch
 326              * parses the string and queries for each, return an error.
 327              */
 328             if (name_id == 0)
 329                 name_id = ossl_namemap_name2num(namemap, name);
 330             if (name_id == 0) {
 331                 ERR_raise_data(ERR_LIB_EVP, ERR_R_FETCH_FAILED,
 332                                "Algorithm %s cannot be found", name);
 333                 free_method(method);
 334                 method = NULL;
 335             } else {
 336                 meth_id = evp_method_id(name_id, operation_id);
 337                 if (meth_id != 0)
 338                     ossl_method_store_cache_set(store, prov, meth_id, propq,
 339                                                 method, up_ref_method, free_method);
 340             }
 341         }
 342
 343         /*
 344          * If we never were in the constructor, the algorithm to be fetched
 345          * is unsupported.
 346          */
 347         unsupported = !methdata->flag_construct_error_occurred;
 348     }
 349
 350     if ((name_id != 0 || name != NULL) && method == NULL) {
 351         int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED;
 352
 353         if (name == NULL)
 354             name = ossl_namemap_num2name(namemap, name_id, 0);
 355         ERR_raise_data(ERR_LIB_EVP, code,
 356                        "%s, Algorithm (%s : %d), Properties (%s)",
 357                        ossl_lib_ctx_get_descriptor(methdata->libctx),
 358                        name == NULL ? "<null>" : name, name_id,
 359                        properties == NULL ? "<null>" : properties);
 360     }
 361
 362     return method;
 363 }
 364
 365 void *evp_generic_fetch(OSSL_LIB_CTX *libctx, int operation_id,
 366                         const char *name, const char *properties,
 367                         void *(*new_method)(int name_id,
 368                                             const OSSL_ALGORITHM *algodef,
 369                                             OSSL_PROVIDER *prov),
 370                         int (*up_ref_method)(void *),
 371                         void (*free_method)(void *))
 372 {
 373     struct evp_method_data_st methdata;
 374     void *method;
 375
 376     methdata.libctx = libctx;
 377     methdata.tmp_store = NULL;
 378     method = inner_evp_generic_fetch(&methdata, NULL, operation_id,
 379                                      name, properties,
 380                                      new_method, up_ref_method, free_method);
 381     dealloc_tmp_evp_method_store(methdata.tmp_store);
 382     return method;
 383 }
 384
 385 /*
 386  * evp_generic_fetch_from_prov() is special, and only returns methods from
 387  * the given provider.
 388  * This is meant to be used when one method needs to fetch an associated
 389  * method.
 390  */
 391 void *evp_generic_fetch_from_prov(OSSL_PROVIDER *prov, int operation_id,
 392                                   const char *name, const char *properties,
 393                                   void *(*new_method)(int name_id,
 394                                                       const OSSL_ALGORITHM *algodef,
 395                                                       OSSL_PROVIDER *prov),
 396                                   int (*up_ref_method)(void *),
 397                                   void (*free_method)(void *))
 398 {
 399     struct evp_method_data_st methdata;
 400     void *method;
 401
 402     methdata.libctx = ossl_provider_libctx(prov);
 403     methdata.tmp_store = NULL;
 404     method = inner_evp_generic_fetch(&methdata, prov, operation_id,
 405                                      name, properties,
 406                                      new_method, up_ref_method, free_method);
 407     dealloc_tmp_evp_method_store(methdata.tmp_store);
 408     return method;
 409 }
 410
 411 int evp_method_store_cache_flush(OSSL_LIB_CTX *libctx)
 412 {
 413     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 414
 415     if (store != NULL)
 416         return ossl_method_store_cache_flush_all(store);
 417     return 1;
 418 }
 419
 420 int evp_method_store_remove_all_provided(const OSSL_PROVIDER *prov)
 421 {
 422     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 423     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 424
 425     if (store != NULL)
 426         return ossl_method_store_remove_all_provided(store, prov);
 427     return 1;
 428 }
 429
 430 static int evp_set_parsed_default_properties(OSSL_LIB_CTX *libctx,
 431                                              OSSL_PROPERTY_LIST *def_prop,
 432                                              int loadconfig,
 433                                              int mirrored)
 434 {
 435     OSSL_METHOD_STORE *store = get_evp_method_store(libctx);
 436     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
 437
 438     if (plp != NULL && store != NULL) {
 439         int ret;
 440 #ifndef FIPS_MODULE
 441         char *propstr = NULL;
 442         size_t strsz;
 443
 444         if (mirrored) {
 445             if (ossl_global_properties_no_mirrored(libctx))
 446                 return 0;
 447         } else {
 448             /*
 449              * These properties have been explicitly set on this libctx, so
 450              * don't allow any mirroring from a parent libctx.
 451              */
 452             ossl_global_properties_stop_mirroring(libctx);
 453         }
 454
 455         strsz = ossl_property_list_to_string(libctx, def_prop, NULL, 0);
 456         if (strsz > 0)
 457             propstr = OPENSSL_malloc(strsz);
 458         if (propstr == NULL) {
 459             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 460             return 0;
 461         }
 462         if (ossl_property_list_to_string(libctx, def_prop, propstr,
 463                                          strsz) == 0) {
 464             OPENSSL_free(propstr);
 465             ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 466             return 0;
 467         }
 468         ossl_provider_default_props_update(libctx, propstr);
 469         OPENSSL_free(propstr);
 470 #endif
 471         ossl_property_free(*plp);
 472         *plp = def_prop;
 473
 474         ret = ossl_method_store_cache_flush_all(store);
 475 #ifndef FIPS_MODULE
 476         ossl_decoder_cache_flush(libctx);
 477 #endif
 478         return ret;
 479     }
 480     ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 481     return 0;
 482 }
 483
 484 int evp_set_default_properties_int(OSSL_LIB_CTX *libctx, const char *propq,
 485                                    int loadconfig, int mirrored)
 486 {
 487     OSSL_PROPERTY_LIST *pl = NULL;
 488
 489     if (propq != NULL && (pl = ossl_parse_query(libctx, propq, 1)) == NULL) {
 490         ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR);
 491         return 0;
 492     }
 493     if (!evp_set_parsed_default_properties(libctx, pl, loadconfig, mirrored)) {
 494         ossl_property_free(pl);
 495         return 0;
 496     }
 497     return 1;
 498 }
 499
 500 int EVP_set_default_properties(OSSL_LIB_CTX *libctx, const char *propq)
 501 {
 502     return evp_set_default_properties_int(libctx, propq, 1, 0);
 503 }
 504
 505 static int evp_default_properties_merge(OSSL_LIB_CTX *libctx, const char *propq,
 506                                         int loadconfig)
 507 {
 508     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
 509     OSSL_PROPERTY_LIST *pl1, *pl2;
 510
 511     if (propq == NULL)
 512         return 1;
 513     if (plp == NULL || *plp == NULL)
 514         return evp_set_default_properties_int(libctx, propq, 0, 0);
 515     if ((pl1 = ossl_parse_query(libctx, propq, 1)) == NULL) {
 516         ERR_raise(ERR_LIB_EVP, EVP_R_DEFAULT_QUERY_PARSE_ERROR);
 517         return 0;
 518     }
 519     pl2 = ossl_property_merge(pl1, *plp);
 520     ossl_property_free(pl1);
 521     if (pl2 == NULL) {
 522         ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
 523         return 0;
 524     }
 525     if (!evp_set_parsed_default_properties(libctx, pl2, 0, 0)) {
 526         ossl_property_free(pl2);
 527         return 0;
 528     }
 529     return 1;
 530 }
 531
 532 static int evp_default_property_is_enabled(OSSL_LIB_CTX *libctx,
 533                                            const char *prop_name)
 534 {
 535     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, 1);
 536
 537     return plp != NULL && ossl_property_is_enabled(libctx, prop_name, *plp);
 538 }
 539
 540 int EVP_default_properties_is_fips_enabled(OSSL_LIB_CTX *libctx)
 541 {
 542     return evp_default_property_is_enabled(libctx, "fips");
 543 }
 544
 545 int evp_default_properties_enable_fips_int(OSSL_LIB_CTX *libctx, int enable,
 546                                            int loadconfig)
 547 {
 548     const char *query = (enable != 0) ? "fips=yes" : "-fips";
 549
 550     return evp_default_properties_merge(libctx, query, loadconfig);
 551 }
 552
 553 int EVP_default_properties_enable_fips(OSSL_LIB_CTX *libctx, int enable)
 554 {
 555     return evp_default_properties_enable_fips_int(libctx, enable, 1);
 556 }
 557
 558 char *evp_get_global_properties_str(OSSL_LIB_CTX *libctx, int loadconfig)
 559 {
 560     OSSL_PROPERTY_LIST **plp = ossl_ctx_global_properties(libctx, loadconfig);
 561     char *propstr = NULL;
 562     size_t sz;
 563
 564     if (plp == NULL)
 565         return OPENSSL_strdup("");
 566
 567     sz = ossl_property_list_to_string(libctx, *plp, NULL, 0);
 568     if (sz == 0) {
 569         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 570         return NULL;
 571     }
 572
 573     propstr = OPENSSL_malloc(sz);
 574     if (propstr == NULL)
 575         return NULL;
 576     if (ossl_property_list_to_string(libctx, *plp, propstr, sz) == 0) {
 577         ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
 578         OPENSSL_free(propstr);
 579         return NULL;
 580     }
 581     return propstr;
 582 }
 583
 584 struct filter_data_st {
 585     int operation_id;
 586     void (*user_fn)(void *method, void *arg);
 587     void *user_arg;
 588 };
 589
 590 static void filter_on_operation_id(int id, void *method, void *arg)
 591 {
 592     struct filter_data_st *data = arg;
 593
 594     if ((id & METHOD_ID_OPERATION_MASK) == data->operation_id)
 595         data->user_fn(method, data->user_arg);
 596 }
 597
 598 void evp_generic_do_all(OSSL_LIB_CTX *libctx, int operation_id,
 599                         void (*user_fn)(void *method, void *arg),
 600                         void *user_arg,
 601                         void *(*new_method)(int name_id,
 602                                             const OSSL_ALGORITHM *algodef,
 603                                             OSSL_PROVIDER *prov),
 604                         int (*up_ref_method)(void *),
 605                         void (*free_method)(void *))
 606 {
 607     struct evp_method_data_st methdata;
 608     struct filter_data_st data;
 609
 610     methdata.libctx = libctx;
 611     methdata.tmp_store = NULL;
 612     (void)inner_evp_generic_fetch(&methdata, NULL, operation_id, NULL, NULL,
 613                                   new_method, up_ref_method, free_method);
 614
 615     data.operation_id = operation_id;
 616     data.user_fn = user_fn;
 617     data.user_arg = user_arg;
 618     if (methdata.tmp_store != NULL)
 619         ossl_method_store_do_all(methdata.tmp_store, &filter_on_operation_id,
 620                                  &data);
 621     ossl_method_store_do_all(get_evp_method_store(libctx),
 622                              &filter_on_operation_id, &data);
 623     dealloc_tmp_evp_method_store(methdata.tmp_store);
 624 }
 625
 626 int evp_is_a(OSSL_PROVIDER *prov, int number,
 627              const char *legacy_name, const char *name)
 628 {
 629     /*
 630      * For a |prov| that is NULL, the library context will be NULL
 631      */
 632     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 633     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 634
 635     if (prov == NULL)
 636         number = ossl_namemap_name2num(namemap, legacy_name);
 637     return ossl_namemap_name2num(namemap, name) == number;
 638 }
 639
 640 int evp_names_do_all(OSSL_PROVIDER *prov, int number,
 641                      void (*fn)(const char *name, void *data),
 642                      void *data)
 643 {
 644     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 645     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 646
 647     return ossl_namemap_doall_names(namemap, number, fn, data);
 648 }