⚠️ GraphQL의 주요 보안 취약점들

자, 이제 본격적으로 GraphQL의 보안 취약점들을 하나씩 뜯어보자! 🔍
각각의 취약점이 어떻게 작동하는지, 실제로 어떤 피해를 줄 수 있는지 알아야 제대로 막을 수 있거든. 💪

이건 GraphQL의 가장 치명적인 약점 중 하나야. 😰

GraphQL은 클라이언트가 원하는 대로 쿼리를 작성할 수 있잖아? 그런데 악의적인 사용자가 엄청나게 복잡하고 깊은 쿼리를 보내면 어떻게 될까?

예를 들어 이런 쿼리를 보낸다고 생각해봐:

query {
  user(id: 1) {
    posts {
      comments {
        author {
          posts {
            comments {
              author {
                posts {
                  comments {
                    # 이게 계속 반복된다면...? 😱
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

이런 식으로 관계를 타고타고 들어가면서 중첩 깊이가 수십, 수백 레벨까지 갈 수 있어.
서버는 이 쿼리를 처리하려고 데이터베이스를 수백만 번 조회하게 되고... 💥

결과? 서버가 뻗어버리는 거지! 전형적인 DoS(Denial of Service) 공격이야. 🔥

const depthLimit = require('graphql-depth-limit');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(5)] // 최대 5단계까지만 허용
});

const { createComplexityLimitRule } = require('graphql-validation-complexity');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    createComplexityLimitRule(1000, {
      onCost: (cost) => {
        console.log('Query cost:', cost);
      }
    })
  ]
});

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => ({
    timeout: 5000 // 5초 제한
  }),
  plugins: [
    {
      requestDidStart() {
        return {
          async executionDidStart() {
            const timeout = setTimeout(() => {
              throw new Error('Query timeout');
            }, 5000);
            
            return {
              willResolveField() {
                return () => clearTimeout(timeout);
              }
            };
          }
        };
      }
    }
  ]
});

GraphQL은 여러 쿼리를 한 번에 보낼 수 있는 배치 기능을 지원해. 편리하긴 한데... 이것도 악용될 수 있어! 😈

공격자가 이런 식으로 수천 개의 쿼리를 한 번에 보낸다면?

[
  { query: "query { user(id: 1) { name email } }" },
  { query: "query { user(id: 2) { name email } }" },
  { query: "query { user(id: 3) { name email } }" },
  // ... 10,000개 반복
]

서버는 이 모든 쿼리를 처리하느라 리소스가 고갈되고... 또 다시 DoS! 💀

const express = require('express');
const { graphqlHTTP } = require('express-graphql');

app.use('/graphql', (req, res, next) => {
  if (Array.isArray(req.body)) {
    if (req.body.length > 10) { // 최대 10개까지만
      return res.status(413).json({
        error: 'Batch size too large'
      });
    }
  }
  next();
}, graphqlHTTP({
  schema,
  graphiql: true
}));

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100개 요청
  message: 'Too many requests from this IP'
});

app.use('/graphql', limiter);

GraphQL의 멋진 기능 중 하나가 바로 인트로스펙션(Introspection)이야! 🎭

이건 API의 전체 스키마를 조회할 수 있는 기능인데, 개발할 때는 엄청 유용해.
GraphiQL이나 GraphQL Playground 같은 도구들이 이 기능을 사용해서 자동완성을 제공하거든. 👍

근데 문제는... 프로덕션 환경에서도 이게 켜져 있으면 공격자가 API의 모든 구조를 파악할 수 있다는 거야! 😱

이런 쿼리로 전체 스키마를 볼 수 있어:

query IntrospectionQuery {
  __schema {
    types {
      name
      fields {
        name
        type {
          name
        }
      }
    }
  }
}

이걸로 공격자는:
✅ 어떤 타입들이 있는지
✅ 어떤 필드들이 있는지
✅ 어떤 쿼리와 뮤테이션이 가능한지
✅ 심지어 숨겨진 관리자 기능까지!

모든 걸 다 알아낼 수 있지. 마치 건물 설계도를 도둑에게 주는 격이야! 🏗️

const server = new ApolloServer({
  typeDefs,
  resolvers,
  introspection: process.env.NODE_ENV !== 'production', // 프로덕션에서는 OFF
  playground: process.env.NODE_ENV !== 'production'
});

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    {
      requestDidStart() {
        return {
          didResolveOperation({ request, context }) {
            if (request.operationName === 'IntrospectionQuery') {
              if (!context.user || !context.user.isAdmin) {
                throw new Error('Introspection disabled');
              }
            }
          }
        };
      }
    }
  ]
});

