Skip to contentSkip to conversation

selftests/landlock: Add tests for io_uring openat access control with Landlock rules

PATCH Superseded Dorine Tipo 2 participants 4 messages Mar 30, 2024 – Apr 4, 2024

Subsystems (3)

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/1 selftests/landlock: Add tests for io_uring openat access control with Landlock rules

This v3 patch expands Landlock test coverage to include io_uring operations. It also introduces a test for IORING_OP_OPENAT with Landlock rules, verifying allowed and disallowed access. This makes sure that IORING_OP_OPENAT is well covered from security vulnerabilities by ensuring Landlock controls access through io_uring.

It also updates Makefile to include -luring in the LDLIBS variable. This ensures the test code has access to the necessary library for io_uring operations.

The patch includes several improvements to the test_ioring_openat(), FIXTURE_SETUP() and FIXTURE_TEARDOWN() addressing feedback received on the initial version.

---
Changes since V1:
V2: - Consolidated two dependent patches in the V1 series into one patch
as suggested by Fabio.
- Updated The subject line to be more descriptive.

V3: - Added "selftests/landlock" subject prefix
- Revised wording in the commit message to accurately reflect the test functionality as suggested by Mickaël.
- Updated the Fixture set_up and tear_down to create and remove the necesssary files and folders for testing access.
- renamed allowed_ruleset_fd and disallowed_ruleset_fd to ruleset_fd as suggest by Mickaël.
- Moved all variable declarations to the top of the function.
- Refactored the code to test only one allowed and one restricted path instead of iterating through all the paths.
- Added comments to explain what is happening in different blocks of code
- Removed the clang-format markers.
- Removed unused arguments in the function definition.
- Added a final rule struct with a null path to the allowed_rule and disallowed_rule arrays as suggested by Fabio.
- CC'd the missing mailing lists as suggested by Shuah.
- All executables have been included in the .gitignore so no updates are necessary.

 tools/testing/selftests/landlock/Makefile  |   4 +-
 tools/testing/selftests/landlock/fs_test.c | 140 +++++++++++++++++++++
 2 files changed, 142 insertions(+), 2 deletions(-)
tools/testing/selftests/landlock/Makefile +2 -2
index 348e2dbdb4e0..ab47d1dadb62 100644
@@ -13,11 +13,11 @@ TEST_GEN_PROGS := $(src_test:.c=)
 TEST_GEN_PROGS_EXTENDED := true
 
 # Short targets:
-$(TEST_GEN_PROGS): LDLIBS += -lcap
+$(TEST_GEN_PROGS): LDLIBS += -lcap -luring
 $(TEST_GEN_PROGS_EXTENDED): LDFLAGS += -static
 
 include ../lib.mk
 
 # Targets with $(OUTPUT)/ prefix:
-$(TEST_GEN_PROGS): LDLIBS += -lcap
+$(TEST_GEN_PROGS): LDLIBS += -lcap -luring
 $(TEST_GEN_PROGS_EXTENDED): LDFLAGS += -static
tools/testing/selftests/landlock/fs_test.c +140 -0

151 lines not on this page · raw message

--
2.25.1

maintainer
#1 lore raw
Quoted 79 lines · Dorine Tipo

This v3 patch expands Landlock test coverage to include io_uring operations. It also introduces a test for IORING_OP_OPENAT with Landlock rules, verifying allowed and disallowed access. This makes sure that IORING_OP_OPENAT is well covered from security vulnerabilities by ensuring Landlock controls access through io_uring.

It also updates Makefile to include -luring in the LDLIBS variable. This ensures the test code has access to the necessary library for io_uring operations.

The patch includes several improvements to the test_ioring_openat(), FIXTURE_SETUP() and FIXTURE_TEARDOWN() addressing feedback received on the initial version.

---
Changes since V1:
V2: - Consolidated two dependent patches in the V1 series into one patch
as suggested by Fabio.
- Updated The subject line to be more descriptive.

