예제 #1
0
        public static void Trace(Packet packet, PacketMonitorForm PacketMonitor)
        {
            IpPacket  ipPacket  = null;
            TcpPacket tcpPacket = null;

            try
            {
                ipPacket = PacketDotNet.IpPacket.GetEncapsulated(packet);
                if (ipPacket == null || ipPacket.Version == IpVersion.IPv6)
                {
                    return;
                }
                tcpPacket = PacketDotNet.TcpPacket.GetEncapsulated(packet);
                if (tcpPacket == null)
                {
                    return;
                }


                long Key = ipPacket.SourceAddress.Address + tcpPacket.SourcePort + ipPacket.DestinationAddress.Address + tcpPacket.AcknowledgmentNumber;

                if (isReassembledPacketOfPostRequest(ipPacket, tcpPacket))
                {
                    PacketReassemble(Key, tcpPacket);
                    MailList[Key].TimeToLive = 0;

                    // Var_PushFlag == true 表示資料都已經擷取完全
                    if (MailList[Key].Var_PushFlag == true)
                    {
                        var Mail = MailList[Key];
                        foreach (var Data in Mail.PostRequestDataList)
                        {
                            Mail.PostRequestData += new string(Data);
                        }
                        foreach (var Data in Mail.VarDataList)
                        {
                            Mail.VarData += new string(Data);
                        }

                        DoSomething(Mail, PacketMonitor);
                        MailList.Remove(Key);
                    }
                }
                else if (isPostRequest(tcpPacket))
                {
                    MailList.Add(Key, new HttpMail(ipPacket, tcpPacket));
                }
                else
                {
                    return;
                }

                AddMailLiveTime();
            }
            catch
            {
                Console.WriteLine();
                return;
            }
        }
        static void Program_OnPacketArrival(object sender, CaptureEventArgs e)
        {
            Packet packet = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
            // получение только TCP пакета из всего фрейма
            var tcpPacket = TcpPacket.GetEncapsulated(packet);
            // получение только IP пакета из всего фрейма
            var ipPacket = IpPacket.GetEncapsulated(packet);

            if (tcpPacket != null && ipPacket != null)
            {
                // IP адрес получателя
                var dstIp = ipPacket.DestinationAddress.ToString();
                // порт отправителя
                var srcPort = tcpPacket.SourcePort.ToString();
                dataPacket = tcpPacket.ParentPacket.ToString();

                if (dataPacket != null)
                {
                    foreach (var port in buff)
                    {
                        if (srcPort == port)
                        {
                            Int32.TryParse(portOfProces, out portForBloc);
                            packageDetected = true;
                        }
                    }
                }
            }
        }
예제 #3
0
 public PackageDetail(TcpPacket tcpPacket, UdpPacket udpPacket, IpPacket ipPacket)
 {
     Id        = Interlocked.Increment(ref _newId);
     TcpPacket = tcpPacket;
     UdpPacket = udpPacket;
     IpPacket  = ipPacket;
 }
예제 #4
0
        /// <summary>
        /// Runs the scenario.
        /// </summary>
        public override void Run()
        {
            Host H1 = new Host("H1"), H2 = new Host("H2");

            H1.RegisterInterface(new Interface(new Nic(
                                                   new MacAddress("AA:AA:AA:AA:AA:AA")), "eth0", "192.168.1.2/24",
                                               "192.168.1.1"));
            H2.RegisterInterface(new Interface(new Nic(
                                                   new MacAddress("BB:BB:BB:BB:BB:BB")), "eth0", "192.168.1.3/24",
                                               "192.168.1.1"));
            // Attach both stations to a "thick" Ethernet 10BASE5 cable.
            new C10Base5(250)
            .Pierce(0, H1.Interfaces["eth0"].Nic.Connector)
            .Pierce(250, H2.Interfaces["eth0"].Nic.Connector);

            var dummyPacket1 = new IpPacket(new IpAddress("192.168.1.3"),
                                            new IpAddress("192.168.1.2"), IpProtocol.Tcp, new byte[] { 1, 2, 3, 4 });
            var dummyPacket2 = new IpPacket(new IpAddress("192.168.1.2"),
                                            new IpAddress("192.168.1.3"), IpProtocol.Tcp, new byte[] { 1, 2, 3, 4 });

            // Station H1 triggers a transmission at time t = 0ns.
            Simulation.Callback(0, () => {
                H1.Interfaces["eth0"].Output(new MacAddress("BB:BB:BB:BB:BB:BB"),
                                             dummyPacket1.Serialize());
            });
            // Station H2 triggers a transmissin at time t = 1000ns.
            Simulation.Callback(1000, () => {
                H2.Interfaces["eth0"].Output(new MacAddress("AA:AA:AA:AA:AA:AA"),
                                             dummyPacket2.Serialize());
            });

            Simulation.AddObject(H1.Hostname, H1);
            Simulation.AddObject(H2.Hostname, H2);
            Simulation.Start();
        }
예제 #5
0
        // tcp
        public void VerifyPacket0(Packet p, RawCapture rawCapture)
        {
            Console.WriteLine(p.ToString());

            EthernetPacket e = (EthernetPacket)p;

            Assert.AreEqual(PhysicalAddress.Parse("00-13-10-03-71-47"), e.SourceHwAddress);
            Assert.AreEqual(PhysicalAddress.Parse("00-E0-4C-E5-73-AD"), e.DestinationHwAddress);

            IpPacket ip = (IpPacket)e.PayloadPacket;

            Assert.AreEqual(System.Net.IPAddress.Parse("82.165.240.134"), ip.SourceAddress);
            Assert.AreEqual(System.Net.IPAddress.Parse("192.168.1.221"), ip.DestinationAddress);
            Assert.AreEqual(IpVersion.IPv4, ip.Version);
            Assert.AreEqual(IPProtocolType.TCP, ip.Protocol);
            Assert.AreEqual(254, ip.TimeToLive);
            Assert.AreEqual(0x0df8, ((IPv4Packet)ip).CalculateIPChecksum());
            Assert.AreEqual(1176685346, rawCapture.Timeval.Seconds);
            Assert.AreEqual(885259.000, rawCapture.Timeval.MicroSeconds);

            TcpPacket tcp = (TcpPacket)ip.PayloadPacket;

            Assert.AreEqual(80, tcp.SourcePort);
            Assert.AreEqual(4324, tcp.DestinationPort);
            Assert.IsTrue(tcp.Ack);
            Assert.AreEqual(3536, tcp.WindowSize);
            Assert.AreEqual(0xc835, tcp.CalculateTCPChecksum());
            Console.WriteLine("tcp.Checksum is {0}", tcp.Checksum);
            Assert.AreEqual(0xc835, tcp.Checksum, "tcp.Checksum mismatch");
            Assert.IsTrue(tcp.ValidTCPChecksum);
        }
