🔐 OWASP Top 10:2025 완전 가이드: 웹 보안 취약점과 방어 전략

// 취약한 코드: 인증은 했지만 소유권 검증 없음
app.get('/api/orders/:orderId', authenticate, async (req, res) => {
  const order = await Order.findById(req.params.orderId)
  res.json(order) // 다른 사람의 주문도 조회 가능
})

// 안전한 코드: 요청자 소유 여부 검증
app.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(403).json({ error: 'Forbidden' })
  res.json(order)
})

# 공격자가 직접 URL을 추측해서 접근 시도
GET /admin/users
GET /admin/dashboard
GET /internal/reports

// 취약한 코드: 관리자 페이지 URL만 숨김 (Security by Obscurity)
app.get('/admin-panel-xk3f', (req, res) => {
  // URL 모르면 못 들어오겠지... (틀린 생각)
  res.render('admin')
})

// 안전한 코드: 역할 기반 접근 제어
app.get('/admin', authenticate, requireRole('ADMIN'), (req, res) => {
  res.render('admin')
})

function requireRole(role) {
  return (req, res, next) => {
    if (!req.user.roles.includes(role)) {
      return res.status(403).json({ error: 'Insufficient privileges' })
    }
    next()
  }
}

// 취약한 코드: alg=none 공격에 취약
const decoded = jwt.verify(token, secret, { algorithms: ['HS256', 'none'] })

// 안전한 코드: 허용 알고리즘 명시적 제한
const decoded = jwt.verify(token, secret, { algorithms: ['HS256'] })

# 취약한 예시: 제품 기본값 그대로 사용
database:
  host: localhost
  username: admin
  password: admin  # 또는 password, 123456

# MongoDB, Redis, Elasticsearch 등은 기본 설정이 인증 없음
# → 포트만 열려있으면 누구나 접근 가능

# 개발 중에 열어둔 디버그 포트가 프로덕션에도 열림
# Node.js 디버그 포트
--inspect=0.0.0.0:9229  # 외부에서 접근 가능하면 원격 코드 실행 가능

# 잠재적으로 위험한 포트들
22   # SSH (기본 포트)
3306 # MySQL
5432 # PostgreSQL
6379 # Redis
27017 # MongoDB

// 취약한 코드: 스택 트레이스 그대로 노출
app.use((err, req, res, next) => {
  res.status(500).json({
    error: err.message,
    stack: err.stack,  // DB 구조, 파일 경로, 내부 로직 노출
    query: err.query   // SQL 쿼리까지 노출
  })
})

// 안전한 코드: 일반화된 에러 메시지
app.use((err, req, res, next) => {
  logger.error(err) // 내부 로그에만 기록
  res.status(500).json({ error: 'Internal server error' })
})

# 취약한 설정: 보안 헤더 없음

# 안전한 설정
add_header X-Content-Type-Options "nosniff";
add_header X-Frame-Options "DENY";
add_header X-XSS-Protection "1; mode=block";
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains";
add_header Content-Security-Policy "default-src 'self'";
add_header Referrer-Policy "strict-origin-when-cross-origin";
add_header Permissions-Policy "geolocation=(), microphone=()";

// package.json — 버전 고정 없이 최신 버전 자동 설치
{
  "dependencies": {
    "express": "*",       // 위험: 악의적 업데이트 자동 설치
    "lodash": "^4.0.0",  // 주의: 마이너 버전 자동 업그레이드
    "axios": "~1.0.0"    // 패치 버전만 자동 업그레이드
  }
}

# 의존성 취약점 확인
npm audit
pip-audit
trivy image my-app:latest

# SBOM(Software Bill of Materials) 생성
syft my-app:latest -o spdx-json > sbom.json

import hashlib
import bcrypt

# 취약한 코드: MD5, SHA1 사용 (레인보우 테이블 공격에 취약)
def bad_hash_password(password):
    return hashlib.md5(password.encode()).hexdigest()

def also_bad(password):
    return hashlib.sha1(password.encode()).hexdigest()

# 안전한 코드: bcrypt (솔트 자동 포함, 느린 해시)
def good_hash_password(password):
    return bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))

def verify_password(password, hashed):
    return bcrypt.checkpw(password.encode(), hashed)

