Wireshark와 네트워크 보안 완전 가이드: 패킷 스니핑부터 침투 탐지까지 개발자를 위한 실전 보안

전통적 접근:
  설계 → 개발 → 테스트 → [보안 테스트] → 배포
  ← 문제 발견 시 비용이 기하급수적으로 증가 →

Shift-Left:
  [보안 설계] → [보안 코딩] → [보안 테스트] → [보안 모니터링]
  ← 조기 발견으로 비용 절감 →

brew install --cask wireshark

sudo apt update
sudo apt install wireshark
sudo usermod -aG wireshark $USER
# 로그아웃 후 재로그인 필요

host 10.0.0.1
port 443
net 192.168.0.0/24
tcp and port 80
not arp

ip.addr == 10.0.0.1
tcp.port == 443
http.request.method == "GET"
dns.qry.name contains "google"

# TCP Stream 예시 (HTTP 요청/응답)
GET /api/users HTTP/1.1
Host: api.example.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
Accept: application/json

HTTP/1.1 200 OK
Content-Type: application/json
Set-Cookie: session=abc123; HttpOnly; Secure

[Response Body]

Source          Destination     Packets   Bytes
10.0.0.5        52.85.132.99    1,234     890KB
10.0.0.5        142.250.80.46   567       234KB
10.0.0.5        104.18.32.68    345       156KB

Ethernet (100%)
  ├── IPv4 (98.5%)
  │   ├── TCP (85.2%)
  │   │   ├── TLS (62.1%)
  │   │   ├── HTTP (15.3%)
  │   │   └── Other (7.8%)
  │   ├── UDP (12.8%)
  │   │   ├── DNS (8.2%)
  │   │   └── QUIC (4.6%)
  │   └── ICMP (0.5%)
  └── ARP (1.5%)

프로파일 예시:
  - Default: 일반 분석
  - Security: 보안 분석 (색상 규칙, 보안 관련 컬럼)
  - Performance: 성능 분석 (지연시간, 재전송 컬럼)
  - DNS: DNS 분석 전용

tcpdump [옵션] [BPF 필터 표현식]

-i eth0        # 인터페이스 지정
-w output.pcap # 파일로 저장
-r input.pcap  # 파일 읽기
-c 100         # 패킷 100개만 캡처
-n             # DNS 역조회 비활성화 (속도 향상)
-nn            # 포트 번호도 이름 변환 안 함
-v / -vv / -vvv  # 상세도 증가
-X             # Hex + ASCII 출력
-A             # ASCII만 출력
-s 0           # 전체 패킷 캡처 (기본: 262144 bytes)
-tttt          # 타임스탬프를 읽기 쉬운 형식으로

# 1. 서버에서 캡처
ssh user@server 'sudo tcpdump -i eth0 -c 5000 -w /tmp/capture.pcap port 443'

# 2. 로컬로 복사
scp user@server:/tmp/capture.pcap ./analysis/

# 3. Wireshark로 열기
wireshark ./analysis/capture.pcap

# 방법 1: ssh 파이프
ssh user@server 'sudo tcpdump -i eth0 -w - port 443' | wireshark -k -i -

# 방법 2: named pipe 사용
mkfifo /tmp/remote_capture
wireshark -k -i /tmp/remote_capture &
ssh user@server 'sudo tcpdump -i eth0 -w - port 443' > /tmp/remote_capture

# 방법 3: 특정 기간만 캡처
ssh user@server 'sudo timeout 60 tcpdump -i eth0 -w - port 80' | wireshark -k -i -

Step 1: SYN (클라이언트 → 서버)
  Source: 10.0.0.5:54321
  Dest:   93.184.216.34:443
  Flags:  [SYN]
  Seq:    0 (ISN: Initial Sequence Number)
  Win:    65535
  Options: MSS=1460, SACK Permitted, Window Scale=6

