Add an extra reduction step to RSAZ mod_exp implementations
[openssl.git] / ssl / ssl_conf.c
1 /*
2  * Copyright 2012-2022 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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 <stdio.h>
11 #include "ssl_local.h"
12 #include <openssl/conf.h>
13 #include <openssl/objects.h>
14 #include <openssl/decoder.h>
15 #include <openssl/core_dispatch.h>
16 #include "internal/nelem.h"
17
18 /*
19  * structure holding name tables. This is used for permitted elements in lists
20  * such as TLSv1.
21  */
22
23 typedef struct {
24     const char *name;
25     int namelen;
26     unsigned int name_flags;
27     uint64_t option_value;
28 } ssl_flag_tbl;
29
30 /* Switch table: use for single command line switches like no_tls2 */
31 typedef struct {
32     uint64_t option_value;
33     unsigned int name_flags;
34 } ssl_switch_tbl;
35
36 /* Sense of name is inverted e.g. "TLSv1" will clear SSL_OP_NO_TLSv1 */
37 #define SSL_TFLAG_INV   0x1
38 /* Mask for type of flag referred to */
39 #define SSL_TFLAG_TYPE_MASK 0xf00
40 /* Flag is for options */
41 #define SSL_TFLAG_OPTION    0x000
42 /* Flag is for cert_flags */
43 #define SSL_TFLAG_CERT      0x100
44 /* Flag is for verify mode */
45 #define SSL_TFLAG_VFY       0x200
46 /* Option can only be used for clients */
47 #define SSL_TFLAG_CLIENT SSL_CONF_FLAG_CLIENT
48 /* Option can only be used for servers */
49 #define SSL_TFLAG_SERVER SSL_CONF_FLAG_SERVER
50 #define SSL_TFLAG_BOTH (SSL_TFLAG_CLIENT|SSL_TFLAG_SERVER)
51
52 #define SSL_FLAG_TBL(str, flag) \
53         {str, (int)(sizeof(str) - 1), SSL_TFLAG_BOTH, flag}
54 #define SSL_FLAG_TBL_SRV(str, flag) \
55         {str, (int)(sizeof(str) - 1), SSL_TFLAG_SERVER, flag}
56 #define SSL_FLAG_TBL_CLI(str, flag) \
57         {str, (int)(sizeof(str) - 1), SSL_TFLAG_CLIENT, flag}
58 #define SSL_FLAG_TBL_INV(str, flag) \
59         {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_BOTH, flag}
60 #define SSL_FLAG_TBL_SRV_INV(str, flag) \
61         {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_SERVER, flag}
62 #define SSL_FLAG_TBL_CERT(str, flag) \
63         {str, (int)(sizeof(str) - 1), SSL_TFLAG_CERT|SSL_TFLAG_BOTH, flag}
64
65 #define SSL_FLAG_VFY_CLI(str, flag) \
66         {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_CLIENT, flag}
67 #define SSL_FLAG_VFY_SRV(str, flag) \
68         {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_SERVER, flag}
69
70 /*
71  * Opaque structure containing SSL configuration context.
72  */
73
74 struct ssl_conf_ctx_st {
75     /*
76      * Various flags indicating (among other things) which options we will
77      * recognise.
78      */
79     unsigned int flags;
80     /* Prefix and length of commands */
81     char *prefix;
82     size_t prefixlen;
83     /* SSL_CTX or SSL structure to perform operations on */
84     SSL_CTX *ctx;
85     SSL *ssl;
86     /* Pointer to SSL or SSL_CTX options field or NULL if none */
87     uint64_t *poptions;
88     /* Certificate filenames for each type */
89     char *cert_filename[SSL_PKEY_NUM];
90     /* Pointer to SSL or SSL_CTX cert_flags or NULL if none */
91     uint32_t *pcert_flags;
92     /* Pointer to SSL or SSL_CTX verify_mode or NULL if none */
93     uint32_t *pvfy_flags;
94     /* Pointer to SSL or SSL_CTX min_version field or NULL if none */
95     int *min_version;
96     /* Pointer to SSL or SSL_CTX max_version field or NULL if none */
97     int *max_version;
98     /* Current flag table being worked on */
99     const ssl_flag_tbl *tbl;
100     /* Size of table */
101     size_t ntbl;
102     /* Client CA names */
103     STACK_OF(X509_NAME) *canames;
104 };
105
106 static void ssl_set_option(SSL_CONF_CTX *cctx, unsigned int name_flags,
107                            uint64_t option_value, int onoff)
108 {
109     uint32_t *pflags;
110
111     if (cctx->poptions == NULL)
112         return;
113     if (name_flags & SSL_TFLAG_INV)
114         onoff ^= 1;
115     switch (name_flags & SSL_TFLAG_TYPE_MASK) {
116
117     case SSL_TFLAG_CERT:
118         pflags = cctx->pcert_flags;
119         break;
120
121     case SSL_TFLAG_VFY:
122         pflags = cctx->pvfy_flags;
123         break;
124
125     case SSL_TFLAG_OPTION:
126         if (onoff)
127             *cctx->poptions |= option_value;
128         else
129             *cctx->poptions &= ~option_value;
130         return;
131
132     default:
133         return;
134
135     }
136     if (onoff)
137         *pflags |= option_value;
138     else
139         *pflags &= ~option_value;
140 }
141
142 static int ssl_match_option(SSL_CONF_CTX *cctx, const ssl_flag_tbl *tbl,
143                             const char *name, int namelen, int onoff)
144 {
145     /* If name not relevant for context skip */
146     if (!(cctx->flags & tbl->name_flags & SSL_TFLAG_BOTH))
147         return 0;
148     if (namelen == -1) {
149         if (strcmp(tbl->name, name))
150             return 0;
151     } else if (tbl->namelen != namelen
152                || OPENSSL_strncasecmp(tbl->name, name, namelen))
153         return 0;
154     ssl_set_option(cctx, tbl->name_flags, tbl->option_value, onoff);
155     return 1;
156 }
157
158 static int ssl_set_option_list(const char *elem, int len, void *usr)
159 {
160     SSL_CONF_CTX *cctx = usr;
161     size_t i;
162     const ssl_flag_tbl *tbl;
163     int onoff = 1;
164     /*
165      * len == -1 indicates not being called in list context, just for single
166      * command line switches, so don't allow +, -.
167      */
168     if (elem == NULL)
169         return 0;
170     if (len != -1) {
171         if (*elem == '+') {
172             elem++;
173             len--;
174             onoff = 1;
175         } else if (*elem == '-') {
176             elem++;
177             len--;
178             onoff = 0;
179         }
180     }
181     for (i = 0, tbl = cctx->tbl; i < cctx->ntbl; i++, tbl++) {
182         if (ssl_match_option(cctx, tbl, elem, len, onoff))
183             return 1;
184     }
185     return 0;
186 }
187
188 /* Set supported signature algorithms */
189 static int cmd_SignatureAlgorithms(SSL_CONF_CTX *cctx, const char *value)
190 {
191     int rv;
192     if (cctx->ssl)
193         rv = SSL_set1_sigalgs_list(cctx->ssl, value);
194     /* NB: ctx == NULL performs syntax checking only */
195     else
196         rv = SSL_CTX_set1_sigalgs_list(cctx->ctx, value);
197     return rv > 0;
198 }
199
200 /* Set supported client signature algorithms */
201 static int cmd_ClientSignatureAlgorithms(SSL_CONF_CTX *cctx, const char *value)
202 {
203     int rv;
204     if (cctx->ssl)
205         rv = SSL_set1_client_sigalgs_list(cctx->ssl, value);
206     /* NB: ctx == NULL performs syntax checking only */
207     else
208         rv = SSL_CTX_set1_client_sigalgs_list(cctx->ctx, value);
209     return rv > 0;
210 }
211
212 static int cmd_Groups(SSL_CONF_CTX *cctx, const char *value)
213 {
214     int rv;
215     if (cctx->ssl)
216         rv = SSL_set1_groups_list(cctx->ssl, value);
217     /* NB: ctx == NULL performs syntax checking only */
218     else
219         rv = SSL_CTX_set1_groups_list(cctx->ctx, value);
220     return rv > 0;
221 }
222
223 /* This is the old name for cmd_Groups - retained for backwards compatibility */
224 static int cmd_Curves(SSL_CONF_CTX *cctx, const char *value)
225 {
226     return cmd_Groups(cctx, value);
227 }
228
229 /* ECDH temporary parameters */
230 static int cmd_ECDHParameters(SSL_CONF_CTX *cctx, const char *value)
231 {
232     int rv = 1;
233
234     /* Ignore values supported by 1.0.2 for the automatic selection */
235     if ((cctx->flags & SSL_CONF_FLAG_FILE)
236             && (OPENSSL_strcasecmp(value, "+automatic") == 0
237                 || OPENSSL_strcasecmp(value, "automatic") == 0))
238         return 1;
239     if ((cctx->flags & SSL_CONF_FLAG_CMDLINE) &&
240         strcmp(value, "auto") == 0)
241         return 1;
242
243     /* ECDHParameters accepts a single group name */
244     if (strstr(value, ":") != NULL)
245         return 0;
246
247     if (cctx->ctx)
248         rv = SSL_CTX_set1_groups_list(cctx->ctx, value);
249     else if (cctx->ssl)
250         rv = SSL_set1_groups_list(cctx->ssl, value);
251
252     return rv > 0;
253 }
254
255 static int cmd_CipherString(SSL_CONF_CTX *cctx, const char *value)
256 {
257     int rv = 1;
258
259     if (cctx->ctx)
260         rv = SSL_CTX_set_cipher_list(cctx->ctx, value);
261     if (cctx->ssl)
262         rv = SSL_set_cipher_list(cctx->ssl, value);
263     return rv > 0;
264 }
265
266 static int cmd_Ciphersuites(SSL_CONF_CTX *cctx, const char *value)
267 {
268     int rv = 1;
269
270     if (cctx->ctx)
271         rv = SSL_CTX_set_ciphersuites(cctx->ctx, value);
272     if (cctx->ssl)
273         rv = SSL_set_ciphersuites(cctx->ssl, value);
274     return rv > 0;
275 }
276
277 static int cmd_Protocol(SSL_CONF_CTX *cctx, const char *value)
278 {
279     static const ssl_flag_tbl ssl_protocol_list[] = {
280         SSL_FLAG_TBL_INV("ALL", SSL_OP_NO_SSL_MASK),
281         SSL_FLAG_TBL_INV("SSLv2", SSL_OP_NO_SSLv2),
282         SSL_FLAG_TBL_INV("SSLv3", SSL_OP_NO_SSLv3),
283         SSL_FLAG_TBL_INV("TLSv1", SSL_OP_NO_TLSv1),
284         SSL_FLAG_TBL_INV("TLSv1.1", SSL_OP_NO_TLSv1_1),
285         SSL_FLAG_TBL_INV("TLSv1.2", SSL_OP_NO_TLSv1_2),
286         SSL_FLAG_TBL_INV("TLSv1.3", SSL_OP_NO_TLSv1_3),
287         SSL_FLAG_TBL_INV("DTLSv1", SSL_OP_NO_DTLSv1),
288         SSL_FLAG_TBL_INV("DTLSv1.2", SSL_OP_NO_DTLSv1_2)
289     };
290     cctx->tbl = ssl_protocol_list;
291     cctx->ntbl = OSSL_NELEM(ssl_protocol_list);
292     return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx);
293 }
294
295 /*
296  * protocol_from_string - converts a protocol version string to a number
297  *
298  * Returns -1 on failure or the version on success
299  */
300 static int protocol_from_string(const char *value)
301 {
302     struct protocol_versions {
303         const char *name;
304         int version;
305     };
306     /*
307      * Note: To avoid breaking previously valid configurations, we must retain
308      * legacy entries in this table even if the underlying protocol is no
309      * longer supported.  This also means that the constants SSL3_VERSION, ...
310      * need to be retained indefinitely.  This table can only grow, never
311      * shrink.
312      */
313     static const struct protocol_versions versions[] = {
314         {"None", 0},
315         {"SSLv3", SSL3_VERSION},
316         {"TLSv1", TLS1_VERSION},
317         {"TLSv1.1", TLS1_1_VERSION},
318         {"TLSv1.2", TLS1_2_VERSION},
319         {"TLSv1.3", TLS1_3_VERSION},
320         {"DTLSv1", DTLS1_VERSION},
321         {"DTLSv1.2", DTLS1_2_VERSION}
322     };
323     size_t i;
324     size_t n = OSSL_NELEM(versions);
325
326     for (i = 0; i < n; i++)
327         if (strcmp(versions[i].name, value) == 0)
328             return versions[i].version;
329     return -1;
330 }
331
332 static int min_max_proto(SSL_CONF_CTX *cctx, const char *value, int *bound)
333 {
334     int method_version;
335     int new_version;
336
337     if (cctx->ctx != NULL)
338         method_version = cctx->ctx->method->version;
339     else if (cctx->ssl != NULL)
340         method_version = cctx->ssl->ctx->method->version;
341     else
342         return 0;
343     if ((new_version = protocol_from_string(value)) < 0)
344         return 0;
345     return ssl_set_version_bound(method_version, new_version, bound);
346 }
347
348 /*
349  * cmd_MinProtocol - Set min protocol version
350  * @cctx: config structure to save settings in
351  * @value: The min protocol version in string form
352  *
353  * Returns 1 on success and 0 on failure.
354  */
355 static int cmd_MinProtocol(SSL_CONF_CTX *cctx, const char *value)
356 {
357     return min_max_proto(cctx, value, cctx->min_version);
358 }
359
360 /*
361  * cmd_MaxProtocol - Set max protocol version
362  * @cctx: config structure to save settings in
363  * @value: The max protocol version in string form
364  *
365  * Returns 1 on success and 0 on failure.
366  */
367 static int cmd_MaxProtocol(SSL_CONF_CTX *cctx, const char *value)
368 {
369     return min_max_proto(cctx, value, cctx->max_version);
370 }
371
372 static int cmd_Options(SSL_CONF_CTX *cctx, const char *value)
373 {
374     static const ssl_flag_tbl ssl_option_list[] = {
375         SSL_FLAG_TBL_INV("SessionTicket", SSL_OP_NO_TICKET),
376         SSL_FLAG_TBL_INV("EmptyFragments",
377                          SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS),
378         SSL_FLAG_TBL("Bugs", SSL_OP_ALL),
379         SSL_FLAG_TBL_INV("Compression", SSL_OP_NO_COMPRESSION),
380         SSL_FLAG_TBL_SRV("ServerPreference", SSL_OP_CIPHER_SERVER_PREFERENCE),
381         SSL_FLAG_TBL_SRV("NoResumptionOnRenegotiation",
382                          SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION),
383         SSL_FLAG_TBL_SRV("DHSingle", SSL_OP_SINGLE_DH_USE),
384         SSL_FLAG_TBL_SRV("ECDHSingle", SSL_OP_SINGLE_ECDH_USE),
385         SSL_FLAG_TBL("UnsafeLegacyRenegotiation",
386                      SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION),
387         SSL_FLAG_TBL("UnsafeLegacyServerConnect",
388                      SSL_OP_LEGACY_SERVER_CONNECT),
389         SSL_FLAG_TBL("ClientRenegotiation",
390                      SSL_OP_ALLOW_CLIENT_RENEGOTIATION),
391         SSL_FLAG_TBL_INV("EncryptThenMac", SSL_OP_NO_ENCRYPT_THEN_MAC),
392         SSL_FLAG_TBL("NoRenegotiation", SSL_OP_NO_RENEGOTIATION),
393         SSL_FLAG_TBL("AllowNoDHEKEX", SSL_OP_ALLOW_NO_DHE_KEX),
394         SSL_FLAG_TBL("PrioritizeChaCha", SSL_OP_PRIORITIZE_CHACHA),
395         SSL_FLAG_TBL("MiddleboxCompat", SSL_OP_ENABLE_MIDDLEBOX_COMPAT),
396         SSL_FLAG_TBL_INV("AntiReplay", SSL_OP_NO_ANTI_REPLAY),
397         SSL_FLAG_TBL_INV("ExtendedMasterSecret", SSL_OP_NO_EXTENDED_MASTER_SECRET),
398         SSL_FLAG_TBL_INV("CANames", SSL_OP_DISABLE_TLSEXT_CA_NAMES),
399         SSL_FLAG_TBL("KTLS", SSL_OP_ENABLE_KTLS),
400         SSL_FLAG_TBL_CERT("StrictCertCheck", SSL_CERT_FLAG_TLS_STRICT)
401     };
402     if (value == NULL)
403         return -3;
404     cctx->tbl = ssl_option_list;
405     cctx->ntbl = OSSL_NELEM(ssl_option_list);
406     return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx);
407 }
408
409 static int cmd_VerifyMode(SSL_CONF_CTX *cctx, const char *value)
410 {
411     static const ssl_flag_tbl ssl_vfy_list[] = {
412         SSL_FLAG_VFY_CLI("Peer", SSL_VERIFY_PEER),
413         SSL_FLAG_VFY_SRV("Request", SSL_VERIFY_PEER),
414         SSL_FLAG_VFY_SRV("Require",
415                          SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
416         SSL_FLAG_VFY_SRV("Once", SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE),
417         SSL_FLAG_VFY_SRV("RequestPostHandshake",
418                          SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE),
419         SSL_FLAG_VFY_SRV("RequirePostHandshake",
420                          SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE |
421                          SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
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 == NULL)
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, const char *CAstore,
475                     int verify_store)
476 {
477     CERT *cert;
478     X509_STORE **st;
479     SSL_CTX *ctx;
480     OSSL_LIB_CTX *libctx = NULL;
481     const char *propq = NULL;
482
483     if (cctx->ctx != NULL) {
484         cert = cctx->ctx->cert;
485         ctx = cctx->ctx;
486     } else if (cctx->ssl != NULL) {
487         cert = cctx->ssl->cert;
488         ctx = cctx->ssl->ctx;
489     } else {
490         return 1;
491     }
492     if (ctx != NULL) {
493         libctx = ctx->libctx;
494         propq = ctx->propq;
495     }
496     st = verify_store ? &cert->verify_store : &cert->chain_store;
497     if (*st == NULL) {
498         *st = X509_STORE_new();
499         if (*st == NULL)
500             return 0;
501     }
502
503     if (CAfile != NULL && !X509_STORE_load_file_ex(*st, CAfile, libctx, propq))
504         return 0;
505     if (CApath != NULL && !X509_STORE_load_path(*st, CApath))
506         return 0;
507     if (CAstore != NULL && !X509_STORE_load_store_ex(*st, CAstore, libctx,
508                                                      propq))
509         return 0;
510     return 1;
511 }
512
513 static int cmd_ChainCAPath(SSL_CONF_CTX *cctx, const char *value)
514 {
515     return do_store(cctx, NULL, value, NULL, 0);
516 }
517
518 static int cmd_ChainCAFile(SSL_CONF_CTX *cctx, const char *value)
519 {
520     return do_store(cctx, value, NULL, NULL, 0);
521 }
522
523 static int cmd_ChainCAStore(SSL_CONF_CTX *cctx, const char *value)
524 {
525     return do_store(cctx, NULL, NULL, value, 0);
526 }
527
528 static int cmd_VerifyCAPath(SSL_CONF_CTX *cctx, const char *value)
529 {
530     return do_store(cctx, NULL, value, NULL, 1);
531 }
532
533 static int cmd_VerifyCAFile(SSL_CONF_CTX *cctx, const char *value)
534 {
535     return do_store(cctx, value, NULL, NULL, 1);
536 }
537
538 static int cmd_VerifyCAStore(SSL_CONF_CTX *cctx, const char *value)
539 {
540     return do_store(cctx, NULL, NULL, value, 1);
541 }
542
543 static int cmd_RequestCAFile(SSL_CONF_CTX *cctx, const char *value)
544 {
545     if (cctx->canames == NULL)
546         cctx->canames = sk_X509_NAME_new_null();
547     if (cctx->canames == NULL)
548         return 0;
549     return SSL_add_file_cert_subjects_to_stack(cctx->canames, value);
550 }
551
552 static int cmd_ClientCAFile(SSL_CONF_CTX *cctx, const char *value)
553 {
554     return cmd_RequestCAFile(cctx, value);
555 }
556
557 static int cmd_RequestCAPath(SSL_CONF_CTX *cctx, const char *value)
558 {
559     if (cctx->canames == NULL)
560         cctx->canames = sk_X509_NAME_new_null();
561     if (cctx->canames == NULL)
562         return 0;
563     return SSL_add_dir_cert_subjects_to_stack(cctx->canames, value);
564 }
565
566 static int cmd_ClientCAPath(SSL_CONF_CTX *cctx, const char *value)
567 {
568     return cmd_RequestCAPath(cctx, value);
569 }
570
571 static int cmd_RequestCAStore(SSL_CONF_CTX *cctx, const char *value)
572 {
573     if (cctx->canames == NULL)
574         cctx->canames = sk_X509_NAME_new_null();
575     if (cctx->canames == NULL)
576         return 0;
577     return SSL_add_store_cert_subjects_to_stack(cctx->canames, value);
578 }
579
580 static int cmd_ClientCAStore(SSL_CONF_CTX *cctx, const char *value)
581 {
582     return cmd_RequestCAStore(cctx, value);
583 }
584
585 static int cmd_DHParameters(SSL_CONF_CTX *cctx, const char *value)
586 {
587     int rv = 0;
588     EVP_PKEY *dhpkey = NULL;
589     BIO *in = NULL;
590     SSL_CTX *sslctx = (cctx->ssl != NULL) ? cctx->ssl->ctx : cctx->ctx;
591     OSSL_DECODER_CTX *decoderctx = NULL;
592
593     if (cctx->ctx != NULL || cctx->ssl != NULL) {
594         in = BIO_new(BIO_s_file());
595         if (in == NULL)
596             goto end;
597         if (BIO_read_filename(in, value) <= 0)
598             goto end;
599
600         decoderctx
601             = OSSL_DECODER_CTX_new_for_pkey(&dhpkey, "PEM", NULL, "DH",
602                                             OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
603                                             sslctx->libctx, sslctx->propq);
604         if (decoderctx == NULL)
605             goto end;
606         ERR_set_mark();
607         while (!OSSL_DECODER_from_bio(decoderctx, in)
608                && dhpkey == NULL
609                && !BIO_eof(in));
610         OSSL_DECODER_CTX_free(decoderctx);
611
612         if (dhpkey == NULL) {
613             ERR_clear_last_mark();
614             goto end;
615         }
616         ERR_pop_to_mark();
617     } else {
618         return 1;
619     }
620
621     if (cctx->ctx != NULL) {
622         if ((rv = SSL_CTX_set0_tmp_dh_pkey(cctx->ctx, dhpkey)) > 0)
623             dhpkey = NULL;
624     }
625     if (cctx->ssl != NULL) {
626         if ((rv = SSL_set0_tmp_dh_pkey(cctx->ssl, dhpkey)) > 0)
627             dhpkey = NULL;
628     }
629  end:
630     EVP_PKEY_free(dhpkey);
631     BIO_free(in);
632     return rv > 0;
633 }
634
635 static int cmd_RecordPadding(SSL_CONF_CTX *cctx, const char *value)
636 {
637     int rv = 0;
638     int block_size = atoi(value);
639
640     /*
641      * All we care about is a non-negative value,
642      * the setters check the range
643      */
644     if (block_size >= 0) {
645         if (cctx->ctx)
646             rv = SSL_CTX_set_block_padding(cctx->ctx, block_size);
647         if (cctx->ssl)
648             rv = SSL_set_block_padding(cctx->ssl, block_size);
649     }
650     return rv;
651 }
652
653
654 static int cmd_NumTickets(SSL_CONF_CTX *cctx, const char *value)
655 {
656     int rv = 0;
657     int num_tickets = atoi(value);
658
659     if (num_tickets >= 0) {
660         if (cctx->ctx)
661             rv = SSL_CTX_set_num_tickets(cctx->ctx, num_tickets);
662         if (cctx->ssl)
663             rv = SSL_set_num_tickets(cctx->ssl, num_tickets);
664     }
665     return rv;
666 }
667
668 typedef struct {
669     int (*cmd) (SSL_CONF_CTX *cctx, const char *value);
670     const char *str_file;
671     const char *str_cmdline;
672     unsigned short flags;
673     unsigned short value_type;
674 } ssl_conf_cmd_tbl;
675
676 /* Table of supported parameters */
677
678 #define SSL_CONF_CMD(name, cmdopt, flags, type) \
679         {cmd_##name, #name, cmdopt, flags, type}
680
681 #define SSL_CONF_CMD_STRING(name, cmdopt, flags) \
682         SSL_CONF_CMD(name, cmdopt, flags, SSL_CONF_TYPE_STRING)
683
684 #define SSL_CONF_CMD_SWITCH(name, flags) \
685         {0, NULL, name, flags, SSL_CONF_TYPE_NONE}
686
687 /* See apps/include/opt.h if you change this table. */
688 /* The SSL_CONF_CMD_SWITCH should be the same order as ssl_cmd_switches */
689 static const ssl_conf_cmd_tbl ssl_conf_cmds[] = {
690     SSL_CONF_CMD_SWITCH("no_ssl3", 0),
691     SSL_CONF_CMD_SWITCH("no_tls1", 0),
692     SSL_CONF_CMD_SWITCH("no_tls1_1", 0),
693     SSL_CONF_CMD_SWITCH("no_tls1_2", 0),
694     SSL_CONF_CMD_SWITCH("no_tls1_3", 0),
695     SSL_CONF_CMD_SWITCH("bugs", 0),
696     SSL_CONF_CMD_SWITCH("no_comp", 0),
697     SSL_CONF_CMD_SWITCH("comp", 0),
698     SSL_CONF_CMD_SWITCH("ecdh_single", SSL_CONF_FLAG_SERVER),
699     SSL_CONF_CMD_SWITCH("no_ticket", 0),
700     SSL_CONF_CMD_SWITCH("serverpref", SSL_CONF_FLAG_SERVER),
701     SSL_CONF_CMD_SWITCH("legacy_renegotiation", 0),
702     SSL_CONF_CMD_SWITCH("client_renegotiation", SSL_CONF_FLAG_SERVER),
703     SSL_CONF_CMD_SWITCH("legacy_server_connect", SSL_CONF_FLAG_CLIENT),
704     SSL_CONF_CMD_SWITCH("no_renegotiation", 0),
705     SSL_CONF_CMD_SWITCH("no_resumption_on_reneg", SSL_CONF_FLAG_SERVER),
706     SSL_CONF_CMD_SWITCH("no_legacy_server_connect", SSL_CONF_FLAG_CLIENT),
707     SSL_CONF_CMD_SWITCH("allow_no_dhe_kex", 0),
708     SSL_CONF_CMD_SWITCH("prioritize_chacha", SSL_CONF_FLAG_SERVER),
709     SSL_CONF_CMD_SWITCH("strict", 0),
710     SSL_CONF_CMD_SWITCH("no_middlebox", 0),
711     SSL_CONF_CMD_SWITCH("anti_replay", SSL_CONF_FLAG_SERVER),
712     SSL_CONF_CMD_SWITCH("no_anti_replay", SSL_CONF_FLAG_SERVER),
713     SSL_CONF_CMD_SWITCH("no_etm", 0),
714     SSL_CONF_CMD_SWITCH("no_ems", 0),
715     SSL_CONF_CMD_STRING(SignatureAlgorithms, "sigalgs", 0),
716     SSL_CONF_CMD_STRING(ClientSignatureAlgorithms, "client_sigalgs", 0),
717     SSL_CONF_CMD_STRING(Curves, "curves", 0),
718     SSL_CONF_CMD_STRING(Groups, "groups", 0),
719     SSL_CONF_CMD_STRING(ECDHParameters, "named_curve", SSL_CONF_FLAG_SERVER),
720     SSL_CONF_CMD_STRING(CipherString, "cipher", 0),
721     SSL_CONF_CMD_STRING(Ciphersuites, "ciphersuites", 0),
722     SSL_CONF_CMD_STRING(Protocol, NULL, 0),
723     SSL_CONF_CMD_STRING(MinProtocol, "min_protocol", 0),
724     SSL_CONF_CMD_STRING(MaxProtocol, "max_protocol", 0),
725     SSL_CONF_CMD_STRING(Options, NULL, 0),
726     SSL_CONF_CMD_STRING(VerifyMode, NULL, 0),
727     SSL_CONF_CMD(Certificate, "cert", SSL_CONF_FLAG_CERTIFICATE,
728                  SSL_CONF_TYPE_FILE),
729     SSL_CONF_CMD(PrivateKey, "key", SSL_CONF_FLAG_CERTIFICATE,
730                  SSL_CONF_TYPE_FILE),
731     SSL_CONF_CMD(ServerInfoFile, NULL,
732                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
733                  SSL_CONF_TYPE_FILE),
734     SSL_CONF_CMD(ChainCAPath, "chainCApath", SSL_CONF_FLAG_CERTIFICATE,
735                  SSL_CONF_TYPE_DIR),
736     SSL_CONF_CMD(ChainCAFile, "chainCAfile", SSL_CONF_FLAG_CERTIFICATE,
737                  SSL_CONF_TYPE_FILE),
738     SSL_CONF_CMD(ChainCAStore, "chainCAstore", SSL_CONF_FLAG_CERTIFICATE,
739                  SSL_CONF_TYPE_STORE),
740     SSL_CONF_CMD(VerifyCAPath, "verifyCApath", SSL_CONF_FLAG_CERTIFICATE,
741                  SSL_CONF_TYPE_DIR),
742     SSL_CONF_CMD(VerifyCAFile, "verifyCAfile", SSL_CONF_FLAG_CERTIFICATE,
743                  SSL_CONF_TYPE_FILE),
744     SSL_CONF_CMD(VerifyCAStore, "verifyCAstore", SSL_CONF_FLAG_CERTIFICATE,
745                  SSL_CONF_TYPE_STORE),
746     SSL_CONF_CMD(RequestCAFile, "requestCAFile", SSL_CONF_FLAG_CERTIFICATE,
747                  SSL_CONF_TYPE_FILE),
748     SSL_CONF_CMD(ClientCAFile, NULL,
749                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
750                  SSL_CONF_TYPE_FILE),
751     SSL_CONF_CMD(RequestCAPath, NULL, SSL_CONF_FLAG_CERTIFICATE,
752                  SSL_CONF_TYPE_DIR),
753     SSL_CONF_CMD(ClientCAPath, NULL,
754                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
755                  SSL_CONF_TYPE_DIR),
756     SSL_CONF_CMD(RequestCAStore, "requestCAStore", SSL_CONF_FLAG_CERTIFICATE,
757                  SSL_CONF_TYPE_STORE),
758     SSL_CONF_CMD(ClientCAStore, NULL,
759                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
760                  SSL_CONF_TYPE_STORE),
761     SSL_CONF_CMD(DHParameters, "dhparam",
762                  SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
763                  SSL_CONF_TYPE_FILE),
764     SSL_CONF_CMD_STRING(RecordPadding, "record_padding", 0),
765     SSL_CONF_CMD_STRING(NumTickets, "num_tickets", SSL_CONF_FLAG_SERVER),
766 };
767
768 /* Supported switches: must match order of switches in ssl_conf_cmds */
769 static const ssl_switch_tbl ssl_cmd_switches[] = {
770     {SSL_OP_NO_SSLv3, 0},       /* no_ssl3 */
771     {SSL_OP_NO_TLSv1, 0},       /* no_tls1 */
772     {SSL_OP_NO_TLSv1_1, 0},     /* no_tls1_1 */
773     {SSL_OP_NO_TLSv1_2, 0},     /* no_tls1_2 */
774     {SSL_OP_NO_TLSv1_3, 0},     /* no_tls1_3 */
775     {SSL_OP_ALL, 0},            /* bugs */
776     {SSL_OP_NO_COMPRESSION, 0}, /* no_comp */
777     {SSL_OP_NO_COMPRESSION, SSL_TFLAG_INV}, /* comp */
778     {SSL_OP_SINGLE_ECDH_USE, 0}, /* ecdh_single */
779     {SSL_OP_NO_TICKET, 0},      /* no_ticket */
780     {SSL_OP_CIPHER_SERVER_PREFERENCE, 0}, /* serverpref */
781     /* legacy_renegotiation */
782     {SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, 0},
783     /* Allow client renegotiation */
784     {SSL_OP_ALLOW_CLIENT_RENEGOTIATION, 0},
785     /* legacy_server_connect */
786     {SSL_OP_LEGACY_SERVER_CONNECT, 0},
787     /* no_renegotiation */
788     {SSL_OP_NO_RENEGOTIATION, 0},
789     /* no_resumption_on_reneg */
790     {SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, 0},
791     /* no_legacy_server_connect */
792     {SSL_OP_LEGACY_SERVER_CONNECT, SSL_TFLAG_INV},
793     /* allow_no_dhe_kex */
794     {SSL_OP_ALLOW_NO_DHE_KEX, 0},
795     /* chacha reprioritization */
796     {SSL_OP_PRIORITIZE_CHACHA, 0},
797     {SSL_CERT_FLAG_TLS_STRICT, SSL_TFLAG_CERT}, /* strict */
798     /* no_middlebox */
799     {SSL_OP_ENABLE_MIDDLEBOX_COMPAT, SSL_TFLAG_INV},
800     /* anti_replay */
801     {SSL_OP_NO_ANTI_REPLAY, SSL_TFLAG_INV},
802     /* no_anti_replay */
803     {SSL_OP_NO_ANTI_REPLAY, 0},
804     /* no Encrypt-then-Mac */
805     {SSL_OP_NO_ENCRYPT_THEN_MAC, 0},
806     /* no Extended master secret */
807     {SSL_OP_NO_EXTENDED_MASTER_SECRET, 0},
808 };
809
810 static int ssl_conf_cmd_skip_prefix(SSL_CONF_CTX *cctx, const char **pcmd)
811 {
812     if (pcmd == NULL || *pcmd == NULL)
813         return 0;
814     /* If a prefix is set, check and skip */
815     if (cctx->prefix) {
816         if (strlen(*pcmd) <= cctx->prefixlen)
817             return 0;
818         if (cctx->flags & SSL_CONF_FLAG_CMDLINE &&
819             strncmp(*pcmd, cctx->prefix, cctx->prefixlen))
820             return 0;
821         if (cctx->flags & SSL_CONF_FLAG_FILE &&
822             OPENSSL_strncasecmp(*pcmd, cctx->prefix, cctx->prefixlen))
823             return 0;
824         *pcmd += cctx->prefixlen;
825     } else if (cctx->flags & SSL_CONF_FLAG_CMDLINE) {
826         if (**pcmd != '-' || !(*pcmd)[1])
827             return 0;
828         *pcmd += 1;
829     }
830     return 1;
831 }
832
833 /* Determine if a command is allowed according to cctx flags */
834 static int ssl_conf_cmd_allowed(SSL_CONF_CTX *cctx, const ssl_conf_cmd_tbl * t)
835 {
836     unsigned int tfl = t->flags;
837     unsigned int cfl = cctx->flags;
838     if ((tfl & SSL_CONF_FLAG_SERVER) && !(cfl & SSL_CONF_FLAG_SERVER))
839         return 0;
840     if ((tfl & SSL_CONF_FLAG_CLIENT) && !(cfl & SSL_CONF_FLAG_CLIENT))
841         return 0;
842     if ((tfl & SSL_CONF_FLAG_CERTIFICATE)
843         && !(cfl & SSL_CONF_FLAG_CERTIFICATE))
844         return 0;
845     return 1;
846 }
847
848 static const ssl_conf_cmd_tbl *ssl_conf_cmd_lookup(SSL_CONF_CTX *cctx,
849                                                    const char *cmd)
850 {
851     const ssl_conf_cmd_tbl *t;
852     size_t i;
853     if (cmd == NULL)
854         return NULL;
855
856     /* Look for matching parameter name in table */
857     for (i = 0, t = ssl_conf_cmds; i < OSSL_NELEM(ssl_conf_cmds); i++, t++) {
858         if (ssl_conf_cmd_allowed(cctx, t)) {
859             if (cctx->flags & SSL_CONF_FLAG_CMDLINE) {
860                 if (t->str_cmdline && strcmp(t->str_cmdline, cmd) == 0)
861                     return t;
862             }
863             if (cctx->flags & SSL_CONF_FLAG_FILE) {
864                 if (t->str_file && OPENSSL_strcasecmp(t->str_file, cmd) == 0)
865                     return t;
866             }
867         }
868     }
869     return NULL;
870 }
871
872 static int ctrl_switch_option(SSL_CONF_CTX *cctx, const ssl_conf_cmd_tbl * cmd)
873 {
874     /* Find index of command in table */
875     size_t idx = cmd - ssl_conf_cmds;
876     const ssl_switch_tbl *scmd;
877     /* Sanity check index */
878     if (idx >= OSSL_NELEM(ssl_cmd_switches))
879         return 0;
880     /* Obtain switches entry with same index */
881     scmd = ssl_cmd_switches + idx;
882     ssl_set_option(cctx, scmd->name_flags, scmd->option_value, 1);
883     return 1;
884 }
885
886 int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value)
887 {
888     const ssl_conf_cmd_tbl *runcmd;
889     if (cmd == NULL) {
890         ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_NULL_CMD_NAME);
891         return 0;
892     }
893
894     if (!ssl_conf_cmd_skip_prefix(cctx, &cmd))
895         return -2;
896
897     runcmd = ssl_conf_cmd_lookup(cctx, cmd);
898
899     if (runcmd) {
900         int rv;
901         if (runcmd->value_type == SSL_CONF_TYPE_NONE) {
902             return ctrl_switch_option(cctx, runcmd);
903         }
904         if (value == NULL)
905             return -3;
906         rv = runcmd->cmd(cctx, value);
907         if (rv > 0)
908             return 2;
909         if (rv == -2)
910             return -2;
911         if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS)
912             ERR_raise_data(ERR_LIB_SSL, SSL_R_BAD_VALUE,
913                            "cmd=%s, value=%s", cmd, value);
914         return 0;
915     }
916
917     if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS)
918         ERR_raise_data(ERR_LIB_SSL, SSL_R_UNKNOWN_CMD_NAME, "cmd=%s", cmd);
919
920     return -2;
921 }
922
923 int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv)
924 {
925     int rv;
926     const char *arg = NULL, *argn;
927
928     if (pargc != NULL && *pargc == 0)
929         return 0;
930     if (pargc == NULL || *pargc > 0)
931         arg = **pargv;
932     if (arg == NULL)
933         return 0;
934     if (pargc == NULL || *pargc > 1)
935         argn = (*pargv)[1];
936     else
937         argn = NULL;
938     cctx->flags &= ~SSL_CONF_FLAG_FILE;
939     cctx->flags |= SSL_CONF_FLAG_CMDLINE;
940     rv = SSL_CONF_cmd(cctx, arg, argn);
941     if (rv > 0) {
942         /* Success: update pargc, pargv */
943         (*pargv) += rv;
944         if (pargc)
945             (*pargc) -= rv;
946         return rv;
947     }
948     /* Unknown switch: indicate no arguments processed */
949     if (rv == -2)
950         return 0;
951     /* Some error occurred processing command, return fatal error */
952     if (rv == 0)
953         return -1;
954     return rv;
955 }
956
957 int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd)
958 {
959     if (ssl_conf_cmd_skip_prefix(cctx, &cmd)) {
960         const ssl_conf_cmd_tbl *runcmd;
961         runcmd = ssl_conf_cmd_lookup(cctx, cmd);
962         if (runcmd)
963             return runcmd->value_type;
964     }
965     return SSL_CONF_TYPE_UNKNOWN;
966 }
967
968 SSL_CONF_CTX *SSL_CONF_CTX_new(void)
969 {
970     SSL_CONF_CTX *ret = OPENSSL_zalloc(sizeof(*ret));
971
972     return ret;
973 }
974
975 int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx)
976 {
977     /* See if any certificates are missing private keys */
978     size_t i;
979     CERT *c = NULL;
980     if (cctx->ctx)
981         c = cctx->ctx->cert;
982     else if (cctx->ssl)
983         c = cctx->ssl->cert;
984     if (c && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
985         for (i = 0; i < SSL_PKEY_NUM; i++) {
986             const char *p = cctx->cert_filename[i];
987             /*
988              * If missing private key try to load one from certificate file
989              */
990             if (p && !c->pkeys[i].privatekey) {
991                 if (!cmd_PrivateKey(cctx, p))
992                     return 0;
993             }
994         }
995     }
996     if (cctx->canames) {
997         if (cctx->ssl)
998             SSL_set0_CA_list(cctx->ssl, cctx->canames);
999         else if (cctx->ctx)
1000             SSL_CTX_set0_CA_list(cctx->ctx, cctx->canames);
1001         else
1002             sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free);
1003         cctx->canames = NULL;
1004     }
1005     return 1;
1006 }
1007
1008 void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx)
1009 {
1010     if (cctx) {
1011         size_t i;
1012         for (i = 0; i < SSL_PKEY_NUM; i++)
1013             OPENSSL_free(cctx->cert_filename[i]);
1014         OPENSSL_free(cctx->prefix);
1015         sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free);
1016         OPENSSL_free(cctx);
1017     }
1018 }
1019
1020 unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags)
1021 {
1022     cctx->flags |= flags;
1023     return cctx->flags;
1024 }
1025
1026 unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx, unsigned int flags)
1027 {
1028     cctx->flags &= ~flags;
1029     return cctx->flags;
1030 }
1031
1032 int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre)
1033 {
1034     char *tmp = NULL;
1035     if (pre) {
1036         tmp = OPENSSL_strdup(pre);
1037         if (tmp == NULL)
1038             return 0;
1039     }
1040     OPENSSL_free(cctx->prefix);
1041     cctx->prefix = tmp;
1042     if (tmp)
1043         cctx->prefixlen = strlen(tmp);
1044     else
1045         cctx->prefixlen = 0;
1046     return 1;
1047 }
1048
1049 void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl)
1050 {
1051     cctx->ssl = ssl;
1052     cctx->ctx = NULL;
1053     if (ssl) {
1054         cctx->poptions = &ssl->options;
1055         cctx->min_version = &ssl->min_proto_version;
1056         cctx->max_version = &ssl->max_proto_version;
1057         cctx->pcert_flags = &ssl->cert->cert_flags;
1058         cctx->pvfy_flags = &ssl->verify_mode;
1059     } else {
1060         cctx->poptions = NULL;
1061         cctx->min_version = NULL;
1062         cctx->max_version = NULL;
1063         cctx->pcert_flags = NULL;
1064         cctx->pvfy_flags = NULL;
1065     }
1066 }
1067
1068 void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx)
1069 {
1070     cctx->ctx = ctx;
1071     cctx->ssl = NULL;
1072     if (ctx) {
1073         cctx->poptions = &ctx->options;
1074         cctx->min_version = &ctx->min_proto_version;
1075         cctx->max_version = &ctx->max_proto_version;
1076         cctx->pcert_flags = &ctx->cert->cert_flags;
1077         cctx->pvfy_flags = &ctx->verify_mode;
1078     } else {
1079         cctx->poptions = NULL;
1080         cctx->min_version = NULL;
1081         cctx->max_version = NULL;
1082         cctx->pcert_flags = NULL;
1083         cctx->pvfy_flags = NULL;
1084     }
1085 }