# 취약: 로그인 폼이 HTTP로 전송
POST http://example.com/login
Content-Type: application/x-www-form-urlencoded

username=admin&password=secret123  # 평문으로 네트워크에 노출

# 안전: 반드시 HTTPS
POST https://example.com/login

# 취약한 설정: 구버전 TLS 허용
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;  # TLS 1.0, 1.1은 POODLE, BEAST 공격에 취약

# 안전한 설정
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:ECDHE-RSA-AES128-GCM-SHA256';
ssl_prefer_server_ciphers off;

// 취약한 코드: 키가 소스 코드에 하드코딩
private static final String SECRET_KEY = "my-super-secret-key-123";

// 안전한 코드: 환경변수 또는 Secrets Manager에서 로드
private static final String SECRET_KEY = System.getenv("JWT_SECRET");

// 취약한 코드: 사용자 입력을 쿼리에 직접 concatenation
String query = "SELECT * FROM users WHERE name = '" + username + "'";
// 공격자 입력: admin' OR '1'='1
// 실행되는 쿼리: SELECT * FROM users WHERE name = 'admin' OR '1'='1'
// → 모든 사용자 데이터 반환

// 안전한 코드: PreparedStatement 사용
String query = "SELECT * FROM users WHERE name = ?";
PreparedStatement stmt = conn.prepareStatement(query);
stmt.setString(1, username);

import subprocess
import shlex

# 취약한 코드: 사용자 입력을 셸 명령에 직접 삽입
def get_file_info(filename):
    output = subprocess.run(f"ls -la {filename}", shell=True, capture_output=True)
    return output.stdout
# 공격자 입력: "file.txt; cat /etc/passwd"
# 실행: ls -la file.txt; cat /etc/passwd  → 시스템 파일 노출

# 안전한 코드: 리스트 형태로 전달, shell=False
def get_file_info(filename):
    output = subprocess.run(["ls", "-la", filename], shell=False, capture_output=True)
    return output.stdout

from flask import Flask, render_template_string

app = Flask(__name__)

# 취약한 코드: 사용자 입력을 템플릿으로 직접 렌더링
@app.route('/greet')
def greet():
    name = request.args.get('name')
    return render_template_string(f"Hello {name}!")
# 공격자 입력: {{7*7}} → "Hello 49!" 출력 (코드 실행 확인)
# 심화 공격: {{config.items()}} → 서버 설정 노출

# 안전한 코드: 변수 분리
@app.route('/greet')
def greet():
    name = request.args.get('name')
    return render_template_string("Hello {{ name }}!", name=name)

// 취약한 코드: Rate Limit 없음
app.post('/login', async (req, res) => {
  const { username, password } = req.body
  const user = await User.findOne({ username })
  if (user && await bcrypt.compare(password, user.password)) {
    res.json({ token: generateToken(user) })
  } else {
    res.status(401).json({ error: 'Invalid credentials' })
  }
})

// 안전한 코드: Rate Limit + 계정 잠금
const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 5,                    // 5회 초과 시 차단
  message: 'Too many login attempts'
})

app.post('/login', loginLimiter, async (req, res) => {
  // ... 동일 로직
})

// 취약한 코드: 로그인 후 세션 ID 갱신 없음
app.post('/login', (req, res) => {
  req.session.userId = user.id  // 기존 세션 ID 그대로 사용
})

// 안전한 코드: 로그인 성공 시 세션 재생성
app.post('/login', (req, res) => {
  req.session.regenerate((err) => {  // 새 세션 ID 발급
    req.session.userId = user.id
    res.json({ success: true })
  })
})

// 취약한 코드: 비밀번호 복잡도 검증 없음
app.post('/register', (req, res) => {
  const { password } = req.body
  // "1234", "aaaa" 같은 비밀번호도 허용

  // 안전한 코드: 복잡도 검증
  const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/
  if (!passwordRegex.test(password)) {
    return res.status(400).json({ error: '비밀번호는 8자 이상, 대소문자, 숫자, 특수문자 포함 필요' })
  }
})

# 취약한 GitHub Actions: 외부 액션 버전 고정 없음
steps:
  - uses: actions/checkout@main  # 위험: main 브랜치는 언제든 변경 가능

# 안전한 설정: 커밋 해시로 고정
steps:
  - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2

