C++中的进程/线程隔离与沙箱：利用命名空间（Namespace）或cgroups进行资源限制 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，我们开始今天的讲座，主题是 C++ 中的进程/线程隔离与沙箱技术，重点是如何利用命名空间 (Namespace) 和 cgroups 进行资源限制。这是一个重要的安全和稳定性保障机制，尤其是在构建复杂系统、容器化应用以及需要隔离不可信代码的场景下。

一、进程/线程隔离的必要性

在多任务操作系统中，多个进程/线程并发执行，共享系统资源。如果没有有效的隔离机制，一个进程/线程的错误或者恶意行为可能会影响到其他进程/线程，甚至导致整个系统崩溃或数据泄露。

安全性： 隔离可以防止恶意代码访问敏感数据或执行未授权操作。例如，运行用户上传的代码时，必须将其限制在一个沙箱环境中，防止其访问文件系统、网络等资源。
稳定性： 隔离可以防止一个进程/线程的崩溃影响到其他进程/线程。例如，一个内存泄漏的进程可能会耗尽系统资源，导致其他进程无法正常运行。
资源管理： 隔离可以限制进程/线程可以使用的资源，例如 CPU、内存、磁盘 I/O 等。这可以防止一个进程占用过多的资源，影响到其他进程的性能。
可移植性： 通过容器化技术，可以将应用程序及其依赖项打包到一个隔离的环境中，使其可以在不同的平台上运行。

二、命名空间 (Namespace) 的隔离原理

命名空间是 Linux 内核提供的一种隔离机制，它可以将全局系统资源划分为多个独立的命名空间，每个命名空间中的进程只能看到自己命名空间内的资源。这就像在一个房间里的人只能看到房间内的东西，而看不到其他房间的东西。

Linux 提供了多种类型的命名空间：

命名空间类型	隔离内容
Mount (mnt)	文件系统挂载点。一个命名空间中的进程无法看到其他命名空间中挂载的文件系统。
UTS (uts)	主机名和域名。一个命名空间中的进程可以拥有自己的主机名和域名。
IPC (ipc)	进程间通信资源，如消息队列、信号量和共享内存。一个命名空间中的进程无法与其他命名空间中的进程进行 IPC 通信。
PID (pid)	进程 ID。一个命名空间中的进程拥有自己的 PID 空间，这使得可以在容器中运行一个完整的 init 系统。
Network (net)	网络接口、路由表和防火墙规则。一个命名空间中的进程可以拥有自己的网络栈，这使得可以创建虚拟网络。
User (user)	用户和组 ID。一个命名空间中的进程可以拥有自己的用户和组 ID 映射，这使得可以在容器中以非 root 用户身份运行进程，提高安全性。
Cgroup (cgroup)	Cgroup 根目录。允许命名空间拥有独立的 cgroup 树，用于更精细的资源控制。

C++ 中使用 clone() 系统调用创建隔离进程

在 C++ 中，可以使用 clone() 系统调用创建新的进程，并指定需要隔离的命名空间。clone() 系统调用的原型如下：

#define _GNU_SOURCE
#include <sched.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

// 定义栈大小
#define STACK_SIZE (1024 * 1024)

// 子进程执行的函数
static int child_func(void *arg) {
    printf("Child process: PID = %ldn", (long)getpid());
    // 在子进程中挂载新的文件系统
    if (mount("none", "/mnt", "tmpfs", 0, NULL) != 0) {
        perror("mount");
        return 1;
    }
    printf("Child process: Mounted tmpfs on /mntn");

    // 创建一个文件
    char filename[64];
    snprintf(filename, sizeof(filename), "/mnt/child_file_%ld.txt", (long)getpid());
    FILE *fp = fopen(filename, "w");
    if (fp == NULL) {
        perror("fopen");
        return 1;
    }
    fprintf(fp, "Hello from child process %ld!n", (long)getpid());
    fclose(fp);
    printf("Child process: Created file %sn", filename);

    // 执行一个命令
    printf("Child process: Executing 'ls -l /mnt'n");
    execl("/bin/ls", "ls", "-l", "/mnt", NULL); // 如果exec失败，会返回到这里
    perror("execl"); // execl 失败时才会被调用
    return 1;
}

