mal-toolbox 0.3.11__py3-none-any.whl → 1.0.1__py3-none-any.whl

{mal_toolbox-0.3.11.dist-info → mal_toolbox-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: mal-toolbox
-Version: 0.3.11
+Version: 1.0.1
 Summary: A collection of tools used to create MAL models and attack graphs.
 Author-email: Andrei Buhaiu <buhaiu@kth.se>, Joakim Loxdal <loxdal@kth.se>, Nikolaos Kakouros <nkak@kth.se>, Jakob Nyberg <jaknyb@kth.se>, Giuseppe Nebbione <nebbione@kth.se>
 License: Apache Software License
@@ -18,11 +18,11 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
-Requires-Dist: py2neo>=2021.2.3
 Requires-Dist: antlr4-tools
 Requires-Dist: antlr4-python3-runtime
 Requires-Dist: docopt
 Requires-Dist: PyYAML
+Dynamic: license-file
 
 # MAL Toolbox overview
 
@@ -30,7 +30,6 @@ MAL Toolbox is a collection of python modules to help developers create and work
 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)
 
@@ -53,13 +52,7 @@ With a MAL language a Model (a MAL instance model) can be created either
 from a model file or empty.
 
 The model class will store all of the relevant information to the MAL
-instance model, most importantly the assets and associations that make it up.
-
-Assets and associations are objects of classes created using the language
-classes factory submodule in runtime. It also allows for `Attacker` objects
-to be created and associated with attack steps on assets in the model.
-The most relevant methods of the Model are the ones used to add different
-elements to the model, `add_asset`, `add_association`, and `add_attacker`.
+instance model, most importantly the assets and their associations.
 
 Model objects can be used to generate attack graphs with the AttackGraph module.
 
@@ -76,11 +69,6 @@ nodes related and the asset field which will contain the object in the model
 instance to which this attack step belongs to, if this information is
 available.
 
-If it is relevant the `attach_attackers` function can be called on the
-resulting attack graph with the instance model given as a parameter in order
-to create attack step nodes that represent the entry points of the attackers
-and attach them to the attack steps specified in the instance model.
-
 ## Ingestors Module
 
 The ingestors module contains various tools that can make use of the instance
@@ -131,16 +119,9 @@ Arguments:
     <lang_file>     Path to .mar or .mal file containing MAL spec.
     <output_file>   Path to write the result of the compilation (yml/json).
 
-Options:
-    --neo4j         Ingest attack graph and instance model into a Neo4j instance
-
 Notes:
     - <lang_file> can be either a .mar file (generated by the older MAL
       compiler) or a .mal file containing the DSL written in MAL.
