def getRoot(self):
# We create an aggregate of all the fields
rootSymbol = AggregateVariable(self.getID(), self.getName(), False, False, None)
for field in self.getExtendedFields():
variable = field.getVariable()
rootSymbol.addChild(variable)
return rootSymbol
def getRoot(self):
# We create an aggregate of all the fields
rootSymbol = AggregateVariable(self.getID(), self.getName(), False,
False, None)
for field in self.getExtendedFields():
variable = field.getVariable()
rootSymbol.addChild(variable)
return rootSymbol
def addAggregate(self, event, rootVariable, rootEntry):
# Display the form for the creation of a word variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the Aggregate"))
# Create the ID of the new variable
variableID = str(uuid.uuid4())
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# name of the variable
variableValueLabel = gtk.Label(_("Name:"))
variableValueLabel.show()
variableValueEntry = gtk.Entry()
variableValueEntry.show()
mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# We retrieve the name of the variable
varName = variableValueEntry.get_text()
# Creation of the aggregate id, name, mutable, value):
aggregateVariable = AggregateVariable(variableID, varName, None)
rootVariable.addChild(aggregateVariable)
self.datas[str(aggregateVariable.getID())] = aggregateVariable
self.treestore.append(rootEntry, [str(aggregateVariable.getID()), _("Aggregate")])
# We close the current dialog
dialog.destroy()
def loadFromXML(xmlRoot, namespace, version, symbol):
"""loadFromXML:
Load a variable from an XML definition.
Calls its proper heir function for it to create the variable.
@type xmlRoot: lxml.etree.Element
@param xmlRoot: the root of the XML definition.
@type namespace: string
@param namespace: the namespace (precision) associated to the variable in the XML definition.
@type version: string
@param version: the load version.
@rtype: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable
@type symbol: netzob.Common.Symbol
@param symbol: the symbol in which the current variable is placed, used by relation variable.
@return: a variable constructed from this XML definition.
"""
if version == "0.1":
logging.debug("[ AbstractVariable: loadFromXML:")
# Data Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DataVariable":
from netzob.Common.MMSTD.Dictionary.Variables.DataVariable import DataVariable
return DataVariable.loadFromXML(xmlRoot, namespace, version, symbol)
# Aggregate Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AggregateVariable":
from netzob.Common.MMSTD.Dictionary.Variables.AggregateVariable import AggregateVariable
return AggregateVariable.loadFromXML(xmlRoot, namespace, version, symbol)
# Alternate Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AlternateVariable":
from netzob.Common.MMSTD.Dictionary.Variables.AlternateVariable import AlternateVariable
return AlternateVariable.loadFromXML(xmlRoot, namespace, version, symbol)
# Repeat Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:RepeatVariable":
from netzob.Common.MMSTD.Dictionary.Variables.RepeatVariable import RepeatVariable
return RepeatVariable.loadFromXML(xmlRoot, namespace, version, symbol)
# Direct Relation Variable
#elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DirectRelationVariable":
# from netzob.Common.MMSTD.Dictionary.Variables.DirectRelationVariable import DirectRelationVariable
# return DirectRelationVariable.loadFromXML(xmlRoot, namespace, version, symbol)
# Computed Relation Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:ComputedRelationVariable":
from netzob.Common.MMSTD.Dictionary.Variables.ComputedRelationVariable import ComputedRelationVariable
return ComputedRelationVariable.loadFromXML(xmlRoot, namespace, version, symbol)
else:
logging.debug("xmlRoot.get(...) returns {0} which does not correspond to a true variable class.").format(xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract"))
logging.debug("AbstractVariable: loadFromXML ]")
else:
logging.debug("Version != 0.1")
def __init__(self, netzob, field, variableId, variableName, defaultValue=None):
# create logger with the given configuration
self.log = logging.getLogger('netzob.Inference.Vocabulary.VariableView.py')
self.netzob = netzob
self.project = self.netzob.getCurrentProject()
self.varId = variableId
self.varName = variableName
self.field = field
self.defaultValue = defaultValue
self.datas = dict()
# Add the initial Aggregate
self.rootVariable = AggregateVariable(variableId, self.varName, None)
if self.defaultValue != None:
self.rootVariable.addChild(self.defaultValue)
def loadFromXML(xmlRoot, namespace, version):
if version == "0.1":
# IPv4 Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:IPv4Variable":
from netzob.Common.MMSTD.Dictionary.Variables.IPv4Variable import IPv4Variable
return IPv4Variable.loadFromXML(xmlRoot, namespace, version)
# Word Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:WordVariable":
from netzob.Common.MMSTD.Dictionary.Variables.WordVariable import WordVariable
return WordVariable.loadFromXML(xmlRoot, namespace, version)
# DecimalWord Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DecimalWordVariable":
from netzob.Common.MMSTD.Dictionary.Variables.DecimalWordVariable import DecimalWordVariable
return DecimalWordVariable.loadFromXML(xmlRoot, namespace, version)
# Binary Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:BinaryVariable":
from netzob.Common.MMSTD.Dictionary.Variables.BinaryVariable import BinaryVariable
return BinaryVariable.loadFromXML(xmlRoot, namespace, version)
# Hex Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:HexVariable":
from netzob.Common.MMSTD.Dictionary.Variables.HexVariable import HexVariable
return HexVariable.loadFromXML(xmlRoot, namespace, version)
# Aggregate Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AggregateVariable":
from netzob.Common.MMSTD.Dictionary.Variables.AggregateVariable import AggregateVariable
return AggregateVariable.loadFromXML(xmlRoot, namespace, version)
# Alternate Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:AlternateVariable":
from netzob.Common.MMSTD.Dictionary.Variables.AlternateVariable import AlternateVariable
return AlternateVariable.loadFromXML(xmlRoot, namespace, version)
# Referenced Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:ReferencedVariable":
from netzob.Common.MMSTD.Dictionary.Variables.ReferencedVariable import ReferencedVariable
return ReferencedVariable.loadFromXML(xmlRoot, namespace, version)
class VariableView(object):
#+----------------------------------------------
#| Constructor:
#+----------------------------------------------
def __init__(self, netzob, field, variableId, variableName, defaultValue=None):
# create logger with the given configuration
self.log = logging.getLogger('netzob.Inference.Vocabulary.VariableView.py')
self.netzob = netzob
self.project = self.netzob.getCurrentProject()
self.varId = variableId
self.varName = variableName
self.field = field
self.defaultValue = defaultValue
self.datas = dict()
# Add the initial Aggregate
self.rootVariable = AggregateVariable(variableId, self.varName, None)
if self.defaultValue != None:
self.rootVariable.addChild(self.defaultValue)
def display(self):
# We display the dedicated dialog for the creation of a variable
self.dialog = gtk.Dialog(title=_("Creation of a variable"), flags=0, buttons=None)
# Create the main panel
self.panel = gtk.Table(rows=2, columns=3, homogeneous=False)
self.treestore = gtk.TreeStore(str, str) # id of the data, description
self.treeview = gtk.TreeView(self.treestore)
self.treeview.connect('button-press-event', self.showMenu)
# messages list
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scroll.show()
self.scroll.set_size_request(200, 300)
self.scroll.add(self.treeview)
self.scroll.show()
self.lvcolumn = gtk.TreeViewColumn(_("Description of the variable"))
self.lvcolumn.set_sort_column_id(1)
cell = gtk.CellRendererText()
self.lvcolumn.pack_start(cell, True)
self.lvcolumn.set_attributes(cell, text=1)
self.treeview.append_column(self.lvcolumn)
self.treeview.show()
self.panel.attach(self.scroll, 0, 2, 0, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
self.panel.show()
# Create button
createButton = gtk.Button(_("Create"))
createButton.show()
createButton.connect("clicked", self.createVariable)
self.panel.attach(createButton, 0, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# We register the default values
self.registerVariable(None, self.rootVariable, "Root")
def registerVariable(self, rootEntry, variable, name):
self.log.debug(_("Register: {0}").format(str(name)))
self.datas[str(variable.getID())] = variable
newEntry = self.treestore.append(rootEntry, [str(variable.getID()), name])
if variable.getTypeVariable() == AggregateVariable.TYPE or variable.getTypeVariable() == AlternateVariable.TYPE:
for child in variable.getChildren():
self.registerVariable(newEntry, child, child.getName())
self.dialog.vbox.pack_start(self.panel, True, True, 0)
self.dialog.show()
def createVariable(self, button):
# We register the root variable as the variable of specified field
self.field.setVariable(self.rootVariable)
self.dialog.destroy()
# Update UI
page = self.netzob.getCurrentNotebookPage()
if page != None:
page.update()
def showMenu(self, treeview, event):
rootVariable = None
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
x = int(event.x)
y = int(event.y)
(path, treeviewColumn, x, y) = treeview.get_path_at_pos(x, y)
# Retrieve the selected variable
variable_id = None
aIter = treeview.get_model().get_iter(path)
if aIter:
if treeview.get_model().iter_is_valid(aIter):
variable_id = treeview.get_model().get_value(aIter, 0)
for varid in self.datas.keys():
if varid == variable_id:
rootVariable = self.datas[varid]
if rootVariable == None:
self.log.debug(_("Impossible to find the selected variable."))
return
# We display the menu for the insertion of sub-elements if its an Aggregate or an Alternative
menu = gtk.Menu()
subElementMenu = gtk.Menu()
# Word Variable
itemWord = gtk.MenuItem(_("Word"))
itemWord.show()
itemWord.connect("activate", self.addWord, rootVariable, aIter)
subElementMenu.append(itemWord)
# Decimal Word Variable
itemDecimalWord = gtk.MenuItem(_("Decimal Word"))
itemDecimalWord.show()
itemDecimalWord.connect("activate", self.addDecimalWord, rootVariable, aIter)
subElementMenu.append(itemDecimalWord)
# IPv4 Variable
itemIPv4 = gtk.MenuItem(_("IPv4"))
itemIPv4.show()
itemIPv4.connect("activate", self.addIPv4, rootVariable, aIter)
subElementMenu.append(itemIPv4)
# Binary Variable
itemBinary = gtk.MenuItem(_("Binary"))
itemBinary.show()
itemBinary.connect("activate", self.addBinary, rootVariable, aIter)
subElementMenu.append(itemBinary)
# Hexadecimal Variable
itemBinary = gtk.MenuItem(_("Hexadecimal"))
itemBinary.show()
itemBinary.connect("activate", self.addHexadecimal, rootVariable, aIter)
subElementMenu.append(itemBinary)
# Aggregate Variable
itemAggregate = gtk.MenuItem(_("Aggregate"))
itemAggregate.show()
itemAggregate.connect("activate", self.addAggregate, rootVariable, aIter)
subElementMenu.append(itemAggregate)
# Alternate Variable
itemAlternate = gtk.MenuItem(_("Alternative"))
itemAlternate.show()
itemAlternate.connect("activate", self.addAlternate, rootVariable, aIter)
subElementMenu.append(itemAlternate)
# Referenced Variable
itemAlternate = gtk.MenuItem(_("Referenced Variable"))
itemAlternate.show()
itemAlternate.connect("activate", self.addReferencedVariable, rootVariable, aIter)
subElementMenu.append(itemAlternate)
item = gtk.MenuItem(_("Add a sub-element"))
item.set_submenu(subElementMenu)
item.show()
menu.append(item)
menu.popup(None, None, None, event.button, event.time)
def addBinary(self, event, rootVariable, rootEntry):
# Display the form for the creation of a Binary variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the Binary Variable"))
# Create the ID of the new variable
varID = uuid.uuid4()
variableID = str(varID)
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Original Value
originalValueLabel = gtk.Label(_("Original value:"))
originalValueLabel.show()
originalValueEntry = gtk.Entry()
originalValueEntry.show()
mainTable.attach(originalValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(originalValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Constraints label
constraintsLabel = gtk.Label(_("Constraints when parsing / generating"))
constraintsLabel.show()
mainTable.attach(constraintsLabel, 0, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# start Value
minBitsLabel = gtk.Label(_("Minimum number of bits:"))
minBitsLabel.show()
minBitsEntry = gtk.Entry()
minBitsEntry.show()
mainTable.attach(minBitsLabel, 0, 1, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(minBitsEntry, 1, 2, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# end Value
maxBitsLabel = gtk.Label(_("Maximum number of bits:"))
maxBitsLabel.show()
maxBitsEntry = gtk.Entry()
maxBitsEntry.show()
mainTable.attach(maxBitsLabel, 0, 1, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(maxBitsEntry, 1, 2, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# Creation of the variable (binary)
# original value :
originalValue = originalValueEntry.get_text()
if len(originalValue) == 0:
originalValue = None
# constraints
minSize = int(minBitsEntry.get_text())
maxSize = int(maxBitsEntry.get_text())
binVariable = BinaryVariable(varID, "binary", originalValue, minSize, maxSize)
rootVariable.addChild(binVariable)
self.datas[str(binVariable.getID())] = binVariable
self.treestore.append(rootEntry, [str(binVariable.getID()), binVariable.getUncontextualizedDescription()])
# We close the current dialog
dialog.destroy()
def addHexadecimal(self, event, rootVariable, rootEntry):
# Display the form for the creation of an Hexadecimal variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the Hexadecimal Variable"))
# Create the ID of the new variable
varID = uuid.uuid4()
variableID = str(varID)
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Original Value
originalValueLabel = gtk.Label(_("Original value:"))
originalValueLabel.show()
originalValueEntry = gtk.Entry()
originalValueEntry.show()
mainTable.attach(originalValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(originalValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Constraints label
constraintsLabel = gtk.Label(_("Constraints when parsing / generating"))
constraintsLabel.show()
mainTable.attach(constraintsLabel, 0, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# start Value
minBitsLabel = gtk.Label(_("Minimum number of hex (0xf=1):"))
minBitsLabel.show()
minBitsEntry = gtk.Entry()
minBitsEntry.show()
mainTable.attach(minBitsLabel, 0, 1, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(minBitsEntry, 1, 2, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# end Value
maxBitsLabel = gtk.Label(_("Maximum number of hex:"))
maxBitsLabel.show()
maxBitsEntry = gtk.Entry()
maxBitsEntry.show()
mainTable.attach(maxBitsLabel, 0, 1, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(maxBitsEntry, 1, 2, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# Creation of the variable (binary)
# original value :
originalValue = originalValueEntry.get_text()
if len(originalValue) == 0:
originalValue = None
# constraints
minSize = int(minBitsEntry.get_text())
maxSize = int(maxBitsEntry.get_text())
hexVariable = HexVariable(varID, "hexadecimal", originalValue, minSize, maxSize)
rootVariable.addChild(hexVariable)
self.datas[str(hexVariable.getID())] = hexVariable
self.treestore.append(rootEntry, [str(hexVariable.getID()), hexVariable.getUncontextualizedDescription()])
# We close the current dialog
dialog.destroy()
def addAlternate(self, event, rootVariable, rootEntry):
# Display the form for the creation of a word variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the Alternative"))
# Create the ID of the new variable
variableID = str(uuid.uuid4())
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# name of the variable
variableValueLabel = gtk.Label(_("Name:"))
variableValueLabel.show()
variableValueEntry = gtk.Entry()
variableValueEntry.show()
mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# We retrieve the name of the variable
varName = variableValueEntry.get_text()
# Creation of the aggregate id, name, mutable, value):
alternateVariable = AlternateVariable(variableID, varName, None)
rootVariable.addChild(alternateVariable)
self.datas[str(alternateVariable.getID())] = alternateVariable
self.treestore.append(rootEntry, [str(alternateVariable.getID()), _("Alternate")])
# We close the current dialog
dialog.destroy()
def addAggregate(self, event, rootVariable, rootEntry):
# Display the form for the creation of a word variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the Aggregate"))
# Create the ID of the new variable
variableID = str(uuid.uuid4())
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# name of the variable
variableValueLabel = gtk.Label(_("Name:"))
variableValueLabel.show()
variableValueEntry = gtk.Entry()
variableValueEntry.show()
mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# We retrieve the name of the variable
varName = variableValueEntry.get_text()
# Creation of the aggregate id, name, mutable, value):
aggregateVariable = AggregateVariable(variableID, varName, None)
rootVariable.addChild(aggregateVariable)
self.datas[str(aggregateVariable.getID())] = aggregateVariable
self.treestore.append(rootEntry, [str(aggregateVariable.getID()), _("Aggregate")])
# We close the current dialog
dialog.destroy()
def addWord(self, event, rootVariable, rootEntry):
# Display the form for the creation of a word variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the WORD"))
# Create the ID of the new variable
variableID = str(uuid.uuid4())
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# name of the variable
variableNameLabel = gtk.Label(_("Name:"))
variableNameLabel.show()
variableNameEntry = gtk.Entry()
variableNameEntry.show()
mainTable.attach(variableNameLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableNameEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# value of the variable
variableValueLabel = gtk.Label(_("Value:"))
variableValueLabel.show()
variableValueEntry = gtk.Entry()
variableValueEntry.show()
mainTable.attach(variableValueLabel, 0, 1, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableValueEntry, 1, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# We retrieve the value of the variable
varName = variableNameEntry.get_text()
varValue = variableValueEntry.get_text()
if len(varValue) == 0:
varValue = None
# Creation of the word id, name, mutable, value):
wordVariable = WordVariable(variableID, varName, varValue)
rootVariable.addChild(wordVariable)
self.datas[str(wordVariable.getID())] = wordVariable
self.treestore.append(rootEntry, [str(wordVariable.getID()), wordVariable.getUncontextualizedDescription()])
# We close the current dialog
dialog.destroy()
def addDecimalWord(self, event, rootVariable, rootEntry):
# Display the form for the creation of a word variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the Decimal WORD"))
# Create the ID of the new variable
variableID = str(uuid.uuid4())
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# value of the variable
variableValueLabel = gtk.Label(_("Value:"))
variableValueLabel.show()
variableValueEntry = gtk.Entry()
variableValueEntry.show()
mainTable.attach(variableValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# We retrieve the value of the variable
varValue = variableValueEntry.get_text()
# Creation of the word id, name, mutable, value):
decimalwordVariable = DecimalWordVariable(variableID, varValue, None)
rootVariable.addChild(decimalwordVariable)
self.datas[str(decimalwordVariable.getID())] = decimalwordVariable
self.treestore.append(rootEntry, [str(decimalwordVariable.getID()), decimalwordVariable.getUncontextualizedDescription()])
# We close the current dialog
dialog.destroy()
def addIPv4(self, event, rootVariable, rootEntry):
# Display the form for the creation of an IPv4 variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the IPv4 Variable"))
# Create the ID of the new variable
varID = uuid.uuid4()
variableID = str(varID)
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Original Value
originalValueLabel = gtk.Label(_("Original value:"))
originalValueLabel.show()
originalValueEntry = gtk.Entry()
originalValueEntry.show()
mainTable.attach(originalValueLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(originalValueEntry, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Constraints label
constraintsLabel = gtk.Label(_("Constraints when parsing / generating"))
constraintsLabel.show()
mainTable.attach(constraintsLabel, 0, 2, 3, 4, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# start Value
startValueLabel = gtk.Label(_("Start:"))
startValueLabel.show()
startValueEntry = gtk.Entry()
startValueEntry.show()
mainTable.attach(startValueLabel, 0, 1, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(startValueEntry, 1, 2, 4, 5, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# end Value
endValueLabel = gtk.Label(_("End:"))
endValueLabel.show()
endValueEntry = gtk.Entry()
endValueEntry.show()
mainTable.attach(endValueLabel, 0, 1, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(endValueEntry, 1, 2, 5, 6, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Format label
hdrFormatLabel = gtk.Label(_("Representation"))
hdrFormatLabel.show()
mainTable.attach(hdrFormatLabel, 0, 2, 7, 8, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Format Value
formatValueLabel = gtk.Label(_("Format:"))
formatValueLabel.show()
formatValueCombo = gtk.combo_box_entry_new_text()
formatValueCombo.show()
formatValueComboStore = gtk.ListStore(str) # format name
formatValueCombo.set_model(formatValueComboStore)
# We retrieve all the existing variables in the project
formatValueCombo.get_model().append([Format.HEX])
formatValueCombo.get_model().append([Format.ASCII])
mainTable.attach(formatValueLabel, 0, 1, 8, 9, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(formatValueCombo, 1, 2, 8, 9, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
# Creation of the variable (ipv4)
# original value :
originalValue = originalValueEntry.get_text()
if len(originalValue) == 0:
originalValue = None
# constraints
startValue = startValueEntry.get_text()
if len(startValue) == 0:
startValue = None
endValue = endValueEntry.get_text()
if len(endValue) == 0:
endValue = None
# format
format = formatValueCombo.get_model().get_value(formatValueCombo.get_active_iter(), 0)
ipVariable = IPv4Variable(varID, "ipv4", originalValue, startValue, endValue, format)
rootVariable.addChild(ipVariable)
self.datas[str(ipVariable.getID())] = ipVariable
self.treestore.append(rootEntry, [str(ipVariable.getID()), ipVariable.getUncontextualizedDescription()])
# We close the current dialog
dialog.destroy()
def addReferencedVariable(self, event, rootVariable, rootEntry):
# Display the form for the creation of a word variable
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK, None)
dialog.set_markup(_("Definition of the ReferencedVariable"))
# Create the ID of the new variable
variableID = str(uuid.uuid4())
mainTable = gtk.Table(rows=3, columns=2, homogeneous=False)
# parent id of the variable
variablePIDLabel = gtk.Label(_("Parent ID:"))
variablePIDLabel.show()
variablePIDValueLabel = gtk.Label(str(rootVariable.getID()))
variablePIDValueLabel.set_sensitive(False)
variablePIDValueLabel.show()
mainTable.attach(variablePIDLabel, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variablePIDValueLabel, 1, 2, 0, 1, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# id of the variable
variableIDLabel = gtk.Label(_("ID:"))
variableIDLabel.show()
variableIDValueLabel = gtk.Label(variableID)
variableIDValueLabel.set_sensitive(False)
variableIDValueLabel.show()
mainTable.attach(variableIDLabel, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(variableIDValueLabel, 1, 2, 1, 2, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
# Selection of the variable
varLabel = gtk.Label(_("Referenced Variable:"))
varLabel.show()
self.varCombo = gtk.combo_box_entry_new_text()
self.varCombo.show()
self.varStore = gtk.ListStore(str, str) # description, id,
self.varCombo.set_model(self.varStore)
# We retrieve all the existing variables in the project
existingVariables = self.project.getVocabulary().getVariables()
for existingVariable in existingVariables:
self.varCombo.get_model().append([existingVariable.getUncontextualizedDescription(), existingVariable.getID()])
mainTable.attach(varLabel, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
mainTable.attach(self.varCombo, 1, 2, 2, 3, xoptions=gtk.FILL, yoptions=0, xpadding=5, ypadding=5)
dialog.vbox.pack_end(mainTable, True, True, 0)
dialog.show_all()
result = dialog.run()
if result != gtk.RESPONSE_OK:
dialog.destroy()
return
idReferencedVariable = self.varCombo.get_model().get_value(self.varCombo.get_active_iter(), 1)
referencedVariable = ReferencedVariable(uuid.uuid4(), "Ref", idReferencedVariable)
rootVariable.addChild(referencedVariable)
self.datas[str(referencedVariable.getID())] = referencedVariable
self.treestore.append(rootEntry, [str(referencedVariable.getID()), referencedVariable.getUncontextualizedDescription()])
# We close the current dialog
dialog.destroy()
def validateChanges(self, widget):
"""validateChanges:
Validate the changes that a user has done on a variable.
Called by a click on the apply button.
@type widget: Gtk.widget
@param widget: the widget which calls this function.
"""
dialog = self.view.getWidg("dialog")
if self.editOverCreate:
anid = self.variable.getID()
else:
anid = str(uuid.uuid4())
name = self.view.getWidg("nameEntry").get_text()
mutable = self.view.getWidg("mutableCheck").get_active()
learnable = self.view.getWidg("learnableCheck").get_active()
strVarType = self.view.getWidg("variableTypeCombo").get_active_text()
variable = None
# Aggregate variable
if strVarType == AggregateVariable.TYPE:
variable = AggregateVariable(anid, name, mutable, learnable)
# Alternate Variable
elif strVarType == AlternateVariable.TYPE:
variable = AlternateVariable(anid, name, mutable, learnable)
# Repeat Variable
elif strVarType == RepeatVariable.TYPE:
minIterations = int(self.view.getWidg("minSpin").get_text())
maxIterations = int(self.view.getWidg("maxSpin").get_text())
variable = RepeatVariable(anid, name, mutable, learnable, None, minIterations, maxIterations)
# Data Variable
elif strVarType == DataVariable.TYPE:
originalValue = str(self.view.getWidg("valueEntry").get_text())
sized = self.view.getWidg("sizedCheck").get_active()
if sized:
# If the variable is defined by a size.
minChars = int(self.view.getWidg("minSpin").get_text())
maxChars = int(self.view.getWidg("maxSpin").get_text())
delimiter = None
else:
# The variable is defined by a delimiter.
minChars = 0
maxChars = 0
delimiter = self.view.getWidg("delimiterEntry").get_text()
vtype = AbstractType.makeType(self.view.getWidg("typeCombo").get_active_text(), sized, minChars, maxChars, delimiter)
variable = DataVariable(anid, name, mutable, learnable, vtype, originalValue)
#===============================================================================
# # Direct Relation Variable
# elif strVarType == DirectRelationVariable.TYPE:
#
# # We find the variable by its ID.
# pointedID = str(self.view.getWidg("IDEntry").get_text())
#
# variable = DirectRelationVariable(anid, name, mutable, learnable, pointedID, self.treeController.symbol)
#===============================================================================
# Computed Relation Variable
elif strVarType == ComputedRelationVariable.TYPE:
# We find the variable by its ID.
pointedID = str(self.view.getWidg("IDEntry").get_text())
sized = self.view.getWidg("sizedCheck").get_active()
if sized:
# If the variable is defined by a size.
minChars = int(self.view.getWidg("minSpin").get_text())
maxChars = int(self.view.getWidg("maxSpin").get_text())
delimiter = None
else:
# The variable is defined by a delimiter.
minChars = 0
maxChars = 0
delimiter = self.view.getWidg("delimiterEntry").get_text()
vtype = AbstractRelationType.makeType(self.view.getWidg("relationTypeCombo").get_active_text(), sized, minChars, maxChars, delimiter)
variable = ComputedRelationVariable(anid, name, mutable, learnable, vtype, pointedID, self.treeController.symbol)
if variable is not None:
# This part is for saving and transfering children when transforming a node variable into an other kind of node variable.
if self.editOverCreate:
father = self.variable.getFathers()[0]
# We transform a node variable into a node variable.
if (self.variable.getVariableType() == AggregateVariable.TYPE or self.variable.getVariableType() == AlternateVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE):
children = self.variable.getChildren()
self.variable = variable
for child in children:
self.variable.addChild(child)
# We transform a repeat variable into a node variable.
elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE):
child = self.variable.getChild()
self.variable = variable
self.variable.addChild(child)
# We transform a repeat variable into a repeat variable.
elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == RepeatVariable.TYPE):
child = self.variable.getChild()
self.variable = variable
self.variable.addChild(child)
# We do not manage/save children.
else:
self.variable = variable
self.variable.addFather(father)
self.treeController.editVariable(self.variable)
else:
self.variable.addChild(variable)
self.treeController.registerVariable(self.rootEntry, variable)
dialog.destroy()
def loadFromXML(xmlRoot, namespace, version, symbol):
"""loadFromXML:
Load a variable from an XML definition.
Calls its proper heir function for it to create the variable.
@type xmlRoot: lxml.etree.Element
@param xmlRoot: the root of the XML definition.
@type namespace: string
@param namespace: the namespace (precision) associated to the variable in the XML definition.
@type version: string
@param version: the load version.
@rtype: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable
@type symbol: netzob.Common.Symbol
@param symbol: the symbol in which the current variable is placed, used by relation variable.
@return: a variable constructed from this XML definition.
"""
if version == "0.1":
logging.debug("[ AbstractVariable: loadFromXML:")
# Data Variable
if xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type",
"abstract") == "netzob:DataVariable":
from netzob.Common.MMSTD.Dictionary.Variables.DataVariable import DataVariable
return DataVariable.loadFromXML(xmlRoot, namespace, version,
symbol)
# Aggregate Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type",
"abstract") == "netzob:AggregateVariable":
from netzob.Common.MMSTD.Dictionary.Variables.AggregateVariable import AggregateVariable
return AggregateVariable.loadFromXML(xmlRoot, namespace,
version, symbol)
# Alternate Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type",
"abstract") == "netzob:AlternateVariable":
from netzob.Common.MMSTD.Dictionary.Variables.AlternateVariable import AlternateVariable
return AlternateVariable.loadFromXML(xmlRoot, namespace,
version, symbol)
# Repeat Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type",
"abstract") == "netzob:RepeatVariable":
from netzob.Common.MMSTD.Dictionary.Variables.RepeatVariable import RepeatVariable
return RepeatVariable.loadFromXML(xmlRoot, namespace, version,
symbol)
# Direct Relation Variable
#elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type", "abstract") == "netzob:DirectRelationVariable":
# from netzob.Common.MMSTD.Dictionary.Variables.DirectRelationVariable import DirectRelationVariable
# return DirectRelationVariable.loadFromXML(xmlRoot, namespace, version, symbol)
# Computed Relation Variable
elif xmlRoot.get("{http://www.w3.org/2001/XMLSchema-instance}type",
"abstract") == "netzob:ComputedRelationVariable":
from netzob.Common.MMSTD.Dictionary.Variables.ComputedRelationVariable import ComputedRelationVariable
return ComputedRelationVariable.loadFromXML(
xmlRoot, namespace, version, symbol)
else:
logging.debug(
"xmlRoot.get(...) returns {0} which does not correspond to a true variable class."
).format(
xmlRoot.get(
"{http://www.w3.org/2001/XMLSchema-instance}type",
"abstract"))
logging.debug("AbstractVariable: loadFromXML ]")
else:
logging.debug("Version != 0.1")
def learn(self, child, readingToken):
"""learn:
The alternate variable learns the given value and adds it at the end of its children.
@type child: netzob.Common.MMSTD.Dictionary.Variable.AbstractVariable.AbstractVariable
@param child: the child we expected to find while reading the given value.
@type readingToken: netzob.Common.MMSTD.Dictionary.VariableProcessingToken.VariableReadingToken.VariableReadingToken
@param readingToken: a token which contains all critical information on this access.
"""
self.log.debug("- [ {0}: learn.".format(self.toString()))
dictOfValues = dict()
savedIndex = readingToken.getIndex()
savedFather = self.getFathers()[0] # TODO: not accurate. But yet we can only have one father
selfPosition = savedFather.indexOfChild(self)
# We create a fake father for this alternate.
if self.getFathers()[0].getType() == AggregateVariable.TYPE:
fakeFather = AggregateVariable(str(uuid.uuid4()), "Fake father", False, False)
# We add this element and its right brother as child of the fake father in order to pursue the read access from where we are.
fakeFather.addChild(self)
for rightBrother in self.getFathers()[0].getChildren()[selfPosition:]:
fakeFather.addChild(rightBrother)
elif self.getFathers()[0].getType() == RepeatVariable.TYPE:
(minIterations, maxIterations) = self.getFathers()[0].getNumberIterations()
# Some iterations of this treatment could have been made before. The fake father should not make more iterations than it remains for the real father.
minIterations = max(0, minIterations - self.getFathers()[0].getCurrentIteration())
maxIterations = max(0, maxIterations - self.getFathers()[0].getCurrentIteration())
fakeFather = RepeatVariable(str(uuid.uuid4()), "Fake father", False, False, self, minIterations, maxIterations)
else:
self.log.error("The father is neither an aggregate nor a repeat variable.")
# We execute the treatment on the fake father.
valueToBeRead = readingToken.getValue()[readingToken.getIndex():]
for index in len(valueToBeRead):
# We search if, by shifting the position of actual variable, we could read the given value.
tmpValue = valueToBeRead[:index]
tmpChild = DataVariable(str(uuid.uuid4()), "Learned Inserted Variable", True, True, BinaryType(True, len(tmpValue), len(tmpValue)), tmpValue)
# We add the new variable at the end, in order to minimize its impact.
self.add(tmpChild)
# We read this new variable from the father in a learning context.
self.setLearning(True)
fakeFather.read(readingToken)
# If this read access works, we learn the variable.
if readingToken.isOk():
break
else:
# We remove the just added child.
self.removeChild(tmpChild)
self.removefather(fakeFather)
# We restore the action induced by the fake father.
readingToken.setIndex(savedIndex)
vocabulary = readingToken.getVocabulary()
for key, val in dictOfValues.iteritems():
child = vocabulary.getVariableByID(key)
# We restore the current values.
child.setCurrentValue(val)
# We restore the cached values.
child.restore(readingToken)
if readingToken.isOk():
# We continue the treatment. The real father's treatment will pursue.
self.read(readingToken)
self.log.debug("Variable {0}: {1}. ] -".format(self.getName(), readingToken.toString()))
def validateChanges(self, widget):
"""validateChanges:
Validate the changes that a user has done on a variable.
Called by a click on the apply button.
@type widget: Gtk.widget
@param widget: the widget which calls this function.
"""
dialog = self.view.getWidg("dialog")
if self.editOverCreate:
anid = self.variable.getID()
else:
anid = str(uuid.uuid4())
name = self.view.getWidg("nameEntry").get_text()
mutable = self.view.getWidg("mutableCheck").get_active()
learnable = self.view.getWidg("learnableCheck").get_active()
varTypeIndex = self.view.getWidg("variableTypeCombo").get_active()
variable = None
# Aggregate variable
if varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(AggregateVariable.TYPE):
variable = AggregateVariable(anid, name, mutable, learnable)
# Alternate Variable
elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(AlternateVariable.TYPE):
variable = AlternateVariable(anid, name, mutable, learnable)
# Repeat Variable
elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(RepeatVariable.TYPE):
minIterations = int(self.view.getWidg("minSpin").get_text())
maxIterations = int(self.view.getWidg("maxSpin").get_text())
variable = RepeatVariable(anid, name, mutable, learnable, None, minIterations, maxIterations)
# Data Variable
elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(DataVariable.TYPE):
sized = self.view.getWidg("sizedCheck").get_active()
if sized:
# If the variable is defined by a size.
minChars = int(self.view.getWidg("minSpin").get_text())
maxChars = int(self.view.getWidg("maxSpin").get_text())
delimiter = None
else:
# The variable is defined by a delimiter.
minChars = 0
maxChars = 0
delimiter = self.view.getWidg("delimiterEntry").get_text()
vtype = AbstractType.makeType(VariableTreeController.TYPE_INDEX_LIST[self.view.getWidg("typeCombo").get_active()], sized, minChars, maxChars, delimiter)
originalValue = vtype.str2bin(self.view.getWidg("valueEntry").get_text())
variable = DataVariable(anid, name, mutable, learnable, vtype, originalValue)
#===============================================================================
# # Direct Relation Variable
# elif strVarType == DirectRelationVariable.TYPE:
#
# # We find the variable by its ID.
# pointedID = str(self.view.getWidg("IDEntry").get_text())
#
# variable = DirectRelationVariable(anid, name, mutable, learnable, pointedID, self.treeController.symbol)
#===============================================================================
# Computed Relation Variable
elif varTypeIndex == VariableTreeController.VARIABLE_INDEX_LIST.index(ComputedRelationVariable.TYPE):
# We find the variable by its ID.
pointedID = str(self.view.getWidg("IDEntry").get_text())
sized = self.view.getWidg("sizedCheck").get_active()
if sized:
# If the variable is defined by a size.
minChars = int(self.view.getWidg("minSpin").get_text())
maxChars = int(self.view.getWidg("maxSpin").get_text())
delimiter = None
else:
# The variable is defined by a delimiter.
minChars = 0
maxChars = 0
delimiter = self.view.getWidg("delimiterEntry").get_text()
factor = float(self.view.getWidg("factorEntry").get_text())
offset = float(self.view.getWidg("offsetEntry").get_text())
vtype = AbstractRelationType.makeType(VariableTreeController.RELATION_TYPE_INDEX_LIST[self.view.getWidg("relationTypeCombo").get_active()], sized, minChars, maxChars, delimiter, factor, offset)
variable = ComputedRelationVariable(anid, name, mutable, learnable, vtype, pointedID, self.treeController.symbol)
if variable is not None:
# This part is for saving and transfering children when transforming a node variable into an other kind of node variable.
if self.editOverCreate:
father = None
if len(self.variable.getFathers()) > 0:
father = self.variable.getFathers()[0]
# We transform a node variable into a node variable.
if (self.variable.getVariableType() == AggregateVariable.TYPE or self.variable.getVariableType() == AlternateVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE):
children = self.variable.getChildren()
self.variable = variable
for child in children:
self.variable.addChild(child)
# We transform a repeat variable into a node variable.
elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == AggregateVariable.TYPE or variable.getVariableType() == AlternateVariable.TYPE):
child = self.variable.getChild()
self.variable = variable
self.variable.addChild(child)
# We transform a repeat variable into a repeat variable.
elif (self.variable.getVariableType() == RepeatVariable.TYPE) and (variable.getVariableType() == RepeatVariable.TYPE):
child = self.variable.getChild()
self.variable = variable
self.variable.setChild(child)
# We do not manage/save children.
else:
self.variable = variable
if father is not None:
self.variable.addFather(father)
self.treeController.editVariable(self.variable)
else:
if self.variable.getVariableType() == RepeatVariable.TYPE:
self.variable.setChild(variable)
else:
self.variable.addChild(variable)
self.treeController.registerVariable(self.rootEntry, variable)
dialog.destroy()
