+
+/**
+*** KDF TESTS
+**/
+
+typedef struct kdf_data_st {
+ /* Context for this operation */
+ EVP_PKEY_CTX *ctx;
+ /* Expected output */
+ unsigned char *output;
+ size_t output_len;
+} KDF_DATA;
+
+/*
+ * Perform public key operation setup: lookup key, allocated ctx and call
+ * the appropriate initialisation function
+ */
+static int kdf_test_init(EVP_TEST *t, const char *name)
+{
+ KDF_DATA *kdata;
+
+ 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)
+ return 0;
+ if (EVP_PKEY_derive_init(kdata->ctx) <= 0)
+ return 0;
+ t->data = kdata;
+ return 1;
+}
+
+static void kdf_test_cleanup(EVP_TEST *t)
+{
+ KDF_DATA *kdata = t->data;
+ OPENSSL_free(kdata->output);
+ EVP_PKEY_CTX_free(kdata->ctx);
+}
+
+static int kdf_test_parse(EVP_TEST *t,
+ const char *keyword, const char *value)
+{
+ KDF_DATA *kdata = t->data;
+
+ if (strcmp(keyword, "Output") == 0)
+ return parse_bin(value, &kdata->output, &kdata->output_len);
+ if (strncmp(keyword, "Ctrl", 4) == 0)
+ return pkey_test_ctrl(t, kdata->ctx, value);
+ return 0;
+}
+
+static int kdf_test_run(EVP_TEST *t)
+{
+ KDF_DATA *kdata = t->data;
+ unsigned char *out = NULL;
+ size_t out_len = kdata->output_len;
+
+ if (!TEST_ptr(out = OPENSSL_malloc(out_len))) {
+ t->err = "INTERNAL_ERROR";
+ goto err;
+ }
+ if (EVP_PKEY_derive(kdata->ctx, out, &out_len) <= 0) {
+ t->err = "KDF_DERIVE_ERROR";
+ goto err;
+ }
+ if (!compare_mem(kdata->output, kdata->output_len, out, out_len)) {
+ t->err = "KDF_MISMATCH";
+ goto err;
+ }
+ t->err = NULL;
+
+ err:
+ OPENSSL_free(out);
+ return 1;
+}
+
+static const EVP_TEST_METHOD kdf_test_method = {
+ "KDF",
+ kdf_test_init,
+ kdf_test_cleanup,
+ kdf_test_parse,
+ kdf_test_run
+};
+
+
+/**
+*** KEYPAIR TESTS
+**/
+
+typedef struct keypair_test_data_st {
+ EVP_PKEY *privk;
+ EVP_PKEY *pubk;
+} KEYPAIR_TEST_DATA;
+
+static int keypair_test_init(EVP_TEST *t, const char *pair)
+{
+ KEYPAIR_TEST_DATA *data;
+ int rv = 0;
+ EVP_PKEY *pk = NULL, *pubk = NULL;
+ char *pub, *priv = NULL;
+
+ /* Split private and public names. */
+ if (!TEST_ptr(priv = OPENSSL_strdup(pair))
+ || !TEST_ptr(pub = strchr(priv, ':'))) {
+ t->err = "PARSING_ERROR";
+ goto end;
+ }
+ *pub++ = '\0';
+
+ if (!TEST_true(find_key(&pk, priv, private_keys))) {
+ TEST_info("Can't find private key: %s", priv);
+ t->err = "MISSING_PRIVATE_KEY";
+ goto end;
+ }
+ if (!TEST_true(find_key(&pubk, pub, public_keys))) {
+ TEST_info("Can't find public key: %s", pub);
+ t->err = "MISSING_PUBLIC_KEY";
+ goto end;
+ }
+
+ if (pk == NULL && pubk == NULL) {
+ /* Both keys are listed but unsupported: skip this test */
+ t->skip = 1;
+ rv = 1;
+ goto end;
+ }
+
+ if (!TEST_ptr(data = OPENSSL_malloc(sizeof(*data))))
+ goto end;
+ data->privk = pk;
+ data->pubk = pubk;
+ t->data = data;
+ rv = 1;
+ t->err = NULL;
+
+end:
+ OPENSSL_free(priv);
+ return rv;
+}
+
+static void keypair_test_cleanup(EVP_TEST *t)
+{
+ OPENSSL_free(t->data);
+ t->data = NULL;
+}
+
+/*
+ * For tests that do not accept any custom keywords.
+ */
+static int void_test_parse(EVP_TEST *t, const char *keyword, const char *value)
+{
+ return 0;
+}
+
+static int keypair_test_run(EVP_TEST *t)
+{
+ int rv = 0;
+ const KEYPAIR_TEST_DATA *pair = t->data;
+
+ if (pair->privk == NULL || pair->pubk == NULL) {
+ /*
+ * this can only happen if only one of the keys is not set
+ * which means that one of them was unsupported while the
+ * other isn't: hence a key type mismatch.
+ */
+ t->err = "KEYPAIR_TYPE_MISMATCH";
+ rv = 1;
+ goto end;
+ }
+
+ if ((rv = EVP_PKEY_cmp(pair->privk, pair->pubk)) != 1 ) {
+ if ( 0 == rv ) {
+ t->err = "KEYPAIR_MISMATCH";
+ } else if ( -1 == rv ) {
+ t->err = "KEYPAIR_TYPE_MISMATCH";
+ } else if ( -2 == rv ) {
+ t->err = "UNSUPPORTED_KEY_COMPARISON";
+ } else {
+ TEST_error("Unexpected error in key comparison");
+ rv = 0;
+ goto end;
+ }
+ rv = 1;
+ goto end;
+ }
+
+ rv = 1;
+ t->err = NULL;
+
+end:
+ return rv;
+}
+
+static const EVP_TEST_METHOD keypair_test_method = {
+ "PrivPubKeyPair",
+ keypair_test_init,
+ keypair_test_cleanup,
+ void_test_parse,
+ keypair_test_run
+};
+
+
+/**
+*** DIGEST SIGN+VERIFY TESTS
+**/
+
+typedef struct {
+ int is_verify; /* Set to 1 if verifying */
+ int is_oneshot; /* Set to 1 for one shot operation */
+ const EVP_MD *md; /* Digest to use */
+ EVP_MD_CTX *ctx; /* Digest context */
+ EVP_PKEY_CTX *pctx;
+ STACK_OF(EVP_TEST_BUFFER) *input; /* Input data: streaming */
+ unsigned char *osin; /* Input data if one shot */
+ size_t osin_len; /* Input length data if one shot */
+ unsigned char *output; /* Expected output */
+ size_t output_len; /* Expected output length */
+} DIGESTSIGN_DATA;
+
+static int digestsigver_test_init(EVP_TEST *t, const char *alg, int is_verify,
+ int is_oneshot)
+{
+ const EVP_MD *md = NULL;
+ DIGESTSIGN_DATA *mdat;
+
+ if (strcmp(alg, "NULL") != 0) {
+ if ((md = EVP_get_digestbyname(alg)) == NULL) {
+ /* If alg has an OID assume disabled algorithm */
+ if (OBJ_sn2nid(alg) != NID_undef || OBJ_ln2nid(alg) != NID_undef) {
+ t->skip = 1;
+ return 1;
+ }
+ return 0;
+ }
+ }
+ if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
+ return 0;
+ mdat->md = md;
+ if (!TEST_ptr(mdat->ctx = EVP_MD_CTX_new())) {
+ OPENSSL_free(mdat);
+ return 0;
+ }
+ mdat->is_verify = is_verify;
+ mdat->is_oneshot = is_oneshot;
+ t->data = mdat;
+ return 1;
+}
+
+static int digestsign_test_init(EVP_TEST *t, const char *alg)
+{
+ return digestsigver_test_init(t, alg, 0, 0);
+}
+
+static void digestsigver_test_cleanup(EVP_TEST *t)
+{
+ DIGESTSIGN_DATA *mdata = t->data;
+
+ EVP_MD_CTX_free(mdata->ctx);
+ sk_EVP_TEST_BUFFER_pop_free(mdata->input, evp_test_buffer_free);
+ OPENSSL_free(mdata->osin);
+ OPENSSL_free(mdata->output);
+ OPENSSL_free(mdata);
+ t->data = NULL;
+}
+
+static int digestsigver_test_parse(EVP_TEST *t,
+ const char *keyword, const char *value)
+{
+ DIGESTSIGN_DATA *mdata = t->data;
+
+ if (strcmp(keyword, "Key") == 0) {
+ EVP_PKEY *pkey = NULL;
+ int rv = 0;
+
+ if (mdata->is_verify)
+ rv = find_key(&pkey, value, public_keys);
+ if (rv == 0)
+ rv = find_key(&pkey, value, private_keys);
+ if (rv == 0 || pkey == NULL) {
+ t->skip = 1;
+ return 1;
+ }
+ if (mdata->is_verify) {
+ if (!EVP_DigestVerifyInit(mdata->ctx, &mdata->pctx, mdata->md,
+ NULL, pkey))
+ t->err = "DIGESTVERIFYINIT_ERROR";
+ return 1;
+ }
+ if (!EVP_DigestSignInit(mdata->ctx, &mdata->pctx, mdata->md, NULL,
+ pkey))
+ t->err = "DIGESTSIGNINIT_ERROR";
+ return 1;
+ }
+
+ if (strcmp(keyword, "Input") == 0) {
+ if (mdata->is_oneshot)
+ return parse_bin(value, &mdata->osin, &mdata->osin_len);
+ return evp_test_buffer_append(value, &mdata->input);
+ }
+ if (strcmp(keyword, "Output") == 0)
+ return parse_bin(value, &mdata->output, &mdata->output_len);
+
+ if (!mdata->is_oneshot) {
+ if (strcmp(keyword, "Count") == 0)
+ return evp_test_buffer_set_count(value, mdata->input);
+ if (strcmp(keyword, "Ncopy") == 0)
+ return evp_test_buffer_ncopy(value, mdata->input);
+ }
+ if (strcmp(keyword, "Ctrl") == 0) {
+ if (mdata->pctx == NULL)
+ return 0;
+ return pkey_test_ctrl(t, mdata->pctx, value);
+ }
+ return 0;
+}
+
+static int digestsign_update_fn(void *ctx, const unsigned char *buf,
+ size_t buflen)
+{
+ return EVP_DigestSignUpdate(ctx, buf, buflen);
+}
+
+static int digestsign_test_run(EVP_TEST *t)
+{
+ DIGESTSIGN_DATA *mdata = t->data;
+ unsigned char *buf = NULL;
+ size_t buflen;
+
+ if (!evp_test_buffer_do(mdata->input, digestsign_update_fn, mdata->ctx)) {
+ t->err = "DIGESTUPDATE_ERROR";
+ goto err;
+ }
+
+ if (!EVP_DigestSignFinal(mdata->ctx, NULL, &buflen)) {
+ t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
+ goto err;
+ }
+ if (!TEST_ptr(buf = OPENSSL_malloc(buflen))) {
+ t->err = "MALLOC_FAILURE";
+ goto err;
+ }
+ if (!EVP_DigestSignFinal(mdata->ctx, buf, &buflen)) {
+ t->err = "DIGESTSIGNFINAL_ERROR";
+ goto err;
+ }
+ if (!compare_mem(mdata->output, mdata->output_len, buf, buflen)) {
+ t->err = "SIGNATURE_MISMATCH";
+ goto err;
+ }
+
+ err:
+ OPENSSL_free(buf);
+ return 1;
+}
+
+static const EVP_TEST_METHOD digestsign_test_method = {
+ "DigestSign",
+ digestsign_test_init,
+ digestsigver_test_cleanup,
+ digestsigver_test_parse,
+ digestsign_test_run
+};
+
+static int digestverify_test_init(EVP_TEST *t, const char *alg)
+{
+ return digestsigver_test_init(t, alg, 1, 0);
+}
+
+static int digestverify_update_fn(void *ctx, const unsigned char *buf,
+ size_t buflen)
+{
+ return EVP_DigestVerifyUpdate(ctx, buf, buflen);
+}
+
+static int digestverify_test_run(EVP_TEST *t)
+{
+ DIGESTSIGN_DATA *mdata = t->data;
+
+ if (!evp_test_buffer_do(mdata->input, digestverify_update_fn, mdata->ctx)) {
+ t->err = "DIGESTUPDATE_ERROR";
+ return 1;
+ }
+
+ if (EVP_DigestVerifyFinal(mdata->ctx, mdata->output,
+ mdata->output_len) <= 0)
+ t->err = "VERIFY_ERROR";
+ return 1;
+}
+
+static const EVP_TEST_METHOD digestverify_test_method = {
+ "DigestVerify",
+ digestverify_test_init,
+ digestsigver_test_cleanup,
+ digestsigver_test_parse,
+ digestverify_test_run
+};
+
+static int oneshot_digestsign_test_init(EVP_TEST *t, const char *alg)
+{
+ return digestsigver_test_init(t, alg, 0, 1);
+}
+
+static int oneshot_digestsign_test_run(EVP_TEST *t)
+{
+ DIGESTSIGN_DATA *mdata = t->data;
+ unsigned char *buf = NULL;
+ size_t buflen;
+
+ if (!EVP_DigestSign(mdata->ctx, NULL, &buflen, mdata->osin,
+ mdata->osin_len)) {
+ t->err = "DIGESTSIGN_LENGTH_ERROR";
+ goto err;
+ }
+ if (!TEST_ptr(buf = OPENSSL_malloc(buflen))) {
+ t->err = "MALLOC_FAILURE";
+ goto err;
+ }
+ if (!EVP_DigestSign(mdata->ctx, buf, &buflen, mdata->osin,
+ mdata->osin_len)) {
+ t->err = "DIGESTSIGN_ERROR";
+ goto err;
+ }
+ if (!compare_mem(mdata->output, mdata->output_len, buf, buflen)) {
+ t->err = "SIGNATURE_MISMATCH";
+ goto err;
+ }
+
+ err:
+ OPENSSL_free(buf);
+ return 1;
+}
+
+static const EVP_TEST_METHOD oneshot_digestsign_test_method = {
+ "OneShotDigestSign",
+ oneshot_digestsign_test_init,
+ digestsigver_test_cleanup,
+ digestsigver_test_parse,
+ oneshot_digestsign_test_run
+};
+
+static int oneshot_digestverify_test_init(EVP_TEST *t, const char *alg)
+{
+ return digestsigver_test_init(t, alg, 1, 1);
+}
+
+static int oneshot_digestverify_test_run(EVP_TEST *t)
+{
+ DIGESTSIGN_DATA *mdata = t->data;
+
+ if (EVP_DigestVerify(mdata->ctx, mdata->output, mdata->output_len,
+ mdata->osin, mdata->osin_len) <= 0)
+ t->err = "VERIFY_ERROR";
+ return 1;
+}
+
+static const EVP_TEST_METHOD oneshot_digestverify_test_method = {
+ "OneShotDigestVerify",
+ oneshot_digestverify_test_init,
+ digestsigver_test_cleanup,
+ digestsigver_test_parse,
+ oneshot_digestverify_test_run
+};
+
+
+/**
+*** PARSING AND DISPATCH
+**/
+
+static const EVP_TEST_METHOD *evp_test_list[] = {
+ &cipher_test_method,
+ &digest_test_method,
+ &digestsign_test_method,
+ &digestverify_test_method,
+ &encode_test_method,
+ &kdf_test_method,
+ &keypair_test_method,
+ &mac_test_method,
+ &oneshot_digestsign_test_method,
+ &oneshot_digestverify_test_method,
+ &pbe_test_method,
+ &pdecrypt_test_method,
+ &pderive_test_method,
+ &psign_test_method,
+ &pverify_recover_test_method,
+ &pverify_test_method,
+ NULL
+};
+
+static const EVP_TEST_METHOD *find_test(const char *name)
+{
+ const EVP_TEST_METHOD **tt;
+
+ for (tt = evp_test_list; *tt; tt++) {
+ if (strcmp(name, (*tt)->name) == 0)
+ return *tt;
+ }
+ return NULL;
+}
+
+static void clear_test(EVP_TEST *t)
+{
+ ERR_clear_error();
+ if (t->data != NULL) {
+ if (t->meth != NULL)
+ t->meth->cleanup(t);
+ OPENSSL_free(t->data);
+ t->data = NULL;
+ }
+ OPENSSL_free(t->expected_err);
+ t->expected_err = NULL;
+ OPENSSL_free(t->func);
+ t->func = NULL;
+ OPENSSL_free(t->reason);
+ t->reason = NULL;
+ /* Text literal. */
+ t->err = NULL;
+ t->skip = 0;
+ t->meth = NULL;
+}
+
+/*
+ * Check for errors in the test structure; return 1 if okay, else 0.
+ */
+static int check_test_error(EVP_TEST *t)
+{
+ unsigned long err;
+ const char *func;
+ const char *reason;
+
+ if (t->err == NULL && t->expected_err == NULL)
+ 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);
+ } else {
+ TEST_info("Above error from the test at %s:%d "
+ "unexpected error %s",
+ current_test_file, t->start_line, 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);
+ 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);
+ return 0;
+ }
+
+ if (t->func == NULL && t->reason == NULL)
+ return 1;
+
+ if (t->func == NULL || t->reason == NULL) {
+ TEST_info("Test line %d: missing function or reason code",
+ t->start_line);
+ 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);
+ 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);
+ 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);
+
+ return 0;
+}
+
+/*
+ * Run a parsed test. Log a message and return 0 on error.
+ */
+static int run_test(EVP_TEST *t)
+{
+ if (t->meth == NULL)
+ return 1;
+ t->ntests++;
+ if (t->skip) {
+ t->nskip++;
+ } 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);
+ return 0;
+ }
+ if (!check_test_error(t)) {
+ test_openssl_errors();
+ t->errors++;
+ }
+ }
+
+ /* clean it up */
+ return 1;
+}
+
+static int find_key(EVP_PKEY **ppk, const char *name, KEY_LIST *lst)
+{
+ for (; lst != NULL; lst = lst->next) {
+ if (strcmp(lst->name, name) == 0) {
+ if (ppk != NULL)
+ *ppk = lst->key;
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static void free_key_list(KEY_LIST *lst)
+{
+ while (lst != NULL) {
+ KEY_LIST *next = lst->next;
+
+ EVP_PKEY_free(lst->key);
+ OPENSSL_free(lst->name);
+ OPENSSL_free(lst);
+ lst = next;
+ }
+}
+
+
+/*
+ * 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?
+ */
+static int key_unsupported()
+{
+ long err = ERR_peek_error();
+
+ if (ERR_GET_LIB(err) == ERR_LIB_EVP
+ && ERR_GET_REASON(err) == EVP_R_UNSUPPORTED_ALGORITHM) {
+ ERR_clear_error();
+ return 1;
+ }
+#ifndef OPENSSL_NO_EC
+ /*
+ * If EC support is enabled we should catch also EC_R_UNKNOWN_GROUP as an
+ * hint to an unsupported algorithm/curve (e.g. if binary EC support is
+ * disabled).
+ */
+ if (ERR_GET_LIB(err) == ERR_LIB_EC
+ && ERR_GET_REASON(err) == EC_R_UNKNOWN_GROUP) {
+ ERR_clear_error();
+ return 1;
+ }
+#endif /* OPENSSL_NO_EC */
+ return 0;
+}
+
+/*
+ * Read, parse, and execute one test. Return EOF; 0 if failure, 1 if okay.
+ */
+static int read_stanza(EVP_TEST *t)
+{
+ int c;
+ char *keyword, *value;
+ KEY_LIST **klist, *key;
+ EVP_PKEY *pkey;
+
+ clear_test(t);
+top:
+ /* Find the first line of a stanza. */
+ for ( ; ; ) {
+ c = read_line(t);
+ if (c == EOF)
+ 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;
+ }
+
+ 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 (pkey == NULL && !key_unsupported()) {
+ TEST_info("Can't read private key %s", value);
+ ERR_print_errors_fp(stderr);
+ 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);
+ if (pkey == NULL && !key_unsupported()) {
+ TEST_info("Can't read public key %s", value);
+ ERR_print_errors_fp(stderr);
+ return 0;
+ }
+ klist = &public_keys;
+ }
+
+ /* If we have a key add to list */
+ if (klist != NULL) {
+ if (find_key(NULL, value, *klist)) {
+ TEST_info("Duplicate key %s", value);
+ return 0;
+ }
+ if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key)))
+ || !TEST_ptr(key->name = OPENSSL_strdup(value)))
+ return 0;
+ key->key = pkey;
+ key->next = *klist;
+ *klist = key;
+
+ /* Go back and start a new stanza. */
+ 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;
+ }
+ if (t->skip == 1) {
+ /* TEST_info("skipping %s %s", keyword, value); */
+ goto skiptoend;
+ }
+
+ /* 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) {
+ if (t->expected_err != NULL) {
+ TEST_info("Line %d: multiple result lines", t->line);
+ goto skiptoend;
+ }
+ if (!TEST_ptr(t->expected_err = OPENSSL_strdup(value)))
+ goto skiptoend;
+ } else if (strcmp(keyword, "Function") == 0) {
+ if (t->func != NULL) {
+ TEST_info("Line %d: multiple function lines\n", t->line);
+ goto skiptoend;
+ }
+ if (!TEST_ptr(t->func = OPENSSL_strdup(value)))
+ goto skiptoend;
+ } else if (strcmp(keyword, "Reason") == 0) {
+ if (t->reason != NULL) {
+ TEST_info("Line %d: multiple reason lines", t->line);
+ goto skiptoend;
+ }
+ if (!TEST_ptr(t->reason = OPENSSL_strdup(value)))
+ goto skiptoend;
+ } else {
+ /* Must be test specific line: try to parse it */
+ int rv = t->meth->parse(t, keyword, value);
+
+ if (rv == 0) {
+ TEST_info("Line %d: unknown keyword %s", t->line, keyword);
+ goto skiptoend;
+ }
+ if (rv < 0) {
+ TEST_info("Line %d: error processing keyword %s\n",
+ t->line, keyword);
+ goto skiptoend;
+ }
+ }
+ }
+
+ 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 int run_file_tests(int i)
+{
+ return do_test_file(testfiles[i]);
+}
+
+int test_main(int argc, char *argv[])
+{
+ if (argc < 2) {
+ TEST_error("Usage: %s file...", argv[0]);
+ return 0;
+ }
+ testfiles = &argv[1];
+
+ ADD_ALL_TESTS(run_file_tests, argc - 1);
+
+ return run_tests(argv[0]);
+}