Add interceptors for the sysctl(3) API family from NetBSD

[krytarowski]

Summary

Add new interceptors for:

• sysctl
• sysctlbyname
• sysctlgetmibinfo
• sysctlnametomib
• asysctl
• asysctlbyname

Cover the API with a new test file TestCases/NetBSD/sysctl.cc.

[krytarowski]

ping

[vitalybuka]

lib/sanitizer_common/sanitizer_common_interceptors.inc

7301

Why you don't check newp here?

7321

READ from namelenp?
same bellow

test/sanitizer_common/TestCases/NetBSD/sysctl.cc

102

Can you please use different prefixies in printfs so make reading errors easier?

[krytarowski]

• apply fixes from review

[krytarowski]

• add more checks

[vitalybuka]

lib/sanitizer_common/sanitizer_common_interceptors.inc

7289

Here and below

if (oldlenp) {
      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldlenp, sizeof(*oldlenp));
      if (oldp)
          COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldp, *oldlenp);
}

7338

*namelenp * sizeof(*name) ?

7340

this should be as well under "if (!res) {"

7342

if (csz) {
  COMMON_INTERCEPTOR_WRITE_RANGE(ctx, csz, sizeof(*csz));
  if (cname)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cname, *csz);
}

7361

should this be

*namelenp * sizeof(*name)

?

The number of elements in the mib array is given by the location specified by sizep before the call, and that location gives the number of entries copied after a suc- cessful call.

7382

The asysctl() and asysctlbyname() functions are wrappers for sysctl() and
sysctlbyname(). They return memory allocated with malloc(3) and resize
the buffer in a loop until all data fits.

if so we should not intercept asysctl and asysctlbyname

[krytarowski]

lib/sanitizer_common/sanitizer_common_interceptors.inc

7382

They are not macro wrappers, but rather complex standalone code.

https://nxr.netbsd.org/xref/src/lib/libc/gen/asysctl.c

asysctlbyname will break because int name[CTL_MAXNAME]; and u_int namelen will be unknown to sanitizers.

Trying to skip asysctl will be risky too, it might work but I will feel safer with an interceptor.

[krytarowski]

• address comments from review
• enhance tests

[vitalybuka]

LGTM

lib/sanitizer_common/sanitizer_common_interceptors.inc

7327

needs clang-format

7334

{} is used inconsistently

[krytarowski]

lib/sanitizer_common/sanitizer_common_interceptors.inc

7327

This is not a part of my diff.

CC: @devnexen the author

7334

This is not a part of my diff.

CC: @devnexen

lib/sanitizer_common/sanitizer_common_interceptors.inc

