예제 #1
0
    def setUp(self):
        self.test_root_dir = os.path.realpath(
            os.path.join(TEST_DIRNAME, RELATIVE_PATH))

        definitions, definitions_raw = get_folder_definitions(
            self.test_root_dir, None)
        self.definitions_context = build_definitions_context(
            definitions, definitions_raw, self.test_root_dir)
예제 #2
0
파일: runner.py 프로젝트: tronxd/checkov
    def run(
        self,
        root_folder: str,
        external_checks_dir: Optional[List[str]] = None,
        files: Optional[List[str]] = None,
        runner_filter: RunnerFilter = RunnerFilter(),
        collect_skip_comments: bool = True,
    ) -> Report:
        report = Report(self.check_type)
        parsing_errors = {}

        if self.context is None or self.definitions is None or self.breadcrumbs is None:
            self.definitions, self.definitions_raw = create_definitions(
                root_folder, files, runner_filter, parsing_errors)
            if external_checks_dir:
                for directory in external_checks_dir:
                    cfn_registry.load_external_checks(directory)
                    self.graph_registry.load_external_checks(directory)
            self.context = build_definitions_context(self.definitions,
                                                     self.definitions_raw,
                                                     root_folder)

            logging.info("creating cloudformation graph")
            local_graph = self.graph_manager.build_graph_from_definitions(
                self.definitions)
            for vertex in local_graph.vertices:
                if vertex.block_type == BlockType.RESOURCE:
                    report.add_resource(f'{vertex.path}:{vertex.id}')
            self.graph_manager.save_graph(local_graph)
            self.definitions, self.breadcrumbs = convert_graph_vertices_to_definitions(
                local_graph.vertices, root_folder)

        # TODO: replace with real graph rendering
        for cf_file in self.definitions.keys():
            file_definition = self.definitions.get(cf_file, None)
            file_definition_raw = self.definitions_raw.get(cf_file, None)
            if file_definition is not None and file_definition_raw is not None:
                cf_context_parser = ContextParser(cf_file, file_definition,
                                                  file_definition_raw)
                logging.debug("Template Dump for {}: {}".format(
                    cf_file, json.dumps(file_definition, indent=2,
                                        default=str)))
                cf_context_parser.evaluate_default_refs()

        report.add_parsing_errors(list(parsing_errors.keys()))
        # run checks
        self.check_definitions(root_folder, runner_filter, report)

        # run graph checks
        graph_report = self.get_graph_checks_report(root_folder, runner_filter)
        merge_reports(report, graph_report)

        return report