Day-197-渗透测试中的前后端分离应用测试

# Day 253: 渗透测试中的前后端分离应用测试

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

---

## 清单 目录
1. [前后端分离架构概述](#前后端分离架构概述)
2. [前端加密技术](#前端加密技术)
3. [加密分析与绕过](#加密分析与绕过)
4. [API 安全测试](#api-安全测试)
5. [认证授权测试](#认证授权测试)
6. [Token 安全测试](#token-安全测试)
7. [请求签名测试](#请求签名测试)
8. [数据脱敏测试](#数据脱敏测试)
9. [前端逻辑测试](#前端逻辑测试)
10. [测试工具与技巧](#测试工具与技巧)
11. [实战案例](#实战案例)
12. [总结与思考](#总结与思考)
13. [参考资料](#参考资料)

---

## 前后端分离架构概述

### 架构特点

```
前后端分离架构:
├── 前端 (Frontend)
│   ├── 技术栈
│   │   ├── React
│   │   ├── Vue
│   │   ├── Angular
│   │   └── 其他框架
│   ├── 部署
│   │   ├── CDN 静态资源
│   │   └── Web 服务器
│   └── 职责
│       ├── 页面渲染
│       ├── 用户交互
│       └── 数据展示
├── 后端 (Backend)
│   ├── 技术栈
│   │   ├── Node.js
│   │   ├── Java
│   │   ├── Python
│   │   └── Go
│   ├── 部署
│   │   ├── API 网关
│   │   └── 微服务
│   └── 职责
│       ├── 业务逻辑
│       ├── 数据处理
│       └── 数据存储
└── 通信
    ├── REST API
    ├── GraphQL
    └── WebSocket
```

### 安全测试挑战

```
前后端分离安全测试挑战:
├── 前端加密
│   ├── 请求参数加密
│   ├── 响应数据加密
│   └── 签名验证
├── API 安全
│   ├── 认证授权
│   ├── 参数验证
│   └── 速率限制
├── Token 管理
│   ├── JWT
│   ├── OAuth
│   └── Session
├── 跨域问题
│   ├── CORS 配置
│   └── 跨域攻击
└── 状态管理
    ├── 客户端状态
    └── 服务端状态
```

### 测试重点

```
测试重点转移:
├── 从页面到 API
│   └── API 接口测试成为核心
├── 从表单到请求
│   └── HTTP 请求测试
├── 从 Session 到 Token
│   └── Token 安全测试
├── 从服务端到客户端
│   └── 前端代码分析
└── 从直接到间接
    └── 通过前端分析后端
```

---

## 前端加密技术

### 常见加密场景

```
前端加密场景:
├── 登录加密
│   └── 密码加密传输
├── 请求签名
│   ├── 参数签名
│   └── 防篡改
├── 数据加密
│   ├── 敏感数据加密
│   └── 响应数据加密
├── 验证码加密
│   └── 验证码识别防护
└── 指纹加密
    └── 设备指纹
```

### 加密算法识别

```javascript
// 常见前端加密库

// 1. CryptoJS
import CryptoJS from 'crypto-js';
CryptoJS.AES.encrypt(data, key);

// 2. jsencrypt (RSA)
import JSEncrypt from 'jsencrypt';
const encrypt = new JSEncrypt();
encrypt.setPublicKey(pubKey);
encrypt.encrypt(data);

// 3. node-rsa
import NodeRSA from 'node-rsa';
const key = new NodeRSA({b: 2048});
key.encrypt(data);

// 4. 自定义加密
// 需要逆向分析
```

### 加密定位方法

```
加密代码定位:
├── 关键词搜索
│   ├── encrypt
│   ├── decrypt
│   ├── AES
│   ├── RSA
│   └── Crypto
├── 网络请求 Hook
│   ├── XMLHttpRequest
│   ├── fetch
│   └── axios
├── 断点调试
│   └── 请求发送前断点
└── 代码审计
    └── 分析加密逻辑
```

```javascript
// Chrome DevTools 定位加密

// 1. XHR 断点
// DevTools → Sources → XHR Breakpoints
// 添加 API 路径

// 2. 事件监听器断点
// DevTools → Sources → Event Listener Breakpoints
// 选择 Mouse/Keyboard

// 3. 代码搜索
// DevTools → Sources → Search
// 搜索关键词：encrypt, AES, RSA

// 4. 网络请求分析
// DevTools → Network
// 查看请求参数和响应
```

---

## 加密分析与绕过

### 加密密钥提取

```
密钥提取方法:
├── 代码分析
│   └── 硬编码密钥
├── 运行时提取
│   └── 内存中密钥
├── 网络请求
│   └── 密钥交换
└── 逆向工程
    └── 反混淆代码
```

```javascript
// 运行时提取密钥示例

// 1. Hook 加密函数
// 在加密函数处断点
// 查看传入的密钥

// 2. 全局变量搜索
// Console 中搜索
window.cryptoKey
window.aesKey
window.secret

// 3. 内存搜索
// 使用调试工具
// 搜索密钥字符串
```

### 加密绕过技术

```
加密绕过方法:
├── 密钥复用
│   └── 使用已知密钥
├── 加密 bypass
│   └── 跳过加密步骤
├── 重放攻击
│   └── 重用加密请求
├── 参数篡改
│   └── 修改加密参数
└── 算法降级
    └── 使用弱加密
```

```javascript
// 加密绕过示例

// 1. 跳过加密
// 修改代码，直接发送明文
// 原代码：
send(encrypt(data))
// 修改为：
send(data)

// 2. 重用加密数据
// 捕获加密请求
// 重放请求

// 3. 修改加密参数
// 修改密钥、IV 等
// 测试加密实现
```

### 常见加密漏洞

```
加密实现漏洞:
├── 硬编码密钥
│   └── 密钥写在代码中
├── 弱加密算法
│   ├── DES
│   ├── MD5
│   └── ECB 模式
├── 固定 IV
│   └── IV 不随机
├── 密钥复用
│   └── 多场景用同一密钥
└── 客户端加密
    └── 加密逻辑在前端
```

```javascript
// 弱加密示例

// 1. 硬编码密钥 (危险)
const KEY = '1234567890123456';

// 2. 固定 IV (危险)
const IV = '0000000000000000';

// 3. ECB 模式 (危险)
CryptoJS.AES.encrypt(data, key, {
    mode: CryptoJS.mode.ECB  // 不安全
});

// 4. MD5 哈希 (危险)
CryptoJS.MD5(password);  // 应使用 bcrypt/argon2
```

---

## API 安全测试

### API 发现

```
API 发现方法:
├── 前端代码分析
│   ├── 搜索 API 路径
│   ├── 分析请求模块
│   └── 提取接口定义
├── 网络抓包
│   ├── 浏览器 DevTools
│   ├── 代理工具
│   └── 流量分析
├── 文档分析
│   ├── Swagger/OpenAPI
│   ├── API 文档
│   └── 注释文档
└── 模糊测试
    └── 路径猜测
```

```javascript
// 前端代码提取 API

// 1. 搜索请求路径
// 在代码中搜索
/api/
/api/v1/
/api/v2/
/rest/

// 2. 分析请求模块
// axios 配置
axios.create({
    baseURL: 'https://api.example.com'
})

// 3. 提取接口
// 从请求代码提取
axios.get('/api/users')
axios.post('/api/orders')
```

### API 测试要点

```
API 测试清单:
├── 认证测试
│   - [ ] 未认证访问
│   - [ ] Token 过期
│   - [ ] Token 篡改
├── 授权测试
│   - [ ] 水平越权
│   - [ ] 垂直越权
│   - [ ] 功能越权
├── 输入验证
│   - [ ] SQL 注入
│   - [ ] XSS
│   - [ ] 命令注入
├── 业务逻辑
│   - [ ] 流程绕过
│   - [ ] 状态篡改
│   - [ ] 竞争条件
└── 配置安全
    - [ ] CORS 配置
    - [ ] 速率限制
    - [ ] 错误处理
```

### 参数测试

```
参数测试方法:
├── 类型测试
│   ├── 字符串→数字
│   ├── 数字→字符串
│   └── null/undefined
├── 边界测试
│   ├── 最大值/最小值
│   ├── 空值
│   └── 超长值
├── 格式测试
│   ├── JSON 格式
│   ├── XML 格式
│   └── 特殊字符
└── 逻辑测试
    ├── 负数数量
    ├── 异常状态
    └── 矛盾参数
```

```javascript
// API 参数测试示例

// 1. 类型篡改
// 原参数：id=123 (数字)
// 测试：id="123" (字符串)
// 测试：id=null
// 测试：id=[]

// 2. 边界测试
// 原参数：amount=100
// 测试：amount=0
// 测试：amount=-1
// 测试：amount=999999999

// 3. 特殊字符
// 原参数：name="test"
// 测试：name="<script>alert(1)</script>"
// 测试：name="'; DROP TABLE users;--"
```

---

## 认证授权测试

### 认证流程分析

```
认证流程:
├── 登录
│   ├── 凭证提交
│   ├── 服务端验证
│   └── Token 返回
├── Token 使用
│   ├── 请求携带
│   ├── 服务端验证
│   └── 响应返回
├── Token 刷新
│   ├── 过期检测
│   ├── 刷新请求
│   └── 新 Token
└── 登出
    ├── Token 失效
    └── 清理本地
```

### 认证绕过测试

```
认证绕过测试:
├── 未认证访问
│   └── 直接访问 API
├── Token  bypass
│   ├── 移除 Token
│   ├── 伪造 Token
│   └── 过期 Token
├── 认证降级
│   └── 使用旧版本 API
└── 逻辑绕过
    └── 跳过认证步骤
```

```bash
# 认证绕过测试

# 1. 未认证访问
curl https://api.example.com/users/123
# 应该返回 401

# 2. Token 移除
curl https://api.example.com/users/123 \
    -H "Authorization: Bearer "
# 应该返回 401

# 3. Token 过期
# 使用过期 Token
curl https://api.example.com/users/123 \
    -H "Authorization: Bearer expired_token"
# 应该返回 401

# 4. Token 篡改
# 修改 Token 内容
curl https://api.example.com/users/123 \
    -H "Authorization: Bearer modified_token"
# 应该返回 401
```

### 越权访问测试

```
越权测试方法:
├── 水平越权
│   └── 访问其他用户数据
├── 垂直越权
│   └── 访问管理员功能
└── 功能越权
    └── 执行未授权操作
```

```bash
# 越权测试示例

# 1. 水平越权
# 用户 A 的 Token
TOKEN_A="user_a_token"

# 访问用户 B 的数据
curl https://api.example.com/users/124 \
    -H "Authorization: Bearer $TOKEN_A"
# 应该返回 403

# 2. 垂直越权
# 普通用户 Token
TOKEN_USER="user_token"

# 访问管理员接口
curl https://api.example.com/admin/users \
    -H "Authorization: Bearer $TOKEN_USER"
# 应该返回 403

# 3. ID 遍历
# 遍历用户 ID
for id in {1..100}; do
    curl https://api.example.com/users/$id \
        -H "Authorization: Bearer $TOKEN"
done
```

---

## Token 安全测试

### JWT Token 测试

```
JWT 测试要点:
├── 签名验证
│   ├── 签名算法
│   ├── 签名密钥
│   └── 签名绕过
├── Payload 测试
│   ├── 内容篡改
│   ├── 权限提升
│   └── 信息泄露
├── Header 测试
│   ├── alg 篡改
│   ├── typ 篡改
│   └── kid 注入
└── 有效期测试
    ├── 过期 Token
    └── 长期 Token
```

```bash
# JWT 测试工具

# 1. jwt.io
# 在线解码和编辑

# 2. jwt_tool
pip install jwt-tool
python3 jwt_tool.py TOKEN_HERE

# 3. 手动测试
# 解码 JWT
echo "TOKEN" | base64 -d

# 修改 Payload
# 重新签名 (如果知道密钥)

# 4. None 算法攻击
# 修改 header alg 为 none
# 移除签名
```

### Token 存储测试

```
Token 存储安全:
├── localStorage
│   ├── 易被 XSS 窃取
│   └── 持久存储
├── sessionStorage
│   ├── 会话级存储
│   └── 相对安全
├── Cookie
│   ├── HttpOnly
│   ├── Secure
│   └── SameSite
└── 内存存储
    └── 最安全
```

```javascript
// Token 存储检查

// 1. 检查存储位置
// DevTools → Application
// 查看 localStorage/sessionStorage/Cookie

// 2. 检查 Cookie 属性
// HttpOnly: 防止 XSS 窃取
// Secure: 仅 HTTPS
// SameSite: 防止 CSRF

// 3. 安全建议
// + 使用 HttpOnly Cookie
// + 使用 Secure 标志
// + 设置 SameSite=Strict
// - 避免 localStorage 存储敏感 Token
```

---

## 请求签名测试

### 签名机制分析

```
签名机制:
├── 签名参数
│   ├── 请求参数
│   ├── 时间戳
│   └── 随机数
├── 签名算法
│   ├── HMAC-SHA256
│   ├── MD5
│   └── 自定义
├── 签名位置
│   ├── Header
│   └── 参数
└── 签名验证
    ├── 服务端验证
    └── 时间验证
```

```javascript
// 签名代码分析

// 1. 查找签名函数
// 搜索关键词
sign
signature
getSign
generateSign

// 2. 分析签名逻辑
function generateSign(params, secret) {
    // 排序参数
    const sorted = Object.keys(params).sort();
    
    // 拼接字符串
    const str = sorted.map(k => `${k}=${params[k]}`).join('&');
    
    // 添加密钥
    const strWithKey = str + '&key=' + secret;
    
    // 哈希
    return md5(strWithKey);
}

// 3. 提取密钥
// 从代码中提取 secret
```

### 签名绕过测试

```
签名绕过方法:
├── 重放攻击
│   └── 重用签名请求
├── 参数篡改
│   └── 修改后重签名
├── 时间绕过
│   └── 修改时间戳
├── 签名 bypass
│   └── 移除签名参数
└── 算法降级
    └── 使用弱算法
```

```bash
# 签名绕过测试

# 1. 重放攻击
# 捕获签名请求
# 重复发送
curl -X POST https://api.example.com/order \
    -d "signature=abc123&timestamp=1234567890"
# 多次发送

# 2. 参数篡改
# 修改参数后重放签名
# 测试是否验证

# 3. 时间绕过
# 修改时间戳
curl -X POST https://api.example.com/order \
    -d "signature=abc123&timestamp=9999999999"
# 测试时间验证

# 4. 签名移除
# 移除签名参数
curl -X POST https://api.example.com/order \
    -d "amount=100"
# 测试是否验证签名
```

---

## 数据脱敏测试

### 敏感数据识别

```
敏感数据类型:
├── 个人信息
│   ├── 身份证号
│   ├── 手机号
│   └── 邮箱
├── 认证信息
│   ├── 密码
│   ├── Token
│   └── 密钥
├── 财务信息
│   ├── 银行卡号
│   ├── 余额
│   └── 交易记录
└── 业务数据
    ├── 订单信息
    └── 合同内容
```

### 脱敏验证

```
脱敏测试清单:
├── 响应数据
│   - [ ] 完整数据返回
│   - [ ] 部分字段脱敏
│   - [ ] 数据加密
├── 列表接口
│   - [ ] 列表数据脱敏
│   - [ ] 详情数据完整
│   └── 权限控制
├── 错误信息
│   - [ ] 不泄露敏感信息
│   - [ ] 不泄露技术细节
│   └── 统一错误格式
└── 日志记录
    - [ ] 不记录敏感数据
    - [ ] 脱敏存储
    └── 访问控制
```

```javascript
// 数据脱敏检查

// 1. 检查响应数据
// DevTools → Network
// 查看 API 响应

// 2. 敏感字段检查
{
    "user": {
        "id": 123,
        "name": "张三",
        "phone": "138****1234",  // + 脱敏
        "id_card": "1101**********1234",  // + 脱敏
        "email": "test@example.com"  // - 未脱敏
    }
}

// 3. 列表接口检查
// 列表应只返回必要字段
// 详情接口返回完整数据
```

---

## 前端逻辑测试

### 业务逻辑分析

```
前端逻辑测试:
├── 流程验证
│   ├── 步骤跳过
│   ├── 顺序颠倒
│   └── 条件绕过
├── 状态管理
│   ├── 状态篡改
│   ├── 状态重用
│   └── 状态预测
├── 计算逻辑
│   ├── 价格计算
│   ├── 优惠计算
│   └── 积分计算
└── 验证逻辑
    ├── 前端验证
    └── 后端验证
```

### 前端验证 bypass

```
前端验证绕过:
├── 禁用 JavaScript
│   └── 绕过前端验证
├── 直接 API 调用
│   └── 跳过前端
├── 参数篡改
│   └── 修改验证参数
└── 重放请求
    └── 重用有效请求
```

```javascript
// 前端验证 bypass

// 1. 禁用 JavaScript
// 浏览器设置 → 禁用 JS
// 直接提交表单

// 2. 直接 API 调用
// 绕过前端验证
curl -X POST https://api.example.com/order \
    -d "amount=0.01"  // 前端验证金额>100

// 3. 修改验证逻辑
// DevTools 修改代码
if (amount > 100) {  // 原代码
if (amount > 0) {    // 修改后

// 4. 控制台执行
// 直接调用函数
submitOrder({amount: 0.01})
```

---

## 测试工具与技巧

### 必备工具

| 工具 | 用途 | 特点 |
|------|------|------|
| **Chrome DevTools** | 调试分析 | 内置 |
| **Burp Suite** | 代理测试 | 功能强大 |
| **Charles** | 抓包 | 易用 |
| **Postman** | API 测试 | 方便 |
| **jwt_tool** | JWT 测试 | 专业 |
| **frida** | Hook 调试 | 强大 |

### 调试技巧

```
调试技巧:
├── 断点调试
│   ├── XHR 断点
│   ├── Fetch 断点
│   └── 函数断点
├── 代码修改
│   ├── 本地覆盖
│   ├── 控制台执行
│   └── 脚本注入
├── 网络修改
│   ├── 请求修改
│   ├── 响应修改
│   └── 延迟模拟
└── 存储修改
    ├── localStorage
    ├── Cookie
    └── IndexDB
```

### 自动化测试

```javascript
// API 自动化测试

// 1. 使用 Postman
// 创建 Collection
// 设置环境变量
// 自动化测试

// 2. 使用脚本
const axios = require('axios');

async function testAPI() {
    const token = 'your_token';
    
    // 测试认证
    try {
        await axios.get('/api/users', {
            headers: { Authorization: `Bearer ${token}` }
        });
    } catch (e) {
        console.log('Auth test failed:', e.response.status);
    }
    
    // 测试越权
    try {
        await axios.get('/api/admin/users', {
            headers: { Authorization: `Bearer ${token}` }
        });
    } catch (e) {
        console.log('Privilege test:', e.response.status);
    }
}
```

---

## 实战案例

### 案例一：电商平台渗透测试

#### 场景描述

```
客户：某电商平台
架构：Vue + Spring Boot
功能：商品、订单、支付
时间：2 周
```

#### 测试过程

```
Week 1: 信息收集与分析
┌─────────────────────────────────────────────────────────┐
│ - 前端代码分析                                          │
│   ├── 反编译打包代码                                    │
│   ├── 搜索 API 路径                                       │
│   ├── 分析加密逻辑                                      │
│   └── 提取密钥 (发现硬编码)                              │
│                                                         │
│ - API 接口整理                                          │
│   ├── 整理 50+ 个 API                                     │
│   ├── 分析参数格式                                      │
│   └── 识别敏感接口                                      │
│                                                         │
│ - 加密分析                                              │
│   ├── 识别 AES 加密                                       │
│   ├── 提取加密密钥                                      │
│   └── 编写解密脚本                                      │
└─────────────────────────────────────────────────────────┘

Week 2: 漏洞测试与验证
┌─────────────────────────────────────────────────────────┐
│ - 认证授权测试                                          │
│   ├── 发现 2 个越权漏洞                                   │
│   ├── Token 验证缺陷                                     │
│   └── 会话管理问题                                      │
│                                                         │
│ - 业务逻辑测试                                          │
│   ├── 价格篡改漏洞                                      │
│   ├── 优惠券重复使用                                    │
│   └── 订单状态篡改                                      │
│                                                         │
│ - 加密测试                                              │
│   ├── 前端加密可绕过                                    │
│   ├── 密钥硬编码                                        │
│   └── 弱加密算法                                        │
│                                                         │
│ - 数据安全检查                                          │
│   ├── 敏感数据未脱敏                                    │
│   ├── 本地存储明文                                      │
│   └── 日志泄露信息                                      │
└─────────────────────────────────────────────────────────┘
```

#### 发现的问题

```
严重 (2 个):
├── 1. 价格篡改漏洞
│   └── 可修改订单金额
└── 2. 硬编码密钥
    └── 加密密钥在前端代码

高 (3 个):
├── 3. 越权访问订单
├── 4. 优惠券重复使用
└── 5. Token 长期有效

中 (5 个):
├── 6-8. 数据未脱敏
├── 9. 前端验证可绕过
└── 10. 错误信息泄露

低 (8 个):
└── 信息泄露、配置问题等
```

### 案例二：金融 APP 后端 API 测试

#### 场景描述

```
客户：某金融机构
架构：React + Node.js
功能：理财、转账、查询
时间：3 周
```

#### 测试结果

```
发现:
├── 严重：1 个
│   └── 转账金额篡改
├── 高：3 个
│   ├── 越权查询
│   ├── 签名可绕过
│   └── Token 重放
├── 中：8 个
│   ├── 数据脱敏不足
│   ├── 速率限制缺失
│   └── 错误信息泄露
└── 低：15 个

建议:
├── 服务端验证所有金额
├── 加强签名验证
├── 实施 Token 刷新机制
├── 完善数据脱敏
└── 添加速率限制
```

---

## 总结与思考

### 核心要点回顾

1. **前后端分离测试重点不同**
   - 从页面转向 API
   - 从 Session 转向 Token
   - 从服务端转向客户端

2. **前端加密不是安全保障**
   - 前端代码可分析
   - 密钥可提取
   - 加密可绕过

3. **API 安全是核心**
   - 认证授权测试
   - 参数验证测试
   - 业务逻辑测试

4. **Token 管理关键**
   - JWT 安全配置
   - Token 存储安全
   - Token 刷新机制

5. **多层防御必要**
   - 前端验证 + 后端验证
   - 客户端加密 + 服务端加密
   - 多层安全检查

### 实战建议

1. **对测试人员**:
   - 学习前端技术
   - 掌握调试工具
   - 理解加密原理
   - 重视 API 测试

2. **对开发人员**:
   - 前端验证不可信
   - 敏感逻辑在后端
   - Token 安全管理
   - 数据脱敏处理

3. **对组织**:
   - API 安全规范
   - 代码审计流程
   - 安全测试集成
   - 持续监控

---

## 参考资料

### 学习资源

- **OWASP API Security Top 10**
  - https://owasp.org/www-project-api-security/

- **JWT Best Practices**
  - https://jwt.io/introduction/

- **Frontend Security**
  - https://cheatsheetseries.owasp.org/

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **Burp Suite** | 渗透测试 | https://portswigger.net/burp |
| **jwt_tool** | JWT 测试 | https://github.com/ticarpi/jwt_tool |
| **Postman** | API 测试 | https://www.postman.com/ |
| **frida** | Hook 调试 | https://frida.re/ |
| **Chrome DevTools** | 前端调试 | 浏览器内置 |

### 书籍推荐

1. **《API Security in Action》**
   - 作者：Neil Madden
   - API 安全权威指南

2. **《Frontend Security》**
   - 前端安全实践

3. **《Web Security Testing Guide》**
   - OWASP 官方指南

---

*365 天信息安全技术系列 | Day 253 | 渗透测试系列 | 前后端分离应用测试*
*创建时间：2026-04-12 | 作者：安全专家 · 严谨专业版*