if (*mntbufp)
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *mntbufp, cnt * struct_statvfs_sz);
   }
   return cnt;
 }
 #define INIT_GETMNTINFO COMMON_INTERCEPT_FUNCTION(getmntinfo)
 #else
 #define INIT_GETMNTINFO
 #endif
 
 #if SANITIZER_INTERCEPT_MI_VECTOR_HASH
 INTERCEPTOR(void, mi_vector_hash, const void *key, SIZE_T len, u32 seed,
             u32 hashes[3]) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, mi_vector_hash, key, len, seed, hashes);
   if (key)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, key, len);
   REAL(mi_vector_hash)(key, len, seed, hashes);
   if (hashes)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, hashes, sizeof(hashes[0]) * 3);
 }
 #define INIT_MI_VECTOR_HASH COMMON_INTERCEPT_FUNCTION(mi_vector_hash)
 #else
 #define INIT_MI_VECTOR_HASH
 #endif
 
 #if SANITIZER_INTERCEPT_SETVBUF
 INTERCEPTOR(int, setvbuf, __sanitizer_FILE *stream, char *buf, int mode,
   SIZE_T size) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, setvbuf, stream, buf, mode, size);
   int ret = REAL(setvbuf)(stream, buf, mode, size);
   if (buf)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, size);
   if (stream)
       unpoison_file(stream);
   return ret;
 }
 
 INTERCEPTOR(void, setbuf, __sanitizer_FILE *stream, char *buf) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, setbuf, stream, buf);
   REAL(setbuf)(stream, buf);
   if (buf) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer_bufsiz);
   }
   if (stream)
       unpoison_file(stream);
 }
 
 INTERCEPTOR(void, setbuffer, __sanitizer_FILE *stream, char *buf, int mode) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, setbuffer, stream, buf, mode);
   REAL(setbuffer)(stream, buf, mode);
   if (buf) {
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer_bufsiz);
   }
   if (stream)
     unpoison_file(stream);
 }
 
 INTERCEPTOR(void, setlinebuf, __sanitizer_FILE *stream) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, setlinebuf, stream);
   REAL(setlinebuf)(stream);
   if (stream)
     unpoison_file(stream);
 }
 #define INIT_SETVBUF COMMON_INTERCEPT_FUNCTION(setvbuf); \
     COMMON_INTERCEPT_FUNCTION(setbuf); \
     COMMON_INTERCEPT_FUNCTION(setbuffer); \
     COMMON_INTERCEPT_FUNCTION(setlinebuf)
 #else
 #define INIT_SETVBUF
 #endif
 
 #if SANITIZER_INTERCEPT_GETVFSSTAT
 INTERCEPTOR(int, getvfsstat, void *buf, SIZE_T bufsize, int flags) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, getvfsstat, buf, bufsize, flags);
   int ret = REAL(getvfsstat)(buf, bufsize, flags);
   if (buf && ret > 0)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, ret * struct_statvfs_sz);
   return ret;
 }
 #define INIT_GETVFSSTAT COMMON_INTERCEPT_FUNCTION(getvfsstat)
 #else
 #define INIT_GETVFSSTAT
 #endif
 
 #if SANITIZER_INTERCEPT_REGEX
 INTERCEPTOR(int, regcomp, void *preg, const char *pattern, int cflags) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, regcomp, preg, pattern, cflags);
   if (pattern)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, pattern, REAL(strlen)(pattern) + 1);
   int res = REAL(regcomp)(preg, pattern, cflags);
   if (!res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, preg, struct_regex_sz);
   return res;
 }
 INTERCEPTOR(int, regexec, const void *preg, const char *string, SIZE_T nmatch,
             struct __sanitizer_regmatch *pmatch[], int eflags) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, regexec, preg, string, nmatch, pmatch, eflags);
   if (preg)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, preg, struct_regex_sz);
   if (string)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, string, REAL(strlen)(string) + 1);
   int res = REAL(regexec)(preg, string, nmatch, pmatch, eflags);
   if (!res && pmatch)
#define INIT_FTS                                                               \
   COMMON_INTERCEPT_FUNCTION(fts_read);                                         \
   COMMON_INTERCEPT_FUNCTION(fts_children);                                     \
   COMMON_INTERCEPT_FUNCTION(fts_set);                                          \
   COMMON_INTERCEPT_FUNCTION(fts_close);
 #else
 #define INIT_FTS
 #endif
 
