socsvn commit: r337266 - soc2018/aniketp/head/tests/sys/audit
aniketp at FreeBSD.org
aniketp at FreeBSD.org
Fri Jun 29 19:39:07 UTC 2018
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 ***
More information about the svn-soc-all
mailing list