X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=test%2Fevp_test.c;h=b36f25e939fe74481405755e2eac56257e9cacfe;hp=501a9fdf81de1380fdd09001b7fee796266d4083;hb=5718fe45605681c4d33e43e689491172af0b46c1;hpb=e3d378bcf1324fb6958366f21539e1e0533225f1

diff --git a/test/evp_test.c b/test/evp_test.c
index 501a9fdf81..b36f25e939 100644
--- a/test/evp_test.c
+++ b/test/evp_test.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2018 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
@@ -28,15 +28,9 @@ typedef struct evp_test_method_st EVP_TEST_METHOD;
  * Structure holding test information
  */
 typedef struct evp_test_st {
-    BIO *in;                      /* file being read */
-    int line;                     /* current line being processed */
-    int start_line;               /* start line of current test */
-    int ntests;                   /* Number of tests */
-    int errors;                   /* Error count */
+    STANZA s;                     /* Common test stanza */
+    char *name;
     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 char *err, *aux_err;    /* Error string for 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 const char *current_test_file = "???";
-
 /*
  * Structure used to hold a list of blocks of memory to test
  * calls to "update" like functions.
@@ -292,7 +284,7 @@ static int parse_bin(const char *value, unsigned char **buf, size_t *buflen)
     /* Otherwise assume as hex literal and convert it to binary buffer */
     if (!TEST_ptr(*buf = OPENSSL_hexstr2buf(value, &len))) {
         TEST_info("Can't convert %s", value);
-        ERR_print_errors(bio_err);
+        TEST_openssl_errors();
         return -1;
     }
     /* Size of input buffer means we'll never overflow */
@@ -368,13 +360,18 @@ static int digest_test_run(EVP_TEST *t)
 {
     DIGEST_DATA *expected = t->data;
     EVP_MD_CTX *mctx;
-    unsigned char got[EVP_MAX_MD_SIZE];
+    unsigned char *got = NULL;
     unsigned int got_len;
 
     t->err = "TEST_FAILURE";
     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
         goto err;
 
+    got = OPENSSL_malloc(expected->output_len > EVP_MAX_MD_SIZE ?
+                         expected->output_len : EVP_MAX_MD_SIZE);
+    if (!TEST_ptr(got))
+        goto err;
+
     if (!EVP_DigestInit_ex(mctx, expected->digest, NULL)) {
         t->err = "DIGESTINIT_ERROR";
         goto err;
@@ -384,9 +381,17 @@ static int digest_test_run(EVP_TEST *t)
         goto err;
     }
 
-    if (!EVP_DigestFinal(mctx, got, &got_len)) {
-        t->err = "DIGESTFINAL_ERROR";
-        goto err;
+    if (EVP_MD_flags(expected->digest) & EVP_MD_FLAG_XOF) {
+        got_len = expected->output_len;
+        if (!EVP_DigestFinalXOF(mctx, got, got_len)) {
+            t->err = "DIGESTFINALXOF_ERROR";
+            goto err;
+        }
+    } else {
+        if (!EVP_DigestFinal(mctx, got, &got_len)) {
+            t->err = "DIGESTFINAL_ERROR";
+            goto err;
+        }
     }
     if (!TEST_int_eq(expected->output_len, got_len)) {
         t->err = "DIGEST_LENGTH_MISMATCH";
@@ -399,6 +404,7 @@ static int digest_test_run(EVP_TEST *t)
     t->err = NULL;
 
  err:
+    OPENSSL_free(got);
     EVP_MD_CTX_free(mctx);
     return 1;
 }
@@ -905,31 +911,17 @@ static int mac_test_run(EVP_TEST *t)
     }
 #endif
 
-    if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_id(expected->type, NULL))) {
-        t->err = "MAC_PKEY_CTX_ERROR";
-        goto err;
-    }
-
-    if (EVP_PKEY_keygen_init(genctx) <= 0) {
-        t->err = "MAC_KEYGEN_INIT_ERROR";
-        goto err;
-    }
-    if (expected->type == EVP_PKEY_CMAC
-             && EVP_PKEY_CTX_ctrl_str(genctx, "cipher", expected->alg) <= 0) {
-        t->err = "MAC_ALGORITHM_SET_ERROR";
-        goto err;
-    }
-
-    if (EVP_PKEY_CTX_set_mac_key(genctx, expected->key,
-                                 expected->key_len) <= 0) {
-        t->err = "MAC_KEY_SET_ERROR";
+    if (expected->type == EVP_PKEY_CMAC)
+        key = EVP_PKEY_new_CMAC_key(NULL, expected->key, expected->key_len,
+                                    EVP_get_cipherbyname(expected->alg));
+    else
+        key = EVP_PKEY_new_raw_private_key(expected->type, NULL, expected->key,
+                                           expected->key_len);
+    if (key == NULL) {
+        t->err = "MAC_KEY_CREATE_ERROR";
         goto err;
     }
 
-    if (EVP_PKEY_keygen(genctx, &key) <= 0) {
-        t->err = "MAC_KEY_GENERATE_ERROR";
-        goto err;
-    }
     if (expected->type == EVP_PKEY_HMAC) {
         if (!TEST_ptr(md = EVP_get_digestbyname(expected->alg))) {
             t->err = "MAC_ALGORITHM_SET_ERROR";
@@ -1031,8 +1023,11 @@ static int pkey_test_init(EVP_TEST *t, const char *name,
         return 0;
     }
     kdata->keyop = keyop;
-    if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new(pkey, NULL)))
+    if (!TEST_ptr(kdata->ctx = EVP_PKEY_CTX_new(pkey, NULL))) {
+        EVP_PKEY_free(pkey);
+        OPENSSL_free(kdata);
         return 0;
+    }
     if (keyopinit(kdata->ctx) <= 0)
         t->err = "KEYOP_INIT_ERROR";
     t->data = kdata;
@@ -1219,7 +1214,10 @@ static int pderive_test_run(EVP_TEST *t)
     unsigned char *got = NULL;
     size_t got_len;
 
-    got_len = expected->output_len;
+    if (EVP_PKEY_derive(expected->ctx, NULL, &got_len) <= 0) {
+        t->err = "DERIVE_ERROR";
+        goto err;
+    }
     if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
         t->err = "DERIVE_ERROR";
         goto err;
@@ -1293,7 +1291,7 @@ static int parse_uint64(const char *value, uint64_t *pr)
             return -1;
         }
         *pr *= 10;
