grpc 1.53.1 → 1.54.0

data/third_party/boringssl-with-bazel/src/crypto/kyber/keccak.c

@@ -0,0 +1,205 @@
+/* Copyright (c) 2023, 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/base.h>
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "../internal.h"
+#include "./internal.h"
+
+
+// keccak_f implements the Keccak-1600 permutation as described at
+// https://keccak.team/keccak_specs_summary.html. Each lane is represented as a
+// 64-bit value and the 5×5 lanes are stored as an array in row-major order.
+static void keccak_f(uint64_t state[25]) {
+  static const int kNumRounds = 24;
+  for (int round = 0; round < kNumRounds; round++) {
+    // θ step
+    uint64_t c[5];
+    for (int x = 0; x < 5; x++) {
+      c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^
+             state[x + 20];
+    }
+
+    for (int x = 0; x < 5; x++) {
+      const uint64_t d = c[(x + 4) % 5] ^ CRYPTO_rotl_u64(c[(x + 1) % 5], 1);
+      for (int y = 0; y < 5; y++) {
+        state[y * 5 + x] ^= d;
+      }
+    }
+
+    // ρ and π steps.
+    //
+    // These steps involve a mapping of the state matrix. Each input point,
+    // (x,y), is rotated and written to the point (y, 2x + 3y). In the Keccak
+    // pseudo-code a separate array is used because an in-place operation would
+    // overwrite some values that are subsequently needed. However, the mapping
+    // forms a trail through 24 of the 25 values so we can do it in place with
+    // only a single temporary variable.
+    //
+    // Start with (1, 0). The value here will be mapped and end up at (0, 2).
+    // That value will end up at (2, 1), then (1, 2), and so on. After 24
+    // steps, 24 of the 25 values have been hit (as this mapping is injective)
+    // and the sequence will repeat. All that remains is to handle the element
+    // at (0, 0), but the rotation for that element is zero, and it goes to (0,
+    // 0), so we can ignore it.
+    int pi_x = 1, pi_y = 0;
+    uint64_t prev_value = state[1];
+    int pi_rot = 1;
+    for (int i = 1; i < 25; i++) {
+      const int out_x = pi_y;
+      const int out_y = (2 * pi_x + 3 * pi_y) % 5;
+      const int index = out_y * 5 + out_x;
+      const uint64_t t = state[index];
+      state[index] = CRYPTO_rotl_u64(prev_value, pi_rot);
+      pi_rot = (pi_rot + i + 1) % 64;
+      prev_value = t;
+      pi_x = out_x;
+      pi_y = out_y;
+    }
+
+    // χ step
+    for (int y = 0; y < 5; y++) {
+      const int row_index = 5 * y;
+      const uint64_t orig_x0 = state[row_index];
+      const uint64_t orig_x1 = state[row_index + 1];
+      state[row_index] ^= ~orig_x1 & state[row_index + 2];
+      state[row_index + 1] ^= ~state[row_index + 2] & state[row_index + 3];
+      state[row_index + 2] ^= ~state[row_index + 3] & state[row_index + 4];
+      state[row_index + 3] ^= ~state[row_index + 4] & orig_x0;
+      state[row_index + 4] ^= ~orig_x0 & orig_x1;
+    }
+
+    // ι step
+    //
+    // From https://keccak.team/files/Keccak-reference-3.0.pdf, section
+    // 1.2, the round constants are based on the output of a LFSR. Thus, as
+    // suggested in the appendix of of
+    // https://keccak.team/keccak_specs_summary.html, the values are
+    // simply encoded here.
+    static const uint64_t kRoundConstants[24] = {
+        0x0000000000000001, 0x0000000000008082, 0x800000000000808a,
+        0x8000000080008000, 0x000000000000808b, 0x0000000080000001,
+        0x8000000080008081, 0x8000000000008009, 0x000000000000008a,
+        0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
+        0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+        0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
+        0x000000000000800a, 0x800000008000000a, 0x8000000080008081,
+        0x8000000000008080, 0x0000000080000001, 0x8000000080008008,
+    };
+
+    state[0] ^= kRoundConstants[round];
+  }
+}
+
+static void keccak_init(struct BORINGSSL_keccak_st *ctx,
+                        size_t *out_required_out_len, const uint8_t *in,
+                        size_t in_len, enum boringssl_keccak_config_t config) {
+  size_t capacity_bytes;
+  uint8_t terminator;
+  switch (config) {
+    case boringssl_sha3_256:
+      capacity_bytes = 512 / 8;
+      *out_required_out_len = 32;
+      terminator = 0x06;
+      break;
+    case boringssl_sha3_512:
+      capacity_bytes = 1024 / 8;
+      *out_required_out_len = 64;
+      terminator = 0x06;
+      break;
+    case boringssl_shake128:
+      capacity_bytes = 256 / 8;
+      *out_required_out_len = 0;
+      terminator = 0x1f;
+      break;
+    case boringssl_shake256:
+      capacity_bytes = 512 / 8;
+      *out_required_out_len = 0;
+      terminator = 0x1f;
+      break;
+    default:
+      abort();
+  }
+
+  OPENSSL_memset(ctx, 0, sizeof(*ctx));
+  ctx->rate_bytes = 200 - capacity_bytes;
+  assert(ctx->rate_bytes % 8 == 0);
+  const size_t rate_words = ctx->rate_bytes / 8;
+
+  while (in_len >= ctx->rate_bytes) {
+    for (size_t i = 0; i < rate_words; i++) {
+      ctx->state[i] ^= CRYPTO_load_u64_le(in + 8 * i);
+    }
+    keccak_f(ctx->state);
+    in += ctx->rate_bytes;
+    in_len -= ctx->rate_bytes;
+  }
+
+  // XOR the final block. Accessing |ctx->state| as a |uint8_t*| is allowed by
+  // strict aliasing because we require |uint8_t| to be a character type.
+  uint8_t *state_bytes = (uint8_t *)ctx->state;
+  assert(in_len < ctx->rate_bytes);
+  for (size_t i = 0; i < in_len; i++) {
+    state_bytes[i] ^= in[i];
+  }
+  state_bytes[in_len] ^= terminator;
+  state_bytes[ctx->rate_bytes - 1] ^= 0x80;
+  keccak_f(ctx->state);
+}
+
+void BORINGSSL_keccak(uint8_t *out, size_t out_len, const uint8_t *in,
+                      size_t in_len, enum boringssl_keccak_config_t config) {
+  struct BORINGSSL_keccak_st ctx;
+  size_t required_out_len;
+  keccak_init(&ctx, &required_out_len, in, in_len, config);
+  if (required_out_len != 0 && out_len != required_out_len) {
+    abort();
+  }
+  BORINGSSL_keccak_squeeze(&ctx, out, out_len);
+}
+
+void BORINGSSL_keccak_init(struct BORINGSSL_keccak_st *ctx, const uint8_t *in,
+                           size_t in_len,
+                           enum boringssl_keccak_config_t config) {
+  size_t required_out_len;
+  keccak_init(ctx, &required_out_len, in, in_len, config);
+  if (required_out_len != 0) {
+    abort();
+  }
+}
+
+void BORINGSSL_keccak_squeeze(struct BORINGSSL_keccak_st *ctx, uint8_t *out,
+                              size_t out_len) {
+  // Accessing |ctx->state| as a |uint8_t*| is allowed by strict aliasing
+  // because we require |uint8_t| to be a character type.
+  const uint8_t *state_bytes = (const uint8_t *)ctx->state;
+  while (out_len) {
+    size_t remaining = ctx->rate_bytes - ctx->offset;
+    size_t todo = out_len;
+    if (todo > remaining) {
+      todo = remaining;
+    }
+    OPENSSL_memcpy(out, &state_bytes[ctx->offset], todo);
+    out += todo;
+    out_len -= todo;
+    ctx->offset += todo;
+    if (ctx->offset == ctx->rate_bytes) {
+      keccak_f(ctx->state);
+      ctx->offset = 0;
+    }
+  }
+}

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

@@ -157,6 +157,16 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
                                          void *arg);
 
 #define DEFINE_LHASH_OF(type)                                                  \
+  /* We disable MSVC C4191 in this macro, which warns when pointers are cast   \
+   * to the wrong type. While the cast itself is valid, it is often a bug      \
+   * because calling it through the cast is UB. However, we never actually     \
+   * call functions as |lhash_cmp_func|. The type is just a type-erased        \
+   * function pointer. (C does not guarantee function pointers fit in          \
+   * |void*|, and GCC will warn on this.) Thus we just disable the false       \
+   * positive warning. */                                                      \
+  OPENSSL_MSVC_PRAGMA(warning(push))                                           \
+  OPENSSL_MSVC_PRAGMA(warning(disable : 4191))                                 \
+                                                                               \
   DECLARE_LHASH_OF(type)                                                       \
                                                                                \
   typedef int (*lhash_##type##_cmp_func)(const type *, const type *);          \
@@ -243,7 +253,9 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
       LHASH_OF(type) *lh, void (*func)(type *, void *), void *arg) {           \
     LHASH_DOALL_##type cb = {func, arg};                                       \
     OPENSSL_lh_doall_arg((_LHASH *)lh, lh_##type##_call_doall_arg, &cb);       \
-  }
+  }                                                                            \
+                                                                               \
+  OPENSSL_MSVC_PRAGMA(warning(pop))
 
 
 #if defined(__cplusplus)

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

