Merge branch '59-http-header-content-security-policy'

Closes: #59

Author: c0r0n3r

cryptoparser/common/base.py

@@ -279,7 +279,7 @@ def as_markdown(self):
 
 
 @attr.s
-class VariantParsable(ParsableBase):
+class VariantParsableBase(ParsableBase):
     variant = attr.ib()
 
     _REGISTERED_VARIANTS = OrderedDict()
@@ -324,6 +324,21 @@ def register_variant_parser(cls, variant_tag, parsable_class):
 
         registered_variants[variant_tag].append(parsable_class)
 
+    @classmethod
+    @abc.abstractmethod
+    def _parse(cls, parsable):
+        raise NotImplementedError()
+
+    def compose(self):
+        return self.variant.compose()
+
+
+class VariantParsable(VariantParsableBase):
+    @classmethod
+    @abc.abstractmethod
+    def _get_variants(cls):
+        raise NotImplementedError()
+
     @classmethod
     def _parse(cls, parsable):
         for variant_parser in cls._get_variant_types():
@@ -335,8 +350,23 @@ def _parse(cls, parsable):
 
         raise InvalidValue(parsable, cls)
 
-    def compose(self):
-        return self.variant.compose()
+
+class VariantParsableExact(VariantParsableBase):
+    @classmethod
+    @abc.abstractmethod
+    def _get_variants(cls):
+        raise NotImplementedError()
+
+    @classmethod
+    def _parse(cls, parsable):
+        for variant_parser in cls._get_variant_types():
+            try:
+                parsed_object = variant_parser.parse_exact_size(parsable)
+                return parsed_object, len(parsable)
+            except (InvalidType, InvalidValue, TooMuchData):
+                pass
+
+        raise InvalidValue(parsable, cls)
 
 
 @attr.s
@@ -825,7 +855,7 @@ def _parse(cls, parsable):
         enum_items.sort(key=lambda color: len(color.value.code), reverse=True)
 
         try:
-            code = six.ensure_text(parsable, 'ascii')
+            code = six.ensure_text(bytes(parsable), 'ascii')
         except UnicodeDecodeError as e:
             six.raise_from(InvalidValue(parsable, cls), e)
 

cryptoparser/common/field.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=too-many-lines
 
 import abc
 import collections
 import datetime
+import enum
 import json
 
 import attr
@@ -791,6 +793,63 @@ def _get_header_value_list_class(cls):
         return NameValuePairListSemicolonSeparated
 
 
+class MimeTypeRegistry(enum.Enum):
+    APPLICATION = 'application'
+    AUDIO = 'audio'
+    FONT = 'font'
+    EXAMPLE = 'example'
+    IMAGE = 'image'
+    MESSAGE = 'message'
+    MODEL = 'model'
+    MULTIPART = 'multipart'
+    TEXT = 'text'
+    VIDEO = 'video'
+
+
+@attr.s
+class FieldValueMimeType(FieldValueComponentBase):
+    type = attr.ib(
+        validator=attr.validators.instance_of(six.string_types),
+        default=None,
+    )
+    registry = attr.ib(
+        validator=attr.validators.optional(attr.validators.instance_of(MimeTypeRegistry)),
+        default=None,
+    )
+
+    def __str__(self):
+        return '{}/{}'.format(self.registry.value, self.type)
+
+    @property
+    def value(self):
+        return self
+
+    @classmethod
+    def get_canonical_name(cls):
+        return ''
+
+    @classmethod
+    def _parse(cls, parsable):
+        parser = ParserText(parsable)
+
+        parser.parse_string_until_separator('registry', '/', item_class=MimeTypeRegistry)
+        parser.parse_separator('/')
+        parser.parse_string_by_length('type', parser.unparsed_length)
+
+        return FieldValueMimeType(**parser), parser.parsed_length
+
+    def compose(self):
+        composer = ComposerText()
+
+        composer.compose_string(str(self))
+
+        return composer.composed
+
+    @classmethod
+    def _check_name(cls, name):
+        pass
+
+
 @attr.s
 class FieldValueSingleBase(FieldValueBase, Serializable):
     value = attr.ib()
@@ -916,6 +975,32 @@ def _as_markdown(self, level):
         return self._markdown_result(self.value, level)
 
 
+class FieldValueStringBySeparatorBase(FieldValueSingleComplexBase):
+    @classmethod
+    @abc.abstractmethod
+    def _get_separators(cls):
+        raise NotImplementedError()
+
+    @classmethod
+    def _get_value_type(cls):
+        return six.string_types
+
+    @classmethod
+    def _parse(cls, parsable):
+        parser = ParserText(parsable)
+
+        parser.parse_string_until_separator_or_end('value', cls._get_separators())
+
+        return cls(parser['value']), parser.parsed_length
+
+    def compose(self):
+        composer = ComposerText()
+
+        composer.compose_string(self.value)
+
+        return composer.composed
+
+
 class FieldValueStringEnum(FieldValueSingleComplexBase):
     @classmethod
     @abc.abstractmethod

cryptoparser/common/parse.py

@@ -201,7 +201,7 @@ def _check_separators(  # pylint: disable=too-many-arguments
 
         return actual_offset - count_offset
 
-    def parse_separator(self, separator, min_length=1, max_length=1):
+    def parse_separator(self, separator, min_length=1, max_length=None):
         self._parsed_length += self._check_separators(
             'separator', self._parsed_length, separator, min_length, max_length
         )
@@ -405,15 +405,18 @@ def _parse_string_array(
                 name, item_offset, separator, str, None, True, separator_spaces
             )
             if parsed_length:
-                parsed_value = self._apply_item_class(
-                    name,
-                    item_offset,
-                    item_offset + parsed_length,
-                    separator,
-                    item_class,
-                    fallback_class,
-                    True
-                )
+                if isinstance(item_class, type) and issubclass(item_class, ParsableBase):
+                    parsed_value = item_class.parse_exact_size(parsed_value.encode(self._encoding))
+                else:
+                    parsed_value = self._apply_item_class(
+                        name,
+                        item_offset,
+                        item_offset + parsed_length,
+                        separator,
+                        item_class,
+                        fallback_class,
+                        True
+                    )
                 value.append(parsed_value)
                 item_offset += parsed_length
             elif not skip_empty: