mal-toolbox 0.1.6__tar.gz → 0.1.8__tar.gz

{mal_toolbox-0.1.6/mal_toolbox.egg-info → mal_toolbox-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mal-toolbox
-Version: 0.1.6
+Version: 0.1.8
 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
@@ -33,6 +33,8 @@ MAL ([Meta Attack Language](https://mal-lang.org/)) models and attack graphs.
 Attack graphs can be used to run simulations (see MAL Simulator) or analysis.
 MAL Toolbox also gives the ability to view the AttackGraph/Model graphically in neo4j.
 
+[Documentation](https://mal-lang.org/mal-toolbox/index.html)(Work in progress)
+
 ## The Language Module
 
 The language module provides various tools to process MAL languages.

{mal_toolbox-0.1.6 → mal_toolbox-0.1.8}/README.md

@@ -6,6 +6,8 @@ MAL ([Meta Attack Language](https://mal-lang.org/)) models and attack graphs.
 Attack graphs can be used to run simulations (see MAL Simulator) or analysis.
 MAL Toolbox also gives the ability to view the AttackGraph/Model graphically in neo4j.
 
+[Documentation](https://mal-lang.org/mal-toolbox/index.html)(Work in progress)
+
 ## The Language Module
 
 The language module provides various tools to process MAL languages.
@@ -99,4 +101,4 @@ To find code examples and tutorials, visit the
 There are unit tests inside of ./tests.
 Before running the tests, make sure to install the requirements in ./tests/requirements.txt with `python -m pip install -r ./tests/requirements.txt`.
 
-To run all tests, use the `pytest` command. To run just a specific file or test function use `pytest tests/<filename>` or `pytest -k <function_name>`.
+To run all tests, use the `pytest` command. To run just a specific file or test function use `pytest tests/<filename>` or `pytest -k <function_name>`.

{mal_toolbox-0.1.6 → mal_toolbox-0.1.8/mal_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mal-toolbox
-Version: 0.1.6
+Version: 0.1.8
 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
@@ -33,6 +33,8 @@ MAL ([Meta Attack Language](https://mal-lang.org/)) models and attack graphs.
 Attack graphs can be used to run simulations (see MAL Simulator) or analysis.
 MAL Toolbox also gives the ability to view the AttackGraph/Model graphically in neo4j.
 
+[Documentation](https://mal-lang.org/mal-toolbox/index.html)(Work in progress)
+
 ## The Language Module
 
 The language module provides various tools to process MAL languages.

{mal_toolbox-0.1.6 → mal_toolbox-0.1.8}/maltoolbox/__init__.py

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-# MAL Toolbox v0.1.6
+# MAL Toolbox v0.1.8
 # 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.6'
+__version__ = '0.1.8'
 __authors__ = ['Andrei Buhaiu',
     'Giuseppe Nebbione',
     'Nikolaos Kakouros',

{mal_toolbox-0.1.6 → mal_toolbox-0.1.8}/maltoolbox/model.py

@@ -28,10 +28,105 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class AttackerAttachment:
-    """Used to attach attackers to attack step entrypoints of assets"""
+    """Used to attach attackers to attack step entry points of assets"""
     id: Optional[int] = None
     name: Optional[str] = None
-    entry_points: list[tuple] = field(default_factory=lambda: [])
+    entry_points: list[tuple[SchemaGeneratedClass, list[str]]] = \
+        field(default_factory=lambda: [])
+
+
+    def get_entry_point_tuple(
+            self,
+            asset: SchemaGeneratedClass
+        ) -> Optional[tuple[SchemaGeneratedClass, list[str]]]:
+        """Return an entry point tuple of an AttackerAttachment matching the
+        asset provided.
+
+
+        Arguments:
+        asset           - the asset to add entry point to
+
+        Return:
+        The entry point tuple containing the asset and the list of attack
+        steps if the asset has any entry points defined for this attacker
+        attachemnt.
+        None, otherwise.
+        """
+        return next((ep_tuple for ep_tuple in self.entry_points
+                                 if ep_tuple[0] == asset), None)
+
+
+    def add_entry_point(
+            self, asset: SchemaGeneratedClass, attackstep_name: str):
+        """Add an entry point to an AttackerAttachment
+
+        self.entry_points contain tuples, first element of each tuple
+        is an asset, second element is a list of attack step names that
+        are entry points for the attacker.
+
+        Arguments:
+        asset           - the asset to add the entry point to
+        attackstep_name - the name of the attack step to add as an entry point
+        """
+
+        logger.debug(
+            f'Add entry point "{attackstep_name}" on asset "{asset.name}" '
+            f'to AttackerAttachment "{self.name}".'
+        )
+
+        # Get the entry point tuple for the asset if it already exists
+        entry_point_tuple = self.get_entry_point_tuple(asset)
+
+        if entry_point_tuple:
+            if attackstep_name not in entry_point_tuple[1]:
+                # If it exists and does not already have the attack step,
+                # add it
+                entry_point_tuple[1].append(attackstep_name)
+            else:
+                logger.info(
+                    f'Entry point "{attackstep_name}" on asset "{asset.name}"'
+                    f' already existed for AttackerAttachment "{self.name}".'
+                )
+        else:
+            # Otherwise, create the entry point tuple and the initial entry
+            # point
+            self.entry_points.append((asset, [attackstep_name]))
+
+    def remove_entry_point(
+            self, asset: SchemaGeneratedClass, attackstep_name: str):
+        """Remove an entry point from an AttackerAttachment if it exists
+
+        Arguments:
+        asset           - the asset to remove the entry point from
+        """
+
+        logger.debug(
+            f'Remove entry point "{attackstep_name}" on asset "{asset.name}" '
+            f'from AttackerAttachment "{self.name}".'
+        )
+
+        # Get the entry point tuple for the asset if it exists
+        entry_point_tuple = self.get_entry_point_tuple(asset)
+
+        if entry_point_tuple:
+            if attackstep_name in entry_point_tuple[1]:
+                # If it exists and not already has the attack step, add it
+                entry_point_tuple[1].remove(attackstep_name)
+            else:
+                logger.warning(
+                    f'Failed to find entry point "{attackstep_name}" on '
+                    f'asset "{asset.name}" for AttackerAttachment '
+                    f'"{self.name}". Nothing to remove.'
+                )
+
+            if not entry_point_tuple[1]:
+                self.entry_points.remove(entry_point_tuple)
+        else:
+            logger.warning(
+                f'Failed to find entry points on asset "{asset.name}" '
+                f'for AttackerAttachment "{self.name}". Nothing to remove.'
+            )
+
 
 class Model():
     """An implementation of a MAL language with assets and associations"""
@@ -133,6 +228,12 @@ class Model():
         for association in asset.associations:
             self.remove_asset_from_association(asset, association)
 
+        # Also remove all of the entry points
+        for attacker in self.attackers:
+            entry_point_tuple = attacker.get_entry_point_tuple(asset)
+            if entry_point_tuple:
+                attacker.entry_points.remove(entry_point_tuple)
+
         self.assets.remove(asset)
 
     def remove_asset_from_association(

{mal_toolbox-0.1.6 → mal_toolbox-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mal-toolbox"
-version = "0.1.6"
+version = "0.1.8"
 authors = [
   { name="Andrei Buhaiu", email="buhaiu@kth.se" },
   { name="Giuseppe Nebbione", email="nebbione@kth.se" },

{mal_toolbox-0.1.6 → mal_toolbox-0.1.8}/tests/test_model.py

@@ -51,6 +51,150 @@ def create_association(
 
 ### Tests
 
+def test_attacker_attachment_add_entry_point(model: Model):
+    """"""
+
+    asset1 = create_application_asset(model, "Asset1")
+    asset2 = create_application_asset(model, "Asset2")
+    model.add_asset(asset1)
+    model.add_asset(asset2)
+
+    # Add attacker 1
+    attacker1 = AttackerAttachment()
+    model.add_attacker(attacker1)
+
+    attacker1.add_entry_point(asset1, 'read')
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read']
+
+    attacker1.add_entry_point(asset1, 'access')
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read', 'access']
+
+    # Try to add already existing entry point
+    attacker1.add_entry_point(asset1, 'access')
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read', 'access']
+
+    attacker1.add_entry_point(asset2, 'access')
+    assert len(attacker1.entry_points) == 2
+    assert attacker1.entry_points[1][0] == asset2
+    assert attacker1.entry_points[1][1] == ['access']
+
+
+def test_attacker_attachment_remove_entry_point(model: Model):
+    """"""
+
+    asset1 = create_application_asset(model, "Asset1")
+    asset2 = create_application_asset(model, "Asset2")
+    model.add_asset(asset1)
+    model.add_asset(asset2)
+
+    # Add attacker 1
+    attacker1 = AttackerAttachment()
+    model.add_attacker(attacker1)
+
+    attacker1.add_entry_point(asset1, 'read')
+    attacker1.add_entry_point(asset1, 'access')
+    attacker1.add_entry_point(asset2, 'access')
+
+    assert len(attacker1.entry_points) == 2
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read', 'access']
+    assert attacker1.entry_points[1][0] == asset2
+    assert attacker1.entry_points[1][1] == ['access']
+
+    attacker1.remove_entry_point(asset1, 'read')
+    assert len(attacker1.entry_points) == 2
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['access']
+    assert attacker1.entry_points[1][0] == asset2
+    assert attacker1.entry_points[1][1] == ['access']
+
+    # Try to remove inexistent entry point, but the asset is still present in
+    # the list of entry points
+    attacker1.remove_entry_point(asset1, 'read')
+    assert len(attacker1.entry_points) == 2
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['access']
+    assert attacker1.entry_points[1][0] == asset2
+    assert attacker1.entry_points[1][1] == ['access']
+
+    attacker1.remove_entry_point(asset1, 'access')
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset2
+    assert attacker1.entry_points[0][1] == ['access']
+
+    # Try to remove inexistent entry point, where the asset is no longer in
+    # the list of entry points
+    attacker1.remove_entry_point(asset1, 'access')
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset2
+    assert attacker1.entry_points[0][1] == ['access']
+
+    attacker1.remove_entry_point(asset2, 'access')
+    assert len(attacker1.entry_points) == 0
+
+
+def test_attacker_attachment_remove_asset(model: Model):
+    """"""
+
+    asset1 = create_application_asset(model, "Asset1")
+    asset2 = create_application_asset(model, "Asset2")
+    model.add_asset(asset1)
+    model.add_asset(asset2)
+
+    attacker1 = AttackerAttachment()
+    model.add_attacker(attacker1)
+    attacker2 = AttackerAttachment()
+    model.add_attacker(attacker2)
+
+    attacker1.add_entry_point(asset1, 'read')
+    attacker1.add_entry_point(asset1, 'access')
+    attacker1.add_entry_point(asset2, 'access')
+
+    attacker2.add_entry_point(asset1, 'read')
+    attacker2.add_entry_point(asset2, 'read')
+    attacker2.add_entry_point(asset2, 'access')
+
+    assert len(attacker1.entry_points) == 2
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read', 'access']
+    assert attacker1.entry_points[1][0] == asset2
+    assert attacker1.entry_points[1][1] == ['access']
+
+    assert len(attacker2.entry_points) == 2
+    assert attacker2.entry_points[0][0] == asset1
+    assert attacker2.entry_points[0][1] == ['read']
+    assert attacker2.entry_points[1][0] == asset2
+    assert attacker2.entry_points[1][1] == ['read', 'access']
+
+    model.remove_asset(asset2)
+    # All of the entry points of the asset removed should be gone, but the
+    # other assets should not be impacted.
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read', 'access']
+
+    assert len(attacker2.entry_points) == 1
+    assert attacker2.entry_points[0][0] == asset1
+    assert attacker2.entry_points[0][1] == ['read']
+
+    # Try to remove inexistent entry point, where the asset is no longer in
+    # the list of entry points
+    attacker1.remove_entry_point(asset2, 'access')
+    assert len(attacker1.entry_points) == 1
+    assert attacker1.entry_points[0][0] == asset1
+    assert attacker1.entry_points[0][1] == ['read', 'access']
+
+    assert len(attacker2.entry_points) == 1
+    assert attacker2.entry_points[0][0] == asset1
+    assert attacker2.entry_points[0][1] == ['read']
+
+
 def test_model_add_asset(model: Model):
     """Make sure assets are added correctly"""
 
@@ -600,17 +744,17 @@ def test_model_attacker_to_dict(model: Model):
     attacker_dict = ret[1]
     assert attacker_dict.get('name') == attacker.name
 
-    # entrypoints_dict has asset IDs as keys
-    entrypoints_dict = attacker_dict.get('entry_points')
+    # entry_points_dict has asset IDs as keys
+    entry_points_dict = attacker_dict.get('entry_points')
 
     # attacker should be attached to p1, therefore p1s
-    # id should be a key in the entrypoints_dict
-    assert p1.id is not None and entrypoints_dict
-    assert p1.id in entrypoints_dict
+    # id should be a key in the entry_points_dict
+    assert p1.id is not None and entry_points_dict
+    assert p1.id in entry_points_dict
 
-    # The given steps should be inside the entrypoint of
+    # The given steps should be inside the entry_point of
     # the attacker for asset p1
-    assert entrypoints_dict[p1.id]['attack_steps'] == attack_steps
+    assert entry_points_dict[p1.id]['attack_steps'] == attack_steps
 
 
 def test_serialize(model: Model):