/// <summary>
/// Start capturing packets on the given device.
/// </summary>
/// <param name="device">The device on which to start capturing packets.</param>
private void StartCaptureOnDevice(ICaptureDevice device)
{
// The following code is taken and modified from SharpPcap's Github repository's
// example 'BasicCap'
// https://github.com/chmorgan/sharppcap/blob/master/Examples/Example3.BasicCap/Program.cs
device.OnPacketArrival += HandlePacketArrival;
// Open the device for capturing
if (device is NpcapDevice)
{
var nPcap = device as NpcapDevice;
// nPcap.Open(OpenFlags.DataTransferUdp | OpenFlags.NoCaptureLocal, _readTimeout);
nPcap.Open(OpenFlags.Promiscuous, _readTimeout);
}
else if (device is LibPcapLiveDevice)
{
var livePcapDevice = device as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, _readTimeout, MonitorMode.Active);
}
else
{
throw new InvalidOperationException($"Unknown device type of {device.GetType()}");
}
// Start the capturing proccess
device.StartCapture();
}
/// <summary>
/// Starts the target manager thread.
/// </summary>
public void Start()
{
Messages.Trace("starting communications manager");
// get the packet capture device
CaptureDeviceList devices = CaptureDeviceList.Instance;
capDevice = devices[Program.interfaceToUse];
Messages.Trace("using [" + capDevice.Description + "] for network capture");
capDevice.OnPacketArrival += capDevice_OnPacketArrival;
if (capDevice is WinPcapDevice)
{
WinPcapDevice winPcap = capDevice as WinPcapDevice;
winPcap.Open(OpenFlags.Promiscuous | OpenFlags.NoCaptureLocal | OpenFlags.MaxResponsiveness, readTimeoutMilliseconds);
}
else if (capDevice is LibPcapLiveDevice)
{
LibPcapLiveDevice livePcapDevice = capDevice as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
throw new InvalidOperationException("unknown device type of " + capDevice.GetType().ToString());
}
capDevice.StartCapture();
// start loop
runThread = true;
commMgrThread.Start();
}
public void SetDevice(string name)
{
if (CurrentCaptureDevice == null || CurrentCaptureDevice.Name != name)
{
if (CurrentCaptureDevice != null)
{
CurrentCaptureDevice.OnPacketArrival -= device_OnPacketArrival;
CurrentCaptureDevice.StopCapture();
}
CurrentCaptureDevice = CaptureDeviceList.Instance.First(i => i.Name == name);
CurrentCaptureDevice.OnPacketArrival += device_OnPacketArrival;
int readTimeoutMilliseconds = 1000;
if (CurrentCaptureDevice is NpcapDevice)
{
var nPcap = CurrentCaptureDevice as NpcapDevice;
nPcap.Open(SharpPcap.Npcap.OpenFlags.DataTransferUdp | SharpPcap.Npcap.OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
}
else if (CurrentCaptureDevice is LibPcapLiveDevice)
{
var livePcapDevice = CurrentCaptureDevice as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
throw new InvalidOperationException("unknown device type of " + CurrentCaptureDevice.GetType().ToString());
}
CurrentCaptureDevice.StartCapture();
}
}
public bool OpenDevice(ICaptureDevice device)
{
mainForm.WriteLine(string.Format("Using device {0}", Device.Description), Color.Black);
mainForm.WriteLine("");
int readTimeoutMilliseconds = 1000;
if (device is SharpPcap.AirPcap.AirPcapDevice)
{
// NOTE: AirPcap devices cannot disable local capture
var airPcap = device as SharpPcap.AirPcap.AirPcapDevice;
airPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp, readTimeoutMilliseconds);
}
else if (device is SharpPcap.WinPcap.WinPcapDevice)
{
var winPcap = device as SharpPcap.WinPcap.WinPcapDevice;
winPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp | SharpPcap.WinPcap.OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
}
else if (device is SharpPcap.LibPcap.LibPcapLiveDevice)
{
var livePcapDevice = device as SharpPcap.LibPcap.LibPcapLiveDevice;
livePcapDevice.Open(SharpPcap.DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
mainForm.WriteLine("Unknown device type of " + device.GetType().ToString(), Color.Red);
return(false);
}
// Register our handler function to the 'packet arrival' event
device.OnPacketArrival +=
new SharpPcap.PacketArrivalEventHandler(device_OnPacketArrival);
device.StartCapture();
return(true);
}
public static void SetDeviceAndPort(ICaptureDevice device, ushort port, Action <UdpPacketReceivedArgs> udpPacketReceived)
{
UdpPacketReceived += udpPacketReceived;
_destinationPort = port;
device.OnPacketArrival += OnPacketArrival;
// Open the device for capturing
device.Open();
const int readTimeoutMilliseconds = 1000;
if (device is AirPcapDevice)
{
// NOTE: AirPcap devices cannot disable local capture
Console.WriteLine("device is AirPcapDevice");
var airPcap = (AirPcapDevice)device;
airPcap.Open(OpenFlags.DataTransferUdp, readTimeoutMilliseconds);
}
else if (device is WinPcapDevice)
{
Console.WriteLine("device is WinPcapDevice");
var winPcap = (WinPcapDevice)device;
winPcap.Open(OpenFlags.DataTransferUdp | OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
}
else if (device is LibPcapLiveDevice)
{
Console.WriteLine("device is LibPcapLiveDevice");
var livePcapDevice = (LibPcapLiveDevice)device;
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
throw new InvalidOperationException("unknown device type of " + device.GetType());
}
}
public void StartCapture(ICaptureDevice device)
{
_activeDevice = device;
_activeDevice.OnPacketArrival += OnPacketArrival;
var readTimeoutMilliseconds = 1000;
switch (_activeDevice)
{
case NpcapDevice nPcap:
nPcap.Open(OpenFlags.DataTransferUdp | OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
break;
case LibPcapLiveDevice livePcapDevice:
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
break;
default:
throw new InvalidOperationException("Unknown device type of " + _activeDevice.GetType());
}
_activeDevice.StartCapture();
}
public static void Main(string[] Args)
{
int SpecifiedDevice = 0;
try
{
foreach (string Argument in Args)
{
if (Argument.StartsWith("d"))
{
SpecifiedDevice = Int32.Parse(Argument.Substring(2));
}
if (Argument.StartsWith("s"))
{
StatisticsInterval = Int32.Parse(Argument.Substring(2));
}
if (Argument.StartsWith("o"))
{
FileName = Argument.Substring(2);
}
}
}
catch (Exception)
{
}
// Print a welcome message
Console.WriteLine("Welcome to Passive Network Discovery");
LogFilePrompt:
Console.WriteLine();
Console.Write("Do you want use MySQL? [Y/n] ");
ConsoleKeyInfo LogTypeKey = Console.ReadKey();
Console.WriteLine();
Console.WriteLine();
if (LogTypeKey.KeyChar == 'n' || LogTypeKey.KeyChar == 'N')
{
// Use files
LogType = FILE;
// Print log filename note
Console.WriteLine();
Console.WriteLine("NOTE: This program will log to {0}", FileName);
}
else if (LogTypeKey.KeyChar == 'y' || LogTypeKey.KeyChar == 'Y' || LogTypeKey.Key == ConsoleKey.Enter)
{
// Use database
LogType = DATABASE;
Console.WriteLine("-- Connecting to MySQL server...");
string DatabaseConnectionString = String.Format("server={0};port={1};user={2};password={3};database={4};",
DatabaseHost, DatabasePort, DatabaseUsername, DatabasePassword, DatabaseSchema);
DatabaseConnection = new MySqlConnection(DatabaseConnectionString);
SecondDatabaseConnection = new MySqlConnection(DatabaseConnectionString);
try
{
DatabaseConnection.Open();
SecondDatabaseConnection.Open();
Console.WriteLine("-- Connected to MySQL server successfully!");
}
catch (Exception ex)
{
Console.WriteLine("-- Error while connecting to MySQL server!");
Console.WriteLine(ex.ToString());
Console.Read();
return;
}
}
else
{
// Please try again
Console.WriteLine();
Console.WriteLine("Did not understand that, please try again!");
goto LogFilePrompt;
}
// Retrieve the device list
var Devices = CaptureDeviceList.Instance;
// If no devices were found print an error
if (Devices.Count < 1)
{
Console.WriteLine("No devices were found on this machine");
return;
}
if (SpecifiedDevice == 0)
{
Console.WriteLine();
Console.WriteLine("The following devices are available on this machine:");
Console.WriteLine("----------------------------------------------------");
Console.WriteLine();
int i = 1;
// Print out the devices
foreach (var TempDevice in Devices)
{
// Description
Console.WriteLine("{0}) {1} {2}", i, TempDevice.Name, TempDevice.Description);
i++;
}
Console.WriteLine();
Console.Write("-- Please choose a device to capture: ");
SpecifiedDevice = int.Parse(Console.ReadLine());
}
try
{
Device = Devices[SpecifiedDevice - 1];
}
catch (Exception)
{
Console.WriteLine("This device doesn't exist");
return;
}
// Register our handler function to the 'packet arrival' event
Device.OnPacketArrival +=
new PacketArrivalEventHandler(OnPacketArrival);
// Open the device for capturing
int ReadTimeoutMilliseconds = 1000;
if (Device is AirPcapDevice)
{
// NOTE: AirPcap devices cannot disable local capture
var AirPcap = Device as AirPcapDevice;
AirPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp, ReadTimeoutMilliseconds);
}
else if (Device is WinPcapDevice)
{
var WinPcap = Device as WinPcapDevice;
WinPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp | SharpPcap.WinPcap.OpenFlags.NoCaptureLocal, ReadTimeoutMilliseconds);
}
else if (Device is LibPcapLiveDevice)
{
var LivePcapDevice = Device as LibPcapLiveDevice;
LivePcapDevice.Open(DeviceMode.Promiscuous, ReadTimeoutMilliseconds);
}
else
{
throw new System.InvalidOperationException("unknown device type of " + Device.GetType().ToString());
}
Console.WriteLine();
Console.WriteLine("-- Listening on {0} {1}, hit 'Ctrl + C' to stop...",
Device.Name, Device.Description);
Console.CancelKeyPress += delegate
{
try
{
// Stop the capturing process
Device.StopCapture();
Console.WriteLine();
Console.WriteLine("-- Capture stopped.");
// Close the pcap device
Device.Close();
DatabaseConnection.Close();
}
catch (Exception ex)
{
// We do not care - at all!
}
};
// Start the capturing process
Device.StartCapture();
Timer StatisticsTimer = new Timer();
StatisticsTimer.Elapsed += new ElapsedEventHandler(DisplayStatisticsEvent);
StatisticsTimer.Interval = StatisticsInterval;
StatisticsTimer.Start();
while (true)
{
Console.Read();
}
}
public static void Main(string[] Args)
{
int SpecifiedDevice = 0;
try
{
foreach (string Argument in Args)
{
if (Argument.StartsWith("d"))
{
SpecifiedDevice = Int32.Parse(Argument.Substring(2));
}
if (Argument.StartsWith("s"))
{
StatisticsInterval = Int32.Parse(Argument.Substring(2));
}
if (Argument.StartsWith("o"))
{
FileName = Argument.Substring(2);
}
}
}
catch (Exception)
{
}
// Print a welcome message
Console.WriteLine("Welcome to Passive Network Discovery");
LogFilePrompt:
Console.WriteLine();
Console.Write("Do you want use MySQL? [Y/n] ");
ConsoleKeyInfo LogTypeKey = Console.ReadKey();
Console.WriteLine();
Console.WriteLine();
if (LogTypeKey.KeyChar == 'n' || LogTypeKey.KeyChar == 'N')
{
// Use files
LogType = FILE;
// Print log filename note
Console.WriteLine();
Console.WriteLine("NOTE: This program will log to {0}", FileName);
}
else if (LogTypeKey.KeyChar == 'y' || LogTypeKey.KeyChar == 'Y' || LogTypeKey.Key == ConsoleKey.Enter)
{
// Use database
LogType = DATABASE;
Console.WriteLine("-- Connecting to MySQL server...");
string DatabaseConnectionString = String.Format("server={0};port={1};user={2};password={3};database={4};",
DatabaseHost, DatabasePort, DatabaseUsername, DatabasePassword, DatabaseSchema);
DatabaseConnection = new MySqlConnection(DatabaseConnectionString);
SecondDatabaseConnection = new MySqlConnection(DatabaseConnectionString);
try
{
DatabaseConnection.Open();
SecondDatabaseConnection.Open();
Console.WriteLine("-- Connected to MySQL server successfully!");
}
catch (Exception ex)
{
Console.WriteLine("-- Error while connecting to MySQL server!");
Console.WriteLine(ex.ToString());
Console.Read();
return;
}
}
else
{
// Please try again
Console.WriteLine();
Console.WriteLine("Did not understand that, please try again!");
goto LogFilePrompt;
}
// Retrieve the device list
var Devices = CaptureDeviceList.Instance;
// If no devices were found print an error
if (Devices.Count < 1)
{
Console.WriteLine("No devices were found on this machine");
return;
}
if (SpecifiedDevice == 0)
{
Console.WriteLine();
Console.WriteLine("The following devices are available on this machine:");
Console.WriteLine("----------------------------------------------------");
Console.WriteLine();
int i = 1;
// Print out the devices
foreach (var TempDevice in Devices)
{
// Description
Console.WriteLine("{0}) {1} {2}", i, TempDevice.Name, TempDevice.Description);
i++;
}
Console.WriteLine();
Console.Write("-- Please choose a device to capture: ");
SpecifiedDevice = int.Parse(Console.ReadLine());
}
try
{
Device = Devices[SpecifiedDevice - 1];
}
catch (Exception)
{
Console.WriteLine("This device doesn't exist");
return;
}
// Register our handler function to the 'packet arrival' event
Device.OnPacketArrival +=
new PacketArrivalEventHandler(OnPacketArrival);
// Open the device for capturing
int ReadTimeoutMilliseconds = 1000;
if (Device is AirPcapDevice)
{
// NOTE: AirPcap devices cannot disable local capture
var AirPcap = Device as AirPcapDevice;
AirPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp, ReadTimeoutMilliseconds);
}
else if (Device is WinPcapDevice)
{
var WinPcap = Device as WinPcapDevice;
WinPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp | SharpPcap.WinPcap.OpenFlags.NoCaptureLocal, ReadTimeoutMilliseconds);
}
else if (Device is LibPcapLiveDevice)
{
var LivePcapDevice = Device as LibPcapLiveDevice;
LivePcapDevice.Open(DeviceMode.Promiscuous, ReadTimeoutMilliseconds);
}
else
{
throw new System.InvalidOperationException("unknown device type of " + Device.GetType().ToString());
}
Console.WriteLine();
Console.WriteLine("-- Listening on {0} {1}, hit 'Ctrl + C' to stop...",
Device.Name, Device.Description);
Console.CancelKeyPress += delegate
{
try
{
// Stop the capturing process
Device.StopCapture();
Console.WriteLine();
Console.WriteLine("-- Capture stopped.");
// Close the pcap device
Device.Close();
DatabaseConnection.Close();
}
catch (Exception ex)
{
// We do not care - at all!
}
};
// Start the capturing process
Device.StartCapture();
Timer StatisticsTimer = new Timer();
StatisticsTimer.Elapsed += new ElapsedEventHandler(DisplayStatisticsEvent);
StatisticsTimer.Interval = StatisticsInterval;
StatisticsTimer.Start();
while (true) { Console.Read(); }
}
/// <summary>
/// Start listening to a device
/// </summary>
/// <param name="device"></param>
public void Listen(ICaptureDevice device)
{
try
{
_device = device;
consoleWrite("Listening to " + device.Name);
// Register our handler function to the 'packet arrival' event
device.OnPacketArrival +=
new PacketArrivalEventHandler(device_OnPacketArrival);
// Open the device for capturing
int readTimeoutMilliseconds = 1000;
if (device is AirPcapDevice)
{
// NOTE: AirPcap devices cannot disable local capture
var airPcap = device as AirPcapDevice;
airPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp, readTimeoutMilliseconds);
}
else if (device is WinPcapDevice)
{
var winPcap = device as WinPcapDevice;
winPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp | SharpPcap.WinPcap.OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
}
else if (device is LibPcapLiveDevice)
{
var livePcapDevice = device as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
throw new System.InvalidOperationException("unknown device type of " + device.GetType().ToString());
}
device.Filter = "src port 9000";
// Start the capturing process
device.StartCapture();
}
catch
{
_form1.showPcapError();
}
}
internal void Start()
{
_device.OnPacketArrival += new PacketArrivalEventHandler(device_OnPacketArrival);
// Open the device for capturing
int readTimeoutMilliseconds = 1000;
//if (_device is AirPcapDevice)
//{
// // NOTE: AirPcap devices cannot disable local capture
// var airPcap = _device as AirPcapDevice;
// airPcap.Open(OpenFlags.DataTransferUdp, readTimeoutMilliseconds);
//}
//else
if (_device is WinPcapDevice)
{
var winPcap = _device as WinPcapDevice;
winPcap.Open(OpenFlags.DataTransferUdp | OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
}
else if (_device is LibPcapLiveDevice)
{
var livePcapDevice = _device as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
throw new System.InvalidOperationException("unknown device type of " + _device.GetType().ToString());
}
_tcpConnectionManager.OnConnectionFound += OnConnectionFound;
_device.StartCapture();
}
static void Main(string[] args)
{
// Retrieve the device list
var devices = CaptureDeviceList.Instance;
// If no devices were found print an error
if (devices.Count < 1)
{
Console.WriteLine("No devices were found on this machine");
return;
}
int i = 0;
// Print out the devices
foreach (var dev in devices)
{
/* Description */
Console.WriteLine("{0}) {1}", i, dev.Description);
i++;
}
Console.WriteLine();
Console.Write("-- Please choose a device to capture: ");
i = int.Parse(Console.ReadLine());
device = devices[i];
// Open the device for capturing
int readTimeoutMilliseconds = 1000;
if (device is NpcapDevice)
{
var nPcap = device as NpcapDevice;
nPcap.Open(SharpPcap.Npcap.OpenFlags.DataTransferUdp | SharpPcap.Npcap.OpenFlags.NoCaptureLocal, readTimeoutMilliseconds);
}
else if (device is LibPcapLiveDevice)
{
var livePcapDevice = device as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, readTimeoutMilliseconds);
}
else
{
throw new InvalidOperationException("unknown device type of " + device.GetType().ToString());
}
//--User Input Settings
Console.Write("Target IP-Address: ");
IPAddress targetIpAddress = IPAddress.Parse(Console.ReadLine());
Console.Write("DHCP-Server IP-Adress: ");
IPAddress dhcpServIpAddress = IPAddress.Parse(Console.ReadLine());
Console.Write("Sending delay (in ms): ");
string sendingDelay = Console.ReadLine();
//--GET Hw-Address from Target and DHCP-Server
Console.WriteLine("Getting Hw-Addresses from Hosts...");
PhysicalAddress targetHwAddress = PhysicalAddress.Parse(localInterface.sendArpRequest(targetIpAddress));
PhysicalAddress dhcpServHwAddress = PhysicalAddress.Parse(localInterface.sendArpRequest(dhcpServIpAddress));
//--Print Out Hw-Addresses
Console.WriteLine("Target Hw-Address: " + targetHwAddress);
Console.WriteLine("DHCP-Server Hw-Address: " + dhcpServHwAddress);
Console.WriteLine("Press ENTER to start...");
Console.Read();
while (true)
{
sendDhcpRelease(targetHwAddress, targetIpAddress, dhcpServHwAddress, dhcpServIpAddress);
Thread.Sleep(Convert.ToInt32(sendingDelay));
}
}
private void threadHandler()
{
this.device.OnPacketArrival += new PacketArrivalEventHandler(packetarrive);
if (device is AirPcapDevice)
{
// NOTE: AirPcap devices cannot disable local capture
var airPcap = device as AirPcapDevice;
airPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp, timeout);
}
else if (device is WinPcapDevice)
{
var winPcap = device as WinPcapDevice;
// winPcap.Open(SharpPcap.WinPcap.OpenFlags.DataTransferUdp, timeout);
// winPcap.Open(SharpPcap.WinPcap.OpenFlags.NoCaptureLocal, timeout);
winPcap.Open(DeviceMode.Promiscuous, timeout);
}
else if (device is LibPcapLiveDevice)
{
var livePcapDevice = device as LibPcapLiveDevice;
livePcapDevice.Open(DeviceMode.Promiscuous, timeout);
}
else
{
throw new System.InvalidOperationException("unknown device type of " + device.GetType().ToString());
}
// this.device.Open(DeviceMode.Promiscuous, timeout);
this.device.Filter = this.filter;
this.device.StartCapture();
}
