Add all publicly avaiable asn1 types to the asn1 fuzzer.
[openssl.git] / 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 (strcmp(value, "Yes") == 0) {
337         *result = 1;
338         return 1;
339     }
340     else if (strcmp(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     OPENSSL_free(ctx->client_npn_protocols);
403     OPENSSL_free(ctx->server_npn_protocols);
404     OPENSSL_free(ctx->server2_npn_protocols);
405     OPENSSL_free(ctx->client_alpn_protocols);
406     OPENSSL_free(ctx->server_alpn_protocols);
407     OPENSSL_free(ctx->server2_alpn_protocols);
408     OPENSSL_free(ctx->expected_npn_protocol);
409     OPENSSL_free(ctx->expected_alpn_protocol);
410     OPENSSL_free(ctx);
411 }
412
413 SSL_TEST_CTX *SSL_TEST_CTX_create(const CONF *conf, const char *test_section)
414 {
415     STACK_OF(CONF_VALUE) *sk_conf;
416     SSL_TEST_CTX *ctx;
417     int i;
418     size_t j;
419
420     sk_conf = NCONF_get_section(conf, test_section);
421     OPENSSL_assert(sk_conf != NULL);
422
423     ctx = SSL_TEST_CTX_new();
424     OPENSSL_assert(ctx != NULL);
425
426     for (i = 0; i < sk_CONF_VALUE_num(sk_conf); i++) {
427         int found = 0;
428         const CONF_VALUE *option = sk_CONF_VALUE_value(sk_conf, i);
429         for (j = 0; j < OSSL_NELEM(ssl_test_ctx_options); j++) {
430             if (strcasecmp(option->name, ssl_test_ctx_options[j].name) == 0) {
431                 if (!ssl_test_ctx_options[j].parse(ctx, option->value)) {
432                     fprintf(stderr, "Bad value %s for option %s\n",
433                             option->value, option->name);
434                     goto err;
435                 }
436                 found = 1;
437                 break;
438             }
439         }
440         if (!found) {
441             fprintf(stderr, "Unknown test option: %s\n", option->name);
442             goto err;
443         }
444     }
445
446     goto done;
447
448  err:
449     SSL_TEST_CTX_free(ctx);
450     ctx = NULL;
451  done:
452     return ctx;
453 }