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