Day-217-渗透测试中的 Serverless 安全测试

# Day 254: 渗透测试中的 Serverless 安全测试

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

---

## 清单 目录
1. [Serverless 架构概述](#serverless-架构概述)
2. [Serverless 安全挑战](#serverless-安全挑战)
3. [Serverless 信息收集](#serverless-信息收集)
4. [函数注入攻击](#函数注入攻击)
5. [权限与 IAM 安全](#权限与-iam-安全)
6. [事件源安全](#事件源安全)
7. [依赖与供应链安全](#依赖与供应链安全)
8. [API 网关安全](#api-网关安全)
9. [Serverless 安全测试工具](#serverless-安全测试工具)
10. [Serverless 安全加固](#serverless-安全加固)
11. [实战案例](#实战案例)
12. [总结与思考](#总结与思考)
13. [参考资料](#参考资料)

---

## Serverless 架构概述

### 什么是 Serverless

Serverless (无服务器计算) 是一种云计算执行模型，云提供商动态管理服务器资源的分配，开发者只需关注代码，无需管理基础设施。

```
┌─────────────────────────────────────────────────────────────┐
│                    Serverless vs 传统架构                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  传统架构：                                                  │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  服务器  →  运行时  →  应用  →  代码                 │   │
│  │     ↓           ↓          ↓         ↓               │   │
│  │  管理 OS    管理环境   管理应用   管理代码           │   │
│  └─────────────────────────────────────────────────────┘   │
│  优点：完全控制                                             │
│  缺点：运维复杂、成本高                                     │
│                                                             │
│  Serverless 架构：                                           │
│  ┌─────────────────────────────────────────────────────┐   │
│  │              云提供商管理                             │   │
│  │  ┌───────────────────────────────────────────────┐  │   │
│  │  │  事件源  →  函数  →  后端服务                  │  │   │
│  │  │  (API/S3/DB)  (代码)  (API/DB/队列)            │  │   │
│  │  └───────────────────────────────────────────────┘  │   │
│  │     ↓           ↓          ↓                        │   │
│  │  事件触发    自动执行    自动扩展                    │   │
│  └─────────────────────────────────────────────────────┘   │
│  优点：无运维、按需付费、自动扩展                           │
│  缺点：冷启动、供应商锁定、调试困难                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Serverless 核心组件

```
Serverless 核心组件:
├── 函数 (Function)
│   ├── AWS Lambda
│   ├── Azure Functions
│   └── Google Cloud Functions
├── 事件源 (Event Source)
│   ├── API Gateway
│   ├── 对象存储 (S3)
│   ├── 数据库 (DynamoDB)
│   ├── 消息队列 (SQS/SNS)
│   └── 定时器 (CloudWatch Events)
├── 后端服务 (Backend)
│   ├── 数据库
│   ├── 对象存储
│   └── 第三方 API
└── 权限管理 (IAM)
    ├── 角色 (Role)
    └── 策略 (Policy)
```

### Serverless 安全测试范围

```
Serverless 安全测试:
├── 函数安全
│   ├── 代码注入
│   ├── 依赖安全
│   └── 配置安全
├── 权限安全
│   ├── IAM 权限
│   ├── 过度授权
│   └── 权限提升
├── 事件源安全
│   ├── API 网关
│   ├── 存储事件
│   └── 数据库事件
├── 数据安全
│   ├── 环境变量
│   ├── 密钥管理
│   └── 数据传输
└── 供应链安全
    ├── 第三方依赖
    └── 开源库安全
```

---

## Serverless 安全挑战

### 独特安全挑战

```
Serverless 安全挑战:
├── 攻击面扩大
│   ├── 每个函数都是入口
│   ├── 多个事件源
│   └── API 端点暴露
├── 权限管理复杂
│   ├── 细粒度权限
│   ├── 函数间权限
│   └── 服务间权限
├── 依赖风险
│   ├── 第三方库
│   ├── 开源依赖
│   └── 供应链攻击
└── 监控困难
    ├── 分布式日志
    ├── 短暂执行
    └── 无服务器访问
```

### 传统安全不适用

```
传统安全不适用:
├── 无服务器访问
│   └── 无法 SSH/RDP
├── 无网络边界
│   └── 传统防火墙无效
├── 无持久存储
│   └── 临时文件系统
└── 无操作系统
    └── 无法安装安全软件
```

---

## Serverless 信息收集

### 函数发现

```
函数发现方法:
├── API 枚举
│   └── API Gateway 端点
├── 配置分析
│   └── Serverless 框架配置
├── 权限分析
│   └── IAM 角色分析
└── 日志分析
    └── CloudWatch 日志
```

```bash
# AWS Lambda 函数枚举
# 列出所有函数
aws lambda list-functions

# 获取函数详情
aws lambda get-function --function-name function-name

# 获取函数配置
aws lambda get-function-configuration --function-name function-name

# 获取函数代码
aws lambda get-function --function-name function-name --query 'Code.Location'

# 列出函数环境变量
aws lambda get-function-configuration --function-name function-name \
    --query 'Environment.Variables'

# 获取函数权限
aws lambda get-policy --function-name function-name
```

### API 网关枚举

```
API 网关枚举:
├── API 端点
│   └── REST API 枚举
├── 路由分析
│   └── 路径与方法
└── 认证配置
    └── 认证方式分析
```

```bash
# AWS API Gateway 枚举
# 列出所有 API
aws apigateway get-rest-apis

# 获取 API 详情
aws apigateway get-rest-api --rest-api-id api-id

# 获取资源 (路由)
aws apigateway get-resources --rest-api-id api-id

# 获取方法 (HTTP 方法)
aws apigateway get-method \
    --rest-api-id api-id \
    --resource-id resource-id \
    --http-method GET

# 获取阶段 (部署阶段)
aws apigateway get-stages --rest-api-id api-id

# 枚举 API 端点
for api in $(aws apigateway get-rest-apis --query 'items[].id' --output text); do
    echo "API: $api"
    aws apigateway get-stages --rest-api-id $api
done
```

### 权限分析

```
权限分析:
├── IAM 角色
│   └── 函数角色分析
├── IAM 策略
│   └── 权限策略分析
└── 信任关系
    └── 角色信任分析
```

```bash
# IAM 权限分析
# 获取函数角色
ROLE=$(aws lambda get-function-configuration \
    --function-name function-name \
    --query 'Role' --output text)

# 获取角色详情
aws iam get-role --role-name role-name

# 获取角色策略
aws iam list-role-policies --role-name role-name
aws iam get-role-policy --role-name role-name --policy-name policy-name

# 获取附加策略
aws iam list-attached-role-policies --role-name role-name

# 权限分析工具
# 使用 Policy Sentry
pip install policy-sentry
policy-sentry analyze --policy policy.json
```

---

## 函数注入攻击

### 事件注入

```
事件注入攻击:
├── API 事件注入
│   └── HTTP 参数注入
├── 存储事件注入
│   └── S3 事件注入
├── 数据库事件注入
│   └── DynamoDB 事件注入
└── 队列事件注入
    └── SQS 事件注入
```

```python
# AWS Lambda 事件注入示例

# 1. API Gateway 事件注入
# 恶意 HTTP 参数
def lambda_handler(event, context):
    # 危险：直接使用用户输入
    user_input = event['queryStringParameters']['input']
    exec(user_input)  # 代码执行
    
    # 安全做法
    # import os
    # os.system(f"echo {shlex.quote(user_input)}")

# 2. S3 事件注入
# 恶意文件上传
def lambda_handler(event, context):
    for record in event['Records']:
        bucket = record['s3']['bucket']['name']
        key = record['s3']['object']['key']
        # 危险：处理恶意文件
        process_file(bucket, key)

# 3. DynamoDB 事件注入
# 恶意数据写入
def lambda_handler(event, context):
    for record in event['Records']:
        if record['eventName'] == 'INSERT':
            data = record['dynamodb']['NewImage']
            # 危险：直接使用数据
            process_data(data)
```

### 代码注入

```
代码注入类型:
├── 命令注入
│   └── os.system/exec
├── 代码执行
│   └── eval/exec
├── SQL 注入
│   └── 数据库查询
└── NoSQL 注入
    └── DynamoDB 查询
```

```python
# 代码注入漏洞示例

# 1. 命令注入
import os
def lambda_handler(event, context):
    filename = event['filename']
    # 危险：命令注入
    os.system(f"cat {filename}")
    
    # 安全做法
    import subprocess
    subprocess.run(['cat', filename], check=True)

# 2. 代码执行
def lambda_handler(event, context):
    code = event['code']
    # 危险：代码执行
    eval(code)
    
    # 安全做法
    # 避免使用 eval/exec
    # 使用安全的解析方式

# 3. SQL 注入
import pymysql
def lambda_handler(event, context):
    user_id = event['user_id']
    # 危险：SQL 注入
    cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")
    
    # 安全做法
    cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))

# 4. NoSQL 注入
import boto3
def lambda_handler(event, context):
    user_id = event['user_id']
    # 危险：NoSQL 注入
    table.query(KeyConditionExpression=f"user_id = {user_id}")
    
    # 安全做法
    from boto3.dynamodb.conditions import Key
    table.query(KeyConditionExpression=Key('user_id').eq(user_id))
```

### 路径遍历

```
路径遍历攻击:
├── 文件读取
│   └── 读取敏感文件
├── 文件写入
│   └── 写入恶意文件
└── 文件删除
    └── 删除关键文件
```

```python
# 路径遍历漏洞示例

# 1. 文件读取
def lambda_handler(event, context):
    filename = event['filename']
    # 危险：路径遍历
    with open(f"/tmp/{filename}", 'r') as f:
        return f.read()
    
    # 攻击：filename = "../../etc/passwd"
    
    # 安全做法
    import os
    safe_path = os.path.basename(filename)
    with open(f"/tmp/{safe_path}", 'r') as f:
        return f.read()

# 2. 文件写入
def lambda_handler(event, context):
    filename = event['filename']
    content = event['content']
    # 危险：任意文件写入
    with open(f"/tmp/{filename}", 'w') as f:
        f.write(content)
    
    # 攻击：filename = "../../tmp/malicious.py"
```

---

## 权限与 IAM 安全

### 过度授权测试

```
过度授权测试:
├── 权限枚举
│   └── 列出所有权限
├── 权限分析
│   └── 分析必要权限
└── 权限滥用
    └── 测试权限滥用
```

```bash
# 过度授权检测
# 1. 获取函数权限
aws lambda get-function-configuration \
    --function-name function-name \
    --query 'Role' --output text

# 2. 分析权限
# 使用 IAM Access Analyzer
aws iam generate-access-analyzer-policy \
    --resource-arn arn:aws:iam::account:role/role-name \
    --access-levels Read Write List

# 3. 检测过度权限
# 使用 Policy Sentry
policy-sentry analyze --policy policy.json

# 4. 最小权限建议
policy-sentry write-policy --config config.yml
```

### 权限提升测试

```
权限提升测试:
├── 角色假设
│   └── AssumeRole 测试
├── 策略修改
│   └── 策略更新测试
└── 服务滥用
    └── 服务权限滥用
```

```bash
# 权限提升测试
# 1. 测试 AssumeRole
aws sts assume-role \
    --role-arn arn:aws:iam::account:role/target-role \
    --role-session-name test-session

# 2. 测试策略修改
aws iam put-role-policy \
    --role-name function-role \
    --policy-name admin-policy \
    --policy-document file://admin-policy.json

# 3. 测试服务滥用
# 使用 Lambda 权限访问 S3
aws s3 ls s3://sensitive-bucket \
    --profile lambda-role

# 4. 测试横向移动
# 使用 Lambda 权限调用其他函数
aws lambda invoke \
    --function-name other-function \
    --payload '{}' \
    response.json
```

### IAM 策略分析

```
IAM 策略分析:
├── 通配符权限
│   └── * 权限检测
├── 危险权限
│   └── 敏感权限检测
└── 跨账户权限
    └── 跨账户访问检测
```

```json
// 危险 IAM 策略示例

// 1. 管理员权限
{
    "Version": "2012-10-17",
    "Statement": [{
        "Effect": "Allow",
        "Action": "*",
        "Resource": "*"
    }]
}

// 2. 通配符权限
{
    "Version": "2012-10-17",
    "Statement": [{
        "Effect": "Allow",
        "Action": "s3:*",
        "Resource": "*"
    }]
}

// 3. 危险权限组合
{
    "Version": "2012-10-17",
    "Statement": [{
        "Effect": "Allow",
        "Action": [
            "lambda:CreateFunction",
            "lambda:InvokeFunction",
            "iam:PassRole"
        ],
        "Resource": "*"
    }]
}
// 风险：可创建函数并执行任意代码
```

---

## 事件源安全

### API Gateway 安全

```
API Gateway 安全:
├── 认证缺失
│   └── 无认证配置
├── 认证绕过
│   └── 认证配置错误
├── 限流缺失
│   └── 无速率限制
└── 输入验证缺失
    └── 无输入验证
```

```bash
# API Gateway 安全测试
# 1. 测试无认证访问
curl https://api-id.execute-api.region.amazonaws.com/prod/function

# 2. 测试认证绕过
curl https://api-id.execute-api.region.amazonaws.com/prod/function \
    -H "Authorization: Bearer fake_token"

# 3. 测试限流
for i in {1..1000}; do
    curl https://api-id.execute-api.region.amazonaws.com/prod/function &
done

# 4. 测试输入验证
curl https://api-id.execute-api.region.amazonaws.com/prod/function \
    -d '{"input": "<script>alert(1)</script>"}'
```

### S3 事件安全

```
S3 事件安全:
├── 恶意文件上传
│   └── 触发函数执行
├── 事件注入
│   └── 恶意事件数据
└── 权限滥用
    └── S3 权限滥用
```

```python
# S3 事件安全测试

# 1. 恶意文件上传测试
# 上传恶意文件触发函数
aws s3 cp malicious.py s3://trigger-bucket/

# 2. 事件注入测试
# 构造恶意事件
event = {
    "Records": [{
        "s3": {
            "bucket": {"name": "target-bucket"},
            "object": {"key": "../../etc/passwd"}
        }
    }]
}

# 3. 权限测试
# 测试 S3 访问权限
aws s3 ls s3://sensitive-bucket
```

### 数据库事件安全

```
数据库事件安全:
├── 数据注入
│   └── 恶意数据写入
├── 事件伪造
│   └── 伪造数据库事件
└── 权限滥用
    └── 数据库权限滥用
```

```python
# 数据库事件安全测试

# 1. DynamoDB 流注入
# 写入恶意数据
import boto3
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('target-table')
table.put_item(Item={
    'id': 'malicious',
    'data': '<script>alert(1)</script>'
})

# 2. 事件伪造测试
# 构造恶意事件
event = {
    "Records": [{
        "dynamodb": {
            "NewImage": {
                "id": {"S": "admin"},
                "role": {"S": "admin"}
            }
        }
    }]
}

# 3. 权限测试
# 测试数据库访问权限
aws dynamodb scan --table-name sensitive-table
```

---

## 依赖与供应链安全

### 依赖漏洞扫描

```
依赖漏洞扫描:
├── Python 依赖
│   └── requirements.txt
├── Node.js 依赖
│   └── package.json
└── 其他依赖
    └── 运行时依赖
```

```bash
# 依赖漏洞扫描
# Python 依赖扫描
pip install safety
safety check -r requirements.txt

# 或使用 pip-audit
pip install pip-audit
pip-audit -r requirements.txt

# Node.js 依赖扫描
npm audit
npm audit --audit-level=high

# 或使用 snyk
npm install -g snyk
snyk test

# 生成依赖清单
pip freeze > requirements.txt
npm list --depth=0 > package-list.txt
```

### 供应链攻击测试

```
供应链攻击测试:
├── 依赖劫持
│   └── 恶意依赖注入
├── 版本篡改
│   └── 依赖版本篡改
└── 代码注入
    └── 依赖代码注入
```

```bash
# 供应链安全测试
# 1. 检查依赖完整性
# Python
pip hash requirements.txt

# Node.js
npm shrinkwrap

# 2. 检查依赖来源
# 确保从官方源下载
pip config list
npm config list

# 3. 锁定依赖版本
# Python
pip freeze > requirements.txt

# Node.js
npm install --package-lock-only

# 4. 使用依赖验证
# Python - 使用 hash
pip install --require-hashes -r requirements.txt
```

### 依赖加固

```
依赖加固措施:
├── 版本锁定
│   └── 锁定依赖版本
├── 哈希验证
│   └── 验证依赖完整性
├── 最小依赖
│   └── 减少依赖数量
└── 定期更新
    └── 定期更新依赖
```

```txt
# requirements.txt 安全示例
# 使用哈希验证
requests==2.28.0 \\
    --hash=sha256:abc123... \\
    --hash=sha256:def456...

# 锁定版本
flask==2.0.0
boto3==1.26.0

# 避免使用最新版本
# 避免使用通配符
# flask>=2.0.0  # 不安全
```

---

## API 网关安全

### 认证测试

```
API 网关认证测试:
├── 无认证测试
│   └── 测试无认证访问
├── 认证绕过
│   └── 测试认证绕过
├── Token 测试
│   └── JWT/Lambda 授权器
└── API Key 测试
    └── API Key 验证
```

```bash
# API 网关认证测试
# 1. 测试无认证
curl https://api-id.execute-api.region.amazonaws.com/prod/function

# 2. 测试 API Key
curl https://api-id.execute-api.region.amazonaws.com/prod/function \
    -H "x-api-key: test-key"

# 3. 测试 JWT
curl https://api-id.execute-api.region.amazonaws.com/prod/function \
    -H "Authorization: Bearer jwt-token"

# 4. 测试 Lambda 授权器
# 测试授权器逻辑
# 检查是否验证签名/过期时间等
```

### 限流测试

```
API 网关限流测试:
├── 无限流测试
│   └── 测试无限请求
├── 限流绕过
│   └── 测试限流绕过
└── DoS 测试
    └── 测试 DoS 防护
```

```bash
# API 网关限流测试
# 1. 测试无限请求
for i in {1..10000}; do
    curl https://api-id.execute-api.region.amazonaws.com/prod/function &
done

# 2. 测试限流绕过
# 使用不同 IP
for i in {1..254}; do
    curl -H "X-Forwarded-For: 192.168.1.$i" \
        https://api-id.execute-api.region.amazonaws.com/prod/function &
done

# 3. 测试并发
ab -n 10000 -c 100 \
    https://api-id.execute-api.region.amazonaws.com/prod/function
```

---

## Serverless 安全测试工具

### 测试工具

| 工具 | 用途 | 链接 |
|------|------|------|
| **SLSProtect** | Serverless 安全 | https://github.com/tenable/slsprotect |
| **PureSec** | Serverless 安全 | https://github.com/puresec |
| **AWS IAM Access Analyzer** | IAM 分析 | AWS 控制台 |
| **Policy Sentry** | 策略分析 | https://github.com/salesforce/policy_sentry |
| **ScoutSuite** | 云安全审计 | https://github.com/nccgroup/ScoutSuite |
| **Prowler** | AWS 安全 | https://github.com/prowler-cloud/prowler |

### SLSProtect 使用

```bash
# 安装 SLSProtect
pip install slsprotect

# 扫描 Serverless 项目
slsprotect scan --project-path ./my-project

# 生成报告
slsprotect report --format html --output report.html

# 检查 IAM 权限
slsprotect check-iam --function function-name
```

### ScoutSuite 使用

```bash
# 安装 ScoutSuite
pip install scoutsuite

# 扫描 AWS
scout aws --profile default

# 扫描特定服务
scout aws --services lambda,apigateway,iam

# 生成报告
scout aws --report-dir ./reports
```

---

## Serverless 安全加固

### 函数安全加固

```
函数安全加固:
├── 代码安全
│   ├── 输入验证
│   ├── 输出编码
│   └── 安全编码
├── 依赖安全
│   ├── 依赖扫描
│   ├── 版本锁定
│   └── 哈希验证
├── 配置安全
│   ├── 环境变量加密
│   ├── 密钥管理
│   └── 安全配置
└── 运行时安全
    ├── 最小权限
    ├── 超时设置
    └── 内存限制
```

```yaml
# Serverless 框架安全配置示例
service: my-service

provider:
  name: aws
  runtime: python3.9
  # 最小权限
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - dynamodb:GetItem
          Resource: arn:aws:dynamodb:region:account:table/my-table
  # 环境变量加密
  environment:
    DB_PASSWORD: ${ssm:/my-service/db-password}
  # 超时和内存限制
  timeout: 30
  memorySize: 128
  # VPC 配置
  vpc:
    securityGroupIds:
      - sg-123456
    subnetIds:
      - subnet-123456

functions:
  myFunction:
    handler: handler.main
    # 禁用不必要的功能
    reservedConcurrency: 100
```

### 权限加固

```
权限加固措施:
├── 最小权限
│   └── 仅必要权限
├── 资源限制
│   └── 限制资源范围
├── 条件限制
│   └── 添加条件限制
└── 定期审计
    └── 定期权限审计
```

```json
// 最小权限策略示例
{
    "Version": "2012-10-17",
    "Statement": [{
        "Effect": "Allow",
        "Action": [
            "dynamodb:GetItem",
            "dynamodb:PutItem"
        ],
        "Resource": "arn:aws:dynamodb:region:account:table/my-table",
        "Condition": {
            "StringEquals": {
                "dynamodb:LeadingKeys": ["${cognito-identity.amazonaws.com:sub}"]
            }
        }
    }]
}
```

---

## 实战案例

### 案例一：电商平台 Serverless 安全测试

#### 场景描述

```
客户：某电商平台
架构：AWS Lambda + API Gateway
函数：20+ Lambda 函数
时间：1 周
```

#### 测试过程

```
Day 1-2: 信息收集
┌─────────────────────────────────────────────────────────┐
│ - 函数枚举                                              │
│   - 发现 25 个 Lambda 函数                                 │
│   - 识别 15 个 API 端点                                    │
│   - 发现 5 个公开 API                                      │
│                                                         │
│ - 权限分析                                              │
│   - 分析 IAM 角色                                         │
│   - 发现 3 个过度授权                                    │
│   - 发现 2 个危险权限组合                                 │
│                                                         │
│ - 配置检查                                              │
│   - 检查环境变量                                         │
│   - 发现 2 个硬编码凭证                                   │
│   - 检查 VPC 配置                                         │
└─────────────────────────────────────────────────────────┘

Day 3-4: 漏洞测试
┌─────────────────────────────────────────────────────────┐
│ - 注入测试                                              │
│   - 测试事件注入                                         │
│   - 发现 2 个代码注入漏洞                                 │
│   - 发现 1 个命令注入漏洞                                 │
│                                                         │
│ - 权限测试                                              │
│   - 测试权限提升                                         │
│   - 发现 1 个权限提升漏洞                                 │
│   - 测试横向移动                                         │
│                                                         │
│ - 依赖测试                                              │
│   - 扫描依赖漏洞                                         │
│   - 发现 10 个高危依赖漏洞                                │
└─────────────────────────────────────────────────────────┘

Day 5: 报告与修复
┌─────────────────────────────────────────────────────────┐
│ - 编写测试报告                                          │
│ - 提交开发团队                                          │
│ - 协助修复                                              │
│ - 复测验证                                              │
└─────────────────────────────────────────────────────────┘
```

#### 发现的问题

```
严重 (3 个):
├── 1. 代码注入漏洞
│   └── 可执行任意代码
├── 2. 权限提升漏洞
│   └── 可获取管理员权限
└── 3. 硬编码凭证
    └── 数据库密码明文

高 (5 个):
├── 4-6. 过度授权
├── 7-8. 依赖漏洞

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

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

### 案例二：金融系统 Serverless 安全评估

#### 场景描述

```
客户：某金融机构
架构：Azure Functions + API Management
函数：30+ 函数
时间：2 周
```

#### 测试结果

```
发现:
├── 严重：2 个
│   ├── 事件注入漏洞
│   └── 密钥泄露
├── 高：8 个
│   ├── 权限配置问题
│   ├── 依赖漏洞
│   └── 认证缺失
├── 中：15 个
│   ├── 配置问题
│   └── 日志问题
└── 低：25 个

建议:
├── 修复注入漏洞
├── 轮换泄露密钥
├── 实施最小权限
├── 更新依赖
└── 完善监控审计
```

---

## 总结与思考

### 核心要点回顾

1. **Serverless 有独特攻击面**
   - 函数即入口
   - 事件源攻击
   - 权限复杂

2. **注入攻击是主要风险**
   - 事件注入
   - 代码注入
   - 路径遍历

3. **权限管理关键**
   - 最小权限
   - 避免过度授权
   - 定期审计

4. **依赖风险严重**
   - 供应链攻击
   - 依赖漏洞
   - 版本管理

5. **传统安全不适用**
   - 无服务器访问
   - 无网络边界
   - 需要新工具

### 实战建议

1. **对测试人员**:
   - 学习 Serverless 架构
   - 掌握云安全工具
   - 了解事件源
   - 测试注入漏洞

2. **对开发人员**:
   - 安全编码
   - 最小权限
   - 依赖管理
   - 输入验证

3. **对组织**:
   - Serverless 安全规范
   - 定期安全测试
   - 实施监控
   - 持续改进

---

## 参考资料

### 学习资源

- **OWASP Serverless Security**
  - https://owasp.org/www-project-serverless-top-10/

- **AWS Lambda Security**
  - https://docs.aws.amazon.com/lambda/latest/dg/security.html

- **Serverless Security Best Practices**
  - https://www.serverless.com/blog/serverless-security/

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **SLSProtect** | Serverless 安全 | https://github.com/tenable/slsprotect |
| **ScoutSuite** | 云安全审计 | https://github.com/nccgroup/ScoutSuite |
| **Policy Sentry** | IAM 策略分析 | https://github.com/salesforce/policy_sentry |
| **Prowler** | AWS 安全 | https://github.com/prowler-cloud/prowler |
| **safety** | Python 依赖扫描 | https://github.com/pyupio/safety |

### 书籍推荐

1. **《Serverless Security》**
   - Serverless 安全权威指南

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

3. **《AWS Lambda in Action》**
   - AWS Lambda 实战

---

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