grpc 1.84.0 → 1.85.0.pre1

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

@@ -23,50 +23,17 @@
 
 #if defined(OPENSSL_RAND_URANDOM)
 
-#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#if defined(OPENSSL_LINUX)
-#if defined(BORINGSSL_FIPS)
 #include <linux/random.h>
-#include <sys/ioctl.h>
-#endif
+#include <stdio.h>
 #include <sys/syscall.h>
-
-#if defined(OPENSSL_ANDROID)
-#include <sys/system_properties.h>
-#endif
-
-#if !defined(OPENSSL_ANDROID)
-#define OPENSSL_HAS_GETAUXVAL
-#endif
-// glibc prior to 2.16 does not have getauxval and sys/auxv.h. Android has some
-// host builds (i.e. not building for Android itself, so |OPENSSL_ANDROID| is
-// unset) which are still using a 2.15 sysroot.
-//
-// TODO(davidben): Remove this once Android updates their sysroot.
-#if defined(__GLIBC_PREREQ)
-#if !__GLIBC_PREREQ(2, 16)
-#undef OPENSSL_HAS_GETAUXVAL
-#endif
-#endif
-#if defined(OPENSSL_HAS_GETAUXVAL)
-#include <sys/auxv.h>
-#endif
-#endif  // OPENSSL_LINUX
-
-#include <openssl/mem.h>
-#include <openssl/thread.h>
+#include <unistd.h>
 
 #include "../internal.h"
