grpc 1.80.0 → 1.81.0

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/dsa/dsa_asn1.cc

@@ -136,9 +136,9 @@ int DSA_SIG_marshal(CBB *cbb, const DSA_SIG *sig) {
 }
 
 DSA *DSA_parse_public_key(CBS *cbs) {
-  bssl::UniquePtr<DSA> ret(DSA_new());
-  if (ret == nullptr) {
-    return nullptr;
+  DSA *ret = DSA_new();
+  if (ret == NULL) {
+    return NULL;
   }
   CBS child;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
@@ -148,12 +148,16 @@ DSA *DSA_parse_public_key(CBS *cbs) {
       !parse_integer(&child, &ret->g) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    return nullptr;
+    goto err;
   }
-  if (!dsa_check_key(ret.get())) {
-    return nullptr;
+  if (!dsa_check_key(ret)) {
+    goto err;
   }
-  return ret.release();
+  return ret;
+
+err:
+  DSA_free(ret);
+  return NULL;
 }
 
 int DSA_marshal_public_key(CBB *cbb, const DSA *dsa) {
@@ -171,9 +175,9 @@ int DSA_marshal_public_key(CBB *cbb, const DSA *dsa) {
 }
 
 DSA *DSA_parse_parameters(CBS *cbs) {
-  bssl::UniquePtr<DSA> ret(DSA_new());
-  if (ret == nullptr) {
-    return nullptr;
+  DSA *ret = DSA_new();
+  if (ret == NULL) {
+    return NULL;
   }
   CBS child;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
@@ -182,12 +186,16 @@ DSA *DSA_parse_parameters(CBS *cbs) {
       !parse_integer(&child, &ret->g) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    return nullptr;
+    goto err;
   }
-  if (!dsa_check_key(ret.get())) {
-    return nullptr;
+  if (!dsa_check_key(ret)) {
+    goto err;
   }
-  return ret.release();
+  return ret;
+
+err:
+  DSA_free(ret);
+  return NULL;
 }
 
 int DSA_marshal_parameters(CBB *cbb, const DSA *dsa) {
@@ -204,9 +212,9 @@ int DSA_marshal_parameters(CBB *cbb, const DSA *dsa) {
 }
 
 DSA *DSA_parse_private_key(CBS *cbs) {
-  bssl::UniquePtr<DSA> ret(DSA_new());
-  if (ret == nullptr) {
-    return nullptr;
+  DSA *ret = DSA_new();
+  if (ret == NULL) {
+    return NULL;
   }
 
   CBS child;
@@ -214,12 +222,12 @@ DSA *DSA_parse_private_key(CBS *cbs) {
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
       !CBS_get_asn1_uint64(&child, &version)) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    return nullptr;
+    goto err;
   }
 
   if (version != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_BAD_VERSION);
-    return nullptr;
+    goto err;
   }
 
   if (!parse_integer(&child, &ret->p) ||
@@ -229,13 +237,17 @@ DSA *DSA_parse_private_key(CBS *cbs) {
       !parse_integer(&child, &ret->priv_key) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    return nullptr;
+    goto err;
   }
-  if (!dsa_check_key(ret.get())) {
-    return nullptr;
+  if (!dsa_check_key(ret)) {
+    goto err;
   }
 
-  return ret.release();
+  return ret;
+
+err:
+  DSA_free(ret);
+  return NULL;
 }
 
 int DSA_marshal_private_key(CBB *cbb, const DSA *dsa) {

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/ec/ec_asn1.cc

@@ -51,10 +51,12 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
       version != 1 ||
       !CBS_get_asn1(&ec_private_key, &private_key, CBS_ASN1_OCTETSTRING)) {
     OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
-    return nullptr;
+    return NULL;
   }
 
   // Parse the optional parameters field.
+  EC_KEY *ret = NULL;
+  BIGNUM *priv_key = NULL;
   if (CBS_peek_asn1_tag(&ec_private_key, kParametersTag)) {
     // Per SEC 1, as an alternative to omitting it, one is allowed to specify
     // this field and put in a NULL to mean inheriting this value. This was
@@ -63,44 +65,43 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
     CBS child;
     if (!CBS_get_asn1(&ec_private_key, &child, kParametersTag)) {
       OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
-      return nullptr;
+      goto err;
     }
     const EC_GROUP *inner_group = EC_KEY_parse_parameters(&child);
-    if (inner_group == nullptr) {
-      return nullptr;
+    if (inner_group == NULL) {
+      goto err;
     }
-    if (group == nullptr) {
+    if (group == NULL) {
       group = inner_group;
-    } else if (EC_GROUP_cmp(group, inner_group, nullptr) != 0) {
+    } else if (EC_GROUP_cmp(group, inner_group, NULL) != 0) {
       // If a group was supplied externally, it must match.
       OPENSSL_PUT_ERROR(EC, EC_R_GROUP_MISMATCH);
-      return nullptr;
+      goto err;
     }
     if (CBS_len(&child) != 0) {
       OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
-      return nullptr;
+      goto err;
     }
   }
 
-  if (group == nullptr) {
+  if (group == NULL) {
     OPENSSL_PUT_ERROR(EC, EC_R_MISSING_PARAMETERS);
-    return nullptr;
+    goto err;
   }
 
-  bssl::UniquePtr<EC_KEY> ret(EC_KEY_new());
-  if (ret == nullptr || !EC_KEY_set_group(ret.get(), group)) {
-    return nullptr;
+  ret = EC_KEY_new();
+  if (ret == NULL || !EC_KEY_set_group(ret, group)) {
+    goto err;
   }
 
   // Although RFC 5915 specifies the length of the key, OpenSSL historically
   // got this wrong, so accept any length. See upstream's
   // 30cd4ff294252c4b6a4b69cbef6a5b4117705d22.
-  bssl::UniquePtr<BIGNUM> priv_key(
-      BN_bin2bn(CBS_data(&private_key), CBS_len(&private_key), nullptr));
+  priv_key = BN_bin2bn(CBS_data(&private_key), CBS_len(&private_key), NULL);
   ret->pub_key = EC_POINT_new(group);
-  if (priv_key == nullptr || ret->pub_key == nullptr ||
-      !EC_KEY_set_private_key(ret.get(), priv_key.get())) {
-    return nullptr;
+  if (priv_key == NULL || ret->pub_key == NULL ||
+      !EC_KEY_set_private_key(ret, priv_key)) {
+    goto err;
   }
 
   if (CBS_peek_asn1_tag(&ec_private_key, kPublicKeyTag)) {
@@ -116,10 +117,10 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
         // form later.
         CBS_len(&public_key) == 0 ||
         !EC_POINT_oct2point(group, ret->pub_key, CBS_data(&public_key),
-                            CBS_len(&public_key), nullptr) ||
+                            CBS_len(&public_key), NULL) ||
         CBS_len(&child) != 0) {
       OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
-      return nullptr;
+      goto err;
     }
 
     // Save the point conversion form.
@@ -130,7 +131,7 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
     // Compute the public key instead.
     if (!ec_point_mul_scalar_base(group, &ret->pub_key->raw,
                                   &ret->priv_key->scalar)) {
-      return nullptr;
+      goto err;
     }
     // Remember the original private-key-only encoding.
     // TODO(davidben): Consider removing this.
@@ -139,15 +140,21 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
 
   if (CBS_len(&ec_private_key) != 0) {
     OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
-    return nullptr;
+    goto err;
   }
 
   // Ensure the resulting key is valid.
-  if (!EC_KEY_check_key(ret.get())) {
-    return nullptr;
+  if (!EC_KEY_check_key(ret)) {
+    goto err;
   }
 
-  return ret.release();
+  BN_free(priv_key);
+  return ret;
+
+err:
+  EC_KEY_free(ret);
+  BN_free(priv_key);
+  return NULL;
 }
 
 int EC_KEY_marshal_private_key(CBB *cbb, const EC_KEY *key,
@@ -320,7 +327,10 @@ int EC_KEY_marshal_curve_name(CBB *cbb, const EC_GROUP *group) {
     return 0;
   }
 
-  return CBB_add_asn1_element(cbb, CBS_ASN1_OBJECT, group->oid, group->oid_len);
+  CBB child;
+  return CBB_add_asn1(cbb, &child, CBS_ASN1_OBJECT) &&
+         CBB_add_bytes(&child, group->oid, group->oid_len) &&  //
+         CBB_flush(cbb);
 }
 
 EC_GROUP *EC_KEY_parse_parameters(CBS *cbs) {
@@ -334,17 +344,14 @@ EC_GROUP *EC_KEY_parse_parameters(CBS *cbs) {
   // TODO(davidben): Remove support for this.
   struct explicit_prime_curve curve;
   if (!parse_explicit_prime_curve(cbs, &curve)) {
-    return nullptr;
+    return NULL;
   }
 
-  bssl::UniquePtr<BIGNUM> p(BN_new());
-  bssl::UniquePtr<BIGNUM> a(BN_new());
-  bssl::UniquePtr<BIGNUM> b(BN_new());
-  bssl::UniquePtr<BIGNUM> x(BN_new());
-  bssl::UniquePtr<BIGNUM> y(BN_new());
-  if (p == nullptr || a == nullptr || b == nullptr || x == nullptr ||
-      y == nullptr) {
-    return nullptr;
+  const EC_GROUP *ret = NULL;
+  BIGNUM *p = BN_new(), *a = BN_new(), *b = BN_new(), *x = BN_new(),
+         *y = BN_new();
+  if (p == NULL || a == NULL || b == NULL || x == NULL || y == NULL) {
+    goto err;
   }
 
   for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kAllGroups); i++) {
@@ -355,27 +362,36 @@ EC_GROUP *EC_KEY_parse_parameters(CBS *cbs) {
 
     // The order alone uniquely identifies the group, but we check the other
     // parameters to avoid misinterpreting the group.
-    if (!EC_GROUP_get_curve_GFp(group, p.get(), a.get(), b.get(), nullptr)) {
-      return nullptr;
+    if (!EC_GROUP_get_curve_GFp(group, p, a, b, NULL)) {
+      goto err;
     }
-    if (!integers_equal(&curve.prime, p.get()) ||
-        !integers_equal(&curve.a, a.get()) ||
-        !integers_equal(&curve.b, b.get())) {
+    if (!integers_equal(&curve.prime, p) || !integers_equal(&curve.a, a) ||
+        !integers_equal(&curve.b, b)) {
       break;
     }
     if (!EC_POINT_get_affine_coordinates_GFp(
-            group, EC_GROUP_get0_generator(group), x.get(), y.get(), nullptr)) {
-      return nullptr;
+            group, EC_GROUP_get0_generator(group), x, y, NULL)) {
+      goto err;
     }
-    if (!integers_equal(&curve.base_x, x.get()) ||
-        !integers_equal(&curve.base_y, y.get())) {
+    if (!integers_equal(&curve.base_x, x) ||
+        !integers_equal(&curve.base_y, y)) {
       break;
     }
-    return const_cast<EC_GROUP *>(group);
+    ret = group;
+    break;
   }
 
-  OPENSSL_PUT_ERROR(EC, EC_R_UNKNOWN_GROUP);
-  return nullptr;
+  if (ret == NULL) {
+    OPENSSL_PUT_ERROR(EC, EC_R_UNKNOWN_GROUP);
+  }
+
+err:
+  BN_free(p);
+  BN_free(a);
+  BN_free(b);
+  BN_free(x);
+  BN_free(y);
+  return (EC_GROUP *)ret;
 }
 
 int EC_POINT_point2cbb(CBB *out, const EC_GROUP *group, const EC_POINT *point,

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/ec/hash_to_curve.cc

@@ -57,76 +57,84 @@ static int expand_message_xmd(const EVP_MD *md, uint8_t *out, size_t out_len,
     return 0;
   }
 
+  int ret = 0;
   const size_t block_size = EVP_MD_block_size(md);
   const size_t md_size = EVP_MD_size(md);
-  bssl::ScopedEVP_MD_CTX ctx;
-
-  // Long DSTs are hashed down to size. See section 5.3.3.
-  static_assert(EVP_MAX_MD_SIZE < 256, "hashed DST still too large");
-  uint8_t dst_buf[EVP_MAX_MD_SIZE];
-  if (dst_len >= 256) {
-    static const char kPrefix[] = "H2C-OVERSIZE-DST-";
-    if (!EVP_DigestInit_ex(ctx.get(), md, nullptr) ||
-        !EVP_DigestUpdate(ctx.get(), kPrefix, sizeof(kPrefix) - 1) ||
-        !EVP_DigestUpdate(ctx.get(), dst, dst_len) ||
-        !EVP_DigestFinal_ex(ctx.get(), dst_buf, nullptr)) {
-      return 0;
+  EVP_MD_CTX ctx;
+  EVP_MD_CTX_init(&ctx);
+
+  {
+    // Long DSTs are hashed down to size. See section 5.3.3.
+    static_assert(EVP_MAX_MD_SIZE < 256, "hashed DST still too large");
+    uint8_t dst_buf[EVP_MAX_MD_SIZE];
+    if (dst_len >= 256) {
+      static const char kPrefix[] = "H2C-OVERSIZE-DST-";
+      if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
+          !EVP_DigestUpdate(&ctx, kPrefix, sizeof(kPrefix) - 1) ||
+          !EVP_DigestUpdate(&ctx, dst, dst_len) ||
+          !EVP_DigestFinal_ex(&ctx, dst_buf, NULL)) {
+        goto err;
+      }
+      dst = dst_buf;
+      dst_len = md_size;
     }
-    dst = dst_buf;
-    dst_len = md_size;
-  }
-  uint8_t dst_len_u8 = (uint8_t)dst_len;
-
-  // Compute b_0.
-  static const uint8_t kZeros[EVP_MAX_MD_BLOCK_SIZE] = {0};
-  // If |out_len| exceeds 16 bits then |i| will wrap below causing an error to
-  // be returned. This depends on the static assert above.
-  uint8_t l_i_b_str_zero[3] = {static_cast<uint8_t>(out_len >> 8),
-                               static_cast<uint8_t>(out_len), 0};
-  uint8_t b_0[EVP_MAX_MD_SIZE];
-  if (!EVP_DigestInit_ex(ctx.get(), md, nullptr) ||
-      !EVP_DigestUpdate(ctx.get(), kZeros, block_size) ||
-      !EVP_DigestUpdate(ctx.get(), msg, msg_len) ||
-      !EVP_DigestUpdate(ctx.get(), l_i_b_str_zero, sizeof(l_i_b_str_zero)) ||
-      !EVP_DigestUpdate(ctx.get(), dst, dst_len) ||
-      !EVP_DigestUpdate(ctx.get(), &dst_len_u8, 1) ||
-      !EVP_DigestFinal_ex(ctx.get(), b_0, nullptr)) {
-    return 0;
-  }
-
-  uint8_t b_i[EVP_MAX_MD_SIZE];
-  uint8_t i = 1;
-  while (out_len > 0) {
-    if (i == 0) {
-      // Input was too large.
-      OPENSSL_PUT_ERROR(EC, ERR_R_INTERNAL_ERROR);
-      return 0;
+    uint8_t dst_len_u8 = (uint8_t)dst_len;
+
+    // Compute b_0.
+    static const uint8_t kZeros[EVP_MAX_MD_BLOCK_SIZE] = {0};
+    // If |out_len| exceeds 16 bits then |i| will wrap below causing an error to
+    // be returned. This depends on the static assert above.
+    uint8_t l_i_b_str_zero[3] = {static_cast<uint8_t>(out_len >> 8),
+                                 static_cast<uint8_t>(out_len), 0};
+    uint8_t b_0[EVP_MAX_MD_SIZE];
+    if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
+        !EVP_DigestUpdate(&ctx, kZeros, block_size) ||
+        !EVP_DigestUpdate(&ctx, msg, msg_len) ||
+        !EVP_DigestUpdate(&ctx, l_i_b_str_zero, sizeof(l_i_b_str_zero)) ||
+        !EVP_DigestUpdate(&ctx, dst, dst_len) ||
+        !EVP_DigestUpdate(&ctx, &dst_len_u8, 1) ||
+        !EVP_DigestFinal_ex(&ctx, b_0, NULL)) {
+      goto err;
     }
-    if (i > 1) {
-      for (size_t j = 0; j < md_size; j++) {
-        b_i[j] ^= b_0[j];
+
+    uint8_t b_i[EVP_MAX_MD_SIZE];
+    uint8_t i = 1;
+    while (out_len > 0) {
+      if (i == 0) {
+        // Input was too large.
+        OPENSSL_PUT_ERROR(EC, ERR_R_INTERNAL_ERROR);
+        goto err;
+      }
+      if (i > 1) {
+        for (size_t j = 0; j < md_size; j++) {
+          b_i[j] ^= b_0[j];
+        }
+      } else {
+        OPENSSL_memcpy(b_i, b_0, md_size);
       }
-    } else {
-      OPENSSL_memcpy(b_i, b_0, md_size);
-    }
 
-    if (!EVP_DigestInit_ex(ctx.get(), md, nullptr) ||
-        !EVP_DigestUpdate(ctx.get(), b_i, md_size) ||
-        !EVP_DigestUpdate(ctx.get(), &i, 1) ||
-        !EVP_DigestUpdate(ctx.get(), dst, dst_len) ||
-        !EVP_DigestUpdate(ctx.get(), &dst_len_u8, 1) ||
-        !EVP_DigestFinal_ex(ctx.get(), b_i, nullptr)) {
-      return 0;
+      if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
+          !EVP_DigestUpdate(&ctx, b_i, md_size) ||
+          !EVP_DigestUpdate(&ctx, &i, 1) ||
+          !EVP_DigestUpdate(&ctx, dst, dst_len) ||
+          !EVP_DigestUpdate(&ctx, &dst_len_u8, 1) ||
+          !EVP_DigestFinal_ex(&ctx, b_i, NULL)) {
+        goto err;
+      }
+
+      size_t todo = out_len >= md_size ? md_size : out_len;
+      OPENSSL_memcpy(out, b_i, todo);
+      out += todo;
+      out_len -= todo;
+      i++;
     }
 
-    size_t todo = out_len >= md_size ? md_size : out_len;
-    OPENSSL_memcpy(out, b_i, todo);
-    out += todo;
-    out_len -= todo;
-    i++;
+    ret = 1;
   }
 
-  return 1;
+err:
+  EVP_MD_CTX_cleanup(&ctx);
+  return ret;
 }
 
 // num_bytes_to_derive determines the number of bytes to derive when hashing to

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/ecdsa/ecdsa_asn1.cc

@@ -88,20 +88,25 @@ int ECDSA_sign(int type, const uint8_t *digest, size_t digest_len, uint8_t *sig,
 
   // TODO(davidben): We can actually do better and go straight from the DER
   // format to the fixed-width format without a malloc.
-  bssl::UniquePtr<ECDSA_SIG> s(ecdsa_sig_from_fixed(eckey, fixed, fixed_len));
-  if (s == nullptr) {
+  ECDSA_SIG *s = ecdsa_sig_from_fixed(eckey, fixed, fixed_len);
+  if (s == NULL) {
     return 0;
   }
 
+  int ret = 0;
   CBB cbb;
   CBB_init_fixed(&cbb, sig, ECDSA_size(eckey));
   size_t len;
-  if (!ECDSA_SIG_marshal(&cbb, s.get()) || !CBB_finish(&cbb, nullptr, &len)) {
+  if (!ECDSA_SIG_marshal(&cbb, s) || !CBB_finish(&cbb, NULL, &len)) {
     OPENSSL_PUT_ERROR(ECDSA, ECDSA_R_ENCODE_ERROR);
-    return 0;
+    goto err;
   }
-  *out_sig_len = static_cast<unsigned>(len);
-  return 1;
+  *out_sig_len = (unsigned)len;
+  ret = 1;
+
+err:
+  ECDSA_SIG_free(s);
+  return ret;
 }
 
 int ECDSA_verify(int type, const uint8_t *digest, size_t digest_len,
@@ -111,15 +116,15 @@ int ECDSA_verify(int type, const uint8_t *digest, size_t digest_len,
   // TODO(davidben): We can actually do better and go straight from the DER
   // format to the fixed-width format without a malloc.
   int ret = 0;
-  uint8_t *der = nullptr;
-  bssl::UniquePtr<ECDSA_SIG> s(ECDSA_SIG_from_bytes(sig, sig_len));
-  if (s == nullptr) {
+  uint8_t *der = NULL;
+  ECDSA_SIG *s = ECDSA_SIG_from_bytes(sig, sig_len);
+  if (s == NULL) {
     goto err;
   }
 
   // Defend against potential laxness in the DER parser.
   size_t der_len;
-  if (!ECDSA_SIG_to_bytes(&der, &der_len, s.get()) || der_len != sig_len ||
+  if (!ECDSA_SIG_to_bytes(&der, &der_len, s) || der_len != sig_len ||
       OPENSSL_memcmp(sig, der, sig_len) != 0) {
     // This should never happen. crypto/bytestring is strictly DER.
     OPENSSL_PUT_ERROR(ECDSA, ERR_R_INTERNAL_ERROR);
@@ -128,11 +133,12 @@ int ECDSA_verify(int type, const uint8_t *digest, size_t digest_len,
 
   uint8_t fixed[ECDSA_MAX_FIXED_LEN];
   size_t fixed_len;
-  ret = ecdsa_sig_to_fixed(eckey, fixed, &fixed_len, sizeof(fixed), s.get()) &&
+  ret = ecdsa_sig_to_fixed(eckey, fixed, &fixed_len, sizeof(fixed), s) &&
         ecdsa_verify_fixed(digest, digest_len, fixed, fixed_len, eckey);
 
 err:
   OPENSSL_free(der);
+  ECDSA_SIG_free(s);
   return ret;
 }
 

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/evp/evp_asn1.cc

@@ -435,24 +435,25 @@ int i2d_DSA_PUBKEY(const DSA *dsa, uint8_t **outp) {
 
 EC_KEY *d2i_EC_PUBKEY(EC_KEY **out, const uint8_t **inp, long len) {
   if (len < 0) {
-    return nullptr;
+    return NULL;
   }
   CBS cbs;
   CBS_init(&cbs, *inp, (size_t)len);
-  bssl::UniquePtr<EVP_PKEY> pkey(EVP_parse_public_key(&cbs));
-  if (pkey == nullptr) {
-    return nullptr;
+  EVP_PKEY *pkey = EVP_parse_public_key(&cbs);
+  if (pkey == NULL) {
+    return NULL;
   }
-  bssl::UniquePtr<EC_KEY> ec_key(EVP_PKEY_get1_EC_KEY(pkey.get()));
-  if (ec_key == nullptr) {
-    return nullptr;
+  EC_KEY *ec_key = EVP_PKEY_get1_EC_KEY(pkey);
+  EVP_PKEY_free(pkey);
+  if (ec_key == NULL) {
+    return NULL;
   }
-  if (out != nullptr) {
+  if (out != NULL) {
     EC_KEY_free(*out);
-    *out = ec_key.get();
+    *out = ec_key;
   }
   *inp = CBS_data(&cbs);
-  return ec_key.release();
+  return ec_key;
 }
 
 int i2d_EC_PUBKEY(const EC_KEY *ec_key, uint8_t **outp) {

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/evp/evp_ctx.cc

@@ -108,36 +108,37 @@ void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx) {
 
 EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx) {
   if (!ctx->pmeth || !ctx->pmeth->copy) {
-    return nullptr;
+    return NULL;
   }
 
-  bssl::UniquePtr<EVP_PKEY_CTX> ret(
-      reinterpret_cast<EVP_PKEY_CTX *>(OPENSSL_zalloc(sizeof(EVP_PKEY_CTX))));
+  EVP_PKEY_CTX *ret =
+      reinterpret_cast<EVP_PKEY_CTX *>(OPENSSL_zalloc(sizeof(EVP_PKEY_CTX)));
   if (!ret) {
-    return nullptr;
+    return NULL;
   }
 
   ret->pmeth = ctx->pmeth;
   ret->engine = ctx->engine;
   ret->operation = ctx->operation;
 
-  if (ctx->pkey != nullptr) {
+  if (ctx->pkey != NULL) {
     EVP_PKEY_up_ref(ctx->pkey);
     ret->pkey = ctx->pkey;
   }
 
-  if (ctx->peerkey != nullptr) {
+  if (ctx->peerkey != NULL) {
     EVP_PKEY_up_ref(ctx->peerkey);
     ret->peerkey = ctx->peerkey;
   }
 
-  if (ctx->pmeth->copy(ret.get(), ctx) <= 0) {
-    ret->pmeth = nullptr;
+  if (ctx->pmeth->copy(ret, ctx) <= 0) {
+    ret->pmeth = NULL;
+    EVP_PKEY_CTX_free(ret);
     OPENSSL_PUT_ERROR(EVP, ERR_LIB_EVP);
-    return nullptr;
+    return NULL;
   }
 
-  return ret.release();
+  return ret;
 }
 
 EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx) { return ctx->pkey; }

data/third_party/boringssl-with-bazel/{src/crypto → crypto}/evp/p_dsa_asn1.cc

@@ -62,11 +62,11 @@ static int dsa_pub_encode(CBB *out, const EVP_PKEY *key) {
       dsa->p != nullptr && dsa->q != nullptr && dsa->g != nullptr;
 
   // See RFC 5480, section 2.
-  CBB spki, algorithm, key_bitstring;
+  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_element(&algorithm, CBS_ASN1_OBJECT, dsa_asn1_meth.oid,
-                            dsa_asn1_meth.oid_len) ||
+      !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 */) ||
@@ -126,12 +126,12 @@ static int dsa_priv_encode(CBB *out, const EVP_PKEY *key) {
   }
 
   // See PKCS#11, v2.40, section 2.5.
-  CBB pkcs8, algorithm, private_key;
+  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_element(&algorithm, CBS_ASN1_OBJECT, dsa_asn1_meth.oid,
-                            dsa_asn1_meth.oid_len) ||
+      !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)) {