grpc 1.84.0 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/strings/string_view.cc

@@ -1,257 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/strings/string_view.h"
-
-#ifndef ABSL_USES_STD_STRING_VIEW
-
-#include <algorithm>
-#include <climits>
-#include <cstring>
-#include <ostream>
-
-#include "absl/base/nullability.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-namespace {
-
-// This is significantly faster for case-sensitive matches with very
-// few possible matches.
-const char* absl_nullable memmatch(const char* absl_nullable phaystack,
-                                   size_t haylen,
-                                   const char* absl_nullable pneedle,
-                                   size_t neelen) {
-  if (0 == neelen) {
-    return phaystack;  // even if haylen is 0
-  }
-  if (haylen < neelen) return nullptr;
-
-  const char* match;
-  const char* hayend = phaystack + haylen - neelen + 1;
-  // A static cast is used here as memchr returns a const void *, and pointer
-  // arithmetic is not allowed on pointers to void.
-  while (
-      (match = static_cast<const char*>(memchr(
-           phaystack, pneedle[0], static_cast<size_t>(hayend - phaystack))))) {
-    if (memcmp(match, pneedle, neelen) == 0)
-      return match;
-    else
-      phaystack = match + 1;
-  }
-  return nullptr;
-}
-
-void WritePadding(std::ostream& o, size_t pad) {
-  char fill_buf[32];
-  memset(fill_buf, o.fill(), sizeof(fill_buf));
-  while (pad) {
-    size_t n = std::min(pad, sizeof(fill_buf));
-    o.write(fill_buf, static_cast<std::streamsize>(n));
-    pad -= n;
-  }
-}
-
-class LookupTable {
- public:
-  // For each character in wanted, sets the index corresponding
-  // to the ASCII code of that character. This is used by
-  // the find_.*_of methods below to tell whether or not a character is in
-  // the lookup table in constant time.
-  explicit LookupTable(string_view wanted) {
-    for (char c : wanted) {
-      table_[Index(c)] = true;
-    }
-  }
-  bool operator[](char c) const { return table_[Index(c)]; }
-
- private:
-  static unsigned char Index(char c) { return static_cast<unsigned char>(c); }
-  bool table_[UCHAR_MAX + 1] = {};
-};
-
-}  // namespace
-
-std::ostream& operator<<(std::ostream& o, string_view piece) {
-  std::ostream::sentry sentry(o);
-  if (sentry) {
-    size_t lpad = 0;
-    size_t rpad = 0;
-    if (static_cast<size_t>(o.width()) > piece.size()) {
-      size_t pad = static_cast<size_t>(o.width()) - piece.size();
-      if ((o.flags() & o.adjustfield) == o.left) {
-        rpad = pad;
-      } else {
-        lpad = pad;
-      }
-    }
-    if (lpad) WritePadding(o, lpad);
-    o.write(piece.data(), static_cast<std::streamsize>(piece.size()));
-    if (rpad) WritePadding(o, rpad);
-    o.width(0);
-  }
-  return o;
-}
-
-string_view::size_type string_view::find(string_view s,
-                                         size_type pos) const noexcept {
-  if (empty() || pos > length_) {
-    if (empty() && pos == 0 && s.empty()) return 0;
-    return npos;
-  }
-  const char* result = memmatch(ptr_ + pos, length_ - pos, s.ptr_, s.length_);
-  return result ? static_cast<size_type>(result - ptr_) : npos;
-}
-
-string_view::size_type string_view::find(char c, size_type pos) const noexcept {
-  if (empty() || pos >= length_) {
-    return npos;
-  }
-  const char* result =
-      static_cast<const char*>(memchr(ptr_ + pos, c, length_ - pos));
-  return result != nullptr ? static_cast<size_type>(result - ptr_) : npos;
-}
-
-string_view::size_type string_view::rfind(string_view s,
-                                          size_type pos) const noexcept {
-  if (length_ < s.length_) return npos;
-  if (s.empty()) return std::min(length_, pos);
-  const char* last = ptr_ + std::min(length_ - s.length_, pos) + s.length_;
-  const char* result = std::find_end(ptr_, last, s.ptr_, s.ptr_ + s.length_);
-  return result != last ? static_cast<size_type>(result - ptr_) : npos;
-}
-
-// Search range is [0..pos] inclusive.  If pos == npos, search everything.
-string_view::size_type string_view::rfind(char c,
-                                          size_type pos) const noexcept {
-  // Note: memrchr() is not available on Windows.
-  if (empty()) return npos;
-  for (size_type i = std::min(pos, length_ - 1);; --i) {
-    if (ptr_[i] == c) {
-      return i;
-    }
-    if (i == 0) break;
-  }
-  return npos;
-}
-
-string_view::size_type string_view::find_first_of(
-    string_view s, size_type pos) const noexcept {
-  if (empty() || s.empty()) {
-    return npos;
-  }
-  // Avoid the cost of LookupTable() for a single-character search.
-  if (s.length_ == 1) return find_first_of(s.ptr_[0], pos);
-  LookupTable tbl(s);
-  for (size_type i = pos; i < length_; ++i) {
-    if (tbl[ptr_[i]]) {
-      return i;
-    }
-  }
-  return npos;
-}
-
-string_view::size_type string_view::find_first_not_of(
-    string_view s, size_type pos) const noexcept {
-  if (empty()) return npos;
-  // Avoid the cost of LookupTable() for a single-character search.
-  if (s.length_ == 1) return find_first_not_of(s.ptr_[0], pos);
-  LookupTable tbl(s);
-  for (size_type i = pos; i < length_; ++i) {
-    if (!tbl[ptr_[i]]) {
-      return i;
-    }
-  }
-  return npos;
-}
-
-string_view::size_type string_view::find_first_not_of(
-    char c, size_type pos) const noexcept {
-  if (empty()) return npos;
-  for (; pos < length_; ++pos) {
-    if (ptr_[pos] != c) {
-      return pos;
-    }
-  }
-  return npos;
-}
-
-string_view::size_type string_view::find_last_of(string_view s,
-                                                 size_type pos) const noexcept {
-  if (empty() || s.empty()) return npos;
-  // Avoid the cost of LookupTable() for a single-character search.
-  if (s.length_ == 1) return find_last_of(s.ptr_[0], pos);
-  LookupTable tbl(s);
-  for (size_type i = std::min(pos, length_ - 1);; --i) {
-    if (tbl[ptr_[i]]) {
-      return i;
-    }
-    if (i == 0) break;
-  }
-  return npos;
-}
-
-string_view::size_type string_view::find_last_not_of(
-    string_view s, size_type pos) const noexcept {
-  if (empty()) return npos;
-  size_type i = std::min(pos, length_ - 1);
-  if (s.empty()) return i;
-  // Avoid the cost of LookupTable() for a single-character search.
-  if (s.length_ == 1) return find_last_not_of(s.ptr_[0], pos);
-  LookupTable tbl(s);
-  for (;; --i) {
-    if (!tbl[ptr_[i]]) {
-      return i;
-    }
-    if (i == 0) break;
-  }
-  return npos;
-}
-
-string_view::size_type string_view::find_last_not_of(
-    char c, size_type pos) const noexcept {
-  if (empty()) return npos;
-  size_type i = std::min(pos, length_ - 1);
-  for (;; --i) {
-    if (ptr_[i] != c) {
-      return i;
-    }
-    if (i == 0) break;
-  }
-  return npos;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#else
-
-// https://github.com/abseil/abseil-cpp/issues/1465
-// CMake builds on Apple platforms error when libraries are empty.
-// Our CMake configuration can avoid this error on header-only libraries,
-// but since this library is conditionally empty, including a single
-// variable is an easy workaround.
-#ifdef __APPLE__
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace strings_internal {
-extern const char kAvoidEmptyStringViewLibraryWarning;
-const char kAvoidEmptyStringViewLibraryWarning = 0;
-}  // namespace strings_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-#endif  // __APPLE__
-
-#endif  // ABSL_USES_STD_STRING_VIEW

data/third_party/boringssl-with-bazel/crypto/evp/p_dh_asn1.cc

@@ -1,142 +0,0 @@
-// Copyright 2006-2021 The OpenSSL Project Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <openssl/evp.h>
-
-#include <openssl/bn.h>
-#include <openssl/dh.h>
-#include <openssl/err.h>
-
-#include "../internal.h"
-#include "internal.h"
-
-
-static void dh_free(EVP_PKEY *pkey) {
-  DH_free(reinterpret_cast<DH *>(pkey->pkey));
-  pkey->pkey = NULL;
-}
-
-static int dh_size(const EVP_PKEY *pkey) {
-  return DH_size(reinterpret_cast<const DH *>(pkey->pkey));
-}
-
-static int dh_bits(const EVP_PKEY *pkey) {
-  return DH_bits(reinterpret_cast<const DH *>(pkey->pkey));
-}
-
-static int dh_param_missing(const EVP_PKEY *pkey) {
-  const DH *dh = reinterpret_cast<const DH *>(pkey->pkey);
-  return dh == NULL || DH_get0_p(dh) == NULL || DH_get0_g(dh) == NULL;
-}
-
-static int dh_param_copy(EVP_PKEY *to, const EVP_PKEY *from) {
-  if (dh_param_missing(from)) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_MISSING_PARAMETERS);
-    return 0;
-  }
-
-  const DH *dh = reinterpret_cast<DH *>(from->pkey);
-  const BIGNUM *q_old = DH_get0_q(dh);
-  BIGNUM *p = BN_dup(DH_get0_p(dh));
-  BIGNUM *q = q_old == NULL ? NULL : BN_dup(q_old);
-  BIGNUM *g = BN_dup(DH_get0_g(dh));
-  if (p == NULL || (q_old != NULL && q == NULL) || g == NULL ||
-      !DH_set0_pqg(reinterpret_cast<DH *>(to->pkey), p, q, g)) {
-    BN_free(p);
-    BN_free(q);
-    BN_free(g);
-    return 0;
-  }
-
-  // |DH_set0_pqg| took ownership of |p|, |q|, and |g|.
-  return 1;
-}
-
-static int dh_param_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  if (dh_param_missing(a) || dh_param_missing(b)) {
-    return -2;
-  }
-
-  // Matching OpenSSL, only compare p and g for PKCS#3-style Diffie-Hellman.
-  // OpenSSL only checks q in X9.42-style Diffie-Hellman ("DHX").
-  const DH *a_dh = reinterpret_cast<const DH *>(a->pkey);
-  const DH *b_dh = reinterpret_cast<const DH *>(b->pkey);
-  return BN_cmp(DH_get0_p(a_dh), DH_get0_p(b_dh)) == 0 &&
-         BN_cmp(DH_get0_g(a_dh), DH_get0_g(b_dh)) == 0;
-}
-
-static int dh_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  if (dh_param_cmp(a, b) <= 0) {
-    return 0;
-  }
-
-  const DH *a_dh = reinterpret_cast<const DH *>(a->pkey);
-  const DH *b_dh = reinterpret_cast<const DH *>(b->pkey);
-  return BN_cmp(DH_get0_pub_key(a_dh), DH_get0_pub_key(b_dh)) == 0;
-}
-
-const EVP_PKEY_ASN1_METHOD dh_asn1_meth = {
-    /*pkey_id=*/EVP_PKEY_DH,
-    /*oid=*/{0},
-    /*oid_len=*/0,
-    /*pkey_method=*/&dh_pkey_meth,
-    /*pub_decode=*/nullptr,
-    /*pub_encode=*/nullptr,
-    /*pub_cmp=*/dh_pub_cmp,
-    /*priv_decode=*/nullptr,
-    /*priv_encode=*/nullptr,
-    /*set_priv_raw=*/nullptr,
-    /*set_pub_raw=*/nullptr,
-    /*get_priv_raw=*/nullptr,
-    /*get_pub_raw=*/nullptr,
-    /*set1_tls_encodedpoint=*/nullptr,
-    /*get1_tls_encodedpoint=*/nullptr,
-    /*pkey_opaque=*/nullptr,
-    /*pkey_size=*/dh_size,
-    /*pkey_bits=*/dh_bits,
-    /*param_missing=*/dh_param_missing,
-    /*param_copy=*/dh_param_copy,
-    /*param_cmp=*/dh_param_cmp,
-    /*pkey_free=*/dh_free,
-};
-
-int EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key) {
-  if (EVP_PKEY_assign_DH(pkey, key)) {
-    DH_up_ref(key);
-    return 1;
-  }
-  return 0;
-}
-
-int EVP_PKEY_assign_DH(EVP_PKEY *pkey, DH *key) {
-  evp_pkey_set_method(pkey, &dh_asn1_meth);
-  pkey->pkey = key;
-  return key != NULL;
-}
-
-DH *EVP_PKEY_get0_DH(const EVP_PKEY *pkey) {
-  if (pkey->type != EVP_PKEY_DH) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_EXPECTING_A_DH_KEY);
-    return NULL;
-  }
-  return reinterpret_cast<DH *>(const_cast<EVP_PKEY *>(pkey)->pkey);
-}
-
-DH *EVP_PKEY_get1_DH(const EVP_PKEY *pkey) {
-  DH *dh = EVP_PKEY_get0_DH(pkey);
-  if (dh != NULL) {
-    DH_up_ref(dh);
-  }
-  return dh;
-}

