grpc 1.84.0 → 1.85.0.pre1

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

@@ -16,152 +16,177 @@
 
 #include <string.h>
 
+#include <array>
+
 #include <openssl/bytestring.h>
 #include <openssl/dsa.h>
 #include <openssl/ec_key.h>
 #include <openssl/err.h>
 #include <openssl/rsa.h>
+#include <openssl/span.h>
 
-#include "internal.h"
 #include "../bytestring/internal.h"
 #include "../internal.h"
+#include "../mem_internal.h"
+#include "internal.h"
 
 
-// We intentionally omit |dh_asn1_meth| from this list. It is not serializable.
-static const EVP_PKEY_ASN1_METHOD *const kASN1Methods[] = {
-    &rsa_asn1_meth,
-    &ec_asn1_meth,
-    &dsa_asn1_meth,
-    &ed25519_asn1_meth,
-    &x25519_asn1_meth,
-};
-
-static const EVP_PKEY_ASN1_METHOD *parse_key_type(CBS *cbs) {
-  CBS oid;
-  if (!CBS_get_asn1(cbs, &oid, CBS_ASN1_OBJECT)) {
-    return NULL;
-  }
-
-  for (unsigned i = 0; i < OPENSSL_ARRAY_SIZE(kASN1Methods); i++) {
-    const EVP_PKEY_ASN1_METHOD *method = kASN1Methods[i];
-    if (CBS_len(&oid) == method->oid_len &&
-        OPENSSL_memcmp(CBS_data(&oid), method->oid, method->oid_len) == 0) {
-      return method;
-    }
-  }
-
-  return NULL;
-}
+using namespace bssl;
 
-EVP_PKEY *EVP_parse_public_key(CBS *cbs) {
+EVP_PKEY *EVP_PKEY_from_subject_public_key_info(const uint8_t *in, size_t len,
+                                                const EVP_PKEY_ALG *const *algs,
+                                                size_t num_algs) {
   // Parse the SubjectPublicKeyInfo.
-  CBS spki, algorithm, key;
-  uint8_t padding;
-  if (!CBS_get_asn1(cbs, &spki, CBS_ASN1_SEQUENCE) ||
+  CBS cbs, spki, algorithm, oid, key;
+  CBS_init(&cbs, in, len);
+  if (!CBS_get_asn1(&cbs, &spki, CBS_ASN1_SEQUENCE) ||
       !CBS_get_asn1(&spki, &algorithm, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1(&algorithm, &oid, CBS_ASN1_OBJECT) ||
       !CBS_get_asn1(&spki, &key, CBS_ASN1_BITSTRING) ||
-      CBS_len(&spki) != 0) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return nullptr;
-  }
-  const EVP_PKEY_ASN1_METHOD *method = parse_key_type(&algorithm);
-  if (method == nullptr) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
-    return nullptr;
-  }
-  if (// Every key type defined encodes the key as a byte string with the same
-      // conversion to BIT STRING.
-      !CBS_get_u8(&key, &padding) ||
-      padding != 0) {
+      CBS_len(&spki) != 0 ||  //
+      CBS_len(&cbs) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     return nullptr;
   }
 
-  // Set up an |EVP_PKEY| of the appropriate type.
-  bssl::UniquePtr<EVP_PKEY> ret(EVP_PKEY_new());
+  UniquePtr<EvpPkey> ret(FromOpaque(EVP_PKEY_new()));
   if (ret == nullptr) {
     return nullptr;
   }
-  evp_pkey_set_method(ret.get(), method);
-
-  // Call into the type-specific SPKI decoding function.
-  if (ret->ameth->pub_decode == nullptr) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
-    return nullptr;
-  }
-  if (!ret->ameth->pub_decode(ret.get(), &algorithm, &key)) {
-    return nullptr;
+  for (const EVP_PKEY_ALG *alg : Span(algs, num_algs)) {
+    if (alg->method->pub_decode == nullptr ||
+        Span(alg->method->oid, alg->method->oid_len) != oid) {
+      continue;
+    }
+    // Every key type we support encodes the key as a byte string with the same
+    // conversion to BIT STRING, so perform that common conversion ahead of
+    // time, but only after the OID is recognized as supported.
+    CBS key_bytes = key;
+    uint8_t padding;
+    if (!CBS_get_u8(&key_bytes, &padding) || padding != 0) {
+      OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
+      return nullptr;
+    }
+    CBS params = algorithm;
+    switch (alg->method->pub_decode(alg, ret.get(), &params, &key_bytes)) {
+      case evp_decode_error:
+        return nullptr;
+      case evp_decode_ok:
+        return ret.release();
+      case evp_decode_unsupported:
+        // Continue trying other algorithms.
+        break;
+    }
   }
 
-  return ret.release();
+  OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
+  return nullptr;
 }
 
 int EVP_marshal_public_key(CBB *cbb, const EVP_PKEY *key) {
-  if (key->ameth == NULL || key->ameth->pub_encode == NULL) {
+  auto *impl = FromOpaque(key);
+  if (impl->ameth == nullptr || impl->ameth->pub_encode == nullptr) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
     return 0;
   }
+  if (impl->pkey == nullptr) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
+    return 0;
+  }
 
-  return key->ameth->pub_encode(cbb, key);
+  return impl->ameth->pub_encode(cbb, impl);
 }
 