SQL Injection은 들어봤지? GraphQL에서도 비슷한 공격이 가능해! 💉

특히 사용자 입력을 직접 데이터베이스 쿼리에 넣을 때 위험해.

예를 들어 이런 리졸버가 있다고 해보자:

// ❌ 위험한 코드!
const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      // 사용자 입력을 직접 SQL에 삽입
      const query = `SELECT * FROM users WHERE id = ${id}`;
      return await db.query(query);
    }
  }
};

공격자가 이런 쿼리를 보낸다면?

query {
  user(id: "1 OR 1=1") {
    name
    email
    password
  }
}

실제 실행되는 SQL은:
SELECT * FROM users WHERE id = 1 OR 1=1

이러면 모든 사용자 정보가 노출되는 거지! 😨

더 악랄한 공격자는 이렇게 할 수도 있어:

query {
  user(id: "1; DROP TABLE users; --") {
    name
  }
}

이건... 사용자 테이블을 통째로 날려버리는 거야! 💣

// ✅ 안전한 코드
const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      // 매개변수 바인딩 사용
      const query = 'SELECT * FROM users WHERE id = ?';
      return await db.query(query, [id]);
    }
  }
};

// Prisma 예시
const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      return await context.prisma.user.findUnique({
        where: { id: parseInt(id) }
      });
    }
  }
};

// 스키마에서 타입 명시
type Query {
  user(id: Int!): User  # Int 타입만 허용!
}

// 추가 검증
const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      // 숫자인지 확인
      if (!Number.isInteger(id) || id < 1) {
        throw new Error('Invalid user ID');
      }
      
      return await context.prisma.user.findUnique({
        where: { id }
      });
    }
  }
};

이건 정말 심각한 문제야! 😰

GraphQL에서는 각 필드마다 권한을 체크해야 하는데, 많은 개발자들이 이걸 놓치거든.

예를 들어 이런 스키마가 있다고 해보자:

type User {
  id: ID!
  name: String!
  email: String!
  salary: Float!      # 민감한 정보!
  ssn: String!        # 주민번호 같은 초민감 정보!
}

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

만약 user 쿼리에만 인증을 체크하고, 각 필드에는 권한 체크가 없다면?

일반 사용자도 이렇게 다른 사람의 급여나 주민번호를 볼 수 있게 돼:

query {
  user(id: "123") {
    name
    salary    # 😱 남의 급여를 볼 수 있다!
    ssn       # 😱😱 주민번호까지!
  }
}

const resolvers = {
  User: {
    salary: (parent, args, context) => {
      // 본인이거나 관리자만 볼 수 있음
      if (context.user.id !== parent.id && !context.user.isAdmin) {
        throw new Error('Unauthorized');
      }
      return parent.salary;
    },
    ssn: (parent, args, context) => {
      // 본인만 볼 수 있음
      if (context.user.id !== parent.id) {
        throw new Error('Unauthorized');
      }
      return parent.ssn;
    }
  }
};

// 스키마 정의
directive @auth(requires: Role = USER) on FIELD_DEFINITION

enum Role {
  ADMIN
  USER
}

type User {
  id: ID!
  name: String!
  email: String! @auth(requires: USER)
  salary: Float! @auth(requires: ADMIN)
  ssn: String! @auth(requires: ADMIN)
}

// Directive 구현
const { SchemaDirectiveVisitor } = require('graphql-tools');

class AuthDirective extends SchemaDirectiveVisitor {
  visitFieldDefinition(field) {
    const { resolve = defaultFieldResolver } = field;
    const { requires } = this.args;

    field.resolve = async function(...args) {
      const context = args[2];
      
      if (!context.user) {
        throw new Error('Not authenticated');
      }
      
      if (requires === 'ADMIN' && !context.user.isAdmin) {
        throw new Error('Not authorized');
      }
      
      return resolve.apply(this, args);
    };
  }
}

const { shield, rule, and, or } = require('graphql-shield');

// 규칙 정의
const isAuthenticated = rule()(async (parent, args, context) => {
  return context.user !== null;
});

const isAdmin = rule()(async (parent, args, context) => {
  return context.user && context.user.isAdmin;
});

