grpc 1.69.0 → 1.70.1

data/third_party/boringssl-with-bazel/src/crypto/bytestring/{cbs.c → cbs.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -50,7 +50,7 @@ int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len) {
   if (cbs->len == 0) {
     return 1;
   }
-  *out_ptr = OPENSSL_memdup(cbs->data, cbs->len);
+  *out_ptr = reinterpret_cast<uint8_t *>(OPENSSL_memdup(cbs->data, cbs->len));
   if (*out_ptr == NULL) {
     return 0;
   }
@@ -62,7 +62,7 @@ int CBS_strdup(const CBS *cbs, char **out_ptr) {
   if (*out_ptr != NULL) {
     OPENSSL_free(*out_ptr);
   }
-  *out_ptr = OPENSSL_strndup((const char*)cbs->data, cbs->len);
+  *out_ptr = OPENSSL_strndup((const char *)cbs->data, cbs->len);
   return (*out_ptr != NULL);
 }
 
@@ -144,9 +144,7 @@ int CBS_get_u32le(CBS *cbs, uint32_t *out) {
   return 1;
 }
 
-int CBS_get_u64(CBS *cbs, uint64_t *out) {
-  return cbs_get_u(cbs, out, 8);
-}
+int CBS_get_u64(CBS *cbs, uint64_t *out) { return cbs_get_u(cbs, out, 8); }
 
 int CBS_get_u64le(CBS *cbs, uint64_t *out) {
   if (!cbs_get_u(cbs, out, 8)) {
@@ -207,7 +205,8 @@ int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out) {
 }
 
 int CBS_get_until_first(CBS *cbs, CBS *out, uint8_t c) {
-  const uint8_t *split = OPENSSL_memchr(CBS_data(cbs), c, CBS_len(cbs));
+  const uint8_t *split = reinterpret_cast<const uint8_t *>(
+      OPENSSL_memchr(CBS_data(cbs), c, CBS_len(cbs)));
   if (split == NULL) {
     return 0;
   }
@@ -223,7 +222,7 @@ int CBS_get_u64_decimal(CBS *cbs, uint64_t *out) {
       break;
     }
     CBS_skip(cbs, 1);
-    if (// Forbid stray leading zeros.
+    if (/* Forbid stray leading zeros */
         (v == 0 && seen_digit) ||
         // Check for overflow.
         v > UINT64_MAX / 10 ||  //
@@ -341,7 +340,7 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
   // 8.1.3.
   if ((length_byte & 0x80) == 0) {
     // Short form length.
-    len = ((size_t) length_byte) + header_len;
+    len = ((size_t)length_byte) + header_len;
     if (out_header_len != NULL) {
       *out_header_len = header_len;
     }
@@ -420,7 +419,7 @@ int CBS_get_any_asn1(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag) {
 }
 
 int CBS_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
-                                    size_t *out_header_len) {
+                             size_t *out_header_len) {
   return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, NULL, NULL,
                                   /*ber_ok=*/0);
 }
@@ -515,8 +514,7 @@ int CBS_get_asn1_int64(CBS *cbs, int64_t *out) {
 
 int CBS_get_asn1_bool(CBS *cbs, int *out) {
   CBS bytes;
-  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_BOOLEAN) ||
-      CBS_len(&bytes) != 1) {
+  if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_BOOLEAN) || CBS_len(&bytes) != 1) {
     return 0;
   }
 
@@ -529,7 +527,8 @@ int CBS_get_asn1_bool(CBS *cbs, int *out) {
   return 1;
 }
 
-int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, CBS_ASN1_TAG tag) {
+int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present,
+                          CBS_ASN1_TAG tag) {
   int present = 0;
 
   if (CBS_peek_asn1_tag(cbs, tag)) {
@@ -576,8 +575,7 @@ int CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, CBS_ASN1_TAG tag,
     return 0;
   }
   if (present) {
-    if (!CBS_get_asn1_uint64(&child, out) ||
-        CBS_len(&child) != 0) {
+    if (!CBS_get_asn1_uint64(&child, out) || CBS_len(&child) != 0) {
       return 0;
     }
   } else {
@@ -597,8 +595,7 @@ int CBS_get_optional_asn1_bool(CBS *cbs, int *out, CBS_ASN1_TAG tag,
     uint8_t boolean;
 
     if (!CBS_get_asn1(&child, &child2, CBS_ASN1_BOOLEAN) ||
-        CBS_len(&child2) != 1 ||
-        CBS_len(&child) != 0) {
+        CBS_len(&child2) != 1 || CBS_len(&child) != 0) {
       return 0;
     }
 
@@ -619,8 +616,7 @@ int CBS_get_optional_asn1_bool(CBS *cbs, int *out, CBS_ASN1_TAG tag,
 int CBS_is_valid_asn1_bitstring(const CBS *cbs) {
   CBS in = *cbs;
   uint8_t num_unused_bits;
-  if (!CBS_get_u8(&in, &num_unused_bits) ||
-      num_unused_bits > 7) {
+  if (!CBS_get_u8(&in, &num_unused_bits) || num_unused_bits > 7) {
     return 0;
   }
 
@@ -707,12 +703,12 @@ int CBS_is_valid_asn1_oid(const CBS *cbs) {
 }
 
 char *CBS_asn1_oid_to_text(const CBS *cbs) {
+  CBS copy = *cbs;
   CBB cbb;
   if (!CBB_init(&cbb, 32)) {
     goto err;
   }
 
-  CBS copy = *cbs;
   // The first component is 40 * value1 + value2, where value1 is 0, 1, or 2.
   uint64_t v;
   if (!parse_base128_integer(&copy, &v)) {
@@ -724,15 +720,13 @@ char *CBS_asn1_oid_to_text(const CBS *cbs) {
         !add_decimal(&cbb, v - 80)) {
       goto err;
     }
-  } else if (!add_decimal(&cbb, v / 40) ||
-             !CBB_add_u8(&cbb, '.') ||
+  } else if (!add_decimal(&cbb, v / 40) || !CBB_add_u8(&cbb, '.') ||
              !add_decimal(&cbb, v % 40)) {
     goto err;
   }
 
   while (CBS_len(&copy) != 0) {
-    if (!parse_base128_integer(&copy, &v) ||
-        !CBB_add_u8(&cbb, '.') ||
+    if (!parse_base128_integer(&copy, &v) || !CBB_add_u8(&cbb, '.') ||
         !add_decimal(&cbb, v)) {
       goto err;
     }
@@ -740,8 +734,7 @@ char *CBS_asn1_oid_to_text(const CBS *cbs) {
 
   uint8_t *txt;
   size_t txt_len;
-  if (!CBB_add_u8(&cbb, '\0') ||
-      !CBB_finish(&cbb, &txt, &txt_len)) {
+  if (!CBB_add_u8(&cbb, '\0') || !CBB_finish(&cbb, &txt, &txt_len)) {
     goto err;
   }
 
@@ -814,7 +807,7 @@ static int CBS_parse_rfc5280_time_internal(const CBS *cbs, int is_gentime,
     if (!cbs_get_two_digits(&copy, &tmp)) {
       return 0;
     }
-      year += tmp;
+    year += tmp;
   } else {
     year = 1900;
     if (!cbs_get_two_digits(&copy, &tmp)) {

data/third_party/boringssl-with-bazel/src/crypto/bytestring/internal.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/bytestring/{unicode.c → unicode.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, Google Inc.
+/* Copyright 2018 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/chacha/{chacha.c → chacha.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/chacha/internal.h

@@ -1,4 +1,4 @@
-/* Copyright (c) 2018, Google Inc.
+/* Copyright 2018 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_aesctrhmac.c → e_aesctrhmac.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_aesgcmsiv.c → e_aesgcmsiv.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017, Google Inc.
+/* Copyright 2017 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -36,7 +36,7 @@
 // Optimised AES-GCM-SIV
 
 struct aead_aes_gcm_siv_asm_ctx {
-  alignas(16) uint8_t key[16*15];
+  alignas(16) uint8_t key[16 * 15];
   int is_128_bit;
 };
 
@@ -57,15 +57,17 @@ static struct aead_aes_gcm_siv_asm_ctx *asm_ctx_from_ctx(
   return (struct aead_aes_gcm_siv_asm_ctx *)(&ctx->state.opaque[offset]);
 }
 
+extern "C" {
 // aes128gcmsiv_aes_ks writes an AES-128 key schedule for |key| to
 // |out_expanded_key|.
-extern void aes128gcmsiv_aes_ks(
-    const uint8_t key[16], uint8_t out_expanded_key[16*15]);
+extern void aes128gcmsiv_aes_ks(const uint8_t key[16],
+                                uint8_t out_expanded_key[16 * 15]);
 
 // aes256gcmsiv_aes_ks writes an AES-256 key schedule for |key| to
 // |out_expanded_key|.
-extern void aes256gcmsiv_aes_ks(
-    const uint8_t key[32], uint8_t out_expanded_key[16*15]);
+extern void aes256gcmsiv_aes_ks(const uint8_t key[32],
+                                uint8_t out_expanded_key[16 * 15]);
+}
 
 static int aead_aes_gcm_siv_asm_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                                      size_t key_len, size_t tag_len) {
@@ -103,6 +105,7 @@ static int aead_aes_gcm_siv_asm_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
 
 static void aead_aes_gcm_siv_asm_cleanup(EVP_AEAD_CTX *ctx) {}
 
+extern "C" {
 // aesgcmsiv_polyval_horner updates the POLYVAL value in |in_out_poly| to
 // include a number (|in_blocks|) of 16-byte blocks of data from |in|, given
 // the POLYVAL key in |key|.
@@ -217,6 +220,7 @@ extern void aes256gcmsiv_enc_msg_x8(const uint8_t *in, uint8_t *out,
                                     const uint8_t *tag,
                                     const struct aead_aes_gcm_siv_asm_ctx *key,
                                     size_t in_len);
+}
 
 // gcm_siv_asm_polyval evaluates POLYVAL at |auth_key| on the given plaintext
 // and AD. The result is written to |out_tag|.
@@ -228,7 +232,7 @@ static void gcm_siv_asm_polyval(uint8_t out_tag[16], const uint8_t *in,
   const size_t ad_blocks = ad_len / 16;
   const size_t in_blocks = in_len / 16;
   int htable_init = 0;
-  alignas(16) uint8_t htable[16*8];
+  alignas(16) uint8_t htable[16 * 8];
 
   if (ad_blocks > 8 || in_blocks > 8) {
     htable_init = 1;
@@ -335,8 +339,7 @@ static int aead_aes_gcm_siv_asm_seal_scatter(
   const uint64_t in_len_64 = in_len;
   const uint64_t ad_len_64 = ad_len;
 
-  if (in_len_64 > (UINT64_C(1) << 36) ||
-      ad_len_64 >= (UINT64_C(1) << 61)) {
+  if (in_len_64 > (UINT64_C(1) << 36) || ad_len_64 >= (UINT64_C(1) << 61)) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);
     return 0;
   }
@@ -424,9 +427,9 @@ static int aead_aes_gcm_siv_asm_open_gather(
 
   struct aead_aes_gcm_siv_asm_ctx expanded_key;
   if (gcm_siv_ctx->is_128_bit) {
-    aes128gcmsiv_aes_ks((const uint8_t *) record_enc_key, &expanded_key.key[0]);
+    aes128gcmsiv_aes_ks((const uint8_t *)record_enc_key, &expanded_key.key[0]);
   } else {
-    aes256gcmsiv_aes_ks((const uint8_t *) record_enc_key, &expanded_key.key[0]);
+    aes256gcmsiv_aes_ks((const uint8_t *)record_enc_key, &expanded_key.key[0]);
   }
   // calculated_tag is 16*8 bytes, rather than 16 bytes, because
   // aes[128|256]gcmsiv_dec uses the extra as scratch space.
@@ -535,7 +538,7 @@ struct aead_aes_gcm_siv_ctx {
     AES_KEY ks;
   } ks;
   block128_f kgk_block;
-  unsigned is_256:1;
+  unsigned is_256 : 1;
 };
 
 static_assert(sizeof(((EVP_AEAD_CTX *)NULL)->state) >=
@@ -635,8 +638,8 @@ static void gcm_siv_polyval(
   }
 
   uint8_t length_block[16];
-  CRYPTO_store_u64_le(length_block, ((uint64_t) ad_len) * 8);
-  CRYPTO_store_u64_le(length_block + 8, ((uint64_t) in_len) * 8);
+  CRYPTO_store_u64_le(length_block, ((uint64_t)ad_len) * 8);
+  CRYPTO_store_u64_le(length_block + 8, ((uint64_t)in_len) * 8);
   CRYPTO_POLYVAL_update_blocks(&polyval_ctx, length_block,
                                sizeof(length_block));
 
@@ -659,10 +662,9 @@ struct gcm_siv_record_keys {
 
 // gcm_siv_keys calculates the keys for a specific GCM-SIV record with the
 // given nonce and writes them to |*out_keys|.
-static void gcm_siv_keys(
-    const struct aead_aes_gcm_siv_ctx *gcm_siv_ctx,
-    struct gcm_siv_record_keys *out_keys,
-    const uint8_t nonce[EVP_AEAD_AES_GCM_SIV_NONCE_LEN]) {
+static void gcm_siv_keys(const struct aead_aes_gcm_siv_ctx *gcm_siv_ctx,
+                         struct gcm_siv_record_keys *out_keys,
+                         const uint8_t nonce[EVP_AEAD_AES_GCM_SIV_NONCE_LEN]) {
   const AES_KEY *const key = &gcm_siv_ctx->ks.ks;
   uint8_t key_material[(128 /* POLYVAL key */ + 256 /* max AES key */) / 8];
   const size_t blocks_needed = gcm_siv_ctx->is_256 ? 6 : 4;
@@ -703,8 +705,7 @@ static int aead_aes_gcm_siv_seal_scatter(
   const uint64_t ad_len_64 = ad_len;
 
   if (in_len + EVP_AEAD_AES_GCM_SIV_TAG_LEN < in_len ||
-      in_len_64 > (UINT64_C(1) << 36) ||
-      ad_len_64 >= (UINT64_C(1) << 61)) {
+      in_len_64 > (UINT64_C(1) << 36) || ad_len_64 >= (UINT64_C(1) << 61)) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);
     return 0;
   }
@@ -830,12 +831,8 @@ const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) {
 
 #else
 
-const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void) {
-  return &aead_aes_128_gcm_siv;
-}
+const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void) { return &aead_aes_128_gcm_siv; }
 
-const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) {
-  return &aead_aes_256_gcm_siv;
-}
+const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) { return &aead_aes_256_gcm_siv; }
 
 #endif  // AES_GCM_SIV_ASM

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_chacha20poly1305.c → e_chacha20poly1305.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -41,13 +41,6 @@ static_assert(alignof(union evp_aead_ctx_st_state) >=
 
 static int aead_chacha20_poly1305_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
                                        size_t key_len, size_t tag_len) {
-  // TODO(crbug.com/42290548): The x86_64 assembly depends on initializing
-  // |OPENSSL_ia32cap_P|. Move the dispatch to C. While we're here, it may be
-  // worth adjusting the assembly calling convention. The assembly functions do
-  // too much work right now. For now, explicitly initialize |OPENSSL_ia32cap_P|
-  // first.
-  OPENSSL_init_cpuid();
-
   struct aead_chacha20_poly1305_ctx *c20_ctx =
       (struct aead_chacha20_poly1305_ctx *)&ctx->state;
 

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_des.c → e_des.cc}

@@ -85,14 +85,16 @@ static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
 }
 
 static const EVP_CIPHER evp_des_cbc = {
-    .nid = NID_des_cbc,
-    .block_size = 8,
-    .key_len = 8,
-    .iv_len = 8,
-    .ctx_size = sizeof(EVP_DES_KEY),
-    .flags = EVP_CIPH_CBC_MODE,
-    .init = des_init_key,
-    .cipher = des_cbc_cipher,
+    /*nid=*/NID_des_cbc,
+    /*block_size=*/8,
+    /*key_len=*/8,
+    /*iv_len=*/8,
+    /*ctx_size=*/sizeof(EVP_DES_KEY),
+    /*flags=*/EVP_CIPH_CBC_MODE,
+    /*init=*/des_init_key,
+    /*cipher=*/des_cbc_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_des_cbc(void) { return &evp_des_cbc; }
@@ -112,14 +114,16 @@ static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
 }
 
 static const EVP_CIPHER evp_des_ecb = {
-    .nid = NID_des_ecb,
-    .block_size = 8,
-    .key_len = 8,
-    .iv_len = 0,
-    .ctx_size = sizeof(EVP_DES_KEY),
-    .flags = EVP_CIPH_ECB_MODE,
-    .init = des_init_key,
-    .cipher = des_ecb_cipher,
+    /*nid=*/NID_des_ecb,
+    /*block_size=*/8,
+    /*key_len=*/8,
+    /*iv_len=*/0,
+    /*ctx_size=*/sizeof(EVP_DES_KEY),
+    /*flags=*/EVP_CIPH_ECB_MODE,
+    /*init=*/des_init_key,
+    /*cipher=*/des_ecb_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_des_ecb(void) { return &evp_des_ecb; }
@@ -149,14 +153,16 @@ static int des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
 }
 
 static const EVP_CIPHER evp_des_ede3_cbc = {
-    .nid = NID_des_ede3_cbc,
-    .block_size = 8,
-    .key_len = 24,
-    .iv_len = 8,
-    .ctx_size = sizeof(DES_EDE_KEY),
-    .flags = EVP_CIPH_CBC_MODE,
-    .init = des_ede3_init_key,
-    .cipher = des_ede3_cbc_cipher,
+    /*nid=*/NID_des_ede3_cbc,
+    /*block_size=*/8,
+    /*key_len=*/24,
+    /*iv_len=*/8,
+    /*ctx_size=*/sizeof(DES_EDE_KEY),
+    /*flags=*/EVP_CIPH_CBC_MODE,
+    /*init=*/des_ede3_init_key,
+    /*cipher=*/des_ede3_cbc_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_des_ede3_cbc(void) { return &evp_des_ede3_cbc; }
@@ -172,14 +178,16 @@ static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
 }
 
 static const EVP_CIPHER evp_des_ede_cbc = {
-    .nid = NID_des_ede_cbc,
-    .block_size = 8,
-    .key_len = 16,
-    .iv_len = 8,
-    .ctx_size = sizeof(DES_EDE_KEY),
-    .flags = EVP_CIPH_CBC_MODE,
-    .init = des_ede_init_key,
-    .cipher = des_ede3_cbc_cipher,
+    /*nid=*/NID_des_ede_cbc,
+    /*block_size=*/8,
+    /*key_len=*/16,
+    /*iv_len=*/8,
+    /*ctx_size=*/sizeof(DES_EDE_KEY),
+    /*flags=*/EVP_CIPH_CBC_MODE,
+    /*init=*/des_ede_init_key,
+    /*cipher=*/des_ede3_cbc_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_des_ede_cbc(void) { return &evp_des_ede_cbc; }
@@ -191,7 +199,7 @@ static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
   }
   in_len -= ctx->cipher->block_size;
 
-  DES_EDE_KEY *dat = (DES_EDE_KEY *) ctx->cipher_data;
+  DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data;
   for (size_t i = 0; i <= in_len; i += ctx->cipher->block_size) {
     DES_ecb3_encrypt_ex(in + i, out + i, &dat->ks.ks[0], &dat->ks.ks[1],
                         &dat->ks.ks[2], ctx->encrypt);
@@ -200,27 +208,31 @@ static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
 }
 
 static const EVP_CIPHER evp_des_ede = {
-    .nid = NID_des_ede_ecb,
-    .block_size = 8,
-    .key_len = 16,
-    .iv_len = 0,
-    .ctx_size = sizeof(DES_EDE_KEY),
-    .flags = EVP_CIPH_ECB_MODE,
-    .init = des_ede_init_key,
-    .cipher = des_ede_ecb_cipher,
+    /*nid=*/NID_des_ede_ecb,
+    /*block_size=*/8,
+    /*key_len=*/16,
+    /*iv_len=*/0,
+    /*ctx_size=*/sizeof(DES_EDE_KEY),
+    /*flags=*/EVP_CIPH_ECB_MODE,
+    /*init=*/des_ede_init_key,
+    /*cipher=*/des_ede_ecb_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_des_ede(void) { return &evp_des_ede; }
 
 static const EVP_CIPHER evp_des_ede3 = {
-    .nid = NID_des_ede3_ecb,
-    .block_size = 8,
-    .key_len = 24,
-    .iv_len = 0,
-    .ctx_size = sizeof(DES_EDE_KEY),
-    .flags = EVP_CIPH_ECB_MODE,
-    .init = des_ede3_init_key,
-    .cipher = des_ede_ecb_cipher,
+    /*nid=*/NID_des_ede3_ecb,
+    /*block_size=*/8,
+    /*key_len=*/24,
+    /*iv_len=*/0,
+    /*ctx_size=*/sizeof(DES_EDE_KEY),
+    /*flags=*/EVP_CIPH_ECB_MODE,
+    /*init=*/des_ede3_init_key,
+    /*cipher=*/des_ede_ecb_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_des_ede3(void) { return &evp_des_ede3; }

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_null.c → e_null.cc}

@@ -69,8 +69,8 @@ static int null_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
   return 1;
 }
 
-static int null_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
-                       const uint8_t *in, size_t in_len) {
+static int null_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
+                       size_t in_len) {
   if (in != out) {
     OPENSSL_memcpy(out, in, in_len);
   }
@@ -78,13 +78,16 @@ static int null_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
 }
 
 static const EVP_CIPHER n_cipher = {
-    .nid = NID_undef,
-    .block_size = 1,
-    .key_len = 0,
-    .iv_len = 0,
-    .ctx_size = 0,
-    .init = null_init_key,
-    .cipher = null_cipher,
+    /*nid=*/NID_undef,
+    /*block_size=*/1,
+    /*key_len=*/0,
+    /*iv_len=*/0,
+    /*ctx_size=*/0,
+    /*flags=*/0,
+    /*init=*/null_init_key,
+    /*cipher=*/null_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_enc_null(void) { return &n_cipher; }

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_rc2.c → e_rc2.cc}

@@ -138,7 +138,9 @@
     }                                               \
   } while (0)
 
-typedef struct rc2_key_st { uint16_t data[64]; } RC2_KEY;
+typedef struct rc2_key_st {
+  uint16_t data[64];
+} RC2_KEY;
 
 static void RC2_encrypt(uint32_t *d, RC2_KEY *key) {
   int i, n;
@@ -427,29 +429,31 @@ static int rc2_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) {
 }
 
 static const EVP_CIPHER rc2_40_cbc = {
-    .nid = NID_rc2_40_cbc,
-    .block_size = 8,
-    .key_len = 5 /* 40 bit */,
-    .iv_len = 8,
-    .ctx_size = sizeof(EVP_RC2_KEY),
-    .flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
-    .init = rc2_init_key,
-    .cipher = rc2_cbc_cipher,
-    .ctrl = rc2_ctrl,
+    /*nid=*/NID_rc2_40_cbc,
+    /*block_size=*/8,
+    /*key_len=*/5 /* 40 bit */,
+    /*iv_len=*/8,
+    /*ctx_size=*/sizeof(EVP_RC2_KEY),
+    /*flags=*/EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
+    /*init=*/rc2_init_key,
+    /*cipher=*/rc2_cbc_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/rc2_ctrl,
 };
 
 const EVP_CIPHER *EVP_rc2_40_cbc(void) { return &rc2_40_cbc; }
 
 static const EVP_CIPHER rc2_cbc = {
-    .nid = NID_rc2_cbc,
-    .block_size = 8,
-    .key_len = 16 /* 128 bit */,
-    .iv_len = 8,
-    .ctx_size = sizeof(EVP_RC2_KEY),
-    .flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
-    .init = rc2_init_key,
-    .cipher = rc2_cbc_cipher,
-    .ctrl = rc2_ctrl,
+    /*nid=*/NID_rc2_cbc,
+    /*block_size=*/8,
+    /*key_len=*/16 /* 128 bit */,
+    /*iv_len=*/8,
+    /*ctx_size=*/sizeof(EVP_RC2_KEY),
+    /*flags=*/EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
+    /*init=*/rc2_init_key,
+    /*cipher=*/rc2_cbc_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/rc2_ctrl,
 };
 
 const EVP_CIPHER *EVP_rc2_cbc(void) { return &rc2_cbc; }

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_rc4.c → e_rc4.cc}

@@ -81,14 +81,16 @@ static int rc4_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
 }
 
 static const EVP_CIPHER rc4 = {
-    .nid = NID_rc4,
-    .block_size = 1,
-    .key_len = 16,
-    .iv_len = 0,
-    .ctx_size = sizeof(RC4_KEY),
-    .flags = EVP_CIPH_VARIABLE_LENGTH,
-    .init = rc4_init_key,
-    .cipher = rc4_cipher,
+    /*nid=*/NID_rc4,
+    /*block_size=*/1,
+    /*key_len=*/16,
+    /*iv_len=*/0,
+    /*ctx_size=*/sizeof(RC4_KEY),
+    /*flags=*/EVP_CIPH_VARIABLE_LENGTH,
+    /*init=*/rc4_init_key,
+    /*cipher=*/rc4_cipher,
+    /*cleanup=*/nullptr,
+    /*ctrl=*/nullptr,
 };
 
 const EVP_CIPHER *EVP_rc4(void) { return &rc4; }

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/{e_tls.c → e_tls.cc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -442,6 +442,7 @@ static int aead_tls_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv,
   const AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)&ctx->state;
   const size_t iv_len = EVP_CIPHER_CTX_iv_length(&tls_ctx->cipher_ctx);
   if (iv_len <= 1) {
+    OPENSSL_PUT_ERROR(CIPHER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
     return 0;
   }