🔥 파일 업로드, 왜 이렇게 위험한 걸까?

🎭 파일 업로드 공격의 주요 유형들

1️⃣ 웹셸(Web Shell) 업로드 공격

<?php
// 이미지 파일로 위장한 웹셸
// 파일명: innocent_image.php.jpg
system($_GET['cmd']); // 외부에서 명령어 실행 가능
?>

// 또는 더 교묘한 방식
<?php
if(isset($_REQUEST['execute'])){
    eval($_REQUEST['execute']); // 임의의 PHP 코드 실행
}
?>

https://example.com/uploads/innocent_image.php.jpg?cmd=ls -la

2️⃣ 더블 익스텐션(Double Extension) 공격

3️⃣ MIME 타입 스푸핑(Spoofing)

POST /upload HTTP/1.1
Host: vulnerable-site.com
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

------WebKitFormBoundary
Content-Disposition: form-data; name="file"; filename="shell.php"
Content-Type: image/jpeg  ← 실제로는 PHP 파일인데 이미지로 속임!

<?php system($_GET['cmd']); ?>
------WebKitFormBoundary--

4️⃣ 파일 크기 공격 (DoS)

5️⃣ 경로 조작(Path Traversal) 공격

// 공격자가 보내는 파일명
filename = "../../../etc/passwd"

// 또는
filename = "..\\..\\..\\windows\\system32\\config\\sam"

// 서버가 제대로 검증하지 않으면
// 중요한 시스템 파일을 덮어쓸 수 있음!

🛡️ 안전한 파일 업로드 구현하기: 실전 가이드

📋 1단계: 화이트리스트 기반 확장자 검증

const path = require('path');
const multer = require('multer');

// 허용할 확장자 화이트리스트
const ALLOWED_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.pdf'];
const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB

const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, '/secure/uploads/') // 웹 루트 밖의 안전한 경로
  },
  filename: function (req, file, cb) {
    // 원본 파일명 사용 금지! 랜덤 이름 생성
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    const ext = path.extname(file.originalname).toLowerCase();
    
    // 확장자 검증
    if (!ALLOWED_EXTENSIONS.includes(ext)) {
      return cb(new Error('허용되지 않는 파일 형식입니다.'));
    }
    
    cb(null, file.fieldname + '-' + uniqueSuffix + ext);
  }
});

const fileFilter = (req, file, cb) => {
  const ext = path.extname(file.originalname).toLowerCase();
  
  // 이중 확장자 체크
  const nameWithoutExt = path.basename(file.originalname, ext);
  if (nameWithoutExt.includes('.')) {
    return cb(new Error('이중 확장자는 허용되지 않습니다.'), false);
  }
  
  if (ALLOWED_EXTENSIONS.includes(ext)) {
    cb(null, true);
  } else {
    cb(new Error('허용되지 않는 파일 형식입니다.'), false);
  }
};

const upload = multer({ 
  storage: storage,
  fileFilter: fileFilter,
  limits: { fileSize: MAX_FILE_SIZE }
});

// 라우트에서 사용
app.post('/upload', upload.single('file'), (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: '파일이 업로드되지 않았습니다.' });
  }
  
  res.json({ 
    message: '파일이 안전하게 업로드되었습니다.',
    filename: req.file.filename 
  });
});

import os
import uuid
from flask import Flask, request, jsonify
from werkzeug.utils import secure_filename

app = Flask(__name__)

# 허용할 확장자 화이트리스트
ALLOWED_EXTENSIONS = {'jpg', 'jpeg', 'png', 'gif', 'pdf'}
MAX_FILE_SIZE = 5 * 1024 * 1024  # 5MB
UPLOAD_FOLDER = '/secure/uploads/'

def allowed_file(filename):
    """안전한 파일 확장자 검증"""
    # 확장자가 있는지 확인
    if '.' not in filename:
        return False
    
    # 소문자로 변환하여 확장자 추출
    ext = filename.rsplit('.', 1)[1].lower()
    
    # 이중 확장자 체크
    name_without_ext = filename.rsplit('.', 1)[0]
    if '.' in name_without_ext:
        return False
    
    return ext in ALLOWED_EXTENSIONS

def generate_safe_filename(original_filename):
    """안전한 파일명 생성"""
    ext = original_filename.rsplit('.', 1)[1].lower()
    # UUID로 완전히 새로운 이름 생성
    safe_name = f"{uuid.uuid4().hex}.{ext}"
    return safe_name

@app.route('/upload', methods=['POST'])
def upload_file():
    # 파일이 요청에 포함되어 있는지 확인
    if 'file' not in request.files:
        return jsonify({'error': '파일이 없습니다.'}), 400
    
    file = request.files['file']
    
    # 파일명이 비어있는지 확인
    if file.filename == '':
        return jsonify({'error': '파일이 선택되지 않았습니다.'}), 400
    
    # 파일 크기 검증
    file.seek(0, os.SEEK_END)
    file_size = file.tell()
    file.seek(0)
    
    if file_size > MAX_FILE_SIZE:
        return jsonify({'error': '파일 크기가 너무 큽니다.'}), 400
    
    # 확장자 검증
    if not allowed_file(file.filename):
        return jsonify({'error': '허용되지 않는 파일 형식입니다.'}), 400
    
    # 안전한 파일명 생성
    safe_filename = generate_safe_filename(file.filename)
    filepath = os.path.join(UPLOAD_FOLDER, safe_filename)
    
    # 파일 저장
    file.save(filepath)
    
    return jsonify({
        'message': '파일이 안전하게 업로드되었습니다.',
        'filename': safe_filename
    }), 200

🔬 2단계: 매직 바이트(Magic Byte) 검증

const fs = require('fs').promises;

// 파일 형식별 매직 바이트 정의
const MAGIC_BYTES = {
  'jpg': [0xFF, 0xD8, 0xFF],
  'png': [0x89, 0x50, 0x4E, 0x47],
  'gif': [0x47, 0x49, 0x46, 0x38],
  'pdf': [0x25, 0x50, 0x44, 0x46],
};

async function verifyFileType(filePath, expectedExtension) {
  try {
    // 파일의 첫 부분만 읽기 (성능 최적화)
    const buffer = Buffer.alloc(8);
    const fd = await fs.open(filePath, 'r');
    await fd.read(buffer, 0, 8, 0);
    await fd.close();
    
    // 예상되는 확장자의 매직 바이트 가져오기
    const expectedBytes = MAGIC_BYTES[expectedExtension];
    
    if (!expectedBytes) {
      throw new Error('지원하지 않는 파일 형식입니다.');
    }
    
    // 매직 바이트 비교
    for (let i = 0; i < expectedBytes.length; i++) {
      if (buffer[i] !== expectedBytes[i]) {
        return false;
      }
    }
    
    return true;
  } catch (error) {
    console.error('파일 검증 오류:', error);
    return false;
  }
}

