# AI 피싱 탐지 시스템 예시 (방어 관점)
import hashlib
from datetime import datetime

class PhishingDetector:
    def __init__(self):
        self.known_patterns = []
        self.ai_score_threshold = 0.75

    def analyze_email(self, email_content, sender_info):
        features = {
            "urgency_score": self._check_urgency(email_content),
            "link_analysis": self._analyze_links(email_content),
            "sender_reputation": self._check_sender(sender_info),
            "ai_generated_probability": self._detect_ai_text(email_content),
            "context_mismatch": self._check_context(email_content, sender_info),
        }
        risk_score = sum(features.values()) / len(features)
        return {
            "risk_level": "HIGH" if risk_score > self.ai_score_threshold else "LOW",
            "features": features,
            "timestamp": datetime.now().isoformat(),
        }

    def _detect_ai_text(self, content):
        # AI 생성 텍스트 특성 분석
        # - 과도하게 완벽한 문법
        # - 통계적 텍스트 패턴 분석
        # - 퍼플렉서티(perplexity) 기반 탐지
        pass

# 랜섬웨어 대응 -- 백업 검증 스크립트 예시
#!/bin/bash

BACKUP_DIR="/backup/daily"
LOG_FILE="/var/log/backup-verify.log"
ALERT_EMAIL="security@company.com"

echo "=== Backup Verification Started: $(date) ===" >> "$LOG_FILE"