Step 2: SYN-ACK (서버 → 클라이언트)
  Source: 93.184.216.34:443
  Dest:   10.0.0.5:54321
  Flags:  [SYN, ACK]
  Seq:    0 (서버의 ISN)
  Ack:    1 (클라이언트 ISN + 1)
  Win:    65535
  Options: MSS=1400, SACK Permitted, Window Scale=7

Step 3: ACK (클라이언트 → 서버)
  Source: 10.0.0.5:54321
  Dest:   93.184.216.34:443
  Flags:  [ACK]
  Seq:    1
  Ack:    1
  Win:    65535

# HTTP 요청 패킷 상세
Frame 45: 342 bytes on wire
  Ethernet II: Src=aa:bb:cc:dd:ee:ff, Dst=11:22:33:44:55:66
  Internet Protocol Version 4: Src=10.0.0.5, Dst=93.184.216.34
  Transmission Control Protocol: Src Port=54321, Dst Port=80
  Hypertext Transfer Protocol:
    GET /api/v1/users?page=1 HTTP/1.1
    Host: api.example.com
    User-Agent: Mozilla/5.0 ...
    Accept: application/json
    Authorization: Bearer eyJhbGci...
    Cookie: session_id=abc123
    Connection: keep-alive

# HTTP 응답 패킷 상세
Frame 47: 1280 bytes on wire
  Hypertext Transfer Protocol:
    HTTP/1.1 200 OK
    Content-Type: application/json; charset=utf-8
    Content-Length: 956
    Set-Cookie: session_id=xyz789; HttpOnly; Secure; SameSite=Strict
    X-Request-Id: req_abc123
    Strict-Transport-Security: max-age=31536000
    X-Content-Type-Options: nosniff

# DNS 질의 (Query)
Domain Name System (query)
  Transaction ID: 0x1a2b
  Flags: 0x0100 Standard query
  Questions: 1
  Queries:
    api.example.com: type A, class IN

# DNS 응답 (Response)
Domain Name System (response)
  Transaction ID: 0x1a2b
  Flags: 0x8180 Standard query response, No error
  Questions: 1
  Answer RRs: 2
  Answers:
    api.example.com: type A, class IN, addr 93.184.216.34
      TTL: 300 (5 minutes)
    api.example.com: type A, class IN, addr 93.184.216.35
      TTL: 300 (5 minutes)

Step 1: Client Hello
  TLS Record Layer:
    Content Type: Handshake (22)
    Version: TLS 1.0 (호환성)
  Handshake Protocol: Client Hello
    Version: TLS 1.2 (호환성을 위해)
    Random: [32 bytes]
    Session ID: [32 bytes]
    Cipher Suites (17 suites):
      TLS_AES_256_GCM_SHA384
      TLS_AES_128_GCM_SHA256
      TLS_CHACHA20_POLY1305_SHA256
    Extensions:
      server_name: api.example.com  (SNI)
      supported_versions: TLS 1.3
      key_share: x25519 [public key]
      signature_algorithms: ecdsa_secp256r1_sha256, rsa_pss_rsae_sha256

Step 2: Server Hello + Certificate + Finished
  Handshake Protocol: Server Hello
    Cipher Suite: TLS_AES_256_GCM_SHA384
    Key Share: x25519 [server public key]
  [Encrypted Extensions]
  [Certificate]
  [Certificate Verify]
  [Finished]

Step 3: Client Finished (Encrypted)
  [Change Cipher Spec]
  [Finished]

# 1. 환경변수 설정 (bash)
export SSLKEYLOGFILE="$HOME/.ssl-keys.log"

# 2. Chrome 또는 Firefox 실행 (이 환경변수를 자동으로 인식)
# 브라우저가 TLS 세션 키를 파일에 기록합니다

# 3. curl에서도 사용 가능
SSLKEYLOGFILE=$HOME/.ssl-keys.log curl https://api.example.com/health

Who has 10.0.0.1? Tell 10.0.0.5
  → 10.0.0.1 is at aa:bb:cc:dd:ee:ff