const isOwner = rule()(async (parent, args, context) => {
  return context.user && context.user.id === parent.id;
});

// 권한 설정
const permissions = shield({
  Query: {
    user: isAuthenticated,
    users: isAdmin
  },
  User: {
    email: isAuthenticated,
    salary: or(isOwner, isAdmin),
    ssn: isOwner
  }
});

// 서버에 적용
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => ({
    user: getUserFromToken(req.headers.authorization)
  }),
  schema: applyMiddleware(schema, permissions)
});

🔐 종합 보안 전략

자, 지금까지 개별 취약점들을 봤는데, 이제 이걸 다 합쳐서 종합적인 보안 전략을 세워보자! 🎯

실제 프로덕션 환경에서는 여러 방어 기법을 레이어처럼 쌓아야 해. 하나가 뚫려도 다른 게 막아주는 식으로 말이야! 🛡️

프로덕션에 배포하기 전에 이 체크리스트를 꼭 확인해봐! ✅

자, 이제 지금까지 배운 걸 다 합쳐서 완전한 보안 설정을 만들어보자! 💪
이건 실제로 프로덕션에서 사용할 수 있는 수준의 코드야.

const { ApolloServer } = require('apollo-server-express');
const express = require('express');
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');
const depthLimit = require('graphql-depth-limit');
const { createComplexityLimitRule } = require('graphql-validation-complexity');
const { shield, rule } = require('graphql-shield');

// Express 앱 설정
const app = express();

// 보안 헤더 설정
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      styleSrc: ["'self'", "'unsafe-inline'"],
      scriptSrc: ["'self'"],
      imgSrc: ["'self'", "data:", "https:"]
    }
  }
}));

// Rate Limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100개 요청
  message: 'Too many requests',
  standardHeaders: true,
  legacyHeaders: false
});

app.use('/graphql', limiter);

// 배치 크기 제한
app.use('/graphql', (req, res, next) => {
  if (Array.isArray(req.body)) {
    if (req.body.length > 10) {
      return res.status(413).json({
        error: 'Batch size too large'
      });
    }
  }
  next();
});

// 권한 규칙 정의
const isAuthenticated = rule()(async (parent, args, context) => {
  return context.user !== null;
});

const isAdmin = rule()(async (parent, args, context) => {
  return context.user && context.user.role === 'ADMIN';
});

const permissions = shield({
  Query: {
    users: isAdmin,
    user: isAuthenticated
  },
  Mutation: {
    createUser: isAdmin,
    updateUser: isAuthenticated,
    deleteUser: isAdmin
  }
});

// Apollo Server 설정
const server = new ApolloServer({
  typeDefs,
  resolvers,
  
  // 인트로스펙션 비활성화 (프로덕션)
  introspection: process.env.NODE_ENV !== 'production',
  playground: process.env.NODE_ENV !== 'production',
  
  // 검증 규칙
  validationRules: [
    depthLimit(7), // 최대 깊이 7
    createComplexityLimitRule(1000, {
      onCost: (cost) => {
        console.log('Query cost:', cost);
      }
    })
  ],
  
  // Context 설정
  context: async ({ req }) => {
    // 토큰에서 사용자 정보 추출
    const token = req.headers.authorization || '';
    const user = await getUserFromToken(token);
    
    return {
      user,
      // IP 주소 저장 (로깅용)
      ip: req.ip
    };
  },
  
  // 에러 포맷팅 (상세 정보 숨기기)
  formatError: (error) => {
    // 프로덕션에서는 상세한 에러 메시지 숨김
    if (process.env.NODE_ENV === 'production') {
      // 내부 에러는 로그만 남기고 일반 메시지 반환
      if (error.extensions?.code === 'INTERNAL_SERVER_ERROR') {
        console.error('Internal error:', error);
        return new Error('Internal server error');
      }
    }
    
    return error;
  },
  
  // 플러그인
  plugins: [
    // 쿼리 타임아웃
    {
      requestDidStart() {
        const startTime = Date.now();
        let timeout;
        
        return {
          async executionDidStart() {
            timeout = setTimeout(() => {
              throw new Error('Query timeout');
            }, 10000); // 10초 제한
          },
          
          willSendResponse() {
            clearTimeout(timeout);
            const duration = Date.now() - startTime;
            console.log(`Query took ${duration}ms`);
          }
        };
      }
    },
    
    // 로깅 플러그인
    {
      requestDidStart({ request, context }) {
        console.log('Query started:', {
          operationName: request.operationName,
          user: context.user?.id,
          ip: context.ip,
          timestamp: new Date().toISOString()
        });
        
        return {
          didEncounterErrors({ errors }) {
            console.error('Query errors:', errors);
          }
        };
      }
    }
  ]
});

