def specialize(self, memory=None, generationStrategy=None):
"""Specialize and generate an hexastring which content
follows the fields definitions attached to the field of the symbol.
>>> from netzob.all import *
>>> f1 = Field(domain=ASCII(nbChars=5))
>>> f0 = Field(domain=Size(f1))
>>> s = Symbol(fields=[f0, f1])
>>> result = s.specialize()
>>> print result[0]
\x05
>>> print len(result)
6
:keyword generationStrategy: if set, the strategy will be used to generate the fields definitions
:type generaionrStrategy: :class:``
:return: a generated content represented as a Raw
:rtype: :class:`str``
:raises: :class:`netzob.Common.Models.Vocabulary.AbstractField.GenerationException` if an error occurs while generating a message
"""
from netzob.Common.Models.Vocabulary.Domain.Specializer.MessageSpecializer import MessageSpecializer
msg = MessageSpecializer(memory=memory)
spePath = msg.specializeSymbol(self)
if spePath is not None:
return TypeConverter.convert(spePath.generatedContent, BitArray, Raw)
def specialize(self, memory=None, generationStrategy=None, presets=None):
"""Specialize and generate an hexastring which content
follows the fields definitions attached to the field of the symbol.
>>> from netzob.all import *
>>> f1 = Field(domain=ASCII(nbChars=5))
>>> f0 = Field(domain=Size(f1))
>>> s = Symbol(fields=[f0, f1])
>>> result = s.specialize()
>>> print result[0]
\x05
>>> print len(result)
6
You can also preset the value of some variables included in the symbol definition.
>>> from netzob.all import *
>>> f1 = Field(domain=ASCII("hello "))
>>> f2 = Field(domain=ASCII(nbChars=(1,10)))
>>> s = Symbol(fields = [f1, f2])
>>> presetValues = dict()
>>> presetValues[f2] = TypeConverter.convert("antoine", ASCII, BitArray)
>>> print s.specialize(presets = presetValues)
hello antoine
A preseted valued bypasses all the constraints checks on your field definition.
For example, in the following example it can be use to bypass a size field definition.
>>> from netzob.all import *
>>> f1 = Field()
>>> f2 = Field(domain=Raw(nbBytes=(10,15)))
>>> f1.domain = Size(f2)
>>> s = Symbol(fields=[f1, f2])
>>> presetValues = {f1: TypeConverter.convert("\xff", Raw, BitArray)}
>>> print repr(s.specialize(presets = presetValues)[0])
'\\xff'
:keyword generationStrategy: if set, the strategy will be used to generate the fields definitions
:type generaionrStrategy: :class:``
:return: a generated content represented as a Raw
:rtype: :class:`str``
:raises: :class:`netzob.Common.Models.Vocabulary.AbstractField.GenerationException` if an error occurs while generating a message
"""
from netzob.Common.Models.Vocabulary.Domain.Specializer.MessageSpecializer import MessageSpecializer
msg = MessageSpecializer(memory=memory, presets=presets)
spePath = msg.specializeSymbol(self)
if spePath is not None:
return TypeConverter.convert(spePath.generatedContent, BitArray,
Raw)
def specialize(self, memory=None, generationStrategy=None, presets=None):
"""Specialize and generate an hexastring which content
follows the fields definitions attached to the field of the symbol.
>>> from netzob.all import *
>>> f1 = Field(domain=ASCII(nbChars=5))
>>> f0 = Field(domain=Size(f1))
>>> s = Symbol(fields=[f0, f1])
>>> result = s.specialize()
>>> print result[0]
\x05
>>> print len(result)
6
You can also preset the value of some variables included in the symbol definition.
>>> from netzob.all import *
>>> f1 = Field(domain=ASCII("hello "))
>>> f2 = Field(domain=ASCII(nbChars=(1,10)))
>>> s = Symbol(fields = [f1, f2])
>>> presetValues = dict()
>>> presetValues[f2] = TypeConverter.convert("antoine", ASCII, BitArray)
>>> print s.specialize(presets = presetValues)
hello antoine
A preseted valued bypasses all the constraints checks on your field definition.
For example, in the following example it can be use to bypass a size field definition.
>>> from netzob.all import *
>>> f1 = Field()
>>> f2 = Field(domain=Raw(nbBytes=(10,15)))
>>> f1.domain = Size(f2)
>>> s = Symbol(fields=[f1, f2])
>>> presetValues = {f1: TypeConverter.convert("\xff", Raw, BitArray)}
>>> print repr(s.specialize(presets = presetValues)[0])
'\\xff'
:keyword generationStrategy: if set, the strategy will be used to generate the fields definitions
:type generaionrStrategy: :class:``
:return: a generated content represented as a Raw
:rtype: :class:`str``
:raises: :class:`netzob.Common.Models.Vocabulary.AbstractField.GenerationException` if an error occurs while generating a message
"""
from netzob.Common.Models.Vocabulary.Domain.Specializer.MessageSpecializer import MessageSpecializer
msg = MessageSpecializer(memory=memory, presets=presets)
spePath = msg.specializeSymbol(self)
if spePath is not None:
return TypeConverter.convert(spePath.generatedContent, BitArray, Raw)
def __init__(self, channel, symbols):
self.channel = channel
self.symbols = symbols
self.memory = Memory()
self.specializer = MessageSpecializer(memory = self.memory)
self.parser = MessageParser(memory = self.memory)
class AbstractionLayer(object):
"""An abstraction layer specializes a symbol into a message before
emitting it and on the other way, abstracts a received message
into a symbol.
>>> from netzob.all import *
>>> symbol = Symbol([Field("Hello Zoby !")], name = "Symbol_Hello")
>>> channelIn = UDPServer(localIP="127.0.0.1", localPort=8889)
>>> abstractionLayerIn = AbstractionLayer(channelIn, [symbol])
>>> abstractionLayerIn.openChannel()
>>> channelOut = UDPClient(remoteIP="127.0.0.1", remotePort=8889)
>>> abstractionLayerOut = AbstractionLayer(channelOut, [symbol])
>>> abstractionLayerOut.openChannel()
>>> abstractionLayerOut.writeSymbol(symbol)
>>> (receivedSymbol, receivedMessage) = abstractionLayerIn.readSymbol()
>>> print receivedSymbol.name
Symbol_Hello
>>> print receivedMessage
Hello Zoby !
"""
def __init__(self, channel, symbols):
self.channel = channel
self.symbols = symbols
self.memory = Memory()
self.specializer = MessageSpecializer(memory = self.memory)
self.parser = MessageParser(memory = self.memory)
@typeCheck(Symbol)
def writeSymbol(self, symbol):
"""Write the specified symbol on the communication channel
after specializing it into a contextualized message.
:param symbol: the symbol to write on the channel
:type symbol: :class:`netzob.Common.Models.Vocabulary.Symbol.Symbol`
:raise TypeError if parameter is not valid and Exception if an exception occurs.
"""
if symbol is None:
raise TypeError("The symbol to write on the channel cannot be None")
self._logger.info("Going to specialize symbol: '{0}' (id={1}).".format(symbol.name, symbol.id))
dataBin = self.specializer.specializeSymbol(symbol).generatedContent
self.memory = self.specializer.memory
self.parser.memory = self.memory
data = TypeConverter.convert(dataBin, BitArray, Raw)
symbol.messages.append(RawMessage(data))
self._logger.info("Data generated from symbol '{0}':\n{1}.".format(symbol.name, symbol))
self._logger.info("Going to write to communication channel...")
self.channel.write(data)
self._logger.info("Writing to commnunication channel donne..")
@typeCheck(int)
def readSymbol(self, timeout=EmptySymbol.defaultReceptionTimeout()):
"""Read from the abstraction layer a message and abstract it
into a message.
The timeout parameter represents the amount of time (in millisecond) above which
no reception of a message triggers the reception of an :class:`netzob.Common.Models.Vocabulary.EmptySymbol.EmptySymbol`. If timeout set to None
or to a negative value means it always wait for the reception of a message.
:keyword timeout: the time above which no reception of message triggers the reception of an :class:`netzob.Common.Models.Vocabulary.EmptySymbol.EmptySymbol`
:type timeout: :class:`int`
:raise TypeError if the parameter is not valid and Exception if an error occurs.
"""
self._logger.info("Going to read from communication channel...")
data = self.channel.read(timeout = timeout)
self._logger.info("Received : {}".format(repr(data)))
symbol = None
for potential in self.symbols:
try:
self.parser.parseMessage(RawMessage(data), potential)
symbol = potential
self.memory = self.parser.memory
self.specializer.memory = self.memory
break
except Exception, e:
symbol = None
if symbol is None and len(data) > 0:
symbol = UnknownSymbol()
elif symbol is None and len(data) == 0:
symbol = EmptySymbol()
symbol.messages.append(RawMessage(data))
self._logger.info("Received a message abstracted with symbol '{}' on communication channel:\n{}".format(symbol.name, symbol))
return (symbol, data)