s1-shift-left-cli 0.4.0__py3-none-any.whl

s1_cns_cli/s1graph/terraform/checks/utils/iam_terraform_document_to_policy_converter.py

@@ -0,0 +1,25 @@
+import copy
+from typing import Dict, List, Any
+
+
+def convert_terraform_conf_to_iam_policy(conf: Dict[str, List[Dict[str, Any]]]) -> Dict[str, List[Dict[str, Any]]]:
+    """
+        converts terraform parsed configuration to iam policy document
+    """
+    result = copy.deepcopy(conf)
+    if "statement" in result.keys():
+        result["Statement"] = result.pop("statement")
+        for statement in result["Statement"]:
+            if "actions" in statement:
+                statement["Action"] = statement.pop("actions")[0]
+            if "resources" in statement:
+                statement["Resource"] = statement.pop("resources")[0]
+            if "not_actions" in statement:
+                statement["NotAction"] = statement.pop("not_actions")[0]
+            if "not_resources" in statement:
+                statement["NotResource"] = statement.pop("not_resources")[0]
+            if "effect" in statement:
+                statement["Effect"] = statement.pop("effect")[0]
+            if "effect" not in statement and "Effect" not in statement:
+                statement["Effect"] = "Allow"
+    return result

s1_cns_cli/s1graph/terraform/context_parsers/__init__.py

@@ -0,0 +1 @@
+from s1_cns_cli.s1graph.terraform.context_parsers.parsers import *  # noqa