# 취약한 방법: 검증 없이 실행
curl https://example.com/install.sh | bash

# 안전한 방법: 해시 검증 후 실행
curl -O https://example.com/install.sh
curl -O https://example.com/install.sh.sha256
sha256sum -c install.sh.sha256  # 해시 일치 확인 후
bash install.sh

// 취약한 코드: 신뢰할 수 없는 소스에서 역직렬화
ObjectInputStream ois = new ObjectInputStream(request.getInputStream());
Object obj = ois.readObject();  // 악의적 직렬화 데이터 처리 시 RCE 가능

// 안전한 코드: 역직렬화 전 타입 검증 또는 JSON 사용
// Java Deserialization Filter (Java 9+)
ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
    "com.example.SafeClass;!*"
);
ois.setObjectInputFilter(filter);

// 보안 이벤트 로깅 예시
const securityLog = {
  // 인증 관련
  'LOGIN_SUCCESS': { level: 'INFO', fields: ['userId', 'ip', 'userAgent', 'timestamp'] },
  'LOGIN_FAILURE': { level: 'WARN', fields: ['username', 'ip', 'reason', 'timestamp'] },
  'LOGOUT': { level: 'INFO', fields: ['userId', 'ip', 'timestamp'] },
  'MFA_FAILURE': { level: 'WARN', fields: ['userId', 'ip', 'timestamp'] },

  // 접근 제어 관련
  'ACCESS_DENIED': { level: 'WARN', fields: ['userId', 'resource', 'ip', 'timestamp'] },
  'PRIVILEGE_ESCALATION_ATTEMPT': { level: 'ERROR', fields: ['userId', 'ip', 'timestamp'] },

  // 데이터 관련
  'SENSITIVE_DATA_ACCESS': { level: 'INFO', fields: ['userId', 'dataType', 'timestamp'] },
  'BULK_DATA_EXPORT': { level: 'WARN', fields: ['userId', 'recordCount', 'timestamp'] },
}

// ❌ 절대 로그에 남기면 안 되는 데이터
logger.info(`Login attempt: username=${username}, password=${password}`)  // 비밀번호
logger.info(`Card payment: card=${cardNumber}, cvv=${cvv}`)               // 결제 정보
logger.info(`Token: ${authToken}`)                                         // 인증 토큰
logger.info(`SSN: ${socialSecurityNumber}`)                                // 개인정보

// ✅ 안전한 로깅
logger.info(`Login attempt: userId=${userId}, ip=${ip}`)
logger.info(`Payment processed: orderId=${orderId}, amount=${amount}`)

// 취약한 코드: 예외 발생 시 파일 락 미해제
public void processUpload(MultipartFile file) throws IOException {
    FileOutputStream fos = new FileOutputStream("temp_" + file.getOriginalFilename());
    fos.write(file.getBytes()); // 여기서 예외 발생 시 fos가 닫히지 않음
    // → 파일 잠금 상태 유지, 디스크 고갈 공격 가능
}

// 안전한 코드: try-with-resources
public void processUpload(MultipartFile file) throws IOException {
    try (FileOutputStream fos = new FileOutputStream("temp_" + file.getOriginalFilename())) {
        fos.write(file.getBytes());
    } // 예외 발생해도 자동으로 close() 호출
}

// 취약한 코드: 이체 중 오류 시 부분만 처리
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    accountRepository.deduct(fromId, amount);   // 출금 성공
    // 여기서 예외 발생 →
    accountRepository.deposit(toId, amount);    // 입금 누락 → 돈이 사라짐
}

// 안전한 코드: 트랜잭션으로 묶기
@Transactional
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    accountRepository.deduct(fromId, amount);
    accountRepository.deposit(toId, amount);
    // 예외 발생 시 전체 롤백 → 데이터 일관성 유지
}

# 취약한 코드
try:
    result = db.execute(query)
except Exception as e:
    return {"error": str(e)}
    # 반환 예시: "psycopg2.errors.UndefinedTable: relation 'users' does not exist"
    # → DB 종류, 테이블 구조, 버전 정보 노출

# 안전한 코드
try:
    result = db.execute(query)
except Exception as e:
    logger.error(f"DB error: {e}", exc_info=True)  # 내부 로그에만
    return {"error": "처리 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요."}