test/fake_rsaprov.c

   1 /*
   2  * Copyright 2021 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 }