def specializeSymbol(self, symbol):
"""This method generates a message based on the provided symbol definition."""
if symbol is None:
raise Exception("Specified symbol is None")
self._logger.debug("Specifies symbol '{0}'.".format(symbol.name))
# this variable host all the specialization path
specializingPaths = [SpecializingPath(memory=self.memory)]
for field in symbol.fields:
self._logger.debug("Specializing field {0}".format(field.name))
fieldDomain = field.domain
if fieldDomain is None:
raise Exception("Cannot specialize field '{0}' since it defines no domain".format(fieldDomain))
fs = FieldSpecializer(field, presets = self.presets)
newSpecializingPaths = []
for specializingPath in specializingPaths:
newSpecializingPaths.extend(fs.specialize(specializingPath))
specializingPaths = newSpecializingPaths
if len(specializingPaths) > 1:
self._logger.info("TODO: multiple valid paths found when specializing this message.")
if len(specializingPaths) == 0:
raise Exception("Cannot specialize this symbol.")
retainedPath = specializingPaths[0]
generatedContent = None
# let's configure the generated content
for field in symbol.fields:
# TODO: only support one level of children... must be improved
if len(field.fields) > 0:
d = None
for child in field.fields:
if d is None:
d = retainedPath.getDataAssignedToVariable(child.domain).copy()
else:
d += retainedPath.getDataAssignedToVariable(child.domain).copy()
else:
d = retainedPath.getDataAssignedToVariable(field.domain)
if generatedContent is None:
generatedContent = d.copy()
else:
generatedContent += d.copy()
retainedPath.generatedContent = generatedContent
self._logger.debug("Specialized message: {0}".format(TypeConverter.convert(retainedPath.generatedContent, BitArray, ASCII)))
self.memory = retainedPath.memory
return retainedPath
def specialize(self):
"""Specialize the current field to build a raw data that
follows the fields definitions attached to current element.
This method allows to generate some content following the field definition:
>>> from netzob.all import *
>>> f = Field("hello")
>>> print('\\n'.join([str(f.specialize()) for x in range(3)]))
b'hello'
b'hello'
b'hello'
This method also applies on multiple fields using a Symbol
>>> fHello = Field("hello ")
>>> fName = Field("zoby")
>>> s = Symbol([fHello, fName])
>>> print('\\n'.join([str(s.specialize()) for x in range(3)]))
b'hello zoby'
b'hello zoby'
b'hello zoby'
:return: a generated content represented with an hexastring
:rtype: :class:`str``
:raises: :class:`netzob.Model.Vocabulary.AbstractField.GenerationException` if an error occurs while generating a message
"""
self._logger.debug("Specializes field {0}".format(self.name))
if self.__domain is None:
raise InvalidDomainException("The domain is not defined.")
from netzob.Model.Vocabulary.Domain.Specializer.FieldSpecializer import FieldSpecializer
fs = FieldSpecializer(self)
if self.domain.svas == SVAS.PERSISTENT:
if isinstance(self.specializingPaths, list):
self.specializingPaths = fs.specialize(
specializingPath=self.specializingPaths[0])
else:
self.specializingPaths = fs.specialize(
specializingPath=self.specializingPaths)
specializingPaths = self.specializingPaths
else:
specializingPaths = fs.specialize()
if len(specializingPaths) < 1:
raise Exception("Cannot specialize this field")
specializingPath = specializingPaths[0]
self._logger.debug(
"field specializing done: {0}".format(specializingPath))
if specializingPath is None:
raise Exception(
"The specialization of the field {0} returned no result.".
format(self.name))
return TypeConverter.convert(
specializingPath.getDataAssignedToVariable(self.domain), BitArray,
Raw)
def specializeSymbol(self, symbol):
"""This method generates a message based on the provided symbol definition."""
if symbol is None:
raise Exception("Specified symbol is None")
self._logger.debug("Specifies symbol '{0}'.".format(symbol.name))
self._update_presets(symbol)
# this variable host all the specialization path
specializingPaths = [SpecializingPath(memory=self.memory)]
for field in symbol.fields:
self._logger.debug("Specializing field {0}".format(field.name))
fieldDomain = field.domain
if fieldDomain is None:
raise Exception(
"Cannot specialize field '{0}' since it defines no domain".
format(fieldDomain))
fs = FieldSpecializer(field, presets=self.presets)
newSpecializingPaths = []
for specializingPath in specializingPaths:
newSpecializingPaths.extend(fs.specialize(specializingPath))
specializingPaths = newSpecializingPaths
if len(specializingPaths) > 1:
self._logger.info(
"TODO: multiple valid paths found when specializing this message."
)
if len(specializingPaths) == 0:
raise Exception("Cannot specialize this symbol.")
retainedPath = specializingPaths[0]
generatedContent = None
# let's configure the generated content
for field in symbol.fields:
# do no produce content if it is a pseudo field
if field.isPseudoField is True:
continue
# TODO: only support one level of children... must be improved
if len(field.fields) > 0:
d = None
for child in field.fields:
# do no produce content if it is a pseudo field
if child.isPseudoField is True:
continue
if d is None:
d = retainedPath.getDataAssignedToVariable(
child.domain).copy()
else:
d += retainedPath.getDataAssignedToVariable(
child.domain).copy()
else:
d = retainedPath.getDataAssignedToVariable(field.domain)
if generatedContent is None:
generatedContent = d.copy()
else:
generatedContent += d.copy()
retainedPath.generatedContent = generatedContent
self._logger.debug("Specialized message: {0}".format(
TypeConverter.convert(retainedPath.generatedContent, BitArray,
ASCII)))
self.memory = retainedPath.memory
return retainedPath