grpc 1.53.1 → 1.54.0

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_oth.c

@@ -1,4 +1,3 @@
-/* crypto/pem/pem_oth.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -60,28 +59,29 @@
 #include <stdio.h>
 
 #include <openssl/err.h>
-#include <openssl/mem.h>
 #include <openssl/evp.h>
+#include <openssl/mem.h>
 #include <openssl/obj.h>
 #include <openssl/rand.h>
 #include <openssl/x509.h>
 
-/* Handle 'other' PEMs: not private keys */
+// Handle 'other' PEMs: not private keys
 
 void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
-                        pem_password_cb *cb, void *u)
-{
-    const unsigned char *p = NULL;
-    unsigned char *data = NULL;
-    long len;
-    char *ret = NULL;
+                        pem_password_cb *cb, void *u) {
+  const unsigned char *p = NULL;
+  unsigned char *data = NULL;
+  long len;
+  char *ret = NULL;
 
-    if (!PEM_bytes_read_bio(&data, &len, NULL, name, bp, cb, u))
-        return NULL;
-    p = data;
-    ret = d2i(x, &p, len);
-    if (ret == NULL)
-        OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
-    OPENSSL_free(data);
-    return ret;
+  if (!PEM_bytes_read_bio(&data, &len, NULL, name, bp, cb, u)) {
+    return NULL;
+  }
+  p = data;
+  ret = d2i(x, &p, len);
+  if (ret == NULL) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
+  }
+  OPENSSL_free(data);
+  return ret;
 }

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_pk8.c

@@ -64,187 +64,180 @@
 #include <openssl/rand.h>
 #include <openssl/x509.h>
 
-static int do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder,
-                      int nid, const EVP_CIPHER *enc,
-                      char *kstr, int klen, pem_password_cb *cb, void *u);
-static int do_pk8pkey_fp(FILE *bp, EVP_PKEY *x, int isder,
-                         int nid, const EVP_CIPHER *enc,
-                         char *kstr, int klen, pem_password_cb *cb, void *u);
-
-/*
- * These functions write a private key in PKCS#8 format: it is a "drop in"
- * replacement for PEM_write_bio_PrivateKey() and friends. As usual if 'enc'
- * is NULL then it uses the unencrypted private key form. The 'nid' versions
- * uses PKCS#5 v1.5 PBE algorithms whereas the others use PKCS#5 v2.0.
- */
-
-int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
-                                      char *kstr, int klen,
-                                      pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey(bp, x, 0, nid, NULL, kstr, klen, cb, u);
+static int do_pk8pkey(BIO *bp, const EVP_PKEY *x, int isder, int nid,
+                      const EVP_CIPHER *enc, char *kstr, int klen,
+                      pem_password_cb *cb, void *u);
+static int do_pk8pkey_fp(FILE *bp, const EVP_PKEY *x, int isder, int nid,
+                         const EVP_CIPHER *enc, char *kstr, int klen,
+                         pem_password_cb *cb, void *u);
+
+// These functions write a private key in PKCS#8 format: it is a "drop in"
+// replacement for PEM_write_bio_PrivateKey() and friends. As usual if 'enc'
+// is NULL then it uses the unencrypted private key form. The 'nid' versions
+// uses PKCS#5 v1.5 PBE algorithms whereas the others use PKCS#5 v2.0.
+
+int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, const EVP_PKEY *x, int nid,
+                                      char *kstr, int klen, pem_password_cb *cb,
+                                      void *u) {
+  return do_pk8pkey(bp, x, 0, nid, NULL, kstr, klen, cb, u);
 }
 
-int PEM_write_bio_PKCS8PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
-                                  char *kstr, int klen,
-                                  pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey(bp, x, 0, -1, enc, kstr, klen, cb, u);
+int PEM_write_bio_PKCS8PrivateKey(BIO *bp, const EVP_PKEY *x,
+                                  const EVP_CIPHER *enc, char *kstr, int klen,
+                                  pem_password_cb *cb, void *u) {
+  return do_pk8pkey(bp, x, 0, -1, enc, kstr, klen, cb, u);
 }
 
