grpc 1.53.1 → 1.54.0

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

@@ -9,7 +9,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -56,12 +56,13 @@
 #include <openssl/x509.h>
 
 #include <assert.h>
+#include <limits.h>
 
 #include <openssl/asn1.h>
 #include <openssl/asn1t.h>
 #include <openssl/bio.h>
-#include <openssl/evp.h>
 #include <openssl/err.h>
+#include <openssl/evp.h>
 #include <openssl/obj.h>
 
 #include "internal.h"
@@ -77,19 +78,19 @@ static int rsa_pss_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
 }
 
 ASN1_SEQUENCE_cb(RSA_PSS_PARAMS, rsa_pss_cb) = {
-  ASN1_EXP_OPT(RSA_PSS_PARAMS, hashAlgorithm, X509_ALGOR,0),
-  ASN1_EXP_OPT(RSA_PSS_PARAMS, maskGenAlgorithm, X509_ALGOR,1),
-  ASN1_EXP_OPT(RSA_PSS_PARAMS, saltLength, ASN1_INTEGER,2),
-  ASN1_EXP_OPT(RSA_PSS_PARAMS, trailerField, ASN1_INTEGER,3),
+    ASN1_EXP_OPT(RSA_PSS_PARAMS, hashAlgorithm, X509_ALGOR, 0),
+    ASN1_EXP_OPT(RSA_PSS_PARAMS, maskGenAlgorithm, X509_ALGOR, 1),
+    ASN1_EXP_OPT(RSA_PSS_PARAMS, saltLength, ASN1_INTEGER, 2),
+    ASN1_EXP_OPT(RSA_PSS_PARAMS, trailerField, ASN1_INTEGER, 3),
 } ASN1_SEQUENCE_END_cb(RSA_PSS_PARAMS, RSA_PSS_PARAMS)
 
