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     {"UnrecognizedName", SSL_AD_UNRECOGNIZED_NAME},
  86 };
  87
  88 __owur static int parse_alert(int *alert, const char *value)
  89 {
  90     return parse_enum(ssl_alerts, OSSL_NELEM(ssl_alerts), alert, value);
  91 }
  92
  93 __owur static int parse_client_alert(SSL_TEST_CTX *test_ctx, const char *value)
  94 {
  95     return parse_alert(&test_ctx->client_alert, value);
  96 }
  97
  98 __owur static int parse_server_alert(SSL_TEST_CTX *test_ctx, const char *value)
  99 {
 100     return parse_alert(&test_ctx->server_alert, value);
 101 }
 102
 103 const char *ssl_alert_name(int alert)
 104 {
 105     return enum_name(ssl_alerts, OSSL_NELEM(ssl_alerts), alert);
 106 }
 107
 108 /************/
 109 /* Protocol */
 110 /************/
 111
 112 static const test_enum ssl_protocols[] = {
 113      {"TLSv1.2", TLS1_2_VERSION},
 114      {"TLSv1.1", TLS1_1_VERSION},
 115      {"TLSv1", TLS1_VERSION},
 116      {"SSLv3", SSL3_VERSION},
 117      {"DTLSv1", DTLS1_VERSION},
 118      {"DTLSv1.2", DTLS1_2_VERSION},
 119 };
 120
 121 __owur static int parse_protocol(SSL_TEST_CTX *test_ctx, const char *value)
 122 {
 123     return parse_enum(ssl_protocols, OSSL_NELEM(ssl_protocols),
 124                       &test_ctx->protocol, value);
 125 }
 126
 127 const char *ssl_protocol_name(int protocol)
 128 {
 129     return enum_name(ssl_protocols, OSSL_NELEM(ssl_protocols), protocol);
 130 }
 131
 132 /***********************/
 133 /* CertVerifyCallback. */
 134 /***********************/
 135
 136 static const test_enum ssl_verify_callbacks[] = {
 137     {"None", SSL_TEST_VERIFY_NONE},
 138     {"AcceptAll", SSL_TEST_VERIFY_ACCEPT_ALL},
 139     {"RejectAll", SSL_TEST_VERIFY_REJECT_ALL},
 140 };
 141
 142 __owur static int parse_client_verify_callback(SSL_TEST_CTX *test_ctx,
 143                                               const char *value)
 144 {
 145     int ret_value;
 146     if (!parse_enum(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
 147                     &ret_value, value)) {
 148         return 0;
 149     }
 150     test_ctx->client_verify_callback = ret_value;
 151     return 1;
 152 }
 153
 154 const char *ssl_verify_callback_name(ssl_verify_callback_t callback)
 155 {
 156     return enum_name(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
 157                      callback);
 158 }
 159
 160 /**************/
 161 /* ServerName */
 162 /**************/
 163
 164 static const test_enum ssl_servername[] = {
 165     {"None", SSL_TEST_SERVERNAME_NONE},
 166     {"server1", SSL_TEST_SERVERNAME_SERVER1},
 167     {"server2", SSL_TEST_SERVERNAME_SERVER2},
 168     {"invalid", SSL_TEST_SERVERNAME_INVALID},
 169 };
 170
 171 __owur static int parse_servername(SSL_TEST_CTX *test_ctx,
 172                                    const char *value)
 173 {
 174     int ret_value;
 175     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
 176                     &ret_value, value)) {
 177         return 0;
 178     }
 179     test_ctx->servername = ret_value;
 180     return 1;
 181 }
 182
 183 __owur static int parse_expected_servername(SSL_TEST_CTX *test_ctx,
 184                                             const char *value)
 185 {
 186     int ret_value;
 187     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
 188                     &ret_value, value)) {
 189         return 0;
 190     }
 191     test_ctx->expected_servername = ret_value;
 192     return 1;
 193 }
 194
 195 const char *ssl_servername_name(ssl_servername_t server)
 196 {
 197     return enum_name(ssl_servername, OSSL_NELEM(ssl_servername),
 198                      server);
 199 }
 200
 201 /***********************/
 202 /* ServerNameCallback. */
 203 /***********************/
 204
 205 static const test_enum ssl_servername_callbacks[] = {
 206     {"None", SSL_TEST_SERVERNAME_CB_NONE},
 207     {"IgnoreMismatch", SSL_TEST_SERVERNAME_IGNORE_MISMATCH},
 208     {"RejectMismatch", SSL_TEST_SERVERNAME_REJECT_MISMATCH},
 209 };
 210
 211 __owur static int parse_servername_callback(SSL_TEST_CTX *test_ctx,
 212                                               const char *value)
 213 {
 214     int ret_value;
 215     if (!parse_enum(ssl_servername_callbacks,
 216                     OSSL_NELEM(ssl_servername_callbacks), &ret_value, value)) {
 217         return 0;
 218     }
 219     test_ctx->servername_callback = ret_value;
 220     return 1;
 221 }
 222
 223 const char *ssl_servername_callback_name(ssl_servername_callback_t callback)
 224 {
 225     return enum_name(ssl_servername_callbacks,
 226                      OSSL_NELEM(ssl_servername_callbacks), callback);
 227 }
 228
 229 /*************************/
 230 /* SessionTicketExpected */
 231 /*************************/
 232
 233 static const test_enum ssl_session_ticket[] = {
 234     {"Ignore", SSL_TEST_SESSION_TICKET_IGNORE},
 235     {"Yes", SSL_TEST_SESSION_TICKET_YES},
 236     {"No", SSL_TEST_SESSION_TICKET_NO},
 237     {"Broken", SSL_TEST_SESSION_TICKET_BROKEN},
 238 };
 239
 240 __owur static int parse_session_ticket(SSL_TEST_CTX *test_ctx, const char *value)
 241 {
 242     int ret_value;
 243     if (!parse_enum(ssl_session_ticket, OSSL_NELEM(ssl_session_ticket),
 244                     &ret_value, value)) {
 245         return 0;
 246     }
 247     test_ctx->session_ticket_expected = ret_value;
 248     return 1;
 249 }
 250
 251 const char *ssl_session_ticket_name(ssl_session_ticket_t server)
 252 {
 253     return enum_name(ssl_session_ticket,
 254                      OSSL_NELEM(ssl_session_ticket),
 255                      server);
 256 }
 257
 258 /***********************/
 259 /* Method.             */
 260 /***********************/
 261
 262 static const test_enum ssl_test_methods[] = {
 263     {"TLS", SSL_TEST_METHOD_TLS},
 264     {"DTLS", SSL_TEST_METHOD_DTLS},
 265 };
 266
 267 __owur static int parse_test_method(SSL_TEST_CTX *test_ctx, const char *value)
 268 {
 269     int ret_value;
 270     if (!parse_enum(ssl_test_methods, OSSL_NELEM(ssl_test_methods),
 271                     &ret_value, value)) {
 272         return 0;
 273     }
 274     test_ctx->method = ret_value;
 275     return 1;
 276 }
 277
 278 const char *ssl_test_method_name(ssl_test_method_t method)
 279 {
 280     return enum_name(ssl_test_methods, OSSL_NELEM(ssl_test_methods), method);
 281 }
 282
 283 /*************************************************************/
 284 /* Known test options and their corresponding parse methods. */
 285 /*************************************************************/
 286
 287 typedef struct {
 288     const char *name;
 289     int (*parse)(SSL_TEST_CTX *test_ctx, const char *value);
 290 } ssl_test_ctx_option;
 291
 292 static const ssl_test_ctx_option ssl_test_ctx_options[] = {
 293     { "ExpectedResult", &parse_expected_result },
 294     { "ClientAlert", &parse_client_alert },
 295     { "ServerAlert", &parse_server_alert },
 296     { "Protocol", &parse_protocol },
 297     { "ClientVerifyCallback", &parse_client_verify_callback },
 298     { "ServerName", &parse_servername },
 299     { "ExpectedServerName", &parse_expected_servername },
 300     { "ServerNameCallback", &parse_servername_callback },
 301     { "SessionTicketExpected", &parse_session_ticket },
 302     { "Method", &parse_test_method },
 303 };
 304
 305
 306 /*
 307  * Since these methods are used to create tests, we use OPENSSL_assert liberally
 308  * for malloc failures and other internal errors.
 309  */
 310 SSL_TEST_CTX *SSL_TEST_CTX_new()
 311 {
 312     SSL_TEST_CTX *ret;
 313     ret = OPENSSL_zalloc(sizeof(*ret));
 314     OPENSSL_assert(ret != NULL);
 315     return ret;
 316 }
 317
 318 void SSL_TEST_CTX_free(SSL_TEST_CTX *ctx)
 319 {
 320     OPENSSL_free(ctx);
 321 }
 322
 323 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
 324 {
 325     STACK_OF(CONF_VALUE) *sk_conf;
 326     SSL_TEST_CTX *ctx;
 327     int i;
 328     size_t j;
 329
 330     sk_conf = NCONF_get_section(conf, test_section);
 331     OPENSSL_assert(sk_conf != NULL);
 332
 333     ctx = SSL_TEST_CTX_new();
 334     OPENSSL_assert(ctx != NULL);
 335
 336     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
 337         int found = 0;
 338         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
 339         for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
 340             if (strcmp(option->name, ssl_test_ctx_options[j].name) == 0) {
 341                 if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
 342                     fprintf(stderr, "Bad value %s for option %s\n",
 343                             option->value, option->name);
 344                     goto err;
 345                 }
 346                 found = 1;
 347                 break;
 348             }
 349         }
 350         if (!found) {
 351             fprintf(stderr, "Unknown test option: %s\n", option->name);
 352             goto err;
 353         }
 354     }
 355
 356     goto done;
 357
 358  err:
 359     SSL_TEST_CTX_free(ctx);
 360     ctx = NULL;
 361  done:
 362     return ctx;
 363 }