1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
* Copyright 2021 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* https://www.openssl.org/source/license.html
* or in the file LICENSE in the source distribution.
*/
#include <string.h>
#include <openssl/core_names.h>
#include <openssl/rand.h>
#include <openssl/provider.h>
#include "../testutil.h"
typedef struct {
int (*cb)(unsigned char *out, size_t outlen);
int state;
} FAKE_RAND;
static FAKE_RAND fake_rand;
static OSSL_FUNC_rand_newctx_fn fake_rand_newctx;
static OSSL_FUNC_rand_freectx_fn fake_rand_freectx;
static OSSL_FUNC_rand_instantiate_fn fake_rand_instantiate;
static OSSL_FUNC_rand_uninstantiate_fn fake_rand_uninstantiate;
static OSSL_FUNC_rand_generate_fn fake_rand_generate;
static OSSL_FUNC_rand_gettable_ctx_params_fn fake_rand_gettable_ctx_params;
static OSSL_FUNC_rand_get_ctx_params_fn fake_rand_get_ctx_params;
static OSSL_FUNC_rand_enable_locking_fn fake_rand_enable_locking;
static void *fake_rand_newctx(void *provctx, void *parent,
const OSSL_DISPATCH *parent_dispatch)
{
fake_rand.cb = NULL;
fake_rand.state = EVP_RAND_STATE_UNINITIALISED;
return &fake_rand;
}
static void fake_rand_freectx(void *vrng)
{
FAKE_RAND *frng = (FAKE_RAND *)vrng;
frng->cb = NULL;
frng->state = EVP_RAND_STATE_UNINITIALISED;
}
static int fake_rand_instantiate(void *vrng, ossl_unused unsigned int strength,
ossl_unused int prediction_resistance,
ossl_unused const unsigned char *pstr,
size_t pstr_len)
{
FAKE_RAND *frng = (FAKE_RAND *)vrng;
frng->state = EVP_RAND_STATE_READY;
return 1;
}
static int fake_rand_uninstantiate(void *vrng)
{
FAKE_RAND *frng = (FAKE_RAND *)vrng;
frng->state = EVP_RAND_STATE_UNINITIALISED;
return 1;
}
static int fake_rand_generate(void *vrng, unsigned char *out, size_t outlen,
unsigned int strength, int prediction_resistance,
const unsigned char *adin, size_t adinlen)
{
FAKE_RAND *frng = (FAKE_RAND *)vrng;
size_t l;
uint32_t r;
if (frng->cb != NULL)
return (*frng->cb)(out, outlen);
while (outlen > 0) {
r = test_random();
l = outlen < sizeof(r) ? outlen : sizeof(r);
memcpy(out, &r, l);
out += l;
outlen -= l;
}
return 1;
}
static int fake_rand_enable_locking(void *vrng)
{
return 1;
}
static int fake_rand_get_ctx_params(ossl_unused void *vrng, OSSL_PARAM params[])
{
FAKE_RAND *frng = (FAKE_RAND *)vrng;
OSSL_PARAM *p;
p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
if (p != NULL && !OSSL_PARAM_set_int(p, frng->state))
return 0;
p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
if (p != NULL && !OSSL_PARAM_set_int(p, 256))
return 0;
p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
if (p != NULL && !OSSL_PARAM_set_size_t(p, INT_MAX))
return 0;
return 1;
}
static const OSSL_PARAM *fake_rand_gettable_ctx_params(void *vrng)
{
static const OSSL_PARAM known_gettable_ctx_params[] = {
OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
OSSL_PARAM_END
};
return known_gettable_ctx_params;
}
static const OSSL_DISPATCH fake_rand_functions[] = {
{ OSSL_FUNC_RAND_NEWCTX, (void (*)(void))fake_rand_newctx },
{ OSSL_FUNC_RAND_FREECTX, (void (*)(void))fake_rand_freectx },
{ OSSL_FUNC_RAND_INSTANTIATE, (void (*)(void))fake_rand_instantiate },
{ OSSL_FUNC_RAND_UNINSTANTIATE, (void (*)(void))fake_rand_uninstantiate },
{ OSSL_FUNC_RAND_GENERATE, (void (*)(void))fake_rand_generate },
{ OSSL_FUNC_RAND_ENABLE_LOCKING, (void (*)(void))fake_rand_enable_locking },
{ OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
(void(*)(void))fake_rand_gettable_ctx_params },
{ OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))fake_rand_get_ctx_params },
{ 0, NULL }
};
static const OSSL_ALGORITHM fake_rand_rand[] = {
{ "FAKE", "provider=fake", fake_rand_functions },
{ NULL, NULL, NULL }
};
static const OSSL_ALGORITHM *fake_rand_query(void *provctx,
int operation_id,
int *no_cache)
{
*no_cache = 0;
switch (operation_id) {
case OSSL_OP_RAND:
return fake_rand_rand;
}
return NULL;
}
/* Functions we provide to the core */
static const OSSL_DISPATCH fake_rand_method[] = {
{ OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OSSL_LIB_CTX_free },
{ OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fake_rand_query },
{ 0, NULL }
};
static int fake_rand_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out, void **provctx)
{
if (!TEST_ptr(*provctx = OSSL_LIB_CTX_new()))
return 0;
*out = fake_rand_method;
return 1;
}
OSSL_PROVIDER *fake_rand_start(OSSL_LIB_CTX *libctx)
{
OSSL_PROVIDER *p;
if (!TEST_true(OSSL_PROVIDER_add_builtin(libctx, "fake-rand",
fake_rand_provider_init))
|| !TEST_true(RAND_set_DRBG_type(libctx, "fake", NULL, NULL, NULL))
|| !TEST_ptr(p = OSSL_PROVIDER_try_load(libctx, "fake-rand", 1)))
return NULL;
return p;
}
void fake_rand_finish(OSSL_PROVIDER *p)
{
OSSL_PROVIDER_unload(p);
}
void fake_rand_set_callback(int (*cb)(unsigned char *out, size_t outlen))
{
fake_rand.cb = cb;
}
|
