mal-toolbox 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

{mal_toolbox-0.2.0.dist-info → mal_toolbox-0.3.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.2
 Name: mal-toolbox
-Version: 0.2.0
+Version: 0.3.0
 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>
+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
 Project-URL: Homepage, https://github.com/mal-lang/mal-toolbox
 Project-URL: Bug Tracker, https://github.com/mal-lang/mal-toolbox/issues
@@ -19,7 +19,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: py2neo>=2021.2.3
-Requires-Dist: python-jsonschema-objects>=0.5.5
 Requires-Dist: antlr4-tools
 Requires-Dist: antlr4-python3-runtime
 Requires-Dist: docopt
@@ -48,17 +47,6 @@ then be used to generate python classes representing the assets and
 associations of the language and to determine the attack steps for each asset
 when generating the attack graph.
 
-### The Language Classes Factory Submodule
-
-The language classes factory submodule is used to generate python classes
-using the `python_jsonschema_objects` package from a language specification.
-The classes generated by the `create_classes` function can then be accessed
-from within that namespace(.e.g: `lang_classes_factory.ns.Application()`,
-`lang_classes_factory.ns.AppExecution()`). Because these classes are built
-using JSON Schema validators they will enforce their restrictions when using
-the python objects created. These classes are typically used in conjunction
-with model module to create instance models.
-
 ## The Model Module
 
 With a MAL language a Model (a MAL instance model) can be created either
@@ -109,21 +97,51 @@ pip install mal-toolbox
 ```
 
 ## Configuration
-A default configuration file `default.conf` can be found in the package
-directory. This contains the default values to use for logging and can also be
-used to store the information needed to access the local Neo4J instance.
+You can use a `maltoolbox.yml` file in the current working directory to
+configure the toolbox. Alternatively, you can use the `MALTOOLBOX_CONFIG`
+environment variable to set a custom config file location:
+
+"""bash
+# in your shell, e.g. bash do:
+export MALTOOLBOX_CONFIG=path/to/yml/config/file
+"""
+
+The default configuration can be found here:
+
+https://github.com/mal-lang/mal-toolbox/blob/main/maltoolbox/__init__.py#L39-L53
 
 ## Command Line Client
-In addition to the modules that make up the MAL-Toolbox package it also
-provides a simple command line client that can be used to easily generate
-attack graphs from a .mar language specification file and a JSON instance
-model file.
 
-The usage is: `maltoolbox gen_ag [--neo4j] <model_json_file>
-<language_mar_file>`
+You can use the maltoolbox cli to:
+
+- Generate attack graphs from model files
+- Compile MAL languages
+- Upgrade model files from older versions
 
-If the `--neo4j` flag is specified the model and attack graph will be loaded
-into a local Neo4J instance.
+```
+Command-line interface for MAL toolbox operations
+
+Usage:
+    maltoolbox attack-graph generate [options] <model_file> <lang_file>
+    maltoolbox compile <lang_file> <output_file>
+    maltoolbox upgrade-model <model_file> <lang_file> <output_file>
+
+Arguments:
+    <model_file>    Path to JSON instance model file.
+    <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-0.3.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+maltoolbox/__init__.py,sha256=q_M3mEsQW1IFQ5xVZ3fK0gVyt8r_c2kxUC3ZDAtPmII,2088
+maltoolbox/__main__.py,sha256=PSg8vFS8X-klJBJdSzrg0aLh9ykZgbcoSSEy3DTQoQQ,3499
+maltoolbox/exceptions.py,sha256=0YjPx2v1yYumZ2o7pVZ1s_jS-GAb3Ng979KEFhROSNY,1399
+maltoolbox/file_utils.py,sha256=tBR8Kjl8IoFzAtYaLNHNALuQrdMT3pD1ZpczHm1pu2g,1875
+maltoolbox/model.py,sha256=XCneM5Hdl2GQhtgXYq0SUAlHBksXn7okevIsSKMSwVY,24084
+maltoolbox/attackgraph/__init__.py,sha256=AHDyX6dAkx3mDic2K56v1xche9N6ofDfbaHkKbdJ2qQ,230
+maltoolbox/attackgraph/attacker.py,sha256=dKMAcOwlNM3LL8qh1tBJuzjFxlTNG-QI2st1LzP8Ofc,4030
+maltoolbox/attackgraph/attackgraph.py,sha256=A5TjDE-B4c0hY28M4IVwHVFhM_ww2eAt7uITjSUCNKc,32495
+maltoolbox/attackgraph/node.py,sha256=Ec67_u_8qf_MgCHaUg4wIbZFC013GWxbIsC8EjoguzE,6465
+maltoolbox/attackgraph/query.py,sha256=s66EQcHlldn7XLCWxZ2FRjZTgk8o3V0mD4LnRaImdCw,6836
+maltoolbox/attackgraph/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maltoolbox/attackgraph/analyzers/apriori.py,sha256=iH1KvKbMi9J3_1qia8FXI80O3ZMQ1LP67HkXbqweq-c,8802
+maltoolbox/ingestors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maltoolbox/ingestors/neo4j.py,sha256=gjQQqk0HVI8ojIqwS1ymt7-_ZvDOTNi8AcczDAlvsGs,8310
+maltoolbox/language/__init__.py,sha256=9p5nvVqDCKEhXbDMIz1MtwZ9GN7x1jmUUXbpjEwuqnw,269
+maltoolbox/language/languagegraph.py,sha256=npP1lX1EE1rqqKNr9qTb4Jylvdn5JYApNyJhjwSebJs,67785
+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=PJYjieioWN5tE_oKm83dtgV5UkC8EUH9Vsy3-FxBtUo,7017
+maltoolbox/translators/updater.py,sha256=8bisZnzMWjGaG5tu8jdF-Oq6bPwIjXkVO-_yZDGc6cA,8652
+mal_toolbox-0.3.0.dist-info/AUTHORS,sha256=zxLrLe8EY39WtRKlAY4Oorx4Z2_LHV2ApRvDGZgY7xY,127
+mal_toolbox-0.3.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mal_toolbox-0.3.0.dist-info/METADATA,sha256=Yfkp5QVZL6W4DIsYkQqRQU3HpTC6dkrVCHsfchgb4k0,6158
+mal_toolbox-0.3.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mal_toolbox-0.3.0.dist-info/entry_points.txt,sha256=oqby5O6cUP_OHCm70k_iYPA6UlbTBf7se1i3XwdK3uU,56
+mal_toolbox-0.3.0.dist-info/top_level.txt,sha256=phqRVLRKGdSUgRY03mcpi2cmbbDo5YGjkV4gkqHFFcM,11
+mal_toolbox-0.3.0.dist-info/RECORD,,

mal_toolbox-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+maltoolbox = maltoolbox.__main__:main

maltoolbox/__init__.py

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-# MAL Toolbox v0.2.0
+# MAL Toolbox v0.3.0
 # Copyright 2024, Andrei Buhaiu.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,75 +20,56 @@
 MAL-Toolbox Framework
 """
 
-__title__ = 'maltoolbox'
-__version__ = '0.2.0'
-__authors__ = ['Andrei Buhaiu',
-    'Giuseppe Nebbione',
-    'Nikolaos Kakouros',
-    'Jakob Nyberg',
-    'Joakim Loxdal']
-__license__ = 'Apache 2.0'
-__docformat__ = 'restructuredtext en'
+__title__ = "maltoolbox"
+__version__ = "0.3.0"
+__authors__ = [
+    "Andrei Buhaiu",
+    "Giuseppe Nebbione",
+    "Nikolaos Kakouros",
+    "Jakob Nyberg",
+    "Joakim Loxdal",
+]
+__license__ = "Apache 2.0"
+__docformat__ = "restructuredtext en"
 
 __all__ = ()
 
 import os
-import configparser
+import yaml
 import logging
+from typing import Any
+
+config: dict[str, Any] = {
+    "logging": {
+        "log_level": logging.INFO,
+        "log_file": "logs/log.txt",
+        "attackgraph_file": "logs/attackgraph.yml",
+        "model_file": "logs/model.yml",
+        "langspec_file": "logs/langspec_file.yml",
+    },
+    "neo4j": {"uri": None, "username": None, "password": None, "dbname": None},
+}
 
-ERROR_INCORRECT_CONFIG = 1
-
-CONFIGFILE = os.path.join(
-    os.path.dirname(os.path.abspath(__file__)),
-    "default.conf"
-)
-
-config = configparser.ConfigParser()
-config.read(CONFIGFILE)
+config_file = os.getenv("MALTOOLBOX_CONFIG", "maltoolbox.yml")
 
-if 'logging' not in config:
-    raise ValueError('Config file is missing essential information, cannot proceed.')
+if os.path.exists(config_file):
+    with open(config_file) as f:
+        config |= yaml.safe_load(f)
 
-if 'log_file' not in config['logging']:
-    raise ValueError('Config file is missing a log_file location, cannot proceed.')
+log_configs, neo4j_configs = config.values()
 
-log_configs = {
-    'log_file': config['logging']['log_file'],
-    'log_level': config['logging']['log_level'],
-    'attackgraph_file': config['logging']['attackgraph_file'],
-    'model_file': config['logging']['model_file'],
-    'langspec_file': config['logging']['langspec_file'],
-}
+os.makedirs(os.path.dirname(log_configs["log_file"]), exist_ok=True)
 
-os.makedirs(os.path.dirname(log_configs['log_file']), exist_ok = True)
-
-formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M')
-file_handler = logging.FileHandler(log_configs['log_file'], mode='w')
+formatter = logging.Formatter(
+    "%(asctime)s %(name)-12s %(levelname)-8s %(message)s", datefmt="%m-%d %H:%M"
+)
+file_handler = logging.FileHandler(log_configs["log_file"], mode="w")
 file_handler.setFormatter(formatter)
 
 logger = logging.getLogger(__name__)
 logger.addHandler(file_handler)
 
-log_level = log_configs['log_level']
-if log_level != '':
-    level = logging.getLevelName(log_level)
-    logger.setLevel(level)
-    logger.info('Set loggin level of %s to %s.', __name__, log_level)
-
-if 'neo4j' in config:
-    for term in ['uri', 'username', 'password', 'dbname']:
-        if term not in config['neo4j']:
-
-            msg = (
-                'Config file is missing essential Neo4J '
-                f'information: {term}, cannot proceed.'
-            )
-            logger.critical(msg)
-            raise ValueError(msg)
+logger.setLevel(log_configs.get("log_level"))
+logger.info("Set loggin level of %s to %s.", __name__, log_configs.get("log_level"))
 
-    neo4j_configs = {
-        'uri': config['neo4j']['uri'],
-        'username': config['neo4j']['username'],
-        'password': config['neo4j']['password'],
-        'dbname': config['neo4j']['dbname'],
-    }
+logger.debug("Config file location: %s", config_file)

maltoolbox/__main__.py

@@ -2,13 +2,14 @@
 Command-line interface for MAL toolbox operations
 
 Usage:
-    maltoolbox attack-graph generate [options] <model> <lang_file>
+    maltoolbox attack-graph generate [options] <model_file> <lang_file>
     maltoolbox compile <lang_file> <output_file>
+    maltoolbox upgrade-model <model_file> <lang_file> <output_file>
 
 Arguments:
-    <model>         Path to JSON instance model file.
+    <model_file>    Path to JSON instance model file.
     <lang_file>     Path to .mar or .mal file containing MAL spec.
-    <output_file>   Path to write the JSON result of the compilation.
+    <output_file>   Path to write the result of the compilation (yml/json).
 
 Options:
     --neo4j         Ingest attack graph and instance model into a Neo4j instance
@@ -26,10 +27,12 @@ import logging
 import json
 import docopt
 
-from maltoolbox.wrappers import create_attack_graph
 from . import log_configs, neo4j_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
 
 logger = logging.getLogger(__name__)
 
@@ -39,7 +42,7 @@ def generate_attack_graph(
         send_to_neo4j: bool
     ) -> None:
     """Create an attack graph and optionally send to neo4j
-    
+
     Args:
     model_file      - path to the model file
     lang_file       - path to the language file
@@ -53,19 +56,23 @@ def generate_attack_graph(
 
     if send_to_neo4j:
         logger.debug('Ingest model graph into Neo4J database.')
-        neo4j.ingest_model(attack_graph.model,
+        neo4j.ingest_model(
+            attack_graph.model,
             neo4j_configs['uri'],
             neo4j_configs['username'],
             neo4j_configs['password'],
             neo4j_configs['dbname'],
-            delete=True)
+            delete=True
+        )
         logger.debug('Ingest attack graph into Neo4J database.')
-        neo4j.ingest_attack_graph(attack_graph,
+        neo4j.ingest_attack_graph(
+            attack_graph,
             neo4j_configs['uri'],
             neo4j_configs['username'],
             neo4j_configs['password'],
             neo4j_configs['dbname'],
-            delete=False)
+            delete=False
+        )
 
 
 def compile(lang_file: str, output_file: str) -> None:
@@ -75,9 +82,31 @@ def compile(lang_file: str, output_file: str) -> None:
         json.dump(compiler.compile(lang_file), f, indent=2)
 
 
-args = docopt.docopt(__doc__)
+def upgrade_model(model_file: str, lang_file: str, output_file: str):
+    lang_graph = LanguageGraph.load_from_file(lang_file)
+
+    if log_configs['langspec_file']:
+        lang_graph.save_to_file(log_configs['langspec_file'])
+
+    model = load_model_from_older_version(model_file, lang_graph)
+    model.save_to_file(output_file)
+
+
+def main():
+    args = docopt.docopt(__doc__)
+
+    if args['attack-graph'] and args['generate']:
+        generate_attack_graph(
+            args['<model_file>'], args['<lang_file>'], args['--neo4j']
+        )
+    elif args['compile']:
+        compile(
+            args['<lang_file>'], args['<output_file>']
+        )
+    elif args['upgrade-model']:
+        upgrade_model(
+            args['<model_file>'], args['<lang_file>'], args['<output_file>']
+        )
 
-if args['attack-graph'] and args['generate']:
-    generate_attack_graph(args['<model>'], args['<lang_file>'], args['--neo4j'])
-elif args['compile']:
-    compile(args['<lang_file>'], args['<output_file>'])
+if __name__ == "__main__":
+    main()

maltoolbox/attackgraph/__init__.py

@@ -4,5 +4,5 @@ models and analyze attack graphs.
 """
 
 from .attacker import Attacker
-from .attackgraph import AttackGraph
+from .attackgraph import AttackGraph, create_attack_graph
 from .node import AttackGraphNode

maltoolbox/attackgraph/analyzers/apriori.py

@@ -12,11 +12,12 @@ Currently these are:
 """
 
 from __future__ import annotations
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 import logging
 
-from ..attackgraph import AttackGraph
-from ..node import AttackGraphNode
+if TYPE_CHECKING:
+    from ..attackgraph import AttackGraph
+    from ..node import AttackGraphNode
 
 logger = logging.getLogger(__name__)
 
@@ -162,7 +163,7 @@ def calculate_viability_and_necessity(graph: AttackGraph) -> None:
     graph       - the attack graph for which we wish to determine the
                   viability and necessity statuses for the nodes.
     """
-    for node in graph.nodes:
+    for node in graph.nodes.values():
         if node.type in ['exist', 'notExist', 'defense']:
             evaluate_viability_and_necessity(node)
             if not node.is_viable:
@@ -178,7 +179,7 @@ def prune_unviable_and_unnecessary_nodes(graph: AttackGraph) -> None:
                   the nodes which are not viable or necessary.
     """
     logger.debug('Prune unviable and unnecessary nodes from the attack graph.')
-    for node in graph.nodes:
+    for node in graph.nodes.values():
         if (node.type == 'or' or node.type == 'and') and \
             (not node.is_viable or not node.is_necessary):
             graph.remove_node(node)

maltoolbox/attackgraph/attacker.py

@@ -3,7 +3,6 @@ MAL-Toolbox Attack Graph Attacker Class
 """
 
 from __future__ import annotations
-from dataclasses import dataclass, field
 import copy
 import logging
 
@@ -14,13 +13,19 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-@dataclass
 class Attacker:
-    name: str
-    entry_points: list[AttackGraphNode] = field(default_factory=list)
-    reached_attack_steps: list[AttackGraphNode] = \
-        field(default_factory=list)
-    id: Optional[int] = None
+
+    def __init__(
+        self,
+        name: str,
+        entry_points: set[AttackGraphNode],
+        reached_attack_steps: set[AttackGraphNode],
+        attacker_id: Optional[int] = None
+    ):
+        self.name = name
+        self.entry_points = entry_points
+        self.reached_attack_steps = reached_attack_steps
+        self.id = attacker_id
 
     def to_dict(self) -> dict:
         attacker_dict: dict = {
@@ -40,18 +45,26 @@ class Attacker:
         return attacker_dict
 
     def __repr__(self) -> str:
-        return str(self.to_dict())
+        return f'Attacker(name: "{self.name}", id: {self.id})'
 
     def __deepcopy__(self, memo) -> Attacker:
-        """Deep copy an Attacker"""
+        """Deep copy an Attacker
+        The deepcopy will copy over attacker specific information, name and
+        id, but it will not copy relations to attack graph nodes, reached
+        attack steps or entry points. These references should be recreated
+        when deepcopying the attack graph itself.
+
+        """
 
         # Check if the object is already in the memo dictionary
         if id(self) in memo:
             return memo[id(self)]
 
         copied_attacker = Attacker(
-            id = self.id,
             name = self.name,
+            attacker_id = self.id,
+            entry_points = set(),
+            reached_attack_steps = set()
         )
 
         # Remember that self was already copied
@@ -66,7 +79,7 @@ class Attacker:
 
     def compromise(self, node: AttackGraphNode) -> None:
         """
-        Have the attacke compromise the node given as a parameter.
+        Have the attacker compromise the node given as a parameter.
 
         Arguments:
         node    - the node that the attacker will compromise
@@ -90,8 +103,8 @@ class Attacker:
             )
             return
 
-        node.compromised_by.append(self)
-        self.reached_attack_steps.append(node)
+        node.compromised_by.add(self)
+        self.reached_attack_steps.add(node)
 
     def undo_compromise(self, node: AttackGraphNode) -> None:
         """