🔌 OWASP API Security Top 10:2023 완전 가이드: REST API 보안 취약점과 방어 전략

// 취약한 코드: 인증은 했지만 소유권 검증 없음
router.get('/api/orders/:orderId', authenticate, async (req, res) => {
  // orderId가 1, 2, 3, ... 순차적이면
  // 공격자는 orderId를 바꿔가며 다른 사람 주문 조회 가능
  const order = await Order.findById(req.params.orderId)
  return res.json(order)
})

// 공격자 요청:
// GET /api/orders/1001 → 내 주문
// GET /api/orders/1002 → 다른 사람 주문 (소유권 검증 없음)
// GET /api/orders/1003 → 또 다른 사람 주문...

// 안전한 코드: 소유권 검증 포함
router.get('/api/orders/:orderId', authenticate, async (req, res) => {
  const order = await Order.findOne({
    _id: req.params.orderId,
    userId: req.user.id  // 현재 인증된 사용자의 것인지 확인
  })

  if (!order) {
    return res.status(404).json({ error: 'Not found' })
    // 403이 아닌 404 반환: 리소스 존재 여부도 노출하지 않음
  }

  return res.json(order)
})

# 취약한 코드: API 키가 코드에 박혀있음
headers = {
    "Authorization": "Bearer sk-prod-abc123def456",  # 실제 프로덕션 키
    "Content-Type": "application/json"
}

# GitHub, GitLab에 이런 코드가 push되면 수초 내로 키가 탈취됨

# 안전한 코드
import os

headers = {
    "Authorization": f"Bearer {os.environ.get('API_SECRET_KEY')}",
    "Content-Type": "application/json"
}

// 취약한 코드: JWT 서명 검증 없이 디코딩만
const jwt = require('jsonwebtoken')

function authenticate(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1]
  // 서명 검증 없이 페이로드만 추출 (공격자가 위조 가능)
  const decoded = Buffer.from(token.split('.')[1], 'base64').toString()
  req.user = JSON.parse(decoded)
  next()
}

// 안전한 코드: 서명 검증 필수
function authenticate(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1]
  if (!token) return res.status(401).json({ error: 'No token' })

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET, {
      algorithms: ['HS256'],  // 허용 알고리즘 명시
      issuer: 'my-api'        // issuer 검증
    })
    req.user = decoded
    next()
  } catch (err) {
    return res.status(401).json({ error: 'Invalid token' })
  }
}

// 취약한 코드: 만료된 토큰 허용
const decoded = jwt.verify(token, secret, {
  ignoreExpiration: true  // 절대 이렇게 하면 안 됨
})

// 안전한 코드: 적절한 만료 시간 설정
const accessToken = jwt.sign(
  { userId: user.id, role: user.role },
  process.env.JWT_SECRET,
  { expiresIn: '15m', issuer: 'my-api' }  // 15분 만료
)

const refreshToken = jwt.sign(
  { userId: user.id },
  process.env.JWT_REFRESH_SECRET,
  { expiresIn: '7d' }  // 리프레시는 7일
)

// 취약한 코드: DB 객체를 그대로 반환
router.get('/api/users/:id', async (req, res) => {
  const user = await User.findById(req.params.id)
  return res.json(user)
  // 반환됨: { _id, name, email, passwordHash, role, ssn, creditCard, ... }
  // 비밀번호 해시, 권한, 주민번호, 카드번호까지 다 나감
})

// 안전한 코드: 필요한 필드만 명시적 선택
router.get('/api/users/:id', async (req, res) => {
  const user = await User.findById(req.params.id)
    .select('name email createdAt')  // 필요한 필드만
  return res.json(user)
})

// 취약한 코드: 요청 바디를 그대로 DB에 저장
router.put('/api/users/:id', authenticate, async (req, res) => {
  // 공격자가 body에 { "role": "admin" } 을 추가하면?
  const user = await User.findByIdAndUpdate(req.params.id, req.body)
  return res.json(user)
})

// 안전한 코드: 허용 필드 명시적 추출
router.put('/api/users/:id', authenticate, async (req, res) => {
  const { name, email, bio } = req.body  // role, isAdmin 등은 제외

  const user = await User.findByIdAndUpdate(
    req.params.id,
    { name, email, bio },  // 허용된 필드만
    { new: true, runValidators: true }
  )
  return res.json({ name: user.name, email: user.email })
})

# 공격자가 대용량 파일을 지속적으로 업로드
while true; do
  curl -X POST https://api.example.com/upload \
    -F "file=@huge_file_10gb.bin"
