c語言rpc
Ⅰ 請問電腦處於sniffer狀態是什麼意識啊
sniffer是竊聽的意思，sniffer狀態應該就是竊聽狀態了
要更詳細的看下面，保證看到你頭大~哈哈
sniffers(嗅探器)幾乎和internet有一樣久的歷史了.Sniffer是一種常用的收集有用數據方法，這些數據可以是用戶的帳號和密碼，可以是一些商用機密數據等等。隨著Internet及電子商務的日益普及,Internet的安全也越來越受到重視。在Internet安全隱患中扮演重要角色之一的Sniffer以受到越來越大的關注，所以今天我要向大家介紹一下介紹Sniffer以及如何阻止sniffer。
大多數的黑客僅僅為了探測內部網上的主機並取得控制權，只有那些"雄心勃勃"的黑客，為了控制整個網路才會安裝特洛伊木馬和後門程序，並清除記錄。他們經常使用的手法是安裝sniffer。
在內部網上，黑客要想迅速獲得大量的賬號（包括用戶名和密碼），最為有效的手段是使用 "sniffer" 程序。這種方法要求運行Sniffer 程序的主機和被監聽的主機必須在同一個乙太網段上，故而在外部主機上運行sniffer是沒有效果的。再者，必須以root的身份使用sniffer 程序，才能夠監聽到乙太網段上的數據流。談到乙太網sniffer，就必須談到乙太網sniffing。
那麼什麼是乙太網sniffer呢?
乙太網sniffing是指對乙太網設備上傳送的數據包進行偵聽，發現感興趣的包。如果發現符合條件的包，就把它存到一個log文件中
去。通常設置的這些條件是包含字"username"或"password"的包。它的目的是將網路層放到promiscuous模式，從而能幹些事情。
Promiscuous模式是指網路上的所有設備都對匯流排上傳送的數據進行偵聽，並不僅僅是它們自己的數據。根據第二章中有關對乙太網的工作原理的基本介紹，可以知道：一個設備要向某一目標發送數據時,它是對乙太網進行廣播的。一個連到乙太網匯流排上的設備在任何時間里都在接受數據。不過只是將屬於自己的數據傳給該計算機上的應用程序。
利用這一點，可以將一台計算機的網路連接設置為接受所有以太
網匯流排上的數據，從而實現sniffer。
sniffer通常運行在路由器，或有路由器功能的主機上。這樣就能對大量的數據進行監控。sniffer屬第二層次的攻擊。通常是攻擊者已經進入了目標系統，然後使用sniffer這種攻擊手段，以便得到更多的信息。
sniffer除了能得到口令或用戶名外，還能得到更多的其他信息，比如一個其他重要的信息，在網上傳送的金融信息等等。sniffer幾乎能得到任何乙太網上的傳送的數據包。黑客會使用各種方法，獲得系統的控制權並留下再次侵入的後門，以保證sniffer能夠執行。在Solaris 2.x平台上，sniffer 程序通常被安裝在/usr/bin 或/dev目錄下。黑客還會巧妙的修改時間，使得sniffer程序看上去是和其它系統程序同時安裝的。
大多數乙太網sniffer程序在後台運行，將結果輸出到某個記錄文件中。黑客常常會修改ps程序，使得系統管理員很難發現運行的sniffer程序。
乙太網sniffer程序將系統的網路介面設定為混合模式。這樣，它就可以監聽到所有流經同一乙太網網段的數據包，不管它的接受者或發送者是不是運行sniffer的主機。 程序將用戶名、密碼和其它黑客感興趣的數據存入log文件。黑客會等待一段時間 ----- 比如一周後，再回到這里下載記錄文件。
講了這么多，那麼到底我們可以用什麼通俗的話來介紹sniffer呢？
計算機網路與電話電路不同，計算機網路是共享通訊通道的。共享意味著計算機能夠接收到發送給其它計算機的信息。捕獲在網路中傳輸的數據信息就稱為sniffing（竊聽）。
乙太網是現在應用最廣泛的計算機連網方式。乙太網協議是在同一迴路向所有主機發送數據包信息。數據包頭包含有目標主機的正確地址。一般情況下只有具有該地址的主機會接受這個數據包。如果一台主機能夠接收所有數據包，而不理會數據包頭內容，這種方式通常稱為"混雜" 模式。
由於在一個普通的網路環境中，帳號和口令信息以明文方式在乙太網中傳輸， 一旦入侵者獲得其中一台主機的root許可權，並將其置於混雜模式以竊聽網路數據，從而有可能入侵網路中的所有計算機。
一句話，sniffer就是一個用來竊聽的黑客手段和工具。
二、sniffer的工作原理
通常在同一個網段的所有網路介面都有訪問在物理媒體上傳輸的所有數據的能力，而每個網路介面都還應該有一個硬體地址，該硬體地址不同於網路中存在的其他網路介面的硬體地址，同時，每個網路至少還要一個廣播地址。（代表所有的介面地址），在正常情況下，一個合法的網路介面應該只響應這樣的兩種數據幀：
1、幀的目標區域具有和本地網路介面相匹配的硬體地址。
2、幀的目標區域具有"廣播地址"。
在接受到上面兩種情況的數據包時，nc通過cpu產生一個硬體中斷，該中斷能引起操作系統注意，然後將幀中所包含的數據傳送給系統進一步處理。
而sniffer就是一種能將本地nc狀態設成（promiscuous）狀態的軟體，當nc處於這種"混雜"方式時，該nc具備"廣播地址"，它對所有遭遇到的每一個幀都產生一個硬體中斷以便提醒操作系統處理流經該物理媒體上的每一個報文包。（絕大多數的nc具備置成 promiscuous方式的能力）
可見，sniffer工作在網路環境中的底層，它會攔截所有的正在網路上傳送的數據，並且通過相應的軟體處理，可以實時分析這些數據的內容，進而分析所處的網路狀態和整體布局。值得注意的是：sniffer是極其安靜的，它是一種消極的安全攻擊。
通常sniffer所要關心的內容可以分成這樣幾類：
1、口令
我想這是絕大多數非法使用sniffer的理由，sniffer可以記錄到明文傳送的userid和passwd.就算你在網路傳送過程中使用了加密的數據，sniffer記錄的數據一樣有可能使入侵者在家裡邊吃肉串邊想辦法算出你的演算法。
2、金融帳號
許多用戶很放心在網上使用自己的信用卡或現金帳號，然而sniffer可以很輕松截獲在網上傳送的用戶姓名、口令、信用卡號碼、截止日期、帳號和pin.
3、偷窺機密或敏感的信息數據
通過攔截數據包，入侵者可以很方便記錄別人之間敏感的信息傳送，或者乾脆攔截整個的email會話過程。
4、窺探低級的協議信息。
這是很可怕的事，我認為，通過對底層的信息協議記錄，比如記錄兩台主機之間的網路介面地址、遠程網路介面ip地址、ip路由信息和tcp連接的位元組順序號碼等。這些信息由非法入侵的人掌握後將對網路安全構成極大的危害，通常有人用sniffer收集這些信息只有一個原因：他正在進行一次欺詐，（通常的ip地址欺詐就要求你准確插入tcp連接的位元組順序號,這將在以後整理的文章中指出）如果某人很關心這個問題，那麼sniffer對他來說只是前奏，今後的問題要大得多。（對於高級的hacker而言，我想這是使用sniffer的唯一理由吧）
二.sniffer的工作環境
snifffer就是能夠捕獲網路報文的設備。嗅探器的正當用處在於分析網路的流量,以便找出所關心的網路中潛在的問題。例如,假設網路的某一段運行得不是很好,報文的發送比較慢,而我們又不知道問題出在什麼地方,此時就可以用嗅探器來作出精確的問題判斷。
嗅探器在功能和設計方面有很多不同。有些只能分析一種協議，而另一些可能能夠分析幾百種協議。一般情況下，大多數的嗅探器至少能夠分析下面的協議：
1.標准乙太網
2.TCP/IP
3.IPX
4.DECNet
嗅探器通常是軟硬體的結合。專用的嗅探器價格非常昂貴。另一方面，免費的嗅探器雖然不需要花什麼錢，但得不到什麼支持。
嗅探器與一般的鍵盤捕獲程序不同。鍵盤捕獲程序捕獲在終端上輸入的鍵值，而嗅探器則捕獲真實的網路報文。嗅探器通過將其置身於網路介面來達到這個目的——例如將乙太網卡設置成雜收模式。（為了理解雜收模式是怎麼回事，先解釋區域網是怎麼工作的）。
數據在網路上是以很小的稱為幀(Ftame)的單位傳輸的幀由好幾部分組成，不同的部分執行不同的功能。（例如，乙太網的前12個位元組存放的是源和目的的地址，這些位告訴網路：數據的來源和去處。乙太網幀的其他部分存放實際的用戶數據、TCP/IP的報文頭或IPX報文頭等等）。
幀通過特定的稱為網路驅動程序的軟體進行成型，然後通過網卡發送到網線上。通過網線到達它們的目的機器，在目的機器的一端執行相反的過程。接收端機器的乙太網卡捕獲到這些幀，並告訴操作系統幀的到達，然後對其進行存儲。就是在這個傳輸和接收的過程中，嗅探器會造成安全方面的問題。
每一個在LAN上的工作站都有其硬體地址。這些地址唯一地表示著網路上的機器（這一點於Internet地址系統比較相似）。當用戶發送一個報文時，這些報文就會發送到LAN上所有可用的機器。
在一般情況下，網路上所有的機器都可以「聽」到通過的流量，但對不屬於自己的報文則不予響應（換句話說，工作站A不會捕獲屬於工作站B的數據，而是簡單的忽略這些數據）。
如果某在工作站的網路介面處於雜收模式，那麼它就可以捕獲網路上所有的報文和幀，如果一個工作站被配置成這樣的方式，它（包括其軟體）就是一個嗅探器。
嗅探器可能造成的危害：
1.嗅探器能夠捕獲口令
2.能夠捕獲專用的或者機密的信息
3.可以用來危害網路鄰居的安全，或者用來獲取更高級別的訪問許可權
事實上，如果你在網路上存在非授權的嗅探器就以為著你的系統已經暴露在別人面前了。（大家可以試試天行2的嗅探功能）
一般我們只嗅探每個報文的前200到300個位元組。用戶名和口令都包含在這一部分中，這是我們關心的真正部分。工人，也可以嗅探給定介面上的所有報文，如果有足夠的空間進行存儲，有足夠的那裡進行處理的話，將會發現另一些非常有趣的東西……
簡單的放置一個嗅探器賓將其放到隨便什麼地方將不會起到什麼作用。將嗅探器放置於被攻擊機器或網路附近，這樣將捕獲到很多口令，還有一個比較好的方法就是放在網關上。如果這樣的話就能捕獲網路和其他網路進行身份鑒別的過程。這樣的方式將成倍地增加我們能夠攻擊的范圍。
三.誰會使用sniffers
可能誰都回知道誰會使用sniffer，但是並不是每個使用它的人都是網路高手，因為現在有很多的sniffer都成了傻瓜似的了，前段時間用的最多的不外乎oicq sniffer。我想那些喜歡查好友ip的朋友都應該記得它吧。呵呵，我都使用過它，現在當然不用了啊！
當然系統管理員使用sniffer來分析網路信息交通並且找出網路上何處發生問題。一個安全管理員可以同時用多種sniffer, 將它們放置在網路的各處,形成一個入侵警報系統。對於系統管理員來說sniffer是一個非常好的工具,但是它同樣是一個經常被黑客使用的工具.駭客安裝sniffer以獲得用戶名和賬號,信用卡號碼,個人信息,和其他的信息可以導致對你或是你的公司的極大危害如果向壞的方面發展。當它們得到這些信息後,駭客將使用密碼來進攻其他的internet 站點甚至倒賣信用卡號碼。
三.sniffer是如何在網路上實施的
談這個問題之前還應該先說一下Ethernet的通訊。通常在同一個網段的所有網路介面都有訪問在媒體上傳輸的所有數據的能力，而每個網路介面都還應該有一個硬體地址，該硬體地址不同於網路中存在的其它網路介面的硬體地址，同時，每個網路至少還要一個廣播地址。在正常情況下，一個合法的網路介面應該只響應這樣的兩種數據幀：
1�幀的目標區域具有和本地網路介面相匹配的硬體地址。
2�幀的目標區域具有「廣播地址」。
在接受到上面兩種情況的數據包時，網卡通過cpu產生一個硬體中斷。該中斷能引起操作系統注意，然後將幀中所包含的數據傳送給系統進一步處理。而sniffer就是一種能將本地網卡狀態設成雜亂模式（promiscuous Mode）的軟體。當網卡處於雜亂模式時，該網卡具備「廣播地址」，它對所有遇到的每一個幀都產生一個硬體中斷以提醒操作系統處理每一個報文包。（絕大多數的網卡具備設置成雜亂模式的能力。
可見，sniffer工作在網路環境中的底層，它會攔截所有的正在網路上傳送的數據。通過相應的軟體處理，可以實時分析這些數據的內容，進而分析所處的網路狀態和整體布局。值得注意的是：sniffer是極其安靜的，它是一種消極的安全攻擊。
四.哪裡可以得到sniffer
我們講的sniffer，主要是在unix系統下運用的，至於那些oicq sniffer就不在我們討論的范圍。
Sniffer是黑客們最常用的入侵手段之一。你可以在經過允許的網路中運行sniffer，了解它是如何有效地危及本地機器安全。
Sniffer可以是硬體，也可以是軟體。現在品種最多,應用最廣的是軟體Sniffer,絕大多數黑客們用的也是軟體Sniffer。
以下是一些也被廣泛用於調試網路故障的sniffer工具：
（一）.商用sniffer：
1. Network General.
Network General開發了多種產品。最重要的是Expert Sniffer，它不僅僅可以sniff，還能夠通過高性能的專門系統發送/接收數據包，幫助診斷故障。還有一個增強產品"Distrbuted Sniffer System"可以將UNIX工作站作為sniffer控制台，而將sniffer agents（代理）分布到遠程主機上。
2. Microsoft's Net Monitor
對於某些商業站點，可能同時需要運行多種協議--NetBEUI、IPX/SPX、TCP/IP、802.3和SNA等。這時很難找到一種sniffer幫助解決網路問題，因為許多sniffer往往將某些正確的協議數據包當成了錯誤數據包。Microsoft的Net Monitor（以前叫Bloodhound）可以解決這個難題。它能夠正確區分諸如Netware控制數據包、NT NetBios名字服務廣播等獨特的數據包。（etherfind只會將這些數據包標識為類型0000的廣播數據包。）這個工具運行在MS Windows 平台上。它甚至能夠按MAC地址（或主機名）進行網路統計和會話信息監視。只需簡單地單擊某個會話即可獲得tcpmp標準的輸出。過濾器設置也是最為簡單的，只要在一個對話框中單擊需要監視的主機即可。
（二）.免費軟體sniffer
1. Sniffit由Lawrence Berkeley 實驗室開發，運行於Solaris、SGI和linux等平台。可以選擇源、目標地址或地址集合，還可以選擇監聽的埠、協議和網路介面等。這個SNIFFER默認狀態下只接受最先的400個位元組的信息包，這對於一次登陸會話進程剛剛好。
2. SNORT：這個SNIFFER有很多選項供你使用並可移植性強，可以記錄一些連接信息，用來跟蹤一些網路活動。
3. TCPDUMP：這個SNIFFER很有名，linux,FREEBSD還搭帶在系統上，是一個被很多UNIX高手認為是一個專業的網路管理工具，記得以前TsutomuShimomura（應該叫下村侵吧）就是使用他自己修改過的TCPDUMP版本來記錄了KEVINMITNICK攻擊他系統的記錄，後來就配合FBI抓住了KEVINMITNICK，後來他寫了一文：使用這些LOG記錄描述了那次的攻擊，
( http://www.attrition.org/security/newbie/security/sniffer/shimomur.txt )
4. ADMsniff:這是非常有名的ADM黑客集團寫的一個SNIFFER程序。
5. linsniffer:這是一個專門設計雜一LINUX平台上的SNIFFER。
6. Esniffer:這個也是一個比較有名的SNIFFER程序。
7. Solsniffer:這是個Solarissniffer，主要是修改了SunSniff專門用來可以方便的在Solair平台上編譯。
8. Ethereal是一基於GTK＋的一個圖形化Sniffer
9. Gobbler(for MS－DOS＆Win95)、Netman、NitWit、Ethload...等等。
（三）.UNIX下的sniffer
UNIX下的sniffer，我比較傾向於snoop.Snoop是按Solaris的標准製作的,雖然Snoop不像是Sniffer Pro那樣好,但是它是一個可定製性非常強的sniffer,在加上它是免費的(和Solaris附一起).誰能打敗它的地位?你可以在極短時間內抓獲一個信息包或是更加深的分析.如果你想學習如何使用snoop,看下面的url:
http://www.enteract.com/~lspitz/snoop.html
（四）.Linux下的sniffer工具
Linux下的sniffer工具，我推薦Tcpmp。
[1].tcpmp的安裝
在linux下tcpmp的安裝十分簡單，一般由兩種安裝方式。一種是以rpm包的形式來進行安裝。另外一種是以源程序的形式安裝。
1． rpm包的形式安裝
這種形式的安裝是最簡單的安裝方法，rpm包是將軟體編譯後打包成二進制的格式，通過rpm命令可以直接安裝，不需要修改任何東西。以超級用戶登錄，使用命令如下：
#rpm -ivh tcpmp-3_4a5.rpm
這樣tcpmp就順利地安裝到你的linux系統中。怎麼樣，很簡單吧。
2． 源程序的安裝
既然rpm包的安裝很簡單,為什麼還要採用比較復雜的源程序安裝呢?其實，linux一個最大的誘人之處就是在她上面有很多軟體是提供源程序的，人們可以修改源程序來滿足自己的特殊的需要。所以我特別建議朋友們都採取這種源程序的安裝方法。
· 第一步 取得源程序 在源程序的安裝方式中，我們首先要取得tcpmp的源程序分發包，這種分發包有兩種 形式，一種是tar壓縮包(tcpmp-3_4a5.tar.Z),另一種是rpm的分發包(tcpmp-3_4a5.src.rpm)。這兩種 形式的內容都是一樣的，不同的僅僅是壓縮的方式.tar的壓縮包可以使用如下命令解開：
#tar xvfz tcpmp-3_4a5.tar.Z
rpm的包可以使用如下命令安裝:
#rpm -ivh tcpmp-3_4a5.src.rpm
這樣就把tcpmp的源代碼解壓到/usr/src/redhat/SOURCES目錄下.
· 第二步 做好編譯源程序前的准備活動
在編譯源程序之前，最好已經確定庫文件libpcap已經安裝完畢，這個庫文件是tcpmp軟體所需的庫文件。同樣，你同時還要有一個標準的c語言編譯器。在linux下標準的c 語言編譯器一般是gcc。 在tcpmp的源程序目錄中。有一個文件是Makefile.in，configure命令就是從Makefile.in文件中自動產生Makefile文件。在Makefile.in文件中，可以根據系統的配置來修改BINDEST 和 MANDEST 這兩個宏定義，預設值是
BINDEST = @sbindir @
MANDEST = @mandir @
第一個宏值表明安裝tcpmp的二進制文件的路徑名，第二個表明tcpmp的man 幫助頁的路徑名,你可以修改它們來滿足系統的需求。
· 第三步 編譯源程序
使用源程序目錄中的configure腳本，它從系統中讀出各種所需的屬性。並且根據Makefile.in文件自動生成Makefile文件，以便編譯使用.make 命令則根據Makefile文件中的規則編譯tcpmp的源程序。使用make install命令安裝編譯好的tcpmp的二進制文件。
總結一下就是:
# tar xvfz tcpmp-3_4a5.tar.Z
# vi Makefile.in
# . /configure
# make
# make install
[2].Tcpmp的使用
tcpmp採用命令行方式，它的命令格式為：
tcpmp [ -adeflnNOpqStvx ] [ -c 數量 ] [ -F 文件名 ]
[ -i 網路介面 ] [ -r 文件名] [ -s snaplen ]
[ -T 類型 ] [ -w 文件名 ] [表達式 ]
1. tcpmp的選項介紹
-a 將網路地址和廣播地址轉變成名字；
-d 將匹配信息包的代碼以人們能夠理解的匯編格式給出；
-dd 將匹配信息包的代碼以c語言程序段的格式給出；
-ddd 將匹配信息包的代碼以十進制的形式給出；
-e 在輸出行列印出數據鏈路層的頭部信息；
-f 將外部的Internet地址以數字的形式列印出來；
-l 使標准輸出變為緩沖行形式；
-n 不把網路地址轉換成名字；
-t 在輸出的每一行不列印時間戳；
-v 輸出一個稍微詳細的信息，例如在ip包中可以包括ttl和服務類型的信息；
-vv 輸出詳細的報文信息；
-c 在收到指定的包的數目後，tcpmp就會停止；
-F 從指定的文件中讀取表達式,忽略其它的表達式；
-i 指定監聽的網路介面；
-r 從指定的文件中讀取包(這些包一般通過-w選項產生)；
-w 直接將包寫入文件中，並不分析和列印出來；
-T 將監聽到的包直接解釋為指定的類型的報文，常見的類型有rpc （遠程過程 調用）和snmp（簡單網路管理協議；）
2. tcpmp的表達式介紹
表達式是一個正則表達式，tcpmp利用它作為過濾報文的條件，如果一個報文滿足表達式的條件，則這個報文將會被捕獲。如果沒有給出任何條件，則網路上所有的信息包將會被截獲。
在表達式中一般如下幾種類型的關鍵字，一種是關於類型的關鍵字，主要包括host，net，port, 例如 host 210.27.48.2，指明 210.27.48.2是一台主機，net 202.0.0.0 指明 202.0.0.0是一個網路地址，port 23 指明埠號是23。如果沒有指定類型，預設的類型是host.
第二種是確定傳輸方向的關鍵字，主要包括src , dst ,dst or src, dst and src ,這些關鍵字指明了傳輸的方向。舉例說明，src 210.27.48.2 ,指明ip包中源地址是210.27.48.2 , dst net 202.0.0.0 指明目的網路地址是202.0.0.0 。如果沒有指明方向關鍵字，則預設是src or dst關鍵字。
第三種是協議的關鍵字，主要包括fddi,ip ,arp,rarp,tcp,udp等類型。Fddi指明是在FDDI(分布式光纖數據介面網路)上的特定的網路協議，實際上它是"ether"的別名，fddi和ether具有類似的源地址和目的地址，所以可以將fddi協議包當作ether的包進行處理和分析。其他的幾個關鍵字就是指明了監聽的包的協議內容。如果沒有指定任何協議，則tcpmp將會監聽所有協議的信息包。
除了這三種類型的關鍵字之外，其他重要的關鍵字如下：gateway, broadcast,less,greater,還有三種邏輯運算，取非運算是 'not ' '! ', 與運算是'and','&&';或運算 是'or' ,''；
這些關鍵字可以組合起來構成強大的組合條件來滿足人們的需要，下面舉幾個例子來說明。
(1)想要截獲所有210.27.48.1 的主機收到的和發出的所有的數據包：
#tcpmp host 210.27.48.1
(2) 想要截獲主機210.27.48.1 和主機210.27.48.2 或210.27.48.3的通信，使用命令：（在命令行中適用括弧時，一定要
#tcpmp host 210.27.48.1 and \ (210.27.48.2 or 210.27.48.3 \)
(3) 如果想要獲取主機210.27.48.1除了和主機210.27.48.2之外所有主機通信的ip包，使用命令：
#tcpmp ip host 210.27.48.1 and ! 210.27.48.2
(4)如果想要獲取主機210.27.48.1接收或發出的telnet包，使用如下命令：
#tcpmp tcp port 23 host 210.27.48.1
3. tcpmp 的輸出結果介紹
下面我們介紹幾種典型的tcpmp命令的輸出信息
(1) 數據鏈路層頭信息
使用命令#tcpmp --e host ice
ice 是一台裝有linux的主機，她的MAC地址是0：90：27：58：AF：1A
H219是一台裝有SOLARIC的SUN工作站，它的MAC地址是8：0：20：79：5B：46；上一條命令的輸出結果如下所示：
21:50:12.847509 eth0 < 8:0:20:79:5b:46 0:90:27:58:af:1a ip 60: h219.33357 > ice.telne
t 0:0(0) ack 22535 win 8760 (DF)
分析：21：50：12是顯示的時間， 847509是ID號，eth0 <表示從網路介面eth0 接受該數據包，eth0 >表示從網路介面設備發送數據包, 8:0:20:79:5b:46是主機H219的MAC地址,它表明是從源地址H219發來的數據包. 0:90:27:58:af:1a是主機ICE的MAC地址,表示該數據包的目的地址是ICE . ip 是表明該數據包是IP數據包,60 是數據包的長度, h219.33357 > ice.telnet 表明該數據包是從主機H219的33357埠發往主機ICE的TELNET(23)埠. ack 22535 表明對序列號是222535的包進行響應. win 8760表明發送窗口的大小是8760.
(2) ARP包的TCPDUMP輸出信息
使用命令#tcpmp arp
得到的輸出結果是：
22:32:42.802509 eth0 > arp who-has route tell ice (0:90:27:58:af:1a)
22:32:42.802902 eth0 < arp reply route is-at 0:90:27:12:10:66 (0:90:27:58:af:1a)
分析: 22:32:42是時間戳, 802509是ID號, eth0 >表明從主機發出該數據包, arp表明是ARP請求包, who-has route tell ice表明是主機ICE請求主機ROUTE的MAC地址。 0:90:27:58:af:1a是主機ICE的MAC地址。
(3) TCP包的輸出信息
用TCPDUMP捕獲的TCP包的一般輸出信息是：
src > dst: flags data-seqno ack window urgent options
src > dst:表明從源地址到目的地址, flags是TCP包中的標志信息,S 是SYN標志, F (FIN), P (PUSH) , R (RST) "." (沒有標記); data-seqno是數據包中的數據的順序號, ack是下次期望的順序號, window是接收緩存的窗口大小, urgent表明數據包中是否有緊急指針. Options是選項.
(4) UDP包的輸出信息
用TCPDUMP捕獲的UDP包的一般輸出信息是：
route.port1 > ice.port2: udp lenth
UDP十分簡單，上面的輸出行表明從主機ROUTE的port1埠發出的一個UDP數據包到主機ICE的port2埠，類型是UDP， 包的長度是lenth上面，我就詳細介紹了TCPDUMP的安裝和使用，希望會對大家有所幫助。如果想要熟練運用TCPDUMP這個LINUX環境下的SNIFFER利器，還需要大家在實踐中總結經驗，充分發揮它的威力。
（五）.windows平台上的sniffer
我推薦netxray和sniffer pro軟體，想必大家都用過他們，不過我在這兒還要再簡單介紹一下他們。
netxray的使用說明
1.1.1.1----2.2.2.2----3.3.3.3----4.4.4.4 這是一個ShareHub連接下的區域網
5.5.5.5 這是一個8080埠上的http/ftp proxy
Internet
啟動Capture，?
Ⅱ linux下C語言的庫函數的頭文件放在哪個目錄下啊
一般來說是放在/usr/include目錄下的；
但是這個並不局限也是可控的，如果我們進行開發過程中， 就會在內核的庫函數文件目錄：
例如在:/XXX/XXX/linux-X.X/include
所以根據不同的情況，頭文件存放的目錄也是不同的，具體需要可以根據locate和grep命令進行查詢。
Ⅲ C語言函數聲明static void clrpchist __P((void));是什麼意思
static void clrpchist __P((void));
此句是申明了一個名為lrpchist __P的函數，函數無返回值，無參數，static修飾表示此函數只能在當前文件被調用，不能被其它.c文件中被調用。
補充static用法：
在C中，static主要定義全局靜態變數、定義局部靜態變數、定義靜態函數。
1. 定義全局靜態變數：
在全局變數前面加上關鍵字static，該全局變數變成了全局靜態變數。全局靜態變數有以下特點。
a.在全局區分配內存。
b.如果沒有初始化，其默認值為0.
c.該變數在本文件內從定義開始到文件結束可見。
2. 定義局部靜態變數：
在局部變數前面加上關鍵字static，其特點如下：
a.該變數在全局數據區分配內存。
b.它始終駐留在全局數據區，直到程序運行結束。
c. 其作用域為局部作用域，當定義它的函數或語句塊結束時，其作用域隨之結束。
3. 定義靜態函數：
在函數返回類型前加上static關鍵字，函數即被定義為靜態函數，其特點如下：
a.靜態函數只能在本源文件中使用
b.在文件作用域中聲明的inline函數默認為static類型
Ⅳ C語言簡單行編輯器
/*
c語言程序設計 簡單的行編輯器
【要求】
（1） 設置一個簡單的行編輯器，每行以回車結束
（2） 數據以文件形式存儲
（3） 編輯器具有查找、替換、修改數據的功能
【備注】完全原創，編寫時間：2010-7-13。請把所有的注釋信息提取出來就可以寫程序設計報告。
*/
#include /*標准文件流操作，這里使用了fopen/fclose/fprintf/printf/scanf/gets函數*/
#include /*標准系統庫，這里使用了malloc/free/exit*/
#include /*標准字元串庫，這里使用strlen/strcpy/memcpy/memset*/
#define szLINE 252 /*定義一行字元串最長為252位元組*/
#define CMDS 12 /*定義12個標准行編輯命令*/
/*採用鏈表存儲文本*/
typedef struct LINE {
char text[szLINE]; /*文本內容*/
struct LINE * next; /*鏈表指針*/
} L;
/*簡寫無類型整數*/
typedef unsigned int U;
/*定義12個行編輯命令的標准格式*/
typedef void (*FUNC)(L **, char*);
/*定義12個標准行編輯命令的關鍵字*/
char keywords[CMDS][8]={
"quit", "help", "load", "save",
"view", "count", "append", "insert",
"erase", "edit", "lookup", "replace"
};/*end keywords*/
/*清空鏈表操作*/
void clear(L ** lines)
{
L * a = 0, * b = 0;
if(!lines) return ;
a = *lines;
while(a) {
b = a->next ;
free(a);
a = b;
}/*end while*/
*lines = 0;
}/*end clear*/
/*在鏈表中根據行號index調出指定的行*/
L * locate(L * lines, U index)
{
L * t = lines; U i = 0;
if(!t) return 0;
if(index == 0) return t;
for(i = 0; i < index; i++) {
t = t->next;
if(!t) return 0;
}/*next*/
return t;
}/*end locate*/
/*瀏覽命令，如果f存在則以帶行號格式保存文件（如果f==stdout則列印到屏幕上），
瀏覽范圍為from到to（行號）。view(lines, 0, 0, 0)表示統計已載入到內存的文本行數量*/
int view(L * lines, FILE * f, U from, U to)
{
L * t = lines; U index = 0;
while(t) {
index ++;
if(f && index >= from && index text);
t = t->next;
}/*end while*/
return index;
}/*end view*/
/*在當前文檔中根據關鍵字進行搜索，並將搜索結果列印出來*/
void lookup(L * lines, char * string)
{
L * t = 0; U index = 0;
if(!string) return ;
t = lines;
while(t) {
index ++;
if(strstr(t->text , string)) printf("%d: %s", index, t->text );
t=t->next;
}/*end while*/
}/*end lookup*/
/*在一行文本中執行替換命令，把所有關鍵字替換為新關鍵字*/
void rpc(char * string, char * key, char * replacement)
{
char fine[szLINE], * x = 0, * y = 0, * z = 0;
int la = 0, lb = 0, r = 0;
if(!string || !key || !replacement) return ;
memset(fine, 0, szLINE);
x = string; y = fine;
/*首先記錄新舊關鍵字長度*/
la = strlen(key);
lb = strlen(replacement);
do {
/*用指針逐個比較*/
r = memcmp(x, key, la);
if(r) {/*如果關鍵字不匹配則復制字元串*/
*y = *x;
x++; y++;
}else{/*如果關鍵字匹配則替換字元串*/
memcpy(y, replacement, lb);
x += la; y += lb;
}/*end if*/
}while(*x);
/*將替換完成的結果返回*/
memcpy(string, fine, szLINE);
}/*end rpc*/
/*全文替換*/
void replace(L * lines, char * string, char * replacement)
{
L * t = 0; U index = 0;
if(!string || !lines || !replacement) return ;
t = lines;
while(t) {
index ++;
if(strstr(t->text , string)) {
printf("[BEFORE] %d: %s", index, t->text );
rpc(t->text, string, replacement);
printf("[AFTER ] %d: %s", index, t->text );
}/*end if*/
t=t->next;
}/*end while*/
}/*end replace*/
/*根據行號插入一行新文本，如果行號小於零則將文本追加至鏈表尾*/
void insert(L ** lines, char * line, int index)
{
L * t = 0, * s = 0; int i = 0;
if(!lines || !line) return ;
/*首先為新文本分配一個鏈表節點*/
t = (L*)malloc(sizeof(L));
memset(t, 0, sizeof(L));
strcpy(t->text , line);
if(index == 0 || !*lines) {/*如果鏈表為空則以新節點為起點定義鏈表*/
t->next = *lines;
*lines = t;
return ;
}/*end if*/
s = *lines;
if(index > 0)/*如果行號為正整數，則將鏈表指針指向行號之前*/
for(i = 0; i < index-2; i++) {
if(!s->next ) break;
s = s->next ;
}/*next*/
else/*否則鏈表指針指向表尾*/
while(s->next ) s = s->next ;
/*end if*/
/*完成鏈表插入操作*/
if(s->next ) t->next = s->next ;
s->next = t;
}/*end insert*/
/*根據行號刪除一行文本*/
void erase(L ** lines, U index)
{
L * a = 0, * b = 0, * c = 0;
if(!lines) return ;
/*index -1 表示目標行，index -2表示目標行的前一行*/
a = locate(*lines, index-2);
b = locate(*lines, index-1);
if(!b) return ;
if(a) /*如果前一行存在則刪除目標行*/
a->next = b->next;
else/*否則表示表頭刪除*/
*lines = b->next ;
/*end if*/
/*釋放內存*/
free(b);
}/*end erase*/
/*根據行號和新錄入文本替換原有行*/
void edit(L * lines, char * line, U index)
{
L * t = locate(lines, index-1);
if(!t) return ;
if(line) strcpy(t->text , line);
}/*end edit*/
/*將文件整個裝入鏈表*/
int load(L ** lines, char * file)
{
FILE * f = 0; char line[szLINE]="";
int total = 0;
if(!lines || !file) return 0;
clear(lines);/*首先清空鏈表*/
/*打開文件*/
f = fopen(file, "r");
if(!f) {
fprintf(stderr, "%s is bad.\n", file);
return 0;
}/*end if*/
/*逐行讀入內存並插入表尾*/
while(!feof(f)) {
memset(line, 0, szLINE);
fgets(line, szLINE - 1, f);
insert(lines, line, -1);
total ++;
}/*end while*/
fclose(f);
fprintf(stderr, "[%s] %d lines loaded.\n", file, total);
/*返回總行數*/
return total;
}/*end load*/
/*將鏈表保存到指定的文本文件*/
int save(L * lines, char * file)
{
FILE * f = 0; L * t = lines;
int total = 0;
if(!lines || !file) return 0;
/*打開文件*/
f = fopen(file, "w");
if(!f) {
fprintf(stderr, "%s is bad.\n", file);
return 0;
}/*end if*/
t = lines;
while(t) {/*逐個文件寫入*/
fprintf(f, "%s", t->text );
t = t->next ;
total ++;
}/*end while*/
fclose(f);
fprintf(stderr, "[%s] %d lines saved.\n", file, total);
/*返回總行數*/
return total;
}/*save*/
/*執行載入文本文件命令*/
void exec_load(L ** lines, char * line)
{
char cmd[szLINE] = "", file[szLINE] = "";
/*分析命令行，提取文件名*/
sscanf(line, "%s %s", cmd, file);
/*執行載入命令*/
load(lines, file);
}/*end exec_load*/
/*執行文本保存命令*/
void exec_save(L ** lines, char * line)
{
char cmd[szLINE] = "", file[szLINE] = "";
/*分析命令行，提取文件名*/
sscanf(line, "%s %s", cmd, file);
/*執行保存命令*/
save(*lines, file);
}/*end exec_save*/
/*執行文本查看命令*/
void exec_view(L ** lines, char * line)
{
char cmd[szLINE] = ""; U from = 0, to = 0;
/*分析命令行，提取目標要查看的起始行號和終止行號*/
sscanf(line, "%s %u %u", cmd, &from, &to);
/*如果起始行號和終止行號大小相反，則根據起始行號顯示一頁*/
if(to < from) to = from + 24;
/*執行查看命令*/
view(*lines, stdout, from, to);
}/*end exec_view*/
/*執行行數統計命令*/
void exec_count(L ** lines, char * line)
{
fprintf(stderr, "%d lines in mem.\n", view(*lines, 0, 0, 0));
}/*end count*/
/*執行文本追加命令*/
void exec_append(L ** lines, char * line)
{
char text[szLINE] = "";
/*在命令之後另起新行用於錄入文本*/
gets(text); strcat(text, "\n");
/*執行文本追加命令*/
insert(lines, text, -1);
}/*end exec_append*/
/*執行文本插入命令*/
void exec_insert(L ** lines, char * line)
{
char cmd[szLINE] = "", text[szLINE] = ""; U index = 0;
/*從命令行提取目標插入點的行號*/
sscanf(line, "%s %d", cmd, &index);
/*在命令之後另起新行用於錄入文本*/
gets(text); strcat(text, "\n");
/*執行文本插入命令*/
insert(lines, text, index);
}/*end insert*/
/*執行文本刪除命令*/
void exec_erase(L ** lines, char * line)
{
char cmd[szLINE] = ""; U index = 0;
/*從命令行提取目標行號*/
sscanf(line, "%s %d", cmd, &index);
/*執行文本刪除命令*/
erase(lines, index);
}/*end erase*/
/*執行文本編輯命令*/
void exec_edit(L ** lines, char * line)
{
char cmd[szLINE] = "", text[szLINE] = ""; U index = 0;
/*從命令行提取目標行號*/
sscanf(line, "%s %d", cmd, &index);
/*在命令之後另起新行用於錄入文本*/
gets(text); strcat(text, "\n");
/*執行文本編輯命令*/
edit(*lines, text, index);
}/*end edit*/
/*執行文本檢索命令*/
void exec_lookup(L ** lines, char * line)
{
char cmd[szLINE] = "", text[szLINE] = "";
/*從命令行提取關鍵字*/
sscanf(line, "%s %s", cmd, text);
/*執行文本檢索命令*/
lookup(*lines, text);
}/*end lookup*/
/*執行在線幫助命令*/
void exec_help(L ** lines, char * line)
{printf("\tcommands:\n\thelp\n\tquit\n\
\tload [file.txt]\n\
\tsave [file.txt]\n\
\tview [from line] [to line]\n\
\tcount\n\
\tappend [return + text]\n\
\tinsert [line number] [return + text]\n\
\terase [line number]\n\
\tedit [line number] [return + text]\n\
\tlookup [text]\n\
\treplace [keyword] [replacement]\n");
}/*end help*/
/*執行文本替換命令*/
void exec_replace(L ** lines, char * line)
{
char cmd[szLINE] = "", text[szLINE] = "", key[szLINE]="";
/*從命令行提取新舊關鍵字*/
sscanf(line, "%s %s %s", cmd, key, text);
/*執行文本替換命令*/
replace(*lines, key, text);
}/*end replace*/
/*執行退出命令*/
void exec_quit(L ** lines, char * line){exit(0);}
/*行編輯命令執行函數，順序與關鍵字表keywords一一對應*/
FUNC functions[CMDS]={
exec_quit, exec_help, exec_load, exec_save,
exec_view, exec_count, exec_append, exec_insert,
exec_erase, exec_edit, exec_lookup, exec_replace
};/*end functions*/
/*從行輸入中識別關鍵字，相當於parse*/
int identified(char * command, char * key)
{
int ln = 0, r = 0;
if(!command || !key) return 0;
ln = strlen(key);
r = memcmp(command, key, ln);
return r==0;
}/*end identified*/
/*主函數*/
int main(int argc, char * argv[])
{
L * lines = 0; char line[szLINE]=""; int a = 0, b = 0, i = 0; FUNC fun = 0;
/*列印歡迎信息*/
printf("Welcome to LINE EDITOR V1.0\nCommand [help] is available.\n");
/*如果帶主函數帶參數，則可以用於列印幫助，或者根據該參數載入一個文本文件*/
if(argc > 1) {
a = strcmp(argv[1], "--help");
b = strcmp(argv[1], "/h");
if(a && b)
load(&lines, argv[1]);
else{
exec_help(0, 0);
return 0;
}/*end if*/
}/*end if*/
/*主命令循環*/
for(;;) {
/*命令提示符中間是表示當前載入的文檔總共有多少行的意思*/
printf("\n
Ⅳ C語言常用詞彙及函數有那些
常用詞彙：
1、short：修飾int，短整型數據，可省略被修飾的int。
2、long：修飾int，長整型數據，可省略被修飾的int。
3、long long：修飾int，超長整型數據，可省略被修飾的int。
4、signed：修飾整型數據，有符號數據類型。
5、unsigned：修飾整型數據，無符號數據類型。
6、restrict:用於限定和約束指針，並表明指針是訪問一個數據對象的唯一且初始的方式。
7、return：用在函數體中，返回特定值（如果是void類型，則不返回函數值）。
8、continue：結束當前循環，開始下一輪循環。
9、break：跳出當前循環或switch結構。
10、goto：無條件跳轉語句。
11、if：條件語句，後面不需要放分號。
12、else：條件語句否定分支（與if連用）。
13、switch：開關語句（多重分支語句）。
14、case：開關語句中的分支標記，與switch連用。
15、default：開關語句中的「其他」分支，可選。
常用函數：
1、int isalpha(int ch) 若ch是字母('A'-'Z','a'-'z')，返回非0值,否則返回0。
2、int isalnum(int ch) 若ch是字母('A'-'Z','a'-'z')或數字('0'-'9')，返回非0值,否則返回0。
3、int abs(int i) 返回整型參數i的絕對值。
4、double cabs(struct complex znum) 返回復數znum的絕對值。
5、double fabs(double x) 返回雙精度參數x的絕對值。
6、long labs(long n) 返回長整型參數n的絕對值。
Ⅵ mongodb c driver支持非同步寫入嗎在官網上沒看到這項的說明，沒有的話要c語言怎樣才能進行操作
一、選擇通信協議
之前寫的項目並發量很小，http+keepalive完全可以搞定了，此項目http完全架不住，因為使用http協議傳遞數據，那麼數據最友好的格式就是json，但是親測過json的序列化和反序列化的耗時不可以忍受，並且隨著數據量的增大耗時也將成倍增長，項目的實際應用場景在寫操作時每條數據最大在10KB，因此http+json的組合被kill掉。
只能選擇常見的RPC方式，thrift、protobuf，protobuf需要自己實現tcp的通信方式，我們項目使用的是golang開發，這兩種方式之前都沒有在生產環境使用過，thrift僅僅自己玩過，因此就直接選擇了thrift，編碼的量級也相比protobuf降低好多，不過在代碼寫差不多的時候發現golang有基於protobuf開源的gRpc包。。。
通信協議選擇了thrift，基本確定了C+S的架構模式，Client負責業務端的訪問請求（還是走的http，貌似業務那幫人只會寫業務邏輯，完全不懂架構的東西，如果懂Client都可以幹掉，自己連Server就搞定了），Server負責Client通過thrift協議發來的請求，包括查詢DB和計算。
二、選擇資料庫
資料庫貌似沒得選啊，MySQL肯定是可以的，但是需要對一條完整的業務數據進行拆分到多個表中，這對高並發寫可能會有影響，一次要鎖住多個表的多條數據，對代碼的要求肯定很高，具體沒有嘗試過，只是猜測。MySQL的存儲方案一直都沒有被考慮過。
我們選擇的是mongodb，版本是3.2.11，NOSQL資料庫，支持嵌套文檔，所有的寫操作都可以通過upsert搞定，將並發寫的代碼要求交給mongo去完成，這樣大大降低了編碼的難度，mongo也屬於內存型資料庫吧，數據的讀寫速度還算可以（但是讀的速度還是達不到我們項目的要求。。）。
Ⅶ c語言：如何將字元串中指定的字元替換為另一個指定字元
需要准備的材料分別有：電腦、C語言編譯器。
1、首先，打開C語言編譯器，新建一個初始.cpp文件，例如：test.cpp。
Ⅷ 如何用c語言實現基於http的webservice
package com.yun.test;
import java.rmi.RemoteException;
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.message.PrefixedQName;
import org.apache.axis.message.SOAPHeaderElement;
import com.cezanne.golden.user.Exception;
import com.cezanne.golden.user.UserManagerServiceProxy;
import javax.xml.namespace.QName;
import java.net.MalformedURLException;
import javax.xml.rpc.ServiceException;
import javax.xml.soap.Name;
import javax.xml.soap.SOAPException;
public class testWebService {
public static String getResult() throws ServiceException, MalformedURLException, RemoteException, SOAPException
{
//標識Web Service的具體路徑
String endpoint = "WebService服務地址";
// 創建 Service實例
Service service = new Service();
// 通過Service實例創建Call的實例
Call call = (Call) service.createCall();
//將Web Service的服務路徑加入到call實例之中.
call.setTargetEndpointAddress( new java.net.URL(endpoint) );//為Call設置服務的位置
// 由於需要認證，故需要設置調用的SOAP頭信息。
Name headerName = new PrefixedQName( new QName("發布的wsdl里的targetNamespace里的url", "string_itemName") );
org.apache.axis.message.SOAPHeaderElement header = new SOAPHeaderElement(headerName);
header.addTextNode( "blablabla" );
call.addHeader(header);
// SOAPHeaderElement soapHeaderElement = new SOAPHeaderElement("發布的wsdl里的targetNamespace里的url", "SoapHeader");
// soapHeaderElement.setNamespaceURI("發布的wsdl里的targetNamespace里的url");
// try
// {
// soapHeaderElement.addChildElement("string_itemName").setValue("blablabla");
// }
// catch (SOAPException e)
// {
// e.printStackTrace();
// }
// call.addHeader(soapHeaderElement);
//調用Web Service的方法
org.apache.axis.description.OperationDesc oper;
org.apache.axis.description.ParameterDesc param;
oper = new org.apache.axis.description.OperationDesc();
oper.setName("opName");
param = new org.apache.axis.description.ParameterDesc(new javax.xml.namespace.QName("", "arg0"), org.apache.axis.description.ParameterDesc.IN, new javax.xml.namespace.QName(", "string"), java.lang.String.class, false, false);
param.setOmittable(true);
oper.addParameter(param);
param = new org.apache.axis.description.ParameterDesc(new javax.xml.namespace.QName("", "arg1"), org.apache.axis.description.ParameterDesc.IN, new javax.xml.namespace.QName(", "string"), java.lang.String.class, false, false);
param.setOmittable(true);
oper.addParameter(param);
param = new org.apache.axis.description.ParameterDesc(new javax.xml.namespace.QName("", "arg2"), org.apache.axis.description.ParameterDesc.IN, new javax.xml.namespace.QName(", "string"), java.lang.String.class, false, false);
param.setOmittable(true);
oper.addParameter(param);
oper.setReturnType(new javax.xml.namespace.QName(", "string"));
oper.setReturnClass(java.lang.String.class);
oper.setReturnQName(new javax.xml.namespace.QName("", "return"));
oper.setStyle(org.apache.axis.constants.Style.WRAPPED);
oper.setUse(org.apache.axis.constants.Use.LITERAL);
oper.addFault(new org.apache.axis.description.FaultDesc(
new javax.xml.namespace.QName("發布的wsdl里的targetNamespace里的url", "Exception"),
"Exception",
new javax.xml.namespace.QName("發布的wsdl里的targetNamespace里的url", "Exception"),
true
));
call.setOperation( oper );
call.setOperationName(new javax.xml.namespace.QName("發布的wsdl里的targetNamespace里的url", "opName"));
//調用Web Service,傳入參數
String res = ( String ) call.invoke( new Object[]("arg0","arg1"));
System.out.println("===============");
return res;
}
/**
* @param args
*/
public static void main(String[] args) {
try {
System.out.println(getResult());
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
} catch (ServiceException e) {
e.printStackTrace();
} catch (SOAPException e) {
e.printStackTrace();
}
}
}
Ⅸ 怎樣用C語言實現網路抓包
第一法則：站在巨人肩膀上 && 不要重復造輪子。
對於這種復雜的過程，第一選擇是使用現成的，節約時間，提升效率。
Wireshark（前稱Ethereal）是一個網路封包分析軟體。網路封包分析軟體的功能是擷取網路封包，並盡可能顯示出最為詳細的網路封包資料。Wireshark使用WinPCAP作為介面，直接與網卡進行數據報文交換。
網路封包分析軟體的功能可想像成 "電工技師使用電表來量測電流、電壓、電阻" 的工作 - 只是將場景移植到網路上，並將電線替換成網路線。在過去，網路封包分析軟體是非常昂貴，或是專門屬於營利用的軟體。Ethereal的出現改變了這一切。在GNUGPL通用許可證的保障范圍底下，使用者可以以免費的代價取得軟體與其源代碼，並擁有針對其源代碼修改及客制化的權利。Ethereal是目前全世界最廣泛的網路封包分析軟體之一。第二法則：學習 && 提升。
如果是單純的學習知識，可以直接嘗試寫一些具有部分功能的程序，過程會有點艱難，但非常有意義。學習網路編程，需要了解 開放系統互連參考模型的的七層每一層的意義以及現實當中實現的四層的網路協議。然後就可以知道抓包的包位於模型當中的傳輸層協議，包括UDP和TCP的協議。進一步要學習每種協議的格式，表頭，數據包等等。一句話，冰凍三尺非一日之寒。
Windows下的抓包及簡單的編程。
Windows2000在TCP/IP協議組件上做了很多改進，功能也有增強。比如在協議棧上的調整，增大了默認窗口大小，以及高延遲鏈接新演算法。同時在安全性上，可應用IPSec加強安全性，比NT下有不少的改進。
Microsoft TCP/IP 組件包含「核心協議」、「服務」及兩者之間的「介面」。傳輸驅動程序介面 (TDI) 與網路設備介面規范 (NDIS) 是公用的。 此外，還有許多用戶模型應用程序的更高級介面。最常用的介面是 Windows Sockets、遠程過程調用 (RPC) 和 NetBIOS。
Windows Sockets 是一個編程介面，它是在加州大學伯克利分校開發的套接字介面的基礎上定義的。它包括了一組擴展件，以充分利用 Microsoft Windows 消息驅動的特點。規范的 1.1 版是在 1993 年 1 月發行的，2.2.0 版在 1996 年 5 月發行。Windows 2000 支持 Winsock 2.2 版。在Winsock2中，支持多個傳輸協議的原始套接字，重疊I/O模型、服務質量控制等。
這里介紹Windows Sockets的一些關於原始套接字(Raw Socket)的編程。同Winsock1相比，最明顯的就是支持了Raw Socket套接字類型，通過原始套接字，我們可以更加自如地控制Windows下的多種協議，而且能夠對網路底層的傳輸機制進行控制。
1、創建一個原始套接字，並設置IP頭選項。
SOCKET sock;
sock = socket(AF_INET,SOCK_RAW,IPPROTO_IP);
或者：
s = WSASoccket(AF_INET,SOCK_RAW,IPPROTO_IP,NULL,0,WSA_FLAG_OVERLAPPED);
這里，我們設置了SOCK_RAW標志，表示我們聲明的是一個原始套接字類型。創建原始套接字後，IP頭就會包含在接收的數據中，如果我們設定 IP_HDRINCL 選項，那麼，就需要自己來構造IP頭。注意，如果設置IP_HDRINCL 選項，那麼必須具有 administrator許可權，要不就必須修改注冊表：
HKEY_LOCAL_
修改鍵：DisableRawSecurity（類型為DWORD），把值修改為 1。如果沒有，就添加。
BOOL blnFlag=TRUE;
setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&blnFlag, sizeof(blnFlag);
對於原始套接字在接收數據報的時候，要注意這么幾點：
a、如果接收的數據報中協議類型和定義的原始套接字匹配，那麼，接收的所有數據就拷貝到套接字中。
b、如果綁定了本地地址，那麼只有接收數據IP頭中對應的遠端地址匹配，接收的數據就拷貝到套接字中。
c、如果定義的是外部地址，比如使用connect()，那麼，只有接收數據IP頭中對應的源地址匹配，接收的數據就拷貝到套接字中。2、構造IP頭和TCP頭
這里，提供IP頭和TCP頭的結構：
// Standard TCP flags
#define URG 0x20
#define ACK 0x10
#define PSH 0x08
#define RST 0x04
#define SYN 0x02
#define FIN 0x01
typedef struct _iphdr //定義IP首部
{
unsigned char h_lenver; //4位首部長度+4位IP版本號
unsigned char tos; //8位服務類型TOS
unsigned short total_len; //16位總長度（位元組）
unsigned short ident; //16位標識
unsigned short frag_and_flags; //3位標志位
unsigned char ttl; //8位生存時間 TTL
unsigned char proto; //8位協議 (TCP, UDP 或其他)
unsigned short checksum; //16位IP首部校驗和
unsigned int sourceIP; //32位源IP地址
unsigned int destIP; //32位目的IP地址
}IP_HEADER;
typedef struct psd_hdr //定義TCP偽首部
{
unsigned long saddr; //源地址
unsigned long daddr; //目的地址
char mbz;
char ptcl; //協議類型
unsigned short tcpl; //TCP長度
}PSD_HEADER;
typedef struct _tcphdr //定義TCP首部
{
USHORT th_sport; //16位源埠
USHORT th_dport; //16位目的埠
unsigned int th_seq; //32位序列號
unsigned int th_ack; //32位確認號
unsigned char th_lenres; //4位首部長度/6位保留字
unsigned char th_flag; //6位標志位
USHORT th_win; //16位窗口大小
USHORT th_sum; //16位校驗和
USHORT th_urp; //16位緊急數據偏移量
}TCP_HEADER;
TCP偽首部並不是真正存在的，只是用於計算檢驗和。校驗和函數：
USHORT checksum(USHORT *buffer, int size)
{
unsigned long cksum=0;
while (size > 1)
{
cksum += *buffer++;
size -= sizeof(USHORT);
}
if (size)
{
cksum += *(UCHAR*)buffer;
}
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >>16);
return (USHORT)(~cksum);
}
當需要自己填充IP頭部和TCP頭部的時候，就同時需要自己計算他們的檢驗和。
3、發送原始套接字數據報
填充這些頭部稍微麻煩點，發送就相對簡單多了。只需要使用sendto()就OK。
sendto(sock, (char*)&tcpHeader, sizeof(tcpHeader), 0, (sockaddr*)&addr_in,sizeof(addr_in));
下面是一個示常式序，可以作為SYN掃描的一部分。
#include <stdio.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#define SOURCE_PORT 7234
#define MAX_RECEIVEBYTE 255
typedef struct ip_hdr //定義IP首部
{
unsigned char h_verlen; //4位首部長度,4位IP版本號
unsigned char tos; //8位服務類型TOS
unsigned short total_len; //16位總長度（位元組）
unsigned short ident; //16位標識
unsigned short frag_and_flags; //3位標志位
unsigned char ttl; //8位生存時間 TTL
unsigned char proto; //8位協議 (TCP, UDP 或其他)
unsigned short checksum; //16位IP首部校驗和
unsigned int sourceIP; //32位源IP地址
unsigned int destIP; //32位目的IP地址
}IPHEADER;
typedef struct tsd_hdr //定義TCP偽首部
{
unsigned long saddr; //源地址
unsigned long daddr; //目的地址
char mbz;
char ptcl; //協議類型
unsigned short tcpl; //TCP長度
}PSDHEADER;
typedef struct tcp_hdr //定義TCP首部
{
USHORT th_sport; //16位源埠
USHORT th_dport; //16位目的埠
unsigned int th_seq; //32位序列號
unsigned int th_ack; //32位確認號
unsigned char th_lenres; //4位首部長度/6位保留字
unsigned char th_flag; //6位標志位
USHORT th_win; //16位窗口大小
USHORT th_sum; //16位校驗和
USHORT th_urp; //16位緊急數據偏移量
}TCPHEADER;
//CheckSum:計算校驗和的子函數
USHORT checksum(USHORT *buffer, int size)
{
unsigned long cksum=0;
while(size >1)
{
cksum+=*buffer++;
size -=sizeof(USHORT);
}
if(size )
{
cksum += *(UCHAR*)buffer;
}
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >>16);
return (USHORT)(~cksum);
}
void useage()
{
printf("****************************************** ");
printf("TCPPing ");
printf(" Written by Refdom ");
printf(" Email: [email protected] ");
printf("Useage: TCPPing.exe Target_ip Target_port ");
printf("******************************************* ");
}
int main(int argc, char* argv[])
{
WSADATA WSAData;
SOCKET sock;
SOCKADDR_IN addr_in;
IPHEADER ipHeader;
TCPHEADER tcpHeader;
PSDHEADER psdHeader;
char szSendBuf[60]={0};
BOOL flag;
int rect,nTimeOver;
useage();
if (argc!= 3)
{ return false; }
if (WSAStartup(MAKEWORD(2,2), &WSAData)!=0)
{
printf("WSAStartup Error! ");
return false;
}
if ((sock=WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED))==INVALID_SOCKET)
{
printf("Socket Setup Error! ");
return false;
}
flag=true;
if (setsockopt(sock,IPPROTO_IP, IP_HDRINCL,(char *)&flag,sizeof(flag))==SOCKET_ERROR)
{
printf("setsockopt IP_HDRINCL error! ");
return false;
}
nTimeOver=1000;
if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&nTimeOver, sizeof(nTimeOver))==SOCKET_ERROR)
{
printf("setsockopt SO_SNDTIMEO error! ");
return false;
}
addr_in.sin_family=AF_INET;
addr_in.sin_port=htons(atoi(argv[2]));
addr_in.sin_addr.S_un.S_addr=inet_addr(argv[1]);
//
//
//填充IP首部
ipHeader.h_verlen=(4<<4 | sizeof(ipHeader)/sizeof(unsigned long));
// ipHeader.tos=0;
ipHeader.total_len=htons(sizeof(ipHeader)+sizeof(tcpHeader));
ipHeader.ident=1;
ipHeader.frag_and_flags=0;
ipHeader.ttl=128;
ipHeader.proto=IPPROTO_TCP;
ipHeader.checksum=0;
ipHeader.sourceIP=inet_addr("本地地址");
ipHeader.destIP=inet_addr(argv[1]);
//填充TCP首部
tcpHeader.th_dport=htons(atoi(argv[2]));
tcpHeader.th_sport=htons(SOURCE_PORT); //源埠號
tcpHeader.th_seq=htonl(0x12345678);
tcpHeader.th_ack=0;
tcpHeader.th_lenres=(sizeof(tcpHeader)/4<<4|0);
tcpHeader.th_flag=2; //修改這里來實現不同的標志位探測，2是SYN，1是FIN，16是ACK探測 等等
tcpHeader.th_win=htons(512);
tcpHeader.th_urp=0;
tcpHeader.th_sum=0;
psdHeader.saddr=ipHeader.sourceIP;
psdHeader.daddr=ipHeader.destIP;
psdHeader.mbz=0;
psdHeader.ptcl=IPPROTO_TCP;
psdHeader.tcpl=htons(sizeof(tcpHeader));
//計算校驗和
memcpy(szSendBuf, &psdHeader, sizeof(psdHeader));
memcpy(szSendBuf+sizeof(psdHeader), &tcpHeader, sizeof(tcpHeader));
tcpHeader.th_sum=checksum((USHORT *)szSendBuf,sizeof(psdHeader)+sizeof(tcpHeader));
memcpy(szSendBuf, &ipHeader, sizeof(ipHeader));
memcpy(szSendBuf+sizeof(ipHeader), &tcpHeader, sizeof(tcpHeader));
memset(szSendBuf+sizeof(ipHeader)+sizeof(tcpHeader), 0, 4);
ipHeader.checksum=checksum((USHORT *)szSendBuf, sizeof(ipHeader)+sizeof(tcpHeader));
memcpy(szSendBuf, &ipHeader, sizeof(ipHeader));
rect=sendto(sock, szSendBuf, sizeof(ipHeader)+sizeof(tcpHeader),
0, (struct sockaddr*)&addr_in, sizeof(addr_in));
if (rect==SOCKET_ERROR)
{
printf("send error!:%d ",WSAGetLastError());
return false;
}
else
printf("send ok! ");
closesocket(sock);
WSACleanup();
return 0;
}
4、接收數據
和發送原始套接字數據相比，接收就比較麻煩了。因為在WIN我們不能用recv()來接收raw socket上的數據，這是因為，所有的IP包都是先遞交給系統核心，然後再傳輸到用戶程序，當發送一個raws socket包的時候（比如syn），核心並不知道，也沒有這個數據被發送或者連接建立的記錄，因此，當遠端主機回應的時候，系統核心就把這些包都全部丟掉，從而到不了應用程序上。所以，就不能簡單地使用接收函數來接收這些數據報。
要達到接收數據的目的，就必須採用嗅探，接收所有通過的數據包，然後進行篩選，留下符合我們需要的。可以再定義一個原始套接字，用來完成接收數據的任務，需要設置SIO_RCVALL，表示接收所有的數據。
SOCKET sniffersock;
sniffsock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);
DWORD lpvBuffer = 1;
DWORD lpcbBytesReturned = 0 ;
WSAIoctl(sniffersock, SIO_RCVALL, &lpvBuffer, sizeof(lpvBuffer), NULL, 0, & lpcbBytesReturned, NULL, NULL);
創建一個用於接收數據的原始套接字，我們可以用接收函數來接收數據包了。然後在使用一個過濾函數達到篩選的目的，接收我們需要的數據包。
如果在XP以上的操作系統，微軟封殺了Raw Soccket，只能用wincpap之類的開發包了。