Updated to full v4 spec, improved handling for load errors

Author: clittle

layers/core/exceptions.py

@@ -21,6 +21,9 @@ class UnknownTechniqueProperty(Exception):
     pass
 
 
+class MissingParameters(Exception):
+    pass
+
 def handler(caller, msg):
     """
         Prints a debug/warning/error message
@@ -85,3 +88,20 @@ def categoryChecker(caller, testee, valid, field):
     if testee not in valid:
         handler(caller, '{} not a valid value for {}'.format(testee, field))
         raise BadInput
+
+def loadChecker(caller, testee, required, field):
+    """
+        Verifies that the tested object contains all required fields
+        :param caller: the entity that called this function (used for error
+            messages)
+        :param testee: the element to test
+        :param requireds: a list of required values for the testee
+        :param field: what the element is to be used as (used for error
+            messages)
+        :raises BadInput: error denoting the testee element is not one of
+            the valid options
+    """
+    for entry in required:
+        if entry not in testee:
+            handler(caller, '{} is not present in {} [{}]'.format(entry, field, testee))
+            raise MissingParameters

layers/core/layer.py

@@ -75,18 +75,7 @@ def _build(self):
             Loads the data stored in self.data into a LayerObj (self.layer)
         """
         try:
-            if 'version' in self._data:
-                ver_obj = dict(layer=self._data['version'])
-            else:
-                ver_obj = self._data['versions']
-        except:
-            handler(type(self).__name__, 'Layer version is malformed. '
-                                         'Unable to load')
-            self.__layer = None
-            return
-        try:
-            self.__layer = _LayerObj(ver_obj, self._data['name'],
-                                    self._data['domain'])
+            self.__layer = _LayerObj(self._data['name'],  self._data['domain'])
         except BadType or BadInput as e:
             handler(type(self).__name__, 'Layer is malformed: {}. '
                                          'Unable to load.'.format(e))
@@ -99,7 +88,7 @@ def _build(self):
             return
 
         for key in self._data:
-            if key not in ['version', 'versions', 'name', 'domain']:
+            if key not in ['name', 'domain']:
                 try:
                     self.__layer._linker(key, self._data[key])
                 except Exception as e:

layers/core/layerobj.py

@@ -7,7 +7,7 @@
     from ..core.metadata import Metadata
     from ..core.versions import Versions
     from ..core.exceptions import UNSETVALUE, typeChecker, BadInput, handler, \
-        categoryChecker, UnknownLayerProperty
+        categoryChecker, UnknownLayerProperty, loadChecker, MissingParameters
 except ValueError:
     from core.filter import Filter
     from core.layout import Layout
@@ -17,19 +17,18 @@
     from core.metadata import Metadata
     from core.versions import Versions
     from core.exceptions import UNSETVALUE, typeChecker, BadInput, handler, \
-        categoryChecker, UnknownLayerProperty
+        categoryChecker, UnknownLayerProperty, loadChecker, MissingParameters
 
 class _LayerObj:
-    def __init__(self, versions, name, domain):
+    def __init__(self, name, domain):
         """
             Initialization - Creates a layer object
 
-            :param version: The corresponding att&ck layer version
             :param name: The name for this layer
-            :param domain: The domain for this layer (mitre-enterprise
-                or mitre-mobile)
+            :param domain: The domain for this layer (enterprise-attack
+                or mobile-attack)
         """
-        self.versions = versions
+        self.__versions = UNSETVALUE
         self.name = name
         self.__description = UNSETVALUE
         self.domain = domain
@@ -48,28 +47,35 @@ def __init__(self, versions, name, domain):
 
     @property
     def version(self):
-        return self.__versions.layer
+        if self.__versions != UNSETVALUE:
+            return self.__versions.layer
 
     @version.setter
     def version(self, version):
         typeChecker(type(self).__name__, version, str, "version")
         categoryChecker(type(self).__name__, version, ["3.0", "4.0"], "version")
+        if self.__versions is UNSETVALUE:
+            self.__versions = Versions()
         self.__versions.layer = version
 
     @property
     def versions(self):
-        return self.__versions
+        if self.__versions != UNSETVALUE:
+            return self.__versions
 
     @versions.setter
     def versions(self, versions):
         typeChecker(type(self).__name__, versions, dict, "version")
-        attack = None
-        nav = None
+        attack = UNSETVALUE
         if 'attack' in versions:
             attack = versions['attack']
