+
+/**
+*** 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;
+}
+