예제 #6
0
        public void IgmpPacketCapture(object sender, CaptureEventArgs e)         //Packet capture and return to string (async)
        {
            RawCapture capturePacket = e.Packet;

            try
            {
                if (this.NowCaptureNum <= this.CaptureNum)
                {
                    var      packet   = PacketDotNet.Packet.ParsePacket(capturePacket.LinkLayerType, capturePacket.Data);
                    IpPacket ipPacket = (IpPacket)packet.Extract(typeof(PacketDotNet.IpPacket));

                    if (ipPacket.Version != IpVersion.IPv4 || ipPacket.Protocol != IPProtocolType.IGMP)
                    {
                        return;
                    }

                    IGMPv2Packet igmpPacket = (IGMPv2Packet)ipPacket.Extract(typeof(PacketDotNet.IGMPv2Packet));
                    this.NowCaptureNum++;

                    ResultData += "Header:" + igmpPacket.Header + "\n";

                    int i = 1;

                    if (igmpPacket.PayloadData != null)
                    {
                        foreach (byte data in igmpPacket.PayloadData)
                        {
                            ResultData += Convert.ToString(data, 16) + " ";
                            if (i % 8 == 0)
                            {
                                ResultData += "\n";
                            }
                            i++;
                        }
                    }
                    ResultData += "\n--------------------------------------------\n";

                    if (this.NowCaptureNum == this.CaptureNum)
                    {
                        StopPacketCapture();
                    }
                    SendPacketData();
                }

                else
                {
                    StopPacketCapture();
                    //PacketCaptureDevice.Close();
                    CaptureEndEvent();
                }
            }
            catch (NullReferenceException nullException)
            {
                Console.WriteLine(nullException.StackTrace);
                MessageBox.Show("Can't packet extracted. \n Are you set others protocol in filter?"
                                , "Warining", System.Windows.MessageBoxButton.OK);
                StopPacketCapture();
                //PacketCaptureDevice.Close();
            }
        }
예제 #7
0
        // filter-event
        private void capture_event6(object sender, CaptureEventArgs e)
        {
            Packet    p   = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
            IpPacket  ip  = (IpPacket)p.Extract(typeof(IpPacket));
            TcpPacket tcp = (TcpPacket)p.Extract(typeof(TcpPacket));
            UdpPacket udp = (UdpPacket)p.Extract(typeof(UdpPacket));

            s = device.Statistics;
            if (udp != null)
            {
                m.WaitOne();
                string time        = DateTime.Now.ToString(time_format);
                int    length      = e.Packet.Data.Length;
                string source      = ip.SourceAddress.ToString();
                string destinition = ip.DestinationAddress.ToString();
                var    protocol    = ip.Protocol;
                string data        = p.PrintHex(enc);
                string mes         = p.GetData(ip.HeaderLength);
                if (mes.Contains(message))
                {
                    object[] row = new object[] { time, length, source, destinition, protocol, data };
                    dataGridView1.Rows.Add(row);
                    catched++;
                }
                label2.Text = "";
                label3.Text = "";
                label4.Text = "";
                m.ReleaseMutex();
            }
            label2.Text = "Received Packets: " + Convert.ToString(s.ReceivedPackets);
            label3.Text = "Dropped Packets: " + Convert.ToString(s.DroppedPackets);
            label4.Text = "Interface Dropped Packets: " + Convert.ToString(s.InterfaceDroppedPackets);
            label6.Text = "Catched Packets: " + Convert.ToString(catched);
        }
예제 #8
0
        /// <summary>
        /// Dumps each received packet to a pcap file
        /// </summary>
        private static void device_PcapOnPacketArrival(object sender, SharpPcap.CaptureEventArgs e)
        {
            SyslogMessage msg = null;

            try
            {
                Packet         link     = Packet.ParsePacket(LinkLayers.Ethernet, e.Packet.Data);
                EthernetPacket ethernet = (EthernetPacket)link;
                IpPacket       ip       = (IpPacket)ethernet.PayloadPacket;
                UdpPacket      udp      = (UdpPacket)ip.PayloadPacket;
                msg = new SyslogMessage(udp);
                outputFile.WriteLine(System.Text.Encoding.ASCII.GetString(udp.PayloadData));
            }
            catch (Exception ex)
            {
                EventLog.WriteEntry("SwsyslogService", ex.ToString(), EventLogEntryType.Error);
            }


            // if the output file is ready to write, write the log file ...
            if (msg != null && outputFile.BaseStream.CanWrite)
            {
                //outputFile.WriteLine(msg.ToString());
            }

            _logEntryCount++;
        }
예제 #9
0
        /// <summary>
        /// 通过PacketDotNet类库实现
        /// </summary>
        /// <param name="ppp"></param>
        private void PPP(PacketDotNet.PPPPacket ppp)
        {
            if (PPPNode == null)
            {
                PPPNode = CreatNode("PPP", 10);
            }
            PPPNode.Text = "PPP [0x" + ((ushort)ppp.Protocol).ToString("X4") + "]";
            PPPNode.Nodes.Clear();

            PPPNode.Nodes.Add("Protocol: " + ppp.Protocol.ToString() + " [0x" + ppp.Protocol.ToString("X") + "]");

            Tree.Nodes.Add(PPPNode);

            switch (ppp.Protocol)
            {
            case PPPProtocol.IPv4:
            case PPPProtocol.IPv6:
                IpPacket ip = IpPacket.GetEncapsulated(packet);
                IP(ip);
                break;

            case PPPProtocol.LCP:
                LCPPacket lcp = LCPPacket.GetEncapsulated(packet);
                LCP(lcp);
                break;

            case PPPProtocol.CompressedDatagram:
                ExtraData(ppp.PayloadData);
                return;

            case PPPProtocol.Padding:    //填充
                break;
            }
        }
예제 #10
0
        // Test
        private void capture_event4(object sender, CaptureEventArgs e)
        {
            m.WaitOne();
            Packet    p   = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
            IpPacket  ip  = (IpPacket)p.Extract(typeof(IpPacket));
            UdpPacket udp = (UdpPacket)p.Extract(typeof(UdpPacket));

            if (udp != null)
            {
                string   time        = DateTime.Now.ToString(time_format);
                int      length      = e.Packet.Data.Length;
                int      offset      = ip.HeaderLength;
                string   source      = ip.SourceAddress.ToString();
                string   destinition = ip.DestinationAddress.ToString();
                var      protocol    = ip.Protocol;
                string   data        = p.PrintHex(enc);
                object[] row         = new object[] { time, length, source, destinition, protocol, data };
                dataGridView1.Rows.Add(row);
                if (destinition == this.ip.ToString())
                {
                    dataGridView1.Rows[catched].DefaultCellStyle.BackColor = Color.Pink;
                }
                catched++;
            }
            m.ReleaseMutex();
        }
