diff options
author | Peter Collingbourne <peter@pcc.me.uk> | 2013-11-21 23:18:03 +0000 |
---|---|---|
committer | Peter Collingbourne <peter@pcc.me.uk> | 2013-11-21 23:18:03 +0000 |
commit | 1b46c2bc1fb30c1882cfbc1c20be005ce18578f1 (patch) | |
tree | 0f43eeebaba0f3fb8734765a1345a56362dffe45 /lib/dfsan | |
parent | 0678d239f1cff13c4ddd07a51e64e4cc57668742 (diff) |
Implement a bunch of custom glibc wrappers & corresponding tests.
- Introduce several new custom glibc wrappers
- Implement some of the not yet implemented wrappers
- Refactor and extend the tests
- Add script to make sure all declare custom glibc wrappers are implemented & tested.
Patch by Lorenzo Martignoni!
Differential Revision: http://llvm-reviews.chandlerc.com/D2234
git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@195381 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/dfsan')
-rw-r--r-- | lib/dfsan/dfsan_custom.cc | 353 | ||||
-rw-r--r-- | lib/dfsan/done_abilist.txt | 36 | ||||
-rw-r--r-- | lib/dfsan/lit_tests/custom.c | 618 | ||||
-rwxr-xr-x | lib/dfsan/scripts/check_custom_wrappers.sh | 50 |
4 files changed, 969 insertions, 88 deletions
diff --git a/lib/dfsan/dfsan_custom.cc b/lib/dfsan/dfsan_custom.cc index 6a132db06..b654d2f15 100644 --- a/lib/dfsan/dfsan_custom.cc +++ b/lib/dfsan/dfsan_custom.cc @@ -11,26 +11,35 @@ // // This file defines the custom functions listed in done_abilist.txt. //===----------------------------------------------------------------------===// + #include "sanitizer_common/sanitizer_internal_defs.h" #include "sanitizer_common/sanitizer_linux.h" #include "dfsan/dfsan.h" +#include <arpa/inet.h> #include <ctype.h> #include <dlfcn.h> #include <link.h> +#include <poll.h> #include <pthread.h> +#include <pwd.h> +#include <sched.h> +#include <signal.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> -#include <sys/types.h> +#include <sys/resource.h> +#include <sys/select.h> #include <sys/stat.h> +#include <sys/time.h> +#include <sys/types.h> #include <time.h> #include <unistd.h> using namespace __dfsan; extern "C" { - SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_stat(const char *path, struct stat *buf, dfsan_label path_label, dfsan_label buf_label, dfsan_label *ret_label) { @@ -338,4 +347,344 @@ SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_dl_iterate_phdr( return dl_iterate_phdr(dl_iterate_phdr_cb, &dipi); } +SANITIZER_INTERFACE_ATTRIBUTE +char *__dfsw_ctime_r(const time_t *timep, char *buf, dfsan_label timep_label, + dfsan_label buf_label, dfsan_label *ret_label) { + char *ret = ctime_r(timep, buf); + if (ret) { + dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), buf, + strlen(buf) + 1); + *ret_label = buf_label; + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +char *__dfsw_fgets(char *s, int size, FILE *stream, dfsan_label s_label, + dfsan_label size_label, dfsan_label stream_label, + dfsan_label *ret_label) { + char *ret = fgets(s, size, stream); + if (ret) { + dfsan_set_label(0, ret, strlen(ret) + 1); + *ret_label = s_label; + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +char *__dfsw_getcwd(char *buf, size_t size, dfsan_label buf_label, + dfsan_label size_label, dfsan_label *ret_label) { + char *ret = getcwd(buf, size); + if (ret) { + dfsan_set_label(0, ret, strlen(ret) + 1); + *ret_label = buf_label; + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +char *__dfsw_get_current_dir_name(dfsan_label *ret_label) { + char *ret = get_current_dir_name(); + if (ret) { + dfsan_set_label(0, ret, strlen(ret) + 1); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_gethostname(char *name, size_t len, dfsan_label name_label, + dfsan_label len_label, dfsan_label *ret_label) { + int ret = gethostname(name, len); + if (ret == 0) { + dfsan_set_label(0, name, strlen(name) + 1); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_getrlimit(int resource, struct rlimit *rlim, + dfsan_label resource_label, dfsan_label rlim_label, + dfsan_label *ret_label) { + int ret = getrlimit(resource, rlim); + if (ret == 0) { + dfsan_set_label(0, rlim, sizeof(struct rlimit)); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_getrusage(int who, struct rusage *usage, dfsan_label who_label, + dfsan_label usage_label, dfsan_label *ret_label) { + int ret = getrusage(who, usage); + if (ret == 0) { + dfsan_set_label(0, usage, sizeof(struct rusage)); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +char *__dfsw_strcpy(char *dest, const char *src, dfsan_label dst_label, + dfsan_label src_label, dfsan_label *ret_label) { + char *ret = strcpy(dest, src); + if (ret) { + internal_memcpy(shadow_for(dest), shadow_for(src), + sizeof(dfsan_label) * (strlen(src) + 1)); + } + *ret_label = dst_label; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +long int __dfsw_strtol(const char *nptr, char **endptr, int base, + dfsan_label nptr_label, dfsan_label endptr_label, + dfsan_label base_label, dfsan_label *ret_label) { + char *tmp_endptr; + long int ret = strtol(nptr, &tmp_endptr, base); + if (endptr) { + *endptr = tmp_endptr; + } + if (tmp_endptr > nptr) { + // If *tmp_endptr is '\0' include its label as well. + *ret_label = dfsan_union( + base_label, + dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +double __dfsw_strtod(const char *nptr, char **endptr, + dfsan_label nptr_label, dfsan_label endptr_label, + dfsan_label *ret_label) { + char *tmp_endptr; + double ret = strtod(nptr, &tmp_endptr); + if (endptr) { + *endptr = tmp_endptr; + } + if (tmp_endptr > nptr) { + // If *tmp_endptr is '\0' include its label as well. + *ret_label = dfsan_read_label( + nptr, + tmp_endptr - nptr + (*tmp_endptr ? 0 : 1)); + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +long long int __dfsw_strtoll(const char *nptr, char **endptr, int base, + dfsan_label nptr_label, dfsan_label endptr_label, + dfsan_label base_label, dfsan_label *ret_label) { + char *tmp_endptr; + long long int ret = strtoll(nptr, &tmp_endptr, base); + if (endptr) { + *endptr = tmp_endptr; + } + if (tmp_endptr > nptr) { + // If *tmp_endptr is '\0' include its label as well. + *ret_label = dfsan_union( + base_label, + dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +unsigned long int __dfsw_strtoul(const char *nptr, char **endptr, int base, + dfsan_label nptr_label, dfsan_label endptr_label, + dfsan_label base_label, dfsan_label *ret_label) { + char *tmp_endptr; + unsigned long int ret = strtoul(nptr, &tmp_endptr, base); + if (endptr) { + *endptr = tmp_endptr; + } + if (tmp_endptr > nptr) { + // If *tmp_endptr is '\0' include its label as well. + *ret_label = dfsan_union( + base_label, + dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +long long unsigned int __dfsw_strtoull(const char *nptr, char **endptr, + dfsan_label nptr_label, + int base, dfsan_label endptr_label, + dfsan_label base_label, + dfsan_label *ret_label) { + char *tmp_endptr; + long long unsigned int ret = strtoull(nptr, &tmp_endptr, base); + if (endptr) { + *endptr = tmp_endptr; + } + if (tmp_endptr > nptr) { + // If *tmp_endptr is '\0' include its label as well. + *ret_label = dfsan_union( + base_label, + dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +time_t __dfsw_time(time_t *t, dfsan_label t_label, dfsan_label *ret_label) { + time_t ret = time(t); + if (ret != (time_t) -1 && t) { + dfsan_set_label(0, t, sizeof(time_t)); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_inet_pton(int af, const char *src, void *dst, dfsan_label af_label, + dfsan_label src_label, dfsan_label dst_label, + dfsan_label *ret_label) { + int ret = inet_pton(af, src, dst); + if (ret == 1) { + dfsan_set_label(dfsan_read_label(src, strlen(src) + 1), dst, + af == AF_INET ? sizeof(struct in_addr) : sizeof(in6_addr)); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +struct tm *__dfsw_localtime_r(const time_t *timep, struct tm *result, + dfsan_label timep_label, dfsan_label result_label, + dfsan_label *ret_label) { + struct tm *ret = localtime_r(timep, result); + if (ret) { + dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), result, + sizeof(struct tm)); + *ret_label = result_label; + } else { + *ret_label = 0; + } + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_getpwuid_r(id_t uid, struct passwd *pwd, + char *buf, size_t buflen, struct passwd **result, + dfsan_label uid_label, dfsan_label pwd_label, + dfsan_label buf_label, dfsan_label buflen_label, + dfsan_label result_label, dfsan_label *ret_label) { + // Store the data in pwd, the strings referenced from pwd in buf, and the + // address of pwd in *result. On failure, NULL is stored in *result. + int ret = getpwuid_r(uid, pwd, buf, buflen, result); + if (ret == 0) { + dfsan_set_label(0, pwd, sizeof(struct passwd)); + dfsan_set_label(0, buf, strlen(buf) + 1); + } + *ret_label = 0; + dfsan_set_label(0, result, sizeof(struct passwd*)); + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_poll(struct pollfd *fds, nfds_t nfds, int timeout, + dfsan_label dfs_label, dfsan_label nfds_label, + dfsan_label timeout_label, dfsan_label *ret_label) { + int ret = poll(fds, nfds, timeout); + if (ret >= 0) { + for (; nfds > 0; --nfds) { + dfsan_set_label(0, &fds[nfds - 1].revents, sizeof(fds[nfds - 1].revents)); + } + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_select(int nfds, fd_set *readfds, fd_set *writefds, + fd_set *exceptfds, struct timeval *timeout, + dfsan_label nfds_label, dfsan_label readfds_label, + dfsan_label writefds_label, dfsan_label exceptfds_label, + dfsan_label timeout_label, dfsan_label *ret_label) { + int ret = select(nfds, readfds, writefds, exceptfds, timeout); + // Clear everything (also on error) since their content is either set or + // undefined. + if (readfds) { + dfsan_set_label(0, readfds, sizeof(fd_set)); + } + if (writefds) { + dfsan_set_label(0, writefds, sizeof(fd_set)); + } + if (exceptfds) { + dfsan_set_label(0, exceptfds, sizeof(fd_set)); + } + dfsan_set_label(0, timeout, sizeof(struct timeval)); + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask, + dfsan_label pid_label, + dfsan_label cpusetsize_label, + dfsan_label mask_label, dfsan_label *ret_label) { + int ret = sched_getaffinity(pid, cpusetsize, mask); + if (ret == 0) { + dfsan_set_label(0, mask, cpusetsize); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_sigemptyset(sigset_t *set, dfsan_label set_label, + dfsan_label *ret_label) { + int ret = sigemptyset(set); + dfsan_set_label(0, set, sizeof(sigset_t)); + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_sigaction(int signum, const struct sigaction *act, + struct sigaction *oldact, dfsan_label signum_label, + dfsan_label act_label, dfsan_label oldact_label, + dfsan_label *ret_label) { + int ret = sigaction(signum, act, oldact); + if (oldact) { + dfsan_set_label(0, oldact, sizeof(struct sigaction)); + } + *ret_label = 0; + return ret; +} + +SANITIZER_INTERFACE_ATTRIBUTE +int __dfsw_gettimeofday(struct timeval *tv, struct timezone *tz, + dfsan_label tv_label, dfsan_label tz_label, + dfsan_label *ret_label) { + int ret = gettimeofday(tv, tz); + if (tv) { + dfsan_set_label(0, tv, sizeof(struct timeval)); + } + if (tz) { + dfsan_set_label(0, tz, sizeof(struct timezone)); + } + *ret_label = 0; + return ret; +} } diff --git a/lib/dfsan/done_abilist.txt b/lib/dfsan/done_abilist.txt index 52e0628aa..54b3935ae 100644 --- a/lib/dfsan/done_abilist.txt +++ b/lib/dfsan/done_abilist.txt @@ -103,23 +103,41 @@ fun:strerror=discard fun:syscall=discard fun:uselocale=discard fun:write=discard +fun:dlclose=discard +fun:__assert_fail=discard # Functions that produce output does not depend on the input (need to zero the # shadow manually). fun:calloc=custom fun:clock_gettime=custom fun:dlopen=custom +fun:fgets=custom fun:fstat=custom +fun:getcwd=custom +fun:get_current_dir_name=custom +fun:gethostname=custom +fun:getrlimit=custom +fun:getrusage=custom fun:pread=custom fun:read=custom fun:stat=custom +fun:time=custom # Functions that produce an output that depend on the input (propagate the # shadow manually). +fun:ctime_r=custom +fun:inet_pton=custom +fun:localtime_r=custom fun:memcpy=custom fun:memset=custom +fun:strcpy=custom fun:strdup=custom fun:strncpy=custom +fun:strtod=custom +fun:strtol=custom +fun:strtoll=custom +fun:strtoul=custom +fun:strtoull=custom # Functions that produce an output that is computed from the input, but is not # necessarily data dependent. @@ -134,21 +152,19 @@ fun:strncmp=custom # Functions that take a callback (wrap the callback manually). fun:dl_iterate_phdr=custom +fun:getpwuid_r=custom +fun:poll=custom +fun:sched_getaffinity=custom +fun:select=custom +fun:sigemptyset=custom +fun:sigaction=custom +fun:gettimeofday=custom + # TODO: custom fun:snprintf=discard fun:vsnprintf=discard fun:asprintf=discard fun:qsort=discard -fun:strtoll=discard -fun:strtoull=discard -fun:sigemptyset=discard -fun:sigaction=discard -fun:gettimeofday=discard -fun:get_current_dir_name=discard -fun:getpwuid_r=discard -fun:poll=discard -fun:sched_getaffinity=discard -fun:select=discard ############################################################################### # pthread diff --git a/lib/dfsan/lit_tests/custom.c b/lib/dfsan/lit_tests/custom.c index c9fa93561..dd6d580a0 100644 --- a/lib/dfsan/lit_tests/custom.c +++ b/lib/dfsan/lit_tests/custom.c @@ -1,154 +1,620 @@ // RUN: %clang_dfsan -m64 %s -o %t && %t // RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %t -// Tests custom implementations of various libc functions. +// Tests custom implementations of various glibc functions. #define _GNU_SOURCE #include <sanitizer/dfsan_interface.h> + +#include <arpa/inet.h> #include <assert.h> +#include <fcntl.h> #include <link.h> +#include <poll.h> #include <pthread.h> -#include <string.h> +#include <pwd.h> +#include <sched.h> +#include <signal.h> +#include <stdio.h> #include <stdlib.h> -#include <sys/types.h> +#include <string.h> +#include <sys/select.h> +#include <sys/resource.h> #include <sys/stat.h> -#include <fcntl.h> +#include <sys/time.h> +#include <sys/types.h> +#include <time.h> #include <unistd.h> -void *ptcb(void *p) { - assert(p == (void *)1); - assert(dfsan_get_label((uintptr_t)p) == 0); - return (void *)2; -} +dfsan_label i_label = 0; +dfsan_label j_label = 0; +dfsan_label i_j_label = 0; -int dlcb(struct dl_phdr_info *info, size_t size, void *data) { - assert(data == (void *)3); - assert(dfsan_get_label((uintptr_t)info) == 0); - assert(dfsan_get_label(size) == 0); - assert(dfsan_get_label((uintptr_t)data) == 0); - return 0; -} +#define ASSERT_ZERO_LABEL(data) \ + assert(0 == dfsan_get_label((long) (data))) -int main(void) { +#define ASSERT_READ_ZERO_LABEL(ptr, size) \ + assert(0 == dfsan_read_label(ptr, size)) + +#define ASSERT_LABEL(data, label) \ + assert(label == dfsan_get_label((long) (data))) + +#define ASSERT_READ_LABEL(ptr, size, label) \ + assert(label == dfsan_read_label(ptr, size)) + +void test_stat() { int i = 1; - dfsan_label i_label = dfsan_create_label("i", 0); dfsan_set_label(i_label, &i, sizeof(i)); - int j = 2; - dfsan_label j_label = dfsan_create_label("j", 0); - dfsan_set_label(j_label, &j, sizeof(j)); - struct stat s; s.st_dev = i; - int rv = stat("/", &s); - assert(rv == 0); - assert(dfsan_get_label(s.st_dev) == 0); + assert(0 == stat("/", &s)); + ASSERT_ZERO_LABEL(s.st_dev); s.st_dev = i; - rv = stat("/nonexistent", &s); - assert(rv == -1); - assert(dfsan_get_label(s.st_dev) == i_label); + assert(-1 == stat("/nonexistent", &s)); + ASSERT_LABEL(s.st_dev, i_label); +} +void test_fstat() { + int i = 1; + dfsan_set_label(i_label, &i, sizeof(i)); + + struct stat s; int fd = open("/dev/zero", O_RDONLY); s.st_dev = i; - rv = fstat(fd, &s); - assert(rv == 0); - assert(dfsan_get_label(s.st_dev) == 0); + int rv = fstat(fd, &s); + assert(0 == rv); + ASSERT_ZERO_LABEL(s.st_dev); +} +void test_memcmp() { char str1[] = "str1", str2[] = "str2"; dfsan_set_label(i_label, &str1[3], 1); dfsan_set_label(j_label, &str2[3], 1); - rv = memcmp(str1, str2, sizeof(str1)); + int rv = memcmp(str1, str2, sizeof(str1)); assert(rv < 0); - assert(dfsan_get_label(rv) == dfsan_union(i_label, j_label)); + ASSERT_LABEL(rv, i_j_label); +} - char strc[sizeof(str1)]; - memcpy(strc, str1, sizeof(str1)); - assert(dfsan_get_label(strc[0]) == 0); - assert(dfsan_get_label(strc[3]) == i_label); +void test_memcpy() { + char str1[] = "str1"; + char str2[sizeof(str1)]; + dfsan_set_label(i_label, &str1[3], 1); - memset(strc, j, sizeof(strc)); - assert(dfsan_get_label(strc[0]) == j_label); - assert(dfsan_get_label(strc[1]) == j_label); - assert(dfsan_get_label(strc[2]) == j_label); - assert(dfsan_get_label(strc[3]) == j_label); - assert(dfsan_get_label(strc[4]) == j_label); + ASSERT_ZERO_LABEL(memcpy(str2, str1, sizeof(str1))); + assert(0 == memcmp(str2, str1, sizeof(str1))); + ASSERT_ZERO_LABEL(str2[0]); + ASSERT_LABEL(str2[3], i_label); +} - rv = strcmp(str1, str2); +void test_memset() { + char buf[8]; + int j = 'a'; + dfsan_set_label(j_label, &j, sizeof(j)); + + ASSERT_ZERO_LABEL(memset(&buf, j, sizeof(buf))); + for (int i = 0; i < 8; ++i) { + ASSERT_LABEL(buf[i], j_label); + assert(buf[i] == 'a'); + } +} + +void test_strcmp() { + char str1[] = "str1", str2[] = "str2"; + dfsan_set_label(i_label, &str1[3], 1); + dfsan_set_label(j_label, &str2[3], 1); + + int rv = strcmp(str1, str2); assert(rv < 0); - assert(dfsan_get_label(rv) == dfsan_union(i_label, j_label)); + ASSERT_LABEL(rv, i_j_label); +} + +void test_strlen() { + char str1[] = "str1"; + dfsan_set_label(i_label, &str1[3], 1); + + int rv = strlen(str1); + assert(rv == 4); + ASSERT_LABEL(rv, i_label); +} + +void test_strdup() { + char str1[] = "str1"; + dfsan_set_label(i_label, &str1[3], 1); char *strd = strdup(str1); - assert(dfsan_get_label(strd[0]) == 0); - assert(dfsan_get_label(strd[3]) == i_label); + ASSERT_ZERO_LABEL(strd[0]); + ASSERT_LABEL(strd[3], i_label); free(strd); +} + +void test_strncpy() { + char str1[] = "str1"; + char str2[sizeof(str1)]; + dfsan_set_label(i_label, &str1[3], 1); + + char *strd = strncpy(str2, str1, 5); + assert(strd == str2); + assert(strcmp(str1, str2) == 0); + ASSERT_ZERO_LABEL(strd); + ASSERT_ZERO_LABEL(strd[0]); + ASSERT_ZERO_LABEL(strd[1]); + ASSERT_ZERO_LABEL(strd[2]); + ASSERT_LABEL(strd[3], i_label); - rv = strncmp(str1, str2, sizeof(str1)); + strd = strncpy(str2, str1, 3); + assert(strd == str2); + assert(strncmp(str1, str2, 3) == 0); + ASSERT_ZERO_LABEL(strd); + ASSERT_ZERO_LABEL(strd[0]); + ASSERT_ZERO_LABEL(strd[1]); + ASSERT_ZERO_LABEL(strd[2]); +} + +void test_strncmp() { + char str1[] = "str1", str2[] = "str2"; + dfsan_set_label(i_label, &str1[3], 1); + dfsan_set_label(j_label, &str2[3], 1); + + int rv = strncmp(str1, str2, sizeof(str1)); assert(rv < 0); - assert(dfsan_get_label(rv) == dfsan_union(i_label, j_label)); + ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); rv = strncmp(str1, str2, 3); assert(rv == 0); - assert(dfsan_get_label(rv) == 0); + ASSERT_ZERO_LABEL(rv); +} + +void test_strcasecmp() { + char str1[] = "str1", str2[] = "str2", str3[] = "Str1"; + dfsan_set_label(i_label, &str1[3], 1); + dfsan_set_label(j_label, &str2[3], 1); + dfsan_set_label(j_label, &str3[2], 1); + + int rv = strcasecmp(str1, str2); + assert(rv < 0); + ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); + + rv = strcasecmp(str1, str3); + assert(rv == 0); + ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); +} - str1[0] = 'S'; +void test_strncasecmp() { + char str1[] = "Str1", str2[] = "str2"; + dfsan_set_label(i_label, &str1[3], 1); + dfsan_set_label(j_label, &str2[3], 1); - rv = strncasecmp(str1, str2, sizeof(str1)); + int rv = strncasecmp(str1, str2, sizeof(str1)); assert(rv < 0); - assert(dfsan_get_label(rv) == dfsan_union(i_label, j_label)); + ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); rv = strncasecmp(str1, str2, 3); assert(rv == 0); - assert(dfsan_get_label(rv) == 0); + ASSERT_ZERO_LABEL(rv); +} + +void test_strchr() { + char str1[] = "str1"; + dfsan_set_label(i_label, &str1[3], 1); char *crv = strchr(str1, 'r'); assert(crv == &str1[2]); - assert(dfsan_get_label((uintptr_t)crv) == 0); + ASSERT_ZERO_LABEL(crv); crv = strchr(str1, '1'); assert(crv == &str1[3]); - assert(dfsan_get_label((uintptr_t)crv) == i_label); + ASSERT_LABEL(crv, i_label); crv = strchr(str1, 'x'); - assert(crv == 0); - assert(dfsan_get_label((uintptr_t)crv) == i_label); + assert(!crv); + ASSERT_LABEL(crv, i_label); +} +void test_calloc() { // With any luck this sequence of calls will cause calloc to return the same // pointer both times. This is probably the best we can do to test this // function. - crv = calloc(4096, 1); - assert(dfsan_get_label(crv[0]) == 0); + char *crv = calloc(4096, 1); + ASSERT_ZERO_LABEL(crv[0]); + dfsan_set_label(i_label, crv, 100); free(crv); crv = calloc(4096, 1); - assert(dfsan_get_label(crv[0]) == 0); + ASSERT_ZERO_LABEL(crv[0]); free(crv); +} +void test_read() { char buf[16]; - buf[0] = i; - buf[15] = j; - rv = read(fd, buf, sizeof(buf)); - assert(rv == sizeof(buf)); - assert(dfsan_get_label(buf[0]) == 0); - assert(dfsan_get_label(buf[15]) == 0); + dfsan_set_label(i_label, buf, 1); + dfsan_set_label(j_label, buf + 15, 1); + ASSERT_LABEL(buf[0], i_label); + ASSERT_LABEL(buf[15], j_label); + + int fd = open("/dev/zero", O_RDONLY); + int rv = read(fd, buf, sizeof(buf)); + assert(rv == sizeof(buf)); + ASSERT_ZERO_LABEL(rv); + ASSERT_ZERO_LABEL(buf[0]); + ASSERT_ZERO_LABEL(buf[15]); close(fd); - fd = open("/bin/sh", O_RDONLY); - buf[0] = i; - buf[15] = j; - rv = pread(fd, buf, sizeof(buf), 0); +} + +void test_pread() { + char buf[16]; + dfsan_set_label(i_label, buf, 1); + dfsan_set_label(j_label, buf + 15, 1); + + ASSERT_LABEL(buf[0], i_label); + ASSERT_LABEL(buf[15], j_label); + + int fd = open("/bin/sh", O_RDONLY); + int rv = pread(fd, buf, sizeof(buf), 0); assert(rv == sizeof(buf)); - assert(dfsan_get_label(buf[0]) == 0); - assert(dfsan_get_label(buf[15]) == 0); + ASSERT_ZERO_LABEL(rv); + ASSERT_ZERO_LABEL(buf[0]); + ASSERT_ZERO_LABEL(buf[15]); + close(fd); +} + +void test_dlopen() { + void *map = dlopen(NULL, RTLD_NOW); + assert(map); + ASSERT_ZERO_LABEL(map); + dlclose(map); + map = dlopen("/nonexistent", RTLD_NOW); + assert(!map); + ASSERT_ZERO_LABEL(map); +} + +void test_clock_gettime() { + struct timespec tp; + dfsan_set_label(j_label, ((char *)&tp) + 3, 1); + int t = clock_gettime(CLOCK_REALTIME, &tp); + assert(t == 0); + ASSERT_ZERO_LABEL(t); + ASSERT_ZERO_LABEL(((char *)&tp)[3]); +} + +void test_ctime_r() { + char *buf = (char*) malloc(64); + time_t t = 0; + + char *ret = ctime_r(&t, buf); + ASSERT_ZERO_LABEL(ret); + assert(buf == ret); + ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1); + + dfsan_set_label(i_label, &t, sizeof(t)); + ret = ctime_r(&t, buf); + ASSERT_ZERO_LABEL(ret); + ASSERT_READ_LABEL(buf, strlen(buf) + 1, i_label); + + t = 0; + dfsan_set_label(j_label, &buf, sizeof(&buf)); + ret = ctime_r(&t, buf); + ASSERT_LABEL(ret, j_label); + ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1); +} + +void test_fgets() { + char *buf = (char*) malloc(128); + FILE *f = fopen("/etc/passwd", "r"); + dfsan_set_label(j_label, buf, 1); + char *ret = fgets(buf, sizeof(buf), f); + assert(ret == buf); + ASSERT_ZERO_LABEL(ret); + ASSERT_READ_ZERO_LABEL(buf, 128); + dfsan_set_label(j_label, &buf, sizeof(&buf)); + ret = fgets(buf, sizeof(buf), f); + ASSERT_LABEL(ret, j_label); + fclose(f); +} + +void test_getcwd() { + char buf[1024]; + char *ptr = buf; + dfsan_set_label(i_label, buf + 2, 2); + char* ret = getcwd(buf, sizeof(buf)); + assert(ret == buf); + assert(ret[0] == '/'); + ASSERT_READ_ZERO_LABEL(buf + 2, 2); + dfsan_set_label(i_label, &ptr, sizeof(ptr)); + ret = getcwd(ptr, sizeof(buf)); + ASSERT_LABEL(ret, i_label); +} + +void test_get_current_dir_name() { + char* ret = get_current_dir_name(); + assert(ret); + assert(ret[0] == '/'); + ASSERT_READ_ZERO_LABEL(ret, strlen(ret) + 1); +} + +void test_gethostname() { + char buf[1024]; + dfsan_set_label(i_label, buf + 2, 2); + assert(gethostname(buf, sizeof(buf)) == 0); + ASSERT_READ_ZERO_LABEL(buf + 2, 2); +} + +void test_getrlimit() { + struct rlimit rlim; + dfsan_set_label(i_label, &rlim, sizeof(rlim)); + assert(getrlimit(RLIMIT_CPU, &rlim) == 0); + ASSERT_READ_ZERO_LABEL(&rlim, sizeof(rlim)); +} + +void test_getrusage() { + struct rusage usage; + dfsan_set_label(i_label, &usage, sizeof(usage)); + assert(getrusage(RUSAGE_SELF, &usage) == 0); + ASSERT_READ_ZERO_LABEL(&usage, sizeof(usage)); +} + +void test_strcpy() { + char src[] = "hello world"; + char dst[sizeof(src) + 2]; + dfsan_set_label(0, src, sizeof(src)); + dfsan_set_label(0, dst, sizeof(dst)); + dfsan_set_label(i_label, src + 2, 1); + dfsan_set_label(j_label, src + 3, 1); + dfsan_set_label(j_label, dst + 4, 1); + dfsan_set_label(i_label, dst + 12, 1); + char *ret = strcpy(dst, src); + assert(ret == dst); + assert(strcmp(src, dst) == 0); + for (int i = 0; i < strlen(src) + 1; ++i) { + assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i])); + } + // Note: if strlen(src) + 1 were used instead to compute the first untouched + // byte of dest, the label would be I|J. This is because strlen() might + // return a non-zero label, and because by default pointer labels are not + // ignored on loads. + ASSERT_LABEL(dst[12], i_label); +} + +void test_strtol() { + char buf[] = "1234578910"; + char *endptr = NULL; + dfsan_set_label(i_label, buf + 1, 1); + dfsan_set_label(j_label, buf + 10, 1); + long int ret = strtol(buf, &endptr, 10); + assert(ret == 1234578910); + assert(endptr == buf + 10); + ASSERT_LABEL(ret, i_j_label); +} + +void test_strtoll() { + char buf[] = "1234578910 "; + char *endptr = NULL; + dfsan_set_label(i_label, buf + 1, 1); + dfsan_set_label(j_label, buf + 2, 1); + long long int ret = strtoll(buf, &endptr, 10); + assert(ret == 1234578910); + assert(endptr == buf + 10); + ASSERT_LABEL(ret, i_j_label); +} + +void test_strtoul() { + char buf[] = "0xffffffffffffaa"; + char *endptr = NULL; + dfsan_set_label(i_label, buf + 1, 1); + dfsan_set_label(j_label, buf + 2, 1); + long unsigned int ret = strtol(buf, &endptr, 16); + assert(ret == 72057594037927850); + assert(endptr == buf + 16); + ASSERT_LABEL(ret, i_j_label); +} + +void test_strtoull() { + char buf[] = "0xffffffffffffffaa"; + char *endptr = NULL; + dfsan_set_label(i_label, buf + 1, 1); + dfsan_set_label(j_label, buf + 2, 1); + long long unsigned int ret = strtoull(buf, &endptr, 16); + assert(ret == 0xffffffffffffffaa); + assert(endptr == buf + 18); + ASSERT_LABEL(ret, i_j_label); +} + +void test_strtod() { + char buf[] = "12345.76 foo"; + char *endptr = NULL; + dfsan_set_label(i_label, buf + 1, 1); + dfsan_set_label(j_label, buf + 6, 1); + double ret = strtod(buf, &endptr); + assert(ret == 12345.76); + assert(endptr == buf + 8); + ASSERT_LABEL(ret, i_j_label); +} + +void test_time() { + time_t t = 0; + dfsan_set_label(i_label, &t, 1); + time_t ret = time(&t); + assert(ret == t); + assert(ret > 0); + ASSERT_ZERO_LABEL(t); +} + +void test_inet_pton() { + char addr4[] = "127.0.0.1"; + dfsan_set_label(i_label, addr4 + 3, 1); + struct in_addr in4; + int ret4 = inet_pton(AF_INET, addr4, &in4); + assert(ret4 == 1); + ASSERT_READ_LABEL(&in4, sizeof(in4), i_label); + assert(in4.s_addr == 0x0100007f); + + char addr6[] = "::1"; + dfsan_set_label(j_label, addr6 + 3, 1); + struct in6_addr in6; + int ret6 = inet_pton(AF_INET6, addr6, &in6); + assert(ret6 == 1); + ASSERT_READ_LABEL(((char *) &in6) + sizeof(in6) - 1, 1, j_label); +} + +void test_localtime_r() { + time_t t0 = 1384800998; + struct tm t1; + dfsan_set_label(i_label, &t0, sizeof(t0)); + struct tm* ret = localtime_r(&t0, &t1); + assert(ret == &t1); + assert(t1.tm_min == 56); + ASSERT_LABEL(t1.tm_mon, i_label); +} + +void test_getpwuid_r() { + struct passwd pwd; + char buf[1024]; + struct passwd *result; + + dfsan_set_label(i_label, &pwd, 4); + int ret = getpwuid_r(0, &pwd, buf, sizeof(buf), &result); + assert(ret == 0); + assert(strcmp(pwd.pw_name, "root") == 0); + assert(result == &pwd); + ASSERT_READ_ZERO_LABEL(&pwd, 4); +} + +void test_poll() { + struct pollfd fd; + fd.fd = 0; + fd.events = POLLIN; + dfsan_set_label(i_label, &fd.revents, sizeof(fd.revents)); + int ret = poll(&fd, 1, 1); + ASSERT_ZERO_LABEL(fd.revents); + assert(ret >= 0); +} + +void test_select() { + struct timeval t; + fd_set fds; + t.tv_sec = 2; + FD_SET(0, &fds); + dfsan_set_label(i_label, &fds, sizeof(fds)); + dfsan_set_label(j_label, &t, sizeof(t)); + int ret = select(1, &fds, NULL, NULL, &t); + assert(ret >= 0); + ASSERT_ZERO_LABEL(t.tv_sec); + ASSERT_READ_ZERO_LABEL(&fds, sizeof(fds)); +} + +void test_sched_getaffinity() { + cpu_set_t mask; + dfsan_set_label(j_label, &mask, 1); + int ret = sched_getaffinity(0, sizeof(mask), &mask); + assert(ret == 0); + ASSERT_READ_ZERO_LABEL(&mask, sizeof(mask)); +} + +void test_sigemptyset() { + sigset_t set; + dfsan_set_label(j_label, &set, 1); + int ret = sigemptyset(&set); + assert(ret == 0); + ASSERT_READ_ZERO_LABEL(&set, sizeof(set)); +} +void test_sigaction() { + struct sigaction oldact; + dfsan_set_label(j_label, &oldact, 1); + int ret = sigaction(SIGUSR1, NULL, &oldact); + assert(ret == 0); + ASSERT_READ_ZERO_LABEL(&oldact, sizeof(oldact)); +} + +void test_gettimeofday() { + struct timeval tv; + struct timezone tz; + dfsan_set_label(i_label, &tv, sizeof(tv)); + dfsan_set_label(j_label, &tz, sizeof(tz)); + int ret = gettimeofday(&tv, &tz); + assert(ret == 0); + ASSERT_READ_ZERO_LABEL(&tv, sizeof(tv)); + ASSERT_READ_ZERO_LABEL(&tz, sizeof(tz)); +} + +void *pthread_create_test_cb(void *p) { + assert(p == (void *)1); + ASSERT_ZERO_LABEL(p); + return (void *)2; +} + +void test_pthread_create() { pthread_t pt; - pthread_create(&pt, 0, ptcb, (void *)1); + pthread_create(&pt, 0, pthread_create_test_cb, (void *)1); void *cbrv; pthread_join(pt, &cbrv); assert(cbrv == (void *)2); +} - dl_iterate_phdr(dlcb, (void *)3); - +int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size, + void *data) { + assert(data == (void *)3); + ASSERT_ZERO_LABEL(info); + ASSERT_ZERO_LABEL(size); + ASSERT_ZERO_LABEL(data); return 0; } + +void test_dl_iterate_phdr() { + dl_iterate_phdr(dl_iterate_phdr_test_cb, (void *)3); +} + +int main(void) { + i_label = dfsan_create_label("i", 0); + j_label = dfsan_create_label("j", 0); + i_j_label = dfsan_union(i_label, j_label); + + test_calloc(); + test_clock_gettime(); + test_dlopen(); + test_fstat(); + test_memcmp(); + test_memcpy(); + test_memset(); + test_pread(); + test_read(); + test_stat(); + test_strcasecmp(); + test_strchr(); + test_strcmp(); + test_strdup(); + test_strlen(); + test_strncasecmp(); + test_strncmp(); + test_strncpy(); + + test_ctime_r(); + test_fgets(); + test_getcwd(); + test_get_current_dir_name(); + test_gethostname(); + test_getrlimit(); + test_getrusage(); + test_strcpy(); + test_strtol(); + test_strtoll(); + test_strtod(); + test_strtoul(); + test_strtoull(); + test_time(); + test_inet_pton(); + test_localtime_r(); + test_getpwuid_r(); + test_poll(); + test_select(); + test_sched_getaffinity(); + test_sigemptyset(); + test_sigaction(); + test_gettimeofday(); + + test_pthread_create(); + test_dl_iterate_phdr(); +} diff --git a/lib/dfsan/scripts/check_custom_wrappers.sh b/lib/dfsan/scripts/check_custom_wrappers.sh new file mode 100755 index 000000000..47a2c45e1 --- /dev/null +++ b/lib/dfsan/scripts/check_custom_wrappers.sh @@ -0,0 +1,50 @@ +#!/bin/bash + +DFSAN_DIR=$(dirname "$0")/../ +DFSAN_CUSTOM_TESTS=${DFSAN_DIR}/lit_tests/custom.c +DFSAN_CUSTOM_WRAPPERS=${DFSAN_DIR}/dfsan_custom.cc +DFSAN_ABI_LIST=${DFSAN_DIR}/done_abilist.txt + +DIFFOUT=$(mktemp -q /tmp/tmp.XXXXXXXXXX) +ERRORLOG=$(mktemp -q /tmp/tmp.XXXXXXXXXX) + +on_exit() { + rm -f ${DIFFOUT} 2> /dev/null + rm -f ${ERRORLOG} 2> /dev/null +} + +trap on_exit EXIT + +diff \ + <(grep "^fun:.*=custom" ${DFSAN_ABI_LIST} | grep -v "dfsan_get_label" \ + | sed "s/^fun:\(.*\)=custom.*/\1/" | sort ) \ + <(grep "__dfsw.*(" ${DFSAN_CUSTOM_WRAPPERS} \ + | sed "s/.*__dfsw_\(.*\)(.*/\1/" \ + | sort) > ${DIFFOUT} +if [ $? -ne 0 ] +then + echo -n "The following differences between the ABI list and ">> ${ERRORLOG} + echo "the implemented custom wrappers have been found:" >> ${ERRORLOG} + cat ${DIFFOUT} >> ${ERRORLOG} +fi + +diff \ + <(grep __dfsw_ ${DFSAN_CUSTOM_WRAPPERS} \ + | sed "s/.*__dfsw_\([^(]*\).*/\1/" \ + | sort) \ + <(grep "^\\s*test_.*();" ${DFSAN_CUSTOM_TESTS} \ + | sed "s/.*test_\(.*\)();/\1/" \ + | sort) > ${DIFFOUT} +if [ $? -ne 0 ] +then + echo -n "The following differences between the implemented " >> ${ERRORLOG} + echo "custom wrappers and the tests have been found:" >> ${ERRORLOG} + cat ${DIFFOUT} >> ${ERRORLOG} +fi + +if [[ -s ${ERRORLOG} ]] +then + cat ${ERRORLOG} + exit 1 +fi + |