# 백업 무결성 검증
for backup_file in "$BACKUP_DIR"/*.tar.gz; do
    if tar -tzf "$backup_file" > /dev/null 2>&1; then
        echo "[OK] $backup_file" >> "$LOG_FILE"
    else
        echo "[FAIL] $backup_file - CORRUPTED" >> "$LOG_FILE"
        echo "Backup corruption detected: $backup_file" | \
            mail -s "ALERT: Backup Verification Failed" "$ALERT_EMAIL"
    fi
done

# 3-2-1 백업 규칙 검증
local_count=$(find "$BACKUP_DIR" -name "*.tar.gz" -mtime -1 | wc -l)
if [ "$local_count" -lt 1 ]; then
    echo "[WARN] No recent local backup found" >> "$LOG_FILE"
fi

# AWS Config 규칙 예시 -- 클라우드 보안 자동 감사
# aws-config-rules.yaml
Resources:
  S3BucketPublicReadRule:
    Type: AWS::Config::ConfigRule
    Properties:
      ConfigRuleName: s3-bucket-public-read-prohibited
      Source:
        Owner: AWS
        SourceIdentifier: S3_BUCKET_PUBLIC_READ_PROHIBITED
      Scope:
        ComplianceResourceTypes:
          - AWS::S3::Bucket

  IAMRootAccessKeyRule:
    Type: AWS::Config::ConfigRule
    Properties:
      ConfigRuleName: iam-root-access-key-check
      Source:
        Owner: AWS
        SourceIdentifier: IAM_ROOT_ACCESS_KEY_CHECK

  EncryptionAtRestRule:
    Type: AWS::Config::ConfigRule
    Properties:
      ConfigRuleName: encrypted-volumes
      Source:
        Owner: AWS
        SourceIdentifier: ENCRYPTED_VOLUMES
      Scope:
        ComplianceResourceTypes:
          - AWS::EC2::Volume

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "EnforceMFA",
      "Effect": "Deny",
      "NotAction": [
        "iam:CreateVirtualMFADevice",
        "iam:EnableMFADevice",
        "iam:GetUser",
        "iam:ListMFADevices",
        "iam:ListVirtualMFADevices",
        "iam:ResyncMFADevice",
        "sts:GetSessionToken"
      ],
      "Resource": "*",
      "Condition": {
        "BoolIfExists": {
          "aws:MultiFactorAuthPresent": "false"
        }
      }
    }
  ]
}

# Kubernetes NetworkPolicy 예시 -- 마이크로세그먼테이션
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-backend-access
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend-api
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: api-gateway
        - namespaceSelector:
            matchLabels:
              env: production
      ports:
        - protocol: TCP
          port: 8080
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: database
      ports:
        - protocol: TCP
          port: 5432
    - to:
        - namespaceSelector: {}
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53

# PQC 전환 준비 -- 암호화 인벤토리 스캔 예시
class CryptoInventoryScanner:
    """조직 내 암호화 사용 현황을 스캔하여 양자 취약 알고리즘을 식별합니다."""

    QUANTUM_VULNERABLE = [
        "RSA-1024", "RSA-2048", "RSA-4096",
        "ECDSA-P256", "ECDSA-P384",
        "ECDH", "DH",
        "DSA",
    ]

    QUANTUM_SAFE = [
        "ML-KEM-768", "ML-KEM-1024",
        "ML-DSA-65", "ML-DSA-87",
        "SLH-DSA-SHA2-128s",
        "AES-256",  # 대칭키는 양자에 강함 (키 길이 2배 필요)
    ]

    def scan_certificates(self, cert_paths):
        results = []
        for path in cert_paths:
            cert_info = self._parse_certificate(path)
            is_vulnerable = cert_info["algorithm"] in self.QUANTUM_VULNERABLE
            results.append({
                "path": path,
                "algorithm": cert_info["algorithm"],
                "key_size": cert_info["key_size"],
                "expiry": cert_info["expiry"],
                "quantum_vulnerable": is_vulnerable,
                "migration_priority": "HIGH" if is_vulnerable else "LOW",
            })
        return results

    def generate_migration_plan(self, scan_results):
        vulnerable = [r for r in scan_results if r["quantum_vulnerable"]]
        return {
            "total_certificates": len(scan_results),
            "vulnerable_count": len(vulnerable),
            "high_priority": [r for r in vulnerable if r["migration_priority"] == "HIGH"],
            "recommended_timeline": "2026-2028",
            "target_algorithms": self.QUANTUM_SAFE,
        }

# LLM 출력 필터링 -- 민감 정보 유출 방지
import re

class LLMOutputFilter:
    """LLM 응답에서 민감 정보를 탐지하고 마스킹합니다."""

    SENSITIVE_PATTERNS = {
        "credit_card": r"\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b",
        "ssn": r"\b\d{3}-\d{2}-\d{4}\b",
        "email": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b",
        "api_key": r"\b(sk|pk|api)[-_][A-Za-z0-9]{20,}\b",
        "ip_address": r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b",
    }

    def filter_response(self, response_text):
        filtered = response_text
        detected = []
        for pattern_name, pattern in self.SENSITIVE_PATTERNS.items():
            matches = re.findall(pattern, filtered)
            if matches:
                detected.append({
                    "type": pattern_name,
                    "count": len(matches),
                })
                filtered = re.sub(pattern, f"[REDACTED_{pattern_name.upper()}]", filtered)
        return {
            "original_length": len(response_text),
            "filtered_text": filtered,
            "detections": detected,
            "was_filtered": len(detected) > 0,
        }

{
  "bomFormat": "CycloneDX",
  "specVersion": "1.5",
  "version": 1,
  "metadata": {
    "component": {
      "type": "application",
      "name": "my-web-app",
      "version": "2.1.0"
    }
  },
  "components": [
    {
      "type": "library",
      "name": "express",
      "version": "4.18.2",
      "purl": "pkg:npm/express@4.18.2",
      "licenses": [
        {
          "license": {
            "id": "MIT"
          }
        }
      ]
    },
    {
      "type": "library",
      "name": "lodash",
      "version": "4.17.21",
      "purl": "pkg:npm/lodash@4.17.21",
      "vulnerabilities": []
    }
  ]
}

# GitHub Actions -- 의존성 보안 스캔 워크플로우
name: Dependency Security Scan
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 6 * * 1'  # 매주 월요일 오전 6시

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

      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          scan-ref: '.'
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'

      - name: Upload Trivy scan results
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: 'trivy-results.sarif'

      - name: Generate SBOM
        uses: anchore/sbom-action@v0
        with:
          format: cyclonedx-json
          output-file: 'sbom.json'

      - name: Check for known vulnerabilities
        run: |
          npm audit --audit-level=high
          echo "Dependency audit completed"

## 개발자 보안 체크리스트 2026

### 코드 보안
- [ ] 시크릿(API 키, 토큰)이 코드에 하드코딩되지 않았는가
- [ ] 입력 값 검증(Input Validation)이 적용되었는가
- [ ] SQL 인젝션, XSS, CSRF 방어가 구현되었는가
- [ ] 최신 OWASP Top 10 취약점이 점검되었는가

### 의존성 관리
- [ ] npm audit / pip audit 결과가 깨끗한가
- [ ] SBOM이 생성되어 관리되고 있는가
- [ ] 사용하지 않는 의존성이 제거되었는가
- [ ] 라이선스 컴플라이언스가 확인되었는가

### 인증/인가
- [ ] MFA가 적용되었는가
- [ ] 최소 권한 원칙이 준수되었는가
- [ ] JWT 토큰 만료 시간이 적절한가
- [ ] 세션 관리가 안전하게 구현되었는가

### AI/LLM 보안
- [ ] 프롬프트 인젝션 방어가 적용되었는가
- [ ] LLM 출력 필터링이 구현되었는가
- [ ] AI 모델 접근 권한이 제한되었는가
- [ ] 학습 데이터 프라이버시가 보장되는가

## 보안 관리자 체크리스트 2026

### 인프라 보안
- [ ] 제로트러스트 아키텍처가 구현되었는가
- [ ] 네트워크 세그먼테이션이 적용되었는가
- [ ] 모든 엔드포인트에 EDR이 배포되었는가
- [ ] 클라우드 CSPM이 활성화되었는가

### 사고 대응
- [ ] 인시던트 대응 계획(IRP)이 최신화되었는가
- [ ] 백업 복구 테스트가 정기적으로 수행되는가
- [ ] SOC 팀의 24/7 모니터링이 운영되는가
- [ ] 포렌식 분석 도구가 준비되어 있는가

### 컴플라이언스
- [ ] ISMS-P 인증이 유지되고 있는가
- [ ] 개인정보 영향평가가 수행되었는가
- [ ] 양자 암호화 전환 로드맵이 수립되었는가
- [ ] 서드파티 보안 감사가 완료되었는가

### 교육/인식
- [ ] 전 직원 보안 인식 교육이 연 2회 이상 시행되는가
- [ ] 딥페이크/피싱 시뮬레이션이 분기별 수행되는가
- [ ] 보안 사고 신고 체계가 명확한가
- [ ] 개발팀 시큐어 코딩 교육이 시행되는가

+------------------------------------------------------------------+
|                    2026 Security Architecture                     |
+------------------------------------------------------------------+
|                                                                   |
|  [Identity Layer]                                                 |
|    - Zero Trust Identity (ZTNA)                                   |
|    - MFA + Biometrics                                             |
|    - Continuous Authentication                                    |
|                                                                   |
|  [Network Layer]                                                  |
|    - Micro-segmentation                                           |
|    - Encrypted Transit (mTLS)                                     |
|    - SASE / SSE                                                   |
|                                                                   |
|  [Application Layer]                                              |
|    - SAST / DAST / IAST                                           |
|    - SBOM + SCA                                                   |
|    - AI/LLM Security (Prompt Guard)                               |
|                                                                   |
|  [Data Layer]                                                     |
|    - PQC (Post-Quantum Cryptography)                              |
|    - DLP (Data Loss Prevention)                                   |
|    - Encryption at Rest + In Transit                              |
|                                                                   |
|  [Detection & Response]                                           |
|    - AI-SOC (SIEM + SOAR)                                         |
|    - EDR / XDR                                                    |
|    - Threat Intelligence                                          |
|                                                                   |
+------------------------------------------------------------------+