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