@@ -57,8 +57,11 @@
 #include <openssl/mem.h>
 
 #include <assert.h>
+#include <errno.h>
+#include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #include <openssl/err.h>
 
@@ -68,12 +71,17 @@ OPENSSL_MSVC_PRAGMA(warning(push, 3))
 OPENSSL_MSVC_PRAGMA(warning(pop))
 #endif
 
+#if defined(BORINGSSL_MALLOC_FAILURE_TESTING)
+#include <errno.h>
+#include <signal.h>
+#include <unistd.h>
+#endif
+
 #include "internal.h"
 
 
 #define OPENSSL_MALLOC_PREFIX 8
-OPENSSL_STATIC_ASSERT(OPENSSL_MALLOC_PREFIX >= sizeof(size_t),
-                      "size_t too large");
+static_assert(OPENSSL_MALLOC_PREFIX >= sizeof(size_t), "size_t too large");
 
 #if defined(OPENSSL_ASAN)
 void __asan_poison_memory_region(const volatile void *addr, size_t size);
@@ -121,7 +129,7 @@ WEAK_SYMBOL_FUNC(void, sdallocx, (void *ptr, size_t size, int flags));
 // primitives used must tolerate every other synchronization primitive linked
 // into the process, including pthreads locks. Failing to meet these constraints
 // may result in deadlocks, crashes, or memory corruption.