// 사용 예시
app.post('/upload', upload.single('file'), async (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: '파일이 없습니다.' });
  }
  
  const ext = path.extname(req.file.filename).slice(1).toLowerCase();
  const isValid = await verifyFileType(req.file.path, ext);
  
  if (!isValid) {
    // 파일 삭제
    await fs.unlink(req.file.path);
    return res.status(400).json({ 
      error: '파일 형식이 일치하지 않습니다. 위조된 파일일 수 있습니다.' 
    });
  }
  
  res.json({ 
    message: '파일이 안전하게 업로드되었습니다.',
    filename: req.file.filename 
  });
});

import os

# 파일 형식별 매직 바이트 정의
MAGIC_BYTES = {
    'jpg': bytes([0xFF, 0xD8, 0xFF]),
    'jpeg': bytes([0xFF, 0xD8, 0xFF]),
    'png': bytes([0x89, 0x50, 0x4E, 0x47]),
    'gif': bytes([0x47, 0x49, 0x46, 0x38]),
    'pdf': bytes([0x25, 0x50, 0x44, 0x46]),
}

def verify_file_type(file_path, expected_extension):
    """파일의 매직 바이트를 검증"""
    try:
        with open(file_path, 'rb') as f:
            # 파일의 첫 8바이트만 읽기
            header = f.read(8)
        
        # 예상되는 확장자의 매직 바이트 가져오기
        expected_bytes = MAGIC_BYTES.get(expected_extension.lower())
        
        if not expected_bytes:
            return False
        
        # 매직 바이트 비교
        return header.startswith(expected_bytes)
    
    except Exception as e:
        print(f"파일 검증 오류: {e}")
        return False

@app.route('/upload', methods=['POST'])
def upload_file():
    # ... 이전 코드 ...
    
    # 파일 저장
    file.save(filepath)
    
    # 매직 바이트 검증
    ext = safe_filename.rsplit('.', 1)[1].lower()
    if not verify_file_type(filepath, ext):
        # 검증 실패 시 파일 삭제
        os.remove(filepath)
        return jsonify({
            'error': '파일 형식이 일치하지 않습니다. 위조된 파일일 수 있습니다.'
        }), 400
    
    return jsonify({
        'message': '파일이 안전하게 업로드되었습니다.',
        'filename': safe_filename
    }), 200

🖼️ 3단계: 이미지 파일 재처리

const sharp = require('sharp');

async function sanitizeImage(inputPath, outputPath) {
  try {
    // 이미지를 읽고 다시 인코딩
    // 이 과정에서 숨겨진 악성 코드가 제거됨
    await sharp(inputPath)
      .resize(2000, 2000, { // 최대 크기 제한
        fit: 'inside',
        withoutEnlargement: true
      })
      .jpeg({ quality: 90 }) // 또는 .png()
      .toFile(outputPath);
    
    return true;
  } catch (error) {
    console.error('이미지 처리 오류:', error);
    return false;
  }
}

app.post('/upload-image', upload.single('image'), async (req, res) => {
  if (!req.file) {
    return res.status(400).json({ error: '이미지가 없습니다.' });
  }
  
  const tempPath = req.file.path;
  const safePath = tempPath + '_safe.jpg';
  
  // 이미지 재처리
  const success = await sanitizeImage(tempPath, safePath);
  
  if (!success) {
    await fs.unlink(tempPath);
    return res.status(400).json({ 
      error: '이미지 처리에 실패했습니다. 손상된 파일일 수 있습니다.' 
    });
  }
  
  // 원본 파일 삭제, 안전한 파일만 유지
  await fs.unlink(tempPath);
  await fs.rename(safePath, tempPath);
  
  res.json({ 
    message: '이미지가 안전하게 업로드되었습니다.',
    filename: req.file.filename 
  });
});

from PIL import Image
import os

def sanitize_image(input_path, output_path, max_size=(2000, 2000)):
    """이미지를 재처리하여 악성 코드 제거"""
    try:
        # 이미지 열기
        with Image.open(input_path) as img:
            # RGB 모드로 변환 (투명도 제거)
            if img.mode in ('RGBA', 'LA', 'P'):
                background = Image.new('RGB', img.size, (255, 255, 255))
                if img.mode == 'P':
                    img = img.convert('RGBA')
                background.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
                img = background
            
            # 크기 조정
            img.thumbnail(max_size, Image.Resampling.LANCZOS)
            
            # 새 파일로 저장 (EXIF 데이터 제거됨)
            img.save(output_path, 'JPEG', quality=90, optimize=True)
        
        return True
    except Exception as e:
        print(f"이미지 처리 오류: {e}")
        return False

@app.route('/upload-image', methods=['POST'])
def upload_image():
    # ... 이전 검증 코드 ...
    
    # 파일 저장
    temp_path = filepath
    safe_path = filepath + '_safe.jpg'
    
    # 이미지 재처리
    if not sanitize_image(temp_path, safe_path):
        os.remove(temp_path)
        return jsonify({
            'error': '이미지 처리에 실패했습니다. 손상된 파일일 수 있습니다.'
        }), 400
    
    # 원본 삭제, 안전한 파일로 교체
    os.remove(temp_path)
    os.rename(safe_path, temp_path)
    
    return jsonify({
        'message': '이미지가 안전하게 업로드되었습니다.',
        'filename': safe_filename
    }), 200

🗂️ 4단계: 안전한 파일 저장 위치

const express = require('express');
const path = require('path');
const fs = require('fs').promises;

// 업로드 디렉토리 (웹 루트 밖!)
const UPLOAD_DIR = '/var/app/secure_uploads/';

// 파일 다운로드 API
app.get('/download/:filename', async (req, res) => {
  try {
    const filename = req.params.filename;
    
    // 경로 조작 공격 방지
    if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
      return res.status(400).json({ error: '잘못된 파일명입니다.' });
    }
    
    const filepath = path.join(UPLOAD_DIR, filename);
    
    // 파일 존재 확인
    try {
      await fs.access(filepath);
    } catch {
      return res.status(404).json({ error: '파일을 찾을 수 없습니다.' });
    }
    
    // 파일 확장자에 따른 MIME 타입 설정
    const ext = path.extname(filename).toLowerCase();
    const mimeTypes = {
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.png': 'image/png',
      '.gif': 'image/gif',
      '.pdf': 'application/pdf',
    };
    
    const mimeType = mimeTypes[ext] || 'application/octet-stream';
    
    // 보안 헤더 설정
    res.setHeader('Content-Type', mimeType);
    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
    res.setHeader('X-Content-Type-Options', 'nosniff'); // MIME 타입 스니핑 방지
    res.setHeader('Content-Security-Policy', "default-src 'none'"); // 스크립트 실행 방지
    
    // 파일 전송
    const fileStream = require('fs').createReadStream(filepath);
    fileStream.pipe(res);
    
  } catch (error) {
    console.error('파일 다운로드 오류:', error);
    res.status(500).json({ error: '파일 다운로드 중 오류가 발생했습니다.' });
  }
});

