grpc 1.53.0 → 1.54.2

data/third_party/boringssl-with-bazel/src/crypto/x509/x509spki.c

@@ -61,77 +61,73 @@
 #include <openssl/mem.h>
 #include <openssl/x509.h>
 
-int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey)
-{
-    if ((x == NULL) || (x->spkac == NULL))
-        return (0);
-    return (X509_PUBKEY_set(&(x->spkac->pubkey), pkey));
+int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey) {
+  if ((x == NULL) || (x->spkac == NULL)) {
+    return 0;
+  }
+  return (X509_PUBKEY_set(&(x->spkac->pubkey), pkey));
 }
 
-EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x)
-{
-    if ((x == NULL) || (x->spkac == NULL))
-        return (NULL);
-    return (X509_PUBKEY_get(x->spkac->pubkey));
+EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x) {
+  if ((x == NULL) || (x->spkac == NULL)) {
+    return NULL;
+  }
+  return (X509_PUBKEY_get(x->spkac->pubkey));
 }
 
-/* Load a Netscape SPKI from a base64 encoded string */
+// Load a Netscape SPKI from a base64 encoded string
 
-NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len)
-{
-    unsigned char *spki_der;
-    const unsigned char *p;
-    size_t spki_len;
-    NETSCAPE_SPKI *spki;
-    if (len <= 0)
-        len = strlen(str);
-    if (!EVP_DecodedLength(&spki_len, len)) {
-        OPENSSL_PUT_ERROR(X509, X509_R_BASE64_DECODE_ERROR);
-        return NULL;
-    }
-    if (!(spki_der = OPENSSL_malloc(spki_len))) {
-        OPENSSL_PUT_ERROR(X509, ERR_R_MALLOC_FAILURE);
-        return NULL;
-    }
-    if (!EVP_DecodeBase64
-        (spki_der, &spki_len, spki_len, (const uint8_t *)str, len)) {
-        OPENSSL_PUT_ERROR(X509, X509_R_BASE64_DECODE_ERROR);
-        OPENSSL_free(spki_der);
-        return NULL;
-    }
-    p = spki_der;
-    spki = d2i_NETSCAPE_SPKI(NULL, &p, spki_len);
+NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len) {
+  unsigned char *spki_der;
+  const unsigned char *p;
+  size_t spki_len;
+  NETSCAPE_SPKI *spki;
+  if (len <= 0) {
+    len = strlen(str);
+  }
+  if (!EVP_DecodedLength(&spki_len, len)) {
+    OPENSSL_PUT_ERROR(X509, X509_R_BASE64_DECODE_ERROR);
+    return NULL;
+  }
+  if (!(spki_der = OPENSSL_malloc(spki_len))) {
+    return NULL;
+  }
+  if (!EVP_DecodeBase64(spki_der, &spki_len, spki_len, (const uint8_t *)str,
+                        len)) {
+    OPENSSL_PUT_ERROR(X509, X509_R_BASE64_DECODE_ERROR);
     OPENSSL_free(spki_der);
-    return spki;
+    return NULL;
+  }
+  p = spki_der;
+  spki = d2i_NETSCAPE_SPKI(NULL, &p, spki_len);
+  OPENSSL_free(spki_der);
+  return spki;
 }
 
-/* Generate a base64 encoded string from an SPKI */
+// Generate a base64 encoded string from an SPKI
 
