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