Fixed range of random produced in BN_is_prime_fasttest_ex() to be 1 < rand < w-1...
[openssl.git] / test / ssl_test_ctx.c
1 /*
2  * Copyright 2016-2018 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 "internal/nelem.h"
16 #include "ssl_test_ctx.h"
17 #include "testutil.h"
18
19 #ifdef OPENSSL_SYS_WINDOWS
20 # define strcasecmp _stricmp
21 #endif
22
23 static const int default_app_data_size = 256;
24 /* Default set to be as small as possible to exercise fragmentation. */
25 static const int default_max_fragment_size = 512;
26
27 static int parse_boolean(const char *value, int *result)
28 {
29     if (strcasecmp(value, "Yes") == 0) {
30         *result = 1;
31         return 1;
32     }
33     else if (strcasecmp(value, "No") == 0) {
34         *result = 0;
35         return 1;
36     }
37     TEST_error("parse_boolean given: '%s'", value);
38     return 0;
39 }
40
41 #define IMPLEMENT_SSL_TEST_BOOL_OPTION(struct_type, name, field)        \
42     static int parse_##name##_##field(struct_type *ctx, const char *value) \
43     {                                                                   \
44         return parse_boolean(value, &ctx->field);                       \
45     }
46
47 #define IMPLEMENT_SSL_TEST_STRING_OPTION(struct_type, name, field)      \
48     static int parse_##name##_##field(struct_type *ctx, const char *value) \
49     {                                                                   \
50         OPENSSL_free(ctx->field);                                       \
51         ctx->field = OPENSSL_strdup(value);                             \
52         return TEST_ptr(ctx->field);                                    \
53     }
54
55 #define IMPLEMENT_SSL_TEST_INT_OPTION(struct_type, name, field)        \
56     static int parse_##name##_##field(struct_type *ctx, const char *value) \
57     {                                                                   \
58         ctx->field = atoi(value);                                       \
59         return 1;                                                       \
60     }
61
62 /* True enums and other test configuration values that map to an int. */
63 typedef struct {
64     const char *name;
65     int value;
66 } test_enum;
67
68
69 __owur static int parse_enum(const test_enum *enums, size_t num_enums,
70                              int *value, const char *name)
71 {
72     size_t i;
73     for (i = 0; i < num_enums; i++) {
74         if (strcmp(enums[i].name, name) == 0) {
75             *value = enums[i].value;
76             return 1;
77         }
78     }
79     return 0;
80 }
81
82 static const char *enum_name(const test_enum *enums, size_t num_enums,
83                              int value)
84 {
85     size_t i;
86     for (i = 0; i < num_enums; i++) {
87         if (enums[i].value == value) {
88             return enums[i].name;
89         }
90     }
91     return "InvalidValue";
92 }
93
94
95 /* ExpectedResult */
96
97 static const test_enum ssl_test_results[] = {
98     {"Success", SSL_TEST_SUCCESS},
99     {"ServerFail", SSL_TEST_SERVER_FAIL},
100     {"ClientFail", SSL_TEST_CLIENT_FAIL},
101     {"InternalError", SSL_TEST_INTERNAL_ERROR},
102     {"FirstHandshakeFailed", SSL_TEST_FIRST_HANDSHAKE_FAILED},
103 };
104
105 __owur static int parse_expected_result(SSL_TEST_CTX *test_ctx, const char *value)
106 {
107     int ret_value;
108     if (!parse_enum(ssl_test_results, OSSL_NELEM(ssl_test_results),
109                     &ret_value, value)) {
110         return 0;
111     }
112     test_ctx->expected_result = ret_value;
113     return 1;
114 }
115
116 const char *ssl_test_result_name(ssl_test_result_t result)
117 {
118     return enum_name(ssl_test_results, OSSL_NELEM(ssl_test_results), result);
119 }
120
121 /* ExpectedClientAlert / ExpectedServerAlert */
122
123 static const test_enum ssl_alerts[] = {
124     {"UnknownCA", SSL_AD_UNKNOWN_CA},
125     {"HandshakeFailure", SSL_AD_HANDSHAKE_FAILURE},
126     {"UnrecognizedName", SSL_AD_UNRECOGNIZED_NAME},
127     {"BadCertificate", SSL_AD_BAD_CERTIFICATE},
128     {"NoApplicationProtocol", SSL_AD_NO_APPLICATION_PROTOCOL},
129 };
130
131 __owur static int parse_alert(int *alert, const char *value)
132 {
133     return parse_enum(ssl_alerts, OSSL_NELEM(ssl_alerts), alert, value);
134 }
135
136 __owur static int parse_client_alert(SSL_TEST_CTX *test_ctx, const char *value)
137 {
138     return parse_alert(&test_ctx->expected_client_alert, value);
139 }
140
141 __owur static int parse_server_alert(SSL_TEST_CTX *test_ctx, const char *value)
142 {
143     return parse_alert(&test_ctx->expected_server_alert, value);
144 }
145
146 const char *ssl_alert_name(int alert)
147 {
148     return enum_name(ssl_alerts, OSSL_NELEM(ssl_alerts), alert);
149 }
150
151 /* ExpectedProtocol */
152
153 static const test_enum ssl_protocols[] = {
154      {"TLSv1.3", TLS1_3_VERSION},
155      {"TLSv1.2", TLS1_2_VERSION},
156      {"TLSv1.1", TLS1_1_VERSION},
157      {"TLSv1", TLS1_VERSION},
158      {"SSLv3", SSL3_VERSION},
159      {"DTLSv1", DTLS1_VERSION},
160      {"DTLSv1.2", DTLS1_2_VERSION},
161 };
162
163 __owur static int parse_protocol(SSL_TEST_CTX *test_ctx, const char *value)
164 {
165     return parse_enum(ssl_protocols, OSSL_NELEM(ssl_protocols),
166                       &test_ctx->expected_protocol, value);
167 }
168
169 const char *ssl_protocol_name(int protocol)
170 {
171     return enum_name(ssl_protocols, OSSL_NELEM(ssl_protocols), protocol);
172 }
173
174 /* VerifyCallback */
175
176 static const test_enum ssl_verify_callbacks[] = {
177     {"None", SSL_TEST_VERIFY_NONE},
178     {"AcceptAll", SSL_TEST_VERIFY_ACCEPT_ALL},
179     {"RejectAll", SSL_TEST_VERIFY_REJECT_ALL},
180 };
181
182 __owur static int parse_client_verify_callback(SSL_TEST_CLIENT_CONF *client_conf,
183                                                const char *value)
184 {
185     int ret_value;
186     if (!parse_enum(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
187                     &ret_value, value)) {
188         return 0;
189     }
190     client_conf->verify_callback = ret_value;
191     return 1;
192 }
193
194 const char *ssl_verify_callback_name(ssl_verify_callback_t callback)
195 {
196     return enum_name(ssl_verify_callbacks, OSSL_NELEM(ssl_verify_callbacks),
197                      callback);
198 }
199
200 /* ServerName */
201
202 static const test_enum ssl_servername[] = {
203     {"None", SSL_TEST_SERVERNAME_NONE},
204     {"server1", SSL_TEST_SERVERNAME_SERVER1},
205     {"server2", SSL_TEST_SERVERNAME_SERVER2},
206     {"invalid", SSL_TEST_SERVERNAME_INVALID},
207 };
208
209 __owur static int parse_servername(SSL_TEST_CLIENT_CONF *client_conf,
210                                    const char *value)
211 {
212     int ret_value;
213     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
214                     &ret_value, value)) {
215         return 0;
216     }
217     client_conf->servername = ret_value;
218     return 1;
219 }
220
221 __owur static int parse_expected_servername(SSL_TEST_CTX *test_ctx,
222                                             const char *value)
223 {
224     int ret_value;
225     if (!parse_enum(ssl_servername, OSSL_NELEM(ssl_servername),
226                     &ret_value, value)) {
227         return 0;
228     }
229     test_ctx->expected_servername = ret_value;
230     return 1;
231 }
232
233 const char *ssl_servername_name(ssl_servername_t server)
234 {
235     return enum_name(ssl_servername, OSSL_NELEM(ssl_servername),
236                      server);
237 }
238
239 /* ServerNameCallback */
240
241 static const test_enum ssl_servername_callbacks[] = {
242     {"None", SSL_TEST_SERVERNAME_CB_NONE},
243     {"IgnoreMismatch", SSL_TEST_SERVERNAME_IGNORE_MISMATCH},
244     {"RejectMismatch", SSL_TEST_SERVERNAME_REJECT_MISMATCH},
245     {"ClientHelloIgnoreMismatch",
246      SSL_TEST_SERVERNAME_CLIENT_HELLO_IGNORE_MISMATCH},
247     {"ClientHelloRejectMismatch",
248      SSL_TEST_SERVERNAME_CLIENT_HELLO_REJECT_MISMATCH},
249     {"ClientHelloNoV12", SSL_TEST_SERVERNAME_CLIENT_HELLO_NO_V12},
250 };
251
252 __owur static int parse_servername_callback(SSL_TEST_SERVER_CONF *server_conf,
253                                             const char *value)
254 {
255     int ret_value;
256     if (!parse_enum(ssl_servername_callbacks,
257                     OSSL_NELEM(ssl_servername_callbacks), &ret_value, value)) {
258         return 0;
259     }
260     server_conf->servername_callback = ret_value;
261     return 1;
262 }
263
264 const char *ssl_servername_callback_name(ssl_servername_callback_t callback)
265 {
266     return enum_name(ssl_servername_callbacks,
267                      OSSL_NELEM(ssl_servername_callbacks), callback);
268 }
269
270 /* SessionTicketExpected */
271
272 static const test_enum ssl_session_ticket[] = {
273     {"Ignore", SSL_TEST_SESSION_TICKET_IGNORE},
274     {"Yes", SSL_TEST_SESSION_TICKET_YES},
275     {"No", SSL_TEST_SESSION_TICKET_NO},
276 };
277
278 __owur static int parse_session_ticket(SSL_TEST_CTX *test_ctx, const char *value)
279 {
280     int ret_value;
281     if (!parse_enum(ssl_session_ticket, OSSL_NELEM(ssl_session_ticket),
282                     &ret_value, value)) {
283         return 0;
284     }
285     test_ctx->session_ticket_expected = ret_value;
286     return 1;
287 }
288
289 const char *ssl_session_ticket_name(ssl_session_ticket_t server)
290 {
291     return enum_name(ssl_session_ticket,
292                      OSSL_NELEM(ssl_session_ticket),
293                      server);
294 }
295
296 /* CompressionExpected */
297
298 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_CTX, test, compression_expected)
299
300 /* SessionIdExpected */
301
302 static const test_enum ssl_session_id[] = {
303     {"Ignore", SSL_TEST_SESSION_ID_IGNORE},
304     {"Yes", SSL_TEST_SESSION_ID_YES},
305     {"No", SSL_TEST_SESSION_ID_NO},
306 };
307
308 __owur static int parse_session_id(SSL_TEST_CTX *test_ctx, const char *value)
309 {
310     int ret_value;
311     if (!parse_enum(ssl_session_id, OSSL_NELEM(ssl_session_id),
312                     &ret_value, value)) {
313         return 0;
314     }
315     test_ctx->session_id_expected = ret_value;
316     return 1;
317 }
318
319 const char *ssl_session_id_name(ssl_session_id_t server)
320 {
321     return enum_name(ssl_session_id,
322                      OSSL_NELEM(ssl_session_id),
323                      server);
324 }
325
326 /* Method */
327
328 static const test_enum ssl_test_methods[] = {
329     {"TLS", SSL_TEST_METHOD_TLS},
330     {"DTLS", SSL_TEST_METHOD_DTLS},
331 };
332
333 __owur static int parse_test_method(SSL_TEST_CTX *test_ctx, const char *value)
334 {
335     int ret_value;
336     if (!parse_enum(ssl_test_methods, OSSL_NELEM(ssl_test_methods),
337                     &ret_value, value)) {
338         return 0;
339     }
340     test_ctx->method = ret_value;
341     return 1;
342 }
343
344 const char *ssl_test_method_name(ssl_test_method_t method)
345 {
346     return enum_name(ssl_test_methods, OSSL_NELEM(ssl_test_methods), method);
347 }
348
349 /* NPN and ALPN options */
350
351 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, npn_protocols)
352 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, npn_protocols)
353 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CTX, test, expected_npn_protocol)
354 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, alpn_protocols)
355 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, alpn_protocols)
356 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CTX, test, expected_alpn_protocol)
357
358 /* SRP options */
359 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, srp_user)
360 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, srp_user)
361 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, srp_password)
362 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, srp_password)
363
364 /* Session Ticket App Data options */
365 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CTX, test, expected_session_ticket_app_data)
366 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_SERVER_CONF, server, session_ticket_app_data)
367
368 /* Handshake mode */
369
370 static const test_enum ssl_handshake_modes[] = {
371     {"Simple", SSL_TEST_HANDSHAKE_SIMPLE},
372     {"Resume", SSL_TEST_HANDSHAKE_RESUME},
373     {"RenegotiateServer", SSL_TEST_HANDSHAKE_RENEG_SERVER},
374     {"RenegotiateClient", SSL_TEST_HANDSHAKE_RENEG_CLIENT},
375     {"KeyUpdateServer", SSL_TEST_HANDSHAKE_KEY_UPDATE_SERVER},
376     {"KeyUpdateClient", SSL_TEST_HANDSHAKE_KEY_UPDATE_CLIENT},
377     {"PostHandshakeAuth", SSL_TEST_HANDSHAKE_POST_HANDSHAKE_AUTH},
378 };
379
380 __owur static int parse_handshake_mode(SSL_TEST_CTX *test_ctx, const char *value)
381 {
382     int ret_value;
383     if (!parse_enum(ssl_handshake_modes, OSSL_NELEM(ssl_handshake_modes),
384                     &ret_value, value)) {
385         return 0;
386     }
387     test_ctx->handshake_mode = ret_value;
388     return 1;
389 }
390
391 const char *ssl_handshake_mode_name(ssl_handshake_mode_t mode)
392 {
393     return enum_name(ssl_handshake_modes, OSSL_NELEM(ssl_handshake_modes),
394                      mode);
395 }
396
397 /* Renegotiation Ciphersuites */
398
399 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CLIENT_CONF, client, reneg_ciphers)
400
401 /* KeyUpdateType */
402
403 static const test_enum ssl_key_update_types[] = {
404     {"KeyUpdateRequested", SSL_KEY_UPDATE_REQUESTED},
405     {"KeyUpdateNotRequested", SSL_KEY_UPDATE_NOT_REQUESTED},
406 };
407
408 __owur static int parse_key_update_type(SSL_TEST_CTX *test_ctx, const char *value)
409 {
410     int ret_value;
411     if (!parse_enum(ssl_key_update_types, OSSL_NELEM(ssl_key_update_types),
412                     &ret_value, value)) {
413         return 0;
414     }
415     test_ctx->key_update_type = ret_value;
416     return 1;
417 }
418
419 /* CT Validation */
420
421 static const test_enum ssl_ct_validation_modes[] = {
422     {"None", SSL_TEST_CT_VALIDATION_NONE},
423     {"Permissive", SSL_TEST_CT_VALIDATION_PERMISSIVE},
424     {"Strict", SSL_TEST_CT_VALIDATION_STRICT},
425 };
426
427 __owur static int parse_ct_validation(SSL_TEST_CLIENT_CONF *client_conf,
428                                       const char *value)
429 {
430     int ret_value;
431     if (!parse_enum(ssl_ct_validation_modes, OSSL_NELEM(ssl_ct_validation_modes),
432                     &ret_value, value)) {
433         return 0;
434     }
435     client_conf->ct_validation = ret_value;
436     return 1;
437 }
438
439 const char *ssl_ct_validation_name(ssl_ct_validation_t mode)
440 {
441     return enum_name(ssl_ct_validation_modes, OSSL_NELEM(ssl_ct_validation_modes),
442                      mode);
443 }
444
445 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_CTX, test, resumption_expected)
446 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_SERVER_CONF, server, broken_session_ticket)
447 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_CTX, test, use_sctp)
448
449 /* CertStatus */
450
451 static const test_enum ssl_certstatus[] = {
452     {"None", SSL_TEST_CERT_STATUS_NONE},
453     {"GoodResponse", SSL_TEST_CERT_STATUS_GOOD_RESPONSE},
454     {"BadResponse", SSL_TEST_CERT_STATUS_BAD_RESPONSE}
455 };
456
457 __owur static int parse_certstatus(SSL_TEST_SERVER_CONF *server_conf,
458                                             const char *value)
459 {
460     int ret_value;
461     if (!parse_enum(ssl_certstatus, OSSL_NELEM(ssl_certstatus), &ret_value,
462                     value)) {
463         return 0;
464     }
465     server_conf->cert_status = ret_value;
466     return 1;
467 }
468
469 const char *ssl_certstatus_name(ssl_cert_status_t cert_status)
470 {
471     return enum_name(ssl_certstatus,
472                      OSSL_NELEM(ssl_certstatus), cert_status);
473 }
474
475 /* ApplicationData */
476
477 IMPLEMENT_SSL_TEST_INT_OPTION(SSL_TEST_CTX, test, app_data_size)
478
479
480 /* MaxFragmentSize */
481
482 IMPLEMENT_SSL_TEST_INT_OPTION(SSL_TEST_CTX, test, max_fragment_size)
483
484 /* Maximum-Fragment-Length TLS extension mode */
485 static const test_enum ssl_max_fragment_len_mode[] = {
486     {"None", TLSEXT_max_fragment_length_DISABLED},
487     { "512", TLSEXT_max_fragment_length_512},
488     {"1024", TLSEXT_max_fragment_length_1024},
489     {"2048", TLSEXT_max_fragment_length_2048},
490     {"4096", TLSEXT_max_fragment_length_4096}
491 };
492
493 __owur static int parse_max_fragment_len_mode(SSL_TEST_CLIENT_CONF *client_conf,
494                                               const char *value)
495 {
496     int ret_value;
497
498     if (!parse_enum(ssl_max_fragment_len_mode,
499                     OSSL_NELEM(ssl_max_fragment_len_mode), &ret_value, value)) {
500         return 0;
501     }
502     client_conf->max_fragment_len_mode = ret_value;
503     return 1;
504 }
505
506 const char *ssl_max_fragment_len_name(int MFL_mode)
507 {
508     return enum_name(ssl_max_fragment_len_mode,
509                      OSSL_NELEM(ssl_max_fragment_len_mode), MFL_mode);
510 }
511
512
513 /* Expected key and signature types */
514
515 __owur static int parse_expected_key_type(int *ptype, const char *value)
516 {
517     int nid;
518     const EVP_PKEY_ASN1_METHOD *ameth;
519
520     if (value == NULL)
521         return 0;
522     ameth = EVP_PKEY_asn1_find_str(NULL, value, -1);
523     if (ameth != NULL)
524         EVP_PKEY_asn1_get0_info(&nid, NULL, NULL, NULL, NULL, ameth);
525     else
526         nid = OBJ_sn2nid(value);
527     if (nid == NID_undef)
528         nid = OBJ_ln2nid(value);
529 #ifndef OPENSSL_NO_EC
530     if (nid == NID_undef)
531         nid = EC_curve_nist2nid(value);
532 #endif
533     if (nid == NID_undef)
534         return 0;
535     *ptype = nid;
536     return 1;
537 }
538
539 __owur static int parse_expected_tmp_key_type(SSL_TEST_CTX *test_ctx,
540                                               const char *value)
541 {
542     return parse_expected_key_type(&test_ctx->expected_tmp_key_type, value);
543 }
544
545 __owur static int parse_expected_server_cert_type(SSL_TEST_CTX *test_ctx,
546                                                   const char *value)
547 {
548     return parse_expected_key_type(&test_ctx->expected_server_cert_type,
549                                    value);
550 }
551
552 __owur static int parse_expected_server_sign_type(SSL_TEST_CTX *test_ctx,
553                                                  const char *value)
554 {
555     return parse_expected_key_type(&test_ctx->expected_server_sign_type,
556                                    value);
557 }
558
559 __owur static int parse_expected_client_cert_type(SSL_TEST_CTX *test_ctx,
560                                                   const char *value)
561 {
562     return parse_expected_key_type(&test_ctx->expected_client_cert_type,
563                                    value);
564 }
565
566 __owur static int parse_expected_client_sign_type(SSL_TEST_CTX *test_ctx,
567                                                  const char *value)
568 {
569     return parse_expected_key_type(&test_ctx->expected_client_sign_type,
570                                    value);
571 }
572
573
574 /* Expected signing hash */
575
576 __owur static int parse_expected_sign_hash(int *ptype, const char *value)
577 {
578     int nid;
579
580     if (value == NULL)
581         return 0;
582     nid = OBJ_sn2nid(value);
583     if (nid == NID_undef)
584         nid = OBJ_ln2nid(value);
585     if (nid == NID_undef)
586         return 0;
587     *ptype = nid;
588     return 1;
589 }
590
591 __owur static int parse_expected_server_sign_hash(SSL_TEST_CTX *test_ctx,
592                                                   const char *value)
593 {
594     return parse_expected_sign_hash(&test_ctx->expected_server_sign_hash,
595                                     value);
596 }
597
598 __owur static int parse_expected_client_sign_hash(SSL_TEST_CTX *test_ctx,
599                                                   const char *value)
600 {
601     return parse_expected_sign_hash(&test_ctx->expected_client_sign_hash,
602                                     value);
603 }
604
605 __owur static int parse_expected_ca_names(STACK_OF(X509_NAME) **pnames,
606                                           const char *value)
607 {
608     if (value == NULL)
609         return 0;
610     if (!strcmp(value, "empty"))
611         *pnames = sk_X509_NAME_new_null();
612     else
613         *pnames = SSL_load_client_CA_file(value);
614     return *pnames != NULL;
615 }
616 __owur static int parse_expected_server_ca_names(SSL_TEST_CTX *test_ctx,
617                                                  const char *value)
618 {
619     return parse_expected_ca_names(&test_ctx->expected_server_ca_names, value);
620 }
621 __owur static int parse_expected_client_ca_names(SSL_TEST_CTX *test_ctx,
622                                                  const char *value)
623 {
624     return parse_expected_ca_names(&test_ctx->expected_client_ca_names, value);
625 }
626
627 /* ExpectedCipher */
628
629 IMPLEMENT_SSL_TEST_STRING_OPTION(SSL_TEST_CTX, test, expected_cipher)
630
631 /* Client and Server ForcePHA */
632
633 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_CLIENT_CONF, client, force_pha)
634 IMPLEMENT_SSL_TEST_BOOL_OPTION(SSL_TEST_SERVER_CONF, server, force_pha)
635
636 /* Known test options and their corresponding parse methods. */
637
638 /* Top-level options. */
639 typedef struct {
640     const char *name;
641     int (*parse)(SSL_TEST_CTX *test_ctx, const char *value);
642 } ssl_test_ctx_option;
643
644 static const ssl_test_ctx_option ssl_test_ctx_options[] = {
645     { "ExpectedResult", &parse_expected_result },
646     { "ExpectedClientAlert", &parse_client_alert },
647     { "ExpectedServerAlert", &parse_server_alert },
648     { "ExpectedProtocol", &parse_protocol },
649     { "ExpectedServerName", &parse_expected_servername },
650     { "SessionTicketExpected", &parse_session_ticket },
651     { "CompressionExpected", &parse_test_compression_expected },
652     { "SessionIdExpected", &parse_session_id },
653     { "Method", &parse_test_method },
654     { "ExpectedNPNProtocol", &parse_test_expected_npn_protocol },
655     { "ExpectedALPNProtocol", &parse_test_expected_alpn_protocol },
656     { "HandshakeMode", &parse_handshake_mode },
657     { "KeyUpdateType", &parse_key_update_type },
658     { "ResumptionExpected", &parse_test_resumption_expected },
659     { "ApplicationData", &parse_test_app_data_size },
660     { "MaxFragmentSize", &parse_test_max_fragment_size },
661     { "ExpectedTmpKeyType", &parse_expected_tmp_key_type },
662     { "ExpectedServerCertType", &parse_expected_server_cert_type },
663     { "ExpectedServerSignHash", &parse_expected_server_sign_hash },
664     { "ExpectedServerSignType", &parse_expected_server_sign_type },
665     { "ExpectedServerCANames", &parse_expected_server_ca_names },
666     { "ExpectedClientCertType", &parse_expected_client_cert_type },
667     { "ExpectedClientSignHash", &parse_expected_client_sign_hash },
668     { "ExpectedClientSignType", &parse_expected_client_sign_type },
669     { "ExpectedClientCANames", &parse_expected_client_ca_names },
670     { "UseSCTP", &parse_test_use_sctp },
671     { "ExpectedCipher", &parse_test_expected_cipher },
672     { "ExpectedSessionTicketAppData", &parse_test_expected_session_ticket_app_data },
673 };
674
675 /* Nested client options. */
676 typedef struct {
677     const char *name;
678     int (*parse)(SSL_TEST_CLIENT_CONF *conf, const char *value);
679 } ssl_test_client_option;
680
681 static const ssl_test_client_option ssl_test_client_options[] = {
682     { "VerifyCallback", &parse_client_verify_callback },
683     { "ServerName", &parse_servername },
684     { "NPNProtocols", &parse_client_npn_protocols },
685     { "ALPNProtocols", &parse_client_alpn_protocols },
686     { "CTValidation", &parse_ct_validation },
687     { "RenegotiateCiphers", &parse_client_reneg_ciphers},
688     { "SRPUser", &parse_client_srp_user },
689     { "SRPPassword", &parse_client_srp_password },
690     { "MaxFragmentLenExt", &parse_max_fragment_len_mode },
691     { "ForcePHA", &parse_client_force_pha },
692 };
693
694 /* Nested server options. */
695 typedef struct {
696     const char *name;
697     int (*parse)(SSL_TEST_SERVER_CONF *conf, const char *value);
698 } ssl_test_server_option;
699
700 static const ssl_test_server_option ssl_test_server_options[] = {
701     { "ServerNameCallback", &parse_servername_callback },
702     { "NPNProtocols", &parse_server_npn_protocols },
703     { "ALPNProtocols", &parse_server_alpn_protocols },
704     { "BrokenSessionTicket", &parse_server_broken_session_ticket },
705     { "CertStatus", &parse_certstatus },
706     { "SRPUser", &parse_server_srp_user },
707     { "SRPPassword", &parse_server_srp_password },
708     { "ForcePHA", &parse_server_force_pha },
709     { "SessionTicketAppData", &parse_server_session_ticket_app_data },
710 };
711
712 SSL_TEST_CTX *SSL_TEST_CTX_new(void)
713 {
714     SSL_TEST_CTX *ret;
715
716     /* The return code is checked by caller */
717     if ((ret = OPENSSL_zalloc(sizeof(*ret))) != NULL) {
718         ret->app_data_size = default_app_data_size;
719         ret->max_fragment_size = default_max_fragment_size;
720     }
721     return ret;
722 }
723
724 static void ssl_test_extra_conf_free_data(SSL_TEST_EXTRA_CONF *conf)
725 {
726     OPENSSL_free(conf->client.npn_protocols);
727     OPENSSL_free(conf->server.npn_protocols);
728     OPENSSL_free(conf->server2.npn_protocols);
729     OPENSSL_free(conf->client.alpn_protocols);
730     OPENSSL_free(conf->server.alpn_protocols);
731     OPENSSL_free(conf->server2.alpn_protocols);
732     OPENSSL_free(conf->client.reneg_ciphers);
733     OPENSSL_free(conf->server.srp_user);
734     OPENSSL_free(conf->server.srp_password);
735     OPENSSL_free(conf->server2.srp_user);
736     OPENSSL_free(conf->server2.srp_password);
737     OPENSSL_free(conf->client.srp_user);
738     OPENSSL_free(conf->client.srp_password);
739     OPENSSL_free(conf->server.session_ticket_app_data);
740     OPENSSL_free(conf->server2.session_ticket_app_data);
741 }
742
743 static void ssl_test_ctx_free_extra_data(SSL_TEST_CTX *ctx)
744 {
745     ssl_test_extra_conf_free_data(&ctx->extra);
746     ssl_test_extra_conf_free_data(&ctx->resume_extra);
747 }
748
749 void SSL_TEST_CTX_free(SSL_TEST_CTX *ctx)
750 {
751     ssl_test_ctx_free_extra_data(ctx);
752     OPENSSL_free(ctx->expected_npn_protocol);
753     OPENSSL_free(ctx->expected_alpn_protocol);
754     OPENSSL_free(ctx->expected_session_ticket_app_data);
755     sk_X509_NAME_pop_free(ctx->expected_server_ca_names, X509_NAME_free);
756     sk_X509_NAME_pop_free(ctx->expected_client_ca_names, X509_NAME_free);
757     OPENSSL_free(ctx->expected_cipher);
758     OPENSSL_free(ctx);
759 }
760
761 static int parse_client_options(SSL_TEST_CLIENT_CONF *client, const CONF *conf,
762                                 const char *client_section)
763 {
764     STACK_OF(CONF_VALUE) *sk_conf;
765     int i;
766     size_t j;
767
768     if (!TEST_ptr(sk_conf = NCONF_get_section(conf, client_section)))
769         return 0;
770
771     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
772         int found = 0;
773         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
774         for (j = 0; j < OSSL_NELEM(ssl_test_client_options); j++) {
775             if (strcmp(option->name, ssl_test_client_options[j].name) == 0) {
776                 if (!ssl_test_client_options[j].parse(client, option->value)) {
777                     TEST_info("Bad value %s for option %s",
778                               option->value, option->name);
779                     return 0;
780                 }
781                 found = 1;
782                 break;
783             }
784         }
785         if (!found) {
786             TEST_info("Unknown test option: %s", option->name);
787             return 0;
788         }
789     }
790
791     return 1;
792 }
793
794 static int parse_server_options(SSL_TEST_SERVER_CONF *server, const CONF *conf,
795                                 const char *server_section)
796 {
797     STACK_OF(CONF_VALUE) *sk_conf;
798     int i;
799     size_t j;
800
801     if (!TEST_ptr(sk_conf = NCONF_get_section(conf, server_section)))
802         return 0;
803
804     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
805         int found = 0;
806         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
807         for (j = 0; j < OSSL_NELEM(ssl_test_server_options); j++) {
808             if (strcmp(option->name, ssl_test_server_options[j].name) == 0) {
809                 if (!ssl_test_server_options[j].parse(server, option->value)) {
810                     TEST_info("Bad value %s for option %s",
811                                option->value, option->name);
812                     return 0;
813                 }
814                 found = 1;
815                 break;
816             }
817         }
818         if (!found) {
819             TEST_info("Unknown test option: %s", option->name);
820             return 0;
821         }
822     }
823
824     return 1;
825 }
826
827 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
828 {
829     STACK_OF(CONF_VALUE) *sk_conf = NULL;
830     SSL_TEST_CTX *ctx = NULL;
831     int i;
832     size_t j;
833
834     if (!TEST_ptr(sk_conf = NCONF_get_section(conf, test_section))
835             || !TEST_ptr(ctx = SSL_TEST_CTX_new()))
836         goto err;
837
838     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
839         int found = 0;
840         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
841
842         /* Subsections */
843         if (strcmp(option->name, "client") == 0) {
844             if (!parse_client_options(&ctx->extra.client, conf, option->value))
845                 goto err;
846         } else if (strcmp(option->name, "server") == 0) {
847             if (!parse_server_options(&ctx->extra.server, conf, option->value))
848                 goto err;
849         } else if (strcmp(option->name, "server2") == 0) {
850             if (!parse_server_options(&ctx->extra.server2, conf, option->value))
851                 goto err;
852         } else if (strcmp(option->name, "resume-client") == 0) {
853             if (!parse_client_options(&ctx->resume_extra.client, conf,
854                                       option->value))
855                 goto err;
856         } else if (strcmp(option->name, "resume-server") == 0) {
857             if (!parse_server_options(&ctx->resume_extra.server, conf,
858                                       option->value))
859                 goto err;
860         } else if (strcmp(option->name, "resume-server2") == 0) {
861             if (!parse_server_options(&ctx->resume_extra.server2, conf,
862                                       option->value))
863                 goto err;
864         } else {
865             for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
866                 if (strcmp(option->name, ssl_test_ctx_options[j].name) == 0) {
867                     if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
868                         TEST_info("Bad value %s for option %s",
869                                    option->value, option->name);
870                         goto err;
871                     }
872                     found = 1;
873                     break;
874                 }
875             }
876             if (!found) {
877                 TEST_info("Unknown test option: %s", option->name);
878                 goto err;
879             }
880         }
881     }
882
883     goto done;
884
885  err:
886     SSL_TEST_CTX_free(ctx);
887     ctx = NULL;
888  done:
889     return ctx;
890 }