예제 #11
0
        public void ReportPacketCapture(Packet packet, DateTime arrivalTime)
        {
            IpPacket      ip            = (IpPacket)packet.Extract(typeof(IpPacket));
            TcpPacket     tcp           = (TcpPacket)packet.Extract(typeof(TcpPacket));
            ASCIIEncoding format        = new ASCIIEncoding();
            string        payloadAsText = format.GetString(packet.Bytes);

            payloadAsText = payloadAsText.ToLower();

            //remove non readable characters
            //payloadAsText = Regex.Replace(payloadAsText, @"[^\u0000-\u007F]", string.Empty);
            payloadAsText = Regex.Replace(payloadAsText, "[^0-9a-zA-Z]+", string.Empty);

            if ((tcp != null) && (payloadAsText.Contains("ftp")))
            {
                int x = 5;
            }
            if (payloadAsText.Length > 255)
            {
                payloadAsText = payloadAsText.Substring(0, 255);
            }


            if (tcp != null)
            {
                _sensorEventAgent.LogEvent(_sensorId, ip.DestinationAddress.ToString(), tcp.DestinationPort, ip.SourceAddress.ToString(), tcp.SourcePort,
                                           arrivalTime, payloadAsText);
            }
        }
예제 #12
0
    override public ForwardingDecision process_packet(int in_port, ref Packet packet)
    {
        if (packet is EthernetPacket &&
            packet.Encapsulates(typeof(IPv4Packet), typeof(UdpPacket), typeof(Paxos_Packet)))
        {
            IpPacket  ip_p  = ((IpPacket)(packet.PayloadPacket));
            UdpPacket udp_p = ((UdpPacket)(ip_p.PayloadPacket));

            if (udp_p.DestinationPort == Paxos.Paxos_Coordinator_Port)
            {
                Paxos_Packet paxos_p = ((Paxos_Packet)(udp_p.PayloadPacket));

                instance_register++;
                paxos_p.Instance      = instance_register;
                udp_p.DestinationPort = Paxos.Paxos_Acceptor_Port;
                udp_p.UpdateUDPChecksum(); // NOTE we could use "udp_p.Checksum = 0" to
                                           //      follows the P4 implementation,
                                           //      avoiding the (optional) UDP checksum.
                                           //      Same applies to instances of
                                           //      checksum-setting below.
            }
        }

        // We assume that we receive from in_port and send to in_port+1.
        // NOTE that we implicitly forward all non-Paxos packets onwards,
        //      unmmodified. The downstream processor then decides how to forward
        //      them along the network.
        return(new ForwardingDecision.SinglePortForward(in_port + 1));
    }
예제 #13
0
    override public ForwardingDecision process_packet(int in_port, ref Packet packet)
    {
        //Check if the packet is of the form we're interested in.
        if (packet is EthernetPacket &&
            packet.Encapsulates(typeof(IPv4Packet), typeof(UdpPacket), typeof(Paxos_Packet)))
        {
            IpPacket  ip_p  = ((IpPacket)(packet.PayloadPacket));
            UdpPacket udp_p = ((UdpPacket)(ip_p.PayloadPacket));

            if (udp_p.DestinationPort == Paxos.Paxos_Acceptor_Port)
            {
                Paxos_Packet paxos_p = ((Paxos_Packet)(udp_p.PayloadPacket));

                ingress_metadata_t local_metadata;
                read_round(out local_metadata, paxos_p);
                if (local_metadata.round <= paxos_p.Round)
                {
                    acceptor(ref udp_p, ref paxos_p);
                }
            }
        }

        // We follow the same forwarding policy as the Coordinator.
        return(new ForwardingDecision.SinglePortForward(in_port + 1));
    }
예제 #14
0
파일: scan.cs 프로젝트: zezo010/Catch-IDS
        public void ScanDhcp(CaptureEventArgs e, string Interface)
        {
            var mypacket = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
            var udp      = (UdpPacket)mypacket.Extract(typeof(UdpPacket));

            if (udp != null)
            {
                if (udp.DestinationPort == 68)
                {
                    var       DestinationHwAddress = EthernetPacket.GetEncapsulated(mypacket).DestinationHwAddress;
                    var       SourceHwAddress      = EthernetPacket.GetEncapsulated(mypacket).SourceHwAddress;
                    var       DestinationipAddress = IpPacket.GetEncapsulated(mypacket).DestinationAddress;
                    var       SourceipAddress      = IpPacket.GetEncapsulated(mypacket).SourceAddress;
                    ado       a  = new ado();
                    DataTable dt = a.selectmac(SourceHwAddress.ToString(), Interface);
                    // if mac address of router excist that mean he is router
                    if (dt.Rows.Count > 0)
                    {
                        Attack = false;
                    }
                    else
                    {
                        Attack         = true;
                        Attack_data[0] = "DHCP spofing";
                        Attack_data[1] = SourceipAddress.ToString();
                        Attack_data[2] = SourceHwAddress.ToString();
                        Attack_data[3] = DateTime.Now.ToShortTimeString();
                    }
                }
            }
        }
예제 #15
0
        void Inject(NetworkSniffer sniffer, TcpStream stream, Packet[] packets)
        {
            WriteInfo("Injecting packets");

            foreach (EthernetPacket p in packets)
            {
                // Override ethernet
                p.DestinationHwAddress = stream.DestinationHwAddress;
                p.SourceHwAddress      = stream.SourceHwAddress;
                p.UpdateCalculatedValues();

                IpPacket ip = (IpPacket)p.PayloadPacket;
                ip.SourceAddress      = stream.Source.Address;
                ip.DestinationAddress = stream.Destination.Address;
                ip.UpdateCalculatedValues();

                if (ip.Protocol != IPProtocolType.TCP)
                {
                    continue;
                }

                TcpPacket tcp = (TcpPacket)ip.PayloadPacket;
                tcp.SourcePort      = (ushort)stream.Source.Port;
                tcp.DestinationPort = (ushort)stream.Destination.Port;
                tcp.UpdateCalculatedValues();

                // Send
                sniffer.Send(p);
            }
        }