int main() {
    char *stack;
    char *stackTop;
    pid_t childPid;

    // 分配栈空间
    stack = (char *)malloc(STACK_SIZE);
    if (stack == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    stackTop = stack + STACK_SIZE;  // 栈顶指针

    // 创建子进程
    childPid = clone(child_func, stackTop,
                       CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWNS | SIGCHLD, NULL); // 使用CLONE_NEWNS创建新的挂载命名空间
    if (childPid == -1) {
        perror("clone");
        exit(EXIT_FAILURE);
    }
    printf("Parent process: Created child with PID = %ldn", (long)childPid);

    // 等待子进程结束
    int status;
    if (waitpid(childPid, &status, 0) == -1) {
        perror("waitpid");
        exit(EXIT_FAILURE);
    }
    printf("Parent process: Child process terminatedn");

    // 清理栈空间
    free(stack);
    exit(EXIT_SUCCESS);
}

代码解释：

clone() 系统调用用于创建新的进程。
child_func() 函数是子进程执行的函数。
CLONE_NEWUTS、CLONE_NEWPID 和 CLONE_NEWNS 标志分别用于创建新的 UTS、PID 和 Mount 命名空间。
SIGCHLD 标志用于在子进程结束时向父进程发送信号。
在子进程中，我们挂载了一个新的 tmpfs 文件系统到 /mnt 目录。这意味着子进程只能看到 /mnt 目录下的文件，而看不到父进程的文件系统。
execl()函数族用指定的程序替换当前进程的映像。

编译和运行：

gcc -Wall -o clone_example clone_example.c
sudo ./clone_example

注意：可能需要 sudo 权限才能执行 mount 操作。

这个例子展示了如何使用 clone() 系统调用创建新的 UTS、PID 和 Mount 命名空间，从而实现进程隔离。

三、Cgroups (Control Groups) 的资源限制

Cgroups 是一种 Linux 内核特性，用于限制、控制和隔离进程组（cgroup）的资源使用。它可以限制 CPU、内存、磁盘 I/O 和网络带宽等资源。

Cgroups 的基本概念

Cgroup: 一组进程的集合，可以对其应用资源限制。
Hierarchy: Cgroups 以树形结构组织，每个节点代表一个 cgroup。
Subsystem: 一种资源控制器，例如 cpu、memory、blkio 等。每个 subsystem 负责控制特定类型的资源。

Cgroups 的使用方式

挂载 cgroup 文件系统:
```
mount -t cgroup -o cpu,memory cgroup /sys/fs/cgroup
```
这会将 cpu 和 memory subsystem 挂载到 /sys/fs/cgroup 目录下。
创建 cgroup:
```
mkdir /sys/fs/cgroup/cpu/my_cgroup
mkdir /sys/fs/cgroup/memory/my_cgroup
```
这会创建两个 cgroup，分别用于 CPU 和内存资源限制。

设置资源限制:

# 限制 CPU 使用率为 50% (假设系统有 2 个 CPU 核心)
echo 50000 > /sys/fs/cgroup/cpu/my_cgroup/cpu.cfs_quota_us
echo 100000 > /sys/fs/cgroup/cpu/my_cgroup/cpu.cfs_period_us

# 限制内存使用量为 100MB
echo 100M > /sys/fs/cgroup/memory/my_cgroup/memory.limit_in_bytes

将进程添加到 cgroup:

echo <pid> > /sys/fs/cgroup/cpu/my_cgroup/tasks
echo <pid> > /sys/fs/cgroup/memory/my_cgroup/tasks

将进程 ID <pid> 添加到 my_cgroup 中。

C++ 中使用 libcg 库控制 Cgroups

虽然可以直接操作 cgroup 文件系统，但使用专门的库可以简化操作。libcg 是一个用于管理 cgroup 的 C 库。

#include <iostream>
#include <cg/cg.h>
#include <unistd.h>
#include <stdexcept>

int main() {
    try {
        // 1. 初始化 libcg
        cg::cgroup cgroup("my_cgroup");

        // 2. 创建 cgroup (如果不存在)
        if (!cgroup.exists()) {
            cgroup.create();
        }

        // 3. 设置 CPU 限制 (50% of one core)
        cgroup.set("cpu.cfs_quota_us", "50000");
        cgroup.set("cpu.cfs_period_us", "100000");

        // 4. 设置内存限制 (100MB)
        cgroup.set("memory.limit_in_bytes", "100M");

        // 5. 将当前进程添加到 cgroup
        pid_t pid = getpid();
        cgroup.add_task(pid);
        std::cout << "Process " << pid << " added to cgroup 'my_cgroup'" << std::endl;

        // 6. 运行一段时间
        std::cout << "Running for a while..." << std::endl;
        sleep(10);

        // 7. 清理 cgroup (可选) - 在实际应用中，可能需要更复杂的清理逻辑
        // cgroup.remove();
        // std::cout << "Cgroup 'my_cgroup' removed." << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

代码解释：

需要安装 libcg: 可以使用包管理器安装，例如 apt-get install libcg-dev 或 yum install libcgroup-devel。
包含 cg/cg.h 头文件。
创建一个 cg::cgroup 对象，指定 cgroup 的名称。
使用 cgroup.create() 创建 cgroup（如果不存在）。
使用 cgroup.set() 设置 CPU 和内存限制。
使用 cgroup.add_task() 将当前进程添加到 cgroup。
可以选择在程序结束时删除 cgroup。

编译和运行：

g++ -Wall -o cgroup_example cgroup_example.cpp -lcg
sudo ./cgroup_example

注意：需要 sudo 权限才能操作 cgroups。

四、结合 Namespace 和 Cgroups 实现沙箱

可以将 Namespace 和 Cgroups 结合起来，创建一个更加完善的沙箱环境。Namespace 用于隔离进程的视图，Cgroups 用于限制进程的资源使用。

实现步骤：

创建新的 Namespace: 使用 clone() 系统调用创建新的 UTS、PID、Mount、Network 和 User 命名空间。
创建 Cgroups: 创建 CPU、内存、磁盘 I/O 和网络带宽等 Cgroups。
设置资源限制: 设置 Cgroups 的资源限制，例如 CPU 使用率、内存使用量、磁盘 I/O 速率和网络带宽。
将进程添加到 Namespace 和 Cgroups: 将需要隔离的进程添加到新的 Namespace 和 Cgroups 中。
设置 User Namespace 映射: 在 User Namespace 中设置用户和组 ID 映射，将容器内的用户映射到宿主机上的非特权用户，防止容器内的进程获得宿主机的 root 权限。

示例代码 (简化版，仅展示核心逻辑):

#define _GNU_SOURCE
#include <sched.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <iostream>
#include <cg/cg.h>
#include <stdexcept>

#define STACK_SIZE (1024 * 1024)

static int child_func(void *arg) {
    try {
        // 创建 cgroup
        cg::cgroup cgroup("sandbox_cgroup");
        if (!cgroup.exists()) {
            cgroup.create();
        }

        // 设置 CPU 限制 (20%)
        cgroup.set("cpu.cfs_quota_us", "20000");
        cgroup.set("cpu.cfs_period_us", "100000");

        // 设置内存限制 (50MB)
        cgroup.set("memory.limit_in_bytes", "50M");

        // 将当前进程添加到 cgroup
        pid_t pid = getpid();
        cgroup.add_task(pid);

        // 设置 user namespace 映射 (简化版) - 实际应用中需要更完善的映射
        // 例如，将容器内的 root 用户映射到宿主机上的非特权用户

        // 执行一些操作
        std::cout << "Sandbox process: Running with PID = " << pid << std::endl;
        sleep(5);
        std::cout << "Sandbox process: Finished" << std::endl;

    } catch (const std::exception& e) {
        std::cerr << "Sandbox process error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

int main() {
    char *stack;
    char *stackTop;
    pid_t childPid;

    stack = (char *)malloc(STACK_SIZE);
    if (stack == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    stackTop = stack + STACK_SIZE;

    // 创建子进程，并隔离命名空间
    childPid = clone(child_func, stackTop,
                       CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWNS | CLONE_NEWNET | CLONE_NEWUSER | SIGCHLD, NULL);
    if (childPid == -1) {
        perror("clone");
        exit(EXIT_FAILURE);
    }

    std::cout << "Parent process: Created sandbox process with PID = " << childPid << std::endl;

    int status;
    if (waitpid(childPid, &status, 0) == -1) {
        perror("waitpid");
        exit(EXIT_FAILURE);
    }

    std::cout << "Parent process: Sandbox process terminated" << std::endl;

    free(stack);
    exit(EXIT_SUCCESS);
}

代码解释：

此代码创建了一个新的 UTS、PID、Mount、Network 和 User 命名空间，并将子进程添加到该命名空间中。
还创建了一个 Cgroup，并设置了 CPU 和内存限制。
最后，将子进程添加到该 Cgroup 中。

五、安全注意事项

Capabilities: Linux Capabilities 允许将 root 权限划分为更细粒度的权限。在沙箱环境中，应该尽量减少进程的 Capabilities，只授予其必要的权限。
Seccomp: Seccomp (Secure Computing Mode) 是一种 Linux 内核特性，可以限制进程可以使用的系统调用。在沙箱环境中，应该使用 Seccomp 限制进程可以使用的系统调用，防止其执行恶意操作。
AppArmor/SELinux: AppArmor 和 SELinux 是 Linux 的安全模块，可以用于限制进程的访问权限。在沙箱环境中，可以使用 AppArmor 或 SELinux 进一步加强隔离。
User Namespace Mapping: 正确配置 User Namespace 映射至关重要，否则容器内的 root 用户可能会获得宿主机的 root 权限。

六、工具和框架

Docker: Docker 是一个流行的容器化平台，它使用 Namespace 和 Cgroups 实现容器隔离。
LXC/LXD: LXC (Linux Containers) 和 LXD 是 Linux 容器技术，它们提供了一种轻量级的虚拟化解决方案。
runc: runc 是一个OCI (Open Container Initiative) 兼容的容器运行时，它可以用于创建和运行容器。
Firejail: Firejail 是一个 SUID 程序，它使用 Namespace 和 Seccomp 创建沙箱环境，可以用于运行不可信的应用程序。

七、总结

Namespace 和 Cgroups 是 Linux 提供的强大的隔离和资源限制机制，可以用于构建安全可靠的沙箱环境。通过结合使用 Namespace 和 Cgroups，可以有效地隔离进程，限制其资源使用，并防止其执行恶意操作。

使用隔离和限制，确保系统安全

利用命名空间隔离进程，利用 cgroups 限制资源，可以有效提升系统的安全性和稳定性。

更多IT精英技术系列讲座，到智猿学院

发表回复 取消回复

发表回复取消回复