devsecops-engine-tools 1.8.10__tar.gz → 1.8.12__tar.gz

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.8.10
+Version: 1.8.12
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_core/src/domain/model/customs_exceptions.py

@@ -12,3 +12,8 @@ class ExceptionGettingFindings(Exception):
     def __init__(self, message):
         self.message = message
         super().__init__(self.message)
+
+class ExceptionGettingEngagements(Exception):
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_core/src/domain/model/gateway/vulnerability_management_gateway.py

@@ -21,3 +21,9 @@ class VulnerabilityManagementGateway(metaclass=ABCMeta):
         self, service, dict_args, secret_tool, config_tool
     ):
         "get all findings and exclusions from vulnerability management platform"
+
+    @abstractmethod
+    def get_active_engagements(
+        self, engagement_name, dict_args, secret_tool, config_tool
+    ):
+        "get_active_engagements"

devsecops_engine_tools-1.8.12/devsecops_engine_tools/engine_core/src/domain/usecases/handle_risk.py

@@ -0,0 +1,178 @@
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.vulnerability_management_gateway import (
+    VulnerabilityManagementGateway,
+)
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.secrets_manager_gateway import (
+    SecretsManagerGateway,
+)
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.devops_platform_gateway import (
+    DevopsPlatformGateway,
+)
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.printer_table_gateway import (
+    PrinterTableGateway,
+)
+from devsecops_engine_tools.engine_risk.src.applications.runner_engine_risk import (
+    runner_engine_risk,
+)
+from devsecops_engine_tools.engine_core.src.domain.model.customs_exceptions import (
+    ExceptionGettingFindings,
+)
+from devsecops_engine_tools.engine_core.src.domain.model.input_core import InputCore
+import re
+
+from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
+from devsecops_engine_tools.engine_utilities import settings
+
+logger = MyLogger.__call__(**settings.SETTING_LOGGER).get_logger()
+
+
+class HandleRisk:
+    def __init__(
+        self,
+        vulnerability_management: VulnerabilityManagementGateway,
+        secrets_manager_gateway: SecretsManagerGateway,
+        devops_platform_gateway: DevopsPlatformGateway,
+        print_table_gateway: PrinterTableGateway,
+    ):
+        self.vulnerability_management = vulnerability_management
+        self.secrets_manager_gateway = secrets_manager_gateway
+        self.devops_platform_gateway = devops_platform_gateway
+        self.print_table_gateway = print_table_gateway
+
+    def _get_all_from_vm(self, dict_args, secret_tool, remote_config, service):
+        try:
+            return self.vulnerability_management.get_all(
+                service,
+                dict_args,
+                secret_tool,
+                remote_config,
+            )
+        except ExceptionGettingFindings as e:
+            logger.error(
+                "Error getting finding list in handle risk: {0}".format(str(e))
+            )
+
+    def _filter_engagements(self, engagements, service, risk_config):
+        filtered_engagements = []
+        min_word_length = risk_config["HANDLE_SERVICE_NAME"]["MIN_WORD_LENGTH"]
+        words = [
+            word
+            for word in re.split(
+                risk_config["HANDLE_SERVICE_NAME"]["REGEX_GET_WORDS"], service
+            )
+            if len(word) > min_word_length
+        ]
+        check_words_regex = risk_config["HANDLE_SERVICE_NAME"]["REGEX_CHECK_WORDS"]
+        min_word_amount = risk_config["HANDLE_SERVICE_NAME"]["MIN_WORD_AMOUNT"]
+        for engagement in engagements:
+            if service.lower() in engagement.name.lower():
+                filtered_engagements += [engagement.name]
+            elif re.search(check_words_regex, engagement.name.lower()) and (
+                sum(1 for word in words if word.lower() in engagement.name.lower())
+                >= min_word_amount
+            ):
+                filtered_engagements += [engagement.name]
+        return filtered_engagements
+
+    def _exclude_services(self, dict_args, pipeline_name, service_list):
+        risk_exclusions = self.devops_platform_gateway.get_remote_config(
+            dict_args["remote_config_repo"], "engine_risk/Exclusions.json"
+        )
+        if (
+            pipeline_name in risk_exclusions
+            and risk_exclusions[pipeline_name].get("SKIP_SERVICE", 0)
+            and risk_exclusions[pipeline_name]["SKIP_SERVICE"].get("services", 0)
+        ):
+            services_to_exclude = risk_exclusions[pipeline_name]["SKIP_SERVICE"].get(
+                "services", []
+            )
+            service_excluded = []
+            for service in service_list:
+                if service in services_to_exclude:
+                    service_list.remove(service)
+                    service_excluded += [service]
+            print(f"Services to exclude: {service_excluded}")
+            logger.info(f"Services to exclude: {service_excluded}")
+        return service_list
+
+    def process(self, dict_args: any, remote_config: any):
+        secret_tool = None
+        if dict_args["use_secrets_manager"] == "true":
+            secret_tool = self.secrets_manager_gateway.get_secret(remote_config)
+
+        risk_config = self.devops_platform_gateway.get_remote_config(
+            dict_args["remote_config_repo"], "engine_risk/ConfigTool.json"
+        )
+
+        pipeline_name = self.devops_platform_gateway.get_variable("pipeline_name")
+        service = pipeline_name
+        service_list = []
+
+        if risk_config["HANDLE_SERVICE_NAME"]["ENABLED"].lower() == "true":
+            service = next(
+                (
+                    pipeline_name.replace(ending, "")
+                    for ending in risk_config["HANDLE_SERVICE_NAME"][
+                        "ERASE_SERVICE_ENDING"
+                    ]
+                    if pipeline_name.endswith(ending)
+                ),
+                pipeline_name,
+            )
+            match_service_code = re.match(
+                risk_config["HANDLE_SERVICE_NAME"]["REGEX_GET_SERVICE_CODE"], service
+            )
+            if match_service_code:
+                service_code = match_service_code.group(0)
+                service_list += [
+                    service.format(service_code=service_code)
+                    for service in risk_config["HANDLE_SERVICE_NAME"]["ADD_SERVICES"]
+                ]
+                engagements = self.vulnerability_management.get_active_engagements(
+                    service_code, dict_args, secret_tool, remote_config
+                )
+                service_list += self._filter_engagements(
+                    engagements, service, risk_config
+                )
+
+        service_list += [service]
+
+        match_parent = re.match(
+            risk_config["PARENT_ANALYSIS"]["REGEX_GET_PARENT"], service
+        )
+        if risk_config["PARENT_ANALYSIS"]["ENABLED"].lower() == "true" and match_parent:
+            parent_service = match_parent.group(0)
+            service_list += [parent_service]
+
+        service_list = list(set(service_list))
+        new_service_list = self._exclude_services(
+            dict_args, pipeline_name, service_list
+        )
+
+        print(f"Services to analyze: {new_service_list}")
+        logger.info(f"Services to analyze: {new_service_list}")
+
+        findings = []
+        exclusions = []
+        for service in new_service_list:
+            findings_list, exclusions_list = self._get_all_from_vm(
+                dict_args, secret_tool, remote_config, service
+            )
+            findings += findings_list
+            exclusions += exclusions_list
+
+        result = runner_engine_risk(
+            dict_args,
+            findings,
+            exclusions,
+            self.devops_platform_gateway,
+            self.print_table_gateway,
+        )
+        input_core = InputCore(
+            [],
+            {},
+            "",
+            "",
+            pipeline_name,
+            self.devops_platform_gateway.get_variable("stage").capitalize(),
+        )
+        return result, input_core

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/defect_dojo.py