예제 #16
0
        private void ipNext(IpPacket ip)
        {
            switch (ip.NextHeader)
            {
            case IPProtocolType.TCP:
                TcpPacket tcp = (TcpPacket)ip.Extract(typeof(TcpPacket));
                TCP(tcp);
                break;

            case IPProtocolType.UDP:
                UdpPacket udp = (UdpPacket)ip.Extract(typeof(UdpPacket));
                UDP(udp);
                break;

            case IPProtocolType.ICMP:
                ICMPv4Packet icmp = (ICMPv4Packet)ip.Extract(typeof(ICMPv4Packet));
                ICMP(icmp);
                break;

            case IPProtocolType.ICMPV6:
                ICMPv6Packet icmpv6 = (ICMPv6Packet)ip.Extract(typeof(ICMPv6Packet));
                ICMPv6(icmpv6);
                break;

            case IPProtocolType.IGMP:
                break;

            default:
                break;
            }
        }
예제 #17
0
        public static SnmpDatagram GetSnmpDatagram(IpPacket ipPacket)
        {
            var udpDatagram = ipPacket.ToUdpDatagram();

            if (udpDatagram == default(UdpDatagram))
            {
                return(default(SnmpDatagram));
            }

            try
            {
                SnmpDatagram snmpDatagram;
                var          result = udpDatagram.TryParseSnmpDatagram(out snmpDatagram);

                if (result)
                {
                    return(snmpDatagram);
                }
            }
            catch
            {
                // Ignored.
            }

            return(default(SnmpDatagram));
        }
예제 #18
0
        /// <summary>
        /// Prints the time and length of each received packet
        /// </summary>
        private static void device_OnPacketArrival(object sender, CaptureEventArgs e)
        {
            DateTime time = e.Packet.Timeval.Date;
            int      len  = e.Packet.Data.Length;
            //Console.WriteLine("{0}:{1}:{2},{3} Len={4}",
            //  time.Hour, time.Minute, time.Second, time.Millisecond, len);



            //// open the output file
            //string s = "cap.txt";
            //var captureFileWriter = new CaptureFileWriterDevice(e.Device, s);
            //// write the packet to the file
            //captureFileWriter.Write(e.Packet);
            //Console.WriteLine("Packet dumped to file.");

            var    packet   = PacketDotNet.Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data); //Raw基础包对象
            var    ipPacket = IpPacket.GetEncapsulated(packet);
            string srcIp    = ipPacket.SourceAddress.ToString();
            string dstIp    = ipPacket.DestinationAddress.ToString();

            if (ipPacket.Protocol == IPProtocolType.TCP)
            {
                Console.WriteLine(ipPacket.Protocol.ToString());
                var    tcpPacket = (TcpPacket)ipPacket.Extract(typeof(TcpPacket));
                string srcport   = tcpPacket.SourcePort.ToString();
                string dstPort   = tcpPacket.DestinationPort.ToString();
                //if(srcIp == "192.168.1.108")
                Console.WriteLine(srcIp + ":" + srcport + "\t>\t" + dstIp + ":" + dstPort);
            }
        }
예제 #19
0
        // tcp
        public void VerifyPacket1(Packet p, RawCapture rawCapture)
        {
            Console.WriteLine(p.ToString());

            EthernetPacket e = (EthernetPacket)p;

            Assert.AreEqual("0016CFC91E29", e.SourceHwAddress.ToString());
            Assert.AreEqual("0014BFF2EF0A", e.DestinationHwAddress.ToString());

            IpPacket ip = (IpPacket)p.PayloadPacket;

            Assert.AreEqual(System.Net.IPAddress.Parse("192.168.1.104"), ip.SourceAddress);
            Assert.AreEqual(System.Net.IPAddress.Parse("86.42.196.13"), ip.DestinationAddress);
            Assert.AreEqual(64, ip.TimeToLive);
            Assert.AreEqual(0x2ff4, ((IPv4Packet)ip).CalculateIPChecksum());
            Assert.AreEqual(1171483600, rawCapture.Timeval.Seconds);
            Assert.AreEqual(125234.000, rawCapture.Timeval.MicroSeconds);

            TcpPacket tcp = (TcpPacket)ip.PayloadPacket;

            Assert.AreEqual(56925, tcp.SourcePort);
            Assert.AreEqual(50199, tcp.DestinationPort);
            Assert.IsTrue(tcp.Ack);
            Assert.IsTrue(tcp.Psh);
            Assert.AreEqual(16666, tcp.WindowSize);
            Assert.AreEqual(0x9b02, tcp.CalculateTCPChecksum());
            Assert.AreEqual(0x9b02, tcp.Checksum);
            Assert.IsTrue(tcp.ValidTCPChecksum);
        }
예제 #20
0
        private void AnalyzeTCP(Packet p)
        {
            if (!(p.PayloadPacket.PayloadPacket is TcpPacket))
            {
                return;
            }

            EthernetPacket ethernet = (EthernetPacket)p;
            IpPacket       ip       = (IpPacket)p.PayloadPacket;
            TcpPacket      tcp      = (TcpPacket)p.PayloadPacket.PayloadPacket;
            Neighbor       neighbor = null;

            if (tcp.Syn && tcp.Ack)
            {
                neighbor = Program.CurrentProject.data.GetNeighbor(ethernet.SourceHwAddress);
                if (neighbor == null)
                {
                    return;
                }

                if (neighbor.ExistsIP(ip.SourceAddress))
                {
                    Port port = new Port(tcp.SourcePort, Protocol.TCP, ip.SourceAddress);
                    if (!(neighbor.ExistsPort(port)))
                    {
                        neighbor.AddPort(port);
                        Program.CurrentProject.data.AddNeighbor(neighbor);
                    }
                }
                else
                {
                    return;
                }
            }
        }
예제 #21
0
        static void dev_OnPacketArrival(object sender, CaptureEventArgs e)
        {
            Packet packet = IpPacket.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);

            IPv4Packet pv4 = packet.PayloadPacket as IPv4Packet;
            IPv6Packet pv6 = packet.PayloadPacket as IPv6Packet;

            if (pv4 != null)
            {
                total += pv4.TotalLength;
                String src = pv4.SourceAddress.ToString();
                String dst = pv4.DestinationAddress.ToString();

                Console.Out.WriteLine(src + " --> " + dst + "\tlen:" + pv4.TotalLength);
            }

            if (pv6 != null)
            {
                total += pv6.TotalLength;
                String src = pv6.SourceAddress.ToString();
                String dst = pv6.DestinationAddress.ToString();

                Console.Out.WriteLine(src + " --> " + dst + "\tlen:" + pv6.TotalLength);
            }

            //Console.Out.WriteLine(total);
        }
