mirror of
https://github.com/openssl/openssl.git
synced 2024-11-27 05:21:51 +08:00
291c5b3e39
Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/17440)
378 lines
12 KiB
C
378 lines
12 KiB
C
/*
|
|
* Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
|
|
* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
* in the file LICENSE in the source distribution or at
|
|
* https://www.openssl.org/source/license.html
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <openssl/params.h>
|
|
#include "testutil.h"
|
|
|
|
/* On machines that dont support <inttypes.h> just disable the tests */
|
|
#if !defined(OPENSSL_NO_INTTYPES_H)
|
|
|
|
# ifdef OPENSSL_SYS_WINDOWS
|
|
# define strcasecmp _stricmp
|
|
# endif
|
|
|
|
# ifdef OPENSSL_SYS_VMS
|
|
# define strtoumax strtoull
|
|
# define strtoimax strtoll
|
|
# endif
|
|
|
|
typedef struct {
|
|
OSSL_PARAM *param;
|
|
int32_t i32;
|
|
int64_t i64;
|
|
uint32_t u32;
|
|
uint64_t u64;
|
|
double d;
|
|
int valid_i32, valid_i64, valid_u32, valid_u64, valid_d;
|
|
void *ref, *datum;
|
|
size_t size;
|
|
} PARAM_CONVERSION;
|
|
|
|
static int param_conversion_load_stanza(PARAM_CONVERSION *pc, const STANZA *s)
|
|
{
|
|
|
|
static int32_t datum_i32, ref_i32;
|
|
static int64_t datum_i64, ref_i64;
|
|
static uint32_t datum_u32, ref_u32;
|
|
static uint64_t datum_u64, ref_u64;
|
|
static double datum_d, ref_d;
|
|
static OSSL_PARAM params[] = {
|
|
OSSL_PARAM_int32("int32", &datum_i32),
|
|
OSSL_PARAM_int64("int64", &datum_i64),
|
|
OSSL_PARAM_uint32("uint32", &datum_u32),
|
|
OSSL_PARAM_uint64("uint64", &datum_u64),
|
|
OSSL_PARAM_double("double", &datum_d),
|
|
OSSL_PARAM_END
|
|
};
|
|
int def_i32 = 0, def_i64 = 0, def_u32 = 0, def_u64 = 0, def_d = 0;
|
|
const PAIR *pp = s->pairs;
|
|
const char *type = NULL;
|
|
char *p;
|
|
int i;
|
|
|
|
memset(pc, 0, sizeof(*pc));
|
|
|
|
for (i = 0; i < s->numpairs; i++, pp++) {
|
|
p = "";
|
|
if (strcasecmp(pp->key, "type") == 0) {
|
|
if (type != NULL) {
|
|
TEST_info("Line %d: multiple type lines", s->curr);
|
|
return 0;
|
|
}
|
|
pc->param = OSSL_PARAM_locate(params, type = pp->value);
|
|
if (pc->param == NULL) {
|
|
TEST_info("Line %d: unknown type line", s->curr);
|
|
return 0;
|
|
}
|
|
} else if (strcasecmp(pp->key, "int32") == 0) {
|
|
if (def_i32++) {
|
|
TEST_info("Line %d: multiple int32 lines", s->curr);
|
|
return 0;
|
|
}
|
|
if (strcasecmp(pp->value, "invalid") != 0) {
|
|
pc->valid_i32 = 1;
|
|
pc->i32 = (int32_t)strtoimax(pp->value, &p, 10);
|
|
}
|
|
} else if (strcasecmp(pp->key, "int64") == 0) {
|
|
if (def_i64++) {
|
|
TEST_info("Line %d: multiple int64 lines", s->curr);
|
|
return 0;
|
|
}
|
|
if (strcasecmp(pp->value, "invalid") != 0) {
|
|
pc->valid_i64 = 1;
|
|
pc->i64 = (int64_t)strtoimax(pp->value, &p, 10);
|
|
}
|
|
} else if (strcasecmp(pp->key, "uint32") == 0) {
|
|
if (def_u32++) {
|
|
TEST_info("Line %d: multiple uint32 lines", s->curr);
|
|
return 0;
|
|
}
|
|
if (strcasecmp(pp->value, "invalid") != 0) {
|
|
pc->valid_u32 = 1;
|
|
pc->u32 = (uint32_t)strtoumax(pp->value, &p, 10);
|
|
}
|
|
} else if (strcasecmp(pp->key, "uint64") == 0) {
|
|
if (def_u64++) {
|
|
TEST_info("Line %d: multiple uint64 lines", s->curr);
|
|
return 0;
|
|
}
|
|
if (strcasecmp(pp->value, "invalid") != 0) {
|
|
pc->valid_u64 = 1;
|
|
pc->u64 = (uint64_t)strtoumax(pp->value, &p, 10);
|
|
}
|
|
} else if (strcasecmp(pp->key, "double") == 0) {
|
|
if (def_d++) {
|
|
TEST_info("Line %d: multiple double lines", s->curr);
|
|
return 0;
|
|
}
|
|
if (strcasecmp(pp->value, "invalid") != 0) {
|
|
pc->valid_d = 1;
|
|
pc->d = strtod(pp->value, &p);
|
|
}
|
|
} else {
|
|
TEST_info("Line %d: unknown keyword %s", s->curr, pp->key);
|
|
return 0;
|
|
}
|
|
if (*p != '\0') {
|
|
TEST_info("Line %d: extra characters at end '%s' for %s",
|
|
s->curr, p, pp->key);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (!TEST_ptr(type)) {
|
|
TEST_info("Line %d: type not found", s->curr);
|
|
return 0;
|
|
}
|
|
|
|
if (strcasecmp(type, "int32") == 0) {
|
|
if (!TEST_true(def_i32) || !TEST_true(pc->valid_i32)) {
|
|
TEST_note("errant int32 on line %d", s->curr);
|
|
return 0;
|
|
}
|
|
datum_i32 = ref_i32 = pc->i32;
|
|
pc->datum = &datum_i32;
|
|
pc->ref = &ref_i32;
|
|
pc->size = sizeof(ref_i32);
|
|
} else if (strcasecmp(type, "int64") == 0) {
|
|
if (!TEST_true(def_i64) || !TEST_true(pc->valid_i64)) {
|
|
TEST_note("errant int64 on line %d", s->curr);
|
|
return 0;
|
|
}
|
|
datum_i64 = ref_i64 = pc->i64;
|
|
pc->datum = &datum_i64;
|
|
pc->ref = &ref_i64;
|
|
pc->size = sizeof(ref_i64);
|
|
} else if (strcasecmp(type, "uint32") == 0) {
|
|
if (!TEST_true(def_u32) || !TEST_true(pc->valid_u32)) {
|
|
TEST_note("errant uint32 on line %d", s->curr);
|
|
return 0;
|
|
}
|
|
datum_u32 = ref_u32 = pc->u32;
|
|
pc->datum = &datum_u32;
|
|
pc->ref = &ref_u32;
|
|
pc->size = sizeof(ref_u32);
|
|
} else if (strcasecmp(type, "uint64") == 0) {
|
|
if (!TEST_true(def_u64) || !TEST_true(pc->valid_u64)) {
|
|
TEST_note("errant uint64 on line %d", s->curr);
|
|
return 0;
|
|
}
|
|
datum_u64 = ref_u64 = pc->u64;
|
|
pc->datum = &datum_u64;
|
|
pc->ref = &ref_u64;
|
|
pc->size = sizeof(ref_u64);
|
|
} else if (strcasecmp(type, "double") == 0) {
|
|
if (!TEST_true(def_d) || !TEST_true(pc->valid_d)) {
|
|
TEST_note("errant double on line %d", s->curr);
|
|
return 0;
|
|
}
|
|
datum_d = ref_d = pc->d;
|
|
pc->datum = &datum_d;
|
|
pc->ref = &ref_d;
|
|
pc->size = sizeof(ref_d);
|
|
} else {
|
|
TEST_error("type unknown at line %d", s->curr);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int param_conversion_test(const PARAM_CONVERSION *pc, int line)
|
|
{
|
|
int32_t i32;
|
|
int64_t i64;
|
|
uint32_t u32;
|
|
uint64_t u64;
|
|
double d;
|
|
|
|
if (!pc->valid_i32) {
|
|
if (!TEST_false(OSSL_PARAM_get_int32(pc->param, &i32))
|
|
|| !TEST_ulong_ne(ERR_get_error(), 0)) {
|
|
TEST_note("unexpected valid conversion to int32 on line %d", line);
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (!TEST_true(OSSL_PARAM_get_int32(pc->param, &i32))
|
|
|| !TEST_true(i32 == pc->i32)) {
|
|
TEST_note("unexpected conversion to int32 on line %d", line);
|
|
return 0;
|
|
}
|
|
memset(pc->datum, 44, pc->size);
|
|
if (!TEST_true(OSSL_PARAM_set_int32(pc->param, i32))
|
|
|| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
|
|
TEST_note("unexpected valid conversion from int32 on line %d",
|
|
line);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (!pc->valid_i64) {
|
|
if (!TEST_false(OSSL_PARAM_get_int64(pc->param, &i64))
|
|
|| !TEST_ulong_ne(ERR_get_error(), 0)) {
|
|
TEST_note("unexpected valid conversion to int64 on line %d", line);
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (!TEST_true(OSSL_PARAM_get_int64(pc->param, &i64))
|
|
|| !TEST_true(i64 == pc->i64)) {
|
|
TEST_note("unexpected conversion to int64 on line %d", line);
|
|
return 0;
|
|
}
|
|
memset(pc->datum, 44, pc->size);
|
|
if (!TEST_true(OSSL_PARAM_set_int64(pc->param, i64))
|
|
|| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
|
|
TEST_note("unexpected valid conversion from int64 on line %d",
|
|
line);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (!pc->valid_u32) {
|
|
if (!TEST_false(OSSL_PARAM_get_uint32(pc->param, &u32))
|
|
|| !TEST_ulong_ne(ERR_get_error(), 0)) {
|
|
TEST_note("unexpected valid conversion to uint32 on line %d", line);
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (!TEST_true(OSSL_PARAM_get_uint32(pc->param, &u32))
|
|
|| !TEST_true(u32 == pc->u32)) {
|
|
TEST_note("unexpected conversion to uint32 on line %d", line);
|
|
return 0;
|
|
}
|
|
memset(pc->datum, 44, pc->size);
|
|
if (!TEST_true(OSSL_PARAM_set_uint32(pc->param, u32))
|
|
|| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
|
|
TEST_note("unexpected valid conversion from uint32 on line %d",
|
|
line);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (!pc->valid_u64) {
|
|
if (!TEST_false(OSSL_PARAM_get_uint64(pc->param, &u64))
|
|
|| !TEST_ulong_ne(ERR_get_error(), 0)) {
|
|
TEST_note("unexpected valid conversion to uint64 on line %d", line);
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (!TEST_true(OSSL_PARAM_get_uint64(pc->param, &u64))
|
|
|| !TEST_true(u64 == pc->u64)) {
|
|
TEST_note("unexpected conversion to uint64 on line %d", line);
|
|
return 0;
|
|
}
|
|
memset(pc->datum, 44, pc->size);
|
|
if (!TEST_true(OSSL_PARAM_set_uint64(pc->param, u64))
|
|
|| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
|
|
TEST_note("unexpected valid conversion from uint64 on line %d",
|
|
line);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (!pc->valid_d) {
|
|
if (!TEST_false(OSSL_PARAM_get_double(pc->param, &d))
|
|
|| !TEST_ulong_ne(ERR_get_error(), 0)) {
|
|
TEST_note("unexpected valid conversion to double on line %d", line);
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (!TEST_true(OSSL_PARAM_get_double(pc->param, &d))) {
|
|
TEST_note("unable to convert to double on line %d", line);
|
|
return 0;
|
|
}
|
|
/*
|
|
* Check for not a number (NaN) without using the libm functions.
|
|
* When d is a NaN, the standard requires d == d to be false.
|
|
* It's less clear if d != d should be true even though it generally is.
|
|
* Hence we use the equality test and a not.
|
|
*/
|
|
if (!(d == d)) {
|
|
/*
|
|
* We've encountered a NaN so check it's really meant to be a NaN.
|
|
* We ignore the case where the two values are both different NaN,
|
|
* that's not resolvable without knowing the underlying format
|
|
* or using libm functions.
|
|
*/
|
|
if (!TEST_false(pc->d == pc->d)) {
|
|
TEST_note("unexpected NaN on line %d", line);
|
|
return 0;
|
|
}
|
|
} else if (!TEST_true(d == pc->d)) {
|
|
TEST_note("unexpected conversion to double on line %d", line);
|
|
return 0;
|
|
}
|
|
memset(pc->datum, 44, pc->size);
|
|
if (!TEST_true(OSSL_PARAM_set_double(pc->param, d))
|
|
|| !TEST_mem_eq(pc->datum, pc->size, pc->ref, pc->size)) {
|
|
TEST_note("unexpected valid conversion from double on line %d",
|
|
line);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int run_param_file_tests(int i)
|
|
{
|
|
STANZA *s;
|
|
PARAM_CONVERSION pc;
|
|
const char *testfile = test_get_argument(i);
|
|
int res = 1;
|
|
|
|
if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
|
|
return 0;
|
|
if (!test_start_file(s, testfile)) {
|
|
OPENSSL_free(s);
|
|
return 0;
|
|
}
|
|
|
|
while (!BIO_eof(s->fp)) {
|
|
if (!test_readstanza(s)) {
|
|
res = 0;
|
|
goto end;
|
|
}
|
|
if (s->numpairs != 0)
|
|
if (!param_conversion_load_stanza(&pc, s)
|
|
|| !param_conversion_test(&pc, s->curr))
|
|
res = 0;
|
|
test_clearstanza(s);
|
|
}
|
|
end:
|
|
test_end_file(s);
|
|
OPENSSL_free(s);
|
|
return res;
|
|
}
|
|
|
|
#endif /* OPENSSL_NO_INTTYPES_H */
|
|
|
|
OPT_TEST_DECLARE_USAGE("file...\n")
|
|
|
|
int setup_tests(void)
|
|
{
|
|
size_t n;
|
|
|
|
if (!test_skip_common_options()) {
|
|
TEST_error("Error parsing test options\n");
|
|
return 0;
|
|
}
|
|
|
|
n = test_get_argument_count();
|
|
if (n == 0)
|
|
return 0;
|
|
|
|
#if !defined(OPENSSL_NO_INTTYPES_H)
|
|
ADD_ALL_TESTS(run_param_file_tests, n);
|
|
#endif /* OPENSSL_NO_INTTYPES_H */
|
|
|
|
return 1;
|
|
}
|