-WEAK_SYMBOL_FUNC(void*, OPENSSL_memory_alloc, (size_t size));
+WEAK_SYMBOL_FUNC(void *, OPENSSL_memory_alloc, (size_t size));
 WEAK_SYMBOL_FUNC(void, OPENSSL_memory_free, (void *ptr));
 WEAK_SYMBOL_FUNC(size_t, OPENSSL_memory_get_size, (void *ptr));
 
@@ -129,17 +137,107 @@ WEAK_SYMBOL_FUNC(size_t, OPENSSL_memory_get_size, (void *ptr));
 // are linking in BoringSSL and, roughly, what version they are using.
 static const uint8_t kBoringSSLBinaryTag[18] = {
     // 16 bytes of magic tag.
-    0x8c, 0x62, 0x20, 0x0b, 0xd2, 0xa0, 0x72, 0x58,
-    0x44, 0xa8, 0x96, 0x69, 0xad, 0x55, 0x7e, 0xec,
+    0x8c,
+    0x62,
+    0x20,
+    0x0b,
+    0xd2,
+    0xa0,
+    0x72,
+    0x58,
+    0x44,
+    0xa8,
+    0x96,
+    0x69,
+    0xad,
+    0x55,
+    0x7e,
+    0xec,
     // Current source iteration. Incremented ~monthly.
-    2, 0,
+    3,
+    0,
 };
 
