/// <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 );
}
