crypto/evp/evp_fetch.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 <stddef.h>
  11 #include <openssl/ossl_typ.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/namemap.h"
  19 #include "internal/evp_int.h"    /* evp_locl.h needs it */
  20 #include "evp_locl.h"
  21
  22 static void default_method_store_free(void *vstore)
  23 {
  24     ossl_method_store_free(vstore);
  25 }
  26
  27 static void *default_method_store_new(OPENSSL_CTX *ctx)
  28 {
  29     return ossl_method_store_new(ctx);
  30 }
  31
  32
  33 static const OPENSSL_CTX_METHOD default_method_store_method = {
  34     default_method_store_new,
  35     default_method_store_free,
  36 };
  37
  38 /* Data to be passed through ossl_method_construct() */
  39 struct method_data_st {
  40     OPENSSL_CTX *libctx;
  41     const char *name;
  42     int id;
  43     OSSL_METHOD_CONSTRUCT_METHOD *mcm;
  44     void *(*method_from_dispatch)(const OSSL_DISPATCH *, OSSL_PROVIDER *);
  45     int (*refcnt_up_method)(void *method);
  46     void (*destruct_method)(void *method);
  47 };
  48
  49 /*
  50  * Generic routines to fetch / create EVP methods with ossl_method_construct()
  51  */
  52 static void *alloc_tmp_method_store(OPENSSL_CTX *ctx)
  53 {
  54     return ossl_method_store_new(ctx);
  55 }
  56
  57  static void dealloc_tmp_method_store(void *store)
  58 {
  59     if (store != NULL)
  60         ossl_method_store_free(store);
  61 }
  62
  63 static OSSL_METHOD_STORE *get_default_method_store(OPENSSL_CTX *libctx)
  64 {
  65     return openssl_ctx_get_data(libctx, OPENSSL_CTX_DEFAULT_METHOD_STORE_INDEX,
  66                                 &default_method_store_method);
  67 }
  68
  69 static void *get_method_from_store(OPENSSL_CTX *libctx, void *store,
  70                                    const char *name, const char *propquery,
  71                                    void *data)
  72 {
  73     struct method_data_st *methdata = data;
  74     void *method = NULL;
  75     OSSL_NAMEMAP *namemap;
  76     int id;
  77
  78     if (store == NULL
  79         && (store = get_default_method_store(libctx)) == NULL)
  80         return NULL;
  81
  82     if ((namemap = ossl_namemap_stored(libctx)) == NULL
  83         || (id = ossl_namemap_add(namemap, name)) == 0)
  84         return NULL;
  85
  86     (void)ossl_method_store_fetch(store, id, propquery, &method);
  87
  88     if (method != NULL
  89         && !methdata->refcnt_up_method(method)) {
  90         method = NULL;
  91     }
  92     return method;
  93 }
  94
  95 static int put_method_in_store(OPENSSL_CTX *libctx, void *store,
  96                                void *method, const char *name,
  97                                const char *propdef, void *data)
  98 {
  99     struct method_data_st *methdata = data;
 100     OSSL_NAMEMAP *namemap;
 101     int id;
 102
 103     if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
 104         || (id = ossl_namemap_add(namemap, name)) == 0)
 105         return 0;
 106
 107     if (store == NULL
 108         && (store = get_default_method_store(libctx)) == NULL)
 109         return 0;
 110
 111     if (methdata->refcnt_up_method(method)
 112         && ossl_method_store_add(store, id, propdef, method,
 113                                  methdata->destruct_method))
 114         return 1;
 115     return 0;
 116 }
 117
 118 static void *construct_method(const char *name, const OSSL_DISPATCH *fns,
 119                               OSSL_PROVIDER *prov, void *data)
 120 {
 121     struct method_data_st *methdata = data;
 122
 123     return methdata->method_from_dispatch(fns, prov);
 124 }
 125
 126 static void destruct_method(void *method, void *data)
 127 {
 128     struct method_data_st *methdata = data;
 129
 130     methdata->destruct_method(method);
 131 }
 132
 133 void *evp_generic_fetch(OPENSSL_CTX *libctx, int operation_id,
 134                         const char *name, const char *properties,
 135                         void *(*new_method)(const OSSL_DISPATCH *fns,
 136                                             OSSL_PROVIDER *prov),
 137                         int (*upref_method)(void *),
 138                         void (*free_method)(void *))
 139 {
 140     OSSL_METHOD_STORE *store = get_default_method_store(libctx);
 141     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
 142     int id;
 143     void *method = NULL;
 144
 145     if (store == NULL || namemap == NULL)
 146         return NULL;
 147
 148     if ((id = ossl_namemap_number(namemap, name)) == 0
 149         || !ossl_method_store_cache_get(store, id, properties, &method)) {
 150         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
 151             alloc_tmp_method_store,
 152             dealloc_tmp_method_store,
 153             get_method_from_store,
 154             put_method_in_store,
 155             construct_method,
 156             destruct_method
 157         };
 158         struct method_data_st mcmdata;
 159
 160         mcmdata.mcm = &mcm;
 161         mcmdata.libctx = libctx;
 162         mcmdata.name = name;
 163         mcmdata.method_from_dispatch = new_method;
 164         mcmdata.destruct_method = free_method;
 165         mcmdata.refcnt_up_method = upref_method;
 166         mcmdata.destruct_method = free_method;
 167         method = ossl_method_construct(libctx, operation_id, name,
 168                                        properties, 0 /* !force_cache */,
 169                                        &mcm, &mcmdata);
 170         ossl_method_store_cache_set(store, id, properties, method);
 171     } else {
 172         upref_method(method);
 173     }
 174
 175     return method;
 176 }
 177
 178 int EVP_set_default_properties(OPENSSL_CTX *libctx, const char *propq)
 179 {
 180     OSSL_METHOD_STORE *store = get_default_method_store(libctx);
 181
 182     if (store != NULL)
 183         return ossl_method_store_set_global_properties(store, propq);
 184     EVPerr(EVP_F_EVP_SET_DEFAULT_PROPERTIES, ERR_R_INTERNAL_ERROR);
 185     return 0;
 186 }