-char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki)
-{
-    unsigned char *der_spki, *p;
-    char *b64_str;
-    size_t b64_len;
-    int der_len;
-    der_len = i2d_NETSCAPE_SPKI(spki, NULL);
-    if (!EVP_EncodedLength(&b64_len, der_len)) {
-        OPENSSL_PUT_ERROR(X509, ERR_R_OVERFLOW);
-        return NULL;
-    }
-    der_spki = OPENSSL_malloc(der_len);
-    if (der_spki == NULL) {
-        OPENSSL_PUT_ERROR(X509, ERR_R_MALLOC_FAILURE);
-        return NULL;
-    }
-    b64_str = OPENSSL_malloc(b64_len);
-    if (b64_str == NULL) {
-        OPENSSL_free(der_spki);
-        OPENSSL_PUT_ERROR(X509, ERR_R_MALLOC_FAILURE);
-        return NULL;
-    }
-    p = der_spki;
-    i2d_NETSCAPE_SPKI(spki, &p);
-    EVP_EncodeBlock((unsigned char *)b64_str, der_spki, der_len);
+char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki) {
+  unsigned char *der_spki, *p;
+  char *b64_str;
+  size_t b64_len;
+  int der_len;
+  der_len = i2d_NETSCAPE_SPKI(spki, NULL);
+  if (!EVP_EncodedLength(&b64_len, der_len)) {
+    OPENSSL_PUT_ERROR(X509, ERR_R_OVERFLOW);
+    return NULL;
+  }
+  der_spki = OPENSSL_malloc(der_len);
+  if (der_spki == NULL) {
+    return NULL;
+  }
+  b64_str = OPENSSL_malloc(b64_len);
+  if (b64_str == NULL) {
     OPENSSL_free(der_spki);
-    return b64_str;
+    return NULL;
+  }
+  p = der_spki;
+  i2d_NETSCAPE_SPKI(spki, &p);
+  EVP_EncodeBlock((unsigned char *)b64_str, der_spki, der_len);
+  OPENSSL_free(der_spki);
+  return b64_str;
 }

data/third_party/boringssl-with-bazel/src/crypto/x509/x_algor.c

@@ -65,89 +65,85 @@
 
 
 ASN1_SEQUENCE(X509_ALGOR) = {
-        ASN1_SIMPLE(X509_ALGOR, algorithm, ASN1_OBJECT),
-        ASN1_OPT(X509_ALGOR, parameter, ASN1_ANY)
+    ASN1_SIMPLE(X509_ALGOR, algorithm, ASN1_OBJECT),
+    ASN1_OPT(X509_ALGOR, parameter, ASN1_ANY),
 } ASN1_SEQUENCE_END(X509_ALGOR)
 
-ASN1_ITEM_TEMPLATE(X509_ALGORS) =
-        ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, algorithms, X509_ALGOR)
-ASN1_ITEM_TEMPLATE_END(X509_ALGORS)
+IMPLEMENT_ASN1_FUNCTIONS_const(X509_ALGOR)
+IMPLEMENT_ASN1_DUP_FUNCTION_const(X509_ALGOR)
 
-IMPLEMENT_ASN1_FUNCTIONS(X509_ALGOR)
-IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(X509_ALGORS, X509_ALGORS, X509_ALGORS)
-IMPLEMENT_ASN1_DUP_FUNCTION(X509_ALGOR)
-
-int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval)
-{
-    if (!alg)
-        return 0;
-    if (ptype != V_ASN1_UNDEF) {
-        if (alg->parameter == NULL)
-            alg->parameter = ASN1_TYPE_new();
-        if (alg->parameter == NULL)
-            return 0;
+int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval) {
+  if (!alg) {
+    return 0;
+  }
+  if (ptype != V_ASN1_UNDEF) {
+    if (alg->parameter == NULL) {
+      alg->parameter = ASN1_TYPE_new();
     }
-    if (alg) {
-        ASN1_OBJECT_free(alg->algorithm);
-        alg->algorithm = aobj;
+    if (alg->parameter == NULL) {
+      return 0;
     }
-    if (ptype == 0)
-        return 1;
-    if (ptype == V_ASN1_UNDEF) {
-        if (alg->parameter) {
-            ASN1_TYPE_free(alg->parameter);
-            alg->parameter = NULL;
-        }
-    } else
-        ASN1_TYPE_set(alg->parameter, ptype, pval);
+  }
+  if (alg) {
+    ASN1_OBJECT_free(alg->algorithm);
+    alg->algorithm = aobj;
+  }
+  if (ptype == 0) {
     return 1;
+  }
+  if (ptype == V_ASN1_UNDEF) {
+    if (alg->parameter) {
+      ASN1_TYPE_free(alg->parameter);
+      alg->parameter = NULL;
+    }
+  } else {
+    ASN1_TYPE_set(alg->parameter, ptype, pval);
+  }
+  return 1;
 }
 
 void X509_ALGOR_get0(const ASN1_OBJECT **out_obj, int *out_param_type,
-                     const void **out_param_value, const X509_ALGOR *alg)
-{
-    if (out_obj != NULL) {
-        *out_obj = alg->algorithm;
+                     const void **out_param_value, const X509_ALGOR *alg) {
+  if (out_obj != NULL) {
+    *out_obj = alg->algorithm;
+  }
+  if (out_param_type != NULL) {
+    int type = V_ASN1_UNDEF;
+    const void *value = NULL;
+    if (alg->parameter != NULL) {
+      type = alg->parameter->type;
+      value = asn1_type_value_as_pointer(alg->parameter);
     }
-    if (out_param_type != NULL) {
-        int type = V_ASN1_UNDEF;
-        const void *value = NULL;
-        if (alg->parameter != NULL) {
-            type = alg->parameter->type;
-            value = asn1_type_value_as_pointer(alg->parameter);
-        }
-        *out_param_type = type;
-        if (out_param_value != NULL) {
-            *out_param_value = value;
-        }
+    *out_param_type = type;
+    if (out_param_value != NULL) {
+      *out_param_value = value;
     }
+  }
 }
 
-/* Set up an X509_ALGOR DigestAlgorithmIdentifier from an EVP_MD */
-
-void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md)
-{
-    int param_type;
+// Set up an X509_ALGOR DigestAlgorithmIdentifier from an EVP_MD
 
-    if (EVP_MD_flags(md) & EVP_MD_FLAG_DIGALGID_ABSENT)
-        param_type = V_ASN1_UNDEF;
-    else
-        param_type = V_ASN1_NULL;
+void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md) {
+  int param_type;
 
-    X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), param_type, NULL);
+  if (EVP_MD_flags(md) & EVP_MD_FLAG_DIGALGID_ABSENT) {
+    param_type = V_ASN1_UNDEF;
+  } else {
+    param_type = V_ASN1_NULL;
+  }
 
+  X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), param_type, NULL);
 }
 