-
-    - If --neo4j is used, the Neo4j instance should be running. The connection
-      parameters required for this app to reach the Neo4j instance should be
-      defined in the default.conf file.
 ```
 
 ## Code examples / Tutorial

mal_toolbox-1.0.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+mal_toolbox-1.0.1.dist-info/licenses/AUTHORS,sha256=zxLrLe8EY39WtRKlAY4Oorx4Z2_LHV2ApRvDGZgY7xY,127
+mal_toolbox-1.0.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+maltoolbox/__init__.py,sha256=AO8CtBtHZ2gaI_kkyQW51Wn44s9xb0ErllNbR_AB0Do,2043
+maltoolbox/__main__.py,sha256=QBloKCJ_RMsFPZ8qiWZQnoP2gnnRyECIJBfA1zTAYJM,2394
+maltoolbox/exceptions.py,sha256=0YjPx2v1yYumZ2o7pVZ1s_jS-GAb3Ng979KEFhROSNY,1399
+maltoolbox/file_utils.py,sha256=fYG3UsvPQcU0ES_WI3nLfuzSZgc0jtE4IAxdMGgs9aA,1876
+maltoolbox/model.py,sha256=xTK2jUr0Gz5pPVhdjh78zO5G46nV8N2ciIt6M5SwcGU,16058
+maltoolbox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maltoolbox/attackgraph/__init__.py,sha256=m_81AjzwXONdclcW_R7mF2f8p-4DvoSRVfQ3Nyh7fak,298
+maltoolbox/attackgraph/attackgraph.py,sha256=fuhpfD3YnQEdDdG7QPdYSylOX3XPL2mbx4cX0_bmX3c,26870
+maltoolbox/attackgraph/node.py,sha256=Z2sdzXhPel9h7ySxP9fjgd1exVmpRbvRySVtLpI1_BM,3904
+maltoolbox/attackgraph/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maltoolbox/ingestors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maltoolbox/language/__init__.py,sha256=TsTTryEyjChwHN1o5F2BSUlFsAss2N6J0H0-nzvXiD8,489
+maltoolbox/language/languagegraph.py,sha256=WLV0-CvfrB4yqaDW3NTLyVOVDduNeD1By3Yqmjzn00Y,73810
+maltoolbox/language/compiler/__init__.py,sha256=JQyAgDwJh1pU7AmuOhd1-d2b2PYXpgMVPtxnav8QHVc,15872
+maltoolbox/language/compiler/mal_lexer.py,sha256=BeifykDAt4PloRASOaLzBgWF35ev_zgD8lXMIsSHykc,12063
+maltoolbox/language/compiler/mal_parser.py,sha256=sUoaE43l2VKg-Dou30mk2wlVS1FvdOREwHNIyFe4IkY,114699
+maltoolbox/translators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maltoolbox/translators/securicad.py,sha256=F_rndv2JyKxfHAXPwf2RrdiFPnemJVArYUpVsFP6QQk,6997
+maltoolbox/translators/updater.py,sha256=UZPnx22udROiocCcSmtrgUJUupkjktkxl-M7rhBxUPc,8660
+mal_toolbox-1.0.1.dist-info/METADATA,sha256=LSJ7hnJewGb32qVSdpv-3KBinzJ_ZHUbsWxWhHEebII,5097
+mal_toolbox-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mal_toolbox-1.0.1.dist-info/entry_points.txt,sha256=oqby5O6cUP_OHCm70k_iYPA6UlbTBf7se1i3XwdK3uU,56
+mal_toolbox-1.0.1.dist-info/top_level.txt,sha256=phqRVLRKGdSUgRY03mcpi2cmbbDo5YGjkV4gkqHFFcM,11
+mal_toolbox-1.0.1.dist-info/RECORD,,

{mal_toolbox-0.3.11.dist-info → mal_toolbox-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

maltoolbox/__init__.py

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-# MAL Toolbox v0.3.11
+# MAL Toolbox v1.0.1
 # Copyright 2025, Andrei Buhaiu.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,7 +21,7 @@ MAL-Toolbox Framework
 """
 
 __title__ = "maltoolbox"
-__version__ = "0.3.11"
+__version__ = "1.0.1"
 __authors__ = [
     "Andrei Buhaiu",
     "Giuseppe Nebbione",
@@ -45,9 +45,9 @@ config: dict[str, Any] = {
         "log_file": "logs/log.txt",
         "attackgraph_file": "logs/attackgraph.yml",
         "model_file": "logs/model.yml",
-        "langspec_file": "logs/langspec_file.yml",
+        "langspec_file": "logs/langspec_file.json",
+        "langgraph_file": "logs/langgraph.yml",
     },
-    "neo4j": {"uri": None, "username": None, "password": None, "dbname": None},
 }
 
 config_file = os.getenv("MALTOOLBOX_CONFIG", "maltoolbox.yml")
@@ -56,8 +56,7 @@ if os.path.exists(config_file):
     with open(config_file) as f:
         config |= yaml.safe_load(f)
 
-log_configs, neo4j_configs = config.values()
-
+log_configs = config['logging']
 os.makedirs(os.path.dirname(log_configs["log_file"]), exist_ok=True)
 
 formatter = logging.Formatter(

maltoolbox/__main__.py

@@ -11,26 +11,18 @@ Arguments:
     <lang_file>     Path to .mar or .mal file containing MAL spec.
     <output_file>   Path to write the result of the compilation (yml/json).
 
-Options:
-    --neo4j         Ingest attack graph and instance model into a Neo4j instance
-
 Notes:
     - <lang_file> can be either a .mar file (generated by the older MAL
       compiler) or a .mal file containing the DSL written in MAL.
-
-    - If --neo4j is used, the Neo4j instance should be running. The connection
-      parameters required for this app to reach the Neo4j instance should be
-      defined in the default.conf file.
 """
 
 import logging
 import json
 import docopt
 
-from . import log_configs, neo4j_configs
+from . import log_configs
 from .attackgraph import create_attack_graph
 from .language.compiler import MalCompiler
-from .ingestors import neo4j
 from .language.languagegraph import LanguageGraph
 from .translators.updater import load_model_from_older_version
 
@@ -39,14 +31,12 @@ logger = logging.getLogger(__name__)
 def generate_attack_graph(
         model_file: str,
         lang_file: str,
-        send_to_neo4j: bool
     ) -> None:
-    """Create an attack graph and optionally send to neo4j
+    """Create an attack graph
 
     Args:
     model_file      - path to the model file
     lang_file       - path to the language file
-    send_to_neo4j   - whether to ingest into neo4j or not
     """
     attack_graph = create_attack_graph(lang_file, model_file)
     if log_configs['attackgraph_file']:
@@ -54,27 +44,6 @@ def generate_attack_graph(
             log_configs['attackgraph_file']
         )
 
-    if send_to_neo4j:
-        logger.debug('Ingest model graph into Neo4J database.')
-        neo4j.ingest_model(
-            attack_graph.model,
-            neo4j_configs['uri'],
-            neo4j_configs['username'],
-            neo4j_configs['password'],
-            neo4j_configs['dbname'],
-            delete=True
-        )
-        logger.debug('Ingest attack graph into Neo4J database.')
-        neo4j.ingest_attack_graph(
-            attack_graph,
-            neo4j_configs['uri'],
-            neo4j_configs['username'],
-            neo4j_configs['password'],
-            neo4j_configs['dbname'],
-            delete=False
-        )
-
-
 def compile(lang_file: str, output_file: str) -> None:
     """Compile language and dump into output file"""
     compiler = MalCompiler()
@@ -97,7 +66,7 @@ def main():
 
     if args['attack-graph'] and args['generate']:
         generate_attack_graph(
-            args['<model_file>'], args['<lang_file>'], args['--neo4j']
+            args['<model_file>'], args['<lang_file>']
         )
     elif args['compile']:
         compile(

maltoolbox/attackgraph/__init__.py

@@ -3,6 +3,12 @@ Contains tools used to generate attack graphs from MAL instance
 models and analyze attack graphs.
 """
 
-from .attacker import Attacker
 from .attackgraph import AttackGraph, create_attack_graph
 from .node import AttackGraphNode
+
+__all__ = [
+    "Attacker",
+    "AttackGraph",
+    "AttackGraphNode",
+    "create_attack_graph"
+]

maltoolbox/attackgraph/attackgraph.py

@@ -11,9 +11,7 @@ import zipfile
 from itertools import chain
 from typing import TYPE_CHECKING
 
-from .analyzers.apriori import calculate_viability_and_necessity
 from .node import AttackGraphNode
-from .attacker import Attacker
 from .. import log_configs
 from ..exceptions import AttackGraphStepExpressionError, AttackGraphException
 from ..exceptions import LanguageGraphException
@@ -35,28 +33,44 @@ logger = logging.getLogger(__name__)
 
 
 def create_attack_graph(
-        lang_file: str,
-        model_file: str,
-        attach_attackers=True,
-        calc_viability_and_necessity=True
+        lang: str | LanguageGraph,
+        model: str | Model,
     ) -> AttackGraph:
     """Create and return an attack graph
 
     Args:
-    lang_file                       - path to language file (.mar or .mal)
-    model_file                      - path to model file (yaml or json)
-    attach_attackers                - whether to run attach_attackers or not
-    calc_viability_and_necessity    - whether run apriori calculations or not
+    lang    - path to language file (.mar or .mal) or a LanguageGraph object
+    model   - path to model file (yaml or json) or a Model object
     """
-    try:
-        lang_graph = LanguageGraph.from_mar_archive(lang_file)
-    except zipfile.BadZipFile:
-        lang_graph = LanguageGraph.from_mal_spec(lang_file)
 
-    if log_configs['langspec_file']:
-        lang_graph.save_to_file(log_configs['langspec_file'])
+    # Load language
+    if isinstance(lang, LanguageGraph):
+        lang_graph = lang
+    elif isinstance(lang, str):
+        # Load from path
+        try:
+            lang_graph = LanguageGraph.from_mar_archive(lang)
+        except zipfile.BadZipFile:
+            lang_graph = LanguageGraph.from_mal_spec(lang)
+    else:
+        raise TypeError("`lang` must be either string or LanguageGraph")
+
+    if 'langspec_file' in log_configs:
+        lang_graph.save_language_specification_to_json(
+            log_configs['langspec_file']
+        )
+
+    if 'langgraph_file' in log_configs:
+        lang_graph.save_to_file(log_configs['langgraph_file'])
 
-    instance_model = Model.load_from_file(model_file, lang_graph)
+    # Load model
+    if isinstance(model, Model):
+        instance_model = model
+    elif isinstance(model, str):
+        # Load from path
+        instance_model = Model.load_from_file(model, lang_graph)
+    else:
+        raise TypeError("`model` must be either string or Model")
 
     if log_configs['model_file']:
         instance_model.save_to_file(log_configs['model_file'])
@@ -70,12 +84,6 @@ def create_attack_graph(
         )
         sys.exit(1)
 
-    if attach_attackers:
-        attack_graph.attach_attackers()
-
-    if calc_viability_and_necessity:
-        calculate_viability_and_necessity(attack_graph)
-
     return attack_graph
 
 
@@ -83,15 +91,13 @@ class AttackGraph():
     """Graph representation of attack steps"""
     def __init__(self, lang_graph, model: Optional[Model] = None):
         self.nodes: dict[int, AttackGraphNode] = {}
-        self.attackers: dict[int, Attacker] = {}
-        # Dictionaries used in optimization to get nodes and attackers by id
-        # or full name faster
+        # Dictionaries used in optimization to get nodes by id or full name
+        # faster
         self._full_name_to_node: dict[str, AttackGraphNode] = {}
 
         self.model = model
         self.lang_graph = lang_graph
         self.next_node_id = 0
-        self.next_attacker_id = 0
         if self.model is not None:
             self._generate_graph()
 
@@ -102,18 +108,11 @@ class AttackGraph():
     def _to_dict(self) -> dict:
         """Convert AttackGraph to dict"""
         serialized_attack_steps = {}
-        serialized_attackers = {}
         for ag_node in self.nodes.values():
             serialized_attack_steps[ag_node.full_name] =\
                 ag_node.to_dict()
-        for attacker in self.attackers.values():
-            serialized_attackers[attacker.name] = attacker.to_dict()
-        logger.debug('Serialized %d attack steps and %d attackers.' %
-            (len(self.nodes), len(self.attackers))
-        )
         return {
-            'attack_steps': serialized_attack_steps,
-            'attackers': serialized_attackers,
+            'attack_steps': serialized_attack_steps
         }
 
     def __deepcopy__(self, memo):
@@ -139,24 +138,12 @@ class AttackGraph():
             if node.children:
                 memo[id(node)].children = copy.deepcopy(node.children, memo)
 
-        # Deep copy attackers
-        for attacker_id, attacker in self.attackers.items():
-            copied_attacker = copy.deepcopy(attacker, memo)
-            copied_attackgraph.attackers[attacker_id] = copied_attacker
-
-        # Re-link attacker references
-        for node in self.nodes.values():
-            if node.compromised_by:
-                memo[id(node)].compromised_by = copy.deepcopy(
-                    node.compromised_by, memo)
-
         # Copy lookup dicts
         copied_attackgraph._full_name_to_node = \
             copy.deepcopy(self._full_name_to_node, memo)
 
         # Copy counters
         copied_attackgraph.next_node_id = self.next_node_id
-        copied_attackgraph.next_attacker_id = self.next_attacker_id
 
         return copied_attackgraph
 
@@ -181,7 +168,6 @@ class AttackGraph():
         attack_graph = AttackGraph(lang_graph)
         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_dict in serialized_attack_steps.values():
@@ -205,7 +191,7 @@ class AttackGraph():
                 lg_attack_step = lg_attack_step,
                 node_id = node_dict['id'],
                 model_asset = node_asset,
-                defense_status = node_dict.get('defense_status', None),
+                ttc_dist = node_dict['ttc'],
                 existence_status = node_dict.get('existence_status', None)
             )
             ag_node.tags = set(node_dict.get('tags', []))
@@ -248,21 +234,6 @@ class AttackGraph():
                         raise LookupError(msg % parent_id)
                     _ag_node.parents.add(parent)
 
-        for attacker in serialized_attackers.values():
-            ag_attacker = Attacker(name = attacker['name'])
-            attack_graph.add_attacker(
-                attacker = ag_attacker,
-                attacker_id = int(attacker['id']),
-                entry_points = [
-                    int(node_id) # Convert to int since they can be strings
-                    for node_id in attacker['entry_points'].keys()
-                ],
-                reached_attack_steps = [
-                    int(node_id) # Convert to int since they can be strings
-                    for node_id in attacker['reached_attack_steps'].keys()
-                ]
-            )
-
         return attack_graph
 
     @classmethod
@@ -304,46 +275,6 @@ class AttackGraph():
         logger.debug(f'Looking up node with full name "%s"', full_name)
         return self._full_name_to_node.get(full_name)
 
-    def attach_attackers(self) -> None:
-        """
-        Create attackers and their entry point nodes and attach them to the
-        relevant attack step nodes and to the attackers.
-        """
-
-        if not self.model:
-            msg = "Can not attach attackers without a model"
-            logger.error(msg)
-            raise AttackGraphException(msg)
-
-        logger.info(
-            'Attach attackers from "%s" model to the graph.', self.model.name
-        )
-
-        for attacker_info in self.model.attackers:
-
-            if not attacker_info.name:
-                msg = "Can not attach attacker without name"
-                logger.error(msg)
-                raise AttackGraphException(msg)
-
-            attacker = Attacker(name = attacker_info.name)
-            self.add_attacker(attacker)
-
-            for (asset, attack_steps) in attacker_info.entry_points:
-                for attack_step in attack_steps:
-                    full_name = asset.name + ':' + attack_step
-                    ag_node = self.get_node_by_full_name(full_name)
-                    if not ag_node:
-                        logger.warning(
-                            'Failed to find attacker entry point '
-                            '%s for %s.',
-                            full_name, attacker.name
-                        )
-                        continue
-                    attacker.compromise(ag_node)
-
-            attacker.entry_points = set(attacker.reached_attack_steps)
-
     def _follow_expr_chain(
             self,
             model: Model,
@@ -535,18 +466,27 @@ class AttackGraph():
                     'Generating attack step node for %s.', attack_step.name
                 )
 
-                defense_status = None
                 existence_status = None
                 node_name = asset.name + ':' + attack_step.name
 
+                ttc_dist = copy.deepcopy(attack_step.ttc)
                 match (attack_step.type):
                     case 'defense':
-                        # Set the defense status for defenses
-                        defense_status = asset.defenses[attack_step.name]
-                        logger.debug(
-                            'Setting the defense status of \"%s\" to "%s".',
-                            node_name, defense_status
-                        )
+                        # Set the TTC probability for defenses
+                        # that were explicitly set in model
+                        if attack_step.name in asset.defenses:
+                            defense_value = float(
+                                asset.defenses[attack_step.name]
+                            )
+                            ttc_dist = {
+                                'arguments': [defense_value],
+                                'name': 'Bernoulli',
+                                'type': 'function'
+                            }
+                            logger.debug(
+                                'Setting defense \"%s\" to "%s".',
+                                node_name, defense_value
+                            )
 
                     case 'exist' | 'notExist':
                         # Resolve step expression associated with
@@ -577,7 +517,7 @@ class AttackGraph():
                 ag_node = self.add_node(
                     lg_attack_step = attack_step,
                     model_asset = asset,
-                    defense_status = defense_status,
+                    ttc_dist = ttc_dist,
                     existence_status = existence_status
                 )
                 attack_step_nodes.append(ag_node)
@@ -660,7 +600,6 @@ class AttackGraph():
         """
 
         self.nodes = {}
-        self.attackers = {}
         self._generate_graph()
 
     def add_node(
@@ -668,7 +607,7 @@ class AttackGraph():
             lg_attack_step: LanguageGraphAttackStep,
             node_id: Optional[int] = None,
             model_asset: Optional[ModelAsset] = None,
-            defense_status: Optional[float] = None,
+            ttc_dist: Optional[dict] = None,
             existence_status: Optional[bool] = None
         ) -> AttackGraphNode:
         """Create and add a node to the graph
@@ -685,9 +624,10 @@ class AttackGraph():
                               only be ommitted if the model which was used to
                               generate the attack graph is not available when
                               loading an attack graph from a file.
-        defese_status       - the defense status of the node. Only, relevant
-                              for defense type nodes. A value between 0.0 and
-                              1.0 is expected.
+        ttc_dist            - the ttc distribution to assign to the node. This
+                              is relevant for when we want to override the ttc
+                              distribution as it is defined in the language.
+                              Frequently used for defenses.
         existence_status    - the existence status of the node. Only, relevant
                               for exist and notExist type nodes.
 
@@ -712,7 +652,7 @@ class AttackGraph():
             node_id = node_id,
             lg_attack_step = lg_attack_step,
             model_asset = model_asset,
-            defense_status = defense_status,
+            ttc_dist = ttc_dist,
             existence_status = existence_status
         )
 
@@ -738,80 +678,3 @@ class AttackGraph():
             raise ValueError(f'Invalid node id.')
         del self.nodes[node.id]
         del self._full_name_to_node[node.full_name]
-
-    def add_attacker(
-            self,
-            attacker: Attacker,
-            attacker_id: Optional[int] = None,
-            entry_points: list[int] = [],
-            reached_attack_steps: list[int] = []
-        ):
-        """Add an attacker to the graph
-        Arguments:
-        attacker                - the attacker to add
-        attacker_id             - the id to assign to this attacker, usually
-                                  used when loading an attack graph from a
-                                  file
-        entry_points            - list of attack step ids that serve as entry
-                                  points for the attacker
-        reached_attack_steps    - list of ids of the attack steps that the
-                                  attacker has reached
-        """
-
-        if logger.isEnabledFor(logging.DEBUG):
-            # Avoid running json.dumps when not in debug
-            if attacker_id is not None:
-                logger.debug('Add attacker "%s" with id:%d.',
-                    attacker.name,
-                    attacker_id
-                )
-            else:
-                logger.debug('Add attacker "%s" without id.',
-                    attacker.name
-                )
-
-        attacker.id = attacker_id or self.next_attacker_id
-        if attacker.id in self.attackers:
-            raise ValueError(f'Attacker index {attacker_id} already in use.')
-
-        self.next_attacker_id = max(attacker.id + 1, self.next_attacker_id)
-        for node_id in reached_attack_steps:
-            node = self.nodes[node_id]
-            if node:
-                attacker.compromise(node)
-            else:
-                msg = ("Could not find node with id %d"
-                       "in reached attack steps.")
-                logger.error(msg, node_id)
-                raise AttackGraphException(msg % node_id)
-        for node_id in entry_points:
-            node = self.nodes[node_id]
-            if node:
-                attacker.entry_points.add(node)
-            else:
-                msg = ("Could not find node with id %d"
-                       "in attacker entrypoints.")
-                logger.error(msg, node_id)
-                raise AttackGraphException(msg % node_id)
-        self.attackers[attacker.id] = attacker
-
-    def remove_attacker(self, attacker: Attacker):
-        """Remove attacker from attack graph
-        Arguments:
-        attacker    - the attacker we wish to remove from the attack graph
-        """
-        if logger.isEnabledFor(logging.DEBUG):
-            # Avoid running json.dumps when not in debug
-            logger.debug(
-                'Remove attacker "%s" with id:%d.',
-                attacker.name, attacker.id
-            )
-
-        # Copy set - we can not remove elements from a set we are looping over
-        nodes_to_uncompromise = set(attacker.reached_attack_steps)
-        for node in nodes_to_uncompromise:
-            attacker.undo_compromise(node)
-
-        if not isinstance(attacker.id, int):
-            raise ValueError(f'Invalid attacker id: {attacker.id}')
-        del self.attackers[attacker.id]