Commit 09434fac authored by Szilárd Pfeiffer's avatar Szilárd Pfeiffer
Browse files

Merge branch '3-use-attrs-to-avoid-boilerplates' 

Closes: #3
parents 5ddc9d94 d719d8d2

cryptoparser/common/algorithm.py

+46 −17
Original line number Diff line number Diff line 
# -*- coding: utf-8 -*-



import enum

import collections

import attr



KeyExchangeParams = collections.namedtuple('KeyExchangeParams', ['name', 'fs', ])

AuthenticationParams = collections.namedtuple('AuthenticationParams', ['name', 'anonymous', ])

BlockCipherParams = collections.namedtuple('BlockCipherParams', ['name', 'key_size', 'block_size', ])

BlockCipherModeParams = collections.namedtuple('BlockCipherModeParams', ['name', ])

MACParams = collections.namedtuple('MACParams', ['name', 'digest_size', ])

NamedGroupParams = collections.namedtuple('NamedGroupParams', ['name', 'size', 'group_type', ])

CipherSuiteParams = collections.namedtuple('TlsCipherSuiteParams', ['key_exchange', ])



@attr.s(frozen=True)

class KeyExchangeParams(object):

    name = attr.ib(validator=attr.validators.instance_of(str))

    forward_secret = attr.ib(validator=attr.validators.instance_of(bool))





@attr.s(frozen=True)

class AuthenticationParams(object):

    name = attr.ib(validator=attr.validators.instance_of(str))

    anonymous = attr.ib(validator=attr.validators.instance_of(bool))





@attr.s(frozen=True)

class BlockCipherParams(object):

    name = attr.ib(validator=attr.validators.instance_of(str))

    key_size = attr.ib(validator=attr.validators.instance_of(int))

    block_size = attr.ib(validator=attr.validators.optional(attr.validators.instance_of(int)))





@attr.s(frozen=True)

class BlockCipherModeParams(object):

    name = attr.ib(validator=attr.validators.instance_of(str))





@attr.s(frozen=True)

class MACParams(object):

    name = attr.ib(validator=attr.validators.instance_of(str))

    digest_size = attr.ib(validator=attr.validators.instance_of(int))





@attr.s(frozen=True)

class NamedGroupParams(object):

    name = attr.ib(validator=attr.validators.instance_of(str))

    size = attr.ib(validator=attr.validators.instance_of(int))

    group_type = attr.ib()





class KeyExchange(enum.Enum):

    ADH = KeyExchangeParams(

        name='ADH',

        fs=False

        forward_secret=False

    )

    DH = KeyExchangeParams(  # pylint: disable=invalid-name

        name='DH',

        fs=False

        forward_secret=False

    )

    DHE = KeyExchangeParams(

        name='DHE',

        fs=True

        forward_secret=True

    )

    ECDH = KeyExchangeParams(

        name='ECDH',

        fs=False

        forward_secret=False

    )

    ECDHE = KeyExchangeParams(

        name='ECDHE',

        fs=True

        forward_secret=True

    )

    KRB5 = KeyExchangeParams(

        name='KRB5',

        fs=False

        forward_secret=False

    )

    PSK = KeyExchangeParams(

        name='PSK',

        fs=False

        forward_secret=False

    )

    RSA = KeyExchangeParams(

        name='RSA',

        fs=False

        forward_secret=False

    )

    SRP = KeyExchangeParams(

        name='SRP',

        fs=False

        forward_secret=False

    )

cryptoparser/common/base.py

+26 −25
Original line number Diff line number Diff line
@@ -12,6 +12,8 @@ except ImportError: # pragma: no cover 


from collections import OrderedDict



import attr



from cryptoparser.common.parse import ParsableBase, ParserBinary, ComposerBinary

from cryptoparser.common.exception import NotEnoughData, TooMuchData, InvalidValue
@@ -28,8 +30,8 @@ def _default( 
        self,  # pylint: disable=unused-argument

        obj

):

    if isinstance(obj, enum.Enum) and hasattr(obj.value, '_asdict'):

        result = {obj.name: obj.value._asdict()}

    if isinstance(obj, enum.Enum):

        result = {obj.name: attr.asdict(obj.value)}

    elif hasattr(obj, '_asdict'):

        result = obj._asdict()

    elif hasattr(obj, '__dict__'):
@@ -58,47 +60,50 @@ class Serializable(object): # pylint: disable=too-few-public-methods 
        return json.dumps(self._asdict())





@attr.s

class VectorParamBase(object):  # pylint: disable=too-few-public-methods

    def __init__(self, min_byte_num, max_byte_num):

        self.min_byte_num = min_byte_num

        self.max_byte_num = max_byte_num

    min_byte_num = attr.ib(validator=attr.validators.instance_of(int))

    max_byte_num = attr.ib(validator=attr.validators.instance_of(int))

    item_num_size = attr.ib(init=False, validator=attr.validators.instance_of(int))



    def __attrs_post_init__(self):

        self.item_num_size = int(math.log(self.max_byte_num, 2) / 8) + 1



        attr.validate(self)



    @abc.abstractmethod

    def get_item_size(self, item):

        raise NotImplementedError()