// 이미지 미리보기 API (더 엄격한 제한)
app.get('/preview/:filename', async (req, res) => {
  try {
    const filename = req.params.filename;
    
    // 경로 조작 방지
    if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
      return res.status(400).json({ error: '잘못된 파일명입니다.' });
    }
    
    // 이미지 파일만 허용
    const ext = path.extname(filename).toLowerCase();
    if (!['.jpg', '.jpeg', '.png', '.gif'].includes(ext)) {
      return res.status(400).json({ error: '이미지 파일만 미리보기 가능합니다.' });
    }
    
    const filepath = path.join(UPLOAD_DIR, filename);
    
    // 파일 존재 확인
    try {
      await fs.access(filepath);
    } catch {
      return res.status(404).json({ error: '파일을 찾을 수 없습니다.' });
    }
    
    // 이미지 MIME 타입 설정
    const mimeTypes = {
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.png': 'image/png',
      '.gif': 'image/gif',
    };
    
    // 보안 헤더 설정
    res.setHeader('Content-Type', mimeTypes[ext]);
    res.setHeader('X-Content-Type-Options', 'nosniff');
    res.setHeader('Content-Security-Policy', "default-src 'none'; img-src 'self'");
    
    // 파일 전송
    const fileStream = require('fs').createReadStream(filepath);
    fileStream.pipe(res);
    
  } catch (error) {
    console.error('이미지 미리보기 오류:', error);
    res.status(500).json({ error: '이미지 로딩 중 오류가 발생했습니다.' });
  }
});

🔐 5단계: 추가 보안 조치들

const NodeClam = require('clamscan');

// ClamAV 초기화
const clamscan = await new NodeClam().init({
  clamdscan: {
    host: 'localhost',
    port: 3310,
  }
});

async function scanFile(filePath) {
  try {
    const { isInfected, viruses } = await clamscan.isInfected(filePath);
    
    if (isInfected) {
      console.log(`악성 파일 탐지: ${viruses.join(', ')}`);
      return false;
    }
    
    return true;
  } catch (error) {
    console.error('바이러스 스캔 오류:', error);
    return false; // 스캔 실패 시 안전하게 거부
  }
}

app.post('/upload', upload.single('file'), async (req, res) => {
  // ... 이전 검증 코드 ...
  
  // 바이러스 스캔
  const isSafe = await scanFile(req.file.path);
  
  if (!isSafe) {
    await fs.unlink(req.file.path);
    return res.status(400).json({ 
      error: '악성 파일이 탐지되었습니다.' 
    });
  }
  
  res.json({ message: '파일이 안전하게 업로드되었습니다.' });
});

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

// 업로드 속도 제한
const uploadLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 10, // 15분당 최대 10개 파일
  message: '너무 많은 파일을 업로드했습니다. 잠시 후 다시 시도해주세요.',
  standardHeaders: true,
  legacyHeaders: false,
});

// 라우트에 적용
app.post('/upload', uploadLimiter, upload.single('file'), async (req, res) => {
  // ... 업로드 처리 ...
});

const crypto = require('crypto');
const { v4: uuidv4 } = require('uuid');

// 데이터베이스 스키마 (예시)
// files 테이블:
// - id: UUID (Primary Key)
// - original_name: 원본 파일명 (암호화)
// - stored_name: 실제 저장된 파일명 (UUID)
// - user_id: 업로드한 사용자
// - upload_date: 업로드 날짜
// - file_size: 파일 크기
// - mime_type: MIME 타입