V3: - Added "selftests/landlock" subject prefix
- Revised wording in the commit message to accurately reflect the test functionality as suggested by Mickaël.
- Updated the Fixture set_up and tear_down to create and remove the necesssary files and folders for testing access.
- renamed allowed_ruleset_fd and disallowed_ruleset_fd to ruleset_fd as suggest by Mickaël.
- Moved all variable declarations to the top of the function.
- Refactored the code to test only one allowed and one restricted path instead of iterating through all the paths.
- Added comments to explain what is happening in different blocks of code
- Removed the clang-format markers.
- Removed unused arguments in the function definition.
- Added a final rule struct with a null path to the allowed_rule and disallowed_rule arrays as suggested by Fabio.
- CC'd the missing mailing lists as suggested by Shuah.
- All executables have been included in the .gitignore so no updates are necessary.

 tools/testing/selftests/landlock/Makefile  |   4 +-
 tools/testing/selftests/landlock/fs_test.c | 140 +++++++++++++++++++++
 2 files changed, 142 insertions(+), 2 deletions(-)
tools/testing/selftests/landlock/Makefile +2 -2
index 348e2dbdb4e0..ab47d1dadb62 100644
@@ -13,11 +13,11 @@ TEST_GEN_PROGS := $(src_test:.c=)
 TEST_GEN_PROGS_EXTENDED := true
 
 # Short targets:
-$(TEST_GEN_PROGS): LDLIBS += -lcap
+$(TEST_GEN_PROGS): LDLIBS += -lcap -luring
 $(TEST_GEN_PROGS_EXTENDED): LDFLAGS += -static
 
 include ../lib.mk
 
 # Targets with $(OUTPUT)/ prefix:
-$(TEST_GEN_PROGS): LDLIBS += -lcap
+$(TEST_GEN_PROGS): LDLIBS += -lcap -luring
 $(TEST_GEN_PROGS_EXTENDED): LDFLAGS += -static
tools/testing/selftests/landlock/fs_test.c +3 -0
index 9a6036fbf289..7147c75b6f79 100644
@@ -21,7 +21,10 @@
 #include <sys/stat.h>
 #include <sys/sysmacros.h>
 #include <sys/vfs.h>
+#include <sys/types.h>
 #include <unistd.h>
+#include <liburing.h>
+#include <linux/io_uring.h>
 
 #include "common.h"
 

tools/testing/selftests/landlock/fs_test.c TEST_F_FORK(layout3_fs, release_inodes) · line 4880

Quoted 4 lines
tools/testing/selftests/landlock/fs_test.c +1 -0
@@ -4874,4 +4877,141 @@ TEST_F_FORK(layout3_fs, release_inodes)
 	ASSERT_EQ(EACCES, test_open(TMP_DIR, O_RDONLY));
 }
 
+/* Test io_uring's IORING_OP_OPENAT access control with landlock rules */

What is tested exactly?