// 미들웨어 적용
server.applyMiddleware({ 
  app,
  path: '/graphql',
  cors: {
    origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
    credentials: true
  }
});

// 서버 시작
const PORT = process.env.PORT || 4000;
app.listen(PORT, () => {
  console.log(`🚀 Server ready at http://localhost:${PORT}${server.graphqlPath}`);
});

이 코드는 우리가 배운 모든 보안 기법을 포함하고 있어! 🎉

• ✅ Rate Limiting
• ✅ Query Depth & Complexity Limiting
• ✅ Query Timeout
• ✅ Batch Size Limiting
• ✅ Authentication & Authorization
• ✅ Introspection 비활성화
• ✅ 보안 헤더
• ✅ CORS 설정
• ✅ 에러 메시지 최소화
• ✅ 로깅 및 모니터링

이 정도면 웬만한 공격은 다 막을 수 있어! 💪

🔍 모니터링과 로깅

보안 설정을 다 했다고 끝이 아니야! 🙅‍♂️

지속적인 모니터링과 로깅이 정말 중요해. 공격을 실시간으로 감지하고 대응할 수 있어야 하거든! 👀

실전에서 사용할 수 있는 로깅 시스템을 만들어보자! 📝

const winston = require('winston');
const { ElasticsearchTransport } = require('winston-elasticsearch');

// Winston 로거 설정
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    // 파일 로깅
    new winston.transports.File({ 
      filename: 'error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'combined.log' 
    }),
    
    // Elasticsearch로 전송 (선택사항)
    new ElasticsearchTransport({
      level: 'info',
      clientOpts: { 
        node: process.env.ELASTICSEARCH_URL 
      }
    })
  ]
});

// 개발 환경에서는 콘솔에도 출력
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

// 로깅 플러그인
const loggingPlugin = {
  requestDidStart({ request, context }) {
    const startTime = Date.now();
    
    // 요청 시작 로그
    logger.info('GraphQL Request', {
      operationName: request.operationName,
      query: request.query,
      variables: request.variables,
      userId: context.user?.id,
      ip: context.ip,
      userAgent: context.userAgent,
      timestamp: new Date().toISOString()
    });
    
    return {
      // 쿼리 파싱 단계
      parsingDidStart() {
        return (err) => {
          if (err) {
            logger.error('Parsing Error', {
              error: err.message,
              query: request.query
            });
          }
        };
      },
      
      // 검증 단계
      validationDidStart() {
        return (errs) => {
          if (errs && errs.length > 0) {
            logger.warn('Validation Errors', {
              errors: errs.map(e => e.message),
              query: request.query
            });
          }
        };
      },
      
      // 실행 단계
      executionDidStart() {
        return {
          // 각 필드 리졸버 실행
          willResolveField({ info }) {
            const fieldStartTime = Date.now();
            
            return (error, result) => {
              const duration = Date.now() - fieldStartTime;
              
              // 느린 필드 감지 (100ms 이상)
              if (duration > 100) {
                logger.warn('Slow Field Resolution', {
                  field: info.fieldName,
                  parentType: info.parentType.name,
                  duration,
                  path: info.path
                });
              }
              
              if (error) {
                logger.error('Field Resolution Error', {
                  field: info.fieldName,
                  error: error.message
                });
              }
            };
          }
        };
      },
      
      // 에러 발생
      didEncounterErrors({ errors }) {
        errors.forEach(error => {
          logger.error('GraphQL Error', {
            message: error.message,
            code: error.extensions?.code,
            path: error.path,
            userId: context.user?.id,
            ip: context.ip
          });
        });
      },
      
      // 응답 전송
      willSendResponse({ response }) {
        const duration = Date.now() - startTime;
        
        logger.info('GraphQL Response', {
          operationName: request.operationName,
          duration,
          hasErrors: response.errors && response.errors.length > 0,
          userId: context.user?.id
        });
        
        // 느린 쿼리 경고 (1초 이상)
        if (duration > 1000) {
          logger.warn('Slow Query Detected', {
            operationName: request.operationName,
            duration,
            query: request.query,
            variables: request.variables
          });
        }
      }
    };
  }
};

