[Sanitizers] intercept hexdump on FreeBSD

[vitalybuka]

LGTM but I am not sure what is the rule for stuff we intercept vs expect instrumentation from the user
WDYT? @eugenis

[MaskRay]

hexdump looks like to come from libmba, not a critical component (libc is usually difficult to instrument, but other libraries are not). I think the user should compile libmba with instrumentation instead of adding interceptors to sanitizers (which adds complexity). @dim @emaste
(HWAddressSanitizer is deployed on Android. Its C library bionic is instrumented so that very few interceptors are needed.)

[dim]

In D110471#4073813, @MaskRay wrote:

hexdump looks like to come from libmba, not a critical component (libc is usually difficult to instrument, but other libraries are not). I think the user should compile libmba with instrumentation instead of adding interceptors to sanitizers (which adds complexity). @dim @emaste

It is actually in libutil (see https://www.freebsd.org/cgi/man.cgi?query=hexdump&sektion=3), but it might be somewhat tricky for end users to instrument this system library.

(HWAddressSanitizer is deployed on Android. Its C library bionic is instrumented so that very few interceptors are needed.)

Does that result in overhead if sanitization is *not* asked for?

[MaskRay]

In D110471#4073833, @dim wrote:

In D110471#4073813, @MaskRay wrote:

hexdump looks like to come from libmba, not a critical component (libc is usually difficult to instrument, but other libraries are not). I think the user should compile libmba with instrumentation instead of adding interceptors to sanitizers (which adds complexity). @dim @emaste

It is actually in libutil (see https://www.freebsd.org/cgi/man.cgi?query=hexdump&sektion=3), but it might be somewhat tricky for end users to instrument this system library.

OK, it's fine then. We just need to kind in mind that if there are too many functions, adding interceptors does not scale.

(HWAddressSanitizer is deployed on Android. Its C library bionic is instrumented so that very few interceptors are needed.)

Does that result in overhead if sanitization is *not* asked for?

The idea is to use a sanitizer-instrumented .a/.so (like multilib) only when requested by -fsanitize=....

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

COMMON_INTERCEPTOR_WRITE_RANGE(ctx, utsname,
                                    __sanitizer::struct_utsname_sz);
   return res;
 }
 #define INIT___XUNAME COMMON_INTERCEPT_FUNCTION(__xuname)
 #else
 #define INIT___XUNAME
 #endif
 
+#if SANITIZER_INTERCEPT_HEXDUMP
+INTERCEPTOR(void, hexdump, const void *ptr, int length, const char *header, int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, hexdump, ptr, length, header, flags);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, length);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, header, internal_strlen(header) + 1);
+  REAL(hexdump)(ptr, length, header, flags);
+}
+
+#define INIT_HEXDUMP COMMON_INTERCEPT_FUNCTION(hexdump);
+#else
+#define INIT_HEXDUMP
+#endif
+
 #include "sanitizer_common_interceptors_netbsd_compat.inc"
 
 static void InitializeCommonInterceptors() {
 #if SI_POSIX
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new ((void *)&metadata_mem) MetadataHashMap();
 #endif
 
#endif
   INIT_GETENTROPY;
   INIT_QSORT;
   INIT_QSORT_R;
   INIT_BSEARCH;
   INIT_SIGALTSTACK;
   INIT_PROCCTL
   INIT_UNAME;
   INIT___XUNAME;
+  INIT_HEXDUMP;
 
   INIT___PRINTF_CHK;
 }

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 // sigaltstack on i386 macOS cannot be intercepted due to setjmp()
 // calling it and assuming that it does not clobber registers.
 #define SANITIZER_INTERCEPT_SIGALTSTACK \
   (SI_POSIX && !(SANITIZER_APPLE && SANITIZER_I386))
 #define SANITIZER_INTERCEPT_UNAME (SI_POSIX && !SI_FREEBSD)
 #define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD
 #define SANITIZER_INTERCEPT_FLOPEN SI_FREEBSD
 #define SANITIZER_INTERCEPT_PROCCTL SI_FREEBSD
+#define SANITIZER_INTERCEPT_HEXDUMP SI_FREEBSD
 
 // This macro gives a way for downstream users to override the above
 // interceptor macros irrespective of the platform they are on. They have
 // to do two things:
 // 1. Build compiler-rt with -DSANITIZER_OVERRIDE_INTERCEPTORS.
 // 2. Provide a header file named sanitizer_intercept_overriders.h in the
 //    include path for their compiler-rt build.
 // An example of an overrider for strlen interceptor that one can list in

compiler-rt/test/sanitizer_common/TestCases/FreeBSD/hexdump.cc

+// RUN: %clangxx -O0 -g %s -o %t -lutil && %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <libutil.h>
+
+int main(void) {
+  printf("hexdump");
+  char *line;
+  size_t lineno = 0, len;
+  const char *delim = "\\\\#";
+  FILE *fp = fopen("/etc/fstab", "r");
+  assert(fp);
+  line = fparseln(fp, &len, &lineno, delim, 0);
+  hexdump(line, len, nullptr, 0);
+  free(line);
+  fclose(fp);
+  assert(lineno != 0);
+  assert(len > 0);
+
+  return 0;
+}