test/property_test.c

   1 /*
   2  * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <stdarg.h>
  12 #include <openssl/evp.h>
  13 #include "testutil.h"
  14 #include "internal/nelem.h"
  15 #include "internal/property.h"
  16 #include "../crypto/property/property_local.h"
  17
  18 /*
  19  * We make our OSSL_PROVIDER for testing purposes.  All we really need is
  20  * a pointer.  We know that as long as we don't try to use the method
  21  * cache flush functions, the provider pointer is merely a pointer being
  22  * passed around, and used as a tag of sorts.
  23  */
  24 struct ossl_provider_st {
  25     int x;
  26 };
  27
  28 static int add_property_names(const char *n, ...)
  29 {
  30     va_list args;
  31     int res = 1;
  32
  33     va_start(args, n);
  34     do {
  35         if (!TEST_int_ne(ossl_property_name(NULL, n, 1), 0))
  36             res = 0;
  37     } while ((n = va_arg(args, const char *)) != NULL);
  38     va_end(args);
  39     return res;
  40 }
  41
  42 static int up_ref(void *p)
  43 {
  44     return 1;
  45 }
  46
  47 static void down_ref(void *p)
  48 {
  49 }
  50
  51 static int test_property_string(void)
  52 {
  53     OSSL_LIB_CTX *ctx;
  54     OSSL_METHOD_STORE *store = NULL;
  55     int res = 0;
  56     OSSL_PROPERTY_IDX i, j;
  57
  58     /*-
  59      * Use our own library context because we depend on ordering from a
  60      * pristine state.
  61      */
  62     if (TEST_ptr(ctx = OSSL_LIB_CTX_new())
  63         && TEST_ptr(store = ossl_method_store_new(ctx))
  64         && TEST_int_eq(ossl_property_name(ctx, "fnord", 0), 0)
  65         && TEST_int_ne(ossl_property_name(ctx, "fnord", 1), 0)
  66         && TEST_int_ne(ossl_property_name(ctx, "name", 1), 0)
  67         /* Pre loaded names */
  68         && TEST_str_eq(ossl_property_name_str(ctx, 1), "provider")
  69         && TEST_str_eq(ossl_property_name_str(ctx, 2), "version")
  70         && TEST_str_eq(ossl_property_name_str(ctx, 3), "fips")
  71         && TEST_str_eq(ossl_property_name_str(ctx, 4), "output")
  72         && TEST_str_eq(ossl_property_name_str(ctx, 5), "input")
  73         && TEST_str_eq(ossl_property_name_str(ctx, 6), "structure")
  74         /* The names we added */
  75         && TEST_str_eq(ossl_property_name_str(ctx, 7), "fnord")
  76         && TEST_str_eq(ossl_property_name_str(ctx, 8), "name")
  77         /* Out of range */
  78         && TEST_ptr_null(ossl_property_name_str(ctx, 0))
  79         && TEST_ptr_null(ossl_property_name_str(ctx, 9))
  80         /* Property value checks */
  81         && TEST_int_eq(ossl_property_value(ctx, "fnord", 0), 0)
  82         && TEST_int_ne(i = ossl_property_value(ctx, "no", 0), 0)
  83         && TEST_int_ne(j = ossl_property_value(ctx, "yes", 0), 0)
  84         && TEST_int_ne(i, j)
  85         && TEST_int_eq(ossl_property_value(ctx, "yes", 1), j)
  86         && TEST_int_eq(ossl_property_value(ctx, "no", 1), i)
  87         && TEST_int_ne(i = ossl_property_value(ctx, "illuminati", 1), 0)
  88         && TEST_int_eq(j = ossl_property_value(ctx, "fnord", 1), i + 1)
  89         && TEST_int_eq(ossl_property_value(ctx, "fnord", 1), j)
  90         /* Pre loaded values */
  91         && TEST_str_eq(ossl_property_value_str(ctx, 1), "yes")
  92         && TEST_str_eq(ossl_property_value_str(ctx, 2), "no")
  93         /* The value we added */
  94         && TEST_str_eq(ossl_property_value_str(ctx, 3), "illuminati")
  95         && TEST_str_eq(ossl_property_value_str(ctx, 4), "fnord")
  96         /* Out of range */
  97         && TEST_ptr_null(ossl_property_value_str(ctx, 0))
  98         && TEST_ptr_null(ossl_property_value_str(ctx, 5))
  99         /* Check name and values are distinct */
 100         && TEST_int_eq(ossl_property_value(ctx, "cold", 0), 0)
 101         && TEST_int_ne(ossl_property_name(ctx, "fnord", 0),
 102                        ossl_property_value(ctx, "fnord", 0)))
 103         res = 1;
 104     ossl_method_store_free(store);
 105     OSSL_LIB_CTX_free(ctx);
 106     return res;
 107 }
 108
 109 static const struct {
 110     const char *defn;
 111     const char *query;
 112     int e;
 113 } parser_tests[] = {
 114     { "", "sky=blue", -1 },
 115     { "", "sky!=blue", 1 },
 116     { "groan", "", 0 },
 117     { "cold=yes", "cold=yes", 1 },
 118     { "cold=yes", "cold", 1 },
 119     { "cold=yes", "cold!=no", 1 },
 120     { "groan", "groan=yes", 1 },
 121     { "groan", "groan=no", -1 },
 122     { "groan", "groan!=yes", -1 },
 123     { "cold=no", "cold", -1 },
 124     { "cold=no", "?cold", 0 },
 125     { "cold=no", "cold=no", 1 },
 126     { "groan", "cold", -1 },
 127     { "groan", "cold=no", 1 },
 128     { "groan", "cold!=yes", 1 },
 129     { "groan=blue", "groan=yellow", -1 },
 130     { "groan=blue", "?groan=yellow", 0 },
 131     { "groan=blue", "groan!=yellow", 1 },
 132     { "groan=blue", "?groan!=yellow", 1 },
 133     { "today=monday, tomorrow=3", "today!=2", 1 },
 134     { "today=monday, tomorrow=3", "today!='monday'", -1 },
 135     { "today=monday, tomorrow=3", "tomorrow=3", 1 },
 136     { "n=0x3", "n=3", 1 },
 137     { "n=0x3", "n=-3", -1 },
 138     { "n=0x33", "n=51", 1 },
 139     { "n=033", "n=27", 1 },
 140     { "n=0", "n=00", 1 },
 141     { "n=0x0", "n=0", 1 },
 142     { "n=0, sky=blue", "?n=0, sky=blue", 2 },
 143     { "n=1, sky=blue", "?n=0, sky=blue", 1 },
 144 };
 145
 146 static int test_property_parse(int n)
 147 {
 148     OSSL_METHOD_STORE *store;
 149     OSSL_PROPERTY_LIST *p = NULL, *q = NULL;
 150     int r = 0;
 151
 152     if (TEST_ptr(store = ossl_method_store_new(NULL))
 153         && add_property_names("sky", "groan", "cold", "today", "tomorrow", "n",
 154                               NULL)
 155         && TEST_ptr(p = ossl_parse_property(NULL, parser_tests[n].defn))
 156         && TEST_ptr(q = ossl_parse_query(NULL, parser_tests[n].query, 0))
 157         && TEST_int_eq(ossl_property_match_count(q, p), parser_tests[n].e))
 158         r = 1;
 159     ossl_property_free(p);
 160     ossl_property_free(q);
 161     ossl_method_store_free(store);
 162     return r;
 163 }
 164
 165 static int test_property_query_value_create(void)
 166 {
 167     OSSL_METHOD_STORE *store;
 168     OSSL_PROPERTY_LIST *p = NULL, *q = NULL, *o = NULL;
 169     int r = 0;
 170
 171     /* The property value used here must not be used in other test cases */
 172     if (TEST_ptr(store = ossl_method_store_new(NULL))
 173         && add_property_names("wood", NULL)
 174         && TEST_ptr(p = ossl_parse_query(NULL, "wood=oak", 0)) /* undefined */
 175         && TEST_ptr(q = ossl_parse_query(NULL, "wood=oak", 1)) /* creates */
 176         && TEST_ptr(o = ossl_parse_query(NULL, "wood=oak", 0)) /* defined */
 177         && TEST_int_eq(ossl_property_match_count(q, p), -1)
 178         && TEST_int_eq(ossl_property_match_count(q, o), 1))
 179         r = 1;
 180     ossl_property_free(o);
 181     ossl_property_free(p);
 182     ossl_property_free(q);
 183     ossl_method_store_free(store);
 184     return r;
 185 }
 186
 187 static const struct {
 188     int query;
 189     const char *ps;
 190 } parse_error_tests[] = {
 191     { 0, "n=1, n=1" },          /* duplicate name */
 192     { 0, "n=1, a=hi, n=1" },    /* duplicate name */
 193     { 1, "n=1, a=bye, ?n=0" },  /* duplicate name */
 194     { 0, "a=abc,#@!, n=1" },    /* non-ASCII character located */
 195     { 1, "a='Hello" },          /* Unterminated string */
 196     { 0, "a=\"World" },         /* Unterminated string */
 197     { 1, "a=2, n=012345678" },  /* Bad octal digit */
 198     { 0, "n=0x28FG, a=3" },     /* Bad hex digit */
 199     { 0, "n=145d, a=2" },       /* Bad decimal digit */
 200     { 1, "@='hello'" },         /* Invalid name */
 201     { 1, "n0123456789012345678901234567890123456789"
 202          "0123456789012345678901234567890123456789"
 203          "0123456789012345678901234567890123456789"
 204          "0123456789012345678901234567890123456789=yes" }, /* Name too long */
 205     { 0, ".n=3" },              /* Invalid name */
 206     { 1, "fnord.fnord.=3" }     /* Invalid name */
 207 };
 208
 209 static int test_property_parse_error(int n)
 210 {
 211     OSSL_METHOD_STORE *store;
 212     OSSL_PROPERTY_LIST *p = NULL;
 213     int r = 0;
 214     const char *ps;
 215
 216     if (!TEST_ptr(store = ossl_method_store_new(NULL))
 217         || !add_property_names("a", "n", NULL))
 218         goto err;
 219     ps = parse_error_tests[n].ps;
 220     if (parse_error_tests[n].query) {
 221         if (!TEST_ptr_null(p = ossl_parse_query(NULL, ps, 1)))
 222             goto err;
 223     } else if (!TEST_ptr_null(p = ossl_parse_property(NULL, ps))) {
 224         goto err;
 225     }
 226     r = 1;
 227  err:
 228     ossl_property_free(p);
 229     ossl_method_store_free(store);
 230     return r;
 231 }
 232
 233 static const struct {
 234     const char *q_global;
 235     const char *q_local;
 236     const char *prop;
 237 } merge_tests[] = {
 238     { "", "colour=blue", "colour=blue" },
 239     { "colour=blue", "", "colour=blue" },
 240     { "colour=red", "colour=blue", "colour=blue" },
 241     { "clouds=pink, urn=red", "urn=blue, colour=green",
 242         "urn=blue, colour=green, clouds=pink" },
 243     { "pot=gold", "urn=blue", "pot=gold, urn=blue" },
 244     { "night", "day", "day=yes, night=yes" },
 245     { "day", "night", "day=yes, night=yes" },
 246     { "", "", "" },
 247     /*
 248      * The following four leave 'day' unspecified in the query, and will match
 249      * any definition
 250      */
 251     { "day=yes", "-day", "day=no" },
 252     { "day=yes", "-day", "day=yes" },
 253     { "day=yes", "-day", "day=arglebargle" },
 254     { "day=yes", "-day", "pot=sesquioxidizing" },
 255     { "day, night", "-night, day", "day=yes, night=no" },
 256     { "-day", "day=yes", "day=yes" },
 257 };
 258
 259 static int test_property_merge(int n)
 260 {
 261     OSSL_METHOD_STORE *store;
 262     OSSL_PROPERTY_LIST *q_global = NULL, *q_local = NULL;
 263     OSSL_PROPERTY_LIST *q_combined = NULL, *prop = NULL;
 264     int r = 0;
 265
 266     if (TEST_ptr(store = ossl_method_store_new(NULL))
 267         && add_property_names("colour", "urn", "clouds", "pot", "day", "night",
 268                               NULL)
 269         && TEST_ptr(prop = ossl_parse_property(NULL, merge_tests[n].prop))
 270         && TEST_ptr(q_global = ossl_parse_query(NULL, merge_tests[n].q_global,
 271                                                 0))
 272         && TEST_ptr(q_local = ossl_parse_query(NULL, merge_tests[n].q_local, 0))
 273         && TEST_ptr(q_combined = ossl_property_merge(q_local, q_global))
 274         && TEST_int_ge(ossl_property_match_count(q_combined, prop), 0))
 275         r = 1;
 276     ossl_property_free(q_global);
 277     ossl_property_free(q_local);
 278     ossl_property_free(q_combined);
 279     ossl_property_free(prop);
 280     ossl_method_store_free(store);
 281     return r;
 282 }
 283
 284 static int test_property_defn_cache(void)
 285 {
 286     OSSL_METHOD_STORE *store;
 287     OSSL_PROPERTY_LIST *red = NULL, *blue = NULL, *blue2 = NULL;
 288     int r;
 289
 290     r = TEST_ptr(store = ossl_method_store_new(NULL))
 291         && add_property_names("red", "blue", NULL)
 292         && TEST_ptr(red = ossl_parse_property(NULL, "red"))
 293         && TEST_ptr(blue = ossl_parse_property(NULL, "blue"))
 294         && TEST_ptr_ne(red, blue)
 295         && TEST_true(ossl_prop_defn_set(NULL, "red", &red));
 296
 297     if (!r)  {
 298         ossl_property_free(red);
 299         red = NULL;
 300         ossl_property_free(blue);
 301         blue = NULL;
 302     }
 303
 304     r = r && TEST_true(ossl_prop_defn_set(NULL, "blue", &blue));
 305     if (!r) {
 306         ossl_property_free(blue);
 307         blue = NULL;
 308     }
 309
 310     r = r && TEST_ptr_eq(ossl_prop_defn_get(NULL, "red"), red)
 311         && TEST_ptr_eq(ossl_prop_defn_get(NULL, "blue"), blue)
 312         && TEST_ptr(blue2 = ossl_parse_property(NULL, "blue"))
 313         && TEST_ptr_ne(blue2, blue)
 314         && TEST_true(ossl_prop_defn_set(NULL, "blue", &blue2));
 315     if (!r) {
 316         ossl_property_free(blue2);
 317         blue2 = NULL;
 318     }
 319
 320     r = r && TEST_ptr_eq(blue2, blue)
 321         && TEST_ptr_eq(ossl_prop_defn_get(NULL, "blue"), blue);
 322
 323     ossl_method_store_free(store);
 324     return r;
 325 }
 326
 327 static const struct {
 328     const char *defn;
 329     const char *query;
 330     int e;
 331 } definition_tests[] = {
 332     { "alpha", "alpha=yes", 1 },
 333     { "alpha=no", "alpha", -1 },
 334     { "alpha=1", "alpha=1", 1 },
 335     { "alpha=2", "alpha=1",-1 },
 336     { "alpha", "omega", -1 },
 337     { "alpha", "?omega", 0 },
 338     { "alpha", "?omega=1", 0 },
 339     { "alpha", "?omega=no", 1 },
 340     { "alpha", "?omega=yes", 0 },
 341     { "alpha, omega", "?omega=yes", 1 },
 342     { "alpha, omega", "?omega=no", 0 }
 343 };
 344
 345 static int test_definition_compares(int n)
 346 {
 347     OSSL_METHOD_STORE *store;
 348     OSSL_PROPERTY_LIST *d = NULL, *q = NULL;
 349     int r;
 350
 351     r = TEST_ptr(store = ossl_method_store_new(NULL))
 352         && add_property_names("alpha", "omega", NULL)
 353         && TEST_ptr(d = ossl_parse_property(NULL, definition_tests[n].defn))
 354         && TEST_ptr(q = ossl_parse_query(NULL, definition_tests[n].query, 0))
 355         && TEST_int_eq(ossl_property_match_count(q, d), definition_tests[n].e);
 356
 357     ossl_property_free(d);
 358     ossl_property_free(q);
 359     ossl_method_store_free(store);
 360     return r;
 361 }
 362
 363 static int test_register_deregister(void)
 364 {
 365     static const struct {
 366         int nid;
 367         const char *prop;
 368         char *impl;
 369     } impls[] = {
 370         { 6, "position=1", "a" },
 371         { 6, "position=2", "b" },
 372         { 6, "position=3", "c" },
 373         { 6, "position=4", "d" },
 374     };
 375     size_t i;
 376     int ret = 0;
 377     OSSL_METHOD_STORE *store;
 378     OSSL_PROVIDER prov = { 1 };
 379
 380     if (!TEST_ptr(store = ossl_method_store_new(NULL))
 381         || !add_property_names("position", NULL))
 382         goto err;
 383
 384     for (i = 0; i < OSSL_NELEM(impls); i++)
 385         if (!TEST_true(ossl_method_store_add(store, &prov, impls[i].nid,
 386                                              impls[i].prop, impls[i].impl,
 387                                              &up_ref, &down_ref))) {
 388             TEST_note("iteration %zd", i + 1);
 389             goto err;
 390         }
 391
 392     /* Deregister in a different order to registration */
 393     for (i = 0; i < OSSL_NELEM(impls); i++) {
 394         const size_t j = (1 + i * 3) % OSSL_NELEM(impls);
 395         int nid = impls[j].nid;
 396         void *impl = impls[j].impl;
 397
 398         if (!TEST_true(ossl_method_store_remove(store, nid, impl))
 399             || !TEST_false(ossl_method_store_remove(store, nid, impl))) {
 400             TEST_note("iteration %zd, position %zd", i + 1, j + 1);
 401             goto err;
 402         }
 403     }
 404
 405     if (TEST_false(ossl_method_store_remove(store, impls[0].nid, impls[0].impl)))
 406         ret = 1;
 407 err:
 408     ossl_method_store_free(store);
 409     return ret;
 410 }
 411
 412 static int test_property(void)
 413 {
 414     static OSSL_PROVIDER fake_provider1 = { 1 };
 415     static OSSL_PROVIDER fake_provider2 = { 2 };
 416     static const OSSL_PROVIDER *fake_prov1 = &fake_provider1;
 417     static const OSSL_PROVIDER *fake_prov2 = &fake_provider2;
 418     static const struct {
 419         const OSSL_PROVIDER **prov;
 420         int nid;
 421         const char *prop;
 422         char *impl;
 423     } impls[] = {
 424         { &fake_prov1, 1, "fast=no, colour=green", "a" },
 425         { &fake_prov1, 1, "fast, colour=blue", "b" },
 426         { &fake_prov1, 1, "", "-" },
 427         { &fake_prov2, 9, "sky=blue, furry", "c" },
 428         { &fake_prov2, 3, NULL, "d" },
 429         { &fake_prov2, 6, "sky.colour=blue, sky=green, old.data", "e" },
 430     };
 431     static struct {
 432         const OSSL_PROVIDER **prov;
 433         int nid;
 434         const char *prop;
 435         char *expected;
 436     } queries[] = {
 437         { &fake_prov1, 1, "fast", "b" },
 438         { &fake_prov1, 1, "fast=yes", "b" },
 439         { &fake_prov1, 1, "fast=no, colour=green", "a" },
 440         { &fake_prov1, 1, "colour=blue, fast", "b" },
 441         { &fake_prov1, 1, "colour=blue", "b" },
 442         { &fake_prov2, 9, "furry", "c" },
 443         { &fake_prov2, 6, "sky.colour=blue", "e" },
 444         { &fake_prov2, 6, "old.data", "e" },
 445         { &fake_prov2, 9, "furry=yes, sky=blue", "c" },
 446         { &fake_prov1, 1, "", "a" },
 447         { &fake_prov2, 3, "", "d" },
 448     };
 449     OSSL_METHOD_STORE *store;
 450     size_t i;
 451     int ret = 0;
 452     void *result;
 453
 454     if (!TEST_ptr(store = ossl_method_store_new(NULL))
 455         || !add_property_names("fast", "colour", "sky", "furry", NULL))
 456         goto err;
 457
 458     for (i = 0; i < OSSL_NELEM(impls); i++)
 459         if (!TEST_true(ossl_method_store_add(store, *impls[i].prov,
 460                                              impls[i].nid, impls[i].prop,
 461                                              impls[i].impl,
 462                                              &up_ref, &down_ref))) {
 463             TEST_note("iteration %zd", i + 1);
 464             goto err;
 465         }
 466     /*
 467      * The first check of queries is with NULL given as provider.  All
 468      * queries are expected to succeed.
 469      */
 470     for (i = 0; i < OSSL_NELEM(queries); i++) {
 471         const OSSL_PROVIDER *nullprov = NULL;
 472         OSSL_PROPERTY_LIST *pq = NULL;
 473
 474         if (!TEST_true(ossl_method_store_fetch(store,
 475                                                queries[i].nid, queries[i].prop,
 476                                                &nullprov, &result))
 477             || !TEST_str_eq((char *)result, queries[i].expected)) {
 478             TEST_note("iteration %zd", i + 1);
 479             ossl_property_free(pq);
 480             goto err;
 481         }
 482         ossl_property_free(pq);
 483     }
 484     /*
 485      * The second check of queries is with &address1 given as provider.
 486      */
 487     for (i = 0; i < OSSL_NELEM(queries); i++) {
 488         OSSL_PROPERTY_LIST *pq = NULL;
 489
 490         result = NULL;
 491         if (queries[i].prov == &fake_prov1) {
 492             if (!TEST_true(ossl_method_store_fetch(store,
 493                                                    queries[i].nid,
 494                                                    queries[i].prop,
 495                                                    &fake_prov1, &result))
 496                 || !TEST_ptr_eq(fake_prov1, &fake_provider1)
 497                 || !TEST_str_eq((char *)result, queries[i].expected)) {
 498                 TEST_note("iteration %zd", i + 1);
 499                 ossl_property_free(pq);
 500                 goto err;
 501             }
 502         } else {
 503             if (!TEST_false(ossl_method_store_fetch(store,
 504                                                     queries[i].nid,
 505                                                     queries[i].prop,
 506                                                     &fake_prov1, &result))
 507                 || !TEST_ptr_eq(fake_prov1, &fake_provider1)
 508                 || !TEST_ptr_null(result)) {
 509                 TEST_note("iteration %zd", i + 1);
 510                 ossl_property_free(pq);
 511                 goto err;
 512             }
 513         }
 514         ossl_property_free(pq);
 515     }
 516     /*
 517      * The third check of queries is with &address2 given as provider.
 518      */
 519     for (i = 0; i < OSSL_NELEM(queries); i++) {
 520         OSSL_PROPERTY_LIST *pq = NULL;
 521
 522         result = NULL;
 523         if (queries[i].prov == &fake_prov2) {
 524             if (!TEST_true(ossl_method_store_fetch(store,
 525                                                    queries[i].nid,
 526                                                    queries[i].prop,
 527                                                    &fake_prov2, &result))
 528                 || !TEST_ptr_eq(fake_prov2, &fake_provider2)
 529                 || !TEST_str_eq((char *)result, queries[i].expected)) {
 530                 TEST_note("iteration %zd", i + 1);
 531                 ossl_property_free(pq);
 532                 goto err;
 533             }
 534         } else {
 535             if (!TEST_false(ossl_method_store_fetch(store,
 536                                                     queries[i].nid,
 537                                                     queries[i].prop,
 538                                                     &fake_prov2, &result))
 539                 || !TEST_ptr_eq(fake_prov2, &fake_provider2)
 540                 || !TEST_ptr_null(result)) {
 541                 TEST_note("iteration %zd", i + 1);
 542                 ossl_property_free(pq);
 543                 goto err;
 544             }
 545         }
 546         ossl_property_free(pq);
 547     }
 548     ret = 1;
 549 err:
 550     ossl_method_store_free(store);
 551     return ret;
 552 }
 553
 554 static int test_query_cache_stochastic(void)
 555 {
 556     const int max = 10000, tail = 10;
 557     OSSL_METHOD_STORE *store;
 558     int i, res = 0;
 559     char buf[50];
 560     void *result;
 561     int errors = 0;
 562     int v[10001];
 563     OSSL_PROVIDER prov = { 1 };
 564
 565     if (!TEST_ptr(store = ossl_method_store_new(NULL))
 566         || !add_property_names("n", NULL))
 567         goto err;
 568
 569     for (i = 1; i <= max; i++) {
 570         v[i] = 2 * i;
 571         BIO_snprintf(buf, sizeof(buf), "n=%d\n", i);
 572         if (!TEST_true(ossl_method_store_add(store, &prov, i, buf, "abc",
 573                                              &up_ref, &down_ref))
 574                 || !TEST_true(ossl_method_store_cache_set(store, &prov, i,
 575                                                           buf, v + i,
 576                                                           &up_ref, &down_ref))
 577                 || !TEST_true(ossl_method_store_cache_set(store, &prov, i,
 578                                                           "n=1234", "miss",
 579                                                           &up_ref, &down_ref))) {
 580             TEST_note("iteration %d", i);
 581             goto err;
 582         }
 583     }
 584     for (i = 1; i <= max; i++) {
 585         BIO_snprintf(buf, sizeof(buf), "n=%d\n", i);
 586         if (!ossl_method_store_cache_get(store, NULL, i, buf, &result)
 587             || result != v + i)
 588             errors++;
 589     }
 590     /* There is a tiny probability that this will fail when it shouldn't */
 591     res = TEST_int_gt(errors, tail) && TEST_int_lt(errors, max - tail);
 592
 593 err:
 594     ossl_method_store_free(store);
 595     return res;
 596 }
 597
 598 static int test_fips_mode(void)
 599 {
 600     int ret = 0;
 601     OSSL_LIB_CTX *ctx = NULL;
 602
 603     if (!TEST_ptr(ctx = OSSL_LIB_CTX_new()))
 604         goto err;
 605
 606     ret = TEST_true(EVP_set_default_properties(ctx, "default=yes,fips=yes"))
 607           && TEST_true(EVP_default_properties_is_fips_enabled(ctx))
 608           && TEST_true(EVP_set_default_properties(ctx, "fips=no,default=yes"))
 609           && TEST_false(EVP_default_properties_is_fips_enabled(ctx))
 610           && TEST_true(EVP_set_default_properties(ctx, "fips=no"))
 611           && TEST_false(EVP_default_properties_is_fips_enabled(ctx))
 612           && TEST_true(EVP_set_default_properties(ctx, "fips!=no"))
 613           && TEST_true(EVP_default_properties_is_fips_enabled(ctx))
 614           && TEST_true(EVP_set_default_properties(ctx, "fips=no"))
 615           && TEST_false(EVP_default_properties_is_fips_enabled(ctx))
 616           && TEST_true(EVP_set_default_properties(ctx, "fips=no,default=yes"))
 617           && TEST_true(EVP_default_properties_enable_fips(ctx, 1))
 618           && TEST_true(EVP_default_properties_is_fips_enabled(ctx))
 619           && TEST_true(EVP_default_properties_enable_fips(ctx, 0))
 620           && TEST_false(EVP_default_properties_is_fips_enabled(ctx));
 621 err:
 622     OSSL_LIB_CTX_free(ctx);
 623     return ret;
 624 }
 625
 626 static struct {
 627     const char *in;
 628     const char *out;
 629 } to_string_tests[] = {
 630     { "fips=yes", "fips=yes" },
 631     { "fips!=yes", "fips!=yes" },
 632     { "fips = yes", "fips=yes" },
 633     { "fips", "fips=yes" },
 634     { "fips=no", "fips=no" },
 635     { "-fips", "-fips" },
 636     { "?fips=yes", "?fips=yes" },
 637     { "fips=yes,provider=fips", "fips=yes,provider=fips" },
 638     { "fips = yes , provider = fips", "fips=yes,provider=fips" },
 639     { "fips=yes,provider!=fips", "fips=yes,provider!=fips" },
 640     { "fips=yes,?provider=fips", "fips=yes,?provider=fips" },
 641     { "fips=yes,-provider", "fips=yes,-provider" },
 642       /* foo is an unknown internal name */
 643     { "foo=yes,fips=yes", "fips=yes"},
 644     { "", "" },
 645     { "fips=3", "fips=3" },
 646     { "fips=-3", "fips=-3" },
 647     { NULL, "" }
 648 };
 649
 650 static int test_property_list_to_string(int i)
 651 {
 652     OSSL_PROPERTY_LIST *pl = NULL;
 653     int ret = 0;
 654     size_t bufsize;
 655     char *buf = NULL;
 656
 657     if (to_string_tests[i].in != NULL
 658             && !TEST_ptr(pl = ossl_parse_query(NULL, to_string_tests[i].in, 1)))
 659         goto err;
 660     bufsize = ossl_property_list_to_string(NULL, pl, NULL, 0);
 661     if (!TEST_size_t_gt(bufsize, 0))
 662         goto err;
 663     buf = OPENSSL_malloc(bufsize);
 664     if (!TEST_ptr(buf)
 665             || !TEST_size_t_eq(ossl_property_list_to_string(NULL, pl, buf,
 666                                                             bufsize),
 667                                bufsize)
 668             || !TEST_str_eq(to_string_tests[i].out, buf)
 669             || !TEST_size_t_eq(bufsize, strlen(to_string_tests[i].out) + 1))
 670         goto err;
 671
 672     ret = 1;
 673  err:
 674     OPENSSL_free(buf);
 675     ossl_property_free(pl);
 676     return ret;
 677 }
 678
 679 int setup_tests(void)
 680 {
 681     ADD_TEST(test_property_string);
 682     ADD_TEST(test_property_query_value_create);
 683     ADD_ALL_TESTS(test_property_parse, OSSL_NELEM(parser_tests));
 684     ADD_ALL_TESTS(test_property_parse_error, OSSL_NELEM(parse_error_tests));
 685     ADD_ALL_TESTS(test_property_merge, OSSL_NELEM(merge_tests));
 686     ADD_TEST(test_property_defn_cache);
 687     ADD_ALL_TESTS(test_definition_compares, OSSL_NELEM(definition_tests));
 688     ADD_TEST(test_register_deregister);
 689     ADD_TEST(test_property);
 690     ADD_TEST(test_query_cache_stochastic);
 691     ADD_TEST(test_fips_mode);
 692     ADD_ALL_TESTS(test_property_list_to_string, OSSL_NELEM(to_string_tests));
 693     return 1;
 694 }