crypto/store/store_meth.c

   1 /*
   2  * Copyright 2020-2021 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/store.h>
  11 #include <openssl/crypto.h>
  12 #include "internal/core.h"
  13 #include "internal/namemap.h"
  14 #include "internal/property.h"
  15 #include "internal/provider.h"
  16 #include "store_local.h"
  17
  18 int OSSL_STORE_LOADER_up_ref(OSSL_STORE_LOADER *loader)
  19 {
  20     int ref = 0;
  21
  22     if (loader->prov != NULL)
  23         CRYPTO_UP_REF(&loader->refcnt, &ref, loader->lock);
  24     return 1;
  25 }
  26
  27 void OSSL_STORE_LOADER_free(OSSL_STORE_LOADER *loader)
  28 {
  29     if (loader != NULL && loader->prov != NULL) {
  30         int i;
  31
  32         CRYPTO_DOWN_REF(&loader->refcnt, &i, loader->lock);
  33         if (i > 0)
  34             return;
  35         ossl_provider_free(loader->prov);
  36         CRYPTO_THREAD_lock_free(loader->lock);
  37     }
  38     OPENSSL_free(loader);
  39 }
  40
  41 /*
  42  * OSSL_STORE_LOADER_new() expects the scheme as a constant string,
  43  * which we currently don't have, so we need an alternative allocator.
  44  */
  45 static OSSL_STORE_LOADER *new_loader(OSSL_PROVIDER *prov)
  46 {
  47     OSSL_STORE_LOADER *loader;
  48
  49     if ((loader = OPENSSL_zalloc(sizeof(*loader))) == NULL
  50         || (loader->lock = CRYPTO_THREAD_lock_new()) == NULL) {
  51         OPENSSL_free(loader);
  52         return NULL;
  53     }
  54     loader->prov = prov;
  55     ossl_provider_up_ref(prov);
  56     loader->refcnt = 1;
  57
  58     return loader;
  59 }
  60
  61 static int up_ref_loader(void *method)
  62 {
  63     return OSSL_STORE_LOADER_up_ref(method);
  64 }
  65
  66 static void free_loader(void *method)
  67 {
  68     OSSL_STORE_LOADER_free(method);
  69 }
  70
  71 /* Permanent loader method store, constructor and destructor */
  72 static void loader_store_free(void *vstore)
  73 {
  74     ossl_method_store_free(vstore);
  75 }
  76
  77 static void *loader_store_new(OSSL_LIB_CTX *ctx)
  78 {
  79     return ossl_method_store_new(ctx);
  80 }
  81
  82
  83 static const OSSL_LIB_CTX_METHOD loader_store_method = {
  84     loader_store_new,
  85     loader_store_free,
  86 };
  87
  88 /* Data to be passed through ossl_method_construct() */
  89 struct loader_data_st {
  90     OSSL_LIB_CTX *libctx;
  91     OSSL_METHOD_CONSTRUCT_METHOD *mcm;
  92     int scheme_id;               /* For get_loader_from_store() */
  93     const char *scheme;          /* For get_loader_from_store() */
  94     const char *propquery;       /* For get_loader_from_store() */
  95
  96     unsigned int flag_construct_error_occurred : 1;
  97 };
  98
  99 /*
 100  * Generic routines to fetch / create OSSL_STORE methods with
 101  * ossl_method_construct()
 102  */
 103
 104 /* Temporary loader method store, constructor and destructor */
 105 static void *alloc_tmp_loader_store(OSSL_LIB_CTX *ctx)
 106 {
 107     return ossl_method_store_new(ctx);
 108 }
 109
 110  static void dealloc_tmp_loader_store(void *store)
 111 {
 112     if (store != NULL)
 113         ossl_method_store_free(store);
 114 }
 115
 116 /* Get the permanent loader store */
 117 static OSSL_METHOD_STORE *get_loader_store(OSSL_LIB_CTX *libctx)
 118 {
 119     return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_STORE_LOADER_STORE_INDEX,
 120                                 &loader_store_method);
 121 }
 122
 123 /* Get loader methods from a store, or put one in */
 124 static void *get_loader_from_store(OSSL_LIB_CTX *libctx, void *store,
 125                                    void *data)
 126 {
 127     struct loader_data_st *methdata = data;
 128     void *method = NULL;
 129     int id;
 130
 131     if ((id = methdata->scheme_id) == 0) {
 132         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 133
 134         id = ossl_namemap_name2num(namemap, methdata->scheme);
 135     }
 136
 137     if (store == NULL
 138         && (store = get_loader_store(libctx)) == NULL)
 139         return NULL;
 140
 141     if (!ossl_method_store_fetch(store, id, methdata->propquery, &method))
 142         return NULL;
 143     return method;
 144 }
 145
 146 static int put_loader_in_store(OSSL_LIB_CTX *libctx, void *store,
 147                                void *method, const OSSL_PROVIDER *prov,
 148                                int operation_id, const char *scheme,
 149                                const char *propdef, void *unused)
 150 {
 151     OSSL_NAMEMAP *namemap;
 152     int id;
 153
 154     if ((namemap = ossl_namemap_stored(libctx)) == NULL
 155         || (id = ossl_namemap_name2num(namemap, scheme)) == 0)
 156         return 0;
 157
 158     if (store == NULL && (store = get_loader_store(libctx)) == NULL)
 159         return 0;
 160
 161     return ossl_method_store_add(store, prov, id, propdef, method,
 162                                  up_ref_loader, free_loader);
 163 }
 164
 165 static void *loader_from_algorithm(int scheme_id, const OSSL_ALGORITHM *algodef,
 166                                    OSSL_PROVIDER *prov)
 167 {
 168     OSSL_STORE_LOADER *loader = NULL;
 169     const OSSL_DISPATCH *fns = algodef->implementation;
 170
 171     if ((loader = new_loader(prov)) == NULL)
 172         return NULL;
 173     loader->scheme_id = scheme_id;
 174     loader->propdef = algodef->property_definition;
 175     loader->description = algodef->algorithm_description;
 176
 177     for (; fns->function_id != 0; fns++) {
 178         switch (fns->function_id) {
 179         case OSSL_FUNC_STORE_OPEN:
 180             if (loader->p_open == NULL)
 181                 loader->p_open = OSSL_FUNC_store_open(fns);
 182             break;
 183         case OSSL_FUNC_STORE_ATTACH:
 184             if (loader->p_attach == NULL)
 185                 loader->p_attach = OSSL_FUNC_store_attach(fns);
 186             break;
 187         case OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS:
 188             if (loader->p_settable_ctx_params == NULL)
 189                 loader->p_settable_ctx_params =
 190                     OSSL_FUNC_store_settable_ctx_params(fns);
 191             break;
 192         case OSSL_FUNC_STORE_SET_CTX_PARAMS:
 193             if (loader->p_set_ctx_params == NULL)
 194                 loader->p_set_ctx_params = OSSL_FUNC_store_set_ctx_params(fns);
 195             break;
 196         case OSSL_FUNC_STORE_LOAD:
 197             if (loader->p_load == NULL)
 198                 loader->p_load = OSSL_FUNC_store_load(fns);
 199             break;
 200         case OSSL_FUNC_STORE_EOF:
 201             if (loader->p_eof == NULL)
 202                 loader->p_eof = OSSL_FUNC_store_eof(fns);
 203             break;
 204         case OSSL_FUNC_STORE_CLOSE:
 205             if (loader->p_close == NULL)
 206                 loader->p_close = OSSL_FUNC_store_close(fns);
 207             break;
 208         case OSSL_FUNC_STORE_EXPORT_OBJECT:
 209             if (loader->p_export_object == NULL)
 210                 loader->p_export_object = OSSL_FUNC_store_export_object(fns);
 211             break;
 212         }
 213     }
 214
 215     if ((loader->p_open == NULL && loader->p_attach == NULL)
 216         || loader->p_load == NULL
 217         || loader->p_eof == NULL
 218         || loader->p_close == NULL) {
 219         /* Only set_ctx_params is optionaal */
 220         OSSL_STORE_LOADER_free(loader);
 221         ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_LOADER_INCOMPLETE);
 222         return NULL;
 223     }
 224     return loader;
 225 }
 226
 227 /*
 228  * The core fetching functionality passes the scheme of the implementation.
 229  * This function is responsible to getting an identity number for them,
 230  * then call loader_from_algorithm() with that identity number.
 231  */
 232 static void *construct_loader(const OSSL_ALGORITHM *algodef,
 233                               OSSL_PROVIDER *prov, void *data)
 234 {
 235     /*
 236      * This function is only called if get_loader_from_store() returned
 237      * NULL, so it's safe to say that of all the spots to create a new
 238      * namemap entry, this is it.  Should the scheme already exist there, we
 239      * know that ossl_namemap_add() will return its corresponding number.
 240      */
 241     struct loader_data_st *methdata = data;
 242     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
 243     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 244     const char *scheme = algodef->algorithm_names;
 245     int id = ossl_namemap_add_name(namemap, 0, scheme);
 246     void *method = NULL;
 247
 248     if (id != 0)
 249         method = loader_from_algorithm(id, algodef, prov);
 250
 251     /*
 252      * Flag to indicate that there was actual construction errors.  This
 253      * helps inner_evp_generic_fetch() determine what error it should
 254      * record on inaccessible algorithms.
 255      */
 256     if (method == NULL)
 257         methdata->flag_construct_error_occurred = 1;
 258
 259     return method;
 260 }
 261
 262 /* Intermediary function to avoid ugly casts, used below */
 263 static void destruct_loader(void *method, void *data)
 264 {
 265     OSSL_STORE_LOADER_free(method);
 266 }
 267
 268 /* Fetching support.  Can fetch by numeric identity or by scheme */
 269 static OSSL_STORE_LOADER *inner_loader_fetch(OSSL_LIB_CTX *libctx,
 270                                              int id, const char *scheme,
 271                                              const char *properties)
 272 {
 273     OSSL_METHOD_STORE *store = get_loader_store(libctx);
 274     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 275     void *method = NULL;
 276     int unsupported = 0;
 277
 278     if (store == NULL || namemap == NULL) {
 279         ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_PASSED_INVALID_ARGUMENT);
 280         return NULL;
 281     }
 282
 283     /*
 284      * If we have been passed neither a scheme_id nor a scheme, we have an
 285      * internal programming error.
 286      */
 287     if (!ossl_assert(id != 0 || scheme != NULL)) {
 288         ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_INTERNAL_ERROR);
 289         return NULL;
 290     }
 291
 292     /* If we haven't received a name id yet, try to get one for the name */
 293     if (id == 0)
 294         id = ossl_namemap_name2num(namemap, scheme);
 295
 296     /*
 297      * If we haven't found the name yet, chances are that the algorithm to
 298      * be fetched is unsupported.
 299      */
 300     if (id == 0)
 301         unsupported = 1;
 302
 303     if (id == 0
 304         || !ossl_method_store_cache_get(store, id, properties, &method)) {
 305         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
 306             alloc_tmp_loader_store,
 307             dealloc_tmp_loader_store,
 308             get_loader_from_store,
 309             put_loader_in_store,
 310             construct_loader,
 311             destruct_loader
 312         };
 313         struct loader_data_st mcmdata;
 314
 315         mcmdata.libctx = libctx;
 316         mcmdata.mcm = &mcm;
 317         mcmdata.scheme_id = id;
 318         mcmdata.scheme = scheme;
 319         mcmdata.propquery = properties;
 320         mcmdata.flag_construct_error_occurred = 0;
 321         if ((method = ossl_method_construct(libctx, OSSL_OP_STORE,
 322                                             0 /* !force_cache */,
 323                                             &mcm, &mcmdata)) != NULL) {
 324             /*
 325              * If construction did create a method for us, we know that there
 326              * is a correct scheme_id, since those have already been calculated
 327              * in get_loader_from_store() and put_loader_in_store() above.
 328              */
 329             if (id == 0)
 330                 id = ossl_namemap_name2num(namemap, scheme);
 331             ossl_method_store_cache_set(store, id, properties, method,
 332                                         up_ref_loader, free_loader);
 333         }
 334
 335         /*
 336          * If we never were in the constructor, the algorithm to be fetched
 337          * is unsupported.
 338          */
 339         unsupported = !mcmdata.flag_construct_error_occurred;
 340     }
 341
 342     if (method == NULL) {
 343         int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED;
 344
 345         if (scheme == NULL)
 346             scheme = ossl_namemap_num2name(namemap, id, 0);
 347         ERR_raise_data(ERR_LIB_OSSL_STORE, code,
 348                        "%s, Scheme (%s : %d), Properties (%s)",
 349                        ossl_lib_ctx_get_descriptor(libctx),
 350                        scheme = NULL ? "<null>" : scheme, id,
 351                        properties == NULL ? "<null>" : properties);
 352     }
 353
 354     return method;
 355 }
 356
 357 OSSL_STORE_LOADER *OSSL_STORE_LOADER_fetch(const char *scheme,
 358                                            OSSL_LIB_CTX *libctx,
 359                                            const char *properties)
 360 {
 361     return inner_loader_fetch(libctx, 0, scheme, properties);
 362 }
 363
 364 OSSL_STORE_LOADER *ossl_store_loader_fetch_by_number(OSSL_LIB_CTX *libctx,
 365                                                      int scheme_id,
 366                                                      const char *properties)
 367 {
 368     return inner_loader_fetch(libctx, scheme_id, NULL, properties);
 369 }
 370
 371 /*
 372  * Library of basic method functions
 373  */
 374
 375 const OSSL_PROVIDER *OSSL_STORE_LOADER_provider(const OSSL_STORE_LOADER *loader)
 376 {
 377     if (!ossl_assert(loader != NULL)) {
 378         ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_PASSED_NULL_PARAMETER);
 379         return 0;
 380     }
 381
 382     return loader->prov;
 383 }
 384
 385 const char *OSSL_STORE_LOADER_properties(const OSSL_STORE_LOADER *loader)
 386 {
 387     if (!ossl_assert(loader != NULL)) {
 388         ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_PASSED_NULL_PARAMETER);
 389         return 0;
 390     }
 391
 392     return loader->propdef;
 393 }
 394
 395 int OSSL_STORE_LOADER_number(const OSSL_STORE_LOADER *loader)
 396 {
 397     if (!ossl_assert(loader != NULL)) {
 398         ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_PASSED_NULL_PARAMETER);
 399         return 0;
 400     }
 401
 402     return loader->scheme_id;
 403 }
 404
 405 const char *OSSL_STORE_LOADER_description(const OSSL_STORE_LOADER *loader)
 406 {
 407     return loader->description;
 408 }
 409
 410 int OSSL_STORE_LOADER_is_a(const OSSL_STORE_LOADER *loader, const char *name)
 411 {
 412     if (loader->prov != NULL) {
 413         OSSL_LIB_CTX *libctx = ossl_provider_libctx(loader->prov);
 414         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 415
 416         return ossl_namemap_name2num(namemap, name) == loader->scheme_id;
 417     }
 418     return 0;
 419 }
 420
 421 struct loader_do_all_data_st {
 422     void (*user_fn)(void *method, void *arg);
 423     void *user_arg;
 424 };
 425
 426 static void loader_do_one(OSSL_PROVIDER *provider,
 427                           const OSSL_ALGORITHM *algodef,
 428                           int no_store, void *vdata)
 429 {
 430     struct loader_do_all_data_st *data = vdata;
 431     OSSL_LIB_CTX *libctx = ossl_provider_libctx(provider);
 432     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 433     const char *name = algodef->algorithm_names;
 434     int id = ossl_namemap_add_name(namemap, 0, name);
 435     void *method = NULL;
 436
 437     if (id != 0)
 438         method =
 439             loader_from_algorithm(id, algodef, provider);
 440
 441     if (method != NULL) {
 442         data->user_fn(method, data->user_arg);
 443         OSSL_STORE_LOADER_free(method);
 444     }
 445 }
 446
 447 void OSSL_STORE_LOADER_do_all_provided(OSSL_LIB_CTX *libctx,
 448                                        void (*fn)(OSSL_STORE_LOADER *loader,
 449                                                   void *arg),
 450                                        void *arg)
 451 {
 452     struct loader_do_all_data_st data;
 453
 454     data.user_fn = (void (*)(void *, void *))fn;
 455     data.user_arg = arg;
 456     ossl_algorithm_do_all(libctx, OSSL_OP_STORE, NULL,
 457                           NULL, loader_do_one, NULL,
 458                           &data);
 459 }
 460
 461 int OSSL_STORE_LOADER_names_do_all(const OSSL_STORE_LOADER *loader,
 462                                    void (*fn)(const char *name, void *data),
 463                                    void *data)
 464 {
 465     if (loader == NULL)
 466         return 0;
 467
 468     if (loader->prov != NULL) {
 469         OSSL_LIB_CTX *libctx = ossl_provider_libctx(loader->prov);
 470         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 471
 472         return ossl_namemap_doall_names(namemap, loader->scheme_id, fn, data);
 473     }
 474
 475     return 1;
 476 }