Index: head/tests/sys/audit/file-attribute-access.c =================================================================== --- head/tests/sys/audit/file-attribute-access.c (revision 335066) +++ head/tests/sys/audit/file-attribute-access.c (revision 335067) @@ -1,239 +1,241 @@ /*- * Copyright (c) 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include "utils.h" static struct pollfd fds[1]; static mode_t mode = 0777; +static int filedesc; static char extregex[80]; static struct stat statbuff; static const char *auclass = "fa"; static const char *path = "fileforaudit"; static const char *errpath = "dirdoesnotexist/fileforaudit"; static const char *successreg = "fileforaudit.*return,success"; static const char *failurereg = "fileforaudit.*return,failure"; ATF_TC_WITH_CLEANUP(stat_success); ATF_TC_HEAD(stat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "stat(2) call"); } ATF_TC_BODY(stat_success, tc) { /* File needs to exist to call stat(2) */ - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, stat(path, &statbuff)); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(stat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(stat_failure); ATF_TC_HEAD(stat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "stat(2) call"); } ATF_TC_BODY(stat_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, stat(errpath, &statbuff)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(stat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(lstat_success); ATF_TC_HEAD(lstat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "lstat(2) call"); } ATF_TC_BODY(lstat_success, tc) { /* Symbolic link needs to exist to call lstat(2) */ ATF_REQUIRE_EQ(0, symlink("symlink", path)); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, lstat(path, &statbuff)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(lstat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(lstat_failure); ATF_TC_HEAD(lstat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "lstat(2) call"); } ATF_TC_BODY(lstat_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: symbolic link does not exist */ ATF_REQUIRE_EQ(-1, lstat(errpath, &statbuff)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(lstat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(fstat_success); ATF_TC_HEAD(fstat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "fstat(2) call"); } ATF_TC_BODY(fstat_success, tc) { - int filedesc; /* File needs to exist to call fstat(2) */ ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, fstat(filedesc, &statbuff)); snprintf(extregex, sizeof(extregex), "fstat.*%jd.*return,success", (intmax_t)statbuff.st_ino); check_audit(fds, extregex, pipefd); + close(filedesc); } ATF_TC_CLEANUP(fstat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(fstat_failure); ATF_TC_HEAD(fstat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "fstat(2) call"); } ATF_TC_BODY(fstat_failure, tc) { FILE *pipefd = setup(fds, auclass); const char *regex = "fstat.*return,failure : Bad file descriptor"; /* Failure reason: bad file descriptor */ ATF_REQUIRE_EQ(-1, fstat(-1, &statbuff)); check_audit(fds, regex, pipefd); } ATF_TC_CLEANUP(fstat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(fstatat_success); ATF_TC_HEAD(fstatat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "fstatat(2) call"); } ATF_TC_BODY(fstatat_success, tc) { /* File or Symbolic link needs to exist to call lstat(2) */ ATF_REQUIRE_EQ(0, symlink("symlink", path)); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, fstatat(AT_FDCWD, path, &statbuff, AT_SYMLINK_NOFOLLOW)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(fstatat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(fstatat_failure); ATF_TC_HEAD(fstatat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "fstatat(2) call"); } ATF_TC_BODY(fstatat_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: symbolic link does not exist */ ATF_REQUIRE_EQ(-1, fstatat(AT_FDCWD, path, &statbuff, AT_SYMLINK_NOFOLLOW)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(fstatat_failure, tc) { cleanup(); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, stat_success); ATF_TP_ADD_TC(tp, stat_failure); ATF_TP_ADD_TC(tp, lstat_success); ATF_TP_ADD_TC(tp, lstat_failure); ATF_TP_ADD_TC(tp, fstat_success); ATF_TP_ADD_TC(tp, fstat_failure); ATF_TP_ADD_TC(tp, fstatat_success); ATF_TP_ADD_TC(tp, fstatat_failure); return (atf_no_error()); } Index: head/tests/sys/audit/file-close.c =================================================================== --- head/tests/sys/audit/file-close.c (revision 335066) +++ head/tests/sys/audit/file-close.c (revision 335067) @@ -1,236 +1,233 @@ /*- * Copyright 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include "utils.h" static pid_t pid; static struct pollfd fds[1]; static mode_t mode = 0777; +static int filedesc; static char extregex[80]; static struct stat statbuff; static const char *auclass = "cl"; static const char *path = "fileforaudit"; static const char *errpath = "dirdoesnotexist/fileforaudit"; static const char *failurereg = "fileforaudit.*return,failure"; ATF_TC_WITH_CLEANUP(munmap_success); ATF_TC_HEAD(munmap_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "munmap(2) call"); } ATF_TC_BODY(munmap_success, tc) { pid = getpid(); snprintf(extregex, sizeof(extregex), "munmap.*%d.*return,success", pid); /* Allocate sample memory, to be removed by munmap(2) */ char *addr = mmap(NULL, sizeof(char), PROT_READ , MAP_ANONYMOUS, -1, 0); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, munmap(addr, sizeof(char))); check_audit(fds, extregex, pipefd); } ATF_TC_CLEANUP(munmap_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(munmap_failure); ATF_TC_HEAD(munmap_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "munmap(2) call"); } ATF_TC_BODY(munmap_failure, tc) { const char *regex = "munmap.*return,failure : Invalid argument"; FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(-1, munmap((void *)SIZE_MAX, -1)); check_audit(fds, regex, pipefd); } ATF_TC_CLEANUP(munmap_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(close_success); ATF_TC_HEAD(close_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "close(2) call"); } ATF_TC_BODY(close_success, tc) { - int filedesc; /* File needs to exist to call close(2) */ ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1); /* Call stat(2) to store the Inode number of 'path' */ ATF_REQUIRE_EQ(0, stat(path, &statbuff)); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, close(filedesc)); /* intmax_t to support all architectures */ snprintf(extregex, sizeof(extregex), "close.*%jd.*return,succes", (intmax_t)statbuff.st_ino); check_audit(fds, extregex, pipefd); } ATF_TC_CLEANUP(close_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(close_failure); ATF_TC_HEAD(close_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "close(2) call"); } ATF_TC_BODY(close_failure, tc) { const char *regex = "close.*return,failure"; FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, close(-1)); check_audit(fds, regex, pipefd); } ATF_TC_CLEANUP(close_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(closefrom_success); ATF_TC_HEAD(closefrom_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "closefrom(2) call"); } ATF_TC_BODY(closefrom_success, tc) { const char *regex = "closefrom.*return,success"; FILE *pipefd = setup(fds, auclass); /* closefrom(2) returns 'void' */ closefrom(INT_MAX); check_audit(fds, regex, pipefd); } ATF_TC_CLEANUP(closefrom_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(revoke_success); ATF_TC_HEAD(revoke_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "revoke(2) call"); } ATF_TC_BODY(revoke_success, tc) { - int filedesc; char *ptyname; pid = getpid(); snprintf(extregex, sizeof(extregex), "revoke.*%d.*return,success", pid); /* Obtain a pseudo terminal and get the path to slave device */ ATF_REQUIRE((filedesc = posix_openpt(O_RDWR | O_NOCTTY)) != -1); ATF_REQUIRE((ptyname = ptsname(filedesc)) != NULL); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, revoke(ptyname)); check_audit(fds, extregex, pipefd); - - /* Close the file descriptor to pseudo terminal */ - ATF_REQUIRE_EQ(0, close(filedesc)); + close(filedesc); } ATF_TC_CLEANUP(revoke_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(revoke_failure); ATF_TC_HEAD(revoke_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "revoke(2) call"); } ATF_TC_BODY(revoke_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, revoke(errpath)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(revoke_failure, tc) { cleanup(); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, munmap_success); ATF_TP_ADD_TC(tp, munmap_failure); ATF_TP_ADD_TC(tp, close_success); ATF_TP_ADD_TC(tp, close_failure); ATF_TP_ADD_TC(tp, closefrom_success); ATF_TP_ADD_TC(tp, revoke_success); ATF_TP_ADD_TC(tp, revoke_failure); return (atf_no_error()); } Index: head/tests/sys/audit/file-create.c =================================================================== --- head/tests/sys/audit/file-create.c (revision 335066) +++ head/tests/sys/audit/file-create.c (revision 335067) @@ -1,584 +1,589 @@ /*- * Copyright 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include "utils.h" static struct pollfd fds[1]; static mode_t mode = 0777; +static int filedesc; static dev_t dev = 0; static const char *auclass = "fc"; static const char *path = "fileforaudit"; static const char *successreg = "fileforaudit.*return,success"; static const char *failurereg = "fileforaudit.*return,failure"; ATF_TC_WITH_CLEANUP(mkdir_success); ATF_TC_HEAD(mkdir_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "mkdir(2) call"); } ATF_TC_BODY(mkdir_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, mkdir(path, mode)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(mkdir_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkdir_failure); ATF_TC_HEAD(mkdir_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "mkdir(2) call"); } ATF_TC_BODY(mkdir_failure, tc) { ATF_REQUIRE_EQ(0, mkdir(path, mode)); FILE *pipefd = setup(fds, auclass); /* Failure reason: directory already exists */ ATF_REQUIRE_EQ(-1, mkdir(path, mode)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(mkdir_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkdirat_success); ATF_TC_HEAD(mkdirat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "mkdirat(2) call"); } ATF_TC_BODY(mkdirat_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, mkdirat(AT_FDCWD, path, mode)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(mkdirat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkdirat_failure); ATF_TC_HEAD(mkdirat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "mkdirat(2) call"); } ATF_TC_BODY(mkdirat_failure, tc) { ATF_REQUIRE_EQ(0, mkdirat(AT_FDCWD, path, mode)); FILE *pipefd = setup(fds, auclass); /* Failure reason: directory already exists */ ATF_REQUIRE_EQ(-1, mkdirat(AT_FDCWD, path, mode)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(mkdirat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkfifo_success); ATF_TC_HEAD(mkfifo_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "mkfifo(2) call"); } ATF_TC_BODY(mkfifo_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, mkfifo(path, mode)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(mkfifo_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkfifo_failure); ATF_TC_HEAD(mkfifo_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "mkfifo(2) call"); } ATF_TC_BODY(mkfifo_failure, tc) { ATF_REQUIRE_EQ(0, mkfifo(path, mode)); FILE *pipefd = setup(fds, auclass); /* Failure reason: FIFO already exists */ ATF_REQUIRE_EQ(-1, mkfifo(path, mode)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(mkfifo_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkfifoat_success); ATF_TC_HEAD(mkfifoat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "mkfifoat(2) call"); } ATF_TC_BODY(mkfifoat_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, mkfifoat(AT_FDCWD, path, mode)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(mkfifoat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mkfifoat_failure); ATF_TC_HEAD(mkfifoat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "mkfifoat(2) call"); } ATF_TC_BODY(mkfifoat_failure, tc) { ATF_REQUIRE_EQ(0, mkfifoat(AT_FDCWD, path, mode)); FILE *pipefd = setup(fds, auclass); /* Failure reason: FIFO already exists */ ATF_REQUIRE_EQ(-1, mkfifoat(AT_FDCWD, path, mode)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(mkfifoat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mknod_success); ATF_TC_HEAD(mknod_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "mknod(2) call"); } ATF_TC_BODY(mknod_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, mknod(path, S_IFIFO | S_IRWXO, dev)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(mknod_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mknod_failure); ATF_TC_HEAD(mknod_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "mknod(2) call"); } ATF_TC_BODY(mknod_failure, tc) { ATF_REQUIRE_EQ(0, mknod(path, S_IFIFO | S_IRWXO, dev)); FILE *pipefd = setup(fds, auclass); /* Failure reason: FIFO node already exists */ ATF_REQUIRE_EQ(-1, mknod(path, S_IFIFO | S_IRWXO, dev)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(mknod_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mknodat_success); ATF_TC_HEAD(mknodat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "mknodat(2) call"); } ATF_TC_BODY(mknodat_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, mknodat(AT_FDCWD, path, S_IFIFO | S_IRWXO, dev)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(mknodat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(mknodat_failure); ATF_TC_HEAD(mknodat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "mknodat(2) call"); } ATF_TC_BODY(mknodat_failure, tc) { ATF_REQUIRE_EQ(0, mknodat(AT_FDCWD, path, S_IFIFO | S_IRWXO, dev)); FILE *pipefd = setup(fds, auclass); /* Failure reason: FIFO node already exists */ ATF_REQUIRE_EQ(-1, mknodat(AT_FDCWD, path, S_IFIFO | S_IRWXO, dev)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(mknodat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(rename_success); ATF_TC_HEAD(rename_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "rename(2) call"); } ATF_TC_BODY(rename_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, rename(path, "renamed")); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(rename_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(rename_failure); ATF_TC_HEAD(rename_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "rename(2) call"); } ATF_TC_BODY(rename_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, rename(path, "renamed")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(rename_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(renameat_success); ATF_TC_HEAD(renameat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "renameat(2) call"); } ATF_TC_BODY(renameat_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, renameat(AT_FDCWD, path, AT_FDCWD, "renamed")); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(renameat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(renameat_failure); ATF_TC_HEAD(renameat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "renameat(2) call"); } ATF_TC_BODY(renameat_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, renameat(AT_FDCWD, path, AT_FDCWD, "renamed")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(renameat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(link_success); ATF_TC_HEAD(link_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "link(2) call"); } ATF_TC_BODY(link_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, link(path, "hardlink")); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(link_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(link_failure); ATF_TC_HEAD(link_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "link(2) call"); } ATF_TC_BODY(link_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, link(path, "hardlink")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(link_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(linkat_success); ATF_TC_HEAD(linkat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "linkat(2) call"); } ATF_TC_BODY(linkat_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, linkat(AT_FDCWD, path, AT_FDCWD, "hardlink", 0)); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(linkat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(linkat_failure); ATF_TC_HEAD(linkat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "linkat(2) call"); } ATF_TC_BODY(linkat_failure, tc) { FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, linkat(AT_FDCWD, path, AT_FDCWD, "hardlink", 0)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(linkat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(symlink_success); ATF_TC_HEAD(symlink_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "symlink(2) call"); } ATF_TC_BODY(symlink_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, symlink(path, "symlink")); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(symlink_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(symlink_failure); ATF_TC_HEAD(symlink_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "symlink(2) call"); } ATF_TC_BODY(symlink_failure, tc) { ATF_REQUIRE_EQ(0, symlink(path, "symlink")); FILE *pipefd = setup(fds, auclass); /* Failure reason: symbolic link already exists */ ATF_REQUIRE_EQ(-1, symlink(path, "symlink")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(symlink_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(symlinkat_success); ATF_TC_HEAD(symlinkat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "symlinkat(2) call"); } ATF_TC_BODY(symlinkat_success, tc) { FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, symlinkat(path, AT_FDCWD, "symlink")); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(symlinkat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(symlinkat_failure); ATF_TC_HEAD(symlinkat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "symlinkat(2) call"); } ATF_TC_BODY(symlinkat_failure, tc) { ATF_REQUIRE_EQ(0, symlinkat(path, AT_FDCWD, "symlink")); FILE *pipefd = setup(fds, auclass); /* Failure reason: symbolic link already exists */ ATF_REQUIRE_EQ(-1, symlinkat(path, AT_FDCWD, "symlink")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(symlinkat_failure, tc) { cleanup(); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, mkdir_success); ATF_TP_ADD_TC(tp, mkdir_failure); ATF_TP_ADD_TC(tp, mkdirat_success); ATF_TP_ADD_TC(tp, mkdirat_failure); ATF_TP_ADD_TC(tp, mkfifo_success); ATF_TP_ADD_TC(tp, mkfifo_failure); ATF_TP_ADD_TC(tp, mkfifoat_success); ATF_TP_ADD_TC(tp, mkfifoat_failure); ATF_TP_ADD_TC(tp, mknod_success); ATF_TP_ADD_TC(tp, mknod_failure); ATF_TP_ADD_TC(tp, mknodat_success); ATF_TP_ADD_TC(tp, mknodat_failure); ATF_TP_ADD_TC(tp, rename_success); ATF_TP_ADD_TC(tp, rename_failure); ATF_TP_ADD_TC(tp, renameat_success); ATF_TP_ADD_TC(tp, renameat_failure); ATF_TP_ADD_TC(tp, link_success); ATF_TP_ADD_TC(tp, link_failure); ATF_TP_ADD_TC(tp, linkat_success); ATF_TP_ADD_TC(tp, linkat_failure); ATF_TP_ADD_TC(tp, symlink_success); ATF_TP_ADD_TC(tp, symlink_failure); ATF_TP_ADD_TC(tp, symlinkat_success); ATF_TP_ADD_TC(tp, symlinkat_failure); return (atf_no_error()); } Index: head/tests/sys/audit/file-delete.c =================================================================== --- head/tests/sys/audit/file-delete.c (revision 335066) +++ head/tests/sys/audit/file-delete.c (revision 335067) @@ -1,270 +1,274 @@ /*- * Copyright 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include "utils.h" static struct pollfd fds[1]; static mode_t mode = 0777; +static int filedesc; static const char *path = "fileforaudit"; static const char *errpath = "dirdoesnotexist/fileforaudit"; static const char *successreg = "fileforaudit.*return,success"; static const char *failurereg = "fileforaudit.*return,failure"; ATF_TC_WITH_CLEANUP(rmdir_success); ATF_TC_HEAD(rmdir_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "rmdir(2) call"); } ATF_TC_BODY(rmdir_success, tc) { ATF_REQUIRE_EQ(0, mkdir(path, mode)); FILE *pipefd = setup(fds, "fd"); ATF_REQUIRE_EQ(0, rmdir(path)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(rmdir_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(rmdir_failure); ATF_TC_HEAD(rmdir_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "rmdir(2) call"); } ATF_TC_BODY(rmdir_failure, tc) { FILE *pipefd = setup(fds, "fd"); /* Failure reason: directory does not exist */ ATF_REQUIRE_EQ(-1, rmdir(errpath)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(rmdir_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(rename_success); ATF_TC_HEAD(rename_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "rename(2) call"); } ATF_TC_BODY(rename_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, "fd"); ATF_REQUIRE_EQ(0, rename(path, "renamed")); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(rename_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(rename_failure); ATF_TC_HEAD(rename_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "rename(2) call"); } ATF_TC_BODY(rename_failure, tc) { FILE *pipefd = setup(fds, "fd"); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, rename(path, "renamed")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(rename_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(renameat_success); ATF_TC_HEAD(renameat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "renameat(2) call"); } ATF_TC_BODY(renameat_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, "fd"); ATF_REQUIRE_EQ(0, renameat(AT_FDCWD, path, AT_FDCWD, "renamed")); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(renameat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(renameat_failure); ATF_TC_HEAD(renameat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "renameat(2) call"); } ATF_TC_BODY(renameat_failure, tc) { FILE *pipefd = setup(fds, "fd"); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, renameat(AT_FDCWD, path, AT_FDCWD, "renamed")); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(renameat_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(unlink_success); ATF_TC_HEAD(unlink_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "unlink(2) call"); } ATF_TC_BODY(unlink_success, tc) { - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, "fd"); ATF_REQUIRE_EQ(0, unlink(path)); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(unlink_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(unlink_failure); ATF_TC_HEAD(unlink_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "unlink(2) call"); } ATF_TC_BODY(unlink_failure, tc) { FILE *pipefd = setup(fds, "fd"); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, unlink(errpath)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(unlink_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(unlinkat_success); ATF_TC_HEAD(unlinkat_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "unlinkat(2) call"); } ATF_TC_BODY(unlinkat_success, tc) { ATF_REQUIRE_EQ(0, mkdir(path, mode)); FILE *pipefd = setup(fds, "fd"); ATF_REQUIRE_EQ(0, unlinkat(AT_FDCWD, path, AT_REMOVEDIR)); check_audit(fds, successreg, pipefd); } ATF_TC_CLEANUP(unlinkat_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(unlinkat_failure); ATF_TC_HEAD(unlinkat_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "unlinkat(2) call"); } ATF_TC_BODY(unlinkat_failure, tc) { FILE *pipefd = setup(fds, "fd"); /* Failure reason: directory does not exist */ ATF_REQUIRE_EQ(-1, unlinkat(AT_FDCWD, errpath, AT_REMOVEDIR)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(unlinkat_failure, tc) { cleanup(); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, rmdir_success); ATF_TP_ADD_TC(tp, rmdir_failure); ATF_TP_ADD_TC(tp, rename_success); ATF_TP_ADD_TC(tp, rename_failure); ATF_TP_ADD_TC(tp, renameat_success); ATF_TP_ADD_TC(tp, renameat_failure); ATF_TP_ADD_TC(tp, unlink_success); ATF_TP_ADD_TC(tp, unlink_failure); ATF_TP_ADD_TC(tp, unlinkat_success); ATF_TP_ADD_TC(tp, unlinkat_failure); return (atf_no_error()); } Index: head/tests/sys/audit/file-write.c =================================================================== --- head/tests/sys/audit/file-write.c (revision 335066) +++ head/tests/sys/audit/file-write.c (revision 335067) @@ -1,139 +1,141 @@ /*- * Copyright 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include "utils.h" static struct pollfd fds[1]; static mode_t mode = 0777; +static int filedesc; static off_t offlen = 0; static const char *path = "fileforaudit"; static const char *errpath = "dirdoesnotexist/fileforaudit"; static const char *successreg = "fileforaudit.*return,success"; static const char *failurereg = "fileforaudit.*return,failure"; ATF_TC_WITH_CLEANUP(truncate_success); ATF_TC_HEAD(truncate_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "truncate(2) call"); } ATF_TC_BODY(truncate_success, tc) { /* File needs to exist to call truncate(2) */ - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); FILE *pipefd = setup(fds, "fw"); ATF_REQUIRE_EQ(0, truncate(path, offlen)); check_audit(fds, successreg, pipefd); + close(filedesc); } ATF_TC_CLEANUP(truncate_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(truncate_failure); ATF_TC_HEAD(truncate_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "truncate(2) call"); } ATF_TC_BODY(truncate_failure, tc) { FILE *pipefd = setup(fds, "fw"); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, truncate(errpath, offlen)); check_audit(fds, failurereg, pipefd); } ATF_TC_CLEANUP(truncate_failure, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(ftruncate_success); ATF_TC_HEAD(ftruncate_success, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " "ftruncate(2) call"); } ATF_TC_BODY(ftruncate_success, tc) { - int filedesc; const char *regex = "ftruncate.*return,success"; /* Valid file descriptor needs to exist to call ftruncate(2) */ ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR)) != -1); FILE *pipefd = setup(fds, "fw"); ATF_REQUIRE_EQ(0, ftruncate(filedesc, offlen)); check_audit(fds, regex, pipefd); + close(filedesc); } ATF_TC_CLEANUP(ftruncate_success, tc) { cleanup(); } ATF_TC_WITH_CLEANUP(ftruncate_failure); ATF_TC_HEAD(ftruncate_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " "ftruncate(2) call"); } ATF_TC_BODY(ftruncate_failure, tc) { const char *regex = "ftruncate.*return,failure"; FILE *pipefd = setup(fds, "fw"); /* Failure reason: bad file descriptor */ ATF_REQUIRE_EQ(-1, ftruncate(-1, offlen)); check_audit(fds, regex, pipefd); } ATF_TC_CLEANUP(ftruncate_failure, tc) { cleanup(); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, truncate_success); ATF_TP_ADD_TC(tp, truncate_failure); ATF_TP_ADD_TC(tp, ftruncate_success); ATF_TP_ADD_TC(tp, ftruncate_failure); return (atf_no_error()); } Index: head/tests/sys/audit/open.c =================================================================== --- head/tests/sys/audit/open.c (revision 335066) +++ head/tests/sys/audit/open.c (revision 335067) @@ -1,191 +1,196 @@ /*- * Copyright (c) 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ /* * Note: open(2) and openat(2) have 12 events each for various values of 'flag' * Please see: contrib/openbsm/etc/audit_event#L261 * * 270:AUE_OPENAT_R:openat(2) - read:fr * 271:AUE_OPENAT_RC:openat(2) - read,creat:fc,fr,fa,fm * 272:AUE_OPENAT_RT:openat(2) - read,trunc:fd,fr,fa,fm * 273:AUE_OPENAT_RTC:openat(2) - read,creat,trunc:fc,fd,fr,fa,fm * 274:AUE_OPENAT_W:openat(2) - write:fw * 275:AUE_OPENAT_WC:openat(2) - write,creat:fc,fw,fa,fm * 276:AUE_OPENAT_WT:openat(2) - write,trunc:fd,fw,fa,fm * 277:AUE_OPENAT_WTC:openat(2) - write,creat,trunc:fc,fd,fw,fa,fm * 278:AUE_OPENAT_RW:openat(2) - read,write:fr,fw * 279:AUE_OPENAT_RWC:openat(2) - read,write,create:fc,fw,fr,fa,fm * 280:AUE_OPENAT_RWT:openat(2) - read,write,trunc:fd,fw,fr,fa,fm * 281:AUE_OPENAT_RWTC:openat(2) - read,write,creat,trunc:fc,fd,fw,fr,fa,fm */ #include #include #include #include "utils.h" static struct pollfd fds[1]; static mode_t o_mode = 0777; +static int filedesc; static char extregex[80]; static const char *path = "fileforaudit"; static const char *errpath = "adirhasnoname/fileforaudit"; /* * Define test-cases for success and failure modes of both open(2) and openat(2) */ #define OPEN_AT_TC_DEFINE(mode, regex, flag, class) \ ATF_TC_WITH_CLEANUP(open_ ## mode ## _success); \ ATF_TC_HEAD(open_ ## mode ## _success, tc) \ { \ atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " \ "open(2) call with flags = %s", #flag); \ } \ ATF_TC_BODY(open_ ## mode ## _success, tc) \ { \ snprintf(extregex, sizeof(extregex), \ "open.*%s.*fileforaudit.*return,success", regex); \ /* File needs to exist for successful open(2) invocation */ \ - ATF_REQUIRE(open(path, O_CREAT, o_mode) != -1); \ + ATF_REQUIRE((filedesc = open(path, O_CREAT, o_mode)) != -1); \ FILE *pipefd = setup(fds, class); \ ATF_REQUIRE(syscall(SYS_open, path, flag) != -1); \ check_audit(fds, extregex, pipefd); \ + close(filedesc); \ } \ ATF_TC_CLEANUP(open_ ## mode ## _success, tc) \ { \ cleanup(); \ } \ ATF_TC_WITH_CLEANUP(open_ ## mode ## _failure); \ ATF_TC_HEAD(open_ ## mode ## _failure, tc) \ { \ atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " \ "open(2) call with flags = %s", #flag); \ } \ ATF_TC_BODY(open_ ## mode ## _failure, tc) \ { \ snprintf(extregex, sizeof(extregex), \ "open.*%s.*fileforaudit.*return,failure", regex); \ FILE *pipefd = setup(fds, class); \ ATF_REQUIRE_EQ(-1, syscall(SYS_open, errpath, flag)); \ check_audit(fds, extregex, pipefd); \ } \ ATF_TC_CLEANUP(open_ ## mode ## _failure, tc) \ { \ cleanup(); \ } \ ATF_TC_WITH_CLEANUP(openat_ ## mode ## _success); \ ATF_TC_HEAD(openat_ ## mode ## _success, tc) \ { \ atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " \ "openat(2) call with flags = %s", #flag); \ } \ ATF_TC_BODY(openat_ ## mode ## _success, tc) \ { \ + int filedesc2; \ snprintf(extregex, sizeof(extregex), \ "openat.*%s.*fileforaudit.*return,success", regex); \ /* File needs to exist for successful openat(2) invocation */ \ - ATF_REQUIRE(open(path, O_CREAT, o_mode) != -1); \ + ATF_REQUIRE((filedesc = open(path, O_CREAT, o_mode)) != -1); \ FILE *pipefd = setup(fds, class); \ - ATF_REQUIRE(openat(AT_FDCWD, path, flag) != -1); \ + ATF_REQUIRE((filedesc2 = openat(AT_FDCWD, path, flag)) != -1); \ check_audit(fds, extregex, pipefd); \ + close(filedesc2); \ + close(filedesc); \ } \ ATF_TC_CLEANUP(openat_ ## mode ## _success, tc) \ { \ cleanup(); \ } \ ATF_TC_WITH_CLEANUP(openat_ ## mode ## _failure); \ ATF_TC_HEAD(openat_ ## mode ## _failure, tc) \ { \ atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " \ "openat(2) call with flags = %s", #flag); \ } \ ATF_TC_BODY(openat_ ## mode ## _failure, tc) \ { \ snprintf(extregex, sizeof(extregex), \ "openat.*%s.*fileforaudit.*return,failure", regex); \ FILE *pipefd = setup(fds, class); \ ATF_REQUIRE_EQ(-1, openat(AT_FDCWD, errpath, flag)); \ check_audit(fds, extregex, pipefd); \ } \ ATF_TC_CLEANUP(openat_ ## mode ## _failure, tc) \ { \ cleanup(); \ } /* * Add both success and failure modes of open(2) and openat(2) */ #define OPEN_AT_TC_ADD(tp, mode) \ do { \ ATF_TP_ADD_TC(tp, open_ ## mode ## _success); \ ATF_TP_ADD_TC(tp, open_ ## mode ## _failure); \ ATF_TP_ADD_TC(tp, openat_ ## mode ## _success); \ ATF_TP_ADD_TC(tp, openat_ ## mode ## _failure); \ } while (0) /* * Each of the 12 OPEN_AT_TC_DEFINE statement is a group of 4 test-cases * corresponding to separate audit events for open(2) and openat(2) */ OPEN_AT_TC_DEFINE(read, "read", O_RDONLY, "fr") OPEN_AT_TC_DEFINE(read_creat, "read,creat", O_RDONLY | O_CREAT, "fr") OPEN_AT_TC_DEFINE(read_trunc, "read,trunc", O_RDONLY | O_TRUNC, "fr") OPEN_AT_TC_DEFINE(read_creat_trunc, "read,creat,trunc", O_RDONLY | O_CREAT | O_TRUNC, "fr") OPEN_AT_TC_DEFINE(write, "write", O_WRONLY, "fw") OPEN_AT_TC_DEFINE(write_creat, "write,creat", O_WRONLY | O_CREAT, "fw") OPEN_AT_TC_DEFINE(write_trunc, "write,trunc", O_WRONLY | O_TRUNC, "fw") OPEN_AT_TC_DEFINE(write_creat_trunc, "write,creat,trunc", O_WRONLY | O_CREAT | O_TRUNC, "fw") OPEN_AT_TC_DEFINE(read_write, "read,write", O_RDWR, "fr") OPEN_AT_TC_DEFINE(read_write_creat, "read,write,creat", O_RDWR | O_CREAT, "fw") OPEN_AT_TC_DEFINE(read_write_trunc, "read,write,trunc", O_RDWR | O_TRUNC, "fr") OPEN_AT_TC_DEFINE(read_write_creat_trunc, "read,write,creat,trunc", O_RDWR | O_CREAT | O_TRUNC, "fw") ATF_TP_ADD_TCS(tp) { OPEN_AT_TC_ADD(tp, read); OPEN_AT_TC_ADD(tp, read_creat); OPEN_AT_TC_ADD(tp, read_trunc); OPEN_AT_TC_ADD(tp, read_creat_trunc); OPEN_AT_TC_ADD(tp, write); OPEN_AT_TC_ADD(tp, write_creat); OPEN_AT_TC_ADD(tp, write_trunc); OPEN_AT_TC_ADD(tp, write_creat_trunc); OPEN_AT_TC_ADD(tp, read_write); OPEN_AT_TC_ADD(tp, read_write_creat); OPEN_AT_TC_ADD(tp, read_write_trunc); OPEN_AT_TC_ADD(tp, read_write_creat_trunc); return (atf_no_error()); } Index: head/tests/sys/audit/utils.c =================================================================== --- head/tests/sys/audit/utils.c (revision 335066) +++ head/tests/sys/audit/utils.c (revision 335067) @@ -1,233 +1,233 @@ /*- * Copyright 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * SUCH DAMAGE. * * $FreeBSD$ */ #include -#include +#include +#include + +#include #include #include -#include -#include #include +#include +#include #include -#include -#include #include "utils.h" /* * Checks the presence of "auditregex" in auditpipe(4) after the * corresponding system call has been triggered. */ static bool get_records(const char *auditregex, FILE *pipestream) { uint8_t *buff; tokenstr_t token; ssize_t size = 1024; char membuff[size]; char del[] = ","; int reclen, bytes = 0; FILE *memstream; /* * Open a stream on 'membuff' (address to memory buffer) for storing * the audit records in the default mode.'reclen' is the length of the * available records from auditpipe which is passed to the functions * au_fetch_tok(3) and au_print_flags_tok(3) for further use. */ ATF_REQUIRE((memstream = fmemopen(membuff, size, "w")) != NULL); ATF_REQUIRE((reclen = au_read_rec(pipestream, &buff)) != -1); /* * Iterate through each BSM token, extracting the bits that are * required to start processing the token sequences. */ while (bytes < reclen) { if (au_fetch_tok(&token, buff + bytes, reclen - bytes) == -1) { perror("au_read_rec"); atf_tc_fail("Incomplete Audit Record"); } /* Print the tokens as they are obtained, in the default form */ au_print_flags_tok(memstream, &token, del, AU_OFLAG_NONE); bytes += token.len; } free(buff); - fclose(memstream); + ATF_REQUIRE_EQ(0, fclose(memstream)); return (atf_utils_grep_string("%s", membuff, auditregex)); } /* * Override the system-wide audit mask settings in /etc/security/audit_control * and set the auditpipe's maximum allowed queue length limit */ static void set_preselect_mode(int filedesc, au_mask_t *fmask) { int qlimit_max; int fmode = AUDITPIPE_PRESELECT_MODE_LOCAL; /* Set local preselection mode for auditing */ if (ioctl(filedesc, AUDITPIPE_SET_PRESELECT_MODE, &fmode) < 0) atf_tc_fail("Preselection mode: %s", strerror(errno)); /* Set local preselection flag corresponding to the audit_event */ if (ioctl(filedesc, AUDITPIPE_SET_PRESELECT_FLAGS, fmask) < 0) atf_tc_fail("Preselection flag: %s", strerror(errno)); /* Set local preselection flag for non-attributable audit_events */ if (ioctl(filedesc, AUDITPIPE_SET_PRESELECT_NAFLAGS, fmask) < 0) atf_tc_fail("Preselection naflag: %s", strerror(errno)); /* Query the maximum possible queue length limit for auditpipe */ if (ioctl(filedesc, AUDITPIPE_GET_QLIMIT_MAX, &qlimit_max) < 0) atf_tc_fail("Query max-limit: %s", strerror(errno)); /* Set the queue length limit as obtained from previous step */ if (ioctl(filedesc, AUDITPIPE_SET_QLIMIT, &qlimit_max) < 0) atf_tc_fail("Set max-qlimit: %s", strerror(errno)); /* This removes any outstanding record on the auditpipe */ if (ioctl(filedesc, AUDITPIPE_FLUSH) < 0) atf_tc_fail("Auditpipe flush: %s", strerror(errno)); } /* * Get the corresponding audit_mask for class-name "name" then set the * success and failure bits for fmask to be used as the ioctl argument */ static au_mask_t get_audit_mask(const char *name) { au_mask_t fmask; au_class_ent_t *class; ATF_REQUIRE((class = getauclassnam(name)) != NULL); fmask.am_success = class->ac_class; fmask.am_failure = class->ac_class; return (fmask); } /* * Loop until the auditpipe returns something, check if it is what * we want, else repeat the procedure until ppoll(2) times out. */ static void check_auditpipe(struct pollfd fd[], const char *auditregex, FILE *pipestream) { struct timespec currtime, endtime, timeout; /* Set the expire time for poll(2) while waiting for syscall audit */ ATF_REQUIRE_EQ(0, clock_gettime(CLOCK_MONOTONIC, &endtime)); endtime.tv_sec += 10; timeout.tv_nsec = endtime.tv_nsec; for (;;) { /* Update the time left for auditpipe to return any event */ ATF_REQUIRE_EQ(0, clock_gettime(CLOCK_MONOTONIC, &currtime)); timeout.tv_sec = endtime.tv_sec - currtime.tv_sec; switch (ppoll(fd, 1, &timeout, NULL)) { /* ppoll(2) returns, check if it's what we want */ case 1: if (fd[0].revents & POLLIN) { if (get_records(auditregex, pipestream)) return; } else { atf_tc_fail("Auditpipe returned an " "unknown event %#x", fd[0].revents); } break; /* poll(2) timed out */ case 0: atf_tc_fail("%s not found in auditpipe within the " "time limit", auditregex); break; /* poll(2) standard error */ case -1: atf_tc_fail("Poll: %s", strerror(errno)); break; default: atf_tc_fail("Poll returned too many file descriptors"); } } } /* * Wrapper functions around static "check_auditpipe" */ static void check_audit_startup(struct pollfd fd[], const char *auditrgx, FILE *pipestream){ check_auditpipe(fd, auditrgx, pipestream); } void check_audit(struct pollfd fd[], const char *auditrgx, FILE *pipestream) { check_auditpipe(fd, auditrgx, pipestream); - /* Cleanup */ - fclose(pipestream); - close(fd[0].fd); + /* Teardown: /dev/auditpipe's instance opened for this test-suite */ + ATF_REQUIRE_EQ(0, fclose(pipestream)); } FILE *setup(struct pollfd fd[], const char *name) { au_mask_t fmask, nomask; fmask = get_audit_mask(name); nomask = get_audit_mask("no"); FILE *pipestream; - fd[0].fd = open("/dev/auditpipe", O_RDONLY); + ATF_REQUIRE((fd[0].fd = open("/dev/auditpipe", O_RDONLY)) != -1); + ATF_REQUIRE((pipestream = fdopen(fd[0].fd, "r")) != NULL); fd[0].events = POLLIN; - pipestream = fdopen(fd[0].fd, "r"); /* Set local preselection audit_class as "no" for audit startup */ set_preselect_mode(fd[0].fd, &nomask); ATF_REQUIRE_EQ(0, system("service auditd onestatus || \ { service auditd onestart && touch started_auditd ; }")); /* If 'started_auditd' exists, that means we started auditd(8) */ if (atf_utils_file_exists("started_auditd")) check_audit_startup(fd, "audit startup", pipestream); /* Set local preselection parameters specific to "name" audit_class */ set_preselect_mode(fd[0].fd, &fmask); return (pipestream); } void cleanup(void) { if (atf_utils_file_exists("started_auditd")) system("service auditd onestop > /dev/null 2>&1"); }