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

s1_cns_cli/s1graph/terraform/graph_builder/variable_rendering/safe_eval_functions.py

@@ -0,0 +1,344 @@
+import itertools
+import logging
+import re
+from datetime import datetime, timedelta
+from functools import reduce
+from math import ceil, floor, log
+from typing import Union, Any, Dict, Callable, List, Optional
+
+from s1_cns_cli.s1graph.terraform.parser_functions import tonumber, FUNCTION_FAILED, create_map, tobool, tostring
+
+"""
+This file contains a custom implementation of the builtin `eval` function.
+`eval` is not a safe function, because it can execute *every* command,
+so this file overrides `eval` and allows only the functions in SAFE_EVAL_DICT.
+
+The functions are an implementation of Terraform's built-in functions
+https://www.terraform.io/docs/configuration/functions.html
+
+Not all of the functions are implemented yet. If a function doesn't exist, the original value is returned.
+"""
+
+
+def _find_regex_groups(pattern: str, input_str: str) -> Optional[Union[Dict[str, str], List[str]]]:
+    match = re.match(pattern, input_str)
+    if match:
+        if match.groupdict():
+            # try to find named capturing groups
+            return match.groupdict()
+        if list(match.groups()):
+            # try to find unnamed capturing groups
+            return list(match.groups())
+    return None
+
+
+def regex(pattern: str, input_str: str) -> Union[Dict[str, str], List[str], str]:
+    try:
+        groups = _find_regex_groups(pattern, input_str)
+        if groups is not None:
+            return groups
+
+        results: List[str] = re.findall(pattern, input_str)
+        # return first match
+        if len(results) > 0:
+            return results[0]
+        return ""
+    except TypeError:
+        return f"regex({pattern}, {input_str})"
+
+
+def regexall(pattern: str, input_str: str) -> Union[Dict[str, str], List[str], str]:
+    try:
+        groups = _find_regex_groups(pattern, input_str)
+        if groups is not None:
+            return groups
+
+        results = re.findall(pattern, input_str)
+        return results
+    except TypeError:
+        return f"regexall({pattern}, {input_str})"
+
+
+def trim(input_str: str, chars_to_remove: str) -> str:
+    for c in chars_to_remove:
+        input_str = input_str.replace(c, "")
+    return input_str
+
+
+def coalesce(*arg: Any) -> Any:
+    return reduce(lambda x, y: x if x not in [None, ""] else y, arg)
+
+
+def coalesce_list(*arg: List[Any]) -> List[Any]:
+    return reduce(lambda x, y: x if x not in [None, []] else y, arg)
+
+
+def flatten(lst: List[List[Any]]) -> List[Any]:
+    res = [item for sublist in lst for item in sublist]
+    if any(type(elem) is list for elem in res):
+        return flatten(res)
+    else:
+        return res
+
+
+def matchkeys(values_list: List[Any], keys_list: List[Any], search_set: List[Any]) -> List[Any]:
+    matching = set()
+    for search in search_set:
+        indices = [i for i, x in enumerate(keys_list) if x == search]
+        for i in indices:
+            matching.add(values_list[i])
+
+    return list(matching)
+
+
+def reverse(lst: List[Any]) -> List[Any]:
+    lst.reverse()
+    return lst
+
+
+def sort(lst: List[str]) -> List[str]:
+    lst.sort()
+    return lst
+
+
+def merge(*args: Any) -> Dict[str, Any]:
+    res: Dict[str, Any] = {}
+    for d in args:
+        res = {**res, **d}
+    return res
+
+
+def wrap_func(f: Callable[..., Any], *args: Any) -> Any:
+    res = f(*args)
+    if res == FUNCTION_FAILED:
+        raise ValueError
+    return res
+
+
+def update_datetime(dt: datetime, delta: timedelta, adding: bool) -> datetime:
+    if adding is True:
+        dt = dt + delta
+    else:
+        dt = dt - delta
+    return dt
+
+
+def timeadd(input_str: str, time_delta: str) -> str:
+    '''
+    From docs:
+    duration is a string representation of a time difference, consisting of sequences of number and unit pairs,
+     like "1.5h" or "1h30m". The accepted units are "ns", "us" (or "µs"), "ms", "s", "m", and "h".
+     The first number may be negative to indicate a negative duration, like "-2h5m".
+    '''
+
+    # Convert the date to allowing parsing
+    input_str = input_str.replace("Z", "+00:00")
+    dt = datetime.fromisoformat(input_str)
+    adding = True
+    if time_delta[0] == '-':
+        adding = False
+        time_delta = time_delta[1:]
+    # Split out into each of the deltas
+    deltas = re.split(r'(\d*\.*\d+)', time_delta)
+    # Needed to strip the leading empty element
+    deltas = list(filter(None, deltas))
+    while len(deltas) > 0:
+        amount = float(deltas[0])
+        interval = deltas[1]
+        deltas = deltas[2:]
+        delta = timedelta(0)
+        if interval == 'h':
+            delta = timedelta(hours=amount)
+        elif interval == 'm':
+            delta = timedelta(minutes=amount)
+        elif interval == 's':
+            delta = timedelta(seconds=amount)
+        elif interval == 'ms':
+            delta = timedelta(milliseconds=amount)
+        elif interval == 'us' or interval == 'µs':
+            delta = timedelta(microseconds=amount)
+        elif interval == 'ns':  # Crude, but timedelta does not deal with nanoseconds
+            delta = timedelta(microseconds=(amount / 1000))
+
+        dt = update_datetime(dt, delta, adding)
+
+    return dt.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+
+def process_formatting_codes(format_str: str, dt: datetime) -> str:
+    format_mapping = {
+        "YYYY": "%Y",
+        "YY": "%y",
+        "MMMM": "%B",
+        "MMM": "%b",
+        "MM": "%m",
+        "M": "%-m",
+        "DD" : "%d",
+        "D" : "%-d",
+        "EEEE" : "%A",
+        "EEE" : "%a",
+        "HH" : "%I",
+        "H" : "%-I",
+        "hh" : "%H",
+        "h" : "%-H",
+        "mm" : "%M",
+        "m" : "%-M",
+        "ss" : "%S",
+        "s" : "%-S",
+        "AA" : "%p",
+        # "aa" : "%p",  # included for completeness but requires separate handling
+        "ZZZZZ" : "%z",
+        "ZZZZ" : "%z",
+        "ZZZ" : "%z",
+        "Z " : "%z"}
+
+    if format_str == 'aa':
+        format_str = dt.strftime('%p').lower()
+    elif format_str == 'ZZZZZ':
+        tz = dt.strftime("%z")
+        format_str = tz[:3] + ":" + tz[3:]
+    elif format_str == 'ZZZ':
+        tz = dt.strftime("%z")
+        if tz == '+0000':
+            tz = 'UTC'
+        format_str = tz
+    elif format_str == 'Z':
+        tz = dt.strftime("%z")
+        if tz == '+0000':
+            tz = 'Z'
+        format_str = tz
+    else:
+        format_str = format_mapping.get(format_str, format_str)
+
+    return format_str
+
+
+def formatdate(format_str: str, input_str: str) -> str:
+    '''
+    From docs: This function is intended for producing common machine-oriented timestamp formats such as
+    those defined in RFC822, RFC850, and RFC1123. It is not suitable for truly human-oriented date
+    formatting because it is not locale-aware.
+    Any non-letter characters, such as punctuation, are reproduced verbatim in the output.
+    To include literal letters in the format string, enclose them in single quotes '.
+    To include a literal quote, escape it by doubling the quotes.
+    Function works through the format string halting on single quotes to process any formatting
+    '''
+
+    # Convert the input str to a date
+    input_str = input_str.replace("Z", "+00:00")
+    dt = datetime.fromisoformat(input_str)
+
+    processed_format_str = ""
+    format_str_segment = ""
+    in_quote = False  # Keep track of whether in formatting or quoted text
+    last_ch = ""  # Used to identify the '' scenario
+    for ch in format_str:
+        if ch == "'" or in_quote is True:
+            if len(format_str_segment) > 0:
+                processed_format_str += process_formatting_codes(format_str_segment, dt)
+                format_str_segment = ""
+            if ch == "'":
+                if last_ch == "'":
+                    processed_format_str += "'"
+                in_quote = not in_quote
+            else:
+                processed_format_str += ch
+        else:
+            if ch != last_ch and last_ch != "":  # new format codescanner and the start of the string
+                processed_format_str += process_formatting_codes(format_str_segment, dt)
+                format_str_segment = ""
+            format_str_segment += ch
+        last_ch = ch
+    if len(format_str_segment) > 0:
+        processed_format_str += process_formatting_codes(format_str_segment, dt)
+
+    return dt.strftime(processed_format_str)
+
+
+SAFE_EVAL_FUNCTIONS: List[str] = []
+SAFE_EVAL_DICT = dict([(k, locals().get(k, None)) for k in SAFE_EVAL_FUNCTIONS])
+
+# math functions
+SAFE_EVAL_DICT["abs"] = abs
+SAFE_EVAL_DICT["ceil"] = ceil
+SAFE_EVAL_DICT["floor"] = floor
+SAFE_EVAL_DICT["log"] = log
+SAFE_EVAL_DICT["max"] = max
+SAFE_EVAL_DICT["min"] = min
+SAFE_EVAL_DICT["parsint"] = int
+SAFE_EVAL_DICT["pow"] = pow
+SAFE_EVAL_DICT["signum"] = lambda x: -1 if x < 0 else 0 if x == 0 else 1
+
+# string functions
+SAFE_EVAL_DICT["chomp"] = lambda x: x.rstrip()
+SAFE_EVAL_DICT["format"] = lambda text_to_format, *args: (text_to_format % args)
+SAFE_EVAL_DICT["formatlist"] = lambda text_to_format, args_list: [(text_to_format % args) for args in args_list]
+SAFE_EVAL_DICT["indent"] = lambda num_of_space, input_str: input_str
+SAFE_EVAL_DICT["join"] = lambda separator, lst: separator.join(lst)
+SAFE_EVAL_DICT["lower"] = lambda input_str: input_str.lower()
+SAFE_EVAL_DICT["regex"] = regex
+SAFE_EVAL_DICT["regexall"] = regexall
+SAFE_EVAL_DICT["replace"] = lambda string, substring, replacement: string.replace(substring, replacement)
+SAFE_EVAL_DICT["split"] = lambda separator, input_str: input_str.split(separator)
+SAFE_EVAL_DICT["strrev"] = lambda input_str: input_str[::-1]
+SAFE_EVAL_DICT["substr"] = lambda input_str, offset, length: input_str[offset : offset + length]
+SAFE_EVAL_DICT["title"] = lambda input_str: input_str.title()
+SAFE_EVAL_DICT["trim"] = trim
+SAFE_EVAL_DICT["trimprefix"] = lambda input_str, prefix: input_str.lstrip(prefix)
+SAFE_EVAL_DICT["trimsuffix"] = lambda input_str, prefix: input_str.rstrip(prefix)
+SAFE_EVAL_DICT["trimspace"] = lambda input_str: input_str.strip()
+SAFE_EVAL_DICT["upper"] = lambda input_str: input_str.upper()
+
+# collections
+SAFE_EVAL_DICT["chunklist"] = lambda lst, chunk_size: [lst[i : i + chunk_size] for i in range(0, len(lst), chunk_size)]
+SAFE_EVAL_DICT["coalesce"] = coalesce
+SAFE_EVAL_DICT["coalescelist"] = coalesce_list
+SAFE_EVAL_DICT["compact"] = lambda lst: list(filter(lambda l: l != "", lst))
+SAFE_EVAL_DICT["concat"] = lambda *lists: list(itertools.chain(*lists))
+SAFE_EVAL_DICT["contains"] = lambda lst, value: value in lst
+SAFE_EVAL_DICT["distinct"] = lambda lst: list(dict.fromkeys(lst))
+SAFE_EVAL_DICT["element"] = lambda lst, index: lst[index]
+SAFE_EVAL_DICT["flatten"] = flatten
+SAFE_EVAL_DICT["index"] = lambda lst, value: lst.index(value)
+SAFE_EVAL_DICT["keys"] = lambda map_input: list(map_input.keys())
+SAFE_EVAL_DICT["length"] = len
+SAFE_EVAL_DICT["list"] = lambda *args: list(args)
+SAFE_EVAL_DICT["lookup"] = lambda map_input, key, default: map_input.get(key, default)
+SAFE_EVAL_DICT["map"] = lambda *args: wrap_func(create_map, list(args))
+SAFE_EVAL_DICT["matchkeys"] = matchkeys
+SAFE_EVAL_DICT["merge"] = merge
+# SAFE_EVAL_DICT['range']
+SAFE_EVAL_DICT["reverse"] = reverse
+SAFE_EVAL_DICT["sort"] = sort
+
+
+# type conversion
+SAFE_EVAL_DICT["tobool"] = lambda arg: wrap_func(tobool, arg)
+SAFE_EVAL_DICT["tolist"] = lambda *args: list(*args)
+# SAFE_EVAL_DICT["tomap"] = lambda arg: wrap_func(tomap, str(arg))
+SAFE_EVAL_DICT["tonumber"] = lambda arg: arg if type(arg) in [int, float] else wrap_func(tonumber, arg)
+SAFE_EVAL_DICT["toset"] = lambda origin: set(origin)
+SAFE_EVAL_DICT["tostring"] = lambda arg: arg if isinstance(arg, str) else wrap_func(tostring, str(arg))
+
+# encoding
+SAFE_EVAL_DICT["jsonencode"] = lambda arg: arg
+
+# date functions
+SAFE_EVAL_DICT["timestamp"] = lambda: datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ')
+SAFE_EVAL_DICT["timeadd"] = timeadd
+SAFE_EVAL_DICT["formatdate"] = formatdate
+
+
+def evaluate(input_str: str) -> Any:
+    if "__" in input_str:
+        logging.debug(f"got a substring with double underscore, which is not allowed. origin string: {input_str}")
+        return input_str
+    if input_str == "...":
+        # don't create an Ellipsis object
+        return input_str
+    evaluated = eval(input_str, {"__builtins__": None}, SAFE_EVAL_DICT)  # nosec
+    return evaluated if not isinstance(evaluated, str) else remove_unicode_null(evaluated)
+
+
+def remove_unicode_null(input_str: str) -> str:
+    return input_str.replace("\u0000", "\\0")