done
# → 디스크 고갈, 처리 큐 마비

const rateLimit = require('express-rate-limit')
const slowDown = require('express-slow-down')

// API 전체 Rate Limit
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,  // 15분
  max: 100,                   // 100회 제한
  standardHeaders: true,
  message: { error: 'Too many requests, please try again later.' }
})

// 특히 민감한 엔드포인트 (로그인, 회원가입)
const authLimiter = rateLimit({
  windowMs: 60 * 60 * 1000,  // 1시간
  max: 5,                     // 5회
  skipSuccessfulRequests: true
})

// Slow Down: 점점 응답을 느리게
const speedLimiter = slowDown({
  windowMs: 15 * 60 * 1000,
  delayAfter: 50,            // 50회 이후
  delayMs: hits => hits * 100  // 점진적 지연
})

app.use('/api/', apiLimiter)
app.use('/api/auth/', authLimiter, speedLimiter)

// 파일 업로드 크기 제한
const upload = multer({
  limits: {
    fileSize: 5 * 1024 * 1024,  // 5MB
    files: 1
  }
})

// 취약한 코드: HTTP 메서드로만 구분, 실제 권한 검증 없음
router.get('/api/users', authenticate, getAllUsers)    // 일반 사용자용
router.delete('/api/users/:id', authenticate, deleteUser)  // 관리자용인데 권한 확인 없음

// 공격자: DELETE /api/users/123  → 다른 사용자 계정 삭제 가능

// 안전한 코드
const requireAdmin = (req, res, next) => {
  if (!req.user.roles?.includes('ADMIN')) {
    return res.status(403).json({ error: 'Admin access required' })
  }
  next()
}

router.get('/api/users', authenticate, getAllUsers)
router.delete('/api/users/:id', authenticate, requireAdmin, deleteUser)
router.post('/api/admin/settings', authenticate, requireAdmin, updateSettings)

# 공격자가 추측하는 관리자 엔드포인트 패턴
GET /api/v1/admin/users
GET /api/internal/users
POST /api/users/promote
DELETE /api/admin/delete-all

# 모두 인증+인가 검증이 없으면 호출 가능

// 취약한 코드: 봇이 초당 수백 번 요청해 한정 상품 독점
router.post('/api/checkout', authenticate, async (req, res) => {
  const { productId, quantity } = req.body

  const product = await Product.findById(productId)
  if (product.stock < quantity) {
    return res.status(400).json({ error: 'Out of stock' })
  }

  // 재고 확인 후 구매 처리
  // 봇이 수백 ms 간격으로 요청하면 동시에 여러 번 결제 가능
  await product.decrementStock(quantity)
  return res.json({ success: true })
})

// 안전한 코드: 분산 락(Distributed Lock) + Rate Limit + 봇 탐지
router.post('/api/checkout', authenticate, checkoutLimiter, async (req, res) => {
  const lockKey = `checkout:${req.user.id}:${req.body.productId}`

  const lock = await redisLock.acquire(lockKey, 5000)  // 5초 락
  if (!lock) {
    return res.status(429).json({ error: '이미 처리 중입니다.' })
  }

  try {
    // 원자적 재고 감소 (race condition 방지)
    const result = await Product.findOneAndUpdate(
      { _id: req.body.productId, stock: { $gte: req.body.quantity } },
      { $inc: { stock: -req.body.quantity } },
      { new: true }
    )
    if (!result) return res.status(400).json({ error: '재고 부족' })
    // ...결제 처리
  } finally {
    await lock.release()
  }
})

import requests

# 취약한 코드: 사용자가 제공한 URL을 검증 없이 요청
@app.route('/api/fetch-preview', methods=['POST'])
def fetch_preview():
    url = request.json.get('url')
    response = requests.get(url)  # 공격자가 url 조작 가능
    return jsonify({'content': response.text[:1000]})

# 공격자 요청 예시:
# { "url": "http://169.254.169.254/latest/meta-data/" }
# → AWS EC2 메타데이터 탈취 (IAM 자격증명, 인스턴스 정보)

# { "url": "http://internal-service.local/admin" }
# → 내부 서비스 접근 (방화벽 우회)

# { "url": "file:///etc/passwd" }
# → 로컬 파일 읽기 (라이브러리에 따라)

# 안전한 코드
import ipaddress
from urllib.parse import urlparse

ALLOWED_SCHEMES = {'http', 'https'}
BLOCKED_HOSTS = {
    '169.254.169.254',  # AWS 메타데이터
    '169.254.170.2',    # AWS ECS 메타데이터
    'metadata.google.internal',  # GCP 메타데이터
}

