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
23 typedef 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
param_conversion_load_stanza(PARAM_CONVERSION * pc,const STANZA * s)35 static 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
param_conversion_test(const PARAM_CONVERSION * pc,int line)184 static 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_ulong_ne(ERR_get_error(), 0)) {
195 TEST_note("unexpected valid conversion to int32 on line %d", line);
196 return 0;
197 }
198 } else {
199 if (!TEST_true(OSSL_PARAM_get_int32(pc->param, &i32))
200 || !TEST_true(i32 == pc->i32)) {
201 TEST_note("unexpected conversion to int32 on line %d", line);
202 return 0;
203 }
204 memset(pc->datum, 44, pc->size);
205 if (!TEST_true(OSSL_PARAM_set_int32(pc->param, i32))
206 || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
207 TEST_note("unexpected valid conversion from int32 on line %d",
208 line);
209 return 0;
210 }
211 }
212
213 if (!pc->valid_i64) {
214 if (!TEST_false(OSSL_PARAM_get_int64(pc->param, &i64))
215 || !TEST_ulong_ne(ERR_get_error(), 0)) {
216 TEST_note("unexpected valid conversion to int64 on line %d", line);
217 return 0;
218 }
219 } else {
220 if (!TEST_true(OSSL_PARAM_get_int64(pc->param, &i64))
221 || !TEST_true(i64 == pc->i64)) {
222 TEST_note("unexpected conversion to int64 on line %d", line);
223 return 0;
224 }
225 memset(pc->datum, 44, pc->size);
226 if (!TEST_true(OSSL_PARAM_set_int64(pc->param, i64))
227 || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
228 TEST_note("unexpected valid conversion from int64 on line %d",
229 line);
230 return 0;
231 }
232 }
233
234 if (!pc->valid_u32) {
235 if (!TEST_false(OSSL_PARAM_get_uint32(pc->param, &u32))
236 || !TEST_ulong_ne(ERR_get_error(), 0)) {
237 TEST_note("unexpected valid conversion to uint32 on line %d", line);
238 return 0;
239 }
240 } else {
241 if (!TEST_true(OSSL_PARAM_get_uint32(pc->param, &u32))
242 || !TEST_true(u32 == pc->u32)) {
243 TEST_note("unexpected conversion to uint32 on line %d", line);
244 return 0;
245 }
246 memset(pc->datum, 44, pc->size);
247 if (!TEST_true(OSSL_PARAM_set_uint32(pc->param, u32))
248 || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
249 TEST_note("unexpected valid conversion from uint32 on line %d",
250 line);
251 return 0;
252 }
253 }
254
255 if (!pc->valid_u64) {
256 if (!TEST_false(OSSL_PARAM_get_uint64(pc->param, &u64))
257 || !TEST_ulong_ne(ERR_get_error(), 0)) {
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_ulong_ne(ERR_get_error(), 0)) {
279 TEST_note("unexpected valid conversion to double on line %d", line);
280 return 0;
281 }
282 } else {
283 if (!TEST_true(OSSL_PARAM_get_double(pc->param, &d))) {
284 TEST_note("unable to convert to double on line %d", line);
285 return 0;
286 }
287 /*
288 * Check for not a number (NaN) without using the libm functions.
289 * When d is a NaN, the standard requires d == d to be false.
290 * It's less clear if d != d should be true even though it generally is.
291 * Hence we use the equality test and a not.
292 */
293 if (!(d == d)) {
294 /*
295 * We've encountered a NaN so check it's really meant to be a NaN.
296 * We ignore the case where the two values are both different NaN,
297 * that's not resolvable without knowing the underlying format
298 * or using libm functions.
299 */
300 if (!TEST_false(pc->d == pc->d)) {
301 TEST_note("unexpected NaN on line %d", line);
302 return 0;
303 }
304 } else if (!TEST_true(d == pc->d)) {
305 TEST_note("unexpected conversion to double on line %d", line);
306 return 0;
307 }
308 memset(pc->datum, 44, pc->size);
309 if (!TEST_true(OSSL_PARAM_set_double(pc->param, d))
310 || !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
311 TEST_note("unexpected valid conversion from double on line %d",
312 line);
313 return 0;
314 }
315 }
316
317 return 1;
318 }
319
run_param_file_tests(int i)320 static int run_param_file_tests(int i)
321 {
322 STANZA *s;
323 PARAM_CONVERSION pc;
324 const char *testfile = test_get_argument(i);
325 int res = 1;
326
327 if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
328 return 0;
329 if (!test_start_file(s, testfile)) {
330 OPENSSL_free(s);
331 return 0;
332 }
333
334 while (!BIO_eof(s->fp)) {
335 if (!test_readstanza(s)) {
336 res = 0;
337 goto end;
338 }
339 if (s->numpairs != 0)
340 if (!param_conversion_load_stanza(&pc, s)
341 || !param_conversion_test(&pc, s->curr))
342 res = 0;
343 test_clearstanza(s);
344 }
345 end:
346 test_end_file(s);
347 OPENSSL_free(s);
348 return res;
349 }
350
351 #endif /* OPENSSL_NO_INTTYPES_H */
352
353 OPT_TEST_DECLARE_USAGE("file...\n")
354
setup_tests(void)355 int setup_tests(void)
356 {
357 size_t n;
358
359 if (!test_skip_common_options()) {
360 TEST_error("Error parsing test options\n");
361 return 0;
362 }
363
364 n = test_get_argument_count();
365 if (n == 0)
366 return 0;
367
368 #if !defined(OPENSSL_NO_INTTYPES_H)
369 ADD_ALL_TESTS(run_param_file_tests, n);
370 #endif /* OPENSSL_NO_INTTYPES_H */
371
372 return 1;
373 }
374