-        if 'navigator' in versions:
-            nav = versions['navigator']
-        self.__versions = Versions(versions['layer'], attack, nav)
+        try:
+            loadChecker(type(self).__name__, versions, ['layer', 'navigator'], "versions")
+            self.__versions = Versions(versions['layer'], attack, versions['navigator'])
+        except MissingParameters as e:
+            handler(type(self).__name__, 'versions {} is missing parameters: '
+                                         '{}. Skipping.'
+                    .format(versions, e))
 
     @property
     def name(self):
@@ -112,20 +118,16 @@ def filters(self):
 
     @filters.setter
     def filters(self, filters):
-        if self.version == "4.0":
-            temp = Filterv4(self.domain)
-        else:
-            temp = Filter(self.domain)
+        temp = Filterv4(self.domain)
         try:
-            if self.version != "4.0":
-                temp.stages = filters['stages']
+            loadChecker(type(self).__name__, filters, ['platforms'], "filters")
+            # force upgrade to v4
             temp.platforms = filters['platforms']
             self.__filters = temp
-        except KeyError as e:
-            handler(type(self).__name__, "Unable to properly extract "
-                                         "information from filter: {}."
-                    .format(e))
-            raise BadInput
+        except MissingParameters as e:
+            handler(type(self).__name__, 'Filters {} is missing parameters: '
+                                         '{}. Skipping.'
+                    .format(filters, e))
 
     @property
     def sorting(self):
@@ -173,17 +175,17 @@ def techniques(self):
     def techniques(self, techniques):
         typeChecker(type(self).__name__, techniques, list, "techniques")
         self.__techniques = []
-        entry = ""
-        try:
-            for entry in techniques:
+
+        for entry in techniques:
+            try:
+                loadChecker(type(self).__name__, entry, ['techniqueID'], "technique")
                 temp = Technique(entry['techniqueID'])
                 temp._loader(entry)
                 self.__techniques.append(temp)
-        except KeyError as e:
-            handler(type(self).__name__, "Unable to properly extract "
-                                         "information from technique {}: {}."
-                    .format(entry, e))
-            raise BadInput
+            except MissingParameters as e:
+                handler(type(self).__name__, 'Technique {} is missing parameters: '
+                                             '{}. Skipping.'
+                        .format(entry, e))
 
     @property
     def gradient(self):
@@ -193,12 +195,12 @@ def gradient(self):
     @gradient.setter
     def gradient(self, gradient):
         try:
-            self.__gradient = Gradient(gradient['colors'],
-                                       gradient['minValue'],
-                                       gradient['maxValue'])
-        except KeyError as e:
-            handler(type(self).__name__, 'Gradient is missing parameters: {}. '
-                                         'Unable to load.'.format(e))
+            loadChecker(type(self).__name__, gradient, ['colors', 'minValue', 'maxValue'], "gradient")
+            self.__gradient = Gradient(gradient['colors'], gradient['minValue'], gradient['maxValue'])
+        except MissingParameters as e:
+            handler(type(self).__name__, 'Gradient {} is missing parameters: '
+                                         '{}. Skipping.'
+                    .format(gradient, e))
 
     @property
     def legendItems(self):
@@ -209,15 +211,15 @@ def legendItems(self):
     def legendItems(self, legendItems):
         typeChecker(type(self).__name__, legendItems, list, "legendItems")
         self.__legendItems = []
-        entry = ""
-        try:
-            for entry in legendItems:
+        for entry in legendItems:
+            try:
+                loadChecker(type(self).__name__, entry, ['label', 'color'], "legendItem")
                 temp = LegendItem(entry['label'], entry['color'])
                 self.__legendItems.append(temp)
-        except KeyError as e:
-            handler(type(self).__name__, 'LegendItem {} is missing parameters:'
-                                         ' {}. Unable to load.'
-                    .format(entry, e))
+            except MissingParameters as e:
+                handler(type(self).__name__, 'Legend Item {} is missing parameters: '
+                                             '{}. Skipping.'
+                        .format(entry, e))
 
     @property
     def showTacticRowBackground(self):
@@ -272,13 +274,13 @@ def metadata(self):
     def metadata(self, metadata):
         typeChecker(type(self).__name__, metadata, list, "metadata")
         self.__metadata = []
-        entry = ""
-        try:
-            for entry in metadata:
+        for entry in metadata:
+            try:
+                loadChecker(type(self).__name__, entry, ['name', 'value'], "metadata")
                 self.__metadata.append(Metadata(entry['name'], entry['value']))