-        if (!TEST_true(isdigit(*p))) {
+        if (!TEST_true(isdigit((unsigned char)*p))) {
             TEST_error("Invalid character in string %s", value);
             return -1;
         }
@@ -1628,14 +1626,30 @@ typedef struct kdf_data_st {
 static int kdf_test_init(EVP_TEST *t, const char *name)
 {
     KDF_DATA *kdata;
+    int kdf_nid = OBJ_sn2nid(name);
+
+#ifdef OPENSSL_NO_SCRYPT
+    if (strcmp(name, "scrypt") == 0) {
+        t->skip = 1;
+        return 1;
+    }
+#endif
+
+    if (kdf_nid == NID_undef)
+        kdf_nid = OBJ_ln2nid(name);
 
     if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
         return 0;
-    kdata->ctx = EVP_PKEY_CTX_new_id(OBJ_sn2nid(name), NULL);
-    if (kdata->ctx == NULL)
+    kdata->ctx = EVP_PKEY_CTX_new_id(kdf_nid, NULL);
+    if (kdata->ctx == NULL) {
+        OPENSSL_free(kdata);
         return 0;
-    if (EVP_PKEY_derive_init(kdata->ctx) <= 0)
+    }
+    if (EVP_PKEY_derive_init(kdata->ctx) <= 0) {
+        EVP_PKEY_CTX_free(kdata->ctx);
+        OPENSSL_free(kdata);
         return 0;
+    }
     t->data = kdata;
     return 1;
 }
@@ -1809,6 +1823,117 @@ static const EVP_TEST_METHOD keypair_test_method = {
     keypair_test_run
 };
 
+/**
+***  KEYGEN TEST
+**/
+
+typedef struct keygen_test_data_st {
+    EVP_PKEY_CTX *genctx; /* Keygen context to use */
+    char *keyname; /* Key name to store key or NULL */
+} KEYGEN_TEST_DATA;
+
+static int keygen_test_init(EVP_TEST *t, const char *alg)
+{
+    KEYGEN_TEST_DATA *data;
+    EVP_PKEY_CTX *genctx;
+    int nid = OBJ_sn2nid(alg);
+
+    if (nid == NID_undef) {
+        nid = OBJ_ln2nid(alg);
+        if (nid == NID_undef)
+            return 0;
+    }
+
+    if (!TEST_ptr(genctx = EVP_PKEY_CTX_new_id(nid, NULL))) {
+        /* assume algorithm disabled */
+        t->skip = 1;
+        return 1;
+    }
+
+    if (EVP_PKEY_keygen_init(genctx) <= 0) {
+        t->err = "KEYGEN_INIT_ERROR";
+        goto err;
+    }
+
+    if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
+        goto err;
+    data->genctx = genctx;
+    data->keyname = NULL;
+    t->data = data;
+    t->err = NULL;
+    return 1;
+
+err:
+    EVP_PKEY_CTX_free(genctx);
+    return 0;
+}
+
+static void keygen_test_cleanup(EVP_TEST *t)
+{
+    KEYGEN_TEST_DATA *keygen = t->data;
+
+    EVP_PKEY_CTX_free(keygen->genctx);
+    OPENSSL_free(keygen->keyname);
+    OPENSSL_free(t->data);
+    t->data = NULL;
+}
+
+static int keygen_test_parse(EVP_TEST *t,
+                             const char *keyword, const char *value)
+{
+    KEYGEN_TEST_DATA *keygen = t->data;
+
+    if (strcmp(keyword, "KeyName") == 0)
+        return TEST_ptr(keygen->keyname = OPENSSL_strdup(value));
+    if (strcmp(keyword, "Ctrl") == 0)
+        return pkey_test_ctrl(t, keygen->genctx, value);
+    return 0;
+}
+
+static int keygen_test_run(EVP_TEST *t)
+{
+    KEYGEN_TEST_DATA *keygen = t->data;
+    EVP_PKEY *pkey = NULL;
+
+    t->err = NULL;
+    if (EVP_PKEY_keygen(keygen->genctx, &pkey) <= 0) {
+        t->err = "KEYGEN_GENERATE_ERROR";
+        goto err;
+    }
+
+    if (keygen->keyname != NULL) {
+        KEY_LIST *key;
+
+        if (find_key(NULL, keygen->keyname, private_keys)) {
+            TEST_info("Duplicate key %s", keygen->keyname);
+            goto err;
+        }
+
+        if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
+            goto err;
+        key->name = keygen->keyname;
+        keygen->keyname = NULL;
+        key->key = pkey;
+        key->next = private_keys;
+        private_keys = key;
+    } else {
+        EVP_PKEY_free(pkey);
+    }
+
+    return 1;
+
+err:
+    EVP_PKEY_free(pkey);
+    return 0;
+}
+
+static const EVP_TEST_METHOD keygen_test_method = {
+    "KeyGen",
+    keygen_test_init,
+    keygen_test_cleanup,
+    keygen_test_parse,
+    keygen_test_run,
+};
 
 /**
 ***  DIGEST SIGN+VERIFY TESTS
@@ -2085,6 +2210,7 @@ static const EVP_TEST_METHOD *evp_test_list[] = {
     &encode_test_method,
     &kdf_test_method,
     &keypair_test_method,
+    &keygen_test_method,
     &mac_test_method,
     &oneshot_digestsign_test_method,
     &oneshot_digestverify_test_method,
@@ -2110,6 +2236,7 @@ static const EVP_TEST_METHOD *find_test(const char *name)
 
 static void clear_test(EVP_TEST *t)
 {
+    test_clearstanza(&t->s);
     ERR_clear_error();
     if (t->data != NULL) {
         if (t->meth != NULL)
@@ -2123,6 +2250,7 @@ static void clear_test(EVP_TEST *t)
     t->func = NULL;
     OPENSSL_free(t->reason);
     t->reason = NULL;
+
     /* Text literal. */
     t->err = NULL;
     t->skip = 0;
@@ -2142,25 +2270,23 @@ static int check_test_error(EVP_TEST *t)
         return 1;
     if (t->err != NULL && t->expected_err == NULL) {
         if (t->aux_err != NULL) {
-            TEST_info("Above error from the test at %s:%d "
-                      "(%s) unexpected error %s",
-                      current_test_file, t->start_line, t->aux_err, t->err);
+            TEST_info("%s:%d: Source of above error (%s); unexpected error %s",
+                      t->s.test_file, t->s.start, t->aux_err, t->err);
         } else {
-            TEST_info("Above error from the test at %s:%d "
-                      "unexpected error %s",
-                      current_test_file, t->start_line, t->err);
+            TEST_info("%s:%d: Source of above error; unexpected error %s",
+                      t->s.test_file, t->s.start, t->err);
         }
         return 0;
     }
     if (t->err == NULL && t->expected_err != NULL) {
-        TEST_info("Test line %d: succeeded but was expecting %s",
-                  t->start_line, t->expected_err);
+        TEST_info("%s:%d: Succeeded but was expecting %s",
+                  t->s.test_file, t->s.start, t->expected_err);
         return 0;
     }
 
     if (strcmp(t->err, t->expected_err) != 0) {
-        TEST_info("Test line %d: expecting %s got %s",
-                  t->start_line, t->expected_err, t->err);
+        TEST_info("%s:%d: Expected %s got %s",
+                  t->s.test_file, t->s.start, t->expected_err, t->err);
         return 0;
     }
 
@@ -2168,32 +2294,32 @@ static int check_test_error(EVP_TEST *t)
         return 1;
 
     if (t->func == NULL || t->reason == NULL) {
-        TEST_info("Test line %d: missing function or reason code",
-                  t->start_line);
+        TEST_info("%s:%d: Test is missing function or reason code",
+                  t->s.test_file, t->s.start);
         return 0;
     }
 
     err = ERR_peek_error();
     if (err == 0) {
-        TEST_info("Test line %d, expected error \"%s:%s\" not set",
-                  t->start_line, t->func, t->reason);
+        TEST_info("%s:%d: Expected error \"%s:%s\" not set",
+                  t->s.test_file, t->s.start, t->func, t->reason);
         return 0;
     }
 
     func = ERR_func_error_string(err);
     reason = ERR_reason_error_string(err);
     if (func == NULL && reason == NULL) {
-        TEST_info("Test line %d: expected error \"%s:%s\","
-                  " no strings available.  Skipping...\n",
-                  t->start_line, t->func, t->reason);
+        TEST_info("%s:%d: Expected error \"%s:%s\", no strings available."
+                  " Assuming ok.",
+                  t->s.test_file, t->s.start, t->func, t->reason);
         return 1;
     }
 
     if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
         return 1;
 
-    TEST_info("Test line %d: expected error \"%s:%s\", got \"%s:%s\"",
-              t->start_line, t->func, t->reason, func, reason);
+    TEST_info("%s:%d: Expected error \"%s:%s\", got \"%s:%s\"",
+              t->s.test_file, t->s.start, t->func, t->reason, func, reason);
 
     return 0;
 }
@@ -2205,18 +2331,19 @@ static int run_test(EVP_TEST *t)
 {
     if (t->meth == NULL)
         return 1;
-    t->ntests++;
+    t->s.numtests++;
     if (t->skip) {
-        t->nskip++;
+        t->s.numskip++;
     } else {
         /* run the test */
         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;
         }
         if (!check_test_error(t)) {
-            test_openssl_errors();
-            t->errors++;
+            TEST_openssl_errors();
+            t->s.errors++;
         }
     }
 
@@ -2248,90 +2375,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?
  */
@@ -2360,202 +2403,235 @@ 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 *keyword, *value;
-    KEY_LIST **klist, *key;
+    char *p = pp->value;
+
+    pp->value = NULL;
+    return p;
+}
+
+static int key_disabled(EVP_PKEY *pkey)
+{
+#if defined(OPENSSL_NO_SM2) && !defined(OPENSSL_NO_EC)
+    int type = EVP_PKEY_base_id(pkey);
+
+    if (type == EVP_PKEY_EC) {
+        EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
+        int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
+
+        if (nid == NID_sm2)
+            return 1;
+    }
+#endif /* OPENSSL_NO_SM2 */
+
+    return 0;
+}
+
+/*
+ * 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;
+    PAIR *pp;
+    int i;
 
-    clear_test(t);
 top:
-    /* Find the first line of a stanza. */
-    for ( ; ; ) {
-        c = read_line(t);
-        if (c == EOF)
+    do {
+        if (BIO_eof(t->s.fp))
             return EOF;
-        if (c == '\0')
-            continue;
-        break;
-    }
-    if (!split_line(t, &keyword, &value))
-        return 0;
-
-    /* Handle a few special cases here. */
-    if (strcmp(keyword, "Title") == 0) {
-        TEST_info("Starting \"%s\" tests", value);
-        goto top;
-    }
+        clear_test(t);
+        if (!test_readstanza(&t->s))
+            return 0;
+    } while (t->s.numpairs == 0);
+    pp = &t->s.pairs[0];
 
