/// <summary> /// This function build an ARP over Ethernet packet. /// </summary> public static Packet BuildArpPacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(macAddressSource), Destination = new MacAddress(macAddressDest), EtherType = EthernetType.None, // Will be filled automatically. }; ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Request, SenderHardwareAddress = new byte[] { 3, 3, 3, 3, 3, 3 }.AsReadOnly(), // 03:03:03:03:03:03. SenderProtocolAddress = new byte[] { 1, 2, 3, 4 }.AsReadOnly(), // 1.2.3.4. TargetHardwareAddress = new byte[] { 4, 4, 4, 4, 4, 4 }.AsReadOnly(), // 04:04:04:04:04:04. TargetProtocolAddress = new byte[] { 11, 22, 33, 44 }.AsReadOnly(), // 11.22.33.44. }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer); return(builder.Build(DateTime.Now)); }
Packet ArpGenerator(string EthernetSourceMac, string EthernetDestinatonMac, string SenderMacAddress, IPAddress SenderIpAddress, string DestinatonMacAddress, IPAddress DestinationIpAddress, bool isRequest) { EthernetSourceMac = ValidMac(EthernetSourceMac); EthernetDestinatonMac = ValidMac(EthernetDestinatonMac); EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(EthernetSourceMac), Destination = new MacAddress(EthernetDestinatonMac), EtherType = EthernetType.None, }; SenderMacAddress = ValidMac(SenderMacAddress); DestinatonMacAddress = ValidMac(DestinatonMacAddress); ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = isRequest ? ArpOperation.Request : ArpOperation.Reply, SenderHardwareAddress = SenderMacAddress.Split(':').Select(x => Convert.ToByte(x, 16)).ToArray().AsReadOnly(), SenderProtocolAddress = SenderIpAddress.GetAddressBytes().AsReadOnly(), TargetHardwareAddress = DestinatonMacAddress.Split(':').Select(x => Convert.ToByte(x, 16)).ToArray().AsReadOnly(), TargetProtocolAddress = DestinationIpAddress.GetAddressBytes().AsReadOnly(), }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer); return(builder.Build(DateTime.Now)); }
/// <summary> /// This function build an IPv4 over Ethernet with payload packet. /// </summary> public static Packet BuildIpV4Packet() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(macAddressSource), Destination = new MacAddress(macAddressDest), EtherType = EthernetType.None, }; IpV4Layer ipV4Layer = new IpV4Layer { Source = new IpV4Address(ipSource), CurrentDestination = new IpV4Address(ipDest), Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = IpV4Protocol.Udp, Ttl = 100, TypeOfService = 0, }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(Encoding.ASCII.GetBytes("hello world")), }; PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, payloadLayer); return(builder.Build(DateTime.Now)); }
/// <summary> /// This function build an IPv6 over Ethernet with payload packet. /// </summary> public static Packet BuildIpV6Packet() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(macAddressSource), Destination = new MacAddress(macAddressDest), EtherType = EthernetType.None, }; IpV6Layer ipV6Layer = new IpV6Layer { Source = new IpV6Address("0123:4567:89AB:CDEF:0123:4567:89AB:CDEF"), CurrentDestination = new IpV6Address("FEDC:BA98:7654:3210:FEDC:BA98:7654:3210"), FlowLabel = 123, HopLimit = 100, NextHeader = IpV4Protocol.Udp, }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(Encoding.ASCII.GetBytes("hello world")), }; PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV6Layer, payloadLayer); return(builder.Build(DateTime.Now)); }
public void RandomUdpTest() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("00:01:02:03:04:05"), Destination = new MacAddress("A0:A1:A2:A3:A4:A5") }; int seed = new Random().Next(); Console.WriteLine("Seed: " + seed); Random random = new Random(seed); for (int i = 0; i != 1000; ++i) { IpV4Layer ipV4Layer = random.NextIpV4Layer(null); ipV4Layer.HeaderChecksum = null; IpV6Layer ipV6Layer = random.NextIpV6Layer(IpV4Protocol.Udp, false); EthernetType ethernetType = random.NextBool() ? EthernetType.IpV4 : EthernetType.IpV6; Layer ipLayer = (ethernetType == EthernetType.IpV4 ? (Layer)ipV4Layer : ipV6Layer); UdpLayer udpLayer = random.NextUdpLayer(); udpLayer.Checksum = null; PayloadLayer payloadLayer = random.NextPayloadLayer(random.Next(60000)); Packet packet = PacketBuilder.Build(DateTime.Now, ethernetLayer, ipLayer, udpLayer, payloadLayer); Assert.IsTrue(packet.IsValid, "IsValid"); // Ethernet ethernetLayer.EtherType = ethernetType; Assert.AreEqual(ethernetLayer, packet.Ethernet.ExtractLayer(), "Ethernet Layer"); ethernetLayer.EtherType = EthernetType.None; // Ip if (ipLayer == ipV4Layer) { // IpV4. ipV4Layer.Protocol = IpV4Protocol.Udp; ipV4Layer.HeaderChecksum = ((IpV4Layer)packet.Ethernet.IpV4.ExtractLayer()).HeaderChecksum; Assert.AreEqual(ipV4Layer, packet.Ethernet.IpV4.ExtractLayer(), "IP Layer"); ipV4Layer.HeaderChecksum = null; } else { // IpV6. Assert.AreEqual(ipV6Layer, packet.Ethernet.IpV6.ExtractLayer(), "IP Layer"); } // UDP udpLayer.Checksum = packet.Ethernet.Ip.Udp.Checksum; Assert.AreEqual(udpLayer, packet.Ethernet.Ip.Udp.ExtractLayer(), "UDP Layer"); Assert.AreEqual(UdpDatagram.HeaderLength + payloadLayer.Length, packet.Ethernet.Ip.Udp.TotalLength, "Total Length"); Assert.IsTrue(!udpLayer.CalculateChecksum && packet.Ethernet.Ip.Udp.Checksum == 0 || udpLayer.CalculateChecksum && packet.Ethernet.Ip.IsTransportChecksumCorrect, "IsTransportChecksumCorrect"); Assert.IsTrue(packet.Ethernet.Ip.Udp.IsChecksumOptional, "IsChecksumOptional"); Assert.AreEqual(payloadLayer.Data, packet.Ethernet.Ip.Udp.Payload, "Payload"); } }
/// <summary> /// This function build a VLanTaggedFrame over Ethernet with payload packet. /// </summary> public static Packet BuildVLanTaggedFramePacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(macAddressSource), Destination = new MacAddress("F4:06:69:06:DC:EF"), EtherType = EthernetType.None, // Will be filled automatically. }; VLanTaggedFrameLayer vLanTaggedFrameLayer = new VLanTaggedFrameLayer { PriorityCodePoint = ClassOfService.Background, CanonicalFormatIndicator = false, VLanIdentifier = 50, EtherType = EthernetType.IpV4, }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(Encoding.ASCII.GetBytes("hello world")), }; PacketBuilder builder = new PacketBuilder(ethernetLayer, vLanTaggedFrameLayer, payloadLayer); return(builder.Build(DateTime.Now)); }
public static Packet CreateRstPacketFor(ScanningOptions options, ushort targetPort) { TcpPacketFactory.RandomizeParameters(); EthernetLayer ethernetLayer = new EthernetLayer { Source = options.SourceMac, Destination = options.TargetMac, }; IpV4Layer ipV4Layer = new IpV4Layer { Source = options.SourceIP, CurrentDestination = options.TargetIP, Ttl = TcpPacketFactory.ttl, Fragmentation = TcpPacketFactory.fragmentation, Identification = TcpPacketFactory.identification }; TcpLayer tcpLayer = new TcpLayer { SourcePort = sourcePort, DestinationPort = targetPort, SequenceNumber = TcpPacketFactory.sequence, ControlBits = TcpControlBits.Reset, Window = TcpPacketFactory.windowSize, }; return(PacketBuilder.Build(DateTime.Now, ethernetLayer, ipV4Layer, tcpLayer)); }
public static PacketBuilder BuildVLanTaggedFramePacketBuilder(ClassOfService CoS) { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("01:01:01:01:01:01"), Destination = new MacAddress("90:1B:0E:1B:DD:E8"), EtherType = EthernetType.None, // Will be filled automatically. }; VLanTaggedFrameLayer vLanTaggedFrameLayer = new VLanTaggedFrameLayer { PriorityCodePoint = CoS, CanonicalFormatIndicator = false, VLanIdentifier = 50, EtherType = (EthernetType)34962, }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(new byte[1496]) }; return(new PacketBuilder(ethernetLayer, vLanTaggedFrameLayer, payloadLayer)); }
private Packet BuildArpPacketRequest(IpV4Address targetIp) { EthernetLayer ethernetLayer = new EthernetLayer { Source = _ownMacAddr, Destination = _macBroadcastAddr, //broadcast EtherType = EthernetType.None, // Will be filled automatically. }; ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Request, SenderHardwareAddress = Array.AsReadOnly(_ownMacAddrByte), // self mac-address SenderProtocolAddress = Array.AsReadOnly(_ownIpAddrByte), // self ip-address TargetHardwareAddress = Array.AsReadOnly(_targetMacAddr), // Not Yet known TargetProtocolAddress = Helper.IpAddressToBytes(targetIp) // ip we want to get the mac for }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer); return(builder.Build(DateTime.Now)); }
/* * sends arp spoofed packet to the target */ private void SpoofTarget(PacketCommunicator communicator, string targetIp) { Task.Factory.StartNew(() => { if (!_targetsPacketBuilders.ContainsKey(targetIp)) { var ether = new EthernetLayer { Source = new MacAddress(_myMac), Destination = new MacAddress(KvStore.IpMac[targetIp]), EtherType = EthernetType.None, }; var arp = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Reply, SenderHardwareAddress = ether.Source.ToBytes(), SenderProtocolAddress = new IpV4Address(_gatewayIp).ToBytes(), TargetHardwareAddress = ether.Destination.ToBytes(), TargetProtocolAddress = new IpV4Address(targetIp).ToBytes() }; _targetsPacketBuilders.Add(targetIp, new PacketBuilder(ether, arp)); } var packet = _targetsPacketBuilders[targetIp].Build(DateTime.Now); communicator.SendPacket(packet); }); }
/// <summary> /// This function build a VLanTaggedFrame over Ethernet with payload packet. /// </summary> public static Packet BuildVLanTaggedFramePacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("01:01:01:01:01:01"), Destination = new MacAddress("02:02:02:02:02:02"), EtherType = EthernetType.None, // Will be filled automatically. }; VLanTaggedFrameLayer vLanTaggedFrameLayer = new VLanTaggedFrameLayer { PriorityCodePoint = ClassOfService.NetworkControl, CanonicalFormatIndicator = false, VLanIdentifier = 50, EtherType = (EthernetType)34962, }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(new byte[] { 0x80, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x35, 0x00 }) }; PacketBuilder builder = new PacketBuilder(ethernetLayer, vLanTaggedFrameLayer, payloadLayer); return(builder.Build(DateTime.Now)); }
/// <summary> /// This function build an IGMP over IPv4 over Ethernet packet. /// </summary> public static Packet BuildIgmpPacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(macAddressSource), Destination = new MacAddress(macAddressDest), EtherType = EthernetType.None, // Will be filled automatically. }; IpV4Layer ipV4Layer = new IpV4Layer { Source = new IpV4Address(ipSource), CurrentDestination = new IpV4Address(ipDest), Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = null, // Will be filled automatically. Ttl = 100, TypeOfService = 0, }; IgmpQueryVersion1Layer igmpLayer = new IgmpQueryVersion1Layer { GroupAddress = new IpV4Address(ipSource), }; PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, igmpLayer); return(builder.Build(DateTime.Now)); }
public void RandomArpTest() { Random random = new Random(); for (int i = 0; i != 1000; ++i) { MacAddress ethernetSource = random.NextMacAddress(); EthernetLayer ethernetLayer = new EthernetLayer { Source = ethernetSource, }; ArpLayer arpLayer = random.NextArpLayer(); Packet packet = PacketBuilder.Build(DateTime.Now, ethernetLayer, arpLayer); Assert.IsTrue(packet.IsValid, "IsValid"); // Ethernet Assert.AreEqual(packet.Length - EthernetDatagram.HeaderLengthValue, packet.Ethernet.PayloadLength, "PayloadLength"); Assert.AreEqual(ethernetSource, packet.Ethernet.Source, "Ethernet Source"); Assert.AreEqual(EthernetDatagram.BroadcastAddress, packet.Ethernet.Destination, "Ethernet Destination"); Assert.AreEqual(EthernetType.Arp, packet.Ethernet.EtherType, "Ethernet EtherType"); // Arp Assert.AreEqual(ArpDatagram.HeaderBaseLength + 2 * arpLayer.SenderHardwareAddress.Count + 2 * arpLayer.SenderProtocolAddress.Count, packet.Ethernet.Arp.Length, "Arp length"); Assert.AreEqual(ArpHardwareType.Ethernet, packet.Ethernet.Arp.HardwareType, "Arp hardware type"); Assert.AreEqual(arpLayer, packet.Ethernet.Arp.ExtractLayer(), "ARP Layer"); Assert.AreNotEqual(arpLayer, random.NextArpLayer(), "ARP Layer"); Assert.AreEqual(arpLayer.GetHashCode(), packet.Ethernet.Arp.ExtractLayer().GetHashCode(), "ARP Layer"); ArpLayer differentArpLayer = random.NextArpLayer(); Assert.AreNotEqual(arpLayer.GetHashCode(), differentArpLayer.GetHashCode(), "ARP Layer"); } }
private static void preparePcap() { var source = new MacAddress(getClientMAC()); var dest = new MacAddress(getRouterMAC()); device = LivePacketDevice.AllLocalMachine[0]; communicator = device.Open(100, PacketDeviceOpenAttributes.Promiscuous, 1000); EthernetLayer ethLayer = new EthernetLayer { Source = source, Destination = dest }; ipLayer = new IpV4Layer { Source = new IpV4Address(LocalIPAddress()), Ttl = 128 }; icmpLayer = new IcmpEchoLayer(); icmpBuilder = new PacketBuilder(ethLayer, ipLayer, icmpLayer); TCPLayer = new TcpLayer(); TCPBuilder = new PacketBuilder(ethLayer, ipLayer, TCPLayer); if (!TCPMode) { communicator.SetFilter("icmp[0] = 0"); } else { //tcp[13] = 18 communicator.SetFilter("tcp[13] = 18 and port " + TCPPort); } }
private void SendSyn(PacketCommunicator communicator) { // Ethernet Layer EthernetLayer ethernetLayer = new EthernetLayer { Source = SourceMac, Destination = DestinationMac, }; // IPv4 Layer IpV4Layer ipV4Layer = new IpV4Layer { Source = SourceIpV4, CurrentDestination = DestinationIpV4, Ttl = 128, Fragmentation = new IpV4Fragmentation(IpV4FragmentationOptions.DoNotFragment, 0), Identification = 1234, }; // TCP Layer TcpLayer tcpLayer = new TcpLayer { SourcePort = _sourcePort, DestinationPort = _destinationPort, SequenceNumber = _seqNumber, ControlBits = TcpControlBits.Synchronize, Window = _windowSize, }; communicator.SendPacket(PacketBuilder.Build(DateTime.Now, ethernetLayer, ipV4Layer, tcpLayer)); _expectedAckNumber = _seqNumber + 1; }
private Packet BuildArpWhoHasPacket(uint remoteIpInt) { // Build ethernet layer var ethernetPacket = new EthernetLayer(); ethernetPacket.EtherType = EthernetType.Arp; ethernetPacket.Source = new MacAddress(this.config.LocalMac); ethernetPacket.Destination = new MacAddress("ff:ff:ff:ff:ff:ff"); // Build ARP layer var arpPacket = new ArpLayer(); arpPacket.ProtocolType = EthernetType.IpV4; arpPacket.Operation = ArpOperation.Request; arpPacket.SenderHardwareAddress = this.localMacBytesCollection; arpPacket.SenderProtocolAddress = this.localIpBytesCollection; arpPacket.TargetHardwareAddress = new ReadOnlyCollection <byte>(new byte[6] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }); byte[] ipAddresBytes = this.IpIntegerToByteArray(remoteIpInt); arpPacket.TargetProtocolAddress = new ReadOnlyCollection <byte>(ipAddresBytes); var packet = new PacketBuilder(ethernetPacket, arpPacket); return(packet.Build(DateTime.Now)); }
private static Packet ArpPacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(DeviceManager.GetDeviceMac()), Destination = new MacAddress(AttackVariables.Mac), EtherType = EthernetType.None, }; ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Request, SenderHardwareAddress = DeviceManager.GetDeviceMac().Split(':').Select(x => Convert.ToByte(x, 16)).ToArray().AsReadOnly(), SenderProtocolAddress = IPAddress.Parse("0.136.136.16").GetAddressBytes().AsReadOnly(), TargetHardwareAddress = AttackVariables.Mac.Split(':').Select(x => Convert.ToByte(x, 16)).ToArray().AsReadOnly(), TargetProtocolAddress = IPAddress.Parse(AttackVariables.IP).GetAddressBytes().AsReadOnly(), }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(AttackVariables.BufferSize), }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer, payloadLayer); return(builder.Build(DateTime.Now)); }
/// <summary> /// This function builds the Ethernet Row Data Packet with every third channel set to a color. /// </summary> private Packet BuildTestPacket(MacAddress source, MacAddress destination, int row, int pixelsWidth, int dataOffset, byte color, int testOffset) { int offset = 0; int width = pixelsWidth * 3; byte[] mainByte = new byte[(width) + 7]; EthernetType type = ((EthernetType)0x5500); if (row < 256) { type = ((EthernetType)0x5500); mainByte[0] = Convert.ToByte(row); } else { type = ((EthernetType)0x5501); mainByte[0] = Convert.ToByte(row % 256); } EthernetLayer ethernetLayer = new EthernetLayer { Source = source, Destination = destination, EtherType = type }; //mainByte[0] = Convert.ToByte(row); mainByte[1] = Convert.ToByte(offset >> 8); mainByte[2] = Convert.ToByte(offset & 0xFF); mainByte[3] = Convert.ToByte(pixelsWidth >> 8); mainByte[4] = Convert.ToByte(pixelsWidth & 0xFF); mainByte[5] = 0x08; mainByte[6] = 0x80; for (int i = 0; i < width; i++) { int indexwHead = 7 + i; byte oldValue = 0; if (i % 3 == testOffset) { oldValue = color; } //int oldint = Convert.ToInt32(data[i + (fullDataOffset * 3)]); int newint = ((oldValue * _brightness) / 100); byte newValue = Convert.ToByte(newint); mainByte[indexwHead] = newValue; //mainByte[indexwHead] = 0x88; } PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(mainByte) }; PacketBuilder builder = new PacketBuilder(ethernetLayer, payloadLayer); return(builder.Build(DateTime.Now)); }
private static Packet BuildRouterArpPacket() { //byte[] mama = _host[1].Split('.') // .Select(t => byte.Parse(t, NumberStyles.AllowHexSpecifier)) // .ToArray(); EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("90:2b:34:33:35:f3"), Destination = new MacAddress("9c:80:df:84:9b:9c"), EtherType = EthernetType.Arp, // Will be filled automatically. }; ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Reply, //156, 128, 223, 132, 155, 156 // 144, 43, 52, 51, 53, 243 //192, 37, 6, 60, 172, 120 SenderHardwareAddress = new byte[] { 144, 43, 52, 51, 53, 243 }.AsReadOnly(), // 03:03:03:03:03:03. SenderProtocolAddress = new byte[] { 192, 168, 2, 176 }.AsReadOnly(), // 1.2.3.4. TargetHardwareAddress = new byte[] { 156, 128, 223, 132, 155, 156 }.AsReadOnly(), // 04:04:04:04:04:04. TargetProtocolAddress = new byte[] { 192, 168, 2, 1 }.AsReadOnly(), // 11.22.33.44. }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer); return(builder.Build(DateTime.Now)); }
/// <summary> /// This function build an ICMP over IPv4 over Ethernet packet. /// </summary> private static Packet BuildIcmpPacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("01:01:01:01:01:01"), Destination = new MacAddress("02:02:02:02:02:02"), EtherType = EthernetType.None, // Will be filled automatically. }; IpV4Layer ipV4Layer = new IpV4Layer { Source = new IpV4Address("1.2.3.4"), CurrentDestination = new IpV4Address("11.22.33.44"), Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = null, // Will be filled automatically. Ttl = 100, TypeOfService = 0, }; IcmpEchoLayer icmpLayer = new IcmpEchoLayer { Checksum = null, // Will be filled automatically. Identifier = 456, SequenceNumber = 800, }; PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, icmpLayer); return(builder.Build(DateTime.Now)); }
public static Packet BuildVLanTaggedFramePacket(int cyclecounter) { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("28:63:36:88:02:52"), Destination = new MacAddress("00:1b:1b:6b:6b:0e"), EtherType = EthernetType.None, // Will be filled automatically. }; VLanTaggedFrameLayer vLanTaggedFrameLayer = new VLanTaggedFrameLayer { PriorityCodePoint = ClassOfService.InternetworkControl, CanonicalFormatIndicator = false, VLanIdentifier = 50, EtherType = (EthernetType)34962, }; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(new byte[] { 0x80, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0x80, 0xFF, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, Convert.ToByte((cyclecounter & 0xFF00) > 8), Convert.ToByte(cyclecounter & 0xFF), 0x35, 0x00 }) }; PacketBuilder builder = new PacketBuilder(ethernetLayer, vLanTaggedFrameLayer, payloadLayer); return(builder.Build(DateTime.Now)); }
public void RandomEthernetTest() { Random random = new Random(); for (int i = 0; i != 1000; ++i) { EthernetLayer ethernetLayer = random.NextEthernetLayer(); int ethernetPayloadLength = random.Next(1500); PayloadLayer payloadLayer = new PayloadLayer { Data = random.NextDatagram(ethernetPayloadLength), }; Packet packet = PacketBuilder.Build(DateTime.Now, ethernetLayer, payloadLayer); // Ethernet Assert.IsTrue(new[] { EthernetType.IpV4, EthernetType.Arp, EthernetType.VLanTaggedFrame }.Contains(packet.Ethernet.EtherType) || packet.IsValid, "IsValid - EtherType = " + packet.Ethernet.EtherType); Assert.AreEqual(packet.Length - EthernetDatagram.HeaderLengthValue, packet.Ethernet.PayloadLength, "PayloadLength"); Assert.AreEqual(ethernetLayer, packet.Ethernet.ExtractLayer(), "Ethernet Layer"); Assert.AreEqual(ethernetLayer.GetHashCode(), packet.Ethernet.ExtractLayer().GetHashCode(), "Ethernet Layer Hash Code"); Assert.AreNotEqual(random.NextEthernetLayer().GetHashCode(), packet.Ethernet.ExtractLayer().GetHashCode(), "Ethernet Layer Hash Code"); Assert.AreEqual(ethernetLayer.ToString(), packet.Ethernet.ExtractLayer().ToString(), "Ethernet Layer ToString()"); Assert.AreNotEqual(random.NextEthernetLayer().ToString(), packet.Ethernet.ExtractLayer().ToString(), "Ethernet Layer ToString()"); Assert.AreNotEqual(2, packet.Ethernet.Source, "Ethernet Source"); Assert.AreEqual(payloadLayer.Data, packet.Ethernet.Payload); } }
public ArpReply(MacAddress sourceMacAddress, IpV4Address sourceIpv4Address, MacAddress targetMacAddress, IpV4Address targetIpv4Address) { SourceMacAddress = sourceMacAddress; SourceIpv4Address = sourceIpv4Address; TargetMacAddress = targetMacAddress; TargetIpv4Address = targetIpv4Address; EthernetLayer = new EthernetLayer { Source = SourceMacAddress, Destination = targetMacAddress, EtherType = EthernetType.Arp }; ArpLayer = new ArpLayer { Operation = ArpOperation.Reply, ProtocolType = EthernetType.IpV4, SenderHardwareAddress = SourceMacAddress.GetNetworkBytes().AsReadOnly(), SenderProtocolAddress = SourceIpv4Address.GetNetworkBytes().AsReadOnly(), TargetHardwareAddress = TargetMacAddress.GetNetworkBytes().AsReadOnly(), TargetProtocolAddress = TargetIpv4Address.GetNetworkBytes().AsReadOnly() }; PacketBuilder = new PacketBuilder(EthernetLayer, ArpLayer); }
public void RandomVLanTaggedFrameTest() { Random random = new Random(); for (int i = 0; i != 1000; ++i) { EthernetLayer ethernetLayer = random.NextEthernetLayer(EthernetType.None); VLanTaggedFrameLayer vLanTaggedFrameLayer = random.NextVLanTaggedFrameLayer(); int payloadLength = random.Next(1500); PayloadLayer payloadLayer = new PayloadLayer { Data = random.NextDatagram(payloadLength), }; Packet packet = PacketBuilder.Build(DateTime.Now, ethernetLayer, vLanTaggedFrameLayer, payloadLayer); ethernetLayer.EtherType = EthernetType.VLanTaggedFrame; // Test output. Assert.AreEqual(ethernetLayer, packet.Ethernet.ExtractLayer()); Assert.AreEqual(vLanTaggedFrameLayer, packet.Ethernet.VLanTaggedFrame.ExtractLayer()); Assert.AreEqual(vLanTaggedFrameLayer.GetHashCode(), packet.Ethernet.VLanTaggedFrame.ExtractLayer().GetHashCode()); Assert.AreNotEqual(random.NextVLanTaggedFrameLayer().GetHashCode(), packet.Ethernet.VLanTaggedFrame.ExtractLayer().GetHashCode()); Assert.AreEqual(vLanTaggedFrameLayer.TagControlInformation, packet.Ethernet.VLanTaggedFrame.TagControlInformation); Assert.AreEqual(payloadLayer.Data, packet.Ethernet.VLanTaggedFrame.Payload); } }
/// <summary> /// This function build an ARP over Ethernet packet. /// </summary> public static Packet BuildArpPacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress("68:05:ca:1e:94:1c"), Destination = new MacAddress("FF:FF:FF:FF:FF:FF"), EtherType = EthernetType.None, // Will be filled automatically. }; ArpLayer arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.InverseRequest, SenderHardwareAddress = new byte[] { 104, 5, 202, 30, 148, 28 }.AsReadOnly(), // 68:05:ca:1e:94:1c SenderProtocolAddress = new byte[] { 10, 128, 24, 154 }.AsReadOnly(), // 1.2.3.4. TargetHardwareAddress = new byte[] { 08, 46, 95, 228, 211, 146 }.AsReadOnly(), // 04:04:04:04:04:04. TargetProtocolAddress = new byte[] { 255, 255, 255, 255 }.AsReadOnly(), // 11.22.33.44. }; PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer); return(builder.Build(DateTime.Now)); }
public ArpRequest(IpV4Address ipV4AddressToIdentify, MacAddress requesterMacAddress, IpV4Address requesterIpV4Address, Action <MacAddress> onIdentified) { if (requesterIpV4Address == ipV4AddressToIdentify) { throw new ArgumentException($"It doesn't make sense to ask {requesterIpV4Address} who {ipV4AddressToIdentify} is."); } IpV4AddressToIdentify = ipV4AddressToIdentify; RequesterMacAddress = requesterMacAddress; RequesterIpV4Address = requesterIpV4Address; OnIdentified = onIdentified; EthernetLayer = new EthernetLayer { Source = requesterMacAddress, Destination = NetworkConstants.BroadcastMacAddress, EtherType = EthernetType.Arp }; ArpLayer = new ArpLayer { Operation = ArpOperation.Request, ProtocolType = EthernetType.IpV4, SenderHardwareAddress = requesterMacAddress.GetNetworkBytes().AsReadOnly(), SenderProtocolAddress = requesterIpV4Address.GetNetworkBytes().AsReadOnly(), TargetHardwareAddress = NetworkConstants.BroadcastMacAddress.GetNetworkBytes().AsReadOnly(), TargetProtocolAddress = ipV4AddressToIdentify.GetNetworkBytes().AsReadOnly() }; PacketBuilder = new PacketBuilder(EthernetLayer, ArpLayer); }
/// <summary> /// This function builds the Ethernet 0x0AFF Packet. /// </summary> private Packet BuildSecondPacket(MacAddress source, MacAddress destination) { EthernetLayer ethernetLayer = new EthernetLayer { Source = source, Destination = destination, EtherType = ((EthernetType)0x0AFF) }; byte[] mainByte = new byte[63]; mainByte[0] = 0xFF; mainByte[1] = 0xFF; mainByte[2] = 0xFF; PayloadLayer payloadLayer = new PayloadLayer { Data = new Datagram(mainByte) }; PacketBuilder builder = new PacketBuilder(ethernetLayer, payloadLayer); return(builder.Build(DateTime.Now)); }
private static Packet BuildIcmpPacket(MacAddress SourceMac, MacAddress DestinationMac, IpV4Address SourceIp, IpV4Address CurrentDestination, string packetType) { EthernetLayer ethernetLayer = new EthernetLayer { Source = SourceMac, Destination = DestinationMac, EtherType = EthernetType.None, // Will be filled automatically. }; IpV4Layer ipV4Layer = new IpV4Layer { //Source = new IpV4Address("1.2.3.4"), //CurrentDestination = new IpV4Address("11.22.33.44"), Source = SourceIp, CurrentDestination = CurrentDestination, Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = null, // Will be filled automatically. Ttl = 100, TypeOfService = 0, }; IcmpEchoLayer icmpLayer = null; IcmpEchoReplyLayer icmpRLayer = null; PacketBuilder builder = null; if (packetType.Equals("REQUEST")) { Console.WriteLine("Request"); icmpLayer = new IcmpEchoLayer { Checksum = null, // Will be filled automatically. Identifier = 456, SequenceNumber = 800, }; builder = new PacketBuilder(ethernetLayer, ipV4Layer, icmpLayer); } else { Console.WriteLine("Reply"); icmpRLayer = new IcmpEchoReplyLayer { Checksum = null, // Will be filled automatically. Identifier = 456, SequenceNumber = 800, }; builder = new PacketBuilder(ethernetLayer, ipV4Layer, icmpRLayer); } return(builder.Build(DateTime.Now)); }
/// <summary> /// This function build an IPv4 over GRE over IPv4 over Ethernet packet. /// </summary> public static Packet BuildGrePacket() { EthernetLayer ethernetLayer = new EthernetLayer { Source = new MacAddress(macAddressSource), Destination = new MacAddress(macAddressDest), EtherType = EthernetType.None, // Will be filled automatically. }; IpV4Layer ipV4Layer = new IpV4Layer { Source = new IpV4Address(ipSource), CurrentDestination = new IpV4Address(ipDest), Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = null, // Will be filled automatically. Ttl = 100, TypeOfService = 0, }; GreLayer greLayer = new GreLayer { Version = GreVersion.Gre, ProtocolType = EthernetType.None, // Will be filled automatically. RecursionControl = 0, FutureUseBits = 0, ChecksumPresent = true, Checksum = null, // Will be filled automatically. Key = null, SequenceNumber = 123, AcknowledgmentSequenceNumber = null, RoutingOffset = null, Routing = null, StrictSourceRoute = false, }; IpV4Layer innerIpV4Layer = new IpV4Layer { Source = new IpV4Address("100.200.201.202"), CurrentDestination = new IpV4Address("123.254.132.40"), Fragmentation = IpV4Fragmentation.None, HeaderChecksum = null, // Will be filled automatically. Identification = 123, Options = IpV4Options.None, Protocol = IpV4Protocol.Udp, Ttl = 120, TypeOfService = 0, }; PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, greLayer, innerIpV4Layer); return(builder.Build(DateTime.Now)); }
/// <summary> /// Assigns from prefilled ethernet layer (with user values) to other tcp layer (assigns only user values, if they are not default) /// </summary> /// <param name="layerToCopyFrom">Ethernet layer with user filled values</param> /// <param name="layerToCopyTo">Ethernet layer to assign values to</param> /// <returns>Modified Ethernet layer with newly assigned user values</returns> private Layer AssignUserValuesFromFilledEthernetLayerToOtherEthernetLayer(EthernetLayer layerToCopyFrom, EthernetLayer layerToCopyTo) { layerToCopyTo.Destination = (layerToCopyFrom.Destination != default) ? layerToCopyFrom.Destination : layerToCopyTo.Destination; layerToCopyTo.EtherType = (layerToCopyFrom.EtherType != default) ? layerToCopyFrom.EtherType : layerToCopyTo.EtherType; layerToCopyTo.Source = (layerToCopyFrom.Source != default) ? layerToCopyFrom.Source : layerToCopyTo.Source; return(layerToCopyTo); }
public arp() { IList<LivePacketDevice> allDevices = LivePacketDevice.AllLocalMachine; if ( allDevices.Count == 0 ) { Console.WriteLine( "No interfaces found! Make sure WinPcap is installed." ); return; } selectedDevice = allDevices[0]; getLocalMacAndIP( out ip, out mac ); ethernetLayer = new EthernetLayer { Source = new MacAddress( ToMac( mac.ToString() ) ), Destination = new MacAddress( "FF:FF:FF:FF:FF:FF" ), EtherType = EthernetType.None, // Will be filled automatically. }; arpLayer = new ArpLayer { ProtocolType = EthernetType.IpV4, Operation = ArpOperation.Request, SenderHardwareAddress = Array.AsReadOnly( mac.GetAddressBytes().ToArray() ), // 03:03:03:03:03:03. SenderProtocolAddress = Array.AsReadOnly( ip ), // 1.2.3.4. TargetHardwareAddress = Array.AsReadOnly( new byte[] { 0, 0, 0, 0, 0, 0 } ), // 00:00:00:00:00:00. }; outputCommunicator = selectedDevice.Open( 100, PacketDeviceOpenAttributes.Promiscuous, 1000 ); }