-EVP_PKEY *EVP_parse_private_key(CBS *cbs) {
+EVP_PKEY *EVP_PKEY_from_private_key_info(const uint8_t *in, size_t len,
+                                         const EVP_PKEY_ALG *const *algs,
+                                         size_t num_algs) {
   // Parse the PrivateKeyInfo.
-  CBS pkcs8, algorithm, key;
+  CBS cbs, pkcs8, oid, algorithm, key;
   uint64_t version;
-  if (!CBS_get_asn1(cbs, &pkcs8, CBS_ASN1_SEQUENCE) ||
-      !CBS_get_asn1_uint64(&pkcs8, &version) ||
-      version != 0 ||
+  CBS_init(&cbs, in, len);
+  if (!CBS_get_asn1(&cbs, &pkcs8, CBS_ASN1_SEQUENCE) ||
+      !CBS_get_asn1_uint64(&pkcs8, &version) || version != 0 ||
       !CBS_get_asn1(&pkcs8, &algorithm, CBS_ASN1_SEQUENCE) ||
-      !CBS_get_asn1(&pkcs8, &key, CBS_ASN1_OCTETSTRING)) {
+      !CBS_get_asn1(&algorithm, &oid, CBS_ASN1_OBJECT) ||
+      !CBS_get_asn1(&pkcs8, &key, CBS_ASN1_OCTETSTRING) ||
+      // A PrivateKeyInfo ends with a SET of Attributes which we ignore.
+      CBS_len(&cbs) != 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     return nullptr;
   }
-  const EVP_PKEY_ASN1_METHOD *method = parse_key_type(&algorithm);
-  if (method == nullptr) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
-    return nullptr;
-  }
-
-  // A PrivateKeyInfo ends with a SET of Attributes which we ignore.
 
-  // Set up an |EVP_PKEY| of the appropriate type.
-  bssl::UniquePtr<EVP_PKEY> ret(EVP_PKEY_new());
+  UniquePtr<EvpPkey> ret(FromOpaque(EVP_PKEY_new()));
   if (ret == nullptr) {
     return nullptr;
   }
-  evp_pkey_set_method(ret.get(), method);
+  for (const EVP_PKEY_ALG *alg : Span(algs, num_algs)) {
+    if (alg->method->priv_decode == nullptr ||
+        Span(alg->method->oid, alg->method->oid_len) != oid) {
+      continue;
+    }
+    CBS params = algorithm, key_copy = key;
+    switch (alg->method->priv_decode(alg, ret.get(), &params, &key_copy)) {
+      case evp_decode_error:
+        return nullptr;
+      case evp_decode_ok:
+        return ret.release();
+      case evp_decode_unsupported:
+        // Continue trying other algorithms.
+        break;
+    }
+  }
 
-  // Call into the type-specific PrivateKeyInfo decoding function.
-  if (ret->ameth->priv_decode == nullptr) {
+  OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
+  return nullptr;
+}
+
+int EVP_marshal_private_key(CBB *cbb, const EVP_PKEY *key) {
+  auto *impl = FromOpaque(key);
+  if (impl->ameth == nullptr || impl->ameth->priv_encode == nullptr) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
-    return nullptr;
+    return 0;
   }
-  if (!ret->ameth->priv_decode(ret.get(), &algorithm, &key)) {
+  if (impl->pkey == nullptr) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
+    return 0;
+  }
+
+  return impl->ameth->priv_encode(cbb, impl);
+}
+
+EVP_PKEY *EVP_parse_public_key(CBS *cbs) {
+  CBS elem;
+  if (!CBS_get_asn1_element(cbs, &elem, CBS_ASN1_SEQUENCE)) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
     return nullptr;
   }
 
-  return ret.release();
+  auto algs = GetDefaultEVPAlgorithms();
+  return EVP_PKEY_from_subject_public_key_info(CBS_data(&elem), CBS_len(&elem),
+                                               algs.data(), algs.size());
 }
 
