xref: /freebsd/crypto/openssl/test/fake_rsaprov.c (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a)
1 /*
2  * Copyright 2021-2022 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * https://www.openssl.org/source/license.html
8  * or in the file LICENSE in the source distribution.
9  */
10 
11 #include <string.h>
12 #include <openssl/core_names.h>
13 #include <openssl/core_object.h>
14 #include <openssl/rand.h>
15 #include <openssl/provider.h>
16 #include "testutil.h"
17 #include "fake_rsaprov.h"
18 
19 static OSSL_FUNC_keymgmt_new_fn fake_rsa_keymgmt_new;
20 static OSSL_FUNC_keymgmt_free_fn fake_rsa_keymgmt_free;
21 static OSSL_FUNC_keymgmt_has_fn fake_rsa_keymgmt_has;
22 static OSSL_FUNC_keymgmt_query_operation_name_fn fake_rsa_keymgmt_query;
23 static OSSL_FUNC_keymgmt_import_fn fake_rsa_keymgmt_import;
24 static OSSL_FUNC_keymgmt_import_types_fn fake_rsa_keymgmt_imptypes;
25 static OSSL_FUNC_keymgmt_export_fn fake_rsa_keymgmt_export;
26 static OSSL_FUNC_keymgmt_export_types_fn fake_rsa_keymgmt_exptypes;
27 static OSSL_FUNC_keymgmt_load_fn fake_rsa_keymgmt_load;
28 
29 static int has_selection;
30 static int imptypes_selection;
31 static int exptypes_selection;
32 static int query_id;
33 
34 struct fake_rsa_keydata {
35     int selection;
36     int status;
37 };
38 
39 static void *fake_rsa_keymgmt_new(void *provctx)
40 {
41     struct fake_rsa_keydata *key;
42 
43     if (!TEST_ptr(key = OPENSSL_zalloc(sizeof(struct fake_rsa_keydata))))
44         return NULL;
45 
46     /* clear test globals */
47     has_selection = 0;
48     imptypes_selection = 0;
49     exptypes_selection = 0;
50     query_id = 0;
51 
52     return key;
53 }
54 
55 static void fake_rsa_keymgmt_free(void *keydata)
56 {
57     OPENSSL_free(keydata);
58 }
59 
60 static int fake_rsa_keymgmt_has(const void *key, int selection)
61 {
62     /* record global for checking */
63     has_selection = selection;
64 
65     return 1;
66 }
67 
68 
69 static const char *fake_rsa_keymgmt_query(int id)
70 {
71     /* record global for checking */
72     query_id = id;
73 
74     return "RSA";
75 }
76 
77 static int fake_rsa_keymgmt_import(void *keydata, int selection,
78                                    const OSSL_PARAM *p)
79 {
80     struct fake_rsa_keydata *fake_rsa_key = keydata;
81 
82     /* key was imported */
83     fake_rsa_key->status = 1;
84 
85     return 1;
86 }
87 
88 static unsigned char fake_rsa_n[] =
89    "\x00\xAA\x36\xAB\xCE\x88\xAC\xFD\xFF\x55\x52\x3C\x7F\xC4\x52\x3F"
90    "\x90\xEF\xA0\x0D\xF3\x77\x4A\x25\x9F\x2E\x62\xB4\xC5\xD9\x9C\xB5"
91    "\xAD\xB3\x00\xA0\x28\x5E\x53\x01\x93\x0E\x0C\x70\xFB\x68\x76\x93"
92    "\x9C\xE6\x16\xCE\x62\x4A\x11\xE0\x08\x6D\x34\x1E\xBC\xAC\xA0\xA1"
93    "\xF5";
94 
95 static unsigned char fake_rsa_e[] = "\x11";
96 
97 static unsigned char fake_rsa_d[] =
98     "\x0A\x03\x37\x48\x62\x64\x87\x69\x5F\x5F\x30\xBC\x38\xB9\x8B\x44"
99     "\xC2\xCD\x2D\xFF\x43\x40\x98\xCD\x20\xD8\xA1\x38\xD0\x90\xBF\x64"
100     "\x79\x7C\x3F\xA7\xA2\xCD\xCB\x3C\xD1\xE0\xBD\xBA\x26\x54\xB4\xF9"
101     "\xDF\x8E\x8A\xE5\x9D\x73\x3D\x9F\x33\xB3\x01\x62\x4A\xFD\x1D\x51";
102 
103 static unsigned char fake_rsa_p[] =
104     "\x00\xD8\x40\xB4\x16\x66\xB4\x2E\x92\xEA\x0D\xA3\xB4\x32\x04\xB5"
105     "\xCF\xCE\x33\x52\x52\x4D\x04\x16\xA5\xA4\x41\xE7\x00\xAF\x46\x12"
106     "\x0D";
107 
108 static unsigned char fake_rsa_q[] =
109     "\x00\xC9\x7F\xB1\xF0\x27\xF4\x53\xF6\x34\x12\x33\xEA\xAA\xD1\xD9"
110     "\x35\x3F\x6C\x42\xD0\x88\x66\xB1\xD0\x5A\x0F\x20\x35\x02\x8B\x9D"
111     "\x89";
112 
113 static unsigned char fake_rsa_dmp1[] =
114     "\x59\x0B\x95\x72\xA2\xC2\xA9\xC4\x06\x05\x9D\xC2\xAB\x2F\x1D\xAF"
115     "\xEB\x7E\x8B\x4F\x10\xA7\x54\x9E\x8E\xED\xF5\xB4\xFC\xE0\x9E\x05";
116 
117 static unsigned char fake_rsa_dmq1[] =
118     "\x00\x8E\x3C\x05\x21\xFE\x15\xE0\xEA\x06\xA3\x6F\xF0\xF1\x0C\x99"
119     "\x52\xC3\x5B\x7A\x75\x14\xFD\x32\x38\xB8\x0A\xAD\x52\x98\x62\x8D"
120     "\x51";
121 
122 static unsigned char fake_rsa_iqmp[] =
123     "\x36\x3F\xF7\x18\x9D\xA8\xE9\x0B\x1D\x34\x1F\x71\xD0\x9B\x76\xA8"
124     "\xA9\x43\xE1\x1D\x10\xB2\x4D\x24\x9F\x2D\xEA\xFE\xF8\x0C\x18\x26";
125 
126 OSSL_PARAM *fake_rsa_key_params(int priv)
127 {
128     if (priv) {
129         OSSL_PARAM params[] = {
130             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_N, fake_rsa_n,
131                           sizeof(fake_rsa_n) -1),
132             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, fake_rsa_e,
133                           sizeof(fake_rsa_e) -1),
134             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_D, fake_rsa_d,
135                           sizeof(fake_rsa_d) -1),
136             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR1, fake_rsa_p,
137                           sizeof(fake_rsa_p) -1),
138             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR2, fake_rsa_q,
139                           sizeof(fake_rsa_q) -1),
140             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT1, fake_rsa_dmp1,
141                           sizeof(fake_rsa_dmp1) -1),
142             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT2, fake_rsa_dmq1,
143                           sizeof(fake_rsa_dmq1) -1),
144             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, fake_rsa_iqmp,
145                           sizeof(fake_rsa_iqmp) -1),
146             OSSL_PARAM_END
147         };
148         return OSSL_PARAM_dup(params);
149     } else {
150         OSSL_PARAM params[] = {
151             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_N, fake_rsa_n,
152                           sizeof(fake_rsa_n) -1),
153             OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, fake_rsa_e,
154                           sizeof(fake_rsa_e) -1),
155             OSSL_PARAM_END
156         };
157         return OSSL_PARAM_dup(params);
158     }
159 }
160 
161 static int fake_rsa_keymgmt_export(void *keydata, int selection,
162                                    OSSL_CALLBACK *param_callback, void *cbarg)
163 {
164     OSSL_PARAM *params = NULL;
165     int ret;
166 
167     if (selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY)
168         return 0;
169 
170     if (!TEST_ptr(params = fake_rsa_key_params(0)))
171         return 0;
172 
173     ret = param_callback(params, cbarg);
174     OSSL_PARAM_free(params);
175     return ret;
176 }
177 
178 static const OSSL_PARAM fake_rsa_import_key_types[] = {
179     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_N, NULL, 0),
180     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, NULL, 0),
181     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_D, NULL, 0),
182     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR1, NULL, 0),
183     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_FACTOR2, NULL, 0),
184     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT1, NULL, 0),
185     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_EXPONENT2, NULL, 0),
186     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_COEFFICIENT1, NULL, 0),
187     OSSL_PARAM_END
188 };
189 
190 static const OSSL_PARAM *fake_rsa_keymgmt_imptypes(int selection)
191 {
192     /* record global for checking */
193     imptypes_selection = selection;
194 
195     return fake_rsa_import_key_types;
196 }
197 
198 static const OSSL_PARAM fake_rsa_export_key_types[] = {
199     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_N, NULL, 0),
200     OSSL_PARAM_BN(OSSL_PKEY_PARAM_RSA_E, NULL, 0),
201     OSSL_PARAM_END
202 };
203 
204 static const OSSL_PARAM *fake_rsa_keymgmt_exptypes(int selection)
205 {
206     /* record global for checking */
207     exptypes_selection = selection;
208 
209     return fake_rsa_export_key_types;
210 }
211 
212 static void *fake_rsa_keymgmt_load(const void *reference, size_t reference_sz)
213 {
214     struct fake_rsa_keydata *key = NULL;
215 
216     if (reference_sz != sizeof(*key))
217         return NULL;
218 
219     key = *(struct fake_rsa_keydata **)reference;
220     if (key->status != 1)
221         return NULL;
222 
223     /* detach the reference */
224     *(struct fake_rsa_keydata  **)reference = NULL;
225 
226     return key;
227 }
228 
229 static void *fake_rsa_gen_init(void *provctx, int selection,
230                                const OSSL_PARAM params[])
231 {
232     unsigned char *gctx = NULL;
233 
234     if (!TEST_ptr(gctx = OPENSSL_malloc(1)))
235         return NULL;
236 
237     *gctx = 1;
238 
239     return gctx;
240 }
241 
242 static void *fake_rsa_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
243 {
244     unsigned char *gctx = genctx;
245     static const unsigned char inited[] = { 1 };
246     struct fake_rsa_keydata *keydata;
247 
248     if (!TEST_ptr(gctx)
249         || !TEST_mem_eq(gctx, sizeof(*gctx), inited, sizeof(inited)))
250         return NULL;
251 
252     if (!TEST_ptr(keydata = fake_rsa_keymgmt_new(NULL)))
253         return NULL;
254 
255     keydata->status = 2;
256     return keydata;
257 }
258 
259 static void fake_rsa_gen_cleanup(void *genctx)
260 {
261    OPENSSL_free(genctx);
262 }
263 
264 static const OSSL_DISPATCH fake_rsa_keymgmt_funcs[] = {
265     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))fake_rsa_keymgmt_new },
266     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))fake_rsa_keymgmt_free} ,
267     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))fake_rsa_keymgmt_has },
268     { OSSL_FUNC_KEYMGMT_QUERY_OPERATION_NAME,
269         (void (*)(void))fake_rsa_keymgmt_query },
270     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))fake_rsa_keymgmt_import },
271     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES,
272         (void (*)(void))fake_rsa_keymgmt_imptypes },
273     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))fake_rsa_keymgmt_export },
274     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES,
275         (void (*)(void))fake_rsa_keymgmt_exptypes },
276     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))fake_rsa_keymgmt_load },
277     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))fake_rsa_gen_init },
278     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))fake_rsa_gen },
279     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))fake_rsa_gen_cleanup },
280     { 0, NULL }
281 };
282 
283 static const OSSL_ALGORITHM fake_rsa_keymgmt_algs[] = {
284     { "RSA:rsaEncryption", "provider=fake-rsa", fake_rsa_keymgmt_funcs, "Fake RSA Key Management" },
285     { NULL, NULL, NULL, NULL }
286 };
287 
288 static OSSL_FUNC_signature_newctx_fn fake_rsa_sig_newctx;
289 static OSSL_FUNC_signature_freectx_fn fake_rsa_sig_freectx;
290 static OSSL_FUNC_signature_sign_init_fn fake_rsa_sig_sign_init;
291 static OSSL_FUNC_signature_sign_fn fake_rsa_sig_sign;
292 
293 static void *fake_rsa_sig_newctx(void *provctx, const char *propq)
294 {
295     unsigned char *sigctx = OPENSSL_zalloc(1);
296 
297     TEST_ptr(sigctx);
298 
299     return sigctx;
300 }
301 
302 static void fake_rsa_sig_freectx(void *sigctx)
303 {
304     OPENSSL_free(sigctx);
305 }
306 
307 static int fake_rsa_sig_sign_init(void *ctx, void *provkey,
308                                   const OSSL_PARAM params[])
309 {
310     unsigned char *sigctx = ctx;
311     struct fake_rsa_keydata *keydata = provkey;
312 
313     /* we must have a ctx */
314     if (!TEST_ptr(sigctx))
315         return 0;
316 
317     /* we must have some initialized key */
318     if (!TEST_ptr(keydata) || !TEST_int_gt(keydata->status, 0))
319         return 0;
320 
321     /* record that sign init was called */
322     *sigctx = 1;
323     return 1;
324 }
325 
326 static int fake_rsa_sig_sign(void *ctx, unsigned char *sig,
327                              size_t *siglen, size_t sigsize,
328                              const unsigned char *tbs, size_t tbslen)
329 {
330     unsigned char *sigctx = ctx;
331 
332     /* we must have a ctx and init was called upon it */
333     if (!TEST_ptr(sigctx) || !TEST_int_eq(*sigctx, 1))
334         return 0;
335 
336     *siglen = 256;
337     /* record that the real sign operation was called */
338     if (sig != NULL) {
339         if (!TEST_int_ge(sigsize, *siglen))
340             return 0;
341         *sigctx = 2;
342         /* produce a fake signature */
343         memset(sig, 'a', *siglen);
344     }
345 
346     return 1;
347 }
348 
349 static const OSSL_DISPATCH fake_rsa_sig_funcs[] = {
350     { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))fake_rsa_sig_newctx },
351     { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))fake_rsa_sig_freectx },
352     { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))fake_rsa_sig_sign_init },
353     { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))fake_rsa_sig_sign },
354     { 0, NULL }
355 };
356 
357 static const OSSL_ALGORITHM fake_rsa_sig_algs[] = {
358     { "RSA:rsaEncryption", "provider=fake-rsa", fake_rsa_sig_funcs, "Fake RSA Signature" },
359     { NULL, NULL, NULL, NULL }
360 };
361 
362 static OSSL_FUNC_store_open_fn fake_rsa_st_open;
363 static OSSL_FUNC_store_settable_ctx_params_fn fake_rsa_st_settable_ctx_params;
364 static OSSL_FUNC_store_set_ctx_params_fn fake_rsa_st_set_ctx_params;
365 static OSSL_FUNC_store_load_fn fake_rsa_st_load;
366 static OSSL_FUNC_store_eof_fn fake_rsa_st_eof;
367 static OSSL_FUNC_store_close_fn fake_rsa_st_close;
368 
369 static const char fake_rsa_scheme[] = "fake_rsa:";
370 
371 static void *fake_rsa_st_open(void *provctx, const char *uri)
372 {
373     unsigned char *storectx = NULL;
374 
375     /* First check whether the uri is ours */
376     if (strncmp(uri, fake_rsa_scheme, sizeof(fake_rsa_scheme) - 1) != 0)
377         return NULL;
378 
379     storectx = OPENSSL_zalloc(1);
380     if (!TEST_ptr(storectx))
381         return NULL;
382 
383     TEST_info("fake_rsa_open called");
384 
385     return storectx;
386 }
387 
388 static const OSSL_PARAM *fake_rsa_st_settable_ctx_params(void *provctx)
389 {
390     static const OSSL_PARAM known_settable_ctx_params[] = {
391         OSSL_PARAM_END
392     };
393     return known_settable_ctx_params;
394 }
395 
396 static int fake_rsa_st_set_ctx_params(void *loaderctx,
397                                       const OSSL_PARAM params[])
398 {
399     return 1;
400 }
401 
402 static int fake_rsa_st_load(void *loaderctx,
403                             OSSL_CALLBACK *object_cb, void *object_cbarg,
404                             OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
405 {
406     unsigned char *storectx = loaderctx;
407     OSSL_PARAM params[4];
408     int object_type = OSSL_OBJECT_PKEY;
409     struct fake_rsa_keydata *key = NULL;
410     int rv = 0;
411 
412     switch (*storectx) {
413     case 0:
414         /* Construct a new key using our keymgmt functions */
415         if (!TEST_ptr(key = fake_rsa_keymgmt_new(NULL)))
416             break;
417         if (!TEST_int_gt(fake_rsa_keymgmt_import(key, 0, NULL), 0))
418             break;
419         params[0] =
420             OSSL_PARAM_construct_int(OSSL_OBJECT_PARAM_TYPE, &object_type);
421         params[1] =
422             OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_TYPE,
423                                              "RSA", 0);
424         /* The address of the key becomes the octet string */
425         params[2] =
426             OSSL_PARAM_construct_octet_string(OSSL_OBJECT_PARAM_REFERENCE,
427                                               &key, sizeof(*key));
428         params[3] = OSSL_PARAM_construct_end();
429         rv = object_cb(params, object_cbarg);
430         *storectx = 1;
431         break;
432 
433     case 2:
434         TEST_info("fake_rsa_load() called in error state");
435         break;
436 
437     default:
438         TEST_info("fake_rsa_load() called in eof state");
439         break;
440     }
441 
442     TEST_info("fake_rsa_load called - rv: %d", rv);
443 
444     if (rv == 0) {
445         fake_rsa_keymgmt_free(key);
446         *storectx = 2;
447     }
448     return rv;
449 }
450 
451 static int fake_rsa_st_eof(void *loaderctx)
452 {
453     unsigned char *storectx = loaderctx;
454 
455     /* just one key for now in the fake_rsa store */
456     return *storectx != 0;
457 }
458 
459 static int fake_rsa_st_close(void *loaderctx)
460 {
461     OPENSSL_free(loaderctx);
462     return 1;
463 }
464 
465 static const OSSL_DISPATCH fake_rsa_store_funcs[] = {
466     { OSSL_FUNC_STORE_OPEN, (void (*)(void))fake_rsa_st_open },
467     { OSSL_FUNC_STORE_SETTABLE_CTX_PARAMS,
468       (void (*)(void))fake_rsa_st_settable_ctx_params },
469     { OSSL_FUNC_STORE_SET_CTX_PARAMS, (void (*)(void))fake_rsa_st_set_ctx_params },
470     { OSSL_FUNC_STORE_LOAD, (void (*)(void))fake_rsa_st_load },
471     { OSSL_FUNC_STORE_EOF, (void (*)(void))fake_rsa_st_eof },
472     { OSSL_FUNC_STORE_CLOSE, (void (*)(void))fake_rsa_st_close },
473     { 0, NULL },
474 };
475 
476 static const OSSL_ALGORITHM fake_rsa_store_algs[] = {
477     { "fake_rsa", "provider=fake-rsa", fake_rsa_store_funcs },
478     { NULL, NULL, NULL }
479 };
480 
481 static const OSSL_ALGORITHM *fake_rsa_query(void *provctx,
482                                             int operation_id,
483                                             int *no_cache)
484 {
485     *no_cache = 0;
486     switch (operation_id) {
487     case OSSL_OP_SIGNATURE:
488         return fake_rsa_sig_algs;
489 
490     case OSSL_OP_KEYMGMT:
491         return fake_rsa_keymgmt_algs;
492 
493     case OSSL_OP_STORE:
494         return fake_rsa_store_algs;
495     }
496     return NULL;
497 }
498 
499 /* Functions we provide to the core */
500 static const OSSL_DISPATCH fake_rsa_method[] = {
501     { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OSSL_LIB_CTX_free },
502     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))fake_rsa_query },
503     { 0, NULL }
504 };
505 
506 static int fake_rsa_provider_init(const OSSL_CORE_HANDLE *handle,
507                                   const OSSL_DISPATCH *in,
508                                   const OSSL_DISPATCH **out, void **provctx)
509 {
510     if (!TEST_ptr(*provctx = OSSL_LIB_CTX_new()))
511         return 0;
512     *out = fake_rsa_method;
513     return 1;
514 }
515 
516 OSSL_PROVIDER *fake_rsa_start(OSSL_LIB_CTX *libctx)
517 {
518     OSSL_PROVIDER *p;
519 
520     if (!TEST_true(OSSL_PROVIDER_add_builtin(libctx, "fake-rsa",
521                                              fake_rsa_provider_init))
522             || !TEST_ptr(p = OSSL_PROVIDER_try_load(libctx, "fake-rsa", 1)))
523         return NULL;
524 
525     return p;
526 }
527 
528 void fake_rsa_finish(OSSL_PROVIDER *p)
529 {
530     OSSL_PROVIDER_unload(p);
531 }
532