Date: Fri, 29 Jun 2018 19:39:02 GMT From: aniketp@FreeBSD.org To: svn-soc-all@FreeBSD.org Subject: socsvn commit: r337266 - soc2018/aniketp/head/tests/sys/audit Message-ID: <201806291939.w5TJd27x010161@socsvn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: aniketp Date: Fri Jun 29 19:38:59 2018 New Revision: 337266 URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=337266 Log: Proposed work complete: 375 tests for 175 system calls Expected failures to be added Modified: soc2018/aniketp/head/tests/sys/audit/Makefile soc2018/aniketp/head/tests/sys/audit/administrative.c soc2018/aniketp/head/tests/sys/audit/file-attribute-access.c soc2018/aniketp/head/tests/sys/audit/file-attribute-modify.c soc2018/aniketp/head/tests/sys/audit/inter-process.c soc2018/aniketp/head/tests/sys/audit/ioctl.c soc2018/aniketp/head/tests/sys/audit/network.c soc2018/aniketp/head/tests/sys/audit/open.c soc2018/aniketp/head/tests/sys/audit/process-control.c Modified: soc2018/aniketp/head/tests/sys/audit/Makefile ============================================================================== --- soc2018/aniketp/head/tests/sys/audit/Makefile Wed Jun 27 16:17:21 2018 (r337265) +++ soc2018/aniketp/head/tests/sys/audit/Makefile Fri Jun 29 19:38:59 2018 (r337266) @@ -3,15 +3,23 @@ TESTSDIR= ${TESTSBASE}/sys/audit ATF_TESTS_C= file-attribute-access +ATF_TESTS_C+= file-attribute-modify ATF_TESTS_C+= file-create ATF_TESTS_C+= file-delete ATF_TESTS_C+= file-close ATF_TESTS_C+= file-write ATF_TESTS_C+= file-read ATF_TESTS_C+= open +ATF_TESTS_C+= ioctl +ATF_TESTS_C+= network +ATF_TESTS_C+= inter-process +ATF_TESTS_C+= administrative +ATF_TESTS_C+= process-control SRCS.file-attribute-access+= file-attribute-access.c SRCS.file-attribute-access+= utils.c +SRCS.file-attribute-modify+= file-attribute-modify.c +SRCS.file-attribute-modify+= utils.c SRCS.file-create+= file-create.c SRCS.file-create+= utils.c SRCS.file-delete+= file-delete.c @@ -24,6 +32,16 @@ SRCS.file-read+= utils.c SRCS.open+= open.c SRCS.open+= utils.c +SRCS.ioctl+= ioctl.c +SRCS.ioctl+= utils.c +SRCS.network+= network.c +SRCS.network+= utils.c +SRCS.inter-process+= inter-process.c +SRCS.inter-process+= utils.c +SRCS.administrative+= administrative.c +SRCS.administrative+= utils.c +SRCS.process-control+= process-control.c +SRCS.process-control+= utils.c TEST_METADATA+= timeout="30" TEST_METADATA+= required_user="root" Modified: soc2018/aniketp/head/tests/sys/audit/administrative.c ============================================================================== --- soc2018/aniketp/head/tests/sys/audit/administrative.c Wed Jun 27 16:17:21 2018 (r337265) +++ soc2018/aniketp/head/tests/sys/audit/administrative.c Fri Jun 29 19:38:59 2018 (r337266) @@ -1,6 +1,5 @@ /*- - * Copyright 2018 Aniket Pandey - * All rights reserved. + * Copyright (c) 2018 Aniket Pandey * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -30,8 +29,13 @@ #include <sys/mount.h> #include <sys/reboot.h> #include <sys/stat.h> +#include <sys/sysctl.h> #include <sys/time.h> +#include <sys/timespec.h> #include <sys/timex.h> + +#include <bsm/audit.h> +#include <bsm/audit_kevents.h> #include <ufs/ufs/quota.h> #include <atf-c.h> @@ -39,15 +43,17 @@ #include <stdlib.h> #include <time.h> #include <unistd.h> -#include <bsm/audit.h> #include "utils.h" static pid_t pid; +static int filedesc; static mode_t mode = 0777; static struct pollfd fds[1]; -static char adregex[60]; +static char adregex[80]; +static const char *auclass = "ad"; static const char *path = "fileforaudit"; +static const char *successreg = "fileforaudit.*return,success"; ATF_TC_WITH_CLEANUP(settimeofday_success); @@ -60,13 +66,13 @@ ATF_TC_BODY(settimeofday_success, tc) { pid = getpid(); - snprintf(adregex, 60, "settimeofday.*%d.*return,success", pid); + snprintf(adregex, sizeof(adregex), "settimeofday.*%d.*success", pid); struct timeval tp; struct timezone tzp; ATF_REQUIRE_EQ(0, gettimeofday(&tp, &tzp)); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); /* Setting the same time as obtained by gettimeofday(2) */ ATF_REQUIRE_EQ(0, settimeofday(&tp, &tzp)); check_audit(fds, adregex, pipefd); @@ -88,15 +94,15 @@ ATF_TC_BODY(settimeofday_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "settimeofday.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "settimeofday.*%d.*failure", pid); struct timeval tp; struct timezone tzp; ATF_REQUIRE_EQ(0, gettimeofday(&tp, &tzp)); - FILE *pipefd = setup(fds, "ad"); - /* Invalid value for tp.tv_sec; */ + FILE *pipefd = setup(fds, auclass); tp.tv_sec = -1; + /* Failure reason: Invalid value for tp.tv_sec; */ ATF_REQUIRE_EQ(-1, settimeofday(&tp, &tzp)); check_audit(fds, adregex, pipefd); } @@ -107,6 +113,60 @@ } +ATF_TC_WITH_CLEANUP(clock_settime_success); +ATF_TC_HEAD(clock_settime_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "clock_settime(2) call"); +} + +ATF_TC_BODY(clock_settime_success, tc) +{ + pid = getpid(); + snprintf(adregex, sizeof(adregex), "clock_settime.*%d.*success", pid); + + struct timespec tp; + ATF_REQUIRE_EQ(0, clock_gettime(CLOCK_REALTIME, &tp)); + + FILE *pipefd = setup(fds, auclass); + /* Setting the same time as obtained by clock_gettime(2) */ + ATF_REQUIRE_EQ(0, clock_settime(CLOCK_REALTIME, &tp)); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(clock_settime_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(clock_settime_failure); +ATF_TC_HEAD(clock_settime_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "clock_settime(2) call"); +} + +ATF_TC_BODY(clock_settime_failure, tc) +{ + pid = getpid(); + snprintf(adregex, sizeof(adregex), "clock_settime.*%d.*failure", pid); + + struct timespec tp; + ATF_REQUIRE_EQ(0, clock_gettime(CLOCK_MONOTONIC, &tp)); + + FILE *pipefd = setup(fds, auclass); + /* Failure reason: cannot use CLOCK_MONOTONIC to set the system time */ + ATF_REQUIRE_EQ(-1, clock_settime(CLOCK_MONOTONIC, &tp)); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(clock_settime_failure, tc) +{ + cleanup(); +} + + ATF_TC_WITH_CLEANUP(adjtime_success); ATF_TC_HEAD(adjtime_success, tc) { @@ -117,11 +177,11 @@ ATF_TC_BODY(adjtime_success, tc) { pid = getpid(); - snprintf(adregex, 60, "adjtime.*%d.*return,success", pid); + snprintf(adregex, sizeof(adregex), "adjtime.*%d.*return,success", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); /* We don't want to change the system time, hence NULL */ - ATF_REQUIRE_EQ(0, adjtime(NULL,NULL)); + ATF_REQUIRE_EQ(0, adjtime(NULL, NULL)); check_audit(fds, adregex, pipefd); } @@ -141,9 +201,9 @@ ATF_TC_BODY(adjtime_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "adjtime.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "adjtime.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(-1, adjtime((struct timeval *)(-1), NULL)); check_audit(fds, adregex, pipefd); } @@ -154,6 +214,54 @@ } +ATF_TC_WITH_CLEANUP(ntp_adjtime_success); +ATF_TC_HEAD(ntp_adjtime_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "ntp_adjtime(2) call"); +} + +ATF_TC_BODY(ntp_adjtime_success, tc) +{ + struct timex timebuff; + bzero(&timebuff, sizeof(timebuff)); + + pid = getpid(); + snprintf(adregex, sizeof(adregex), "ntp_adjtime.*%d.*success", pid); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE(ntp_adjtime(&timebuff) != -1); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(ntp_adjtime_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(ntp_adjtime_failure); +ATF_TC_HEAD(ntp_adjtime_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "ntp_adjtime(2) call"); +} + +ATF_TC_BODY(ntp_adjtime_failure, tc) +{ + pid = getpid(); + snprintf(adregex, sizeof(adregex), "ntp_adjtime.*%d.*failure", pid); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(-1, ntp_adjtime(NULL)); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(ntp_adjtime_failure, tc) +{ + cleanup(); +} + ATF_TC_WITH_CLEANUP(nfs_getfh_success); ATF_TC_HEAD(nfs_getfh_success, tc) @@ -166,13 +274,14 @@ { fhandle_t fhp; pid = getpid(); - snprintf(adregex, 60, "nfs_getfh.*%d.*return,success", pid); + snprintf(adregex, sizeof(adregex), "nfs_getfh.*%d.*ret.*success", pid); /* File needs to exist to call getfh(2) */ - ATF_REQUIRE(open(path, O_CREAT, mode) != -1); - FILE *pipefd = setup(fds, "ad"); + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, getfh(path, &fhp)); check_audit(fds, adregex, pipefd); + close(filedesc); } ATF_TC_CLEANUP(nfs_getfh_success, tc) @@ -191,9 +300,9 @@ ATF_TC_BODY(nfs_getfh_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "nfs_getfh.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "nfs_getfh.*%d.*ret.*failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); /* Failure reason: file does not exist */ ATF_REQUIRE_EQ(-1, getfh(path, NULL)); check_audit(fds, adregex, pipefd); @@ -205,6 +314,188 @@ } +ATF_TC_WITH_CLEANUP(auditctl_success); +ATF_TC_HEAD(auditctl_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "auditctl(2) call"); +} + +ATF_TC_BODY(auditctl_success, tc) +{ + /* File needs to exist in order to call auditctl(2) */ + ATF_REQUIRE((filedesc = open(path, O_CREAT | O_WRONLY, mode)) != -1); + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, auditctl(path)); + check_audit(fds, successreg, pipefd); + close(filedesc); +} + +ATF_TC_CLEANUP(auditctl_success, tc) +{ + /* + * auditctl(2) disables audit log at /var/audit and initiates auditing + * at the configured path. To reset this, we need to stop and start the + * auditd(8) again. Here, we check if auditd(8) was running already + * before the test started. If so, we stop and start it again. + */ + system("service auditd onestop > /dev/null 2>&1"); + if (!atf_utils_file_exists("started_auditd")) + system("service auditd onestart > /dev/null 2>&1"); +} + + +ATF_TC_WITH_CLEANUP(auditctl_failure); +ATF_TC_HEAD(auditctl_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "auditctl(2) call"); +} + +ATF_TC_BODY(auditctl_failure, tc) +{ + pid = getpid(); + snprintf(adregex, sizeof(adregex), "auditctl.*%d.*return,failure", pid); + + FILE *pipefd = setup(fds, auclass); + /* Failure reason: file does not exist */ + ATF_REQUIRE_EQ(-1, auditctl(NULL)); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(auditctl_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(auditon_success); +ATF_TC_HEAD(auditon_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "auditon(2) call"); +} + +ATF_TC_BODY(auditon_success, tc) +{ + pid = getpid(); + au_evclass_map_t evclass; + snprintf(adregex, sizeof(adregex), "auditon.*%d.*return,success", pid); + + /* Initialize evclass to get the event-class mapping for auditon(2) */ + evclass.ec_number = AUE_AUDITON; + evclass.ec_class = 0; + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, auditon(A_GETCLASS, &evclass, sizeof(&evclass))); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(auditon_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(auditon_failure); +ATF_TC_HEAD(auditon_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "auditon(2) call"); +} + +ATF_TC_BODY(auditon_failure, tc) +{ + pid = getpid(); + snprintf(adregex, sizeof(adregex), "auditon.*%d.*return,failure", pid); + + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Invalid au_evclass_map_t structure */ + ATF_REQUIRE_EQ(-1, auditon(A_GETCLASS, NULL, 0)); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(auditon_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(acct_success); +ATF_TC_HEAD(acct_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "acct(2) call"); +} + +ATF_TC_BODY(acct_success, tc) +{ + int acctinfo, filedesc2; + size_t len = sizeof(acctinfo); + const char *acctname = "kern.acct_configured"; + ATF_REQUIRE_EQ(0, sysctlbyname(acctname, &acctinfo, &len, NULL, 0)); + + /* File needs to exist to start system accounting */ + ATF_REQUIRE((filedesc = open(path, O_CREAT | O_RDWR, mode)) != -1); + + /* + * acctinfo = 0: System accounting was disabled + * acctinfo = 1: System accounting was enabled + */ + if (acctinfo) { + ATF_REQUIRE((filedesc2 = open("acct_ok", O_CREAT, mode)) != -1); + close(filedesc2); + } + + pid = getpid(); + snprintf(adregex, sizeof(adregex), + "acct.*%s.*%d.*return,success", path, pid); + + /* + * We temporarily switch the accounting record to a file at + * our own configured path in order to confirm acct(2)'s successful + * auditing. Then we set everything back to its original state. + */ + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, acct(path)); + check_audit(fds, adregex, pipefd); + close(filedesc); +} + +ATF_TC_CLEANUP(acct_success, tc) +{ + /* Reset accounting configured path */ + ATF_REQUIRE_EQ(0, system("service accounting onestop")); + if (atf_utils_file_exists("acct_ok")) { + ATF_REQUIRE_EQ(0, system("service accounting onestart")); + } + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(acct_failure); +ATF_TC_HEAD(acct_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "acct(2) call"); +} + +ATF_TC_BODY(acct_failure, tc) +{ + pid = getpid(); + snprintf(adregex, sizeof(adregex), "acct.*%d.*return,failure", pid); + + FILE *pipefd = setup(fds, auclass); + /* Failure reason: File does not exist */ + ATF_REQUIRE_EQ(-1, acct(path)); + check_audit(fds, adregex, pipefd); +} + +ATF_TC_CLEANUP(acct_failure, tc) +{ + cleanup(); +} + + ATF_TC_WITH_CLEANUP(getauid_success); ATF_TC_HEAD(getauid_success, tc) { @@ -216,9 +507,9 @@ { au_id_t auid; pid = getpid(); - snprintf(adregex, 60, "getauid.*%d.*return,success", pid); + snprintf(adregex, sizeof(adregex), "getauid.*%d.*return,success", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, getauid(&auid)); check_audit(fds, adregex, pipefd); } @@ -239,9 +530,10 @@ ATF_TC_BODY(getauid_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "getauid.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "getauid.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Bad address */ ATF_REQUIRE_EQ(-1, getauid(NULL)); check_audit(fds, adregex, pipefd); } @@ -263,10 +555,10 @@ { au_id_t auid; pid = getpid(); - snprintf(adregex, 60, "setauid.*%d.*return,success", pid); + snprintf(adregex, sizeof(adregex), "setauid.*%d.*return,success", pid); ATF_REQUIRE_EQ(0, getauid(&auid)); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, setauid(&auid)); check_audit(fds, adregex, pipefd); } @@ -287,9 +579,10 @@ ATF_TC_BODY(setauid_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "setauid.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "setauid.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Bad address */ ATF_REQUIRE_EQ(-1, setauid(NULL)); check_audit(fds, adregex, pipefd); } @@ -309,11 +602,11 @@ ATF_TC_BODY(getaudit_success, tc) { - auditinfo_t auditinfo; pid = getpid(); - snprintf(adregex, 60, "getaudit.*%d.*return,success", pid); + auditinfo_t auditinfo; + snprintf(adregex, sizeof(adregex), "getaudit.*%d.*return,success", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, getaudit(&auditinfo)); check_audit(fds, adregex, pipefd); } @@ -334,9 +627,10 @@ ATF_TC_BODY(getaudit_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "getaudit.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "getaudit.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Bad address */ ATF_REQUIRE_EQ(-1, getaudit(NULL)); check_audit(fds, adregex, pipefd); } @@ -356,12 +650,12 @@ ATF_TC_BODY(setaudit_success, tc) { - auditinfo_t auditinfo; pid = getpid(); - snprintf(adregex, 60, "setaudit.*%d.*return,success", pid); + auditinfo_t auditinfo; + snprintf(adregex, sizeof(adregex), "setaudit.*%d.*return,success", pid); ATF_REQUIRE_EQ(0, getaudit(&auditinfo)); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(0, setaudit(&auditinfo)); check_audit(fds, adregex, pipefd); } @@ -382,9 +676,10 @@ ATF_TC_BODY(setaudit_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "setaudit.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "setaudit.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Bad address */ ATF_REQUIRE_EQ(-1, setaudit(NULL)); check_audit(fds, adregex, pipefd); } @@ -404,13 +699,13 @@ ATF_TC_BODY(getaudit_addr_success, tc) { - auditinfo_addr_t auditinfo; - u_int *length = (u_int *)malloc(sizeof(u_int)); pid = getpid(); - snprintf(adregex, 60, "getaudit_addr.*%d.*return,success", pid); + auditinfo_addr_t auditinfo; + snprintf(adregex, sizeof(adregex), + "getaudit_addr.*%d.*return,success", pid); - FILE *pipefd = setup(fds, "ad"); - ATF_REQUIRE_EQ(0, getaudit_addr(&auditinfo, *length)); + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, getaudit_addr(&auditinfo, sizeof(auditinfo))); check_audit(fds, adregex, pipefd); } @@ -430,9 +725,11 @@ ATF_TC_BODY(getaudit_addr_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "getaudit_addr.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), + "getaudit_addr.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Bad address */ ATF_REQUIRE_EQ(-1, getaudit_addr(NULL, 0)); check_audit(fds, adregex, pipefd); } @@ -452,14 +749,14 @@ ATF_TC_BODY(setaudit_addr_success, tc) { - auditinfo_addr_t auditinfo; - u_int *length = (u_int *)malloc(sizeof(u_int)); pid = getpid(); - snprintf(adregex, 60, "setaudit_addr.*%d.*return,success", pid); - ATF_REQUIRE_EQ(0, getaudit_addr(&auditinfo, *length)); + auditinfo_addr_t auditinfo; + snprintf(adregex, sizeof(adregex), + "setaudit_addr.*%d.*return,success", pid); - FILE *pipefd = setup(fds, "ad"); - ATF_REQUIRE_EQ(0, setaudit_addr(&auditinfo, *length)); + ATF_REQUIRE_EQ(0, getaudit_addr(&auditinfo, sizeof(auditinfo))); + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, setaudit_addr(&auditinfo, sizeof(auditinfo))); check_audit(fds, adregex, pipefd); } @@ -479,9 +776,11 @@ ATF_TC_BODY(setaudit_addr_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "setaudit_addr.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), + "setaudit_addr.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Bad address */ ATF_REQUIRE_EQ(-1, setaudit_addr(NULL, 0)); check_audit(fds, adregex, pipefd); } @@ -508,9 +807,9 @@ ATF_TC_BODY(reboot_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "reboot.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "reboot.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(-1, reboot(-1)); check_audit(fds, adregex, pipefd); } @@ -522,35 +821,6 @@ /* - * Audit of acct(2) cannot be tested in normal conditions as we don't want - * to enable/disable the collection of system accounting records - */ - - -ATF_TC_WITH_CLEANUP(acct_failure); -ATF_TC_HEAD(acct_failure, tc) -{ - atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " - "acct(2) call"); -} - -ATF_TC_BODY(acct_failure, tc) -{ - pid = getpid(); - snprintf(adregex, 60, "acct.*%d.*return,failure", pid); - - FILE *pipefd = setup(fds, "ad"); - ATF_REQUIRE_EQ(-1, acct(path)); - check_audit(fds, adregex, pipefd); -} - -ATF_TC_CLEANUP(acct_failure, tc) -{ - cleanup(); -} - - -/* * Audit of quotactl(2) cannot be tested in normal conditions as we don't want * to tamper with filesystem quotas */ @@ -566,9 +836,9 @@ ATF_TC_BODY(quotactl_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "quotactl.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "quotactl.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(-1, quotactl(NULL, 0, 0, NULL)); check_audit(fds, adregex, pipefd); } @@ -579,12 +849,6 @@ } -/* - * Audit of mount(2) and nmount(2) cannot be tested in normal - * conditions as we are not allowed to mount a filesystem. - */ - - ATF_TC_WITH_CLEANUP(mount_failure); ATF_TC_HEAD(mount_failure, tc) { @@ -595,9 +859,9 @@ ATF_TC_BODY(mount_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "mount.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "mount.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(-1, mount(NULL, NULL, 0, NULL)); check_audit(fds, adregex, pipefd); } @@ -618,9 +882,9 @@ ATF_TC_BODY(nmount_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "nmount.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "nmount.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); + FILE *pipefd = setup(fds, auclass); ATF_REQUIRE_EQ(-1, nmount(NULL, 0, 0)); check_audit(fds, adregex, pipefd); } @@ -631,62 +895,74 @@ } -ATF_TC_WITH_CLEANUP(ntp_adjtime_failure); -ATF_TC_HEAD(ntp_adjtime_failure, tc) +ATF_TC_WITH_CLEANUP(swapon_failure); +ATF_TC_HEAD(swapon_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " - "ntp_adjtime(2) call"); + "swapon(2) call"); } -ATF_TC_BODY(ntp_adjtime_failure, tc) +ATF_TC_BODY(swapon_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "ntp_adjtime.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "swapon.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); - ATF_REQUIRE_EQ(-1, ntp_adjtime(NULL)); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Block device required */ + ATF_REQUIRE_EQ(-1, swapon(path)); check_audit(fds, adregex, pipefd); } -ATF_TC_CLEANUP(ntp_adjtime_failure, tc) +ATF_TC_CLEANUP(swapon_failure, tc) { cleanup(); } -ATF_TC_WITH_CLEANUP(auditctl_failure); -ATF_TC_HEAD(auditctl_failure, tc) +ATF_TC_WITH_CLEANUP(swapoff_failure); +ATF_TC_HEAD(swapoff_failure, tc) { atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " - "auditctl(2) call"); + "swapoff(2) call"); } -ATF_TC_BODY(auditctl_failure, tc) +ATF_TC_BODY(swapoff_failure, tc) { pid = getpid(); - snprintf(adregex, 60, "auditctl.*%d.*return,failure", pid); + snprintf(adregex, sizeof(adregex), "swapoff.*%d.*return,failure", pid); - FILE *pipefd = setup(fds, "ad"); - ATF_REQUIRE_EQ(-1, auditctl(NULL)); + FILE *pipefd = setup(fds, auclass); + /* Failure reason: Block device required */ + ATF_REQUIRE_EQ(-1, swapoff(path)); check_audit(fds, adregex, pipefd); } -ATF_TC_CLEANUP(auditctl_failure, tc) +ATF_TC_CLEANUP(swapoff_failure, tc) { cleanup(); } - ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, settimeofday_success); ATF_TP_ADD_TC(tp, settimeofday_failure); + ATF_TP_ADD_TC(tp, clock_settime_success); + ATF_TP_ADD_TC(tp, clock_settime_failure); ATF_TP_ADD_TC(tp, adjtime_success); ATF_TP_ADD_TC(tp, adjtime_failure); + ATF_TP_ADD_TC(tp, ntp_adjtime_success); + ATF_TP_ADD_TC(tp, ntp_adjtime_failure); ATF_TP_ADD_TC(tp, nfs_getfh_success); ATF_TP_ADD_TC(tp, nfs_getfh_failure); + ATF_TP_ADD_TC(tp, acct_success); + ATF_TP_ADD_TC(tp, acct_failure); + + ATF_TP_ADD_TC(tp, auditctl_success); + ATF_TP_ADD_TC(tp, auditctl_failure); + ATF_TP_ADD_TC(tp, auditon_success); + ATF_TP_ADD_TC(tp, auditon_failure); ATF_TP_ADD_TC(tp, getauid_success); ATF_TP_ADD_TC(tp, getauid_failure); @@ -704,13 +980,11 @@ ATF_TP_ADD_TC(tp, setaudit_addr_failure); ATF_TP_ADD_TC(tp, reboot_failure); - ATF_TP_ADD_TC(tp, acct_failure); ATF_TP_ADD_TC(tp, quotactl_failure); ATF_TP_ADD_TC(tp, mount_failure); ATF_TP_ADD_TC(tp, nmount_failure); - ATF_TP_ADD_TC(tp, ntp_adjtime_failure); - ATF_TP_ADD_TC(tp, auditctl_failure); + ATF_TP_ADD_TC(tp, swapon_failure); + ATF_TP_ADD_TC(tp, swapoff_failure); return (atf_no_error()); } - Modified: soc2018/aniketp/head/tests/sys/audit/file-attribute-access.c ============================================================================== --- soc2018/aniketp/head/tests/sys/audit/file-attribute-access.c Wed Jun 27 16:17:21 2018 (r337265) +++ soc2018/aniketp/head/tests/sys/audit/file-attribute-access.c Fri Jun 29 19:38:59 2018 (r337266) @@ -26,6 +26,7 @@ */ #include <sys/param.h> +#include <sys/extattr.h> #include <sys/ucred.h> #include <sys/mount.h> #include <sys/stat.h> @@ -40,11 +41,14 @@ static struct pollfd fds[1]; static mode_t mode = 0777; static pid_t pid; -static int filedesc; +static fhandle_t fht; +static int filedesc, fhdesc; static char extregex[80]; +static char buff[] = "ezio"; static struct stat statbuff; static struct statfs statfsbuff; static const char *auclass = "fa"; +static const char *name = "authorname"; static const char *path = "fileforaudit"; static const char *errpath = "dirdoesnotexist/fileforaudit"; static const char *successreg = "fileforaudit.*return,success"; @@ -370,6 +374,768 @@ } +ATF_TC_WITH_CLEANUP(fhopen_success); +ATF_TC_HEAD(fhopen_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "fhopen(2) call"); +} + +ATF_TC_BODY(fhopen_success, tc) +{ + pid = getpid(); + snprintf(extregex, sizeof(extregex), "fhopen.*%d.*return,success", pid); + + /* File needs to exist to get a file-handle */ + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); + /* Get the file handle to be passed to fhopen(2) */ + ATF_REQUIRE_EQ(0, getfh(path, &fht)); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE((fhdesc = fhopen(&fht, O_RDWR)) != -1); + check_audit(fds, extregex, pipefd); + + close(fhdesc); + close(filedesc); +} + +ATF_TC_CLEANUP(fhopen_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(fhopen_failure); +ATF_TC_HEAD(fhopen_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "fhopen(2) call"); +} + +ATF_TC_BODY(fhopen_failure, tc) +{ + const char *regex = "fhopen.*return,failure : Invalid argument"; + FILE *pipefd = setup(fds, auclass); + /* + * Failure reason: NULL does not represent any file handle + * and O_CREAT is not allowed as the flag for fhopen(2) + */ + ATF_REQUIRE_EQ(-1, fhopen(NULL, O_CREAT)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(fhopen_failure, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(fhstat_success); +ATF_TC_HEAD(fhstat_success, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of a successful " + "fstat(2) call"); +} + +ATF_TC_BODY(fhstat_success, tc) +{ + pid = getpid(); + snprintf(extregex, sizeof(extregex), "fhstat.*%d.*return,success", pid); + + /* File needs to exist to get a file-handle */ + ATF_REQUIRE((filedesc = open(path, O_CREAT, mode)) != -1); + /* Get the file handle to be passed to fhstat(2) */ + ATF_REQUIRE_EQ(0, getfh(path, &fht)); + + FILE *pipefd = setup(fds, auclass); + ATF_REQUIRE_EQ(0, fhstat(&fht, &statbuff)); + check_audit(fds, extregex, pipefd); + close(filedesc); +} + +ATF_TC_CLEANUP(fhstat_success, tc) +{ + cleanup(); +} + + +ATF_TC_WITH_CLEANUP(fhstat_failure); +ATF_TC_HEAD(fhstat_failure, tc) +{ + atf_tc_set_md_var(tc, "descr", "Tests the audit of an unsuccessful " + "fhstat(2) call"); +} + +ATF_TC_BODY(fhstat_failure, tc) +{ + const char *regex = "fhstat.*return,failure : Bad address"; + FILE *pipefd = setup(fds, auclass); + /* Failure reason: NULL does not represent any file handle */ + ATF_REQUIRE_EQ(-1, fhstat(NULL, NULL)); + check_audit(fds, regex, pipefd); +} + +ATF_TC_CLEANUP(fhstat_failure, tc) +{ + cleanup(); +} *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201806291939.w5TJd27x010161>