+#if SANITIZER_INTERCEPT_SYSCTL
+INTERCEPTOR(int, sysctl, int *name, unsigned int namelen, void *oldp,
+            SIZE_T *oldlenp, void *newp, SIZE_T newlen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctl, name, namelen, oldp, oldlenp, newp,
+                           newlen);
+  if (name)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, name, namelen * sizeof(*name));
+  if (oldlenp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, oldlenp, sizeof(*oldlenp));
+  if (newp && newlen)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, newp, newlen);
+  int res = REAL(sysctl)(name, namelen, oldp, oldlenp, newp, newlen);
+  if (!res) {
+    if (oldlenp) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldlenp, sizeof(*oldlenp));
+      if (oldp)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldp, *oldlenp);
+    }
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sysctlbyname, char *sname, void *oldp, SIZE_T *oldlenp,
+            void *newp, SIZE_T newlen) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctlbyname, sname, oldp, oldlenp, newp,
+                           newlen);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  if (oldlenp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, oldlenp, sizeof(*oldlenp));
+  if (newp && newlen)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, newp, newlen);
+  int res = REAL(sysctlbyname)(sname, oldp, oldlenp, newp, newlen);
+  if (!res) {
+    if (oldlenp) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldlenp, sizeof(*oldlenp));
+      if (oldp)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldp, *oldlenp);
+    }
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sysctlgetmibinfo, char *sname, int *name,
+            unsigned int *namelenp, char *cname, SIZE_T *csz, void **rnode,
+            int v) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctlgetmibinfo, sname, name, namelenp, cname,
+                           csz, rnode, v);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  if (namelenp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, namelenp, sizeof(*namelenp));
+  if (csz)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, csz, sizeof(*csz));
+  // Skip rnode, it's rarely used and not trivial to sanitize
+  // It's also used mostly internally
+  int res = REAL(sysctlgetmibinfo)(sname, name, namelenp, cname, csz, rnode, v);
+  if (!res) {
+    if (namelenp) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, namelenp, sizeof(*namelenp));
+      if (name)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, *namelenp * sizeof(*name));
+    }
+    if (csz) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, csz, sizeof(*csz));
+      if (cname)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cname, *csz);
+    }
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sysctlnametomib, const char *sname, int *name,
+            SIZE_T *namelenp) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctlnametomib, sname, name, namelenp);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  if (namelenp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, namelenp, sizeof(*namelenp));
+  int res = REAL(sysctlnametomib)(sname, name, namelenp);
+  if (!res) {
+    if (namelenp) {
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, namelenp, sizeof(*namelenp));
+      if (name)
+        COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, *namelenp * sizeof(*name));
+    }
+  }
+  return res;
+}
+
+INTERCEPTOR(void *, asysctl, const int *name, SIZE_T namelen, SIZE_T *len) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, asysctl, name, namelen, len);
+  if (name)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, name, sizeof(*name) * namelen);
+  void *res = REAL(asysctl)(name, namelen, len);
+  if (res && len) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, len, sizeof(*len));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, *len);
+  }
+  return res;
+}
+
+INTERCEPTOR(void *, asysctlbyname, const char *sname, SIZE_T *len) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, asysctlbyname, sname, len);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  void *res = REAL(asysctlbyname)(sname, len);
+  if (res && len) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, len, sizeof(*len));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, *len);
+  }
+  return res;
+}
+#define INIT_SYSCTL                                                            \
+  COMMON_INTERCEPT_FUNCTION(sysctl);                                           \
+  COMMON_INTERCEPT_FUNCTION(sysctlbyname);                                     \
+  COMMON_INTERCEPT_FUNCTION(sysctlgetmibinfo);                                 \
+  COMMON_INTERCEPT_FUNCTION(sysctlnametomib);                                  \
+  COMMON_INTERCEPT_FUNCTION(asysctl);                                          \
+  COMMON_INTERCEPT_FUNCTION(asysctlbyname);
+#else
+#define INIT_SYSCTL
+#endif
+
 static void InitializeCommonInterceptors() {
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new((void *)&metadata_mem) MetadataHashMap();
 
   INIT_MMAP;
   INIT_MMAP64;
   INIT_TEXTDOMAIN;
   INIT_STRLEN;
static void InitializeCommonInterceptors() {
   INIT_PROTOENT;
   INIT_NETENT;
   INIT_GETMNTINFO;
   INIT_MI_VECTOR_HASH;
   INIT_SETVBUF;
   INIT_GETVFSSTAT;
   INIT_REGEX;
   INIT_FTS;
+  INIT_SYSCTL;
 
   INIT___PRINTF_CHK;
 }

lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_NETENT SI_NETBSD
 #define SANITIZER_INTERCEPT_SETVBUF (SI_NETBSD || SI_FREEBSD || \
   SI_LINUX || SI_MAC)
 #define SANITIZER_INTERCEPT_GETMNTINFO SI_NETBSD
 #define SANITIZER_INTERCEPT_MI_VECTOR_HASH SI_NETBSD
 #define SANITIZER_INTERCEPT_GETVFSSTAT SI_NETBSD
 #define SANITIZER_INTERCEPT_REGEX SI_NETBSD
 #define SANITIZER_INTERCEPT_FTS SI_NETBSD
