Add and use OPENSSL_zalloc
[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->key = &ret->pkeys[cert->key - cert->pkeys];
196
197 #ifndef OPENSSL_NO_RSA
198     if (cert->rsa_tmp != NULL) {
199         RSA_up_ref(cert->rsa_tmp);
200         ret->rsa_tmp = cert->rsa_tmp;
201     }
202     ret->rsa_tmp_cb = cert->rsa_tmp_cb;
203 #endif
204
205 #ifndef OPENSSL_NO_DH
206     if (cert->dh_tmp != NULL) {
207         ret->dh_tmp = DHparams_dup(cert->dh_tmp);
208         if (ret->dh_tmp == NULL) {
209             SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_DH_LIB);
210             goto err;
211         }
212         if (cert->dh_tmp->priv_key) {
213             BIGNUM *b = BN_dup(cert->dh_tmp->priv_key);
214             if (!b) {
215                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
216                 goto err;
217             }
218             ret->dh_tmp->priv_key = b;
219         }
220         if (cert->dh_tmp->pub_key) {
221             BIGNUM *b = BN_dup(cert->dh_tmp->pub_key);
222             if (!b) {
223                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
224                 goto err;
225             }
226             ret->dh_tmp->pub_key = b;
227         }
228     }
229     ret->dh_tmp_cb = cert->dh_tmp_cb;
230     ret->dh_tmp_auto = cert->dh_tmp_auto;
231 #endif
232
233 #ifndef OPENSSL_NO_EC
234     if (cert->ecdh_tmp) {
235         ret->ecdh_tmp = EC_KEY_dup(cert->ecdh_tmp);
236         if (ret->ecdh_tmp == NULL) {
237             SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_EC_LIB);
238             goto err;
239         }
240     }
241     ret->ecdh_tmp_cb = cert->ecdh_tmp_cb;
242     ret->ecdh_tmp_auto = cert->ecdh_tmp_auto;
243 #endif
244
245     for (i = 0; i < SSL_PKEY_NUM; i++) {
246         CERT_PKEY *cpk = cert->pkeys + i;
247         CERT_PKEY *rpk = ret->pkeys + i;
248         if (cpk->x509 != NULL) {
249             rpk->x509 = cpk->x509;
250             X509_up_ref(rpk->x509);
251         }
252
253         if (cpk->privatekey != NULL) {
254             rpk->privatekey = cpk->privatekey;
255             CRYPTO_add(&cpk->privatekey->references, 1, CRYPTO_LOCK_EVP_PKEY);
256         }
257
258         if (cpk->chain) {
259             rpk->chain = X509_chain_up_ref(cpk->chain);
260             if (!rpk->chain) {
261                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
262                 goto err;
263             }
264         }
265         if (cert->pkeys[i].serverinfo != NULL) {
266             /* Just copy everything. */
267             ret->pkeys[i].serverinfo =
268                 OPENSSL_malloc(cert->pkeys[i].serverinfo_length);
269             if (ret->pkeys[i].serverinfo == NULL) {
270                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
271                 goto err;
272             }
273             ret->pkeys[i].serverinfo_length =
274                 cert->pkeys[i].serverinfo_length;
275             memcpy(ret->pkeys[i].serverinfo,
276                    cert->pkeys[i].serverinfo,
277                    cert->pkeys[i].serverinfo_length);
278         }
279     }
280
281     ret->references = 1;
282     /* Configured sigalgs copied across */
283     if (cert->conf_sigalgs) {
284         ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen);
285         if (!ret->conf_sigalgs)
286             goto err;
287         memcpy(ret->conf_sigalgs, cert->conf_sigalgs, cert->conf_sigalgslen);
288         ret->conf_sigalgslen = cert->conf_sigalgslen;
289     } else
290         ret->conf_sigalgs = NULL;
291
292     if (cert->client_sigalgs) {
293         ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen);
294         if (!ret->client_sigalgs)
295             goto err;
296         memcpy(ret->client_sigalgs, cert->client_sigalgs,
297                cert->client_sigalgslen);
298         ret->client_sigalgslen = cert->client_sigalgslen;
299     } else
300         ret->client_sigalgs = NULL;
301     /* Shared sigalgs also NULL */
302     ret->shared_sigalgs = NULL;
303     /* Copy any custom client certificate types */
304     if (cert->ctypes) {
305         ret->ctypes = OPENSSL_malloc(cert->ctype_num);
306         if (!ret->ctypes)
307             goto err;
308         memcpy(ret->ctypes, cert->ctypes, cert->ctype_num);
309         ret->ctype_num = cert->ctype_num;
310     }
311
312     ret->cert_flags = cert->cert_flags;
313
314     ret->cert_cb = cert->cert_cb;
315     ret->cert_cb_arg = cert->cert_cb_arg;
316
317     if (cert->verify_store) {
318         CRYPTO_add(&cert->verify_store->references, 1,
319                    CRYPTO_LOCK_X509_STORE);
320         ret->verify_store = cert->verify_store;
321     }
322
323     if (cert->chain_store) {
324         CRYPTO_add(&cert->chain_store->references, 1, CRYPTO_LOCK_X509_STORE);
325         ret->chain_store = cert->chain_store;
326     }
327
328     ret->sec_cb = cert->sec_cb;
329     ret->sec_level = cert->sec_level;
330     ret->sec_ex = cert->sec_ex;
331
332     if (!custom_exts_copy(&ret->cli_ext, &cert->cli_ext))
333         goto err;
334     if (!custom_exts_copy(&ret->srv_ext, &cert->srv_ext))
335         goto err;
336
337     return (ret);
338
339  err:
340     ssl_cert_free(ret);
341
342     return NULL;
343 }
344
345 /* Free up and clear all certificates and chains */
346
347 void ssl_cert_clear_certs(CERT *c)
348 {
349     int i;
350     if (c == NULL)
351         return;
352     for (i = 0; i < SSL_PKEY_NUM; i++) {
353         CERT_PKEY *cpk = c->pkeys + i;
354         X509_free(cpk->x509);
355         cpk->x509 = NULL;
356         EVP_PKEY_free(cpk->privatekey);
357         cpk->privatekey = NULL;
358         sk_X509_pop_free(cpk->chain, X509_free);
359         cpk->chain = NULL;
360         OPENSSL_free(cpk->serverinfo);
361         cpk->serverinfo = NULL;
362         cpk->serverinfo_length = 0;
363     }
364 }
365
366 void ssl_cert_free(CERT *c)
367 {
368     int i;
369
370     if (c == NULL)
371         return;
372
373     i = CRYPTO_add(&c->references, -1, CRYPTO_LOCK_SSL_CERT);
374 #ifdef REF_PRINT
375     REF_PRINT("CERT", c);
376 #endif
377     if (i > 0)
378         return;
379 #ifdef REF_CHECK
380     if (i < 0) {
381         fprintf(stderr, "ssl_cert_free, bad reference count\n");
382         abort();                /* ok */
383     }
384 #endif
385
386 #ifndef OPENSSL_NO_RSA
387     RSA_free(c->rsa_tmp);
388 #endif
389 #ifndef OPENSSL_NO_DH
390     DH_free(c->dh_tmp);
391 #endif
392 #ifndef OPENSSL_NO_EC
393     EC_KEY_free(c->ecdh_tmp);
394 #endif
395
396     ssl_cert_clear_certs(c);
397     OPENSSL_free(c->conf_sigalgs);
398     OPENSSL_free(c->client_sigalgs);
399     OPENSSL_free(c->shared_sigalgs);
400     OPENSSL_free(c->ctypes);
401     X509_STORE_free(c->verify_store);
402     X509_STORE_free(c->chain_store);
403     custom_exts_free(&c->cli_ext);
404     custom_exts_free(&c->srv_ext);
405     OPENSSL_free(c);
406 }
407
408 int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
409 {
410     int i, r;
411     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
412     if (!cpk)
413         return 0;
414     sk_X509_pop_free(cpk->chain, X509_free);
415     for (i = 0; i < sk_X509_num(chain); i++) {
416         r = ssl_security_cert(s, ctx, sk_X509_value(chain, i), 0, 0);
417         if (r != 1) {
418             SSLerr(SSL_F_SSL_CERT_SET0_CHAIN, r);
419             return 0;
420         }
421     }
422     cpk->chain = chain;
423     return 1;
424 }
425
426 int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
427 {
428     STACK_OF(X509) *dchain;
429     if (!chain)
430         return ssl_cert_set0_chain(s, ctx, NULL);
431     dchain = X509_chain_up_ref(chain);
432     if (!dchain)
433         return 0;
434     if (!ssl_cert_set0_chain(s, ctx, dchain)) {
435         sk_X509_pop_free(dchain, X509_free);
436         return 0;
437     }
438     return 1;
439 }
440
441 int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
442 {
443     int r;
444     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
445     if (!cpk)
446         return 0;
447     r = ssl_security_cert(s, ctx, x, 0, 0);
448     if (r != 1) {
449         SSLerr(SSL_F_SSL_CERT_ADD0_CHAIN_CERT, r);
450         return 0;
451     }
452     if (!cpk->chain)
453         cpk->chain = sk_X509_new_null();
454     if (!cpk->chain || !sk_X509_push(cpk->chain, x))
455         return 0;
456     return 1;
457 }
458
459 int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
460 {
461     if (!ssl_cert_add0_chain_cert(s, ctx, x))
462         return 0;
463     X509_up_ref(x);
464     return 1;
465 }
466
467 int ssl_cert_select_current(CERT *c, X509 *x)
468 {
469     int i;
470     if (x == NULL)
471         return 0;
472     for (i = 0; i < SSL_PKEY_NUM; i++) {
473         CERT_PKEY *cpk = c->pkeys + i;
474         if (cpk->x509 == x && cpk->privatekey) {
475             c->key = cpk;
476             return 1;
477         }
478     }
479
480     for (i = 0; i < SSL_PKEY_NUM; i++) {
481         CERT_PKEY *cpk = c->pkeys + i;
482         if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) {
483             c->key = cpk;
484             return 1;
485         }
486     }
487     return 0;
488 }
489
490 int ssl_cert_set_current(CERT *c, long op)
491 {
492     int i, idx;
493     if (!c)
494         return 0;
495     if (op == SSL_CERT_SET_FIRST)
496         idx = 0;
497     else if (op == SSL_CERT_SET_NEXT) {
498         idx = (int)(c->key - c->pkeys + 1);
499         if (idx >= SSL_PKEY_NUM)
500             return 0;
501     } else
502         return 0;
503     for (i = idx; i < SSL_PKEY_NUM; i++) {
504         CERT_PKEY *cpk = c->pkeys + i;
505         if (cpk->x509 && cpk->privatekey) {
506             c->key = cpk;
507             return 1;
508         }
509     }
510     return 0;
511 }
512
513 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg)
514 {
515     c->cert_cb = cb;
516     c->cert_cb_arg = arg;
517 }
518
519 int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk)
520 {
521     X509 *x;
522     int i;
523     X509_STORE *verify_store;
524     X509_STORE_CTX ctx;
525
526     if (s->cert->verify_store)
527         verify_store = s->cert->verify_store;
528     else
529         verify_store = s->ctx->cert_store;
530
531     if ((sk == NULL) || (sk_X509_num(sk) == 0))
532         return (0);
533
534     x = sk_X509_value(sk, 0);
535     if (!X509_STORE_CTX_init(&ctx, verify_store, x, sk)) {
536         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_X509_LIB);
537         return (0);
538     }
539     /* Set suite B flags if needed */
540     X509_STORE_CTX_set_flags(&ctx, tls1_suiteb(s));
541     X509_STORE_CTX_set_ex_data(&ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s);
542
543     /*
544      * We need to inherit the verify parameters. These can be determined by
545      * the context: if its a server it will verify SSL client certificates or
546      * vice versa.
547      */
548
549     X509_STORE_CTX_set_default(&ctx, s->server ? "ssl_client" : "ssl_server");
550     /*
551      * Anything non-default in "param" should overwrite anything in the ctx.
552      */
553     X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(&ctx), s->param);
554
555     if (s->verify_callback)
556         X509_STORE_CTX_set_verify_cb(&ctx, s->verify_callback);
557
558     if (s->ctx->app_verify_callback != NULL)
559         i = s->ctx->app_verify_callback(&ctx, s->ctx->app_verify_arg);
560     else {
561         i = X509_verify_cert(&ctx);
562 # if 0
563         /* Dummy error calls so mkerr generates them */
564         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_EE_KEY_TOO_SMALL);
565         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_CA_KEY_TOO_SMALL);
566         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, SSL_R_CA_MD_TOO_WEAK);
567 # endif
568         if (i > 0)
569             i = ssl_security_cert_chain(s, ctx.chain, NULL, 1);
570     }
571
572     s->verify_result = ctx.error;
573     X509_STORE_CTX_cleanup(&ctx);
574
575     return (i);
576 }
577
578 static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list,
579                                STACK_OF(X509_NAME) *name_list)
580 {
581     sk_X509_NAME_pop_free(*ca_list, X509_NAME_free);
582     *ca_list = name_list;
583 }
584
585 STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk)
586 {
587     int i;
588     STACK_OF(X509_NAME) *ret;
589     X509_NAME *name;
590
591     ret = sk_X509_NAME_new_null();
592     for (i = 0; i < sk_X509_NAME_num(sk); i++) {
593         name = X509_NAME_dup(sk_X509_NAME_value(sk, i));
594         if ((name == NULL) || !sk_X509_NAME_push(ret, name)) {
595             sk_X509_NAME_pop_free(ret, X509_NAME_free);
596             return (NULL);
597         }
598     }
599     return (ret);
600 }
601
602 void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
603 {
604     set_client_CA_list(&(s->client_CA), name_list);
605 }
606
607 void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
608 {
609     set_client_CA_list(&(ctx->client_CA), name_list);
610 }
611
612 STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx)
613 {
614     return (ctx->client_CA);
615 }
616
617 STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s)
618 {
619     if (s->type == SSL_ST_CONNECT) { /* we are in the client */
620         if (((s->version >> 8) == SSL3_VERSION_MAJOR) && (s->s3 != NULL))
621             return (s->s3->tmp.ca_names);
622         else
623             return (NULL);
624     } else {
625         if (s->client_CA != NULL)
626             return (s->client_CA);
627         else
628             return (s->ctx->client_CA);
629     }
630 }
631
632 static int add_client_CA(STACK_OF(X509_NAME) **sk, X509 *x)
633 {
634     X509_NAME *name;
635
636     if (x == NULL)
637         return (0);
638     if ((*sk == NULL) && ((*sk = sk_X509_NAME_new_null()) == NULL))
639         return (0);
640
641     if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL)
642         return (0);
643
644     if (!sk_X509_NAME_push(*sk, name)) {
645         X509_NAME_free(name);
646         return (0);
647     }
648     return (1);
649 }
650
651 int SSL_add_client_CA(SSL *ssl, X509 *x)
652 {
653     return (add_client_CA(&(ssl->client_CA), x));
654 }
655
656 int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x)
657 {
658     return (add_client_CA(&(ctx->client_CA), x));
659 }
660
661 static int xname_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
662 {
663     return (X509_NAME_cmp(*a, *b));
664 }
665
666 #ifndef OPENSSL_NO_STDIO
667 /**
668  * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed;
669  * it doesn't really have anything to do with clients (except that a common use
670  * for a stack of CAs is to send it to the client). Actually, it doesn't have
671  * much to do with CAs, either, since it will load any old cert.
672  * \param file the file containing one or more certs.
673  * \return a ::STACK containing the certs.
674  */
675 STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
676 {
677     BIO *in;
678     X509 *x = NULL;
679     X509_NAME *xn = NULL;
680     STACK_OF(X509_NAME) *ret = NULL, *sk;
681
682     sk = sk_X509_NAME_new(xname_cmp);
683
684     in = BIO_new(BIO_s_file_internal());
685
686     if ((sk == NULL) || (in == NULL)) {
687         SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE);
688         goto err;
689     }
690
691     if (!BIO_read_filename(in, file))
692         goto err;
693
694     for (;;) {
695         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
696             break;
697         if (ret == NULL) {
698             ret = sk_X509_NAME_new_null();
699             if (ret == NULL) {
700                 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE);
701                 goto err;
702             }
703         }
704         if ((xn = X509_get_subject_name(x)) == NULL)
705             goto err;
706         /* check for duplicates */
707         xn = X509_NAME_dup(xn);
708         if (xn == NULL)
709             goto err;
710         if (sk_X509_NAME_find(sk, xn) >= 0)
711             X509_NAME_free(xn);
712         else {
713             sk_X509_NAME_push(sk, xn);
714             sk_X509_NAME_push(ret, xn);
715         }
716     }
717     goto done;
718
719  err:
720     sk_X509_NAME_pop_free(ret, X509_NAME_free);
721     ret = NULL;
722  done:
723     sk_X509_NAME_free(sk);
724     BIO_free(in);
725     X509_free(x);
726     if (ret != NULL)
727         ERR_clear_error();
728     return (ret);
729 }
730 #endif
731
732 /**
733  * Add a file of certs to a stack.
734  * \param stack the stack to add to.
735  * \param file the file to add from. All certs in this file that are not
736  * already in the stack will be added.
737  * \return 1 for success, 0 for failure. Note that in the case of failure some
738  * certs may have been added to \c stack.
739  */
740
741 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
742                                         const char *file)
743 {
744     BIO *in;
745     X509 *x = NULL;
746     X509_NAME *xn = NULL;
747     int ret = 1;
748     int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b);
749
750     oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_cmp);
751
752     in = BIO_new(BIO_s_file_internal());
753
754     if (in == NULL) {
755         SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK,
756                ERR_R_MALLOC_FAILURE);
757         goto err;
758     }
759
760     if (!BIO_read_filename(in, file))
761         goto err;
762
763     for (;;) {
764         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
765             break;
766         if ((xn = X509_get_subject_name(x)) == NULL)
767             goto err;
768         xn = X509_NAME_dup(xn);
769         if (xn == NULL)
770             goto err;
771         if (sk_X509_NAME_find(stack, xn) >= 0)
772             X509_NAME_free(xn);
773         else
774             sk_X509_NAME_push(stack, xn);
775     }
776
777     ERR_clear_error();
778     goto done;
779
780  err:
781         ret = 0;
782  done:
783     BIO_free(in);
784     X509_free(x);
785     (void)sk_X509_NAME_set_cmp_func(stack, oldcmp);
786     return ret;
787 }
788
789 /**
790  * Add a directory of certs to a stack.
791  * \param stack the stack to append to.
792  * \param dir the directory to append from. All files in this directory will be
793  * examined as potential certs. Any that are acceptable to
794  * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be
795  * included.
796  * \return 1 for success, 0 for failure. Note that in the case of failure some
797  * certs may have been added to \c stack.
798  */
799
800 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
801                                        const char *dir)
802 {
803     OPENSSL_DIR_CTX *d = NULL;
804     const char *filename;
805     int ret = 0;
806
807     CRYPTO_w_lock(CRYPTO_LOCK_READDIR);
808
809     /* Note that a side effect is that the CAs will be sorted by name */
810
811     while ((filename = OPENSSL_DIR_read(&d, dir))) {
812         char buf[1024];
813         int r;
814
815         if (strlen(dir) + strlen(filename) + 2 > sizeof buf) {
816             SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,
817                    SSL_R_PATH_TOO_LONG);
818             goto err;
819         }
820 #ifdef OPENSSL_SYS_VMS
821         r = BIO_snprintf(buf, sizeof buf, "%s%s", dir, filename);
822 #else
823         r = BIO_snprintf(buf, sizeof buf, "%s/%s", dir, filename);
824 #endif
825         if (r <= 0 || r >= (int)sizeof(buf))
826             goto err;
827         if (!SSL_add_file_cert_subjects_to_stack(stack, buf))
828             goto err;
829     }
830
831     if (errno) {
832         SYSerr(SYS_F_OPENDIR, get_last_sys_error());
833         ERR_add_error_data(3, "OPENSSL_DIR_read(&ctx, '", dir, "')");
834         SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB);
835         goto err;
836     }
837
838     ret = 1;
839
840  err:
841     if (d)
842         OPENSSL_DIR_end(&d);
843     CRYPTO_w_unlock(CRYPTO_LOCK_READDIR);
844     return ret;
845 }
846
847 /* Add a certificate to a BUF_MEM structure */
848
849 static int ssl_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x)
850 {
851     int n;
852     unsigned char *p;
853
854     n = i2d_X509(x, NULL);
855     if (!BUF_MEM_grow_clean(buf, (int)(n + (*l) + 3))) {
856         SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF, ERR_R_BUF_LIB);
857         return 0;
858     }
859     p = (unsigned char *)&(buf->data[*l]);
860     l2n3(n, p);
861     i2d_X509(x, &p);
862     *l += n + 3;
863
864     return 1;
865 }
866
867 /* Add certificate chain to internal SSL BUF_MEM strcuture */
868 int ssl_add_cert_chain(SSL *s, CERT_PKEY *cpk, unsigned long *l)
869 {
870     BUF_MEM *buf = s->init_buf;
871     int i;
872
873     X509 *x;
874     STACK_OF(X509) *extra_certs;
875     X509_STORE *chain_store;
876
877     /* TLSv1 sends a chain with nothing in it, instead of an alert */
878     if (!BUF_MEM_grow_clean(buf, 10)) {
879         SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_BUF_LIB);
880         return 0;
881     }
882
883     if (!cpk || !cpk->x509)
884         return 1;
885
886     x = cpk->x509;
887
888     /*
889      * If we have a certificate specific chain use it, else use parent ctx.
890      */
891     if (cpk->chain)
892         extra_certs = cpk->chain;
893     else
894         extra_certs = s->ctx->extra_certs;
895
896     if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs)
897         chain_store = NULL;
898     else if (s->cert->chain_store)
899         chain_store = s->cert->chain_store;
900     else
901         chain_store = s->ctx->cert_store;
902
903     if (chain_store) {
904         X509_STORE_CTX xs_ctx;
905
906         if (!X509_STORE_CTX_init(&xs_ctx, chain_store, x, NULL)) {
907             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_X509_LIB);
908             return (0);
909         }
910         X509_verify_cert(&xs_ctx);
911         /* Don't leave errors in the queue */
912         ERR_clear_error();
913         i = ssl_security_cert_chain(s, xs_ctx.chain, NULL, 0);
914         if (i != 1) {
915             X509_STORE_CTX_cleanup(&xs_ctx);
916             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
917             return 0;
918         }
919         for (i = 0; i < sk_X509_num(xs_ctx.chain); i++) {
920             x = sk_X509_value(xs_ctx.chain, i);
921
922             if (!ssl_add_cert_to_buf(buf, l, x)) {
923                 X509_STORE_CTX_cleanup(&xs_ctx);
924                 return 0;
925             }
926         }
927         X509_STORE_CTX_cleanup(&xs_ctx);
928     } else {
929         i = ssl_security_cert_chain(s, extra_certs, x, 0);
930         if (i != 1) {
931             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
932             return 0;
933         }
934         if (!ssl_add_cert_to_buf(buf, l, x))
935             return 0;
936         for (i = 0; i < sk_X509_num(extra_certs); i++) {
937             x = sk_X509_value(extra_certs, i);
938             if (!ssl_add_cert_to_buf(buf, l, x))
939                 return 0;
940         }
941     }
942     return 1;
943 }
944
945 /* Build a certificate chain for current certificate */
946 int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags)
947 {
948     CERT *c = s ? s->cert : ctx->cert;
949     CERT_PKEY *cpk = c->key;
950     X509_STORE *chain_store = NULL;
951     X509_STORE_CTX xs_ctx;
952     STACK_OF(X509) *chain = NULL, *untrusted = NULL;
953     X509 *x;
954     int i, rv = 0;
955     unsigned long error;
956
957     if (!cpk->x509) {
958         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_NO_CERTIFICATE_SET);
959         goto err;
960     }
961     /* Rearranging and check the chain: add everything to a store */
962     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) {
963         chain_store = X509_STORE_new();
964         if (!chain_store)
965             goto err;
966         for (i = 0; i < sk_X509_num(cpk->chain); i++) {
967             x = sk_X509_value(cpk->chain, i);
968             if (!X509_STORE_add_cert(chain_store, x)) {
969                 error = ERR_peek_last_error();
970                 if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
971                     ERR_GET_REASON(error) !=
972                     X509_R_CERT_ALREADY_IN_HASH_TABLE)
973                     goto err;
974                 ERR_clear_error();
975             }
976         }
977         /* Add EE cert too: it might be self signed */
978         if (!X509_STORE_add_cert(chain_store, cpk->x509)) {
979             error = ERR_peek_last_error();
980             if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
981                 ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE)
982                 goto err;
983             ERR_clear_error();
984         }
985     } else {
986         if (c->chain_store)
987             chain_store = c->chain_store;
988         else if (s)
989             chain_store = s->ctx->cert_store;
990         else
991             chain_store = ctx->cert_store;
992
993         if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED)
994             untrusted = cpk->chain;
995     }
996
997     if (!X509_STORE_CTX_init(&xs_ctx, chain_store, cpk->x509, untrusted)) {
998         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_X509_LIB);
999         goto err;
1000     }
1001     /* Set suite B flags if needed */
1002     X509_STORE_CTX_set_flags(&xs_ctx,
1003                              c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
1004
1005     i = X509_verify_cert(&xs_ctx);
1006     if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) {
1007         if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR)
1008             ERR_clear_error();
1009         i = 1;
1010         rv = 2;
1011     }
1012     if (i > 0)
1013         chain = X509_STORE_CTX_get1_chain(&xs_ctx);
1014     if (i <= 0) {
1015         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_CERTIFICATE_VERIFY_FAILED);
1016         i = X509_STORE_CTX_get_error(&xs_ctx);
1017         ERR_add_error_data(2, "Verify error:",
1018                            X509_verify_cert_error_string(i));
1019
1020         X509_STORE_CTX_cleanup(&xs_ctx);
1021         goto err;
1022     }
1023     X509_STORE_CTX_cleanup(&xs_ctx);
1024     /* Remove EE certificate from chain */
1025     x = sk_X509_shift(chain);
1026     X509_free(x);
1027     if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) {
1028         if (sk_X509_num(chain) > 0) {
1029             /* See if last cert is self signed */
1030             x = sk_X509_value(chain, sk_X509_num(chain) - 1);
1031             X509_check_purpose(x, -1, 0);
1032             if (x->ex_flags & EXFLAG_SS) {
1033                 x = sk_X509_pop(chain);
1034                 X509_free(x);
1035             }
1036         }
1037     }
1038     /*
1039      * Check security level of all CA certificates: EE will have been checked
1040      * already.
1041      */
1042     for (i = 0; i < sk_X509_num(chain); i++) {
1043         x = sk_X509_value(chain, i);
1044         rv = ssl_security_cert(s, ctx, x, 0, 0);
1045         if (rv != 1) {
1046             SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, rv);
1047             sk_X509_pop_free(chain, X509_free);
1048             rv = 0;
1049             goto err;
1050         }
1051     }
1052     sk_X509_pop_free(cpk->chain, X509_free);
1053     cpk->chain = chain;
1054     if (rv == 0)
1055         rv = 1;
1056  err:
1057     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
1058         X509_STORE_free(chain_store);
1059
1060     return rv;
1061 }
1062
1063 int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref)
1064 {
1065     X509_STORE **pstore;
1066     if (chain)
1067         pstore = &c->chain_store;
1068     else
1069         pstore = &c->verify_store;
1070     X509_STORE_free(*pstore);
1071     *pstore = store;
1072     if (ref && store)
1073         CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE);
1074     return 1;
1075 }
1076
1077 static int ssl_security_default_callback(SSL *s, SSL_CTX *ctx, int op,
1078                                          int bits, int nid, void *other,
1079                                          void *ex)
1080 {
1081     int level, minbits;
1082     static const int minbits_table[5] = { 80, 112, 128, 192, 256 };
1083     if (ctx)
1084         level = SSL_CTX_get_security_level(ctx);
1085     else
1086         level = SSL_get_security_level(s);
1087     /* Level 0: anything goes */
1088     if (level <= 0)
1089         return 1;
1090     if (level > 5)
1091         level = 5;
1092     minbits = minbits_table[level - 1];
1093     switch (op) {
1094     case SSL_SECOP_CIPHER_SUPPORTED:
1095     case SSL_SECOP_CIPHER_SHARED:
1096     case SSL_SECOP_CIPHER_CHECK:
1097         {
1098             const SSL_CIPHER *c = other;
1099             /* No ciphers below security level */
1100             if (bits < minbits)
1101                 return 0;
1102             /* No unauthenticated ciphersuites */
1103             if (c->algorithm_auth & SSL_aNULL)
1104                 return 0;
1105             /* No MD5 mac ciphersuites */
1106             if (c->algorithm_mac & SSL_MD5)
1107                 return 0;
1108             /* SHA1 HMAC is 160 bits of security */
1109             if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
1110                 return 0;
1111             /* Level 2: no RC4 */
1112             if (level >= 2 && c->algorithm_enc == SSL_RC4)
1113                 return 0;
1114             /* Level 3: forward secure ciphersuites only */
1115             if (level >= 3 && !(c->algorithm_mkey & (SSL_kEDH | SSL_kEECDH)))
1116                 return 0;
1117             break;
1118         }
1119     case SSL_SECOP_VERSION:
1120         /* SSLv3 not allowed on level 2 */
1121         if (nid <= SSL3_VERSION && level >= 2)
1122             return 0;
1123         /* TLS v1.1 and above only for level 3 */
1124         if (nid <= TLS1_VERSION && level >= 3)
1125             return 0;
1126         /* TLS v1.2 only for level 4 and above */
1127         if (nid <= TLS1_1_VERSION && level >= 4)
1128             return 0;
1129         break;
1130
1131     case SSL_SECOP_COMPRESSION:
1132         if (level >= 2)
1133             return 0;
1134         break;
1135     case SSL_SECOP_TICKET:
1136         if (level >= 3)
1137             return 0;
1138         break;
1139     default:
1140         if (bits < minbits)
1141             return 0;
1142     }
1143     return 1;
1144 }
1145
1146 int ssl_security(SSL *s, int op, int bits, int nid, void *other)
1147 {
1148     return s->cert->sec_cb(s, NULL, op, bits, nid, other, s->cert->sec_ex);
1149 }
1150
1151 int ssl_ctx_security(SSL_CTX *ctx, int op, int bits, int nid, void *other)
1152 {
1153     return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other,
1154                              ctx->cert->sec_ex);
1155 }