Python AbstractType.defaultSign方法代码示例

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def __init__(self, _type, unitSize=None, endianness=None, sign=None):
        """Creates a new encoding function that will encode
        the data with the specified types and following its attributes. If an attribute
        is not specified (or set to None), it takes its default value defined in :class:`netzob.Common.Models.Types.AbstractType.AbstractType`.

        :parameter _type: the type that will be used to encode
        :type _type: :class:`type`
        :keyword unitSize: the unitsize of the expected result. Values must be one of AbstractType.UNITSIZE_*
        :type unitSize: str
        :keyword endianness: the endianness of the expected result. Values must be AbstractType.ENDIAN_BIG or AbstractType.ENDIAN_LITTLE
        :type endianness: str
        :keyword sign: the sign of the expected result. Values must be AbstractType.SIGN_SIGNED or AbstractType.SIGN_UNSIGNED
        :type sign: str
        """
        self.type = _type
        if unitSize is None:
            unitSize = AbstractType.defaultUnitSize()
        self.unitSize = unitSize

        if endianness is None:
            endianness = AbstractType.defaultEndianness()
        self.endianness = endianness

        if sign is None:
            sign = AbstractType.defaultSign()
        self.sign = sign

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def decode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """This method convert the specified data in python raw format.

        >>> from netzob.all import *
        >>> import os
        >>> # Generate 1024 random bytes
        >>> randomData = os.urandom(1024)
        >>> # Convert to hexastring
        >>> hex = TypeConverter.convert(randomData, Raw, HexaString)
        >>> print len(hex)
        2048
        >>> # Convert back to byte and verify we didn't lost anything
        >>> raw = TypeConverter.convert(hex, HexaString, Raw)
        >>> print raw == randomData
        True


        :param data: the data encoded in hexaString (str) which will be decoded in raw
        :type data: str
        :keyword unitSize: the unit size of the specified data
        :type unitSize: :class:`netzob.Common.Models.Types.UnitSize.UnitSize`
        :keyword endianness: the endianness of the specified data
        :type endianness: :class:`netzob.Common.Models.Types.Endianness.Endianness`
        :keyword sign: the sign of the specified data
        :type sign: :class:`netzob.Common.Models.Types.Sign.Sign`

        :return: data encoded in python raw
        :rtype: python raw
        :raise: TypeError if parameters are not valid.
        """
        if data is None:
            raise TypeError("data cannot be None")

        if len(data) % 2 == 1:
            data = '0' + data

        return binascii.unhexlify(data)

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def __init__(self, value=None, nbBytes=None, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        if value is not None and not isinstance(value, bitarray):
            from netzob.Common.Models.Types.TypeConverter import TypeConverter
            from netzob.Common.Models.Types.BitArray import BitArray
            value = TypeConverter.convert(value, Raw, BitArray)

        nbBits = self._convertNbBytesinNbBits(nbBytes)

        super(Raw, self).__init__(self.__class__.__name__, value, nbBits, unitSize=unitSize, endianness=endianness, sign=sign)

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
 def encode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
     return data

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def canParse(self, data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """Computes if specified data can be parsed as a Timestamp with the predefined constraints.

        >>> from netzob.all import *
        >>> time = Timestamp()
        >>> time.canParse(TypeConverter.convert(1444494130, Integer, BitArray, src_unitSize=AbstractType.UNITSIZE_32))
        True
        >>> # A timestamp is nothing else than 32bits parsed as an unsigned long
        >>> time.canParse(TypeConverter.convert("test", ASCII, BitArray))
        True
        >>> time.canParse(TypeConverter.convert("te", ASCII, BitArray))
        False
        
        However, some constrains over the definition of the Timestamp can be set to restrain the accepted values

        >>> from netzob.all import *
        >>> time = Timestamp(epoch=Timestamp.EPOCH_WINDOWS, unity=Timestamp.UNITY_NANOSECOND, unitSize = AbstractType.UNITSIZE_64)
        >>> # the returned year is < 1900
        >>> time.canParse(TypeConverter.convert("test", ASCII, BitArray))
        False

        """

        if data is None:
            raise TypeError("data cannot be None")
         
        # Timestamp must be 8 bits modulo length
        if len(data) % 8 != 0:
            return False

        if len(data) < int(self.unitSize):
            return False

        try:

            value = TypeConverter.convert(data[:int(self.unitSize)], BitArray, Integer, dst_unitSize=AbstractType.UNITSIZE_32, dst_sign=AbstractType.SIGN_UNSIGNED)

            # convert the value in seconds
            value = value / self.unity

            # add the utc now with the epoch
            timestamp_datetime = self.epoch + timedelta(seconds=value)
            
            # convert obtained datetime to timestamp in seconds 
            result_sec = int( timestamp_datetime.strftime('%s') )
            
            datetime.fromtimestamp(result_sec)
        except Exception:
            return False
        
        return True

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def decode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """Decode the specified IPv4 data into its raw representation.

        >>> from netzob.all import *
        >>> print IPv4.decode("127.0.0.1")
        \x7f\x00\x00\x01

        """

        if data is None:
            raise TypeError("Data cannot be None")
        ip = IPv4()
        if not ip.canParse(data):
            raise TypeError("Data is not a valid IPv4, cannot decode it.")
        ip = IPAddress(data)
        return ip.packed

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def canParse(self, data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """For the moment its always true because we consider
        the decimal type to be very similar to the raw type.

        >>> from netzob.all import *

        >>> BitArray().canParse(TypeConverter.convert("hello netzob", ASCII, BitArray))
        True

        >>> b = BitArray(nbBits=8)
        >>> b.canParse(bitarray('01010101'))
        True

        >>> b.canParse(bitarray('010101011'))
        False

        :param data: the data to check
        :type data: python raw
        :return: True if data can be parsed as a BitArray
        :rtype: bool
        :raise: TypeError if the data is None
        """

        if data is None:
            raise TypeError("data cannot be None")

        if not isinstance(data, bitarray):
            raise TypeError("Data should be a python raw ({0}:{1})".format(data, type(data)))

        if len(data) == 0:
            return False

        (nbMinBits, nbMaxBits) = self.size

        nbBitsData = len(data)

        if nbMinBits is not None and nbMinBits > nbBitsData:
            return False
        if nbMaxBits is not None and nbMaxBits < nbBitsData:
            return False

        return True

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def decode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """This method convert the specified data in python raw format.

        >>> from netzob.all import *
        >>> from netzob.Common.Models.Types.BitArray import BitArray
        >>> d = ASCII.decode("hello netzob")
        >>> r = BitArray.encode(d)
        >>> print r.to01()
        011010000110010101101100011011000110111100100000011011100110010101110100011110100110111101100010
        >>> t = BitArray.decode(r)
        >>> print t
        hello netzob


        :param data: the data encoded in BitArray which will be decoded in raw
        :type data: bitarray
        :keyword unitSize: the unit size of the specified data
        :type unitSize: :class:`netzob.Common.Models.Types.UnitSize.UnitSize`
        :keyword endianness: the endianness of the specified data
        :type endianness: :class:`netzob.Common.Models.Types.Endianness.Endianness`
        :keyword sign: the sign of the specified data
        :type sign: :class:`netzob.Common.Models.Types.Sign.Sign`

        :return: data encoded in python raw
        :rtype: python raw
        :raise: TypeError if parameters are not valid.
        """
        if data is None:
            raise TypeError("data cannot be None")
        return data.tobytes()

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def canParse(self, data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """This method returns True if data is an ASCII (utf-8)

        >>> from netzob.all import *
        >>> ASCII().canParse(TypeConverter.convert("hello netzob", ASCII, BitArray))
        True

        The ascii table is defined from 0 to 127:
        >>> ASCII().canParse(TypeConverter.convert(128, Integer, BitArray, src_sign=AbstractType.SIGN_UNSIGNED))
        False

        >>> a = ASCII(nbChars=10)
        >>> a.canParse(TypeConverter.convert("hellohello", ASCII, BitArray))
        True
        >>> a.canParse(TypeConverter.convert("hello hello", ASCII, BitArray))
        False

        >>> a = ASCII(nbChars=(2,20))
        >>> a.canParse(TypeConverter.convert("Netzob", ASCII, BitArray))
        True
        >>> a.canParse(TypeConverter.convert("Hello netzob, what's up ?", ASCII, BitArray))
        False

        :param data: the data to check
        :type data: python raw
        :return: True if data can be parsed as an ASCII
        :rtype: bool
        :raise: TypeError if the data is None
        """

        if data is None:
            raise TypeError("data cannot be None")

        if len(data) == 0:
            return False

        # Ascii must be 8 bits modulo length
        if len(data) % 8 != 0:
            return False

        rawData = data.tobytes()

        try:
            rawData.encode('utf-8')
        except:
            return False

        (minChar, maxChar) = self.nbChars
        if minChar is not None:
            if len(rawData) < minChar:
                return False
        if maxChar is not None:
            if len(rawData) > maxChar:
                return False

        return True

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def __init__(self, value=None, interval=None, nbUnits=None, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        if value is not None and not isinstance(value, bitarray):
            from netzob.Common.Models.Types.TypeConverter import TypeConverter
            from netzob.Common.Models.Types.BitArray import BitArray
            interval = value
            value = TypeConverter.convert(value, Decimal, BitArray, src_unitSize=unitSize, src_endianness=endianness, src_sign=sign, dst_unitSize=unitSize, dst_endianness=endianness, dst_sign=sign)
        else:
            value = None

        if interval is not None:
            nbBits = int(self._computeNbUnitSizeForInterval(interval, unitSize, sign)) * int(unitSize)
        elif nbUnits is not None:
            nbBits = nbUnits * int(unitSize)
        else:
            nbBits = int(unitSize)

        super(Decimal, self).__init__(self.__class__.__name__, value, nbBits, unitSize=unitSize, endianness=endianness, sign=sign)

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def encode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """This method convert the python raw data to the Decimal.

        >>> from netzob.all import *

        >>> raw = Decimal.decode(23)
        >>> print Decimal.encode(raw)
        23

        >>> raw = Decimal.decode(1200, unitSize=AbstractType.UNITSIZE_16)
        >>> print Decimal.encode(raw, unitSize=AbstractType.UNITSIZE_16)
        1200

        >>> raw = Decimal.decode(25, unitSize=AbstractType.UNITSIZE_16, endianness=AbstractType.ENDIAN_LITTLE)
        >>> print repr(Decimal.encode(raw, unitSize=AbstractType.UNITSIZE_16, endianness=AbstractType.ENDIAN_BIG))
        6400
        >>> print repr(Decimal.encode(raw, unitSize=AbstractType.UNITSIZE_16, endianness=AbstractType.ENDIAN_LITTLE))
        25

        >>> print Decimal.encode('\xcc\xac\x9c\x0c\x1c\xacL\x1c,\xac', unitSize=AbstractType.UNITSIZE_8)
        -395865088909314208584756

        :param data: the data encoded in python raw which will be encoded in current type
        :type data: python raw
        :keyword unitSize: the unitsize to consider while encoding. Values must be one of AbstractType.UNITSIZE_*
        :type unitSize: str
        :keyword endianness: the endianness to consider while encoding. Values must be AbstractType.ENDIAN_BIG or AbstractType.ENDIAN_LITTLE
        :type endianness: str
        :keyword sign: the sign to consider while encoding Values must be AbstractType.SIGN_SIGNED or AbstractType.SIGN_UNSIGNED
        :type sign: str

        :return: data encoded in python raw
        :rtype: python raw
        :raise: TypeError if parameters are not valid.
        """
        if data is None:
            raise TypeError("data cannot be None")

        perWordFormat = Decimal.computeFormat(unitSize, endianness, sign)

        nbWords = (len(data) * 8 / int(unitSize))

        finalValue = 0

        iWord = 0
        start = 0
        end = nbWords
        inc = 1
        if endianness == AbstractType.ENDIAN_BIG:
            end = 0
            start = nbWords
            inc = -1

        for i in range(start, end, inc):
            # Extract the portion that represents the current word
            startPos = iWord * int(unitSize) / 8
            endPos = iWord * int(unitSize) / 8 + int(unitSize) / 8

            wordData = data[startPos:endPos]
            unpackedWord = struct.unpack(perWordFormat, wordData)[0]

            unpackedWord = unpackedWord << int(unitSize) * iWord
            finalValue = finalValue + unpackedWord

            iWord += 1

        return finalValue

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def decode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """This method convert the specified data in python raw format.

        >>> from netzob.all import *
        >>> print Decimal.decode(23)
        \x17

        >>> print Decimal.decode(-1, sign=AbstractType.SIGN_UNSIGNED)
        Traceback (most recent call last):
        ...
        error: ubyte format requires 0 <= number <= 255

        >>> print Decimal.decode(-1, sign=AbstractType.SIGN_SIGNED)
        \xff

        >>> print Decimal.decode(2000000000000000)
        Traceback (most recent call last):
        ...
        error: byte format requires -128 <= number <= 127

        >>> print Decimal.decode(2000000000000000, unitSize=AbstractType.UNITSIZE_64)
        \x00\x07\x1a\xfdI\x8d\x00\x00

        >>> print Decimal.decode(25, unitSize=AbstractType.UNITSIZE_16, endianness=AbstractType.ENDIAN_LITTLE)
        \x19\x00
        >>> print Decimal.decode(25, unitSize=AbstractType.UNITSIZE_16, endianness=AbstractType.ENDIAN_BIG)
        \x00\x19

        >>> val = 167749568
        >>> a = Decimal.decode(val, unitSize=AbstractType.UNITSIZE_32)
        >>> b = Decimal.encode(a, unitSize=AbstractType.UNITSIZE_32)
        >>> b == val
        True


        :param data: the data encoded in Decimal which will be decoded in raw
        :type data: the current type
        :keyword unitSize: the unitsize to consider while encoding. Values must be one of AbstractType.UNITSIZE_*
        :type unitSize: str
        :keyword endianness: the endianness to consider while encoding. Values must be AbstractType.ENDIAN_BIG or AbstractType.ENDIAN_LITTLE
        :type endianness: str
        :keyword sign: the sign to consider while encoding Values must be AbstractType.SIGN_SIGNED or AbstractType.SIGN_UNSIGNED
        :type sign: str

        :return: data encoded in python raw
        :rtype: python raw
        :raise: TypeError if parameters are not valid.
        """
        if data is None:
            raise TypeError("data cannot be None")

        f = Decimal.computeFormat(unitSize, endianness, sign)
        return struct.pack(f, int(data))

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def canParse(self, data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """This method returns True if data is a Decimal.
        For the moment its always true because we consider
        the decimal type to be very similar to the raw type.

        >>> from netzob.all import *
        >>> Decimal().canParse(TypeConverter.convert("hello netzob", ASCII, Raw))
        True

        :param data: the data to check
        :type data: python raw
        :return: True if data is can be parsed as a Decimal
        :rtype: bool
        :raise: TypeError if the data is None
        """

        if data is None:
            raise TypeError("data cannot be None")

        if len(data) == 0:
            return False

        return True

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def __init__(self, value=None, network=None, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """Builds an IPv4 domain with optional constraints.

        :parameter value: specify a constraints over the expected value.
        :type value: an str, an IPAddress or an int which can be parsed as an IPv4 (ex. "192.168.0.10")
        :parameter network: if no value is specified (None), a constraints over the network the parsed IP belongs can be specified with this parameter (ex. "192.168.0.0/24")
        :type network: an str or an IPAddress which can be parsed as a network IPv4
        """

        if value is not None and not isinstance(value, bitarray):
            from netzob.Common.Models.Types.TypeConverter import TypeConverter
            from netzob.Common.Models.Types.BitArray import BitArray
            value = TypeConverter.convert(value, IPv4, BitArray, src_unitSize=unitSize, src_endianness=endianness, src_sign=sign, dst_unitSize=unitSize, dst_endianness=endianness, dst_sign=sign)

        self.network = network

        super(IPv4, self).__init__(self.__class__.__name__, value, 32, unitSize=unitSize, endianness=endianness, sign=sign)

# 需要导入模块: from netzob.Common.Models.Types.AbstractType import AbstractType [as 别名]
# 或者: from netzob.Common.Models.Types.AbstractType.AbstractType import defaultSign [as 别名]
    def encode(data, unitSize=AbstractType.defaultUnitSize(), endianness=AbstractType.defaultEndianness(), sign=AbstractType.defaultSign()):
        """Encodes the specified data into an IPAddress object

        :param data: the data to encode into an IPAddress
        :type data: str or raw bytes (BBBB)
        :return: the encoded IPAddress
        """
        if isinstance(data, (str, int)):
            try:
                ip = IPAddress(data)
                if ip is not None and ip.version == 4 and not ip.is_netmask():
                    return ip
            except:
                pass
        try:

            structFormat = ">"
            if endianness == AbstractType.ENDIAN_BIG:
                structFormat = ">"

            if not sign == AbstractType.SIGN_SIGNED:
                structFormat += "bbbb"
            else:
                structFormat += "BBBB"
            quads = map(str, struct.unpack(structFormat, data))
            strIP = string.join(quads, '.')

            ip = IPAddress(strIP)
            if ip is not None and ip.version == 4 and not ip.is_netmask():
                return ip
        except Exception, e:
            raise TypeError("Impossible encode {0} into an IPv4 data ({1})".format(data, e))