test/ssl_test_ctx.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   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
   8  */
   9
  10 #include <string.h>
  11
  12 #include <openssl/e_os2.h>
  13 #include <openssl/crypto.h>
  14
  15 #include "e_os.h"
  16 #include "ssl_test_ctx.h"
  17
  18 /* True enums and other test configuration values that map to an int. */
  19 typedef struct {
  20     const char *name;
  21     int value;
  22 } test_enum;
  23
  24
  25 __owur static int parse_enum(const test_enum *enums, size_t num_enums,
  26                              int *value, const char *name)
  27 {
  28     size_t i;
  29     for (i = 0; i < num_enums; i++) {
  30         if (strcmp(enums[i].name, name) == 0) {
  31             *value = enums[i].value;
  32             return 1;
  33         }
  34     }
  35     return 0;
  36 }
  37
  38 static const char *enum_name(const test_enum *enums, size_t num_enums,
  39                              int value)
  40 {
  41     size_t i;
  42     for (i = 0; i < num_enums; i++) {
  43         if (enums[i].value == value) {
  44             return enums[i].name;
  45         }
  46     }
  47     return "InvalidValue";
  48 }
  49
  50
  51 /*******************/
  52 /* ExpectedResult. */
  53 /*******************/
  54
  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},
  60 };
  61
  62 __owur static int parse_expected_result(SSL_TEST_CTX *test_ctx, const char *value)
  63 {
  64     int ret_value;
  65     if (!parse_enum(ssl_test_results, OSSL_NELEM(ssl_test_results),
  66                     &ret_value, value)) {
  67         return 0;
  68     }
  69     test_ctx->expected_result = ret_value;
  70     return 1;
  71 }
  72
  73 const char *ssl_test_result_name(ssl_test_result_t result)
  74 {
  75     return enum_name(ssl_test_results, OSSL_NELEM(ssl_test_results), result);
  76 }
  77
  78 /******************************/
  79 /* ClientAlert / ServerAlert. */
  80 /******************************/
  81
  82 static const test_enum ssl_alerts[] = {
  83     {"UnknownCA", SSL_AD_UNKNOWN_CA},
  84     {"HandshakeFailure", SSL_AD_HANDSHAKE_FAILURE},
  85 };
  86
  87 __owur static int parse_alert(int *alert, const char *value)
  88 {
  89     return parse_enum(ssl_alerts, OSSL_NELEM(ssl_alerts), alert, value);
  90 }
  91
  92 __owur static int parse_client_alert(SSL_TEST_CTX *test_ctx, const char *value)
  93 {
  94     return parse_alert(&test_ctx->client_alert, value);
  95 }
  96
  97 __owur static int parse_server_alert(SSL_TEST_CTX *test_ctx, const char *value)
  98 {
  99     return parse_alert(&test_ctx->server_alert, value);
 100 }
 101
 102 const char *ssl_alert_name(int alert)
 103 {
 104     return enum_name(ssl_alerts, OSSL_NELEM(ssl_alerts), alert);
 105 }
 106
 107 /************/
 108 /* Protocol */
 109 /************/
 110
 111 static const test_enum ssl_protocols[] = {
 112      {"TLSv1.2", TLS1_2_VERSION},
 113      {"TLSv1.1", TLS1_1_VERSION},
 114      {"TLSv1", TLS1_VERSION},
 115      {"SSLv3", SSL3_VERSION},
 116      {"DTLSv1", DTLS1_VERSION},
 117      {"DTLSv1.2", DTLS1_2_VERSION},
 118 };
 119
 120 __owur static int parse_protocol(SSL_TEST_CTX *test_ctx, const char *value)
 121 {
 122     return parse_enum(ssl_protocols, OSSL_NELEM(ssl_protocols),
 123                       &test_ctx->protocol, value);
 124 }
 125
 126 const char *ssl_protocol_name(int protocol)
 127 {
 128     return enum_name(ssl_protocols, OSSL_NELEM(ssl_protocols), protocol);
 129 }
 130
 131 /***********************/
 132 /* CertVerifyCallback. */
 133 /***********************/
 134
 135 static const test_enum ssl_verify_callbacks[] = {
 136     {"None", SSL_TEST_VERIFY_NONE},
 137     {"AcceptAll", SSL_TEST_VERIFY_ACCEPT_ALL},
 138     {"RejectAll", SSL_TEST_VERIFY_REJECT_ALL},
 139 };
 140
 141 __owur static int parse_client_verify_callback(SSL_TEST_CTX *test_ctx,
 142                                               const char *value)
 143 {
 144     int ret_value;
 145     if (!parse_enum(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
 146                     &ret_value, value)) {
 147         return 0;
 148     }
 149     test_ctx->client_verify_callback = ret_value;
 150     return 1;
 151 }
 152
 153 const char *ssl_verify_callback_name(ssl_verify_callback_t callback)
 154 {
 155     return enum_name(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
 156                      callback);
 157 }
 158
 159 /**************/
 160 /* ServerName */
 161 /**************/
 162
 163 static const test_enum ssl_servername[] = {
 164     {"None", SSL_TEST_SERVERNAME_NONE},
 165     {"server1", SSL_TEST_SERVERNAME_SERVER1},
 166     {"server2", SSL_TEST_SERVERNAME_SERVER2},
 167 };
 168
 169 __owur static int parse_servername(SSL_TEST_CTX *test_ctx,
 170                                    const char *value)
 171 {
 172     int ret_value;
 173     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
 174                     &ret_value, value)) {
 175         return 0;
 176     }
 177     test_ctx->servername = ret_value;
 178     return 1;
 179 }
 180
 181 const char *ssl_servername_name(ssl_servername_t server)
 182 {
 183     return enum_name(ssl_servername, OSSL_NELEM(ssl_servername),
 184                      server);
 185 }
 186
 187 /*************************/
 188 /* SessionTicketExpected */
 189 /*************************/
 190
 191 static const test_enum ssl_session_ticket[] = {
 192     {"Ignore", SSL_TEST_SESSION_TICKET_IGNORE},
 193     {"Yes", SSL_TEST_SESSION_TICKET_YES},
 194     {"No", SSL_TEST_SESSION_TICKET_NO},
 195     {"Broken", SSL_TEST_SESSION_TICKET_BROKEN},
 196 };
 197
 198 __owur static int parse_session_ticket(SSL_TEST_CTX *test_ctx, const char *value)
 199 {
 200     int ret_value;
 201     if (!parse_enum(ssl_session_ticket, OSSL_NELEM(ssl_session_ticket),
 202                     &ret_value, value)) {
 203         return 0;
 204     }
 205     test_ctx->session_ticket_expected = ret_value;
 206     return 1;
 207 }
 208
 209 const char *ssl_session_ticket_name(ssl_session_ticket_t server)
 210 {
 211     return enum_name(ssl_session_ticket,
 212                      OSSL_NELEM(ssl_session_ticket),
 213                      server);
 214 }
 215
 216 /***********************/
 217 /* Method.             */
 218 /***********************/
 219
 220 static const test_enum ssl_test_methods[] = {
 221     {"TLS", SSL_TEST_METHOD_TLS},
 222     {"DTLS", SSL_TEST_METHOD_DTLS},
 223 };
 224
 225 __owur static int parse_test_method(SSL_TEST_CTX *test_ctx, const char *value)
 226 {
 227     int ret_value;
 228     if (!parse_enum(ssl_test_methods, OSSL_NELEM(ssl_test_methods),
 229                     &ret_value, value)) {
 230         return 0;
 231     }
 232     test_ctx->method = ret_value;
 233     return 1;
 234 }
 235
 236 const char *ssl_test_method_name(ssl_test_method_t method)
 237 {
 238     return enum_name(ssl_test_methods, OSSL_NELEM(ssl_test_methods), method);
 239 }
 240
 241 /*************************************************************/
 242 /* Known test options and their corresponding parse methods. */
 243 /*************************************************************/
 244
 245 typedef struct {
 246     const char *name;
 247     int (*parse)(SSL_TEST_CTX *test_ctx, const char *value);
 248 } ssl_test_ctx_option;
 249
 250 static const ssl_test_ctx_option ssl_test_ctx_options[] = {
 251     { "ExpectedResult", &parse_expected_result },
 252     { "ClientAlert", &parse_client_alert },
 253     { "ServerAlert", &parse_server_alert },
 254     { "Protocol", &parse_protocol },
 255     { "ClientVerifyCallback", &parse_client_verify_callback },
 256     { "ServerName", &parse_servername },
 257     { "SessionTicketExpected", &parse_session_ticket },
 258     { "Method", &parse_test_method },
 259 };
 260
 261
 262 /*
 263  * Since these methods are used to create tests, we use OPENSSL_assert liberally
 264  * for malloc failures and other internal errors.
 265  */
 266 SSL_TEST_CTX *SSL_TEST_CTX_new()
 267 {
 268     SSL_TEST_CTX *ret;
 269     ret = OPENSSL_zalloc(sizeof(*ret));
 270     OPENSSL_assert(ret != NULL);
 271     return ret;
 272 }
 273
 274 void SSL_TEST_CTX_free(SSL_TEST_CTX *ctx)
 275 {
 276     OPENSSL_free(ctx);
 277 }
 278
 279 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
 280 {
 281     STACK_OF(CONF_VALUE) *sk_conf;
 282     SSL_TEST_CTX *ctx;
 283     int i;
 284     size_t j;
 285
 286     sk_conf = NCONF_get_section(conf, test_section);
 287     OPENSSL_assert(sk_conf != NULL);
 288
 289     ctx = SSL_TEST_CTX_new();
 290     OPENSSL_assert(ctx != NULL);
 291
 292     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
 293         int found = 0;
 294         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
 295         for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
 296             if (strcmp(option->name, ssl_test_ctx_options[j].name) == 0) {
 297                 if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
 298                     fprintf(stderr, "Bad value %s for option %s\n",
 299                             option->value, option->name);
 300                     goto err;
 301                 }
 302                 found = 1;
 303                 break;
 304             }
 305         }
 306         if (!found) {
 307             fprintf(stderr, "Unknown test option: %s\n", option->name);
 308             goto err;
 309         }
 310     }
 311
 312     goto done;
 313
 314  err:
 315     SSL_TEST_CTX_free(ctx);
 316     ctx = NULL;
 317  done:
 318     return ctx;
 319 }