[sanitizer] Add a function to gather random bytes

[cryptoad]

Summary

AFAICT compiler-rt doesn't have a function that would return 'good' random
bytes to seed a PRNG. Currently, the SizeClassAllocator64 uses addresses
returned by mmap to seed its PRNG, which is not ideal, and
SizeClassAllocator32 doesn't benefit from the entropy offered by its 64-bit
counterpart address space, so right now it has nothing. This function aims at
solving this, allowing to implement good 32-bit chunk randomization. Scudo also
has a function that does this for Cookie purposes, which would go away in a
later CL once this lands.

This function will try the getrandom syscall if available, and fallback to
/dev/urandom if not.

Unfortunately, I do not have a way to implement and test a Mac and Windows
version, so those are unimplemented as of now. Note that kRandomShuffleChunks
is only used on Linux for now.

[zturner]

Assuming sanitizer windows doesn't mind to take a dependency on advapi32.dll (maybe it already has one?) this can be implemented pretty trivially using CryptGenRandom or RtlGenRandom (latter is easier to use).

In any case, shouldn't the unimplemented versions at least do *something*, even if they are not cryptographically strong?

[cryptoad]

In D34412#785712, @zturner wrote:

Assuming sanitizer windows doesn't mind to take a dependency on advapi32.dll (maybe it already has one?) this can be implemented pretty trivially using CryptGenRandom or RtlGenRandom (latter is easier to use).

Looks like this is what is needed indeed. I can't speak for what's going on with Sanitizer Windows though.

In any case, shouldn't the unimplemented versions at least do *something*, even if they are not cryptographically strong?

I am not in disagreement. The reasoning behind leaving them unimplemented is twofold:

• without a dev platform (and experience on the platform) for either, I am not comfortable writing something and debugging through the bots;
• it might lead to false expectation as to what the function is doing.

If that can be done in parts, this one first, then the other platforms by people with experience, that help solve this.
Or if you have an idea that can work for a simple initialization that is bound to work, I'll gladly take it.

[rnk]

In D34412#785712, @zturner wrote:

Assuming sanitizer windows doesn't mind to take a dependency on advapi32.dll (maybe it already has one?) this can be implemented pretty trivially using CryptGenRandom or RtlGenRandom (latter is easier to use).

We can definitely do that. We probably already link against it.

In any case, shouldn't the unimplemented versions at least do *something*, even if they are not cryptographically strong?

The use case for this random data is more ASLR. We can definitely add this API on Windows now, but scudo is only supported on Linux for now, so there isn't much reason to do it or to block this patch for Windows or Mac. I support landing this as is.

[alekseyshl]

I think it's fine to leave them unimplemented on win/mac and let someone with access to the actual platform to add and test the code.

lib/sanitizer_common/sanitizer_common.h

924

Why u8*? Why not customary void*?

lib/sanitizer_common/sanitizer_mac.cc

928

Maybe UNIMPLEMENTED(); is slightly more robust than return false?

lib/sanitizer_common/tests/sanitizer_common_test.cc

316

Please use ARRAY_SIZE(buffer_*) instead of literal 32.

[cryptoad]

Addressing review comments.

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);
+
 }  // 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
 }
 
 uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding) {
   UNREACHABLE("FindAvailableMemoryRange is not available");
   return 0;
 }
 
+bool GetRandom(void *buffer, uptr length) {
+  if (!buffer || !length || length > 256)
+    return false;
+#if defined(__NR_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);
+    int rverrno = 0;
+    if (internal_iserror(res, &rverrno) && rverrno == ENOSYS)
+      atomic_store_relaxed(&skip_getrandom_syscall, 1);
+    else if (res == length)
+      return true;
+  }
+#endif
+  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) {
+  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) {
+  UNIMPLEMENTED();
+}
+
 }  // namespace __sanitizer
 
 #endif  // _WIN32

lib/sanitizer_common/tests/sanitizer_common_test.cc

TEST(SanitizerCommon, InternalScopedString) {
   EXPECT_EQ(0U, str.length());
   EXPECT_STREQ("", str.data());
 
   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));
+  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_NE(internal_memcmp(buffer_1, buffer_2, size), 0);
+    }
+  }
+}
+#endif
+
 }  // namespace __sanitizer