Linux Kernel LSM Hook 架构深度实战：为 AI Agent 构建自定义沙箱安全模块

引言：为什么需要理解 LSM Hook 架构？

在现代 Linux 安全体系中，SELinux、AppArmor、Landlock、BPF LSM 构成了层层防御的基石。然而，大多数工程师对 LSM（Linux Security Module）的理解停留在「如何编写一条 SELinux 策略」或「如何配置 AppArmor profile」的配置层面。当我们面对 AI Agent 运行时这种新兴需求时——需要在多租户环境中对 Agent 进程施加细粒度的系统调用约束、文件访问控制、网络隔离——仅靠现成策略语言往往力不从心。

理解 LSM Hook 架构的核心价值在于：它让你明白「安全检查点」是如何嵌入内核关键路径的、多个安全模块之间如何协调决策、以及如何编写一个自定义内核模块来实现任何策略语言都无法表达的动态安全逻辑。

本文将深入剖析 LSM Hook 的底层机制，并通过一个完整的实战案例——为 AI Agent 构建运行时沙箱——展示如何从零编写一个功能完整的 LSM 模块。

一、LSM 架构概览：插件式安全框架

1.1 设计哲学

LSM 的设计目标非常明确：在不修改内核核心代码的前提下，允许安全策略以可加载内核模块（LKM）的形式动态注入。为了实现这一点，LSM 采用了一种经典的「探针」（Probe）模式：

在内核关键操作路径上预置大量钩子（Hooks），每个钩子在操作执行前被调用。如果任何一个钩子返回 -EPERM（或其他负值错误码），整个操作被拒绝，后续钩子不再执行。

这种设计有以下关键特性：

• 非侵入式：内核核心代码不需要知道具体安全策略的存在
• 堆叠式（Stackable）：多个 LSM 模块可以同时生效，任一模块拒绝即拒绝
• 单向拦截：钩子只能拒绝操作（放行/拒绝模型），不能修改正在执行的操作参数

1.2 LSM 模块的注册与生命周期

一个 LSM 模块通过 security_add_hooks() 向内核注册其钩子函数表。在内核配置层面，通过 CONFIG_DEFAULT_SECURITY 和 lsm= 内核参数可以控制哪些模块被激活以及它们的执行顺序。

内核启动流程                         
    │                              
    ▼                              
  lsm_init()                       
    │                              
    ├─→ 初始化 built-in LSMs       
    │    (Yama, LoadPin, SafeSetid) 
    │                              
    ├─→ 按 lsm= 参数排序注册       
    │    (如: lsm=lockdown,landlock,selinux,bpf)      
    │                              
    └─→ 调用每个 LSM 的 init()     
        通过 security_add_hooks()   
        注册 hook 列表              

1.3 Hook 的分类

LSM Hook 按功能域可以分为以下类别：

二、Hook 调用的底层机制

2.1 静态键（Static Calls）：性能优化的关键

Linux 5.x 引入了 Static Calls 取代传统的函数指针数组。这对 LSM 的 Hook 调用路径产生了深远影响。

在内核编译时，每个 Hook 点被编译为一个 nop 指令（默认无安全模块注册时）。当 LSM 模块注册时，通过修改文本段将该 nop 替换为跳转指令，直接跳转到具体模块的 Hook 函数。

这意味着：

• 无 LSM 模块时：Hook 点是零开销的，仅为一条 nop 指令
• 有 LSM 模块时：调用开销为单次跳转，无需函数指针解引用
• 运行时切换：注册/注销模块时动态 patch 文本段

2.2 LSM 间的协作与冲突解决

当多个 LSM 同时注册了同一个 Hook 时，内核按注册顺序依次调用。第一个返回非零值的模块即终止链式调用。这就是所谓的「第一个拒绝者胜出」规则。

// 内核 security/security.c 中的核心逻辑
int security_vm_enough_mm(struct mm_struct *mm, long pages)
{
    struct security_hook_list *hp;
    int rc = 0;

    hlist_for_each_entry(hp, &security_hook_heads.vm_enough_mm, list) {
        rc = hp->hook.vm_enough_mm(mm, pages);
        if (rc)
            break;  // 第一个非零返回值即终止
    }
    return rc;
}

这种简单策略带来一个重要推论：不存在 LSM 优先级覆盖机制。一个低优先级的模块如果排在前面，会先于高优先级模块做出决策。

2.3 BPF LSM 的动态钩子

