mal-toolbox 0.1.2__tar.gz → 0.1.4__tar.gz

{mal_toolbox-0.1.2/mal_toolbox.egg-info → mal_toolbox-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mal-toolbox
-Version: 0.1.2
+Version: 0.1.4
 Summary: A collection of tools used to create MAL models and attack graphs.
 Author-email: Andrei Buhaiu <buhaiu@kth.se>, Giuseppe Nebbione <nebbione@kth.se>, Nikolaos Kakouros <nkak@kth.se>, Jakob Nyberg <jaknyb@kth.se>, Joakim Loxdal <loxdal@kth.se>
 License: Apache Software License
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: py2neo>=2021.2.3
-Requires-Dist: python-jsonschema-objects>=0.4.1
+Requires-Dist: python-jsonschema-objects>=0.5.5
 Requires-Dist: antlr4-tools
 Requires-Dist: antlr4-python3-runtime
 Requires-Dist: docopt

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4/mal_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mal-toolbox
-Version: 0.1.2
+Version: 0.1.4
 Summary: A collection of tools used to create MAL models and attack graphs.
 Author-email: Andrei Buhaiu <buhaiu@kth.se>, Giuseppe Nebbione <nebbione@kth.se>, Nikolaos Kakouros <nkak@kth.se>, Jakob Nyberg <jaknyb@kth.se>, Joakim Loxdal <loxdal@kth.se>
 License: Apache Software License
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: py2neo>=2021.2.3
-Requires-Dist: python-jsonschema-objects>=0.4.1
+Requires-Dist: python-jsonschema-objects>=0.5.5
 Requires-Dist: antlr4-tools
 Requires-Dist: antlr4-python3-runtime
 Requires-Dist: docopt

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/mal_toolbox.egg-info/SOURCES.txt

@@ -26,7 +26,6 @@ maltoolbox/ingestors/neo4j.py
 maltoolbox/language/__init__.py
 maltoolbox/language/classes_factory.py
 maltoolbox/language/languagegraph.py
-maltoolbox/language/specification.py
 maltoolbox/language/compiler/__init__.py
 maltoolbox/language/compiler/mal_lexer.py
 maltoolbox/language/compiler/mal_parser.py

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/mal_toolbox.egg-info/requires.txt

@@ -1,5 +1,5 @@
 py2neo>=2021.2.3
-python-jsonschema-objects>=0.4.1
+python-jsonschema-objects>=0.5.5
 antlr4-tools
 antlr4-python3-runtime
 docopt

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/__init__.py

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-# MAL Toolbox v0.1.2
+# MAL Toolbox v0.1.4
 # Copyright 2024, Andrei Buhaiu.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,7 +21,7 @@ MAL-Toolbox Framework
 """
 
 __title__ = 'maltoolbox'
-__version__ = '0.1.2'
+__version__ = '0.1.4'
 __authors__ = ['Andrei Buhaiu',
     'Giuseppe Nebbione',
     'Nikolaos Kakouros',

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/attackgraph/attackgraph.py

@@ -10,7 +10,6 @@ from typing import TYPE_CHECKING
 from .node import AttackGraphNode
 from .attacker import Attacker
 from ..exceptions import AttackGraphStepExpressionError
-from ..language import specification
 from ..model import Model
 from ..exceptions import AttackGraphException
 from ..file_utils import (
@@ -37,7 +36,8 @@ def _process_step_expression(
     Recursively process an attack step expression.
 
     Arguments:
-    lang            - a dictionary representing the MAL language specification
+    lang_graph      - a language graph representing the MAL language
+                      specification
     model           - a maltoolbox.model.Model instance from which the attack
                       graph was generated
     target_assets   - the list of assets that this step expression should apply
@@ -150,11 +150,28 @@ def _process_step_expression(
                     step_expression['stepExpression'])
                 new_target_assets.extend(assets)
 
-            selected_new_target_assets = [asset for asset in \
-                new_target_assets if specification.extends_asset(
-                    lang_graph._lang_spec,
-                    asset.type,
-                    step_expression['subType'])]
+            selected_new_target_assets = []
+            for asset in new_target_assets:
+                lang_graph_asset = lang_graph.get_asset_by_name(
+                    asset.type
+                )
+                if not lang_graph_asset:
+                    raise LookupError(
+                        f'Failed to find asset \"{asset.type}\" in the '
+                        'language graph.'
+                    )
+                lang_graph_subtype_asset = lang_graph.get_asset_by_name(
+                    step_expression['subType']
+                )
+                if not lang_graph_subtype_asset:
+                    raise LookupError(
+                        'Failed to find asset '
+                        f'\"{step_expression["subType"]}\" in the '
+                        'language graph.'
+                    )
+                if lang_graph_asset.is_subasset_of(lang_graph_subtype_asset):
+                    selected_new_target_assets.append(asset)
+
             return (selected_new_target_assets, None)
 
         case 'collect':
@@ -225,17 +242,39 @@ class AttackGraph():
         """
 
         attack_graph = AttackGraph()
+        attack_graph.model = model
         serialized_attack_steps = serialized_object['attack_steps']
         serialized_attackers = serialized_object['attackers']
 
         # Create all of the nodes in the imported attack graph.
         for node_full_name, node_dict in serialized_attack_steps.items():
+
+            # Recreate asset links if model is available.
+            node_asset = None
+            if model and 'asset' in node_dict:
+                node_asset = model.get_asset_by_name(node_dict['asset'])
+                if node_asset is None:
+                    msg = ('Failed to find asset with id %s'
+                            'when loading from attack graph dict')
+                    logger.error(msg, node_dict["asset"])
+                    raise LookupError(msg % node_dict["asset"])
+
             ag_node = AttackGraphNode(
                 type=node_dict['type'],
                 name=node_dict['name'],
-                ttc=node_dict['ttc']
+                ttc=node_dict['ttc'],
+                asset=node_asset
             )
 
+            if node_asset:
+                # Add AttackGraphNode to attack_step_nodes of asset
+                if hasattr(node_asset, 'attack_step_nodes'):
+                    node_attack_steps = list(node_asset.attack_step_nodes)
+                    node_attack_steps.append(ag_node)
+                    node_asset.attack_step_nodes = node_attack_steps
+                else:
+                    node_asset.attack_step_nodes = [ag_node]
+
             ag_node.defense_status = float(node_dict['defense_status']) if \
                 'defense_status' in node_dict else None
             ag_node.existence_status = node_dict['existence_status'] \
@@ -249,7 +288,8 @@ class AttackGraph():
             ag_node.tags = node_dict['tags'] if \
                 'tags' in node_dict else []
 
-            attack_graph.add_node(ag_node, node_id = node_dict['id'])
+            # Add AttackGraphNode to AttackGraph
+            attack_graph.add_node(ag_node, node_id=node_dict['id'])
 
         # Re-establish links between nodes.
         for node_full_name, node_dict in serialized_attack_steps.items():
@@ -278,23 +318,6 @@ class AttackGraph():
                         raise LookupError(msg % parent_id)
                     _ag_node.parents.append(parent)
 
-                # Also recreate asset links if model is available.
-                if model and 'asset' in node_dict:
-                    asset = model.get_asset_by_name(
-                        node_dict['asset'])
-                    if asset is None:
-                        msg = ('Failed to find asset with id %s'
-                               'when loading from attack graph dict')
-                        logger.error(msg, node_dict["asset"])
-                        raise LookupError(msg % node_dict["asset"])
-                    _ag_node.asset = asset
-                    if hasattr(asset, 'attack_step_nodes'):
-                        attack_step_nodes = list(asset.attack_step_nodes)
-                        attack_step_nodes.append(_ag_node)
-                        asset.attack_step_nodes = attack_step_nodes
-                    else:
-                        asset.attack_step_nodes = [_ag_node]
-
         for attacker_name, attacker in serialized_attackers.items():
             ag_attacker = Attacker(
                 name = attacker['name'],

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/attackgraph/node.py

@@ -28,7 +28,7 @@ class AttackGraphNode:
     attributes: Optional[dict] = None
 
     # Optional extra metadata for AttackGraphNode
-    extras: Optional[dict] = None
+    extras: dict = field(default_factory=dict)
 
     def to_dict(self) -> dict:
         """Convert node to dictionary"""

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/ingestors/neo4j.py

@@ -8,7 +8,7 @@ import logging
 from py2neo import Graph, Node, Relationship, Subgraph
 
 from ..model import AttackerAttachment, Model
-from ..language import specification, LanguageClassesFactory
+from ..language import LanguageGraph, LanguageClassesFactory
 
 logger = logging.getLogger(__name__)
 
@@ -123,7 +123,7 @@ def get_model(
         username: str,
         password: str,
         dbname: str,
-        lang_spec: dict,
+        lang_graph: LanguageGraph,
         lang_classes_factory: LanguageClassesFactory
     ) -> Model:
     """Load a model from Neo4j"""
@@ -184,7 +184,7 @@ def get_model(
             target_id = right_id
             target_prop = left_field
 
-        if attacker_id:
+        if attacker_id is not None:
             attacker = instance_model.get_attacker_by_id(attacker_id)
             if not attacker:
                 msg = 'Failed to find attacker with id %s in model!'
@@ -192,7 +192,7 @@ def get_model(
                 raise LookupError(msg % attacker_id)
             target_asset = instance_model.get_asset_by_id(target_id)
             if not target_asset:
-                msg = 'Failed to find asset with id %s in model!'
+                msg = 'Failed to find asset with id %d in model!'
                 logger.error(msg, target_id)
                 raise LookupError(msg % target_id)
             attacker.entry_points.append((target_asset,
@@ -200,25 +200,23 @@ def get_model(
             continue
 
         left_asset = instance_model.get_asset_by_id(left_id)
-        if not left_asset:
-            msg = 'Failed to find asset with id %s in model!'
+        if left_asset is None:
+            msg = 'Failed to find asset with id %d in model!'
             logger.error(msg, left_id)
             raise LookupError(msg % left_id)
         right_asset = instance_model.get_asset_by_id(right_id)
-        if not right_asset:
-            msg = 'Failed to find asset with id %s in model!'
+        if right_asset is None:
+            msg = 'Failed to find asset with id %d in model!'
             logger.error(msg, right_id)
             raise LookupError(msg % right_id)
 
-        assoc_name = specification.get_association_by_fields_and_assets(
-            lang_spec,
+        assoc = lang_graph.get_association_by_fields_and_assets(
             left_field,
             right_field,
             left_asset.type,
             right_asset.type)
-        logger.debug('Found "%s" association.', assoc_name)
 
-        if not assoc_name:
+        if not assoc:
             logger.error(
                 'Failed to find ("%s", "%s", "%s", "%s")'
                 'association in language specification!',
@@ -227,15 +225,31 @@ def get_model(
             )
             return None
 
-        if not hasattr(lang_classes_factory.ns,
-            assoc_name):
-            msg = 'Failed to find %s association in language specification!'
-            logger.error(msg, assoc_name)
-            raise LookupError(msg % assoc_name)
+        logger.debug('Found "%s" association.', assoc.name)
+
+        assoc_name = lang_classes_factory.get_association_by_signature(
+            assoc.name,
+            left_asset.type,
+            right_asset.type
+        )
+
+        if not assoc_name:
+            msg = 'Failed to find \"%s\" association in language specification!'
+            logger.error(msg, assoc.name)
+            raise LookupError(msg % assoc.name)
 
         assoc = getattr(lang_classes_factory.ns, assoc_name)()
         setattr(assoc, left_field, [left_asset])
         setattr(assoc, right_field, [right_asset])
-        instance_model.add_association(assoc)
+        if not (instance_model.association_exists_between_assets(
+            assoc_name,
+            left_asset,
+            right_asset
+        ) or instance_model.association_exists_between_assets(
+            assoc_name,
+            right_asset,
+            left_asset
+        )):
+            instance_model.add_association(assoc)
 
     return instance_model

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/language/classes_factory.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING
 import python_jsonschema_objects as pjs
 
 if TYPE_CHECKING:
-    from typing import Literal, TypeAlias
+    from typing import Literal, Optional, TypeAlias
     from maltoolbox.language import LanguageGraph
     from python_jsonschema_objects.classbuilder import ProtocolBase
 
@@ -184,3 +184,59 @@ class LanguageClassesFactory:
         # Once we have the JSON schema we create the actual classes.
         builder = pjs.ObjectBuilder(self.json_schema)
         self.ns = builder.build_classes(standardize_names=False)
+
+    def get_association_by_signature(
+        self,
+        assoc_name: str,
+        left_asset: str,
+        right_asset: str
+    ) -> Optional[str]:
+        """
+        Get association name based on its signature. This is primarily
+        relevant for getting the exact association full name when multiple
+        associations with the same name exist.
+
+        Arguments:
+        assoc_name          - the association name
+        left_asset          - the name of the left asset type
+        right_asset         - the name of the right asset type
+
+        Return: The matching association name if a match is found.
+        None if there is no match.
+        """
+        lang_assocs_entries = self.json_schema['definitions']\
+                ['LanguageAssociation']['definitions']
+        if not assoc_name in lang_assocs_entries:
+            raise LookupError(
+                'Failed to find "%s" association in the language json '
+                'schema.' % assoc_name
+            )
+        assoc_entry = lang_assocs_entries[assoc_name]
+        # If the association has a oneOf property it should always have more
+        # than just one alternative, but check just in case
+        if 'definitions' in assoc_entry and \
+                len(assoc_entry['definitions']) > 1:
+            full_name = '%s_%s_%s' % (
+                assoc_name,
+                left_asset,
+                right_asset
+            )
+            full_name_flipped = '%s_%s_%s' % (
+                assoc_name,
+                right_asset,
+                left_asset
+            )
+            if not full_name in assoc_entry['definitions']:
+                if not full_name_flipped in assoc_entry['definitions']:
+                    raise LookupError(
+                        'Failed to find "%s" or "%s" association in the '
+                        'language json schema.'
+                        % (full_name,
+                        full_name_flipped)
+                    )
+                else:
+                    return full_name_flipped
+            else:
+                return full_name
+        else:
+            return assoc_name

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/language/languagegraph.py

@@ -1000,8 +1000,17 @@ class LanguageGraph():
             elif step['reaches']['overrides'] == True:
                 attack_steps[step['name']] = copy.deepcopy(step)
             else:
-                attack_steps[step['name']]['reaches']['stepExpressions'].\
-                    extend(step['reaches']['stepExpressions'])
+                if attack_steps[step['name']]['reaches'] is not None and \
+                        'stepExpressions' in \
+                        attack_steps[step['name']]['reaches']:
+                    attack_steps[step['name']]['reaches']['stepExpressions'].\
+                        extend(step['reaches']['stepExpressions'])
+                else:
+                    attack_steps[step['name']]['reaches'] = {
+                        'overrides': False,
+                        'stepExpressions': step['reaches']['stepExpressions']
+                    }
+
 
         return attack_steps
 
@@ -1096,3 +1105,81 @@ class LanguageGraph():
         self.associations = []
         self.attack_steps = []
         self._generate_graph()
+
+    def get_asset_by_name(
+            self,
+            asset_name
+    ) -> Optional[LanguageGraphAsset]:
+        """
+        Get an asset based on its name
+
+        Arguments:
+        asset_name  - a string containing the asset name
+
+        Return:
+        The asset matching the name.
+        None if there is no match.
+        """
+        for asset in self.assets:
+            if asset.name == asset_name:
+                return asset
+
+        return None
+
+    def get_association_by_fields_and_assets(
+            self,
+            first_field: str,
+            second_field: str,
+            first_asset_name: str,
+            second_asset_name: str
+        ) -> Optional[LanguageGraphAssociation]:
+        """
+        Get an association based on its field names and asset types
+
+        Arguments:
+        first_field         - a string containing the first field
+        second_field        - a string containing the second field
+        first_asset_name    - a string representing the first asset type
+        second_asset_name   - a string representing the second asset type
+
+        Return:
+        The association matching the fieldnames and asset types.
+        None if there is no match.
+        """
+        first_asset = self.get_asset_by_name(first_asset_name)
+        if first_asset is None:
+            raise LookupError(
+                f'Failed to find asset with name \"{first_asset_name}\" in '
+                'the language graph.'
+            )
+
+        second_asset = self.get_asset_by_name(second_asset_name)
+        if second_asset is None:
+            raise LookupError(
+                f'Failed to find asset with name \"{second_asset_name}\" in '
+                'the language graph.'
+            )
+
+        for assoc in self.associations:
+            logger.debug(
+                'Compare ("%s", "%s", "%s", "%s") to ("%s", "%s", "%s", "%s").',
+                first_asset_name, first_field,
+                second_asset_name, second_field,
+                assoc.left_field.asset.name, assoc.left_field.fieldname,
+                assoc.right_field.asset.name, assoc.right_field.fieldname
+            )
+
+            # If the asset and fields match either way we accept it as a match.
+            if assoc.left_field.fieldname == first_field and \
+                assoc.right_field.fieldname == second_field and \
+                first_asset.is_subasset_of(assoc.left_field.asset) and \
+                second_asset.is_subasset_of(assoc.right_field.asset):
+                return assoc
+
+            if assoc.left_field.fieldname == second_field and \
+                assoc.right_field.fieldname == first_field and \
+                second_asset.is_subasset_of(assoc.left_field.asset) and \
+                first_asset.is_subasset_of(assoc.right_field.asset):
+                return assoc
+
+        return None

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/model.py

@@ -400,7 +400,10 @@ class Model():
             )
 
     def association_exists_between_assets(
-            self, association_type, left_asset, right_asset
+            self,
+            association_type: str,
+            left_asset: SchemaGeneratedClass,
+            right_asset: SchemaGeneratedClass
         ):
         """Return True if the association already exists between the assets"""
         logger.debug(

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/maltoolbox/translators/securicad.py

@@ -7,26 +7,28 @@ import json
 import logging
 import xml.etree.ElementTree as ET
 
+from typing import Optional
+
 from ..model import AttackerAttachment, Model
-from ..language import specification, LanguageClassesFactory
+from ..language import LanguageGraph, LanguageClassesFactory
 
 logger = logging.getLogger(__name__)
 
 def load_model_from_scad_archive(
         scad_archive: str,
-        lang_spec: dict,
+        lang_graph: LanguageGraph,
         lang_classes_factory: LanguageClassesFactory
-    ) -> Model:
+    ) -> Optional[Model]:
     """
     Reads a '.sCAD' archive generated by securiCAD representing an instance
     model and loads the information into a maltoobox.model.Model object.
 
     Arguments:
     scad_archive            - the path to a '.sCAD' archive
-    lang_spec               - a dictionary containing the MAL language
-                              specification
+    lang_graph              - a language graph representing the MAL
+                              language specification
     lang_classes_factory    - a language classes factory that contains
-                              the same classes defined by the
+                              the classes defined by the
                               language specification
 
     Return:
@@ -39,7 +41,6 @@ def load_model_from_scad_archive(
         root = ET.fromstring(scad_model)
 
     instance_model = Model(scad_archive,
-        lang_spec,
         lang_classes_factory)
 
     for child in root.iter('objects'):
@@ -52,10 +53,13 @@ def load_model_from_scad_archive(
             )
 
         if child.attrib['metaConcept'] == 'Attacker':
-            attacker_id = int(child.attrib['id'])
-            attacker = AttackerAttachment()
-            attacker.entry_points = []
-            instance_model.add_attacker(attacker, attacker_id = attacker_id)
+            attacker_obj_id = int(child.attrib['id'])
+            attacker_at = AttackerAttachment()
+            attacker_at.entry_points = []
+            instance_model.add_attacker(
+                attacker_at,
+                attacker_id = attacker_obj_id
+            )
             continue
 
         if not hasattr(lang_classes_factory.ns,
@@ -100,7 +104,7 @@ def load_model_from_scad_archive(
             target_id = right_id
             target_prop = child.attrib['sourceProperty']
 
-        if attacker_id:
+        if attacker_id is not None:
             attacker = instance_model.get_attacker_by_id(attacker_id)
             if not attacker:
                 logger.error(
@@ -137,28 +141,32 @@ def load_model_from_scad_archive(
         # matches the target field and vice versa.
         left_field = child.attrib['sourceProperty']
         right_field = child.attrib['targetProperty']
-        assoc_name = specification.get_association_by_fields_and_assets(
-            lang_spec,
+        lang_graph_assoc = lang_graph.get_association_by_fields_and_assets(
             left_field,
             right_field,
-            left_asset.metaconcept,
-            right_asset.metaconcept)
-        logger.debug('Found "%s" association.', assoc_name)
+            left_asset.type,
+            right_asset.type)
 
-        if not assoc_name:
-            logger.error(
+        if not lang_graph_assoc:
+            raise LookupError(
                 'Failed to find ("%s", "%s", "%s", "%s")'
-                'association in lang specification',
-                left_asset.metaconcept, right_asset.metaconcept,
-                left_field, right_field
+                'association in lang specification.' %
+                (left_asset.type, right_asset.type,
+                left_field, right_field)
             )
             return None
 
-        if not hasattr(lang_classes_factory.ns,
-            assoc_name):
+        logger.debug('Found "%s" association.', lang_graph_assoc.name)
+        assoc_name = lang_classes_factory.get_association_by_signature(
+            lang_graph_assoc.name,
+            left_asset.type,
+            right_asset.type
+        )
+
+        if assoc_name is None:
             logger.error(
-                'Failed to find %s association in language specification!',
-                assoc_name
+                'Failed to find association with name \"%s\" in model!',
+                lang_graph_assoc.name
             )
             return None
 

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mal-toolbox"
-version = "0.1.2"
+version = "0.1.4"
 authors = [
   { name="Andrei Buhaiu", email="buhaiu@kth.se" },
   { name="Giuseppe Nebbione", email="nebbione@kth.se" },
@@ -13,7 +13,7 @@ readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
   "py2neo>=2021.2.3",
-  "python-jsonschema-objects>=0.4.1",
+  "python-jsonschema-objects>=0.5.5",
   "antlr4-tools",
   "antlr4-python3-runtime",
   "docopt",

{mal_toolbox-0.1.2 → mal_toolbox-0.1.4}/tests/test_model.py

@@ -505,55 +505,52 @@ def test_model_get_associated_assets_by_fieldname(model: Model):
     assert ret == []
 
 
-# TODO: Re-enable these tests once we have a newer release of
-# python-jsonschema-objects that properly handles zero value defaults.
-#
-# def test_model_asset_to_dict(model: Model):
-#     """Make sure assets are converted to dictionaries correctly"""
-#     # Create and add asset
-#     p1 = create_application_asset(model, "Program 1")
-#     model.add_asset(p1)
-#
-#     # Tuple is returned
-#     ret = model.asset_to_dict(p1)
-#
-#     # First element should be the id
-#     p1_id = ret[0]
-#     assert p1_id == p1.id
-#
-#     # Second element is the dict, each value should
-#     # be set as below for an 'Application' asset in coreLang
-#     p1_dict = ret[1]
-#     assert p1_dict.get('name') == p1.name
-#     assert p1_dict.get('type') == 'Application'
-#
-#     # Default values should not be saved
-#     assert p1_dict.get('defenses') == None
-#
-# def test_model_asset_with_nondefault_defense_to_dict(model: Model):
-#     """Make sure assets are converted to dictionaries correctly"""
-#     # Create and add asset
-#     p1 = create_application_asset(model, "Program 1")
-#     p1.notPresent = 1.0
-#     model.add_asset(p1)
-#
-#     # Tuple is returned
-#     ret = model.asset_to_dict(p1)
-#
-#     # First element should be the id
-#     p1_id = ret[0]
-#     assert p1_id == p1.id
-#
-#     # Second element is the dict, each value should
-#     # be set as below for an 'Application' asset in coreLang
-#     p1_dict = ret[1]
-#     assert p1_dict.get('name') == p1.name
-#     assert p1_dict.get('type') == 'Application'
-#
-#     # Default values for 'Application' defenses in coreLang
-#     assert p1_dict.get('defenses') == {
-#         'notPresent': 1.0
-#     }
+def test_model_asset_to_dict(model: Model):
+    """Make sure assets are converted to dictionaries correctly"""
+    # Create and add asset
+    p1 = create_application_asset(model, "Program 1")
+    model.add_asset(p1)
+
+    # Tuple is returned
+    ret = model.asset_to_dict(p1)
+
+    # First element should be the id
+    p1_id = ret[0]
+    assert p1_id == p1.id
+
+    # Second element is the dict, each value should
+    # be set as below for an 'Application' asset in coreLang
+    p1_dict = ret[1]
+    assert p1_dict.get('name') == p1.name
+    assert p1_dict.get('type') == 'Application'
+
+    # Default values should not be saved
+    assert p1_dict.get('defenses') == None
+
+def test_model_asset_with_nondefault_defense_to_dict(model: Model):
+    """Make sure assets are converted to dictionaries correctly"""
+    # Create and add asset
+    p1 = create_application_asset(model, "Program 1")
+    p1.notPresent = 1.0
+    model.add_asset(p1)
+
+    # Tuple is returned
+    ret = model.asset_to_dict(p1)
+
+    # First element should be the id
+    p1_id = ret[0]
+    assert p1_id == p1.id
+
+    # Second element is the dict, each value should
+    # be set as below for an 'Application' asset in coreLang
+    p1_dict = ret[1]
+    assert p1_dict.get('name') == p1.name
+    assert p1_dict.get('type') == 'Application'
+
+    # Default values for 'Application' defenses in coreLang
+    assert p1_dict.get('defenses') == {
+        'notPresent': 1.0
+    }
 
 
 def test_model_association_to_dict(model: Model):

mal_toolbox-0.1.2/maltoolbox/language/specification.py

@@ -1,90 +0,0 @@
-"""
-MAL-Toolbox Language Specification Module
-
-"""
-
-import logging
-
-from typing import Optional
-logger = logging.getLogger(__name__)
-
-# TODO move these functions to their relevant module/class
-
-def get_association_by_fields_and_assets(
-        lang_spec: dict,
-        first_field: str,
-        second_field: str,
-        first_asset: str,
-        second_asset: str
-    ) -> Optional[str]:
-    """
-    Get an association based on its field names and asset types
-
-    Arguments:
-    lang_spec       - a dictionary containing the MAL language specification
-    first_field     - a string containing the first field
-    second_field    - a string containing the second field
-    first_asset     - a string representing the first asset type
-    second_asset    - a string representing the second asset type
-
-    Return:
-    The name of the association matching the fieldnames and asset types.
-    None if there is no match.
-    """
-    for assoc in lang_spec['associations']:
-        logger.debug(
-            'Compare ("%s", "%s". "%s". "%s") to ("%s", "%s", "%s", "%s").',
-            first_asset, first_field, second_asset, second_field,
-            assoc["leftAsset"], assoc["leftField"],
-            assoc["rightAsset"], assoc["rightField"]
-        )
-
-        # If the asset and fields match either way we accept it as a match.
-        if assoc['leftField'] == first_field and \
-            assoc['rightField'] == second_field and \
-            extends_asset(lang_spec, first_asset, assoc['leftAsset']) and \
-            extends_asset(lang_spec, second_asset, assoc['rightAsset']):
-            return assoc['name']
-        if assoc['leftField'] == second_field and \
-            assoc['rightField'] == first_field and \
-            extends_asset(lang_spec, second_asset, assoc['leftAsset']) and \
-            extends_asset(lang_spec, first_asset, assoc['rightAsset']):
-            return assoc['name']
-
-    return None
-
-def extends_asset(lang_spec: dict, asset: str, target_asset: str) -> bool:
-    """
-    Check if an asset extends the target asset through inheritance.
-
-    Arguments:
-    lang_spec       - a dictionary containing the MAL language specification
-    asset           - the asset name we wish to evaluate
-    target_asset    - the target asset name we wish to evaluate if it
-                      is extended
-
-    Return:
-    True if this asset extends the target_asset via inheritance.
-    False otherwise.
-    """
-
-    logger.debug('Check if %s extends %s via inheritance.', asset, target_asset)
-
-    if asset == target_asset:
-        return True
-
-    asset_dict = next((asset_info for asset_info in lang_spec['assets'] \
-        if asset_info['name'] == asset), None)
-    if not asset_dict:
-        logger.error(
-            'Failed to find asset type %s when looking for variable.', asset
-        )
-        return False
-    if asset_dict['superAsset']:
-        if asset_dict['superAsset'] == target_asset:
-            return True
-        else:
-            return extends_asset(lang_spec, asset_dict['superAsset'],
-                target_asset)
-
-    return False