本學渣在《入侵防御技術及應用》這門課中的課程設計，希望能幫到你的課設或是專案

一、選題內容

1.1、問題描述：

基于網路嗅探，設計并實作一個簡單的網路預警系統，針對捕獲的資料包實作解碼/譯碼和特征檢測，

1.2、要求：

采用文本界面或圖形界面下進行互動的作業方式，完成如下功能：

1.2.1、界面方面：

可配置、可顯示系統運行結果，

1.2.2、功能設計：

抓取本機在網路中的通信資料，包括協議型別、源和目的地址、埠、資料包大小等，
支持應用層協議分析，至少包括 HTTP、FTP、SMTP 三種協議，
支持 SSL/TLS，
支持基于 MAC 地址、IP 地址、協議型別、埠、應用層協議特征的特征檢測，
支持實時統計分析，根據檢測結果，實時報警，

二、實驗環境

編程語言：本程式采用C#語言設計
作業系統：Windows10
編譯器：Microsoft Visual Studio 2019

三、方案設計

3.1、總體功能流程圖設計

3.2、抓包功能

通過Winpcap實作在Windows操作平臺上對底層資料包的捕獲以及過濾，WinPcap 是 BPF 模型和 Libpcap 函式庫在 Windows 平臺下網路資料包捕獲和網路狀態分析的一種體系結構，這個體系結構是由一個核心的包過濾驅動程式，一個底層的動態連接庫 Packet.dll 和一個高層的獨立于系統的函式庫 Libpcap 組成，C#函式庫SharpPcap以及PacketDotNet就是利用封裝好的winpcap進行抓包，它提供了許多基于資料包packet的功能函式介面，

3.3、應用層協議分析

利用捕獲到的傳輸層資料包，分析其對應的埠號，再根據特定埠號判斷協議型別，通過每個應用層協議報文格式進一步分析其欄位的值，通過庫函式自帶的封裝好的資料包函式介面可以實作對相應不同應用層協議型別的資料包內容的決議，

3.4、TLS/SSL

由于Packet.Net以及SharpPcap并沒有HTTPS資料包的決議，所以只能自己設計出針對TLS或SSL的資料包內容決議，HTTPS埠號默認是443，通過對埠的分析得知資料包是否是HTTPS，以及對資料欄位格式的分析可以決議出HTTPS資料包的諸如內容型別、協議版本、資料長度等資訊

3.5、網路攻擊的特征檢測

本程式根據入侵檢測實驗課中學習到的SYN-FLOOD攻擊以及NTP反射放大攻擊的特征進行了檢測，在本次實驗中用于測驗攻擊的程式中，Syn-Flood攻擊后的資料包的源ip地址是隨機不確定的，而Ntp反射攻擊后的資料包的源ip地址是確定的，也就是ntp服務器，

3.5.1、Syn-Flood攻擊的特征檢測

Syn-Flood通過判斷捕捉到的資料包對應的Tcp協議標志位是否是SYN以及目的地址是否是本機IP，其次在當前捕捉的資料報緩沖區陣列中占比是否達到百分之七十以上來判斷，
其次，由于資料包緩沖區是每隔50ms讀取一次，在事先測量攻擊時觀察到50ms內收到攻擊的資料包數量是有一定要求的，即倘若50ms內讀取到的資料包內容較少則并不鑒定為攻擊，
流程圖設計如下：

3.5.2、Ntp放大反射攻擊的特征檢測

Ntp放大反射攻擊是通過分析資料包中UDP協議對應的源埠號是否是123，并且資料包的源ip地址是否一致的（均為Ntp Server服務器IP地址），以及資料包的目標地址是否是本機來判斷，如果當前資料包緩沖區陣列中滿足條件的占比達到百分之七十以上則判斷主機受到了Ntp放大反射攻擊，與Syn-Flood相同，倘若當前讀取到的資料包數量較低則不鑒定為攻擊，
流程圖設計如下：

