blob: fd643086491f3caa51f154e1b936d9322ab87884 [file] [log] [blame]
Adam Langleyd1515a32017-01-23 16:46:16 -08001/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2 * All rights reserved.
3 *
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
7 *
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14 *
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
21 *
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
24 * are met:
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39 *
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 *
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
56 */
57/* ====================================================================
58 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
59 *
60 * Redistribution and use in source and binary forms, with or without
61 * modification, are permitted provided that the following conditions
62 * are met:
63 *
64 * 1. Redistributions of source code must retain the above copyright
65 * notice, this list of conditions and the following disclaimer.
66 *
67 * 2. Redistributions in binary form must reproduce the above copyright
68 * notice, this list of conditions and the following disclaimer in
69 * the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3. All advertising materials mentioning features or use of this
73 * software must display the following acknowledgment:
74 * "This product includes software developed by the OpenSSL Project
75 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
76 *
77 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
78 * endorse or promote products derived from this software without
79 * prior written permission. For written permission, please contact
80 * openssl-core@openssl.org.
81 *
82 * 5. Products derived from this software may not be called "OpenSSL"
83 * nor may "OpenSSL" appear in their names without prior written
84 * permission of the OpenSSL Project.
85 *
86 * 6. Redistributions of any form whatsoever must retain the following
87 * acknowledgment:
88 * "This product includes software developed by the OpenSSL Project
89 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
90 *
91 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
92 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
93 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
94 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
95 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
96 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
97 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
98 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
99 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
100 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
101 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
102 * OF THE POSSIBILITY OF SUCH DAMAGE.
103 * ====================================================================
104 *
105 * This product includes cryptographic software written by Eric Young
106 * (eay@cryptsoft.com). This product includes software written by Tim
107 * Hudson (tjh@cryptsoft.com).
108 *
109 */
110/* ====================================================================
111 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
112 * ECC cipher suite support in OpenSSL originally developed by
113 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
114 */
115/* ====================================================================
116 * Copyright 2005 Nokia. All rights reserved.
117 *
118 * The portions of the attached software ("Contribution") is developed by
119 * Nokia Corporation and is licensed pursuant to the OpenSSL open source
120 * license.
121 *
122 * The Contribution, originally written by Mika Kousa and Pasi Eronen of
123 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
124 * support (see RFC 4279) to OpenSSL.
125 *
126 * No patent licenses or other rights except those expressly stated in
127 * the OpenSSL open source license shall be deemed granted or received
128 * expressly, by implication, estoppel, or otherwise.
129 *
130 * No assurances are provided by Nokia that the Contribution does not
131 * infringe the patent or other intellectual property rights of any third
132 * party or that the license provides you with all the necessary rights
133 * to make use of the Contribution.
134 *
135 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
136 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
137 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
138 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
139 * OTHERWISE. */
140
141#include <openssl/ssl.h>
142
Adam Langley3509dac2017-02-01 11:59:18 -0800143#include <assert.h>
144
Adam Langley46db7af2017-02-01 15:49:37 -0800145#include <openssl/asn1.h>
146#include <openssl/bytestring.h>
147#include <openssl/err.h>
148#include <openssl/pem.h>
Adam Langleyd1515a32017-01-23 16:46:16 -0800149#include <openssl/stack.h>
150#include <openssl/x509.h>
Adam Langley3509dac2017-02-01 11:59:18 -0800151#include <openssl/x509v3.h>
Adam Langleyd1515a32017-01-23 16:46:16 -0800152#include <openssl/x509_vfy.h>
153
154#include "internal.h"
Adam Langley34b4c822017-02-02 10:57:17 -0800155#include "../crypto/internal.h"
Adam Langleyd1515a32017-01-23 16:46:16 -0800156
157
David Benjamin86e95b82017-07-18 16:34:25 -0400158namespace bssl {
159
Adam Langley415c0102017-02-10 13:30:23 -0800160/* check_ssl_x509_method asserts that |ssl| has the X509-based method
161 * installed. Calling an X509-based method on an |ssl| with a different method
162 * will likely misbehave and possibly crash or leak memory. */
163static void check_ssl_x509_method(const SSL *ssl) {
164 assert(ssl == NULL || ssl->ctx->x509_method == &ssl_crypto_x509_method);
165}
166
167/* check_ssl_ctx_x509_method acts like |check_ssl_x509_method|, but for an
168 * |SSL_CTX|. */
169static void check_ssl_ctx_x509_method(const SSL_CTX *ctx) {
170 assert(ctx == NULL || ctx->x509_method == &ssl_crypto_x509_method);
171}
172
Adam Langley94a62e62017-02-10 15:24:56 -0800173/* x509_to_buffer returns a |CRYPTO_BUFFER| that contains the serialised
174 * contents of |x509|. */
175static CRYPTO_BUFFER *x509_to_buffer(X509 *x509) {
176 uint8_t *buf = NULL;
177 int cert_len = i2d_X509(x509, &buf);
178 if (cert_len <= 0) {
179 return 0;
180 }
181
182 CRYPTO_BUFFER *buffer = CRYPTO_BUFFER_new(buf, cert_len, NULL);
183 OPENSSL_free(buf);
184
185 return buffer;
186}
187
188/* new_leafless_chain returns a fresh stack of buffers set to {NULL}. */
189static STACK_OF(CRYPTO_BUFFER) *new_leafless_chain(void) {
190 STACK_OF(CRYPTO_BUFFER) *chain = sk_CRYPTO_BUFFER_new_null();
191 if (chain == NULL) {
192 return NULL;
193 }
194
195 if (!sk_CRYPTO_BUFFER_push(chain, NULL)) {
196 sk_CRYPTO_BUFFER_free(chain);
197 return NULL;
198 }
199
200 return chain;
201}
202
203/* ssl_cert_set_chain sets elements 1.. of |cert->chain| to the serialised
204 * forms of elements of |chain|. It returns one on success or zero on error, in
205 * which case no change to |cert->chain| is made. It preverses the existing
206 * leaf from |cert->chain|, if any. */
207static int ssl_cert_set_chain(CERT *cert, STACK_OF(X509) *chain) {
208 STACK_OF(CRYPTO_BUFFER) *new_chain = NULL;
209
210 if (cert->chain != NULL) {
211 new_chain = sk_CRYPTO_BUFFER_new_null();
212 if (new_chain == NULL) {
213 return 0;
214 }
215
216 CRYPTO_BUFFER *leaf = sk_CRYPTO_BUFFER_value(cert->chain, 0);
217 if (!sk_CRYPTO_BUFFER_push(new_chain, leaf)) {
218 goto err;
219 }
220 /* |leaf| might be NULL if it's a “leafless” chain. */
221 if (leaf != NULL) {
222 CRYPTO_BUFFER_up_ref(leaf);
223 }
224 }
225
226 for (size_t i = 0; i < sk_X509_num(chain); i++) {
227 if (new_chain == NULL) {
228 new_chain = new_leafless_chain();
229 if (new_chain == NULL) {
230 goto err;
231 }
232 }
233
234 CRYPTO_BUFFER *buffer = x509_to_buffer(sk_X509_value(chain, i));
235 if (buffer == NULL ||
236 !sk_CRYPTO_BUFFER_push(new_chain, buffer)) {
237 CRYPTO_BUFFER_free(buffer);
238 goto err;
239 }
240 }
241
242 sk_CRYPTO_BUFFER_pop_free(cert->chain, CRYPTO_BUFFER_free);
243 cert->chain = new_chain;
244
245 return 1;
246
247err:
248 sk_CRYPTO_BUFFER_pop_free(new_chain, CRYPTO_BUFFER_free);
249 return 0;
250}
251
Adam Langleyd5c565a2017-02-28 10:38:40 -0800252static void ssl_crypto_x509_cert_flush_cached_leaf(CERT *cert) {
Adam Langley3509dac2017-02-01 11:59:18 -0800253 X509_free(cert->x509_leaf);
254 cert->x509_leaf = NULL;
255}
256
Adam Langleyd5c565a2017-02-28 10:38:40 -0800257static void ssl_crypto_x509_cert_flush_cached_chain(CERT *cert) {
Adam Langley3509dac2017-02-01 11:59:18 -0800258 sk_X509_pop_free(cert->x509_chain, X509_free);
259 cert->x509_chain = NULL;
260}
261
Adam Langley0bdef092017-02-23 15:02:58 -0800262static int ssl_crypto_x509_check_client_CA_list(
263 STACK_OF(CRYPTO_BUFFER) *names) {
264 for (size_t i = 0; i < sk_CRYPTO_BUFFER_num(names); i++) {
265 const CRYPTO_BUFFER *buffer = sk_CRYPTO_BUFFER_value(names, i);
266 const uint8_t *inp = CRYPTO_BUFFER_data(buffer);
267 X509_NAME *name = d2i_X509_NAME(NULL, &inp, CRYPTO_BUFFER_len(buffer));
268 const int ok = name != NULL && inp == CRYPTO_BUFFER_data(buffer) +
269 CRYPTO_BUFFER_len(buffer);
270 X509_NAME_free(name);
271 if (!ok) {
272 return 0;
273 }
274 }
275
276 return 1;
277}
278
Adam Langleyd5c565a2017-02-28 10:38:40 -0800279static void ssl_crypto_x509_cert_clear(CERT *cert) {
280 ssl_crypto_x509_cert_flush_cached_leaf(cert);
281 ssl_crypto_x509_cert_flush_cached_chain(cert);
Adam Langley3509dac2017-02-01 11:59:18 -0800282
283 X509_free(cert->x509_stash);
284 cert->x509_stash = NULL;
285}
286
Adam Langleyd5c565a2017-02-28 10:38:40 -0800287static void ssl_crypto_x509_cert_free(CERT *cert) {
288 ssl_crypto_x509_cert_clear(cert);
Adam Langley2a3b3432017-02-10 13:56:48 -0800289 X509_STORE_free(cert->verify_store);
290}
291
Adam Langleyd5c565a2017-02-28 10:38:40 -0800292static void ssl_crypto_x509_cert_dup(CERT *new_cert, const CERT *cert) {
Adam Langley2a3b3432017-02-10 13:56:48 -0800293 if (cert->verify_store != NULL) {
294 X509_STORE_up_ref(cert->verify_store);
295 new_cert->verify_store = cert->verify_store;
296 }
297}
298
Adam Langley46db7af2017-02-01 15:49:37 -0800299static int ssl_crypto_x509_session_cache_objects(SSL_SESSION *sess) {
David Benjamine8703a32017-07-09 16:17:55 -0400300 bssl::UniquePtr<STACK_OF(X509)> chain;
Adam Langley46db7af2017-02-01 15:49:37 -0800301 const size_t num_certs = sk_CRYPTO_BUFFER_num(sess->certs);
Adam Langley46db7af2017-02-01 15:49:37 -0800302 if (num_certs > 0) {
David Benjamine8703a32017-07-09 16:17:55 -0400303 chain.reset(sk_X509_new_null());
304 if (!chain) {
Adam Langley46db7af2017-02-01 15:49:37 -0800305 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
David Benjamine8703a32017-07-09 16:17:55 -0400306 return 0;
Adam Langley46db7af2017-02-01 15:49:37 -0800307 }
308 }
309
310 X509 *leaf = NULL;
311 for (size_t i = 0; i < num_certs; i++) {
312 X509 *x509 = X509_parse_from_buffer(sk_CRYPTO_BUFFER_value(sess->certs, i));
313 if (x509 == NULL) {
314 OPENSSL_PUT_ERROR(SSL, SSL_R_DECODE_ERROR);
David Benjamine8703a32017-07-09 16:17:55 -0400315 return 0;
Adam Langley46db7af2017-02-01 15:49:37 -0800316 }
David Benjamine8703a32017-07-09 16:17:55 -0400317 if (!sk_X509_push(chain.get(), x509)) {
Adam Langley46db7af2017-02-01 15:49:37 -0800318 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
319 X509_free(x509);
David Benjamine8703a32017-07-09 16:17:55 -0400320 return 0;
Adam Langley46db7af2017-02-01 15:49:37 -0800321 }
322 if (i == 0) {
323 leaf = x509;
324 }
325 }
326
327 sk_X509_pop_free(sess->x509_chain, X509_free);
David Benjamine8703a32017-07-09 16:17:55 -0400328 sess->x509_chain = chain.release();
Adam Langley46db7af2017-02-01 15:49:37 -0800329 sk_X509_pop_free(sess->x509_chain_without_leaf, X509_free);
330 sess->x509_chain_without_leaf = NULL;
331
332 X509_free(sess->x509_peer);
333 if (leaf != NULL) {
334 X509_up_ref(leaf);
335 }
336 sess->x509_peer = leaf;
Adam Langley46db7af2017-02-01 15:49:37 -0800337 return 1;
Adam Langley46db7af2017-02-01 15:49:37 -0800338}
339
340static int ssl_crypto_x509_session_dup(SSL_SESSION *new_session,
341 const SSL_SESSION *session) {
342 if (session->x509_peer != NULL) {
343 X509_up_ref(session->x509_peer);
344 new_session->x509_peer = session->x509_peer;
345 }
346 if (session->x509_chain != NULL) {
347 new_session->x509_chain = X509_chain_up_ref(session->x509_chain);
348 if (new_session->x509_chain == NULL) {
349 return 0;
350 }
351 }
352
353 return 1;
354}
355
356static void ssl_crypto_x509_session_clear(SSL_SESSION *session) {
357 X509_free(session->x509_peer);
358 session->x509_peer = NULL;
359 sk_X509_pop_free(session->x509_chain, X509_free);
360 session->x509_chain = NULL;
361 sk_X509_pop_free(session->x509_chain_without_leaf, X509_free);
362 session->x509_chain_without_leaf = NULL;
363}
364
David Benjamin54689ed2017-02-28 20:07:22 -0500365static int ssl_verify_alarm_type(long type) {
366 switch (type) {
367 case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
368 case X509_V_ERR_UNABLE_TO_GET_CRL:
369 case X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER:
370 return SSL_AD_UNKNOWN_CA;
371
372 case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
373 case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
374 case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
375 case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
376 case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
377 case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
378 case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
379 case X509_V_ERR_CERT_NOT_YET_VALID:
380 case X509_V_ERR_CRL_NOT_YET_VALID:
381 case X509_V_ERR_CERT_UNTRUSTED:
382 case X509_V_ERR_CERT_REJECTED:
383 case X509_V_ERR_HOSTNAME_MISMATCH:
384 case X509_V_ERR_EMAIL_MISMATCH:
385 case X509_V_ERR_IP_ADDRESS_MISMATCH:
386 return SSL_AD_BAD_CERTIFICATE;
387
388 case X509_V_ERR_CERT_SIGNATURE_FAILURE:
389 case X509_V_ERR_CRL_SIGNATURE_FAILURE:
390 return SSL_AD_DECRYPT_ERROR;
391
392 case X509_V_ERR_CERT_HAS_EXPIRED:
393 case X509_V_ERR_CRL_HAS_EXPIRED:
394 return SSL_AD_CERTIFICATE_EXPIRED;
395
396 case X509_V_ERR_CERT_REVOKED:
397 return SSL_AD_CERTIFICATE_REVOKED;
398
399 case X509_V_ERR_UNSPECIFIED:
400 case X509_V_ERR_OUT_OF_MEM:
401 case X509_V_ERR_INVALID_CALL:
402 case X509_V_ERR_STORE_LOOKUP:
403 return SSL_AD_INTERNAL_ERROR;
404
405 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
406 case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
407 case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
408 case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
409 case X509_V_ERR_CERT_CHAIN_TOO_LONG:
410 case X509_V_ERR_PATH_LENGTH_EXCEEDED:
411 case X509_V_ERR_INVALID_CA:
412 return SSL_AD_UNKNOWN_CA;
413
414 case X509_V_ERR_APPLICATION_VERIFICATION:
415 return SSL_AD_HANDSHAKE_FAILURE;
416
417 case X509_V_ERR_INVALID_PURPOSE:
418 return SSL_AD_UNSUPPORTED_CERTIFICATE;
419
420 default:
421 return SSL_AD_CERTIFICATE_UNKNOWN;
422 }
423}
424
Adam Langley2a3b3432017-02-10 13:56:48 -0800425static int ssl_crypto_x509_session_verify_cert_chain(SSL_SESSION *session,
David Benjamin3a1dd462017-07-11 16:13:10 -0400426 SSL *ssl,
427 uint8_t *out_alert) {
428 *out_alert = SSL_AD_INTERNAL_ERROR;
Adam Langley2a3b3432017-02-10 13:56:48 -0800429 STACK_OF(X509) *const cert_chain = session->x509_chain;
430 if (cert_chain == NULL || sk_X509_num(cert_chain) == 0) {
431 return 0;
432 }
433
434 X509_STORE *verify_store = ssl->ctx->cert_store;
435 if (ssl->cert->verify_store != NULL) {
436 verify_store = ssl->cert->verify_store;
437 }
438
439 X509 *leaf = sk_X509_value(cert_chain, 0);
440 int ret = 0;
441 X509_STORE_CTX ctx;
442 if (!X509_STORE_CTX_init(&ctx, verify_store, leaf, cert_chain)) {
443 OPENSSL_PUT_ERROR(SSL, ERR_R_X509_LIB);
444 return 0;
445 }
446 if (!X509_STORE_CTX_set_ex_data(&ctx, SSL_get_ex_data_X509_STORE_CTX_idx(),
447 ssl)) {
448 goto err;
449 }
450
451 /* We need to inherit the verify parameters. These can be determined by the
452 * context: if its a server it will verify SSL client certificates or vice
453 * versa. */
454 X509_STORE_CTX_set_default(&ctx, ssl->server ? "ssl_client" : "ssl_server");
455
456 /* Anything non-default in "param" should overwrite anything in the ctx. */
457 X509_VERIFY_PARAM_set1(X509_STORE_CTX_get0_param(&ctx), ssl->param);
458
459 if (ssl->verify_callback) {
460 X509_STORE_CTX_set_verify_cb(&ctx, ssl->verify_callback);
461 }
462
463 int verify_ret;
464 if (ssl->ctx->app_verify_callback != NULL) {
465 verify_ret = ssl->ctx->app_verify_callback(&ctx, ssl->ctx->app_verify_arg);
466 } else {
467 verify_ret = X509_verify_cert(&ctx);
468 }
469
470 session->verify_result = ctx.error;
471
472 /* If |SSL_VERIFY_NONE|, the error is non-fatal, but we keep the result. */
473 if (verify_ret <= 0 && ssl->verify_mode != SSL_VERIFY_NONE) {
David Benjamin3a1dd462017-07-11 16:13:10 -0400474 *out_alert = ssl_verify_alarm_type(ctx.error);
Adam Langley2a3b3432017-02-10 13:56:48 -0800475 goto err;
476 }
477
478 ERR_clear_error();
479 ret = 1;
480
481err:
482 X509_STORE_CTX_cleanup(&ctx);
483 return ret;
484}
485
Adam Langley34b4c822017-02-02 10:57:17 -0800486static void ssl_crypto_x509_hs_flush_cached_ca_names(SSL_HANDSHAKE *hs) {
487 sk_X509_NAME_pop_free(hs->cached_x509_ca_names, X509_NAME_free);
488 hs->cached_x509_ca_names = NULL;
489}
490
Adam Langley2a3b3432017-02-10 13:56:48 -0800491static int ssl_crypto_x509_ssl_new(SSL *ssl) {
492 ssl->param = X509_VERIFY_PARAM_new();
493 if (ssl->param == NULL) {
494 return 0;
495 }
496 X509_VERIFY_PARAM_inherit(ssl->param, ssl->ctx->param);
497 return 1;
498}
499
Adam Langley34b4c822017-02-02 10:57:17 -0800500static void ssl_crypto_x509_ssl_flush_cached_client_CA(SSL *ssl) {
501 sk_X509_NAME_pop_free(ssl->cached_x509_client_CA, X509_NAME_free);
502 ssl->cached_x509_client_CA = NULL;
503}
504
Adam Langley2a3b3432017-02-10 13:56:48 -0800505static void ssl_crypto_x509_ssl_free(SSL *ssl) {
506 ssl_crypto_x509_ssl_flush_cached_client_CA(ssl);
507 X509_VERIFY_PARAM_free(ssl->param);
508}
509
Adam Langley94a62e62017-02-10 15:24:56 -0800510static int ssl_crypto_x509_ssl_auto_chain_if_needed(SSL *ssl) {
511 /* Only build a chain if there are no intermediates configured and the feature
512 * isn't disabled. */
513 if ((ssl->mode & SSL_MODE_NO_AUTO_CHAIN) ||
514 !ssl_has_certificate(ssl) ||
515 ssl->cert->chain == NULL ||
516 sk_CRYPTO_BUFFER_num(ssl->cert->chain) > 1) {
517 return 1;
518 }
519
520 X509 *leaf =
521 X509_parse_from_buffer(sk_CRYPTO_BUFFER_value(ssl->cert->chain, 0));
522 if (!leaf) {
523 OPENSSL_PUT_ERROR(SSL, ERR_R_X509_LIB);
524 return 0;
525 }
526
527 X509_STORE_CTX ctx;
528 if (!X509_STORE_CTX_init(&ctx, ssl->ctx->cert_store, leaf, NULL)) {
529 X509_free(leaf);
530 OPENSSL_PUT_ERROR(SSL, ERR_R_X509_LIB);
531 return 0;
532 }
533
534 /* Attempt to build a chain, ignoring the result. */
535 X509_verify_cert(&ctx);
536 X509_free(leaf);
537 ERR_clear_error();
538
539 /* Remove the leaf from the generated chain. */
540 X509_free(sk_X509_shift(ctx.chain));
541
542 const int ok = ssl_cert_set_chain(ssl->cert, ctx.chain);
543 X509_STORE_CTX_cleanup(&ctx);
544 if (!ok) {
545 return 0;
546 }
547
Adam Langleyd5c565a2017-02-28 10:38:40 -0800548 ssl_crypto_x509_cert_flush_cached_chain(ssl->cert);
Adam Langley94a62e62017-02-10 15:24:56 -0800549
550 return 1;
551}
552
Adam Langley34b4c822017-02-02 10:57:17 -0800553static void ssl_crypto_x509_ssl_ctx_flush_cached_client_CA(SSL_CTX *ctx) {
554 sk_X509_NAME_pop_free(ctx->cached_x509_client_CA, X509_NAME_free);
555 ctx->cached_x509_client_CA = NULL;
556}
557
Adam Langley2a3b3432017-02-10 13:56:48 -0800558static int ssl_crypto_x509_ssl_ctx_new(SSL_CTX *ctx) {
559 ctx->cert_store = X509_STORE_new();
560 ctx->param = X509_VERIFY_PARAM_new();
561 return (ctx->cert_store != NULL && ctx->param != NULL);
562}
563
564static void ssl_crypto_x509_ssl_ctx_free(SSL_CTX *ctx) {
565 ssl_crypto_x509_ssl_ctx_flush_cached_client_CA(ctx);
566 X509_VERIFY_PARAM_free(ctx->param);
567 X509_STORE_free(ctx->cert_store);
568}
569
Adam Langley3509dac2017-02-01 11:59:18 -0800570const SSL_X509_METHOD ssl_crypto_x509_method = {
Adam Langley0bdef092017-02-23 15:02:58 -0800571 ssl_crypto_x509_check_client_CA_list,
Adam Langleyd5c565a2017-02-28 10:38:40 -0800572 ssl_crypto_x509_cert_clear,
573 ssl_crypto_x509_cert_free,
574 ssl_crypto_x509_cert_dup,
575 ssl_crypto_x509_cert_flush_cached_chain,
576 ssl_crypto_x509_cert_flush_cached_leaf,
Adam Langley46db7af2017-02-01 15:49:37 -0800577 ssl_crypto_x509_session_cache_objects,
578 ssl_crypto_x509_session_dup,
579 ssl_crypto_x509_session_clear,
Adam Langley2a3b3432017-02-10 13:56:48 -0800580 ssl_crypto_x509_session_verify_cert_chain,
Adam Langley34b4c822017-02-02 10:57:17 -0800581 ssl_crypto_x509_hs_flush_cached_ca_names,
Adam Langley2a3b3432017-02-10 13:56:48 -0800582 ssl_crypto_x509_ssl_new,
583 ssl_crypto_x509_ssl_free,
Adam Langley34b4c822017-02-02 10:57:17 -0800584 ssl_crypto_x509_ssl_flush_cached_client_CA,
Adam Langley94a62e62017-02-10 15:24:56 -0800585 ssl_crypto_x509_ssl_auto_chain_if_needed,
Adam Langley2a3b3432017-02-10 13:56:48 -0800586 ssl_crypto_x509_ssl_ctx_new,
587 ssl_crypto_x509_ssl_ctx_free,
Adam Langley34b4c822017-02-02 10:57:17 -0800588 ssl_crypto_x509_ssl_ctx_flush_cached_client_CA,
Adam Langley3509dac2017-02-01 11:59:18 -0800589};
590
David Benjamin86e95b82017-07-18 16:34:25 -0400591} // namespace bssl
592
593using namespace bssl;
594
595X509 *SSL_get_peer_certificate(const SSL *ssl) {
596 check_ssl_x509_method(ssl);
597 if (ssl == NULL) {
598 return NULL;
599 }
600 SSL_SESSION *session = SSL_get_session(ssl);
601 if (session == NULL || session->x509_peer == NULL) {
602 return NULL;
603 }
604 X509_up_ref(session->x509_peer);
605 return session->x509_peer;
606}
607
608STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *ssl) {
609 check_ssl_x509_method(ssl);
610 if (ssl == NULL) {
611 return NULL;
612 }
613 SSL_SESSION *session = SSL_get_session(ssl);
614 if (session == NULL ||
615 session->x509_chain == NULL) {
616 return NULL;
617 }
618
619 if (!ssl->server) {
620 return session->x509_chain;
621 }
622
623 /* OpenSSL historically didn't include the leaf certificate in the returned
624 * certificate chain, but only for servers. */
625 if (session->x509_chain_without_leaf == NULL) {
626 session->x509_chain_without_leaf = sk_X509_new_null();
627 if (session->x509_chain_without_leaf == NULL) {
628 return NULL;
629 }
630
631 for (size_t i = 1; i < sk_X509_num(session->x509_chain); i++) {
632 X509 *cert = sk_X509_value(session->x509_chain, i);
633 if (!sk_X509_push(session->x509_chain_without_leaf, cert)) {
634 sk_X509_pop_free(session->x509_chain_without_leaf, X509_free);
635 session->x509_chain_without_leaf = NULL;
636 return NULL;
637 }
638 X509_up_ref(cert);
639 }
640 }
641
642 return session->x509_chain_without_leaf;
643}
644
645STACK_OF(X509) *SSL_get_peer_full_cert_chain(const SSL *ssl) {
646 check_ssl_x509_method(ssl);
647 SSL_SESSION *session = SSL_get_session(ssl);
648 if (session == NULL) {
649 return NULL;
650 }
651
652 return session->x509_chain;
653}
654
655int SSL_CTX_set_purpose(SSL_CTX *ctx, int purpose) {
656 check_ssl_ctx_x509_method(ctx);
657 return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose);
658}
659
660int SSL_set_purpose(SSL *ssl, int purpose) {
661 check_ssl_x509_method(ssl);
662 return X509_VERIFY_PARAM_set_purpose(ssl->param, purpose);
663}
664
665int SSL_CTX_set_trust(SSL_CTX *ctx, int trust) {
666 check_ssl_ctx_x509_method(ctx);
667 return X509_VERIFY_PARAM_set_trust(ctx->param, trust);
668}
669
670int SSL_set_trust(SSL *ssl, int trust) {
671 check_ssl_x509_method(ssl);
672 return X509_VERIFY_PARAM_set_trust(ssl->param, trust);
673}
674
675int SSL_CTX_set1_param(SSL_CTX *ctx, const X509_VERIFY_PARAM *param) {
676 check_ssl_ctx_x509_method(ctx);
677 return X509_VERIFY_PARAM_set1(ctx->param, param);
678}
679
680int SSL_set1_param(SSL *ssl, const X509_VERIFY_PARAM *param) {
681 check_ssl_x509_method(ssl);
682 return X509_VERIFY_PARAM_set1(ssl->param, param);
683}
684
685X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx) {
686 check_ssl_ctx_x509_method(ctx);
687 return ctx->param;
688}
689
690X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl) {
691 check_ssl_x509_method(ssl);
692 return ssl->param;
693}
694
695int SSL_get_verify_depth(const SSL *ssl) {
696 check_ssl_x509_method(ssl);
697 return X509_VERIFY_PARAM_get_depth(ssl->param);
698}
699
700int (*SSL_get_verify_callback(const SSL *ssl))(int, X509_STORE_CTX *) {
701 check_ssl_x509_method(ssl);
702 return ssl->verify_callback;
703}
704
705int SSL_CTX_get_verify_mode(const SSL_CTX *ctx) {
706 check_ssl_ctx_x509_method(ctx);
707 return ctx->verify_mode;
708}
709
710int SSL_CTX_get_verify_depth(const SSL_CTX *ctx) {
711 check_ssl_ctx_x509_method(ctx);
712 return X509_VERIFY_PARAM_get_depth(ctx->param);
713}
714
715int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(
716 int ok, X509_STORE_CTX *store_ctx) {
717 check_ssl_ctx_x509_method(ctx);
718 return ctx->default_verify_callback;
719}
720
721void SSL_set_verify(SSL *ssl, int mode,
722 int (*callback)(int ok, X509_STORE_CTX *store_ctx)) {
723 check_ssl_x509_method(ssl);
724 ssl->verify_mode = mode;
725 if (callback != NULL) {
726 ssl->verify_callback = callback;
727 }
728}
729
730void SSL_set_verify_depth(SSL *ssl, int depth) {
731 check_ssl_x509_method(ssl);
732 X509_VERIFY_PARAM_set_depth(ssl->param, depth);
733}
734
735void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
736 int (*cb)(X509_STORE_CTX *store_ctx,
737 void *arg),
738 void *arg) {
739 check_ssl_ctx_x509_method(ctx);
740 ctx->app_verify_callback = cb;
741 ctx->app_verify_arg = arg;
742}
743
744void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
745 int (*cb)(int, X509_STORE_CTX *)) {
746 check_ssl_ctx_x509_method(ctx);
747 ctx->verify_mode = mode;
748 ctx->default_verify_callback = cb;
749}
750
751void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth) {
752 check_ssl_ctx_x509_method(ctx);
753 X509_VERIFY_PARAM_set_depth(ctx->param, depth);
754}
755
756int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx) {
757 check_ssl_ctx_x509_method(ctx);
758 return X509_STORE_set_default_paths(ctx->cert_store);
759}
760
761int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *ca_file,
762 const char *ca_dir) {
763 check_ssl_ctx_x509_method(ctx);
764 return X509_STORE_load_locations(ctx->cert_store, ca_file, ca_dir);
765}
766
767void SSL_set_verify_result(SSL *ssl, long result) {
768 check_ssl_x509_method(ssl);
769 if (result != X509_V_OK) {
770 abort();
771 }
772}
773
774long SSL_get_verify_result(const SSL *ssl) {
775 check_ssl_x509_method(ssl);
776 SSL_SESSION *session = SSL_get_session(ssl);
777 if (session == NULL) {
778 return X509_V_ERR_INVALID_CALL;
779 }
780 return session->verify_result;
781}
782
783X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx) {
784 check_ssl_ctx_x509_method(ctx);
785 return ctx->cert_store;
786}
787
788void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store) {
789 check_ssl_ctx_x509_method(ctx);
790 X509_STORE_free(ctx->cert_store);
791 ctx->cert_store = store;
792}
793
Adam Langley3509dac2017-02-01 11:59:18 -0800794static int ssl_use_certificate(CERT *cert, X509 *x) {
795 if (x == NULL) {
796 OPENSSL_PUT_ERROR(SSL, ERR_R_PASSED_NULL_PARAMETER);
797 return 0;
798 }
799
800 CRYPTO_BUFFER *buffer = x509_to_buffer(x);
801 if (buffer == NULL) {
802 return 0;
803 }
804
805 const int ok = ssl_set_cert(cert, buffer);
806 CRYPTO_BUFFER_free(buffer);
807 return ok;
808}
809
810int SSL_use_certificate(SSL *ssl, X509 *x) {
Adam Langley415c0102017-02-10 13:30:23 -0800811 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800812 return ssl_use_certificate(ssl->cert, x);
813}
814
815int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x) {
Adam Langley415c0102017-02-10 13:30:23 -0800816 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800817 return ssl_use_certificate(ctx->cert, x);
818}
819
820/* ssl_cert_cache_leaf_cert sets |cert->x509_leaf|, if currently NULL, from the
821 * first element of |cert->chain|. */
822static int ssl_cert_cache_leaf_cert(CERT *cert) {
823 assert(cert->x509_method);
824
825 if (cert->x509_leaf != NULL ||
826 cert->chain == NULL) {
827 return 1;
828 }
829
830 CRYPTO_BUFFER *leaf = sk_CRYPTO_BUFFER_value(cert->chain, 0);
831 if (!leaf) {
832 return 1;
833 }
834
835 cert->x509_leaf = X509_parse_from_buffer(leaf);
836 return cert->x509_leaf != NULL;
837}
838
839static X509 *ssl_cert_get0_leaf(CERT *cert) {
840 if (cert->x509_leaf == NULL &&
841 !ssl_cert_cache_leaf_cert(cert)) {
842 return NULL;
843 }
844
845 return cert->x509_leaf;
846}
847
848X509 *SSL_get_certificate(const SSL *ssl) {
Adam Langley415c0102017-02-10 13:30:23 -0800849 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800850 return ssl_cert_get0_leaf(ssl->cert);
851}
852
853X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx) {
Adam Langley415c0102017-02-10 13:30:23 -0800854 check_ssl_ctx_x509_method(ctx);
Adam Langley34b4c822017-02-02 10:57:17 -0800855 CRYPTO_MUTEX_lock_write((CRYPTO_MUTEX *) &ctx->lock);
856 X509 *ret = ssl_cert_get0_leaf(ctx->cert);
857 CRYPTO_MUTEX_unlock_write((CRYPTO_MUTEX *) &ctx->lock);
858 return ret;
Adam Langley3509dac2017-02-01 11:59:18 -0800859}
860
Adam Langley3509dac2017-02-01 11:59:18 -0800861static int ssl_cert_set0_chain(CERT *cert, STACK_OF(X509) *chain) {
862 if (!ssl_cert_set_chain(cert, chain)) {
863 return 0;
864 }
865
866 sk_X509_pop_free(chain, X509_free);
Adam Langleyd5c565a2017-02-28 10:38:40 -0800867 ssl_crypto_x509_cert_flush_cached_chain(cert);
Adam Langley3509dac2017-02-01 11:59:18 -0800868 return 1;
869}
870
871static int ssl_cert_set1_chain(CERT *cert, STACK_OF(X509) *chain) {
872 if (!ssl_cert_set_chain(cert, chain)) {
873 return 0;
874 }
875
Adam Langleyd5c565a2017-02-28 10:38:40 -0800876 ssl_crypto_x509_cert_flush_cached_chain(cert);
Adam Langley3509dac2017-02-01 11:59:18 -0800877 return 1;
878}
879
880static int ssl_cert_append_cert(CERT *cert, X509 *x509) {
881 assert(cert->x509_method);
882
883 CRYPTO_BUFFER *buffer = x509_to_buffer(x509);
884 if (buffer == NULL) {
885 return 0;
886 }
887
888 if (cert->chain != NULL) {
889 if (!sk_CRYPTO_BUFFER_push(cert->chain, buffer)) {
890 CRYPTO_BUFFER_free(buffer);
891 return 0;
892 }
893
894 return 1;
895 }
896
897 cert->chain = new_leafless_chain();
898 if (cert->chain == NULL ||
899 !sk_CRYPTO_BUFFER_push(cert->chain, buffer)) {
900 CRYPTO_BUFFER_free(buffer);
901 sk_CRYPTO_BUFFER_free(cert->chain);
902 cert->chain = NULL;
903 return 0;
904 }
905
906 return 1;
907}
908
909static int ssl_cert_add0_chain_cert(CERT *cert, X509 *x509) {
910 if (!ssl_cert_append_cert(cert, x509)) {
911 return 0;
912 }
913
914 X509_free(cert->x509_stash);
915 cert->x509_stash = x509;
Adam Langleyd5c565a2017-02-28 10:38:40 -0800916 ssl_crypto_x509_cert_flush_cached_chain(cert);
Adam Langley3509dac2017-02-01 11:59:18 -0800917 return 1;
918}
919
920static int ssl_cert_add1_chain_cert(CERT *cert, X509 *x509) {
921 if (!ssl_cert_append_cert(cert, x509)) {
922 return 0;
923 }
924
Adam Langleyd5c565a2017-02-28 10:38:40 -0800925 ssl_crypto_x509_cert_flush_cached_chain(cert);
Adam Langley3509dac2017-02-01 11:59:18 -0800926 return 1;
927}
928
929int SSL_CTX_set0_chain(SSL_CTX *ctx, STACK_OF(X509) *chain) {
Adam Langley415c0102017-02-10 13:30:23 -0800930 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800931 return ssl_cert_set0_chain(ctx->cert, chain);
932}
933
934int SSL_CTX_set1_chain(SSL_CTX *ctx, STACK_OF(X509) *chain) {
Adam Langley415c0102017-02-10 13:30:23 -0800935 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800936 return ssl_cert_set1_chain(ctx->cert, chain);
937}
938
939int SSL_set0_chain(SSL *ssl, STACK_OF(X509) *chain) {
Adam Langley415c0102017-02-10 13:30:23 -0800940 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800941 return ssl_cert_set0_chain(ssl->cert, chain);
942}
943
944int SSL_set1_chain(SSL *ssl, STACK_OF(X509) *chain) {
Adam Langley415c0102017-02-10 13:30:23 -0800945 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800946 return ssl_cert_set1_chain(ssl->cert, chain);
947}
948
949int SSL_CTX_add0_chain_cert(SSL_CTX *ctx, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -0800950 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800951 return ssl_cert_add0_chain_cert(ctx->cert, x509);
952}
953
954int SSL_CTX_add1_chain_cert(SSL_CTX *ctx, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -0800955 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800956 return ssl_cert_add1_chain_cert(ctx->cert, x509);
957}
958
959int SSL_CTX_add_extra_chain_cert(SSL_CTX *ctx, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -0800960 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800961 return SSL_CTX_add0_chain_cert(ctx, x509);
962}
963
964int SSL_add0_chain_cert(SSL *ssl, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -0800965 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800966 return ssl_cert_add0_chain_cert(ssl->cert, x509);
967}
968
969int SSL_add1_chain_cert(SSL *ssl, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -0800970 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800971 return ssl_cert_add1_chain_cert(ssl->cert, x509);
972}
973
974int SSL_CTX_clear_chain_certs(SSL_CTX *ctx) {
Adam Langley415c0102017-02-10 13:30:23 -0800975 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800976 return SSL_CTX_set0_chain(ctx, NULL);
977}
978
979int SSL_CTX_clear_extra_chain_certs(SSL_CTX *ctx) {
Adam Langley415c0102017-02-10 13:30:23 -0800980 check_ssl_ctx_x509_method(ctx);
Adam Langley3509dac2017-02-01 11:59:18 -0800981 return SSL_CTX_clear_chain_certs(ctx);
982}
983
984int SSL_clear_chain_certs(SSL *ssl) {
Adam Langley415c0102017-02-10 13:30:23 -0800985 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -0800986 return SSL_set0_chain(ssl, NULL);
987}
988
Adam Langley3509dac2017-02-01 11:59:18 -0800989/* ssl_cert_cache_chain_certs fills in |cert->x509_chain| from elements 1.. of
990 * |cert->chain|. */
991static int ssl_cert_cache_chain_certs(CERT *cert) {
992 assert(cert->x509_method);
993
994 if (cert->x509_chain != NULL ||
995 cert->chain == NULL ||
996 sk_CRYPTO_BUFFER_num(cert->chain) < 2) {
997 return 1;
998 }
999
1000 STACK_OF(X509) *chain = sk_X509_new_null();
1001 if (chain == NULL) {
1002 return 0;
1003 }
1004
1005 for (size_t i = 1; i < sk_CRYPTO_BUFFER_num(cert->chain); i++) {
1006 CRYPTO_BUFFER *buffer = sk_CRYPTO_BUFFER_value(cert->chain, i);
1007 X509 *x509 = X509_parse_from_buffer(buffer);
1008 if (x509 == NULL ||
1009 !sk_X509_push(chain, x509)) {
1010 X509_free(x509);
1011 goto err;
1012 }
1013 }
1014
1015 cert->x509_chain = chain;
1016 return 1;
1017
1018err:
1019 sk_X509_pop_free(chain, X509_free);
1020 return 0;
1021}
1022
1023int SSL_CTX_get0_chain_certs(const SSL_CTX *ctx, STACK_OF(X509) **out_chain) {
Adam Langley415c0102017-02-10 13:30:23 -08001024 check_ssl_ctx_x509_method(ctx);
Adam Langley34b4c822017-02-02 10:57:17 -08001025 CRYPTO_MUTEX_lock_write((CRYPTO_MUTEX *) &ctx->lock);
1026 const int ret = ssl_cert_cache_chain_certs(ctx->cert);
1027 CRYPTO_MUTEX_unlock_write((CRYPTO_MUTEX *) &ctx->lock);
1028
1029 if (!ret) {
Adam Langley3509dac2017-02-01 11:59:18 -08001030 *out_chain = NULL;
1031 return 0;
1032 }
1033
1034 *out_chain = ctx->cert->x509_chain;
1035 return 1;
1036}
1037
1038int SSL_CTX_get_extra_chain_certs(const SSL_CTX *ctx,
1039 STACK_OF(X509) **out_chain) {
1040 return SSL_CTX_get0_chain_certs(ctx, out_chain);
1041}
1042
1043int SSL_get0_chain_certs(const SSL *ssl, STACK_OF(X509) **out_chain) {
Adam Langley415c0102017-02-10 13:30:23 -08001044 check_ssl_x509_method(ssl);
Adam Langley3509dac2017-02-01 11:59:18 -08001045 if (!ssl_cert_cache_chain_certs(ssl->cert)) {
1046 *out_chain = NULL;
1047 return 0;
1048 }
1049
1050 *out_chain = ssl->cert->x509_chain;
1051 return 1;
1052}
Adam Langley46db7af2017-02-01 15:49:37 -08001053
1054static SSL_SESSION *ssl_session_new_with_crypto_x509(void) {
David Benjamin31b0c9b2017-07-20 14:49:15 -04001055 return ssl_session_new(&ssl_crypto_x509_method).release();
Adam Langley46db7af2017-02-01 15:49:37 -08001056}
1057
1058SSL_SESSION *d2i_SSL_SESSION_bio(BIO *bio, SSL_SESSION **out) {
1059 return ASN1_d2i_bio_of(SSL_SESSION, ssl_session_new_with_crypto_x509,
1060 d2i_SSL_SESSION, bio, out);
1061}
1062
1063int i2d_SSL_SESSION_bio(BIO *bio, const SSL_SESSION *session) {
1064 return ASN1_i2d_bio_of(SSL_SESSION, i2d_SSL_SESSION, bio, session);
1065}
1066
1067IMPLEMENT_PEM_rw(SSL_SESSION, SSL_SESSION, PEM_STRING_SSL_SESSION, SSL_SESSION)
1068
1069SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const uint8_t **pp, long length) {
1070 if (length < 0) {
1071 OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
1072 return NULL;
1073 }
1074
1075 CBS cbs;
1076 CBS_init(&cbs, *pp, length);
1077
David Benjamin31b0c9b2017-07-20 14:49:15 -04001078 UniquePtr<SSL_SESSION> ret = SSL_SESSION_parse(&cbs, &ssl_crypto_x509_method,
1079 NULL /* no buffer pool */);
1080 if (!ret) {
Adam Langley46db7af2017-02-01 15:49:37 -08001081 return NULL;
1082 }
1083
1084 if (a) {
1085 SSL_SESSION_free(*a);
David Benjamin31b0c9b2017-07-20 14:49:15 -04001086 *a = ret.get();
Adam Langley46db7af2017-02-01 15:49:37 -08001087 }
1088 *pp = CBS_data(&cbs);
David Benjamin31b0c9b2017-07-20 14:49:15 -04001089 return ret.release();
Adam Langley46db7af2017-02-01 15:49:37 -08001090}
Adam Langley34b4c822017-02-02 10:57:17 -08001091
1092STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *list) {
1093 return sk_X509_NAME_deep_copy(list, X509_NAME_dup, X509_NAME_free);
1094}
1095
1096static void set_client_CA_list(STACK_OF(CRYPTO_BUFFER) **ca_list,
1097 const STACK_OF(X509_NAME) *name_list,
1098 CRYPTO_BUFFER_POOL *pool) {
1099 STACK_OF(CRYPTO_BUFFER) *buffers = sk_CRYPTO_BUFFER_new_null();
1100 if (buffers == NULL) {
1101 return;
1102 }
1103
1104 for (size_t i = 0; i < sk_X509_NAME_num(name_list); i++) {
1105 X509_NAME *name = sk_X509_NAME_value(name_list, i);
1106 uint8_t *outp = NULL;
1107 int len = i2d_X509_NAME(name, &outp);
1108 if (len < 0) {
1109 goto err;
1110 }
1111
1112 CRYPTO_BUFFER *buffer = CRYPTO_BUFFER_new(outp, len, pool);
1113 OPENSSL_free(outp);
1114 if (buffer == NULL ||
1115 !sk_CRYPTO_BUFFER_push(buffers, buffer)) {
1116 CRYPTO_BUFFER_free(buffer);
1117 goto err;
1118 }
1119 }
1120
1121 sk_CRYPTO_BUFFER_pop_free(*ca_list, CRYPTO_BUFFER_free);
1122 *ca_list = buffers;
1123 return;
1124
1125err:
1126 sk_CRYPTO_BUFFER_pop_free(buffers, CRYPTO_BUFFER_free);
1127}
1128
1129void SSL_set_client_CA_list(SSL *ssl, STACK_OF(X509_NAME) *name_list) {
Adam Langley415c0102017-02-10 13:30:23 -08001130 check_ssl_x509_method(ssl);
Adam Langley34b4c822017-02-02 10:57:17 -08001131 ssl->ctx->x509_method->ssl_flush_cached_client_CA(ssl);
1132 set_client_CA_list(&ssl->client_CA, name_list, ssl->ctx->pool);
1133 sk_X509_NAME_pop_free(name_list, X509_NAME_free);
1134}
1135
1136void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list) {
Adam Langley415c0102017-02-10 13:30:23 -08001137 check_ssl_ctx_x509_method(ctx);
Adam Langley34b4c822017-02-02 10:57:17 -08001138 ctx->x509_method->ssl_ctx_flush_cached_client_CA(ctx);
1139 set_client_CA_list(&ctx->client_CA, name_list, ctx->pool);
1140 sk_X509_NAME_pop_free(name_list, X509_NAME_free);
1141}
1142
1143static STACK_OF(X509_NAME) *
1144 buffer_names_to_x509(const STACK_OF(CRYPTO_BUFFER) *names,
1145 STACK_OF(X509_NAME) **cached) {
1146 if (names == NULL) {
1147 return NULL;
1148 }
1149
1150 if (*cached != NULL) {
1151 return *cached;
1152 }
1153
1154 STACK_OF(X509_NAME) *new_cache = sk_X509_NAME_new_null();
1155 if (new_cache == NULL) {
1156 OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
1157 return NULL;
1158 }
1159
1160 for (size_t i = 0; i < sk_CRYPTO_BUFFER_num(names); i++) {
1161 const CRYPTO_BUFFER *buffer = sk_CRYPTO_BUFFER_value(names, i);
1162 const uint8_t *inp = CRYPTO_BUFFER_data(buffer);
1163 X509_NAME *name = d2i_X509_NAME(NULL, &inp, CRYPTO_BUFFER_len(buffer));
1164 if (name == NULL ||
1165 inp != CRYPTO_BUFFER_data(buffer) + CRYPTO_BUFFER_len(buffer) ||
1166 !sk_X509_NAME_push(new_cache, name)) {
1167 X509_NAME_free(name);
1168 goto err;
1169 }
1170 }
1171
1172 *cached = new_cache;
1173 return new_cache;
1174
1175err:
1176 sk_X509_NAME_pop_free(new_cache, X509_NAME_free);
1177 return NULL;
1178}
1179
1180STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *ssl) {
Adam Langley415c0102017-02-10 13:30:23 -08001181 check_ssl_x509_method(ssl);
Adam Langley34b4c822017-02-02 10:57:17 -08001182 /* For historical reasons, this function is used both to query configuration
1183 * state on a server as well as handshake state on a client. However, whether
1184 * |ssl| is a client or server is not known until explicitly configured with
1185 * |SSL_set_connect_state|. If |handshake_func| is NULL, |ssl| is in an
1186 * indeterminate mode and |ssl->server| is unset. */
1187 if (ssl->handshake_func != NULL && !ssl->server) {
1188 if (ssl->s3->hs != NULL) {
David Benjamin31b0c9b2017-07-20 14:49:15 -04001189 return buffer_names_to_x509(ssl->s3->hs->ca_names.get(),
Adam Langley34b4c822017-02-02 10:57:17 -08001190 &ssl->s3->hs->cached_x509_ca_names);
1191 }
1192
1193 return NULL;
1194 }
1195
1196 if (ssl->client_CA != NULL) {
1197 return buffer_names_to_x509(
1198 ssl->client_CA, (STACK_OF(X509_NAME) **)&ssl->cached_x509_client_CA);
1199 }
1200 return buffer_names_to_x509(ssl->ctx->client_CA,
1201 &ssl->ctx->cached_x509_client_CA);
1202}
1203
1204STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx) {
Adam Langley415c0102017-02-10 13:30:23 -08001205 check_ssl_ctx_x509_method(ctx);
Adam Langley34b4c822017-02-02 10:57:17 -08001206 CRYPTO_MUTEX_lock_write((CRYPTO_MUTEX *) &ctx->lock);
1207 STACK_OF(X509_NAME) *ret = buffer_names_to_x509(
1208 ctx->client_CA, (STACK_OF(X509_NAME) **)&ctx->cached_x509_client_CA);
1209 CRYPTO_MUTEX_unlock_write((CRYPTO_MUTEX *) &ctx->lock);
1210 return ret;
1211}
1212
1213static int add_client_CA(STACK_OF(CRYPTO_BUFFER) **names, X509 *x509,
1214 CRYPTO_BUFFER_POOL *pool) {
1215 if (x509 == NULL) {
1216 return 0;
1217 }
1218
1219 uint8_t *outp = NULL;
1220 int len = i2d_X509_NAME(X509_get_subject_name(x509), &outp);
1221 if (len < 0) {
1222 return 0;
1223 }
1224
1225 CRYPTO_BUFFER *buffer = CRYPTO_BUFFER_new(outp, len, pool);
1226 OPENSSL_free(outp);
1227 if (buffer == NULL) {
1228 return 0;
1229 }
1230
1231 int alloced = 0;
1232 if (*names == NULL) {
1233 *names = sk_CRYPTO_BUFFER_new_null();
1234 alloced = 1;
1235
1236 if (*names == NULL) {
1237 CRYPTO_BUFFER_free(buffer);
1238 return 0;
1239 }
1240 }
1241
1242 if (!sk_CRYPTO_BUFFER_push(*names, buffer)) {
1243 CRYPTO_BUFFER_free(buffer);
1244 if (alloced) {
1245 sk_CRYPTO_BUFFER_pop_free(*names, CRYPTO_BUFFER_free);
1246 *names = NULL;
1247 }
1248 return 0;
1249 }
1250
1251 return 1;
1252}
1253
1254int SSL_add_client_CA(SSL *ssl, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -08001255 check_ssl_x509_method(ssl);
Adam Langley34b4c822017-02-02 10:57:17 -08001256 if (!add_client_CA(&ssl->client_CA, x509, ssl->ctx->pool)) {
1257 return 0;
1258 }
1259
1260 ssl_crypto_x509_ssl_flush_cached_client_CA(ssl);
1261 return 1;
1262}
1263
1264int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x509) {
Adam Langley415c0102017-02-10 13:30:23 -08001265 check_ssl_ctx_x509_method(ctx);
Adam Langley34b4c822017-02-02 10:57:17 -08001266 if (!add_client_CA(&ctx->client_CA, x509, ctx->pool)) {
1267 return 0;
1268 }
1269
1270 ssl_crypto_x509_ssl_ctx_flush_cached_client_CA(ctx);
1271 return 1;
1272}
Adam Langley2a3b3432017-02-10 13:56:48 -08001273
1274static int do_client_cert_cb(SSL *ssl, void *arg) {
1275 if (ssl_has_certificate(ssl) || ssl->ctx->client_cert_cb == NULL) {
1276 return 1;
1277 }
1278
1279 X509 *x509 = NULL;
1280 EVP_PKEY *pkey = NULL;
1281 int ret = ssl->ctx->client_cert_cb(ssl, &x509, &pkey);
1282 if (ret < 0) {
1283 return -1;
1284 }
1285
1286 if (ret != 0) {
1287 if (!SSL_use_certificate(ssl, x509) ||
1288 !SSL_use_PrivateKey(ssl, pkey)) {
1289 return 0;
1290 }
1291 }
1292
1293 X509_free(x509);
1294 EVP_PKEY_free(pkey);
1295 return 1;
1296}
1297
1298void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, int (*cb)(SSL *ssl,
1299 X509 **out_x509,
1300 EVP_PKEY **out_pkey)) {
1301 check_ssl_ctx_x509_method(ctx);
1302 /* Emulate the old client certificate callback with the new one. */
1303 SSL_CTX_set_cert_cb(ctx, do_client_cert_cb, NULL);
1304 ctx->client_cert_cb = cb;
1305}
1306
1307static int set_cert_store(X509_STORE **store_ptr, X509_STORE *new_store,
1308 int take_ref) {
1309 X509_STORE_free(*store_ptr);
1310 *store_ptr = new_store;
1311
1312 if (new_store != NULL && take_ref) {
1313 X509_STORE_up_ref(new_store);
1314 }
1315
1316 return 1;
1317}
1318
1319int SSL_get_ex_data_X509_STORE_CTX_idx(void) {
1320 /* The ex_data index to go from |X509_STORE_CTX| to |SSL| always uses the
1321 * reserved app_data slot. Before ex_data was introduced, app_data was used.
1322 * Avoid breaking any software which assumes |X509_STORE_CTX_get_app_data|
1323 * works. */
1324 return 0;
1325}
1326
1327int SSL_CTX_set0_verify_cert_store(SSL_CTX *ctx, X509_STORE *store) {
1328 check_ssl_ctx_x509_method(ctx);
1329 return set_cert_store(&ctx->cert->verify_store, store, 0);
1330}
1331
1332int SSL_CTX_set1_verify_cert_store(SSL_CTX *ctx, X509_STORE *store) {
1333 check_ssl_ctx_x509_method(ctx);
1334 return set_cert_store(&ctx->cert->verify_store, store, 1);
1335}
1336
1337int SSL_set0_verify_cert_store(SSL *ssl, X509_STORE *store) {
1338 check_ssl_x509_method(ssl);
1339 return set_cert_store(&ssl->cert->verify_store, store, 0);
1340}
1341
1342int SSL_set1_verify_cert_store(SSL *ssl, X509_STORE *store) {
1343 check_ssl_x509_method(ssl);
1344 return set_cert_store(&ssl->cert->verify_store, store, 1);
1345}