grpc 1.53.0 → 1.58.0

data/third_party/boringssl-with-bazel/src/crypto/evp/p_ed25519.c

@@ -27,7 +27,6 @@ static int pkey_ed25519_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) { return 1; }
 static int pkey_ed25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
   ED25519_KEY *key = OPENSSL_malloc(sizeof(ED25519_KEY));
   if (key == NULL) {
-    OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
     return 0;
   }
 
@@ -37,18 +36,18 @@ static int pkey_ed25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
   }
 
   uint8_t pubkey_unused[32];
-  ED25519_keypair(pubkey_unused, key->key.priv);
+  ED25519_keypair(pubkey_unused, key->key);
   key->has_private = 1;
 
-  OPENSSL_free(pkey->pkey.ptr);
-  pkey->pkey.ptr = key;
+  OPENSSL_free(pkey->pkey);
+  pkey->pkey = key;
   return 1;
 }
 
 static int pkey_ed25519_sign_message(EVP_PKEY_CTX *ctx, uint8_t *sig,
                                      size_t *siglen, const uint8_t *tbs,
                                      size_t tbslen) {
-  ED25519_KEY *key = ctx->pkey->pkey.ptr;
+  const ED25519_KEY *key = ctx->pkey->pkey;
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -64,7 +63,7 @@ static int pkey_ed25519_sign_message(EVP_PKEY_CTX *ctx, uint8_t *sig,
     return 0;
   }
 
-  if (!ED25519_sign(sig, tbs, tbslen, key->key.priv)) {
+  if (!ED25519_sign(sig, tbs, tbslen, key->key)) {
     return 0;
   }
 
@@ -75,9 +74,9 @@ static int pkey_ed25519_sign_message(EVP_PKEY_CTX *ctx, uint8_t *sig,
 static int pkey_ed25519_verify_message(EVP_PKEY_CTX *ctx, const uint8_t *sig,
                                        size_t siglen, const uint8_t *tbs,
                                        size_t tbslen) {
-  ED25519_KEY *key = ctx->pkey->pkey.ptr;
+  const ED25519_KEY *key = ctx->pkey->pkey;
   if (siglen != 64 ||
-      !ED25519_verify(tbs, tbslen, sig, key->key.pub.value)) {
+      !ED25519_verify(tbs, tbslen, sig, key->key + ED25519_PUBLIC_KEY_OFFSET)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_SIGNATURE);
     return 0;
   }

data/third_party/boringssl-with-bazel/src/crypto/evp/p_ed25519_asn1.c

@@ -24,8 +24,8 @@
 
 
 static void ed25519_free(EVP_PKEY *pkey) {
-  OPENSSL_free(pkey->pkey.ptr);
-  pkey->pkey.ptr = NULL;
+  OPENSSL_free(pkey->pkey);
+  pkey->pkey = NULL;
 }
 
 static int ed25519_set_priv_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
@@ -36,18 +36,17 @@ static int ed25519_set_priv_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
 
   ED25519_KEY *key = OPENSSL_malloc(sizeof(ED25519_KEY));
   if (key == NULL) {
-    OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
     return 0;
   }
 
   // The RFC 8032 encoding stores only the 32-byte seed, so we must recover the
   // full representation which we use from it.
   uint8_t pubkey_unused[32];
-  ED25519_keypair_from_seed(pubkey_unused, key->key.priv, in);
+  ED25519_keypair_from_seed(pubkey_unused, key->key, in);
   key->has_private = 1;
 
   ed25519_free(pkey);
-  pkey->pkey.ptr = key;
+  pkey->pkey = key;
   return 1;
 }
 
@@ -59,21 +58,20 @@ static int ed25519_set_pub_raw(EVP_PKEY *pkey, const uint8_t *in, size_t len) {
 
   ED25519_KEY *key = OPENSSL_malloc(sizeof(ED25519_KEY));
   if (key == NULL) {
-    OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
     return 0;
   }
 
-  OPENSSL_memcpy(key->key.pub.value, in, 32);
+  OPENSSL_memcpy(key->key + ED25519_PUBLIC_KEY_OFFSET, in, 32);
   key->has_private = 0;
 
   ed25519_free(pkey);
-  pkey->pkey.ptr = key;
+  pkey->pkey = key;
   return 1;
 }
 
 static int ed25519_get_priv_raw(const EVP_PKEY *pkey, uint8_t *out,
                                 size_t *out_len) {
-  const ED25519_KEY *key = pkey->pkey.ptr;
+  const ED25519_KEY *key = pkey->pkey;
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -90,14 +88,14 @@ static int ed25519_get_priv_raw(const EVP_PKEY *pkey, uint8_t *out,
   }
 
   // The raw private key format is the first 32 bytes of the private key.
-  OPENSSL_memcpy(out, key->key.priv, 32);
+  OPENSSL_memcpy(out, key->key, 32);
   *out_len = 32;
   return 1;
 }
 
 static int ed25519_get_pub_raw(const EVP_PKEY *pkey, uint8_t *out,
                                size_t *out_len) {
-  const ED25519_KEY *key = pkey->pkey.ptr;
+  const ED25519_KEY *key = pkey->pkey;
   if (out == NULL) {
     *out_len = 32;
     return 1;
@@ -108,7 +106,7 @@ static int ed25519_get_pub_raw(const EVP_PKEY *pkey, uint8_t *out,
     return 0;
   }
 
-  OPENSSL_memcpy(out, key->key.pub.value, 32);
+  OPENSSL_memcpy(out, key->key + ED25519_PUBLIC_KEY_OFFSET, 32);
   *out_len = 32;
   return 1;
 }
@@ -126,7 +124,7 @@ static int ed25519_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int ed25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
-  const ED25519_KEY *key = pkey->pkey.ptr;
+  const ED25519_KEY *key = pkey->pkey;
 
   // See RFC 8410, section 4.
   CBB spki, algorithm, oid, key_bitstring;
@@ -136,7 +134,8 @@ static int ed25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
       !CBB_add_bytes(&oid, ed25519_asn1_meth.oid, ed25519_asn1_meth.oid_len) ||
       !CBB_add_asn1(&spki, &key_bitstring, CBS_ASN1_BITSTRING) ||
       !CBB_add_u8(&key_bitstring, 0 /* padding */) ||
-      !CBB_add_bytes(&key_bitstring, key->key.pub.value, 32) ||
+      !CBB_add_bytes(&key_bitstring, key->key + ED25519_PUBLIC_KEY_OFFSET,
+                     32) ||
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -146,9 +145,10 @@ static int ed25519_pub_encode(CBB *out, const EVP_PKEY *pkey) {
 }
 
 static int ed25519_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  const ED25519_KEY *a_key = a->pkey.ptr;
-  const ED25519_KEY *b_key = b->pkey.ptr;
-  return OPENSSL_memcmp(a_key->key.pub.value, b_key->key.pub.value, 32) == 0;
+  const ED25519_KEY *a_key = a->pkey;
+  const ED25519_KEY *b_key = b->pkey;
+  return OPENSSL_memcmp(a_key->key + ED25519_PUBLIC_KEY_OFFSET,
+                        b_key->key + ED25519_PUBLIC_KEY_OFFSET, 32) == 0;
 }
 
 static int ed25519_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
@@ -168,7 +168,7 @@ static int ed25519_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int ed25519_priv_encode(CBB *out, const EVP_PKEY *pkey) {
-  ED25519_KEY *key = pkey->pkey.ptr;
+  const ED25519_KEY *key = pkey->pkey;
   if (!key->has_private) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_NOT_A_PRIVATE_KEY);
     return 0;
@@ -185,7 +185,7 @@ static int ed25519_priv_encode(CBB *out, const EVP_PKEY *pkey) {
       !CBB_add_asn1(&private_key, &inner, CBS_ASN1_OCTETSTRING) ||
       // The PKCS#8 encoding stores only the 32-byte seed which is the first 32
       // bytes of the private key.
-      !CBB_add_bytes(&inner, key->key.priv, 32) ||
+      !CBB_add_bytes(&inner, key->key, 32) ||
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -202,6 +202,7 @@ const EVP_PKEY_ASN1_METHOD ed25519_asn1_meth = {
     EVP_PKEY_ED25519,
     {0x2b, 0x65, 0x70},
     3,
+    &ed25519_pkey_meth,
     ed25519_pub_decode,
     ed25519_pub_encode,
     ed25519_pub_cmp,
@@ -211,11 +212,13 @@ const EVP_PKEY_ASN1_METHOD ed25519_asn1_meth = {
     ed25519_set_pub_raw,
     ed25519_get_priv_raw,
     ed25519_get_pub_raw,
-    NULL /* pkey_opaque */,
+    /*set1_tls_encodedpoint=*/NULL,
+    /*get1_tls_encodedpoint=*/NULL,
+    /*pkey_opaque=*/NULL,
     ed25519_size,
     ed25519_bits,
-    NULL /* param_missing */,
-    NULL /* param_copy */,
-    NULL /* param_cmp */,
+    /*param_missing=*/NULL,
+    /*param_copy=*/NULL,
+    /*param_cmp=*/NULL,
     ed25519_free,
 };

data/third_party/boringssl-with-bazel/src/crypto/evp/p_hkdf.c

@@ -0,0 +1,233 @@
+/* Copyright (c) 2022, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#include <openssl/evp.h>
+
+#include <openssl/bytestring.h>
+#include <openssl/err.h>
+#include <openssl/hkdf.h>
+#include <openssl/kdf.h>
+#include <openssl/mem.h>
+
+#include "../internal.h"
+#include "internal.h"
+
+
+typedef struct {
+  int mode;
+  const EVP_MD *md;
+  uint8_t *key;
+  size_t key_len;
+  uint8_t *salt;
+  size_t salt_len;
+  CBB info;
+} HKDF_PKEY_CTX;
+
+static int pkey_hkdf_init(EVP_PKEY_CTX *ctx) {
+  HKDF_PKEY_CTX *hctx = OPENSSL_malloc(sizeof(HKDF_PKEY_CTX));
+  if (hctx == NULL) {
+    return 0;
+  }
+
+  OPENSSL_memset(hctx, 0, sizeof(HKDF_PKEY_CTX));
+  if (!CBB_init(&hctx->info, 0)) {
+    OPENSSL_free(hctx);
+    return 0;
+  }
+
+  ctx->data = hctx;
+  return 1;
+}
+
+static int pkey_hkdf_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) {
+  if (!pkey_hkdf_init(dst)) {
+    return 0;
+  }
+
+  HKDF_PKEY_CTX *hctx_dst = dst->data;
+  const HKDF_PKEY_CTX *hctx_src = src->data;
+  hctx_dst->mode = hctx_src->mode;
+  hctx_dst->md = hctx_src->md;
+
+  if (hctx_src->key_len != 0) {
+    hctx_dst->key = OPENSSL_memdup(hctx_src->key, hctx_src->key_len);
+    if (hctx_dst->key == NULL) {
+      return 0;
+    }
+    hctx_dst->key_len = hctx_src->key_len;
+  }
+
+  if (hctx_src->salt_len != 0) {
+    hctx_dst->salt = OPENSSL_memdup(hctx_src->salt, hctx_src->salt_len);
+    if (hctx_dst->salt == NULL) {
+      return 0;
+    }
+    hctx_dst->salt_len = hctx_src->salt_len;
+  }
+
+  if (!CBB_add_bytes(&hctx_dst->info, CBB_data(&hctx_src->info),
+                     CBB_len(&hctx_src->info))) {
+    return 0;
+  }
+
+  return 1;
+}
+
+static void pkey_hkdf_cleanup(EVP_PKEY_CTX *ctx) {
+  HKDF_PKEY_CTX *hctx = ctx->data;
+  if (hctx != NULL) {
+    OPENSSL_free(hctx->key);
+    OPENSSL_free(hctx->salt);
+    CBB_cleanup(&hctx->info);
+    OPENSSL_free(hctx);
+    ctx->data = NULL;
+  }
+}
+
+static int pkey_hkdf_derive(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *out_len) {
+  HKDF_PKEY_CTX *hctx = ctx->data;
+  if (hctx->md == NULL) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_MISSING_PARAMETERS);
+    return 0;
+  }
+  if (hctx->key_len == 0) {
+    OPENSSL_PUT_ERROR(EVP, EVP_R_NO_KEY_SET);
+    return 0;
+  }
+
+  if (out == NULL) {
+    if (hctx->mode == EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY) {
+      *out_len = EVP_MD_size(hctx->md);
+    }
+    // HKDF-Expand is variable-length and returns |*out_len| bytes. "Output" the
+    // input length by leaving it alone.
+    return 1;
+  }
+
+  switch (hctx->mode) {
+    case EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND:
+      return HKDF(out, *out_len, hctx->md, hctx->key, hctx->key_len, hctx->salt,
+                  hctx->salt_len, CBB_data(&hctx->info), CBB_len(&hctx->info));
+
+    case EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY:
+      if (*out_len < EVP_MD_size(hctx->md)) {
+        OPENSSL_PUT_ERROR(EVP, EVP_R_BUFFER_TOO_SMALL);
+        return 0;
+      }
+      return HKDF_extract(out, out_len, hctx->md, hctx->key, hctx->key_len,
+                          hctx->salt, hctx->salt_len);
+
+    case EVP_PKEY_HKDEF_MODE_EXPAND_ONLY:
+      return HKDF_expand(out, *out_len, hctx->md, hctx->key, hctx->key_len,
+                         CBB_data(&hctx->info), CBB_len(&hctx->info));
+  }
+  OPENSSL_PUT_ERROR(EVP, ERR_R_INTERNAL_ERROR);
+  return 0;
+}
+
+static int pkey_hkdf_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
+  HKDF_PKEY_CTX *hctx = ctx->data;
+  switch (type) {
+    case EVP_PKEY_CTRL_HKDF_MODE:
+      if (p1 != EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND &&
+          p1 != EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY &&
+          p1 != EVP_PKEY_HKDEF_MODE_EXPAND_ONLY) {
+        OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_OPERATION);
+        return 0;
+      }
+      hctx->mode = p1;
+      return 1;
+    case EVP_PKEY_CTRL_HKDF_MD:
+      hctx->md = p2;
+      return 1;
+    case EVP_PKEY_CTRL_HKDF_KEY: {
+      const CBS *key = p2;
+      if (!CBS_stow(key, &hctx->key, &hctx->key_len)) {
+        return 0;
+      }
+      return 1;
+    }
+    case EVP_PKEY_CTRL_HKDF_SALT: {
+      const CBS *salt = p2;
+      if (!CBS_stow(salt, &hctx->salt, &hctx->salt_len)) {
+        return 0;
+      }
+      return 1;
+    }
+    case EVP_PKEY_CTRL_HKDF_INFO: {
+      const CBS *info = p2;
+      // |EVP_PKEY_CTX_add1_hkdf_info| appends to the info string, rather than
+      // replacing it.
+      if (!CBB_add_bytes(&hctx->info, CBS_data(info), CBS_len(info))) {
+        return 0;
+      }
+      return 1;
+    }
+    default:
+      OPENSSL_PUT_ERROR(EVP, EVP_R_COMMAND_NOT_SUPPORTED);
+      return 0;
+  }
+}
+
+const EVP_PKEY_METHOD hkdf_pkey_meth = {
+    EVP_PKEY_HKDF,
+    pkey_hkdf_init,
+    pkey_hkdf_copy,
+    pkey_hkdf_cleanup,
+    /*keygen=*/NULL,
+    /*sign=*/NULL,
+    /*sign_message=*/NULL,
+    /*verify=*/NULL,
+    /*verify_message=*/NULL,
+    /*verify_recover=*/NULL,
+    /*encrypt=*/NULL,
+    /*decrypt=*/NULL,
+    pkey_hkdf_derive,
+    /*paramgen=*/NULL,
+    pkey_hkdf_ctrl,
+};
+
+int EVP_PKEY_CTX_hkdf_mode(EVP_PKEY_CTX *ctx, int mode) {
+  return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_HKDF, EVP_PKEY_OP_DERIVE,
+                           EVP_PKEY_CTRL_HKDF_MODE, mode, NULL);
+}
+
+int EVP_PKEY_CTX_set_hkdf_md(EVP_PKEY_CTX *ctx, const EVP_MD *md) {
+  return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_HKDF, EVP_PKEY_OP_DERIVE,
+                           EVP_PKEY_CTRL_HKDF_MD, 0, (void *)md);
+}
+
+int EVP_PKEY_CTX_set1_hkdf_key(EVP_PKEY_CTX *ctx, const uint8_t *key,
+                               size_t key_len) {
+  CBS cbs;
+  CBS_init(&cbs, key, key_len);
+  return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_HKDF, EVP_PKEY_OP_DERIVE,
+                           EVP_PKEY_CTRL_HKDF_KEY, 0, &cbs);
+}
+
+int EVP_PKEY_CTX_set1_hkdf_salt(EVP_PKEY_CTX *ctx, const uint8_t *salt,
+                                size_t salt_len) {
+  CBS cbs;
+  CBS_init(&cbs, salt, salt_len);
+  return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_HKDF, EVP_PKEY_OP_DERIVE,
+                           EVP_PKEY_CTRL_HKDF_SALT, 0, &cbs);
+}
+
+int EVP_PKEY_CTX_add1_hkdf_info(EVP_PKEY_CTX *ctx, const uint8_t *info,
+                                size_t info_len) {
+  CBS cbs;
+  CBS_init(&cbs, info, info_len);
+  return EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_HKDF, EVP_PKEY_OP_DERIVE,
+                           EVP_PKEY_CTRL_HKDF_INFO, 0, &cbs);
+}

