| // SPDX-License-Identifier: GPL-2.0 | |
| /* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */ | |
| #include <stdlib.h> | |
| #include <sys/types.h> | |
| #include <sys/xattr.h> | |
| #include <linux/fsverity.h> | |
| #include <unistd.h> | |
| #include <test_progs.h> | |
| #include "test_get_xattr.skel.h" | |
| #include "test_set_remove_xattr.skel.h" | |
| #include "test_fsverity.skel.h" | |
| static const char testfile[] = "/tmp/test_progs_fs_kfuncs"; | |
| static void test_get_xattr(const char *name, const char *value, bool allow_access) | |
| { | |
| struct test_get_xattr *skel = NULL; | |
| int fd = -1, err; | |
| int v[32]; | |
| fd = open(testfile, O_CREAT | O_RDONLY, 0644); | |
| if (!ASSERT_GE(fd, 0, "create_file")) | |
| return; | |
| close(fd); | |
| fd = -1; | |
| err = setxattr(testfile, name, value, strlen(value) + 1, 0); | |
| if (err && errno == EOPNOTSUPP) { | |
| printf("%s:SKIP:local fs doesn't support xattr (%d)\n" | |
| "To run this test, make sure /tmp filesystem supports xattr.\n", | |
| __func__, errno); | |
| test__skip(); | |
| goto out; | |
| } | |
| if (!ASSERT_OK(err, "setxattr")) | |
| goto out; | |
| skel = test_get_xattr__open_and_load(); | |
| if (!ASSERT_OK_PTR(skel, "test_get_xattr__open_and_load")) | |
| goto out; | |
| skel->bss->monitored_pid = getpid(); | |
| err = test_get_xattr__attach(skel); | |
| if (!ASSERT_OK(err, "test_get_xattr__attach")) | |
| goto out; | |
| fd = open(testfile, O_RDONLY, 0644); | |
| if (!ASSERT_GE(fd, 0, "open_file")) | |
| goto out; | |
| /* Trigger security_inode_getxattr */ | |
| err = getxattr(testfile, name, v, sizeof(v)); | |
| if (allow_access) { | |
| ASSERT_EQ(err, -1, "getxattr_return"); | |
| ASSERT_EQ(errno, EINVAL, "getxattr_errno"); | |
| ASSERT_EQ(skel->bss->found_xattr_from_file, 1, "found_xattr_from_file"); | |
| ASSERT_EQ(skel->bss->found_xattr_from_dentry, 1, "found_xattr_from_dentry"); | |
| } else { | |
| ASSERT_EQ(err, strlen(value) + 1, "getxattr_return"); | |
| ASSERT_EQ(skel->bss->found_xattr_from_file, 0, "found_xattr_from_file"); | |
| ASSERT_EQ(skel->bss->found_xattr_from_dentry, 0, "found_xattr_from_dentry"); | |
| } | |
| out: | |
| close(fd); | |
| test_get_xattr__destroy(skel); | |
| remove(testfile); | |
| } | |
| /* xattr value we will set to security.bpf.foo */ | |
| static const char value_foo[] = "hello"; | |
| static void read_and_validate_foo(struct test_set_remove_xattr *skel) | |
| { | |
| char value_out[32]; | |
| int err; | |
| err = getxattr(testfile, skel->rodata->xattr_foo, value_out, sizeof(value_out)); | |
| ASSERT_EQ(err, sizeof(value_foo), "getxattr size foo"); | |
| ASSERT_EQ(strncmp(value_out, value_foo, sizeof(value_foo)), 0, "strncmp value_foo"); | |
| } | |
| static void set_foo(struct test_set_remove_xattr *skel) | |
| { | |
| ASSERT_OK(setxattr(testfile, skel->rodata->xattr_foo, value_foo, strlen(value_foo) + 1, 0), | |
| "setxattr foo"); | |
| } | |
| static void validate_bar_match(struct test_set_remove_xattr *skel) | |
| { | |
| char value_out[32]; | |
| int err; | |
| err = getxattr(testfile, skel->rodata->xattr_bar, value_out, sizeof(value_out)); | |
| ASSERT_EQ(err, sizeof(skel->data->value_bar), "getxattr size bar"); | |
| ASSERT_EQ(strncmp(value_out, skel->data->value_bar, sizeof(skel->data->value_bar)), 0, | |
| "strncmp value_bar"); | |
| } | |
| static void validate_bar_removed(struct test_set_remove_xattr *skel) | |
| { | |
| char value_out[32]; | |
| int err; | |
| err = getxattr(testfile, skel->rodata->xattr_bar, value_out, sizeof(value_out)); | |
| ASSERT_LT(err, 0, "getxattr size bar should fail"); | |
| } | |
| static void test_set_remove_xattr(void) | |
| { | |
| struct test_set_remove_xattr *skel = NULL; | |
| int fd = -1, err; | |
| fd = open(testfile, O_CREAT | O_RDONLY, 0644); | |
| if (!ASSERT_GE(fd, 0, "create_file")) | |
| return; | |
| close(fd); | |
| fd = -1; | |
| skel = test_set_remove_xattr__open_and_load(); | |
| if (!ASSERT_OK_PTR(skel, "test_set_remove_xattr__open_and_load")) | |
| return; | |
| /* Set security.bpf.foo to "hello" */ | |
| err = setxattr(testfile, skel->rodata->xattr_foo, value_foo, strlen(value_foo) + 1, 0); | |
| if (err && errno == EOPNOTSUPP) { | |
| printf("%s:SKIP:local fs doesn't support xattr (%d)\n" | |
| "To run this test, make sure /tmp filesystem supports xattr.\n", | |
| __func__, errno); | |
| test__skip(); | |
| goto out; | |
| } | |
| if (!ASSERT_OK(err, "setxattr")) | |
| goto out; | |
| skel->bss->monitored_pid = getpid(); | |
| err = test_set_remove_xattr__attach(skel); | |
| if (!ASSERT_OK(err, "test_set_remove_xattr__attach")) | |
| goto out; | |
| /* First, test not _locked version of the kfuncs with getxattr. */ | |
| /* Read security.bpf.foo and trigger test_inode_getxattr. This | |
| * bpf program will set security.bpf.bar to "world". | |
| */ | |
| read_and_validate_foo(skel); | |
| validate_bar_match(skel); | |
| /* Read security.bpf.foo and trigger test_inode_getxattr again. | |
| * This will remove xattr security.bpf.bar. | |
| */ | |
| read_and_validate_foo(skel); | |
| validate_bar_removed(skel); | |
| ASSERT_TRUE(skel->bss->set_security_bpf_bar_success, "set_security_bpf_bar_success"); | |
| ASSERT_TRUE(skel->bss->remove_security_bpf_bar_success, "remove_security_bpf_bar_success"); | |
| ASSERT_TRUE(skel->bss->set_security_selinux_fail, "set_security_selinux_fail"); | |
| ASSERT_TRUE(skel->bss->remove_security_selinux_fail, "remove_security_selinux_fail"); | |
| /* Second, test _locked version of the kfuncs, with setxattr */ | |
| /* Set security.bpf.foo and trigger test_inode_setxattr. This | |
| * bpf program will set security.bpf.bar to "world". | |
| */ | |
| set_foo(skel); | |
| validate_bar_match(skel); | |
| /* Set security.bpf.foo and trigger test_inode_setxattr again. | |
| * This will remove xattr security.bpf.bar. | |
| */ | |
| set_foo(skel); | |
| validate_bar_removed(skel); | |
| ASSERT_TRUE(skel->bss->locked_set_security_bpf_bar_success, | |
| "locked_set_security_bpf_bar_success"); | |
| ASSERT_TRUE(skel->bss->locked_remove_security_bpf_bar_success, | |
| "locked_remove_security_bpf_bar_success"); | |
| ASSERT_TRUE(skel->bss->locked_set_security_selinux_fail, | |
| "locked_set_security_selinux_fail"); | |
| ASSERT_TRUE(skel->bss->locked_remove_security_selinux_fail, | |
| "locked_remove_security_selinux_fail"); | |
| out: | |
| close(fd); | |
| test_set_remove_xattr__destroy(skel); | |
| remove(testfile); | |
| } | |
| #ifndef SHA256_DIGEST_SIZE | |
| #define SHA256_DIGEST_SIZE 32 | |
| #endif | |
| static void test_fsverity(void) | |
| { | |
| struct fsverity_enable_arg arg = {0}; | |
| struct test_fsverity *skel = NULL; | |
| struct fsverity_digest *d; | |
| int fd, err; | |
| char buffer[4096]; | |
| fd = open(testfile, O_CREAT | O_RDWR, 0644); | |
| if (!ASSERT_GE(fd, 0, "create_file")) | |
| return; | |
| /* Write random buffer, so the file is not empty */ | |
| err = write(fd, buffer, 4096); | |
| if (!ASSERT_EQ(err, 4096, "write_file")) | |
| goto out; | |
| close(fd); | |
| /* Reopen read-only, otherwise FS_IOC_ENABLE_VERITY will fail */ | |
| fd = open(testfile, O_RDONLY, 0644); | |
| if (!ASSERT_GE(fd, 0, "open_file1")) | |
| return; | |
| /* Enable fsverity for the file. | |
| * If the file system doesn't support verity, this will fail. Skip | |
| * the test in such case. | |
| */ | |
| arg.version = 1; | |
| arg.hash_algorithm = FS_VERITY_HASH_ALG_SHA256; | |
| arg.block_size = 4096; | |
| err = ioctl(fd, FS_IOC_ENABLE_VERITY, &arg); | |
| if (err) { | |
| printf("%s:SKIP:local fs doesn't support fsverity (%d)\n" | |
| "To run this test, try enable CONFIG_FS_VERITY and enable FSVerity for the filesystem.\n", | |
| __func__, errno); | |
| test__skip(); | |
| goto out; | |
| } | |
| skel = test_fsverity__open_and_load(); | |
| if (!ASSERT_OK_PTR(skel, "test_fsverity__open_and_load")) | |
| goto out; | |
| /* Get fsverity_digest from ioctl */ | |
| d = (struct fsverity_digest *)skel->bss->expected_digest; | |
| d->digest_algorithm = FS_VERITY_HASH_ALG_SHA256; | |
| d->digest_size = SHA256_DIGEST_SIZE; | |
| err = ioctl(fd, FS_IOC_MEASURE_VERITY, skel->bss->expected_digest); | |
| if (!ASSERT_OK(err, "ioctl_FS_IOC_MEASURE_VERITY")) | |
| goto out; | |
| skel->bss->monitored_pid = getpid(); | |
| err = test_fsverity__attach(skel); | |
| if (!ASSERT_OK(err, "test_fsverity__attach")) | |
| goto out; | |
| /* Reopen the file to trigger the program */ | |
| close(fd); | |
| fd = open(testfile, O_RDONLY); | |
| if (!ASSERT_GE(fd, 0, "open_file2")) | |
| goto out; | |
| ASSERT_EQ(skel->bss->got_fsverity, 1, "got_fsverity"); | |
| ASSERT_EQ(skel->bss->digest_matches, 1, "digest_matches"); | |
| out: | |
| close(fd); | |
| test_fsverity__destroy(skel); | |
| remove(testfile); | |
| } | |
| void test_fs_kfuncs(void) | |
| { | |
| /* Matches xattr_names in progs/test_get_xattr.c */ | |
| if (test__start_subtest("user_xattr")) | |
| test_get_xattr("user.kfuncs", "hello", true); | |
| if (test__start_subtest("security_bpf_xattr")) | |
| test_get_xattr("security.bpf.xxx", "hello", true); | |
| if (test__start_subtest("security_bpf_xattr_error")) | |
| test_get_xattr("security.bpf", "hello", false); | |
| if (test__start_subtest("security_selinux_xattr_error")) | |
| test_get_xattr("security.selinux", "hello", false); | |
| if (test__start_subtest("set_remove_xattr")) | |
| test_set_remove_xattr(); | |
| if (test__start_subtest("fsverity")) | |
| test_fsverity(); | |
| } |