+ 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 *expected = t->data;
+ unsigned char *got = NULL;
+ size_t got_len;
+
+ if (!evp_test_buffer_do(expected->input, digestsign_update_fn,
+ expected->ctx)) {
+ t->err = "DIGESTUPDATE_ERROR";
+ goto err;
+ }
+
+ if (!EVP_DigestSignFinal(expected->ctx, NULL, &got_len)) {
+ t->err = "DIGESTSIGNFINAL_LENGTH_ERROR";
+ goto err;
+ }
+ if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
+ t->err = "MALLOC_FAILURE";
+ goto err;
+ }
+ if (!EVP_DigestSignFinal(expected->ctx, got, &got_len)) {
+ t->err = "DIGESTSIGNFINAL_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 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 *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;