mirror of https://github.com/torvalds/linux.git
815 lines
17 KiB
C
815 lines
17 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#define _GNU_SOURCE
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <sched.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/capability.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/syscall.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <linux/nsfs.h>
|
|
#include "../kselftest_harness.h"
|
|
#include "../filesystems/utils.h"
|
|
#include "wrappers.h"
|
|
|
|
/*
|
|
* Test credential changes and their impact on namespace active references.
|
|
*/
|
|
|
|
/*
|
|
* Test setuid() in a user namespace properly swaps active references.
|
|
* Create a user namespace with multiple UIDs mapped, then setuid() between them.
|
|
* Verify that the user namespace remains active throughout.
|
|
*/
|
|
TEST(setuid_preserves_active_refs)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
__u64 userns_id;
|
|
struct ns_id_req req = {
|
|
.size = sizeof(req),
|
|
.spare = 0,
|
|
.ns_id = 0,
|
|
.ns_type = CLONE_NEWUSER,
|
|
.spare2 = 0,
|
|
.user_ns_id = 0,
|
|
};
|
|
__u64 ns_ids[256];
|
|
ssize_t ret;
|
|
int i;
|
|
bool found = false;
|
|
int pipefd[2];
|
|
|
|
ASSERT_EQ(pipe(pipefd), 0);
|
|
|
|
pid = fork();
|
|
ASSERT_GE(pid, 0);
|
|
|
|
if (pid == 0) {
|
|
/* Child process */
|
|
int fd, userns_fd;
|
|
__u64 child_userns_id;
|
|
uid_t orig_uid = getuid();
|
|
int setuid_count;
|
|
|
|
close(pipefd[0]);
|
|
|
|
/* Create new user namespace with multiple UIDs mapped (0-9) */
|
|
userns_fd = get_userns_fd(0, orig_uid, 10);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get user namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &child_userns_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
/* Send namespace ID to parent */
|
|
write(pipefd[1], &child_userns_id, sizeof(child_userns_id));
|
|
|
|
/*
|
|
* Perform multiple setuid() calls.
|
|
* Each setuid() triggers commit_creds() which should properly
|
|
* swap active references via switch_cred_namespaces().
|
|
*/
|
|
for (setuid_count = 0; setuid_count < 50; setuid_count++) {
|
|
uid_t target_uid = (setuid_count % 10);
|
|
if (setuid(target_uid) < 0) {
|
|
if (errno != EPERM) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
close(pipefd[1]);
|
|
exit(0);
|
|
}
|
|
|
|
/* Parent process */
|
|
close(pipefd[1]);
|
|
|
|
if (read(pipefd[0], &userns_id, sizeof(userns_id)) != sizeof(userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get namespace ID from child");
|
|
}
|
|
close(pipefd[0]);
|
|
|
|
TH_LOG("Child user namespace ID: %llu", (unsigned long long)userns_id);
|
|
|
|
/* Verify namespace is active while child is running */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
if (ret < 0) {
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
if (errno == ENOSYS)
|
|
SKIP(return, "listns() not supported");
|
|
ASSERT_GE(ret, 0);
|
|
}
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == userns_id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
ASSERT_TRUE(found);
|
|
|
|
waitpid(pid, &status, 0);
|
|
ASSERT_TRUE(WIFEXITED(status));
|
|
ASSERT_EQ(WEXITSTATUS(status), 0);
|
|
|
|
/* Verify namespace becomes inactive after child exits */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
ASSERT_GE(ret, 0);
|
|
|
|
found = false;
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == userns_id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT_FALSE(found);
|
|
TH_LOG("setuid() correctly preserved active references (no leak)");
|
|
}
|
|
|
|
/*
|
|
* Test setgid() in a user namespace properly handles active references.
|
|
*/
|
|
TEST(setgid_preserves_active_refs)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
__u64 userns_id;
|
|
struct ns_id_req req = {
|
|
.size = sizeof(req),
|
|
.spare = 0,
|
|
.ns_id = 0,
|
|
.ns_type = CLONE_NEWUSER,
|
|
.spare2 = 0,
|
|
.user_ns_id = 0,
|
|
};
|
|
__u64 ns_ids[256];
|
|
ssize_t ret;
|
|
int i;
|
|
bool found = false;
|
|
int pipefd[2];
|
|
|
|
ASSERT_EQ(pipe(pipefd), 0);
|
|
|
|
pid = fork();
|
|
ASSERT_GE(pid, 0);
|
|
|
|
if (pid == 0) {
|
|
/* Child process */
|
|
int fd, userns_fd;
|
|
__u64 child_userns_id;
|
|
uid_t orig_uid = getuid();
|
|
int setgid_count;
|
|
|
|
close(pipefd[0]);
|
|
|
|
/* Create new user namespace with multiple GIDs mapped */
|
|
userns_fd = get_userns_fd(0, orig_uid, 10);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get user namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &child_userns_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
write(pipefd[1], &child_userns_id, sizeof(child_userns_id));
|
|
|
|
/* Perform multiple setgid() calls */
|
|
for (setgid_count = 0; setgid_count < 50; setgid_count++) {
|
|
gid_t target_gid = (setgid_count % 10);
|
|
if (setgid(target_gid) < 0) {
|
|
if (errno != EPERM) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
close(pipefd[1]);
|
|
exit(0);
|
|
}
|
|
|
|
/* Parent process */
|
|
close(pipefd[1]);
|
|
|
|
if (read(pipefd[0], &userns_id, sizeof(userns_id)) != sizeof(userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get namespace ID from child");
|
|
}
|
|
close(pipefd[0]);
|
|
|
|
waitpid(pid, &status, 0);
|
|
ASSERT_TRUE(WIFEXITED(status));
|
|
ASSERT_EQ(WEXITSTATUS(status), 0);
|
|
|
|
/* Verify namespace becomes inactive */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
if (ret < 0) {
|
|
if (errno == ENOSYS)
|
|
SKIP(return, "listns() not supported");
|
|
ASSERT_GE(ret, 0);
|
|
}
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == userns_id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT_FALSE(found);
|
|
TH_LOG("setgid() correctly preserved active references (no leak)");
|
|
}
|
|
|
|
/*
|
|
* Test setresuid() which changes real, effective, and saved UIDs.
|
|
* This should properly swap active references via commit_creds().
|
|
*/
|
|
TEST(setresuid_preserves_active_refs)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
__u64 userns_id;
|
|
struct ns_id_req req = {
|
|
.size = sizeof(req),
|
|
.spare = 0,
|
|
.ns_id = 0,
|
|
.ns_type = CLONE_NEWUSER,
|
|
.spare2 = 0,
|
|
.user_ns_id = 0,
|
|
};
|
|
__u64 ns_ids[256];
|
|
ssize_t ret;
|
|
int i;
|
|
bool found = false;
|
|
int pipefd[2];
|
|
|
|
ASSERT_EQ(pipe(pipefd), 0);
|
|
|
|
pid = fork();
|
|
ASSERT_GE(pid, 0);
|
|
|
|
if (pid == 0) {
|
|
/* Child process */
|
|
int fd, userns_fd;
|
|
__u64 child_userns_id;
|
|
uid_t orig_uid = getuid();
|
|
int setres_count;
|
|
|
|
close(pipefd[0]);
|
|
|
|
/* Create new user namespace */
|
|
userns_fd = get_userns_fd(0, orig_uid, 10);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get user namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &child_userns_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
write(pipefd[1], &child_userns_id, sizeof(child_userns_id));
|
|
|
|
/* Perform multiple setresuid() calls */
|
|
for (setres_count = 0; setres_count < 30; setres_count++) {
|
|
uid_t uid1 = (setres_count % 5);
|
|
uid_t uid2 = ((setres_count + 1) % 5);
|
|
uid_t uid3 = ((setres_count + 2) % 5);
|
|
|
|
if (setresuid(uid1, uid2, uid3) < 0) {
|
|
if (errno != EPERM) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
close(pipefd[1]);
|
|
exit(0);
|
|
}
|
|
|
|
/* Parent process */
|
|
close(pipefd[1]);
|
|
|
|
if (read(pipefd[0], &userns_id, sizeof(userns_id)) != sizeof(userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get namespace ID from child");
|
|
}
|
|
close(pipefd[0]);
|
|
|
|
waitpid(pid, &status, 0);
|
|
ASSERT_TRUE(WIFEXITED(status));
|
|
ASSERT_EQ(WEXITSTATUS(status), 0);
|
|
|
|
/* Verify namespace becomes inactive */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
if (ret < 0) {
|
|
if (errno == ENOSYS)
|
|
SKIP(return, "listns() not supported");
|
|
ASSERT_GE(ret, 0);
|
|
}
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == userns_id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT_FALSE(found);
|
|
TH_LOG("setresuid() correctly preserved active references (no leak)");
|
|
}
|
|
|
|
/*
|
|
* Test credential changes across multiple user namespaces.
|
|
* Create nested user namespaces and verify active reference tracking.
|
|
*/
|
|
TEST(cred_change_nested_userns)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
__u64 parent_userns_id, child_userns_id;
|
|
struct ns_id_req req = {
|
|
.size = sizeof(req),
|
|
.spare = 0,
|
|
.ns_id = 0,
|
|
.ns_type = CLONE_NEWUSER,
|
|
.spare2 = 0,
|
|
.user_ns_id = 0,
|
|
};
|
|
__u64 ns_ids[256];
|
|
ssize_t ret;
|
|
int i;
|
|
bool found_parent = false, found_child = false;
|
|
int pipefd[2];
|
|
|
|
ASSERT_EQ(pipe(pipefd), 0);
|
|
|
|
pid = fork();
|
|
ASSERT_GE(pid, 0);
|
|
|
|
if (pid == 0) {
|
|
/* Child process */
|
|
int fd, userns_fd;
|
|
__u64 parent_id, child_id;
|
|
uid_t orig_uid = getuid();
|
|
|
|
close(pipefd[0]);
|
|
|
|
/* Create first user namespace */
|
|
userns_fd = get_userns_fd(0, orig_uid, 1);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get first namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &parent_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
/* Create nested user namespace */
|
|
userns_fd = get_userns_fd(0, 0, 1);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get nested namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &child_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
/* Send both IDs to parent */
|
|
write(pipefd[1], &parent_id, sizeof(parent_id));
|
|
write(pipefd[1], &child_id, sizeof(child_id));
|
|
|
|
/* Perform some credential changes in nested namespace */
|
|
setuid(0);
|
|
setgid(0);
|
|
|
|
close(pipefd[1]);
|
|
exit(0);
|
|
}
|
|
|
|
/* Parent process */
|
|
close(pipefd[1]);
|
|
|
|
/* Read both namespace IDs */
|
|
if (read(pipefd[0], &parent_userns_id, sizeof(parent_userns_id)) != sizeof(parent_userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get parent namespace ID");
|
|
}
|
|
|
|
if (read(pipefd[0], &child_userns_id, sizeof(child_userns_id)) != sizeof(child_userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get child namespace ID");
|
|
}
|
|
close(pipefd[0]);
|
|
|
|
TH_LOG("Parent userns: %llu, Child userns: %llu",
|
|
(unsigned long long)parent_userns_id,
|
|
(unsigned long long)child_userns_id);
|
|
|
|
/* Verify both namespaces are active */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
if (ret < 0) {
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
if (errno == ENOSYS)
|
|
SKIP(return, "listns() not supported");
|
|
ASSERT_GE(ret, 0);
|
|
}
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == parent_userns_id)
|
|
found_parent = true;
|
|
if (ns_ids[i] == child_userns_id)
|
|
found_child = true;
|
|
}
|
|
|
|
ASSERT_TRUE(found_parent);
|
|
ASSERT_TRUE(found_child);
|
|
|
|
/* Wait for child */
|
|
waitpid(pid, &status, 0);
|
|
ASSERT_TRUE(WIFEXITED(status));
|
|
ASSERT_EQ(WEXITSTATUS(status), 0);
|
|
|
|
/* Verify both namespaces become inactive */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
ASSERT_GE(ret, 0);
|
|
|
|
found_parent = false;
|
|
found_child = false;
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == parent_userns_id)
|
|
found_parent = true;
|
|
if (ns_ids[i] == child_userns_id)
|
|
found_child = true;
|
|
}
|
|
|
|
ASSERT_FALSE(found_parent);
|
|
ASSERT_FALSE(found_child);
|
|
TH_LOG("Nested user namespace credential changes preserved active refs (no leak)");
|
|
}
|
|
|
|
/*
|
|
* Test rapid credential changes don't cause refcount imbalances.
|
|
* This stress-tests the switch_cred_namespaces() logic.
|
|
*/
|
|
TEST(rapid_cred_changes_no_leak)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
__u64 userns_id;
|
|
struct ns_id_req req = {
|
|
.size = sizeof(req),
|
|
.spare = 0,
|
|
.ns_id = 0,
|
|
.ns_type = CLONE_NEWUSER,
|
|
.spare2 = 0,
|
|
.user_ns_id = 0,
|
|
};
|
|
__u64 ns_ids[256];
|
|
ssize_t ret;
|
|
int i;
|
|
bool found = false;
|
|
int pipefd[2];
|
|
|
|
ASSERT_EQ(pipe(pipefd), 0);
|
|
|
|
pid = fork();
|
|
ASSERT_GE(pid, 0);
|
|
|
|
if (pid == 0) {
|
|
/* Child process */
|
|
int fd, userns_fd;
|
|
__u64 child_userns_id;
|
|
uid_t orig_uid = getuid();
|
|
int change_count;
|
|
|
|
close(pipefd[0]);
|
|
|
|
/* Create new user namespace with wider range of UIDs/GIDs */
|
|
userns_fd = get_userns_fd(0, orig_uid, 100);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get user namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &child_userns_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
write(pipefd[1], &child_userns_id, sizeof(child_userns_id));
|
|
|
|
/*
|
|
* Perform many rapid credential changes.
|
|
* Mix setuid, setgid, setreuid, setregid, setresuid, setresgid.
|
|
*/
|
|
for (change_count = 0; change_count < 200; change_count++) {
|
|
switch (change_count % 6) {
|
|
case 0:
|
|
setuid(change_count % 50);
|
|
break;
|
|
case 1:
|
|
setgid(change_count % 50);
|
|
break;
|
|
case 2:
|
|
setreuid(change_count % 50, (change_count + 1) % 50);
|
|
break;
|
|
case 3:
|
|
setregid(change_count % 50, (change_count + 1) % 50);
|
|
break;
|
|
case 4:
|
|
setresuid(change_count % 50, (change_count + 1) % 50, (change_count + 2) % 50);
|
|
break;
|
|
case 5:
|
|
setresgid(change_count % 50, (change_count + 1) % 50, (change_count + 2) % 50);
|
|
break;
|
|
}
|
|
}
|
|
|
|
close(pipefd[1]);
|
|
exit(0);
|
|
}
|
|
|
|
/* Parent process */
|
|
close(pipefd[1]);
|
|
|
|
if (read(pipefd[0], &userns_id, sizeof(userns_id)) != sizeof(userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get namespace ID from child");
|
|
}
|
|
close(pipefd[0]);
|
|
|
|
TH_LOG("Testing with user namespace ID: %llu", (unsigned long long)userns_id);
|
|
|
|
waitpid(pid, &status, 0);
|
|
ASSERT_TRUE(WIFEXITED(status));
|
|
ASSERT_EQ(WEXITSTATUS(status), 0);
|
|
|
|
/* Verify namespace becomes inactive (no leaked active refs) */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
if (ret < 0) {
|
|
if (errno == ENOSYS)
|
|
SKIP(return, "listns() not supported");
|
|
ASSERT_GE(ret, 0);
|
|
}
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == userns_id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT_FALSE(found);
|
|
TH_LOG("200 rapid credential changes completed with no active ref leak");
|
|
}
|
|
|
|
/*
|
|
* Test setfsuid/setfsgid which change filesystem UID/GID.
|
|
* These also trigger credential changes but may have different code paths.
|
|
*/
|
|
TEST(setfsuid_preserves_active_refs)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
__u64 userns_id;
|
|
struct ns_id_req req = {
|
|
.size = sizeof(req),
|
|
.spare = 0,
|
|
.ns_id = 0,
|
|
.ns_type = CLONE_NEWUSER,
|
|
.spare2 = 0,
|
|
.user_ns_id = 0,
|
|
};
|
|
__u64 ns_ids[256];
|
|
ssize_t ret;
|
|
int i;
|
|
bool found = false;
|
|
int pipefd[2];
|
|
|
|
ASSERT_EQ(pipe(pipefd), 0);
|
|
|
|
pid = fork();
|
|
ASSERT_GE(pid, 0);
|
|
|
|
if (pid == 0) {
|
|
/* Child process */
|
|
int fd, userns_fd;
|
|
__u64 child_userns_id;
|
|
uid_t orig_uid = getuid();
|
|
int change_count;
|
|
|
|
close(pipefd[0]);
|
|
|
|
/* Create new user namespace */
|
|
userns_fd = get_userns_fd(0, orig_uid, 10);
|
|
if (userns_fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (setns(userns_fd, CLONE_NEWUSER) < 0) {
|
|
close(userns_fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(userns_fd);
|
|
|
|
/* Get user namespace ID */
|
|
fd = open("/proc/self/ns/user", O_RDONLY);
|
|
if (fd < 0) {
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
|
|
if (ioctl(fd, NS_GET_ID, &child_userns_id) < 0) {
|
|
close(fd);
|
|
close(pipefd[1]);
|
|
exit(1);
|
|
}
|
|
close(fd);
|
|
|
|
write(pipefd[1], &child_userns_id, sizeof(child_userns_id));
|
|
|
|
/* Perform multiple setfsuid/setfsgid calls */
|
|
for (change_count = 0; change_count < 50; change_count++) {
|
|
setfsuid(change_count % 10);
|
|
setfsgid(change_count % 10);
|
|
}
|
|
|
|
close(pipefd[1]);
|
|
exit(0);
|
|
}
|
|
|
|
/* Parent process */
|
|
close(pipefd[1]);
|
|
|
|
if (read(pipefd[0], &userns_id, sizeof(userns_id)) != sizeof(userns_id)) {
|
|
close(pipefd[0]);
|
|
kill(pid, SIGKILL);
|
|
waitpid(pid, NULL, 0);
|
|
SKIP(return, "Failed to get namespace ID from child");
|
|
}
|
|
close(pipefd[0]);
|
|
|
|
waitpid(pid, &status, 0);
|
|
ASSERT_TRUE(WIFEXITED(status));
|
|
ASSERT_EQ(WEXITSTATUS(status), 0);
|
|
|
|
/* Verify namespace becomes inactive */
|
|
ret = sys_listns(&req, ns_ids, ARRAY_SIZE(ns_ids), 0);
|
|
if (ret < 0) {
|
|
if (errno == ENOSYS)
|
|
SKIP(return, "listns() not supported");
|
|
ASSERT_GE(ret, 0);
|
|
}
|
|
|
|
for (i = 0; i < ret; i++) {
|
|
if (ns_ids[i] == userns_id) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT_FALSE(found);
|
|
TH_LOG("setfsuid/setfsgid correctly preserved active references (no leak)");
|
|
}
|
|
|
|
TEST_HARNESS_MAIN
|