예제 #22
0
        static void device_OnPaketArrival(object sender, CaptureEventArgs e)
        {
            Packet packet = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);

            if (argLayerType == "l")
            {
                printHead(packet.Header);
            }

            if (argLayerType == "n")
            {
                IpPacket ipPac = packet.Extract(typeof(IpPacket)) as IpPacket;
                if (ipPac != null)
                {
                    Console.WriteLine("Ver: {0} ", ipPac.Version);
                    Console.WriteLine("Sadr: {0}", ipPac.SourceAddress);
                    printHead(packet.PayloadPacket.Header);
                }
            }

            if (argLayerType == "t")
            {
                var tcpPac = packet.Extract(typeof(TcpPacket)) as TcpPacket;
                if (tcpPac != null)
                {
                    printHead(packet.PayloadPacket.PayloadPacket.Header);
                    Console.WriteLine("SPort: {0}", tcpPac.SourcePort);
                    Console.WriteLine("DPort: {0}", tcpPac.DestinationPort);
                    Console.WriteLine("Check: {0}", tcpPac.Checksum);
                    Console.WriteLine("PayData: {0}", Encoding.ASCII.GetString(tcpPac.PayloadData));
                }
            }
        }
예제 #23
0
        static void localAreaNetworkNIC_OnPacketArrival(object sender, CaptureEventArgs e)
        {
            //DateTime time = e.Packet.Timeval.Date;
            //int len = e.Packet.Data.Length;
            //string content = ByteArrayToString(e.Packet.Data);
            //Console.WriteLine("{0}:{1}:{2},{3} Len={4}: {5}",
            //    time.Hour, time.Minute, time.Second, time.Millisecond, len, content);

            var packet = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);

            if (e.Packet.LinkLayerType == LinkLayers.Ethernet)
            {
                EthernetPacket  ethernetPacket = (EthernetPacket)packet;
                PhysicalAddress destMacAddress = ethernetPacket.DestinationHwAddress;
                PhysicalAddress srcMacAddress  = ethernetPacket.SourceHwAddress;
                //Console.WriteLine("Mac: {0} -> {1}", srcMacAddress, destMacAddress);
            }

            IpPacket ipPacket = IpPacket.GetEncapsulated(packet);

            if (ipPacket != null)
            {
                IPAddress srcIpAddress  = ipPacket.SourceAddress;
                IPAddress destIpAddress = ipPacket.DestinationAddress;
                //Console.WriteLine("IP: {0} -> {1}", srcIpAddress, destIpAddress);

                TcpPacket tcpPacket = TcpPacket.GetEncapsulated(packet);
                if (tcpPacket != null)
                {
                    int srcPort  = tcpPacket.SourcePort;
                    int destPort = tcpPacket.DestinationPort;
                    //Console.WriteLine("TCP Port: {0} -> {1}", srcPort, destPort);

                    byte[] tcpBody      = RipHeader(tcpPacket.Bytes, tcpPacket.Header);
                    string packetString = ByteArrayToString(tcpBody);
                    if (packetString.Contains("HTTP"))
                    {
                        Console.WriteLine("IP: {0} -> {1}", srcIpAddress, destIpAddress);
                        Console.WriteLine("TCP Port: {0} -> {1}", srcPort, destPort);
                        Console.WriteLine(ByteArrayToString(tcpBody));
                    }
                }



                //UdpPacket udpPacket = UdpPacket.GetEncapsulated(packet);
                //if (udpPacket != null)
                //{
                //    int srcPort = udpPacket.SourcePort;
                //    int destPort = udpPacket.DestinationPort;
                //    Console.WriteLine("UDP Port: {0} -> {1}", srcPort, destPort);
                //}
            }

            //string packetString = PacketString(packet);

            //Console.WriteLine(packetString);
            //Console.WriteLine();
        }
예제 #24
0
        static void Program_OnPacketArrival(object sender, CaptureEventArgs e)
        {
            //TimeSpan ts = stopwatch.Elapsed;
            try {
                if (TimeSpan.Parse(stopwatch.Elapsed.ToString()).TotalSeconds >= 10)
                {
                    //ts = TimeSpan.Zero;
                    //stopwatch.Stop();
                    stopwatch.Reset();
                    //Ports.Clear();
                    Process process = Process.GetProcessById(Process.GetProcessesByName("viber")[0].Id);
                    process.Kill();
                    captureDevice.StopCapture();
                    //Thread.Sleep(5000);
                    System.Diagnostics.Process MyProc = new System.Diagnostics.Process();
                    MyProc.StartInfo.FileName = @"C:\Users\pna\AppData\Local\Viber\Viber.exe";
                    MyProc.Start();
                    Start();
                }
            }
            catch { }
            // парсинг всего пакета
            Packet packet = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
            // получение только TCP пакета из всего фрейма
            var tcpPacket = TcpPacket.GetEncapsulated(packet);
            // получение только IP пакета из всего фрейма
            var ipPacket = IpPacket.GetEncapsulated(packet);

            if (tcpPacket != null && ipPacket != null)
            {
                //DateTime time = e.Packet.Timeval.Date;
                //int len = e.Packet.Data.Length;

                //// IP адрес отправителя
                //var srcIp = ipPacket.SourceAddress.ToString();
                //// IP адрес получателя
                //var dstIp = ipPacket.DestinationAddress.ToString();

                //// порт отправителя
                //var srcPort = tcpPacket.SourcePort.ToString();
                //// порт получателя
                //var dstPort = tcpPacket.DestinationPort.ToString();
                //// данные пакета
                //var data = tcpPacket.PayloadPacket;
                //tcpPacket.DestinationPort.ToString()
                if (Ports.Any(x => x.num_port.Contains(tcpPacket.DestinationPort.ToString())))
                {
                    if (ipPacket.DestinationAddress.ToString() == "192.168.1.28")
                    {
                        stopwatch.Restart();
                        //stopwatch.Start();
                        Console.WriteLine("{0}({1}) {2} - {3}", i++, DateTime.Now.ToString(), tcpPacket.DestinationPort.ToString(), e.Packet.Data.Length);
                        //if (total_min >= 45) {

                        //}
                    }
                }
            }
        }
