Fix #2400 Add NO_RENEGOTIATE option
[openssl.git] / ssl / ssl_cert.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /* ====================================================================
11  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12  * ECC cipher suite support in OpenSSL originally developed by
13  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
14  */
15
16 #include <stdio.h>
17
18 #include "e_os.h"
19 #ifndef NO_SYS_TYPES_H
20 # include <sys/types.h>
21 #endif
22
23 #include "internal/o_dir.h"
24 #include <openssl/lhash.h>
25 #include <openssl/bio.h>
26 #include <openssl/pem.h>
27 #include <openssl/x509v3.h>
28 #include <openssl/dh.h>
29 #include <openssl/bn.h>
30 #include <openssl/crypto.h>
31 #include "ssl_locl.h"
32 #include "internal/thread_once.h"
33
34 static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
35                                          int op, int bits, int nid, void *other,
36                                          void *ex);
37
38 static CRYPTO_ONCE ssl_x509_store_ctx_once = CRYPTO_ONCE_STATIC_INIT;
39 static volatile int ssl_x509_store_ctx_idx = -1;
40
41 DEFINE_RUN_ONCE_STATIC(ssl_x509_store_ctx_init)
42 {
43     ssl_x509_store_ctx_idx = X509_STORE_CTX_get_ex_new_index(0,
44                                                              "SSL for verify callback",
45                                                              NULL, NULL, NULL);
46     return ssl_x509_store_ctx_idx >= 0;
47 }
48
49 int SSL_get_ex_data_X509_STORE_CTX_idx(void)
50 {
51
52     if (!RUN_ONCE(&ssl_x509_store_ctx_once, ssl_x509_store_ctx_init))
53         return -1;
54     return ssl_x509_store_ctx_idx;
55 }
56
57 CERT *ssl_cert_new(void)
58 {
59     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
60
61     if (ret == NULL) {
62         SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE);
63         return NULL;
64     }
65
66     ret->key = &(ret->pkeys[SSL_PKEY_RSA]);
67     ret->references = 1;
68     ret->sec_cb = ssl_security_default_callback;
69     ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
70     ret->sec_ex = NULL;
71     ret->lock = CRYPTO_THREAD_lock_new();
72     if (ret->lock == NULL) {
73         SSLerr(SSL_F_SSL_CERT_NEW, ERR_R_MALLOC_FAILURE);
74         OPENSSL_free(ret);
75         return NULL;
76     }
77
78     return ret;
79 }
80
81 CERT *ssl_cert_dup(CERT *cert)
82 {
83     CERT *ret = OPENSSL_zalloc(sizeof(*ret));
84     int i;
85
86     if (ret == NULL) {
87         SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
88         return NULL;
89     }
90
91     ret->references = 1;
92     ret->key = &ret->pkeys[cert->key - cert->pkeys];
93     ret->lock = CRYPTO_THREAD_lock_new();
94     if (ret->lock == NULL) {
95         SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
96         OPENSSL_free(ret);
97         return NULL;
98     }
99 #ifndef OPENSSL_NO_DH
100     if (cert->dh_tmp != NULL) {
101         ret->dh_tmp = cert->dh_tmp;
102         EVP_PKEY_up_ref(ret->dh_tmp);
103     }
104     ret->dh_tmp_cb = cert->dh_tmp_cb;
105     ret->dh_tmp_auto = cert->dh_tmp_auto;
106 #endif
107
108     for (i = 0; i < SSL_PKEY_NUM; i++) {
109         CERT_PKEY *cpk = cert->pkeys + i;
110         CERT_PKEY *rpk = ret->pkeys + i;
111         if (cpk->x509 != NULL) {
112             rpk->x509 = cpk->x509;
113             X509_up_ref(rpk->x509);
114         }
115
116         if (cpk->privatekey != NULL) {
117             rpk->privatekey = cpk->privatekey;
118             EVP_PKEY_up_ref(cpk->privatekey);
119         }
120
121         if (cpk->chain) {
122             rpk->chain = X509_chain_up_ref(cpk->chain);
123             if (!rpk->chain) {
124                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
125                 goto err;
126             }
127         }
128         if (cert->pkeys[i].serverinfo != NULL) {
129             /* Just copy everything. */
130             ret->pkeys[i].serverinfo =
131                 OPENSSL_malloc(cert->pkeys[i].serverinfo_length);
132             if (ret->pkeys[i].serverinfo == NULL) {
133                 SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
134                 goto err;
135             }
136             ret->pkeys[i].serverinfo_length = cert->pkeys[i].serverinfo_length;
137             memcpy(ret->pkeys[i].serverinfo,
138                    cert->pkeys[i].serverinfo, cert->pkeys[i].serverinfo_length);
139         }
140     }
141
142     /* Configured sigalgs copied across */
143     if (cert->conf_sigalgs) {
144         ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen
145                                            * sizeof(*cert->conf_sigalgs));
146         if (ret->conf_sigalgs == NULL)
147             goto err;
148         memcpy(ret->conf_sigalgs, cert->conf_sigalgs,
149                cert->conf_sigalgslen * sizeof(*cert->conf_sigalgs));
150         ret->conf_sigalgslen = cert->conf_sigalgslen;
151     } else
152         ret->conf_sigalgs = NULL;
153
154     if (cert->client_sigalgs) {
155         ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen
156                                              * sizeof(*cert->client_sigalgs));
157         if (ret->client_sigalgs == NULL)
158             goto err;
159         memcpy(ret->client_sigalgs, cert->client_sigalgs,
160                cert->client_sigalgslen * sizeof(*cert->client_sigalgs));
161         ret->client_sigalgslen = cert->client_sigalgslen;
162     } else
163         ret->client_sigalgs = NULL;
164     /* Shared sigalgs also NULL */
165     ret->shared_sigalgs = NULL;
166     /* Copy any custom client certificate types */
167     if (cert->ctype) {
168         ret->ctype = OPENSSL_memdup(cert->ctype, cert->ctype_len);
169         if (ret->ctype == NULL)
170             goto err;
171         ret->ctype_len = cert->ctype_len;
172     }
173
174     ret->cert_flags = cert->cert_flags;
175
176     ret->cert_cb = cert->cert_cb;
177     ret->cert_cb_arg = cert->cert_cb_arg;
178
179     if (cert->verify_store) {
180         X509_STORE_up_ref(cert->verify_store);
181         ret->verify_store = cert->verify_store;
182     }
183
184     if (cert->chain_store) {
185         X509_STORE_up_ref(cert->chain_store);
186         ret->chain_store = cert->chain_store;
187     }
188
189     ret->sec_cb = cert->sec_cb;
190     ret->sec_level = cert->sec_level;
191     ret->sec_ex = cert->sec_ex;
192
193     if (!custom_exts_copy(&ret->custext, &cert->custext))
194         goto err;
195 #ifndef OPENSSL_NO_PSK
196     if (cert->psk_identity_hint) {
197         ret->psk_identity_hint = OPENSSL_strdup(cert->psk_identity_hint);
198         if (ret->psk_identity_hint == NULL)
199             goto err;
200     }
201 #endif
202     return ret;
203
204  err:
205     ssl_cert_free(ret);
206
207     return NULL;
208 }
209
210 /* Free up and clear all certificates and chains */
211
212 void ssl_cert_clear_certs(CERT *c)
213 {
214     int i;
215     if (c == NULL)
216         return;
217     for (i = 0; i < SSL_PKEY_NUM; i++) {
218         CERT_PKEY *cpk = c->pkeys + i;
219         X509_free(cpk->x509);
220         cpk->x509 = NULL;
221         EVP_PKEY_free(cpk->privatekey);
222         cpk->privatekey = NULL;
223         sk_X509_pop_free(cpk->chain, X509_free);
224         cpk->chain = NULL;
225         OPENSSL_free(cpk->serverinfo);
226         cpk->serverinfo = NULL;
227         cpk->serverinfo_length = 0;
228     }
229 }
230
231 void ssl_cert_free(CERT *c)
232 {
233     int i;
234
235     if (c == NULL)
236         return;
237
238     CRYPTO_DOWN_REF(&c->references, &i, c->lock);
239     REF_PRINT_COUNT("CERT", c);
240     if (i > 0)
241         return;
242     REF_ASSERT_ISNT(i < 0);
243
244 #ifndef OPENSSL_NO_DH
245     EVP_PKEY_free(c->dh_tmp);
246 #endif
247
248     ssl_cert_clear_certs(c);
249     OPENSSL_free(c->conf_sigalgs);
250     OPENSSL_free(c->client_sigalgs);
251     OPENSSL_free(c->shared_sigalgs);
252     OPENSSL_free(c->ctype);
253     X509_STORE_free(c->verify_store);
254     X509_STORE_free(c->chain_store);
255     custom_exts_free(&c->custext);
256 #ifndef OPENSSL_NO_PSK
257     OPENSSL_free(c->psk_identity_hint);
258 #endif
259     CRYPTO_THREAD_lock_free(c->lock);
260     OPENSSL_free(c);
261 }
262
263 int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
264 {
265     int i, r;
266     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
267     if (!cpk)
268         return 0;
269     for (i = 0; i < sk_X509_num(chain); i++) {
270         r = ssl_security_cert(s, ctx, sk_X509_value(chain, i), 0, 0);
271         if (r != 1) {
272             SSLerr(SSL_F_SSL_CERT_SET0_CHAIN, r);
273             return 0;
274         }
275     }
276     sk_X509_pop_free(cpk->chain, X509_free);
277     cpk->chain = chain;
278     return 1;
279 }
280
281 int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
282 {
283     STACK_OF(X509) *dchain;
284     if (!chain)
285         return ssl_cert_set0_chain(s, ctx, NULL);
286     dchain = X509_chain_up_ref(chain);
287     if (!dchain)
288         return 0;
289     if (!ssl_cert_set0_chain(s, ctx, dchain)) {
290         sk_X509_pop_free(dchain, X509_free);
291         return 0;
292     }
293     return 1;
294 }
295
296 int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
297 {
298     int r;
299     CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
300     if (!cpk)
301         return 0;
302     r = ssl_security_cert(s, ctx, x, 0, 0);
303     if (r != 1) {
304         SSLerr(SSL_F_SSL_CERT_ADD0_CHAIN_CERT, r);
305         return 0;
306     }
307     if (!cpk->chain)
308         cpk->chain = sk_X509_new_null();
309     if (!cpk->chain || !sk_X509_push(cpk->chain, x))
310         return 0;
311     return 1;
312 }
313
314 int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
315 {
316     if (!ssl_cert_add0_chain_cert(s, ctx, x))
317         return 0;
318     X509_up_ref(x);
319     return 1;
320 }
321
322 int ssl_cert_select_current(CERT *c, X509 *x)
323 {
324     int i;
325     if (x == NULL)
326         return 0;
327     for (i = 0; i < SSL_PKEY_NUM; i++) {
328         CERT_PKEY *cpk = c->pkeys + i;
329         if (cpk->x509 == x && cpk->privatekey) {
330             c->key = cpk;
331             return 1;
332         }
333     }
334
335     for (i = 0; i < SSL_PKEY_NUM; i++) {
336         CERT_PKEY *cpk = c->pkeys + i;
337         if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) {
338             c->key = cpk;
339             return 1;
340         }
341     }
342     return 0;
343 }
344
345 int ssl_cert_set_current(CERT *c, long op)
346 {
347     int i, idx;
348     if (!c)
349         return 0;
350     if (op == SSL_CERT_SET_FIRST)
351         idx = 0;
352     else if (op == SSL_CERT_SET_NEXT) {
353         idx = (int)(c->key - c->pkeys + 1);
354         if (idx >= SSL_PKEY_NUM)
355             return 0;
356     } else
357         return 0;
358     for (i = idx; i < SSL_PKEY_NUM; i++) {
359         CERT_PKEY *cpk = c->pkeys + i;
360         if (cpk->x509 && cpk->privatekey) {
361             c->key = cpk;
362             return 1;
363         }
364     }
365     return 0;
366 }
367
368 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg)
369 {
370     c->cert_cb = cb;
371     c->cert_cb_arg = arg;
372 }
373
374 int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk)
375 {
376     X509 *x;
377     int i = 0;
378     X509_STORE *verify_store;
379     X509_STORE_CTX *ctx = NULL;
380     X509_VERIFY_PARAM *param;
381
382     if ((sk == NULL) || (sk_X509_num(sk) == 0))
383         return 0;
384
385     if (s->cert->verify_store)
386         verify_store = s->cert->verify_store;
387     else
388         verify_store = s->ctx->cert_store;
389
390     ctx = X509_STORE_CTX_new();
391     if (ctx == NULL) {
392         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_MALLOC_FAILURE);
393         return 0;
394     }
395
396     x = sk_X509_value(sk, 0);
397     if (!X509_STORE_CTX_init(ctx, verify_store, x, sk)) {
398         SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_X509_LIB);
399         goto end;
400     }
401     param = X509_STORE_CTX_get0_param(ctx);
402     /*
403      * XXX: Separate @AUTHSECLEVEL and @TLSSECLEVEL would be useful at some
404      * point, for now a single @SECLEVEL sets the same policy for TLS crypto
405      * and PKI authentication.
406      */
407     X509_VERIFY_PARAM_set_auth_level(param, SSL_get_security_level(s));
408
409     /* Set suite B flags if needed */
410     X509_STORE_CTX_set_flags(ctx, tls1_suiteb(s));
411     if (!X509_STORE_CTX_set_ex_data
412         (ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s)) {
413         goto end;
414     }
415
416     /* Verify via DANE if enabled */
417     if (DANETLS_ENABLED(&s->dane))
418         X509_STORE_CTX_set0_dane(ctx, &s->dane);
419
420     /*
421      * We need to inherit the verify parameters. These can be determined by
422      * the context: if its a server it will verify SSL client certificates or
423      * vice versa.
424      */
425
426     X509_STORE_CTX_set_default(ctx, s->server ? "ssl_client" : "ssl_server");
427     /*
428      * Anything non-default in "s->param" should overwrite anything in the ctx.
429      */
430     X509_VERIFY_PARAM_set1(param, s->param);
431
432     if (s->verify_callback)
433         X509_STORE_CTX_set_verify_cb(ctx, s->verify_callback);
434
435     if (s->ctx->app_verify_callback != NULL)
436         i = s->ctx->app_verify_callback(ctx, s->ctx->app_verify_arg);
437     else
438         i = X509_verify_cert(ctx);
439
440     s->verify_result = X509_STORE_CTX_get_error(ctx);
441     sk_X509_pop_free(s->verified_chain, X509_free);
442     s->verified_chain = NULL;
443     if (X509_STORE_CTX_get0_chain(ctx) != NULL) {
444         s->verified_chain = X509_STORE_CTX_get1_chain(ctx);
445         if (s->verified_chain == NULL) {
446             SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN, ERR_R_MALLOC_FAILURE);
447             i = 0;
448         }
449     }
450
451     /* Move peername from the store context params to the SSL handle's */
452     X509_VERIFY_PARAM_move_peername(s->param, param);
453
454  end:
455     X509_STORE_CTX_free(ctx);
456     return i;
457 }
458
459 static void set0_CA_list(STACK_OF(X509_NAME) **ca_list,
460                         STACK_OF(X509_NAME) *name_list)
461 {
462     sk_X509_NAME_pop_free(*ca_list, X509_NAME_free);
463     *ca_list = name_list;
464 }
465
466 STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk)
467 {
468     int i;
469     STACK_OF(X509_NAME) *ret;
470     X509_NAME *name;
471
472     ret = sk_X509_NAME_new_null();
473     if (ret == NULL) {
474         SSLerr(SSL_F_SSL_DUP_CA_LIST, ERR_R_MALLOC_FAILURE);
475         return NULL;
476     }
477     for (i = 0; i < sk_X509_NAME_num(sk); i++) {
478         name = X509_NAME_dup(sk_X509_NAME_value(sk, i));
479         if (name == NULL || !sk_X509_NAME_push(ret, name)) {
480             sk_X509_NAME_pop_free(ret, X509_NAME_free);
481             X509_NAME_free(name);
482             return NULL;
483         }
484     }
485     return (ret);
486 }
487
488 void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
489 {
490     set0_CA_list(&s->ca_names, name_list);
491 }
492
493 void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
494 {
495     set0_CA_list(&ctx->ca_names, name_list);
496 }
497
498 const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx)
499 {
500     return ctx->ca_names;
501 }
502
503 const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s)
504 {
505     return s->ca_names != NULL ? s->ca_names : s->ctx->ca_names;
506 }
507
508 void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
509 {
510     SSL_CTX_set0_CA_list(ctx, name_list);
511 }
512
513 STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx)
514 {
515     return ctx->ca_names;
516 }
517
518 void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
519 {
520     SSL_set0_CA_list(s, name_list);
521 }
522
523 const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s)
524 {
525     return s->s3 != NULL ? s->s3->tmp.peer_ca_names : NULL;
526 }
527
528 STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s)
529 {
530     if (!s->server)
531         return s->s3 != NULL ?  s->s3->tmp.peer_ca_names : NULL;
532     return s->ca_names != NULL ?  s->ca_names : s->ctx->ca_names;
533 }
534
535 static int add_ca_name(STACK_OF(X509_NAME) **sk, const X509 *x)
536 {
537     X509_NAME *name;
538
539     if (x == NULL)
540         return 0;
541     if (*sk == NULL && ((*sk = sk_X509_NAME_new_null()) == NULL))
542         return 0;
543
544     if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL)
545         return 0;
546
547     if (!sk_X509_NAME_push(*sk, name)) {
548         X509_NAME_free(name);
549         return 0;
550     }
551     return 1;
552 }
553
554 int SSL_add1_CA_list(SSL *ssl, const X509 *x)
555 {
556     return add_ca_name(&ssl->ca_names, x);
557 }
558
559 int SSL_CTX_add1_CA_list(SSL_CTX *ctx, const X509 *x)
560 {
561     return add_ca_name(&ctx->ca_names, x);
562 }
563
564 int SSL_add_client_CA(SSL *ssl, X509 *x)
565 {
566     return add_ca_name(&ssl->ca_names, x);
567 }
568
569 int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x)
570 {
571     return add_ca_name(&ctx->ca_names, x);
572 }
573
574 static int xname_sk_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
575 {
576     return (X509_NAME_cmp(*a, *b));
577 }
578
579 static int xname_cmp(const X509_NAME *a, const X509_NAME *b)
580 {
581     return X509_NAME_cmp(a, b);
582 }
583
584 static unsigned long xname_hash(const X509_NAME *a)
585 {
586     return X509_NAME_hash((X509_NAME *)a);
587 }
588
589 /**
590  * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed;
591  * it doesn't really have anything to do with clients (except that a common use
592  * for a stack of CAs is to send it to the client). Actually, it doesn't have
593  * much to do with CAs, either, since it will load any old cert.
594  * \param file the file containing one or more certs.
595  * \return a ::STACK containing the certs.
596  */
597 STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
598 {
599     BIO *in = BIO_new(BIO_s_file());
600     X509 *x = NULL;
601     X509_NAME *xn = NULL;
602     STACK_OF(X509_NAME) *ret = NULL;
603     LHASH_OF(X509_NAME) *name_hash = lh_X509_NAME_new(xname_hash, xname_cmp);
604
605     if ((name_hash == NULL) || (in == NULL)) {
606         SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE);
607         goto err;
608     }
609
610     if (!BIO_read_filename(in, file))
611         goto err;
612
613     for (;;) {
614         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
615             break;
616         if (ret == NULL) {
617             ret = sk_X509_NAME_new_null();
618             if (ret == NULL) {
619                 SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE, ERR_R_MALLOC_FAILURE);
620                 goto err;
621             }
622         }
623         if ((xn = X509_get_subject_name(x)) == NULL)
624             goto err;
625         /* check for duplicates */
626         xn = X509_NAME_dup(xn);
627         if (xn == NULL)
628             goto err;
629         if (lh_X509_NAME_retrieve(name_hash, xn) != NULL) {
630             /* Duplicate. */
631             X509_NAME_free(xn);
632             xn = NULL;
633         } else {
634             lh_X509_NAME_insert(name_hash, xn);
635             if (!sk_X509_NAME_push(ret, xn))
636                 goto err;
637         }
638     }
639     goto done;
640
641  err:
642     X509_NAME_free(xn);
643     sk_X509_NAME_pop_free(ret, X509_NAME_free);
644     ret = NULL;
645  done:
646     BIO_free(in);
647     X509_free(x);
648     lh_X509_NAME_free(name_hash);
649     if (ret != NULL)
650         ERR_clear_error();
651     return (ret);
652 }
653
654 /**
655  * Add a file of certs to a stack.
656  * \param stack the stack to add to.
657  * \param file the file to add from. All certs in this file that are not
658  * already in the stack will be added.
659  * \return 1 for success, 0 for failure. Note that in the case of failure some
660  * certs may have been added to \c stack.
661  */
662
663 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
664                                         const char *file)
665 {
666     BIO *in;
667     X509 *x = NULL;
668     X509_NAME *xn = NULL;
669     int ret = 1;
670     int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b);
671
672     oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp);
673
674     in = BIO_new(BIO_s_file());
675
676     if (in == NULL) {
677         SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK, ERR_R_MALLOC_FAILURE);
678         goto err;
679     }
680
681     if (!BIO_read_filename(in, file))
682         goto err;
683
684     for (;;) {
685         if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL)
686             break;
687         if ((xn = X509_get_subject_name(x)) == NULL)
688             goto err;
689         xn = X509_NAME_dup(xn);
690         if (xn == NULL)
691             goto err;
692         if (sk_X509_NAME_find(stack, xn) >= 0) {
693             /* Duplicate. */
694             X509_NAME_free(xn);
695         } else if (!sk_X509_NAME_push(stack, xn)) {
696             X509_NAME_free(xn);
697             goto err;
698         }
699     }
700
701     ERR_clear_error();
702     goto done;
703
704  err:
705     ret = 0;
706  done:
707     BIO_free(in);
708     X509_free(x);
709     (void)sk_X509_NAME_set_cmp_func(stack, oldcmp);
710     return ret;
711 }
712
713 /**
714  * Add a directory of certs to a stack.
715  * \param stack the stack to append to.
716  * \param dir the directory to append from. All files in this directory will be
717  * examined as potential certs. Any that are acceptable to
718  * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be
719  * included.
720  * \return 1 for success, 0 for failure. Note that in the case of failure some
721  * certs may have been added to \c stack.
722  */
723
724 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
725                                        const char *dir)
726 {
727     OPENSSL_DIR_CTX *d = NULL;
728     const char *filename;
729     int ret = 0;
730
731     /* Note that a side effect is that the CAs will be sorted by name */
732
733     while ((filename = OPENSSL_DIR_read(&d, dir))) {
734         char buf[1024];
735         int r;
736
737         if (strlen(dir) + strlen(filename) + 2 > sizeof buf) {
738             SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,
739                    SSL_R_PATH_TOO_LONG);
740             goto err;
741         }
742 #ifdef OPENSSL_SYS_VMS
743         r = BIO_snprintf(buf, sizeof buf, "%s%s", dir, filename);
744 #else
745         r = BIO_snprintf(buf, sizeof buf, "%s/%s", dir, filename);
746 #endif
747         if (r <= 0 || r >= (int)sizeof(buf))
748             goto err;
749         if (!SSL_add_file_cert_subjects_to_stack(stack, buf))
750             goto err;
751     }
752
753     if (errno) {
754         SYSerr(SYS_F_OPENDIR, get_last_sys_error());
755         ERR_add_error_data(3, "OPENSSL_DIR_read(&ctx, '", dir, "')");
756         SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB);
757         goto err;
758     }
759
760     ret = 1;
761
762  err:
763     if (d)
764         OPENSSL_DIR_end(&d);
765
766     return ret;
767 }
768
769 /* Build a certificate chain for current certificate */
770 int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags)
771 {
772     CERT *c = s ? s->cert : ctx->cert;
773     CERT_PKEY *cpk = c->key;
774     X509_STORE *chain_store = NULL;
775     X509_STORE_CTX *xs_ctx = NULL;
776     STACK_OF(X509) *chain = NULL, *untrusted = NULL;
777     X509 *x;
778     int i, rv = 0;
779
780     if (!cpk->x509) {
781         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_NO_CERTIFICATE_SET);
782         goto err;
783     }
784     /* Rearranging and check the chain: add everything to a store */
785     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) {
786         chain_store = X509_STORE_new();
787         if (chain_store == NULL)
788             goto err;
789         for (i = 0; i < sk_X509_num(cpk->chain); i++) {
790             x = sk_X509_value(cpk->chain, i);
791             if (!X509_STORE_add_cert(chain_store, x))
792                 goto err;
793         }
794         /* Add EE cert too: it might be self signed */
795         if (!X509_STORE_add_cert(chain_store, cpk->x509))
796             goto err;
797     } else {
798         if (c->chain_store)
799             chain_store = c->chain_store;
800         else if (s)
801             chain_store = s->ctx->cert_store;
802         else
803             chain_store = ctx->cert_store;
804
805         if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED)
806             untrusted = cpk->chain;
807     }
808
809     xs_ctx = X509_STORE_CTX_new();
810     if (xs_ctx == NULL) {
811         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_MALLOC_FAILURE);
812         goto err;
813     }
814     if (!X509_STORE_CTX_init(xs_ctx, chain_store, cpk->x509, untrusted)) {
815         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_X509_LIB);
816         goto err;
817     }
818     /* Set suite B flags if needed */
819     X509_STORE_CTX_set_flags(xs_ctx,
820                              c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
821
822     i = X509_verify_cert(xs_ctx);
823     if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) {
824         if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR)
825             ERR_clear_error();
826         i = 1;
827         rv = 2;
828     }
829     if (i > 0)
830         chain = X509_STORE_CTX_get1_chain(xs_ctx);
831     if (i <= 0) {
832         SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_CERTIFICATE_VERIFY_FAILED);
833         i = X509_STORE_CTX_get_error(xs_ctx);
834         ERR_add_error_data(2, "Verify error:",
835                            X509_verify_cert_error_string(i));
836
837         goto err;
838     }
839     /* Remove EE certificate from chain */
840     x = sk_X509_shift(chain);
841     X509_free(x);
842     if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) {
843         if (sk_X509_num(chain) > 0) {
844             /* See if last cert is self signed */
845             x = sk_X509_value(chain, sk_X509_num(chain) - 1);
846             if (X509_get_extension_flags(x) & EXFLAG_SS) {
847                 x = sk_X509_pop(chain);
848                 X509_free(x);
849             }
850         }
851     }
852     /*
853      * Check security level of all CA certificates: EE will have been checked
854      * already.
855      */
856     for (i = 0; i < sk_X509_num(chain); i++) {
857         x = sk_X509_value(chain, i);
858         rv = ssl_security_cert(s, ctx, x, 0, 0);
859         if (rv != 1) {
860             SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, rv);
861             sk_X509_pop_free(chain, X509_free);
862             rv = 0;
863             goto err;
864         }
865     }
866     sk_X509_pop_free(cpk->chain, X509_free);
867     cpk->chain = chain;
868     if (rv == 0)
869         rv = 1;
870  err:
871     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
872         X509_STORE_free(chain_store);
873     X509_STORE_CTX_free(xs_ctx);
874
875     return rv;
876 }
877
878 int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref)
879 {
880     X509_STORE **pstore;
881     if (chain)
882         pstore = &c->chain_store;
883     else
884         pstore = &c->verify_store;
885     X509_STORE_free(*pstore);
886     *pstore = store;
887     if (ref && store)
888         X509_STORE_up_ref(store);
889     return 1;
890 }
891
892 static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
893                                          int op, int bits, int nid, void *other,
894                                          void *ex)
895 {
896     int level, minbits;
897     static const int minbits_table[5] = { 80, 112, 128, 192, 256 };
898     if (ctx)
899         level = SSL_CTX_get_security_level(ctx);
900     else
901         level = SSL_get_security_level(s);
902
903     if (level <= 0) {
904         /*
905          * No EDH keys weaker than 1024-bits even at level 0, otherwise,
906          * anything goes.
907          */
908         if (op == SSL_SECOP_TMP_DH && bits < 80)
909             return 0;
910         return 1;
911     }
912     if (level > 5)
913         level = 5;
914     minbits = minbits_table[level - 1];
915     switch (op) {
916     case SSL_SECOP_CIPHER_SUPPORTED:
917     case SSL_SECOP_CIPHER_SHARED:
918     case SSL_SECOP_CIPHER_CHECK:
919         {
920             const SSL_CIPHER *c = other;
921             /* No ciphers below security level */
922             if (bits < minbits)
923                 return 0;
924             /* No unauthenticated ciphersuites */
925             if (c->algorithm_auth & SSL_aNULL)
926                 return 0;
927             /* No MD5 mac ciphersuites */
928             if (c->algorithm_mac & SSL_MD5)
929                 return 0;
930             /* SHA1 HMAC is 160 bits of security */
931             if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
932                 return 0;
933             /* Level 2: no RC4 */
934             if (level >= 2 && c->algorithm_enc == SSL_RC4)
935                 return 0;
936             /* Level 3: forward secure ciphersuites only */
937             if (level >= 3 && !(c->algorithm_mkey & (SSL_kEDH | SSL_kEECDH)))
938                 return 0;
939             break;
940         }
941     case SSL_SECOP_VERSION:
942         if (!SSL_IS_DTLS(s)) {
943             /* SSLv3 not allowed at level 2 */
944             if (nid <= SSL3_VERSION && level >= 2)
945                 return 0;
946             /* TLS v1.1 and above only for level 3 */
947             if (nid <= TLS1_VERSION && level >= 3)
948                 return 0;
949             /* TLS v1.2 only for level 4 and above */
950             if (nid <= TLS1_1_VERSION && level >= 4)
951                 return 0;
952         } else {
953             /* DTLS v1.2 only for level 4 and above */
954             if (DTLS_VERSION_LT(nid, DTLS1_2_VERSION) && level >= 4)
955                 return 0;
956         }
957         break;
958
959     case SSL_SECOP_COMPRESSION:
960         if (level >= 2)
961             return 0;
962         break;
963     case SSL_SECOP_TICKET:
964         if (level >= 3)
965             return 0;
966         break;
967     default:
968         if (bits < minbits)
969             return 0;
970     }
971     return 1;
972 }
973
974 int ssl_security(const SSL *s, int op, int bits, int nid, void *other)
975 {
976     return s->cert->sec_cb(s, NULL, op, bits, nid, other, s->cert->sec_ex);
977 }
978
979 int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, void *other)
980 {
981     return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other,
982                              ctx->cert->sec_ex);
983 }