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)
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)