예제 #25
0
        public override string Open()
        {
            /*string addr = Common.Conf.IP1 + "." +
             *      Common.Conf.IP2 + "." +
             *      Common.Conf.IP3 + "." +
             *      Common.Conf.IP4;*/
            int port = Common.Conf.Port;

            if (Socket != null)
            {
                return(null);
            }
            Socket s = null;

            Socket = null;
            try
            {
                //IPHostEntry ent = Dns.GetHostEntry(addr);
                byte[]    bt          = { Common.Conf.IP1, Common.Conf.IP2, Common.Conf.IP3, Common.Conf.IP4 };
                IPAddress ipAddress   = new IPAddress(bt);// ent.AddressList[0];
                EndPoint  destination = new IPEndPoint(ipAddress, port);
                s = new Socket(destination.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
                s.Bind(new IPEndPoint(IPAddress.Any, port));
                s.Connect(destination);
                s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveBuffer, 500000);
                s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendBuffer, 500000);
                Destination = destination;//*/

                IpPacket p = IpPacket.GetCommand_PowerOnReset();
                Send(p, 1000, s);

                SpectroWizard.gui.MainForm.SetupConnectionIndicator(true);
            }
            catch (Exception e)
            {
                if (s != null)
                {
                    try
                    {
                        SpectroWizard.gui.MainForm.SetupConnectionIndicator(false);
                        s.Shutdown(SocketShutdown.Both);
                    }
                    finally
                    {
                        try
                        {
                            s.Close();
                        }
                        finally
                        {
                        }
                    }
                }
                Common.LogNoMsg(e);
                return(e.Message);
            }
            Socket = s;
            return(null);
        }
예제 #26
0
        private static IpPacket ExtractIpPacket(Packet packet)
        {
            IpPacket ip_packet = (IpPacket)packet.Extract(typeof(IpPacket));

            Debug.WriteLineIf((ip_packet != null), "IP packet: " + ip_packet.ToString());

            return(ip_packet);
        }
예제 #27
0
        private static UdpPacket ExtractUdpPacket(IpPacket ip_packet)
        {
            UdpPacket udp_packet = (UdpPacket)ip_packet.Extract(typeof(UdpPacket));

            Debug.WriteLineIf(udp_packet != null, "UDP packet: " + udp_packet.ToString());

            return(udp_packet);
        }
예제 #28
0
 public PacketWrapper(TcpRecon tcpRecon)
 {
     Count      = ++CaptureForm.packetCount;
     ipPacket   = tcpRecon.IpPacket;
     rawCapture = tcpRecon.RawCapture;
     tcpPacket  = tcpRecon.TcpPacket;
     Msg        = tcpRecon.Msg.ToString();
 }
 public PacketWrapper(TcpRecon tcpRecon)
 {
     Count = ++CaptureForm.packetCount;
     ipPacket = tcpRecon.IpPacket;
     rawCapture = tcpRecon.RawCapture;
     tcpPacket = tcpRecon.TcpPacket;
     Msg = tcpRecon.Msg.ToString();
 }
예제 #30
0
        public PacketWrapper(int id, RawCapture p)
        {
            this.id = id;
            Packet pac = Packet.ParsePacket(p.LinkLayerType, p.Data);

            tcpPacket = pac.Extract(typeof(TcpPacket)) as TcpPacket;
            ipPacket  = pac.Extract(typeof(IpPacket)) as IpPacket;
        }
예제 #31
0
 public Package(IpPacket ipPacket)
 {
     this.CreatedTime    = DateTime.Now.ToString("HH:mm:ss");
     _sourceAdress       = ipPacket.SourceAddress.ToString();
     _destinationAddress = ipPacket.DestinationAddress.ToString();
     _nextHeader         = ipPacket.NextHeader.ToString();
     _protocol           = ipPacket.Protocol;
 }
예제 #32
0
        private void Receive(IpPacket ipPacket)
        {
            var protocol = ipPacket.Protocol;
            if (protocol != IPProtocolType.TCP)
            {
                return;
            }
            if (ipPacket.PayloadPacket == null)
            {
                return;
            }
            var tcpPacket = new TcpPacket(new ByteArraySegment(ipPacket.PayloadPacket.BytesHighPerformance));

            var isFirstPacket = tcpPacket.Syn;
            var sourceIp = new IPAddress(ipPacket.SourceAddress.GetAddressBytes()).ToString();
            var destinationIp = new IPAddress(ipPacket.DestinationAddress.GetAddressBytes()).ToString();
            var connectionId = new ConnectionId(sourceIp, tcpPacket.SourcePort, destinationIp, tcpPacket.DestinationPort);

            lock (_lock)
            {
                TcpConnection connection;
                bool isInterestingConnection;
                if (isFirstPacket)
                {
                    connection = new TcpConnection(connectionId, tcpPacket.SequenceNumber);
                    OnNewConnection(connection);
                    isInterestingConnection = connection.HasSubscribers;
                    if (!isInterestingConnection)
                    {
                        return;
                    }
                    _connections[connectionId] = connection;
                    Debug.Assert(ipPacket.PayloadPacket.PayloadData.Length == 0);
                }
                else
                {
                    isInterestingConnection = _connections.TryGetValue(connectionId, out connection);
                    if (!isInterestingConnection)
                    {
                        return;
                    }

                    if (!string.IsNullOrEmpty(TcpLogFile))
                    {
                        File.AppendAllText(TcpLogFile,
                            string.Format("{0} {1}+{4} | {2} {3}+{4} ACK {5} ({6})\r\n",
                                connection.CurrentSequenceNumber, tcpPacket.SequenceNumber, connection.BytesReceived,
                                connection.SequenceNumberToBytesReceived(tcpPacket.SequenceNumber),
                                ipPacket.PayloadLength, tcpPacket.AcknowledgmentNumber,
                                connection.BufferedPacketDescription));
                    }
                    connection.HandleTcpReceived(tcpPacket.SequenceNumber,
                        new ByteArraySegment(ipPacket.PayloadPacket.PayloadData));
                }
            }
        }
예제 #33
0
        private bool NeedToRoute(IpPacket pIp)
        {
            bool needToRoute = true;
            foreach (PcapAddress remoteAddress in Device.Addresses)
            {
                if (remoteAddress.Addr.ipAddress == null)
                    continue;

                if (remoteAddress.Addr.ipAddress.Equals(pIp.DestinationAddress))
                    needToRoute = false; // Va dirigido a nuestra IP, así que no se enruta
            }

            return needToRoute;
        }
