internal static void StartBranchScan()
{
try
{
ScanDone = 0;
TotalScans = ProxyLogIDs.Count;
NewRequestSignatures.Clear();
ScanItemUniquenessChecker UniqueChecker = new ScanItemUniquenessChecker(true);
foreach (int i in ScanBranch.ProxyLogIDs)
{
ScanItem(UniqueChecker, "Proxy", i);
}
foreach (int i in ScanBranch.ProbeLogIDs)
{
ScanItem(UniqueChecker, "Probe", i);
}
foreach (string Signature in NewRequestSignatures)
{
if (!RequestSignatures.Contains(Signature))
{
RequestSignatures.Add(Signature);
}
}
NewRequestSignatures.Clear();
IronUI.UpdateScanBranchStats(0, 0, "All Scan Jobs Created && Queued. Close this Window.", false, true);
}
catch (ThreadAbortException)
{
//
}
catch (Exception Exp)
{
IronException.Report("Scan Branch Exception", Exp.Message, Exp.StackTrace);
}
}
internal static void MoveScanTraceRecordBack(int JumpLevel)
{
IronUI.ShowScanTraceStatus("Loading please wait....", false);
Thread T = new Thread(MoveScanTraceRecordBack);
T.Start(JumpLevel);
}
internal static void DoStop()
{
try
{
Stopped = true;
if (ScanManagerThread != null)
{
if (ScanManagerThread.ThreadState == ThreadState.Running && !CanStop)
{
//ask if user is sure about stopping scan and then call...
EndAll();
}
else
{
EndAll();
}
}
else
{
IronUI.UpdateConsoleControlsStatus(false);
}
}
catch (Exception Exp)
{
IronException.Report("Error stopping the Scan", Exp);
}
}
static void MarkForJavaScriptTesting(object Details)
{
try
{
object[] DetailsArray = (object[])Details;
RequestSource Source = (RequestSource)DetailsArray[0];
int ID = (int)DetailsArray[1];
Session IrSe = GetLog(Source, ID);
if (IrSe == null)
{
IronUI.ShowLogStatus("Unable to read Response from log", true);
return;
}
if (IrSe.Response == null)
{
IronUI.ShowLogStatus("Unable to read Response from log", true);
return;
}
IronUI.FillAndShowJavaScriptTester(IrSe.Response.BodyString);
}
catch (Exception Exp)
{
IronUI.ShowLogStatus("Unable to read Response from Log", true);
IronException.Report("Error reading from log", Exp.Message, Exp.StackTrace);
}
}
internal static void LoadNewPassivePlugins()
{
ScriptEngine Engine = GetScriptEngine();
LoadNewPassivePlugins(Engine);
IronUI.BuildPluginTree();
}
static void CopyResponse(object Details)
{
try
{
object[] DetailsArray = (object[])Details;
RequestSource Source = (RequestSource)DetailsArray[0];
int ID = (int)DetailsArray[1];
Session IrSe = GetLog(Source, ID);
if (IrSe == null)
{
IronUI.ShowLogStatus("Unable to read Response from log", true);
return;
}
if (IrSe.Response == null)
{
IronUI.ShowLogStatus("Unable to read Response from log", true);
return;
}
IronUI.SetClipBoard(IrSe.Response.ToString());
}
catch (Exception Exp)
{
IronUI.ShowLogStatus("Unable to read Request from Log", true);
IronException.Report("Error reading from log", Exp.Message, Exp.StackTrace);
}
}
internal static void SendRequest()
{
if (ManualTesting.CurrentRequest == null)
{
return;
}
if (!IronProxy.ProxyRunning)
{
throw new Exception("IronWASP Proxy is currently not running. IronWASP cannot send Requests unless the Proxy is started. Please go to the Proxy section of IronWASP and click on the 'Start Proxy' button to fix this problem.");
}
IronUI.ResetMTResponseDisplayFields();
Request Request = ManualTesting.CurrentRequest.GetClone();
StringDictionary Flags = new StringDictionary();
Flags.Add("IronFlag-BuiltBy", "ManualTestingSection");
Request.ID = Interlocked.Increment(ref Config.TestRequestsCount);
StoreInGroupList(Request);
SetCurrentID(Request.ID);
IronDB.LogMTRequest(Request);
IronUI.UpdateMTLogGridWithRequest(Request);
Flags.Add("IronFlag-ID", Request.ID.ToString());
Fiddler.FiddlerApplication.oProxy.InjectCustomRequest(Request.GetFiddlerHTTPRequestHeaders(), Request.BodyArray, Flags);
}
static void MarkForScanning(object Details)
{
try
{
object[] DetailsArray = (object[])Details;
RequestSource Source = (RequestSource)DetailsArray[0];
int ID = (int)DetailsArray[1];
Session IrSe = GetLog(Source, ID);
if (IrSe == null)
{
IronUI.ShowLogStatus("Unable to read Request from log", true);
return;
}
if (IrSe.Request == null)
{
IronUI.ShowLogStatus("Unable to read Request from log", true);
return;
}
int ScanID = Interlocked.Increment(ref Config.ScanCount);
IronDB.CreateScan(ScanID, IrSe.Request);
IronUI.CreateScan(ScanID, "Not Started", IrSe.Request.Method, IrSe.Request.FullUrl);
IronUI.ShowScanJobsQueue();
}
catch (Exception Exp)
{
IronUI.ShowLogStatus("Unable to read Request from Log", true);
IronException.Report("Error reading from log", Exp.Message, Exp.StackTrace);
}
}
static void Executor()
{
while (On)
{
try
{
On = false;
if (QueuedCommands.Length > 0)
{
InteractiveShellResult Result = IronScripting.ExecuteMultiLineShellInput(QueuedCommands);
IronUI.UpdateInteractiveShellResult(Result);
}
else
{
InteractiveShellResult Result = IronScripting.ExecuteInteractiveShellInput(QueuedCommand);
IronUI.UpdateInteractiveShellResult(Result);
}
}
catch (ThreadAbortException)
{
}
catch (Exception exp)
{
IronException.Report("Error executing Scripting Shell commands", exp.Message, exp.StackTrace);
}
MSR.Reset();
MSR.WaitOne();
}
}
internal static void SerializeRequestBody(object BFPObject)
{
string PluginName = "";
try
{
BodyFormatParamters BFP = (BodyFormatParamters)BFPObject;
Request Request = BFP.Request;
FormatPlugin Plugin = BFP.Plugin;
PluginName = Plugin.Name;
string XML = BFP.XML;
Request NewRequest = Plugin.ToRequestFromXml(Request, XML);
IronUI.FillMTRequestWithNewRequestFromFormatXML(NewRequest, PluginName);
}
catch (ThreadAbortException)
{
//
}
catch (Exception Exp)
{
IronException.Report("Error Serializing 'Manual Testing' Request using Format Plugin - " + PluginName, Exp.Message, Exp.StackTrace);
IronUI.ShowMTException("Error Serializing");
}
}
internal static void ImportBurpLog(string BurpLogFile)
{
IronUI.OpenImportForm();
IronUI.SetUIVisibility(false);
BurpImportThread = new Thread(StartImportBurpLog);
BurpImportThread.Start(BurpLogFile);
}
internal static void LoadAllActivePlugins()
{
ScriptEngine Engine = GetScriptEngine();
LoadAllActivePlugins(Engine);
IronUI.UpdateAllActivePluginRows();
IronUI.BuildPluginTree();
}
internal static void LoadNewFormatPlugins()
{
ScriptEngine Engine = GetScriptEngine();
LoadNewFormatPlugins(Engine);
IronUI.UpdateAllFormatPluginRows();
IronUI.BuildPluginTree();
}
internal static void LoadNewSessionPlugins()
{
ScriptEngine Engine = GetScriptEngine();
LoadNewSessionPlugins(Engine);
//IronUI.UpdateSessionPluginsInASTab();
IronUI.BuildPluginTree();
}
public static void StoreRequest(Request RequestToStore)
{
StoredRequestStack.Push(RequestToStore);
if (StoredRequestStack.Count == 1)
{
IronUI.EnableStoredRequestBtn();
}
}
internal static void StoreInGroupList(Response Res)
{
Session IrSe = null;
if (RedGroupSessions.ContainsKey(Res.ID))
{
lock (RedGroupSessions)
{
RedGroupSessions[Res.ID].Response = Res;
IrSe = RedGroupSessions[Res.ID];
}
}
else if (BlueGroupSessions.ContainsKey(Res.ID))
{
lock (BlueGroupSessions)
{
BlueGroupSessions[Res.ID].Response = Res;
IrSe = BlueGroupSessions[Res.ID];
}
}
else if (GreenGroupSessions.ContainsKey(Res.ID))
{
lock (GreenGroupSessions)
{
GreenGroupSessions[Res.ID].Response = Res;
IrSe = GreenGroupSessions[Res.ID];
}
}
else if (GrayGroupSessions.ContainsKey(Res.ID))
{
lock (GrayGroupSessions)
{
GrayGroupSessions[Res.ID].Response = Res;
IrSe = GrayGroupSessions[Res.ID];
}
}
else if (BrownGroupSessions.ContainsKey(Res.ID))
{
lock (BrownGroupSessions)
{
BrownGroupSessions[Res.ID].Response = Res;
IrSe = BrownGroupSessions[Res.ID];
}
}
if (IrSe != null)
{
if (IrSe.Flags.ContainsKey("Reflecton"))
{
IrSe.Flags["Reflecton"] = Analyzer.CheckReflections(IrSe);
}
else
{
IrSe.Flags.Add("Reflecton", Analyzer.CheckReflections(IrSe));
}
IronUI.UpdateTestGroupLogGridWithResponse(IrSe);
}
}
internal void Ask()
{
lock (AskUserQueue)
{
AskUserQueue.Enqueue(this);
}
IronUI.AskUser();
MSR.WaitOne();
}
void SyntaxChecker()
{
try
{
while (Open)
{
string EditorText = "";
lock (EditorTextStack)
{
if (EditorTextStack.Count > 0)
{
EditorText = EditorTextStack.Pop();
EditorTextStack.Clear();
}
}
string ErrorMessage = "";
try
{
string IndentError = "";
if (CurrentLanguage.Equals("py"))
{
IndentError = CheckPythonIndentation(EditorText)[0];
}
ScriptSource Source = Engine.CreateScriptSourceFromString(EditorText);
ScriptErrorReporter CompileErrors = new ScriptErrorReporter();
Source.Compile(CompileErrors);
ErrorMessage = CompileErrors.GetErrors();
if (IndentError.Length > 0)
{
ErrorMessage = string.Format("{0}\r\n{1}", IndentError, ErrorMessage);
ShowHideIndentationFixMenu(true);
}
else
{
ShowHideIndentationFixMenu(false);
}
if (ErrorMessage.Length == 0)
{
ErrorMessage = "0";
}
}
catch (Exception Exp)
{
ErrorMessage = Exp.Message;
}
IronUI.ShowPluginCompilerError(ErrorMessage);
MRE.Reset();
MRE.WaitOne();
}
}
catch (ThreadAbortException) { }
catch (Exception Exp)
{
IronException.Report("Error performing Syntax checking", Exp);
}
}
internal static void FollowRedirect()
{
Request RedirectRequest = GetRedirect();
if (RedirectRequest != null)
{
ManualTesting.SendRequest();
IronUI.StartMTSend(ManualTesting.CurrentRequestID);
}
}
static void PrepareToShowLog()
{
IronUI.ResetLogDisplayFields();
IronUI.ShowLogStatus("Loading...", false);
try
{
CurrentThread.Abort();
}
catch { }
}
internal static void HandleResponse(Session IrSe)
{
IrSe.FiddlerSession.state = Fiddler.SessionStates.Done;
IronDB.LogMTResponse(IrSe.Response);
IronUI.UpdateMTLogGridWithResponse(IrSe.Response);
StoreInGroupList(IrSe.Response);
}
static void LoadPlugin(string PluginFile, ScriptEngine Engine)
{
try
{
ScriptSource PluginSource;
CompiledCode CompiledPlugin;
ScriptErrorReporter CompileErrors = new ScriptErrorReporter();
string ErrorMessage = "";
fileName = PluginFile.Substring(PluginFile.LastIndexOf('\\') + 1);
if (StartUp)
{
IronUI.ShowLoadMessage("Loading Plugin - " + fileName);
}
if (PluginFile.EndsWith(".py", StringComparison.CurrentCultureIgnoreCase))
{
Engine.Runtime.TryGetEngine("py", out Engine);
PluginSource = Engine.CreateScriptSourceFromFile(PluginFile);
string IndentError = PluginEditor.CheckPythonIndentation(PluginSource.GetCode())[1];
CompiledPlugin = PluginSource.Compile(CompileErrors);
ErrorMessage = CompileErrors.GetErrors();
if (IndentError.Length > 0)
{
ErrorMessage = string.Format("{0}\r\n{1}", IndentError, ErrorMessage);
}
if (ErrorMessage.Length == 0)
{
PluginSource.ExecuteProgram();
}
}
else if (PluginFile.EndsWith(".rb", StringComparison.CurrentCultureIgnoreCase))
{
Engine.Runtime.TryGetEngine("rb", out Engine);
PluginSource = Engine.CreateScriptSourceFromFile(PluginFile);
CompiledPlugin = PluginSource.Compile(CompileErrors);
ErrorMessage = CompileErrors.GetErrors();
if (ErrorMessage.Length == 0)
{
PluginSource.ExecuteProgram();
}
}
if (ErrorMessage.Length > 0)
{
IronException.Report("Syntax error in Plugin - " + PluginFile, ErrorMessage);
}
}
catch (Exception Exp)
{
IronException.Report("Error loading plugin - " + PluginFile, Exp.Message, Exp.StackTrace);
}
finally
{
fileName = "";
}
}
internal static void LoadAllNewPlugins()
{
LoadNewPassivePlugins();
LoadNewActivePlugins();
LoadNewFormatPlugins();
LoadNewSessionPlugins();
IronUI.UpdateAllFormatPluginRows();
IronUI.UpdateAllActivePluginRows();
//IronUI.UpdateSessionPluginsInASTab();
IronUI.BuildPluginTree();
}
internal static void ShowGroup(string Group)
{
//TestIDLbl.BackColor = Color.Red;
//TestIDLbl.Text = "ID: 0";
//ManualTesting.CurrentGroup = "Red";
ManualTesting.CurrentGroup = Group;
IronUI.ResetMTDisplayFields();
IronUI.UpdateTestGroupLogGrid(ManualTesting.GroupSessions[Group]);
ManualTesting.ShowSession(ManualTesting.CurrentGroupLogId[Group]);
//if (ManualTesting.RedGroupID == 0) MTReqResTabs.SelectTab("MTRequestTab");
}
internal static void MoveScanTraceRecordBack(object JumpLevelObj)
{
int JumpLevel = (int)JumpLevelObj;
List <IronTrace> Records = GetPreviousScanTraceRecords(JumpLevel);
if (Records.Count == 0)
{
return;
}
IronUI.SetScanTraceGrid(Records);
}
internal static void ImportLogsFromIronwaspProjectFile(string ProjectDir)
{
//IronUI.OpenImportForm();
IronUI.SetUIVisibility(false);
try
{
ImportThread.Abort();
}
catch { }
ImportThread = new Thread(StartLogsImportFromIronwaspProjectFile);
ImportThread.Start(ProjectDir);
}
internal static void MoveScanTraceRecordForward(object JumpLevelObj)
{
int JumpLevel = (int)JumpLevelObj;
List <IronTrace> Records = GetNextScanTraceRecords(JumpLevel);
if (Records.Count == 0)
{
IronUI.ShowScanTraceStatus("Reached end of Scan Traces", true);
return;
}
IronUI.SetScanTraceGrid(Records);
}
public override void Write(byte[] buffer, int offset, int count)
{
byte[] Output = new byte[count];
for (int i = 0; i < count; i++)
{
Output[i] = buffer[i + offset];
}
if (buffer.Length > 0)
{
IronUI.UpdateInteractiveShellOut(Encoding.UTF8.GetString(Output));
}
}
static void UpdatePluginResult()
{
PluginResult[] DequedPluginResult;
lock (PluginResultQ)
{
DequedPluginResult = PluginResultQ.ToArray();
PluginResultQ.Clear();
}
if (DequedPluginResult == null)
{
return;
}
List <PluginResult> PRs = new List <PluginResult>();
foreach (PluginResult PR in DequedPluginResult)
{
try
{
foreach (Trigger T in PR.Triggers.GetTriggers())
{
if (T.Request != null)
{
T.Request.StoredHeadersString = T.Request.GetHeadersAsString();
if (T.Request.IsBinary)
{
T.Request.StoredBinaryBodyString = T.Request.BinaryBodyString;
}
}
if (T.Response != null)
{
T.Response.StoredHeadersString = T.Response.GetHeadersAsString();
if (T.Response.IsBinary)
{
T.Response.StoredBinaryBodyString = T.Response.BinaryBodyString;
}
}
}
PR.Id = Interlocked.Increment(ref Config.PluginResultCount);
PRs.Add(PR);
}
catch (InvalidOperationException)
{
break;
}
}
if (PRs.Count > 0)
{
IronDB.LogPluginResults(PRs);
IronUI.UpdatePluginResultTree(PRs);
}
}
internal static void LoadAllPlugins()
{
ScriptEngine Engine = GetScriptEngine();
LoadAllPassivePlugins(Engine);
LoadAllActivePlugins(Engine);
LoadAllFormatPlugins(Engine);
LoadAllSessionPlugins(Engine);
IronUI.UpdateAllFormatPluginRows();
IronUI.UpdateAllActivePluginRows();
//IronUI.UpdateSessionPluginsInASTab();
IronUI.BuildPluginTree();
}
