grpc 1.61.0 → 1.62.0.pre1

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

@@ -67,28 +67,6 @@ OPENSSL_EXPORT int CBS_get_asn1_implicit_string(CBS *in, CBS *out,
 int CBB_finish_i2d(CBB *cbb, uint8_t **outp);
 
 
-// Unicode utilities.
-
-// The following functions read one Unicode code point from |cbs| with the
-// corresponding encoding and store it in |*out|. They return one on success and
-// zero on error.
-OPENSSL_EXPORT int cbs_get_utf8(CBS *cbs, uint32_t *out);
-OPENSSL_EXPORT int cbs_get_latin1(CBS *cbs, uint32_t *out);
-OPENSSL_EXPORT int cbs_get_ucs2_be(CBS *cbs, uint32_t *out);
-OPENSSL_EXPORT int cbs_get_utf32_be(CBS *cbs, uint32_t *out);
-
-// cbb_get_utf8_len returns the number of bytes needed to represent |u| in
-// UTF-8.
-OPENSSL_EXPORT size_t cbb_get_utf8_len(uint32_t u);
-
-// The following functions encode |u| to |cbb| with the corresponding
-// encoding. They return one on success and zero on error.
-OPENSSL_EXPORT int cbb_add_utf8(CBB *cbb, uint32_t u);
-OPENSSL_EXPORT int cbb_add_latin1(CBB *cbb, uint32_t u);
-OPENSSL_EXPORT int cbb_add_ucs2_be(CBB *cbb, uint32_t u);
-OPENSSL_EXPORT int cbb_add_utf32_be(CBB *cbb, uint32_t u);
-
-
 #if defined(__cplusplus)
 }  // extern C
 #endif

data/third_party/boringssl-with-bazel/src/crypto/bytestring/unicode.c

