[sanitizers] Add a blocking boolean to GetRandom prototype

[cryptoad]

Summary

On platforms with getrandom, the system call defaults to blocking. This
becomes an issue in the very early stage of the boot for Scudo, when the RNG
source is not set-up yet: the syscall will block and we'll stall.

Introduce a parameter to specify that the function should not block, defaulting
to blocking as the underlying syscall does.

Update Scudo to use the non-blocking version.

[alekseyshl]

lib/sanitizer_common/sanitizer_linux.cc

1704

Can you move those defines to the top of the file and define SANITIZER_USE_GETRANDOM? Then here you can do

if (SANITIZER_USE_GETRANDOM) {
  ...
}

[cryptoad]

lib/sanitizer_common/sanitizer_linux.cc

1704

So the compiler still wants SYSCALL(getrandom) and GRND_NONBLOCK to be defined with an if rather than an #if.
I am unsure how to cleanly address that. Macroing the internal_syscall part to do nothing?

[cryptoad]

How about this code construct?

[alekseyshl]

lib/sanitizer_common/sanitizer_linux.cc

1704

You're right, this is not ideal too. Yep, let's keep #if SANITIZER_LINUX && defined(__NR_getrandom) block at the top of the file and use #if SANITIZER_USE_GETRANDOM here to avoid internal_getrandom definition. Other than that, looks good. Sorry for the delay!

[cryptoad]

Keeping SANITIZER_USE_GETRANDOM at the top, protecting the getrandom
syscall with an #if to keep the compiler happy.

lib/sanitizer_common/sanitizer_common.h

 
 // The default value for allocator_release_to_os_interval_ms common flag to
 // indicate that sanitizer allocator should not attempt to release memory to OS.
 const s32 kReleaseToOSIntervalNever = -1;
 
 void CheckNoDeepBind(const char *filename, int flag);
 
 // Returns the requested amount of random data (up to 256 bytes) that can then
-// be used to seed a PRNG.
-bool GetRandom(void *buffer, uptr length);
+// be used to seed a PRNG. Defaults to blocking like the underlying syscall.
+bool GetRandom(void *buffer, uptr length, bool blocking = true);
 
 }  // namespace __sanitizer
 
 inline void *operator new(__sanitizer::operator_new_size_type size,
                           __sanitizer::LowLevelAllocator &alloc) {
   return alloc.Allocate(size);
 }
 
 #endif  // SANITIZER_COMMON_H

lib/sanitizer_common/sanitizer_linux.cc

 #endif
 
 #if defined(__x86_64__) || SANITIZER_MIPS64
 extern "C" {
 extern void internal_sigreturn();
 }
 #endif
 
+#if SANITIZER_LINUX && defined(__NR_getrandom)
+# if !defined(GRND_NONBLOCK)
+#  define GRND_NONBLOCK 1
+# endif
+# define SANITIZER_USE_GETRANDOM 1
+#else
+# define SANITIZER_USE_GETRANDOM 0
+#endif  // SANITIZER_LINUX && defined(__NR_getrandom)
+
 namespace __sanitizer {
 
 #if SANITIZER_LINUX && defined(__x86_64__)
 #include "sanitizer_syscall_linux_x86_64.inc"
 #elif SANITIZER_LINUX && defined(__aarch64__)
 #include "sanitizer_syscall_linux_aarch64.inc"
 #else
 #include "sanitizer_syscall_generic.inc"

 }
 
 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding,
                               uptr *largest_gap_found) {
   UNREACHABLE("FindAvailableMemoryRange is not available");
   return 0;
 }
 
-bool GetRandom(void *buffer, uptr length) {
+#if SANITIZER_USE_GETRANDOM
+uptr internal_getrandom(void *buffer, uptr length, bool blocking) {
+  return internal_syscall(SYSCALL(getrandom), buffer, length,
+                          blocking ? 0 : GRND_NONBLOCK);
+}
+#else
+uptr internal_getrandom(void *buffer, uptr length, bool blocking) {
+  return static_cast<uptr>(-ENOSYS);
+}
+#endif  // SANITIZER_USE_GETRANDOM
+
+bool GetRandom(void *buffer, uptr length, bool blocking) {
   if (!buffer || !length || length > 256)
     return false;
-#if defined(__NR_getrandom)
+  if (SANITIZER_USE_GETRANDOM) {
     static atomic_uint8_t skip_getrandom_syscall;
     if (!atomic_load_relaxed(&skip_getrandom_syscall)) {
       // Up to 256 bytes, getrandom will not be interrupted.
-    uptr res = internal_syscall(SYSCALL(getrandom), buffer, length, 0);
+      uptr res = internal_getrandom(buffer, length, blocking);
       int rverrno = 0;
       if (internal_iserror(res, &rverrno) && rverrno == ENOSYS)
         atomic_store_relaxed(&skip_getrandom_syscall, 1);
       else if (res == length)
         return true;
     }
-#endif
+  }
+  // Up to 256 bytes, a read off /dev/urandom will not be interrupted.
+  // blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom.
   uptr fd = internal_open("/dev/urandom", O_RDONLY);
   if (internal_iserror(fd))
     return false;
-  // internal_read deals with EINTR.
   uptr res = internal_read(fd, buffer, length);
   if (internal_iserror(res))
     return false;
   internal_close(fd);
   return true;
 }
 
 } // namespace __sanitizer
 
 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX

lib/sanitizer_common/sanitizer_mac.cc

void PrintModuleMap() {
   Printf("End of module map.\n");
 }
 
 void CheckNoDeepBind(const char *filename, int flag) {
   // Do nothing.
 }
 
 // FIXME: implement on this platform.
-bool GetRandom(void *buffer, uptr length) {
+bool GetRandom(void *buffer, uptr length, bool blocking) {
   UNIMPLEMENTED();
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_MAC

lib/sanitizer_common/sanitizer_win.cc

 // FIXME implement on this platform.
 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) { }
 
 void CheckNoDeepBind(const char *filename, int flag) {
   // Do nothing.
 }
 
 // FIXME: implement on this platform.
-bool GetRandom(void *buffer, uptr length) {
+bool GetRandom(void *buffer, uptr length, bool blocking) {
   UNIMPLEMENTED();
 }
 
 }  // namespace __sanitizer
 
 #endif  // _WIN32

lib/sanitizer_common/tests/sanitizer_common_test.cc

TEST(SanitizerCommon, InternalScopedString) {
   str.append("0123456789");
   EXPECT_EQ(9U, str.length());
   EXPECT_STREQ("012345678", str.data());
 }
 
 #if SANITIZER_LINUX
 TEST(SanitizerCommon, GetRandom) {
   u8 buffer_1[32], buffer_2[32];
-  EXPECT_FALSE(GetRandom(nullptr, 32));
-  EXPECT_FALSE(GetRandom(buffer_1, 0));
-  EXPECT_FALSE(GetRandom(buffer_1, 512));
+  for (bool blocking : { false, true }) {
+    EXPECT_FALSE(GetRandom(nullptr, 32, blocking));
+    EXPECT_FALSE(GetRandom(buffer_1, 0, blocking));
+    EXPECT_FALSE(GetRandom(buffer_1, 512, blocking));
     EXPECT_EQ(ARRAY_SIZE(buffer_1), ARRAY_SIZE(buffer_2));
     for (uptr size = 4; size <= ARRAY_SIZE(buffer_1); size += 4) {
       for (uptr i = 0; i < 100; i++) {
-      EXPECT_TRUE(GetRandom(buffer_1, size));
-      EXPECT_TRUE(GetRandom(buffer_2, size));
+        EXPECT_TRUE(GetRandom(buffer_1, size, blocking));
+        EXPECT_TRUE(GetRandom(buffer_2, size, blocking));
         EXPECT_NE(internal_memcmp(buffer_1, buffer_2, size), 0);
       }
     }
   }
+}
 #endif
 
 }  // namespace __sanitizer

lib/scudo/scudo_utils.h

 INLINE u64 rotl(const u64 X, int K) {
   return (X << K) | (X >> (64 - K));
 }
 
 // XoRoShiRo128+ PRNG (http://xoroshiro.di.unimi.it/).
 struct XoRoShiRo128Plus {
  public:
   void init() {
-    if (UNLIKELY(!GetRandom(reinterpret_cast<void *>(State), sizeof(State)))) {
-      // Early processes (eg: init) do not have /dev/urandom yet, but we still
-      // have to provide them with some degree of entropy. Not having a secure
-      // seed is not as problematic for them, as they are less likely to be
-      // the target of heap based vulnerabilities exploitation attempts.
+    if (UNLIKELY(!GetRandom(reinterpret_cast<void *>(State), sizeof(State),
+                            /*blocking=*/false))) {
+      // On some platforms, early processes like `init` do not have an
+      // initialized random pool (getrandom blocks and /dev/urandom doesn't
+      // exist yet), but we still have to provide them with some degree of
+      // entropy. Not having a secure seed is not as problematic for them, as
+      // they are less likely to be the target of heap based vulnerabilities
+      // exploitation attempts.
       State[0] = NanoTime();
       State[1] = 0;
     }
     fillCache();
   }
   u8 getU8() {
     if (UNLIKELY(isCacheEmpty()))
       fillCache();