@attr.s

class VectorParamNumeric(VectorParamBase):  # pylint: disable=too-few-public-methods

    def __init__(self, item_size, min_byte_num, max_byte_num, numeric_class=int):

        super(VectorParamNumeric, self).__init__(min_byte_num, max_byte_num)



        self.item_size = item_size

        self.numeric_class = numeric_class

    item_size = attr.ib(validator=attr.validators.instance_of(int))

    numeric_class = attr.ib(default=int, validator=attr.validators.instance_of(type))



    def get_item_size(self, item):

        return self.item_size





@attr.s

class VectorParamParsable(VectorParamBase):  # pylint: disable=too-few-public-methods

    def __init__(self, item_class, min_byte_num, max_byte_num, fallback_class):

        super(VectorParamParsable, self).__init__(min_byte_num, max_byte_num)



        self.item_class = item_class

        self.fallback_class = fallback_class

    item_class = attr.ib(validator=attr.validators.instance_of(type))

    fallback_class = attr.ib(validator=attr.validators.optional(attr.validators.instance_of(type)))



    def get_item_size(self, item):

        return len(item.compose())





@attr.s

class VectorBase(ParsableBase, MutableSequence):

    def __init__(self, items):

        super(VectorBase, self).__init__()

    _items = attr.ib()

    _items_size = attr.ib(init=False, default=0)

    param = attr.ib(init=False, default=None)



        self.param = self.get_param()

    def __attrs_post_init__(self):

        items = self._items



        self._items_size = 0

        self.param = self.get_param()

        self._items = []



        for item in items:
@@ -107,6 +112,8 @@ class VectorBase(ParsableBase, MutableSequence): 


        self._update_items_size(del_item=None, insert_item=None)



        attr.validate(self)



    def _update_items_size(self, del_item=None, insert_item=None):

        size_diff = 0
@@ -127,9 +134,6 @@ class VectorBase(ParsableBase, MutableSequence): 
    def get_param(cls):

        raise NotImplementedError()



    def __repr__(self):

        return "<{0} {1}>".format(self.__class__.__name__, self._items)



    def __len__(self):

        return len(self._items)
@@ -148,9 +152,6 @@ class VectorBase(ParsableBase, MutableSequence): 
    def __str__(self):

        return str(self._items)



    def __eq__(self, other):

        return self._items == other._items  # pylint: disable=protected-access



    def insert(self, index, value):

        self._update_items_size(insert_item=value)

cryptoparser/common/exception.py

+8 −4
Original line number Diff line number Diff line 
# -*- coding: utf-8 -*-



import enum

import attr





@attr.s

class InvalidDataLength(Exception):

    def __init__(self, bytes_needed=None):

        super(InvalidDataLength, self).__init__()



        self.bytes_needed = bytes_needed

    bytes_needed = attr.ib(default=None, validator=attr.validators.optional(attr.validators.instance_of(int)))





@attr.s

class NotEnoughData(InvalidDataLength):

    pass





@attr.s

class TooMuchData(InvalidDataLength):

    pass





@attr.s(init=False)

class InvalidValue(Exception):

    value = attr.ib()



    def __init__(self, value, type_class, class_member=None):

        if isinstance(value, enum.IntEnum):

            message = hex(value.value)

cryptoparser/common/parse.py

+9 −8
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 


import abc

import struct

import attr



import six
@@ -41,7 +42,12 @@ class ParsableBase(object): 
        raise NotImplementedError()





@attr.s

class ParserBinary(object):

    _parsable = attr.ib(validator=attr.validators.instance_of((bytes, bytearray)))

    _parsed_length = attr.ib(init=False, default=0)

    _parsed_values = attr.ib(init=False, default=dict())



    _INT_FORMATER_BY_SIZE = {

        1: '!B',

        2: '!H',
@@ -49,11 +55,6 @@ class ParserBinary(object): 
        4: '!I',

    }



    def __init__(self, parsable):

        self._parsable = parsable

        self._parsed_length = 0

        self._parsed_values = dict()



    def __getitem__(self, key):

        return self._parsed_values[key]
@@ -161,7 +162,10 @@ class ParserBinary(object): 
        self._parsed_length += value_length





@attr.s

class ComposerBinary(object):

    _composed = attr.ib(init=False, default=bytes())



    _INT_FORMATER_BY_SIZE = {

        1: '!B',

        2: '!H',
@@ -169,9 +173,6 @@ class ComposerBinary(object): 
        4: '!I',

    }



    def __init__(self):

        self._composed = bytearray()



    def _compose_numeric_array(self, values, item_size):

        composed_bytes = bytearray()

cryptoparser/tls/ciphersuite.py

+351 −354

File changed.

Preview size limit exceeded, changes collapsed.