심각한 보안 이벤트가 발생하면 즉시 알림을 받아야 해! 📱
Slack이나 이메일로 알림을 보내는 시스템을 만들어보자.

const axios = require('axios');

// Slack 웹훅 URL
const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL;

// 알림 전송 함수
async function sendAlert(severity, message, details) {
  const color = {
    critical: '#dc3545',
    warning: '#ffc107',
    info: '#17a2b8'
  }[severity] || '#6c757d';
  
  try {
    await axios.post(SLACK_WEBHOOK_URL, {
      attachments: [{
        color,
        title: `🚨 GraphQL Security Alert - ${severity.toUpperCase()}`,
        text: message,
        fields: Object.entries(details).map(([key, value]) => ({
          title: key,
          value: String(value),
          short: true
        })),
        footer: 'GraphQL Security Monitor',
        ts: Math.floor(Date.now() / 1000)
      }]
    });
  } catch (error) {
    logger.error('Failed to send alert', { error: error.message });
  }
}

// 보안 이벤트 감지 미들웨어
const securityMonitor = {
  requestDidStart({ request, context }) {
    // 인증 실패 카운터 (메모리 캐시 또는 Redis 사용)
    const failedAttempts = new Map();
    
    return {
      didEncounterErrors({ errors }) {
        errors.forEach(async (error) => {
          // 인증 실패 감지
          if (error.extensions?.code === 'UNAUTHENTICATED') {
            const ip = context.ip;
            const count = (failedAttempts.get(ip) || 0) + 1;
            failedAttempts.set(ip, count);
            
            // 5번 이상 실패 시 알림
            if (count >= 5) {
              await sendAlert('warning', 'Multiple authentication failures detected', {
                IP: ip,
                Attempts: count,
                'User Agent': context.userAgent,
                'Last Query': request.operationName
              });
            }
          }
          
          // 권한 거부 감지
          if (error.extensions?.code === 'FORBIDDEN') {
            await sendAlert('warning', 'Unauthorized access attempt', {
              IP: context.ip,
              'User ID': context.user?.id || 'Anonymous',
              Query: request.operationName,
              Field: error.path?.join('.')
            });
          }
          
          // 쿼리 복잡도 초과
          if (error.message.includes('complexity')) {
            await sendAlert('critical', 'Query complexity limit exceeded', {
              IP: context.ip,
              'User ID': context.user?.id || 'Anonymous',
              Query: request.query
            });
          }
        });
      },
      
      willSendResponse({ response }) {
        // 비정상적으로 많은 데이터 반환 감지
        const responseSize = JSON.stringify(response).length;
        if (responseSize > 1000000) { // 1MB 이상
          sendAlert('warning', 'Large response detected', {
            Size: `${(responseSize / 1024 / 1024).toFixed(2)} MB`,
            Query: request.operationName,
            'User ID': context.user?.id || 'Anonymous'
          });
        }
      }
    };
  }
};

🧪 보안 테스트

보안 설정을 다 했으면 이제 제대로 작동하는지 테스트해야 해! 🧪

실제로 공격을 시뮬레이션해보면서 방어가 잘 되는지 확인해보자. 이런 걸 침투 테스트(Penetration Testing)라고 해! 🎯

// 테스트 스크립트 (test-depth-attack.js)
const axios = require('axios');

async function testDepthAttack() {
  // 10단계 중첩 쿼리 생성
  let query = 'query { user(id: 1) { ';
  for (let i = 0; i < 10; i++) {
    query += 'posts { comments { author { ';
  }
  query += 'name ';
  for (let i = 0; i < 10; i++) {
    query += '}}}';
  }
  
  try {
    const response = await axios.post('http://localhost:4000/graphql', {
      query
    });
    
    console.log('❌ Depth limit NOT working!');
    console.log('Response:', response.data);
  } catch (error) {
    if (error.response?.data?.errors) {
      const depthError = error.response.data.errors.find(
        e => e.message.includes('depth')
      );
      
      if (depthError) {
        console.log('✅ Depth limit working correctly!');
        console.log('Error:', depthError.message);
      }
    }
  }
}

testDepthAttack();