BPF LSM 引入了一种独特的机制：允许通过 BPF 程序动态注册 Hook，而无需编译内核模块。这依赖于 LSM 框架中预定义的 BPF 专用 Hook 点：

// include/linux/lsm_bpf.h
BPF_LSM_HOOK(inode_security, struct inode *, struct inode *inode);
BPF_LSM_HOOK(file_permission, struct file *file, int mask);
BPF_LSM_HOOK(task_alloc, struct task_struct *task, unsigned long clone_flags);
BPF_LSM_HOOK(bpf, int cmd, union bpf_attr *attr, unsigned int size);

通过 bpf(BPF_RAW_TRACEPOINT_OPEN) 附加到 LSM 探针，可以在运行时动态修改安全策略，甚至根据系统状态做出实时决策。

三、实战：构建 AI Agent 沙箱安全模块

3.1 需求分析

我们需要为 AI Agent 运行时实现以下安全策略：

1. 系统调用白名单：Agent 进程只能执行预定义的系统调用集合（如 open, read, write, mmap 等常规操作），禁止 ptrace, mount, reboot 等危险调用
2. 文件访问控制：Agent 只能访问其工作目录 /var/ai-agents// 下的文件
3. 网络限制：仅允许对特定网关地址的连接，禁止直接外部网络访问
4. 资源配额审计：记录 Agent 的所有权限检查操作，用于事后审计

3.2 模块骨架

/* ai_agent_lsm.c - AI Agent 沙箱安全模块 */
#include <linux/lsm_hooks.h>
#include <linux/cred.h>
#include <linux/path.h>
#include <linux/dcache.h>
#include <linux/mount.h>
#include <linux/file.h>
#include <linux/net.h>
#include <linux/ip.h>
#include <linux/list.h>
#include <linux/jhash.h>
#include <linux/slab.h>
#include <linux/cred.h>
#include <linux/bpf-cgroup.h>
#include <uapi/linux/bpf.h>

#define AI_AGENT_MAX_AGENTS 256
#define AI_AGENT_HASH_BITS 8

/* 每个 Agent 实例的安全上下文 */
struct ai_agent_security {
    pid_t agent_pid;        /* Agent 主进程 PID */
    uid_t agent_uid;        /* Agent 运行 UID */
    gid_t agent_gid;        /* Agent 运行 GID */
    char work_dir[256];     /* 工作目录路径 */
    __be32 gateway_ip;      /* 允许连接的网关 IP */
    __be32 gateway_netmask; /* 网关子网掩码 */
};

/* 全局 Agent 注册表（使用哈希表） */
struct ai_agent_map {
    struct hlist_head heads[1 << AI_AGENT_HASH_BITS];
    spinlock_t lock;
};

static struct ai_agent_map agent_map;

static inline struct hlist_head *agent_hash_bucket(pid_t pid)
{
    u32 hash = jhash_1val(pid, 0);
    return &agent_map.heads[hash & ((1 << AI_AGENT_HASH_BITS) - 1)];
}

/* 查找 Agent 安全上下文 */
static inline struct ai_agent_security *agent_find(pid_t pid)
{
    struct ai_agent_security *sec;
    struct hlist_head *bucket = agent_hash_bucket(pid);
    
    hlist_for_each_entry_rcu(sec, bucket, hlist) {
        if (sec->agent_pid == pid)
            return sec;
    }
    return NULL;
}

3.3 核心 Hook 实现

文件权限检查 Hook

这是沙箱最核心的 Hook：拦截所有文件操作，验证目标路径是否在 Agent 工作目录内。

/* 
 * file_permission Hook - 检查文件访问是否在 Agent 工作目录内
 *
 * 处理流程：
 * 1. 检查当前进程是否属于已注册的 Agent
 * 2. 解析目标文件系统路径
 * 3. 验证路径是否为 Agent 工作目录的前缀
 * 4. 对敏感路径（如 /proc/1/, /etc/shadow）施加额外限制
 */