s1_cns_cli/s1graph/terraform/graph_builder/variable_rendering/vertex_reference.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from s1_cns_cli.s1graph.common.graph.graph_builder.variable_rendering.vertex_reference import VertexReference
+from s1_cns_cli.s1graph.terraform.graph_builder.graph_components.block_types import BlockType
+
+
+class TerraformVertexReference(VertexReference):
+    def __init__(self, block_type: str, sub_parts: list[str], origin_value: str) -> None:
+        super().__init__(block_type, sub_parts, origin_value)
+
+    @staticmethod
+    def block_type_str_to_enum(block_type_str: str) -> str:
+        if block_type_str == "var":
+            return BlockType.VARIABLE
+        if block_type_str == "local":
+            return BlockType.LOCALS
+        return BlockType().get(block_type_str)

s1_cns_cli/s1graph/terraform/graph_manager.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Type, Any, TYPE_CHECKING
+
+from s1_cns_cli.s1graph.common.runners.base_runner import strtobool
+from s1_cns_cli.s1graph.common.util.consts import DEFAULT_EXTERNAL_MODULES_DIR
+from s1_cns_cli.s1graph.terraform.graph_builder.local_graph import TerraformLocalGraph
+from s1_cns_cli.s1graph.terraform.parser import Parser
+
+from s1_cns_cli.s1graph.common.graph.graph_manager import GraphManager
+from s1_cns_cli.s1graph.terraform.tf_parser import TFParser
+
+if TYPE_CHECKING:
+    from s1_cns_cli.s1graph.common.typing import LibraryGraphConnector
+
+
+class TerraformGraphManager(GraphManager[TerraformLocalGraph, "dict[str, dict[str, Any]]"]):
+    def __init__(self, db_connector: LibraryGraphConnector, source: str = "") -> None:
+        parser = TFParser() if strtobool(os.getenv('SENTINELONE_CNS_NEW_TF_PARSER', 'False')) else Parser()
+        super().__init__(db_connector=db_connector, parser=parser, source=source)
+
+    def build_graph_from_source_directory(
+        self,
+        source_dir: str,
+        render_variables: bool = True,
+        local_graph_class: Type[TerraformLocalGraph] = TerraformLocalGraph,
+        parsing_errors: dict[str, Exception] | None = None,
+        download_external_modules: bool = False,
+        external_modules_download_path: str = DEFAULT_EXTERNAL_MODULES_DIR,
+        excluded_paths: list[str] | None = None,
+        vars_files: list[str] | None = None,
+        create_graph: bool = True,
+    ) -> tuple[TerraformLocalGraph | None, dict[str, dict[str, Any]]]:
+        logging.info("Parsing HCL files in source dir")
+        module, tf_definitions = self.parser.parse_hcl_module(
+            source_dir=source_dir,
+            source=self.source,
+            download_external_modules=download_external_modules,
+            external_modules_download_path=external_modules_download_path,
+            parsing_errors=parsing_errors,
+            excluded_paths=excluded_paths,
+            vars_files=vars_files,
+            create_graph=create_graph,
+        )
+
+        local_graph = None
+        if create_graph and module:
+            logging.info("Building graph from parsed module")
+            local_graph = local_graph_class(module)
+            local_graph.build_graph(render_variables=render_variables)
+
+        return local_graph, tf_definitions
+
+    def build_graph_from_definitions(
+        self, definitions: dict[str, dict[str, Any]], render_variables: bool = True
+    ) -> TerraformLocalGraph:
+        module, _ = self.parser.parse_hcl_module_from_tf_definitions(definitions, "", self.source)
+        local_graph = TerraformLocalGraph(module)
+        local_graph.build_graph(render_variables=render_variables)
+
+        return local_graph