-int EVP_marshal_private_key(CBB *cbb, const EVP_PKEY *key) {
-  if (key->ameth == NULL || key->ameth->priv_encode == NULL) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
-    return 0;
+EVP_PKEY *EVP_parse_private_key(CBS *cbs) {
+  CBS elem;
+  if (!CBS_get_asn1_element(cbs, &elem, CBS_ASN1_SEQUENCE)) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
+    return nullptr;
   }
 
-  return key->ameth->priv_encode(cbb, key);
+  auto algs = GetDefaultEVPAlgorithms();
+  return EVP_PKEY_from_private_key_info(CBS_data(&elem), CBS_len(&elem),
+                                        algs.data(), algs.size());
 }
 
 static bssl::UniquePtr<EVP_PKEY> old_priv_decode(CBS *cbs, int type) {
-  bssl::UniquePtr<EVP_PKEY> ret(EVP_PKEY_new());
+  UniquePtr<EVP_PKEY> ret(EVP_PKEY_new());
   if (ret == nullptr) {
     return nullptr;
   }
 
   switch (type) {
     case EVP_PKEY_EC: {
-      bssl::UniquePtr<EC_KEY> ec_key(EC_KEY_parse_private_key(cbs, nullptr));
+      UniquePtr<EC_KEY> ec_key(EC_KEY_parse_private_key(cbs, nullptr));
       if (ec_key == nullptr) {
         return nullptr;
       }
@@ -169,7 +194,7 @@ static bssl::UniquePtr<EVP_PKEY> old_priv_decode(CBS *cbs, int type) {
       return ret;
     }
     case EVP_PKEY_DSA: {
-      bssl::UniquePtr<DSA> dsa(DSA_parse_private_key(cbs));
+      UniquePtr<DSA> dsa(DSA_parse_private_key(cbs));
       if (dsa == nullptr) {
         return nullptr;
       }
@@ -177,7 +202,7 @@ static bssl::UniquePtr<EVP_PKEY> old_priv_decode(CBS *cbs, int type) {
       return ret;
     }
     case EVP_PKEY_RSA: {
-      bssl::UniquePtr<RSA> rsa(RSA_parse_private_key(cbs));
+      UniquePtr<RSA> rsa(RSA_parse_private_key(cbs));
       if (rsa == nullptr) {
         return nullptr;
       }
@@ -192,38 +217,28 @@ static bssl::UniquePtr<EVP_PKEY> old_priv_decode(CBS *cbs, int type) {
 
 EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **out, const uint8_t **inp,
                          long len) {
-  if (len < 0) {
-    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return nullptr;
-  }
-
-  // Parse with the legacy format.
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  bssl::UniquePtr<EVP_PKEY> ret = old_priv_decode(&cbs, type);
-  if (ret == nullptr) {
-    // Try again with PKCS#8.
-    ERR_clear_error();
-    CBS_init(&cbs, *inp, (size_t)len);
-    ret.reset(EVP_parse_private_key(&cbs));
+  return D2IFromCBS(out, inp, len, [&](CBS *cbs) -> UniquePtr<EVP_PKEY> {
+    // Parse with the legacy format.
+    CBS copy = *cbs;
+    UniquePtr<EVP_PKEY> ret = old_priv_decode(cbs, type);
     if (ret == nullptr) {
-      return nullptr;
-    }
-    if (ret->type != type) {
-      OPENSSL_PUT_ERROR(EVP, EVP_R_DIFFERENT_KEY_TYPES);
-      return nullptr;
+      // Try again with PKCS#8.
+      ERR_clear_error();
+      *cbs = copy;
+      ret.reset(EVP_parse_private_key(cbs));
+      if (ret == nullptr) {
+        return nullptr;
+      }
+      if (EVP_PKEY_id(ret.get()) != type) {
+        OPENSSL_PUT_ERROR(EVP, EVP_R_DIFFERENT_KEY_TYPES);
+        return nullptr;
+      }
     }
-  }
-
-  if (out != nullptr) {
-    EVP_PKEY_free(*out);
-    *out = ret.get();
-  }
-  *inp = CBS_data(&cbs);
-  return ret.release();
+    return ret;
+  });
 }
 
-// num_elements parses one SEQUENCE from |in| and returns the number of elements
+// num_elements parses one SEQUENCE from `in` and returns the number of elements
 // in it. On parse error, it returns zero.
 static size_t num_elements(const uint8_t *in, size_t in_len) {
   CBS cbs, sequence;
@@ -235,7 +250,7 @@ static size_t num_elements(const uint8_t *in, size_t in_len) {
 
   size_t count = 0;
   while (CBS_len(&sequence) > 0) {
-    if (!CBS_get_any_asn1_element(&sequence, NULL, NULL, NULL)) {
+    if (!CBS_get_any_asn1_element(&sequence, nullptr, nullptr, nullptr)) {
       return 0;
     }
 
@@ -248,15 +263,15 @@ static size_t num_elements(const uint8_t *in, size_t in_len) {
 EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **out, const uint8_t **inp, long len) {
   if (len < 0) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
-    return NULL;
+    return nullptr;
   }
 
   // Parse the input as a PKCS#8 PrivateKeyInfo.
   CBS cbs;
   CBS_init(&cbs, *inp, (size_t)len);
   EVP_PKEY *ret = EVP_parse_private_key(&cbs);
-  if (ret != NULL) {
-    if (out != NULL) {
+  if (ret != nullptr) {
+    if (out != nullptr) {
       EVP_PKEY_free(*out);
       *out = ret;
     }
@@ -279,7 +294,7 @@ EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **out, const uint8_t **inp, long len) {
 }
 
 int i2d_PublicKey(const EVP_PKEY *key, uint8_t **outp) {
-  switch (key->type) {
+  switch (EVP_PKEY_id(key)) {
     case EVP_PKEY_RSA:
       return i2d_RSAPublicKey(EVP_PKEY_get0_RSA(key), outp);
     case EVP_PKEY_DSA:
@@ -294,93 +309,69 @@ int i2d_PublicKey(const EVP_PKEY *key, uint8_t **outp) {
 
 EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **out, const uint8_t **inp,
                         long len) {
-  bssl::UniquePtr<EVP_PKEY> ret(EVP_PKEY_new());
-  if (ret == nullptr) {
-    return nullptr;
-  }
+  return D2IFromCBS(out, inp, len, [&](CBS *cbs) -> UniquePtr<EVP_PKEY> {
+    UniquePtr<EVP_PKEY> ret(EVP_PKEY_new());
+    if (ret == nullptr) {
+      return nullptr;
+    }
+    switch (type) {
+      case EVP_PKEY_RSA: {
+        UniquePtr<RSA> rsa(RSA_parse_public_key(cbs));
+        if (rsa == nullptr) {
+          return nullptr;
+        }
+        EVP_PKEY_assign_RSA(ret.get(), rsa.release());
+        return ret;
+      }
 
-  CBS cbs;
-  CBS_init(&cbs, *inp, len < 0 ? 0 : (size_t)len);
-  switch (type) {
-    case EVP_PKEY_RSA: {
-      bssl::UniquePtr<RSA> rsa(RSA_parse_public_key(&cbs));
-      if (rsa == nullptr) {
+      // Unlike OpenSSL, we do not support EC keys with this API. The raw EC
+      // public key serialization requires knowing the group. In OpenSSL,
+      // calling this function with `EVP_PKEY_EC` and setting `out` to
+      // nullptr does not work. It requires `*out` to include a
+      // partially-initialized `EVP_PKEY` to extract the group.
+      default:
+        OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
         return nullptr;
-      }
-      EVP_PKEY_assign_RSA(ret.get(), rsa.release());
-      break;
     }
-
-    // Unlike OpenSSL, we do not support EC keys with this API. The raw EC
-    // public key serialization requires knowing the group. In OpenSSL, calling
-    // this function with |EVP_PKEY_EC| and setting |out| to nullptr does not
-    // work. It requires |*out| to include a partially-initialized |EVP_PKEY| to
-    // extract the group.
-    default:
-      OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_PUBLIC_KEY_TYPE);
-      return nullptr;
-  }
-
-  *inp = CBS_data(&cbs);
-  if (out != nullptr) {
-    EVP_PKEY_free(*out);
-    *out = ret.get();
-  }
-  return ret.release();
+  });
 }
 
 EVP_PKEY *d2i_PUBKEY(EVP_PKEY **out, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return nullptr;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  bssl::UniquePtr<EVP_PKEY> ret(EVP_parse_public_key(&cbs));
-  if (ret == nullptr) {
-    return nullptr;
-  }
-  if (out != nullptr) {
-    EVP_PKEY_free(*out);
-    *out = ret.get();
-  }
-  *inp = CBS_data(&cbs);
-  return ret.release();
+  return D2IFromCBS(out, inp, len, EVP_parse_public_key);
 }
 
 int i2d_PUBKEY(const EVP_PKEY *pkey, uint8_t **outp) {
-  if (pkey == NULL) {
+  if (pkey == nullptr) {
     return 0;
   }
+  return I2DFromCBB(
+      /*initial_capacity=*/128, outp,
+      [&](CBB *cbb) -> bool { return EVP_marshal_public_key(cbb, pkey); });
+}
 
-  CBB cbb;
-  if (!CBB_init(&cbb, 128) ||
-      !EVP_marshal_public_key(&cbb, pkey)) {
-    CBB_cleanup(&cbb);
-    return -1;
+static bssl::UniquePtr<EVP_PKEY> parse_spki(
+    CBS *cbs, Span<const EVP_PKEY_ALG *const> algs) {
+  CBS spki;
+  if (!CBS_get_asn1_element(cbs, &spki, CBS_ASN1_SEQUENCE)) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
+    return nullptr;
   }
-  return CBB_finish_i2d(&cbb, outp);
+  return UniquePtr<EVP_PKEY>(EVP_PKEY_from_subject_public_key_info(
+      CBS_data(&spki), CBS_len(&spki), algs.data(), algs.size()));
+}
+
+static bssl::UniquePtr<EVP_PKEY> parse_spki(CBS *cbs, const EVP_PKEY_ALG *alg) {
+  return parse_spki(cbs, Span(&alg, 1));
 }
 
 RSA *d2i_RSA_PUBKEY(RSA **out, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return nullptr;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  bssl::UniquePtr<EVP_PKEY> pkey(EVP_parse_public_key(&cbs));
-  if (pkey == nullptr) {
-    return nullptr;
-  }
-  bssl::UniquePtr<RSA> rsa(EVP_PKEY_get1_RSA(pkey.get()));
-  if (rsa == nullptr) {
-    return nullptr;
-  }
-  if (out != nullptr) {
-    RSA_free(*out);
-    *out = rsa.get();
-  }
-  *inp = CBS_data(&cbs);
-  return rsa.release();
+  return D2IFromCBS(out, inp, len, [](CBS *cbs) -> UniquePtr<RSA> {
+    UniquePtr<EVP_PKEY> pkey = parse_spki(cbs, EVP_pkey_rsa());
+    if (pkey == nullptr) {
+      return nullptr;
+    }
+    return UniquePtr<RSA>(EVP_PKEY_get1_RSA(pkey.get()));
+  });
 }
 
 int i2d_RSA_PUBKEY(const RSA *rsa, uint8_t **outp) {
@@ -388,7 +379,7 @@ int i2d_RSA_PUBKEY(const RSA *rsa, uint8_t **outp) {
     return 0;
   }
 
-  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
+  UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
   if (pkey == nullptr ||
       !EVP_PKEY_set1_RSA(pkey.get(), const_cast<RSA *>(rsa))) {
     return -1;
@@ -398,25 +389,13 @@ int i2d_RSA_PUBKEY(const RSA *rsa, uint8_t **outp) {
 }
 
 DSA *d2i_DSA_PUBKEY(DSA **out, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return nullptr;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  bssl::UniquePtr<EVP_PKEY> pkey(EVP_parse_public_key(&cbs));
-  if (pkey == nullptr) {
-    return nullptr;
-  }
-  bssl::UniquePtr<DSA> dsa(EVP_PKEY_get1_DSA(pkey.get()));
-  if (dsa == nullptr) {
-    return nullptr;
-  }
-  if (out != nullptr) {
-    DSA_free(*out);
-    *out = dsa.get();
-  }
-  *inp = CBS_data(&cbs);
-  return dsa.release();
+  return D2IFromCBS(out, inp, len, [](CBS *cbs) -> UniquePtr<DSA> {
+    UniquePtr<EVP_PKEY> pkey = parse_spki(cbs, EVP_pkey_dsa());
+    if (pkey == nullptr) {
+      return nullptr;
+    }
+    return UniquePtr<DSA>(EVP_PKEY_get1_DSA(pkey.get()));
+  });
 }
 
 int i2d_DSA_PUBKEY(const DSA *dsa, uint8_t **outp) {
@@ -424,7 +403,7 @@ int i2d_DSA_PUBKEY(const DSA *dsa, uint8_t **outp) {
     return 0;
   }
 
-  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
+  UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
   if (pkey == nullptr ||
       !EVP_PKEY_set1_DSA(pkey.get(), const_cast<DSA *>(dsa))) {
     return -1;
@@ -434,34 +413,23 @@ 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 NULL;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  EVP_PKEY *pkey = EVP_parse_public_key(&cbs);
-  if (pkey == NULL) {
-    return NULL;
-  }
-  EC_KEY *ec_key = EVP_PKEY_get1_EC_KEY(pkey);
-  EVP_PKEY_free(pkey);
-  if (ec_key == NULL) {
-    return NULL;
-  }
-  if (out != NULL) {
-    EC_KEY_free(*out);
-    *out = ec_key;
-  }
-  *inp = CBS_data(&cbs);
-  return ec_key;
+  return D2IFromCBS(out, inp, len, [](CBS *cbs) -> UniquePtr<EC_KEY> {
+    const EVP_PKEY_ALG *const algs[] = {EVP_pkey_ec_p224(), EVP_pkey_ec_p256(),
+                                        EVP_pkey_ec_p384(), EVP_pkey_ec_p521()};
+    UniquePtr<EVP_PKEY> pkey = parse_spki(cbs, algs);
+    if (pkey == nullptr) {
+      return nullptr;
+    }
+    return UniquePtr<EC_KEY>(EVP_PKEY_get1_EC_KEY(pkey.get()));
+  });
 }
 
 int i2d_EC_PUBKEY(const EC_KEY *ec_key, uint8_t **outp) {
-  if (ec_key == NULL) {
+  if (ec_key == nullptr) {
     return 0;
   }
 
-  bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
+  UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new());
   if (pkey == nullptr ||
       !EVP_PKEY_set1_EC_KEY(pkey.get(), const_cast<EC_KEY *>(ec_key))) {
     return -1;