def is_safe_url(url):
    try:
        parsed = urlparse(url)

        # 스킴 검증
        if parsed.scheme not in ALLOWED_SCHEMES:
            return False

        # 차단된 호스트 검증
        if parsed.hostname in BLOCKED_HOSTS:
            return False

        # Private IP 차단 (내부망 접근 방지)
        try:
            ip = ipaddress.ip_address(parsed.hostname)
            if ip.is_private or ip.is_loopback or ip.is_link_local:
                return False
        except ValueError:
            pass  # 도메인명인 경우 통과

        return True
    except Exception:
        return False

@app.route('/api/fetch-preview', methods=['POST'])
def fetch_preview():
    url = request.json.get('url')
    if not is_safe_url(url):
        return jsonify({'error': '허용되지 않는 URL입니다.'}), 400

    response = requests.get(url, timeout=5, allow_redirects=False)
    return jsonify({'content': response.text[:1000]})

// 취약한 설정: 모든 Origin 허용
app.use(cors())
// 또는
app.use(cors({ origin: '*' }))

// 이렇게 하면 어떤 도메인에서든 API 호출 가능
// CSRF 공격에 노출될 수 있음

// 안전한 설정: 허용 도메인 명시
const allowedOrigins = [
  'https://myapp.com',
  'https://www.myapp.com',
  process.env.NODE_ENV === 'development' ? 'http://localhost:3000' : null
].filter(Boolean)

app.use(cors({
  origin: (origin, callback) => {
    if (!origin || allowedOrigins.includes(origin)) {
      callback(null, true)
    } else {
      callback(new Error('Not allowed by CORS'))
    }
  },
  credentials: true
}))

# 취약한 설정
if __name__ == '__main__':
    app.run(debug=True)  # 프로덕션에서도 debug=True면 Werkzeug 디버거 노출

# 안전한 설정
import os

debug_mode = os.environ.get('FLASK_DEBUG', 'false').lower() == 'true'
app.run(debug=debug_mode)

// helmet.js로 간편하게 보안 헤더 적용
const helmet = require('helmet')

app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'"],
    }
  },
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true
  }
}))

// 커스텀 헤더 추가
app.use((req, res, next) => {
  res.setHeader('X-API-Version', '1.0')
  res.removeHeader('X-Powered-By')  // 서버 기술 스택 숨기기
  next()
})

# OpenAPI/Swagger 명세로 API 인벤토리 관리
openapi: "3.0.0"
info:
  title: "My API"
  version: "2.1.0"
  x-api-status: "production"  # 상태 명시
  x-deprecated-versions:
    - version: "1.0.0"
      sunset-date: "2025-12-31"

paths:
  /api/v2/users:
    get:
      summary: "사용자 목록 조회"
      security:
        - bearerAuth: []
      # ...

  /api/v1/users:
    get:
      deprecated: true  # 명시적 deprecated 표시
      description: "v2로 마이그레이션 필요. 2025-12-31 종료."

// 취약한 코드: 외부 API 응답을 그대로 신뢰
async function getUserLocation(ipAddress) {
  const response = await fetch(`https://third-party-geo.api/lookup/${ipAddress}`)
  const data = await response.json()

  // 외부 API가 악의적인 데이터를 반환하면?
  // data.city = "<script>alert('xss')</script>"
  return data  // 검증 없이 반환 → XSS, Injection 위험
}

// 외부 API가 침해당한 경우 (API3:2025 공급망 공격)
// → 우리 서버가 악성 응답을 실행

// 안전한 코드: 외부 API 응답도 검증
const Joi = require('joi')

const geoResponseSchema = Joi.object({
  ip: Joi.string().ip().required(),
  city: Joi.string().max(100).required(),
  country: Joi.string().length(2).required(),
  latitude: Joi.number().min(-90).max(90).required(),
  longitude: Joi.number().min(-180).max(180).required()
})

async function getUserLocation(ipAddress) {
  const response = await fetch(`https://third-party-geo.api/lookup/${ipAddress}`, {
    timeout: 3000  // 타임아웃 설정
  })

  if (!response.ok) {
    throw new Error(`External API error: ${response.status}`)
  }

  const data = await response.json()

  // 외부 응답도 스키마 검증
  const { error, value } = geoResponseSchema.validate(data)
  if (error) {
    throw new Error(`Invalid external API response: ${error.message}`)
  }

  return value  // 검증된 데이터만 반환
}