Day-218-渗透测试中的微服务安全测试

# Day 253: 渗透测试中的微服务安全测试

> 渗透测试系列第 53 篇 | 预计阅读时间：45 分钟 | 难度：★★★★★

---

## 清单 目录
1. [微服务架构概述](#微服务架构概述)
2. [微服务安全挑战](#微服务安全挑战)
3. [微服务信息收集](#微服务信息收集)
4. [API 网关安全测试](#api-网关安全测试)
5. [服务间通信安全](#服务间通信安全)
6. [容器安全测试](#容器安全测试)
7. [服务注册与发现安全](#服务注册与发现安全)
8. [配置管理安全](#配置管理安全)
9. [认证授权测试](#认证授权测试)
10. [微服务安全测试工具](#微服务安全测试工具)
11. [微服务安全加固](#微服务安全加固)
12. [实战案例](#实战案例)
13. [总结与思考](#总结与思考)
14. [参考资料](#参考资料)

---

## 微服务架构概述

### 什么是微服务

微服务架构是一种将单一应用程序开发为一组小型服务的方法，每个服务都在自己的进程中运行，并使用轻量级机制 (通常是 HTTP API) 进行通信。

```
┌─────────────────────────────────────────────────────────────┐
│                    微服务 vs 单体架构                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  单体架构：                                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │                    单体应用                          │   │
│  │  ┌───────────────────────────────────────────────┐  │   │
│  │  │  UI  +  业务逻辑  +  数据访问  +  数据库       │  │   │
│  │  └───────────────────────────────────────────────┘  │   │
│  └─────────────────────────────────────────────────────┘   │
│  优点：简单、易部署                                         │
│  缺点：耦合高、扩展难                                       │
│                                                             │
│  微服务架构：                                                │
│  ┌─────────────────────────────────────────────────────┐   │
│  │                   API 网关                            │   │
│  └─────────────────────────────────────────────────────┘   │
│       ↓         ↓         ↓         ↓                       │
│  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐              │
│  │ 用户服务│ │ 订单服务│ │ 支付服务│ │ 商品服务│              │
│  └────────┘ └────────┘ └────────┘ └────────┘              │
│       ↓         ↓         ↓         ↓                       │
│  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐              │
│  │ 数据库  │ │ 数据库  │ │ 数据库  │ │ 数据库  │              │
│  └────────┘ └────────┘ └────────┘ └────────┘              │
│                                                             │
│  优点：解耦、易扩展、独立部署                               │
│  缺点：复杂度高、运维难                                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 微服务组件

```
微服务核心组件:
├── API 网关
│   ├── 请求路由
│   ├── 认证授权
│   └── 限流熔断
├── 服务注册与发现
│   ├── 服务注册
│   ├── 服务发现
│   └── 健康检查
├── 配置中心
│   ├── 配置管理
│   ├── 动态刷新
│   └── 版本控制
├── 服务通信
│   ├── 同步通信 (HTTP/RPC)
│   └── 异步通信 (消息队列)
└── 监控链路
    ├── 日志收集
    ├── 链路追踪
    └── 指标监控
```

### 微服务安全测试范围

```
微服务安全测试:
├── 网关安全
│   ├── 认证绕过
│   ├── 授权测试
│   └── 限流绕过
├── 服务安全
│   ├── 服务间认证
│   ├── 接口安全
│   └── 数据安全
├── 通信安全
│   ├── 加密传输
│   ├── 证书验证
│   └── 中间人攻击
├── 容器安全
│   ├── 镜像安全
│   ├── 运行时安全
│   └── 编排安全
└── 配置安全
    ├── 敏感配置
    ├── 密钥管理
    └── 环境隔离
```

---

## 微服务安全挑战

### 攻击面扩大

```
微服务攻击面:
├── 服务数量多
│   └── 每个服务都是潜在入口
├── API 数量多
│   └── 每个 API 都可能被攻击
├── 网络复杂
│   ├── 服务间通信
│   └── 东西向流量
└── 依赖复杂
    ├── 第三方库
    └── 服务依赖
```

### 认证授权复杂

```
认证授权挑战:
├── 分布式认证
│   └── 跨服务认证
├── 权限粒度
│   └── 细粒度权限控制
├── Token 传递
│   ├── Token 传播
│   └── Token 验证
└── 会话管理
    └── 分布式会话
```

### 配置管理困难

```
配置管理挑战:
├── 配置分散
│   └── 多服务配置
├── 密钥管理
│   ├── 密钥分发
│   └── 密钥轮换
├── 环境差异
│   ├── 开发/测试/生产
│   └── 配置一致性
└── 动态更新
    └── 配置热更新
```

---

## 微服务信息收集

### 服务发现

```
服务发现方法:
├── API 网关
│   └── 网关路由配置
├── 服务注册中心
│   ├── Eureka
│   ├── Consul
│   └── Nacos
├── 配置文件
│   └── Kubernetes 配置
└── 网络扫描
    └── 内部网络扫描
```

```bash
# Kubernetes 服务发现
kubectl get services --all-namespaces
kubectl get pods --all-namespaces
kubectl get ingress --all-namespaces

# 获取服务详情
kubectl describe service service-name -n namespace

# 获取 Endpoints
kubectl get endpoints service-name -n namespace

# 查看服务标签
kubectl get pods --show-labels
```

### API 枚举

```
API 枚举方法:
├── Swagger/OpenAPI
│   └── /swagger.json
│   └── /v2/api-docs
├── API 文档
│   └── /api-docs
│   └── /docs
├── 网关配置
│   └── 路由规则
└── 流量分析
    └── 请求路径分析
```

```bash
# Swagger 文档发现
curl https://target.com/swagger.json
curl https://target.com/v2/api-docs
curl https://target.com/v3/api-docs

# API 文档发现
curl https://target.com/api-docs
curl https://target.com/docs
curl https://target.com/redoc

# 使用工具扫描
gobuster dir -u https://target.com -w api-wordlist.txt
dirsearch -u https://target.com -e json,yaml
```

### 服务依赖分析

```
服务依赖分析:
├── 调用链分析
│   └── 链路追踪数据
├── 配置分析
│   └── 服务依赖配置
├── 日志分析
│   └── 服务调用日志
└── 流量分析
    └── 服务间流量
```

```bash
# Kubernetes 查看服务依赖
kubectl get pods -o wide
kubectl get services -o wide

# 查看服务选择器
kubectl get svc service-name -o jsonpath='{.spec.selector}'

# 查看 Pod 标签
kubectl get pods --show-labels

# 查看服务依赖关系
kubectl get endpoints service-name -o yaml
```

---

## API 网关安全测试

### 网关绕过测试

```
网关绕过测试:
├── 直接访问服务
│   └── 绕过网关认证
├── 内部 IP 访问
│   └── 访问内部服务
├── 端口扫描
│   └── 发现暴露服务
└── 域名解析
    └── 内部域名解析
```

```bash
# 直接访问服务测试
# 1. 发现内部服务 IP
nslookup internal-service.default.svc.cluster.local

# 2. 直接访问服务
curl http://internal-service-ip:port/api/endpoint

# 3. 测试认证绕过
curl http://internal-service-ip:port/api/admin
# 如果返回数据，说明认证可绕过

# Kubernetes 端口转发
kubectl port-forward service/service-name 8080:80
curl http://localhost:8080/api/endpoint
```

### 认证绕过测试

```
认证绕过测试:
├── Token 缺失
│   └── 无 Token 访问
├── Token 伪造
│   └── 伪造 Token
├── Token 过期
│   └── 使用过期 Token
└── Token 复用
    └── 跨服务复用
```

```bash
# Token 缺失测试
curl https://target.com/api/protected
# 应该返回 401

# Token 伪造测试
curl https://target.com/api/protected \
    -H "Authorization: Bearer fake_token"

# Token 过期测试
curl https://target.com/api/protected \
    -H "Authorization: Bearer expired_token"

# 测试不同服务 Token 复用
# 获取服务 A 的 Token
TOKEN=$(curl -X POST https://target.com/auth/login -d '{"user":"test","pass":"test"}' | jq -r '.token')

# 使用服务 A 的 Token 访问服务 B
curl https://target.com/service-b/api/endpoint \
    -H "Authorization: Bearer $TOKEN"
```

### 限流绕过测试

```
限流绕过测试:
├── IP 轮换
│   └── 多 IP 请求
├── Token 轮换
│   └── 多 Token 请求
├── 路径变化
│   └── 不同路径请求
└── 并发请求
    └── 并发绕过限制
```

```bash
# IP 轮换测试
for i in {1..100}; do
    curl -H "X-Forwarded-For: 192.168.1.$i" \
        https://target.com/api/endpoint
done

# Token 轮换测试
for i in {1..100}; do
    curl -H "Authorization: Bearer token_$i" \
        https://target.com/api/endpoint
done

# 并发请求测试
for i in {1..100}; do
    curl https://target.com/api/endpoint &
done
wait
```

---

## 服务间通信安全

### 通信协议测试

```
通信协议测试:
├── HTTP/HTTPS
│   ├── 加密配置
│   └── 证书验证
├── gRPC
│   ├── 认证配置
│   └── 加密配置
├── 消息队列
│   ├── 认证配置
│   └── 加密配置
└── 服务网格
    └── mTLS 配置
```

```bash
# HTTPS 配置测试
# 检查是否使用 HTTPS
curl -I http://internal-service:port
# 应该重定向到 HTTPS

# 检查证书
openssl s_client -connect internal-service:port

# 检查证书有效期
echo | openssl s_client -connect internal-service:port 2>/dev/null | openssl x509 -noout -dates

# gRPC 测试
# 使用 grpcurl 测试
grpcurl -plaintext internal-service:port list
grpcurl -cert cert.pem -key key.pem internal-service:port list
```

### 中间人攻击测试

```
中间人攻击测试:
├── 证书验证缺失
│   └── 接受任意证书
├── 证书信任问题
│   └── 信任自签名证书
├── 加密降级
│   └── 强制弱加密
└── 协议降级
    └── 强制 HTTP
```

```bash
# 证书验证测试
# 1. 使用自签名证书
curl https://internal-service:port \
    --cacert self-signed.crt

# 2. 禁用证书验证
curl https://internal-service:port \
    -k

# 3. 测试证书固定
# 修改证书，测试服务是否拒绝连接

# 加密降级测试
# 测试是否支持弱加密套件
nmap --script ssl-enum-ciphers -p 443 internal-service
```

### 服务间认证测试

```
服务间认证测试:
├── 无认证
│   └── 服务间无认证
├── 弱认证
│   └── 简单 Token 认证
├── 认证绕过
│   └── 伪造服务身份
└── 权限提升
    └── 服务权限提升
```

```bash
# 服务间认证测试
# 1. 测试无认证访问
curl http://internal-service:port/api/internal

# 2. 伪造服务 Token
curl http://internal-service:port/api/internal \
    -H "X-Service-Token: fake_token"

# 3. 测试服务权限
# 使用服务 A 的身份访问服务 B
curl http://service-b:port/api/admin \
    -H "X-Service-Token: service-a-token"

# 4. 测试服务网格 mTLS
# 检查是否启用 mTLS
istioctl analyze
```

---

## 容器安全测试

### 镜像安全测试

```
镜像安全测试:
├── 漏洞扫描
│   └── 镜像漏洞
├── 配置检查
│   ├── 敏感信息
│   └── 不安全配置
├── 基础镜像
│   └── 基础镜像安全
└── 依赖检查
    └── 依赖漏洞
```

```bash
# 镜像漏洞扫描
# 使用 Trivy
trivy image myapp:latest

# 使用 Clair
clair-scanner -c http://clair:6060 myapp:latest

# 使用 Docker Scan
docker scan myapp:latest

# 检查镜像配置
docker history myapp:latest
docker inspect myapp:latest

# 检查敏感信息
docker run --rm myapp:latest env
docker run --rm myapp:latest cat /etc/passwd
```

### 运行时安全测试

```
运行时安全测试:
├── 特权容器
│   └── 特权模式检查
├── 能力检查
│   └── Linux 能力
├── 挂载检查
│   └── 卷挂载
└── 网络检查
    └── 网络模式
```

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

# 检查能力
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{" "}{.metadata.name}{" "}{.spec.containers[*].securityContext.capabilities.add}{"\n"}{end}'

# 检查卷挂载
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{" "}{.metadata.name}{" "}{.spec.volumes[*].hostPath.path}{"\n"}{end}'

# 检查网络模式
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{" "}{.metadata.name}{" "}{.spec.hostNetwork}{"\n"}{end}'
```

### 编排安全测试

```
编排安全测试:
├── RBAC 配置
│   └── 权限配置
├── 网络策略
│   └── 网络隔离
├── Pod 安全策略
│   └── 安全上下文
└── 密钥管理
    └── Secret 管理
```

```bash
# Kubernetes RBAC 检查
kubectl get clusterroles
kubectl get clusterrolebindings
kubectl get roles --all-namespaces
kubectl get rolebindings --all-namespaces

# 检查过度权限
kubectl auth can-i --list --as=system:serviceaccount:default:default

# 网络策略检查
kubectl get networkpolicies --all-namespaces

# Pod 安全策略检查
kubectl get psp

# Secret 检查
kubectl get secrets --all-namespaces
kubectl get secret secret-name -o yaml
```

---

## 服务注册与发现安全

### 服务注册安全

```
服务注册安全:
├── 未授权注册
│   └── 恶意服务注册
├── 服务欺骗
│   └── 伪造服务身份
├── 注册信息
│   └── 敏感信息泄露
└── 健康检查
    └── 健康检查绕过
```

```bash
# Consul 服务注册测试
# 1. 检查未授权访问
curl http://consul:8500/v1/catalog/services

# 2. 注册恶意服务
curl -X PUT http://consul:8500/v1/catalog/register \
    -d '{
        "Node": "attacker",
        "Address": "192.168.1.100",
        "Service": {
            "Service": "malicious-service",
            "Port": 8080
        }
    }'

# 3. 检查服务信息
curl http://consul:8500/v1/catalog/service/malicious-service

# Eureka 服务注册测试
curl http://eureka:8761/eureka/apps
```

### 服务发现安全

```
服务发现安全:
├── 信息泄露
│   └── 服务信息暴露
├── 服务枚举
│   └── 服务列表获取
├── 健康检查
│   └── 服务状态获取
└── DNS 劫持
    └── DNS 响应篡改
```

```bash
# 服务枚举测试
# Consul
curl http://consul:8500/v1/catalog/services

# Eureka
curl http://eureka:8761/eureka/apps

# Kubernetes
kubectl get services --all-namespaces
kubectl get endpoints --all-namespaces

# DNS 服务发现
nslookup _http._tcp.service.default.svc.cluster.local

# 检查 DNS 劫持
dig service.default.svc.cluster.local
```

---

## 配置管理安全

### 敏感配置测试

```
敏感配置测试:
├── 配置文件
│   ├── 硬编码凭证
│   └── 敏感信息
├── 环境变量
│   ├── 敏感变量
│   └── 变量泄露
├── 配置中心
│   ├── 未授权访问
│   └── 配置泄露
└── 密钥管理
    ├── 密钥存储
    └── 密钥轮换
```

```bash
# Kubernetes 配置检查
# 检查 ConfigMap
kubectl get configmaps --all-namespaces
kubectl get configmap config-name -o yaml

# 检查 Secret
kubectl get secrets --all-namespaces
kubectl get secret secret-name -o yaml

# 检查环境变量
kubectl exec pod-name -- env

# 检查挂载的 ConfigMap
kubectl describe pod pod-name | grep -A 5 "ConfigMap"

# Spring Cloud Config 测试
curl http://config-server:8888/app/dev
curl http://config-server:8888/app/prod
```

### 配置中心安全

```
配置中心安全:
├── 认证绕过
│   └── 未授权访问配置
├── 配置篡改
│   └── 恶意配置注入
├── 配置泄露
│   └── 敏感配置暴露
└── 动态更新
    └── 恶意配置更新
```

```bash
# Spring Cloud Config 安全测试
# 1. 未授权访问测试
curl http://config-server:8888/app/dev
curl http://config-server:8888/app/prod

# 2. 敏感配置测试
curl http://config-server:8888/app/db-password

# 3. 配置篡改测试
curl -X POST http://config-server:8888/app/dev \
    -H "Content-Type: application/json" \
    -d '{"malicious": "config"}'

# 4. 刷新配置测试
curl -X POST http://app-server:8080/actuator/refresh
```

---

## 认证授权测试

### 分布式认证测试

```
分布式认证测试:
├── JWT Token
│   ├── Token 验证
│   ├── Token 传递
│   └── Token 刷新
├── OAuth 2.0
│   ├── 授权码流程
│   ├── 客户端凭证
│   └── Token 内省
└── mTLS
    ├── 证书验证
    └── 双向认证
```

```bash
# JWT Token 测试
# 1. Token 验证测试
curl https://target.com/api/protected \
    -H "Authorization: Bearer invalid_token"

# 2. Token 传递测试
# 检查 Token 是否在服务间传递
curl https://target.com/service-a/api/call-service-b \
    -H "Authorization: Bearer valid_token"

# 3. Token 刷新测试
curl -X POST https://target.com/auth/refresh \
    -H "Authorization: Bearer refresh_token"

# OAuth 2.0 测试
# 1. 授权码劫持测试
# 2. 客户端凭证测试
curl -X POST https://target.com/oauth/token \
    -d "grant_type=client_credentials" \
    -d "client_id=client" \
    -d "client_secret=secret"
```

### 服务间授权测试

```
服务间授权测试:
├── 服务身份
│   └── 服务身份验证
├── 服务权限
│   └── 服务权限检查
├── 跨服务调用
│   └── 跨服务授权
└── 权限提升
    └── 服务权限提升
```

```bash
# 服务间授权测试
# 1. 测试服务身份验证
curl http://service-a:port/api/internal \
    -H "X-Service-Name: fake-service"

# 2. 测试服务权限
# 使用低权限服务访问高权限接口
curl http://service-b:port/api/admin \
    -H "X-Service-Name: low-privilege-service"

# 3. 测试跨服务调用
# 服务 A 调用服务 B，检查授权
curl http://service-a:port/api/call-service-b

# 4. 测试权限提升
# 修改服务角色/权限
curl -X PUT http://service-a:port/api/role \
    -H "Content-Type: application/json" \
    -d '{"role": "admin"}'
```

---

## 微服务安全测试工具

### 测试工具

| 工具 | 用途 | 链接 |
|------|------|------|
| **Trivy** | 镜像扫描 | https://github.com/aquasecurity/trivy |
| **kube-bench** | K8s 检查 | https://github.com/aquasecurity/kube-bench |
| **kube-hunter** | K8s 渗透 | https://github.com/aquasecurity/kube-hunter |
| **istioctl** | Istio 分析 | https://istio.io/ |
| **grpcurl** | gRPC 测试 | https://github.com/fullstorydev/grpcurl |
| **postman** | API 测试 | https://www.postman.com/ |
| **burp** | 综合测试 | https://portswigger.net/burp |

### Kubernetes 安全工具

```bash
# kube-bench CIS 基准检查
kube-bench run --targets=master
kube-bench run --targets=node

# kube-hunter 渗透测试
kube-hunter --remote <cluster-ip>
kube-hunter --pod

# kubectl 安全检查
kubectl auth can-i --list
kubectl get pods --all-namespaces -o jsonpath='{range .items[*]}{.metadata.namespace}{" "}{.metadata.name}{" "}{.spec.containers[*].securityContext.privileged}{"\n"}{end}'

# Datadog 安全检查
# 使用 Cluster Agent 检查配置
```

### 服务网格安全工具

```bash
# Istio 安全检查
# 检查 mTLS 状态
istioctl analyze

# 检查认证策略
istioctl get peerauthentication --all-namespaces

# 检查授权策略
istioctl get authorizationpolicy --all-namespaces

# 测试 mTLS
istioctl proxy-config listener <pod-name>.<namespace>

# Linkerd 安全检查
linkerd check
linkerd viz check
```

---

## 微服务安全加固

### 网关安全加固

```
网关安全加固:
├── 认证授权
│   ├── 统一认证
│   └── 细粒度授权
├── 限流熔断
│   ├── 请求限流
│   └── 熔断保护
├── 输入验证
│   ├── 参数验证
│   └── 请求体验证
└── 日志审计
    ├── 请求日志
    └── 审计日志
```

```yaml
# Kong 网关配置示例
services:
  - name: user-service
    url: http://user-service:8080
    routes:
      - paths:
          - /api/users
    plugins:
      - name: jwt
      - name: rate-limiting
        config:
          minute: 100
      - name: acl
        config:
          allow:
            - admin
            - user
```

### 通信安全加固

```
通信安全加固:
├── 加密传输
│   ├── TLS/HTTPS
│   └── mTLS
├── 证书管理
│   ├── 证书轮换
│   └── 证书吊销
├── 服务认证
│   ├── 服务身份
│   └── 服务凭证
└── 网络隔离
    ├── 网络策略
    └── 服务网格
```

```yaml
# Istio mTLS 配置
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: default
spec:
  mtls:
    mode: STRICT

# 服务间认证配置
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: require-mtls
  namespace: default
spec:
  selector:
    matchLabels:
      app: my-service
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/allowed-service"]
    to:
    - operation:
        methods: ["GET", "POST"]
```

### 容器安全加固

```
容器安全加固:
├── 镜像安全
│   ├── 漏洞扫描
│   └── 签名验证
├── 运行时安全
│   ├── 最小权限
│   └── 安全上下文
├── 网络安全
│   ├── 网络策略
│   └── 服务网格
└── 密钥管理
    ├── Secret 管理
    └── 密钥轮换
```

```yaml
# Kubernetes Pod 安全配置
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  containers:
  - name: app
    image: myapp:latest
    securityContext:
      runAsNonRoot: true
      runAsUser: 1000
      allowPrivilegeEscalation: false
      capabilities:
        drop:
          - ALL
      readOnlyRootFilesystem: true
    volumeMounts:
    - name: tmp
      mountPath: /tmp
  volumes:
  - name: tmp
    emptyDir: {}
  serviceAccountName: restricted-sa
```

---

## 实战案例

### 案例一：电商平台微服务安全测试

#### 场景描述

```
客户：某电商平台
架构：Spring Cloud + Kubernetes
服务：10+ 微服务
时间：2 周
```

#### 测试过程

```
Week 1: 信息收集与网关测试
┌─────────────────────────────────────────────────────────┐
│ - 服务发现                                              │
│   - 发现 15 个微服务                                       │
│   - 识别 3 个内部服务                                      │
│   - 发现 2 个未授权 API                                    │
│                                                         │
│ - 网关测试                                              │
│   - 测试认证绕过                                         │
│   - 发现 1 个认证 bypass 漏洞                               │
│   - 测试限流绕过                                         │
│                                                         │
│ - 配置检查                                              │
│   - 检查 ConfigMap                                       │
│   - 发现 3 个硬编码凭证                                    │
│   - 检查 Secret                                          │
│   - 发现 2 个明文密码                                      │
└─────────────────────────────────────────────────────────┘

Week 2: 服务间通信与容器测试
┌─────────────────────────────────────────────────────────┐
│ - 服务间通信测试                                        │
│   - 测试 mTLS 配置                                         │
│   - 发现 2 个服务未启用 mTLS                               │
│   - 测试服务间认证                                       │
│   - 发现 1 个服务无认证                                    │
│                                                         │
│ - 容器安全测试                                          │
│   - 扫描镜像漏洞                                         │
│   - 发现 20 个高危漏洞                                     │
│   - 检查容器配置                                         │
│   - 发现 3 个特权容器                                      │
│                                                         │
│ - 报告与修复                                            │
│   - 编写测试报告                                         │
│   - 提交开发团队                                         │
│   - 协助修复                                             │
└─────────────────────────────────────────────────────────┘
```

#### 发现的问题

```
严重 (3 个):
├── 1. 网关认证绕过
│   └── 可直接访问内部 API
├── 2. 服务间无认证
│   └── 可伪造服务身份
└── 3. 硬编码凭证
    └── 数据库密码明文

高 (5 个):
├── 4-6. 镜像漏洞
├── 7-8. mTLS 未启用

中 (10 个):
├── 9-13. 配置问题
└── 14-18. 权限问题

低 (15 个):
└── 其他配置问题
```

### 案例二：金融系统微服务安全评估

#### 场景描述

```
客户：某金融机构
架构：Istio + Kubernetes
服务：20+ 微服务
时间：3 周
```

#### 测试结果

```
发现:
├── 严重：2 个
│   ├── 内部服务暴露
│   └── 密钥泄露
├── 高：8 个
│   ├── 认证配置问题
│   ├── 网络策略缺失
│   └── 容器权限过大
├── 中：15 个
│   ├── 配置问题
│   └── 日志问题
└── 低：25 个

建议:
├── 启用 mTLS
├── 实施网络策略
├── 修复容器权限
├── 轮换泄露密钥
└── 完善监控审计
```

---

## 总结与思考

### 核心要点回顾

1. **微服务攻击面扩大**
   - 服务数量多
   - API 数量多
   - 网络复杂

2. **认证授权复杂**
   - 分布式认证
   - 服务间认证
   - Token 传递

3. **配置管理困难**
   - 配置分散
   - 密钥管理
   - 环境差异

4. **容器安全风险**
   - 镜像漏洞
   - 运行时安全
   - 编排安全

5. **通信安全关键**
   - 加密传输
   - 服务认证
   - 网络隔离

### 实战建议

1. **对测试人员**:
   - 学习微服务架构
   - 掌握容器技术
   - 了解服务网格
   - 使用专业工具

2. **对开发人员**:
   - 实施 mTLS
   - 统一认证
   - 最小权限
   - 安全配置

3. **对组织**:
   - 建立微服务安全规范
   - 实施 DevSecOps
   - 定期安全测试
   - 持续监控

---

## 参考资料

### 学习资源

- **OWASP Microservice Security**
  - https://owasp.org/www-project-microservice-security/

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

- **Istio Security**
  - https://istio.io/latest/docs/concepts/security/

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **Trivy** | 镜像扫描 | https://github.com/aquasecurity/trivy |
| **kube-bench** | K8s 检查 | https://github.com/aquasecurity/kube-bench |
| **kube-hunter** | K8s 渗透 | https://github.com/aquasecurity/kube-hunter |
| **istioctl** | Istio 分析 | https://istio.io/ |
| **grpcurl** | gRPC 测试 | https://github.com/fullstorydev/grpcurl |

### 书籍推荐

1. **《Microservices Security in Action》**
   - 作者：Prabath Siriwardena
   - 微服务安全权威指南

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

3. **《Cloud Native Security》**
   - 云原生安全实践

---

*365 天信息安全技术系列 | Day 253 | 渗透测试补充系列 | 微服务安全测试*
*创建时间：2026-04-12 | 作者：安全专家 · 严谨专业版*