legacy-libs/grpc-cloned/deps/grpc/third_party/boringssl/ssl/ssl_lib.cc

   1 /* 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
 143 #include <assert.h>
 144 #include <stdlib.h>
 145 #include <string.h>
 146
 147 #include <openssl/bytestring.h>
 148 #include <openssl/crypto.h>
 149 #include <openssl/err.h>
 150 #include <openssl/lhash.h>
 151 #include <openssl/mem.h>
 152 #include <openssl/rand.h>
 153
 154 #include "internal.h"
 155 #include "../crypto/internal.h"
 156
 157 #if defined(OPENSSL_WINDOWS)
 158 #include <sys/timeb.h>
 159 #else
 160 #include <sys/socket.h>
 161 #include <sys/time.h>
 162 #endif
 163
 164
 165 namespace bssl {
 166
 167 // |SSL_R_UNKNOWN_PROTOCOL| is no longer emitted, but continue to define it
 168 // to avoid downstream churn.
 169 OPENSSL_DECLARE_ERROR_REASON(SSL, UNKNOWN_PROTOCOL)
 170
 171 // The following errors are no longer emitted, but are used in nginx without
 172 // #ifdefs.
 173 OPENSSL_DECLARE_ERROR_REASON(SSL, BLOCK_CIPHER_PAD_IS_WRONG)
 174 OPENSSL_DECLARE_ERROR_REASON(SSL, NO_CIPHERS_SPECIFIED)
 175
 176 // Some error codes are special. Ensure the make_errors.go script never
 177 // regresses this.
 178 static_assert(SSL_R_TLSV1_ALERT_NO_RENEGOTIATION ==
 179                   SSL_AD_NO_RENEGOTIATION + SSL_AD_REASON_OFFSET,
 180               "alert reason code mismatch");
 181
 182 // kMaxHandshakeSize is the maximum size, in bytes, of a handshake message.
 183 static const size_t kMaxHandshakeSize = (1u << 24) - 1;
 184
 185 static CRYPTO_EX_DATA_CLASS g_ex_data_class_ssl =
 186     CRYPTO_EX_DATA_CLASS_INIT_WITH_APP_DATA;
 187 static CRYPTO_EX_DATA_CLASS g_ex_data_class_ssl_ctx =
 188     CRYPTO_EX_DATA_CLASS_INIT_WITH_APP_DATA;
 189
 190 bool CBBFinishArray(CBB *cbb, Array<uint8_t> *out) {
 191   uint8_t *ptr;
 192   size_t len;
 193   if (!CBB_finish(cbb, &ptr, &len)) {
 194     OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
 195     return false;
 196   }
 197   out->Reset(ptr, len);
 198   return true;
 199 }
 200
 201 void ssl_reset_error_state(SSL *ssl) {
 202   // Functions which use |SSL_get_error| must reset I/O and error state on
 203   // entry.
 204   ssl->s3->rwstate = SSL_NOTHING;
 205   ERR_clear_error();
 206   ERR_clear_system_error();
 207 }
 208
 209 void ssl_set_read_error(SSL* ssl) {
 210   ssl->s3->read_shutdown = ssl_shutdown_error;
 211   ssl->s3->read_error.reset(ERR_save_state());
 212 }
 213
 214 static bool check_read_error(const SSL *ssl) {
 215   if (ssl->s3->read_shutdown == ssl_shutdown_error) {
 216     ERR_restore_state(ssl->s3->read_error.get());
 217     return false;
 218   }
 219   return true;
 220 }
 221
 222 int ssl_can_write(const SSL *ssl) {
 223   return !SSL_in_init(ssl) || ssl->s3->hs->can_early_write;
 224 }
 225
 226 int ssl_can_read(const SSL *ssl) {
 227   return !SSL_in_init(ssl) || ssl->s3->hs->can_early_read;
 228 }
 229
 230 ssl_open_record_t ssl_open_handshake(SSL *ssl, size_t *out_consumed,
 231                                      uint8_t *out_alert, Span<uint8_t> in) {
 232   *out_consumed = 0;
 233   if (!check_read_error(ssl)) {
 234     *out_alert = 0;
 235     return ssl_open_record_error;
 236   }
 237   auto ret = ssl->method->open_handshake(ssl, out_consumed, out_alert, in);
 238   if (ret == ssl_open_record_error) {
 239     ssl_set_read_error(ssl);
 240   }
 241   return ret;
 242 }
 243
 244 ssl_open_record_t ssl_open_change_cipher_spec(SSL *ssl, size_t *out_consumed,
 245                                               uint8_t *out_alert,
 246                                               Span<uint8_t> in) {
 247   *out_consumed = 0;
 248   if (!check_read_error(ssl)) {
 249     *out_alert = 0;
 250     return ssl_open_record_error;
 251   }
 252   auto ret =
 253       ssl->method->open_change_cipher_spec(ssl, out_consumed, out_alert, in);
 254   if (ret == ssl_open_record_error) {
 255     ssl_set_read_error(ssl);
 256   }
 257   return ret;
 258 }
 259
 260 ssl_open_record_t ssl_open_app_data(SSL *ssl, Span<uint8_t> *out,
 261                                     size_t *out_consumed, uint8_t *out_alert,
 262                                     Span<uint8_t> in) {
 263   *out_consumed = 0;
 264   if (!check_read_error(ssl)) {
 265     *out_alert = 0;
 266     return ssl_open_record_error;
 267   }
 268   auto ret = ssl->method->open_app_data(ssl, out, out_consumed, out_alert, in);
 269   if (ret == ssl_open_record_error) {
 270     ssl_set_read_error(ssl);
 271   }
 272   return ret;
 273 }
 274
 275 void ssl_cipher_preference_list_free(
 276     struct ssl_cipher_preference_list_st *cipher_list) {
 277   if (cipher_list == NULL) {
 278     return;
 279   }
 280   sk_SSL_CIPHER_free(cipher_list->ciphers);
 281   OPENSSL_free(cipher_list->in_group_flags);
 282   OPENSSL_free(cipher_list);
 283 }
 284
 285 void ssl_update_cache(SSL_HANDSHAKE *hs, int mode) {
 286   SSL *const ssl = hs->ssl;
 287   SSL_CTX *ctx = ssl->session_ctx;
 288   // Never cache sessions with empty session IDs.
 289   if (ssl->s3->established_session->session_id_length == 0 ||
 290       ssl->s3->established_session->not_resumable ||
 291       (ctx->session_cache_mode & mode) != mode) {
 292     return;
 293   }
 294
 295   // Clients never use the internal session cache.
 296   int use_internal_cache = ssl->server && !(ctx->session_cache_mode &
 297                                             SSL_SESS_CACHE_NO_INTERNAL_STORE);
 298
 299   // A client may see new sessions on abbreviated handshakes if the server
 300   // decides to renew the ticket. Once the handshake is completed, it should be
 301   // inserted into the cache.
 302   if (ssl->s3->established_session.get() != ssl->session ||
 303       (!ssl->server && hs->ticket_expected)) {
 304     if (use_internal_cache) {
 305       SSL_CTX_add_session(ctx, ssl->s3->established_session.get());
 306     }
 307     if (ctx->new_session_cb != NULL) {
 308       SSL_SESSION_up_ref(ssl->s3->established_session.get());
 309       if (!ctx->new_session_cb(ssl, ssl->s3->established_session.get())) {
 310         // |new_session_cb|'s return value signals whether it took ownership.
 311         SSL_SESSION_free(ssl->s3->established_session.get());
 312       }
 313     }
 314   }
 315
 316   if (use_internal_cache &&
 317       !(ctx->session_cache_mode & SSL_SESS_CACHE_NO_AUTO_CLEAR)) {
 318     // Automatically flush the internal session cache every 255 connections.
 319     int flush_cache = 0;
 320     CRYPTO_MUTEX_lock_write(&ctx->lock);
 321     ctx->handshakes_since_cache_flush++;
 322     if (ctx->handshakes_since_cache_flush >= 255) {
 323       flush_cache = 1;
 324       ctx->handshakes_since_cache_flush = 0;
 325     }
 326     CRYPTO_MUTEX_unlock_write(&ctx->lock);
 327
 328     if (flush_cache) {
 329       struct OPENSSL_timeval now;
 330       ssl_get_current_time(ssl, &now);
 331       SSL_CTX_flush_sessions(ctx, now.tv_sec);
 332     }
 333   }
 334 }
 335
 336 static int cbb_add_hex(CBB *cbb, const uint8_t *in, size_t in_len) {
 337   static const char hextable[] = "0123456789abcdef";
 338   uint8_t *out;
 339
 340   if (!CBB_add_space(cbb, &out, in_len * 2)) {
 341     return 0;
 342   }
 343
 344   for (size_t i = 0; i < in_len; i++) {
 345     *(out++) = (uint8_t)hextable[in[i] >> 4];
 346     *(out++) = (uint8_t)hextable[in[i] & 0xf];
 347   }
 348
 349   return 1;
 350 }
 351
 352 int ssl_log_secret(const SSL *ssl, const char *label, const uint8_t *secret,
 353                    size_t secret_len) {
 354   if (ssl->ctx->keylog_callback == NULL) {
 355     return 1;
 356   }
 357
 358   ScopedCBB cbb;
 359   uint8_t *out;
 360   size_t out_len;
 361   if (!CBB_init(cbb.get(), strlen(label) + 1 + SSL3_RANDOM_SIZE * 2 + 1 +
 362                           secret_len * 2 + 1) ||
 363       !CBB_add_bytes(cbb.get(), (const uint8_t *)label, strlen(label)) ||
 364       !CBB_add_bytes(cbb.get(), (const uint8_t *)" ", 1) ||
 365       !cbb_add_hex(cbb.get(), ssl->s3->client_random, SSL3_RANDOM_SIZE) ||
 366       !CBB_add_bytes(cbb.get(), (const uint8_t *)" ", 1) ||
 367       !cbb_add_hex(cbb.get(), secret, secret_len) ||
 368       !CBB_add_u8(cbb.get(), 0 /* NUL */) ||
 369       !CBB_finish(cbb.get(), &out, &out_len)) {
 370     return 0;
 371   }
 372
 373   ssl->ctx->keylog_callback(ssl, (const char *)out);
 374   OPENSSL_free(out);
 375   return 1;
 376 }
 377
 378 void ssl_do_info_callback(const SSL *ssl, int type, int value) {
 379   void (*cb)(const SSL *ssl, int type, int value) = NULL;
 380   if (ssl->info_callback != NULL) {
 381     cb = ssl->info_callback;
 382   } else if (ssl->ctx->info_callback != NULL) {
 383     cb = ssl->ctx->info_callback;
 384   }
 385
 386   if (cb != NULL) {
 387     cb(ssl, type, value);
 388   }
 389 }
 390
 391 void ssl_do_msg_callback(SSL *ssl, int is_write, int content_type,
 392                          Span<const uint8_t> in) {
 393   if (ssl->msg_callback == NULL) {
 394     return;
 395   }
 396
 397   // |version| is zero when calling for |SSL3_RT_HEADER| and |SSL2_VERSION| for
 398   // a V2ClientHello.
 399   int version;
 400   switch (content_type) {
 401     case 0:
 402       // V2ClientHello
 403       version = SSL2_VERSION;
 404       break;
 405     case SSL3_RT_HEADER:
 406       version = 0;
 407       break;
 408     default:
 409       version = SSL_version(ssl);
 410   }
 411
 412   ssl->msg_callback(is_write, version, content_type, in.data(), in.size(), ssl,
 413                     ssl->msg_callback_arg);
 414 }
 415
 416 void ssl_get_current_time(const SSL *ssl, struct OPENSSL_timeval *out_clock) {
 417   // TODO(martinkr): Change callers to |ssl_ctx_get_current_time| and drop the
 418   // |ssl| arg from |current_time_cb| if possible.
 419   ssl_ctx_get_current_time(ssl->ctx, out_clock);
 420 }
 421
 422 void ssl_ctx_get_current_time(const SSL_CTX *ctx,
 423                               struct OPENSSL_timeval *out_clock) {
 424   if (ctx->current_time_cb != NULL) {
 425     // TODO(davidben): Update current_time_cb to use OPENSSL_timeval. See
 426     // https://crbug.com/boringssl/155.
 427     struct timeval clock;
 428     ctx->current_time_cb(nullptr /* ssl */, &clock);
 429     if (clock.tv_sec < 0) {
 430       assert(0);
 431       out_clock->tv_sec = 0;
 432       out_clock->tv_usec = 0;
 433     } else {
 434       out_clock->tv_sec = (uint64_t)clock.tv_sec;
 435       out_clock->tv_usec = (uint32_t)clock.tv_usec;
 436     }
 437     return;
 438   }
 439
 440 #if defined(BORINGSSL_UNSAFE_DETERMINISTIC_MODE)
 441   out_clock->tv_sec = 1234;
 442   out_clock->tv_usec = 1234;
 443 #elif defined(OPENSSL_WINDOWS)
 444   struct _timeb time;
 445   _ftime(&time);
 446   if (time.time < 0) {
 447     assert(0);
 448     out_clock->tv_sec = 0;
 449     out_clock->tv_usec = 0;
 450   } else {
 451     out_clock->tv_sec = time.time;
 452     out_clock->tv_usec = time.millitm * 1000;
 453   }
 454 #else
 455   struct timeval clock;
 456   gettimeofday(&clock, NULL);
 457   if (clock.tv_sec < 0) {
 458     assert(0);
 459     out_clock->tv_sec = 0;
 460     out_clock->tv_usec = 0;
 461   } else {
 462     out_clock->tv_sec = (uint64_t)clock.tv_sec;
 463     out_clock->tv_usec = (uint32_t)clock.tv_usec;
 464   }
 465 #endif
 466 }
 467
 468 void SSL_CTX_set_handoff_mode(SSL_CTX *ctx, bool on) {
 469   ctx->handoff = on;
 470 }
 471
 472 }  // namespace bssl
 473
 474 using namespace bssl;
 475
 476 int SSL_library_init(void) {
 477   CRYPTO_library_init();
 478   return 1;
 479 }
 480
 481 int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
 482   CRYPTO_library_init();
 483   return 1;
 484 }
 485
 486 static uint32_t ssl_session_hash(const SSL_SESSION *sess) {
 487   const uint8_t *session_id = sess->session_id;
 488
 489   uint8_t tmp_storage[sizeof(uint32_t)];
 490   if (sess->session_id_length < sizeof(tmp_storage)) {
 491     OPENSSL_memset(tmp_storage, 0, sizeof(tmp_storage));
 492     OPENSSL_memcpy(tmp_storage, sess->session_id, sess->session_id_length);
 493     session_id = tmp_storage;
 494   }
 495
 496   uint32_t hash =
 497       ((uint32_t)session_id[0]) |
 498       ((uint32_t)session_id[1] << 8) |
 499       ((uint32_t)session_id[2] << 16) |
 500       ((uint32_t)session_id[3] << 24);
 501
 502   return hash;
 503 }
 504
 505 // NB: If this function (or indeed the hash function which uses a sort of
 506 // coarser function than this one) is changed, ensure
 507 // SSL_CTX_has_matching_session_id() is checked accordingly. It relies on being
 508 // able to construct an SSL_SESSION that will collide with any existing session
 509 // with a matching session ID.
 510 static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b) {
 511   if (a->ssl_version != b->ssl_version) {
 512     return 1;
 513   }
 514
 515   if (a->session_id_length != b->session_id_length) {
 516     return 1;
 517   }
 518
 519   return OPENSSL_memcmp(a->session_id, b->session_id, a->session_id_length);
 520 }
 521
 522 SSL_CTX *SSL_CTX_new(const SSL_METHOD *method) {
 523   SSL_CTX *ret = NULL;
 524
 525   if (method == NULL) {
 526     OPENSSL_PUT_ERROR(SSL, SSL_R_NULL_SSL_METHOD_PASSED);
 527     return NULL;
 528   }
 529
 530   ret = (SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
 531   if (ret == NULL) {
 532     goto err;
 533   }
 534
 535   OPENSSL_memset(ret, 0, sizeof(SSL_CTX));
 536
 537   ret->method = method->method;
 538   ret->x509_method = method->x509_method;
 539
 540   CRYPTO_MUTEX_init(&ret->lock);
 541
 542   ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
 543   ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
 544
 545   ret->session_timeout = SSL_DEFAULT_SESSION_TIMEOUT;
 546   ret->session_psk_dhe_timeout = SSL_DEFAULT_SESSION_PSK_DHE_TIMEOUT;
 547
 548   ret->references = 1;
 549
 550   ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
 551   ret->verify_mode = SSL_VERIFY_NONE;
 552   ret->cert = ssl_cert_new(method->x509_method);
 553   if (ret->cert == NULL) {
 554     goto err;
 555   }
 556
 557   ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
 558   if (ret->sessions == NULL) {
 559     goto err;
 560   }
 561
 562   if (!ret->x509_method->ssl_ctx_new(ret)) {
 563     goto err;
 564   }
 565
 566   if (!SSL_CTX_set_strict_cipher_list(ret, SSL_DEFAULT_CIPHER_LIST)) {
 567     goto err2;
 568   }
 569
 570   ret->client_CA = sk_CRYPTO_BUFFER_new_null();
 571   if (ret->client_CA == NULL) {
 572     goto err;
 573   }
 574
 575   CRYPTO_new_ex_data(&ret->ex_data);
 576
 577   ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
 578
 579   // Disable the auto-chaining feature by default. Once this has stuck without
 580   // problems, the feature will be removed entirely.
 581   ret->mode = SSL_MODE_NO_AUTO_CHAIN;
 582
 583   // Lock the SSL_CTX to the specified version, for compatibility with legacy
 584   // uses of SSL_METHOD.
 585   if (!SSL_CTX_set_max_proto_version(ret, method->version) ||
 586       !SSL_CTX_set_min_proto_version(ret, method->version)) {
 587     OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
 588     goto err2;
 589   }
 590
 591   return ret;
 592
 593 err:
 594   OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
 595 err2:
 596   SSL_CTX_free(ret);
 597   return NULL;
 598 }
 599
 600 int SSL_CTX_up_ref(SSL_CTX *ctx) {
 601   CRYPTO_refcount_inc(&ctx->references);
 602   return 1;
 603 }
 604
 605 void SSL_CTX_free(SSL_CTX *ctx) {
 606   if (ctx == NULL ||
 607       !CRYPTO_refcount_dec_and_test_zero(&ctx->references)) {
 608     return;
 609   }
 610
 611   // Free internal session cache. However: the remove_cb() may reference the
 612   // ex_data of SSL_CTX, thus the ex_data store can only be removed after the
 613   // sessions were flushed. As the ex_data handling routines might also touch
 614   // the session cache, the most secure solution seems to be: empty (flush) the
 615   // cache, then free ex_data, then finally free the cache. (See ticket
 616   // [openssl.org #212].)
 617   SSL_CTX_flush_sessions(ctx, 0);
 618
 619   CRYPTO_free_ex_data(&g_ex_data_class_ssl_ctx, ctx, &ctx->ex_data);
 620
 621   CRYPTO_MUTEX_cleanup(&ctx->lock);
 622   lh_SSL_SESSION_free(ctx->sessions);
 623   ssl_cipher_preference_list_free(ctx->cipher_list);
 624   ssl_cert_free(ctx->cert);
 625   sk_SSL_CUSTOM_EXTENSION_pop_free(ctx->client_custom_extensions,
 626                                    SSL_CUSTOM_EXTENSION_free);
 627   sk_SSL_CUSTOM_EXTENSION_pop_free(ctx->server_custom_extensions,
 628                                    SSL_CUSTOM_EXTENSION_free);
 629   sk_CRYPTO_BUFFER_pop_free(ctx->client_CA, CRYPTO_BUFFER_free);
 630   ctx->x509_method->ssl_ctx_free(ctx);
 631   sk_SRTP_PROTECTION_PROFILE_free(ctx->srtp_profiles);
 632   OPENSSL_free(ctx->psk_identity_hint);
 633   OPENSSL_free(ctx->supported_group_list);
 634   OPENSSL_free(ctx->alpn_client_proto_list);
 635   EVP_PKEY_free(ctx->tlsext_channel_id_private);
 636   OPENSSL_free(ctx->verify_sigalgs);
 637   OPENSSL_free(ctx->tlsext_ticket_key_current);
 638   OPENSSL_free(ctx->tlsext_ticket_key_prev);
 639
 640   OPENSSL_free(ctx);
 641 }
 642
 643 SSL *SSL_new(SSL_CTX *ctx) {
 644   if (ctx == NULL) {
 645     OPENSSL_PUT_ERROR(SSL, SSL_R_NULL_SSL_CTX);
 646     return NULL;
 647   }
 648   if (ctx->method == NULL) {
 649     OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
 650     return NULL;
 651   }
 652
 653   SSL *ssl = (SSL *)OPENSSL_malloc(sizeof(SSL));
 654   if (ssl == NULL) {
 655     goto err;
 656   }
 657   OPENSSL_memset(ssl, 0, sizeof(SSL));
 658
 659   ssl->conf_min_version = ctx->conf_min_version;
 660   ssl->conf_max_version = ctx->conf_max_version;
 661   ssl->tls13_variant = ctx->tls13_variant;
 662
 663   // RFC 6347 states that implementations SHOULD use an initial timer value of
 664   // 1 second.
 665   ssl->initial_timeout_duration_ms = 1000;
 666
 667   ssl->options = ctx->options;
 668   ssl->mode = ctx->mode;
 669   ssl->max_cert_list = ctx->max_cert_list;
 670
 671   ssl->cert = ssl_cert_dup(ctx->cert);
 672   if (ssl->cert == NULL) {
 673     goto err;
 674   }
 675
 676   ssl->msg_callback = ctx->msg_callback;
 677   ssl->msg_callback_arg = ctx->msg_callback_arg;
 678   ssl->verify_mode = ctx->verify_mode;
 679   ssl->verify_callback = ctx->default_verify_callback;
 680   ssl->custom_verify_callback = ctx->custom_verify_callback;
 681   ssl->retain_only_sha256_of_client_certs =
 682       ctx->retain_only_sha256_of_client_certs;
 683
 684   ssl->quiet_shutdown = ctx->quiet_shutdown;
 685   ssl->max_send_fragment = ctx->max_send_fragment;
 686
 687   SSL_CTX_up_ref(ctx);
 688   ssl->ctx = ctx;
 689   SSL_CTX_up_ref(ctx);
 690   ssl->session_ctx = ctx;
 691
 692   if (!ssl->ctx->x509_method->ssl_new(ssl)) {
 693     goto err;
 694   }
 695
 696   if (ctx->supported_group_list) {
 697     ssl->supported_group_list = (uint16_t *)BUF_memdup(
 698         ctx->supported_group_list, ctx->supported_group_list_len * 2);
 699     if (!ssl->supported_group_list) {
 700       goto err;
 701     }
 702     ssl->supported_group_list_len = ctx->supported_group_list_len;
 703   }
 704
 705   if (ctx->alpn_client_proto_list) {
 706     ssl->alpn_client_proto_list = (uint8_t *)BUF_memdup(
 707         ctx->alpn_client_proto_list, ctx->alpn_client_proto_list_len);
 708     if (ssl->alpn_client_proto_list == NULL) {
 709       goto err;
 710     }
 711     ssl->alpn_client_proto_list_len = ctx->alpn_client_proto_list_len;
 712   }
 713
 714   ssl->method = ctx->method;
 715
 716   if (!ssl->method->ssl_new(ssl)) {
 717     goto err;
 718   }
 719
 720   CRYPTO_new_ex_data(&ssl->ex_data);
 721
 722   ssl->psk_identity_hint = NULL;
 723   if (ctx->psk_identity_hint) {
 724     ssl->psk_identity_hint = BUF_strdup(ctx->psk_identity_hint);
 725     if (ssl->psk_identity_hint == NULL) {
 726       goto err;
 727     }
 728   }
 729   ssl->psk_client_callback = ctx->psk_client_callback;
 730   ssl->psk_server_callback = ctx->psk_server_callback;
 731
 732   ssl->tlsext_channel_id_enabled = ctx->tlsext_channel_id_enabled;
 733   if (ctx->tlsext_channel_id_private) {
 734     EVP_PKEY_up_ref(ctx->tlsext_channel_id_private);
 735     ssl->tlsext_channel_id_private = ctx->tlsext_channel_id_private;
 736   }
 737
 738   ssl->signed_cert_timestamps_enabled = ctx->signed_cert_timestamps_enabled;
 739   ssl->ocsp_stapling_enabled = ctx->ocsp_stapling_enabled;
 740   ssl->handoff = ctx->handoff;
 741
 742   return ssl;
 743
 744 err:
 745   SSL_free(ssl);
 746   OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
 747
 748   return NULL;
 749 }
 750
 751 void SSL_free(SSL *ssl) {
 752   if (ssl == NULL) {
 753     return;
 754   }
 755
 756   if (ssl->ctx != NULL) {
 757     ssl->ctx->x509_method->ssl_free(ssl);
 758   }
 759
 760   CRYPTO_free_ex_data(&g_ex_data_class_ssl, ssl, &ssl->ex_data);
 761
 762   BIO_free_all(ssl->rbio);
 763   BIO_free_all(ssl->wbio);
 764
 765   // add extra stuff
 766   ssl_cipher_preference_list_free(ssl->cipher_list);
 767
 768   SSL_SESSION_free(ssl->session);
 769
 770   ssl_cert_free(ssl->cert);
 771
 772   OPENSSL_free(ssl->tlsext_hostname);
 773   SSL_CTX_free(ssl->session_ctx);
 774   OPENSSL_free(ssl->supported_group_list);
 775   OPENSSL_free(ssl->alpn_client_proto_list);
 776   OPENSSL_free(ssl->token_binding_params);
 777   OPENSSL_free(ssl->quic_transport_params);
 778   EVP_PKEY_free(ssl->tlsext_channel_id_private);
 779   OPENSSL_free(ssl->psk_identity_hint);
 780   sk_CRYPTO_BUFFER_pop_free(ssl->client_CA, CRYPTO_BUFFER_free);
 781   sk_SRTP_PROTECTION_PROFILE_free(ssl->srtp_profiles);
 782
 783   if (ssl->method != NULL) {
 784     ssl->method->ssl_free(ssl);
 785   }
 786   SSL_CTX_free(ssl->ctx);
 787
 788   OPENSSL_free(ssl);
 789 }
 790
 791 void SSL_set_connect_state(SSL *ssl) {
 792   ssl->server = false;
 793   ssl->do_handshake = ssl_client_handshake;
 794 }
 795
 796 void SSL_set_accept_state(SSL *ssl) {
 797   ssl->server = true;
 798   ssl->do_handshake = ssl_server_handshake;
 799 }
 800
 801 void SSL_set0_rbio(SSL *ssl, BIO *rbio) {
 802   BIO_free_all(ssl->rbio);
 803   ssl->rbio = rbio;
 804 }
 805
 806 void SSL_set0_wbio(SSL *ssl, BIO *wbio) {
 807   BIO_free_all(ssl->wbio);
 808   ssl->wbio = wbio;
 809 }
 810
 811 void SSL_set_bio(SSL *ssl, BIO *rbio, BIO *wbio) {
 812   // For historical reasons, this function has many different cases in ownership
 813   // handling.
 814
 815   // If nothing has changed, do nothing
 816   if (rbio == SSL_get_rbio(ssl) && wbio == SSL_get_wbio(ssl)) {
 817     return;
 818   }
 819
 820   // If the two arguments are equal, one fewer reference is granted than
 821   // taken.
 822   if (rbio != NULL && rbio == wbio) {
 823     BIO_up_ref(rbio);
 824   }
 825
 826   // If only the wbio is changed, adopt only one reference.
 827   if (rbio == SSL_get_rbio(ssl)) {
 828     SSL_set0_wbio(ssl, wbio);
 829     return;
 830   }
 831
 832   // There is an asymmetry here for historical reasons. If only the rbio is
 833   // changed AND the rbio and wbio were originally different, then we only adopt
 834   // one reference.
 835   if (wbio == SSL_get_wbio(ssl) && SSL_get_rbio(ssl) != SSL_get_wbio(ssl)) {
 836     SSL_set0_rbio(ssl, rbio);
 837     return;
 838   }
 839
 840   // Otherwise, adopt both references.
 841   SSL_set0_rbio(ssl, rbio);
 842   SSL_set0_wbio(ssl, wbio);
 843 }
 844
 845 BIO *SSL_get_rbio(const SSL *ssl) { return ssl->rbio; }
 846
 847 BIO *SSL_get_wbio(const SSL *ssl) { return ssl->wbio; }
 848
 849 int SSL_do_handshake(SSL *ssl) {
 850   ssl_reset_error_state(ssl);
 851
 852   if (ssl->do_handshake == NULL) {
 853     OPENSSL_PUT_ERROR(SSL, SSL_R_CONNECTION_TYPE_NOT_SET);
 854     return -1;
 855   }
 856
 857   if (!SSL_in_init(ssl)) {
 858     return 1;
 859   }
 860
 861   // Run the handshake.
 862   SSL_HANDSHAKE *hs = ssl->s3->hs.get();
 863
 864   bool early_return = false;
 865   int ret = ssl_run_handshake(hs, &early_return);
 866   ssl_do_info_callback(
 867       ssl, ssl->server ? SSL_CB_ACCEPT_EXIT : SSL_CB_CONNECT_EXIT, ret);
 868   if (ret <= 0) {
 869     return ret;
 870   }
 871
 872   // Destroy the handshake object if the handshake has completely finished.
 873   if (!early_return) {
 874     ssl->s3->hs.reset();
 875   }
 876
 877   return 1;
 878 }
 879
 880 int SSL_connect(SSL *ssl) {
 881   if (ssl->do_handshake == NULL) {
 882     // Not properly initialized yet
 883     SSL_set_connect_state(ssl);
 884   }
 885
 886   return SSL_do_handshake(ssl);
 887 }
 888
 889 int SSL_accept(SSL *ssl) {
 890   if (ssl->do_handshake == NULL) {
 891     // Not properly initialized yet
 892     SSL_set_accept_state(ssl);
 893   }
 894
 895   return SSL_do_handshake(ssl);
 896 }
 897
 898 static int ssl_do_post_handshake(SSL *ssl, const SSLMessage &msg) {
 899   if (ssl_protocol_version(ssl) >= TLS1_3_VERSION) {
 900     return tls13_post_handshake(ssl, msg);
 901   }
 902
 903   // We do not accept renegotiations as a server or SSL 3.0. SSL 3.0 will be
 904   // removed entirely in the future and requires retaining more data for
 905   // renegotiation_info.
 906   if (ssl->server || ssl->version == SSL3_VERSION) {
 907     goto no_renegotiation;
 908   }
 909
 910   if (msg.type != SSL3_MT_HELLO_REQUEST || CBS_len(&msg.body) != 0) {
 911     ssl_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
 912     OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_HELLO_REQUEST);
 913     return 0;
 914   }
 915
 916   switch (ssl->renegotiate_mode) {
 917     case ssl_renegotiate_ignore:
 918       // Ignore the HelloRequest.
 919       return 1;
 920
 921     case ssl_renegotiate_once:
 922       if (ssl->s3->total_renegotiations != 0) {
 923         goto no_renegotiation;
 924       }
 925       break;
 926
 927     case ssl_renegotiate_never:
 928       goto no_renegotiation;
 929
 930     case ssl_renegotiate_freely:
 931       break;
 932   }
 933
 934   // Renegotiation is only supported at quiescent points in the application
 935   // protocol, namely in HTTPS, just before reading the HTTP response. Require
 936   // the record-layer be idle and avoid complexities of sending a handshake
 937   // record while an application_data record is being written.
 938   if (!ssl->s3->write_buffer.empty() ||
 939       ssl->s3->write_shutdown != ssl_shutdown_none) {
 940     goto no_renegotiation;
 941   }
 942
 943   // Begin a new handshake.
 944   if (ssl->s3->hs != nullptr) {
 945     OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
 946     return 0;
 947   }
 948   ssl->s3->hs = ssl_handshake_new(ssl);
 949   if (ssl->s3->hs == nullptr) {
 950     return 0;
 951   }
 952
 953   ssl->s3->total_renegotiations++;
 954   return 1;
 955
 956 no_renegotiation:
 957   OPENSSL_PUT_ERROR(SSL, SSL_R_NO_RENEGOTIATION);
 958   ssl_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_NO_RENEGOTIATION);
 959   return 0;
 960 }
 961
 962 static int ssl_read_impl(SSL *ssl) {
 963   ssl_reset_error_state(ssl);
 964
 965   if (ssl->do_handshake == NULL) {
 966     OPENSSL_PUT_ERROR(SSL, SSL_R_UNINITIALIZED);
 967     return -1;
 968   }
 969
 970   // Replay post-handshake message errors.
 971   if (!check_read_error(ssl)) {
 972     return -1;
 973   }
 974
 975   while (ssl->s3->pending_app_data.empty()) {
 976     // Complete the current handshake, if any. False Start will cause
 977     // |SSL_do_handshake| to return mid-handshake, so this may require multiple
 978     // iterations.
 979     while (!ssl_can_read(ssl)) {
 980       int ret = SSL_do_handshake(ssl);
 981       if (ret < 0) {
 982         return ret;
 983       }
 984       if (ret == 0) {
 985         OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
 986         return -1;
 987       }
 988     }
 989
 990     // Process any buffered post-handshake messages.
 991     SSLMessage msg;
 992     if (ssl->method->get_message(ssl, &msg)) {
 993       // If we received an interrupt in early read (EndOfEarlyData), loop again
 994       // for the handshake to process it.
 995       if (SSL_in_init(ssl)) {
 996         ssl->s3->hs->can_early_read = false;
 997         continue;
 998       }
 999
1000       // Handle the post-handshake message and try again.
1001       if (!ssl_do_post_handshake(ssl, msg)) {
1002         ssl_set_read_error(ssl);
1003         return -1;
1004       }
1005       ssl->method->next_message(ssl);
1006       continue;  // Loop again. We may have begun a new handshake.
1007     }
1008
1009     uint8_t alert = SSL_AD_DECODE_ERROR;
1010     size_t consumed = 0;
1011     auto ret = ssl_open_app_data(ssl, &ssl->s3->pending_app_data, &consumed,
1012                                  &alert, ssl->s3->read_buffer.span());
1013     bool retry;
1014     int bio_ret = ssl_handle_open_record(ssl, &retry, ret, consumed, alert);
1015     if (bio_ret <= 0) {
1016       return bio_ret;
1017     }
1018     if (!retry) {
1019       assert(!ssl->s3->pending_app_data.empty());
1020       ssl->s3->key_update_count = 0;
1021     }
1022   }
1023
1024   return 1;
1025 }
1026
1027 int SSL_read(SSL *ssl, void *buf, int num) {
1028   int ret = SSL_peek(ssl, buf, num);
1029   if (ret <= 0) {
1030     return ret;
1031   }
1032   // TODO(davidben): In DTLS, should the rest of the record be discarded?  DTLS
1033   // is not a stream. See https://crbug.com/boringssl/65.
1034   ssl->s3->pending_app_data =
1035       ssl->s3->pending_app_data.subspan(static_cast<size_t>(ret));
1036   if (ssl->s3->pending_app_data.empty()) {
1037     ssl->s3->read_buffer.DiscardConsumed();
1038   }
1039   return ret;
1040 }
1041
1042 int SSL_peek(SSL *ssl, void *buf, int num) {
1043   int ret = ssl_read_impl(ssl);
1044   if (ret <= 0) {
1045     return ret;
1046   }
1047   if (num <= 0) {
1048     return num;
1049   }
1050   size_t todo =
1051       std::min(ssl->s3->pending_app_data.size(), static_cast<size_t>(num));
1052   OPENSSL_memcpy(buf, ssl->s3->pending_app_data.data(), todo);
1053   return static_cast<int>(todo);
1054 }
1055
1056 int SSL_write(SSL *ssl, const void *buf, int num) {
1057   ssl_reset_error_state(ssl);
1058
1059   if (ssl->do_handshake == NULL) {
1060     OPENSSL_PUT_ERROR(SSL, SSL_R_UNINITIALIZED);
1061     return -1;
1062   }
1063
1064   if (ssl->s3->write_shutdown != ssl_shutdown_none) {
1065     OPENSSL_PUT_ERROR(SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
1066     return -1;
1067   }
1068
1069   int ret = 0;
1070   bool needs_handshake = false;
1071   do {
1072     // If necessary, complete the handshake implicitly.
1073     if (!ssl_can_write(ssl)) {
1074       ret = SSL_do_handshake(ssl);
1075       if (ret < 0) {
1076         return ret;
1077       }
1078       if (ret == 0) {
1079         OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
1080         return -1;
1081       }
1082     }
1083
1084     ret = ssl->method->write_app_data(ssl, &needs_handshake,
1085                                       (const uint8_t *)buf, num);
1086   } while (needs_handshake);
1087   return ret;
1088 }
1089
1090 int SSL_shutdown(SSL *ssl) {
1091   ssl_reset_error_state(ssl);
1092
1093   if (ssl->do_handshake == NULL) {
1094     OPENSSL_PUT_ERROR(SSL, SSL_R_UNINITIALIZED);
1095     return -1;
1096   }
1097
1098   // If we are in the middle of a handshake, silently succeed. Consumers often
1099   // call this function before |SSL_free|, whether the handshake succeeded or
1100   // not. We assume the caller has already handled failed handshakes.
1101   if (SSL_in_init(ssl)) {
1102     return 1;
1103   }
1104
1105   if (ssl->quiet_shutdown) {
1106     // Do nothing if configured not to send a close_notify.
1107     ssl->s3->write_shutdown = ssl_shutdown_close_notify;
1108     ssl->s3->read_shutdown = ssl_shutdown_close_notify;
1109     return 1;
1110   }
1111
1112   // This function completes in two stages. It sends a close_notify and then it
1113   // waits for a close_notify to come in. Perform exactly one action and return
1114   // whether or not it succeeds.
1115
1116   if (ssl->s3->write_shutdown != ssl_shutdown_close_notify) {
1117     // Send a close_notify.
1118     if (ssl_send_alert(ssl, SSL3_AL_WARNING, SSL_AD_CLOSE_NOTIFY) <= 0) {
1119       return -1;
1120     }
1121   } else if (ssl->s3->alert_dispatch) {
1122     // Finish sending the close_notify.
1123     if (ssl->method->dispatch_alert(ssl) <= 0) {
1124       return -1;
1125     }
1126   } else if (ssl->s3->read_shutdown != ssl_shutdown_close_notify) {
1127     if (SSL_is_dtls(ssl)) {
1128       // Bidirectional shutdown doesn't make sense for an unordered
1129       // transport. DTLS alerts also aren't delivered reliably, so we may even
1130       // time out because the peer never received our close_notify. Report to
1131       // the caller that the channel has fully shut down.
1132       if (ssl->s3->read_shutdown == ssl_shutdown_error) {
1133         ERR_restore_state(ssl->s3->read_error.get());
1134         return -1;
1135       }
1136       ssl->s3->read_shutdown = ssl_shutdown_close_notify;
1137     } else {
1138       // Keep discarding data until we see a close_notify.
1139       for (;;) {
1140         ssl->s3->pending_app_data = Span<uint8_t>();
1141         int ret = ssl_read_impl(ssl);
1142         if (ret <= 0) {
1143           break;
1144         }
1145       }
1146       if (ssl->s3->read_shutdown != ssl_shutdown_close_notify) {
1147         return -1;
1148       }
1149     }
1150   }
1151
1152   // Return 0 for unidirectional shutdown and 1 for bidirectional shutdown.
1153   return ssl->s3->read_shutdown == ssl_shutdown_close_notify;
1154 }
1155
1156 int SSL_send_fatal_alert(SSL *ssl, uint8_t alert) {
1157   if (ssl->s3->alert_dispatch) {
1158     if (ssl->s3->send_alert[0] != SSL3_AL_FATAL ||
1159         ssl->s3->send_alert[1] != alert) {
1160       // We are already attempting to write a different alert.
1161       OPENSSL_PUT_ERROR(SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
1162       return -1;
1163     }
1164     return ssl->method->dispatch_alert(ssl);
1165   }
1166
1167   return ssl_send_alert(ssl, SSL3_AL_FATAL, alert);
1168 }
1169
1170 int SSL_set_quic_transport_params(SSL *ssl, const uint8_t *params,
1171                                   size_t params_len) {
1172   ssl->quic_transport_params = (uint8_t *)BUF_memdup(params, params_len);
1173   if (!ssl->quic_transport_params) {
1174     return 0;
1175   }
1176   ssl->quic_transport_params_len = params_len;
1177   return 1;
1178 }
1179
1180 void SSL_get_peer_quic_transport_params(const SSL *ssl,
1181                                         const uint8_t **out_params,
1182                                         size_t *out_params_len) {
1183   *out_params = ssl->s3->peer_quic_transport_params.data();
1184   *out_params_len = ssl->s3->peer_quic_transport_params.size();
1185 }
1186
1187 void SSL_CTX_set_early_data_enabled(SSL_CTX *ctx, int enabled) {
1188   ctx->cert->enable_early_data = !!enabled;
1189 }
1190
1191 void SSL_CTX_set_tls13_variant(SSL_CTX *ctx, enum tls13_variant_t variant) {
1192   ctx->tls13_variant = variant;
1193 }
1194
1195 void SSL_set_tls13_variant(SSL *ssl, enum tls13_variant_t variant) {
1196   ssl->tls13_variant = variant;
1197 }
1198
1199 void SSL_set_early_data_enabled(SSL *ssl, int enabled) {
1200   ssl->cert->enable_early_data = !!enabled;
1201 }
1202
1203 int SSL_in_early_data(const SSL *ssl) {
1204   if (ssl->s3->hs == NULL) {
1205     return 0;
1206   }
1207   return ssl->s3->hs->in_early_data;
1208 }
1209
1210 int SSL_early_data_accepted(const SSL *ssl) {
1211   return ssl->s3->early_data_accepted;
1212 }
1213
1214 void SSL_reset_early_data_reject(SSL *ssl) {
1215   SSL_HANDSHAKE *hs = ssl->s3->hs.get();
1216   if (hs == NULL ||
1217       hs->wait != ssl_hs_early_data_rejected) {
1218     abort();
1219   }
1220
1221   hs->wait = ssl_hs_ok;
1222   hs->in_early_data = false;
1223   hs->early_session.reset();
1224
1225   // Discard any unfinished writes from the perspective of |SSL_write|'s
1226   // retry. The handshake will transparently flush out the pending record
1227   // (discarded by the server) to keep the framing correct.
1228   ssl->s3->wpend_pending = false;
1229 }
1230
1231 static int bio_retry_reason_to_error(int reason) {
1232   switch (reason) {
1233     case BIO_RR_CONNECT:
1234       return SSL_ERROR_WANT_CONNECT;
1235     case BIO_RR_ACCEPT:
1236       return SSL_ERROR_WANT_ACCEPT;
1237     default:
1238       return SSL_ERROR_SYSCALL;
1239   }
1240 }
1241
1242 int SSL_get_error(const SSL *ssl, int ret_code) {
1243   if (ret_code > 0) {
1244     return SSL_ERROR_NONE;
1245   }
1246
1247   // Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
1248   // where we do encode the error
1249   uint32_t err = ERR_peek_error();
1250   if (err != 0) {
1251     if (ERR_GET_LIB(err) == ERR_LIB_SYS) {
1252       return SSL_ERROR_SYSCALL;
1253     }
1254     return SSL_ERROR_SSL;
1255   }
1256
1257   if (ret_code == 0) {
1258     if (ssl->s3->read_shutdown == ssl_shutdown_close_notify) {
1259       return SSL_ERROR_ZERO_RETURN;
1260     }
1261     // An EOF was observed which violates the protocol, and the underlying
1262     // transport does not participate in the error queue. Bubble up to the
1263     // caller.
1264     return SSL_ERROR_SYSCALL;
1265   }
1266
1267   switch (ssl->s3->rwstate) {
1268     case SSL_PENDING_SESSION:
1269       return SSL_ERROR_PENDING_SESSION;
1270
1271     case SSL_CERTIFICATE_SELECTION_PENDING:
1272       return SSL_ERROR_PENDING_CERTIFICATE;
1273
1274     case SSL_HANDOFF:
1275       return SSL_ERROR_HANDOFF;
1276
1277     case SSL_READING: {
1278       BIO *bio = SSL_get_rbio(ssl);
1279       if (BIO_should_read(bio)) {
1280         return SSL_ERROR_WANT_READ;
1281       }
1282
1283       if (BIO_should_write(bio)) {
1284         // TODO(davidben): OpenSSL historically checked for writes on the read
1285         // BIO. Can this be removed?
1286         return SSL_ERROR_WANT_WRITE;
1287       }
1288
1289       if (BIO_should_io_special(bio)) {
1290         return bio_retry_reason_to_error(BIO_get_retry_reason(bio));
1291       }
1292
1293       break;
1294     }
1295
1296     case SSL_WRITING: {
1297       BIO *bio = SSL_get_wbio(ssl);
1298       if (BIO_should_write(bio)) {
1299         return SSL_ERROR_WANT_WRITE;
1300       }
1301
1302       if (BIO_should_read(bio)) {
1303         // TODO(davidben): OpenSSL historically checked for reads on the write
1304         // BIO. Can this be removed?
1305         return SSL_ERROR_WANT_READ;
1306       }
1307
1308       if (BIO_should_io_special(bio)) {
1309         return bio_retry_reason_to_error(BIO_get_retry_reason(bio));
1310       }
1311
1312       break;
1313     }
1314
1315     case SSL_X509_LOOKUP:
1316       return SSL_ERROR_WANT_X509_LOOKUP;
1317
1318     case SSL_CHANNEL_ID_LOOKUP:
1319       return SSL_ERROR_WANT_CHANNEL_ID_LOOKUP;
1320
1321     case SSL_PRIVATE_KEY_OPERATION:
1322       return SSL_ERROR_WANT_PRIVATE_KEY_OPERATION;
1323
1324     case SSL_PENDING_TICKET:
1325       return SSL_ERROR_PENDING_TICKET;
1326
1327     case SSL_EARLY_DATA_REJECTED:
1328       return SSL_ERROR_EARLY_DATA_REJECTED;
1329
1330     case SSL_CERTIFICATE_VERIFY:
1331       return SSL_ERROR_WANT_CERTIFICATE_VERIFY;
1332   }
1333
1334   return SSL_ERROR_SYSCALL;
1335 }
1336
1337 uint32_t SSL_CTX_set_options(SSL_CTX *ctx, uint32_t options) {
1338   ctx->options |= options;
1339   return ctx->options;
1340 }
1341
1342 uint32_t SSL_CTX_clear_options(SSL_CTX *ctx, uint32_t options) {
1343   ctx->options &= ~options;
1344   return ctx->options;
1345 }
1346
1347 uint32_t SSL_CTX_get_options(const SSL_CTX *ctx) { return ctx->options; }
1348
1349 uint32_t SSL_set_options(SSL *ssl, uint32_t options) {
1350   ssl->options |= options;
1351   return ssl->options;
1352 }
1353
1354 uint32_t SSL_clear_options(SSL *ssl, uint32_t options) {
1355   ssl->options &= ~options;
1356   return ssl->options;
1357 }
1358
1359 uint32_t SSL_get_options(const SSL *ssl) { return ssl->options; }
1360
1361 uint32_t SSL_CTX_set_mode(SSL_CTX *ctx, uint32_t mode) {
1362   ctx->mode |= mode;
1363   return ctx->mode;
1364 }
1365
1366 uint32_t SSL_CTX_clear_mode(SSL_CTX *ctx, uint32_t mode) {
1367   ctx->mode &= ~mode;
1368   return ctx->mode;
1369 }
1370
1371 uint32_t SSL_CTX_get_mode(const SSL_CTX *ctx) { return ctx->mode; }
1372
1373 uint32_t SSL_set_mode(SSL *ssl, uint32_t mode) {
1374   ssl->mode |= mode;
1375   return ssl->mode;
1376 }
1377
1378 uint32_t SSL_clear_mode(SSL *ssl, uint32_t mode) {
1379   ssl->mode &= ~mode;
1380   return ssl->mode;
1381 }
1382
1383 uint32_t SSL_get_mode(const SSL *ssl) { return ssl->mode; }
1384
1385 void SSL_CTX_set0_buffer_pool(SSL_CTX *ctx, CRYPTO_BUFFER_POOL *pool) {
1386   ctx->pool = pool;
1387 }
1388
1389 int SSL_get_tls_unique(const SSL *ssl, uint8_t *out, size_t *out_len,
1390                        size_t max_out) {
1391   *out_len = 0;
1392   OPENSSL_memset(out, 0, max_out);
1393
1394   // tls-unique is not defined for SSL 3.0 or TLS 1.3.
1395   if (!ssl->s3->initial_handshake_complete ||
1396       ssl_protocol_version(ssl) < TLS1_VERSION ||
1397       ssl_protocol_version(ssl) >= TLS1_3_VERSION) {
1398     return 0;
1399   }
1400
1401   // The tls-unique value is the first Finished message in the handshake, which
1402   // is the client's in a full handshake and the server's for a resumption. See
1403   // https://tools.ietf.org/html/rfc5929#section-3.1.
1404   const uint8_t *finished = ssl->s3->previous_client_finished;
1405   size_t finished_len = ssl->s3->previous_client_finished_len;
1406   if (ssl->session != NULL) {
1407     // tls-unique is broken for resumed sessions unless EMS is used.
1408     if (!ssl->session->extended_master_secret) {
1409       return 0;
1410     }
1411     finished = ssl->s3->previous_server_finished;
1412     finished_len = ssl->s3->previous_server_finished_len;
1413   }
1414
1415   *out_len = finished_len;
1416   if (finished_len > max_out) {
1417     *out_len = max_out;
1418   }
1419
1420   OPENSSL_memcpy(out, finished, *out_len);
1421   return 1;
1422 }
1423
1424 static int set_session_id_context(CERT *cert, const uint8_t *sid_ctx,
1425                                    size_t sid_ctx_len) {
1426   if (sid_ctx_len > sizeof(cert->sid_ctx)) {
1427     OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
1428     return 0;
1429   }
1430
1431   static_assert(sizeof(cert->sid_ctx) < 256, "sid_ctx too large");
1432   cert->sid_ctx_length = (uint8_t)sid_ctx_len;
1433   OPENSSL_memcpy(cert->sid_ctx, sid_ctx, sid_ctx_len);
1434   return 1;
1435 }
1436
1437 int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const uint8_t *sid_ctx,
1438                                    size_t sid_ctx_len) {
1439   return set_session_id_context(ctx->cert, sid_ctx, sid_ctx_len);
1440 }
1441
1442 int SSL_set_session_id_context(SSL *ssl, const uint8_t *sid_ctx,
1443                                size_t sid_ctx_len) {
1444   return set_session_id_context(ssl->cert, sid_ctx, sid_ctx_len);
1445 }
1446
1447 const uint8_t *SSL_get0_session_id_context(const SSL *ssl, size_t *out_len) {
1448   *out_len = ssl->cert->sid_ctx_length;
1449   return ssl->cert->sid_ctx;
1450 }
1451
1452 void SSL_certs_clear(SSL *ssl) { ssl_cert_clear_certs(ssl->cert); }
1453
1454 int SSL_get_fd(const SSL *ssl) { return SSL_get_rfd(ssl); }
1455
1456 int SSL_get_rfd(const SSL *ssl) {
1457   int ret = -1;
1458   BIO *b = BIO_find_type(SSL_get_rbio(ssl), BIO_TYPE_DESCRIPTOR);
1459   if (b != NULL) {
1460     BIO_get_fd(b, &ret);
1461   }
1462   return ret;
1463 }
1464
1465 int SSL_get_wfd(const SSL *ssl) {
1466   int ret = -1;
1467   BIO *b = BIO_find_type(SSL_get_wbio(ssl), BIO_TYPE_DESCRIPTOR);
1468   if (b != NULL) {
1469     BIO_get_fd(b, &ret);
1470   }
1471   return ret;
1472 }
1473
1474 int SSL_set_fd(SSL *ssl, int fd) {
1475   BIO *bio = BIO_new(BIO_s_socket());
1476   if (bio == NULL) {
1477     OPENSSL_PUT_ERROR(SSL, ERR_R_BUF_LIB);
1478     return 0;
1479   }
1480   BIO_set_fd(bio, fd, BIO_NOCLOSE);
1481   SSL_set_bio(ssl, bio, bio);
1482   return 1;
1483 }
1484
1485 int SSL_set_wfd(SSL *ssl, int fd) {
1486   BIO *rbio = SSL_get_rbio(ssl);
1487   if (rbio == NULL || BIO_method_type(rbio) != BIO_TYPE_SOCKET ||
1488       BIO_get_fd(rbio, NULL) != fd) {
1489     BIO *bio = BIO_new(BIO_s_socket());
1490     if (bio == NULL) {
1491       OPENSSL_PUT_ERROR(SSL, ERR_R_BUF_LIB);
1492       return 0;
1493     }
1494     BIO_set_fd(bio, fd, BIO_NOCLOSE);
1495     SSL_set0_wbio(ssl, bio);
1496   } else {
1497     // Copy the rbio over to the wbio.
1498     BIO_up_ref(rbio);
1499     SSL_set0_wbio(ssl, rbio);
1500   }
1501
1502   return 1;
1503 }
1504
1505 int SSL_set_rfd(SSL *ssl, int fd) {
1506   BIO *wbio = SSL_get_wbio(ssl);
1507   if (wbio == NULL || BIO_method_type(wbio) != BIO_TYPE_SOCKET ||
1508       BIO_get_fd(wbio, NULL) != fd) {
1509     BIO *bio = BIO_new(BIO_s_socket());
1510     if (bio == NULL) {
1511       OPENSSL_PUT_ERROR(SSL, ERR_R_BUF_LIB);
1512       return 0;
1513     }
1514     BIO_set_fd(bio, fd, BIO_NOCLOSE);
1515     SSL_set0_rbio(ssl, bio);
1516   } else {
1517     // Copy the wbio over to the rbio.
1518     BIO_up_ref(wbio);
1519     SSL_set0_rbio(ssl, wbio);
1520   }
1521   return 1;
1522 }
1523
1524 static size_t copy_finished(void *out, size_t out_len, const uint8_t *in,
1525                             size_t in_len) {
1526   if (out_len > in_len) {
1527     out_len = in_len;
1528   }
1529   OPENSSL_memcpy(out, in, out_len);
1530   return in_len;
1531 }
1532
1533 size_t SSL_get_finished(const SSL *ssl, void *buf, size_t count) {
1534   if (!ssl->s3->initial_handshake_complete ||
1535       ssl_protocol_version(ssl) < TLS1_VERSION ||
1536       ssl_protocol_version(ssl) >= TLS1_3_VERSION) {
1537     return 0;
1538   }
1539
1540   if (ssl->server) {
1541     return copy_finished(buf, count, ssl->s3->previous_server_finished,
1542                          ssl->s3->previous_server_finished_len);
1543   }
1544
1545   return copy_finished(buf, count, ssl->s3->previous_client_finished,
1546                        ssl->s3->previous_client_finished_len);
1547 }
1548
1549 size_t SSL_get_peer_finished(const SSL *ssl, void *buf, size_t count) {
1550   if (!ssl->s3->initial_handshake_complete ||
1551       ssl_protocol_version(ssl) < TLS1_VERSION ||
1552       ssl_protocol_version(ssl) >= TLS1_3_VERSION) {
1553     return 0;
1554   }
1555
1556   if (ssl->server) {
1557     return copy_finished(buf, count, ssl->s3->previous_client_finished,
1558                          ssl->s3->previous_client_finished_len);
1559   }
1560
1561   return copy_finished(buf, count, ssl->s3->previous_server_finished,
1562                        ssl->s3->previous_server_finished_len);
1563 }
1564
1565 int SSL_get_verify_mode(const SSL *ssl) { return ssl->verify_mode; }
1566
1567 int SSL_get_extms_support(const SSL *ssl) {
1568   // TLS 1.3 does not require extended master secret and always reports as
1569   // supporting it.
1570   if (!ssl->s3->have_version) {
1571     return 0;
1572   }
1573   if (ssl_protocol_version(ssl) >= TLS1_3_VERSION) {
1574     return 1;
1575   }
1576
1577   // If the initial handshake completed, query the established session.
1578   if (ssl->s3->established_session != NULL) {
1579     return ssl->s3->established_session->extended_master_secret;
1580   }
1581
1582   // Otherwise, query the in-progress handshake.
1583   if (ssl->s3->hs != NULL) {
1584     return ssl->s3->hs->extended_master_secret;
1585   }
1586   assert(0);
1587   return 0;
1588 }
1589
1590 int SSL_CTX_get_read_ahead(const SSL_CTX *ctx) { return 0; }
1591
1592 int SSL_get_read_ahead(const SSL *ssl) { return 0; }
1593
1594 void SSL_CTX_set_read_ahead(SSL_CTX *ctx, int yes) { }
1595
1596 void SSL_set_read_ahead(SSL *ssl, int yes) { }
1597
1598 int SSL_pending(const SSL *ssl) {
1599   return static_cast<int>(ssl->s3->pending_app_data.size());
1600 }
1601
1602 // Fix this so it checks all the valid key/cert options
1603 int SSL_CTX_check_private_key(const SSL_CTX *ctx) {
1604   return ssl_cert_check_private_key(ctx->cert, ctx->cert->privatekey);
1605 }
1606
1607 // Fix this function so that it takes an optional type parameter
1608 int SSL_check_private_key(const SSL *ssl) {
1609   return ssl_cert_check_private_key(ssl->cert, ssl->cert->privatekey);
1610 }
1611
1612 long SSL_get_default_timeout(const SSL *ssl) {
1613   return SSL_DEFAULT_SESSION_TIMEOUT;
1614 }
1615
1616 int SSL_renegotiate(SSL *ssl) {
1617   // Caller-initiated renegotiation is not supported.
1618   OPENSSL_PUT_ERROR(SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1619   return 0;
1620 }
1621
1622 int SSL_renegotiate_pending(SSL *ssl) {
1623   return SSL_in_init(ssl) && ssl->s3->initial_handshake_complete;
1624 }
1625
1626 int SSL_total_renegotiations(const SSL *ssl) {
1627   return ssl->s3->total_renegotiations;
1628 }
1629
1630 size_t SSL_CTX_get_max_cert_list(const SSL_CTX *ctx) {
1631   return ctx->max_cert_list;
1632 }
1633
1634 void SSL_CTX_set_max_cert_list(SSL_CTX *ctx, size_t max_cert_list) {
1635   if (max_cert_list > kMaxHandshakeSize) {
1636     max_cert_list = kMaxHandshakeSize;
1637   }
1638   ctx->max_cert_list = (uint32_t)max_cert_list;
1639 }
1640
1641 size_t SSL_get_max_cert_list(const SSL *ssl) {
1642   return ssl->max_cert_list;
1643 }
1644
1645 void SSL_set_max_cert_list(SSL *ssl, size_t max_cert_list) {
1646   if (max_cert_list > kMaxHandshakeSize) {
1647     max_cert_list = kMaxHandshakeSize;
1648   }
1649   ssl->max_cert_list = (uint32_t)max_cert_list;
1650 }
1651
1652 int SSL_CTX_set_max_send_fragment(SSL_CTX *ctx, size_t max_send_fragment) {
1653   if (max_send_fragment < 512) {
1654     max_send_fragment = 512;
1655   }
1656   if (max_send_fragment > SSL3_RT_MAX_PLAIN_LENGTH) {
1657     max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
1658   }
1659   ctx->max_send_fragment = (uint16_t)max_send_fragment;
1660
1661   return 1;
1662 }
1663
1664 int SSL_set_max_send_fragment(SSL *ssl, size_t max_send_fragment) {
1665   if (max_send_fragment < 512) {
1666     max_send_fragment = 512;
1667   }
1668   if (max_send_fragment > SSL3_RT_MAX_PLAIN_LENGTH) {
1669     max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
1670   }
1671   ssl->max_send_fragment = (uint16_t)max_send_fragment;
1672
1673   return 1;
1674 }
1675
1676 int SSL_set_mtu(SSL *ssl, unsigned mtu) {
1677   if (!SSL_is_dtls(ssl) || mtu < dtls1_min_mtu()) {
1678     return 0;
1679   }
1680   ssl->d1->mtu = mtu;
1681   return 1;
1682 }
1683
1684 int SSL_get_secure_renegotiation_support(const SSL *ssl) {
1685   if (!ssl->s3->have_version) {
1686     return 0;
1687   }
1688   return ssl_protocol_version(ssl) >= TLS1_3_VERSION ||
1689          ssl->s3->send_connection_binding;
1690 }
1691
1692 size_t SSL_CTX_sess_number(const SSL_CTX *ctx) {
1693   MutexReadLock lock(const_cast<CRYPTO_MUTEX *>(&ctx->lock));
1694   return lh_SSL_SESSION_num_items(ctx->sessions);
1695 }
1696
1697 unsigned long SSL_CTX_sess_set_cache_size(SSL_CTX *ctx, unsigned long size) {
1698   unsigned long ret = ctx->session_cache_size;
1699   ctx->session_cache_size = size;
1700   return ret;
1701 }
1702
1703 unsigned long SSL_CTX_sess_get_cache_size(const SSL_CTX *ctx) {
1704   return ctx->session_cache_size;
1705 }
1706
1707 int SSL_CTX_set_session_cache_mode(SSL_CTX *ctx, int mode) {
1708   int ret = ctx->session_cache_mode;
1709   ctx->session_cache_mode = mode;
1710   return ret;
1711 }
1712
1713 int SSL_CTX_get_session_cache_mode(const SSL_CTX *ctx) {
1714   return ctx->session_cache_mode;
1715 }
1716
1717
1718 int SSL_CTX_get_tlsext_ticket_keys(SSL_CTX *ctx, void *out, size_t len) {
1719   if (out == NULL) {
1720     return 48;
1721   }
1722   if (len != 48) {
1723     OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH);
1724     return 0;
1725   }
1726
1727   // The default ticket keys are initialized lazily. Trigger a key
1728   // rotation to initialize them.
1729   if (!ssl_ctx_rotate_ticket_encryption_key(ctx)) {
1730     return 0;
1731   }
1732
1733   uint8_t *out_bytes = reinterpret_cast<uint8_t *>(out);
1734   MutexReadLock lock(&ctx->lock);
1735   OPENSSL_memcpy(out_bytes, ctx->tlsext_ticket_key_current->name, 16);
1736   OPENSSL_memcpy(out_bytes + 16, ctx->tlsext_ticket_key_current->hmac_key, 16);
1737   OPENSSL_memcpy(out_bytes + 32, ctx->tlsext_ticket_key_current->aes_key, 16);
1738   return 1;
1739 }
1740
1741 int SSL_CTX_set_tlsext_ticket_keys(SSL_CTX *ctx, const void *in, size_t len) {
1742   if (in == NULL) {
1743     return 48;
1744   }
1745   if (len != 48) {
1746     OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH);
1747     return 0;
1748   }
1749   if (!ctx->tlsext_ticket_key_current) {
1750     ctx->tlsext_ticket_key_current =
1751         (tlsext_ticket_key *)OPENSSL_malloc(sizeof(tlsext_ticket_key));
1752     if (!ctx->tlsext_ticket_key_current) {
1753       return 0;
1754     }
1755   }
1756   OPENSSL_memset(ctx->tlsext_ticket_key_current, 0, sizeof(tlsext_ticket_key));
1757   const uint8_t *in_bytes = reinterpret_cast<const uint8_t *>(in);
1758   OPENSSL_memcpy(ctx->tlsext_ticket_key_current->name, in_bytes, 16);
1759   OPENSSL_memcpy(ctx->tlsext_ticket_key_current->hmac_key, in_bytes + 16, 16);
1760   OPENSSL_memcpy(ctx->tlsext_ticket_key_current->aes_key, in_bytes + 32, 16);
1761   OPENSSL_free(ctx->tlsext_ticket_key_prev);
1762   ctx->tlsext_ticket_key_prev = nullptr;
1763   // Disable automatic key rotation.
1764   ctx->tlsext_ticket_key_current->next_rotation_tv_sec = 0;
1765   return 1;
1766 }
1767
1768 int SSL_CTX_set_tlsext_ticket_key_cb(
1769     SSL_CTX *ctx, int (*callback)(SSL *ssl, uint8_t *key_name, uint8_t *iv,
1770                                   EVP_CIPHER_CTX *ctx, HMAC_CTX *hmac_ctx,
1771                                   int encrypt)) {
1772   ctx->tlsext_ticket_key_cb = callback;
1773   return 1;
1774 }
1775
1776 int SSL_CTX_set1_curves(SSL_CTX *ctx, const int *curves, size_t curves_len) {
1777   return tls1_set_curves(&ctx->supported_group_list,
1778                          &ctx->supported_group_list_len, curves,
1779                          curves_len);
1780 }
1781
1782 int SSL_set1_curves(SSL *ssl, const int *curves, size_t curves_len) {
1783   return tls1_set_curves(&ssl->supported_group_list,
1784                          &ssl->supported_group_list_len, curves,
1785                          curves_len);
1786 }
1787
1788 int SSL_CTX_set1_curves_list(SSL_CTX *ctx, const char *curves) {
1789   return tls1_set_curves_list(&ctx->supported_group_list,
1790                               &ctx->supported_group_list_len, curves);
1791 }
1792
1793 int SSL_set1_curves_list(SSL *ssl, const char *curves) {
1794   return tls1_set_curves_list(&ssl->supported_group_list,
1795                               &ssl->supported_group_list_len, curves);
1796 }
1797
1798 uint16_t SSL_get_curve_id(const SSL *ssl) {
1799   // TODO(davidben): This checks the wrong session if there is a renegotiation
1800   // in progress.
1801   SSL_SESSION *session = SSL_get_session(ssl);
1802   if (session == NULL) {
1803     return 0;
1804   }
1805
1806   return session->group_id;
1807 }
1808
1809 int SSL_CTX_set_tmp_dh(SSL_CTX *ctx, const DH *dh) {
1810   return 1;
1811 }
1812
1813 int SSL_set_tmp_dh(SSL *ssl, const DH *dh) {
1814   return 1;
1815 }
1816
1817 STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx) {
1818   return ctx->cipher_list->ciphers;
1819 }
1820
1821 int SSL_CTX_cipher_in_group(const SSL_CTX *ctx, size_t i) {
1822   if (i >= sk_SSL_CIPHER_num(ctx->cipher_list->ciphers)) {
1823     return 0;
1824   }
1825   return ctx->cipher_list->in_group_flags[i];
1826 }
1827
1828 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *ssl) {
1829   if (ssl == NULL) {
1830     return NULL;
1831   }
1832
1833   const struct ssl_cipher_preference_list_st *prefs =
1834       ssl_get_cipher_preferences(ssl);
1835   if (prefs == NULL) {
1836     return NULL;
1837   }
1838
1839   return prefs->ciphers;
1840 }
1841
1842 const char *SSL_get_cipher_list(const SSL *ssl, int n) {
1843   if (ssl == NULL) {
1844     return NULL;
1845   }
1846
1847   STACK_OF(SSL_CIPHER) *sk = SSL_get_ciphers(ssl);
1848   if (sk == NULL || n < 0 || (size_t)n >= sk_SSL_CIPHER_num(sk)) {
1849     return NULL;
1850   }
1851
1852   const SSL_CIPHER *c = sk_SSL_CIPHER_value(sk, n);
1853   if (c == NULL) {
1854     return NULL;
1855   }
1856
1857   return c->name;
1858 }
1859
1860 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str) {
1861   return ssl_create_cipher_list(&ctx->cipher_list, str, false /* not strict */);
1862 }
1863
1864 int SSL_CTX_set_strict_cipher_list(SSL_CTX *ctx, const char *str) {
1865   return ssl_create_cipher_list(&ctx->cipher_list, str, true /* strict */);
1866 }
1867
1868 int SSL_set_cipher_list(SSL *ssl, const char *str) {
1869   return ssl_create_cipher_list(&ssl->cipher_list, str, false /* not strict */);
1870 }
1871
1872 int SSL_set_strict_cipher_list(SSL *ssl, const char *str) {
1873   return ssl_create_cipher_list(&ssl->cipher_list, str, true /* strict */);
1874 }
1875
1876 const char *SSL_get_servername(const SSL *ssl, const int type) {
1877   if (type != TLSEXT_NAMETYPE_host_name) {
1878     return NULL;
1879   }
1880
1881   // Historically, |SSL_get_servername| was also the configuration getter
1882   // corresponding to |SSL_set_tlsext_host_name|.
1883   if (ssl->tlsext_hostname != NULL) {
1884     return ssl->tlsext_hostname;
1885   }
1886
1887   return ssl->s3->hostname.get();
1888 }
1889
1890 int SSL_get_servername_type(const SSL *ssl) {
1891   if (SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name) == NULL) {
1892     return -1;
1893   }
1894   return TLSEXT_NAMETYPE_host_name;
1895 }
1896
1897 void SSL_CTX_set_custom_verify(
1898     SSL_CTX *ctx, int mode,
1899     enum ssl_verify_result_t (*callback)(SSL *ssl, uint8_t *out_alert)) {
1900   ctx->verify_mode = mode;
1901   ctx->custom_verify_callback = callback;
1902 }
1903
1904 void SSL_set_custom_verify(
1905     SSL *ssl, int mode,
1906     enum ssl_verify_result_t (*callback)(SSL *ssl, uint8_t *out_alert)) {
1907   ssl->verify_mode = mode;
1908   ssl->custom_verify_callback = callback;
1909 }
1910
1911 void SSL_CTX_enable_signed_cert_timestamps(SSL_CTX *ctx) {
1912   ctx->signed_cert_timestamps_enabled = true;
1913 }
1914
1915 void SSL_enable_signed_cert_timestamps(SSL *ssl) {
1916   ssl->signed_cert_timestamps_enabled = true;
1917 }
1918
1919 void SSL_CTX_enable_ocsp_stapling(SSL_CTX *ctx) {
1920   ctx->ocsp_stapling_enabled = true;
1921 }
1922
1923 void SSL_enable_ocsp_stapling(SSL *ssl) {
1924   ssl->ocsp_stapling_enabled = true;
1925 }
1926
1927 void SSL_get0_signed_cert_timestamp_list(const SSL *ssl, const uint8_t **out,
1928                                          size_t *out_len) {
1929   SSL_SESSION *session = SSL_get_session(ssl);
1930   if (ssl->server || !session || !session->signed_cert_timestamp_list) {
1931     *out_len = 0;
1932     *out = NULL;
1933     return;
1934   }
1935
1936   *out = CRYPTO_BUFFER_data(session->signed_cert_timestamp_list);
1937   *out_len = CRYPTO_BUFFER_len(session->signed_cert_timestamp_list);
1938 }
1939
1940 void SSL_get0_ocsp_response(const SSL *ssl, const uint8_t **out,
1941                             size_t *out_len) {
1942   SSL_SESSION *session = SSL_get_session(ssl);
1943   if (ssl->server || !session || !session->ocsp_response) {
1944     *out_len = 0;
1945     *out = NULL;
1946     return;
1947   }
1948
1949   *out = CRYPTO_BUFFER_data(session->ocsp_response);
1950   *out_len = CRYPTO_BUFFER_len(session->ocsp_response);
1951 }
1952
1953 int SSL_set_tlsext_host_name(SSL *ssl, const char *name) {
1954   OPENSSL_free(ssl->tlsext_hostname);
1955   ssl->tlsext_hostname = NULL;
1956
1957   if (name == NULL) {
1958     return 1;
1959   }
1960
1961   size_t len = strlen(name);
1962   if (len == 0 || len > TLSEXT_MAXLEN_host_name) {
1963     OPENSSL_PUT_ERROR(SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME);
1964     return 0;
1965   }
1966   ssl->tlsext_hostname = BUF_strdup(name);
1967   if (ssl->tlsext_hostname == NULL) {
1968     OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
1969     return 0;
1970   }
1971   return 1;
1972 }
1973
1974 int SSL_CTX_set_tlsext_servername_callback(
1975     SSL_CTX *ctx, int (*callback)(SSL *ssl, int *out_alert, void *arg)) {
1976   ctx->tlsext_servername_callback = callback;
1977   return 1;
1978 }
1979
1980 int SSL_CTX_set_tlsext_servername_arg(SSL_CTX *ctx, void *arg) {
1981   ctx->tlsext_servername_arg = arg;
1982   return 1;
1983 }
1984
1985 int SSL_select_next_proto(uint8_t **out, uint8_t *out_len, const uint8_t *peer,
1986                           unsigned peer_len, const uint8_t *supported,
1987                           unsigned supported_len) {
1988   const uint8_t *result;
1989   int status;
1990
1991   // For each protocol in peer preference order, see if we support it.
1992   for (unsigned i = 0; i < peer_len;) {
1993     for (unsigned j = 0; j < supported_len;) {
1994       if (peer[i] == supported[j] &&
1995           OPENSSL_memcmp(&peer[i + 1], &supported[j + 1], peer[i]) == 0) {
1996         // We found a match
1997         result = &peer[i];
1998         status = OPENSSL_NPN_NEGOTIATED;
1999         goto found;
2000       }
2001       j += supported[j];
2002       j++;
2003     }
2004     i += peer[i];
2005     i++;
2006   }
2007
2008   // There's no overlap between our protocols and the peer's list.
2009   result = supported;
2010   status = OPENSSL_NPN_NO_OVERLAP;
2011
2012 found:
2013   *out = (uint8_t *)result + 1;
2014   *out_len = result[0];
2015   return status;
2016 }
2017
2018 void SSL_get0_next_proto_negotiated(const SSL *ssl, const uint8_t **out_data,
2019                                     unsigned *out_len) {
2020   *out_data = ssl->s3->next_proto_negotiated.data();
2021   *out_len = ssl->s3->next_proto_negotiated.size();
2022 }
2023
2024 void SSL_CTX_set_next_protos_advertised_cb(
2025     SSL_CTX *ctx,
2026     int (*cb)(SSL *ssl, const uint8_t **out, unsigned *out_len, void *arg),
2027     void *arg) {
2028   ctx->next_protos_advertised_cb = cb;
2029   ctx->next_protos_advertised_cb_arg = arg;
2030 }
2031
2032 void SSL_CTX_set_next_proto_select_cb(
2033     SSL_CTX *ctx, int (*cb)(SSL *ssl, uint8_t **out, uint8_t *out_len,
2034                             const uint8_t *in, unsigned in_len, void *arg),
2035     void *arg) {
2036   ctx->next_proto_select_cb = cb;
2037   ctx->next_proto_select_cb_arg = arg;
2038 }
2039
2040 int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const uint8_t *protos,
2041                             unsigned protos_len) {
2042   OPENSSL_free(ctx->alpn_client_proto_list);
2043   ctx->alpn_client_proto_list = (uint8_t *)BUF_memdup(protos, protos_len);
2044   if (!ctx->alpn_client_proto_list) {
2045     return 1;
2046   }
2047   ctx->alpn_client_proto_list_len = protos_len;
2048
2049   return 0;
2050 }
2051
2052 int SSL_set_alpn_protos(SSL *ssl, const uint8_t *protos, unsigned protos_len) {
2053   OPENSSL_free(ssl->alpn_client_proto_list);
2054   ssl->alpn_client_proto_list = (uint8_t *)BUF_memdup(protos, protos_len);
2055   if (!ssl->alpn_client_proto_list) {
2056     return 1;
2057   }
2058   ssl->alpn_client_proto_list_len = protos_len;
2059
2060   return 0;
2061 }
2062
2063 void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
2064                                 int (*cb)(SSL *ssl, const uint8_t **out,
2065                                           uint8_t *out_len, const uint8_t *in,
2066                                           unsigned in_len, void *arg),
2067                                 void *arg) {
2068   ctx->alpn_select_cb = cb;
2069   ctx->alpn_select_cb_arg = arg;
2070 }
2071
2072 void SSL_get0_alpn_selected(const SSL *ssl, const uint8_t **out_data,
2073                             unsigned *out_len) {
2074   if (SSL_in_early_data(ssl) && !ssl->server) {
2075     *out_data = ssl->s3->hs->early_session->early_alpn;
2076     *out_len = ssl->s3->hs->early_session->early_alpn_len;
2077   } else {
2078     *out_data = ssl->s3->alpn_selected.data();
2079     *out_len = ssl->s3->alpn_selected.size();
2080   }
2081 }
2082
2083 void SSL_CTX_set_allow_unknown_alpn_protos(SSL_CTX *ctx, int enabled) {
2084   ctx->allow_unknown_alpn_protos = !!enabled;
2085 }
2086
2087 void SSL_CTX_set_tls_channel_id_enabled(SSL_CTX *ctx, int enabled) {
2088   ctx->tlsext_channel_id_enabled = !!enabled;
2089 }
2090
2091 int SSL_CTX_enable_tls_channel_id(SSL_CTX *ctx) {
2092   SSL_CTX_set_tls_channel_id_enabled(ctx, 1);
2093   return 1;
2094 }
2095
2096 void SSL_set_tls_channel_id_enabled(SSL *ssl, int enabled) {
2097   ssl->tlsext_channel_id_enabled = !!enabled;
2098 }
2099
2100 int SSL_enable_tls_channel_id(SSL *ssl) {
2101   SSL_set_tls_channel_id_enabled(ssl, 1);
2102   return 1;
2103 }
2104
2105 static int is_p256_key(EVP_PKEY *private_key) {
2106   const EC_KEY *ec_key = EVP_PKEY_get0_EC_KEY(private_key);
2107   return ec_key != NULL &&
2108          EC_GROUP_get_curve_name(EC_KEY_get0_group(ec_key)) ==
2109              NID_X9_62_prime256v1;
2110 }
2111
2112 int SSL_CTX_set1_tls_channel_id(SSL_CTX *ctx, EVP_PKEY *private_key) {
2113   if (!is_p256_key(private_key)) {
2114     OPENSSL_PUT_ERROR(SSL, SSL_R_CHANNEL_ID_NOT_P256);
2115     return 0;
2116   }
2117
2118   EVP_PKEY_free(ctx->tlsext_channel_id_private);
2119   EVP_PKEY_up_ref(private_key);
2120   ctx->tlsext_channel_id_private = private_key;
2121   ctx->tlsext_channel_id_enabled = true;
2122
2123   return 1;
2124 }
2125
2126 int SSL_set1_tls_channel_id(SSL *ssl, EVP_PKEY *private_key) {
2127   if (!is_p256_key(private_key)) {
2128     OPENSSL_PUT_ERROR(SSL, SSL_R_CHANNEL_ID_NOT_P256);
2129     return 0;
2130   }
2131
2132   EVP_PKEY_free(ssl->tlsext_channel_id_private);
2133   EVP_PKEY_up_ref(private_key);
2134   ssl->tlsext_channel_id_private = private_key;
2135   ssl->tlsext_channel_id_enabled = true;
2136
2137   return 1;
2138 }
2139
2140 size_t SSL_get_tls_channel_id(SSL *ssl, uint8_t *out, size_t max_out) {
2141   if (!ssl->s3->tlsext_channel_id_valid) {
2142     return 0;
2143   }
2144   OPENSSL_memcpy(out, ssl->s3->tlsext_channel_id,
2145                  (max_out < 64) ? max_out : 64);
2146   return 64;
2147 }
2148
2149 int SSL_set_token_binding_params(SSL *ssl, const uint8_t *params, size_t len) {
2150   if (len > 256) {
2151     OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
2152     return 0;
2153   }
2154   OPENSSL_free(ssl->token_binding_params);
2155   ssl->token_binding_params = (uint8_t *)BUF_memdup(params, len);
2156   if (!ssl->token_binding_params) {
2157     return 0;
2158   }
2159   ssl->token_binding_params_len = len;
2160   return 1;
2161 }
2162
2163 int SSL_is_token_binding_negotiated(const SSL *ssl) {
2164   return ssl->token_binding_negotiated;
2165 }
2166
2167 uint8_t SSL_get_negotiated_token_binding_param(const SSL *ssl) {
2168   return ssl->negotiated_token_binding_param;
2169 }
2170
2171 size_t SSL_get0_certificate_types(SSL *ssl, const uint8_t **out_types) {
2172   if (ssl->server || ssl->s3->hs == NULL) {
2173     *out_types = NULL;
2174     return 0;
2175   }
2176   *out_types = ssl->s3->hs->certificate_types.data();
2177   return ssl->s3->hs->certificate_types.size();
2178 }
2179
2180 EVP_PKEY *SSL_get_privatekey(const SSL *ssl) {
2181   if (ssl->cert != NULL) {
2182     return ssl->cert->privatekey;
2183   }
2184
2185   return NULL;
2186 }
2187
2188 EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx) {
2189   if (ctx->cert != NULL) {
2190     return ctx->cert->privatekey;
2191   }
2192
2193   return NULL;
2194 }
2195
2196 const SSL_CIPHER *SSL_get_current_cipher(const SSL *ssl) {
2197   return ssl->s3->aead_write_ctx->cipher();
2198 }
2199
2200 int SSL_session_reused(const SSL *ssl) {
2201   return ssl->s3->session_reused || SSL_in_early_data(ssl);
2202 }
2203
2204 const COMP_METHOD *SSL_get_current_compression(SSL *ssl) { return NULL; }
2205
2206 const COMP_METHOD *SSL_get_current_expansion(SSL *ssl) { return NULL; }
2207
2208 int *SSL_get_server_tmp_key(SSL *ssl, EVP_PKEY **out_key) { return 0; }
2209
2210 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode) {
2211   ctx->quiet_shutdown = (mode != 0);
2212 }
2213
2214 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx) {
2215   return ctx->quiet_shutdown;
2216 }
2217
2218 void SSL_set_quiet_shutdown(SSL *ssl, int mode) {
2219   ssl->quiet_shutdown = (mode != 0);
2220 }
2221
2222 int SSL_get_quiet_shutdown(const SSL *ssl) { return ssl->quiet_shutdown; }
2223
2224 void SSL_set_shutdown(SSL *ssl, int mode) {
2225   // It is an error to clear any bits that have already been set. (We can't try
2226   // to get a second close_notify or send two.)
2227   assert((SSL_get_shutdown(ssl) & mode) == SSL_get_shutdown(ssl));
2228
2229   if (mode & SSL_RECEIVED_SHUTDOWN &&
2230       ssl->s3->read_shutdown == ssl_shutdown_none) {
2231     ssl->s3->read_shutdown = ssl_shutdown_close_notify;
2232   }
2233
2234   if (mode & SSL_SENT_SHUTDOWN &&
2235       ssl->s3->write_shutdown == ssl_shutdown_none) {
2236     ssl->s3->write_shutdown = ssl_shutdown_close_notify;
2237   }
2238 }
2239
2240 int SSL_get_shutdown(const SSL *ssl) {
2241   int ret = 0;
2242   if (ssl->s3->read_shutdown != ssl_shutdown_none) {
2243     // Historically, OpenSSL set |SSL_RECEIVED_SHUTDOWN| on both close_notify
2244     // and fatal alert.
2245     ret |= SSL_RECEIVED_SHUTDOWN;
2246   }
2247   if (ssl->s3->write_shutdown == ssl_shutdown_close_notify) {
2248     // Historically, OpenSSL set |SSL_SENT_SHUTDOWN| on only close_notify.
2249     ret |= SSL_SENT_SHUTDOWN;
2250   }
2251   return ret;
2252 }
2253
2254 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl) { return ssl->ctx; }
2255
2256 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx) {
2257   if (ssl->ctx == ctx) {
2258     return ssl->ctx;
2259   }
2260
2261   // One cannot change the X.509 callbacks during a connection.
2262   if (ssl->ctx->x509_method != ctx->x509_method) {
2263     assert(0);
2264     return NULL;
2265   }
2266
2267   if (ctx == NULL) {
2268     ctx = ssl->session_ctx;
2269   }
2270
2271   ssl_cert_free(ssl->cert);
2272   ssl->cert = ssl_cert_dup(ctx->cert);
2273
2274   SSL_CTX_up_ref(ctx);
2275   SSL_CTX_free(ssl->ctx);
2276   ssl->ctx = ctx;
2277
2278   return ssl->ctx;
2279 }
2280
2281 void SSL_set_info_callback(SSL *ssl,
2282                            void (*cb)(const SSL *ssl, int type, int value)) {
2283   ssl->info_callback = cb;
2284 }
2285
2286 void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl, int type,
2287                                               int value) {
2288   return ssl->info_callback;
2289 }
2290
2291 int SSL_state(const SSL *ssl) {
2292   return SSL_in_init(ssl) ? SSL_ST_INIT : SSL_ST_OK;
2293 }
2294
2295 void SSL_set_state(SSL *ssl, int state) { }
2296
2297 char *SSL_get_shared_ciphers(const SSL *ssl, char *buf, int len) {
2298   if (len <= 0) {
2299     return NULL;
2300   }
2301   buf[0] = '\0';
2302   return buf;
2303 }
2304
2305 int SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_unused *unused,
2306                          CRYPTO_EX_dup *dup_unused, CRYPTO_EX_free *free_func) {
2307   int index;
2308   if (!CRYPTO_get_ex_new_index(&g_ex_data_class_ssl, &index, argl, argp,
2309                                free_func)) {
2310     return -1;
2311   }
2312   return index;
2313 }
2314
2315 int SSL_set_ex_data(SSL *ssl, int idx, void *data) {
2316   return CRYPTO_set_ex_data(&ssl->ex_data, idx, data);
2317 }
2318
2319 void *SSL_get_ex_data(const SSL *ssl, int idx) {
2320   return CRYPTO_get_ex_data(&ssl->ex_data, idx);
2321 }
2322
2323 int SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_unused *unused,
2324                              CRYPTO_EX_dup *dup_unused,
2325                              CRYPTO_EX_free *free_func) {
2326   int index;
2327   if (!CRYPTO_get_ex_new_index(&g_ex_data_class_ssl_ctx, &index, argl, argp,
2328                                free_func)) {
2329     return -1;
2330   }
2331   return index;
2332 }
2333
2334 int SSL_CTX_set_ex_data(SSL_CTX *ctx, int idx, void *data) {
2335   return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
2336 }
2337
2338 void *SSL_CTX_get_ex_data(const SSL_CTX *ctx, int idx) {
2339   return CRYPTO_get_ex_data(&ctx->ex_data, idx);
2340 }
2341
2342 int SSL_want(const SSL *ssl) { return ssl->s3->rwstate; }
2343
2344 void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,
2345                                   RSA *(*cb)(SSL *ssl, int is_export,
2346                                              int keylength)) {}
2347
2348 void SSL_set_tmp_rsa_callback(SSL *ssl, RSA *(*cb)(SSL *ssl, int is_export,
2349                                                    int keylength)) {}
2350
2351 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
2352                                  DH *(*cb)(SSL *ssl, int is_export,
2353                                            int keylength)) {}
2354
2355 void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*cb)(SSL *ssl, int is_export,
2356                                                  int keylength)) {}
2357
2358 static int use_psk_identity_hint(char **out, const char *identity_hint) {
2359   if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
2360     OPENSSL_PUT_ERROR(SSL, SSL_R_DATA_LENGTH_TOO_LONG);
2361     return 0;
2362   }
2363
2364   // Clear currently configured hint, if any.
2365   OPENSSL_free(*out);
2366   *out = NULL;
2367
2368   // Treat the empty hint as not supplying one. Plain PSK makes it possible to
2369   // send either no hint (omit ServerKeyExchange) or an empty hint, while
2370   // ECDHE_PSK can only spell empty hint. Having different capabilities is odd,
2371   // so we interpret empty and missing as identical.
2372   if (identity_hint != NULL && identity_hint[0] != '\0') {
2373     *out = BUF_strdup(identity_hint);
2374     if (*out == NULL) {
2375       return 0;
2376     }
2377   }
2378
2379   return 1;
2380 }
2381
2382 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint) {
2383   return use_psk_identity_hint(&ctx->psk_identity_hint, identity_hint);
2384 }
2385
2386 int SSL_use_psk_identity_hint(SSL *ssl, const char *identity_hint) {
2387   return use_psk_identity_hint(&ssl->psk_identity_hint, identity_hint);
2388 }
2389
2390 const char *SSL_get_psk_identity_hint(const SSL *ssl) {
2391   if (ssl == NULL) {
2392     return NULL;
2393   }
2394   return ssl->psk_identity_hint;
2395 }
2396
2397 const char *SSL_get_psk_identity(const SSL *ssl) {
2398   if (ssl == NULL) {
2399     return NULL;
2400   }
2401   SSL_SESSION *session = SSL_get_session(ssl);
2402   if (session == NULL) {
2403     return NULL;
2404   }
2405   return session->psk_identity;
2406 }
2407
2408 void SSL_set_psk_client_callback(
2409     SSL *ssl, unsigned (*cb)(SSL *ssl, const char *hint, char *identity,
2410                              unsigned max_identity_len, uint8_t *psk,
2411                              unsigned max_psk_len)) {
2412   ssl->psk_client_callback = cb;
2413 }
2414
2415 void SSL_CTX_set_psk_client_callback(
2416     SSL_CTX *ctx, unsigned (*cb)(SSL *ssl, const char *hint, char *identity,
2417                                  unsigned max_identity_len, uint8_t *psk,
2418                                  unsigned max_psk_len)) {
2419   ctx->psk_client_callback = cb;
2420 }
2421
2422 void SSL_set_psk_server_callback(
2423     SSL *ssl, unsigned (*cb)(SSL *ssl, const char *identity, uint8_t *psk,
2424                              unsigned max_psk_len)) {
2425   ssl->psk_server_callback = cb;
2426 }
2427
2428 void SSL_CTX_set_psk_server_callback(
2429     SSL_CTX *ctx, unsigned (*cb)(SSL *ssl, const char *identity,
2430                                  uint8_t *psk, unsigned max_psk_len)) {
2431   ctx->psk_server_callback = cb;
2432 }
2433
2434 int SSL_set_dummy_pq_padding_size(SSL *ssl, size_t num_bytes) {
2435   if (num_bytes > 0xffff) {
2436     return 0;
2437   }
2438
2439   ssl->dummy_pq_padding_len = num_bytes;
2440   return 1;
2441 }
2442
2443 int SSL_dummy_pq_padding_used(SSL *ssl) {
2444   if (ssl->server) {
2445     return 0;
2446   }
2447
2448   return ssl->did_dummy_pq_padding;
2449 }
2450
2451 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
2452                               void (*cb)(int write_p, int version,
2453                                          int content_type, const void *buf,
2454                                          size_t len, SSL *ssl, void *arg)) {
2455   ctx->msg_callback = cb;
2456 }
2457
2458 void SSL_CTX_set_msg_callback_arg(SSL_CTX *ctx, void *arg) {
2459   ctx->msg_callback_arg = arg;
2460 }
2461
2462 void SSL_set_msg_callback(SSL *ssl,
2463                           void (*cb)(int write_p, int version, int content_type,
2464                                      const void *buf, size_t len, SSL *ssl,
2465                                      void *arg)) {
2466   ssl->msg_callback = cb;
2467 }
2468
2469 void SSL_set_msg_callback_arg(SSL *ssl, void *arg) {
2470   ssl->msg_callback_arg = arg;
2471 }
2472
2473 void SSL_CTX_set_keylog_callback(SSL_CTX *ctx,
2474                                  void (*cb)(const SSL *ssl, const char *line)) {
2475   ctx->keylog_callback = cb;
2476 }
2477
2478 void (*SSL_CTX_get_keylog_callback(const SSL_CTX *ctx))(const SSL *ssl,
2479                                                         const char *line) {
2480   return ctx->keylog_callback;
2481 }
2482
2483 void SSL_CTX_set_current_time_cb(SSL_CTX *ctx,
2484                                  void (*cb)(const SSL *ssl,
2485                                             struct timeval *out_clock)) {
2486   ctx->current_time_cb = cb;
2487 }
2488
2489 int SSL_is_init_finished(const SSL *ssl) {
2490   return !SSL_in_init(ssl);
2491 }
2492
2493 int SSL_in_init(const SSL *ssl) {
2494   // This returns false once all the handshake state has been finalized, to
2495   // allow callbacks and getters based on SSL_in_init to return the correct
2496   // values.
2497   SSL_HANDSHAKE *hs = ssl->s3->hs.get();
2498   return hs != nullptr && !hs->handshake_finalized;
2499 }
2500
2501 int SSL_in_false_start(const SSL *ssl) {
2502   if (ssl->s3->hs == NULL) {
2503     return 0;
2504   }
2505   return ssl->s3->hs->in_false_start;
2506 }
2507
2508 int SSL_cutthrough_complete(const SSL *ssl) {
2509   return SSL_in_false_start(ssl);
2510 }
2511
2512 void SSL_get_structure_sizes(size_t *ssl_size, size_t *ssl_ctx_size,
2513                              size_t *ssl_session_size) {
2514   *ssl_size = sizeof(SSL);
2515   *ssl_ctx_size = sizeof(SSL_CTX);
2516   *ssl_session_size = sizeof(SSL_SESSION);
2517 }
2518
2519 int SSL_is_server(const SSL *ssl) { return ssl->server; }
2520
2521 int SSL_is_dtls(const SSL *ssl) { return ssl->method->is_dtls; }
2522
2523 void SSL_CTX_set_select_certificate_cb(
2524     SSL_CTX *ctx,
2525     enum ssl_select_cert_result_t (*cb)(const SSL_CLIENT_HELLO *)) {
2526   ctx->select_certificate_cb = cb;
2527 }
2528
2529 void SSL_CTX_set_dos_protection_cb(SSL_CTX *ctx,
2530                                    int (*cb)(const SSL_CLIENT_HELLO *)) {
2531   ctx->dos_protection_cb = cb;
2532 }
2533
2534 void SSL_set_renegotiate_mode(SSL *ssl, enum ssl_renegotiate_mode_t mode) {
2535   ssl->renegotiate_mode = mode;
2536 }
2537
2538 int SSL_get_ivs(const SSL *ssl, const uint8_t **out_read_iv,
2539                 const uint8_t **out_write_iv, size_t *out_iv_len) {
2540   size_t write_iv_len;
2541   if (!ssl->s3->aead_read_ctx->GetIV(out_read_iv, out_iv_len) ||
2542       !ssl->s3->aead_write_ctx->GetIV(out_write_iv, &write_iv_len) ||
2543       *out_iv_len != write_iv_len) {
2544     return 0;
2545   }
2546
2547   return 1;
2548 }
2549
2550 static uint64_t be_to_u64(const uint8_t in[8]) {
2551   return (((uint64_t)in[0]) << 56) | (((uint64_t)in[1]) << 48) |
2552          (((uint64_t)in[2]) << 40) | (((uint64_t)in[3]) << 32) |
2553          (((uint64_t)in[4]) << 24) | (((uint64_t)in[5]) << 16) |
2554          (((uint64_t)in[6]) << 8) | ((uint64_t)in[7]);
2555 }
2556
2557 uint64_t SSL_get_read_sequence(const SSL *ssl) {
2558   // TODO(davidben): Internally represent sequence numbers as uint64_t.
2559   if (SSL_is_dtls(ssl)) {
2560     // max_seq_num already includes the epoch.
2561     assert(ssl->d1->r_epoch == (ssl->d1->bitmap.max_seq_num >> 48));
2562     return ssl->d1->bitmap.max_seq_num;
2563   }
2564   return be_to_u64(ssl->s3->read_sequence);
2565 }
2566
2567 uint64_t SSL_get_write_sequence(const SSL *ssl) {
2568   uint64_t ret = be_to_u64(ssl->s3->write_sequence);
2569   if (SSL_is_dtls(ssl)) {
2570     assert((ret >> 48) == 0);
2571     ret |= ((uint64_t)ssl->d1->w_epoch) << 48;
2572   }
2573   return ret;
2574 }
2575
2576 uint16_t SSL_get_peer_signature_algorithm(const SSL *ssl) {
2577   // TODO(davidben): This checks the wrong session if there is a renegotiation
2578   // in progress.
2579   SSL_SESSION *session = SSL_get_session(ssl);
2580   if (session == NULL) {
2581     return 0;
2582   }
2583
2584   return session->peer_signature_algorithm;
2585 }
2586
2587 size_t SSL_get_client_random(const SSL *ssl, uint8_t *out, size_t max_out) {
2588   if (max_out == 0) {
2589     return sizeof(ssl->s3->client_random);
2590   }
2591   if (max_out > sizeof(ssl->s3->client_random)) {
2592     max_out = sizeof(ssl->s3->client_random);
2593   }
2594   OPENSSL_memcpy(out, ssl->s3->client_random, max_out);
2595   return max_out;
2596 }
2597
2598 size_t SSL_get_server_random(const SSL *ssl, uint8_t *out, size_t max_out) {
2599   if (max_out == 0) {
2600     return sizeof(ssl->s3->server_random);
2601   }
2602   if (max_out > sizeof(ssl->s3->server_random)) {
2603     max_out = sizeof(ssl->s3->server_random);
2604   }
2605   OPENSSL_memcpy(out, ssl->s3->server_random, max_out);
2606   return max_out;
2607 }
2608
2609 const SSL_CIPHER *SSL_get_pending_cipher(const SSL *ssl) {
2610   SSL_HANDSHAKE *hs = ssl->s3->hs.get();
2611   if (hs == NULL) {
2612     return NULL;
2613   }
2614   return hs->new_cipher;
2615 }
2616
2617 void SSL_set_retain_only_sha256_of_client_certs(SSL *ssl, int enabled) {
2618   ssl->retain_only_sha256_of_client_certs = !!enabled;
2619 }
2620
2621 void SSL_CTX_set_retain_only_sha256_of_client_certs(SSL_CTX *ctx, int enabled) {
2622   ctx->retain_only_sha256_of_client_certs = !!enabled;
2623 }
2624
2625 void SSL_CTX_set_grease_enabled(SSL_CTX *ctx, int enabled) {
2626   ctx->grease_enabled = !!enabled;
2627 }
2628
2629 int32_t SSL_get_ticket_age_skew(const SSL *ssl) {
2630   return ssl->s3->ticket_age_skew;
2631 }
2632
2633 void SSL_CTX_set_false_start_allowed_without_alpn(SSL_CTX *ctx, int allowed) {
2634   ctx->false_start_allowed_without_alpn = !!allowed;
2635 }
2636
2637 int SSL_is_draft_downgrade(const SSL *ssl) { return ssl->s3->draft_downgrade; }
2638
2639 int SSL_clear(SSL *ssl) {
2640   // In OpenSSL, reusing a client |SSL| with |SSL_clear| causes the previously
2641   // established session to be offered the next time around. wpa_supplicant
2642   // depends on this behavior, so emulate it.
2643   UniquePtr<SSL_SESSION> session;
2644   if (!ssl->server && ssl->s3->established_session != NULL) {
2645     session.reset(ssl->s3->established_session.get());
2646     SSL_SESSION_up_ref(session.get());
2647   }
2648
2649   // The ssl->d1->mtu is simultaneously configuration (preserved across
2650   // clear) and connection-specific state (gets reset).
2651   //
2652   // TODO(davidben): Avoid this.
2653   unsigned mtu = 0;
2654   if (ssl->d1 != NULL) {
2655     mtu = ssl->d1->mtu;
2656   }
2657
2658   ssl->method->ssl_free(ssl);
2659   if (!ssl->method->ssl_new(ssl)) {
2660     return 0;
2661   }
2662
2663   if (SSL_is_dtls(ssl) && (SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
2664     ssl->d1->mtu = mtu;
2665   }
2666
2667   if (session != nullptr) {
2668     SSL_set_session(ssl, session.get());
2669   }
2670
2671   return 1;
2672 }
2673
2674 int SSL_CTX_sess_connect(const SSL_CTX *ctx) { return 0; }
2675 int SSL_CTX_sess_connect_good(const SSL_CTX *ctx) { return 0; }
2676 int SSL_CTX_sess_connect_renegotiate(const SSL_CTX *ctx) { return 0; }
2677 int SSL_CTX_sess_accept(const SSL_CTX *ctx) { return 0; }
2678 int SSL_CTX_sess_accept_renegotiate(const SSL_CTX *ctx) { return 0; }
2679 int SSL_CTX_sess_accept_good(const SSL_CTX *ctx) { return 0; }
2680 int SSL_CTX_sess_hits(const SSL_CTX *ctx) { return 0; }
2681 int SSL_CTX_sess_cb_hits(const SSL_CTX *ctx) { return 0; }
2682 int SSL_CTX_sess_misses(const SSL_CTX *ctx) { return 0; }
2683 int SSL_CTX_sess_timeouts(const SSL_CTX *ctx) { return 0; }
2684 int SSL_CTX_sess_cache_full(const SSL_CTX *ctx) { return 0; }
2685
2686 int SSL_num_renegotiations(const SSL *ssl) {
2687   return SSL_total_renegotiations(ssl);
2688 }
2689
2690 int SSL_CTX_need_tmp_RSA(const SSL_CTX *ctx) { return 0; }
2691 int SSL_need_tmp_RSA(const SSL *ssl) { return 0; }
2692 int SSL_CTX_set_tmp_rsa(SSL_CTX *ctx, const RSA *rsa) { return 1; }
2693 int SSL_set_tmp_rsa(SSL *ssl, const RSA *rsa) { return 1; }
2694 void ERR_load_SSL_strings(void) {}
2695 void SSL_load_error_strings(void) {}
2696 int SSL_cache_hit(SSL *ssl) { return SSL_session_reused(ssl); }
2697
2698 int SSL_CTX_set_tmp_ecdh(SSL_CTX *ctx, const EC_KEY *ec_key) {
2699   if (ec_key == NULL || EC_KEY_get0_group(ec_key) == NULL) {
2700     OPENSSL_PUT_ERROR(SSL, ERR_R_PASSED_NULL_PARAMETER);
2701     return 0;
2702   }
2703   int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec_key));
2704   return SSL_CTX_set1_curves(ctx, &nid, 1);
2705 }
2706
2707 int SSL_set_tmp_ecdh(SSL *ssl, const EC_KEY *ec_key) {
2708   if (ec_key == NULL || EC_KEY_get0_group(ec_key) == NULL) {
2709     OPENSSL_PUT_ERROR(SSL, ERR_R_PASSED_NULL_PARAMETER);
2710     return 0;
2711   }
2712   int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec_key));
2713   return SSL_set1_curves(ssl, &nid, 1);
2714 }
2715
2716 void SSL_CTX_set_ticket_aead_method(SSL_CTX *ctx,
2717                                     const SSL_TICKET_AEAD_METHOD *aead_method) {
2718   ctx->ticket_aead_method = aead_method;
2719 }