@@ -10,6 +10,7 @@ from devsecops_engine_tools.engine_utilities.defect_dojo import (
     ImportScanRequest,
     Connect,
     Finding,
+    Engagement,
 )
 from devsecops_engine_tools.engine_core.src.domain.model.exclusions import Exclusions
 from devsecops_engine_tools.engine_core.src.domain.model.report import Report
@@ -18,6 +19,7 @@ from devsecops_engine_tools.engine_core.src.domain.model.customs_exceptions impo
     ExceptionVulnerabilityManagement,
     ExceptionFindingsExcepted,
     ExceptionGettingFindings,
+    ExceptionGettingEngagements
 )
 from devsecops_engine_tools.engine_core.src.infrastructure.helpers.util import (
     format_date,
@@ -247,6 +249,32 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                 "Error getting all findings with the following error: {0} ".format(ex)
             )
 
+    def get_active_engagements(self, engagement_name, dict_args, secret_tool, config_tool):
+        try:
+            request_is = ImportScanRequest(
+                token_defect_dojo=dict_args.get("token_vulnerability_management")
+                or secret_tool.get("token_defect_dojo"),
+                host_defect_dojo=config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"][
+                    "HOST_DEFECT_DOJO"
+                ],
+                engagement_name=engagement_name,
+            )
+
+            request_active = {
+                "name": engagement_name,
+                "limit": config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"][
+                    "LIMITS_QUERY"
+                ],
+                "active": "true",
+            }
+
+            return Engagement.get_engagements(request_is, request_active).results
+
+        except Exception as ex:
+            raise ExceptionGettingEngagements(
+                "Error getting engagements with the following error: {0} ".format(ex)
+            )
+
     def _get_session_manager(self, dict_args, secret_tool, config_tool):
         token_dd = dict_args.get("token_vulnerability_management") or secret_tool.get(
             "token_defect_dojo"

devsecops_engine_tools-1.8.12/devsecops_engine_tools/engine_sast/engine_secret/src/domain/model/gateway/git_gateway.py

@@ -0,0 +1,11 @@
+from abc import ABCMeta, abstractmethod
+
+
+class GitGateway(metaclass=ABCMeta):
+    @abstractmethod
+    def get_files_pull_request(self, sys_working_dir: str,
+                               target_branch: str,
+                               source_branch: str,
+                               message_info_engine_secret: str
+                               ) -> dict:
+        "get_files_pull_request"

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_sast/engine_secret/src/domain/model/gateway/tool_gateway.py

@@ -11,6 +11,5 @@ class ToolGateway(metaclass=ABCMeta):
                             exclude_path: dict,
                             agent_os: str,
                             agent_work_folder: str,
-                            num_threads: int,
-                            repository_name: str) -> str:
+                            num_threads: int) -> str:
         "run tool secret scan"

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_sast/engine_secret/src/domain/usecases/secret_scan.py