+#define SANITIZER_INTERCEPT_SYSCTL SI_NETBSD
 
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

test/sanitizer_common/TestCases/NetBSD/sysctl.cc

+// RUN: %clangxx -O0 -g %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <sys/param.h>
+#include <sys/types.h>
+
+#include <sys/sysctl.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void test_sysctl() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  int mib[] = {CTL_KERN, KERN_OSTYPE};
+  int rv = sysctl(mib, __arraycount(mib), buf, &len, NULL, 0);
+  assert(!rv);
+
+  printf("sysctl: '%s' size: '%zu'\n", buf, len);
+}
+
+void test_sysctlbyname() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  int mib[] = {CTL_KERN, KERN_OSTYPE};
+  int rv = sysctlbyname("kern.ostype", buf, &len, NULL, 0);
+  assert(!rv);
+
+  printf("sysctlbyname: '%s' size: '%zu'\n", buf, len);
+}
+
+void test_sysctlgetmibinfo() {
+  int mib[CTL_MAXNAME];
+  unsigned int mib_len = __arraycount(mib);
+  int rv = sysctlgetmibinfo("kern.ostype", &mib[0], &mib_len, NULL, NULL, NULL,
+                       SYSCTL_VERSION);
+  assert(!rv);
+
+  char buf[100];
+  size_t len = sizeof(buf);
+  rv = sysctl(mib, mib_len, buf, &len, NULL, 0);
+  assert(!rv);
+
+  printf("sysctlgetmibinfo: '%s' size: '%zu'\n", buf, len);
+}
+
+void test_sysctlnametomib() {
+  int mib[CTL_MAXNAME];
+  size_t mib_len = __arraycount(mib);
+  int rv = sysctlnametomib("kern.ostype", &mib[0], &mib_len);
+  assert(!rv);
+
+  char buf[100];
+  size_t len = sizeof(buf);
+  rv = sysctl(mib, mib_len, buf, &len, NULL, 0);
+  assert(!rv);
+
+  printf("sysctlnametomib: '%s' size: '%zu'\n", buf, len);
+}
+
+void test_asysctl() {
+  int mib[] = {CTL_KERN, KERN_OSTYPE};
+  size_t len;
+  char *buf = (char *)asysctl(mib, __arraycount(mib), &len);
+  assert(buf);
+
+  printf("asysctl: '%s' size: '%zu'\n", buf, len);
+
+  free(buf);
+}
+
+void test_asysctlbyname() {
+  size_t len;
+  char *buf = (char *)asysctlbyname("kern.ostype", &len);
+  assert(buf);
+
+  printf("asysctlbyname: '%s' size: '%zu'\n", buf, len);
+
+  free(buf);
+}
+
+int main(void) {
+  printf("sysctl\n");
+
+  test_sysctl();
+  test_sysctlbyname();
+  test_sysctlgetmibinfo();
+  test_sysctlnametomib();
+  test_asysctl();
+  test_asysctlbyname();
+
+  // CHECK: sysctl
+  // CHECK: sysctl: '{{.*}}' size: '{{.*}}'
+  // CHECK: sysctlbyname: '{{.*}}' size: '{{.*}}'
+  // CHECK: sysctlgetmibinfo: '{{.*}}' size: '{{.*}}'
+  // CHECK: sysctlnametomib: '{{.*}}' size: '{{.*}}'
+  // CHECK: asysctl: '{{.*}}' size: '{{.*}}'
+  // CHECK: asysctlbyname: '{{.*}}' size: '{{.*}}'
+
+  return 0;
+}