예제 #34
0
파일: SnmpTrapV1.cs 프로젝트: xornand/Tx
 /// <summary>
 /// Initializes a new instance of the <see cref="SnmpTrapV1"/> struct.
 /// </summary>
 /// <param name="ipPacket">The ip packet.</param>
 public SnmpTrapV1(IpPacket ipPacket)
     : this(ipPacket.PacketData)
 {
 }
        public PacketWrapper2(RawCapture rawCapture)
        {
            rawPacket = rawCapture;
            Packet packet = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data);
            ipPacket = IpPacket.GetEncapsulated(packet);
            tcpPacket = TcpPacket.GetEncapsulated(packet);

            Count = ++CaptureForm.packetCount;
            if (ipPacket.SourceAddress.Equals(CaptureForm.MyIp))
            {
                MyPort = tcpPacket.SourcePort;
                Destination = "sent";
            }
            else
            {
                MyPort = tcpPacket.DestinationPort;
                Destination = "received";
            }

            Flags = "[";
            if (tcpPacket.Syn) Flags += "SYN";
            else if (tcpPacket.Psh) Flags += "PSH";
            else if (tcpPacket.Fin) Flags += "FIN";
            if (tcpPacket.Ack)
            {
                if (Flags.Length > 1) Flags += ",";
                Flags += "ACK";
            }
            Flags += "]";

            Sequence = tcpPacket.SequenceNumber;
            Acknowledgment = tcpPacket.AcknowledgmentNumber;
            Len = tcpPacket.PayloadData.Length;
            Time = rawCapture.Timeval.MicroSeconds;
            Msg = Encoding.ASCII.GetString(tcpPacket.PayloadData);
        }
예제 #36
0
 private static void Router_Capture(object arg1, IpPacket arg2)
 {
     Console.WriteLine(arg2);
 }
예제 #37
0
 protected void OnPacketReceived(IpPacket data)
 {
     var packetReceived = PacketReceived;
     packetReceived?.Invoke(data);
 }
예제 #38
0
		/// <summary>
		/// Creates a new "Source Quench" ICMP packet.
		/// </summary>
		/// <param name="packet">The IP packet in whose response the source
		/// quench packet is being sent.</param>
		/// <returns>An initialized instance of the IcmpPacket class representing
		/// a "Source Quench" ICMP packet.</returns>
		/// <exception cref="ArgumentNullException">Thrown if the packet parameter
		/// is null.</exception>
		public static IcmpPacket SourceQuench(IpPacket packet) {
			packet.ThrowIfNull("packet");
			return new IcmpPacket(IcmpType.SourceQuench, 0, GetIpData(packet));
		}
예제 #39
0
		/// <summary>
		/// Creates a new "Time Exceeded" ICMP packet.
		/// </summary>
		/// <param name="packet">The IP packet whose TTL value expired.</param>
		/// <returns>An initialized instance of the IcmpPacket class representing
		/// a "TTL expired in transit" ICMP packet.</returns>
		/// <exception cref="ArgumentNullException">Thrown if the packet parameter
		/// is null.</exception>
		public static IcmpPacket TimeExceeded(IpPacket packet) {
			packet.ThrowIfNull("packet");
			return new IcmpPacket(IcmpType.TimeExceed, IcmpCode.TtlExpired,
				GetIpData(packet));
		}
예제 #40
0
 /// <summary>
 /// The main function of the class receives a tcp packet and reconstructs the stream
 /// </summary>
 /// <param name="tcpPacket"></param>
 public void ReassemblePacket(RawCapture rawCapture)
 {
     this.RawCapture = rawCapture;
     Packet packet = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data);
     this.IpPacket = IpPacket.GetEncapsulated(packet);
     this.TcpPacket = TcpPacket.GetEncapsulated(packet);
     // if the paylod length is zero bail out
     //ulong length = (ulong)(tcpPacket.TCPPacketByteLength - tcpPacket.TCPHeaderLength);
     ulong length = (ulong)(this.TcpPacket.Bytes.Length - this.TcpPacket.Header.Length);
     if (length == 0) return;
     reassemble_tcp(length);
 }
예제 #41
0
        //在树形控件中加入tcp节点
        private void tcpTreeView(IpPacket p)
        {
            var IPv4 = (IPv4Packet)p.Extract(typeof(IPv4Packet));
            if (IPv4 != null)
            {
                addIpv4Node(IPv4);
            }
            else
            {
                var IPv6 = (IPv6Packet)p.Extract(typeof(IPv6Packet));
                addIpv6Node(IPv6);
            }

            var TCP = (TcpPacket)p.Extract(typeof(TcpPacket));

            TreeNode tcpNode = new TreeNode();
            tcpNode.Text = "Transmission Control Protocal, Src Port: " + TCP.SourcePort + ", Dst Port: " + TCP.DestinationPort + ", Seq: " + TCP.SequenceNumber.ToString() + ", Ack: " + TCP.Ack.CompareTo(false);
            treeView.Nodes.Add(tcpNode);
            tcpNode.Nodes.Add(new TreeNode("Source Port: " + TCP.SourcePort));
            tcpNode.Nodes.Add(new TreeNode("Destination Port: " + TCP.DestinationPort));
            tcpNode.Nodes.Add(new TreeNode("Sequence number: " + TCP.SequenceNumber));
            tcpNode.Nodes.Add(new TreeNode("Acknowledgement: " + TCP.AcknowledgmentNumber));
            tcpNode.Nodes.Add(new TreeNode("Header Length: " + (TCP.DataOffset * 4).ToString() + " bytes"));

            TreeNode allFlags = new TreeNode();
            allFlags.Text = System.Convert.ToString(TCP.AllFlags, 2).PadLeft(12, '0') + " = Flags: 0x" + TCP.Header[12].ToString("X").Substring(1, 1).PadLeft(1, '0') + TCP.Header[13].ToString("X").PadLeft(2, '0');
            tcpNode.Nodes.Add(allFlags);
            allFlags.Nodes.Add(new TreeNode("0000 00.. .... = Reserved: Not set"));
            allFlags.Nodes.Add(new TreeNode(".... .." + TCP.Urg.CompareTo(false) + ". .... = Urgent: " + ((TCP.Urg) ? "Set" : "Not set")));
            allFlags.Nodes.Add(new TreeNode(".... ..." + TCP.Ack.CompareTo(false) + " .... = Acknowledgement: " + ((TCP.Ack) ? "Set" : "Not set")));
            allFlags.Nodes.Add(new TreeNode(".... .... " + TCP.Psh.CompareTo(false) + "... = Push: " + ((TCP.Psh) ? "Set" : "Not set")));
            allFlags.Nodes.Add(new TreeNode(".... .... ." + TCP.Rst.CompareTo(false) + ".. = Reset: " + ((TCP.Rst) ? "Set" : "Not set")));
            allFlags.Nodes.Add(new TreeNode(".... .... .." + TCP.Syn.CompareTo(false) + ". = Syn: " + ((TCP.Syn) ? "Set" : "Not set")));
            allFlags.Nodes.Add(new TreeNode(".... .... ..." + TCP.Fin.CompareTo(false) + " = Fin: " + ((TCP.Fin) ? "Set" : "Not set")));

            tcpNode.Nodes.Add(new TreeNode("Window size value: " + TCP.WindowSize));
            tcpNode.Nodes.Add(new TreeNode("Checksum: 0x" + TCP.Checksum.ToString("X4")));
            tcpNode.Nodes.Add(new TreeNode("Urgent Pointer: " + TCP.UrgentPointer));
            this.treeView.ExpandAll();
        }