static int ai_agent_file_permission(struct file *file, int mask)
{
    struct ai_agent_security *sec;
    const char *filepath;
    struct path *target_path;
    char buf[512];
    bool allowed = false;
    
    rcu_read_lock();
    sec = agent_find(task_tgid_nr(current));
    rcu_read_unlock();
    
    if (!sec)
        return 0; /* 非 Agent 进程，放行 */
    
    /* 解析文件路径 */
    target_path = &file->f_path;
    filepath = d_path(target_path, buf, sizeof(buf));
    if (IS_ERR(filepath))
        return -ENOMEM;
    
    /* 检查是否以工作目录为前缀 */
    if (strncmp(filepath, sec->work_dir, strlen(sec->work_dir)) == 0)
        allowed = true;
    
    /* 额外规则：只读访问放行通用只读路径 */
    if (!allowed && (mask & MAY_WRITE) == 0) {
        static const char *readonly_whitelist[] = {
            "/usr/lib/",
            "/usr/share/locale/",
            "/etc/ssl/certs/",
            "/lib/modules/" KERNEL_VERSION(5, 0, 0) "/",
            NULL
        };
        for (int i = 0; readonly_whitelist[i]; i++) {
            if (strncmp(filepath, readonly_whitelist[i],
                       strlen(readonly_whitelist[i])) == 0) {
                allowed = true;
                break;
            }
        }
    }
    
    if (!allowed) {
        /* 审计日志 */
        audit_log(current->ai, GFP_KERNEL,
                  "AI Agent %d denied access: %s (mask=0x%x) "
                  "work_dir=%s",
                  current->tgid, filepath, mask, sec->work_dir);
        return -EACCES;
    }
    
    return 0;
}

Socket 连接 Hook

限制 Agent 进程只能连接到指定网关，防止数据泄露。

/*
 * socket_connect Hook - 限制网络连接目标
 *
 * AI Agent 需要连接 LLM API 网关，但不能直接访问外部网络。
 * 此 Hook 验证目标地址是否匹配配置的网关 IP/子网。
 */
static int ai_agent_socket_connect(struct socket *sock,
                                    struct sockaddr *addr, int addrlen)
{
    struct ai_agent_security *sec;
    struct sockaddr_in *sin = (struct sockaddr_in *)addr;
    __be32 target_ip;
    __be32 masked_target, masked_gateway;
    
    if (addr->sa_family != AF_INET)
        return 0; /* IPv6 放行，可类似处理 */
    
    rcu_read_lock();
    sec = agent_find(task_tgid_nr(current));
    rcu_read_unlock();
    
    if (!sec)
        return 0; /* 非 Agent 进程 */
    
    target_ip = sin->sin_addr.s_addr;
    
    /* 允许回环地址 */
    if ((ntohl(target_ip) & 0xFF000000) == 0x7F000000)
        return 0;
    
    /* 检查目标是否在网关子网内 */
    masked_target = target_ip & sec->gateway_netmask;
    masked_gateway = sec->gateway_ip & sec->gateway_netmask;
    
    if (masked_target != masked_gateway) {
        audit_log(current->ai, GFP_KERNEL,
                  "AI Agent %d denied connect: %pI4 (allowed: %pI4/%pI4)",
                  current->tgid, &target_ip,
                  &sec->gateway_ip, &sec->gateway_netmask);
        return -ECONNREFUSED;
    }
    
    return 0;
}

任务安全上下文管理

当 Agent 进程通过 fork()/clone() 创建子进程时，安全上下文需要继承。

/*
 * task_alloc Hook - 继承 Agent 安全上下文
 *
 * 当已注册 Agent 创建子进程时，自动继承沙箱配置。
 * 这是实现「Agent 工作负载隔离」的关键。
 */
static int ai_agent_task_alloc(struct task_struct *task,
                               unsigned long clone_flags)
{
    struct ai_agent_security *parent_sec, *child_sec;
    struct task_struct *parent = current;
    
    parent_sec = agent_find(task_tgid_nr(parent));
    if (!parent_sec)
        return 0; /* 非 Agent 进程创建的子进程 */
    
    /* 仅对 CLONE_THREAD 标志的线程继承沙箱 */
    if (!(clone_flags & CLONE_THREAD))
        return 0;
    
    child_sec = kzalloc(sizeof(*child_sec), GFP_KERNEL);
    if (!child_sec)
        return -ENOMEM;
    
    memcpy(child_sec, parent_sec, sizeof(*child_sec));
    child_sec->agent_pid = task_tgid_nr(task);
    
    spin_lock(&agent_map.lock);
    hlist_add_head_rcu(&child_sec->hlist,
                       agent_hash_bucket(child_sec->agent_pid));
    spin_unlock(&agent_map.lock);
    
    return 0;
}

/*
 * task_free Hook - 清理 Agent 安全上下文
 */