@@ -38,7 +38,7 @@ static int is_valid_code_point(uint32_t v) {
 // TOP_BITS returns a byte with the top |n| bits set.
 #define TOP_BITS(n) ((uint8_t)~BOTTOM_BITS(8 - (n)))
 
-int cbs_get_utf8(CBS *cbs, uint32_t *out) {
+int CBS_get_utf8(CBS *cbs, uint32_t *out) {
   uint8_t c;
   if (!CBS_get_u8(cbs, &c)) {
     return 0;
@@ -80,7 +80,7 @@ int cbs_get_utf8(CBS *cbs, uint32_t *out) {
   return 1;
 }
 
-int cbs_get_latin1(CBS *cbs, uint32_t *out) {
+int CBS_get_latin1(CBS *cbs, uint32_t *out) {
   uint8_t c;
   if (!CBS_get_u8(cbs, &c)) {
     return 0;
@@ -89,7 +89,7 @@ int cbs_get_latin1(CBS *cbs, uint32_t *out) {
   return 1;
 }
 
-int cbs_get_ucs2_be(CBS *cbs, uint32_t *out) {
+int CBS_get_ucs2_be(CBS *cbs, uint32_t *out) {
   // Note UCS-2 (used by BMPString) does not support surrogates.
   uint16_t c;
   if (!CBS_get_u16(cbs, &c) ||
@@ -100,11 +100,11 @@ int cbs_get_ucs2_be(CBS *cbs, uint32_t *out) {
   return 1;
 }
 
-int cbs_get_utf32_be(CBS *cbs, uint32_t *out) {
+int CBS_get_utf32_be(CBS *cbs, uint32_t *out) {
   return CBS_get_u32(cbs, out) && is_valid_code_point(*out);
 }
 
-size_t cbb_get_utf8_len(uint32_t u) {
+size_t CBB_get_utf8_len(uint32_t u) {
   if (u <= 0x7f) {
     return 1;
   }
@@ -117,7 +117,7 @@ size_t cbb_get_utf8_len(uint32_t u) {
   return 4;
 }
 
-int cbb_add_utf8(CBB *cbb, uint32_t u) {
+int CBB_add_utf8(CBB *cbb, uint32_t u) {
   if (!is_valid_code_point(u)) {
     return 0;
   }
@@ -142,14 +142,14 @@ int cbb_add_utf8(CBB *cbb, uint32_t u) {
   return 0;
 }
 
-int cbb_add_latin1(CBB *cbb, uint32_t u) {
+int CBB_add_latin1(CBB *cbb, uint32_t u) {
   return u <= 0xff && CBB_add_u8(cbb, (uint8_t)u);
 }
 
-int cbb_add_ucs2_be(CBB *cbb, uint32_t u) {
+int CBB_add_ucs2_be(CBB *cbb, uint32_t u) {
   return u <= 0xffff && is_valid_code_point(u) && CBB_add_u16(cbb, (uint16_t)u);
 }
 
-int cbb_add_utf32_be(CBB *cbb, uint32_t u) {
+int CBB_add_utf32_be(CBB *cbb, uint32_t u) {
   return is_valid_code_point(u) && CBB_add_u32(cbb, u);
 }

data/third_party/boringssl-with-bazel/src/crypto/chacha/chacha.c

@@ -60,7 +60,40 @@ void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
   OPENSSL_memcpy(&out[16], &x[12], sizeof(uint32_t) * 4);
 }
 
-#if defined(CHACHA20_ASM)
+#if defined(CHACHA20_ASM_NOHW)
+static void ChaCha20_ctr32(uint8_t *out, const uint8_t *in, size_t in_len,
+                           const uint32_t key[8], const uint32_t counter[4]) {
+#if defined(CHACHA20_ASM_NEON)
+  if (ChaCha20_ctr32_neon_capable(in_len)) {
+    ChaCha20_ctr32_neon(out, in, in_len, key, counter);
+    return;
+  }
+#endif
+#if defined(CHACHA20_ASM_AVX2)
+  if (ChaCha20_ctr32_avx2_capable(in_len)) {
+    ChaCha20_ctr32_avx2(out, in, in_len, key, counter);
+    return;
+  }
+#endif
+#if defined(CHACHA20_ASM_SSSE3_4X)
+  if (ChaCha20_ctr32_ssse3_4x_capable(in_len)) {
+    ChaCha20_ctr32_ssse3_4x(out, in, in_len, key, counter);
+    return;
+  }
+#endif
+#if defined(CHACHA20_ASM_SSSE3)
+  if (ChaCha20_ctr32_ssse3_capable(in_len)) {
+    ChaCha20_ctr32_ssse3(out, in, in_len, key, counter);
+    return;
+  }
+#endif
+  if (in_len > 0) {
+    ChaCha20_ctr32_nohw(out, in, in_len, key, counter);
+  }
+}
+#endif
+
+#if defined(CHACHA20_ASM) || defined(CHACHA20_ASM_NOHW)
 
 void CRYPTO_chacha_20(uint8_t *out, const uint8_t *in, size_t in_len,
                       const uint8_t key[32], const uint8_t nonce[12],

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

@@ -17,6 +17,8 @@
 
 #include <openssl/base.h>
 
+#include "../internal.h"
+
 #if defined(__cplusplus)
 extern "C" {
 #endif
@@ -27,11 +29,49 @@ extern "C" {
 void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
                       const uint8_t nonce[16]);
 
-#if !defined(OPENSSL_NO_ASM) &&                         \
-    (defined(OPENSSL_X86) || defined(OPENSSL_X86_64) || \
-     defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
+#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86)
+
 #define CHACHA20_ASM
 
+#elif !defined(OPENSSL_NO_ASM) && \
+    (defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
+
+#define CHACHA20_ASM_NOHW
+
+#define CHACHA20_ASM_NEON
+OPENSSL_INLINE int ChaCha20_ctr32_neon_capable(size_t len) {
+  return (len >= 192) && CRYPTO_is_NEON_capable();
+}
+void ChaCha20_ctr32_neon(uint8_t *out, const uint8_t *in, size_t in_len,
+                         const uint32_t key[8], const uint32_t counter[4]);
+#elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64)
+#define CHACHA20_ASM_NOHW
+
+#define CHACHA20_ASM_AVX2
+OPENSSL_INLINE int ChaCha20_ctr32_avx2_capable(size_t len) {
+  return (len > 128) && CRYPTO_is_AVX2_capable();
+}
+void ChaCha20_ctr32_avx2(uint8_t *out, const uint8_t *in, size_t in_len,
+                         const uint32_t key[8], const uint32_t counter[4]);
+
+#define CHACHA20_ASM_SSSE3_4X
+OPENSSL_INLINE int ChaCha20_ctr32_ssse3_4x_capable(size_t len) {
+  int capable = (len > 128) && CRYPTO_is_SSSE3_capable();
+  int faster = (len > 192) || !CRYPTO_cpu_perf_is_like_silvermont();
+  return capable && faster;
+}
+void ChaCha20_ctr32_ssse3_4x(uint8_t *out, const uint8_t *in, size_t in_len,
+                             const uint32_t key[8], const uint32_t counter[4]);
+
+#define CHACHA20_ASM_SSSE3
+OPENSSL_INLINE int ChaCha20_ctr32_ssse3_capable(size_t len) {
+  return (len > 128) && CRYPTO_is_SSSE3_capable();
+}
+void ChaCha20_ctr32_ssse3(uint8_t *out, const uint8_t *in, size_t in_len,
+                          const uint32_t key[8], const uint32_t counter[4]);
+#endif
+
+#if defined(CHACHA20_ASM)
 // ChaCha20_ctr32 encrypts |in_len| bytes from |in| and writes the result to
 // |out|. If |in| and |out| alias, they must be equal.
 //
@@ -44,6 +84,12 @@ void ChaCha20_ctr32(uint8_t *out, const uint8_t *in, size_t in_len,
                     const uint32_t key[8], const uint32_t counter[4]);
 #endif
 
+#if defined(CHACHA20_ASM_NOHW)
+// ChaCha20_ctr32_nohw is like |ChaCha20_ctr32| except |in_len| must be nonzero.
+void ChaCha20_ctr32_nohw(uint8_t *out, const uint8_t *in, size_t in_len,
+                         const uint32_t key[8], const uint32_t counter[4]);
+#endif
+
 
 #if defined(__cplusplus)
 }  // extern C

data/third_party/boringssl-with-bazel/src/crypto/cipher_extra/e_aesgcmsiv.c

@@ -126,16 +126,16 @@ extern void aesgcmsiv_htable_polyval(const uint8_t htable[16 * 8],
                                      uint8_t in_out_poly[16]);
 
 // aes128gcmsiv_dec decrypts |in_len| & ~15 bytes from |out| and writes them to
-// |in|. (The full value of |in_len| is still used to find the authentication
-// tag appended to the ciphertext, however, so must not be pre-masked.)
+// |in|. |in| and |out| may be equal, but must not otherwise alias.
 //
-// |in| and |out| may be equal, but must not otherwise overlap.
+// |in_out_calculated_tag_and_scratch|, on entry, must contain:
+//    1. The current value of the calculated tag, which will be updated during
+//       decryption and written back to the beginning of this buffer on exit.
+//    2. The claimed tag, which is needed to derive counter values.
 //
-// While decrypting, it updates the POLYVAL value found at the beginning of
-// |in_out_calculated_tag_and_scratch| and writes the updated value back before
-// return. During executation, it may use the whole of this space for other
-// purposes. In order to decrypt and update the POLYVAL value, it uses the
-// expanded key from |key| and the table of powers in |htable|.
+// While decrypting, the whole of |in_out_calculated_tag_and_scratch| may be
+// used for other purposes. In order to decrypt and update the POLYVAL value, it
+// uses the expanded key from |key| and the table of powers in |htable|.
 extern void aes128gcmsiv_dec(const uint8_t *in, uint8_t *out,
                              uint8_t in_out_calculated_tag_and_scratch[16 * 8],
                              const uint8_t htable[16 * 6],
@@ -393,14 +393,10 @@ static int aead_aes_gcm_siv_asm_seal_scatter(
   return 1;
 }
 
-// TODO(martinkr): Add aead_aes_gcm_siv_asm_open_gather. N.B. aes128gcmsiv_dec
-// expects ciphertext and tag in a contiguous buffer.
-
-static int aead_aes_gcm_siv_asm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,
-                                     size_t *out_len, size_t max_out_len,
-                                     const uint8_t *nonce, size_t nonce_len,
-                                     const uint8_t *in, size_t in_len,
-                                     const uint8_t *ad, size_t ad_len) {
+static int aead_aes_gcm_siv_asm_open_gather(
+    const EVP_AEAD_CTX *ctx, uint8_t *out, const uint8_t *nonce,
+    size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *in_tag,
+    size_t in_tag_len, const uint8_t *ad, size_t ad_len) {
   const uint64_t ad_len_64 = ad_len;
   if (ad_len_64 >= (UINT64_C(1) << 61)) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);
@@ -408,8 +404,8 @@ static int aead_aes_gcm_siv_asm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,
   }
 
   const uint64_t in_len_64 = in_len;
-  if (in_len < EVP_AEAD_AES_GCM_SIV_TAG_LEN ||
-      in_len_64 > (UINT64_C(1) << 36) + AES_BLOCK_SIZE) {
+  if (in_len_64 > UINT64_C(1) << 36 ||
+      in_tag_len != EVP_AEAD_AES_GCM_SIV_TAG_LEN) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT);
     return 0;
   }
@@ -420,13 +416,6 @@ static int aead_aes_gcm_siv_asm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,
   }
 
   const struct aead_aes_gcm_siv_asm_ctx *gcm_siv_ctx = asm_ctx_from_ctx(ctx);
-  const size_t plaintext_len = in_len - EVP_AEAD_AES_GCM_SIV_TAG_LEN;
-  const uint8_t *const given_tag = in + plaintext_len;
-
-  if (max_out_len < plaintext_len) {
-    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BUFFER_TOO_SMALL);
-    return 0;
-  }
 
   alignas(16) uint64_t record_auth_key[2];
   alignas(16) uint64_t record_enc_key[4];
@@ -459,27 +448,27 @@ static int aead_aes_gcm_siv_asm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,
   alignas(16) uint8_t htable[16 * 6];
   aesgcmsiv_htable6_init(htable, (const uint8_t *)record_auth_key);
 
+  // aes[128|256]gcmsiv_dec needs access to the claimed tag. So it's put into
+  // its scratch space.
+  memcpy(calculated_tag + 16, in_tag, EVP_AEAD_AES_GCM_SIV_TAG_LEN);
   if (gcm_siv_ctx->is_128_bit) {
-    aes128gcmsiv_dec(in, out, calculated_tag, htable, &expanded_key,
-                     plaintext_len);
+    aes128gcmsiv_dec(in, out, calculated_tag, htable, &expanded_key, in_len);
   } else {
-    aes256gcmsiv_dec(in, out, calculated_tag, htable, &expanded_key,
-                     plaintext_len);
+    aes256gcmsiv_dec(in, out, calculated_tag, htable, &expanded_key, in_len);
   }
 
-  if (plaintext_len & 15) {
+  if (in_len & 15) {
     aead_aes_gcm_siv_asm_crypt_last_block(gcm_siv_ctx->is_128_bit, out, in,
-                                          plaintext_len, given_tag,
-                                          &expanded_key);
+                                          in_len, in_tag, &expanded_key);
     OPENSSL_memset(scratch, 0, sizeof(scratch));
-    OPENSSL_memcpy(scratch, out + (plaintext_len & ~15), plaintext_len & 15);
+    OPENSSL_memcpy(scratch, out + (in_len & ~15), in_len & 15);
     aesgcmsiv_polyval_horner(calculated_tag, (const uint8_t *)record_auth_key,
                              scratch, 1);
   }
 
   uint8_t length_block[16];
   CRYPTO_store_u64_le(length_block, ad_len * 8);
-  CRYPTO_store_u64_le(length_block + 8, plaintext_len * 8);
+  CRYPTO_store_u64_le(length_block + 8, in_len * 8);
   aesgcmsiv_polyval_horner(calculated_tag, (const uint8_t *)record_auth_key,
                            length_block, 1);
 
@@ -495,13 +484,12 @@ static int aead_aes_gcm_siv_asm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,
     aes256gcmsiv_ecb_enc_block(calculated_tag, calculated_tag, &expanded_key);
   }
 
-  if (CRYPTO_memcmp(calculated_tag, given_tag, EVP_AEAD_AES_GCM_SIV_TAG_LEN) !=
+  if (CRYPTO_memcmp(calculated_tag, in_tag, EVP_AEAD_AES_GCM_SIV_TAG_LEN) !=
       0) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT);
     return 0;
   }
 
-  *out_len = in_len - EVP_AEAD_AES_GCM_SIV_TAG_LEN;
   return 1;
 }
 
@@ -515,9 +503,9 @@ static const EVP_AEAD aead_aes_128_gcm_siv_asm = {
     aead_aes_gcm_siv_asm_init,
     NULL /* init_with_direction */,
     aead_aes_gcm_siv_asm_cleanup,
-    aead_aes_gcm_siv_asm_open,
+    NULL /* open */,
     aead_aes_gcm_siv_asm_seal_scatter,
-    NULL /* open_gather */,
+    aead_aes_gcm_siv_asm_open_gather,
     NULL /* get_iv */,
     NULL /* tag_len */,
 };
@@ -532,9 +520,9 @@ static const EVP_AEAD aead_aes_256_gcm_siv_asm = {
     aead_aes_gcm_siv_asm_init,
     NULL /* init_with_direction */,
     aead_aes_gcm_siv_asm_cleanup,
-    aead_aes_gcm_siv_asm_open,
+    NULL /* open */,
     aead_aes_gcm_siv_asm_seal_scatter,
-    NULL /* open_gather */,
+    aead_aes_gcm_siv_asm_open_gather,
     NULL /* get_iv */,
     NULL /* tag_len */,
 };
@@ -647,8 +635,8 @@ static void gcm_siv_polyval(
   }
 
   uint8_t length_block[16];
-  CRYPTO_store_u64_le(length_block, ad_len * 8);
-  CRYPTO_store_u64_le(length_block + 8, 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));
 

data/third_party/boringssl-with-bazel/src/crypto/conf/conf.c

@@ -70,126 +70,117 @@
 #include "../internal.h"
 
 
+struct conf_section_st {
+  char *name;
+  // values contains non-owning pointers to the values in the section.
+  STACK_OF(CONF_VALUE) *values;
+};
+
 static const char kDefaultSectionName[] = "default";
 
+static uint32_t conf_section_hash(const CONF_SECTION *s) {
+  return OPENSSL_strhash(s->name);
+}
+
+static int conf_section_cmp(const CONF_SECTION *a, const CONF_SECTION *b) {
+  return strcmp(a->name, b->name);
+}
+
 static uint32_t conf_value_hash(const CONF_VALUE *v) {
-  const uint32_t section_hash = v->section ? OPENSSL_strhash(v->section) : 0;
-  const uint32_t name_hash = v->name ? OPENSSL_strhash(v->name) : 0;
+  const uint32_t section_hash = OPENSSL_strhash(v->section);
+  const uint32_t name_hash = OPENSSL_strhash(v->name);
   return (section_hash << 2) ^ name_hash;
 }
 
 static int conf_value_cmp(const CONF_VALUE *a, const CONF_VALUE *b) {
-  int i;
-
-  if (a->section != b->section) {
-    i = strcmp(a->section, b->section);
-    if (i) {
-      return i;
-    }
+  int cmp = strcmp(a->section, b->section);
+  if (cmp != 0) {
+    return cmp;
   }
 
-  if (a->name != NULL && b->name != NULL) {
-    return strcmp(a->name, b->name);
-  } else if (a->name == b->name) {
-    return 0;
-  } else {
-    return (a->name == NULL) ? -1 : 1;
-  }
+  return strcmp(a->name, b->name);
 }
 
 CONF *NCONF_new(void *method) {
-  CONF *conf;
-
   if (method != NULL) {
     return NULL;
   }
 
-  conf = OPENSSL_malloc(sizeof(CONF));
+  CONF *conf = OPENSSL_malloc(sizeof(CONF));
   if (conf == NULL) {
     return NULL;
   }
 
-  conf->data = lh_CONF_VALUE_new(conf_value_hash, conf_value_cmp);
-  if (conf->data == NULL) {
-    OPENSSL_free(conf);
+  conf->sections = lh_CONF_SECTION_new(conf_section_hash, conf_section_cmp);
+  conf->values = lh_CONF_VALUE_new(conf_value_hash, conf_value_cmp);
+  if (conf->sections == NULL || conf->values == NULL) {
+    NCONF_free(conf);
     return NULL;
   }
 
   return conf;
 }
 
-CONF_VALUE *CONF_VALUE_new(void) {
-  CONF_VALUE *v = OPENSSL_malloc(sizeof(CONF_VALUE));
-  if (!v) {
-    return NULL;
-  }
-  OPENSSL_memset(v, 0, sizeof(CONF_VALUE));
-  return v;
-}
+CONF_VALUE *CONF_VALUE_new(void) { return OPENSSL_zalloc(sizeof(CONF_VALUE)); }
 
-static void value_free_contents(CONF_VALUE *value) {
-  OPENSSL_free(value->section);
-  if (value->name) {
-    OPENSSL_free(value->name);
-    OPENSSL_free(value->value);
-  } else {
-    // TODO(davidben): When |value->name| is NULL, |CONF_VALUE| is actually an
-    // entirely different structure. This is fragile and confusing. Make a
-    // proper |CONF_SECTION| type that doesn't require this.
-    sk_CONF_VALUE_free((STACK_OF(CONF_VALUE) *)value->value);
+static void value_free(CONF_VALUE *value) {
+  if (value == NULL) {
+    return;
   }
+  OPENSSL_free(value->section);
+  OPENSSL_free(value->name);
+  OPENSSL_free(value->value);
+  OPENSSL_free(value);
 }
 
-static void value_free(CONF_VALUE *value) {
-  if (value != NULL) {
-    value_free_contents(value);
-    OPENSSL_free(value);
+static void section_free(CONF_SECTION *section) {
+  if (section == NULL) {
+    return;
   }
+  OPENSSL_free(section->name);
+  sk_CONF_VALUE_free(section->values);
+  OPENSSL_free(section);
 }
 
 static void value_free_arg(CONF_VALUE *value, void *arg) { value_free(value); }
 
+static void section_free_arg(CONF_SECTION *section, void *arg) {
+  section_free(section);
+}
+
 void NCONF_free(CONF *conf) {
-  if (conf == NULL || conf->data == NULL) {
+  if (conf == NULL) {
     return;
   }
 
-  lh_CONF_VALUE_doall_arg(conf->data, value_free_arg, NULL);
-  lh_CONF_VALUE_free(conf->data);
+  lh_CONF_SECTION_doall_arg(conf->sections, section_free_arg, NULL);
+  lh_CONF_SECTION_free(conf->sections);
+  lh_CONF_VALUE_doall_arg(conf->values, value_free_arg, NULL);
+  lh_CONF_VALUE_free(conf->values);
   OPENSSL_free(conf);
 }
 
-static CONF_VALUE *NCONF_new_section(const CONF *conf, const char *section) {
-  STACK_OF(CONF_VALUE) *sk = NULL;
-  int ok = 0;
-  CONF_VALUE *v = NULL, *old_value;
-
-  sk = sk_CONF_VALUE_new_null();
-  v = CONF_VALUE_new();
-  if (sk == NULL || v == NULL) {
-    goto err;
+static CONF_SECTION *NCONF_new_section(const CONF *conf, const char *section) {
+  CONF_SECTION *s = OPENSSL_malloc(sizeof(CONF_SECTION));
+  if (!s) {
+    return NULL;
   }
-  v->section = OPENSSL_strdup(section);
-  if (v->section == NULL) {
+  s->name = OPENSSL_strdup(section);
+  s->values = sk_CONF_VALUE_new_null();
+  if (s->name == NULL || s->values == NULL) {
     goto err;
   }
 
-  v->name = NULL;
-  v->value = (char *)sk;
-
-  if (!lh_CONF_VALUE_insert(conf->data, &old_value, v)) {
+  CONF_SECTION *old_section;
+  if (!lh_CONF_SECTION_insert(conf->sections, &old_section, s)) {
     goto err;
   }
-  value_free(old_value);
-  ok = 1;
+  section_free(old_section);
+  return s;
 
 err:
-  if (!ok) {
-    sk_CONF_VALUE_free(sk);
-    OPENSSL_free(v);
-    v = NULL;
-  }
-  return v;
+  section_free(s);
+  return NULL;
 }
 
 static int str_copy(CONF *conf, char *section, char **pto, char *from) {
@@ -261,21 +252,20 @@ err:
   return 0;
 }
 
-static CONF_VALUE *get_section(const CONF *conf, const char *section) {
-  CONF_VALUE template;
-
+static CONF_SECTION *get_section(const CONF *conf, const char *section) {
+  CONF_SECTION template;
   OPENSSL_memset(&template, 0, sizeof(template));
-  template.section = (char *) section;
-  return lh_CONF_VALUE_retrieve(conf->data, &template);
+  template.name = (char *) section;
+  return lh_CONF_SECTION_retrieve(conf->sections, &template);
 }
 
 const STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
                                               const char *section) {
-  const CONF_VALUE *section_value = get_section(conf, section);
-  if (section_value == NULL) {
+  const CONF_SECTION *section_obj = get_section(conf, section);
+  if (section_obj == NULL) {
     return NULL;
   }
-  return (STACK_OF(CONF_VALUE)*) section_value->value;
+  return section_obj->values;
 }
 
 const char *NCONF_get_string(const CONF *conf, const char *section,
@@ -287,30 +277,35 @@ const char *NCONF_get_string(const CONF *conf, const char *section,
   }
 
   OPENSSL_memset(&template, 0, sizeof(template));
-  template.section = (char *) section;
-  template.name = (char *) name;
-  value = lh_CONF_VALUE_retrieve(conf->data, &template);
+  template.section = (char *)section;
+  template.name = (char *)name;
+  value = lh_CONF_VALUE_retrieve(conf->values, &template);
   if (value == NULL) {
     return NULL;
   }
   return value->value;
 }
 
-static int add_string(const CONF *conf, CONF_VALUE *section,
+static int add_string(const CONF *conf, CONF_SECTION *section,
                       CONF_VALUE *value) {
-  STACK_OF(CONF_VALUE) *section_stack = (STACK_OF(CONF_VALUE)*) section->value;
-  CONF_VALUE *old_value;
+  value->section = OPENSSL_strdup(section->name);
+  if (value->section == NULL) {
+    return 0;
+  }
 
-  value->section = OPENSSL_strdup(section->section);
-  if (!sk_CONF_VALUE_push(section_stack, value)) {
+  if (!sk_CONF_VALUE_push(section->values, value)) {
     return 0;
   }
 
-  if (!lh_CONF_VALUE_insert(conf->data, &old_value, value)) {
+  CONF_VALUE *old_value;
+  if (!lh_CONF_VALUE_insert(conf->values, &old_value, value)) {
+    // Remove |value| from |section->values|, so we do not leave a dangling
+    // pointer.
+    sk_CONF_VALUE_pop(section->values);
     return 0;
   }
   if (old_value != NULL) {
-    (void)sk_CONF_VALUE_delete_ptr(section_stack, old_value);
+    (void)sk_CONF_VALUE_delete_ptr(section->values, old_value);
     value_free(old_value);
   }
 
@@ -395,8 +390,8 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
   int again;
   long eline = 0;
   char btmp[DECIMAL_SIZE(eline) + 1];
-  CONF_VALUE *v = NULL, *tv;
-  CONF_VALUE *sv = NULL;
+  CONF_VALUE *v = NULL;
+  CONF_SECTION *sv = NULL;
   char *section = NULL, *buf;
   char *start, *psection, *pname;
 
@@ -547,6 +542,7 @@ int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
         goto err;
       }
 
+      CONF_SECTION *tv;
       if (strcmp(psection, section) != 0) {
         if ((tv = get_section(conf, psection)) == NULL) {
           tv = NCONF_new_section(conf, psection);
@@ -576,12 +572,7 @@ err:
   }
   snprintf(btmp, sizeof btmp, "%ld", eline);
   ERR_add_error_data(2, "line ", btmp);
-
-  if (v != NULL) {
-    OPENSSL_free(v->name);
-    OPENSSL_free(v->value);
-    OPENSSL_free(v);
-  }
+  value_free(v);
   return 0;
 }
 

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

@@ -24,10 +24,14 @@ extern "C" {
 #endif
 
 
+typedef struct conf_section_st CONF_SECTION;
+
+DEFINE_LHASH_OF(CONF_SECTION)
 DEFINE_LHASH_OF(CONF_VALUE)
 
 struct conf_st {
-  LHASH_OF(CONF_VALUE) *data;
+  LHASH_OF(CONF_VALUE) *values;
+  LHASH_OF(CONF_SECTION) *sections;
 };
 
 // CONF_VALUE_new returns a freshly allocated and zeroed |CONF_VALUE|.