devsecops-engine-tools 1.8.9__tar.gz → 1.8.11__tar.gz

{devsecops_engine_tools-1.8.9 → devsecops_engine_tools-1.8.11}/PKG-INFO

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

{devsecops_engine_tools-1.8.9 → devsecops_engine_tools-1.8.11}/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.9 → devsecops_engine_tools-1.8.11}/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.11/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.9 → devsecops_engine_tools-1.8.11}/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.9 → devsecops_engine_tools-1.8.11}/devsecops_engine_tools/engine_sca/engine_container/src/infrastructure/driven_adapters/prisma_cloud/prisma_deserialize_output.py

@@ -30,6 +30,9 @@ class PrismaDeserealizator(DeseralizatorGateway):
             image_object = file.read()
 
             json_data = json.loads(image_object)
+            console_url = json_data.get("consoleURL",False)
+            if console_url:
+                print(f"Console URL: {console_url}")
             vulnerabilities_data = (
                 json_data["results"][0]["vulnerabilities"]
                 if "vulnerabilities" in json_data["results"][0]

{devsecops_engine_tools-1.8.9 → devsecops_engine_tools-1.8.11}/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.11/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.11/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.9 → devsecops_engine_tools-1.8.11}/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.9 → devsecops_engine_tools-1.8.11}/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.11/devsecops_engine_tools/version.py

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

{devsecops_engine_tools-1.8.9 → devsecops_engine_tools-1.8.11}/devsecops_engine_tools.egg-info/PKG-INFO

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

{devsecops_engine_tools-1.8.9 → devsecops_engine_tools-1.8.11}/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.9/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.9/devsecops_engine_tools/version.py

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