/// <summary>
/// Constructor.
/// </summary>
/// <param name="ScanProvider">Instanciated implementation of an IScanProvider.</param>
/// <param name="dorkToScan">A DorkDone, which represents the Dork to scan.</param>
public Scanner(IScanProvider ScanProvider, DorkDone dorkToScan)
{
scanProvider = ScanProvider;
_ScanStatus = (int)SCANTHREADSTATE.Waiting;
_DorkToScan = dorkToScan;
httpGet = null;
}
/// <summary>
/// Re-scan (so, scan again) the selected Dork.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RescanMenuItem_Click(object sender, EventArgs e)
{
DorkDone ddone = (DorkDone)resultListView.SelectedItems[0].Tag;
SelectedDork.Dork = ddone as Dork;
SelectedDork.TreeNode = ddone.LastNode;
SelectedDork.NextPage = 0;
singleScan();
}
/// <summary>
/// Creates new DorkDone object from a given SSelectedDork object.
/// Presets attributes like status, time, host
/// </summary>
/// <param name="scanDork">A selected Dork (eg from ui)</param>
/// <returns>Corresponding DorkDone object</returns>
private DorkDone CreateDorkForScanning(SSelectedDork scanDork)
{
DorkDone dorkdone = new DorkDone(scanDork);
dorkdone.ScanResult = (int)RESULT_STATUS.WhileScan;
dorkdone.Host = scanHostTextBox.Text.Trim();
dorkdone.Now();
return(dorkdone);
}
/// <summary>
/// Shows the Dork of the selected result back in the TreeView.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void showLeftStrip_Click(object sender, EventArgs e)
{
tvwDorks.Focus();
DorkDone dork = (DorkDone)resultListView.SelectedItems[0].Tag;
TreeNode treenode = dork.LastNode;
treenode.Expand();
treenode.EnsureVisible();
tvwDorks.SelectedNode = treenode;
}
/// <summary>
/// Clear all un-successful Dorks/results out of the ResultView.
/// Leaves just positives.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClearErrorsStrip_Click(object sender, EventArgs e)
{
foreach (ListViewItem listItem in resultListView.Items)
{
DorkDone ddone = (DorkDone)listItem.Tag;
if (ddone.ScanResult != (int)RESULT_STATUS.ScanWithResult)
{
resultListView.Items.Remove(listItem);
}
}
}
/// <summary>
/// Called when double-clicking on an item in the result-list.
/// Opens browser with the Url, or (if unsuccessfull scan) opens
/// dialog with description of error.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void resultList_DoubleClick(object sender, EventArgs e)
{
if (resultListView.SelectedItems.Count == 1)
{
DorkDone ddone = (DorkDone)resultListView.SelectedItems[0].Tag;
if (ddone.ScanResult == (int)RESULT_STATUS.ScanWithResult ||
ddone.ScanResult == (int)RESULT_STATUS.Blocked)
{
openInBrowserToolStripMenuItem_Click(sender, e);
}
else
{
if (ddone.ScanResult == (int)RESULT_STATUS.Failure)
{
ShowErrorStrip_Click(sender, e);
}
}
}
}
/// <summary>
/// Called whenever the selection from the user in the result-list changes.
/// Mostly items from the context-menu are enabled/disabled here.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void resultSelectionChanged(object sender, EventArgs e)
{
bool selectedItems = resultListView.SelectedItems.Count > 0;
bool oneSelectedItem = resultListView.SelectedItems.Count == 1;
cutToolStripButton.Enabled = cutToolStripMenuItem.Enabled = selectedItems;
copyToolStripButton.Enabled = copyToolStripMenuItem.Enabled = selectedItems;
copyToClpMenuItem.Enabled = selectedItems;
openInBrowserToolStripMenuItem.Enabled = oneSelectedItem;
RescanMenuItem.Enabled = oneSelectedItem;
showLeftStrip.Enabled = oneSelectedItem;
scanMoreFromHereStrip.Enabled = oneSelectedItem;
if (oneSelectedItem)
{
DorkDone ddone = resultListView.SelectedItems[0].Tag as DorkDone;
if (ddone != null)
{
bool isSuccessItem = (ddone.ScanResult == (int)RESULT_STATUS.ScanWithResult);
ShowErrorStrip.Enabled = (ddone.ScanResult == (int)RESULT_STATUS.Failure);
scanMoreFromHereStrip.Enabled = (ddone.NextPage != 0) && (isSuccessItem);
openInBrowserToolStripMenuItem.Enabled = isSuccessItem;
// again, here, show it to the user
formatDorkToRichText(ddone as Dork);
}
}
else
{
ShowErrorStrip.Enabled = false;
openInBrowserToolStripMenuItem.Enabled = false;
}
}
/// <summary>
/// If a Dork failed, show its error message in a MessageBox.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ShowErrorStrip_Click(object sender, EventArgs e)
{
DorkDone ddone = (DorkDone)resultListView.SelectedItems[0].Tag;
MessageBox.Show(ddone.ErrorMessage, rm.GetString("RES_E_SCANERROR"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
/// <summary>
/// This is the Background worker which starts and controls the ScanMonitor.
/// Does some UI things, also takes care of the ScanningDialog.
/// This seems a doubling of the ScanMonitor's Watcher, but it is needed to keep the UI running independently.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void doThreadScan(object sender, DoWorkEventArgs e)
{
BackgroundWorker bw = (BackgroundWorker)sender;
int ScanCountSession = 0;
double frac = 100.0 / ((double)dorksToScan.Count);
double realstat = 0;
using (ScanMonitor scanmonitor = new ScanMonitor(Properties.Settings.Default.MaxParallelScans))
{
foreach (SSelectedDork _dork in dorksToScan)
{
ScanCountSession++;
if (scanningdialog != null)
{
scanningdialog.UpdateTitle(ScanCountSession);
Update();
}
DorkDone dorkdone = CreateDorkForScanning(_dork);
ListViewItem lv = ShowTemporaryDork(_dork);
lv.Tag = dorkdone;
dorkdone.ViewItem = lv;
Update();
Scanner scanner = new Scanner(new ScanGoogleProvider(), dorkdone);
while (!scanmonitor.IsThreadAvail())
{
CheckAndDisplayResults(scanmonitor);
Thread.Sleep(300);
}
scanmonitor.Add(scanner);
Thread.Sleep(200);
CheckAndDisplayResults(scanmonitor);
if (scanningdialog != null)
{
realstat += frac / Properties.Settings.Default.RequestPages;
scanningdialog.SetPercentage((int)Math.Round(realstat));
Update();
}
if (bw.CancellationPending)
{
e.Cancel = true;
break;
}
int stealthtime = Properties.Settings.Default.StealthTime / 1000;
if (stealthtime > 0)
{
if (stealthtime > 3)
{
progressBar1.ForeColor = Color.DarkGray;
}
for (int i = 0; i < stealthtime; i++)
{
Thread.Sleep(1000);
if (bw.CancellationPending)
{
e.Cancel = true;
break;
}
}
if (stealthtime > 3)
{
progressBar1.ForeColor = Color.DarkBlue;
}
}
if (scanningdialog != null)
{
realstat = (frac * ScanCountSession);
scanningdialog.SetPercentage((int)Math.Round(realstat));
Update();
}
// be sure to cancel
if (e.Cancel == true)
{
break;
}
} // foreach
if (scanningdialog != null)
{
if (scanmonitor.HasResults() || scanmonitor.HasPendingScans())
{
scanningdialog.UpdateTitleWaiting();
}
}
while (scanmonitor.HasResults() ||
(!e.Cancel && scanmonitor.HasPendingScans())
)
{
CheckAndDisplayResults(scanmonitor);
Thread.Sleep(200);
}
}
}
/// <summary>
/// This is one of the hearts of gS.
/// Like it is named, it checks the results and with them controls
/// the outer interface of the ScanMonitor. It's somehow a respectful
/// connection between the UI and the parallel scanner in the backend.
/// </summary>
/// <param name="scanmonitor">Instance of ScanMonitor while scanning.</param>
private void CheckAndDisplayResults(ScanMonitor scanmonitor)
{
if (scanmonitor.HasResults())
{
Scanner scanner = scanmonitor.GetFinishedScanner();
DorkDone dorkdone = scanner.ResultDork;
if (dorkdone == null)
{
return;
}
if (dorkdone.ScanResult == (int)RESULT_STATUS.Cancel)
{
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceInfo, "Scan was canceled.");
dorkdone.ViewItem.ImageIndex = (int)RESULT_STATUS.Cancel;
dorkdone.ViewItem.SubItems[0].Text = rm.GetString("RES_CANCELSCAN");
dorkdone.ViewItem.SubItems[2].Text = "";
return;
}
if (dorkdone.ScanResult == (int)RESULT_STATUS.Nothing)
{
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceInfo, "Scan returned no results.");
dorkdone.ViewItem.ImageIndex = (int)RESULT_STATUS.Nothing;
dorkdone.ViewItem.SubItems[0].Text = rm.GetString("RES_NORESULT");
dorkdone.ViewItem.SubItems[2].Text = "";
summaryStat.ScansNoResult++;
return;
}
if (dorkdone.ScanResult == (int)RESULT_STATUS.Failure)
{
dorkdone.ViewItem.ImageIndex = (int)RESULT_STATUS.Failure;
dorkdone.ViewItem.SubItems[0].Text = rm.GetString("RES_FAILED");
dorkdone.ViewItem.SubItems[2].Text = "";
summaryStat.ScansFailed++;
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceInfo, "Scan failed.");
return;
}
if (dorkdone.ScanResult == (int)RESULT_STATUS.Blocked)
{
dorkdone.ViewItem.ImageIndex = (int)RESULT_STATUS.Blocked;
dorkdone.ViewItem.SubItems[0].Text = rm.GetString("RES_BLOCKED");
dorkdone.ViewItem.SubItems[2].Text = dorkdone.ResultURL;
summaryStat.ScansFailed++;
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceInfo, "Scan was blocked.");
if (Properties.Settings.Default.BlockDetectMode == (int)BLOCKING_MODE.SingleAndStop)
{
int stoppedscans = scanmonitor.StopAllActive();
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceVerbose, stoppedscans, "Scans canceled in queue");
while (scanmonitor.HasPendingScans())
{
Thread.Sleep(200);
}
}
if (Properties.Settings.Default.BlockDetectMode != (int)BLOCKING_MODE.Ignore)
{
ShowScanningDialog(false);
DialogResult dr = MessageBox.Show("Start browser to unlock block? Cancel will stop scanning.", "Block detected!", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Stop);
if (dr == DialogResult.Yes)
{
OSUtils.OpenInBrowser(dorkdone.ResultURL);
MessageBox.Show("Ready to resume?", "Resume scanning.", MessageBoxButtons.OK, MessageBoxIcon.Question);
}
else if (dr == DialogResult.Cancel)
{
int stoppedscans = scanmonitor.StopAllActive();
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceVerbose, stoppedscans, "Scans canceled in queue");
while (scanmonitor.HasPendingScans())
{
Thread.Sleep(100);
}
StopScanning();
}
ShowScanningDialog(true);
}
return;
}
if (dorkdone.ScanResult == (int)RESULT_STATUS.ScanWithResult)
{
resultListView.Items.Remove(dorkdone.ViewItem); // remove the one that is displayed while scanning
if (scanner.Count > 0)
{
int lastIdx = 0;
DorkDone resDork = scanner.ResultDork;
DorkDone followDork = null;
if (resDork.NextPage != 0)
{
if ((resDork.NextPage / 10) < Properties.Settings.Default.RequestPages)
{
followDork = new DorkDone();
followDork = (DorkDone)resDork.Clone();
followDork.ScanResult = (int)RESULT_STATUS.WhileScan;
Scanner nextscanner = new Scanner(new ScanGoogleProvider(), followDork);
while (!scanmonitor.IsThreadAvail())
{
Thread.Sleep(300);
}
scanmonitor.Add(nextscanner);
Thread.Sleep(100);
}
}
do
{
ListViewItem lv1 = resultListView.Items.Add(rm.GetString("RES_SUCCESS"),
(int)RESULT_STATUS.ScanWithResult);
lv1.SubItems.Add(resDork.Title);
lv1.SubItems.Add(resDork.ResultURL);
lastIdx = lv1.Index;
lv1.Tag = resDork;
summaryStat.ScansSuccess++;
resDork = resDork.Next;
resultListView.EnsureVisible(lastIdx);
} while (resDork != null);
}
}
}
}
/// <summary>
/// Run a scan with a DorkDone.
/// </summary>
/// <param name="DorkToScan">DorkDone to scan.</param>
/// <returns>True if no errors occured.</returns>
public bool DoDork(DorkDone DorkToScan)
{
_ScanStatus = (int)SCANTHREADSTATE.Working;
RequestBuilder req = new RequestBuilder(scanProvider);
httpGet = new HttpSimpleGet(Properties.Settings.Default.ScanTimeOut);
string currentRequest = req.getRequest(DorkToScan.Query,
DorkToScan.Host,
DorkToScan.NextPage);
Trace.WriteLineIf(Debug.Trace.TraceGoolag.TraceInfo, currentRequest, "ScanURL:");
if (!httpGet.Do(currentRequest))
{
DorkToScan.ErrorMessage = httpGet.GetErrorMessage();
DorkToScan.ScanResult = (int)RESULT_STATUS.Failure;
_ScanStatus = (int)SCANTHREADSTATE.Finished;
firstResultDork = DorkToScan;
return(false);
}
ParseHtmlResults parser = new ParseHtmlResults(scanProvider, DorkToScan.NextPage);
parsedResults = parser.Parse(httpGet.GetResults());
if (parsedResults.Count > 0)
{
DorkToScan.ScanResult = (int)RESULT_STATUS.ScanWithResult;
DorkToScan.NextPage = parser.NextPage;
DorkDone tmpDork = null;
foreach (string parsedUrl in parsedResults)
{
DorkDone newDork = new DorkDone();
newDork = (DorkDone)DorkToScan.Clone();
newDork.ResultURL = parsedUrl;
newDork.Next = tmpDork;
tmpDork = newDork;
}
firstResultDork = tmpDork;
}
else
{
DorkToScan.Next = null;
firstResultDork = DorkToScan;
if (parser.Blocked)
{
DorkToScan.ScanResult = (int)RESULT_STATUS.Blocked;
DorkToScan.ResultURL = httpGet.ResponseUri;
}
else
{
DorkToScan.ScanResult = (int)RESULT_STATUS.Nothing;
}
}
_ScanStatus = (int)SCANTHREADSTATE.Finished;
return(true);
}