-int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
-                            char *kstr, int klen,
-                            pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey(bp, x, 1, -1, enc, kstr, klen, cb, u);
+int i2d_PKCS8PrivateKey_bio(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                            char *kstr, int klen, pem_password_cb *cb,
+                            void *u) {
+  return do_pk8pkey(bp, x, 1, -1, enc, kstr, klen, cb, u);
 }
 
-int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
-                                char *kstr, int klen,
-                                pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey(bp, x, 1, nid, NULL, kstr, klen, cb, u);
+int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, const EVP_PKEY *x, int nid, char *kstr,
+                                int klen, pem_password_cb *cb, void *u) {
+  return do_pk8pkey(bp, x, 1, nid, NULL, kstr, klen, cb, u);
 }
 
-static int do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder, int nid,
+static int do_pk8pkey(BIO *bp, const EVP_PKEY *x, int isder, int nid,
                       const EVP_CIPHER *enc, char *kstr, int klen,
-                      pem_password_cb *cb, void *u)
-{
-    X509_SIG *p8;
-    PKCS8_PRIV_KEY_INFO *p8inf;
-    char buf[PEM_BUFSIZE];
-    int ret;
-    if (!(p8inf = EVP_PKEY2PKCS8(x))) {
-        OPENSSL_PUT_ERROR(PEM, PEM_R_ERROR_CONVERTING_PRIVATE_KEY);
+                      pem_password_cb *cb, void *u) {
+  X509_SIG *p8;
+  PKCS8_PRIV_KEY_INFO *p8inf;
+  char buf[PEM_BUFSIZE];
+  int ret;
+  if (!(p8inf = EVP_PKEY2PKCS8(x))) {
+    OPENSSL_PUT_ERROR(PEM, PEM_R_ERROR_CONVERTING_PRIVATE_KEY);
+    return 0;
+  }
+  if (enc || (nid != -1)) {
+    if (!kstr) {
+      klen = 0;
+      if (!cb) {
+        cb = PEM_def_callback;
+      }
+      klen = cb(buf, PEM_BUFSIZE, 1, u);
+      if (klen <= 0) {
+        OPENSSL_PUT_ERROR(PEM, PEM_R_READ_KEY);
+        PKCS8_PRIV_KEY_INFO_free(p8inf);
         return 0;
+      }
+
+      kstr = buf;
     }
-    if (enc || (nid != -1)) {
-        if (!kstr) {
-            klen = 0;
-            if (!cb)
-                cb = PEM_def_callback;
-            klen = cb(buf, PEM_BUFSIZE, 1, u);
-            if (klen <= 0) {
-                OPENSSL_PUT_ERROR(PEM, PEM_R_READ_KEY);
-                PKCS8_PRIV_KEY_INFO_free(p8inf);
-                return 0;
-            }
-
-            kstr = buf;
-        }
-        p8 = PKCS8_encrypt(nid, enc, kstr, klen, NULL, 0, 0, p8inf);
-        if (kstr == buf)
-            OPENSSL_cleanse(buf, klen);
-        PKCS8_PRIV_KEY_INFO_free(p8inf);
-        if (isder)
-            ret = i2d_PKCS8_bio(bp, p8);
-        else
-            ret = PEM_write_bio_PKCS8(bp, p8);
-        X509_SIG_free(p8);
-        return ret;
+    p8 = PKCS8_encrypt(nid, enc, kstr, klen, NULL, 0, 0, p8inf);
+    if (kstr == buf) {
+      OPENSSL_cleanse(buf, klen);
+    }
+    PKCS8_PRIV_KEY_INFO_free(p8inf);
+    if (isder) {
+      ret = i2d_PKCS8_bio(bp, p8);
     } else {
-        if (isder)
-            ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
-        else
-            ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(bp, p8inf);
-        PKCS8_PRIV_KEY_INFO_free(p8inf);
-        return ret;
+      ret = PEM_write_bio_PKCS8(bp, p8);
     }
+    X509_SIG_free(p8);
+    return ret;
+  } else {
+    if (isder) {
+      ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
+    } else {
+      ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(bp, p8inf);
+    }
+    PKCS8_PRIV_KEY_INFO_free(p8inf);
+    return ret;
+  }
 }
 
 EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
-                                  void *u)
-{
-    PKCS8_PRIV_KEY_INFO *p8inf = NULL;
-    X509_SIG *p8 = NULL;
-    int klen;
-    EVP_PKEY *ret;
-    char psbuf[PEM_BUFSIZE];
-    p8 = d2i_PKCS8_bio(bp, NULL);
-    if (!p8)
-        return NULL;
-
-    klen = 0;
-    if (!cb)
-        cb = PEM_def_callback;
-    klen = cb(psbuf, PEM_BUFSIZE, 0, u);
-    if (klen <= 0) {
-        OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_PASSWORD_READ);
-        X509_SIG_free(p8);
-        return NULL;
-    }
-    p8inf = PKCS8_decrypt(p8, psbuf, klen);
+                                  void *u) {
+  PKCS8_PRIV_KEY_INFO *p8inf = NULL;
+  X509_SIG *p8 = NULL;
+  int klen;
+  EVP_PKEY *ret;
+  char psbuf[PEM_BUFSIZE];
+  p8 = d2i_PKCS8_bio(bp, NULL);
+  if (!p8) {
+    return NULL;
+  }
+
+  klen = 0;
+  if (!cb) {
+    cb = PEM_def_callback;
+  }
+  klen = cb(psbuf, PEM_BUFSIZE, 0, u);
+  if (klen <= 0) {
+    OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_PASSWORD_READ);
     X509_SIG_free(p8);
-    OPENSSL_cleanse(psbuf, klen);
-    if (!p8inf)
-        return NULL;
-    ret = EVP_PKCS82PKEY(p8inf);
-    PKCS8_PRIV_KEY_INFO_free(p8inf);
-    if (!ret)
-        return NULL;
-    if (x) {
-        if (*x)
-            EVP_PKEY_free(*x);
-        *x = ret;
+    return NULL;
+  }
+  p8inf = PKCS8_decrypt(p8, psbuf, klen);
+  X509_SIG_free(p8);
+  OPENSSL_cleanse(psbuf, klen);
+  if (!p8inf) {
+    return NULL;
+  }
+  ret = EVP_PKCS82PKEY(p8inf);
+  PKCS8_PRIV_KEY_INFO_free(p8inf);
+  if (!ret) {
+    return NULL;
+  }
+  if (x) {
+    if (*x) {
+      EVP_PKEY_free(*x);
     }
-    return ret;
+    *x = ret;
+  }
+  return ret;
 }
 
 
