Make SSL_{CTX}_set_tmp_ecdh() call SSL_{CTX_}set1_curves()
[openssl.git] / ssl / ssl_cert.c
1 /*
2  * ! \file ssl/ssl_cert.c
3  */
4 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5  * All rights reserved.
6  *
7  * This package is an SSL implementation written
8  * by Eric Young (eay@cryptsoft.com).
9  * The implementation was written so as to conform with Netscapes SSL.
10  *
11  * This library is free for commercial and non-commercial use as long as
12  * the following conditions are aheared to.  The following conditions
13  * apply to all code found in this distribution, be it the RC4, RSA,
14  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
15  * included with this distribution is covered by the same copyright terms
16  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
17  *
18  * Copyright remains Eric Young's, and as such any Copyright notices in
19  * the code are not to be removed.
20  * If this package is used in a product, Eric Young should be given attribution
21  * as the author of the parts of the library used.
22  * This can be in the form of a textual message at program startup or
23  * in documentation (online or textual) provided with the package.
24  *
25  * Redistribution and use in source and binary forms, with or without
26  * modification, are permitted provided that the following conditions
27  * are met:
28  * 1. Redistributions of source code must retain the copyright
29  *    notice, this list of conditions and the following disclaimer.
30  * 2. Redistributions in binary form must reproduce the above copyright
31  *    notice, this list of conditions and the following disclaimer in the
32  *    documentation and/or other materials provided with the distribution.
33  * 3. All advertising materials mentioning features or use of this software
34  *    must display the following acknowledgement:
35  *    "This product includes cryptographic software written by
36  *     Eric Young (eay@cryptsoft.com)"
37  *    The word 'cryptographic' can be left out if the rouines from the library
38  *    being used are not cryptographic related :-).
39  * 4. If you include any Windows specific code (or a derivative thereof) from
40  *    the apps directory (application code) you must include an acknowledgement:
41  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
42  *
43  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  *
55  * The licence and distribution terms for any publically available version or
56  * derivative of this code cannot be changed.  i.e. this code cannot simply be
57  * copied and put under another distribution licence
58  * [including the GNU Public Licence.]
59  */
60 /* ====================================================================
61  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
62  *
63  * Redistribution and use in source and binary forms, with or without
64  * modification, are permitted provided that the following conditions
65  * are met:
66  *
67  * 1. Redistributions of source code must retain the above copyright
68  *    notice, this list of conditions and the following disclaimer.
69  *
70  * 2. Redistributions in binary form must reproduce the above copyright
71  *    notice, this list of conditions and the following disclaimer in
72  *    the documentation and/or other materials provided with the
73  *    distribution.
74  *
75  * 3. All advertising materials mentioning features or use of this
76  *    software must display the following acknowledgment:
77  *    "This product includes software developed by the OpenSSL Project
78  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
79  *
80  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
81  *    endorse or promote products derived from this software without
82  *    prior written permission. For written permission, please contact
83  *    openssl-core@openssl.org.
84  *
85  * 5. Products derived from this software may not be called "OpenSSL"
86  *    nor may "OpenSSL" appear in their names without prior written
87  *    permission of the OpenSSL Project.
88  *
89  * 6. Redistributions of any form whatsoever must retain the following
90  *    acknowledgment:
91  *    "This product includes software developed by the OpenSSL Project
92  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
93  *
94  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
95  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
97  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
98  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
99  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
100  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
101  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
102  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
103  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
104  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
105  * OF THE POSSIBILITY OF SUCH DAMAGE.
106  * ====================================================================
107  *
108  * This product includes cryptographic software written by Eric Young
109  * (eay@cryptsoft.com).  This product includes software written by Tim
110  * Hudson (tjh@cryptsoft.com).
111  *
112  */
113 /* ====================================================================
114  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
115  * ECC cipher suite support in OpenSSL originally developed by
116  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
117  */
118
119 #include <stdio.h>
120
121 #include "e_os.h"
122 #ifndef NO_SYS_TYPES_H
123 # include <sys/types.h>
124 #endif
125
126 #include "internal/o_dir.h"
127 #include <openssl/objects.h>
128 #include <openssl/bio.h>
129 #include <openssl/pem.h>
130 #include <openssl/x509v3.h>
131 #ifndef OPENSSL_NO_DH
132 # include <openssl/dh.h>
133 #endif
134 #include <openssl/bn.h>
135 #include "ssl_locl.h"
136
137 static int ssl_security_default_callback(SSL *s, SSL_CTX *ctx, int op,
138                                          int bits, int nid, void *other,
139                                          void *ex);
140
141 int SSL_get_ex_data_X509_STORE_CTX_idx(void)
142 {
143     static volatile int ssl_x509_store_ctx_idx = -1;
144     int got_write_lock = 0;
145
146     CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
147
148     if (ssl_x509_store_ctx_idx < 0) {
149         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
150         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
151         got_write_lock = 1;
152
153         if (ssl_x509_store_ctx_idx < 0) {
154             ssl_x509_store_ctx_idx =
155                 X509_STORE_CTX_get_ex_new_index(0, "SSL for verify callback",
156                                                 NULL, NULL, NULL);
157         }
158     }
159
160     if (got_write_lock)
161         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
162     else
163         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
164
165     return ssl_x509_store_ctx_idx;
166 }
167
168 CERT *ssl_cert_new(void)
169 {
170     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
171
172     if (ret == NULL) {
173         SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE);
174         return (NULL);
175     }
176
177     ret->key = &(ret->pkeys[SSL_PKEY_RSA_ENC]);
178     ret->references = 1;
179     ret->sec_cb = ssl_security_default_callback;
180     ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
181     ret->sec_ex = NULL;
182     return (ret);
183 }
184
185 CERT *ssl_cert_dup(CERT *cert)
186 {
187     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
188     int i;
189
190     if (ret == NULL) {
191         SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
192         return (NULL);
193     }
194
195     ret->references = 1;
196     ret->key = &ret->pkeys[cert->key - cert->pkeys];
197
198 #ifndef OPENSSL_NO_RSA
199     if (cert->rsa_tmp != NULL) {
200         RSA_up_ref(cert->rsa_tmp);
201         ret->rsa_tmp = cert->rsa_tmp;
202     }
203     ret->rsa_tmp_cb = cert->rsa_tmp_cb;
204 #endif
205
206 #ifndef OPENSSL_NO_DH
207     if (cert->dh_tmp != NULL) {
208         ret->dh_tmp = DHparams_dup(cert->dh_tmp);
209         if (ret->dh_tmp == NULL) {
210             SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_DH_LIB);
211             goto err;
212         }
213         if (cert->dh_tmp->priv_key) {
214             BIGNUM *b = BN_dup(cert->dh_tmp->priv_key);
215             if (!b) {
216                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
217                 goto err;
218             }
219             ret->dh_tmp->priv_key = b;
220         }
221         if (cert->dh_tmp->pub_key) {
222             BIGNUM *b = BN_dup(cert->dh_tmp->pub_key);
223             if (!b) {
224                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
225                 goto err;
226             }
227             ret->dh_tmp->pub_key = b;
228         }
229     }
230     ret->dh_tmp_cb = cert->dh_tmp_cb;
231     ret->dh_tmp_auto = cert->dh_tmp_auto;
232 #endif
233
234 #ifndef OPENSSL_NO_EC
235     ret->ecdh_tmp_auto = cert->ecdh_tmp_auto;
236 #endif
237
238     for (i = 0; i < SSL_PKEY_NUM; i++) {
239         CERT_PKEY *cpk = cert->pkeys + i;
240         CERT_PKEY *rpk = ret->pkeys + i;
241         if (cpk->x509 != NULL) {
242             rpk->x509 = cpk->x509;
243             X509_up_ref(rpk->x509);
244         }
245
246         if (cpk->privatekey != NULL) {
247             rpk->privatekey = cpk->privatekey;
248             CRYPTO_add(&cpk->privatekey->references, 1, CRYPTO_LOCK_EVP_PKEY);
249         }
250
251         if (cpk->chain) {
252             rpk->chain = X509_chain_up_ref(cpk->chain);
253             if (!rpk->chain) {
254                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
255                 goto err;
256             }
257         }
258         if (cert->pkeys[i].serverinfo != NULL) {
259             /* Just copy everything. */
260             ret->pkeys[i].serverinfo =
261                 OPENSSL_malloc(cert->pkeys[i].serverinfo_length);
262             if (ret->pkeys[i].serverinfo == NULL) {
263                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
264                 goto err;
265             }
266             ret->pkeys[i].serverinfo_length =
267                 cert->pkeys[i].serverinfo_length;
268             memcpy(ret->pkeys[i].serverinfo,
269                    cert->pkeys[i].serverinfo,
270                    cert->pkeys[i].serverinfo_length);
271         }
272     }
273
274     /* Configured sigalgs copied across */
275     if (cert->conf_sigalgs) {
276         ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen);
277         if (ret->conf_sigalgs == NULL)
278             goto err;
279         memcpy(ret->conf_sigalgs, cert->conf_sigalgs, cert->conf_sigalgslen);
280         ret->conf_sigalgslen = cert->conf_sigalgslen;
281     } else
282         ret->conf_sigalgs = NULL;
283
284     if (cert->client_sigalgs) {
285         ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen);
286         if (ret->client_sigalgs == NULL)
287             goto err;
288         memcpy(ret->client_sigalgs, cert->client_sigalgs,
289                cert->client_sigalgslen);
290         ret->client_sigalgslen = cert->client_sigalgslen;
291     } else
292         ret->client_sigalgs = NULL;
293     /* Shared sigalgs also NULL */
294     ret->shared_sigalgs = NULL;
295     /* Copy any custom client certificate types */
296     if (cert->ctypes) {
297         ret->ctypes = OPENSSL_malloc(cert->ctype_num);
298         if (ret->ctypes == NULL)
299             goto err;
300         memcpy(ret->ctypes, cert->ctypes, cert->ctype_num);
301         ret->ctype_num = cert->ctype_num;
302     }
303
304     ret->cert_flags = cert->cert_flags;
305
306     ret->cert_cb = cert->cert_cb;
307     ret->cert_cb_arg = cert->cert_cb_arg;
308
309     if (cert->verify_store) {
310         CRYPTO_add(&cert->verify_store->references, 1,
311                    CRYPTO_LOCK_X509_STORE);
312         ret->verify_store = cert->verify_store;
313     }
314
315     if (cert->chain_store) {
316         CRYPTO_add(&cert->chain_store->references, 1, CRYPTO_LOCK_X509_STORE);
317         ret->chain_store = cert->chain_store;
318     }
319
320     ret->sec_cb = cert->sec_cb;
321     ret->sec_level = cert->sec_level;
322     ret->sec_ex = cert->sec_ex;
323
324     if (!custom_exts_copy(&ret->cli_ext, &cert->cli_ext))
325         goto err;
326     if (!custom_exts_copy(&ret->srv_ext, &cert->srv_ext))
327         goto err;
328 #ifndef OPENSSL_NO_PSK
329     if (cert->psk_identity_hint) {
330         ret->psk_identity_hint = BUF_strdup(cert->psk_identity_hint);
331         if (ret->psk_identity_hint == NULL)
332             goto err;
333     }
334 #endif
335     return (ret);
336
337  err:
338     ssl_cert_free(ret);
339
340     return NULL;
341 }
342
343 /* Free up and clear all certificates and chains */
344
345 void ssl_cert_clear_certs(CERT *c)
346 {
347     int i;
348     if (c == NULL)
349         return;
350     for (i = 0; i < SSL_PKEY_NUM; i++) {
351         CERT_PKEY *cpk = c->pkeys + i;
352         X509_free(cpk->x509);
353         cpk->x509 = NULL;
354         EVP_PKEY_free(cpk->privatekey);
355         cpk->privatekey = NULL;
356         sk_X509_pop_free(cpk->chain, X509_free);
357         cpk->chain = NULL;
358         OPENSSL_free(cpk->serverinfo);
359         cpk->serverinfo = NULL;
360         cpk->serverinfo_length = 0;
361     }
362 }
363
364 void ssl_cert_free(CERT *c)
365 {
366     int i;
367
368     if (c == NULL)
369         return;
370
371     i = CRYPTO_add(&c->references, -1, CRYPTO_LOCK_SSL_CERT);
372 #ifdef REF_PRINT
373     REF_PRINT("CERT", c);
374 #endif
375     if (i > 0)
376         return;
377 #ifdef REF_CHECK
378     if (i < 0) {
379         fprintf(stderr, "ssl_cert_free, bad reference count\n");
380         abort();                /* ok */
381     }
382 #endif
383
384 #ifndef OPENSSL_NO_RSA
385     RSA_free(c->rsa_tmp);
386 #endif
387 #ifndef OPENSSL_NO_DH
388     DH_free(c->dh_tmp);
389 #endif
390
391     ssl_cert_clear_certs(c);
392     OPENSSL_free(c->conf_sigalgs);
393     OPENSSL_free(c->client_sigalgs);
394     OPENSSL_free(c->shared_sigalgs);
395     OPENSSL_free(c->ctypes);
396     X509_STORE_free(c->verify_store);
397     X509_STORE_free(c->chain_store);
398     custom_exts_free(&c->cli_ext);
399     custom_exts_free(&c->srv_ext);
400 #ifndef OPENSSL_NO_PSK
401     OPENSSL_free(c->psk_identity_hint);
402 #endif
403     OPENSSL_free(c);
404 }
405
406 int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
407 {
408     int i, r;
409     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
410     if (!cpk)
411         return 0;
412     sk_X509_pop_free(cpk->chain, X509_free);
413     for (i = 0; i < sk_X509_num(chain); i++) {
414         r = ssl_security_cert(s, ctx, sk_X509_value(chain, i), 0, 0);
415         if (r != 1) {
416             SSLerr(SSL_F_SSL_CERT_SET0_CHAIN, r);
417             return 0;
418         }
419     }
420     cpk->chain = chain;
421     return 1;
422 }
423
424 int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
425 {
426     STACK_OF(X509) *dchain;
427     if (!chain)
428         return ssl_cert_set0_chain(s, ctx, NULL);
429     dchain = X509_chain_up_ref(chain);
430     if (!dchain)
431         return 0;
432     if (!ssl_cert_set0_chain(s, ctx, dchain)) {
433         sk_X509_pop_free(dchain, X509_free);
434         return 0;
435     }
436     return 1;
437 }
438
439 int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
440 {
441     int r;
442     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
443     if (!cpk)
444         return 0;
445     r = ssl_security_cert(s, ctx, x, 0, 0);
446     if (r != 1) {
447         SSLerr(SSL_F_SSL_CERT_ADD0_CHAIN_CERT, r);
448         return 0;
449     }
450     if (!cpk->chain)
451         cpk->chain = sk_X509_new_null();
452     if (!cpk->chain || !sk_X509_push(cpk->chain, x))
453         return 0;
454     return 1;
455 }
456
457 int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
458 {
459     if (!ssl_cert_add0_chain_cert(s, ctx, x))
460         return 0;
461     X509_up_ref(x);
462     return 1;
463 }
464
465 int ssl_cert_select_current(CERT *c, X509 *x)
466 {
467     int i;
468     if (x == NULL)
469         return 0;
470     for (i = 0; i < SSL_PKEY_NUM; i++) {
471         CERT_PKEY *cpk = c->pkeys + i;
472         if (cpk->x509 == x && cpk->privatekey) {
473             c->key = cpk;
474             return 1;
475         }
476     }
477
478     for (i = 0; i < SSL_PKEY_NUM; i++) {
479         CERT_PKEY *cpk = c->pkeys + i;
480         if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) {
481             c->key = cpk;
482             return 1;
483         }
484     }
485     return 0;
486 }
487
488 int ssl_cert_set_current(CERT *c, long op)
489 {
490     int i, idx;
491     if (!c)
492         return 0;
493     if (op == SSL_CERT_SET_FIRST)
494         idx = 0;
495     else if (op == SSL_CERT_SET_NEXT) {
496         idx = (int)(c->key - c->pkeys + 1);
497         if (idx >= SSL_PKEY_NUM)
498             return 0;
499     } else
500         return 0;
501     for (i = idx; i < SSL_PKEY_NUM; i++) {
502         CERT_PKEY *cpk = c->pkeys + i;
503         if (cpk->x509 && cpk->privatekey) {
504             c->key = cpk;
505             return 1;
506         }
507     }
508     return 0;
509 }
510
511 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg)
512 {
513     c->cert_cb = cb;
514     c->cert_cb_arg = arg;
515 }
516
517 int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk)
518 {
519     X509 *x;
520     int i;
521     X509_STORE *verify_store;
522     X509_STORE_CTX ctx;
523
524     if (s->cert->verify_store)
525         verify_store = s->cert->verify_store;
526     else
527         verify_store = s->ctx->cert_store;
528
529     if ((sk == NULL) || (sk_X509_num(sk) == 0))
530         return (0);
531
532     x = sk_X509_value(sk, 0);
533     if (!X509_STORE_CTX_init(&ctx, verify_store, x, sk)) {
534         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_X509_LIB);
535         return (0);
536     }
537     /* Set suite B flags if needed */
538     X509_STORE_CTX_set_flags(&ctx, tls1_suiteb(s));
539     X509_STORE_CTX_set_ex_data(&ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s);
540
541     /*
542      * We need to inherit the verify parameters. These can be determined by
543      * the context: if its a server it will verify SSL client certificates or
544      * vice versa.
545      */
546
547     X509_STORE_CTX_set_default(&ctx, s->server ? "ssl_client" : "ssl_server");
548     /*
549      * Anything non-default in "param" should overwrite anything in the ctx.
550      */
551     X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(&ctx), s->param);
552
553     if (s->verify_callback)
554         X509_STORE_CTX_set_verify_cb(&ctx, s->verify_callback);
555
556     if (s->ctx->app_verify_callback != NULL)
557         i = s->ctx->app_verify_callback(&ctx, s->ctx->app_verify_arg);
558     else {
559         i = X509_verify_cert(&ctx);
560 # if 0
561         /* Dummy error calls so mkerr generates them */
562         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_EE_KEY_TOO_SMALL);
563         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_CA_KEY_TOO_SMALL);
564         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_CA_MD_TOO_WEAK);
565 # endif
566         if (i > 0)
567             i = ssl_security_cert_chain(s, ctx.chain, NULL, 1);
568     }
569
570     s->verify_result = ctx.error;
571     X509_STORE_CTX_cleanup(&ctx);
572
573     return (i);
574 }
575
576 static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list,
577                                STACK_OF(X509_NAME) *name_list)
578 {
579     sk_X509_NAME_pop_free(*ca_list, X509_NAME_free);
580     *ca_list = name_list;
581 }
582
583 STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk)
584 {
585     int i;
586     STACK_OF(X509_NAME) *ret;
587     X509_NAME *name;
588
589     ret = sk_X509_NAME_new_null();
590     for (i = 0; i < sk_X509_NAME_num(sk); i++) {
591         name = X509_NAME_dup(sk_X509_NAME_value(sk, i));
592         if ((name == NULL) || !sk_X509_NAME_push(ret, name)) {
593             sk_X509_NAME_pop_free(ret, X509_NAME_free);
594             return (NULL);
595         }
596     }
597     return (ret);
598 }
599
600 void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
601 {
602     set_client_CA_list(&(s->client_CA), name_list);
603 }
604
605 void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
606 {
607     set_client_CA_list(&(ctx->client_CA), name_list);
608 }
609
610 STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx)
611 {
612     return (ctx->client_CA);
613 }
614
615 STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s)
616 {
617     if (!s->server) { /* we are in the client */
618         if (((s->version >> 8) == SSL3_VERSION_MAJOR) && (s->s3 != NULL))
619             return (s->s3->tmp.ca_names);
620         else
621             return (NULL);
622     } else {
623         if (s->client_CA != NULL)
624             return (s->client_CA);
625         else
626             return (s->ctx->client_CA);
627     }
628 }
629
630 static int add_client_CA(STACK_OF(X509_NAME) **sk, X509 *x)
631 {
632     X509_NAME *name;
633
634     if (x == NULL)
635         return (0);
636     if ((*sk == NULL) && ((*sk = sk_X509_NAME_new_null()) == NULL))
637         return (0);
638
639     if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL)
640         return (0);
641
642     if (!sk_X509_NAME_push(*sk, name)) {
643         X509_NAME_free(name);
644         return (0);
645     }
646     return (1);
647 }
648
649 int SSL_add_client_CA(SSL *ssl, X509 *x)
650 {
651     return (add_client_CA(&(ssl->client_CA), x));
652 }
653
654 int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x)
655 {
656     return (add_client_CA(&(ctx->client_CA), x));
657 }
658
659 static int xname_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
660 {
661     return (X509_NAME_cmp(*a, *b));
662 }
663
664 /**
665  * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed;
666  * it doesn't really have anything to do with clients (except that a common use
667  * for a stack of CAs is to send it to the client). Actually, it doesn't have
668  * much to do with CAs, either, since it will load any old cert.
669  * \param file the file containing one or more certs.
670  * \return a ::STACK containing the certs.
671  */
672 STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
673 {
674     BIO *in;
675     X509 *x = NULL;
676     X509_NAME *xn = NULL;
677     STACK_OF(X509_NAME) *ret = NULL, *sk;
678
679     sk = sk_X509_NAME_new(xname_cmp);
680
681     in = BIO_new(BIO_s_file());
682
683     if ((sk == NULL) || (in == NULL)) {
684         SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE);
685         goto err;
686     }
687
688     if (!BIO_read_filename(in, file))
689         goto err;
690
691     for (;;) {
692         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
693             break;
694         if (ret == NULL) {
695             ret = sk_X509_NAME_new_null();
696             if (ret == NULL) {
697                 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE);
698                 goto err;
699             }
700         }
701         if ((xn = X509_get_subject_name(x)) == NULL)
702             goto err;
703         /* check for duplicates */
704         xn = X509_NAME_dup(xn);
705         if (xn == NULL)
706             goto err;
707         if (sk_X509_NAME_find(sk, xn) >= 0)
708             X509_NAME_free(xn);
709         else {
710             sk_X509_NAME_push(sk, xn);
711             sk_X509_NAME_push(ret, xn);
712         }
713     }
714     goto done;
715
716  err:
717     sk_X509_NAME_pop_free(ret, X509_NAME_free);
718     ret = NULL;
719  done:
720     sk_X509_NAME_free(sk);
721     BIO_free(in);
722     X509_free(x);
723     if (ret != NULL)
724         ERR_clear_error();
725     return (ret);
726 }
727
728 /**
729  * Add a file of certs to a stack.
730  * \param stack the stack to add to.
731  * \param file the file to add from. All certs in this file that are not
732  * already in the stack will be added.
733  * \return 1 for success, 0 for failure. Note that in the case of failure some
734  * certs may have been added to \c stack.
735  */
736
737 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
738                                         const char *file)
739 {
740     BIO *in;
741     X509 *x = NULL;
742     X509_NAME *xn = NULL;
743     int ret = 1;
744     int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b);
745
746     oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_cmp);
747
748     in = BIO_new(BIO_s_file());
749
750     if (in == NULL) {
751         SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK,
752                ERR_R_MALLOC_FAILURE);
753         goto err;
754     }
755
756     if (!BIO_read_filename(in, file))
757         goto err;
758
759     for (;;) {
760         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
761             break;
762         if ((xn = X509_get_subject_name(x)) == NULL)
763             goto err;
764         xn = X509_NAME_dup(xn);
765         if (xn == NULL)
766             goto err;
767         if (sk_X509_NAME_find(stack, xn) >= 0)
768             X509_NAME_free(xn);
769         else
770             sk_X509_NAME_push(stack, xn);
771     }
772
773     ERR_clear_error();
774     goto done;
775
776  err:
777         ret = 0;
778  done:
779     BIO_free(in);
780     X509_free(x);
781     (void)sk_X509_NAME_set_cmp_func(stack, oldcmp);
782     return ret;
783 }
784
785 /**
786  * Add a directory of certs to a stack.
787  * \param stack the stack to append to.
788  * \param dir the directory to append from. All files in this directory will be
789  * examined as potential certs. Any that are acceptable to
790  * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be
791  * included.
792  * \return 1 for success, 0 for failure. Note that in the case of failure some
793  * certs may have been added to \c stack.
794  */
795
796 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
797                                        const char *dir)
798 {
799     OPENSSL_DIR_CTX *d = NULL;
800     const char *filename;
801     int ret = 0;
802
803     CRYPTO_w_lock(CRYPTO_LOCK_READDIR);
804
805     /* Note that a side effect is that the CAs will be sorted by name */
806
807     while ((filename = OPENSSL_DIR_read(&d, dir))) {
808         char buf[1024];
809         int r;
810
811         if (strlen(dir) + strlen(filename) + 2 > sizeof buf) {
812             SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,
813                    SSL_R_PATH_TOO_LONG);
814             goto err;
815         }
816 #ifdef OPENSSL_SYS_VMS
817         r = BIO_snprintf(buf, sizeof buf, "%s%s", dir, filename);
818 #else
819         r = BIO_snprintf(buf, sizeof buf, "%s/%s", dir, filename);
820 #endif
821         if (r <= 0 || r >= (int)sizeof(buf))
822             goto err;
823         if (!SSL_add_file_cert_subjects_to_stack(stack, buf))
824             goto err;
825     }
826
827     if (errno) {
828         SYSerr(SYS_F_OPENDIR, get_last_sys_error());
829         ERR_add_error_data(3, "OPENSSL_DIR_read(&ctx, '", dir, "')");
830         SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB);
831         goto err;
832     }
833
834     ret = 1;
835
836  err:
837     if (d)
838         OPENSSL_DIR_end(&d);
839     CRYPTO_w_unlock(CRYPTO_LOCK_READDIR);
840     return ret;
841 }
842
843 /* Add a certificate to a BUF_MEM structure */
844
845 static int ssl_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x)
846 {
847     int n;
848     unsigned char *p;
849
850     n = i2d_X509(x, NULL);
851     if (!BUF_MEM_grow_clean(buf, (int)(n + (*l) + 3))) {
852         SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF, ERR_R_BUF_LIB);
853         return 0;
854     }
855     p = (unsigned char *)&(buf->data[*l]);
856     l2n3(n, p);
857     i2d_X509(x, &p);
858     *l += n + 3;
859
860     return 1;
861 }
862
863 /* Add certificate chain to internal SSL BUF_MEM strcuture */
864 int ssl_add_cert_chain(SSL *s, CERT_PKEY *cpk, unsigned long *l)
865 {
866     BUF_MEM *buf = s->init_buf;
867     int i;
868
869     X509 *x;
870     STACK_OF(X509) *extra_certs;
871     X509_STORE *chain_store;
872
873     /* TLSv1 sends a chain with nothing in it, instead of an alert */
874     if (!BUF_MEM_grow_clean(buf, 10)) {
875         SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_BUF_LIB);
876         return 0;
877     }
878
879     if (!cpk || !cpk->x509)
880         return 1;
881
882     x = cpk->x509;
883
884     /*
885      * If we have a certificate specific chain use it, else use parent ctx.
886      */
887     if (cpk->chain)
888         extra_certs = cpk->chain;
889     else
890         extra_certs = s->ctx->extra_certs;
891
892     if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs)
893         chain_store = NULL;
894     else if (s->cert->chain_store)
895         chain_store = s->cert->chain_store;
896     else
897         chain_store = s->ctx->cert_store;
898
899     if (chain_store) {
900         X509_STORE_CTX xs_ctx;
901
902         if (!X509_STORE_CTX_init(&xs_ctx, chain_store, x, NULL)) {
903             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_X509_LIB);
904             return (0);
905         }
906         /*
907          * It is valid for the chain not to be complete (because normally we
908          * don't include the root cert in the chain). Therefore we deliberately
909          * ignore the error return from this call. We're not actually verifying
910          * the cert - we're just building as much of the chain as we can
911          */
912         X509_verify_cert(&xs_ctx);
913         /* Don't leave errors in the queue */
914         ERR_clear_error();
915         i = ssl_security_cert_chain(s, xs_ctx.chain, NULL, 0);
916         if (i != 1) {
917             X509_STORE_CTX_cleanup(&xs_ctx);
918             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
919             return 0;
920         }
921         for (i = 0; i < sk_X509_num(xs_ctx.chain); i++) {
922             x = sk_X509_value(xs_ctx.chain, i);
923
924             if (!ssl_add_cert_to_buf(buf, l, x)) {
925                 X509_STORE_CTX_cleanup(&xs_ctx);
926                 return 0;
927             }
928         }
929         X509_STORE_CTX_cleanup(&xs_ctx);
930     } else {
931         i = ssl_security_cert_chain(s, extra_certs, x, 0);
932         if (i != 1) {
933             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
934             return 0;
935         }
936         if (!ssl_add_cert_to_buf(buf, l, x))
937             return 0;
938         for (i = 0; i < sk_X509_num(extra_certs); i++) {
939             x = sk_X509_value(extra_certs, i);
940             if (!ssl_add_cert_to_buf(buf, l, x))
941                 return 0;
942         }
943     }
944     return 1;
945 }
946
947 /* Build a certificate chain for current certificate */
948 int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags)
949 {
950     CERT *c = s ? s->cert : ctx->cert;
951     CERT_PKEY *cpk = c->key;
952     X509_STORE *chain_store = NULL;
953     X509_STORE_CTX xs_ctx;
954     STACK_OF(X509) *chain = NULL, *untrusted = NULL;
955     X509 *x;
956     int i, rv = 0;
957     unsigned long error;
958
959     if (!cpk->x509) {
960         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_NO_CERTIFICATE_SET);
961         goto err;
962     }
963     /* Rearranging and check the chain: add everything to a store */
964     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) {
965         chain_store = X509_STORE_new();
966         if (chain_store == NULL)
967             goto err;
968         for (i = 0; i < sk_X509_num(cpk->chain); i++) {
969             x = sk_X509_value(cpk->chain, i);
970             if (!X509_STORE_add_cert(chain_store, x)) {
971                 error = ERR_peek_last_error();
972                 if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
973                     ERR_GET_REASON(error) !=
974                     X509_R_CERT_ALREADY_IN_HASH_TABLE)
975                     goto err;
976                 ERR_clear_error();
977             }
978         }
979         /* Add EE cert too: it might be self signed */
980         if (!X509_STORE_add_cert(chain_store, cpk->x509)) {
981             error = ERR_peek_last_error();
982             if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
983                 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE)
984                 goto err;
985             ERR_clear_error();
986         }
987     } else {
988         if (c->chain_store)
989             chain_store = c->chain_store;
990         else if (s)
991             chain_store = s->ctx->cert_store;
992         else
993             chain_store = ctx->cert_store;
994
995         if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED)
996             untrusted = cpk->chain;
997     }
998
999     if (!X509_STORE_CTX_init(&xs_ctx, chain_store, cpk->x509, untrusted)) {
1000         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_X509_LIB);
1001         goto err;
1002     }
1003     /* Set suite B flags if needed */
1004     X509_STORE_CTX_set_flags(&xs_ctx,
1005                              c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
1006
1007     i = X509_verify_cert(&xs_ctx);
1008     if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) {
1009         if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR)
1010             ERR_clear_error();
1011         i = 1;
1012         rv = 2;
1013     }
1014     if (i > 0)
1015         chain = X509_STORE_CTX_get1_chain(&xs_ctx);
1016     if (i <= 0) {
1017         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_CERTIFICATE_VERIFY_FAILED);
1018         i = X509_STORE_CTX_get_error(&xs_ctx);
1019         ERR_add_error_data(2, "Verify error:",
1020                            X509_verify_cert_error_string(i));
1021
1022         X509_STORE_CTX_cleanup(&xs_ctx);
1023         goto err;
1024     }
1025     X509_STORE_CTX_cleanup(&xs_ctx);
1026     /* Remove EE certificate from chain */
1027     x = sk_X509_shift(chain);
1028     X509_free(x);
1029     if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) {
1030         if (sk_X509_num(chain) > 0) {
1031             /* See if last cert is self signed */
1032             x = sk_X509_value(chain, sk_X509_num(chain) - 1);
1033             if (X509_get_extension_flags(x) & EXFLAG_SS) {
1034                 x = sk_X509_pop(chain);
1035                 X509_free(x);
1036             }
1037         }
1038     }
1039     /*
1040      * Check security level of all CA certificates: EE will have been checked
1041      * already.
1042      */
1043     for (i = 0; i < sk_X509_num(chain); i++) {
1044         x = sk_X509_value(chain, i);
1045         rv = ssl_security_cert(s, ctx, x, 0, 0);
1046         if (rv != 1) {
1047             SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, rv);
1048             sk_X509_pop_free(chain, X509_free);
1049             rv = 0;
1050             goto err;
1051         }
1052     }
1053     sk_X509_pop_free(cpk->chain, X509_free);
1054     cpk->chain = chain;
1055     if (rv == 0)
1056         rv = 1;
1057  err:
1058     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
1059         X509_STORE_free(chain_store);
1060
1061     return rv;
1062 }
1063
1064 int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref)
1065 {
1066     X509_STORE **pstore;
1067     if (chain)
1068         pstore = &c->chain_store;
1069     else
1070         pstore = &c->verify_store;
1071     X509_STORE_free(*pstore);
1072     *pstore = store;
1073     if (ref && store)
1074         CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE);
1075     return 1;
1076 }
1077
1078 static int ssl_security_default_callback(SSL *s, SSL_CTX *ctx, int op,
1079                                          int bits, int nid, void *other,
1080                                          void *ex)
1081 {
1082     int level, minbits;
1083     static const int minbits_table[5] = { 80, 112, 128, 192, 256 };
1084     if (ctx)
1085         level = SSL_CTX_get_security_level(ctx);
1086     else
1087         level = SSL_get_security_level(s);
1088     /* Level 0: anything goes */
1089     if (level <= 0)
1090         return 1;
1091     if (level > 5)
1092         level = 5;
1093     minbits = minbits_table[level - 1];
1094     switch (op) {
1095     case SSL_SECOP_CIPHER_SUPPORTED:
1096     case SSL_SECOP_CIPHER_SHARED:
1097     case SSL_SECOP_CIPHER_CHECK:
1098         {
1099             const SSL_CIPHER *c = other;
1100             /* No ciphers below security level */
1101             if (bits < minbits)
1102                 return 0;
1103             /* No unauthenticated ciphersuites */
1104             if (c->algorithm_auth & SSL_aNULL)
1105                 return 0;
1106             /* No MD5 mac ciphersuites */
1107             if (c->algorithm_mac & SSL_MD5)
1108                 return 0;
1109             /* SHA1 HMAC is 160 bits of security */
1110             if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
1111                 return 0;
1112             /* Level 2: no RC4 */
1113             if (level >= 2 && c->algorithm_enc == SSL_RC4)
1114                 return 0;
1115             /* Level 3: forward secure ciphersuites only */
1116             if (level >= 3 && !(c->algorithm_mkey & (SSL_kEDH | SSL_kEECDH)))
1117                 return 0;
1118             break;
1119         }
1120     case SSL_SECOP_VERSION:
1121         /* SSLv3 not allowed on level 2 */
1122         if (nid <= SSL3_VERSION && level >= 2)
1123             return 0;
1124         /* TLS v1.1 and above only for level 3 */
1125         if (nid <= TLS1_VERSION && level >= 3)
1126             return 0;
1127         /* TLS v1.2 only for level 4 and above */
1128         if (nid <= TLS1_1_VERSION && level >= 4)
1129             return 0;
1130         break;
1131
1132     case SSL_SECOP_COMPRESSION:
1133         if (level >= 2)
1134             return 0;
1135         break;
1136     case SSL_SECOP_TICKET:
1137         if (level >= 3)
1138             return 0;
1139         break;
1140     default:
1141         if (bits < minbits)
1142             return 0;
1143     }
1144     return 1;
1145 }
1146
1147 int ssl_security(SSL *s, int op, int bits, int nid, void *other)
1148 {
1149     return s->cert->sec_cb(s, NULL, op, bits, nid, other, s->cert->sec_ex);
1150 }
1151
1152 int ssl_ctx_security(SSL_CTX *ctx, int op, int bits, int nid, void *other)
1153 {
1154     return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other,
1155                              ctx->cert->sec_ex);
1156 }