# 공격자가 게이트웨이(10.0.0.1)를 사칭
10.0.0.1 is at [공격자 MAC: 11:22:33:44:55:66]  ← 비정상!
10.0.0.1 is at [실제 MAC: aa:bb:cc:dd:ee:ff]     ← 정상

# 같은 IP에 대해 두 개의 다른 MAC 주소 → ARP Spoofing!

arp.duplicate-address-detected
arp.duplicate-address-frame

#!/bin/bash
# ARP 테이블 모니터링
while true; do
    arp -a | sort > /tmp/arp_current.txt
    if [ -f /tmp/arp_previous.txt ]; then
        diff /tmp/arp_previous.txt /tmp/arp_current.txt
        if [ $? -ne 0 ]; then
            echo "[ALERT] ARP table changed at $(date)"
            diff /tmp/arp_previous.txt /tmp/arp_current.txt
        fi
    fi
    cp /tmp/arp_current.txt /tmp/arp_previous.txt
    sleep 10
done

공격자 → 대상:22  [SYN]
대상:22 → 공격자  [SYN,ACK]  ← 포트 열림
공격자 → 대상:22  [RST]       ← 연결 완료 안 함

공격자 → 대상:23  [SYN]
대상:23 → 공격자  [RST,ACK]  ← 포트 닫힘

# SYN 스캔 탐지 (ACK 없는 SYN만)
tcp.flags.syn == 1 and tcp.flags.ack == 0

# 짧은 시간에 다수의 포트로 SYN
tcp.flags.syn == 1 and tcp.flags.ack == 0 and ip.src == 10.0.0.100

# 대량의 SYN 패킷이 다양한 소스 IP에서 동시에 유입
# Wireshark 필터
tcp.flags.syn == 1 and tcp.flags.ack == 0

# tcpdump로 SYN 패킷 카운트
sudo tcpdump -i eth0 'tcp[tcpflags] & tcp-syn != 0' -c 10000 2>&1 | tail -1
# 결과: "10000 packets captured" 가 수 초 만에 나오면 SYN Flood 의심

# 동일 URL에 대한 대량 요청
# Wireshark 필터
http.request.uri == "/api/login"

# 초당 요청 수 확인
# Statistics > I/O Graph에서 http.request를 Y축으로 설정

# DNS 응답이 쿼리보다 훨씬 큰 경우 (증폭 비율)
# 작은 쿼리 (약 60 bytes) → 큰 응답 (약 3000+ bytes)

# Wireshark 필터
dns.response and frame.len > 1000

# 증폭 비율 = 응답 크기 / 요청 크기
# ANY 쿼리의 증폭 비율: 약 28x ~ 54x

# Wireshark Display Filter
http.request.method == "POST" and (
  http contains "UNION" or
  http contains "SELECT" or
  http contains "DROP" or
  http contains "DELETE" or
  http contains "1=1" or
  http contains "OR 1" or
  http contains "--" or
  http contains "/*"
)

POST /api/login HTTP/1.1
Host: vulnerable-app.com
Content-Type: application/x-www-form-urlencoded

username=admin' OR '1'='1&password=anything

# 비정상 응답 크기 탐지
http.response and http.content_length > 10000

# 정상 DNS 쿼리
api.example.com (15자)

# DNS Tunneling 쿼리 (비정상적으로 긴 도메인)
dGhpcyBpcyBhIHNlY3JldCBtZXNzYWdl.tunnel.evil.com (48자)

# 비정상 길이 DNS 쿼리 탐지
dns.qry.name.len > 50

# TXT 레코드 쿼리 (tunneling에 자주 사용)
dns.qry.type == 16

# 특정 도메인에 대한 비정상 많은 쿼리
dns.qry.name contains "tunnel.evil.com"

# tcpdump로 대용량 아웃바운드 모니터링
sudo tcpdump -i eth0 'src net 10.0.0.0/8 and dst net not 10.0.0.0/8 and greater 10000' -c 100