-/*
- * X509_ALGOR_cmp returns 0 if |a| and |b| are equal and non-zero otherwise.
- */
-int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b)
-{
-    int rv;
-    rv = OBJ_cmp(a->algorithm, b->algorithm);
-    if (rv)
-        return rv;
-    if (!a->parameter && !b->parameter)
-        return 0;
-    return ASN1_TYPE_cmp(a->parameter, b->parameter);
+// X509_ALGOR_cmp returns 0 if |a| and |b| are equal and non-zero otherwise.
+int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b) {
+  int rv;
+  rv = OBJ_cmp(a->algorithm, b->algorithm);
+  if (rv) {
+    return rv;
+  }
+  if (!a->parameter && !b->parameter) {
+    return 0;
+  }
+  return ASN1_TYPE_cmp(a->parameter, b->parameter);
 }

data/third_party/boringssl-with-bazel/src/crypto/x509/x_all.c

@@ -66,138 +66,100 @@
 #include <openssl/rsa.h>
 #include <openssl/stack.h>
 
+#include "../asn1/internal.h"
 #include "internal.h"
 
 
-int X509_verify(X509 *x509, EVP_PKEY *pkey)
-{
-    if (X509_ALGOR_cmp(x509->sig_alg, x509->cert_info->signature)) {
-        OPENSSL_PUT_ERROR(X509, X509_R_SIGNATURE_ALGORITHM_MISMATCH);
-        return 0;
-    }
-    return ASN1_item_verify(ASN1_ITEM_rptr(X509_CINF), x509->sig_alg,
-                            x509->signature, x509->cert_info, pkey);
-}
-
-int X509_REQ_verify(X509_REQ *req, EVP_PKEY *pkey)
-{
-    return ASN1_item_verify(ASN1_ITEM_rptr(X509_REQ_INFO),
-                            req->sig_alg, req->signature, req->req_info, pkey);
-}
-
-int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
-{
-    x->cert_info->enc.modified = 1;
-    return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), x->cert_info->signature,
-                           x->sig_alg, x->signature, x->cert_info, pkey, md));
-}
-
-int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
-{
-    x->cert_info->enc.modified = 1;
-    return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF),
-                              x->cert_info->signature,
-                              x->sig_alg, x->signature, x->cert_info, ctx);
-}
-
-int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
-{
-    return (ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO), x->sig_alg, NULL,
-                           x->signature, x->req_info, pkey, md));
+int X509_verify(X509 *x509, EVP_PKEY *pkey) {
+  if (X509_ALGOR_cmp(x509->sig_alg, x509->cert_info->signature)) {
+    OPENSSL_PUT_ERROR(X509, X509_R_SIGNATURE_ALGORITHM_MISMATCH);
+    return 0;
+  }
+  return ASN1_item_verify(ASN1_ITEM_rptr(X509_CINF), x509->sig_alg,
+                          x509->signature, x509->cert_info, pkey);
 }
 