static void ai_agent_task_free(struct task_struct *task)
{
    struct ai_agent_security *sec;
    
    sec = agent_find(task_tgid_nr(task));
    if (!sec)
        return;
    
    spin_lock(&agent_map.lock);
    hlist_del_rcu(&sec->hlist);
    spin_unlock(&agent_map.lock);
    
    kfree_rcu(sec, rcu);
}

模块加载权限 Hook

防止 Agent 进程加载非授权的内核模块。

/*
 * kernel_module_request Hook - 禁止 Agent 请求模块加载
 */
static int ai_agent_kernel_module_request(const char *kmod_name)
{
    struct ai_agent_security *sec;
    
    sec = agent_find(task_tgid_nr(current));
    if (!sec)
        return 0;
    
    audit_log(current->ai, GFP_KERNEL,
              "AI Agent %d denied module request: %s",
              current->tgid, kmod_name);
    return -EPERM;
}

/*
 * bpf Hook - 禁止 Agent 创建 BPF 程序（防止绕过沙箱）
 */
static int ai_agent_bpf(int cmd, union bpf_attr *attr, unsigned int size)
{
    struct ai_agent_security *sec;
    
    sec = agent_find(task_tgid_nr(current));
    if (!sec)
        return 0;
    
    /* 只允许查询操作，禁止加载和附加 */
    switch (cmd) {
    case BPF_MAP_LOOKUP_ELEM:
    case BPF_MAP_GET_NEXT_KEY:
    case BPF_MAP_GET_NEXT_ID:
    case BPF_MAP_GET_FD_BY_ID:
    case BPF_PROG_GET_FD_BY_ID:
    case BPF_OBJ_GET_INFO_BY_FD:
        return 0;
    default:
        audit_log(current->ai, GFP_KERNEL,
                  "AI Agent %d denied bpf cmd=%d", current->tgid, cmd);
        return -EPERM;
    }
}

3.4 模块注册与配置接口

/* 定义所有 Hook */
static struct security_hook_list ai_agent_hooks[] __lsm_ro_after_init = {
    LSM_HOOK_INIT(file_permission, ai_agent_file_permission),
    LSM_HOOK_INIT(socket_connect, ai_agent_socket_connect),
    LSM_HOOK_INIT(socket_bind, ai_agent_socket_bind),
    LSM_HOOK_INIT(task_alloc, ai_agent_task_alloc),
    LSM_HOOK_INIT(task_free, ai_agent_task_free),
    LSM_HOOK_INIT(kernel_module_request, ai_agent_kernel_module_request),
    LSM_HOOK_INIT(bpf, ai_agent_bpf),
};

/* 通过 sysfs 注册 Agent */
static ssize_t ai_agent_register(struct kobject *kobj,
                                  struct kobj_attribute *attr,
                                  const char *buf, size_t count)
{
    struct ai_agent_security *sec;
    pid_t pid;
    char work_dir[256];
    __be32 gateway;
    __be32 netmask = htonl(0xFFFFFF00); /* /24 默认 */
    
    if (sscanf(buf, "%d %255s %pI4", &pid, work_dir, &gateway) < 3)
        return -EINVAL;
    
    sec = kzalloc(sizeof(*sec), GFP_KERNEL);
    if (!sec)
        return -ENOMEM;
    
    sec->agent_pid = pid;
    sec->agent_uid = __kuid_val(current_uid());
    sec->agent_gid = __kgid_val(current_gid());
    strscpy(sec->work_dir, work_dir, sizeof(sec->work_dir));
    sec->gateway_ip = gateway;
    sec->gateway_netmask = netmask;
    
    spin_lock(&agent_map.lock);
    hlist_add_head_rcu(&sec->hlist, agent_hash_bucket(pid));
    spin_unlock(&agent_map.lock);
    
    pr_info("AI Agent LSM: registered agent pid=%d work_dir=%s gw=%pI4\n",
            pid, work_dir, &gateway);
    return count;
}

static struct kobj_attribute register_attr =
    __ATTR(register, 0220, NULL, ai_agent_register);

static int __init ai_agent_lsm_init(void)
{
    int i;
    
    /* 初始化哈希表 */
    for (i = 0; i < (1 << AI_AGENT_HASH_BITS); i++)
        INIT_HLIST_HEAD(&agent_map.heads[i]);
    spin_lock_init(&agent_map.lock);
    
    /* 注册 sysfs 接口 */
    sysfs_create_kobj(&aixx_ktype);
    security_add_hooks(ai_agent_hooks,
                       ARRAY_SIZE(ai_agent_hooks),
                       "ai_agent");
    
    pr_info("AI Agent LSM: initialized\n");
    return 0;
}

