mirror/openssl
2
0
Fork 0
mirror of https://github.com/openssl/openssl.git synced 2024-11-27 05:21:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use common STANZA for bn and exp tests

Browse Source 
Standardize file:line messages
Reduce buff size; move to end of STANZA
Add some Title entries (with blank line after)
Add Title to some BN test files.

Reviewed-by: Andy Polyakov <appro@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3608)
This commit is contained in:
Rich Salz 2017-06-05 13:32:05 -04:00
parent 71dd3b6464
commit ae269dd8b7
10 changed files with 368 additions and 370 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
test/bnmod.txt
View File

@ -5,12 +5,11 @@
# in the file LICENSE in the source distribution or at # in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html # https://www.openssl.org/source/license.html
# Modulus tests.
# ModMul tests.
#
# These test vectors satisfy A * B = ModMul (mod M) and 0 <= ModMul < M. # These test vectors satisfy A * B = ModMul (mod M) and 0 <= ModMul < M.
Title = ModMul tests
ModMul = ae2ca2ce7addaee2e2b7752e286b2bb6a58b51cfbed5c924f00398e59ec36fe6341cd83da43a33a12410f45f6228079c4aeb3912be87e2e81fa1799151bfa0fea29873097475b2c3efa312145d0bf7e51b2a7c9bc961a4f4dcf0c883ff90b919b87c21099fba40257645be31f95a3a277 ModMul = ae2ca2ce7addaee2e2b7752e286b2bb6a58b51cfbed5c924f00398e59ec36fe6341cd83da43a33a12410f45f6228079c4aeb3912be87e2e81fa1799151bfa0fea29873097475b2c3efa312145d0bf7e51b2a7c9bc961a4f4dcf0c883ff90b919b87c21099fba40257645be31f95a3a277
A = 6b18497fed9befdf22a01d988d34213f6687d8a96e86c188dea4172e7c6095a0d18d3c86c0f5a1af9c6e3aaeb6baac2a510930b3ed06ec78ec2e12b A = 6b18497fed9befdf22a01d988d34213f6687d8a96e86c188dea4172e7c6095a0d18d3c86c0f5a1af9c6e3aaeb6baac2a510930b3ed06ec78ec2e12b
B = 1a058d99397db0d209f01212dd4023ae01b15da04fe62d1f76f21622b2695558c67d706c535ca7f19b36f8ef2d508ffd6cf6fcf25e5 B = 1a058d99397db0d209f01212dd4023ae01b15da04fe62d1f76f21622b2695558c67d706c535ca7f19b36f8ef2d508ffd6cf6fcf25e5
@ -2012,10 +2011,10 @@ B = 8bdfa8fe5ef3b2ad02bc63c4d
M = 84daecf412b8c50ad6dfdb546c3eb783dcc6f32003eda914bb M = 84daecf412b8c50ad6dfdb546c3eb783dcc6f32003eda914bb
# ModExp tests.
#
# These test vectors satisfy A ^ E = ModExp (mod M) and 0 <= ModExp < M. # These test vectors satisfy A ^ E = ModExp (mod M) and 0 <= ModExp < M.
Title = ModExp tests
# Regression test for carry propagation bug in sqr8x_reduction. # Regression test for carry propagation bug in sqr8x_reduction.
ModExp = 19324b647d967d644b3219 ModExp = 19324b647d967d644b3219
A = 050505050505 A = 050505050505
@ -2476,11 +2475,11 @@ E = d7e6df5d755284929b986cd9b61c9c2c8843f24c711fbdbae1a468edcae15940094372557072
M = e4e784aa1fa88625a43ba0185a153a929663920be7fe674a4d33c943d3b898cff051482e7050a070cede53be5e89f31515772c7aea637576f99f82708f89d9e244f6ad3a24a02cbe5c0ff7bcf2dad5491f53db7c3f2698a7c41b44f086652f17bb05fe4c5c0a92433c34086b49d7e1825b28bab6c5a9bd0bc95b53d659afa0d7 M = e4e784aa1fa88625a43ba0185a153a929663920be7fe674a4d33c943d3b898cff051482e7050a070cede53be5e89f31515772c7aea637576f99f82708f89d9e244f6ad3a24a02cbe5c0ff7bcf2dad5491f53db7c3f2698a7c41b44f086652f17bb05fe4c5c0a92433c34086b49d7e1825b28bab6c5a9bd0bc95b53d659afa0d7
# ModSqrt tests.
#
# These test vectors satisfy (ModSqrt * ModSqrt) mod P = A mod P with P a prime. # These test vectors satisfy (ModSqrt * ModSqrt) mod P = A mod P with P a prime.
# ModSqrt is in [0, (P-1)/2]. # ModSqrt is in [0, (P-1)/2].
Title = ModSqrt
ModSqrt = 1 ModSqrt = 1
A = 1 A = 1
P = 2 P = 2

8
test/bnmul.txt
View File