// test-batch-attack.js
async function testBatchAttack() {
  // 100개의 쿼리 배치 생성
  const batch = [];
  for (let i = 0; i < 100; i++) {
    batch.push({
      query: `query { user(id: ${i}) { name email } }`
    });
  }
  
  try {
    const response = await axios.post('http://localhost:4000/graphql', batch);
    console.log('❌ Batch limit NOT working!');
  } catch (error) {
    if (error.response?.status === 413) {
      console.log('✅ Batch limit working correctly!');
      console.log('Error:', error.response.data);
    }
  }
}

testBatchAttack();

// test-rate-limit.js
async function testRateLimit() {
  const results = {
    success: 0,
    blocked: 0
  };
  
  // 200개의 요청을 빠르게 전송
  const promises = [];
  for (let i = 0; i < 200; i++) {
    promises.push(
      axios.post('http://localhost:4000/graphql', {
        query: '{ user(id: 1) { name } }'
      })
      .then(() => results.success++)
      .catch(err => {
        if (err.response?.status === 429) {
          results.blocked++;
        }
      })
    );
  }
  
  await Promise.all(promises);
  
  console.log('Results:', results);
  
  if (results.blocked > 0) {
    console.log('✅ Rate limiting working!');
    console.log(`Blocked ${results.blocked} out of 200 requests`);
  } else {
    console.log('❌ Rate limiting NOT working!');
  }
}

testRateLimit();

// test-authorization.js
async function testAuthorization() {
  // 토큰 없이 요청
  try {
    const response = await axios.post('http://localhost:4000/graphql', {
      query: `
        query {
          user(id: 1) {
            name
            email
            salary
            ssn
          }
        }
      `
    });
    
    const data = response.data.data.user;
    
    if (data.salary !== null || data.ssn !== null) {
      console.log('❌ Authorization NOT working!');
      console.log('Sensitive data exposed:', data);
    } else {
      console.log('✅ Field-level authorization working!');
    }
  } catch (error) {
    if (error.response?.data?.errors) {
      console.log('✅ Authorization working correctly!');
      console.log('Errors:', error.response.data.errors);
    }
  }
}

testAuthorization();

매번 수동으로 테스트하기 귀찮지? 자동화하자! 🚀

Jest를 사용해서 보안 테스트 스위트를 만들어보자.

// security.test.js
const axios = require('axios');

const API_URL = 'http://localhost:4000/graphql';

describe('GraphQL Security Tests', () => {
  
  describe('Query Depth Limiting', () => {
    test('should block queries exceeding depth limit', async () => {
      let query = 'query { user(id: 1) { ';
      for (let i = 0; i < 10; i++) {
        query += 'posts { comments { author { ';
      }
      query += 'name ';
      for (let i = 0; i < 10; i++) {
        query += '}}}';
      }
      
      try {
        await axios.post(API_URL, { query });
        fail('Should have thrown an error');
      } catch (error) {
        expect(error.response.data.errors).toBeDefined();
        expect(error.response.data.errors[0].message).toContain('depth');
      }
    });
  });
  
  describe('Batch Size Limiting', () => {
    test('should block large batch requests', async () => {
      const batch = Array(100).fill({
        query: '{ user(id: 1) { name } }'
      });
      
      try {
        await axios.post(API_URL, batch);
        fail('Should have thrown an error');
      } catch (error) {
        expect(error.response.status).toBe(413);
      }
    });
  });
  
  describe('Rate Limiting', () => {
    test('should block excessive requests', async () => {
      const requests = Array(150).fill(null).map(() =>
        axios.post(API_URL, {
          query: '{ user(id: 1) { name } }'
        }).catch(err => err.response)
      );
      
      const responses = await Promise.all(requests);
      const blocked = responses.filter(r => r?.status === 429);
      
      expect(blocked.length).toBeGreaterThan(0);
    });
  });
  
  describe('Authorization', () => {
    test('should block unauthorized access to sensitive fields', async () => {
      const response = await axios.post(API_URL, {
        query: `
          query {
            user(id: 1) {
              salary
              ssn
            }
          }
        `
      });
      
      expect(response.data.errors).toBeDefined();
      expect(response.data.errors[0].message).toContain('Unauthorized');
    });
    
    test('should allow access with valid token', async () => {
      const token = 'valid-jwt-token-here';
      
      const response = await axios.post(API_URL, {
        query: '{ user(id: 1) { name email } }'
      }, {
        headers: {
          'Authorization': `Bearer ${token}`
        }
      });
      
      expect(response.data.data.user).toBeDefined();
      expect(response.data.errors).toBeUndefined();
    });
  });
  
  describe('Introspection', () => {
    test('should block introspection in production', async () => {
      const response = await axios.post(API_URL, {
        query: `
          query {
            __schema {
              types {
                name
              }
            }
          }
        `
      });
      
      if (process.env.NODE_ENV === 'production') {
        expect(response.data.errors).toBeDefined();
      }
    });
  });
  
});