3.6、實時統計分析

通過呼叫WinForm中的DataGridView視窗與設計更新并讀取資料包多執行緒的委托函式來實作，DataGridView是WinForm中自帶的以表格形式顯示資料的視窗控制元件，提供了實時顯示的函式介面，通常這個函式是與執行緒聯合使用的，在本程式中，設計了一個資料包陣列緩沖區，讀取資料緩沖區的執行緒每隔50ms更新一次，每次讀取時從當前緩沖區中統計每個資料包的協議內容、個數等資訊，并且通過WinForm中提供的函式介面Invoke實作將讀取到的統計資訊實時顯示到DataGrid表格中，

四、系統實作

4.1、抓包功能

C#的SharpPcap庫中提供了一個CaptureDeviceList類，該類是用來獲取本地已有的網路配接器的，在實體化它的一個物件之后，呼叫它的一個Instance引數可以獲取到網路配接器device，
在捕捉資料包之前，需要選擇資料采集模式，device提供了Promiscuous和Normal兩種模式，前者是混雜模式，它能夠接受所有經過它的資料流，無論這個資料流的目的地址是不是它，它都會接受這個資料包，后者普通模式是只接受目的地址是它的包而不接受其他的地址的網路資料包，
定義一個型別為資料包RawPacket的緩沖區鏈表，在開啟監聽事件時，將捕獲到的資料包存入資料包緩沖區中，由于該操作是異步的程序，在當前執行緒對資料包緩沖區執行操作時，其他執行緒是不能訪問的，在更新完緩沖區陣列后釋放該執行緒，更新周期設定為50ms，
每個緩沖區鏈表中存放的資料包格式為Packet，將該Packet物件作為決議函式的引數進行呼叫并創建各網路層協議的物件，例如資料鏈路層的物件為Ethernet、網路層的物件為Ipv4、傳輸層物件為UDP，如果根據Packet物件創建的新的各層次的物件并非null則表明此時捕捉到的資料包就是對應層次的協議，在每次更新資料包緩沖區時，首先通過庫函式中提供的鏈路層的函式介面實作對緩沖區中每個資料包的鏈路層決議，決議出其源mac地址以及目的mac地址等資訊，其次根據資料包再決議其網路層的協議、IP地址、版本資訊，然后再決議其傳輸層資訊，包括分析TCP還是UDP以及埠資訊，
C#WinForm表單中提供了結點樹控制元件，捕獲到的資料包個層次資訊均是通過結點數顯示的，利用該控制元件可以實作類似于Wireshark軟體里決議資料包各層次內容的效果，

4.2、應用層協議分析

從傳輸層的資料包區分應用層協議，首先判斷其傳輸層的埠，例如HTTP的埠號為80、SMTP的埠號為25、FTP的埠號為21或20，在分析出屬于哪一種應用層協議后，再根據捕獲到的資料包的位元組陣列內容進行決議，通過庫函式中提供的函式實作，其引數即為對應的位元組陣列，回傳值為節點樹node，最后再將決議出來的node物件作為子節點添加到表單中的結點數父類中顯示，

4.3、TLS/SSL

由于本程式中庫函式并沒有提供HTTPS決議的函式，所以我根據資料包的位元組陣列自行進行了簡單的決議，在資料包的傳輸層物件中分析其埠號的值，倘若為443則判斷是HTTPS協議，根據資料包位元組陣列中特定位置的欄位值來決議出對應的內容，HTTPS位元組陣列的資料載體中第一個位元組代表內容型別Content Type，這是握手層，20代表Change Cipher Spec更改加密規范協議，21代表Alert警告協議，22代表HandShake握手協議，23代表Application Data應用資料協議，資料載體中第二個和第三位元組代表協議版本資訊，例如0303欄位代表協議版本為TLSv1.2，0301代表TLSv1.0等，資料載體中第四個位元組和第五個位元組代表資料段的長度，后面欄位的內容是詳細的封裝資訊，包括證書以及秘鑰等，

