Coverage Report

Created: 2024-11-21 07:03

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