2 * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
12 #include <openssl/e_os2.h>
13 #include <openssl/crypto.h>
16 #include "ssl_test_ctx.h"
18 /* True enums and other test configuration values that map to an int. */
25 __owur static int parse_enum(const test_enum *enums, size_t num_enums,
26 int *value, const char *name)
29 for (i = 0; i < num_enums; i++) {
30 if (strcmp(enums[i].name, name) == 0) {
31 *value = enums[i].value;
38 static const char *enum_name(const test_enum *enums, size_t num_enums,
42 for (i = 0; i < num_enums; i++) {
43 if (enums[i].value == value) {
47 return "InvalidValue";
55 static const test_enum ssl_test_results[] = {
56 {"Success", SSL_TEST_SUCCESS},
57 {"ServerFail", SSL_TEST_SERVER_FAIL},
58 {"ClientFail", SSL_TEST_CLIENT_FAIL},
59 {"InternalError", SSL_TEST_INTERNAL_ERROR},
62 __owur static int parse_expected_result(SSL_TEST_CTX *test_ctx, const char *value)
65 if (!parse_enum(ssl_test_results, OSSL_NELEM(ssl_test_results),
69 test_ctx->expected_result = ret_value;
73 const char *ssl_test_result_name(ssl_test_result_t result)
75 return enum_name(ssl_test_results, OSSL_NELEM(ssl_test_results), result);
78 /******************************/
79 /* ClientAlert / ServerAlert. */
80 /******************************/
82 static const test_enum ssl_alerts[] = {
83 {"UnknownCA", SSL_AD_UNKNOWN_CA},
84 {"HandshakeFailure", SSL_AD_HANDSHAKE_FAILURE},
85 {"UnrecognizedName", SSL_AD_UNRECOGNIZED_NAME},
86 {"BadCertificate", SSL_AD_BAD_CERTIFICATE}
89 __owur static int parse_alert(int *alert, const char *value)
91 return parse_enum(ssl_alerts, OSSL_NELEM(ssl_alerts), alert, value);
94 __owur static int parse_client_alert(SSL_TEST_CTX *test_ctx, const char *value)
96 return parse_alert(&test_ctx->client_alert, value);
99 __owur static int parse_server_alert(SSL_TEST_CTX *test_ctx, const char *value)
101 return parse_alert(&test_ctx->server_alert, value);
104 const char *ssl_alert_name(int alert)
106 return enum_name(ssl_alerts, OSSL_NELEM(ssl_alerts), alert);
113 static const test_enum ssl_protocols[] = {
114 {"TLSv1.2", TLS1_2_VERSION},
115 {"TLSv1.1", TLS1_1_VERSION},
116 {"TLSv1", TLS1_VERSION},
117 {"SSLv3", SSL3_VERSION},
118 {"DTLSv1", DTLS1_VERSION},
119 {"DTLSv1.2", DTLS1_2_VERSION},
122 __owur static int parse_protocol(SSL_TEST_CTX *test_ctx, const char *value)
124 return parse_enum(ssl_protocols, OSSL_NELEM(ssl_protocols),
125 &test_ctx->protocol, value);
128 const char *ssl_protocol_name(int protocol)
130 return enum_name(ssl_protocols, OSSL_NELEM(ssl_protocols), protocol);
133 /***********************/
134 /* CertVerifyCallback. */
135 /***********************/
137 static const test_enum ssl_verify_callbacks[] = {
138 {"None", SSL_TEST_VERIFY_NONE},
139 {"AcceptAll", SSL_TEST_VERIFY_ACCEPT_ALL},
140 {"RejectAll", SSL_TEST_VERIFY_REJECT_ALL},
143 __owur static int parse_client_verify_callback(SSL_TEST_CTX *test_ctx,
147 if (!parse_enum(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
148 &ret_value, value)) {
151 test_ctx->client_verify_callback = ret_value;
155 const char *ssl_verify_callback_name(ssl_verify_callback_t callback)
157 return enum_name(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
165 static const test_enum ssl_servername[] = {
166 {"None", SSL_TEST_SERVERNAME_NONE},
167 {"server1", SSL_TEST_SERVERNAME_SERVER1},
168 {"server2", SSL_TEST_SERVERNAME_SERVER2},
169 {"invalid", SSL_TEST_SERVERNAME_INVALID},
172 __owur static int parse_servername(SSL_TEST_CTX *test_ctx,
176 if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
177 &ret_value, value)) {
180 test_ctx->servername = ret_value;
184 __owur static int parse_expected_servername(SSL_TEST_CTX *test_ctx,
188 if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
189 &ret_value, value)) {
192 test_ctx->expected_servername = ret_value;
196 const char *ssl_servername_name(ssl_servername_t server)
198 return enum_name(ssl_servername, OSSL_NELEM(ssl_servername),
202 /***********************/
203 /* ServerNameCallback. */
204 /***********************/
206 static const test_enum ssl_servername_callbacks[] = {
207 {"None", SSL_TEST_SERVERNAME_CB_NONE},
208 {"IgnoreMismatch", SSL_TEST_SERVERNAME_IGNORE_MISMATCH},
209 {"RejectMismatch", SSL_TEST_SERVERNAME_REJECT_MISMATCH},
212 __owur static int parse_servername_callback(SSL_TEST_CTX *test_ctx,
216 if (!parse_enum(ssl_servername_callbacks,
217 OSSL_NELEM(ssl_servername_callbacks), &ret_value, value)) {
220 test_ctx->servername_callback = ret_value;
224 const char *ssl_servername_callback_name(ssl_servername_callback_t callback)
226 return enum_name(ssl_servername_callbacks,
227 OSSL_NELEM(ssl_servername_callbacks), callback);
230 /*************************/
231 /* SessionTicketExpected */
232 /*************************/
234 static const test_enum ssl_session_ticket[] = {
235 {"Ignore", SSL_TEST_SESSION_TICKET_IGNORE},
236 {"Yes", SSL_TEST_SESSION_TICKET_YES},
237 {"No", SSL_TEST_SESSION_TICKET_NO},
238 {"Broken", SSL_TEST_SESSION_TICKET_BROKEN},
241 __owur static int parse_session_ticket(SSL_TEST_CTX *test_ctx, const char *value)
244 if (!parse_enum(ssl_session_ticket, OSSL_NELEM(ssl_session_ticket),
245 &ret_value, value)) {
248 test_ctx->session_ticket_expected = ret_value;
252 const char *ssl_session_ticket_name(ssl_session_ticket_t server)
254 return enum_name(ssl_session_ticket,
255 OSSL_NELEM(ssl_session_ticket),
259 /***********************/
261 /***********************/
263 static const test_enum ssl_test_methods[] = {
264 {"TLS", SSL_TEST_METHOD_TLS},
265 {"DTLS", SSL_TEST_METHOD_DTLS},
268 __owur static int parse_test_method(SSL_TEST_CTX *test_ctx, const char *value)
271 if (!parse_enum(ssl_test_methods, OSSL_NELEM(ssl_test_methods),
272 &ret_value, value)) {
275 test_ctx->method = ret_value;
279 const char *ssl_test_method_name(ssl_test_method_t method)
281 return enum_name(ssl_test_methods, OSSL_NELEM(ssl_test_methods), method);
284 /*************************************************************/
285 /* Known test options and their corresponding parse methods. */
286 /*************************************************************/
290 int (*parse)(SSL_TEST_CTX *test_ctx, const char *value);
291 } ssl_test_ctx_option;
293 static const ssl_test_ctx_option ssl_test_ctx_options[] = {
294 { "ExpectedResult", &parse_expected_result },
295 { "ClientAlert", &parse_client_alert },
296 { "ServerAlert", &parse_server_alert },
297 { "Protocol", &parse_protocol },
298 { "ClientVerifyCallback", &parse_client_verify_callback },
299 { "ServerName", &parse_servername },
300 { "ExpectedServerName", &parse_expected_servername },
301 { "ServerNameCallback", &parse_servername_callback },
302 { "SessionTicketExpected", &parse_session_ticket },
303 { "Method", &parse_test_method },
308 * Since these methods are used to create tests, we use OPENSSL_assert liberally
309 * for malloc failures and other internal errors.
311 SSL_TEST_CTX *SSL_TEST_CTX_new()
314 ret = OPENSSL_zalloc(sizeof(*ret));
315 OPENSSL_assert(ret != NULL);
319 void SSL_TEST_CTX_free(SSL_TEST_CTX *ctx)
324 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
326 STACK_OF(CONF_VALUE) *sk_conf;
331 sk_conf = NCONF_get_section(conf, test_section);
332 OPENSSL_assert(sk_conf != NULL);
334 ctx = SSL_TEST_CTX_new();
335 OPENSSL_assert(ctx != NULL);
337 for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
339 const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
340 for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
341 if (strcmp(option->name, ssl_test_ctx_options[j].name) == 0) {
342 if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
343 fprintf(stderr, "Bad value %s for option %s\n",
344 option->value, option->name);
352 fprintf(stderr, "Unknown test option: %s\n", option->name);
360 SSL_TEST_CTX_free(ctx);