DEFINE_LSM(ai_agent) = {
    .name = "ai_agent",
    .init = ai_agent_lsm_init,
};

3.5 Makefile 与 Kconfig

# Makefile
obj-$(CONFIG_SECURITY_AI_AGENT) += ai_agent_lsm.o

# Kconfig
config SECURITY_AI_AGENT
    bool "AI Agent sandbox LSM"
    depends on SECURITY && AUDIT
    default n
    help
      This module provides LSM hooks that restrict AI Agent
      processes to their assigned work directories and approved
      network gateways.

四、与 BPF LSM 的对比及选型建议

4.1 原生模块 vs BPF LSM 的核心差异

4.2 混合架构实践

在 AI Agent 沙箱场景中，最佳实践常采用混合策略：

• BPF LSM 用于策略层：动态调节允许的网络白名单、文件路径规则
• 原生模块用于不可变层：强制执行 BPF LSM 无法绕过的硬限制（如模块加载禁止、原始套接字禁止）
• 用户态守护进程：通过 netlink 与内核模块通信，实时更新 Agent 注册信息

┌─────────────────────────────────────────┐
│   用户态守护进程 (ai-sandboxd)           │
│   - CLI/API 接口                         │
│   - Agent 生命周期管理                    │
│   - 策略引擎                             │
│   - 审计日志收集                         │
└──────────────┬──────────────────────────┘
               │ netlink / cgroup / sysfs
               ▼
┌─────────────────────────────────────────┐
│   BPF LSM 程序                           │
│   - 动态网络白名单更新                    │
│   - 文件系统路径正则匹配                  │
│   - 资源配额追踪                          │
└──────────────┬──────────────────────────┘
               │ 协作 / 共同决策
               ▼
┌─────────────────────────────────────────┐
│   原生 LSM 模块 (硬限制层)               │
│   - 禁止模块加载 (CAP_SYS_MODULE check)  │
│   - 禁止原始套接字 (socket AF_RAW check) │
│   - BPF自身操作审计                       │
└─────────────────────────────────────────┘

五、性能影响与生产部署考量

5.1 开销测量

使用 lmbench 和自研 benchmark 对 AI Agent LSM 模块进行开销测试：

主要开销来源：RCU 读取锁保护下的哈希表查找，以及 d_path() 路径解析。

5.2 优化策略

RCU 化所有读路径：Agent 注册和注销使用 spinlock，所有 Hook 中的查找操作使用 rcu_read_lock()。这确保了在多核系统上的读路径几乎零争用。

路径缓存：为了减少 d_path() 的调用开销，可以为每个 Agent 维护一个路径前缀缓存：

struct ai_agent_path_cache {
    struct path work_dir_path; /* 预先解析的 work_dir path 对象 */
    unsigned int path_len;
    bool initialized;
};

使用 Static Key 全局开关：当没有注册任何 Agent 时，通过静态键完全绕过所有 LSM Hook 的检查逻辑：

static DEFINE_STATIC_KEY_FALSE(ai_agent_enabled);

static int ai_agent_file_permission(struct file *file, int mask)
{
    if (!static_branch_unlikely(&ai_agent_enabled))
        return 0;
    /* 正常检查逻辑... */
}

5.3 部署清单

生产部署 AI Agent LSM 模块需要以下步骤：

# 1. 验证 CONFIG_SECURITY_AI_AGENT 已启用
grep CONFIG_SECURITY_AI_AGENT /boot/config-$(uname -r)

# 2. 确保内核启用 LSM stacking
cat /sys/kernel/security/lsm
# 输出应包含: lockdown,landlock,yama,ai_agent,bpf

# 3. 加载模块
insmod ai_agent_lsm.ko

# 4. 配置内核参数（推荐: 仅堆叠不替代 SELinux）
# 在 /etc/default/grub 的 GRUB_CMDLINE_LINUX 中添加:
# lsm=lockdown,yama,selinux,ai_agent,bpf

# 5. 启动 Agent 时使用 sysfs 注册
echo "1234 /var/ai-agents/agent-001 10.0.1.10" > \
    /sys/kernel/security/ai_agent/register

# 6. 启动 Agent exec
nsenter --mount --pid --fork \
    chroot /var/ai-agents/agent-001 /usr/bin/ai-agent --mode=sandboxed

六、LSM 在 AI 基础设施中的扩展应用

6.1 模型文件保护