4.4、網路攻擊的特征檢測

根據分析抓包程序中更新的資料包緩沖區來實作，由于該資料包緩沖區是實時更新的，因此針對緩沖區的檢測也是實時的，

4.4.1、Syn-Flood攻擊的特征檢測

定義一個int陣列，長度為當前資料包緩沖區的長度，用于存放當前資料包陣列中TCP報文內容的標志為SYN的個數，再定義一個string陣列，用于存放緩沖區資料包中的目的地址，如果該資料包緩沖區中滿足tcp標志位為syn且目的ip地址為本機的比例達到百分之七十以上則判斷受到攻擊，利用WinForm中的MessageBox空間進行彈窗提示，

4.4.2、Ntp放大反射攻擊的特征檢測

定義一個int陣列，用于存放資料包緩沖區陣列中UDP對應的源埠是否為123，定義兩個string陣列，一個用于存放資料包目的IP地址，另一個用于存放源地址，找出源地址陣列中占比最大的值，用于判斷是否是Ntp服務器的地址，在上述中提到過，本程式測驗的Syn攻擊程式發送的資料包中的源地址是隨機的，而NTP攻擊程式中由于本機訪問一次NTP服務器，NTP服務器變以數十倍的數量發送相應資料包，所以本測驗的NTP攻擊中源地址均是固定的NTP服務器的地址，通過判斷資料包緩沖區中，滿足發送的目的地址是本機、源地址是本次緩沖區中源地址重復次數最多的、UDP對應的埠號是123這三個條件的占比達到百分之七十以上則彈窗提示收到NTP攻擊，

4.5、實時統計的實作

定義一個引數型別為資料包的委托函式，用于實時顯示到DataGridView表中，在每次更新資料包緩沖區的執行緒運行時，通過擁有控制元件的基礎視窗句柄用指定的資料包鏈表執行事先定義好的用于顯示的委托函式，根據資料包和索引序列號生成相應的字串顯示到視窗串列中，C#的DataGridView中提供了ADD函式的介面，該函式的引數是用于顯示到表格中每一行的資料陣列，通過決議資料包后的資訊打包成陣列后呼叫DataGridView控制元件的ADD函式將該資料包添加到新的一行中去，

五、程式演示

5.1、抓包演示

選擇網路配接器，這里選擇的是無線網

選擇掃描模式

SharpPcap庫中提供了過濾規則的函式，通過輸入規則可實作過濾

點擊開始按鈕后執行抓包，結果如下圖，包含各個層次的資訊以及資料包內容

在左下角結點樹中可以展開詳細的各層次的資訊:

傳輸層UDP的內容如下：

5.2、應用層協議決議演示

5.2.1、FTP

抓取到的FTP資料包如下

5.2.2、SMTP

SMTP資料包是通過在CMD控制臺中輸入telnet smtp.qq.com 25可以捕捉到SMTP的資料包，因為SMTP的埠號為25，在過濾器中設定過濾規則后顯示的內容決議如下：

5.2.3、HTTP

在正常訪問網頁后可以捕捉到Http資料包，其決議內容如下

5.3、TLS/SSL演示

5.4、網路攻擊

本實驗中用于測驗攻擊的程式是在入侵檢測DOS攻擊實驗課中使用到的兩個檔案

5.4.1、Syn-Flood攻擊及預警演示

在cmd控制臺中使用事先準備的syn-flood攻擊軟體在程式中可以捕捉到Syn-Flood攻擊后的資料包以及彈窗提示如下：

5.4.2、Ntp放大反射攻擊及預警演示

在CMD中開始ntp攻擊

捕捉到的資料包以及預警提示如下：

5.5、實時統計演示

本程式中實作了一個實時統計資料包協議型別對應數量的監控視窗，如下：

六、總結