@@ -36,20 +36,14 @@ class SecretScan:
             files_pullrequest = self.git_gateway.get_files_pull_request(
                 self.devops_platform_gateway.get_variable("path_directory"),
                 self.devops_platform_gateway.get_variable("target_branch"),
-                config_tool.target_branches,
                 self.devops_platform_gateway.get_variable("source_branch"),
-                self.devops_platform_gateway.get_variable("access_token"),
-                self.devops_platform_gateway.get_variable("organization"),
-                self.devops_platform_gateway.get_variable("project_name"),
-                self.devops_platform_gateway.get_variable("repository"),
-                self.devops_platform_gateway.get_variable("repository_provider"))
+                config_tool.message_info_engine_secret)
             findings, file_path_findings = self.tool_gateway.run_tool_secret_scan(
                     files_pullrequest,
                     config_tool.exclude_path,
                     self.devops_platform_gateway.get_variable("os"),
                     self.devops_platform_gateway.get_variable("path_directory"),
-                    config_tool.number_threads,
-                    self.devops_platform_gateway.get_variable("repository")
+                    config_tool.number_threads
                     )
             finding_list = self.tool_deserialize.get_list_vulnerability(
                 findings,

devsecops_engine_tools-1.8.12/devsecops_engine_tools/engine_sast/engine_secret/src/infrastructure/driven_adapters/git_cli/git_run.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+import os
+import subprocess
+from devsecops_engine_tools.engine_sast.engine_secret.src.domain.model.gateway.git_gateway import GitGateway
+
+from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
+from devsecops_engine_tools.engine_utilities import settings
+
+logger = MyLogger.__call__(**settings.SETTING_LOGGER).get_logger()
+
+@dataclass
+class GitRun(GitGateway):
+
+    def get_files_pull_request(self,
+                               sys_working_dir,
+                               target_branch,
+                               source_branch,
+                               message_info_engine_secret
+                               ):
+        try:
+            source_branch = source_branch.replace("refs/heads/", "")
+            os.chdir(sys_working_dir)
+            subprocess.run(['git', 'checkout', '-b', source_branch, f'origin/{source_branch}'], text=True, capture_output=True, check=True)    
+            env = os.environ.copy()
+            env["GIT_COMMITTER_NAME"] = "Your Name"
+            env["GIT_COMMITTER_EMAIL"] = "your.email@example.com"
+            env["GIT_AUTHOR_NAME"] = "Your Name"
+            env["GIT_AUTHOR_EMAIL"] = "your.email@example.com"
+            command = ["git", "rebase", f"origin/{target_branch}", "-X", "theirs"]
+            subprocess.run(command, env=env, text=True, capture_output=True)
+
+            diff = subprocess.run(['git', 'diff', f'origin/{target_branch}..{source_branch}', '--name-only'], capture_output=True, text=True)
+            if diff.returncode == 0:
+                diff_files = diff.stdout.strip().split("\n")
+                print("Pull Requests Associated Files:",diff_files)
+                return diff_files
+        except subprocess.CalledProcessError as e:
+            raise Exception(f"Error in pipeline configuration, {message_info_engine_secret}") from e
+        except Exception as e:
+            logger.warning(f"Error getting files PullRequest: {e}")
+            return []

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_sast/engine_secret/src/infrastructure/driven_adapters/trufflehog/trufflehog_run.py

@@ -43,8 +43,7 @@ class TrufflehogRun(ToolGateway):
         exclude_paths,
         agent_os,
         agent_work_folder,
-        num_threads,
-        repository_name,
+        num_threads
     ):
         trufflehog_command = "trufflehog"
         if "Windows" in agent_os:
@@ -60,7 +59,6 @@ class TrufflehogRun(ToolGateway):
                 [agent_work_folder] * len(include_paths),
                 [exclude_path] * len(include_paths),
                 include_paths,
-                [repository_name] * len(include_paths),
             )
         findings, file_findings = self.create_file(self.decode_output(results), agent_work_folder)
         return  findings, file_findings
@@ -88,10 +86,9 @@ class TrufflehogRun(ToolGateway):
         trufflehog_command,
         agent_work_folder,
         exclude_path,
-        include_path,
-        repository_name,
+        include_path
     ):
-        command = f"{trufflehog_command} filesystem {agent_work_folder + '/' + repository_name} --include-paths {include_path} --exclude-paths {exclude_path} --no-verification --json"
+        command = f"{trufflehog_command} filesystem {agent_work_folder} --include-paths {include_path} --exclude-paths {exclude_path} --no-verification --json"
         result = subprocess.run(command, capture_output=True, shell=True, text=True)
         return result.stdout.strip()
 

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_utilities/defect_dojo/__init__.py

@@ -3,3 +3,4 @@ from .domain.request_objects.finding import FindingRequest
 from .applications.defect_dojo import DefectDojo
 from .applications.finding import Finding
 from .applications.connect import Connect
+from .applications.engagement import Engagement

devsecops_engine_tools-1.8.12/devsecops_engine_tools/engine_utilities/defect_dojo/applications/engagement.py

@@ -0,0 +1,16 @@
+from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.user_case.engagement import EngagementUserCase
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.engagement import EngagementRestConsumer
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+
+class Engagement:
+    @staticmethod
+    def get_engagements(request_is: ImportScanRequest, request: dict):
+        try:
+            rest_engagement = EngagementRestConsumer(request_is, session=SessionManager())
+
+            uc = EngagementUserCase(rest_engagement)
+            return uc.execute(request)
+        except ApiError as e:
+            raise e

devsecops_engine_tools-1.8.12/devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/engagement.py

@@ -0,0 +1,9 @@
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.engagement import EngagementRestConsumer
+
+class EngagementUserCase:
+    def __init__(self, rest_engagement: EngagementRestConsumer):
+        self.__rest_engagement = rest_engagement
+
+    def execute(self, request):
+        response = self.__rest_engagement.get_engagements_by_request(request)
+        return response

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/engagement.py

@@ -1,9 +1,16 @@
 import json
 from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
 from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
-from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
-from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
-from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.engagement import Engagement, EngagementList
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import (
+    ImportScanRequest,
+)
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import (
+    VERIFY_CERTIFICATE,
+)
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.engagement import (
+    Engagement,
+    EngagementList,
+)
 from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
 from datetime import datetime
 from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
