test/params_test.c

   1 /*
   2  * Copyright 2019 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 /*
  12  * This program tests the use of OSSL_PARAM, currently in raw form.
  13  */
  14
  15 #include <string.h>
  16 #include <openssl/bn.h>
  17 #include <openssl/core.h>
  18 #include <openssl/params.h>
  19 #include "internal/nelem.h"
  20 #include "testutil.h"
  21
  22 /*-
  23  * PROVIDER SECTION
  24  * ================
  25  *
  26  * Even though it's not necessarily ONLY providers doing this part,
  27  * they are naturally going to be the most common users of
  28  * set_params and get_params functions.
  29  */
  30
  31 /*
  32  * In real use cases, setters and getters would take an object with
  33  * which the parameters are associated.  This structure is a cheap
  34  * simulation.
  35  */
  36 struct object_st {
  37     /*
  38      * Documented as a native integer, of the size given by sizeof(int).
  39      * Assumed data type OSSL_PARAM_INTEGER
  40      */
  41     int p1;
  42     /*
  43      * Documented as a native double, of the size given by sizeof(double).
  44      * Assumed data type OSSL_PARAM_REAL
  45      */
  46     double p2;
  47     /*
  48      * Documented as an arbitrarly large unsigned integer.
  49      * The data size must be large enough to accomodate.
  50      * Assumed data type OSSL_PARAM_UNSIGNED_INTEGER
  51      */
  52     BIGNUM *p3;
  53     /*
  54      * Documented as a C string.
  55      * The data size must be large enough to accomodate.
  56      * Assumed data type OSSL_PARAM_UTF8_STRING
  57      */
  58     char *p4;
  59     size_t p4_l;
  60     /*
  61      * Documented as a C string.
  62      * Assumed data type OSSL_PARAM_UTF8_STRING
  63      */
  64     char p5[256];
  65     size_t p5_l;
  66     /*
  67      * Documented as a pointer to a constant C string.
  68      * Assumed data type OSSL_PARAM_UTF8_PTR
  69      */
  70     const char *p6;
  71     size_t p6_l;
  72 };
  73
  74 #define p1_init 42                              /* The ultimate answer */
  75 #define p2_init 6.283                           /* Magic number */
  76 /* Stolen from evp_data, BLAKE2s256 test */
  77 #define p3_init                                 \
  78     "4142434445464748494a4b4c4d4e4f50"          \
  79     "5152535455565758595a616263646566"          \
  80     "6768696a6b6c6d6e6f70717273747576"          \
  81     "7778797a30313233343536373839"
  82 #define p4_init "BLAKE2s256"                    /* Random string */
  83 #define p5_init "Hellow World"                  /* Random string */
  84 #define p6_init OPENSSL_FULL_VERSION_STR        /* Static string */
  85
  86 static void cleanup_object(void *vobj)
  87 {
  88     struct object_st *obj = vobj;
  89
  90     BN_free(obj->p3);
  91     obj->p3 = NULL;
  92     OPENSSL_free(obj->p4);
  93     obj->p4 = NULL;
  94     OPENSSL_free(obj);
  95 }
  96
  97 static void *init_object(void)
  98 {
  99     struct object_st *obj = OPENSSL_zalloc(sizeof(*obj));
 100
 101     obj->p1 = p1_init;
 102     obj->p2 = p2_init;
 103     if (!TEST_true(BN_hex2bn(&obj->p3, p3_init)))
 104         goto fail;
 105     if (!TEST_ptr(obj->p4 = OPENSSL_strdup(p4_init)))
 106         goto fail;
 107     strcpy(obj->p5, p5_init);
 108     obj->p6 = p6_init;
 109
 110     return obj;
 111  fail:
 112     cleanup_object(obj);
 113     obj = NULL;
 114
 115     return NULL;
 116 }
 117
 118 /*
 119  * RAW provider, which handles the parameters in a very raw manner,
 120  * with no fancy API and very minimal checking.  The application that
 121  * calls these to set or request parameters MUST get its OSSL_PARAM
 122  * array right.
 123  */
 124
 125 static int raw_set_params(void *vobj, const OSSL_PARAM *params)
 126 {
 127     struct object_st *obj = vobj;
 128
 129     for (; params->key != NULL; params++)
 130         if (strcmp(params->key, "p1") == 0) {
 131             obj->p1 = *(int *)params->data;
 132         } else if (strcmp(params->key, "p2") == 0) {
 133             obj->p2 = *(double *)params->data;
 134         } else if (strcmp(params->key, "p3") == 0) {
 135             BN_free(obj->p3);
 136             if (!TEST_ptr(obj->p3 = BN_native2bn(params->data,
 137                                                  params->data_size, NULL)))
 138                 return 0;
 139         } else if (strcmp(params->key, "p4") == 0) {
 140             OPENSSL_free(obj->p4);
 141             if (!TEST_ptr(obj->p4 = OPENSSL_strndup(params->data,
 142                                                     params->data_size)))
 143                 return 0;
 144         } else if (strcmp(params->key, "p5") == 0) {
 145             strncpy(obj->p5, params->data, params->data_size);
 146         } else if (strcmp(params->key, "p6") == 0) {
 147             obj->p6 = *(const char **)params->data;
 148         }
 149
 150     return 1;
 151 }
 152
 153 static int raw_get_params(void *vobj, const OSSL_PARAM *params)
 154 {
 155     struct object_st *obj = vobj;
 156
 157     for (; params->key != NULL; params++)
 158         if (strcmp(params->key, "p1") == 0) {
 159             if (params->return_size != NULL)
 160                 *params->return_size = sizeof(obj->p1);
 161             *(int *)params->data = obj->p1;
 162         } else if (strcmp(params->key, "p2") == 0) {
 163             if (params->return_size != NULL)
 164                 *params->return_size = sizeof(obj->p2);
 165             *(double *)params->data = obj->p2;
 166         } else if (strcmp(params->key, "p3") == 0) {
 167             size_t bytes = BN_num_bytes(obj->p3);
 168
 169             if (params->return_size != NULL)
 170                 *params->return_size = bytes;
 171             if (!TEST_size_t_ge(params->data_size, bytes))
 172                 return 0;
 173             BN_bn2nativepad(obj->p3, params->data, bytes);
 174         } else if (strcmp(params->key, "p4") == 0) {
 175             size_t bytes = strlen(obj->p4) + 1;
 176
 177             if (params->return_size != NULL)
 178                 *params->return_size = bytes;
 179             if (!TEST_size_t_ge(params->data_size, bytes))
 180                 return 0;
 181             strcpy(params->data, obj->p4);
 182         } else if (strcmp(params->key, "p5") == 0) {
 183             size_t bytes = strlen(obj->p5) + 1;
 184
 185             if (params->return_size != NULL)
 186                 *params->return_size = bytes;
 187             if (!TEST_size_t_ge(params->data_size, bytes))
 188                 return 0;
 189             strcpy(params->data, obj->p5);
 190         } else if (strcmp(params->key, "p6") == 0) {
 191             /*
 192              * We COULD also use OPENSSL_FULL_VERSION_STR directly and
 193              * use sizeof(OPENSSL_FULL_VERSION_STR) instead of calling
 194              * strlen().
 195              * The caller wouldn't know the difference.
 196              */
 197             size_t bytes = strlen(obj->p6) + 1;
 198
 199             if (params->return_size != NULL)
 200                 *params->return_size = bytes;
 201             *(const char **)params->data = obj->p6;
 202         }
 203
 204     return 1;
 205 }
 206
 207 /*
 208  * API provider, which handles the parameters using the API from params.h
 209  */
 210
 211 static int api_set_params(void *vobj, const OSSL_PARAM *params)
 212 {
 213     struct object_st *obj = vobj;
 214     const OSSL_PARAM *p = NULL;
 215
 216     if ((p = OSSL_PARAM_locate(params, "p1")) != NULL
 217         && !TEST_true(OSSL_PARAM_get_int(p, &obj->p1)))
 218         return 0;
 219     if ((p = OSSL_PARAM_locate(params, "p2")) != NULL
 220         && !TEST_true(OSSL_PARAM_get_double(p, &obj->p2)))
 221         return 0;
 222     if ((p = OSSL_PARAM_locate(params, "p3")) != NULL
 223         && !TEST_true(OSSL_PARAM_get_BN(p, &obj->p3)))
 224         return 0;
 225     if ((p = OSSL_PARAM_locate(params, "p4")) != NULL) {
 226         OPENSSL_free(obj->p4);
 227         obj->p4 = NULL;
 228         /* If the value pointer is NULL, we get it automatically allocated */
 229         if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &obj->p4, 0)))
 230             return 0;
 231     }
 232     if ((p = OSSL_PARAM_locate(params, "p5")) != NULL) {
 233         char *p5_ptr = obj->p5;
 234         if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &p5_ptr, sizeof(obj->p5))))
 235             return 0;
 236     }
 237     if ((p = OSSL_PARAM_locate(params, "p6")) != NULL
 238         && !TEST_true(OSSL_PARAM_get_utf8_ptr(p, &obj->p6)))
 239         return 0;
 240
 241     return 1;
 242 }
 243
 244 static int api_get_params(void *vobj, const OSSL_PARAM *params)
 245 {
 246     struct object_st *obj = vobj;
 247     const OSSL_PARAM *p = NULL;
 248
 249     if ((p = OSSL_PARAM_locate(params, "p1")) != NULL
 250         && !TEST_true(OSSL_PARAM_set_int(p, obj->p1)))
 251         return 0;
 252     if ((p = OSSL_PARAM_locate(params, "p2")) != NULL
 253         && !TEST_true(OSSL_PARAM_set_double(p, obj->p2)))
 254         return 0;
 255     if ((p = OSSL_PARAM_locate(params, "p3")) != NULL
 256         && !TEST_true(OSSL_PARAM_set_BN(p, obj->p3)))
 257         return 0;
 258     if ((p = OSSL_PARAM_locate(params, "p4")) != NULL
 259         && !TEST_true(OSSL_PARAM_set_utf8_string(p, obj->p4)))
 260         return 0;
 261     if ((p = OSSL_PARAM_locate(params, "p5")) != NULL
 262         && !TEST_true(OSSL_PARAM_set_utf8_string(p, obj->p5)))
 263         return 0;
 264     if ((p = OSSL_PARAM_locate(params, "p6")) != NULL
 265         && !TEST_true(OSSL_PARAM_set_utf8_ptr(p, obj->p6)))
 266         return 0;
 267
 268     return 1;
 269 }
 270
 271 /*
 272  * This structure only simulates a provider dispatch, the real deal is
 273  * a bit more code that's not necessary in these tests.
 274  */
 275 struct provider_dispatch_st {
 276     int (*set_params)(void *obj, const OSSL_PARAM *params);
 277     int (*get_params)(void *obj, const OSSL_PARAM *params);
 278 };
 279
 280 /* "raw" provider */
 281 static const struct provider_dispatch_st provider_raw = {
 282     raw_set_params, raw_get_params
 283 };
 284
 285 /* "api" provider */
 286 static const struct provider_dispatch_st provider_api = {
 287     api_set_params, api_get_params
 288 };
 289
 290 /*-
 291  * APPLICATION SECTION
 292  * ===================
 293  */
 294
 295 /* In all our tests, these are variables that get manipulated as parameters
 296  *
 297  * These arrays consistenly do nothing with the "p2" parameter, and
 298  * always include a "foo" parameter.  This is to check that the
 299  * set_params and get_params calls ignore the lack of parameters that
 300  * the application isn't interested in, as well as ignore parameters
 301  * they don't understand (the application may have one big bag of
 302  * parameters).
 303  */
 304 static int app_p1;                    /* "p1" */
 305 static double app_p2;                 /* "p2" is ignored */
 306 static BIGNUM *app_p3 = NULL;         /* "p3" */
 307 static unsigned char bignumbin[4096]; /* "p3" */
 308 static size_t bignumbin_l;            /* "p3" */
 309 static char app_p4[256];              /* "p4" */
 310 static size_t app_p4_l;               /* "p4" */
 311 static char app_p5[256];              /* "p5" */
 312 static size_t app_p5_l;               /* "p5" */
 313 static const char *app_p6 = NULL;     /* "p6" */
 314 static size_t app_p6_l;               /* "p6" */
 315 static unsigned char foo[1];          /* "foo" */
 316 static size_t foo_l;                  /* "foo" */
 317
 318 #define app_p1_init 17           /* A random number */
 319 #define app_p2_init 47.11        /* Another random number */
 320 #define app_p3_init "deadbeef"   /* Classic */
 321 #define app_p4_init "Hello"
 322 #define app_p5_init "World"
 323 #define app_p6_init "Cookie"
 324 #define app_foo_init 'z'
 325
 326 static int cleanup_app_variables(void)
 327 {
 328     BN_free(app_p3);
 329     app_p3 = NULL;
 330     return 1;
 331 }
 332
 333 static int init_app_variables(void)
 334 {
 335     int l = 0;
 336
 337     cleanup_app_variables();
 338
 339     app_p1 = app_p1_init;
 340     app_p2 = app_p2_init;
 341     if (!BN_hex2bn(&app_p3, app_p3_init)
 342         || (l = BN_bn2nativepad(app_p3, bignumbin, sizeof(bignumbin))) < 0)
 343         return 0;
 344     bignumbin_l = (size_t)l;
 345     strcpy(app_p4, app_p4_init);
 346     app_p4_l = sizeof(app_p4_init);
 347     strcpy(app_p5, app_p5_init);
 348     app_p5_l = sizeof(app_p5_init);
 349     app_p6 = app_p6_init;
 350     foo[0] = app_foo_init;
 351     foo_l = sizeof(app_foo_init);
 352
 353     return 1;
 354 }
 355
 356 /*
 357  * Here, we define test OSSL_PARAM arrays
 358  */
 359
 360 /* An array of OSSL_PARAM, specific in the most raw manner possible */
 361 static const OSSL_PARAM static_raw_params[] = {
 362     { "p1", OSSL_PARAM_INTEGER, &app_p1, sizeof(app_p1), NULL },
 363     { "p3", OSSL_PARAM_UNSIGNED_INTEGER, &bignumbin, sizeof(bignumbin),
 364       &bignumbin_l },
 365     { "p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4), &app_p4_l },
 366     { "p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5), &app_p5_l },
 367     { "p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6), &app_p6_l },
 368     { "foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), &foo_l },
 369     { NULL, 0, NULL, 0, NULL }
 370 };
 371
 372 /* The same array of OSSL_PARAM, specified with the macros from params.h */
 373 static const OSSL_PARAM static_api_params[] = {
 374     OSSL_PARAM_int("p1", &app_p1),
 375     OSSL_PARAM_SIZED_BN("p3", &bignumbin, sizeof(bignumbin), bignumbin_l),
 376     OSSL_PARAM_DEFN("p4", OSSL_PARAM_UTF8_STRING,
 377                     &app_p4, sizeof(app_p4), &app_p4_l),
 378     OSSL_PARAM_DEFN("p5", OSSL_PARAM_UTF8_STRING,
 379                     &app_p5, sizeof(app_p5), &app_p5_l),
 380     OSSL_PARAM_DEFN("p6", OSSL_PARAM_UTF8_PTR,
 381                     &app_p6, sizeof(app_p6), &app_p6_l),
 382     OSSL_PARAM_DEFN("foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), &foo_l),
 383     OSSL_PARAM_END
 384 };
 385
 386 /*
 387  * The same array again, but constructed at run-time
 388  * This exercises the OSSL_PARAM constructor functions
 389  */
 390 static OSSL_PARAM *construct_api_params(void)
 391 {
 392     size_t n = 0;
 393     static OSSL_PARAM params[10];
 394     OSSL_PARAM param_end = OSSL_PARAM_END;
 395
 396     params[n++] = OSSL_PARAM_construct_int("p1", &app_p1, NULL);
 397     params[n++] = OSSL_PARAM_construct_BN("p3", bignumbin, sizeof(bignumbin),
 398                                           &bignumbin_l);
 399     params[n++] = OSSL_PARAM_construct_utf8_string("p4", app_p4, sizeof(app_p4),
 400                                                    &app_p4_l);
 401     params[n++] = OSSL_PARAM_construct_utf8_string("p5", app_p5,
 402                                                    sizeof(app_p5), &app_p5_l);
 403     params[n++] = OSSL_PARAM_construct_utf8_ptr("p6", (char **)&app_p6,
 404                                                 &app_p6_l);
 405     params[n++] = OSSL_PARAM_construct_octet_string("foo", &foo, sizeof(foo),
 406                                                     &foo_l);
 407     params[n++] = param_end;
 408
 409     return params;
 410 }
 411
 412 struct param_owner_st {
 413     const OSSL_PARAM *static_params;
 414     OSSL_PARAM *(*constructed_params)(void);
 415 };
 416
 417 static const struct param_owner_st raw_params = {
 418     static_raw_params, NULL
 419 };
 420
 421 static const struct param_owner_st api_params = {
 422     static_api_params, construct_api_params
 423 };
 424
 425 /*-
 426  * TESTING
 427  * =======
 428  */
 429
 430 /*
 431  * Test cases to combine parameters with "provider side" functions
 432  */
 433 static struct {
 434     const struct provider_dispatch_st *prov;
 435     const struct param_owner_st *app;
 436     const char *desc;
 437 } test_cases[] = {
 438     /* Tests within specific methods */
 439     { &provider_raw, &raw_params, "raw provider vs raw params" },
 440     { &provider_api, &api_params, "api provider vs api params" },
 441
 442     /* Mixed methods */
 443     { &provider_raw, &api_params, "raw provider vs api params" },
 444     { &provider_api, &raw_params, "api provider vs raw params" },
 445 };
 446
 447 /* Generic tester of combinations of "providers" and params */
 448 static int test_case_variant(const OSSL_PARAM *params,
 449                              const struct provider_dispatch_st *prov)
 450 {
 451     BIGNUM *verify_p3 = NULL;
 452     void *obj = NULL;
 453     int errcnt = 0;
 454
 455     /*
 456      * Initialize
 457      */
 458     if (!TEST_ptr(obj = init_object())
 459         || !TEST_true(BN_hex2bn(&verify_p3, p3_init))) {
 460         errcnt++;
 461         goto fin;
 462     }
 463
 464     /*
 465      * Get parameters a first time, just to see that getting works and
 466      * gets us the values we expect.
 467      */
 468     init_app_variables();
 469
 470     if (!TEST_true(prov->get_params(obj, params))
 471         || !TEST_int_eq(app_p1, p1_init)        /* "provider" value */
 472         || !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */
 473         || !TEST_ptr(BN_native2bn(bignumbin, bignumbin_l, app_p3))
 474         || !TEST_BN_eq(app_p3, verify_p3)       /* "provider" value */
 475         || !TEST_str_eq(app_p4, p4_init)        /* "provider" value */
 476         || !TEST_str_eq(app_p5, p5_init)        /* "provider" value */
 477         || !TEST_str_eq(app_p6, p6_init)        /* "provider" value */
 478         || !TEST_char_eq(foo[0], app_foo_init)  /* Should remain untouched */
 479         || !TEST_int_eq(foo_l, sizeof(app_foo_init)))
 480         errcnt++;
 481
 482     /*
 483      * Set parameters, then sneak into the object itself and check
 484      * that its attributes got set (or ignored) properly.
 485      */
 486     init_app_variables();
 487
 488     if (!TEST_true(prov->set_params(obj, params))) {
 489         errcnt++;
 490     } else {
 491         struct object_st *sneakpeek = obj;
 492
 493         if (!TEST_int_eq(sneakpeek->p1, app_p1)         /* app value set */
 494             || !TEST_double_eq(sneakpeek->p2, p2_init)  /* Should remain untouched */
 495             || !TEST_BN_eq(sneakpeek->p3, app_p3)       /* app value set */
 496             || !TEST_str_eq(sneakpeek->p4, app_p4)      /* app value set */
 497             || !TEST_str_eq(sneakpeek->p5, app_p5))     /* app value set */
 498             errcnt++;
 499     }
 500
 501     /*
 502      * Get parameters again, checking that we get different values
 503      * than earlier where relevant.
 504      */
 505     BN_free(verify_p3);
 506     verify_p3 = NULL;
 507
 508     if (!TEST_true(BN_hex2bn(&verify_p3, app_p3_init))) {
 509         errcnt++;
 510         goto fin;
 511     }
 512
 513     if (!TEST_true(prov->get_params(obj, params))
 514         || !TEST_int_eq(app_p1, app_p1_init)    /* app value */
 515         || !TEST_double_eq(app_p2, app_p2_init) /* Should remain untouched */
 516         || !TEST_ptr(BN_native2bn(bignumbin, bignumbin_l, app_p3))
 517         || !TEST_BN_eq(app_p3, verify_p3)       /* app value */
 518         || !TEST_str_eq(app_p4, app_p4_init)    /* app value */
 519         || !TEST_str_eq(app_p5, app_p5_init)    /* app value */
 520         || !TEST_str_eq(app_p6, app_p6_init)    /* app value */
 521         || !TEST_char_eq(foo[0], app_foo_init)  /* Should remain untouched */
 522         || !TEST_int_eq(foo_l, sizeof(app_foo_init)))
 523         errcnt++;
 524
 525  fin:
 526     BN_free(verify_p3);
 527     verify_p3 = NULL;
 528     cleanup_app_variables();
 529     cleanup_object(obj);
 530
 531     return errcnt == 0;
 532 }
 533
 534 static int test_case(int i)
 535 {
 536     TEST_info("Case: %s", test_cases[i].desc);
 537
 538     return test_case_variant(test_cases[i].app->static_params,
 539                              test_cases[i].prov)
 540         && (test_cases[i].app->constructed_params == NULL
 541             || test_case_variant(test_cases[i].app->constructed_params(),
 542                                  test_cases[i].prov));
 543 }
 544
 545 int setup_tests(void)
 546 {
 547     ADD_ALL_TESTS(test_case, OSSL_NELEM(test_cases));
 548     return 1;
 549 }