@ -5,10 +5,10 @@
# in the file LICENSE in the source distribution or at # in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html # https://www.openssl.org/source/license.html
# Square tests.
#
# These test vectors satisfy A^2 = Square. # These test vectors satisfy A^2 = Square.
Title = Square tests.
# Regression test for a BN_sqr overflow bug. # Regression test for a BN_sqr overflow bug.
Square = 4000000000000000800000000000000240000000000000000000000000000001fffffffffffffff8000000000000000400000000000000000000000000000000 Square = 4000000000000000800000000000000240000000000000000000000000000001fffffffffffffff8000000000000000400000000000000000000000000000000
A = 80000000000000008000000000000001fffffffffffffffe0000000000000000 A = 80000000000000008000000000000001fffffffffffffffe0000000000000000
@ -318,10 +318,10 @@ Square = eea8028b26e0df090504d54da714a6f5f2695202e53cff479c78aedd47a8dc676243ec5
A = -3dcb44be1e54c5a5d7db48055ca9afa1ebe2ae648aa6e16ac497502a7deee09ffa124720fad0ab163ce8b3ea6a90f110ea52b67dbc424d0cf1e8c9726dfd9e45bebcefaa5cd5706edeed27896525f31c6bbea3d67ee97badefabf3e2532470b66e3ae3100f66ddf50cf02fc3a8e3f44c304251d3b6a7ca3a6e4bd5d16a41bd97a4 A = -3dcb44be1e54c5a5d7db48055ca9afa1ebe2ae648aa6e16ac497502a7deee09ffa124720fad0ab163ce8b3ea6a90f110ea52b67dbc424d0cf1e8c9726dfd9e45bebcefaa5cd5706edeed27896525f31c6bbea3d67ee97badefabf3e2532470b66e3ae3100f66ddf50cf02fc3a8e3f44c304251d3b6a7ca3a6e4bd5d16a41bd97a4
# Product tests.
#
# These test vectors satisfy A * B = Product. # These test vectors satisfy A * B = Product.
Title = Product tests
Product = 5befab3320f8f90542f3120235abd926aac3805a19e343f690 Product = 5befab3320f8f90542f3120235abd926aac3805a19e343f690
A = b057af553afb120db6b7764f8 A = b057af553afb120db6b7764f8
B = 857734c4c27a1d17f7cf59dee B = 857734c4c27a1d17f7cf59dee

12
test/bnshift.txt
View File

@ -5,10 +5,10 @@
# in the file LICENSE in the source distribution or at # in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html # https://www.openssl.org/source/license.html
# LShift1 tests.
#
# These test vectors satisfy A * 2 = LShift1 # These test vectors satisfy A * 2 = LShift1
Title = Lshift1 tests
LShift1 = 0 LShift1 = 0
A = 0 A = 0
@ -1213,10 +1213,10 @@ LShift1 = -ab4e80e4b56556d99108eb3cb35f17d1ae83da33b4138619070000000000000000000
A = -55a740725ab2ab6cc884759e59af8be8d741ed19da09c30c838000000000000000000000000 A = -55a740725ab2ab6cc884759e59af8be8d741ed19da09c30c838000000000000000000000000
# LShift tests
#
# These test vectors satisfy A * 2^N = LShift. # These test vectors satisfy A * 2^N = LShift.
Title = LShift tests
LShift = 18c9e860855d594dcb06d00b7d1933608ba906d85fa2d92c9e0 LShift = 18c9e860855d594dcb06d00b7d1933608ba906d85fa2d92c9e0
A = c64f43042aeaca6e5836805be8c99b045d4836c2fd16c964f0 A = c64f43042aeaca6e5836805be8c99b045d4836c2fd16c964f0
N = 1 N = 1
@ -2018,10 +2018,10 @@ A = e8e7c5ae65d7333de82bcbfdd7cea60ffb11e600aa3088ec8e
N = 64 N = 64
# RShift tests
#
# These test vectors satisfy A / 2^N = RShift, rounding towards zero. # These test vectors satisfy A / 2^N = RShift, rounding towards zero.
Title = RShift tests
Rshift = 0 Rshift = 0
A = -1 A = -1
N = 1 N = 1

131
test/bntest.c
View File

