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に対して2つの異なるMACアドレス → ARPスプーフィング！

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トンネリングクエリ（異常に長いドメイン）
dGhpcyBpcyBhIHNlY3JldCBtZXNzYWdl.tunnel.evil.com（48文字）

# 異常長DNSクエリ検知
dns.qry.name.len > 50

# TXTレコードクエリ（トンネリングに頻繁に使用）
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サーバー] ←→ [Appサーバー] ←→ [DBサーバー]
  すべて同じVLAN、自由な通信

マイクロセグメンテーション:
  [Webサーバー] --ポリシー-→ [Appサーバー] --ポリシー-→ [DBサーバー]
  各通信に別個のセキュリティポリシー適用
  - 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インジェクション脆弱）:
// const query = `SELECT * FROM users WHERE id = ${userId}`;

// 正しい方法: パラメータ化クエリ
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に保存、ローテーション適用
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時間実践侵入テスト試験
  └── キャリアインパクト: シニアペンテスター、レッドチーム

Web開発者:
  Security+ → CEH → OSCP → Bug Bounty

クラウド開発者:
  Security+ → AWS Security Specialty → CCSP

DevOpsエンジニア:
  Security+ → CKS (Kubernetes Security) → OSCP