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     {"BadCertificate", SSL_AD_BAD_CERTIFICATE},
  87     {"NoApplicationProtocol", SSL_AD_NO_APPLICATION_PROTOCOL},
  88 };
  89
  90 __owur static int parse_alert(int *alert, const char *value)
  91 {
  92     return parse_enum(ssl_alerts, OSSL_NELEM(ssl_alerts), alert, value);
  93 }
  94
  95 __owur static int parse_client_alert(SSL_TEST_CTX *test_ctx, const char *value)
  96 {
  97     return parse_alert(&test_ctx->client_alert, value);
  98 }
  99
 100 __owur static int parse_server_alert(SSL_TEST_CTX *test_ctx, const char *value)
 101 {
 102     return parse_alert(&test_ctx->server_alert, value);
 103 }
 104
 105 const char *ssl_alert_name(int alert)
 106 {
 107     return enum_name(ssl_alerts, OSSL_NELEM(ssl_alerts), alert);
 108 }
 109
 110 /************/
 111 /* Protocol */
 112 /************/
 113
 114 static const test_enum ssl_protocols[] = {
 115      {"TLSv1.2", TLS1_2_VERSION},
 116      {"TLSv1.1", TLS1_1_VERSION},
 117      {"TLSv1", TLS1_VERSION},
 118      {"SSLv3", SSL3_VERSION},
 119      {"DTLSv1", DTLS1_VERSION},
 120      {"DTLSv1.2", DTLS1_2_VERSION},
 121 };
 122
 123 __owur static int parse_protocol(SSL_TEST_CTX *test_ctx, const char *value)
 124 {
 125     return parse_enum(ssl_protocols, OSSL_NELEM(ssl_protocols),
 126                       &test_ctx->protocol, value);
 127 }
 128
 129 const char *ssl_protocol_name(int protocol)
 130 {
 131     return enum_name(ssl_protocols, OSSL_NELEM(ssl_protocols), protocol);
 132 }
 133
 134 /***********************/
 135 /* CertVerifyCallback. */
 136 /***********************/
 137
 138 static const test_enum ssl_verify_callbacks[] = {
 139     {"None", SSL_TEST_VERIFY_NONE},
 140     {"AcceptAll", SSL_TEST_VERIFY_ACCEPT_ALL},
 141     {"RejectAll", SSL_TEST_VERIFY_REJECT_ALL},
 142 };
 143
 144 __owur static int parse_client_verify_callback(SSL_TEST_CTX *test_ctx,
 145                                               const char *value)
 146 {
 147     int ret_value;
 148     if (!parse_enum(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
 149                     &ret_value, value)) {
 150         return 0;
 151     }
 152     test_ctx->client_verify_callback = ret_value;
 153     return 1;
 154 }
 155
 156 const char *ssl_verify_callback_name(ssl_verify_callback_t callback)
 157 {
 158     return enum_name(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
 159                      callback);
 160 }
 161
 162 /**************/
 163 /* ServerName */
 164 /**************/
 165
 166 static const test_enum ssl_servername[] = {
 167     {"None", SSL_TEST_SERVERNAME_NONE},
 168     {"server1", SSL_TEST_SERVERNAME_SERVER1},
 169     {"server2", SSL_TEST_SERVERNAME_SERVER2},
 170     {"invalid", SSL_TEST_SERVERNAME_INVALID},
 171 };
 172
 173 __owur static int parse_servername(SSL_TEST_CTX *test_ctx,
 174                                    const char *value)
 175 {
 176     int ret_value;
 177     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
 178                     &ret_value, value)) {
 179         return 0;
 180     }
 181     test_ctx->servername = ret_value;
 182     return 1;
 183 }
 184
 185 __owur static int parse_expected_servername(SSL_TEST_CTX *test_ctx,
 186                                             const char *value)
 187 {
 188     int ret_value;
 189     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
 190                     &ret_value, value)) {
 191         return 0;
 192     }
 193     test_ctx->expected_servername = ret_value;
 194     return 1;
 195 }
 196
 197 const char *ssl_servername_name(ssl_servername_t server)
 198 {
 199     return enum_name(ssl_servername, OSSL_NELEM(ssl_servername),
 200                      server);
 201 }
 202
 203 /***********************/
 204 /* ServerNameCallback. */
 205 /***********************/
 206
 207 static const test_enum ssl_servername_callbacks[] = {
 208     {"None", SSL_TEST_SERVERNAME_CB_NONE},
 209     {"IgnoreMismatch", SSL_TEST_SERVERNAME_IGNORE_MISMATCH},
 210     {"RejectMismatch", SSL_TEST_SERVERNAME_REJECT_MISMATCH},
 211 };
 212
 213 __owur static int parse_servername_callback(SSL_TEST_CTX *test_ctx,
 214                                               const char *value)
 215 {
 216     int ret_value;
 217     if (!parse_enum(ssl_servername_callbacks,
 218                     OSSL_NELEM(ssl_servername_callbacks), &ret_value, value)) {
 219         return 0;
 220     }
 221     test_ctx->servername_callback = ret_value;
 222     return 1;
 223 }
 224
 225 const char *ssl_servername_callback_name(ssl_servername_callback_t callback)
 226 {
 227     return enum_name(ssl_servername_callbacks,
 228                      OSSL_NELEM(ssl_servername_callbacks), callback);
 229 }
 230
 231 /*************************/
 232 /* SessionTicketExpected */
 233 /*************************/
 234
 235 static const test_enum ssl_session_ticket[] = {
 236     {"Ignore", SSL_TEST_SESSION_TICKET_IGNORE},
 237     {"Yes", SSL_TEST_SESSION_TICKET_YES},
 238     {"No", SSL_TEST_SESSION_TICKET_NO},
 239     {"Broken", SSL_TEST_SESSION_TICKET_BROKEN},
 240 };
 241
 242 __owur static int parse_session_ticket(SSL_TEST_CTX *test_ctx, const char *value)
 243 {
 244     int ret_value;
 245     if (!parse_enum(ssl_session_ticket, OSSL_NELEM(ssl_session_ticket),
 246                     &ret_value, value)) {
 247         return 0;
 248     }
 249     test_ctx->session_ticket_expected = ret_value;
 250     return 1;
 251 }
 252
 253 const char *ssl_session_ticket_name(ssl_session_ticket_t server)
 254 {
 255     return enum_name(ssl_session_ticket,
 256                      OSSL_NELEM(ssl_session_ticket),
 257                      server);
 258 }
 259
 260 /***********************/
 261 /* Method.             */
 262 /***********************/
 263
 264 static const test_enum ssl_test_methods[] = {
 265     {"TLS", SSL_TEST_METHOD_TLS},
 266     {"DTLS", SSL_TEST_METHOD_DTLS},
 267 };
 268
 269 __owur static int parse_test_method(SSL_TEST_CTX *test_ctx, const char *value)
 270 {
 271     int ret_value;
 272     if (!parse_enum(ssl_test_methods, OSSL_NELEM(ssl_test_methods),
 273                     &ret_value, value)) {
 274         return 0;
 275     }
 276     test_ctx->method = ret_value;
 277     return 1;
 278 }
 279
 280 const char *ssl_test_method_name(ssl_test_method_t method)
 281 {
 282     return enum_name(ssl_test_methods, OSSL_NELEM(ssl_test_methods), method);
 283 }
 284
 285 #define IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(field)                     \
 286     static int parse_##field(SSL_TEST_CTX *test_ctx, const char *value) \
 287     {                                                                   \
 288         OPENSSL_free(test_ctx->field);                                  \
 289         test_ctx->field = OPENSSL_strdup(value);                        \
 290         OPENSSL_assert(test_ctx->field != NULL);                        \
 291         return 1;                                                       \
 292     }
 293
 294 /************************************/
 295 /* NPN and ALPN options             */
 296 /************************************/
 297
 298 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(client_npn_protocols)
 299 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(server_npn_protocols)
 300 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(server2_npn_protocols)
 301 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(expected_npn_protocol)
 302 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(client_alpn_protocols)
 303 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(server_alpn_protocols)
 304 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(server2_alpn_protocols)
 305 IMPLEMENT_SSL_TEST_CTX_STRING_OPTION(expected_alpn_protocol)
 306
 307 /***********************/
 308 /* Handshake mode      */
 309 /***********************/
 310
 311 static const test_enum ssl_handshake_modes[] = {
 312     {"Simple", SSL_TEST_HANDSHAKE_SIMPLE},
 313     {"Resume", SSL_TEST_HANDSHAKE_RESUME},
 314     {"Renegotiate", SSL_TEST_HANDSHAKE_RENEGOTIATE},
 315 };
 316
 317 __owur static int parse_handshake_mode(SSL_TEST_CTX *test_ctx, const char *value)
 318 {
 319     int ret_value;
 320     if (!parse_enum(ssl_handshake_modes, OSSL_NELEM(ssl_handshake_modes),
 321                     &ret_value, value)) {
 322         return 0;
 323     }
 324     test_ctx->handshake_mode = ret_value;
 325     return 1;
 326 }
 327
 328 const char *ssl_handshake_mode_name(ssl_handshake_mode_t mode)
 329 {
 330     return enum_name(ssl_handshake_modes, OSSL_NELEM(ssl_handshake_modes),
 331                      mode);
 332 }
 333
 334 static int parse_boolean(const char *value, int *result)
 335 {
 336     if (strcasecmp(value, "Yes") == 0) {
 337         *result = 1;
 338         return 1;
 339     }
 340     else if (strcasecmp(value, "No") == 0) {
 341         *result = 0;
 342         return 1;
 343     }
 344     return 0;
 345 }
 346
 347 #define IMPLEMENT_SSL_TEST_CTX_BOOL_OPTION(field)                       \
 348     static int parse_##field(SSL_TEST_CTX *test_ctx, const char *value) \
 349     {                                                                   \
 350         return parse_boolean(value, &test_ctx->field);                  \
 351     }
 352
 353 IMPLEMENT_SSL_TEST_CTX_BOOL_OPTION(resumption_expected)
 354
 355 /*************************************************************/
 356 /* Known test options and their corresponding parse methods. */
 357 /*************************************************************/
 358
 359 typedef struct {
 360     const char *name;
 361     int (*parse)(SSL_TEST_CTX *test_ctx, const char *value);
 362 } ssl_test_ctx_option;
 363
 364 static const ssl_test_ctx_option ssl_test_ctx_options[] = {
 365     { "ExpectedResult", &parse_expected_result },
 366     { "ClientAlert", &parse_client_alert },
 367     { "ServerAlert", &parse_server_alert },
 368     { "Protocol", &parse_protocol },
 369     { "ClientVerifyCallback", &parse_client_verify_callback },
 370     { "ServerName", &parse_servername },
 371     { "ExpectedServerName", &parse_expected_servername },
 372     { "ServerNameCallback", &parse_servername_callback },
 373     { "SessionTicketExpected", &parse_session_ticket },
 374     { "Method", &parse_test_method },
 375     { "ClientNPNProtocols", &parse_client_npn_protocols },
 376     { "ServerNPNProtocols", &parse_server_npn_protocols },
 377     { "Server2NPNProtocols", &parse_server2_npn_protocols },
 378     { "ExpectedNPNProtocol", &parse_expected_npn_protocol },
 379     { "ClientALPNProtocols", &parse_client_alpn_protocols },
 380     { "ServerALPNProtocols", &parse_server_alpn_protocols },
 381     { "Server2ALPNProtocols", &parse_server2_alpn_protocols },
 382     { "ExpectedALPNProtocol", &parse_expected_alpn_protocol },
 383     { "HandshakeMode", &parse_handshake_mode },
 384     { "ResumptionExpected", &parse_resumption_expected },
 385 };
 386
 387 /*
 388  * Since these methods are used to create tests, we use OPENSSL_assert liberally
 389  * for malloc failures and other internal errors.
 390  */
 391 SSL_TEST_CTX *SSL_TEST_CTX_new()
 392 {
 393     SSL_TEST_CTX *ret;
 394     ret = OPENSSL_zalloc(sizeof(*ret));
 395     OPENSSL_assert(ret != NULL);
 396     return ret;
 397 }
 398
 399 void SSL_TEST_CTX_free(SSL_TEST_CTX *ctx)
 400 {
 401
 402 #ifndef OPENSSL_NO_NEXTPROTONEG
 403     OPENSSL_free(ctx->client_npn_protocols);
 404     OPENSSL_free(ctx->server_npn_protocols);
 405     OPENSSL_free(ctx->server2_npn_protocols);
 406     OPENSSL_free(ctx->client_alpn_protocols);
 407     OPENSSL_free(ctx->server_alpn_protocols);
 408     OPENSSL_free(ctx->server2_alpn_protocols);
 409     OPENSSL_free(ctx->expected_npn_protocol);
 410     OPENSSL_free(ctx->expected_alpn_protocol);
 411 #endif
 412     OPENSSL_free(ctx);
 413 }
 414
 415 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
 416 {
 417     STACK_OF(CONF_VALUE) *sk_conf;
 418     SSL_TEST_CTX *ctx;
 419     int i;
 420     size_t j;
 421
 422     sk_conf = NCONF_get_section(conf, test_section);
 423     OPENSSL_assert(sk_conf != NULL);
 424
 425     ctx = SSL_TEST_CTX_new();
 426     OPENSSL_assert(ctx != NULL);
 427
 428     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
 429         int found = 0;
 430         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
 431         for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
 432             if (strcmp(option->name, ssl_test_ctx_options[j].name) == 0) {
 433                 if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
 434                     fprintf(stderr, "Bad value %s for option %s\n",
 435                             option->value, option->name);
 436                     goto err;
 437                 }
 438                 found = 1;
 439                 break;
 440             }
 441         }
 442         if (!found) {
 443             fprintf(stderr, "Unknown test option: %s\n", option->name);
 444             goto err;
 445         }
 446     }
 447
 448     goto done;
 449
 450  err:
 451     SSL_TEST_CTX_free(ctx);
 452     ctx = NULL;
 453  done:
 454     return ctx;
 455 }