Day-093-GraphQL 安全

# Day 91: GraphQL 安全 - 查询攻击/内省漏洞/防护方案

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

---

## 清单 目录

1. [GraphQL 概述](#graphql-概述)
2. [GraphQL 特有漏洞](#graphql-特有漏洞)
3. [查询深度攻击](#查询深度攻击)
4. [批量查询攻击](#批量查询攻击)
5. [内省漏洞](#内省漏洞)
6. [授权漏洞](#授权漏洞)
7. [防护方案](#防护方案)
8. [实战案例](#实战案例)
9. [总结与思考](#总结与思考)
10. [参考资料](#参考资料)

---

## GraphQL 概述

### GraphQL 基础

**什么是 GraphQL**：
```
GraphQL 是 Facebook 开发的查询语言和运行时：
- 客户端定义所需数据结构
- 单端点查询
- 强类型系统
- 内省查询能力
```

**与 REST 对比**：
```
REST:
- 多端点 (/users, /posts, /comments)
- 过度获取/获取不足
- 版本管理复杂

GraphQL:
- 单端点 (/graphql)
- 按需获取
- 版本演进友好
```

### GraphQL 架构

**基本组件**：
```
Schema (模式):
- 类型定义
- 查询 (Query)
- 变更 (Mutation)
- 订阅 (Subscription)

Resolver (解析器):
- 字段解析逻辑
- 数据源连接
- 业务逻辑
```

**查询示例**：
```graphql
# 查询用户及其文章
query {
  user(id: "123") {
    name
    email
    posts {
      title
      content
      comments {
        text
        author {
          name
        }
      }
    }
  }
}
```

---

## GraphQL 特有漏洞

### 漏洞分类

**OWASP GraphQL Top 8**：
```
1. 注入漏洞 (Injection)
2. 认证失效 (Authentication)
3. 授权问题 (Authorization)
4. 资源滥用 (Resource Abuse)
5. 通用漏洞 (Generic)
6. 操作问题 (Operational)
7. 供应链问题 (Supply Chain)
8. 其他 (Other)
```

### 注入漏洞

**SQL 注入**：
```graphql
# 恶意查询
query {
  user(filter: {name: "admin' OR '1'='1"}) {
    id
    name
    email
  }
}

# 联合查询注入
query {
  user(id: "1 UNION SELECT password FROM users--") {
    name
  }
}
```

**NoSQL 注入**：
```graphql
# MongoDB 注入
query {
  user(filter: {name: {$ne: null}}) {
    password
  }
}
```

**命令注入**：
```graphql
# 解析器中的命令注入
mutation {
  runCommand(cmd: "ls; cat /etc/passwd")
}
```

---

## 查询深度攻击

### 深度查询攻击

**攻击原理**：
```graphql
# 正常查询 (深度 3)
query {
  user {
    posts {
      comments {
        text
      }
    }
  }
}

# 恶意深度查询 (深度 10+)
query {
  user {
    posts {
      comments {
        author {
          posts {
            comments {
              author {
                posts {
                  comments {
                    author {
                      name  # 指数级资源消耗
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
```

**资源消耗计算**：
```
假设:
- 用户有 10 篇文章
- 每篇文章有 10 条评论
- 每条评论有 1 个作者

深度 3: 1 × 10 × 10 = 100 记录
深度 5: 1 × 10 × 10 × 1 × 10 = 1,000 记录
深度 10: 10^5 = 100,000 记录
深度 20: 10^10 = 100 亿记录 (DoS)
```

### 防护方案

**深度限制**：
```javascript
// Apollo Server 深度限制
import depthLimit from 'graphql-depth-limit';

const server = new ApolloServer({
  schema,
  validationRules: [depthLimit(10)]  // 最大深度 10
});
```

**复杂度分析**：
```javascript
// 查询复杂度计算
const complexity = {
  Query: {
    user: () => 1,
    posts: () => 5,
    comments: () => 3
  }
};

// 限制总复杂度
maxComplexity: 1000
```

---

## 批量查询攻击

### 别名攻击

**攻击原理**：
```graphql
# 使用别名执行多次查询
query {
  user1: user(id: "1") { email }
  user2: user(id: "2") { email }
  user3: user(id: "3") { email }
  # ... 重复 1000 次
  user1000: user(id: "1000") { email }
}
```

**资源耗尽**：
```
单次查询成本：1
1000 次查询成本：1000
数据库连接耗尽
内存耗尽
响应时间超时
```

### 批量攻击防护

**查询数量限制**：
```javascript
// 限制查询操作数量
const batchLimit = require('graphql-batch-limit');

validationRules: [batchLimit(10)]  // 最多 10 个操作
```

**速率限制**：
```javascript
// 基于 IP 的速率限制
const rateLimit = {
  windowMs: 60000,  // 1 分钟
  max: 100          // 最多 100 次查询
};

app.use('/graphql', rateLimitMiddleware);
```

**查询成本分析**：
```javascript
// 计算查询成本
function calculateCost(query) {
  const fieldCosts = {
    user: 1,
    posts: 5,
    comments: 3,
    author: 2
  };
  
  // 遍历查询树计算总成本
  return totalCost;
}

// 拒绝高成本查询
if (cost > 1000) {
  throw new Error('Query too complex');
}
```

---

## 内省漏洞

### 内省查询

**内省功能**：
```graphql
# 查询所有类型
query {
  __schema {
    types {
      name
      description
      fields {
        name
        type {
          name
          kind
        }
      }
    }
  }
}

# 查询可用查询
query {
  __type(name: "Query") {
    fields {
      name
      description
    }
  }
}

# 查询可用变更
query {
  __type(name: "Mutation") {
    fields {
      name
      description
    }
  }
}
```

**信息泄露风险**：
```
内省查询可能泄露:
- 完整 API 结构
- 隐藏的管理功能
- 敏感字段名称
- 数据类型和关系
- 认证/授权机制
```

### 内省防护

**生产环境禁用内省**：
```javascript
// Apollo Server 配置
const server = new ApolloServer({
  schema,
  introspection: process.env.NODE_ENV !== 'production',
  playground: process.env.NODE_ENV !== 'production'
});
```

**条件内省**：
```javascript
// 仅允许特定用户内省
const server = new ApolloServer({
  schema,
  introspection: (request) => {
    const user = getUserFromRequest(request);
    return user?.isAdmin === true;
  }
});
```

**隐藏敏感类型**：
```javascript
// 使用 schema filter
const schemaFilter = (schema) => {
  // 移除敏感类型
  const filteredTypes = schema.types.filter(
    type => !type.name.startsWith('Admin')
  );
  return filteredTypes;
};
```

---

## 授权漏洞

### 字段级授权

**授权问题**：
```graphql
# 未授权访问其他用户数据
query {
  user(id: "123") {  # 应该是当前用户
    email
    password  # 敏感字段
    ssn       # 社保号
  }
}
```

**防护方案**：
```javascript
// 字段级授权中间件
const authDirective = {
  visitFieldDefinition(field) {
    const { requires } = this.args;
    
    field.resolve = async (parent, args, context, info) => {
      if (!context.user) {
        throw new Error('Unauthorized');
      }
      
      if (requires && !context.user.roles.includes(requires)) {
        throw new Error('Insufficient permissions');
      }
      
      return field.resolve(parent, args, context, info);
    };
  }
};

// Schema 中使用
type User {
  email: String @auth(requires: "USER")
  password: String @auth(requires: "ADMIN")
  ssn: String @auth(requires: "ADMIN")
}
```

### IDOR 漏洞

**漏洞示例**：
```graphql
# 未验证所有权
query {
  order(id: "12345") {  # 未检查是否属于当前用户
    items
    total
    address
  }
}
```

**防护方案**：
```javascript
// 所有权验证
const resolvers = {
  Query: {
    order: async (parent, { id }, context) => {
      const order = await db.order.findById(id);
      
      // 验证所有权
      if (order.userId !== context.user.id) {
        throw new Error('Not authorized');
      }
      
      return order;
    }
  }
};
```

---

## 防护方案

### 输入验证

**查询验证**：
```javascript
// 验证查询结构
function validateQuery(query) {
  // 检查深度
  if (getDepth(query) > MAX_DEPTH) {
    throw new Error('Query too deep');
  }
  
  // 检查复杂度
  if (calculateComplexity(query) > MAX_COMPLEXITY) {
    throw new Error('Query too complex');
  }
  
  // 检查批量操作
  if (countOperations(query) > MAX_BATCH) {
    throw new Error('Too many operations');
  }
}
```

**参数验证**：
```javascript
// 验证输入参数
const validateInput = {
  ID: (id) => {
    if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
      throw new Error('Invalid ID format');
    }
    return id;
  },
  
  Email: (email) => {
    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
      throw new Error('Invalid email');
    }
    return email;
  }
};
```

### 安全配置

**生产环境配置**：
```javascript
const productionConfig = {
  // 禁用调试功能
  introspection: false,
  playground: false,
  debug: false,
  
  // 启用安全限制
  validationRules: [
    depthLimit(10),
    batchLimit(10),
    complexityLimit(1000)
  ],
  
  // 错误处理
  formatError: (error) => {
    // 生产环境不泄露详细错误
    if (process.env.NODE_ENV === 'production') {
      return { message: 'Internal server error' };
    }
    return error;
  }
};
```

**日志与监控**：
```javascript
// 查询日志
const queryLogger = {
  requestDidStart(requestContext) {
    const startTime = Date.now();
    
    return {
      willSendResponse() {
        const duration = Date.now() - startTime;
        logger.info('GraphQL Query', {
          query: requestContext.request.query,
          duration,
          userId: requestContext.context.user?.id
        });
      }
    };
  }
};

// 异常查询告警
if (duration > 5000 || complexity > 500) {
  alert('Suspicious GraphQL query detected');
}
```

---

## 实战案例

### 案例 1: 深度查询 DoS 攻击

**漏洞场景**：
```
目标：社交网络 GraphQL API
漏洞：无查询深度限制
影响：服务不可用
```

**攻击过程**：
```graphql
# 攻击查询
query {
  user {
    followers {
      following {
        followers {
          following {
            followers {
              following {
                name  # 深度 7
              }
            }
          }
        }
      }
    }
  }
}

# 资源消耗
# 假设平均每人有 100 个关注者
# 深度 7 = 100^3.5 ≈ 1000 万次查询
```

**修复方案**：
```javascript
// 实施深度限制
import depthLimit from 'graphql-depth-limit';

const server = new ApolloServer({
  schema,
  validationRules: [depthLimit(5)]  // 最大深度 5
});

// 添加复杂度限制
const complexityLimit = require('graphql-cost-analysis');

validationRules: [
  depthLimit(5),
  complexityLimit({ maximumCost: 1000 })
];
```

### 案例 2: 内省信息泄露

**漏洞场景**：
```
目标：电商 GraphQL API
漏洞：生产环境启用内省
影响：API 结构完全暴露
```

**攻击过程**：
```graphql
# 1. 获取完整 Schema
query {
  __schema {
    types {
      name
      fields {
        name
        type { name }
      }
    }
  }
}

# 2. 发现隐藏的管理功能
query {
  __type(name: "AdminMutation") {
    fields {
      name
      description
    }
  }
}

# 3. 利用发现的功能
mutation {
  adminCreateUser(email: "attacker@evil.com", role: "ADMIN")
}
```

**修复方案**：
```javascript
// 生产环境禁用内省
const server = new ApolloServer({
  schema,
  introspection: process.env.NODE_ENV === 'development',
  playground: process.env.NODE_ENV === 'development'
});

// 隐藏敏感类型
const schemaTransform = (schema) => {
  // 移除管理相关类型
  return filterTypes(schema, (type) => {
    return !type.name.startsWith('Admin');
  });
};
```

### 案例 3: 批量查询数据窃取

**漏洞场景**：
```
目标：用户数据 API
漏洞：无批量查询限制
影响：大规模数据泄露
```

**攻击过程**：
```graphql
# 批量获取所有用户邮箱
query {
  u1: user(id: "1") { email }
  u2: user(id: "2") { email }
  u3: user(id: "3") { email }
  # ... 重复 10000 次
  u10000: user(id: "10000") { email }
}

# 结果：10000 个用户邮箱被窃取
```

**修复方案**：
```javascript
// 批量查询限制
const batchLimit = require('graphql-batch-limit');

const server = new ApolloServer({
  schema,
  validationRules: [batchLimit(10)]  // 最多 10 个操作
});

// 速率限制
const rateLimit = require('express-rate-limit');

app.use('/graphql', rateLimit({
  windowMs: 60 * 1000,  // 1 分钟
  max: 100              // 最多 100 次请求
}));

// 分页强制
const paginatedResolver = async (parent, args, context) => {
  const page = args.page || 1;
  const limit = Math.min(args.limit || 20, 100);  // 最大 100
  
  return db.query({
    offset: (page - 1) * limit,
    limit: limit
  });
};
```

---

## 总结与思考

### 核心要点回顾

1. **GraphQL 概述**：查询语言、单端点、强类型
2. **特有漏洞**：注入、认证、授权、资源滥用
3. **深度攻击**：指数级资源消耗、深度限制
4. **批量攻击**：别名滥用、速率限制
5. **内省漏洞**：信息泄露、生产禁用
6. **授权漏洞**：字段级授权、IDOR 防护
7. **防护方案**：输入验证、安全配置、监控

### 深入思考

**GraphQL 安全挑战**：
- 灵活性 vs 安全性平衡
- 性能 vs 限制权衡
- 开发体验 vs 安全控制

**最佳实践**：
- 默认安全配置
- 深度和复杂度限制
- 字段级授权
- 生产禁用内省
- 完整日志监控

### 未来趋势

**发展方向**：
- 自动安全分析
- AI 驱动异常检测
- 标准化安全实践
- 更好的工具支持

---

## 参考资料

### 学习资源

- **OWASP GraphQL Security**: https://owasp.org/www-project-graphql-security/
- **GraphQL Security Cheat Sheet**: https://cheatsheetseries.owasp.org/cheatsheets/GraphQL_Cheat_Sheet.html
- **Awesome GraphQL Security**: https://github.com/dolevf/awesome-graphql-security

### 工具资源

- **GraphQL Voyager**: https://graphql-voyager.now.sh
- **GraphQL Playground**: https://github.com/prisma-labs/graphql-playground
- **InQL Scanner**: https://github.com/dolevf/inql

---

*Day 91 完成 | GraphQL 安全详解 | 字数：约 18,000 字*