-#include "getrandom_fillin.h"
 
 
-#if defined(USE_NR_getrandom)
+using namespace bssl;
 
 #if defined(OPENSSL_MSAN)
 extern "C" {
@@ -82,7 +49,7 @@ static ssize_t boringssl_getrandom(void *buf, size_t buf_len, unsigned flags) {
 
 #if defined(OPENSSL_MSAN)
   if (ret > 0) {
-    // MSAN doesn't recognise |syscall| and thus doesn't notice that we have
+    // MSAN doesn't recognise `syscall` and thus doesn't notice that we have
     // initialised the output buffer.
     __msan_unpoison(buf, ret);
   }
@@ -91,60 +58,24 @@ static ssize_t boringssl_getrandom(void *buf, size_t buf_len, unsigned flags) {
   return ret;
 }
 
-#endif  // USE_NR_getrandom
-
-// kHaveGetrandom in |urandom_fd| signals that |getrandom| or |getentropy| is
+// kHaveGetrandom in `urandom_fd` signals that `getrandom` or `getentropy` is
 // available and should be used instead.
 static const int kHaveGetrandom = -3;
 
-// urandom_fd is a file descriptor to /dev/urandom. It's protected by |once|.
+// urandom_fd is a file descriptor to /dev/urandom. It's protected by `once`.
 static int urandom_fd;
 
-#if defined(USE_NR_getrandom)
-
-// getrandom_ready is one if |getrandom| had been initialized by the time
-// |init_once| was called and zero otherwise.
-static int getrandom_ready;
-
-// extra_getrandom_flags_for_seed contains a value that is ORed into the flags
-// for getrandom() when reading entropy for a seed.
-static int extra_getrandom_flags_for_seed;
-
-// On Android, check a system property to decide whether to set
-// |extra_getrandom_flags_for_seed| otherwise they will default to zero.  If
-// ro.oem_boringcrypto_hwrand is true then |extra_getrandom_flags_for_seed| will
-// be set to GRND_RANDOM, causing all random data to be drawn from the same
-// source as /dev/random.
-static void maybe_set_extra_getrandom_flags(void) {
-#if defined(BORINGSSL_FIPS) && defined(OPENSSL_ANDROID)
-  char value[PROP_VALUE_MAX + 1];
-  int length = __system_property_get("ro.boringcrypto.hwrand", value);
-  if (length < 0 || length > PROP_VALUE_MAX) {
-    return;
-  }
-
-  value[length] = 0;
-  if (OPENSSL_strcasecmp(value, "true") == 0) {
-    extra_getrandom_flags_for_seed = GRND_RANDOM;
-  }
-#endif
-}
-
-#endif  // USE_NR_getrandom
-
 static CRYPTO_once_t rand_once = CRYPTO_ONCE_INIT;
 
 // init_once initializes the state of this module to values previously
-// requested. This is the only function that modifies |urandom_fd|, which may be
+// requested. This is the only function that modifies `urandom_fd`, which may be
 // read safely after calling the once.
-static void init_once(void) {
-#if defined(USE_NR_getrandom)
+static void init_once() {
   int have_getrandom;
   uint8_t dummy;
   ssize_t getrandom_ret =
       boringssl_getrandom(&dummy, sizeof(dummy), GRND_NONBLOCK);
   if (getrandom_ret == 1) {
-    getrandom_ready = 1;
     have_getrandom = 1;
   } else if (getrandom_ret == -1 && errno == EAGAIN) {
     // We have getrandom, but the entropy pool has not been initialized yet.
@@ -160,18 +91,10 @@ static void init_once(void) {
 
   if (have_getrandom) {
     urandom_fd = kHaveGetrandom;
-    maybe_set_extra_getrandom_flags();
     return;
   }
-#endif  // USE_NR_getrandom
 
   // FIPS builds must support getrandom.
-  //
-  // Historically, only Android FIPS builds required getrandom, while Linux FIPS
-  // builds had a /dev/urandom fallback which used RNDGETENTCNT as a poor
-  // approximation for getrandom's blocking behavior. This is now removed, but
-  // avoid making assumptions on this removal until March 2023, in case it needs
-  // to be restored. This comment can be deleted after March 2023.
 #if defined(BORINGSSL_FIPS)
   perror("getrandom not found");
   abort();
@@ -190,96 +113,24 @@ static void init_once(void) {
   urandom_fd = fd;
 }
 
-static CRYPTO_once_t wait_for_entropy_once = CRYPTO_ONCE_INIT;
-
-static void wait_for_entropy(void) {
-  int fd = urandom_fd;
-  if (fd == kHaveGetrandom) {
-    // |getrandom| and |getentropy| support blocking in |fill_with_entropy|
-    // directly. For |getrandom|, we first probe with a non-blocking call to aid
-    // debugging.
-#if defined(USE_NR_getrandom)
-    if (getrandom_ready) {
-      // The entropy pool was already initialized in |init_once|.
-      return;
-    }
-
-    uint8_t dummy;
-    ssize_t getrandom_ret =
-        boringssl_getrandom(&dummy, sizeof(dummy), GRND_NONBLOCK);
-    if (getrandom_ret == -1 && errno == EAGAIN) {
-      // Attempt to get the path of the current process to aid in debugging when
-      // something blocks.
-      const char *current_process = "<unknown>";
-#if defined(OPENSSL_HAS_GETAUXVAL)
-      const unsigned long getauxval_ret = getauxval(AT_EXECFN);
-      if (getauxval_ret != 0) {
-        current_process = (const char *)getauxval_ret;
-      }
-#endif
-
-      fprintf(
-          stderr,
-          "%s: getrandom indicates that the entropy pool has not been "
-          "initialized. Rather than continue with poor entropy, this process "
-          "will block until entropy is available.\n",
-          current_process);
+void bssl::CRYPTO_init_sysrand() { CRYPTO_once(&rand_once, init_once); }
 
-      getrandom_ret =
-          boringssl_getrandom(&dummy, sizeof(dummy), 0 /* no flags */);
-    }
-
-    if (getrandom_ret != 1) {
-      perror("getrandom");
-      abort();
-    }
-#endif  // USE_NR_getrandom
-    return;
-  }
-}
-
-// fill_with_entropy writes |len| bytes of entropy into |out|. It returns one
-// on success and zero on error. If |block| is one, this function will block
-// until the entropy pool is initialized. Otherwise, this function may fail,
-// setting |errno| to |EAGAIN| if the entropy pool has not yet been initialized.
-// If |seed| is one, this function will OR in the value of
-// |*extra_getrandom_flags_for_seed()| when using |getrandom|.
-static int fill_with_entropy(uint8_t *out, size_t len, int block, int seed) {
+// CRYPTO_sysrand writes `len` bytes of entropy into `out`.
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t len) {
   if (len == 0) {
-    return 1;
-  }
-
-#if defined(USE_NR_getrandom) || defined(FREEBSD_GETRANDOM)
-  int getrandom_flags = 0;
-  if (!block) {
-    getrandom_flags |= GRND_NONBLOCK;
-  }
-#endif
-
-#if defined(USE_NR_getrandom)
-  if (seed) {
-    getrandom_flags |= extra_getrandom_flags_for_seed;
+    return;
   }
-#endif
 
   CRYPTO_init_sysrand();
-  if (block) {
-    CRYPTO_once(&wait_for_entropy_once, wait_for_entropy);
-  }
 
-  // Clear |errno| so it has defined value if |read| or |getrandom|
+  // Clear `errno` so it has defined value if `read` or `getrandom`
   // "successfully" returns zero.
   errno = 0;
   while (len > 0) {
     ssize_t r;
 
     if (urandom_fd == kHaveGetrandom) {
-#if defined(USE_NR_getrandom)
-      r = boringssl_getrandom(out, len, getrandom_flags);
-#else  // USE_NR_getrandom
-      fprintf(stderr, "urandom fd corrupt.\n");
-      abort();
-#endif
+      r = boringssl_getrandom(out, len, 0);
     } else {
       do {
         r = read(urandom_fd, out, len);
@@ -287,42 +138,12 @@ static int fill_with_entropy(uint8_t *out, size_t len, int block, int seed) {
     }
 
     if (r <= 0) {
-      return 0;
+      perror("entropy fill failed");
+      abort();
     }
     out += r;
     len -= r;
   }
-
-  return 1;
-}
-
-void CRYPTO_init_sysrand(void) { CRYPTO_once(&rand_once, init_once); }
-
-// CRYPTO_sysrand puts |requested| random bytes into |out|.
-void CRYPTO_sysrand(uint8_t *out, size_t requested) {
-  if (!fill_with_entropy(out, requested, /*block=*/1, /*seed=*/0)) {
-    perror("entropy fill failed");
-    abort();
-  }
-}
-
-void CRYPTO_sysrand_for_seed(uint8_t *out, size_t requested) {
-  if (!fill_with_entropy(out, requested, /*block=*/1, /*seed=*/1)) {
-    perror("entropy fill failed");
-    abort();
-  }
-}
-
-int CRYPTO_sysrand_if_available(uint8_t *out, size_t requested) {
-  if (fill_with_entropy(out, requested, /*block=*/0, /*seed=*/0)) {
-    return 1;
-  } else if (errno == EAGAIN) {
-    OPENSSL_memset(out, 0, requested);
-    return 0;
-  } else {
-    perror("opportunistic entropy fill failed");
-    abort();
-  }
 }
 
 #endif  // OPENSSL_RAND_URANDOM

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

@@ -25,6 +25,8 @@
 
 #include <windows.h>
 
+using namespace bssl;
+
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
     !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 #include <bcrypt.h>
@@ -34,16 +36,16 @@ OPENSSL_MSVC_PRAGMA(comment(lib, "bcrypt.lib"))
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && \
     !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
 
-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) {
   while (requested > 0) {
     ULONG output_bytes_this_pass = ULONG_MAX;
     if (requested < output_bytes_this_pass) {
       output_bytes_this_pass = (ULONG)requested;
     }
     if (!BCRYPT_SUCCESS(BCryptGenRandom(
-            /*hAlgorithm=*/NULL, out, output_bytes_this_pass,
+            /*hAlgorithm=*/nullptr, out, output_bytes_this_pass,
             BCRYPT_USE_SYSTEM_PREFERRED_RNG))) {
       abort();
     }
@@ -55,26 +57,26 @@ void CRYPTO_sysrand(uint8_t *out, size_t requested) {
 #else
 
 // See: https://learn.microsoft.com/en-us/windows/win32/seccng/processprng
-typedef BOOL (WINAPI *ProcessPrngFunction)(PBYTE pbData, SIZE_T cbData);
-static ProcessPrngFunction g_processprng_fn = NULL;
+typedef BOOL(WINAPI *ProcessPrngFunction)(PBYTE pbData, SIZE_T cbData);
+static ProcessPrngFunction g_processprng_fn = nullptr;
 
-static void init_processprng(void) {
+static void init_processprng() {
   HMODULE hmod = LoadLibraryW(L"bcryptprimitives");
-  if (hmod == NULL) {
+  if (hmod == nullptr) {
     abort();
   }
   g_processprng_fn = (ProcessPrngFunction)GetProcAddress(hmod, "ProcessPrng");
-  if (g_processprng_fn == NULL) {
+  if (g_processprng_fn == nullptr) {
     abort();
   }
 }
 
-void CRYPTO_init_sysrand(void) {
+void bssl::CRYPTO_init_sysrand() {
   static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
   CRYPTO_once(&once, init_processprng);
 }
 
-void CRYPTO_sysrand(uint8_t *out, size_t requested) {
+void bssl::CRYPTO_sysrand(uint8_t *out, size_t requested) {
   CRYPTO_init_sysrand();
   // On non-UWP configurations, use ProcessPrng instead of BCryptGenRandom
   // to avoid accessing resources that may be unavailable inside the
@@ -86,13 +88,4 @@ void CRYPTO_sysrand(uint8_t *out, size_t requested) {
 
 #endif  // WINAPI_PARTITION_APP && !WINAPI_PARTITION_DESKTOP
 
-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_WINDOWS

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

@@ -18,30 +18,21 @@
 #include <stdlib.h>
 
 
-// See comment above the typedef of CRYPTO_refcount_t about these tests.
-static_assert(alignof(CRYPTO_refcount_t) == alignof(CRYPTO_atomic_u32),
-              "CRYPTO_refcount_t does not match CRYPTO_atomic_u32 alignment");
-static_assert(sizeof(CRYPTO_refcount_t) == sizeof(CRYPTO_atomic_u32),
-              "CRYPTO_refcount_t does not match CRYPTO_atomic_u32 size");
+using namespace bssl;
 
-static_assert((CRYPTO_refcount_t)-1 == CRYPTO_REFCOUNT_MAX,
-              "CRYPTO_REFCOUNT_MAX is incorrect");
-
-void CRYPTO_refcount_inc(CRYPTO_refcount_t *in_count) {
-  CRYPTO_atomic_u32 *count = (CRYPTO_atomic_u32 *)in_count;
-  uint32_t expected = CRYPTO_atomic_load_u32(count);
+void bssl::CRYPTO_refcount_inc(CRYPTO_refcount_t *count) {
+  uint32_t expected = count->load();
 
   while (expected != CRYPTO_REFCOUNT_MAX) {
     uint32_t new_value = expected + 1;
-    if (CRYPTO_atomic_compare_exchange_weak_u32(count, &expected, new_value)) {
+    if (count->compare_exchange_weak(expected, new_value)) {
       break;
     }
   }
 }
 
-int CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *in_count) {
-  CRYPTO_atomic_u32 *count = (CRYPTO_atomic_u32 *)in_count;
-  uint32_t expected = CRYPTO_atomic_load_u32(count);
+int bssl::CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *count) {
+  uint32_t expected = count->load();
 
   for (;;) {
     if (expected == 0) {
@@ -50,8 +41,7 @@ int CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *in_count) {
       return 0;
     } else {
       const uint32_t new_value = expected - 1;
-      if (CRYPTO_atomic_compare_exchange_weak_u32(count, &expected,
-                                                  new_value)) {
+      if (count->compare_exchange_weak(expected, new_value)) {
         return new_value == 0;
       }
     }

data/third_party/boringssl-with-bazel/crypto/rsa/internal.h

@@ -17,20 +17,35 @@
 
 #include <openssl/base.h>
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
+#include "../fipsmodule/rsa/internal.h"
 
 
+BSSL_NAMESPACE_BEGIN
+
 int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len,
                                       size_t max_out, const uint8_t *from,
                                       size_t from_len, const uint8_t *param,
                                       size_t param_len, const EVP_MD *md,
                                       const EVP_MD *mgf1md);
 
-
-#if defined(__cplusplus)
-}  // extern C
-#endif
+// rsa_pss_params_get_md returns the hash function used with `params`. This also
+// specifies the MGF-1 hash and the salt length because we do not support other
+// configurations.
+const EVP_MD *rsa_pss_params_get_md(rsa_pss_params_t params);
+
+// rsa_marshal_pss_params marshals `params` as a DER-encoded RSASSA-PSS-params
+// (RFC 4055). It returns one on success and zero on error. If `params` is
+// `rsa_pss_params_none`, this function gives an error.
+int rsa_marshal_pss_params(CBB *cbb, rsa_pss_params_t params);
+
+// rsa_marshal_pss_params decodes a DER-encoded RSASSA-PSS-params
+// (RFC 4055). It returns one on success and zero on error. On success, it sets
+// `*out` to the result. If `allow_explicit_trailer` is non-zero, an explicit
+// encoding of the trailerField is allowed, although it is not valid DER. This
+// function never outputs `rsa_pss_params_none`.
+int rsa_parse_pss_params(CBS *cbs, rsa_pss_params_t *out,
+                         int allow_explicit_trailer);
+
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_RSA_INTERNAL_H