function encryptFilename(filename, secretKey) {
  const cipher = crypto.createCipher('aes-256-cbc', secretKey);
  let encrypted = cipher.update(filename, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return encrypted;
}

function decryptFilename(encryptedFilename, secretKey) {
  const decipher = crypto.createDecipher('aes-256-cbc', secretKey);
  let decrypted = decipher.update(encryptedFilename, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  return decrypted;
}

app.post('/upload', upload.single('file'), async (req, res) => {
  // ... 보안 검증 ...
  
  const fileId = uuidv4();
  const storedName = `${fileId}${path.extname(req.file.originalname)}`;
  const encryptedOriginalName = encryptFilename(
    req.file.originalname, 
    process.env.ENCRYPTION_KEY
  );
  
  // 데이터베이스에 저장
  await db.query(`
    INSERT INTO files (id, original_name, stored_name, user_id, file_size, mime_type)
    VALUES (?, ?, ?, ?, ?, ?)
  `, [
    fileId,
    encryptedOriginalName,
    storedName,
    req.user.id,
    req.file.size,
    req.file.mimetype
  ]);
  
  // 파일을 UUID 이름으로 저장
  await fs.rename(req.file.path, path.join(UPLOAD_DIR, storedName));
  
  res.json({ 
    message: '파일이 안전하게 업로드되었습니다.',
    fileId: fileId // 클라이언트에게는 UUID만 전달
  });
});

// 다운로드 시 UUID로 조회
app.get('/download/:fileId', async (req, res) => {
  const fileId = req.params.fileId;
  
  // 데이터베이스에서 파일 정보 조회
  const file = await db.query('SELECT * FROM files WHERE id = ?', [fileId]);
  
  if (!file) {
    return res.status(404).json({ error: '파일을 찾을 수 없습니다.' });
  }
  
  // 원본 파일명 복호화
  const originalName = decryptFilename(file.original_name, process.env.ENCRYPTION_KEY);
  
  // 파일 전송
  res.setHeader('Content-Disposition', `attachment; filename="${originalName}"`);
  // ... 나머지 파일 전송 로직 ...
});

const AWS = require('aws-sdk');
const s3 = new AWS.S3({
  accessKeyId: process.env.AWS_ACCESS_KEY,
  secretAccessKey: process.env.AWS_SECRET_KEY,
  region: process.env.AWS_REGION
});

async function uploadToS3(file, filename) {
  const params = {
    Bucket: process.env.S3_BUCKET,
    Key: `uploads/${filename}`,
    Body: file.buffer,
    ContentType: file.mimetype,
    // 중요: 파일을 private으로 설정
    ACL: 'private',
    // 메타데이터 추가
    Metadata: {
      'original-name': file.originalname,
      'upload-date': new Date().toISOString()
    },
    // 서버 측 암호화
    ServerSideEncryption: 'AES256'
  };
  
  return s3.upload(params).promise();
}

// Presigned URL로 안전한 다운로드 제공
async function getSecureDownloadUrl(filename, expiresIn = 3600) {
  const params = {
    Bucket: process.env.S3_BUCKET,
    Key: `uploads/${filename}`,
    Expires: expiresIn, // 1시간 후 만료
    ResponseContentDisposition: `attachment; filename="${filename}"`
  };
  
  return s3.getSignedUrl('getObject', params);
}

app.get('/download/:fileId', async (req, res) => {
  // ... 파일 정보 조회 ...
  
  // 임시 다운로드 URL 생성 (1시간 유효)
  const downloadUrl = await getSecureDownloadUrl(file.stored_name);
  
  res.json({ downloadUrl });
});

🎓 실전 체크리스트: 내 코드는 안전할까?

🔬 실제 공격 시나리오와 방어 전략

시나리오 1: PHP 웹셸 업로드 공격

async function secureImageUpload(file) {
  // 1. 확장자 검증
  const ext = path.extname(file.originalname).toLowerCase();
  const allowedExts = ['.jpg', '.jpeg', '.png', '.gif'];
  
  if (!allowedExts.includes(ext)) {
    throw new Error('허용되지 않는 파일 형식입니다.');
  }
  
  // 2. 이중 확장자 검사
  const nameWithoutExt = path.basename(file.originalname, ext);
  if (nameWithoutExt.includes('.')) {
    throw new Error('이중 확장자는 허용되지 않습니다.');
  }
  
  // 3. 매직 바이트 검증
  const isValidImage = await verifyFileType(file.path, ext.slice(1));
  if (!isValidImage) {
    await fs.unlink(file.path);
    throw new Error('유효하지 않은 이미지 파일입니다.');
  }
  
  // 4. 이미지 재처리
  const safePath = file.path + '_safe' + ext;
  const processed = await sanitizeImage(file.path, safePath);
  if (!processed) {
    await fs.unlink(file.path);
    throw new Error('이미지 처리에 실패했습니다.');
  }
  
  // 5. 안전한 파일명 생성
  const safeFilename = `${uuidv4()}${ext}`;
  const finalPath = path.join(SECURE_UPLOAD_DIR, safeFilename);
  
  // 6. 웹 루트 밖으로 이동
  await fs.rename(safePath, finalPath);
  await fs.unlink(file.path);
  
  return safeFilename;
}

시나리오 2: 경로 조작(Path Traversal) 공격

function sanitizeFilename(filename) {
  // 1. 경로 구분자 제거
  let safe = filename.replace(/[\/\\]/g, '');
  
  // 2. 상대 경로 문자 제거
  safe = safe.replace(/\.\./g, '');
  
  // 3. 특수 문자 제거
  safe = safe.replace(/[^a-zA-Z0-9._-]/g, '');
  
  // 4. 최대 길이 제한
  if (safe.length > 255) {
    safe = safe.substring(0, 255);
  }
  
  // 5. 빈 문자열 체크
  if (safe.length === 0) {
    throw new Error('유효하지 않은 파일명입니다.');
  }
  
  return safe;
}

// 더 안전한 방법: 원본 파일명을 아예 사용하지 않음
function generateSecureFilename(originalFilename) {
  const ext = path.extname(originalFilename).toLowerCase();
  
  // UUID + 타임스탬프로 완전히 새로운 이름 생성
  const timestamp = Date.now();
  const random = crypto.randomBytes(16).toString('hex');
  
  return `${timestamp}-${random}${ext}`;
}

시나리오 3: 대용량 파일 DoS 공격

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

// 1. 파일 크기 제한
const upload = multer({
  storage: storage,
  limits: {
    fileSize: 5 * 1024 * 1024, // 5MB
    files: 1 // 한 번에 1개만
  }
});

// 2. IP별 업로드 횟수 제한
const uploadLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 10, // 15분당 최대 10개
  message: '업로드 한도를 초과했습니다.',
  standardHeaders: true,
  legacyHeaders: false,
  // IP별로 다른 제한 적용 가능
  skip: (req) => {
    // 인증된 프리미엄 사용자는 제한 완화
    return req.user && req.user.isPremium;
  }
});

// 3. 속도 제한 (점진적 지연)
const speedLimiter = slowDown({
  windowMs: 15 * 60 * 1000,
  delayAfter: 5, // 5개 업로드 후부터 지연 시작
  delayMs: 500 // 매 요청마다 500ms씩 지연 증가
});

// 4. 사용자별 총 저장 공간 제한
async function checkUserQuota(userId, fileSize) {
  const userFiles = await db.query(
    'SELECT SUM(file_size) as total FROM files WHERE user_id = ?',
    [userId]
  );
  
  const currentTotal = userFiles[0].total || 0;
  const maxQuota = 100 * 1024 * 1024; // 100MB
  
  if (currentTotal + fileSize > maxQuota) {
    throw new Error('저장 공간이 부족합니다.');
  }
}

// 5. 전체 시스템 디스크 공간 모니터링
const diskspace = require('diskspace');

async function checkSystemDiskSpace() {
  return new Promise((resolve, reject) => {
    diskspace.check('/', (err, result) => {
      if (err) return reject(err);
      
      const freeSpaceGB = result.free / (1024 * 1024 * 1024);
      
      // 여유 공간이 10GB 미만이면 업로드 차단
      if (freeSpaceGB < 10) {
        reject(new Error('서버 저장 공간이 부족합니다.'));
      }
      
      resolve(true);
    });
  });
}

// 모든 방어 계층 적용
app.post('/upload',
  uploadLimiter,
  speedLimiter,
  upload.single('file'),
  async (req, res) => {
    try {
      // 시스템 디스크 공간 체크
      await checkSystemDiskSpace();
      
      // 사용자 할당량 체크
      await checkUserQuota(req.user.id, req.file.size);
      
      // 파일 처리
      const safeFilename = await secureImageUpload(req.file);
      
      // 데이터베이스에 기록
      await db.query(
        'INSERT INTO files (user_id, filename, file_size) VALUES (?, ?, ?)',
        [req.user.id, safeFilename, req.file.size]
      );
      
      res.json({ 
        message: '파일이 안전하게 업로드되었습니다.',
        filename: safeFilename 
      });
      
    } catch (error) {
      console.error('업로드 오류:', error);
      res.status(400).json({ error: error.message });
    }
  }
);

🌐 클라우드 환경에서의 파일 업로드 보안