Quoted 21 lines
tools/testing/selftests/landlock/fs_test.c +21 -0
+static int test_ioring_op_openat(struct __test_metadata *const _metadata, const __u64 access, const char **paths)
+{
+	int ruleset_fd;
+	int ret;
+	struct io_uring ring;
+	struct io_uring_sqe *sqe;
+
+	/* Test Allowed Access */
+	const struct rule allowed_rule[] = {
+		{
+			.path = paths[0],
+			.access = access,
+		},
+		{
+			.path = NULL,
+		},
+	};
+
+	ruleset_fd = create_ruleset(_metadata, allowed_rule[0].access, allowed_rule);
+
+	ASSERT_LE(0, ruleset_fd);

tools/testing/selftests/landlock/fs_test.c TEST_F_FORK(layout3_fs, release_inodes) · line 4911

Quoted 10 lines
tools/testing/selftests/landlock/fs_test.c +10 -0
+
+	ret = io_uring_queue_init(32, &ring, 0);
+
+	ASSERT_EQ(0, ret);
+
+	/* Test allowed path */
+	sqe = io_uring_get_sqe(&ring);
+
+	/* Prepare SQE  for the openat operation */
+	io_uring_prep_openat(sqe, AT_FDCWD, paths[0], O_RDONLY, ruleset_fd);

Can you please explain what this call to io_uring_prep_openat() do?

Quoted 110 lines
tools/testing/selftests/landlock/fs_test.c +105 -1
+
+	/* Verify successful SQE preparation */
+	ASSERT_EQ(0, ret);
+
+	if (ret != 0)
+		return ret;
+
+	ret = io_uring_submit(&ring);
+
+	/* Verify 1 submission completed */
+	ASSERT_EQ(1, ret);
+
+	/* Test Disallowed Access */
+	const struct rule disallowed_rule[] = {
+		{
+			.path = paths[0],
+			.access = 0,
+		},
+		{
+			.path = NULL,
+		},
+	};
+
+	ruleset_fd = create_ruleset(_metadata, disallowed_rule[0].access, disallowed_rule);
+
+	ASSERT_LE(0, ruleset_fd);
+
+	/* Test disallowed path */
+	sqe = io_uring_get_sqe(&ring);
+
+	/* Prepare SQE  for the openat operation */
+	io_uring_prep_openat(sqe, AT_FDCWD, paths[0], O_RDONLY, ruleset_fd);
+
+	/* Verify successful SQE preparation */
+	ASSERT_EQ(0, ret);
+
+	if (ret != 0)
+		return ret;
+
+	ret = io_uring_submit(&ring);
+	/* Verify 1 submission completed */
+	ASSERT_EQ(0, ret);
+
+	/*  Cleanup: close ruleset fds, etc. */
+	close(ruleset_fd);
+
+	return 0;
+}
+
+FIXTURE(openat_test) {
+	struct __test_metadata *metadata;
+	const char *allowed_paths[11];
+	const char *disallowed_paths[2];
+};
+
+FIXTURE_SETUP(openat_test)
+{
+	/* initialize metadata, allowed_paths, and disallowed_paths */
+	self->metadata = _metadata;
+	const char *temp_allowed_paths[] = {
+		file1_s1d1, file2_s1d1, file1_s1d2, file2_s1d2,
+		file1_s1d3, file2_s1d3, file1_s2d1, file1_s2d2,
+		file1_s2d3, file2_s2d3, file1_s3d1};
+
+	memcpy(self->allowed_paths, temp_allowed_paths, sizeof(temp_allowed_paths));
+
+	const char *temp_disallowed_paths[] = {dir_s3d2, dir_s3d3};
+
+	memcpy(self->disallowed_paths, temp_disallowed_paths, sizeof(temp_disallowed_paths));
+
+	/* Create necessary directories and files */
+	for (int i = 0; i < sizeof(self->allowed_paths) / sizeof(char *); i++) {
+		create_file(self->metadata, self->allowed_paths[i]);
+	}
+
+	/* Create directories for disallowed paths */
+	for (int i = 0; i < sizeof(self->disallowed_paths) / sizeof(char *); i++) {
+		create_directory(self->metadata, self->disallowed_paths[i]);
+	}
+}
+
+FIXTURE_TEARDOWN(openat_test)
+{
+	/* Clean up test environment */
+	for (int i = 0; i < sizeof(self->allowed_paths) / sizeof(char *); i++) {
+		remove_path(self->allowed_paths[i]);
+	}
+
+	for (int i = 0; i < sizeof(self->disallowed_paths) / sizeof(char *); i++) {
+		remove_path(self->disallowed_paths[i]);
+	}
+}
+
+/* Test IORING_OP_OPENAT. */
+TEST_F_FORK(openat_test, test_ioring_op_openat_allowed)
+{
+	test_ioring_op_openat(self->metadata, LANDLOCK_ACCESS_FS_READ_FILE |
+			      LANDLOCK_ACCESS_FS_WRITE_FILE, self->allowed_paths);
+}
+
+TEST_F_FORK(openat_test, test_ioring_op_openat_disallowed)
+{
+	test_ioring_op_openat(self->metadata, 0, self->disallowed_paths);
+}
+
 TEST_HARNESS_MAIN
--

2.25.1

#2 lore raw

Subject: [PATCH v3] selftests/landlock: Add tests for io_uring openat access control with Landlock rules

Quoted 1 line

What is tested exactly?

