[msan] Add interceptors: crypt, crypt_r.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

9593 ↗

(On Diff #223111)

why you don't check data?

9598 ↗

(On Diff #223111)

REAL(crypt_r?

compiler-rt/test/msan/crypt.cpp

7 ↗

(On Diff #223111)

test in common could be nice as well

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

9593 ↗

(On Diff #223111)

we'd need a new kind of check for it, because it must all be addressable, but only one field of it is required to be initialized. I can add that...

9598 ↗

(On Diff #223111)

good catch

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

9593 ↗

(On Diff #223111)

maybe just write all?

[eugenis]

addressed comments

[uweigand]

The Posix/crypt.cpp test case fails on my system with:

/home/uweigand/llvm/llvm-head/projects/compiler-rt/test/sanitizer_common/TestCases/Posix/crypt.cpp:18:15: error: use of undeclared identifier 'crypt'
    char *p = crypt("abcdef", "$1$");

I believe the test case is missing a

#include <crypt.h>

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

INTERCEPTOR(SSIZE_T, getrandom, void *buf, SIZE_T buflen, unsigned int flags) {
   }
   return n;
 }
 #define INIT_GETRANDOM COMMON_INTERCEPT_FUNCTION(getrandom)
 #else
 #define INIT_GETRANDOM
 #endif
 
+#if SANITIZER_INTERCEPT_CRYPT
+INTERCEPTOR(char *, crypt, char *key, char *salt) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, crypt, key, salt);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, key, internal_strlen(key) + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, salt, internal_strlen(salt) + 1);
+  char *res = REAL(crypt)(key, salt);
+  if (res != nullptr)
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, internal_strlen(res) + 1);
+  return res;
+}
+#define INIT_CRYPT COMMON_INTERCEPT_FUNCTION(crypt);
+#else
+#define INIT_CRYPT
+#endif
+
+#if SANITIZER_INTERCEPT_CRYPT_R
+INTERCEPTOR(char *, crypt_r, char *key, char *salt, void *data) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, crypt_r, key, salt, data);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, key, internal_strlen(key) + 1);
+  COMMON_INTERCEPTOR_READ_RANGE(ctx, salt, internal_strlen(salt) + 1);
+  char *res = REAL(crypt_r)(key, salt, data);
+  if (res != nullptr) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, data,
+                                   __sanitizer::struct_crypt_data_sz);
+    COMMON_INTERCEPTOR_INITIALIZE_RANGE(res, internal_strlen(res) + 1);
+  }
+  return res;
+}
+#define INIT_CRYPT_R COMMON_INTERCEPT_FUNCTION(crypt_r);
+#else
+#define INIT_CRYPT_R
+#endif
+
 static void InitializeCommonInterceptors() {
 #if SI_POSIX
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new ((void *)&metadata_mem) MetadataHashMap();
 #endif
 
   INIT_MMAP;
   INIT_MMAP64;
#endif
   INIT_POPENVE;
   INIT_PCLOSE;
   INIT_FUNOPEN;
   INIT_FUNOPEN2;
   INIT_FDEVNAME;
   INIT_GETUSERSHELL;
   INIT_SL_INIT;
   INIT_GETRANDOM;
+  INIT_CRYPT;
+  INIT_CRYPT_R;
 
   INIT___PRINTF_CHK;
 }

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

 #define SANITIZER_INTERCEPT_PCLOSE SI_POSIX
 #define SANITIZER_INTERCEPT_FUNOPEN (SI_NETBSD || SI_FREEBSD)
 #define SANITIZER_INTERCEPT_FUNOPEN2 SI_NETBSD
 #define SANITIZER_INTERCEPT_GETFSENT (SI_FREEBSD || SI_NETBSD || SI_MAC)
 #define SANITIZER_INTERCEPT_ARC4RANDOM (SI_FREEBSD || SI_NETBSD || SI_MAC)
 #define SANITIZER_INTERCEPT_FDEVNAME SI_FREEBSD
 #define SANITIZER_INTERCEPT_GETUSERSHELL (SI_POSIX && !SI_ANDROID)
 #define SANITIZER_INTERCEPT_SL_INIT (SI_FREEBSD || SI_NETBSD)
