Added support for versions and domain changes in v4

Author: clittle

layers/README.md

@@ -12,7 +12,7 @@ This folder contains modules and scripts for working with ATT&CK Navigator layer
 | [legenditem](core/legenditem.py) | Implements a basic [legenditem object](https://github.com/mitre-attack/attack-navigator/blob/develop/layers/LAYERFORMATv3.md#legenditem-object-properties). |
 | [metadata](core/metadata.py) | Implements a basic [metadata object](https://github.com/mitre-attack/attack-navigator/blob/develop/layers/LAYERFORMATv3.md#metadata-object-properties). |
 | [technique](core/technique.py) | Implements a basic [technique object](https://github.com/mitre-attack/attack-navigator/blob/develop/layers/LAYERFORMATv3.md#technique-object-properties). |
-
+| [version](core/versions.py) | Impelments a basic [version object]().|
 #### Manipulator Scripts
 | script | description |
 |:-------|:------------|
@@ -36,7 +36,7 @@ This folder contains modules and scripts for working with ATT&CK Navigator layer
 | [layerExporter_cli.py](layerExporter_cli.py) | A commandline utility to export Layer files to excel or svg formats using the exporter tools. Run with `-h` for usage. |
 
 ## Layer
-The Layer class provides format validation and read/write capabilities to aid in working with ATT&CK Navigator Layers in python. It is the primary interface through which other Layer-related classes defined in the core module should be used. The Layer class API and a usage example are below.
+The Layer class provides format validation and read/write capabilities to aid in working with ATT&CK Navigator Layers in python. It is the primary interface through which other Layer-related classes defined in the core module should be used. The Layer class API and a usage example are below. The class currently supports version 3 and 4 of the ATT&CK Layer spec, and will upgrade version 3 layers into compatible version 4 ones whenever possible.
 
 | method [x = Layer()]| description |
 |:-------|:------------|
@@ -56,6 +56,14 @@ example_layer_dict = {
     "domain": "mitre-enterprise"
 }
 
+example_layer4_dict = {
+    "name": "layer v4 example",
+    "versions" : {
+        "layer" : "4.0"
+    },
+    "domain": "enterprise-attack"
+}
+
 example_layer_location = "/path/to/layer/file.json"
 example_layer_out_location = "/path/to/new/layer/file.json"
 
@@ -65,7 +73,7 @@ layer1 = Layer(example_layer_dict)              # Create a new layer and load ex
 layer1.to_file(example_layer_out_location)  # Write out the loaded layer to the specified file
 
 layer2 = Layer()                                # Create a new layer object
-layer2.from_dict(example_layer_dict)           # Load layer data into existing layer object
+layer2.from_dict(example_layer4_dict)           # Load layer data into existing layer object
 print(layer2.to_dict())                        # Retrieve the loaded layer's data as a dictionary, and print it
 
 layer3 = Layer()                                # Create a new layer object

layers/core/filter.py

@@ -46,8 +46,9 @@ def get_dict(self):
             if entry == 'domain':
                 continue
             if listing[entry] != UNSETVALUE:
-                temp[entry.split(type(self).__name__ + '__')[-1]] \
-                    = listing[entry]
+                subname = entry.split('__')[-1]
+                if subname != 'stages':
+                    temp[subname] = listing[entry]
         if len(temp) > 0:
             return temp
 

layers/core/layer.py

@@ -75,7 +75,17 @@ def _build(self):
             Loads the data stored in self.data into a LayerObj (self.layer)
         """
         try:
-            self.__layer = _LayerObj(self._data['version'], self._data['name'],
+            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'])
         except BadType or BadInput as e:
             handler(type(self).__name__, 'Layer is malformed: {}. '
@@ -89,7 +99,7 @@ def _build(self):
             return
 
         for key in self._data:
-            if key not in ['version', 'name', 'domain']:
+            if key not in ['version', 'versions', 'name', 'domain']:
                 try:
                     self.__layer._linker(key, self._data[key])
                 except Exception as e:

layers/core/layerobj.py

@@ -5,6 +5,7 @@
     from ..core.gradient import Gradient
     from ..core.legenditem import LegendItem
     from ..core.metadata import Metadata
+    from ..core.versions import Versions
     from ..core.exceptions import UNSETVALUE, typeChecker, BadInput, handler, \
         categoryChecker, UnknownLayerProperty
 except ValueError:
@@ -14,11 +15,12 @@
     from core.gradient import Gradient
     from core.legenditem import LegendItem
     from core.metadata import Metadata
+    from core.versions import Versions
     from core.exceptions import UNSETVALUE, typeChecker, BadInput, handler, \
         categoryChecker, UnknownLayerProperty
 
 class _LayerObj:
-    def __init__(self, version, name, domain):
+    def __init__(self, versions, name, domain):
         """
             Initialization - Creates a layer object
 
@@ -27,7 +29,7 @@ def __init__(self, version, name, domain):
             :param domain: The domain for this layer (mitre-enterprise
                 or mitre-mobile)
         """
-        self.version = version
+        self.versions = versions
         self.name = name
         self.__description = UNSETVALUE
         self.domain = domain
@@ -46,13 +48,28 @@ def __init__(self, version, name, domain):
 
     @property
     def version(self):
-        return self.__version
+        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")
-        self.__version = version
+        self.__versions.layer = version
+
+    @property
+    def versions(self):
+        return self.__versions
+
+    @versions.setter
+    def versions(self, versions):
+        typeChecker(type(self).__name__, versions, dict, "version")
+        attack = None
+        nav = None
+        if 'attack' in versions:
+            attack = versions['attack']
+        if 'navigator' in versions:
+            nav = versions['navigator']
+        self.__versions = Versions(versions['layer'], attack, nav)
 
     @property
     def name(self):
@@ -70,8 +87,11 @@ def domain(self):
     @domain.setter
     def domain(self, domain):
         typeChecker(type(self).__name__, domain, str, "domain")
-        categoryChecker(type(self).__name__, domain, ["mitre-enterprise",
-                                                      "mitre-mobile"],
+        dom = domain
+        if dom.startswith('mitre'):
+            dom = dom.split('-')[-1] + '-attack'
+        categoryChecker(type(self).__name__, dom, ["enterprise-attack",
+                                                      "mobile-attack"],
                         "domain")
         self.__domain = domain
 
@@ -301,7 +321,7 @@ 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, version=self.version, domain=self.domain)
+        temp = dict(name=self.name, versions=self.versions.get_dict(), domain=self.domain)
 
         if self.description:
             temp['description'] = self.description

layers/core/versions.py

@@ -0,0 +1,59 @@
+try:
+    from ..core.exceptions import typeChecker, categoryChecker, UNSETVALUE
+except ValueError:
+    from core.exceptions import typeChecker, categoryChecker, UNSETVALUE
+
+
+class Versions:
+    def __init__(self, layer="4.0", attack=UNSETVALUE, navigator=UNSETVALUE):
+        """
+            Initialization - Creates a v4 Versions object
+
+            :param layer: The layer version
+            :param attack: The attack version
+            :param navigator: The navigator version
+        """
+        self.layer = layer
+        self.attack = attack
+        self.navigator = navigator
+
+    @property
+    def attack(self):
+        return self.__attack
+
+    @attack.setter
+    def attack(self, attack):
+        typeChecker(type(self).__name__, attack, str, "attack")
+        self.__attack = attack
+
+    @property
+    def navigator(self):
+        return self.__navigator
+
+    @navigator.setter
+    def navigator(self, navigator):
+        typeChecker(type(self).__name__, navigator, str, "navigator")
+        self.__navigator = navigator
+
+    @property
+    def layer(self):
+        return self.__layer
+
+    @layer.setter
+    def layer(self, layer):
+        typeChecker(type(self).__name__, layer, str, "layer")
+        categoryChecker(type(self).__name__, layer, ["3.0", "4.0"], "version")
+        self.__layer = layer
+
+    def get_dict(self):
+        """
+            Converts the currently loaded data into a dict
+            :returns: A dict representation of the local Versions object
+        """
+        temp = dict()
+        listing = vars(self)
+        for entry in listing:
+            if listing[entry] != UNSETVALUE:
+                subname = entry.split('__')[-1]
+                temp[subname] = listing[entry]
+        return temp