crypto/evp/kdf_meth.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 <openssl/evp.h>
  11 #include <openssl/err.h>
  12 #include <openssl/core.h>
  13 #include <openssl/core_dispatch.h>
  14 #include <openssl/kdf.h>
  15 #include "internal/provider.h"
  16 #include "internal/core.h"
  17 #include "crypto/evp.h"
  18 #include "evp_local.h"
  19
  20 static int evp_kdf_up_ref(void *vkdf)
  21 {
  22     EVP_KDF *kdf = (EVP_KDF *)vkdf;
  23     int ref = 0;
  24
  25     CRYPTO_UP_REF(&kdf->refcnt, &ref);
  26     return 1;
  27 }
  28
  29 static void evp_kdf_free(void *vkdf)
  30 {
  31     EVP_KDF *kdf = (EVP_KDF *)vkdf;
  32     int ref = 0;
  33
  34     if (kdf == NULL)
  35         return;
  36
  37     CRYPTO_DOWN_REF(&kdf->refcnt, &ref);
  38     if (ref > 0)
  39         return;
  40     OPENSSL_free(kdf->type_name);
  41     ossl_provider_free(kdf->prov);
  42     CRYPTO_FREE_REF(&kdf->refcnt);
  43     OPENSSL_free(kdf);
  44 }
  45
  46 static void *evp_kdf_new(void)
  47 {
  48     EVP_KDF *kdf = NULL;
  49
  50     if ((kdf = OPENSSL_zalloc(sizeof(*kdf))) == NULL
  51         || !CRYPTO_NEW_REF(&kdf->refcnt, 1)) {
  52         OPENSSL_free(kdf);
  53         return NULL;
  54     }
  55     return kdf;
  56 }
  57
  58 static void *evp_kdf_from_algorithm(int name_id,
  59                                     const OSSL_ALGORITHM *algodef,
  60                                     OSSL_PROVIDER *prov)
  61 {
  62     const OSSL_DISPATCH *fns = algodef->implementation;
  63     EVP_KDF *kdf = NULL;
  64     int fnkdfcnt = 0, fnctxcnt = 0;
  65
  66     if ((kdf = evp_kdf_new()) == NULL) {
  67         ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
  68         return NULL;
  69     }
  70     kdf->name_id = name_id;
  71     if ((kdf->type_name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
  72         evp_kdf_free(kdf);
  73         return NULL;
  74     }
  75     kdf->description = algodef->algorithm_description;
  76
  77     for (; fns->function_id != 0; fns++) {
  78         switch (fns->function_id) {
  79         case OSSL_FUNC_KDF_NEWCTX:
  80             if (kdf->newctx != NULL)
  81                 break;
  82             kdf->newctx = OSSL_FUNC_kdf_newctx(fns);
  83             fnctxcnt++;
  84             break;
  85         case OSSL_FUNC_KDF_DUPCTX:
  86             if (kdf->dupctx != NULL)
  87                 break;
  88             kdf->dupctx = OSSL_FUNC_kdf_dupctx(fns);
  89             break;
  90         case OSSL_FUNC_KDF_FREECTX:
  91             if (kdf->freectx != NULL)
  92                 break;
  93             kdf->freectx = OSSL_FUNC_kdf_freectx(fns);
  94             fnctxcnt++;
  95             break;
  96         case OSSL_FUNC_KDF_RESET:
  97             if (kdf->reset != NULL)
  98                 break;
  99             kdf->reset = OSSL_FUNC_kdf_reset(fns);
 100             break;
 101         case OSSL_FUNC_KDF_DERIVE:
 102             if (kdf->derive != NULL)
 103                 break;
 104             kdf->derive = OSSL_FUNC_kdf_derive(fns);
 105             fnkdfcnt++;
 106             break;
 107         case OSSL_FUNC_KDF_GETTABLE_PARAMS:
 108             if (kdf->gettable_params != NULL)
 109                 break;
 110             kdf->gettable_params =
 111                 OSSL_FUNC_kdf_gettable_params(fns);
 112             break;
 113         case OSSL_FUNC_KDF_GETTABLE_CTX_PARAMS:
 114             if (kdf->gettable_ctx_params != NULL)
 115                 break;
 116             kdf->gettable_ctx_params =
 117                 OSSL_FUNC_kdf_gettable_ctx_params(fns);
 118             break;
 119         case OSSL_FUNC_KDF_SETTABLE_CTX_PARAMS:
 120             if (kdf->settable_ctx_params != NULL)
 121                 break;
 122             kdf->settable_ctx_params =
 123                 OSSL_FUNC_kdf_settable_ctx_params(fns);
 124             break;
 125         case OSSL_FUNC_KDF_GET_PARAMS:
 126             if (kdf->get_params != NULL)
 127                 break;
 128             kdf->get_params = OSSL_FUNC_kdf_get_params(fns);
 129             break;
 130         case OSSL_FUNC_KDF_GET_CTX_PARAMS:
 131             if (kdf->get_ctx_params != NULL)
 132                 break;
 133             kdf->get_ctx_params = OSSL_FUNC_kdf_get_ctx_params(fns);
 134             break;
 135         case OSSL_FUNC_KDF_SET_CTX_PARAMS:
 136             if (kdf->set_ctx_params != NULL)
 137                 break;
 138             kdf->set_ctx_params = OSSL_FUNC_kdf_set_ctx_params(fns);
 139             break;
 140         }
 141     }
 142     if (fnkdfcnt != 1 || fnctxcnt != 2) {
 143         /*
 144          * In order to be a consistent set of functions we must have at least
 145          * a derive function, and a complete set of context management
 146          * functions.
 147          */
 148         evp_kdf_free(kdf);
 149         ERR_raise(ERR_LIB_EVP, EVP_R_INVALID_PROVIDER_FUNCTIONS);
 150         return NULL;
 151     }
 152     kdf->prov = prov;
 153     if (prov != NULL)
 154         ossl_provider_up_ref(prov);
 155
 156     return kdf;
 157 }
 158
 159 EVP_KDF *EVP_KDF_fetch(OSSL_LIB_CTX *libctx, const char *algorithm,
 160                        const char *properties)
 161 {
 162     return evp_generic_fetch(libctx, OSSL_OP_KDF, algorithm, properties,
 163                              evp_kdf_from_algorithm, evp_kdf_up_ref,
 164                              evp_kdf_free);
 165 }
 166
 167 int EVP_KDF_up_ref(EVP_KDF *kdf)
 168 {
 169     return evp_kdf_up_ref(kdf);
 170 }
 171
 172 void EVP_KDF_free(EVP_KDF *kdf)
 173 {
 174     evp_kdf_free(kdf);
 175 }
 176
 177 const OSSL_PARAM *EVP_KDF_gettable_params(const EVP_KDF *kdf)
 178 {
 179     if (kdf->gettable_params == NULL)
 180         return NULL;
 181     return kdf->gettable_params(ossl_provider_ctx(EVP_KDF_get0_provider(kdf)));
 182 }
 183
 184 const OSSL_PARAM *EVP_KDF_gettable_ctx_params(const EVP_KDF *kdf)
 185 {
 186     void *alg;
 187
 188     if (kdf->gettable_ctx_params == NULL)
 189         return NULL;
 190     alg = ossl_provider_ctx(EVP_KDF_get0_provider(kdf));
 191     return kdf->gettable_ctx_params(NULL, alg);
 192 }
 193
 194 const OSSL_PARAM *EVP_KDF_settable_ctx_params(const EVP_KDF *kdf)
 195 {
 196     void *alg;
 197
 198     if (kdf->settable_ctx_params == NULL)
 199         return NULL;
 200     alg = ossl_provider_ctx(EVP_KDF_get0_provider(kdf));
 201     return kdf->settable_ctx_params(NULL, alg);
 202 }
 203
 204 const OSSL_PARAM *EVP_KDF_CTX_gettable_params(EVP_KDF_CTX *ctx)
 205 {
 206     void *alg;
 207
 208     if (ctx->meth->gettable_ctx_params == NULL)
 209         return NULL;
 210     alg = ossl_provider_ctx(EVP_KDF_get0_provider(ctx->meth));
 211     return ctx->meth->gettable_ctx_params(ctx->algctx, alg);
 212 }
 213
 214 const OSSL_PARAM *EVP_KDF_CTX_settable_params(EVP_KDF_CTX *ctx)
 215 {
 216     void *alg;
 217
 218     if (ctx->meth->settable_ctx_params == NULL)
 219         return NULL;
 220     alg = ossl_provider_ctx(EVP_KDF_get0_provider(ctx->meth));
 221     return ctx->meth->settable_ctx_params(ctx->algctx, alg);
 222 }
 223
 224 void EVP_KDF_do_all_provided(OSSL_LIB_CTX *libctx,
 225                              void (*fn)(EVP_KDF *kdf, void *arg),
 226                              void *arg)
 227 {
 228     evp_generic_do_all(libctx, OSSL_OP_KDF,
 229                        (void (*)(void *, void *))fn, arg,
 230                        evp_kdf_from_algorithm, evp_kdf_up_ref, evp_kdf_free);
 231 }