在本實驗中，一大難點在于為了實作捕捉到資料包能夠實時顯示，需要動用多執行緒呼叫以及委托函式的相關知識，由于事先對他們的操作并不是很熟練，導致在這個地方卡了不少時間，最后在深入理解了相關實體后才自己寫出來，
其次，關于SSL以及TLS要實作的功能理解出錯了，本次實驗中TLS以及SSL應該是要決議其簽名以及加密內容的，而我只實作了特定欄位值的決議，在預警功能這一方面，我事先并沒有考慮到分析埠以及標志位等資訊的判斷，只考慮了IP地址以及占比，導致一開始的預警系統雖然能夠檢測到相應的攻擊但是誤報率很高，具體體現在我正常瀏覽網頁時也會提示收到攻擊，在后來加上對埠號以及標志位的判斷后誤誤報率大大降低，
對預警系統的實作只考慮到了兩種攻擊的情況，考慮到的方面較少，并且經過老師提醒后我才了解NTP反射的源主機IP地址是可以偽造的，所以相關函式還需要一進步改進，本程式只對Syn-Flood以及NTP放大反射攻擊進行了特征檢測，此外其他攻擊的特征檢測并沒有考慮，

七、部分代碼展示

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using SharpPcap;
using SharpPcap.LibPcap;//參考SharpPcap
using SharpPcap.WinPcap;
using SharpPcap.AirPcap;
using System.Net.NetworkInformation;
using PacketDotNet;
using System.Management;
using System.Net;
using System.Net.Sockets;