+#define SANITIZER_INTERCEPT_CRYPT (SI_POSIX && !SI_ANDROID)
+#define SANITIZER_INTERCEPT_CRYPT_R (SI_LINUX && !SI_ANDROID)
 
 #define SANITIZER_INTERCEPT_GETRANDOM (SI_LINUX && __GLIBC_PREREQ(2, 25))
 #define SANITIZER_INTERCEPT___CXA_ATEXIT SI_NETBSD
 #define SANITIZER_INTERCEPT_ATEXIT SI_NETBSD
 #define SANITIZER_INTERCEPT_PTHREAD_ATFORK SI_NETBSD
 
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

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

 };
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern unsigned struct_msqid_ds_sz;
 extern unsigned struct_mq_attr_sz;
 extern unsigned struct_timex_sz;
 extern unsigned struct_statvfs_sz;
+extern unsigned struct_crypt_data_sz;
 #endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
 
 struct __sanitizer_iovec {
   void *iov_base;
   uptr iov_len;
 };
 
 #if !SANITIZER_ANDROID

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

 #include <linux/if_plip.h>
 #include <linux/lp.h>
 #include <linux/mroute.h>
 #include <linux/mroute6.h>
 #include <linux/scc.h>
 #include <linux/serial.h>
 #include <sys/msg.h>
 #include <sys/ipc.h>
+#include <crypt.h>
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
 #if SANITIZER_ANDROID
 #include <linux/kd.h>
 #include <linux/mtio.h>
 #include <linux/ppp_defs.h>
 #include <linux/if_ppp.h>
 #endif
#elif defined(__arm__) || defined(__i386__) || defined(__mips__) \
   || defined(__powerpc__) || defined(__s390__) || defined(__sparc__)
 #define SIZEOF_STRUCT_USTAT 20
 #else
 #error Unknown size of struct ustat
 #endif
   unsigned struct_ustat_sz = SIZEOF_STRUCT_USTAT;
   unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
   unsigned struct_statvfs64_sz = sizeof(struct statvfs64);
+  unsigned struct_crypt_data_sz = sizeof(struct crypt_data);
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_timex_sz = sizeof(struct timex);
   unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
   unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
   unsigned struct_statvfs_sz = sizeof(struct statvfs);
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID

compiler-rt/trunk/test/sanitizer_common/TestCases/Linux/crypt_r.cpp

+// RUN: %clangxx -O0 -g %s -lcrypt -o %t && %run %t
+
+#include <assert.h>
+#include <unistd.h>
+#include <cstring>
+#include <crypt.h>
+
+#include <sanitizer/msan_interface.h>
+
+int
+main (int argc, char** argv)
+{
+  {
+    crypt_data cd;
+    cd.initialized = 0;
+    char *p = crypt_r("abcdef", "xz", &cd);
+    volatile size_t z = strlen(p);
+  }
+  {
+    crypt_data cd;
+    cd.initialized = 0;
+    char *p = crypt_r("abcdef", "$1$", &cd);
+    volatile size_t z = strlen(p);
+  }
+  {
+    crypt_data cd;
+    cd.initialized = 0;
+    char *p = crypt_r("abcdef", "$5$", &cd);
+    volatile size_t z = strlen(p);
+  }
+  {
+    crypt_data cd;
+    cd.initialized = 0;
+    char *p = crypt_r("abcdef", "$6$", &cd);
+    volatile size_t z = strlen(p);
+  }
+}

compiler-rt/trunk/test/sanitizer_common/TestCases/Posix/crypt.cpp

+// RUN: %clangxx -O0 -g %s -o %t -lcrypt && %run %t
+
+#include <assert.h>
+#include <unistd.h>
+#include <cstring>
+
+int
+main (int argc, char** argv)
+{
+  {
+    char *p = crypt("abcdef", "xz");
+    volatile size_t z = strlen(p);
+  }
+  {
+    char *p = crypt("abcdef", "$1$");
+    volatile size_t z = strlen(p);
+  }
+  {
+    char *p = crypt("abcdef", "$5$");
+    volatile size_t z = strlen(p);
+  }
+  {
+    char *p = crypt("abcdef", "$6$");
+    volatile size_t z = strlen(p);
+  }
+}