@@ -18,18 +25,37 @@ class EngagementRestConsumer:
         self.__session = session._instance
 
     def get_engagements(self, engagement_name):
-        url = f"{self.__host}/api/v2/engagements/?name={engagement_name}"
+        request = {"name": engagement_name}
+        return self.get_engagements_by_request(request)
 
-        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+    def get_engagements_by_request(self, request):
+        url = f"{self.__host}/api/v2/engagements/"
+        headers = {
+            "Authorization": f"Token {self.__token}",
+            "Content-Type": "application/json",
+        }
         try:
-            response = self.__session.get(url=url, headers=headers, verify=VERIFY_CERTIFICATE)
+            response = self.__session.get(
+                url=url, headers=headers, params=request, verify=VERIFY_CERTIFICATE
+            )
             if response.status_code != 200:
                 logger.error(response.json())
                 raise ApiError(response.json())
-            response = EngagementList().from_dict(response.json())
+            engagements = EngagementList().from_dict(response.json())
+            while response.json().get("next", None):
+                next_url = response.json().get("next")
+                next_url = next_url.replace("http://", "https://", 1)
+                response = self.__session.get(
+                    next_url, headers=headers, data={}, verify=VERIFY_CERTIFICATE
+                )
+                if response.status_code != 200:
+                    raise ApiError(response.json())
+                engagements.results += (
+                    EngagementList().from_dict(response.json()).results
+                )
         except Exception as e:
             raise ApiError(e)
-        return response
+        return engagements
 
     def post_engagement(self, engagement_name, product_id):
         url = f"{self.__host}/api/v2/engagements/"
@@ -43,9 +69,14 @@ class EngagementRestConsumer:
                 "status": "In Progress",
             }
         )
-        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        headers = {
+            "Authorization": f"Token {self.__token}",
+            "Content-Type": "application/json",
+        }
         try:
-            response = self.__session.post(url=url, headers=headers, data=data, verify=VERIFY_CERTIFICATE)
+            response = self.__session.post(
+                url=url, headers=headers, data=data, verify=VERIFY_CERTIFICATE
+            )
             if response.status_code != 201:
                 logger.error(response.json())
                 raise ApiError(response.json())

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/finding.py

@@ -23,6 +23,13 @@ class FindingRestConsumer:
         if response.status_code != 200:
             raise ApiError(response.json())
         findings = FindingList.from_dict(response.json())