-IMPLEMENT_ASN1_FUNCTIONS(RSA_PSS_PARAMS)
+IMPLEMENT_ASN1_FUNCTIONS_const(RSA_PSS_PARAMS)
 
 
-/* Given an MGF1 Algorithm ID decode to an Algorithm Identifier */
-static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg) {
-  if (alg == NULL || alg->parameter == NULL ||
-      OBJ_obj2nid(alg->algorithm) != NID_mgf1 ||
+// Given an MGF1 Algorithm ID decode to an Algorithm Identifier
+static X509_ALGOR *rsa_mgf1_decode(const X509_ALGOR *alg) {
+  if (OBJ_obj2nid(alg->algorithm) != NID_mgf1 ||
+      alg->parameter == NULL ||
       alg->parameter->type != V_ASN1_SEQUENCE) {
     return NULL;
   }
@@ -99,30 +100,27 @@ static X509_ALGOR *rsa_mgf1_decode(X509_ALGOR *alg) {
   return d2i_X509_ALGOR(NULL, &p, plen);
 }
 
-static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg,
-                                      X509_ALGOR **pmaskHash) {
-  *pmaskHash = NULL;
-
+static RSA_PSS_PARAMS *rsa_pss_decode(const X509_ALGOR *alg) {
   if (alg->parameter == NULL || alg->parameter->type != V_ASN1_SEQUENCE) {
     return NULL;
   }
 
   const uint8_t *p = alg->parameter->value.sequence->data;
   int plen = alg->parameter->value.sequence->length;
-  RSA_PSS_PARAMS *pss = d2i_RSA_PSS_PARAMS(NULL, &p, plen);
-  if (pss == NULL) {
-    return NULL;
-  }
+  return d2i_RSA_PSS_PARAMS(NULL, &p, plen);
+}
 
-  *pmaskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
-  return pss;
+static int is_allowed_pss_md(const EVP_MD *md) {
+  int md_type = EVP_MD_type(md);
+  return md_type == NID_sha256 || md_type == NID_sha384 ||
+         md_type == NID_sha512;
 }
 
-/* allocate and set algorithm ID from EVP_MD, default SHA1 */
+// rsa_md_to_algor sets |*palg| to an |X509_ALGOR| describing the digest |md|,
+// which must be an allowed PSS digest.
 static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md) {
-  if (EVP_MD_type(md) == NID_sha1) {
-    return 1;
-  }
+  // SHA-1 should be omitted (DEFAULT), but we do not allow SHA-1.
+  assert(is_allowed_pss_md(md));
   *palg = X509_ALGOR_new();
   if (*palg == NULL) {
     return 0;
@@ -131,16 +129,14 @@ static int rsa_md_to_algor(X509_ALGOR **palg, const EVP_MD *md) {
   return 1;
 }
 
-/* Allocate and set MGF1 algorithm ID from EVP_MD */
+// rsa_md_to_mgf1 sets |*palg| to an |X509_ALGOR| describing MGF-1 with the
+// digest |mgf1md|, which must be an allowed PSS digest.
 static int rsa_md_to_mgf1(X509_ALGOR **palg, const EVP_MD *mgf1md) {
+  // SHA-1 should be omitted (DEFAULT), but we do not allow SHA-1.
+  assert(is_allowed_pss_md(mgf1md));
   X509_ALGOR *algtmp = NULL;
   ASN1_STRING *stmp = NULL;
-  *palg = NULL;
-
-  if (EVP_MD_type(mgf1md) == NID_sha1) {
-    return 1;
-  }
-  /* need to embed algorithm ID inside another */
+  // need to embed algorithm ID inside another
   if (!rsa_md_to_algor(&algtmp, mgf1md) ||
       !ASN1_item_pack(algtmp, ASN1_ITEM_rptr(X509_ALGOR), &stmp)) {
     goto err;
@@ -162,38 +158,35 @@ err:
   return 0;
 }
 
-/* convert algorithm ID to EVP_MD, default SHA1 */
-static const EVP_MD *rsa_algor_to_md(X509_ALGOR *alg) {
-  const EVP_MD *md;
+static const EVP_MD *rsa_algor_to_md(const X509_ALGOR *alg) {
   if (!alg) {
-    return EVP_sha1();
+    // If omitted, PSS defaults to SHA-1, which we do not allow.
+    OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
+    return NULL;
   }
-  md = EVP_get_digestbyobj(alg->algorithm);
-  if (md == NULL) {
+  const EVP_MD *md = EVP_get_digestbyobj(alg->algorithm);
+  if (md == NULL || !is_allowed_pss_md(md)) {
     OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
+    return NULL;
   }
   return md;
 }
 
-/* convert MGF1 algorithm ID to EVP_MD, default SHA1 */
-static const EVP_MD *rsa_mgf1_to_md(const X509_ALGOR *alg,
-                                    X509_ALGOR *maskHash) {
-  const EVP_MD *md;
+static const EVP_MD *rsa_mgf1_to_md(const X509_ALGOR *alg) {
   if (!alg) {
-    return EVP_sha1();
-  }
-  /* Check mask and lookup mask hash algorithm */
-  if (OBJ_obj2nid(alg->algorithm) != NID_mgf1 ||
-      maskHash == NULL) {
+    // If omitted, PSS defaults to MGF-1 with SHA-1, which we do not allow.
     OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
     return NULL;
   }
-  md = EVP_get_digestbyobj(maskHash->algorithm);
-  if (md == NULL) {
+  // Check mask and lookup mask hash algorithm.
+  X509_ALGOR *maskHash = rsa_mgf1_decode(alg);
+  if (maskHash == NULL) {
     OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
     return NULL;
   }
-  return md;
+  const EVP_MD *ret = rsa_algor_to_md(maskHash);
+  X509_ALGOR_free(maskHash);
+  return ret;
 }
 
 int x509_rsa_ctx_to_pss(EVP_MD_CTX *ctx, X509_ALGOR *algor) {
@@ -205,18 +198,14 @@ int x509_rsa_ctx_to_pss(EVP_MD_CTX *ctx, X509_ALGOR *algor) {
     return 0;
   }
 
-  EVP_PKEY *pk = EVP_PKEY_CTX_get0_pkey(ctx->pctx);
+  if (sigmd != mgf1md || !is_allowed_pss_md(sigmd)) {
+    OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
+    return 0;
+  }
+  int md_len = (int)EVP_MD_size(sigmd);
   if (saltlen == -1) {
-    saltlen = EVP_MD_size(sigmd);
-  } else if (saltlen == -2) {
-    // TODO(davidben): Forbid this mode. The world has largely standardized on
-    // salt length matching hash length.
-    saltlen = EVP_PKEY_size(pk) - EVP_MD_size(sigmd) - 2;
-    if (((EVP_PKEY_bits(pk) - 1) & 0x7) == 0) {
-      saltlen--;
-    }
-  } else if (saltlen != (int)EVP_MD_size(sigmd)) {
-    // We only allow salt length matching hash length and, for now, the -2 case.
+    saltlen = md_len;
+  } else if (saltlen != md_len) {
     OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
     return 0;
   }
@@ -228,12 +217,12 @@ int x509_rsa_ctx_to_pss(EVP_MD_CTX *ctx, X509_ALGOR *algor) {
     goto err;
   }
 
-  if (saltlen != 20) {
-    pss->saltLength = ASN1_INTEGER_new();
-    if (!pss->saltLength ||
-        !ASN1_INTEGER_set(pss->saltLength, saltlen)) {
-      goto err;
-    }
+  // The DEFAULT value is 20, but this does not match any supported digest.
+  assert(saltlen != 20);
+  pss->saltLength = ASN1_INTEGER_new();
+  if (!pss->saltLength ||  //
+      !ASN1_INTEGER_set_int64(pss->saltLength, saltlen)) {
+    goto err;
   }
 
   if (!rsa_md_to_algor(&pss->hashAlgorithm, sigmd) ||
@@ -241,7 +230,7 @@ int x509_rsa_ctx_to_pss(EVP_MD_CTX *ctx, X509_ALGOR *algor) {
     goto err;
   }
 
-  /* Finally create string with pss parameter encoding. */
+  // Finally create string with pss parameter encoding.
   if (!ASN1_item_pack(pss, ASN1_ITEM_rptr(RSA_PSS_PARAMS), &os)) {
     goto err;
   }
@@ -260,35 +249,40 @@ int x509_rsa_pss_to_ctx(EVP_MD_CTX *ctx, const X509_ALGOR *sigalg,
                         EVP_PKEY *pkey) {
   assert(OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss);
 
-  /* Decode PSS parameters */
+  // Decode PSS parameters
   int ret = 0;
-  X509_ALGOR *maskHash;
-  RSA_PSS_PARAMS *pss = rsa_pss_decode(sigalg, &maskHash);
+  RSA_PSS_PARAMS *pss = rsa_pss_decode(sigalg);
   if (pss == NULL) {
     OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
     goto err;
   }
 
-  const EVP_MD *mgf1md = rsa_mgf1_to_md(pss->maskGenAlgorithm, maskHash);
+  const EVP_MD *mgf1md = rsa_mgf1_to_md(pss->maskGenAlgorithm);
   const EVP_MD *md = rsa_algor_to_md(pss->hashAlgorithm);
   if (mgf1md == NULL || md == NULL) {
     goto err;
   }
 
-  int saltlen = 20;
-  if (pss->saltLength != NULL) {
-    saltlen = ASN1_INTEGER_get(pss->saltLength);
+  // We require the MGF-1 and signing hashes to match.
+  if (mgf1md != md) {
+    OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
+    goto err;
+  }
 
-    /* Could perform more salt length sanity checks but the main
-     * RSA routines will trap other invalid values anyway. */
-    if (saltlen < 0) {
-      OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
-      goto err;
-    }
+  // We require the salt length be the hash length. The DEFAULT value is 20, but
+  // this does not match any supported salt length.
+  uint64_t salt_len = 0;
+  if (pss->saltLength == NULL ||
+      !ASN1_INTEGER_get_uint64(&salt_len, pss->saltLength) ||
+      salt_len != EVP_MD_size(md)) {
+    OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
+    goto err;
   }
+  assert(salt_len <= INT_MAX);
 
-  /* low-level routines support only trailer field 0xbc (value 1)
-   * and PKCS#1 says we should reject any other value anyway. */
+  // The trailer field must be 1 (0xbc). This value is DEFAULT, so the structure
+  // is required to omit it in DER. Although a syntax error, we also tolerate an
+  // explicitly-encoded value. See the certificates in cl/362617931.
   if (pss->trailerField != NULL && ASN1_INTEGER_get(pss->trailerField) != 1) {
     OPENSSL_PUT_ERROR(X509, X509_R_INVALID_PSS_PARAMETERS);
     goto err;
@@ -297,7 +291,7 @@ int x509_rsa_pss_to_ctx(EVP_MD_CTX *ctx, const X509_ALGOR *sigalg,
   EVP_PKEY_CTX *pctx;
   if (!EVP_DigestVerifyInit(ctx, &pctx, md, NULL, pkey) ||
       !EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) ||
-      !EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, saltlen) ||
+      !EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, (int)salt_len) ||
       !EVP_PKEY_CTX_set_rsa_mgf1_md(pctx, mgf1md)) {
     goto err;
   }
@@ -306,7 +300,6 @@ int x509_rsa_pss_to_ctx(EVP_MD_CTX *ctx, const X509_ALGOR *sigalg,
 
 err:
   RSA_PSS_PARAMS_free(pss);
-  X509_ALGOR_free(maskHash);
   return ret;
 }
 
@@ -315,8 +308,8 @@ int x509_print_rsa_pss_params(BIO *bp, const X509_ALGOR *sigalg, int indent,
   assert(OBJ_obj2nid(sigalg->algorithm) == NID_rsassaPss);
 
   int rv = 0;
-  X509_ALGOR *maskHash;
-  RSA_PSS_PARAMS *pss = rsa_pss_decode(sigalg, &maskHash);
+  X509_ALGOR *maskHash = NULL;
+  RSA_PSS_PARAMS *pss = rsa_pss_decode(sigalg);
   if (!pss) {
     if (BIO_puts(bp, " (INVALID PSS PARAMETERS)\n") <= 0) {
       goto err;
@@ -325,8 +318,8 @@ int x509_print_rsa_pss_params(BIO *bp, const X509_ALGOR *sigalg, int indent,
     goto err;
   }
 
-  if (BIO_puts(bp, "\n") <= 0 ||
-      !BIO_indent(bp, indent, 128) ||
+  if (BIO_puts(bp, "\n") <= 0 ||       //
+      !BIO_indent(bp, indent, 128) ||  //
       BIO_puts(bp, "Hash Algorithm: ") <= 0) {
     goto err;
   }
@@ -339,31 +332,31 @@ int x509_print_rsa_pss_params(BIO *bp, const X509_ALGOR *sigalg, int indent,
     goto err;
   }
 
-  if (BIO_puts(bp, "\n") <= 0 ||
-      !BIO_indent(bp, indent, 128) ||
+  if (BIO_puts(bp, "\n") <= 0 ||       //
+      !BIO_indent(bp, indent, 128) ||  //
       BIO_puts(bp, "Mask Algorithm: ") <= 0) {
     goto err;
   }
 
   if (pss->maskGenAlgorithm) {
-    if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0 ||
-        BIO_puts(bp, " with ") <= 0) {
-      goto err;
-    }
-
-    if (maskHash) {
-      if (i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0) {
+    maskHash = rsa_mgf1_decode(pss->maskGenAlgorithm);
+    if (maskHash == NULL) {
+      if (BIO_puts(bp, "INVALID") <= 0) {
+        goto err;
+      }
+    } else {
+      if (i2a_ASN1_OBJECT(bp, pss->maskGenAlgorithm->algorithm) <= 0 ||
+          BIO_puts(bp, " with ") <= 0 ||
+          i2a_ASN1_OBJECT(bp, maskHash->algorithm) <= 0) {
         goto err;
       }
-    } else if (BIO_puts(bp, "INVALID") <= 0) {
-      goto err;
     }
   } else if (BIO_puts(bp, "mgf1 with sha1 (default)") <= 0) {
     goto err;
   }
   BIO_puts(bp, "\n");
 
-  if (!BIO_indent(bp, indent, 128) ||
+  if (!BIO_indent(bp, indent, 128) ||  //
       BIO_puts(bp, "Salt Length: 0x") <= 0) {
     goto err;
   }
@@ -377,7 +370,7 @@ int x509_print_rsa_pss_params(BIO *bp, const X509_ALGOR *sigalg, int indent,
   }
   BIO_puts(bp, "\n");
 
-  if (!BIO_indent(bp, indent, 128) ||
+  if (!BIO_indent(bp, indent, 128) ||  //
       BIO_puts(bp, "Trailer Field: 0x") <= 0) {
     goto err;
   }

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

@@ -54,6 +54,8 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.] */
 
+#include <assert.h>
+
 #include <openssl/asn1.h>
 #include <openssl/err.h>
 #include <openssl/mem.h>
@@ -61,70 +63,83 @@
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 
-int X509_CRL_print_fp(FILE *fp, X509_CRL *x)
-{
-    BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(X509, ERR_R_BUF_LIB);
-        return 0;
-    }
-    int ret = X509_CRL_print(b, x);
-    BIO_free(b);
-    return ret;
+int X509_CRL_print_fp(FILE *fp, X509_CRL *x) {
+  BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
+  if (b == NULL) {
+    OPENSSL_PUT_ERROR(X509, ERR_R_BUF_LIB);
+    return 0;
+  }
+  int ret = X509_CRL_print(b, x);
+  BIO_free(b);
+  return ret;
 }
 
-int X509_CRL_print(BIO *out, X509_CRL *x)
-{
-    STACK_OF(X509_REVOKED) *rev;
-    X509_REVOKED *r;
-    long l;
-    size_t i;
-    char *p;
+int X509_CRL_print(BIO *out, X509_CRL *x) {
+  long version = X509_CRL_get_version(x);
+  assert(X509_CRL_VERSION_1 <= version && version <= X509_CRL_VERSION_2);
+  const X509_ALGOR *sig_alg;
+  const ASN1_BIT_STRING *signature;
+  X509_CRL_get0_signature(x, &signature, &sig_alg);
+  if (BIO_printf(out, "Certificate Revocation List (CRL):\n") <= 0 ||
+      BIO_printf(out, "%8sVersion %ld (0x%lx)\n", "", version + 1,
+                 (unsigned long)version) <= 0 ||
+      // Note this and the other |X509_signature_print| call both print the
+      // outer signature algorithm, rather than printing the inner and outer
+      // ones separately. This matches OpenSSL, though it was probably a bug.
+      !X509_signature_print(out, sig_alg, NULL)) {
+    return 0;
+  }
 
-    BIO_printf(out, "Certificate Revocation List (CRL):\n");
-    l = X509_CRL_get_version(x);
-    BIO_printf(out, "%8sVersion %lu (0x%lx)\n", "", l + 1, l);
-    const X509_ALGOR *sig_alg;
-    const ASN1_BIT_STRING *signature;
-    X509_CRL_get0_signature(x, &signature, &sig_alg);
-    // Note this and the other |X509_signature_print| call print the outer
-    // signature algorithm twice, rather than both the inner and outer ones.
-    // This matches OpenSSL, though it was probably a bug.
-    X509_signature_print(out, sig_alg, NULL);
-    p = X509_NAME_oneline(X509_CRL_get_issuer(x), NULL, 0);
-    BIO_printf(out, "%8sIssuer: %s\n", "", p);
-    OPENSSL_free(p);
-    BIO_printf(out, "%8sLast Update: ", "");
-    ASN1_TIME_print(out, X509_CRL_get0_lastUpdate(x));
-    BIO_printf(out, "\n%8sNext Update: ", "");
-    if (X509_CRL_get0_nextUpdate(x))
-        ASN1_TIME_print(out, X509_CRL_get0_nextUpdate(x));
-    else
-        BIO_printf(out, "NONE");
-    BIO_printf(out, "\n");
+  char *issuer = X509_NAME_oneline(X509_CRL_get_issuer(x), NULL, 0);
+  int ok = issuer != NULL && BIO_printf(out, "%8sIssuer: %s\n", "", issuer) > 0;
+  OPENSSL_free(issuer);
+  if (!ok) {
+    return 0;
+  }
 
-    X509V3_extensions_print(out, "CRL extensions", X509_CRL_get0_extensions(x),
-                            0, 8);
-
-    rev = X509_CRL_get_REVOKED(x);
+  if (BIO_printf(out, "%8sLast Update: ", "") <= 0 ||
+      !ASN1_TIME_print(out, X509_CRL_get0_lastUpdate(x)) ||
+      BIO_printf(out, "\n%8sNext Update: ", "") <= 0) {
+    return 0;
+  }
+  if (X509_CRL_get0_nextUpdate(x)) {
+    if (!ASN1_TIME_print(out, X509_CRL_get0_nextUpdate(x))) {
+      return 0;
+    }
+  } else {
+    if (BIO_printf(out, "NONE") <= 0) {
+      return 0;
+    }
+  }
 
-    if (sk_X509_REVOKED_num(rev) > 0)
-        BIO_printf(out, "Revoked Certificates:\n");
-    else
-        BIO_printf(out, "No Revoked Certificates.\n");
+  if (BIO_printf(out, "\n") <= 0 ||
+      !X509V3_extensions_print(out, "CRL extensions",
+                               X509_CRL_get0_extensions(x), 0, 8)) {
+    return 0;
+  }
 
-    for (i = 0; i < sk_X509_REVOKED_num(rev); i++) {
-        r = sk_X509_REVOKED_value(rev, i);
-        BIO_printf(out, "    Serial Number: ");
-        i2a_ASN1_INTEGER(out, r->serialNumber);
-        BIO_printf(out, "\n        Revocation Date: ");
-        ASN1_TIME_print(out, r->revocationDate);
-        BIO_printf(out, "\n");
-        X509V3_extensions_print(out, "CRL entry extensions",
-                                r->extensions, 0, 8);
+  const STACK_OF(X509_REVOKED) *rev = X509_CRL_get_REVOKED(x);
+  if (sk_X509_REVOKED_num(rev) > 0) {
+    if (BIO_printf(out, "Revoked Certificates:\n") <= 0) {
+      return 0;
+    }
+  } else {
+    if (BIO_printf(out, "No Revoked Certificates.\n") <= 0) {
+      return 0;
     }
-    X509_signature_print(out, sig_alg, signature);
+  }
 
-    return 1;
+  for (size_t i = 0; i < sk_X509_REVOKED_num(rev); i++) {
+    const X509_REVOKED *r = sk_X509_REVOKED_value(rev, i);
+    if (BIO_printf(out, "    Serial Number: ") <= 0 ||
+        i2a_ASN1_INTEGER(out, X509_REVOKED_get0_serialNumber(r)) <= 0 ||
+        BIO_printf(out, "\n        Revocation Date: ") <= 0 ||
+        !ASN1_TIME_print(out, X509_REVOKED_get0_revocationDate(r)) ||
+        BIO_printf(out, "\n") <= 0 ||
+        !X509V3_extensions_print(out, "CRL entry extensions",
+                                 X509_REVOKED_get0_extensions(r), 0, 8)) {
+    }
+  }
 
+  return X509_signature_print(out, sig_alg, signature);
 }

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

@@ -54,6 +54,7 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.] */
 
+#include <assert.h>
 #include <stdio.h>
 
 #include <openssl/bn.h>
@@ -81,7 +82,7 @@ int X509_REQ_print_ex(BIO *bio, X509_REQ *x, unsigned long nmflags,
                       unsigned long cflag) {
   long l;
   EVP_PKEY *pkey;
-  STACK_OF(X509_ATTRIBUTE) * sk;
+  STACK_OF(X509_ATTRIBUTE) *sk;
   char mlch = ' ';
 
   int nmindent = 0;
@@ -104,7 +105,11 @@ int X509_REQ_print_ex(BIO *bio, X509_REQ *x, unsigned long nmflags,
   }
   if (!(cflag & X509_FLAG_NO_VERSION)) {
     l = X509_REQ_get_version(x);
-    if (BIO_printf(bio, "%8sVersion: %ld (0x%lx)\n", "", l + 1, l) <= 0) {
+    // Only zero, |X509_REQ_VERSION_1|, is valid but our parser accepts some
+    // invalid values for compatibility.
+    assert(0 <= l && l <= 2);
+    if (BIO_printf(bio, "%8sVersion: %ld (0x%lx)\n", "", l + 1,
+                   (unsigned long)l) <= 0) {
       goto err;
     }
   }
@@ -184,10 +189,8 @@ int X509_REQ_print_ex(BIO *bio, X509_REQ *x, unsigned long nmflags,
             goto err;
           }
 
-          if (type == V_ASN1_PRINTABLESTRING ||
-              type == V_ASN1_UTF8STRING ||
-              type == V_ASN1_IA5STRING ||
-              type == V_ASN1_T61STRING) {
+          if (type == V_ASN1_PRINTABLESTRING || type == V_ASN1_UTF8STRING ||
+              type == V_ASN1_IA5STRING || type == V_ASN1_T61STRING) {
             if (BIO_write(bio, (char *)bs->data, bs->length) != bs->length) {
               goto err;
             }
@@ -205,13 +208,12 @@ int X509_REQ_print_ex(BIO *bio, X509_REQ *x, unsigned long nmflags,
     if (exts) {
       BIO_printf(bio, "%8sRequested Extensions:\n", "");
 
-      size_t i;
-      for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
-        X509_EXTENSION *ex = sk_X509_EXTENSION_value(exts, i);
+      for (size_t i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
+        const X509_EXTENSION *ex = sk_X509_EXTENSION_value(exts, i);
         if (BIO_printf(bio, "%12s", "") <= 0) {
           goto err;
         }
-        ASN1_OBJECT *obj = X509_EXTENSION_get_object(ex);
+        const ASN1_OBJECT *obj = X509_EXTENSION_get_object(ex);
         i2a_ASN1_OBJECT(bio, obj);
         const int is_critical = X509_EXTENSION_get_critical(ex);
         if (BIO_printf(bio, ": %s\n", is_critical ? "critical" : "") <= 0) {