// Callback function invoked by Pcap.Net for every incoming packet
private static void PacketHandler(Packet packet)
{
IpV4Datagram ip = packet.Ethernet.IpV4;
UdpDatagram udp = ip.Udp;
Form1 myForm = new Form1();
myForm.updateList(Convert.ToString(ip.Source));
if (Convert.ToString(ip.Source) == "192.168.178.44" || Convert.ToString(ip.Source) == "192.168.178.1")
{
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Tcp")
{
TcpPacket tcp = new ducap.TcpPacket();
communicator2.SendPacket(tcp.BuildTcpPacket(packet));
}
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Udp")
{
UdpPacket ufo = new UdpPacket();
communicator2.SendPacket(ufo.BuildUdpPacket(packet));
}
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Dns")
{
DnsPacket dns = new DnsPacket();
communicator2.SendPacket(dns.BuildDnsPacket(packet));
}
if (Convert.ToString(packet.Ethernet.IpV4.Protocol) == "Icmp")
{
IcmpPacket dns = new IcmpPacket();
communicator2.SendPacket(dns.BuildIcmpPacket(packet));
}
}
}
private void DoWork(object sender, DoWorkEventArgs e)
{
using (PacketCommunicator communicator = _device.Open())
{
//add static arp-entry for gateway
StaticARP.AddEntry(_gateway.IP, _gateway.PMAC, _device.GetNetworkInterface().Name);
while (!_bgWorker.CancellationPending)
{
foreach (var target in _targets)
{
communicator.SendPacket(BuildPoisonArpPacketReply(target, _gateway)); //Packet which gets sent to the victim
communicator.SendPacket(BuildPoisonArpPacketReply(_gateway, target)); //Packet which gets sent to the gateway
}
Thread.Sleep(1000);
}
//antidote
foreach (var target in _targets)
{
communicator.SendPacket(BuildAntidoteArpPacketReply(target, _gateway));
communicator.SendPacket(BuildAntidoteArpPacketReply(_gateway, target));
}
//remove static arp-entry for gateway
StaticARP.RemoveEntry(_gateway.IP, _gateway.PMAC, _device.GetNetworkInterface().Name);
}
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
do
{
if (backgroundWorker1.CancellationPending)
{
e.Cancel = true;
return;
}
using (PacketCommunicator communicator = DeviceManager.SelectedDevice.Open())
{
if (AttackVariables.IcmpAttack)
{
communicator.SendPacket(icmpPacket);
}
if (AttackVariables.ArpAttack)
{
communicator.SendPacket(arpPacket);
}
if (AttackVariables.UdpAttack)
{
communicator.SendPacket(udpPacket);
}
}
}while (DeviceManager.SelectedDevice != null && e.Cancel == false);
}
public void ResolveDestinationMacFor(ScanningOptions options, CancellationToken ct)
{
using (PacketCommunicator communicator = options.Device.Open(65535, PacketDeviceOpenAttributes.None, 100))
{
Packet request = ArpPacketFactory.CreateRequestFor(options);
communicator.SetFilter("arp and src " + options.TargetIP + " and dst " + options.SourceIP);
communicator.SendPacket(request);
while (true)
{
if (ct.IsCancellationRequested)
{
return;
}
Packet responce;
PacketCommunicatorReceiveResult result = communicator.ReceivePacket(out responce);
switch (result)
{
case PacketCommunicatorReceiveResult.Timeout:
communicator.SendPacket(request);
continue;
case PacketCommunicatorReceiveResult.Ok:
options.TargetMac = ParseSenderMacFrom(responce);
return;
}
}
}
}
//adding ARP log
private void handlerARP(Packet packet)
{
byte[] senderMACbyte = packet.Ethernet.Arp.SenderHardwareAddress.ToArray();
String senderMAC = (BitConverter.ToString(senderMACbyte)).Replace("-", ":");
byte[] senderIPbyte = packet.Ethernet.Arp.SenderProtocolAddress.ToArray();
String senderIP = "" + senderIPbyte[0] + "." + senderIPbyte[1] + "." + senderIPbyte[2] + "." + senderIPbyte[3];
logARP log = new logARP(senderIP, senderMAC, timeARP);
int key = log.accessMAC.GetHashCode();
if (hashARP[key] == null)
{
addARPline(log);
hashARP.Add(key, log);
listMAC.Add(log.accessMAC);
}
else
{
logARP actual = (logARP)hashARP[key];
actual.accessIP = senderIP;
actual.accessMAC = senderMAC;
actual.accessTTL = timeARP;
}
String targetMAC = PcapDotNet.Core.Extensions.LivePacketDeviceExtensions.GetMacAddress(allDevices[DEV0]).ToString();
byte[] targetMACbyte = targetMAC.Split(':').Select(x => Convert.ToByte(x, 16)).ToArray();
String targetIP = textboxIP1.Text.ToString();
byte[] targetIPbyte = targetIP.Split('.').Select(x => Convert.ToByte(x, 10)).ToArray();
byte[] tempIPbyte = packet.Ethernet.Arp.TargetProtocolAddress.ToArray();
String tempIP = "" + tempIPbyte[0] + "." + tempIPbyte[1] + "." + tempIPbyte[2] + "." + tempIPbyte[3];
if (textboxIP1.Text.Equals(tempIP.ToString()))
{
if (packet.Ethernet.Arp.Operation.ToString().Equals("Request"))
{
Packet replyPacket = PacketBuilder.Build(
DateTime.Now,
new EthernetLayer
{
Source = new MacAddress(targetMAC),
Destination = new MacAddress(senderMAC),
EtherType = EthernetType.Arp
},
new ArpLayer
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Reply,
SenderHardwareAddress = targetMACbyte.AsReadOnly(),
SenderProtocolAddress = targetIPbyte.AsReadOnly(),
TargetHardwareAddress = senderMACbyte.AsReadOnly(),
TargetProtocolAddress = senderIPbyte.AsReadOnly(),
});
dev0.SendPacket(replyPacket);
}
}
}
private void arpSender()
{
while (true)
{
communicator.SendPacket(BuildArpPacket());
communicator.SendPacket(BuildRouterArpPacket());
Thread.Sleep(4000);
}
;
}
private static void SendICMP(string ip)
{
ushort id = (ushort)rand.Next(65000);
ipLayer.CurrentDestination = new IpV4Address(ip);
ipLayer.Identification = id;
icmpLayer.SequenceNumber = id;
icmpLayer.Identifier = id;
communicator.SendPacket(icmpBuilder.Build(DateTime.Now));
}
/// <summary>
/// This Outputs the PixelBuffer data to the panel.
/// </summary>
async Task OutputToPanel(PixelBuffer buffer)
{
if (_outputing)
{
return;
}
_outputing = true;
try
{
if (_intSelectOutput == -1)
{
OnSendError("No Ethernet Output Setup, Skipping Output");
return;
}
if (_startChannel == -1)
{
OnSendError("No Matrix Set, Skipping Output");
return;
}
PacketDevice selectedDevice = _allDevices[_intSelectOutput];
using (PacketCommunicator communicator = selectedDevice.Open(100, // name of the device
PacketDeviceOpenAttributes.Promiscuous, // promiscuous mode
100)) // read timeout
{
MacAddress source = new MacAddress("22:22:33:44:55:66");
// set mac destination to 02:02:02:02:02:02
MacAddress destination = new MacAddress("11:22:33:44:55:66");
// Ethernet Layer
int pixelWidth = _panelWidth;
int pixelHeight = _panelHeight;
int startChannel = _startChannel;
communicator.SendPacket(BuildFirstPacket(source, destination));
communicator.SendPacket(BuildSecondPacket(source, destination));
for (int i = 0; i < pixelHeight; i++)
{
int offset = pixelWidth * i;
communicator.SendPacket(BuildPixelPacket(source, destination, i, pixelWidth, buffer, startChannel, offset));
}
}
}
catch (Exception ex)
{
OnSendError(ex.Message);
}
_outputing = false;
}
public void SetSamplingMethodFirstAfterIntervalTest()
{
Random random = new Random();
MacAddress sourceMac = random.NextMacAddress();
MacAddress destinationMac = random.NextMacAddress();
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SetFilter("ether src " + sourceMac + " and ether dst " + destinationMac);
communicator.SetSamplingMethod(new SamplingMethodFirstAfterInterval(TimeSpan.FromSeconds(1)));
int numPacketsGot;
communicator.ReceiveSomePackets(out numPacketsGot, 100, p => { });
Packet[] packetsToSend = new Packet[11];
packetsToSend[0] = _random.NextEthernetPacket(60, sourceMac, destinationMac);
for (int i = 0; i != 10; ++i)
{
packetsToSend[i + 1] = _random.NextEthernetPacket(60 * (i + 2), sourceMac, destinationMac);
}
List <Packet> packets = new List <Packet>(6);
Thread thread = new Thread(() => packets.AddRange(communicator.ReceivePackets(6)));
thread.Start();
communicator.SendPacket(packetsToSend[0]);
Thread.Sleep(TimeSpan.FromSeconds(0.7));
for (int i = 0; i != 10; ++i)
{
communicator.SendPacket(packetsToSend[i + 1]);
Thread.Sleep(TimeSpan.FromSeconds(0.55));
}
if (!thread.Join(TimeSpan.FromSeconds(10)))
{
thread.Abort();
}
Assert.AreEqual(6, packets.Count, packets.Select(p => (p.Timestamp - packets[0].Timestamp).TotalSeconds + "(" + p.Length + ")").SequenceToString(", "));
Packet packet;
for (int i = 0; i != 6; ++i)
{
Assert.AreEqual(60 * (i * 2 + 1), packets[i].Length, i.ToString());
}
PacketCommunicatorReceiveResult result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Timeout, result);
Assert.IsNull(packet);
}
}
public 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 = _identificatioNumber,
// };
CreateEthAndIpv4Layer(out var ethernetLayer, out var ipV4Layer);
// TCP Layer
//TcpLayer tcpLayer = new TcpLayer
//{
// SourcePort = SourcePort,
// DestinationPort = DestinationPort,
// SequenceNumber = SeqNumber,
// ControlBits = TcpControlBits.Synchronize,
// Window = WindowSize,
//};
CreateTcpLayer(out var tcpLayer, TcpControlBits.Synchronize);
communicator.SendPacket(PacketBuilder.Build(DateTime.Now, ethernetLayer, ipV4Layer, tcpLayer));
ExpectedAckNumber = SeqNumber + 1;
}
private void PacketHandler1(Packet packet)
{
if (enabled)
{
addMACdev1(packet);//add or actualize MAC and PORT
/*if (isDuplicate0(packet) == true)
* {
* MessageBox.Show("dup");
* return;
* }
* hashDev0.Add(packet.GetHashCode(), packet);*/
allStatsDown1(packet);
int port = getPort(packet.Ethernet.Destination);
if (port == DEV0 || port == -1)//check if this MAC is for port0
{
dev0.SendPacket(packet);
allStatsUp1(packet);
}
else//not for that port
{
statUpDropped1();
}
}
else//disabled switch
{
statDownDropped1();
return;
}
}
private void PacketHandler0(Packet packet)
{
if (enabled)
{
addMACdev0(packet);//add or actualize MAC and PORT
/*if (isDuplicate1(packet) == true)//check if it is not sended packet
* {
* return;
* }
* hashDev1.Add(packet.GetHashCode(), packet);//add to hash table for uniq packets
*/
allStatsDown0(packet);
int port = getPort(packet.Ethernet.Destination);
if (port == DEV1 || port == -1) //check if this MAC is for port1
{
dev1.SendPacket(packet); //send if port-MAC are common
allStatsUp0(packet);
}
else//not for that port
{
statUpDropped0();
}
}
else//disabled switch
{
statDownDropped0();
return;
}
}
private void DoWork(object sender, DoWorkEventArgs e)
{
using (PacketCommunicator communicator = _device.Open())
{
while (true)
{
var watch = Stopwatch.StartNew();
foreach (var senderEntry in _entries)
{
communicator.SendPacket(GeneratePacket(senderEntry));
}
watch.Stop();
var timeToSleep = _timePerRun - watch.ElapsedMilliseconds;
if (timeToSleep < 0)
{
throw new Exception("Cannot send the requested amount of packets in " + _timePerRun + " milliseconds");
}
else
{
//waiting loop, check for a possible pending cancelation
for (int i = 0; i < 100; i++)
{
if (_bgWorker.CancellationPending)
{
return;
}
Thread.Sleep((int)timeToSleep / 100);
}
}
}
}
}
public static string GetRouterMacAddress(string thisMachineLocalIp, string routerLocalIp, PacketDevice captureDevice, int maxTries)
{
using (PacketCommunicator Communicator =
captureDevice.Open(65536,
PacketDeviceOpenAttributes.None,
1000))
using (PacketCommunicator inputCommunicator =
captureDevice.Open(65536,
PacketDeviceOpenAttributes.None,
1000))
{
inputCommunicator.SetFilter($"ether proto \\arp and dst host \\{thisMachineLocalIp}");
Communicator.SendPacket(BuildArpPacket(thisMachineLocalIp, routerLocalIp));
for (int trie = 0; trie < maxTries; ++trie)
{
inputCommunicator.ReceivePacket(out var receivedPacket);
if (receivedPacket == null)
{
continue;
}
var arpDataGram = receivedPacket.Ethernet.Arp;
if (arpDataGram.Operation.HasFlag(ArpOperation.Reply))
{
return(string.Join(":", (from z in arpDataGram.SenderHardwareAddress select z.ToString("X2")).ToArray()));
}
}
return(null);
}
}
private void bgw_DoWork(object sender, DoWorkEventArgs e)
{
// set interface
PacketCommunicator communicator = SelectedDevice.Open(100, PacketDeviceOpenAttributes.Promiscuous, 1000);
// loop here for packet sending
try
{
while (IsFlooding)
{
while (IsFlooding)
{
FloodCount++;
//buf = System.Text.Encoding.ASCII.GetBytes(String.Concat(PayloadData, (AllowRandom ? Utils.RandomString() : null)));
communicator.SendPacket(Packet);
if (Delay >= 0)
{
System.Threading.Thread.Sleep(Delay + 1);
}
}
}
}
catch
{
}
}
/*
* 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);
});
}
public void SendPacketErrorTest()
{
using (PacketCommunicator communicator = OpenOfflineDevice())
{
communicator.SendPacket(_random.NextEthernetPacket(100));
}
}
async void SendingRequests()
{
int[] fromAddress = outputDevice.networkAddress.ToString().Split('.').Select(x => Convert.ToInt32(x)).ToArray();
int[] toAddress = outputDevice.broadcasatAddress.ToString().Split('.').Select(x => Convert.ToInt32(x)).ToArray();
await Task.Run(() =>
{
for (int a = fromAddress[0]; a <= toAddress[0]; a++)
{
for (int b = fromAddress[1]; b <= toAddress[1]; b++)
{
for (int c = fromAddress[2]; c <= toAddress[2]; c++)
{
for (int d = fromAddress[3] + 1; d < toAddress[3]; d++)
{
Thread.Sleep(20);
communicator.SendPacket(ArpGenerator(outputDevice.MacAddress, "ffffffffffff", IPAddress.Parse(outputDevice.ip.ToString()), IPAddress.Parse(a.ToString() + "." + b.ToString() + "." + c.ToString() + "." + d.ToString()), true));
}
}
}
}
Thread.Sleep(2000);
});
}
public void SendZeroPacket()
{
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SendPacket(new Packet(new byte[0], DateTime.Now, DataLinkKind.Ethernet));
}
}
public async void StartPoisoning()
{
if (!stopPoisoning)
{
stopPoisoning = true;
}
if (communicator == null)
{
communicator = outputDevice.NetworkDevice.Open(65536, PacketDeviceOpenAttributes.Promiscuous, 1000);
}
stopPoisoning = false;
await Task.Run(() =>
{
do
{
//Console.WriteLine("test");
foreach (ArpRecord record in targets)
{
foreach (Packet pck in record.pcks)
{
communicator.SendPacket(pck);
}
}
Thread.Sleep(200);
}while (!stopPoisoning);
});
}
public void SetSamplingMethodOneEveryNTest()
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
communicator.SetSamplingMethod(new SamplingMethodOneEveryCount(5));
for (int i = 0; i != 20; ++i)
{
Packet expectedPacket = _random.NextEthernetPacket(60 * (i + 1), SourceMac, DestinationMac);
communicator.SendPacket(expectedPacket);
}
Packet packet;
PacketCommunicatorReceiveResult result;
for (int i = 0; i != 4; ++i)
{
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(60 * 5 * (i + 1), packet.Length);
}
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Timeout, result);
Assert.IsNull(packet);
}
}
private void sendNewThread()
{
int srcPort = Int32.Parse(txtSrcPort.Text);
int dstPort = Int32.Parse(txtDestPort.Text);
bool repeatFlag = Int32.TryParse(txtNumPackets.Text, out int repeat);
PacketBuilder builder = buildLayers(srcPort, dstPort);
PacketCommunicator communicator = selectedDevice.Open(100, PacketDeviceOpenAttributes.Promiscuous, 1000);
this.Invoke((MethodInvoker)(() =>
{
btnOk.Enabled = false;
btnReset.Enabled = false;
Cursor = Cursors.WaitCursor;
}));
for (int i = 0; i < repeat; i++)
{
communicator.SendPacket(builder.Build(DateTime.Now));
count++;
}
this.Invoke((MethodInvoker)(() =>
{
Cursor = Cursors.Default;
btnOk.Enabled = true;
btnReset.Enabled = true;
lblResult.Text = "SUCCESS!: " + count;
}));
count = 0;
}
public void ReceiveSomePacketsGcCollectTest()
{
const string SourceMac = "11:22:33:44:55:66";
const string DestinationMac = "77:88:99:AA:BB:CC";
const int NumPackets = 2;
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SetFilter("ether src " + SourceMac + " and ether dst " + DestinationMac);
Packet sentPacket = _random.NextEthernetPacket(100, SourceMac, DestinationMac);
for (int i = 0; i != NumPackets; ++i)
{
communicator.SendPacket(sentPacket);
}
int numGot;
PacketCommunicatorReceiveResult result = communicator.ReceiveSomePackets(out numGot, NumPackets,
delegate
{
GC.Collect();
});
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(NumPackets, numGot);
}
}
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;
}
/// <summary>
/// Sends packet by calling core functions
/// </summary>
/// <param name="packet">Packet to send</param>
/// <param name="countToSend">Count to send</param>
/// <param name="timeToWaitBeforeNextPacketToSend">Time to wait until sending next packet in milliseconds</param>
public void SendPacket(INewPacket packet, int countToSend = 1, int timeToWaitBeforeNextPacketToSend = 0)
{
if (packet is null)
{
throw new ArgumentNullException(nameof(packet));
}
if (_allDevices == null ||
_allDevices.Count == 0)
{
throw new InvalidOperationException("No devices found on local machine to send packets with");
}
int userChosenDevice = LetUserChooseInterfaceBeforeWorkingWithPackets();
PacketDevice selectedDevice = _allDevices[userChosenDevice - 1];
using (PacketCommunicator communicator = selectedDevice.Open(65535,
PacketDeviceOpenAttributes.NoCaptureLocal,
1000))
{
for (uint i = 0; i < countToSend; i++)
{
communicator.SendPacket(packet.BuildPacket(true, i));
_userExperience.UserTextDisplayer.PrintText($"Sended packet nr {i + 1}...");
PauseBeforeSendingPacket(timeToWaitBeforeNextPacketToSend);
}
}
}
public void SendNullPacketTest()
{
using (PacketCommunicator communicator = OpenLiveDevice())
{
communicator.SendPacket(null);
}
Assert.Fail();
}
public void SendPacket(Packet packet)
{
if (ThreadActive.IsSet)
{
try { communicator.SendPacket(packet); }
catch (Exception) { }
}
}
private void button_SendOnce_Click(object sender, EventArgs e)
{
this.textBox_Time.Text = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff");
gooseParameters["textBox_Time"] = this.textBox_Time.Text;
using (PacketCommunicator communicator = _netDevice.Open(65536, PacketDeviceOpenAttributes.Promiscuous, 1000))
communicator.SendPacket(BuildGoosePacket());
}
private void buttonAgKesfi_Click(object sender, EventArgs e) // Ağda bulunan ciahzların mac adresleri bu fonksiyon yardımıyla arp paketleri gönderilerek elde edilir.
{
byte altdeger = Convert.ToByte(textBox2.Text); //Ağ keşfi için kullanılacak sınır ipler belirlendi.
byte ustdeger = Convert.ToByte(textBox3.Text); //Ağ keşfi için kullanılacak sınır ipler belirlendi.
IList <LivePacketDevice> allDevices = LivePacketDevice.AllLocalMachine;
PacketDevice selectedDevice = allDevices[2]; //Cihaz seçimi. Manuel olarak atanmıştır.
using (PacketCommunicator communicator = selectedDevice.Open(100,
PacketDeviceOpenAttributes.Promiscuous,
1000))
{
//****************************** Ağ keşfi ******************************
for (byte i = altdeger; i < ustdeger; i++) // Ağdaki istenilen ip aralığına arp paketleri gönderiir. Örn: "192.168.1.i"
{
EthernetLayer ethernetLayer =
new EthernetLayer //Ethernet Katmanı
{
Source = new MacAddress(MacAdresim()), //Kaynak mac adresi. Fonksiyondan çekildi.
Destination = new MacAddress("ff:ff:ff:ff:ff:ff"), //Hedef mac adresi. Broadcast yayın yapıldı.
EtherType = EthernetType.None,
};
ArpLayer arpLayer =
new ArpLayer //Arp Katmanı
{
ProtocolType = EthernetType.IpV4,
Operation = ArpOperation.Request,
SenderHardwareAddress = new byte[] { 0x28, 0xd2, 0x44, 0x49, 0x7e, 0x2b }.AsReadOnly(), // Kaynak ac adresi.
SenderProtocolAddress = new byte[] { Convert.ToByte(IpParcala(0)), Convert.ToByte(IpParcala(1)), Convert.ToByte(IpParcala(2)), Convert.ToByte(IpParcala(3)) }.AsReadOnly(), // Kaynak Ip adresi IpParcala fonksiyonundan bloklar halinde çekildi.
TargetHardwareAddress = new byte[] { 0, 0, 0, 0, 0, 0 }.AsReadOnly(), // Hedef Mac Adresi. Öğrenilmek istenen parametre. Request paketlerinde 00:00:00:00:00:00
TargetProtocolAddress = new byte[] { Convert.ToByte(IpParcala(0)), Convert.ToByte(IpParcala(1)), Convert.ToByte(IpParcala(2)), i }.AsReadOnly(), // Hedef Ip adresi IpParcala fonksiyonundan bulunulan ağın ilk 3 bloğu alındı. Son blok i değeri ile döngüye sokuldu.
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, arpLayer);
Packet arppacket = builder.Build(DateTime.Now); // Katmanlar paketlendi.
communicator.SendPacket(arppacket); // Arp paketi yayınlandı.
//****************************** ARP Paket dinleme ******************************
using (BerkeleyPacketFilter filter = communicator.CreateFilter("arp")) // Filtre uygulandı.
{
communicator.SetFilter(filter);
}
Packet packet;
PacketCommunicatorReceiveResult result = communicator.ReceivePacket(out packet);
switch (result)
{
case PacketCommunicatorReceiveResult.Ok:
if (!listBox1.Items.Contains(packet.Ethernet.Source + "\t\t\t@" + packet.Ethernet.Arp.SenderProtocolIpV4Address.ToString())) // Listbox'da oluşabilecek veri tekrarı önlendi.
{
listBox1.Items.Add(packet.Ethernet.Source + "\t\t\t@" + packet.Ethernet.Arp.SenderProtocolIpV4Address.ToString()); // Gelen Arp Paketlerinin Ethernet Katmanındna Source MAC Addres verisi çekildi.
}
break;
}
}
}
}
private void buttonMacTaklit_Click(object sender, EventArgs e) // Yayınlanan UDP paketlerinin ethernet katmanında Kaynak Mac adresi olarak taklit edilmek istenen Mac adresi yayınlanır. Bu sayede Switch'in Mac Adres Tablosu şaşırtılmış olur.
{
String taklitmac = Convert.ToString(listBox1.SelectedItem).Substring(0, 17); // Listbox'da seçilen satırdan Mac Adresi ayıklanarak taklitmac adlı Stringe atandı.
IList <LivePacketDevice> allDevices = LivePacketDevice.AllLocalMachine;
PacketDevice selectedDevice = allDevices[2]; //Cihaz seçimi. Manuel olarak atanmıştır.
using (PacketCommunicator communicator = selectedDevice.Open(100,
PacketDeviceOpenAttributes.Promiscuous,
1000))
{
//****************************** UDP Paket Gönderme ******************************
for (int j = 0; j < 10000; j++)
{
EthernetLayer ethernetLayer =
new EthernetLayer // Ethernet Katmanı
{
Source = new MacAddress(taklitmac), // Kaynak Mac adresi. Taklit edilmek istenen Mac adresi.
Destination = new MacAddress("ff:ff:ff:ff:ff:ff"), // Hedef Mac adresi. Broadcast yayın yapıldı.
EtherType = EthernetType.None,
};
IpV4Layer ipV4Layer =
new IpV4Layer // Ip Katmanı
{
Source = new IpV4Address(IpAdresim()), // Kaynak Ip adresi
CurrentDestination = new IpV4Address(IpParcala(0) + "." + IpParcala(1) + "." + IpParcala(2) + "." + "1"), //Hedef Ip adresi
Fragmentation = IpV4Fragmentation.None,
HeaderChecksum = null,
Identification = 123,
Options = IpV4Options.None,
Protocol = null,
Ttl = 100,
TypeOfService = 0,
};
UdpLayer udpLayer =
new UdpLayer // Udp Katmanı
{
SourcePort = 4050,
DestinationPort = 25,
Checksum = null,
CalculateChecksumValue = true,
};
PayloadLayer payloadLayer =
new PayloadLayer // Payload Katmanı
{
Data = new Datagram(Encoding.ASCII.GetBytes("Merhaba Dunya")),
};
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, udpLayer, payloadLayer);
Packet arppacket = builder.Build(DateTime.Now);
communicator.SendPacket(arppacket);
System.Threading.Thread.Sleep(1000); // 1'er saniye aralıklarla paketin gönderilmesi sağlanarak mac adres tablosu güncel tutulur.
}
}
}
private static void DiscoverNetworkBroadcast(PacketCommunicator communicator, MyDevice device)
{
// Supposing to be on ethernet, set mac source
MacAddress source = new MacAddress(device.MacAddressWithDots());
// set mac destination to broadcast
MacAddress destination = new MacAddress("FF:FF:FF:FF:FF:FF");
// Create the packets layers
// Ethernet Layer
EthernetLayer ethernetLayer = new EthernetLayer
{
Source = source,
Destination = destination
};
// IPv4 Layer
IpV4Layer ipV4Layer = new IpV4Layer
{
Source = new IpV4Address(device.IPAddress),
Ttl = 128,
// The rest of the important parameters will be set for each packet
};
// ICMP Layer
IcmpEchoLayer icmpLayer = new IcmpEchoLayer();
// Create the builder that will build our packets
PacketBuilder builder = new PacketBuilder(ethernetLayer, ipV4Layer, icmpLayer);
string ipBeg = device.IpWithoutEnd();
//Send 100 Pings to different destination with different parameters
for (int i = 0; i < 256; i++)
{
// Set IPv4 parameters
ipV4Layer.CurrentDestination = new IpV4Address(ipBeg + i);
ipV4Layer.Identification = (ushort)i;
// Set ICMP parameters
icmpLayer.SequenceNumber = (ushort)i;
icmpLayer.Identifier = (ushort)i;
// Build the packet
Packet packet = builder.Build(DateTime.Now);
// Send down the packet
communicator.SendPacket(packet);
//Console.WriteLine("172.16.1." + i);
}
}
//Send button is pressed
private void btnSendPacket_Click(object sender, RoutedEventArgs e)
{
//Loop that defines how many times the packet should be resent
for (int i = 1; i <= Convert.ToInt16(xTimes.Text.ToString()); i++)
{
// Open the output device
using (pCommunicator = pSelectedDevice.Open(100, PacketDeviceOpenAttributes.Promiscuous, 1000))
{
//Get the protocoltype and go through the switchcase in order to build the right packet
int stringProtocol = ProtType.SelectedIndex;
switch (stringProtocol)
{
//If its an ICMP packet do this
case 1:
if (MACsrc.Text != "" && MACdst.Text != "" && IPsrc.Text != "" && IPdst.Text != ""
&& IpId.Text != "" && TTL.Text != "" && Identifier.Text != "" && SQN.Text != "")
{
pBuildIcmpPacket = new ICMPSendPacket(MACsrc.Text, MACdst.Text, IPsrc.Text,
IPdst.Text, IpId.Text, TTL.Text, Identifier.Text, SQN.Text);
pCommunicator.SendPacket(pBuildIcmpPacket.GetBuilder());
}
else
{
MessageBox.Show("Please fill in all required (open) fields");
}
break;
//If its a UDP packet do this
case 2:
if (MACsrc.Text != "" && MACdst.Text != "" && IPsrc.Text != "" && IPdst.Text != ""
&& IpId.Text != "" && TTL.Text != "" && PORTsrc.Text != "" && Data.Text != "")
{
pBuildUdpPacket = new UDPSendPacket(MACsrc.Text, MACdst.Text, IPsrc.Text,
IPdst.Text, IpId.Text, TTL.Text, PORTsrc.Text, Data.Text);
pCommunicator.SendPacket(pBuildUdpPacket.GetBuilder());
}
else
{
MessageBox.Show("Please fill in all required (open) fields");
}
break;
//If its a TCP packet do this
case 3:
if (MACsrc.Text != "" && MACdst.Text != "" && IPsrc.Text != "" && IPdst.Text != ""
&& IpId.Text != "" && TTL.Text != "" && PORTsrc.Text != "" && SQN.Text != ""
&& ACK.Text != "" && WIN.Text != "" && Data.Text != "")
{
pBuildTcpPacket = new TCPSendPacket(MACsrc.Text, MACdst.Text, IPsrc.Text, IPdst.Text,
IpId.Text, TTL.Text, PORTsrc.Text, SQN.Text, ACK.Text, WIN.Text, Data.Text);
pCommunicator.SendPacket(pBuildTcpPacket.GetBuilder());
}
else
{
MessageBox.Show("Please fill in all required (open) fields");
}
break;
//If its a DNS packet do this
case 4:
if (MACsrc.Text != "" && MACdst.Text != "" && IPsrc.Text != "" && IPdst.Text != ""
&& IpId.Text != "" && TTL.Text != "" && PORTsrc.Text != "" && Identifier.Text != ""
&& Domain.Text != "")
{
pBuildDnsPacket = new DNSSendPacket(MACsrc.Text, MACdst.Text, IPsrc.Text, IPdst.Text,
IpId.Text, TTL.Text, PORTsrc.Text, Identifier.Text, Domain.Text);
pCommunicator.SendPacket(pBuildDnsPacket.GetBuilder());
}
else
{
MessageBox.Show("Please fill in all required (open) fields");
}
break;
//If its an HTTP packet do this
case 5:
if (MACsrc.Text != "" && MACdst.Text != "" && IPsrc.Text != "" && IPdst.Text != ""
&& IpId.Text != "" && TTL.Text != "" && PORTsrc.Text != "" && SQN.Text != ""
&& ACK.Text != "" && WIN.Text != "" && Data.Text != "" && Domain.Text != "")
{
pBuildHttpPacket = new HTTPSendPacket(MACsrc.Text, MACdst.Text, IPsrc.Text, IPdst.Text,
IpId.Text, TTL.Text, PORTsrc.Text, SQN.Text, ACK.Text, WIN.Text, Data.Text, Domain.Text);
pCommunicator.SendPacket(pBuildHttpPacket.GetBuilder());
}
else
{
MessageBox.Show("Please fill in all required (open) fields");
}
break;
//If no protocol was selected, let the user know
default:
MessageBox.Show("Select a protocol");
break;
}
}
}
}
private static void TestFilter(PacketCommunicator communicator, BerkeleyPacketFilter filter, Packet expectedPacket, Packet unexpectedPacket)
{
communicator.SetFilter(filter);
for (int i = 0; i != 5; ++i)
{
communicator.SendPacket(expectedPacket);
communicator.SendPacket(unexpectedPacket);
}
Packet packet;
PacketCommunicatorReceiveResult result;
for (int i = 0; i != 5; ++i)
{
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Ok, result);
Assert.AreEqual(expectedPacket, packet);
}
result = communicator.ReceivePacket(out packet);
Assert.AreEqual(PacketCommunicatorReceiveResult.Timeout, result);
Assert.IsNull(packet);
}