+    /* Are we adding a key? */
     klist = NULL;
     pkey = NULL;
-    if (strcmp(keyword, "PrivateKey") == 0) {
-        if (!read_key(t))
-            return 0;
-        pkey = PEM_read_bio_PrivateKey(t->key, NULL, 0, NULL);
+    if (strcmp(pp->key, "PrivateKey") == 0) {
+        pkey = PEM_read_bio_PrivateKey(t->s.key, NULL, 0, NULL);
         if (pkey == NULL && !key_unsupported()) {
-            TEST_info("Can't read private key %s", value);
-            ERR_print_errors_fp(stderr);
+            EVP_PKEY_free(pkey);
+            TEST_info("Can't read private key %s", pp->value);
+            TEST_openssl_errors();
             return 0;
         }
         klist = &private_keys;
-    }
-    else if (strcmp(keyword, "PublicKey") == 0) {
-        if (!read_key(t))
-            return 0;
-        pkey = PEM_read_bio_PUBKEY(t->key, NULL, 0, NULL);
+    } else if (strcmp(pp->key, "PublicKey") == 0) {
+        pkey = PEM_read_bio_PUBKEY(t->s.key, NULL, 0, NULL);
         if (pkey == NULL && !key_unsupported()) {
-            TEST_info("Can't read public key %s", value);
-            ERR_print_errors_fp(stderr);
+            EVP_PKEY_free(pkey);
+            TEST_info("Can't read public key %s", pp->value);
+            TEST_openssl_errors();
             return 0;
         }
         klist = &public_keys;
+    } else if (strcmp(pp->key, "PrivateKeyRaw") == 0
+               || strcmp(pp->key, "PublicKeyRaw") == 0 ) {
+        char *strnid = NULL, *keydata = NULL;
+        unsigned char *keybin;
+        size_t keylen;
+        int nid;
+
+        if (strcmp(pp->key, "PrivateKeyRaw") == 0)
+            klist = &private_keys;
+        else
+            klist = &public_keys;
+
+        strnid = strchr(pp->value, ':');
+        if (strnid != NULL) {
+            *strnid++ = '\0';
+            keydata = strchr(strnid, ':');
+            if (keydata != NULL)
+                *keydata++ = '\0';
+        }
+        if (keydata == NULL) {
+            TEST_info("Failed to parse %s value", pp->key);
+            return 0;
+        }
+
+        nid = OBJ_txt2nid(strnid);
+        if (nid == NID_undef) {
+            TEST_info("Uncrecognised algorithm NID");
+            return 0;
+        }
+        if (!parse_bin(keydata, &keybin, &keylen)) {
+            TEST_info("Failed to create binary key");
+            return 0;
+        }
+        if (klist == &private_keys)
+            pkey = EVP_PKEY_new_raw_private_key(nid, NULL, keybin, keylen);
+        else
+            pkey = EVP_PKEY_new_raw_public_key(nid, NULL, keybin, keylen);
+        if (pkey == NULL && !key_unsupported()) {
+            TEST_info("Can't read %s data", pp->key);
+            OPENSSL_free(keybin);
+            TEST_openssl_errors();
+            return 0;
+        }
+        OPENSSL_free(keybin);
+    }
+    if (pkey != NULL && key_disabled(pkey)) {
+        EVP_PKEY_free(pkey);
+        pkey = NULL;
     }
 
     /* If we have a key add to list */
     if (klist != NULL) {
-        if (find_key(NULL, value, *klist)) {
-            TEST_info("Duplicate key %s", value);
+        if (find_key(NULL, pp->value, *klist)) {
+            TEST_info("Duplicate key %s", pp->value);
             return 0;
         }
-        if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key)))
-                || !TEST_ptr(key->name = OPENSSL_strdup(value)))
+        if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
             return 0;