通过 file_open Hook 对 AI 模型文件（.safetensors, .gguf, .ckpt）施加完整性校验，在文件打开时验证其哈希值是否与预注册的一致，防止模型投毒攻击。

6.2 GPU 设备访问控制

通过 bpf Hook 限制对 /dev/nvidia 和 /dev/dri/ 的 ioctl 操作类型，确保 Agent 只能发起安全的 GPU 计算请求，而不能执行 GPU 调试或功耗控制等危险操作。

6.3 模型推理延迟 SLA 利用 task_fix_setuid 和 task_fix_setgid Hook，当 Agent 进程尝试提升权限时触发实时告警，结合 eBPF 统计调度延迟指标。

6.4 模型权重加密存储联动

与内核 fs-crypt 模块协同，通过 inode_setattr Hook 确保 Agent 创建的新文件继承工作目录的加密上下文，防止明文模型权重泄漏到未加密位置。

七、常见陷阱与生产经验

7.1 Deadlock 风险

在 LSM Hook 中绝对不能做的事情：

• 获取该 Hook 路径上已持有的同一把锁
• 发起可能导致重新进入同一 Hook 的操作（如在 file_permission Hook 中打开文件）
• 调用可能触发同一 Hook 的内核 API（如在 socket_connect 中发起本地连接）

7.2 审计日志风暴

当 Agent 进程频繁执行大量文件操作时，audit_log() 可能成为性能瓶颈。解决方案：

• 使用 audit_log_start() 批量提交
• 实现每-Agent 的日志速率限制
• 高频率日志通过 tracepoint + BPF ringbuffer 异步收集

7.3 模块引用计数问题

如果 Hook 操作中使用了其他内核模块导出的符号（如 d_path() 内部调用），必须确保这些模块不会被提前卸载。使用 try_module_get() 或依赖自动符号引用。

7.4 安全模块堆叠顺序

正确的 LSM 顺序至关重要：lsm=lockdown,yama,selinux,ai_agent,bpf

• lockdown 最先执行，保护内核自身完整性
• ai_agent 在 selinux 之后，确保非 Agent 相关决策不被影响
• bpf 最后执行，用于动态策略调整

八、调试与排错

8.1 Tracepoint 注入

为了在不停机的情况下调试 Hook 行为，可在 Hook 函数中插入 tracepoint：

trace_ai_agent_file_check(current->tgid, filepath, mask, allowed);

对应的用户态追踪脚本：

from bcc import BPF

bpf_text = """
TRACEPOINT_PROBE(ai_agent, file_check) {
    bpf_trace_printk("agent=%d file=%s mask=%d allowed=%d\\n",
                     args->pid, args->path, args->mask, args->allowed);
    return 0;
}
"""
b = BPF(text=bpf_text)
b.trace_print()

8.2 kprobe 辅助 Hook 调试

当 LSM 模块已加载但策略似乎未生效时，可使用 kprobe 验证是否真的可达 Hook 调用路径：

# 跟踪 Hook 函数是否被调用
echo 'p:myprobe ai_agent_file_permission file=%di mask=%si' > \
    /sys/kernel/debug/tracing/kprobe_events
echo 1 > /sys/kernel/debug/tracing/events/kprobes/myprobe/enable
cat /sys/kernel/debug/tracing/trace_pipe

九、总结与展望

LSM Hook 框架是 Linux 安全架构中最核心的扩展机制之一。通过理解其静态键优化、堆叠式决策和 RCU 化的查找机制，我们能够构建既高性能又安全可靠的内核级沙箱。

对于 AI Agent 这一新兴安全边界，单纯的配置级策略（AppArmor profile、SELinux policy）已无法满足动态运行时需求。混合架构——原生 LSM 模块提供硬保障、BPF LSM 提供灵活性、用户态守护进程提供管理能力——正在成为生产级 Agent 安全运行时的标准范式。

随着内核生态的发展，One day 我们或许能看到专门面向 AI 工作负载的 LSM 模块进入主线——彼时，Agent 沙箱将不再是少数大型企业的专利，而是每个 Linux 用户都能使用的标准安全能力。

参考资料

• security/security.c - 内核 LSM 核心框架
• include/linux/lsm_hooks.h - LSM Hook 定义全集
• security/selinux/ - 参考 SELinux 实现最佳实践
• kernel/bpf/syscall.c - BPF LSM 附加机制
• Documentation/admin-guide/LSM/ - 内核官方文档及多个 LSM 的堆叠指南