-int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
-{
-    return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO),
-                              x->sig_alg, NULL, x->signature, x->req_info,
-                              ctx);
+int X509_REQ_verify(X509_REQ *req, EVP_PKEY *pkey) {
+  return ASN1_item_verify(ASN1_ITEM_rptr(X509_REQ_INFO), req->sig_alg,
+                          req->signature, req->req_info, pkey);
 }
 
-int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
-{
-    x->crl->enc.modified = 1;
-    return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO), x->crl->sig_alg,
-                           x->sig_alg, x->signature, x->crl, pkey, md));
+int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md) {
+  asn1_encoding_clear(&x->cert_info->enc);
+  return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CINF), x->cert_info->signature,
+                         x->sig_alg, x->signature, x->cert_info, pkey, md));
 }
 
-int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
-{
-    x->crl->enc.modified = 1;
-    return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO),
-                              x->crl->sig_alg, x->sig_alg, x->signature,
-                              x->crl, ctx);
+int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx) {
+  asn1_encoding_clear(&x->cert_info->enc);
+  return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CINF), x->cert_info->signature,
+                            x->sig_alg, x->signature, x->cert_info, ctx);
 }
 
-int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
-{
-    return (ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), x->sig_algor, NULL,
-                           x->signature, x->spkac, pkey, md));
+int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md) {
+  asn1_encoding_clear(&x->req_info->enc);
+  return (ASN1_item_sign(ASN1_ITEM_rptr(X509_REQ_INFO), x->sig_alg, NULL,
+                         x->signature, x->req_info, pkey, md));
 }
 
-int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *spki, EVP_PKEY *pkey)
-{
-    return (ASN1_item_verify(ASN1_ITEM_rptr(NETSCAPE_SPKAC), spki->sig_algor,
-                             spki->signature, spki->spkac, pkey));
+int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx) {
+  asn1_encoding_clear(&x->req_info->enc);
+  return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_REQ_INFO), x->sig_alg, NULL,
+                            x->signature, x->req_info, ctx);
 }
 
-X509 *d2i_X509_fp(FILE *fp, X509 **x509)
-{
-    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509), fp, x509);
+int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md) {
+  asn1_encoding_clear(&x->crl->enc);
+  return (ASN1_item_sign(ASN1_ITEM_rptr(X509_CRL_INFO), x->crl->sig_alg,
+                         x->sig_alg, x->signature, x->crl, pkey, md));
 }
 
-int i2d_X509_fp(FILE *fp, X509 *x509)
-{
-    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509), fp, x509);
+int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx) {
+  asn1_encoding_clear(&x->crl->enc);
+  return ASN1_item_sign_ctx(ASN1_ITEM_rptr(X509_CRL_INFO), x->crl->sig_alg,
+                            x->sig_alg, x->signature, x->crl, ctx);
 }
 
-X509 *d2i_X509_bio(BIO *bp, X509 **x509)
-{
-    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509), bp, x509);
+int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md) {
+  return (ASN1_item_sign(ASN1_ITEM_rptr(NETSCAPE_SPKAC), x->sig_algor, NULL,
+                         x->signature, x->spkac, pkey, md));
 }
 
-int i2d_X509_bio(BIO *bp, X509 *x509)
-{
-    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509), bp, x509);
+int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *spki, EVP_PKEY *pkey) {
+  return (ASN1_item_verify(ASN1_ITEM_rptr(NETSCAPE_SPKAC), spki->sig_algor,
+                           spki->signature, spki->spkac, pkey));
 }
 
-X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
-{
-    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
+X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl) {
+  return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
 }
 
-int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
-{
-    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
+int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl) {
+  return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_CRL), fp, crl);
 }
 
-X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
-{
-    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
+X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl) {
+  return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
 }
 
-int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
-{
-    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
+int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl) {
+  return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_CRL), bp, crl);
 }
 
-X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
-{
-    return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
+X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req) {
+  return ASN1_item_d2i_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
 }
 
-int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
-{
-    return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
+int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req) {
+  return ASN1_item_i2d_fp(ASN1_ITEM_rptr(X509_REQ), fp, req);
 }
 
