grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/pool/pool.cc

@@ -21,171 +21,223 @@
 #include <openssl/mem.h>
 #include <openssl/rand.h>
 #include <openssl/siphash.h>
-#include <openssl/thread.h>
 
 #include "../internal.h"
+#include "../mem_internal.h"
 #include "internal.h"
 
 
-static uint32_t CRYPTO_BUFFER_hash(const CRYPTO_BUFFER *buf) {
-  return (uint32_t)SIPHASH_24(buf->pool->hash_key, buf->data, buf->len);
+using namespace bssl;
+
+static uint32_t CRYPTO_BUFFER_hash(const CryptoBuffer *buf) {
+  // This function must be called while there is a read or write lock on the
+  // pool, so it is safe to read `pool_`.
+  return buf->pool_handle_->pool_->Hash(buf->span());
 }
 
-static int CRYPTO_BUFFER_cmp(const CRYPTO_BUFFER *a, const CRYPTO_BUFFER *b) {
-  // Only |CRYPTO_BUFFER|s from the same pool have compatible hashes.
-  assert(a->pool != NULL);
-  assert(a->pool == b->pool);
-  if (a->len != b->len) {
-    return 1;
-  }
-  return OPENSSL_memcmp(a->data, b->data, a->len);
+static int CRYPTO_BUFFER_cmp(const CryptoBuffer *a, const CryptoBuffer *b) {
+  // Only `CRYPTO_BUFFER`s from the same pool have compatible hashes.
+  assert(a->pool_handle_ != nullptr);
+  assert(a->pool_handle_ == b->pool_handle_);
+  return a->span() == b->span() ? 0 : 1;
 }
 
-CRYPTO_BUFFER_POOL *CRYPTO_BUFFER_POOL_new(void) {
-  CRYPTO_BUFFER_POOL *pool = reinterpret_cast<CRYPTO_BUFFER_POOL *>(
-      OPENSSL_zalloc(sizeof(CRYPTO_BUFFER_POOL)));
-  if (pool == NULL) {
-    return NULL;
-  }
+CryptoBufferPool::CryptoBufferPool() : RefCounted(CheckSubClass()) {
+  RAND_bytes(reinterpret_cast<uint8_t *>(&hash_key_), sizeof(hash_key_));
+}
 
-  pool->bufs = lh_CRYPTO_BUFFER_new(CRYPTO_BUFFER_hash, CRYPTO_BUFFER_cmp);
-  if (pool->bufs == NULL) {
-    OPENSSL_free(pool);
-    return NULL;
+CryptoBufferPool::~CryptoBufferPool() {
+  if (handle_) {
+    MutexWriteLock lock(&handle_->lock_);
+    handle_->pool_ = nullptr;
   }
+  lh_CryptoBuffer_free(bufs_);
+}
 
-  CRYPTO_MUTEX_init(&pool->lock);
-  RAND_bytes((uint8_t *)&pool->hash_key, sizeof(pool->hash_key));
+uint32_t CryptoBufferPool::Hash(Span<const uint8_t> data) const {
+  return static_cast<uint32_t>(SIPHASH_24(hash_key_, data.data(), data.size()));
+}
 
-  return pool;
+CryptoBuffer *CryptoBufferPool::FindBufferLocked(uint32_t hash,
+                                                 Span<const uint8_t> data) {
+  return lh_CryptoBuffer_retrieve_key(
+      bufs_, &data, hash,
+      [](const void *key_v, const CryptoBuffer *buf) -> int {
+        Span<const uint8_t> key =
+            *static_cast<const Span<const uint8_t> *>(key_v);
+        return key == buf->span() ? 0 : 1;
+      });
 }
 
-void CRYPTO_BUFFER_POOL_free(CRYPTO_BUFFER_POOL *pool) {
-  if (pool == NULL) {
-    return;
+CRYPTO_BUFFER_POOL *CRYPTO_BUFFER_POOL_new() {
+  auto pool = MakeUnique<CryptoBufferPool>();
+  if (pool == nullptr) {
+    return nullptr;
   }
 
-#if !defined(NDEBUG)
-  CRYPTO_MUTEX_lock_write(&pool->lock);
-  assert(lh_CRYPTO_BUFFER_num_items(pool->bufs) == 0);
-  CRYPTO_MUTEX_unlock_write(&pool->lock);
-#endif
+  pool->bufs_ = lh_CryptoBuffer_new(CRYPTO_BUFFER_hash, CRYPTO_BUFFER_cmp);
+  pool->handle_ = MakeUnique<CryptoBufferPoolHandle>(pool.get());
+  if (pool->bufs_ == nullptr || pool->handle_ == nullptr) {
+    return nullptr;
+  }
 
-  lh_CRYPTO_BUFFER_free(pool->bufs);
-  CRYPTO_MUTEX_cleanup(&pool->lock);
-  OPENSSL_free(pool);
+  return pool.release();
 }
 
-static void crypto_buffer_free_object(CRYPTO_BUFFER *buf) {
-  if (!buf->data_is_static) {
-    OPENSSL_free(buf->data);
+void CRYPTO_BUFFER_POOL_free(CRYPTO_BUFFER_POOL *pool) {
+  if (pool != nullptr) {
+    FromOpaque(pool)->DecRefInternal();
   }
-  OPENSSL_free(buf);
 }
 
-static CRYPTO_BUFFER *crypto_buffer_new(const uint8_t *data, size_t len,
-                                        int data_is_static,
-                                        CRYPTO_BUFFER_POOL *pool) {
-  if (pool != NULL) {
-    CRYPTO_BUFFER tmp;
-    tmp.data = (uint8_t *)data;
-    tmp.len = len;
-    tmp.pool = pool;
-
-    CRYPTO_MUTEX_lock_read(&pool->lock);
-    CRYPTO_BUFFER *duplicate = lh_CRYPTO_BUFFER_retrieve(pool->bufs, &tmp);
-    if (data_is_static && duplicate != NULL && !duplicate->data_is_static) {
-      // If the new |CRYPTO_BUFFER| would have static data, but the duplicate
-      // does not, we replace the old one with the new static version.
-      duplicate = NULL;
+int CRYPTO_BUFFER_POOL_up_ref(CRYPTO_BUFFER_POOL *pool) {
+  FromOpaque(pool)->UpRefInternal();
+  return 1;
+}
+
+void CryptoBuffer::UpRefInternal() const {
+  // This is safe in the case that `buf->pool` is NULL because it's just
+  // standard reference counting in that case.
+  //
+  // This is also safe if `buf->pool` is non-NULL because, if it were racing
+  // with `CRYPTO_BUFFER_free` then the two callers must have independent
+  // references already and so the reference count will never hit zero.
+  CRYPTO_refcount_inc(&references_);
+}
+
+void CryptoBuffer::DecRefInternal() {
+  // If there is a pool, decrementing the refcount must synchronize with it.
+  if (pool_handle_ == nullptr) {
+    if (!CRYPTO_refcount_dec_and_test_zero(&references_)) {
+      return;
     }
-    if (duplicate != NULL) {
-      CRYPTO_refcount_inc(&duplicate->references);
+  } else {
+    MutexWriteLock lock(&pool_handle_->lock_);
+    if (!CRYPTO_refcount_dec_and_test_zero(&references_)) {
+      return;
     }
-    CRYPTO_MUTEX_unlock_read(&pool->lock);
 
-    if (duplicate != NULL) {
-      return duplicate;
+    // We have an exclusive lock on the pool handle, therefore no concurrent
+    // lookups can find this buffer and increment the reference count. Thus, if
+    // the count is zero there are and can never be any more references and thus
+    // we can free this buffer. It is possible the pool was already destroyed,
+    // but it cannot be destroyed concurrently.
+    //
+    // Note it is possible `buf` is no longer in the pool, if it was replaced by
+    // a static version. If that static version was since removed, it is even
+    // possible for `found` to be NULL.
+    if (CryptoBufferPool *pool = pool_handle_->pool_; pool != nullptr) {
+      CryptoBuffer *found = lh_CryptoBuffer_retrieve(pool->bufs_, this);
+      if (found == this) {
+        found = lh_CryptoBuffer_delete(pool->bufs_, this);
+        assert(found == this);
+        (void)found;
+      }
     }
   }
 
-  CRYPTO_BUFFER *const buf =
-      reinterpret_cast<CRYPTO_BUFFER *>(OPENSSL_zalloc(sizeof(CRYPTO_BUFFER)));
-  if (buf == NULL) {
-    return NULL;
+  this->~CryptoBuffer();
+  OPENSSL_free(this);
+}
+
+CryptoBuffer::~CryptoBuffer() {
+  if (!data_is_static_) {
+    OPENSSL_free(data_);
+  }
+}
+
+static UniquePtr<CryptoBuffer> crypto_buffer_new(Span<const uint8_t> data,
+                                                 bool data_is_static) {
+  UniquePtr<CryptoBuffer> buf = MakeUnique<CryptoBuffer>();
+  if (buf == nullptr) {
+    return nullptr;
   }
 
   if (data_is_static) {
-    buf->data = (uint8_t *)data;
-    buf->data_is_static = 1;
+    buf->data_ = const_cast<uint8_t *>(data.data());
+    buf->data_is_static_ = true;
   } else {
-    buf->data = reinterpret_cast<uint8_t *>(OPENSSL_memdup(data, len));
-    if (len != 0 && buf->data == NULL) {
-      OPENSSL_free(buf);
-      return NULL;
+    buf->data_ =
+        static_cast<uint8_t *>(OPENSSL_memdup(data.data(), data.size()));
+    if (!data.empty() && buf->data_ == nullptr) {
+      return nullptr;
     }
   }
 
-  buf->len = len;
-  buf->references = 1;
+  buf->len_ = data.size();
+  return buf;
+}
 
-  if (pool == NULL) {
-    return buf;
+static UniquePtr<CryptoBuffer> crypto_buffer_new_with_pool(
+    Span<const uint8_t> data, bool data_is_static, CryptoBufferPool *pool) {
+  if (pool == nullptr) {
+    return crypto_buffer_new(data, data_is_static);
   }
 
-  buf->pool = pool;
+  const uint32_t hash = pool->Hash(data);
+  {
+    // Look for a matching buffer in the pool.
+    MutexReadLock lock(&pool->handle_->lock_);
+    CryptoBuffer *duplicate = pool->FindBufferLocked(hash, data);
+    if (data_is_static && duplicate != nullptr && !duplicate->data_is_static_) {
+      // If the new `CRYPTO_BUFFER` would have static data, but the duplicate
+      // does not, we replace the old one with the new static version.
+      duplicate = nullptr;
+    }
+    if (duplicate != nullptr) {
+      return UpRef(duplicate);
+    }
+  }
 
-  CRYPTO_MUTEX_lock_write(&pool->lock);
-  CRYPTO_BUFFER *duplicate = lh_CRYPTO_BUFFER_retrieve(pool->bufs, buf);
-  if (data_is_static && duplicate != NULL && !duplicate->data_is_static) {
-    // If the new |CRYPTO_BUFFER| would have static data, but the duplicate does
+  UniquePtr<CryptoBuffer> buf = crypto_buffer_new(data, data_is_static);
+  if (buf == nullptr) {
+    return nullptr;
+  }
+
+  MutexWriteLock lock(&pool->handle_->lock_);
+  CryptoBuffer *duplicate = pool->FindBufferLocked(hash, data);
+  if (data_is_static && duplicate != nullptr && !duplicate->data_is_static_) {
+    // If the new `CRYPTO_BUFFER` would have static data, but the duplicate does
     // not, we replace the old one with the new static version.
-    duplicate = NULL;
+    duplicate = nullptr;
   }
-  int inserted = 0;
-  if (duplicate == NULL) {
-    CRYPTO_BUFFER *old = NULL;
-    inserted = lh_CRYPTO_BUFFER_insert(pool->bufs, &old, buf);
-    // |old| may be non-NULL if a match was found but ignored. |pool->bufs| does
-    // not increment refcounts, so there is no need to clean up after the
-    // replacement.
-  } else {
-    CRYPTO_refcount_inc(&duplicate->references);
+  if (duplicate != nullptr) {
+    return UpRef(duplicate);
   }
-  CRYPTO_MUTEX_unlock_write(&pool->lock);
 
-  if (!inserted) {
-    // We raced to insert |buf| into the pool and lost, or else there was an
-    // error inserting.
-    crypto_buffer_free_object(buf);
-    return duplicate;
+  // Insert `buf` into the pool. Note `old` may be non-NULL if a match was found
+  // but ignored. `pool->bufs_` does not increment refcounts, so there is no
+  // need to clean up after the replacement.
+  buf->pool_handle_ = UpRef(pool->handle_);
+  CryptoBuffer *old = nullptr;
+  if (!lh_CryptoBuffer_insert(pool->bufs_, &old, buf.get())) {
+    buf->pool_handle_ = nullptr;  // No need to synchronize with the pool.
+    return nullptr;
   }
-
   return buf;
 }
 
 CRYPTO_BUFFER *CRYPTO_BUFFER_new(const uint8_t *data, size_t len,
                                  CRYPTO_BUFFER_POOL *pool) {
-  return crypto_buffer_new(data, len, /*data_is_static=*/0, pool);
+  return crypto_buffer_new_with_pool(Span(data, len), /*data_is_static=*/false,
+                                     FromOpaque(pool))
+      .release();
 }
 
 CRYPTO_BUFFER *CRYPTO_BUFFER_alloc(uint8_t **out_data, size_t len) {
-  CRYPTO_BUFFER *const buf =
-      reinterpret_cast<CRYPTO_BUFFER *>(OPENSSL_zalloc(sizeof(CRYPTO_BUFFER)));
-  if (buf == NULL) {
-    return NULL;
+  auto buf = MakeUnique<CryptoBuffer>();
+  if (buf == nullptr) {
+    return nullptr;
   }
 
-  buf->data = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
-  if (len != 0 && buf->data == NULL) {
-    OPENSSL_free(buf);
-    return NULL;
+  buf->data_ = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
+  if (len != 0 && buf->data_ == nullptr) {
+    return nullptr;
   }
-  buf->len = len;
-  buf->references = 1;
+  buf->len_ = len;
 
-  *out_data = buf->data;
-  return buf;
+  *out_data = buf->data_;
+  return buf.release();
 }
 
 CRYPTO_BUFFER *CRYPTO_BUFFER_new_from_CBS(const CBS *cbs,
@@ -195,68 +247,36 @@ CRYPTO_BUFFER *CRYPTO_BUFFER_new_from_CBS(const CBS *cbs,
 
 CRYPTO_BUFFER *CRYPTO_BUFFER_new_from_static_data_unsafe(
     const uint8_t *data, size_t len, CRYPTO_BUFFER_POOL *pool) {
-  return crypto_buffer_new(data, len, /*data_is_static=*/1, pool);
+  return crypto_buffer_new_with_pool(Span(data, len), /*data_is_static=*/true,
+                                     FromOpaque(pool))
+      .release();
 }
 
 void CRYPTO_BUFFER_free(CRYPTO_BUFFER *buf) {
-  if (buf == NULL) {
-    return;
-  }
-
-  CRYPTO_BUFFER_POOL *const pool = buf->pool;
-  if (pool == NULL) {
-    if (CRYPTO_refcount_dec_and_test_zero(&buf->references)) {
-      // If a reference count of zero is observed, there cannot be a reference
-      // from any pool to this buffer and thus we are able to free this
-      // buffer.
-      crypto_buffer_free_object(buf);
-    }
-
-    return;
+  if (buf != nullptr) {
+    FromOpaque(buf)->DecRefInternal();
   }
-
-  CRYPTO_MUTEX_lock_write(&pool->lock);
-  if (!CRYPTO_refcount_dec_and_test_zero(&buf->references)) {
-    CRYPTO_MUTEX_unlock_write(&buf->pool->lock);
-    return;
-  }
-
-  // We have an exclusive lock on the pool, therefore no concurrent lookups can
-  // find this buffer and increment the reference count. Thus, if the count is
-  // zero there are and can never be any more references and thus we can free
-  // this buffer.
-  //
-  // Note it is possible |buf| is no longer in the pool, if it was replaced by a
-  // static version. If that static version was since removed, it is even
-  // possible for |found| to be NULL.
-  CRYPTO_BUFFER *found = lh_CRYPTO_BUFFER_retrieve(pool->bufs, buf);
-  if (found == buf) {
-    found = lh_CRYPTO_BUFFER_delete(pool->bufs, buf);
-    assert(found == buf);
-    (void)found;
-  }
-
-  CRYPTO_MUTEX_unlock_write(&buf->pool->lock);
-  crypto_buffer_free_object(buf);
 }
 
 int CRYPTO_BUFFER_up_ref(CRYPTO_BUFFER *buf) {
-  // This is safe in the case that |buf->pool| is NULL because it's just
-  // standard reference counting in that case.
-  //
-  // This is also safe if |buf->pool| is non-NULL because, if it were racing
-  // with |CRYPTO_BUFFER_free| then the two callers must have independent
-  // references already and so the reference count will never hit zero.
-  CRYPTO_refcount_inc(&buf->references);
+  FromOpaque(buf)->UpRefInternal();
   return 1;
 }
 
+CRYPTO_BUFFER *CRYPTO_BUFFER_dup_ref(const CRYPTO_BUFFER *buf) {
+  auto *buf_ = const_cast<CRYPTO_BUFFER *>(buf);
+  FromOpaque(buf_)->UpRefInternal();
+  return buf_;
+}
+
 const uint8_t *CRYPTO_BUFFER_data(const CRYPTO_BUFFER *buf) {
-  return buf->data;
+  return FromOpaque(buf)->data_;
 }
 
-size_t CRYPTO_BUFFER_len(const CRYPTO_BUFFER *buf) { return buf->len; }
+size_t CRYPTO_BUFFER_len(const CRYPTO_BUFFER *buf) {
+  return FromOpaque(buf)->len_;
+}
 
 void CRYPTO_BUFFER_init_CBS(const CRYPTO_BUFFER *buf, CBS *out) {
-  CBS_init(out, buf->data, buf->len);
+  *out = FromOpaque(buf)->span();
 }

data/third_party/boringssl-with-bazel/crypto/rand/deterministic.cc

@@ -26,24 +26,26 @@
 #include "../internal.h"
 
 
-// g_num_calls is the number of calls to |CRYPTO_sysrand| that have occurred.
+using namespace bssl;
+
+// g_num_calls is the number of calls to `CRYPTO_sysrand` that have occurred.
 //
 // This is intentionally not thread-safe. If the fuzzer mode is ever used in a
 // multi-threaded program, replace this with a thread-local. (A mutex would not
 // be deterministic.)
 static uint64_t g_num_calls = 0;
-static CRYPTO_MUTEX g_num_calls_lock = CRYPTO_MUTEX_INIT;
+static StaticMutex g_num_calls_lock;
 
-void RAND_reset_for_fuzzing(void) { g_num_calls = 0; }
+void RAND_reset_for_fuzzing() { g_num_calls = 0; }
 
-void CRYPTO_init_sysrand(void) {}
+void bssl::CRYPTO_init_sysrand() {}
 
-void CRYPTO_sysrand(uint8_t *out, size_t requested) {
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
   static const uint8_t kZeroKey[32] = {0};
 
-  CRYPTO_MUTEX_lock_write(&g_num_calls_lock);
+  g_num_calls_lock.LockWrite();
   uint64_t num_calls = g_num_calls++;
-  CRYPTO_MUTEX_unlock_write(&g_num_calls_lock);
+  g_num_calls_lock.UnlockWrite();
 
   uint8_t nonce[12];
   OPENSSL_memset(nonce, 0, sizeof(nonce));
@@ -53,13 +55,4 @@ void CRYPTO_sysrand(uint8_t *out, size_t requested) {
   CRYPTO_chacha_20(out, out, requested, kZeroKey, nonce, 0);
 }
 
-int CRYPTO_sysrand_if_available(uint8_t *buf, size_t len) {
-  CRYPTO_sysrand(buf, len);
-  return 1;
-}
-
-void CRYPTO_sysrand_for_seed(uint8_t *out, size_t requested) {
-  CRYPTO_sysrand(out, requested);
-}
-
 #endif  // OPENSSL_RAND_DETERMINISTIC