s1_cns_cli/s1graph/terraform/image_referencer/base_provider.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import os
+
+from hcl2 import START_LINE as HCL_START_LINE, END_LINE as HCL_END_LINE
+
+from s1_cns_cli.s1graph.common.graph.graph_builder import CustomAttributes
+from s1_cns_cli.s1graph.common.images.graph.image_referencer_provider import GraphImageReferencerProvider
+from s1_cns_cli.s1graph.common.images.image_referencer import Image
+from s1_cns_cli.s1graph.common.util.consts import START_LINE, END_LINE
+from s1_cns_cli.s1graph.common.util.str_utils import removeprefix
+from s1_cns_cli.s1graph.terraform.graph_builder.utils import setup_file_path_to_referred_id, get_related_resource_id
+
+
+class BaseTerraformProvider(GraphImageReferencerProvider):
+
+    def extract_images_from_resources(self) -> list[Image]:
+        images = []
+        supported_resources_graph = self.extract_nodes()
+        file_path_to_referred_id = setup_file_path_to_referred_id(self.graph_connector)
+
+        for resource in self.extract_resource(supported_resources_graph):
+            image_names: list[str] = []
+            resource_type = resource[CustomAttributes.RESOURCE_TYPE]
+
+            extract_images_func = self.supported_resource_types.get(resource_type)
+            if extract_images_func:
+                image_names.extend(extract_images_func(resource))
+
+            if not image_names:
+                # no need to process any further
+                continue
+
+            start_line = 0
+            end_line = 0
+            if all(key in resource for key in (HCL_START_LINE, HCL_END_LINE)):
+                # hcl file
+                start_line = resource[HCL_START_LINE]
+                end_line = resource[HCL_END_LINE]
+            elif all(key in resource for key in (START_LINE, END_LINE)):
+                # TF plan file
+                start_line = resource[START_LINE]
+                end_line = resource[END_LINE]
+
+            related_resource_id = get_related_resource_id(resource, file_path_to_referred_id)
+            for name in image_names:
+                images.append(
+                    Image(
+                        file_path=resource[CustomAttributes.FILE_PATH],
+                        name=name,
+                        start_line=start_line,
+                        end_line=end_line,
+                        related_resource_id=f'{removeprefix(resource.get("file_path_", ""), os.getenv("BC_ROOT_DIR", ""))}:{related_resource_id}'
+                    )
+                )
+
+        return images

