[Sanitizers] Intercept snprintf_l() on FreeBSD

[kutuzov.viktor.84]

Summary

In contrast to Linux, FreeBSD does not omit the *printf_l() functions so we have to intercept them. Particularly, libcxx leverage snprintf_l() for verbalization of numeric values. Since gtest use the standard i/o streams, we get mass false positives on Msan unit tests.

[emaste]

lib/sanitizer_common/sanitizer_common_interceptors.inc

906–908 ↗

(On Diff #16647)

Just to confirm, the issue reported in this comment is not directly tied to the new *printf_l functionality?

[eugenis]

Please add a test, either in test/asan or in lib/asan/tests/asan_test.cc

lib/sanitizer_common/sanitizer_common_interceptors.inc

892 ↗

(On Diff #16647)

Why not use VSNPRINTF_INTERCEPTOR_IMPL directly?

Also, what about all the other *printf*_l functions? They do not have to be done in 1 patch, but you'll probably run into issues with them at some point, too.

906–908 ↗

(On Diff #16647)

It's not.

[kutuzov.viktor.84]

Rewritten with VSNPRINTF_INTERCEPTOR_IMPL.

[kutuzov.viktor.84]

Also, what about all the other *printf*_l functions? They do not have to be done in 1 patch, but you'll probably run into issues with them at some point, too.

Yes, I've added them to my TODO and will provide another patch for the rest of the funcs some time later.

Now it seems I have to add a test case to this patch...

[kutuzov.viktor.84]

A test added.

[eugenis]

lib/asan/tests/asan_test.cc

1289 ↗

(On Diff #17442)

Capital W after an underscore looks unusual.

1298 ↗

(On Diff #17442)

This does not really test much (does it fail before this patch?).
See test/asan/TestCases/printf-*.c for inspiration. No need to repeat all 5 of them for the _l variant, but please add something that verifies that the whole prinf sanitizing machinery is applied in this case.

[kutuzov.viktor.84]

Updated. Thanks, Evgeniy.

[eugenis]

LGTM

compiler-rt/trunk/lib/asan/tests/asan_test.cc

EXPECT_DEATH(
       "AddressSanitizer: stack-buffer-.*flow");
   EXPECT_DEATH(
       pthread_getschedparam(pthread_self(), Ident(&policy) - 1, &param),
       "AddressSanitizer: stack-buffer-.*flow");
   int res = pthread_getschedparam(pthread_self(), &policy, &param);
   ASSERT_EQ(0, res);
 }
 #endif
+
+#if SANITIZER_TEST_HAS_PRINTF_L
+static int vsnprintf_l_wrapper(char *s, size_t n,
+                               locale_t l, const char *format, ...) {
+  va_list va;
+  va_start(va, format);
+  int res = vsnprintf_l(s, n , l, format, va);
+  va_end(va);
+  return res;
+}
+
+TEST(AddressSanitizer, snprintf_l) {
+  char buff[5];
+  // Check that snprintf_l() works fine with Asan.
+  int res = snprintf_l(buff, 5,
+                       _LIBCPP_GET_C_LOCALE, "%s", "snprintf_l()");
+  EXPECT_EQ(12, res);
+  // Check that vsnprintf_l() works fine with Asan.
+  res = vsnprintf_l_wrapper(buff, 5,
+                            _LIBCPP_GET_C_LOCALE, "%s", "vsnprintf_l()");
+  EXPECT_EQ(13, res);
+
+  EXPECT_DEATH(snprintf_l(buff, 10,
+                          _LIBCPP_GET_C_LOCALE, "%s", "snprintf_l()"),
+                "AddressSanitizer: stack-buffer-overflow");
+  EXPECT_DEATH(vsnprintf_l_wrapper(buff, 10,
+                                  _LIBCPP_GET_C_LOCALE, "%s", "vsnprintf_l()"),
+                "AddressSanitizer: stack-buffer-overflow");
+}
+#endif

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common_interceptors.inc

 INTERCEPTOR(int, vfprintf, __sanitizer_FILE *stream, const char *format,
             va_list ap)
 VPRINTF_INTERCEPTOR_IMPL(vfprintf, stream, format, ap)
 
 INTERCEPTOR(int, vsnprintf, char *str, SIZE_T size, const char *format,
             va_list ap)
 VSNPRINTF_INTERCEPTOR_IMPL(vsnprintf, str, size, format, ap)
 
+#if SANITIZER_INTERCEPT_PRINTF_L
+INTERCEPTOR(int, vsnprintf_l, char *str, SIZE_T size, void *loc,
+            const char *format, va_list ap)
+VSNPRINTF_INTERCEPTOR_IMPL(vsnprintf_l, str, size, loc, format, ap)
+
+INTERCEPTOR(int, snprintf_l, char *str, SIZE_T size, void *loc,
+            const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(snprintf_l, vsnprintf_l, str, size, loc, format)
+#endif  // SANITIZER_INTERCEPT_PRINTF_L
+
 INTERCEPTOR(int, vsprintf, char *str, const char *format, va_list ap)
 VSPRINTF_INTERCEPTOR_IMPL(vsprintf, str, format, ap)
 
 INTERCEPTOR(int, vasprintf, char **strp, const char *format, va_list ap)
 VASPRINTF_INTERCEPTOR_IMPL(vasprintf, strp, format, ap)
 
 #if SANITIZER_INTERCEPT_ISOC99_PRINTF
 INTERCEPTOR(int, __isoc99_vprintf, const char *format, va_list ap)
#define INIT_PRINTF                     \
   COMMON_INTERCEPT_FUNCTION(vsprintf);  \
   COMMON_INTERCEPT_FUNCTION(vsnprintf); \
   COMMON_INTERCEPT_FUNCTION(vasprintf); \
   COMMON_INTERCEPT_FUNCTION(vfprintf);
 #else
 #define INIT_PRINTF
 #endif
 
+#if SANITIZER_INTERCEPT_PRINTF_L
+#define INIT_PRINTF_L                     \
+  COMMON_INTERCEPT_FUNCTION(snprintf_l);  \
+  COMMON_INTERCEPT_FUNCTION(vsnprintf_l);
+#else
+#define INIT_PRINTF_L
+#endif
+
 #if SANITIZER_INTERCEPT_ISOC99_PRINTF
 #define INIT_ISOC99_PRINTF                       \
   COMMON_INTERCEPT_FUNCTION(__isoc99_printf);    \
   COMMON_INTERCEPT_FUNCTION(__isoc99_sprintf);   \
   COMMON_INTERCEPT_FUNCTION(__isoc99_snprintf);  \
   COMMON_INTERCEPT_FUNCTION(__isoc99_fprintf);   \
   COMMON_INTERCEPT_FUNCTION(__isoc99_vprintf);   \
   COMMON_INTERCEPT_FUNCTION(__isoc99_vsprintf);  \
static void InitializeCommonInterceptors() {
   INIT_PWRITEV;
   INIT_PWRITEV64;
   INIT_PRCTL;
   INIT_LOCALTIME_AND_FRIENDS;
   INIT_STRPTIME;
   INIT_SCANF;
   INIT_ISOC99_SCANF;
   INIT_PRINTF;
+  INIT_PRINTF_L;
   INIT_ISOC99_PRINTF;
   INIT_FREXP;
   INIT_FREXPF_FREXPL;
   INIT_GETPWNAM_AND_FRIENDS;
   INIT_GETPWNAM_R_AND_FRIENDS;
   INIT_GETPWENT;
   INIT_FGETPWENT;
   INIT_GETPWENT_R;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_STRPTIME SI_NOT_WINDOWS
 
 #define SANITIZER_INTERCEPT_SCANF SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_ISOC99_SCANF SI_LINUX_NOT_ANDROID
 
 #ifndef SANITIZER_INTERCEPT_PRINTF
 # define SANITIZER_INTERCEPT_PRINTF SI_NOT_WINDOWS
+# define SANITIZER_INTERCEPT_PRINTF_L SI_FREEBSD
 # define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_LINUX_NOT_ANDROID
 #endif
 
 #define SANITIZER_INTERCEPT_FREXP 1
 #define SANITIZER_INTERCEPT_FREXPF_FREXPL SI_NOT_WINDOWS
 
 #define SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS \

compiler-rt/trunk/lib/sanitizer_common/tests/sanitizer_test_utils.h

 #endif
 
 #if !defined(__APPLE__)
 # define SANITIZER_TEST_HAS_STRNLEN 1
 #else
 # define SANITIZER_TEST_HAS_STRNLEN 0
 #endif
 
+#if defined(__FreeBSD__)
+# define SANITIZER_TEST_HAS_PRINTF_L 1
+#else
+# define SANITIZER_TEST_HAS_PRINTF_L 0
+#endif
+
 #endif  // SANITIZER_TEST_UTILS_H