def createDefault():
logging.info("Create a default configuration file")
defaultConfig = ConfigParser.RawConfigParser()
defaultConfig.add_section('clustering')
defaultConfig.add_section('projects')
defaultConfig.add_section('automata')
defaultConfig.add_section('logging')
defaultConfig.add_section('import')
defaultConfig.set('clustering', 'equivalence_threshold', '60')
defaultConfig.set('clustering', 'orphan_reduction', '0')
defaultConfig.set('clustering', 'nbiteration', '100')
defaultConfig.set('clustering', 'do_internal_slick', '0')
defaultConfig.set('clustering', 'protocol_type', '1')
defaultTraceDirectory = os.path.join(ResourcesConfiguration.getWorkspaceFile(), "projects")
defaultConfig.set('projects', 'path', defaultTraceDirectory)
defaultAutomatonDirectory = os.path.join(ResourcesConfiguration.getWorkspaceFile(), "automaton")
defaultConfig.set('automata', 'path', defaultAutomatonDirectory)
defaultConfig.set('logging', 'path', '')
#defaultConfig.set('import', 'repository_prototypes', 'resources/prototypes/repository.xml')
defaultConfig.set('import', 'repository_prototypes', '')
return defaultConfig
def createWorkspace(name, path):
tracesPath = "traces"
projectsPath = "projects"
prototypesPath = "prototypes"
loggingPath = "logging"
pathOfLogging = "logging/logging.conf"
# we create a "traces" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, tracesPath)):
os.mkdir(os.path.join(path, tracesPath))
# we create a "projects" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, projectsPath)):
os.mkdir(os.path.join(path, projectsPath))
# we create the "prototypes" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, prototypesPath)):
os.mkdir(os.path.join(path, prototypesPath))
# we upload in it the default repository file
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
staticRepositoryPath = os.path.join(os.path.join(ResourcesConfiguration.getStaticResources(), "defaults"), "repository.xml.default")
shutil.copy(staticRepositoryPath, os.path.join(os.path.join(path, prototypesPath), "repository.xml"))
# we create the "logging" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, loggingPath)):
os.mkdir(os.path.join(path, loggingPath))
# we upload in it the default repository file
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
staticLoggingPath = os.path.join(os.path.join(ResourcesConfiguration.getStaticResources(), "defaults"), "logging.conf.default")
shutil.copy(staticLoggingPath, os.path.join(os.path.join(path, loggingPath), "logging.conf"))
workspace = Workspace(name, datetime.datetime.now(), path, tracesPath, pathOfLogging, prototypesPath)
workspace.saveConfigFile()
return workspace
def applyButton_clicked_cb(self, widget):
"""Callback executed when the user clicks on the apply button"""
workspacePath = self.getSelectedWorkspace()
# We verify the workspace can be loaded.
# if it can, we stop the current GTK
if workspacePath is None or len(workspacePath) == 0:
self.setError(_("No workspace provided."))
else:
logging.debug("Create the requested workspace")
try:
ResourcesConfiguration.createWorkspace(workspacePath)
except OSError as e:
self.log.warning(
"Impossible to create a workspace : {0}".format(e))
self.setError("Impossible to create a workspace here.")
return
(workspace,
error) = (Workspace.loadWorkspace(self._selectedWorkspace))
if workspace is not None:
# If we managed to load the given workspace, we save it and stop the GTK
ResourcesConfiguration.generateUserFile(
self._selectedWorkspace)
self.loadedWorkspace = workspace
self.stop()
else:
self.setError(error)
def applyButton_clicked_cb(self, widget):
"""Callback executed when the user clicks on the apply button"""
workspacePath = self.getSelectedWorkspace()
# We verify the workspace can be loaded.
# if it can, we stop the current GTK
if workspacePath is None or len(workspacePath) == 0:
self.setError(_("No workspace provided."))
else:
logging.debug("Create the requested workspace")
try:
ResourcesConfiguration.createWorkspace(workspacePath)
except OSError as e:
self.log.warning("Impossible to create a workspace : {0}".format(e))
self.setError("Impossible to create a workspace here.")
return
(workspace, error) = (Workspace.loadWorkspace(self._selectedWorkspace))
if workspace is not None:
# If we managed to load the given workspace, we save it and stop the GTK
ResourcesConfiguration.generateUserFile(self._selectedWorkspace)
self.loadedWorkspace = workspace
self.stop()
else:
self.setError(error)
def __init__(self):
self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
self.window.set_title(_("Netzob"))
self.window.set_position(Gtk.WindowPosition.CENTER)
self.window.set_decorated(False)
self.window.set_default_size(268, 501)
self.window.set_events(Gdk.EventMask.ALL_EVENTS_MASK)
# Retrieve static resources
staticPath = ResourcesConfiguration.getStaticResources()
logoPath = os.path.abspath(os.path.join(staticPath, "logo.png"))
hbox = Gtk.HBox()
hbox.show()
self.window.add(hbox)
self.image = Gtk.Image()
self.image.set_from_file(logoPath)
self.image.show()
main_vbox = Gtk.VBox(False, 1)
# main_vbox.pack_start(self.image, True, True)
workspace = ResourcesConfiguration.getWorkspace()
if workspace is not None:
self.lbl = Gtk.Label(label=_("Current workspace: {0}".format(workspace)))
else:
self.lbl = Gtk.Label(label=_("Current workspace: NO WORKSPACE COMPUTED!"))
self.lbl.set_alignment(0, 0.5)
main_vbox.pack_start(self.image, True, True, 2)
self.window.add(main_vbox)
self.window.show_all()
def advancedBugreportingEntry_focus_out_event_cb(self, entry, data):
"""Called on "focus-out" of the API key entry. If its value
was changed, we can save the new value."""
if self.keyUpdated:
apiKey = entry.get_text()
self.log.info("Saving the new API key: {0}".format(apiKey))
ResourcesConfiguration.saveAPIKey(apiKey)
self.keyUpdated = False
def __init__(self, controller, parent=None):
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui",
"workspaceConfigurationDialog.glade"))
self._getObjects(self.builder,
["workspaceConfigurationDialog",
"advancedLoggingCombobox",
"advancedBugreportingEntry",
"advancedBugreportingCheckbox",
"advancedBugreportingTestkey",
"advancedBugreportingTestkeySpinner",
"projectsTreestore1",
"projectCurrentName",
"projectCurrentDate",
"projectCurrentSymbolsCount",
"projectCurrentMessagesCount",
"projectsDuplicateButton",
"projectsDeleteButton",
"projectsExportButton",
"projectsTreeviewSelection",
"projectsConfigureButton",
"workspaceConfigurationActionGroup",
])
self.controller = controller
self.workspaceConfigurationDialog.set_transient_for(parent)
# Set combobox to the configured log level
model = self.advancedLoggingCombobox.get_model()
treeIter = model.get_iter_first()
while treeIter is not None:
if model[treeIter][0] == self.controller._loggingConfiguration.getLoggingLevel():
self.advancedLoggingCombobox.set_active_iter(treeIter)
break
treeIter = model.iter_next(treeIter)
# Update API key
key = ResourcesConfiguration.extractAPIKeyDefinitionFromLocalFile()
self.advancedBugreportingEntry.set_text(key or "")
# Set the 'enable bug reporting' toggle
enableBugReporting = controller.workspace.enableBugReporting
self.advancedBugreportingCheckbox.set_active(enableBugReporting)
self.refreshEnableBugReporting(enableBugReporting)
# Updating the "Defined projects" list
self.refreshProjectList()
# Getting the popup menu
self.uiManager = Gtk.UIManager()
self.uiManager.insert_action_group(self.workspaceConfigurationActionGroup)
self.uiManager.add_ui_from_file(os.path.join(ResourcesConfiguration.getStaticResources(), "ui", "workspaceConfigurationPopupMenu.ui"))
self.popup = self.uiManager.get_widget("/PopupMenu")
# Finally, connect signals to the controller
self.builder.connect_signals(self.controller)
def _findUiResource(self, resource):
r = os.path.join(ResourcesConfiguration.getStaticResources(), "ui", resource)
if os.path.isfile(r):
return r
r = os.path.join(ResourcesConfiguration.getPluginsStaticResources(), "ui", resource)
if os.path.isfile(r):
return r
raise NetzobAbstractViewException(_("Requested file ({0}) was not found.").format(resource))
def currentWorkspaceHasChanged(self):
"""currentWorkspaceHasChanged:
Execute the operations which must be done when
the current workspace has changed :
- Update the view,
- Save the new workspace."""
if self.controller.getCurrentWorkspace() is not None:
ResourcesConfiguration.generateUserFile(self.controller.getCurrentWorkspace().getPath(), ResourcesConfiguration.extractAPIKeyDefinitionFromLocalFile())
self.currentProjectHasChanged()
self.updateSwitchProjectMenu(self.controller.getCurrentWorkspace().getNameOfProjects())
def _findUiResource(self, resource):
r = os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
resource)
if os.path.isfile(r):
return r
r = os.path.join(ResourcesConfiguration.getPluginsStaticResources(),
"ui", resource)
if os.path.isfile(r):
return r
raise NetzobAbstractViewException(
_("Requested file ({0}) was not found.").format(resource))
def currentWorkspaceHasChanged(self):
"""currentWorkspaceHasChanged:
Execute the operations which must be done when
the current workspace has changed :
- Update the view,
- Save the new workspace."""
if self.controller.getCurrentWorkspace() is not None:
ResourcesConfiguration.generateUserFile(
self.controller.getCurrentWorkspace().getPath(),
ResourcesConfiguration.extractAPIKeyDefinitionFromLocalFile())
self.currentProjectHasChanged()
self.updateSwitchProjectMenu(
self.controller.getCurrentWorkspace().getNameOfProjects())
def _loadActionGroupUIDefinition(self):
"""Loads the action group and the UI definition of menu items
. This method should only be called in the constructor"""
# Load actions
actionsBuilder = Gtk.Builder()
actionsBuilder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"grammar", "grammarActions.glade"))
self._actionGroup = actionsBuilder.get_object("grammarActionGroup")
actionsBuilder.connect_signals(self.controller)
uiDefinitionFilePath = os.path.join(
ResourcesConfiguration.getStaticResources(), "ui", "grammar",
"grammarMenuToolbar.ui")
with open(uiDefinitionFilePath, "r") as uiDefinitionFile:
self._uiDefinition = uiDefinitionFile.read()
def loadWorkspace(workspacePath):
workspaceFile = os.path.join(workspacePath, Workspace.CONFIGURATION_FILENAME)
# verify we can open and read the file
if workspaceFile == None:
logging.warn("The workspace's configuration file can't be find (No workspace path given).")
return None
# is the workspaceFile is a file
if not os.path.isfile(workspaceFile):
logging.warn("The specified workspace's configuration file (" + str(workspaceFile) + ") is not valid : its not a file.")
return None
# is it readable
if not os.access(workspaceFile, os.R_OK):
logging.warn("The specified workspace's configuration file (" + str(workspaceFile) + ") is not readable.")
return None
# We validate the file given the schemas
for xmlSchemaFile in Workspace.WORKSPACE_SCHEMAS.keys():
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Workspace.isSchemaValidateXML(xmlSchemaPath, workspaceFile):
logging.debug("The file " + str(xmlSchemaPath) + " validates the workspace configuration file.")
parsingFunc = Workspace.WORKSPACE_SCHEMAS[xmlSchemaFile]
workspace = parsingFunc(workspacePath, workspaceFile)
if workspace != None:
return workspace
else:
logging.fatal("The specified Workspace file is not valid according to the XSD found in %s." % (xmlSchemaPath))
return None
def __init__(self, controller, idActor):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "simulator",
"createNetworkActor.glade"))
self._getObjects(self.builder, ["createNetworkActorDialog",
"createButton",
"idEntry",
"nameEntry",
"initiatorCheckButton",
"typeComboBoxText",
"l4ProtocolComboBoxText",
"bindIPEntry",
"bindPortEntry",
"targetIPEntry",
"targetPortEntry",
"errorImage", "errorLabel"])
self.controller = controller
self.builder.connect_signals(self.controller)
self.idEntry.set_text(str(idActor))
self.idEntry.set_sensitive(False)
def retrieveMessagesFromFiles(self):
# We read each file and create one message for each file
self.messages = []
self.lineView.get_model().clear()
for file in self.filesToBeImported:
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), "xsds/0.1/common.xsd")
# If we find a version which validates the XML, we parse with the associated function
if not Workspace.isSchemaValidateXML(xmlSchemaPath, file):
logging.error(_("The specified XML file {0} is not valid according to the XSD ({1}).").format(str(file), str(xmlSchemaPath)))
else:
logging.debug(_("XML file valid according to the XSD schema"))
# Parse the XML Document as 0.1 version
tree = ElementTree()
tree.parse(file)
xmlFile = tree.getroot()
for xmlMessage in xmlFile.findall("{" + Project.COMMON_NAMESPACE + "}message"):
message = AbstractMessageFactory.loadFromXML(xmlMessage, Project.COMMON_NAMESPACE, "0.1")
logging.debug(_("XML String data: {0}").format(message.getStringData()))
self.messages.append(message)
self.lineView.get_model().append(None, [str(message.getID()), message.getType(), message.getStringData()])
def __init__(self, controller):
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui",
"vocabulary",
"customTransformationFunctionDialog.glade",
)
)
self._getObjects(
self.builder,
[
"customTransformationFunctionDialog",
"imageError",
"imageValid",
"cancelButton",
"applyButton",
"nameOfFunctionEntry",
"labelMessage",
"functionReverseTextView",
"sourceCodeIsTheSameForReverseCheckButton",
"functionTextView",
"messagesListStore",
"scrolledwindow3",
],
)
self.controller = controller
self.builder.connect_signals(self.controller)
def renameLayer_cb(self, widget):
builder2 = Gtk.Builder()
builder2.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"dialogbox.glade"))
dialog = builder2.get_object("renamelayer")
dialog.set_title(
_("Rename the layer {0}").format(self.layers[0].getName()))
applybutton = builder2.get_object("button10")
entry = builder2.get_object("entry3")
entry.connect("changed", self.entry_disableButtonIfEmpty_cb,
applybutton)
result = dialog.run()
if (result == 0):
newLayerName = entry.get_text()
self.log.debug("Renamed layer {0} to {1}".format(
self.layers[0].getName(), newLayerName))
currentProject = self.vocabularyController.netzob.getCurrentProject(
)
currentProject.getVocabulary().getFieldByID(
self.layers[0].getID()).setName(newLayerName)
self.vocabularyController.view.updateLeftPanel()
self.vocabularyController.view.updateSelectedMessageTable()
dialog.destroy()
dialog.destroy()
def loadProject(workspace, projectDirectory):
projectFile = os.path.join(os.path.join(workspace.getPath(), projectDirectory), Project.CONFIGURATION_FILENAME)
# verify we can open and read the file
if projectFile == None:
return None
# is the projectFile is a file
if not os.path.isfile(projectFile):
logging.warn("The specified project's configuration file (" + str(projectFile) + ") is not valid : its not a file.")
return None
# is it readable
if not os.access(projectFile, os.R_OK):
logging.warn("The specified project's configuration file (" + str(projectFile) + ") is not readable.")
return None
# We validate the file given the schemas
for xmlSchemaFile in Project.PROJECT_SCHEMAS.keys():
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Project.isSchemaValidateXML(xmlSchemaPath, projectFile):
logging.debug("The file " + str(projectFile) + " validates the project configuration file.")
parsingFunc = Project.PROJECT_SCHEMAS[xmlSchemaFile]
project = parsingFunc(projectFile)
if project != None:
logging.info("Loading project '" + str(project.getName()) + "' from workspace.")
return project
else:
logging.warn("The project declared in file (" + projectFile + ") is not valid")
return None
def getNameOfProject(workspace, projectDirectory):
projectFile = os.path.join(os.path.join(workspace.getPath(), projectDirectory), Project.CONFIGURATION_FILENAME)
# verify we can open and read the file
if projectFile == None:
return None
# is the projectFile is a file
if not os.path.isfile(projectFile):
logging.warn("The specified project's configuration file (" + str(projectFile) + ") is not valid : its not a file.")
return None
# is it readable
if not os.access(projectFile, os.R_OK):
logging.warn("The specified project's configuration file (" + str(projectFile) + ") is not readable.")
return None
# We validate the file given the schemas
for xmlSchemaFile in Project.PROJECT_SCHEMAS.keys():
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Project.isSchemaValidateXML(xmlSchemaPath, projectFile):
logging.debug("The file " + str(projectFile) + " validates the project configuration file.")
tree = ElementTree()
tree.parse(projectFile)
xmlProject = tree.getroot()
# Register the namespace
etree.register_namespace('netzob', PROJECT_NAMESPACE)
etree.register_namespace('netzob-common', COMMON_NAMESPACE)
projectName = xmlProject.get('name', 'none')
if projectName != None and projectName != 'none':
return projectName
else:
logging.warn("The project declared in file (" + projectFile + ") is not valid")
return None
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary",
"environmentDependenciesSearcherView.glade"))
self._getObjects(self.builder, ["envDepsSearcherDialog",
"cancelButton",
"executeButton",
"searchProgressBar",
"envDependenciesListstore"
])
self.controller = controller
self.builder.connect_signals(self.controller)
self.cancelButton.set_sensitive(True)
# Update the list store of env. dependencies
currentProject = self.controller.vocabularyController.getCurrentProject()
envDeps = []
if currentProject is not None:
envDeps.extend(currentProject.getEnvironmentDependencies())
# Search in the same time all the applicative data in the project
appData = currentProject.getApplicativeData()
for data in appData:
envDeps.append(Property(data.getName(), data.getType(), data.getValue()))
for envDep in envDeps:
i = self.envDependenciesListstore.append()
self.envDependenciesListstore.set(i, 0, str(envDep.getCurrentValue()))
self.envDependenciesListstore.set(i, 1, str(envDep.getName()))
self.envDependenciesListstore.set(i, 2, str(envDep.getFormat()))
def __init__(self, controller, idTransition):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "grammar",
"createCloseChannelTransition.glade"))
self._getObjects(self.builder, ["createCloseChannelTransitionDialog",
"createButton", "cancelButton",
"idEntry", "nameEntry", "timeEntry",
"startStateComboBox", "endStateComboBox",
"stateListStore",
"errorImage", "errorLabel"])
self.controller = controller
self.builder.connect_signals(self.controller)
self.idEntry.set_text(str(idTransition))
self.idEntry.set_sensitive(False)
currentProject = self.controller.grammarController.getCurrentProject()
# Retrieve the states and symbols of the current project
states = []
if currentProject is not None:
automata = currentProject.getGrammar().getAutomata()
if automata is not None:
states.extend(automata.getStates())
self.stateListStore.clear()
# Configure the list of states
for state in states:
i = self.stateListStore.append()
self.stateListStore.set(i, 0, str(state.getID()))
self.stateListStore.set(i, 1, state.getName())
def __init__(self, controller):
"""
Constructor
"""
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui",
"vocabulary",
"partitioning",
"forcePartitioning.glade",
)
)
self._getObjects(
self.builder,
[
"forceDialog",
"force_execute",
"force_stop",
"force_cancel",
"force_entry",
"force_radiobutton_hexa",
"force_radiobutton_string",
"force_progressbar",
],
)
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller, gladeFileName):
self.controller = controller
self.builderWidget = Gtk.Builder()
gladePath = os.path.join(ResourcesConfiguration.getStaticResources(), "ui", "Variables", gladeFileName)
self.builderWidget.add_from_file(gladePath)
self.widgDict = dict()
def renameLayer_cb(self, widget):
builder2 = Gtk.Builder()
builder2.add_from_file(os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui",
"dialogbox.glade"))
dialog = builder2.get_object("renamelayer")
dialog.set_title(_("Rename the layer {0}").format(self.layers[0].getName()))
applybutton = builder2.get_object("button10")
entry = builder2.get_object("entry3")
entry.connect("changed", self.entry_disableButtonIfEmpty_cb, applybutton)
result = dialog.run()
if (result == 0):
newLayerName = entry.get_text()
self.log.debug("Renamed layer {0} to {1}".format(self.layers[0].getName(), newLayerName))
currentProject = self.vocabularyController.netzob.getCurrentProject()
currentProject.getVocabulary().getFieldByID(self.layers[0].getID()).setName(newLayerName)
self.vocabularyController.view.updateLeftPanel()
self.vocabularyController.view.updateSelectedMessageTable()
dialog.destroy()
dialog.destroy()
def loadProjectFromFile(projectFile):
# verify we can open and read the file
if projectFile is None:
return None
# is the projectFile is a file
if not os.path.isfile(projectFile):
logging.warn(
"The specified project's configuration file ({0}) is not valid: its not a file.".format(projectFile)
)
return None
# is it readable
if not os.access(projectFile, os.R_OK):
logging.warn("The specified project's configuration file ({0}) is not readable.".format(projectFile))
return None
# We validate the file given the schemas
for xmlSchemaFile in Project.PROJECT_SCHEMAS.keys():
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Project.isSchemaValidateXML(xmlSchemaPath, projectFile):
parsingFunc = Project.PROJECT_SCHEMAS[xmlSchemaFile]
project = parsingFunc(projectFile)
if project is not None:
logging.info("Loading project '{0}' from workspace.".format(project.getName()))
return project
else:
logging.warn("The project declared in file ({0}) is not valid".format(projectFile))
return None
def createSymbolButton_clicked_cb(self, toolButton):
if self.getCurrentProject() is None:
NetzobErrorMessage(_("No project selected."))
return
builder2 = Gtk.Builder()
builder2.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"dialogbox.glade"))
dialog = builder2.get_object("createsymbol")
dialog.set_transient_for(self.netzob.view.mainWindow)
# Disable apply button if no text
applybutton = builder2.get_object("button1")
entry = builder2.get_object("entry1")
entry.connect("changed", self.entry_disableButtonIfEmpty_cb,
applybutton)
result = dialog.run()
if (result == 0):
newSymbolName = entry.get_text()
newSymbolId = str(uuid.uuid4())
self.log.debug(
"A new symbol will be created with the given name: {0}".format(
newSymbolName))
currentProject = self.netzob.getCurrentProject()
newSymbol = Symbol(newSymbolId, newSymbolName, currentProject)
currentProject.getVocabulary().addSymbol(newSymbol)
self.view.updateLeftPanel()
dialog.destroy()
if (result == 1):
dialog.destroy()
def createSymbolButton_clicked_cb(self, toolButton):
if self.getCurrentProject() is None:
NetzobErrorMessage(_("No project selected."))
return
builder2 = Gtk.Builder()
builder2.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(), "ui", "dialogbox.glade"))
dialog = builder2.get_object("createsymbol")
dialog.set_transient_for(self.netzob.view.mainWindow)
# Disable apply button if no text
applybutton = builder2.get_object("button1")
entry = builder2.get_object("entry1")
entry.connect("changed", self.entry_disableButtonIfEmpty_cb, applybutton)
result = dialog.run()
if (result == 0):
newSymbolName = entry.get_text()
newSymbolId = str(uuid.uuid4())
self.log.debug("A new symbol will be created with the given name: {0}".format(newSymbolName))
currentProject = self.netzob.getCurrentProject()
newSymbol = Symbol(newSymbolId, newSymbolName, currentProject)
currentProject.getVocabulary().addSymbol(newSymbol)
self.view.updateLeftPanel()
dialog.destroy()
if (result == 1):
dialog.destroy()
def __init__(self, controller, state):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"grammar", "createStateDialog.glade"))
self._getObjects(self.builder, [
"createStateDialog", "createButton", "cancelButton", "idEntry",
"nameEntry", "initialStateCheckButton", "errorImage", "errorLabel",
"titleLabel"
])
self.controller = controller
self.builder.connect_signals(self.controller)
self.titleLabel.set_label(_("Edit the state"))
isInitialState = False
automata = controller.grammarController.getCurrentProject().getGrammar(
).getAutomata()
initialState = automata.getInitialState()
if str(initialState.getID()) == str(state.getID()):
isInitialState = True
self.idEntry.set_text(str(state.getID()))
self.idEntry.set_sensitive(False)
self.nameEntry.set_text(state.getName())
self.initialStateCheckButton.set_active(isInitialState)
def isFolderAValidWorkspace(workspacePath):
"""Computes if the provided folder
represents a valid (and loadable) workspace
@return: None if the workspace is loadable or the error message if not valid
"""
if workspacePath is None:
return _("The workspace's path ({0}) is incorrect.".format(workspacePath))
workspaceFile = os.path.join(workspacePath, Workspace.CONFIGURATION_FILENAME)
# verify we can open and read the file
if workspaceFile is None:
return _("The workspace's configuration file can't be find (No workspace path given).")
# is the workspaceFile is a file
if not os.path.isfile(workspaceFile):
return _("The specified workspace's configuration file ({0}) is not valid: its not a file.".format(workspaceFile))
# is it readable
if not os.access(workspaceFile, os.R_OK):
return _("The specified workspace's configuration file ({0}) is not readable.".format(workspaceFile))
for xmlSchemaFile in Workspace.WORKSPACE_SCHEMAS.keys():
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Workspace.isSchemaValidateXML(xmlSchemaPath, workspaceFile):
return None
return _("The specified workspace is not valid according to the XSD definitions.")
def loadProjectFromFile(projectFile):
# verify we can open and read the file
if projectFile is None:
return None
# is the projectFile is a file
if not os.path.isfile(projectFile):
logging.warn(
"The specified project's configuration file ({0}) is not valid: its not a file."
.format(projectFile))
return None
# is it readable
if not os.access(projectFile, os.R_OK):
logging.warn(
"The specified project's configuration file ({0}) is not readable."
.format(projectFile))
return None
# We validate the file given the schemas
for xmlSchemaFile in Project.PROJECT_SCHEMAS.keys():
xmlSchemaPath = os.path.join(
ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Project.isSchemaValidateXML(xmlSchemaPath, projectFile):
parsingFunc = Project.PROJECT_SCHEMAS[xmlSchemaFile]
project = parsingFunc(projectFile)
if project is not None:
logging.info(
"Loading project '{0}' from workspace.".format(
project.getName()))
return project
else:
logging.warn(
"The project declared in file ({0}) is not valid".format(
projectFile))
return None
def loadWorkspace(workspacePath):
"""Load the workspace declared in the
provided directory
@type workspacePath: str
@var workspacePath: folder to load as a workspace
@return a tupple with the workspace or None if not valid and the error message"""
errorMessage = Workspace.isFolderAValidWorkspace(workspacePath)
if errorMessage is not None:
logging.warn(errorMessage)
return (None, errorMessage)
workspaceFile = os.path.join(workspacePath, Workspace.CONFIGURATION_FILENAME)
logging.debug(" Workspace configuration file found: " + str(workspaceFile))
# We validate the file given the schemas
for xmlSchemaFile in Workspace.WORKSPACE_SCHEMAS.keys():
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
xmlSchemaPath = os.path.join(ResourcesConfiguration.getStaticResources(), xmlSchemaFile)
# If we find a version which validates the XML, we parse with the associated function
if Workspace.isSchemaValidateXML(xmlSchemaPath, workspaceFile):
logging.debug(" Workspace configuration file " + str(workspaceFile) + " is valid against XSD scheme " + str(xmlSchemaPath))
parsingFunc = Workspace.WORKSPACE_SCHEMAS[xmlSchemaFile]
workspace = parsingFunc(workspacePath, workspaceFile)
if workspace is not None:
return (workspace, None)
else:
logging.fatal("The specified Workspace file is not valid according to the XSD found in %s." % (xmlSchemaPath))
return (None, _("An unknown error prevented to open the workspace."))
def __init__(self, controller, idTransition):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"grammar", "createCloseChannelTransition.glade"))
self._getObjects(self.builder, [
"createCloseChannelTransitionDialog", "createButton",
"cancelButton", "idEntry", "nameEntry", "timeEntry",
"startStateComboBox", "endStateComboBox", "stateListStore",
"errorImage", "errorLabel"
])
self.controller = controller
self.builder.connect_signals(self.controller)
self.idEntry.set_text(str(idTransition))
self.idEntry.set_sensitive(False)
currentProject = self.controller.grammarController.getCurrentProject()
# Retrieve the states and symbols of the current project
states = []
if currentProject is not None:
automata = currentProject.getGrammar().getAutomata()
if automata is not None:
states.extend(automata.getStates())
self.stateListStore.clear()
# Configure the list of states
for state in states:
i = self.stateListStore.append()
self.stateListStore.set(i, 0, str(state.getID()))
self.stateListStore.set(i, 1, state.getName())
def __init__(self, controller, gladeFileName):
self.controller = controller
self.builderWidget = Gtk.Builder()
gladePath = os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "Variables", gladeFileName)
self.builderWidget.add_from_file(gladePath)
self.widgDict = dict()
def _initResourcesAndLocales(self):
# Initialize resources
logging.debug("+ Initialize resources...")
if not ResourcesConfiguration.initializeResources():
logging.fatal("Error while configuring the resources of Netzob")
sys.exit()
# Initialiaze gettext
gettext.bindtextdomain("netzob", ResourcesConfiguration.getLocaleLocation())
gettext.textdomain("netzob")
locale.bindtextdomain("netzob", ResourcesConfiguration.getLocaleLocation())
locale.textdomain("netzob")
try:
locale.getlocale()
except:
logging.exception("setlocale failed, resetting to C")
locale.setlocale(locale.LC_ALL, "C")
def _loadActionGroupUIDefinition(self):
"""Loads the action group and the UI definition of menu items
. This method should only be called in the constructor"""
# Load actions
actionsBuilder = Gtk.Builder()
actionsBuilder.add_from_file(os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui", "grammar",
"grammarActions.glade"))
self._actionGroup = actionsBuilder.get_object("grammarActionGroup")
actionsBuilder.connect_signals(self.controller)
uiDefinitionFilePath = os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui", "grammar",
"grammarMenuToolbar.ui")
with open(uiDefinitionFilePath, "r") as uiDefinitionFile:
self._uiDefinition = uiDefinitionFile.read()
def _initResourcesAndLocales(self):
# Initialize resources
logging.debug("+ Initialize resources...")
if not ResourcesConfiguration.initializeResources():
logging.fatal("Error while configuring the resources of Netzob")
sys.exit()
# Initialiaze gettext
gettext.bindtextdomain("netzob", ResourcesConfiguration.getLocaleLocation())
gettext.textdomain("netzob")
locale.bindtextdomain("netzob", ResourcesConfiguration.getLocaleLocation())
locale.textdomain("netzob")
try:
locale.getlocale()
except:
logging.exception("setlocale failed, resetting to C")
locale.setlocale(locale.LC_ALL, "C")
def createWorkspace(name, path):
tracesPath = "traces"
projectsPath = "projects"
prototypesPath = "prototypes"
loggingPath = "logging"
pathOfLogging = "logging/logging.conf"
# we create a "traces" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, tracesPath)):
os.mkdir(os.path.join(path, tracesPath))
# we create a "projects" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, projectsPath)):
os.mkdir(os.path.join(path, projectsPath))
# we create the "prototypes" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, prototypesPath)):
os.mkdir(os.path.join(path, prototypesPath))
# we upload in it the default repository file
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
staticRepositoryPath = os.path.join(
os.path.join(ResourcesConfiguration.getStaticResources(),
"defaults"), "repository.xml.default")
shutil.copy(
staticRepositoryPath,
os.path.join(os.path.join(path, prototypesPath),
"repository.xml"))
# we create the "logging" directory if it doesn't yet exist
if not os.path.isdir(os.path.join(path, loggingPath)):
os.mkdir(os.path.join(path, loggingPath))
# we upload in it the default repository file
from netzob.Common.ResourcesConfiguration import ResourcesConfiguration
staticLoggingPath = os.path.join(
os.path.join(ResourcesConfiguration.getStaticResources(),
"defaults"), "logging.conf.default")
shutil.copy(
staticLoggingPath,
os.path.join(os.path.join(path, loggingPath), "logging.conf"))
workspace = Workspace(name, datetime.datetime.now(), path, tracesPath,
pathOfLogging, prototypesPath)
workspace.saveConfigFile()
return workspace
def __init__(self):
self.apiKey = ResourcesConfiguration.extractAPIKeyDefinitionFromLocalFile()
self.disableRemoteCertificateVerification = False
self.targetBugReport = "{0}/projects/{1}".format(BugReporter.URL_TARGET_BUG_REPORT, BugReporter.PROJECT_NAME_BUG_REPORT)
self.log = logging.getLogger(__name__)
self.customFieldSHA2ID = "5"
self.currentReport = None
def __init__(self, controller):
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary", "partitioning",
"resetPartitioning.glade"))
self._getObjects(self.builder, ["resetDialog",
"reset_execute", "reset_stop", "reset_cancel",
"reset_progressbar"])
self.controller = controller
self.builder.connect_signals(self.controller)
def addIconToFactory(iconStockID, iconFilename):
iconSet = Gtk.IconSet()
iconSource = Gtk.IconSource()
iconPath = os.path.abspath(
os.path.join(ResourcesConfiguration.getStaticResources(), "icons",
"24x24", iconFilename))
iconSource.set_filename(iconPath)
iconSource.set_size(Gtk.IconSize.LARGE_TOOLBAR)
iconSet.add_source(iconSource)
netzobIconFactory.add(iconStockID, iconSet)
def __init__(self, controller):
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary",
"moveMessageDialog.glade"))
self._getObjects(self.builder, ["moveMessageDialog",
"moveMessageMoveAndForgetRadioButton", "moveMessageMoveAndReComputeRadioButton",
"moveMessageMoveInTrashRadioButton"])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary", "splitFieldDialog.glade"))
self._getObjects(self.builder, ["splitFieldDialog", "buffer", "splitPositionAdjustment", "bufferHAdjustment", "scale1"])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"dialogbox.glade"))
self._getObjects(self.builder, [
"certificateError", "certificateErrorApplyButton",
"certificateErrorCancelButton", "certificateErrorTextView"
])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self):
self.apiKey = ResourcesConfiguration.extractAPIKeyDefinitionFromLocalFile(
)
self.disableRemoteCertificateVerification = False
self.targetBugReport = "{0}/projects/{1}".format(
BugReporter.URL_TARGET_BUG_REPORT,
BugReporter.PROJECT_NAME_BUG_REPORT)
self.log = logging.getLogger(__name__)
self.customFieldSHA2ID = "5"
self.currentReport = None
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary",
"messageDistributionDialog.glade"))
self._getObjects(self.builder, ["messageDistributionDialog", "closeButton"])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary",
"editFieldDialog.glade"))
self._getObjects(self.builder, ["dialog", "fieldName", "description", "regex"])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(
ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary", "filterMessagesBar.glade"))
self._getObjects(self.builder, ["filterBar", "filter_entry", "numberOfResultLabel",
"filter_close"])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"vocabulary", "filterMessagesBar.glade"))
self._getObjects(self.builder, [
"filterBar", "filter_entry", "numberOfResultLabel", "filter_close"
])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"vocabulary", "fieldAnalysis.glade"))
self._getObjects(
self.builder,
["dialog", "fieldName", "domainListstore", "typeListstore"])
self.controller = controller
self.builder.connect_signals(self.controller)
def loadBaseMenuBarAndToolbar(self):
# Load actions
mainActionsBuilder = Gtk.Builder()
mainActionsBuilder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"mainActions.glade"))
mainActionsBuilder.connect_signals(self.controller)
self.mainActionGroup = mainActionsBuilder.get_object("mainActionGroup")
# Load menu bar and toolbar UI definitions
self.uiManager = Gtk.UIManager()
self.uiManager.insert_action_group(self.mainActionGroup)
self.uiManager.add_ui_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"mainMenuToolbar.ui"))
mainToolbar = self.uiManager.get_widget("/mainToolbar")
mainToolbar.set_icon_size(Gtk.IconSize.LARGE_TOOLBAR)
self.setPrimaryToolbarStyle(mainToolbar)
self.setMenuBar(self.uiManager.get_widget("/mainMenuBar"))
self.setToolbar(mainToolbar)
# Add accel group to window
self.mainWindow.add_accel_group(self.uiManager.get_accel_group())
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"vocabulary", "splitFieldDialog.glade"))
self._getObjects(self.builder, [
"splitFieldDialog", "buffer", "splitPositionAdjustment",
"bufferHAdjustment", "scale1"
])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"vocabulary", "relationsView.glade"))
self._getObjects(self.builder, [
"relationsDialog", "relationsViewport", "relationsCancelButton",
"relationsApplyButton"
])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self):
self.window = Gtk.Window(Gtk.WindowType.TOPLEVEL)
self.window.set_title(_("Netzob"))
self.window.set_position(Gtk.WindowPosition.CENTER)
self.window.set_decorated(False)
self.window.set_default_size(268, 501)
self.window.set_events(Gdk.EventMask.ALL_EVENTS_MASK)
# Retrieve static resources
staticPath = ResourcesConfiguration.getStaticResources()
logoPath = os.path.abspath(os.path.join(staticPath, "logo.png"))
hbox = Gtk.HBox()
hbox.show()
self.window.add(hbox)
self.image = Gtk.Image()
self.image.set_from_file(logoPath)
self.image.show()
main_vbox = Gtk.VBox(False, 1)
# main_vbox.pack_start(self.image, True, True)
workspace = ResourcesConfiguration.getWorkspace()
if workspace is not None:
self.lbl = Gtk.Label(
label=_("Current workspace: {0}".format(workspace)))
else:
self.lbl = Gtk.Label(
label=_("Current workspace: NO WORKSPACE COMPUTED!"))
self.lbl.set_alignment(0, 0.5)
main_vbox.pack_start(self.image, True, True, 2)
self.window.add(main_vbox)
self.window.show_all()
def newProject_activate_cb(self, action):
"""Display the dialog in order to create a new project when
the user request it through the menu."""
finish = False
errorMessage = None
while not finish:
# open Dialogbox
builder2 = Gtk.Builder()
builder2.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(), "ui", "dialogbox.glade"))
dialog = builder2.get_object("newProject")
dialog.set_transient_for(self.view.mainWindow)
applybutton = builder2.get_object("newProjectApplyButton")
entry = builder2.get_object("entry4")
entry.connect("changed", self.entry_disableButtonIfEmpty_cb, applybutton)
if errorMessage is not None:
# Display a warning message on the dialog box
warnLabel = builder2.get_object("NewProjectWarnLabel")
warnLabel.set_text(errorMessage)
warnBox = builder2.get_object("newProjectWarnBox")
warnBox.show_all()
# Run the dialog window and wait for the result
result = dialog.run()
if result == 0:
newProjectName = entry.get_text()
dialog.destroy()
self.log.debug("Verify the uniqueness of project name: {0}".format(newProjectName))
found = False
for (projectName, projectPath) in self.currentWorkspace.getNameOfProjects():
if projectName == newProjectName:
found = True
break
if found:
self.log.info("A project with the same name already exists ({0}, {1}), please change it.".format(projectName, projectPath))
errorMessage = _("A project with this name exists")
else:
self.log.debug("Create new project {0}".format(newProjectName))
newProject = Project.createProject(self.getCurrentWorkspace(), newProjectName)
self.switchProject(newProject.getPath())
finish = True
errorMessage = None
else:
dialog.destroy()
finish = True
def __init__(self, controller):
'''
Constructor
'''
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(ResourcesConfiguration.getStaticResources(),
"ui", "vocabulary", "partitioning",
"forcePartitioning.glade"))
self._getObjects(self.builder, ["forceDialog",
"force_execute", "force_stop", "force_cancel",
"force_entry",
"force_radiobutton_hexa", "force_radiobutton_string",
"force_progressbar"])
self.controller = controller
self.builder.connect_signals(self.controller)
def __init__(self, controller, parent=None):
self.builder = Gtk.Builder()
self.builder.add_from_file(
os.path.join(ResourcesConfiguration.getStaticResources(), "ui",
"dialogbox.glade"))
self._getObjects(self.builder, [
"bugReporter", "bugTrackerEntry", "bugReporterApiKeyEntry",
"reportTextView", "bugReporterSaveButton",
"bugReporterCancelButton", "bugReporterMessageBox",
"bugReporterInfoImg", "bugReporterWarnImg", "bugReporterWarnLabel",
"bugReporterRememberAPIKeyCheckButton"
])
self.controller = controller
self.builder.connect_signals(self.controller)
self.bugReporter.set_transient_for(parent)