+        key->name = take_value(pp);
         key->key = pkey;
         key->next = *klist;
         *klist = key;
 
         /* 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;
     }
 
-    /* Start of a new text.  Look it up. */
-    if (!TEST_ptr(t->meth = find_test(keyword)))
-        goto skiptoend;
-    t->start_line = t->line;
-    if (!t->meth->init(t, value)) {
-        TEST_error("unknown %s: %s\n", keyword, value);
-        goto skiptoend;
+    /* Find the test, based on first keyword. */
+    if (!TEST_ptr(t->meth = find_test(pp->key)))
+        return 0;
+    if (!t->meth->init(t, pp->value)) {
+        TEST_error("unknown %s: %s\n", pp->key, pp->value);
+        return 0;
     }
     if (t->skip == 1) {
-        /* TEST_info("skipping %s %s", keyword, value); */
-        goto skiptoend;
+        /* TEST_info("skipping %s %s", pp->key, pp->value); */
+        return 0;
     }
 
-    /* Read rest of stanza. */
-    for ( ; ; ) {
-        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) {
+    for (pp++, i = 1; i < t->s.numpairs; pp++, i++) {
+        if (strcmp(pp->key, "Result") == 0) {
             if (t->expected_err != NULL) {
-                TEST_info("Line %d: multiple result lines", t->line);
-                goto skiptoend;
+                TEST_info("Line %d: multiple result lines", t->s.curr);
+                return 0;
             }
-            if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value)))
-                goto skiptoend;
-        } else if (strcmp(keyword, "Function") == 0) {
+            t->expected_err = take_value(pp);
+        } else if (strcmp(pp->key, "Function") == 0) {
             if (t->func != NULL) {
-                TEST_info("Line %d: multiple function lines\n", t->line);
-                goto skiptoend;
+                TEST_info("Line %d: multiple function lines\n", t->s.curr);
+                return 0;
             }
-            if (!TEST_ptr(t->func = OPENSSL_strdup(value)))
-                goto skiptoend;
-        } else if (strcmp(keyword, "Reason") == 0) {
+            t->func = take_value(pp);
+        } else if (strcmp(pp->key, "Reason") == 0) {
             if (t->reason != NULL) {
-                TEST_info("Line %d: multiple reason lines", t->line);
-                goto skiptoend;
+                TEST_info("Line %d: multiple reason lines", t->s.curr);
+                return 0;
             }
-            if (!TEST_ptr(t->reason = OPENSSL_strdup(value)))
-                goto skiptoend;
+            t->reason = take_value(pp);
         } else {
             /* 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) {
-                TEST_info("Line %d: unknown keyword %s", t->line, keyword);
-                goto skiptoend;
+                TEST_info("Line %d: unknown keyword %s", t->s.curr, pp->key);
+                return 0;
             }
             if (rv < 0) {
                 TEST_info("Line %d: error processing keyword %s\n",
-                        t->line, keyword);
-                goto skiptoend;
+                        t->s.curr, pp->key);
+                return 0;
             }
         }
     }
 
     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)
+static int run_file_tests(int i)
 {
-    BIO *in;
-    EVP_TEST t;
+    EVP_TEST *t;
+    const char *testfile = test_get_argument(i);
     int c;
 
-    set_test_title(testfile);
-    current_test_file = testfile;
-    if (!TEST_ptr(in = BIO_new_file(testfile, "rb")))
+    if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
+        return 0;
+    if (!test_start_file(&t->s, testfile)) {
+        OPENSSL_free(t);
         return 0;
-    memset(&t, 0, sizeof(t));
-    t.in = in;
+    }
 
-    TEST_info("Reading %s", testfile);
-    for ( ; ; ) {
-        c = read_stanza(&t);
-        if (t.skip)
+    while (!BIO_eof(t->s.fp)) {
+        c = parse(t);
+        if (t->skip)
             continue;
-        if (c == 0 || !run_test(&t)) {
-            t.errors++;
+        if (c == 0 || !run_test(t)) {
+            t->s.errors++;
             break;
         }
-        if (c == EOF)
-            break;
     }
-    clear_test(&t);
+    test_end_file(&t->s);
+    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;
+    BIO_free(t->s.key);
+    c = t->s.errors;
+    OPENSSL_free(t);
+    return c == 0;
 }
 
-static char * const *testfiles;
-
-static int run_file_tests(int i)
+int setup_tests(void)
 {
-    return do_test_file(testfiles[i]);
-}
+    size_t n = test_get_argument_count();
 
-int test_main(int argc, char *argv[])
-{
-    if (argc < 2) {
-        TEST_error("Usage: %s file...", argv[0]);
+    if (n == 0) {
+        TEST_error("Usage: %s file...", test_get_program_name());
         return 0;
     }
-    testfiles = &argv[1];
-
-    ADD_ALL_TESTS(run_file_tests, argc - 1);
 
-    return run_tests(argv[0]);
+    ADD_ALL_TESTS(run_file_tests, n);
+    return 1;
 }