s1_cns_cli/s1graph/terraform/context_parsers/base_parser.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import logging
+import re
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from itertools import islice
+from pathlib import Path
+from typing import List, Dict, Any, Tuple
+
+import dpath
+
+from s1_cns_cli.s1graph.common.s1cns.integration_features.features.policy_metadata_integration import integration as metadata_integration
+from s1_cns_cli.s1graph.common.comment.enum import COMMENT_REGEX
+from s1_cns_cli.s1graph.common.models.enums import ContextCategories
+from s1_cns_cli.s1graph.common.util.parser_utils import get_abs_path
+from s1_cns_cli.s1graph.terraform.context_parsers.registry import parser_registry
+
+OPEN_CURLY = "{"
+CLOSE_CURLY = "}"
+
+
+class BaseContextParser(ABC):
+    def __init__(self, definition_type: str) -> None:
+        # bc_integration.setup_http_manager()
+        self.logger = logging.getLogger("{}".format(self.__module__))
+        if definition_type.upper() not in ContextCategories.__members__:
+            self.logger.error("Terraform context parser type not supported yet")
+            raise Exception()
+        self.definition_type = definition_type
+        self.tf_file = ""
+        self.tf_file_path: Path | None = None
+        self.file_lines: list[tuple[int, str]] = []
+        self.filtered_lines: list[tuple[int, str]] = []
+        self.filtered_line_numbers: list[int] = []
+        self.context: dict[str, Any] = defaultdict(dict)
+
+        parser_registry.register(self)
+
+    @abstractmethod
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        """
+        returns the entity's path in the context parser
+        :param entity_block: entity definition block
+        :return: list of nested entity's keys in the context parser
+        """
+        raise NotImplementedError
+
+    def get_entity_definition_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        """
+        returns the entity's path in the entity definition block
+        :param entity_block: entity definition block
+        :return: list of nested entity's keys in the entity definition block
+        """
+        return self.get_entity_context_path(entity_block)
+
+    def _is_block_signature(self, line_num: int, line_tokens: List[str], entity_context_path: List[str]) -> bool:
+        """
+        Determine if the given tokenized line token is the entity signature line
+        :param line_num: The line number in the file
+        :param line_tokens: list of line tokens
+        :param entity_context_path: the entity's path in the context parser
+        :return: True/False
+        """
+        block_type = self.get_block_type()
+        return all(x in line_tokens for x in [block_type] + entity_context_path)
+
+    @staticmethod
+    def _trim_whitespaces_linebreaks(text: str) -> str:
+        return text.strip()
+
+    def _filter_file_lines(self) -> List[Tuple[int, str]]:
+        parsed_file_lines = [(ind, self._trim_whitespaces_linebreaks(line)) for (ind, line) in self.file_lines]
+        self.filtered_lines = [(ind, line) for (ind, line) in parsed_file_lines if line]
+        self.filtered_line_numbers = [ind for ind, _ in self.filtered_lines]
+        return self.filtered_lines
+
+    def _read_file_lines(self) -> List[Tuple[int, str]]:
+        with open(self.tf_file, "r") as file:
+            file.seek(0)
+            file_lines = [(ind + 1, line) for ind, line in enumerate(file.readlines())]
+            return file_lines
+
+    @staticmethod
+    def is_optional_comment_line(line: str) -> bool:
+        line_without_whitespace = line.replace(" ", "")
+        return "s1cns:skip=" in line_without_whitespace
+
+    def _collect_skip_comments(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Collects s1cns skip comments to all definition blocks
+        :param definition_blocks: parsed definition blocks
+        :return: context enriched with with skipped checks per skipped entity
+        """
+        bc_id_mapping = metadata_integration.bc_to_ckv_id_mapping
+        comments = [
+            (
+                line_num,
+                {
+                    "id": match.group(2),
+                    "suppress_comment": match.group(3)[1:] if match.group(3) else "No comment provided",
+                },
+            )
+            for (line_num, x) in self.file_lines
+            if self.is_optional_comment_line(x)
+            for match in [re.search(COMMENT_REGEX, x)]
+            if match
+        ]
+        for entity_block in definition_blocks:
+            skipped_checks = []
+            entity_context_path = self.get_entity_context_path(entity_block)
+            entity_context = self.context
+            found = True
+            for k in entity_context_path:
+                if k in entity_context:
+                    entity_context = entity_context[k]
+                else:
+                    logging.warning(f'Failed to find context for {".".join(entity_context_path)}')
+                    found = False
+                    break
+            if not found:
+                continue
+            for (skip_check_line_num, skip_check) in comments:
+                if "start_line" in entity_context and "end_line" in entity_context \
+                        and entity_context["start_line"] < skip_check_line_num < entity_context["end_line"]:
+                    # No matter which ID was used to skip, save the pair of IDs in the appropriate fields
+                    if bc_id_mapping and skip_check["id"] in bc_id_mapping:
+                        skip_check["bc_id"] = skip_check["id"]
+                        skip_check["id"] = bc_id_mapping[skip_check["id"]]
+                    elif metadata_integration.check_metadata:
+                        skip_check["bc_id"] = metadata_integration.get_bc_id(skip_check["id"])
+                    skipped_checks.append(skip_check)
+            dpath.new(self.context, entity_context_path + ["skipped_checks"], skipped_checks)
+        return self.context
+
+    def _compute_definition_end_line(self, start_line_num: int) -> int:
+        """Given the codescanner block's start line, compute the block's end line
+        :param start_line_num: codescanner block's first line number (the signature line)
+        :return: the codescanner block's last line number
+        """
+        parsed_file_lines = self.filtered_lines
+        start_line_idx = self.filtered_line_numbers.index(start_line_num)
+        i = 0
+        end_line_num = 0
+        for (line_num, line) in islice(parsed_file_lines, start_line_idx, None):
+            if OPEN_CURLY in line:
+                i += line.count(OPEN_CURLY)
+            if CLOSE_CURLY in line:
+                i -= line.count(CLOSE_CURLY)
+                if i == 0:
+                    end_line_num = line_num
+                    break
+        return end_line_num
+
+    def run(
+            self, tf_file: str, definition_blocks: List[Dict[str, Any]], collect_skip_comments: bool = True
+    ) -> Dict[str, Any]:
+        # TF files for loaded modules have this formation:  <file>[<referrer>#<index>]
+        # Chop off everything after the file name for our purposes here
+        self.tf_file = get_abs_path(tf_file)
+        self.tf_file_path = Path(self.tf_file)
+        self.context = defaultdict(dict)
+        self.file_lines = self._read_file_lines()
+        self.context = self.enrich_definition_block(definition_blocks)
+        if collect_skip_comments:
+            self.context = self._collect_skip_comments(definition_blocks)
+        return self.context
+
+    def get_block_type(self) -> str:
+        return self.definition_type
+
+    @staticmethod
+    def _clean_line(line: str) -> str:
+        res = line.replace('"', " ")
+        if '"{' in res:
+            res = res.split("{")[0]
+        return res
+
+    @abstractmethod
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Enrich the context of a Terraform block
+        :param definition_blocks: Terraform block, key-value dictionary
+        :return: Enriched block context
+        """
+        pass

s1_cns_cli/s1graph/terraform/context_parsers/parsers/__init__.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+modules = Path(__file__).parent.glob("*.py")
+__all__ = [f.stem for f in modules if f.is_file() and not f.stem == "__init__"]

s1_cns_cli/s1graph/terraform/context_parsers/parsers/data_context_parser.py

@@ -0,0 +1,32 @@
+from typing import Dict, Any, List
+
+from hcl2 import START_LINE, END_LINE
+
+from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+
+
+class DataContextParser(BaseContextParser):
+    def __init__(self) -> None:
+        definition_type = "data"
+        super().__init__(definition_type=definition_type)
+
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        entity_type, entity_value = next(iter(entity_block.items()))
+        entity_name = next(iter(entity_value))
+        return [entity_type, entity_name]
+
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        for entity_block in definition_blocks:
+            entity_type, entity_value = next(iter(entity_block.items()))
+            entity_name, entity_config = next(iter(entity_value.items()))
+
+            self.context[entity_type][entity_name] = {
+                "start_line": entity_config[START_LINE],
+                "end_line": entity_config[END_LINE],
+                "code_lines": self.file_lines[entity_config[START_LINE] - 1: entity_config[END_LINE]],
+            }
+
+        return self.context
+
+
+parser = DataContextParser()

s1_cns_cli/s1graph/terraform/context_parsers/parsers/locals_context_parser.py

@@ -0,0 +1,40 @@
+from typing import Dict, Any, List
+
+from hcl2 import START_LINE, END_LINE
+
+from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+import dpath
+
+
+class LocalsContextParser(BaseContextParser):
+    def __init__(self) -> None:
+        definition_type = "locals"
+        super().__init__(definition_type=definition_type)
+
+    def _collect_local_values(self, local_block: Dict[str, Any]) -> None:
+        for local_name, local_value in local_block.items():
+            if local_name in {START_LINE, END_LINE}:
+                continue
+
+            local_value = local_value[0] if isinstance(local_value, list) and len(local_value) > 0 else local_value
+            if type(local_value) in (int, float, bool, str, dict):
+                dpath.new(self.context, ["assignments", local_name], local_value)
+
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        return []
+
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        for entity_block in definition_blocks:
+            if START_LINE in entity_block.keys():
+                self.context["start_line"] = entity_block[START_LINE]
+            if END_LINE in entity_block.keys():
+                self.context["end_line"] = entity_block[END_LINE]
+            if "start_line" in self.context and "end_line" in self.context:
+                self.context["code_lines"] = self.file_lines[self.context["start_line"] - 1: self.context["end_line"]]
+
+            if isinstance(entity_block, dict):
+                self._collect_local_values(entity_block)
+        return self.context
+
+
+parser = LocalsContextParser()

s1_cns_cli/s1graph/terraform/context_parsers/parsers/module_context_parser.py

@@ -0,0 +1,29 @@
+from typing import Dict, Any, List
+
+from hcl2 import END_LINE, START_LINE
+
+from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+
+
+class ModuleContextParser(BaseContextParser):
+    def __init__(self) -> None:
+        definition_type = "module"
+        super().__init__(definition_type=definition_type)
+
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        entity_name = next(iter(entity_block.keys()))
+        return [entity_name]
+
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        for entity_block in definition_blocks:
+            entity_name, entity_config = next(iter(entity_block.items()))
+            self.context[entity_name] = {
+                "start_line": entity_config[START_LINE],
+                "end_line": entity_config[END_LINE],
+                "code_lines": self.file_lines[entity_config[START_LINE] - 1: entity_config[END_LINE]],
+            }
+
+        return self.context
+
+
+parser = ModuleContextParser()

s1_cns_cli/s1graph/terraform/context_parsers/parsers/provider_context_parser.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Dict, Any, List
+
+import hcl2
+from hcl2 import START_LINE, END_LINE
+
+from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+
+
+class ProviderContextParser(BaseContextParser):
+    def __init__(self) -> None:
+        definition_type = "provider"
+        super().__init__(definition_type=definition_type)
+
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        entity_type, entity_value = next(iter(entity_block.items()))
+        return [entity_type, entity_value.get("alias", ["default"])[0]]
+
+    def get_entity_definition_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        entity_type, _ = next(iter(entity_block.items()))
+        return [entity_type]
+
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        for entity_block in definition_blocks:
+            entity_type, entity_config = next(iter(entity_block.items()))
+            entity_name = entity_config.get("alias", ["default"])[0]
+            self.context[entity_type][entity_name] = {
+                "start_line": entity_config[START_LINE],
+                "end_line": entity_config[END_LINE],
+                "code_lines": self.file_lines[entity_config[START_LINE] - 1: entity_config[END_LINE]],
+            }
+
+        return self.context
+
+    def _is_block_signature(self, line_num: int, line_tokens: List[str], entity_context_path: List[str]) -> bool:
+        # Ignore the alias as it is not part of the signature
+        is_provider = super()._is_block_signature(line_num, line_tokens, entity_context_path[0:-1])
+        if not is_provider or "=" in line_tokens or line_tokens[0] != "provider":
+            if not all(bracket in line_tokens for bracket in ("{", "}")):
+                # The line provider = alias is not a provider block although it has the correct words
+                # Also skips comments that include words like provider and aws
+                return False
+
+        end_line = self._compute_definition_end_line(line_num)
+        provider_type = entity_context_path[0]
+        try:
+            provider_obj = hcl2.loads(
+                "\n".join(
+                    map(lambda obj: obj[1], self.file_lines[line_num - 1 : end_line if end_line > line_num else line_num])
+                )
+            )["provider"][0]
+        except Exception as e:
+            logging.info(f'got exception while loading file {self.tf_file}\n {e}')
+            return False
+        alias = provider_obj[provider_type].get("alias", ["default"])
+        return super()._is_block_signature(line_num, line_tokens + alias, entity_context_path)
+
+
+parser = ProviderContextParser()

s1_cns_cli/s1graph/terraform/context_parsers/parsers/resource_context_parser.py

@@ -0,0 +1,36 @@
+from typing import Dict, Any, List
+
+from hcl2 import END_LINE, START_LINE
+
+from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+
+
+class ResourceContextParser(BaseContextParser):
+    def __init__(self) -> None:
+        definition_type = "resource"
+        super().__init__(definition_type=definition_type)
+
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        entity_type = next(iter(entity_block.keys()))
+        entity_name = next(iter(entity_block[entity_type]))
+        return [entity_type, entity_name]
+
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        for entity_block in definition_blocks:
+            entity_type, entity_value = next(iter(entity_block.items()))
+            entity_name, entity_config = next(iter(entity_value.items()))
+
+            if isinstance(entity_config[START_LINE], list) and isinstance(entity_config[END_LINE], list):
+                entity_config[START_LINE] = entity_config[START_LINE][0]
+                entity_config[END_LINE] = entity_config[END_LINE][0]
+
+            self.context[entity_type][entity_name] = {
+                "start_line": entity_config[START_LINE],
+                "end_line": entity_config[END_LINE],
+                "code_lines": self.file_lines[entity_config[START_LINE] - 1: entity_config[END_LINE]],
+            }
+
+        return self.context
+
+
+parser = ResourceContextParser()

s1_cns_cli/s1graph/terraform/context_parsers/parsers/variable_context_parser.py

@@ -0,0 +1,42 @@
+from typing import Dict, Any, List
+
+import dpath
+from hcl2 import START_LINE, END_LINE
+
+from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+
+
+class VariableContextParser(BaseContextParser):
+    def __init__(self) -> None:
+        definition_type = "variable"
+        super().__init__(definition_type=definition_type)
+
+    def _collect_default_variables_values(self, variable_block: Dict[str, Dict[str, Any]]) -> None:
+        for variable_name, values in variable_block.items():
+            default_value = values.get("default")
+            if (
+                isinstance(default_value, list)
+                and len(default_value) == 1
+                and type(default_value[0]) in (int, float, bool, str)
+            ):
+                dpath.new(self.context, ["assignments", variable_name], default_value[0])
+
+    def get_entity_context_path(self, entity_block: Dict[str, Dict[str, Any]]) -> List[str]:
+        entity_name = next(iter(entity_block.keys()))
+        return [entity_name]
+
+    def enrich_definition_block(self, definition_blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        for entity_block in definition_blocks:
+            entity_name, entity_config = next(iter(entity_block.items()))
+            self.context[entity_name] = {
+                "start_line": entity_config[START_LINE],
+                "end_line": entity_config[END_LINE],
+                "code_lines": self.file_lines[entity_config[START_LINE] - 1: entity_config[END_LINE]],
+            }
+
+            if isinstance(entity_block, dict):
+                self._collect_default_variables_values(entity_block)
+        return self.context
+
+
+parser = VariableContextParser()

s1_cns_cli/s1graph/terraform/context_parsers/registry.py

@@ -0,0 +1,48 @@
+import logging
+from typing import Dict, TYPE_CHECKING, Tuple, List, Any
+
+import dpath
+
+from s1_cns_cli.s1graph.terraform.modules.module_objects import TFDefinitionKey
+
+if TYPE_CHECKING:
+    from s1_cns_cli.s1graph.terraform.context_parsers.base_parser import BaseContextParser
+
+
+class ParserRegistry:
+    context_parsers: Dict[str, "BaseContextParser"] = {}  # noqa: CCE003
+    definitions_context: Dict[str, Dict[str, Dict[str, Any]]] = {}  # noqa: CCE003
+
+    def __init__(self) -> None:
+        self.logger = logging.getLogger(__name__)
+
+    def register(self, parser: "BaseContextParser") -> None:
+        self.context_parsers[parser.definition_type] = parser
+
+    def reset_definitions_context(self) -> None:
+        self.definitions_context = {}
+
+    def enrich_definitions_context(
+        self, definitions: Tuple[str, Dict[str, List[Dict[str, Any]]]], collect_skip_comments: bool = True
+    ) -> Dict[str, Dict[str, Dict[str, Any]]]:
+        supported_definitions = [parser_type for parser_type in self.context_parsers.keys()]
+        (tf_definition_key, definition_blocks_types) = definitions
+        if isinstance(tf_definition_key, TFDefinitionKey):
+            tf_file = tf_definition_key.file_path
+        else:
+            tf_file = tf_definition_key
+        if definition_blocks_types:
+            definition_blocks_types = {x: definition_blocks_types[x] for x in definition_blocks_types.keys()}
+            for definition_type in definition_blocks_types.keys():
+                if definition_type in supported_definitions:
+                    dpath.new(self.definitions_context, [tf_file, definition_type], {})
+                    context_parser = self.context_parsers[definition_type]
+                    definition_blocks = definition_blocks_types[definition_type]
+                    self.definitions_context[tf_file][definition_type] = context_parser.run(
+                        tf_file, definition_blocks, collect_skip_comments
+                    )
+
+        return self.definitions_context
+
+
+parser_registry = ParserRegistry()

s1_cns_cli/s1graph/terraform/context_parsers/tf_plan/__init__.py

@@ -0,0 +1,34 @@
+import logging
+from typing import Dict
+
+from s1_cns_cli.s1graph.cloudformation.parser.cfn_yaml import ContentType
+from s1_cns_cli.s1graph.cloudformation.parser import cfn_yaml
+
+LOGGER = logging.getLogger(__name__)
+
+
+def parse(filename, out_parsing_errors: Dict[str, str]):
+    """
+        Decode filename into an object
+    """
+    logging.debug(f"[tf_plan] - Parsing file {filename}")
+
+    try:
+        template, template_lines = cfn_yaml.load(filename, ContentType.TFPLAN)
+    except Exception as e:
+        logging.debug(f"[tf_plan] - Failed to parse file {filename}", exc_info=True)
+        out_parsing_errors[filename] = str(e)
+        return None, None
+
+    if (
+        template is not None
+        and isinstance(template, dict)
+        and 'terraform_version' in template
+        and 'planned_values' in template
+    ):
+        logging.debug(f"[tf_plan] - Successfully parsed file {filename}")
+
+        return template, template_lines
+
+    logging.debug(f"[tf_plan] - Missing required fields in file {filename}")
+    return None, None

s1_cns_cli/s1graph/terraform/deep_analysis_plan_graph_manager.py

@@ -0,0 +1,50 @@
+import logging
+
+from s1_cns_cli.s1graph.terraform.graph_builder.graph_components.blocks import TerraformBlock
+from s1_cns_cli.s1graph.terraform.graph_builder.local_graph import TerraformLocalGraph
+from s1_cns_cli.s1graph.terraform.graph_builder.graph_components.block_types import BlockType
+from s1_cns_cli.s1graph.common.output.report import Report
+from s1_cns_cli.s1graph.terraform.plan_parser import TF_PLAN_RESOURCE_ADDRESS
+from typing import Dict
+
+
+class DeepAnalysisGraphManager:
+    def __init__(self, tf_graph: TerraformLocalGraph, tf_plan_graph: TerraformLocalGraph) -> None:
+        self.tf_graph: TerraformLocalGraph = tf_graph
+        self.tf_plan_graph: TerraformLocalGraph = tf_plan_graph
+        self._address_to_tf_vertex_map: Dict[str, TerraformBlock] = {}
+        self._address_to_tf_plan_vertex_map: Dict[str, TerraformBlock] = {}
+        self._apply_address_mapping()
+
+    def _apply_address_mapping(self) -> None:
+        self._address_to_tf_vertex_map = {
+            vertex.attributes[TF_PLAN_RESOURCE_ADDRESS]: vertex
+            for vertex in self.tf_graph.vertices
+            if vertex.block_type == BlockType.RESOURCE
+        }
+        self._address_to_tf_plan_vertex_map = {
+            vertex.attributes[TF_PLAN_RESOURCE_ADDRESS]: vertex
+            for vertex in self.tf_plan_graph.vertices
+            if vertex.block_type == BlockType.RESOURCE
+        }
+
+    def enrich_tf_graph_attributes(self) -> None:
+        for address, tf_plan_vertex in self._address_to_tf_plan_vertex_map.items():
+            tf_vertex = self._address_to_tf_vertex_map.get(address)
+            if not tf_vertex:
+                logging.info(f'Cant find this address: {address} in tf graph')
+                continue
+            tf_vertex.attributes = {**tf_vertex.attributes, **tf_plan_vertex.attributes}
+            tf_vertex.path = tf_plan_vertex.path
+
+    def filter_report(self, report: Report) -> None:
+        report.failed_checks = [check for check in report.failed_checks if
+                                check.resource_address in self._address_to_tf_plan_vertex_map]
+        report.passed_checks = [check for check in report.passed_checks if
+                                check.resource_address in self._address_to_tf_plan_vertex_map]
+        report.skipped_checks = [check for check in report.skipped_checks if
+                                 check.resource_address in self._address_to_tf_plan_vertex_map]
+        # No need to filter other fields for now
+        report.resources = set()
+        report.extra_resources = set()
+        report.parsing_errors = []