Coverage Report

Created: 2025-06-13 06:58

/src/openssl30/providers/implementations/rands/test_rng.c
Line
Count
Source (jump to first uncovered line)
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 <string.h>
11
#include <openssl/core_dispatch.h>
12
#include <openssl/e_os2.h>
13
#include <openssl/params.h>
14
#include <openssl/core_names.h>
15
#include <openssl/evp.h>
16
#include <openssl/err.h>
17
#include <openssl/randerr.h>
18
#include "prov/providercommon.h"
19
#include "prov/provider_ctx.h"
20
#include "prov/provider_util.h"
21
#include "prov/implementations.h"
22
23
static OSSL_FUNC_rand_newctx_fn test_rng_new;
24
static OSSL_FUNC_rand_freectx_fn test_rng_free;
25
static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate;
26
static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate;
27
static OSSL_FUNC_rand_generate_fn test_rng_generate;
28
static OSSL_FUNC_rand_reseed_fn test_rng_reseed;
29
static OSSL_FUNC_rand_nonce_fn test_rng_nonce;
30
static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params;
31
static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params;
32
static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params;
33
static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params;
34
static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization;
35
static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking;
36
static OSSL_FUNC_rand_lock_fn test_rng_lock;
37
static OSSL_FUNC_rand_unlock_fn test_rng_unlock;
38
static OSSL_FUNC_rand_get_seed_fn test_rng_get_seed;
39
40
typedef struct {
41
    void *provctx;
42
    int state;
43
    unsigned int strength;
44
    size_t max_request;
45
    unsigned char *entropy, *nonce;
46
    size_t entropy_len, entropy_pos, nonce_len;
47
    CRYPTO_RWLOCK *lock;
48
} PROV_TEST_RNG;
49
50
static void *test_rng_new(void *provctx, void *parent,
51
                          const OSSL_DISPATCH *parent_dispatch)
52
60
{
53
60
    PROV_TEST_RNG *t;
54
55
60
    t = OPENSSL_zalloc(sizeof(*t));
56
60
    if (t == NULL)
57
0
        return NULL;
58
59
60
    t->max_request = INT_MAX;
60
60
    t->provctx = provctx;
61
60
    t->state = EVP_RAND_STATE_UNINITIALISED;
62
60
    return t;
63
60
}
64
65
static void test_rng_free(void *vtest)
66
60
{
67
60
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
68
69
60
    if (t == NULL)
70
0
        return;
71
60
    OPENSSL_free(t->entropy);
72
60
    OPENSSL_free(t->nonce);
73
60
    CRYPTO_THREAD_lock_free(t->lock);
74
60
    OPENSSL_free(t);
75
60
}
76
77
static int test_rng_instantiate(void *vtest, unsigned int strength,
78
                                int prediction_resistance,
79
                                const unsigned char *pstr, size_t pstr_len,
80
                                const OSSL_PARAM params[])
81
0
{
82
0
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
83
84
0
    if (!test_rng_set_ctx_params(t, params) || strength > t->strength)
85
0
        return 0;
86
87
0
    t->state = EVP_RAND_STATE_READY;
88
0
    t->entropy_pos = 0;
89
90
0
    return 1;
91
0
}
92
93
static int test_rng_uninstantiate(void *vtest)
94
0
{
95
0
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
96
97
0
    t->entropy_pos = 0;
98
0
    t->state = EVP_RAND_STATE_UNINITIALISED;
99
0
    return 1;
100
0
}
101
102
static int test_rng_generate(void *vtest, unsigned char *out, size_t outlen,
103
                             unsigned int strength, int prediction_resistance,
104
                             const unsigned char *adin, size_t adin_len)
105
{
106
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
107
108
    if (strength > t->strength || t->entropy_len - t->entropy_pos < outlen)
109
        return 0;
110
    memcpy(out, t->entropy + t->entropy_pos, outlen);
111
    t->entropy_pos += outlen;
112
    return 1;
113
}
114
115
static int test_rng_reseed(ossl_unused void *vtest,
116
                           ossl_unused int prediction_resistance,
117
                           ossl_unused const unsigned char *ent,
118
                           ossl_unused size_t ent_len,
119
                           ossl_unused const unsigned char *adin,
120
                           ossl_unused size_t adin_len)
121
29
{
122
29
    return 1;
123
29
}
124
125
static size_t test_rng_nonce(void *vtest, unsigned char *out,
126
                             unsigned int strength,
127
                             ossl_unused size_t min_noncelen,
128
                             size_t max_noncelen)
129
0
{
130
0
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
131
0
    size_t i;
132
133
0
    if (t->nonce == NULL || strength > t->strength)
134
0
        return 0;
135
136
0
    i = t->nonce_len > max_noncelen ? max_noncelen : t->nonce_len;
137
0
    if (out != NULL)
138
0
        memcpy(out, t->nonce, i);
139
0
    return i;
140
0
}
141
142
static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
143
0
{
144
0
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
145
0
    OSSL_PARAM *p;
146
147
0
    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
148
0
    if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
149
0
        return 0;
150
151
0
    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
152
0
    if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
153
0
        return 0;
154
155
0
    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
156
0
    if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
157
0
        return 0;
158
0
    return 1;
159
0
}
160
161
static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
162
                                                      ossl_unused void *provctx)
163
0
{
164
0
    static const OSSL_PARAM known_gettable_ctx_params[] = {
165
0
        OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
166
0
        OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
167
0
        OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
168
0
        OSSL_PARAM_END
169
0
    };
170
0
    return known_gettable_ctx_params;
171
0
}
172
173
static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
174
{
175
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
176
    const OSSL_PARAM *p;
177
    void *ptr = NULL;
178
    size_t size = 0;
179
180
    if (params == NULL)
181
        return 1;
182
183
    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
184
    if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
185
        return 0;
186
187
    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
188
    if (p != NULL) {
189
        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
190
            return 0;
191
        OPENSSL_free(t->entropy);
192
        t->entropy = ptr;
193
        t->entropy_len = size;
194
        t->entropy_pos = 0;
195
        ptr = NULL;
196
    }
197
198
    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE);
199
    if (p != NULL) {
200
        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
201
            return 0;
202
        OPENSSL_free(t->nonce);
203
        t->nonce = ptr;
204
        t->nonce_len = size;
205
    }
206
207
    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
208
    if (p != NULL  && !OSSL_PARAM_get_size_t(p, &t->max_request))
209
        return 0;
210
211
    return 1;
212
}
213
214
static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest,
215
                                                      ossl_unused void *provctx)
216
60
{
217
60
    static const OSSL_PARAM known_settable_ctx_params[] = {
218
60
        OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
219
60
        OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
220
60
        OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
221
60
        OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
222
60
        OSSL_PARAM_END
223
60
    };
224
60
    return known_settable_ctx_params;
225
60
}
226
227
static int test_rng_verify_zeroization(ossl_unused void *vtest)
228
0
{
229
0
    return 1;
230
0
}
231
232
static size_t test_rng_get_seed(void *vtest, unsigned char **pout,
233
                                int entropy, size_t min_len, size_t max_len,
234
                                ossl_unused int prediction_resistance,
235
                                ossl_unused const unsigned char *adin,
236
                                ossl_unused size_t adin_len)
237
0
{
238
0
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
239
240
0
    *pout = t->entropy;
241
0
    return  t->entropy_len > max_len ? max_len : t->entropy_len;
242
0
}
243
244
static int test_rng_enable_locking(void *vtest)
245
0
{
246
0
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
247
248
0
    if (t != NULL && t->lock == NULL) {
249
0
        t->lock = CRYPTO_THREAD_lock_new();
250
0
        if (t->lock == NULL) {
251
0
            ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
252
0
            return 0;
253
0
        }
254
0
    }
255
0
    return 1;
256
0
}
257
258
static int test_rng_lock(void *vtest)
259
149
{
260
149
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
261
262
149
    if (t == NULL || t->lock == NULL)
263
149
        return 1;
264
0
    return CRYPTO_THREAD_write_lock(t->lock);
265
149
}
266
267
static void test_rng_unlock(void *vtest)
268
149
{
269
149
    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
270
271
149
    if (t != NULL && t->lock != NULL)
272
0
        CRYPTO_THREAD_unlock(t->lock);
273
149
}
274
275
const OSSL_DISPATCH ossl_test_rng_functions[] = {
276
    { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new },
277
    { OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free },
278
    { OSSL_FUNC_RAND_INSTANTIATE,
279
      (void(*)(void))test_rng_instantiate },
280
    { OSSL_FUNC_RAND_UNINSTANTIATE,
281
      (void(*)(void))test_rng_uninstantiate },
282
    { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate },
283
    { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed },
284
    { OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce },
285
    { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking },
286
    { OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock },
287
    { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock },
288
    { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
289
      (void(*)(void))test_rng_settable_ctx_params },
290
    { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params },
291
    { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
292
      (void(*)(void))test_rng_gettable_ctx_params },
293
    { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))test_rng_get_ctx_params },
294
    { OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
295
      (void(*)(void))test_rng_verify_zeroization },
296
    { OSSL_FUNC_RAND_GET_SEED, (void(*)(void))test_rng_get_seed },
297
    { 0, NULL }
298
};