protected override void OnInput(DataFrame frame)
{
for (int i = 0; i < Config.DuplicationCount; ++i)
{
WriteOutput(frame.CloneFrame());
}
}
protected override void OnInput(DataFrame frame)
{
DataNode[] nodes = frame.SelectNodes(SelectionPath);
if (nodes.Length > 1)
{
for (int i = 0; i < nodes.Length; ++i)
{
DataFrame newFrame = frame.CloneFrame();
DataNode[] newNodes = newFrame.SelectNodes(SelectionPath);
for (int j = 0; j < newNodes.Length; ++j)
{
if (j != i)
{
newNodes[j].RemoveNode();
}
}
newFrame.Current = newNodes[i];
WriteOutput(newFrame);
}
}
else
{
WriteOutput(frame);
}
}
/// <summary>
/// Add a simple packet with a tag and a frame
/// </summary>
/// <param name="tag">The tag to add</param>
/// <param name="frame">The frame to add, this will be cloned before putting in log</param>
/// <returns>The logged packet</returns>
public LogPacket AddPacket(string tag, DataFrame frame)
{
LogPacket ret = new LogPacket(tag, Guid.NewGuid(), "Packet Log", frame.CloneFrame(), ColorValue.White);
AddPacket(ret);
return(ret);
}
private void toolStripButtonUndo_Click(object sender, EventArgs e)
{
_currFrame = _oldFrame.CloneFrame();
UpdateFrame();
UpdateFrameModified();
toolStripButtonUndo.Enabled = false;
toolStripButtonSnapshot.Enabled = false;
}
/// <summary>
/// Set the frame to edit
/// </summary>
/// <param name="frame">The data frame</param>
/// <param name="selector">Root selection path</param>
/// <param name="color">The colour to display the frame in (if applicable)</param>
public void SetFrame(DataFrame frame, string selector, Color color)
{
toolStripButtonSnapshot.Enabled = false;
toolStripButtonUndo.Enabled = false;
_oldFrame = frame;
_currFrame = frame.CloneFrame();
_selector = selector;
_color = color;
UpdateFrame();
}
/// <summary>
/// Internal write function
/// </summary>
/// <param name="frame">The frame to write</param>
/// <param name="nodes">The list of nodes to write to</param>
private void WriteOutput(DataFrame frame, OutputNode[] nodes)
{
try
{
// Leave this like it is for legacy reasons.
if (frame == null)
{
foreach (OutputNode node in nodes)
{
node.Node.Shutdown(this);
}
}
else
{
_outputPacketCount++;
_byteCount += frame.Length;
if (LogOutput)
{
LogPacket(String.Format("{0} Output", Name), new ColorValue(255, 255, 255), frame, false);
}
if (nodes.Length == 1)
{
// If we only have one output then don't need to clone
nodes[0].Node.Input(frame);
}
else
{
foreach (OutputNode node in nodes)
{
DataFrame newFrame = frame.CloneFrame();
node.Node.Input(newFrame);
}
}
}
}
catch (ThreadAbortException)
{
// If we get a thread abort it probably means we want to go away
throw;
}
catch (Exception ex)
{
// Back stop, do nothing but write to log
LogException(ex);
}
}
/// <summary>
/// Log a packet from the graph
/// </summary>
/// <param name="tag">A textual tag for the frame</param>
/// <param name="color">The color to display the frame (if applicable)</param>
/// <param name="frame">The frame to log, note this must be cloned to preserve its value</param>
/// <param name="logAsBytes">Indicates whether the packet should be logged as a byte array</param>
/// <param name="path">Selection path for which part of the packet to log</param>
private void OnLogPacket(string tag, ColorValue color, DataFrame frame, bool logAsBytes, string path)
{
EventHandler <LogPacketEventArgs> logPacketEvent = LogPacketEvent;
if (logPacketEvent != null)
{
DataFrame logFrame = null;
if (path != "/")
{
DataNode node = frame.SelectSingleNode(path);
if (node != null)
{
node = node.CloneNode();
DataKey key = node as DataKey;
if (key != null)
{
logFrame = new DataFrame(key);
}
else
{
logFrame = new DataFrame();
logFrame.Root.AddSubNode(node);
}
if (logAsBytes)
{
logFrame.ConvertToBasic();
}
}
}
else
{
logFrame = logAsBytes ? new DataFrame(frame.ToArray()) : frame.CloneFrame();
}
if (logFrame != null)
{
logPacketEvent(this, new LogPacketEventArgs(tag, Uuid, logFrame, color, NetworkDescription));
}
}
}
protected override void OnInput(DataFrame frame)
{
DataFrame logFrame;
if (Config.ConvertToBytes)
{
logFrame = new DataFrame(frame.ToArray());
}
else
{
logFrame = frame.CloneFrame();
}
LogPacket packet = new LogPacket(Config.Tag, Graph.Uuid, Guid.NewGuid(),
Graph.NetworkDescription, logFrame, Config.Color, DateTime.Now);
Config.PacketLog.AddPacket(packet);
WriteOutput(frame);
}
/// <summary>
/// Log a packet from the graph
/// </summary>
/// <param name="tag">A textual tag for the frame</param>
/// <param name="color">The color to display the frame (if applicable)</param>
/// <param name="frame">The frame to log, note this must be cloned to preserve its value</param>
/// <param name="logAsBytes">Indicates whether the packet should be logged as a byte array</param>
/// <param name="path">Selection path for which part of the packet to log</param>
private void OnLogPacket(string tag, ColorValue color, DataFrame frame, bool logAsBytes, string path)
{
EventHandler<LogPacketEventArgs> logPacketEvent = LogPacketEvent;
if (logPacketEvent != null)
{
DataFrame logFrame = null;
if (path != "/")
{
DataNode node = frame.SelectSingleNode(path);
if (node != null)
{
node = node.CloneNode();
DataKey key = node as DataKey;
if (key != null)
{
logFrame = new DataFrame(key);
}
else
{
logFrame = new DataFrame();
logFrame.Root.AddSubNode(node);
}
if (logAsBytes)
{
logFrame.ConvertToBasic();
}
}
}
else
{
logFrame = logAsBytes ? new DataFrame(frame.ToArray()) : frame.CloneFrame();
}
if (logFrame != null)
{
logPacketEvent(this, new LogPacketEventArgs(tag, Uuid, logFrame, color, NetworkDescription));
}
}
}
protected override void OnInput(DataFrame frame)
{
DataNode[] nodes = frame.SelectNodes(SelectionPath);
DataFrame oldFrame = null;
bool doLog = false;
string counterName = String.Format("{0}_count", Uuid);
if (nodes.Length > 0)
{
if (Config.LogPackets)
{
oldFrame = frame.CloneFrame();
}
}
foreach (DataNode node in nodes)
{
if (Config.NoConversion)
{
DataValue value = node as DataValue;
// If not a byte array then ignore
if ((value == null) || !(value.Value is byte[]))
{
LogVerbose(CANAPE.NodeLibrary.Properties.Resources.ByteFuzzer_IgnoringNode, node.Name);
continue;
}
}
byte[] data = node.ToArray();
int fuzzLength = FuzzerUtils.GetFuzzLength(data.Length, Config.FuzzStart, Config.FuzzLength);
if (fuzzLength > 0)
{
long count = Graph.GlobalMeta.IncrementCounterLong(counterName, Config.MinValue, Config.Increment);
if (Config.Increment < 0)
{
if (count < Config.MaxValue)
{
LogInfo("No more values to fuzz");
}
else
{
doLog = true;
}
}
else if (Config.Increment > 0)
{
if (count > Config.MaxValue)
{
LogInfo("No more values to fuzz");
}
else
{
doLog = true;
}
}
if (doLog)
{
if (Config.LogFuzzText)
{
LogVerbose("Fuzzing with value {0}", count);
}
byte[] countData = BitConverter.GetBytes(count);
Array.Resize(ref countData, fuzzLength);
if (!Config.LittleEndian)
{
countData = countData.Reverse().ToArray();
}
Buffer.BlockCopy(countData, 0, data, Config.FuzzStart, fuzzLength);
node.ReplaceNode(data);
}
}
}
if (doLog)
{
if (Config.LogPackets)
{
Graph.DoLogPacket(String.Format("{0}: Pre-fuzz", Name), Config.Color, oldFrame, Config.ConvertToBytes);
Graph.DoLogPacket(String.Format("{0}: Post-fuzz", Name), Config.Color, frame, Config.ConvertToBytes);
}
}
WriteOutput(frame);
}
/// <summary>
/// Set the frame to edit
/// </summary>
/// <param name="frame">The data frame</param>
/// <param name="selector">Root selection path</param>
/// <param name="color">The colour to display the frame in (if applicable)</param>
public void SetFrame(DataFrame frame, string selector, Color color)
{
toolStripButtonSnapshot.Enabled = false;
toolStripButtonUndo.Enabled = false;
_oldFrame = frame;
_currFrame = frame.CloneFrame();
_selector = selector;
_color = color;
UpdateFrame();
}
/// <summary>
/// Add a simple packet with a tag and a frame
/// </summary>
/// <param name="tag">The tag to add</param>
/// <param name="frame">The frame to add, this will be cloned before putting in log</param>
/// <returns>The logged packet</returns>
public LogPacket AddPacket(string tag, DataFrame frame)
{
LogPacket ret = new LogPacket(tag, Guid.NewGuid(), "Packet Log", frame.CloneFrame(), ColorValue.White);
AddPacket(ret);
return ret;
}
/// <summary>
/// Internal write function
/// </summary>
/// <param name="frame">The frame to write</param>
/// <param name="nodes">The list of nodes to write to</param>
private void WriteOutput(DataFrame frame, OutputNode[] nodes)
{
try
{
// Leave this like it is for legacy reasons.
if (frame == null)
{
foreach (OutputNode node in nodes)
{
node.Node.Shutdown(this);
}
}
else
{
_outputPacketCount++;
_byteCount += frame.Length;
if (LogOutput)
{
LogPacket(String.Format("{0} Output", Name), new ColorValue(255, 255, 255), frame, false);
}
if (nodes.Length == 1)
{
// If we only have one output then don't need to clone
nodes[0].Node.Input(frame);
}
else
{
foreach (OutputNode node in nodes)
{
DataFrame newFrame = frame.CloneFrame();
node.Node.Input(newFrame);
}
}
}
}
catch (ThreadAbortException)
{
// If we get a thread abort it probably means we want to go away
throw;
}
catch (Exception ex)
{
// Back stop, do nothing but write to log
LogException(ex);
}
}
public DataFrame GetFrame()
{
return(_currFrame.CloneFrame());
}