# 비정상 포트로의 아웃바운드
sudo tcpdump -i eth0 'src net 10.0.0.0/8 and not (dst port 80 or dst port 443 or dst port 53 or dst port 22)'

# 기본 포트 스캔
nmap 192.168.1.1

# 서비스 버전 탐지
nmap -sV 192.168.1.1

# OS 탐지
nmap -O 192.168.1.1

# 공격적 스캔 (서비스, OS, 스크립트, traceroute)
nmap -A 192.168.1.1

# 전체 포트 스캔
nmap -p- 192.168.1.1

# NSE 스크립트 활용
nmap --script vuln 192.168.1.1
nmap --script ssl-heartbleed 192.168.1.1
nmap --script http-sql-injection 192.168.1.1

# Docker로 빠른 스캔
docker run -t zaproxy/zap-stable zap-baseline.py -t https://target.com

# API 스캔
docker run -t zaproxy/zap-stable zap-api-scan.py -t https://target.com/openapi.json -f openapi

# 전체 스캔
docker run -t zaproxy/zap-stable zap-full-scan.py -t https://target.com

# Suricata 설치 (Ubuntu)
sudo apt install suricata

# 규칙 업데이트
sudo suricata-update

# IDS 모드로 실행
sudo suricata -c /etc/suricata/suricata.yaml -i eth0

# 커스텀 규칙 예시
# /etc/suricata/rules/local.rules
# alert http any any -> any any (msg:"SQL Injection Attempt"; content:"UNION SELECT"; nocase; sid:1000001; rev:1;)
# alert dns any any -> any any (msg:"DNS Tunneling Suspected"; dns.query; content:".tunnel."; nocase; sid:1000002; rev:1;)

# Metasploit 시작
msfconsole

# 취약점 검색
# msf6> search type:exploit platform:linux apache

# 모듈 사용 예시
# msf6> use exploit/multi/http/apache_log4j
# msf6> set RHOSTS target.com
# msf6> set RPORT 8080
# msf6> run

전통적 모델:
  [인터넷] --방화벽-- [내부 네트워크: 모두 신뢰]
  → 내부 침투 시 횡적 이동(Lateral Movement) 자유

제로 트러스트:
  [모든 요청] --인증/인가-- [리소스]
  → 모든 접근마다 검증 (위치 무관)

전통적 네트워크:
  [Web Server] ←→ [App Server] ←→ [DB Server]
  모두 같은 VLAN, 자유로운 통신

마이크로 세그먼테이션:
  [Web Server] --정책-→ [App Server] --정책-→ [DB Server]
  각 통신에 별도 보안 정책 적용
  - Web → App: 포트 8080만 허용
  - App → DB: 포트 5432만 허용
  - Web → DB: 차단

일반 TLS:
  Client → Server: "당신이 진짜 서버인지 인증서로 증명해주세요"
  Server → Client: [서버 인증서 제시]
  → 클라이언트는 검증하지 않음

mTLS:
  Client → Server: "당신이 진짜 서버인지 증명해주세요"
  Server → Client: [서버 인증서] + "당신도 증명해주세요"
  Client → Server: [클라이언트 인증서]
  → 양방향 인증 완료

const https = require('https')
const fs = require('fs')

const options = {
  key: fs.readFileSync('server-key.pem'),
  cert: fs.readFileSync('server-cert.pem'),
  ca: fs.readFileSync('ca-cert.pem'), // CA 인증서
  requestCert: true, // 클라이언트 인증서 요구
  rejectUnauthorized: true, // 유효하지 않은 인증서 거부
}

const server = https.createServer(options, (req, res) => {
  const clientCert = req.socket.getPeerCertificate()
  console.log('Client CN:', clientCert.subject.CN)
  res.writeHead(200)
  res.end('Mutual TLS authenticated!\n')
})

server.listen(443)