-int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
-                           char *kstr, int klen, pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey_fp(fp, x, 1, -1, enc, kstr, klen, cb, u);
+int i2d_PKCS8PrivateKey_fp(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc,
+                           char *kstr, int klen, pem_password_cb *cb, void *u) {
+  return do_pk8pkey_fp(fp, x, 1, -1, enc, kstr, klen, cb, u);
 }
 
-int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,
-                               char *kstr, int klen,
-                               pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey_fp(fp, x, 1, nid, NULL, kstr, klen, cb, u);
+int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, const EVP_PKEY *x, int nid, char *kstr,
+                               int klen, pem_password_cb *cb, void *u) {
+  return do_pk8pkey_fp(fp, x, 1, nid, NULL, kstr, klen, cb, u);
 }
 
-int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
-                                  char *kstr, int klen,
-                                  pem_password_cb *cb, void *u)
-{
-    return do_pk8pkey_fp(fp, x, 0, nid, NULL, kstr, klen, cb, u);
+int PEM_write_PKCS8PrivateKey_nid(FILE *fp, const EVP_PKEY *x, int nid,
+                                  char *kstr, int klen, pem_password_cb *cb,
+                                  void *u) {
+  return do_pk8pkey_fp(fp, x, 0, nid, NULL, kstr, klen, cb, u);
 }
 
-int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
-                              char *kstr, int klen, pem_password_cb *cb,
-                              void *u)
-{
-    return do_pk8pkey_fp(fp, x, 0, -1, enc, kstr, klen, cb, u);
+int PEM_write_PKCS8PrivateKey(FILE *fp, const EVP_PKEY *x,
+                              const EVP_CIPHER *enc, char *kstr, int klen,
+                              pem_password_cb *cb, void *u) {
+  return do_pk8pkey_fp(fp, x, 0, -1, enc, kstr, klen, cb, u);
 }
 
-static int do_pk8pkey_fp(FILE *fp, EVP_PKEY *x, int isder, int nid,
+static int do_pk8pkey_fp(FILE *fp, const EVP_PKEY *x, int isder, int nid,
                          const EVP_CIPHER *enc, char *kstr, int klen,
-                         pem_password_cb *cb, void *u)
-{
-    BIO *bp;
-    int ret;
-    if (!(bp = BIO_new_fp(fp, BIO_NOCLOSE))) {
-        OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
-        return (0);
-    }
-    ret = do_pk8pkey(bp, x, isder, nid, enc, kstr, klen, cb, u);
-    BIO_free(bp);
-    return ret;
+                         pem_password_cb *cb, void *u) {
+  BIO *bp;
+  int ret;
+  if (!(bp = BIO_new_fp(fp, BIO_NOCLOSE))) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
+    return 0;
+  }
+  ret = do_pk8pkey(bp, x, isder, nid, enc, kstr, klen, cb, u);
+  BIO_free(bp);
+  return ret;
 }
 
 EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
-                                 void *u)
-{
-    BIO *bp;
-    EVP_PKEY *ret;
-    if (!(bp = BIO_new_fp(fp, BIO_NOCLOSE))) {
-        OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
-        return NULL;
-    }
-    ret = d2i_PKCS8PrivateKey_bio(bp, x, cb, u);
-    BIO_free(bp);
-    return ret;
+                                 void *u) {
+  BIO *bp;
+  EVP_PKEY *ret;
+  if (!(bp = BIO_new_fp(fp, BIO_NOCLOSE))) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
+    return NULL;
+  }
+  ret = d2i_PKCS8PrivateKey_bio(bp, x, cb, u);
+  BIO_free(bp);
+  return ret;
 }
 
 
