Branch data Line data Source code
1 : : /*! \file ssl/ssl_cert.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@cryptsoft.com).
7 : : * The implementation was written so as to conform with Netscapes SSL.
8 : : *
9 : : * This library is free for commercial and non-commercial use as long as
10 : : * the following conditions are aheared to. The following conditions
11 : : * apply to all code found in this distribution, be it the RC4, RSA,
12 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 : : * included with this distribution is covered by the same copyright terms
14 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 : : *
16 : : * Copyright remains Eric Young's, and as such any Copyright notices in
17 : : * the code are not to be removed.
18 : : * If this package is used in a product, Eric Young should be given attribution
19 : : * as the author of the parts of the library used.
20 : : * This can be in the form of a textual message at program startup or
21 : : * in documentation (online or textual) provided with the package.
22 : : *
23 : : * Redistribution and use in source and binary forms, with or without
24 : : * modification, are permitted provided that the following conditions
25 : : * are met:
26 : : * 1. Redistributions of source code must retain the copyright
27 : : * notice, this list of conditions and the following disclaimer.
28 : : * 2. Redistributions in binary form must reproduce the above copyright
29 : : * notice, this list of conditions and the following disclaimer in the
30 : : * documentation and/or other materials provided with the distribution.
31 : : * 3. All advertising materials mentioning features or use of this software
32 : : * must display the following acknowledgement:
33 : : * "This product includes cryptographic software written by
34 : : * Eric Young (eay@cryptsoft.com)"
35 : : * The word 'cryptographic' can be left out if the rouines from the library
36 : : * being used are not cryptographic related :-).
37 : : * 4. If you include any Windows specific code (or a derivative thereof) from
38 : : * the apps directory (application code) you must include an acknowledgement:
39 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 : : * SUCH DAMAGE.
52 : : *
53 : : * The licence and distribution terms for any publically available version or
54 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
55 : : * copied and put under another distribution licence
56 : : * [including the GNU Public Licence.]
57 : : */
58 : : /* ====================================================================
59 : : * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
60 : : *
61 : : * Redistribution and use in source and binary forms, with or without
62 : : * modification, are permitted provided that the following conditions
63 : : * are met:
64 : : *
65 : : * 1. Redistributions of source code must retain the above copyright
66 : : * notice, this list of conditions and the following disclaimer.
67 : : *
68 : : * 2. Redistributions in binary form must reproduce the above copyright
69 : : * notice, this list of conditions and the following disclaimer in
70 : : * the documentation and/or other materials provided with the
71 : : * distribution.
72 : : *
73 : : * 3. All advertising materials mentioning features or use of this
74 : : * software must display the following acknowledgment:
75 : : * "This product includes software developed by the OpenSSL Project
76 : : * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 : : *
78 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 : : * endorse or promote products derived from this software without
80 : : * prior written permission. For written permission, please contact
81 : : * openssl-core@openssl.org.
82 : : *
83 : : * 5. Products derived from this software may not be called "OpenSSL"
84 : : * nor may "OpenSSL" appear in their names without prior written
85 : : * permission of the OpenSSL Project.
86 : : *
87 : : * 6. Redistributions of any form whatsoever must retain the following
88 : : * acknowledgment:
89 : : * "This product includes software developed by the OpenSSL Project
90 : : * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 : : *
92 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
104 : : * ====================================================================
105 : : *
106 : : * This product includes cryptographic software written by Eric Young
107 : : * (eay@cryptsoft.com). This product includes software written by Tim
108 : : * Hudson (tjh@cryptsoft.com).
109 : : *
110 : : */
111 : : /* ====================================================================
112 : : * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 : : * ECC cipher suite support in OpenSSL originally developed by
114 : : * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115 : : */
116 : :
117 : : #include <stdio.h>
118 : :
119 : : #include "e_os.h"
120 : : #ifndef NO_SYS_TYPES_H
121 : : # include <sys/types.h>
122 : : #endif
123 : :
124 : : #include "o_dir.h"
125 : : #include <openssl/objects.h>
126 : : #include <openssl/bio.h>
127 : : #include <openssl/pem.h>
128 : : #include <openssl/x509v3.h>
129 : : #ifndef OPENSSL_NO_DH
130 : : #include <openssl/dh.h>
131 : : #endif
132 : : #include <openssl/bn.h>
133 : : #include "ssl_locl.h"
134 : :
135 : : static int ssl_security_default_callback(SSL *s, SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex);
136 : :
137 : 3020 : int SSL_get_ex_data_X509_STORE_CTX_idx(void)
138 : : {
139 : : static volatile int ssl_x509_store_ctx_idx= -1;
140 : 3020 : int got_write_lock = 0;
141 : :
142 : 3020 : CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
143 : :
144 [ + + ]: 3020 : if (ssl_x509_store_ctx_idx < 0)
145 : : {
146 : 915 : CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
147 : 915 : CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
148 : 915 : got_write_lock = 1;
149 : :
150 [ + - ]: 915 : if (ssl_x509_store_ctx_idx < 0)
151 : : {
152 : 915 : ssl_x509_store_ctx_idx=X509_STORE_CTX_get_ex_new_index(
153 : : 0,"SSL for verify callback",NULL,NULL,NULL);
154 : : }
155 : : }
156 : :
157 [ + + ]: 3020 : if (got_write_lock)
158 : 915 : CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
159 : : else
160 : 2105 : CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
161 : :
162 : 3020 : return ssl_x509_store_ctx_idx;
163 : : }
164 : :
165 : 4496 : void ssl_cert_set_default_md(CERT *cert)
166 : : {
167 : : /* Set digest values to defaults */
168 : : #ifndef OPENSSL_NO_DSA
169 : 4496 : cert->pkeys[SSL_PKEY_DSA_SIGN].digest = EVP_sha1();
170 : : #endif
171 : : #ifndef OPENSSL_NO_RSA
172 : 4496 : cert->pkeys[SSL_PKEY_RSA_SIGN].digest = EVP_sha1();
173 : 4496 : cert->pkeys[SSL_PKEY_RSA_ENC].digest = EVP_sha1();
174 : : #endif
175 : : #ifndef OPENSSL_NO_ECDSA
176 : 4496 : cert->pkeys[SSL_PKEY_ECC].digest = EVP_sha1();
177 : : #endif
178 : 4496 : }
179 : :
180 : 1808 : CERT *ssl_cert_new(void)
181 : : {
182 : : CERT *ret;
183 : :
184 : 1808 : ret=(CERT *)OPENSSL_malloc(sizeof(CERT));
185 [ - + ]: 1808 : if (ret == NULL)
186 : : {
187 : 0 : SSLerr(SSL_F_SSL_CERT_NEW,ERR_R_MALLOC_FAILURE);
188 : 0 : return(NULL);
189 : : }
190 : : memset(ret,0,sizeof(CERT));
191 : :
192 : 1808 : ret->key= &(ret->pkeys[SSL_PKEY_RSA_ENC]);
193 : 1808 : ret->references=1;
194 : 1808 : ssl_cert_set_default_md(ret);
195 : 1808 : ret->sec_cb = ssl_security_default_callback;
196 : 1808 : ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL;
197 : 1808 : ret->sec_ex = NULL;
198 : 1808 : return(ret);
199 : : }
200 : :
201 : 1808 : CERT *ssl_cert_dup(CERT *cert)
202 : : {
203 : : CERT *ret;
204 : : int i;
205 : :
206 : 1808 : ret = (CERT *)OPENSSL_malloc(sizeof(CERT));
207 [ - + ]: 1808 : if (ret == NULL)
208 : : {
209 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
210 : 0 : return(NULL);
211 : : }
212 : :
213 : : memset(ret, 0, sizeof(CERT));
214 : :
215 : 1808 : ret->key = &ret->pkeys[cert->key - &cert->pkeys[0]];
216 : : /* or ret->key = ret->pkeys + (cert->key - cert->pkeys),
217 : : * if you find that more readable */
218 : :
219 : 1808 : ret->valid = cert->valid;
220 : 1808 : ret->mask_k = cert->mask_k;
221 : 1808 : ret->mask_a = cert->mask_a;
222 : 1808 : ret->export_mask_k = cert->export_mask_k;
223 : 1808 : ret->export_mask_a = cert->export_mask_a;
224 : :
225 : : #ifndef OPENSSL_NO_RSA
226 [ - + ]: 1808 : if (cert->rsa_tmp != NULL)
227 : : {
228 : 0 : RSA_up_ref(cert->rsa_tmp);
229 : 0 : ret->rsa_tmp = cert->rsa_tmp;
230 : : }
231 : 1808 : ret->rsa_tmp_cb = cert->rsa_tmp_cb;
232 : : #endif
233 : :
234 : : #ifndef OPENSSL_NO_DH
235 [ + + ]: 1808 : if (cert->dh_tmp != NULL)
236 : : {
237 : 739 : ret->dh_tmp = DHparams_dup(cert->dh_tmp);
238 [ - + ]: 739 : if (ret->dh_tmp == NULL)
239 : : {
240 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_DH_LIB);
241 : 0 : goto err;
242 : : }
243 [ + + ]: 739 : if (cert->dh_tmp->priv_key)
244 : : {
245 : 706 : BIGNUM *b = BN_dup(cert->dh_tmp->priv_key);
246 [ - + ]: 706 : if (!b)
247 : : {
248 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
249 : 0 : goto err;
250 : : }
251 : 706 : ret->dh_tmp->priv_key = b;
252 : : }
253 [ + + ]: 739 : if (cert->dh_tmp->pub_key)
254 : : {
255 : 706 : BIGNUM *b = BN_dup(cert->dh_tmp->pub_key);
256 [ - + ]: 706 : if (!b)
257 : : {
258 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_BN_LIB);
259 : 0 : goto err;
260 : : }
261 : 706 : ret->dh_tmp->pub_key = b;
262 : : }
263 : : }
264 : 1808 : ret->dh_tmp_cb = cert->dh_tmp_cb;
265 : 1808 : ret->dh_tmp_auto = cert->dh_tmp_auto;
266 : : #endif
267 : :
268 : : #ifndef OPENSSL_NO_ECDH
269 [ + + ]: 1808 : if (cert->ecdh_tmp)
270 : : {
271 : 739 : ret->ecdh_tmp = EC_KEY_dup(cert->ecdh_tmp);
272 [ - + ]: 739 : if (ret->ecdh_tmp == NULL)
273 : : {
274 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_EC_LIB);
275 : 0 : goto err;
276 : : }
277 : : }
278 : 1808 : ret->ecdh_tmp_cb = cert->ecdh_tmp_cb;
279 : 1808 : ret->ecdh_tmp_auto = cert->ecdh_tmp_auto;
280 : : #endif
281 : :
282 [ + + ]: 16272 : for (i = 0; i < SSL_PKEY_NUM; i++)
283 : : {
284 : 14464 : CERT_PKEY *cpk = cert->pkeys + i;
285 : 14464 : CERT_PKEY *rpk = ret->pkeys + i;
286 [ + + ]: 14464 : if (cpk->x509 != NULL)
287 : : {
288 : 1036 : rpk->x509 = cpk->x509;
289 : 1036 : CRYPTO_add(&rpk->x509->references, 1, CRYPTO_LOCK_X509);
290 : : }
291 : :
292 [ + + ]: 14464 : if (cpk->privatekey != NULL)
293 : : {
294 : 1036 : rpk->privatekey = cpk->privatekey;
295 : 1036 : CRYPTO_add(&cpk->privatekey->references, 1,
296 : : CRYPTO_LOCK_EVP_PKEY);
297 : :
298 [ - + ]: 1036 : switch(i)
299 : : {
300 : : /* If there was anything special to do for
301 : : * certain types of keys, we'd do it here.
302 : : * (Nothing at the moment, I think.) */
303 : :
304 : : case SSL_PKEY_RSA_ENC:
305 : : case SSL_PKEY_RSA_SIGN:
306 : : /* We have an RSA key. */
307 : : break;
308 : :
309 : : case SSL_PKEY_DSA_SIGN:
310 : : /* We have a DSA key. */
311 : : break;
312 : :
313 : : case SSL_PKEY_DH_RSA:
314 : : case SSL_PKEY_DH_DSA:
315 : : /* We have a DH key. */
316 : : break;
317 : :
318 : : case SSL_PKEY_ECC:
319 : : /* We have an ECC key */
320 : : break;
321 : :
322 : : default:
323 : : /* Can't happen. */
324 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, SSL_R_LIBRARY_BUG);
325 : : }
326 : : }
327 : :
328 [ - + ]: 14464 : if (cpk->chain)
329 : : {
330 : 0 : rpk->chain = X509_chain_up_ref(cpk->chain);
331 [ # # ]: 0 : if (!rpk->chain)
332 : : {
333 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
334 : 0 : goto err;
335 : : }
336 : : }
337 : 14464 : rpk->valid_flags = 0;
338 : : #ifndef OPENSSL_NO_TLSEXT
339 [ + + ]: 14464 : if (cert->pkeys[i].serverinfo != NULL)
340 : : {
341 : : /* Just copy everything. */
342 : 55 : ret->pkeys[i].serverinfo =
343 : 55 : OPENSSL_malloc(cert->pkeys[i].serverinfo_length);
344 [ - + ]: 55 : if (ret->pkeys[i].serverinfo == NULL)
345 : : {
346 : 0 : SSLerr(SSL_F_SSL_CERT_DUP, ERR_R_MALLOC_FAILURE);
347 : 0 : return NULL;
348 : : }
349 : 55 : ret->pkeys[i].serverinfo_length =
350 : 55 : cert->pkeys[i].serverinfo_length;
351 : 110 : memcpy(ret->pkeys[i].serverinfo,
352 : 55 : cert->pkeys[i].serverinfo,
353 : : cert->pkeys[i].serverinfo_length);
354 : : }
355 : : #endif
356 : : }
357 : :
358 : 1808 : ret->references=1;
359 : : /* Set digests to defaults. NB: we don't copy existing values as they
360 : : * will be set during handshake.
361 : : */
362 : 1808 : ssl_cert_set_default_md(ret);
363 : : /* Peer sigalgs set to NULL as we get these from handshake too */
364 : 1808 : ret->peer_sigalgs = NULL;
365 : 1808 : ret->peer_sigalgslen = 0;
366 : : /* Configured sigalgs however we copy across */
367 : :
368 [ - + ]: 1808 : if (cert->conf_sigalgs)
369 : : {
370 : 0 : ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen);
371 [ # # ]: 0 : if (!ret->conf_sigalgs)
372 : : goto err;
373 : 0 : memcpy(ret->conf_sigalgs, cert->conf_sigalgs,
374 : : cert->conf_sigalgslen);
375 : 0 : ret->conf_sigalgslen = cert->conf_sigalgslen;
376 : : }
377 : : else
378 : 1808 : ret->conf_sigalgs = NULL;
379 : :
380 [ - + ]: 1808 : if (cert->client_sigalgs)
381 : : {
382 : 0 : ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen);
383 [ # # ]: 0 : if (!ret->client_sigalgs)
384 : : goto err;
385 : 0 : memcpy(ret->client_sigalgs, cert->client_sigalgs,
386 : : cert->client_sigalgslen);
387 : 0 : ret->client_sigalgslen = cert->client_sigalgslen;
388 : : }
389 : : else
390 : 1808 : ret->client_sigalgs = NULL;
391 : : /* Shared sigalgs also NULL */
392 : 1808 : ret->shared_sigalgs = NULL;
393 : : /* Copy any custom client certificate types */
394 [ - + ]: 1808 : if (cert->ctypes)
395 : : {
396 : 0 : ret->ctypes = OPENSSL_malloc(cert->ctype_num);
397 [ # # ]: 0 : if (!ret->ctypes)
398 : : goto err;
399 : 0 : memcpy(ret->ctypes, cert->ctypes, cert->ctype_num);
400 : 0 : ret->ctype_num = cert->ctype_num;
401 : : }
402 : :
403 : 1808 : ret->cert_flags = cert->cert_flags;
404 : :
405 : 1808 : ret->cert_cb = cert->cert_cb;
406 : 1808 : ret->cert_cb_arg = cert->cert_cb_arg;
407 : :
408 [ - + ]: 1808 : if (cert->verify_store)
409 : : {
410 : 0 : CRYPTO_add(&cert->verify_store->references, 1, CRYPTO_LOCK_X509_STORE);
411 : 0 : ret->verify_store = cert->verify_store;
412 : : }
413 : :
414 [ - + ]: 1808 : if (cert->chain_store)
415 : : {
416 : 0 : CRYPTO_add(&cert->chain_store->references, 1, CRYPTO_LOCK_X509_STORE);
417 : 0 : ret->chain_store = cert->chain_store;
418 : : }
419 : :
420 : 1808 : ret->ciphers_raw = NULL;
421 : :
422 : 1808 : ret->sec_cb = cert->sec_cb;
423 : 1808 : ret->sec_level = cert->sec_level;
424 : 1808 : ret->sec_ex = cert->sec_ex;
425 : :
426 : 1808 : return(ret);
427 : :
428 : : #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_ECDH)
429 : : err:
430 : : #endif
431 : : #ifndef OPENSSL_NO_RSA
432 [ # # ]: 0 : if (ret->rsa_tmp != NULL)
433 : 0 : RSA_free(ret->rsa_tmp);
434 : : #endif
435 : : #ifndef OPENSSL_NO_DH
436 [ # # ]: 0 : if (ret->dh_tmp != NULL)
437 : 0 : DH_free(ret->dh_tmp);
438 : : #endif
439 : : #ifndef OPENSSL_NO_ECDH
440 [ # # ]: 0 : if (ret->ecdh_tmp != NULL)
441 : 0 : EC_KEY_free(ret->ecdh_tmp);
442 : : #endif
443 : :
444 : 0 : ssl_cert_clear_certs(ret);
445 : :
446 : 0 : return NULL;
447 : : }
448 : :
449 : : /* Free up and clear all certificates and chains */
450 : :
451 : 3616 : void ssl_cert_clear_certs(CERT *c)
452 : : {
453 : : int i;
454 [ + - ]: 3616 : if (c == NULL)
455 : 3616 : return;
456 [ + + ]: 32544 : for (i = 0; i<SSL_PKEY_NUM; i++)
457 : : {
458 : 28928 : CERT_PKEY *cpk = c->pkeys + i;
459 [ + + ]: 28928 : if (cpk->x509)
460 : : {
461 : 2072 : X509_free(cpk->x509);
462 : 2072 : cpk->x509 = NULL;
463 : : }
464 [ + + ]: 28928 : if (cpk->privatekey)
465 : : {
466 : 2072 : EVP_PKEY_free(cpk->privatekey);
467 : 2072 : cpk->privatekey = NULL;
468 : : }
469 [ - + ]: 28928 : if (cpk->chain)
470 : : {
471 : 0 : sk_X509_pop_free(cpk->chain, X509_free);
472 : 0 : cpk->chain = NULL;
473 : : }
474 : : #ifndef OPENSSL_NO_TLSEXT
475 [ + + ]: 28928 : if (cpk->serverinfo)
476 : : {
477 : 110 : OPENSSL_free(cpk->serverinfo);
478 : 110 : cpk->serverinfo = NULL;
479 : 110 : cpk->serverinfo_length = 0;
480 : : }
481 : : #endif
482 : : /* Clear all flags apart from explicit sign */
483 : 28928 : cpk->valid_flags &= CERT_PKEY_EXPLICIT_SIGN;
484 : : }
485 : : }
486 : :
487 : 3616 : void ssl_cert_free(CERT *c)
488 : : {
489 : : int i;
490 : :
491 [ + - ]: 3616 : if(c == NULL)
492 : : return;
493 : :
494 : 3616 : i=CRYPTO_add(&c->references,-1,CRYPTO_LOCK_SSL_CERT);
495 : : #ifdef REF_PRINT
496 : : REF_PRINT("CERT",c);
497 : : #endif
498 [ + - ]: 3616 : if (i > 0) return;
499 : : #ifdef REF_CHECK
500 : : if (i < 0)
501 : : {
502 : : fprintf(stderr,"ssl_cert_free, bad reference count\n");
503 : : abort(); /* ok */
504 : : }
505 : : #endif
506 : :
507 : : #ifndef OPENSSL_NO_RSA
508 [ + + ]: 3616 : if (c->rsa_tmp) RSA_free(c->rsa_tmp);
509 : : #endif
510 : : #ifndef OPENSSL_NO_DH
511 [ + + ]: 3616 : if (c->dh_tmp) DH_free(c->dh_tmp);
512 : : #endif
513 : : #ifndef OPENSSL_NO_ECDH
514 [ + + ]: 3616 : if (c->ecdh_tmp) EC_KEY_free(c->ecdh_tmp);
515 : : #endif
516 : :
517 : 3616 : ssl_cert_clear_certs(c);
518 [ + + ]: 3616 : if (c->peer_sigalgs)
519 : 255 : OPENSSL_free(c->peer_sigalgs);
520 [ - + ]: 3616 : if (c->conf_sigalgs)
521 : 0 : OPENSSL_free(c->conf_sigalgs);
522 [ - + ]: 3616 : if (c->client_sigalgs)
523 : 0 : OPENSSL_free(c->client_sigalgs);
524 [ + + ]: 3616 : if (c->shared_sigalgs)
525 : 255 : OPENSSL_free(c->shared_sigalgs);
526 [ - + ]: 3616 : if (c->ctypes)
527 : 0 : OPENSSL_free(c->ctypes);
528 [ - + ]: 3616 : if (c->verify_store)
529 : 0 : X509_STORE_free(c->verify_store);
530 [ - + ]: 3616 : if (c->chain_store)
531 : 0 : X509_STORE_free(c->chain_store);
532 [ + + ]: 3616 : if (c->ciphers_raw)
533 : 1003 : OPENSSL_free(c->ciphers_raw);
534 : 3616 : OPENSSL_free(c);
535 : : }
536 : :
537 : 2127 : int ssl_cert_inst(CERT **o)
538 : : {
539 : : /* Create a CERT if there isn't already one
540 : : * (which cannot really happen, as it is initially created in
541 : : * SSL_CTX_new; but the earlier code usually allows for that one
542 : : * being non-existant, so we follow that behaviour, as it might
543 : : * turn out that there actually is a reason for it -- but I'm
544 : : * not sure that *all* of the existing code could cope with
545 : : * s->cert being NULL, otherwise we could do without the
546 : : * initialization in SSL_CTX_new).
547 : : */
548 : :
549 [ - + ]: 2127 : if (o == NULL)
550 : : {
551 : 0 : SSLerr(SSL_F_SSL_CERT_INST, ERR_R_PASSED_NULL_PARAMETER);
552 : 0 : return(0);
553 : : }
554 [ - + ]: 2127 : if (*o == NULL)
555 : : {
556 [ # # ]: 0 : if ((*o = ssl_cert_new()) == NULL)
557 : : {
558 : 0 : SSLerr(SSL_F_SSL_CERT_INST, ERR_R_MALLOC_FAILURE);
559 : 0 : return(0);
560 : : }
561 : : }
562 : : return(1);
563 : : }
564 : :
565 : 0 : int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
566 : : {
567 : : int i, r;
568 [ # # ]: 0 : CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
569 [ # # ]: 0 : if (!cpk)
570 : : return 0;
571 [ # # ]: 0 : if (cpk->chain)
572 : 0 : sk_X509_pop_free(cpk->chain, X509_free);
573 [ # # ]: 0 : for (i = 0; i < sk_X509_num(chain); i++)
574 : : {
575 : 0 : r = ssl_security_cert(s, ctx, sk_X509_value(chain, i), 0, 0);
576 [ # # ]: 0 : if (r != 1)
577 : : {
578 : 0 : SSLerr(SSL_F_SSL_CERT_SET0_CHAIN, r);
579 : 0 : return 0;
580 : : }
581 : : }
582 : 0 : cpk->chain = chain;
583 : 0 : return 1;
584 : : }
585 : :
586 : 0 : int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
587 : : {
588 : : STACK_OF(X509) *dchain;
589 [ # # ]: 0 : if (!chain)
590 : 0 : return ssl_cert_set0_chain(s, ctx, NULL);
591 : 0 : dchain = X509_chain_up_ref(chain);
592 [ # # ]: 0 : if (!dchain)
593 : : return 0;
594 [ # # ]: 0 : if (!ssl_cert_set0_chain(s, ctx, dchain))
595 : : {
596 : 0 : sk_X509_pop_free(dchain, X509_free);
597 : 0 : return 0;
598 : : }
599 : : return 1;
600 : : }
601 : :
602 : 0 : int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
603 : : {
604 : : int r;
605 [ # # ]: 0 : CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
606 [ # # ]: 0 : if (!cpk)
607 : : return 0;
608 : 0 : r = ssl_security_cert(s, ctx, x, 0, 0);
609 [ # # ]: 0 : if (r != 1)
610 : : {
611 : 0 : SSLerr(SSL_F_SSL_CERT_ADD0_CHAIN_CERT, r);
612 : 0 : return 0;
613 : : }
614 [ # # ]: 0 : if (!cpk->chain)
615 : 0 : cpk->chain = sk_X509_new_null();
616 [ # # ][ # # ]: 0 : if (!cpk->chain || !sk_X509_push(cpk->chain, x))
617 : : return 0;
618 : : return 1;
619 : : }
620 : :
621 : 0 : int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
622 : : {
623 [ # # ]: 0 : if (!ssl_cert_add0_chain_cert(s, ctx, x))
624 : : return 0;
625 : 0 : CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
626 : 0 : return 1;
627 : : }
628 : :
629 : 0 : int ssl_cert_select_current(CERT *c, X509 *x)
630 : : {
631 : : int i;
632 [ # # ]: 0 : if (x == NULL)
633 : : return 0;
634 [ # # ]: 0 : for (i = 0; i < SSL_PKEY_NUM; i++)
635 : : {
636 : 0 : CERT_PKEY *cpk = c->pkeys + i;
637 [ # # ][ # # ]: 0 : if (cpk->x509 == x && cpk->privatekey)
638 : : {
639 : 0 : c->key = cpk;
640 : 0 : return 1;
641 : : }
642 : : }
643 : :
644 [ # # ]: 0 : for (i = 0; i < SSL_PKEY_NUM; i++)
645 : : {
646 : 0 : CERT_PKEY *cpk = c->pkeys + i;
647 [ # # ][ # # ]: 0 : if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x))
[ # # ]
648 : : {
649 : 0 : c->key = cpk;
650 : 0 : return 1;
651 : : }
652 : : }
653 : : return 0;
654 : : }
655 : :
656 : 0 : int ssl_cert_set_current(CERT *c, long op)
657 : : {
658 : : int i, idx;
659 [ # # ]: 0 : if (!c)
660 : : return 0;
661 [ # # ]: 0 : if (op == SSL_CERT_SET_FIRST)
662 : : idx = 0;
663 [ # # ]: 0 : else if (op == SSL_CERT_SET_NEXT)
664 : : {
665 : 0 : idx = (int)(c->key - c->pkeys + 1);
666 [ # # ]: 0 : if (idx >= SSL_PKEY_NUM)
667 : : return 0;
668 : : }
669 : : else
670 : : return 0;
671 [ # # ]: 0 : for (i = idx; i < SSL_PKEY_NUM; i++)
672 : : {
673 : 0 : CERT_PKEY *cpk = c->pkeys + i;
674 [ # # ][ # # ]: 0 : if (cpk->x509 && cpk->privatekey)
675 : : {
676 : 0 : c->key = cpk;
677 : 0 : return 1;
678 : : }
679 : : }
680 : : return 0;
681 : : }
682 : :
683 : 0 : void ssl_cert_set_cert_cb(CERT *c, int (*cb)(SSL *ssl, void *arg), void *arg)
684 : : {
685 : 0 : c->cert_cb = cb;
686 : 0 : c->cert_cb_arg = arg;
687 : 0 : }
688 : :
689 : 1410 : SESS_CERT *ssl_sess_cert_new(void)
690 : : {
691 : : SESS_CERT *ret;
692 : :
693 : 1410 : ret = OPENSSL_malloc(sizeof *ret);
694 [ - + ]: 1410 : if (ret == NULL)
695 : : {
696 : 0 : SSLerr(SSL_F_SSL_SESS_CERT_NEW, ERR_R_MALLOC_FAILURE);
697 : 0 : return NULL;
698 : : }
699 : :
700 : : memset(ret, 0 ,sizeof *ret);
701 : 1410 : ret->peer_key = &(ret->peer_pkeys[SSL_PKEY_RSA_ENC]);
702 : 1410 : ret->references = 1;
703 : :
704 : 1410 : return ret;
705 : : }
706 : :
707 : 1410 : void ssl_sess_cert_free(SESS_CERT *sc)
708 : : {
709 : : int i;
710 : :
711 [ + - ]: 1410 : if (sc == NULL)
712 : : return;
713 : :
714 : 1410 : i = CRYPTO_add(&sc->references, -1, CRYPTO_LOCK_SSL_SESS_CERT);
715 : : #ifdef REF_PRINT
716 : : REF_PRINT("SESS_CERT", sc);
717 : : #endif
718 [ + - ]: 1410 : if (i > 0)
719 : : return;
720 : : #ifdef REF_CHECK
721 : : if (i < 0)
722 : : {
723 : : fprintf(stderr,"ssl_sess_cert_free, bad reference count\n");
724 : : abort(); /* ok */
725 : : }
726 : : #endif
727 : :
728 : : /* i == 0 */
729 [ + + ]: 1410 : if (sc->cert_chain != NULL)
730 : 1410 : sk_X509_pop_free(sc->cert_chain, X509_free);
731 [ + + ]: 12690 : for (i = 0; i < SSL_PKEY_NUM; i++)
732 : : {
733 [ + + ]: 11280 : if (sc->peer_pkeys[i].x509 != NULL)
734 : 1047 : X509_free(sc->peer_pkeys[i].x509);
735 : : #if 0 /* We don't have the peer's private key. These lines are just
736 : : * here as a reminder that we're still using a not-quite-appropriate
737 : : * data structure. */
738 : : if (sc->peer_pkeys[i].privatekey != NULL)
739 : : EVP_PKEY_free(sc->peer_pkeys[i].privatekey);
740 : : #endif
741 : : }
742 : :
743 : : #ifndef OPENSSL_NO_RSA
744 [ + + ]: 1410 : if (sc->peer_rsa_tmp != NULL)
745 : 33 : RSA_free(sc->peer_rsa_tmp);
746 : : #endif
747 : : #ifndef OPENSSL_NO_DH
748 [ + + ]: 1410 : if (sc->peer_dh_tmp != NULL)
749 : 198 : DH_free(sc->peer_dh_tmp);
750 : : #endif
751 : : #ifndef OPENSSL_NO_ECDH
752 [ + + ]: 1410 : if (sc->peer_ecdh_tmp != NULL)
753 : 462 : EC_KEY_free(sc->peer_ecdh_tmp);
754 : : #endif
755 : :
756 : 1410 : OPENSSL_free(sc);
757 : : }
758 : :
759 : 110 : int ssl_set_peer_cert_type(SESS_CERT *sc,int type)
760 : : {
761 : 110 : sc->peer_cert_type = type;
762 : 110 : return(1);
763 : : }
764 : :
765 : 1212 : int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk)
766 : : {
767 : : X509 *x;
768 : : int i;
769 : : X509_STORE *verify_store;
770 : : X509_STORE_CTX ctx;
771 : :
772 [ + - ]: 1212 : if (s->cert->verify_store)
773 : : verify_store = s->cert->verify_store;
774 : : else
775 : 1212 : verify_store = s->ctx->cert_store;
776 : :
777 [ + - ][ + - ]: 1212 : if ((sk == NULL) || (sk_X509_num(sk) == 0))
778 : : return(0);
779 : :
780 : 1212 : x=sk_X509_value(sk,0);
781 [ - + ]: 1212 : if(!X509_STORE_CTX_init(&ctx,verify_store,x,sk))
782 : : {
783 : 0 : SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,ERR_R_X509_LIB);
784 : 0 : return(0);
785 : : }
786 : : /* Set suite B flags if needed */
787 : 1212 : X509_STORE_CTX_set_flags(&ctx, tls1_suiteb(s));
788 : : #if 0
789 : : if (SSL_get_verify_depth(s) >= 0)
790 : : X509_STORE_CTX_set_depth(&ctx, SSL_get_verify_depth(s));
791 : : #endif
792 : 1212 : X509_STORE_CTX_set_ex_data(&ctx,SSL_get_ex_data_X509_STORE_CTX_idx(),s);
793 : :
794 : : /* We need to inherit the verify parameters. These can be determined by
795 : : * the context: if its a server it will verify SSL client certificates
796 : : * or vice versa.
797 : : */
798 : :
799 [ + + ]: 1212 : X509_STORE_CTX_set_default(&ctx,
800 : 1212 : s->server ? "ssl_client" : "ssl_server");
801 : : /* Anything non-default in "param" should overwrite anything in the
802 : : * ctx.
803 : : */
804 : 1212 : X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(&ctx), s->param);
805 : :
806 [ + + ]: 1212 : if (s->verify_callback)
807 : 308 : X509_STORE_CTX_set_verify_cb(&ctx, s->verify_callback);
808 : :
809 [ + + ]: 1212 : if (s->ctx->app_verify_callback != NULL)
810 : : #if 1 /* new with OpenSSL 0.9.7 */
811 : 308 : i=s->ctx->app_verify_callback(&ctx, s->ctx->app_verify_arg);
812 : : #else
813 : : i=s->ctx->app_verify_callback(&ctx); /* should pass app_verify_arg */
814 : : #endif
815 : : else
816 : : {
817 : : #ifndef OPENSSL_NO_X509_VERIFY
818 : 904 : i=X509_verify_cert(&ctx);
819 : : #if 0
820 : : /* Dummy error calls so mkerr generates them */
821 : : SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,SSL_R_EE_KEY_TOO_SMALL);
822 : : SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,SSL_R_CA_KEY_TOO_SMALL);
823 : : SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,SSL_R_CA_MD_TOO_WEAK);
824 : : #endif
825 [ + + ]: 904 : if (i > 0)
826 : 6 : i = ssl_security_cert_chain(s, ctx.chain, NULL, 1);
827 : : #else
828 : : i=0;
829 : : ctx.error=X509_V_ERR_APPLICATION_VERIFICATION;
830 : : SSLerr(SSL_F_SSL_VERIFY_CERT_CHAIN,SSL_R_NO_VERIFY_CALLBACK);
831 : : #endif
832 : : }
833 : :
834 : 1212 : s->verify_result=ctx.error;
835 : 1212 : X509_STORE_CTX_cleanup(&ctx);
836 : :
837 : 1212 : return(i);
838 : : }
839 : :
840 : 0 : static void set_client_CA_list(STACK_OF(X509_NAME) **ca_list,STACK_OF(X509_NAME) *name_list)
841 : : {
842 [ # # ]: 0 : if (*ca_list != NULL)
843 : 0 : sk_X509_NAME_pop_free(*ca_list,X509_NAME_free);
844 : :
845 : 0 : *ca_list=name_list;
846 : 0 : }
847 : :
848 : 0 : STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *sk)
849 : : {
850 : : int i;
851 : : STACK_OF(X509_NAME) *ret;
852 : : X509_NAME *name;
853 : :
854 : 0 : ret=sk_X509_NAME_new_null();
855 [ # # ]: 0 : for (i=0; i<sk_X509_NAME_num(sk); i++)
856 : : {
857 : 0 : name=X509_NAME_dup(sk_X509_NAME_value(sk,i));
858 [ # # ][ # # ]: 0 : if ((name == NULL) || !sk_X509_NAME_push(ret,name))
859 : : {
860 : 0 : sk_X509_NAME_pop_free(ret,X509_NAME_free);
861 : 0 : return(NULL);
862 : : }
863 : : }
864 : : return(ret);
865 : : }
866 : :
867 : 0 : void SSL_set_client_CA_list(SSL *s,STACK_OF(X509_NAME) *name_list)
868 : : {
869 : 0 : set_client_CA_list(&(s->client_CA),name_list);
870 : 0 : }
871 : :
872 : 0 : void SSL_CTX_set_client_CA_list(SSL_CTX *ctx,STACK_OF(X509_NAME) *name_list)
873 : : {
874 : 0 : set_client_CA_list(&(ctx->client_CA),name_list);
875 : 0 : }
876 : :
877 : 0 : STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx)
878 : : {
879 : 0 : return(ctx->client_CA);
880 : : }
881 : :
882 : 99 : STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s)
883 : : {
884 [ - + ]: 99 : if (s->type == SSL_ST_CONNECT)
885 : : { /* we are in the client */
886 [ # # ][ # # ]: 0 : if (((s->version>>8) == SSL3_VERSION_MAJOR) &&
887 : 0 : (s->s3 != NULL))
888 : 0 : return(s->s3->tmp.ca_names);
889 : : else
890 : : return(NULL);
891 : : }
892 : : else
893 : : {
894 [ + - ]: 99 : if (s->client_CA != NULL)
895 : : return(s->client_CA);
896 : : else
897 : 99 : return(s->ctx->client_CA);
898 : : }
899 : : }
900 : :
901 : 0 : static int add_client_CA(STACK_OF(X509_NAME) **sk,X509 *x)
902 : : {
903 : : X509_NAME *name;
904 : :
905 [ # # ]: 0 : if (x == NULL) return(0);
906 [ # # ][ # # ]: 0 : if ((*sk == NULL) && ((*sk=sk_X509_NAME_new_null()) == NULL))
907 : : return(0);
908 : :
909 [ # # ]: 0 : if ((name=X509_NAME_dup(X509_get_subject_name(x))) == NULL)
910 : : return(0);
911 : :
912 [ # # ]: 0 : if (!sk_X509_NAME_push(*sk,name))
913 : : {
914 : 0 : X509_NAME_free(name);
915 : 0 : return(0);
916 : : }
917 : : return(1);
918 : : }
919 : :
920 : 0 : int SSL_add_client_CA(SSL *ssl,X509 *x)
921 : : {
922 : 0 : return(add_client_CA(&(ssl->client_CA),x));
923 : : }
924 : :
925 : 0 : int SSL_CTX_add_client_CA(SSL_CTX *ctx,X509 *x)
926 : : {
927 : 0 : return(add_client_CA(&(ctx->client_CA),x));
928 : : }
929 : :
930 : 0 : static int xname_cmp(const X509_NAME * const *a, const X509_NAME * const *b)
931 : : {
932 : 0 : return(X509_NAME_cmp(*a,*b));
933 : : }
934 : :
935 : : #ifndef OPENSSL_NO_STDIO
936 : : /*!
937 : : * Load CA certs from a file into a ::STACK. Note that it is somewhat misnamed;
938 : : * it doesn't really have anything to do with clients (except that a common use
939 : : * for a stack of CAs is to send it to the client). Actually, it doesn't have
940 : : * much to do with CAs, either, since it will load any old cert.
941 : : * \param file the file containing one or more certs.
942 : : * \return a ::STACK containing the certs.
943 : : */
944 : 0 : STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
945 : : {
946 : : BIO *in;
947 : 0 : X509 *x=NULL;
948 : 0 : X509_NAME *xn=NULL;
949 : 0 : STACK_OF(X509_NAME) *ret = NULL,*sk;
950 : :
951 : 0 : sk=sk_X509_NAME_new(xname_cmp);
952 : :
953 : 0 : in=BIO_new(BIO_s_file_internal());
954 : :
955 [ # # ]: 0 : if ((sk == NULL) || (in == NULL))
956 : : {
957 : 0 : SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE,ERR_R_MALLOC_FAILURE);
958 : 0 : goto err;
959 : : }
960 : :
961 [ # # ]: 0 : if (!BIO_read_filename(in,file))
962 : : goto err;
963 : :
964 : : for (;;)
965 : : {
966 [ # # ]: 0 : if (PEM_read_bio_X509(in,&x,NULL,NULL) == NULL)
967 : : break;
968 [ # # ]: 0 : if (ret == NULL)
969 : : {
970 : 0 : ret = sk_X509_NAME_new_null();
971 [ # # ]: 0 : if (ret == NULL)
972 : : {
973 : 0 : SSLerr(SSL_F_SSL_LOAD_CLIENT_CA_FILE,ERR_R_MALLOC_FAILURE);
974 : 0 : goto err;
975 : : }
976 : : }
977 [ # # ]: 0 : if ((xn=X509_get_subject_name(x)) == NULL) goto err;
978 : : /* check for duplicates */
979 : 0 : xn=X509_NAME_dup(xn);
980 [ # # ]: 0 : if (xn == NULL) goto err;
981 [ # # ]: 0 : if (sk_X509_NAME_find(sk,xn) >= 0)
982 : 0 : X509_NAME_free(xn);
983 : : else
984 : : {
985 : 0 : sk_X509_NAME_push(sk,xn);
986 : 0 : sk_X509_NAME_push(ret,xn);
987 : : }
988 : : }
989 : :
990 : : if (0)
991 : : {
992 : : err:
993 [ # # ]: 0 : if (ret != NULL) sk_X509_NAME_pop_free(ret,X509_NAME_free);
994 : : ret=NULL;
995 : : }
996 [ # # ]: 0 : if (sk != NULL) sk_X509_NAME_free(sk);
997 [ # # ]: 0 : if (in != NULL) BIO_free(in);
998 [ # # ]: 0 : if (x != NULL) X509_free(x);
999 [ # # ]: 0 : if (ret != NULL)
1000 : 0 : ERR_clear_error();
1001 : 0 : return(ret);
1002 : : }
1003 : : #endif
1004 : :
1005 : : /*!
1006 : : * Add a file of certs to a stack.
1007 : : * \param stack the stack to add to.
1008 : : * \param file the file to add from. All certs in this file that are not
1009 : : * already in the stack will be added.
1010 : : * \return 1 for success, 0 for failure. Note that in the case of failure some
1011 : : * certs may have been added to \c stack.
1012 : : */
1013 : :
1014 : 0 : int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
1015 : : const char *file)
1016 : : {
1017 : : BIO *in;
1018 : 0 : X509 *x=NULL;
1019 : 0 : X509_NAME *xn=NULL;
1020 : 0 : int ret=1;
1021 : : int (*oldcmp)(const X509_NAME * const *a, const X509_NAME * const *b);
1022 : :
1023 : 0 : oldcmp=sk_X509_NAME_set_cmp_func(stack,xname_cmp);
1024 : :
1025 : 0 : in=BIO_new(BIO_s_file_internal());
1026 : :
1027 [ # # ]: 0 : if (in == NULL)
1028 : : {
1029 : 0 : SSLerr(SSL_F_SSL_ADD_FILE_CERT_SUBJECTS_TO_STACK,ERR_R_MALLOC_FAILURE);
1030 : 0 : goto err;
1031 : : }
1032 : :
1033 [ # # ]: 0 : if (!BIO_read_filename(in,file))
1034 : : goto err;
1035 : :
1036 : : for (;;)
1037 : : {
1038 [ # # ]: 0 : if (PEM_read_bio_X509(in,&x,NULL,NULL) == NULL)
1039 : : break;
1040 [ # # ]: 0 : if ((xn=X509_get_subject_name(x)) == NULL) goto err;
1041 : 0 : xn=X509_NAME_dup(xn);
1042 [ # # ]: 0 : if (xn == NULL) goto err;
1043 [ # # ]: 0 : if (sk_X509_NAME_find(stack,xn) >= 0)
1044 : 0 : X509_NAME_free(xn);
1045 : : else
1046 : 0 : sk_X509_NAME_push(stack,xn);
1047 : : }
1048 : :
1049 : 0 : ERR_clear_error();
1050 : :
1051 : : if (0)
1052 : : {
1053 : : err:
1054 : : ret=0;
1055 : : }
1056 [ # # ]: 0 : if(in != NULL)
1057 : 0 : BIO_free(in);
1058 [ # # ]: 0 : if(x != NULL)
1059 : 0 : X509_free(x);
1060 : :
1061 : 0 : (void)sk_X509_NAME_set_cmp_func(stack,oldcmp);
1062 : :
1063 : 0 : return ret;
1064 : : }
1065 : :
1066 : : /*!
1067 : : * Add a directory of certs to a stack.
1068 : : * \param stack the stack to append to.
1069 : : * \param dir the directory to append from. All files in this directory will be
1070 : : * examined as potential certs. Any that are acceptable to
1071 : : * SSL_add_dir_cert_subjects_to_stack() that are not already in the stack will be
1072 : : * included.
1073 : : * \return 1 for success, 0 for failure. Note that in the case of failure some
1074 : : * certs may have been added to \c stack.
1075 : : */
1076 : :
1077 : 0 : int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
1078 : : const char *dir)
1079 : : {
1080 : 0 : OPENSSL_DIR_CTX *d = NULL;
1081 : : const char *filename;
1082 : 0 : int ret = 0;
1083 : :
1084 : 0 : CRYPTO_w_lock(CRYPTO_LOCK_READDIR);
1085 : :
1086 : : /* Note that a side effect is that the CAs will be sorted by name */
1087 : :
1088 [ # # ]: 0 : while((filename = OPENSSL_DIR_read(&d, dir)))
1089 : : {
1090 : : char buf[1024];
1091 : : int r;
1092 : :
1093 [ # # ]: 0 : if(strlen(dir)+strlen(filename)+2 > sizeof buf)
1094 : : {
1095 : 0 : SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK,SSL_R_PATH_TOO_LONG);
1096 : 0 : goto err;
1097 : : }
1098 : :
1099 : : #ifdef OPENSSL_SYS_VMS
1100 : : r = BIO_snprintf(buf,sizeof buf,"%s%s",dir,filename);
1101 : : #else
1102 : 0 : r = BIO_snprintf(buf,sizeof buf,"%s/%s",dir,filename);
1103 : : #endif
1104 [ # # ]: 0 : if (r <= 0 || r >= (int)sizeof(buf))
1105 : : goto err;
1106 [ # # ]: 0 : if(!SSL_add_file_cert_subjects_to_stack(stack,buf))
1107 : : goto err;
1108 : : }
1109 : :
1110 [ # # ]: 0 : if (errno)
1111 : : {
1112 : 0 : SYSerr(SYS_F_OPENDIR, get_last_sys_error());
1113 : 0 : ERR_add_error_data(3, "OPENSSL_DIR_read(&ctx, '", dir, "')");
1114 : 0 : SSLerr(SSL_F_SSL_ADD_DIR_CERT_SUBJECTS_TO_STACK, ERR_R_SYS_LIB);
1115 : 0 : goto err;
1116 : : }
1117 : :
1118 : : ret = 1;
1119 : :
1120 : : err:
1121 [ # # ]: 0 : if (d) OPENSSL_DIR_end(&d);
1122 : 0 : CRYPTO_w_unlock(CRYPTO_LOCK_READDIR);
1123 : 0 : return ret;
1124 : : }
1125 : :
1126 : : /* Add a certificate to a BUF_MEM structure */
1127 : :
1128 : 1586 : static int ssl_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x)
1129 : : {
1130 : : int n;
1131 : : unsigned char *p;
1132 : :
1133 : 1586 : n=i2d_X509(x,NULL);
1134 [ - + ]: 1586 : if (!BUF_MEM_grow_clean(buf,(int)(n+(*l)+3)))
1135 : : {
1136 : 0 : SSLerr(SSL_F_SSL_ADD_CERT_TO_BUF,ERR_R_BUF_LIB);
1137 : 0 : return 0;
1138 : : }
1139 : 1586 : p=(unsigned char *)&(buf->data[*l]);
1140 : 1586 : l2n3(n,p);
1141 : 1586 : i2d_X509(x,&p);
1142 : 1586 : *l+=n+3;
1143 : :
1144 : 1586 : return 1;
1145 : : }
1146 : :
1147 : : /* Add certificate chain to internal SSL BUF_MEM strcuture */
1148 : 1036 : int ssl_add_cert_chain(SSL *s, CERT_PKEY *cpk, unsigned long *l)
1149 : : {
1150 : 1036 : BUF_MEM *buf = s->init_buf;
1151 : : int i;
1152 : :
1153 : : X509 *x;
1154 : : STACK_OF(X509) *extra_certs;
1155 : : X509_STORE *chain_store;
1156 : :
1157 : : /* TLSv1 sends a chain with nothing in it, instead of an alert */
1158 [ - + ]: 1036 : if (!BUF_MEM_grow_clean(buf,10))
1159 : : {
1160 : 0 : SSLerr(SSL_F_SSL_ADD_CERT_CHAIN,ERR_R_BUF_LIB);
1161 : 0 : return 0;
1162 : : }
1163 : :
1164 [ + - ][ + - ]: 1036 : if (!cpk || !cpk->x509)
1165 : : return 1;
1166 : :
1167 : 1036 : x = cpk->x509;
1168 : :
1169 : : /* If we have a certificate specific chain use it, else use
1170 : : * parent ctx.
1171 : : */
1172 [ + - ]: 1036 : if (cpk->chain)
1173 : : extra_certs = cpk->chain;
1174 : : else
1175 : 1036 : extra_certs = s->ctx->extra_certs;
1176 : :
1177 [ + - ][ + - ]: 1036 : if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs)
1178 : : chain_store = NULL;
1179 [ + - ]: 1036 : else if (s->cert->chain_store)
1180 : : chain_store = s->cert->chain_store;
1181 : : else
1182 : 1036 : chain_store = s->ctx->cert_store;
1183 : :
1184 [ + - ]: 1036 : if (chain_store)
1185 : : {
1186 : : X509_STORE_CTX xs_ctx;
1187 : :
1188 [ - + ]: 1036 : if (!X509_STORE_CTX_init(&xs_ctx,chain_store,x,NULL))
1189 : : {
1190 : 0 : SSLerr(SSL_F_SSL_ADD_CERT_CHAIN,ERR_R_X509_LIB);
1191 : 0 : return(0);
1192 : : }
1193 : 1036 : X509_verify_cert(&xs_ctx);
1194 : : /* Don't leave errors in the queue */
1195 : 1036 : ERR_clear_error();
1196 : 1036 : i = ssl_security_cert_chain(s, xs_ctx.chain, NULL, 0);
1197 [ + - ]: 1036 : if (i != 1)
1198 : : {
1199 : 0 : X509_STORE_CTX_cleanup(&xs_ctx);
1200 : 0 : SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
1201 : 0 : return 0;
1202 : : }
1203 [ + + ]: 2622 : for (i=0; i < sk_X509_num(xs_ctx.chain); i++)
1204 : : {
1205 : 1586 : x = sk_X509_value(xs_ctx.chain, i);
1206 : :
1207 [ - + ]: 1586 : if (!ssl_add_cert_to_buf(buf, l, x))
1208 : : {
1209 : 0 : X509_STORE_CTX_cleanup(&xs_ctx);
1210 : 0 : return 0;
1211 : : }
1212 : : }
1213 : 1036 : X509_STORE_CTX_cleanup(&xs_ctx);
1214 : : }
1215 : : else
1216 : : {
1217 : 0 : i = ssl_security_cert_chain(s, extra_certs, x, 0);
1218 [ # # ]: 0 : if (i != 1)
1219 : : {
1220 : 0 : SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
1221 : 0 : return 0;
1222 : : }
1223 [ # # ]: 0 : if (!ssl_add_cert_to_buf(buf, l, x))
1224 : : return 0;
1225 [ # # ]: 0 : for (i=0; i<sk_X509_num(extra_certs); i++)
1226 : : {
1227 : 0 : x=sk_X509_value(extra_certs,i);
1228 [ # # ]: 0 : if (!ssl_add_cert_to_buf(buf, l, x))
1229 : : return 0;
1230 : : }
1231 : : }
1232 : : return 1;
1233 : : }
1234 : :
1235 : : /* Build a certificate chain for current certificate */
1236 : 0 : int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags)
1237 : : {
1238 [ # # ]: 0 : CERT *c = s ? s->cert : ctx->cert;
1239 : 0 : CERT_PKEY *cpk = c->key;
1240 : 0 : X509_STORE *chain_store = NULL;
1241 : : X509_STORE_CTX xs_ctx;
1242 : 0 : STACK_OF(X509) *chain = NULL, *untrusted = NULL;
1243 : : X509 *x;
1244 : 0 : int i, rv = 0;
1245 : : unsigned long error;
1246 : :
1247 [ # # ]: 0 : if (!cpk->x509)
1248 : : {
1249 : 0 : SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_NO_CERTIFICATE_SET);
1250 : 0 : goto err;
1251 : : }
1252 : : /* Rearranging and check the chain: add everything to a store */
1253 [ # # ]: 0 : if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
1254 : : {
1255 : 0 : chain_store = X509_STORE_new();
1256 [ # # ]: 0 : if (!chain_store)
1257 : : goto err;
1258 [ # # ]: 0 : for (i = 0; i < sk_X509_num(cpk->chain); i++)
1259 : : {
1260 : 0 : x = sk_X509_value(cpk->chain, i);
1261 [ # # ]: 0 : if (!X509_STORE_add_cert(chain_store, x))
1262 : : {
1263 : 0 : error = ERR_peek_last_error();
1264 [ # # ][ # # ]: 0 : if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
1265 : 0 : ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE)
1266 : : goto err;
1267 : 0 : ERR_clear_error();
1268 : : }
1269 : : }
1270 : : /* Add EE cert too: it might be self signed */
1271 [ # # ]: 0 : if (!X509_STORE_add_cert(chain_store, cpk->x509))
1272 : : {
1273 : 0 : error = ERR_peek_last_error();
1274 [ # # ][ # # ]: 0 : if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
1275 : 0 : ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE)
1276 : : goto err;
1277 : 0 : ERR_clear_error();
1278 : : }
1279 : : }
1280 : : else
1281 : : {
1282 [ # # ]: 0 : if (c->chain_store)
1283 : : chain_store = c->chain_store;
1284 [ # # ]: 0 : else if (s)
1285 : 0 : chain_store = s->ctx->cert_store;
1286 : : else
1287 : 0 : chain_store = ctx->cert_store;
1288 : :
1289 [ # # ]: 0 : if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED)
1290 : 0 : untrusted = cpk->chain;
1291 : : }
1292 : :
1293 [ # # ]: 0 : if (!X509_STORE_CTX_init(&xs_ctx, chain_store, cpk->x509, untrusted))
1294 : : {
1295 : 0 : SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, ERR_R_X509_LIB);
1296 : 0 : goto err;
1297 : : }
1298 : : /* Set suite B flags if needed */
1299 : 0 : X509_STORE_CTX_set_flags(&xs_ctx, c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
1300 : :
1301 : 0 : i = X509_verify_cert(&xs_ctx);
1302 [ # # ][ # # ]: 0 : if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR)
1303 : : {
1304 [ # # ]: 0 : if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR)
1305 : 0 : ERR_clear_error();
1306 : : i = 1;
1307 : : rv = 2;
1308 : : }
1309 [ # # ]: 0 : if (i > 0)
1310 : 0 : chain = X509_STORE_CTX_get1_chain(&xs_ctx);
1311 [ # # ]: 0 : if (i <= 0)
1312 : : {
1313 : 0 : SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, SSL_R_CERTIFICATE_VERIFY_FAILED);
1314 : 0 : i = X509_STORE_CTX_get_error(&xs_ctx);
1315 : 0 : ERR_add_error_data(2, "Verify error:",
1316 : : X509_verify_cert_error_string(i));
1317 : :
1318 : 0 : X509_STORE_CTX_cleanup(&xs_ctx);
1319 : 0 : goto err;
1320 : : }
1321 : 0 : X509_STORE_CTX_cleanup(&xs_ctx);
1322 : : /* Remove EE certificate from chain */
1323 : 0 : x = sk_X509_shift(chain);
1324 : 0 : X509_free(x);
1325 [ # # ]: 0 : if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT)
1326 : : {
1327 [ # # ]: 0 : if (sk_X509_num(chain) > 0)
1328 : : {
1329 : : /* See if last cert is self signed */
1330 : 0 : x = sk_X509_value(chain, sk_X509_num(chain) - 1);
1331 : 0 : X509_check_purpose(x, -1, 0);
1332 [ # # ]: 0 : if (x->ex_flags & EXFLAG_SS)
1333 : : {
1334 : 0 : x = sk_X509_pop(chain);
1335 : 0 : X509_free(x);
1336 : : }
1337 : : }
1338 : : }
1339 : : /* Check security level of all CA certificates: EE will have been
1340 : : * checked already.
1341 : : */
1342 [ # # ]: 0 : for (i = 0; i < sk_X509_num(chain); i++)
1343 : : {
1344 : 0 : x = sk_X509_value(chain, i);
1345 : 0 : rv = ssl_security_cert(s, ctx, x, 0, 0);
1346 [ # # ]: 0 : if (rv != 1)
1347 : : {
1348 : 0 : SSLerr(SSL_F_SSL_BUILD_CERT_CHAIN, rv);
1349 : 0 : sk_X509_pop_free(chain, X509_free);
1350 : 0 : rv = 0;
1351 : 0 : goto err;
1352 : : }
1353 : : }
1354 [ # # ]: 0 : if (cpk->chain)
1355 : 0 : sk_X509_pop_free(cpk->chain, X509_free);
1356 : 0 : cpk->chain = chain;
1357 [ # # ]: 0 : if (rv == 0)
1358 : 0 : rv = 1;
1359 : : err:
1360 [ # # ]: 0 : if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
1361 : 0 : X509_STORE_free(chain_store);
1362 : :
1363 : 0 : return rv;
1364 : : }
1365 : :
1366 : 0 : int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref)
1367 : : {
1368 : : X509_STORE **pstore;
1369 [ # # ]: 0 : if (chain)
1370 : 0 : pstore = &c->chain_store;
1371 : : else
1372 : 0 : pstore = &c->verify_store;
1373 [ # # ]: 0 : if (*pstore)
1374 : 0 : X509_STORE_free(*pstore);
1375 : 0 : *pstore = store;
1376 [ # # ]: 0 : if (ref && store)
1377 : 0 : CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE);
1378 : 0 : return 1;
1379 : : }
1380 : :
1381 : 171726 : static int ssl_security_default_callback(SSL *s, SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex)
1382 : : {
1383 : : int level, minbits;
1384 : : static const int minbits_table[5] = {80, 112, 128, 192, 256};
1385 [ + + ]: 171726 : if (ctx)
1386 : 2811 : level = SSL_CTX_get_security_level(ctx);
1387 : : else
1388 : 168915 : level = SSL_get_security_level(s);
1389 : : /* Level 0: anything goes */
1390 [ - + ]: 171726 : if (level <= 0)
1391 : : return 1;
1392 [ # # ]: 0 : if (level > 5)
1393 : 0 : level = 5;
1394 : 0 : minbits = minbits_table[level - 1];
1395 [ # # # # : 0 : switch (op)
# # ]
1396 : : {
1397 : : case SSL_SECOP_CIPHER_SUPPORTED:
1398 : : case SSL_SECOP_CIPHER_SHARED:
1399 : : case SSL_SECOP_CIPHER_CHECK:
1400 : : {
1401 : 0 : const SSL_CIPHER *c = other;
1402 : : /* No ciphers below security level */
1403 [ # # ]: 0 : if (bits < minbits)
1404 : : return 0;
1405 : : /* No SSLv2 ciphers */
1406 [ # # ]: 0 : if ((SSL_CIPHER_get_id(c) >> 24) == 0x2)
1407 : : return 0;
1408 : : /* No unauthenticated ciphersuites */
1409 [ # # ]: 0 : if (c->algorithm_auth & SSL_aNULL)
1410 : : return 0;
1411 : : /* No MD5 mac ciphersuites */
1412 [ # # ]: 0 : if (c->algorithm_mac & SSL_MD5)
1413 : : return 0;
1414 : : /* SHA1 HMAC is 160 bits of security */
1415 [ # # ][ # # ]: 0 : if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
1416 : : return 0;
1417 : : /* Level 2: no RC4 */
1418 [ # # ][ # # ]: 0 : if (level >= 2 && c->algorithm_enc == SSL_RC4)
1419 : : return 0;
1420 : : /* Level 3: forward secure ciphersuites only */
1421 [ # # ][ # # ]: 0 : if (level >= 3 && !(c->algorithm_mkey & (SSL_kEDH|SSL_kEECDH)))
1422 : : return 0;
1423 : : break;
1424 : : }
1425 : : case SSL_SECOP_VERSION:
1426 : : /* SSLv2 allowed only on level zero */
1427 [ # # ]: 0 : if (nid == SSL2_VERSION)
1428 : : return 0;
1429 : : /* SSLv3 not allowed on level 2 */
1430 [ # # ]: 0 : if (nid <= SSL3_VERSION && level >= 2)
1431 : : return 0;
1432 : : /* TLS v1.1 and above only for level 3 */
1433 [ # # ]: 0 : if (nid <= TLS1_VERSION && level >= 3)
1434 : : return 0;
1435 : : /* TLS v1.2 only for level 4 and above */
1436 [ # # ]: 0 : if (nid <= TLS1_1_VERSION && level >= 4)
1437 : : return 0;
1438 : : break;
1439 : :
1440 : : case SSL_SECOP_COMPRESSION:
1441 [ # # ]: 0 : if (level >= 2)
1442 : : return 0;
1443 : : break;
1444 : : case SSL_SECOP_TICKET:
1445 [ # # ]: 0 : if (level >= 3)
1446 : : return 0;
1447 : : break;
1448 : : case SSL_SECOP_SSL2_COMPAT:
1449 : : /* SSLv2 compatible client hello only for level zero */
1450 : : return 0;
1451 : : default:
1452 [ # # ]: 0 : if (bits < minbits)
1453 : : return 0;
1454 : : }
1455 : : return 1;
1456 : : }
1457 : :
1458 : 168915 : int ssl_security(SSL *s, int op, int bits, int nid, void *other)
1459 : : {
1460 : 168915 : return s->cert->sec_cb(s, NULL, op, bits, nid, other, s->cert->sec_ex);
1461 : : }
1462 : :
1463 : 2811 : int ssl_ctx_security(SSL_CTX *ctx, int op, int bits, int nid, void *other)
1464 : : {
1465 : 2811 : return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other, ctx->cert->sec_ex);
1466 : : }
|
