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

maltoolbox/language/languagegraph.py

@@ -4,12 +4,12 @@ MAL-Toolbox Language Graph Module
 
 from __future__ import annotations
 
-import copy
 import logging
 import json
 import zipfile
 
 from dataclasses import dataclass, field
+from functools import cached_property
 from typing import Any, Optional
 
 from maltoolbox.file_utils import (
@@ -26,43 +26,91 @@ from ..exceptions import (
 
 logger = logging.getLogger(__name__)
 
+
+def disaggregate_attack_step_full_name(
+        attack_step_full_name: str) -> list[str]:
+    return attack_step_full_name.split(':')
+
+
+@dataclass
+class Detector:
+    context: Context
+    name: Optional[str]
+    type: Optional[str]
+    tprate: Optional[dict]
+
+    def to_dict(self) -> dict:
+        return {
+            "context": self.context.to_dict(),
+            "name": self.name,
+            "type": self.type,
+            "tprate": self.tprate,
+        }
+
+
+class Context(dict):
+    def __init__(self, context) -> None:
+        super().__init__(context)
+        self._context_dict = context
+        for label, asset in context.items():
+            setattr(self, label, asset)
+
+    def to_dict(self) -> dict:
+        return {label: asset.name for label, asset in self.items()}
+
+    def __str__(self) -> str:
+        return str({label: asset.name for label, asset in self._context_dict.items()})
+
+
 @dataclass
 class LanguageGraphAsset:
-    name: Optional[str] = None
-    associations: list[LanguageGraphAssociation] = field(default_factory=lambda: [])
-    attack_steps: list[LanguageGraphAttackStep] = field(default_factory=lambda: [])
-    description: dict = field(default_factory=lambda: {})
-    # MAL languages currently do not support multiple inheritance, but this is
-    # futureproofing at its most hopeful.
-    super_assets: list = field(default_factory=lambda: [])
-    sub_assets: list = field(default_factory=lambda: [])
+    name: str
+    own_associations: dict[str, LanguageGraphAssociation] = \
+        field(default_factory = dict)
+    attack_steps: dict[str, LanguageGraphAttackStep] = \
+        field(default_factory = dict)
+    info: dict = field(default_factory = dict)
+    own_super_asset: Optional[LanguageGraphAsset] = None
+    own_sub_assets: set[LanguageGraphAsset] = field(default_factory = set)
+    own_variables: dict = field(default_factory = dict)
     is_abstract: Optional[bool] = None
 
+
     def to_dict(self) -> dict:
         """Convert LanguageGraphAsset to dictionary"""
         node_dict: dict[str, Any] = {
             'name': self.name,
-            'associations': [],
-            'attack_steps': [],
-            'description': self.description,
-            'super_assets': [],
-            'sub_assets': []
+            'associations': {},
+            'attack_steps': {},
+            'info': self.info,
+            'super_asset': self.own_super_asset.name \
+                if self.own_super_asset else "",
+            'sub_assets': [asset.name for asset in self.own_sub_assets],
+            'variables': {},
+            'is_abstract': self.is_abstract
         }
 
-        for assoc in self.associations:
-            node_dict['associations'].append((assoc.name,
-                assoc.left_field.fieldname,
-                assoc.right_field.fieldname))
-        for attack_step in self.attack_steps:
-            node_dict['attack_steps'].append(attack_step.name)
-        for super_asset in self.super_assets:
-            node_dict['super_assets'].append(super_asset.name)
-        for sub_asset in self.sub_assets:
-            node_dict['sub_assets'].append(sub_asset.name)
+        for fieldname, assoc in self.own_associations.items():
+            node_dict['associations'][fieldname] = assoc.to_dict()
+        for attack_step in self.attack_steps.values():
+            node_dict['attack_steps'][attack_step.name] = \
+                attack_step.to_dict()
+        for variable_name, (var_target_asset, var_expr_chain) in \
+                self.own_variables.items():
+            node_dict['variables'][variable_name] = (
+                var_target_asset.name,
+                var_expr_chain.to_dict()
+            )
         return node_dict
 
+
     def __repr__(self) -> str:
-        return str(self.to_dict())
+        return f'LanguageGraphAsset(name: "{self.name}")'
+
+
+    def __hash__(self):
+        return hash(self.name)
+
 
     def is_subasset_of(self, target_asset: LanguageGraphAsset) -> bool:
         """
@@ -76,15 +124,16 @@ class LanguageGraphAsset:
         True if this asset extends the target_asset via inheritance.
         False otherwise.
         """
-        current_assets = [self]
-        while (current_assets):
-            current_asset = current_assets.pop()
+        current_asset: Optional[LanguageGraphAsset] = self
+        while (current_asset):
             if current_asset == target_asset:
                 return True
-            current_assets.extend(current_asset.super_assets)
+            current_asset = current_asset.own_super_asset
         return False
 
-    def get_all_subassets(self) -> list[LanguageGraphAsset]:
+
+    @cached_property
+    def sub_assets(self) -> set[LanguageGraphAsset]:
         """
         Return a list of all of the assets that directly or indirectly extend
         this asset.
@@ -92,15 +141,18 @@ class LanguageGraphAsset:
         Return:
         A list of all of the assets that extend this asset plus itself.
         """
-        current_assets = [self]
-        subassets = [self]
-        while (current_assets):
-            current_asset = current_assets.pop()
-            current_assets.extend(current_asset.sub_assets)
-            subassets.extend(current_asset.sub_assets)
-        return subassets
-
-    def get_all_superassets(self) -> list[LanguageGraphAsset]:
+        subassets: list[LanguageGraphAsset] = []
+        for subasset in self.own_sub_assets:
+            subassets.extend(subasset.sub_assets)
+
+        subassets.extend(self.own_sub_assets)
+        subassets.append(self)
+
+        return set(subassets)
+
+
+    @cached_property
+    def super_assets(self) -> list[LanguageGraphAsset]:
         """
         Return a list of all of the assets that this asset directly or
         indirectly extends.
@@ -108,24 +160,79 @@ class LanguageGraphAsset:
         Return:
         A list of all of the assets that this asset extends plus itself.
         """
-        current_assets = [self]
-        superassets = [self]
-        while (current_assets):
-            current_asset = current_assets.pop()
-            current_assets.extend(current_asset.super_assets)
-            superassets.extend(current_asset.super_assets)
+        current_asset: Optional[LanguageGraphAsset] = self
+        superassets = []
+        while (current_asset):
+            superassets.append(current_asset)
+            current_asset = current_asset.own_super_asset
         return superassets
 
+
+    @cached_property
+    def associations(self) -> dict[str, LanguageGraphAssociation]:
+        """
+        Return a list of all of the associations that belong to this asset
+        directly or indirectly via inheritance.
+
+        Return:
+        A list of all of the associations that apply to this asset, either
+        directly or via inheritance.
+        """
+
+        associations = dict(self.own_associations)
+        if self.own_super_asset:
+            associations |= self.own_super_asset.associations
+        return associations
+
+
+    @property
+    def variables(self) -> dict[str, ExpressionsChain]:
+        """
+        Return a list of all of the variables that belong to this asset
+        directly or indirectly via inheritance.
+
+        Return:
+        A list of all of the variables that apply to this asset, either
+        directly or via inheritance.
+        """
+
+        all_vars = dict(self.own_variables)
+        if self.own_super_asset:
+            all_vars |= self.own_super_asset.variables
+        return all_vars
+
+
+    def get_variable(
+        self,
+        var_name: str,
+        ) -> Optional[tuple]:
+        """
+        Return a variable matching the given name if the asset or any of its
+        super assets has its definition.
+
+        Return:
+        A tuple containing the target asset and expressions chain to it if the
+        variable was defined.
+        None otherwise.
+        """
+        current_asset: Optional[LanguageGraphAsset] = self
+        while (current_asset):
+            if var_name in current_asset.own_variables:
+                return current_asset.own_variables[var_name]
+            current_asset = current_asset.own_super_asset
+        return None
+
+
     def get_all_common_superassets(
             self, other: LanguageGraphAsset
-        ) -> set[Optional[str]]:
+        ) -> set[str]:
         """Return a set of all common ancestors between this asset
         and the other asset given as parameter"""
         self_superassets = set(
-            asset.name for asset in self.get_all_superassets()
+            asset.name for asset in self.super_assets
         )
         other_superassets = set(
-            asset.name for asset in other.get_all_superassets()
+            asset.name for asset in other.super_assets
         )
         return self_superassets.intersection(other_superassets)
 
@@ -143,12 +250,13 @@ class LanguageGraphAssociation:
     name: str
     left_field: LanguageGraphAssociationField
     right_field: LanguageGraphAssociationField
-    description: Optional[dict] = None
+    info: dict = field(default_factory = dict)
 
     def to_dict(self) -> dict:
         """Convert LanguageGraphAssociation to dictionary"""
-        node_dict = {
+        assoc_dict = {
             'name': self.name,
+            'info': self.info,
             'left': {
                 'asset': self.left_field.asset.name,
                 'fieldname': self.left_field.fieldname,
@@ -160,14 +268,41 @@ class LanguageGraphAssociation:
                 'fieldname': self.right_field.fieldname,
                 'min': self.right_field.minimum,
                 'max': self.right_field.maximum
-            },
-            'description': self.description
+            }
         }
 
-        return node_dict
+        return assoc_dict
+
 
     def __repr__(self) -> str:
-        return str(self.to_dict())
+        return (f'LanguageGraphAssociation(name: "{self.name}", '
+            f'left_field: {self.left_field}, '
+            f'right_field: {self.right_field})')
+
+
+    @property
+    def full_name(self) -> str:
+        """
+        Return the full name of the association. This is a combination of the
+        association name, left field name, left asset type, right field name,
+        and right asset type.
+        """
+        full_name = '%s_%s_%s' % (
+            self.name,\
+            self.left_field.fieldname,\
+            self.right_field.fieldname
+            )
+        return full_name
+
+
+    def get_field(self, fieldname: str) -> LanguageGraphAssociationField:
+        """
+        Return the field that matches the `fieldname` given as parameter.
+        """
+        if self.right_field.fieldname == fieldname:
+            return self.right_field
+        return self.left_field
+
 
     def contains_fieldname(self, fieldname: str) -> bool:
         """
@@ -184,6 +319,7 @@ class LanguageGraphAssociation:
             return True
         return False
 
+
     def contains_asset(self, asset: Any) -> bool:
         """
         Check if the association matches the asset given as a parameter. A
@@ -201,6 +337,7 @@ class LanguageGraphAssociation:
             return True
         return False
 
+
     def get_opposite_fieldname(self, fieldname: str) -> str:
         """
         Return the opposite field name if the association contains the field
@@ -221,49 +358,36 @@ class LanguageGraphAssociation:
         logger.error(msg, fieldname, self.name)
         raise LanguageGraphAssociationError(msg % (fieldname, self.name))
 
-    def get_opposite_asset(
-            self, asset: LanguageGraphAsset
-        ) -> Optional[LanguageGraphAsset]:
-        """
-        Return the opposite asset if the association matches the asset given
-        as a parameter. A match can either be an explicit one or if the asset
-        given subassets either of the two assets that are part of the
-        association.
-
-        Arguments:
-        asset       - the asset to look for
-        Return the other asset if the parameter matched either of the
-        two. None, otherwise.
-        """
-        #TODO Should check to see which one is the tightest fit for
-        #     associations between assets on different levels of the same
-        #     inheritance chain.
-        if asset.is_subasset_of(self.left_field.asset):
-            return self.right_field.asset
-        if asset.is_subasset_of(self.right_field.asset):
-            return self.left_field.asset
-
-        logger.warning(
-            'Requested asset "%s" from association %s'
-            'which did not contain it!', asset.name, self.name
-        )
-        return None
-
 
 @dataclass
 class LanguageGraphAttackStep:
     name: str
     type: str
     asset: LanguageGraphAsset
-    ttc: dict = field(default_factory = lambda: {})
-    children: dict = field(default_factory = lambda: {})
-    parents: dict = field(default_factory = lambda: {})
-    description: dict = field(default_factory = lambda: {})
-    attributes: Optional[dict] = None
+    ttc: dict = field(default_factory = dict)
+    overrides: bool = False
+    children: dict = field(default_factory = dict)
+    parents: dict = field(default_factory = dict)
+    info: dict = field(default_factory = dict)
+    inherits: Optional[LanguageGraphAttackStep] = None
+    tags: set = field(default_factory = set)
+    _attributes: Optional[dict] = None
+    detectors: dict = field(default_factory = lambda: {})
+
+
+    def __hash__(self):
+        return hash(self.full_name)
+
 
     @property
-    def qualified_name(self) -> str:
-        return f"{self.asset.name}:{self.name}"
+    def full_name(self) -> str:
+        """
+        Return the full name of the attack step. This is a combination of the
+        asset type name to which the attack step belongs and attack step name
+        itself.
+        """
+        full_name = self.asset.name + ':' + self.name
+        return full_name
 
     def to_dict(self) -> dict:
         node_dict: dict[Any, Any] = {
@@ -273,95 +397,140 @@ class LanguageGraphAttackStep:
             'ttc': self.ttc,
             'children': {},
             'parents': {},
-            'description': self.description
+            'info': self.info,
+            'overrides': self.overrides,
+            'inherits': self.inherits.full_name if self.inherits else None,
+            'tags': list(self.tags),
+            'detectors': {label: detector.to_dict() for label, detector in
+            self.detectors.items()},
         }
 
         for child in self.children:
             node_dict['children'][child] = []
-            for (_, dep_chain) in self.children[child]:
-                if dep_chain:
+            for (_, expr_chain) in self.children[child]:
+                if expr_chain:
                     node_dict['children'][child].append(
-                        dep_chain.to_dict())
+                        expr_chain.to_dict())
                 else:
                     node_dict['children'][child].append(None)
 
         for parent in self.parents:
             node_dict['parents'][parent] = []
-            for (_, dep_chain) in self.parents[parent]:
-                if dep_chain:
+            for (_, expr_chain) in self.parents[parent]:
+                if expr_chain:
                     node_dict['parents'][parent].append(
-                        dep_chain.to_dict())
+                        expr_chain.to_dict())
                 else:
                     node_dict['parents'][parent].append(None)
 
+        if hasattr(self, 'own_requires'):
+            node_dict['requires'] = []
+            for requirement in self.own_requires:
+                node_dict['requires'].append(requirement.to_dict())
+
         return node_dict
 
+
+    @cached_property
+    def requires(self):
+        if not hasattr(self, 'own_requires'):
+            requirements = []
+        else:
+            requirements = self.own_requires
+
+        if self.inherits:
+            requirements.extend(self.inherits.requires)
+        return requirements
+
+
     def __repr__(self) -> str:
         return str(self.to_dict())
 
 
-class DependencyChain:
-    def __init__(self, type: str, next_link: Optional[DependencyChain]):
+class ExpressionsChain:
+    def __init__(self,
+            type: str,
+            left_link: Optional[ExpressionsChain] = None,
+            right_link: Optional[ExpressionsChain] = None,
+            sub_link: Optional[ExpressionsChain] = None,
+            fieldname: Optional[str] = None,
+            association = None,
+            subtype = None
+        ):
         self.type = type
-        self.next_link: Optional[DependencyChain] = next_link
-        self.fieldname: str = ""
-        self.association: Optional[LanguageGraphAssociation] = None
-        self.left_chain: Optional[DependencyChain] = None
-        self.right_chain: Optional[DependencyChain] = None
-        self.subtype: Optional[Any] = None
-        self.current_link: Optional[DependencyChain] = None
-
-    def __iter__(self):
-        self.current_link = self
-        return self
-
-    def __next__(self):
-        if self.current_link:
-            dep_chain = self.current_link
-            self.current_link = self.current_link.next_link
-            return dep_chain
-        raise StopIteration
+        self.left_link: Optional[ExpressionsChain] = left_link
+        self.right_link: Optional[ExpressionsChain] = right_link
+        self.sub_link: Optional[ExpressionsChain] = sub_link
+        self.fieldname: Optional[str] = fieldname
+        self.association: Optional[LanguageGraphAssociation] = association
+        self.subtype: Optional[Any] = subtype
+
 
     def to_dict(self) -> dict:
-        """Convert DependencyChain to dictionary"""
+        """Convert ExpressionsChain to dictionary"""
         match (self.type):
-            case 'union' | 'intersection' | 'difference':
-                return {self.type: {
-                    'left': self.left_chain.to_dict()
-                            if self.left_chain else {},
-                    'right': self.right_chain.to_dict()
-                             if self.right_chain else {}
-                    }
+            case 'union' | 'intersection' | 'difference' | 'collect':
+                return {
+                    self.type: {
+                        'left': self.left_link.to_dict()
+                                if self.left_link else {},
+                        'right': self.right_link.to_dict()
+                                 if self.right_link else {}
+                    },
+                    'type': self.type
                 }
 
             case 'field':
                 if not self.association:
-                    raise LanguageGraphAssociationError("Missing association for dep chain")
-                return {self.association.name:
-                    {'fieldname': self.fieldname,
-                     'next_association':
-                            self.next_link.to_dict()
-                            if self.next_link else {}
-                        }
-                    }
+                    raise LanguageGraphAssociationError(
+                        "Missing association for expressions chain"
+                    )
+                if self.fieldname == self.association.left_field.fieldname:
+                    asset_type = self.association.left_field.asset.name
+                elif self.fieldname == self.association.right_field.fieldname:
+                    asset_type = self.association.right_field.asset.name
+                else:
+                    raise LanguageGraphException(
+                        'Failed to find fieldname "%s" in association:\n%s' %
+                        (
+                            self.fieldname,
+                            json.dumps(self.association.to_dict(),
+                                indent = 2)
+                        )
+                    )
+
+                return {
+                    self.association.name:
+                    {
+                        'fieldname': self.fieldname,
+                        'asset type': asset_type
+                    },
+                    'type': self.type
+                }
 
             case 'transitive':
-                return {'transitive':
-                    self.next_link.to_dict()
-                    if self.next_link else {}
+                if not self.sub_link:
+                    raise LanguageGraphException(
+                        "No sub link for transitive expressions chain"
+                    )
+                return {
+                    'transitive': self.sub_link.to_dict(),
+                    'type': self.type
                 }
 
             case 'subType':
                 if not self.subtype:
                     raise LanguageGraphException(
-                        "No subtype for dependency chain"
+                        "No subtype for expressions chain"
                     )
-                if not self.next_link:
+                if not self.sub_link:
                     raise LanguageGraphException(
-                        "No next link for subtype dependency chain"
+                        "No sub link for subtype expressions chain"
                     )
-                return {'subType': self.subtype.name,
-                    'expression': self.next_link.to_dict()
+                return {
+                    'subType': self.subtype.name,
+                    'expression': self.sub_link.to_dict(),
+                    'type': self.type
                 }
 
             case _:
@@ -369,22 +538,133 @@ class DependencyChain:
                 logger.error(msg, self.type)
                 raise LanguageGraphAssociationError(msg % self.type)
 
+    @classmethod
+    def _from_dict(cls,
+            serialized_expr_chain: dict,
+            lang_graph: LanguageGraph,
+        ) -> Optional[ExpressionsChain]:
+        """Create ExpressionsChain from dict
+        Args:
+        serialized_expr_chain   - expressions chain in dict format
+        lang_graph              - the LanguageGraph that contains the assets,
+                                  associations, and attack steps relevant for
+                                  the expressions chain
+        """
+
+        if serialized_expr_chain is None or not serialized_expr_chain:
+            return None
+
+        if 'type' not in serialized_expr_chain:
+            logger.debug(json.dumps(serialized_expr_chain, indent = 2))
+            msg = 'Missing expressions chain type!'
+            logger.error(msg)
+            raise LanguageGraphAssociationError(msg)
+            return None
+
+        expr_chain_type = serialized_expr_chain['type']
+        match (expr_chain_type):
+            case 'union' | 'intersection' | 'difference' | 'collect':
+                left_link = cls._from_dict(
+                    serialized_expr_chain[expr_chain_type]['left'],
+                    lang_graph
+                )
+                right_link = cls._from_dict(
+                    serialized_expr_chain[expr_chain_type]['right'],
+                    lang_graph
+                )
+                new_expr_chain = ExpressionsChain(
+                    type = expr_chain_type,
+                    left_link = left_link,
+                    right_link = right_link
+                )
+                return new_expr_chain
+
+            case 'field':
+                assoc_name = list(serialized_expr_chain.keys())[0]
+                target_asset = lang_graph.assets[\
+                    serialized_expr_chain[assoc_name]['asset type']]
+                fieldname = serialized_expr_chain[assoc_name]['fieldname']
+
+                association = None
+                for assoc in target_asset.associations.values():
+                    if assoc.contains_fieldname(fieldname) and \
+                            assoc.name == assoc_name:
+                        association = assoc
+                        break
+
+                if association is None:
+                    msg = 'Failed to find association "%s" with '\
+                        'fieldname "%s"'
+                    logger.error(msg % (assoc_name, fieldname))
+                    raise LanguageGraphException(msg % (assoc_name,
+                        fieldname))
+
+                new_expr_chain = ExpressionsChain(
+                    type = 'field',
+                    association = association,
+                    fieldname = fieldname
+                )
+                return new_expr_chain
+
+            case 'transitive':
+                sub_link = cls._from_dict(
+                    serialized_expr_chain['transitive'],
+                    lang_graph
+                )
+                new_expr_chain = ExpressionsChain(
+                    type = 'transitive',
+                    sub_link = sub_link
+                )
+                return new_expr_chain
+
+            case 'subType':
+                sub_link = cls._from_dict(
+                    serialized_expr_chain['expression'],
+                    lang_graph
+                )
+                subtype_name = serialized_expr_chain['subType']
+                if subtype_name in lang_graph.assets:
+                    subtype_asset = lang_graph.assets[subtype_name]
+                else:
+                    msg = 'Failed to find subtype %s'
+                    logger.error(msg % subtype_name)
+                    raise LanguageGraphException(msg % subtype_name)
+
+                new_expr_chain = ExpressionsChain(
+                    type = 'subType',
+                    sub_link = sub_link,
+                    subtype = subtype_asset
+                )
+                return new_expr_chain
+
+            case _:
+                msg = 'Unknown expressions chain type %s!'
+                logger.error(msg, serialized_expr_chain['type'])
+                raise LanguageGraphAssociationError(msg %
+                    serialized_expr_chain['type'])
+
+
     def __repr__(self) -> str:
         return str(self.to_dict())
 
 
 class LanguageGraph():
     """Graph representation of a MAL language"""
-    def __init__(self, lang: dict):
-        self.assets: list = []
-        self.associations: list = []
-        self.attack_steps: list = []
-        self._lang_spec: dict = lang
-        self.metadata = {
-            "version": lang["defines"]["version"],
-            "id": lang["defines"]["id"],
-        }
-        self._generate_graph()
+    def __init__(self, lang: Optional[dict] = None):
+        self.assets: dict = {}
+        if lang is not None:
+            self._lang_spec: dict = lang
+            self.metadata = {
+                "version": lang["defines"]["version"],
+                "id": lang["defines"]["id"],
+            }
+            self._generate_graph()
+
+
+    def __repr__(self) -> str:
+        return (f'LanguageGraph(id: "{self.metadata.get("id", "N/A")}", '
+            f'version: "{self.metadata.get("version", "N/A")}")')
+
 
     @classmethod
     def from_mal_spec(cls, mal_spec_file: str) -> LanguageGraph:
@@ -397,6 +677,7 @@ class LanguageGraph():
         logger.info("Loading mal spec %s", mal_spec_file)
         return LanguageGraph(MalCompiler().compile(mal_spec_file))
 
+
     @classmethod
     def from_mar_archive(cls, mar_archive: str) -> LanguageGraph:
         """
@@ -411,39 +692,241 @@ class LanguageGraph():
             langspec = archive.read('langspec.json')
             return LanguageGraph(json.loads(langspec))
 
+
     def _to_dict(self):
         """Converts LanguageGraph into a dict"""
-        serialized_assets = []
-        for asset in self.assets:
-            serialized_assets.append(asset.to_dict())
-        serialized_associations = []
-        for associations in self.associations:
-            serialized_associations.append(associations.to_dict())
-        serialized_attack_steps = []
-        for attack_step in self.attack_steps:
-            serialized_attack_steps.append(attack_step.to_dict())
 
         logger.debug(
-            'Serializing %s assets, %s associations, and %s attack steps',
-            len(serialized_assets), len(serialized_associations),
-            len(serialized_attack_steps)
+            'Serializing %s assets.', len(self.assets.items())
         )
 
-        serialized_graph = {
-            'Assets': serialized_assets,
-            'Associations': serialized_associations,
-            'Attack Steps': serialized_attack_steps
-        }
+        serialized_graph = {'metadata': self.metadata}
+        for asset in self.assets.values():
+            serialized_graph[asset.name] = asset.to_dict()
+
         return serialized_graph
 
+    def _link_association_to_assets(cls,
+            assoc: LanguageGraphAssociation,
+            left_asset: LanguageGraphAsset,
+            right_asset: LanguageGraphAsset):
+        left_asset.own_associations[assoc.right_field.fieldname] = assoc
+        right_asset.own_associations[assoc.left_field.fieldname] = assoc
+
     def save_to_file(self, filename: str) -> None:
         """Save to json/yml depending on extension"""
         return save_dict_to_file(filename, self._to_dict())
 
+
     @classmethod
-    def _from_dict(cls, serialized_object: dict) -> None:
-        raise NotImplementedError(
-            "Converting from dict feature is not implemented yet")
+    def _from_dict(cls, serialized_graph: dict) -> LanguageGraph:
+        """Create LanguageGraph from dict
+        Args:
+        serialized_graph   - LanguageGraph in dict format
+        """
+
+        logger.debug('Create language graph from dictionary.')
+        lang_graph = LanguageGraph()
+        lang_graph.metadata = serialized_graph.pop('metadata')
+
+        # Recreate all of the assets
+        for asset_dict in serialized_graph.values():
+            logger.debug(
+                'Create asset language graph nodes for asset %s',
+                asset_dict['name']
+            )
+            asset_node = LanguageGraphAsset(
+                name = asset_dict['name'],
+                own_associations = {},
+                attack_steps = {},
+                info = asset_dict['info'],
+                own_super_asset = None,
+                own_sub_assets = set(),
+                own_variables = {},
+                is_abstract = asset_dict['is_abstract']
+            )
+            lang_graph.assets[asset_dict['name']] = asset_node
+
+        # Relink assets based on inheritance
+        for asset_dict in serialized_graph.values():
+            asset = lang_graph.assets[asset_dict['name']]
+            super_asset_name = asset_dict['super_asset']
+            if not super_asset_name:
+                continue
+
+            super_asset = lang_graph.assets[super_asset_name]
+            if not super_asset:
+                msg = 'Failed to find super asset "%s" for asset "%s"!'
+                logger.error(
+                    msg, asset_dict["super_asset"], asset_dict["name"])
+                raise LanguageGraphSuperAssetNotFoundError(
+                    msg % (asset_dict["super_asset"], asset_dict["name"]))
+
+            super_asset.own_sub_assets.add(asset)
+            asset.own_super_asset = super_asset
+
+        # Generate all of the association nodes of the language graph.
+        for asset_dict in serialized_graph.values():
+            logger.debug(
+                'Create association language graph nodes for asset %s',
+                asset_dict['name']
+            )
+
+            asset = lang_graph.assets[asset_dict['name']]
+            for association in asset_dict['associations'].values():
+                left_asset = lang_graph.assets[association['left']['asset']]
+                if not left_asset:
+                    msg = 'Left asset "%s" for association "%s" not found!'
+                    logger.error(
+                        msg, association['left']['asset'],
+                            association['name'])
+                    raise LanguageGraphAssociationError(
+                        msg % (association['left']['asset'],
+                            association['name']))
+
+                right_asset = lang_graph.assets[association['right']['asset']]
+                if not right_asset:
+                    msg = 'Right asset "%s" for association "%s" not found!'
+                    logger.error(
+                        msg, association['right']['asset'],
+                            association['name'])
+                    raise LanguageGraphAssociationError(
+                        msg % (association['right']['asset'],
+                            association['name'])
+                    )
+
+                assoc_node = LanguageGraphAssociation(
+                    name = association['name'],
+                    left_field = LanguageGraphAssociationField(
+                        left_asset,
+                        association['left']['fieldname'],
+                        association['left']['min'],
+                        association['left']['max']),
+                    right_field = LanguageGraphAssociationField(
+                        right_asset,
+                        association['right']['fieldname'],
+                        association['right']['min'],
+                        association['right']['max']),
+                    info = association['info']
+                )
+
+                # Add the association to the left and right asset
+                lang_graph._link_association_to_assets(assoc_node,
+                    left_asset, right_asset)
+
+        # Recreate the variables
+        for asset_dict in serialized_graph.values():
+            asset = lang_graph.assets[asset_dict['name']]
+            for variable_name, var_target in asset_dict['variables'].items():
+                (target_asset_name, expr_chain_dict) = var_target
+                target_asset = lang_graph.assets[target_asset_name]
+                expr_chain = ExpressionsChain._from_dict(
+                    expr_chain_dict,
+                    lang_graph
+                )
+                asset.own_variables[variable_name] = (target_asset, expr_chain)
+
+        # Recreate the attack steps
+        for asset_dict in serialized_graph.values():
+            asset = lang_graph.assets[asset_dict['name']]
+            logger.debug(
+                'Create attack steps language graph nodes for asset %s',
+                asset_dict['name']
+            )
+            for attack_step_dict in asset_dict['attack_steps'].values():
+                attack_step_node = LanguageGraphAttackStep(
+                    name = attack_step_dict['name'],
+                    type = attack_step_dict['type'],
+                    asset = asset,
+                    ttc = attack_step_dict['ttc'],
+                    overrides = attack_step_dict['overrides'],
+                    children = {},
+                    parents = {},
+                    info = attack_step_dict['info'],
+                    tags = set(attack_step_dict['tags'])
+                )
+                asset.attack_steps[attack_step_dict['name']] = \
+                    attack_step_node
+
+        # Relink attack steps based on inheritence
+        for asset_dict in serialized_graph.values():
+            asset = lang_graph.assets[asset_dict['name']]
+            for attack_step_dict in asset_dict['attack_steps'].values():
+                if 'inherits' in attack_step_dict and \
+                        attack_step_dict['inherits'] is not None:
+                    attack_step = asset.attack_steps[
+                        attack_step_dict['name']]
+                    ancestor_asset_name, ancestor_attack_step_name = \
+                        disaggregate_attack_step_full_name(
+                            attack_step_dict['inherits'])
+                    ancestor_asset = lang_graph.assets[ancestor_asset_name]
+                    ancestor_attack_step = ancestor_asset.attack_steps[\
+                        ancestor_attack_step_name]
+                    attack_step.inherits = ancestor_attack_step
+
+
+        # Relink attack steps based on expressions chains
+        for asset_dict in serialized_graph.values():
+            asset = lang_graph.assets[asset_dict['name']]
+            for attack_step_dict in asset_dict['attack_steps'].values():
+                attack_step = asset.attack_steps[attack_step_dict['name']]
+                for child_target in attack_step_dict['children'].items():
+                    target_full_attack_step_name = child_target[0]
+                    expr_chains = child_target[1]
+                    target_asset_name, target_attack_step_name = \
+                        disaggregate_attack_step_full_name(
+                            target_full_attack_step_name)
+                    target_asset = lang_graph.assets[target_asset_name]
+                    target_attack_step = target_asset.attack_steps[
+                        target_attack_step_name]
+                    for expr_chain_dict in expr_chains:
+                        expr_chain = ExpressionsChain._from_dict(
+                            expr_chain_dict,
+                            lang_graph
+                        )
+                        if target_attack_step.full_name in attack_step.children:
+                            attack_step.children[target_attack_step.full_name].\
+                                append((target_attack_step, expr_chain))
+                        else:
+                            attack_step.children[target_attack_step.full_name] = \
+                                [(target_attack_step, expr_chain)]
+
+                for parent_target in attack_step_dict['parents'].items():
+                    target_full_attack_step_name = parent_target[0]
+                    expr_chains = parent_target[1]
+                    target_asset_name, target_attack_step_name = \
+                        disaggregate_attack_step_full_name(
+                            target_full_attack_step_name)
+                    target_asset = lang_graph.assets[target_asset_name]
+                    target_attack_step = target_asset.attack_steps[
+                        target_attack_step_name]
+                    for expr_chain_dict in expr_chains:
+                        expr_chain = ExpressionsChain._from_dict(
+                            expr_chain_dict,
+                            lang_graph
+                        )
+                        if target_attack_step.full_name in attack_step.parents:
+                            attack_step.parents[target_attack_step.full_name].\
+                                append((target_attack_step, expr_chain))
+                        else:
+                            attack_step.parents[target_attack_step.full_name] = \
+                                [(target_attack_step, expr_chain)]
+
+                # Recreate the requirements of exist and notExist attack steps
+                if attack_step.type == 'exist' or \
+                        attack_step.type == 'notExist':
+                    if 'requires' in attack_step_dict:
+                        expr_chains = attack_step_dict['requires']
+                        attack_step.own_requires = []
+                        for expr_chain_dict in expr_chains:
+                            expr_chain = ExpressionsChain._from_dict(
+                                expr_chain_dict,
+                                lang_graph
+                            )
+                            attack_step.own_requires.append(expr_chain)
+
+        return lang_graph
+
 
     @classmethod
     def load_from_file(cls, filename: str) -> LanguageGraph:
@@ -453,17 +936,23 @@ class LanguageGraph():
             lang_graph = cls.from_mal_spec(filename)
         elif filename.endswith('.mar'):
             lang_graph = cls.from_mar_archive(filename)
-        elif filename.endswith(('yaml', 'yml')):
+        elif filename.endswith(('.yaml', '.yml')):
             lang_graph = cls._from_dict(load_dict_from_yaml_file(filename))
-        elif filename.endswith(('json')):
+        elif filename.endswith(('.json')):
             lang_graph = cls._from_dict(load_dict_from_json_file(filename))
+        else:
+            raise TypeError(
+                "Unknown file extension, expected json/mal/mar/yml/yaml"
+            )
 
         if lang_graph:
             return lang_graph
+        else:
+            raise LanguageGraphException(
+                f'Failed to load language graph from file "{filename}".'
+            )
+
 
-        raise TypeError(
-            "Unknown file extension, expected json/mal/mar/yml/yaml"
-        )
 
     def save_language_specification_to_json(self, filename: str) -> None:
         """
@@ -477,23 +966,21 @@ class LanguageGraph():
         with open(filename, 'w', encoding='utf-8') as file:
             json.dump(self._lang_spec, file, indent=4)
 
+
     def process_step_expression(self,
-            lang: dict,
             target_asset,
-            dep_chain,
+            expr_chain,
             step_expression: dict
         ) -> tuple:
         """
         Recursively process an attack step expression.
 
         Arguments:
-        lang                - A dictionary representing the MAL language
-                              specification.
         target_asset        - The asset type that this step expression should
                               apply to. Initially it will contain the asset
                               type to which the attack step belongs.
-        dep_chain           - A dependency chain of linked of associations and
-                              set operations from the attack step to its
+        expr_chain          - A expressions chain of linked of associations
+                              and set operations from the attack step to its
                               parent attack step.
                               Note: This was done for the parent attack step
                               because it was easier to construct recursively
@@ -518,19 +1005,29 @@ class LanguageGraph():
                 # The attack step expression just adds the name of the attack
                 # step. All other step expressions only modify the target
                 # asset and parent associations chain.
-                return (target_asset,
-                    dep_chain,
-                    step_expression['name'])
+                return (
+                    target_asset,
+                    None,
+                    step_expression['name']
+                )
 
             case 'union' | 'intersection' | 'difference':
                 # The set operators are used to combine the left hand and right
                 # hand targets accordingly.
-                lh_target_asset, lh_dep_chain, _ = self.process_step_expression(
-                    lang, target_asset, dep_chain, step_expression['lhs'])
-                rh_target_asset, rh_dep_chain, _ = self.process_step_expression(
-                    lang, target_asset, dep_chain, step_expression['rhs'])
+                lh_target_asset, lh_expr_chain, _ = self.process_step_expression(
+                    target_asset,
+                    expr_chain,
+                    step_expression['lhs']
+                )
+                rh_target_asset, rh_expr_chain, _ = \
+                    self.process_step_expression(
+                        target_asset,
+                        expr_chain,
+                        step_expression['rhs']
+                    )
 
-                if not lh_target_asset.get_all_common_superassets(rh_target_asset):
+                if not lh_target_asset.get_all_common_superassets(
+                        rh_target_asset):
                     logger.error(
                         "Set operation attempted between targets that"
                         " do not share any common superassets: %s and %s!",
@@ -538,30 +1035,32 @@ class LanguageGraph():
                     )
                     return (None, None, None)
 
-                new_dep_chain = DependencyChain(
+                new_expr_chain = ExpressionsChain(
                     type = step_expression['type'],
-                    next_link = None)
-                new_dep_chain.left_chain = lh_dep_chain
-                new_dep_chain.right_chain = rh_dep_chain
-                return (lh_target_asset,
-                    new_dep_chain,
-                    None)
+                    left_link = lh_expr_chain,
+                    right_link = rh_expr_chain
+                )
+                return (
+                    lh_target_asset,
+                    new_expr_chain,
+                    None
+                )
 
             case 'variable':
-                # Fetch the step expression associated with the variable from
-                # the language specification and resolve that.
-                variable_step_expr = self._get_variable_for_asset_type_by_name(
-                    target_asset.name, step_expression['name'])
-                if variable_step_expr:
-                    return self.process_step_expression(
-                        lang,
-                        target_asset,
-                        dep_chain,
-                        variable_step_expr)
-
+                var_name = step_expression['name']
+                var_target_asset, var_expr_chain = self._resolve_variable(
+                    target_asset, var_name)
+                var_target_asset, var_expr_chain = \
+                    target_asset.get_variable(var_name)
+                if var_expr_chain is not None:
+                    return (
+                        var_target_asset,
+                        var_expr_chain,
+                        None
+                    )
                 else:
                     logger.error(
-                        'Failed to find variable %s for %s',
+                        'Failed to find variable \"%s\" for %s',
                         step_expression["name"], target_asset.name
                     )
                     return (None, None, None)
@@ -578,7 +1077,7 @@ class LanguageGraph():
                     return (None, None, None)
 
                 new_target_asset = None
-                for association in target_asset.associations:
+                for association in target_asset.associations.values():
                     if (association.left_field.fieldname == fieldname and \
                         target_asset.is_subasset_of(
                             association.right_field.asset)):
@@ -590,15 +1089,16 @@ class LanguageGraph():
                         new_target_asset = association.right_field.asset
 
                     if new_target_asset:
-                        new_dep_chain = DependencyChain(
+                        new_expr_chain = ExpressionsChain(
                             type = 'field',
-                            next_link = dep_chain)
-                        new_dep_chain.fieldname = \
-                            association.get_opposite_fieldname(fieldname)
-                        new_dep_chain.association = association
-                        return (new_target_asset,
-                            new_dep_chain,
-                            None)
+                            fieldname = fieldname,
+                            association = association
+                        )
+                        return (
+                            new_target_asset,
+                            new_expr_chain,
+                            None
+                        )
                 logger.error(
                     'Failed to find field "%s" on asset "%s"!',
                     fieldname, target_asset.name
@@ -609,18 +1109,22 @@ class LanguageGraph():
                 # Create a transitive tuple entry that applies to the next
                 # component of the step expression.
                 result_target_asset, \
-                result_dep_chain, \
+                result_expr_chain, \
                 attack_step = \
-                    self.process_step_expression(lang,
+                    self.process_step_expression(
                         target_asset,
-                        dep_chain,
-                        step_expression['stepExpression'])
-                new_dep_chain = DependencyChain(
+                        expr_chain,
+                        step_expression['stepExpression']
+                    )
+                new_expr_chain = ExpressionsChain(
                     type = 'transitive',
-                    next_link = result_dep_chain)
-                return (result_target_asset,
-                    new_dep_chain,
-                    attack_step)
+                    sub_link = result_expr_chain
+                )
+                return (
+                    result_target_asset,
+                    new_expr_chain,
+                    attack_step
+                )
 
             case 'subType':
                 # Create a subType tuple entry that applies to the next
@@ -628,19 +1132,20 @@ class LanguageGraph():
                 # asset to the subasset.
                 subtype_name = step_expression['subType']
                 result_target_asset, \
-                result_dep_chain, \
+                result_expr_chain, \
                 attack_step = \
-                    self.process_step_expression(lang,
+                    self.process_step_expression(
                         target_asset,
-                        dep_chain,
-                        step_expression['stepExpression'])
-
-                subtype_asset = next((asset for asset in self.assets if asset.name == subtype_name), None)
+                        expr_chain,
+                        step_expression['stepExpression']
+                    )
 
-                if not subtype_asset:
-                    msg = 'Failed to find subtype attackstep "{subtype_name}"'
-                    logger.error(msg)
-                    raise LanguageGraphException(msg)
+                if subtype_name in self.assets:
+                    subtype_asset = self.assets[subtype_name]
+                else:
+                    msg = 'Failed to find subtype %s'
+                    logger.error(msg % subtype_name)
+                    raise LanguageGraphException(msg % subtype_name)
 
                 if not subtype_asset.is_subasset_of(result_target_asset):
                     logger.error(
@@ -650,31 +1155,48 @@ class LanguageGraph():
                     )
                     return (None, None, None)
 
-                new_dep_chain = DependencyChain(
+                new_expr_chain = ExpressionsChain(
                     type = 'subType',
-                    next_link = result_dep_chain)
-                new_dep_chain.subtype = subtype_asset
-                return (subtype_asset,
-                    new_dep_chain,
-                    attack_step)
+                    sub_link = result_expr_chain,
+                    subtype = subtype_asset
+                )
+                return (
+                    subtype_asset,
+                    new_expr_chain,
+                    attack_step
+                )
 
             case 'collect':
                 # Apply the right hand step expression to left hand step
                 # expression target asset and parent associations chain.
-                (lh_target_asset, lh_dep_chain, _) = \
-                    self.process_step_expression(lang,
+                (lh_target_asset, lh_expr_chain, _) = \
+                    self.process_step_expression(
                         target_asset,
-                        dep_chain,
-                        step_expression['lhs'])
+                        expr_chain,
+                        step_expression['lhs']
+                    )
                 (rh_target_asset,
-                    rh_dep_chain,
+                    rh_expr_chain,
                     rh_attack_step_name) = \
-                    self.process_step_expression(lang,
+                    self.process_step_expression(
                         lh_target_asset,
-                        lh_dep_chain,
-                        step_expression['rhs'])
-                return (rh_target_asset, rh_dep_chain,
-                    rh_attack_step_name)
+                        None,
+                        step_expression['rhs']
+                    )
+                if rh_expr_chain:
+                    new_expr_chain = ExpressionsChain(
+                        type = 'collect',
+                        left_link = lh_expr_chain,
+                        right_link = rh_expr_chain
+                    )
+                else:
+                    new_expr_chain = lh_expr_chain
+
+                return (
+                    rh_target_asset,
+                    new_expr_chain,
+                    rh_attack_step_name
+                )
 
             case _:
                 logger.error(
@@ -682,17 +1204,18 @@ class LanguageGraph():
                 )
                 return (None, None, None)
 
-    def reverse_dep_chain(
+
+    def reverse_expr_chain(
             self,
-            dep_chain: Optional[DependencyChain],
-            reverse_chain: Optional[DependencyChain]
-        ) -> Optional[DependencyChain]:
+            expr_chain: Optional[ExpressionsChain],
+            reverse_chain: Optional[ExpressionsChain]
+        ) -> Optional[ExpressionsChain]:
         """
         Recursively reverse the associations chain. From parent to child or
         vice versa.
 
         Arguments:
-        dep_chain  - A chain of nested tuples that specify the
+        expr_chain          - A chain of nested tuples that specify the
                               associations and set operations chain from an
                               attack step to its connected attack step.
         reverse_chain       - A chain of nested tuples that represents the
@@ -701,70 +1224,103 @@ class LanguageGraph():
         Return:
         The resulting reversed associations chain.
         """
-        if not dep_chain:
+        if not expr_chain:
             return reverse_chain
         else:
-            match (dep_chain.type):
-                case 'union' | 'intersection' | 'difference':
+            match (expr_chain.type):
+                case 'union' | 'intersection' | 'difference' | 'collect':
                     left_reverse_chain = \
-                        self.reverse_dep_chain(dep_chain.left_chain,
+                        self.reverse_expr_chain(expr_chain.left_link,
                         reverse_chain)
                     right_reverse_chain = \
-                        self.reverse_dep_chain(dep_chain.right_chain,
+                        self.reverse_expr_chain(expr_chain.right_link,
                         reverse_chain)
-                    new_dep_chain = DependencyChain(
-                        type = dep_chain.type,
-                        next_link = None)
-                    new_dep_chain.left_chain = left_reverse_chain
-                    new_dep_chain.right_chain = right_reverse_chain
-                    return new_dep_chain
+                    if expr_chain.type == 'collect':
+                        new_expr_chain = ExpressionsChain(
+                            type = expr_chain.type,
+                            left_link = right_reverse_chain,
+                            right_link = left_reverse_chain
+                        )
+                    else:
+                        new_expr_chain = ExpressionsChain(
+                            type = expr_chain.type,
+                            left_link = left_reverse_chain,
+                            right_link = right_reverse_chain
+                        )
+
+                    return new_expr_chain
 
                 case 'transitive':
-                    result_reverse_chain = self.reverse_dep_chain(
-                        dep_chain.next_link, reverse_chain)
-                    new_dep_chain = DependencyChain(
+                    result_reverse_chain = self.reverse_expr_chain(
+                        expr_chain.sub_link, reverse_chain)
+                    new_expr_chain = ExpressionsChain(
                         type = 'transitive',
-                        next_link = result_reverse_chain)
-                    return new_dep_chain
+                        sub_link = result_reverse_chain
+                    )
+                    return new_expr_chain
 
                 case 'field':
-                    association = dep_chain.association
+                    association = expr_chain.association
 
                     if not association:
                         raise LanguageGraphException(
-                            "Missing association for dep chain"
+                            "Missing association for expressions chain"
+                        )
+
+                    if not expr_chain.fieldname:
+                        raise LanguageGraphException(
+                            "Missing field name for expressions chain"
                         )
 
                     opposite_fieldname = association.get_opposite_fieldname(
-                        dep_chain.fieldname)
-                    new_dep_chain = DependencyChain(
+                        expr_chain.fieldname)
+                    new_expr_chain = ExpressionsChain(
                         type = 'field',
-                        next_link = reverse_chain
+                        association = association,
+                        fieldname = opposite_fieldname
                     )
-                    new_dep_chain.fieldname = opposite_fieldname
-                    new_dep_chain.association = association
-                    return self.reverse_dep_chain(
-                                dep_chain.next_link,
-                                new_dep_chain
-                            )
+                    return new_expr_chain
 
                 case 'subType':
-                    result_reverse_chain = self.reverse_dep_chain(
-                        dep_chain.next_link,
+                    result_reverse_chain = self.reverse_expr_chain(
+                        expr_chain.sub_link,
                         reverse_chain
                     )
-                    new_dep_chain = DependencyChain(
+                    new_expr_chain = ExpressionsChain(
                         type = 'subType',
-                        next_link = result_reverse_chain
+                        sub_link = result_reverse_chain,
+                        subtype = expr_chain.subtype
                     )
-                    new_dep_chain.subtype = dep_chain.subtype
-                    return new_dep_chain
-                    # return reverse_chain
+                    return new_expr_chain
 
                 case _:
                     msg = 'Unknown assoc chain element "%s"'
-                    logger.error(msg, dep_chain.type)
-                    raise LanguageGraphAssociationError(msg % dep_chain.type)
+                    logger.error(msg, expr_chain.type)
+                    raise LanguageGraphAssociationError(msg % expr_chain.type)
+
+    def _resolve_variable(self, asset, var_name) -> tuple:
+        """
+        Resolve a variable for a specific asset by variable name.
+
+        Arguments:
+        asset       - a language graph asset to which the variable belongs
+        var_name    - a string representing the variable name
+
+        Return:
+        A tuple containing the target asset and expressions chain required to
+        reach it.
+        """
+        if var_name not in asset.variables:
+            var_expr = self._get_var_expr_for_asset(asset.name, var_name)
+            target_asset, expr_chain, _ = self.process_step_expression(
+                asset,
+                None,
+                var_expr
+            )
+            asset.own_variables[var_name] = (target_asset, expr_chain)
+            return (target_asset, expr_chain)
+        return asset.variables[var_name]
+
 
     def _generate_graph(self) -> None:
         """
@@ -772,41 +1328,40 @@ class LanguageGraph():
         given in the constructor.
         """
         # Generate all of the asset nodes of the language graph.
-        for asset in self._lang_spec['assets']:
+        for asset_dict in self._lang_spec['assets']:
             logger.debug(
                 'Create asset language graph nodes for asset %s',
-                asset["name"]
+                asset_dict['name']
             )
             asset_node = LanguageGraphAsset(
-                name = asset['name'],
-                associations = [],
-                attack_steps = [],
-                description = asset['meta'],
-                super_assets = [],
-                sub_assets = [],
-                is_abstract = asset['isAbstract']
+                name = asset_dict['name'],
+                own_associations = {},
+                attack_steps = {},
+                info = asset_dict['meta'],
+                own_super_asset = None,
+                own_sub_assets = set(),
+                own_variables = {},
+                is_abstract = asset_dict['isAbstract']
             )
-            self.assets.append(asset_node)
+            self.assets[asset_dict['name']] = asset_node
 
         # Link assets based on inheritance
-        for asset_info in self._lang_spec['assets']:
-            asset = next((asset for asset in self.assets \
-                if asset.name == asset_info['name']), None)
-            if asset_info['superAsset']:
-                super_asset = next((asset for asset in self.assets \
-                    if asset.name == asset_info['superAsset']), None)
+        for asset_dict in self._lang_spec['assets']:
+            asset = self.assets[asset_dict['name']]
+            if asset_dict['superAsset']:
+                super_asset = self.assets[asset_dict['superAsset']]
                 if not super_asset:
                     msg = 'Failed to find super asset "%s" for asset "%s"!'
                     logger.error(
-                        msg, asset_info["superAsset"], asset_info["name"])
+                        msg, asset_dict["superAsset"], asset_dict["name"])
                     raise LanguageGraphSuperAssetNotFoundError(
-                        msg % (asset_info["superAsset"], asset_info["name"]))
+                        msg % (asset_dict["superAsset"], asset_dict["name"]))
 
-                super_asset.sub_assets.append(asset)
-                asset.super_assets.append(super_asset)
+                super_asset.own_sub_assets.add(asset)
+                asset.own_super_asset = super_asset
 
         # Generate all of the association nodes of the language graph.
-        for asset in self.assets:
+        for asset in self.assets.values():
             logger.debug(
                 'Create association language graph nodes for asset %s',
                 asset.name
@@ -814,8 +1369,7 @@ class LanguageGraph():
 
             associations = self._get_associations_for_asset_type(asset.name)
             for association in associations:
-                left_asset = next((asset for asset in self.assets \
-                    if asset.name == association['leftAsset']), None)
+                left_asset = self.assets[association['leftAsset']]
                 if not left_asset:
                     msg = 'Left asset "%s" for association "%s" not found!'
                     logger.error(
@@ -823,8 +1377,7 @@ class LanguageGraph():
                     raise LanguageGraphAssociationError(
                         msg % (association["leftAsset"], association["name"]))
 
-                right_asset = next((asset for asset in self.assets \
-                    if asset.name == association['rightAsset']), None)
+                right_asset = self.assets[association['rightAsset']]
                 if not right_asset:
                     msg = 'Right asset "%s" for association "%s" not found!'
                     logger.error(
@@ -833,17 +1386,6 @@ class LanguageGraph():
                         msg % (association["rightAsset"], association["name"])
                     )
 
-                # Technically we should be more exhaustive and check the
-                # flipped version too and all of the fieldnames as well.
-                assoc_node = next((assoc for assoc in self.associations \
-                    if assoc.name == association['name'] and
-                        assoc.left_field.asset == left_asset and
-                        assoc.right_field.asset == right_asset),
-                        None)
-                if assoc_node:
-                    # The association was already created, skip it
-                    continue
-
                 assoc_node = LanguageGraphAssociation(
                     name = association['name'],
                     left_field = LanguageGraphAssociationField(
@@ -856,124 +1398,224 @@ class LanguageGraph():
                         association['rightField'],
                         association['rightMultiplicity']['min'],
                         association['rightMultiplicity']['max']),
-                    description = association['meta']
+                    info = association['meta']
                 )
 
-                # Add the association to the left and right asset and all of
-                # the assets that inherit them
-                associated_assets = [left_asset, right_asset]
-                while associated_assets != []:
-                    asset = associated_assets.pop()
-                    associated_assets.extend(asset.sub_assets)
-                    if assoc_node not in asset.associations:
-                        asset.associations.append(assoc_node)
+                # Add the association to the left and right asset
+                self._link_association_to_assets(assoc_node,
+                    left_asset, right_asset)
+
+        # Set the variables
+        for asset in self.assets.values():
+            for variable in self._get_variables_for_asset_type(asset.name):
+                if logger.isEnabledFor(logging.DEBUG):
+                    # Avoid running json.dumps when not in debug
+                    logger.debug(
+                        'Processing Variable Expression:\n%s',
+                        json.dumps(variable, indent = 2)
+                    )
+                self._resolve_variable(asset, variable['name'])
 
-                self.associations.append(assoc_node)
 
         # Generate all of the attack step nodes of the language graph.
-        for asset in self.assets:
+        for asset in self.assets.values():
             logger.debug(
                 'Create attack steps language graph nodes for asset %s',
                 asset.name
             )
             attack_steps = self._get_attacks_for_asset_type(asset.name)
-            for attack_step_name, attack_step_attribs in attack_steps.items():
+            for attack_step_attribs in attack_steps.values():
                 logger.debug(
                     'Create attack step language graph nodes for %s',
-                    attack_step_name
+                    attack_step_attribs['name']
                 )
 
                 attack_step_node = LanguageGraphAttackStep(
-                    name = attack_step_name,
+                    name = attack_step_attribs['name'],
                     type = attack_step_attribs['type'],
                     asset = asset,
                     ttc = attack_step_attribs['ttc'],
+                    overrides = attack_step_attribs['reaches']['overrides'] \
+                        if attack_step_attribs['reaches'] else False,
                     children = {},
                     parents = {},
-                    description = attack_step_attribs['meta']
+                    info = attack_step_attribs['meta'],
+                    tags = set(attack_step_attribs['tags'])
                 )
-                attack_step_node.attributes = attack_step_attribs
-                asset.attack_steps.append(attack_step_node)
-                self.attack_steps.append(attack_step_node)
-
-        # Then, link all of the attack step nodes according to their associations.
-        for attack_step in self.attack_steps:
-            logger.debug(
-                'Determining children for attack step %s',
-                attack_step.name
-            )
-            step_expressions = \
-                attack_step.attributes['reaches']['stepExpressions'] if \
-                    attack_step.attributes['reaches'] else []
-
-            for step_expression in step_expressions:
-                # Resolve each of the attack step expressions listed for this
-                # attack step to determine children.
-                (target_asset, dep_chain, attack_step_name) = \
-                    self.process_step_expression(self._lang_spec,
-                        attack_step.asset,
-                        None,
-                        step_expression)
-                if not target_asset:
-                    msg = 'Failed to find target asset to link with for ' \
-                        'step expression:\n%s'
-                    raise LanguageGraphStepExpressionError(
-                        msg % json.dumps(step_expression, indent = 2)
+                attack_step_node._attributes = attack_step_attribs
+                asset.attack_steps[attack_step_attribs['name']] = \
+                    attack_step_node
+
+                for detector in attack_step_attribs.get("detectors",
+                                                        {}).values():
+                    attack_step_node.detectors[detector["name"]] = Detector(
+                        context=Context(
+                            {
+                                label: self.assets[asset]
+                                for label, asset in detector["context"].items()
+                            }
+                        ),
+                        name=detector.get("name"),
+                        type=detector.get("type"),
+                        tprate=detector.get("tprate"),
                     )
 
-                target_attack_step = next((attack_step \
-                    for attack_step in target_asset.attack_steps \
-                        if attack_step.name == attack_step_name), None)
-
-                if not target_attack_step:
-                    msg = 'Failed to find target attack step %s on %s to ' \
-                          'link with for step expression:\n%s'
-                    raise LanguageGraphStepExpressionError(
-                        msg % (
-                            attack_step_name,
-                            target_asset.name,
-                            json.dumps(step_expression, indent = 2)
+        # Create the inherited attack steps
+        assets = list(self.assets.values())
+        while len(assets) > 0:
+            asset = assets.pop(0)
+            if asset.own_super_asset in assets:
+                # The asset still has super assets that should be resolved
+                # first, moved it to the back.
+                assets.append(asset)
+            else:
+                if asset.own_super_asset:
+                    for attack_step in \
+                            asset.own_super_asset.attack_steps.values():
+                        if attack_step.name not in asset.attack_steps:
+                            attack_step_node = LanguageGraphAttackStep(
+                                name = attack_step.name,
+                                type = attack_step.type,
+                                asset = asset,
+                                ttc = attack_step.ttc,
+                                overrides = False,
+                                children = {},
+                                parents = {},
+                                info = attack_step.info,
+                                tags = set(attack_step.tags)
+                            )
+                            attack_step_node.inherits = attack_step
+                            asset.attack_steps[attack_step.name] = attack_step_node
+                        elif asset.attack_steps[attack_step.name].overrides:
+                            # The inherited attack step was already overridden.
+                            continue
+                        else:
+                            asset.attack_steps[attack_step.name].inherits = \
+                                attack_step
+                            asset.attack_steps[attack_step.name].tags |= \
+                                attack_step.tags
+                            asset.attack_steps[attack_step.name].info |= \
+                                attack_step.info
+
+        # Then, link all of the attack step nodes according to their
+        # associations.
+        for asset in self.assets.values():
+            for attack_step in asset.attack_steps.values():
+                logger.debug(
+                    'Determining children for attack step %s',
+                    attack_step.name
+                )
+
+                if attack_step._attributes is None:
+                    # This is simply an empty inherited attack step
+                    continue
+
+                step_expressions = \
+                    attack_step._attributes['reaches']['stepExpressions'] if \
+                        attack_step._attributes['reaches'] else []
+
+                for step_expression in step_expressions:
+                    # Resolve each of the attack step expressions listed for
+                    # this attack step to determine children.
+                    (target_asset, expr_chain, target_attack_step_name) = \
+                        self.process_step_expression(
+                            attack_step.asset,
+                            None,
+                            step_expression
+                        )
+                    if not target_asset:
+                        msg = 'Failed to find target asset to link with for ' \
+                            'step expression:\n%s'
+                        raise LanguageGraphStepExpressionError(
+                            msg % json.dumps(step_expression, indent = 2)
                         )
-                    )
 
-                # It is easier to create the parent associations chain due to
-                # the left-hand first progression.
-                if attack_step.name in target_attack_step.parents:
-                    target_attack_step.parents[attack_step.name].append(
-                        (attack_step, dep_chain))
-                else:
-                    target_attack_step.parents[attack_step.name] = \
-                        [(attack_step, dep_chain)]
-                # Reverse the parent associations chain to get the child
-                # associations chain.
-                if target_attack_step.name in attack_step.children:
-                    attack_step.children[target_attack_step.name].append(
-                        (target_attack_step,
-                        self.reverse_dep_chain(dep_chain,
-                            None)))
-                else:
-                    attack_step.children[target_attack_step.name] = \
-                        [(target_attack_step,
-                        self.reverse_dep_chain(dep_chain,
-                            None))]
+                    target_asset_attack_steps = target_asset.attack_steps
+                    if target_attack_step_name not in \
+                            target_asset_attack_steps:
+                        msg = 'Failed to find target attack step %s on %s to ' \
+                              'link with for step expression:\n%s'
+                        raise LanguageGraphStepExpressionError(
+                            msg % (
+                                target_attack_step_name,
+                                target_asset.name,
+                                json.dumps(step_expression, indent = 2)
+                            )
+                        )
+
+                    target_attack_step = target_asset_attack_steps[
+                        target_attack_step_name]
+
+                    # Link to the children target attack steps
+                    if target_attack_step.full_name in attack_step.children:
+                        attack_step.children[target_attack_step.full_name].\
+                            append((target_attack_step, expr_chain))
+                    else:
+                        attack_step.children[target_attack_step.full_name] = \
+                            [(target_attack_step, expr_chain)]
+                    # Reverse the children associations chains to get the
+                    # parents associations chain.
+                    if attack_step.full_name in target_attack_step.parents:
+                        target_attack_step.parents[attack_step.full_name].\
+                            append((attack_step,
+                            self.reverse_expr_chain(expr_chain,
+                                None)))
+                    else:
+                        target_attack_step.parents[attack_step.full_name] = \
+                            [(attack_step,
+                            self.reverse_expr_chain(expr_chain,
+                                None))]
+
+                # Evaluate the requirements of exist and notExist attack steps
+                if attack_step.type == 'exist' or \
+                        attack_step.type == 'notExist':
+                    step_expressions = \
+                        attack_step._attributes['requires']['stepExpressions'] \
+                            if attack_step._attributes['requires'] else []
+                    if not step_expressions:
+                        msg = 'Failed to find requirements for attack step' \
+                        ' "%s" of type "%s":\n%s'
+                        raise LanguageGraphStepExpressionError(
+                            msg % (
+                                attack_step.name,
+                                attack_step.type,
+                                json.dumps(attack_step._attributes, indent = 2)
+                            )
+                        )
+
+                    attack_step.own_requires = []
+                    for step_expression in step_expressions:
+                        _, \
+                        result_expr_chain, \
+                        _ = \
+                            self.process_step_expression(
+                                attack_step.asset,
+                                None,
+                                step_expression
+                            )
+                        attack_step.own_requires.append(result_expr_chain)
 
     def _get_attacks_for_asset_type(self, asset_type: str) -> dict:
         """
         Get all Attack Steps for a specific Class
 
         Arguments:
-        asset_type      - a string representing the class for which we want to list
-                          the possible attack steps
+        asset_type      - a string representing the class for which we want to
+                          list the possible attack steps
 
         Return:
-        A dictionary representing the set of possible attacks for the specified
-        class. Each key in the dictionary is an attack name and is associated
-        with a dictionary containing other characteristics of the attack such as
-        type of attack, TTC distribution, child attack steps and other information
+        A dictionary representing the set of possible attacks for the
+        specified class. Each key in the dictionary is an attack name and is
+        associated with a dictionary containing other characteristics of the
+        attack such as type of attack, TTC distribution, child attack steps
+        and other information
         """
         attack_steps: dict = {}
         try:
-            asset = next((asset for asset in self._lang_spec['assets'] if asset['name'] == asset_type))
+            asset = next(
+                asset for asset in self._lang_spec['assets'] \
+                    if asset['name'] == asset_type
+            )
         except StopIteration:
             logger.error(
                 'Failed to find asset type %s when looking'
@@ -983,33 +1625,10 @@ class LanguageGraph():
 
         logger.debug(
             'Get attack steps for %s asset from '
-            'language specification.', asset["name"]
+            'language specification.', asset['name']
         )
-        if asset['superAsset']:
-            logger.debug('Asset extends another one, fetch the superclass '\
-                'attack steps for it.')
-            attack_steps = self._get_attacks_for_asset_type(asset['superAsset'])
-
-        for step in asset['attackSteps']:
-            if step['name'] not in attack_steps:
-                attack_steps[step['name']] = copy.deepcopy(step)
-            elif not step['reaches']:
-                # This attack step does not lead to any attack steps
-                continue
-            elif step['reaches']['overrides'] == True:
-                attack_steps[step['name']] = copy.deepcopy(step)
-            else:
-                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']
-                    }
 
+        attack_steps = {step['name']: step for step in asset['attackSteps']}
 
         return attack_steps
 
@@ -1018,14 +1637,15 @@ class LanguageGraph():
         Get all Associations for a specific Class
 
         Arguments:
-        asset_type      - a string representing the class for which we want to list
-                          the associations
+        asset_type      - a string representing the class for which we want to
+                          list the associations
 
         Return:
         A dictionary representing the set of associations for the specified
         class. Each key in the dictionary is an attack name and is associated
-        with a dictionary containing other characteristics of the attack such as
-        type of attack, TTC distribution, child attack steps and other information
+        with a dictionary containing other characteristics of the attack such
+        as type of attack, TTC distribution, child attack steps and other
+        information
         """
         logger.debug(
             'Get associations for %s asset from '
@@ -1033,8 +1653,8 @@ class LanguageGraph():
         )
         associations: list = []
 
-        asset = next((asset for asset in self._lang_spec['assets'] if asset['name'] == \
-            asset_type), None)
+        asset = next((asset for asset in self._lang_spec['assets'] \
+            if asset['name'] == asset_type), None)
         if not asset:
             logger.error(
                 'Failed to find asset type %s when '
@@ -1042,10 +1662,6 @@ class LanguageGraph():
             )
             return associations
 
-        if asset['superAsset']:
-            logger.debug('Asset extends another one, fetch the superclass '\
-                'associations for it.')
-            associations.extend(self._get_associations_for_asset_type(asset['superAsset']))
         assoc_iter = (assoc for assoc in self._lang_spec['associations'] \
             if assoc['leftAsset'] == asset_type or \
                 assoc['rightAsset'] == asset_type)
@@ -1056,129 +1672,64 @@ class LanguageGraph():
 
         return associations
 
-    def _get_variable_for_asset_type_by_name(
-            self, asset_type: str, variable_name: str) -> dict:
+    def _get_variables_for_asset_type(
+            self, asset_type: str) -> dict:
         """
         Get a variables for a specific asset type by name.
-        NOTE: Variables are the ones specified in MAL through `let` statements
+        Note: Variables are the ones specified in MAL through `let` statements
 
         Arguments:
         asset_type      - a string representing the type of asset which
-                          contains the variable
-        variable_name   - the name of the variable to search for
+                          contains the variables
 
         Return:
-        A dictionary representing the step expressions for the specified variable.
+        A dictionary representing the step expressions for the variables
+            belonging to the asset.
         """
 
-        asset = next((asset for asset in self._lang_spec['assets'] if asset['name'] == \
-            asset_type), None)
-        if not asset:
-            msg = 'Failed to find asset type %s when looking for variable.'
+        asset_dict = next((asset for asset in self._lang_spec['assets'] \
+            if asset['name'] == asset_type), None)
+        if not asset_dict:
+            msg = 'Failed to find asset type %s in language specification '\
+                'when looking for variables.'
             logger.error(msg, asset_type)
             raise LanguageGraphException(msg % asset_type)
 
-        variable_dict = next((variable for variable in \
-            asset['variables'] if variable['name'] == variable_name), None)
-        if not variable_dict:
-            if asset['superAsset']:
-                variable_dict = self._get_variable_for_asset_type_by_name(asset['superAsset'],
-                                                       variable_name)
-            if variable_dict:
-                return variable_dict
-            else:
-                msg = 'Failed to find variable %s in %s lang specification.'
-                logger.error(msg, variable_name, asset_type)
-                raise LanguageGraphException(
-                    msg % (variable_name, asset_type))
-
-        return variable_dict['stepExpression']
+        return asset_dict['variables']
 
-    def regenerate_graph(self) -> None:
-        """
-        Regenerate language graph starting from the MAL language specification
-        given in the constructor.
-        """
-
-        self.assets = []
-        self.associations = []
-        self.attack_steps = []
-        self._generate_graph()
-
-    def get_asset_by_name(
-            self,
-            asset_name
-    ) -> Optional[LanguageGraphAsset]:
+    def _get_var_expr_for_asset(
+            self, asset_type: str, var_name) -> dict:
         """
-        Get an asset based on its name
+        Get a variable for a specific asset type by variable name.
 
         Arguments:
-        asset_name  - a string containing the asset name
+        asset_type      - a string representing the type of asset which
+                          contains the variable
+        var_name        - a string representing the variable name
 
         Return:
-        The asset matching the name.
-        None if there is no match.
+        A dictionary representing the step expression for the variable.
         """
-        for asset in self.assets:
-            if asset.name == asset_name:
-                return asset
 
-        return None
+        vars_dict = self._get_variables_for_asset_type(asset_type)
 
-    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
+        var_expr = next((var_entry['stepExpression'] for var_entry \
+            in vars_dict if var_entry['name'] == var_name), None)
 
-        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
+        if not var_expr:
+            msg = 'Failed to find variable name "%s" in language '\
+                'specification when looking for variables for "%s" asset.'
+            logger.error(msg, var_name, asset_type)
+            raise LanguageGraphException(msg % (var_name, asset_type))
+        return var_expr
 
-        Return:
-        The association matching the fieldnames and asset types.
-        None if there is no match.
+    def regenerate_graph(self) -> None:
+        """
+        Regenerate language graph starting from the MAL language specification
+        given in the constructor.
         """
-        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
+        self.assets = {}
+        self._generate_graph()
 
-            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