+
+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 *expected = t->data;
+ unsigned char *got = NULL;
+ size_t got_len;
+
+ if (!EVP_DigestSign(expected->ctx, NULL, &got_len,
+ expected->osin, expected->osin_len)) {
+ t->err = "DIGESTSIGN_LENGTH_ERROR";
+ goto err;
+ }
+ if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
+ t->err = "MALLOC_FAILURE";
+ goto err;
+ }
+ if (!EVP_DigestSign(expected->ctx, got, &got_len,
+ expected->osin, expected->osin_len)) {
+ t->err = "DIGESTSIGN_ERROR";
+ goto err;
+ }
+ if (!TEST_mem_eq(expected->output, expected->output_len, got, got_len)) {
+ t->err = "SIGNATURE_MISMATCH";
+ goto err;
+ }
+
+ err:
+ OPENSSL_free(got);
+ 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,
+ &keygen_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)
+{
+ test_clearstanza(&t->s);
+ 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("%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("%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("%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("%s:%d: Expected %s got %s",
+ t->s.test_file, t->s.start, 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("%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("%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("%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("%s:%d: Expected error \"%s:%s\", got \"%s:%s\"",
+ t->s.test_file, t->s.start, 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->s.numtests++;
+ if (t->skip) {
+ t->s.numskip++;
+ } else {
+ /* run the test */
+ if (t->err == NULL && t->meth->run_test(t) != 1) {
+ 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->s.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;
+ }
+}
+
+/*
+ * 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;
+}
+
+/*
+ * NULL out the value from |pp| but return it. This "steals" a pointer.
+ */
+static char *take_value(PAIR *pp)
+{
+ 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;
+
+top:
+ do {
+ if (BIO_eof(t->s.fp))
+ return EOF;
+ 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(pp->key, "PrivateKey") == 0) {
+ pkey = PEM_read_bio_PrivateKey(t->s.key, NULL, 0, NULL);
+ if (pkey == NULL && !key_unsupported()) {
+ 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(pp->key, "PublicKey") == 0) {
+ pkey = PEM_read_bio_PUBKEY(t->s.key, NULL, 0, NULL);
+ if (pkey == NULL && !key_unsupported()) {
+ 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, pp->value, *klist)) {
+ TEST_info("Duplicate key %s", pp->value);
+ return 0;
+ }
+ 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;
+ }
+
+ /* 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", pp->key, pp->value); */
+ return 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->s.curr);
+ return 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->s.curr);
+ return 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->s.curr);
+ return 0;
+ }
+ t->reason = take_value(pp);
+ } else {
+ /* Must be test specific line: try to parse it */
+ int rv = t->meth->parse(t, pp->key, pp->value);
+
+ if (rv == 0) {
+ 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->s.curr, pp->key);
+ return 0;
+ }
+ }
+ }
+
+ return 1;
+}
+
+static int run_file_tests(int i)
+{
+ EVP_TEST *t;
+ const char *testfile = test_get_argument(i);
+ int c;
+
+ if (!TEST_ptr(t = OPENSSL_zalloc(sizeof(*t))))
+ return 0;
+ if (!test_start_file(&t->s, testfile)) {
+ 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 setup_tests(void)
+{
+ size_t n = test_get_argument_count();
+
+ if (n == 0) {
+ TEST_error("Usage: %s file...", test_get_program_name());
+ return 0;
+ }
+
+ ADD_ALL_TESTS(run_file_tests, n);
+ return 1;
+}