class DiffDialog(QDialog, DiffDialog.Ui_DiffDialog):
""" Visual dialog that allows for the diffing of two responses """
def __init__(self, framework, parent=None):
super(DiffDialog, self).__init__(parent)
self.setupUi(self)
self.framework = framework
self.Progress = ProgressDialog()
self.framework.subscribe_add_differ_response_id(
self.differ_add_response_id)
# Create progress dialog
self.customButton.clicked.connect(self.custom_diff)
self.leftTree.itemSelectionChanged.connect(self.diff_items)
self.rightTree.itemSelectionChanged.connect(self.diff_items)
self.clearButton.clicked.connect(self.clear_items)
self.Data = None
self.cursor = None
self.framework.subscribe_database_events(self.db_attach,
self.db_detach)
def db_attach(self):
self.Data = self.framework.getDB()
self.cursor = self.Data.allocate_thread_cursor()
self.populate_differ_ids()
def db_detach(self):
self.clear_items()
self.close_cursor()
self.Data = None
def close_cursor(self):
if self.cursor and self.Data:
self.cursor.close()
self.Data.release_thread_cursor(self.cursor)
self.cursor = None
def populate_differ_ids(self):
for row in self.Data.get_differ_ids(self.cursor):
# TODO: add constants?
self.leftTree.addTopLevelItem(
QTreeWidgetItem([str(row[0]), str(row[1])]))
self.rightTree.addTopLevelItem(
QTreeWidgetItem([str(row[0]), str(row[1])]))
def differ_add_response_id(self, Id):
row = self.Data.read_responses_by_id(self.cursor, Id)
if not row:
return
responseItems = [m or '' for m in list(row)]
self.leftTree.addTopLevelItem(
QTreeWidgetItem(
[str(row[ResponsesTable.ID]),
str(row[ResponsesTable.URL])]))
self.rightTree.addTopLevelItem(
QTreeWidgetItem(
[str(row[ResponsesTable.ID]),
str(row[ResponsesTable.URL])]))
def clear_items(self):
self.leftTree.clear()
self.rightTree.clear()
self.Data.clear_differ_items(self.cursor)
def diff_items(self):
""" Diff the selected items in the two panes """
differ = difflib.HtmlDiff(wrapcolumn=50)
# Passes if only one item is selected, otherwise it would error
leftItem = self.leftTree.currentItem()
rightItem = self.rightTree.currentItem()
if leftItem is not None and rightItem is not None:
try:
self.Progress.show()
leftIndex = str(leftItem.text(0))
rightIndex = str(rightItem.text(0))
if leftIndex != rightIndex:
# TODO: take content types into account
# TODO: can a initial match be done to detect when comparing extremely disimilar types
# compute character distribution, check standard deviation
# TODO: this should be run in a background thread to avoid starving main loop
dbResponse = self.Data.read_responses_by_id(
self.cursor, leftIndex)
leftHtml = str(dbResponse[ResponsesTable.RES_DATA])
dbResponse = self.Data.read_responses_by_id(
self.cursor, rightIndex)
rightHtml = str(dbResponse[ResponsesTable.RES_DATA])
diffHtml = differ.make_file(leftHtml.splitlines(),
rightHtml.splitlines())
self.diffView.setHtml(diffHtml)
else:
self.diffView.setHtml('')
except Exception as e:
self.display_message('Failed when comparing:\n%s' % (e))
self.diffView.setHtml('')
finally:
self.Progress.close()
def custom_diff(self):
""" Custom diff dialog that allows you to copy and paste content in to do
custom diffing """
#ToDo: Fix: Currently runs on exec and can't go back to the main dialog until closed
customDiffDialog = DiffCustomDialog()
customDiffDialog.show()
customDiffDialog.exec_()
def display_message(self, message):
dialog = SimpleDialog(message)
dialog.exec_()
class DiffDialog(QDialog, DiffDialog.Ui_DiffDialog):
""" Visual dialog that allows for the diffing of two responses """
def __init__(self, framework, parent=None):
super(DiffDialog, self).__init__(parent)
self.setupUi(self)
self.framework = framework
self.Progress = ProgressDialog()
self.framework.subscribe_add_differ_response_id(self.differ_add_response_id)
# Create progress dialog
self.customButton.clicked.connect(self.custom_diff)
self.leftTree.itemSelectionChanged.connect(self.diff_items)
self.rightTree.itemSelectionChanged.connect(self.diff_items)
self.clearButton.clicked.connect(self.clear_items)
self.Data = None
self.cursor = None
self.framework.subscribe_database_events(self.db_attach, self.db_detach)
def db_attach(self):
self.Data = self.framework.getDB()
self.cursor = self.Data.allocate_thread_cursor()
self.populate_differ_ids()
def db_detach(self):
self.clear_items()
self.close_cursor()
self.Data = None
def close_cursor(self):
if self.cursor and self.Data:
self.cursor.close()
self.Data.release_thread_cursor(self.cursor)
self.cursor = None
def populate_differ_ids(self):
for row in self.Data.get_differ_ids(self.cursor):
# TODO: add constants?
self.leftTree.addTopLevelItem(QTreeWidgetItem([str(row[0]), str(row[1])]))
self.rightTree.addTopLevelItem(QTreeWidgetItem([str(row[0]), str(row[1])]))
def differ_add_response_id(self, Id):
row = self.Data.read_responses_by_id(self.cursor, Id)
if not row:
return
responseItems = [m or '' for m in list(row)]
self.leftTree.addTopLevelItem(QTreeWidgetItem([str(row[ResponsesTable.ID]), str(row[ResponsesTable.URL])]))
self.rightTree.addTopLevelItem(QTreeWidgetItem([str(row[ResponsesTable.ID]), str(row[ResponsesTable.URL])]))
def clear_items(self):
self.leftTree.clear()
self.rightTree.clear()
self.Data.clear_differ_items(self.cursor)
def diff_items(self):
""" Diff the selected items in the two panes """
differ = difflib.HtmlDiff(wrapcolumn=50)
# Passes if only one item is selected, otherwise it would error
leftItem = self.leftTree.currentItem()
rightItem = self.rightTree.currentItem()
if leftItem is not None and rightItem is not None:
try:
self.Progress.show()
leftIndex = str(leftItem.text(0))
rightIndex = str(rightItem.text(0))
if leftIndex != rightIndex:
# TODO: take content types into account
# TODO: can a initial match be done to detect when comparing extremely disimilar types
# compute character distribution, check standard deviation
# TODO: this should be run in a background thread to avoid starving main loop
dbResponse = self.Data.read_responses_by_id(self.cursor, leftIndex)
leftHtml = str(dbResponse[ResponsesTable.RES_DATA])
dbResponse = self.Data.read_responses_by_id(self.cursor, rightIndex)
rightHtml = str(dbResponse[ResponsesTable.RES_DATA])
diffHtml = differ.make_file(leftHtml.splitlines(), rightHtml.splitlines())
self.diffView.setHtml(diffHtml)
else:
self.diffView.setHtml('')
except Exception as e:
self.display_message('Failed when comparing:\n%s' % (e))
self.diffView.setHtml('')
finally:
self.Progress.close()
def custom_diff(self):
""" Custom diff dialog that allows you to copy and paste content in to do
custom diffing """
#ToDo: Fix: Currently runs on exec and can't go back to the main dialog until closed
customDiffDialog = DiffCustomDialog()
customDiffDialog.show()
customDiffDialog.exec_()
def display_message(self, message):
dialog = SimpleDialog(message)
dialog.exec_()
class RaftMain(QMainWindow, RaftMain.Ui_MainWindow):
""" Reimplementation of the imported Ui_MainWindow class """
def __init__(self, dbfilename = '', parent=None):
super(RaftMain, self).__init__(parent)
if MAC:
qt_mac_set_native_menubar(False)
self.setupUi(self)
# hide currently unimplemented features
self.reqTabRawRequestTab.hide()
self.reqTabRawRequestTab.setParent(None)
self.wfUnusedSequenceTab.hide()
self.wfUnusedSequenceTab.setParent(None)
# initialize framework
self.framework = Framework(self)
# default filename is temp.raftdb
if dbfilename:
self.dbfilename = dbfilename
else:
self.dbfilename = self.framework.get_temp_db_filename()
# restore settings
self.restore_settings()
# Create progress dialog
self.Progress = ProgressDialog()
# add helper and utility singletons
# TODO: should be base extractor and that loads/returns appropriate type
self.contentExtractor = BaseExtractor.BaseExtractor()
self.framework.setContentExtractor(self.contentExtractor)
# Create actions for items
self.responsesDataTree.doubleClicked.connect(self.response_item_double_clicked)
self.fillingDataTree = False
self.responsesDataTree.clicked.connect(self.fill_bottom)
self.responsesDataTree.activated.connect(self.fill_bottom)
self.responsesDataTree.setSortingEnabled(True)
self.responsesDataTree.sortByColumn(0, Qt.AscendingOrder)
#analysis tab connections
self.mainAnalysisTreeWidget.clicked.connect(self.analysistree_handle_click)
self.mainAnalysisTreeWidget.activated.connect(self.analysistree_handle_click)
self.mainAnalysisTreeWidget.expanded.connect(self.analysistree_handle_expand)
self.cookiesTabIndex = self.mainTabWidget.indexOf(self.tabMainCookies)
self.mainTabWidget.currentChanged.connect(self.main_tab_change)
# Toolbar buttons and actions
self.actionButtonOpen.triggered.connect(self.open_file)
self.actionZoomIn.triggered.connect(self.zoom_in)
self.actionZoomOut.triggered.connect(self.zoom_out)
self.actionDiff.triggered.connect(self.diff)
self.actionAnalyze.triggered.connect(self.analyze_content)
self.actionSequence.triggered.connect(self.display_sequence)
self.actionConfig.triggered.connect(self.display_config)
self.actionSearch.triggered.connect(self.display_search)
self.actionBrowser.triggered.connect(self.launch_browser)
# Create the actions for the buttons
# self.connect(self.encodeButton, SIGNAL("clicked()"), self.encode_values)
# self.connect(self.encodeWrapButton, SIGNAL("clicked()"), self.wrap_encode)
# self.connect(self.decodeButton, SIGNAL("clicked()"), self.decode_values)
# self.connect(self.decodeWrapButton, SIGNAL("clicked()"), self.wrap_decode)
# Actions for Menus
self.actionNew_Project.triggered.connect(self.new_project)
self.actionOpen.triggered.connect(self.open_file)
self.actionSave_As.triggered.connect(self.save_as)
self.actionImport_RaftCaptureXml.triggered.connect(lambda x: self.import_raft('raft_capture_xml'))
self.actionImport_BurpLog.triggered.connect(lambda x: self.import_burp('burp_log'))
self.actionImport_BurpState.triggered.connect(lambda x: self.import_burp('burp_state'))
self.actionImport_BurpXml.triggered.connect(lambda x: self.import_burp('burp_xml'))
self.actionImport_Burp_Vuln_XML.triggered.connect(lambda x: self.import_burp('burp_vuln_xml'))
self.actionImport_AppScan_XML.triggered.connect(lambda x: self.import_appscan('appscan_xml'))
self.actionImport_WebScarab.triggered.connect(self.import_webscarab)
self.actionImport_ParosMessages.triggered.connect(lambda x: self.import_paros('paros_message'))
self.actionRefresh_Responses.triggered.connect(self.refresh_responses)
self.actionClear_Responses.triggered.connect(self.clear_responses)
self.actionExport_Settings.triggered.connect(self.export_settings)
self.actionImport_Settings.triggered.connect(self.import_settings)
self.actionEncoder_Decoder.triggered.connect(self.detach_encoder)
# Actions for configuration
self.actionConfiguration_BlackHoleNetwork.triggered.connect(lambda x: self.raft_config_toggle('black_hole_network', x))
self.actionAbout_RAFT.triggered.connect(self.display_about)
self.actionAnalysisConfiguration.triggered.connect(self.display_analysis_config)
# Declare, but do not fill, list of analyzers
self.analyzerlist = AnalyzerList(self.framework)
self.setup_others()
def db_attach(self):
self.framework.debug_log('Database %s attached' % (self.db))
self.cursor = self.Data.allocate_thread_cursor()
def db_detach(self):
self.framework.debug_log('Database %s detached' % (self.db))
if self.Data:
self.close_cursor()
def close_cursor(self):
if self.cursor and self.Data:
self.cursor.close()
self.Data.release_thread_cursor(self.cursor)
self.cursor = None
def do_db_connect(self):
###
# Set up initial data connections for tools
###
self.framework.subscribe_database_events(self.db_attach, self.db_detach)
self.Progress.show()
# Set initial temp.raftdb file for storage of imported data.
self.Data = database.Db(__version__, self.framework.report_exception)
self.db = self.dbfilename
self.databaseThread = DatabaseThread.DatabaseThread(self.framework, self.Data, self)
self.connect(self, SIGNAL('connectDbFinished()'), self.connectDbFinishedHandler, Qt.QueuedConnection)
self.databaseThread.start()
self.databaseThread.connectDb(self.db, self)
def connectDbFinishedHandler(self):
self.framework.setDB(self.Data, self.db)
self.actionConfiguration_BlackHoleNetwork.setChecked(self.framework.get_raft_config_value('black_hole_network', bool))
self.Progress.close()
self.refresh_analysis_tab()
def setup_others(self):
# set request response factory
self.framework.setRequestResponseFactory(RequestResponseFactory.RequestResponseFactory(self.framework, self))
# scoping and spider
self.framework.setScopeController(ScopeController.ScopeController(self.framework, self))
self.framework.setSpiderConfig(SpiderConfig.SpiderConfig(self.framework, self))
# setup network accessmanager
self.dbNetworkAccessManager = DatabaseNetworkAccessManager(self.framework, self.framework.get_global_cookie_jar())
self.framework.setNetworkAccessManager(self.dbNetworkAccessManager)
# set up tabs
self.vulnerabilitiesTab = VulnerabilitiesTab.VulnerabilitiesTab(self.framework, self)
self.cookiesTab = CookiesTab.CookiesTab(self.framework, self)
self.requesterTab = RequesterTab.RequesterTab(self.framework, self)
self.webfuzzerTab = WebFuzzerTab.WebFuzzerTab(self.framework, self)
self.domFuzzerTab = DomFuzzerTab.DomFuzzerTab(self.framework, self)
self.crawlerTab = CrawlerTab.CrawlerTab(self.framework, self)
self.encoderTab = EncoderTab.EncoderTab(self.framework, self)
self.scopingTab = ScopingTab.ScopingTab(self.framework, self)
self.testerTab = TesterTab.TesterTab(self.framework, self)
self.logTab = LogTab.LogTab(self.framework, self)
self.quickAnalysisTab = QuickAnalysisTab.QuickAnalysisTab(self.framework, self)
# sitemap
self.siteMapRequestResponse = RequestResponseWidget(self.framework, self.sitemapTabPlaceholder, self.sitemapSearchControlPlaceholder, self)
# TODO: cleanup site map and optimize...
self.siteMapModel = SiteMapModel.SiteMapModel(self.framework)
self.siteMapThread = SiteMapThread.SiteMapThread(self.framework, self.siteMapModel, self)
self.siteMapThread.start(QThread.LowestPriority)
self.importerThread = ImporterThread.ImporterThread(self.framework, self)
self.connect(self, SIGNAL('runImportFinished()'), self.import_file_finished, Qt.QueuedConnection)
self.importerThread.start(QThread.LowestPriority)
self.treeViewSitemap.setContextMenuPolicy(Qt.CustomContextMenu)
self.treeViewSitemapMenu = QMenu(self)
treeViewSitemapCopyUrlAction = QAction("Copy URL", self)
treeViewSitemapCopyUrlAction.triggered.connect(self.sitemap_copy_url)
self.treeViewSitemapMenu.addAction(treeViewSitemapCopyUrlAction)
self.connect(self.treeViewSitemap, SIGNAL('customContextMenuRequested(const QPoint &)'), self.sitemap_context_menu)
self.treeViewSitemap.activated.connect(self.siteMapRequestResponse.viewItemSelected)
# TODO: clicked is annoying sometimes
self.treeViewSitemap.clicked.connect(self.siteMapRequestResponse.viewItemSelected)
self.treeViewSitemap.setModel(self.siteMapModel)
# view tab
self.viewTabRequestResponse = RequestResponseWidget(self.framework, self.responseTabPlaceholder, self.responseSearchControlPlaceholder, self)
# Responses data
self.responsesDataModel = ResponsesDataModel.ResponsesDataModel(self.framework, self)
self.responsesDataTree.setModel(self.responsesDataModel)
self.responsesThread = ResponsesThread.ResponsesThread(self.framework, self.responsesDataModel, self)
self.responsesThread.start(QThread.LowPriority)
self.connect(self, SIGNAL('fillResponsesFinished()'), self.fillResponsesFinishedHandler, Qt.QueuedConnection)
self.responsesContextMenu = ResponsesContextMenuWidget(self.framework, self.responsesDataModel, self.responsesDataTree, self)
self.responsesContextMenu.set_currentChanged_callback(self.fill_bottom)
#analysis results tab
#add response widget to the bottom
self.mainAnalysisTabRequestResponse = RequestResponseWidget(self.framework, self.mainAnalysisTabPlaceholder, self.mainAnalysisSearchControlPlaceholder, self)
self.analyzerThread = AnalyzerThread.AnalyzerThread(self.framework, self)
self.connect(self, SIGNAL('runAnalysisFinished(QString)'), self.handle_runAnalysisFinished, Qt.QueuedConnection)
self.analyzerThread.start(QThread.LowestPriority)
# dom fuzzer thread
self.domFuzzerQueueDataModel = DomFuzzerQueueDataModel.DomFuzzerQueueDataModel(self.framework, self)
self.domFuzzerFuzzQueueTable.setModel(self.domFuzzerQueueDataModel)
self.domFuzzerResultsDataModel = DomFuzzerResultsDataModel.DomFuzzerResultsDataModel(self.framework, self)
self.domFuzzerResultsTreeView.setModel(self.domFuzzerResultsDataModel)
self.domFuzzerThread = DomFuzzerThread.DomFuzzerThread(self.framework, self.domFuzzerQueueDataModel, self.domFuzzerResultsDataModel, self)
self.domFuzzerThread.start(QThread.LowestPriority)
self.domFuzzerTab.set_fuzzer_thread(self.domFuzzerThread)
self.domFuzzerTab.setup_fuzzer_results_treeview()
# spider thread
self.spiderQueueDataModel = SpiderQueueDataModel.SpiderQueueDataModel(self.framework, self)
self.crawlerSpiderQueueTreeView.setModel(self.spiderQueueDataModel)
self.spiderPendingResponsesDataModel = SpiderPendingResponsesDataModel.SpiderPendingResponsesDataModel(self.framework, self)
self.crawlerSpiderPendingResponsesTreeView.setModel(self.spiderPendingResponsesDataModel)
self.spiderPendingAnalysisDataModel = SpiderPendingAnalysisDataModel.SpiderPendingAnalysisDataModel(self.framework, self)
self.crawlerSpiderPendingAnalysisTreeView.setModel(self.spiderPendingAnalysisDataModel)
self.spiderInternalStateDataModel = SpiderInternalStateDataModel.SpiderInternalStateDataModel(self.framework, self)
self.crawlerSpiderInternalStateTreeView.setModel(self.spiderInternalStateDataModel)
self.spiderThread = SpiderThread.SpiderThread(self.framework, self.spiderQueueDataModel, self.spiderPendingResponsesDataModel, self.spiderPendingAnalysisDataModel, self.spiderInternalStateDataModel, self)
self.spiderThread.start(QThread.LowestPriority)
self.crawlerTab.set_spider_thread(self.spiderThread)
# quick analysis thread
self.quickAnalysisThread = QuickAnalysisThread.QuickAnalysisThread(self.framework, self)
self.quickAnalysisThread.start(QThread.LowestPriority)
self.quickAnalysisTab.set_quick_analysis_thread(self.quickAnalysisThread)
# handlers
self.framework.register_browser_openers(self.open_url_in_browser, self.open_content_in_browser)
self.do_db_connect()
def fillResponses(self, fillAll = False):
self.Progress.show()
self.fillingDataTree = True
self.fillAll = fillAll
self.responsesThread.fillResponses(fillAll, self)
def fillResponsesFinishedHandler(self):
self.Progress.close()
self.fillingDataTree = False
self.siteMapThread.populateSiteMap(self.fillAll)
def restore_settings(self):
# TODO: make constants make sense
settings = QSettings('RaftDev', 'Raft');
saved = settings.value('RaftMain/geometry')
if saved is not None:
self.restoreGeometry(saved);
def closeEvent(self, event):
settings = QSettings('RaftDev', 'Raft');
settings.setValue('RaftMain/geometry', self.saveGeometry());
QWidget.closeEvent(self, event)
def create_file(self):
""" Open a dialog and allow for specifying a filename as well as creating a new database """
file = QFileDialog.getSaveFileName(None, "Create File", "")
self.Data.create_raft_db(str(file), __version__)
def new_project(self):
# Support '.raftdb' file types
file = QFileDialog.getSaveFileName(None, "Create new RAFT DB file", "", "RAFT Database File (*.raftdb)")
if file:
self.Progress.show()
try:
# Reinitialize with the database value set from new db name
self.framework.closeDB()
# 2 seconds to settle
QThread.sleep(2)
self.db = str(file)
self.databaseThread.connectDb(self.db, self)
finally:
self.Progress.close()
def open_file(self):
""" Open File from file open dialog """
file = QFileDialog.getOpenFileName(None, "Open file", "")
if file != "":
origdb = self.db
self.Progress.show()
# Reinitialize with the database value set
self.framework.closeDB()
self.db = str(file)
self.databaseThread.connectDb(self.db, self)
else:
pass
def save_as(self):
""" Dialog and logic to save the temp.raftdb file to a working database """
# Support '.db' file types
file = QFileDialog.getSaveFileName(None, "Save to RAFT DB file", "", "RAFT Database File (*.raftdb)")
if file:
self.Progress.show()
try:
# Reinitialize with the database value set from new db name
self.framework.closeDB()
# 5 seconds to settle
QThread.sleep(2)
# New db location
new_db = str(file)
shutil.move(self.db, new_db)
self.db = new_db
self.databaseThread.connectDb(self.db, self)
finally:
self.Progress.close()
def refresh_responses(self):
self.fillResponses(True)
def clear_responses(self):
response = self.display_confirm_dialog('Clear All Responses?\n\nAll response data will be permanently removed from the project database!')
if response:
self.Progress.show()
try:
# Truncate existing response values
self.Data.truncate_response_data(self.cursor)
self.framework.closeDB()
self.databaseThread.connectDb(self.db, self)
finally:
self.Progress.close()
def export_settings(self):
filename = QFileDialog.getSaveFileName(None, "Export RAFT Settings", "", "RAFT Settings File (*.raftsettings)")
if filename:
self.Progress.show()
SettingsFiles.process_export(self.framework, filename)
self.Progress.close()
def import_settings(self):
filename = QFileDialog.getOpenFileName(None, "Import RAFT Settings", "", "RAFT Settings File (*.raftsettings)")
if filename:
self.Progress.show()
SettingsFiles.process_import(self.framework, filename)
self.Progress.close()
def import_file_finished(self):
self.Progress.close()
self.fillResponses()
def import_proxy_file(self, proxy_file, source):
self.Progress.show()
self.importerThread.runImport(importers, proxy_file, source, self)
def import_proxy_files(self, proxy_filelist, source):
self.Progress.show()
self.importerThread.runImportList(importers, proxy_filelist, source, self)
def import_burp(self, source):
""" Import a Burp proxy log """
files = QFileDialog.getOpenFileNames(None, "Open file", "")
if files is not None:
self.import_proxy_files(files, source)
def import_appscan(self, source):
""" Import an AppScan XML file """
files = QFileDialog.getOpenFileNames(None, "Open file", "")
if files is not None:
self.import_proxy_files(files, source)
def import_raft(self, source):
""" Import a Raft Capture XML """
files = QFileDialog.getOpenFileNames(None, "Open file", "")
if files is not None:
self.import_proxy_files(files, source)
def import_webscarab(self, source):
""" Import a WebScarab conversation log """
# TODO: decide if there is a more friendly way to handle this
# file = QFileDialog.getExistingDirectory(None, "Open saved conversation", "")
file = QFileDialog.getOpenFileName(None, "Open saved conversation", "", "Converstation Log (conversationlog)")
if file:
self.import_proxy_file(str(file), 'webscarab')
def import_paros(self, source):
""" Import a Paros proxy log """
file = QFileDialog.getOpenFileName(None, "Open file", "")
if file:
self.import_proxy_file(str(file), source)
################################################
# Is this section still being used now we are depend on the AnalyzerThread? Can we rip it out?
def analyze_content(self):
""" Perform analysis on the captured content"""
self.Progress.show()
self.analyzerThread.runAnalysis(self)
def handle_runAnalysisFinished(self, fullanalysistext = ''):
self.Progress.close()
#self.mainAnalysisEdit.setText(fullanalysistext)
#self.refresh_analysis_tab()
self.analysis_tab_add_results(None)
def refresh_analysis_tab(self):
self.runsdisplayed=list()
rundata=self.Data.analysis_get_runs(self.cursor)
self.populate_analysis_tree(rundata)
def analysis_tab_add_results(self,results):
rundata=self.Data.analysis_get_runs(self.cursor, lastx=1)
self.populate_analysis_tree(rundata)
def populate_analysis_tree(self,rundata):
virtualparent=self.mainAnalysisTreeWidget.invisibleRootItem()
resultfactory=ResultFactory()
for run in rundata:
runid=run[0]
if runid not in self.runsdisplayed:
self.runsdisplayed.append(runid)
tempRun=AnalysisRun(run[1], run[2],resultfactory)
tempRun.runid=runid
tempRun.dbgenerated=True
runtreeitem=tempRun.generateTreeItem(virtualparent)
runtreeitem.customdata=tempRun
tempRun.generateTreeChildren(self.Data,self.cursor,runtreeitem)
def analysistree_handle_expand(self, index):
item=self.mainAnalysisTreeView.itemFromIndex(index)
item.wasexpanded=True
self.analysistree_load_grandchildren(item)
def analysistree_load_grandchildren(self, item):
#For each child of this item:
numchildren=item.childCount()
for i in range(0,numchildren):
childitem=item.child(i)
childitem.wasexpanded=True
#If the childitem doesn't have children, make them:
if childitem.childCount()==0:
childitem.customdata.generateTreeChildren(self.Data,self.cursor,childitem)
childitem.wasexpanded=True
def analysistree_handle_click(self, index):
item=self.mainAnalysisTreeWidget.itemFromIndex(index)
if hasattr(item,'customdata'):
self.analysistree_load_decendants_to_bottom(item)
self.mainAnalysisEdit.setText(item.customdata.toHTML())
self.fill_analysis_request_response(item)
if hasattr(item.customdata, 'getFoundData'):
founddata=item.customdata.getFoundData()
if founddata is not None:
self.set_analysis_request_response_highlight('response',founddata)
def set_analysis_request_response_highlight(self, section, searchtext):
self.mainAnalysisTabRequestResponse.set_search(section, searchtext)
def analysistree_load_decendants_to_bottom(self,item):
numchildren=item.childCount()
if hasattr(item,'customdata') and numchildren==0: #(not hasattr(item,'wasexpanded') or not item.wasexpanded):
item.customdata.generateTreeChildren(self.Data, self.cursor, item)
item.wasexpanded=True
for i in range(0,numchildren):
self.analysistree_load_decendants_to_bottom(item.child(i))
def response_item_double_clicked(self, index):
Id = interface.index_to_id(self.responsesDataModel, index)
if Id:
dialog = RequestResponseDetailDialog(self.framework, Id, self)
dialog.show()
dialog.exec_()
def fill_bottom(self, index):
""" Return the data from the database and fill bottom part of main window """
if self.fillingDataTree:
return
Id = interface.index_to_id(self.responsesDataModel, index)
if Id:
self.viewTabRequestResponse.fill(str(Id))
def fill_analysis_request_response(self, item):
""" Return the data from the database and fill bottom part of main window """
pageid=None
for possible in (item, item.parent()):
if hasattr(possible,"customdata") and hasattr(possible.customdata,"pageid"):
pageid=possible.customdata.pageid
break
if pageid is not None:
self.mainAnalysisTabRequestResponse.fill(str(pageid))
####
# Requester tool section
####
def main_tab_change(self):
""" This function fires when the main tab widget changes. """
position = self.mainTabWidget.currentIndex()
if self.cookiesTabIndex == position:
self.cookiesTab.fill_cookies_tab()
####
# Web Fuzzer tool section
####
def check_content_type(self, content):
""" Check the content type of submitted content """
# TODO: improve these to match tighter
pattern_xml = re.compile("xml", re.I)
pattern_js = re.compile("javascript", re.I)
pattern_json = re.compile("json", re.I)
pattern_css = re.compile("css", re.I)
# Return the lexer type
if pattern_xml.search(content):
return("xml")
elif pattern_js.search(content):
return("javascript")
elif pattern_json.search(content):
return("javascript")
elif pattern_css.search(content):
return("css")
else:
return(None)
def zoom_in(self):
""" Zoom in on the items in the selected tab """
self.framework.signal_zoom_in()
def zoom_out(self):
""" Zoom out on the items in the selected tab """
self.framework.signal_zoom_out()
def sitemap_context_menu(self, point):
""" Display the context menu for the sitemap """
self.treeViewSitemapMenu.exec_(self.treeViewSitemap.mapToGlobal(point))
def sitemap_copy_url(self):
index = self.treeViewSitemap.currentIndex()
if index and index.isValid():
obj = index.internalPointer()
if obj.url:
QApplication.clipboard().setText(obj.url)
def diff(self):
""" Launch Diff dialog and Diff 2 responses """
myDiffDialog = DiffDialog(self.framework)
myDiffDialog.show()
myDiffDialog.exec_()
def raft_config_toggle(self, configName, status):
configValue = 'False'
if status:
configValue = 'True'
self.framework.set_raft_config_value(configName, configValue)
def display_about(self):
dialog = RaftAboutDialog()
dialog.show()
dialog.exec_()
def display_message(self, message):
dialog = SimpleDialog(message)
dialog.exec_()
def display_confirm_dialog(self, message):
response = QMessageBox.question(self, 'Confirm', message, QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if 0 != (response & QMessageBox.Yes):
return True
else:
return False
def detach_encoder(self):
index = self.mainTabWidget.indexOf(self.tabMainEncoder)
if -1 != index:
tabText = self.mainTabWidget.tabText(index)
dialog = QDialog()
dialog.setWindowTitle(tabText)
verticalLayout = QVBoxLayout(dialog)
tabWidget = QTabWidget(dialog)
verticalLayout.addWidget(tabWidget)
self.tabMainEncoder.setParent(tabWidget)
tabWidget.addTab(self.tabMainEncoder, tabText)
dialog.finished.connect(lambda code: self.reattach_encoder(code, index))
dialog.show()
dialog.exec_()
def reattach_encoder(self, code, index):
self.tabMainEncoder.setParent(self.mainTabWidget)
self.mainTabWidget.insertTab(index, self.tabMainEncoder, 'Encoder')
def display_config(self):
dialog = ConfigDialog(self.framework, self)
dialog.show()
dialog.exec_()
def display_analysis_config(self):
dialog = AnalysisConfigDialog(self.framework, self)
#Instantiate all found analyzers
self.analyzerlist.instantiate_analyzers(useallanalyzers=True)
analyzerdict=TreeWidgetTools.obj_list_to_dict(self.analyzerlist, valueattr='isenabled')
TreeWidgetTools.populate_tree_widget(dialog.analyzerList,analyzerdict)
dialog.analyzerList.setSortingEnabled(True)
dialog.analyzerList.sortItems(0,0)
#generated.setParent(dialog.LeftWidget)
#dialog.verticalLayoutTopLeft.addWidget(generated)
#dialog.analyzerList=generated
dialog.analyzerList.clicked.connect(dialog.viewItemSelected)
dialog.defaultsButton.clicked.connect(dialog.defaultsButtonClicked)
dialog.saveAllButton.clicked.connect(dialog.saveAllButtonClicked)
dialog.closeButton.clicked.connect(dialog.closeButtonClicked)
dialog.saveButton.clicked.connect(dialog.saveButtonClicked)
dialog.addnodeButton.clicked.connect(dialog.addnodeButtonClicked)
dialog.delnodeButton.clicked.connect(dialog.delnodeButtonClicked)
#Setup complete, display dialog
dialog.show()
dialog.exec_()
def display_sequence(self):
dialog = SequenceDialog(self.framework)
dialog.show()
dialog.exec_()
def display_search(self):
dialog = SearchDialog(self.framework, self)
dialog.show()
dialog.exec_()
def launch_browser(self):
dialog = RaftBrowserDialog(self.framework, self)
dialog.show()
dialog.exec_()
def open_url_in_browser(self, url):
options = {'url':url}
dialog = RaftBrowserDialog(self.framework, self, options)
dialog.show()
dialog.exec_()
def open_content_in_browser(self, url, body, mimetype = ''):
options = {'url':url, 'body':body, 'mimetype':mimetype}
dialog = RaftBrowserDialog(self.framework, self, options)
dialog.show()
dialog.exec_()
def test(self):
""" Test Function """
print("hello world")
class ConfigDialog(QDialog, ConfigDialog.Ui_configDialog):
""" The Config Dialog """
def __init__(self, framework, parent=None):
super(ConfigDialog, self).__init__(parent)
self.setupUi(self)
self.framework = framework
self.payloads_dir = os.path.join(self.framework.get_data_dir(), 'payloads')
self.Progress = ProgressDialog()
self.buttonBox.clicked.connect(self.handle_buttonBox_clicked)
self.checkBoxUseProxy.stateChanged.connect(self.handle_useProxy_stateChanged)
self.browserCustomUserAgentCheckBox.stateChanged.connect(self.handle_browserCustomUserAgent_stateChanged)
self.spiderExcludeDangerouPathCheckBox.stateChanged.connect(self.handle_spiderExcludeDangerouPath_stateChanged)
self.framework.subscribe_raft_config_populated(self.configuration_populated)
self.dataBankTab = DataBankTab.DataBankTab(self.framework, self)
self.dbankFuzzFileAddButton.clicked.connect(self.add_fuzz_file)
self.dbankFuzzFileDelButton.clicked.connect(self.del_fuzz_file)
self.dbankGenButton.clicked.connect(self.generate_payload)
def configuration_populated(self):
self.fill_values()
def fill_values(self):
self.bhNetworkBox.setChecked(self.framework.get_raft_config_value('black_hole_network', bool))
self.checkBoxUseProxy.setChecked(self.framework.get_raft_config_value('use_proxy', bool))
self.confProxyEdit.setText(self.framework.get_raft_config_value('proxy_host', default_value = 'localhost'))
self.confProxyPort.setText(self.framework.get_raft_config_value('proxy_port', default_value = '8080'))
self.confProxyUsername.setText(self.framework.get_raft_config_value('proxy_username'))
self.confProxyPassword.setText(self.framework.get_raft_config_value('proxy_password'))
if 'socks5' == self.framework.get_raft_config_value('proxy_type'):
self.confProxyProxyType.setCurrentIndex(1)
else:
self.confProxyProxyType.setCurrentIndex(0)
self.set_enable_proxy_edits()
self.fill_browser_edits()
self.fill_crawler_edits()
def handle_buttonBox_clicked(self, button):
role = self.buttonBox.buttonRole(button)
if role == QDialogButtonBox.AcceptRole:
self.do_save_config()
self.dataBankTab.do_save_databank()
def do_save_config(self):
self.framework.set_raft_config_value('black_hole_network', bool(self.bhNetworkBox.isChecked()))
if self.checkBoxUseProxy.isChecked():
self.framework.set_raft_config_value('proxy_host', self.confProxyEdit.text())
self.framework.set_raft_config_value('proxy_port', int(self.confProxyPort.text() or '8080'))
self.framework.set_raft_config_value('proxy_username', self.confProxyUsername.text())
self.framework.set_raft_config_value('proxy_password', self.confProxyPassword.text())
if 'http' in self.confProxyProxyType.currentText().lower():
self.framework.set_raft_config_value('proxy_type', 'http')
else:
self.framework.set_raft_config_value('proxy_type', 'socks5')
self.framework.set_raft_config_value('use_proxy', True)
else:
self.framework.set_raft_config_value('use_proxy', False)
self.save_browser_config()
self.save_crawler_config()
def handle_useProxy_stateChanged(self, state):
self.set_enable_proxy_edits()
def set_enable_proxy_edits(self):
if self.checkBoxUseProxy.isChecked():
self.confProxyEdit.setEnabled(True)
self.confProxyPort.setEnabled(True)
self.confProxyUsername.setEnabled(True)
self.confProxyPassword.setEnabled(True)
self.confProxyProxyType.setEnabled(True)
else:
self.confProxyEdit.setEnabled(False)
self.confProxyPort.setEnabled(False)
self.confProxyUsername.setEnabled(False)
self.confProxyPassword.setEnabled(False)
self.confProxyProxyType.setEnabled(False)
def fill_crawler_edits(self):
self.fill_spider_edits()
def save_crawler_config(self):
self.save_spider_config()
def value_or_default(self, obj, name, default_value):
if name in obj:
return obj[name]
else:
return default_value
def handle_spiderExcludeDangerouPath_stateChanged(self):
self.spiderDangerousPathEdit.setEnabled(self.spiderExcludeDangerouPathCheckBox.isChecked())
def handle_browserCustomUserAgent_stateChanged(self):
self.browserUserAgentEdit.setEnabled(self.browserCustomUserAgentCheckBox.isChecked())
def fill_spider_edits(self):
configuration = self.framework.get_raft_config_value('SPIDER', str)
if configuration:
obj = json.loads(configuration)
else:
obj = {}
self.spiderSubmitFormsCheckBox.setChecked(bool(self.value_or_default(obj, 'submit_forms', True)))
self.spiderUseDataBankCheckBox.setChecked(bool(self.value_or_default(obj, 'use_data_bank', True)))
self.spiderSubmitUsernamePasswordCheckBox.setChecked(bool(self.value_or_default(obj, 'submit_user_name_password', True)))
self.spiderEvaluateJavascriptCheckBox.setChecked(bool(self.value_or_default(obj, 'evaluate_javascript', True)))
self.spiderIterateUserAgentsCheckBox.setChecked(bool(self.value_or_default(obj, 'iterate_user_agents', True)))
self.spiderRetrieveMediaFilesCheckBox.setChecked(bool(self.value_or_default(obj, 'retrieve_media_files', True)))
self.spiderExcludeDangerouPathCheckBox.setChecked(bool(self.value_or_default(obj, 'exclude_dangerous_paths', False)))
self.spiderDangerousPathEdit.setText(self.value_or_default(obj, 'dangerous_path', 'delete|remove|destroy'))
self.spiderMaxLinksEdit.setText(str(self.value_or_default(obj, 'max_links', 8192)))
self.spiderMaxLinkDepthEdit.setText(str(self.value_or_default(obj, 'max_link_depth', 5)))
self.spiderMaxChildrenEdit.setText(str(self.value_or_default(obj, 'max_children', 256)))
self.spiderMaxUniqueParametersEdit.setText(str(self.value_or_default(obj, 'max_unique_parameters', 16)))
self.spiderRedundantContentLimit.setText(str(self.value_or_default(obj, 'redundant_content_limit', 128)))
self.spiderRedundantStructureLimit.setText(str(self.value_or_default(obj, 'redundant_structure_limit', 256)))
self.spiderMediaExtensionsEdit.setText(self.value_or_default(obj, 'media_extensions', 'wmv,mp3,mp4,mpa,gif,jpg,jpeg,png'))
def save_spider_config(self):
obj = {}
obj['submit_forms'] = self.spiderSubmitFormsCheckBox.isChecked()
obj['use_data_bank'] = self.spiderUseDataBankCheckBox.isChecked()
obj['submit_user_name_password'] = self.spiderSubmitUsernamePasswordCheckBox.isChecked()
obj['evaluate_javascript'] = self.spiderEvaluateJavascriptCheckBox.isChecked()
obj['iterate_user_agents'] = self.spiderIterateUserAgentsCheckBox.isChecked()
obj['retrieve_media_files'] = self.spiderRetrieveMediaFilesCheckBox.isChecked()
obj['exclude_dangerous_paths'] = self.spiderExcludeDangerouPathCheckBox.isChecked()
obj['dangerous_path'] = self.spiderDangerousPathEdit.text()
obj['max_links'] = int(self.spiderMaxLinksEdit.text())
obj['max_link_depth'] = int(self.spiderMaxLinkDepthEdit.text())
obj['max_children'] = int(self.spiderMaxChildrenEdit.text())
obj['max_unique_parameters'] = int(self.spiderMaxUniqueParametersEdit.text())
obj['redundant_content_limit'] = int(self.spiderRedundantContentLimit.text())
obj['redundant_structure_limit'] = int(self.spiderRedundantStructureLimit.text())
obj['media_extensions'] = self.spiderMediaExtensionsEdit.text()
configuration = json.dumps(obj)
self.framework.set_raft_config_value('SPIDER', configuration)
def fill_browser_edits(self):
self.browserEnableJavaScriptCheckBox.setChecked(self.framework.get_raft_config_value('browser_javascript_enabled', bool, True))
self.browserEnableWebStorageCheckBox.setChecked(self.framework.get_raft_config_value('browser_web_storage_enabled', bool, True))
self.browserEnablePluginsCheckBox.setChecked(self.framework.get_raft_config_value('browser_plugins_enabled', bool, True))
self.browserEnableJavaCheckBox.setChecked(self.framework.get_raft_config_value('browser_java_enabled', bool, True))
self.browserAutoLoadImagesCheckBox.setChecked(self.framework.get_raft_config_value('browser_auto_load_images', bool, True))
self.browserCustomUserAgentCheckBox.setChecked(self.framework.get_raft_config_value('browser_custom_user_agent', bool, False))
self.browserUserAgentEdit.setText(self.framework.get_raft_config_value('browser_user_agent_value', str, self.framework.useragent()))
def save_browser_config(self):
self.framework.set_raft_config_value('browser_javascript_enabled', self.browserEnableJavaScriptCheckBox.isChecked())
self.framework.set_raft_config_value('browser_web_storage_enabled', self.browserEnableWebStorageCheckBox.isChecked())
self.framework.set_raft_config_value('browser_plugins_enabled', self.browserEnablePluginsCheckBox.isChecked())
self.framework.set_raft_config_value('browser_java_enabled', self.browserEnableJavaCheckBox.isChecked())
self.framework.set_raft_config_value('browser_auto_load_images', self.browserAutoLoadImagesCheckBox.isChecked())
self.framework.set_raft_config_value('browser_custom_user_agent', self.browserCustomUserAgentCheckBox.isChecked())
self.framework.set_raft_config_value('browser_user_agent_value', self.browserUserAgentEdit.text())
def add_fuzz_file(self):
file = QFileDialog.getOpenFileName(None, "Open file", "")
shutil.copy(file, self.payloads_dir)
# Refresh the payload list in the interface.
# pl = Payloads.Payloads()
self.dataBankTab.fill_payload_combo_box()
def del_fuzz_file(self):
# Gets the current name of the file selected in the combobox
filename = self.dataBankTab.mainWindow.dbankPayloadsBox.currentText()
path = self.payloads_dir
message = "Are you sure you want to delete: {0}".format(filename)
response = ConfirmDialog.display_confirm_dialog(self, message)
if response == True:
os.remove(path + "/" + filename)
self.dataBankTab.fill_payload_combo_box()
# Clear the items from the textedit
self.dataBankTab.mainWindow.dbankFuzzValuesEdit.clear()
def write_payload(self, fullpath, start, stop):
step = self.dataBankTab.mainWindow.dbankGenStep.text()
prepend = self.dataBankTab.mainWindow.dbankGenPre.text()
postpend = self.dataBankTab.mainWindow.dbankGenPost.text()
try:
f = open(fullpath, "w")
self.Progress = ProgressDialog()
for item in range(int(start), int(stop), int(step)):
f.write(prepend + str(item) + postpend +"\n")
self.dataBankTab.fill_payload_combo_box()
# Display a message since small payload generation will not show the progress dialog.
message = "Payload Generated"
dialog = SimpleDialog(message)
dialog.exec_()
except Exception as e:
message = "An error occured:\n%s" % (e)
dialog = SimpleDialog(message)
dialog.exec_()
# Remove the file created on error so a blank payload is not listed in the payload list
os.remove(fullpath)
finally:
self.Progress.close()
def generate_payload(self):
""" Generate a payload file and place it in the payloads directory. Payloads will be one item per line. """
filename = self.dataBankTab.mainWindow.dbankGenPayloadName.text()
start = self.dataBankTab.mainWindow.dbankGenStart.text()
stop = self.dataBankTab.mainWindow.dbankGenStop.text()
step = self.dataBankTab.mainWindow.dbankGenStep.text()
prepend = self.dataBankTab.mainWindow.dbankGenPre.text()
postpend = self.dataBankTab.mainWindow.dbankGenPost.text()
if filename == "":
message = "You didn't specify a filename"
dialog = SimpleDialog(message)
dialog.exec_()
return()
if start == "":
message = "You didn't specify a start of the range"
dialog = SimpleDialog(message)
dialog.exec_()
return()
if stop == "":
message = "You didn't specify a end of the range"
dialog = SimpleDialog(message)
dialog.exec_()
return()
fullpath = self.payloads_dir + "/" + filename
if os.path.exists(fullpath):
message = "File already exists. Would you like to overwrite?"
response = ConfirmDialog.display_confirm_dialog(self, message)
if response == False:
return()
self.write_payload(fullpath, start, stop)