Inherits ui_window::Ui_MainWindow.
Public Member Functions | |
def | __init__ |
Constructor of Window. | |
def | initSettingVariables |
Initializes setting variables. | |
def | initShortcuts |
Initializes application shortcuts. | |
def | initWidgetActions |
Initializes widget actions. | |
def | initUndoActions |
Initializes undo actions. | |
def | initModifyProjectActions |
Associates proper widgets signals with (projectModify) function. | |
def | initMutators |
Initializes mutators. | |
def | recordingClearAll |
Clears all outputs of recording Programs. | |
def | fuzzingClearAll |
Clears all outputs of fuzzing Programs. | |
def | recordingPeachClear |
Clears output of recoding Peach program. | |
def | recordingServerClear |
Clears output of recoding Server program. | |
def | recordingClientClear |
Clears output of recoding Client program. | |
def | fuzzingPeachClear |
Clears output of fuzzing Peach program. | |
def | fuzzingClientClear |
Clears output of fuzzing Client program. | |
def | fuzzingServerClear |
Clears output of fuzzing Server program. | |
def | editUndoAction |
Performs undo action on active undo stack. | |
def | editRedoAction |
Performs redo action on active undo stack. | |
def | addUndoLineEdit |
Adds undoactions::UndoLineEdit action to active undo stack. | |
def | addUndoCheckBox |
Adds undoactions::UndoCheckBox action to active undo stack. | |
def | addUndoRadioButton |
Adds undoactions::UndoRadioButton action to active undo stack. | |
def | addUndoSpinBox |
Adds undoactions::UndoSpinBox action to active undo stack. | |
def | addUndoLineEdit |
Adds undoactions::UndoLineEdit action to active undo stack. | |
def | setUndoUpdate |
Enables/disables main menu Edit -> Undo menu item. | |
def | setRedoUpdate |
Enables/disables main menu Edit -> Redo menu item. | |
def | fuzzingSeedCheckChanged |
Enables/disables seed and seed iteration on fuzzing tab according to state param. | |
def | openDump |
Opens dump for selected item in dump tree widget in debugger. | |
def | deleteDump |
Deletes dump according to selected item in dump tree widget. | |
def | viewDumpCommands |
Opens actionview dialog for selected item in dump tree widget. | |
def | refreshDump |
Refreshes items of dump tree widget according to current dump directory. | |
def | projectModify |
Marks current project as modified. | |
def | recordingServerStartUpdate |
Enables/disables start Server button on recording tab according to state param. | |
def | recordingClientStartUpdate |
Enables/disables start Client button on recording tab according to state param. | |
def | fuzzingClientStartUpdate |
Enables/disables start Client button on fuzzing tab according to state param. | |
def | fuzzingServerStartUpdate |
Enables/disables start Server button on fuzzing tab according to state param. | |
def | switchTab |
Sets current undo stack according to tabIdx param. | |
def | hideMutators |
Hides Column with mutators on fuzzing edit tab. | |
def | showMutators |
Shows Column with mutators on fuzzing edit tab. | |
def | browseRecordingClientProgram |
Opens browse dialog for Client program on recording tab. | |
def | browseRecordingClientActivation |
Opens browse dialog for Client activation on recording tab. | |
def | browseRecordingClientSymbols |
Opens browse dialog for Client symbols on recording tab. | |
def | browseRecordingServerProgram |
Opens browse dialog for Server program on recording tab. | |
def | browseRecordingServerSymbols |
Opens browse dialog for Server symbols on recording tab. | |
def | recordingOpenXmlEditor |
Opens extern editor program for recording XML. | |
def | recordingXmlEditorCloseAction |
Handles extern editor exit action when editing recording XML. | |
def | fuzzingOpenXmlEditor |
Opens extern editor program for fuzzing XML. | |
def | fuzzingXmlEditorCloseAction |
Handles extern editor exit action when editing recording XML. | |
def | fuzzingClientStart |
Starts fuzzing Client program. | |
def | fuzzingServerStart |
Starts fuzzing Server program. | |
def | fuzzingPeachEnableStop |
Enables the fuzzing buttons when the Peach process is running. | |
def | fuzzingPeachStart |
Starts the fuzzing Peach program. | |
def | recordingClientStart |
Starts recording Client program. | |
def | recordingServerStart |
Starts recording Server program. | |
def | recordingPeachEnableStop |
Enables the recording buttons when the Peach process is running. | |
def | recordingPeachStart |
Starts recording Peach program. | |
def | fuzzingStartAll |
Tries to start all fuzzing programs. | |
def | recordingStartAll |
Tries to start all recording programs. | |
def | recordingClientStop |
Stops recording Client process. | |
def | recordingServerStop |
Stops recording Server process. | |
def | recordingPeachStop |
Stops recording Peach process. | |
def | recordingPeachProcessClean |
Performs necessary actions after recording peach process exits. | |
def | fuzzingClientStop |
Stops fuzzing Client process. | |
def | fuzzingServerStop |
Stops fuzzing Server process. | |
def | fuzzingPeachStop |
Stops fuzzing Peach process. | |
def | fuzzingPeachProcessClean |
Performs necessary actions after recording peach process exits. | |
def | fuzzingStopAll |
Tries to stop all fuzzing programs. | |
def | recordingStopAll |
Tries to stop all recording programs. | |
def | fuzzingPeachPause |
Pauses/Unpauses the Peach fuzzing process. | |
def | recordingPeachPause |
Pauses/Unpauses the Peach recording process. | |
def | recordingUnpauseAction |
Processes successful recording unpause action. | |
def | recordingPauseAction |
Processes successful recording pause action. | |
def | fuzzingUnpauseAction |
Processes successful fuzzing unpause action. | |
def | fuzzingPauseAction |
Processes successful fuzzing pause action. | |
def | updateStatusBar |
Updates text on status bar. | |
def | waitingStart |
Sets window component to enabled(False) state (they become gray) and changes cursor to wait cursor. | |
def | waitingEnd |
Sets window component to enabled(True) state and changes cursor to arrow cursor. | |
def | escapeKeyReaction |
Reaction to pressed escape key (used when waiting for start all). | |
def | readPortWaiterIteration |
Updates status bar when waiting in start all. | |
def | readPortWaiterExitFuzzing |
Processes return value from testport::portWaiterThread in fuzzing phase. | |
def | readPortWaiterExitRecording |
Processes return value from testport::portWaiterThread in recording phase. | |
def | recordingClientUpdateOutput |
Updates recording Client output. | |
def | recordingServerUpdateOutput |
Updates recording Server output. | |
def | recordingPeachUpdateOutput |
Updates recording Peach output. | |
def | fuzzingClientUpdateOutput |
Updates fuzzing Client output. | |
def | fuzzingServerUpdateOutput |
Updates fuzzing Server output. | |
def | fuzzingPeachUpdateOutput |
Updates fuzzing Peach output. | |
def | projectCreate |
Creates directory for new project and copies there selected fuzzing and recording templates. | |
def | projectLoadFiles |
Loads whole project into Main window. | |
def | projectRebase |
Creates new project structure and performs necessary actions to activate this structure. | |
def | projectCopyActive |
Copies project from one directory to another. | |
def | projectOpen |
Opens open project dialog and tries to open selected project. | |
def | projectOpenRecent |
Opens recent project dialog and tries to open selected recent project. | |
def | projectNew |
Opens new project dialog and tries to create and load new project. | |
def | projectSaveAs |
Opens save as dialog and tries to copy current project to selected directory and load it. | |
def | projectImportRecording |
Opens import recording XML dialog and tries to load selected XML. | |
def | projectImportFuzzing |
Opens import fuzzing XML dialog and tries to load selected XML. | |
def | projectExportRecording |
Opens export recording XML dialog and tries to store current recording XML to specified location. | |
def | projectExportFuzzing |
Opens export fuzzing XML dialog and tries to store current fuzzing XML to specified location. | |
def | projectSave |
Saves current project and unmodifies it. | |
def | preferencesOpen |
Opens preferences dialog. | |
def | aboutQtOpen |
Opens about QT dialog. | |
def | aboutOpen |
Opens about HotFuzz dialog. | |
def | projectInfoOpen |
Opens project info dialog. | |
def | introOpen |
Opens intro dialog. | |
def | getDebugInfo |
Returns well formated debug parameters for peach Program. | |
def | recordingUpdateProgressBar |
Function that updates recording progress bar. | |
def | fuzzingUpdateProgressBar |
Function that updates fuzzing progress bar. | |
def | setNoMutators |
Sets all mutators as unused. | |
def | setAllMutators |
Sets all mutators as used. | |
def | activateMutators |
Updates state of all mutators according to newly loaded xml. | |
def | setMutatorsRoot |
Sets new root XML element for all mutators. | |
def | changeMutable |
Changes state of given data model tree widget item. | |
def | setAllMutable |
Sets all tree widgets in data model tree as mutable. | |
def | setNoneMutable |
Sets all tree widgets in data model tree as non mutable. | |
def | resetFuzzingXML |
Restores whole fuzzing XML from previously recorded XML (or unmodified template XML if XML has not been recorded yet). | |
def | setModelFocus |
Action which set focus of data model according to selected item in state model. | |
def | querySaveProject |
Opens dialog which asks whether to store project. | |
def | closeEvent |
Reimplementation of Window closing dialog. | |
Public Attributes | |
fuzzingClientProcess | |
Fuzzing Client process. | |
fuzzingServerProcess | |
Fuzzing Server process. | |
fuzzingPeachProcess | |
Fuzzing Peach process. | |
recordingServerProcess | |
Recording Server process. | |
recordingClientProcess | |
Recording Client process. | |
recordingPeachProcess | |
Recording Peach process. | |
portThread | |
Thread which test whether some program listens to specified hosts and ports. | |
unpauseThread | |
Communicator unpause Thread. | |
pauseThread | |
Communicator pause Thread. | |
killThread | |
Communicator kill Thread. | |
progressThread | |
Communicator progress Thread. | |
recordingPeachOutputQFile | |
File where to optionally store output from recording Peach. | |
recordingServerOutputQFile | |
File where to optionally store output from recording Server. | |
recordingClientOutputQFile | |
File where to optionally store output from recording Client. | |
fuzzingPeachOutputQFile | |
File where to optionally store output from fuzzing Peach. | |
fuzzingClientOutputQFile | |
File where to optionally store output from fuzzing Client. | |
fuzzingServerOutputQFile | |
File where to optionally store output from fuzzing Server. | |
project | |
Current project. | |
fuzzingEditorXmlLoaded | |
Indicates whether loading fuzzing XML after manual editing was successful. | |
recordingEditorXmlLoaded | |
Indicates whether loading recording XML after manual editing was successful. | |
recordingManipulator | |
Recording XML manipulator. | |
fuzzingManipulator | |
Fuzzing XML manipulator. | |
pathToPeach | |
Path to peach.py. | |
pathToDebugger | |
Path to debugger. | |
pathToEditor | |
Path to editor. | |
startAllTimeout | |
Start All button timeout. | |
recentProjectCount | |
How many recent project should the application remember. | |
projectDir | |
Directory where projects are stored. | |
defaultAuthor | |
Default author. | |
peachCommunicatorPort | |
On which port does peach communicator listen. | |
fuzzingClientOutputEnabled | |
Indicator whether storing of fuzzing Client output to file is enabled. | |
fuzzingServerOutputEnabled | |
Indicator whether storing of fuzzing Server output to file is enabled. | |
fuzzingPeachOutputEnabled | |
Indicator whether storing of fuzzing Peach output to file is enabled. | |
recordingPeachOutputEnabled | |
Indicator whether storing of recording Peach output to file is enabled. | |
recordingServerOutputEnabled | |
Indicator whether storing of recording Server output to file is enabled. | |
recordingClientOutputEnabled | |
Indicator whether storing of recording Client output to file is enabled. | |
recentProjects | |
List of recent projects. | |
debug | |
Indicator whether debugging is enabled. | |
debugDissect | |
Indicator whether debugging dissection is enabled. | |
debugLevel | |
Debug level. | |
killPortThreadShortcut | |
Shortcut which stops Start All waiting. | |
copyRecordingClientShortCut | |
Shortcut for copying from recording Client Output into clipboard. | |
copyRecordingServerShortCut | |
Shortcut for copying from recording Server Output into clipboard. | |
copyRecordingPeachShortCut | |
Shortcut for copying from recording Peach Output into clipboard. | |
copyFuzzingClientShortCut | |
Shortcut for copying from fuzzing Client Output into clipboard. | |
copyFuzzingServerShortCut | |
Shortcut for copying from fuzzing Server Output into clipboard. | |
copyFuzzingPeachShortCut | |
Shortcut for copying from fuzzing Peach Output into clipboard. | |
mutableUndoStack | |
Undo stack of second tab. | |
fuzzingUndoStack | |
Undo stack of third tab. | |
recordingUndoStack | |
Undo stack of first tab. | |
undoGroup | |
Group of all undo stacks. | |
mutators | |
Dict of all available mutators. | |
recordingEditorProcess | |
Process structure of extern editor. | |
fuzzingEditorProcess | |
Process structure of extern editor. | |
crashCount | |
Count of crashes in current fuzzing session. | |
lastCrash | |
Iteration Number of the last crash. | |
dumpTree | |
Dump reader. |
Main Window class.
It is responsible for starting up other dialogs, it connect all its widget signals to appropriate action, stores and load application setting, starts and manages extern programs, disables/enables shows/hides widgets, ...
It also contains various class variables (e.g. with application settings, fuzzing crash indicators, etc.
Its logic consists of 4 parts : Menu part (Main Menu of the application), Recoding part (tab recording), Fuzzing part (tab fuzzing settings and fuzzing), Dump viewer part (tab viewer)
Menu part responsible for triggering the most of dialogs (e.g. loading project, saving project, modifying application preferences, ...).
Recording part is responsible for loading/storing/modifying content of recording XML. It also starts extern processes (Client, Server and Peach). These processes after given number of iterations should end and create plain fuzzing XML.
Fuzzing part modifies fuzzing XML (loaded when starting a new project or created by recording part) and is responsible for starting fuzzing processes (Client, Server and Peach). During the fuzzing some crashes may appear. These crashes lies within specific location in project dumps directory.
Dump viewer part is responsible for viewing content of dumps directory in the most human readable way.
Project itself is handled mostly by class project::HotFuzzProject, this class is responsible just for creating necessary directories and copying project's XMLs.
Interaction with Peach program (which is started in fuzzing and recoding part) is handled in separate threads in separate file (udpcommunicator), Main window just processes the signals from these threads and updates widgets according to these signals.
Status bar is often used for showing user quite important informations.
def window::Window::__init__ | ( | self, | ||
parent = None | ||||
) |
Constructor of Window.
It initializes all necessary variables(processes, threads, files structures) and widgets. Initializations that creates basic component layout and behaviour are done within parent class Ui_MainWindow. (Generated from window.ui files) Some initializations are done within this function. All other initializations are done in init* functions
self | The object pointer. | |
parent | Parent object. |
def window::Window::aboutOpen | ( | self | ) |
Opens about HotFuzz dialog.
self | The object pointer. |
def window::Window::aboutQtOpen | ( | self | ) |
Opens about QT dialog.
self | The object pointer. |
def window::Window::activateMutators | ( | self | ) |
Updates state of all mutators according to newly loaded xml.
self | The object pointer. |
def window::Window::addUndoCheckBox | ( | self, | ||
origValue, | ||||
widget | ||||
) |
Adds undoactions::UndoCheckBox action to active undo stack.
Note that this function is triggered whenever widget looses focus and its value was modified.
origValue | Original value. | |
widget | Widget which emitted the signal. | |
self | The object pointer. |
def window::Window::addUndoLineEdit | ( | self, | ||
origValue, | ||||
widget | ||||
) |
Adds undoactions::UndoLineEdit action to active undo stack.
Note that this function is triggered whenever widget looses focus and its value was modified.
origValue | Original value. | |
widget | Widget which emitted the signal. | |
self | The object pointer. |
def window::Window::addUndoLineEdit | ( | self, | ||
origValue, | ||||
widget | ||||
) |
Adds undoactions::UndoLineEdit action to active undo stack.
Note that this function is triggered whenever widget looses focus and its value was modified.
origValue | Original value. | |
widget | Widget which emitted the signal. | |
self | The object pointer. |
def window::Window::addUndoRadioButton | ( | self, | ||
widget | ||||
) |
Adds undoactions::UndoRadioButton action to active undo stack.
Note that this function is triggered whenever widget looses focus and its value was modified.
widget | Widget which emitted the signal. | |
self | The object pointer. |
def window::Window::addUndoSpinBox | ( | self, | ||
origValue, | ||||
widget | ||||
) |
Adds undoactions::UndoSpinBox action to active undo stack.
Note that this function is triggered whenever widget looses focus and its value was modified.
origValue | Original value. | |
widget | Widget which emitted the signal. | |
self | The object pointer. |
def window::Window::browseRecordingClientActivation | ( | self | ) |
Opens browse dialog for Client activation on recording tab.
self | The object pointer. |
def window::Window::browseRecordingClientProgram | ( | self | ) |
Opens browse dialog for Client program on recording tab.
self | The object pointer. |
def window::Window::browseRecordingClientSymbols | ( | self | ) |
Opens browse dialog for Client symbols on recording tab.
self | The object pointer. |
def window::Window::browseRecordingServerProgram | ( | self | ) |
Opens browse dialog for Server program on recording tab.
self | The object pointer. |
def window::Window::browseRecordingServerSymbols | ( | self | ) |
Opens browse dialog for Server symbols on recording tab.
self | The object pointer. |
def window::Window::changeMutable | ( | self, | ||
widget, | ||||
column | ||||
) |
Changes state of given data model tree widget item.
widget | Datamodel tree widget item. | |
column | Column of the data model tree widget item. (Unused parameter) | |
self | The object pointer. |
def window::Window::closeEvent | ( | self, | ||
event | ||||
) |
Reimplementation of Window closing dialog.
event | Closing event. | |
self | The object pointer. |
def window::Window::deleteDump | ( | self | ) |
Deletes dump according to selected item in dump tree widget.
self | The object pointer. |
def window::Window::editRedoAction | ( | self | ) |
Performs redo action on active undo stack.
self | The object pointer. |
def window::Window::editUndoAction | ( | self | ) |
Performs undo action on active undo stack.
self | The object pointer. |
def window::Window::escapeKeyReaction | ( | self | ) |
Reaction to pressed escape key (used when waiting for start all).
self | The object pointer. |
def window::Window::fuzzingClearAll | ( | self | ) |
Clears all outputs of fuzzing Programs.
self | The object pointer. |
def window::Window::fuzzingClientClear | ( | self | ) |
Clears output of fuzzing Client program.
self | The object pointer. |
def window::Window::fuzzingClientStart | ( | self | ) |
Starts fuzzing Client program.
self | The object pointer. |
def window::Window::fuzzingClientStartUpdate | ( | self, | ||
state | ||||
) |
Enables/disables start Client button on fuzzing tab according to state param.
state | New state. | |
self | The object pointer. |
def window::Window::fuzzingClientStop | ( | self | ) |
Stops fuzzing Client process.
self | The object pointer. |
def window::Window::fuzzingClientUpdateOutput | ( | self | ) |
Updates fuzzing Client output.
self | The object pointer. |
def window::Window::fuzzingOpenXmlEditor | ( | self | ) |
Opens extern editor program for fuzzing XML.
self | The object pointer. |
def window::Window::fuzzingPauseAction | ( | self, | ||
int | ||||
) |
Processes successful fuzzing pause action.
int | Thread return value. | |
self | The object pointer. |
def window::Window::fuzzingPeachClear | ( | self | ) |
Clears output of fuzzing Peach program.
self | The object pointer. |
def window::Window::fuzzingPeachEnableStop | ( | self | ) |
Enables the fuzzing buttons when the Peach process is running.
It is used few seconds after the Peach process start. At first the stop button are disabled and this function enables them. It avoids the premature stop operations.
self | The object pointer. |
def window::Window::fuzzingPeachPause | ( | self | ) |
Pauses/Unpauses the Peach fuzzing process.
self | The object pointer. |
def window::Window::fuzzingPeachProcessClean | ( | self | ) |
Performs necessary actions after recording peach process exits.
self | The object pointer. |
def window::Window::fuzzingPeachStart | ( | self | ) |
Starts the fuzzing Peach program.
Current state of Main Window is exported to temporary XML, which is used as parameter when starting peach.
self | The object pointer. |
def window::Window::fuzzingPeachStop | ( | self | ) |
Stops fuzzing Peach process.
self | The object pointer. |
def window::Window::fuzzingPeachUpdateOutput | ( | self | ) |
Updates fuzzing Peach output.
self | The object pointer. |
def window::Window::fuzzingSeedCheckChanged | ( | self, | ||
state | ||||
) |
Enables/disables seed and seed iteration on fuzzing tab according to state param.
state | New state of fuzzing seed checkbox. | |
self | The object pointer. |
def window::Window::fuzzingServerClear | ( | self | ) |
Clears output of fuzzing Server program.
self | The object pointer. |
def window::Window::fuzzingServerStart | ( | self | ) |
Starts fuzzing Server program.
self | The object pointer. |
def window::Window::fuzzingServerStartUpdate | ( | self, | ||
state | ||||
) |
Enables/disables start Server button on fuzzing tab according to state param.
state | New state. | |
self | The object pointer. |
def window::Window::fuzzingServerStop | ( | self | ) |
Stops fuzzing Server process.
self | The object pointer. |
def window::Window::fuzzingServerUpdateOutput | ( | self | ) |
Updates fuzzing Server output.
self | The object pointer. |
def window::Window::fuzzingStartAll | ( | self | ) |
Tries to start all fuzzing programs.
self | The object pointer. |
def window::Window::fuzzingStopAll | ( | self | ) |
Tries to stop all fuzzing programs.
self | The object pointer. |
def window::Window::fuzzingUnpauseAction | ( | self, | ||
int | ||||
) |
Processes successful fuzzing unpause action.
int | Thread return value. | |
self | The object pointer. |
def window::Window::fuzzingUpdateProgressBar | ( | self, | ||
value | ||||
) |
Function that updates fuzzing progress bar.
value | Iteration number. (Negative number means that program crashed during last iteration.) | |
self | The object pointer. |
def window::Window::fuzzingXmlEditorCloseAction | ( | self, | ||
retval | ||||
) |
Handles extern editor exit action when editing recording XML.
retval | Return value of extern editor program. | |
self | The object pointer. |
def window::Window::getDebugInfo | ( | self | ) |
Returns well formated debug parameters for peach Program.
self | The object pointer. |
def window::Window::hideMutators | ( | self | ) |
def window::Window::initModifyProjectActions | ( | self | ) |
Associates proper widgets signals with (projectModify) function.
self | The object pointer. |
def window::Window::initMutators | ( | self | ) |
def window::Window::initSettingVariables | ( | self | ) |
Initializes setting variables.
self | The object pointer. |
def window::Window::initShortcuts | ( | self | ) |
Initializes application shortcuts.
self | The object pointer. |
def window::Window::initUndoActions | ( | self | ) |
Initializes undo actions.
self | The object pointer. |
def window::Window::initWidgetActions | ( | self | ) |
Initializes widget actions.
(e.g. associate the openButton signal clicked() with the open function, ...)
self | The object pointer. |
def window::Window::introOpen | ( | self | ) |
def window::Window::openDump | ( | self | ) |
Opens dump for selected item in dump tree widget in debugger.
self | The object pointer. |
def window::Window::preferencesOpen | ( | self | ) |
def window::Window::projectCopyActive | ( | self, | ||
source, | ||||
target | ||||
) |
def window::Window::projectCreate | ( | self, | ||
projectPath, | ||||
recordingTemplatePath, | ||||
fuzzingTemplatePath | ||||
) |
Creates directory for new project and copies there selected fuzzing and recording templates.
projectPath | Path to new project. | |
recordingTemplatePath | Path to selected recording template. | |
fuzzingTemplatePath | Path to selected fuzzing template. | |
self | The object pointer. |
def window::Window::projectExportFuzzing | ( | self | ) |
Opens export fuzzing XML dialog and tries to store current fuzzing XML to specified location.
self | The object pointer. |
def window::Window::projectExportRecording | ( | self | ) |
Opens export recording XML dialog and tries to store current recording XML to specified location.
self | The object pointer. |
def window::Window::projectImportFuzzing | ( | self | ) |
Opens import fuzzing XML dialog and tries to load selected XML.
self | The object pointer. |
def window::Window::projectImportRecording | ( | self | ) |
Opens import recording XML dialog and tries to load selected XML.
self | The object pointer. |
def window::Window::projectInfoOpen | ( | self | ) |
def window::Window::projectLoadFiles | ( | self, | ||
projectPath | ||||
) |
def window::Window::projectModify | ( | self | ) |
def window::Window::projectNew | ( | self | ) |
def window::Window::projectOpen | ( | self | ) |
def window::Window::projectOpenRecent | ( | self | ) |
def window::Window::projectRebase | ( | self, | ||
projectPath | ||||
) |
def window::Window::projectSave | ( | self | ) |
def window::Window::projectSaveAs | ( | self | ) |
Opens save as dialog and tries to copy current project to selected directory and load it.
self | The object pointer. |
def window::Window::querySaveProject | ( | self | ) |
def window::Window::readPortWaiterExitFuzzing | ( | self, | ||
int | ||||
) |
Processes return value from testport::portWaiterThread in fuzzing phase.
int | Return value. | |
self | The object pointer. |
def window::Window::readPortWaiterExitRecording | ( | self, | ||
int | ||||
) |
Processes return value from testport::portWaiterThread in recording phase.
int | Return value. | |
self | The object pointer. |
def window::Window::readPortWaiterIteration | ( | self, | ||
int | ||||
) |
Updates status bar when waiting in start all.
int | Waiting iteration. | |
self | The object pointer. |
def window::Window::recordingClearAll | ( | self | ) |
Clears all outputs of recording Programs.
self | The object pointer. |
def window::Window::recordingClientClear | ( | self | ) |
Clears output of recoding Client program.
self | The object pointer. |
def window::Window::recordingClientStart | ( | self | ) |
Starts recording Client program.
self | The object pointer. |
def window::Window::recordingClientStartUpdate | ( | self, | ||
state | ||||
) |
Enables/disables start Client button on recording tab according to state param.
state | New state. | |
self | The object pointer. |
def window::Window::recordingClientStop | ( | self | ) |
Stops recording Client process.
self | The object pointer. |
def window::Window::recordingClientUpdateOutput | ( | self | ) |
Updates recording Client output.
self | The object pointer. |
def window::Window::recordingOpenXmlEditor | ( | self | ) |
Opens extern editor program for recording XML.
self | The object pointer. |
def window::Window::recordingPauseAction | ( | self, | ||
int | ||||
) |
Processes successful recording pause action.
int | Thread return value. | |
self | The object pointer. |
def window::Window::recordingPeachClear | ( | self | ) |
Clears output of recoding Peach program.
self | The object pointer. |
def window::Window::recordingPeachEnableStop | ( | self | ) |
Enables the recording buttons when the Peach process is running.
It is used few seconds after the Peach process start. At first the stop button are disabled and this function enables them. It avoids the premature stop operations.
self | The object pointer. |
def window::Window::recordingPeachPause | ( | self | ) |
Pauses/Unpauses the Peach recording process.
self | The object pointer. |
def window::Window::recordingPeachProcessClean | ( | self | ) |
Performs necessary actions after recording peach process exits.
self | The object pointer. |
def window::Window::recordingPeachStart | ( | self | ) |
Starts recording Peach program.
Current state of Main Window is exported to temporary XML, which is used as parameter when starting peach.
self | The object pointer. |
def window::Window::recordingPeachStop | ( | self | ) |
Stops recording Peach process.
self | The object pointer. |
def window::Window::recordingPeachUpdateOutput | ( | self | ) |
Updates recording Peach output.
self | The object pointer. |
def window::Window::recordingServerClear | ( | self | ) |
Clears output of recoding Server program.
self | The object pointer. |
def window::Window::recordingServerStart | ( | self | ) |
Starts recording Server program.
self | The object pointer. |
def window::Window::recordingServerStartUpdate | ( | self, | ||
state | ||||
) |
Enables/disables start Server button on recording tab according to state param.
state | New state. | |
self | The object pointer. |
def window::Window::recordingServerStop | ( | self | ) |
Stops recording Server process.
self | The object pointer. |
def window::Window::recordingServerUpdateOutput | ( | self | ) |
Updates recording Server output.
self | The object pointer. |
def window::Window::recordingStartAll | ( | self | ) |
Tries to start all recording programs.
self | The object pointer. |
def window::Window::recordingStopAll | ( | self | ) |
Tries to stop all recording programs.
self | The object pointer. |
def window::Window::recordingUnpauseAction | ( | self, | ||
int | ||||
) |
Processes successful recording unpause action.
int | Thread return value. | |
self | The object pointer. |
def window::Window::recordingUpdateProgressBar | ( | self, | ||
value | ||||
) |
Function that updates recording progress bar.
value | Iteration number. | |
self | The object pointer. |
def window::Window::recordingXmlEditorCloseAction | ( | self, | ||
retval | ||||
) |
Handles extern editor exit action when editing recording XML.
retval | Return value of extern editor program. | |
self | The object pointer. |
def window::Window::refreshDump | ( | self | ) |
Refreshes items of dump tree widget according to current dump directory.
self | The object pointer. |
def window::Window::resetFuzzingXML | ( | self | ) |
Restores whole fuzzing XML from previously recorded XML (or unmodified template XML if XML has not been recorded yet).
self | The object pointer. |
def window::Window::setAllMutable | ( | self | ) |
Sets all tree widgets in data model tree as mutable.
self | The object pointer. |
def window::Window::setAllMutators | ( | self | ) |
def window::Window::setModelFocus | ( | self, | ||
widget, | ||||
column | ||||
) |
Action which set focus of data model according to selected item in state model.
widget | Selected item in state model tree widget. | |
column | Column of the state model tree widget item. (Unused parameter) | |
self | The object pointer. |
def window::Window::setMutatorsRoot | ( | self, | ||
root | ||||
) |
Sets new root XML element for all mutators.
root | New root element. | |
self | The object pointer. |
def window::Window::setNoMutators | ( | self | ) |
def window::Window::setNoneMutable | ( | self | ) |
Sets all tree widgets in data model tree as non mutable.
self | The object pointer. |
def window::Window::setRedoUpdate | ( | self, | ||
bool | ||||
) |
Enables/disables main menu Edit -> Redo menu item.
bool | If True, enable item, if False disable item. | |
self | The object pointer. |
def window::Window::setUndoUpdate | ( | self, | ||
bool | ||||
) |
Enables/disables main menu Edit -> Undo menu item.
bool | If True, enable item, if False disable item. | |
self | The object pointer. | |
self | The object pointer. |
def window::Window::showMutators | ( | self | ) |
def window::Window::switchTab | ( | self, | ||
tabIdx | ||||
) |
Sets current undo stack according to tabIdx param.
tabIdx | index of current tab. | |
self | The object pointer. |
def window::Window::updateStatusBar | ( | self, | ||
message | ||||
) |
Updates text on status bar.
message | Text to be shown. | |
self | The object pointer. |
def window::Window::viewDumpCommands | ( | self | ) |
def window::Window::waitingEnd | ( | self | ) |
Sets window component to enabled(True) state and changes cursor to arrow cursor.
self | The object pointer. |
def window::Window::waitingStart | ( | self | ) |
Sets window component to enabled(False) state (they become gray) and changes cursor to wait cursor.
self | The object pointer. |
Shortcut for copying from fuzzing Client Output into clipboard.
Shortcut for copying from fuzzing Peach Output into clipboard.
Shortcut for copying from fuzzing Server Output into clipboard.
Shortcut for copying from recording Client Output into clipboard.
Shortcut for copying from recording Peach Output into clipboard.
Shortcut for copying from recording Server Output into clipboard.
Count of crashes in current fuzzing session.
Indicator whether debugging is enabled.
Indicator whether debugging dissection is enabled.
Debug level.
Default author.
Dump reader.
Indicator whether storing of fuzzing Client output to file is enabled.
File where to optionally store output from fuzzing Client.
Fuzzing Client process.
Process structure of extern editor.
Indicates whether loading fuzzing XML after manual editing was successful.
Fuzzing XML manipulator.
Indicator whether storing of fuzzing Peach output to file is enabled.
File where to optionally store output from fuzzing Peach.
Fuzzing Peach process.
Indicator whether storing of fuzzing Server output to file is enabled.
File where to optionally store output from fuzzing Server.
Fuzzing Server process.
Undo stack of third tab.
Shortcut which stops Start All waiting.
Communicator kill Thread.
(sends kill signal to peach)
Iteration Number of the last crash.
Undo stack of second tab.
Dict of all available mutators.
Path to debugger.
(windbg)
Path to editor.
(e.g. notepad.exe)
Path to peach.py.
(HotFuzz peach file)
Communicator pause Thread.
(sends pause signal to peach)
On which port does peach communicator listen.
Thread which test whether some program listens to specified hosts and ports.
Communicator progress Thread.
(updates progressbar)
Directory where projects are stored.
How many recent project should the application remember.
List of recent projects.
Indicator whether storing of recording Client output to file is enabled.
File where to optionally store output from recording Client.
Recording Client process.
Process structure of extern editor.
Indicates whether loading recording XML after manual editing was successful.
Recording XML manipulator.
Indicator whether storing of recording Peach output to file is enabled.
File where to optionally store output from recording Peach.
Recording Peach process.
Indicator whether storing of recording Server output to file is enabled.
File where to optionally store output from recording Server.
Recording Server process.
Undo stack of first tab.
Start All button timeout.
Group of all undo stacks.
Communicator unpause Thread.
(sends unpause signal to peach)