@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/boringssl/src/crypto/pem/pem_oth.c

@@ -60,28 +60,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;
 }

package/third_party/boringssl/src/crypto/pem/pem_pk8.c

@@ -64,187 +64,178 @@
 #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, 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);
 }
 
 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);
+                                  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);
+                            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, 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,
                       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);
+                           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, 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, 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);
+                              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,
                          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 +243,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)

package/third_party/boringssl/src/crypto/pem/pem_pkey.c

@@ -69,110 +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;
+                                  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 (!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;
+  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);
+    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;
     }
- p8err:
-    if (ret == NULL)
-        OPENSSL_PUT_ERROR(PEM, ERR_R_ASN1_LIB);
+    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);
+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;
+                         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;
 }

package/third_party/boringssl/src/crypto/poly1305/poly1305_vec.c

@@ -27,22 +27,6 @@
 
 #include <emmintrin.h>
 
-static uint32_t load_u32_le(const uint8_t in[4]) {
-  uint32_t ret;
-  OPENSSL_memcpy(&ret, in, 4);
-  return ret;
-}
-
-static uint64_t load_u64_le(const uint8_t in[8]) {
-  uint64_t ret;
-  OPENSSL_memcpy(&ret, in, 8);
-  return ret;
-}
-
-static void store_u64_le(uint8_t out[8], uint64_t v) {
-  OPENSSL_memcpy(out, &v, 8);
-}
-
 typedef __m128i xmmi;
 
 static const alignas(16) uint32_t poly1305_x64_sse2_message_mask[4] = {
@@ -112,8 +96,8 @@ void CRYPTO_poly1305_init(poly1305_state *state, const uint8_t key[32]) {
   uint64_t t0, t1;
 
   // clamp key
-  t0 = load_u64_le(key + 0);
-  t1 = load_u64_le(key + 8);
+  t0 = CRYPTO_load_u64_le(key + 0);
+  t1 = CRYPTO_load_u64_le(key + 8);
   r0 = t0 & 0xffc0fffffff;
   t0 >>= 44;
   t0 |= t1 << 20;
@@ -131,10 +115,10 @@ void CRYPTO_poly1305_init(poly1305_state *state, const uint8_t key[32]) {
   p->R22.d[3] = (uint32_t)(r2 >> 32);
 
   // store pad
-  p->R23.d[1] = load_u32_le(key + 16);
-  p->R23.d[3] = load_u32_le(key + 20);
-  p->R24.d[1] = load_u32_le(key + 24);
-  p->R24.d[3] = load_u32_le(key + 28);
+  p->R23.d[1] = CRYPTO_load_u32_le(key + 16);
+  p->R23.d[3] = CRYPTO_load_u32_le(key + 20);
+  p->R24.d[1] = CRYPTO_load_u32_le(key + 24);
+  p->R24.d[3] = CRYPTO_load_u32_le(key + 28);
 
   // H = 0
   st->H[0] = _mm_setzero_si128();
@@ -766,8 +750,8 @@ void CRYPTO_poly1305_finish(poly1305_state *state, uint8_t mac[16]) {
   }
 
 poly1305_donna_atleast16bytes:
-  t0 = load_u64_le(m + 0);
-  t1 = load_u64_le(m + 8);
+  t0 = CRYPTO_load_u64_le(m + 0);
+  t1 = CRYPTO_load_u64_le(m + 8);
   h0 += t0 & 0xfffffffffff;
   t0 = shr128_pair(t1, t0, 44);
   h1 += t0 & 0xfffffffffff;
@@ -806,8 +790,8 @@ poly1305_donna_atmost15bytes:
   OPENSSL_memset(m + leftover, 0, 16 - leftover);
   leftover = 16;
 
-  t0 = load_u64_le(m + 0);
-  t1 = load_u64_le(m + 8);
+  t0 = CRYPTO_load_u64_le(m + 0);
+  t1 = CRYPTO_load_u64_le(m + 8);
   h0 += t0 & 0xfffffffffff;
   t0 = shr128_pair(t1, t0, 44);
   h1 += t0 & 0xfffffffffff;
@@ -853,8 +837,8 @@ poly1305_donna_finish:
   t1 = (t1 >> 24);
   h2 += (t1)+c;
 
-  store_u64_le(mac + 0, ((h0) | (h1 << 44)));
-  store_u64_le(mac + 8, ((h1 >> 20) | (h2 << 24)));
+  CRYPTO_store_u64_le(mac + 0, ((h0) | (h1 << 44)));
+  CRYPTO_store_u64_le(mac + 8, ((h1 >> 20) | (h2 << 24)));
 }
 
 #endif  // BORINGSSL_HAS_UINT128 && OPENSSL_X86_64