이제 npm test 명령어 하나로 모든 보안 테스트를 실행할 수 있어! 🎉

CI/CD 파이프라인에 이 테스트들을 추가하면, 배포 전에 자동으로 보안 검증이 이루어지는 거지! 💪

🌐 실전 사례 연구

이론만 배우면 재미없잖아? 😅
실제로 어떤 회사들이 GraphQL 보안 문제를 겪었고, 어떻게 해결했는지 알아보자! 📚

GitHub은 2016년에 GraphQL API를 공개했어. 세계에서 가장 큰 코드 저장소니까 보안이 정말 중요하겠지? 🔐

초기 문제점:
• 복잡한 쿼리로 인한 성능 저하
• 레이트 리밋 우회 시도
• 과도한 데이터 요청

GitHub의 해결책:

// GitHub 스타일의 복잡도 계산
type Repository {
  name: String!           # 복잡도: 1
  issues(first: Int): [Issue!]!  # 복잡도: first * 2
  pullRequests(first: Int): [PullRequest!]!  # 복잡도: first * 3
}

// 이 쿼리의 복잡도는?
query {
  repository(name: "react") {
    name                    # 1
    issues(first: 100) {    # 100 * 2 = 200
      title
    }
    pullRequests(first: 50) {  # 50 * 3 = 150
      title
    }
  }
}
// 총 복잡도: 1 + 200 + 150 = 351

결과:
GitHub API는 현재 하루에 수백만 건의 요청을 안정적으로 처리하고 있어! 🚀

Shopify는 수백만 개의 온라인 상점을 운영하는 플랫폼이야. 보안이 뚫리면 큰일나겠지? 💰

Shopify가 직면한 문제:
• 악의적인 상점 주인이 다른 상점 데이터 접근 시도
• 대량의 제품 정보 스크래핑
• API 남용으로 인한 서버 부하

Shopify의 해결책:

const resolvers = {
  Query: {
    products: async (parent, args, context) => {
      // 현재 상점 ID 확인
      const shopId = context.shop.id;
      
      // 해당 상점의 제품만 반환
      return await db.products.findMany({
        where: {
          shopId: shopId
        }
      });
    }
  },
  
  Product: {
    // 각 필드에서도 권한 체크
    inventory: async (parent, args, context) => {
      // 상점 주인이거나 직원만 재고 정보 볼 수 있음
      if (!context.user.canViewInventory(parent.shopId)) {
        throw new Error('Unauthorized');
      }
      
      return parent.inventory;
    }
  }
};

type Query {
  # ❌ 이렇게는 안 돼!
  # products: [Product!]!
  
  # ✅ 이렇게 해야 해!
  products(
    first: Int!      # 최대 250개까지
    after: String
  ): ProductConnection!
}

type ProductConnection {
  edges: [ProductEdge!]!
  pageInfo: PageInfo!
}

type ProductEdge {
  cursor: String!
  node: Product!
}

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
}

결과:
Shopify는 이런 전략으로 API 남용을 99% 이상 줄였고, 서버 비용도 크게 절감했어! 💰

이건 실제로 있었던 일인데... 이름은 밝힐 수 없지만 교훈이 되는 사례야. 😢

사고 경위:
2021년, 한 핀테크 스타트업이 GraphQL API를 출시했어.
개발 속도를 높이기 위해 보안은 "나중에" 하기로 했지...

그런데 출시 2주 만에 해커가 이런 쿼리를 발견했어:

query {
  users {
    id
    name
    email
    bankAccount {
      accountNumber
      balance
      transactions {
        amount
        date
        description
      }
    }
  }
}

문제는:
❌ 인증 체크가 없었음
❌ 필드 레벨 권한 체크가 없었음
❌ 페이지네이션이 없어서 모든 사용자 데이터를 한 번에 가져갈 수 있었음
❌ Rate limiting이 없었음

결과:
• 5,000명 이상의 사용자 금융 정보 유출 💸
• 금융감독원 제재
• 거액의 벌금
• 서비스 신뢰도 추락
• 결국 서비스 종료... 😭

보안은 "나중에"가 아니라 "처음부터" 해야 해! 🚨