test/params_conversion_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 <string.h>
  12 #include <openssl/params.h>
  13 #include "testutil.h"
  14
  15 /* On machines that dont support <inttypes.h> just disable the tests */
  16 #if !defined(OPENSSL_NO_INTTYPES_H)
  17
  18 # ifdef OPENSSL_SYS_WINDOWS
  19 #  define strcasecmp _stricmp
  20 # endif
  21
  22 # ifdef OPENSSL_SYS_VMS
  23 #  define strtoumax strtoull
  24 #  define strtoimax strtoll
  25 # endif
  26
  27 typedef struct {
  28     OSSL_PARAM *param;
  29     int32_t i32;
  30     int64_t i64;
  31     uint32_t u32;
  32     uint64_t u64;
  33     double d;
  34     int valid_i32, valid_i64, valid_u32, valid_u64, valid_d;
  35     void *ref, *datum;
  36     size_t size;
  37 } PARAM_CONVERSION;
  38
  39 static int param_conversion_load_stanza(PARAM_CONVERSION *pc, const STANZA *s)
  40 {
  41
  42     static int32_t datum_i32, ref_i32;
  43     static int64_t datum_i64, ref_i64;
  44     static uint32_t datum_u32, ref_u32;
  45     static uint64_t datum_u64, ref_u64;
  46     static double datum_d, ref_d;
  47     static OSSL_PARAM params[] = {
  48         OSSL_PARAM_int32("int32",   &datum_i32),
  49         OSSL_PARAM_int64("int64",   &datum_i64),
  50         OSSL_PARAM_uint32("uint32", &datum_u32),
  51         OSSL_PARAM_uint64("uint64", &datum_u64),
  52         OSSL_PARAM_double("double", &datum_d),
  53         OSSL_PARAM_END
  54     };
  55     int def_i32 = 0, def_i64 = 0, def_u32 = 0, def_u64 = 0, def_d = 0;
  56     const PAIR *pp = s->pairs;
  57     const char *type = NULL;
  58     char *p;
  59     int i;
  60
  61     memset(pc, 0, sizeof(*pc));
  62
  63     for (i = 0; i < s->numpairs; i++, pp++) {
  64         p = "";
  65         if (strcasecmp(pp->key, "type") == 0) {
  66             if (type != NULL) {
  67                 TEST_info("Line %d: multiple type lines", s->curr);
  68                 return 0;
  69             }
  70             pc->param = OSSL_PARAM_locate(params, type = pp->value);
  71             if (pc->param == NULL) {
  72                 TEST_info("Line %d: unknown type line", s->curr);
  73                 return 0;
  74             }
  75         } else if (strcasecmp(pp->key, "int32") == 0) {
  76             if (def_i32++) {
  77                 TEST_info("Line %d: multiple int32 lines", s->curr);
  78                 return 0;
  79             }
  80             if (strcasecmp(pp->value, "invalid") != 0) {
  81                 pc->valid_i32 = 1;
  82                 pc->i32 = (int32_t)strtoimax(pp->value, &p, 10);
  83             }
  84         } else if (strcasecmp(pp->key, "int64") == 0) {
  85             if (def_i64++) {
  86                 TEST_info("Line %d: multiple int64 lines", s->curr);
  87                 return 0;
  88             }
  89             if (strcasecmp(pp->value, "invalid") != 0) {
  90                 pc->valid_i64 = 1;
  91                 pc->i64 = (int64_t)strtoimax(pp->value, &p, 10);
  92             }
  93         } else if (strcasecmp(pp->key, "uint32") == 0) {
  94             if (def_u32++) {
  95                 TEST_info("Line %d: multiple uint32 lines", s->curr);
  96                 return 0;
  97             }
  98             if (strcasecmp(pp->value, "invalid") != 0) {
  99                 pc->valid_u32 = 1;
 100                 pc->u32 = (uint32_t)strtoumax(pp->value, &p, 10);
 101             }
 102         } else if (strcasecmp(pp->key, "uint64") == 0) {
 103             if (def_u64++) {
 104                 TEST_info("Line %d: multiple uint64 lines", s->curr);
 105                 return 0;
 106             }
 107             if (strcasecmp(pp->value, "invalid") != 0) {
 108                 pc->valid_u64 = 1;
 109                 pc->u64 = (uint64_t)strtoumax(pp->value, &p, 10);
 110             }
 111         } else if (strcasecmp(pp->key, "double") == 0) {
 112             if (def_d++) {
 113                 TEST_info("Line %d: multiple double lines", s->curr);
 114                 return 0;
 115             }
 116             if (strcasecmp(pp->value, "invalid") != 0) {
 117                 pc->valid_d = 1;
 118                 pc->d = strtod(pp->value, &p);
 119             }
 120         } else {
 121             TEST_info("Line %d: unknown keyword %s", s->curr, pp->key);
 122             return 0;
 123         }
 124         if (*p != '\0') {
 125             TEST_info("Line %d: extra characters at end '%s' for %s",
 126                       s->curr, p, pp->key);
 127             return 0;
 128         }
 129     }
 130
 131     if (!TEST_ptr(type)) {
 132         TEST_info("Line %d: type not found", s->curr);
 133         return 0;
 134     }
 135
 136     if (strcasecmp(type, "int32") == 0) {
 137         if (!TEST_true(def_i32) || !TEST_true(pc->valid_i32)) {
 138             TEST_note("errant int32 on line %d", s->curr);
 139             return 0;
 140         }
 141         datum_i32 = ref_i32 = pc->i32;
 142         pc->datum = &datum_i32;
 143         pc->ref = &ref_i32;
 144         pc->size = sizeof(ref_i32);
 145     } else if (strcasecmp(type, "int64") == 0) {
 146         if (!TEST_true(def_i64) || !TEST_true(pc->valid_i64)) {
 147             TEST_note("errant int64 on line %d", s->curr);
 148             return 0;
 149         }
 150         datum_i64 = ref_i64 = pc->i64;
 151         pc->datum = &datum_i64;
 152         pc->ref = &ref_i64;
 153         pc->size = sizeof(ref_i64);
 154     } else if (strcasecmp(type, "uint32") == 0) {
 155         if (!TEST_true(def_u32) || !TEST_true(pc->valid_u32)) {
 156             TEST_note("errant uint32 on line %d", s->curr);
 157             return 0;
 158         }
 159         datum_u32 = ref_u32 = pc->u32;
 160         pc->datum = &datum_u32;
 161         pc->ref = &ref_u32;
 162         pc->size = sizeof(ref_u32);
 163     } else if (strcasecmp(type, "uint64") == 0) {
 164         if (!TEST_true(def_u64) || !TEST_true(pc->valid_u64)) {
 165             TEST_note("errant uint64 on line %d", s->curr);
 166             return 0;
 167         }
 168         datum_u64 = ref_u64 = pc->u64;
 169         pc->datum = &datum_u64;
 170         pc->ref = &ref_u64;
 171         pc->size = sizeof(ref_u64);
 172     } else if (strcasecmp(type, "double") == 0) {
 173         if (!TEST_true(def_d) || !TEST_true(pc->valid_d)) {
 174             TEST_note("errant double on line %d", s->curr);
 175             return 0;
 176         }
 177         datum_d = ref_d = pc->d;
 178         pc->datum = &datum_d;
 179         pc->ref = &ref_d;
 180         pc->size = sizeof(ref_d);
 181     } else {
 182         TEST_error("type unknown at line %d", s->curr);
 183         return 0;
 184     }
 185     return 1;
 186 }
 187
 188 static int param_conversion_test(const PARAM_CONVERSION *pc, int line)
 189 {
 190     int32_t i32;
 191     int64_t i64;
 192     uint32_t u32;
 193     uint64_t u64;
 194     double d;
 195
 196     if (!pc->valid_i32) {
 197         if (!TEST_false(OSSL_PARAM_get_int32(pc->param, &i32))) {
 198             TEST_note("unexpected valid conversion to int32 on line %d", line);
 199             return 0;
 200         }
 201     } else {
 202         if (!TEST_true(OSSL_PARAM_get_int32(pc->param, &i32))
 203             || !TEST_true(i32 == pc->i32)) {
 204             TEST_note("unexpected conversion to int32 on line %d", line);
 205             return 0;
 206         }
 207         memset(pc->datum, 44, pc->size);
 208         if (!TEST_true(OSSL_PARAM_set_int32(pc->param, i32))
 209             || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
 210             TEST_note("unexpected valid conversion from int32 on line %d",
 211                       line);
 212             return 0;
 213         }
 214     }
 215
 216     if (!pc->valid_i64) {
 217         if (!TEST_false(OSSL_PARAM_get_int64(pc->param, &i64))) {
 218             TEST_note("unexpected valid conversion to int64 on line %d", line);
 219             return 0;
 220         }
 221     } else {
 222         if (!TEST_true(OSSL_PARAM_get_int64(pc->param, &i64))
 223             || !TEST_true(i64 == pc->i64)) {
 224             TEST_note("unexpected conversion to int64 on line %d", line);
 225             return 0;
 226         }
 227         memset(pc->datum, 44, pc->size);
 228         if (!TEST_true(OSSL_PARAM_set_int64(pc->param, i64))
 229             || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
 230             TEST_note("unexpected valid conversion from int64 on line %d",
 231                       line);
 232             return 0;
 233         }
 234     }
 235
 236     if (!pc->valid_u32) {
 237         if (!TEST_false(OSSL_PARAM_get_uint32(pc->param, &u32))) {
 238             TEST_note("unexpected valid conversion to uint32 on line %d", line);
 239             return 0;
 240         }
 241     } else {
 242         if (!TEST_true(OSSL_PARAM_get_uint32(pc->param, &u32))
 243             || !TEST_true(u32 == pc->u32)) {
 244             TEST_note("unexpected conversion to uint32 on line %d", line);
 245             return 0;
 246         }
 247         memset(pc->datum, 44, pc->size);
 248         if (!TEST_true(OSSL_PARAM_set_uint32(pc->param, u32))
 249             || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
 250             TEST_note("unexpected valid conversion from uint32 on line %d",
 251                       line);
 252             return 0;
 253         }
 254     }
 255
 256     if (!pc->valid_u64) {
 257         if (!TEST_false(OSSL_PARAM_get_uint64(pc->param, &u64))) {
 258             TEST_note("unexpected valid conversion to uint64 on line %d", line);
 259             return 0;
 260         }
 261     } else {
 262         if (!TEST_true(OSSL_PARAM_get_uint64(pc->param, &u64))
 263             || !TEST_true(u64 == pc->u64)) {
 264             TEST_note("unexpected conversion to uint64 on line %d", line);
 265             return 0;
 266         }
 267         memset(pc->datum, 44, pc->size);
 268         if (!TEST_true(OSSL_PARAM_set_uint64(pc->param, u64))
 269             || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
 270             TEST_note("unexpected valid conversion from uint64 on line %d",
 271                       line);
 272             return 0;
 273         }
 274     }
 275
 276     if (!pc->valid_d) {
 277         if (!TEST_false(OSSL_PARAM_get_double(pc->param, &d))) {
 278             TEST_note("unexpected valid conversion to double on line %d", line);
 279             return 0;
 280         }
 281     } else {
 282         if (!TEST_true(OSSL_PARAM_get_double(pc->param, &d))) {
 283             TEST_note("unable to convert to double on line %d", line);
 284             return 0;
 285         }
 286         /*
 287          * Check for not a number (NaN) without using the libm functions.
 288          * When d is a NaN, the standard requires d == d to be false.
 289          * It's less clear if d != d should be true even though it generally is.
 290          * Hence we use the equality test and a not.
 291          */
 292         if (!(d == d)) {
 293             /*
 294              * We've encountered a NaN so check it's really meant to be a NaN.
 295              * We ignore the case where the two values are both different NaN,
 296              * that's not resolvable without knowing the underlying format
 297              * or using libm functions.
 298              */
 299             if (!TEST_false(pc->d == pc->d)) {
 300                 TEST_note("unexpected NaN on line %d", line);
 301                 return 0;
 302             }
 303         } else if (!TEST_true(d == pc->d)) {
 304             TEST_note("unexpected conversion to double on line %d", line);
 305             return 0;
 306         }
 307         memset(pc->datum, 44, pc->size);
 308         if (!TEST_true(OSSL_PARAM_set_double(pc->param, d))
 309             || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
 310             TEST_note("unexpected valid conversion from double on line %d",
 311                       line);
 312             return 0;
 313         }
 314     }
 315
 316     return 1;
 317 }
 318
 319 static int run_param_file_tests(int i)
 320 {
 321     STANZA *s;
 322     PARAM_CONVERSION pc;
 323     const char *testfile = test_get_argument(i);
 324     int res = 1;
 325
 326     if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
 327         return 0;
 328     if (!test_start_file(s, testfile)) {
 329         OPENSSL_free(s);
 330         return 0;
 331     }
 332
 333     while (!BIO_eof(s->fp)) {
 334         if (!test_readstanza(s)) {
 335             res = 0;
 336             goto end;
 337         }
 338         if (s->numpairs != 0)
 339             if (!param_conversion_load_stanza(&pc, s)
 340                 || !param_conversion_test(&pc, s->curr))
 341                 res = 0;
 342         test_clearstanza(s);
 343     }
 344 end:
 345     test_end_file(s);
 346     OPENSSL_free(s);
 347     return res;
 348 }
 349
 350 #endif /* OPENSSL_NO_INTTYPES_H */
 351
 352 OPT_TEST_DECLARE_USAGE("file...\n")
 353
 354 int setup_tests(void)
 355 {
 356     size_t n;
 357
 358     if (!test_skip_common_options()) {
 359         TEST_error("Error parsing test options\n");
 360         return 0;
 361     }
 362
 363     n = test_get_argument_count();
 364     if (n == 0)
 365         return 0;
 366
 367 #if !defined(OPENSSL_NO_INTTYPES_H)
 368     ADD_ALL_TESTS(run_param_file_tests, n);
 369 #endif /* OPENSSL_NO_INTTYPES_H */
 370
 371     return 1;
 372 }