# Istio PeerAuthentication - mTLS 강제
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: production
spec:
  mtls:
    mode: STRICT # mTLS 필수

---
# Istio AuthorizationPolicy - 세밀한 접근 제어
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: api-access
  namespace: production
spec:
  selector:
    matchLabels:
      app: api-server
  rules:
    - from:
        - source:
            principals: ['cluster.local/ns/production/sa/frontend']
      to:
        - operation:
            methods: ['GET', 'POST']
            paths: ['/api/v1/*']

# Kubernetes NetworkPolicy - Pod 간 통신 제어
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-network-policy
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: api-server
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: database
      ports:
        - protocol: TCP
          port: 5432
    - to: # DNS 허용
        - namespaceSelector: {}
      ports:
        - protocol: UDP
          port: 53

---
# Pod Security Standards
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 2000
    seccompProfile:
      type: RuntimeDefault
  containers:
    - name: app
      image: myapp:latest
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
            - ALL
      resources:
        limits:
          memory: '256Mi'
          cpu: '500m'

# Nginx 설정
server {
    listen 80;
    server_name example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    # HSTS 헤더 (2년, 서브도메인 포함, preload)
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;

    # TLS 설정
    ssl_protocols TLSv1.3 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
}

// Express.js - 안전한 CORS 설정
const cors = require('cors')

const corsOptions = {
  origin: ['https://app.example.com', 'https://admin.example.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,
  maxAge: 86400, // Preflight 캐시 24시간
}

app.use(cors(corsOptions))

// 절대 이렇게 하지 마세요:
// app.use(cors());  // 모든 오리진 허용 = 보안 취약

// Express.js - Rate Limiting
const rateLimit = require('express-rate-limit')

// 일반 API
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100 요청
  message: 'Too many requests, please try again later.',
  standardHeaders: true,
  legacyHeaders: false,
})

// 로그인 엔드포인트 (더 엄격)
const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 5,
  message: 'Too many login attempts, please try again after 15 minutes.',
})

app.use('/api/', apiLimiter)
app.use('/api/login', loginLimiter)

// Joi를 사용한 입력 검증
const Joi = require('joi')

const userSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  email: Joi.string().email().required(),
  password: Joi.string()
    .min(12)
    .pattern(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])/)
    .required(),
  age: Joi.number().integer().min(13).max(120),
})

app.post('/api/register', (req, res) => {
  const result = userSchema.validate(req.body)
  if (result.error) {
    return res.status(400).json({
      error: result.error.details[0].message,
    })
  }
  // 검증 통과 후 처리
})

// Node.js + PostgreSQL - 안전한 쿼리
const { Pool } = require('pg')
const pool = new Pool()

// 절대 하지 마세요 (SQL Injection 취약):
// const query = `SELECT * FROM users WHERE id = ${userId}`;

// 올바른 방법: Parameterized Query
async function getUser(userId) {
  const result = await pool.query('SELECT id, username, email FROM users WHERE id = $1', [userId])
  return result.rows[0]
}

// ORM 사용 (Prisma)
async function getUserPrisma(userId) {
  return await prisma.user.findUnique({
    where: { id: userId },
    select: { id: true, username: true, email: true },
  })
}

// JWT 보안 모범 사례
const jwt = require('jsonwebtoken')

// Access Token: 짧은 만료 시간
const accessToken = jwt.sign({ userId: user.id, role: user.role }, process.env.JWT_SECRET, {
  expiresIn: '15m', // 15분
  algorithm: 'RS256', // RSA 비대칭 키 사용
  issuer: 'api.example.com',
  audience: 'app.example.com',
})

// Refresh Token: DB에 저장, 회전(Rotation) 적용
const refreshToken = jwt.sign(
  { userId: user.id, tokenVersion: user.tokenVersion },
  process.env.REFRESH_SECRET,
  { expiresIn: '7d' }
)

