summaryrefslogtreecommitdiffstats
path: root/tools
diff options
context:
space:
mode:
authorpjd <pjd@FreeBSD.org>2013-03-02 00:56:53 +0000
committerpjd <pjd@FreeBSD.org>2013-03-02 00:56:53 +0000
commit782c8022a25e4abf89eefcab8b95ee74400b7caf (patch)
treedaceb7a0c6155bf90d4768e11ea312cfb9bce4a1 /tools
parent48e0f13795816420f399e2606735c7ef9dab3d7c (diff)
downloadFreeBSD-src-782c8022a25e4abf89eefcab8b95ee74400b7caf.zip
FreeBSD-src-782c8022a25e4abf89eefcab8b95ee74400b7caf.tar.gz
Update existing regression tests after Capsicum overhaul.
Diffstat (limited to 'tools')
-rw-r--r--tools/regression/security/cap_test/cap_test_capabilities.c447
-rw-r--r--tools/regression/security/cap_test/cap_test_relative.c3
2 files changed, 349 insertions, 101 deletions
diff --git a/tools/regression/security/cap_test/cap_test_capabilities.c b/tools/regression/security/cap_test/cap_test_capabilities.c
index 450ad88..b6423f8 100644
--- a/tools/regression/security/cap_test/cap_test_capabilities.c
+++ b/tools/regression/security/cap_test/cap_test_capabilities.c
@@ -1,8 +1,12 @@
/*-
* Copyright (c) 2009-2011 Robert N. M. Watson
* Copyright (c) 2011 Jonathan Anderson
+ * Copyright (c) 2012 FreeBSD Foundation
* All rights reserved.
*
+ * Portions of this software were developed by Pawel Jakub Dawidek under
+ * sponsorship from the FreeBSD Foundation.
+ *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
@@ -43,6 +47,7 @@ __FBSDID("$FreeBSD$");
#include <err.h>
#include <fcntl.h>
#include <poll.h>
+#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -60,14 +65,20 @@ __FBSDID("$FreeBSD$");
*/
#define CHECK_RESULT(syscall, rights_needed, succeeded) do { \
if ((rights & (rights_needed)) == (rights_needed)) { \
- if (!(succeeded)) \
+ if (succeeded) { \
+ if (success == -1) \
+ success = PASSED; \
+ } else { \
SYSCALL_FAIL(syscall, "failed"); \
+ } \
} else { \
- if (succeeded) \
+ if (succeeded) { \
FAILX("%s:\tsucceeded when it shouldn't have" \
- " (rights 0x%jx)", #syscall, rights); \
- else if (errno != ENOTCAPABLE) \
+ " (rights 0x%jx)", #syscall, \
+ (uintmax_t)rights); \
+ } else if (errno != ENOTCAPABLE) { \
SYSCALL_FAIL(syscall, "errno != ENOTCAPABLE"); \
+ } \
} \
errno = 0; \
} while (0)
@@ -79,8 +90,11 @@ __FBSDID("$FreeBSD$");
if ((rights & (rights_needed)) == (rights_needed)) { \
if (p == MAP_FAILED) \
SYSCALL_FAIL(mmap, "failed"); \
- else \
+ else { \
(void)munmap(p, getpagesize()); \
+ if (success == -1) \
+ success = PASSED; \
+ } \
} else { \
if (p != MAP_FAILED) { \
FAILX("%s:\tsucceeded when it shouldn't have" \
@@ -97,96 +111,200 @@ __FBSDID("$FreeBSD$");
* make sure only those rights work.
*/
static int
-try_file_ops(int fd, cap_rights_t rights)
+try_file_ops(int filefd, int dirfd, cap_rights_t rights)
{
struct stat sb;
struct statfs sf;
- int fd_cap, fd_capcap;
+ cap_rights_t erights;
+ int fd_cap, fd_capcap, dfd_cap;
ssize_t ssize, ssize2;
off_t off;
void *p;
char ch;
int ret, is_nfs;
struct pollfd pollfd;
- int success = PASSED;
+ int success = -1;
- REQUIRE(fstatfs(fd, &sf));
- is_nfs = (strncmp("nfs", sf.f_fstypename, sizeof(sf.f_fstypename))
- == 0);
+ REQUIRE(fstatfs(filefd, &sf));
+ is_nfs = (strcmp("nfs", sf.f_fstypename) == 0);
- REQUIRE(fd_cap = cap_new(fd, rights));
+ REQUIRE(fd_cap = cap_new(filefd, rights));
+ CHECK(cap_getrights(fd_cap, &erights) == 0);
+ CHECK(rights == erights);
REQUIRE(fd_capcap = cap_new(fd_cap, rights));
+ CHECK(cap_getrights(fd_capcap, &erights) == 0);
+ CHECK(rights == erights);
CHECK(fd_capcap != fd_cap);
-
- pollfd.fd = fd_cap;
- pollfd.events = POLLIN | POLLERR | POLLHUP;
- pollfd.revents = 0;
+ REQUIRE(dfd_cap = cap_new(dirfd, rights));
+ CHECK(cap_getrights(dfd_cap, &erights) == 0);
+ CHECK(rights == erights);
ssize = read(fd_cap, &ch, sizeof(ch));
- CHECK_RESULT(read, CAP_READ | CAP_SEEK, ssize >= 0);
-
- ssize = pread(fd_cap, &ch, sizeof(ch), 0);
- ssize2 = pread(fd_cap, &ch, sizeof(ch), 0);
- CHECK_RESULT(pread, CAP_READ, ssize >= 0);
- CHECK(ssize == ssize2);
+ CHECK_RESULT(read, CAP_READ, ssize >= 0);
ssize = write(fd_cap, &ch, sizeof(ch));
- CHECK_RESULT(write, CAP_WRITE | CAP_SEEK, ssize >= 0);
-
- ssize = pwrite(fd_cap, &ch, sizeof(ch), 0);
- CHECK_RESULT(pwrite, CAP_WRITE, ssize >= 0);
+ CHECK_RESULT(write, CAP_WRITE, ssize >= 0);
off = lseek(fd_cap, 0, SEEK_SET);
CHECK_RESULT(lseek, CAP_SEEK, off >= 0);
- /*
- * Note: this is not expected to work over NFS.
- */
- ret = fchflags(fd_cap, UF_NODUMP);
- CHECK_RESULT(fchflags, CAP_FCHFLAGS,
- (ret == 0) || (is_nfs && (errno == EOPNOTSUPP)));
+ ssize = pread(fd_cap, &ch, sizeof(ch), 0);
+ ssize2 = pread(fd_cap, &ch, sizeof(ch), 0);
+ CHECK_RESULT(pread, CAP_PREAD, ssize >= 0);
+ CHECK(ssize == ssize2);
- ret = fstat(fd_cap, &sb);
- CHECK_RESULT(fstat, CAP_FSTAT, ret == 0);
+ ssize = pwrite(fd_cap, &ch, sizeof(ch), 0);
+ CHECK_RESULT(pwrite, CAP_PWRITE, ssize >= 0);
+
+ p = mmap(NULL, getpagesize(), PROT_NONE, MAP_SHARED, fd_cap, 0);
+ CHECK_MMAP_RESULT(CAP_MMAP);
p = mmap(NULL, getpagesize(), PROT_READ, MAP_SHARED, fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_READ);
+ CHECK_MMAP_RESULT(CAP_MMAP_R);
p = mmap(NULL, getpagesize(), PROT_WRITE, MAP_SHARED, fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_WRITE);
+ CHECK_MMAP_RESULT(CAP_MMAP_W);
p = mmap(NULL, getpagesize(), PROT_EXEC, MAP_SHARED, fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_MAPEXEC);
+ CHECK_MMAP_RESULT(CAP_MMAP_X);
p = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED,
fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_READ | CAP_WRITE);
+ CHECK_MMAP_RESULT(CAP_MMAP_RW);
p = mmap(NULL, getpagesize(), PROT_READ | PROT_EXEC, MAP_SHARED,
fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_READ | CAP_MAPEXEC);
+ CHECK_MMAP_RESULT(CAP_MMAP_RX);
p = mmap(NULL, getpagesize(), PROT_EXEC | PROT_WRITE, MAP_SHARED,
fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_MAPEXEC | CAP_WRITE);
+ CHECK_MMAP_RESULT(CAP_MMAP_WX);
p = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_SHARED, fd_cap, 0);
- CHECK_MMAP_RESULT(CAP_MMAP | CAP_READ | CAP_WRITE | CAP_MAPEXEC);
+ CHECK_MMAP_RESULT(CAP_MMAP_RWX);
+
+ /* TODO: openat(O_APPEND) */
+ ret = openat(dfd_cap, "cap_create", O_CREAT | O_RDONLY, 0600);
+ CHECK_RESULT(openat(O_CREATE | O_RDONLY),
+ CAP_CREATE | CAP_READ | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_create", 0) == 0);
+ ret = openat(dfd_cap, "cap_create", O_CREAT | O_WRONLY, 0600);
+ CHECK_RESULT(openat(O_CREATE | O_WRONLY),
+ CAP_CREATE | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_create", 0) == 0);
+ ret = openat(dfd_cap, "cap_create", O_CREAT | O_RDWR, 0600);
+ CHECK_RESULT(openat(O_CREATE | O_RDWR),
+ CAP_CREATE | CAP_READ | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_create", 0) == 0);
ret = fsync(fd_cap);
CHECK_RESULT(fsync, CAP_FSYNC, ret == 0);
+ ret = openat(dirfd, "cap_fsync", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = openat(dfd_cap, "cap_fsync", O_FSYNC | O_RDONLY, 0600);
+ CHECK_RESULT(openat(O_FSYNC | O_RDONLY),
+ CAP_FSYNC | CAP_READ | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_fsync", O_FSYNC | O_WRONLY, 0600);
+ CHECK_RESULT(openat(O_FSYNC | O_WRONLY),
+ CAP_FSYNC | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_fsync", O_FSYNC | O_RDWR, 0600);
+ CHECK_RESULT(openat(O_FSYNC | O_RDWR),
+ CAP_FSYNC | CAP_READ | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_fsync", O_SYNC | O_RDONLY, 0600);
+ CHECK_RESULT(openat(O_SYNC | O_RDONLY),
+ CAP_FSYNC | CAP_READ | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_fsync", O_SYNC | O_WRONLY, 0600);
+ CHECK_RESULT(openat(O_SYNC | O_WRONLY),
+ CAP_FSYNC | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_fsync", O_SYNC | O_RDWR, 0600);
+ CHECK_RESULT(openat(O_SYNC | O_RDWR),
+ CAP_FSYNC | CAP_READ | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ CHECK(unlinkat(dirfd, "cap_fsync", 0) == 0);
+
+ ret = ftruncate(fd_cap, 0);
+ CHECK_RESULT(ftruncate, CAP_FTRUNCATE, ret == 0);
+
+ ret = openat(dirfd, "cap_ftruncate", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = openat(dfd_cap, "cap_ftruncate", O_TRUNC | O_RDONLY);
+ CHECK_RESULT(openat(O_TRUNC | O_RDONLY),
+ CAP_FTRUNCATE | CAP_READ | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_ftruncate", O_TRUNC | O_WRONLY);
+ CHECK_RESULT(openat(O_TRUNC | O_WRONLY),
+ CAP_FTRUNCATE | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ ret = openat(dfd_cap, "cap_ftruncate", O_TRUNC | O_RDWR);
+ CHECK_RESULT(openat(O_TRUNC | O_RDWR),
+ CAP_FTRUNCATE | CAP_READ | CAP_WRITE | CAP_LOOKUP, ret >= 0);
+ CHECK(ret == -1 || close(ret) == 0);
+ CHECK(unlinkat(dirfd, "cap_ftruncate", 0) == 0);
+
+ /*
+ * Note: this is not expected to work over NFS.
+ */
+ ret = fchflags(fd_cap, UF_NODUMP);
+ CHECK_RESULT(fchflags, CAP_FCHFLAGS,
+ ret == 0 || (is_nfs && errno == EOPNOTSUPP));
+
+#ifdef TODO /* No such syscalls yet. */
+ ret = openat(dirfd, "cap_fchflagsat", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = fchflagsat(dfd_cap, "cap_fchflagsat", UF_NODUMP, 0);
+ CHECK_RESULT(fchflagsat, CAP_FCHFLAGSAT | CAP_LOOKUP, ret == 0);
+ CHECK(unlinkat(dirfd, "cap_fchflagsat", 0) == 0);
+#endif
+
ret = fchown(fd_cap, -1, -1);
CHECK_RESULT(fchown, CAP_FCHOWN, ret == 0);
+ ret = openat(dirfd, "cap_fchownat", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = fchownat(dfd_cap, "cap_fchownat", -1, -1, 0);
+ CHECK_RESULT(fchownat, CAP_FCHOWN | CAP_LOOKUP, ret == 0);
+ CHECK(unlinkat(dirfd, "cap_fchownat", 0) == 0);
+
ret = fchmod(fd_cap, 0644);
CHECK_RESULT(fchmod, CAP_FCHMOD, ret == 0);
+ ret = openat(dirfd, "cap_fchmodat", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = fchmodat(dfd_cap, "cap_fchmodat", 0600, 0);
+ CHECK_RESULT(fchmodat, CAP_FCHMOD | CAP_LOOKUP, ret == 0);
+ CHECK(unlinkat(dirfd, "cap_fchmodat", 0) == 0);
+
+ ret = fcntl(fd_cap, F_GETFL);
+ CHECK_RESULT(fcntl(F_GETFL), CAP_FCNTL, ret >= 0);
+ ret = fcntl(fd_cap, F_SETFL, ret);
+ CHECK_RESULT(fcntl(F_SETFL), CAP_FCNTL, ret == 0);
+
/* XXX flock */
- ret = ftruncate(fd_cap, 0);
- CHECK_RESULT(ftruncate, CAP_FTRUNCATE, ret == 0);
+ ret = fstat(fd_cap, &sb);
+ CHECK_RESULT(fstat, CAP_FSTAT, ret == 0);
+
+ ret = openat(dirfd, "cap_fstatat", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = fstatat(dfd_cap, "cap_fstatat", &sb, 0);
+ CHECK_RESULT(fstatat, CAP_FSTAT | CAP_LOOKUP, ret == 0);
+ CHECK(unlinkat(dirfd, "cap_fstatat", 0) == 0);
ret = fstatfs(fd_cap, &sf);
CHECK_RESULT(fstatfs, CAP_FSTATFS, ret == 0);
@@ -197,6 +315,55 @@ try_file_ops(int fd, cap_rights_t rights)
ret = futimes(fd_cap, NULL);
CHECK_RESULT(futimes, CAP_FUTIMES, ret == 0);
+ ret = openat(dirfd, "cap_futimesat", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = futimesat(dfd_cap, "cap_futimesat", NULL);
+ CHECK_RESULT(futimesat, CAP_FUTIMES | CAP_LOOKUP, ret == 0);
+ CHECK(unlinkat(dirfd, "cap_futimesat", 0) == 0);
+
+ ret = openat(dirfd, "cap_linkat_src", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = linkat(dirfd, "cap_linkat_src", dfd_cap, "cap_linkat_dst", 0);
+ CHECK_RESULT(linkat, CAP_LINKAT | CAP_LOOKUP, ret == 0);
+ CHECK(unlinkat(dirfd, "cap_linkat_src", 0) == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_linkat_dst", 0) == 0);
+
+ ret = mkdirat(dfd_cap, "cap_mkdirat", 0700);
+ CHECK_RESULT(mkdirat, CAP_MKDIRAT | CAP_LOOKUP, ret == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_mkdirat", AT_REMOVEDIR) == 0);
+
+ ret = mkfifoat(dfd_cap, "cap_mkfifoat", 0600);
+ CHECK_RESULT(mkfifoat, CAP_MKFIFOAT | CAP_LOOKUP, ret == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_mkfifoat", 0) == 0);
+
+ ret = mknodat(dfd_cap, "cap_mknodat", S_IFCHR | 0600, 0);
+ CHECK_RESULT(mknodat, CAP_MKNODAT | CAP_LOOKUP, ret == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_mknodat", 0) == 0);
+
+ /* TODO: renameat(2) */
+
+ ret = symlinkat("test", dfd_cap, "cap_symlinkat");
+ CHECK_RESULT(symlinkat, CAP_SYMLINKAT | CAP_LOOKUP, ret == 0);
+ CHECK(ret == -1 || unlinkat(dirfd, "cap_symlinkat", 0) == 0);
+
+ ret = openat(dirfd, "cap_unlinkat", O_CREAT, 0600);
+ CHECK(ret >= 0);
+ CHECK(close(ret) == 0);
+ ret = unlinkat(dfd_cap, "cap_unlinkat", 0);
+ CHECK_RESULT(unlinkat, CAP_UNLINKAT | CAP_LOOKUP, ret == 0);
+ CHECK(ret == 0 || unlinkat(dirfd, "cap_unlinkat", 0) == 0);
+ ret = mkdirat(dirfd, "cap_unlinkat", 0700);
+ CHECK(ret == 0);
+ ret = unlinkat(dfd_cap, "cap_unlinkat", AT_REMOVEDIR);
+ CHECK_RESULT(unlinkat, CAP_UNLINKAT | CAP_LOOKUP, ret == 0);
+ CHECK(ret == 0 || unlinkat(dirfd, "cap_unlinkat", AT_REMOVEDIR) == 0);
+
+ pollfd.fd = fd_cap;
+ pollfd.events = POLLIN | POLLERR | POLLHUP;
+ pollfd.revents = 0;
+
ret = poll(&pollfd, 1, 0);
if (rights & CAP_POLL_EVENT)
CHECK((pollfd.revents & POLLNVAL) == 0);
@@ -205,79 +372,159 @@ try_file_ops(int fd, cap_rights_t rights)
/* XXX: select, kqueue */
- close (fd_cap);
+ close(fd_cap);
+ close(fd_capcap);
+
+ if (success == -1) {
+ fprintf(stderr, "No tests for rights 0x%jx.\n",
+ (uintmax_t)rights);
+ success = FAILED;
+ }
return (success);
}
-#define TRY(fd, rights) \
+#define TRY(rights) \
do { \
if (success == PASSED) \
- success = try_file_ops(fd, rights); \
+ success = try_file_ops(filefd, dirfd, (rights)); \
else \
/* We've already failed, but try the test anyway. */ \
- try_file_ops(fd, rights); \
+ try_file_ops(filefd, dirfd, (rights)); \
} while (0)
+#define KEEP_ERRNO(...) do { \
+ int _saved_errno = errno; \
+ __VA_ARGS__; \
+ errno = _saved_errno; \
+} while (0);
+
int
test_capabilities(void)
{
- int fd;
+ int filefd, dirfd, tmpfd;
int success = PASSED;
-
- fd = open("/tmp/cap_test_capabilities", O_RDWR | O_CREAT, 0644);
- if (fd < 0)
+ char file[] = "/tmp/cap_test.XXXXXXXXXX";
+ char dir[] = "/tmp/cap_test.XXXXXXXXXX";
+
+ filefd = mkstemp(file);
+ if (filefd < 0)
+ err(-1, "mkstemp");
+ if (mkdtemp(dir) == NULL) {
+ KEEP_ERRNO(unlink(file));
+ err(-1, "mkdtemp");
+ }
+ dirfd = open(dir, O_RDONLY | O_DIRECTORY);
+ if (dirfd == -1) {
+ KEEP_ERRNO(unlink(file));
+ KEEP_ERRNO(rmdir(dir));
err(-1, "open");
+ }
+ tmpfd = open("/tmp", O_RDONLY | O_DIRECTORY);
+ if (tmpfd == -1) {
+ KEEP_ERRNO(unlink(file));
+ KEEP_ERRNO(rmdir(dir));
+ err(-1, "open");
+ }
- if (cap_enter() < 0)
+ if (cap_enter() == -1) {
+ KEEP_ERRNO(unlink(file));
+ KEEP_ERRNO(rmdir(dir));
err(-1, "cap_enter");
-
- /* XXX: Really want to try all combinations. */
- TRY(fd, CAP_READ);
- TRY(fd, CAP_READ | CAP_SEEK);
- TRY(fd, CAP_WRITE);
- TRY(fd, CAP_WRITE | CAP_SEEK);
- TRY(fd, CAP_READ | CAP_WRITE);
- TRY(fd, CAP_READ | CAP_WRITE | CAP_SEEK);
- TRY(fd, CAP_SEEK);
- TRY(fd, CAP_FCHFLAGS);
- TRY(fd, CAP_IOCTL);
- TRY(fd, CAP_FSTAT);
- TRY(fd, CAP_MMAP);
- TRY(fd, CAP_MMAP | CAP_READ);
- TRY(fd, CAP_MMAP | CAP_WRITE);
- TRY(fd, CAP_MMAP | CAP_MAPEXEC);
- TRY(fd, CAP_MMAP | CAP_READ | CAP_WRITE);
- TRY(fd, CAP_MMAP | CAP_READ | CAP_MAPEXEC);
- TRY(fd, CAP_MMAP | CAP_MAPEXEC | CAP_WRITE);
- TRY(fd, CAP_MMAP | CAP_READ | CAP_WRITE | CAP_MAPEXEC);
- TRY(fd, CAP_FCNTL);
- TRY(fd, CAP_POST_EVENT);
- TRY(fd, CAP_POLL_EVENT);
- TRY(fd, CAP_FSYNC);
- TRY(fd, CAP_FCHOWN);
- TRY(fd, CAP_FCHMOD);
- TRY(fd, CAP_FTRUNCATE);
- TRY(fd, CAP_FLOCK);
- TRY(fd, CAP_FSTATFS);
- TRY(fd, CAP_FPATHCONF);
- TRY(fd, CAP_FUTIMES);
- TRY(fd, CAP_ACL_GET);
- TRY(fd, CAP_ACL_SET);
- TRY(fd, CAP_ACL_DELETE);
- TRY(fd, CAP_ACL_CHECK);
- TRY(fd, CAP_EXTATTR_GET);
- TRY(fd, CAP_EXTATTR_SET);
- TRY(fd, CAP_EXTATTR_DELETE);
- TRY(fd, CAP_EXTATTR_LIST);
- TRY(fd, CAP_MAC_GET);
- TRY(fd, CAP_MAC_SET);
-
- /*
- * Socket-specific.
- */
- TRY(fd, CAP_GETPEERNAME);
- TRY(fd, CAP_GETSOCKNAME);
- TRY(fd, CAP_ACCEPT);
+ }
+
+ TRY(CAP_READ);
+ TRY(CAP_WRITE);
+ TRY(CAP_SEEK);
+ TRY(CAP_PREAD);
+ TRY(CAP_PWRITE);
+ TRY(CAP_READ | CAP_WRITE);
+ TRY(CAP_PREAD | CAP_PWRITE);
+ TRY(CAP_MMAP);
+ TRY(CAP_MMAP_R);
+ TRY(CAP_MMAP_W);
+ TRY(CAP_MMAP_X);
+ TRY(CAP_MMAP_RW);
+ TRY(CAP_MMAP_RX);
+ TRY(CAP_MMAP_WX);
+ TRY(CAP_MMAP_RWX);
+ TRY(CAP_CREATE | CAP_READ | CAP_LOOKUP);
+ TRY(CAP_CREATE | CAP_WRITE | CAP_LOOKUP);
+ TRY(CAP_CREATE | CAP_READ | CAP_WRITE | CAP_LOOKUP);
+#ifdef TODO
+ TRY(CAP_FEXECVE);
+#endif
+ TRY(CAP_FSYNC);
+ TRY(CAP_FSYNC | CAP_READ | CAP_LOOKUP);
+ TRY(CAP_FSYNC | CAP_WRITE | CAP_LOOKUP);
+ TRY(CAP_FSYNC | CAP_READ | CAP_WRITE | CAP_LOOKUP);
+ TRY(CAP_FTRUNCATE);
+ TRY(CAP_FTRUNCATE | CAP_READ | CAP_LOOKUP);
+ TRY(CAP_FTRUNCATE | CAP_WRITE | CAP_LOOKUP);
+ TRY(CAP_FTRUNCATE | CAP_READ | CAP_WRITE | CAP_LOOKUP);
+#ifdef TODO
+ TRY(CAP_FCHDIR);
+#endif
+ TRY(CAP_FCHFLAGS);
+ TRY(CAP_FCHOWN);
+ TRY(CAP_FCHOWN | CAP_LOOKUP);
+ TRY(CAP_FCHMOD | CAP_LOOKUP);
+ TRY(CAP_FCNTL);
+#ifdef TODO
+ TRY(CAP_FLOCK);
+#endif
+ TRY(CAP_FPATHCONF);
+#ifdef TODO
+ TRY(CAP_FSCK);
+#endif
+ TRY(CAP_FSTAT | CAP_LOOKUP);
+ TRY(CAP_FSTATFS);
+ TRY(CAP_FUTIMES | CAP_LOOKUP);
+ TRY(CAP_LINKAT | CAP_LOOKUP);
+ TRY(CAP_MKDIRAT | CAP_LOOKUP);
+ TRY(CAP_MKFIFOAT | CAP_LOOKUP);
+ TRY(CAP_MKNODAT | CAP_LOOKUP);
+ TRY(CAP_SYMLINKAT | CAP_LOOKUP);
+ TRY(CAP_UNLINKAT | CAP_LOOKUP);
+ /* Rename needs CAP_RENAMEAT on source directory and CAP_LINKAT on destination directory. */
+ TRY(CAP_RENAMEAT | CAP_UNLINKAT | CAP_LOOKUP);
+#ifdef TODO
+ TRY(CAP_LOOKUP);
+ TRY(CAP_EXTATTR_DELETE);
+ TRY(CAP_EXTATTR_GET);
+ TRY(CAP_EXTATTR_LIST);
+ TRY(CAP_EXTATTR_SET);
+ TRY(CAP_ACL_CHECK);
+ TRY(CAP_ACL_DELETE);
+ TRY(CAP_ACL_GET);
+ TRY(CAP_ACL_SET);
+ TRY(CAP_ACCEPT);
+ TRY(CAP_BIND);
+ TRY(CAP_CONNECT);
+ TRY(CAP_GETPEERNAME);
+ TRY(CAP_GETSOCKNAME);
+ TRY(CAP_GETSOCKOPT);
+ TRY(CAP_LISTEN);
+ TRY(CAP_PEELOFF);
+ TRY(CAP_RECV);
+ TRY(CAP_SEND);
+ TRY(CAP_SETSOCKOPT);
+ TRY(CAP_SHUTDOWN);
+ TRY(CAP_MAC_GET);
+ TRY(CAP_MAC_SET);
+ TRY(CAP_SEM_GETVALUE);
+ TRY(CAP_SEM_POST);
+ TRY(CAP_SEM_WAIT);
+ TRY(CAP_POST_EVENT);
+ TRY(CAP_POLL_EVENT);
+ TRY(CAP_IOCTL);
+ TRY(CAP_TTYHOOK);
+ TRY(CAP_PDGETPID);
+ TRY(CAP_PDWAIT);
+ TRY(CAP_PDKILL);
+#endif
+
+ (void)unlinkat(tmpfd, file + strlen("/tmp/"), 0);
+ (void)unlinkat(tmpfd, dir + strlen("/tmp/"), AT_REMOVEDIR);
return (success);
}
diff --git a/tools/regression/security/cap_test/cap_test_relative.c b/tools/regression/security/cap_test/cap_test_relative.c
index 1f62e84..27410eb 100644
--- a/tools/regression/security/cap_test/cap_test_relative.c
+++ b/tools/regression/security/cap_test/cap_test_relative.c
@@ -61,7 +61,8 @@ test_relative(void)
cap_rights_t rights;
REQUIRE(etc = open("/etc/", O_RDONLY));
- CHECK_SYSCALL_FAILS(EINVAL, cap_getrights, etc, &rights);
+ CHECK_SYSCALL_SUCCEEDS(cap_getrights, etc, &rights);
+ CHECK_RIGHTS(rights, CAP_ALL);
MAKE_CAPABILITY(etc_cap, etc, CAP_READ);
MAKE_CAPABILITY(etc_cap_ro, etc, CAP_READ | CAP_LOOKUP);
OpenPOWER on IntegriCloud