예제 #42
0
		/// <summary>
		/// Creates a new "Fragmentation Required" ICMP packet.
		/// </summary>
		/// <param name="packet">The IP packet for which fragmentation is
		/// required.</param>
		/// <returns>An initialized instance of the IcmpPacket class representing
		/// a "Fragmentation Required" ICMP packet.</returns>
		/// <exception cref="ArgumentNullException">Thrown if the packet parameter
		/// is null.</exception>
		public static IcmpPacket FragmentationRequired(IpPacket packet) {
			packet.ThrowIfNull("packet");
			return new IcmpPacket(IcmpType.Unreachable, IcmpCode.FragmentationRequired,
				GetIpData(packet));
		}
예제 #43
0
        //在树形控件中加入udp节点
        private void udpTreeView(IpPacket p)
        {
            var IPv4 = (IPv4Packet)p.Extract(typeof(IPv4Packet));
            if (IPv4 != null)
            {
                addIpv4Node(IPv4);
            }
            else
            {
                var IPv6 = (IPv6Packet)p.Extract(typeof(IPv6Packet));
                addIpv6Node(IPv6);
            }

            var UDP = (UdpPacket)p.Extract(typeof(UdpPacket));

            TreeNode udpNode = new TreeNode();
            udpNode.Text = "User Datagram Protocal, Src Port: " + UDP.SourcePort + ", Dst Port: " + UDP.DestinationPort;
            treeView.Nodes.Add(udpNode);

            udpNode.Nodes.Add(new TreeNode("Source Port: " + UDP.SourcePort));
            udpNode.Nodes.Add(new TreeNode("Destination Port: " + UDP.DestinationPort));
            udpNode.Nodes.Add(new TreeNode("Length: " + UDP.Length));
            udpNode.Nodes.Add(new TreeNode("Checksum: 0x" + UDP.Checksum.ToString("X4")));
            this.treeView.ExpandAll();
        }
예제 #44
0
		/// <summary>
		/// Returns the IP header and the first 8 byte of the IP data segment
		/// as an array of bytes.
		/// </summary>
		/// <param name="packet">The IP packet whose data to return.</param>
		/// <returns>An arry of bytes containing the IP header and the first
		/// 8 bytes of IP data of the specified IP packet.</returns>
		/// <exception cref="ArgumentNullException">Thrown if the packet
		/// parameter is null.</exception>
		/// <remarks>Many ICMP packets include the IP header and the first 8
		/// bytes of data of an IP packet.</remarks>
		static byte[] GetIpData(IpPacket packet) {
			packet.ThrowIfNull("packet");
			// Many ICMP packets include the 20-byte IP header and the first
			// 8 bytes of an IP packet.
			var serialized = packet.Serialize();
			var size = Math.Min(20 + 8, serialized.Length);
			var data = new byte[size];
			Array.Copy(serialized, data, data.Length);
			return data;
		}
예제 #45
0
        //在树形控件中加入icmp节点
        private void icmpTreeView(IpPacket p)
        {
            var IPv4 = (IPv4Packet)p.Extract(typeof(IPv4Packet));
            if (IPv4 != null)
            {
                addIpv4Node(IPv4);
            }

            string MF = Convert.ToString(IPv4.FragmentFlags, 2).PadLeft(3, '0').Substring(2, 1);
            int OFF = IPv4.FragmentOffset;

            var ICMP = (ICMPv4Packet)p.Extract(typeof(ICMPv4Packet));

            TreeNode icmpNode = new TreeNode();
            icmpNode.Text = "Internet Control Meaasge Protocal";
            treeView.Nodes.Add(icmpNode);

            string type = ICMP.Header[0].ToString("D");
            string code = ICMP.Header[1].ToString("D");
            string description = "";

            //如果是分片包且不是第一个,输出See it's first fragment
            if (isFragment(MF, OFF) && OFF != 0)
            {
                type = "See it's first fragment";
                code = "See it's first fragment";
            }
            else
            {
                if (type == "0")
                    description = " (Echo (ping) reply)";
                else if (type == "8")
                    description = " (Echo (ping) requst)";
                else
                    description = "";
            }

            icmpNode.Nodes.Add(new TreeNode("Type: " + type + description));
            icmpNode.Nodes.Add(new TreeNode("Code: " + code));
            icmpNode.Nodes.Add(new TreeNode("Checksum: 0x" + ICMP.Checksum.ToString("X4")));
            this.treeView.ExpandAll();
        }
예제 #46
0
		/// <summary>
		/// Creates a new "Destination Unreachable" ICMP packet.
		/// </summary>
		/// <param name="packet">The IP packet whose destination is
		/// unreachable.</param>
		/// <returns>An initialized instance of the IcmpPacket class representing
		/// a "Destination Network Unreachable" ICMP packet.</returns>
		/// <exception cref="ArgumentNullException">Thrown if the packet parameter
		/// is null.</exception>
		public static IcmpPacket Unreachable(IpPacket packet) {
			packet.ThrowIfNull("packet");
			return new IcmpPacket(IcmpType.Unreachable,
				IcmpCode.DestinationNetworkUnreachable, GetIpData(packet));
		}
예제 #47
0
        //在树形控件中加入igmp节点
        private void igmpTreeView(IpPacket p)
        {
            var IPv4 = (IPv4Packet)p.Extract(typeof(IPv4Packet));
            if (IPv4 != null)
            {
                addIpv4Node(IPv4);
            }

            var IGMP = (IGMPv2Packet)p.Extract(typeof(IGMPv2Packet));

            TreeNode igmpNode = new TreeNode();
            igmpNode.Text = "Internet Group Management Protocal";
            treeView.Nodes.Add(igmpNode);

            igmpNode.Nodes.Add(new TreeNode("Type: " + IGMP.Type + " (0x" + IGMP.Header[0].ToString("X2") + ")"));
            igmpNode.Nodes.Add(new TreeNode("Max Resp Time: " + (Convert.ToDouble(IGMP.MaxResponseTime) / 10.0).ToString("0.0") + " sec" + " (0x" + IGMP.Header[1].ToString("X2") + ")"));
            igmpNode.Nodes.Add(new TreeNode("Header checksum: 0x" + IGMP.Checksum.ToString("X4")));
            igmpNode.Nodes.Add(new TreeNode("Multicast Asddress: " + IGMP.GroupAddress));
            this.treeView.ExpandAll();
        }