AWS S3를 활용한 안전한 파일 업로드

const AWS = require('aws-sdk');
const crypto = require('crypto');

// S3 클라이언트 설정
const s3 = new AWS.S3({
  accessKeyId: process.env.AWS_ACCESS_KEY,
  secretAccessKey: process.env.AWS_SECRET_KEY,
  region: process.env.AWS_REGION,
  signatureVersion: 'v4' // 최신 서명 버전 사용
});

// 버킷 정책 설정 (JSON)
const bucketPolicy = {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DenyInsecureTransport",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": [
        "arn:aws:s3:::your-bucket-name/*",
        "arn:aws:s3:::your-bucket-name"
      ],
      "Condition": {
        "Bool": {
          "aws:SecureTransport": "false" // HTTPS만 허용
        }
      }
    },
    {
      "Sid": "DenyUnencryptedObjectUploads",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::your-bucket-name/*",
      "Condition": {
        "StringNotEquals": {
          "s3:x-amz-server-side-encryption": "AES256" // 암호화 강제
        }
      }
    }
  ]
};

// 안전한 업로드 함수
async function secureS3Upload(file, userId) {
  // 1. 파일 검증 (이전에 만든 함수들 사용)
  await validateFile(file);
  
  // 2. 안전한 파일명 생성
  const safeFilename = generateSecureFilename(file.originalname);
  const s3Key = `users/${userId}/${safeFilename}`;
  
  // 3. S3 업로드 파라미터
  const params = {
    Bucket: process.env.S3_BUCKET,
    Key: s3Key,
    Body: file.buffer,
    ContentType: file.mimetype,
    
    // 보안 설정
    ACL: 'private', // 절대 public으로 하지 마!
    ServerSideEncryption: 'AES256', // 서버 측 암호화
    
    // 메타데이터
    Metadata: {
      'user-id': userId.toString(),
      'original-name': Buffer.from(file.originalname).toString('base64'),
      'upload-date': new Date().toISOString(),
      'content-hash': crypto.createHash('sha256').update(file.buffer).digest('hex')
    },
    
    // 태그 (비용 추적 및 관리용)
    Tagging: `user-id=${userId}&upload-date=${Date.now()}`,
    
    // 스토리지 클래스 (비용 최적화)
    StorageClass: 'STANDARD_IA' // 자주 접근하지 않는 파일용
  };
  
  // 4. 업로드 실행
  const result = await s3.upload(params).promise();
  
  return {
    key: s3Key,
    etag: result.ETag,
    location: result.Location
  };
}

// Presigned URL로 안전한 다운로드
async function generateSecureDownloadUrl(s3Key, expiresIn = 3600) {
  const params = {
    Bucket: process.env.S3_BUCKET,
    Key: s3Key,
    Expires: expiresIn, // 1시간 후 만료
    
    // 응답 헤더 강제 설정
    ResponseContentType: 'application/octet-stream',
    ResponseContentDisposition: 'attachment',
    
    // 보안 헤더
    ResponseCacheControl: 'no-cache, no-store, must-revalidate',
    ResponseContentSecurityPolicy: "default-src 'none'"
  };
  
  return s3.getSignedUrlPromise('getObject', params);
}

// S3 버킷 CORS 설정
const corsConfiguration = {
  CORSRules: [
    {
      AllowedOrigins: ['https://yourdomain.com'], // 특정 도메인만 허용
      AllowedMethods: ['GET', 'PUT', 'POST'],
      AllowedHeaders: ['*'],
      MaxAgeSeconds: 3000,
      ExposeHeaders: ['ETag']
    }
  ]
};

// 라우트에서 사용
app.post('/upload', 
  authenticate, // 인증 미들웨어
  upload.single('file'),
  async (req, res) => {
    try {
      const result = await secureS3Upload(req.file, req.user.id);
      
      // 데이터베이스에 기록
      await db.query(`
        INSERT INTO files (user_id, s3_key, filename, file_size, etag)
        VALUES (?, ?, ?, ?, ?)
      `, [
        req.user.id,
        result.key,
        req.file.originalname,
        req.file.size,
        result.etag
      ]);
      
      res.json({
        message: '파일이 안전하게 업로드되었습니다.',
        fileId: result.key
      });
      
    } catch (error) {
      console.error('S3 업로드 오류:', error);
      res.status(500).json({ error: '업로드 중 오류가 발생했습니다.' });
    }
  }
);

// 다운로드 라우트
app.get('/download/:fileId',
  authenticate,
  async (req, res) => {
    try {
      // 파일 소유권 확인
      const file = await db.query(
        'SELECT * FROM files WHERE s3_key = ? AND user_id = ?',
        [req.params.fileId, req.user.id]
      );
      
      if (!file) {
        return res.status(404).json({ error: '파일을 찾을 수 없습니다.' });
      }
      
      // Presigned URL 생성
      const downloadUrl = await generateSecureDownloadUrl(file.s3_key);
      
      res.json({ downloadUrl });
      
    } catch (error) {
      console.error('다운로드 오류:', error);
      res.status(500).json({ error: '다운로드 URL 생성에 실패했습니다.' });
    }
  }
);

직접 업로드(Direct Upload) 패턴

// 서버: Presigned POST URL 생성
app.post('/get-upload-url', authenticate, async (req, res) => {
  const { filename, contentType } = req.body;
  
  // 파일 검증
  const ext = path.extname(filename).toLowerCase();
  if (!['.jpg', '.png', '.pdf'].includes(ext)) {
    return res.status(400).json({ error: '허용되지 않는 파일 형식입니다.' });
  }
  
  const safeFilename = generateSecureFilename(filename);
  const s3Key = `users/${req.user.id}/${safeFilename}`;
  
  const params = {
    Bucket: process.env.S3_BUCKET,
    Fields: {
      key: s3Key,
      'Content-Type': contentType,
      'x-amz-server-side-encryption': 'AES256',
      'x-amz-meta-user-id': req.user.id.toString()
    },
    Conditions: [
      ['content-length-range', 0, 5 * 1024 * 1024], // 최대 5MB
      ['eq', '$Content-Type', contentType],
      ['starts-with', '$key', `users/${req.user.id}/`]
    ],
    Expires: 300 // 5분 후 만료
  };
  
  s3.createPresignedPost(params, (err, data) => {
    if (err) {
      return res.status(500).json({ error: '업로드 URL 생성 실패' });
    }
    
    res.json({
      uploadUrl: data.url,
      fields: data.fields,
      key: s3Key
    });
  });
});

// 클라이언트: 직접 업로드
async function directUploadToS3(file) {
  // 1. 서버에서 Presigned URL 받기
  const response = await fetch('/get-upload-url', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      filename: file.name,
      contentType: file.type
    })
  });
  
  const { uploadUrl, fields, key } = await response.json();
  
  // 2. FormData 생성
  const formData = new FormData();
  Object.entries(fields).forEach(([key, value]) => {
    formData.append(key, value);
  });
  formData.append('file', file);
  
  // 3. S3로 직접 업로드
  const uploadResponse = await fetch(uploadUrl, {
    method: 'POST',
    body: formData
  });
  
  if (!uploadResponse.ok) {
    throw new Error('업로드 실패');
  }
  
  // 4. 서버에 업로드 완료 알림
  await fetch('/upload-complete', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      key: key,
      filename: file.name,
      size: file.size
    })
  });
  
  return key;
}

📱 모바일 앱에서의 파일 업로드 보안

iOS/Android 네이티브 앱

import UIKit
import CryptoKit

class SecureFileUploader {
    
    // 허용된 파일 형식
    let allowedMimeTypes = [
        "image/jpeg",
        "image/png",
        "image/gif",
        "application/pdf"
    ]
    
    let maxFileSize = 5 * 1024 * 1024 // 5MB
    
    func uploadFile(fileURL: URL, completion: @escaping (Result<String, Error>) -> Void) {
        
        // 1. 파일 크기 검증
        guard let fileSize = try? FileManager.default.attributesOfItem(atPath: fileURL.path)[.size] as? Int,
              fileSize <= maxFileSize else {
            completion(.failure(UploadError.fileTooLarge))
            return
        }
        
        // 2. MIME 타입 검증
        guard let mimeType = getMimeType(for: fileURL),
              allowedMimeTypes.contains(mimeType) else {
            completion(.failure(UploadError.invalidFileType))
            return
        }
        
        // 3. 파일 해시 계산 (무결성 검증용)
        guard let fileData = try? Data(contentsOf: fileURL),
              let fileHash = calculateSHA256(data: fileData) else {
            completion(.failure(UploadError.fileReadError))
            return
        }
        
        // 4. 서버로 업로드
        uploadToServer(fileData: fileData, mimeType: mimeType, hash: fileHash, completion: completion)
    }
    
    private func getMimeType(for url: URL) -> String? {
        let pathExtension = url.pathExtension.lowercased()
        
        switch pathExtension {
        case "jpg", "jpeg":
            return "image/jpeg"
        case "png":
            return "image/png"
        case "gif":
            return "image/gif"
        case "pdf":
            return "application/pdf"
        default:
            return nil
        }
    }
    
    private func calculateSHA256(data: Data) -> String? {
        let hash = SHA256.hash(data: data)
        return hash.compactMap { String(format: "%02x", $0) }.joined()
    }
    
    private func uploadToServer(fileData: Data, mimeType: String, hash: String, 
                               completion: @escaping (Result<String, Error>) -> Void) {
        
        guard let url = URL(string: "https://api.example.com/upload") else {
            completion(.failure(UploadError.invalidURL))
            return
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization")
        
        // Multipart form data 생성
        let boundary = UUID().uuidString
        request.setValue("multipart/form-data; boundary=\(boundary)", 
                        forHTTPHeaderField: "Content-Type")
        
        var body = Data()
        
        // 파일 해시 추가
        body.append("--\(boundary)\r\n".data(using: .utf8)!)
        body.append("Content-Disposition: form-data; name=\"hash\"\r\n\r\n".data(using: .utf8)!)
        body.append("\(hash)\r\n".data(using: .utf8)!)
        
        // 파일 데이터 추가
        body.append("--\(boundary)\r\n".data(using: .utf8)!)
        body.append("Content-Disposition: form-data; name=\"file\"; filename=\"file\"\r\n".data(using: .utf8)!)
        body.append("Content-Type: \(mimeType)\r\n\r\n".data(using: .utf8)!)
        body.append(fileData)
        body.append("\r\n".data(using: .utf8)!)
        body.append("--\(boundary)--\r\n".data(using: .utf8)!)
        
        request.httpBody = body
        
        // 업로드 실행
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                completion(.failure(error))
                return
            }
            
            guard let httpResponse = response as? HTTPURLResponse,
                  (200...299).contains(httpResponse.statusCode) else {
                completion(.failure(UploadError.serverError))
                return
            }
            
            // 성공
            completion(.success("Upload successful"))
        }.resume()
    }
}

enum UploadError: Error {
    case fileTooLarge
    case invalidFileType
    case fileReadError
    case invalidURL
    case serverError
}

import android.content.Context
import android.net.Uri
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.asRequestBody
import java.io.File
import java.security.MessageDigest

class SecureFileUploader(private val context: Context) {
    
    private val allowedMimeTypes = setOf(
        "image/jpeg",
        "image/png",
        "image/gif",
        "application/pdf"
    )
    
    private val maxFileSize = 5 * 1024 * 1024L // 5MB
    
    fun uploadFile(uri: Uri, callback: (Result<String>) -> Unit) {
        try {
            // 1. 파일 크기 검증
            val fileSize = getFileSize(uri)
            if (fileSize > maxFileSize) {
                callback(Result.failure(Exception("파일 크기가 너무 큽니다")))
                return
            }
            
            // 2. MIME 타입 검증
            val mimeType = context.contentResolver.getType(uri)
            if (mimeType !in allowedMimeTypes) {
                callback(Result.failure(Exception("허용되지 않는 파일 형식입니다")))
                return
            }
            
            // 3. 파일 읽기
            val inputStream = context.contentResolver.openInputStream(uri)
            val file = File(context.cacheDir, "temp_upload")
            inputStream?.use { input ->
                file.outputStream().use { output ->
                    input.copyTo(output)
                }
            }
            
            // 4. 파일 해시 계산
            val fileHash = calculateSHA256(file)
            
            // 5. 서버로 업로드
            uploadToServer(file, mimeType!!, fileHash, callback)
            
        } catch (e: Exception) {
            callback(Result.failure(e))
        }
    }
    
    private fun getFileSize(uri: Uri): Long {
        context.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
            val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
            cursor.moveToFirst()
            return cursor.getLong(sizeIndex)
        }
        return 0
    }
    
    private fun calculateSHA256(file: File): String {
        val digest = MessageDigest.getInstance("SHA-256")
        val bytes = file.readBytes()
        val hash = digest.digest(bytes)
        return hash.joinToString("") { "%02x".format(it) }
    }
    
    private fun uploadToServer(file: File, mimeType: String, hash: String, 
                              callback: (Result<String>) -> Unit) {
        
        val client = OkHttpClient()
        
        val requestBody = MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("hash", hash)
            .addFormDataPart(
                "file",
                file.name,
                file.asRequestBody(mimeType.toMediaType())
            )
            .build()
        
        val request = Request.Builder()
            .url("https://api.example.com/upload")
            .addHeader("Authorization", "Bearer $authToken")
            .post(requestBody)
            .build()
        
        client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                callback(Result.failure(e))
            }
            
            override fun onResponse(call: Call, response: Response) {
                if (response.isSuccessful) {
                    callback(Result.success("업로드 성공"))
                } else {
                    callback(Result.failure(Exception("서버 오류: ${response.code}")))
                }
                
                // 임시 파일 삭제
                file.delete()
            }
        })
    }
}

🎯 재능넷에서 파일 업로드 보안 구현하기

// 사용자 등급별 설정
const USER_UPLOAD_POLICIES = {
  basic: {
    allowedTypes: ['.jpg', '.jpeg', '.png', '.gif'],
    maxFileSize: 2 * 1024 * 1024, // 2MB
    maxFiles: 5,
    dailyLimit: 10
  },
  expert: {
    allowedTypes: ['.jpg', '.jpeg', '.png', '.gif', '.pdf', '.docx'],
    maxFileSize: 10 * 1024 * 1024, // 10MB
    maxFiles: 20,
    dailyLimit: 50
  },
  premium: {
    allowedTypes: ['.jpg', '.jpeg', '.png', '.gif', '.pdf', '.docx', '.zip'],
    maxFileSize: 50 * 1024 * 1024, // 50MB
    maxFiles: 100,
    dailyLimit: 200
  }
};

// 재능넷 전용 업로드 미들웨어
function jaeningNetUploadMiddleware(req, res, next) {
  const userTier = req.user.tier; // 'basic', 'expert', 'premium'
  const policy = USER_UPLOAD_POLICIES[userTier];
  
  // 동적으로 multer 설정 생성
  const upload = multer({
    storage: multer.memoryStorage(),
    limits: {
      fileSize: policy.maxFileSize,
      files: policy.maxFiles
    },
    fileFilter: (req, file, cb) => {
      const ext = path.extname(file.originalname).toLowerCase();
      
      if (!policy.allowedTypes.includes(ext)) {
        return cb(new Error(`${userTier} 등급은 ${ext} 파일을 업로드할 수 없습니다.`));
      }
      
      cb(null, true);
    }
  }).array('files', policy.maxFiles);
  
  upload(req, res, next);
}

// 일일 업로드 제한 체크
async function checkDailyLimit(userId, userTier) {
  const today = new Date().toISOString().split('T')[0];
  
  const count = await db.query(`
    SELECT COUNT(*) as count 
    FROM uploads 
    WHERE user_id = ? AND DATE(created_at) = ?
  `, [userId, today]);
  
  const policy = USER_UPLOAD_POLICIES[userTier];
  
  if (count[0].count >= policy.dailyLimit) {
    throw new Error(`일일 업로드 한도(${policy.dailyLimit}개)를 초과했습니다.`);
  }
}

// 포트폴리오 이미지 업로드
app.post('/api/portfolio/upload',
  authenticate,
  jaeningNetUploadMiddleware,
  async (req, res) => {
    try {
      // 일일 한도 체크
      await checkDailyLimit(req.user.id, req.user.tier);
      
      const uploadedFiles = [];
      
      for (const file of req.files) {
        // 보안 검증
        const isValid = await validateFile(file);
        if (!isValid) {
          continue; // 유효하지 않은 파일은 건너뛰기
        }
        
        // 이미지 최적화 및 워터마크 추가
        const processedImage = await processPortfolioImage(file);
        
        // S3 업로드
        const s3Key = await uploadToS3(processedImage, req.user.id);
        
        // 데이터베이스 저장
        const fileRecord = await db.query(`
          INSERT INTO portfolio_images 
          (user_id, s3_key, original_name, file_size, tier)
          VALUES (?, ?, ?, ?, ?)
        `, [
          req.user.id,
          s3Key,
          file.originalname,
          file.size,
          req.user.tier
        ]);
        
        uploadedFiles.push({
          id: fileRecord.insertId,
          url: await generateThumbnailUrl(s3Key)
        });
      }
      
      res.json({
        message: '포트폴리오 이미지가 업로드되었습니다.',
        files: uploadedFiles,
        remainingQuota: USER_UPLOAD_POLICIES[req.user.tier].dailyLimit - uploadedFiles.length
      });
      
    } catch (error) {
      console.error('업로드 오류:', error);
      res.status(400).json({ error: error.message });
    }
  }
);

// 이미지 처리 (워터마크, 리사이징)
async function processPortfolioImage(file) {
  return sharp(file.buffer)
    .resize(1920, 1080, {
      fit: 'inside',
      withoutEnlargement: true
    })
    .composite([{
      input: Buffer.from(`
        <svg width="200" height="50">
          <text x="10" y="30" font-family="Arial" font-size="20" 
                fill="rgba(255,255,255,0.5)">재능넷</text>
        </svg>
      `),
      gravity: 'southeast'
    }])
    .jpeg({ quality: 85 })
    .toBuffer();
}

🔍 보안 모니터링 및 로깅

포괄적인 로깅 시스템

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

// Winston 로거 설정
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    // 파일 로그
    new winston.transports.File({ 
      filename: 'logs/upload-error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'logs/upload-combined.log' 
    }),
    
    // Elasticsearch (선택사항)
    new ElasticsearchTransport({
      level: 'info',
      clientOpts: { node: 'http://localhost:9200' },
      index: 'upload-logs'
    })
  ]
});

// 업로드 이벤트 로깅 미들웨어
function uploadLoggingMiddleware(req, res, next) {
  const startTime = Date.now();
  
  // 응답 완료 시 로그 기록
  res.on('finish', () => {
    const duration = Date.now() - startTime;
    
    const logData = {
      timestamp: new Date().toISOString(),
      userId: req.user?.id || 'anonymous',
      ip: req.ip,
      userAgent: req.get('user-agent'),
      method: req.method,
      url: req.originalUrl,
      statusCode: res.statusCode,
      duration: duration,
      fileInfo: req.file ? {
        originalName: req.file.originalname,
        mimeType: req.file.mimetype,
        size: req.file.size,
        encoding: req.file.encoding
      } : null,
      error: res.locals.error || null
    };
    
    if (res.statusCode >= 400) {
      logger.error('Upload failed', logData);
    } else {
      logger.info('Upload successful', logData);
    }
  });
  
  next();
}

// 의심스러운 활동 감지
class SecurityMonitor {
  constructor() {
    this.suspiciousActivities = new Map();
    this.blockedIPs = new Set();
  }
  
  // 의심스러운 패턴 감지
  detectSuspiciousActivity(userId, ip, activity) {
    const key = `${userId}-${ip}`;
    
    if (!this.suspiciousActivities.has(key)) {
      this.suspiciousActivities.set(key, []);
    }
    
    const activities = this.suspiciousActivities.get(key);
    activities.push({
      activity,
      timestamp: Date.now()
    });
    
    // 최근 5분간의 활동만 유지
    const fiveMinutesAgo = Date.now() - (5 * 60 * 1000);
    const recentActivities = activities.filter(a => a.timestamp > fiveMinutesAgo);
    this.suspiciousActivities.set(key, recentActivities);
    
    // 의심스러운 패턴 체크
    if (this.isSuspicious(recentActivities)) {
      this.blockIP(ip);
      this.alertAdmin(userId, ip, recentActivities);
      return true;
    }
    
    return false;
  }
  
  isSuspicious(activities) {
    // 5분 내에 10번 이상 실패
    const failures = activities.filter(a => a.activity === 'upload_failed');
    if (failures.length >= 10) {
      return true;
    }
    
    // 다양한 확장자로 업로드 시도
    const extensions = new Set(
      activities
        .filter(a => a.activity === 'invalid_extension')
        .map(a => a.extension)
    );
    if (extensions.size >= 5) {
      return true;
    }
    
    // 짧은 시간에 대용량 파일 여러 개
    const largeFiles = activities.filter(a => 
      a.activity === 'large_file' && a.size > 10 * 1024 * 1024
    );
    if (largeFiles.length >= 5) {
      return true;
    }
    
    return false;
  }
  
  blockIP(ip) {
    this.blockedIPs.add(ip);
    logger.warn('IP blocked due to suspicious activity', { ip });
    
    // 1시간 후 자동 해제
    setTimeout(() => {
      this.blockedIPs.delete(ip);
      logger.info('IP unblocked', { ip });
    }, 60 * 60 * 1000);
  }
  
  isBlocked(ip) {
    return this.blockedIPs.has(ip);
  }
  
  async alertAdmin(userId, ip, activities) {
    // 관리자에게 알림 전송
    await sendAdminAlert({
      type: 'SUSPICIOUS_UPLOAD_ACTIVITY',
      userId,
      ip,
      activities,
      timestamp: new Date().toISOString()
    });
    
    logger.error('Suspicious activity detected', {
      userId,
      ip,
      activityCount: activities.length
    });
  }
}

const securityMonitor = new SecurityMonitor();

// 보안 모니터링 미들웨어
function securityMonitoringMiddleware(req, res, next) {
  // IP 차단 체크
  if (securityMonitor.isBlocked(req.ip)) {
    logger.warn('Blocked IP attempted access', { ip: req.ip });
    return res.status(403).json({ 
      error: '접근이 차단되었습니다. 관리자에게 문의하세요.' 
    });
  }
  
  next();
}

// 업로드 라우트에 모든 보안 계층 적용
app.post('/upload',
  uploadLoggingMiddleware,
  securityMonitoringMiddleware,
  authenticate,
  uploadLimiter,
  upload.single('file'),
  async (req, res) => {
    try {
      // 파일 검증
      if (!req.file) {
        securityMonitor.detectSuspiciousActivity(
          req.user.id,
          req.ip,
          { activity: 'no_file' }
        );
        throw new Error('파일이 없습니다.');
      }
      
      // 확장자 검증
      const ext = path.extname(req.file.originalname).toLowerCase();
      if (!ALLOWED_EXTENSIONS.includes(ext)) {
        securityMonitor.detectSuspiciousActivity(
          req.user.id,
          req.ip,
          { activity: 'invalid_extension', extension: ext }
        );
        throw new Error('허용되지 않는 파일 형식입니다.');
      }
      
      // 파일 크기 체크
      if (req.file.size > MAX_FILE_SIZE) {
        securityMonitor.detectSuspiciousActivity(
          req.user.id,
          req.ip,
          { activity: 'large_file', size: req.file.size }
        );
        throw new Error('파일 크기가 너무 큽니다.');
      }
      
      // 매직 바이트 검증
      const isValid = await verifyFileType(req.file.path, ext.slice(1));
      if (!isValid) {
        securityMonitor.detectSuspiciousActivity(
          req.user.id,
          req.ip,
          { activity: 'magic_byte_mismatch', extension: ext }
        );
        await fs.unlink(req.file.path);
        throw new Error('파일 형식이 일치하지 않습니다.');
      }
      
      // 안전한 처리
      const safeFilename = await secureFileUpload(req.file);
      
      logger.info('File uploaded successfully', {
        userId: req.user.id,
        filename: safeFilename,
        originalName: req.file.originalname,
        size: req.file.size
      });
      
      res.json({ 
        message: '파일이 안전하게 업로드되었습니다.',
        filename: safeFilename 
      });
      
    } catch (error) {
      res.locals.error = error.message;
      
      securityMonitor.detectSuspiciousActivity(
        req.user?.id || 'anonymous',
        req.ip,
        { activity: 'upload_failed', error: error.message }
      );
      
      res.status(400).json({ error: error.message });
    }
  }
);

실시간 대시보드

// 통계 API
app.get('/api/admin/upload-stats', authenticateAdmin, async (req, res) => {
  try {
    const stats = await db.query(`
      SELECT 
        DATE(created_at) as date,
        COUNT(*) as total_uploads,
        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful,
        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
        SUM(file_size) as total_size,
        AVG(file_size) as avg_size
      FROM uploads
      WHERE created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
      GROUP BY DATE(created_at)
      ORDER BY date DESC
    `);
    
    const topUsers = await db.query(`
      SELECT 
        user_id,
        COUNT(*) as upload_count,
        SUM(file_size) as total_size
      FROM uploads
      WHERE created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
      GROUP BY user_id
      ORDER BY upload_count DESC
      LIMIT 10
    `);
    
    const suspiciousActivities = await db.query(`
      SELECT *
      FROM security_logs
      WHERE severity = 'high'
        AND created_at >= DATE_SUB(NOW(), INTERVAL 24 HOUR)
      ORDER BY created_at DESC
      LIMIT 20
    `);
    
    res.json({
      stats,
      topUsers,
      suspiciousActivities,
      blockedIPs: Array.from(securityMonitor.blockedIPs)
    });
    
  } catch (error) {
    console.error('통계 조회 오류:', error);
    res.status(500).json({ error: '통계를 불러올 수 없습니다.' });
  }
});

🎓 마무리: 보안은 여정이지 목적지가 아니야

🚀 다음 단계: 더 공부하고 싶다면?

💬 마지막으로...