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

7283

Why you don't check newp here?

7303

READ from namelenp?
same bellow

test/sanitizer_common/TestCases/NetBSD/sysctl.cc

101

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

7271

Here and below

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

7320

*namelenp * sizeof(*name) ?

7322

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

7324

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

7343

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.

7364

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

7364

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

7254–7374

needs clang-format

7254–7374

{} is used inconsistently

[krytarowski]

lib/sanitizer_common/sanitizer_common_interceptors.inc

7254–7374

This is not a part of my diff.

CC: @devnexen

7254–7374

This is not a part of my diff.

CC: @devnexen the author

lib/sanitizer_common/sanitizer_common_interceptors.inc

 }
 #define INIT_NETENT \
   COMMON_INTERCEPT_FUNCTION(getnetent); \
   COMMON_INTERCEPT_FUNCTION(getnetbyname); \
   COMMON_INTERCEPT_FUNCTION(getnetbyaddr)
 #else
 #define INIT_NETENT
 #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;
+  int res;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctl, name, namelen, oldp, oldlenp, newp,
+                           newlen);
+  if (name)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, name, namelen * sizeof(*name));
+  if (newp)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, newp, newlen);
+  res = REAL(sysctl)(name, namelen, oldp, oldlenp, newp, newlen);
+  if (!res) {
+    if (oldlenp)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldlenp, sizeof(*oldlenp));
+    if (oldp && oldlenp)
+      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;
+  int res;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctlbyname, sname, oldp, oldlenp, newp,
+                           newlen);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  res = REAL(sysctlbyname)(sname, oldp, oldlenp, newp, newlen);
+  if (!res) {
+    if (oldlenp)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldlenp, sizeof(*oldlenp));
+    if (oldp && oldlenp)
+      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;
+  int res;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctlgetmibinfo, sname, name, namelenp, cname,
+                           csz, rnode, v);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  // Skip rnode, it's rarely used and not trivial to sanitize
+  // It's also used mostly internally
+  res = REAL(sysctlgetmibinfo)(sname, name, namelenp, cname, csz, rnode, v);
+  if (!res) {
+    if (namelenp)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, namelenp, sizeof(*namelenp));
+    if (name && namelenp)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, *namelenp);
+  }
+  if (cname && csz) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, csz, sizeof(*csz));
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, cname, *csz);
+  }
+  return res;
+}
+
+INTERCEPTOR(int, sysctlnametomib, const char *sname, int *name,
+            SIZE_T *namelenp) {
+  void *ctx;
+  int res;
+  COMMON_INTERCEPTOR_ENTER(ctx, sysctlnametomib, sname, name, namelenp);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  res = REAL(sysctlnametomib)(sname, name, namelenp);
+  if (!res) {
+    if (namelenp)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, namelenp, sizeof(*namelenp));
+    if (name && namelenp)
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, *namelenp);
+  }
+  return res;
+}
+
+INTERCEPTOR(void *, asysctl, const int *name, SIZE_T namelen, SIZE_T *len) {
+  void *ctx;
+  void *res;
+  COMMON_INTERCEPTOR_ENTER(ctx, asysctl, name, namelen, len);
+  if (name)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, name, sizeof(*name) * namelen);
+  res = REAL(asysctl)(name, namelen, len);
+  if (len)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, len, sizeof(*len));
+  if (res && len)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, *len);
+  return res;
+}
+
+INTERCEPTOR(void *, asysctlbyname, const char *sname, SIZE_T *len) {
+  void *ctx;
+  void *res;
+  COMMON_INTERCEPTOR_ENTER(ctx, asysctlbyname, sname, len);
+  if (sname)
+    COMMON_INTERCEPTOR_READ_RANGE(ctx, sname, REAL(strlen)(sname) + 1);
+  res = REAL(asysctlbyname)(sname, len);
+  if (len)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, len, sizeof(*len));
+  if (res && 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;
   INIT_STRNLEN;
static void InitializeCommonInterceptors() {
   INIT_STRLCPY;
   INIT_DEVNAME;
   INIT_DEVNAME_R;
   INIT_FGETLN;
   INIT_STRMODE;
   INIT_TTYENT;
   INIT_PROTOENT;
   INIT_NETENT;
+  INIT_SYSCTL;
 
   INIT___PRINTF_CHK;
 }

lib/sanitizer_common/sanitizer_platform_interceptors.h

 
 #define SANITIZER_INTERCEPT_DEVNAME (SI_NETBSD || SI_OPENBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_DEVNAME_R (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_FGETLN (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_STRMODE (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_TTYENT SI_NETBSD
 #define SANITIZER_INTERCEPT_PROTOENT SI_NETBSD
 #define SANITIZER_INTERCEPT_NETENT 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 <stdio.h>
+#include <stdlib.h>
+
+void test_sysctl() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  int mib[] = {CTL_KERN, KERN_OSTYPE};
+
+  if (sysctl(mib, __arraycount(mib), buf, &len, NULL, 0) == -1)
+    abort();
+
+  printf("OSTYPE: '%s'\n", buf);
+}
+
+void test_sysctlbyname() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  int mib[] = {CTL_KERN, KERN_OSTYPE};
+
+  if (sysctlbyname("kern.ostype", buf, &len, NULL, 0) == -1)
+    abort();
+
+  printf("OSTYPE: '%s'\n", buf);
+}
+
+void test_sysctlgetmibinfo() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  unsigned int mib_len;
+  int mib[CTL_MAXNAME];
+
+  if (sysctlgetmibinfo("kern.ostype", &mib[0], &mib_len, NULL, NULL, NULL,
+                       SYSCTL_VERSION))
+    abort();
+
+  if (sysctl(mib, mib_len, buf, &len, NULL, 0) == -1)
+    abort();
+
+  printf("OSTYPE: '%s'\n", buf);
+}
+
+void test_sysctlnametomib() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  size_t mib_len;
+  int mib[CTL_MAXNAME];
+
+  mib_len = __arraycount(mib);
+  if (sysctlnametomib("kern.ostype", &mib[0], &mib_len) == -1)
+    abort();
+
+  if (sysctl(mib, mib_len, buf, &len, NULL, 0) == -1)
+    abort();
+
+  printf("OSTYPE: '%s'\n", buf);
+}
+
+void test_asysctl() {
+  char *buf;
+  size_t len;
+  int mib[] = {CTL_KERN, KERN_OSTYPE};
+
+  if ((buf = (char *)asysctl(mib, __arraycount(mib), &len)) == NULL)
+    abort();
+
+  printf("OSTYPE: '%s'\n", buf);
+
+  free(buf);
+}
+
+void test_asysctlbyname() {
+  char *buf;
+  size_t len;
+
+  if ((buf = (char *)asysctlbyname("kern.ostype", &len)) == NULL)
+    abort();
+
+  printf("OSTYPE: '%s'\n", buf);
+
+  free(buf);
+}
+
+int main(void) {
+  printf("sysctl\n");
+
+  test_sysctl();
+  test_sysctlbyname();
+  test_sysctlgetmibinfo();
+  test_sysctlnametomib();
+  test_asysctl();
+  test_asysctlbyname();
+
+  // CHECK: sysctl
+  // CHECK: OSTYPE: '{{.*}}'
+  // CHECK: OSTYPE: '{{.*}}'
+  // CHECK: OSTYPE: '{{.*}}'
+  // CHECK: OSTYPE: '{{.*}}'
+  // CHECK: OSTYPE: '{{.*}}'
+  // CHECK: OSTYPE: '{{.*}}'
+
+  return 0;
+}