The test_ioring_op_openat() function is testing the enforcement of Landlock rules for read-only access.
It's specifically checking whether the Landlock rules correctly allow or deny read-only access to the specified file when using the openat system call with io_uring. The test does this by preparing a submission queue entry for the openat operation with io_uring_prep_openat(), submitting this operation to the kernel via io_uring, and then checking the result. If the operation is successful, it means that Landlock allowed the read-only access as expected. If the operation fails, it means that Landlock correctly denied the access.

Quoted 32 lines
tools/testing/selftests/landlock/fs_test.c +31 -0
+static int test_ioring_op_openat(struct __test_metadata *const _metadata, const __u64 access, const char **paths)
+{
+     int ruleset_fd;
+     int ret;
+     struct io_uring ring;
+     struct io_uring_sqe *sqe;
+
+     /* Test Allowed Access */
+     const struct rule allowed_rule[] = {
+             {
+                     .path = paths[0],
+                     .access = access,
+             },
+             {
+                     .path = NULL,
+             },
+     };
+
+     ruleset_fd = create_ruleset(_metadata, allowed_rule[0].access, allowed_rule);
+
+     ASSERT_LE(0, ruleset_fd);
+
+     ret = io_uring_queue_init(32, &ring, 0);
+
+     ASSERT_EQ(0, ret);
+
+     /* Test allowed path */
+     sqe = io_uring_get_sqe(&ring);
+
+     /* Prepare SQE  for the openat operation */
+     io_uring_prep_openat(sqe, AT_FDCWD, paths[0], O_RDONLY, ruleset_fd);
Quoted 1 line

Can you please explain what this call to io_uring_prep_openat() do?

io_uring_prep_openat() prepares the submission queue entry for the openat system call. In my tests the call to io_uring_prep_openat() is preparing an openat operation to open a file at a certain path with read-only access. This operation is then submitted to the kernel via io_uring, and the test checks whether the operation is allowed or denied based on the define Landlock rules.

maintainer
#3 lore raw
Quoted 1 line

Subject: Re: your mail

There is an issue with the subject.

Quoted 13 lines · Dorine Tipo
Quoted 2 lines

What is tested exactly?

The test_ioring_op_openat() function is testing the enforcement of Landlock rules for read-only access.
It's specifically checking whether the Landlock rules correctly allow or deny read-only access to the specified file when using the openat system call with io_uring. The test does this by preparing a submission queue entry for the openat operation with io_uring_prep_openat(), submitting this operation to the kernel via io_uring, and then checking the result. If the operation is successful, it means that Landlock allowed the read-only access as expected. If the operation fails, it means that Landlock correctly denied the access.

That doesn't reflect the content of this patch.

Quoted 33 lines
Quoted 32 lines
tools/testing/selftests/landlock/fs_test.c +31 -0
+static int test_ioring_op_openat(struct __test_metadata *const _metadata, const __u64 access, const char **paths)
+{
+     int ruleset_fd;
+     int ret;
+     struct io_uring ring;
+     struct io_uring_sqe *sqe;
+
+     /* Test Allowed Access */
+     const struct rule allowed_rule[] = {
+             {
+                     .path = paths[0],
+                     .access = access,
+             },
+             {
+                     .path = NULL,
+             },
+     };
+
+     ruleset_fd = create_ruleset(_metadata, allowed_rule[0].access, allowed_rule);
+
+     ASSERT_LE(0, ruleset_fd);
+
+     ret = io_uring_queue_init(32, &ring, 0);
+
+     ASSERT_EQ(0, ret);
+
+     /* Test allowed path */
+     sqe = io_uring_get_sqe(&ring);
+
+     /* Prepare SQE  for the openat operation */
+     io_uring_prep_openat(sqe, AT_FDCWD, paths[0], O_RDONLY, ruleset_fd);
Quoted 8 lines
Quoted 1 line

Can you please explain what this call to io_uring_prep_openat() do?

io_uring_prep_openat() prepares the submission queue entry for the openat system call. In my tests the call to io_uring_prep_openat() is preparing an openat operation to open a file at a certain path with read-only access. This operation is then submitted to the kernel via io_uring, and the test checks whether the operation is allowed or denied based on the define Landlock rules.

This is not what is tested by this patch.

What is the last argument of io_uring_prep_openat()? Did you write this code?