-X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
-{
-    return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
+X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req) {
+  return ASN1_item_d2i_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
 }
 
-int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
-{
-    return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
+int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req) {
+  return ASN1_item_i2d_bio(ASN1_ITEM_rptr(X509_REQ), bp, req);
 }
 
 
@@ -223,6 +185,9 @@ int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
     return ret;                                \
   }
 
+IMPLEMENT_D2I_FP(X509, d2i_X509_fp, d2i_X509_bio);
+IMPLEMENT_I2D_FP(X509, i2d_X509_fp, i2d_X509_bio);
+
 IMPLEMENT_D2I_FP(RSA, d2i_RSAPrivateKey_fp, d2i_RSAPrivateKey_bio)
 IMPLEMENT_I2D_FP(RSA, i2d_RSAPrivateKey_fp, i2d_RSAPrivateKey_bio)
 
@@ -257,6 +222,9 @@ IMPLEMENT_I2D_FP(RSA, i2d_RSA_PUBKEY_fp, i2d_RSA_PUBKEY_bio)
     return ret;                                 \
   }
 
+IMPLEMENT_D2I_BIO(X509, d2i_X509_bio, d2i_X509)
+IMPLEMENT_I2D_BIO(X509, i2d_X509_bio, i2d_X509)
+
 IMPLEMENT_D2I_BIO(RSA, d2i_RSAPrivateKey_bio, d2i_RSAPrivateKey)
 IMPLEMENT_I2D_BIO(RSA, i2d_RSAPrivateKey_bio, i2d_RSAPrivateKey)
 
@@ -266,7 +234,6 @@ IMPLEMENT_I2D_BIO(RSA, i2d_RSAPublicKey_bio, i2d_RSAPublicKey)
 IMPLEMENT_D2I_BIO(RSA, d2i_RSA_PUBKEY_bio, d2i_RSA_PUBKEY)
 IMPLEMENT_I2D_BIO(RSA, i2d_RSA_PUBKEY_bio, i2d_RSA_PUBKEY)
 
-#ifndef OPENSSL_NO_DSA
 IMPLEMENT_D2I_FP(DSA, d2i_DSAPrivateKey_fp, d2i_DSAPrivateKey_bio)
 IMPLEMENT_I2D_FP(DSA, i2d_DSAPrivateKey_fp, i2d_DSAPrivateKey_bio)
 
@@ -278,7 +245,6 @@ IMPLEMENT_I2D_BIO(DSA, i2d_DSAPrivateKey_bio, i2d_DSAPrivateKey)
 
 IMPLEMENT_D2I_BIO(DSA, d2i_DSA_PUBKEY_bio, d2i_DSA_PUBKEY)
 IMPLEMENT_I2D_BIO(DSA, i2d_DSA_PUBKEY_bio, i2d_DSA_PUBKEY)
-#endif
 
 IMPLEMENT_D2I_FP(EC_KEY, d2i_ECPrivateKey_fp, d2i_ECPrivateKey_bio)
 IMPLEMENT_I2D_FP(EC_KEY, i2d_ECPrivateKey_fp, i2d_ECPrivateKey_bio)
@@ -292,42 +258,46 @@ IMPLEMENT_I2D_BIO(EC_KEY, i2d_ECPrivateKey_bio, i2d_ECPrivateKey)
 IMPLEMENT_D2I_BIO(EC_KEY, d2i_EC_PUBKEY_bio, d2i_EC_PUBKEY)
 IMPLEMENT_I2D_BIO(EC_KEY, i2d_EC_PUBKEY_bio, i2d_EC_PUBKEY)
 
-int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
-                       unsigned char *md, unsigned int *len)
-{
-    ASN1_BIT_STRING *key;
-    key = X509_get0_pubkey_bitstr(data);
-    if (!key)
-        return 0;
-    return EVP_Digest(key->data, key->length, md, len, type, NULL);
+int X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
+                       unsigned int *len) {
+  ASN1_BIT_STRING *key;
+  key = X509_get0_pubkey_bitstr(data);
+  if (!key) {
+    return 0;
+  }
+  return EVP_Digest(key->data, key->length, md, len, type, NULL);
 }
 
-int X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
-                unsigned int *len)
-{
-    return (ASN1_item_digest
-            (ASN1_ITEM_rptr(X509), type, (char *)data, md, len));
+int X509_digest(const X509 *x509, const EVP_MD *md, uint8_t *out,
+                unsigned *out_len) {
+  uint8_t *der = NULL;
+  // TODO(https://crbug.com/boringssl/407): This function is not const-correct.
+  int der_len = i2d_X509((X509 *)x509, &der);
+  if (der_len < 0) {
+    return 0;
+  }
+
+  int ret = EVP_Digest(der, der_len, out, out_len, md, NULL);
+  OPENSSL_free(der);
+  return ret;
 }
 
-int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
-                    unsigned char *md, unsigned int *len)
-{
-    return (ASN1_item_digest
-            (ASN1_ITEM_rptr(X509_CRL), type, (char *)data, md, len));
+int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
+                    unsigned int *len) {
+  return (
+      ASN1_item_digest(ASN1_ITEM_rptr(X509_CRL), type, (char *)data, md, len));
 }
 
-int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
-                    unsigned char *md, unsigned int *len)
-{
-    return (ASN1_item_digest
-            (ASN1_ITEM_rptr(X509_REQ), type, (char *)data, md, len));
+int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
+                    unsigned int *len) {
+  return (
+      ASN1_item_digest(ASN1_ITEM_rptr(X509_REQ), type, (char *)data, md, len));
 }
 
 int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
-                     unsigned char *md, unsigned int *len)
-{
-    return (ASN1_item_digest
-            (ASN1_ITEM_rptr(X509_NAME), type, (char *)data, md, len));
+                     unsigned char *md, unsigned int *len) {
+  return (
+      ASN1_item_digest(ASN1_ITEM_rptr(X509_NAME), type, (char *)data, md, len));
 }
 
 IMPLEMENT_D2I_FP(X509_SIG, d2i_PKCS8_fp, d2i_PKCS8_bio)
@@ -341,16 +311,16 @@ IMPLEMENT_D2I_FP(PKCS8_PRIV_KEY_INFO, d2i_PKCS8_PRIV_KEY_INFO_fp,
 IMPLEMENT_I2D_FP(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO_fp,
                  i2d_PKCS8_PRIV_KEY_INFO_bio)
 
-int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
-{
-    PKCS8_PRIV_KEY_INFO *p8inf;
-    int ret;
-    p8inf = EVP_PKEY2PKCS8(key);
-    if (!p8inf)
-        return 0;
-    ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
-    PKCS8_PRIV_KEY_INFO_free(p8inf);
-    return ret;
+int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key) {
+  PKCS8_PRIV_KEY_INFO *p8inf;
+  int ret;
+  p8inf = EVP_PKEY2PKCS8(key);
+  if (!p8inf) {
+    return 0;
+  }
+  ret = i2d_PKCS8_PRIV_KEY_INFO_fp(fp, p8inf);
+  PKCS8_PRIV_KEY_INFO_free(p8inf);
+  return ret;
 }
 
 IMPLEMENT_D2I_FP(EVP_PKEY, d2i_PrivateKey_fp, d2i_PrivateKey_bio)
@@ -364,16 +334,16 @@ IMPLEMENT_D2I_BIO(PKCS8_PRIV_KEY_INFO, d2i_PKCS8_PRIV_KEY_INFO_bio,
 IMPLEMENT_I2D_BIO(PKCS8_PRIV_KEY_INFO, i2d_PKCS8_PRIV_KEY_INFO_bio,
                   i2d_PKCS8_PRIV_KEY_INFO)
 
-int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
-{
-    PKCS8_PRIV_KEY_INFO *p8inf;
-    int ret;
-    p8inf = EVP_PKEY2PKCS8(key);
-    if (!p8inf)
-        return 0;
-    ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
-    PKCS8_PRIV_KEY_INFO_free(p8inf);
-    return ret;
+int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key) {
+  PKCS8_PRIV_KEY_INFO *p8inf;
+  int ret;
+  p8inf = EVP_PKEY2PKCS8(key);
+  if (!p8inf) {
+    return 0;
+  }
+  ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
+  PKCS8_PRIV_KEY_INFO_free(p8inf);
+  return ret;
 }
 
 IMPLEMENT_D2I_BIO(EVP_PKEY, d2i_PrivateKey_bio, d2i_AutoPrivateKey)