// 검증 미들웨어
function verifyToken(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1]
  if (!token) return res.status(401).json({ error: 'No token' })

  try {
    const decoded = jwt.verify(token, process.env.JWT_PUBLIC_KEY, {
      algorithms: ['RS256'],
      issuer: 'api.example.com',
      audience: 'app.example.com',
    })
    req.user = decoded
    next()
  } catch (err) {
    return res.status(401).json({ error: 'Invalid token' })
  }
}

# HashiCorp Vault 사용 예시
vault kv put secret/myapp/db \
  username="dbuser" \
  password="supersecret" \
  host="db.internal.example.com"

# 애플리케이션에서 읽기
vault kv get -field=password secret/myapp/db

// AWS Secrets Manager
const { SecretsManagerClient, GetSecretValueCommand } = require('@aws-sdk/client-secrets-manager')

async function getSecret(secretName) {
  const client = new SecretsManagerClient({ region: 'us-east-1' })
  const response = await client.send(new GetSecretValueCommand({ SecretId: secretName }))
  return JSON.parse(response.SecretString)
}

// 사용
const dbCreds = await getSecret('production/database')

// Helmet.js로 보안 헤더 설정
const helmet = require('helmet')

app.use(
  helmet({
    contentSecurityPolicy: {
      directives: {
        defaultSrc: ["'self'"],
        scriptSrc: ["'self'"],
        styleSrc: ["'self'", "'unsafe-inline'"],
        imgSrc: ["'self'", 'data:', 'https:'],
        connectSrc: ["'self'", 'https://api.example.com'],
        fontSrc: ["'self'", 'https://fonts.gstatic.com'],
        objectSrc: ["'none'"],
        mediaSrc: ["'none'"],
        frameSrc: ["'none'"],
      },
    },
    crossOriginEmbedderPolicy: true,
    crossOriginOpenerPolicy: true,
    crossOriginResourcePolicy: { policy: 'same-site' },
    hsts: { maxAge: 63072000, includeSubDomains: true, preload: true },
    noSniff: true, // X-Content-Type-Options: nosniff
    referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
    xssFilter: true, // X-XSS-Protection
  })
)

# npm audit
npm audit
npm audit fix

# Snyk
npx snyk test
npx snyk monitor

# GitHub Dependabot (자동 PR 생성)
# .github/dependabot.yml

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

입문 (0~1년차):
  CompTIA Security+
  ├── 난이도: ★★☆☆☆
  ├── 비용: 약 $404 (시험비)
  ├── 준비 기간: 2~3개월
  ├── 내용: 보안 기초, 위협, 암호화, 네트워크 보안
  └── 커리어 임팩트: IT 보안 입문, 정부/군 분야 필수

중급 (1~3년차):
  CEH (Certified Ethical Hacker)
  ├── 난이도: ★★★☆☆
  ├── 비용: 약 $1,199 (시험비)
  ├── 준비 기간: 3~4개월
  ├── 내용: 해킹 기법, 취약점 분석, 침투 테스트
  └── 커리어 임팩트: 보안 분석가, 펜테스터

  CISSP (보안 관리자 경로)
  ├── 난이도: ★★★★☆
  ├── 비용: 약 $749 (시험비)
  ├── 준비 기간: 4~6개월 (경력 5년 필요)
  ├── 내용: 보안 관리, 거버넌스, 리스크 관리
  └── 커리어 임팩트: CISO, 보안 아키텍트

고급 (3년차+):
  OSCP (Offensive Security Certified Professional)
  ├── 난이도: ★★★★★
  ├── 비용: 약 $1,649 (교육 + 시험)
  ├── 준비 기간: 6~12개월
  ├── 내용: 24시간 실전 침투 테스트 시험
  └── 커리어 임팩트: 시니어 펜테스터, 레드팀

웹 개발자:
  Security+ → CEH → OSCP → Bug Bounty

클라우드 개발자:
  Security+ → AWS Security Specialty → CCSP

DevOps 엔지니어:
  Security+ → CKS (Kubernetes Security) → OSCP