+        while response.json().get("next", None):
+            next_url = response.json().get("next")
+            next_url = next_url.replace("http://", "https://", 1)
+            response = self.__session.get(next_url, headers=headers, data={}, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                raise ApiError(response.json())
+            findings.results += FindingList.from_dict(response.json()).results
         return findings
 
     def close(self, request, id):

devsecops_engine_tools-1.8.12/devsecops_engine_tools/version.py

@@ -0,0 +1 @@
+version = '1.8.12'

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.8.10
+Version: 1.8.12
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team

{devsecops_engine_tools-1.8.10 → devsecops_engine_tools-1.8.12}/devsecops_engine_tools.egg-info/SOURCES.txt

@@ -211,6 +211,7 @@ devsecops_engine_tools/engine_utilities/defect_dojo/hello_world.py
 devsecops_engine_tools/engine_utilities/defect_dojo/applications/__init__.py
 devsecops_engine_tools/engine_utilities/defect_dojo/applications/connect.py
 devsecops_engine_tools/engine_utilities/defect_dojo/applications/defect_dojo.py
+devsecops_engine_tools/engine_utilities/defect_dojo/applications/engagement.py
 devsecops_engine_tools/engine_utilities/defect_dojo/applications/finding.py
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/__init__.py
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/__init__.py
@@ -230,6 +231,7 @@ devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/finding.p
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/import_scan.py
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/__init__.py
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/cmdb.py
+devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/engagement.py
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/finding.py
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/import_scan.py
 devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/__init__.py

devsecops_engine_tools-1.8.10/devsecops_engine_tools/engine_core/src/domain/usecases/handle_risk.py

@@ -1,101 +0,0 @@
-from devsecops_engine_tools.engine_core.src.domain.model.gateway.vulnerability_management_gateway import (
-    VulnerabilityManagementGateway,
-)
-from devsecops_engine_tools.engine_core.src.domain.model.gateway.secrets_manager_gateway import (
-    SecretsManagerGateway,
-)
-from devsecops_engine_tools.engine_core.src.domain.model.gateway.devops_platform_gateway import (
-    DevopsPlatformGateway,
-)
-from devsecops_engine_tools.engine_core.src.domain.model.gateway.printer_table_gateway import (
-    PrinterTableGateway,
-)
-from devsecops_engine_tools.engine_risk.src.applications.runner_engine_risk import (
-    runner_engine_risk,
-)
-from devsecops_engine_tools.engine_core.src.domain.model.customs_exceptions import (
-    ExceptionGettingFindings,
-)
-from devsecops_engine_tools.engine_core.src.domain.model.input_core import (
-    InputCore
-)
-
-from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
-from devsecops_engine_tools.engine_utilities import settings
-
-logger = MyLogger.__call__(**settings.SETTING_LOGGER).get_logger()
-
-
-class HandleRisk:
-    def __init__(
-        self,
-        vulnerability_management: VulnerabilityManagementGateway,
-        secrets_manager_gateway: SecretsManagerGateway,
-        devops_platform_gateway: DevopsPlatformGateway,
-        print_table_gateway: PrinterTableGateway,
-    ):
-        self.vulnerability_management = vulnerability_management
-        self.secrets_manager_gateway = secrets_manager_gateway
-        self.devops_platform_gateway = devops_platform_gateway
-        self.print_table_gateway = print_table_gateway
-
-    def _get_all_from_vm(self, dict_args, secret_tool, remote_config, service):
-        try:
-            return self.vulnerability_management.get_all(
-                service,
-                dict_args,
-                secret_tool,
-                remote_config,
-            )
-        except ExceptionGettingFindings as e:
-            logger.error(
-                "Error getting finding list in handle risk: {0}".format(str(e))
-            )
-
-    def process(self, dict_args: any, remote_config: any):
-        secret_tool = None
-        if dict_args["use_secrets_manager"] == "true":
-            secret_tool = self.secrets_manager_gateway.get_secret(remote_config)
-
-        risk_config = self.devops_platform_gateway.get_remote_config(
-            dict_args["remote_config_repo"], "engine_risk/ConfigTool.json"
-        )
-
-        service = self.devops_platform_gateway.get_variable("pipeline_name")
-        parent_identifier = risk_config["PARENT_ANALYSIS"]["PARENT_IDENTIFIER"]
-
-        parent_findings = []
-        parent_exclusions = []
-        if (
-            risk_config["PARENT_ANALYSIS"]["ENABLED"].lower() == "true"
-            and parent_identifier in service
-        ):
-            parent_service = service.split(parent_identifier)[0] + parent_identifier
-            parent_findings, parent_exclusions = self._get_all_from_vm(
-                dict_args, secret_tool, remote_config, parent_service
-            )
-
-        findings, exclusions = self._get_all_from_vm(
-            dict_args, secret_tool, remote_config, service
-        )
-
-        findings_list = parent_findings + findings
-
-        exclusions_list = parent_exclusions + exclusions
-
-        result = runner_engine_risk(
-            dict_args,
-            findings_list,
-            exclusions_list,
-            self.devops_platform_gateway,
-            self.print_table_gateway,
-        )
-        input_core = InputCore(
-            [],
-            {},
-            "",
-            "",
-            service,
-            self.devops_platform_gateway.get_variable("stage").capitalize(),
-        )
-        return result, input_core

devsecops_engine_tools-1.8.10/devsecops_engine_tools/engine_sast/engine_secret/src/domain/model/gateway/git_gateway.py

@@ -1,15 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-
-class GitGateway(metaclass=ABCMeta):
-    @abstractmethod
-    def get_files_pull_request(self, sys_working_dir: str,
-                               target_branch: str,
-                               config_target_branch: dict,
-                               source_branch: str,
-                               access_token: str,
-                               collection_uri: str,
-                               team_project: str,
-                               repository_name: str,
-                               repository_provider: str) -> dict:
-        "get_files_pull_request"