test/provider_pkey_test.c

   1 /*
   2  * Copyright 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 <stddef.h>
  11 #include <string.h>
  12 #include <openssl/provider.h>
  13 #include <openssl/params.h>
  14 #include <openssl/core_names.h>
  15 #include <openssl/evp.h>
  16 #include <openssl/store.h>
  17 #include "testutil.h"
  18 #include "fake_rsaprov.h"
  19
  20 static OSSL_LIB_CTX *libctx = NULL;
  21 extern int key_deleted; /* From fake_rsaprov.c */
  22
  23 /* Fetch SIGNATURE method using a libctx and propq */
  24 static int fetch_sig(OSSL_LIB_CTX *ctx, const char *alg, const char *propq,
  25                      OSSL_PROVIDER *expected_prov)
  26 {
  27     OSSL_PROVIDER *prov;
  28     EVP_SIGNATURE *sig = EVP_SIGNATURE_fetch(ctx, "RSA", propq);
  29     int ret = 0;
  30
  31     if (!TEST_ptr(sig))
  32         return 0;
  33
  34     if (!TEST_ptr(prov = EVP_SIGNATURE_get0_provider(sig)))
  35         goto end;
  36
  37     if (!TEST_ptr_eq(prov, expected_prov)) {
  38         TEST_info("Fetched provider: %s, Expected provider: %s",
  39                   OSSL_PROVIDER_get0_name(prov),
  40                   OSSL_PROVIDER_get0_name(expected_prov));
  41         goto end;
  42     }
  43
  44     ret = 1;
  45 end:
  46     EVP_SIGNATURE_free(sig);
  47     return ret;
  48 }
  49
  50
  51 static int test_pkey_sig(void)
  52 {
  53     OSSL_PROVIDER *deflt = NULL;
  54     OSSL_PROVIDER *fake_rsa = NULL;
  55     int i, ret = 0;
  56     EVP_PKEY *pkey = NULL;
  57     EVP_PKEY_CTX *ctx = NULL;
  58
  59     if (!TEST_ptr(fake_rsa = fake_rsa_start(libctx)))
  60         return 0;
  61
  62     if (!TEST_ptr(deflt = OSSL_PROVIDER_load(libctx, "default")))
  63         goto end;
  64
  65     /* Do a direct fetch to see it works */
  66     if (!TEST_true(fetch_sig(libctx, "RSA", "provider=fake-rsa", fake_rsa))
  67         || !TEST_true(fetch_sig(libctx, "RSA", "?provider=fake-rsa", fake_rsa)))
  68         goto end;
  69
  70     /* Construct a pkey using precise propq to use our provider */
  71     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA",
  72                                                    "provider=fake-rsa"))
  73         || !TEST_true(EVP_PKEY_fromdata_init(ctx))
  74         || !TEST_true(EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEYPAIR, NULL))
  75         || !TEST_ptr(pkey))
  76         goto end;
  77
  78     EVP_PKEY_CTX_free(ctx);
  79     ctx = NULL;
  80
  81     /* try exercising signature_init ops a few times */
  82     for (i = 0; i < 3; i++) {
  83         size_t siglen;
  84
  85         /*
  86          * Create a signing context for our pkey with optional propq.
  87          * The sign init should pick both keymgmt and signature from
  88          * fake-rsa as the key is not exportable.
  89          */
  90         if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey,
  91                                                        "?provider=default")))
  92             goto end;
  93
  94         /*
  95          * If this picks the wrong signature without realizing it
  96          * we can get a segfault or some internal error. At least watch
  97          * whether fake-rsa sign_init is exercised by calling sign.
  98          */
  99         if (!TEST_int_eq(EVP_PKEY_sign_init(ctx), 1))
 100             goto end;
 101
 102         if (!TEST_int_eq(EVP_PKEY_sign(ctx, NULL, &siglen, NULL, 0), 1)
 103             || !TEST_size_t_eq(siglen, 256))
 104             goto end;
 105
 106         EVP_PKEY_CTX_free(ctx);
 107         ctx = NULL;
 108     }
 109
 110     ret = 1;
 111
 112 end:
 113     fake_rsa_finish(fake_rsa);
 114     OSSL_PROVIDER_unload(deflt);
 115     EVP_PKEY_CTX_free(ctx);
 116     EVP_PKEY_free(pkey);
 117     return ret;
 118 }
 119
 120 static int test_alternative_keygen_init(void)
 121 {
 122     EVP_PKEY_CTX *ctx = NULL;
 123     OSSL_PROVIDER *deflt = NULL;
 124     OSSL_PROVIDER *fake_rsa = NULL;
 125     const OSSL_PROVIDER *provider;
 126     const char *provname;
 127     int ret = 0;
 128
 129     if (!TEST_ptr(deflt = OSSL_PROVIDER_load(libctx, "default")))
 130         goto end;
 131
 132     /* first try without the fake RSA provider loaded */
 133     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA", NULL)))
 134         goto end;
 135
 136     if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0))
 137         goto end;
 138
 139     if (!TEST_ptr(provider = EVP_PKEY_CTX_get0_provider(ctx)))
 140         goto end;
 141
 142     if (!TEST_ptr(provname = OSSL_PROVIDER_get0_name(provider)))
 143         goto end;
 144
 145     if (!TEST_str_eq(provname, "default"))
 146         goto end;
 147
 148     EVP_PKEY_CTX_free(ctx);
 149     ctx = NULL;
 150
 151     /* now load fake RSA and try again */
 152     if (!TEST_ptr(fake_rsa = fake_rsa_start(libctx)))
 153         return 0;
 154
 155     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA",
 156                                                    "?provider=fake-rsa")))
 157         goto end;
 158
 159     if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0))
 160         goto end;
 161
 162     if (!TEST_ptr(provider = EVP_PKEY_CTX_get0_provider(ctx)))
 163         goto end;
 164
 165     if (!TEST_ptr(provname = OSSL_PROVIDER_get0_name(provider)))
 166         goto end;
 167
 168     if (!TEST_str_eq(provname, "fake-rsa"))
 169         goto end;
 170
 171     ret = 1;
 172
 173 end:
 174     fake_rsa_finish(fake_rsa);
 175     OSSL_PROVIDER_unload(deflt);
 176     EVP_PKEY_CTX_free(ctx);
 177     return ret;
 178 }
 179
 180 static int test_pkey_eq(void)
 181 {
 182     OSSL_PROVIDER *deflt = NULL;
 183     OSSL_PROVIDER *fake_rsa = NULL;
 184     EVP_PKEY *pkey_fake = NULL;
 185     EVP_PKEY *pkey_dflt = NULL;
 186     EVP_PKEY_CTX *ctx = NULL;
 187     OSSL_PARAM *params = NULL;
 188     int ret = 0;
 189
 190     if (!TEST_ptr(fake_rsa = fake_rsa_start(libctx)))
 191         return 0;
 192
 193     if (!TEST_ptr(deflt = OSSL_PROVIDER_load(libctx, "default")))
 194         goto end;
 195
 196     /* Construct a public key for fake-rsa */
 197     if (!TEST_ptr(params = fake_rsa_key_params(0))
 198         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA",
 199                                                       "provider=fake-rsa"))
 200         || !TEST_true(EVP_PKEY_fromdata_init(ctx))
 201         || !TEST_true(EVP_PKEY_fromdata(ctx, &pkey_fake, EVP_PKEY_PUBLIC_KEY,
 202                                         params))
 203         || !TEST_ptr(pkey_fake))
 204         goto end;
 205
 206     EVP_PKEY_CTX_free(ctx);
 207     ctx = NULL;
 208     OSSL_PARAM_free(params);
 209     params = NULL;
 210
 211     /* Construct a public key for default */
 212     if (!TEST_ptr(params = fake_rsa_key_params(0))
 213         || !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(libctx, "RSA",
 214                                                       "provider=default"))
 215         || !TEST_true(EVP_PKEY_fromdata_init(ctx))
 216         || !TEST_true(EVP_PKEY_fromdata(ctx, &pkey_dflt, EVP_PKEY_PUBLIC_KEY,
 217                                         params))
 218         || !TEST_ptr(pkey_dflt))
 219         goto end;
 220
 221     EVP_PKEY_CTX_free(ctx);
 222     ctx = NULL;
 223     OSSL_PARAM_free(params);
 224     params = NULL;
 225
 226     /* now test for equality */
 227     if (!TEST_int_eq(EVP_PKEY_eq(pkey_fake, pkey_dflt), 1))
 228         goto end;
 229
 230     ret = 1;
 231 end:
 232     fake_rsa_finish(fake_rsa);
 233     OSSL_PROVIDER_unload(deflt);
 234     EVP_PKEY_CTX_free(ctx);
 235     EVP_PKEY_free(pkey_fake);
 236     EVP_PKEY_free(pkey_dflt);
 237     OSSL_PARAM_free(params);
 238     return ret;
 239 }
 240
 241 static int test_pkey_store(int idx)
 242 {
 243     OSSL_PROVIDER *deflt = NULL;
 244     OSSL_PROVIDER *fake_rsa = NULL;
 245     int ret = 0;
 246     EVP_PKEY *pkey = NULL;
 247     OSSL_STORE_LOADER *loader = NULL;
 248     OSSL_STORE_CTX *ctx = NULL;
 249     OSSL_STORE_INFO *info;
 250     const char *propq = idx == 0 ? "?provider=fake-rsa"
 251                                  : "?provider=default";
 252
 253     /* It's important to load the default provider first for this test */
 254     if (!TEST_ptr(deflt = OSSL_PROVIDER_load(libctx, "default")))
 255         goto end;
 256
 257     if (!TEST_ptr(fake_rsa = fake_rsa_start(libctx)))
 258         goto end;
 259
 260     if (!TEST_ptr(loader = OSSL_STORE_LOADER_fetch(libctx, "fake_rsa",
 261                                                    propq)))
 262         goto end;
 263
 264     OSSL_STORE_LOADER_free(loader);
 265
 266     if (!TEST_ptr(ctx = OSSL_STORE_open_ex("fake_rsa:test", libctx, propq,
 267                                            NULL, NULL, NULL, NULL, NULL)))
 268         goto end;
 269
 270     while (!OSSL_STORE_eof(ctx)
 271            && (info = OSSL_STORE_load(ctx)) != NULL
 272            && pkey == NULL) {
 273         if (OSSL_STORE_INFO_get_type(info) == OSSL_STORE_INFO_PKEY)
 274             pkey = OSSL_STORE_INFO_get1_PKEY(info);
 275         OSSL_STORE_INFO_free(info);
 276         info = NULL;
 277     }
 278
 279     if (!TEST_ptr(pkey) || !TEST_int_eq(EVP_PKEY_is_a(pkey, "RSA"), 1))
 280         goto end;
 281
 282     ret = 1;
 283
 284 end:
 285     fake_rsa_finish(fake_rsa);
 286     OSSL_PROVIDER_unload(deflt);
 287     OSSL_STORE_close(ctx);
 288     EVP_PKEY_free(pkey);
 289     return ret;
 290 }
 291
 292 static int test_pkey_delete(void)
 293 {
 294     OSSL_PROVIDER *deflt = NULL;
 295     OSSL_PROVIDER *fake_rsa = NULL;
 296     int ret = 0;
 297     EVP_PKEY *pkey = NULL;
 298     OSSL_STORE_LOADER *loader = NULL;
 299     OSSL_STORE_CTX *ctx = NULL;
 300     OSSL_STORE_INFO *info;
 301     const char *propq = "?provider=fake-rsa";
 302
 303     /* It's important to load the default provider first for this test */
 304     if (!TEST_ptr(deflt = OSSL_PROVIDER_load(libctx, "default")))
 305         goto end;
 306
 307     if (!TEST_ptr(fake_rsa = fake_rsa_start(libctx)))
 308         goto end;
 309
 310     if (!TEST_ptr(loader = OSSL_STORE_LOADER_fetch(libctx, "fake_rsa",
 311                                                    propq)))
 312         goto end;
 313
 314     OSSL_STORE_LOADER_free(loader);
 315
 316     /* First iteration: load key, check it, delete it */
 317     if (!TEST_ptr(ctx = OSSL_STORE_open_ex("fake_rsa:test", libctx, propq,
 318                                            NULL, NULL, NULL, NULL, NULL)))
 319         goto end;
 320
 321     while (!OSSL_STORE_eof(ctx)
 322            && (info = OSSL_STORE_load(ctx)) != NULL
 323            && pkey == NULL) {
 324         if (OSSL_STORE_INFO_get_type(info) == OSSL_STORE_INFO_PKEY)
 325             pkey = OSSL_STORE_INFO_get1_PKEY(info);
 326         OSSL_STORE_INFO_free(info);
 327         info = NULL;
 328     }
 329
 330     if (!TEST_ptr(pkey) || !TEST_int_eq(EVP_PKEY_is_a(pkey, "RSA"), 1))
 331         goto end;
 332     EVP_PKEY_free(pkey);
 333     pkey = NULL;
 334
 335     if (!TEST_int_eq(OSSL_STORE_delete("fake_rsa:test", libctx, propq,
 336                                        NULL, NULL, NULL), 1))
 337         goto end;
 338     if (!TEST_int_eq(OSSL_STORE_close(ctx), 1))
 339         goto end;
 340
 341     /* Second iteration: load key should fail */
 342     if (!TEST_ptr(ctx = OSSL_STORE_open_ex("fake_rsa:test", libctx, propq,
 343                                            NULL, NULL, NULL, NULL, NULL)))
 344         goto end;
 345
 346     while (!OSSL_STORE_eof(ctx)) {
 347            info = OSSL_STORE_load(ctx);
 348            if (!TEST_ptr_null(info))
 349                goto end;
 350     }
 351
 352     ret = 1;
 353
 354 end:
 355     fake_rsa_finish(fake_rsa);
 356     OSSL_PROVIDER_unload(deflt);
 357     OSSL_STORE_close(ctx);
 358     fake_rsa_restore_store_state();
 359     return ret;
 360 }
 361
 362 int setup_tests(void)
 363 {
 364     libctx = OSSL_LIB_CTX_new();
 365     if (libctx == NULL)
 366         return 0;
 367
 368     ADD_TEST(test_pkey_sig);
 369     ADD_TEST(test_alternative_keygen_init);
 370     ADD_TEST(test_pkey_eq);
 371     ADD_ALL_TESTS(test_pkey_store, 2);
 372     ADD_TEST(test_pkey_delete);
 373
 374     return 1;
 375 }
 376
 377 void cleanup_tests(void)
 378 {
 379     OSSL_LIB_CTX_free(libctx);
 380 }