在現代網路環境中，安全威脅日益複雜多變，傳統的防護手段已難以應對新型態的攻擊模式。Scapy 作為一套功能強大的 Python 網路封包處理函式庫，提供了靈活的底層封包操作能力，讓安全研究人員與網路管理者能夠深入網路通訊的核心層級，進行精確的安全測試與威脅分析。本文將系統性地探討 Scapy 在網路安全測試領域的實戰應用，從 ARP 欺騙偵測到封包混淆技術，展示如何運用這個工具建構完整的網路安全防護體系。
Scapy 網路安全測試工具的核心架構
Scapy 作為一個專為網路封包操作設計的 Python 函式庫，其核心優勢在於提供了直接操作網路協定堆疊的能力。相較於傳統的網路工具，Scapy 允許使用者以程式化的方式建立、修改、傳送與接收任意格式的網路封包，這種靈活性使其成為網路安全測試、協定分析與漏洞研究的理想工具。
封包操作的基礎原理
Scapy 的設計理念建立在對網路協定層次化結構的深刻理解之上，它將每個網路協定視為可獨立操作的物件，透過層疊組合的方式構建完整的網路封包。這種設計使得使用者能夠精確控制封包的每個欄位，從乙太網路框架的 MAC 位址到傳輸層的連接埠號碼，都可以根據測試需求進行客製化設定。
在實際應用中，Scapy 能夠處理各種網路層級的協定，包含第二層的乙太網路協定、第三層的 IP 協定、第四層的 TCP 與 UDP 協定，以及更高層的應用層協定。這種全面的協定支援能力，使得 Scapy 能夠模擬各種複雜的網路通訊場景，為安全測試提供了完整的工具基礎。
ARP 欺騙偵測機制的實作技術
ARP 協定作為區域網路中實現 IP 位址與 MAC 位址對應的關鍵機制，其安全性直接影響整個網路的通訊安全。ARP 欺騙攻擊透過發送偽造的 ARP 回應封包，誤導網路裝置將流量導向攻擊者控制的主機，從而實現中間人攻擊或網路監聽。建立有效的 ARP 欺騙偵測機制，是維護網路安全的重要防線。
ARP 欺騙攻擊的運作原理
在正常的 ARP 通訊流程中，當主機需要與區域網路中的另一台裝置通訊時，會廣播 ARP 請求封包詢問目標 IP 位址對應的 MAC 位址。目標主機收到請求後，會回傳包含其 MAC 位址的 ARP 回應封包。然而，ARP 協定本身缺乏身份驗證機制，任何主機都可以發送 ARP 回應封包，即使該主機並非被詢問的目標。
攻擊者利用這個協定漏洞，持續發送偽造的 ARP 回應封包，宣稱自己擁有其他主機的 IP 位址。網路中的裝置收到這些偽造封包後，會更新自己的 ARP 快取表，將原本指向合法主機的 MAC 位址映射改為指向攻擊者的 MAC 位址。這樣一來，所有原本應該傳送給合法主機的網路流量，都會被導向攻擊者的裝置。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ARP 欺騙偵測系統實作
功能：監聽網路中的 ARP 流量，偵測可能的欺騙攻擊行為
原理：透過驗證 ARP 回應的真實性來判斷是否存在攻擊
"""
from scapy.all import sniff, ARP, Ether, srp, conf
import time
from collections import defaultdict
class ARPSpoofDetector:
"""ARP 欺騙偵測類別，提供完整的攻擊偵測功能"""
def __init__(self, interface='eth0', alert_threshold=3):
"""
初始化偵測器
參數：
interface: 監聽的網路介面名稱
alert_threshold: 觸發告警的可疑事件閾值
"""
self.interface = interface
self.alert_threshold = alert_threshold
# 使用字典記錄 IP 與 MAC 的正常對應關係
self.arp_table = {}
# 記錄可疑活動的計數器
self.suspicious_activity = defaultdict(int)
# 停用 Scapy 的詳細輸出訊息
conf.verb = 0
def build_arp_table(self):
"""
建立初始的 ARP 對應表
透過主動掃描網段來建立基準線，用於後續的異常比對
"""
print(f"[*] 正在建立 {self.interface} 的 ARP 對應表...")
# 建構 ARP 請求封包，詢問整個 /24 網段的主機
# 使用乙太網路廣播位址確保所有裝置都能收到請求
arp_request = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(pdst="192.168.1.0/24")
# 發送 ARP 請求並接收回應
# timeout 參數設定等待回應的時間限制
answered, unanswered = srp(arp_request, timeout=2, iface=self.interface)
# 處理收到的回應，建立 IP 與 MAC 的對應關係
for sent, received in answered:
ip = received[ARP].psrc # 來源 IP 位址
mac = received[ARP].hwsrc # 來源 MAC 位址
self.arp_table[ip] = mac
print(f"[+] 發現主機：{ip} -> {mac}")
print(f"[*] ARP 對應表建立完成，共發現 {len(self.arp_table)} 台主機")
def verify_arp_response(self, packet):
"""
驗證 ARP 回應封包的真實性
參數：
packet: 接收到的 ARP 封包
返回：
True 表示封包可疑，False 表示封包正常
"""
# 檢查封包是否為 ARP 回應（op=2 表示 ARP 回應）
if packet[ARP].op != 2:
return False
source_ip = packet[ARP].psrc # 回應封包聲稱的 IP 位址
source_mac = packet[ARP].hwsrc # 回應封包的 MAC 位址
# 檢查這個 IP 是否在我們的已知對應表中
if source_ip in self.arp_table:
# 比對 MAC 位址是否與記錄相符
if self.arp_table[source_ip] != source_mac:
# MAC 位址不符，可能是欺騙攻擊
print(f"[!] 偵測到 ARP 異常：")
print(f" IP: {source_ip}")
print(f" 預期 MAC: {self.arp_table[source_ip]}")
print(f" 實際 MAC: {source_mac}")
return True
else:
# 發現新的主機，更新對應表
self.arp_table[source_ip] = source_mac
print(f"[+] 新增主機記錄：{source_ip} -> {source_mac}")
return False
def packet_handler(self, packet):
"""
封包處理回呼函式，處理每個捕獲的 ARP 封包
參數：
packet: Scapy 捕獲的封包物件
"""
# 確認封包包含 ARP 層
if ARP not in packet:
return
# 驗證封包是否可疑
if self.verify_arp_response(packet):
source_ip = packet[ARP].psrc
# 累計可疑活動計數
self.suspicious_activity[source_ip] += 1
# 檢查是否達到告警閾值
if self.suspicious_activity[source_ip] >= self.alert_threshold:
print(f"[!!!] 嚴重告警：偵測到持續的 ARP 欺騙攻擊")
print(f" 攻擊來源：{source_ip}")
print(f" 可疑事件數：{self.suspicious_activity[source_ip]}")
# 在實際應用中，這裡可以觸發自動化防禦措施
# 例如：封鎖攻擊來源、發送管理員通知等
def start_monitoring(self):
"""
啟動 ARP 監聽服務
持續監聽網路介面上的 ARP 流量，偵測潛在的攻擊行為
"""
print(f"[*] 開始監聽 {self.interface} 的 ARP 流量...")
print("[*] 按 Ctrl+C 停止監聽")
try:
# 使用 Scapy 的 sniff 函式捕獲封包
# filter 參數指定只捕獲 ARP 封包，減少處理負擔
# prn 參數指定封包處理函式
# store 設為 False 避免記憶體累積過多封包
sniff(
iface=self.interface,
filter="arp",
prn=self.packet_handler,
store=False
)
except KeyboardInterrupt:
print("\n[*] 停止監聽")
self.print_statistics()
def print_statistics(self):
"""印出偵測統計資訊"""
print("\n[*] 偵測統計摘要：")
print(f" 已知主機數量：{len(self.arp_table)}")
print(f" 可疑 IP 數量：{len(self.suspicious_activity)}")
if self.suspicious_activity:
print("\n[*] 可疑活動詳情：")
for ip, count in self.suspicious_activity.items():
print(f" {ip}: {count} 次可疑事件")
# 程式進入點
if __name__ == "__main__":
# 建立偵測器實例，指定監聽介面與告警閾值
detector = ARPSpoofDetector(interface='eth0', alert_threshold=3)
# 建立初始的 ARP 對應表作為比對基準
detector.build_arp_table()
# 啟動持續監聽
detector.start_monitoring()
這個 ARP 欺騙偵測系統採用主動驗證的策略，首先透過掃描網段建立正常的 IP 與 MAC 對應關係作為基準線，接著持續監聽網路上的 ARP 流量。當偵測到 ARP 回應的 MAC 位址與已知記錄不符時，系統會發出告警並累計可疑活動計數。這種方法能夠有效識別 ARP 欺騙攻擊的早期徵兆，為管理員提供及時的威脅情報。
封包混淆技術在網路穩定性測試中的應用
網路系統的健壯性測試需要模擬各種異常情況，包含資料損壞、封包亂序、延遲抖動等真實網路環境中可能遇到的問題。封包混淆技術透過有意地修改封包內容或傳輸特性，能夠有效驗證系統對異常狀況的處理能力，這對於開發高可靠性的網路應用至關重要。
封包內容損壞模擬技術
在網路傳輸過程中，實體層的干擾、硬體故障或軟體錯誤都可能導致資料損壞。雖然現代網路協定通常具備錯誤檢測與重傳機制，但測試應用程式在面對損壞資料時的行為仍然非常重要。透過主動注入隨機錯誤，可以驗證應用程式的錯誤處理邏輯是否完善，以及在極端情況下是否能夠優雅地降級或恢復。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
網路封包混淆測試工具
功能：模擬網路傳輸中的各種異常情況，測試系統健壯性
包含：資料損壞、封包延遲、順序打亂等多種混淆模式
"""
from scapy.all import IP, TCP, UDP, Raw, send, fragment
import random
import time
class PacketCorruptor:
"""封包混淆器類別，提供多種封包異常模擬功能"""
def __init__(self, corruption_rate=0.1):
"""
初始化混淆器
參數：
corruption_rate: 損壞率，範圍 0.0 到 1.0
0.1 表示損壞 10% 的位元組
"""
self.corruption_rate = corruption_rate
def corrupt_data(self, data):
"""
損壞封包的資料內容
透過隨機修改位元組值來模擬資料傳輸錯誤
參數：
data: 原始資料（bytes 型別）
返回：
損壞後的資料
"""
if not data:
return data
# 轉換為可變的位元組陣列
data_array = bytearray(data)
data_length = len(data_array)
# 計算要損壞的位元組數量
num_bytes_to_corrupt = max(1, int(data_length * self.corruption_rate))
print(f"[*] 原始資料長度：{data_length} 位元組")
print(f"[*] 將損壞 {num_bytes_to_corrupt} 個位元組")
# 隨機選擇要損壞的位置
corrupt_positions = random.sample(range(data_length), num_bytes_to_corrupt)
# 修改選定位置的位元組值
for pos in corrupt_positions:
original_value = data_array[pos]
# 產生不同於原值的隨機位元組
new_value = random.randint(0, 255)
while new_value == original_value:
new_value = random.randint(0, 255)
data_array[pos] = new_value
print(f"[+] 位置 {pos}: 0x{original_value:02x} -> 0x{new_value:02x}")
return bytes(data_array)
def corrupt_packet(self, packet):
"""
損壞完整的網路封包
參數：
packet: Scapy 封包物件
返回：
損壞後的封包
"""
# 檢查封包是否包含應用層資料
if Raw not in packet:
print("[!] 封包不包含資料層，無法進行損壞")
return packet
print(f"[*] 處理封包：{packet.summary()}")
# 取得原始資料並進行損壞
original_data = packet[Raw].load
corrupted_data = self.corrupt_data(original_data)
# 更新封包的資料內容
packet[Raw].load = corrupted_data
# 刪除校驗和，讓網路堆疊重新計算
# 這確保損壞只發生在資料層，傳輸層校驗和會反映新的資料
if TCP in packet:
del packet[TCP].chksum
elif UDP in packet:
del packet[UDP].chksum
if IP in packet:
del packet[IP].chksum
return packet
def add_delay(self, packet, min_delay=0.1, max_delay=0.5):
"""
為封包傳送新增隨機延遲
模擬網路延遲或抖動情況
參數：
packet: 要傳送的封包
min_delay: 最小延遲時間（秒）
max_delay: 最大延遲時間（秒）
"""
delay = random.uniform(min_delay, max_delay)
print(f"[*] 新增 {delay:.3f} 秒延遲")
time.sleep(delay)
send(packet, verbose=0)
def fragment_packet(self, packet, fragment_size=8):
"""
將封包分片傳送
測試接收端的分片重組能力
參數：
packet: 要分片的封包
fragment_size: 每個分片的大小（位元組）
返回：
分片後的封包清單
"""
if IP not in packet:
print("[!] 只能分片 IP 封包")
return [packet]
# 使用 Scapy 的分片功能
fragments = fragment(packet, fragsize=fragment_size)
print(f"[*] 封包已分片為 {len(fragments)} 個片段")
return fragments
def send_out_of_order(self, packets):
"""
亂序傳送封包序列
測試接收端的重排序能力
參數：
packets: 封包清單
"""
print(f"[*] 將亂序傳送 {len(packets)} 個封包")
# 打亂封包順序
shuffled_packets = list(packets)
random.shuffle(shuffled_packets)
# 依序傳送打亂後的封包
for i, packet in enumerate(shuffled_packets):
print(f"[+] 傳送第 {i+1} 個封包")
send(packet, verbose=0)
# 短暫延遲確保封包依序到達網路堆疊
time.sleep(0.01)
# 使用範例
def test_corruption():
"""測試封包損壞功能"""
print("=== 封包損壞測試 ===\n")
# 建立測試封包
test_data = "Hello, this is a test message for corruption testing!"
packet = IP(dst="192.168.1.100") / TCP(dport=80) / Raw(load=test_data)
# 建立混淆器實例
corruptor = PacketCorruptor(corruption_rate=0.2)
# 損壞封包
corrupted_packet = corruptor.corrupt_packet(packet)
print("\n[*] 原始資料：", test_data)
print("[*] 損壞後資料：", corrupted_packet[Raw].load.decode('utf-8', errors='replace'))
# 傳送損壞的封包
print("\n[*] 傳送損壞的封包...")
send(corrupted_packet, verbose=0)
def test_fragmentation():
"""測試封包分片功能"""
print("\n=== 封包分片測試 ===\n")
# 建立較大的測試封包
large_data = "X" * 100 # 100 位元組的資料
packet = IP(dst="192.168.1.100") / TCP(dport=80) / Raw(load=large_data)
corruptor = PacketCorruptor()
# 分片封包
fragments = corruptor.fragment_packet(packet, fragment_size=20)
# 亂序傳送分片
corruptor.send_out_of_order(fragments)
if __name__ == "__main__":
# 執行測試
test_corruption()
test_fragmentation()
這個封包混淆工具提供了多種測試模式，包含資料損壞、延遲注入、封包分片與亂序傳送。透過這些功能，可以全面測試網路應用在各種異常情況下的表現，確保系統具備足夠的容錯能力與錯誤恢復機制。
多層次網路安全防護架構設計
建構完善的網路安全防護體系需要採用縱深防禦策略，結合多種安全技術與機制，在不同層級提供保護。這種多層次的防護架構能夠確保即使某一層防線被突破，其他層級仍能提供保護，大幅提升整體系統的安全性。
防護架構的層次化設計
現代網路安全架構通常包含邊界防護層、流量檢測層、應用防護層與資料保護層。邊界防護層部署在網路出入口，透過防火牆與存取控制清單過濾進出流量。流量檢測層使用入侵檢測系統與流量分析工具，識別異常行為模式。應用防護層在應用程式層級實施安全控制，包含身份驗證、授權管理與輸入驗證。資料保護層則確保敏感資料的加密儲存與安全傳輸。
@startuml
!define PLANTUML_FORMAT svg
!theme _none_
skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 16
skinparam minClassWidth 100
package "網路安全防護架構" {
rectangle "外部網路" as External
rectangle "邊界防護層" as Border {
component "防火牆系統" as Firewall
component "DDoS 防護" as DDoS
}
rectangle "流量檢測層" as Detection {
component "入侵檢測系統\n(IDS)" as IDS
component "流量分析引擎" as Traffic
}
rectangle "應用防護層" as Application {
component "Web 應用防火牆\n(WAF)" as WAF
component "身份認證系統" as Auth
}
rectangle "內部網路" as Internal
rectangle "監控告警中心" as Monitor
}
External -down-> Firewall : 入站流量
Firewall -down-> DDoS : DDoS 過濾
DDoS -down-> IDS : 清洗後流量
IDS -down-> Traffic : 異常偵測
Traffic -down-> WAF : 合法流量
WAF -down-> Auth : 應用層防護
Auth -down-> Internal : 授權流量
IDS -right-> Monitor : 告警通知
Traffic -right-> Monitor : 威脅情報
WAF -right-> Monitor : 攻擊記錄
note right of Border
邊界防護功能：
封包過濾規則
連線狀態追蹤
流量速率限制
DDoS 攻擊緩解
end note
note right of Detection
檢測層功能：
異常行為識別
簽章比對分析
流量模式學習
威脅情報關聯
end note
@enduml這個架構展示了完整的防護流程，外部流量首先經過邊界防護層的防火牆系統，過濾明顯的惡意流量。接著進入流量檢測層，透過入侵檢測系統與流量分析引擎識別可疑行為。通過檢測的流量再經過應用防護層的深度檢查，最終到達內部網路。整個過程中，各層的安全事件都會匯總到監控告警中心，提供統一的威脅可見性。
QoS 流量控制與網路效能最佳化
在確保網路安全的同時，也必須兼顧網路效能與服務品質。過度嚴格的安全控制可能導致合法流量受到影響，降低使用者體驗。透過實施服務品質控制機制，可以在維持安全防護的前提下，確保關鍵應用獲得足夠的網路資源。
Linux 流量控制機制實作
Linux 作業系統提供了強大的流量控制功能，透過 Traffic Control 子系統可以實現複雜的頻寬管理與優先權控制。這些機制能夠根據流量類型、來源位址或應用特徵，動態調整網路資源的分配，確保重要服務的可用性。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
網路 QoS 組態管理工具
功能：使用 Linux TC 命令實作流量控制與優先權管理
支援：頻寬限制、優先權佇列、流量整形等功能
"""
import subprocess
import json
from enum import Enum
class QoSClass(Enum):
"""流量類別定義"""
HIGH_PRIORITY = 1 # 高優先權：即時語音、視訊
NORMAL = 2 # 一般優先權：網頁瀏覽、檔案傳輸
LOW_PRIORITY = 3 # 低優先權：背景更新、備份流量
class QoSManager:
"""QoS 管理器類別，提供完整的流量控制功能"""
def __init__(self, interface='eth0'):
"""
初始化 QoS 管理器
參數：
interface: 要管理的網路介面名稱
"""
self.interface = interface
self.configured = False
def _run_command(self, command):
"""
執行系統命令的輔助函式
參數：
command: 要執行的命令清單
返回：
命令執行結果
"""
try:
result = subprocess.run(
command,
check=True,
capture_output=True,
text=True
)
return True, result.stdout
except subprocess.CalledProcessError as e:
return False, e.stderr
def clear_qos(self):
"""
清除現有的 QoS 組態
在重新組態前必須先清除舊的設定
"""
print(f"[*] 清除 {self.interface} 的 QoS 組態...")
# 刪除根佇列規則
command = ["tc", "qdisc", "del", "dev", self.interface, "root"]
success, output = self._run_command(command)
if success:
print("[+] QoS 組態已清除")
self.configured = False
else:
# 如果沒有現有組態，刪除命令會失敗，這是正常的
print("[*] 無現有 QoS 組態需要清除")
def setup_htb_qdisc(self, total_bandwidth="100Mbit"):
"""
設定 HTB (Hierarchical Token Bucket) 佇列規則
HTB 是一種分層的流量整形演算法，支援精確的頻寬控制
參數：
total_bandwidth: 總頻寬限制
"""
print(f"[*] 設定 HTB 佇列規則...")
# 新增根 HTB 佇列
# handle 1: 指定佇列的控制代碼編號
# default 30 指定預設流量分類
command = [
"tc", "qdisc", "add",
"dev", self.interface,
"root", "handle", "1:",
"htb", "default", "30"
]
success, output = self._run_command(command)
if not success:
print(f"[!] HTB 佇列設定失敗：{output}")
return False
# 新增根類別，定義總頻寬
command = [
"tc", "class", "add",
"dev", self.interface,
"parent", "1:",
"classid", "1:1",
"htb", "rate", total_bandwidth
]
success, output = self._run_command(command)
if success:
print(f"[+] HTB 根類別已設定：總頻寬 {total_bandwidth}")
self.configured = True
return True
else:
print(f"[!] 根類別設定失敗：{output}")
return False
def add_traffic_class(self, class_id, priority, guaranteed_rate, max_rate):
"""
新增流量類別，定義不同優先權的頻寬分配
參數：
class_id: 類別識別碼（10, 20, 30 等）
priority: 優先權等級（數字越小優先權越高）
guaranteed_rate: 保證頻寬
max_rate: 最大頻寬（可以超過保證頻寬）
"""
print(f"[*] 新增流量類別 1:{class_id}...")
# 新增子類別
command = [
"tc", "class", "add",
"dev", self.interface,
"parent", "1:1",
"classid", f"1:{class_id}",
"htb",
"rate", guaranteed_rate, # 保證頻寬
"ceil", max_rate, # 最大頻寬上限
"prio", str(priority) # 優先權等級
]
success, output = self._run_command(command)
if success:
print(f"[+] 類別 1:{class_id} 已新增")
print(f" 保證頻寬：{guaranteed_rate}")
print(f" 最大頻寬：{max_rate}")
print(f" 優先權：{priority}")
else:
print(f"[!] 類別新增失敗：{output}")
return success
def add_filter_rule(self, class_id, protocol, src_port=None, dst_port=None):
"""
新增過濾規則，將特定流量導向指定類別
參數：
class_id: 目標類別識別碼
protocol: 協定類型（tcp, udp, icmp）
src_port: 來源連接埠（選填）
dst_port: 目的連接埠（選填）
"""
print(f"[*] 新增過濾規則至類別 1:{class_id}...")
# 基本的 u32 過濾器命令
command = [
"tc", "filter", "add",
"dev", self.interface,
"protocol", "ip",
"parent", "1:0",
"prio", "1",
"u32"
]
# 根據協定型別新增匹配條件
if protocol == "tcp":
command.extend(["match", "ip", "protocol", "6", "0xff"])
elif protocol == "udp":
command.extend(["match", "ip", "protocol", "17", "0xff"])
elif protocol == "icmp":
command.extend(["match", "ip", "protocol", "1", "0xff"])
# 如果指定了連接埠，新增連接埠匹配條件
if dst_port:
# 匹配目的連接埠
command.extend([
"match", "ip", "dport",
str(dst_port), "0xffff"
])
# 指定流量分類
command.extend(["flowid", f"1:{class_id}"])
success, output = self._run_command(command)
if success:
rule_desc = f"{protocol}"
if dst_port:
rule_desc += f" 連接埠 {dst_port}"
print(f"[+] 過濾規則已新增：{rule_desc} -> 類別 1:{class_id}")
else:
print(f"[!] 過濾規則新增失敗：{output}")
return success
def show_qos_status(self):
"""顯示目前的 QoS 組態狀態"""
print(f"\n=== {self.interface} QoS 狀態 ===\n")
# 顯示佇列規則
print("[*] 佇列規則 (qdisc):")
subprocess.run(["tc", "qdisc", "show", "dev", self.interface])
# 顯示類別設定
print("\n[*] 類別設定 (class):")
subprocess.run(["tc", "class", "show", "dev", self.interface])
# 顯示過濾規則
print("\n[*] 過濾規則 (filter):")
subprocess.run(["tc", "filter", "show", "dev", self.interface])
def setup_enterprise_qos():
"""
企業級 QoS 組態範例
針對不同應用類型設定合適的頻寬與優先權
"""
print("=== 企業級 QoS 組態 ===\n")
# 建立 QoS 管理器
qos = QoSManager(interface='eth0')
# 清除現有組態
qos.clear_qos()
# 設定 HTB 根佇列，總頻寬 100Mbps
if not qos.setup_htb_qdisc(total_bandwidth="100Mbit"):
print("[!] QoS 設定失敗")
return
# 新增高優先權類別（即時通訊）
# 保證 30Mbps，最高可使用 50Mbps
qos.add_traffic_class(
class_id=10,
priority=1,
guaranteed_rate="30Mbit",
max_rate="50Mbit"
)
# 新增一般優先權類別（一般應用）
# 保證 50Mbps，最高可使用 80Mbps
qos.add_traffic_class(
class_id=20,
priority=2,
guaranteed_rate="50Mbit",
max_rate="80Mbit"
)
# 新增低優先權類別（背景流量）
# 保證 20Mbps，最高可使用 100Mbps
qos.add_traffic_class(
class_id=30,
priority=3,
guaranteed_rate="20Mbit",
max_rate="100Mbit"
)
# 設定過濾規則
# VoIP 流量（SIP 信令）-> 高優先權
qos.add_filter_rule(
class_id=10,
protocol="udp",
dst_port=5060
)
# HTTP/HTTPS 流量 -> 一般優先權
qos.add_filter_rule(
class_id=20,
protocol="tcp",
dst_port=80
)
qos.add_filter_rule(
class_id=20,
protocol="tcp",
dst_port=443
)
# 其他流量使用預設類別（低優先權）
# 顯示組態結果
qos.show_qos_status()
print("\n[+] QoS 組態完成")
print("[*] 高優先權流量：VoIP (30-50 Mbps)")
print("[*] 一般優先權流量：HTTP/HTTPS (50-80 Mbps)")
print("[*] 低優先權流量：其他 (20-100 Mbps)")
if __name__ == "__main__":
# 執行企業級 QoS 組態
setup_enterprise_qos()
這個 QoS 管理工具展示了如何使用 Linux Traffic Control 系統實作精細的流量控制。透過 HTB 演算法，可以為不同類型的流量分配保證頻寬與最大頻寬上限，確保即使在網路壅塞的情況下，關鍵應用仍能獲得足夠的資源。
網路安全監控與事件回應機制
建立完善的安全監控體系是及時發現與處理安全事件的關鍵。有效的監控系統不僅需要收集各層級的安全資料，更需要透過關聯分析識別複雜的攻擊模式，並提供自動化的回應機制。
安全事件的檢測與分析流程
安全監控系統需要整合多個資料來源，包含網路流量資料、系統日誌、應用程式記錄與安全裝置告警。透過將這些異質性資料正規化並建立關聯關係，可以發現單一資料源無法識別的複雜攻擊行為。事件回應流程應包含事件分級、影響評估、應急處置與事後分析等階段，確保組織能夠有效應對各種安全威脅。
未來網路安全技術發展趨勢
隨著網路技術的快速演進，安全防護技術也必須持續創新以應對新型態的威脅。人工智慧與機器學習技術在網路安全領域的應用日益廣泛，能夠處理大量的安全資料並識別未知的攻擊模式。軟體定義網路技術為安全防護帶來新的可能性，透過程式化控制網路行為，可以實現更動態與彈性的防禦策略。零信任架構的理念也逐漸成為主流，不再基於網路邊界來劃分信任區域，而是對每個存取請求進行嚴格驗證。
結論
Scapy 作為一套功能全面的網路安全測試工具，為安全研究人員與網路管理者提供了強大的封包操作能力。透過本文介紹的 ARP 欺騙偵測、封包混淆技術與 QoS 流量控制等實戰應用，可以建構完整的網路安全測試與防護體系。在實際應用中，需要根據組織的具體需求與威脅環境，選擇合適的安全技術與防護策略，並持續監控與最佳化安全機制。
Scapy 的程式化特性使其能夠輕鬆整合至自動化測試流程中，配合持續整合系統可以實現定期的安全掃描與驗證。然而，使用這類強大的工具時也需要注意合法性與倫理問題，確保所有測試活動都在授權範圍內進行。隨著網路環境的持續演變，Scapy 及其社群也在不斷發展，未來將會有更多創新的應用場景與功能特性出現，為網路安全領域帶來更多可能性。