@@ -252,4 +245,4 @@ IMPLEMENT_PEM_rw(PKCS8, X509_SIG, PEM_STRING_PKCS8, X509_SIG)
 
 
 IMPLEMENT_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF,
-             PKCS8_PRIV_KEY_INFO)
+                 PKCS8_PRIV_KEY_INFO)

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_pkey.c

@@ -69,146 +69,114 @@
 #include <openssl/x509.h>
 
 EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
-                                  void *u)
-{
-    char *nm = NULL;
-    const unsigned char *p = NULL;
-    unsigned char *data = NULL;
-    long len;
-    EVP_PKEY *ret = NULL;
-
-    if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))
-        return NULL;
-    p = data;
-
-    if (strcmp(nm, PEM_STRING_PKCS8INF) == 0) {
-        PKCS8_PRIV_KEY_INFO *p8inf;
-        p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &p, len);
-        if (!p8inf)
-            goto p8err;
-        ret = EVP_PKCS82PKEY(p8inf);
-        if (x) {
-            if (*x)
-                EVP_PKEY_free((EVP_PKEY *)*x);
-            *x = ret;
-        }
-        PKCS8_PRIV_KEY_INFO_free(p8inf);
-    } else if (strcmp(nm, PEM_STRING_PKCS8) == 0) {
-        PKCS8_PRIV_KEY_INFO *p8inf;
-        X509_SIG *p8;
-        int klen;
-        char psbuf[PEM_BUFSIZE];
-        p8 = d2i_X509_SIG(NULL, &p, len);
-        if (!p8)
-            goto p8err;
-
-        klen = 0;
-        if (!cb)
-            cb = PEM_def_callback;
-        klen = cb(psbuf, PEM_BUFSIZE, 0, u);
-        if (klen <= 0) {
-            OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_PASSWORD_READ);
-            X509_SIG_free(p8);
-            goto err;
-        }
-        p8inf = PKCS8_decrypt(p8, psbuf, klen);
-        X509_SIG_free(p8);
-        OPENSSL_cleanse(psbuf, klen);
-        if (!p8inf)
-            goto p8err;
-        ret = EVP_PKCS82PKEY(p8inf);
-        if (x) {
-            if (*x)
-                EVP_PKEY_free((EVP_PKEY *)*x);
-            *x = ret;
-        }
-        PKCS8_PRIV_KEY_INFO_free(p8inf);
-    } else if (strcmp(nm, PEM_STRING_RSA) == 0) {
-        /* TODO(davidben): d2i_PrivateKey parses PKCS#8 along with the
-         * standalone format. This and the cases below probably should not
-         * accept PKCS#8. */
-        ret = d2i_PrivateKey(EVP_PKEY_RSA, x, &p, len);
-    } else if (strcmp(nm, PEM_STRING_EC) == 0) {
-        ret = d2i_PrivateKey(EVP_PKEY_EC, x, &p, len);
-    } else if (strcmp(nm, PEM_STRING_DSA) == 0) {
-        ret = d2i_PrivateKey(EVP_PKEY_DSA, x, &p, len);
+                                  void *u) {
+  char *nm = NULL;
+  const unsigned char *p = NULL;
+  unsigned char *data = NULL;
+  long len;
+  EVP_PKEY *ret = NULL;
+
+  if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u)) {
+    return NULL;
+  }
+  p = data;
+
+  if (strcmp(nm, PEM_STRING_PKCS8INF) == 0) {
+    PKCS8_PRIV_KEY_INFO *p8inf;
+    p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &p, len);
+    if (!p8inf) {
+      goto p8err;
+    }
+    ret = EVP_PKCS82PKEY(p8inf);
+    if (x) {
+      if (*x) {
+        EVP_PKEY_free((EVP_PKEY *)*x);
+      }
+      *x = ret;
+    }
+    PKCS8_PRIV_KEY_INFO_free(p8inf);
+  } else if (strcmp(nm, PEM_STRING_PKCS8) == 0) {
+    PKCS8_PRIV_KEY_INFO *p8inf;
+    X509_SIG *p8;
+    int klen;
+    char psbuf[PEM_BUFSIZE];
+    p8 = d2i_X509_SIG(NULL, &p, len);
+    if (!p8) {
+      goto p8err;
     }
- p8err:
-    if (ret == NULL)
-        OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
 
- err:
-    OPENSSL_free(nm);
-    OPENSSL_free(data);
-    return (ret);
+    klen = 0;
+    if (!cb) {
+      cb = PEM_def_callback;
+    }
+    klen = cb(psbuf, PEM_BUFSIZE, 0, u);
+    if (klen <= 0) {
+      OPENSSL_PUT_ERROR(PEM, PEM_R_BAD_PASSWORD_READ);
+      X509_SIG_free(p8);
+      goto err;
+    }
+    p8inf = PKCS8_decrypt(p8, psbuf, klen);
+    X509_SIG_free(p8);
+    OPENSSL_cleanse(psbuf, klen);
+    if (!p8inf) {
+      goto p8err;
+    }
+    ret = EVP_PKCS82PKEY(p8inf);
+    if (x) {
+      if (*x) {
+        EVP_PKEY_free((EVP_PKEY *)*x);
+      }
+      *x = ret;
+    }
+    PKCS8_PRIV_KEY_INFO_free(p8inf);
+  } else if (strcmp(nm, PEM_STRING_RSA) == 0) {
+    // TODO(davidben): d2i_PrivateKey parses PKCS#8 along with the
+    // standalone format. This and the cases below probably should not
+    // accept PKCS#8.
+    ret = d2i_PrivateKey(EVP_PKEY_RSA, x, &p, len);
+  } else if (strcmp(nm, PEM_STRING_EC) == 0) {
+    ret = d2i_PrivateKey(EVP_PKEY_EC, x, &p, len);
+  } else if (strcmp(nm, PEM_STRING_DSA) == 0) {
+    ret = d2i_PrivateKey(EVP_PKEY_DSA, x, &p, len);
+  }
+p8err:
+  if (ret == NULL) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
+  }
+
+err:
+  OPENSSL_free(nm);
+  OPENSSL_free(data);
+  return ret;
 }
 
 int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