s1_cns_cli/s1graph/terraform/image_referencer/manager.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from s1_cns_cli.s1graph.common.images.graph.image_referencer_manager import GraphImageReferencerManager
+from s1_cns_cli.s1graph.terraform.image_referencer.provider.aws import AwsTerraformProvider
+from s1_cns_cli.s1graph.terraform.image_referencer.provider.azure import AzureTerraformProvider
+from s1_cns_cli.s1graph.terraform.image_referencer.provider.gcp import GcpTerraformProvider
+
+if TYPE_CHECKING:
+    from s1_cns_cli.s1graph.common.images.image_referencer import Image
+
+
+class TerraformImageReferencerManager(GraphImageReferencerManager):
+
+    def extract_images_from_resources(self) -> list[Image]:
+        images = []
+
+        aws_provider = AwsTerraformProvider(graph_connector=self.graph_connector)
+        azure_provider = AzureTerraformProvider(graph_connector=self.graph_connector)
+        gcp_provider = GcpTerraformProvider(graph_connector=self.graph_connector)
+
+        images.extend(aws_provider.extract_images_from_resources())
+        images.extend(azure_provider.extract_images_from_resources())
+        images.extend(gcp_provider.extract_images_from_resources())
+
+        return images

s1_cns_cli/s1graph/terraform/image_referencer/provider/aws.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+
+from s1_cns_cli.s1graph.common.util.data_structures_utils import find_in_dict
+from s1_cns_cli.s1graph.common.util.type_forcers import force_list, extract_json
+from s1_cns_cli.s1graph.terraform.image_referencer.base_provider import BaseTerraformProvider
+
+if TYPE_CHECKING:
+    from networkx import DiGraph
+
+
+class AwsTerraformProvider(BaseTerraformProvider):
+    def __init__(self, graph_connector: DiGraph) -> None:
+        super().__init__(
+            graph_connector=graph_connector,
+            supported_resource_types=SUPPORTED_AWS_IMAGE_RESOURCE_TYPES,
+        )
+
+
+def extract_images_from_aws_apprunner_service(resource: dict[str, Any]) -> list[str]:
+    image_names: list[str] = []
+
+    image_repo = find_in_dict(input_dict=resource, key_path="source_configuration/image_repository")
+    if isinstance(image_repo, dict):
+        repo_type = image_repo.get("image_repository_type")
+        name = image_repo.get("image_identifier")
+        if name and isinstance(name, str) and repo_type == "ECR_PUBLIC":
+            image_names.append(name)
+
+    return image_names
+
+
+def extract_images_from_aws_batch_job_definition(resource: dict[str, Any]) -> list[str]:
+    image_names: list[str] = []
+
+    properties = extract_json(resource.get("container_properties"))
+    if isinstance(properties, dict):
+        name = properties.get("image")
+        if name and isinstance(name, str):
+            image_names.append(name)
+
+    # node properties are not supported yet
+    # https://github.com/hashicorp/terraform-provider-aws/issues/20983
+
+    return image_names
+
+
+def extract_images_from_aws_codebuild_project(resource: dict[str, Any]) -> list[str]:
+    image_names: list[str] = []
+
+    name = find_in_dict(input_dict=resource, key_path="environment/image")
+    if name and isinstance(name, str):
+        # AWS provided images have an internal identifier
+        if not name.startswith("aws/codebuild/"):
+            image_names.append(name)
+
+    return image_names
+
+
+def extract_images_from_aws_ecs_task_definition(resource: dict[str, Any]) -> list[str]:
+    image_names: list[str] = []
+
+    definitions = extract_json(resource.get("container_definitions"))
+    if isinstance(definitions, list):
+        for definition in definitions:
+            if isinstance(definition, dict):
+                name = definition.get("image")
+                if name and isinstance(name, str):
+                    image_names.append(name)
+
+    return image_names
+
+
+def extract_images_from_aws_lightsail_container_service_deployment_version(resource: dict[str, Any]) -> list[str]:
+    image_names: list[str] = []
+
+    containers = resource.get("container")
+    if containers:
+        for container in force_list(containers):
+            if isinstance(container, dict):
+                name = container.get("image")
+                if name and isinstance(name, str):
+                    image_names.append(name)
+
+    return image_names
+
+
+# needs to be at the bottom to add the defined functions
+SUPPORTED_AWS_IMAGE_RESOURCE_TYPES = {
+    "aws_apprunner_service": extract_images_from_aws_apprunner_service,
+    "aws_batch_job_definition": extract_images_from_aws_batch_job_definition,
+    "aws_codebuild_project": extract_images_from_aws_codebuild_project,
+    "aws_ecs_task_definition": extract_images_from_aws_ecs_task_definition,
+    "aws_lightsail_container_service_deployment_version": extract_images_from_aws_lightsail_container_service_deployment_version,
+}