@ -35,26 +35,12 @@ BIGNUM *bn_expand2(BIGNUM *b, int words);
BIGNUM *bn_expand2(BIGNUM *b, int words) { return NULL; } BIGNUM *bn_expand2(BIGNUM *b, int words) { return NULL; }
#include "../crypto/bn/bn_lcl.h" #include "../crypto/bn/bn_lcl.h"
#define MAXPAIRS 20
/* /*
* Things in boring, not in openssl. TODO we should add them. * Things in boring, not in openssl. TODO we should add them.
*/ */
#define HAVE_BN_PADDED 0 #define HAVE_BN_PADDED 0
#define HAVE_BN_SQRT 0 #define HAVE_BN_SQRT 0
typedef struct pair_st {
char *key;
char *value;
} PAIR;
typedef struct stanza_st {
int curr; /* Current line in file */
int start; /* Line where test starts */
int numpairs;
PAIR pairs[MAXPAIRS];
} STANZA;
typedef struct filetest_st { typedef struct filetest_st {
const char *name; const char *name;
int (*func)(STANZA *s); int (*func)(STANZA *s);
@ -68,7 +54,6 @@ typedef struct mpitest_st {
static const int NUM0 = 100; /* number of tests */ static const int NUM0 = 100; /* number of tests */
static const int NUM1 = 50; /* additional tests for some functions */ static const int NUM1 = 50; /* additional tests for some functions */
static BIO *fp;
static BN_CTX *ctx; static BN_CTX *ctx;
/* /*
@ -113,7 +98,7 @@ static BIGNUM *getBN(STANZA *s, const char *attribute)
BIGNUM *ret = NULL; BIGNUM *ret = NULL;
if ((hex = findattr(s, attribute)) == NULL) { if ((hex = findattr(s, attribute)) == NULL) {
TEST_error("Can't find %s in test at line %d", attribute, s->start); TEST_error("%s:%d: Can't find %s", s->test_file, s->start, attribute);
return NULL; return NULL;
} }
@ -1986,85 +1971,6 @@ err:
return ret; return ret;
} }
/* Delete leading and trailing spaces from a string */
static char *strip_spaces(char *p)
{
char *q;
/* Skip over leading spaces */
while (*p && isspace(*p))
p++;
if (!*p)
return NULL;
for (q = p + strlen(p) - 1; q != p && isspace(*q); )
*q-- = '\0';
return *p ? p : NULL;
}
/*
* Read next test stanza; return 1 if found, 0 on EOF or error.
*/
static int readstanza(STANZA *s)
{
PAIR *pp = s->pairs;
char *p, *equals, *key, *value;
char buff[1024];
while (BIO_gets(fp, buff, sizeof(buff))) {
s->curr++;
if (!TEST_ptr(p = strchr(buff, '\n'))) {
TEST_info("Line %d too long", s->curr);
return 0;
}
*p = '\0';
/* Blank line marks end of tests. */
if (buff[0] == '\0')
break;
/* Lines starting with a pound sign are ignored. */
if (buff[0] == '#')
continue;
if (!TEST_ptr(equals = strchr(buff, '='))) {
TEST_info("Missing = at line %d\n", s->curr);
return 0;
}
*equals++ = '\0';
if (s->numpairs == 0)
s->start = s->curr;
if (!TEST_ptr(key = strip_spaces(buff))
|| !TEST_ptr(value = strip_spaces(equals))
|| !TEST_int_lt(s->numpairs++, MAXPAIRS)
|| !TEST_ptr(pp->key = OPENSSL_strdup(key))
|| !TEST_ptr(pp->value = OPENSSL_strdup(value)))
return 0;
pp++;
}
/* If we read anything, return ok. */
return 1;
}
static void clearstanza(STANZA *s)
{
PAIR *pp = s->pairs;
int i = s->numpairs;
int start = s->start;
int curr = s->curr;
for ( ; --i >= 0; pp++) {
OPENSSL_free(pp->key);
OPENSSL_free(pp->value);
}
memset(s, 0, sizeof(*s));
s->curr = curr;
s->start = start;
}
static int file_test_run(STANZA *s) static int file_test_run(STANZA *s)
{ {
static const FILETEST filetests[] = { static const FILETEST filetests[] = {
@ -2086,13 +1992,14 @@ static int file_test_run(STANZA *s)
for ( ; --numtests >= 0; tp++) { for ( ; --numtests >= 0; tp++) {
if (findattr(s, tp->name) != NULL) { if (findattr(s, tp->name) != NULL) {
if (!tp->func(s)) { if (!tp->func(s)) {
TEST_info("Failed %s test at %d", tp->name, s->start); TEST_info("%s:%d: Failed %s test",
s->test_file, s->start, tp->name);
return 0; return 0;
} }
return 1; return 1;
} }
} }
TEST_info("Unknown test at %d", s->start); TEST_info("%s:%d: Unknown test", s->test_file, s->start);
return 0; return 0;
} }
@ -2100,26 +2007,30 @@ static char * const *testfiles;
static int run_file_tests(int i) static int run_file_tests(int i)
{ {
STANZA s; STANZA *s = NULL;
int errcnt = 0; int c;
if (!TEST_ptr(fp = BIO_new_file(testfiles[i], "rb"))) if (!TEST_ptr(s = OPENSSL_zalloc(sizeof(*s))))
return 0; return 0;
if (!test_start_file(s, testfiles[i])) {
OPENSSL_free(s);
return 0;
}
/* Read test file. */ /* Read test file. */
set_test_title(testfiles[i]); while (!BIO_eof(s->fp) && test_readstanza(s)) {
memset(&s, 0, sizeof(s)); if (s->numpairs == 0)
while (!BIO_eof(fp) && readstanza(&s)) {
if (s.numpairs == 0)
continue; continue;
if (!file_test_run(&s)) { if (!file_test_run(s))
errcnt++; s->errors++;
} s->numtests++;
clearstanza(&s); test_clearstanza(s);
} }
BIO_free(fp); test_end_file(s);
c = s->errors;
OPENSSL_free(s);
return errcnt == 0; return c == 0;
} }

2
test/build.info
View File

@ -10,7 +10,7 @@
IF[{- !$disabled{tests} -}] IF[{- !$disabled{tests} -}]
LIBS_NO_INST=libtestutil.a LIBS_NO_INST=libtestutil.a
SOURCE[libtestutil.a]=testutil/basic_output.c testutil/output_helpers.c \ SOURCE[libtestutil.a]=testutil/basic_output.c testutil/output_helpers.c \
testutil/driver.c testutil/tests.c testutil/cb.c \ testutil/driver.c testutil/tests.c testutil/cb.c testutil/stanza.c \
{- rebase_files("../apps", $target{apps_aux_src}) -} \ {- rebase_files("../apps", $target{apps_aux_src}) -} \
testutil/test_main.c testutil/main.c testutil/test_main.c testutil/main.c
INCLUDE[libtestutil.a]=.. ../include INCLUDE[libtestutil.a]=.. ../include

355
test/evp_test.c
View File

@ -28,15 +28,9 @@ typedef struct evp_test_method_st EVP_TEST_METHOD;
* Structure holding test information * Structure holding test information
*/ */
typedef struct evp_test_st { typedef struct evp_test_st {
BIO *in; /* file being read */ STANZA s; /* Common test stanza */
int line; /* current line being processed */ char *name;
int start_line; /* start line of current test */
int ntests; /* Number of tests */
int errors; /* Error count */
int skip; /* Current test should be skipped */ int skip; /* Current test should be skipped */
int nskip; /* Number of tests skipped */
char buf[10240]; /* Input buffer */
BIO *key; /* temp memory BIO for reading in keys */
const EVP_TEST_METHOD *meth; /* method for this test */ const EVP_TEST_METHOD *meth; /* method for this test */
const char *err, *aux_err; /* Error string for test */ const char *err, *aux_err; /* Error string for test */
char *expected_err; /* Expected error value of test */ char *expected_err; /* Expected error value of test */
@ -80,8 +74,6 @@ static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst);
static int parse_bin(const char *value, unsigned char **buf, size_t *buflen); static int parse_bin(const char *value, unsigned char **buf, size_t *buflen);
static const char *current_test_file = "???";
/* /*
* Structure used to hold a list of blocks of memory to test * Structure used to hold a list of blocks of memory to test
* calls to "update" like functions. * calls to "update" like functions.
@ -2110,6 +2102,7 @@ static const EVP_TEST_METHOD *find_test(const char *name)
static void clear_test(EVP_TEST *t) static void clear_test(EVP_TEST *t)
{ {
test_clearstanza(&t->s);
ERR_clear_error(); ERR_clear_error();
if (t->data != NULL) { if (t->data != NULL) {
if (t->meth != NULL) if (t->meth != NULL)
@ -2123,6 +2116,7 @@ static void clear_test(EVP_TEST *t)
t->func = NULL; t->func = NULL;
OPENSSL_free(t->reason); OPENSSL_free(t->reason);
t->reason = NULL; t->reason = NULL;
/* Text literal. */ /* Text literal. */
t->err = NULL; t->err = NULL;
t->skip = 0; t->skip = 0;
@ -2142,25 +2136,23 @@ static int check_test_error(EVP_TEST *t)
return 1; return 1;
if (t->err != NULL && t->expected_err == NULL) { if (t->err != NULL && t->expected_err == NULL) {
if (t->aux_err != NULL) { if (t->aux_err != NULL) {
TEST_info("Above error from the test at %s:%d " TEST_info("%s:%d: Source of above error (%s); unexpected error %s",
"(%s) unexpected error %s", t->s.test_file, t->s.start, t->aux_err, t->err);
current_test_file, t->start_line, t->aux_err, t->err);
} else { } else {
TEST_info("Above error from the test at %s:%d " TEST_info("%s:%d: Source of above error; unexpected error %s",
"unexpected error %s", t->s.test_file, t->s.start, t->err);
current_test_file, t->start_line, t->err);
} }
return 0; return 0;
} }
if (t->err == NULL && t->expected_err != NULL) { if (t->err == NULL && t->expected_err != NULL) {
TEST_info("Test line %d: succeeded but was expecting %s", TEST_info("%s:%d: Succeeded but was expecting %s",
t->start_line, t->expected_err); t->s.test_file, t->s.start, t->expected_err);
return 0; return 0;
} }
if (strcmp(t->err, t->expected_err) != 0) { if (strcmp(t->err, t->expected_err) != 0) {
TEST_info("Test line %d: expecting %s got %s", TEST_info("%s:%d: Expected %s got %s",
t->start_line, t->expected_err, t->err); t->s.test_file, t->s.start, t->expected_err, t->err);
return 0; return 0;
} }
@ -2168,32 +2160,32 @@ static int check_test_error(EVP_TEST *t)
return 1; return 1;
if (t->func == NULL || t->reason == NULL) { if (t->func == NULL || t->reason == NULL) {
TEST_info("Test line %d: missing function or reason code", TEST_info("%s:%d: Test is missing function or reason code",
t->start_line); t->s.test_file, t->s.start);
return 0; return 0;
} }
err = ERR_peek_error(); err = ERR_peek_error();
if (err == 0) { if (err == 0) {
TEST_info("Test line %d, expected error \"%s:%s\" not set", TEST_info("%s:%d: Expected error \"%s:%s\" not set",
t->start_line, t->func, t->reason); t->s.test_file, t->s.start, t->func, t->reason);
return 0; return 0;
} }
func = ERR_func_error_string(err); func = ERR_func_error_string(err);
reason = ERR_reason_error_string(err); reason = ERR_reason_error_string(err);
if (func == NULL && reason == NULL) { if (func == NULL && reason == NULL) {
TEST_info("Test line %d: expected error \"%s:%s\"," TEST_info("%s:%d: Expected error \"%s:%s\", no strings available."
" no strings available. Skipping...\n", " Assuming ok.",
t->start_line, t->func, t->reason); t->s.test_file, t->s.start, t->func, t->reason);
return 1; return 1;
} }
if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0) if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
return 1; return 1;
TEST_info("Test line %d: expected error \"%s:%s\", got \"%s:%s\"", TEST_info("%s:%d: Expected error \"%s:%s\", got \"%s:%s\"",
t->start_line, t->func, t->reason, func, reason); t->s.test_file, t->s.start, t->func, t->reason, func, reason);
return 0; return 0;
} }
@ -2205,18 +2197,19 @@ static int run_test(EVP_TEST *t)
{ {
if (t->meth == NULL) if (t->meth == NULL)
return 1; return 1;
t->ntests++; t->s.numtests++;
if (t->skip) { if (t->skip) {
t->nskip++; t->s.numskip++;
} else { } else {
/* run the test */ /* run the test */
if (t->err == NULL && t->meth->run_test(t) != 1) { if (t->err == NULL && t->meth->run_test(t) != 1) {
TEST_info("Line %d error %s", t->start_line, t->meth->name); TEST_info("%s:%d %s error",
t->s.test_file, t->s.start, t->meth->name);
return 0; return 0;
} }
if (!check_test_error(t)) { if (!check_test_error(t)) {
test_openssl_errors(); test_openssl_errors();
t->errors++; t->s.errors++;
} }
} }
@ -2248,90 +2241,6 @@ static void free_key_list(KEY_LIST *lst)
} }
} }
/*
* Read a line, remove the newline, return EOF or first char.
* Comment lines are treated like empty lines.
*/
static int read_line(EVP_TEST *t)
{
char *p;
if (!BIO_gets(t->in, t->buf, sizeof(t->buf)))
return EOF;
t->line++;
if ((p = strchr(t->buf, '\n')) != NULL)
*p = '\0';
if (t->buf[0] == '#')
t->buf[0] = '\0';
return t->buf[0];
}
/*
* Skip leading spaces and remove trailing spaces from string.
*/
static char *strip_spaces(char *pval)
{
char *p, *start;
for (start = pval; isspace(*start); )
start++;
if (*start == '\0')
return start;
for (p = start + strlen(start); --p >= start && isspace(*p); )
*p = '\0';
return start;
}
/*
* Split line into 'key = value'; return 1 if okay, 0 on error.
*/
static int split_line(EVP_TEST *t, char **keyword, char **value)
{
char *p;
/* Look for = sign */
if ((p = strchr(t->buf, '=')) == NULL) {
TEST_error("Line %d: Missing '=' in test file", t->line);
return 0;
}
*p++ = '\0';
*keyword = strip_spaces(t->buf);
*value = strip_spaces(p);
if (**keyword == '\0') {
TEST_error("Line %d: Missing key; malformed input line", t->line);
return 0;
}
return 1;
}
/*
* Read a PEM block. Return 1 if okay, 0 on error.
*/
static int read_key(EVP_TEST *t)
{
char tmpbuf[128];
if (t->key == NULL) {
if (!TEST_ptr(t->key = BIO_new(BIO_s_mem())))
return 0;
} else if (!TEST_int_gt(BIO_reset(t->key), 0)) {
return 0;
}
/* Read to PEM end line and place content in memory BIO */
while (BIO_gets(t->in, tmpbuf, sizeof(tmpbuf))) {
t->line++;
if (!TEST_int_gt(BIO_puts(t->key, tmpbuf), 0))
return 0;
if (strncmp(tmpbuf, "-----END", 8) == 0)
return 1;
}
TEST_error("Can't find key end");
return 0;
}
/* /*
* Is the key type an unsupported algorithm? * Is the key type an unsupported algorithm?
*/ */
@ -2360,54 +2269,52 @@ static int key_unsupported()
} }
/* /*
* Read, parse, and execute one test. Return EOF; 0 if failure, 1 if okay. * NULL out the value from |pp| but return it. This "steals" a pointer.
*/ */
static int read_stanza(EVP_TEST *t) static char *take_value(PAIR *pp)
{ {
int c; char *p = pp->value;
char *keyword, *value;
KEY_LIST **klist, *key; pp->value = NULL;
return p;
}
/*
* Read and parse one test. Return 0 if failure, 1 if okay.
*/
static int parse(EVP_TEST *t)
{
KEY_LIST *key, **klist;
EVP_PKEY *pkey; EVP_PKEY *pkey;
PAIR *pp;
int i;
clear_test(t);
top: top:
/* Find the first line of a stanza. */ do {
for ( ; ; ) { if (BIO_eof(t->s.fp))
c = read_line(t);
if (c == EOF)
return EOF; return EOF;
if (c == '\0') clear_test(t);
continue; if (!test_readstanza(&t->s))
break; return 0;
} } while (t->s.numpairs == 0);
if (!split_line(t, &keyword, &value)) pp = &t->s.pairs[0];
return 0;
/* Handle a few special cases here. */
if (strcmp(keyword, "Title") == 0) {
TEST_info("Starting \"%s\" tests", value);
goto top;
}
/* Are we adding a key? */
klist = NULL; klist = NULL;
pkey = NULL; pkey = NULL;
if (strcmp(keyword, "PrivateKey") == 0) { if (strcmp(pp->key, "PrivateKey") == 0) {
if (!read_key(t)) pkey = PEM_read_bio_PrivateKey(t->s.key, NULL, 0, NULL);
return 0;
pkey = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL);
if (pkey == NULL && !key_unsupported()) { if (pkey == NULL && !key_unsupported()) {
TEST_info("Can't read private key %s", value); TEST_info("Can't read private key %s", pp->value);
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return 0; return 0;
} }
klist = &private_keys; klist = &private_keys;
} }
else if (strcmp(keyword, "PublicKey") == 0) { else if (strcmp(pp->key, "PublicKey") == 0) {
if (!read_key(t)) pkey = PEM_read_bio_PUBKEY(t->s.key, NULL, 0, NULL);
return 0;
pkey = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL);
if (pkey == NULL && !key_unsupported()) { if (pkey == NULL && !key_unsupported()) {
TEST_info("Can't read public key %s", value); TEST_info("Can't read public key %s", pp->value);
ERR_print_errors_fp(stderr); ERR_print_errors_fp(stderr);
return 0; return 0;
} }
@ -2416,135 +2323,105 @@ top:
/* If we have a key add to list */ /* If we have a key add to list */
if (klist != NULL) { if (klist != NULL) {
if (find_key(NULL, value, *klist)) { if (find_key(NULL, pp->value, *klist)) {
TEST_info("Duplicate key %s", value); TEST_info("Duplicate key %s", pp->value);
return 0; return 0;
} }
if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))) if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
|| !TEST_ptr(key->name = OPENSSL_strdup(value)))
return 0; return 0;
key->name = take_value(pp);
key->key = pkey; key->key = pkey;
key->next = *klist; key->next = *klist;
*klist = key; *klist = key;
/* Go back and start a new stanza. */ /* Go back and start a new stanza. */
if (t->s.numpairs != 1)
TEST_info("Line %d: missing blank line\n", t->s.curr);
goto top; goto top;
} }
/* Start of a new text. Look it up. */ /* Find the test, based on first keyword. */
if (!TEST_ptr(t->meth = find_test(keyword))) if (!TEST_ptr(t->meth = find_test(pp->key)))
goto skiptoend; return 0;
t->start_line = t->line; if (!t->meth->init(t, pp->value)) {
if (!t->meth->init(t, value)) { TEST_error("unknown %s: %s\n", pp->key, pp->value);
TEST_error("unknown %s: %s\n", keyword, value); return 0;
goto skiptoend;
} }
if (t->skip == 1) { if (t->skip == 1) {
/* TEST_info("skipping %s %s", keyword, value); */ /* TEST_info("skipping %s %s", pp->key, pp->value); */
goto skiptoend; return 0;
} }
/* Read rest of stanza. */ for (pp++, i = 1; i < t->s.numpairs; pp++, i++) {
for ( ; ; ) { if (strcmp(pp->key, "Result") == 0) {
c = read_line(t);
if (c == EOF)
return c;
if (c == '\0')
break;
if (!split_line(t, &keyword, &value))
goto skiptoend;
if (strcmp(keyword, "Result") == 0) {
if (t->expected_err != NULL) { if (t->expected_err != NULL) {
TEST_info("Line %d: multiple result lines", t->line); TEST_info("Line %d: multiple result lines", t->s.curr);
goto skiptoend; return 0;
} }
if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value))) t->expected_err = take_value(pp);
goto skiptoend; } else if (strcmp(pp->key, "Function") == 0) {
} else if (strcmp(keyword, "Function") == 0) {
if (t->func != NULL) { if (t->func != NULL) {
TEST_info("Line %d: multiple function lines\n", t->line); TEST_info("Line %d: multiple function lines\n", t->s.curr);
goto skiptoend; return 0;
} }
if (!TEST_ptr(t->func = OPENSSL_strdup(value))) t->func = take_value(pp);
goto skiptoend; } else if (strcmp(pp->key, "Reason") == 0) {
} else if (strcmp(keyword, "Reason") == 0) {
if (t->reason != NULL) { if (t->reason != NULL) {
TEST_info("Line %d: multiple reason lines", t->line); TEST_info("Line %d: multiple reason lines", t->s.curr);
goto skiptoend; return 0;
} }
if (!TEST_ptr(t->reason = OPENSSL_strdup(value))) t->reason = take_value(pp);
goto skiptoend;
} else { } else {
/* Must be test specific line: try to parse it */ /* Must be test specific line: try to parse it */
int rv = t->meth->parse(t, keyword, value); int rv = t->meth->parse(t, pp->key, pp->value);
if (rv == 0) { if (rv == 0) {
TEST_info("Line %d: unknown keyword %s", t->line, keyword); TEST_info("Line %d: unknown keyword %s", t->s.curr, pp->key);
goto skiptoend; return 0;
} }
if (rv < 0) { if (rv < 0) {
TEST_info("Line %d: error processing keyword %s\n", TEST_info("Line %d: error processing keyword %s\n",
t->line, keyword); t->s.curr, pp->key);
goto skiptoend; return 0;
} }
} }
} }
return 1; return 1;
skiptoend:
/* Read to end of stanza and return failure */
for ( ; ; ) {
c = read_line(t);
if (c == EOF)
return EOF;
if (c == '\0')
break;
}
return 0;
}
static int do_test_file(const char *testfile)
{
BIO *in;
EVP_TEST t;
int c;
set_test_title(testfile);
current_test_file = testfile;
if (!TEST_ptr(in = BIO_new_file(testfile, "rb")))
return 0;
memset(&t, 0, sizeof(t));
t.in = in;
TEST_info("Reading %s", testfile);
for ( ; ; ) {
c = read_stanza(&t);
if (t.skip)
continue;
if (c == 0 || !run_test(&t)) {
t.errors++;
break;
}
if (c == EOF)
break;
}
clear_test(&t);
TEST_info("Completed %d tests with %d errors and %d skipped",
t.ntests, t.errors, t.nskip);
free_key_list(public_keys);
free_key_list(private_keys);
BIO_free(t.key);
BIO_free(in);
return t.errors == 0;
} }
static char * const *testfiles; static char * const *testfiles;
static int run_file_tests(int i) static int run_file_tests(int i)
{ {
return do_test_file(testfiles[i]); EVP_TEST *t;
int c;
if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
return 0;
if (!test_start_file(&t->s, testfiles[i])) {
OPENSSL_free(t);
return 0;
}
while (!BIO_eof(t->s.fp)) {
c = parse(t);
if (t->skip)
continue;
if (c == 0 || !run_test(t)) {
t->s.errors++;
break;
}
}
test_end_file(&t->s);
clear_test(t);
free_key_list(public_keys);
free_key_list(private_keys);
BIO_free(t->s.key);
c = t->s.errors;
OPENSSL_free(t);
return c == 0;
} }
int test_main(int argc, char *argv[]) int test_main(int argc, char *argv[])

