Linux Landlock LSM 深入实战：非特权沙盒从原理到容器安全的全面指南

enum landlock_rule_type {
    LANDLOCK_RULE_PATH_BENEATH,   // 路径规则：指定目录下的操作
    LANDLOCK_RULE_NET_PORT,       // 网络规则：指定端口（v4+）
};

struct landlock_ruleset_attr {
    __u64 handled_access_fs;    // 这个 ruleset 要管控的访问类型
    __u64 handled_access_net;   // 网络访问类型（可选）
};

struct landlock_path_beneath_attr {
    __u64 allowed_access;       // 允许的访问类型
    __s32 parent_fd;            // 父目录的 fd
};

用户进程做文件操作
  ↓
系统调用进入内核
  ↓
VFS 层 → 触发 LSM hook (如 file_permission)
  ↓
landlock_file_permission() 被调用
  ├─ 遍历该进程的所有 Landlock ruleset（从最新到最旧）
  ├─ 对每个 ruleset，检查路径是否匹配某条规则
  │   ├─ 匹配 && 权限允许 → 继续检查下一条
  │   ├─ 匹配 && 权限拒绝 → 返回 -EACCES
  │   └─ 不匹配 → 跳过此条规则
  ├─ 如果所有规则都检查完毕仍未允许
  └─ 如果没有任何规则覆盖该对象 → -EACCES（默认拒绝）

#include <sys/syscall.h>
#include <sys/prctl>
#include <linux/landlock.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main(int argc, char *argv[])
{
    struct landlock_ruleset_attr ruleset_attr = {
        .handled_access_fs = LANDLOCK_ACCESS_FS_EXECUTE
                            | LANDLOCK_ACCESS_FS_READ_FILE
                            | LANDLOCK_ACCESS_FS_READ_DIR,
    };
    int ruleset_fd, allowed_fd;

    // 第1步：要求内核支持 Landlock（防止旧内核静默忽略）
    prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY);  // 可选: 允许 ptrace

    // 第2步：创建 ruleset
    ruleset_fd = syscall(__NR_landlock_create_ruleset,
                          &ruleset_attr, sizeof(ruleset_attr), 0);
    if (ruleset_fd < 0) {
        perror("landlock_create_ruleset");
        return 1;
    }

    // 第3步：添加规则 — 允许读取 /tmp/allowed_dir
    allowed_fd = open("/tmp/allowed_dir", O_PATH | O_CLOEXEC);
    struct landlock_path_beneath_attr path_beneath = {
        .allowed_access = LANDLOCK_ACCESS_FS_READ_FILE
                        | LANDLOCK_ACCESS_FS_READ_DIR,
        .parent_fd = allowed_fd,
    };
    syscall(__NR_landlock_add_rule, ruleset_fd,
            LANDLOCK_RULE_PATH_BENEATH, &path_beneath, 0);
    close(allowed_fd);

    // 第4步：启用 Landlock（从此刻起规则生效且不可撤回）
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
        perror("prctl(PR_SET_NO_NEW_PRIVS)");
        return 1;
    }
    if (syscall(__NR_landlock_restrict_self, ruleset_fd, 0)) {
        perror("landlock_restrict_self");
        return 1;
    }
    close(ruleset_fd);

    // 从此时起，进程只能读取 /tmp/allowed_dir
    // 任何其他文件访问都将得到 EACCES
    return 0;
}

use landlock::{
    Access, AccessFs, Ruleset, RulesetAttr, RulesetCreated, RulesetCreatedAttr,
    RulesetStatus, path_beneath_rules, AccessFs, ABI,
};
use std::os::unix::io::AsRawFd;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 定义要管控的权限集
    let abi = ABI::V1;
    let access = AccessFs::from_all(abi);

    // 创建 ruleset
    let ruleset = Ruleset::new()
        .handle_access(access)?
        .create()?;

    // 添加允许的规则
    let rules = path_beneath_rules(
        ["/var/app/data", "/tmp/work"].iter(),
        AccessFs::from_read(abi),
    );

    // 应用规则
    let _ = ruleset.add_rules(rules)?.restrict_self()?;

    // 沙盒已生效
    Ok(())
}

/* 推荐的应用顺序 */

// 1. 先 fork，让子进程成为后续规则的目标
fork();

// 2. 启用 NO_NEW_PRIVS（提权防护）
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);

// 3. 先装 seccomp（限制 executes 以及非必要的系统调用）
seccomp(STRICT);  // 仅允许 read/write/exit/sigreturn

// 4. 再装 Landlock（限制文件访问范围）
landlock_restrict_self();

// 5. 最后 exec 目标程序
execve(target_binary);

# 在 Docker 容器入口脚本中使用 Landlock
# docker-entrypoint.sh
set -e

# 编译并运行一个使用 Landlock 的最小包装器
gcc -o /usr/local/bin/landlock-wrap scripts/landlock-wrap.c || true

# 用 Landlock 限制应用只能访问必要目录，然后 exec 应用
exec /usr/local/bin/landlock-wrap \
    --allow-read /var/app/data \
    --allow-write /var/app/tmp \
    --allow-read /usr/share \
    -- \
    /usr/local/bin/my-app "$@"

// hooks.json（OCI hooks 配置）
{
  "version": "1.0.0",
  "hook": {
    "path": "/usr/local/bin/landlock-hook",
    "args": ["landlock-hook", "--config", "/etc/landlock.yaml"]
  },
  "stages": ["prestart"],
  "when": {
    "always": true
  }
}

# LXC 配置文件配置 Landlock
lxc.apparmor.profile = unconfined      # 不需要 AppArmor
lxc.hook.pre-start = /usr/local/bin/lxc-landlock-hook

# 策略文件: /var/lib/lxc/mycontainer/landlock.yaml
landlock:
  fs:
    deny:
      - /
    allow:
      - path: /var/www/html
        access:
          - execute
          - read_file
          - read_dir
      - path: /var/log/myapp
        access:
          - write_file
          - read_file

// Flatpak bubblewrap + Landlock 伪代码
// 1. 启动 bwrap 创建隔离环境
bwrap --ro-bind /usr /usr \
      --ro-bind /bin /bin \
      --dir /tmp \
      --proc /proc \
      --dev /dev \
      // 2. 在新的 mount namespace 中应用 Landlock
      landlock-writer \
        --fs-deny / \
        --fs-allow-read /usr \
        --fs-allow-read /tmp \
        --fs-allow-write /tmp \
        --exec firefox

# /etc/systemd/system/my-webapp.service
[Unit]
Description=My Web Application

[Service]
Type=simple
ExecStart=/usr/local/bin/webapp

# Landlock 规则（systemd 253+）
LandlockPaths=/var/lib/webapp:ro
LandlockPaths=/var/log/webapp:rw
LandlockPaths=/etc/ssl:ro
LandlockWritablePaths=/var/lib/webapp/tmp

# 配合其他沙盒选项
NoNewPrivileges=yes
SystemCallFilter=@system-service @module

[Install]
WantedBy=multi-user.target

/* 推荐做法：按 ABI 版本降级尝试 */
int try_landlock(void) {
    int abi = landlock_create_ruleset(NULL, 0,
                                      LANDLOCK_CREATE_RULESET_VERSION);
    switch (abi) {
        case 5: /* v5: 网络 + Ioctl 全功能 */
        case 4: /* v4: 网络 */
        case 3: /* v3: Ioctl 控制 */
        case 2: /* v2: Truncate */
        case 1: /* v1: Basic FS 控制 */
            return setup_rules(abi);
        case -1:
            /* 旧内核不支持 Landlock，程序降级运行 */
            return 0;
    }
}