-        except KeyError as e:
-            handler(type(self).__name__, 'Metadata {} is missing parameters: '
-                                         '{}. Unable to load.'
+            except MissingParameters as e:
+                handler(type(self).__name__, 'Metadata {} is missing parameters: '
+                                         '{}. Skipping.'
                     .format(entry, e))
 
     def _enumerate(self):
@@ -321,10 +323,12 @@ def get_dict(self):
             Converts the currently loaded layer into a dict
             :returns: A dict representation of the current layer object
         """
-        temp = dict(name=self.name, versions=self.versions.get_dict(), domain=self.domain)
+        temp = dict(name=self.name, domain=self.domain)
 
         if self.description:
             temp['description'] = self.description
+        if self.versions:
+            temp['versions'] = self.versions.get_dict()
         if self.filters:
             temp['filters'] = self.filters.get_dict()
         if self.sorting:
@@ -364,6 +368,13 @@ def _linker(self, field, data):
         """
         if field == 'description':
             self.description = data
+        elif field.startswith('version'):
+            if not field.endswith('s'):
+                # force upgrade
+                ver_obj = dict(layer="4.0", navigator="4.0")
+                self.versions = ver_obj
+            else:
+                self.versions = data
         elif field == 'filters':
             self.filters = data
         elif field == 'sorting':

layers/core/versions.py

@@ -5,7 +5,7 @@
 
 
 class Versions:
-    def __init__(self, layer="4.0", attack=UNSETVALUE, navigator=UNSETVALUE):
+    def __init__(self, layer="4.0", attack=UNSETVALUE, navigator="4.0"):
         """
             Initialization - Creates a v4 Versions object
 
@@ -14,7 +14,7 @@ def __init__(self, layer="4.0", attack=UNSETVALUE, navigator=UNSETVALUE):
             :param navigator: The navigator version
         """
         self.layer = layer
-        self.attack = attack
+        self.__attack = attack
         self.navigator = navigator
 
     @property
@@ -33,6 +33,7 @@ def navigator(self):
     @navigator.setter
     def navigator(self, navigator):
         typeChecker(type(self).__name__, navigator, str, "navigator")
+        categoryChecker(type(self).__name__, navigator, ["4.0"], "navigator version")
         self.__navigator = navigator
 
     @property
@@ -42,7 +43,10 @@ def layer(self):
     @layer.setter
     def layer(self, layer):
         typeChecker(type(self).__name__, layer, str, "layer")
-        categoryChecker(type(self).__name__, layer, ["3.0", "4.0"], "version")
+        categoryChecker(type(self).__name__, layer, ["3.0", "4.0"], "layer version")
+        if layer == '3.0':
+            print('[NOTICE] - Forcibly upgrading version from {} to 4.0.'.format(layer))
+            layer = "4.0"
         self.__layer = layer
 
     def get_dict(self):

layers/exporters/svg_templates.py

@@ -8,13 +8,13 @@
     from exporters.svg_objects import G, SVG_HeaderBlock, SVG_Technique, Text, convertToPx,_optimalFontSize, \
         _getstringwidth
     from core.gradient import Gradient
-    from core.filter import Filter
+    from core.filter import Filterv4
 except ModuleNotFoundError:
     from ..exporters.matrix_gen import MatrixGen
     from ..exporters.svg_objects import G, SVG_HeaderBlock, SVG_Technique, Text, convertToPx, _optimalFontSize, \
         _getstringwidth
     from ..core.gradient import Gradient
-    from ..core.filter import Filter
+    from ..core.filter import Filterv4
 
 
 class BadTemplateException(Exception):
@@ -91,11 +91,10 @@ def _build_headers(self, name, config, desc=None, filters=None, gradient=None):
                 if config.showFilters:
                     fi = filters
                     if fi is None:
-                        fi = Filter()
+                        fi = Filterv4()
                         fi.platforms = ["Windows", "Linux",	"macOS"]
-                        fi.stages = ["act"]
                     g2 = SVG_HeaderBlock().build(height=header_height, width=header_width, label='filters',
-                                             t1text=', '.join(fi.platforms), t2text=fi.stages[0], config=config)
+                                             t1text=', '.join(fi.platforms), config=config)
                     b2 = G(tx=operation_x / header_count * psych + 1.5 * border * psych)
                     header.append(b2)
                     b2.append(g2)