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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
|
/*
* Copyright 2021-2022 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"
#include "fake_rsaprov.h"
static OSSL_FUNC_keymgmt_new_fn fake_rsa_keymgmt_new;
static OSSL_FUNC_keymgmt_free_fn fake_rsa_keymgmt_free;
static OSSL_FUNC_keymgmt_has_fn fake_rsa_keymgmt_has;
static OSSL_FUNC_keymgmt_query_operation_name_fn fake_rsa_keymgmt_query;
static OSSL_FUNC_keymgmt_import_fn fake_rsa_keymgmt_import;
static OSSL_FUNC_keymgmt_import_types_fn fake_rsa_keymgmt_imptypes;
static int has_selection;
static int imptypes_selection;
static int query_id;
static void *fake_rsa_keymgmt_new(void *provctx)
{
unsigned char *keydata = OPENSSL_zalloc(1);
TEST_ptr(keydata);
/* clear test globals */
has_selection = 0;
imptypes_selection = 0;
query_id = 0;
return keydata;
}
static void fake_rsa_keymgmt_free(void *keydata)
{
OPENSSL_free(keydata);
}
static int fake_rsa_keymgmt_has(const void *key, int selection)
{
/* record global for checking */
has_selection = selection;
return 1;
}
static const char *fake_rsa_keymgmt_query(int id)
{
/* record global for checking */
query_id = id;
return "RSA";
}
static int fake_rsa_keymgmt_import(void *keydata, int selection,
const OSSL_PARAM *p)
{
unsigned char *fake_rsa_key = keydata;
/* key was imported */
*fake_rsa_key = 1;
return 1;
}
static const OSSL_PARAM fake_rsa_import_key_types[] = {
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_N, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_D, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR1, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR2, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT1, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT2, NULL, 0),
OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, NULL, 0),
OSSL_PARAM_END
};
static const OSSL_PARAM *fake_rsa_keymgmt_imptypes(int selection)
{
/* record global for checking */
imptypes_selection = selection;
return fake_rsa_import_key_types;
}
static void *fake_rsa_gen_init(void *provctx, int selection,
const OSSL_PARAM params[])
{
unsigned char *gctx = NULL;
if (!TEST_ptr(gctx = OPENSSL_malloc(1)))
return NULL;
*gctx = 1;
return gctx;
}
static void *fake_rsa_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
{
unsigned char *gctx = genctx;
static const unsigned char inited[] = { 1 };
unsigned char *keydata;
if (!TEST_ptr(gctx)
|| !TEST_mem_eq(gctx, sizeof(*gctx), inited, sizeof(inited)))
return NULL;
if (!TEST_ptr(keydata = fake_rsa_keymgmt_new(NULL)))
return NULL;
*keydata = 2;
return keydata;
}
static void fake_rsa_gen_cleanup(void *genctx)
{
OPENSSL_free(genctx);
}
static const OSSL_DISPATCH fake_rsa_keymgmt_funcs[] = {
{ OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))fake_rsa_keymgmt_new },
{ OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))fake_rsa_keymgmt_free} ,
{ OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))fake_rsa_keymgmt_has },
{ OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME,
(void (*)(void))fake_rsa_keymgmt_query },
{ OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))fake_rsa_keymgmt_import },
{ OSSL_FUNC_KEYMGMT_IMPORT_TYPES,
(void (*)(void))fake_rsa_keymgmt_imptypes },
{ OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))fake_rsa_gen_init },
{ OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))fake_rsa_gen },
{ OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))fake_rsa_gen_cleanup },
{ 0, NULL }
};
static const OSSL_ALGORITHM fake_rsa_keymgmt_algs[] = {
{ "RSA:rsaEncryption", "provider=fake-rsa", fake_rsa_keymgmt_funcs, "Fake RSA Key Management" },
{ NULL, NULL, NULL, NULL }
};
static OSSL_FUNC_signature_newctx_fn fake_rsa_sig_newctx;
static OSSL_FUNC_signature_freectx_fn fake_rsa_sig_freectx;
static OSSL_FUNC_signature_sign_init_fn fake_rsa_sig_sign_init;
static OSSL_FUNC_signature_sign_fn fake_rsa_sig_sign;
static void *fake_rsa_sig_newctx(void *provctx, const char *propq)
{
unsigned char *sigctx = OPENSSL_zalloc(1);
TEST_ptr(sigctx);
return sigctx;
}
static void fake_rsa_sig_freectx(void *sigctx)
{
OPENSSL_free(sigctx);
}
static int fake_rsa_sig_sign_init(void *ctx, void *provkey,
const OSSL_PARAM params[])
{
unsigned char *sigctx = ctx;
unsigned char *keydata = provkey;
/* we must have a ctx */
if (!TEST_ptr(sigctx))
return 0;
/* we must have some initialized key */
if (!TEST_ptr(keydata) || !TEST_int_gt(keydata[0], 0))
return 0;
/* record that sign init was called */
*sigctx = 1;
return 1;
}
static int fake_rsa_sig_sign(void *ctx, unsigned char *sig,
size_t *siglen, size_t sigsize,
const unsigned char *tbs, size_t tbslen)
{
unsigned char *sigctx = ctx;
/* we must have a ctx and init was called upon it */
if (!TEST_ptr(sigctx) || !TEST_int_eq(*sigctx, 1))
return 0;
*siglen = 256;
/* record that the real sign operation was called */
if (sig != NULL) {
if (!TEST_int_ge(sigsize, *siglen))
return 0;
*sigctx = 2;
/* produce a fake signature */
memset(sig, 'a', *siglen);
}
return 1;
}
static const OSSL_DISPATCH fake_rsa_sig_funcs[] = {
{ OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))fake_rsa_sig_newctx },
{ OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))fake_rsa_sig_freectx },
{ OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))fake_rsa_sig_sign_init },
{ OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))fake_rsa_sig_sign },
{ 0, NULL }
};
static const OSSL_ALGORITHM fake_rsa_sig_algs[] = {
{ "RSA:rsaEncryption", "provider=fake-rsa", fake_rsa_sig_funcs, "Fake RSA Signature" },
{ NULL, NULL, NULL, NULL }
};
static const OSSL_ALGORITHM *fake_rsa_query(void *provctx,
int operation_id,
int *no_cache)
{
*no_cache = 0;
switch (operation_id) {
case OSSL_OP_SIGNATURE:
return fake_rsa_sig_algs;
case OSSL_OP_KEYMGMT:
return fake_rsa_keymgmt_algs;
}
return NULL;
}
/* Functions we provide to the core */
static const OSSL_DISPATCH fake_rsa_method[] = {
{ OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OSSL_LIB_CTX_free },
{ OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fake_rsa_query },
{ 0, NULL }
};
static int fake_rsa_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_rsa_method;
return 1;
}
OSSL_PROVIDER *fake_rsa_start(OSSL_LIB_CTX *libctx)
{
OSSL_PROVIDER *p;
if (!TEST_true(OSSL_PROVIDER_add_builtin(libctx, "fake-rsa",
fake_rsa_provider_init))
|| !TEST_ptr(p = OSSL_PROVIDER_try_load(libctx, "fake-rsa", 1)))
return NULL;
return p;
}
void fake_rsa_finish(OSSL_PROVIDER *p)
{
OSSL_PROVIDER_unload(p);
}
|