+#if defined(BORINGSSL_MALLOC_FAILURE_TESTING)
+static struct CRYPTO_STATIC_MUTEX malloc_failure_lock =
+    CRYPTO_STATIC_MUTEX_INIT;
+static uint64_t current_malloc_count = 0;
+static uint64_t malloc_number_to_fail = 0;
+static int malloc_failure_enabled = 0, break_on_malloc_fail = 0,
+           any_malloc_failed = 0;
+
+static void malloc_exit_handler(void) {
+  CRYPTO_STATIC_MUTEX_lock_read(&malloc_failure_lock);
+  if (any_malloc_failed) {
+    // Signal to the test driver that some allocation failed, so it knows to
+    // increment the counter and continue.
+    _exit(88);
+  }
+  CRYPTO_STATIC_MUTEX_unlock_read(&malloc_failure_lock);
+}
+
+static void init_malloc_failure(void) {
+  const char *env = getenv("MALLOC_NUMBER_TO_FAIL");
+  if (env != NULL && env[0] != 0) {
+    char *endptr;
+    malloc_number_to_fail = strtoull(env, &endptr, 10);
+    if (*endptr == 0) {
+      malloc_failure_enabled = 1;
+      atexit(malloc_exit_handler);
+    }
+  }
+  break_on_malloc_fail = getenv("MALLOC_BREAK_ON_FAIL") != NULL;
+}
+
+// should_fail_allocation returns one if the current allocation should fail and
+// zero otherwise.
+static int should_fail_allocation() {
+  static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
+  CRYPTO_once(&once, init_malloc_failure);
+  if (!malloc_failure_enabled) {
+    return 0;
+  }
+
+  // We lock just so multi-threaded tests are still correct, but we won't test
+  // every malloc exhaustively.
+  CRYPTO_STATIC_MUTEX_lock_write(&malloc_failure_lock);
+  int should_fail = current_malloc_count == malloc_number_to_fail;
+  current_malloc_count++;
+  any_malloc_failed = any_malloc_failed || should_fail;
+  CRYPTO_STATIC_MUTEX_unlock_write(&malloc_failure_lock);
+
+  if (should_fail && break_on_malloc_fail) {
+    raise(SIGTRAP);
+  }
+  if (should_fail) {
+    errno = ENOMEM;
+  }
+  return should_fail;
+}
+
+void OPENSSL_reset_malloc_counter_for_testing(void) {
+  CRYPTO_STATIC_MUTEX_lock_write(&malloc_failure_lock);
+  current_malloc_count = 0;
+  CRYPTO_STATIC_MUTEX_unlock_write(&malloc_failure_lock);
+}
+
+#else
+static int should_fail_allocation(void) { return 0; }
+#endif
+
 void *OPENSSL_malloc(size_t size) {
+  if (should_fail_allocation()) {
+    goto err;
+  }
+
   if (OPENSSL_memory_alloc != NULL) {
     assert(OPENSSL_memory_free != NULL);
     assert(OPENSSL_memory_get_size != NULL);
-    return OPENSSL_memory_alloc(size);
+    void *ptr = OPENSSL_memory_alloc(size);
+    if (ptr == NULL && size != 0) {
+      goto err;
+    }
+    return ptr;
   }
 
   if (size + OPENSSL_MALLOC_PREFIX < size) {
@@ -151,18 +249,23 @@ void *OPENSSL_malloc(size_t size) {
     // rare code path.
     uint8_t unused = *(volatile uint8_t *)kBoringSSLBinaryTag;
     (void) unused;
-    return NULL;
+    goto err;
   }
 
   void *ptr = malloc(size + OPENSSL_MALLOC_PREFIX);
   if (ptr == NULL) {
-    return NULL;
+    goto err;
   }
 
   *(size_t *)ptr = size;
 
   __asan_poison_memory_region(ptr, OPENSSL_MALLOC_PREFIX);
   return ((uint8_t *)ptr) + OPENSSL_MALLOC_PREFIX;
+
+ err:
+  // This only works because ERR does not call OPENSSL_malloc.
+  OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
+  return NULL;
 }
 
 void OPENSSL_free(void *orig_ptr) {
@@ -180,11 +283,18 @@ void OPENSSL_free(void *orig_ptr) {
 
   size_t size = *(size_t *)ptr;
   OPENSSL_cleanse(ptr, size + OPENSSL_MALLOC_PREFIX);
+
+// ASan knows to intercept malloc and free, but not sdallocx.
+#if defined(OPENSSL_ASAN)
+  (void)sdallocx;
+  free(ptr);
+#else
   if (sdallocx) {
     sdallocx(ptr, size + OPENSSL_MALLOC_PREFIX, 0 /* flags */);
   } else {
     free(ptr);
   }
+#endif
 }
 
 void *OPENSSL_realloc(void *orig_ptr, size_t new_size) {
@@ -233,8 +343,18 @@ void OPENSSL_cleanse(void *ptr, size_t len) {
 #endif  // !OPENSSL_NO_ASM
 }
 
-void OPENSSL_clear_free(void *ptr, size_t unused) {
-  OPENSSL_free(ptr);
+void OPENSSL_clear_free(void *ptr, size_t unused) { OPENSSL_free(ptr); }
+
+int CRYPTO_secure_malloc_init(size_t size, size_t min_size) { return 0; }
+
+int CRYPTO_secure_malloc_initialized(void) { return 0; }
+
+size_t CRYPTO_secure_used(void) { return 0; }
+
+void *OPENSSL_secure_malloc(size_t size) { return OPENSSL_malloc(size); }
+
+void OPENSSL_secure_clear_free(void *ptr, size_t len) {
+  OPENSSL_clear_free(ptr, len);
 }
 
 int CRYPTO_memcmp(const void *in_a, const void *in_b, size_t len) {
@@ -290,6 +410,34 @@ char *OPENSSL_strdup(const char *s) {
   return ret;
 }
 
+int OPENSSL_isalpha(int c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+int OPENSSL_isdigit(int c) { return c >= '0' && c <= '9'; }
+
+int OPENSSL_isxdigit(int c) {
+  return OPENSSL_isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+}
+
+int OPENSSL_fromxdigit(uint8_t *out, int c) {
+  if (OPENSSL_isdigit(c)) {
+    *out = c - '0';
+    return 1;
+  }
+  if ('a' <= c && c <= 'f') {
+    *out = c - 'a' + 10;
+    return 1;
+  }
+  if ('A' <= c && c <= 'F') {
+    *out = c - 'A' + 10;
+    return 1;
+  }
+  return 0;
+}
+
+int OPENSSL_isalnum(int c) { return OPENSSL_isalpha(c) || OPENSSL_isdigit(c); }
+
 int OPENSSL_tolower(int c) {
   if (c >= 'A' && c <= 'Z') {
     return c + ('a' - 'A');
@@ -297,6 +445,11 @@ int OPENSSL_tolower(int c) {
   return c;
 }
 
+int OPENSSL_isspace(int c) {
+  return c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r' ||
+         c == ' ';
+}
+
 int OPENSSL_strcasecmp(const char *a, const char *b) {
   for (size_t i = 0;; i++) {
     const int aa = OPENSSL_tolower(a[i]);
@@ -341,6 +494,62 @@ int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) {
   return vsnprintf(buf, n, format, args);
 }
 
+int OPENSSL_vasprintf_internal(char **str, const char *format, va_list args,
+                               int system_malloc) {
+  void *(*allocate)(size_t) = system_malloc ? malloc : OPENSSL_malloc;
+  void (*deallocate)(void *) = system_malloc ? free : OPENSSL_free;
+  void *(*reallocate)(void *, size_t) =
+      system_malloc ? realloc : OPENSSL_realloc;
+  char *candidate = NULL;
+  size_t candidate_len = 64;  // TODO(bbe) what's the best initial size?
+
+  if ((candidate = allocate(candidate_len)) == NULL) {
+    goto err;
+  }
+  va_list args_copy;
+  va_copy(args_copy, args);
+  int ret = vsnprintf(candidate, candidate_len, format, args_copy);
+  va_end(args_copy);
+  if (ret < 0) {
+    goto err;
+  }
+  if ((size_t)ret >= candidate_len) {
+    // Too big to fit in allocation.
+    char *tmp;
+
+    candidate_len = (size_t)ret + 1;
+    if ((tmp = reallocate(candidate, candidate_len)) == NULL) {
+      goto err;
+    }
+    candidate = tmp;
+    ret = vsnprintf(candidate, candidate_len, format, args);
+  }
+  // At this point this should not happen unless vsnprintf is insane.
+  if (ret < 0 || (size_t)ret >= candidate_len) {
+    goto err;
+  }
+  *str = candidate;
+  return ret;
+
+ err:
+  deallocate(candidate);
+  *str = NULL;
+  errno = ENOMEM;
+  return -1;
+}
+
+int OPENSSL_vasprintf(char **str, const char *format, va_list args) {
+  return OPENSSL_vasprintf_internal(str, format, args, /*system_malloc=*/0);
+}
+
+int OPENSSL_asprintf(char **str, const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  int ret = OPENSSL_vasprintf(str, format, args);
+  va_end(args);
+  return ret;
+}
+
 char *OPENSSL_strndup(const char *str, size_t size) {
   size = OPENSSL_strnlen(str, size);
 
@@ -352,7 +561,6 @@ char *OPENSSL_strndup(const char *str, size_t size) {
   }
   char *ret = OPENSSL_malloc(alloc_size);
   if (ret == NULL) {
-    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
 
@@ -391,7 +599,6 @@ void *OPENSSL_memdup(const void *data, size_t size) {
 
   void *ret = OPENSSL_malloc(size);
   if (ret == NULL) {
-    OPENSSL_PUT_ERROR(CRYPTO, ERR_R_MALLOC_FAILURE);
     return NULL;
   }
 

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

@@ -155,7 +155,6 @@ ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o) {
   return r;
 
 err:
-  OPENSSL_PUT_ERROR(OBJ, ERR_R_MALLOC_FAILURE);
   OPENSSL_free(ln);
   OPENSSL_free(sn);
   OPENSSL_free(data);
@@ -506,25 +505,37 @@ static int cmp_long_name(const ASN1_OBJECT *a, const ASN1_OBJECT *b) {
 // obj_add_object inserts |obj| into the various global hashes for run-time
 // added objects. It returns one on success or zero otherwise.
 static int obj_add_object(ASN1_OBJECT *obj) {
-  int ok;
-  ASN1_OBJECT *old_object;
-
   obj->flags &= ~(ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
                   ASN1_OBJECT_FLAG_DYNAMIC_DATA);
 
   CRYPTO_STATIC_MUTEX_lock_write(&global_added_lock);
   if (global_added_by_nid == NULL) {
     global_added_by_nid = lh_ASN1_OBJECT_new(hash_nid, cmp_nid);
+  }
+  if (global_added_by_data == NULL) {
     global_added_by_data = lh_ASN1_OBJECT_new(hash_data, cmp_data);
-    global_added_by_short_name = lh_ASN1_OBJECT_new(hash_short_name, cmp_short_name);
+  }
+  if (global_added_by_short_name == NULL) {
+    global_added_by_short_name =
+        lh_ASN1_OBJECT_new(hash_short_name, cmp_short_name);
+  }
+  if (global_added_by_long_name == NULL) {
     global_added_by_long_name = lh_ASN1_OBJECT_new(hash_long_name, cmp_long_name);
   }
 
+  int ok = 0;
+  if (global_added_by_nid == NULL ||
+      global_added_by_data == NULL ||
+      global_added_by_short_name == NULL ||
+      global_added_by_long_name == NULL) {
+    goto err;
+  }
+
   // We don't pay attention to |old_object| (which contains any previous object
   // that was evicted from the hashes) because we don't have a reference count
   // on ASN1_OBJECT values. Also, we should never have duplicates nids and so
   // should always have objects in |global_added_by_nid|.
-
+  ASN1_OBJECT *old_object;
   ok = lh_ASN1_OBJECT_insert(global_added_by_nid, &old_object, obj);
   if (obj->length != 0 && obj->data != NULL) {
     ok &= lh_ASN1_OBJECT_insert(global_added_by_data, &old_object, obj);
@@ -535,8 +546,9 @@ static int obj_add_object(ASN1_OBJECT *obj) {
   if (obj->ln != NULL) {
     ok &= lh_ASN1_OBJECT_insert(global_added_by_long_name, &old_object, obj);
   }
-  CRYPTO_STATIC_MUTEX_unlock_write(&global_added_lock);
 
+err:
+  CRYPTO_STATIC_MUTEX_unlock_write(&global_added_lock);
   return ok;
 }
 

data/third_party/boringssl-with-bazel/src/crypto/obj/obj_dat.h

@@ -57,7 +57,7 @@
 /* This file is generated by crypto/obj/objects.go. */
 
 
-#define NUM_NID 963
+#define NUM_NID 967
 
 static const uint8_t kObjectData[] = {
     /* NID_rsadsi */
@@ -8781,6 +8781,10 @@ static const ASN1_OBJECT kObjects[NUM_NID] = {
     {"ED448", "ED448", NID_ED448, 3, &kObjectData[6181], 0},
     {"X448", "X448", NID_X448, 3, &kObjectData[6184], 0},
     {"SHA512-256", "sha512-256", NID_sha512_256, 9, &kObjectData[6187], 0},
+    {"HKDF", "hkdf", NID_hkdf, 0, NULL, 0},
+    {"X25519Kyber768", "X25519Kyber768", NID_X25519Kyber768, 0, NULL, 0},
+    {"P256Kyber768", "P256Kyber768", NID_P256Kyber768, 0, NULL, 0},
+    {"P384Kyber768", "P384Kyber768", NID_P384Kyber768, 0, NULL, 0},
 };
 
 static const uint16_t kNIDsInShortNameOrder[] = {
@@ -8878,6 +8882,7 @@ static const uint16_t kNIDsInShortNameOrder[] = {
     949 /* ED25519 */,
     960 /* ED448 */,
     99 /* GN */,
+    963 /* HKDF */,
     855 /* HMAC */,
     780 /* HMAC-MD5 */,
     781 /* HMAC-SHA1 */,
@@ -8913,6 +8918,8 @@ static const uint16_t kNIDsInShortNameOrder[] = {
     18 /* OU */,
     749 /* Oakley-EC2N-3 */,
     750 /* Oakley-EC2N-4 */,
+    965 /* P256Kyber768 */,
+    966 /* P384Kyber768 */,
     9 /* PBE-MD2-DES */,
     168 /* PBE-MD2-RC2-64 */,
     10 /* PBE-MD5-DES */,
@@ -8979,6 +8986,7 @@ static const uint16_t kNIDsInShortNameOrder[] = {
     458 /* UID */,
     0 /* UNDEF */,
     948 /* X25519 */,
+    964 /* X25519Kyber768 */,
     961 /* X448 */,
     11 /* X500 */,
     378 /* X500algorithms */,
@@ -9826,6 +9834,8 @@ static const uint16_t kNIDsInLongNameOrder[] = {
     366 /* OCSP Nonce */,
     371 /* OCSP Service Locator */,
     180 /* OCSP Signing */,
+    965 /* P256Kyber768 */,
+    966 /* P384Kyber768 */,
     161 /* PBES2 */,
     69 /* PBKDF2 */,
     162 /* PBMAC1 */,
@@ -9850,6 +9860,7 @@ static const uint16_t kNIDsInLongNameOrder[] = {
     133 /* Time Stamping */,
     375 /* Trust Root */,
     948 /* X25519 */,
+    964 /* X25519Kyber768 */,
     961 /* X448 */,
     12 /* X509 */,
     402 /* X509v3 AC Targeting */,
@@ -10096,6 +10107,7 @@ static const uint16_t kNIDsInLongNameOrder[] = {
     601 /* generic cryptogram */,
     99 /* givenName */,
     814 /* gost89-cnt */,
+    963 /* hkdf */,
     855 /* hmac */,
     780 /* hmac-md5 */,
     781 /* hmac-sha1 */,