Allow disabling the min and max version
[openssl.git] / ssl / ssl_conf.c
1 /*
2  * ! \file ssl/ssl_conf.c \brief SSL configuration functions
3  */
4 /* ====================================================================
5  * Copyright (c) 2012 The OpenSSL Project.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. All advertising materials mentioning features or use of this
20  *    software must display the following acknowledgment:
21  *    "This product includes software developed by the OpenSSL Project
22  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
23  *
24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25  *    endorse or promote products derived from this software without
26  *    prior written permission. For written permission, please contact
27  *    openssl-core@openssl.org.
28  *
29  * 5. Products derived from this software may not be called "OpenSSL"
30  *    nor may "OpenSSL" appear in their names without prior written
31  *    permission of the OpenSSL Project.
32  *
33  * 6. Redistributions of any form whatsoever must retain the following
34  *    acknowledgment:
35  *    "This product includes software developed by the OpenSSL Project
36  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
37  *
38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49  * OF THE POSSIBILITY OF SUCH DAMAGE.
50  * ====================================================================
51  *
52  * This product includes cryptographic software written by Eric Young
53  * (eay@cryptsoft.com).  This product includes software written by Tim
54  * Hudson (tjh@cryptsoft.com).
55  *
56  */
57
58 #ifdef REF_CHECK
59 # include <assert.h>
60 #endif
61 #include <stdio.h>
62 #include "ssl_locl.h"
63 #include <openssl/conf.h>
64 #include <openssl/objects.h>
65 #ifndef OPENSSL_NO_DH
66 # include <openssl/dh.h>
67 #endif
68
69 /*
70  * structure holding name tables. This is used for pemitted elements in lists
71  * such as TLSv1.
72  */
73
74 typedef struct {
75     const char *name;
76     int namelen;
77     unsigned int name_flags;
78     unsigned long option_value;
79 } ssl_flag_tbl;
80
81 /* Switch table: use for single command line switches like no_tls2 */
82 typedef struct {
83     unsigned long option_value;
84     unsigned int name_flags;
85 } ssl_switch_tbl;
86
87 /* Sense of name is inverted e.g. "TLSv1" will clear SSL_OP_NO_TLSv1 */
88 #define SSL_TFLAG_INV   0x1
89 /* Mask for type of flag referred to */
90 #define SSL_TFLAG_TYPE_MASK 0xf00
91 /* Flag is for options */
92 #define SSL_TFLAG_OPTION    0x000
93 /* Flag is for cert_flags */
94 #define SSL_TFLAG_CERT      0x100
95 /* Flag is for verify mode */
96 #define SSL_TFLAG_VFY       0x200
97 /* Option can only be used for clients */
98 #define SSL_TFLAG_CLIENT SSL_CONF_FLAG_CLIENT
99 /* Option can only be used for servers */
100 #define SSL_TFLAG_SERVER SSL_CONF_FLAG_SERVER
101 #define SSL_TFLAG_BOTH (SSL_TFLAG_CLIENT|SSL_TFLAG_SERVER)
102
103 #define SSL_FLAG_TBL(str, flag) \
104         {str, (int)(sizeof(str) - 1), SSL_TFLAG_BOTH, flag}
105 #define SSL_FLAG_TBL_SRV(str, flag) \
106         {str, (int)(sizeof(str) - 1), SSL_TFLAG_SERVER, flag}
107 #define SSL_FLAG_TBL_CLI(str, flag) \
108         {str, (int)(sizeof(str) - 1), SSL_TFLAG_CLIENT, flag}
109 #define SSL_FLAG_TBL_INV(str, flag) \
110         {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_BOTH, flag}
111 #define SSL_FLAG_TBL_SRV_INV(str, flag) \
112         {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_SERVER, flag}
113 #define SSL_FLAG_TBL_CERT(str, flag) \
114         {str, (int)(sizeof(str) - 1), SSL_TFLAG_CERT|SSL_TFLAG_BOTH, flag}
115
116 #define SSL_FLAG_VFY_CLI(str, flag) \
117         {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_CLIENT, flag}
118 #define SSL_FLAG_VFY_SRV(str, flag) \
119         {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_SERVER, flag}
120
121 /*
122  * Opaque structure containing SSL configuration context.
123  */
124
125 struct ssl_conf_ctx_st {
126     /*
127      * Various flags indicating (among other things) which options we will
128      * recognise.
129      */
130     unsigned int flags;
131     /* Prefix and length of commands */
132     char *prefix;
133     size_t prefixlen;
134     /* SSL_CTX or SSL structure to perform operations on */
135     SSL_CTX *ctx;
136     SSL *ssl;
137     /* Pointer to SSL or SSL_CTX options field or NULL if none */
138     uint32_t *poptions;
139     /* Certificate filenames for each type */
140     char *cert_filename[SSL_PKEY_NUM];
141     /* Pointer to SSL or SSL_CTX cert_flags or NULL if none */
142     uint32_t *pcert_flags;
143     /* Pointer to SSL or SSL_CTX verify_mode or NULL if none */
144     uint32_t *pvfy_flags;
145     /* Pointer to SSL or SSL_CTX min_version field or NULL if none */
146     int *min_version;
147     /* Pointer to SSL or SSL_CTX max_version field or NULL if none */
148     int *max_version;
149     /* Current flag table being worked on */
150     const ssl_flag_tbl *tbl;
151     /* Size of table */
152     size_t ntbl;
153     /* Client CA names */
154     STACK_OF(X509_NAME) *canames;
155 };
156
157 static void ssl_set_option(SSL_CONF_CTX *cctx, unsigned int name_flags,
158                            unsigned long option_value, int onoff)
159 {
160     uint32_t *pflags;
161     if (cctx->poptions == NULL)
162         return;
163     if (name_flags & SSL_TFLAG_INV)
164         onoff ^= 1;
165     switch (name_flags & SSL_TFLAG_TYPE_MASK) {
166
167     case SSL_TFLAG_CERT:
168         pflags = cctx->pcert_flags;
169         break;
170
171     case SSL_TFLAG_VFY:
172         pflags =  cctx->pvfy_flags;
173         break;
174
175     case SSL_TFLAG_OPTION:
176         pflags = cctx->poptions;
177         break;
178
179     default:
180         return;
181
182     }
183     if (onoff)
184         *pflags |= option_value;
185     else
186         *pflags &= ~option_value;
187 }
188
189 static int ssl_match_option(SSL_CONF_CTX *cctx, const ssl_flag_tbl *tbl,
190                             const char *name, int namelen, int onoff)
191 {
192     /* If name not relevant for context skip */
193     if (!(cctx->flags & tbl->name_flags & SSL_TFLAG_BOTH))
194         return 0;
195     if (namelen == -1) {
196         if (strcmp(tbl->name, name))
197             return 0;
198     } else if (tbl->namelen != namelen
199                || strncasecmp(tbl->name, name, namelen))
200         return 0;
201     ssl_set_option(cctx, tbl->name_flags, tbl->option_value, onoff);
202     return 1;
203 }
204
205 static int ssl_set_option_list(const char *elem, int len, void *usr)
206 {
207     SSL_CONF_CTX *cctx = usr;
208     size_t i;
209     const ssl_flag_tbl *tbl;
210     int onoff = 1;
211     /*
212      * len == -1 indicates not being called in list context, just for single
213      * command line switches, so don't allow +, -.
214      */
215     if (elem == NULL)
216         return 0;
217     if (len != -1) {
218         if (*elem == '+') {
219             elem++;
220             len--;
221             onoff = 1;
222         } else if (*elem == '-') {
223             elem++;
224             len--;
225             onoff = 0;
226         }
227     }
228     for (i = 0, tbl = cctx->tbl; i < cctx->ntbl; i++, tbl++) {
229         if (ssl_match_option(cctx, tbl, elem, len, onoff))
230             return 1;
231     }
232     return 0;
233 }
234
235 /* Set supported signature algorithms */
236 static int cmd_SignatureAlgorithms(SSL_CONF_CTX *cctx, const char *value)
237 {
238     int rv;
239     if (cctx->ssl)
240         rv = SSL_set1_sigalgs_list(cctx->ssl, value);
241     /* NB: ctx == NULL performs syntax checking only */
242     else
243         rv = SSL_CTX_set1_sigalgs_list(cctx->ctx, value);
244     return rv > 0;
245 }
246
247 /* Set supported client signature algorithms */
248 static int cmd_ClientSignatureAlgorithms(SSL_CONF_CTX *cctx,
249                                          const char *value)
250 {
251     int rv;
252     if (cctx->ssl)
253         rv = SSL_set1_client_sigalgs_list(cctx->ssl, value);
254     /* NB: ctx == NULL performs syntax checking only */
255     else
256         rv = SSL_CTX_set1_client_sigalgs_list(cctx->ctx, value);
257     return rv > 0;
258 }
259
260 static int cmd_Curves(SSL_CONF_CTX *cctx, const char *value)
261 {
262     int rv;
263     if (cctx->ssl)
264         rv = SSL_set1_curves_list(cctx->ssl, value);
265     /* NB: ctx == NULL performs syntax checking only */
266     else
267         rv = SSL_CTX_set1_curves_list(cctx->ctx, value);
268     return rv > 0;
269 }
270
271 #ifndef OPENSSL_NO_EC
272 /* ECDH temporary parameters */
273 static int cmd_ECDHParameters(SSL_CONF_CTX *cctx, const char *value)
274 {
275     int rv = 1;
276     EC_KEY *ecdh;
277     int nid;
278
279     nid = EC_curve_nist2nid(value);
280     if (nid == NID_undef)
281         nid = OBJ_sn2nid(value);
282     if (nid == 0)
283         return 0;
284     ecdh = EC_KEY_new_by_curve_name(nid);
285     if (!ecdh)
286         return 0;
287     if (cctx->ctx)
288         rv = SSL_CTX_set_tmp_ecdh(cctx->ctx, ecdh);
289     else if (cctx->ssl)
290         rv = SSL_set_tmp_ecdh(cctx->ssl, ecdh);
291     EC_KEY_free(ecdh);
292
293     return rv > 0;
294 }
295 #endif
296 static int cmd_CipherString(SSL_CONF_CTX *cctx, const char *value)
297 {
298     int rv = 1;
299     if (cctx->ctx)
300         rv = SSL_CTX_set_cipher_list(cctx->ctx, value);
301     if (cctx->ssl)
302         rv = SSL_set_cipher_list(cctx->ssl, value);
303     return rv > 0;
304 }
305
306 static int cmd_Protocol(SSL_CONF_CTX *cctx, const char *value)
307 {
308     static const ssl_flag_tbl ssl_protocol_list[] = {
309         SSL_FLAG_TBL_INV("ALL", SSL_OP_NO_SSL_MASK),
310         SSL_FLAG_TBL_INV("SSLv2", SSL_OP_NO_SSLv2),
311         SSL_FLAG_TBL_INV("SSLv3", SSL_OP_NO_SSLv3),
312         SSL_FLAG_TBL_INV("TLSv1", SSL_OP_NO_TLSv1),
313         SSL_FLAG_TBL_INV("TLSv1.1", SSL_OP_NO_TLSv1_1),
314         SSL_FLAG_TBL_INV("TLSv1.2", SSL_OP_NO_TLSv1_2),
315         SSL_FLAG_TBL_INV("DTLSv1", SSL_OP_NO_DTLSv1),
316         SSL_FLAG_TBL_INV("DTLSv1.2", SSL_OP_NO_DTLSv1_2)
317     };
318     cctx->tbl = ssl_protocol_list;
319     cctx->ntbl = OSSL_NELEM(ssl_protocol_list);
320     return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx);
321 }
322
323 /*
324  * protocol_from_string - converts a protocol version string to a number
325  *
326  * Returns -1 on failure or the version on success
327  */
328 static int protocol_from_string(const char *value)
329 {
330     struct protocol_versions {
331         const char *name;
332         int version;
333     };
334     static const struct protocol_versions versions[] = {
335         {"None", 0},
336         {"SSLv3", SSL3_VERSION},
337         {"TLSv1", TLS1_VERSION},
338         {"TLSv1.1", TLS1_1_VERSION},
339         {"TLSv1.2", TLS1_2_VERSION},
340         {"DTLSv1", DTLS1_VERSION},
341         {"DTLSv1.2", DTLS1_2_VERSION}};
342     size_t i;
343     size_t n = OSSL_NELEM(versions);
344
345     for (i = 0; i < n; i++)
346         if (strcmp(versions[i].name, value) == 0)
347             return versions[i].version;
348     return -1;
349 }
350
351 static int min_max_proto(SSL_CONF_CTX *cctx, const char *value, int *bound)
352 {
353     int method_version;
354     int new_version;
355
356     if (cctx->ctx != NULL)
357         method_version = cctx->ctx->method->version;
358     else if (cctx->ssl != NULL)
359         method_version = cctx->ssl->ctx->method->version;
360     else
361         return 0;
362     if ((new_version = protocol_from_string(value)) < 0)
363         return 0;
364     return ssl_set_version_bound(method_version, new_version, bound);
365 }
366
367 /*
368  * cmd_MinProtocol - Set min protocol version
369  * @cctx: config structure to save settings in
370  * @value: The min protocol version in string form
371  *
372  * Returns 1 on success and 0 on failure.
373  */
374 static int cmd_MinProtocol(SSL_CONF_CTX *cctx, const char *value)
375 {
376     return min_max_proto(cctx, value, cctx->min_version);
377 }
378
379 /*
380  * cmd_MaxProtocol - Set max protocol version
381  * @cctx: config structure to save settings in
382  * @value: The max protocol version in string form
383  *
384  * Returns 1 on success and 0 on failure.
385  */
386 static int cmd_MaxProtocol(SSL_CONF_CTX *cctx, const char *value)
387 {
388     return min_max_proto(cctx, value, cctx->max_version);
389 }
390
391 static int cmd_Options(SSL_CONF_CTX *cctx, const char *value)
392 {
393     static const ssl_flag_tbl ssl_option_list[] = {
394         SSL_FLAG_TBL_INV("SessionTicket", SSL_OP_NO_TICKET),
395         SSL_FLAG_TBL_INV("EmptyFragments",
396                          SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS),
397         SSL_FLAG_TBL("Bugs", SSL_OP_ALL),
398         SSL_FLAG_TBL_INV("Compression", SSL_OP_NO_COMPRESSION),
399         SSL_FLAG_TBL_SRV("ServerPreference", SSL_OP_CIPHER_SERVER_PREFERENCE),
400         SSL_FLAG_TBL_SRV("NoResumptionOnRenegotiation",
401                          SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION),
402         SSL_FLAG_TBL_SRV("DHSingle", SSL_OP_SINGLE_DH_USE),
403         SSL_FLAG_TBL_SRV("ECDHSingle", SSL_OP_SINGLE_ECDH_USE),
404         SSL_FLAG_TBL("UnsafeLegacyRenegotiation",
405                      SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION),
406     };
407     if (value == NULL)
408         return -3;
409     cctx->tbl = ssl_option_list;
410     cctx->ntbl = OSSL_NELEM(ssl_option_list);
411     return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx);
412 }
413
414 static int cmd_VerifyMode(SSL_CONF_CTX *cctx, const char *value)
415 {
416     static const ssl_flag_tbl ssl_vfy_list[] = {
417         SSL_FLAG_VFY_CLI("Peer", SSL_VERIFY_PEER),
418         SSL_FLAG_VFY_SRV("Request", SSL_VERIFY_PEER),
419         SSL_FLAG_VFY_SRV("Require",
420                          SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
421         SSL_FLAG_VFY_SRV("Once", SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE)
422     };
423     if (value == NULL)
424         return -3;
425     cctx->tbl = ssl_vfy_list;
426     cctx->ntbl = OSSL_NELEM(ssl_vfy_list);
427     return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx);
428 }
429
430 static int cmd_Certificate(SSL_CONF_CTX *cctx, const char *value)
431 {
432     int rv = 1;
433     CERT *c = NULL;
434     if (cctx->ctx) {
435         rv = SSL_CTX_use_certificate_chain_file(cctx->ctx, value);
436         c = cctx->ctx->cert;
437     }
438     if (cctx->ssl) {
439         rv = SSL_use_certificate_chain_file(cctx->ssl, value);
440         c = cctx->ssl->cert;
441     }
442     if (rv > 0 && c && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
443         char **pfilename = &cctx->cert_filename[c->key - c->pkeys];
444         OPENSSL_free(*pfilename);
445         *pfilename = OPENSSL_strdup(value);
446         if (!*pfilename)
447             rv = 0;
448     }
449
450     return rv > 0;
451 }
452
453 static int cmd_PrivateKey(SSL_CONF_CTX *cctx, const char *value)
454 {
455     int rv = 1;
456     if (!(cctx->flags & SSL_CONF_FLAG_CERTIFICATE))
457         return -2;
458     if (cctx->ctx)
459         rv = SSL_CTX_use_PrivateKey_file(cctx->ctx, value, SSL_FILETYPE_PEM);
460     if (cctx->ssl)
461         rv = SSL_use_PrivateKey_file(cctx->ssl, value, SSL_FILETYPE_PEM);
462     return rv > 0;
463 }
464
465 static int cmd_ServerInfoFile(SSL_CONF_CTX *cctx, const char *value)
466 {
467     int rv = 1;
468     if (cctx->ctx)
469         rv = SSL_CTX_use_serverinfo_file(cctx->ctx, value);
470     return rv > 0;
471 }
472
473 static int do_store(SSL_CONF_CTX *cctx,
474                     const char *CAfile, const char *CApath, int verify_store)
475 {
476     CERT *cert;
477     X509_STORE **st;
478     if (cctx->ctx)
479         cert = cctx->ctx->cert;
480     else if (cctx->ssl)
481         cert = cctx->ssl->cert;
482     else
483         return 1;
484     st = verify_store ? &cert->verify_store : &cert->chain_store;
485     if (*st == NULL) {
486         *st = X509_STORE_new();
487         if (*st == NULL)
488             return 0;
489     }
490     return X509_STORE_load_locations(*st, CAfile, CApath) > 0;
491 }
492
493 static int cmd_ChainCAPath(SSL_CONF_CTX *cctx, const char *value)
494 {
495     return do_store(cctx, NULL, value, 0);
496 }
497
498 static int cmd_ChainCAFile(SSL_CONF_CTX *cctx, const char *value)
499 {
500     return do_store(cctx, value, NULL, 0);
501 }
502
503 static int cmd_VerifyCAPath(SSL_CONF_CTX *cctx, const char *value)
504 {
505     return do_store(cctx, NULL, value, 1);
506 }
507
508 static int cmd_VerifyCAFile(SSL_CONF_CTX *cctx, const char *value)
509 {
510     return do_store(cctx, value, NULL, 1);
511 }
512
513 static int cmd_ClientCAFile(SSL_CONF_CTX *cctx, const char *value)
514 {
515     if (cctx->canames == NULL)
516         cctx->canames = sk_X509_NAME_new_null();
517     if (cctx->canames == NULL)
518         return 0;
519     return SSL_add_file_cert_subjects_to_stack(cctx->canames, value);
520 }
521
522 static int cmd_ClientCAPath(SSL_CONF_CTX *cctx, const char *value)
523 {
524     if (cctx->canames == NULL)
525         cctx->canames = sk_X509_NAME_new_null();
526     if (cctx->canames == NULL)
527         return 0;
528     return SSL_add_dir_cert_subjects_to_stack(cctx->canames, value);
529 }
530
531 #ifndef OPENSSL_NO_DH
532 static int cmd_DHParameters(SSL_CONF_CTX *cctx, const char *value)
533 {
534     int rv = 0;
535     DH *dh = NULL;
536     BIO *in = NULL;
537     if (cctx->ctx || cctx->ssl) {
538         in = BIO_new(BIO_s_file());
539         if (in == NULL)
540             goto end;
541         if (BIO_read_filename(in, value) <= 0)
542             goto end;
543         dh = PEM_read_bio_DHparams(in, NULL, NULL, NULL);
544         if (dh == NULL)
545             goto end;
546     } else
547         return 1;
548     if (cctx->ctx)
549         rv = SSL_CTX_set_tmp_dh(cctx->ctx, dh);
550     if (cctx->ssl)
551         rv = SSL_set_tmp_dh(cctx->ssl, dh);
552  end:
553     DH_free(dh);
554     BIO_free(in);
555     return rv > 0;
556 }
557 #endif
558 typedef struct {
559     int (*cmd) (SSL_CONF_CTX *cctx, const char *value);
560     const char *str_file;
561     const char *str_cmdline;
562     unsigned short flags;
563     unsigned short value_type;
564 } ssl_conf_cmd_tbl;
565
566 /* Table of supported parameters */
567
568 #define SSL_CONF_CMD(name, cmdopt, flags, type) \
569         {cmd_##name, #name, cmdopt, flags, type}
570
571 #define SSL_CONF_CMD_STRING(name, cmdopt, flags) \
572         SSL_CONF_CMD(name, cmdopt, flags, SSL_CONF_TYPE_STRING)
573
574 #define SSL_CONF_CMD_SWITCH(name, flags) \
575         {0, NULL, name, flags, SSL_CONF_TYPE_NONE}
576
577 /* See apps/apps.h if you change this table. */
578 static const ssl_conf_cmd_tbl ssl_conf_cmds[] = {
579     SSL_CONF_CMD_SWITCH("no_ssl3", 0),
580     SSL_CONF_CMD_SWITCH("no_tls1", 0),
581     SSL_CONF_CMD_SWITCH("no_tls1_1", 0),
582     SSL_CONF_CMD_SWITCH("no_tls1_2", 0),
583     SSL_CONF_CMD_SWITCH("bugs", 0),
584     SSL_CONF_CMD_SWITCH("no_comp", 0),
585     SSL_CONF_CMD_SWITCH("ecdh_single", SSL_CONF_FLAG_SERVER),
586     SSL_CONF_CMD_SWITCH("no_ticket", 0),
587     SSL_CONF_CMD_SWITCH("serverpref", SSL_CONF_FLAG_SERVER),
588     SSL_CONF_CMD_SWITCH("legacy_renegotiation", 0),
589     SSL_CONF_CMD_SWITCH("legacy_server_connect", SSL_CONF_FLAG_SERVER),
590     SSL_CONF_CMD_SWITCH("no_resumption_on_reneg", SSL_CONF_FLAG_SERVER),
591     SSL_CONF_CMD_SWITCH("no_legacy_server_connect", SSL_CONF_FLAG_SERVER),
592     SSL_CONF_CMD_SWITCH("strict", 0),
593 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
594     SSL_CONF_CMD_SWITCH("debug_broken_protocol", 0),
595 #endif
596     SSL_CONF_CMD_STRING(SignatureAlgorithms, "sigalgs", 0),
597     SSL_CONF_CMD_STRING(ClientSignatureAlgorithms, "client_sigalgs", 0),
598     SSL_CONF_CMD_STRING(Curves, "curves", 0),
599 #ifndef OPENSSL_NO_EC
600     SSL_CONF_CMD_STRING(ECDHParameters, "named_curve", SSL_CONF_FLAG_SERVER),
601 #endif
602     SSL_CONF_CMD_STRING(CipherString, "cipher", 0),
603     SSL_CONF_CMD_STRING(Protocol, NULL, 0),
604     SSL_CONF_CMD_STRING(MinProtocol, "min_protocol", SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CLIENT),
605     SSL_CONF_CMD_STRING(MaxProtocol, "max_protocol", SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CLIENT),
606     SSL_CONF_CMD_STRING(Options, NULL, 0),
607     SSL_CONF_CMD_STRING(VerifyMode, NULL, 0),
608     SSL_CONF_CMD(Certificate, "cert", SSL_CONF_FLAG_CERTIFICATE,
609                  SSL_CONF_TYPE_FILE),
610     SSL_CONF_CMD(PrivateKey, "key", SSL_CONF_FLAG_CERTIFICATE,
611                  SSL_CONF_TYPE_FILE),
612     SSL_CONF_CMD(ServerInfoFile, NULL,
613                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
614                  SSL_CONF_TYPE_FILE),
615     SSL_CONF_CMD(ChainCAPath, "chainCApath", SSL_CONF_FLAG_CERTIFICATE,
616                  SSL_CONF_TYPE_DIR),
617     SSL_CONF_CMD(ChainCAFile, "chainCAfile", SSL_CONF_FLAG_CERTIFICATE,
618                  SSL_CONF_TYPE_FILE),
619     SSL_CONF_CMD(VerifyCAPath, "verifyCApath", SSL_CONF_FLAG_CERTIFICATE,
620                  SSL_CONF_TYPE_DIR),
621     SSL_CONF_CMD(VerifyCAFile, "verifyCAfile", SSL_CONF_FLAG_CERTIFICATE,
622                  SSL_CONF_TYPE_FILE),
623     SSL_CONF_CMD(ClientCAFile, NULL,
624                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
625                  SSL_CONF_TYPE_FILE),
626     SSL_CONF_CMD(ClientCAPath, NULL,
627                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
628                  SSL_CONF_TYPE_DIR),
629 #ifndef OPENSSL_NO_DH
630     SSL_CONF_CMD(DHParameters, "dhparam",
631                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
632                  SSL_CONF_TYPE_FILE)
633 #endif
634 };
635
636 /* Supported switches: must match order of switches in ssl_conf_cmds */
637 static const ssl_switch_tbl ssl_cmd_switches[] = {
638     {SSL_OP_NO_SSLv3, 0},       /* no_ssl3 */
639     {SSL_OP_NO_TLSv1, 0},       /* no_tls1 */
640     {SSL_OP_NO_TLSv1_1, 0},     /* no_tls1_1 */
641     {SSL_OP_NO_TLSv1_2, 0},     /* no_tls1_2 */
642     {SSL_OP_ALL, 0},            /* bugs */
643     {SSL_OP_NO_COMPRESSION, 0}, /* no_comp */
644     {SSL_OP_SINGLE_ECDH_USE, 0}, /* ecdh_single */
645     {SSL_OP_NO_TICKET, 0},      /* no_ticket */
646     {SSL_OP_CIPHER_SERVER_PREFERENCE, 0}, /* serverpref */
647     /* legacy_renegotiation */
648     {SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, 0},
649     /* legacy_server_connect */
650     {SSL_OP_LEGACY_SERVER_CONNECT, 0},
651     /* no_resumption_on_reneg */
652     {SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, 0},
653     /* no_legacy_server_connect */
654     {SSL_OP_LEGACY_SERVER_CONNECT, SSL_TFLAG_INV},
655     {SSL_CERT_FLAG_TLS_STRICT, SSL_TFLAG_CERT}, /* strict */
656 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
657     {SSL_CERT_FLAG_BROKEN_PROTOCOL, SSL_TFLAG_CERT} /* debug_broken_protocol */
658 #endif
659 };
660
661 static int ssl_conf_cmd_skip_prefix(SSL_CONF_CTX *cctx, const char **pcmd)
662 {
663     if (!pcmd || !*pcmd)
664         return 0;
665     /* If a prefix is set, check and skip */
666     if (cctx->prefix) {
667         if (strlen(*pcmd) <= cctx->prefixlen)
668             return 0;
669         if (cctx->flags & SSL_CONF_FLAG_CMDLINE &&
670             strncmp(*pcmd, cctx->prefix, cctx->prefixlen))
671             return 0;
672         if (cctx->flags & SSL_CONF_FLAG_FILE &&
673             strncasecmp(*pcmd, cctx->prefix, cctx->prefixlen))
674             return 0;
675         *pcmd += cctx->prefixlen;
676     } else if (cctx->flags & SSL_CONF_FLAG_CMDLINE) {
677         if (**pcmd != '-' || !(*pcmd)[1])
678             return 0;
679         *pcmd += 1;
680     }
681     return 1;
682 }
683
684 /* Determine if a command is allowed according to cctx flags */
685 static int ssl_conf_cmd_allowed(SSL_CONF_CTX *cctx,
686                                 const ssl_conf_cmd_tbl * t)
687 {
688     unsigned int tfl = t->flags;
689     unsigned int cfl = cctx->flags;
690     if ((tfl & SSL_CONF_FLAG_SERVER) && !(cfl & SSL_CONF_FLAG_SERVER))
691         return 0;
692     if ((tfl & SSL_CONF_FLAG_CLIENT) && !(cfl & SSL_CONF_FLAG_CLIENT))
693         return 0;
694     if ((tfl & SSL_CONF_FLAG_CERTIFICATE)
695         && !(cfl & SSL_CONF_FLAG_CERTIFICATE))
696         return 0;
697     return 1;
698 }
699
700 static const ssl_conf_cmd_tbl *ssl_conf_cmd_lookup(SSL_CONF_CTX *cctx,
701                                                    const char *cmd)
702 {
703     const ssl_conf_cmd_tbl *t;
704     size_t i;
705     if (cmd == NULL)
706         return NULL;
707
708     /* Look for matching parameter name in table */
709     for (i = 0, t = ssl_conf_cmds; i < OSSL_NELEM(ssl_conf_cmds); i++, t++) {
710         if (ssl_conf_cmd_allowed(cctx, t)) {
711             if (cctx->flags & SSL_CONF_FLAG_CMDLINE) {
712                 if (t->str_cmdline && strcmp(t->str_cmdline, cmd) == 0)
713                     return t;
714             }
715             if (cctx->flags & SSL_CONF_FLAG_FILE) {
716                 if (t->str_file && strcasecmp(t->str_file, cmd) == 0)
717                     return t;
718             }
719         }
720     }
721     return NULL;
722 }
723
724 static int ctrl_switch_option(SSL_CONF_CTX *cctx,
725                               const ssl_conf_cmd_tbl * cmd)
726 {
727     /* Find index of command in table */
728     size_t idx = cmd - ssl_conf_cmds;
729     const ssl_switch_tbl *scmd;
730     /* Sanity check index */
731     if (idx >= OSSL_NELEM(ssl_cmd_switches))
732         return 0;
733     /* Obtain switches entry with same index */
734     scmd = ssl_cmd_switches + idx;
735     ssl_set_option(cctx, scmd->name_flags, scmd->option_value, 1);
736     return 1;
737 }
738
739 int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value)
740 {
741     const ssl_conf_cmd_tbl *runcmd;
742     if (cmd == NULL) {
743         SSLerr(SSL_F_SSL_CONF_CMD, SSL_R_INVALID_NULL_CMD_NAME);
744         return 0;
745     }
746
747     if (!ssl_conf_cmd_skip_prefix(cctx, &cmd))
748         return -2;
749
750     runcmd = ssl_conf_cmd_lookup(cctx, cmd);
751
752     if (runcmd) {
753         int rv;
754         if (runcmd->value_type == SSL_CONF_TYPE_NONE) {
755             return ctrl_switch_option(cctx, runcmd);
756         }
757         if (value == NULL)
758             return -3;
759         rv = runcmd->cmd(cctx, value);
760         if (rv > 0)
761             return 2;
762         if (rv == -2)
763             return -2;
764         if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS) {
765             SSLerr(SSL_F_SSL_CONF_CMD, SSL_R_BAD_VALUE);
766             ERR_add_error_data(4, "cmd=", cmd, ", value=", value);
767         }
768         return 0;
769     }
770
771     if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS) {
772         SSLerr(SSL_F_SSL_CONF_CMD, SSL_R_UNKNOWN_CMD_NAME);
773         ERR_add_error_data(2, "cmd=", cmd);
774     }
775
776     return -2;
777 }
778
779 int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv)
780 {
781     int rv;
782     const char *arg = NULL, *argn;
783     if (pargc && *pargc == 0)
784         return 0;
785     if (!pargc || *pargc > 0)
786         arg = **pargv;
787     if (arg == NULL)
788         return 0;
789     if (!pargc || *pargc > 1)
790         argn = (*pargv)[1];
791     else
792         argn = NULL;
793     cctx->flags &= ~SSL_CONF_FLAG_FILE;
794     cctx->flags |= SSL_CONF_FLAG_CMDLINE;
795     rv = SSL_CONF_cmd(cctx, arg, argn);
796     if (rv > 0) {
797         /* Success: update pargc, pargv */
798         (*pargv) += rv;
799         if (pargc)
800             (*pargc) -= rv;
801         return rv;
802     }
803     /* Unknown switch: indicate no arguments processed */
804     if (rv == -2)
805         return 0;
806     /* Some error occurred processing command, return fatal error */
807     if (rv == 0)
808         return -1;
809     return rv;
810 }
811
812 int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd)
813 {
814     if (ssl_conf_cmd_skip_prefix(cctx, &cmd)) {
815         const ssl_conf_cmd_tbl *runcmd;
816         runcmd = ssl_conf_cmd_lookup(cctx, cmd);
817         if (runcmd)
818             return runcmd->value_type;
819     }
820     return SSL_CONF_TYPE_UNKNOWN;
821 }
822
823 SSL_CONF_CTX *SSL_CONF_CTX_new(void)
824 {
825     SSL_CONF_CTX *ret = OPENSSL_zalloc(sizeof(*ret));
826
827     return ret;
828 }
829
830 int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx)
831 {
832     /* See if any certificates are missing private keys */
833     size_t i;
834     CERT *c = NULL;
835     if (cctx->ctx)
836         c = cctx->ctx->cert;
837     else if (cctx->ssl)
838         c = cctx->ssl->cert;
839     if (c && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
840         for (i = 0; i < SSL_PKEY_NUM; i++) {
841             const char *p = cctx->cert_filename[i];
842             /*
843              * If missing private key try to load one from certificate file
844              */
845             if (p && !c->pkeys[i].privatekey) {
846                 if (!cmd_PrivateKey(cctx, p))
847                     return 0;
848             }
849         }
850     }
851     if (cctx->canames) {
852         if (cctx->ssl)
853             SSL_set_client_CA_list(cctx->ssl, cctx->canames);
854         else if (cctx->ctx)
855             SSL_CTX_set_client_CA_list(cctx->ctx, cctx->canames);
856         else
857             sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free);
858         cctx->canames = NULL;
859     }
860     return 1;
861 }
862
863 void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx)
864 {
865     if (cctx) {
866         size_t i;
867         for (i = 0; i < SSL_PKEY_NUM; i++)
868             OPENSSL_free(cctx->cert_filename[i]);
869         OPENSSL_free(cctx->prefix);
870         sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free);
871         OPENSSL_free(cctx);
872     }
873 }
874
875 unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags)
876 {
877     cctx->flags |= flags;
878     return cctx->flags;
879 }
880
881 unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx, unsigned int flags)
882 {
883     cctx->flags &= ~flags;
884     return cctx->flags;
885 }
886
887 int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre)
888 {
889     char *tmp = NULL;
890     if (pre) {
891         tmp = OPENSSL_strdup(pre);
892         if (tmp == NULL)
893             return 0;
894     }
895     OPENSSL_free(cctx->prefix);
896     cctx->prefix = tmp;
897     if (tmp)
898         cctx->prefixlen = strlen(tmp);
899     else
900         cctx->prefixlen = 0;
901     return 1;
902 }
903
904 void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl)
905 {
906     cctx->ssl = ssl;
907     cctx->ctx = NULL;
908     if (ssl) {
909         cctx->poptions = &ssl->options;
910         cctx->min_version = &ssl->min_proto_version;
911         cctx->max_version = &ssl->max_proto_version;
912         cctx->pcert_flags = &ssl->cert->cert_flags;
913         cctx->pvfy_flags = &ssl->verify_mode;
914     } else {
915         cctx->poptions = NULL;
916         cctx->min_version = NULL;
917         cctx->max_version = NULL;
918         cctx->pcert_flags = NULL;
919         cctx->pvfy_flags = NULL;
920     }
921 }
922
923 void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx)
924 {
925     cctx->ctx = ctx;
926     cctx->ssl = NULL;
927     if (ctx) {
928         cctx->poptions = &ctx->options;
929         cctx->min_version = &ctx->min_proto_version;
930         cctx->max_version = &ctx->max_proto_version;
931         cctx->pcert_flags = &ctx->cert->cert_flags;
932         cctx->pvfy_flags = &ctx->verify_mode;
933     } else {
934         cctx->poptions = NULL;
935         cctx->min_version = NULL;
936         cctx->max_version = NULL;
937         cctx->pcert_flags = NULL;
938         cctx->pvfy_flags = NULL;
939     }
940 }