private async Task ReadAsync(Socket s)
{
// Reusable SocketAsyncEventArgs and awaitable wrapper
var args = new SocketAsyncEventArgs();
args.SetBuffer(new byte[0x100000], 0, 0x100000);
var awaitable = new SocketAwaitable(args);
while (true)
{
await s.ReceiveAsync(awaitable);
var bytesRead = args.BytesTransferred;
if (bytesRead <= 0)
{
throw new Exception("Raw socket is disconnected");
}
var ipPacket = new IPv4Packet(new ByteArraySegment(args.Buffer, 0, bytesRead));
if (ipPacket.Version != IPVersion.IPv4 || ipPacket.Protocol != PacketDotNet.ProtocolType.Tcp)
{
continue;
}
OnPacketReceived(ipPacket);
}
}
public static EthernetPacket Packet(string ipsrc, string ipdes, int portsrc, int portdes, string macsrc, string macdes, EthernetPacketType packetType)
{
TcpPacket tcpPacket = new TcpPacket(ushort.Parse(portsrc.ToString()), ushort.Parse(portdes.ToString())); // ports # TCP Packet
IPAddress IpSourceAddress = IPAddress.Parse(ipsrc);
IPAddress IpDestinationAddress = IPAddress.Parse(ipdes);
IPv4Packet ipPacket = new IPv4Packet(IpSourceAddress, IpDestinationAddress);// IP addresses # IP Packets
string SourceMacAddress = macsrc;
string DestinationMacAddress = macdes;
//convert above value to a Physical Address
PhysicalAddress MACsource = PhysicalAddress.Parse(SourceMacAddress);
PhysicalAddress MACdestination = PhysicalAddress.Parse(DestinationMacAddress);
EthernetPacket eth0Packet = new EthernetPacket(MACsource, MACdestination, packetType); // MAC address # Eth0 Packet
// this below does Packet construction Encapsulation
ipPacket.PayloadPacket = tcpPacket;
eth0Packet.PayloadPacket = ipPacket;
Console.WriteLine(eth0Packet.ToString());
// allows us to retrieve bytes from the packets
byte[] packetBytes = eth0Packet.Bytes;
return(eth0Packet);
}
void AgentBase(IPv4Packet packet, Metadata.BaseMetadata metadata)
{
metadata.SourceAddress = packet.SourceAddress.ToString();
metadata.TargetAddress = packet.DestinationAddress.ToString();
if (packet.Protocol == ProtocolType.Udp)
{
if (packet.PayloadPacket != null)
{
UdpPacket udpPacket = packet.PayloadPacket as UdpPacket;
metadata.SourcePort = udpPacket.SourcePort;
metadata.TargetPort = udpPacket.DestinationPort;
}
metadata.ProtocolName = "UDP";
}
else if (packet.Protocol == ProtocolType.Tcp)
{
if (packet.PayloadPacket != null)
{
TcpPacket tcpPacket = packet.PayloadPacket as TcpPacket;
metadata.SourcePort = tcpPacket.SourcePort;
metadata.TargetPort = tcpPacket.DestinationPort;
}
metadata.ProtocolName = "TCP";
}
else
{
metadata.ProtocolName = packet.Protocol.ToString();
}
Metadata.MetadataSaver.Instance.Add(metadata);
//LogHelper.Debug(string.Format("发现{0}协议数据{1}-{2}", packet.Protocol.ToString(), packet.SourceAddress, packet.DestinationAddress));
}
private void btnSendPacket_Click(object sender, RoutedEventArgs e)
{
device = gbxDevInfo.DataContext as ICaptureDevice;
// Open the device
device.Open();
try
{
IPAddress ip = IPAddress.Parse(tbxSourceIp.Text);
IPAddress ipaddress = System.Net.IPAddress.Parse(tbxDestinationIp.Text);
TcpPacket tcpPakje = new TcpPacket(80, 80);
IPv4Packet pakje = new IPv4Packet(ip, ipaddress);
pakje.PayloadData = System.Text.Encoding.ASCII.GetBytes(tbxPayloadIp.Text);
pakje.TimeToLive = int.Parse(tbxTTLIp.Text);
// pakje.Protocol = tbxProtocolIp.Text;
device.SendPacket(pakje);
Console.WriteLine("-- Packet sent successfuly.");
}
catch (Exception ex)
{
Console.WriteLine("-- " + ex.Message);
}
// Close the pcap device
device.Close();
Console.WriteLine("-- Device closed.");
}
public override async Task PacketReceived(object sender, DataMessageEventArgs eventArgs)
{
if (!initialized)
{
return;
}
var ipv4Packet = IPv4Packet.Parse(eventArgs.Data);
ipv4Packet.SourceAddress = GetIpFromPhysicalAddress(GetPhysicalAddressFromId(eventArgs.SourceId));
ipv4Packet.DestinationAddress = IPAddress.Broadcast;
var ethernetPacket = new EthernetPacket(GetPhysicalAddressFromId(eventArgs.SourceId),
new PhysicalAddress(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }), ipv4Packet, EthernetPacket.PacketType.IpV4);
if (!eventArgs.IsBroadcast)
{
ipv4Packet.DestinationAddress = GetIpFromPhysicalAddress(tapInterface.GetPhysicalAddress());
ethernetPacket.DestinationAddress = tapInterface.GetPhysicalAddress();
}
var packetData = ethernetPacket.ToBytes();
tapStream.Write(packetData, 0, packetData.Length);
await Task.Delay(0);
}
public void GreIPv4Parsing()
{
var dev = new CaptureFileReaderDevice(NUnitSetupClass.CaptureDirectory + "gre_all_options.pcap");
dev.Open();
var rawCapture = dev.GetNextPacket();
dev.Close();
LinkLayers linkLayers = rawCapture.GetLinkLayers();
if (linkLayers == LinkLayers.Ethernet)
{
Console.WriteLine("Linklayer is ethernet");
// Linklayer
Packet p = Packet.ParsePacket(linkLayers, rawCapture.Data);
Assert.IsNotNull(p);
// Ethernet
EthernetPacket eth = p.Extract <EthernetPacket>();
Assert.IsNotNull(eth);
if (eth.Type == EthernetType.IPv4)
{
Console.WriteLine("IPv4 inside ethernet");
// IPv4
IPv4Packet ipv4 = eth.Extract <IPv4Packet>();
Assert.IsNotNull(ipv4);
if (ipv4.Protocol == ProtocolType.Gre)
{
Console.WriteLine("GRE inside IPv4");
// Gre
GrePacket grep = ipv4.Extract <GrePacket>();
Assert.IsNotNull(grep);
// String output
Console.WriteLine(grep.ToString());
// Get header
if (grep.HasCheckSum)
{
Console.WriteLine("GRE has checksum flag");
}
if (grep.HasKey)
{
Console.WriteLine("GRE has key flag");
}
if (grep.HasReserved)
{
Console.WriteLine("GRE has reserved flag");
}
if (grep.HasSequence)
{
Console.WriteLine("GRE has sequence flag");
}
Assert.AreEqual(grep.Protocol, EthernetType.IPv4);
}
}
}
}
void device_OnPacketArrival(object sender, CaptureEventArgs e)
{
IPv4Packet ipPacket;
if (e.Packet.LinkLayerType != LinkLayers.Null)
{
var linkPacket = Packet.ParsePacket(e.Packet.LinkLayerType, e.Packet.Data);
ipPacket = linkPacket.PayloadPacket as IPv4Packet;
}
else
{
ipPacket = new IPv4Packet(new ByteArraySegment(e.Packet.Data, 4, e.Packet.Data.Length - 4));
}
if (ipPacket == null)
{
return;
}
var ipData = ipPacket.BytesHighPerformance;
var ipData2 = new ArraySegment <byte>(ipData.Bytes, ipData.Offset, ipData.Length);
OnPacketReceived(ipData2);
var device = (WinPcapDevice)sender;
if (device.Statistics.DroppedPackets != _droppedPackets || device.Statistics.InterfaceDroppedPackets != _interfaceDroppedPackets)
{
_droppedPackets = device.Statistics.DroppedPackets;
_interfaceDroppedPackets = device.Statistics.InterfaceDroppedPackets;
OnWarning(string.Format("DroppedPackets {0}, InterfaceDroppedPackets {1}", device.Statistics.DroppedPackets, device.Statistics.InterfaceDroppedPackets));
}
}
public void TestSend()
{
var dst = IPAddress.Parse("8.8.8.8");
var nic = IpHelper.GetBestInterface(dst);
Assert.NotNull(nic, "No internet connected interface found");
var src = nic.GetIPProperties().UnicastAddresses
.Select(addr => addr.Address)
.FirstOrDefault(addr => addr.AddressFamily == AddressFamily.InterNetwork);
var ifIndex = nic.GetIPProperties().GetIPv4Properties().Index;
Console.WriteLine($"Using NIC {nic.Name} [{ifIndex}]");
Console.WriteLine($"Sending from {src} to {dst}");
var device = new WinDivertDevice();
device.Open();
try
{
var udp = new UdpPacket(5000, 5000);
udp.PayloadData = new byte[100];
var ip = IPv4Packet.RandomPacket();
ip.PayloadPacket = udp;
ip.SourceAddress = src;
ip.DestinationAddress = dst;
device.SendPacket(ip);
}
finally
{
device.Close();
}
}
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);
}
public static Packet BuildDnsReply(IPAddress senderIp, PhysicalAddress senderMac, ushort senderPort, IPAddress targetIp, PhysicalAddress targetMac, ushort targetPort, byte[] requestData, IPAddress answerIP, int vlanId)
{
byte[] answerContent = new byte[requestData.Length + 16];
requestData.CopyTo(answerContent, 0);
int contentLen = answerContent.Length;
// DNS Header
answerContent[2] = 0x81; answerContent[3] = 0x80; // Flags : 81 80 (Standard Response, No Error)
answerContent[6] = 0x00; answerContent[7] = 0x01; // Answer RRs : 1
// DNS Answer
answerContent[contentLen - 16] = 0xc0; answerContent[contentLen - 15] = 0x0c; // Name : c0 0c
answerContent[contentLen - 14] = 0x00; answerContent[contentLen - 13] = 0x01; // Type : A (Host Address)
answerContent[contentLen - 12] = 0x00; answerContent[contentLen - 11] = 0x01; // Class : IN
answerContent[contentLen - 10] = 0x00; answerContent[contentLen - 9] = 0x00; answerContent[contentLen - 8] = 0x00; answerContent[contentLen - 7] = 0x05; // 5 (seconds)//0x3c; // Time To Live : 60 (seconds)
answerContent[contentLen - 6] = 0x00; answerContent[contentLen - 5] = 0x04; // Data Length : 4
byte[] ipBytes = answerIP.GetAddressBytes();
answerContent[contentLen - 4] = ipBytes[0];
answerContent[contentLen - 3] = ipBytes[1];
answerContent[contentLen - 2] = ipBytes[2];
answerContent[contentLen - 1] = ipBytes[3];
EthernetPacket ePacket = new EthernetPacket(senderMac, targetMac, EthernetPacketType.IpV4);
IPv4Packet v4Packet = new IPv4Packet(senderIp, targetIp);
UdpPacket uPacket = new UdpPacket(senderPort, targetPort);
return(PacketBuilder.BuildPacket(vlanId, ePacket, v4Packet, uPacket, answerContent));
}
/**
* Process packets when they arrive
*/
private void device_onPacketArrival(Object sender, CaptureEventArgs packet)
{
try
{
String address = null, protocol = null;
// Convert the packet data from a byte array to a EthernetPacket instance
EthernetPacket ethernetPacket = (EthernetPacket)Packet.ParsePacket(packet.Packet.LinkLayerType, packet.Packet.Data);
// IPv4
if (ethernetPacket.PayloadPacket is IPv4Packet)
{
IPv4Packet ip = (IPv4Packet)ethernetPacket.PayloadPacket;
address = ip.SourceAddress.ToString();
protocol = ip.Protocol.ToString();
}
// IPv6
else if (ethernetPacket.PayloadPacket is IPv6Packet)
{
IPv6Packet ip = (IPv6Packet)ethernetPacket.PayloadPacket;
// Convert address to IPv4 since the GeoIP database we're using doesn't support IPv6 lookups
address = ip.SourceAddress.MapToIPv4().ToString();
protocol = ip.Protocol.ToString();
}
// ARP
else if (ethernetPacket.PayloadPacket is ARPPacket)
{
ARPPacket arp = (ARPPacket)ethernetPacket.PayloadPacket;
address = arp.SenderProtocolAddress.ToString();
// Check if this is a gratuitious ARP
checkForGratuitiousArp(arp);
protocol = "ARP";
}
// Other
else
{
// Don't care about other packet types
return;
}
// We care about this packet, so the packet counter can increment
numPackets++;
// If we haven't processes this IP address yet, add it to the address queue
if (address != null && !addedAddresses.Contains(address) && !pendingAddresses.ContainsKey(address))
{
pendingAddresses.Add(address, protocol);
}
} catch (Exception)
{
// Handle issues gracefully
}
}
/// <summary>
/// Fires off on a seperate thread when a packet is available
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ProcessPacket(RawCapture incoming)
{
try
{
Packet packet = Packet.ParsePacket(LinkLayers.Ethernet, incoming.Data);
EthernetPacket ethSrc = (EthernetPacket)packet.Extract(typeof(EthernetPacket));
IPv4Packet ipSrc = (IPv4Packet)packet.Extract(typeof(IPv4Packet));
if (ipSrc.Protocol == IPProtocolType.UDP)
{
UdpPacket udpSrc = (UdpPacket)packet.Extract(typeof(UdpPacket));
// From RFC 1002 Section 4.2.1.1
// Need to grab the transaction id for the reply
UInt16 namedTrnId = BitConverter.ToUInt16(udpSrc.PayloadData, 0);
// Looking for Response = query(0), OpCode = Query(0)
// 11000000 00000000
UInt16 flags = Utility.ReverseUInt16(BitConverter.ToUInt16(udpSrc.PayloadData, 2));
if ((flags & 0xc000) == 0)
{
// Grab the name and make sure it's WPAD
string name = Encoding.Default.GetString(udpSrc.PayloadData, 12, 34);
if (Utility.DecodeName(name) == WpadHostName)
{
Logger.AddToInfoView("Received NBNS query for {0} from {1}", WpadHostName, ethSrc.SourceHwAddress);
UdpPacket udpDst = new UdpPacket(NetbiosPort, NetbiosPort);
udpDst.PayloadData = SetupResponse(namedTrnId, GetDeviceIp(this.Device));
IPv4Packet ipDst = new IPv4Packet(GetDeviceIp(this.Device), ipSrc.SourceAddress);
ipDst.PayloadPacket = udpDst;
udpDst.UpdateCalculatedValues();
udpDst.UpdateUDPChecksum();
ipDst.UpdateCalculatedValues();
ipDst.UpdateIPChecksum();
EthernetPacket ethDst = new EthernetPacket(this.Device.MacAddress, ethSrc.SourceHwAddress, EthernetPacketType.IpV4);
ethDst.PayloadPacket = ipDst;
ethDst.UpdateCalculatedValues();
Logger.AddToInfoView("Sending poisoned response for {0}", WpadHostName);
this.Device.SendPacket(ethDst.Bytes);
}
}
}
else if (ipSrc.Protocol == IPProtocolType.TCP)
{
TcpPacket tcpSrc = (TcpPacket)packet.Extract(typeof(TcpPacket));
if (tcpSrc.Syn)
{
Logger.AddToInfoView("SYN sent {0}:{1}", ipSrc.DestinationAddress, tcpSrc.SourcePort);
}
}
}
catch (Exception ex)
{
Logger.AddToErrorView("OnPacketArrival", ex);
}
}
private bool Route(ref IPv4Packet packet)
{
bool done = false;
EthernetPacket eth_packet = packet.ParentPacket as EthernetPacket;
foreach (Route route in Routes)
{
if (eth_packet.SourceHwAddress.Equals(route.Source.MacAddress) &&
(route.SourceIp == null || route.SourceIp.Equals(packet.SourceAddress)) &&
(route.DestIp == null || route.DestIp.Equals(packet.DestinationAddress)))
{
if (route.NewSourceIp != null)
{
packet.SourceAddress = route.NewSourceIp.IpAddress;
eth_packet.SourceHwAddress = route.NewSourceIp.MacAddress;
done = true;
}
if (route.NewDestIp != null)
{
packet.DestinationAddress = route.NewDestIp.IpAddress;
eth_packet.DestinationHwAddress = route.NewDestIp.MacAddress;
done = true;
}
}
}
return(done);
}
private static void sendDhcpRelease(PhysicalAddress pSourceHwAddress, IPAddress pSourceIpAddress, PhysicalAddress pDestinationHwAddress, IPAddress pDestinationIpAddress)
{
PhysicalAddress ethernetSourceHwAddress = pSourceHwAddress;
PhysicalAddress ethernetDestinationHwAddress = pDestinationHwAddress;
var ethernetPacket = new EthernetPacket(ethernetSourceHwAddress,
ethernetDestinationHwAddress,
EthernetType.None);
var ipPacket = new IPv4Packet(pSourceIpAddress, pDestinationIpAddress);
const ushort udpSourcePort = 68;
const ushort udpDestinationPort = 67;
var udpPacket = new UdpPacket(udpSourcePort, udpDestinationPort);
//-- Combine all bytes to single payload
byte[] payload = buildDhcpReleasePacket(pSourceIpAddress, pSourceHwAddress, pDestinationIpAddress);
udpPacket.PayloadData = payload;
ipPacket.PayloadPacket = udpPacket;
ethernetPacket.PayloadPacket = ipPacket;
device.SendPacket(ethernetPacket);
Console.WriteLine("DHCP Release successful send to: " + pDestinationIpAddress + " from: " + pDestinationIpAddress + " at: " + DateTime.Now.ToShortTimeString());
}
static void createPacket()
{
Console.Write("Enter name of text file (for example t.txt): ");
string path = Console.ReadLine();
string txtFile = File.ReadAllText(path, Encoding.Default);
ushort tcpSourcePort = 123;
ushort tcpDestinationPort = 321;
var tcpPacket = new TcpPacket(tcpSourcePort, tcpDestinationPort);
tcpPacket.PayloadData = Encoding.UTF8.GetBytes(txtFile);
var ipSourceAddress = System.Net.IPAddress.Parse("127.0.0.1");
var ipDestinationAddress = System.Net.IPAddress.Parse("127.0.0.2");
var ipPacket = new IPv4Packet(ipSourceAddress, ipDestinationAddress);
var sourceHwAddress = PhysicalAddress.Parse("90-90-90-90-90-90");
var destinationHwAddress = PhysicalAddress.Parse("80-80-80-80-80-80");
var ethernetPacket = new EthernetPacket(sourceHwAddress, destinationHwAddress, EthernetPacketType.None);
ipPacket.PayloadPacket = tcpPacket;
ethernetPacket.PayloadPacket = ipPacket;
getPacket(ethernetPacket);
}
/// <summary>
/// 使用函数构造UDP数据包
/// </summary>
/// <param name="device"></param>
/// <param name="dst_mac"></param>
/// <param name="dst_ip"></param>
/// <param name="src_port"></param>
/// <param name="dst_port"></param>
/// <param name="send_data"></param>
/// <returns></returns>
private byte[] GenUDPPacket(PcapDevice device, PhysicalAddress dst_mac, IPAddress dst_ip, int src_port,
int dst_port, string send_data)
{
// 构造UDP部分数据报
UdpPacket udp_pkg = new UdpPacket((ushort)src_port, (ushort)dst_port);
udp_pkg.PayloadData = strToToHexByte(send_data);
udp_pkg.UpdateCalculatedValues();
// 构造IP部分数据报
IPv4Packet ip_pkg = new IPv4Packet(device.Interface.Addresses[1].Addr.ipAddress, dst_ip);
ip_pkg.Protocol = IPProtocolType.UDP;
ip_pkg.Version = IpVersion.IPv4;
ip_pkg.PayloadData = udp_pkg.Bytes;
ip_pkg.TimeToLive = 10;
ip_pkg.UpdateCalculatedValues();
ip_pkg.UpdateIPChecksum();
// 构造以太网帧
EthernetPacket net_pkg = new EthernetPacket(device.MacAddress, dst_mac, EthernetPacketType.IpV4);
net_pkg.Type = EthernetPacketType.IpV4;
net_pkg.PayloadData = ip_pkg.Bytes;
net_pkg.UpdateCalculatedValues();
return(net_pkg.Bytes);
}
static byte[] CreatePacket(int packetType = (int)EthernetPacketType.IPv4, int srcPort = 123, int dstPort = 321)
{
UInt16 tcpSourcePort = 123;
UInt16 tcpDestinationPort = 321;
var udpPacket = new UdpPacket(tcpSourcePort, tcpDestinationPort);
var ipSourceAddress = System.Net.IPAddress.Parse("192.168.1.1");
var ipDestinationAddress = System.Net.IPAddress.Parse("192.168.1.2");
var ipPacket = new IPv4Packet(ipSourceAddress, ipDestinationAddress);
var sourceHwAddress = "90-90-90-90-90-90";
var ethernetSourceHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(sourceHwAddress);
var destinationHwAddress = "80-80-80-80-80-80";
var ethernetDestinationHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(destinationHwAddress);
// NOTE: using EthernetPacketType.None to illustrate that the ethernet
// protocol type is updated based on the packet payload that is
// assigned to that particular ethernet packet
var ethernetPacket = new EthernetPacket(ethernetSourceHwAddress,
ethernetDestinationHwAddress,
EthernetPacketType.None);
// Now stitch all of the packets together
ipPacket.PayloadPacket = udpPacket;
ethernetPacket.PayloadPacket = ipPacket;
// and print out the packet to see that it looks just like we wanted it to
byte[] payload = ethernetPacket.Bytes;
// it can be crc error. but this is just test.
payload[12] = (byte)(packetType / 0x0100);
payload[13] = (byte)(packetType % 0x0100);
return(payload);
}
public void ChangeValues()
{
var packet = IPv4Packet.RandomPacket();
packet.Id = 12345;
Assert.AreEqual(12345, packet.Id);
}
private async Task ReadAsync(Socket s)
{
// Reusable SocketAsyncEventArgs and awaitable wrapper
var args = new SocketAsyncEventArgs();
args.SetBuffer(new byte[0x100000], 0, 0x100000);
var awaitable = new SocketAwaitable(args);
while (_isInit)
{
await s.ReceiveAsync(awaitable);
var bytesRead = args.BytesTransferred;
if (bytesRead <= 0)
{
throw new Exception("Raw socket is disconnected");
}
IPv4Packet ipPacket;
try { ipPacket = new IPv4Packet(new ByteArraySegment(args.Buffer, 0, bytesRead)); }
catch (InvalidOperationException) { continue; }
if (ipPacket.Version != IpVersion.IPv4 || ipPacket.Protocol != IPProtocolType.TCP)
{
continue;
}
OnPacketReceived(ipPacket);
}
_socket.Close();
_socket = null;
}
private void SendRTPPacket(string sourceSocket, string destinationSocket)
{
try
{
//logger.Debug("Attempting to send RTP packet from " + sourceSocket + " to " + destinationSocket + ".");
Log("Attempting to send RTP packet from " + sourceSocket + " to " + destinationSocket + ".");
IPEndPoint sourceEP = IPSocket.GetIPEndPoint(sourceSocket);
IPEndPoint destEP = IPSocket.GetIPEndPoint(destinationSocket);
RTPPacket rtpPacket = new RTPPacket(80);
rtpPacket.Header.SequenceNumber = (UInt16)6500;
rtpPacket.Header.Timestamp = 100000;
UDPPacket udpPacket = new UDPPacket(sourceEP.Port, destEP.Port, rtpPacket.GetBytes());
IPv4Header ipHeader = new IPv4Header(ProtocolType.Udp, Crypto.GetRandomInt(6), sourceEP.Address, destEP.Address);
IPv4Packet ipPacket = new IPv4Packet(ipHeader, udpPacket.GetBytes());
byte[] data = ipPacket.GetBytes();
Socket rawSocket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
rawSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, 1);
rawSocket.SendTo(data, destEP);
}
catch (Exception excp)
{
logger.Error("Exception SendRTPPacket. " + excp.Message);
}
}
public IPFragmentKey(IPv4Packet ipv4Packet)
{
this.SourceAddress = ipv4Packet.SourceAddress;
this.DestinationAddress = ipv4Packet.DestinationAddress;
this.Protocol = ipv4Packet.Protocol;
this.IPIdentification = ipv4Packet.Id;
}
public IPv4Packet CreateIPv4Packet(EthernetPacket ethernetHeader)
{
int ipv4PacketTotalLength = Int32.Parse(textBoxTotalLength.Text);
byte[] bytes = new byte[EthernetFields_Fields.ETH_HEADER_LEN + ipv4PacketTotalLength];
IPv4Packet ipv4Packet = new IPv4Packet(
EthernetFields_Fields.ETH_HEADER_LEN,
bytes);
// Ethernet fields
ipv4Packet.EthernetHeader = ethernetHeader.Bytes;
// IP fields
ipv4Packet.Version = 4;
ipv4Packet.IPHeaderLength = IPv4Fields_Fields.IP_HEADER_LEN;
ipv4Packet.TypeOfService = Int32.Parse(textBoxDS.Text);
ipv4Packet.IPTotalLength = ipv4PacketTotalLength;
ipv4Packet.Id = 0;
ipv4Packet.FragmentFlags = Int32.Parse(textBoxFlags.Text);
ipv4Packet.FragmentOffset = 0;
ipv4Packet.TimeToLive = Int32.Parse(textBoxTTL.Text);
ipv4Packet.IPProtocol = (IPProtocol.IPProtocolType)((DictionaryEntry)comboBoxIPProtocols.SelectedItem).Key;
ipv4Packet.SourceAddress = IPAddress.Parse(textBoxSourceAddress.Text);
ipv4Packet.DestinationAddress = IPAddress.Parse(textBoxDestinationAddress.Text);
ipv4Packet.ComputeIPChecksum(true);
ipv4Packet.IPData = GetRandomPacketData(ipv4Packet.IPPayloadLength);
return(ipv4Packet);
}
public TempPacketSaveData GetPacket(byte[] payload, int streamId)
{
PhysicalAddress emptyAddress = PhysicalAddress.Parse("000000000000");
PacketDotNet.EthernetPacket etherPacket = new EthernetPacket(emptyAddress, emptyAddress, EthernetType.IPv4);
bool flip = streamId < 0;
streamId = Math.Abs(streamId);
Random r = new Random(streamId);
IPAddress sourceIp = new IPAddress(r.Next());
IPAddress destIp = new IPAddress(r.Next());
if (flip)
{
IPAddress tempAddress = sourceIp;
sourceIp = destIp;
destIp = tempAddress;
}
IPv4Packet ipPacket = new IPv4Packet(sourceIp, destIp)
{
Protocol = ProtocolType.Udp
};
TcpPacket tcpPacket = new TcpPacket(1, 1)
{
PayloadData = payload
};
ipPacket.PayloadPacket = tcpPacket;
etherPacket.PayloadPacket = ipPacket;
return(new TempPacketSaveData(etherPacket.Bytes, LinkLayerType.Ethernet));
}
public static void Main(string[] args)
{
ushort tcpSourcePort = 123;
ushort tcpDestinationPort = 321;
var tcpPacket = new TcpPacket(tcpSourcePort, tcpDestinationPort);
var ipSourceAddress = System.Net.IPAddress.Parse("192.168.1.1");
var ipDestinationAddress = System.Net.IPAddress.Parse("192.168.1.2");
var ipPacket = new IPv4Packet(ipSourceAddress, ipDestinationAddress);
var sourceHwAddress = "90-90-90-90-90-90";
var ethernetSourceHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(sourceHwAddress);
var destinationHwAddress = "80-80-80-80-80-80";
var ethernetDestinationHwAddress = System.Net.NetworkInformation.PhysicalAddress.Parse(destinationHwAddress);
// NOTE: using EthernetPacketType.None to illustrate that the ethernet
// protocol type is updated based on the packet payload that is
// assigned to that particular ethernet packet
var ethernetPacket = new EthernetPacket(ethernetSourceHwAddress,
ethernetDestinationHwAddress,
EthernetPacketType.None);
// Now stitch all of the packets together
ipPacket.PayloadPacket = tcpPacket;
ethernetPacket.PayloadPacket = ipPacket;
// and print out the packet to see that it looks just like we wanted it to
Console.WriteLine(ethernetPacket.ToString());
Console.ReadKey(true);
}
private void IPv4(IPv4Packet v4)
{
if (IPv4Node == null)
{
IPv4Node = new TreeNode();
}
IPv4Node.Nodes.Clear();
IPv4Node.Text = string.Format("Internet Protocol Version 4, Src: {0}, Dst: {1}",
v4.SourceAddress, v4.DestinationAddress);
IPv4Node.Nodes.Add(string.Format("Version: {0}", v4.Version));
IPv4Node.Nodes.Add(string.Format("Header Length: {0} bytes", v4.HeaderLength));
IPv4Node.Nodes.Add(string.Format("Differentiated Services Field: {0}", v4.TypeOfService));
IPv4Node.Nodes.Add(string.Format("Total Length: {0}", v4.TotalLength));
IPv4Node.Nodes.Add(string.Format("Identification: {0}", v4.Id));
IPv4Node.Nodes.Add(string.Format("Flags: {0}", v4.FragmentFlags));
IPv4Node.Nodes.Add(string.Format("Fragment offset: {0}", v4.FragmentOffset));
IPv4Node.Nodes.Add(string.Format("Time to live: {0}", v4.TimeToLive));
IPv4Node.Nodes.Add(string.Format("Protocol: {0}", v4.Protocol));
IPv4Node.Nodes.Add(string.Format("Header checksum: {0}", v4.Checksum));
IPv4Node.Nodes.Add(string.Format("Source: {0}", v4.SourceAddress));
IPv4Node.Nodes.Add(string.Format("Destination: {0}", v4.DestinationAddress));
tree.Nodes.Add(IPv4Node);
}
private async Task DnsReply(ushort transactionId, List <string> labels, ushort id, ushort sourcePort)
{
var answerDnsPacket = new DnsPacket(transactionId, 0, 0, new List <DnsPacket.ResourceRecord>
{
new DnsPacket.ResourceRecord
{
Class = 0x0001,
Type = 0x0001,
Labels = labels
}
}, new List <DnsPacket.ResourceRecord>
{
new DnsPacket.ResourceRecord
{
Class = 0x0001,
Type = 0x0001,
TTL = 30 * 60,
Labels = labels,
Data = GetIpFromId(id).GetAddressBytes()
}
},
new List <DnsPacket.ResourceRecord>(),
new List <DnsPacket.ResourceRecord>(), DnsPacket.DnsFlags.IsAutorative | DnsPacket.DnsFlags.IsResponse);
var answerIpV4Packet = new IPv4Packet(GetIpFromId(-1), GetIpFromId(selfId));
answerIpV4Packet.SetPayloadPacket(new UdpPacket(53, sourcePort,
answerDnsPacket, answerIpV4Packet));
var answerEthernetPacket = new EthernetPacket(GetPhysicalAddressFromId(-1),
GetPhysicalAddressFromId(selfId), answerIpV4Packet, EthernetPacket.PacketType.IpV4);
var answerData = answerEthernetPacket.ToBytes();
await tapStream.WriteAsync(answerData, 0, answerData.Length);
}
public static Frame CreateFromIpPacket(IPv4Packet ipPacket, Int64 timestamp)
{
var frame = CreateFrameBase(timestamp, ipPacket);
frame.IsValid = DissectSourceIpPacket(frame, ipPacket);
return(frame);
}
private bool is_injected_packet_to_be_filtered(ref ARPPacket p_arp, ref IPv4Packet p_ipv4, ref UdpPacket p_udp, ref TcpPacket p_tcp)
{
// FILTER ARP PACKETS
if (p_arp != null)
{
// FILTER ARP PACKETS TO OR FROM GATEWAY IPs
foreach (IPAddress ip in gateway_ips)
{
if (p_arp.TargetProtocolAddress.Equals(ip))
{
return(true);
}
else if (p_arp.SenderProtocolAddress.Equals(ip))
{
return(true);
}
}
}
// FILTER IPv4 PACKETS
if (p_ipv4 != null)
{
// FILTER IP PACKETS TO OR FROM GATEWAY IPs
if (pdev_filter_exclude_gatway_ips)
{
foreach (IPAddress ip in gateway_ips)
{
if (p_ipv4.DestinationAddress.Equals(ip))
{
return(true);
}
else if (p_ipv4.SourceAddress.Equals(ip))
{
return(true);
}
}
}
}
// FILTER UDP PACKETS
if (p_udp != null)
{
// FILTER UDP PACKETS TO WELL KNOWN PORTS
if (pdev_filter_wellknown_ports && p_udp.DestinationPort < 1024)
{
return(true);
}
}
// FILTER TCP PACKETS
if (p_tcp != null)
{
// FILTER TCP PACKETS TO WELL KNOWN PORTS
if (pdev_filter_wellknown_ports && p_tcp.DestinationPort < 1024)
{
return(true);
}
}
return(false);
}
public SendPacket(DateTime dateTime, IPv4Packet ipv4)
{
UdpPacket udp = (UdpPacket)ipv4.PayloadPacket;
Date = dateTime;
PayLoad = udp.PayloadData;
Destination = new IPEndPoint(ipv4.DestinationAddress, udp.DestinationPort);
}
public static Packet BuildDHCPDiscoverPacket(IPAddress srcIP, PhysicalAddress srcMAC, int vlanID)
{
EthernetPacket ePacket = new EthernetPacket(srcMAC, NetAddress.BroadcastMAC, EthernetPacketType.IpV4);
IPv4Packet iPacket = new IPv4Packet(srcIP, IPAddress.Broadcast);
UdpPacket uPacket = new UdpPacket(68, 67);
return(PacketBuilder.BuildPacket(vlanID, ePacket, iPacket, uPacket, GetDHCPDiscoverPacketData(srcMAC)));
}
public static Packet CreatePacket(Param param)
{
Packet ret = null;
//create layer 4
if (param.packetType == Param.PacketType.TCP)
{
TcpPacket tcpPacket = new TcpPacket(param.sPort, param.dPort);
tcpPacket.AllFlags = param.tcpFlag;
if (param.dIP.ToString().Contains("."))
{
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
ipPacket.PayloadPacket = tcpPacket;
tcpPacket.PayloadData = param.payload;
ret.PayloadPacket = ipPacket;
ipPacket.UpdateCalculatedValues();
ipPacket.UpdateIPChecksum();
tcpPacket.Checksum = (ushort)tcpPacket.CalculateTCPChecksum();
}
else
{
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
ipPacket.PayloadPacket = tcpPacket;
tcpPacket.PayloadData = param.payload;
ret.PayloadPacket = ipPacket;
}
}
else if (param.packetType == Param.PacketType.UDP)
{
UdpPacket udpPacket = new UdpPacket(param.sPort, param.dPort);
if (param.dIP.ToString().Contains("."))
{
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
ipPacket.PayloadPacket = udpPacket;
udpPacket.PayloadData = param.payload;
udpPacket.UpdateUDPChecksum();
ipPacket.PayloadLength = (ushort)(ipPacket.PayloadLength + param.payload.Length);
ipPacket.UpdateIPChecksum();
ret.PayloadPacket = ipPacket;
}
else
{
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
ipPacket.PayloadPacket = udpPacket;
udpPacket.PayloadData = param.payload;
udpPacket.UpdateUDPChecksum();
ipPacket.PayloadLength = (ushort)(ipPacket.PayloadLength + param.payload.Length);
ret.PayloadPacket = ipPacket;
}
}
else if (param.packetType == Param.PacketType.ICMP)
{
ICMPv4Packet icmpPacket = new ICMPv4Packet(new ByteArraySegment(new byte[32]));
if (param.type != 0 && param.code != 0)
{
icmpPacket.TypeCode = (ICMPv4TypeCodes)((param.type * 256) + (param.code));
}
else if (param.type != 0)
{
icmpPacket.TypeCode = (ICMPv4TypeCodes)((param.type * 256));
}
else
{
icmpPacket.TypeCode = ICMPv4TypeCodes.EchoRequest;
}
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ipPacket.PayloadPacket = icmpPacket;
ipPacket.Checksum = ipPacket.CalculateIPChecksum();
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
ret.PayloadPacket = ipPacket;
}
else if (param.packetType == Param.PacketType.ICMPv6)
{
ICMPv6Packet icmpv6Packet = CreateICMPv6Packet(param);
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ipPacket.PayloadPacket = icmpv6Packet;
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
ret.PayloadPacket = ipPacket;
}
else if (param.packetType == Param.PacketType.IP)
{
if (param.dIP.ToString().Contains("."))
{
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV4);
IPv4Packet ipPacket = new IPv4Packet(param.sIP, param.dIP);
if (param.IPv4Frag) { ipPacket.FragmentFlags = (int)1; }
ipPacket.Protocol = param.IPProtocol;
ipPacket.PayloadData = param.payload;
ipPacket.UpdateCalculatedValues();
ret.PayloadPacket = ipPacket;
ipPacket.UpdateIPChecksum();
}
else
{
ret = new EthernetPacket(param.sMAC, param.dMAC, EthernetPacketType.IpV6);
//if extension headers were not specified, just put the payload
if (param.ExtentionHeader.Count == 0)
{
IPv6Packet ipPacket = new IPv6Packet(param.sIP, param.dIP);
ipPacket.Protocol = param.IPProtocol;
ipPacket.PayloadData = param.payload;
ipPacket.PayloadLength = (ushort)param.payload.Length;
ipPacket.UpdateCalculatedValues();
ret.PayloadPacket = ipPacket;
}
else
{
ret = PacketFactory.CreateEHPacket(param, (EthernetPacket)ret);
}
ret.UpdateCalculatedValues();
}
}
else if (param.packetType == Param.PacketType.EtherType)
{
ret = new EthernetPacket(param.sMAC, param.dMAC, param.EtherTypeProtocol);
byte[] etherBuffer = (new byte[64]);
var payload = new byte[etherBuffer.Length + (param.payload).Length];
etherBuffer.CopyTo(payload, 0);
(param.payload).CopyTo(payload, etherBuffer.Length);
ret.PayloadData = payload;
ret.UpdateCalculatedValues();
}
return ret;
}
public void SendRTPPacket(string sourceSocket, string destinationSocket)
{
try
{
//logger.Debug("Attempting to send RTP packet from " + sourceSocket + " to " + destinationSocket + ".");
FireLogEvent("Attempting to send RTP packet from " + sourceSocket + " to " + destinationSocket + ".");
IPEndPoint sourceEP = IPSocket.GetIPEndPoint(sourceSocket);
IPEndPoint destEP = IPSocket.GetIPEndPoint(destinationSocket);
RTPPacket rtpPacket = new RTPPacket(80);
rtpPacket.Header.SequenceNumber = (UInt16)6500;
rtpPacket.Header.Timestamp = 100000;
UDPPacket udpPacket = new UDPPacket(sourceEP.Port, destEP.Port, rtpPacket.GetBytes());
IPv4Header ipHeader = new IPv4Header(ProtocolType.Udp, Crypto.GetRandomInt(6), sourceEP.Address, destEP.Address);
IPv4Packet ipPacket = new IPv4Packet(ipHeader, udpPacket.GetBytes());
byte[] data = ipPacket.GetBytes();
Socket rawSocket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.IP);
rawSocket.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, 1);
rawSocket.SendTo(data, destEP);
}
catch (Exception excp)
{
logger.Error("Exception SendRTPPacket. " + excp.Message);
}
}