1
test/evpciph.txt
View File

@ -1178,6 +1178,7 @@ Operation = DECRYPT
Result = CIPHERFINAL_ERROR Result = CIPHERFINAL_ERROR
Title = AES XTS test vectors from IEEE Std 1619-2007 Title = AES XTS test vectors from IEEE Std 1619-2007
Cipher = aes-128-xts Cipher = aes-128-xts
Key = 0000000000000000000000000000000000000000000000000000000000000000 Key = 0000000000000000000000000000000000000000000000000000000000000000
IV = 00000000000000000000000000000000 IV = 00000000000000000000000000000000

13
test/evppkey.txt
View File

@ -708,6 +708,7 @@ PrivateKey=Alice-25519
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VuBCIEIHcHbQpzGKV9PBbBclGyZkXfTC+H68CZKrF3+6UduSwq MC4CAQAwBQYDK2VuBCIEIHcHbQpzGKV9PBbBclGyZkXfTC+H68CZKrF3+6UduSwq
-----END PRIVATE KEY----- -----END PRIVATE KEY-----
PublicKey=Alice-25519-PUBLIC PublicKey=Alice-25519-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VuAyEAhSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo= MCowBQYDK2VuAyEAhSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo=
@ -719,6 +720,7 @@ PrivateKey=Bob-25519
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VuBCIEIF2rCH5iSopLeeF/i4OADuZvO7EpJhi2/Rwviyf/iODr MC4CAQAwBQYDK2VuBCIEIF2rCH5iSopLeeF/i4OADuZvO7EpJhi2/Rwviyf/iODr
-----END PRIVATE KEY----- -----END PRIVATE KEY-----
PublicKey=Bob-25519-PUBLIC PublicKey=Bob-25519-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VuAyEA3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08= MCowBQYDK2VuAyEA3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08=
@ -747,9 +749,9 @@ Function = EVP_PKEY_verify_init
Reason = operation not supported for this keytype Reason = operation not supported for this keytype
Title = RSA PSS/OAEP (from RSASecurity FTP)
# Additional RSA-PSS and RSA-OAEP tests converted from # Additional RSA-PSS and RSA-OAEP tests converted from
# ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip # ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
Title = RSA PSS/OAEP (from RSASecurity FTP)
PublicKey=RSA-PSS-1 PublicKey=RSA-PSS-1
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
@ -5811,7 +5813,6 @@ SharedSecret=A7927098655F1F9976FA50A9D566865DC530331846381C87256BAF3226244B76D36
# 456068d3f8aad8ac62a03d19ed3173f00ad51f42b51aeab4753c20f30c01cf23 # # 456068d3f8aad8ac62a03d19ed3173f00ad51f42b51aeab4753c20f30c01cf23 #
Title = ECDH KATs (from NIST SP800-56A co-factor ECDH KATs Title = ECDH KATs (from NIST SP800-56A co-factor ECDH KATs
PrivateKey=KAS-ECC-CDH_P-192_C0 PrivateKey=KAS-ECC-CDH_P-192_C0
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MG8CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEVTBTAgEBBBjxfT/qNnt000CFHKQn MG8CAQAwEwYHKoZIzj0CAQYIKoZIzj0DAQEEVTBTAgEBBBjxfT/qNnt000CFHKQn
@ -17327,18 +17328,22 @@ PrivateKey=ED25519-1
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIJ1hsZ3v/VpguoRK9JLsLMREScVpezJpGXA7rAMcrn9g MC4CAQAwBQYDK2VwBCIEIJ1hsZ3v/VpguoRK9JLsLMREScVpezJpGXA7rAMcrn9g
-----END PRIVATE KEY----- -----END PRIVATE KEY-----
PrivateKey=ED25519-2 PrivateKey=ED25519-2
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIEzNCJso/5banbbDRuwRTg9bijGfNaumJNqM9u1PuKb7 MC4CAQAwBQYDK2VwBCIEIEzNCJso/5banbbDRuwRTg9bijGfNaumJNqM9u1PuKb7
-----END PRIVATE KEY----- -----END PRIVATE KEY-----
PrivateKey=ED25519-3 PrivateKey=ED25519-3
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIMWqjfQ/n4N77bdELzHct7Fm04U1B28JS4XOOi4LRFj3 MC4CAQAwBQYDK2VwBCIEIMWqjfQ/n4N77bdELzHct7Fm04U1B28JS4XOOi4LRFj3
-----END PRIVATE KEY----- -----END PRIVATE KEY-----
PrivateKey=ED25519-4 PrivateKey=ED25519-4
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIPXldnzxUzGVF2MPImh2uGyBYMxYO8ATdExr8lX1zA7l MC4CAQAwBQYDK2VwBCIEIPXldnzxUzGVF2MPImh2uGyBYMxYO8ATdExr8lX1zA7l
-----END PRIVATE KEY----- -----END PRIVATE KEY-----
PrivateKey=ED25519-5 PrivateKey=ED25519-5
-----BEGIN PRIVATE KEY----- -----BEGIN PRIVATE KEY-----
MC4CAQAwBQYDK2VwBCIEIIM/5iQJI3udYux3WHUgkR6adZzsHRl1W32pAbltyj1C MC4CAQAwBQYDK2VwBCIEIIM/5iQJI3udYux3WHUgkR6adZzsHRl1W32pAbltyj1C
@ -17348,18 +17353,22 @@ PublicKey=ED25519-1-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEA11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo= MCowBQYDK2VwAyEA11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo=
-----END PUBLIC KEY----- -----END PUBLIC KEY-----
PublicKey=ED25519-2-PUBLIC PublicKey=ED25519-2-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAPUAXw+hDiVqStwqnTRt+vJyYLM8uxJaMwM1V8Sr0Zgw= MCowBQYDK2VwAyEAPUAXw+hDiVqStwqnTRt+vJyYLM8uxJaMwM1V8Sr0Zgw=
-----END PUBLIC KEY----- -----END PUBLIC KEY-----
PublicKey=ED25519-3-PUBLIC PublicKey=ED25519-3-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEA/FHNjmIYoaONpH7QAjDwWAgW7RO6MwOsXeuRFUiQgCU= MCowBQYDK2VwAyEA/FHNjmIYoaONpH7QAjDwWAgW7RO6MwOsXeuRFUiQgCU=
-----END PUBLIC KEY----- -----END PUBLIC KEY-----
PublicKey=ED25519-4-PUBLIC PublicKey=ED25519-4-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAJ4EX/BRMcjQPZ9DyMW6Dhs7/vyskKMnFH+98WX8dQm4= MCowBQYDK2VwAyEAJ4EX/BRMcjQPZ9DyMW6Dhs7/vyskKMnFH+98WX8dQm4=
-----END PUBLIC KEY----- -----END PUBLIC KEY-----
PublicKey=ED25519-5-PUBLIC PublicKey=ED25519-5-PUBLIC
-----BEGIN PUBLIC KEY----- -----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEA7Bcrk61eVjv0kyxw4SRQNMNUZ+8u/U1k6/gZaDRn4r8= MCowBQYDK2VwAyEA7Bcrk61eVjv0kyxw4SRQNMNUZ+8u/U1k6/gZaDRn4r8=

44
test/testutil.h
View File

@ -402,4 +402,48 @@ void test_openssl_errors(void);
extern BIO *bio_out; extern BIO *bio_out;
extern BIO *bio_err; extern BIO *bio_err;
/*
* Utilities to parse a test file.
*/
#define TESTMAXPAIRS 20
typedef struct pair_st {
char *key;
char *value;
} PAIR;
typedef struct stanza_st {
const char *test_file; /* Input file name */
BIO *fp; /* Input file */
int curr; /* Current line in file */
int start; /* Line where test starts */
int errors; /* Error count */
int numtests; /* Number of tests */
int numskip; /* Number of skipped tests */
int numpairs;
PAIR pairs[TESTMAXPAIRS];
BIO *key; /* temp memory BIO for reading in keys */
char buff[4096]; /* Input buffer for a single key/value */
} STANZA;
/*
* Prepare to start reading the file |testfile| as input.
*/
int test_start_file(STANZA *s, const char *testfile);
int test_end_file(STANZA *s);
/*
* Read a stanza from the test file. A stanza consists of a block
* of lines of the form
* key = value
* The block is terminated by EOF or a blank line.
* Return 1 if found, 0 on EOF or error.
*/
int test_readstanza(STANZA *s);
/*
* Clear a stanza, release all allocated memory.
*/
void test_clearstanza(STANZA *s);
#endif /* HEADER_TESTUTIL_H */ #endif /* HEADER_TESTUTIL_H */

157
test/testutil/stanza.c Normal file
View File

@ -0,0 +1,157 @@
/*
* Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the OpenSSL license (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 <assert.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "e_os.h"
#include "../testutil.h"
int test_start_file(STANZA *s, const char *testfile)
{
TEST_info("Reading %s", testfile);
set_test_title(testfile);
memset(s, 0, sizeof(*s));
if (!TEST_ptr(s->fp = BIO_new_file(testfile, "rb")))
return 0;
s->test_file = testfile;
return 1;
}
int test_end_file(STANZA *s)
{
TEST_info("Completed %d tests with %d errors and %d skipped",
s->numtests, s->errors, s->numskip);
BIO_free(s->fp);
return 1;
}
/*
* Read a PEM block. Return 1 if okay, 0 on error.
*/
static int read_key(STANZA *s)
{
char tmpbuf[128];
if (s->key == NULL) {
if (!TEST_ptr(s->key = BIO_new(BIO_s_mem())))
return 0;
} else if (!TEST_int_gt(BIO_reset(s->key), 0)) {
return 0;
}
/* Read to PEM end line and place content in memory BIO */
while (BIO_gets(s->fp, tmpbuf, sizeof(tmpbuf))) {
s->curr++;
if (!TEST_int_gt(BIO_puts(s->key, tmpbuf), 0))
return 0;
if (strncmp(tmpbuf, "-----END", 8) == 0)
return 1;
}
TEST_error("Can't find key end");
return 0;
}
/*
* Delete leading and trailing spaces from a string
*/
static char *strip_spaces(char *p)
{
char *q;
/* Skip over leading spaces */
while (*p && isspace(*p))
p++;
if (!*p)
return NULL;
for (q = p + strlen(p) - 1; q != p && isspace(*q); )
*q-- = '\0';
return *p ? p : NULL;
}
/*
* Read next test stanza; return 1 if found, 0 on EOF or error.
*/
int test_readstanza(STANZA *s)
{
PAIR *pp = s->pairs;
char *p, *equals, *key, *value;
for (s->numpairs = 0; BIO_gets(s->fp, s->buff, sizeof(s->buff)); ) {
s->curr++;
if (!TEST_ptr(p = strchr(s->buff, '\n'))) {
TEST_info("Line %d too long", s->curr);
return 0;
}
*p = '\0';
/* Blank line marks end of tests. */
if (s->buff[0] == '\0')
break;
/* Lines starting with a pound sign are ignored. */
if (s->buff[0] == '#')
continue;
/* Parse into key=value */
if (!TEST_ptr(equals = strchr(s->buff, '='))) {
TEST_info("Missing = at line %d\n", s->curr);
return 0;
}
*equals++ = '\0';
if (!TEST_ptr(key = strip_spaces(s->buff))) {
TEST_info("Empty field at line %d\n", s->curr);
return 0;
}
if ((value = strip_spaces(equals)) == NULL)
value = "";
if (strcmp(key, "Title") == 0) {
TEST_info("Starting \"%s\" tests at line %d", value, s->curr);
continue;
}
if (s->numpairs == 0)
s->start = s->curr;
if (strcmp(key, "PrivateKey") == 0) {
if (!read_key(s))
return 0;
}
if (strcmp(key, "PublicKey") == 0) {
if (!read_key(s))
return 0;
}
if (!TEST_int_lt(s->numpairs++, TESTMAXPAIRS)
|| !TEST_ptr(pp->key = OPENSSL_strdup(key))
|| !TEST_ptr(pp->value = OPENSSL_strdup(value)))
return 0;
pp++;
}
/* If we read anything, return ok. */
return 1;
}
void test_clearstanza(STANZA *s)
{
PAIR *pp = s->pairs;
int i = s->numpairs;
for ( ; --i >= 0; pp++) {
OPENSSL_free(pp->key);
OPENSSL_free(pp->value);
}
s->numpairs = 0;
}