/// <summary>
/// Gets a directory listing of a directory.
/// </summary>
/// <param name="Path">The path of the directory to get a listing of.</param>
/// <returns>CoreSploitResultList of FileSystemEntryResults.</returns>
public static CoreSploitResultList <FileSystemEntryResult> GetDirectoryListing(string Path)
{
CoreSploitResultList <FileSystemEntryResult> results = new CoreSploitResultList <FileSystemEntryResult>();
foreach (string dir in Directory.GetDirectories(Path))
{
DirectoryInfo dirInfo = new DirectoryInfo(dir);
results.Add(new FileSystemEntryResult
{
Name = dirInfo.FullName,
Length = 0,
CreationTimeUtc = dirInfo.CreationTimeUtc,
LastAccessTimeUtc = dirInfo.LastAccessTimeUtc,
LastWriteTimeUtc = dirInfo.LastWriteTimeUtc
});
}
foreach (string file in Directory.GetFiles(Path))
{
FileInfo fileInfo = new FileInfo(file);
results.Add(new FileSystemEntryResult
{
Name = fileInfo.FullName,
Length = fileInfo.Length,
CreationTimeUtc = fileInfo.CreationTimeUtc,
LastAccessTimeUtc = fileInfo.LastAccessTimeUtc,
LastWriteTimeUtc = fileInfo.LastWriteTimeUtc
});
}
return(results);
}
/// <summary>
/// Pings specified ComputerNames to identify live systems.
/// </summary>
/// <param name="ComputerNames">ComputerNames to ping.</param>
/// <param name="Timeout">Timeout (in milliseconds) before a ComputerName is considered down.</param>
/// <param name="Threads">Number of threads with which to ping simultaneously</param>
/// <returns></returns>
public static CoreSploitResultList <PingResult> Ping(IList <string> ComputerNames, int Timeout = 250,
int Threads = 100)
{
IList <string> pingAddresses = Utilities.ConvertCidrToIPs(ComputerNames).Distinct().ToList();
CoreSploitResultList <PingResult> pingResults = new CoreSploitResultList <PingResult>();
using (CountdownEvent waiter = new CountdownEvent(pingAddresses.Count))
{
object pingResultsLock = new object();
int runningThreads = 0;
foreach (string ComputerName in pingAddresses)
{
Ping ping = new Ping();
PingResult pingResult = new PingResult(ComputerName, true);
ping.PingCompleted += new PingCompletedEventHandler((sender, e) =>
{
if (e.Reply != null && e.Reply.Status == IPStatus.Success)
{
lock (pingResultsLock)
{
pingResults.Add(pingResult);
}
}
((CountdownEvent)e.UserState).Signal();
});
while (runningThreads >= Threads)
{
#warning Causes a core dump on Linux
waiter.Wait();
runningThreads--;
}
try
{
ping.SendAsync(ComputerName, Timeout, waiter);
runningThreads++;
}
catch
{
}
}
waiter.Wait(Timeout * pingAddresses.Count);
}
return(pingResults);
}
/// <summary>
/// Conducts a port scan of specified ComputerNames on specified ports and reports open ports.
/// </summary>
/// <param name="ComputerNames">ComputerNames to port scan.</param>
/// <param name="Ports">Ports to scan.</param>
/// <param name="Ping">Optional switch. If true, pings the ComputerNames to ensure each is up before port scanning.</param>
/// <param name="Timeout">Timeout (in milliseconds) before a port is considered down.</param>
/// <param name="Threads">Number of threads with which to portscan simultaneously</param>
/// <returns>List of PortScanResults</returns>
public static CoreSploitResultList <PortScanResult> PortScan(IList <string> ComputerNames, IList <int> Ports,
bool Ping = true, int Timeout = 250, int Threads = 100)
{
IList <string> scanAddresses = Utilities.ConvertCidrToIPs(ComputerNames).Distinct().ToList();
IList <int> scanPorts = Ports.Where(P => P > 1 && P < 65536).Distinct().ToList();
if (Ping)
{
CoreSploitResultList <PingResult> pingResults = Network.Ping(scanAddresses, Timeout, Threads);
scanAddresses = pingResults.Where(PR => PR.IsUp).Select(PR => PR.ComputerName).ToList();
}
IList <PortScanResult> portScanResults = new List <PortScanResult>();
using (CountdownEvent waiter = new CountdownEvent(scanAddresses.Count * Ports.Count))
{
object portScanResultsLock = new object();
int runningThreads = 0;
foreach (string ComputerName in scanAddresses)
{
foreach (int Port in scanPorts)
{
TcpClient client = null;
if (!Utilities.IsIP(ComputerName))
{
client = new TcpClient();
}
else
{
IPAddress.TryParse(ComputerName, out IPAddress address);
client = new TcpClient(address.AddressFamily);
}
PortScanResult portScanResult = new PortScanResult(ComputerName, Port, true);
while (runningThreads >= Threads)
{
#warning this may not work properly -scottie
waiter.Wait();
runningThreads--;
}
IAsyncResult asyncResult = client.BeginConnect(ComputerName, Port, new AsyncCallback((state) =>
{
try
{
client.EndConnect(state);
client.Close();
}
catch
{
portScanResult.IsOpen = false;
}
if (portScanResult.IsOpen)
{
lock (portScanResultsLock)
{
portScanResults.Add(portScanResult);
}
}
((CountdownEvent)state.AsyncState).Signal();
}), waiter);
runningThreads++;
}
}
waiter.Wait(Timeout * scanAddresses.Count * Ports.Count);
}
CoreSploitResultList <PortScanResult> results = new CoreSploitResultList <PortScanResult>();
results.AddRange(portScanResults);
return(results);
}
/// <summary>
/// Gets a list of running processes on the system.
/// </summary>
/// <returns>List of ProcessResults.</returns>
public static CoreSploitResultList <ProcessResult> GetProcessList()
{
Platform processorArchitecture = Platform.Unknown;
if (System.Environment.Is64BitOperatingSystem)
{
processorArchitecture = Platform.x64;
}
else
{
processorArchitecture = Platform.x86;
}
Process[] processes = Process.GetProcesses().OrderBy(P => P.Id).ToArray();
CoreSploitResultList <ProcessResult> results = new CoreSploitResultList <ProcessResult>();
foreach (Process process in processes)
{
int processId = process.Id;
int parentProcessId = 0;
string processName = process.ProcessName;
string processPath = string.Empty;
int sessionId = process.SessionId;
//string processOwner = GetProcessOwner(process);
Platform processArch = Platform.Unknown;
if (parentProcessId != 0)
{
try
{
processPath = process.MainModule.FileName;
}
catch (System.ComponentModel.Win32Exception) { }
}
/**
* if (processorArchitecture == Platform.x64)
* {
* processArch = IsWow64(process) ? Win32.Kernel32.Platform.x86 : Win32.Kernel32.Platform.x64;
* }
* else if (processorArchitecture == Win32.Kernel32.Platform.x86)
* {
* processArch = Win32.Kernel32.Platform.x86;
* }
* else if (processorArchitecture == Win32.Kernel32.Platform.IA64)
* {
* processArch = "x86";
* }
**/
results.Add(new ProcessResult
{
Pid = processId,
Ppid = parentProcessId,
Name = processName,
Path = processPath,
SessionID = sessionId,
//Owner = processOwner,
//Architecture = processArch
});
}
return(results);
}