-                             unsigned char *kstr, int klen,
-                             pem_password_cb *cb, void *u)
-{
-    return PEM_write_bio_PKCS8PrivateKey(bp, x, enc, (char *)kstr, klen, cb, u);
+                             unsigned char *kstr, int klen, pem_password_cb *cb,
+                             void *u) {
+  return PEM_write_bio_PKCS8PrivateKey(bp, x, enc, (char *)kstr, klen, cb, u);
 }
 
 EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
-                              void *u)
-{
-    BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
-        return NULL;
-    }
-    EVP_PKEY *ret = PEM_read_bio_PrivateKey(b, x, cb, u);
-    BIO_free(b);
-    return ret;
+                              void *u) {
+  BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
+  if (b == NULL) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
+    return NULL;
+  }
+  EVP_PKEY *ret = PEM_read_bio_PrivateKey(b, x, cb, u);
+  BIO_free(b);
+  return ret;
 }
 
 int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
-                         unsigned char *kstr, int klen,
-                         pem_password_cb *cb, void *u)
-{
-    BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
-        return 0;
-    }
-    int ret = PEM_write_bio_PrivateKey(b, x, enc, kstr, klen, cb, u);
-    BIO_free(b);
-    return ret;
-}
-
-
-/* Transparently read in PKCS#3 or X9.42 DH parameters */
-
-DH *PEM_read_bio_DHparams(BIO *bp, DH **x, pem_password_cb *cb, void *u)
-{
-    char *nm = NULL;
-    const unsigned char *p = NULL;
-    unsigned char *data = NULL;
-    long len;
-    DH *ret = NULL;
-
-    if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_DHPARAMS, bp, cb, u))
-        return NULL;
-    p = data;
-
-    ret = d2i_DHparams(x, &p, len);
-
-    if (ret == NULL)
-        OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
-    OPENSSL_free(nm);
-    OPENSSL_free(data);
-    return ret;
-}
-
-DH *PEM_read_DHparams(FILE *fp, DH **x, pem_password_cb *cb, void *u)
-{
-    BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
-    if (b == NULL) {
-        OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
-        return NULL;
-    }
-    DH *ret = PEM_read_bio_DHparams(b, x, cb, u);
-    BIO_free(b);
-    return ret;
+                         unsigned char *kstr, int klen, pem_password_cb *cb,
+                         void *u) {
+  BIO *b = BIO_new_fp(fp, BIO_NOCLOSE);
+  if (b == NULL) {
+    OPENSSL_PUT_ERROR(PEM, ERR_R_BUF_LIB);
+    return 0;
+  }
+  int ret = PEM_write_bio_PrivateKey(b, x, enc, kstr, klen, cb, u);
+  BIO_free(b);
+  return ret;
 }

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_x509.c

@@ -1,4 +1,3 @@
-/* pem_x509.c */
 /*
  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
  * 2001.

data/third_party/boringssl-with-bazel/src/crypto/pem/pem_xaux.c

@@ -1,4 +1,3 @@
-/* pem_xaux.c */
 /*
  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
  * 2001.

data/third_party/boringssl-with-bazel/src/crypto/pkcs7/pkcs7_x509.c

@@ -328,7 +328,6 @@ int i2d_PKCS7(const PKCS7 *p7, uint8_t **out) {
   if (*out == NULL) {
     *out = OPENSSL_malloc(p7->ber_len);
     if (*out == NULL) {
-      OPENSSL_PUT_ERROR(PKCS8, ERR_R_MALLOC_FAILURE);
       return -1;
     }
     OPENSSL_memcpy(*out, p7->ber_bytes, p7->ber_len);