data/third_party/boringssl-with-bazel/crypto/evp/p_dsa_asn1.cc

@@ -1,279 +0,0 @@
-// Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <openssl/evp.h>
-
-#include <openssl/bn.h>
-#include <openssl/bytestring.h>
-#include <openssl/digest.h>
-#include <openssl/dsa.h>
-#include <openssl/err.h>
-
-#include "../dsa/internal.h"
-#include "internal.h"
-
-
-static int dsa_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
-  // See RFC 3279, section 2.3.2.
-
-  // Parameters may or may not be present.
-  bssl::UniquePtr<DSA> dsa;
-  if (CBS_len(params) == 0) {
-    dsa.reset(DSA_new());
-    if (dsa == nullptr) {
-      return 0;
-    }
-  } else {
-    dsa.reset(DSA_parse_parameters(params));
-    if (dsa == nullptr || CBS_len(params) != 0) {
-      OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-      return 0;
-    }
-  }
-
-  dsa->pub_key = BN_new();
-  if (dsa->pub_key == nullptr) {
-    return 0;
-  }
-
-  if (!BN_parse_asn1_unsigned(key, dsa->pub_key) || CBS_len(key) != 0) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return 0;
-  }
-
-  EVP_PKEY_assign_DSA(out, dsa.release());
-  return 1;
-}
-
-static int dsa_pub_encode(CBB *out, const EVP_PKEY *key) {
-  const DSA *dsa = reinterpret_cast<const DSA *>(key->pkey);
-  const int has_params =
-      dsa->p != nullptr && dsa->q != nullptr && dsa->g != nullptr;
-
-  // See RFC 5480, section 2.
-  CBB spki, algorithm, oid, key_bitstring;
-  if (!CBB_add_asn1(out, &spki, CBS_ASN1_SEQUENCE) ||
-      !CBB_add_asn1(&spki, &algorithm, CBS_ASN1_SEQUENCE) ||
-      !CBB_add_asn1(&algorithm, &oid, CBS_ASN1_OBJECT) ||
-      !CBB_add_bytes(&oid, dsa_asn1_meth.oid, dsa_asn1_meth.oid_len) ||
-      (has_params && !DSA_marshal_parameters(&algorithm, dsa)) ||
-      !CBB_add_asn1(&spki, &key_bitstring, CBS_ASN1_BITSTRING) ||
-      !CBB_add_u8(&key_bitstring, 0 /* padding */) ||
-      !BN_marshal_asn1(&key_bitstring, dsa->pub_key) || !CBB_flush(out)) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
-    return 0;
-  }
-
-  return 1;
-}
-
-static int dsa_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
-  // See PKCS#11, v2.40, section 2.5.
-
-  // Decode parameters.
-  bssl::UniquePtr<DSA> dsa(DSA_parse_parameters(params));
-  if (dsa == nullptr || CBS_len(params) != 0) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return 0;
-  }
-
-  dsa->priv_key = BN_new();
-  if (dsa->priv_key == nullptr) {
-    return 0;
-  }
-  if (!BN_parse_asn1_unsigned(key, dsa->priv_key) || CBS_len(key) != 0) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return 0;
-  }
-
-  // To avoid DoS attacks when importing private keys, check bounds on |dsa|.
-  // This bounds |dsa->priv_key| against |dsa->q| and bounds |dsa->q|'s bit
-  // width.
-  if (!dsa_check_key(dsa.get())) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return 0;
-  }
-
-  // Calculate the public key.
-  bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new());
-  dsa->pub_key = BN_new();
-  if (ctx == nullptr || dsa->pub_key == nullptr ||
-      !BN_mod_exp_mont_consttime(dsa->pub_key, dsa->g, dsa->priv_key, dsa->p,
-                                 ctx.get(), nullptr)) {
-    return 0;
-  }
-
-  EVP_PKEY_assign_DSA(out, dsa.release());
-  return 1;
-}
-
-static int dsa_priv_encode(CBB *out, const EVP_PKEY *key) {
-  const DSA *dsa = reinterpret_cast<const DSA *>(key->pkey);
-  if (dsa == nullptr || dsa->priv_key == nullptr) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_MISSING_PARAMETERS);
-    return 0;
-  }
-
-  // See PKCS#11, v2.40, section 2.5.
-  CBB pkcs8, algorithm, oid, private_key;
-  if (!CBB_add_asn1(out, &pkcs8, CBS_ASN1_SEQUENCE) ||
-      !CBB_add_asn1_uint64(&pkcs8, 0 /* version */) ||
-      !CBB_add_asn1(&pkcs8, &algorithm, CBS_ASN1_SEQUENCE) ||
-      !CBB_add_asn1(&algorithm, &oid, CBS_ASN1_OBJECT) ||
-      !CBB_add_bytes(&oid, dsa_asn1_meth.oid, dsa_asn1_meth.oid_len) ||
-      !DSA_marshal_parameters(&algorithm, dsa) ||
-      !CBB_add_asn1(&pkcs8, &private_key, CBS_ASN1_OCTETSTRING) ||
-      !BN_marshal_asn1(&private_key, dsa->priv_key) || !CBB_flush(out)) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
-    return 0;
-  }
-
-  return 1;
-}
-
-static int int_dsa_size(const EVP_PKEY *pkey) {
-  const DSA *dsa = reinterpret_cast<const DSA *>(pkey->pkey);
-  return DSA_size(dsa);
-}
-
-static int dsa_bits(const EVP_PKEY *pkey) {
-  const DSA *dsa = reinterpret_cast<const DSA *>(pkey->pkey);
-  return BN_num_bits(DSA_get0_p(dsa));
-}
-
-static int dsa_missing_parameters(const EVP_PKEY *pkey) {
-  const DSA *dsa = reinterpret_cast<const DSA *>(pkey->pkey);
-  if (DSA_get0_p(dsa) == nullptr || DSA_get0_q(dsa) == nullptr ||
-      DSA_get0_g(dsa) == nullptr) {
-    return 1;
-  }
-  return 0;
-}
-
-static int dup_bn_into(BIGNUM **out, BIGNUM *src) {
-  bssl::UniquePtr<BIGNUM> a(BN_dup(src));
-  if (a == nullptr) {
-    return 0;
-  }
-  BN_free(*out);
-  *out = a.release();
-  return 1;
-}
-
-static int dsa_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from) {
-  DSA *to_dsa = reinterpret_cast<DSA *>(to->pkey);
-  const DSA *from_dsa = reinterpret_cast<const DSA *>(from->pkey);
-  if (!dup_bn_into(&to_dsa->p, from_dsa->p) ||
-      !dup_bn_into(&to_dsa->q, from_dsa->q) ||
-      !dup_bn_into(&to_dsa->g, from_dsa->g)) {
-    return 0;
-  }
-
-  return 1;
-}
-
-static int dsa_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const DSA *a_dsa = reinterpret_cast<const DSA *>(a->pkey);
-  const DSA *b_dsa = reinterpret_cast<const DSA *>(b->pkey);
-  return BN_cmp(DSA_get0_p(a_dsa), DSA_get0_p(b_dsa)) == 0 &&
-         BN_cmp(DSA_get0_q(a_dsa), DSA_get0_q(b_dsa)) == 0 &&
-         BN_cmp(DSA_get0_g(a_dsa), DSA_get0_g(b_dsa)) == 0;
-}
-
-static int dsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const DSA *a_dsa = reinterpret_cast<const DSA *>(a->pkey);
-  const DSA *b_dsa = reinterpret_cast<const DSA *>(b->pkey);
-  return BN_cmp(DSA_get0_pub_key(b_dsa), DSA_get0_pub_key(a_dsa)) == 0;
-}
-
-static void int_dsa_free(EVP_PKEY *pkey) {
-  DSA_free(reinterpret_cast<DSA *>(pkey->pkey));
-  pkey->pkey = nullptr;
-}
-
-const EVP_PKEY_ASN1_METHOD dsa_asn1_meth = {
-    EVP_PKEY_DSA,
-    // 1.2.840.10040.4.1
-    {0x2a, 0x86, 0x48, 0xce, 0x38, 0x04, 0x01},
-    7,
-
-    /*pkey_method=*/nullptr,
-
-    dsa_pub_decode,
-    dsa_pub_encode,
-    dsa_pub_cmp,
-
-    dsa_priv_decode,
-    dsa_priv_encode,
-
-    /*set_priv_raw=*/nullptr,
-    /*set_pub_raw=*/nullptr,
-    /*get_priv_raw=*/nullptr,
-    /*get_pub_raw=*/nullptr,
-    /*set1_tls_encodedpoint=*/nullptr,
-    /*get1_tls_encodedpoint=*/nullptr,
-
-    /*pkey_opaque=*/nullptr,
-
-    int_dsa_size,
-    dsa_bits,
-
-    dsa_missing_parameters,
-    dsa_copy_parameters,
-    dsa_cmp_parameters,
-
-    int_dsa_free,
-};
-
-int EVP_PKEY_CTX_set_dsa_paramgen_bits(EVP_PKEY_CTX *ctx, int nbits) {
-  // BoringSSL does not support DSA in |EVP_PKEY_CTX|.
-  OPENSSL_PUT_ERROR(EVP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-  return 0;
-}
-
-int EVP_PKEY_CTX_set_dsa_paramgen_q_bits(EVP_PKEY_CTX *ctx, int qbits) {
-  // BoringSSL does not support DSA in |EVP_PKEY_CTX|.
-  OPENSSL_PUT_ERROR(EVP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-  return 0;
-}
-
-int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key) {
-  if (EVP_PKEY_assign_DSA(pkey, key)) {
-    DSA_up_ref(key);
-    return 1;
-  }
-  return 0;
-}
-
-int EVP_PKEY_assign_DSA(EVP_PKEY *pkey, DSA *key) {
-  evp_pkey_set_method(pkey, &dsa_asn1_meth);
-  pkey->pkey = key;
-  return key != nullptr;
-}
-
-DSA *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey) {
-  if (pkey->type != EVP_PKEY_DSA) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_EXPECTING_A_DSA_KEY);
-    return nullptr;
-  }
-  return reinterpret_cast<DSA *>(pkey->pkey);
-}
-
-DSA *EVP_PKEY_get1_DSA(const EVP_PKEY *pkey) {
-  DSA *dsa = EVP_PKEY_get0_DSA(pkey);
-  if (dsa != nullptr) {
-    DSA_up_ref(dsa);
-  }
-  return dsa;
-}