namespace MySniffer
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
            pktInfo = new PacketInfo(this.treeView1);
            IpAddress = GetLocalIP();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            loadDevice();//加載表單時加載網卡
            Control.CheckForIllegalCrossThreadCalls = false;
        }
        public void DetecetSynFlood(List<RawCapture> bufferList)
        {
            try
            {
                if (StartMessageBox == false)
                {
                    if (bufferList.Count < 30)
                    {
                        return;
                    }
                    int N = bufferList.Count;
                    string[] DestPortArr = new string[N];
                   int[] SourceSYN = new int[N];
                    for (int i = 0; i < N; i++)
                    {
                            Packet pp = Packet.ParsePacket(bufferList[i].LinkLayerType,
                          bufferList[i].Data);
                            IpPacket ipp = IpPacket.GetEncapsulated(pp);
                            if(ipp!=null)
                            {
                                DestPortArr[i] = ipp.DestinationAddress.ToString();
                            }
                            TcpPacket tp = TcpPacket.GetEncapsulated(pp);
                            
                            if (tp!=null)
                            {
                                bool tempbool = tp.Syn;
                                SourceSYN[i] = (tempbool == true ? 1 : 0);
                            }                  
                    }
                    int temp2 = 0;
                    for (int i = 0; i < N; i++)
                    {
                        if ((DestPortArr[i] == IpAddress)&& SourceSYN[i]==1)
                        {
                            temp2++;
                        }
                    }
                    double y = ((double)(temp2)) / ((double)(N));
                    if (y >= 0.7)
                    {
                        DialogResult answer;
                        answer = MessageBox.Show
                            ("檢測到SYN FLOOD攻擊");
                        if (answer == DialogResult.OK)
                        {
                            StartMessageBox = false;
                        }
                        else
                        {
                            StartMessageBox = true;
                        }
                    }
                }

            }
            catch (Exception)
            {

            }
            
          
        }
        public void DetecetNtpReply(List<RawCapture> bufferList)
        {
            if (StartMessageBox == false)
            {
                if (bufferList.Count < 5)
                {
                    return;
                }
                int N = bufferList.Count;
                string[] DestPortArr = new string[N];
                string[] SourcePortArr = new string[N];
                int[] SourcePort = new int[N];
                for (int i = 0; i < N; i++)
                {
                    Packet pp = Packet.ParsePacket(bufferList[i].LinkLayerType,
                         bufferList[i].Data);
                    IpPacket ip = IpPacket.GetEncapsulated(pp);
                    if(ip!=null)
                    {
                        DestPortArr[i]=ip.DestinationAddress.ToString();
                    }
                    UdpPacket up = UdpPacket.GetEncapsulated(pp);
                    if (up != null)
                    {
                        string temps =up.SourcePort.ToString();
                        SourcePort[i] = (temps == "123" ? 1 : 0);
                    }
                }
                var d = from n in SourcePortArr
                        group n by n into g
                        select new { Key = g.Key, Count = g.Count() };
                //找到出現次數最多的那個次數
                var max = d.Max(a => a.Count);
                int temp2 = 0;
                //根據最大的次數 查找元素
                var maxItems = from m in d where m.Count == max select m.Key;
                string Source = maxItems.First();
                for (int i = 0; i < N; i++)
                {
                    if ((SourcePortArr[i] == Source) && (DestPortArr[i] == IpAddress)
                        &&(SourcePort[i]==1))
                    {
                        temp2++;
                    }
                }
                double y = ((double)(temp2)) / ((double)(N));

                if (y >= 0.7)
                {
                    DialogResult answer;
                    answer = MessageBox.Show
                        ("檢測到NTP反射放大攻擊");
                    if (answer == DialogResult.OK)
                    {
                        StartMessageBox = false;
                    }
                    else
                    {
                        StartMessageBox = true;
                    }
                }
            }


        }
        string IpAddress = "";//獲取本機IP地址
        ICaptureDevice device;// 定義設備
        bool StartMessageBox = false;
        List<RawCapture> packetList = new List<RawCapture>();//捕獲的資料串列
        List<RawCapture> bufferList;//快取串列
        Thread AnalyzerThread;//分析資料的執行緒
        Thread MonitorThread;//監控執行緒
        object threadLock = new object();//執行緒鎖定
        object MonitorLock = new object();//監控執行緒鎖定
        bool isStartAnalyzer;//用于表示是否啟動分析執行緒的標志
        DeviceMode devMode = DeviceMode.Promiscuous;//資料采集模式，默認為混雜模式
        int readTimeOut = 50;//設定讀取的時間延遲
        delegate void DataGridRowsShowHandler(RawCapture packet);
        public static string GetLocalIP()
        {
            /* var address = NetworkInterface
            .GetAllNetworkInterfaces()
            .Where(i => i.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)
            .SelectMany(i => i.GetIPProperties().UnicastAddresses)
            .Where(a => a.Address.AddressFamily == AddressFamily.InterNetwork)
            .Select(a => a.Address.ToString())
            .ToList().Last();
             return address.ToString();*/
            string AddressIP = string.Empty;
            foreach (IPAddress _IPAddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
            {
                if (_IPAddress.AddressFamily.ToString() == "InterNetwork")
                {
                    AddressIP = _IPAddress.ToString();
                }
            }
            return AddressIP;
        }

        //定義委托函式，用于實時顯示捕獲到的資料包
        DataBuilder rowsBulider = new DataBuilder();
        PacketInfo pktInfo;//用于分析資料包的類
        uint packetIndex = 0;
        private MonitorForm monitorform;
        int[][] DataCache = new int[4][];
        private void loadDevice()// 獲取網卡方法
        {
            comDeviceList.ComboBox.DisplayMember = "Text";
            comDeviceList.ComboBox.ValueMember = "Value";
            CaptureDeviceList deviceLst = CaptureDeviceList.Instance;
            //獲取主機網卡資訊
            foreach (ICaptureDevice dev in deviceLst)
            {
                // AirPcap devices cannot disable local capture
                if (dev is AirPcapDevice)
                {
                    Console.WriteLine(dev.ToString());
                }
                else if (dev is WinPcapDevice)
                {
                    ClsComboboxItem clsCbxItem = new ClsComboboxItem();
                    clsCbxItem.Text = ((WinPcapDevice)dev).Interface.FriendlyName
                        + "  " + dev.Description.Split('\'')[1];
                    clsCbxItem.Value = dev;
                    comDeviceList.ComboBox.Items.Add(clsCbxItem);
                }
                else if (dev is LibPcapLiveDevice)
                {
                    Console.WriteLine(dev.ToString());
                }
            }
        }
        //選擇網卡
        private void comDeviceList_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {

                device = CaptureDeviceList.Instance[comDeviceList.SelectedIndex];
            }
            catch(Exception)
            {

            }
           
        }
        private void UIConfig(bool isStart)
        {
            //設定UI界面按鈕的可選性
            comDeviceList.Enabled = !isStart;
            comFilter.Enabled = !isStart;
            btnStart.Enabled = !isStart;
            btnStop.Enabled = isStart;
            btnOpen.Enabled = !isStart;
            btnSave.Enabled = !isStart;
            checkBox1.Enabled = !isStart;
        }
        public void Clear()
        {
            //清空串列
            if (packetList != null)
            {
                packetList.Clear();
            }
            if (bufferList != null)
            {
                bufferList.Clear();
            }
            dataGridPacket.Rows.Clear();
            treeView1.Nodes.Clear();
            richTextBox1.Text = "";
            packetIndex = 0;
        }
       private void checkBox1_CheckedChanged(object sender, EventArgs e)
        {
            //設定更改的資料采集模式
            if(checkBox1.SelectedItem =="混雜模式")
            {
                devMode = DeviceMode.Promiscuous;
            }
            else if(checkBox1.SelectedItem == "普通模式")
            {
                devMode = DeviceMode.Normal;
            }
            else
            {
                devMode = DeviceMode.Promiscuous;
            }
            //混雜模式：能夠接受所有經過它的資料流，
            //不論這個資料流的目的地址是不是它，它都會接受這個資料包

            //普通模式：只接受目的地址是它的包而不接受其他的地址的網路資料包
        }
        /// <summary>
        /// 啟動網卡
        /// </summary>
        private void Start()
        {
            if (device == null || device.Started)
                return;
            bufferList = new List<RawCapture>();
            DataCache=InitArr(DataCache);
            //構造快取串列
            Clear();//清理原有的資料
            isStartAnalyzer = true;//開始決議標志位置true
            StartAnalyzer();//啟動分析執行緒

            try
            {
                device.OnPacketArrival += new PacketArrivalEventHandler(device_OnPacketArrival);
                //默認使用混雜模式，超時50ms
                device.Open(devMode, readTimeOut);
                //通過選用的模式以及選擇的每捕獲資料包的延時來呼叫開啟設備的函式
                device.Filter = comFilter.Text;
                //設定過濾規則
                device.StartCapture();
                //呼叫開始捕捉資料包的函式
                UIConfig(true);
                 //設定UI控制元件的可選性
            }
            catch (Exception ex)
            {
                //意外情況處理
                MessageBox.Show(ex.Message);
                UIConfig(false);
            }

        }
        /// <summary>
        /// 啟動分析
        /// </summary>
        private void StartAnalyzer()
        {
            AnalyzerThread = new Thread(new ThreadStart(analysrThreadMethod));
            //構造分析資料的執行緒
            AnalyzerThread.IsBackground = true;
            //設定為后臺運行的執行緒
            AnalyzerThread.Start();
            //決議執行緒開始執行
      

        }
        public void StartMonitor()
        {
            MonitorThread = new Thread(new ThreadStart(MonitorMethod));
            MonitorThread.IsBackground = true;
            MonitorThread.Start();
        }

        /// <summary>
        /// 停止
        /// </summary>
        private void Stop()
        {
            try
            {
                if (device != null && device.Started)
                {
                    //如果當前網路配接器存在并且正在作業，則將它暫停
                    device.StopCapture();
                    device.Close();
                }
                isStartAnalyzer = false;
                //將決議標志位置false
                if (AnalyzerThread !=null && AnalyzerThread.IsAlive)
                {
                    AnalyzerThread.Abort();
                    //若當前決議行程存在且正在作業則強制終止該執行緒
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);//例外情況處理
            }
            UIConfig(false);
        }

        void device_OnPacketArrival(object sender, CaptureEventArgs e)
        {
            lock (threadLock)
            {
                bufferList.Add(e.Packet);
            }
            //事件threadLock沒有被鎖定的話則lock鎖定它，否則一直等待，直至事件被釋放，
            //lock以后在給資料包緩沖區鏈表添加資料包的期間其他執行緒不能執行此操作也不能呼叫該事件
            //執行完之后釋放事件，并且添加函式的操作可以被其他執行緒訪問，
        }
        //資料分析執行緒
        private void analysrThreadMethod()
        {
            while (isStartAnalyzer)
            {
                //只要開始決議的標志位為true，決議會一直進行
                bool isShoudSleep = true;
                //設定執行緒睡眠標志位
                lock (threadLock)
                {
                    if (bufferList.Count != 0)
                        isShoudSleep = false;
                    //當執行緒緩沖區中沒有資料時，睡眠標志設定為false
                }
                if (isShoudSleep)
                {
                    Thread.Sleep(200);
                    //如果睡眠標志設定為true，則讓當前執行緒睡眠200ms
                }
                else
                {
                    //如果執行緒此時處于活躍狀態，即資料包快取中含有資料，則將資料包添加到鏈表中
                    List<RawCapture> tmpPacketList;
                    lock (threadLock) //獲取資料
                    {
                        tmpPacketList = bufferList;
                        DetecetSynFlood(bufferList);
                        DetecetNtpReply(bufferList);
                        //將當前資料包快取區的資料保存到總資料包鏈表中
                        bufferList = new List<RawCapture>();
                        packetList.AddRange(tmpPacketList);
                    }
                    //將暫存緩沖區中的每個資料包作為實參添加到顯示函式的引數串列中
                    foreach (var i in tmpPacketList)
                    {
                        this.Invoke(new DataGridRowsShowHandler(ShowDataRows), i);
                        //呼叫委托，實作界面中的實時顯示            
                    }
                }
            }
        }
        public void MonitorMethod()
        {
            while (isStartAnalyzer)
            {
                bool isShoudSleep = true;
                lock (MonitorLock)
                {
                    if (bufferList.Count != 0)
                        isShoudSleep = false;
                    //當執行緒緩沖區中沒有資料時，睡眠標志設定為false
                }
                if (isShoudSleep)
                {
                    Thread.Sleep(200);
                    //如果睡眠標志設定為true，則讓當前執行緒睡眠200ms
                }
                else
                {
                    monitorform.UpdateDatagrid(DataCache);
                }
            }
        }
        public int[][] InitArr(int[][] arr)
        {
            int[] Eth = new int[7];
            int[] Net = new int[6];
            int[] Tra = new int[2];
            int[] APP = new int[8];
            InitArr(Eth);
            InitArr(Net);
            InitArr(Tra);
            InitArr(APP);
            arr = new int[][] { Eth, Net, Tra, APP };
            return arr;
        }
        public void InitArr(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] = 0;
            }
        }
        //根據資料包顯示到DataGrid串列中的函式
        private void ShowDataRows(RawCapture packet)
        {
            try
            {
                //根據資料包和索引序列號生成相應的字串顯示到視窗串列中
                string[] Row_Arr = rowsBulider.Row(packet, ++packetIndex);
                int[][] data = rowsBulider.Monitor(packet);
                AddData(DataCache,data);
                dataGridPacket.Rows.Add(Row_Arr);
                //加載DataGridRows，添加到串列中去;
            }
            catch (Exception ex)
            {
                MessageBox.Show("加載DataGridRows失敗");//例外情況的處理 
            }
        }
        private void AddData(int[][] Data1,int[][]Data)
        {
            for(int i=0;i<Data1.Length;i++)
            {
                for(int j=0;j<Data1[i].Length;j++)
                {
                    Data1[i][j]+= Data[i][j];
                }
            }
        }
        private void btnStart_Click(object sender, EventArgs e)
        {
            Start();//點擊開始按鈕執行開始函式
        }

        private void btnStop_Click(object sender, EventArgs e)
        {
            Stop();//點擊停止按鈕執行停止函式
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            Stop();//關閉程式時也呼叫停止函式
        }

        private void dataGridPacket_CellMouseDown
            (object sender, DataGridViewCellMouseEventArgs e)
        {
            if (e.RowIndex == -1)
                return;
            if (e.Button == MouseButtons.Right)//右擊也可選中
            {
                dataGridPacket.Rows[e.RowIndex].Selected = true;
            }
            selectDataGridRow(e.RowIndex);
        }
        /// <summary>
        /// 選中一行
        /// </summary>
        /// <param name="index">選定的資料行索引值</param>
        private void selectDataGridRow(int index)
        {
            if (index < 0 || index > dataGridPacket.Rows.Count)
                return;
            //獲取資料包位置
            int i = Convert.ToInt32(dataGridPacket.Rows[index].Cells[0].Value.ToString());
            //第一列單元格的內容：捕獲到的資料包的標號
            if (i > packetList.Count)
                return;
            RawCapture rawPacket = packetList[i - 1];
            //根據選定的序號索引值定為到想要讀取的資料包
            treeView1.Nodes.Clear();
            //清空當前視窗頁面下的協議樹
            pktInfo.GetProtcolTree(rawPacket);
            richTextBox1.Text = HexConvert.ConvertToHexText(rawPacket.Data);
            //以十六進制在視窗右下角中顯示資料包的內容，以及對應的ASCLL碼值
        }
        private void btnSave_Click(object sender, EventArgs e)
        {
            SaveFileDialog sd = new SaveFileDialog();
            sd.Filter = "Pcap檔案|*.pcap";
            // pcap檔案是常用的資料報存盤格式
            if (sd.ShowDialog() == DialogResult.OK)
            {
                var offDev = new SharpPcap.LibPcap.CaptureFileWriterDevice(sd.FileName);
                foreach (var i in packetList)
                {
                    offDev.Write(i);
                }
                //將資料包鏈表中的資料以PAP檔案格式存盤到指定的路徑中
                MessageBox.Show("檔案保存成功", "提示", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        //打開檔案
        private void btnOpen_Click(object sender, EventArgs e)
        {
            OpenFileDialog od = new OpenFileDialog();
            od.Filter = "pcap檔案|*.pcap";
            if (od.ShowDialog() == DialogResult.OK)
            {
                //清空串列
                Clear();
                ICaptureDevice offDev = new SharpPcap.LibPcap.
                    CaptureFileReaderDevice(od.FileName);
                //通過pap檔案讀取的網路配接器
                RawCapture tempPacket;
                offDev.Open();
                while ((tempPacket = offDev.GetNextPacket()) != null)
                {
                    packetList.Add(tempPacket);
                    ShowDataRows(tempPacket);
                    //從pap檔案中讀取資料包資訊
                }
                offDev.Close();
            }
        }

        private void comFilter_Click(object sender, EventArgs e)
        {

        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            Clear();
            //清空
        }

        private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
        {

        }

        private void comDeviceList_Click(object sender, EventArgs e)
        {

        }

        private void toolStripTextBox1_Click(object sender, EventArgs e)
        {

        }

        private void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            if(monitorform==null||monitorform.isclosed==true)
            {
                monitorform = new MonitorForm(DataCache);
                monitorform.Show();
                monitorform.UpdateDatagrid(DataCache);
                StartMonitor();
            }
            else
            {
                monitorform.UpdateDatagrid(DataCache);
                StartMonitor();
            }
           
        }

        private void checkBox1_Click(object sender, EventArgs e)
        {

        }

        private void dataGridPacket_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {

        }
    }
}