grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/ssl/ssl_buffer.cc

@@ -64,13 +64,13 @@ bool SSLBuffer::EnsureCap(size_t header_len, size_t new_cap) {
     new_buf = inline_buf_;
     new_offset = 0;
   } else {
-    // Add up to |SSL3_ALIGN_PAYLOAD| - 1 bytes of slack for alignment.
+    // Add up to `SSL3_ALIGN_PAYLOAD` - 1 bytes of slack for alignment.
     //
     // Since this buffer gets allocated quite frequently and doesn't contain any
-    // sensitive data, we allocate with malloc rather than |OPENSSL_malloc| and
+    // sensitive data, we allocate with malloc rather than `OPENSSL_malloc` and
     // avoid zeroing on free.
     new_buf = (uint8_t *)malloc(new_cap + SSL3_ALIGN_PAYLOAD - 1);
-    if (new_buf == NULL) {
+    if (new_buf == nullptr) {
       OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
       return false;
     }
@@ -120,13 +120,13 @@ static int dtls_read_buffer_next_packet(SSL *ssl) {
   SSLBuffer *buf = &ssl->s3->read_buffer;
 
   if (!buf->empty()) {
-    // It is an error to call |dtls_read_buffer_extend| when the read buffer is
+    // It is an error to call `dtls_read_buffer_extend` when the read buffer is
     // not empty.
     OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
     return -1;
   }
 
-  // Read a single packet from |ssl->rbio|. |buf->cap()| must fit in an int.
+  // Read a single packet from `ssl->rbio`. `buf->cap()` must fit in an int.
   int ret =
       BIO_read(ssl->rbio.get(), buf->data(), static_cast<int>(buf->cap()));
   if (ret <= 0) {
@@ -147,7 +147,7 @@ static int tls_read_buffer_extend_to(SSL *ssl, size_t len) {
 
   // Read until the target length is reached.
   while (buf->size() < len) {
-    // The amount of data to read is bounded by |buf->cap|, which must fit in an
+    // The amount of data to read is bounded by `buf->cap`, which must fit in an
     // int.
     int ret = BIO_read(ssl->rbio.get(), buf->data() + buf->size(),
                        static_cast<int>(len - buf->size()));
@@ -162,7 +162,7 @@ static int tls_read_buffer_extend_to(SSL *ssl, size_t len) {
 }
 
 int ssl_read_buffer_extend_to(SSL *ssl, size_t len) {
-  // |ssl_read_buffer_extend_to| implicitly discards any consumed data.
+  // `ssl_read_buffer_extend_to` implicitly discards any consumed data.
   ssl->s3->read_buffer.DiscardConsumed();
 
   if (SSL_is_dtls(ssl)) {
@@ -170,11 +170,11 @@ int ssl_read_buffer_extend_to(SSL *ssl, size_t len) {
         DTLS1_RT_MAX_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH <= 0xffff,
         "DTLS read buffer is too large");
 
-    // The |len| parameter is ignored in DTLS.
+    // The `len` parameter is ignored in DTLS.
     len = DTLS1_RT_MAX_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH;
   }
 
-  // The DTLS record header can have a variable length, so the |header_len|
+  // The DTLS record header can have a variable length, so the `header_len`
   // value provided for buffer alignment only works if the header is the maximum
   // length.
   if (!ssl->s3->read_buffer.EnsureCap(DTLS1_RT_MAX_HEADER_LENGTH, len)) {
@@ -188,7 +188,7 @@ int ssl_read_buffer_extend_to(SSL *ssl, size_t len) {
 
   int ret;
   if (SSL_is_dtls(ssl)) {
-    // |len| is ignored for a datagram transport.
+    // `len` is ignored for a datagram transport.
     ret = dtls_read_buffer_next_packet(ssl);
   } else {
     ret = tls_read_buffer_extend_to(ssl, len);
@@ -257,14 +257,13 @@ static_assert(DTLS1_RT_MAX_HEADER_LENGTH + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD +
 
 static int tls_write_buffer_flush(SSL *ssl) {
   SSLBuffer *buf = &ssl->s3->write_buffer;
-
   while (!buf->empty()) {
-    int ret = BIO_write(ssl->wbio.get(), buf->data(), buf->size());
-    if (ret <= 0) {
+    size_t written;
+    if (!BIO_write_ex(ssl->wbio.get(), buf->data(), buf->size(), &written)) {
       ssl->s3->rwstate = SSL_ERROR_WANT_WRITE;
-      return ret;
+      return -1;
     }
-    buf->Consume(static_cast<size_t>(ret));
+    buf->Consume(written);
   }
   buf->Clear();
   return 1;
@@ -276,14 +275,14 @@ static int dtls_write_buffer_flush(SSL *ssl) {
     return 1;
   }
 
-  int ret = BIO_write(ssl->wbio.get(), buf->data(), buf->size());
-  if (ret <= 0) {
+  if (!BIO_write_ex(ssl->wbio.get(), buf->data(), buf->size(),
+                    /*out_written=*/nullptr)) {
     ssl->s3->rwstate = SSL_ERROR_WANT_WRITE;
     // If the write failed, drop the write buffer anyway. Datagram transports
     // can't write half a packet, so the caller is expected to retry from the
     // top.
     buf->Clear();
-    return ret;
+    return -1;
   }
   buf->Clear();
   return 1;

data/third_party/boringssl-with-bazel/ssl/ssl_cert.cc

@@ -23,20 +23,24 @@
 
 #include <openssl/bn.h>
 #include <openssl/bytestring.h>
+#include <openssl/ec.h>
 #include <openssl/ec_key.h>
 #include <openssl/err.h>
+#include <openssl/evp.h>
 #include <openssl/mem.h>
-#include <openssl/sha.h>
+#include <openssl/pool.h>
+#include <openssl/sha2.h>
 #include <openssl/x509.h>
 
 #include "../crypto/internal.h"
+#include "../crypto/mem_internal.h"
 #include "internal.h"
 
 
 BSSL_NAMESPACE_BEGIN
 
 CERT::CERT(const SSL_X509_METHOD *x509_method_arg)
-    : legacy_credential(MakeUnique<SSL_CREDENTIAL>(SSLCredentialType::kX509)),
+    : legacy_credential(MakeUnique<SSLCredential>(SSLCredentialType::kX509)),
       x509_method(x509_method_arg) {}
 
 CERT::~CERT() { x509_method->cert_free(this); }
@@ -47,17 +51,18 @@ UniquePtr<CERT> ssl_cert_dup(CERT *cert) {
     return nullptr;
   }
 
-  // TODO(crbug.com/boringssl/431): This should just be |CopyFrom|.
+  // TODO(crbug.com/boringssl/431): This should just be `CopyFrom`.
   for (const auto &cred : cert->credentials) {
     if (!ret->credentials.Push(UpRef(cred))) {
       return nullptr;
     }
   }
 
-  // |legacy_credential| is mutable, so it must be copied. We cannot simply
+  // `legacy_credential` is mutable, so it must be copied. We cannot simply
   // bump the reference count.
   ret->legacy_credential = cert->legacy_credential->Dup();
-  if (ret->legacy_credential == nullptr) {
+  if (ret->legacy_credential == nullptr ||
+      !ret->available_trust_anchors.CopyFrom(cert->available_trust_anchors)) {
     return nullptr;
   }
 
@@ -80,12 +85,12 @@ static int cert_set_chain_and_key(
     CERT *cert, CRYPTO_BUFFER *const *certs, size_t num_certs,
     EVP_PKEY *privkey, const SSL_PRIVATE_KEY_METHOD *privkey_method) {
   if (num_certs == 0 ||  //
-      (privkey == NULL && privkey_method == NULL)) {
+      (privkey == nullptr && privkey_method == nullptr)) {
     OPENSSL_PUT_ERROR(SSL, ERR_R_PASSED_NULL_PARAMETER);
     return 0;
   }
 
-  if (privkey != NULL && privkey_method != NULL) {
+  if (privkey != nullptr && privkey_method != nullptr) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_CANNOT_HAVE_BOTH_PRIVKEY_AND_METHOD);
     return 0;
   }
@@ -162,7 +167,7 @@ bool ssl_parse_cert_chain(uint8_t *out_alert,
       }
 
       // Retain the hash of the leaf certificate if requested.
-      if (out_leaf_sha256 != NULL) {
+      if (out_leaf_sha256 != nullptr) {
         SHA256(CBS_data(&certificate), CBS_len(&certificate), out_leaf_sha256);
       }
     }
@@ -181,8 +186,42 @@ bool ssl_parse_cert_chain(uint8_t *out_alert,
   return true;
 }
 
-// ssl_cert_skip_to_spki parses a DER-encoded, X.509 certificate from |in| and
-// positions |*out_tbs_cert| to cover the TBSCertificate, starting at the
+bool ssl_parse_rpk_cert(uint8_t *out_alert,
+                        UniquePtr<EVP_PKEY> *out_raw_public_key,
+                        UniquePtr<EVP_PKEY> *out_pubkey,
+                        uint8_t *out_rpk_sha256, CBS *cbs) {
+  out_raw_public_key->reset();
+  out_pubkey->reset();
+  CBS spki;
+  if (!CBS_get_u24_length_prefixed(cbs, &spki) ||  //
+      CBS_len(cbs) != 0) {
+    OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_RAW_PUBLIC_KEY);
+    *out_alert = SSL_AD_DECODE_ERROR;
+    return false;
+  }
+  // The TLS 1.2 Certificate format for Raw Public Keys in RFC 7250 does not
+  // permit the peer to decline to send a Certificate, which is possible to do
+  // with X.509 Certificates, but we allow a client to do this by sending an
+  // empty RPK SPKI.
+  if (CBS_len(&spki) == 0) {
+    return true;
+  }
+  *out_raw_public_key = ssl_parse_peer_subject_public_key_info(spki);
+  if (*out_raw_public_key == nullptr) {
+    OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_RAW_PUBLIC_KEY);
+    *out_alert = SSL_AD_DECODE_ERROR;
+    return false;
+  }
+  // Retain the hash of the leaf certificate if requested.
+  if (out_rpk_sha256 != nullptr) {
+    SHA256(CBS_data(&spki), CBS_len(&spki), out_rpk_sha256);
+  }
+  *out_pubkey = UpRef(*out_raw_public_key);
+  return true;
+}
+
+// ssl_cert_skip_to_spki parses a DER-encoded, X.509 certificate from `in` and
+// positions `*out_tbs_cert` to cover the TBSCertificate, starting at the
 // subjectPublicKeyInfo.
 static bool ssl_cert_skip_to_spki(const CBS *in, CBS *out_tbs_cert) {
   /* From RFC 5280, section 4.1
@@ -208,19 +247,19 @@ static bool ssl_cert_skip_to_spki(const CBS *in, CBS *out_tbs_cert) {
       !CBS_get_asn1(&toplevel, out_tbs_cert, CBS_ASN1_SEQUENCE) ||  //
       // version
       !CBS_get_optional_asn1(
-          out_tbs_cert, NULL, NULL,
+          out_tbs_cert, nullptr, nullptr,
           CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 0) ||  //
 
       // serialNumber
-      !CBS_get_asn1(out_tbs_cert, NULL, CBS_ASN1_INTEGER) ||
+      !CBS_get_asn1(out_tbs_cert, nullptr, CBS_ASN1_INTEGER) ||
       // signature algorithm
-      !CBS_get_asn1(out_tbs_cert, NULL, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1(out_tbs_cert, nullptr, CBS_ASN1_SEQUENCE) ||
       // issuer
-      !CBS_get_asn1(out_tbs_cert, NULL, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1(out_tbs_cert, nullptr, CBS_ASN1_SEQUENCE) ||
       // validity
-      !CBS_get_asn1(out_tbs_cert, NULL, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1(out_tbs_cert, nullptr, CBS_ASN1_SEQUENCE) ||
       // subject
-      !CBS_get_asn1(out_tbs_cert, NULL, CBS_ASN1_SEQUENCE)) {
+      !CBS_get_asn1(out_tbs_cert, nullptr, CBS_ASN1_SEQUENCE)) {
     return false;
   }
 
@@ -237,12 +276,12 @@ bool ssl_cert_extract_issuer(const CBS *in, CBS *out_dn) {
       !CBS_get_asn1(&toplevel, &cert, CBS_ASN1_SEQUENCE) ||  //
       // version
       !CBS_get_optional_asn1(
-          &cert, NULL, NULL,
+          &cert, nullptr, nullptr,
           CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 0) ||  //
       // serialNumber
-      !CBS_get_asn1(&cert, NULL, CBS_ASN1_INTEGER) ||  //
+      !CBS_get_asn1(&cert, nullptr, CBS_ASN1_INTEGER) ||  //
       // signature algorithm
-      !CBS_get_asn1(&cert, NULL, CBS_ASN1_SEQUENCE) ||  //
+      !CBS_get_asn1(&cert, nullptr, CBS_ASN1_SEQUENCE) ||  //
       // issuer
       !CBS_get_asn1_element(&cert, out_dn, CBS_ASN1_SEQUENCE)) {
     return false;
@@ -260,13 +299,14 @@ bool ssl_cert_matches_issuer(const CBS *in, const CBS *dn) {
 }
 
 UniquePtr<EVP_PKEY> ssl_cert_parse_pubkey(const CBS *in) {
-  CBS buf = *in, tbs_cert;
-  if (!ssl_cert_skip_to_spki(&buf, &tbs_cert)) {
+  CBS buf = *in, tbs_cert, spki;
+  if (!ssl_cert_skip_to_spki(&buf, &tbs_cert) ||
+      !CBS_get_asn1_element(&tbs_cert, &spki, CBS_ASN1_SEQUENCE)) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_CANNOT_PARSE_LEAF_CERT);
     return nullptr;
   }
 
-  return UniquePtr<EVP_PKEY>(EVP_parse_public_key(&tbs_cert));
+  return ssl_parse_peer_subject_public_key_info(spki);
 }
 
 bool ssl_compare_public_and_private_key(const EVP_PKEY *pubkey,
@@ -277,22 +317,16 @@ bool ssl_compare_public_and_private_key(const EVP_PKEY *pubkey,
     return true;
   }
 
-  switch (EVP_PKEY_cmp(pubkey, privkey)) {
-    case 1:
-      return true;
-    case 0:
-      OPENSSL_PUT_ERROR(X509, X509_R_KEY_VALUES_MISMATCH);
-      return false;
-    case -1:
+  if (EVP_PKEY_eq(pubkey, privkey) != 1) {
+    if (EVP_PKEY_id(pubkey) != EVP_PKEY_id(privkey)) {
       OPENSSL_PUT_ERROR(X509, X509_R_KEY_TYPE_MISMATCH);
-      return false;
-    case -2:
-      OPENSSL_PUT_ERROR(X509, X509_R_UNKNOWN_KEY_TYPE);
-      return false;
+    } else {
+      OPENSSL_PUT_ERROR(X509, X509_R_KEY_VALUES_MISMATCH);
+    }
+    return false;
   }
 
-  assert(0);
-  return false;
+  return true;
 }
 
 bool ssl_cert_check_key_usage(const CBS *in, enum ssl_key_usage_t bit) {
@@ -302,12 +336,12 @@ bool ssl_cert_check_key_usage(const CBS *in, enum ssl_key_usage_t bit) {
   int has_extensions;
   if (!ssl_cert_skip_to_spki(&buf, &tbs_cert) ||
       // subjectPublicKeyInfo
-      !CBS_get_asn1(&tbs_cert, NULL, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1(&tbs_cert, nullptr, CBS_ASN1_SEQUENCE) ||
       // issuerUniqueID
-      !CBS_get_optional_asn1(&tbs_cert, NULL, NULL,
+      !CBS_get_optional_asn1(&tbs_cert, nullptr, nullptr,
                              CBS_ASN1_CONTEXT_SPECIFIC | 1) ||
       // subjectUniqueID
-      !CBS_get_optional_asn1(&tbs_cert, NULL, NULL,
+      !CBS_get_optional_asn1(&tbs_cert, nullptr, nullptr,
                              CBS_ASN1_CONTEXT_SPECIFIC | 2) ||
       !CBS_get_optional_asn1(
           &tbs_cert, &outer_extensions, &has_extensions,
@@ -331,7 +365,7 @@ bool ssl_cert_check_key_usage(const CBS *in, enum ssl_key_usage_t bit) {
     if (!CBS_get_asn1(&extensions, &extension, CBS_ASN1_SEQUENCE) ||
         !CBS_get_asn1(&extension, &oid, CBS_ASN1_OBJECT) ||
         (CBS_peek_asn1_tag(&extension, CBS_ASN1_BOOLEAN) &&
-         !CBS_get_asn1(&extension, NULL, CBS_ASN1_BOOLEAN)) ||
+         !CBS_get_asn1(&extension, nullptr, CBS_ASN1_BOOLEAN)) ||
         !CBS_get_asn1(&extension, &contents, CBS_ASN1_OCTETSTRING) ||
         CBS_len(&extension) != 0) {
       OPENSSL_PUT_ERROR(SSL, SSL_R_CANNOT_PARSE_LEAF_CERT);
@@ -374,7 +408,7 @@ bool ssl_cert_check_key_usage(const CBS *in, enum ssl_key_usage_t bit) {
 UniquePtr<STACK_OF(CRYPTO_BUFFER)> SSL_parse_CA_list(SSL *ssl,
                                                      uint8_t *out_alert,
                                                      CBS *cbs) {
-  CRYPTO_BUFFER_POOL *const pool = ssl->ctx->pool;
+  CRYPTO_BUFFER_POOL *const pool = ssl->ctx->pool.get();
 
   UniquePtr<STACK_OF(CRYPTO_BUFFER)> ret(sk_CRYPTO_BUFFER_new_null());
   if (!ret) {
@@ -488,12 +522,11 @@ bool ssl_check_leaf_certificate(SSL_HANDSHAKE *hs, EVP_PKEY *pkey,
 
   if (EVP_PKEY_id(pkey) == EVP_PKEY_EC) {
     // Check the key's group and point format are acceptable.
-    EC_KEY *ec_key = EVP_PKEY_get0_EC_KEY(pkey);
     uint16_t group_id;
-    if (!ssl_nid_to_group_id(
-            &group_id, EC_GROUP_get_curve_name(EC_KEY_get0_group(ec_key))) ||
+    if (!ssl_nid_to_group_id(&group_id, EVP_PKEY_get_ec_curve_nid(pkey)) ||
         !tls1_check_group_id(hs, group_id) ||
-        EC_KEY_get_conv_form(ec_key) != POINT_CONVERSION_UNCOMPRESSED) {
+        EVP_PKEY_get_ec_point_conv_form(pkey) !=
+            POINT_CONVERSION_UNCOMPRESSED) {
       OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_ECC_CERT);
       return false;
     }
@@ -519,8 +552,8 @@ int SSL_set_chain_and_key(SSL *ssl, CRYPTO_BUFFER *const *certs,
 int SSL_CTX_set_chain_and_key(SSL_CTX *ctx, CRYPTO_BUFFER *const *certs,
                               size_t num_certs, EVP_PKEY *privkey,
                               const SSL_PRIVATE_KEY_METHOD *privkey_method) {
-  return cert_set_chain_and_key(ctx->cert.get(), certs, num_certs, privkey,
-                                privkey_method);
+  return cert_set_chain_and_key(FromOpaque(ctx)->cert.get(), certs, num_certs,
+                                privkey, privkey_method);
 }
 
 void SSL_certs_clear(SSL *ssl) {
@@ -535,7 +568,7 @@ void SSL_certs_clear(SSL *ssl) {
 }
 
 const STACK_OF(CRYPTO_BUFFER) *SSL_CTX_get0_chain(const SSL_CTX *ctx) {
-  return ctx->cert->legacy_credential->chain.get();
+  return FromOpaque(ctx)->cert->legacy_credential->chain.get();
 }
 
 const STACK_OF(CRYPTO_BUFFER) *SSL_get0_chain(const SSL *ssl) {
@@ -547,16 +580,16 @@ const STACK_OF(CRYPTO_BUFFER) *SSL_get0_chain(const SSL *ssl) {
 
 int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, size_t der_len,
                                  const uint8_t *der) {
-  UniquePtr<CRYPTO_BUFFER> buffer(CRYPTO_BUFFER_new(der, der_len, NULL));
+  UniquePtr<CRYPTO_BUFFER> buffer(CRYPTO_BUFFER_new(der, der_len, nullptr));
   if (!buffer) {
     return 0;
   }
 
-  return ssl_set_cert(ctx->cert.get(), std::move(buffer));
+  return ssl_set_cert(FromOpaque(ctx)->cert.get(), std::move(buffer));
 }
 
 int SSL_use_certificate_ASN1(SSL *ssl, const uint8_t *der, size_t der_len) {
-  UniquePtr<CRYPTO_BUFFER> buffer(CRYPTO_BUFFER_new(der, der_len, NULL));
+  UniquePtr<CRYPTO_BUFFER> buffer(CRYPTO_BUFFER_new(der, der_len, nullptr));
   if (!buffer || !ssl->config) {
     return 0;
   }
@@ -566,7 +599,7 @@ int SSL_use_certificate_ASN1(SSL *ssl, const uint8_t *der, size_t der_len) {
 
 void SSL_CTX_set_cert_cb(SSL_CTX *ctx, int (*cb)(SSL *ssl, void *arg),
                          void *arg) {
-  ssl_cert_set_cert_cb(ctx->cert.get(), cb, arg);
+  ssl_cert_set_cert_cb(FromOpaque(ctx)->cert.get(), cb, arg);
 }
 
 void SSL_set_cert_cb(SSL *ssl, int (*cb)(SSL *ssl, void *arg), void *arg) {
@@ -578,16 +611,16 @@ void SSL_set_cert_cb(SSL *ssl, int (*cb)(SSL *ssl, void *arg), void *arg) {
 
 const STACK_OF(CRYPTO_BUFFER) *SSL_get0_peer_certificates(const SSL *ssl) {
   SSL_SESSION *session = SSL_get_session(ssl);
-  if (session == NULL) {
-    return NULL;
+  if (session == nullptr) {
+    return nullptr;
   }
 
   return session->certs.get();
 }
 
 const STACK_OF(CRYPTO_BUFFER) *SSL_get0_server_requested_CAs(const SSL *ssl) {
-  if (ssl->s3->hs == NULL) {
-    return NULL;
+  if (ssl->s3->hs == nullptr) {
+    return nullptr;
   }
   return ssl->s3->hs->ca_names.get();
 }
@@ -595,8 +628,9 @@ const STACK_OF(CRYPTO_BUFFER) *SSL_get0_server_requested_CAs(const SSL *ssl) {
 int SSL_CTX_set_signed_cert_timestamp_list(SSL_CTX *ctx, const uint8_t *list,
                                            size_t list_len) {
   UniquePtr<CRYPTO_BUFFER> buf(CRYPTO_BUFFER_new(list, list_len, nullptr));
-  return buf != nullptr && SSL_CREDENTIAL_set1_signed_cert_timestamp_list(
-                               ctx->cert->legacy_credential.get(), buf.get());
+  return buf != nullptr &&
+         SSL_CREDENTIAL_set1_signed_cert_timestamp_list(
+             FromOpaque(ctx)->cert->legacy_credential.get(), buf.get());
 }
 
 int SSL_set_signed_cert_timestamp_list(SSL *ssl, const uint8_t *list,
@@ -614,8 +648,9 @@ int SSL_CTX_set_ocsp_response(SSL_CTX *ctx, const uint8_t *response,
                               size_t response_len) {
   UniquePtr<CRYPTO_BUFFER> buf(
       CRYPTO_BUFFER_new(response, response_len, nullptr));
-  return buf != nullptr && SSL_CREDENTIAL_set1_ocsp_response(
-                               ctx->cert->legacy_credential.get(), buf.get());
+  return buf != nullptr &&
+         SSL_CREDENTIAL_set1_ocsp_response(
+             FromOpaque(ctx)->cert->legacy_credential.get(), buf.get());
 }
 
 int SSL_set_ocsp_response(SSL *ssl, const uint8_t *response,
@@ -631,12 +666,15 @@ int SSL_set_ocsp_response(SSL *ssl, const uint8_t *response,
 }
 
 void SSL_CTX_set0_client_CAs(SSL_CTX *ctx, STACK_OF(CRYPTO_BUFFER) *name_list) {
-  ctx->x509_method->ssl_ctx_flush_cached_client_CA(ctx);
-  ctx->client_CA.reset(name_list);
+  auto *ctx_impl = FromOpaque(ctx);
+  ctx_impl->x509_method->ssl_ctx_flush_cached_client_CA(ctx_impl);
+  ctx_impl->client_CA.reset(name_list);
 }
 
 void SSL_set0_client_CAs(SSL *ssl, STACK_OF(CRYPTO_BUFFER) *name_list) {
   if (!ssl->config) {
+    // `SSL_set0_client_CAs` is expected to take ownership of `name_list`.
+    sk_CRYPTO_BUFFER_pop_free(name_list, CRYPTO_BUFFER_free);
     return;
   }
   ssl->ctx->x509_method->ssl_flush_cached_client_CA(ssl->config.get());