data/third_party/boringssl-with-bazel/src/crypto/evp/p_rsa.c

@@ -67,7 +67,7 @@
 #include <openssl/rsa.h>
 
 #include "../internal.h"
-#include "../fipsmodule/rsa/internal.h"
+#include "../rsa_extra/internal.h"
 #include "internal.h"
 
 
@@ -171,7 +171,7 @@ static int setup_tbuf(RSA_PKEY_CTX *ctx, EVP_PKEY_CTX *pk) {
 static int pkey_rsa_sign(EVP_PKEY_CTX *ctx, uint8_t *sig, size_t *siglen,
                          const uint8_t *tbs, size_t tbslen) {
   RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey.rsa;
+  RSA *rsa = ctx->pkey->pkey;
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (!sig) {
@@ -210,7 +210,7 @@ static int pkey_rsa_verify(EVP_PKEY_CTX *ctx, const uint8_t *sig,
                            size_t siglen, const uint8_t *tbs,
                            size_t tbslen) {
   RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey.rsa;
+  RSA *rsa = ctx->pkey->pkey;
 
   if (rctx->md) {
     switch (rctx->pad_mode) {
@@ -243,7 +243,7 @@ static int pkey_rsa_verify_recover(EVP_PKEY_CTX *ctx, uint8_t *out,
                                    size_t *out_len, const uint8_t *sig,
                                    size_t sig_len) {
   RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey.rsa;
+  RSA *rsa = ctx->pkey->pkey;
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (out == NULL) {
@@ -307,7 +307,7 @@ static int pkey_rsa_verify_recover(EVP_PKEY_CTX *ctx, uint8_t *out,
 static int pkey_rsa_encrypt(EVP_PKEY_CTX *ctx, uint8_t *out, size_t *outlen,
                             const uint8_t *in, size_t inlen) {
   RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey.rsa;
+  RSA *rsa = ctx->pkey->pkey;
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (!out) {
@@ -339,7 +339,7 @@ static int pkey_rsa_decrypt(EVP_PKEY_CTX *ctx, uint8_t *out,
                             size_t *outlen, const uint8_t *in,
                             size_t inlen) {
   RSA_PKEY_CTX *rctx = ctx->data;
-  RSA *rsa = ctx->pkey->pkey.rsa;
+  RSA *rsa = ctx->pkey->pkey;
   const size_t key_len = EVP_PKEY_size(ctx->pkey);
 
   if (!out) {

data/third_party/boringssl-with-bazel/src/crypto/evp/p_rsa_asn1.c

@@ -68,6 +68,7 @@
 
 static int rsa_pub_encode(CBB *out, const EVP_PKEY *key) {
   // See RFC 3279, section 2.3.1.
+  const RSA *rsa = key->pkey;
   CBB spki, algorithm, oid, null, key_bitstring;
   if (!CBB_add_asn1(out, &spki, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1(&spki, &algorithm, CBS_ASN1_SEQUENCE) ||
@@ -76,7 +77,7 @@ static int rsa_pub_encode(CBB *out, const EVP_PKEY *key) {
       !CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||
       !CBB_add_asn1(&spki, &key_bitstring, CBS_ASN1_BITSTRING) ||
       !CBB_add_u8(&key_bitstring, 0 /* padding */) ||
-      !RSA_marshal_public_key(&key_bitstring, key->pkey.rsa) ||
+      !RSA_marshal_public_key(&key_bitstring, rsa) ||
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -109,11 +110,14 @@ static int rsa_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int rsa_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
-  return BN_cmp(b->pkey.rsa->n, a->pkey.rsa->n) == 0 &&
-         BN_cmp(b->pkey.rsa->e, a->pkey.rsa->e) == 0;
+  const RSA *a_rsa = a->pkey;
+  const RSA *b_rsa = b->pkey;
+  return BN_cmp(RSA_get0_n(b_rsa), RSA_get0_n(a_rsa)) == 0 &&
+         BN_cmp(RSA_get0_e(b_rsa), RSA_get0_e(a_rsa)) == 0;
 }
 
 static int rsa_priv_encode(CBB *out, const EVP_PKEY *key) {
+  const RSA *rsa = key->pkey;
   CBB pkcs8, algorithm, oid, null, private_key;
   if (!CBB_add_asn1(out, &pkcs8, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1_uint64(&pkcs8, 0 /* version */) ||
@@ -122,7 +126,7 @@ static int rsa_priv_encode(CBB *out, const EVP_PKEY *key) {
       !CBB_add_bytes(&oid, rsa_asn1_meth.oid, rsa_asn1_meth.oid_len) ||
       !CBB_add_asn1(&algorithm, &null, CBS_ASN1_NULL) ||
       !CBB_add_asn1(&pkcs8, &private_key, CBS_ASN1_OCTETSTRING) ||
-      !RSA_marshal_private_key(&private_key, key->pkey.rsa) ||
+      !RSA_marshal_private_key(&private_key, rsa) ||
       !CBB_flush(out)) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_ENCODE_ERROR);
     return 0;
@@ -153,42 +157,55 @@ static int rsa_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
 }
 
 static int rsa_opaque(const EVP_PKEY *pkey) {
-  return RSA_is_opaque(pkey->pkey.rsa);
+  const RSA *rsa = pkey->pkey;
+  return RSA_is_opaque(rsa);
 }
 
 static int int_rsa_size(const EVP_PKEY *pkey) {
-  return RSA_size(pkey->pkey.rsa);
+  const RSA *rsa = pkey->pkey;
+  return RSA_size(rsa);
 }
 
 static int rsa_bits(const EVP_PKEY *pkey) {
-  return RSA_bits(pkey->pkey.rsa);
+  const RSA *rsa = pkey->pkey;
+  return RSA_bits(rsa);
 }
 
-static void int_rsa_free(EVP_PKEY *pkey) { RSA_free(pkey->pkey.rsa); }
+static void int_rsa_free(EVP_PKEY *pkey) {
+  RSA_free(pkey->pkey);
+  pkey->pkey = NULL;
+}
 
 const EVP_PKEY_ASN1_METHOD rsa_asn1_meth = {
-  EVP_PKEY_RSA,
-  // 1.2.840.113549.1.1.1
-  {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01}, 9,
+    EVP_PKEY_RSA,
+    // 1.2.840.113549.1.1.1
+    {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01},
+    9,
+
+    &rsa_pkey_meth,
 
-  rsa_pub_decode,
-  rsa_pub_encode,
-  rsa_pub_cmp,
+    rsa_pub_decode,
+    rsa_pub_encode,
+    rsa_pub_cmp,
 
-  rsa_priv_decode,
-  rsa_priv_encode,
+    rsa_priv_decode,
+    rsa_priv_encode,
 
-  NULL /* set_priv_raw */,
-  NULL /* set_pub_raw */,
-  NULL /* get_priv_raw */,
-  NULL /* get_pub_raw */,
+    /*set_priv_raw=*/NULL,
+    /*set_pub_raw=*/NULL,
+    /*get_priv_raw=*/NULL,
+    /*get_pub_raw=*/NULL,
+    /*set1_tls_encodedpoint=*/NULL,
+    /*get1_tls_encodedpoint=*/NULL,
 
-  rsa_opaque,
+    rsa_opaque,
 
-  int_rsa_size,
-  rsa_bits,
+    int_rsa_size,
+    rsa_bits,
 
-  0,0,0,
+    0,
+    0,
+    0,
 
-  int_rsa_free,
+    int_rsa_free,
 };

data/third_party/boringssl-with-bazel/src/crypto/evp/p_x25519.c

@@ -27,7 +27,6 @@ static int pkey_x25519_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src) { return 1; }
 static int pkey_x25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
   X25519_KEY *key = OPENSSL_malloc(sizeof(X25519_KEY));
   if (key == NULL) {
-    OPENSSL_PUT_ERROR(EVP, ERR_R_MALLOC_FAILURE);
     return 0;
   }
 
@@ -39,8 +38,8 @@ static int pkey_x25519_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
   X25519_keypair(key->pub, key->priv);
   key->has_private = 1;
 
-  OPENSSL_free(pkey->pkey.ptr);
-  pkey->pkey.ptr = key;
+  OPENSSL_free(pkey->pkey);
+  pkey->pkey = key;
   return 1;
 }
 
@@ -51,8 +50,8 @@ static int pkey_x25519_derive(EVP_PKEY_CTX *ctx, uint8_t *out,
     return 0;
   }
 
-  const X25519_KEY *our_key = ctx->pkey->pkey.ptr;
-  const X25519_KEY *peer_key = ctx->peerkey->pkey.ptr;
+  const X25519_KEY *our_key = ctx->pkey->pkey;
+  const X25519_KEY *peer_key = ctx->peerkey->pkey;
   if (our_key == NULL || peer_key == NULL) {
     OPENSSL_PUT_ERROR(EVP, EVP_R_KEYS_NOT_SET);
     return 0;